/// Boundary Representation. A surface or polysurface along with trim curve information.
Constructors
Properties
Parameter space trimming curves (used by trims)
Disposed
Indicates if this object has been disposed or the document it originally belonged to has been disposed.
HasBrepForm
Returns true if the Brep.TryConvertBrep function will be successful for this object
Returns true if the Brep has region topology information, false otherwise.
HasUserData
Gets true if this class has any custom information attached to it through UserData.
IsDeformable
true if object can be accurately modified with "squishy" transformations like projections, shears, and non-uniform scaling.
IsDocumentControlled
If true this object may not be modified. Any properties or functions that attempt to modify this object when it is set to "IsReadOnly" will throw a NotSupportedException.
Overrides: CommonObject.IsDocumentControlled
Gets a value indicating whether or not the Brep is manifold. Non manifold breps have at least one edge that is shared among three or more faces.
IsShallowDuplicate
Is this instance a 'shallow copy'. Shallow copies are no different than regular instances with the exception that they will convert to complete independent 'deep' copies if a non const operation is perform on the instance (something that mutates the internal data)
Determines whether this brep is a solid, or a closed oriented manifold.
Returns true if the Brep has a single face and that face is geometrically the same as the underlying surface. I.e., the face has trivial trimming.
In this case, the surface is the first face surface. The flag Brep.Faces[0].OrientationIsReversed records the correspondence between the surface's natural parametric orientation and the orientation of the Brep.
trivial trimming here means that there is only one loop curve in the brep and that loop curve is the same as the underlying surface boundary.
ObjectType
Useful for switch statements that need to differentiate between basic object types like points, curves, surfaces, and so on.
Gets the solid orientation state of this Brep.
UserData
List of custom information that is attached to this class.
UserDictionary
Dictionary of custom information attached to this class. The dictionary is actually user data provided as an easy to use shareable set of information.
Methods
Add a 3d curve used by the brep edges
Returns: Index used to reference this geometry in the edge curve list
Adds a 3D surface used by BrepFace.
Returns: Index that should be used to reference the geometry.
-1 is returned if the input is not acceptable.
Add a 2d curve used by the brep trims
Returns: Index used to reference this geometry in the trimming curve list
Appends a copy of another brep to this and updates indices of appended brep parts. Duplicates are not removed
Returns a new Brep that is equivalent to this Brep with all planar holes capped.
Returns: New brep on success. null on error.
Change the seam of a closed trimmed surface.
public static Brep ChangeSeam()
face,
A Brep face with a closed underlying surface.
direction,
The parameter direction (0 = U, 1 = V). The face's underlying surface must be closed in this direction.
parameter,
The parameter at which to place the seam.
tolerance
Tolerance used to cut up surface.
Returns: A new Brep that has the same geometry as the face with a relocated seam if successful, or null on failure.
Finds a point on the Brep that is closest to testPoint. The method searches all Brep faces looking for the one closest to testPoint. When found, if the closest point falls on the inactive region of the face, then the method finds the face's edge that is closest to testPoint.
[ConstOperation]
public bool ClosestPoint()
testPoint,
Base point to project to surface.
out Point3d
closestPoint,
Location of the closest Brep point.
out ComponentIndex
ci,
Component index of the Brep component that contains the closest point. Possible component index types are ComponentIndexType.BrepEdge and ComponentIndexType.BrepFace.
out double
s,
If ci.ComponentIndexType == ComponentIndexType.BrepEdge, then s is the parameter of the closest edge point.
out double
t,
If ci.ComponentIndexType == ComponentIndexType.BrepFace, then (s,t) is the parameter of the closest face point.
maximumDistance,
If maximumDistance > 0, then only points whose distance is <= maximumDistance will be returned. Using a positive value of maximumDistance can substantially speed up the search.
out Vector3d
normal
If ci.ComponentIndexType == ComponentIndexType.BrepEdge, then this is the tangent to the edge at s. If ci.ComponentIndexType == ComponentIndexType.BrepFace, then this is the normal to the face at (s,t).
Returns: true if the operation succeeded, false otherwise.
Finds a point on the brep that is closest to testPoint.
Returns: The point on the Brep closest to testPoint or Point3d.Unset if the operation failed.
Deletes any unreferenced objects from arrays, re-indexes as needed, and shrinks arrays to minimum required size. Uses CUllUnused* members to delete any unreferenced objects from arrays.
public void Compact()
ComponentIndex
If this piece of geometry is a component in something larger, like a BrepEdge in a Brep, then this function returns the component index.
Returns: This object's component index. If this object is not a sub-piece of a larger geometric entity, then the returned index has m_type = ComponentIndex.InvalidType and m_index = -1.
ConstructConstObject
Assigns a parent object and a sub-object index to this.
Copy all trims from a Brep face onto a surface.
Returns: A brep with the shape of surfaceSource and the trims of trimSource or null on failure.
Creates a brep representation of the sphere with two similar trimmed NURBS surfaces, and no singularities.
Returns: A new brep, or null on error.
Makes a curve blend between points on two surface edges. The blend will be tangent to the surfaces and perpendicular to the edges.
public static Curve CreateBlendShape()
face0,
First face to blend from.
edge0,
First edge to blend from.
t0,
Location on first edge for first end of blend curve.
rev0,
If false, edge0 will be used in its natural direction. If true, edge0 will be used in the reversed direction.
continuity0,
Continuity for the blend at the start.
face1,
Second face to blend from.
edge1,
Second edge to blend from.
t1,
Location on second edge for second end of blend curve.
rev1,
If false, edge1 will be used in its natural direction. If true, edge1 will be used in the reversed direction.
continuity1
>Continuity for the blend at the end.
Returns: The blend curve on success. null on failure
Makes a surface blend between two surface edges.
public static Brep[] CreateBlendSurface()
face0,
First face to blend from.
edge0,
First edge to blend from.
domain0,
The domain of edge0 to use.
rev0,
If false, edge0 will be used in its natural direction. If true, edge0 will be used in the reversed direction.
continuity0,
Continuity for the blend at the start.
face1,
Second face to blend from.
edge1,
Second edge to blend from.
domain1,
The domain of edge1 to use.
rev1,
If false, edge1 will be used in its natural direction. If true, edge1 will be used in the reversed direction.
continuity1
Continuity for the blend at the end.
Remarks: Same as the overload that takes BlendSurfaceOptions, with the default options except for continuity, and the absolute tolerance of the active document.
Returns: Array of Breps if successful.
CreateBlendSurface
#Makes the surface blend the BlendSrf command makes between two surface edges.
public static Brep[] CreateBlendSurface()
face0,
First face to blend from.
edge0,
Edge of face0 to blend from.
domain0,
The part of edge0 to use, in edge0's parameters.
rev0,
If false, edge0 will be used in its natural direction. If true, edge0 will be used in the reversed direction.
face1,
Second face to blend from.
edge1,
Edge of face1 to blend from.
domain1,
The part of edge1 to use, in edge1's parameters.
rev1,
If false, edge1 will be used in its natural direction. If true, edge1 will be used in the reversed direction.
options,
Continuity and the other BlendSrf settings.
tolerance
Fitting tolerance. BlendSrf uses the document's absolute tolerance.
Remarks: When the whole of two closed edges is used, the blend is closed, and the seams and directions are matched the way BlendSrf matches them automatically. rev0 and rev1 are not used in that case.
Returns: Array of Breps if successful, an empty array if not.
Compute the Solid Difference of two Breps.
Remarks: The solid orientation of the breps make a difference when calling this function. Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.
Returns: An array of Brep results or null on failure.
Compute the Solid Difference of two Breps.
Remarks: The solid orientation of the breps make a difference when calling this function. Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.
Returns: An array of Brep results or null on failure.
Compute the Solid Difference of two sets of Breps.
public static Brep[] CreateBooleanDifference()
firstSet,
First set of Breps (the set to subtract from).
secondSet,
Second set of Breps (the set to subtract).
tolerance,
Tolerance to use for difference operation.
manifoldOnly
If true, non-manifold input breps are ignored.
Remarks: The solid orientation of the breps make a difference when calling this function. Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.
Returns: An array of Brep results or null on failure.
Compute the Solid Difference of two sets of Breps.
public static Brep[] CreateBooleanDifference()
firstSet,
First set of Breps (the set to subtract from).
secondSet,
Second set of Breps (the set to subtract).
tolerance
Tolerance to use for difference operation.
Remarks: The solid orientation of the breps make a difference when calling this function. Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.
Returns: An array of Brep results or null on failure.
Compute the solid difference between two sets of Breps.
public static Brep[] CreateBooleanDifferenceWithIndexMap()
firstSet,
The set to be differenced from.
secondSet,
The set to difference with.
tolerance,
Tolerance to use for the boolean operation.
manifoldOnly,
If true, non-manifold input breps are ignored.
indexMap
results[i] is the result if subtracting something from firstSet[indexMap[i]].
Remarks: Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.
Returns: An array of Brep results or null on failure. May be empty if all of the firstSet is differenced away.
Compute the Solid Intersection of two Breps.
Remarks: The solid orientation of the breps make a difference when calling this function. Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.
Returns: An array of Brep results or null on failure.
Compute the Solid Intersection of two Breps.
Remarks: The solid orientation of the breps make a difference when calling this function. Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.
Returns: An array of Brep results or null on failure.
Compute the Solid Intersection of two sets of Breps.
public static Brep[] CreateBooleanIntersection()
firstSet,
First set of Breps.
secondSet,
Second set of Breps.
tolerance,
Tolerance to use for intersection operation.
manifoldOnly
If true, non-manifold input breps are ignored.
Remarks: The solid orientation of the breps make a difference when calling this function. Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.
Returns: An array of Brep results or null on failure.
Compute the Solid Intersection of two sets of Breps.
public static Brep[] CreateBooleanIntersection()
firstSet,
First set of Breps.
secondSet,
Second set of Breps.
tolerance
Tolerance to use for intersection operation.
Remarks: The solid orientation of the breps make a difference when calling this function. Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.
Returns: An array of Brep results or null on failure.
Splits shared areas of Breps and creates separate Breps from the shared and unshared parts.
Remarks: Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.
Returns: An array of Brep if successful, an empty array on failure.
Splits shared areas of Breps and creates separate Breps from the shared and unshared parts.
public static Brep[] CreateBooleanSplit()
firstSet,
The Breps to split.
secondSet,
The cutting Breps.
tolerance
Tolerance to use for splitting operation. When in doubt, use the document's model absolute tolerance.
Remarks: Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.
Returns: An array of Brep if successful, an empty array on failure.
Compute the Boolean Union of a set of Breps.
public static Brep[] CreateBooleanUnion()
breps,
Breps to union.
tolerance,
Tolerance to use for union operation.
manifoldOnly,
If true, non-manifold input breps are ignored.
nakedEdgePoints,
If Boolean failed because the intersection hit a naked edge, a point will be added where the intersection hits the edge.
badIntersectionPoints,
If Boolean failed because an intersection ends on the interior of both surfaces, a point is added.This happens when the surface intersector fails.
nonManifoldEdgePoints
If Boolean failed because the intersection hit a non-manifold edge, a point will be added where the intersection hits the edge.
Remarks: Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.
Returns: An array of Brep results or null on failure.
Compute the Boolean Union of a set of Breps.
public static Brep[] CreateBooleanUnion()
breps,
Breps to union.
tolerance,
Tolerance to use for union operation.
manifoldOnly
If true, non-manifold input breps are ignored.
Remarks: Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.
Returns: An array of Brep results or null on failure.
Compute the Boolean Union of a set of Breps.
Remarks: Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.
Returns: An array of Brep results or null on failure.
CreateBooleanUnionWithIndexMap
#Compute the Boolean Union of a set of Breps, reporting which inputs produced each result.
public static Brep[] CreateBooleanUnionWithIndexMap()
breps,
Breps to union. May not contain nulls.
tolerance,
Tolerance to use for union operation.
manifoldOnly,
If true, non-manifold input breps are ignored.
indexMap
indexMap[i] holds the positions in
breps of the inputs that produced result i. Null when this method returns null.Remarks: A union result can come from several inputs, so this reports a list per result where CreateBooleanDifferenceWithIndexMap(IEnumerable<Brep>, IEnumerable<Brep>, double, bool, int[]) reports one index. The indices name the group of inputs a result was built from, which is not always the same as the inputs its geometry reached: a result made of disconnected pieces is separated into one result per piece, and each piece names the whole group. An input absorbed by another contributes no geometry and appears in no entry of
indexMap. An input the operation could not use is absent in the same way: one that is non-manifold when manifoldOnly is true, or one the Boolean kernel cannot accept. An input whose shells are disjoint produces one result per shell, and each of those names it. A null element in breps throws ArgumentException, because the reported indices are positions in that sequence. The other CreateBooleanUnion overloads drop nulls silently and renumber what follows. Breps that have never been added to a document may need preparing first, or this method can fail, or return an unexpected result. See Brep.PrepareForBooleans.Returns: An array of Brep results or null on failure. May be empty when the union produced no geometry.
Creates a ruled surface as a bevel between two input surface edges.
public static Brep[] CreateChamferSurface()
face0,
First face to chamfer from.
uv0,
A parameter face0 at the side you want to keep after chamfering.
radius0,
The distance from the intersection of face0 to the edge of the chamfer.
face1,
Second face to chamfer from.
uv1,
A parameter face1 at the side you want to keep after chamfering.
radius1,
The distance from the intersection of face1 to the edge of the chamfer.
extend,
If true, then when one input surface is longer than the other, the chamfer surface is extended to the input surface edges.
tolerance
The tolerance. When in doubt, use the document's model absolute tolerance.
obsoleteUse the CreateFilletSurface that takes settings and returns results
Returns: Array of Breps if successful.
Creates a ruled surface as a bevel between two input surface edges.
public static Brep[] CreateChamferSurface()
face0,
First face to chamfer from.
uv0,
A parameter face0 at the side you want to keep after chamfering.
radius0,
The distance from the intersection of face0 to the edge of the chamfer.
face1,
Second face to chamfer from.
uv1,
A parameter face1 at the side you want to keep after chamfering.
radius1,
The distance from the intersection of face1 to the edge of the chamfer.
trim,
If true, the input faces will be trimmed, if false, the input faces will be split.
extend,
If true, then when one input surface is longer than the other, the chamfer surface is extended to the input surface edges.
tolerance,
The tolerance. When in doubt, use the document's model absolute tolerance.
outBreps0,
The trim or split results of the Brep owned by face0.
outBreps1
The trim or split results of the Brep owned by face1.
obsoleteUse the CreateFilletSurface that takes settings and returns results
Returns: Array of Breps if successful.
Constructs the contour curves for a brep, using a slicing plane.
Returns: An array with intersected curves. This array can be empty.
Constructs the contour curves for a brep at a specified interval.
Returns: An array with intersected curves. This array can be empty.
Creates an array of analysis meshes for the brep, one per face. The meshes are not set on the brep.
public static Mesh[] CreateCurvatureAnalysisMesh()
brep,
The brep to mesh.
state,
Supplies the curvature style and the false color ranges.
meshingParameters
The mesh density. RhinoDoc.GetAnalysisMeshingParameters returns what a document uses, and MeshingParameters.DefaultAnalysisMesh is the default.
Remarks: Each mesh covers the untrimmed surface under a face, so on a trimmed face the mesh extends past the trims and any statistic taken from it includes area that is not part of the brep. For statistics, mesh the brep with MeshingParameters.ComputeCurvature set and pass the result to MeshCurvatureStats; the curvature values do not depend on the style, so one mesh serves every style.
Returns: The analysis meshes. The array is empty if no mesh could be created.
Create an array of analysis meshes for the brep using the specified settings. Meshes aren't set on the brep.
public static Mesh[] CreateCurvatureAnalysisMesh()
Remarks: The mesh density comes from the active document, and falls back to MeshingParameters.DefaultAnalysisMesh when there is no active document, as when running headless or in Compute.
Each mesh covers the untrimmed surface under a face, so on a trimmed face the mesh extends past the trims and any statistic taken from it includes area that is not part of the brep.
Returns: The analysis meshes. The array is empty if no mesh could be created.
Creates a single developable surface between two curves.
Returns: The output Breps if successful, otherwise an empty array.
Creates a single developable surface between two curves.
public static Brep[] CreateDevelopableLoft()
rail0,
The first rail curve.
rail1,
The second rail curve.
fixedRulings
Rulings define lines across the surface that define the straight sections on the developable surface, where rulings[i].X = parameter on first rail curve, and rulings[i].Y = parameter on second rail curve. Note, rulings will be automatically adjusted to minimum twist.
Returns: The output Breps if successful, otherwise an empty array.
Constructs a coons patch from 2, 3, or 4 curves.
Returns: resulting brep or null on failure.
Fillets, chamfers, or blends the edges of a brep.
public static Brep[] CreateFilletEdges()
brep,
The brep to fillet, chamfer, or blend edges.
edgeIndices,
An array of one or more edge indices where the fillet, chamfer, or blend will occur.
startRadii,
An array of starting fillet, chamfer, or blend radaii, one for each edge index.
endRadii,
An array of ending fillet, chamfer, or blend radaii, one for each edge index.
blendType,
The blend type.
railType,
The rail type.
setbackFillets,
Use setback fillets (not used with blendType=BlendType.Chamfer)
tolerance,
The tolerance to be used to perform calculations.
angleTolerance
Angle tolerance to be used to perform calculations [radians]. If unsure, use Math.PI/180.0 (one degree)
Returns: Array of Breps if successful.
Fillets, chamfers, or blends the edges of a brep.
public static Brep[] CreateFilletEdges()
brep,
The brep to fillet, chamfer, or blend edges.
edgeIndices,
An array of one or more edge indices where the fillet, chamfer, or blend will occur.
startRadii,
An array of starting fillet, chamfer, or blend radaii, one for each edge index.
endRadii,
An array of ending fillet, chamfer, or blend radaii, one for each edge index.
blendType,
The blend type.
railType,
The rail type.
tolerance
The tolerance to be used to perform calculations.
obsoletePrefer the version that takes setbackFillets and angleTolerance options.
Returns: Array of Breps if successful.
Fillets, chamfers, or blends the edges of a brep.
public static Brep[] CreateFilletEdgesVariableRadius()
brep,
The brep to fillet, chamfer, or blend edges.
edgeIndices,
An array of one or more edge indices where the fillet, chamfer, or blend will occur.
edgeDistances,
A dictionary with key the edge index on the input brep, and value a list of BrepEdgeFilletDistance items to apply.
blendType,
The blend type.
railType,
The rail type.
setbackFillets,
Use setback fillets (not used with blendType=BlendType.Chamfer)
tolerance,
The tolerance to be used to perform calculations.
angleTolerance
Angle tolerance to be used to perform calculations [radians].
Returns: Array of Breps if successful.
Create a fillet (rational arcs or non-rational arc approxiation or chamfered surface
public static bool CreateFilletSurface()
face0,
First face to fillet from.
uv0,
A parameter face0 at the side you want to keep after filleting.
face1,
Second face to fillet from.
uv1,
A parameter face1 at the side you want to keep after filleting.
settings,
The settings to use for filleting/chamfering
results
If true is returned, this contains the fillet results.
Returns: true if successful
Exceptions:
| ArgumentNullException |
Creates a constant-radius round surface between two surfaces.
public static Brep[] CreateFilletSurface()
face0,
First face to fillet from.
uv0,
A parameter face0 at the side you want to keep after filleting.
face1,
Second face to fillet from.
uv1,
A parameter face1 at the side you want to keep after filleting.
radius,
The fillet radius.
extend,
If true, then when one input surface is longer than the other, the fillet surface is extended to the input surface edges.
tolerance
The tolerance. When in doubt, use the document's model absolute tolerance.
obsoleteUse the CreateFilletSurface that takes settings and returns results
Returns: Array of Breps if successful.
Creates a constant-radius round surface between two surfaces.
public static Brep[] CreateFilletSurface()
face0,
First face to fillet from.
uv0,
A parameter face0 at the side you want to keep after filleting.
face1,
Second face to fillet from.
uv1,
A parameter face1 at the side you want to keep after filleting.
radius,
The fillet radius.
trim,
If true, the input faces will be trimmed, if false, the input faces will be split.
extend,
If true, then when one input surface is longer than the other, the fillet surface is extended to the input surface edges.
tolerance,
The tolerance. When in doubt, use the document's model absolute tolerance.
outBreps0,
The trim or split results of the Brep owned by face0.
outBreps1
The trim or split results of the Brep owned by face1.
obsoleteUse the CreateFilletSurface that takes settings and returns results
Returns: Array of Breps if successful.
Create a fillet (rational arcs or non-rational arc approxiation or chamfered surface
public static bool CreateFilletSurfaceCurve()
face,
Face to fillet from.
uv,
A parameter on the face at the side you want to keep after filleting.
curve,
Curve to fillet to.
t,
A parameter on the curve close to the point on the face.
settings,
The settings to use for filleting
results
If true is returned, this contains the fillet results.
Returns: true if successful
Exceptions:
| ArgumentNullException |
Constructs new brep that matches a bounding box.
Returns: A new brep; or null on failure.
Constructs new brep that matches an aligned box.
Returns: A Brep with 6 faces that is similar to the Box.
Constructs new brep from 8 corner points.
public static Brep CreateFromBox()
corners
8 points defining the box corners arranged as the vN labels indicate.
v7_______e6____v6
|\ |\
| e7 | e5
| \ ______e4_____\
e11 v4 | v5
| | e10 |
| | | |
v3--|---e2----v2 e9
\ e8 \ |
e3 | e1|
\| \|
v0_____e0______v1Returns: A new brep, or null on error.
Constructs a Brep representation of the cone with a single face for the cone, an edge along the cone seam, and vertices at the base and apex ends of this seam edge. The optional cap is a single face with one circular edge starting and ending at the base vertex.
Returns: A Brep if successful, null on error.
Makes a Brep with one face from three corner points.
Returns: A boundary representation, or null on error.
Makes a Brep with one face from four corner points.
Returns: A boundary representation, or null on error.
Constructs a Brep definition of a cylinder.
Returns: A Brep representation of the cylinder with a single face for the cylinder, an edge along the cylinder seam, and vertices at the bottom and top ends of this seam edge. The optional bottom/top caps are single faces with one circular edge starting and ending at the bottom/top vertex.
Joins two naked edges, or edges that are coincident or close together, from two Breps.
Returns: The resulting Brep if successful, null on failure.
Constructs one or more Breps by lofting through a set of curves, optionally matching start and end tangents of surfaces when first and/or last loft curves are surface edges
public static Brep[] CreateFromLoft()
curves,
The curves to loft through. This function will not perform any curve sorting. You must pass in curves in the order you want them lofted. This function will not adjust the directions of open curves. Use Curve.DoDirectionsMatch and Curve.Reverse to adjust the directions of open curves. This function will not adjust the seams of closed curves. Use Curve.ChangeClosedCurveSeam to adjust the seam of closed curves.
start,
Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point. "start" and "StartTangent" cannot both be true.
end,
Optional ending point of loft. Use Point3d.Unset if you do not want to include an end point. "end and "EndTangent" cannot both be true.
StartTangent,
If StartTangent is true and the first loft curve is a surface edge, the loft will match the tangent of the surface behind that edge.
EndTangent,
If EndTangent is true and the first loft curve is a surface edge, the loft will match the tangent of the surface behind that edge.
StartTrim,
BrepTrim from the surface edge where start tangent is to be matched
EndTrim,
BrepTrim from the surface edge where end tangent is to be matched
loftType,
type of loft to perform.
closed
true if the last curve in this loft should be connected back to the first one.
Returns: Constructs a closed surface, continuing the surface past the last curve around to the first curve. Available when you have selected three shape curves.
Constructs one or more Breps by lofting through a set of curves.
public static Brep[] CreateFromLoft()
curves,
The curves to loft through. This function will not perform any curve sorting. You must pass in curves in the order you want them lofted. This function will not adjust the directions of open curves. Use Curve.DoDirectionsMatch and Curve.Reverse to adjust the directions of open curves. This function will not adjust the seams of closed curves. Use Curve.ChangeClosedCurveSeam to adjust the seam of closed curves.
start,
Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point.
end,
Optional ending point of loft. Use Point3d.Unset if you do not want to include an end point.
loftType,
type of loft to perform.
closed,
true if the last curve in this loft should be connected back to the first one.
angleTol
angle tolerance, in radians, used to perform the loft.
Returns: Constructs a closed surface, continuing the surface past the last curve around to the first curve. Available when you have selected three shape curves.
Constructs one or more Breps by lofting through a set of curves.
public static Brep[] CreateFromLoft()
curves,
The curves to loft through. This function will not perform any curve sorting. You must pass in curves in the order you want them lofted. This function will not adjust the directions of open curves. Use Curve.DoDirectionsMatch and Curve.Reverse to adjust the directions of open curves. This function will not adjust the seams of closed curves. Use Curve.ChangeClosedCurveSeam to adjust the seam of closed curves.
start,
Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point.
end,
Optional ending point of loft. Use Point3d.Unset if you do not want to include an end point.
loftType,
type of loft to perform.
closed
true if the last curve in this loft should be connected back to the first one.
Returns: Constructs a closed surface, continuing the surface past the last curve around to the first curve. Available when you have selected three shape curves.
Constructs one or more Breps by lofting through a set of curves. Input for the loft is simplified by rebuilding to a specified number of control points.
public static Brep[] CreateFromLoftRebuild()
curves,
The curves to loft through. This function will not perform any curve sorting. You must pass in curves in the order you want them lofted. This function will not adjust the directions of open curves. Use Curve.DoDirectionsMatch and Curve.Reverse to adjust the directions of open curves. This function will not adjust the seams of closed curves. Use Curve.ChangeClosedCurveSeam to adjust the seam of closed curves.
start,
Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point.
end,
Optional ending point of lost. Use Point3d.Unset if you do not want to include an end point.
loftType,
type of loft to perform.
closed,
true if the last curve in this loft should be connected back to the first one.
angleTol,
angle tolerance, in radians, used to perform the loft.
rebuildPointCount
A number of points to use while rebuilding the curves. 0 leaves turns this parameter off.
Returns: Constructs a closed surface, continuing the surface past the last curve around to the first curve. Available when you have selected three shape curves.
Constructs one or more Breps by lofting through a set of curves. Input for the loft is simplified by rebuilding to a specified number of control points.
public static Brep[] CreateFromLoftRebuild()
curves,
The curves to loft through. This function will not perform any curve sorting. You must pass in curves in the order you want them lofted. This function will not adjust the directions of open curves. Use Curve.DoDirectionsMatch and Curve.Reverse to adjust the directions of open curves. This function will not adjust the seams of closed curves. Use Curve.ChangeClosedCurveSeam to adjust the seam of closed curves.
start,
Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point.
end,
Optional ending point of lost. Use Point3d.Unset if you do not want to include an end point.
loftType,
type of loft to perform.
closed,
true if the last curve in this loft should be connected back to the first one.
rebuildPointCount
A number of points to use while rebuilding the curves. 0 leaves turns this parameter off.
Returns: Constructs a closed surface, continuing the surface past the last curve around to the first curve. Available when you have selected three shape curves.
Constructs one or more Breps by lofting through a set of curves. Input for the loft is simplified by refitting to a specified tolerance.
public static Brep[] CreateFromLoftRefit()
curves,
The curves to loft through. This function will not perform any curve sorting. You must pass in curves in the order you want them lofted. This function will not adjust the directions of open curves. Use Curve.DoDirectionsMatch and Curve.Reverse to adjust the directions of open curves. This function will not adjust the seams of closed curves. Use Curve.ChangeClosedCurveSeam to adjust the seam of closed curves.
start,
Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point.
end,
Optional ending point of lost. Use Point3d.Unset if you do not want to include an end point.
loftType,
type of loft to perform.
closed,
true if the last curve in this loft should be connected back to the first one.
angleTol,
angle tolerance, in radians, used to perform the loft.
refitTolerance
A distance to use in refitting, or 0 if you want to turn this parameter off.
Returns: Constructs a closed surface, continuing the surface past the last curve around to the first curve. Available when you have selected three shape curves.
Constructs one or more Breps by lofting through a set of curves. Input for the loft is simplified by refitting to a specified tolerance.
public static Brep[] CreateFromLoftRefit()
curves,
The curves to loft through. This function will not perform any curve sorting. You must pass in curves in the order you want them lofted. This function will not adjust the directions of open curves. Use Curve.DoDirectionsMatch and Curve.Reverse to adjust the directions of open curves. This function will not adjust the seams of closed curves. Use Curve.ChangeClosedCurveSeam to adjust the seam of closed curves.
start,
Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point.
end,
Optional ending point of lost. Use Point3d.Unset if you do not want to include an end point.
loftType,
type of loft to perform.
closed,
true if the last curve in this loft should be connected back to the first one.
refitTolerance
A distance to use in refitting, or 0 if you want to turn this parameter off.
Returns: Constructs a closed surface, continuing the surface past the last curve around to the first curve. Available when you have selected three shape curves.
Match an edge to the target curve using the settings provided
public static bool CreateFromMatch()
edge,
The edge to match. This need to be an untrimmed surface edge.
targetCurve,
The curve to match to. This needs to be a BrepEdge if tangent or curvature matching is requested.
settings,
The settings used for matching
out Brep
matched,
If successful, this contains the matched brep
out Brep
target
If successful and MatchSrfSettings.Average is true, this contains the changed target brep.
Match an edge to the target curves using the settings provided
public static bool CreateFromMatch()
edge,
The edge to match. This need to be an untrimmed surface edge.
targetCurves,
The curves to match to. These need to be BrepEdge if tangent or curvature matching is requested.
settings,
The settings used for matching
out Brep
matched,
If successful, this contains the matched brep
out Brep
target
If successful and MatchSrfSettings.Average is true, this contains the changed target brep.
Create a brep representation of a mesh
Offsets a face including trim information to create a new brep.
public static Brep CreateFromOffsetFace()
face,
the face to offset.
offsetDistance,
An offset distance.
offsetTolerance,
Use 0.0 to make a loose offset. Otherwise, the document's absolute tolerance is usually sufficient.
bothSides,
When true, offset to both sides of the input face.
createSolid
When true, make a solid object.
Returns: A new brep if successful. The brep can be disjoint if bothSides is true and createSolid is false, or if createSolid is true and connecting the offsets with side surfaces fails. null if unsuccessful.
Constructs a brep form of a surface of revolution.
public static Brep CreateFromRevSurface()
surface,
The surface of revolution.
capStart,
if true, the start of the revolute is not on the axis of revolution, and the surface of revolution is closed, then a circular cap will be added to close of the hole at the start of the revolute.
capEnd
if true, the end of the revolute is not on the axis of revolution, and the surface of revolution is closed, then a circular cap will be added to close of the hole at the end of the revolute.
Returns: A Brep if successful, null on error.
Constructs a Brep definition of a sphere.
Returns: A Brep if successful, null on error.
Constructs a Brep from a surface. The resulting Brep has an outer boundary made from four trims. The trims are ordered so that they run along the south, east, north, and then west side of the surface's parameter space.
Returns: Resulting brep or null on failure.
Sweep1 function that fits a surface through a profile curve that define the surface cross-sections and one curve that defines a surface edge.
Remarks: Rhino's Sweep1 command uses this when the "refit rail" option is enabled (true).
Returns: Array of Brep sweep results.
Sweep1 function that fits a surface through profile curves that define the surface cross-sections and one curve that defines a surface edge.
Remarks: Rhino's Sweep1 command uses this when the "refit rail" option is enabled (true).
Returns: Array of Brep sweep results.
Sweep1 function that fits a surface through a series of profile curves that define the surface cross-sections and one curve that defines a surface edge. Unlike other CreateFromSweep and CreateFromSweepSegmented overrides, this method:
- Matches shape curve directions and (for closed shapes) seam points before sweeping, which prevents twisting.
- Detects when the inputs qualify for a "simple sweep" and creates a simpler surface in this case.
- Lets the caller pick between the refit - rail and segmented sweep paths.
- Splits the resulting Breps at fully multiple knots.
public static Brep[] CreateFromSweep()
rail,
Rail to sweep shapes along. For SweepFrame.AlignWithSurface, pass a BrepEdge or a BrepTrim so the sweep can find the surface to align to. An interior edge belongs to two faces and a BrepEdge does not say which one, so pass the BrepTrim of the face you want; a BrepEdge uses its first trim.
shapes,
Shape curves.
startPoint,
Optional starting point of sweep. Use Point3d.Unset if you do not want to include a start point.
endPoint,
Optional ending point of sweep. Use Point3d.Unset if you do not want to include an end point.
frameType,
The frame type.
roadlikeNormal,
The roadlike normal directoion. Use Vector3d.Unset if the frame type is not set to roadlike.
closed,
Only matters if shapes are closed.
blendType,
The shape blending type.
miterType,
The mitering type.
tolerance,
rebuildType,
The rebuild style.
rebuildPointCount,
If rebuild == SweepRebuild.Rebuild, the number of points. Otherwise specify 0.
refitTolerance,
If rebuild == SweepRebuild.Refit, the refit tolerance. Otherwise, specify 0.0.
refitRail
false = segmented sweep, true = refit-rail sweep.
Remarks: This version mimics what Rhino's Sweep1 command does.
Returns: Array of Brep sweep results.
Sweep1 function that fits a surface through a series of profile curves that define the surface cross-sections and one curve that defines a surface edge.
public static Brep[] CreateFromSweep()
rail,
Rail to sweep shapes along.
shapes,
Shape curves.
startPoint,
Optional starting point of sweep. Use Point3d.Unset if you do not want to include a start point.
endPoint,
Optional ending point of sweep. Use Point3d.Unset if you do not want to include an end point.
frameType,
The frame type.
roadlikeNormal,
The roadlike normal directoion. Use Vector3d.Unset if the frame type is not set to roadlike.
closed,
Only matters if shapes are closed.
blendType,
The shape blending type.
miterType,
The mitering type.
tolerance,
rebuildType,
The rebuild style.
rebuildPointCount,
If rebuild == SweepRebuild.Rebuild, the number of points. Otherwise specify 0.
refitTolerance
If rebuild == SweepRebuild.Refit, the refit tolerance. Otherwise, specify 0.0
Remarks: Rhino's Sweep1 command uses this when the "refit rail" option is enabled (true).
Returns: Array of Brep sweep results.
General 2 rail sweep. If you are not producing the sweep results that you are after, then use the SweepTwoRail class with options to generate the swept geometry.
Returns: Array of Brep sweep results
General 2 rail sweep. If you are not producing the sweep results that you are after, then use the SweepTwoRail class with options to generate the swept geometry.
Returns: Array of Brep sweep results
Sweep2 function that fits a surface through profile curves that define the surface cross-sections and two curves that defines the surface edges.
public static Brep[] CreateFromSweep()
rail1,
Rail to sweep shapes along
rail2,
Rail to sweep shapes along
shapes,
Shape curves
start,
Optional starting point of sweep. Use Point3d.Unset if you do not want to include a start point.
end,
Optional ending point of sweep. Use Point3d.Unset if you do not want to include an end point.
closed,
Only matters if shapes are closed.
tolerance,
Tolerance for fitting surface and rails.
rebuild,
The rebuild style.
rebuildPointCount,
If rebuild == SweepRebuild.Rebuild, the number of points. Otherwise specify 0.
refitTolerance,
If rebuild == SweepRebuild.Refit, the refit tolerance. Otherwise, specify 0.0
preserveHeight,
Removes the association between the height scaling from the width scaling
autoAdjust
Set to true to have shape curves adjusted, sorted, and matched automatically. This will produce results comparable to Rhino's Sweep2 command. Set to false to not have shape curves adjusted, sorted, and matched automatically.
Returns: Array of Brep sweep results
Sweep2 function that fits a surface through profile curves that define the surface cross-sections and two curves that defines the surface edges.
public static Brep[] CreateFromSweep()
rail1,
Rail to sweep shapes along
rail2,
Rail to sweep shapes along
shapes,
Shape curves
start,
Optional starting point of sweep. Use Point3d.Unset if you do not want to include a start point.
end,
Optional ending point of sweep. Use Point3d.Unset if you do not want to include an end point.
closed,
Only matters if shapes are closed.
tolerance,
Tolerance for fitting surface and rails.
rebuild,
The rebuild style.
rebuildPointCount,
If rebuild == SweepRebuild.Rebuild, the number of points. Otherwise specify 0.
refitTolerance,
If rebuild == SweepRebuild.Refit, the refit tolerance. Otherwise, specify 0.0
preserveHeight
Removes the association between the height scaling from the width scaling
Returns: Array of Brep sweep results
Makes a 2 rail sweep. Like CreateFromSweep but the result is split where parameterization along a rail changes abruptly.
public static Brep[] CreateFromSweepInParts()
rail1,
Rail to sweep shapes along
rail2,
Rail to sweep shapes along
shapes,
Shape curves
rail_params,
Shape parameters
closed,
Only matters if shapes are closed
tolerance
Tolerance for fitting surface and rails
Returns: Array of Brep sweep results
Sweep1 function that fits a surface through a profile curve that define the surface cross-sections and one curve that defines a surface edge. The Segmented version breaks the rail at curvature kinks and sweeps each piece separately, then put the results together into a Brep.
Remarks: Rhino's Sweep1 command uses this when the "refit rail" option is disabled (false).
Returns: Array of Brep sweep results
Sweep1 function that fits a surface through a series of profile curves that define the surface cross-sections and one curve that defines a surface edge. The Segmented version breaks the rail at curvature kinks and sweeps each piece separately, then put the results together into a Brep.
Remarks: Rhino's Sweep1 command uses this when the "refit rail" option is disabled (false).
Returns: Array of Brep sweep results.
Sweep1 function that fits a surface through a series of profile curves that define the surface cross-sections and one curve that defines a surface edge. The Segmented version breaks the rail at curvature kinks and sweeps each piece separately, then put the results together into a Brep.
public static Brep[] CreateFromSweepSegmented()
rail,
Rail to sweep shapes along.
shapes,
Shape curves.
startPoint,
Optional starting point of sweep. Use Point3d.Unset if you do not want to include a start point.
endPoint,
Optional ending point of sweep. Use Point3d.Unset if you do not want to include an end point.
frameType,
The frame type.
roadlikeNormal,
The roadlike normal directoion. Use Vector3d.Unset if the frame type is not set to roadlike.
closed,
Only matters if shapes are closed.
blendType,
The shape blending type.
miterType,
The mitering type.
tolerance,
rebuildType,
The rebuild style.
rebuildPointCount,
If rebuild == SweepRebuild.Rebuild, the number of points. Otherwise specify 0.
refitTolerance
If rebuild == SweepRebuild.Refit, the refit tolerance. Otherwise, specify 0.0
Remarks: Rhino's Sweep1 command uses this when the "refit rail" option is disabled (false).
Returns: Array of Brep sweep results.
Extrude a curve to a taper making a brep (potentially more than 1)
public static Brep[] CreateFromTaperedExtrude()
curveToExtrude,
the curve to extrude
distance,
the distance to extrude
direction,
the direction of the extrusion
basePoint,
the base point of the extrusion
draftAngleRadians,
angle of the extrusion
cornerType,
tolerance,
tolerance to use for the extrusion
angleToleranceRadians
angle tolerance to use for the extrusion
Returns: array of breps on success
Extrude a curve to a taper making a brep (potentially more than 1)
public static Brep[] CreateFromTaperedExtrude()
curveToExtrude,
the curve to extrude
distance,
the distance to extrude
direction,
the direction of the extrusion
basePoint,
the base point of the extrusion
draftAngleRadians,
angle of the extrusion
cornerType
obsoleteUse version that takes tolerance as input
Remarks: tolerances used are based on the active doc tolerance
Returns: array of breps on success
Creates one or more Breps by extruding a curve a distance along an axis with draft angle.
public static Brep[] CreateFromTaperedExtrudeWithRef()
curve,
The curve to extrude.
direction,
The extrusion direction.
distance,
The extrusion distance.
draftAngle,
The extrusion draft angle in radians.
plane,
The end of the extrusion will be parallel to this plane, and "distance" from the plane's origin. The plane's origin is generally be a point on the curve. For planar curves, a natural choice for the plane's normal direction will be the normal direction of the curve's plane. In any case, plane.Normal = direction may make sense.
tolerance
The intersecting and trimming tolerance.
Returns: An array of Breps if successful.
Constructs a Brep definition of a torus.
Returns: A Brep representation of the torus if successful, null otherwise.
Offsets a Brep.
public static Brep[] CreateOffsetBrep()
brep,
The Brep to offset.
distance,
The distance to offset. This is a signed distance value with respect to face normals and flipped faces.
solid,
If true, then the function makes a closed solid from the input and offset surfaces by lofting a ruled surface between all of the matching edges.
extend,
If true, then the function maintains the sharp corners when the original surfaces have sharps corner. If False, then the function creates fillets at sharp corners in the original surfaces.
shrink,
If true, then the function shrinks the underlying surfaces to their face's outer boundary loop.
tolerance,
The offset tolerance.
outBlends,
The results of the calculation.
outWalls
The results of the calculation.
Returns: Array of Breps if successful. If the function succeeds in offsetting, a single Brep will be returned. Otherwise, the array will contain the offset surfaces, outBlends will contain the set of blends used to fill in gaps (if extend is false), and outWalls will contain the set of wall surfaces that was supposed to join the offset to the original (if solid is true).
Offsets a Brep.
public static Brep[] CreateOffsetBrep()
brep,
The Brep to offset.
distance,
The distance to offset. This is a signed distance value with respect to face normals and flipped faces.
solid,
If true, then the function makes a closed solid from the input and offset surfaces by lofting a ruled surface between all of the matching edges.
extend,
If true, then the function maintains the sharp corners when the original surfaces have sharps corner. If False, then the function creates fillets at sharp corners in the original surfaces.
tolerance,
The offset tolerance.
outBlends,
The results of the calculation.
outWalls
The results of the calculation.
Returns: Array of Breps if successful. If the function succeeds in offsetting, a single Brep will be returned. Otherwise, the array will contain the offset surfaces, outBlends will contain the set of blends used to fill in gaps (if extend is false), and outWalls will contain the set of wall surfaces that was supposed to join the offset to the original (if solid is true).
Constructs a brep patch.
This is the simple version of fit that uses a plane with u x v spans. It makes a plane by fitting to the points from the input geometry to use as the starting surface. The surface has the specified u and v span count.
public static Brep CreatePatch()
geometry,
A combination of curves, brep trims, points, point clouds or meshes. Curves and trims are sampled to get points. Trims are sampled for points and normals.
uSpans,
The number of spans in the U direction.
vSpans,
The number of spans in the V direction.
tolerance
Tolerance used by input analysis functions for loop finding, trimming, etc.
Returns: A brep fit through input on success, or null on error.
Constructs a brep patch.
This is the simple version of fit that uses a specified starting surface.
public static Brep CreatePatch()
geometry,
Combination of Curves, BrepTrims, Points, PointClouds or Meshes. Curves and trims are sampled to get points. Trims are sampled for points and normals.
startingSurface,
A starting surface (can be null).
tolerance
Tolerance used by input analysis functions for loop finding, trimming, etc.
Returns: Brep fit through input on success, or null on error.
Constructs a brep patch using all controls
public static Brep CreatePatch()
geometry,
A combination of curves, brep trims, points, point clouds or meshes. Curves and trims are sampled to get points. Trims are sampled for points and normals.
startingSurface,
A starting surface (can be null).
uSpans,
Number of surface spans used when a plane is fit through points to start in the U direction.
vSpans,
Number of surface spans used when a plane is fit through points to start in the U direction.
trim,
If true, try to find an outer loop from among the input curves and trim the result to that loop
tangency,
If true, try to find brep trims in the outer loop of curves and try to fit to the normal direction of the trim's surface at those locations.
pointSpacing,
Basic distance between points sampled from input curves.
flexibility,
Determines the behavior of the surface in areas where its not otherwise controlled by the input. Lower numbers make the surface behave more like a stiff material; higher, less like a stiff material. That is, each span is made to more closely match the spans adjacent to it if there is no input geometry mapping to that area of the surface when the flexibility value is low. The scale is logarithmic. Numbers around 0.001 or 0.1 make the patch pretty stiff and numbers around 10 or 100 make the surface flexible.
surfacePull,
Tends to keep the result surface where it was before the fit in areas where there is on influence from the input geometry
bool[]
fixEdges,
Array of four elements. Flags to keep the edges of a starting (untrimmed) surface in place while fitting the interior of the surface. Order of flags is left, bottom, right, top
tolerance
Tolerance used by input analysis functions for loop finding, trimming, etc.
Returns: A brep fit through input on success, or null on error.
Creates a single walled pipe.
public static Brep[] CreatePipe()
rail,
The rail, or path, curve.
radius,
The radius of the pipe.
localBlending,
The shape blending. If True, Local (pipe radius stays constant at the ends and changes more rapidly in the middle) is applied. If False, Global (radius is linearly blended from one end to the other, creating pipes that taper from one radius to the other) is applied.
cap,
The end cap mode.
fitRail,
If the curve is a polycurve of lines and arcs, the curve is fit and a single surface is created; otherwise the result is a Brep with joined surfaces created from the polycurve segments.
absoluteTolerance,
The sweeping and fitting tolerance. When in doubt, use the document's absolute tolerance.
angleToleranceRadians
The angle tolerance. When in doubt, use the document's angle tolerance in radians.
Returns: Array of Breps success.
Creates a single walled pipe.
public static Brep[] CreatePipe()
rail,
The rail, or path, curve.
railRadiiParameters,
One or more normalized curve parameters where changes in radius occur. Important: curve parameters must be normalized - ranging between 0.0 and 1.0. Use Interval.NormalizedParameterAt to calculate these.
radii,
One or more radii - one at each normalized curve parameter in railRadiiParameters.
localBlending,
The shape blending. If True, Local (pipe radius stays constant at the ends and changes more rapidly in the middle) is applied. If False, Global (radius is linearly blended from one end to the other, creating pipes that taper from one radius to the other) is applied.
cap,
The end cap mode.
fitRail,
If the curve is a polycurve of lines and arcs, the curve is fit and a single surface is created; otherwise the result is a Brep with joined surfaces created from the polycurve segments.
absoluteTolerance,
The sweeping and fitting tolerance. When in doubt, use the document's absolute tolerance.
angleToleranceRadians
The angle tolerance. When in doubt, use the document's angle tolerance in radians.
Returns: Array of Breps success.
Constructs a set of planar breps as outlines by the loops.
Returns: An array of Planar Breps.
Constructs a set of planar breps as outlines by the loops.
obsoleteUse version that takes tolerance as input
Returns: An array of Planar Breps.
Constructs a set of planar Breps as outlines by the loops.
Returns: An array of Planar Breps.
Constructs a set of planar Breps as outlines by the loops.
obsoleteUse version that takes tolerance as input
Returns: An array of Planar Breps or null on error.
Constructs a set of planar breps as outlines by the loops.
Returns: An array of Planar Breps.
Constructs a set of planar breps as outlines by the loops.
obsoleteUse version that takes tolerance as input
Returns: An array of Planar Breps.
CreatePlanarBrepsWithIndexMap
#Constructs a set of planar Breps as outlines by the loops, reporting which input curves bounded each Brep.
public static Brep[] CreatePlanarBrepsWithIndexMap()
inputLoops,
Curve loops that delineate the planar boundaries.
tolerance,
Tolerance to use when sorting and building the loops.
indexMap
One entry per returned Brep, in the same order. Entry i lists, ascending, the positions in
inputLoops of the curves sorted onto Brep i. Null when this method returns null.Remarks: A curve that closes an outer loop and a curve that closes a hole in the same face are both listed for that face, and a hole rejected while the Brep is built still leaves its curves listed. The entries are not a partition of
inputLoops. A self-intersecting input is split into regions, and a curve bounding several of them is listed for each. A curve the merge dropped, one sorted onto no face, and one whose face failed to produce a valid Brep are listed nowhere. A null element in inputLoops throws ArgumentException, because the reported indices are positions in that sequence. The other CreatePlanarBreps overloads drop nulls silently and renumber what follows.Returns: An array of planar Breps, or null on failure.
CreatePlanarDifference
Returns: An array of Brep results or null on failure.
CreatePlanarIntersection
Returns: An array of Brep results or null on failure.
CreatePlanarUnion
Returns: An array of Brep results or null on failure.
CreatePlanarUnion
public static Brep[] CreatePlanarUnion()
breps,
The planar regions on which to perform the union operation.
plane,
The plane in which all the input breps lie
tolerance
Tolerance to use for union operation.
Returns: An array of Brep results or null on failure.
Constructs a Brep definition of a quad sphere.
Returns: A Brep if successful, null on error.
Creates a hollowed out shell from a solid Brep. Function only operates on simple, solid, manifold Breps.
public static Brep[] CreateShell()
brep,
The solid Brep to shell.
facesToRemove,
The indices of the Brep faces to remove. These surfaces are removed and the remainder is offset inward, using the outer parts of the removed surfaces to join the inner and outer parts.
distance,
The distance, or thickness, for the shell. This is a signed distance value with respect to face normals and flipped faces.
tolerance
The offset tolerance. When in doubt, use the document's absolute tolerance.
Returns: An array of Brep results or null on failure.
Constructs closed polysurfaces from surfaces and polysurfaces that bound a region in space.
public static Brep[] CreateSolid()
breps,
The intersecting surfaces and polysurfaces to automatically trim and join into closed polysurfaces.
tolerance
The trim and join tolerance. If set to RhinoMath.UnsetValue, Rhino's global absolute tolerance is used.
Returns: The resulting polysurfaces on success or null on failure.
Creates a double-walled pipe.
public static Brep[] CreateThickPipe()
rail,
The rail, or path, curve.
radius0,
The first radius of the pipe.
radius1,
The second radius of the pipe.
localBlending,
The shape blending. If True, Local (pipe radius stays constant at the ends and changes more rapidly in the middle) is applied. If False, Global (radius is linearly blended from one end to the other, creating pipes that taper from one radius to the other) is applied.
cap,
The end cap mode.
fitRail,
If the curve is a polycurve of lines and arcs, the curve is fit and a single surface is created; otherwise the result is a Brep with joined surfaces created from the polycurve segments.
absoluteTolerance,
The sweeping and fitting tolerance. When in doubt, use the document's absolute tolerance.
angleToleranceRadians
The angle tolerance. When in doubt, use the document's angle tolerance in radians.
Returns: Array of Breps success.
Creates a double-walled pipe.
public static Brep[] CreateThickPipe()
rail,
The rail, or path, curve.
railRadiiParameters,
One or more normalized curve parameters where changes in radius occur. Important: curve parameters must be normalized - ranging between 0.0 and 1.0. Use Interval.NormalizedParameterAt to calculate these.
radii0,
One or more radii for the first wall - one at each normalized curve parameter in railRadiiParameters.
radii1,
One or more radii for the second wall - one at each normalized curve parameter in railRadiiParameters.
localBlending,
The shape blending. If True, Local (pipe radius stays constant at the ends and changes more rapidly in the middle) is applied. If False, Global (radius is linearly blended from one end to the other, creating pipes that taper from one radius to the other) is applied.
cap,
The end cap mode.
fitRail,
If the curve is a polycurve of lines and arcs, the curve is fit and a single surface is created; otherwise the result is a Brep with joined surfaces created from the polycurve segments.
absoluteTolerance,
The sweeping and fitting tolerance. When in doubt, use the document's absolute tolerance.
angleToleranceRadians
The angle tolerance. When in doubt, use the document's angle tolerance in radians.
Returns: Array of Breps success.
Create a Brep trimmed plane.
Returns: Resulting brep or null on failure.
Create a Brep trimmed plane.
public static Brep CreateTrimmedPlane()
plane,
Plane that will be trimmed.
curves
A list of curves that form a simple (no self intersections) closed curve that defines the outer boundary of the trimmed plane.
Returns: Resulting brep or null on failure.
Constructs a Brep using the trimming information of a brep face and a surface. Surface must be roughly the same shape and in the same location as the trimming brep face.
Returns: A brep with the shape of surfaceSource and the trims of trimSource or null on failure.
Constructs a Brep using the trimming information of a brep face and a surface. Surface must be roughly the same shape and in the same location as the trimming brep face.
obsoleteUse version that takes tolerance as input
Returns: A brep with the shape of surfaceSource and the trims of trimSource or null on failure.
Create a patch using variational approach
public static Brep CreateVariationalPatch()
edges,
Edges with continuity constraints
internalCurves,
Internal curves
points,
Internal points
settings,
The settings to use while creating the surface
multiThreading,
Use multi-threading during the calculation
cancelToken,
The cancellation token.
progress,
The provider for progress updates.
results
The results of the patching algorithm.
Returns: Trimmed surface if successful, null otherwise
Create a patch using variational approach
public static Brep CreateVariationalPatch()
doc,
The Rhino document. Use null if not available.
edges,
Edges with continuity constraints
internalCurves,
Internal curves
points,
Internal points
settings,
The settings to use while creating the surface
multiThreading,
Use multi-threading during the calculation
cancelToken,
The cancellation token.
progress,
The provider for progress updates.
results
The results of the patching algorithm.
Returns: Trimmed surface if successful, null otherwise
Culls 3d curves not referenced by an edge.
Returns: true if operation succeeded; false otherwise.
Culls 2d curves not referenced by a trim.
Returns: true if operation succeeded; false otherwise.
Culls edges with m_edge_index == -1.
Returns: true if operation succeeded; false otherwise.
Culls faces with m_face_index == -1.
Returns: true if operation succeeded; false otherwise.
Culls loops with m_loop_index == -1.
Returns: true if operation succeeded; false otherwise.
Culls surfaces not referenced by a face.
Returns: true if operation succeeded; false otherwise.
Culls trims with m_trim_index == -1.
Returns: true if operation succeeded; false otherwise.
Culls vertices with m_vertex_index == -1.
Returns: true if operation succeeded; false otherwise.
Splits, or cuts up, a surface. Designed to split the underlying surface of a Brep face with edge curves.
public static Brep[] CutUpSurface()
surface,
The surface to cut up.
curves,
The edge curves with consistent orientation. The curves should lie on the surface.
flip,
If true, the input curves are oriented clockwise.
fitTolerance,
The fitting tolerance.
keepTolerance
Used to decide which face to keep. For best results, should be at least 2 * fitTolerance.
Returns: The Brep pieces if successful, an empty array on failure.
Takes a surface and a set of all 3D curves that define a single trimmed surface, and splits the surface with the curves, keeping the piece that uses all of the curves.
public static Brep[] CutUpSurface()
surface,
The surface.
curves,
The curves.
useEdgeCurves,
The 2D trimming curves are made by pulling back the 3D curves using the fitting tolerance. If useEdgeCurves is true, the input 3D curves will be used as the edge curves in the result. Otherwise, the edges will come from pushing up the 2D pullbacks.
tolerance
The fitting tolerance. When in doubt, use the document's model absolute tolerance.
Remarks: This function is useful when importing non-3dm files with questionable geometry. It is also a good way to quickly create a trimmed surface that has multiple inner boundaries without having to call split or trim and then select all of the pieces to throw away. If the surface is closed, an attempt will be made to move seams so that they avoid the curves. If that cannot be done, the result may have more than one face. If the surface is closed in both directions, it is possible that the split will result in two faces that use all of the input curves. In this case all curves must be oriented counter-clockwise, with respect to the surface normal, around the desired result. The surface may be extended if it is not large enough to contain the curves. Noisy singularities will be repaired when possible.
Returns: The resulting Breps is successful, otherwise an empty array. Note, you may want to join the results into a single Brep.
Exceptions:
| ArgumentNullException |
DataCRC
Returns a CRC calculated from the information that defines the object. This CRC can be used as a quick way to see if two objects are not identical.
Returns: CRC of the information the defines the object.
DeleteAllUserStrings
public void DeleteAllUserStrings()
Destroys a Brep's region topology information.
public void DestroyRegionTopology()
Dispose
Actively reclaims unmanaged resources that this instance uses.
public void Dispose()
Dispose
Overridden in order to destroy local display cache information
Overrides: CommonObject.Dispose
Same as Duplicate(), but already performs a cast to a brep.
This cast always succeeds.
Returns: A brep.
Duplicate all the edges of this Brep.
Returns: An array of edge curves.
Duplicate edges of this Brep.
Returns: Array of edge curves on success.
Duplicate naked edges of this Brep.
Returns: Array of edge curves on success.
DuplicateShallow
Constructs a light copy of this object. By "light", it is meant that the same underlying data is used until something is done to attempt to change it. For example, you could have a shallow copy of a very heavy mesh object and the same underlying data will be used when doing things like inspecting the number of faces on the mesh. If you modify the location of one of the mesh vertices, the shallow copy will create a full duplicate of the underlying mesh data and the shallow copy will become a deep copy.
Returns: An object of the same type as this object.
This behavior is overridden by implementing classes.
Copy a subset of this Brep into another Brep.
[ConstOperation]
public Brep DuplicateSubBrep()
faceIndices
array of face indices in this brep to copy. (If any values in faceIndices are out of range or if faceIndices contains duplicates, this function will return null.)
Returns: A brep, or null on error.
Duplicate all the corner vertices of this Brep.
Returns: An array or corner vertices.
EnsurePrivateCopy
If you want to keep a copy of this class around by holding onto it in a variable after a command completes, call EnsurePrivateCopy to make sure that this class is not tied to the document. You can call this function as many times as you want.
public void EnsurePrivateCopy()
Extends Faces to meet and trims the faces to each other. If input faces intersect without extending, the selection point indicates the side to keep
public static bool ExtendBrepFacesToConnect()
Face0,
[in] first face to connect
edgeIndex0,
[in] edge to extend.
Face1,
[in] second surface
edgeIndex1,
[in] edge to extend.
tol,
[in] tolerance used for intersecting faces and simplifing extension curve
angleTol,
[in] angle tolerance in radians used for simplifying extendsion curve
out Brep
outBrep0,
[out] first face extended and trimmed to connect with the second face
out Brep
outBrep1
[out] second face extended and trimmed to connect with the first face
Returns: true if valid connection found
Extends Faces to meet and trims the faces to each other. If input faces intersect without extending, the selection point indicates the side to keep
public static bool ExtendBrepFacesToConnect()
Face0,
[in] first face to connect
f0_sel_pt,
selection point on first face near the edge to extend.
Face1,
[in] second surface
f1_sel_pt,
selection point on second face near the edge to extend.
tol,
[in] tolerance used for intersecting faces and simplifing extension curve
angleTol,
[in] angle tolerance in radians used for simplifying extendsion curve
out Brep
outBrep0,
[out] first face extended and trimmed to connect with the second face
out Brep
outBrep1
[out] second face extended and trimmed to connect with the first face
Returns: true if valid connection found
Find the indices of all brep faces, edges and vertices that are within tolerance of a test-point.
Compute the Area of the Brep. If you want proper Area data with moments and error information, use the AreaMassProperties class.
Returns: The area of the Brep.
Compute the Area of the Brep. If you want proper Area data with moments and error information, use the AreaMassProperties class.
Returns: The area of the Brep.
GetBoundingBox
Bounding box solver. Gets the world axis aligned bounding box for the geometry.
[ConstOperation]
public BoundingBox GetBoundingBox()
accurate
If true, a physically accurate bounding box will be computed. If not, a bounding box estimate will be computed. For some geometry types there is no difference between the estimate and the accurate bounding box. Estimated bounding boxes can be computed much (much) faster than accurate (or "tight") bounding boxes. Estimated bounding boxes are always similar to or larger than accurate bounding boxes.
Returns: The bounding box of the geometry in world coordinates or BoundingBox.Empty if not bounding box could be found.
GetBoundingBox
Aligned Bounding box solver. Gets the plane aligned bounding box.
Returns: A BoundingBox in plane coordinates.
GetBoundingBox
Aligned Bounding box solver. Gets the plane aligned bounding box.
Returns: A BoundingBox in plane coordinates.
GetBoundingBox
Aligned Bounding box solver. Gets the world axis aligned bounding box for the transformed geometry.
[ConstOperation]
public virtual BoundingBox GetBoundingBox()
xform
Transformation to apply to object prior to the BoundingBox computation. The geometry itself is not modified.
Returns: The accurate bounding box of the transformed geometry in world coordinates or BoundingBox.Empty if not bounding box could be found.
If this Brep has two or more connected components, then duplicates of the connected components are returned.
Returns: An array of connected components, or an empty array.
GetObjectData
Populates a System.Runtime.Serialization.SerializationInfo with the data needed to serialize the target object.
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
public virtual void GetObjectData()
info,
The System.Runtime.Serialization.SerializationInfo to populate with data.
context
The destination (see System.Runtime.Serialization.StreamingContext) for this serialization.
Finds a point inside of a solid Brep.
Returns: Returns false if the input is not solid and manifold, if the Brep's bounding box is less than 2.0 * tolerance wide, or if no point could be found due to ray shooting or other errors. Otherwise, true is returned.
Gets an array containing all regions in this brep.
Returns: An array of regions in this brep. This array can be empty, but not null.
If this Brep has two or more components connected by tangent edges, then duplicates of the connected components are returned.
Returns: An array of tangent edge connected components, or an empty array.
GetUserString
Gets user string from this geometry.
Returns: string associated with the key if successful. null if no key was found.
GetUserStrings
Gets a copy of all (user key string, user value string) pairs attached to this geometry.
Returns: A new collection.
Compute the Volume of the Brep. If you want proper Volume data with moments and error information, use the VolumeMassProperties class.
Returns: The volume of the Brep.
Compute the Volume of the Brep. If you want proper Volume data with moments and error information, use the VolumeMassProperties class.
Returns: The volume of the Brep.
Constructs all the Wireframe curves for this Brep.
Returns: An array of Wireframe curves or null on failure.
Individually insets faces of a brep by offsetting the faces outer edges inward and inner edges out then splitting the face with the offset curves.
[ConstOperation]
public Brep InsetFaces()
faceIndices,
the indices of the faces to inset
distance,
The distance to offset along the face
loose,
If true, offset by moving edit points otherwise offset within tolerance.
ignoreSeams,
If true, the seam edges are not offset and adjacent edges are extended to meet the seam. Otherwise offset normally.
creaseCorners,
If true, splitting curves will be made between the creases on edge curves and creases on the inset curves.
tolerance,
The fitting tolerance for the offset. When in doubt, use the document's absolute tolerance.
angleTolerance
The angle tolerance in radians for identifying creases when creasing corners. When in doubt, use the document's angle tolerance.
Returns: The brep with inset faces on success. Null on error.
Verifies a Brep is in the form of a solid box.
Returns: true if the Brep is a solid box, false otherwise.
Verifies a Brep is in the form of a solid box.
Returns: true if the Brep is a solid box, false otherwise.
See if this and other are same brep geometry.
Returns: true if breps are the same.
Determines if the Brep is a portion of an extrusion within RhinoMath.ZeroTolerance.
Returns: true if the Brep is an extrusion.
Determines if the Brep is a portion of an extrusion within a given tolerance.
Returns: true if the Brep is an extrusion.
Test a Brep to see if it is an oriented manifold. Non manifold Breps have at least one edge that is shared among three or more faces.
Returns: If the Brep is a manifold, true is returned. Otherwise false is returned.
Determines if point is inside a Brep. This question only makes sense when the brep is a closed and manifold. This function does not check for closed or manifold, so result is not valid in those cases. Intersects a line through point with brep, finds the intersection point Q closest to point, and looks at face normal at Q. If the point Q is on an edge or the intersection is not transverse at Q, then another line is used.
[ConstOperation]
public bool IsPointInside()
point,
3d point to test.
tolerance,
3d distance tolerance used for intersection and determining strict inclusion. A good default is RhinoMath.SqrtEpsilon.
strictlyIn
if true, point is in if inside brep by at least tolerance. if false, point is in if truly in or within tolerance of boundary.
Returns: true if point is in, false if not.
Expert user function that tests the brep to see if its geometry information is valid. The value of brep.IsValidTopology() must be true before brep.IsValidGeometry() can be safely called.
[ConstOperation]
public bool IsValidGeometry()
out string
log
If the brep geometry is not valid, then a brief description of the problem in English is assigned to this out parameter. The information is suitable for low-level debugging purposes by programmers and is not intended to be useful as a high level user interface tool. Otherwise, string.Empty.
Returns: A value that indicates whether the geometry is valid.
Expert user function that tests the brep to see if its tolerances and flags are valid. The values of brep.IsValidTopology() and brep.IsValidGeometry() must be true before brep.IsValidTolerancesAndFlags() can be safely called.
[ConstOperation]
public bool IsValidTolerancesAndFlags()
out string
log
If the brep tolerance or flags are not valid, then a brief description of the problem in English is assigned to this out parameter. The information is suitable for low-level debugging purposes by programmers and is not intended to be useful as a high level user interface tool. Otherwise, string.Empty.
Returns: A value that indicates
Tests the brep to see if its topology information is valid.
[ConstOperation]
public bool IsValidTopology()
out string
log
If the brep topology is not valid, then a brief English description of the problem is appended to the log. The information appended to log is suitable for low-level debugging purposes by programmers and is not intended to be useful as a high level user interface tool.
Returns: true if the topology is valid; false otherwise.
IsValidWithLog
Determines if an object is valid. Also provides a report on errors if this object happens not to be valid.
Returns: true if this object is valid; false otherwise.
If any edges of this brep overlap edges of otherBrep, merge a copy of otherBrep into this brep joining all edges that overlap within tolerance.
Remarks: if no edges overlap, this brep is unchanged. otherBrep is copied if it is merged with this, and otherBrep is always unchanged Use this to join a list of breps in a series. When joining multiple breps in series, compact should be set to false. Call compact on the last Join.
Returns: true if any edges were joined.
Joins the breps in the input array at any overlapping edges to form as few as possible resulting breps. There may be more than one brep in the result array.
public static Brep[] JoinBreps()
brepsToJoin,
A list, an array or any enumerable set of breps to join.
tolerance,
3d distance tolerance for detecting overlapping edges. When in doubt, use the document's model absolute tolerance.
angleTolerance,
Angle tolerance, in radians, used for merging edges. When in doubt, use the document's model angle tolerance.
indexMap
List of integer arrays, one for each joined result, containing all input Brep indices that went into making each result. Note, this can be null.
Returns: New joined breps on success, null on failure.
Joins the breps in the input array at any overlapping edges to form as few as possible resulting breps. There may be more than one brep in the result array.
public static Brep[] JoinBreps()
brepsToJoin,
A list, an array or any enumerable set of breps to join.
tolerance,
3d distance tolerance for detecting overlapping edges. When in doubt, use the document's model absolute tolerance.
angleTolerance
Angle tolerance, in radians, used for merging edges. When in doubt, use the document's model angle tolerance.
Returns: New joined breps on success, null on failure.
Joins the breps in the input array at any overlapping edges to form as few as possible resulting breps. There may be more than one brep in the result array.
public static Brep[] JoinBreps()
brepsToJoin,
A list, an array or any enumerable set of breps to join.
tolerance
3d distance tolerance for detecting overlapping edges.
Returns: New joined breps on success, null on failure.
Joins two naked edges, or edges that are coincident or close together.
public bool JoinEdges()
edgeIndex0,
The first edge index.
edgeIndex1,
The second edge index.
joinTolerance,
The join tolerance.
compact
If joining more than one edge pair and want the edge indices of subsequent pairs to remain valid, set to false. But then call Brep.Compact() on the final result.
Returns: true if successful, false otherwise.
Joins naked edge pairs within the same brep that overlap within tolerance.
Returns: number of joins made.
MakeDeformable
If possible, converts the object into a form that can be accurately modified with "squishy" transformations like projections, shears, an non-uniform scaling.
Returns: false if object cannot be converted to a deformable object. true if object was already deformable or was converted into a deformable object.
No support is available for this function.
Expert user function that converts all geometry in Brep to NURB form.
Remarks: Don't call this function unless you know exactly what you are doing.
MemoryEstimate
Computes an estimate of the number of bytes that this object is using in memory.
Returns: An estimated memory footprint.
Combines two or more breps into one. A merge is like a boolean union that keeps the inside pieces. This function creates non-manifold Breps which in general are unusual in Rhino. You may want to consider using JoinBreps or CreateBooleanUnion functions instead.
public static Brep MergeBreps()
brepsToMerge,
must contain more than one Brep.
tolerance
the tolerance to use when merging.
Returns: Single merged Brep on success. Null on error.
Merges adjacent coplanar faces into single faces.
public bool MergeCoplanarFaces()
tolerance,
Tolerance for determining when edges are adjacent. When in doubt, use the document's ModelAbsoluteTolerance property.
angleTolerance
Angle tolerance, in radians, for determining when faces are parallel. When in doubt, use the document's ModelAngleToleranceRadians property.
Returns: true if faces were merged, false if no faces were merged.
Merges adjacent coplanar faces into single faces.
Returns: true if faces were merged, false if no faces were merged.
Merges coplanar faces adjacent to Brep face into a single face.
public bool MergeCoplanarFaces()
faceIndex,
The index of the Brep face to search.
tolerance,
Tolerance for determining when edges are adjacent. When in doubt, use the document's ModelAbsoluteTolerance property.
angleTolerance
Angle tolerance, in radians, for determining when faces are parallel. When in doubt, use the document's ModelAngleToleranceRadians property.
Returns: true if faces were merged, false if no faces were merged.
Merges two coplanar, adjacent Brep faces into a single face.
public bool MergeCoplanarFaces()
faceIndex0,
The index of the first Brep face.
faceIndex1,
The index of the second Brep face.
tolerance,
Tolerance for determining when edges are adjacent. When in doubt, use the document's ModelAbsoluteTolerance property.
angleTolerance
Angle tolerance, in radians, for determining when faces are parallel. When in doubt, use the document's ModelAngleToleranceRadians property.
Returns: true if faces were merged, false if no faces were merged.
Merges two surfaces into one surface at untrimmed edges. Both surfaces must be untrimmed and share an edge.
public static Brep MergeSurfaces()
brep0,
The first single-face Brep to merge.
brep1,
The second single-face Brep to merge.
tolerance,
Surface edges must be within this tolerance for the two surfaces to merge.
angleToleranceRadians,
Edge must be within this angle tolerance in order for contiguous edges to be combined into a single edge.
point0,
2D pick point on the first single-face Brep. The value can be unset.
point1,
2D pick point on the second single-face Brep. The value can be unset.
roundness,
Defines the roundness of the merge. Acceptable values are between 0.0 (sharp) and 1.0 (smooth).
smooth
The surface will be smooth. This makes the surface behave better for control point editing, but may alter the shape of both surfaces.
Returns: The merged Brep if successful, null if not successful.
Merges two surfaces into one surface at untrimmed edges. Both surfaces must be untrimmed and share an edge.
public static Brep MergeSurfaces()
brep0,
The first single-face Brep to merge.
brep1,
The second single-face Brep to merge.
tolerance,
Surface edges must be within this tolerance for the two surfaces to merge.
angleToleranceRadians
Edge must be within this angle tolerance in order for contiguous edges to be combined into a single edge.
Returns: The merged Brep if successful, null if not successful.
Merges two surfaces into one surface at untrimmed edges.
public static Brep MergeSurfaces()
surface0,
The first surface to merge.
surface1,
The second surface to merge.
tolerance,
Surface edges must be within this tolerance for the two surfaces to merge.
angleToleranceRadians
Edge must be within this angle tolerance in order for contiguous edges to be combined into a single edge.
Returns: The merged surfaces as a Brep if successful, null if not successful.
NonConstOperation
Destroy cache handle
protected override void NonConstOperation()
Overrides: CommonObject.NonConstOperation
OnSwitchToNonConst
Is called when a non-constant operation occurs.
protected override void OnSwitchToNonConst()
Overrides: CommonObject.OnSwitchToNonConst
Prepares this Brep for a Boolean or intersection operation by applying the same cleanup Rhino performs when a Brep is added to the document. Breps that have never been added to a document can fail these operations, or return unexpected results, without it.
Remarks: Because kinked surfaces can cause problems downstream, Rhino, by default, splits kinked surfaces when adding Breps to the document. So this method splits all kinky Brep faces. Also, because inward pointing face normals for solid Breps can cause problems, Rhino flips inward pointing normals for solids when adding Breps to the document. So this method checks the solid orientation and, if inward, flips the face normals.
This method modifies the Brep in place. If it returns false, then the Brep was modified but is no longer valid. Duplicate the Brep first if you need to keep the original, and note that flipping an inward pointing solid discards a deliberately inside out orientation.
Returns: true if the Brep is ready to use, false otherwise.
Prepares this Brep for a Boolean or intersection operation by applying the same cleanup Rhino performs when a Brep is added to the document. Breps that have never been added to a document can fail these operations, or return unexpected results, without it.
Remarks: Because kinked surfaces can cause problems downstream, Rhino, by default, splits kinked surfaces when adding Breps to the document. So this method splits all kinky Brep faces. Also, because inward pointing face normals for solid Breps can cause problems, Rhino flips inward pointing normals for solids when adding Breps to the document. So this method checks the solid orientation and, if inward, flips the face normals.
This method modifies the Brep in place. If it returns false, then the Brep was modified but is no longer valid. Duplicate the Brep first if you need to keep the original, and note that flipping an inward pointing solid discards a deliberately inside out orientation.
Returns: true if the Brep is ready to use, false otherwise.
If the brep.Faces[faceIndex] is planar, and all the adjacent faces are planar, this function transforms brep.Faces[faceIndex] with the transform parameter and recomputes the adjacent faces. See the PushPull commands extend mode.
Returns: The brep with the transformed face on success. Null on error.
No support is available for this function.
Expert user function used by MakeValidForV2 to convert trim curves from one surface to its NURBS form. After calling this function, you need to change the surface of the face to a NurbsSurface.
public void RebuildTrimsForV2()
face,
Face whose underlying surface has a parameterization that is different from its NURBS form.
nurbsSurface
NURBS form of the face's underlying surface.
Remarks: Don't call this function unless you know exactly what you are doing.
Recursively removes any Brep face with a naked edge. This function is only useful for non-manifold Breps.
Returns: true if successful, false if everything is removed or if the result has any Brep edges with more than two Brep trims.
Remove all inner loops, or holes, in a Brep.
Returns: The Brep without holes if successful, null otherwise.
Removes inner loops, or holes, in a Brep.
[ConstOperation]
public Brep RemoveHoles()
loops,
A list of BrepLoop component indexes, where BrepLoop.LoopType == Rhino.Geometry.BrepLoopType.Inner.
tolerance
The tolerance. When in doubt, use the document's model absolute tolerance.
Returns: The Brep without holes if successful, null otherwise.
Fills in missing or fixes incorrect component information from a Brep. Useful when reading Brep information from other file formats that do not provide as complete of a Brep definition as required by Rhino.
Returns: True on success.
Re-trims the given edges of this single-face Brep, replacing each deleted edge with new boundary geometry. This is the SDK equivalent of the ReplaceEdge command.
[ConstOperation]
public Brep ReplaceEdge()
edgeIndices,
The indices of the edges to replace.
method,
How the deleted edges are re-trimmed.
replacementCurve,
The curve used to re-trim when
method is BrepReplaceEdgeMethod.Curve; ignored (may be null) otherwise.tolerance
The tolerance. When in doubt, use the document's model absolute tolerance.
Returns: The modified Brep if successful, null otherwise (for example, if this Brep has more than one face).
Rotate
Rotates the object about the specified axis. A positive rotation angle results in a counter-clockwise rotation about the axis (right hand rule).
Returns: true if geometry successfully rotated.
Scale
Scales the object by the specified factor. The scale is centered at the origin.
Returns: true if geometry successfully scaled.
Set tolerances and flags in a Brep.
public void SetTolerancesBoxesAndFlags()
Set tolerances and flags in a Brep.
public void SetTolerancesBoxesAndFlags()
bLazy,
If true, only flags and tolerances that are not set will be calculated.
bSetVertexTolerances,
Set true to compute BrepVertex tolerances.
bSetEdgeTolerances,
Set true to compute BrepEdge tolerances.
bSetTrimTolerances,
Set true to compute BrepTrim tolerances.
bSetTrimIsoFlags,
Set true to compute BrepTrim.IsoStatus values.
bSetTrimTypeFlags,
Set true to compute BrepTrim.TrimType values.
bSetLoopTypeFlags,
Set true to compute BrepLoop.BrepLoopType values.
bSetTrimBoxes
Set true to compute BrepTrim bounding boxes.
This function can be used to set the BrepTrim::m_iso flag. It is intended to be used when creating a Brep from a definition that does not include compatible parameter space type information.
public void SetTrimIsoFlags()
SetUserString
Attach a user string (key,value combination) to this geometry.
Returns: true on success.
This function can be used to compute vertex information for a b-rep when everything but the Vertices array is properly filled in. It is intended to be used when creating a Brep from a definition that does not include explicit vertex information.
public void SetVertices()
Splits a Brep into pieces using a Brep as a cutter.
[ConstOperation]
public Brep[] Split()
cutter,
The Brep to use as a cutter.
intersectionTolerance,
The tolerance with which to compute intersections.
out bool
toleranceWasRaised
Set to true if the split failed at intersectionTolerance but succeeded when the tolerance was increased to twice intersectionTolerance.
Returns: A new array of Breps. This array can be empty.
Splits a Brep into pieces using a Brep as a cutter.
Returns: A new array of Breps. This array can be empty.
Splits a Brep into pieces using Breps as cutters.
[ConstOperation]
public Brep[] Split()
cutters,
One or more Breps to use as cutters.
intersectionTolerance
The tolerance with which to compute intersections.
Returns: A new array of Breps. This array can be empty.
Splits a Brep into pieces using curves, at least partially on the Brep, as cutters.
[ConstOperation]
public Brep[] Split()
cutters,
The splitting curves. Only the portion of the curve on the Brep surface will be used for cutting.
intersectionTolerance
The tolerance with which to compute intersections.
Returns: A new array of Breps. This array can be empty.
Splits a Brep into pieces using a combination of curves, to be extruded, and Breps as cutters.
[ConstOperation]
public Brep[] Split()
cutters,
The curves, surfaces, faces and Breps to be used as cutters. Any other geometry is ignored.
normal,
A construction plane normal, used in deciding how to extrude a curve into a cutter.
planView,
Set true if the assume view is a plan, or parallel projection, view.
intersectionTolerance
The tolerance with which to compute intersections.
Remarks: A Curve in cutters is extruded to produce a surface to use as a cutter. The extrusion direction is chosen, as in the Rhino Split command, based on the properties of the active view. In particular the construction plane Normal and whether the active view is a plan view, a parallel projection with construction plane normal as the view direction. If planView is false and the curve is planar then the curve is extruded perpendicular to the curve, otherwise the curve is extruded in the normal direction.
Returns: A new array of Breps. This array can be empty.
Separates, or splits, a disjoint Brep into separate Breps.
Returns: An array of Brep pieces if successful, otherwise an empty array if the Brep is not disjoint or on error.
Separates, or splits, a disjoint Brep into separate Breps.
Returns: An array of Brep pieces if successful, otherwise an empty array if the Brep is not disjoint or on error.
Standardizes all trims, edges, and faces in the brep. After standardizing, there may be unused curves and surfaces in the brep. Call Brep.Compact to remove these unused curves and surfaces.
public void Standardize()
ToJSON
Create a JSON string representation of this object
Transform
Transforms the geometry. If the input Transform has a SimilarityType of OrientationReversing, you may want to consider flipping the transformed geometry after calling this function when it makes sense. For example, you may want to call Flip() on a Brep after transforming it.
Returns: true if geometry successfully transformed.
Transform an array of Brep components, bend neighbors to match, and leave the rest fixed.
public bool TransformComponent()
components,
The Brep components to transform.
xform,
The transformation to apply.
tolerance,
The desired fitting tolerance to use when bending faces that share edges with both fixed and transformed components.
timeLimit,
If the deformation is extreme, it can take a long time to calculate the result. If time_limit > 0, then the value specifies the maximum amount of time in seconds you want to spend before giving up.
useMultipleThreads
True if multiple threads can be used.
Returns: true if successful, false otherwise.
Translate
Translates the object along the specified vector.
Returns: true if geometry successfully translated.
Translate
Translates the object along the specified vector.
Returns: true if geometry successfully translated.
Trims a brep with an oriented cutter. The parts of the brep that lie inside (opposite the normal) of the cutter are retained while the parts to the outside (in the direction of the normal) are discarded. If the Cutter is closed, then a connected component of the Brep that does not intersect the cutter is kept if and only if it is contained in the inside of cutter. That is the region bounded by cutter opposite from the normal of cutter, If cutter is not closed all these components are kept.
Returns: This Brep is not modified, the trim results are returned in an array.
Trims a Brep with an oriented cutter. The parts of Brep that lie inside (opposite the normal) of the cutter are retained while the parts to the outside ( in the direction of the normal ) are discarded. A connected component of Brep that does not intersect the cutter is kept if and only if it is contained in the inside of Cutter. That is the region bounded by cutter opposite from the normal of cutter, or in the case of a Plane cutter the half space opposite from the plane normal.
Returns: This Brep is not modified, the trim results are returned in an array.
Attempts to convert a generic Geometry object into a Brep.
Returns: Brep if a brep form could be created or null if this is not possible. If geometry was of type Brep to begin with, the same object is returned, i.e. it is not duplicated.
Tests a Brep to see if it is an extrusion and returns the extrusion.
Returns: true if the Brep is a portion of an extrusion.
Tests a Brep to see if it is an extrusion within RhinoMath.ZeroTolerance and returns the extrusion.
Returns: true if the Brep is an extrusion.
Un-joins, or separates, edges within the Brep. Note, seams in closed surfaces will not separate.
Returns: This Brep is not modified, the trim results are returned in an array.
Untrims a face completely, expanding it back to its underlying surface: the outer boundary is untrimmed and all inner loops (holes) are removed.
Returns: The untrimmed Brep if successful, null otherwise.
Untrims the outer boundary of a face, expanding the face back to the boundary of its underlying surface. Inner loops (holes) are left in place. The outer boundary is only untrimmed when all of its edges are naked; otherwise the operation fails to avoid corrupting adjacent faces.
Returns: The untrimmed Brep if successful, null otherwise.
Cuts this solid brep with a single open cutting curve. The curve is extruded along direction into a sheet, then along trimDirection to close the sheet into a solid cutter.
public bool WireCut()
openCurve,
Open cutting curve.
direction,
First extrusion direction (the wire sweep).
trimDirection,
Second extrusion direction that closes the cutter.
depth,
Depth along direction. RhinoMath.UnsetValue or a value <= 0 cuts through and skips trim capping.
trimDepth,
Depth along trimDirection. Ignored when cutting through.
bothSides,
Extrude both ways along direction.
trimBothSides,
Extrude both ways along trimDirection.
tolerance,
Intersection and boolean tolerance, typically the document absolute tolerance.
splitKinkyFaces,
Split output pieces along creases.
keptPieces,
Pieces that remain after the cut (boolean difference side).
cutAwayPieces
The cut-away pieces (boolean intersection side).
Returns: true if successful.
Cuts this solid brep with extrusions of closed planar curves
public bool WireCut()
closedCurves,
Closed cutting curves. All are extruded along the same direction.
direction,
Extrusion direction of the cutters.
depth,
Extrusion depth. RhinoMath.UnsetValue or a value <= 0 cuts all the way through.
bothSides,
Extrude the cutters to both sides of the curves. Ignored when cutting through.
tolerance,
Intersection and boolean tolerance, typically the document absolute tolerance.
splitKinkyFaces,
Split output pieces along creases.
keptPieces,
Pieces that remain after the cut (boolean difference side).
cutAwayPieces
The cut-away pieces (boolean intersection side).
Returns: true if successful.