def make_stem_pieces(b):
obj1 = []
h = (b.tof[0].chine_hab - b.tof[1].chine_hab) * (
b.tof[0].section - b.chine) / (b.tof[1].section -
b.tof[0].section) + b.tof[0].chine_hab
p1 = [b.chine, 0, h]
obj1.append(rs.AddLine([0, 0, b.bow], p1))
obj1.append(rs.AddLine([0, 0, b.bow], [b.stem_width, 0, b.bow]))
obj1.append(
rs.AddLine([b.stem_width, 0, b.bow], ss(p1, [b.stem_width, 0, 0])))
obj1.append(rs.AddLine(ss(p1, [b.stem_width, 0, 0]), p1))
obj1 = rs.MoveObjects(rs.JoinCurves(obj1, delete_input=True), sm(-1, p1))
obj2 = []
h = (b.tof[-1].chine_hab -
b.tof[-2].chine_hab) * (b.loa - b.aft - b.tof[-1].section) / (
b.tof[-1].section - b.tof[-2].section) + b.tof[-1].chine_hab
p2 = [b.loa - b.aft, 0, h]
obj2.append(rs.AddLine([b.loa, 0, b.stern], p2))
obj2.append(
rs.AddLine([b.loa, 0, b.stern], [b.loa - b.stem_width, 0, b.stern]))
obj2.append(
rs.AddLine([b.loa - b.stem_width, 0, b.stern],
ss(p2, [-b.stem_width, 0, 0])))
obj2.append(rs.AddLine(ss(p2, [-b.stem_width, 0, 0]), p2))
obj2 = rs.MoveObjects(rs.JoinCurves(obj2, delete_input=True), sm(-1, p2))
return rs.RotateObjects(obj1 + obj2, [0, 0, 0], 90, [1, 0, 0])
def tree_gen(self, radius, height):
result = []
summary = []
if radius < self.terminal_radius:
if self.for_reals:
result.append(self.get_leaf())
summary.append("leaf")
else:
if self.for_reals:
result.append(self.twig_gen(radius, radius, height))
summary.append("twig " + str(radius) + " " + str(height))
subs = []
sub_radius = radius * self.radius_fraction
sub_height = height * self.height_fraction
sub_angle_y = self.bend
for i in range(self.density):
sub_angle_z = (i + (0.5 * random.random())) * (360 / self.density)
sub, sub_summary = self.tree_gen(sub_radius, sub_height)
if self.for_reals:
sub = rs.RotateObjects(sub, (0,0,0), sub_angle_y, (0,1,0))
sub = rs.RotateObjects(sub, (0,0,0), sub_angle_z, (0,0,1))
sub = rs.MoveObjects(sub, (0,0,height))
subs += sub
summary.append(sub_summary)
center, center_summary = self.tree_gen(sub_radius, sub_height)
if self.for_reals:
center = rs.MoveObjects(center, (0,0,height))
result += subs + center
summary.append(center_summary)
return result, summary
def place_box(self):
myBox1 = box()
box1 = myBox1.console(self.data[2], 0, 0)
myBox2 = box()
box2 = myBox2.console(self.data[1], 1,
(self.data[1][0] - self.data[0][0] - 2 * cut2) /
2.0)
myBox3 = box()
box3 = myBox3.console(self.data[0], 1,
(self.data[1][0] - self.data[0][0] - 2 * cut2) /
2.0)
rs.MoveObjects(box1, (0, 0, myBox1.height / 2.0))
rs.MoveObjects(box2, (0, 0, myBox2.height / 2.0 + cut2))
rs.MoveObjects(box3, (0, 0, myBox3.height / 2.0 + 2 * cut2))
def rMove(vector):
objs = rs.GetObjects("Select objs")
if objs != None:
rs.MoveObjects(objs, vector)
objs = None
vector = vector + inputvec
rMove(vector)
def unroll(self):
x = 0
for i in range(len(self.srfList)):
g = rs.AddGroup()
s, p = rs.UnrollSurface(self.srfList[i], False, self.unrollList[i])
s = rs.JoinSurfaces(s, True)
p = rs.MoveObjects(p, [x, self.name * 10, 0])
s = rs.MoveObject(s, [x, self.name * 10, 0])
b = rs.DuplicateSurfaceBorder(s, 1)
rs.ObjectLayer(b, "cut")
rs.AddObjectsToGroup(b, g)
rs.AddObjectsToGroup(p, g)
bb = rs.BoundingBox(s)
x += fabs(bb[0].X - bb[1].X) + 1
t = rs.AddText(
str(self.name) + "-" + str(i),
util.averagePt(rs.CurvePoints(b)), 0.3)
t = util.makeEngravingFont(t)
rs.AddObjectsToGroup(t, g)
rs.DeleteObjects(s)
def update(self):
print('update')
#delete last generated objects
try:
rs.DeleteObjects(self.generatedObjs)
self.generatedObjs = []
except:
print('exception in delete generated object')
divWidth = 600
crv = self.baseCrv
if not rs.IsObject(crv):
print('crv is not an object')
return
if not rs.IsPolyline(crv):
pts = rs.DivideCurveEquidistant(crv, divWidth)
rail = rs.AddPolyline(pts)
else:
rail = rs.CopyObject(crv)
pts = rs.CurveEditPoints(rail)
if len(pts) < 3:
print('too little points')
return
#find vectors to move and orient the profile
vect = pts[1] - pts[0]
vect = rs.VectorUnitize(vect)
a = rs.VectorAngle(vect, (0, 1, 0)) - 90
#load the component
path = self.loadPath
component = None
try:
component = importComponent(path)
except:
print('exception on importing module')
if component is None:
print('component is None')
return None
#rs.MoveObjects(component.breps,pts[0])
#rs.RotateObjects(component.breps,pts[0],a)
for b in component.breps:
self.generatedObjs.append(b)
oriented = orientObjAlongPolyPts(b, pts)
print('pts count:', len(pts), ' num gen:', len(oriented))
rs.MoveObjects(component.polys, pts[0])
rs.RotateObjects(component.polys, pts[0], a)
for c in component.polys:
self.generatedObjs.append(c)
mesh = meshSwipPolyAlongPoly(c, rail)
self.generatedObjs.append(mesh)
rs.DeleteObject(rail)
print('generated obj count:', len(self.generatedObjs))
rs.AddGroup('gen')
rs.AddObjectsToGroup(self.generatedObjs, 'gen')
def moveSrftoZ(srf):
domainU = rs.SurfaceDomain(srf, 0)
domainV = rs.SurfaceDomain(srf, 1)
u = domainU[1] / 2.0
v = domainV[1] / 2.0
point = rs.EvaluateSurface(srf, u, v)
# vec = [0, 0, point.Z]
# vec = rs.VectorReverse(vec)
# vec = [0,0,vec.Z]
rs.MoveObjects(srf, rs.VectorReverse([0, 0, point.Z]))
def moveToOrigin(objs, origin):
#box = rs.BoundingBox(objs)
if origin:
#selection_base = [box[0].X, box[0].Y, box[0].Z]
vector = rs.VectorSubtract(origin, [0, 0, 0])
objs = rs.MoveObjects(objs, rs.VectorReverse(vector))
return True
else:
return False
def moveToOrigin(allObjects, CADinMilli):
cadOrigin = rs.GetDocumentData("Project Info", "CAD coordinate (X,Y,Z)")
cadOrigin = cadOrigin.split(",")
try:
moveVec = rs.VectorCreate([0,0,0], [float(cadOrigin[0]), float(cadOrigin[1]), float(cadOrigin[2])])
except:
print "Move to origin FAILED. Make sure CAD Coordinate has been correctly entered into Project Info."
return
if CADinMilli:
moveVec = rs.VectorScale(moveVec, .001)
rs.MoveObjects(allObjects,moveVec)
return
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 GroupMove(rectOutlineList, objects, objCenter, rotatedAngle, movingCenter):
for objs, rect, center, rotAngle, centerStart in zip(
objects, rectOutlineList, objCenter, rotatedAngle, movingCenter):
# rotate everything by center with rotatedAngle
rs.RotateObjects(objs, center, rotAngle)
# find vector to move from obj location to rectangle(obj center to rect center)
boxCenter = rs.CurveAreaCentroid(rect)[0]
moveVector = rs.VectorCreate(boxCenter, center)
# check if object is in box
rectPt = rs.PolylineVertices(rect)
rectPt = PointsReorder(rectPt, 1)
if rs.Distance(rectPt[0], rectPt[1]) > rs.Distance(
rectPt[1], rectPt[2]):
rs.RotateObjects(objs, center, 90)
rs.MoveObjects(objs, moveVector)
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 moveToOrigin(objs):
#get left bottom
rs.EnableRedraw(True)
selection_base = rs.GetPoint("Pick export base point")
rs.EnableRedraw(False)
#box = rs.BoundingBox(objs)
if selection_base:
#selection_base = [box[0].X, box[0].Y, box[0].Z]
vector = rs.VectorSubtract(selection_base, [0, 0, 0])
objs = rs.MoveObjects(objs, rs.VectorReverse(vector))
return True
else:
return False
def get_brep_plan_cut(brep, cut_height, tolerance):
"""cut a brep at a certain height. returns list of geometry.polycurve
tolerance should be the document tolerance.
NOTE: attempts to join the curves."""
bb = rs.BoundingBox(brep)
height = rs.Distance(bb[0], bb[4])
#get middle section and get polycurve
midplane_pts = rs.MoveObjects(bb[0:4], [0, 0, cut_height])
plane = rs.PlaneFromPoints(bb[0], bb[1], bb[3])
rs.DeleteObjects(midplane_pts)
bool_merged = Rhino.Geometry.Brep.MergeCoplanarFaces(brep, tolerance)
g = Rhino.Geometry.Intersect.Intersection.BrepPlane(brep, plane, tolerance)
g_polycurves = g[1]
g_polycurves = Rhino.Geometry.Curve.JoinCurves(g_polycurves, tolerance)
return g_polycurves
def TruncateWorldCoordinate():
try:
# Get setout point
point = rs.GetPoint("Pick Point for World Coordinate value")
if point:
rs.EnableRedraw(False)
northing = round(point.Y, 5)
easting = round(point.X, 5)
# Add origin layer and lock it
rs.AddLayer("_ORIGIN_", (255, 0, 0), visible=True, locked=True)
originPoint = rs.AddPoint(point)
# Move all objects to origin
allObj = rs.AllObjects()
vector = rs.VectorCreate((0, 0, 0), point)
rs.MoveObjects(allObj, vector)
# Draw origin marker`
circle = rs.AddCircle(originPoint, 1)
quads = rs.EllipseQuadPoints(circle)
line1 = rs.AddLine(quads[0], quads[1])
line2 = rs.AddLine(quads[2], quads[3])
# Draw text marker and designate a name
text = rs.AddText((" E " + str(easting) + " N " + str(northing)),
originPoint, 0.5)
rs.ObjectName(text, "_ORIGIN_TEXT_")
rs.ObjectName(originPoint, "_ORIGIN_POINT_")
# Move geometry to locked origin layer
rs.ObjectLayer([circle, line1, line2, originPoint, text],
"_ORIGIN_")
rs.EnableRedraw(True)
except:
print("Failed to execute")
rs.EnableRedraw(True)
return
def RestoreWorldCoordinate():
try:
rs.EnableRedraw(False)
# retreive northing and easting from text object
obj = rs.ObjectsByName("_ORIGIN_TEXT_")
if obj:
text = rs.TextObjectText(obj)
textList = text.split()
easting = float(textList[1])
northing = float(textList[3])
# create reference coordinates to make vector
orPoint = (easting, northing, 0)
point = rs.PointCoordinates(rs.ObjectsByName("_ORIGIN_POINT_"))
vector = rs.VectorCreate(orPoint, point)
# move all objects back to original origin point
allObj = rs.AllObjects()
rs.MoveObjects(allObj, vector)
# delete coordinate geometry
isCurrent = rs.IsLayerCurrent("_ORIGIN_")
if isCurrent == False:
rs.PurgeLayer("_ORIGIN_")
if isCurrent == True:
defaultCheck = rs.IsLayer("Default")
if defaultCheck == True:
rs.CurrentLayer("Default")
rs.PurgeLayer("_ORIGIN_")
if defaultCheck == False:
rs.AddLayer("Default")
rs.CurrentLayer("Default")
rs.PurgeLayer("_ORIGIN_")
rs.EnableRedraw(True)
except:
print("Failed to execute")
rs.EnableRedraw(True)
return
def get_frame_brep(outline_srf, border_thickness, thickness):
"""get the frame brep. This is a solid that is booleaned with the slices of
terrain to make a border when border mode is on."""
edge_crvs = rs.DuplicateEdgeCurves(outline_srf)
outline_crv = rs.JoinCurves(edge_crvs)
pt, _ = rs.CurveAreaCentroid(outline_crv)
inner_crv = rs.OffsetCurve(outline_crv, pt, border_thickness, [0, 0, 1])
rs.MoveObjects([outline_crv, inner_crv], [0, 0, thickness * 2])
path_line = rs.AddLine([0, 0, 0], [0, 0, -thickness * 4])
inner_brep = rs.ExtrudeCurve(inner_crv, path_line)
outer_brep = rs.ExtrudeCurve(outline_crv, path_line)
rs.CapPlanarHoles(inner_brep)
rs.CapPlanarHoles(outer_brep)
frame_brep = rs.BooleanDifference([outer_brep], [inner_brep])
rs.DeleteObjects([outline_crv, inner_crv])
rs.DeleteObjects(edge_crvs)
rs.DeleteObject(path_line)
return frame_brep
def draw_coaming(c):
pts = [[0, 0, 0]]
half = [[(i + 1) * c.spacing, c.points[i], 0]
for i in range(len(c.points))]
pts.extend(half)
pts.append([c.length, 0, 0])
half = [[(i + 1) * c.spacing, -c.points[i], 0]
for i in range(len(c.points))]
half.reverse()
pts.extend(half)
pts.append([0, 0, 0])
crv = rs.AddInterpCurve(pts,
degree=3,
knotstyle=0,
start_tangent=[0, 1, 0],
end_tangent=[0, 1, 0])
strip = [crv, rs.OffsetCurve(crv, [-1, 0, 0], c.width1)]
rs.CopyObjects(strip, [0, c.beam + 2 * c.width1, 0])
strip2 = [rs.CopyObjects(crv), rs.OffsetCurve(crv, [-1, 0, 0], c.width2)]
rs.MoveObjects(strip2, [0, -c.beam - c.width1 - c.width2, 0])
def createTable(partlist):
if not "partlistgroup" in rs.GroupNames():
rs.AddGroup("partlistgroup")
#clean the group
group = sc.doc.Groups.FindName("partlistgroup")
objs = sc.doc.ActiveDoc.Groups.GroupMembers(group.Index)
rs.DeleteObjects(objs)
#rs.DeleteObjects
twidth = 100
def addTexts(texts, y):
for i, text in enumerate(texts):
if i == 0:
a = 6
just = Rhino.Geometry.TextJustification.BottomRight
elif i == 1:
a = 9.5
just = Rhino.Geometry.TextJustification.BottomLeft
else:
a = 14 + twidth
just = Rhino.Geometry.TextJustification.BottomRight
plane = Rhino.Geometry.Plane.WorldXY
plane.Origin = Rhino.Geometry.Point3d(a, y - 4, 0)
textobject = sc.doc.Objects.AddText(text, plane, 2.0,
'Courier New', False, False,
just)
rs.AddObjectToGroup(textobject, "partlistgroup")
def addBorders(i, y):
start = Rhino.Geometry.Point3d(0, y - 6, 0)
end = Rhino.Geometry.Point3d(16 + twidth, y - 6, 0)
line = sc.doc.Objects.AddLine(start, end) #bottom border
rs.AddObjectToGroup(line, "partlistgroup")
if i == 0:
#add top border
trans = Rhino.Geometry.Transform.Translation(0, 6, 0)
h_line = Rhino.Geometry.Line(start, end)
h_line.Transform(trans)
line = sc.doc.Objects.AddLine(h_line)
rs.AddObjectToGroup(line, "partlistgroup")
#add vertical lines
v_start = Rhino.Geometry.Point3d(0, y, 0)
v_end = Rhino.Geometry.Point3d(0, y - 6, 0)
v_line = Rhino.Geometry.Line(v_start, v_end)
line = sc.doc.Objects.AddLine(v_line)
rs.AddObjectToGroup(line, "partlistgroup")
trans = Rhino.Geometry.Transform.Translation(8, 0, 0)
v_line.Transform(trans)
line = sc.doc.Objects.AddLine(v_line)
rs.AddObjectToGroup(line, "partlistgroup")
trans = Rhino.Geometry.Transform.Translation(twidth, 0, 0)
v_line.Transform(trans)
line = sc.doc.Objects.AddLine(v_line)
rs.AddObjectToGroup(line, "partlistgroup")
trans = Rhino.Geometry.Transform.Translation(8, 0, 0)
v_line.Transform(trans)
line = sc.doc.Objects.AddLine(v_line)
rs.AddObjectToGroup(line, "partlistgroup")
y = len(partlist) * 6
for i, texts in enumerate(partlist):
addTexts(texts, y)
addBorders(i, y)
y -= 6
#sc.doc.Views.Redraw()
group = sc.doc.Groups.FindName("partlistgroup")
objs = sc.doc.ActiveDoc.Groups.GroupMembers(group.Index)
rs.MoveObjects(objs, (10, 10, 0))
#lineFrom = rs.GetPoint("Plane From:")
#lineTo = rs.GetPoint("Plane To:")
#distance = rs.Distance(lineFrom, lineTo)
#plane = rs.LinePlane([lineFrom, lineTo])
#rs.AddPlaneSurface( plane, distance, distance )
distance = rs.Distance(s1, e1)
plane = rs.LinePlane([s1, e1])
p1 = rs.AddPlaneSurface(plane, distance, distance)
rs.HideObject(p1)
distance = rs.Distance(s2, e2)
plane = rs.LinePlane([s2, e2])
p2 = rs.AddPlaneSurface(plane, distance, distance)
rs.HideObject(p2)
l1 = rs.AddLine(s1, e1)
l2 = rs.AddLine(s2, e2)
if l1:
points1 = rs.DivideCurve(l1, 20)
for point in points1:
rs.AddPoint(point)
rs.MoveObjects(points1, y)
if l2:
points2 = rs.DivideCurve(l2, 20)
for point in points2:
rs.AddPoint(point)
def draw_frame_layout(s, keel_str, chine_str, gunwale_str, deck_str, diam,
bdiam):
objs = []
t = [0, 2 * s.gunwale_hb, 0]
r = 90
# t = [0,0,0]
# r = 0
objs.append(
rs.AddLine([s.section, 0, s.keel_hab],
[s.section, s.chine_hb, s.chine_hab]))
objs.append(
rs.AddLine([s.section, s.chine_hb, s.chine_hab],
[s.section, s.gunwale_hb, s.gunwale_hab]))
objs.append(
rs.AddLine([s.section, s.gunwale_hb, s.gunwale_hab],
[s.section, s.deckridge_hb, s.deckridge_hab]))
if (s.deckridge_hb != 0):
objs.append(
rs.AddLine([s.section, s.deckridge_hb, s.deckridge_hab],
[s.section, 0., s.deckridge_hab]))
objs.extend(rs.MirrorObjects(objs, [0, 0, 0], [1, 0, 0], copy=True))
objs = rs.JoinCurves(objs, delete_input=True)
#ins = rs.OffsetCurve(objs,[s.section,0,.5*s.deckridge_hab],s.width + .75*deck_str.width,normal=[1,0,0])
# if not ins: ins = []
ins = []
rs.DeleteObjects(objs)
chine_edge = make_chine_edge([s.section, s.chine_hb, s.chine_hab],
[s.section, s.gunwale_hb, s.gunwale_hab],
chine_str.thickness, gunwale_str.thickness,
chine_str.width, gunwale_str.width,
[s.section, s.deckridge_hb, s.deckridge_hab])
keel_edge = make_keel_edge([s.section, 0, s.keel_hab],
[s.section, s.chine_hb, s.chine_hab],
keel_str.thickness, keel_str.width,
[s.section, s.gunwale_hb, s.gunwale_hab])
deck_edge = make_deck_edge([s.section, s.gunwale_hb, s.gunwale_hab],
[s.section, s.deckridge_hb, s.deckridge_hab],
deck_str.thickness, gunwale_str.thickness,
deck_str.width,
[s.section, s.chine_hb, s.chine_hab],
s.deck_string_place)
edges = chine_edge + keel_edge + deck_edge
edges.extend(rs.MirrorObjects(edges, [0, 0, 0], [1, 0, 0], copy=True))
edges = rs.JoinCurves(edges, delete_input=True)
edges.extend(
rs.OffsetCurve(edges, [s.section, 0, .5 * s.deckridge_hab],
s.width,
normal=[1, 0, 0],
style=3))
g = rs.AddGroup()
rs.AddObjectsToGroup(edges, g)
# if s.num-1 in [0,2,5,7]:
if 1:
p = [s.section, 0, 0]
plane = rs.PlaneFromNormal(p, [1, 0, 0])
holes = [
rs.MoveObject(
rs.AddCircle(plane, diam / 2),
[0, 1.5 * deck_str.thickness, s.keel_hab + deck_str.width])
]
holes.extend(rs.MirrorObjects(holes, p, ss(p, [1, 0, 0]), copy=True))
else:
holes = []
rs.MoveObjects(
rs.RotateObjects(ins + edges + holes, [s.section, 0, s.keel_hab], r,
[0, 1, 0]), t)
def MultiUnroll():
msg = "Select surface/polysurface objects to unroll"
brepIDs = rs.GetObjects(msg, 8 + 16, preselect=True)
if not brepIDs: return
msg = "Select curves and/or points to unroll with surfaces, or Enter to continue"
otherIDs = rs.GetObjects(msg, 1 + 4 + 8192)
if "MultiUR_Numbering" in sc.sticky:
user_num = sc.sticky["MultiUR_Numbering"]
else:
user_num = True
if "MultiUR_Explode" in sc.sticky: user_exp = sc.sticky["MultiUR_Explode"]
else: user_exp = False
if "MultiUR_Properties" in sc.sticky:
user_prop = sc.sticky["MultiUR_Properties"]
else:
user_prop = False
if "MultiUR_Spacing" in sc.sticky:
user_space = sc.sticky["MultiUR_Spacing"]
else:
user_space = 1.0
if "MultiUR_XLimit" in sc.sticky: user_xl = sc.sticky["MultiUR_XLimit"]
else: user_xl = 0
prompt = "Start point for unrolls - press Enter for world 0"
msg = [
"NumberObjects", "Explode", "KeepProperties", "LayoutSpacing",
"XExtents"
]
ini = [user_num, user_exp, user_prop, user_space, user_xl]
limits = [["No", "Yes"], ["No", "Yes"], ["No", "Yes"], [True, 0],
[True, 0]]
result = CommandLineOptions(prompt, msg, ini, limits)
if not result: return
x_extents = result[4]
new_sp = result[5]
#initialize
max_y = new_sp.Y
x_origin = new_sp.X
exceed_warning = False
ur_number = 0
no_unroll = 0
crvs = []
pts = []
dots = []
tol = sc.doc.ModelAbsoluteTolerance
#get underlying geometry objects
objs = [sc.doc.Objects.Find(objID).Geometry for objID in brepIDs]
if otherIDs:
for objID in otherIDs:
if rs.IsCurve(objID):
crvs.append(sc.doc.Objects.Find(objID).Geometry)
elif rs.IsPoint(objID):
pts.append(sc.doc.Objects.Find(objID).Geometry)
else:
dots.append(sc.doc.Objects.Find(objID).Geometry)
#run the unroller
rs.EnableRedraw(False)
for i, obj in enumerate(objs):
if isinstance(obj, Rhino.Geometry.Extrusion): obj = obj.ToBrep()
ur = Rhino.Geometry.Unroller(obj)
if result[1]: ur.ExplodeOutput = True
if len(crvs) > 0:
for crv in crvs:
ur.AddFollowingGeometry(crv)
if len(pts) > 0:
for pt in pts:
ur.AddFollowingGeometry(pt)
if len(dots) > 0:
for dot in dots:
ur.AddFollowingGeometry(dot)
unroll = ur.PerformUnroll()
if unroll[0]:
#something was unrolled
ur_number += 1
if result[1]: ur_objs = unroll[0]
else: ur_objs = Rhino.Geometry.Brep.JoinBreps(unroll[0], tol)
ur_IDs = [sc.doc.Objects.AddBrep(ur_obj) for ur_obj in ur_objs]
bb = rs.BoundingBox(ur_IDs)
if x_extents > 0:
if bb[3].Y - bb[0].Y > max_y: max_y = bb[3].Y - bb[0].Y
if bb[1].X - bb[0].X > x_extents:
x_extents = bb[1].X - bb[0].X
exceed_warning = True
if new_sp.X + bb[1].X > (x_origin + x_extents):
#need to reset start point to x_origin, y_max
new_sp.X = x_origin
new_sp.Y += max_y + result[3]
move_vec = new_sp - bb[0]
if unroll[1]:
ur_crv_IDs = [
sc.doc.Objects.AddCurve(ur_obj) for ur_obj in unroll[1]
]
ur_IDs.extend(ur_crv_IDs)
if unroll[2]:
ur_pt_IDs = [
sc.doc.Objects.AddPoint(ur_obj) for ur_obj in unroll[2]
]
ur_IDs.extend(ur_pt_IDs)
if unroll[3]:
ur_dot_IDs = [
sc.doc.Objects.AddTextDot(ur_obj) for ur_obj in unroll[3]
]
ur_IDs.extend(ur_dot_IDs)
if result[2]:
#keep properties (MatchAttributes() causes problems with grouping)
TransferColorLayer(ur_IDs, brepIDs[i])
if result[0]:
#number objects and group
AddDotToObjCtr(ur_IDs, str(ur_number), result[2])
#add number dot to original object
AddDotToObjCtr([brepIDs[i]], ur_number, result[2])
#move all objs into position
rs.MoveObjects(ur_IDs, move_vec)
new_sp = (bb[1] +
(move_vec + Rhino.Geometry.Vector3d(result[3], 0, 0)))
else:
no_unroll += 1
#Clean up, store settings, report
sc.sticky["MultiUR_Numbering"] = result[0]
sc.sticky["MultiUR_Explode"] = result[1]
sc.sticky["MultiUR_Properties"] = result[2]
sc.sticky["MultiUR_Spacing"] = result[3]
sc.sticky["MultiUR_XLimit"] = x_extents
if exceed_warning:
us = rs.UnitSystemName(abbreviate=True)
msg = "At least one of the unrolled objects exceeded the X extents limit!\n"
msg += "Limit has been extended to {:.2f} {} ".format(x_extents, us)
msg += "to allow all objects to unroll."
rs.MessageBox(msg, 48)
msg = "Sucessfully unrolled {} objects".format(len(brepIDs) - no_unroll)
if no_unroll > 0:
msg += " | Unable to unroll {} objects".format(no_unroll)
print msg
def drawEhombusTilingByRegularOffsetLine(emblem):
tmpObjs = []
# self.rhomboids
for rhomboid in emblem.rhomboids:
objs = []
# 中点長方形の対角四角形
for i in range(len(rhomboid.midPts)):
p0 = rhomboid.midPts[i]
if (i == 0):
nextMidPt = rhomboid.midPts[i + 1]
prevtMidPt = rhomboid.midPts[len(rhomboid.midPts) - 1]
elif (i == len(rhomboid.midPts) - 1):
nextMidPt = rhomboid.midPts[0]
prevtMidPt = rhomboid.midPts[i - 1]
else:
nextMidPt = rhomboid.midPts[i + 1]
prevtMidPt = rhomboid.midPts[i - 1]
p1 = rs.VectorAdd(p0, nextMidPt)
p1 = rs.VectorDivide(p1, 2.0)
p2 = rhomboid.ellipsePts[0]
p3 = rs.VectorAdd(p0, prevtMidPt)
p3 = rs.VectorDivide(p3, 2.0)
pts = [p0, p1, p2, p3, p0]
obj = rs.AddPolyline(pts)
if (i % 2 == 0):
rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[1].no)
else:
rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[0].no)
objs.append(obj)
# 外周面
pts = []
for pt in rhomboid.pts:
pts.append(pt)
pts.append(pts[0])
obj = rs.AddPolyline(pts)
rs.ObjectLayer(obj, "srfRhomboid")
objs.append(obj)
# 外周線
for i in range(len(rhomboid.pts)):
if (i == len(rhomboid.pts) - 1):
obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[0])
else:
obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[i + 1])
rs.ObjectLayer(obj, "lineBlack")
objs.append(obj)
# rotate
xform = rs.XformRotation2(rhomboid.rotateAng, [0, 0, 1], [0, 0, 0])
rs.TransformObjects(objs, xform)
# move
rs.MoveObjects(objs, rhomboid.movePt)
# text
txt = "%s" % (rhomboid.name)
pt = rhomboid.getAbsolutePt(rhomboid.ellipsePts[0])
height = 1.2
pt = [pt[0], pt[1] + height / 2.0, pt[2]]
obj = rs.AddText(txt,
pt,
height,
font,
font_style=0,
justification=2 + 65536)
rs.ObjectLayer(obj, "textRhomboid")
objs.append(obj)
# tmpObjs
for obj in objs:
tmpObjs.append(obj)
# move to center
pts = rs.BoundingBox(tmpObjs)
center = rs.VectorAdd(pts[0], pts[2])
center = rs.VectorScale(center, 0.5)
center = rs.VectorSubtract([0, 0, 0], center)
rs.MoveObjects(tmpObjs, center)
return tmpObjs
#SHL Architects #Sean Lamb 29-05-2019 #[email protected] #Example use of ws_lib package. Run in Rhino Python Interpreter. import System.Drawing as sd import rhinoscriptsyntax as rs import shl-toolbox.lib.layers as wla reload(wla) import shl-toolbox.lib.rhino_util as wru reload(wru) wla.add_layer("t1",sd.Color.Aqua) layerlist = "Layer 01" rhobjs = wla.get_layer_objects(layerlist) x = 5 guids = wru.docobj_to_guid(rhobjs) y = 10 rs.MoveObjects(guids,[20,20,0]) wla.change_object_layers(guids,"t1")
pattern_A.append(rs.AddLine(joins[i],joins[i+1]))
#----------Generate pattern B----------#
joins_2 = []
joins_2.append(a)
p_2 = rs.CopyObject(a,[(d/2),0,0])
joins_2.append(p_2)
for i in range (1, (xint+1)):
c_2 = rs.CopyObject(p_2,[l,0,0])
joins_2.append(c_2)
p_2 = rs.CopyObject(c_2,[d,0,0])
joins_2.append(p_2)
pattern_B = []
for i in range (1, (len(joins_2)-1), 2):
pattern_B.append(rs.AddLine(joins_2[i],joins_2[i+1]))
p_B = rs.MoveObjects(pattern_B, [0,s,0])
for i in range (0, (xint_2-1), 2):
pattern_A = rs.CopyObjects(pattern_A, [0,s*2,0])
p_B = rs.CopyObjects(p_B, [0,s*2,0])
rs.DeleteObjects(joins)
rs.DeleteObjects(joins_2)
rs.DeleteObject(obj_0)
rs.EnableRedraw(True)
import rhinoscriptsyntax as rs
import Rhino
import Rhino.Geometry as rg
doc = Rhino.RhinoDoc.ActiveDoc
###insert clipboard object at point
cmd = "'_Paste"
rs.Command(cmd, False)
objs = rs.LastCreatedObjects(select=True)
destination = rs.GetPoint("Choose a point to place object")
#calculate initial point and placement point
pt = rs.CurveStartPoint(objs[0])
dx = destination[0] - pt[0]
dy = destination[1] - pt[1]
dz = destination[2] - pt[2]
translation = [dx, dy, dz]
rs.MoveObjects(objs, translation)
def ScatterBlocks():
try:
################################################################################
# GET OBJECTS AND VARIABLE #
################################################################################
obj = rs.GetObject(message="Select surface to scatter on", filter=8 | 16 |
32, preselect=False, select=False, custom_filter=None, subobjects=False)
if not obj:
return
blocks = rs.GetObjects(message="Select blocks to scatter", filter=4096, group=True, preselect=False,
select=False, objects=None, minimum_count=1, maximum_count=0, custom_filter=None)
if not blocks:
return
scatterNum = rs.GetInteger(
message="Enter scatter amount", number=100, minimum=1, maximum=10000)
if not scatterNum:
return
userScale = rs.GetReal(
"enter scale multiplyer (0 for no scaling)", number=0, minimum=None, maximum=None)
userRotation = rs.GetBoolean(
"random rotation of blocks?", ("Rotation", "No", "Yes"), (True))
if not userRotation:
return
isMesh = rs.IsMesh(obj)
ptBucket = 0
pointList = []
blockList = []
worldZVector = (rs.WorldXYPlane()).ZAxis
rs.EnableRedraw(False)
def MeshBrep(brep_id, params):
brep = rs.coercebrep(brep_id)
if brep:
mesh = Rhino.Geometry.Mesh()
mesh_parts = Rhino.Geometry.Mesh.CreateFromBrep(brep, params)
for mesh_part in mesh_parts:
mesh.Append(mesh_part)
mesh.Compact()
return mesh
def TestMeshBrep():
mesh_params = Rhino.Geometry.MeshingParameters.Coarse
mesh_brep = MeshBrep(obj, mesh_params)
if mesh_brep:
mesh = sc.doc.Objects.AddMesh(mesh_brep)
return mesh
def chunks(lst, n): # list split generator
for i in xrange(0, len(lst), n):
yield lst[i:i + n]
if isMesh == False:
mesh = TestMeshBrep()
else:
mesh = obj
# Get and format vertex points in mesh, format from point3d object to float list
meshVerts = rs.MeshFaces(mesh, face_type=False)
totalArea = rs.MeshArea(mesh)
meshFaceCount = rs.MeshFaceCount(mesh)
PT01 = meshVerts[0::3]
PT01S = []
for i in PT01:
i = (i.X, i.Y, i.Z)
PT01S.append(i)
PT02 = meshVerts[1::3]
PT02S = []
for i in PT02:
i = (i.X, i.Y, i.Z)
PT02S.append(i)
PT03 = meshVerts[2::3]
PT03S = []
for i in PT03:
i = (i.X, i.Y, i.Z)
PT03S.append(i)
# format list together in order to loop through
triangleList = zip(PT01S, PT02S, PT03S)
################################################################################
# POINT SCATTER LOOP #
################################################################################
# loop through the three vertexes forming individual triangles
for i in triangleList:
a = i[0] # triangle vert 1
b = i[1] # triangle vert 2
c = i[2] # triangle vert 3
# Find area of triangle
dist01 = rs.Distance(a, b)
dist02 = rs.Distance(a, c)
dist03 = rs.Distance(b, c)
# Herons formula to find area of triangle by sides
s = (dist01 + dist02 + dist03) / 2
tArea = math.sqrt(s*(s-dist01)*(s-dist02)*(s-dist03))
# assign portion of points base on area of triangle, if assignment of points is lower then one, add that to the next assignment
numPtsPerUnit = totalArea[1] / scatterNum
ptAllocation = tArea / numPtsPerUnit
ptBucket = ptBucket + ptAllocation
if ptBucket < 1:
continue
else:
pointShare = int(math.floor(ptBucket))
ptBucket = 0
# Vectors from origin to either corner of triangle
ac = rs.VectorCreate(c, a)
ab = rs.VectorCreate(b, a)
originVector = rs.VectorCreate(a, (0, 0, 0))
# Generate random numbers between 0,1. Random scatter onto triangle
for i in range(pointShare):
r1 = random.random()
r2 = random.random()
if r1 + r2 < 1:
p = r1 * ac + r2 * ab
else:
p = (1 - r1) * ac + (1 - r2) * ab
points = rs.AddPoint(p)
pointList.append(points)
rs.MoveObjects(points, originVector)
################################################################################
# MOVE BLOCKS TO POINTS WITH ROTATION / SCALE #
################################################################################
# shuffle point list then split list by the number of blocks to scatter. Copy blocks to split lists
random.shuffle(pointList)
ptDivision = int(len(pointList) / len(blocks))
genList = chunks(pointList, ptDivision)
blockIndex = 0
for pts in genList: # looping through split point list and blocks and copying blocks to scatter
blockPt = rs.BlockInstanceInsertPoint(blocks[blockIndex])
for pt in pts:
vector = rs.VectorCreate(pt, blockPt)
newBlock = rs.CopyObject(blocks[blockIndex], vector)
# create list of blocks for later modification
blockList.append(newBlock)
if blockIndex < (len(blocks) - 1):
blockIndex += 1
# apply random scaling and rotation to blocks
if userRotation[0] == True:
for block in blockList:
centerPt = rs.BlockInstanceInsertPoint(block)
angle = random.randint(0, 360)
rs.RotateObject(block, centerPt, angle, worldZVector)
for block in blockList:
centerPt = rs.BlockInstanceInsertPoint(block)
scale = random.uniform((userScale/4), userScale)
rs.ScaleObject(block, centerPt, (scale, scale, scale))
# If a mesh was created, delete it, general cleanup
if isMesh == False:
rs.DeleteObject(mesh)
rs.DeleteObjects(pointList)
rs.EnableRedraw(True)
except:
print("Failed to execute")
rs.EnableRedraw(True)
return
biggestY = ydist
#create a bounding polyine
#not necessary but help see the border
polyline = rs.AddPolyline(boxpts[0:4])
#define endpoint of xmove vector
xpt = [xdist + offset, 0, 0]
#set totalX
totalX = totalX + xdist + offset
#define xmove vector
xmove = rs.VectorCreate(origin, xpt)
#add objects to the moved list
moved.append(joined)
moved.append(polyline)
#move all the objects
rs.MoveObjects(moved, xmove)
#increment the column count
columncount += 1
#check to see if the columncount is evenly divisible by the row
#if it is we need to move the column
if columncount % row == 0:
#get the biggestY value and add the offset
#I call this the formfeed (like a typewriter)
formfeed = biggestY + offset
#That makes this the carrigeReturn
#Ding!
carrigeReturn = [-totalX, formfeed, 0]
move = rs.VectorCreate(origin, carrigeReturn)
#We then move all the objects back and reset the
#biggestY and totalX values
__author__ = "dfmd"
__version__ = "2019.07.12"
import rhinoscriptsyntax as rs
surfaces = rs.GetObjects("Surfaces", rs.filter.surface,True,True)
tol = 10
y_distance = 0
if surfaces:
try:
rs.EnableRedraw(False)
for srf in surfaces:
urolled_srf = rs.UnrollSurface(srf, explode=False)
bounding_box = rs.BoundingBox(urolled_srf)
y_distance += rs.Distance(bounding_box[0],bounding_box[3]) + tol
move_vector = rs.VectorCreate((0,0,0),(0,y_distance,0))
rs.MoveObjects(urolled_srf,move_vector)
rs.EnableRedraw(True)
except Exception as e:
print('Error: %s' % e)
def drawRhombusOnRegularOffsetLine(emblem):
tmpObjs = []
for rhomboid in emblem.rhomboids:
objs = []
# 中点長方形の対角四角形
for i in range(len(rhomboid.midPts)):
p0 = rhomboid.midPts[i]
if (i == 0):
nextMidPt = rhomboid.midPts[i + 1]
prevtMidPt = rhomboid.midPts[len(rhomboid.midPts) - 1]
elif (i == len(rhomboid.midPts) - 1):
nextMidPt = rhomboid.midPts[0]
prevtMidPt = rhomboid.midPts[i - 1]
else:
nextMidPt = rhomboid.midPts[i + 1]
prevtMidPt = rhomboid.midPts[i - 1]
p1 = rs.VectorAdd(p0, nextMidPt)
p1 = rs.VectorDivide(p1, 2.0)
p2 = rhomboid.ellipsePts[0]
p3 = rs.VectorAdd(p0, prevtMidPt)
p3 = rs.VectorDivide(p3, 2.0)
pts = [p0, p1, p2, p3, p0]
obj = rs.AddPolyline(pts)
if (i % 2 == 0):
rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[1].no)
else:
rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[0].no)
objs.append(obj)
# 外周面
pts = []
for pt in rhomboid.pts:
pts.append(pt)
pts.append(pts[0])
obj = rs.AddPolyline(pts)
rs.ObjectLayer(obj, "srfRhomboid")
objs.append(obj)
# 外周線
for i in range(len(rhomboid.pts)):
if (i == len(rhomboid.pts) - 1):
obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[0])
else:
obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[i + 1])
rs.ObjectLayer(obj, "lineBlack")
objs.append(obj)
# move to center
objs = rs.MoveObjects(objs, [
-rhomboid.ellipsePts[0][0], -rhomboid.ellipsePts[0][1],
-rhomboid.ellipsePts[0][2]
])
# rotate
xform = rs.XformRotation2(rhomboid.rotateAng, [0, 0, 1], [0, 0, 0])
rs.TransformObjects(objs, xform)
# move
pts = rs.LineLineIntersection(
[rhomboid.lines[0].sPt, rhomboid.lines[0].ePt],
[rhomboid.lines[1].sPt, rhomboid.lines[1].ePt])
rs.MoveObjects(objs, pts[0])
# tmpObjs
for obj in objs:
tmpObjs.append(obj)
return tmpObjs
