RhinoCompute.Mesh¶

RhinoCompute.Mesh.
createFromPlane
(plane, xInterval, yInterval, xCount, yCount, multiple=false)¶ Constructs a planar mesh grid.
Arguments:  plane (rhino3dm.Plane) – Plane of mesh.
 xInterval (rhino3dm.Interval) – Interval describing size and extends of mesh along plane xdirection.
 yInterval (rhino3dm.Interval) – Interval describing size and extends of mesh along plane ydirection.
 xCount (int) – Number of faces in xdirection.
 yCount (int) – Number of faces in ydirection.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromFilteredFaceList
(original, inclusion, multiple=false)¶ Constructs a submesh, that contains a filtered list of faces.
Arguments:  original (rhino3dm.Mesh) – The mesh to copy. This item can be null, and in this case an empty mesh is returned.
 inclusion (IEnumerable<bool>) – A series of True and False values, that determine if each face is used in the new mesh. If the amount does not match the length of the face list, the pattern is repeated. If it exceeds the amount of faces in the mesh face list, the pattern is truncated. This items can be None or empty, and the mesh will simply be duplicated.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromBox
(box, xCount, yCount, zCount, multiple=false)¶ Constructs new mesh that matches a bounding box.
Arguments:  box (rhino3dm.BoundingBox) – A box to use for creation.
 xCount (int) – Number of faces in xdirection.
 yCount (int) – Number of faces in ydirection.
 zCount (int) – Number of faces in zdirection.
 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 failure.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromBox1
(box, xCount, yCount, zCount, multiple=false)¶ Constructs new mesh that matches an aligned box.
Arguments:  box (rhino3dm.Box) – Box to match.
 xCount (int) – Number of faces in xdirection.
 yCount (int) – Number of faces in ydirection.
 zCount (int) – Number of faces in zdirection.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromBox2
(corners, xCount, yCount, zCount, multiple=false)¶ Constructs new mesh from 8 corner points.
Arguments:  corners (list[rhino3dm.Point3d]) – 8 points defining the box corners arranged as the vN labels indicate. v7_____________v6 \ \  \ \ _____________\ v4  v5      v3———v2        v0_____________v1
 xCount (int) – Number of faces in xdirection.
 yCount (int) – Number of faces in ydirection.
 zCount (int) – Number of faces in zdirection.
 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 failure. A new box mesh, on None on error.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromSphere
(sphere, xCount, yCount, multiple=false)¶ Constructs a mesh sphere.
Arguments:  sphere (rhino3dm.Sphere) – Base sphere for mesh.
 xCount (int) – Number of faces in the around direction.
 yCount (int) – Number of faces in the toptobottom direction.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createIcoSphere
(sphere, subdivisions, multiple=false)¶ Constructs a icospherical mesh. A mesh icosphere differs from a standard UV mesh sphere in that it’s vertices are evenly distributed. A mesh icosphere starts from an icosahedron (a regular polyhedron with 20 equilateral triangles). It is then refined by splitting each triangle into 4 smaller triangles. This splitting can be done several times.
Arguments:  sphere (rhino3dm.Sphere) – The input sphere provides the orienting plane and radius.
 subdivisions (int) – The number of times you want the faces split, where 0 <= subdivisions <= 7. Note, the total number of mesh faces produces is: 20 * (4 ^ subdivisions)
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A welded mesh icosphere if successful, or None on failure.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createQuadSphere
(sphere, subdivisions, multiple=false)¶ Constructs a quad mesh sphere. A quad mesh sphere differs from a standard UV mesh sphere in that it’s vertices are evenly distributed. A quad mesh sphere starts from a cube (a regular polyhedron with 6 square sides). It is then refined by splitting each quad into 4 smaller quads. This splitting can be done several times.
Arguments:  sphere (rhino3dm.Sphere) – The input sphere provides the orienting plane and radius.
 subdivisions (int) – The number of times you want the faces split, where 0 <= subdivisions <= 8. Note, the total number of mesh faces produces is: 6 * (4 ^ subdivisions)
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A welded quad mesh sphere if successful, or None on failure.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromCylinder
(cylinder, vertical, around, multiple=false)¶ Constructs a capped mesh cylinder.
Arguments:  vertical (int) – Number of faces in the toptobottom direction.
 around (int) – Number of faces around the cylinder.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Returns a mesh cylinder if successful, None otherwise.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromCylinder1
(cylinder, vertical, around, capBottom, capTop, multiple=false)¶ Constructs a mesh cylinder.
Arguments:  vertical (int) – Number of faces in the toptobottom direction.
 around (int) – Number of faces around the cylinder.
 capBottom (bool) – If True end at Cylinder.Height1 should be capped.
 capTop (bool) – If True end at Cylinder.Height2 should be capped.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Returns a mesh cylinder if successful, None otherwise.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromCylinder2
(cylinder, vertical, around, capBottom, capTop, quadCaps, multiple=false)¶ Constructs a mesh cylinder.
Arguments:  vertical (int) – Number of faces in the toptobottom direction.
 around (int) – Number of faces around the cylinder.
 capBottom (bool) – If True end at Cylinder.Height1 should be capped.
 capTop (bool) – If True end at Cylinder.Height2 should be capped.
 quadCaps (bool) – If True and it’s possible to make quad caps, i.e.. around is even, then caps will have quad faces.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Returns a mesh cylinder if successful, None otherwise.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromCone
(cone, vertical, around, multiple=false)¶ Constructs a solid mesh cone.
Arguments:  vertical (int) – Number of faces in the toptobottom direction.
 around (int) – Number of faces around the cone.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A valid mesh if successful.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromCone1
(cone, vertical, around, solid, multiple=false)¶ Constructs a mesh cone.
Arguments:  vertical (int) – Number of faces in the toptobottom direction.
 around (int) – Number of faces around the cone.
 solid (bool) – If False the mesh will be open with no faces on the circular planar portion.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A valid mesh if successful.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromCone2
(cone, vertical, around, solid, quadCaps, multiple=false)¶ Constructs a mesh cone.
Arguments:  vertical (int) – Number of faces in the toptobottom direction.
 around (int) – Number of faces around the cone.
 solid (bool) – If False the mesh will be open with no faces on the circular planar portion.
 quadCaps (bool) – If True and it’s possible to make quad caps, i.e.. around is even, then caps will have quad faces.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A valid mesh if successful.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromTorus
