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.

ClosestPoint(Point3d testPoint)

Finds a point on the brep that is closest to testPoint.

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.

ConstructConstObject(object parentObject, int subobjectIndex)

Assigns a parent object and a sub-object index to this.

CopyTrimCurves(BrepFace trimSource, Surface surfaceSource, double tolerance)

Copy all trims from a Brep face onto a surface.

CreateBaseballSphere(Point3d center, double radius, double tolerance)

Creates a brep representation of the sphere with two similar trimmed NURBS surfaces, and no singularities.

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.

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.

CreateBooleanDifference(Brep firstBrep, Brep secondBrep, double tolerance, bool manifoldOnly)

Compute the Solid Difference of two Breps.

CreateBooleanDifference(Brep firstBrep, Brep secondBrep, double tolerance)

Compute the Solid Difference of two Breps.

CreateBooleanDifference(IEnumerable<Brep> firstSet, IEnumerable<Brep> secondSet, double tolerance, bool manifoldOnly)

Compute the Solid Difference of two sets of Breps.

CreateBooleanDifference(IEnumerable<Brep> firstSet, IEnumerable<Brep> secondSet, double tolerance)

Compute the Solid Difference of two sets of Breps.

CreateBooleanIntersection(Brep firstBrep, Brep secondBrep, double tolerance, bool manifoldOnly)

Compute the Solid Intersection of two Breps.

CreateBooleanIntersection(Brep firstBrep, Brep secondBrep, double tolerance)

Compute the Solid Intersection of two Breps.

CreateBooleanIntersection(IEnumerable<Brep> firstSet, IEnumerable<Brep> secondSet, double tolerance, bool manifoldOnly)

Compute the Solid Intersection of two sets of Breps.

CreateBooleanIntersection(IEnumerable<Brep> firstSet, IEnumerable<Brep> secondSet, double tolerance)

Compute the Solid Intersection of two sets of Breps.

CreateBooleanSplit(Brep firstBrep, Brep secondBrep, double tolerance)

Splits shared areas of Breps and creates separate Breps from the shared and unshared parts.

CreateBooleanSplit(IEnumerable<Brep> firstSet, IEnumerable<Brep> secondSet, double tolerance)

Splits shared areas of Breps and creates separate Breps from the shared and unshared parts.

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.

CreateBooleanUnion(IEnumerable<Brep> breps, double tolerance, bool manifoldOnly)

Compute the Boolean Union of a set of Breps.

CreateBooleanUnion(IEnumerable<Brep> breps, double tolerance)

Compute the Boolean Union of a set of Breps.

CreateChamferSurface(BrepFace face0, Point2d uv0, double radius0, BrepFace face1, Point2d uv1, double radius1, bool extend, double tolerance)

Creates a ruled surface as a bevel between two input surface edges.

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)

Creates a ruled surface as a bevel between two input surface edges.

CreateContourCurves(Brep brepToContour, Plane sectionPlane)

Constructs the contour curves for a brep, using a slicing plane.

CreateContourCurves(Brep brepToContour, Point3d contourStart, Point3d contourEnd, double interval)

Constructs the contour curves for a brep at a specified interval.

CreateCurvatureAnalysisMesh(Brep brep,CurvatureAnalysisSettingsState state)

Create an array of analysis meshes for the brep using the specified settings. Meshes aren't set on the brep.

CreateDevelopableLoft(Curve crv0, Curve crv1, bool reverse0, bool reverse1, int density)

Creates a single developable surface between two curves.

CreateDevelopableLoft(NurbsCurve rail0, NurbsCurve rail1, IEnumerable<Point2d> fixedRulings)

Creates a single developable surface between two curves.

CreateEdgeSurface(IEnumerable<Curve> curves)

Constructs a coons patch from 2, 3, or 4 curves.

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.

CreateFilletEdges(Brep brep, IEnumerable<int> edgeIndices, IEnumerable<double> startRadii, IEnumerable<double> endRadii, BlendType blendType, RailType railType, double tolerance)

Fillets, chamfers, or blends the edges of a 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.

CreateFilletSurface(BrepFace face0, Point2d uv0, BrepFace face1, Point2d uv1, double radius, bool extend, double tolerance)

Creates a constant-radius round surface between two surfaces.

CreateFilletSurface(BrepFace face0, Point2d uv0, BrepFace face1, Point2d uv1, double radius, bool trim, bool extend, double tolerance, out Brep[] outBreps0, out Brep[] outBreps1)

