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