(torus, vertical, around, multiple=false)¶ Constructs a mesh torus.
Arguments:  torus (Torus) – The torus.
 vertical (int) – Number of faces in the toptobottom direction.
 around (int) – Number of faces around the torus.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Returns a mesh torus if successful, None otherwise.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromPlanarBoundary
(boundary, parameters, multiple=false)¶ Do not use this overload. Use version that takes a tolerance parameter instead.
Arguments:  boundary (rhino3dm.Curve) – Do not use.
 parameters (rhino3dm.MeshingParameters) – Do not use.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Do not use.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromPlanarBoundary1
(boundary, parameters, tolerance, multiple=false)¶ Attempts to construct a mesh from a closed planar curve.RhinoMakePlanarMeshes
Arguments:  boundary (rhino3dm.Curve) – must be a closed planar curve.
 parameters (rhino3dm.MeshingParameters) – parameters used for creating the mesh.
 tolerance (float) – Tolerance to use during operation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: New mesh on success or None on failure.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromClosedPolyline
(polyline, multiple=false)¶ Attempts to create a Mesh that is a triangulation of a simple closed polyline that projects onto a plane.
Arguments:  polyline (rhino3dm.Polyline) – must be closed
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: New mesh on success or None on failure.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromTessellation
(points, edges, plane, allowNewVertices, multiple=false)¶ Attempts to create a mesh that is a triangulation of a list of points, projected on a plane, including its holes and fixed edges.
Arguments:  points (list[rhino3dm.Point3d]) – A list, an array or any enumerable of points.
 plane (rhino3dm.Plane) – A plane.
 allowNewVertices (bool) – If true, the mesh might have more vertices than the list of input points, if doing so will improve long thin triangles.
 edges (IEnumerable<IEnumerable<Point3d>>) – A list of polylines, or other lists of points representing edges. This can be null. If nested enumerable items are null, they will be discarded.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new mesh, or None if not successful.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromBrep
(brep, multiple=false)¶ Constructs a mesh from a brep.
Arguments:  brep (rhino3dm.Brep) – Brep to approximate.
 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 meshes.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
createFromBrep1
(brep, meshingParameters, multiple=false)¶ Constructs a mesh from a brep.
Arguments:  brep (rhino3dm.Brep) – Brep to approximate.
 meshingParameters (rhino3dm.MeshingParameters) – Parameters to use during meshing.
 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 meshes.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
createFromSurface
(surface, multiple=false)¶ Constructs a mesh from a surface
Arguments:  surface (rhino3dm.Surface) – Surface to approximate
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: New mesh representing the surface
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromSurface1
(surface, meshingParameters, multiple=false)¶ Constructs a mesh from a surface
Arguments:  surface (rhino3dm.Surface) – Surface to approximate
 meshingParameters (rhino3dm.MeshingParameters) – settings used to create the mesh
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: New mesh representing the surface
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromSubD
(subd, displayDensity, multiple=false)¶ Create a mesh from a SubD limit surface
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createPatch
(outerBoundary, angleToleranceRadians, pullbackSurface, innerBoundaryCurves, innerBothSideCurves, innerPoints, trimback, divisions, multiple=false)¶ Construct a mesh patch from a variety of input geometry.
Arguments:  outerBoundary (rhino3dm.Polyline) – (optional: can be null) Outer boundary polyline, if provided this will become the outer boundary of the resulting mesh. Any of the input that is completely outside the outer boundary will be ignored and have no impact on the result. If any of the input intersects the outer boundary the result will be unpredictable and is likely to not include the entire outer boundary.
 angleToleranceRadians (float) – Maximum angle between unit tangents and adjacent vertices. Used to divide curve inputs that cannot otherwise be represented as a polyline.
 innerBoundaryCurves (list[rhino3dm.Curve]) – (optional: can be null) Polylines to create holes in the output mesh. If innerBoundaryCurves are the only input then the result may be null if trimback is set to False (see comments for trimback) because the resulting mesh could be invalid (all faces created contained vertexes from the perimeter boundary).
 pullbackSurface (rhino3dm.Surface) – (optional: can be null) Initial surface where 3d input will be pulled to make a 2d representation used by the function that generates the mesh. Providing a pullbackSurface can be helpful when it is similar in shape to the pattern of the input, the pulled 2d points will be a better representation of the 3d points. If all of the input is more or less coplanar to start with, providing pullbackSurface has no real benefit.
 innerBothSideCurves (list[rhino3dm.Curve]) – (optional: can be null) These polylines will create faces on both sides of the edge. If there are only input points(innerPoints) there is no way to guarantee a triangulation that will create an edge between two particular points. Adding a line, or polyline, to innerBothsideCurves that includes points from innerPoints will help guide the triangulation.
 innerPoints (list[rhino3dm.Point3d]) – (optional: can be null) Points to be used to generate the mesh. If outerBoundary is not null, points outside of that boundary after it has been pulled to pullbackSurface (or the best plane through the input if pullbackSurface is null) will be ignored.
 trimback (bool) – Only used when a outerBoundary has not been provided. When that is the case, the function uses the perimeter of the surface as the outer boundary instead. If true, any face of the resulting triangulated mesh that contains a vertex of the perimeter boundary will be removed.
 divisions (int) – Only used when a outerBoundary has not been provided. When that is the case, division becomes the number of divisions each side of the surface’s perimeter will be divided into to create an outer boundary to work with.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: mesh on success; None on failure
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createBooleanUnion
(meshes, multiple=false)¶ Computes the solid union of a set of meshes.
Arguments:  meshes (list[rhino3dm.Mesh]) – Meshes to union.
 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 Mesh results or None on failure.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
createBooleanDifference
(firstSet, secondSet, multiple=false)¶ Computes the solid difference of two sets of Meshes.
Arguments:  firstSet (list[rhino3dm.Mesh]) – First set of Meshes (the set to subtract from).
 secondSet (list[rhino3dm.Mesh]) – Second set of Meshes (the set to subtract).
 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 Mesh results or None on failure.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
