def delResult(self):
for i in self.req_obj:
srf = i.getSrf()
try:
rs.DeleteObjects(srf)
except:
try:
rs.DeleteObjects(srf)
except:
pass
int_poly = i.getReqPoly()
try:
rs.DeleteObjects(int_poly)
except:
try:
rs.DeleteObject(int_poly)
except:
pass
bound_poly = i.getGenPoly()
try:
rs.DeleteObjects(bound_poly)
except:
try:
rs.DeleteObject(bound_poly)
except:
pass
def setSensorLocation():
projectedPtList = []
# Select boundary surface
boundarySrf = rs.GetObject("Select surface for making boundary",
rs.filter.surface)
# For making location point with grid
direction = (0, 0, 100)
plane = rs.MoveObject(boundarySrf, direction)
# Dividing surface to points
ptList = ArrayPointsOnSurface(plane)
# point projection
projectedSrf = rs.GetObject("Select surface for projection",
rs.filter.surface)
for point in ptList:
pointsOnModel = rs.ProjectPointToSurface(point, projectedSrf,
(0, 0, 1))
projectedPt = rs.AddPoint(pointsOnModel[0][0], pointsOnModel[0][1],
pointsOnModel[0][2])
projectedPtList.append(projectedPt)
rs.DeleteObjects(plane)
rs.DeleteObjects(ptList)
return projectedPtList
def unionAllCurves(Curves):
res = []
for curveCount in range(0, len(Curves), 2):
try:
sc.doc = rc.RhinoDoc.ActiveDoc #change target document
rs.EnableRedraw(False)
guid1 = sc.doc.Objects.AddCurve(Curves[curveCount])
guid2 = sc.doc.Objects.AddCurve(Curves[curveCount + 1])
all = rs.CurveBooleanUnion([guid1, guid2])
rs.DeleteObjects(guid1)
rs.DeleteObjects(guid2)
if all:
a = [rs.coercegeometry(a) for a in all]
for g in a: g.EnsurePrivateCopy() #must ensure copy if we delete from doc
rs.DeleteObjects(all)
sc.doc = ghdoc #put back document
rs.EnableRedraw()
if a == None:
a = [Curves[curveCount], Curves[curveCount + 1]]
except:
rs.DeleteObjects(guid1)
sc.doc = ghdoc #put back document
rs.EnableRedraw()
a = [Curves[curveCount]]
if a:
res.extend(a)
return res
def SplitObject(solid, cSrf):
preInnerSrf = rs.CopyObject(cSrf)
innerSrfs = rs.TrimBrep(preInnerSrf, solid)
if not innerSrfs:
rs.DeleteObject(preInnerSrf)
return [solid]
solids = []
solids.append(solid)
for srf in innerSrfs:
newSolids = []
for obj in solids:
splitObjs = rs.SplitBrep(obj, srf, True)
if not splitObjs:
newSolids.append(obj)
else:
for sObj in splitObjs:
toJoin = [sObj, srf]
newSolids.append(rs.JoinSurfaces(toJoin))
rs.DeleteObjects(splitObjs)
solids = newSolids
rs.DeleteObjects(innerSrfs)
return solids
def recSplit(self, iniPts, counter=0):
p=iniPts
vertical=False
if(rs.Distance(p[0],p[1])>rs.Distance(p[0],p[3])):
vertical=True
if(vertical==True):
p0,p1=self.verSplit(iniPts)
else:
p0,p1=self.horSplit(iniPts)
poly0=rs.AddPolyline(p0)
poly1=rs.AddPolyline(p1)
counter+=1
if(counter<3):
pts0=self.getIntxCrv(poly0)
pts1=self.getIntxCrv(poly1)
rs.DeleteObjects([poly0,poly1])
self.recSplit(pts0,counter)
self.recSplit(pts1,counter)
else:
intxCrv0=rs.CurveBooleanIntersection(self.SITECRV,poly0)
intxCrv1=rs.CurveBooleanIntersection(self.SITECRV,poly1)
for i in intxCrv0:
self.FPOLY.append(i)
for i in intxCrv1:
self.FPOLY.append(i)
rs.DeleteObjects([poly0,poly1])
rs.DeleteObject(self.crv)
def isShareEdge(srf1, srf2):
border1 = rs.DuplicateSurfaceBorder(srf1)
border2 = rs.DuplicateSurfaceBorder(srf2)
edges1 = rs.ExplodeCurves(border1, True)
edges2 = rs.ExplodeCurves(border2, True)
shareMid = []
threshold = 0.001
flag = False
for e1 in edges1:
for e2 in edges2:
mid1 = rs.CurveMidPoint(e1)
mid2 = rs.CurveMidPoint(e2)
if rs.Distance(mid1, mid2) < threshold:
s1 = rs.CurveStartPoint(e1)
s2 = rs.CurveStartPoint(e2)
e1 = rs.CurveEndPoint(e1)
e2 = rs.CurveEndPoint(e2)
if rs.Distance(s1, s1) < threshold:
flag = True
break
if rs.Distance(s1, e1) < threshold:
flag = True
break
rs.DeleteObjects(edges1)
rs.DeleteObjects(edges2)
return flag
def divideSrfToPattern(srf, facadeType):
top, bot, verts = getSrfTopBotVertCrvs(srf)
if bot is None:
print('bot is None exit')
return None
if not rs.IsCurve(bot):
print('bot is not Curve exit')
return None
if len(verts) < 1:
print('len(verts)<1')
return None
if not rs.IsCurve(verts[0]):
print('verts[0] is not a curve')
return None
p0 = rs.CurveStartPoint(verts[0])
p1 = rs.CurveEndPoint(verts[0])
if p1[2] > p0[2]: vect = p1 - p0
else: vect = p0 - p1
print(vect)
rs.EnableRedraw(False)
m = meshExtrudeCrvToPattern(bot, facadeType, vect)
rs.DeleteObjects([top, bot])
rs.DeleteObjects(verts)
rs.EnableRedraw(True)
return m
def cut_building_volumes(terrain_section_breps, bldg_section_breps):
"""
input: list of lists of extruded terrain breps and section breps.
first level of list is section heights, second level is breps.
output: the new terrain breps
"""
#boolean problem is caused by non-manifold error. need to scale the B_breps prior to booleaning.
new_terrain_section_breps = []
for i, brep_level in enumerate(terrain_section_breps):
new_level_terrain_section_breps = []
for A_brep in brep_level:
#rs.ObjectLayer(A_brep,"s10") #debug
B_breps = rs.CopyObjects(bldg_section_breps[i])
#[rs.ObjectLayer(B_brep,"s11") for B_brep in B_breps] #debug
boolean_result = rs.BooleanDifference([A_brep], B_breps, False)
if boolean_result:
c = [rs.CopyObject(x) for x in boolean_result]
rs.DeleteObjects(boolean_result)
new_level_terrain_section_breps.extend(c)
else:
new_level_terrain_section_breps.append(rs.CopyObject(A_brep))
#print new_level_terrain_section_breps
rs.DeleteObjects(A_brep)
rs.DeleteObjects(B_breps)
rs.DeleteObjects(B_breps) #possibly not needed
rs.DeleteObjects(boolean_result)
#rs.ObjectLayer(new_level_terrain_section_breps,"s3")
new_terrain_section_breps.append(new_level_terrain_section_breps)
return new_terrain_section_breps
def createcurvaturegraph():
curve_ids = rs.GetObjects("Curves for curvature graph", 4, False, True,
True)
if not curve_ids: return
samples = 10
scale = 1.0
preview = []
while True:
rs.EnableRedraw(False)
for p in preview:
rs.DeleteObjects(p)
preview = []
for id in curve_ids:
cg = addcurvaturegraph(id, samples, scale)
preview.append(cg)
rs.EnableRedraw(True)
result = rs.GetString("Curvature settings", "Accept",
("Samples", "Scale", "Accept"))
if not result:
for p in preview:
rs.DeleteObjects(p)
break
result = result.upper()
if result == "ACCEPT": break
elif result == "SAMPLES":
numsamples = rs.GetInteger("Number of samples per knot-span",
samples, 3, 100)
if numsamples: samples = numsamples
elif result == "SCALE":
sc = rs.GetReal("Scale of the graph", scale, 0.01, 1000.0)
if sc: scale = sc
def teardown(cfg):
print("teardown")
cfg['view'].Close()
"""
activate_display_mode(cfg['view_restore']['disp_mode'], cfg)
cfg['view'].Maximized = cfg['view_restore']['maximized']
cfg['view'].Size = cfg['view_restore']['size']
"""
if 'pad_obj_ids' in cfg and cfg['pad_obj_ids']:
print("... deleting padding objects")
rs.DeleteObjects(cfg['pad_obj_ids'])
if 'tmp_obj_ids' in cfg and cfg['tmp_obj_ids']:
print("... deleting xformed objects")
rs.DeleteObjects(cfg['tmp_obj_ids'])
if 'rot_group' in cfg and cfg['rot_group']:
print("... rotating objects back to their starting position")
rxf = rs.XformRotation2(-cfg['tot_rot'], (0, 0, 1),
cfg['rot_group']['bbox'].Center)
rs.TransformObjects(cfg['rot_group']['obj_ids'], rxf)
show_all_groups(cfg)
sc.doc.RenderSettings = cfg['render_settings']
for mode in cfg['display_modes'].keys():
if mode == 'rndr': continue
if not Rhino.Display.DisplayModeDescription.DeleteDiplayMode(
cfg['display_modes'][mode].Id):
print(
"Temporary display mode {} was not deleted. Consider removing this yourself."
.format(cfg['display_modes'][mode].EnglishName))
delete_residual_display_modes()
return
def wallProfile(polySrf):
if polySrf:
offsets = []
border = rs.DuplicateSurfaceBorder(polySrf)
rs.SimplifyCurve(border)
offsets.append(rs.OffsetCurve(border, [0, 0, 0], width / 2))
faces = rs.ExplodePolysurfaces(polySrf, False)
faceborders = [rs.DuplicateSurfaceBorder(face) for face in faces]
rs.DeleteObjects(faces)
for faceborder in faceborders:
rs.SimplifyCurve(faceborder)
centroid = rs.CurveAreaCentroid(faceborder)
offsets.append(rs.OffsetCurve(faceborder, centroid[0], width / 2))
rs.DeleteObjects(faceborders)
srf = rs.AddPlanarSrf(offsets)
rs.DeleteObjects(border)
rs.DeleteObjects(offsets)
return srf
def sweepSec(crv, plane, vec):
rect = profileXform(rectFrame(), plane, vec)
sweep = rs.AddSweep1(crv, rect, closed=True)
sweep = rs.CapPlanarHoles(sweep)
if rect: rs.DeleteObjects(rect)
if crv: rs.DeleteObjects(crv)
return sweep
def squareSect(crv,width,height):
sections=[]
divPts=rs.DivideCurve(crv,10)
keep=True
for i in range(len(divPts)):
param=rs.CurveClosestPoint(crv,divPts[i])
tan=rs.CurveTangent(crv,param)
plane=rs.PlaneFromNormal(divPts[i],tan)
sect=rs.AddRectangle(plane,width,height)
cpt=rs.CurveAreaCentroid(sect)[0]
vec=rs.VectorCreate(divPts[i],cpt)
sect=rs.MoveObject(sect,vec)
if i>0:
if testAlign(sect,oldSect)==False:
sect=align(sect,oldSect,divPts[i],tan)
oldSect=sect
sections.append(sect)
branch=rs.AddLoftSrf(sections,None,None,2,0,0,False)
edges=rs.DuplicateEdgeCurves(branch)
if width>height:
testVal=height
else:
testVal=width
for i in range(len(edges)):
testPt=rs.CurveMidPoint(edges[i])
for j in range(len(edges)):
param=rs.CurveClosestPoint(edges[j],testPt)
pt=rs.EvaluateCurve(edges[j],param)
if rs.Distance(pt,testPt)<testVal/6:
keep=False
rs.DeleteObjects(sections)
rs.DeleteObjects(edges)
return branch
def makeFace(srfs):
srfsJoined = rs.JoinSurfaces(srfs, True)
boundaryCrv = rs.DuplicateSurfaceBorder(srfsJoined)
srf = rs.AddPlanarSrf(boundaryCrv)
rs.DeleteObjects(boundaryCrv)
rs.DeleteObject(srfsJoined)
rs.DeleteObjects(srfs)
return srf
def sweepSec(crv, plane, vec):
# rs.AddPlaneSurface( plane, 1, 1 )
rect = profile2(plane, vec)
sweep = rs.AddSweep1(crv, rect, closed=True)
sweep = rs.CapPlanarHoles(sweep)
if rect: rs.DeleteObjects(rect)
if crv: rs.DeleteObjects(crv)
return sweep
def makeBrep(srf):
point1 = rs.EvaluateSurface(srf, 0, 0)
vec = rs.CreateVector(0, 0, height)
point2 = rs.CopyObject(point1, vec)
line = rs.AddLine(point1, point2)
brep = rs.ExtrudeSurface(srf, line)
if point2: rs.DeleteObjects(point2)
if line: rs.DeleteObjects(line)
return brep
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 setPlanarBaseSurface(self):
'''
set surface that is planar surface
this surface will be made from additiveObj
this surface will be used in offsetNonPlanarSurface()
'''
explodedSurfaces = rs.ExplodePolysurfaces(self.additiveObj)
editPoint = []
if len(explodedSurfaces) is 0:
meshed = rhino.Geometry.Mesh.CreateFromBrep(
rs.coercebrep(self.additiveObj))
editPoint = rs.MeshVertices(meshed[0])
else:
for i in explodedSurfaces:
meshed = rhino.Geometry.Mesh.CreateFromBrep(rs.coercebrep(i))
vertices = rs.MeshVertices(meshed[0])
editPoint.extend(vertices)
rs.DeleteObjects(explodedSurfaces)
xValues = [i[0] for i in editPoint]
yValues = [i[1] for i in editPoint]
xValues.sort()
yValues.sort()
xMin = xValues[0]
xMax = xValues[-1]
yMin = yValues[0]
yMax = yValues[-1]
lineForSur = []
lineForSur.append(rs.AddLine((xMin, yMin, 0), (xMax, yMin, 0)))
lineForSur.append(rs.AddLine((xMax, yMin, 0), (xMax, yMax, 0)))
lineForSur.append(rs.AddLine((xMax, yMax, 0), (xMin, yMax, 0)))
lineForSur.append(rs.AddLine((xMin, yMax, 0), (xMin, yMin, 0)))
joinedCurve = rs.JoinCurves(lineForSur)
rs.DeleteObjects(lineForSur)
curveForSur = rs.OffsetCurve(joinedCurve, (0, 0, 1), 20)
if len(curveForSur) > 1:
curveForSur = rs.OffsetCurve(joinedCurve, (0, 0, 1), -20)
self.basePlanarSurface = rs.AddPlanarSrf(curveForSur)
rs.DeleteObjects(curveForSur)
if self.basePlanarSurface is None:
return False
return True
def mapping(discretization_spacing, surface_guid, curve_features_guids = [], point_features_guids = []):
"""Creates planar polylines from the boundaries of a NURBS surface, NURBS curves and point on the NURBS surface
by using the UV parameterisation with a user-input discretisation spacing.
Parameters
----------
discretization_spacing: real
Spacing value for discretisation of NURBS surface borders and curves into polylines.
surface: Rhino surface guid
Untrimmed or trimmed Rhino NURBS surface.
curve_features: Rhino curve guid
Rhino NURBS curve on the surface.
point_features: Rhino point guid
Rhino point on the surface.
Returns
-------
output: list
Planar parameterised geometrical output: boundary, holes, polyline features and point features.
Raises
------
-
"""
boundaries = surface_borders(surface_guid, border_type = 1)
boundary_polylines = [curve_discretisation(boundary, discretization_spacing) for boundary in boundaries]
uv_boundary_polylines = [[rs.SurfaceClosestPoint(surface_guid, vertex) for vertex in rs.PolylineVertices(boundary_polyline)] for boundary_polyline in boundary_polylines]
planar_boundary_polylines = [[[u, v, 0] for u, v in uv_boundary_polyline] for uv_boundary_polyline in uv_boundary_polylines]
planar_boundary_polyline = []
for polyline in planar_boundary_polylines:
planar_boundary_polyline += polyline[: -1]
planar_boundary_polyline.append(planar_boundary_polyline[0])
rs.DeleteObjects(boundaries)
rs.DeleteObjects(boundary_polylines)
holes = surface_borders(surface_guid, border_type = 2)
if len(holes) > 1:
holes = rs.JoinCurves(holes, delete_input = True)
hole_polylines = [curve_discretisation(hole, discretization_spacing) for hole in holes]
uv_hole_polylines = [[rs.SurfaceClosestPoint(surface_guid, vertex) for vertex in rs.PolylineVertices(hole_polyline)] for hole_polyline in hole_polylines]
planar_hole_polylines = [[[u, v, 0] for u, v in hole] for hole in uv_hole_polylines]
rs.DeleteObjects(holes)
rs.DeleteObjects(hole_polylines)
polyline_features = [curve_discretisation(curve_features_guid, discretization_spacing) for curve_features_guid in curve_features_guids]
uv_polyline_features = [[rs.SurfaceClosestPoint(surface_guid, vertex) for vertex in rs.PolylineVertices(polyline_feature)] for polyline_feature in polyline_features]
planar_polyline_features = [[[u, v, 0] for u, v in feature] for feature in uv_polyline_features]
rs.DeleteObjects(polyline_features)
uv_point_features = [rs.SurfaceClosestPoint(surface_guid, point) for point in point_features_guids]
planar_point_features = [[u, v, 0] for u, v in uv_point_features]
return planar_boundary_polyline, planar_hole_polylines, planar_polyline_features, planar_point_features
def makeWall(obj):
rs.EnableRedraw(False)
shape = wallProfile(obj)
railCurve = addRail(shape)
wall = rs.ExtrudeSurface(shape, railCurve)
rs.DeleteObjects(shape)
rs.DeleteObjects(railCurve)
rs.EnableRedraw(False)
return wall
def get_cut_curve(self):
if self.compensation == 0: return rs.CopyObject(self.nurbs_curve)
offset_distance = self.general_input["cut_diam"] * 0.5
scl_obj = rs.ScaleObject(self.nurbs_curve, self.point, (1.2, 1.2, 1),
True)
offset_points = rs.BoundingBox(scl_obj)
rs.DeleteObject(scl_obj)
offset_point_a = offset_points[0]
offset_point_b = self.point
if not rs.PointInPlanarClosedCurve(self.point, self.nurbs_curve):
offset_point_b = self.find_point_in_curve(self.nurbs_curve)
offset_a = rs.OffsetCurve(self.nurbs_curve, offset_point_a,
offset_distance, None, 2)
offset_b = rs.OffsetCurve(self.nurbs_curve, offset_point_b,
offset_distance, None, 2)
#Revisa si el offset no genero curvas separadas y si es el caso asigna la curva original como offset comparativo
if not offset_a or len(offset_a) != 1:
self.log.append(
"offset error: el cortador no cabe en una de las curvas, se reemplazo con la curva original."
)
if offset_a: rs.DeleteObjects(offset_a)
offset_a = rs.CopyObject(self.nurbs_curve)
if not offset_b or len(offset_b) != 1:
self.log.append(
"offset error: el cortador no cabe en una de las curvas, se reemplazo con la curva original."
)
if offset_b: rs.DeleteObjects(offset_b)
offset_b = rs.CopyObject(self.nurbs_curve)
#Revisa el area para saber cual es el offset interno o externo
if rs.CurveArea(offset_a) < rs.CurveArea(offset_b):
in_offset = offset_a
out_offset = offset_b
else:
in_offset = offset_b
out_offset = offset_a
#Responde dependiendo que compensacion se necesita
if self.compensation == 1:
rs.DeleteObject(in_offset)
return out_offset
elif self.compensation == -1:
rs.DeleteObject(out_offset)
return in_offset
else:
rs.DeleteObject(in_offset)
rs.DeleteObject(out_offset)
return None
def throwNode(nodes,speed,stickRange,passParams,resizeThreshold):
boundRadius = passParams[0]
bGeom = passParams[1]
#sFactor = passParams[2]
#print passParams[2]
#assumes time steps of 1
startPos = getBoundaryPos(boundRadius);
endPos = getBoundaryPos(boundRadius);
direction = rs.VectorSubtract(endPos,startPos)
direction = rs.VectorUnitize(direction)
vel = rs.VectorScale(direction,speed);
currentPos = rs.VectorAdd(startPos,vel)
previewGeom = []
isTravelling = True
while(isTravelling):
scriptcontext.escape_test() #hit escape to quit NOT WORKING
time.sleep(0.01*10**-7)
for o in previewGeom: rs.DeleteObjects(o)
dist = rs.VectorLength(currentPos) #distance to origin
#check if particle went out of bounds
if(dist>boundRadius):
isTravelling = False
else:
previewGeom.append(drawPos(currentPos,stickRange))
for i in range(len(nodes)):
n = nodes[i]
if(inStickRange(currentPos,n,stickRange)):
#GOT STUCK! add a new node at that position
newNode = node(currentPos,i,.08) #parent is idx of node stuck too
newNode.increaseRadius(.01, nodes)
nodes.append(newNode)
#rNodes.append(rs.AddPoint(currentPos))
if(math.fabs(boundRadius-dist) <= resizeThreshold):
#print "boundRadius should resize"
rs.DeleteObjects(bGeom)
boundRadius += resizeThreshold/2 #arbitrary
bGeom = rs.AddCircle([0,0,0],boundRadius)
passParams[0] = boundRadius
passParams[1] = bGeom
isTravelling = False
for o in previewGeom: rs.DeleteObjects(o)
break
currentPos = rs.VectorAdd(currentPos,vel)
Rhino.RhinoApp.Wait()
return passParams
def checkPos(objs):
# if ok, start export
copies = rs.CopyObjects( objs)
copies = ce.explodeBlock( copies )
# filter objects to only curves and points
copies = filterObjects(copies)
if not ce.checkCurvePosition(copies):
rs.DeleteObjects(copies)
return False
rs.DeleteObjects(copies)
def OnFormClosed(self, sender, e):
generatedStair = rs.ObjectsByName(
"GdC9V&^a^rGZZNgiWFH&aTRQLLscu*9AZCmhk8t2!a")
generatedHandrail = rs.ObjectsByName(
"qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc")
rs.DeleteObjects(rs.ObjectsByName(
"xAbJgNV6^bz6azN&6E$Q^WeX$Dd^vygCz5z7Hmynb5"))
rs.DeleteObjects(rs.ObjectsByName("BC6#DT5LCQX*#8r97Tquf5gNF"))
if generatedStair:
rs.DeleteObject(generatedStair)
if generatedHandrail:
rs.DeleteObjects(generatedHandrail)
self.Close(False)
def getVertSrf(srfs):
vertSrfs = []
for f in srfs:
edges = rs.ExplodeCurves(rs.DuplicateSurfaceBorder(f), True)
for e in edges:
p1 = rs.CurveStartPoint(e)
p2 = rs.CurveEndPoint(e)
if p1[0] == p2[0] and p1[1] == p2[1]:
vertSrfs.append(f)
rs.DeleteObjects(edges)
break
rs.DeleteObjects(edges)
return vertSrfs
def RemoveFromBlock():
block = rs.GetObject("Select Block to extract objects from",
rs.filter.instance,
preselect=True)
if not block: return
blockName = rs.BlockInstanceName(block)
objref = rs.coercerhinoobject(block)
idef = objref.InstanceDefinition
idefIndex = idef.Index
XformBlock = rs.BlockInstanceXform(block)
blockObjects = rs.BlockObjects(blockName)
blockInstanceObjects = rs.TransformObjects(blockObjects, XformBlock, True)
objs = rs.GetObjects("Select Objects to extract from Block",
objects=blockInstanceObjects)
if not objs:
rs.DeleteObjects(blockInstanceObjects)
return
keep = [] #List to keep in block
delete = [] #list to delete from block and add to doc
rs.EnableRedraw(False)
for object in blockInstanceObjects:
if object in objs: delete.append(object)
else: keep.append(object)
if rs.IsBlockReference(blockName):
print "Block is referenced from file; unable to modify block"
rs.DeleteObjects(keep)
return
rs.TransformObjects(keep, rs.XformInverse(XformBlock), False)
newGeometry = []
newAttributes = []
for object in keep:
newGeometry.append(rs.coercegeometry(object))
ref = Rhino.DocObjects.ObjRef(object)
attr = ref.Object().Attributes
newAttributes.append(attr)
InstanceDefinitionTable = sc.doc.ActiveDoc.InstanceDefinitions
InstanceDefinitionTable.ModifyGeometry(idefIndex, newGeometry,
newAttributes)
rs.DeleteObjects(keep)
rs.EnableRedraw(True)
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 editing_symmetry(coarse_pseudo_quad_mesh):
"""Edit the symmetry of a pattern via Conway operators.
Parameters
----------
coarse_pseudo_quad_mesh : CoarsePseudoQuadMesh
The pattern to edit.
"""
conway_operators = {
'conway_seed', 'conway_dual', 'conway_join', 'conway_ambo',
'conway_kis', 'conway_needle', 'conway_zip', 'conway_truncate',
'conway_ortho', 'conway_expand', 'conway_gyro', 'conway_snub',
'conway_meta', 'conway_bevel'
}
conway = {operator[7:]: operator for operator in conway_operators}
while True:
rs.EnableRedraw(False)
artist = rhino_artist.MeshArtist(
coarse_pseudo_quad_mesh.get_polygonal_mesh())
guid = artist.draw_mesh()
rs.EnableRedraw(True)
operator = rs.GetString('Conway operator?',
strings=conway.keys() + ['exit'])
if operator is None or operator == 'exit':
if type(guid) == list:
rs.DeleteObjects(guid)
else:
rs.DeleteObject(guid)
return coarse_pseudo_quad_mesh.get_polygonal_mesh()
elif operator == 'seed':
coarse_pseudo_quad_mesh.set_polygonal_mesh(
coarse_pseudo_quad_mesh.get_quad_mesh().copy())
elif operator in conway and conway[operator] in globals() and str(
conway[operator])[:6] == 'conway':
coarse_pseudo_quad_mesh.set_polygonal_mesh(
globals()[conway[operator]](
coarse_pseudo_quad_mesh.get_polygonal_mesh()))
if type(guid) == list:
rs.DeleteObjects(guid)
else:
rs.DeleteObject(guid)
def main():
objs = rs.VisibleObjects()
cutLevel = 12
rs.EnableRedraw(False)
objsCopy = rs.CopyObjects(objs)
splitModel(objsCopy, cutLevel)
makePlan()
rs.DeleteObjects(rs.ObjectsByGroup("Above"))
rs.DeleteObjects(rs.ObjectsByGroup("Below"))
cutAtPlan(cutLevel, False)
rs.Command('_SelDupAll _delete')
cutAtPlan(cutLevel, True)
rs.Command('_SelDup _delete')
rs.EnableRedraw(True)
def rebuildBrep(obj):
srfs = rs.ExplodePolysurfaces(obj)
crvs = map(rebuildSrfCrv, srfs)
rs.DeleteObjects(srfs)
newSrfs = map(rs.AddPlanarSrf, crvs)
# newSrfs = rs.AddPlanarSrf(crvs)
rs.DeleteObjects(crvs)
newbrep = rs.JoinSurfaces(newSrfs, delete_input=True)
try:
copySourceLayer(newbrep, obj)
copySourceData(newbrep, obj)
except:
pass
rs.DeleteObject(obj)