Creates a constant-radius round surface between two surfaces.

CreateFromBox(BoundingBox box)

Constructs new brep that matches a bounding box.

CreateFromBox(Box box)

Constructs new brep that matches an aligned box.

CreateFromBox(IEnumerable<Point3d> corners)

Constructs new brep from 8 corner points.

CreateFromCone(Cone cone, bool capBottom)

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.

CreateFromCornerPoints(Point3d corner1, Point3d corner2, Point3d corner3, double tolerance)

Makes a Brep with one face from three corner points.

CreateFromCornerPoints(Point3d corner1, Point3d corner2, Point3d corner3, Point3d corner4, double tolerance)

Makes a Brep with one face from four corner points.

CreateFromCylinder(Cylinder cylinder, bool capBottom, bool capTop)

Constructs a Brep definition of a cylinder.

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.

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

CreateFromLoft(IEnumerable<Curve> curves, Point3d start, Point3d end, LoftType loftType, bool closed)

Constructs one or more Breps by lofting through a set of curves.

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.

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.

CreateFromMesh(Mesh mesh, bool trimmedTriangles)

Create a brep representation of a mesh

CreateFromOffsetFace(BrepFace face, double offsetDistance, double offsetTolerance, bool bothSides, bool createSolid)

Offsets a face including trim information to create a new brep.

CreateFromRevSurface(RevSurface surface, bool capStart, bool capEnd)

Constructs a brep form of a surface of revolution.

CreateFromSphere(Sphere sphere)

Constructs a Brep definition of a sphere.

CreateFromSurface(Surface surface)

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.

CreateFromSweep(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.

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.

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.

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.

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.

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.

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.

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.

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.

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)

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)

CreateFromTaperedExtrude(Curve curveToExtrude, double distance, Vector3d direction, Point3d basePoint, double draftAngleRadians, ExtrudeCornerType cornerType)

Extrude a curve to a taper making a brep (potentially more than 1)

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.

CreateFromTorus(Torus torus)

Constructs a Brep definition of a torus.

CreateOffsetBrep(Brep brep, double distance, bool solid, bool extend, bool shrink, double tolerance, out Brep[] outBlends, out Brep[] outWalls)

Offsets a Brep.

CreateOffsetBrep(Brep brep, double distance, bool solid, bool extend, double tolerance, out Brep[] outBlends, out Brep[] outWalls)

Offsets a 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.

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.

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

CreatePipe(Curve rail, double radius, bool localBlending, PipeCapMode cap, bool fitRail, double absoluteTolerance, double angleToleranceRadians)

Creates a single walled pipe.

CreatePipe(Curve rail, IEnumerable<double> railRadiiParameters, IEnumerable<double> radii, bool localBlending, PipeCapMode cap, bool fitRail, double absoluteTolerance, double angleToleranceRadians)

Creates a single walled pipe.

CreatePlanarBreps(Curve inputLoop, double tolerance)

Constructs a set of planar breps as outlines by the loops.

CreatePlanarBreps(Curve inputLoop)

Constructs a set of planar breps as outlines by the loops.

CreatePlanarBreps(IEnumerable<Curve> inputLoops, double tolerance)

Constructs a set of planar breps as outlines by the loops.

CreatePlanarBreps(IEnumerable<Curve> inputLoops)

Constructs a set of planar breps as outlines by the loops.

CreatePlanarBreps(CurveList inputLoops, double tolerance)

Constructs a set of planar Breps as outlines by the loops.

CreatePlanarBreps(CurveList inputLoops)

Constructs a set of planar Breps as outlines by the loops.

CreatePlanarDifference(Brep b0, Brep b1, Plane plane, double tolerance)

CreatePlanarDifference

CreatePlanarIntersection(Brep b0, Brep b1, Plane plane, double tolerance)

CreatePlanarIntersection

CreatePlanarUnion(Brep b0, Brep b1, Plane plane, double tolerance)

CreatePlanarUnion

CreatePlanarUnion(IEnumerable<Brep> breps, Plane plane, double tolerance)

CreatePlanarUnion

CreateQuadSphere(Sphere sphere)

Constructs a Brep definition of a quad sphere.

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.

CreateSolid(IEnumerable<Brep> breps, double tolerance)

Constructs closed polysurfaces from surfaces and polysurfaces that bound a region in space.

CreateThickPipe(Curve rail, double radius0, double radius1, bool localBlending, PipeCapMode cap, bool fitRail, double absoluteTolerance, double angleToleranceRadians)