createBooleanIntersection
(firstSet, secondSet, multiple=false)¶ Computes the solid intersection of two sets of meshes.
Arguments:  firstSet (list[rhino3dm.Mesh]) – First set of Meshes.
 secondSet (list[rhino3dm.Mesh]) – Second set of Meshes.
 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 Mesh results or None on failure.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
createBooleanSplit
(meshesToSplit, meshSplitters, multiple=false)¶ Splits a set of meshes with another set.
Arguments:  meshesToSplit (list[rhino3dm.Mesh]) – A list, an array, or any enumerable set of meshes to be split. If this is null, None will be returned.
 meshSplitters (list[rhino3dm.Mesh]) – A list, an array, or any enumerable set of meshes that cut. If this is null, None will be returned.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new mesh array, or None on error.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
createFromCurvePipe
(curve, radius, segments, accuracy, capType, faceted, intervals, multiple=false)¶ Constructs a new mesh pipe from a curve.
Arguments:  curve (rhino3dm.Curve) – A curve to pipe.
 radius (float) – The radius of the pipe.
 segments (int) – The number of segments in the pipe.
 accuracy (int) – The accuracy of the pipe.
 capType (MeshPipeCapStyle) – The type of cap to be created at the end of the pipe.
 faceted (bool) – Specifies whether the pipe is faceted, or not.
 intervals (list[rhino3dm.Interval]) – A series of intervals to pipe. This value can be null.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new mesh, or None on failure.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromCurveExtrusion
(curve, direction, parameters, boundingBox, multiple=false)¶ Constructs a new extrusion from a curve.
Arguments:  curve (rhino3dm.Curve) – A curve to extrude.
 direction (rhino3dm.Vector3d) – The direction of extrusion.
 parameters (rhino3dm.MeshingParameters) – The parameters of meshing.
 boundingBox (rhino3dm.BoundingBox) – The bounding box controls the length 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: A new mesh, or None on failure.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
createFromIterativeCleanup
(meshes, tolerance, multiple=false)¶ Repairs meshes with vertices that are too near, using a tolerance value.
Arguments:  meshes (list[rhino3dm.Mesh]) – The meshes to be repaired.
 tolerance (float) – A minimum distance for clean vertices.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A valid meshes array if successful. If no change was required, some meshes can be null. Otherwise, null, when no changes were done.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
requireIterativeCleanup
(meshes, tolerance, multiple=false)¶ Analyzes some meshes, and determines if a pass of CreateFromIterativeCleanup would change the array. All available cleanup steps are used. Currently available cleanup steps are: mending of single precision coincidence even though double precision vertices differ. union of nearly identical vertices, irrespectively of their origin. removal of tjoints along edges.
Arguments:  meshes (list[rhino3dm.Mesh]) – A list, and array or any enumerable of meshes.
 tolerance (float) – A 3d distance. This is usually a value of about 10e7 magnitude.
 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 would be changed, otherwise false.
Return type: bool

RhinoCompute.Mesh.
volume
(thisMesh, multiple=false)¶ Compute volume of the mesh.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Volume of the mesh.
Return type: float

RhinoCompute.Mesh.
isPointInside
(thisMesh, point, tolerance, strictlyIn, multiple=false)¶ Determines if a point is inside a solid mesh.
Arguments:  point (rhino3dm.Point3d) – 3d point to test.
 tolerance (float) – (>=0) 3d distance tolerance used for raymesh intersection and determining strict inclusion.
 strictlyIn (bool) – If strictlyIn is true, then point must be inside mesh by at least tolerance in order for this function to return true. If strictlyIn is false, then this function will return True if point is inside or the distance from point to a mesh face is <= tolerance.
 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 inside the solid mesh, False if not.
Return type: bool

RhinoCompute.Mesh.
smooth
(thisMesh, smoothFactor, bXSmooth, bYSmooth, bZSmooth, bFixBoundaries, coordinateSystem, multiple=false)¶ Smooths a mesh by averaging the positions of mesh vertices in a specified region.
Arguments:  smoothFactor (float) – The smoothing factor, which controls how much vertices move towards the average of the neighboring vertices.
 bXSmooth (bool) – When True vertices move in X axis direction.
 bYSmooth (bool) – When True vertices move in Y axis direction.
 bZSmooth (bool) – When True vertices move in Z axis direction.
 bFixBoundaries (bool) – When True vertices along naked edges will not be modified.
 coordinateSystem (SmoothingCoordinateSystem) – The coordinates to determine the direction of the smoothing.
 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.Mesh.
smooth1
(thisMesh, smoothFactor, bXSmooth, bYSmooth, bZSmooth, bFixBoundaries, coordinateSystem, plane, multiple=false)¶ Smooths a mesh by averaging the positions of mesh vertices in a specified region.
Arguments:  smoothFactor (float) – The smoothing factor, which controls how much vertices move towards the average of the neighboring vertices.
 bXSmooth (bool) – When True vertices move in X axis direction.
 bYSmooth (bool) – When True vertices move in Y axis direction.
 bZSmooth (bool) – When True vertices move in Z axis direction.
 bFixBoundaries (bool) – When True vertices along naked edges will not be modified.
 coordinateSystem (SmoothingCoordinateSystem) – The coordinates to determine the direction of the smoothing.
 plane (rhino3dm.Plane) – If SmoothingCoordinateSystem.CPlane specified, then the construction plane.
 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.Mesh.
smooth2
(thisMesh, vertexIndices, smoothFactor, bXSmooth, bYSmooth, bZSmooth, bFixBoundaries, coordinateSystem, plane, multiple=false)¶ Smooths part of a mesh by averaging the positions of mesh vertices in a specified region.
Arguments:  vertexIndices (list[int]) – The mesh vertex indices that specify the part of the mesh to smooth.
 smoothFactor (float) – The smoothing factor, which controls how much vertices move towards the average of the neighboring vertices.
 bXSmooth (bool) – When True vertices move in X axis direction.
 bYSmooth (bool) – When True vertices move in Y axis direction.
 bZSmooth (bool) – When True vertices move in Z axis direction.
 bFixBoundaries (bool) – When True vertices along naked edges will not be modified.
 coordinateSystem (SmoothingCoordinateSystem) – The coordinates to determine the direction of the smoothing.
 plane (rhino3dm.Plane) – If SmoothingCoordinateSystem.CPlane specified, then the construction plane.
 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.Mesh.
