Surfaces

volmdlr module for 3D Surfaces.

class volmdlr.surfaces.BSplineSurface3D(degree_u: int, degree_v: int, control_points: List[Point3D], nb_u: int, nb_v: int, u_multiplicities: List[int], v_multiplicities: List[int], u_knots: List[float], v_knots: List[float], weights: List[float] | None = None, name: str = '')

Bases: Surface3D

A class representing a 3D B-spline surface.

A B-spline surface is a smooth surface defined by a set of control points and a set of basis functions called B-spline basis functions. The shape of the surface is determined by the position of the control points and can be modified by moving the control points.

Parameters:

• degree_u (int) – The degree of the B-spline curve in the u direction.

• degree_v (int) – The degree of the B-spline curve in the v direction.

• control_points (List[volmdlr.Point3D]) – A list of 3D control points that define the shape of the surface.

• nb_u (int) – The number of control points in the u direction.

• nb_v (int) – The number of control points in the v direction.

• u_multiplicities (List[int]) – A list of multiplicities for the knots in the u direction. The multiplicity of a knot is the number of times it appears in the knot vector.

• v_multiplicities (List[int]) – A list of multiplicities for the knots in the v direction. The multiplicity of a knot is the number of times it appears in the knot vector.

• u_knots (List[float]) – A list of knots in the u direction. The knots are real numbers that define the position of the control points along the u direction.

• v_knots (List[float]) – A list of knots in the v direction. The knots are real numbers that define the position of the control points along the v direction.

• weights (List[float]) – (optional) A list of weights for the control points. The weights can be used to adjust the influence of each control point on the shape of the surface. Default is None.

• name (str) – (optional) A name for the surface. Default is an empty string.

arc2d_parametric_to_dimension(arc2d, grid2d: Grid2D)

Convert an arc 2d from the parametric to the dimensioned frame.

arc2d_to_3d(arc2d)

Evaluates the Euclidean form for the parametric arc.

arc2d_with_dimension_to_3d(arc2d)

Compute the arc 3d, on a Bspline surface, of an arc 2d in the dimensioned frame.

arc2d_with_dimension_to_parametric_frame(arc2d)

Convert an arc 2d from the dimensioned to the parametric frame.

