RhinoCompute.Brep¶

RhinoCompute.Brep.
changeSeam
(face, direction, parameter, tolerance, multiple=false)¶ Change the seam of a closed trimmed surface.
Arguments:  face (rhino3dm.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 (float) – The parameter at which to place the seam.
 tolerance (float) – Tolerance used to cut up surface.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new Brep that has the same geometry as the face with a relocated seam if successful, or None on failure.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
copyTrimCurves
(trimSource, surfaceSource, tolerance, multiple=false)¶ Copy all trims from a Brep face onto a surface.
Arguments:  trimSource (rhino3dm.BrepFace) – Brep face which defines the trimming curves.
 surfaceSource (rhino3dm.Surface) – The surface to trim.
 tolerance (float) – Tolerance to use for rebuilding 3D trim curves.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A brep with the shape of surfaceSource and the trims of trimSource or None on failure.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
createBaseballSphere
(center, radius, tolerance, multiple=false)¶ Creates a brep representation of the sphere with two similar trimmed NURBS surfaces, and no singularities.
Arguments:  center (rhino3dm.Point3d) – The center of the sphere.
 radius (float) – The radius of the sphere.
 tolerance (float) – Used in computing 2d trimming curves. If >= 0.0, then the max of ON_0.0001 * radius and RhinoMath.ZeroTolerance will be used.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new brep, or None on error.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
createDevelopableLoft
(crv0, crv1, reverse0, reverse1, density, multiple=false)¶ Creates a single developable surface between two curves.
Arguments:  crv0 (rhino3dm.Curve) – The first rail curve.
 crv1 (rhino3dm.Curve) – The second rail curve.
 reverse0 (bool) – Reverse the first rail curve.
 reverse1 (bool) – Reverse the second rail curve
 density (int) – The number of rulings across the surface.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The output Breps if successful, otherwise an empty array.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createDevelopableLoft1
(rail0, rail1, fixedRulings, multiple=false)¶ Creates a single developable surface between two curves.
Arguments:  rail0 (rhino3dm.NurbsCurve) – The first rail curve.
 rail1 (rhino3dm.NurbsCurve) – The second rail curve.
 fixedRulings (list[rhino3dm.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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The output Breps if successful, otherwise an empty array.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createPlanarBreps
(inputLoops, multiple=false)¶ Constructs a set of planar breps as outlines by the loops.
Arguments:  inputLoops (list[rhino3dm.Curve]) – Curve loops that delineate the planar boundaries.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Planar Breps.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createPlanarBreps1
(inputLoops, tolerance, multiple=false)¶ Constructs a set of planar breps as outlines by the loops.
Arguments:  inputLoops (list[rhino3dm.Curve]) – Curve loops that delineate the planar boundaries.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Planar Breps.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createPlanarBreps2
(inputLoop, multiple=false)¶ Constructs a set of planar breps as outlines by the loops.
Arguments:  inputLoop (rhino3dm.Curve) – A curve that should form the boundaries of the surfaces or polysurfaces.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Planar Breps.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createPlanarBreps3
(inputLoop, tolerance, multiple=false)¶ Constructs a set of planar breps as outlines by the loops.
Arguments:  inputLoop (rhino3dm.Curve) – A curve that should form the boundaries of the surfaces or polysurfaces.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Planar Breps.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createTrimmedSurface
(trimSource, surfaceSource, multiple=false)¶ 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.
Arguments:  trimSource (rhino3dm.BrepFace) – BrepFace which contains trimmingSource brep.
 surfaceSource (rhino3dm.Surface) – Surface that trims of BrepFace will be applied to.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A brep with the shape of surfaceSource and the trims of trimSource or None on failure.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
createTrimmedSurface1
(trimSource, surfaceSource, tolerance, multiple=false)¶ 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.
Arguments:  trimSource (rhino3dm.BrepFace) – BrepFace which contains trimmingSource brep.
 surfaceSource (rhino3dm.Surface) – Surface that trims of BrepFace will be applied to.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A brep with the shape of surfaceSource and the trims of trimSource or None on failure.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
createFromCornerPoints
(corner1, corner2, corner3, tolerance, multiple=false)¶ Makes a Brep with one face from three corner points.
Arguments:  corner1 (rhino3dm.Point3d) – A first corner.
 corner2 (rhino3dm.Point3d) – A second corner.
 corner3 (rhino3dm.Point3d) – A third corner.
 tolerance (float) – Minimum edge length allowed before collapsing the side into a singularity.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A boundary representation, or None on error.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
createFromCornerPoints1
(corner1, corner2, corner3, corner4, tolerance, multiple=false)¶ Makes a Brep with one face from four corner points.
Arguments:  corner1 (rhino3dm.Point3d) – A first corner.
 corner2 (rhino3dm.Point3d) – A second corner.
 corner3 (rhino3dm.Point3d) – A third corner.
 corner4 (rhino3dm.Point3d) – A fourth corner.
 tolerance (float) – Minimum edge length allowed before collapsing the side into a singularity.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A boundary representation, or None on error.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
createEdgeSurface
(curves, multiple=false)¶ Constructs a coons patch from 2, 3, or 4 curves.
Arguments:  curves (list[rhino3dm.Curve]) – A list, an array or any enumerable set of curves.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: resulting brep or None on failure.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
createPlanarBreps4
(inputLoops, multiple=false)¶ Constructs a set of planar Breps as outlines by the loops.
Arguments:  inputLoops (Rhino.Collections.CurveList) – Curve loops that delineate the planar boundaries.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Planar Breps or None on error.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createPlanarBreps5
(inputLoops, tolerance, multiple=false)¶ Constructs a set of planar Breps as outlines by the loops.
Arguments:  inputLoops (Rhino.Collections.CurveList) – Curve loops that delineate the planar boundaries.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Planar Breps.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromOffsetFace
(face, offsetDistance, offsetTolerance, bothSides, createSolid, multiple=false)¶ Offsets a face including trim information to create a new brep.
Arguments:  face (rhino3dm.BrepFace) – the face to offset.
 offsetDistance (float) – An offset distance.
 offsetTolerance (float) – 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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
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. None if unsuccessful.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
createSolid
(breps, tolerance, multiple=false)¶ Constructs closed polysurfaces from surfaces and polysurfaces that bound a region in space.
Arguments:  breps (list[rhino3dm.Brep]) – The intersecting surfaces and polysurfaces to automatically trim and join into closed polysurfaces.
 tolerance (float) – The trim and join tolerance. If set to RhinoMath.UnsetValue, Rhino’s global absolute tolerance is used.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The resulting polysurfaces on success or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
mergeSurfaces
(surface0, surface1, tolerance, angleToleranceRadians, multiple=false)¶ Merges two surfaces into one surface at untrimmed edges.
Arguments:  surface0 (rhino3dm.Surface) – The first surface to merge.
 surface1 (rhino3dm.Surface) – The second surface to merge.
 tolerance (float) – Surface edges must be within this tolerance for the two surfaces to merge.
 angleToleranceRadians (float) – Edge must be within this angle tolerance in order for contiguous edges to be combined into a single edge.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The merged surfaces as a Brep if successful, None if not successful.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
mergeSurfaces1
(brep0, brep1, tolerance, angleToleranceRadians, multiple=false)¶ Merges two surfaces into one surface at untrimmed edges. Both surfaces must be untrimmed and share an edge.
Arguments:  brep0 (rhino3dm.Brep) – The first singleface Brep to merge.
 brep1 (rhino3dm.Brep) – The second singleface Brep to merge.
 tolerance (float) – Surface edges must be within this tolerance for the two surfaces to merge.
 angleToleranceRadians (float) – Edge must be within this angle tolerance in order for contiguous edges to be combined into a single edge.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The merged Brep if successful, None if not successful.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
mergeSurfaces2
(brep0, brep1, tolerance, angleToleranceRadians, point0, point1, roundness, smooth, multiple=false)¶ Merges two surfaces into one surface at untrimmed edges. Both surfaces must be untrimmed and share an edge.
Arguments:  brep0 (rhino3dm.Brep) – The first singleface Brep to merge.
 brep1 (rhino3dm.Brep) – The second singleface Brep to merge.
 tolerance (float) – Surface edges must be within this tolerance for the two surfaces to merge.
 angleToleranceRadians (float) – Edge must be within this angle tolerance in order for contiguous edges to be combined into a single edge.
 point0 (rhino3dm.Point2d) – 2D pick point on the first singleface Brep. The value can be unset.
 point1 (rhino3dm.Point2d) – 2D pick point on the second singleface Brep. The value can be unset.
 roundness (float) – 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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The merged Brep if successful, None if not successful.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
createPatch
(geometry, startingSurface, tolerance, multiple=false)¶ Constructs a brep patch. This is the simple version of fit that uses a specified starting surface.
Arguments:  geometry (list[rhino3dm.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 (rhino3dm.Surface) – A starting surface (can be null).
 tolerance (float) – Tolerance used by input analysis functions for loop finding, trimming, etc.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Brep fit through input on success, or None on error.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
createPatch1
(geometry, uSpans, vSpans, tolerance, multiple=false)¶ 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.
Arguments:  geometry (list[rhino3dm.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 (float) – Tolerance used by input analysis functions for loop finding, trimming, etc.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A brep fit through input on success, or None on error.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
createPatch2
(geometry, startingSurface, uSpans, vSpans, trim, tangency, pointSpacing, flexibility, surfacePull, fixEdges, tolerance, multiple=false)¶ Constructs a brep patch using all controls
Arguments:  geometry (list[rhino3dm.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 (rhino3dm.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 (float) – Basic distance between points sampled from input curves.
 flexibility (float) – 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 (float) – 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 (float) – Tolerance used by input analysis functions for loop finding, trimming, etc.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A brep fit through input on success, or None on error.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
createPipe
(rail, radius, localBlending, cap, fitRail, absoluteTolerance, angleToleranceRadians, multiple=false)¶ Creates a single walled pipe.
Arguments:  rail (rhino3dm.Curve) – The rail, or path, curve.
 radius (float) – 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 (float) – The sweeping and fitting tolerance. When in doubt, use the document’s absolute tolerance.
 angleToleranceRadians (float) – The angle tolerance. When in doubt, use the document’s angle tolerance in radians.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Breps success.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createPipe1
(rail, railRadiiParameters, radii, localBlending, cap, fitRail, absoluteTolerance, angleToleranceRadians, multiple=false)¶ Creates a single walled pipe.
Arguments:  rail (rhino3dm.Curve) – The rail, or path, curve.
 railRadiiParameters (list[float]) – 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 (list[float]) – 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 (float) – The sweeping and fitting tolerance. When in doubt, use the document’s absolute tolerance.
 angleToleranceRadians (float) – The angle tolerance. When in doubt, use the document’s angle tolerance in radians.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Breps success.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createThickPipe
(rail, radius0, radius1, localBlending, cap, fitRail, absoluteTolerance, angleToleranceRadians, multiple=false)¶ Creates a doublewalled pipe.
Arguments:  rail (rhino3dm.Curve) – The rail, or path, curve.
 radius0 (float) – The first radius of the pipe.
 radius1 (float) – 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 (float) – The sweeping and fitting tolerance. When in doubt, use the document’s absolute tolerance.
 angleToleranceRadians (float) – The angle tolerance. When in doubt, use the document’s angle tolerance in radians.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Breps success.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createThickPipe1
(rail, railRadiiParameters, radii0, radii1, localBlending, cap, fitRail, absoluteTolerance, angleToleranceRadians, multiple=false)¶ Creates a doublewalled pipe.
Arguments:  rail (rhino3dm.Curve) – The rail, or path, curve.
 railRadiiParameters (list[float]) – 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 (list[float]) – One or more radii for the first wall  one at each normalized curve parameter in railRadiiParameters.
 radii1 (list[float]) – 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 (float) – The sweeping and fitting tolerance. When in doubt, use the document’s absolute tolerance.
 angleToleranceRadians (float) – The angle tolerance. When in doubt, use the document’s angle tolerance in radians.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Breps success.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromSweep
(rail, shape, closed, tolerance, multiple=false)¶ Sweep1 function that fits a surface through a profile curve that define the surface crosssections and one curve that defines a surface edge.
Arguments:  rail (rhino3dm.Curve) – Rail to sweep shapes along
 shape (rhino3dm.Curve) – Shape curve
 closed (bool) – Only matters if shape is closed
 tolerance (float) – Tolerance for fitting surface and rails
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Brep sweep results
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromSweep1
(rail, shapes, closed, tolerance, multiple=false)¶ Sweep1 function that fits a surface through profile curves that define the surface crosssections and one curve that defines a surface edge.
Arguments:  rail (rhino3dm.Curve) – Rail to sweep shapes along
 shapes (list[rhino3dm.Curve]) – Shape curves
 closed (bool) – Only matters if shapes are closed
 tolerance (float) – Tolerance for fitting surface and rails
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Brep sweep results
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromSweep2
(rail, shapes, startPoint, endPoint, frameType, roadlikeNormal, closed, blendType, miterType, tolerance, rebuildType, rebuildPointCount, refitTolerance, multiple=false)¶ Sweep1 function that fits a surface through a series of profile curves that define the surface crosssections and one curve that defines a surface edge.
Arguments:  rail (rhino3dm.Curve) – Rail to sweep shapes along.
 shapes (list[rhino3dm.Curve]) – Shape curves.
 startPoint (rhino3dm.Point3d) – Optional starting point of sweep. Use Point3d.Unset if you do not want to include a start point.
 endPoint (rhino3dm.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 (rhino3dm.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.
 rebuildType (SweepRebuild) – The rebuild style.
 rebuildPointCount (int) – If rebuild == SweepRebuild.Rebuild, the number of points. Otherwise specify 0.
 refitTolerance (float) – If rebuild == SweepRebuild.Refit, the refit tolerance. Otherwise, specify 0.0
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Brep sweep results.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromSweepSegmented
(rail, shape, closed, tolerance, multiple=false)¶ Sweep1 function that fits a surface through a profile curve that define the surface crosssections 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.
Arguments:  rail (rhino3dm.Curve) – Rail to sweep shapes along
 shape (rhino3dm.Curve) – Shape curve
 closed (bool) – Only matters if shape is closed
 tolerance (float) – Tolerance for fitting surface and rails
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Brep sweep results
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromSweepSegmented1
(rail, shapes, closed, tolerance, multiple=false)¶ Sweep1 function that fits a surface through a series of profile curves that define the surface crosssections 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.
Arguments:  rail (rhino3dm.Curve) – Rail to sweep shapes along.
 shapes (list[rhino3dm.Curve]) – Shape curves.
 closed (bool) – Only matters if shapes are closed.
 tolerance (float) – Tolerance for fitting surface and rails.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Brep sweep results.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromSweepSegmented2
(rail, shapes, startPoint, endPoint, frameType, roadlikeNormal, closed, blendType, miterType, tolerance, rebuildType, rebuildPointCount, refitTolerance, multiple=false)¶ Sweep1 function that fits a surface through a series of profile curves that define the surface crosssections 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.
Arguments:  rail (rhino3dm.Curve) – Rail to sweep shapes along.
 shapes (list[rhino3dm.Curve]) – Shape curves.
 startPoint (rhino3dm.Point3d) – Optional starting point of sweep. Use Point3d.Unset if you do not want to include a start point.
 endPoint (rhino3dm.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 (rhino3dm.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.
 rebuildType (SweepRebuild) – The rebuild style.
 rebuildPointCount (int) – If rebuild == SweepRebuild.Rebuild, the number of points. Otherwise specify 0.
 refitTolerance (float) – If rebuild == SweepRebuild.Refit, the refit tolerance. Otherwise, specify 0.0
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Brep sweep results.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromSweep3
(rail1, rail2, shape, closed, tolerance, multiple=false)¶ 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.
Arguments:  rail1 (rhino3dm.Curve) – Rail to sweep shapes along
 rail2 (rhino3dm.Curve) – Rail to sweep shapes along
 shape (rhino3dm.Curve) – Shape curve
 closed (bool) – Only matters if shape is closed
 tolerance (float) – Tolerance for fitting surface and rails
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Brep sweep results
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromSweep4
(rail1, rail2, shapes, closed, tolerance, multiple=false)¶ 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.
Arguments:  rail1 (rhino3dm.Curve) – Rail to sweep shapes along
 rail2 (rhino3dm.Curve) – Rail to sweep shapes along
 shapes (list[rhino3dm.Curve]) – Shape curves
 closed (bool) – Only matters if shapes are closed
 tolerance (float) – Tolerance for fitting surface and rails
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Brep sweep results
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromSweep5
(rail1, rail2, shapes, start, end, closed, tolerance, rebuild, rebuildPointCount, refitTolerance, preserveHeight, multiple=false)¶ Sweep2 function that fits a surface through profile curves that define the surface crosssections and two curves that defines the surface edges.
Arguments:  rail1 (rhino3dm.Curve) – Rail to sweep shapes along
 rail2 (rhino3dm.Curve) – Rail to sweep shapes along
 shapes (list[rhino3dm.Curve]) – Shape curves
 start (rhino3dm.Point3d) – Optional starting point of sweep. Use Point3d.Unset if you do not want to include a start point.
 end (rhino3dm.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 (float) – 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 (float) – If rebuild == SweepRebuild.Refit, the refit tolerance. Otherwise, specify 0.0
 preserveHeight (bool) – Removes the association between the height scaling from the width scaling
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Brep sweep results
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromSweepInParts
(rail1, rail2, shapes, rail_params, closed, tolerance, multiple=false)¶ Makes a 2 rail sweep. Like CreateFromSweep but the result is split where parameterization along a rail changes abruptly.
Arguments:  rail1 (rhino3dm.Curve) – Rail to sweep shapes along
 rail2 (rhino3dm.Curve) – Rail to sweep shapes along
 shapes (list[rhino3dm.Curve]) – Shape curves
 rail_params (list[rhino3dm.Point2d]) – Shape parameters
 closed (bool) – Only matters if shapes are closed
 tolerance (float) – Tolerance for fitting surface and rails
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Brep sweep results
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromTaperedExtrude
(curveToExtrude, distance, direction, basePoint, draftAngleRadians, cornerType, tolerance, angleToleranceRadians, multiple=false)¶ Extrude a curve to a taper making a brep (potentially more than 1)
Arguments:  curveToExtrude (rhino3dm.Curve) – the curve to extrude
 distance (float) – the distance to extrude
 direction (rhino3dm.Vector3d) – the direction of the extrusion
 basePoint (rhino3dm.Point3d) – the base point of the extrusion
 draftAngleRadians (float) – angle of the extrusion
 tolerance (float) – tolerance to use for the extrusion
 angleToleranceRadians (float) – angle tolerance to use for the extrusion
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: array of breps on success
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromTaperedExtrude1
(curveToExtrude, distance, direction, basePoint, draftAngleRadians, cornerType, multiple=false)¶ Extrude a curve to a taper making a brep (potentially more than 1)
Arguments:  curveToExtrude (rhino3dm.Curve) – the curve to extrude
 distance (float) – the distance to extrude
 direction (rhino3dm.Vector3d) – the direction of the extrusion
 basePoint (rhino3dm.Point3d) – the base point of the extrusion
 draftAngleRadians (float) – angle of the extrusion
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: array of breps on success
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromTaperedExtrudeWithRef
(curve, direction, distance, draftAngle, plane, tolerance, multiple=false)¶ Creates one or more Breps by extruding a curve a distance along an axis with draft angle.
Arguments:  curve (rhino3dm.Curve) – The curve to extrude.
 direction (rhino3dm.Vector3d) – The extrusion direction.
 distance (float) – The extrusion distance.
 draftAngle (float) – The extrusion draft angle in radians.
 plane (rhino3dm.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 (float) – The intersecting and trimming tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Breps if successful.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createBlendSurface
(face0, edge0, domain0, rev0, continuity0, face1, edge1, domain1, rev1, continuity1, multiple=false)¶ Makes a surface blend between two surface edges.
Arguments:  face0 (rhino3dm.BrepFace) – First face to blend from.
 edge0 (rhino3dm.BrepEdge) – First edge to blend from.
 domain0 (rhino3dm.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 (rhino3dm.BrepFace) – Second face to blend from.
 edge1 (rhino3dm.BrepEdge) – Second edge to blend from.
 domain1 (rhino3dm.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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Breps if successful.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createBlendShape
(face0, edge0, t0, rev0, continuity0, face1, edge1, t1, rev1, continuity1, multiple=false)¶ Makes a curve blend between points on two surface edges. The blend will be tangent to the surfaces and perpendicular to the edges.
Arguments:  face0 (rhino3dm.BrepFace) – First face to blend from.
 edge0 (rhino3dm.BrepEdge) – First edge to blend from.
 t0 (float) – 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 (rhino3dm.BrepFace) – Second face to blend from.
 edge1 (rhino3dm.BrepEdge) – Second edge to blend from.
 t1 (float) – 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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The blend curve on success. None on failure
Return type: rhino3dm.Curve

RhinoCompute.Brep.
createFilletSurface
(face0, uv0, face1, uv1, radius, extend, tolerance, multiple=false)¶ Creates a constantradius round surface between two surfaces.
Arguments:  face0 (rhino3dm.BrepFace) – First face to fillet from.
 uv0 (rhino3dm.Point2d) – A parameter face0 at the side you want to keep after filleting.
 face1 (rhino3dm.BrepFace) – Second face to fillet from.
 uv1 (rhino3dm.Point2d) – A parameter face1 at the side you want to keep after filleting.
 radius (float) – 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 (float) – The tolerance. When in doubt, use the document’s model absolute tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Breps if successful.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFilletSurface1
(face0, uv0, face1, uv1, radius, trim, extend, tolerance, multiple=false)¶ Creates a constantradius round surface between two surfaces.
Arguments:  face0 (rhino3dm.BrepFace) – First face to fillet from.
 uv0 (rhino3dm.Point2d) – A parameter face0 at the side you want to keep after filleting.
 face1 (rhino3dm.BrepFace) – Second face to fillet from.
 uv1 (rhino3dm.Point2d) – A parameter face1 at the side you want to keep after filleting.
 radius (float) – 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 (float) – The tolerance. When in doubt, use the document’s model absolute tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Breps if successful.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createChamferSurface
(face0, uv0, radius0, face1, uv1, radius1, extend, tolerance, multiple=false)¶ Creates a ruled surface as a bevel between two input surface edges.
Arguments:  face0 (rhino3dm.BrepFace) – First face to chamfer from.
 uv0 (rhino3dm.Point2d) – A parameter face0 at the side you want to keep after chamfering.
 radius0 (float) – The distance from the intersection of face0 to the edge of the chamfer.
 face1 (rhino3dm.BrepFace) – Second face to chamfer from.
 uv1 (rhino3dm.Point2d) – A parameter face1 at the side you want to keep after chamfering.
 radius1 (float) – 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 (float) – The tolerance. When in doubt, use the document’s model absolute tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Breps if successful.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createChamferSurface1
(face0, uv0, radius0, face1, uv1, radius1, trim, extend, tolerance, multiple=false)¶ Creates a ruled surface as a bevel between two input surface edges.
Arguments:  face0 (rhino3dm.BrepFace) – First face to chamfer from.
 uv0 (rhino3dm.Point2d) – A parameter face0 at the side you want to keep after chamfering.
 radius0 (float) – The distance from the intersection of face0 to the edge of the chamfer.
 face1 (rhino3dm.BrepFace) – Second face to chamfer from.
 uv1 (rhino3dm.Point2d) – A parameter face1 at the side you want to keep after chamfering.
 radius1 (float) – 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 (float) – The tolerance. When in doubt, use the document’s model absolute tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Breps if successful.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFilletEdges
(brep, edgeIndices, startRadii, endRadii, blendType, railType, tolerance, multiple=false)¶ Fillets, chamfers, or blends the edges of a brep.
Arguments:  brep (rhino3dm.Brep) – The brep to fillet, chamfer, or blend edges.
 edgeIndices (list[int]) – An array of one or more edge indices where the fillet, chamfer, or blend will occur.
 startRadii (list[float]) – An array of starting fillet, chamfer, or blend radaii, one for each edge index.
 endRadii (list[float]) – 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 (float) – The tolerance to be used to perform calculations.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of Breps if successful.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createOffsetBrep
(brep, distance, solid, extend, tolerance, multiple=false)¶ Offsets a Brep.
Arguments:  brep (rhino3dm.Brep) – The Brep to offset.
 distance (float) – 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 (float) – The offset tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
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).
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
removeFins
(thisBrep, multiple=false)¶ Recursively removes any Brep face with a naked edge. This function is only useful for nonmanifold Breps.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if successful, False if everything is removed or if the result has any Brep edges with more than two Brep trims.
Return type: bool

RhinoCompute.Brep.
createFromJoinedEdges
(brep0, edgeIndex0, brep1, edgeIndex1, joinTolerance, multiple=false)¶ Joins two naked edges, or edges that are coincident or close together, from two Breps.
Arguments:  brep0 (rhino3dm.Brep) – The first Brep.
 edgeIndex0 (int) – The edge index on the first Brep.
 brep1 (rhino3dm.Brep) – The second Brep.
 edgeIndex1 (int) – The edge index on the second Brep.
 joinTolerance (float) – The join tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The resulting Brep if successful, None on failure.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
createFromLoft
(curves, start, end, loftType, closed, multiple=false)¶ Constructs one or more Breps by lofting through a set of curves.
Arguments:  curves (list[rhino3dm.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 (rhino3dm.Point3d) – Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point.
 end (rhino3dm.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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
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.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromLoftRebuild
(curves, start, end, loftType, closed, rebuildPointCount, multiple=false)¶ 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.
Arguments:  curves (list[rhino3dm.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 (rhino3dm.Point3d) – Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point.
 end (rhino3dm.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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
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.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromLoftRefit
(curves, start, end, loftType, closed, refitTolerance, multiple=false)¶ Constructs one or more Breps by lofting through a set of curves. Input for the loft is simplified by refitting to a specified tolerance.
Arguments:  curves (list[rhino3dm.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 (rhino3dm.Point3d) – Optional starting point of loft. Use Point3d.Unset if you do not want to include a start point.
 end (rhino3dm.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 (float) – A distance to use in refitting, or 0 if you want to turn this parameter off.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
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.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createFromLoft1
(curves, start, end, StartTangent, EndTangent, StartTrim, EndTrim, loftType, closed, multiple=false)¶ 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
Arguments:  curves (list[rhino3dm.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 (rhino3dm.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 (rhino3dm.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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
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.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createPlanarUnion
(breps, plane, tolerance, multiple=false)¶ CreatePlanarUnion
Arguments:  breps (list[rhino3dm.Brep]) – The planar regions on which to preform the union operation.
 plane (rhino3dm.Plane) – The plane in which all the input breps lie
 tolerance (float) – Tolerance to use for union operation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createPlanarUnion1
(b0, b1, plane, tolerance, multiple=false)¶ CreatePlanarUnion
Arguments:  b0 (rhino3dm.Brep) – The first brep to union.
 b1 (rhino3dm.Brep) – The first brep to union.
 plane (rhino3dm.Plane) – The plane in which all the input breps lie
 tolerance (float) – Tolerance to use for union operation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createPlanarDifference
(b0, b1, plane, tolerance, multiple=false)¶ CreatePlanarDifference
Arguments:  b0 (rhino3dm.Brep) – The first brep to intersect.
 b1 (rhino3dm.Brep) – The first brep to intersect.
 plane (rhino3dm.Plane) – The plane in which all the input breps lie
 tolerance (float) – Tolerance to use for Difference operation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createPlanarIntersection
(b0, b1, plane, tolerance, multiple=false)¶ CreatePlanarIntersection
Arguments:  b0 (rhino3dm.Brep) – The first brep to intersect.
 b1 (rhino3dm.Brep) – The first brep to intersect.
 plane (rhino3dm.Plane) – The plane in which all the input breps lie
 tolerance (float) – Tolerance to use for intersection operation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createBooleanUnion
(breps, tolerance, multiple=false)¶ Compute the Boolean Union of a set of Breps.
Arguments:  breps (list[rhino3dm.Brep]) – Breps to union.
 tolerance (float) – Tolerance to use for union operation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createBooleanUnion1
(breps, tolerance, manifoldOnly, multiple=false)¶ Compute the Boolean Union of a set of Breps.
Arguments:  breps (list[rhino3dm.Brep]) – Breps to union.
 tolerance (float) – Tolerance to use for union operation.
 manifoldOnly (bool) – If true, nonmanifold input breps are ignored.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createBooleanIntersection
(firstSet, secondSet, tolerance, multiple=false)¶ Compute the Solid Intersection of two sets of Breps.
Arguments:  firstSet (list[rhino3dm.Brep]) – First set of Breps.
 secondSet (list[rhino3dm.Brep]) – Second set of Breps.
 tolerance (float) – Tolerance to use for intersection operation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createBooleanIntersection1
(firstSet, secondSet, tolerance, manifoldOnly, multiple=false)¶ Compute the Solid Intersection of two sets of Breps.
Arguments:  firstSet (list[rhino3dm.Brep]) – First set of Breps.
 secondSet (list[rhino3dm.Brep]) – Second set of Breps.
 tolerance (float) – Tolerance to use for intersection operation.
 manifoldOnly (bool) – If true, nonmanifold input breps are ignored.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createBooleanIntersection2
(firstBrep, secondBrep, tolerance, multiple=false)¶ Compute the Solid Intersection of two Breps.
Arguments:  firstBrep (rhino3dm.Brep) – First Brep for boolean intersection.
 secondBrep (rhino3dm.Brep) – Second Brep for boolean intersection.
 tolerance (float) – Tolerance to use for intersection operation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createBooleanIntersection3
(firstBrep, secondBrep, tolerance, manifoldOnly, multiple=false)¶ Compute the Solid Intersection of two Breps.
Arguments:  firstBrep (rhino3dm.Brep) – First Brep for boolean intersection.
 secondBrep (rhino3dm.Brep) – Second Brep for boolean intersection.
 tolerance (float) – Tolerance to use for intersection operation.
 manifoldOnly (bool) – If true, nonmanifold input breps are ignored.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createBooleanDifference
(firstSet, secondSet, tolerance, multiple=false)¶ Compute the Solid Difference of two sets of Breps.
Arguments:  firstSet (list[rhino3dm.Brep]) – First set of Breps (the set to subtract from).
 secondSet (list[rhino3dm.Brep]) – Second set of Breps (the set to subtract).
 tolerance (float) – Tolerance to use for difference operation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createBooleanDifference1
(firstSet, secondSet, tolerance, manifoldOnly, multiple=false)¶ Compute the Solid Difference of two sets of Breps.
Arguments:  firstSet (list[rhino3dm.Brep]) – First set of Breps (the set to subtract from).
 secondSet (list[rhino3dm.Brep]) – Second set of Breps (the set to subtract).
 tolerance (float) – Tolerance to use for difference operation.
 manifoldOnly (bool) – If true, nonmanifold input breps are ignored.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createBooleanDifference2
(firstBrep, secondBrep, tolerance, multiple=false)¶ Compute the Solid Difference of two Breps.
Arguments:  firstBrep (rhino3dm.Brep) – First Brep for boolean difference.
 secondBrep (rhino3dm.Brep) – Second Brep for boolean difference.
 tolerance (float) – Tolerance to use for difference operation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createBooleanDifference3
(firstBrep, secondBrep, tolerance, manifoldOnly, multiple=false)¶ Compute the Solid Difference of two Breps.
Arguments:  firstBrep (rhino3dm.Brep) – First Brep for boolean difference.
 secondBrep (rhino3dm.Brep) – Second Brep for boolean difference.
 tolerance (float) – Tolerance to use for difference operation.
 manifoldOnly (bool) – If true, nonmanifold input breps are ignored.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createBooleanSplit
(firstBrep, secondBrep, tolerance, multiple=false)¶ Splits shared areas of Breps and creates separate Breps from the shared and unshared parts.
Arguments:  firstBrep (rhino3dm.Brep) – The Brep to split.
 secondBrep (rhino3dm.Brep) – The cutting Brep.
 tolerance (float) – Tolerance to use for splitting operation. When in doubt, use the document’s model absolute tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep if successful, an empty array on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createBooleanSplit1
(firstSet, secondSet, tolerance, multiple=false)¶ Splits shared areas of Breps and creates separate Breps from the shared and unshared parts.
Arguments:  firstSet (list[rhino3dm.Brep]) – The Breps to split.
 secondSet (list[rhino3dm.Brep]) – The cutting Breps.
 tolerance (float) – Tolerance to use for splitting operation. When in doubt, use the document’s model absolute tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep if successful, an empty array on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
createShell
(brep, facesToRemove, distance, tolerance, multiple=false)¶ Creates a hollowed out shell from a solid Brep. Function only operates on simple, solid, manifold Breps.
Arguments:  brep (rhino3dm.Brep) – The solid Brep to shell.
 facesToRemove (list[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 (float) – The distance, or thickness, for the shell. This is a signed distance value with respect to face normals and flipped faces.
 tolerance (float) – The offset tolerance. When in doubt, use the document’s absolute tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Brep results or None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
joinBreps
(brepsToJoin, tolerance, multiple=false)¶ 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.
Arguments:  brepsToJoin (list[rhino3dm.Brep]) – A list, an array or any enumerable set of breps to join.
 tolerance (float) – 3d distance tolerance for detecting overlapping edges.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: new joined breps on success, None on failure.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
mergeBreps
(brepsToMerge, tolerance, multiple=false)¶ Combines two or more breps into one. A merge is like a boolean union that keeps the inside pieces. This function creates nonmanifold Breps which in general are unusual in Rhino. You may want to consider using JoinBreps or CreateBooleanUnion functions instead.
Arguments:  brepsToMerge (list[rhino3dm.Brep]) – must contain more than one Brep.
 tolerance (float) – the tolerance to use when merging.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Single merged Brep on success. Null on error.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
createContourCurves
(brepToContour, contourStart, contourEnd, interval, multiple=false)¶ Constructs the contour curves for a brep at a specified interval.
Arguments:  brepToContour (rhino3dm.Brep) – A brep or polysurface.
 contourStart (rhino3dm.Point3d) – A point to start.
 contourEnd (rhino3dm.Point3d) – A point to use as the end.
 interval (float) – The interaxial offset in world units.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array with intersected curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Brep.
createContourCurves1
(brepToContour, sectionPlane, multiple=false)¶ Constructs the contour curves for a brep, using a slicing plane.
Arguments:  brepToContour (rhino3dm.Brep) – A brep or polysurface.
 sectionPlane (rhino3dm.Plane) – A plane.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array with intersected curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Brep.
createCurvatureAnalysisMesh
(brep, state, multiple=false)¶ Create an array of analysis meshes for the brep using the specified settings. Meshes aren’t set on the brep.
Arguments:  state (Rhino.ApplicationSettings.CurvatureAnalysisSettingsState) – CurvatureAnalysisSettingsState
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if meshes were created
Return type: rhino3dm.Mesh[]

RhinoCompute.Brep.
getRegions
(thisBrep, multiple=false)¶ Gets an array containing all regions in this brep.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of regions in this brep. This array can be empty, but not null.
Return type: BrepRegion[]

RhinoCompute.Brep.
getWireframe
(thisBrep, density, multiple=false)¶ Constructs all the Wireframe curves for this Brep.
Arguments:  density (int) – Wireframe density. Valid values range between 1 and 99.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of Wireframe curves or None on failure.
Return type: rhino3dm.Curve[]

RhinoCompute.Brep.
closestPoint
(thisBrep, testPoint, multiple=false)¶ Finds a point on the brep that is closest to testPoint.
Arguments:  testPoint (rhino3dm.Point3d) – Base point to project to brep.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The point on the Brep closest to testPoint or Point3d.Unset if the operation failed.
Return type: rhino3dm.Point3d

RhinoCompute.Brep.
isPointInside
(thisBrep, point, tolerance, strictlyIn, multiple=false)¶ 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.
Arguments:  point (rhino3dm.Point3d) – 3d point to test.
 tolerance (float) – 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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if point is in, False if not.
Return type: bool

RhinoCompute.Brep.
getPointInside
(thisBrep, tolerance, multiple=false)¶ Finds a point inside of a solid Brep.
Arguments:  tolerance (float) – 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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
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.
Return type: bool

RhinoCompute.Brep.
capPlanarHoles
(thisBrep, tolerance, multiple=false)¶ Returns a new Brep that is equivalent to this Brep with all planar holes capped.
Arguments:  tolerance (float) – Tolerance to use for capping.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: New brep on success. None on error.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
join
(thisBrep, otherBrep, tolerance, compact, multiple=false)¶ 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.
Arguments:  otherBrep (rhino3dm.Brep) – Brep to be added to this brep.
 tolerance (float) – 3d distance tolerance for detecting overlapping edges.
 compact (bool) – if true, set brep flags and tolerances, remove unused faces and edges.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if any edges were joined.
Return type: bool

RhinoCompute.Brep.
joinNakedEdges
(thisBrep, tolerance, multiple=false)¶ Joins naked edge pairs within the same brep that overlap within tolerance.
Arguments:  tolerance (float) – The tolerance value.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: number of joins made.
Return type: int

RhinoCompute.Brep.
mergeCoplanarFaces
(thisBrep, tolerance, multiple=false)¶ Merges adjacent coplanar faces into single faces.
Arguments:  tolerance (float) – Tolerance for determining when edges are adjacent. When in doubt, use the document’s ModelAbsoluteTolerance property.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if faces were merged, False if no faces were merged.
Return type: bool

RhinoCompute.Brep.
mergeCoplanarFaces1
(thisBrep, tolerance, angleTolerance, multiple=false)¶ Merges adjacent coplanar faces into single faces.
Arguments:  tolerance (float) – Tolerance for determining when edges are adjacent. When in doubt, use the document’s ModelAbsoluteTolerance property.
 angleTolerance (float) – Angle tolerance, in radians, for determining when faces are parallel. When in doubt, use the document’s ModelAngleToleranceRadians property.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if faces were merged, False if no faces were merged.
Return type: bool

RhinoCompute.Brep.
split
(thisBrep, cutter, intersectionTolerance, multiple=false)¶ Splits a Brep into pieces using a Brep as a cutter.
Arguments:  cutter (rhino3dm.Brep) – The Brep to use as a cutter.
 intersectionTolerance (float) – The tolerance with which to compute intersections.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new array of Breps. This array can be empty.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
split1
(thisBrep, cutter, intersectionTolerance, multiple=false)¶ Splits a Brep into pieces using a Brep as a cutter.
Arguments:  cutter (rhino3dm.Brep) – The Brep to use as a cutter.
 intersectionTolerance (float) – The tolerance with which to compute intersections.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new array of Breps. This array can be empty.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
split2
(thisBrep, cutters, intersectionTolerance, multiple=false)¶ Splits a Brep into pieces using Breps as cutters.
Arguments:  cutters (list[rhino3dm.Brep]) – One or more Breps to use as cutters.
 intersectionTolerance (float) – The tolerance with which to compute intersections.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new array of Breps. This array can be empty.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
split3
(thisBrep, cutters, intersectionTolerance, multiple=false)¶ Splits a Brep into pieces using curves, at least partially on the Brep, as cutters.
Arguments:  cutters (list[rhino3dm.Curve]) – The splitting curves. Only the portion of the curve on the Brep surface will be used for cutting.
 intersectionTolerance (float) – The tolerance with which to compute intersections.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new array of Breps. This array can be empty.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
split4
(thisBrep, cutters, normal, planView, intersectionTolerance, multiple=false)¶ Splits a Brep into pieces using a combination of curves, to be extruded, and Breps as cutters.
Arguments:  cutters (list[rhino3dm.GeometryBase]) – The curves, surfaces, faces and Breps to be used as cutters. Any other geometry is ignored.
 normal (rhino3dm.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 (float) – The tolerance with which to compute intersections.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new array of Breps. This array can be empty.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
trim
(thisBrep, cutter, intersectionTolerance, multiple=false)¶ 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.
Arguments:  cutter (rhino3dm.Brep) – A cutting brep.
 intersectionTolerance (float) – A tolerance value with which to compute intersections.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: This Brep is not modified, the trim results are returned in an array.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
trim1
(thisBrep, cutter, intersectionTolerance, multiple=false)¶ 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.
Arguments:  cutter (rhino3dm.Plane) – A cutting plane.
 intersectionTolerance (float) – A tolerance value with which to compute intersections.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: This Brep is not modified, the trim results are returned in an array.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
unjoinEdges
(thisBrep, edgesToUnjoin, multiple=false)¶ Unjoins, or separates, edges within the Brep. Note, seams in closed surfaces will not separate.
Arguments:  edgesToUnjoin (list[int]) – The indices of the Brep edges to unjoin.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: This Brep is not modified, the trim results are returned in an array.
Return type: rhino3dm.Brep[]

RhinoCompute.Brep.
joinEdges
(thisBrep, edgeIndex0, edgeIndex1, joinTolerance, compact, multiple=false)¶ Joins two naked edges, or edges that are coincident or close together.
Arguments:  edgeIndex0 (int) – The first edge index.
 edgeIndex1 (int) – The second edge index.
 joinTolerance (float) – 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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if successful, False otherwise.
Return type: bool

RhinoCompute.Brep.
transformComponent
(thisBrep, components, xform, tolerance, timeLimit, useMultipleThreads, multiple=false)¶ Transform an array of Brep components, bend neighbors to match, and leave the rest fixed.
Arguments:  components (IEnumerable<ComponentIndex>) – The Brep components to transform.
 xform (Transform) – The transformation to apply.
 tolerance (float) – The desired fitting tolerance to use when bending faces that share edges with both fixed and transformed components.
 timeLimit (float) – 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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if successful, False otherwise.
Return type: bool

RhinoCompute.Brep.
getArea
(thisBrep, multiple=false)¶ Compute the Area of the Brep. If you want proper Area data with moments and error information, use the AreaMassProperties class.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The area of the Brep.
Return type: float

RhinoCompute.Brep.
getArea1
(thisBrep, relativeTolerance, absoluteTolerance, multiple=false)¶ Compute the Area of the Brep. If you want proper Area data with moments and error information, use the AreaMassProperties class.
Arguments:  relativeTolerance (float) – Relative tolerance to use for area calculation.
 absoluteTolerance (float) – Absolute tolerance to use for area calculation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The area of the Brep.
Return type: float

RhinoCompute.Brep.
getVolume
(thisBrep, multiple=false)¶ Compute the Volume of the Brep. If you want proper Volume data with moments and error information, use the VolumeMassProperties class.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The volume of the Brep.
Return type: float

RhinoCompute.Brep.
getVolume1
(thisBrep, relativeTolerance, absoluteTolerance, multiple=false)¶ Compute the Volume of the Brep. If you want proper Volume data with moments and error information, use the VolumeMassProperties class.
Arguments:  relativeTolerance (float) – Relative tolerance to use for area calculation.
 absoluteTolerance (float) – Absolute tolerance to use for area calculation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The volume of the Brep.
Return type: float

RhinoCompute.Brep.
rebuildTrimsForV2
(thisBrep, face, nurbsSurface, multiple=false)¶ 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.
Arguments:  face (rhino3dm.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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: void

RhinoCompute.Brep.
makeValidForV2
(thisBrep, multiple=false)¶ No support is available for this function. Expert user function that converts all geometry in Brep to NURB form.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: bool

RhinoCompute.Brep.
repair
(thisBrep, tolerance, multiple=false)¶ 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.
Arguments:  tolerance (float) – The repair tolerance. When in doubt, use the document’s model absolute tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success.
Return type: bool

RhinoCompute.Brep.
removeHoles
(thisBrep, tolerance, multiple=false)¶ Remove all inner loops, or holes, in a Brep.
Arguments:  tolerance (float) – The tolerance. When in doubt, use the document’s model absolute tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The Brep without holes if successful, None otherwise.
Return type: rhino3dm.Brep

RhinoCompute.Brep.
removeHoles1
(thisBrep, loops, tolerance, multiple=false)¶ Removes inner loops, or holes, in a Brep.
Arguments:  loops (IEnumerable<ComponentIndex>) – A list of BrepLoop component indexes, where BrepLoop.LoopType == Rhino.Geometry.BrepLoopType.Inner.
 tolerance (float) – The tolerance. When in doubt, use the document’s model absolute tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The Brep without holes if successful, None otherwise.
Return type: rhino3dm.Brep