def main(): to_delete = [] rs.ProjectOsnaps(False) positive_object = rs.GetObject("select positive object", 16) negative_object = rs.GetObject("select negative object", 16) rs.HideObject(negative_object) polysurface, face = GetSubSurface("select tenon surface") to_delete.append(face) normal = rs.VectorUnitize(rs.SurfaceNormal(face, (0.5, 0.5))) plane = rs.PlaneFromNormal(rs.EvaluateSurface(face, 0.5, 0.5), normal) rs.ViewCPlane(plane=plane) rs.ProjectOsnaps(True) tenon_rects = rs.GetObjects(message="select tenon curves", filter=4) tenon_faces = [] for rect in tenon_rects: tenon_faces.append(rs.AddPlanarSrf(rect)[0]) rs.ShowObject(negative_object) rs.ProjectOsnaps(False) height_pt = rs.GetPoint("enter height point") # compule a vector normal to plane of the desired height extrude_vec_a = rs.EvaluateSurface(face, 0.5, 0.5) dist = rs.DistanceToPlane(plane, height_pt) extrude_vec_b = [dist * el for el in normal] extrude_vec_b = rs.VectorAdd(extrude_vec_a, extrude_vec_b) extrude_curve = rs.AddCurve((extrude_vec_a, extrude_vec_b)) to_delete.append(extrude_curve) tenons = [] for tenon_face in tenon_faces: tenon = rs.ExtrudeSurface(tenon_face, extrude_curve) tenons.append(tenon) rs.BooleanUnion([positive_object] + tenons, delete_input=False) rs.BooleanDifference([negative_object], tenons, delete_input=False) to_delete.append(positive_object) to_delete.append(negative_object) rs.DeleteObjects(to_delete) rs.DeleteObjects(tenon_faces) rs.DeleteObjects(tenons)
def EvaluateSurfaceParam(ref_srf, u_val, v_val): normalized = (u_val, v_val) parameter = rs.SurfaceParameter(ref_srf, normalized) print "Surface parameter: ", parameter return rs.EvaluateSurface(ref_srf, parameter[0], parameter[1])
def distance(self): Udomain = rs.SurfaceDomain(self.strsrf, 0) Vdomain = rs.SurfaceDomain(self.strsrf, 1) stepU = (Udomain[1] - Udomain[0]) / self.intu stepV = (Vdomain[1] - Vdomain[0]) / self.intv #PLOT POINTS ON SURFACE) for i in range(self.intu + 1): for j in range(self.intv + 1): #define u and v in terms of step values and i and j u = Udomain[0] + stepU * i v = Vdomain[0] + stepV * j point = rs.EvaluateSurface(self.strsrf, u, v) crvParam = rs.CurveClosestPoint(self.Crv, point) crvPoints = rs.EvaluateCurve(self.Crv, crvParam) if rs.Distance(point, crvPoints) < 400: self.dis[(i, j)] = rs.Distance(point, crvPoints) else: self.dis[(i, j)] = 1300 return self.dis
def uv_points_from_surface(srf, u_div, v_div): """Creates a nested uv point list from a surface. Parameters ---------- srf : System.Guid The surface identifier. u_div : int Number of poinst in u direction v_div : int Number of poinst in v direction Returns ------- list[list[:rhino:`Rhino.Geometry.Point3d`]] Points for every uv division. """ u_domain = rs.SurfaceDomain(srf, 0) v_domain = rs.SurfaceDomain(srf, 1) u_step = (u_domain[1] - u_domain[0]) / (u_div - 1) v_step = (v_domain[1] - v_domain[0]) / (v_div - 1) uv_points = [[None for _ in range(v_div)] for _ in range(u_div)] for u in range(u_div): for v in range(v_div): uv = (u_domain[0] + u_step * u, v_domain[0] + v_step * v) uv_points[u][v] = rs.EvaluateSurface(srf, uv[0], uv[1]) return uv_points
def addRail(obj): point1 = rs.EvaluateSurface(obj, 0, 0) vec = rs.CreateVector(0, 0, height) point2 = rs.CopyObject(point1, vec) line = rs.AddLine(point1, point2) if point2: rs.DeleteObjects(point2) return line
def uv_points_from_surface(srf, u_div, v_div): """Creates a nested uv point list from a surface. Parameters ---------- srf : Rhino surface The object identifier u_div : int Number of poinst in u direction v_div : int Number of poinst in v direction Returns ------- 2D array (nested list) Points for every uv division. """ u_domain = rs.SurfaceDomain(srf, 0) v_domain = rs.SurfaceDomain(srf, 1) u_step = (u_domain[1] - u_domain[0]) / (u_div - 1) v_step = (v_domain[1] - v_domain[0]) / (v_div - 1) uv_points = [[None for _ in range(v_div)] for _ in range(u_div)] for u in range(u_div): for v in range(v_div): uv = (u_domain[0] + u_step * u, v_domain[0] + v_step * v) uv_points[u][v] = rs.EvaluateSurface(srf, uv[0], uv[1]) return uv_points
def create_quad_mesh(srf,u_div,v_div): u_domain = rs.SurfaceDomain(srf, 0) v_domain = rs.SurfaceDomain(srf, 1) u = (u_domain[1] - u_domain[0]) / (u_div - 1) v = (v_domain[1] - v_domain[0]) / (v_div - 1) #pts = [[None for i in range(v_div)] for j in range(u_div)] mesh_pts = [] for i in xrange(u_div): for j in xrange(v_div): #pts[i][j] = rs.EvaluateSurface (srf, u_domain[0] + u * i, v_domain[0] + v * j) mesh_pts.append(rs.EvaluateSurface (srf, u_domain[0] + u * i, v_domain[0] + v * j)) faces = [] for i in xrange(u_div-1): for j in xrange(v_div-1): faces.append(((i*v_div)+j,((i+1)*v_div)+j,((i+1)*v_div)+j+1,(i*v_div)+j+1)) mesh = Mesh() for i,pt in enumerate(mesh_pts): mesh.add_vertex(str(i),{'x' : pt[0], 'y' : pt[1], 'z' : pt[2]}) for face in faces: mesh.add_face(face) return mesh
def RandomPtOnSrf(srf): if srf is None: print "Not a surface" return dom_u = rs.SurfaceDomain(srf, 0) dom_v = rs.SurfaceDomain(srf, 1) counter = 0 while True: pt_u = random.uniform(dom_u[0], dom_u[1]) pt_v = random.uniform(dom_v[0], dom_v[1]) pt = rs.EvaluateSurface(srf, pt_u, pt_v) if type(srf ) == rc.DocObjects.ObjectType.Extrusion: #If extrusion objects temp = rs.coercesurface(srf) testSrf = temp.ToBrep() else: testSrf = srf testPt = testSrf.ClosestPoint(pt) d = rs.Distance(testPt, pt) if d > rs.UnitAbsoluteTolerance(): return pt else: counter += 1
def ArrayPointsOnSurface(srf): ptList = [] # Get the number of rows rows = 51 # Get the number of columns cols = 51 # Get the domain of the surface u, v = rs.SurfaceDomain(srf, 0), rs.SurfaceDomain(srf, 1) # Turn off redrawing (faster) rs.EnableRedraw(False) # Add the points for i in range(rows): s = u[0] + ((u[1] - u[0]) / (rows - 1)) * i for j in range(cols): t = v[0] + ((v[1] - v[0]) / (cols - 1)) * j pt = rs.EvaluateSurface(srf, s, t) obj = rs.AddPoint(pt) # add the point ptList.append(obj) return ptList # Turn on redrawing rs.EnableRedraw(True)
def _point_in_surface(id): v = rh.BrepClosestPoint(id, rawu0) if v: return fromPt(v[0]) else: u, v = rh.SurfaceDomain(id, 0), rh.SurfaceDomain(id, 1) return rh.EvaluateSurface(id, u[0], v[0])
def ArrayPointsOnSurface(): # Get the surface object surface_id = rs.GetObject("Select surface", rs.filter.surface) if surface_id is None: return # Get the number of rows rows = rs.GetInteger("Number of rows", 2, 2) if rows is None: return # Get the number of columns columns = rs.GetInteger("Number of columns", 2, 2) if columns is None: return # Get the number of columns hairlength = rs.GetInteger("Length of Hair", 2, 2) if hairlength is None: return # Get the domain of the surface U = rs.SurfaceDomain(surface_id, 0) V = rs.SurfaceDomain(surface_id, 1) if U is None or V is None: return # Add the points for i in xrange(0, rows): param0 = U[0] + (((U[1] - U[0]) / (rows - 1)) * i) for j in xrange(0, columns): param1 = V[0] + (((V[1] - V[0]) / (columns - 1)) * j) point = rs.EvaluateSurface(surface_id, param0, param1) rs.AddPoint(point) arrNormal = rs.SurfaceNormal(surface_id, point) rs.AddLine(point, point - arrNormal * hairlength)
def remapping(mesh, surface_guid): """Remap a planar mesh in space uv on a spatial surface in space xyz. Parameters ---------- planar_mesh : Mesh A planar mesh to remap on the surface. spatial_surface : Rhino surface guid A spatial Rhino surface on which to remap the mesh. Returns ------- mesh: Mesh The remapped mesh. Raises ------ - """ for vkey in mesh.vertices(): u, v, w = mesh.vertex_coordinates(vkey) x, y, z = rs.EvaluateSurface(surface_guid, u, v) attr = mesh.vertex[vkey] attr['x'] = x attr['y'] = y attr['z'] = z return mesh
def faces(): surfaces = rs.GetObjects("select surfaces", filter=rs.filter.surface) points = [ rs.EvaluateSurface(surface, *rs.SurfaceParameter(surface, (0.5, 0.5))) for surface in surfaces ] x = reduce(lambda s, point: s + point.X, points, 0) / len(points) y = reduce(lambda s, point: s + point.Y, points, 0) / len(points) z = reduce(lambda s, point: s + point.Z, points, 0) / len(points) # find the center of the object mass_center = rs.AddPoint(x, y, z) extrude_curves = {} # find the appropriate extrusion curve with the lowest dot product for surface in surfaces: surface_center = rs.EvaluateSurface( surface, *rs.SurfaceParameter(surface, (0.5, 0.5))) center_vector = rs.VectorCreate(surface_center, mass_center) normals = [] normals.append( rs.SurfaceNormal(surface, rs.SurfaceParameter(surface, (0.5, 0.5)))) normals.append(-rs.SurfaceNormal( surface, rs.SurfaceParameter(surface, (0.5, 0.5)))) if (rs.VectorDotProduct(normals[0], center_vector) < rs.VectorDotProduct(normals[1], center_vector)): extrude_curve = normals[0] else: extrude_curve = normals[1] extrude_curve = rs.VectorUnitize(extrude_curve) extrude_curve = rs.VectorScale(extrude_curve, 0.25) extrude_curve = [ surface_center, rs.VectorAdd(surface_center, extrude_curve) ] extrude_curve = rs.AddCurve(extrude_curve) rs.ExtrudeSurface(surface, extrude_curve) rs.DeleteObject(extrude_curve) rs.DeleteObject(surface) rs.DeleteObject(mass_center)
def getSrfFrame(srf): domainU = rs.SurfaceDomain(srf, 0) domainV = rs.SurfaceDomain(srf, 1) u = domainU[1] / 2.0 v = domainV[1] / 2.0 point = rs.EvaluateSurface(srf, u, v) param = rs.SurfaceClosestPoint(srf, point) return rs.SurfaceFrame(srf, param)
def srfPtZPair(srf): domainU = rs.SurfaceDomain(srf, 0) domainV = rs.SurfaceDomain(srf, 1) u = domainU[1] / 2.0 v = domainV[1] / 2.0 point = rs.EvaluateSurface(srf, u, v) el = round(point.Z, 3) return [srf, el]
def get_dist(p): param = rs.SurfaceClosestPoint(surf, p) cp = rs.EvaluateSurface(surf, param[0], param[1]) #n = rs.SurfaceNormal(surf,param) #dv = map_values(param,axis.Domain[0],axis.Domain[1],0,1) #r = (1-dv)*start_radius + dv*end_radius d = rs.Distance(p, cp) - thickness / 2.0 return d
def evaluatedeviation( surface_id, threshold, sample ): r2point = rs.SurfaceClosestPoint(surface_id, sample)#Returns the UV parameter of the point on a surface that is closest to a test point. if not r2point: return r3point = rs.EvaluateSurface(surface_id, r2point[0], r2point[1])#evaluates the surface with UV parameters(U=[0] and v[1]) if not r3point: return deviation = rs.Distance(r3point, sample)#sample refers to the previous point if deviation<=threshold: return#if deviation is less than threshold do nothing rs.AddPoint(sample)#if deviation is more than threshold add point rs.AddLine(sample, r3point)#if deviation is more than threshold add line
def makeBrep(srf): point1 = rs.EvaluateSurface(srf, 0, 0) vec = rs.CreateVector(0, 0, height) point2 = rs.CopyObject(point1, vec) line = rs.AddLine(point1, point2) brep = rs.ExtrudeSurface(srf, line) if point2: rs.DeleteObjects(point2) if line: rs.DeleteObjects(line) return brep
def RecursiveSphere(surface, generation): if generation > 0: domainU = rs.SurfaceDomain(surface, 0) domainV = rs.SurfaceDomain(surface, 1) randomU1 = random.uniform(domainU[0], domainU[1]) randomV1 = random.uniform(domainV[0], domainV[1]) randomU2 = random.uniform(domainU[0], domainU[1]) randomV2 = random.uniform(domainV[0], domainV[1]) randomU3 = random.uniform(domainU[0], domainU[1]) randomV3 = random.uniform(domainV[0], domainV[1]) point1 = rs.EvaluateSurface(surface, randomU1, randomV1) point2 = rs.EvaluateSurface(surface, randomU2, randomV2) point3 = rs.EvaluateSurface(surface, randomU3, randomV3) newsphere1 = NewSphere(point, 1000 / (4 - generation)) newsphere2 = NewSphere(point, 1000 / (4 - generation)) newsphere3 = NewSphere(point, 1000 / (4 - generation)) RecursiveSphere(newsphere1, generation - 1) RecursiveSphere(newsphere2, generation - 1) RecursiveSphere(newsphere3, generation - 1)
def moveSrftoZ(srf): domainU = rs.SurfaceDomain(srf, 0) domainV = rs.SurfaceDomain(srf, 1) u = domainU[1] / 2.0 v = domainV[1] / 2.0 point = rs.EvaluateSurface(srf, u, v) # vec = [0, 0, point.Z] # vec = rs.VectorReverse(vec) # vec = [0,0,vec.Z] rs.MoveObjects(srf, rs.VectorReverse([0, 0, point.Z]))
def inter_S_B(s, div, Lis, br): udiv = div vdiv = div srf = rs.AddSphere((s[1]), ((s[2]) * 2.5)) u = rs.SurfaceDomain(srf, 0) v = rs.SurfaceDomain(srf, 1) pts = [] for i in range(0, udiv + 1, 1): for j in range(0, vdiv + 1, 1): pt = (i / udiv, j / vdiv, 0) srfP = rs.SurfaceParameter(srf, pt) newpt = rs.EvaluateSurface(srf, srfP[0], srfP[1]) pts.append(rs.AddPoint(newpt)) lig = [] lid = [] for p in pts: lig.append(rs.AddLine((Lis[0])[1], p)) lid.append(rs.AddLine((Lis[0])[2], p)) ig = [] id = [] for i in lig: for u in br: if type(rs.CurveBrepIntersect(i, (u[0]))) == tuple: ig.append((rs.CurveBrepIntersect(i, (u[0]))) + (u[1], )) else: ig.append((rs.CurveBrepIntersect(i, (u[0])))) for i in lid: for u in br: if type(rs.CurveBrepIntersect(i, (u[0]))) == tuple: id.append((rs.CurveBrepIntersect(i, (u[0]))) + (u[1], )) else: id.append((rs.CurveBrepIntersect(i, (u[0])))) if len(id) == 0: self.AddRuntimeMessage( war, "it doesn't seem like there's any geometries connected") raise Exception('noGeo') intg = 0 for i in ig: if type(i) is tuple: intg += (1 * (i[-1])) intd = 0 for i in id: if type(i) is tuple: intd += (1 * (i[-1])) difg = len(ig) - intg if difg <= 0: difg = 0.1 difd = len(id) - intd if difd <= 0: difd = 0.1 return [(((math.log10(difg * 100 / len(ig))) * 35.3) - 70.6), (((math.log10(difd * 100 / len(id))) * 35.3) - 70.6)]
def descent(self, points=None): """""" if not points: points = self.heightfield() tol = rs.UnitAbsoluteTolerance() descent = [] if rs.IsPolysurface(self.guid): rs.EnableRedraw(False) faces = {} for p0 in points: p = p0[:] p[2] -= 2 * tol bcp = rs.BrepClosestPoint(self.guid, p) uv = bcp[1] index = bcp[2][1] try: face = faces[index] except (TypeError, IndexError): face = rs.ExtractSurface(self.guid, index, True) faces[index] = face p1 = rs.EvaluateSurface(face, uv[0], uv[1]) vector = [p1[_] - p0[_] for _ in range(3)] descent.append((p0, vector)) rs.DeleteObjects(faces.values()) rs.EnableRedraw(True) elif rs.IsSurface(self.guid): for p0 in points: p = p0[:] p[2] -= 2 * tol bcp = rs.BrepClosestPoint(self.guid, p) uv = bcp[1] p1 = rs.EvaluateSurface(self.guid, uv[0], uv[1]) vector = [p1[_] - p0[_] for _ in range(3)] descent.append((p0, vector)) else: raise RhinoSurfaceError('object is not a surface') return descent
def evaluatedeviation( surface_id, threshold, sample ): r2point = rs.SurfaceClosestPoint(surface_id, sample) if not r2point: return r3point = rs.EvaluateSurface(surface_id, r2point[0], r2point[1]) if not r3point: return deviation = rs.Distance(r3point, sample) if deviation<=threshold: return rs.AddPoint(sample) rs.AddLine(sample, r3point)
def isoframe(srf, uv, spacing, vec): points = intervalpts(srf, uv, spacing) sweeps = [] for i in points: point = rs.EvaluateSurface(srf, i[0], i[1]) parameter = rs.SurfaceClosestPoint(srf, point) plane = rs.SurfaceFrame(srf, parameter) crv = rs.ExtractIsoCurve(srf, parameter, flipBool(uv)) direction = rs.CurveTangent(crv, 0) newplane = rs.PlaneFromNormal(point, direction, plane.ZAxis) sweeps.append(sweepSec(crv, newplane, vec)) return sweeps
def heightfield(self, density=10, over_space=True): """""" try: du, dv = density except TypeError: du = density dv = density du = int(du) dv = int(dv) xyz = [] rs.EnableRedraw(False) if rs.IsPolysurface(self.guid): faces = rs.ExplodePolysurfaces(self.guid) elif rs.IsSurface(self.guid): faces = [self.guid] else: raise RhinoSurfaceError('object is not a surface') if over_space: for guid in faces: face = RhinoSurface(guid) uv = face.space(density) for u, v in uv: xyz.append(list(rs.EvaluateSurface(face.guid, u, v))) else: for guid in faces: bbox = rs.BoundingBox(guid) xmin = bbox[0][0] xmax = bbox[1][0] ymin = bbox[0][1] ymax = bbox[3][1] xstep = 1.0 * (xmax - xmin) / (du - 1) ystep = 1.0 * (ymax - ymin) / (dv - 1) seeds = [] for i in xrange(du): for j in xrange(dv): seed = xmin + i * xstep, ymin + j * ystep, 0 seeds.append(seed) points = map(list, rs.ProjectPointToSurface(seeds, guid, [0, 0, 1])) xyz += points if len(faces) > 1: rs.DeleteObjects(faces) rs.EnableRedraw(True) return xyz
def XYZ_To_UVW(srf_id, pXYZ): pUVW = [] for point in pXYZ: uvClosest = rs.SurfaceClosestPoint(srf_id, point) ptClosest = rs.EvaluateSurface(srf_id, uvClosest) srfNormal = rs.SurfaceNormal(srf_id, uvClosest) pPositive = rs.PointAdd(ptClosest, srfNormal) pNegative = rs.PointSubtract(ptClosest, srfNormal) fDistance = rs.Distance(ptClosest, point) if rs.Distance(point,pPositive) > rs.Distance(point, pNegative): fDistance = -fDistance pUVW.append( (uvClosest[0], uvClosest[1], fDistance) ) return pUVW
def ConvertToUVW(srf_id, xyz_points): uvw_points = [] for point in xyz_points: Suv = rs.SurfaceClosestPoint(srf_id, point) Sxyz = rs.EvaluateSurface(srf_id, Suv) Snormal = rs.SurfaceNormal(srf_id, Suv) dirPos = rs.PointAdd(Sxyz, Snormal) dirNeg = rs.PointSubtract(Sxyz, Snormal) Sdist = rs.Distance(Sxyz, point) if rs.Distance(point, dirPos) > rs.Distance(point, dirNeg): Sdist = -Sdist uvw_points.append((Suv(0), Suv(1), Sdist)) return uvw_points
def RandomPtOnSrf(srf): if srf is None: print "Not a surface" return dom_u = rs.SurfaceDomain(srf, 0) dom_v = rs.SurfaceDomain(srf, 1) while True: pt_u = random.uniform(dom_u[0], dom_u[1]) pt_v = random.uniform(dom_v[0], dom_v[1]) pt = rs.EvaluateSurface(srf, pt_u, pt_v) if rs.IsPointOnSurface(srf, pt): return pt
def RecurseSurface(srf_id, u0, u1, v0, v1): A = rs.EvaluateSurface(srf_id, (u0, v0)) B = rs.EvaluateSurface(srf_id, (u1, v0)) C = rs.EvaluateSurface(srf_id, (u1, v1)) D = rs.EvaluateSurface(srf_id, (u0, v1)) gauss = SurfaceCurvature(srf_id, u0, u1, v0, v1) diag = rs.Distance(A, C) factor = abs(diag * gauss) print "Gauss:", round(gauss, 4), print " Diagonal:", round(diag, 2), print " Factor:", round(factor, 3) if factor < 10: rs.AddCurve((A, B, C, D, A), 3) else: um = u0 + 0.5 * (u1 - u0) vm = v0 + 0.5 * (v1 - v0) RecurseSurface(srf_id, u0, um, v0, vm) RecurseSurface(srf_id, um, u1, v0, vm) RecurseSurface(srf_id, u0, um, vm, v1) RecurseSurface(srf_id, um, u1, vm, v1)
def point_uv_to_xyz(self, uv): """Return the XYZ point from the inverse mapping of a UV point based on the UV parameterisation of the surface. Parameters ---------- uv : list (u, v, 0) coordinates. Returns ------- list The (x, y, z) coordinates of the inverse-mapped point. """ return tuple(rs.EvaluateSurface(self.guid, *uv))