/// Boundary Representation. A surface or polysurface along with trim curve information.
Constructors
Brep
#Protected constructor used in serialization.
Parameters:
| info (SerializationInfo) | |
| context (StreamingContext) |
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
Parameters:
| curve (Curve) |
Returns: Index used to reference this geometry in the edge curve list
Adds a 3D surface used by BrepFace.
Parameters:
| surface (Surface) | A copy of the surface is added to this brep. |
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
Parameters:
| curve (Curve) |
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
Parameters:
| other (Brep) |
Returns a new Brep that is equivalent to this Brep with all planar holes capped.
Parameters:
| tolerance (double) | Tolerance to use for capping. |
Returns: New brep on success. null on error.
Change the seam of a closed trimmed surface.
Parameters:
| face (BrepFace) | A Brep face with a closed underlying surface. |
| direction (int) | The parameter direction (0 = U, 1 = V). The face's underlying surface must be closed in this direction. |
| parameter (double) | The parameter at which to place the seam. |
| tolerance (double) | 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.
[ConstOperation]
public bool ClosestPoint(Point3d testPoint, out Point3d closestPoint, out ComponentIndex ci, out double s, out double t, double maximumDistance, out Vector3d normal)
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.
Parameters:
| testPoint (Point3d) | Base point to project to surface. |
| closestPoint (out Point3d) | Location of the closest Brep point. |
| ci (out ComponentIndex) | Component index of the Brep component that contains the closest point. Possible component index types are ComponentIndexType.BrepEdge and ComponentIndexType.BrepFace. |
| s (out double) | If ci.ComponentIndexType == ComponentIndexType.BrepEdge, then s is the parameter of the closest edge point. |
| t (out double) | If ci.ComponentIndexType == ComponentIndexType.BrepFace, then (s,t) is the parameter of the closest face point. |
| maximumDistance (double) | 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. |
| normal (out Vector3d) | 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.
Parameters:
| testPoint (Point3d) | Base point to project to brep. |
Returns: The point on the Brep closest to testPoint or Point3d.Unset if the operation failed.
public void Compact()
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.
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.
Creates a brep representation of the sphere with two similar trimmed NURBS surfaces, and no singularities.
public static Curve CreateBlendShape(BrepFace face0, BrepEdge edge0, double t0, bool rev0, BlendContinuity continuity0, BrepFace face1, BrepEdge edge1, double t1, bool rev1, BlendContinuity continuity1)
Makes a curve blend between points on two surface edges. The blend will be tangent to the surfaces and perpendicular to the edges.
Parameters:
| face0 (BrepFace) | First face to blend from. |
| edge0 (BrepEdge) | First edge to blend from. |
| t0 (double) | Location on first edge for first end of blend curve. |
| rev0 (bool) | If false, edge0 will be used in its natural direction. If true, edge0 will be used in the reversed direction. |
| continuity0 (BlendContinuity) | Continuity for the blend at the start. |
| face1 (BrepFace) | Second face to blend from. |
| edge1 (BrepEdge) | Second edge to blend from. |
| t1 (double) | Location on second edge for second end of blend curve. |
| rev1 (bool) | If false, edge1 will be used in its natural direction. If true, edge1 will be used in the reversed direction. |
| continuity1 (BlendContinuity) | >Continuity for the blend at the end. |
Returns: The blend curve on success. null on failure
public static Brep[] CreateBlendSurface(BrepFace face0, BrepEdge edge0, Interval domain0, bool rev0, BlendContinuity continuity0, BrepFace face1, BrepEdge edge1, Interval domain1, bool rev1, BlendContinuity continuity1)
Makes a surface blend between two surface edges.
Parameters:
| face0 (BrepFace) | First face to blend from. |
| edge0 (BrepEdge) | First edge to blend from. |
| domain0 (Interval) | The domain of edge0 to use. |
| rev0 (bool) | If false, edge0 will be used in its natural direction. If true, edge0 will be used in the reversed direction. |
| continuity0 (BlendContinuity) | Continuity for the blend at the start. |
| face1 (BrepFace) | Second face to blend from. |
| edge1 (BrepEdge) | Second edge to blend from. |
| domain1 (Interval) | The domain of edge1 to use. |
| rev1 (bool) | If false, edge1 will be used in its natural direction. If true, edge1 will be used in the reversed direction. |
| continuity1 (BlendContinuity) | Continuity for the blend at the end. |
Returns: Array of Breps if successful.
public static Brep[] CreateBooleanDifference(Brep firstBrep, Brep secondBrep, double tolerance, bool manifoldOnly)
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.
Parameters:
| firstBrep (Brep) | First Brep for boolean difference. |
| secondBrep (Brep) | Second Brep for boolean difference. |
| tolerance (double) | Tolerance to use for difference operation. |
| manifoldOnly (bool) | If true, non-manifold input breps are ignored. |
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.
Parameters:
| firstBrep (Brep) | First Brep for boolean difference. |
| secondBrep (Brep) | Second Brep for boolean difference. |
| tolerance (double) | Tolerance to use for difference operation. |
Returns: An array of Brep results or null on failure.
public static Brep[] CreateBooleanDifference(IEnumerable<Brep> firstSet, IEnumerable<Brep> secondSet, double tolerance, bool manifoldOnly)
Compute the Solid Difference of two sets of 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.
Parameters:
| firstSet (IEnumerable<Brep>) | First set of Breps (the set to subtract from). |
| secondSet (IEnumerable<Brep>) | Second set of Breps (the set to subtract). |
| tolerance (double) | Tolerance to use for difference operation. |
| manifoldOnly (bool) | If true, non-manifold input breps are ignored. |
Returns: An array of Brep results or null on failure.
public static Brep[] CreateBooleanDifference(IEnumerable<Brep> firstSet, IEnumerable<Brep> secondSet, double tolerance)
Compute the Solid Difference of two sets of 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.
Parameters:
| firstSet (IEnumerable<Brep>) | First set of Breps (the set to subtract from). |
| secondSet (IEnumerable<Brep>) | Second set of Breps (the set to subtract). |
| tolerance (double) | Tolerance to use for difference operation. |
Returns: An array of Brep results or null on failure.
public static Brep[] CreateBooleanDifferenceWithIndexMap(IEnumerable<Brep> firstSet, IEnumerable<Brep> secondSet, double tolerance, bool manifoldOnly, out int[] indexMap)
Compute the solid difference between two sets 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.
Parameters:
| firstSet (IEnumerable<Brep>) | The set to be differenced from. |
| secondSet (IEnumerable<Brep>) | The set to difference with. |
| tolerance (double) | Tolerance to use for the boolean operation. |
| manifoldOnly (bool) | If true, non-manifold input breps are ignored. |
| indexMap (out int[]) | results[i] is the result if subtracting something from firstSet[indexMap[i]]. |
Returns: An array of Brep results or null on failure. May be empty if all of the firstSet is differenced away.
public static Brep[] CreateBooleanIntersection(Brep firstBrep, Brep secondBrep, double tolerance, bool manifoldOnly)
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.
Parameters:
| firstBrep (Brep) | First Brep for boolean intersection. |
| secondBrep (Brep) | Second Brep for boolean intersection. |
| tolerance (double) | Tolerance to use for intersection operation. |
| manifoldOnly (bool) | If true, non-manifold input breps are ignored. |
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.
Parameters:
| firstBrep (Brep) | First Brep for boolean intersection. |
| secondBrep (Brep) | Second Brep for boolean intersection. |
| tolerance (double) | Tolerance to use for intersection operation. |
Returns: An array of Brep results or null on failure.
public static Brep[] CreateBooleanIntersection(IEnumerable<Brep> firstSet, IEnumerable<Brep> secondSet, double tolerance, bool manifoldOnly)
Compute the Solid Intersection of two sets of 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.
Parameters:
| firstSet (IEnumerable<Brep>) | First set of Breps. |
| secondSet (IEnumerable<Brep>) | Second set of Breps. |
| tolerance (double) | Tolerance to use for intersection operation. |
| manifoldOnly (bool) | If true, non-manifold input breps are ignored. |
Returns: An array of Brep results or null on failure.
public static Brep[] CreateBooleanIntersection(IEnumerable<Brep> firstSet, IEnumerable<Brep> secondSet, double tolerance)
Compute the Solid Intersection of two sets of 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.
Parameters:
| firstSet (IEnumerable<Brep>) | First set of Breps. |
| secondSet (IEnumerable<Brep>) | Second set of Breps. |
| tolerance (double) | Tolerance to use for intersection operation. |
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.
Parameters:
| firstBrep (Brep) | The Brep to split. |
| secondBrep (Brep) | The cutting Brep. |
| tolerance (double) | Tolerance to use for splitting operation. When in doubt, use the document's model absolute tolerance. |
Returns: An array of Brep if successful, an empty array on failure.
public static Brep[] CreateBooleanSplit(IEnumerable<Brep> firstSet, IEnumerable<Brep> secondSet, double tolerance)
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.
Parameters:
| firstSet (IEnumerable<Brep>) | The Breps to split. |
| secondSet (IEnumerable<Brep>) | The cutting Breps. |
| tolerance (double) | Tolerance to use for splitting operation. When in doubt, use the document's model absolute tolerance. |
Returns: An array of Brep if successful, an empty array on failure.
public static Brep[] CreateBooleanUnion(IEnumerable<Brep> breps, double tolerance, bool manifoldOnly, out Point3d[] nakedEdgePoints, out Point3d[] badIntersectionPoints, out Point3d[] nonManifoldEdgePoints)
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.
Parameters:
| breps (IEnumerable<Brep>) | Breps to union. |
| tolerance (double) | Tolerance to use for union operation. |
| manifoldOnly (bool) | If true, non-manifold input breps are ignored. |
| nakedEdgePoints (out Point3d[]) | If Boolean failed because the intersection hit a naked edge, a point will be added where the intersection hits the edge. |
| badIntersectionPoints (out Point3d[]) | 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 (out Point3d[]) | If Boolean failed because the intersection hit a non-manifold edge, a point will be added where the intersection hits the edge. |
Returns: An array of Brep results or null on failure.
public static Brep[] CreateBooleanUnion(IEnumerable<Brep> breps, double tolerance, bool manifoldOnly)
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.
Parameters:
| breps (IEnumerable<Brep>) | Breps to union. |
| tolerance (double) | Tolerance to use for union operation. |
| manifoldOnly (bool) | If true, non-manifold input breps are ignored. |
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.
Parameters:
| breps (IEnumerable<Brep>) | Breps to union. |
| tolerance (double) | Tolerance to use for union operation. |
Returns: An array of Brep results or null on failure.
CreateBooleanUnionWithIndexMap
#public static Brep[] CreateBooleanUnionWithIndexMap(IEnumerable<Brep> breps, double tolerance, bool manifoldOnly, out int[][] indexMap)
Compute the Boolean Union of a set of Breps, reporting which inputs produced each result.
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.Parameters:
| breps (IEnumerable<Brep>) | Breps to union. May not contain nulls. |
| tolerance (double) | Tolerance to use for union operation. |
| manifoldOnly (bool) | If true, non-manifold input breps are ignored. |
| indexMap (out int[][]) | indexMap[i] holds the positions in breps of the inputs that produced result i. Null when this method returns null. |
Returns: An array of Brep results or null on failure. May be empty when the union produced no geometry.
public static Brep[] CreateChamferSurface(BrepFace face0, Point2d uv0, double radius0, BrepFace face1, Point2d uv1, double radius1, bool extend, double tolerance)
obsoleteUse the CreateFilletSurface that takes settings and returns results
Creates a ruled surface as a bevel between two input surface edges.
Parameters:
| face0 (BrepFace) | First face to chamfer from. |
| uv0 (Point2d) | A parameter face0 at the side you want to keep after chamfering. |
| radius0 (double) | The distance from the intersection of face0 to the edge of the chamfer. |
| face1 (BrepFace) | Second face to chamfer from. |
| uv1 (Point2d) | A parameter face1 at the side you want to keep after chamfering. |
| radius1 (double) | The distance from the intersection of face1 to the edge of the chamfer. |
| extend (bool) | If true, then when one input surface is longer than the other, the chamfer surface is extended to the input surface edges. |
| tolerance (double) | The tolerance. When in doubt, use the document's model absolute tolerance. |
Returns: Array of Breps if successful.
public static Brep[] CreateChamferSurface(BrepFace face0, Point2d uv0, double radius0, BrepFace face1, Point2d uv1, double radius1, bool trim, bool extend, double tolerance, out Brep[] outBreps0, out Brep[] outBreps1)
obsoleteUse the CreateFilletSurface that takes settings and returns results
Creates a ruled surface as a bevel between two input surface edges.
Parameters:
| face0 (BrepFace) | First face to chamfer from. |
| uv0 (Point2d) | A parameter face0 at the side you want to keep after chamfering. |
| radius0 (double) | The distance from the intersection of face0 to the edge of the chamfer. |
| face1 (BrepFace) | Second face to chamfer from. |
| uv1 (Point2d) | A parameter face1 at the side you want to keep after chamfering. |
| radius1 (double) | The distance from the intersection of face1 to the edge of the chamfer. |
| trim (bool) | If true, the input faces will be trimmed, if false, the input faces will be split. |
| extend (bool) | If true, then when one input surface is longer than the other, the chamfer surface is extended to the input surface edges. |
| tolerance (double) | The tolerance. When in doubt, use the document's model absolute tolerance. |
| outBreps0 (out Brep[]) | The trim or split results of the Brep owned by face0. |
| outBreps1 (out Brep[]) | The trim or split results of the Brep owned by face1. |
Returns: Array of Breps if successful.
Constructs the contour curves for a brep, using a slicing plane.
public static Curve[] CreateContourCurves(Brep brepToContour, Point3d contourStart, Point3d contourEnd, double interval)
Constructs the contour curves for a brep at a specified interval.
public static Mesh[] CreateCurvatureAnalysisMesh(Brep brep, CurvatureAnalysisSettingsState state, MeshingParameters meshingParameters)
Creates an array of analysis meshes for the brep, one per face. The meshes are not set on the brep.
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.
Parameters:
| brep (Brep) | The brep to mesh. |
| state (CurvatureAnalysisSettingsState) | Supplies the curvature style and the false color ranges. |
| meshingParameters (MeshingParameters) | The mesh density. RhinoDoc.GetAnalysisMeshingParameters returns what a document uses, and MeshingParameters.DefaultAnalysisMesh is the default. |
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.
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.
Parameters:
| brep (Brep) | The brep to mesh. |
| state (CurvatureAnalysisSettingsState) | CurvatureAnalysisSettingsState |
Returns: The analysis meshes. The array is empty if no mesh could be created.
public static Brep[] CreateDevelopableLoft(Curve crv0, Curve crv1, bool reverse0, bool reverse1, int density)
Creates a single developable surface between two curves.
public static Brep[] CreateDevelopableLoft(NurbsCurve rail0, NurbsCurve rail1, IEnumerable<Point2d> fixedRulings)
Creates a single developable surface between two curves.
Parameters:
| rail0 (NurbsCurve) | The first rail curve. |
| rail1 (NurbsCurve) | The second rail curve. |
| fixedRulings (IEnumerable<Point2d>) | 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.
Parameters:
| curves (IEnumerable<Curve>) | A list, an array or any enumerable set of curves. |
Returns: resulting brep or null on failure.
public static Brep[] CreateFilletEdges(Brep brep, IEnumerable<int> edgeIndices, IEnumerable<double> startRadii, IEnumerable<double> endRadii, BlendType blendType, RailType railType, bool setbackFillets, double tolerance, double angleTolerance)
Fillets, chamfers, or blends the edges of a brep.
Parameters:
| brep (Brep) | The brep to fillet, chamfer, or blend edges. |
| edgeIndices (IEnumerable<int>) | An array of one or more edge indices where the fillet, chamfer, or blend will occur. |
| startRadii (IEnumerable<double>) | An array of starting fillet, chamfer, or blend radaii, one for each edge index. |
| endRadii (IEnumerable<double>) | An array of ending fillet, chamfer, or blend radaii, one for each edge index. |
| blendType (BlendType) | The blend type. |
| railType (RailType) | The rail type. |
| setbackFillets (bool) | Use setback fillets (not used with blendType=BlendType.Chamfer) |
| tolerance (double) | The tolerance to be used to perform calculations. |
| angleTolerance (double) | Angle tolerance to be used to perform calculations [radians]. If unsure, use Math.PI/180.0 (one degree) |
Returns: Array of Breps if successful.
public static Brep[] CreateFilletEdges(Brep brep, IEnumerable<int> edgeIndices, IEnumerable<double> startRadii, IEnumerable<double> endRadii, BlendType blendType, RailType railType, double tolerance)
obsoletePrefer the version that takes setbackFillets and angleTolerance options.
Fillets, chamfers, or blends the edges of a brep.
Parameters:
| brep (Brep) | The brep to fillet, chamfer, or blend edges. |
| edgeIndices (IEnumerable<int>) | An array of one or more edge indices where the fillet, chamfer, or blend will occur. |
| startRadii (IEnumerable<double>) | An array of starting fillet, chamfer, or blend radaii, one for each edge index. |
| endRadii (IEnumerable<double>) | An array of ending fillet, chamfer, or blend radaii, one for each edge index. |
| blendType (BlendType) | The blend type. |
| railType (RailType) | The rail type. |
| tolerance (double) | The tolerance to be used to perform calculations. |
Returns: Array of Breps if successful.
public static Brep[] CreateFilletEdgesVariableRadius(Brep brep, IEnumerable<int> edgeIndices, IDictionary<int, IList<BrepEdgeFilletDistance>> edgeDistances, BlendType blendType, RailType railType, bool setbackFillets, double tolerance, double angleTolerance)
Fillets, chamfers, or blends the edges of a brep.
Parameters:
| brep (Brep) | The brep to fillet, chamfer, or blend edges. |
| edgeIndices (IEnumerable<int>) | An array of one or more edge indices where the fillet, chamfer, or blend will occur. |
| edgeDistances (IDictionary<int, IList<BrepEdgeFilletDistance>>) | A dictionary with key the edge index on the input brep, and value a list of BrepEdgeFilletDistance items to apply. |
| blendType (BlendType) | The blend type. |
| railType (RailType) | The rail type. |
| setbackFillets (bool) | Use setback fillets (not used with blendType=BlendType.Chamfer) |
| tolerance (double) | The tolerance to be used to perform calculations. |
| angleTolerance (double) | Angle tolerance to be used to perform calculations [radians]. |
Returns: Array of Breps if successful.
public static bool CreateFilletSurface(BrepFace face0, Point2d uv0, BrepFace face1, Point2d uv1, FilletSurfaceSettings settings, out FilletSurfaceResults results)
Create a fillet (rational arcs or non-rational arc approxiation or chamfered surface
Parameters:
| face0 (BrepFace) | First face to fillet from. |
| uv0 (Point2d) | A parameter face0 at the side you want to keep after filleting. |
| face1 (BrepFace) | Second face to fillet from. |
| uv1 (Point2d) | A parameter face1 at the side you want to keep after filleting. |
| settings (Brep.FilletSurfaceSettings) | The settings to use for filleting/chamfering |
| results (out Brep.FilletSurfaceResults) | If true is returned, this contains the fillet results. |
Returns: true if successful
Exceptions:
| ArgumentNullException |
public static Brep[] CreateFilletSurface(BrepFace face0, Point2d uv0, BrepFace face1, Point2d uv1, double radius, bool extend, double tolerance)
obsoleteUse the CreateFilletSurface that takes settings and returns results
Creates a constant-radius round surface between two surfaces.
Parameters:
| face0 (BrepFace) | First face to fillet from. |
| uv0 (Point2d) | A parameter face0 at the side you want to keep after filleting. |
| face1 (BrepFace) | Second face to fillet from. |
| uv1 (Point2d) | A parameter face1 at the side you want to keep after filleting. |
| radius (double) | The fillet radius. |
| extend (bool) | If true, then when one input surface is longer than the other, the fillet surface is extended to the input surface edges. |
| tolerance (double) | The tolerance. When in doubt, use the document's model absolute tolerance. |
Returns: Array of Breps if successful.
public static Brep[] CreateFilletSurface(BrepFace face0, Point2d uv0, BrepFace face1, Point2d uv1, double radius, bool trim, bool extend, double tolerance, out Brep[] outBreps0, out Brep[] outBreps1)
obsoleteUse the CreateFilletSurface that takes settings and returns results
Creates a constant-radius round surface between two surfaces.
Parameters:
| face0 (BrepFace) | First face to fillet from. |
| uv0 (Point2d) | A parameter face0 at the side you want to keep after filleting. |
| face1 (BrepFace) | Second face to fillet from. |
| uv1 (Point2d) | A parameter face1 at the side you want to keep after filleting. |
| radius (double) | The fillet radius. |
| trim (bool) | If true, the input faces will be trimmed, if false, the input faces will be split. |
| extend (bool) | If true, then when one input surface is longer than the other, the fillet surface is extended to the input surface edges. |
| tolerance (double) | The tolerance. When in doubt, use the document's model absolute tolerance. |
| outBreps0 (out Brep[]) | The trim or split results of the Brep owned by face0. |
| outBreps1 (out Brep[]) | The trim or split results of the Brep owned by face1. |
Returns: Array of Breps if successful.
public static bool CreateFilletSurfaceCurve(BrepFace face, Point2d uv, Curve curve, double t, FilletSurfaceSettings settings, out FilletSurfaceResults results)
Create a fillet (rational arcs or non-rational arc approxiation or chamfered surface
Parameters:
| face (BrepFace) | Face to fillet from. |
| uv (Point2d) | A parameter on the face at the side you want to keep after filleting. |
| curve (Curve) | Curve to fillet to. |
| t (double) | A parameter on the curve close to the point on the face. |
| settings (Brep.FilletSurfaceSettings) | The settings to use for filleting |
| results (out Brep.FilletSurfaceResults) | If true is returned, this contains the fillet results. |
Returns: true if successful
Exceptions:
| ArgumentNullException |
Constructs new brep that matches a bounding box.
Parameters:
| box (BoundingBox) | A box to use for creation. |
Returns: A new brep; or null on failure.
Constructs new brep that matches an aligned box.
Parameters:
| box (Box) | Box to match. |
Returns: A Brep with 6 faces that is similar to the Box.
Constructs new brep from 8 corner points.
Parameters:
| corners (IEnumerable<Point3d>) | 8 points defining the box corners arranged as the vN labels indicate. |
Returns: 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.
public static Brep CreateFromCornerPoints(Point3d corner1, Point3d corner2, Point3d corner3, double tolerance)
Makes a Brep with one face from three corner points.
public static Brep CreateFromCornerPoints(Point3d corner1, Point3d corner2, Point3d corner3, Point3d corner4, double tolerance)
Makes a Brep with one face from four corner points.
Constructs a Brep definition of a cylinder.
Parameters:
| cylinder (Cylinder) | cylinder.IsFinite() must be true. |
| capBottom (bool) | if true end at cylinder.m_height[0] should be capped. |
| capTop (bool) | if true end at cylinder.m_height[1] should be capped. |
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.
public static Brep CreateFromJoinedEdges(Brep brep0, int edgeIndex0, Brep brep1, int edgeIndex1, double joinTolerance)
Joins two naked edges, or edges that are coincident or close together, from two Breps.
public static Brep[] CreateFromLoft(IEnumerable<Curve> curves, Point3d start, Point3d end, bool StartTangent, bool EndTangent, BrepTrim StartTrim, BrepTrim EndTrim, LoftType loftType, bool closed)
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
Parameters:
| curves (IEnumerable<Curve>) | 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 (Point3d) | 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 (Point3d) | 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 (bool) | 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 (bool) | 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) | BrepTrim from the surface edge where start tangent is to be matched |
| EndTrim (BrepTrim) | BrepTrim from the surface edge where end tangent is to be matched |
| loftType (LoftType) | type of loft to perform. |
| closed (bool) | 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.
public static Brep[] CreateFromLoft(IEnumerable<Curve> curves, Point3d start, Point3d end, LoftType loftType, bool closed, double angleTol)
Constructs one or more Breps by lofting through a set of curves.
Parameters:
| curves (IEnumerable<Curve>) | 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 (Point3d) | Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point. |
| end (Point3d) | Optional ending point of loft. Use Point3d.Unset if you do not want to include an end point. |
| loftType (LoftType) | type of loft to perform. |
| closed (bool) | true if the last curve in this loft should be connected back to the first one. |
| angleTol (double) | 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.
public static Brep[] CreateFromLoft(IEnumerable<Curve> curves, Point3d start, Point3d end, LoftType loftType, bool closed)
Constructs one or more Breps by lofting through a set of curves.
Parameters:
| curves (IEnumerable<Curve>) | 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 (Point3d) | Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point. |
| end (Point3d) | Optional ending point of loft. Use Point3d.Unset if you do not want to include an end point. |
| loftType (LoftType) | type of loft to perform. |
| closed (bool) | 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.
public static Brep[] CreateFromLoftRebuild(IEnumerable<Curve> curves, Point3d start, Point3d end, LoftType loftType, bool closed, double angleTol, int rebuildPointCount)
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.
Parameters:
| curves (IEnumerable<Curve>) | 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 (Point3d) | Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point. |
| end (Point3d) | Optional ending point of lost. Use Point3d.Unset if you do not want to include an end point. |
| loftType (LoftType) | type of loft to perform. |
| closed (bool) | true if the last curve in this loft should be connected back to the first one. |
| angleTol (double) | angle tolerance, in radians, used to perform the loft. |
| rebuildPointCount (int) | 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.
public static Brep[] CreateFromLoftRebuild(IEnumerable<Curve> curves, Point3d start, Point3d end, LoftType loftType, bool closed, int rebuildPointCount)
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.
Parameters:
| curves (IEnumerable<Curve>) | 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 (Point3d) | Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point. |
| end (Point3d) | Optional ending point of lost. Use Point3d.Unset if you do not want to include an end point. |
| loftType (LoftType) | type of loft to perform. |
| closed (bool) | true if the last curve in this loft should be connected back to the first one. |
| rebuildPointCount (int) | 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.
public static Brep[] CreateFromLoftRefit(IEnumerable<Curve> curves, Point3d start, Point3d end, LoftType loftType, bool closed, double angleTol, double refitTolerance)
Constructs one or more Breps by lofting through a set of curves. Input for the loft is simplified by refitting to a specified tolerance.
Parameters:
| curves (IEnumerable<Curve>) | 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 (Point3d) | Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point. |
| end (Point3d) | Optional ending point of lost. Use Point3d.Unset if you do not want to include an end point. |
| loftType (LoftType) | type of loft to perform. |
| closed (bool) | true if the last curve in this loft should be connected back to the first one. |
| angleTol (double) | angle tolerance, in radians, used to perform the loft. |
| refitTolerance (double) | 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.
public static Brep[] CreateFromLoftRefit(IEnumerable<Curve> curves, Point3d start, Point3d end, LoftType loftType, bool closed, double refitTolerance)
Constructs one or more Breps by lofting through a set of curves. Input for the loft is simplified by refitting to a specified tolerance.
Parameters:
| curves (IEnumerable<Curve>) | 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 (Point3d) | Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point. |
| end (Point3d) | Optional ending point of lost. Use Point3d.Unset if you do not want to include an end point. |
| loftType (LoftType) | type of loft to perform. |
| closed (bool) | true if the last curve in this loft should be connected back to the first one. |
| refitTolerance (double) | 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.
public static bool CreateFromMatch(BrepEdge edge, Curve targetCurve, MatchSrfSettings settings, out Brep matched, out Brep target)
Match an edge to the target curve using the settings provided
Parameters:
| edge (BrepEdge) | The edge to match. This need to be an untrimmed surface edge. |
| targetCurve (Curve) | The curve to match to. This needs to be a BrepEdge if tangent or curvature matching is requested. |
| settings (MatchSrfSettings) | The settings used for matching |
| matched (out Brep) | If successful, this contains the matched brep |
| target (out Brep) | If successful and MatchSrfSettings.Average is true, this contains the changed target brep. |
public static bool CreateFromMatch(BrepEdge edge, IEnumerable<Curve> targetCurves, MatchSrfSettings settings, out Brep matched, out Brep target)
Match an edge to the target curves using the settings provided
Parameters:
| edge (BrepEdge) | The edge to match. This need to be an untrimmed surface edge. |
| targetCurves (IEnumerable<Curve>) | The curves to match to. These need to be BrepEdge if tangent or curvature matching is requested. |
| settings (MatchSrfSettings) | The settings used for matching |
| matched (out Brep) | If successful, this contains the matched brep |
| target (out Brep) | If successful and MatchSrfSettings.Average is true, this contains the changed target brep. |
Create a brep representation of a mesh
public static Brep CreateFromOffsetFace(BrepFace face, double offsetDistance, double offsetTolerance, bool bothSides, bool createSolid)
Offsets a face including trim information to create a new brep.
Parameters:
| face (BrepFace) | the face to offset. |
| offsetDistance (double) | An offset distance. |
| offsetTolerance (double) | Use 0.0 to make a loose offset. Otherwise, the document's absolute tolerance is usually sufficient. |
| bothSides (bool) | When true, offset to both sides of the input face. |
| createSolid (bool) | 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.
Parameters:
| surface (RevSurface) | The surface of revolution. |
| capStart (bool) | 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 (bool) | 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.
Parameters:
| sphere (Sphere) | The input sphere provides the orienting plane and radius. |
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.
Parameters:
| surface (Surface) | A surface to convert. |
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).
Parameters:
| rail (Curve) | Rail to sweep shapes along. |
| shape (Curve) | Shape curve. |
| closed (bool) | Only matters if shape is closed. |
| tolerance (double) | Tolerance for fitting surface and rails. |
Returns: Array of Brep sweep results.
public static Brep[] CreateFromSweep(Curve rail, IEnumerable<Curve> shapes, bool closed, double tolerance)
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).
Parameters:
| rail (Curve) | Rail to sweep shapes along. |
| shapes (IEnumerable<Curve>) | Shape curves. |
| closed (bool) | Only matters if shapes are closed. |
| tolerance (double) | Tolerance for fitting surface and rails. |
Returns: Array of Brep sweep results.
public static Brep[] CreateFromSweep(Curve rail, IEnumerable<Curve> shapes, Point3d startPoint, Point3d endPoint, SweepFrame frameType, Vector3d roadlikeNormal, bool closed, SweepBlend blendType, SweepMiter miterType, double tolerance, SweepRebuild rebuildType, int rebuildPointCount, double refitTolerance, bool refitRail)
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.
Remarks: This version mimics what Rhino's Sweep1 command does.
Parameters:
| rail (Curve) | 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 (IEnumerable<Curve>) | Shape curves. |
| startPoint (Point3d) | Optional starting point of sweep. Use Point3d.Unset if you do not want to include a start point. |
| endPoint (Point3d) | Optional ending point of sweep. Use Point3d.Unset if you do not want to include an end point. |
| frameType (SweepFrame) | The frame type. |
| roadlikeNormal (Vector3d) | The roadlike normal directoion. Use Vector3d.Unset if the frame type is not set to roadlike. |
| closed (bool) | Only matters if shapes are closed. |
| blendType (SweepBlend) | The shape blending type. |
| miterType (SweepMiter) | The mitering type. |
| tolerance (double) | |
| rebuildType (SweepRebuild) | The rebuild style. |
| rebuildPointCount (int) | If rebuild == SweepRebuild.Rebuild, the number of points. Otherwise specify 0. |
| refitTolerance (double) | If rebuild == SweepRebuild.Refit, the refit tolerance. Otherwise, specify 0.0. |
| refitRail (bool) | false = segmented sweep, true = refit-rail sweep. |
Returns: Array of Brep sweep results.
public static Brep[] CreateFromSweep(Curve rail, IEnumerable<Curve> shapes, Point3d startPoint, Point3d endPoint, SweepFrame frameType, Vector3d roadlikeNormal, bool closed, SweepBlend blendType, SweepMiter miterType, double tolerance, SweepRebuild rebuildType, int rebuildPointCount, double refitTolerance)
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.
Remarks: Rhino's Sweep1 command uses this when the "refit rail" option is enabled (true).
Parameters:
| rail (Curve) | Rail to sweep shapes along. |
| shapes (IEnumerable<Curve>) | Shape curves. |
| startPoint (Point3d) | Optional starting point of sweep. Use Point3d.Unset if you do not want to include a start point. |
| endPoint (Point3d) | Optional ending point of sweep. Use Point3d.Unset if you do not want to include an end point. |
| frameType (SweepFrame) | The frame type. |
| roadlikeNormal (Vector3d) | The roadlike normal directoion. Use Vector3d.Unset if the frame type is not set to roadlike. |
| closed (bool) | Only matters if shapes are closed. |
| blendType (SweepBlend) | The shape blending type. |
| miterType (SweepMiter) | The mitering type. |
| tolerance (double) | |
| rebuildType (SweepRebuild) | The rebuild style. |
| rebuildPointCount (int) | If rebuild == SweepRebuild.Rebuild, the number of points. Otherwise specify 0. |
| refitTolerance (double) | If rebuild == SweepRebuild.Refit, the refit tolerance. Otherwise, specify 0.0 |
Returns: Array of Brep sweep results.
public static Brep[] CreateFromSweep(Curve rail1, Curve rail2, Curve shape, bool closed, double tolerance)
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.
public static Brep[] CreateFromSweep(Curve rail1, Curve rail2, IEnumerable<Curve> shapes, bool closed, double tolerance)
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.
public static Brep[] CreateFromSweep(Curve rail1, Curve rail2, IEnumerable<Curve> shapes, Point3d start, Point3d end, bool closed, double tolerance, SweepRebuild rebuild, int rebuildPointCount, double refitTolerance, bool preserveHeight, bool autoAdjust)
Sweep2 function that fits a surface through profile curves that define the surface cross-sections and two curves that defines the surface edges.
Parameters:
| rail1 (Curve) | Rail to sweep shapes along |
| rail2 (Curve) | Rail to sweep shapes along |
| shapes (IEnumerable<Curve>) | Shape curves |
| start (Point3d) | Optional starting point of sweep. Use Point3d.Unset if you do not want to include a start point. |
| end (Point3d) | Optional ending point of sweep. Use Point3d.Unset if you do not want to include an end point. |
| closed (bool) | Only matters if shapes are closed. |
| tolerance (double) | Tolerance for fitting surface and rails. |
| rebuild (SweepRebuild) | The rebuild style. |
| rebuildPointCount (int) | If rebuild == SweepRebuild.Rebuild, the number of points. Otherwise specify 0. |
| refitTolerance (double) | If rebuild == SweepRebuild.Refit, the refit tolerance. Otherwise, specify 0.0 |
| preserveHeight (bool) | Removes the association between the height scaling from the width scaling |
| autoAdjust (bool) | 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
public static Brep[] CreateFromSweep(Curve rail1, Curve rail2, IEnumerable<Curve> shapes, Point3d start, Point3d end, bool closed, double tolerance, SweepRebuild rebuild, int rebuildPointCount, double refitTolerance, bool preserveHeight)
Sweep2 function that fits a surface through profile curves that define the surface cross-sections and two curves that defines the surface edges.
Parameters:
| rail1 (Curve) | Rail to sweep shapes along |
| rail2 (Curve) | Rail to sweep shapes along |
| shapes (IEnumerable<Curve>) | Shape curves |
| start (Point3d) | Optional starting point of sweep. Use Point3d.Unset if you do not want to include a start point. |
| end (Point3d) | Optional ending point of sweep. Use Point3d.Unset if you do not want to include an end point. |
| closed (bool) | Only matters if shapes are closed. |
| tolerance (double) | Tolerance for fitting surface and rails. |
| rebuild (SweepRebuild) | The rebuild style. |
| rebuildPointCount (int) | If rebuild == SweepRebuild.Rebuild, the number of points. Otherwise specify 0. |
| refitTolerance (double) | If rebuild == SweepRebuild.Refit, the refit tolerance. Otherwise, specify 0.0 |
| preserveHeight (bool) | Removes the association between the height scaling from the width scaling |
Returns: Array of Brep sweep results
public static Brep[] CreateFromSweepInParts(Curve rail1, Curve rail2, IEnumerable<Curve> shapes, IEnumerable<Point2d> rail_params, bool closed, double tolerance)
Makes a 2 rail sweep. Like CreateFromSweep but the result is split where parameterization along a rail changes abruptly.
Parameters:
| rail1 (Curve) | Rail to sweep shapes along |
| rail2 (Curve) | Rail to sweep shapes along |
| shapes (IEnumerable<Curve>) | Shape curves |
| rail_params (IEnumerable<Point2d>) | Shape parameters |
| closed (bool) | Only matters if shapes are closed |
| tolerance (double) | Tolerance for fitting surface and rails |
Returns: Array of Brep sweep results
public static Brep[] CreateFromSweepSegmented(Curve rail, Curve shape, bool closed, double tolerance)
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).
Parameters:
| rail (Curve) | Rail to sweep shapes along |
| shape (Curve) | Shape curve |
| closed (bool) | Only matters if shape is closed |
| tolerance (double) | Tolerance for fitting surface and rails |
Returns: Array of Brep sweep results
public static Brep[] CreateFromSweepSegmented(Curve rail, IEnumerable<Curve> shapes, bool closed, double tolerance)
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).
Parameters:
| rail (Curve) | Rail to sweep shapes along. |
| shapes (IEnumerable<Curve>) | Shape curves. |
| closed (bool) | Only matters if shapes are closed. |
| tolerance (double) | Tolerance for fitting surface and rails. |
Returns: Array of Brep sweep results.
public static Brep[] CreateFromSweepSegmented(Curve rail, IEnumerable<Curve> shapes, Point3d startPoint, Point3d endPoint, SweepFrame frameType, Vector3d roadlikeNormal, bool closed, SweepBlend blendType, SweepMiter miterType, double tolerance, SweepRebuild rebuildType, int rebuildPointCount, double refitTolerance)
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).
Parameters:
| rail (Curve) | Rail to sweep shapes along. |
| shapes (IEnumerable<Curve>) | Shape curves. |
| startPoint (Point3d) | Optional starting point of sweep. Use Point3d.Unset if you do not want to include a start point. |
| endPoint (Point3d) | Optional ending point of sweep. Use Point3d.Unset if you do not want to include an end point. |
| frameType (SweepFrame) | The frame type. |
| roadlikeNormal (Vector3d) | The roadlike normal directoion. Use Vector3d.Unset if the frame type is not set to roadlike. |
| closed (bool) | Only matters if shapes are closed. |
| blendType (SweepBlend) | The shape blending type. |
| miterType (SweepMiter) | The mitering type. |
| tolerance (double) | |
| rebuildType (SweepRebuild) | The rebuild style. |
| rebuildPointCount (int) | If rebuild == SweepRebuild.Rebuild, the number of points. Otherwise specify 0. |
| refitTolerance (double) | If rebuild == SweepRebuild.Refit, the refit tolerance. Otherwise, specify 0.0 |
Returns: Array of Brep sweep results.
public static Brep[] CreateFromTaperedExtrude(Curve curveToExtrude, double distance, Vector3d direction, Point3d basePoint, double draftAngleRadians, ExtrudeCornerType cornerType, double tolerance, double angleToleranceRadians)
Extrude a curve to a taper making a brep (potentially more than 1)
Parameters:
| curveToExtrude (Curve) | the curve to extrude |
| distance (double) | the distance to extrude |
| direction (Vector3d) | the direction of the extrusion |
| basePoint (Point3d) | the base point of the extrusion |
| draftAngleRadians (double) | angle of the extrusion |
| cornerType (ExtrudeCornerType) | |
| tolerance (double) | tolerance to use for the extrusion |
| angleToleranceRadians (double) | angle tolerance to use for the extrusion |
Returns: array of breps on success
public static Brep[] CreateFromTaperedExtrude(Curve curveToExtrude, double distance, Vector3d direction, Point3d basePoint, double draftAngleRadians, ExtrudeCornerType cornerType)
obsoleteUse version that takes tolerance as input
Extrude a curve to a taper making a brep (potentially more than 1)
Remarks: tolerances used are based on the active doc tolerance
Parameters:
| curveToExtrude (Curve) | the curve to extrude |
| distance (double) | the distance to extrude |
| direction (Vector3d) | the direction of the extrusion |
| basePoint (Point3d) | the base point of the extrusion |
| draftAngleRadians (double) | angle of the extrusion |
| cornerType (ExtrudeCornerType) |
Returns: array of breps on success
public static Brep[] CreateFromTaperedExtrudeWithRef(Curve curve, Vector3d direction, double distance, double draftAngle, Plane plane, double tolerance)
Creates one or more Breps by extruding a curve a distance along an axis with draft angle.
Parameters:
| curve (Curve) | The curve to extrude. |
| direction (Vector3d) | The extrusion direction. |
| distance (double) | The extrusion distance. |
| draftAngle (double) | The extrusion draft angle in radians. |
| plane (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 (double) | The intersecting and trimming tolerance. |
Returns: An array of Breps if successful.
Constructs a Brep definition of a torus.
Parameters:
| torus (Torus) | The torus. |
Returns: A Brep representation of the torus if successful, null otherwise.
public static Brep[] CreateOffsetBrep(Brep brep, double distance, bool solid, bool extend, bool shrink, double tolerance, out Brep[] outBlends, out Brep[] outWalls)
Offsets a Brep.
Parameters:
| brep (Brep) | The Brep to offset. |
| distance (double) | The distance to offset. This is a signed distance value with respect to face normals and flipped faces. |
| solid (bool) | 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 (bool) | 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 (bool) | If true, then the function shrinks the underlying surfaces to their face's outer boundary loop. |
| tolerance (double) | The offset tolerance. |
| outBlends (out Brep[]) | The results of the calculation. |
| outWalls (out Brep[]) | 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).
public static Brep[] CreateOffsetBrep(Brep brep, double distance, bool solid, bool extend, double tolerance, out Brep[] outBlends, out Brep[] outWalls)
Offsets a Brep.
Parameters:
| brep (Brep) | The Brep to offset. |
| distance (double) | The distance to offset. This is a signed distance value with respect to face normals and flipped faces. |
| solid (bool) | 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 (bool) | 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 (double) | The offset tolerance. |
| outBlends (out Brep[]) | The results of the calculation. |
| outWalls (out Brep[]) | 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).
public static Brep CreatePatch(IEnumerable<GeometryBase> geometry, int uSpans, int vSpans, double tolerance)
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.
Parameters:
| geometry (IEnumerable<GeometryBase>) | 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 (int) | The number of spans in the U direction. |
| vSpans (int) | The number of spans in the V direction. |
| tolerance (double) | Tolerance used by input analysis functions for loop finding, trimming, etc. |
Returns: A brep fit through input on success, or null on error.
public static Brep CreatePatch(IEnumerable<GeometryBase> geometry, Surface startingSurface, double tolerance)
Constructs a brep patch.
This is the simple version of fit that uses a specified starting surface.
Parameters:
| geometry (IEnumerable<GeometryBase>) | Combination of Curves, BrepTrims, Points, PointClouds or Meshes. Curves and trims are sampled to get points. Trims are sampled for points and normals. |
| startingSurface (Surface) | A starting surface (can be null). |
| tolerance (double) | Tolerance used by input analysis functions for loop finding, trimming, etc. |
Returns: Brep fit through input on success, or null on error.
public static Brep CreatePatch(IEnumerable<GeometryBase> geometry, Surface startingSurface, int uSpans, int vSpans, bool trim, bool tangency, double pointSpacing, double flexibility, double surfacePull, bool[] fixEdges, double tolerance)
Constructs a brep patch using all controls
Parameters:
| geometry (IEnumerable<GeometryBase>) | 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 (Surface) | A starting surface (can be null). |
| uSpans (int) | Number of surface spans used when a plane is fit through points to start in the U direction. |
| vSpans (int) | Number of surface spans used when a plane is fit through points to start in the U direction. |
| trim (bool) | If true, try to find an outer loop from among the input curves and trim the result to that loop |
| tangency (bool) | 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 (double) | Basic distance between points sampled from input curves. |
| flexibility (double) | 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 (double) | Tends to keep the result surface where it was before the fit in areas where there is on influence from the input geometry |
| fixEdges (bool[]) | 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 (double) | Tolerance used by input analysis functions for loop finding, trimming, etc. |
Returns: A brep fit through input on success, or null on error.
public static Brep[] CreatePipe(Curve rail, double radius, bool localBlending, PipeCapMode cap, bool fitRail, double absoluteTolerance, double angleToleranceRadians)
Creates a single walled pipe.
Parameters:
| rail (Curve) | The rail, or path, curve. |
| radius (double) | The radius of the pipe. |
| localBlending (bool) | 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 (PipeCapMode) | The end cap mode. |
| fitRail (bool) | 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 (double) | The sweeping and fitting tolerance. When in doubt, use the document's absolute tolerance. |
| angleToleranceRadians (double) | The angle tolerance. When in doubt, use the document's angle tolerance in radians. |
Returns: Array of Breps success.
public static Brep[] CreatePipe(Curve rail, IEnumerable<double> railRadiiParameters, IEnumerable<double> radii, bool localBlending, PipeCapMode cap, bool fitRail, double absoluteTolerance, double angleToleranceRadians)
Creates a single walled pipe.
Parameters:
| rail (Curve) | The rail, or path, curve. |
| railRadiiParameters (IEnumerable<double>) | 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 (IEnumerable<double>) | One or more radii - one at each normalized curve parameter in railRadiiParameters. |
| localBlending (bool) | 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 (PipeCapMode) | The end cap mode. |
| fitRail (bool) | 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 (double) | The sweeping and fitting tolerance. When in doubt, use the document's absolute tolerance. |
| angleToleranceRadians (double) | 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.
obsoleteUse version that takes tolerance as input
Constructs a set of planar breps as outlines by the loops.
Parameters:
| inputLoop (Curve) | A curve that should form the boundaries of the surfaces or polysurfaces. |
Returns: An array of Planar Breps.
Constructs a set of planar Breps as outlines by the loops.
obsoleteUse version that takes tolerance as input
Constructs a set of planar Breps as outlines by the loops.
Parameters:
| inputLoops (CurveList) | Curve loops that delineate the planar boundaries. |
Returns: An array of Planar Breps or null on error.
Constructs a set of planar breps as outlines by the loops.
Parameters:
| inputLoops (IEnumerable<Curve>) | Curve loops that delineate the planar boundaries. |
| tolerance (double) |
Returns: An array of Planar Breps.
obsoleteUse version that takes tolerance as input
Constructs a set of planar breps as outlines by the loops.
Parameters:
| inputLoops (IEnumerable<Curve>) | Curve loops that delineate the planar boundaries. |
Returns: An array of Planar Breps.
CreatePlanarBrepsWithIndexMap
#public static Brep[] CreatePlanarBrepsWithIndexMap(IEnumerable<Curve> inputLoops, double tolerance, out int[][] indexMap)
Constructs a set of planar Breps as outlines by the loops, reporting which input curves bounded each Brep.
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.Parameters:
| inputLoops (IEnumerable<Curve>) | Curve loops that delineate the planar boundaries. |
| tolerance (double) | Tolerance to use when sorting and building the loops. |
| indexMap (out int[][]) | 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. |
Returns: An array of planar Breps, or null on failure.
CreatePlanarDifference
CreatePlanarIntersection
CreatePlanarUnion
CreatePlanarUnion
Parameters:
| breps (IEnumerable<Brep>) | The planar regions on which to perform the union operation. |
| plane (Plane) | The plane in which all the input breps lie |
| tolerance (double) | Tolerance to use for union operation. |
Returns: An array of Brep results or null on failure.
Constructs a Brep definition of a quad sphere.
Parameters:
| sphere (Sphere) | The input sphere provides the orienting plane and radius. |
Returns: A Brep if successful, null on error.
public static Brep[] CreateShell(Brep brep, IEnumerable<int> facesToRemove, double distance, double tolerance)
Creates a hollowed out shell from a solid Brep. Function only operates on simple, solid, manifold Breps.
Parameters:
| brep (Brep) | The solid Brep to shell. |
| facesToRemove (IEnumerable<int>) | 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 (double) | The distance, or thickness, for the shell. This is a signed distance value with respect to face normals and flipped faces. |
| tolerance (double) | 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.
Parameters:
| breps (IEnumerable<Brep>) | The intersecting surfaces and polysurfaces to automatically trim and join into closed polysurfaces. |
| tolerance (double) | 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.
public static Brep[] CreateThickPipe(Curve rail, double radius0, double radius1, bool localBlending, PipeCapMode cap, bool fitRail, double absoluteTolerance, double angleToleranceRadians)
Creates a double-walled pipe.
Parameters:
| rail (Curve) | The rail, or path, curve. |
| radius0 (double) | The first radius of the pipe. |
| radius1 (double) | The second radius of the pipe. |
| localBlending (bool) | 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 (PipeCapMode) | The end cap mode. |
| fitRail (bool) | 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 (double) | The sweeping and fitting tolerance. When in doubt, use the document's absolute tolerance. |
| angleToleranceRadians (double) | The angle tolerance. When in doubt, use the document's angle tolerance in radians. |
Returns: Array of Breps success.
public static Brep[] CreateThickPipe(Curve rail, IEnumerable<double> railRadiiParameters, IEnumerable<double> radii0, IEnumerable<double> radii1, bool localBlending, PipeCapMode cap, bool fitRail, double absoluteTolerance, double angleToleranceRadians)
Creates a double-walled pipe.
Parameters:
| rail (Curve) | The rail, or path, curve. |
| railRadiiParameters (IEnumerable<double>) | 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 (IEnumerable<double>) | One or more radii for the first wall - one at each normalized curve parameter in railRadiiParameters. |
| radii1 (IEnumerable<double>) | One or more radii for the second wall - one at each normalized curve parameter in railRadiiParameters. |
| localBlending (bool) | 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 (PipeCapMode) | The end cap mode. |
| fitRail (bool) | 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 (double) | The sweeping and fitting tolerance. When in doubt, use the document's absolute tolerance. |
| angleToleranceRadians (double) | The angle tolerance. When in doubt, use the document's angle tolerance in radians. |
Returns: Array of Breps success.
Create a Brep trimmed plane.
Create a Brep trimmed plane.
Parameters:
| plane (Plane) | Plane that will be trimmed. |
| curves (IEnumerable<Curve>) | 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.
public static Brep CreateTrimmedSurface(BrepFace trimSource, Surface surfaceSource, double tolerance)
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
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.
public static Brep CreateVariationalPatch(IEnumerable<CurveConstraint> edges, IEnumerable<CurveConstraint> internalCurves, IEnumerable<PointConstraint> points, VariationalPatchSettings settings, bool multiThreading, CancellationToken cancelToken, IProgress<double> progress, out VariationalPatchResult results)
Create a patch using variational approach
Parameters:
| edges (IEnumerable<Brep.CurveConstraint>) | Edges with continuity constraints |
| internalCurves (IEnumerable<Brep.CurveConstraint>) | Internal curves |
| points (IEnumerable<Brep.PointConstraint>) | Internal points |
| settings (Brep.VariationalPatchSettings) | The settings to use while creating the surface |
| multiThreading (bool) | Use multi-threading during the calculation |
| cancelToken (CancellationToken) | The cancellation token. |
| progress (IProgress<double>) | The provider for progress updates. |
| results (out Brep.VariationalPatchResult) | The results of the patching algorithm. |
Returns: Trimmed surface if successful, null otherwise
public static Brep CreateVariationalPatch(RhinoDoc doc, IEnumerable<CurveConstraint> edges, IEnumerable<CurveConstraint> internalCurves, IEnumerable<PointConstraint> points, VariationalPatchSettings settings, bool multiThreading, CancellationToken cancelToken, IProgress<double> progress, out VariationalPatchResult results)
Create a patch using variational approach
Parameters:
| doc (RhinoDoc) | The Rhino document. Use null if not available. |
| edges (IEnumerable<Brep.CurveConstraint>) | Edges with continuity constraints |
| internalCurves (IEnumerable<Brep.CurveConstraint>) | Internal curves |
| points (IEnumerable<Brep.PointConstraint>) | Internal points |
| settings (Brep.VariationalPatchSettings) | The settings to use while creating the surface |
| multiThreading (bool) | Use multi-threading during the calculation |
| cancelToken (CancellationToken) | The cancellation token. |
| progress (IProgress<double>) | The provider for progress updates. |
| results (out Brep.VariationalPatchResult) | 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.
public static Brep[] CutUpSurface(Surface surface, IEnumerable<Curve> curves, bool flip, double fitTolerance, double keepTolerance)
Splits, or cuts up, a surface. Designed to split the underlying surface of a Brep face with edge curves.
Parameters:
| surface (Surface) | The surface to cut up. |
| curves (IEnumerable<Curve>) | The edge curves with consistent orientation. The curves should lie on the surface. |
| flip (bool) | If true, the input curves are oriented clockwise. |
| fitTolerance (double) | The fitting tolerance. |
| keepTolerance (double) | 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.
public static Brep[] CutUpSurface(Surface surface, IEnumerable<Curve> curves, bool useEdgeCurves, double tolerance)
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.
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.
Parameters:
| surface (Surface) | The surface. |
| curves (IEnumerable<Curve>) | The curves. |
| useEdgeCurves (bool) | 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 (double) | The fitting tolerance. When in doubt, use the document's model absolute tolerance. |
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.
Parameters:
| currentRemainder (uint) | The current remainder value. |
Returns: CRC of the information the defines the object.
DeleteAllUserStrings
public void DeleteAllUserStrings()
Parameters:
| key (string) |
public void DestroyRegionTopology()
Destroys a Brep's region topology information.
Dispose
public void Dispose()
Actively reclaims unmanaged resources that this instance uses.
Dispose
Overridden in order to destroy local display cache information
Parameters:
| disposing (bool) |
Overrides: CommonObject.Dispose
Copies this brep.
Returns: A brep.
Overrides: GeometryBase.Duplicate
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.
Parameters:
| nakedOnly (bool) | If true, then only the "naked" edges are duplicated. If false, then all edges are duplicated. |
Returns: Array of edge curves on success.
Duplicate naked edges of this Brep.
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.
Parameters:
| faceIndices (IEnumerable<int>) | 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
public void 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 static bool ExtendBrepFacesToConnect(BrepFace Face0, int edgeIndex0, BrepFace Face1, int edgeIndex1, double tol, double angleTol, out Brep outBrep0, out Brep outBrep1)
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
Parameters:
| Face0 (BrepFace) | [in] first face to connect |
| edgeIndex0 (int) | [in] edge to extend. |
| Face1 (BrepFace) | [in] second surface |
| edgeIndex1 (int) | [in] edge to extend. |
| tol (double) | [in] tolerance used for intersecting faces and simplifing extension curve |
| angleTol (double) | [in] angle tolerance in radians used for simplifying extendsion curve |
| outBrep0 (out Brep) | [out] first face extended and trimmed to connect with the second face |
| outBrep1 (out Brep) | [out] second face extended and trimmed to connect with the first face |
Returns: true if valid connection found
public static bool ExtendBrepFacesToConnect(BrepFace Face0, Point3d f0_sel_pt, BrepFace Face1, Point3d f1_sel_pt, double tol, double angleTol, out Brep outBrep0, out Brep outBrep1)
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
Parameters:
| Face0 (BrepFace) | [in] first face to connect |
| f0_sel_pt (Point3d) | selection point on first face near the edge to extend. |
| Face1 (BrepFace) | [in] second surface |
| f1_sel_pt (Point3d) | selection point on second face near the edge to extend. |
| tol (double) | [in] tolerance used for intersecting faces and simplifing extension curve |
| angleTol (double) | [in] angle tolerance in radians used for simplifying extendsion curve |
| outBrep0 (out Brep) | [out] first face extended and trimmed to connect with the second face |
| outBrep1 (out Brep) | [out] second face extended and trimmed to connect with the first face |
Returns: true if valid connection found
[ConstOperation]
public void FindCoincidentBrepComponents(Point3d point, double tolerance, out int[] faces, out int[] edges, out int[] vertices)
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.
GetBoundingBox
Bounding box solver. Gets the world axis aligned bounding box for the geometry.
Parameters:
| accurate (bool) | 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.
GetBoundingBox
Aligned Bounding box solver. Gets the plane aligned bounding box.
Parameters:
| plane (Plane) | Orientation plane for BoundingBox. |
Returns: A BoundingBox in plane coordinates.
GetBoundingBox
Aligned Bounding box solver. Gets the world axis aligned bounding box for the transformed geometry.
Parameters:
| xform (Transform) | 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
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
Populates a System.Runtime.Serialization.SerializationInfo with the data needed to serialize the target object.
Parameters:
| info (SerializationInfo) | The System.Runtime.Serialization.SerializationInfo to populate with data. |
| context (StreamingContext) | The destination (see System.Runtime.Serialization.StreamingContext) for this serialization. |
Finds a point inside of a solid Brep.
Parameters:
| tolerance (double) | Used for intersecting rays and is not necessarily related to the distance from the brep to the found point. When in doubt, use the document's model absolute tolerance. |
| point (out Point3d) | A point inside the 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.
[ConstOperation]
public Brep[] GetTangentConnectedComponents(double angleTolerance, bool includeMeshes)
If this Brep has two or more components connected by tangent edges, then duplicates of the connected components are returned.
Parameters:
| key (string) | id used to retrieve the string. |
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.
Constructs all the Wireframe curves for this Brep.
Parameters:
| density (int) | Wireframe density. Valid values range between -1 and 99. |
Returns: An array of Wireframe curves or null on failure.
[ConstOperation]
public Brep InsetFaces(IEnumerable<int> faceIndices, double distance, bool loose, bool ignoreSeams, bool creaseCorners, double tolerance, double angleTolerance)
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.
Parameters:
| faceIndices (IEnumerable<int>) | the indices of the faces to inset |
| distance (double) | The distance to offset along the face |
| loose (bool) | If true, offset by moving edit points otherwise offset within tolerance. |
| ignoreSeams (bool) | If true, the seam edges are not offset and adjacent edges are extended to meet the seam. Otherwise offset normally. |
| creaseCorners (bool) | If true, splitting curves will be made between the creases on edge curves and creases on the inset curves. |
| tolerance (double) | The fitting tolerance for the offset. When in doubt, use the document's absolute tolerance. |
| angleTolerance (double) | 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.
Parameters:
| tolerance (double) | The tolerance used to determine if faces are planar and to compare face normals. |
Returns: true if the Brep is a solid box, false otherwise.
See if this and other are same brep geometry.
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.
Parameters:
| tolerance (double) | tolerance to use when checking. |
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.
Parameters:
| isOriented (out bool) | Set to true if the Brep is an oriented manifold, or false if the Brep is not an oriented manifold. |
| hasBoundary (out bool) | Set to true if the Brep has a boundary edge, or false if the Brep does not have a boundary edge. |
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.
Parameters:
| point (Point3d) | 3d point to test. |
| tolerance (double) | 3d distance tolerance used for intersection and determining strict inclusion. A good default is RhinoMath.SqrtEpsilon. |
| strictlyIn (bool) | 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.
Parameters:
| log (out string) | 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.
Parameters:
| log (out string) | 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.
Parameters:
| log (out string) | 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.
Parameters:
| log (out string) | A textual log. This out parameter is assigned during this call. |
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.
Parameters:
| otherBrep (Brep) | Brep to be added to this brep. |
| tolerance (double) | 3d distance tolerance for detecting overlapping edges. |
| compact (bool) | if true, set brep flags and tolerances, remove unused faces and edges. |
Returns: true if any edges were joined.
public static Brep[] JoinBreps(IEnumerable<Brep> brepsToJoin, double tolerance, double angleTolerance, out List<int[]> indexMap)
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.
Parameters:
| brepsToJoin (IEnumerable<Brep>) | A list, an array or any enumerable set of breps to join. |
| tolerance (double) | 3d distance tolerance for detecting overlapping edges. When in doubt, use the document's model absolute tolerance. |
| angleTolerance (double) | Angle tolerance, in radians, used for merging edges. When in doubt, use the document's model angle tolerance. |
| indexMap (out List<int[]>) | 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.
public static Brep[] JoinBreps(IEnumerable<Brep> brepsToJoin, double tolerance, double angleTolerance)
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.
Parameters:
| brepsToJoin (IEnumerable<Brep>) | A list, an array or any enumerable set of breps to join. |
| tolerance (double) | 3d distance tolerance for detecting overlapping edges. When in doubt, use the document's model absolute tolerance. |
| angleTolerance (double) | 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.
Parameters:
| brepsToJoin (IEnumerable<Brep>) | A list, an array or any enumerable set of breps to join. |
| tolerance (double) | 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.
Parameters:
| edgeIndex0 (int) | The first edge index. |
| edgeIndex1 (int) | The second edge index. |
| joinTolerance (double) | The join tolerance. |
| compact (bool) | 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.
Parameters:
| tolerance (double) | The tolerance value. |
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.
Parameters:
| brepsToMerge (IEnumerable<Brep>) | must contain more than one Brep. |
| tolerance (double) | the tolerance to use when merging. |
Returns: Single merged Brep on success. Null on error.
Merges adjacent coplanar faces into single faces.
Parameters:
| tolerance (double) | Tolerance for determining when edges are adjacent. When in doubt, use the document's ModelAbsoluteTolerance property. |
| angleTolerance (double) | 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.
Parameters:
| tolerance (double) | Tolerance for determining when edges are adjacent. When in doubt, use the document's ModelAbsoluteTolerance property. |
Returns: true if faces were merged, false if no faces were merged.
Merges coplanar faces adjacent to Brep face into a single face.
Parameters:
| faceIndex (int) | The index of the Brep face to search. |
| tolerance (double) | Tolerance for determining when edges are adjacent. When in doubt, use the document's ModelAbsoluteTolerance property. |
| angleTolerance (double) | 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.
public bool MergeCoplanarFaces(int faceIndex0, int faceIndex1, double tolerance, double angleTolerance)
Merges two coplanar, adjacent Brep faces into a single face.
Parameters:
| faceIndex0 (int) | The index of the first Brep face. |
| faceIndex1 (int) | The index of the second Brep face. |
| tolerance (double) | Tolerance for determining when edges are adjacent. When in doubt, use the document's ModelAbsoluteTolerance property. |
| angleTolerance (double) | 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.
public static Brep MergeSurfaces(Brep brep0, Brep brep1, double tolerance, double angleToleranceRadians, Point2d point0, Point2d point1, double roundness, bool smooth)
Merges two surfaces into one surface at untrimmed edges. Both surfaces must be untrimmed and share an edge.
Parameters:
| brep0 (Brep) | The first single-face Brep to merge. |
| brep1 (Brep) | The second single-face Brep to merge. |
| tolerance (double) | Surface edges must be within this tolerance for the two surfaces to merge. |
| angleToleranceRadians (double) | Edge must be within this angle tolerance in order for contiguous edges to be combined into a single edge. |
| point0 (Point2d) | 2D pick point on the first single-face Brep. The value can be unset. |
| point1 (Point2d) | 2D pick point on the second single-face Brep. The value can be unset. |
| roundness (double) | Defines the roundness of the merge. Acceptable values are between 0.0 (sharp) and 1.0 (smooth). |
| smooth (bool) | 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.
public static Brep MergeSurfaces(Brep brep0, Brep brep1, double tolerance, double angleToleranceRadians)
Merges two surfaces into one surface at untrimmed edges. Both surfaces must be untrimmed and share an edge.
Parameters:
| brep0 (Brep) | The first single-face Brep to merge. |
| brep1 (Brep) | The second single-face Brep to merge. |
| tolerance (double) | Surface edges must be within this tolerance for the two surfaces to merge. |
| angleToleranceRadians (double) | 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.
public static Brep MergeSurfaces(Surface surface0, Surface surface1, double tolerance, double angleToleranceRadians)
Merges two surfaces into one surface at untrimmed edges.
Parameters:
| surface0 (Surface) | The first surface to merge. |
| surface1 (Surface) | The second surface to merge. |
| tolerance (double) | Surface edges must be within this tolerance for the two surfaces to merge. |
| angleToleranceRadians (double) | 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
protected override void NonConstOperation()
Destroy cache handle
Overrides: CommonObject.NonConstOperation
OnSwitchToNonConst
protected override void OnSwitchToNonConst()
Is called when a non-constant operation occurs.
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.
Parameters:
| angleToleranceRadians (double) | Angle tolerance, in radians, used to split kinky faces. When in doubt, use the document's model angle tolerance. |
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.
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.
Remarks: Don't call this function unless you know exactly what you are doing.
Parameters:
| face (BrepFace) | Face whose underlying surface has a parameterization that is different from its NURBS form. |
| nurbsSurface (NurbsSurface) | NURBS form of the face's underlying surface. |
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.
Parameters:
| tolerance (double) | The tolerance. When in doubt, use the document's model absolute tolerance. |
Returns: The Brep without holes if successful, null otherwise.
Removes inner loops, or holes, in a Brep.
Parameters:
| loops (IEnumerable<ComponentIndex>) | A list of BrepLoop component indexes, where BrepLoop.LoopType == Rhino.Geometry.BrepLoopType.Inner. |
| tolerance (double) | 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.
Parameters:
| tolerance (double) | The repair tolerance. When in doubt, use the document's model absolute tolerance. |
Returns: True on success.
[ConstOperation]
public Brep ReplaceEdge(IEnumerable<int> edgeIndices, BrepReplaceEdgeMethod method, Curve replacementCurve, double tolerance)
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.
Parameters:
| edgeIndices (IEnumerable<int>) | The indices of the edges to replace. |
| method (BrepReplaceEdgeMethod) | How the deleted edges are re-trimmed. |
| replacementCurve (Curve) | The curve used to re-trim when method is BrepReplaceEdgeMethod.Curve; ignored (may be null) otherwise. |
| tolerance (double) | 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).
Scale
Scales the object by the specified factor. The scale is centered at the origin.
Parameters:
| scaleFactor (double) | The uniform scaling factor. |
Returns: true if geometry successfully scaled.
public void SetTolerancesBoxesAndFlags()
Set tolerances and flags in a Brep.
public void SetTolerancesBoxesAndFlags(bool bLazy, bool bSetVertexTolerances, bool bSetEdgeTolerances, bool bSetTrimTolerances, bool bSetTrimIsoFlags, bool bSetTrimTypeFlags, bool bSetLoopTypeFlags, bool bSetTrimBoxes)
Set tolerances and flags in a Brep.
Parameters:
| bLazy (bool) | If true, only flags and tolerances that are not set will be calculated. |
| bSetVertexTolerances (bool) | Set true to compute BrepVertex tolerances. |
| bSetEdgeTolerances (bool) | Set true to compute BrepEdge tolerances. |
| bSetTrimTolerances (bool) | Set true to compute BrepTrim tolerances. |
| bSetTrimIsoFlags (bool) | Set true to compute BrepTrim.IsoStatus values. |
| bSetTrimTypeFlags (bool) | Set true to compute BrepTrim.TrimType values. |
| bSetLoopTypeFlags (bool) | Set true to compute BrepLoop.BrepLoopType values. |
| bSetTrimBoxes (bool) | Set true to compute BrepTrim bounding boxes. |
public void SetTrimIsoFlags()
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.
SetUserString
Attach a user string (key,value combination) to this geometry.
public void SetVertices()
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.
[ConstOperation]
public Brep[] Split(Brep cutter, double intersectionTolerance, out bool toleranceWasRaised)
Splits a Brep into pieces using a Brep as a cutter.
Parameters:
| cutter (Brep) | The Brep to use as a cutter. |
| intersectionTolerance (double) | The tolerance with which to compute intersections. |
| toleranceWasRaised (out bool) | 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.
Splits a Brep into pieces using Breps as cutters.
Parameters:
| cutters (IEnumerable<Brep>) | One or more Breps to use as cutters. |
| intersectionTolerance (double) | 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.
Parameters:
| cutters (IEnumerable<Curve>) | The splitting curves. Only the portion of the curve on the Brep surface will be used for cutting. |
| intersectionTolerance (double) | The tolerance with which to compute intersections. |
Returns: A new array of Breps. This array can be empty.
[ConstOperation]
public Brep[] Split(IEnumerable<GeometryBase> cutters, Vector3d normal, bool planView, double intersectionTolerance)
Splits a Brep into pieces using a combination of curves, to be extruded, and Breps as cutters.
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.
Parameters:
| cutters (IEnumerable<GeometryBase>) | The curves, surfaces, faces and Breps to be used as cutters. Any other geometry is ignored. |
| normal (Vector3d) | A construction plane normal, used in deciding how to extrude a curve into a cutter. |
| planView (bool) | Set true if the assume view is a plan, or parallel projection, view. |
| intersectionTolerance (double) | The tolerance with which to compute intersections. |
Returns: A new array of Breps. This array can be empty.
Separates, or splits, a disjoint Brep into separate Breps.
Parameters:
| brep (Brep) | The disjoint Brep to separate. |
| indexMap (out List<int[]>) | List of integer arrays, one for each result, containing all input Brep face indices that went into making each result. Note, this can be null. |
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.
Parameters:
| brep (Brep) | The disjoint Brep to separate. |
Returns: An array of Brep pieces if successful, otherwise an empty array if the Brep is not disjoint or on error.
public void Standardize()
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.
ToJSON
Create a JSON string representation of this object
Parameters:
| options (SerializationOptions) |
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.
Parameters:
| xform (Transform) | Transformation to apply to geometry. |
Returns: true if geometry successfully transformed.
public bool TransformComponent(IEnumerable<ComponentIndex> components, Transform xform, double tolerance, double timeLimit, bool useMultipleThreads)
Transform an array of Brep components, bend neighbors to match, and leave the rest fixed.
Parameters:
| components (IEnumerable<ComponentIndex>) | The Brep components to transform. |
| xform (Transform) | The transformation to apply. |
| tolerance (double) | The desired fitting tolerance to use when bending faces that share edges with both fixed and transformed components. |
| timeLimit (double) | 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 (bool) | True if multiple threads can be used. |
Returns: true if successful, false otherwise.
Translate
Translates the object along the specified vector.
Translate
Translates the object along the specified vector.
Parameters:
| translationVector (Vector3d) | A moving 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.
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.
Attempts to convert a generic Geometry object into a Brep.
Parameters:
| geometry (GeometryBase) | Geometry to convert, not all types of GeometryBase can be represented by BReps. |
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.
Tests a Brep to see if it is an extrusion within RhinoMath.ZeroTolerance and returns the extrusion.
Parameters:
| extrusion (out Extrusion) | On success, the extrusion parameters are filled in. |
Returns: true if the Brep is an extrusion.
Un-joins, or separates, edges within the Brep. Note, seams in closed surfaces will not separate.
Parameters:
| edgesToUnjoin (IEnumerable<int>) | The indices of the Brep edges to un-join. |
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.
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.
Parameters:
| faceIndex (int) | The index of the face to untrim. |
Returns: The untrimmed Brep if successful, null otherwise.
public bool WireCut(Curve openCurve, Vector3d direction, Vector3d trimDirection, double depth, double trimDepth, bool bothSides, bool trimBothSides, double tolerance, bool splitKinkyFaces, out Brep[] keptPieces, out Brep[] cutAwayPieces)
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.
Parameters:
| openCurve (Curve) | Open cutting curve. |
| direction (Vector3d) | First extrusion direction (the wire sweep). |
| trimDirection (Vector3d) | Second extrusion direction that closes the cutter. |
| depth (double) | Depth along direction. RhinoMath.UnsetValue or a value <= 0 cuts through and skips trim capping. |
| trimDepth (double) | Depth along trimDirection. Ignored when cutting through. |
| bothSides (bool) | Extrude both ways along direction. |
| trimBothSides (bool) | Extrude both ways along trimDirection. |
| tolerance (double) | Intersection and boolean tolerance, typically the document absolute tolerance. |
| splitKinkyFaces (bool) | Split output pieces along creases. |
| keptPieces (out Brep[]) | Pieces that remain after the cut (boolean difference side). |
| cutAwayPieces (out Brep[]) | The cut-away pieces (boolean intersection side). |
Returns: true if successful.
public bool WireCut(IEnumerable<Curve> closedCurves, Vector3d direction, double depth, bool bothSides, double tolerance, bool splitKinkyFaces, out Brep[] keptPieces, out Brep[] cutAwayPieces)
Cuts this solid brep with extrusions of closed planar curves
Parameters:
| closedCurves (IEnumerable<Curve>) | Closed cutting curves. All are extruded along the same direction. |
| direction (Vector3d) | Extrusion direction of the cutters. |
| depth (double) | Extrusion depth. RhinoMath.UnsetValue or a value <= 0 cuts all the way through. |
| bothSides (bool) | Extrude the cutters to both sides of the curves. Ignored when cutting through. |
| tolerance (double) | Intersection and boolean tolerance, typically the document absolute tolerance. |
| splitKinkyFaces (bool) | Split output pieces along creases. |
| keptPieces (out Brep[]) | Pieces that remain after the cut (boolean difference side). |
| cutAwayPieces (out Brep[]) | The cut-away pieces (boolean intersection side). |
Returns: true if successful.