unweld
(thisMesh, angleToleranceRadians, modifyNormals, multiple=false)¶ Makes sure that faces sharing an edge and having a difference of normal greater than or equal to angleToleranceRadians have unique vertexes along that edge, adding vertices if necessary.
Arguments:  angleToleranceRadians (float) – Angle at which to make unique vertices.
 modifyNormals (bool) – Determines whether new vertex normals will have the same vertex normal as the original (false) or vertex normals made from the corresponding face normals (true)
 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.Mesh.
unweldEdge
(thisMesh, edgeIndices, modifyNormals, multiple=false)¶ Adds creases to a smooth mesh by creating coincident vertices along selected edges.
Arguments:  edgeIndices (list[int]) – An array of mesh topology edge indices.
 modifyNormals (bool) – If true, the vertex normals on each side of the edge take the same value as the face to which they belong, giving the mesh a hard edge look. If false, each of the vertex normals on either side of the edge is assigned the same value as the original normal that the pair is replacing, keeping a smooth look.
 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.Mesh.
unweldVertices
(thisMesh, topologyVertexIndices, modifyNormals, multiple=false)¶ Ensures that faces sharing a common topological vertex have unique indices into the collection.
Arguments:  topologyVertexIndices (list[int]) – Topological vertex indices, from the collection, to be unwelded. Use to convert from vertex indices to topological vertex indices.
 modifyNormals (bool) – If true, the new vertex normals will be calculated from the face normal.
 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.Mesh.
weld
(thisMesh, angleToleranceRadians, multiple=false)¶ Makes sure that faces sharing an edge and having a difference of normal greater than or equal to angleToleranceRadians share vertexes along that edge, vertex normals are averaged.
Arguments:  angleToleranceRadians (float) – Angle at which to weld vertices.
 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.Mesh.
rebuildNormals
(thisMesh, multiple=false)¶ Removes mesh normals and reconstructs the face and vertex normals based on the orientation of the faces.
Arguments:  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.Mesh.
extractNonManifoldEdges
(thisMesh, selective, multiple=false)¶ Extracts, or removes, nonmanifold mesh edges.
Arguments:  selective (bool) – If true, then extract hanging faces only.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A mesh containing the extracted nonmanifold parts if successful, None otherwise.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
healNakedEdges
(thisMesh, distance, multiple=false)¶ Attempts to “heal” naked edges in a mesh based on a given distance. First attempts to move vertexes to neighboring vertexes that are within that distance away. Then it finds edges that have a closest point to the vertex within the distance and splits the edge. When it finds one it splits the edge and makes two new edges using that point.
Arguments:  distance (float) – Distance to not exceed when modifying the mesh.
 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.Mesh.
fillHoles
(thisMesh, multiple=false)¶ Attempts to determine “holes” in the mesh by chaining naked edges together. Then it triangulates the closed polygons adds the faces to the mesh.
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 otherwise.
Return type: bool

RhinoCompute.Mesh.
fileHole
(thisMesh, topologyEdgeIndex, multiple=false)¶ Given a starting “naked” edge index, this function attempts to determine a “hole” by chaining additional naked edges together until if returns to the start index. Then it triangulates the closed polygon and either adds the faces to the mesh.
Arguments:  topologyEdgeIndex (int) – Starting naked edge index.
 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.Mesh.
unifyNormals
(thisMesh, multiple=false)¶ Attempts to fix inconsistencies in the directions of mesh faces in a mesh. This function does not modify mesh vertex normals, it rearranges the mesh face winding and face normals to make them all consistent. Note, you may want to call Mesh.Normals.ComputeNormals() to recompute vertex normals after calling this functions.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: number of faces that were modified.
Return type: int

RhinoCompute.Mesh.
unifyNormals1
(thisMesh, countOnly, multiple=false)¶ Attempts to fix inconsistencies in the directions of mesh faces in a mesh. This function does not modify mesh vertex normals, it rearranges the mesh face winding and face normals to make them all consistent. Note, you may want to call Mesh.Normals.ComputeNormals() to recompute vertex normals after calling this functions.
Arguments:  countOnly (bool) – If true, then only the number of faces that would be modified is determined.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: If countOnly=false, the number of faces that were modified. If countOnly=true, the number of faces that would be modified.
Return type: int

RhinoCompute.Mesh.
splitDisjointPieces
(thisMesh, multiple=false)¶ Splits up the mesh into its unconnected pieces.
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 containing all the disjoint pieces that make up this Mesh.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
split
(thisMesh, plane, multiple=false)¶ Split a mesh by an infinite plane.
Arguments:  plane (rhino3dm.Plane) – The splitting plane.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new mesh array with the split result. This can be None if no result was found.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
split1
(thisMesh, mesh, multiple=false)¶ Split a mesh with another mesh. Suggestion: upgrade to overload with tolerance.
Arguments:  mesh (rhino3dm.Mesh) – Mesh to split with.
 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 mesh segments representing the split result.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
split2
(thisMesh, meshes, multiple=false)¶ Split a mesh with a collection of meshes. Suggestion: upgrade to overload with tolerance. Does not split at coplanar intersections.
Arguments:  meshes (list[rhino3dm.Mesh]) – Meshes to split with.
 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 mesh segments representing the split result.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
split3
(thisMesh, meshes, tolerance, splitAtCoplanar, textLog, cancel, progress, multiple=false)¶ Split a mesh with a collection of meshes.
Arguments:  meshes (list[rhino3dm.Mesh]) – Meshes to split with.
 tolerance (float) – A value for intersection tolerance. WARNING! Correct values are typically in the (10e8  10e4) range.An option is to use the document tolerance diminished by a few orders or magnitude.
 splitAtCoplanar (bool) – If false, coplanar areas will not be separated.
 textLog (TextLog) – A text log to write onto.
 cancel (CancellationToken) – A cancellation token.
 progress (IProgress<double>) – A progress reporter item. This can be null.
 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 mesh parts representing the split result, or null: when no mesh intersected, or if a cancel stopped the computation.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