arc3d_to_2d(arc3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

arc3d_to_2d_with_dimension(arc3d, grid2d: Grid2D)

Compute the arc 2d of an arc 3d, on a Bspline surface, in the dimensioned frame.

arcellipse3d_to_2d(arcellipse3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

basis_functions_u(u, k, i)

Compute basis functions Bi in u direction for u=u and degree=k.

basis_functions_v(v, k, i)

Compute basis functions Bi in v direction for v=v and degree=k.

blending_matrix_u(u)

Compute a matrix of basis_functions in u direction for a vector u like [0,1].

blending_matrix_v(v)

Compute a matrix of basis_functions in v direction for a vector v like [0,1].

blending_vector_u(u)

Compute a vector of basis_functions in u direction for u=u.

blending_vector_v(v)

Compute a vector of basis_functions in v direction for v=v.

property bounding_box

Gets the Bounding box of the BSpline Surface 3d.

bsplinecurve2d_parametric_to_dimension(bsplinecurve2d, grid2d: Grid2D)

Convert a bsplinecurve2d from the parametric to the dimensioned frame.

bsplinecurve2d_to_3d(bspline_curve2d)

Converts the parametric boundary representation into a 3D primitive.

bsplinecurve2d_with_dimension_to_3d(bsplinecurve2d)

Compute the bsplinecurve3d, on a Bspline surface, of a bsplinecurve2d defined in the dimensioned frame.

bsplinecurve2d_with_dimension_to_parametric_frame(bsplinecurve2d)

Convert a bsplinecurve2d from the dimensioned to the parametric frame.

bsplinecurve3d_to_2d(bspline_curve3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

bsplinecurve3d_to_2d_with_dimension(bsplinecurve3d, grid2d: Grid2D)

Compute the bsplinecurve2d of a bsplinecurve3d, on a Bspline surface, in the dimensioned frame.

check_bounds(x)

Check surface bounds.

static check_convergence(surf_derivatives, distance_vector, tol1: float = 1e-06, tol2: float = 1e-08)

Check convergence of point inversion method.

connect_contours(outer_contour, inner_contours)

Create connections between contours on parametric domain.

Parameters:

• outer_contour – Outer contour 2D.

• inner_contours (list) – List of 2D contours.

contour2d_parametric_to_dimension(contour2d: Contour2D, grid2d: Grid2D)

Convert a contour 2d from the parametric to the dimensioned frame.

contour2d_with_dimension_to_3d(contour2d)

Compute the contour3d, on a Bspline surface, of a contour2d define in the dimensioned frame.

contour2d_with_dimension_to_parametric_frame(contour2d)

Convert a contour 2d from the dimensioned to the parametric frame.

contour3d_to_2d_with_dimension(contour3d: Contour3D, grid2d: Grid2D)

Compute the Contour 2d of a Contour 3d, on a Bspline surface, in the dimensioned frame.

property control_points

Gets control points.

control_points_matrix(coordinates)

Define control points like a matrix, for each coordinate: x:0, y:1, z:2.

property control_points_table

Creates control points table.

copy(deep: bool = True, **kwargs)

Returns a copy of the instance.

Parameters:

deep – If False, perform a shallow copy. If True, perform a deep copy.

ctrlpts2d()

Each row represents the control points in u direction and each column the points in v direction.

property data

Returns a dictionary of the BSpline data.

decompose(return_params: bool = False, decompose_dir='uv')

Decomposes the surface into Bezier surface patches of the same degree.

Parameters:

• return_params (bool) – If True, returns the parameters from start and end of each Bézier patch with repect to the input curve.

• decompose_dir (str) – Direction of decomposition. ‘uv’, ‘u’ or ‘v’.

property delta

Evaluation delta for both u- and v-directions.

Getter:

Gets evaluation delta as a tuple of values corresponding to u- and v-directions

Setter:

Sets evaluation delta for both u- and v-directions

Type:

float

property delta_u

Evaluation delta for the u-direction.

Getter:

Gets evaluation delta for the u-direction

Setter:

Sets evaluation delta for the u-direction

Type:

float

property delta_v

Evaluation delta for the v-direction.

Getter:

Gets evaluation delta for the v-direction

Setter:

Sets evaluation delta for the v-direction

Type:

float

derivatives(u, v, order)

Evaluates n-th order surface derivatives at the given (u, v) parameter pair.

Parameters:

• u (float) – Point’s u coordinate.

• v (float) – Point’s v coordinate.

• order (int) – Order of the derivatives.

Returns:

A list SKL, where SKL[k][l] is the derivative of the surface S(u,v) with respect

to u k times and v l times :rtype: List[volmdlr.Vector3D]

property domain

Domain.

Domain is determined using the knot vector(s).

Getter:

Gets the domain

edge3d_to_2d_with_dimension(edge3d, grid2d: Grid2D)

Compute the edge 2d of an edge 3d, on a Bspline surface, in the dimensioned frame.

error_with_edge3d(edge3d)

Compute the error/distance between the Bspline surface and an edge 3d.

it’s the mean of the start and end points errors’

error_with_point3d(point3d)

Compute the error/distance between the Bspline surface and a point 3d.

property evalpts

Evaluated points.

Getter:

Gets the coordinates of the evaluated points

Type:

list

evaluate(**kwargs)

Evaluates the surface.

The evaluated points are stored in evalpts property.

Keyword Arguments:

• start_u: start parameter on the u-direction

• stop_u: stop parameter on the u-direction

• start_v: start parameter on the v-direction

• stop_v: stop parameter on the v-direction

The start_u, start_v and stop_u and stop_v parameters allow evaluation of a surface segment in the range [start_u, stop_u][start_v, stop_v] i.e. the surface will also be evaluated at the stop_u and stop_v parameter values.

extract_curves(u: List[float] | None = None, v: List[float] | None = None)

Extracts curves from a surface.

Parameters:

• u – a list of parameters in ascending order in u direction to extract curves

• v – a list of parameters in ascending order in v direction to extract curves

Returns:

a dictionary containing the extracted curves in u and v direction

Return type:

dict

face_class = 'BSplineFace3D'

fix_start_end_singularity_point_any_direction(edge3d, points, points3d, tol: float = 1e-06)

Helper function.

Uses local discretization and line intersection with the tangent line at the point just before the undefined point on the BREP of the 3D edge to find the real values on parametric domain.

fix_undefined_brep_with_neighbors(edge, previous_edge, next_edge)

Uses neighbors edges to fix edge contained within the periodicity boundary.

frame_mapping(frame: Frame3D, side: str)

Changes frame_mapping and return a new BSplineSurface3D.

side = ‘old’ or ‘new’

classmethod from_cylindrical_face(cylindrical_face, degree_u, degree_v, name: str = '', **kwargs)

Define a bspline surface from a cylindrical face.

Parameters

cylindrical_facevolmdlr.faces.CylindricalFace3D

face 3d

degree_uint

degree of the output surface for the u-direction.

degree_vint

degree of the output surface for the v-direction.

points_xint

number of points in x-direction

points_yint

number of points in y-direction

name: str

object’s name.

Returns

B-spline surface

classmethod from_cylindrical_faces(cylindrical_faces, degree_u, degree_v, points_x: int = 10, points_y: int = 10, name: str = '')

Define a bspline surface from a list of cylindrical faces.

Parameters

cylindrical_facesList[volmdlr.faces.CylindricalFace3D]

faces 3d

degree_uint

degree of the output surface for the u-direction

degree_vint

degree of the output surface for the v-direction

points_xint

number of points in x-direction

points_yint

number of points in y-direction

name: str

object’s name.

Returns

B-spline surface

classmethod from_geomdl_surface(surface, name: str = '')

Create a volmdlr BSpline_Surface3D from a geomdl’s one.

classmethod from_points_approximation(points_3d: List[Point3D], size_u: int, size_v: int, degree_u: int, degree_v: int, name: str = '', **kwargs)

Bspline Surface approximate through 3d points.

Parameters:

• points_3d (List[volmdlr.Point3D]) – data points.

• size_u (int) – number of data points on the u-direction.

• size_v (int) – number of data points on the v-direction.

• degree_u (int) – degree of the output surface for the u-direction.

• degree_v (int) – degree of the output surface for the v-direction.

• name (str) – (Optional) instance name.

Keyword Arguments:

• ctrlpts_size_u: number of control points on the u-direction. Default: size_u - 1

• ctrlpts_size_v: number of control points on the v-direction. Default: size_v - 1

Returns:

B-spline surface.

Return type:

BSplineSurface3D

classmethod from_points_interpolation(points_3d: List[Point3D], size_u: int, size_v: int, degree_u: int, degree_v: int, name: str = '')

Bspline Surface interpolation through 3d points.

Parameters:

• points_3d (List[volmdlr.Point3D]) – data points.

• size_u (int) – number of data points on the u-direction.

• size_v (int) – number of data points on the v-direction.

• degree_u (int) – degree of the output surface for the u-direction.

• degree_v (int) – degree of the output surface for the v-direction.

• name (str) – (Optional) instance name.

Returns:

B-spline surface.

Return type:

BSplineSurface3D

classmethod from_step(arguments, object_dict, **kwargs)

Converts a step primitive to a BSplineSurface3D.

Parameters:

• arguments (list) – The arguments of the step primitive.

• object_dict (dict) – The dictionary containing all the step primitives that have already been instantiated.

Returns:

The corresponding BSplineSurface3D object.

Return type:

volmdlr.faces.BSplineSurface3D

fullarcellipse3d_to_2d(fullarcellipse3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

get_surface_curves(**kwargs)

Extracts curves from a surface.

grid2d_deformation(grid2d: Grid2D)

Compute the deformation/displacement (dx/dy) of a Grid2D based on a Bspline surface.

grid2d_deformed(grid2d: Grid2D)

Dimension and deform a Grid2D points based on a Bspline surface.

grid3d(grid2d: Grid2D)

Generate 3d grid points of a Bspline surface, based on a Grid2D.

intersection_with(other_bspline_surface3d)

Compute intersection points between two Bspline surfaces.

return u,v parameters for intersection points for both surfaces

is_intersected_with(other_bspline_surface3d)

Check if the two surfaces are intersected or not.

return True, when there are more 50points on the intersection zone.

is_singularity_point(point, *args, **kwargs)

Returns True if the point belongs to the surface singularity and False otherwise.

is_undefined_brep(edge)

Returns True if the edge is contained within the periodicity boundary.

property knots_vector_u

Compute the global knot vector (u direction) based on knot elements and multiplicities.

property knots_vector_v

Compute the global knot vector (v direction) based on knot elements and multiplicities.

property knotvector

Knot vector in u and v direction respectively.

linesegment2d_parametric_to_dimension(linesegment2d, grid2d: Grid2D)

Convert a linesegment2d from the parametric to the dimensioned frame.

linesegment2d_to_3d(linesegment2d)

Evaluates the Euclidean form for the parametric line segment.

linesegment2d_with_dimension_to_3d(linesegment2d)

Compute the linesegment3d, on a Bspline surface, of a linesegment2d defined in the dimensioned frame.

linesegment2d_with_dimension_to_parametric_frame(linesegment2d)

Convert a linesegment2d from the dimensioned to the parametric frame.

linesegment3d_to_2d(linesegment3d)

A line segment on a BSplineSurface3D will be in any case a line in 2D?.

linesegment3d_to_2d_with_dimension(linesegment3d, grid2d: Grid2D)

Compute the linesegment2d of a linesegment3d, on a Bspline surface, in the dimensioned frame.

merge_with(other_bspline_surface3d, abs_tol: float = 1e-06)

Merges two adjacent surfaces based on their faces.

Parameters:

• other_bspline_surface3d (volmdlr.faces.BSplineSurface3D) – Other adjacent surface

• abs_tol (float.) – tolerance.

Returns:

Merged surface

Return type:

volmdlr.faces.BSplineSurface3D

nearest_edges3d(contour3d, threshold: float)

Compute the nearest edges of a contour 3d to a Bspline_surface3d based on a threshold.

parametric_points_to_3d(points: ndarray[Any, dtype[float64]]) → ndarray[Any, dtype[float64]]

Transform parametric coordinates to 3D points on the BSpline surface.

Given a set of parametric coordinates (u, v) representing points on the surface, this method returns the corresponding 3D points on the BSpline surface.

Parameters:

points (numpy.ndarray[np.float64]) – Parametric coordinates in the form of a numpy array with shape (n, 2), where n is the number of points, and each row corresponds to (u, v).

Returns:

Array of 3D points representing the BSpline surface in Cartesian coordinates.

Return type:

numpy.ndarray[np.float64]

plane_intersections(plane3d)

Compute intersection points between a Bspline surface and a plane 3d.

plot(ax=None, edge_style: EdgeStyle = EdgeStyle(color='grey', alpha=0.5, edge_ends=False, edge_direction=False, width=None, arrow=False, plot_points=False, dashed=True, linestyle='-', linewidth=1, equal_aspect=True), **kwargs)

Plot representation of the surface.

point2d_parametric_to_dimension(point2d: Point3D, grid2d: Grid2D)

Convert a point 2d from the parametric to the dimensioned frame.

point2d_to_3d(point2d: Point2D)

Evaluate the surface at a given parameter coordinate.

point2d_with_dimension_to_3d(point2d, grid2d: Grid2D)

Compute the point 3d, on a Bspline surface, of a point 2d define in the dimensioned frame.

point2d_with_dimension_to_parametric_frame(point2d, grid2d: Grid2D)

Convert a point 2d from the dimensioned to the parametric frame.

point3d_to_2d(point3d: Point3D, tol=1e-06)

Evaluates the parametric coordinates (u, v) of a 3D point (x, y, z).

Parameters:

• point3d (volmdlr.Point3D) – A 3D point to be evaluated.

• tol (float) – Tolerance to accept the results.

Returns:

The parametric coordinates (u, v) of the point.

Return type:

volmdlr.Point2D

point3d_to_2d_minimize(point3d, initial_guess, point_inversion_result, tol)

Auxiliary function for point3d_to_2d in case the point inversion does not converge.

point3d_to_2d_with_dimension(point3d: Point3D, grid2d: Grid2D)

Compute the point2d of a point3d, on a Bspline surface, in the dimensioned frame.

point_inversion(x, point3d, tol, maxiter: int = 50)

Performs point inversion.

Given a point P = (x, y, z) assumed to lie on the NURBS surface S(u, v), point inversion is the problem of finding the corresponding parameters u, v that S(u, v) = P.

point_inversion_funcs(x, point3d)

Returns functions evaluated at x.

point_inversion_grid_search(point3d, acceptable_distance, max_iter: int = 15)

Find the parameters (u, v) of a 3D point on the BSpline surface using a grid search algorithm.

points()

Returns surface points.

classmethod points_approximate_into_bspline_surface(points_3d, size_u, size_v, degree_u, degree_v, name: str = '', **kwargs)

Bspline Surface approximate through 3d points.

classmethod points_fitting_into_bspline_surface(points_3d, size_u, size_v, degree_u, degree_v, name: str = '')

Bspline Surface interpolation through 3d points.

rectangular_cut(u1: float, u2: float, v1: float, v2: float, name: str = '')

Deprecated method, Use BSplineFace3D from_surface_rectangular_cut method.

rotation(center: Vector3D, axis: Vector3D, angle: float)

BSplineSurface3D rotation.

Parameters:

• center – rotation center

• axis – rotation axis

• angle – angle rotation

Returns:

a new rotated BSplineSurface3D

property sample_size

Sample size for both u- and v-directions.

Getter:

Gets sample size as a tuple of values corresponding to u- and v-directions

Setter:

Sets sample size for both u- and v-directions

Type:

int

property sample_size_u

Sample size for the u-direction.

Getter:

Gets sample size for the u-direction

Setter:

Sets sample size for the u-direction

Type:

int

property sample_size_v

Sample size for the v-direction.

Getter:

Gets sample size for the v-direction

Setter:

Sets sample size for the v-direction

Type:

int

simplify_surface()

Verifies if BSplineSurface3D could be a Plane3D.

Returns:

A planar surface if possible, otherwise, returns self.

split_surface_u(u: float)

Splits the surface at the input parametric coordinate on the u-direction.

Parameters:

u (float) – Parametric coordinate u chosen between 0 and 1

Returns:

Two split surfaces

Return type:

List[volmdlr.faces.BSplineSurface3D]

split_surface_v(v: float)

Splits the surface at the input parametric coordinate on the v-direction.

Parameters:

v (float) – Parametric coordinate v chosen between 0 and 1

Returns:

Two split surfaces

Return type:

List[volmdlr.faces.BSplineSurface3D]

split_surface_with_bspline_curve(bspline_curve3d: BSplineCurve3D)

Cuts the surface into two pieces with a bspline curve.

Parameters:

bspline_curve3d (edges.BSplineCurve3D) – A BSplineCurve3d used for cutting

Returns:

Two split surfaces

Return type:

List[volmdlr.faces.BSplineSurface3D]

property surface_curves

Extracts curves from a surface.

to_dict(*args, **kwargs)

Avoids storing points in memo that makes serialization slow.

to_geomdl()

Translate into a geomdl object.

to_plane3d()

Converts a Bspline surface3d to a Plane3d.

Returns:

A Plane

Return type:

Plane3D

to_step(current_id)

Converts object into a step entity.

translation(offset: Vector3D)

BSplineSurface3D translation.

Parameters:

offset – translation vector

Returns:

A new translated BSplineSurface3D

property u_closed

Returns True if the surface is close in any of the u boundaries.

u_closed_lower(tol: float = 1e-06)

Returns True if the surface is close in any of the u boundaries.

u_closed_upper(tol: float = 1e-06)

Returns True if the surface is close in any of the u boundaries.

property u_domain

The parametric domain of the surface in the U direction.

u_iso(u: float) → BSplineCurve3D

Returns the u-iso curve of the surface.

Parameters:

u (float) – The value of u where to extract the curve.

Returns:

A line 3D

Return type:

curves.Line3D

property v_closed

Returns True if the surface is close in any of the u boundaries.

v_closed_lower(tol: float = 1e-06)

Returns True if the surface is close in any of the u boundaries.

v_closed_upper(tol: float = 1e-06)

Returns True if the surface is close in any of the u boundaries.

property v_domain

The parametric domain of the surface in the V direction.

v_iso(v: float) → BSplineCurve3D

Returns the v-iso curve of the surface.

Parameters:

v – The value of v where to extract the curve.

Returns:

A BSpline curve 3D

Return type:

edges.BSplineCurve3D

vertices()

Evaluated points.

Getter:

Gets the coordinates of the evaluated points

Type:

list

property weights

Gets the weights of the BSpline surface.

wire3d_to_2d(wire3d)

Compute the 2d of a wire 3d, on a Bspline surface.

wire3d_to_2d_with_dimension(wire3d)

Compute the 2d of a wire 3d, on a Bspline surface, in the dimensioned frame.

property x_periodicity

Evaluates the periodicity of the surface in u direction.

xy_limits(other_bspline_surface3d)

Compute x, y limits to define grid2d.

property y_periodicity

Evaluates the periodicity of the surface in v direction.

class volmdlr.surfaces.BezierSurface3D(degree_u: int, degree_v: int, control_points: List[List[Point3D]], nb_u: int, nb_v: int, name='')

Bases: BSplineSurface3D

A 3D Bezier surface.

Parameters:

• degree_u (int) – The degree of the Bezier surface in the u-direction.

• degree_v (int) – The degree of the Bezier surface in the v-direction.

• control_points (List[List[volmdlr.Point3D]]) – A list of lists of control points defining the Bezier surface.

• nb_u (int) – The number of control points in the u-direction.

• nb_v (int) – The number of control points in the v-direction.

• name (str) – (Optional) name for the Bezier surface.

class volmdlr.surfaces.ConicalSurface3D(frame: Frame3D, semi_angle: float, ref_radius: float = 0.0, name: str = '')

Bases: UPeriodicalSurface

Describes a cone.

A cone is defined by the half-angle, and is positioned in space by a frame and a reference radius. The main axis of the frame is the axis of revolution of the cone. The plane defined by the origin, the x direction and the y direction of the frame is the plane of the cone. The intersection of the cone with this reference plane is a circle of radius equal to the reference radius. The apex of the cone is on the negative side of the main axis of the frame if the half-angle is positive, and on the positive side if the half-angle is negative. This frame is the “local coordinate system” of the cone. The following apply:

Rotation around its main axis, in the trigonometric sense given by the x direction and the y direction, defines the u parametric direction and the x-axis gives the origin for the u parameter. The z axis defines the v parametric direction of the cone and the origin of the frame is the origin of the v parameter. The parametric range of the two parameters is:

• [ 0, 2.*Pi ] for u, and

• ] -infinity, +infinity [ for v

The parametric equation of the cone is: P(u, v) = O + (R + v*tan(ang)) * (cos(u)*x + sin(u)*y) + v*z where:

• O, x, y and z are respectively the origin, the x, y and z direction of the cone’s local coordinate system

• ang is the half-angle at the apex of the cone

• R is the reference radius.

Parameters:

• frame – Cone’s local coordinate system.

• semi_angle – half-angle at the apex of the cone.

• ref_radius – radius of the circle formed by the intersection of the cone with the reference plane.

property apex

Computes the apex of the cone.

It is on the negative side of the axis of revolution of this cone if the half-angle at the apex is positive,

and on the positive side of the “main axis” if the half-angle is negative.

check_primitives_order(contour)

If contours passes at the cone singularity this makes sure that the contour is not in an undefined order.

circle_intersections(circle: Circle3D)

Calculates the intersections between a conical surface and a Circle 3D.

Parameters:

circle – other circle to verify intersections.

Returns:

a list of intersection points, if there exists any.

concurrent_plane_intersection(plane3d: Plane3D)

Cone plane intersections when plane’s normal is concurrent with the cone’s axis, but not orthogonal.

Parameters:

plane3d – intersecting plane.

Returns:

list of intersecting curves.

conicalsurface_intersections(conical_surface)

Conical Surface intersections with another conical surface.

Parameters:

conical_surface – intersecting conical surface.

Returns:

list of intersecting curves.

contour3d_to_2d(contour3d, return_primitives_mapping: bool = False)

Transforms a Contour3D into a Contour2D in the parametric domain of the surface.

Parameters:

• contour3d (wires.Contour3D) – The contour to be transformed.

• return_primitives_mapping (bool) – If True, returns a dictionary containing the correspondence between 2D and 3D primitives

Returns:

A 2D contour object.

Return type:

wires.Contour2D

property domain

Returns u and v bounds.

face_class = 'ConicalFace3D'

frame_mapping(frame: Frame3D, side: str)

Changes frame_mapping and return a new ConicalSurface3D.

Parameters:

side – ‘old’ or ‘new’

classmethod from_step(arguments, object_dict, **kwargs)

Converts a step primitive to a ConicalSurface3D.

Parameters:

• arguments (list) – The arguments of the step primitive.

• object_dict (dict) – The dictionary containing all the step primitives that have already been instantiated.

Returns:

The corresponding ConicalSurface3D object.

Return type:

volmdlr.faces.ConicalSurface3D

get_circle_generatrices(number_circles: int, z1, z2)

Get circles generatrix of the cone.

Parameters:

• z1 – Initial height of cone.

• z2 – Final height of cone.

• number_circles – number of expected circles.

get_generatrices(number_lines: int = 36, z: float = 1)

Gets Conical Surface 3D generatrix lines.

Parameters:

• z – cone’s z height.

• number_lines – number of generatrix lines.

Returns:

static get_singularity_lines()

Return lines that are parallel and coincident with surface singularity at parametric domain.

is_coincident(surface3d, abs_tol: float = 1e-06)

Verifies if two conical surfaces are coincident.

Parameters:

• surface3d – other surface 3d.

• abs_tol – tolerance.

Returns:

True if they are coincident, False otherwise.

is_singularity_point(point, *args, **kwargs)

Verifies if point is on the surface singularity.

line_intersections(line: Line3D)

Calculates the intersections between a conical surface and a Line 3D.

Parameters:

line – other line to verify intersections.

Returns:

a list of intersection points, if there exists any.

linesegment3d_to_2d(linesegment3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

normal_at_point(point: Point3D)

Gets normal vector at given point on the surface.

Parameters:

point – point to be verified.

Returns:

normal

parallel_conicalsurface_intersections(conical_surface)

Get Conical Surface intersections with another conical surface, when their axis are parallel.

Parameters:

conical_surface – intersecting conical surface.

Returns:

list of intersecting curves.

parallel_plane_intersection(plane3d: Plane3D)

Conical plane intersections when plane’s normal is perpendicular with the Cone’s axis.

Parameters:

plane3d – intersecting plane

Returns:

list of intersecting curves

parametric_points_to_3d(points: ndarray[Any, dtype[float64]]) → ndarray[Any, dtype[float64]]

Transform parametric coordinates to 3D points on the conical surface.

Given a set of parametric coordinates (u, v) representing points on the surface, this method returns the corresponding 3D points on the conical surface.

Parameters:

points (numpy.ndarray[np.float64]) – Parametric coordinates in the form of a numpy array with shape (n, 2), where n is the number of points, and each row corresponds to (u, v).

Returns:

Array of 3D points representing the conical surface in Cartesian coordinates.

Return type:

numpy.ndarray[np.float64]

perpendicular_plane_intersection(plane3d)

Cone plane intersections when plane’s normal is parallel with the cone axis.

Parameters:

plane3d – Intersecting plane.

Returns:

List of intersecting curves.

plane_intersections(plane3d)

Gets the intersections between a plane 3d and a conical surface 3d.

Parameters:

plane3d – other plane, to verify intersections.

Returns:

plot(ax=None, edge_style: EdgeStyle = EdgeStyle(color='grey', alpha=0.5, edge_ends=False, edge_direction=False, width=None, arrow=False, plot_points=False, dashed=True, linestyle='-', linewidth=1, equal_aspect=True), **kwargs)

Plots the ConicalSurface3D.

point2d_to_3d(point2d: Point2D)

Coverts a parametric coordinate on the surface into a 3D spatial point (x, y, z).

Parameters:

point2d (volmdlr.`Point2D) – Point at the ConicalSuface3D

point3d_to_2d(point3d: Point3D)

Returns the cylindrical coordinates volmdlr.Point2D(theta, z) of a Cartesian coordinates point (x, y, z).

Parameters:

point3d (volmdlr.`Point3D) – Point at the CylindricalSuface3D.

rectangular_cut(theta1: float, theta2: float, param_z1: float, param_z2: float, name: str = '')

Deprecated method, Use ConicalFace3D from_surface_rectangular_cut method.

rotation(center: Point3D, axis: Vector3D, angle: float)

ConicalSurface3D rotation.

Parameters:

• center – rotation center.

• axis – rotation axis.

• angle – angle rotation.

Returns:

a new rotated ConicalSurface3D.

same_apex_conicalsurface_intersections(conical_surface)

Gets Conical Surface intersections with another conical surface, sharing the same apex.

Parameters:

conical_surface – intersecting conical surface.

Returns:

list of intersecting curves.

sphericalsurface_intersections(spherical_surface: SphericalSurface3D)

Conical Surface intersections with a Spherical surface.

Parameters:

spherical_surface – intersecting sphere.

Returns:

list of intersecting curves.

to_step(current_id)

Converts the object to a STEP representation.

Parameters:

current_id (int) – The ID of the last written primitive.

Returns:

The STEP representation of the object and the last ID.

Return type:

tuple[str, list[int]]

translation(offset: Vector3D)

ConicalSurface3D translation.

Parameters:

offset – translation vector.

Returns:

A new translated ConicalSurface3D.

property u_domain

The parametric domain of the surface in the U direction.

u_iso(u: float) → Line3D

Returns the u-iso curve of the surface.

Parameters:

u (float) – The value of u where to extract the curve.

Returns:

A line 3D

Return type:

curves.Line3D

property v_domain

The parametric domain of the surface in the V direction.

v_iso(v: float) → Circle3D

Returns the v-iso curve of the surface.

Parameters:

v (float) – The value of u where to extract the curve.

Returns:

A Circle 3D

Return type:

curves.Circle3D

x_periodicity = 6.283185307179586

y_periodicity = None

class volmdlr.surfaces.CylindricalSurface3D(frame, radius: float, name: str = '')

Bases: UPeriodicalSurface

The local plane is defined by (theta, z).

Parameters:

• frame – frame.w is axis, frame.u is theta=0 frame.v theta=pi/2

• frame –

• radius (float) – Cylinder’s radius

concurrent_plane_intersection(plane3d: Plane3D)

Cylindrical plane intersections when plane’s normal is concurrent with the cone’s axis, but not orthogonal.

Parameters:

plane3d – intersecting plane.

Returns:

list of intersecting curves.

conicalsurface_intersections(conical_surface: ConicalSurface3D)

Cylinder Surface intersections with a Conical surface.

Parameters:

conical_surface – intersecting plane.

Returns:

list of intersecting curves.

cylindricalsurface_intersections(cylindricalsurface: CylindricalSurface3D)

Gets intersections between two cylindrical surfaces 3d.

Parameters:

cylindricalsurface – other cylindrical surface.

Returns:

a list containing the resulting intersections, if there are any.

face_class = 'CylindricalFace3D'

frame_mapping(frame: Frame3D, side: str)

Changes frame_mapping and return a new CylindricalSurface3D.

Parameters:

side – ‘old’ or ‘new’

classmethod from_step(arguments, object_dict, **kwargs)

Converts a step primitive to a CylindricalSurface3D.

Parameters:

• arguments (list) – The arguments of the step primitive.

• object_dict (dict) – The dictionary containing all the step primitives that have already been instantiated

Returns:

The corresponding CylindricalSurface3D object.

Return type:

volmdlr.faces.CylindricalSurface3D

get_circle_generatrices(number_circles: int = 10, length: float = 1.0)

Retrieve circles representing the generatrices of a cylinder.

Generates a specified number of circles along the surface of the cylinder, each representing a generatrix.

Parameters:

• number_circles (int) – The number of generatrices to generate. Default is 10

• length (float) – The length of the cylinder along the z-direction. Default is 1.

Returns:

A list of Circle3D instances representing the generatrices of the cylinder.

Return type:

List[Circle3D]

get_generatrices(number_lines: int = 30, length: float = 1)

Retrieve line segments representing the generatrices of a cylinder.

Generates a specified number of line segments along the surface of the cylinder, each representing a generatrix.

Parameters:

• number_lines (int) – The number of generatrices to generate. Default is 30

• length (float) – The length of the cylinder along the z-direction. Default is 1.

Returns:

A list of LineSegment3D instances representing the generatrices of the cylinder.

Return type:

List[LineSegment3D]

grid3d(grid2d: Grid2D)

Generate 3d grid points of a Cylindrical surface, based on a Grid2D.

is_coincident(surface3d, abs_tol: float = 1e-06)

Verifies if two CylindricalSurfaces are coincident.

Parameters:

• surface3d – surface to verify.

• abs_tol – tolerance.

Returns:

True if they are coincident, False otherwise.

line_intersections(line: Line3D)

Gets intersections between a line and a Cylindrical Surface 3D.

normal_at_point(point: Point3D)

Gets normal vector at given point on the surface.

Parameters:

point – point to be verified.

Returns:

normal

parallel_plane_intersection(plane3d)

Cylinder plane intersections when plane’s normal is perpendicular with the cylinder axis.

Parameters:

plane3d – intersecting plane

Returns:

list of intersecting curves

parametric_points_to_3d(points: ndarray[Any, dtype[float64]]) → ndarray[Any, dtype[float64]]

Transform parametric coordinates to 3D points on the cylindrical surface.

Given a set of parametric coordinates (u, v) representing points on the surface, this method returns the corresponding 3D points on the cylindrical surface.

Parameters:

points (numpy.ndarray[np.float64]) – Parametric coordinates in the form of a numpy array with shape (n, 2), where n is the number of points, and each row corresponds to (u, v).

Returns:

Array of 3D points representing the cylindrical surface in Cartesian coordinates.

Return type:

numpy.ndarray[np.float64]

perpendicular_plane_intersection(plane3d)

Cylinder plane intersections when plane’s normal is parallel with the cylinder axis.

Parameters:

plane3d – intersecting plane

Returns:

list of intersecting curves

plane_intersections(plane3d)

Cylinder intersections with a plane.

Parameters:

plane3d – intersecting plane.

Returns:

list of intersecting curves.

plot(ax=None, edge_style: EdgeStyle = EdgeStyle(color='grey', alpha=0.5, edge_ends=False, edge_direction=False, width=None, arrow=False, plot_points=False, dashed=True, linestyle='-', linewidth=1, equal_aspect=True), length=None, **kwargs)

Plot the cylindrical surface in the local frame normal direction.

Parameters:

• ax (Axes3D or None) – Matplotlib Axes3D object to plot on. If None, create a new figure.

• edge_style (EdgeStyle.) – edge styles.

• length (float) – plotted length

Returns:

Matplotlib Axes3D object containing the plotted wire-frame.

Return type:

Axes3D

point2d_to_3d(point2d: Point2D)

Coverts a parametric coordinate on the surface into a 3D spatial point (x, y, z).

Parameters:

point2d (volmdlr.`Point2D) – Point at the ToroidalSuface3D

point3d_to_2d(point3d)

Returns the cylindrical coordinates volmdlr.Point2D(theta, z) of a Cartesian coordinates point (x, y, z).

Parameters:

point3d (volmdlr.`Point3D) – Point at the CylindricalSuface3D

point_belongs(point3d, abs_tol: float = 1e-05)

Verifies if a given point is on the CylindricalSurface3D.

Parameters:

• point3d – Point to verify.

• abs_tol – Tolerance.

Returns:

True if point on surface, False otherwise.

rectangular_cut(theta1: float, theta2: float, param_z1: float, param_z2: float, name: str = '')

Deprecated method, Use CylindricalFace3D from_surface_rectangular_cut method.

rotation(center: Point3D, axis: Vector3D, angle: float)

CylindricalFace3D rotation.

Parameters:

• center – rotation center.

• axis – rotation axis.

• angle – angle rotation.

Returns:

a new rotated Plane3D.

sphericalsurface_intersections(spherical_surface: SphericalSurface3D)

Cylinder Surface intersections with a Spherical surface.

Parameters:

spherical_surface – intersecting sphere.

Returns:

list of intersecting curves.

to_step(current_id)

Converts the object to a STEP representation.

Parameters:

current_id (int) – The ID of the last written primitive.

Returns:

The STEP representation of the object and the last ID.

Return type:

tuple[str, list[int]]

translation(offset: Vector3D)

CylindricalFace3D translation.

Parameters:

offset – translation vector.

Returns:

A new translated CylindricalFace3D.

property u_domain

The parametric domain of the surface in the U direction.

u_iso(u: float) → Line3D

Returns the u-iso curve of the surface.

Parameters:

u (float) – The value of u where to extract the curve.

Returns:

A line 3D

Return type:

curves.Line3D

property v_domain

The parametric domain of the surface in the V direction.

v_iso(v: float) → Circle3D

Returns the v-iso curve of the surface.

Parameters:

v (float) – The value of u where to extract the curve.

Returns:

A Circle 3D

Return type:

curves.Circle3D

x_periodicity = 6.283185307179586

y_periodicity = None

class volmdlr.surfaces.ExtrusionSurface3D(edge: FullArcEllipse3D | BSplineCurve3D, direction: Vector3D, name: str = '')

Bases: Surface3D

Defines a surface of extrusion.

An extrusion surface is a surface that is a generic cylindrical surface generated by the linear extrusion of a curve, generally an Ellipse or a B-Spline curve.

Parameters:

• edge (Union[vmw.Wire3D, vmw.Contour3D]) – edge.

• axis_point (volmdlr.Point3D) – Axis placement

• axis (volmdlr.Vector3D) – Axis of extrusion

arc3d_to_2d(arc3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

arcellipse3d_to_2d(arcellipse3d)

Transformation of an arc-ellipse 3d to 2d, in a cylindrical surface.

bsplinecurve3d_to_2d(bspline_curve3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

face_class = 'ExtrusionFace3D'

frame_mapping(frame: Frame3D, side: str)

Returns a new Extrusion Surface positioned in the specified frame.

Parameters:

• frame (volmdlr.Frame3D) – Frame of reference

• side – ‘old’ or ‘new’

classmethod from_step(arguments, object_dict, **kwargs)

Creates an extrusion surface from step data.

fullarcellipse3d_to_2d(fullarcellipse3d)

Converts a 3D full elliptical arc to a 2D line segment in the current plane.

This method converts a 3D full elliptical arc to a 2D line segment in the current plane. It first calculates the length of the arc using the length method of the fullarcellipse3d object. Then, it converts the start and end points of the arc to 2D points using the point3d_to_2d method. Additionally, it calculates a point on the arc at a small abscissa value (0.01 * length) and converts it to a 2D point. Based on the relative position of this point, the method determines the start and end points of the line segment in 2D. If the abscissa point is closer to the start point, the line segment starts from (0, start.y) and ends at (length, end.y). If the abscissa point is closer to the end point, the line segment starts from (length, start.y) and ends at (0, end.y). If the abscissa point lies exactly at the midpoint of the arc, a NotImplementedError is raised. The resulting line segment is returned as a list.

Parameters:

fullarcellipse3d – The 3D full elliptical arc object to convert.

Returns:

A list containing a 2D line segment representing the converted arc.

Raises:

NotImplementedError: If the abscissa point lies exactly at the midpoint of the arc.

linesegment2d_to_3d(linesegment2d)

Converts a BREP line segment 2D onto a 3D primitive on the surface.

linesegment3d_to_2d(linesegment3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

parametric_points_to_3d(points: ndarray[Any, dtype[float64]]) → ndarray[Any, dtype[float64]]

Transform parametric coordinates to 3D points on the extrusion surface.

Given a set of parametric coordinates (u, v) representing points on the surface, this method returns the corresponding 3D points on the extrusion surface.

Parameters:

points (numpy.ndarray[np.float64]) – Parametric coordinates in the form of a numpy array with shape (n, 2), where n is the number of points, and each row corresponds to (u, v).

Returns:

Array of 3D points representing the extrusion surface in Cartesian coordinates.

Return type:

numpy.ndarray[np.float64]

plot(ax=None, edge_style: EdgeStyle = EdgeStyle(color='grey', alpha=0.5, edge_ends=False, edge_direction=False, width=None, arrow=False, plot_points=False, dashed=True, linestyle='-', linewidth=1, equal_aspect=True), z: float = 0.5, **kwargs)

Plot for extrusion surface using matplotlib.

point2d_to_3d(point2d: Point2D)

Transform a parametric (u, v) point into a 3D Cartesian point (x, y, z).

# u = [0, 1] and v = z

point3d_to_2d(point3d)

Transform a 3D Cartesian point (x, y, z) into a parametric (u, v) point.

rectangular_cut(x1: float = 0.0, x2: float = 1.0, y1: float = 0.0, y2: float = 1.0, name: str = '')

Deprecated method, Use ExtrusionFace3D from_surface_rectangular_cut method.

to_step(current_id)

Translate volmdlr primitive to step syntax.

property u_domain

The parametric domain of the surface in the U direction.

u_iso(u: float) → Line3D

Returns the u-iso curve of the surface.

Parameters:

u (float) – The value of u where to extract the curve.

Returns:

A line 3D

Return type:

curves.Line3D

property v_domain

The parametric domain of the surface in the V direction.

v_iso(v: float) → Curve

Returns the v-iso curve of the surface.

Parameters:

v (float) – The value of u where to extract the curve.

Returns:

A Curve

Return type:

curves.Curve

property x_periodicity

Returns the periodicity in x direction.

y_periodicity = None

class volmdlr.surfaces.Plane3D(frame: Frame3D, name: str = '')

Bases: Surface3D

Defines a plane 3d.

Parameters:

frame – u and v of frame describe the plane, w is the normal

angle_between_planes(plane2)

Get angle between 2 planes.

Parameters:

plane2 – the second plane.

Returns:

the angle between the two planes.

arc3d_to_2d(arc3d)

Converts primitive from 3D cartesian space to surface parametric space.

bsplinecurve2d_to_3d(bspline_curve2d)

Converts a 2D B-Spline in parametric domain into a 3D B-Spline in spatial domain.

Parameters:

bspline_curve2d (edges.BSplineCurve2D) – The B-Spline curve to perform the transformation.

Returns:

A 3D B-Spline.

Return type:

edges.BSplineCurve3D

bsplinecurve3d_to_2d(bspline_curve3d)

Converts a 3D B-Spline in spatial domain into a 2D B-Spline in parametric domain.

Parameters:

bspline_curve3d (edges.BSplineCurve3D) – The B-Spline curve to perform the transformation.

Returns:

A 2D B-Spline.

Return type:

edges.BSplineCurve2D

bsplinecurve_intersections(bspline_curve)

Calculates the intersections between a Plane 3D and a Bspline Curve 3D.

Parameters:

bspline_curve – bspline_curve to verify intersections.

Returns:

list of intersections: List[volmdlr.Point3D].

contour2d_to_3d(contour2d, return_primitives_mapping: bool = False)

Transforms a Contour2D in the parametric domain of the surface into a Contour3D in Cartesian coordinate.

Parameters:

• contour2d (wires.Contour2D) – The contour to be transformed.

• return_primitives_mapping (bool) – If True, returns a dictionary containing the correspondence between 2D and 3D primitives

Returns:

A 3D contour object.

Return type:

wires.Contour3D

contour3d_to_2d(contour3d, return_primitives_mapping: bool = False)

Transforms a Contour3D into a Contour2D in the parametric domain of the surface.

Parameters:

• contour3d (wires.Contour3D) – The contour to be transformed.

• return_primitives_mapping (bool) – If True, returns a dictionary containing the correspondence between 2D and 3D primitives

Returns:

A 2D contour object.

Return type:

wires.Contour2D

copy(deep=True, memo=None)

Creates a copy of the plane.

cylindricalsurface_intersections(cylindrical_surface: CylindricalSurface3D)

Gets intersections between plane and cylindrical surface.

Parameters:

cylindrical_surface – cylindrical surface to get intersections with.

Returns:

List containing all intersections between plane and cylindrical surface.

equation_coefficients()

Returns the a,b,c,d coefficient from equation ax+by+cz+d = 0.

face_class = 'PlaneFace3D'

frame_mapping(frame: Frame3D, side: str)

Changes frame_mapping and return a new Frame3D.

Parameters:

• frame (volmdlr.Frame3D) – Frame of reference

• side – ‘old’ or ‘new’

classmethod from_3_points(*args, name: str = '')

Point 1 is used as origin of the plane.

classmethod from_normal(point, normal, name: str = '')

Creates a Plane 3D form a point and a normal vector.

classmethod from_plane_vectors(plane_origin: Point3D, plane_x: Vector3D, plane_y: Vector3D, name: str = '')

Initializes a 3D plane object with a given plane origin and plane x and y vectors.

Parameters:

• plane_origin – A volmdlr.Point3D representing the origin of the plane.

• plane_x – A volmdlr.Vector3D representing the x-axis of the plane.

• plane_y – A volmdlr.Vector3D representing the y-axis of the plane.

• name – object’s name.

Returns:

A Plane3D object initialized from the provided plane origin and plane x and y vectors.

classmethod from_points(points, name: str = '')

Returns a 3D plane that goes through the 3 first points on the list.

Why for more than 3 points we only do some check and never raise error?

classmethod from_step(arguments, object_dict, **kwargs)

Converts a step primitive to a Plane3D.

Parameters:

• arguments (list) – The arguments of the step primitive.

• object_dict (dict) – The dictionary containing all the step primitives that have already been instantiated

Returns:

The corresponding Plane3D object.

Return type:

volmdlr.faces.Plane3D

is_coincident(plane2, abs_tol: float = 1e-06)

Verifies if two planes are parallel and coincident.

is_parallel(plane2, abs_tol: float = 1e-06)

Verifies if two planes are parallel.

line_intersections(line)

Find the intersection with a line.

Parameters:

line (edges.Line) – Line to evaluate the intersection

Returns:

ADD DESCRIPTION

Return type:

List[volmdlr.Point3D]

linesegment_intersections(linesegment3d: LineSegment3D, abs_tol: float = 1e-06) → List[Point3D]

Gets the intersections of a plane a line segment 3d.

Parameters:

• linesegment3d – other line segment.

• abs_tol – tolerance allowed.

Returns:

a list with the intersecting point.

property normal

Gets the plane normal vector.

normal_at_point(point)

Gets Normal vector at a given point on the surface.

Parameters:

point – point on the surface.

Returns:

parametric_points_to_3d(points: ndarray[Any, dtype[float64]]) → ndarray[Any, dtype[float64]]

Transform parametric coordinates to 3D points on the plane.

Given a set of parametric coordinates (u, v) representing points on the surface, this method returns the corresponding 3D points on the plane.

Parameters:

points (numpy.ndarray[np.float64]) – Parametric coordinates in the form of a numpy array with shape (n, 2), where n is the number of points, and each row corresponds to (u, v).

Returns:

Array of 3D points representing the plane in Cartesian coordinates.

Return type:

numpy.ndarray[np.float64]

classmethod plane_between_two_planes(plane1, plane2, name: str = '')

Calculates a plane between two other planes.

Parameters:

• plane1 – plane1.

• plane2 – plane2.

• name – object’s name.

Returns:

resulting plane.

plane_grid(grid_size: int, length: float = 1.0)

Plane’s grid.

plane_intersections(plane3d)

Computes intersection points between two Planes 3D.

plot(ax=None, edge_style: EdgeStyle = EdgeStyle(color='grey', alpha=1, edge_ends=False, edge_direction=False, width=None, arrow=False, plot_points=False, dashed=True, linestyle='-', linewidth=1, equal_aspect=True), length: float = 1.0, **kwargs)

Plot the cylindrical surface in the local frame normal direction.

Parameters:

• ax (Axes3D or None) – Matplotlib Axes3D object to plot on. If None, create a new figure.

• edge_style (EdgeStyle.) – edge styles.

• length (float) – plotted length

Returns:

Matplotlib Axes3D object containing the plotted wire-frame.

Return type:

Axes3D

point2d_to_3d(point2d)

Converts a 2D parametric point into a 3D point on the surface.

point3d_to_2d(point3d)

Converts a 3D point into a 2D parametric point.

point_belongs(point3d, abs_tol: float = 1e-06)

Return if the point belongs to the plane at a tolerance of 1e-6.

point_distance(point3d)

Calculates the distance of a point to plane.

Parameters:

point3d – point to verify distance.

Returns:

a float, point distance to plane.

rectangular_cut(x1: float, x2: float, y1: float, y2: float, name: str = '')

Deprecated method, Use PlaneFace3D from_surface_rectangular_cut method.

rotation(center: Point3D, axis: Vector3D, angle: float)

Plane3D rotation.

Parameters:

• center – rotation center

• axis – rotation axis

• angle – angle rotation

Returns:

a new rotated Plane3D

to_step(current_id)

Converts the object to a STEP representation.

Parameters:

current_id (int) – The ID of the last written primitive.

Returns:

The STEP representation of the object and the last ID.

Return type:

tuple[str, list[int]]

translation(offset: Vector3D)

Plane3D translation.

Parameters:

offset – translation vector

Returns:

A new translated Plane3D

u_iso(u: float) → Line3D

Returns the u-iso curve of the surface.

Parameters:

u (float) – The value of u where to extract the curve.

Returns:

A line 3D

Return type:

curves.Line3D

v_iso(v: float) → Line3D

Returns the v-iso curve of the surface.

Parameters:

v (float) – The value of u where to extract the curve.

Returns:

A line 3D

Return type:

curves.Line3D

class volmdlr.surfaces.RevolutionSurface3D(edge, axis_point: Point3D, axis: Vector3D, name: str = '')

Bases: UPeriodicalSurface

Defines a surface of revolution.

Parameters:

• edge (edges.Edge) – Edge.

• axis_point (volmdlr.Point3D) – Axis placement

• axis (volmdlr.Vector3D) – Axis of revolution

arc3d_to_2d(arc3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

bsplinecurve2d_to_3d(bspline_curve2d)

Is this right?.

property domain

Returns u and v bounds.

face_class = 'RevolutionFace3D'

frame_mapping(frame: Frame3D, side: str)

Returns a new Revolution Surface positioned in the specified frame.

Parameters:

• frame (volmdlr.Frame3D) – Frame of reference

• side – ‘old’ or ‘new’

classmethod from_step(arguments, object_dict, **kwargs)

Converts a step primitive to a RevolutionSurface3D.

Parameters:

• arguments (list) – The arguments of the step primitive.

• object_dict (dict) – The dictionary containing all the step primitives that have already been instantiated.

Returns:

The corresponding RevolutionSurface3D object.

Return type:

volmdlr.faces.RevolutionSurface3D

fullarc3d_to_2d(fullarc3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

get_singularity_lines()

Return lines that are parallel and coincident with surface singularity at parametric domain.

is_singularity_point(point, *args, **kwargs)

Returns True if the point belongs to the surface singularity and False otherwise.

linesegment2d_to_3d(linesegment2d)

Converts a BREP line segment 2D onto a 3D primitive on the surface.

parametric_points_to_3d(points: ndarray[Any, dtype[float64]]) → ndarray[Any, dtype[float64]]

Transform parametric coordinates to 3D points on the revolution surface.

Given a set of parametric coordinates (u, v) representing points on the surface, this method returns the corresponding 3D points on the revolution surface.

Parameters:

points (numpy.ndarray[np.float64]) – Parametric coordinates in the form of a numpy array with shape (n, 2), where n is the number of points, and each row corresponds to (u, v).

Returns:

Array of 3D points representing the revolution surface in Cartesian coordinates.

Return type:

numpy.ndarray[np.float64]

plot(ax=None, edge_style: EdgeStyle = EdgeStyle(color='grey', alpha=0.5, edge_ends=False, edge_direction=False, width=None, arrow=False, plot_points=False, dashed=True, linestyle='-', linewidth=1, equal_aspect=True), number_curves: int = 20, **kwargs)

Plot rotated Revolution surface generatrix.

Parameters:

• number_curves (int) – Number of curves to display.

• ax – matplotlib axis.

• edge_style – plot edge style.

point2d_to_3d(point2d: Point2D)

Transform a parametric (u, v) point into a 3D Cartesian point (x, y, z).

u = [0, 2pi] and v = [0, 1] into a

point3d_to_2d(point3d)

Transform a 3D Cartesian point (x, y, z) into a parametric (u, v) point.

rectangular_cut(x1: float, x2: float, y1: float, y2: float, name: str = '')

Deprecated method, Use RevolutionFace3D from_surface_rectangular_cut method.

rotation(center: Point3D, axis: Vector3D, angle: float)

Revolution Surface 3D rotation.

Parameters:

• center – rotation center

• axis – rotation axis

• angle – angle rotation

Returns:

a new rotated Revolution Surface 3D

simplify()

Gets the simplified version of the surface.

to_step(current_id)

Translate volmdlr primitive to step syntax.

translation(offset)

Returns a new translated Revolution Surface.

Parameters:

offset – translation vector.

u_closed()

Returns True if the surface is close in any of the u boundaries.

u_closed_lower()

Returns True if the surface is close in any of the u boundaries.

u_closed_upper()

Returns True if the surface is close in any of the u boundaries.

property u_domain

The parametric domain of the surface in the U direction.

u_iso(u: float) → Curve

Returns the u-iso curve of the surface.

Parameters:

u (float) – The value of u where to extract the curve.

Returns:

A curve

Return type:

curves.Curve

v_closed()

Returns True if the surface is close in any of the u boundaries.

property v_domain

The parametric domain of the surface in the V direction.

v_iso(v: float) → Circle3D

Returns the v-iso curve of the surface.

Parameters:

v (float) – The value of u where to extract the curve.

Returns:

A Circle 3D

Return type:

curves.Circle3D

x_periodicity = 6.283185307179586

property y_periodicity

Evaluates the periodicity of the surface in v direction.

class volmdlr.surfaces.RuledSurface3D(wire1: Wire3D, wire2: Wire3D, name: str = '')

Bases: Surface3D

Defines a ruled surface between two wires.

Parameters:

• wire1 (vmw.Wire3D) – Wire

• wire2 (wires.Wire3D) – Wire

face_class = 'RuledFace3D'

point2d_to_3d(point2d: Point2D)

Coverts a parametric coordinate on the surface into a 3D spatial point (x, y, z).

Parameters:

point2d (volmdlr.`Point2D) – Point at the ToroidalSuface3D

point3d_to_2d(point3d)

Returns the parametric coordinates volmdlr.Point2D(u, v) of a cartesian coordinates point (x, y, z).

Parameters:

point3d (volmdlr.`Point3D) – Point at the CylindricalSuface3D

rectangular_cut(x1: float, x2: float, y1: float, y2: float, name: str = '')

Deprecated method, Use RuledFace3D from_surface_rectangular_cut method.

class volmdlr.surfaces.SphericalSurface3D(frame, radius, name='')

Bases: UVPeriodicalSurface

Defines a spherical surface.

Parameters:

• frame (volmdlr.Frame3D) – Sphere’s frame to position it

• radius (float) – Sphere’s radius

arc2d_to_3d(arc2d)

Converts a BREP arc 2D onto a 3D primitive on the surface.

arc3d_to_2d(arc3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

arc3d_to_2d_any_direction(arc3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

arc3d_to_2d_any_direction_singularity(arc3d, point_singularity, half_pi)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

arc3d_to_2d_with_singularity(arc3d, start, end, singularity_points)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

arc_intersections(arc: Arc3D)

Gets intersections between an arc 3D and a SphericalSurface3D.

Parameters:

arc – other arc to search intersections with.

Returns:

list containing the intersection points.

arcellipse_intersections(arcellipse: ArcEllipse3D)

Gets intersections between an arcellipse 3D and a SphericalSurface3D.

Parameters:

arcellipse – other arcellipse to search intersections with.

Returns:

list containing the intersection points.

property bounding_box

Bounding Box for Spherical Surface 3D.

bsplinecurve2d_to_3d(bspline_curve2d)

Converts a BREP BSpline curve 2D onto a 3D primitive on the surface.

bsplinecurve3d_to_2d(bspline_curve3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

check_parametric_contour_end(primitives2d, tol)

Helper function to repair_primitives_periodicity.

circle_intersections(circle: Circle3D)

Gets intersections between a circle 3D and a SphericalSurface3D.

Parameters:

circle – other circle to search intersections with.

Returns:

list containing the intersection points.

contour2d_to_3d(contour2d, return_primitives_mapping: bool = False)

Transforms a Contour2D in the parametric domain of the surface into a Contour3D in Cartesian coordinate.

Parameters:

• contour2d (wires.Contour2D) – The contour to be transformed.

• return_primitives_mapping (bool) – If True, returns a dictionary containing the correspondence between 2D and 3D primitives

Returns:

A 3D contour object.

Return type:

wires.Contour3D

contour3d_to_2d(contour3d, return_primitives_mapping: bool = False)

Transforms a Contour3D into a Contour2D in the parametric domain of the surface.

Parameters:

• contour3d (wires.Contour3D) – The contour to be transformed.

• return_primitives_mapping (bool) – If True, returns a dictionary containing the correspondence between 2D and 3D primitives

Returns:

A 2D contour object.

Return type:

wires.Contour2D

property domain

Returns u and v bounds.

property domain_u

The parametric domain of the surface in the U direction.

property domain_v

The parametric domain of the surface in the V direction.

edge_passes_on_singularity_point(edge)

Helper function to verify id edge passes on the sphere singularity point.

ellipse_intersections(ellipse: Ellipse3D)

Gets intersections between an ellipse 3D and a SphericalSurface3D.

Parameters:

ellipse – other ellipse to search intersections with.

Returns:

list containing the intersection points.

face_class = 'SphericalFace3D'

find_edge_start_end_undefined_parametric_points(edge3d, points, points3d)

Helper function.

Uses local discretization and line intersection with the tangent line at the point just before the undefined point on the BREP of the 3D edge to find the real value of theta on the sphere parametric domain.

frame_mapping(frame: Frame3D, side: str)

Changes Spherical Surface 3D’s frame and return a new Spherical Surface 3D.

Parameters:

• frame (volmdlr.Frame3D) – Frame of reference

• side – ‘old’ or ‘new’

classmethod from_step(arguments, object_dict, **kwargs)

Converts a step primitive to a SphericalSurface3D.

Parameters:

• arguments (list) – The arguments of the step primitive.

• object_dict (dict) – The dictionary containing all the step primitives that have already been instantiated.

Returns:

The corresponding SphericalSurface3D object.

Return type:

volmdlr.faces.SphericalSurface3D

fullarc3d_to_2d(fullarc3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

fullarc_intersections(fullarc: Arc3D)

Gets intersections between a fullarc 3D and a SphericalSurface3D.

Parameters:

fullarc – other fullarc to search intersections with.

Returns:

list containing the intersection points.

fullarcellipse_intersections(fullarcellipse: FullArcEllipse3D)

Gets intersections between a full arcellipse 3D and a SphericalSurface3D.

Parameters:

fullarcellipse – other full arcellipse to search intersections with.

Returns:

list containing the intersection points.

get_circle_at_z(z_position: float)

Gets a circle on the sphere at given z position < radius.

Parameters:

z_position – circle’s z position.

Returns:

circle 3D at given z position.

helper_arc3d_to_2d_with_singularity(arc3d, start, end, point_singularity, half_pi)

Helper function to arc3d_to_2d_with_singularity.

is_lat_long_curve(arc)

Checks if a curve defined on the sphere is a latitude/longitude curve.

Returns True if it is, False otherwise.

is_point2d_on_sphere_singularity(point2d, tol=1e-05)

Verifies if point is on the spherical singularity point on parametric domain.

is_point3d_on_sphere_singularity(point3d)

Verifies if point is on the spherical singularity point on parametric domain.

is_singularity_point(point, *args, **kwargs)

Verifies if point is on the surface singularity.

line_intersections(line: Line3D)

Calculates the intersection points between a 3D line and a spherical surface.

The method calculates the intersection points between a 3D line and a sphere using the equation of the line and the equation of the sphere. It returns a list of intersection points, which can be empty if there are no intersections. The intersection points are represented as 3D points using the volmdlr.Point3D class.

Parameters:

line – The 3D line object to intersect with the sphere.

:type line:curves.Line3D :return: A list of intersection points between the line and the sphere. The list may be empty if there are no intersections. :rtype: List[volmdlr.Point3D]

Example:

>>> from volmdlr import Point3D, edges, surfaces, OXYZ
>>> spherical_surface3d = SphericalSurface3D(OXYZ, 1)
>>> line2 = curves.Line3D(Point3D(0, 1, -0.5), Point3D(0, 1, 0.5))
>>> line_intersections2 = spherical_surface3d.line_intersections(line2) #returns [Point3D(0.0, 1.0, 0.0)]

normal_at_point(point: Point3D)

Gets normal vector at given point on the surface.

Parameters:

point – point to be verified.

Returns:

normal

parametric_points_to_3d(points: ndarray[Any, dtype[float64]]) → ndarray[Any, dtype[float64]]

Transform parametric coordinates to 3D points on the spherical surface.

Given a set of parametric coordinates (u, v) representing points on the surface, this method returns the corresponding 3D points on the spherical surface.

Parameters:

points (numpy.ndarray[np.float64]) – Parametric coordinates in the form of a numpy array with shape (n, 2), where n is the number of points, and each row corresponds to (u, v).

Returns:

Array of 3D points representing the spherical surface in Cartesian coordinates.

Return type:

numpy.ndarray[np.float64]

plane_intersections(plane3d)

Sphere intersections with a plane.

Parameters:

plane3d – intersecting plane.

Returns:

list of intersecting curves.

plot(ax=None, edge_style: EdgeStyle = EdgeStyle(color='grey', alpha=0.5, edge_ends=False, edge_direction=False, width=None, arrow=False, plot_points=False, dashed=True, linestyle='-', linewidth=1, equal_aspect=True), **kwargs)

Plot sphere arcs.

point2d_to_3d(point2d)

Coverts a parametric coordinate on the surface into a 3D spatial point (x, y, z).

source: https://mathcurve.com/surfaces/sphere # -pi<theta<pi, -pi/2<phi<pi/2

Parameters:

point2d (volmdlr.`Point2D) – Point at the CylindricalSuface3D.

point3d_to_2d(point3d)

Transform a 3D spatial point (x, y, z) into a 2D spherical parametric point (theta, phi).

rectangular_cut(theta1, theta2, phi1, phi2, name='')

Deprecated method, Use ShericalFace3D from_surface_rectangular_cut method.

rotation(center: Point3D, axis: Vector3D, angle: float)

Spherical Surface 3D rotation.

Parameters:

• center – rotation center

• axis – rotation axis

• angle – angle rotation

Returns:

a new rotated Spherical Surface 3D

sphericalsurface_intersections(spherical_surface: SphericalSurface3D)

Cylinder Surface intersections with a Spherical surface.

Parameters:

spherical_surface – intersecting sphere.

Returns:

list of intersecting curves.

to_step(current_id)

Converts the object to a STEP representation.

Parameters:

current_id (int) – The ID of the last written primitive.

Returns:

The STEP representation of the object and the last ID.

Return type:

tuple[str, list[int]]

translation(offset: Vector3D)

Spherical Surface 3D translation.

Parameters:

offset – translation vector

Returns:

A new translated Spherical Surface 3D

triangulation()

Triangulation of Spherical Surface.

u_iso(u: float) → Circle3D

Returns the u-iso curve of the surface.

Parameters:

u (float) – The value of u where to extract the curve.

Returns:

A circle 3D

Return type:

curves.Circle3D

v_iso(v: float) → Circle3D

Returns the v-iso curve of the surface.

Parameters:

v (float) – The value of u where to extract the curve.

Returns:

A Circle 3D

Return type:

curves.Circle3D

x_periodicity = 6.283185307179586

y_periodicity = 3.141592653589793

class volmdlr.surfaces.Surface2D(outer_contour: Contour2D, inner_contours: List[Contour2D], name: str = 'name')

Bases: PhysicalObject

A surface bounded by an outer contour.

area()

Computes the area of the surface.

axial_symmetry(line)

Finds out the symmetric 2D surface according to a line.

bounding_rectangle()

Returns bounding rectangle.

Returns:

Returns a python object with useful methods

Return type:

:class:`volmdlr.core.BoundingRectangle

center_of_mass()

Compute the center of mass of the 2D surface.

Returns:

The center of mass of the surface.

Return type:

volmdlr.Point2D

copy(deep=True, memo=None)

Copies the surface2d.

cut_by_line(line: Line2D)

Returns a list of cut Surface2D by the given line.

Parameters:

line (curves.Line2D) – The line to cut the Surface2D with.

Returns:

A list of 2D surfaces resulting from the cut.

Return type:

List[volmdlr.faces.Surface2D]

frame_mapping(frame: Frame2D, side: str)

Frame mapping of a surface 2d.

classmethod from_contours(outer_contour, inner_contours)

Create a Surface2D object from an outer contour and a list of inner contours.

Parameters:

• outer_contour (wires.Contour2D) – The outer contour that bounds the surface.

• inner_contours – The list of inner contours that define the holes of the surface.

:type inner_contours : List[wires.Contour2D] :return: Surface2D defined by the given contours.

geo_lines()

Gets the lines that define a Surface2D in a .geo file.

static get_mesh_lines_with_transfinite_curves(lists_contours, min_points, size)

Gets Surface 2d mesh lines with transfinite curves.

line_crossings(line: Line2D)

Find intersection points between a line and the 2D surface.

Parameters:

line (curves.Line2D) – The line to intersect with the shape.

Returns:

A list of intersection points sorted by increasing abscissa along the line. Each intersection point is a tuple (point, primitive) where point is the intersection point and primitive is the intersected primitive.

Return type:

List[Tuple[volmdlr.Point2D, volmdlr.core.Primitive2D]]

mesh_lines(factor: float, curvature_mesh_size: int | None = None, min_points: int | None = None, initial_mesh_size: float = 5)

Gets the lines that define mesh parameters for a Surface2D, to be added to a .geo file.

Parameters:

factor – A float, between 0 and 1, that describes the mesh quality

(1 for coarse mesh - 0 for fine mesh) :type factor: float :param curvature_mesh_size: Activate the calculation of mesh element sizes based on curvature (with curvature_mesh_size elements per 2*Pi radians), defaults to 0 :type curvature_mesh_size: int, optional :param min_points: Check if there are enough points on small edges (if it is not, we force to have min_points on that edge), defaults to None :type min_points: int, optional :param initial_mesh_size: If factor=1, it will be initial_mesh_size elements per dimension, defaults to 5 :type initial_mesh_size: float, optional

Returns:

A list of lines that describe mesh parameters

Return type:

List[str]

plot(ax=None, edge_style: EdgeStyle = EdgeStyle(color='grey', alpha=0.5, edge_ends=False, edge_direction=False, width=None, arrow=False, plot_points=False, dashed=True, linestyle='-', linewidth=1, equal_aspect=False), **kwargs)

Plot surface 2d using Matplotlib.

point_belongs(point2d: Point2D, include_edge_points: bool = True)

Check whether a point belongs to the 2D surface.

Parameters:

point2d (volmdlr.Point2D) – The point to check.

Returns:

True if the point belongs to the surface, False otherwise.

Return type:

bool

random_point_inside()

Generate a random point inside the 2D surface.

Taking into account any inner contours (holes) it may have.

Returns:

A random point inside the surface.

Return type:

volmdlr.Point2D

rotation(center, angle)

Surface2D rotation.

Parameters:

• center – rotation center.

• angle – angle rotation.

Returns:

a new rotated Surface2D.

second_moment_area(point: Point2D)

Computes the second moment area of the surface.

split_at_centers()

Split in n slices.

# TODO: is this used ?

split_by_lines(lines)

Returns a list of cut surfaces given by the lines provided as argument.

split_regularly(n)

Split in n slices.

to_geo(file_name: str, factor: float, **kwargs)

Gets the .geo file for the Surface2D.

to_msh(file_name: str, mesh_dimension: int, mesh_order: int, factor: float, **kwargs)

Gets .msh file for the Surface2D generated by gmsh.

Parameters:

• file_name (str) – The msh. file name

• mesh_dimension (int) – The mesh dimension (1: 1D-Edge, 2: 2D-Triangle, 3D-Tetrahedra)

• factor – A float, between 0 and 1, that describes the mesh quality

(1 for coarse mesh - 0 for fine mesh) :type factor: float :param curvature_mesh_size: Activate the calculation of mesh element sizes based on curvature (with curvature_mesh_size elements per 2*Pi radians), defaults to 0 :type curvature_mesh_size: int, optional :param min_points: Check if there are enough points on small edges (if it is not, we force to have min_points on that edge), defaults to None :type min_points: int, optional :param initial_mesh_size: If factor=1, it will be initial_mesh_size elements per dimension, defaults to 5 :type initial_mesh_size: float, optional

Returns:

A txt file

Return type:

.txt

translation(offset: Vector2D)

Surface2D translation.

Parameters:

offset – translation vector.

Returns:

A new translated Surface2D.

triangulation(number_points_x: int = 15, number_points_y: int = 15)

Triangulates the Surface2D using the Triangle library.

Parameters:

• number_points_x (int) – Number of discretization points in x direction.

• number_points_y (int) – Number of discretization points in y direction.

Returns:

The triangulated surface as a display mesh.

Return type:

volmdlr.display.Mesh2D

static triangulation_without_holes(vertices, segments, points_grid, tri_opt)

Triangulates a surface without holes.

Parameters:

• vertices – vertices of the surface.

• segments – segments defined as tuples of vertices.

• points_grid – to do.

• tri_opt – triangulation option: “p”

Returns:

class volmdlr.surfaces.Surface3D(frame: Frame3D | None = None, name: str = '')

Bases: DessiaObject

Abstract class.

arc_intersections(arc3d: Arc3D)

Calculates the intersections between a conical surface and an arc 3D.

Parameters:

arc3d – other arc to verify intersections.

Returns:

a list of intersection points, if there exists any.

arcellipse_intersections(arcellipse: ArcEllipse3D)

Calculates the intersections between a conical surface and an arcellipse 3D.

Parameters:

arcellipse – other arcellipse to verify intersections.

Returns:

a list of intersection points, if there exists any.

brep_connectivity_check(brep: Contour2D, tol: float = 1e-06) → bool

Checks the topology of 2D BREP in 3D space.

bsplinecurve2d_to_3d(bspline_curve2d)

Is this right?.

bsplinecurve3d_to_2d(bspline_curve3d)

Is this right?.

check_parametric_contour_end(primitives2d, tol)

Helper function to repair_primitives_periodicity.

circle_intersections(circle: Circle3D)

Calculates the intersections between a surface 3d and a Circle 3D.

Parameters:

circle – other circle to verify intersections.

Returns:

a list of intersection points, if there exists any.

connect_contours(outer_contour, inner_contours)

Abstract method. Repair 2D contours of a face on the parametric domain.

Parameters:

• outer_contour – Outer contour 2D.

• inner_contours (list) – List of 2D contours.

Returns:

NotImplementedError: If the method is not implemented in the subclass.

contour2d_to_3d(contour2d, return_primitives_mapping: bool = False)

Transforms a Contour2D in the parametric domain of the surface into a Contour3D in Cartesian coordinate.

Parameters:

• contour2d (wires.Contour2D) – The contour to be transformed.

• return_primitives_mapping (bool) – If True, returns a dictionary containing the correspondence between 2D and 3D primitives

Returns:

A 3D contour object.

Return type:

wires.Contour3D

contour3d_to_2d(contour3d, return_primitives_mapping: bool = False)

Transforms a Contour3D into a Contour2D in the parametric domain of the surface.

Parameters:

• contour3d (wires.Contour3D) – The contour to be transformed.

• return_primitives_mapping (bool) – If True, returns a dictionary containing the correspondence between 2D and 3D primitives

Returns:

A 2D contour object.

Return type:

wires.Contour2D

contour_intersections(contour3d: Contour3D)

Gets intersections between a contour 3D and a Surface 3D.

Parameters:

contour3d – other contour get intersections with.

Returns:

list of intersecting points.

curve_intersections(curve)

Calculates the intersections between a conical surface and a curve 3D.

Parameters:

curve – other circle to verify intersections.

Returns:

a list of intersection points, if there exists any.

property domain

Returns u and v bounds.

edge_intersections(edge)

Gets intersections between a Surface 3D, and an edge 3D.

Parameters:

edge – any 3D edge.

Returns:

list of points.

ellipse_intersections(ellipse: Ellipse3D)

Calculates the intersections between a conical surface and an ellipse 3D.

Parameters:

ellipse – other ellipse to verify intersections.

Returns:

a list of intersection points, if there exists any.

face_class = None

face_from_contours3d(contours3d: List[Contour3D], name: str = '')

Deprecated method, ‘Use Face3D from_contours3d method’.

frame_mapping(frame, side: str)

Frame mapping for Surface 3D.

fullarc_intersections(fullarc: FullArc3D)

Calculates the intersections between a conical surface and a full arc 3D.

Parameters:

fullarc – other fullarc to verify intersections.

Returns:

a list of intersection points, if there exists any.

fullarcellipse_intersections(fullarcellipse: FullArcEllipse3D)

Calculates the intersections between a conical surface and a fullarcellipse 3D.

Parameters:

fullarcellipse – other fullarcellipse to verify intersections.

Returns:

a list of intersection points, if there exists any.

geodesic_distance(point1_3d: Point3D, point2_3d: Point3D)

Approximation of geodesic distance between 2 3D points supposed to be on the surface.

geodesic_distance_from_points2d(point1_2d: Point2D, point2_2d: Point2D, number_points: int = 50)

Approximation of geodesic distance via line segments length sum in 3D.

hyperbola_intersections(hyperbola: Hyperbola3D)

Calculates the intersections between a conical surface and a hyperbola 3D.

Parameters:

hyperbola – other hyperbola to verify intersections.

Returns:

a list of intersection points, if there exists any.

is_degenerated_brep(*args)

An edge is said to be degenerated when it corresponds to a single 3D point.

is_singularity_point(*args, **kwargs)

Verifies if point is on the surface singularity.

static is_undefined_brep(*args)

Verifies if the edge is contained within the periodicity boundary.

line_intersections(line: Line3D)

Gets intersections between a line and a Surface 3D.

linesegment3d_to_2d(linesegment3d)

A line segment on a surface will be in any case a line in 2D?.

linesegment_intersections(linesegment3d: LineSegment3D, abs_tol: float = 1e-06)

Calculates the intersection points between a 3D line segment and a surface 3D.

The method calculates the intersection points between a 3D line segment and a 3d Surface by first finding the intersection points between the infinite line containing the line segment and the Surface, and then filtering out the points that are not within the line segment. It returns a list of intersection points, which can be empty if there are no intersections. The intersection points are represented as 3D points using the volmdlr.Point3D class. Note: The method assumes that the line segment and the Surface are in the same coordinate system.

Parameters:

• linesegment3d (edges.LineSegment3D.) – The 3D line segment object to intersect with the Surface.

• abs_tol (float.) – tolerance.

Returns:

A list of intersection points between the line segment and the Surface.

The list may be empty if there are no intersections. :rtype: List[volmdlr.Point3D]:

normal_from_point2d(point2d)

Evaluates the normal vector of the bspline surface at this 2D point.

normal_from_point3d(point3d)

Evaluates the normal vector of the bspline surface at this 3D point.

parabola_intersections(parabola: Parabola3D)

Calculates the intersections between a conical surface and a parabola 3D.

Parameters:

parabola – other parabola to verify intersections.

Returns:

a list of intersection points, if there exists any.

parametric_points_to_3d(points: ndarray[Any, dtype[float64]]) → ndarray[Any, dtype[float64]]

Transform parametric coordinates to 3D points on the surface.

Given a set of parametric coordinates (u, v) representing points on the surface, this method returns the corresponding 3D points on the surface.

Parameters:

points (numpy.ndarray[np.float64]) – Parametric coordinates in the form of a numpy array with shape (n, 2), where n is the number of points, and each row corresponds to (u, v).

Returns:

Array of 3D points representing the surface in Cartesian coordinates.

Return type:

numpy.ndarray[np.float64]

plane_intersections(plane3d: Plane3D)

Gets intersections between a line and a Surface 3D.

plot(ax=None, edge_style: EdgeStyle = EdgeStyle(color='grey', alpha=0.5, edge_ends=False, edge_direction=False, width=None, arrow=False, plot_points=False, dashed=True, linestyle='-', linewidth=1, equal_aspect=True), **kwargs)

Abstract method.

point2d_to_3d(point2d)

Abstract method.

point3d_to_2d(point3d)

Abstract method. Convert a 3D point to a 2D parametric point.

Parameters:

point3d (volmdlr.Point3D) – The 3D point to convert, represented by 3 coordinates (x, y, z).

Returns:

NotImplementedError: If the method is not implemented in the subclass.

point_belongs(point3d, abs_tol: float = 1e-06)

Verifies if point is on Toroidal Surface 3D.

Parameters:

• point3d – other point.

• abs_tol – tolerance.

Returns:

True or False.

point_distance(point3d: Point3D)

Calculates the minimal distance from a given point and the surface.

Parameters:

point3d (volmdlr.Point3D) – point to verify distance.

Returns:

point distance to the surface.

Return type:

float

point_projection(point3d)

Returns the projection of the point on the surface.

Parameters:

point3d (volmdlr.Point3D) – Point to project.

Returns:

A point on the surface

Return type:

volmdlr.Point3D

primitives3d_to_2d(primitives3d)

Helper function to perform conversion of 3D primitives into B-Rep primitives.

Parameters:

primitives3d (List[edges.Edge]) – List of 3D primitives from a 3D contour.

Returns:

A list of 2D primitives on parametric domain.

Return type:

List[edges.Edge]

repair_primitives_periodicity(primitives2d, primitives_mapping)

Repairs the continuity of the 2D contour while using contour3d_to_2d on periodic surfaces.

Parameters:

• primitives2d (list) – The primitives in parametric surface domain.

• primitives_mapping (dict) – It is a dictionary that stores the correspondence between primitives in the parametric domain with their equivalent primitive in 3D space.

Returns:

A list of primitives.

Return type:

list

static repair_reverse(primitives2d, primitives_mapping, i)

Helper function to repair_primitives_periodicity.

static repair_singularity(primitives2d, i, previous_primitive)

Helper function to repair_primitives_periodicity.

static repair_translation(primitives2d, primitives_mapping, i, delta)

Helper function to repair_primitives_periodicity.

surface_intersections(other_surface: Surface3D)

Gets intersections between two surfaces.

Parameters:

other_surface – other surface to get intersections with.

Returns:

a list containing all intersections between the two surfaces 3d.

property u_domain

The parametric domain of the surface in the U direction.

static update_primitives_mapping(primitives_mapping, primitives, primitive3d)

Helper function to contour3d_to_2d.

property v_domain

The parametric domain of the surface in the V direction.

x_periodicity = None

y_periodicity = None

class volmdlr.surfaces.ToroidalSurface3D(frame: Frame3D, major_radius: float, minor_radius: float, name: str = '')

Bases: UVPeriodicalSurface

The local plane is defined by (theta, phi).

Theta is the angle around the big (R) circle and phi around the small (r).

Parameters:

• frame – Tore’s frame: origin is the center, u is pointing at theta=0.

• major_radius – Tore’s radius.

• r – Circle to revolute radius.

See Also Definitions of R and r according to https://en.wikipedia.org/wiki/Torus.

arc3d_to_2d(arc3d)

Converts the arc from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

property bounding_box

Returns the surface bounding box.

bsplinecurve2d_to_3d(bspline_curve2d)

Converts the parametric boundary representation into a 3D primitive.

bsplinecurve3d_to_2d(bspline_curve3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

circle_intersections(circle: Circle3D)

Calculates the intersections between a toroidal surface 3d and a Circle 3D.

Parameters:

circle – other circle to verify intersections.

Returns:

a list of intersection points, if there exists any.

concurrent_plane_intersection(plane3d, number_curves: int | None = None)

Toroidal plane intersections when plane’s normal is concurrent with the cone’s axis, but not orthogonal.

Parameters:

• plane3d – intersecting plane.

• number_curves – the number of resulting curves, if known.

Returns:

list of intersecting curves.

conicalsurface_intersections(conical_surface: ConicalSurface3D)

Gets the intersections between a toroidal surface and cylindrical surface.

Parameters:

conical_surface – other Conical Surface 3d.

Returns:

List os curves intersecting Torus.

cylindricalsurface_intersections(cylindrical_surface: CylindricalSurface3D)

Gets the intersections between a toroidal surface and cylindrical surface.

Parameters:

cylindrical_surface – other cylindrical surface.

Returns:

List os curves intersecting Torus.

classmethod dict_to_object(dict_: Dict[str, Any], **kwargs) → ToroidalSurface3D

Creates a ToroidalSurface3D from a dictionary.

face_class = 'ToroidalFace3D'

frame_mapping(frame: Frame3D, side: str)

Changes frame_mapping and return a new ToroidalSurface3D.

Parameters:

• frame (`volmdlr.Frame3D) – The new frame to map to.

• side (str) – Indicates whether the frame should be mapped to the ‘old’ or ‘new’ frame. Acceptable values are ‘old’ or ‘new’.

classmethod from_step(arguments, object_dict, **kwargs)

Converts a step primitive to a ToroidalSurface3D.

Parameters:

• arguments (list) – The arguments of the step primitive.

• object_dict (dict) – The dictionary containing all the step primitives that have already been instantiated.

Returns:

The corresponding ToroidalSurface3D object.

Return type:

volmdlr.faces.ToroidalSurface3D

fullarc3d_to_2d(fullarc3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

get_villarceau_circles(plane3d)

The concurrent intersecting plane touches the torus in two isolated points.

Parameters:

plane3d – concurrent plane.

Returns:

two circles.

property inner_radius

Get torus inner radius.

is_coincident(surface3d, abs_tol: float = 1e-06)

Verifies if two ToroidalSurfaces are coincident.

Parameters:

• surface3d – surface to verify.

• abs_tol – tolerance.

Returns:

True if they are coincident, False otherwise.

line_intersections(line: Line3D)

Calculates the intersections between the toroidal surface and an infinite line.

Parameters:

line – other line.

Returns:

intersections.

normal_at_point(point: Point3D)

Gets normal vector at given point on the surface.

Parameters:

point – point to be verified.

Returns:

normal

property outer_radius

Get torus outer radius.

outer_radius_tangent_inner_radius_toroidalsurface_intersections(toroidal_surface)

Calculates the intersections between two toroidal surfaces.

Case where the outer radius of one toroidal surface is touching inner radius of the other toroidal surface.

Parameters:

toroidal_surface – other toroidal surface.

Returns:

parallel_plane_intersection(plane3d: Plane3D)

Toroidal plane intersections when plane’s normal is perpendicular with the cylinder axis.

Parameters:

plane3d – intersecting plane.

Returns:

list of intersecting curves.

parametric_points_to_3d(points: ndarray[Any, dtype[float64]]) → ndarray[Any, dtype[float64]]

Transform parametric coordinates to 3D points on the toroidal surface.

Given a set of parametric coordinates (u, v) representing points on the surface, this method returns the corresponding 3D points on the toroidal surface.

Parameters:

points (numpy.ndarray[np.float64]) – Parametric coordinates in the form of a numpy array with shape (n, 2), where n is the number of points, and each row corresponds to (u, v).

Returns:

Array of 3D points representing the toroidal surface in Cartesian coordinates.

Return type:

numpy.ndarray[np.float64]

perpendicular_plane_intersection(plane3d)

Toroidal plane intersections when plane’s normal is parallel with the cylinder axis.

Parameters:

plane3d – intersecting plane.

Returns:

list of intersecting curves.

plane_intersections(plane3d)

Toroidal intersections with a plane.

Parameters:

plane3d – intersecting plane.

Returns:

list of intersecting curves.

plot(ax=None, edge_style: EdgeStyle = EdgeStyle(color='grey', alpha=0.5, edge_ends=False, edge_direction=False, width=None, arrow=False, plot_points=False, dashed=True, linestyle='-', linewidth=1, equal_aspect=True), **kwargs)

Plot torus arcs.

point2d_to_3d(point2d: Point2D)

Coverts a parametric coordinate on the surface into a 3D spatial point (x, y, z).

Parameters:

point2d (volmdlr.`Point2D) – Point at the ToroidalSuface3D

point3d_to_2d(point3d)

Transform a 3D spatial point (x, y, z) into a 2D spherical parametric point (theta, phi).

point_projection(point3d)

Returns the projection of the point on the toroidal surface.

Parameters:

point3d (volmdlr.Point3D) – Point to project.

Returns:

A point on the surface

Return type:

volmdlr.Point3D

rectangular_cut(theta1: float, theta2: float, phi1: float, phi2: float, name: str = '')

Deprecated method, Use ToroidalFace3D from_surface_rectangular_cut method.

rotation(center: Point3D, axis: Vector3D, angle: float)

ToroidalSurface3D rotation.

Parameters:

• center – rotation center.

• axis – rotation axis.

• angle – angle rotation.

Returns:

a new rotated ToroidalSurface3D.

sphericalsurface_intersections(spherical_surface: SphericalSurface3D)

Gets the intersections between a toroidal surface and spherical surface.

Parameters:

spherical_surface – other spherical Surface 3d.

Returns:

List os curves intersecting Torus.

to_step(current_id)

Converts the object to a STEP representation.

Parameters:

current_id (int) – The ID of the last written primitive.

Returns:

The STEP representation of the object and the last ID.

Return type:

tuple[str, list[int]]

toroidalsurface_intersections(toroidal_surface)

Gets the intersections between two toroidal surface.

Parameters:

toroidal_surface – other toroidal Surface 3d.

Returns:

List os curves intersecting Torus.

toroidalsurface_intersections_profile_profile(toroidal_surface)

Get intersections between two parallel toroidal surfaces, if there are any.

Parameters:

toroidal_surface – other toroidal surface.

Returns:

torus_arcs(number_arcs: int = 50)

Retrieve torus arcs representing the generatrices of a Torus.

Parameters:

number_arcs (int) – The number of generatrices to generate. Default is 30

Returns:

A list of Circle3D instances representing the generatrices of the torus.

Return type:

List[Circle3D]

translation(offset: Vector3D)

ToroidalSurface3D translation.

Parameters:

offset – translation vector

Returns:

A new translated ToroidalSurface3D

triangulation()

Triangulation.

Return type:

display.Mesh3D

property u_domain

The parametric domain of the surface in the U direction.

u_iso(u: float) → Circle3D

Returns the u-iso curve of the surface.

Parameters:

u (float) – The value of u where to extract the curve.

Returns:

A circle 3D

Return type:

curves.Circle3D

property v_domain

The parametric domain of the surface in the V direction.

v_iso(v: float) → Circle3D

Returns the v-iso curve of the surface.

Parameters:

v (float) – The value of u where to extract the curve.

Returns:

A Circle 3D

Return type:

curves.Circle3D

x_periodicity = 6.283185307179586

y_periodicity = 6.283185307179586

class volmdlr.surfaces.UPeriodicalSurface(frame: Frame3D | None = None, name: str = '')

Bases: Surface3D

Abstract class for surfaces with two-pi periodicity that creates some problems.

arc3d_to_2d(arc3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

The BREP of an arc of circle on a cylindrical or a conical surface is a horizontal line segment.

arcellipse3d_to_2d(arcellipse3d)

Transformation of a 3D arc of ellipse to a 2D primitive in a cylindrical surface.

bsplinecurve2d_to_3d(bspline_curve2d)

Is this right?.

bsplinecurve3d_to_2d(bspline_curve3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

connect_contours(outer_contour, inner_contours)

Repair contours on parametric domain.

Parameters:

• outer_contour – Outer contour 2D.

• inner_contours (list) – List of 2D contours.

fix_undefined_brep_with_neighbors(edge, previous_edge, next_edge)

Uses neighbors edges to fix edge contained within the periodicity boundary.

fullarc3d_to_2d(fullarc3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

The BREP of a circle on a cylindrical or a conical surface is a horizontal line segment with length of two pi.

fullarcellipse3d_to_2d(fullarcellipse3d)

Transformation of a 3D arc ellipse to 2D, in a cylindrical surface.

is_degenerated_brep(*args)

An edge is said to be degenerated when it corresponds to a single 3D point.

static is_undefined_brep(edge)

Returns True if the edge is contained within the periodicity boundary.

linesegment2d_to_3d(linesegment2d)

Converts a BREP line segment 2D onto a 3D primitive on the surface.

linesegment3d_to_2d(linesegment3d)

Converts the primitive from 3D spatial coordinates to its equivalent 2D primitive in the parametric space.

For cylindrical or conical surfaces, a line segment in 3D space is typically projected onto the 2D parametric space as a vertical line segment. This is because a 3D line that lies on a cylindrical or conical surface corresponds to a generatrix of the surface, and it extends along the height of the surface without bending or deviating in the other directions. Therefore, the BREP of a line segment on cylindrical or conical surface is a vertical line segment.

point2d_to_3d(point2d)

Abstract method.

point3d_to_2d(point3d)

Abstract method. Convert a 3D point to a 2D parametric point.

Parameters:

point3d (volmdlr.Point3D) – The 3D point to convert, represented by 3 coordinates (x, y, z).

Returns:

NotImplementedError: If the method is not implemented in the subclass.

v_iso(v)

Abstract method.

class volmdlr.surfaces.UVPeriodicalSurface(frame: Frame3D | None = None, name: str = '')

Bases: UPeriodicalSurface

Abstract class for surfaces with two-pi periodicity in both u and v parametric directions.

linesegment2d_to_3d(linesegment2d)

Converts the parametric boundary representation into a 3D primitive.

point2d_to_3d(point2d)

Abstract method.

point3d_to_2d(point3d)

Abstract method. Convert a 3D point to a 2D parametric point.

Parameters:

point3d (volmdlr.Point3D) – The 3D point to convert, represented by 3 coordinates (x, y, z).

Returns:

NotImplementedError: If the method is not implemented in the subclass.

u_iso(u)

Abstract method.

v_iso(v)

Abstract method.

volmdlr.surfaces.knots_vector_inv(knots_vector)

Compute knot-elements and multiplicities based on the global knot vector.