viktor.geometry
VisualisationError
- exception
viktor.geometry.
VisualisationError
¶ Bases:
Exception
Vector
- class
viktor.geometry.
Vector
(x, y, z=0)¶ -
A 3-dimensional vector in space.
The following operations are supported:
Negation
v1 = Vector(1, 2, 3) v2 = -v1 # results in Vector(-1, -2, -3)
Addition
v1 = Vector(1, 2, 3) v2 = Vector(1, 2, 3) v3 = v1 + v2 # results in Vector(2, 4, 6)
Subtraction
v1 = Vector(1, 2, 3) v2 = Vector(1, 2, 3) v3 = v1 - v2 # results in Vector(0, 0, 0)
(reverse) Multiplication
v1 = Vector(1, 2, 3) v2 = v1 * 3 # results in Vector(3, 6, 9) v3 = 3 * v1 # results in Vector(3, 6, 9)
Dot product
v1 = Vector(1, 2, 3) v2 = Vector(1, 2, 3) res = v1.dot(v2) # results in 14
Cross product
v1 = Vector(1, 0, 0) v2 = Vector(0, 1, 0) v3 = v1.cross(v2) # results in Vector(0, 0, 1)
- Parameters
x (
float
) – X-coordinate.y (
float
) – Y-coordinate.z (
float
) – Z-coordinate (default: 0).
- property
squared_magnitude
¶ Vector magnitude without square root; faster than magnitude.
- Return type
float
- property
magnitude
¶ Magnitude of the Vector.
- Return type
float
- property
coordinates
¶ Coordinates of the Vector as tuple (X, Y, Z).
- Return type
Tuple
[float
,float
,float
]
-
normalize
()¶ Return the normalized vector (with unit-length).
- Raises
ValueError – if vector is a null-vector.
- Return type
Material
- class
viktor.geometry.
Material
(name, density=None, price=None, *, threejs_type='MeshStandardMaterial', threejs_roughness=0.7, threejs_metalness=0.8, threejs_opacity=1.0, color=Color(221, 221, 221))¶ -
- Parameters
name (
str
) –density (
Optional
[float
]) –price (
Optional
[float
]) –color (
Color
) –threejs_type (
str
) –threejs_roughness (
float
) – Between 0 - 1 where closer to 1 gives the material a rough texture.threejs_metalness (
float
) – Between 0 - 1 where closer to 1 gives the material a shiny metal look.threejs_opacity (
float
) – Between 0 - 1 where closer to 0 makes the material less visible.
- property
name
¶ - Return type
str
- property
density
¶ - Return type
Optional
[float
]
- property
price
¶ - Return type
Optional
[float
]
TransformableObject
- class
viktor.geometry.
TransformableObject
¶ Bases:
abc.ABC
-
translate
(translation_vector)¶ Translate an object along a translation vector.
- Parameters
translation_vector (
Union
[Vector
,Tuple
[float
,float
,float
]]) – Vector along which translation is to be performed.
-
rotate
(angle, direction, point=None)¶ Rotate an object along an axis (direction) by an angle. Direction will follow right hand rule.
-
mirror
(point, normal)¶ Mirror an object on a plane defined by a point and normal vector.
-
Group
- class
viktor.geometry.
Group
(objects)¶ Bases:
viktor.geometry.TransformableObject
- Parameters
objects (
List
[TransformableObject
]) – Objects that are part of the group.
-
add
(objects)¶
- property
children
¶ - Return type
List
[TransformableObject
]
-
duplicate
()¶
Point
- class
viktor.geometry.
Point
(x, y, z=0)¶ -
This class represents a point object, which is instantiated by means of 3-dimensional coordinates X, Y, and Z. It forms a basis of many structural 2D and 3D objects.
Example usage:
p1 = Point(0, 0) # creates a point in the origin p2 = Point(1, 2, 3) p3 = p2.copy()
- Parameters
x (
float
) – X-coordinate.y (
float
) – Y-coordinate.z (
float
) – (optional) Z-coordinate, defaults to 0.
- Raises
TypeError – if the point is instantiated with a None value.
- property
coordinates
¶ Coordinates of the Point as array (X, Y, Z).
- property
x
¶ Returns the X-coordinate.
- Return type
float
- property
y
¶ Returns the Y-coordinate.
- Return type
float
- property
z
¶ Returns the Z-coordinate.
- Return type
float
-
coincides_with
(other)¶ Given another Point object, this method determines whether the two points coincide.
- Return type
bool
-
get_local_coordinates
(local_origin, spherical=False)¶ Method to determine the local coordinates of the current Point with respect to a ‘local origin’.
- Return type
ndarray
Line
- class
viktor.geometry.
Line
(start_point, end_point)¶ -
- property
length
¶ - Return type
float
-
collinear
(point)¶ True if point is collinear (in line) with Line, else False.
- Return type
bool
- property
length_vector
¶
- property
unit_vector
¶
- property
geometries
¶
- property
horizontal
¶ - Return type
bool
- property
vertical
¶ - Return type
bool
-
discretize
(num=2)¶
-
revolve
(*, material=None, **kwargs)¶ Revolve line around y-axis, only possible for lines in x-y plane.
- Parameters
material (
Optional
[Material
]) – optional material- Raises
NotImplementedError – when line is not in x-y plane
- Return type
-
get_line_function_parameters
()¶ Get parameters for y=ax+b definition of a line
- Return type
Tuple
[float
,float
]- Returns
(a,b) (or nan if line is vertical)
-
find_overlap
(other, inclusive=False)¶ Find the overlapping part of this line with another line.
The returned value depends on the situation:
None, if no overlap is found or the two lines are not parallel
Point, if an overlap is found with length equal to 0
Line, if an overlap is found with length larger than 0
- property
calculate_intersection_bounded_line_with_y
-
viktor.geometry.
calculate_intersection_bounded_line_with_y
(line, y_intersection)¶ Calculate x intersection between two points and y value. Return None if no intersection is found.
Returns x: Returns None: o / y-----/--- y--------- /: o / : / o x o
- Parameters
line (
Line
) – Line object.y_intersection (
float
) – y-value of the intersection line.
- Return type
Optional
[float
]
calculate_intersection_extended_line_with_y
-
viktor.geometry.
calculate_intersection_extended_line_with_y
(line, y_intersection)¶ Calculates the intersection x value of a line at a given y value.
Returns x: Returns x: o / y-----/--- y---------- /: o: / : / : o x o x
- Parameters
line (
Line
) – Line object.y_intersection (
float
) – y-value of the intersection line.
- Return type
float
line_is_horizontal
-
viktor.geometry.
line_is_horizontal
(line)¶ Returns True if line is horizontal.
- Return type
bool
line_is_vertical
-
viktor.geometry.
line_is_vertical
(line)¶ Returns True if line is vertical.
- Return type
bool
x_between_bounds
-
viktor.geometry.
x_between_bounds
(x, x1, x2, inclusive=True)¶ Method checks whether the x value is between the bounds x1 and x2.
- Parameters
x (
float
) – x-value to be evaluated.x1 (
float
) – Lower bound.x2 (
float
) – Upper bound.inclusive (
bool
) – If set to True, this method will also return True when the x value is equal to either x1 or x2.
- Return type
bool
y_between_bounds
-
viktor.geometry.
y_between_bounds
(y, y1, y2, inclusive=True)¶ Method checks whether the y value is between the bounds y1 and y2.
- Parameters
y (
float
) – y-value to be evaluated.y1 (
float
) – Lower bound.y2 (
float
) – Upper bound.inclusive (
bool
) – If set to True, this method will also return True when the y value is equal to either y1 or y2.
- Return type
bool
point_is_on_bounded_line
-
viktor.geometry.
point_is_on_bounded_line
(point, line, inclusive=True)¶ Method checks whether a given Point object is within the ends of a Line.
calculate_intersection_extended_line_with_x
-
viktor.geometry.
calculate_intersection_extended_line_with_x
(line, x)¶ Returns the point at which a given line intersects a vertical axis at position x.
Returns P(x, y): Returns P(x, y): o / y-----P--- y-----P---- /: o: / : / : o x o x
get_line_function_parameters
-
viktor.geometry.
get_line_function_parameters
(line)¶ Returns the line function parameters (a, b) of a line (y = ax + b).
- Return type
Tuple
[float
,float
]
calculate_intersection_extended_lines
-
viktor.geometry.
calculate_intersection_extended_lines
(extended_line1, extended_line2)¶ Calculate intersection between two lines defined by start/end points. The lines are assumed to extend infinitely: bounds are not taken account. Returns None if lines are parallel (i.e. no intersection exists).
Returns P(x, y): Returns P(x, y): Returns None: o / o-----P---o o--o P o-----o / o / / o--o o o
calculate_intersection_bounded_line_extended_line
-
viktor.geometry.
calculate_intersection_bounded_line_extended_line
(bounded_line, extended_line, inclusive=True)¶ Calculate intersection between line with fixed endpoints and line which is indefinitely extended.
calculate_intersection_bounded_lines
-
viktor.geometry.
calculate_intersection_bounded_lines
(bounded_line1, bounded_line2, inclusive=True)¶ Calculate intersection between two lines with fixed endpoints.
Revolve
- class
viktor.geometry.
Revolve
(*args, material=None, **kwargs)¶ Bases:
viktor.geometry.TransformableObject
,abc.ABC
Abstract base class of a revolved object.
- abstract property
surface_area
¶ - Return type
float
- abstract property
inner_volume
¶ - Return type
float
- property
thickness
¶ - Return type
float
- property
mass
¶ Calculates the mass of the object as rho * area * thickness, with rho the density of the Material.
- Return type
float
- abstract property
LineRevolve
- class
viktor.geometry.
LineRevolve
(line, *args, material=None, **kwargs)¶ Bases:
viktor.geometry.Revolve
Returns an revolved object of a Line around the global y-axis.
An example revolve of a line between the point (1, 1, 0) and (3, 2, 0) is shown below, with the line object shown in black.
line = Line(Point(1, 1, 0), Point(3, 2, 0)) line_rev = LineRevolve(line)
- Parameters
- property
uuid
¶
- property
height
¶ - Return type
float
- property
surface_area
¶ Returns the total exterior area of the revolved object.
- Return type
float
- property
inner_volume
¶ Returns the inner volume of the revolved object.
This method will only return a value if the defined Line meets the following conditions:
it should NOT be horizontal, i.e. y_start != y_end
it should be defined in positive y-direction, i.e. y_start < y_end
- Return type
float
Arc
- class
viktor.geometry.
Arc
(centre_point, start_point, end_point, short_arc=True)¶ -
Creates a constant radius arc with three Points in the xy plane. Clockwise rotation creates an outward surface.
- Parameters
centre_point (
Point
) – Point in xy plane.start_point (
Point
) – Point in xy plane. Should have same distance to centre_point as end_point.end_point (
Point
) – Point in xy plane. Should have same distance to centre_point as start_point.short_arc (
bool
) – Angle of arc smaller than pi if True, larger than pi if False.
- property
radius
¶ - Return type
float
- property
theta1
¶ Angle of the end point with respect to the x-axis in radians.
- Return type
float
- property
theta2
¶ Angle of the start point with respect to the x-axis in radians.
- Return type
float
- property
short_arc
¶ - Return type
bool
- property
angle
¶ Absolute angle of the arc in radians, which is the difference between theta1 and theta2.
- Return type
float
- property
length
¶ Arc length.
- Return type
float
- property
theta1_theta2
¶ Calculates the angles of the end (theta1) and start (theta2) points with respect to the x-axis in radians.
- Return type
Tuple
[float
,float
]
-
discretize
(num=2)¶ Returns a discretized representation of the arc, as a list of Point objects. The amount of points can be specified using ‘num’, which should be larger than 1.
- Return type
List
[Point
]
ArcRevolve
- class
viktor.geometry.
ArcRevolve
(arc, *args, material=None, **kwargs)¶ Bases:
viktor.geometry.Revolve
Returns an revolved object of an arc around the global y-axis.
In the example below, rotation_angle is equal to pi / 3:
kwargs can consist of:
rotation_angle: Angle of the revolve according to the right-hand-rule, with the start of the rotation in positive z-direction. Angle in radians. If not specified, 2 pi will be used.
- property
uuid
¶ - Return type
str
- property
surface_area
¶ Total exterior area of the object.
- Return type
float
- property
inner_volume
¶ Returns the inner volume of the revolved object.
This method will only return a value if the defined Arc meets the following conditions:
it should be short, i.e. short_arc=True
the start- and end-point are located on the same side w.r.t. the y-axis of the center-point of the Arc
it is defined in clockwise direction
- Return type
float
- property
height
¶ Height of the object.
- Return type
float
Triangle
CartesianAxes
- class
viktor.geometry.
CartesianAxes
(origin=Point(0.0, 0.0, 0.0), axis_length=1, axis_diameter=0.05)¶ Bases:
viktor.geometry.Group
Helper ThreeJS visualisation object to show positive x (red), y (green) and z (blue) axes.
- Parameters
origin (
Point
) – Coordinates of the origin.axis_length (
float
) – Length of the axes.axis_diameter (
float
) – Diameter of the axes.
RDWGSConverter
- class
viktor.geometry.
RDWGSConverter
¶ -
Class that provides functions to translate latitude and longitude coordinates between the WGS system and RD system.
The RD coordinate system is a cartesian coordinate system that is frequently used for in civil engineering to describe locations in the Netherlands. The origin is located in france, so that for all of the Netherlands, both x (m) and y (m) values are positive and y is always larger then x. The domain in which the RD coordinate system is valid is:
x: [-7000, 300000]
y: [289000, 629000]
About the RD coordinate system: https://nl.wikipedia.org/wiki/Rijksdriehoeksco%C3%B6rdinaten
-
X0
= 155000¶
-
Y0
= 463000¶
-
phi0
= 52.1551744¶
-
lam0
= 5.38720621¶
- static
from_rd_to_wgs
(coords)¶ Convert RD coordinates (x, y) to WGS coordinates [latitude, longitude].
lat, lon = RDWGSConverter.from_rd_to_wgs((100000, 400000))
- Parameters
coords (
Tuple
[float
,float
]) – RD coordinates (x, y)- Return type
List
[float
]
- static
from_wgs_to_rd
(coords)¶ Convert WGS coordinates (latitude, longitude) to RD coordinates [x, y].
x, y = RDWGSConverter.from_rd_to_wgs((51.58622, 4.59360))
- Parameters
coords (
Tuple
[float
,float
]) – WGS coordinates (latitude, longitude)- Return type
List
[float
]
spherical_to_cartesian
-
viktor.geometry.
spherical_to_cartesian
(spherical_coordinates)¶ Using ISO/physical convention: https://upload.wikimedia.org/wikipedia/commons/4/4f/3D_Spherical.svg
- Parameters
spherical_coordinates (
Tuple
[float
,float
,float
]) – Spherical coordinates (r, theta, phi).- Return type
ndarray
- Returns
Cartesian coordinates (x, y, z).
cartesian_to_spherical
-
viktor.geometry.
cartesian_to_spherical
(cartesian_coordinates)¶ Using ISO/physical convention: https://upload.wikimedia.org/wikipedia/commons/4/4f/3D_Spherical.svg
- Parameters
cartesian_coordinates (
Tuple
[float
,float
,float
]) – Cartesian coordinates (x, y, z).- Return type
ndarray
- Returns
Spherical coordinates (r, theta, phi).
cylindrical_to_cartesian
-
viktor.geometry.
cylindrical_to_cartesian
(cylindrical_coordinates)¶ Using ISO convention: https://commons.wikimedia.org/wiki/File:Coord_system_CY_1.svg
Reference plane is former Cartesian xy-plane and cylindrical axis is the Cartesian z-axis.
- Parameters
cylindrical_coordinates (
Tuple
[float
,float
,float
]) – Cylindrical coordinates (rho, phi, z).- Return type
ndarray
- Returns
Cartesian coordinates (x, y, z).
cartesian_to_cylindrical
-
viktor.geometry.
cartesian_to_cylindrical
(cartesian_coordinates)¶ Using ISO convention: https://commons.wikimedia.org/wiki/File:Coord_system_CY_1.svg
Reference plane is former Cartesian xy-plane and cylindrical axis is the Cartesian z-axis.
- Parameters
cartesian_coordinates (
Tuple
[float
,float
,float
]) – Cartesian coordinates (x, y, z).- Return type
ndarray
- Returns
Cylindrical coordinates (rho, phi, z) with phi between -pi and +pi.
Extrusion
- class
viktor.geometry.
Extrusion
(profile, line, profile_rotation=0, *, material=None)¶ Bases:
viktor.geometry.Group
Extruded object from a given set of points, which is called the profile. This profile should meet the following requirements:
start point should be added at the end for closed profile
points should be defined in z=0 plane
circumference should be defined clockwise
Note that the profile is defined with respect to the start point of the Line object, i.e. the profile is defined in the local coordinate system. An example is given below of two extrusions with the same dimensions. Their corresponding Line objects are also visualized. The extrusion have the following profile:
# black box profile_b = [ Point(1, 1), Point(1, 2), Point(2, 2), Point(2, 1), Point(1, 1), ] box_b = Extrusion(profile_b, Line(Point(4, 1, 0), Point(4, 1, 1))) # yellow box profile_y = [ Point(-0.5, -0.5), Point(-0.5, 0.5), Point(0.5, 0.5), Point(0.5, -0.5), Point(-0.5, -0.5), ] box_y = Extrusion(profile_y, Line(Point(2, 2, 0), Point(2, 2, 1)))
- Parameters
- property
uuid
¶ - Return type
str
- property
length
¶ - Return type
float
- property
transformation
¶
ArcExtrusion
- class
viktor.geometry.
ArcExtrusion
(profile, arc, profile_rotation=0, n_segments=50, *, material=None)¶ Bases:
viktor.geometry.Group
Given an Arc and a cross-section of the extrusion, a discretized Extrusion object is returned.
The coordinates of the profile are defined with respect to the Arc and have a LOCAL coordinate system:
z-axis is in direction of the arc from start to end.
x-axis is in positive global z-axis.
y-axis follows from the right-hand-rule.
Rotation of the profile is about the axis according to the right-hand-rule with LOCAL z-axis (see definition above).
Example:
profile = [ Point(1, 1), Point(1, 2), Point(3, 2), Point(3, 1), Point(1, 1), ] arc = Arc(Point(1, 1, 0), Point(3, 1, 0), Point(1, 3, 0)) arc_ext = ArcExtrusion(profile, arc, profile_rotation=10, n_segments=10)
This will result in the following visualization, where the Arc itself is also shown in the xy plane:
- Parameters
profile (
List
[Point
]) – Coordinates of cross-section.arc (
Arc
) – An Arc object is used to define the direction of the extrusion.profile_rotation (
float
) – Rotation of the profile around its local Z-axis in degrees.n_segments (
int
) – Number of discretized segments of the arc, which is 50 by default.material (
Optional
[Material
]) – optional material
CircularExtrusion
- class
viktor.geometry.
CircularExtrusion
(diameter, line, *, open_ends=False, material=None)¶ Bases:
viktor.geometry.TransformableObject
This class is used to construct an extrusion which has a circular base, e.g. a circular foundation pile.
- Parameters
- property
length
¶ - Return type
float
- property
diameter
¶ - Return type
float
- property
radius
¶ - Return type
float
- property
cross_sectional_area
¶ - Return type
float
RectangularExtrusion
- class
viktor.geometry.
RectangularExtrusion
(width, height, line, profile_rotation=0, *, material=None)¶ Bases:
viktor.geometry.Extrusion
Extruded object from a given set of points, which is called the profile. This profile should meet the following requirements:
start point should be added at the end for closed profile
points should be defined in z=0 plane
circumference should be defined clockwise
Note that the profile is defined with respect to the start point of the Line object, i.e. the profile is defined in the local coordinate system. An example is given below of two extrusions with the same dimensions. Their corresponding Line objects are also visualized. The extrusion have the following profile:
# black box profile_b = [ Point(1, 1), Point(1, 2), Point(2, 2), Point(2, 1), Point(1, 1), ] box_b = Extrusion(profile_b, Line(Point(4, 1, 0), Point(4, 1, 1))) # yellow box profile_y = [ Point(-0.5, -0.5), Point(-0.5, 0.5), Point(0.5, 0.5), Point(0.5, -0.5), Point(-0.5, -0.5), ] box_y = Extrusion(profile_y, Line(Point(2, 2, 0), Point(2, 2, 1)))
- Parameters
- property
width
¶ Width of the extrusion.
- Return type
float
- property
height
¶ Height of the extrusion.
- Return type
float
- property
cross_sectional_area
¶ Returns the area of the cross-section (width x height).
- Return type
float
- property
inner_volume
¶ Returns the inner volume of the extruded object.
- Return type
float
SquareBeam
- class
viktor.geometry.
SquareBeam
(length_x, length_y, length_z, *, material=None)¶ Bases:
viktor.geometry.RectangularExtrusion
High level object to create a rectangular beam object around the origin. The centroid of the beam is located at the origin (0, 0, 0).
- Parameters
length_x (
float
) – Width of the extrusion in x-direction.length_y (
float
) – Length of the extrusion in y-direction.length_z (
float
) – Height of the extrusion in z-direction.material (
Optional
[Material
]) – optional material
points_are_coplanar
lines_in_same_plane
calculate_distance_vector
convert_points_for_lathe
translation_matrix
scaling_matrix
rotation_matrix
-
viktor.geometry.
rotation_matrix
(angle, direction, point=None)¶ Returns the rotation matrix that corresponds to a rotation about an axis defined by a point and direction. Angle in radians, direction in accordance to right hand rule.
Example:
>>> R = rotation_matrix(pi/2, [0, 0, 1], [1, 0, 0]) >>> np.allclose(np.dot(R, [0, 0, 0, 1]), [1, -1, 0, 1]) True
- Return type
ndarray
reflection_matrix
-
viktor.geometry.
reflection_matrix
(point, normal)¶ Returns the reflection matrix to mirror at a plane defined by a point and a normal vector.
unit_vector
-
viktor.geometry.
unit_vector
(data, axis=None, out=None)¶ Returns the unit vector of a given vector.
- Return type
ndarray
mirror_object
-
viktor.geometry.
mirror_object
(obj, point, normal)¶ Function that mirrors an object through a plane. The plane is defined by a point and a normal vector. The return is a copy of the original object, mirrored over the specified plane.
- Parameters
obj – Object that is to be mirrored
point (
Point
) – Point object on the desired mirror planenormal – Vector that denotes a normal vector of the desired mirror plane.
volume_cone
-
viktor.geometry.
volume_cone
(r, h)¶ Calculates the volume of a cone.
- Parameters
r (
float
) – Radius of the base.h (
float
) – Height of the cone.
- Return type
float
surface_cone_without_base
-
viktor.geometry.
surface_cone_without_base
(r, h)¶ Calculates the exterior surface of the cone, excluding the area of the circular base.
- Parameters
r (
float
) – Radius of the base.h (
float
) – Height of the cone.
- Return type
float
surface_area_dome
-
viktor.geometry.
surface_area_dome
(theta1, theta2, r, R)¶ Computes the surface area of a dome (arc-revolve).
- Parameters
theta1 – Starting angle of arc in radians.
theta2 – Ending angle of arc in radians.
r – Radius of arc.
R – Distance from centre of arc to rotation line.
- Return type
float
- Returns
surface area of arc-revolve.
hex_to_rgb
-
viktor.geometry.
hex_to_rgb
(value)¶ Return (red, green, blue) for the color given as #rrggbb.
- Return type
Tuple
[int
, …]
rgb_to_hex
-
viktor.geometry.
rgb_to_hex
(red, green, blue, include_hashtag=True)¶ Return color as #rrggbb for the given color values.
- Return type
str
circumference_is_clockwise
add_point
-
viktor.geometry.
add_point
(unique_points, point)¶ Adds a Point object to a unique list of Point objects. The point is only added when not already present in the list.
get_vertices_faces
find_overlap
-
viktor.geometry.
find_overlap
(region_a, region_b, inclusive=False)¶ Given to regions with upper and lower boundary, check if there is overlap and if so return a tuple with the overlap found
The direction of the given regions does not matter: (1, 2) will be handled exactly the same as (2, 1) The returned Tuple will always be in ascending order
Example usage:
find_overlap((2, 4), (3, 5)) -> (3, 4) find_overlap((4, 2), (5, 3)) -> (3, 4) find_overlap((2, 3), (3, 4)) -> None find_overlap((2, 3), (3, 4), inclusive=True) -> (3, 3)
- Parameters
region_a (
Tuple
[float
,float
]) – Tuple of values of the first region.region_b (
Tuple
[float
,float
]) – Tuple of values of the second region.inclusive (
bool
) – A flag to decide whether a point overlap is counted as overlap or not.
- Return type
Optional
[Tuple
[float
,float
]]- Returns
A tuple with upper and lower bounds of the overlapping region, or None.
Pattern
- class
viktor.geometry.
Pattern
(base_object, duplicate_translation_list)¶ Bases:
viktor.geometry.Group
Instantiates a pattern based on a base object and several duplicates, each translated by an input vector.
- Parameters
base_object (
TransformableObject
) – the object to be duplicatedduplicate_translation_list (
List
[List
[float
]]) – a list of translation vectors, each of which generates a duplicate
LinearPattern
- class
viktor.geometry.
LinearPattern
(base_object, direction, number_of_elements, spacing)¶ Bases:
viktor.geometry.Pattern
Instantiates a linear, evenly spaced, pattern along a single direction.
- Parameters
base_object (
TransformableObject
) – the object to be duplicateddirection (
List
[float
]) – a unit vector specifying in which direction the pattern propagatesnumber_of_elements (
int
) – total amount of elements in the pattern, including the base objectspacing (
float
) – the applied spacing
BidirectionalPattern
- class
viktor.geometry.
BidirectionalPattern
(base_object, direction_1, direction_2, number_of_elements_1, number_of_elements_2, spacing_1, spacing_2)¶ Bases:
viktor.geometry.Pattern
Instantiates a two-dimensional pattern, evenly spaced in two separate directions
- Parameters
base_object (
TransformableObject
) – the object to be duplicateddirection_1 (
List
[float
]) – a unit vector specifying the first directiondirection_2 (
List
[float
]) – a unit vector specifying the second directionnumber_of_elements_1 (
int
) – total amount of elements along direction 1number_of_elements_2 (
int
) – total amount of elements along direction 2spacing_1 (
float
) – the applied spacing in direction 1spacing_2 (
float
) – the applied spacing in direction 2
Polygon
- class
viktor.geometry.
Polygon
(points, *, surface_orientation=False, material=None)¶ Bases:
viktor.geometry.TransformableObject
2D closed polygon without holes in x-y plane.
- Parameters
points (
List
[Point
]) – profile is automatically closed, do not add start point at the end. only the x and y coordinates are considered (z is set to 0). left hand rule around circumference determines surface directionsurface_orientation (
bool
) –if True, the left hand rule around circumference determines surface direction
if False, surface always in +z direction
material (
Optional
[Material
]) – optional material
- Raises
ValueError –
if less than 3 points are provided.
if points contains duplicates.
if points form a polygon with self-intersecting lines.
if points are all collinear.
-
has_clockwise_circumference
()¶ - Method determines the direction of the input points, and returns:
True if the circumference is clockwise
False if the circumference is counter-clockwise
- Return type
bool
- property
cross_sectional_area
¶ - Return type
float
- property
centroid
¶ Returns the coordinate of the centroid (geometric center) of the polygon.
- Return type
Tuple
[float
,float
]
- property
moment_of_inertia
¶ Returns the moment of inertia in xy-plane.
- Return type
Tuple
[float
,float
]
Polyline
- class
viktor.geometry.
Polyline
(points)¶ -
This is a class representing a line made up of multiple straight line segments. It can be created by providing a list of Points. The list of points can be empty or contain duplicate points The line has a directions, following the order of the provided list of points The Polyline class is immutable. All functions that perform changes on a polyline will return a mutated copy of the original polyline
- classmethod
from_lines
(lines)¶ create a polyline object from a list of lines the end of one line must always coincide with the start of the next
- Parameters
lines –
- Return type
- Returns
-
is_equal_to
(other)¶ check if all points in this polyline coincide with all points of another polyline
- Parameters
other (
Polyline
) –- Return type
bool
- Returns
- property
lines
¶ A list of lines connecting all polyline points. Lines between coincident points are skipped.
- Return type
List
[Line
]
- property
x_min
¶ The lowest x-coordinate present within this polyline
- Return type
Optional
[float
]- Returns
- property
x_max
¶ The highest x-coordinate present within this polyline
- Return type
Optional
[float
]- Returns
- property
y_min
¶ The lowest y-coordinate present within this polyline
- Return type
Optional
[float
]- Returns
- property
y_max
¶ The highest y-coordinate present within this polyline
- Return type
Optional
[float
]- Returns
- property
z_min
¶ The lowest z-coordinate present within this polyline
- Return type
Optional
[float
]- Returns
- property
z_max
¶ The highest z-coordinate present within this polyline
- Return type
Optional
[float
]- Returns
-
get_reversed_polyline
()¶ returns a polyline that is the reverse of this one
- Return type
- Returns
-
serialize
()¶ return a json serializable dict of form:
>>> [{'x': point_1.x, 'y': point_1.y}, >>> {'x': point_2.x, 'y': point_2.y}]
- Returns
- classmethod
from_dict
(polyline_dict)¶ Turn a dict generated in the serialize method back into a polyline object
- Return type
-
filter_duplicate_points
()¶ Returns a new Polyline object. If a two consecutive points in this polyline coincide, the second point will be omitted
- Return type
- Returns
-
is_monotonic_ascending_x
(strict=True)¶ Check if the x coordinates of the points of this polyline are ascending.
- Parameters
strict (
bool
) – when set to false, equal x coordinates are accepted between points- Return type
bool
- Returns
-
is_monotonic_ascending_y
(strict=True)¶ Check if the y coordinates of the points of this polyline are ascending
- Parameters
strict (
bool
) – when set to false, equal y coordinates are accepted between points- Return type
bool
- Returns
-
intersections_with_polyline
(other_polyline)¶ Find all intersections with another polyline and return them ordered according to the direction of this polyline
If the polylines are partly parallel, the start and end points of the parallel section will be returned as intersections. If one of the polylines is a subset of the other, or the two lines are completely parallel, no intersection will be found
-
intersections_with_x_location
(x)¶ Find all intersections of this polyline with a given x location. Ordered from start to end of this polyline.
If this line is partly vertical, the start and end points of the vertical section will be returned as a intersection If this line is completely vertical, no intersection will be found.
- Parameters
x (
float
) –- Return type
List
[Point
]- Returns
-
point_is_on_polyline
(point)¶ Check if a given point lies on this polyline
- Parameters
point –
- Return type
bool
- Returns
-
get_polyline_between
(start_point, end_point, inclusive=False)¶ Given two points that both lie on a polyline, return the polyline that lies between those two points start_point has to lie before end_point on this polyline.
If the given start point lies after the given end point on this polyline, an empty polyline will be returned If the two given points are identical, it depends on the inclusive flag whether a polyline containing that point once, or an empty polyline will be returned
-
find_overlaps
(other)¶ Find all overlapping regions of this polyline with another polyline. The returned overlapping regions will all point in the direction of this line. The overlap polylines will contain all points of both polylines, even if they only occur in one of the lines.
if no overlaps are found, an empty list will be returned.
-
combine_with
(other)¶ Given two polylines that have at least one point in common and together form one line without any side branches, combine those two polylines The combined line will contain all points of both polylines.
-
split
(point)¶ return the two separate parts of this polyline before and after the given point
will raise a value error when the provided point does not lie on this polyline
- classmethod
get_lowest_or_highest_profile_x
(profile_1, profile_2, lowest)¶ given two polylines with n intersections, return a third polyline that will always follow the lowest (or highest) of the two lines the x locations of the points of the two polylines should be not descending (lines from left to right or vertical) the returned polyline will only cover the overlapping range in x coordinates
If one of the profiles is an empty polyline, an empty polyline will be returned.
examples:
/----------------| / /-------|-------------------- profile_1: ----------------\ / / | \ / / |_____________________________ profile_2: -------------\-/ / \_________/ get_lowest_or_highest_profile_x(cls, profile_1, profile_2, lowest=True) will return: /-------| / | / |____________________ result: -------------\ / \_________/
Note that only the overlapping region of the two profiles is returned!
- Parameters
- Return type
- Returns
Currently, this implementation is exclusive. Meaning that vertical line parts that lie on the start or end of the overlap region in x are not taken into account
- classmethod
Cone
- class
viktor.geometry.
Cone
(diameter, height, *, origin=None, orientation=None, material=None)¶ Bases:
viktor.geometry.TransformableObject
Creates a cone object.
- Parameters
diameter (
float
) – Diameter of the circular base surface.height (
float
) – Height from base to tip.origin (
Optional
[Point
]) – Optional location of the centroid of the base surface (default: Point(0, 0, 0)).orientation (
Optional
[Vector
]) – Optional orientation from origin to the tip (default: Vector(0, 0, 1)).material (
Optional
[Material
]) – Optional material.
- classmethod
from_line
(diameter, line, *, material=None)¶ Create a Cone object by a given base diameter and line.
- Parameters
- Return type
Sphere
- class
viktor.geometry.
Sphere
(centre_point, radius, width_segments=30, height_segments=30, material=None)¶ Bases:
viktor.geometry.TransformableObject
This class can be used to construct a spherical object around the specified coordinate.
The smoothness of the edges can be altered by setting width_segments and height_segments. In the example below both the default smoothness of 30 (left) and a rough sphere with 5 segments (right) is shown:
- Parameters
-
diameter
()¶ - Return type
float
-
circumference
()¶ - Return type
float
-
surface_area
()¶ - Return type
float
-
volume
()¶ - Return type
float
Torus
- class
viktor.geometry.
Torus
(radius_cross_section, radius_rotation_axis, rotation_angle=6.283185307179586, *, material=None)¶ Bases:
viktor.geometry.Group
Create a torus object
- Parameters
radius_cross_section (
float
) –radius_rotation_axis (
float
) – measured from central axis to centre of cross-section.rotation_angle (
float
) – optional argument to control how large of a torus section you want. 2pi for complete torusmaterial (
Optional
[Material
]) – optional material
- property
inner_volume
¶
TriangleAssembly
- class
viktor.geometry.
TriangleAssembly
(triangles, *, material=None)¶ Bases:
viktor.geometry.TransformableObject
Fundamental visualisation geometry, built up from triangles. Right hand rule on triangle circumference determines the surface direction.
GeoPoint
- class
viktor.geometry.
GeoPoint
(lat, lon)¶ -
Geographical point on the Earth’s surface described by a latitude / longitude coordinate pair.
This object can be created directly, or will be returned in the parameter set when using a
GeoPointField
.- Parameters
lat (
float
) – Latitude.lon (
float
) – Longitude.
- classmethod
from_rd
(coords)¶ Instantiates a GeoPoint from the provided RD coordinates.
- Parameters
coords (
Tuple
[float
,float
]) – RD coordinates (x, y).- Return type
- property
rd
¶ RD representation (x, y) of the GeoPoint.
- Return type
Tuple
[float
,float
]
GeoPolyline
- class
viktor.geometry.
GeoPolyline
(*points)¶ -
Geographical polyline on the Earth’s surface described by a a list of
GeoPoints
.This object can be created directly, or will be returned in the parameter set when using a
GeoPolylineField
.- Parameters
points (
GeoPoint
) – Geo points (minimum 2).
GeoPolygon
- class
viktor.geometry.
GeoPolygon
(*points)¶ -
Geographical polygon on the Earth’s surface described by a a list of
GeoPoints
.This object can be created directly, or will be returned in the parameter set when using a
GeoPolygonField
.- Parameters
points (
GeoPoint
) – Geo points (minimum 3). The profile is automatically closed, so it is not necessary to add the start point at the end.