split4
(thisMesh, meshes, tolerance, splitAtCoplanar, createNgons, textLog, cancel, progress, multiple=false)¶ Split a mesh with a collection of meshes.
Arguments:  meshes (list[rhino3dm.Mesh]) – Meshes to split with.
 tolerance (float) – A value for intersection tolerance. WARNING! Correct values are typically in the (10e8  10e4) range.An option is to use the document tolerance diminished by a few orders or magnitude.
 splitAtCoplanar (bool) – If false, coplanar areas will not be separated.
 createNgons (bool) – If true, creates ngons along the split ridge.
 textLog (TextLog) – A text log to write onto.
 cancel (CancellationToken) – A cancellation token.
 progress (IProgress<double>) – A progress reporter item. This can be null.
 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 mesh parts representing the split result, or null: when no mesh intersected, or if a cancel stopped the computation.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
getOutlines
(thisMesh, plane, multiple=false)¶ Constructs the outlines of a mesh projected against a plane.
Arguments:  plane (rhino3dm.Plane) – A plane to project against.
 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 polylines, or None on error.
Return type: rhino3dm.Polyline[]

RhinoCompute.Mesh.
getOutlines1
(thisMesh, viewport, multiple=false)¶ Constructs the outlines of a mesh. The projection information in the viewport is used to determine how the outlines are projected.
Arguments:  viewport (Display.RhinoViewport) – A viewport to determine projection direction.
 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 polylines, or None on error.
Return type: rhino3dm.Polyline[]

RhinoCompute.Mesh.
getOutlines2
(thisMesh, viewportInfo, plane, multiple=false)¶ Constructs the outlines of a mesh.
Arguments:  viewportInfo (ViewportInfo) – The viewport info that provides the outline direction.
 plane (rhino3dm.Plane) – Usually the view’s construction plane. If a parallel projection and view plane is parallel to this, then project the results to the 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 of polylines, or None on error.
Return type: rhino3dm.Polyline[]

RhinoCompute.Mesh.
getNakedEdges
(thisMesh, multiple=false)¶ Returns all edges of a mesh that are considered “naked” in the sense that the edge only has one face.
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 polylines, or None on error.
Return type: rhino3dm.Polyline[]

RhinoCompute.Mesh.
explodeAtUnweldedEdges
(thisMesh, multiple=false)¶ Explode the mesh into submeshes where a submesh is a collection of faces that are contained within a closed loop of “unwelded” edges. Unwelded edges are edges where the faces that share the edge have unique mesh vertexes (not mesh topology vertexes) at both ends of the edge.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of submeshes on success; None on error. If the count in the returned array is 1, then nothing happened and the output is essentially a copy of the input.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
closestPoint
(thisMesh, testPoint, multiple=false)¶ Gets the point on the mesh that is closest to a given test point.
Arguments:  testPoint (rhino3dm.Point3d) – Point to search for.
 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 mesh closest to testPoint, or Point3d.Unset on failure.
Return type: rhino3dm.Point3d

RhinoCompute.Mesh.
closestMeshPoint
(thisMesh, testPoint, maximumDistance, multiple=false)¶ Gets the point on the mesh that is closest to a given test point. Similar to the ClosestPoint function except this returns a MeshPoint class which includes extra information beyond just the location of the closest point.
Arguments:  testPoint (rhino3dm.Point3d) – The source of the search.
 maximumDistance (float) – Optional upper bound on the distance from test point to the mesh. If you are only interested in finding a point Q on the mesh when testPoint.DistanceTo(Q) < maximumDistance, then set maximumDistance to that value. This parameter is ignored if you pass 0.0 for a maximumDistance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: closest point information on success. None on failure.
Return type: MeshPoint

RhinoCompute.Mesh.
closestPoint1
(thisMesh, testPoint, maximumDistance, multiple=false)¶ Gets the point on the mesh that is closest to a given test point.
Arguments:  testPoint (rhino3dm.Point3d) – Point to search for.
 maximumDistance (float) – Optional upper bound on the distance from test point to the mesh. If you are only interested in finding a point Q on the mesh when testPoint.DistanceTo(Q) < maximumDistance, then set maximumDistance to that value. This parameter is ignored if you pass 0.0 for a maximumDistance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Index of face that the closest point lies on if successful. 1 if not successful; the value of pointOnMesh is undefined.
Return type: int

RhinoCompute.Mesh.
closestPoint2
(thisMesh, testPoint, maximumDistance, multiple=false)¶ Gets the point on the mesh that is closest to a given test point.
Arguments:  testPoint (rhino3dm.Point3d) – Point to search for.
 maximumDistance (float) – Optional upper bound on the distance from test point to the mesh. If you are only interested in finding a point Q on the mesh when testPoint.DistanceTo(Q) < maximumDistance, then set maximumDistance to that value. This parameter is ignored if you pass 0.0 for a maximumDistance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Index of face that the closest point lies on if successful. 1 if not successful; the value of pointOnMesh is undefined.
Return type: int

RhinoCompute.Mesh.
pointAt
(thisMesh, meshPoint, multiple=false)¶ Evaluate a mesh at a set of barycentric coordinates.
Arguments:  meshPoint (MeshPoint) – MeshPoint instance containing a valid Face Index and Barycentric coordinates.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A Point on the mesh or Point3d.Unset if the faceIndex is not valid or if the barycentric coordinates could not be evaluated.
Return type: rhino3dm.Point3d

RhinoCompute.Mesh.
pointAt1
(thisMesh, faceIndex, t0, t1, t2, t3, multiple=false)¶ Evaluates a mesh at a set of barycentric coordinates. Barycentric coordinates must be assigned in accordance with the rules as defined by MeshPoint.T.
Arguments:  faceIndex (int) – Index of triangle or quad to evaluate.
 t0 (float) – First barycentric coordinate.
 t1 (float) – Second barycentric coordinate.
 t2 (float) – Third barycentric coordinate.
 t3 (float) – Fourth barycentric coordinate. If the face is a triangle, this coordinate will be ignored.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A Point on the mesh or Point3d.Unset if the faceIndex is not valid or if the barycentric coordinates could not be evaluated.
Return type: rhino3dm.Point3d

RhinoCompute.Mesh.
normalAt
(thisMesh, meshPoint, multiple=false)¶ Evaluate a mesh normal at a set of barycentric coordinates.
Arguments:  meshPoint (MeshPoint) – MeshPoint instance containing a valid Face Index and Barycentric coordinates.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A Normal vector to the mesh or Vector3d.Unset if the faceIndex is not valid or if the barycentric coordinates could not be evaluated.
Return type: rhino3dm.Vector3d

