pooltool.objects¶
Simulation object classes¶
The three main simulation objects are pooltool.objects.ball.datatypes.Ball
,
pooltool.objects.cue.datatypes.Cue
, and
pooltool.objects.table.datatypes.Table
, however there are many more objects
that either help create the primary objects or comprise the primary objects. Those are
all kept in this module.
Overview¶
A billiards ball |
|
A container of BallState objects |
|
Stores a ball’s rendered BallOrientation |
|
Ball parameters and physical constants |
|
Holds a ball’s state |
|
A ballset |
|
A cue stick |
|
Cue stick specifications |
|
A circular cushion segment defined by a circle center and radius |
|
An Enum for the direction of a cushion |
|
A collection of cushion segments |
|
A linear cushion segment defined by the line between points p1 and p2 |
|
A circular pocket |
|
A table. |
|
Parameter specifications for a billiards (pocketless) table. |
|
Parameter specifications for a pocket table. |
|
Parameter specifications for a snooker table. |
|
A table model specifier |
|
An Enum describing the table type |
|
Return the ballset with the given name. |
Classes¶
- class pooltool.objects.Ball(id: str, state: BallState = BallState.default, params: BallParams = BallParams.default, ballset: BallSet | None = None, initial_orientation: BallOrientation = BallOrientation.random, history: BallHistory = BallHistory.factory, history_cts: BallHistory = BallHistory.factory)[source]¶
A billiards ball
This class represents a billiards ball. It stores its parameters (mass, radius, etc.), it’s state (coordinates, velocity, spin, etc), its history (a time-resolved trajectory of its state), amongst other things.
- state¶
The ball’s state.
This is the current state of the ball.
See also
See the Important section in
Ball
for a description of the role ofstates
during simulation.
- params¶
The ball’s physical parameters.
The physical parameters of the ball.
- ballset¶
The ball set that the ball belongs to.
Important if rendering the ball in a scene.
See also
See
Ball.set_ballset()
for details
- Type:
- initial_orientation¶
The initial rendered orientation of the ball.
Important if rendering the ball in a scene.
This is the orientation of the ball at \(t = 0\).
- history¶
The ball’s state history
The historical states of the ball from \(t_{initial}\) to \(t_{final}\).
See also
See the Important section in
Ball
for a description of the role ofhistory
during simulation.
- history_cts¶
The ball’s continuous state history
The historical states of the ball from \(t_{initial}\) to \(t_{final}\) densely sampled with respect to time.
See also
See
pooltool.evolution.event_based.continuize.continuize()
for a details about continuizing a simulated system.See the Important section in
Ball
for a description of the role ofhistory_cts
during simulation.
Important
To instantiate this class, consider using the
create()
constructor. Or, use functions withinpooltool.layouts
to generate entire collection of balls. Or, of course, construct as normal with__init__
.Important
The following explains how a
Ball
object is modified when its parent system is simulated (pooltool.evolution.event_based.simulate.simulate()
).At the start of the simulation process,
state
represents the ball state at \(t = 0\). A copy ofstate
is appended tohistory
.For each timestep of the simulation,
state
is used to inform how the system should advance forward in time. Once determined,state
is updated to reflect the ball’s new state. A copy ofstate
is appended tohistory
.When the simulation is finished,
state
represents the final resting state of the ball. So too doeshistory[-1]
.Finally, if the system is continuized (see
pooltool.evolution.continuize.continuize()
),history_cts
is populated. Otherwise it remains empty.- property xyz¶
The displacement (from origin) vector of the ball.
A shortcut for
self.state.rvw[0]
.
- property vel¶
The velocity vector of the ball.
A shortcut for
self.state.rvw[1]
.
- property avel¶
The angular velocity vector of the ball.
A shortcut for
self.state.rvw[2]
.
Methods:
- set_ballset(ballset: pooltool.objects.ball.sets.BallSet) None [source]¶
Update the ballset
- Raises:
ValueError -- If the ball ID doesn’t match to a model name of the ballset.
See also
See
pooltool.objects.ball.sets
for details about ball sets.See
pooltool.system.datatypes.System.set_ballset()
for setting the ballset for all the balls in a system.
- copy(drop_history: bool = False) Ball [source]¶
Create a copy
- Parameters:
drop_history (bool) -- If True, the returned copy
history
andhistory_cts
attributes are both set to emptyBallHistory
objects.- Return type:
- static create(id: str, *, xy: Sequence[float] | None = None, ballset: pooltool.objects.ball.sets.BallSet | None = None, **kwargs) Ball [source]¶
Create a ball using keyword arguments.
This constructor flattens the tunable parameter space, allowing one to construct a
Ball
without directly instancing objects like likepooltool.objects.balls.params.BallParams
andBallState
.- Parameters:
xy (Optional[Sequence[float]]) -- The x and y coordinates of the ball position.
ballset (Optional[pooltool.objects.ball.sets.BallSet]) -- A ballset.
**kwargs -- Arguments accepted by
pooltool.objects.balls.params.BallParams
- Return type:
- class pooltool.objects.BallHistory(states: List[BallState] = UNKNOWN)[source]¶
A container of BallState objects
- states¶
A list of time-increasing BallState objects (default =
[]
).- Type:
Methods:
- add(state: BallState) None [source]¶
Append a state to the history
- Raises:
AssertionError -- If
state.t < self.states[-1]
Notes
This appends
state
tostates
state
is not copied before appending to the history, so they share the same memory address.
- copy() BallHistory [source]¶
Create a copy
- Return type:
- vectorize() Tuple[numpy.typing.NDArray[numpy.float64], numpy.typing.NDArray[numpy.float64], numpy.typing.NDArray[numpy.float64]] | None [source]¶
Compile the attribute from each ball state into arrays
This method unzips each
BallState
instates
, resulting in an array ofBallState.rvw
values, an array ofBallState.s
values, and an array ofBallState.t
values.The vectors have the following properties:
>>> import pooltool as pt >>> history = pt.simulate(pt.System.example(), continuous=True).balls["cue"].history_cts >>> rvws, ss, ts = history.vectorize() >>> # Their lengths are equal to the BallHistory >>> len(rvws) == len(ss) == len(ts) == len(history) True >>> # The indices of the arrays match the values of the history >>> pt.objects.BallState(rvws[26], ss[26], ts[26]) == history[26] True
- Returns:
A length 3 tuple (
rvws
,ss
andts
). Returns None ifself
has no length.- Return type:
Optional[Tuple[numpy.typing.NDArray[numpy.float64], numpy.typing.NDArray[numpy.float64], numpy.typing.NDArray[numpy.float64]]]
Example
vectorize
can be useful for plotting trajectories.import pooltool as pt import matplotlib.pyplot as plt system = pt.System.example() pt.simulate(system, continuous=True, inplace=True) for ball in system.balls.values(): rvw, ss, ts = ball.history_cts.vectorize() plt.plot(rvw[:, 0, 0], rvw[:, 0, 1], color=ss) plt.show()
See also
- static from_vectorization(vectorization: Tuple[numpy.typing.NDArray[numpy.float64], numpy.typing.NDArray[numpy.float64], numpy.typing.NDArray[numpy.float64]] | None) BallHistory [source]¶
Zips a vectorization into a BallHistory
An inverse method of
vectorize()
.- Returns:
A BallHistory constructed from the input vectors.
- Return type:
Example
This illustrates a round-trip with
vectorize()
andfrom_vectorization()
.First create history
>>> import pooltool as pt >>> history = pt.simulate(pt.System.example(), continuous=True).balls["cue"].history_cts
Illustrate a lossless round trip:
>>> pt.objects.BallHistory.from_vectorization(history.vectorize()) == history True
See also
- class pooltool.objects.BallOrientation(pos: Tuple[float, float, float, float], sphere: Tuple[float, float, float, float])[source]¶
Stores a ball’s rendered BallOrientation
From a practical standpoint, what needs to be understood about this class is that its attributes uniquely specify a ball’s rendered orientation. Less practically, but more specifically, these attributes correspond to the nodes, ‘pos’ and ‘sphere’, that make up a ball’s visual rendering.
Methods:
- static random() BallOrientation [source]¶
Generate a random BallOrientation
This generates a ball orientation from a uniform sampling of possible orientations.
- Returns:
A randomized ball orientation.
- Return type:
- copy() BallOrientation [source]¶
Create a copy
Note
Since the class is frozen and its attributes are immutable, this just returns
self
.
- Return type:
- class pooltool.objects.BallParams(m: float = 0.170097, R: float = 0.028575, u_s: float = 0.2, u_r: float = 0.01, u_sp_proportionality: float = 0.4444444444444444, e_c: float = 0.85, f_c: float = 0.2, g: float = 9.81)[source]¶
Ball parameters and physical constants
- u_sp_proportionality¶
The spinning coefficient of friction, with R factored out (default = 0.01).
See also
For the coefficient of spinning friction, use the property
u_sp()
.
- Type:
- e_c¶
The cushion coefficient of restitution (default = 0.85).
Note
This is a potentially model-dependent ball-cushion parameter and should be placed elsewhere, either as a model parameter or as a cushion segment parameter.
- Type:
- f_c¶
The cushion coefficient of friction (default = 0.2).
Note
This is a potentially model-dependent ball-cushion parameter and should be placed elsewhere, either as a model parameter or as a cushion segment parameter.
- Type:
Most of the default values (SI units) are taken from or based off of https://billiards.colostate.edu/faq/physics/physical-properties/.
Some of the parameters aren’t truly ball parameters, e.g. the gravitational constant. However, it is nice to be able to tune such parameters on a ball-by-ball basis, so they are included here.
Methods:
- u_sp() float ¶
Coefficient of spinning friction
This is equal to
u_sp_proportionality
*R
Cached Property Note
This is a cached property, and should be accessed as an attribute, not as a method call.
- Return type:
- copy() BallParams [source]¶
Return a copy
Note
Since the class is frozen and its attributes are immutable, this just returns
self
.
- Return type:
- classmethod default(game_type: pooltool.game.datatypes.GameType = GameType.EIGHTBALL) BallParams [source]¶
Return prebuilt ball parameters based on game type
- Parameters:
game_type (pooltool.game.datatypes.GameType) -- What type of game is being played?
- Returns:
The prebuilt ball parameters associated with the passed game type.
- Return type:
- classmethod prebuilt(name: PrebuiltBallParams) BallParams [source]¶
Return prebuilt ball parameters based on name
- Parameters:
name (PrebuiltBallParams) -- A
PrebuiltBallParams
member.- Return type:
All prebuilt ball parameters are named with the
PrebuiltBallParams
Enum. This constructor takes a prebuilt name and returns the corresponding ball parameters.See also
PrebuiltBallParams
- class pooltool.objects.BallState(rvw: ndarray[Any, dtype[float64]], s, t=0)[source]¶
Holds a ball’s state
The ball’s state is defined (1) the kinematic state of the ball, (2) a label specifying the ball’s motion state, and (3) the point in time that the ball exists in.
- rvw¶
The kinematic state of the ball.
rvw
is a \(3\times3\) matrix that stores the 3 vectors that characterize a ball’s kinematic state:\(r\): The displacement (from origin) vector (accessed with
rvw[0]
)\(v\): The velocity vector (accessed with
rvw[1]
)\(w\): The angular velocity vector (accessed with
rvw[2]
)
- Type:
numpy.ndarray[Any, numpy.dtype[numpy.float64]]
- s¶
The motion state label of the ball.
s
is an integer corresponding to the following motion state labels:0 = stationary 1 = spinning 2 = sliding 3 = rolling 4 = pocketed
- Type:
Methods:
- class pooltool.objects.BallSet(name: str)[source]¶
A ballset
- name¶
The name of the ballset.
During instantiation, the validity of this name will be checked, and a ValueError will be raised if the ballset doesn’t exist.
- Type:
- property path: pathlib.Path¶
The path of the ballset directory
This directory holds the ball models.
- Return type:
Methods:
- ball_path(id: str) pathlib.Path [source]¶
The model path used for a given ball ID
- Parameters:
id (str) -- The ball ID.
- Raises:
ValueError -- If Ball ID doesn’t match to the ballset.
- Returns:
The model path.
- Return type:
Path
- class pooltool.objects.Cue(id: str = 'cue_stick', V0: float = 2.0, phi: float = 0.0, theta: float = 0.0, a: float = 0.0, b: float = 0.25, cue_ball_id: str = 'cue', specs: CueSpecs = CueSpecs.default)[source]¶
A cue stick
- V0¶
The impact speed.
Units are m/s.
Warning: This is the speed of the cue stick upon impact, not the speed of the ball upon impact.
- Type:
- phi¶
The directional strike angle.
The horizontal direction of the cue’s orientation relative to the table layout. Specified in degrees.
If you imagine facing from the head rail (where the cue is positioned for a break shot) towards the foot rail (where the balls are racked),
\(\phi = 0\) corresponds to striking the cue ball to the right
\(\phi = 90\) corresponds to striking the cue ball towards the foot rail
\(\phi = 180\) corresponds to striking the cue ball to the left
\(\phi = 270\) corresponds to striking the cue ball towards the head rail
\(\phi = 360\) corresponds to striking the cue ball to the right
- Type:
- theta¶
The cue inclination angle.
The vertical angle of the cue stick relative to the table surface. Specified in degrees.
\(\theta = 0\) corresponds to striking the cue ball parallel with the table (no massé)
\(\theta = 90\) corresponds to striking the cue ball downwards into the table (max massé)
- Type:
- a¶
The amount and direction of side spin.
\(a = -1\) is the rightmost side of ball
\(a = +1\) is the leftmost side of the ball
- Type:
- b¶
The amount of top/bottom spin.
\(b = -1\) is the bottom-most side of the ball
\(b = +1\) is the top-most side of the ball
- Type:
- specs¶
The cue specs.
Methods:
- copy() Cue [source]¶
Create a copy
Note
specs
is shared betweenself
and the copy, but that’s ok because it’s frozen and has no mutable attributes.- Return type:
- set_state(V0: float | None = None, phi: float | None = None, theta: float | None = None, a: float | None = None, b: float | None = None, cue_ball_id: str | None = None) None [source]¶
Set the cueing parameters
- Parameters:
If any arguments are
None
, they will be left untouched--they will not be set to None.
- class pooltool.objects.CueSpecs(brand: str = 'Predator', M: float = 0.567, length: float = 1.4732, tip_radius: float = 0.007, butt_radius: float = 0.02)[source]¶
Cue stick specifications
All units are SI.
Methods:
- class pooltool.objects.CircularCushionSegment(id: str, center: ndarray[Any, dtype[float64]], radius: float)[source]¶
A circular cushion segment defined by a circle center and radius
- center¶
A length-3 array specifying the circular cushion’s center.
center[0]
,center[1]
, andcenter[2]
are the x-, y-, and z-coordinates of the cushion’s center. The circle is assumed to be parallel to the XY plane, which makescenter[2]
is the height of the cushion.- Type:
numpy.ndarray[Any, numpy.dtype[numpy.float64]]
Methods:
- height() float ¶
The height of the cushion
Cached Property Note
This is a cached property, and should be accessed as an attribute, not as a method call.
- Return type:
- a() float ¶
The x-coordinate of the cushion’s center
Cached Property Note
This is a cached property, and should be accessed as an attribute, not as a method call.
- Return type:
- b() float ¶
The y-coordinate of the cushion’s center
Cached Property Note
This is a cached property, and should be accessed as an attribute, not as a method call.
- Return type:
- get_normal(rvw: numpy.typing.NDArray[numpy.float64]) numpy.typing.NDArray[numpy.float64] [source]¶
Calculates the normal vector for a ball contacting the cushion
Assumes that the ball is in fact in contact with the cushion.
- Parameters:
rvw (numpy.typing.NDArray[numpy.float64]) -- The kinematic state vectors of the contacting ball (see
- Return type:
numpy.typing.NDArray[numpy.float64]
:param
pooltool.objects.ball.datatypes.BallState.rvw
).:- Returns:
The normal vector, with the z-component set to 0.
- Return type:
NDArray[np.float64]
- copy() CircularCushionSegment [source]¶
Create a copy
- Return type:
- class pooltool.objects.CushionDirection[source]¶
An Enum for the direction of a cushion
Important for constructing cushions if simulation performance speed is required.
For most table geometries, the playing surface only exists on one side of the cushion, so collisions only need to be checked for one direction. This direction can be specified with this class’s attributes.
- SIDE1¶
Use side 1.
- SIDE2¶
Use side 2.
- BOTH¶
Use sides 1 and 2.
Unfortunately, the rule governing whether to use
SIDE1
orSIDE2
is not clear and instead requires experimentation.If
BOTH
is used, both collision checks are performed which makes collision checks twice as slow.Note
This used to inherit from
Enum
, but accessing the cushion direction inget_next_ball_linear_cushion_collision
somehow took up 20% of the functions runtime so I removed it.
- class pooltool.objects.CushionSegments(linear: Dict[str, LinearCushionSegment], circular: Dict[str, CircularCushionSegment])[source]¶
A collection of cushion segments
Cushion segments can be either linear (see
LinearCushionSegment
) or circular (seeCircularCushionSegment
). This class stores both.- linear¶
A dictionary of linear cushion segments.
Warning
Keys must match the value IDs, e.g.
{"2": LinearCushionSegment(id="2", ...)}
- circular¶
A dictionary of circular cushion segments.
Warning
Keys must match the value IDs, e.g.
{"2t": CircularCushionSegment(id="2t", ...)}
Methods:
- copy() CushionSegments [source]¶
Create a copy
- Return type:
- class pooltool.objects.LinearCushionSegment(id: str, p1: ndarray[Any, dtype[float64]], p2: ndarray[Any, dtype[float64]], direction: int = 2)[source]¶
A linear cushion segment defined by the line between points p1 and p2
- p1¶
The 3D coordinate where the cushion segment starts.
Note
p1 and p2 must share the same height (
p1[2] == p2[2]
).
- Type:
numpy.ndarray[Any, numpy.dtype[numpy.float64]]
- p2¶
The 3D coordinate where the cushion segment ends.
Note
p1 and p2 must share the same height (
p1[2] == p2[2]
).
- Type:
numpy.ndarray[Any, numpy.dtype[numpy.float64]]
- direction¶
The cushion direction (default =
CushionDirection.BOTH
).See
CushionDirection
for explanation.- Type:
Methods:
- height() float ¶
The height of the cushion
Cached Property Note
This is a cached property, and should be accessed as an attribute, not as a method call.
- Return type:
- lx() float ¶
The x-coefficient (\(l_x\)) of the cushion’s 2D general form line equation
Cached Property Note
This is a cached property, and should be accessed as an attribute, not as a method call.
The cushion’s general form line equation in the \(XY\) plane (i.e. dismissing the z-component) is
\[l_x x + l_y y + l_0 = 0\]where
\[\begin{split}\begin{align*} l_x &= -\frac{p_{2y} - p_{1y}}{p_{2x} - p_{1x}} \\ l_y &= 1 \\ l_0 &= \frac{p_{2y} - p_{1y}}{p_{2x} - p_{1x}} p_{1x} - p_{1y} \\ \end{align*}\end{split}\]- Return type:
- ly() float ¶
The x-coefficient (\(l_y\)) of the cushion’s 2D general form line equation
See
lx()
for definition.Cached Property Note
This is a cached property, and should be accessed as an attribute, not as a method call.
- Return type:
- l0() float ¶
The constant term (\(l_0\)) of the cushion’s 2D general form line equation
See
lx()
for definition.Cached Property Note
This is a cached property, and should be accessed as an attribute, not as a method call.
- Return type:
- normal() numpy.typing.NDArray[numpy.float64] ¶
The line’s normal vector, with the z-component set to 0.
Warning
The returned normal vector is arbitrarily directed, meaning it may point away from the table surface, rather than towards it. This nonideality is properly handled in downstream simulation logic, however if you’re using this method for custom purposes, you may want to reverse the direction of this vector by negating it.
- Return type:
numpy.typing.NDArray[numpy.float64]
- get_normal(rvw: numpy.typing.NDArray[numpy.float64]) numpy.typing.NDArray[numpy.float64] [source]¶
Calculates the normal vector
Warning
The returned normal vector is arbitrarily directed, meaning it may point away from the table surface, rather than towards it. This nonideality is properly handled in downstream simulation logic, however if you’re using this method for custom purposes, you may want to reverse the direction of this vector by negating it.
- Parameters:
rvw (numpy.typing.NDArray[numpy.float64]) --
The kinematic state vectors of the contacting balls.
See
rvw
parameter ofpooltool.objects.ball.datatypes.BallState
.- Returns:
The line’s normal vector, with the z-component set to 0.
- Return type:
NDArray[np.float64]
Note
This method only exists for call signature parity with
CircularCushionSegment.get_normal()
. Consider usingnormal()
instead.
- copy() LinearCushionSegment [source]¶
Create a copy
- Return type:
- class pooltool.objects.Pocket(id: str, center: ndarray[Any, dtype[float64]], radius: float, depth: float = 0.08, contains: set = UNKNOWN)[source]¶
A circular pocket
- center¶
A length-3 array specifying the pocket’s position.
center[0]
is the x-coordinate of the pocket’s centercenter[1]
is the y-coordinate of the pocket’s centercenter[2]
must be 0.0
- Type:
numpy.ndarray[Any, numpy.dtype[numpy.float64]]
Methods:
- a() float ¶
The x-coordinate of the pocket’s center
Cached Property Note
This is a cached property, and should be accessed as an attribute, not as a method call.
- Return type:
- b() float ¶
The y-coordinate of the pocket’s center
Cached Property Note
This is a cached property, and should be accessed as an attribute, not as a method call.
- Return type:
- class pooltool.objects.Table(cushion_segments: CushionSegments, pockets: Dict[str, Pocket], table_type: TableType, model_descr: TableModelDescr | None = None, height: float = 0.708, lights_height: float = 1.99)[source]¶
A table.
While a table can be constructed by passing all of the following initialization parameters, there are many easier ways, all of which are detailed in the Table Specification </resources/table_specs> resource.
- cushion_segments¶
The table’s linear and circular cushion segments.
- pockets¶
The table’s pockets.
- Type:
- table_type¶
An Enum specifying the type of table.
- height¶
The height of the playing surface (measured from the ground).
This is just used for visualization.
- Type:
- lights_height¶
The height of the table lights (measured from the playing surface).
This is just used for visualization.
- Type:
- property w: float¶
The width of the table.
Warning
This assumes the table follows the layout similar to this diagram. Specifically, it must have the linear cushion segments with IDs
"3"`
and"12"
.- Return type:
- property l: float¶
The length of the table.
Warning
This assumes the table follows the layout similar to this diagram. Specifically, it must have the linear cushion segments with IDs
"9"`
and"18"
.- Return type:
Methods:
- static from_table_specs(specs: pooltool.objects.table.specs.TableSpecs) Table [source]¶
Build a table from a table specifications object
- Parameters:
specs (pooltool.objects.table.specs.TableSpecs) --
A valid table specification.
- Returns:
A table matching the specifications of the input.
pooltool.objects.table.specs.PocketTableSpecs
hastable_type
set to pooltool.objects.table.specs.TableType.POCKETpooltool.objects.table.specs.BilliardTableSpecs
hastable_type
set to pooltool.objects.table.specs.TableType.BILLIARDpooltool.objects.table.specs.SnookerTableSpecs
hastable_type
set to pooltool.objects.table.specs.TableType.SNOOKER
- Return type:
- classmethod prebuilt(name: pooltool.objects.table.collection.TableName) Table [source]¶
Create a default table based on name
- Parameters:
name (pooltool.objects.table.collection.TableName) -- The name of the prebuilt table specs.
- Returns:
A prebuilt table.
- Return type:
- classmethod default(table_type: pooltool.objects.table.specs.TableType = TableType.POCKET) Table [source]¶
Create a default table based on table type
A default table is associated to each table type.
- Parameters:
table_type (pooltool.objects.table.specs.TableType) -- The type of table.
- Returns:
The default table for the given table type.
- Return type:
- classmethod from_game_type(game_type: pooltool.game.datatypes.GameType) Table [source]¶
Create a default table based on table type
A default table is associated with each game type.
- Parameters:
game_type (pooltool.game.datatypes.GameType) -- The game type.
- Returns:
The default table for the given game type.
- Return type:
- class pooltool.objects.BilliardTableSpecs(l: float = 3.05, w: float = 1.525, cushion_width: float = 0.0508, cushion_height: float = 0.036576, height: float = 0.708, lights_height: float = 1.99, model_descr: TableModelDescr = TableModelDescr.null)[source]¶
Parameter specifications for a billiards (pocketless) table.
See also
See the Table Specification resource for visualizations and descriptions of each attribute.
See
PocketTableSpecs
for billiard table specs.See
SnookerTableSpecs
for pocket table specs.
- class pooltool.objects.PocketTableSpecs(l: float = 1.9812, w: float = 0.9906, cushion_width: float = 0.0508, cushion_height: float = 0.036576, corner_pocket_width: float = 0.118, corner_pocket_angle: float = 5.3, corner_pocket_depth: float = 0.0398, corner_pocket_radius: float = 0.062, corner_jaw_radius: float = 0.02095, side_pocket_width: float = 0.137, side_pocket_angle: float = 7.14, side_pocket_depth: float = 0.00437, side_pocket_radius: float = 0.0645, side_jaw_radius: float = 0.00795, height: float = 0.708, lights_height: float = 1.99, model_descr: TableModelDescr = TableModelDescr.null)[source]¶
Parameter specifications for a pocket table.
See also
See the Table Specification resource for visualizations and descriptions of each attribute.
See
BilliardTableSpecs
for billiard table specs.See
SnookerTableSpecs
for pocket table specs.
- class pooltool.objects.SnookerTableSpecs(l: float = 3.5445, w: float = 1.7465, cushion_width: float = 0.039369999999999995, cushion_height: float = 0.028, corner_pocket_width: float = 0.083, corner_pocket_angle: float = 0, corner_pocket_depth: float = 0.036, corner_pocket_radius: float = 0.1016, corner_jaw_radius: float = 0.1016, side_pocket_width: float = 0.087, side_pocket_angle: float = 0, side_pocket_depth: float = 0.02413, side_pocket_radius: float = 0.042671999999999995, side_jaw_radius: float = 0.0635, height: float = 0.708, lights_height: float = 1.99, model_descr: TableModelDescr = TableModelDescr.null)[source]¶
Parameter specifications for a snooker table.
See also
See the Table Specification resource for visualizations and descriptions of each attribute.
See
BilliardTableSpecs
for billiard table specs.See
PocketTableSpecs
for pocket table specs.
Note
Currently, this class is an identical clone of
PocketTableSpecs
, but with different defaults. That’s not very useful, but it’s likely that some time in the future, snooker tables may have some parameters distinct from standard pool tables (e.g. directional cloth), causing these classes to diverge.
- class pooltool.objects.TableModelDescr(name: str)[source]¶
A table model specifier
- property path: str¶
The path of the model
The path is searched for in
pooltool/models/table/{name}/{name}[_pbr].glb
. If physical based rendering (PBR) is requested, a model suffixed with _pbr will be looked for.- Raises:
ConfigError -- If model path cannot be found from name.
- Returns:
A filename specified with Panda3D filename syntax (see https://docs.panda3d.org/1.10/python/programming/advanced-loading/filename-syntax).
- Return type:
Functions¶
- pooltool.objects.get_ballset(name: str) BallSet [source]¶
Return the ballset with the given name.
- Parameters:
name (str) -- The name of the ballset. To list available ballset names, call
get_ballset_names()
.- Raises:
ValueError -- If Ball ID doesn’t match to the ballset.
- Returns:
A ballset.
- Return type: