def curvature(self, points=None): """""" if not points: points = self.heightfield() curvature = [] if rs.IsPolysurface(self.guid): rs.EnableRedraw(False) faces = {} for point in points: bcp = rs.BrepClosestPoint(self.guid, point) uv = bcp[1] index = bcp[2][1] try: face = faces[index] except (TypeError, IndexError): face = rs.ExtractSurface(self.guid, index, True) faces[index] = face props = rs.SurfaceCurvature(face, uv) curvature.append((point, (props[1], props[3], props[5]))) rs.DeleteObjects(faces.values()) rs.EnableRedraw(False) elif rs.IsSurface(self.guid): for point in points: bcp = rs.BrepClosestPoint(self.guid, point) uv = bcp[1] props = rs.SurfaceCurvature(self.guid, uv) curvature.append((point, (props[1], props[3], props[5]))) else: raise RhinoSurfaceError('object is not a surface') return curvature
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 projectPolyline(vertices, surface): #new list for new polyline vertices polyline = [] #step through list and get the closest on the BREP (will work for trimmed srf) for vertex in vertices: pt = rs.BrepClosestPoint(surface, vertex) #if we have a closest point, append to the new list, if not just move on if pt: polyline.append(pt[0]) return polyline
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 callback(k, args): if k%10 == 0: rs.Prompt(str(k)) # constrain all non-fixed to a surface for key, attr in mesh.vertices(data=True): if key in fixed: continue srf = attr['srf'] x, y, z = rs.BrepClosestPoint(srf,mesh.vertex_coordinates(key))[0] attr['x'] = x attr['y'] = y attr['z'] = z conduit.redraw()
def convert_to_uv_space(srf,pts): tol = rs.UnitAbsoluteTolerance() uv_pts = [] for pt in pts: #need for issues in cases points lie on a seam if not rs.IsPointOnSurface (srf, pt): pts_dis = [] pts_dis.append((pt[0]+tol,pt[1],pt[2])) pts_dis.append((pt[0]-tol,pt[1],pt[2])) pts_dis.append((pt[0],pt[1]+tol,pt[2])) pts_dis.append((pt[0],pt[1]-tol,pt[2])) pts_dis.append((pt[0],pt[1],pt[2]+tol)) pts_dis.append((pt[0],pt[1],pt[2]-tol)) for pt_dis in pts_dis: data= rs.BrepClosestPoint(srf,pt_dis) if rs.IsPointOnSurface(srf,data[0]): pt = data[0] break u,v = rs.SurfaceClosestPoint(srf,pt) uv_pts.append((u,v,0)) #rs.AddTextDot(str(data[2] ) + " / " + str(rs.IsPointOnSurface (srf, pt)) + " / " + str(u) + " / " + str(v),pt) return uv_pts
def callback(k, args): if k % 10 == 0: rs.Prompt(str(k)) # constrain all non-fixed to a surface or guide curves for key, attr in mesh.vertices(data=True): if attr['fixed']: continue if attr['srf']: srf = attr['srf'] x, y, z = rs.BrepClosestPoint(srf, mesh.vertex_coordinates(key))[0] attr['x'] = x attr['y'] = y attr['z'] = z elif attr['crv']: crv = attr['crv'] x, y, z = rs.PointClosestObject(mesh.vertex_coordinates(key), [crv])[1] attr['x'] = x attr['y'] = y attr['z'] = z conduit.redraw()
def WhoFramedTheSurface(): surface_id = rs.GetObject("Surface to frame", 8, True, True) if not surface_id: return count = rs.GetInteger("Number of iterations per direction", 20, 2) if not count: return udomain = rs.SurfaceDomain(surface_id, 0) vdomain = rs.SurfaceDomain(surface_id, 1) ustep = (udomain[1] - udomain[0]) / count vstep = (vdomain[1] - vdomain[0]) / count rs.EnableRedraw(False) u = udomain[0] while u <= udomain[1]: v = vdomain[0] while v <= vdomain[1]: pt = rs.EvaluateSurface(surface_id, u, v) if rs.Distance(pt, rs.BrepClosestPoint(surface_id, pt)[0]) < 0.1: srf_frame = rs.SurfaceFrame(surface_id, [u, v]) rs.AddPlaneSurface(srf_frame, 1.0, 1.0) v += vstep u += ustep rs.EnableRedraw(True)
def projectpolyline(vertices, surface_id): polyline = [] for vertex in vertices: pt = rs.BrepClosestPoint(surface_id, vertex) if pt: polyline.append(pt[0]) return polyline
def ProjectCurvesToTIN(): try: crvs = rs.GetObjects(message="Select curves to project", filter=4, group=True, preselect=False, select=False, objects=None, minimum_count=1, maximum_count=0, custom_filter=None) if not crvs: return obj = rs.GetObject("Select the TIN to project onto", 8 | 16 | 32) if not obj: return isMesh = rs.IsMesh(obj) zUpList = [] zDownList = [] rs.EnableRedraw(False) # Convert Mesh to Nurbs for ShootRay compatibility if isMesh == True: srf = rs.MeshToNurb(obj) if isMesh == False: srf = obj # Shoot ray from each grip point and move grips to reflection point for crv in crvs: rs.EnableObjectGrips(crv) grips = rs.ObjectGripLocations(crv) for grip in grips: zUp = rs.ShootRay(srf, grip, (0, 0, 1), 1) # if zUp != None: if zUp == None: zUpList.append(False) else: zUpList.append(zUp[1]) zDown = rs.ShootRay(srf, grip, (0, 0, -1), 1) # if zDown != None: if zDown == None: zDownList.append(False) else: zDownList.append(zDown[1]) rs.CopyObject(crv) # Copy Existing curve # Find the right list to iterate over and insert existing points for any falses if all(x is False for x in zUpList): falseindex = [i for i, val in enumerate(zDownList) if not val] for i in falseindex: # Replace False with existing grip location and closest Z value closestPt = rs.BrepClosestPoint(srf, grips[i]) zDownList[i] = (grips[i].X, grips[i].Y, closestPt[0].Z) rs.ObjectGripLocations(crv, zDownList) else: falseindex = [i for i, val in enumerate(zUpList) if not val] for i in falseindex: # Replace False with existing grip location and closest Z value closestPt = rs.BrepClosestPoint(srf, grips[i]) zUpList[i] = (grips[i].X, grips[i].Y, closestPt[0].Z) rs.ObjectGripLocations(crv, zUpList) del zDownList[:] del zUpList[:] rs.EnableObjectGrips(crv, False) if isMesh == True: rs.DeleteObject(srf) rs.EnableRedraw(True) except: rs.EnableObjectGrips(crv, False) rs.DeleteObject(crv) rs.EnableRedraw(True) print("Failed to project curves") return
def remesh_ani(srf,mesh,trg_len_min,trg_len_max,gauss_min,gauss_max, tol=0.1, divergence=0.01, kmax=100, target_start=None, kmax_approach=None, verbose=False, allow_boundary=False, ufunc=None): """Remesh until all edges have a specified target length. This involves three operations: * split edges that are shorter than a minimum length, * collapse edges that are longer than a maximum length, * swap edges if this improves the valency error. The minimum and maximum lengths are calculated based on a desired target length: Parameters: target (float): The target length. tol (float): Length deviation tolerance. Defaults to `0.1` kmax (int): The number of iterations. verbose (bool): Print feedback messages, if True. Returns: None """ if verbose: print print target reduce = 0.63 max_dis = 0.03 min_dis = 0.03 boundary = set(mesh.vertices_on_boundary()) count = 0 kmax_approach = float(kmax_approach) for k in xrange(kmax): if verbose: print print k count += 1 # split if count == 1: visited = set() for u, v in mesh.edges(): # is this correct? if u in visited or v in visited: continue # pt = mesh.edge_midpoint(u,v) # para = rs.SurfaceClosestPoint(srf,pt) # data = rs.SurfaceCurvature(srf,para) # # gauss = abs(data[7]+0.000000000000000000001) # if gauss == 0.0: # gauss = 0.00000000000001 # elif gauss > 1.0: # gauss = 1 # trg_len = (1-(gauss/1)) * (trg_len_max - trg_len_min) + trg_len_min # # # lmin = (1 - tol) * (4.0 / 5.0) * trg_len # lmax = (1 + tol) * (4.0 / 3.0) * trg_len # fac = float(target_start/trg_len) # # if k <= kmax_approach and 1==1: # scale_val = fac*(1.0-k/kmax_approach) # dlmin = lmin*scale_val # dlmax = lmax*scale_val # else: # dlmin = 0 # dlmax = 0 # # if k>200: # rs.AddTextDot(round(gauss,3),pt) l = mesh.edge_length(u, v) pt = mesh.edge_midpoint(u,v) pt2 = rs.BrepClosestPoint (srf, pt)[0] dis = distance(pt,pt2) if dis > max_dis: trg_len = l * reduce else: trg_len = l lmin = (1 - tol) * (4.0 / 5.0) * trg_len lmax = (1 + tol) * (4.0 / 3.0) * trg_len fac = float(target_start/trg_len) if k <= kmax_approach and 1==1: scale_val = fac*(1.0-k/kmax_approach) dlmin = lmin*scale_val dlmax = lmax*scale_val else: dlmin = 0 dlmax = 0 # if l <= lmax: # continue if l <= lmax+dlmax: continue if verbose: print 'split edge: {0} - {1}'.format(u, v) split_edge(mesh, u, v, allow_boundary=allow_boundary) visited.add(u) visited.add(v) # collapse elif count == 2: visited = set() for u, v in mesh.edges(): # is this correct? if u in visited or v in visited: continue # pt = mesh.edge_midpoint(u,v) # para = rs.SurfaceClosestPoint(srf,pt) # data = rs.SurfaceCurvature(srf,para) # # gauss = abs(data[7]+0.000000000000000000001) # if gauss == 0.0: # gauss = 0.00000000000001 # elif gauss > 1.0: # gauss = 1 # trg_len = (1-(gauss/1)) * (trg_len_max - trg_len_min) + trg_len_min # # # lmin = (1 - tol) * (4.0 / 5.0) * trg_len # lmax = (1 + tol) * (4.0 / 3.0) * trg_len # fac = float(target_start/trg_len) # # if k <= kmax_approach and 1==1: # scale_val = fac*(1.0-k/kmax_approach) # dlmin = lmin*scale_val # dlmax = lmax*scale_val # else: # dlmin = 0 # dlmax = 0 # # # if k>200: # rs.AddTextDot(round(gauss,3),pt) l = mesh.edge_length(u, v) pt = mesh.edge_midpoint(u,v) pt2 = rs.BrepClosestPoint (srf, pt)[0] dis = distance(pt,pt2) if dis < min_dis: trg_len = l else: trg_len = l lmin = (1 - tol) * (4.0 / 5.0) * trg_len lmax = (1 + tol) * (4.0 / 3.0) * trg_len fac = float(target_start/trg_len) if k <= kmax_approach and 1==1: scale_val = fac*(1.0-k/kmax_approach) dlmin = lmin*scale_val dlmax = lmax*scale_val else: dlmin = 0 dlmax = 0 # if l >= lmin: # continue if l >= lmin-dlmin: continue if verbose: print 'collapse edge: {0} - {1}'.format(u, v) collapse_edge(mesh, u, v) visited.add(u) visited.add(v) for nbr in mesh.halfedge[u]: visited.add(nbr) # swap elif count == 3: visited = set() for u, v in mesh.edges(): if u in visited or v in visited: continue f1 = mesh.halfedge[u][v] f2 = mesh.halfedge[v][u] if f1 is None or f2 is None: continue v1 = mesh.face[f1][v] v2 = mesh.face[f2][u] valency1 = mesh.vertex_degree(u) valency2 = mesh.vertex_degree(v) valency3 = mesh.vertex_degree(v1) valency4 = mesh.vertex_degree(v2) if u in boundary: valency1 += 2 if v in boundary: valency2 += 2 if v1 in boundary: valency3 += 2 if v2 in boundary: valency4 += 2 current_error = abs(valency1 - 6) + abs(valency2 - 6) + abs(valency3 - 6) + abs(valency4 - 6) flipped_error = abs(valency1 - 7) + abs(valency2 - 7) + abs(valency3 - 5) + abs(valency4 - 5) if current_error <= flipped_error: continue if verbose: print 'swap edge: {0} - {1}'.format(u, v) swap_edge(mesh, u, v) visited.add(u) visited.add(v) # count else: count = 0 # if not has_split and not has_collapsed and not has_swapped and dlmin == 0: # termin += 1 # if termin > 10: # print "break asdddddddddddddddddddddddddddddddddddddddddddddddddddddddd" # break # else: # termin = 0 # smoothen mesh_smooth_on_local_plane(mesh,k=1,d=0.2,fixed=boundary) if ufunc: ufunc(mesh,k)
def main(): atr = [] ManV = [] totrev = [] rdm = [] for iS in range(len(Sources)): Closest_pt_on_sphere = (rs.BrepClosestPoint((rs.AddSphere( (Sources[iS])[1], (Sources[iS])[2])), Lp)) Si.append("S_{}".format(iS + 1)) Distance = (rs.Distance(Lp, (Closest_pt_on_sphere[0]))) SDi.append(DecDist(Lh, Distance)) spthi = (Sources[iS][0]).replace('\\', '/') PathList = (spthi).split() PercentS = ("\ ").join(PathList) SPa.append(PercentS) if Lock == True: SPa[iS] = '/i/NoSource_LOCKED' self.AddRuntimeMessage( rem, 'Your Sketch is locked, no sound until you unlock ;)') self.Message = "EsquisSons is locked" SPan.append(pan(Listener, (Sources[iS])[1])) Sint.append(inter_S_B((Sources[iS]), 3, Listener, Geometry)) if Reverb_on == True: Srev = (rev(Geometry, Listener, (Sources[iS]), 50)) Srev1.append((Srev)[0] * Factor) Srev2.append((Srev)[1] * Factor) Str.append((Srev)[2]) atr.append((Srev)[2]) totrev.append(Srev[0] + Srev[1]) ManV.append(volm(Sources[iS])) rdm.append(Sources[iS][4]) if Reverb_on is True: for i in range(0, len(atr)): RTsource.append(round(atr[i] / 1000, 1)) Revinfo.append( str(round(atr[i] / 1000, 1)) + 'sec // mix : ' + str(totrev[i] * Factor) + '%') else: RTsource.append('No RT: Reverb is disabled') Revinfo.append('No infos: Reverb is disabled') io = int((len(Sources) - 1)) i_msg = [] iosc = [] for i in range(10): try: pathold = oldpath[i] except IndexError: oldpath.insert(i, ["empty"]) except NameError: oldpath = [] oldpath.append(["empty"]) iport = (57100 + i) iosc.append(OSC.OSCClient()) iosc[i].connect(("127.0.0.1", iport)) i_msg.append(OSC.OSCMessage()) if i <= io: i_msg[i].append(SDi[i][0]) i_msg[i].append(SDi[i][1]) i_msg[i].append(SPa[i]) i_msg[i].append(SPan[i]) if Lock is True: i_msg[i].append(0) else: if ((i_msg[i])[2]) != (oldpath[i]): i_msg[i].append(1) else: i_msg[i].append(2) i_msg[i].append(Sint[i]) try: i_msg[i].append(Srev1[i]) i_msg[i].append(Srev2[i]) i_msg[i].append(Str[i]) except: i_msg[i].append(0) i_msg[i].append(0) i_msg[i].append(0) i_msg[i].append(ManV[i]) i_msg[i].append(rdm[i]) iosc[i].send(i_msg[i]) oldpath[i] = SPa[i] else: i_msg[i].append(-127) i_msg[i].append(0) i_msg[i].append('/i/NoSource') i_msg[i].append(0) i_msg[i].append(0) i_msg[i].append(0) i_msg[i].append(0) i_msg[i].append(0) i_msg[i].append(0) i_msg[i].append(0) i_msg[i].append(0) try: iosc[i].send(i_msg[i]) except: self.AddRuntimeMessage( ero, 'Connexion Failed, please ensure APP is open (use launcher) then reset the engine (with lock/unlock)' ) self.Message = 'Connexion Failure' print "message, source {} : {}".format(i, i_msg[i])
def rev(Ge, Lis, Src, div): udiv = div vdiv = div Pt_L = Lis[0][0] srf = [] FirstRay = [] SecondRay = [] First_RefPoint = [] drawray = [] Reverb = [] for i in Ge: srf.append(i[0]) sph = (rs.AddSphere(Src[1], Src[2])) Src_pt = (Src[1]) u = rs.SurfaceDomain(sph, 0) v = rs.SurfaceDomain(sph, 1) pts = [] for i in range(0, udiv + 1, 1): for j in range(0, vdiv + 1, 1): pt = (i / udiv, j / vdiv, 0) sphP = rs.SurfaceParameter(sph, pt) newpt = rs.EvaluateSurface(sph, sphP[0], sphP[1]) pts.append(rs.AddPoint(newpt)) Dir = [] for p in pts: Dir.append(rs.VectorCreate(p, Src_pt)) Reflexion = [] for d in Dir: Reflexion.append(rs.ShootRay(srf, Src_pt, d, reflections=4)) Project = [] for v in Reflexion: Cl_Pt = [] Ray_v = [] try: Project.append(v[1]) Ray_v.append(rs.AddPolyline(v)) except: pass for u in Ray_v: pt_on = rs.CurveClosestPoint(u, Pt_L) cl = rs.EvaluateCurve(u, pt_on) Dicl = (rs.Distance(Pt_L, cl)) if Dicl <= ((Lis[0])[3]): try: First_RefPoint = rs.CurveClosestPoint(u, v[1]) Second_RefPoint = rs.CurveClosestPoint(u, v[2]) endc = ((rs.CurveClosestPoint( u, (rs.CurveEndPoint(u))))) if pt_on > Second_RefPoint: SecondRay.append(pt_on / endc * (rs.CurveLength(u))) drawray.append(u) elif pt_on > First_RefPoint: FirstRay.append(pt_on / endc * (rs.CurveLength(u))) except: pass box = rs.AddBox(rs.BoundingBox(Project)) boxarea = round((rs.SurfaceArea(box)[0]), 2) Cube = [] Cube.append(box) surfacetorev = [] for s in srf: ptons = [] for p in Project: if rs.Distance((rs.BrepClosestPoint(s, p)[0]), p) < 0.1: ptons.append(p) if len(ptons) > 0: surfacetorev.append(s) surfaceab = [] for x in Ge: if x[0] in surfacetorev: surfaceab.append(x[2]) SrfandAb = [(surfacetorev[i], surfaceab[i]) for i in range(0, len(surfacetorev))] bbox = box box = round(((rs.SurfaceVolume(box))[0]), 1) srfvol = [] srfvolex = [] absvol = [] srfarea = [] srfrev = [] areaabs = [] surfacecenter = [] absidx = [] absvoltot = [] for i in SrfandAb: if rs.SurfaceVolume(i[0]) > 0: srfvol.append(i[0]) absvol.append(i[1]) else: srfarea.append((rs.SurfaceArea(i[0]))[0]) absvoltot.append(i[1]) srfvolex = rs.ExplodePolysurfaces(srfvol) for i in srfvolex: ptonsrf = [] usefulsrf = [] for p in Project: if rs.Distance((rs.BrepClosestPoint(i, p)[0]), p) < 0.01: ptonsrf.append(p) usefulsrf.append(i) if len(ptonsrf) > 0: srfarea.append(rs.SurfaceArea(i)[0]) srfrev.append(i) for i in srfrev: surfacecenter.append(rs.SurfaceAreaCentroid(i)[0]) for b in srfvol: for i in surfacecenter: if rs.Distance((rs.BrepClosestPoint(b, i)[0]), i) < 0.01: absidx.append(srfvol.index(b)) for i in absidx: absvoltot.append(absvol[i]) try: areaabs = [ srfarea[i] * (absvoltot[i]) for i in range(0, len(absvoltot)) ] except: raise Exception( 'One source must be too deep inside a geometry, try to get it out or to move it a little bit !' ) Builtareaabs = 0 for i in areaabs: Builtareaabs += i BuiltArea = 0 for i in srfarea: BuiltArea += i BuiltArea = round(BuiltArea, 2) EmptyArea = 2 * (round(boxarea - BuiltArea, 2)) if EmptyArea < 0: EmptyArea = 0 TR = 1000 * (0.16 * box) / (Builtareaabs + (EmptyArea * 1)) FRValue = 0 for f in FirstRay: FV = ((((Lis[0])[3]) * 15) / f) FRValue += FV if FRValue >= 125: FRValue = 125 SRValue = 0 for s in SecondRay: SV = ((((Lis[0])[3]) * 20) / s) SRValue += SV if SRValue > 125: SRValue = 125 Reverb.append(round(FRValue)) Reverb.append(round(SRValue)) Reverb.append(round(TR, 2)) return Reverb
uDomain = rs.SurfaceDomain(idSurface, 0) vDomain = rs.SurfaceDomain(idSurface, 1) # get size int from domain & / by intended count = increment between surfaces uStep = (uDomain[1] - uDomain[0]) / intCount vStep = (vDomain[1] - vDomain[0]) / intCount #print uStep #print vStep rs.EnableRedraw(False) # loop through size of surface by step increment in both u & v directions for u in rs.frange(uDomain[0], uDomain[1], uStep): for v in rs.frange(vDomain[0], vDomain[1], vStep): pt = rs.EvaluateSurface(idSurface, u, v) # get points at each domain step if rs.Distance(pt, rs.BrepClosestPoint(idSurface, pt)[0]) < 0.1: srfFrame = rs.SurfaceFrame( idSurface, [u, v]) # create ref plane at each division point newPlane = rs.AddPlaneSurface( srfFrame, 1.0, 1.0) # create surface at each ref plane # add height guideline from plane's origin to "ceiling" centerPt = rs.SurfaceAreaCentroid( newPlane) # locate center of each new plane limit = 10 # set "ceiling" endPt = limit - centerPt[0][ 2] # access z coordinate with the tuple rs.AddLine(centerPt[0], rs.PointAdd(centerPt[0], (0, 0, endPt))) rs.EnableRedraw(True) # refresh viewport at one time only
def DistanceTo(pt, id): ptCP = rs.BrepClosestPoint(id,pt) if ptCP: d = rs.Distance(pt, ptCP[0]) return math.log(d+1)
if len(subcrvs) > 1: subcurve = rs.JoinCurves(subcrvs) assert len(subcurve) == 1 subcurve = subcurve[0] else: subcurve = subcrvs[0] newpts = [] """Need to specify num_of_seg""" divparams = rs.DivideCurve(subcurve, num_of_seg, create_points=True, return_points=False) print(divparams) for j in range(len(divparams)): divpt = rs.EvaluateCurve(main_curve, divparams[j]) normal = rs.BrepClosestPoint(surface, divpt)[3] """Need to specify tangent""" tangent = rs.CurveTangent(main_curve, divparams[j], segment_index=-1) pushoff = rs.VectorCrossProduct(tangent, normal) dist = eps * (len(divparams) / 2 - abs(len(divparams) / 2 - j - 1)) newpt = rs.PointAdd(divpt, rs.VectorScale(pushoff, dist)) newpt = rs.BrepClosestPoint(surface, newpt)[0] newpts.append(newpt) newcrv = rs.AddInterpCurve(newpts) newcurves.append(newcrv) t1paramnew = [] t2paramnew = [] if t1param < t2param: t1paramnew.append(t2param) t1paramnew.append(0) t2paramnew.append(1)