def ConvertToUVW(srf_id, xyz_points): uvw_points = [] for point in xyz_points: Suv = rs.SurfaceClosestPoint(srf_id, point) Sxyz = rs.EvaluateSurface(srf_id, Suv) Snormal = rs.SurfaceNormal(srf_id, Suv) dirPos = rs.PointAdd(Sxyz, Snormal) dirNeg = rs.PointSubtract(Sxyz, Snormal) Sdist = rs.Distance(Sxyz, point) if rs.Distance(point, dirPos) > rs.Distance(point, dirNeg): Sdist = -Sdist uvw_points.append((Suv(0), Suv(1), Sdist)) return uvw_points
def get_derivation_cell_position_triples(cls, n_shapes):## 09-21 17:52 """Receives: n_shapes int >= 2. The number of labeled shapes in the derivation Calculates the positions of labeled shapes, arrows, and rule names arranged in an array. Returns: derivation_cell_position_triples [(triple)]. A list of n triples, n = n_shapes, each of the form: ( labeled_shape_position, arrow_position, rule_name_position) where each position is a triple of the form: (num, num, num) """ labeled_shape_offset = cls.derivation_labeled_shape_offset arrow_offset = cls.derivation_arrow_offset rule_name_offset = cls.derivation_rule_name_offset cell_positions = (cls._get_derivation_array_cell_positions(n_shapes)) derivation_cell_position_triples = [] for i in range(n_shapes): derivation_array_cell_position = ( cell_positions[i]) labeled_shape_position = rs.PointAdd( derivation_array_cell_position, labeled_shape_offset) arrow_position = rs.PointAdd( derivation_array_cell_position, arrow_offset) rule_name_position = rs.PointAdd( derivation_array_cell_position, rule_name_offset) position_triple = ( labeled_shape_position, arrow_position, rule_name_position) derivation_cell_position_triples.append(position_triple) return derivation_cell_position_triples
def _add_3_frame_layer(cls, layer_name, rule_spec, left_frame_position): """Receives: layer_name str left_frame_position Point3d. The location of the leftmost frame instance Draws 3 frame instances on the specified layer """ cls._add_subsequent_rule(layer_name, rule_spec, left_frame_position) frame_name = s.Settings.frame_name right_frame_offset = (100, 0, 0) right_frame_position = rs.PointAdd(left_frame_position, right_frame_offset) f.Frame.new_instance(frame_name, layer_name, right_frame_position)
def add_tickmarks(rect, len, offset): c, _ = rs.CurveAreaCentroid(rect) mirror_v = [c, rs.PointAdd(c, [0, 10, 0])] mirror_h = [c, rs.PointAdd(c, [10, 0, 0])] pts = rs.CurvePoints(rect) if not pts: return "ERROR" pts = rs.SortPoints(pts) # print pts t_0 = rs.CopyObject(pts[0], [offset, offset, 0]) t_1 = rs.CopyObject(t_0, [len, 0, 0]) t_2 = rs.CopyObject(t_0, [0, len, 0]) tick = rs.AddPolyline([t_1, t_0, t_2]) rs.DeleteObjects([t_0, t_1, t_2]) tick_2 = rs.MirrorObject(tick, mirror_v[0], mirror_v[1], True) ticks_3 = rs.MirrorObjects([tick, tick_2], mirror_h[0], mirror_h[1], True) rs.ObjectLayer([tick, tick_2] + ticks_3, LCUT_NAMES[3]) tick_list = [tick, tick_2] + ticks_3 return tick_list
def XYZ_To_UVW(srf_id, pXYZ): pUVW = [] for pt in pXYZ: uvClosest = rs.SurfaceClosestPoint(srf_id, pt) ptClosest = rs.EvaluateSurface(srf_id, uvClosest) srfNormal = rs.SurfaceNormal(srf_id, uvClosest) pPositive = rs.PointAdd(ptClosest, srfNormal) pNegative = rs.PointSubtract(ptClosest, srfNormal) fDistance = rs.Distance(ptClosest, pt) if rs.Distance(pt, pPositive) > rs.Distance(pt, pNegative): fDistance = -fDistance pUVW.append((uvClosest[0], uvClosest[1], fDistance)) return pUVW
def spiral_stairs(curve, center, start_pt, end_pt, stair_width, steps, plinth_lst, bannister_lst): height = end_pt[2] - start_pt[2] cen = rs.AddLine(center, rs.PointAdd(center, [0, 0, height])) cen_e = rs.CurveEndPoint(cen) ref_pts = [n * 1 / steps for n in range(steps + 1)] outer_pts = [rs.EvaluateCurve(curve, t) for t in ref_pts] inner_pts = [[cen_e[0], cen_e[1], cen_e[2] * t] for t in ref_pts] print(inner_pts) rise = [0, 0, height / steps] for i in range(steps): #draw rise v_ver = [ outer_pts[i], inner_pts[i], rs.PointAdd(inner_pts[i], rise), rs.PointAdd(outer_pts[i], rise) ] rs.AddSrfPt(v_ver) #draw run v_hori = [v_ver[3], v_ver[2], outer_pts[i + 1]] rs.AddSrfPt(v_hori) #draw sides s1 = rs.AddLine(outer_pts[i], rs.PointAdd(outer_pts[i], rise)) s2 = rs.AddLine(rs.PointAdd(outer_pts[i], rise), outer_pts[i + 1]) s3 = rs.AddSubCrv(curve, rs.CurveClosestPoint(curve, outer_pts[i]), rs.CurveClosestPoint(curve, outer_pts[i + 1])) rs.AddEdgeSrf([s1, s2, s3]) rs.DeleteObjects([s1, s2, s3]) if plinth_lst[0]: curvy_plinth(curve, None, stair_width, plinth_lst) if bannister_lst[0]: curvy_bannister(curve, None, stair_width, bannister_lst)
def meshLoftSections(sections, closed=True): faces = [] v = [] for i in range(len(sections)): v.extend(sections[i]) for i in range(len(sections) - 1): for j in range(len(sections[0]) - 1): index0 = i * len(sections[0]) + j index1 = i * len(sections[0]) + (j + 1) % len(sections) index2 = (i + 1) * len(sections[0]) + (j + 1) % len(sections) index3 = (i + 1) * len(sections[0]) + j faces.append([index0, index1, index2, index3]) if closed: st_cnt, en_cnt = [0, 0, 0], [0, 0, 0] for i in range(len(sections[0])): st_cnt = rs.PointAdd(st_cnt, sections[0][i]) en_cnt = rs.PointAdd(en_cnt, sections[-1][i]) st_cnt = rs.VectorScale(st_cnt, 1 / len(sections[0])) en_cnt = rs.VectorScale(en_cnt, 1 / len(sections[0])) init = 0 v.append(st_cnt) for j in range(len(sections[0]) - 1): index0 = init + j index1 = len(v) - 1 index2 = init + (j + 1) % (len(sections[0]) - 1) index3 = init + j faces.append([index0, index1, index2]) #init = len(sections)*(len(sections[0])-1) + 1 init = len(v) - 1 - len(sections[0]) v.append(en_cnt) for j in range(len(sections[0]) - 1): index0 = init + j index1 = len(v) - 1 index2 = init + j + 1 index3 = init + j faces.append([index0, index1, index2]) mesh = rs.AddMesh(v, faces)
def offsetPoints(pList, startPt, endPt): pointList = [] sideVector = rs.VectorCreate(endPt, startPt) pointSpacing = (rs.VectorLength(sideVector) / len(pList)) gapVector = rs.VectorUnitize(sideVector) gapVector = rs.VectorScale(gapVector, pointSpacing) for i in range(0, len(pList)): scaledVector = rs.VectorScale(gapVector, i) pointMove = rs.VectorAdd(startPt, scaledVector) offsetPoint = rs.VectorAdd(pointMove, pList[i] * rs.VectorLength(sideVector)) point = (0, 0, 0) movedPoint = rs.PointAdd(point, offsetPoint) pointList.append(movedPoint) return pointList
def get_arrow_position(cls, left_frame_position): ## rule arrow """Receives: left_frame_position Point3d or (num, num, num). The position of the left frame instance Returns: arrow_position Point3d. The center point of the arrow """ frame_gap_factor_x = (cls.right_frame_offset_factor - 1) / 2 arrow_offset_x = cls.frame_size[0] * (frame_gap_factor_x + 1) arrow_offset_y = cls.frame_size[1] / 2 arrow_offset_z = 0 arrow_offset = (arrow_offset_x, arrow_offset_y, arrow_offset_z) arrow_position = rs.PointAdd(left_frame_position, arrow_offset) return arrow_position
def smoothcurve(curve_id, s): curve_points = rs.CurvePoints(curve_id) new_curve_points = [] for i in range(len(curve_points) - 1): vm = smoothingvector(curve_points[i], curve_points[i - 1], curve_points[i + 1], s) new_curve_points.append(rs.PointAdd(curve_points[i], vm)) knots = rs.CurveKnots(curve_id) degree = rs.CurveDegree(curve_id) weights = rs.CurveWeights(curve_id, 0) newcurve_id = rs.AddNurbsCurve(new_curve_points, knots, degree, weights) if newcurve_id: rs.DeleteObject(curve_id) return newcurve_id
def get_right_frame_position(cls, left_frame_position): """Receives: left_frame_position Point3d or (num, num, num). The origin of the left frame block Returns: right_frame_position Point3d. The origin of the right frame block """ frame_side_x = cls.frame_size[0] right_frame_offset_x = ( frame_side_x * cls.right_frame_offset_factor) right_frame_offset = (right_frame_offset_x, 0, 0) right_frame_position = rs.PointAdd( left_frame_position, right_frame_offset) return right_frame_position
def nameTag(obj): roomName = rs.ObjectName(obj) try: text = str(roomName) pt0 = rs.BoundingBox(obj)[0] pt2 = rs.BoundingBox(obj)[2] pt = rs.PointDivide(rs.PointAdd(pt0, pt2), 2) areaTag = rs.AddText(text, pt, 1, justification=131074) except: print "Object has no name" return parentLayer = rs.ParentLayer(rs.ObjectLayer(obj)) hostLayer = rs.AddLayer("ANNO_NAME", (128, 128, 128), parent=parentLayer) rs.ObjectLayer(areaTag, hostLayer) return None
def addArc(startPt, endPt, vecDir): vecBase = rs.PointSubtract(endPt, startPt) if rs.VectorLength(vecBase) == 0.0: return if rs.IsVectorParallelTo(vecBase, vecDir): return vecBase = rs.VectorUnitize(vecBase) vecDir = rs.VectorUnitize(vecDir) vecBisector = rs.VectorAdd(vecDir, vecBase) vecBisector = rs.VectorUnitize(vecBisector) midlength = (0.5*rs.Distance(startPt, endPt)) / (rs.VectorDotProduct(vecBisector, vecDir)) vecBisector = rs.VectorScale(vecBisector, midlength) return rs.AddArc3Pt(startPt, endPt, rs.PointAdd(startPt, vecBisector))
def isometricflow(polyline=None, t=0.1): polyline = polyline or rs.GetObject("Select a polyline", rs.filter.curve, True, True) if polyline is None: return vertices = rs.PolylineVertices(polyline) n = len(vertices) - 1 lengths = [] angles = [] if vertices: for i in range(n): if i > 0: prev = i - 1 else: prev = n - 1 next = i + 1 l_i = subtract(vertices[next], vertices[i]) l_j = subtract(vertices[i], vertices[prev]) lengths.append(length(l_i)) # TODO: Is this working only for convex polygons? Does rs.VectorAngle return negative values when it's not convex? angles.append(angle(l_i, l_j)) angles_sum = sum(angles) for a in angles: a = a - t * (a - angles_sum / n) # TODO(mikhaildubov): This is a dead piece of code prev_edge = subtract(vertices[1], vertices[0]) newvertices = [vertices[0]] for i in range(1, n): newvertices.append(rs.PointAdd(newvertices[-1], prev_edge)) next_edge = scale(unit(rotate(prev_edge, angles[i], [0, 0, 1])), lengths[i]) prev_edge = next_edge newvertices.append(newvertices[0]) # first point closes the polyline # new_polyline = rs.AddPolyline(newvertices, polyline) # replaces previous polyline new_polyline = rs.AddPolyline(newvertices) # keeps previous polyline return new_polyline
def DrawFrameBySize(size,location, rightMargin, leftMargin ): width, height = GetFrameSize(size) # draw layout frame width = width*config.DRAWINGSCALE height = height*config.DRAWINGSCALE rightMargin = rightMargin*config.DRAWINGSCALE leftMargin = leftMargin*config.DRAWINGSCALE p0 = rs.PointAdd((0,0,0),location) p1 = rs.PointAdd((width,0,0),location) p2 = rs.PointAdd((width,height,0),location) p3 = rs.PointAdd((0,height,0),location) outPolyline = rs.AddPolyline([p0,p1,p2,p3,p0]) p0 = rs.PointAdd((leftMargin,rightMargin,0),location) p1 = rs.PointAdd((width-rightMargin,rightMargin,0),location) p2 = rs.PointAdd((width-rightMargin,height-rightMargin,0),location) p3 = rs.PointAdd((leftMargin,height-rightMargin,0),location) inPolyline = rs.AddPolyline([p0,p1,p2,p3,p0]) return ( outPolyline, inPolyline)
def SurfacePoints3(self): ptMTX = {} srfNORM = {} rndNORM = {} #rndptlist3 = [] Udomain = rs.SurfaceDomain(self.strsrf, 0) Vdomain = rs.SurfaceDomain(self.strsrf, 1) stepU = (Udomain[1] - Udomain[0]) / self.intu stepV = (Vdomain[1] - Vdomain[0]) / self.intv #PLOT POINTS ON SURFACE count = 0 self.rndvectorlist = self.rndvector() for i in range(self.intu + 1): for j in range(self.intv + 1): #define u and v in terms of step values and i and j u = Udomain[0] + stepU * i v = Vdomain[0] + stepV * j point = rs.EvaluateSurface(self.strsrf, u, v) ptMTX[(i, j)] = point #find normals at u,v parameters srfNORM[(i, j)] = rs.SurfaceNormal(self.strsrf, (u, v)) #CREATE GRID OF OFFSET POINTS DEFINED BY SURFACE NORMALS self.Dis = self.distance() for i in range(self.intu + 1): for j in range(self.intv + 1): srfNORM[(i, j)] = rs.VectorScale(srfNORM[(i, j)], 120000 / self.Dis[(i, j)]) srfNORM[(i, j)] = rs.PointAdd(ptMTX[(i, j)], srfNORM[(i, j)]) rndNORM[(i, j)] = rs.VectorAdd( srfNORM[(i, j)], self.rndvectorlist[count] * (800 / self.Dis[(i, j)])) count = count + 1 #rs.AddPoint(rndNORM[(i,j)]) #rs.AddPoint(ptMTX[(i,j)]) self.rndptlist3.append(rndNORM[(i, j)]) #rs.DeleteObject(rndptlist3) return self.rndptlist3
def addArcDiv(ptStart, ptEnd, vecDir): vecBase = rs.PointSubtract(ptEnd, ptStart) # error handling if rs.VectorLength(vecBase) == 0.0: return if rs.IsVectorParallelTo(vecBase, vecDir): return vecBase = rs.VectorUnitize( vecBase ) # normalize vector == force magnitude to 1 to just compare direction vecDir = rs.VectorUnitize(vecDir) vecBisector = rs.VectorAdd(vecDir, vecBase) vecBisector = rs.VectorUnitize(vecBisector) dotProd = rs.VectorDotProduct(vecBisector, vecDir) midLength = (0.5 * rs.Distance(ptStart, ptEnd)) / dotProd vecBisector = rs.VectorScale(vecBisector, midLength) return rs.AddArc3Pt(ptStart, rs.PointAdd(pt.Start, vecBisector), ptEnd)
def _point_is_in_box(cls, point, position, size): """Receives: point Point3d or (num, num, num) position Point3d or (num, num, num). The position of the box size Point3d or (num, num, num). The diagonal size of the box Returns: value boolean. True, if the point is inside or on the surface of the box """ p1 = position p2 = rs.PointAdd(p1, size) x0, y0, z0 = point x1, y1, z1 = p1 x2, y2, z2 = p2 value = (x1 <= x0 <= x2 and y1 <= y0 <= y2 and z1 <= z0 <= z2) return value
def grow(self): x1 = self.node[0][0] - (self.size[1] / 2) x2 = self.node[0][0] + (self.size[1] / 2) y1 = self.node[0][1] - (self.size[1] / 2) y2 = self.node[0][1] + (self.size[1] / 2) z1 = self.node[0][2] z2 = self.node[0][2] + self.size[0] i = 0 while i < self.twigCount: randPt = placePt(x1, x2, y1, y2, z1, z2) joinPt = self.node[rs.PointArrayClosestPoint(self.node, randPt)] vec = rs.VectorScale( rs.VectorUnitize(rs.VectorSubtract(randPt, joinPt)), self.segLength) newPt = rs.PointAdd(joinPt, vec) self.addTwig(joinPt, newPt) i += 1
def AddArcDir(ptStart, ptEnd, vecDir): vecBase = rs.PointSubtract(ptEnd, ptStart) if rs.VectorLength(vecBase) == 0.0: return if rs.IsVectorParallelTo(vecBase, vecDir): return rs.AddLine(ptStart, ptEnd) vecBase = rs.VectorUnitize(vecBase) vecDir = rs.VectorUnitize(vecDir) vecBisector = rs.VectorAdd(vecDir, vecBase) vecBisector = rs.VectorUnitize(vecBisector) dotProd = rs.VectorDotProduct(vecBisector, vecDir) midLength = (0.5 * rs.Distance(ptStart, ptEnd)) / dotProd vecBisector = rs.VectorScale(vecBisector, midLength) return rs.AddArc3Pt(ptStart, ptEnd, rs.PointAdd(ptStart, vecBisector))
def Polygon_C(Center, R, N): import rhinoscriptsyntax as rs from math import tan, pi #List Definition vertex = [] Erase = [] ##################################################################### ######## Geometric Operations ##################################################################### pt = rs.AddPoint([Center[0], Center[1] + R, Center[2]]) #angle in degrees divided by the number of sides Alf = 2. * pi / N #angle in degrees divided by the number of sides Alfa = 360. / N #you have to add a vector in the x direction which is the radius #multiplied by tangent of the angle divided by 2 pt2 = rs.PointAdd(pt, (R * tan(Alfa / 2), 0, 0)) #Draw point on rhinospace pt2 = rs.AddPoint(pt2) #Loop for the rest of the vertex for i in range(N + 1): p = rs.RotateObject(pt2, Center, i * Alfa, axis=None, copy=True) vertex.append(p) #Define Polyline rs.AddPolyline(vertex) #Finish Erase = [pt, pt2] #We extended our existing list, is equivalent to add a list to another list vertex.extend(Erase) #Delete points at vertexes rs.DeleteObjects(vertex) print("Operation complete")
def curvy_stairs(curve, start_pt, end_pt, stair_width, steps, plinth_lst, bannister_lst): ref = rs.OffsetCurve( curve, [1, 0, 0], stair_width) # create the second curve to guide the stair ref_pts = [n * 1 / steps for n in range(steps + 1) ] # guide points to divide up the curve left_pts = [rs.EvaluateCurve(curve, t) for t in ref_pts] # guide points on input curve right_pts = [rs.EvaluateCurve(ref, t) for t in ref_pts] #guide points on the offset curve height = end_pt[2] - start_pt[2] #stair height rise = [0, 0, height / steps] # a vector for i in range(steps): #draw rise v_ver = [ left_pts[i], right_pts[i], rs.PointAdd(right_pts[i], rise), rs.PointAdd(left_pts[i], rise) ] rs.AddSrfPt(v_ver) #draw run v_hori = [v_ver[3], v_ver[2], right_pts[i + 1], left_pts[i + 1]] rs.AddSrfPt(v_hori) #draw sides s1 = rs.AddLine(left_pts[i], rs.PointAdd(left_pts[i], rise)) s2 = rs.AddLine(rs.PointAdd(left_pts[i], rise), left_pts[i + 1]) s3 = rs.AddSubCrv(curve, rs.CurveClosestPoint(curve, left_pts[i]), rs.CurveClosestPoint(curve, left_pts[i + 1])) rs.AddEdgeSrf([s1, s2, s3]) rs.DeleteObjects([s1, s2, s3]) s1 = rs.AddLine(right_pts[i], rs.PointAdd(right_pts[i], rise)) s2 = rs.AddLine(rs.PointAdd(right_pts[i], rise), right_pts[i + 1]) s3 = rs.AddSubCrv(ref, rs.CurveClosestPoint(ref, right_pts[i]), rs.CurveClosestPoint(ref, right_pts[i + 1])) rs.AddEdgeSrf([s1, s2, s3]) rs.DeleteObjects([s1, s2, s3]) s1 = rs.AddLine(left_pts[0], right_pts[0]) s2 = rs.AddLine(left_pts[-1], right_pts[-1]) rs.AddEdgeSrf([s1, curve, s2, ref]) rs.DeleteObjects([s1, s2]) if plinth_lst[0]: curvy_plinth(curve, ref, stair_width, plinth_lst) if bannister_lst[0]: curvy_bannister(curve, ref, stair_width, bannister_lst)
def genIntPoly(self, poly): cen=rs.CurveAreaCentroid(poly)[0] pts=rs.CurvePoints(poly) a=[(pts[0][0]+pts[1][0])/2,(pts[0][1]+pts[1][1])/2,0] b=[(pts[0][0]+pts[3][0])/2,(pts[0][1]+pts[3][1])/2,0] vec1=rs.VectorScale(rs.VectorUnitize(rs.VectorCreate(cen,a)),self.d0/2) vec2=rs.VectorScale(rs.VectorUnitize(rs.VectorCreate(cen,b)),self.d1/2) p=rs.PointAdd(cen,vec1) q=rs.PointAdd(cen,-vec1) r=rs.PointAdd(p,vec2) u=rs.PointAdd(p,-vec2) t=rs.PointAdd(q,vec2) s=rs.PointAdd(q,-vec2) poly=rs.AddPolyline([r,u,s,t,r]) self.req_poly.append(poly)
def duplicateN(): obj = rs.GetObject("Select object to duplicate", 16, True) if obj is None: return box = rs.BoundingBox(obj) if not isinstance(box, list): return origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2) endpt = rs.GetPoint("To point") ndups = rs.GetInteger("Number of duplications") maxd = rs.GetReal("Max Distance") translation = rs.VectorCreate(endpt, origin) for i in range(0, ndups, 1): xr = random() if random() < 0.5 else -1*random() yr = random() if random() < 0.5 else -1*random() zr = random() if random() < 0.5 else -1*random() newpt = [xr*maxd, yr*maxd, zr*maxd] translation1 = rs.VectorCreate(endpt, newpt) translation2 = rs.VectorCreate(translation1, origin) rs.CopyObject(obj, translation2)
def FitSurface(srf_id, samples): ptSurface = rs.SurfacePoints(srf_id) grSurface = rs.SurfaceEditPoints(idSrf, True, True) nrSurface = GrevilleNormals(srf_id) uvSamples = XYZ_To_UVW(srf_id, samples) #Create null vectors for all control-point forces vecForce = [(0,0,0) for pt in ptSurface] for i in range(len(uvSamples)): LocalCP = NearestUV(uvSamples[i], grSurface) LocalForce = nrSurface[LocalCP] LocalForce = rs.VectorScale(LocalForce, uvSamples[i][2]) vecForce[LocalCP] = rs.VectorAdd(vecForce[LocalCP], LocalForce) ptSurface = [rs.PointAdd(ptSurface[i], vecForce[i]) for i in range(len(ptSurface))] srf_CP_Count = rs.SurfacePointCount(srf_id) srf_Knots = rs.SurfaceKnots(srf_id) srf_Weights = rs.SurfaceWeights(srf_id) srf_Degree = (rs.SurfaceDegree(srf_id, 0), rs.SurfaceDegree(srf_id, 1)) return rs.AddNurbsSurface(srf_CP_Count, ptSurface, srf_Knots[0], srf_Knots[1], srf_Degree, srf_Weights)
def create_square(self, start_point, end_point, start_vector): across = rs.VectorUnitize(end_point - start_point) up = rs.VectorScale(start_vector, 0.5) over_unit = rs.VectorUnitize(rs.VectorCrossProduct(up, across)) over = rs.VectorScale((over_unit), 0.5) points_inner = [] points_inner.append(rs.PointAdd(start_point, rs.VectorAdd(up, over))) points_inner.append( rs.PointAdd(points_inner[0], rs.VectorReverse(over_unit))) points_inner.append( rs.PointAdd(points_inner[1], rs.VectorReverse(start_vector))) points_inner.append(rs.PointAdd(points_inner[2], over_unit)) points_outer = [] points_outer.append( rs.PointAdd(start_point, rs.VectorAdd(start_vector, over_unit))) points_outer.append( rs.PointAdd(points_outer[0], rs.VectorScale(rs.VectorReverse(over_unit), 2))) points_outer.append( rs.PointAdd(points_outer[1], rs.VectorScale(rs.VectorReverse(start_vector), 2))) points_outer.append( rs.PointAdd(points_outer[2], rs.VectorScale(over_unit, 2))) return [points_outer, points_inner, across]
def RunCommand( is_interactive ): margin = 5 L, W = 810, 455 basept = Rhino.Geometry.Point3d(0,0,0) L = unit_convert(L) W = unit_convert(W) margin = unit_convert(margin) go = Rhino.Input.Custom.GetPoint() opt_L = Rhino.Input.Custom.OptionDouble(L,0.2,10000) opt_W = Rhino.Input.Custom.OptionDouble(W,0.2,10000) go.SetCommandPrompt("Pick lower left corner of lasercut area or Enter to place at origin. Default sheet size is L=%.2f, W=%.2f" % (L,W)) go.AddOptionDouble("Length", opt_L) go.AddOptionDouble("Width", opt_W) go.AcceptNothing(True) while True: res = go.Get() if res == Rhino.Input.GetResult.Option: continue elif res == Rhino.Input.GetResult.Cancel: return elif res == Rhino.Input.GetResult.Nothing: pass elif res == Rhino.Input.GetResult.Point: basept = go.Point() break layer_dict = wla.get_lcut_layers() plane = rs.WorldXYPlane() plane = rs.MovePlane(plane,basept) inner_rect = rs.AddRectangle(plane,L-margin*2,W-margin*2) plane = rs.MovePlane(plane, rs.PointAdd(basept, [-margin,-margin,0])) outer_rect = rs.AddRectangle(plane, L, W) rs.ObjectLayer([inner_rect, outer_rect],"XXX_LCUT_00-GUIDES") rs.SelectObjects([inner_rect,outer_rect]) return True
def contour (crvOffset): # get geometry surfaceId = rs.GetObject("pick surface to contour", 0, True, True) startPt = rs.GetPoint("base point of contours") endPt = rs.GetPoint("end point of contours") count = 0 reference = [] target = [] # make contours & store in newCrvs newCrvs = rs.AddSrfContourCrvs(surfaceId, (startPt, endPt), crvOffset) # output is a list of GUIDs. can't access raw points # divide the target surface printBed = rs.GetObject("pick surface for layout", 8, True, True) intCount = len(newCrvs) uDomain = rs.SurfaceDomain(printBed, 0) vDomain = rs.SurfaceDomain(printBed, 1) uStep = (uDomain[1] - uDomain[0]) / intCount for u in rs.frange(uDomain[0], uDomain[1], uStep): layout = rs.SurfaceFrame(printBed, [u,1]) target1 = layout[0] # set target to point inside of object - note this is a single point target2 = rs.PointAdd(target1,(0,10,0)) # this could be more parametric target.extend([target1, target2]) #print target # add text, reference and orient! # for orient, we need a list 3 points to reference and 3 points to target! # maybe reference should be curve origin crvPl[0] and midpoint? or else polyline verticies -- need to convert curve to polyline first? for crv in newCrvs: count += 1 # for label crvPl = rs.CurvePlane(crv) # plane for text rs.AddText(count, crvPl, 0.25) # should you label on the ground? #crvPl = rs.PointAdd(crvPl[0], (0,0,-1)) # if you wanted to offset text ref1 = rs.CurveMidPoint(crv) ref2 = crvPl[0] reference.extend([ref1, ref2])
def createSupPt(origin, nCores, nFloors, rad1, rad2, hP, ang): for i in range((nCores * nFloors) + 1): ptO = rs.PointAdd(origin, (0, 0, hP * i / nCores)) pt1 = rs.Polar(ptO, (360 * i / nCores), rad1) pt1AuxA = rs.Polar(ptO, (360 * i / nCores) + ang, rad1) pt1AuxB = rs.Polar(ptO, (360 * i / nCores) - ang, rad1) pt2 = rs.Polar(ptO, (360 * i / nCores), rad2) pt2AuxA = rs.Polar(ptO, (360 * i / nCores) + ang, rad2) pt2AuxB = rs.Polar(ptO, (360 * i / nCores) - ang, rad2) #pExt.append(pt1) pExt.Add(pt1, g.Kernel.Data.GH_Path(i // nCores)) auxExtPts.extend([pt1AuxA, pt1AuxB]) arc1 = rs.AddArc3Pt(pt1AuxA, pt1AuxB, pt1) #arc drawing pedestrian path in core area arcPed.Add( rs.OffsetCurve(arc1, origin, pedOff)[0], g.Kernel.Data.GH_Path(i // nCores)) arcPark.Add( rs.OffsetCurve(arc1, origin, pedOff + parkOff)[0], g.Kernel.Data.GH_Path(i // nCores)) #extArcs.append(arc1) extArcs.Add(arc1, g.Kernel.Data.GH_Path(i // nCores)) #pInt.append(pt2) pInt.Add(pt2, g.Kernel.Data.GH_Path(i // nCores)) auxIntPts.extend([pt2AuxA, pt2AuxB]) arc2 = rs.AddArc3Pt(pt2AuxA, pt2AuxB, pt2) #intArcs.append(arc2) intArcs.Add(arc2, g.Kernel.Data.GH_Path(i // nCores)) pSupExt.AddRange([pt1AuxA, pt1AuxB, pt2AuxA, pt2AuxB], g.Kernel.Data.GH_Path(i // nCores))
def layerTag(obj): roomName = rs.LayerName(rs.ObjectLayer(obj), False) #add text tag try: text = str(roomName) pt0 = rs.BoundingBox(obj)[0] pt2 = rs.BoundingBox(obj)[2] pt = rs.AddPoint(rs.PointDivide(rs.PointAdd(pt0, pt2), 2)) rs.MoveObject(pt, [0, 1.5, 0]) areaTag = rs.AddText(text, pt, 1, justification=131074) except: print "Object has no name" return rs.DeleteObject(pt) parentLayer = rs.ParentLayer(rs.ObjectLayer(obj)) hostLayer = rs.AddLayer("ANNO_LAYER", (128, 128, 128), parent=parentLayer) rs.ObjectLayer(areaTag, hostLayer) #te = rs.coercerhinoobject(id, True, True) #te.Geometry.TextFormula = text #te.CommitChanges() #sc.doc.Views.Redraw() return None