Creates a double-walled pipe.

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.

CreateTrimmedPlane(Plane plane, Curve curve)

Create a Brep trimmed plane.

CreateTrimmedPlane(Plane plane, IEnumerable<Curve> curves)

Create a Brep trimmed plane.

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.

CreateTrimmedSurface(BrepFace trimSource, Surface surfaceSource)

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.

CullUnused2dCurves()

Culls 3d curves not referenced by an edge.

CullUnused3dCurves()

Culls 2d curves not referenced by a trim.

CullUnusedEdges()

Culls edges with m_edge_index == -1.

CullUnusedFaces()

Culls faces with m_face_index == -1.

CullUnusedLoops()

Culls loops with m_loop_index == -1.

CullUnusedSurfaces()

Culls surfaces not referenced by a face.

CullUnusedTrims()

Culls trims with m_trim_index == -1.

CullUnusedVertices()

Culls vertices with m_vertex_index == -1.

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.

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.

DataCRC(uint currentRemainder)

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.

DeleteAllUserStrings()

DeleteUserString(string key)

DestroyRegionTopology()

Destroys a Brep's region topology information.

Dispose()

Actively reclaims unmanaged resources that this instance uses.

Dispose(bool disposing)

For derived class implementers.
This method is called with argument True when class user calls Dispose(), while with argument False when the Garbage Collector invokes the finalizer, or Finalize() method.
You must reclaim all used unmanaged resources in both cases, and can use this chance to call Dispose on disposable fields if the argument is true.
Also, you must call the base virtual method within your overriding method.

Dispose(bool disposing)

Overridden in order to destroy local display cache information

Duplicate()

Copies this brep.

Duplicate()

Constructs a deep (full) copy of this object.

DuplicateBrep()

Same as <b>Duplicate()</b> , but already performs a cast to a brep.
This cast always succeeds.

DuplicateEdgeCurves()

Duplicate all the edges of this Brep.

DuplicateEdgeCurves(bool nakedOnly)

Duplicate edges of this Brep.

DuplicateNakedEdgeCurves(bool nakedOuter, bool nakedInner)

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.

DuplicateSubBrep(IEnumerable<int> faceIndices)

Copy a subset of this Brep into another Brep.

DuplicateVertices()

Duplicate all the corner vertices of this Brep.

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.

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

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

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.

Flip()

Reverses entire brep orientation of all faces.

FromBase64String(int archive3dm, int opennurbs, string base64Data)

Create a CommonObject instance from a Base64 encoded string. This is typically the values used when passing common objects around as JSON data

FromJSON(Dictionary<string, string> jsonDictionary)

Create a CommonObject instance from a JSON dictionary

FromJSON(string json)

Create a CommonObject instance from a JSON string

GeometryEquals(GeometryBase first, GeometryBase second)

Determines if two geometries equal one another, in pure geometrical shape. This version only compares the geometry itself and does not include any user data comparisons. This is a comparison by value: for two identical items it will be true, no matter where in memory they may be stored.

GeometryReferenceEquals(GeometryBase one, GeometryBase other)

Determines if two objects are respectively shallow copies, new managed instantiations of the same geometry, or similar internal references to the exact same geometry, both in managed and in unmanaged code.

GetArea()

Compute the Area of the Brep. If you want proper Area data with moments and error information, use the AreaMassProperties class.

GetArea(double relativeTolerance, double absoluteTolerance)

Compute the Area of the Brep. If you want proper Area data with moments and error information, use the AreaMassProperties class.

GetBoundingBox(bool accurate)

Bounding box solver. Gets the world axis aligned bounding box for the geometry.

GetBoundingBox(Plane plane, out Box worldBox)

Aligned Bounding box solver. Gets the plane aligned bounding box.

GetBoundingBox(Plane plane)

Aligned Bounding box solver. Gets the plane aligned bounding box.

GetBoundingBox(Transform xform)

Aligned Bounding box solver. Gets the world axis aligned bounding box for the transformed geometry.

GetConnectedComponents()

If this Brep has two or more connected components, then duplicates of the connected components are returned.

GetObjectData(SerializationInfo info,StreamingContext context)

Populates a System.Runtime.Serialization.SerializationInfo with the data needed to serialize the target object.

GetPointInside(double tolerance, out Point3d point)

Finds a point inside of a solid Brep.

GetRegions()

Gets an array containing all regions in this 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.

GetUserString(string key)

Gets user string from this geometry.

GetUserStrings()

