def GridCornerSmall(treeIn): listIn = TreeToList(treeIn) cor_x = [] cor_y = [] cor_z = [] for i in listIn: cX = i.X cY = i.Y cZ = i.Z cor_x.append(cX) cor_y.append(cY) cor_z.append(cZ) cor_x.sort() cor_y.sort() cor_z.sort() corx_min = (cor_x[0]) cory_min = (cor_y[0]) corz_min = (cor_z[0]) cor_x.reverse() cor_y.reverse() cor_z.reverse() corx_max = (cor_x[0]) cory_max = (cor_y[0]) corz_max = (cor_z[0]) SmallCorner = rs.AddPoint(corx_min, cory_min, corz_min) SmallCorner = rs.coerce3dpoint(SmallCorner) BigCorner = rs.AddPoint(corx_max, cory_max, corz_max) BigCorner = rs.coerce3dpoint(BigCorner) return (SmallCorner)
def draw_rectangle_2(p, theta): t = 1 p0 = rs.AddPoint(p) p1 = rs.CopyObject(p0, polar(t, theta + 11, 0)) p2 = rs.CopyObject(p0, polar(t, theta + 169, 0)) p3 = rs.CopyObject(p0, polar(t, theta - 169, 0)) p4 = rs.CopyObject(p0, polar(t, theta - 11, 0)) rec = [ rs.AddLine(p1, p2), rs.AddLine(p2, p3), rs.AddLine(p3, p4), rs.AddLine(p4, p1) ] return rec
def CSVlist(): #prompt the user for a file to import filter = "CSV file (*.csv)|*.csv|*.txt|All Files (*.*)|*.*||" filename = rs.OpenFileName("Open Point File", filter) if not filename: return with open(filename) as csvfile: reader = csv.reader(csvfile) for row in reader: x = float(row[0]) y = float(row[1]) z = float(row[2]) print x, y, z rs.AddPoint(x,y,z)
def branchingDLA_MAIN(): #nodes = [ ] #create root node nodes = [node([0,0,0],0,1)] rNodes = [rs.AddPoint(nodes[0].posVec)] speed = .5 #rhino units per iteration stickRange = 1.5 nThrows = 300 boundRadius = 10.0 rs.AddCircle([0,0,0],boundRadius) for i in range(nThrows): throwNode(nodes,speed,stickRange,rNodes,boundRadius)
def AnnotateCurveEndPoints(): print "annotateCurveEndPoints" #Annotates the endpoints of curve objects. If the curve is closed then only the starting point is annotated. # get the curve object objectId = rs.GetObject("Select curve", rs.filter.curve) if objectId is None: return # Add the first annotation point = rs.CurveStartPoint(objectId) rs.AddPoint(point) #textDot is out of scale #rs.AddTextDot(point, point) txtString = meters(point) rs.AddText(txtString, point, 1000 ) print (point.X + point.Y + point.Z) # Add the second annotation if not rs.IsCurveClosed(objectId): point = rs.CurveEndPoint(objectId) rs.AddPoint(point) txtString = meters(point) rs.AddText(txtString, point, 1000 )
def intersect_surfaces(guids): """Intersects all surfaces in model. Uses python cmd line, not api.""" sc.doc.Views.Redraw() rs.UnselectAllObjects() layer('INTS_BOX') rs.SelectObjects(guids.boxes) rs.Command('_Intersect', echo=False) rs.UnselectAllObjects() layer('INTS') rs.SelectObjects(guids.fractures) rs.Command('_Intersect', echo=False) frac_isect_ids = rs.LastCreatedObjects() rs.UnselectAllObjects() if frac_isect_ids: for intid in frac_isect_ids: if rs.IsCurve(intid): rs.AddPoint(rs.CurveStartPoint(intid)) rs.AddPoint(rs.CurveEndPoint(intid)) if len(frac_isect_ids) > 1: rs.SelectObjects(frac_isect_ids) rs.Command('_Intersect', echo=False) if rs.IsLayer('INTS_BOX_INT'): layer('INTS_BOX_INT') rs.UnselectAllObjects() rs.SelectObjects(guids.boxes_int) rs.SelectObjects(guids.fractures) rs.Command('_Intersect', echo=False) frac_isect_ids = rs.LastCreatedObjects() rs.UnselectAllObjects() if frac_isect_ids: for intid in frac_isect_ids: if rs.IsCurve(intid): rs.AddPoint(rs.CurveStartPoint(intid)) rs.AddPoint(rs.CurveEndPoint(intid)) if len(frac_isect_ids) > 1: rs.SelectObjects(frac_isect_ids) rs.Command('_Intersect', echo=False)
def _CreateConstructionGeometry(self): self.PCG1 = rs.AddPoint([-100,-100,0]) self.PCG2 = rs.AddPoint([-100,100,0]) self.PCG3 = rs.AddPoint([100,100,0]) self.PCG4 = rs.AddPoint([100,-100,0]) self.XoY_Plane = rs.AddSrfPt([self.PCG1, self.PCG2, self.PCG3, self.PCG4]) self.PCG5 = rs.AddPoint([3,3,0]) self.PCG6 = rs.AddPoint([3,3,100]) self.ProjVectorZ = rs.VectorCreate(self.PCG5, self.PCG6)
def vert3_to_points(self, vert3): # print(vert3) points = [] for i in xrange(len(vert3)): vert = vert3[i] # print(vert) p = rs.AddPoint(vert) points.append(p) points_geo = rs.coerce3dpointlist(points) return points_geo
def Main(): n = 50 radius = 3 for i in range(0, n): # notice how range() accepts variables # a little trick here: as i goes from 0 to n-1, k will go from 0 to 1 k = i / (n - 1) # traverse the full circle angle = k * 2 * math.pi # and now, work that trigonometry rs.AddPoint([radius * math.cos(angle), radius * math.sin(angle), 0])
def draw(self): for i in range(self.uNum + 1): for j in range(self.vNum + 1): pt = self.getPt(i, j) rs.AddPoint(pt) rs.AddText(str(i) + ',' + str(j), pt, height=0.2) # # return self #eof #eoc
def param(self): #print " check " dome = rs.CurveDomain(self.c1) #print dome #domain remaping domemin = dome[0] domemax = dome[1] pointList1 = [] pointList2 = [] #iterations of i for i in range(0, self.numberD + 1): #parameter defined to evaluate the tangent of curve parameter = (domemax - domemin) / self.numberD * i pt = rs.EvaluateCurve(self.c1, parameter) tn = rs.CurveTangent(self.c1, parameter) tn = rs.VectorUnitize(tn) tn = rs.VectorScale(tn, self.scale) point1 = rs.AddPoint(pt) rs.AddPoint(tn) point2 = rs.VectorAdd(pt, tn) rs.AddLine(pt, point2) pointList1.append(point1) pointList2.append(point2) return [pointList1, pointList2]
def equilateralPolygon(sides, size): cornerpoints = [] cornerpoint = rs.AddPoint(0, size, 0) cornerpoints.append(cornerpoint) for points in range(1, sides, 1): anothercorner = rs.RotateObject(cornerpoint, (0, 0, 0), points * 360 / sides, None, copy=True) cornerpoints.append(anothercorner) print(cornerpoints) rs.AddLine(cornerpoints[0], cornerpoints[1]) rs.AddLine(cornerpoints[1], cornerpoints[2])
def _clear_objects(cls): """Deletes all drawn objects, including locked objects, if any. Returns: n_objects int. The number of objects deleted, if successful """ dummy_point = rs.AddPoint(0, 0, 0) value = rs.DeleteObject(dummy_point) include_lights = True include_grips = True objects = rs.AllObjects(include_lights, include_grips) n_objects = rs.DeleteObjects(objects) remaining_objects = rs.AllObjects(include_lights, include_grips) rs.UnlockObjects(remaining_objects) m_objects = rs.DeleteObjects(remaining_objects) return n_objects + m_objects
def MakeEllipsoidalCoordinates(treeIn, treeOut): # U1, U2, U3 meghatarozasa MaxCoord = GridCornerBig(treeIn) x_max = MaxCoord.X y_max = MaxCoord.Y z_max = MaxCoord.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 a = alpha / x_max b = beta / y_max y = y_max - y # a logikus vetites miatt U2 = x * a U3 = y * b + gap deltaZ = z_max if deltaZ != 0: deltaV = thick v = (1 - (z / deltaZ)) * deltaV else: v = 0 U2rad = math.radians(U2) U3rad = math.radians(U3) a = math.sin(U3rad) * math.sin(U3rad) b = (rad - v) * (rad - v) c = math.cos(U3rad) * math.cos(U3rad) d = (height - v) * (height - v) U1 = math.sqrt(1 / (a / b + c / d)) EllPoint = rs.AddPoint(U1, U2, U3) EllPoint = rs.coerce3dpoint(EllPoint) treeOut.Add(EllPoint, treePath)
def ptsOnSrf (): surfaceId = rs.GetObject("pick surface", 8, True, True) uVal = rs.GetInteger("pick u/row count",4, 1, 20) vVal = rs.GetInteger("pick v/col count",4, 1, 20) uDomain = rs.SurfaceDomain(surfaceId, 0) vDomain = rs.SurfaceDomain(surfaceId, 1) uStep = (uDomain[1] - uDomain[0])/ uVal vStep = (vDomain[1] - vDomain[0])/ vVal count = 0 for i in rs.frange(uDomain[0], uDomain[1], uStep): for j in rs.frange(vDomain[0], vDomain[1], vStep): point = rs.EvaluateSurface(surfaceId, i, j) newPt = rs.AddPoint(point) count += 1 rs.AddText(count,newPt, .25)
def manypoints(): pt = [] imax = rs.GetInteger("number of spheres in X-axis", 5, 1, 10) jmax = rs.GetInteger("number of spheres in Y-axis", 5, 1, 10) kmax = rs.GetInteger("number of spheres in Z-axis", 5, 1, 10) for i in rs.frange(0, imax, 1): for j in rs.frange(0, jmax, 1): for k in rs.frange(0, kmax, 1): #set up coordinate arrPointCoord = rs.AddPoint([i, j, k]) pt.append(arrPointCoord) r = 0 + (255 - 0) / (imax) * i g = 255 - (0 + (255 - 0) / (jmax) * j) b = (255 / kmax * k) rs.ObjectColor(pt, [r, g, b])
def main(): ptStart = rs.AddPoint(0,0,0) vecDir = [0,0,1] minTwigCount = 1 maxTwigCount = 5 maxGen = 5 maxTwigLength = 1 lengthMutation = .5 maxTwigAngle = 90 angleMutation = .5 newProps = minTwigCount, maxTwigCount, maxGen, maxTwigLength, lengthMutation, maxTwigAngle, angleMutation RecursiveGrowth (ptStart, vecDir, props, 0)
def createSegments(): for i in range(levels): points = [] origin = [0+random.random()*depth,0+random.random()*depth,i*levelres] point1 = rs.AddPoint(radius,0,i*levelres) points.append(point1) for i in range(1, segements): tempPoint = points[-1] tempOrgin = [origin[0] + random.random()*depth, origin[1] + random.random()*depth, origin[2]+1] newPt = rs.RotateObject(tempPoint,tempOrgin,degrees,None,True) points.append(newPt) points.append(point1) lastCircle.append(tempOrgin) polygon = rs.AddPolyline(points) lofts.append(polygon) return lofts
def plotGaussKernel(): stepSize = .01 nIter = 120 maxGrowLen = 2 minGrowLen = .001 cutoffDist = 3 s = 1.0 / (maxGrowLen * math.sqrt(2.0 * math.pi) ) # calculate s so that gauss(x=0)=maxGrowLen u = 0 gaussKernel = createGaussKernel(stepSize, maxGrowLen, minGrowLen, cutoffDist) for i in range(len(gaussKernel)): x = i * stepSize y = gaussKernel[i] rs.AddPoint(x, y, 0)
def ellipse(self, xheight, yheight, placement='center', angle=0): """xheight: the x dimension of the ellipse before rotation \n yheight: the y dimension of the ellipse before rotation \n placement: (optional) 'center' places ellipse centered around the turtle, 'edge' places ellipse to the side of the turtle \n angle: (optional) rotates ellipse around the turtle's""" centerPoint = rs.AddPoint(self.point) if placement == 'edge': centerPoint = rs.MoveObject( centerPoint, rs.VectorScale(rs.VectorCreate([1, 0, 0], [0, 0, 0]), xheight / 2)) newEllipse = rs.AddCircle(centerPoint, xheight / 2) ScaleFactor = yheight / xheight rs.ScaleObject(newEllipse, self.point, [1, ScaleFactor, 0]) newEllipse = rs.RotateObject(newEllipse, self.point, angle) rs.DeleteObject(centerPoint)
def cubecenter(self, m1, m2, m3): # a = rs.AddPoint(self.point) p = rs.GetPoint("Enter center point") a = rs.AddPoint(p) l = m1 / 2 w = m2 / 2 h = m3 / 2 b = rs.CopyObject(a, [l, w, -h]) c = rs.CopyObject(a, [l, -w, -h]) d = rs.CopyObject(a, [-l, -w, -h]) e = rs.CopyObject(a, [-l, w, -h]) f = rs.CopyObject(a, [l, w, h]) g = rs.CopyObject(a, [l, -w, h]) h = rs.CopyObject(a, [-l, -w, h]) j = rs.CopyObject(a, [-l, w, (m3 / 2)]) box = rs.AddBox([b, c, d, e, f, g, h, j])
def xyz2pts(self, FN): filepath = self._mainDIR + self._session + "\\" + FN + ".xyz" if (os.path.exists(filepath)): result = [] with open(filepath) as fp: line = fp.readline() while line: curLine = line.strip() coord = curLine.split(' ') for i in range(len(coord)): coord[i] = float(coord[i]) result.append(rs.AddPoint(coord)) line = fp.readline() return result else: raise Exception('File doesn\'t exist!')
def splitlines(lines, count): #temp list and clear input list templines = lines lines = [] pts = [] #make sure we have a way to break the recursion if count == 0: return 1 else: for line in templines: #get properties of the line (endpts, length, direction, domain) stpt = rs.CurveStartPoint(line) endpt = rs.CurveEndPoint(line) length = rs.Distance(stpt, endpt) dir1 = rs.VectorCreate(endpt, stpt) crvdomain = rs.CurveDomain(line) #parameters for midpt and pts 1/3 and 2/3 along the line t0 = crvdomain[1] / 2.0 t1 = crvdomain[1] / 3.0 t2 = t1 * 2 midpt = rs.EvaluateCurve(line, t0) ptatonethird = rs.EvaluateCurve(line, t1) ptattwothird = rs.EvaluateCurve(line, t2) midpt = rs.AddPoint(midpt) #call get normal function normal = getnormal(stpt, endpt) #move midpt perpendicular to line at 1/3 the length of the line scaled = rs.VectorScale(normal, 0.3333) rs.MoveObject(midpt, scaled) #create the 4 newlines and add them to the list newline1 = rs.AddLine(stpt, ptatonethird) newline2 = rs.AddLine(ptatonethird, midpt) newline3 = rs.AddLine(midpt, ptattwothird) newline4 = rs.AddLine(ptattwothird, endpt) lines.append(newline1) lines.append(newline2) lines.append(newline3) lines.append(newline4) #create a list of objects to delete cleanup = [] cleanup.append(line) cleanup.append(midpt) rs.DeleteObjects(cleanup) #don't forget to decrement the count otherwise infinite loop count = count - 1 return splitlines(lines, count)
def automated_smoothing_surface_constraints(mesh, surface): """Apply automatically surface-related constraints to the vertices of a mesh to smooth: kinks, boundaries and surface. Parameters ---------- mesh : Mesh The mesh to apply the constraints to for smoothing. surface : RhinoSurface A RhinoSurface object on which to constrain mesh vertices. Returns ------- constraints : dict A dictionary of mesh constraints for smoothing as vertex keys pointing to point, curve or surface objects. """ constraints = {} points = [rs.AddPoint(point) for point in surface.kinks()] curves = surface.borders(type=0) constraints.update({vkey: surface.guid for vkey in mesh.vertices()}) for vkey in mesh.vertices_on_boundary(): xyz = mesh.vertex_coordinates(vkey) projections = { curve: distance_point_point( xyz, RhinoCurve.from_guid(curve).closest_point(xyz)) for curve in curves } constraints.update({vkey: min(projections, key=projections.get)}) key_to_index = { i: vkey for i, vkey in enumerate(mesh.vertices_on_boundary()) } vertex_coordinates = tuple( mesh.vertex_coordinates(vkey) for vkey in mesh.vertices_on_boundary()) constraints.update({ key_to_index[closest_point_in_cloud(rs.PointCoordinates(point), vertex_coordinates)[2]]: point for point in points }) return constraints
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 create_connection_tangram(self, target_tangram): if self.can_grow: vector = self.get_connection_vector(self, target_tangram) ref_type = self.get_connection_type(vector) ref_tangram = self.get_growing_tangram(ref_type) face_index = self.get_connection_face(vector) can_grow = get_distance(self.center, target_tangram.get_center()) > 2 angle = self.get_connection_angle(ref_type, ref_tangram, face_index, vector) tangram_shape = create_shape(self, ref_tangram, face_index, angle) center = find_center( Brep.Vertices.GetValue(rs.coercebrep(tangram_shape))) shape_list.append(rs.AddPoint(center)) self.create_tangram(ref_type, self.classification, tangram_shape, center, can_grow, (self.target_face, self.name), face_index)
def __init__(self,radius,sides): self.radius = radius self.sides = sides theta = (2*math.pi)/self.sides print theta pt01 = rs.AddPoint(self.radius,0,0); pts = [] pts.append(pt01) self.origin = [0,0,0] degrees = theta*(180/math.pi) print degrees for i in range(1,self.sides): tempPt = pts[-1] newPt = rs.RotateObject(tempPt,self.origin,degrees,None,True) pts.append(newPt) pts.append(pt01) self.polygon = rs.AddPolyline(pts);
def define_mesh_points_triangle(self, num): pts = [] for i in xrange(num): for j in xrange(num): yy = j * (math.sin((1.0 / 3.0) * math.pi)) if j % 2 == 0: xx = i else: xx = i + (math.cos((1.0 / 3.0) * math.pi)) pts.append(rs.AddPoint(xx, yy, 0)) return pts
def make(self): self.segments = rs.ExplodeCurves(self.Rect) treadLength = rs.CurveLength(self.segments[1]) / self.numRisers riserHeight = self.deltaHeight / self.numRisers runVector = rs.VectorCreate( rs.CurveEndPoint(self.segments[1]), rs.CurveStartPoint(self.segments[1])) unitRunVec = rs.VectorUnitize(runVector) treadVec = rs.VectorScale(unitRunVec, treadLength) riseVec = rs.VectorCreate([0, 0, riserHeight], [0, 0, 0]) newPt = [ rs.CurveStartPoint(self.segments[0]).X, rs.CurveStartPoint(self.segments[0]).Y, rs.CurveStartPoint(self.segments[0]).Z - self.deltaHeight ] ptList = [] ptList.append(rs.AddPoint(newPt)) for i in range(self.numRisers): tempPt = rs.CopyObject(ptList[-1]) rs.MoveObject(tempPt, riseVec) ptList.append(tempPt) tempPt = rs.CopyObject(ptList[-1]) rs.MoveObject(tempPt, treadVec) ptList.append(tempPt) downLine = rs.VectorCreate([0, 0, 0], [0, 0, self.thickness]) newBtmPt = rs.MoveObject(rs.CopyObject(ptList[0]), downLine) ptList.insert(0, newBtmPt) newBtmPt2 = rs.MoveObject(rs.CopyObject(ptList[-1]), downLine) ptList.append(newBtmPt2) stringer = rs.AddPolyline(ptList) closeCrv = rs.AddLine(rs.CurveStartPoint(stringer), rs.CurveEndPoint(stringer)) newStringer = rs.JoinCurves([stringer, closeCrv], True) stair = rs.ExtrudeCurve(newStringer, self.segments[0]) rs.CapPlanarHoles(stair) rs.DeleteObject(stringer) rs.DeleteObject(newStringer) rs.DeleteObjects(ptList) rs.DeleteObjects(self.segments) return stair
def AddPoint(ptcordTmpPointInter, ptcordTmpPoint, ltTmpCordNum, intWhich): #to add the point into the dict ltTmpCordNumInter = [ltTmpCordNum[0], ltTmpCordNum[1]] if ptcordTmpPointInter[intWhich] < ptcordTmpPoint[intWhich]: ltTmpCordNumInter[intWhich] -= 1 if intWhich == 1: ltTmpCordNumInter[0] += 1 else: ltTmpCordNumInter[intWhich] += 1 if ((ltTmpCordNumInter[0] % 5 == 0)): rs.AddTextDot( str(ltTmpCordNumInter[0]) + "," + str(ltTmpCordNumInter[1]), ptcordTmpPointInter) dictPointByCord[ptcordTmpPointInter] = ltTmpCordNumInter dictPointByNum[tuple(ltTmpCordNumInter)] = ptcordTmpPointInter ptTmpPoint = rs.AddPoint(ptcordTmpPointInter) ltObjectPoint.append(ptTmpPoint)