def proof_placement(self, checkbuildspace=True):
# color objects
self.correctplacement = True
print 'Moving to zero level'
for obj in self.objIds:
BB = rs.BoundingBox(obj)
rs.MoveObject(obj, [0, 0, -BB[0][2]])
BB = rs.BoundingBox(obj)
if checkbuildspace:
print 'Checking positioning'
for point in BB:
if point[0] < 0 or point[0] > 241:
rs.ObjectColor(obj, (255, 0, 0))
self.correctplacement = False
break
else:
rs.ObjectColor(obj, (0, 255, 0))
if point[1] < 0 or point[1] > 209:
rs.ObjectColor(obj, (255, 0, 0))
self.correctplacement = False
break
else:
rs.ObjectColor(obj, (0, 255, 0))
if point[2] < 0 or point[2] > 205:
rs.ObjectColor(obj, (255, 0, 0))
self.correctplacement = False
break
else:
rs.ObjectColor(obj, (0, 255, 0))
def GetPointDynamicDrawFuncHide(sender, args):
obj_all = rs.VisibleObjects()
rs.HideObjects(obj_all)
cursPos = rs.GetCursorPos()
viewSize = rs.ViewSize()
stepSize = int(viewSize[1] / _NUM_LAYER)
obj_Layer1 = 'Layer: 000001 Wall1'
obj_Layer2 = 'Layer: 000002 Wall1'
settings = Rhino.DocObjects.ObjectEnumeratorSettings()
settings.HiddenObjects = True
settings.NameFilter = obj_Layer1
ids_L1 = [rhobj.Id for rhobj in scriptcontext.doc.Objects.GetObjectList(settings)]
settings.NameFilter = obj_Layer2
ids_L2 = [rhobj.Id for rhobj in scriptcontext.doc.Objects.GetObjectList(settings)]
z_L1 = rs.BoundingBox(ids_L1[0])[0][2]
z_L2 = rs.BoundingBox(ids_L2[0])[0][2]
zVal = viewSize[1] - cursPos[3][1]
z_level = int(zVal / stepSize)
segmentList = ['Wall',
'DenseInfill',
'SparseInfill',
'Brim',
'Skirt',
'Support']
zero_str = '000000'
settings = ObjectEnumeratorSettings()
settings.HiddenObjects = True
for segment in segmentList:
i = 0
while 1:
i += 1
obj_LayerZ = str('Layer: ' + zero_str[:-len(str(z_level))] + str(z_level) + ' ' + segment + str(i))
try:
settings.NameFilter = obj_LayerZ
ids_LZ = [rhobj.Id for rhobj in scriptcontext.doc.Objects.GetObjectList(settings)]
if len(ids_LZ) == 0:
break
# rs.SelectObject(ids_LZ)
rs.ShowObject(ids_LZ)
except:
print 'not found'
args.Display.DrawDot(args.CurrentPoint, 'Layer ' + str(z_level) + ' - Distance ' + str(z_L2 - z_L1) + ' mm')
Rhino.Display.RhinoView.Redraw(scriptcontext.doc.Views.ActiveView)
Rhino.RhinoApp.Wait()
def splitModel(objs, cutLevel):
point = Rhino.Geometry.Point3d(0,0,cutLevel)
belowDir = rs.AddLine(point, [0,0,-9999])
aboveDir = rs.AddLine(point, [0,0,9999])
circle = rs.AddCircle(point, 9999)
circleSrf = rs.AddPlanarSrf(circle)
aboveGroup = rs.AddGroup("Above")
belowGroup = rs.AddGroup("Below")
for obj in objs:
ptBtm = rs.BoundingBox(obj)[0]
ptTop = rs.BoundingBox(obj)[6]
if ptBtm[2]>cutLevel:
intersecting = False
rs.AddObjectToGroup(obj, "Above")
#print "Object Above"
elif ptTop[2]<cutLevel:
intersecting = False
rs.AddObjectToGroup(obj, "Below")
#print "Object Below"
else:
intersecting = True
if intersecting:
if rs.IsBrep(obj):
closed = False
if rs.IsPolysurfaceClosed(obj):
closed = True
try:
copy = rs.CopyObject(obj)
splitSrfs = rs.SplitBrep(obj, circleSrf, True)
for splitSrf in splitSrfs:
#print "looping"
if closed:
rs.CapPlanarHoles(splitSrf)
rs.MatchObjectAttributes(splitSrf, copy)
ptBtm = rs.BoundingBox(splitSrf)[0]
ptTop = rs.BoundingBox(splitSrf)[6]
mdPtZ = (ptBtm[2] + ptTop[2]) / 2
if mdPtZ>cutLevel:
rs.AddObjectToGroup(splitSrf, "Above")
else:
rs.AddObjectToGroup(splitSrf, "Below")
rs.DeleteObject(copy)
rs.DeleteObject(obj)
except:
None
if rs.IsBlockInstance(obj):
contents = rs.ExplodeBlockInstance(obj)
for content in contents:
objs.append(content)
rs.DeleteObject(belowDir)
rs.DeleteObject(aboveDir)
rs.DeleteObject(circle)
rs.DeleteObject(circleSrf)
def findHOffset(prevCrv, currentCrv):
#The offset is equal to the width of the previous footprint's bounding box plus 1/8 of the width of the current footprint's bounding box. Returns the x-transformation amount.
prevBox = rs.BoundingBox(prevCrv, in_world_coords=True)
currentBox = rs.BoundingBox(currentCrv, in_world_coords=True)
prevSpacing = rs.Distance(prevBox[0], prevBox[1])
currentSpacing = rs.Distance(currentBox[0], currentBox[1])
currentSpacing = currentSpacing * 0.25
offset = prevSpacing + currentSpacing
return offset
def nesting(self):
auto_nesting = True
if len(self.objIds) > 1:
print 'Checking intersections'
# proof if objects have intersections
bBoxCo = []
for obj, i in zip(self.objIds, range(len(self.objIds))):
bBoxCo.append(rs.BoundingBox(obj))
for obj, i in zip(self.objIds, range(len(self.objIds))):
rs.ObjectColor(obj, (0, 255, 0))
objIds_tmp = copy.deepcopy(self.objIds)
objIds_tmp.remove(obj)
for objCompare in objIds_tmp:
intersect = rs.MeshMeshIntersection(obj, objCompare)
if intersect is not None:
rs.ObjectColor(obj, (255, 0, 0))
rs.ObjectColor(objCompare, (255, 0, 0))
self.correctplacement = False
if auto_nesting:
BB = rs.BoundingBox(obj)
BBComp = rs.BoundingBox(objCompare)
xmin_BB = BB[0][0]
xmax_BB = BB[1][0]
ymin_BB = BB[0][1]
ymax_BB = BB[3][1]
xmin_BBComp = BBComp[0][0]
xmax_BBComp = BBComp[1][0]
ymin_BBComp = BBComp[0][1]
ymax_BBComp = BBComp[3][1]
if xmin_BBComp >= xmin_BB and xmin_BBComp <= xmax_BB:
print 'Correcting x value'
# x_delta_to_min = xmin_BBComp - xmin_BB
x_delta_to_max = xmin_BBComp - xmax_BB
rs.MoveObject(objCompare,
[abs(x_delta_to_max), 0, 0])
if xmax_BBComp >= xmin_BB and xmax_BBComp <= xmax_BB:
print 'Correcting xvalue 2'
if ymin_BBComp >= ymin_BB and ymin_BBComp <= ymax_BB:
print 'Correcting y value'
# y_delta_to_min = ymin_BBComp - ymin_BB
y_delta_to_max = ymin_BBComp - ymax_BB
rs.MoveObject(objCompare,
[0, abs(y_delta_to_max), 0])
if ymax_BBComp >= ymin_BB and ymax_BBComp <= ymax_BB:
print 'Correcting y value 2'
def main():
objs = rs.GetObjects("Select Objects to Number", preselect = True)
if objs is None: return
pts = []
for obj in objs:
pt0 = rs.BoundingBox(obj)[0]
pt2 = rs.BoundingBox(obj)[2]
centerPt = rs.PointDivide(rs.PointAdd(pt0, pt2), 2)
pts.append(centerPt)
sortedPts = proximityPts(pts,0)
addNumberTag(sortedPts, objs)
print len(sortedPts)
def duplicateAndRotate():
obj_ids = rs.GetObjects("Select object(s) to duplicate and rotate", 0,
True, True)
if obj_ids is None: return
box = rs.BoundingBox(obj_ids)
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)
copied_obj_ids = rs.CopyObjects(obj_ids, translation2)
xyp = rs.WorldXYPlane()
rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[0])
rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[1])
rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[2])
def main():
counts = [0, 0, 0]
spacings = [10, 10, 10]
rotations = [0, 0, 0]
counts[0] = rs.GetInteger("number in x direction", minimum=1)
# counts[1] = rs.GetInteger("number in y direction", minimum=1)
# counts[2] = rs.GetInteger("number in z direction", minimum=1)
spacings[0] = rs.GetReal("x spacing")
# spacings[1] = rs.GetReal("y spacing")
# spacings[2] = rs.GetReal("z spacing")
rotations[0] = rs.GetReal("rotation of each object along x axis")
# rotations[1] = rs.GetReal("y spacing")
# rotations[2] = rs.GetReal("z spacing")
print "count", counts
print "spacing", spacings
print "rotation", rotations
for ix in range(counts[0]):
newobj = rs.CopyObject(obj, [spacings[0] * ix, 0, 0])
bbox = rs.BoundingBox(newobj)
if bbox:
centroid = rs.PointSubtract(bbox[0], bbox[6])
print bbox[6], bbox[0]
print centroid
rs.AddPoint(centroid)
else:
print "no bbox"
def brepOrExtrusionOfBlock_ShadedPick(rdInstRef, ptPicked, planeCam):
"""Create intersecting line that passes through the actual picked point.
Its vector is that of the camera view.
The line extends to the bounding box of the block instance."""
vector = rg.Vector3d.Negate(planeCam.ZAxis)
ptOnCameraPlane = planeCam.ClosestPoint(ptPicked)
pts_bbox = rs.BoundingBox(rdInstRef.Id)
bbox = rg.BoundingBox(pts_bbox[0], pts_bbox[6])
rgLine = rg.Line(ptOnCameraPlane, vector, 1.)
rgLine.ExtendThroughBox(bbox)
rgLineCrv = rg.LineCurve(rgLine)
rgBreps_Intrsct, pts_Intrsct_All = (
brepsOrExtrusionsAndPtsInBlockInstThatIntrsctLine(
rdInstRef, rgLineCrv))
rgObj_Nearest = pt_Nearest = None
for i, pts_Intrsct in enumerate(pts_Intrsct_All):
for pt_Intrsct in pts_Intrsct:
fDistPtToPlane = ptOnCameraPlane.DistanceTo(pt_Intrsct)
if pt_Nearest is None or fDistPtToPlane < fDistPtToPlane_Min:
rgObj_Nearest = rgBreps_Intrsct[i]
pt_Nearest = pt_Intrsct
fDistPtToPlane_Min = fDistPtToPlane
return rgObj_Nearest, pt_Nearest
def genHalfPlanes(site_crv, int_crv):
B = rs.BoundingBox(site_crv)
polyBB = rs.AddPolyline([B[0], B[1], B[2], B[3], B[0]])
diagB = 2 * rs.Distance(B[0], B[2])
rays = []
int_pts = rs.CurvePoints(int_crv)
bsp_tree = []
bsp_tree.append(site_crv)
for i in range(len(int_pts) - 1):
a = int_pts[i]
b = int_pts[i + 1]
m = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2, 0]
p = [
m[0] + (a[0] - m[0]) * diagB / (rs.Distance(a, m)),
m[1] + (a[1] - m[1]) * diagB / (rs.Distance(a, m)), 0
]
q = [
m[0] + (b[0] - m[0]) * diagB / (rs.Distance(b, m)),
m[1] + (b[1] - m[1]) * diagB / (rs.Distance(b, m)), 0
]
u = [q[0] - p[0], q[1] - p[1], 0]
v = [-u[1], u[0], 0]
r = [p[0] + v[0], p[1] + v[1], 0]
s = [q[0] + v[0], q[1] + v[1], 0]
w = [u[1], -u[0], 0]
R = [p[0] + w[0], p[1] + w[1], 0]
S = [q[0] + w[0], q[1] + w[1], 0]
polyA = rs.AddPolyline([p, q, s, r, p])
polyB = rs.AddPolyline([p, q, S, R, p])
used_crv = []
new_crv = []
for bsp_crv in bsp_tree:
sum = 0
try:
crvA = rs.CurveBooleanIntersection(bsp_crv, polyA)
new_crv.append(crvA)
sum += 1
except:
pass
try:
crvB = rs.CurveBooleanIntersection(bsp_crv, polyB)
new_crv.append(crvB)
sum += 1
except:
pass
if (sum > 0):
used_crv.append(bsp_crv)
for crv in new_crv:
bsp_tree.append(crv)
for crv in used_crv:
bsp_tree.remove(crv)
rs.DeleteObject(crv)
rs.DeleteObject(polyA)
rs.DeleteObject(polyB)
rs.DeleteObject(polyBB)
return bsp_tree
def transformMatrix():
obj_ids = rs.GetObjects("Select object(s) from which to create matrix", 0,
True, True)
if obj_ids is None: return
box = rs.BoundingBox(obj_ids)
if not isinstance(box, list): return
origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2)
endpt = rs.GetPoint("To point")
newpt = [1, 1, 1]
translation1 = rs.VectorCreate(endpt, newpt)
translation2 = rs.VectorCreate(translation1, origin)
copied_obj_ids = rs.CopyObjects(obj_ids, translation2)
for obj in copied_obj_ids:
matrix = []
degrees = 90.0 # Some angle
radians = math.radians(degrees)
c = math.cos(radians)
s = math.sin(radians)
matrix.append([c, -s, 0, 0])
matrix.append([s, c, 0, 0])
matrix.append([0, 0, 1, 0])
matrix.append([0, 0, 0, 1])
pprint.pprint(matrix)
rs.ScaleObject(obj, newpt, [3, 1, -9])
plane = rs.ViewCPlane()
pprint.pprint(plane)
rs.RotateObject(obj, newpt, uniform(0, 360), plane.XAxis)
rs.RotateObject(obj, newpt, uniform(0, 360), plane.YAxis)
rs.RotateObject(obj, newpt, uniform(0, 360), plane.ZAxis)
def calculateWidth(files):
global box_width
for filename in files:
join_string = str(input_directory + filename)
combined_string = '!_Import ' + '"' + join_string + '"'
rs.Command(combined_string)
objs = rs.LastCreatedObjects(select=False)[0]
bounding_pts = rs.BoundingBox([objs], view_or_plane=rs.WorldXYPlane())
maxX = 0
minX = 0
minY = 0
minZ = 0
for pt in bounding_pts:
if pt[0] < minX:
minX = pt[0]
if pt[0] > maxX:
maxX = pt[0]
if pt[1] < minY:
minY = pt[1]
if pt[2] < minZ:
minZ = pt[2]
if abs(maxX - minX) > box_width:
box_width = abs(maxX - minX)
rs.DeleteObject(objs)
def get_bounding_dims(brep):
"""return bounding box x,y,z dims for a brep or many breps"""
bb = rs.BoundingBox(brep)
Dimensions = namedtuple('Dimensions', 'X Y Z')
dims = Dimensions(rs.Distance(bb[0], bb[1]), rs.Distance(bb[0], bb[3]),
rs.Distance(bb[0], bb[4]))
return dims
def construct_mesh_center(points):
meshes = []
### calc center point
bbox = rs.BoundingBox(points)
line = rs.AddLine(bbox[0], bbox[6])
c = rs.CurveMidPoint(line)
### set new point list
points.append(c)
###
c_index = len(points) - 1
# print(c_index)
for j in xrange(len(points) - 1):
if j < (len(points) - 2):
vertex_ = [(c_index, int(j), int(j) + 1, int(j) + 1)]
# print(vertex_)
m = rs.AddMesh(points, vertex_)
meshes.append(m)
else:
vertex_ = [(c_index, int(j), 0, 0)]
# print(vertex_)
m = rs.AddMesh(points, vertex_)
meshes.append(m)
mesh_joined = rs.JoinMeshes(meshes)
return mesh_joined
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 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 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 AddBlockName(obj):
name = rs.BlockInstanceName(obj)
pt = rs.BlockInstanceInsertPoint(obj)
bb = rs.BoundingBox(obj)
text = rs.AddText(name, (bb[0] + bb[6]) / 2)
rs.SetUserText(text, 'tag', 'label')
group = rs.AddGroup()
rs.AddObjectsToGroup([obj, text], group)
def getBounds( r, c ):
bb = rs.BoundingBox(c)
w = abs(bb[0].X - bb[1].X)
h = abs(bb[0].Y - bb[2].Y)
if r:
return "width=\"%f\" height=\"%f\"" %(h + pad*2,w + pad*2)
else:
return "width=\"%f\" height=\"%f\"" %(w + pad*2,h + pad*2)
def meetsLength(len, startCrv, endCrv):
objects = [startCrv, endCrv]
boundingBox = rs.BoundingBox(objects, in_world_coords=True)
curLen = rs.Distance(boundingBox[0], boundingBox[1])
if curLen >= len:
return True
else:
return False
def main():
objs = rs.GetObjects()
for obj in objs:
pts = rs.BoundingBox(obj)
ctrPt = (pts[0] + pts[2]) / 2
RandomRotate(obj, ctrPt, 0, 360)
RandomScaling(obj, ctrPt, .8, 1.2)
def DropBlockToSurface():
try:
obj = rs.GetObjects('Select Objects',
rs.filter.curve | rs.filter.instance
| rs.filter.mesh | rs.filter.surface
| rs.filter.subd | rs.filter.light
| rs.filter.polysurface,
preselect=True)
srf = rs.GetObject('Select Surface')
if obj:
if srf:
rs.EnableRedraw(False)
# Check if srf is a mesh, if so convert to Nurb
isMesh = rs.IsMesh(srf)
if isMesh == True:
srf = rs.MeshToNurb(srf)
# For each object send test rays up and down in Z coord
# Move each object to the ray test that hits a srf
for i in obj:
bndBox = rs.BoundingBox(i)
pt1 = bndBox[0]
pt2 = bndBox[2]
crv = rs.AddLine(pt1, pt2)
if crv:
midcrv = rs.CurveMidPoint(crv)
rs.DeleteObject(crv)
ray_pt_up = rs.ShootRay(srf,
midcrv, (0, 0, 1),
reflections=1)
ray_pt_down = rs.ShootRay(srf,
midcrv, (0, 0, -1),
reflections=1)
if ray_pt_up:
vector = rs.VectorCreate(ray_pt_up[1], midcrv)
rs.MoveObject(i, vector)
if ray_pt_down:
vector = rs.VectorCreate(ray_pt_down[1], midcrv)
rs.MoveObject(i, vector)
# deleate any created srf
if isMesh == True:
rs.DeleteObject(srf)
rs.EnableRedraw(True)
except:
print("Failed to execute")
rs.EnableRedraw(True)
return
def testDuplications():
print("\n testDuplications commands \n")
obj_ids = rs.GetObjects(
"Select object(s) from which to create the rectangular matrix", 0,
True, True)
if obj_ids is None: return
box = rs.BoundingBox(obj_ids)
if not isinstance(box, list): return
origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2)
nXdups = rs.GetInteger("Duplications X", 1, 1)
rXdups = rs.GetReal("Duplications X rand", 0, 0, 100) / 100
nYdups = rs.GetInteger("Duplications Y", 1, 1)
rYdups = rs.GetReal("Duplications Y rand", 0, 0, 100) / 100
nZdups = rs.GetInteger("Duplications Z", 1, 1)
rZdups = rs.GetReal("Duplications Z rand", 0, 0, 100) / 100
rKeep = 1 - rs.GetReal("Percent to erase", 0, 0, 100) / 100
endpt = rs.GetPoint("To point")
calc_val_real = lambda val, rand: val + random.uniform(
-rand * val, rand * val)
calc_val_int = lambda val, rand: val + int(
round(random.uniform(-rand * val, rand * val)))
xspace = 3
yspace = 3
zspace = 3
xdups = calc_val_int(nXdups, rXdups)
ydups = calc_val_int(nYdups, rYdups)
zdups = calc_val_int(nZdups, rZdups)
translations = []
# Copy Points with Spacing
for k in range(zdups):
for j in range(ydups):
for i in range(xdups):
newpt = [
origin[0] + i * xspace, origin[1] + j * yspace,
origin[2] + k * zspace
]
translations = translations + [rs.VectorCreate(endpt, newpt)]
nObjs = len(translations)
print(nObjs)
objs_to_keep = random.sample(range(nObjs), int(round(nObjs * rKeep)))
translations = [translations[i] for i in objs_to_keep]
copied_objs = []
for tr in translations:
copied_objs = copied_objs + rs.CopyObjects(obj_ids, tr)
def IsAbovePlane(obj, elevation):
pts = rs.BoundingBox(obj)
lowestCoord = pts[0][2]
highestCoord = pts[-1][2]
centerPtZ = (lowestCoord + highestCoord) / 2
if centerPtZ > elevation:
return True
else:
return False
def get_bounding_rectangle(self):
'''
Assuming the island is planar, gets the four points bounding the current representation
of the island. BoundingBox returns a list of 8 points. This returns the first four (the
base of the box)
'''
full_box = rs.BoundingBox(self.get_perimeter_geometry(),
view_or_plane=island_plane)
return full_box[0:4]
def process_floor(in_objects, floor_outline, outline_cut_height=None):
"""function used to process an individual floor.
input:
in_objects: the internal curves and breps selected for this floor
floor_outline: the outline brep for the envelope
outline_cut_height: height to cut at.
output: (crv,[crv])
crv: the offset boundary curve for the floor
[crv]: the internal curves for the floor
pt: lower-left reference point
bdims = bounding dims of this floor
"""
#classify the inputs
in_crvs, in_breps = brep_or_crv(in_objects)
#get list of crvs to project
brep_sections = []
for b in in_breps:
cut_height = wge.get_brep_height(b) / 2
pcurves = wge.get_brep_plan_cut(rs.coercebrep(b), cut_height, D_TOL)
brep_sections.extend(pcurves)
b_section_guids = wru.add_curves_to_layer(brep_sections, LCUT_INDICES[0])
in_crvs.extend(b_section_guids)
#get the outline brep curve
if not outline_cut_height:
outline_cut_height = wge.get_brep_height(floor_outline)
floor_outline_crvs = wge.get_brep_plan_cut(rs.coercebrep(floor_outline),
outline_cut_height, D_TOL)
floor_outline_crvs = wru.add_curves_to_layer(floor_outline_crvs,
LCUT_INDICES[1])
#get bounding info for the floor outline
bb = rs.BoundingBox(floor_outline)
corner = bb[0]
bdims = wge.get_bounding_dims(floor_outline)
proj_srf = rs.AddSrfPt([bb[0], bb[1], bb[2], bb[3]])
internal_crvs = rs.ProjectCurveToSurface(in_crvs, proj_srf,
[0, 0, -1]) if in_crvs else []
offset_floor_crv = rs.ProjectCurveToSurface(floor_outline_crvs, proj_srf,
[0, 0, -1])
#rs.DeleteObjects(in_crvs)
rs.DeleteObjects(floor_outline_crvs)
rs.DeleteObject(proj_srf)
out_floor_crvs = rs.coercecurve(offset_floor_crv)
out_internal_crvs = [rs.coercecurve(x) for x in internal_crvs]
rs.DeleteObject(offset_floor_crv)
rs.DeleteObjects(internal_crvs)
rs.DeleteObjects(b_section_guids)
#TODO: make sure objects are being deleted
return out_floor_crvs, out_internal_crvs, corner, bdims
def createSectionBox(obj):
box = rs.BoundingBox(obj)
bb = rs.AddBox(box)
faces = rs.ExplodePolysurfaces(bb)
faces = [rs.FlipSurface(x) for x in faces]
planes = [getSrfFrame(x) for x in faces]
clips = [rs.AddClippingPlane(x, 1000, 1000) for x in planes]
group = rs.AddGroup()
rs.AddObjectsToGroup(clips, group)
return clips
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
def testArrangement(sortedCurves, factor):
totalBox = rs.BoundingBox(sortedCurves)
sqrtSource = rs.Distance(totalBox[0], totalBox[1])
minLength = sqrtSource**0.5
minLength = minLength**factor
def meetsLength(len, startCrv, endCrv):
objects = [startCrv, endCrv]
boundingBox = rs.BoundingBox(objects, in_world_coords=True)
curLen = rs.Distance(boundingBox[0], boundingBox[1])
if curLen >= len:
return True
else:
return False
#Then, defining a list of the resulting lists.
listOfLists = []
s = 0 #"Start"
e = 0 #"End"
#Loop that splits the list into smaller lists.
while True:
if (s + e) == len(sortedCurves) or s == len(sortedCurves):
listOfLists.append(sortedCurves[s:s + e])
break
elif meetsLength(minLength, sortedCurves[s],
sortedCurves[s + e]) == True:
listOfLists.append(sortedCurves[s:s + e])
s = s + e
e = 1
continue
else:
e += 1
continue
#Now to move them vertically. First, like with the horizontal movement, we need to create a function that finds the vertical offset between each line.
def findVOffset(curCrv):
currentBox = rs.BoundingBox(curCrv, in_world_coords=True)
vHeight = rs.Distance(currentBox[0], currentBox[3])
offset = vHeight * 1.125
offset = 0 - offset
return offset
#And to move them.
for i in range(len(listOfLists)):
if i == len(listOfLists) - 1:
break
else:
rs.MoveObject(
listOfLists[i + 1],
rs.VectorCreate(findAnchorPoint(listOfLists[i]),
findAnchorPoint(listOfLists[i + 1])))
rs.MoveObject(listOfLists[i + 1],
(0, findVOffset(listOfLists[i + 1]), 0))
def getLowestPoint(obj):
box = rs.BoundingBox(obj)
min = 1e20
lowest = None
if box:
for i, point in enumerate(box):
if point.Z < min:
min = point.Z
lowest = point
return lowest
