def grow(self, side): newBranches = [] if len(self.branches) == 0: self.startBranch() for i in range(len(self.branches)): self.pullBranch(self.branches[i]) axis01 = self.findAxis(self.branches[i].end01) axis02 = self.findAxis(self.branches[i].end02) if rs.VectorAngle(self.branches[i].axis, axis01) < 60 and side == 1: param = rs.CurveClosestPoint(self.path, self.branches[i].end01) dist = rs.Distance(self.branches[i].end01, rs.EvaluateCurve(self.path, param)) tan = rs.CurveTangent(self.path, param) newBranches.append( branch(self.branches[i].end01, self.branches[i].vec01, self.ang, axis01)) if rs.VectorAngle(self.branches[i].axis, axis02) < 60 and side == 2: param = rs.CurveClosestPoint(self.path, self.branches[i].end02) dist = rs.Distance(self.branches[i].end02, rs.EvaluateCurve(self.path, param)) tan = rs.CurveTangent(self.path, param) vecAng = rs.VectorAngle(self.branches[i].vec02, tan) vec = rs.VectorRotate(self.branches[i].vec02, -vecAng / 5, axis02) newBranches.append( branch(self.branches[i].end02, self.branches[i].vec02, self.ang, axis02)) self.branches = [] self.branches.extend(newBranches) return self.branches
def offset_face(mesh, fkey, t): cent = mesh.face_centroid(fkey) vcords = mesh.face_coordinates(fkey, ordered=True) vkeys = mesh.face_vertices(fkey, ordered=True) pts = [] vecs = [] keys = [None] * len(vcords) for i, vcor in enumerate(vcords): vec1 = rs.VectorUnitize(rs.VectorCreate(vcords[i - 2], vcords[i - 1])) vec2 = rs.VectorUnitize(rs.VectorCreate(vcords[i], vcords[i - 1])) vec = rs.VectorAdd(vec1, vec2) vec = rs.VectorUnitize(vec) ang = rs.VectorAngle(vec, vec1) ang = math.radians(ang) l = t / math.sin(ang) vec = rs.VectorScale(vec, l) pt = rs.PointAdd(vcords[i - 1], vec) keys[i - 1] = mesh.add_vertex(x=pt[0], y=pt[1], z=pt[2]) for i, vkey in enumerate(vkeys): mesh.add_face([vkeys[i], keys[i], keys[i - 1], vkeys[i - 1]]) mesh.add_face(keys) del mesh.face[fkey]
def get_reference_vector(b_obj): """pick a reference vector for deciding surface category. note that we can't pick [0,1,0] because the brep might be on a 45deg angle.""" base_ref_vect = rs.VectorCreate([0,1,0],[0,0,0]) up = rs.coerce3dvector([0,0,1]) down = rs.coerce3dvector([0,0,-1]) epsilon = 0.5 faces = b_obj.Faces print faces.Count ref_faces = [] ref_angle_rotation = 90 for k in faces: v = k.NormalAt(0.5,0.5) #top and botom of extrusion have IsSurface = False (why?) if not (v.EpsilonEquals(up,epsilon) or v.EpsilonEquals(down,epsilon)): ref_faces.append(k) angle = rs.VectorAngle(v,base_ref_vect) angle = angle%90 print angle ref_angle_rotation = min(ref_angle_rotation,angle) new_ref_vector = rs.VectorRotate(base_ref_vect,ref_angle_rotation,[0,0,1]) #debug: verify this angle is good # for k in faces: # v = k.NormalAt(0.5,0.5) #top and botom of extrusion have IsSurface = False (why?) # if not (v.EpsilonEquals(up,epsilon) or v.EpsilonEquals(down,epsilon)): # ref_faces.append(k) # angle = rs.VectorAngle(v,new_ref_vector) # angle = angle%180 # print angle return new_ref_vector
def CreateRectangles(self): futureVel = self.vel.Clone() futurePos = self.pos.Clone() futureVel += self.acc futurePos += futureVel n0 = self.plane.ZAxis n1 = futureVel vecAngle = rs.VectorAngle(n0, n1) cross = rg.Vector3d.CrossProduct(n0, n1) self.plane.Rotate(math.radians(vecAngle), cross, self.pos) self.plane.Origin = self.pos #self.plane.Origin = self.pos #self.plane.ZAxis = futureVel #self.plane.UpdateEquation() #self.plane = rg.Plane(self.pos, futureVel) rect = rg.Rectangle3d(self.plane, self.size, self.size) rect = rect.ToNurbsCurve() #sc.doc.Objects.AddCurve(rect) self.history.append(rect) self.historyPos.append(self.pos)
def radiationForVector(vec, genCumSkyResult, TregenzaPatchesNormalVectors = lb_preparation.TregenzaPatchesNormalVectors): radiation = 0; patchNum = 0; for patchNum, patchVec in enumerate(TregenzaPatchesNormalVectors): vecAngle = rs.VectorAngle(patchVec, vec) if vecAngle < 90: radiation = radiation + genCumSkyResult[patchNum] * math.cos(math.radians(vecAngle)) return radiation
def mergeCoincidentLines(segments): """ removes coincident, consecutive segments input: List of GUIDs returns: List of GUIDs """ newSegments = [] i = 0 while i < len(segments): if (i < len(segments) - 1): #if coincident, delete both, add new. a = rs.VectorCreate(rs.CurveStartPoint(segments[i]), rs.CurveEndPoint(segments[i])) b = rs.VectorCreate(rs.CurveStartPoint(segments[i + 1]), rs.CurveEndPoint(segments[i + 1])) a = rs.VectorUnitize(a) b = rs.VectorUnitize(b) aAng = rs.VectorAngle(a, b) if (aAng < .00001): newLine = rs.AddLine(rs.CurveStartPoint(segments[i]), rs.CurveEndPoint(segments[i + 1])) rs.DeleteObject(segments[i]) rs.DeleteObject(segments[i + 1]) newSegments.append(newLine) i = i + 2 else: newSegments.append( segments[i]) #if not coincident, add to array i = i + 1 else: newSegments.append(segments[i]) #add last seg to array i = i + 1 return newSegments
def orientObjAlongPolyPts(obj, pts, basePoint=(0, 0, 0), baseVect=(0, 1, 0)): print('orient obj along poly points') up = (0, 0, 1) generatedObjects = [] for i in range(0, len(pts) - 1): if i < (len(pts) - 2): p0 = pts[i] p1 = pts[i + 1] p2 = pts[i + 2] v1 = rs.VectorUnitize(p1 - p0) v2 = rs.VectorUnitize(p2 - p1) n1 = rs.VectorCrossProduct(v1, up) n2 = rs.VectorCrossProduct(v2, up) mid = rs.VectorAdd(n1, n2) n = rs.VectorUnitize(mid) else: p0 = pts[i] p1 = pts[i + 1] v1 = rs.VectorUnitize(p1 - p0) n = rs.VectorCrossProduct(v1, up) rs.AddLine(p1, p1 + n) a = rs.VectorAngle((0, 1, 0), n) gen = rs.OrientObject(obj, [basePoint, basePoint + baseVect], [p1, p1 + n], 1) generatedObjects.append(gen) #g=rs.AddGroup() #groupObjects=rs.AddObjectsToGroup(generatedObjects,g) return generatedObjects
def update(self): print('update') #delete last generated objects try: rs.DeleteObjects(self.generatedObjs) self.generatedObjs = [] except: print('exception in delete generated object') divWidth = 600 crv = self.baseCrv if not rs.IsObject(crv): print('crv is not an object') return if not rs.IsPolyline(crv): pts = rs.DivideCurveEquidistant(crv, divWidth) rail = rs.AddPolyline(pts) else: rail = rs.CopyObject(crv) pts = rs.CurveEditPoints(rail) if len(pts) < 3: print('too little points') return #find vectors to move and orient the profile vect = pts[1] - pts[0] vect = rs.VectorUnitize(vect) a = rs.VectorAngle(vect, (0, 1, 0)) - 90 #load the component path = self.loadPath component = None try: component = importComponent(path) except: print('exception on importing module') if component is None: print('component is None') return None #rs.MoveObjects(component.breps,pts[0]) #rs.RotateObjects(component.breps,pts[0],a) for b in component.breps: self.generatedObjs.append(b) oriented = orientObjAlongPolyPts(b, pts) print('pts count:', len(pts), ' num gen:', len(oriented)) rs.MoveObjects(component.polys, pts[0]) rs.RotateObjects(component.polys, pts[0], a) for c in component.polys: self.generatedObjs.append(c) mesh = meshSwipPolyAlongPoly(c, rail) self.generatedObjs.append(mesh) rs.DeleteObject(rail) print('generated obj count:', len(self.generatedObjs)) rs.AddGroup('gen') rs.AddObjectsToGroup(self.generatedObjs, 'gen')
def CreateRectangles(self): futureVel = self.vel.Clone() futurePos = self.pos.Clone() futureVel += self.acc futurePos += futureVel n0 = self.plane.ZAxis n1 = futureVel vecAngle = rs.VectorAngle(n0, n1) cross = rg.Vector3d.CrossProduct(n0, n1) self.plane.Rotate(math.radians(vecAngle), cross, self.pos) self.plane.Origin = self.pos self.plane.Rotate(math.radians(1), self.plane.Normal) #pts = [rg.Point3d(self.size/2, self.size, 0), rg.Point3d(self.size/2, -self.size, 0), rg.Point3d(-self.size/2, -self.size, 0), rg.Point3d(-self.size/2, self.size, 0), rg.Point3d(self.size/2, self.size, 0)] pts = [rg.Point3d(self.size/2, self.size, 0), rg.Point3d(self.size/2, -self.size, 0), rg.Point3d(-self.size/2, -self.size, 0), rg.Point3d(-self.size/2, self.size, 0)] nurb = rg.NurbsCurve.Create(True, 3, pts) self.plane = rg.Plane(self.pos, self.vel) circ = rg.Circle(self.plane, self.size) circ = circ.ToNurbsCurve() xform = rg.Transform.PlaneToPlane(rg.Plane.WorldXY, self.plane) nurb.Transform(xform) rect = rg.Rectangle3d(self.plane, rg.Interval(-self.size, self.size), rg.Interval(-self.size, self.size)) rect = rect.ToNurbsCurve() #sc.doc.Objects.AddCurve(rect) self.history.append(circ) self.historyPos.append(self.pos)
def angAttractor(attPt,testPt,baseVec,baseAng,thres,max): compare=rs.VectorCreate(attPt,testPt) editAng=rs.VectorAngle(baseVec,compare) ang=baseAng+(1-setAttractor(attPt,testPt,thres,0))*(editAng-baseAng) if ang>max: ang=max return ang
def get_face_category(f,v): """pick category: 0: side srfs that get extended 1: side srfs that get shortened 2: top surfaces""" normal = f.NormalAt(0.5,0.5) epsilon = 0.5 up = rs.coerce3dvector([0,0,1]) down = rs.coerce3dvector([0,0,-1]) compare_angle = min(rs.VectorAngle(normal,v),rs.VectorAngle(normal,rs.VectorReverse(v))) if normal.EpsilonEquals(up,epsilon) or normal.EpsilonEquals(down,epsilon): return 2 elif 88 < compare_angle < 92: return 1 else: return 0
def setAngleOfBaseSurface(self): tmpVector = (0, 0, 1) self.angleOfSurface = rs.VectorAngle(tmpVector, self.normalVec) #for debug if self.angleOfSurface < 0 or self.angleOfSurface > 90: print('self.angleOfSurface is wseird')
def edgeAngle(myMesh, edgeIndex): #TODO: make myMesh function which findes angel between two faces of a given edge faceIdxs = myMesh.getFacesForEdge(edgeIndex) if (len(faceIdxs) == 2): faceNorm0 = myMesh.face_normal(faceIdxs[0]) faceNorm1 = myMesh.face_normal(faceIdxs[1]) return rs.VectorAngle(faceNorm0, faceNorm1) else: return None
def grow(self): newBranches = [] if len(self.branches) == 0: self.startBranch() for i in range(len(self.branches)): self.pullBranch(self.branches[i]) axis01 = self.findAxis(self.branches[i].end01) axis02 = self.findAxis(self.branches[i].end02) if rs.VectorAngle(self.branches[i].axis, axis01) < 60: newBranches.append( branch(self.branches[i].end01, self.branches[i].vec01, self.ang, axis01)) if rs.VectorAngle(self.branches[i].axis, axis02) < 60: newBranches.append( branch(self.branches[i].end02, self.branches[i].vec02, self.ang, axis02)) self.branches = [] self.branches.extend(newBranches) return self.branches
def getTabAngles(self, mesh, currFaceIdx, xForm): # WORKING AWAY FROM THIS: data is implicit in tabFace center edge = self.meshEdgeIdx otherFace = getOtherFaceIdx(edge, currFaceIdx, mesh) if otherFace is not None: faceCenter = mesh.Faces.GetFaceCenter(otherFace) # Point3d if getDistanceToEdge(mesh, edge, faceCenter) <= self.tabWidth: faceCenter.Transform(xForm) self.tabFaceCenter = faceCenter else: posVecCenter = Rhino.Geometry.Vector3d(faceCenter) pntI, pntJ = getPointsForEdge(mesh, edge) # Point3d vecEdge = getEdgeVector(mesh, edge) # Vector3d posVecI = Rhino.Geometry.Vector3d(pntI) posVecJ = Rhino.Geometry.Vector3d(pntJ) vecI = Rhino.Geometry.Vector3d.Subtract(posVecCenter, posVecI) vecJ = Rhino.Geometry.Vector3d.Subtract(posVecJ, posVecCenter) angleI = rs.VectorAngle(vecI, vecEdge) angleJ = rs.VectorAngle(vecJ, vecEdge) self.tabAngles = [angleI, angleJ] """ color = (0,0,0,0) drawVector(vecI,posVecI,color) drawVector(vecJ,posVecCenter,color) strI = str(angleI) strJ = str(angleJ) rs.AddTextDot(strI,posVecI) rs.AddTextDot(strJ,posVecJ) print #wtf: for some reason needed this line to print below print( 'angleI: %.2f, angleJ: %.2f' %(angleI,angleJ) ) """ elif otherFace == -1: print "was nakedEdge" else: print "otherFace: ", print otherFace
def grow(self): newBranches = [] print(self.ang) first = False if len(self.branches) == 0: self.startBranch() first = True for i in range(len(self.branches)): self.pullBranch(self.branches[i]) axis01 = self.findAxis(self.branches[i].end01) axis02 = self.findAxis(self.branches[i].end02) b01 = r.random() b02 = r.random() if rs.VectorAngle(self.branches[i].axis, axis01) < 60 and b01 < .5: ang = self.ang * r.random() self.branches[i].vec01 = rs.VectorUnitize( self.branches[i].vec01) self.branches[i].vec01 = self.branches[i].vec01 * self.len sc = r.random() + .25 if sc > 1: sc = 1 v = self.branches[i].vec01 * sc newBranches.append( branch(self.branches[i].end01, v, ang, axis01)) if rs.VectorAngle(self.branches[i].axis, axis02) < 60 and b02 < .5: ang = self.ang * r.random() self.branches[i].vec02 = rs.VectorUnitize( self.branches[i].vec02) self.branches[i].vec02 = self.branches[i].vec02 * self.len sc = r.random() + .25 if sc > 1: sc = 1 v = self.branches[i].vec02 * sc newBranches.append( branch(self.branches[i].end02, v, self.ang, axis02)) self.branches = [] self.branches.extend(newBranches) return self.branches
def grow(self): newBranches = [] if len(self.branches) == 0: self.startBranch() for i in range(len(self.branches)): self.pullBranch(self.branches[i]) axis01 = self.findAxis(self.branches[i].end01) axis02 = self.findAxis(self.branches[i].end02) if rs.VectorAngle(self.branches[i].axis, axis01) < 60: v = rs.VectorCreate(self.branches[i].end01, self.branches[i].start) v = rs.VectorScale(v, self.length / rs.VectorLength(v)) newBranches.append( branch(self.branches[i].end01, v, self.ang, axis01)) if rs.VectorAngle(self.branches[i].axis, axis02) < 60: v = rs.VectorCreate(self.branches[i].end02, self.branches[i].start) v = rs.VectorScale(v, self.length / rs.VectorLength(v)) newBranches.append( branch(self.branches[i].end02, v, self.ang, axis02)) self.branches = [] self.branches.extend(newBranches) return self.branches
def AngleABC(a, b, c): """AngleABC(a, b, c). As if A-B-C made a polyline, measures the clockwise angle parameters: a (pt): first pt b (pt): elbow between A and C. c (pt): last point returns: clockwise angle in degrees """ vec1 = rs.VectorCreate(a, b) vec2 = rs.VectorCreate(c, b) inner = rs.VectorAngle(vec1, vec2) det = vec1[0]*vec2[1]-vec1[1]*vec2[0] if det<0: return inner else: return 360-inner
def blkFace(obj): cameraPos = rs.ViewCamera() cameraPos.Z = 0 xform = rs.BlockInstanceXform(obj) plane = rs.PlaneTransform(rs.WorldXYPlane(), xform) viewdir = rs.VectorUnitize(cameraPos - plane.Origin) angle = rs.VectorAngle(viewdir, plane.YAxis) newXform = rs.XformRotation3(plane.YAxis, viewdir, plane.Origin) rs.TransformObject(obj, newXform)
def assignBlockToPanel(obj): """ Assigns block containing a base surface to a surface with the matching name. Block, base surface, and target surface must all have the same name. input: target surface (with name) returns: None """ allBlockNames = rs.BlockNames() for eachBlockName in allBlockNames: if rs.ObjectName(obj) == eachBlockName: blockName = eachBlockName print "Matching Block Found" objBasePt = rs.SurfaceEditPoints(obj)[0] objYPt = rs.SurfaceEditPoints(obj)[1] objXPt = rs.SurfaceEditPoints(obj)[2] objXVec = rs.VectorCreate(objXPt, objBasePt) objXLength = rs.VectorLength(objXVec) objYLength = rs.Distance(objBasePt, objYPt) blockObjs = rs.BlockObjects(blockName) for blockObj in blockObjs: if rs.ObjectName(blockObj) == blockName: print "Contains base plane" if rs.IsSurface(blockObj): blockBasePt = rs.SurfaceEditPoints(blockObj)[0] blockYPt = rs.SurfaceEditPoints(blockObj)[1] blockXPt = rs.SurfaceEditPoints(blockObj)[2] blockXVec = rs.VectorCreate(blockXPt, blockBasePt) rotAngle = rs.VectorAngle(objXVec, blockXVec) blockXLength = rs.VectorLength(blockXVec) blockYLength = rs.VectorLength( rs.VectorCreate(blockYPt, blockBasePt)) xScale = objXLength / blockXLength yScale = objYLength / blockYLength newScale = [yScale, xScale, 1] rs.InsertBlock(blockName, objBasePt, scale=newScale, angle_degrees=rotAngle) break else: print "Error: Base plane was not a surface"
def detectParalellSurface(self): #fix layer height #self.paralellIntersectedCurve #self.indexParalellSurfaces explodedSurfaces = rs.ExplodePolysurfaces(self.addtiveObj) for surface in explodedSurfaces: #normals.append(rs.SurfaceNormal(surface)) tmpNormal = rs.SurfaceNormal(surface, [0, 0]) gotAngle = rs.VectorAngle(tmpNormal, self.normalVec) if gotAngle == 0 or gotAngle == 180: tmpPoints = rs.SurfaceEditPoints(surface) tmpPlane = rs.PlaneFromNormal(tmpPoints[0], self.normalVec) distance = rs.DistanceToPlane(tmpPlane, self.basePointForPlane) distance *= (1.0 / math.cos(math.radians(self.angleOfSurface))) print("distance") print(distance) paralellLayer = int(distance / self.fixedLayerHeight) if paralellLayer < 0: paralellLayer *= -1 if paralellLayer == int( self.distancePrinting / self.fixedLayerHeight) or int(distance) == 0: continue self.indexParalellSurfaces.append(int(paralellLayer)) print("paralellLayer") print(paralellLayer) print("layer num") print(self.distancePrinting / self.fixedLayerHeight) #there is object to delete self.paralellIntersectedCurves.append( rs.JoinCurves(rs.DuplicateEdgeCurves(surface))) rs.DeleteObjects(explodedSurfaces) """
def FaceCamera(): try: frames = rs.GetObjects("Select Picture Frames", filter=8, preselect=True) # rotate surfaces around z axis towards camera point if frames: rs.EnableRedraw(False) cam = rs.ViewCamera() camz = (cam.X, cam.Y, 0) angle = 1 for i in frames: angle = 1 while angle >= 1: # get mid point of surface and move to z 0 pointmid = rs.SurfaceAreaCentroid(i) pointmidz = (pointmid[0].X, pointmid[0].Y, 0) # Get center UV of surface domainU = rs.SurfaceDomain(i, 0) domainV = rs.SurfaceDomain(i, 1) u = domainU[1] / 2.0 v = domainV[1] / 2.0 # Get normal vector of surface and cam vector vec1 = rs.SurfaceNormal(i, (u, v)) vec1 = vec1.X, vec1.Y, 0 vec2 = rs.VectorCreate(camz, pointmidz) # find angle difference between the two vectors angle = rs.VectorAngle(vec1, vec2) angle = round(angle) # Rotate Object rs.RotateObject(i, pointmidz, angle) continue rs.EnableRedraw(True) except: print("Failed to execute") rs.EnableRedraw(True) return
def trail(self, r): vectr = [0, 0, 0] sum = [0, 0, 0] count = 0 if traillist: for i in range(len(traillist)): distan = rs.Distance(self.pos, traillist[i]) vecref = rs.VectorCreate(traillist[i], self.pos) angl = rs.VectorAngle(self.vel, vecref) if 0 < distan < r and 0 < angl < 45: sum = rs.VectorAdd(sum, traillist[i]) count = count + 1 if count > 0: avep = rs.VectorScale(sum, 1 / count) vectr = rs.VectorCreate(avep, self.pos) vectr = vectorlimit(vectr, self.mf) #if count == 0: #print(vectr) return vectr
def makeSliceSurface(surface, maxAngle): explodedSurfaces = rs.ExplodePolysurfaces(surface) newSurfaces = [] rs.DeleteObject(surface) baseVec = (0, 0, 1) for i in explodedSurfaces: vec = rs.SurfaceNormal(i, [0, 0]) angle = rs.VectorAngle(baseVec, vec) if angle > maxAngle: rs.DeleteObject(i) else: newSurfaces.append(i) joinedSurface = rs.JoinSurfaces(newSurfaces) return joinedSurface
def UpdateDisplay(self): if self.id: sc.doc.Objects.Delete(self.id, True) growthRate = .05 #Transform start circle scale xform = rg.Transform.Scale(self.plane.Origin, (self.size + growthRate) / self.size) self.size += growthRate self.endCirc = rg.Circle(self.circ.Plane, self.circ.Radius) tanEnd = self.path.TangentAt(1) ptEnd = self.path.PointAt(1) #Transform circle to end plane n0 = self.plane.ZAxis n1 = self.path.TangentAt(1) vecAngle = rs.VectorAngle(n0, n1) cross = rg.Vector3d.CrossProduct(n0, n1) endPlane = self.plane.Clone() ptEnd = self.path.PointAt(1) endPlane.Origin = ptEnd endPlane.Rotate(math.radians(vecAngle), cross, ptEnd) endPlaneXform = rg.Transform.PlaneToPlane(self.circ.Plane, endPlane) self.endCirc.Transform(endPlaneXform) self.circ.Transform(xform) self.crv0 = rg.Circle(self.circ.Plane, self.circ.Radius) self.crv0 = self.crv0.ToNurbsCurve() self.crv1 = rg.Circle(self.endCirc.Plane, self.endCirc.Radius) self.crv1 = self.crv1.ToNurbsCurve() loft = rg.Brep() results = loft.CreateFromLoft([self.crv0, self.crv1], rg.Point3d.Unset, rg.Point3d.Unset, rg.LoftType.Straight, False) self.id = sc.doc.Objects.AddBrep(results[0], self.parent.attr)
def blkFace(obj): cameraPos = rs.ViewCamera() cameraPos.Z = 0 plane = rs.WorldXYPlane() if rs.IsBlockInstance(obj): plane = blkPlane(obj) elif rs.IsSurface(obj): plane = srfPlane(obj) targetpos = plane.Origin targetpos.Z = 0 viewdir = rs.VectorUnitize(cameraPos - targetpos) angle = rs.VectorAngle(viewdir, plane.YAxis) newXform = rs.XformRotation3(plane.YAxis, viewdir, plane.Origin) rs.TransformObject(obj, newXform)
def orientObjAlongPolyPts(obj, pts, baseVect=(0, 1, 0)): up = (0, 0, 1) for i in range(0, len(pts) - 1): if i < (len(pts) - 2): p0 = pts[i] p1 = pts[i + 1] p2 = pts[i + 2] v1 = rs.VectorUnitize(p1 - p0) v2 = rs.VectorUnitize(p2 - p1) n1 = rs.VectorCrossProduct(v1, up) n2 = rs.VectorCrossProduct(v2, up) mid = rs.VectorAdd(n1, n2) n = rs.VectorUnitize(mid) else: p0 = pts[i] p1 = pts[i + 1] v1 = rs.VectorUnitize(p1 - p0) n = rs.VectorCrossProduct(v1, up) rs.AddLine(p1, p1 + n) a = rs.VectorAngle((0, 1, 0), n) rs.OrientObject(obj, [(0, 0, 0), baseVect], [p1, p1 + n], 1)
def angle(v1, v2): # rs.VectorAngle returns degrees which is not very convenient return radians(rs.VectorAngle(v1, v2))
def rc_collapse_box(): go = Rhino.Input.Custom.GetObject() go.GeometryFilter = Rhino.DocObjects.ObjectType.Brep default_KeepLayer = sc.sticky["KeepLayer"] if sc.sticky.has_key( "KeepLayer") else False default_IgnoreOpen = sc.sticky["IgnoreOpen"] if sc.sticky.has_key( "IgnoreOpen") else False opt_KeepLayer = Rhino.Input.Custom.OptionToggle(default_KeepLayer, "No", "Yes") opt_IgnoreOpen = Rhino.Input.Custom.OptionToggle(default_IgnoreOpen, "No", "Yes") go.SetCommandPrompt("Select Breps") go.AddOptionToggle("KeepLayer", opt_KeepLayer) go.AddOptionToggle("IgnoreOpenBreps", opt_IgnoreOpen) go.GroupSelect = True go.SubObjectSelect = False go.AcceptEnterWhenDone(True) go.AcceptNothing(True) go.EnableClearObjectsOnEntry(False) go.EnableUnselectObjectsOnExit(False) go.GroupSelect = True go.SubObjectSelect = False go.DeselectAllBeforePostSelect = False res = None bHavePreselectedObjects = True while True: res = go.GetMultiple(1, 0) if res == Rhino.Input.GetResult.Option: go.EnablePreSelect(False, True) continue #If not correct elif res != Rhino.Input.GetResult.Object: rs.Redraw() print "No breps were selected!" return Rhino.Commands.Result.Cancel if go.ObjectsWerePreselected: rs.Redraw() bHavePreselectedObjects = True go.EnablePreSelect(False, True) continue break OPT_IGNORE_OPEN = opt_IgnoreOpen.CurrentValue OPT_KEEP_LAYER = opt_KeepLayer.CurrentValue sticky["IgnoreOpen"] = OPT_IGNORE_OPEN sticky["KeepLayer"] = OPT_KEEP_LAYER rs.EnableRedraw(False) input_breps = [] for i in xrange(go.ObjectCount): b_obj = go.Object(i).Object() input_breps.append(b_obj.Id) current_cplane = sc.doc.Views.ActiveView.ActiveViewport.GetConstructionPlane( ) temp_cplane = current_cplane.Plane current_cplane.Plane = rs.WorldXYPlane() solid_brep_count = 0 for brep in input_breps: if not rs.IsObjectSolid(brep): solid_brep_count += 1 if OPT_IGNORE_OPEN: continue if OPT_KEEP_LAYER: brep_layer = rs.ObjectLayer(rs.coerceguid(brep)) exploded = rs.ExplodePolysurfaces(brep, True) remaining_srfs = [] for srf in exploded: norm = rs.SurfaceNormal(srf, [0.5, 0.5]) if 10 > rs.VectorAngle(norm, [0, 0, 1]) or 10 > rs.VectorAngle( norm, [0, 0, -1]): rs.DeleteObject(srf) else: remaining_srfs.append(srf) areas = [rs.SurfaceArea(s) for s in remaining_srfs] areas = [x[0] for x in areas] srfs, areas = zip( *sorted(zip(remaining_srfs, areas), key=lambda x: x[1])) pt1, _ = rs.SurfaceAreaCentroid(srfs[-1]) pt2, _ = rs.SurfaceAreaCentroid(srfs[-2]) vect = rs.VectorCreate(pt2, pt1) vect = rs.VectorDivide(vect, 2) rs.MoveObject(srfs[-1], vect) if OPT_KEEP_LAYER: rs.ObjectLayer(srfs[-1], brep_layer) rs.SelectObjects(srfs[-1]) rs.DeleteObjects(srfs[:-1]) rs.EnableRedraw(True) rs.Redraw() current_cplane.Plane = temp_cplane if solid_brep_count > 0: outcome = " and were not collapsed." if OPT_IGNORE_OPEN else " and may have been flattened incorrectly. Check input geometry." report = str(solid_brep_count) + " brep(s) were not closed" + outcome print report
for v_list, r_list in zip(_sphere_testVec.Branches, _sphere_radiation.Branches): for v, r in zip(v_list, r_list): objs.append(OrientationRad(r, v)) # Find the closest Sphere segment to the window (based on srfc normal) # Calc shading factor # ------------------------------------------------------------------------------ win_radiation_ = [] sphere_segment_radiation_ = [] win_shading_factor_ = [] max_error = 0 for window in windows: smallest_angle = 360 for obj in objs: angle_diff = rs.VectorAngle(obj.srfc_normal, window.srfc_normal) if angle_diff < smallest_angle: closestRadVal = obj.radiation smallest_angle = angle_diff win_radiation_.append(window.radiation) sphere_segment_radiation_.append(closestRadVal) win_shading_factor_.append(window.radiation / closestRadVal) if smallest_angle > max_error: max_error = smallest_angle