RhinoCompute.Mesh.
normalAt1
(thisMesh, faceIndex, t0, t1, t2, t3, multiple=false)¶ Evaluate a mesh normal at a set of barycentric coordinates. Barycentric coordinates must be assigned in accordance with the rules as defined by MeshPoint.T.
Arguments:  faceIndex (int) – Index of triangle or quad to evaluate.
 t0 (float) – First barycentric coordinate.
 t1 (float) – Second barycentric coordinate.
 t2 (float) – Third barycentric coordinate.
 t3 (float) – Fourth barycentric coordinate. If the face is a triangle, this coordinate will be ignored.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A Normal vector to the mesh or Vector3d.Unset if the faceIndex is not valid or if the barycentric coordinates could not be evaluated.
Return type: rhino3dm.Vector3d

RhinoCompute.Mesh.
colorAt
(thisMesh, meshPoint, multiple=false)¶ Evaluate a mesh color at a set of barycentric coordinates.
Arguments:  meshPoint (MeshPoint) – MeshPoint instance containing a valid Face Index and Barycentric coordinates.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The interpolated vertex color on the mesh or Color.Transparent if the faceIndex is not valid, if the barycentric coordinates could not be evaluated, or if there are no colors defined on the mesh.
Return type: Color

RhinoCompute.Mesh.
colorAt1
(thisMesh, faceIndex, t0, t1, t2, t3, multiple=false)¶ Evaluate a mesh normal at a set of barycentric coordinates. Barycentric coordinates must be assigned in accordance with the rules as defined by MeshPoint.T.
Arguments:  faceIndex (int) – Index of triangle or quad to evaluate.
 t0 (float) – First barycentric coordinate.
 t1 (float) – Second barycentric coordinate.
 t2 (float) – Third barycentric coordinate.
 t3 (float) – Fourth barycentric coordinate. If the face is a triangle, this coordinate will be ignored.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The interpolated vertex color on the mesh or Color.Transparent if the faceIndex is not valid, if the barycentric coordinates could not be evaluated, or if there are no colors defined on the mesh.
Return type: Color

RhinoCompute.Mesh.
pullPointsToMesh
(thisMesh, points, multiple=false)¶ Pulls a collection of points to a mesh.
Arguments:  points (list[rhino3dm.Point3d]) – An array, a list or any enumerable set of points.
 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 points. This can be empty.
Return type: rhino3dm.Point3d[]

RhinoCompute.Mesh.
pullCurve
(thisMesh, curve, tolerance, multiple=false)¶ Gets a polyline approximation of the input curve and then moves its control points to the closest point on the mesh. Then it “connects the points” over edges so that a polyline on the mesh is formed.
Arguments:  curve (rhino3dm.Curve) – A curve to pull.
 tolerance (float) – A tolerance value.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A polyline curve, or None if none could be constructed.
Return type: PolylineCurve

RhinoCompute.Mesh.
splitWithProjectedPolylines
(thisMesh, curves, tolerance, multiple=false)¶ Splits a mesh by adding edges in correspondence with input polylines, and divides the mesh at partitioned areas. Polyline segments that are measured not to be on the mesh will be ignored.
Arguments:  curves (IEnumerable<PolylineCurve>) – An array, a list or any enumerable of polyline curves.
 tolerance (float) – A tolerance value.
 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 meshes, or None if no change would happen.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
splitWithProjectedPolylines1
(thisMesh, curves, tolerance, textLog, cancel, progress, multiple=false)¶ Splits a mesh by adding edges in correspondence with input polylines, and divides the mesh at partitioned areas. Polyline segments that are measured not to be on the mesh will be ignored.
Arguments:  curves (IEnumerable<PolylineCurve>) – An array, a list or any enumerable of polyline curves.
 tolerance (float) – A tolerance value.
 textLog (TextLog) – A text log, or null.
 cancel (CancellationToken) – A cancellation token to stop the computation at a given point.
 progress (IProgress<double>) – A progress reporter to inform the user about progress. The reported value is indicative.
 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 meshes, or None if no change would happen.
Return type: rhino3dm.Mesh[]

RhinoCompute.Mesh.
offset
(thisMesh, distance, multiple=false)¶ Makes a new mesh with vertices offset a distance in the opposite direction of the existing vertex normals. Same as Mesh.Offset(distance, false)
Arguments:  distance (float) – A distance value to use for offsetting.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new mesh on success, or None on failure.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
offset1
(thisMesh, distance, solidify, multiple=false)¶ Makes a new mesh with vertices offset a distance in the opposite direction of the existing vertex normals. Optionally, based on the value of solidify, adds the input mesh and a ribbon of faces along any naked edges. If solidify is False it acts exactly as the Offset(distance) function.
Arguments:  distance (float) – A distance value.
 solidify (bool) – True if the mesh should be solidified.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new mesh on success, or None on failure.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
offset2
(thisMesh, distance, solidify, direction, multiple=false)¶ Makes a new mesh with vertices offset a distance along the direction parameter. Optionally, based on the value of solidify, adds the input mesh and a ribbon of faces along any naked edges. If solidify is False it acts exactly as the Offset(distance) function.
Arguments:  distance (float) – A distance value.
 solidify (bool) – True if the mesh should be solidified.
 direction (rhino3dm.Vector3d) – Direction of offset for all vertices.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new mesh on success, or None on failure.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
offset3
(thisMesh, distance, solidify, direction, multiple=false)¶ Makes a new mesh with vertices offset a distance along the direction parameter. Optionally, based on the value of solidify, adds the input mesh and a ribbon of faces along any naked edges. If solidify is False it acts exactly as the Offset(distance) function. Returns list of wall faces, i.e. the faces that connect original and offset mesh when solidified.
Arguments:  distance (float) – A distance value.
 solidify (bool) – True if the mesh should be solidified.
 direction (rhino3dm.Vector3d) – Direction of offset for all vertices.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new mesh on success, or None on failure.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
