def MoveWithVector (treeIn, profPointTreeIn, vectorTreeIn, thicknessIn, angleIn, treeOut): profMax = GridCornerBig (profPointTreeIn) profMin = GridCornerSmall (profPointTreeIn) max = GridCornerBig (treeIn) for i in range(treeIn.BranchCount): treeBranch = treeIn.Branch(i) treePath = treeIn.Path(i) profBranch = profPointTreeIn.Branch(i) vectorBranch = vectorTreeIn.Branch(i) thicknessBranch = thicknessIn.Branch(i) angleBranch = angleIn.Branch(i) for j in range(treeBranch.Count): elem = treeBranch[j] profPoint = profBranch [j] vector = vectorBranch [j] v = thicknessBranch [j] angle = angleBranch [j] if type != 0: elemLapos = rs.AddPoint (elem.X,elem.Y,0) elemLapos = rs.coerce3dvector (elemLapos) #angle = rs.VectorAngle ([1,0,0], elemLapos) betaRad = math.radians (beta) gammaRad = math.radians (angle) if gammaRad > betaRad/2: gammaRad = gammaRad - betaRad/2 else: gammaRad = betaRad/2 - gammaRad v = (math.cos (betaRad/2)) / (math.cos (gammaRad)) *v vec = rs.coerce3dpoint (vector) rotVecX = vec.X rotVecZ = vec.Y rotVecY = vec.Z rotVec = rs.AddPoint (rotVecX, rotVecY, rotVecZ) rotVec = rs.coerce3dpoint (rotVec) ORIGO = rs.AddPoint (0,0,0) ORIGO = rs.coerce3dpoint (ORIGO) VECTOR = rs.RotateObject(rotVec, ORIGO, angle, [0,0,1]) vector = rs.coerce3dvector (VECTOR) vector = vector * v elem = rs.coerce3dpoint (elem) MovePoint = rs.MoveObject (elem, vector) MovePoint = rs.coerce3dpoint (MovePoint) treeOut.Add (elem, treePath)
def FromEdgetoPlane(): PointPlane = [] CurveIdList = [] Brep = [] edges = rs.GetEdgeCurves() if edges: for edgeinfo in edges: Brep.append(edgeinfo[1]) CurveIdList.append(edgeinfo[0]) for CurveId in CurveIdList: if rs.IsCircle(CurveId): Pt = rs.CircleCenterPoint(CurveId) Normal = rs.CurveNormal(CurveId) LenghtNormal = rs.VectorLength(Normal) LenghNormal = self.m_foronumero.Text LenghNormal = int(LenghNormal) Normal = (LenghNormal * Normal[0], LenghNormal * Normal[1], LenghNormal * Normal[2]) PtStill = rs.AddPoint(Pt) Ptmoved = rs.MoveObject(Pt, Normal) Ptmoved = rs.coerce3dpoint(Ptmoved) PtStill = rs.coerce3dpoint(PtStill) PointPlane.append([ PtStill[0], PtStill[1], PtStill[2], Normal[0], Normal[1], Normal[2] ]) #PointPlane.append([Ptmoved[0],Ptmoved[1],Ptmoved[2],Normal[0],Normal[1],Normal[2]]) return (PointPlane, Brep)
def user_function(mesh,i): for key, a in mesh.vertices_iter(True): pt = (a['x'], a['y'], a['z']) if a['type'] == 'fixed' or a['type'] == 'free': continue if a['type'] == 'guide': point = rs.coerce3dpoint(pt) rc, t = a['guide_crv'].ClosestPoint(point) pt = a['guide_crv'].PointAt(t) elif a['type'] == 'surface': point = rs.coerce3dpoint(pt) pt = a['guide_srf'].ClosestPoint(point) mesh.vertex[key]['x'] = pt[0] mesh.vertex[key]['y'] = pt[1] mesh.vertex[key]['z'] = pt[2] if vis: if i%vis==0: rs.Prompt(str(i)) draw_light(mesh,temp = True) Rhino.RhinoApp.Wait()
def draw(self): p1 = rs.coerce3dpoint(self.center + self.sv1) p2 = rs.coerce3dpoint(self.center + self.sv2) perim = rh.Geometry.Ellipse(rs.coerce3dpoint(self.center), p1, p2) perim_id = sc.doc.Objects.AddEllipse(perim) perim_nrbs = perim.ToNurbsCurve() srf = rh.Geometry.Brep.CreatePlanarBreps(perim_nrbs)[0] srf_id = sc.doc.Objects.AddBrep(srf)
def draw(self): p1 = rs.coerce3dpoint(self.center+self.sv1) p2 = rs.coerce3dpoint(self.center+self.sv2) perim = rh.Geometry.Ellipse(rs.coerce3dpoint(self.center), p1, p2) perim_id = sc.doc.Objects.AddEllipse(perim) perim_nrbs = perim.ToNurbsCurve() srf = rh.Geometry.Brep.CreatePlanarBreps(perim_nrbs)[0] srf_id = sc.doc.Objects.AddBrep(srf)
def draw(self): plane = rs.PlaneFromNormal(rs.coerce3dpoint(self.center), self.nv) p1 = rs.coerce3dpoint(self.center + self.sv1 + self.sv2) p2 = rs.coerce3dpoint(self.center - self.sv1 - self.sv2) p3 = rs.coerce3dpoint(self.center + self.sv1 - self.sv2) p4 = rs.coerce3dpoint(self.center - self.sv1 + self.sv2) pts = [p1, p4, p2, p3, p1] draw_rectangle(pts) for pt in pts[0:-1]: sc.doc.Objects.AddPoint(pt)
def draw(self): plane = rs.PlaneFromNormal(rs.coerce3dpoint(self.center), self.nv) p1 = rs.coerce3dpoint(self.center+self.sv1+self.sv2) p2 = rs.coerce3dpoint(self.center-self.sv1-self.sv2) p3 = rs.coerce3dpoint(self.center+self.sv1-self.sv2) p4 = rs.coerce3dpoint(self.center-self.sv1+self.sv2) pts = [p1,p4,p2,p3,p1] draw_rectangle(pts) for pt in pts[0:-1]: sc.doc.Objects.AddPoint(pt)
def CupolaCollar(treeIn, profilePointsIn, profileVectorsIn, treeOut, ratioOut, profilePointsOut, profileVectorsOut): Pmax = GridCornerBig(treeIn) Xmax = Pmax.X Ymax = Pmax.Y Zmax = Pmax.Z Pmin = GridCornerSmall(treeIn) Xmin = Pmin.X Ymin = Pmin.Y Zmin = Pmin.Z print profilePointsIn for i in range(treeIn.BranchCount): treeBranch = treeIn.Branch(i) treePath = treeIn.Path(i) profPointsBranch = profilePointsIn.Branch(i) profVectorsBranch = profileVectorsIn.Branch(i) for j in range(treeBranch.Count): elem = treeBranch[j] profPoint = profPointsBranch[j] profVector = profVectorsBranch[j] x = elem.X y = elem.Y z = elem.Z Xr = x / Xmax Yr = y / Ymax if Zmax == 0: Zr = 0 else: Zr = z / Zmax P1 = rs.AddPoint(Xmin, y, z) P1 = rs.coerce3dpoint(P1) P2 = rs.AddPoint(Xmax, y, z) P2 = rs.coerce3dpoint(P2) path = ghpath(treePath.AppendElement(j)) treeOut.Add(P1, path) treeOut.Add(P2, path) ratioOut.Add(Xr, path) profilePointsOut.Add(profPoint, path) profilePointsOut.Add(profPoint, path) profileVectorsOut.Add(profVector, path) profileVectorsOut.Add(profVector, path)
def slopeCalc(p1, p2): pt1 = rs.coerce3dpoint(p1) pt2 = rs.coerce3dpoint(p2) h = pt2.Z - pt1.Z pt2.Z = pt1.Z dist = pt1.DistanceTo(pt2) #print dist slope = h * 100 / dist return slope
def slopeCalc(p1,p2): pt1 = rs.coerce3dpoint(p1) pt2 = rs.coerce3dpoint(p2) h = pt2.Z-pt1.Z pt2.Z = pt1.Z dist = pt1.DistanceTo(pt2) #print dist slope = h*100/dist return slope
def convertToPolylines(obj): # get object properties text = rs.TextObjectText(obj) pt = rs.TextObjectPoint(obj) origin = rs.coerce3dpoint([0,0,0]) ht = rs.TextObjectHeight(obj) object_layer = rs.ObjectLayer(obj) plane = rs.TextObjectPlane(obj) diff = rs.coerce3dpoint([pt.X, pt.Y, pt.Z]) p1 = rs.WorldXYPlane() matrix = rs.XformRotation4(p1.XAxis, p1.YAxis, p1.ZAxis, plane.XAxis, plane.YAxis, plane.ZAxis) rs.DeleteObject(obj) # set current layer to put strings in prevlayer = rs.CurrentLayer() layer = rs.AddLayer('temptextlayer') rs.CurrentLayer('temptextlayer') # split text at enters text = text.split('\r\n') opts='GroupOutput=No FontName="timfont" Italic=No Bold=No Height='+ str(ht) opts+=" Output=Curves AllowOpenCurves=Yes LowerCaseAsSmallCaps=No AddSpacing=No " origin.Y += ht * len(text) *1.2 for item in text: rs.Command("_-TextObject " + opts + '"'+item+'"' + " " + str(origin) , False) origin.Y -= ht *1.5 #restore current layer rs.CurrentLayer(prevlayer) #select newly created texts polylines = rs.ObjectsByLayer('temptextlayer') # transform to old position rs.TransformObjects(polylines, matrix, copy=False) rs.MoveObjects(polylines, diff) rs.ObjectLayer(polylines, object_layer) return polylines
def convertTextToPolylines2(obj): # get object properties text = rs.TextObjectText(obj) pt = rs.TextObjectPoint(obj) origin = rs.coerce3dpoint([0, 0, 0]) ht = rs.TextObjectHeight(obj) object_layer = rs.ObjectLayer(obj) plane = rs.TextObjectPlane(obj) diff = rs.coerce3dpoint([pt.X, pt.Y, pt.Z]) p1 = rs.WorldXYPlane() #restore view cplane rs.ViewCPlane(None, p1) matrix = rs.XformRotation4(p1.XAxis, p1.YAxis, p1.ZAxis, plane.XAxis, plane.YAxis, plane.ZAxis) rs.DeleteObject(obj) # split text at enters text = text.split('\r\n') opts = 'GroupOutput=No FontName="' + EXPORT_FONT + '" Italic=No Bold=No Height=' + str( ht) opts += " Output=Curves AllowOpenCurves=Yes LowerCaseAsSmallCaps=No AddSpacing=No " n_lines = len(text) origin.Y += 1.6 * ht * (len(text) - 1) polylines = [] for item in text: rs.Command( "_-TextObject " + opts + '"' + item + '"' + " " + str(origin), False) polylines += rs.LastCreatedObjects() origin.Y -= ht * 1.6 rs.ObjectLayer(polylines, object_layer) polylines = rs.ScaleObjects(polylines, (0, 0, 0), (0.7, 1, 1), True) # transform to old position rs.TransformObjects(polylines, matrix, copy=False) rs.MoveObjects(polylines, diff) return polylines
def Get_PointOnMeshEdge(msg0, msg1): #gets Mesh edge go = Rhino.Input.Custom.GetObject() go.SetCommandPrompt(msg0) go.GeometryFilter = Rhino.DocObjects.ObjectType.MeshEdge go.SubObjectSelect = True go.GroupSelect = False go.AcceptNothing(True) if go.Get() != Rhino.Input.GetResult.Object: return objref = go.Object(0) #get edge index index = objref.GeometryComponentIndex.Index #get mesh parent mesh = objref.Mesh() #get line representing mesh edge edge_line = mesh.TopologyEdges.EdgeLine(index) edge_point = edge_line[0] print(type(edge_point.X)) #start a get point constrained to edge line gp = Rhino.Input.Custom.GetPoint() gp.SetCommandPrompt(msg1) gp.Constrain(edge_line) get_rc = gp.Get() placed_point = rs.coerce3dpoint(sc.doc.Objects.AddPoint(gp.Point())) sc.doc.Views.Redraw() #The distance brom edgeline[0] to pickedpoint is calcuated here distance = math.sqrt((placed_point.X - edge_point.X)**2 + (placed_point.Y - edge_point.Y)**2 + (placed_point.Z - edge_point.Z)**2) return distance
def Build_Key(Point, colors, tol): """ Build key for tolerance shading. Create color coded text objects and planes. """ low2 = "-" + str(tol[2]) + '"' + " and lower" low1 = "-" + str(tol[2]) + '"' + " to -" + str(tol[1]) + '"' low0 = "-" + str(tol[1]) + " to -" + str(tol[0]) + '"' good = "-" + str(tol[0]) + " to +" + str(tol[0]) + '"' high0 = "+" + str(tol[0]) + " to +" + str(tol[1]) + '"' high1 = "+" + str(tol[1]) + " to +" + str(tol[2]) + '"' high2 = "+" + str(tol[2]) + " and higher" stringList = [high2, high1, high0, good, low0, low1, low2] objs = [] for i in range(len(stringList)): pt = rs.coerce3dpoint([0, 0, 1.5 * i + 3]) plane = rs.PlaneFromNormal(pt + Point, [0, -1, 0], [1, 0, 0]) txt = rs.AddText(stringList[i], plane) srf = rs.AddPlaneSurface(plane, 1, 1) rs.MoveObject(srf, [-2, 0, 0]) stringColor = "Tol_" + colors[i].ToString().split("[")[1].rstrip("]") mt.OrganizeLayer(stringColor, Objects=[srf, txt], Render=colors[i], Color=colors[i])
def getSolarGeom(boundary,ht,lat,shourlst,ehourlst,day,north,long,timeZ,s_mth,e_mth): CH = ConvexHull2d() boundary_pts = rs.CurvePoints(boundary) # you'll need this later boundary_pts.pop(-1) bchullpts = CH.convex_hull(boundary_pts) centerPt = rs.CurveAreaCentroid(rs.AddCurve(bchullpts + [bchullpts[0]],1))[0] #centerPt = rs.CurveAreaCentroid(boundary)[0] boundary_plane = rs.PlaneFitFromPoints(boundary_pts) top_plane = get_plane(boundary,ht) # project curve to user_defined height sun_pts = get_sunpt(lat,centerPt,s_mth,day,shourlst,north_=north,lon=long,tZ=timeZ,scale_=100) sun_pts.extend(get_sunpt(lat,centerPt,e_mth,day,ehourlst,north_=north,lon=long,tZ=timeZ,scale_=100)) top_lst = project_curve(sun_pts,centerPt,top_plane,boundary) top_curves = map(lambda x: rs.coercecurve(x),top_lst) # temp for viz top_lst = map(lambda x: rs.CurvePoints(x),top_lst) top_pts = map(lambda x: rs.coerce3dpoint(x),\ reduce(lambda i,j:i+j,top_lst)) # convex hull methods chull_pts = CH.convex_hull(top_pts) chull_crv = rs.AddCurve(chull_pts + [chull_pts[0]],1) #chull_centerPt = rs.CurveAreaCentroid(chull_crv)[0] # adjust curve directions #if not rs.CurveDirectionsMatch(boundary,chull_crv): # rs.ReverseCurve(boundary) #b = rs.CurvePoints(boundary) + rs.CurvePoints(chull_crv) #c = rs.CurvePoints(chull_crv) return (boundary,chull_crv),top_curves
def CalculateColor(i): Vertex = MeshObj.Vertices[i] Point = rs.coerce3dpoint(Vertex) if bb.IsPointInside(Point, tol, True) == False: Color = White else: CP = Brep.ClosestPoint(Point) Distance = Point.DistanceTo(CP) Color = None if Distance < Range[0]: Color = Colors[3] # Green # elif Distance < Range[1]: if Brep.IsPointInside(Point, tol, True) == True: Color = Colors[4] #Too Low else: Color = Colors[2] #Too High elif Distance < Range[2]: if Brep.IsPointInside(Point, tol, True) == True: Color = Colors[5] #Too Low else: Color = Colors[1] #Too High # Outside Range # else: if Brep.IsPointInside(Point, tol, True) == True: Color = Colors[6] #Too Low else: Color = Colors[0] #Too High ColorList[i] = Color
def filterObjects(objs): new_list = [] for obj in objs: if rs.LayerVisible( rs.ObjectLayer(obj) ): # only export visible layers if rs.IsCurve(obj): new_list.append(obj) elif rs.IsPoint(obj): # convert to circle layer = rs.ObjectLayer(obj) point=rs.coerce3dpoint(obj) circle = rs.AddCircle(rs.WorldXYPlane(),3) rs.ObjectLayer(circle, layer) rs.MoveObject(circle, [point.X, point.Y, point.Z]) new_list.append(circle) rs.DeleteObject(obj) # rs.DeleteObject(point) else: # remove from obj list rs.DeleteObject(obj) else: # remove from obj list rs.DeleteObject(obj) return new_list
def Flows(strSrf,step,iterations): global p3dDropsPos global p3dDropProj print "Longitud de la matriz de puntos proyectados: " + str(len(p3dDropProj)) lines = [] for i in range(0,len(p3dDropProj)): for j in range(iterations): p3dDummy0 = rs.coerce3dpoint(p3dDropProj[i]) puvClosest0 = rs.SurfaceClosestPoint(strSrf,p3dDropProj[i]) v3dNormal = rs.SurfaceNormal(strSrf,puvClosest0) v3dMovement = rs.VectorScale(rs.VectorUnitize((v3dNormal[0],v3dNormal[1],0)),step) p3dDropProj[i] = rs.PointAdd(p3dDummy0,v3dMovement) puvClosest1 = rs.SurfaceClosestPoint(strSrf,p3dDropProj[i]) #print puvClosest1 p3dDummy1 = rs.EvaluateSurface(strSrf,puvClosest1[0],puvClosest1[1]) p3dDropProj[i] = p3dDummy1 #print str(rs.coerce3dpoint(p3dDummy0)) + '|| ' + str(rs.coerce3dpoint(p3dDummy1)) dblLenCheck = rs.Distance(p3dDummy0,p3dDummy1) strTrail = rs.AddLine(p3dDummy0,p3dDummy1) if dblLenCheck>0.01 and rs.IsCurve(strTrail): lines.append(strTrail) else: break
def falls(self,strSrf): p3dProjectedPt = rs.ProjectPointToSurface(self.p3dLocation,strSrf,(0,0,-1)) #print p3dProjectedPt #if p3dProjectedPt != None: self.p3dLocation = rs.coerce3dpoint(p3dProjectedPt[0]) #print self.p3dLocation rs.AddPoint(self.p3dLocation)
def Get_SelectPointOnMeshEdge(self, message_0, message_1): """Performs 90Lap joint boolean operation to beam object: Parameters ---------- message_0: First message to user message_1: Second message to user Return: ------ Point3D """ go = Rhino.Input.Custom.GetObject() go.SetCommandPrompt(message_0) go.GeometryFilter = Rhino.DocObjects.ObjectType.MeshEdge go.SubObjectSelect = True go.GroupSelect = False go.AcceptNothing(True) if go.Get() != Rhino.Input.GetResult.Object: return objref = go.Object(0) index = objref.GeometryComponentIndex.Index mesh = objref.Mesh() edge_line = mesh.TopologyEdges.EdgeLine(index) gp = Rhino.Input.Custom.GetPoint() gp.SetCommandPrompt(message_1) gp.Constrain(edge_line) get_rc = gp.Get() placed_point = rs.coerce3dpoint(sc.doc.Objects.AddPoint(gp.Point())) sc.doc.Views.Redraw() return placed_point
def ptCheck(a): #determines if the submitted point is a point object in space or array value #if object is #designation implemented to determine if it is not a point object designation = 0 try: if rs.ObjectType(a) == 1: #collect point object value b = rs.coerce3dpoint(a) elif rs.ObjectType(a)!= 1: #item is not a point designation = 1 except: #item already an array object for use b = a #exporting value if designation == 0: return b #not a point object else: rs.UnselectAllObjects() print "Collecting point value but is another object type" rs.SelectObject(a) exit()
def checkInputs(): #Set a default view resolution. if _viewResolution_ == None: viewRes = 1 else: viewRes = _viewResolution_ #Set a default parallel. if parallel_ == None: parallel = False else: parallel = parallel_ #Check to to see if the connected _testPts are points or planes. checkData = True viewMethod = 0 viewPoints = [] viewPtNormals = [] for point in _testPtsOrPlanes: try: #The user has connected planes. viewPoints.append(point.Origin) viewPtNormals.append(point.Normal) viewMethod = 1 except: #The user has connected points. try: viewPoints.append(rc.Geometry.Point3d(point)) if viewMethod == 1: checkData = False except: viewPoints.append(rc.Geometry.Point3d(rs.coerce3dpoint(point))) if checkData == False: warning = "_testPtsOrPlanes can be either points or planes but not both." print warning ghenv.Component.AddRuntimeMessage(w, warning) return checkData, viewRes, viewMethod, viewPoints, viewPtNormals, parallel
def RemoveDuplicatePts(points): # Create a dictionary to keep track of the Id pointDict = {} ptList = [] for pt in points: pt3d = rs.coerce3dpoint(pt) pointDict[pt3d] = pt ptList.append(pt3d) #sortList ptList.sort() ptLast = ptList[-1] tol = sc.doc.ModelAbsoluteTolerance for i in range(len(ptList)-2,-1,-1): if (abs(ptList[i][0]-ptLast[0]) < tol) and (abs(ptList[i][1]-ptLast[1])) < tol and (abs(ptList[i][2]-ptLast[2]) < tol): del ptList[i] else: ptLast = ptList[i] #find the the ids with the new list outputList = [] for pt in ptList: ptId = pointDict[pt] outputList.append(ptId) return outputList
def MakePlan(elevation, viewDepthZ, geos): objs = rs.CopyObjects(geos) rs.HideObjects(geos) ############################################################################ print "Cutting Plan" allCrvs = [] #Make plane plane = Rhino.Geometry.Plane(rs.coerce3dpoint((0, 0, elevation)), rs.coerce3dvector((0, 0, 1))) planeNeg = Rhino.Geometry.Plane(rs.coerce3dpoint((0, 0, viewDepthZ)), rs.coerce3dvector((0, 0, 1))) ############################################################################ #Partition the geometry partitionedObjs = PartitionGeometry(objs, elevation, viewDepthZ) ############################################################################ #Intersection Curves #interCrvs = IntersectGeos(partitionedObjs[1], plane) ############################################################################ #Split Geometry #Get the bottom half of intersecting objs belowObjs = SplitGeometry(partitionedObjs[1], plane) print "A" #Get the top half of that previous geometry visibleObjs = SplitGeometry(partitionedObjs[0] + belowObjs, planeNeg, -1) rs.SelectObjects(visibleObjs) objs2del = rs.InvertSelectedObjects() rs.DeleteObjects(objs2del) print "A" ############################################################################ #Make 2D allCrvs += ProjectPlan(visibleObjs, plane) rs.DeleteObjects(visibleObjs) print "Plan Cut" rs.ShowObjects(geos) rs.HideObjects(allCrvs) return allCrvs
def PyramidCollar(treeIn, treeOut, ratioOut): Pmax = GridCornerBig(treeIn) Xmax = Pmax.X Ymax = Pmax.Y Zmax = Pmax.Z Pmin = GridCornerSmall(treeIn) Xmin = Pmin.X Ymin = Pmin.Y Zmin = Pmin.Z for i in range(treeIn.BranchCount): treeBranch = treeIn.Branch(i) treePath = treeIn.Path(i) for j in range(treeBranch.Count): elem = treeBranch[j] x = elem.X y = elem.Y z = elem.Z Xr = x / Xmax Yr = y / Ymax if Zmax == 0: Zr = 0 else: Zr = z / Zmax P1 = rs.AddPoint(Xmin, Ymin, z) P1 = rs.coerce3dpoint(P1) P2 = rs.AddPoint(Xmin, Ymax, z) P2 = rs.coerce3dpoint(P2) P3 = rs.AddPoint(Xmax, Ymin, z) P3 = rs.coerce3dpoint(P3) P4 = rs.AddPoint(Xmax, Ymax, z) P4 = rs.coerce3dpoint(P4) path = ghpath(treePath.AppendElement(j)) treeOut.Add(P1, path) treeOut.Add(P2, path) treeOut.Add(P3, path) treeOut.Add(P4, path) ratioOut.Add(Xr, path) ratioOut.Add(Yr, path)
def align_dims(): if not sc.doc.Views.ActiveView.ActiveViewport.CameraZ == Rhino.Geometry.Plane.WorldXY.ZAxis: print "this works only in top view (world XY)" return """ align vertical dimensions horizontally or horizontal dimensions vertically version 1.0 www.studiogijs.nl """ dims = rs.GetObjects("select dims to align", preselect=True, filter=512) if not dims: return p_ref = rs.GetPoint("set basepoint for the dimensions", in_plane=True) if not p_ref: return p_ref = rs.coerce3dpoint(p_ref) dims = [rs.coercerhinoobject(dim) for dim in dims] for dim in dims: vertical = False horizontal = False rc, e1, e2, a1, a2, dp, tp = dim.Geometry.Get3dPoints() if not rc: return #check arrow endpoints to see if dim is vertical or horizontal if a1.Y == a2.Y: horizontal = True if a1.X == a2.X: vertical = True if not (horizontal or vertical): continue #next dimension #make sure all points are set relative to e1 #for SetLocations method we need positions of dimension #extension lines and text position tp -= e1 p_r = p_ref - e1 e2 -= e1 if horizontal: #make 2dpoints for setting the new location #sometimes dimension plane is inverted #depending on where the endpoints wer picked px = dim.Geometry.Plane.XAxis.X #plane x-axis is (1,0,0) or (-1,0,0) py = dim.Geometry.Plane.YAxis.Y #plane y-axis is (0,1,0) or (0,-1,0) dp_new = Rhino.Geometry.Point2d(tp.X * px, p_r.Y * py) e1_new = Rhino.Geometry.Point2d(0, 0) e2_new = Rhino.Geometry.Point2d(e2.X * px, e2.Y * py) elif vertical: #make 2dpoints for setting the new location #notice that vertical dimensions have their plane rotated 90 degrees #sometimes dimension plane is inverted px = dim.Geometry.Plane.XAxis.Y #plane x-axis is (0,-1,0) or (0,1,0) py = dim.Geometry.Plane.YAxis.X #plane y-axis is (1,0,0) or (-1,0,0) dp_new = Rhino.Geometry.Point2d(tp.Y * px, p_r.X * py) e1_new = Rhino.Geometry.Point2d(0, 0) e2_new = Rhino.Geometry.Point2d(e2.Y * px, e2.X * py) #perform the move dim.Geometry.SetLocations(e1_new, e2_new, dp_new) dim.CommitChanges()
def system_guid_obj_to_coordinate(self): """System.GuidObjectをRhino.Objectに変換。クラス変数に座標値を保持させる""" p = rs.coerce3dpoint(self.point) self.x = p[0] self.y = p[1] self.z = p[2] self.coordinate = [p[0], p[1], p[2]]
def estendeFG(linha,corda,ponto): linnha = rs.coerceline(linha) ponto = rs.coerce3dpoint(ponto) if not gh.CurveXCurve(linha,corda)[0]: pt =gh.EndPoints(linha)[0] construc_aux.append(Line(pt,ponto)) return True else: return False
def set_control_vertices(self, line): if tryRhino: pt = [float(el) for el in line] #pt = rs.AddPoint(pt[0],pt[1],pt[2]) pt = rs.coerce3dpoint(pt) self.control_vertices.append(pt) else: self.control_vertices.append([float(el) for el in line]) self.weights = [1. for el in self.control_vertices] return
def myPos(I, J, LISTOFCELLS): xPos = J * cellsize yPos = I * -cellsize zPos = LISTOFCELLS[I][J] if zPos == -9999: zPos = 0 if geoL == True: xPos = xPos + xllcorner yPos = yPos + yllcorner + (cellsize * nrows) return rs.coerce3dpoint([xPos, yPos, zPos])
def GetPointDynamicDrawFunc(sender, args): point_b = args.CurrentPoint point_C = Rhino.Geometry.Point3d((point_a.X + point_b.X) / 2, (point_a.Y + point_b.Y) / 2, (point_a.Z + point_b.Z) / 2) #Rhino.Geometry.Transform.Translation( vec = rs.VectorCreate(point_b, point_a) rs.VectorUnitize(vec) vec2 = rs.VectorScale(vec, 500) vec3 = rs.coerce3dpoint(rs.VectorAdd(point_b, vec2)) rs.VectorReverse(vec2) vec4 = rs.coerce3dpoint(rs.VectorSubtract(point_b, vec2)) args.Display.DrawLine(point_a, vec3, line_color_1, 1) args.Display.DrawLine(point_a, vec4, line_color_1, 1) args.Display.DrawPoint(point_a, Rhino.Display.PointStyle.ControlPoint, 3, line_color_1) args.Display.DrawPoint(point_b, Rhino.Display.PointStyle.ControlPoint, 3, line_color_2)
def MakePlanPreview(num): points = [(0, 0, 0 + i) for i in num] vec_p = [rs.VectorCreate(i, (0,0,0)) for i in points] guid = [] origin = [] for i in vec_p: guid.append(rs.CopyObject(point_p, i)) for i in guid: origin.append(rs.coerce3dpoint(i))# ガイドから3dpointに変換 return origin
def check_pt_inputs(self): try: self._pt_lst = map(lambda p: rs.coerce3dpoint(p), _pt_lst) check_data = True except: warning = 'Could not coerce points. Check your point geometry inputs!' print warning ghenv.Component.AddRuntimeMessage( gh.GH_RuntimeMessageLevel.Warning, warning) check_data = False return check_data
def unfilletCurve(curve): rs.EnableRedraw(False) curLay = rs.CurrentLayer() childrenLay = rs.LayerChildren(curLay) cutCrvs = [] contours = [] finalLines = [] finalLineSegs = [] tempCrv = curve if tempCrv is not None: cutCrvs.append(tempCrv) for crv in cutCrvs: contours.append(ghcomp.Explode(crv, True)[0]) for contour in contours: for i in range(0, len(contour)): if rs.IsLine(contour[i]): finalLines.append(sc.doc.Objects.AddCurve(contour[i])) finalPts = [] for line in finalLines: rs.ExtendCurveLength(line, 0, 2, 300) for i in range(0, len(finalLines) - 1): tempPt = rs.CurveCurveIntersection(finalLines[i], finalLines[i + 1]) finalPts.append(rs.AddPoint(rs.coerce3dpoint(tempPt[0][1]))) tempPt = rs.CurveCurveIntersection(finalLines[-1], finalLines[0]) finalPts.append(rs.AddPoint(rs.coerce3dpoint(tempPt[0][1]))) for i in range(0, len(finalPts) - 1): finalLineSegs.append(rs.AddLine(finalPts[i], finalPts[i + 1])) finalLineSegs.append(rs.AddLine(finalPts[-1], finalPts[0])) lastCrv = rs.JoinCurves(finalLineSegs, True) sc.doc.Views.Redraw() rs.DeleteObjects(finalPts) rs.DeleteObjects(finalLines) rs.DeleteObject(tempCrv) rs.DeleteObjects(cutCrvs) rs.EnableRedraw(True) rs.SelectObject(lastCrv)
def get_sunpt(lb_sunpath,lb_preparation,lat,cpt,month,day,hourlst,north_=0,lon=0,tZ=0,scale_=100): """modifed from Ladybug""" sunpt_lst = [] for hour in hourlst: centerPt = rs.coerce3dpoint(cpt) northAngle_, northVector = lb_preparation.angle2north(north_) lb_sunpath.initTheClass(lat,northAngle=northAngle_,cenPt=centerPt,\ scale=scale_,longtitude=lon, timeZone=tZ ) lb_sunpath.solInitOutput(month,day,hour) sunpt_lst.append(lb_sunpath.sunPosPt()[2]) # basePoint.Location #return sunSphereMesh, sunVector, basePoint.Location return sunpt_lst
def MoveGridToOrigo(treeIn, treeOut): RacsOrigo = GridCornerSmall(treeIn) RacsOrigo = rs.coerce3dpoint(RacsOrigo) ORIGO = rs.AddPoint(0, 0, 0) ORIGO = rs.coerce3dpoint(ORIGO) # A kiindulasi racs eltolasa Eltolas = ORIGO - RacsOrigo Eltolas = rs.coerce3dpoint(Eltolas) for i in range(treeIn.BranchCount): treeBranch = treeIn.Branch(i) treePath = treeIn.Path(i) for j in range(treeBranch.Count): point = treeBranch[j] + Eltolas point = rs.coerce3dpoint(point) treeOut.Add(point, treePath)
def Falls(strSrf): global p3dDropsPos global p3dDropProj for i in range(len(p3dDropsPos)): p3dProjectedPt = rs.ProjectPointToSurface(p3dDropsPos[i],strSrf,(0,0,-1)) #print p3dProjectedPt if len(p3dProjectedPt)>0: p3dDropProj.append(rs.AddPoint(rs.coerce3dpoint(p3dProjectedPt[0]))) if not rs.IsLayer("Drops"): rs.AddLayer("Drops",(30,30,255)) rs.ObjectLayer(p3dDropProj,"Drops")
def getpoints4lot(self,lots_,cpt_,value_ref_,actual_value_ref_): ## Loop through tree lots and add the point_nodes ## to each lot; returns lst of (listof points inside each lot) ## bpt_lst,lots: listof(listof(point data) debug = sc.sticky['debug'] lst_bpt_lst_ = [] lst_val_lst_ = [] lst_val_lst_actual_ = [] for j,lot in enumerate(lots_): boundary = lot.shape.bottom_crv neighbor = [] neighbor_val= [] neighbor_val_actual = [] # look through all cpts from dpts and add to neighborlst for i,cp in enumerate(cpt_): movedist = abs(lot.shape.cpt[2]-cp[2]) if abs(movedist-0.0)>0.1: if lot.shape.cpt[2] < cp[2]: movedist *= -1 vec = rc.Geometry.Vector3d(0,0,movedist) else: vec = rc.Geometry.Vector3d(0,0,0) if not lot.shape.is_guid(cp): cp = sc.doc.Objects.AddPoint(cp) copy_cp = rs.CopyObject(cp,vec) #copy_cp = rs.coerce3dpoint() #copy_cp = cp in_lot = 0 try: in_lot = int(rs.PointInPlanarClosedCurve(copy_cp,boundary,lot.shape.cplane)) except: pass #0 = point is outside of the curve #1 = point is inside of the curve #2 = point in on the curve if abs(float(in_lot) - 1.) <= 0.1: cp = rs.coerce3dpoint(cp) neighbor.append(cp)#,datalst[i]]) neighbor_val.append(value_ref_[i]) neighbor_val_actual.append(actual_value_ref_[i]) #d = rs.AddPoint(copy_cp[0], copy_cp[1],0) #debug.append(d) lst_bpt_lst_.append(neighbor) lst_val_lst_.append(neighbor_val) lst_val_lst_actual_.append(neighbor_val_actual) return lst_bpt_lst_,lst_val_lst_,lst_val_lst_actual_
def Flows(strSrf,step,iterations,p3dDropProj2,intCount): #New variable for setting a break point intCount = intCount+1 #Setting lists p3dDummy1 = [] p3dUV = [] v3dNormal = [] v3dUni = [] p3dDummy2 = [] lineDummy = [] lineProy = [] p3dDropEnd = [] p3dDrop = [] lineProyTest = [] #Tomamos los ptos proyectados y sacamos coordenadas for i in range (len(p3dDropProj2)): #obtenemos pto en srf #obtenemos su uv p3dDummy1.append(rs.coerce3dpoint(p3dDropProj2[i])) p3dUV.append(rs.SurfaceClosestPoint(strSrf,p3dDummy1[i])) #sacamos la normal en ese pto a la srf #hacemos unitario el vector #desplazamos el pto v3dNormal.append(rs.SurfaceNormal(strSrf,p3dUV[i])) v3dUni.append(rs.VectorUnitize(v3dNormal[i])) p3dDummy2.append(rs.PointAdd(p3dDummy1[i],v3dUni[i])) #anadimos linea #Proyectamos la linea sobre la superficie #borramos los pelos lineDummy.append(rs.AddLine(p3dDummy1[i],p3dDummy2[i])) lineProyTest.append(rs.ProjectCurveToSurface(lineDummy[i],strSrf,(0,0,-1))) rs.DeleteObjects(lineDummy[i]) #Nueva lista eliminando los nones de la anterior (NEW! - USING FILTER) lineProy = filter(None,lineProyTest) for i in range (len(lineProy)): #Buscamos el pto final de las minicurvas para empezar a iterar p3dDropEnd.append(rs.CurveEndPoint(lineProy[i])) #set a Break Point if intCount<iterations: Flows(strSrf,step,iterations,p3dDropEnd,intCount)
pts = [] for j in itertools.islice(lineConstrainedPoints.Branch(i),1,None): if j is not None: pts.append (j) parts = DynamicRelaxation.makeForceConstraintsFromList(ps,makePtsFromRhino(pts),makePtFromRhino(vect), False) allLineConstraints.append(parts) #### rail constrained points allRailConstraints = [] for i in range(railConstrainedPoints.BranchCount): if len(railConstrainedPoints.Branch(i))>1 and railConstrainedPoints.Branch(i)[1] is not None: rail = CurveConstraint(rs.coercecurve(railConstrainedPoints.Branch(i)[0])) pts = [] for j in itertools.islice(railConstrainedPoints.Branch(i),1,None): if j is not None: pts.append (rs.coerce3dpoint(j)) parts, springs = DynamicRelaxation.makePositionSpringConstraintsFromList(ps, makePtsFromRhino(pts),rail.apply, 1000, 0) allRailConstraints.append(parts) #### plane constrained points allPlaneConstraintPoints = [] for i in range(planeConstrainedPoints.BranchCount): if len(planeConstrainedPoints.Branch(i))>1: plVect = makePtFromRhino(planeConstrainedPoints.Branch(i)[0]) pts = [] for j in itertools.islice(planeConstrainedPoints.Branch(i),1,None): if j is not None: pts.append (j) parts = DynamicRelaxation.makeForceConstraintsFromList(ps,makePtsFromRhino(pts),plVect) allPlaneConstraintPoints.append(parts)
def checkTheInputs(): # Set default scale. scale = 1 if _scale_ != None: if _scale_ > 0: scale = _scale_ else: warning = "_scale_ must be greater than 0." print warning ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning) return -1 # Set default sky density. if _skyDensity_ != None: if _skyDensity_ >= 0: skyDensity = int(_skyDensity_*100) else: warning = "skyDensity_ must be greater than 0." print warning ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning) return -1 else: skyDensity = 100 # Check the view point or plane. viewMethod = 0 viewPlane = None if _centerPtOrPlane_ == None: centerPt = rc.Geometry.Point3d.Origin else: try: #The user has connected planes. centerPt = _centerPtOrPlane_.Origin viewPlane = rc.Geometry.Plane(_centerPtOrPlane_) viewMethod = 1 except: #The user has connected points. try: centerPt = rc.Geometry.Point3d(_centerPtOrPlane_) except: try: centerPt = rc.Geometry.Point3d(rs.coerce3dpoint(_centerPtOrPlane_)) except: warning = "_centerPtOrPlane_ is neither a point or a plane." print warning ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning) return -1 # Check the orientation. if orientation_ != None: if orientation_.lower() == "north": orientVector = rc.Geometry.Vector3d(0,1,0) elif orientation_.lower() == "east": orientVector = rc.Geometry.Vector3d(1,0,0) elif orientation_.lower() == "south": orientVector = rc.Geometry.Vector3d(0,-1,0) elif orientation_.lower() == "west": orientVector = rc.Geometry.Vector3d(-1,0,0) else: try: orientAngle = float(orientation_) if orientAngle > 360 or orientAngle < 0: warning = "orientation_ must be between 0 and 360." print warning ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning) return -1 orientVector = rc.Geometry.Vector3d(0,1,0) orientVector.Rotate(math.radians(-orientAngle), rc.Geometry.Vector3d.ZAxis) except: warning = "orientation_ input is not valid." print warning ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning) return -1 viewMethod = 1 viewPlane = rc.Geometry.Plane(centerPt, orientVector) # Check the overhang, left fin, and right fin projections. if overhangProject_ != None: if overhangProject_ < 0 or overhangProject_ > 90: warning = "overhangProject_ should be between 0 and 90." print warning ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning) return -1 if leftFinProject_ != None: if leftFinProject_ < 0 or leftFinProject_ > 180: warning = "leftFinProject_ should be between 0 and 180." print warning ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning) return -1 if rightFinProject_ != None: if rightFinProject_ < 0 or rightFinProject_ > 180: warning = "rightFinProject_ should be between 0 and 180." print warning ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning) return -1 return viewMethod, centerPt, viewPlane, scale, skyDensity
----------------""" import copy import scriptcontext as sc import rhinoscriptsyntax as rs import clr clr.AddReference("Grasshopper") from Grasshopper.Kernel.Data import GH_Path from Grasshopper import DataTree if run: rule = DataTree[object]() rule_ = [\ ['bula', True],\ ['grammar_key','bula'],\ ['bula_point_lst', map(lambda pt: rs.coerce3dpoint(pt), analysis_ref)],\ ['bula_value_lst', value_ref],\ ['end_rule']] for i, r in enumerate(rule_): rule.Add(r) else: rule = []
def PlaneRemapToPlaneSpace(plane_guid, point): plane_obj = rs.coerceplane(plane_guid) (status, point) = plane_obj.RemapToPlaneSpace(rs.coerce3dpoint(point)) return point
def convertToArrayPoint3d(points): pArray = System.Array.CreateInstance(Rhino.Geometry.Point3d, len(points)) arrPoints = List[System.Array[Point3d]]([pArray]) for i in range(len(points)): pArray[i] = rs.coerce3dpoint(points[i]) return arrPoints
def convert_pts(self,pt): rc_pt = map(lambda p: rs.coerce3dpoint(p),pt) return map(lambda y: Vector(y[0],y[1],y[2]),rc_pt)
''' Created on 16/07/2014 @author: krnj ''' import rhinoscriptsyntax as rs if debug: import pydevd as py py.settrace() def midPoint(p1,p2): #p3 = rs.MoveObject(p1, p1+p2) mPt = (p1+p2)/2 return mPt if pt1 and pt2: pt1 = rs.coerce3dpoint(pt1) pt2 = rs.coerce3dpoint(pt2) a = midPoint(pt1,pt2) print pt1.__getattribute__(Guid)