def draw_objects(): text_1a, text_1b = '1a', '1b' point_1a, point_1b = (10, 10, 0), (10, 20, 0) text_dot_1a = rs.AddTextDot(text_1a, point_1a) text_dot_1b = rs.AddTextDot(text_1b, point_1b) text_dots = [text_dot_1a, text_dot_1b] return text_dots
def draw_more_objects(): text_2a, text_2b = '2a', '2b' point_2a, point_2b = (20, 10, 0), (20, 20, 0) text_dot_2c = rs.AddTextDot(text_2a, point_2a) text_dot_2d = rs.AddTextDot(text_2b, point_2b) more_text_dots = [text_dot_2c, text_dot_2d] return more_text_dots
def draw_still_more_objects(): text_3a, text_3b = '3a', '3b' point_3a, point_3b = (30, 10, 0), (30, 20, 0) text_dot_2c = rs.AddTextDot(text_3a, point_3a) text_dot_2d = rs.AddTextDot(text_3b, point_3b) still_more_text_dots = [text_dot_2c, text_dot_2d] return still_more_text_dots
def add_dot(self, show_instance=True): if self.point is None: self.get_point() if show_instance is True: self.dot = rs.AddTextDot("{} [{}]".format(self.data.name, self.instance), self.point) else: self.dot = rs.AddTextDot(self.data.name, self.point)
def visualize_rays(room, keys=None, ref_order=None, layer='Default', dot=None): rs.CurrentLayer(layer) if not keys: keys = room.ray_lines.keys() for rk in keys: if ref_order: ref_k = ref_order if ref_k in room.ray_lines[rk]: u, v = room.ray_lines[rk][ref_k] line = rs.AddLine(u, v) else: lkeys = room.ray_lines[rk] for lk in lkeys: u, v = room.ray_lines[rk][lk] line = rs.AddLine(u, v) if dot == 'w': w = room.ray_powers[rk][lk][ 100] # this needs to be better, user given rs.AddTextDot(str(w), rs.CurveMidPoint(line)) if dot == 't': t = room.ray_times[rk][lk] rs.AddTextDot(str(t), rs.CurveMidPoint(line)) if dot == 'key': rs.AddTextDot(str(lk), rs.CurveMidPoint(line))
def draw_sierpinski_unreduced(): rs.AddLine([0, 0, 0], [0, 9, 0]) rs.AddLine([0, 9, 0], [0, 18, 0]) rs.AddLine([0, 0, 0], [18, 0, 0]) rs.AddLine([0, 18, 0], [18, 0, 0]) rs.AddLine([0, 0, 0], [0, 0, 24]) rs.AddLine([0, 0, 24], [0, 18, 0]) rs.AddLine([0, 0, 24], [18, 0, 0]) rs.AddTextDot('a', [6, 6, 8]) rs.AddLine([0, 0, 12], [0, 9, 0]) rs.AddLine([0, 0, 12], [9, 0, 0]) rs.AddLine([0, 9, 0], [9, 0, 0]) rs.AddTextDot('a', [3, 3, 4]) rs.AddLine([0, 9, 0], [0, 9, 12]) rs.AddLine([0, 9, 0], [9, 9, 0]) rs.AddLine([0, 9, 12], [9, 9, 0]) rs.AddTextDot('a', [3, 12, 4]) rs.AddLine([9, 0, 0], [9, 0, 12]) rs.AddLine([9, 0, 0], [9, 9, 0]) rs.AddLine([9, 0, 12], [9, 9, 0]) rs.AddTextDot('a', [12, 3, 4]) rs.AddLine([0, 0, 12], [0, 9, 12]) rs.AddLine([0, 0, 12], [9, 0, 12]) rs.AddLine([0, 9, 12], [9, 0, 12]) rs.AddTextDot('a', [3, 3, 16])
def adjust_face_edges(face,cat,adjust_dist): epsilon = 0.5 normal = face.NormalAt(0.5,0.5) b = face.Brep adj_edge_inds = face.AdjacentEdges() brep = face.DuplicateFace(False) brep_edges = brep.Edges edge_concavity = [-1 for i in adj_edge_inds] ###FUNCTION THIS OUT### #get the midpoints of the brepform's edges brepform_midpoints = [] for i,brepform_edge in enumerate(brep_edges): brepform_mid = brepform_edge.Domain.Mid brepform_midpoints.append(brepform_edge.PointAt(brepform_mid)) print "start thru adjacent edge list" #need to identify to concavity of each edge and hold it in a list that is #ordered the same as the brepform edge list. once this is done we can work directly with the brep. for i in adj_edge_inds: edge = b.Edges.Item[i] mid = edge.Domain.Mid conc = edge.ConcavityAt(mid,1) p = edge.PointAt(mid) #display rs.AddTextDot(i,p) #display for j,brepform_mp in enumerate(brepform_midpoints): print "looping through brepform midpoints" if p.EpsilonEquals(brepform_mp,0.5): print "found an edge equality" edge_concavity[j]=conc break #display convex/concave by brep midpoints for i,mp in enumerate(brepform_midpoints): rs.AddTextDot(edge_concavity[i],mp) ###FUNCTION THIS OUT END### edge_vectors = get_edge_vectors(brep,adjust_dist) print edge_vectors for i,edge in enumerate(brep_edges): xform = Rhino.Geometry.Transform.Translation(edge_vectors[i]) #many questions here... how to supply an enum testList = List[Rhino.Geometry.ComponentIndex]() testList.Add(Rhino.Geometry.ComponentIndex(edge,0)) brep.TransformComponent(testList,edge_vectors[i],0.1,10,False) return None
def try_good_arg_lpoints(): try_name = 'good_arg_lpoints' my_ex = e.Exporter() lpoint_1 = rs.AddTextDot('lp1', [10, 10, 0]) lpoint_2 = rs.AddTextDot('lp2', [20, 20, 0]) lpoints = [lpoint_2, lpoint_1] actual_value = my_ex._get_lpoint_specs(lpoints) expected_value = [((10, 10, 0), 'lp1'), ((20, 20, 0), 'lp2')] if not actual_value == expected_value: g.Grammar.print_test_error_message(method_name, try_name, expected_value, actual_value)
def _draw_text_dots(): text_1, text_2 = '1', '2' dot_1, dot_2 = (10, 0, 0), (20, 0, 0) text_dot_1 = rs.AddTextDot(text_1, dot_1) text_dot_2 = rs.AddTextDot(text_2, dot_2) if text_dot_1 and text_dot_2: message = 'Drew 2 visible text dots' else: message = 'Did not draw 2 visible text dots' print(message) text_dots = [text_dot_1, text_dot_2] return text_dots
def select_quad_mesh_strip(mesh, text='key'): """Select quad mesh strip. Parameters ---------- mesh : QuadMesh, CoarseQuadMesh The quad mesh or coarse quad mesh. text : str Optional argument to show the strip key or density. The key by default. Returns ------- hashable The strip key. """ n = mesh.number_of_strips() # different colors per strip strip_to_color = {skey: scale_vector([float(i), 0, n - 1 - float(i)], 255 / (n - 1)) for i, skey in enumerate(mesh.strips())} rs.EnableRedraw(False) # add strip polylines with colors and arrows guids_to_strip = {rs.AddPolyline(mesh.strip_edge_midpoint_polyline(skey)): skey for skey in mesh.strips()} for guid, skey in guids_to_strip.items(): rs.ObjectColor(guid, strip_to_color[skey]) rs.CurveArrows(guid, arrow_style = 3) # show strip key or density if text == 'key' or text == 'density': if text == 'key': guids_to_dot = {guid: rs.AddTextDot(skey, Polyline(mesh.strip_edge_midpoint_polyline(skey)).point(t = .5)) for guid, skey in guids_to_strip.items()} elif text == 'density': guids_to_dot = {guid: rs.AddTextDot(mesh.get_strip_density(skey), Polyline(mesh.strip_edge_midpoint_polyline(skey)).point(t = .5)) for guid, skey in guids_to_strip.items()} for guid, dot in guids_to_dot.items(): rs.ObjectColor(dot, rs.ObjectColor(guid)) # return polyline strip rs.EnableRedraw(True) skey = guids_to_strip.get(rs.GetObject('Get strip.', filter = 4), None) rs.EnableRedraw(False) # delete objects rs.DeleteObjects(guids_to_strip.keys()) if text == 'key' or text == 'density': rs.DeleteObjects(guids_to_dot.values()) return skey
def _draw_labeled_shape(cls, labeled_shape_spec, position): """Receives: labeled_shape_spec (line_specs, labeled_point_specs) position (num, num, num) or Point3d Draws the labeled shape at the specified position. Returns: boolean True, if successful None otherwise """ line_specs, lpoint_specs = labeled_shape_spec return_value = True for line_spec in line_specs: tail, head = line_spec offset_tail = cls._offset_point(tail, position) offset_head = cls._offset_point(head, position) line_guid = rs.AddLine(offset_tail, offset_head) if not line_guid: return_value = None break for lpoint_spec in lpoint_specs: text, point = lpoint_spec offset_point = cls._offset_point(point, position) text_dot_guid = rs.AddTextDot(text, offset_point) if not text_dot_guid: return_value = None break return return_value
def _try_textdot(): p1 = (10, 10, 0) text = 'td1' td1 = rs.AddTextDot(text, p1) name = 'td1' # _test_line(name, td1) ## bombs with textdot _test_textdot(name, td1)
def set_up_bad_type_selection(): g.Grammar.clear_all() f.Frame.new() r.Rule.add_first() line = rs.AddLine((0, 0, 0), (10, 10, 0)) lpoint = rs.AddTextDot('textdot', (5, 5, 0)) rs.SelectObject(line)
def make(self): group = rs.AddGroup() if (self.hexShape.length == 6): r = range(-1, self.hexShape.length - 1) else: r = range(self.hexShape.length - 1) for i in r: srf = self.makeTriangleSrf(i) unroll = self.makeUnrollPattern(i) self.srfList.append(srf) self.unrollList.append(unroll) # txt = rs.AddTextDot( str(self.name), self.hexProjection.centerPt, ) rs.AddObjectsToGroup(txt, group) rs.AddObjectsToGroup(self.srfList, group) rs.AddObjectsToGroup(self.unrollList, group) return self
def ShowRL(): try: def scale(): system = rs.UnitSystem() if system == 2 or system == 3 or system == 4: scaleFactorDict = {2: 0.001, 3: 0.01, 4: 1} scaleFactor = scaleFactorDict[system] return scaleFactor if system != 2 or system != 3 or system != 4: return None if scale() == None: rs.MessageBox( "This tool is can only be used in mm, cm or m model units") return None point = rs.GetPoint('Select point') if point: pointZ = point.Z pointZ = pointZ * scale() rs.AddTextDot('+RL ' + str(round(pointZ, 3)), point) # Copy RL to Clipboard RL = str(round(pointZ, 3)) rs.ClipboardText(RL) except: print("Failed to execute") rs.EnableRedraw(True) return
def drawTriTab(self, net): holeRadius = net.holeRadius mesh = net.mesh flatVerts = net.flatVerts flatFaces = net.flatFaces minArea = (holeRadius**2.0) * math.pi * 30 # print "minArea: " + str(minArea) flatFace = self.getConnectToFace(flatFaces, mesh) area = flatFace.getArea(flatVerts) pntA, pntC = self.get_coordinates(island) pntB = self.tabFaceCenter points = [pntA, pntB, pntC] polyline = Rhino.Geometry.PolylineCurve([pntA, pntB, pntC, pntA]) props = Rhino.Geometry.AreaMassProperties.Compute(polyline) if area > minArea: centerPnt = props.Centroid else: rs.AddTextDot("o", pntB) centerPnt = flatFaces[self.fromFace].getCenterPoint( flatVerts, True) hole = rs.AddCircle(centerPnt, holeRadius) polyGuid = rs.AddPolyline(points) self.geom.append(polyGuid) self.geom.append(hole) return polyGuid
def set_up_no_selection(): g.Grammar.clear_all() f.Frame.new() r.Rule.add_first() line = rs.AddLine((0, 0, 0), (10, 10, 0)) lpoint = rs.AddTextDot('textdot', (10, 10, 0)) text = rs.AddText('text', (5, 5, 0), 2)
def SampleTextDot(): gp = SampleGetTextDotPoint(); gp.Get() if (gp.CommandResult() == Rhino.Commands.Result.Success): point = gp.Point() str = gp.FormatPointString(point) rs.AddTextDot(str, point) rs.Redraw()
def show_mesh_vert(vert,mesh): '''note this is a re-write of a mesh method probably found in meshutils in rhinounfolder ''' coordinates = mesh.Vertices[vert] #point = rs.AddPoint(coordinates) dot = rs.AddTextDot(str(vert),coordinates) return dot
def AddTag(obj, text, color): box = rs.BoundingBox(obj) mid = (box[0] + box[-2])/2 tag = rs.AddTextDot(text, mid) rs.SetUserText(obj, 'tag', text) rs.ObjectColor(obj, color) group = rs.AddGroup() rs.AddObjectsToGroup([obj, tag], group)
def draw_lpoint_triple(text, tail, head): """Receives label text and a list of point triples: str [<iter>, ...] Draws text dots with <text>-a, -b, -c """ line_vector = rs.PointSubtract(head, tail) offset_vector = line_vector * offset offset_tail = rs.VectorAdd(tail, offset_vector) offset_head = rs.VectorSubtract(head, offset_vector) axis = [0, 0, 1] angle = 90 rotated_offset_vector = rs.VectorRotate(offset_vector, angle, axis) offset_side = rs.VectorAdd(offset_tail, rotated_offset_vector) rs.AddTextDot(('%s-a' % text), offset_tail) rs.AddTextDot(('%s-b' % text), offset_head) rs.AddTextDot(('%s-c' % text), offset_side)
def _add_lpoints(): lpoints = [('a', (0, 10, 0)), ('a', (20, 10, 0))] layer_name = s.Settings.first_rule_layer_name l.Layer.new(layer_name) rs.CurrentLayer(layer_name) for lpoint in lpoints: text, point = lpoint rs.AddTextDot(text, point) rs.CurrentLayer(s.Settings.default_layer_name)
def MarkShortEdges(): tol = 1 mm = Rhino.UnitSystem.Millimeters units = sc.doc.ModelUnitSystem tol = Rhino.RhinoMath.UnitScale(mm, units) while True: if sc.sticky.has_key('EDGELENGTH_TOL'): tol = sc.sticky['EDGELENGTH_TOL'] go = Rhino.Input.Custom.GetObject() opTol = Rhino.Input.Custom.OptionDouble(tol) go.AddOptionDouble("EdgeLength", opTol) go.AcceptNumber(True, False) res = go.Get() if (go.CommandResult() != Rhino.Commands.Result.Success): return if res == Rhino.Input.GetResult.Object: go.Object(0) break if res == Rhino.Input.GetResult.Option: tol = opTol.CurrentValue sc.sticky['EDGELENGTH_TOL'] = tol continue if res == Rhino.Input.GetResult.Number: tol = go.Number() sc.sticky['EDGELENGTH_TOL'] = tol continue sTol = str(round(tol, 4)) brepId = rs.GetObject(filter=8 + 16, preselect=True) if brepId is None: return brep = sc.doc.Objects.Find(brepId).Geometry edges = brep.Edges count = 0 for edge in edges: l = edge.GetLength() if edge.GetLength() <= tol: if count == 0: grp = rs.AddGroup() temp = rs.AddTextDot("!!!", edge.PointAtStart) rs.AddObjectsToGroup(temp, grp) count += 1 if count == 1: msg = " edge found at or below " + sTol + " in length." else: msg = " edges found at or below " + sTol + " in length." print str(count) + msg
def draw_vert_labels(points): offset_x, offset_y, offset_z = -1, -1, 0 for p in points: x, y, z = p p_offset = [ x + offset_x, y + offset_y, z + offset_z] rs.AddTextDot('a', p_offset)
def _draw_labeled_point(labeled_point, origin): """Draws a labeled point with the specified origin. Receives: labeled_point point3d origin point3d """ p_local, label = labeled_point p_world = _get_point_world_from_local(p_local, origin) textdot = rs.AddTextDot(label, p_world) return textdot
def getInnerPoint(self, flatVerts, vert): cornerVec = Rhino.Geometry.Vector3d(flatVerts[vert].point) vec = Rhino.Geometry.Vector3d(centerVec - cornerVec) length = vec.Length if not vec.Unitize(): return vec = vec.Multiply(vec, length * ratio) pos = Rhino.Geometry.Vector3d.Add(cornerVec, vec) rs.AddTextDot(str(i), pos)
def 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) rs.AddTextDot(point, point) # Add the second annotation if not rs.IsCurveClosed(objectId): point = rs.CurveEndPoint(objectId) rs.AddPoint(point) rs.AddTextDot(point, point)
def tag_parameters(crv_geo, params): layer_index = add_layer("bridgePreview", sd.Color.Aqua) pts = points_from_params(crv_geo, params, layer_index) for param, pt in zip(params, pts): rs.AddTextDot(param, pt) return 0
def growRegion(): filter = Rhino.DocObjects.ObjectType.Mesh rc, objRef = Rhino.Input.RhinoGet.GetOneObject("select testMesh", False, filter) if not objRef or rc != Rhino.Commands.Result.Success: return rc mesh = objRef.Mesh() if not mesh: return mesh.Compact() randIdx = int(random.uniform(0, mesh.Vertices.Count - 1)) tVertIdxRoot = mesh.TopologyVertices.TopologyVertexIndex(randIdx) vertPnt = mesh.Vertices[randIdx] rad = .1 rs.AddSphere(vertPnt, rad) growVerts = [] stepSize = .01 maxGrowLen = .5 minGrowLen = .02 cutoffDist = .7 gKernel = GKernel(stepSize, maxGrowLen, minGrowLen, cutoffDist) gKernel.plot() conVertsIdx = mesh.Vertices.GetConnectedVertices(randIdx) print type(conVertsIdx) #conVertsIdx is an Array[int] in .NET framework. print str(conVertsIdx.Length) for i in range(conVertsIdx.Length): idx = conVertsIdx[i] if (idx != randIdx): tVertIdx = mesh.TopologyVertices.TopologyVertexIndex(idx) dist = lenBetweenTVerts(tVertIdxRoot, tVertIdx, mesh) lookUpIdx = int(round(dist / stepSize)) distStr = "d:%1.2f,i:%d" % (dist, lookUpIdx) rs.AddTextDot(distStr, mesh.Vertices[idx]) if (dist < cutoffDist): growVerts.append([idx, lookUpIdx]) else: growVerts.append([idx, 0]) """GROW REGION""" for i in range(len(growVerts)): vertIdx = growVerts[i][0] kernelIdx = growVerts[i][1] growLength = gKernel.gaussKernel[kernelIdx] vert = mesh.Vertices[vertIdx] vertNormal = mesh.Normals[vertIdx] growVec = vertNormal.Multiply(vertNormal, growLength) newLoc = rs.VectorAdd(vert, growVec) #normalArrow = rs.AddLine(vert,newLoc) #rs.CurveArrows(normalArrow,2) mesh.Vertices.SetVertex(vertIdx, newLoc.X, newLoc.Y, newLoc.Z) scriptcontext.doc.Objects.Replace(objRef, mesh)
def AddDotToObjCtr(objIDs, text, transfer=True): #adds a dot to object(s) bounding box center and groups dot with object(s) bb = rs.BoundingBox(objIDs) if bb: dotID = rs.AddTextDot(text, (bb[0] + bb[6]) / 2) if transfer: TransferColorLayer(dotID, objIDs[0]) objIDs.append(dotID) group = rs.AddGroup() test = rs.AddObjectsToGroup(objIDs, group) return dotID