collapseFacesByEdgeLength
(thisMesh, bGreaterThan, edgeLength, multiple=false)¶ Collapses multiple mesh faces, with greater/less than edge length, based on the principles found in Stan Melax’s mesh reduction PDF, see http://pomax.nihongoresources.com/downloads/PolygonReduction.pdf
Arguments:  bGreaterThan (bool) – Determines whether edge with lengths greater than or less than edgeLength are collapsed.
 edgeLength (float) – Length with which to compare to edge lengths.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Number of edges (faces) that were collapsed.
Return type: int

RhinoCompute.Mesh.
collapseFacesByArea
(thisMesh, lessThanArea, greaterThanArea, multiple=false)¶ Collapses multiple mesh faces, with areas less than LessThanArea and greater than GreaterThanArea, based on the principles found in Stan Melax’s mesh reduction PDF, see http://pomax.nihongoresources.com/downloads/PolygonReduction.pdf
Arguments:  lessThanArea (float) – Area in which faces are selected if their area is less than or equal to.
 greaterThanArea (float) – Area in which faces are selected if their area is greater than or equal to.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Number of faces that were collapsed in the process.
Return type: int

RhinoCompute.Mesh.
collapseFacesByByAspectRatio
(thisMesh, aspectRatio, multiple=false)¶ Collapses a multiple mesh faces, determined by face aspect ratio, based on criteria found in Stan Melax’s polygon reduction, see http://pomax.nihongoresources.com/downloads/PolygonReduction.pdf
Arguments:  aspectRatio (float) – Faces with an aspect ratio less than aspectRatio are considered as candidates.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Number of faces that were collapsed in the process.
Return type: int

RhinoCompute.Mesh.
getUnsafeLock
(thisMesh, writable, multiple=false)¶ Allows to obtain unsafe pointers to the underlying unmanaged data structures of the mesh.
Arguments:  writable (bool) – True if user will need to write onto the structure. False otherwise.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A lock that needs to be released.
Return type: MeshUnsafeLock

RhinoCompute.Mesh.
releaseUnsafeLock
(thisMesh, meshData, multiple=false)¶ Updates the Mesh data with the information that was stored via the .
Arguments:  meshData (MeshUnsafeLock) – The data that will be unlocked.
 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.Mesh.
withShutLining
(thisMesh, faceted, tolerance, curves, multiple=false)¶ Constructs new mesh from the current one, with shut lining applied to it.
Arguments:  faceted (bool) – Specifies whether the shutline is faceted.
 tolerance (float) – The tolerance of the shutline.
 curves (IEnumerable<ShutLiningCurveInfo>) – A collection of curve arguments.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new mesh with shutlining. Null on failure.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
withDisplacement
(thisMesh, displacement, multiple=false)¶ Constructs new mesh from the current one, with displacement applied to it.
Arguments:  displacement (MeshDisplacementInfo) – Information on mesh displacement.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new mesh with shutlining.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
withEdgeSoftening
(thisMesh, softeningRadius, chamfer, faceted, force, angleThreshold, multiple=false)¶ Constructs new mesh from the current one, with edge softening applied to it.
Arguments:  softeningRadius (float) – The softening radius.
 chamfer (bool) – Specifies whether to chamfer the edges.
 faceted (bool) – Specifies whether the edges are faceted.
 force (bool) – Specifies whether to soften edges despite too large a radius.
 angleThreshold (float) – Threshold angle (in degrees) which controls whether an edge is softened or not. The angle refers to the angles between the adjacent faces of an edge.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A new mesh with soft edges.
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
quadRemeshBrep
(brep, parameters, multiple=false)¶ Create QuadRemesh from a Brep Set Brep Face Mode by setting QuadRemeshParameters.PreserveMeshArrayEdgesMode
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
quadRemeshBrep1
(brep, parameters, guideCurves, multiple=false)¶ Create Quad Remesh from a Brep
Arguments:  brep (rhino3dm.Brep) – Set Brep Face Mode by setting QuadRemeshParameters.PreserveMeshArrayEdgesMode
 guideCurves (list[rhino3dm.Curve]) – A curve array used to influence mesh face layout The curves should touch the input mesh Set Guide Curve Influence by using QuadRemeshParameters.GuideCurveInfluence
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
quadRemeshBrepAsync
(brep, parameters, progress, cancelToken, multiple=false)¶ Quad remesh this Brep asynchronously.
Arguments:  brep (rhino3dm.Brep) – Set Brep Face Mode by setting QuadRemeshParameters.PreserveMeshArrayEdgesMode
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: Task<Mesh>

RhinoCompute.Mesh.
quadRemeshBrepAsync1
(brep, parameters, guideCurves, progress, cancelToken, multiple=false)¶ Quad remesh this Brep asynchronously.
Arguments:  brep (rhino3dm.Brep) – Set Brep Face Mode by setting QuadRemeshParameters.PreserveMeshArrayEdgesMode
 guideCurves (list[rhino3dm.Curve]) – A curve array used to influence mesh face layout The curves should touch the input mesh Set Guide Curve Influence by using QuadRemeshParameters.GuideCurveInfluence
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: Task<Mesh>

RhinoCompute.Mesh.
quadRemesh
(thisMesh, parameters, multiple=false)¶ Quad remesh this mesh.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
quadRemesh1
(thisMesh, parameters, guideCurves, multiple=false)¶ Quad remesh this mesh.
Arguments:  guideCurves (list[rhino3dm.Curve]) – A curve array used to influence mesh face layout The curves should touch the input mesh Set Guide Curve Influence by using QuadRemeshParameters.GuideCurveInfluence
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: rhino3dm.Mesh

RhinoCompute.Mesh.
quadRemeshAsync
(thisMesh, parameters, progress, cancelToken, multiple=false)¶ Quad remesh this mesh asynchronously.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: Task<Mesh>

RhinoCompute.Mesh.
quadRemeshAsync1
(thisMesh, parameters, guideCurves, progress, cancelToken, multiple=false)¶ Quad remesh this mesh asynchronously.
Arguments:  guideCurves (list[rhino3dm.Curve]) – A curve array used to influence mesh face layout The curves should touch the input mesh Set Guide Curve Influence by using QuadRemeshParameters.GuideCurveInfluence
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: Task<Mesh>

RhinoCompute.Mesh.
quadRemeshAsync2
(thisMesh, faceBlocks, parameters, guideCurves, progress, cancelToken, multiple=false)¶ Quad remesh this mesh asynchronously.
Arguments:  guideCurves (list[rhino3dm.Curve]) – A curve array used to influence mesh face layout The curves should touch the input mesh Set Guide Curve Influence by using QuadRemeshParameters.GuideCurveInfluence
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: Task<Mesh>