Gets a copy of all (user key string, user value string) pairs attached to this geometry.

GetVolume()

Compute the Volume of the Brep. If you want proper Volume data with moments and error information, use the VolumeMassProperties class.

GetVolume(double relativeTolerance, double absoluteTolerance)

Compute the Volume of the Brep. If you want proper Volume data with moments and error information, use the VolumeMassProperties class.

GetWireframe(int density)

Constructs all the Wireframe curves for this 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.

IsBox()

Verifies a Brep is in the form of a solid box.

IsBox(double tolerance)

Verifies a Brep is in the form of a solid box.

IsDuplicate(Brep other, double tolerance)

See if this and other are same brep geometry.

IsPointInside(Point3d point, double tolerance, bool strictlyIn)

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.

IsValidGeometry(out string log)

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.

IsValidTolerancesAndFlags(out string log)

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.

IsValidTopology(out string log)

Tests the brep to see if its topology information is valid.

IsValidWithLog(out string log)

Determines if an object is valid. Also provides a report on errors if this object happens not to be valid.

Join(Brep otherBrep, double tolerance, bool compact)

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.

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.

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.

JoinBreps(IEnumerable<Brep> brepsToJoin, double tolerance)

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.

JoinEdges(int edgeIndex0, int edgeIndex1, double joinTolerance, bool compact)

Joins two naked edges, or edges that are coincident or close together.

JoinNakedEdges(double tolerance)

Joins naked edge pairs within the same brep that overlap within tolerance.

MakeDeformable()

If possible, converts the object into a form that can be accurately modified with "squishy" transformations like projections, shears, an non-uniform scaling.

MakeValidForV2()

No support is available for this function.
Expert user function that converts all geometry in Brep to NURB form.

MemoryEstimate()

Computes an estimate of the number of bytes that this object is using in memory.

MergeBreps(IEnumerable<Brep> brepsToMerge, double tolerance)

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.

MergeCoplanarFaces(double tolerance, double angleTolerance)

Merges adjacent coplanar faces into single faces.

MergeCoplanarFaces(double tolerance)

Merges adjacent coplanar faces into single faces.

MergeCoplanarFaces(int faceIndex, double tolerance, double angleTolerance)

Merges coplanar faces adjacent to Brep face into a single face.

MergeCoplanarFaces(int faceIndex0, int faceIndex1, double tolerance, double angleTolerance)

Merges two coplanar, adjacent Brep faces into a single face.

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.

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.

MergeSurfaces(Surface surface0, Surface surface1, double tolerance, double angleToleranceRadians)

Merges two surfaces into one surface at untrimmed edges.

NonConstOperation()

For derived classes implementers.
Defines the necessary implementation to free the instance from being constant.

NonConstOperation()

Destroy cache handle

OnSwitchToNonConst()

Is called when a non-constant operation first occurs.

OnSwitchToNonConst()

Is called when a non-constant operation occurs.

RebuildTrimsForV2(BrepFace face, NurbsSurface nurbsSurface)

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.

RemoveFins()

Recursively removes any Brep face with a naked edge. This function is only useful for non-manifold Breps.

RemoveHoles(double tolerance)

Remove all inner loops, or holes, in a Brep.

RemoveHoles(IEnumerable<ComponentIndex> loops, double tolerance)

Removes inner loops, or holes, in a Brep.

Repair(double tolerance)

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.

Rotate(double angleRadians, Vector3d rotationAxis, Point3d rotationCenter)

Rotates the object about the specified axis. A positive rotation angle results in a counter-clockwise rotation about the axis (right hand rule).

Scale(double scaleFactor)

Scales the object by the specified factor. The scale is centered at the origin.

SetTolerancesBoxesAndFlags()

Set tolerances and flags in a Brep.

SetTolerancesBoxesAndFlags(bool bLazy, bool bSetVertexTolerances, bool bSetEdgeTolerances, bool bSetTrimTolerances, bool bSetTrimIsoFlags, bool bSetTrimTypeFlags, bool bSetLoopTypeFlags, bool bSetTrimBoxes)

Set tolerances and flags in a Brep.

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(string key, string value)

Attach a user string (key,value combination) to this geometry.

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.

Split(Brep cutter, double intersectionTolerance, out bool toleranceWasRaised)

Splits a Brep into pieces using a Brep as a cutter.

Split(Brep cutter, double intersectionTolerance)

Splits a Brep into pieces using a Brep as a cutter.

Split(IEnumerable<Brep> cutters, double intersectionTolerance)