RhinoCompute.Mesh.
reduce
(thisMesh, desiredPolygonCount, allowDistortion, accuracy, normalizeSize, multiple=false)¶ Reduce polygon count
Arguments:  desiredPolygonCount (int) – desired or target number of faces
 allowDistortion (bool) – If True mesh appearance is not changed even if the target polygon count is not reached
 accuracy (int) – Integer from 1 to 10 telling how accurate reduction algorithm to use. Greater number gives more accurate results
 normalizeSize (bool) – If True mesh is fitted to an axis aligned unit cube until reduction is complete
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if mesh is successfully reduced and False if mesh could not be reduced for some reason.
Return type: bool

RhinoCompute.Mesh.
reduce1
(thisMesh, desiredPolygonCount, allowDistortion, accuracy, normalizeSize, threaded, multiple=false)¶ Reduce polygon count
Arguments:  desiredPolygonCount (int) – desired or target number of faces
 allowDistortion (bool) – If True mesh appearance is not changed even if the target polygon count is not reached
 accuracy (int) – Integer from 1 to 10 telling how accurate reduction algorithm to use. Greater number gives more accurate results
 normalizeSize (bool) – If True mesh is fitted to an axis aligned unit cube until reduction is complete
 threaded (bool) – If True then will run computation inside a worker thread and ignore any provided CancellationTokens and ProgressReporters. If False then will run on main thread.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if mesh is successfully reduced and False if mesh could not be reduced for some reason.
Return type: bool

RhinoCompute.Mesh.
reduce2
(thisMesh, desiredPolygonCount, allowDistortion, accuracy, normalizeSize, cancelToken, progress, multiple=false)¶ Reduce polygon count
Arguments:  desiredPolygonCount (int) – desired or target number of faces
 allowDistortion (bool) – If True mesh appearance is not changed even if the target polygon count is not reached
 accuracy (int) – Integer from 1 to 10 telling how accurate reduction algorithm to use. Greater number gives more accurate results
 normalizeSize (bool) – If True mesh is fitted to an axis aligned unit cube until reduction is complete
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if mesh is successfully reduced and False if mesh could not be reduced for some reason.
Return type: bool

RhinoCompute.Mesh.
reduce3
(thisMesh, desiredPolygonCount, allowDistortion, accuracy, normalizeSize, cancelToken, progress, threaded, multiple=false)¶ Reduce polygon count
Arguments:  desiredPolygonCount (int) – desired or target number of faces
 allowDistortion (bool) – If True mesh appearance is not changed even if the target polygon count is not reached
 accuracy (int) – Integer from 1 to 10 telling how accurate reduction algorithm to use. Greater number gives more accurate results
 normalizeSize (bool) – If True mesh is fitted to an axis aligned unit cube until reduction is complete
 threaded (bool) – If True then will run computation inside a worker thread and ignore any provided CancellationTokens and ProgressReporters. If False then will run on main thread.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if mesh is successfully reduced and False if mesh could not be reduced for some reason.
Return type: bool

RhinoCompute.Mesh.
reduce4
(thisMesh, parameters, multiple=false)¶ Reduce polygon count
Arguments:  parameters (ReduceMeshParameters) – Parameters
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if mesh is successfully reduced and False if mesh could not be reduced for some reason.
Return type: bool

RhinoCompute.Mesh.
reduce5
(thisMesh, parameters, threaded, multiple=false)¶ Reduce polygon count
Arguments:  parameters (ReduceMeshParameters) – Parameters
 threaded (bool) – If True then will run computation inside a worker thread and ignore any provided CancellationTokens and ProgressReporters. If False then will run on main thread.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if mesh is successfully reduced and False if mesh could not be reduced for some reason.
Return type: bool

RhinoCompute.Mesh.
computeThickness
(meshes, maximumThickness, multiple=false)¶ Compute thickness metrics for this mesh.
Arguments:  meshes (list[rhino3dm.Mesh]) – Meshes to include in thickness analysis.
 maximumThickness (float) – Maximum thickness to consider. Use as small a thickness as possible to speed up the solver.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of thickness measurements.
Return type: MeshThicknessMeasurement[]

RhinoCompute.Mesh.
computeThickness1
(meshes, maximumThickness, cancelToken, multiple=false)¶ Compute thickness metrics for this mesh.
Arguments:  meshes (list[rhino3dm.Mesh]) – Meshes to include in thickness analysis.
 maximumThickness (float) – Maximum thickness to consider. Use as small a thickness as possible to speed up the solver.
 cancelToken (System.Threading.CancellationToken) – Computation cancellation token.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of thickness measurements.
Return type: MeshThicknessMeasurement[]

RhinoCompute.Mesh.
computeThickness2
(meshes, maximumThickness, sharpAngle, cancelToken, multiple=false)¶ Compute thickness metrics for this mesh.
Arguments:  meshes (list[rhino3dm.Mesh]) – Meshes to include in thickness analysis.
 maximumThickness (float) – Maximum thickness to consider. Use as small a thickness as possible to speed up the solver.
 sharpAngle (float) – Sharpness angle in radians.
 cancelToken (System.Threading.CancellationToken) – Computation cancellation token.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array of thickness measurements.
Return type: MeshThicknessMeasurement[]

RhinoCompute.Mesh.
createContourCurves
(meshToContour, contourStart, contourEnd, interval, multiple=false)¶ Constructs contour curves for a mesh, sectioned along a linear axis.
Arguments:  meshToContour (rhino3dm.Mesh) – A mesh to contour.
 contourStart (rhino3dm.Point3d) – A start point of the contouring axis.
 contourEnd (rhino3dm.Point3d) – An end point of the contouring axis.
 interval (float) – An interval distance.
 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 curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Mesh.
createContourCurves1
(meshToContour, sectionPlane, multiple=false)¶ Constructs contour curves for a mesh, sectioned at a plane.
Arguments:  meshToContour (rhino3dm.Mesh) – A mesh to contour.
 sectionPlane (rhino3dm.Plane) – A cutting 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 of curves. This array can be empty.
Return type: rhino3dm.Curve[]