def RemoveSurfacesIfAnyIntersectBoundary(self, surf, boundaries):
"""
checks if a surface intersects the boundary and deletes the surface
An auxilliary method to trim extruding fractures.
Parameters
----------
surf: GUID
guid of a Rhino surface
boundaries: list
list of boundary guids
"""
# Checks if a surface intersects a boundary
# If so, it deletes it and any created intersections
# Could run this with any set of boundary surfaces
# Intended to run with the CreateSetOfExtendedBoundaries function
for boundary in boundaries:
intersections = (rs.IntersectBreps(boundary, surf))
if intersections is not None: # If there are intersections
# Delete this surface
rs.DeleteObject(surf)
# delete the surface from domain fractures list
self.my_fractures.remove(surf)
# Delete all created intersections
for inter in intersections:
rs.DeleteObject(inter)
return True # WHY RETURN TRUE AND FALSE?
return False
def LinearDimJoin(object_id0, object_id1):
annotation_object0 = sc.doc.Objects.Find( object_id0 )
dim0 = annotation_object0.Geometry
annotation_object1 = sc.doc.Objects.Find( object_id1 )
dim1 = annotation_object1.Geometry
if isinstance(dim0, Rhino.Geometry.LinearDimension) and isinstance(dim1, Rhino.Geometry.LinearDimension):
_, extensionLine01End, extensionLine02End, arrowhead01End, arrowhead02End, dimlinepoint0, _ = dim0.Get3dPoints()
_, extensionLine11End, extensionLine12End, arrowhead11End, arrowhead12End, dimlinepoint1, _ = dim1.Get3dPoints()
line0 = geo.Line(arrowhead01End, arrowhead02End)
direct0=rs.VectorUnitize(line0.Direction)
line1 = geo.Line(arrowhead11End, arrowhead12End)
direct1=rs.VectorUnitize(line1.Direction)
if rs.IsVectorParallelTo(direct0, direct1 ) != 0 :
param0 = line0.ClosestParameter(line1.From)
param1 = line0.ClosestParameter(line1.To)
paramDictionary = {
0.0 : extensionLine01End,
1.0 : extensionLine02End,
param0 : extensionLine11End,
param1 : extensionLine12End
}
extensionLineList = []
for key in sorted(paramDictionary.keys()):
extensionLineList.append(paramDictionary[key])
distance0 = line0.DistanceTo(extensionLineList[0],False)
distance1 = line1.DistanceTo(extensionLineList[0],False)
if distance0 > distance1:
rs.AddLinearDimension(dim0.Plane, extensionLineList[0], extensionLineList[len(extensionLineList)-1], dimlinepoint0 )
else:
rs.AddLinearDimension(dim1.Plane, extensionLineList[0], extensionLineList[len(extensionLineList)-1], dimlinepoint1 )
rs.DeleteObject(object_id0)
rs.DeleteObject(object_id1)
def mergeCoincidentLines(segments):
"""
removes coincident, consecutive segments
input: List of GUIDs
returns: List of GUIDs
"""
newSegments = []
i = 0
while i < len(segments):
if (i < len(segments) - 1): #if coincident, delete both, add new.
a = rs.VectorCreate(rs.CurveStartPoint(segments[i]),
rs.CurveEndPoint(segments[i]))
b = rs.VectorCreate(rs.CurveStartPoint(segments[i + 1]),
rs.CurveEndPoint(segments[i + 1]))
a = rs.VectorUnitize(a)
b = rs.VectorUnitize(b)
aAng = rs.VectorAngle(a, b)
if (aAng < .00001):
newLine = rs.AddLine(rs.CurveStartPoint(segments[i]),
rs.CurveEndPoint(segments[i + 1]))
rs.DeleteObject(segments[i])
rs.DeleteObject(segments[i + 1])
newSegments.append(newLine)
i = i + 2
else:
newSegments.append(
segments[i]) #if not coincident, add to array
i = i + 1
else:
newSegments.append(segments[i]) #add last seg to array
i = i + 1
return newSegments
def innerPanel():
objs = rs.GetObjects("Select objects to add frame to", filter = 24, group = True,preselect = True)
if objs is None:
return
dist = rs.GetReal("Offset Distance")
if dist is None:
return
rs.EnableRedraw(False)
srfs = []
for obj in objs:
if rs.IsPolysurface(obj):
srfs = srfs + rs.ExplodePolysurfaces(obj)
else:
srfs.append(rs.CopyObject(obj))
for srf in srfs:
if rs.IsSurfacePlanar(srf):
edgeCrvs = rs.DuplicateEdgeCurves(srf)
border = rs.JoinCurves(edgeCrvs, True)
innerEdge = rs.OffsetCurveOnSurface(border, srf, dist)
#rs.SplitBrep(srf, innerEdge)
rs.AddPlanarSrf(innerEdge)
rs.DeleteObject(innerEdge)
rs.DeleteObject(border)
else:
print "A surface was not planar"
rs.DeleteObjects(srfs)
rs.EnableRedraw(True)
def offsetext():
def RepresentsInt(s):
try:
int(s)
return True
except ValueError:
return False
viste = rs.ViewNames()
for viewport in viste:
rs.ViewDisplayMode(viewport,"Shaded")
diametro = rs.StringBox("dimensione della punta","10","scontornatura")
if RepresentsInt(diametro):
diametro = int(diametro)
else:
diametro = 10
brep = rs.GetObjects("dammi un solido",16)
brepexp = rs.ExplodePolysurfaces(brep)
get_val = rs.GetEdgeCurves("dammi le curve")
surf_edge = []
for i in get_val:
surf_edge.append(i[0])
surf_edge = rs.coerceguidlist(surf_edge)
if len(surf_edge)>1:
surf_edge = rs.JoinCurves(surf_edge,True)
surface = rs.GetObjects("conferma la selezione",8,False,True,1,1)
print surf_edge
uv= []
temp_edge = rs.ExplodeCurves(surf_edge,False)
new_surface = rs.CopyObject(surface,(0,0,0))
list_evpt =[]
for i in temp_edge:
evpt =rs.CurveMidPoint(i)
print evpt
list_evpt.append(evpt)
for i in list_evpt:
bord= rs.SurfaceClosestPoint(new_surface,i)
uv.append(bord)
for i in uv:
rs.ExtendSurface(new_surface,i,diametro*10)
edge = rs.OffsetCurveOnSurface(surf_edge,new_surface,-diametro)
print edge
if rs.CurveLength(edge)<rs.CurveLength(surf_edge):
rs.DeleteObject(edge)
edge = rs.OffsetCurveOnSurface(surf_edge,new_surface,diametro)
surf_edge = rs.ExplodeCurves(surf_edge,True)
print edge
rs.ObjectColor(edge,(0,0,255))
for i in brepexp:
rs.DeleteObject(i)
for i in temp_edge:
rs.DeleteObject(i)
for i in surf_edge:
rs.DeleteObject(i)
rs.DeleteObjects([new_surface,surface])
def GenStaggeredCourtyardBlock(site_crv, setback, stepbacks, bay_gap, fsr_li,
flr_depth):
bldg_srf_li = []
outer_setback_crv = rs.OffsetCurve(site_crv,
rs.CurveAreaCentroid(site_crv)[0],
setback)
inner_floor_crv = rs.OffsetCurve(site_crv,
rs.CurveAreaCentroid(site_crv)[0],
setback + flr_depth)
req_ht = (rs.CurveArea(site_crv)[0] * fsr_li[0]) / (
rs.CurveArea(outer_setback_crv)[0] - rs.CurveArea(inner_floor_crv)[0])
l = rs.AddLine([0, 0, 0], [0, 0, req_ht])
srf = rs.AddPlanarSrf([outer_setback_crv, inner_floor_crv])
srf2 = rs.ExtrudeSurface(srf, l)
rs.DeleteObject(l)
prev_ht = req_ht
k = 1
for depth in stepbacks:
req_ar = rs.CurveArea(site_crv)[0] * fsr_li[k]
itr_stepback_crv = rs.OffsetCurve(site_crv,
rs.CurveAreaCentroid(site_crv)[0],
setback + depth)
got_ar = rs.CurveArea(itr_stepback_crv)[0] - rs.CurveArea(
inner_floor_crv)[0]
ht = req_ar / got_ar
l = rs.AddLine([0, 0, 0], [0, 0, ht])
srf = rs.AddPlanarSrf([itr_stepback_crv, inner_floor_crv])
srf2 = rs.ExtrudeSurface(srf, l)
rs.MoveObject(srf2, [0, 0, prev_ht])
rs.DeleteObject(l)
rs.DeleteObject(srf)
bldg_srf_li.append(srf2) #
prev_ht += ht
k += 1
def getIntxCrv(self, poly):
intxCrv=rs.CurveBooleanIntersection(self.SITECRV,poly)
if(len(intxCrv)>0):
maxCrv=intxCrv[0]
maxAr=0.0
for i in intxCrv:
ar=rs.CurveArea(i)[0]
if(ar>maxAr):
maxAr=ar
maxCrv=i
crvpts=rs.CurvePoints(maxCrv)
rs.DeleteObjects(intxCrv)
for i in intxCrv:
try:
rs.DeleteObject(i)
pass
except:
print("#1. curve not deleted")
return crvpts
else:
for i in intxCrv:
try:
rs.DeleteObject(i)
except:
print("#2. curve not deleted")
return
def filterObjects(objs):
new_list = []
for obj in objs:
if rs.LayerVisible( rs.ObjectLayer(obj) ):
# only export visible layers
if rs.IsCurve(obj):
new_list.append(obj)
elif rs.IsPoint(obj):
# convert to circle
layer = rs.ObjectLayer(obj)
point=rs.coerce3dpoint(obj)
circle = rs.AddCircle(rs.WorldXYPlane(),3)
rs.ObjectLayer(circle, layer)
rs.MoveObject(circle, [point.X, point.Y, point.Z])
new_list.append(circle)
rs.DeleteObject(obj)
# rs.DeleteObject(point)
else:
# remove from obj list
rs.DeleteObject(obj)
else:
# remove from obj list
rs.DeleteObject(obj)
return new_list
def exportData():
# Generating sensor points
pts = setSensorLocation()
# Make csv file
file_object = open("points1.csv", "w")
# import sensor value
file_data = open("values.csv", "r")
data = file_data.readlines()
valList = []
for index in range(0, len(data)):
valNum = float(data[index])
valList.append(valNum)
maxNum = max(valList)
minNum = min(valList)
# index initialization
i = 0
# Writing csv file: iteration
for pt in pts:
coord = rs.PointCoordinates(pt)
dataLine = str(coord)
dataLine = dataLine + " ," + data[i]
val = float(data[i])
visLine = makeHeight(pt, val)
pipe = makePipe(visLine)
# Making layers and their colors depending on value
color = mapVal2Color(minNum, maxNum, i, val)
rs.EnableRedraw(False)
# Visualization: assigning layer to point
#rs.ObjectLayer(pt, layername)
#rs.ObjectLayer(visLine, layername)
#rs.ObjectLayer(pipe, layername)
# GUID to Brep
pipeBrep = rs.coercebrep(pipe)
AddMaterial(pipeBrep, i, color)
rs.DeleteObject(pt)
rs.DeleteObject(visLine)
rs.DeleteObject(pipe)
i = i + 1
file_object.writelines(dataLine)
file_object.close()
file_data.close()
print("data export done")
def draw(pts):
rs.EnableRedraw(0)
sleep(0.05)
RhinoApp.Wait()
for i in range(4):
for j in range(4):
if recs[i][j]:
rs.DeleteObject(recs[i][j])
if tags[i][j]:
rs.DeleteObject(tags[i][j])
if pts[i][j]:
recs[i][j] = rs.AddRectangle(
rs.PlaneFromNormal((i + 0.1, j + 0.1, 0), (0, 0, 1)), 0.8,
0.8)
tags[i][j] = rs.AddText(pts[i][j], (i + 0.5, j + 0.5, 0),
0.2 + (0.1 / len(str(pts[i][j]))),
'Arial', 0, 131074)
if pts[i][j] <= 4:
rs.ObjectColor(tags[i][j], (245, 245, 220))
rs.ObjectColor(recs[i][j], (245, 245, 220))
if 8 <= pts[i][j] <= 16:
rs.ObjectColor(tags[i][j], (245, 97, 0))
rs.ObjectColor(recs[i][j], (245, 97, 0))
if 32 <= pts[i][j] <= 64:
rs.ObjectColor(tags[i][j], (245, 7, 0))
rs.ObjectColor(recs[i][j], (245, 9, 0))
if pts[i][j] > 64:
rs.ObjectColor(tags[i][j], (245, 197, 44))
rs.ObjectColor(recs[i][j], (245, 197, 44))
rs.EnableRedraw(1)
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<DIV):
pts0=self.getIntxCrv(poly0)
pts1=self.getIntxCrv(poly1)
rs.DeleteObject(poly0)
rs.DeleteObject(poly1)
self.recSplit(pts0,counter)
self.recSplit(pts1,counter)
else:
intxCrv0=rs.CurveBooleanIntersection(self.SITECRV,poly0)
intxCrv1=rs.CurveBooleanIntersection(self.SITECRV,poly1)
rs.DeleteObject(poly0)
rs.DeleteObject(poly1)
for i in intxCrv0:
self.FPOLY.append(i)
for i in intxCrv1:
self.FPOLY.append(i)
rs.DeleteObject(self.crv)
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 meshSwipPolyAlongPoly(profile, rail):
profile = rs.CopyObject(profile)
pts = rs.CurveEditPoints(rail)
baseVect = Rhino.Geometry.Point3d(0, 1, 0)
meshes = []
for i in range(0, len(pts) - 2):
p0 = pts[i]
p1 = pts[i + 1]
p2 = pts[i + 2]
v1 = rs.VectorUnitize(p1 - p0)
v2 = rs.VectorUnitize(p2 - p1)
rv1 = rs.VectorUnitize(p0 - p1)
vect = p1 - p0
mid = rs.VectorUnitize((rv1 + v2) / 2)
np = p1 + mid
up = p1 + Rhino.Geometry.Point3d(0, 0, 1)
pln = rs.PlaneFromPoints(p1, np, up)
mesh, pjpts = meshExtrudePolyToByVectPlane(profile, vect, pln)
meshes.append(mesh)
rs.DeleteObject(profile)
profile = rs.AddPolyline(pjpts)
mesh = rs.JoinMeshes(meshes, True)
rs.DeleteObject(profile)
return mesh
def GenStagerredBlock(site_crv, setback, stepbacks, bay_gap, fsr_li,
flr_depths):
bldg_srf_li = []
setback_crv = rs.OffsetCurve(site_crv,
rs.CurveAreaCentroid(site_crv)[0], setback)
ht = fsr_li[0] * rs.CurveArea(site_crv)[0] / rs.CurveArea(setback_crv)[0]
pl_srf0 = rs.AddPlanarSrf(setback_crv)
l = rs.AddLine([0, 0, 0], [0, 0, ht])
ext_srf = rs.ExtrudeSurface(pl_srf0, l)
rs.DeleteObjects([l, pl_srf0])
k = 1
for depth in stepbacks:
stepback_crv = rs.OffsetCurve(setback_crv,
rs.CurveAreaCentroid(site_crv)[0], depth)
ht2 = rs.CurveArea(site_crv)[0] * fsr_li[k] / rs.CurveArea(
stepback_crv)[0]
l = rs.AddLine([0, 0, 0], [0, 0, ht2])
pl_srf = rs.AddPlanarSrf(stepback_crv)
ext_srf = rs.ExtrudeSurface(pl_srf, l)
rs.MoveObject(ext_srf, [0, 0, ht])
bldg_srf_li.append(ext_srf)
rs.DeleteObject(l)
rs.DeleteObject(pl_srf)
ht += ht2
k += 1
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 collisionDetection(used_timber_list, not_used_timber_list, unused_timber,
id_connect):
num_used_timber = len(used_timber_list)
num_not_used_timber = len(not_used_timber_list)
sum_timber = num_used_timber + num_not_used_timber
timber1 = unused_timber # これから生成するTimber
count = 0 # timber1と他のused_timberが衝突していない時のカウント
# 衝突判定(unused_timberとused_listのtimber同士の接触判定)
for i in range(num_used_timber):
# 接合部は衝突とみなさない
if i == id_connect:
count = count + 1
# 接合部材以外のused_timberとの衝突判定
else:
timber2 = used_timber_list[i]
curve = rs.IntersectBreps(timber1.surface, timber2.surface)
# 衝突していない場合
if curve is None:
count = count + 1
# 衝突している場合
else:
# 衝突部に目印の球体を生成 --> ただの目印なので接触処理するときはコメントアウトしてもらえればと
# mark_sphere = createMarkSphere(curve)
# rs.ObjectLayer(mark_sphere, "collision")
# objectを削除
rs.DeleteObject(curve[0])
break
# 衝突判定(unused_timberとnot_used_listのtimber同士の接触判定)
for j in range(num_not_used_timber):
timber2 = not_used_timber_list[j]
curve = rs.IntersectBreps(timber1.surface, timber2.surface)
# 衝突していない場合
if curve is None:
count = count + 1
# 衝突している場合
else:
# 衝突部に目印の球体を生成 --> ただの目印なので接触処理するときはコメントアウトしてもらえればと
# mark_sphere = createMarkSphere(curve)
# rs.ObjectLayer(mark_sphere, "collision")
# objectを削除
rs.DeleteObject(curve[0])
# unused_timberがどの部材とも衝突してない場合
if count == sum_timber:
return False
# unused_timberがいずれかの部材と衝突している場合
else:
return True
def Fillet(self, radius):
curve0 = self.curves.pop()
curve1 = self.curves.pop()
curve = rs.AddFilletCurve(curve0, curve1, radius, self.currentPoint,
self.currentPoint)
rs.DeleteObject(curve0)
rs.DeleteObject(curve1)
self.curves.append(curve)
def editing_topology(coarse_pseudo_quad_mesh):
"""Edit the topology of a pattern, i.e. its singularities, via its strips.
Parameters
----------
coarse_pseudo_quad_mesh : CoarsePseudoQuadMesh
The pattern to edit.
"""
while True:
# update drawing
rs.EnableRedraw(False)
artist = rhino_artist.MeshArtist(coarse_pseudo_quad_mesh)
guid = artist.draw_mesh()
rs.EnableRedraw(True)
# choose operation
operation = rs.GetString('edit strip topology?',
strings=['add', 'delete', 'split', 'exit'])
# stop if asked
if operation is None or operation == 'exit':
rs.DeleteObject(guid)
break
# apply operation
if operation == 'add':
skey = add_strip(coarse_pseudo_quad_mesh,
select_mesh_polyedge(coarse_pseudo_quad_mesh))[0]
coarse_pseudo_quad_mesh.set_strip_density(skey, 1)
elif operation == 'delete':
skeys = set(select_quad_mesh_strips(coarse_pseudo_quad_mesh))
skey_to_skeys = delete_strips(coarse_pseudo_quad_mesh, skeys)
if skey_to_skeys is not None:
for skey_0, skeys in skey_to_skeys.items():
d = int(
ceil(
float(
coarse_pseudo_quad_mesh.get_strip_density(
skey_0)) / 2.))
coarse_pseudo_quad_mesh.set_strips_density(d, skeys)
elif operation == 'split':
skey = select_quad_mesh_strip(coarse_pseudo_quad_mesh)
n = rs.GetInteger('number of splits', number=2, minimum=2)
skeys = split_strip(coarse_pseudo_quad_mesh, skey, n=n)
# update data
d = int(
ceil(
float(coarse_pseudo_quad_mesh.get_strip_density(skey)) /
float(n)))
coarse_pseudo_quad_mesh.set_strips_density(d, skeys)
# delete drawing
rs.DeleteObject(guid)
def GetFracture ():
dx = rs.GetReal("Enter x-axis direction:")
if not dx:
dx = 0.0
print "x-axis direction: ", dx
objs = rs.ObjectsByType(8,False)
cir_objs = rs.ObjectsByType(4)
#delete all circles
for cur_obj in cir_objs:
if rs.IsCircle(cur_obj):
rs.DeleteObject(cur_obj)
occor = []
radius = []
center = []
#for all surface
for obj in objs:
rs.UnselectAllObjects()
rs.SelectObject(obj)
rs.Command ("_Silhouette")
created_objs = rs.LastCreatedObjects()
#not a circle
if len(created_objs) !=1:
rs.DeleteObjects(created_objs)
print "unvailded surface"
continue
created_objs = created_objs[0]
#not a circle
if not rs.IsCircle(created_objs):
rs.DeleteObject(created_objs)
print "unvailded surface, not circle"
continue
point = rs.CircleCenterPoint(created_objs)
center.append(point)
r = rs.CircleRadius(created_objs)
radius.append(r)
normal = rs.SurfaceNormal(obj,[0,0])
occor.append(GetDirDip(normal,dx))
rs.DeleteObject(created_objs)
print center
print occor
print radius
path = rs.DocumentPath()
path_l = path.split("\\")
path_l[len(path_l)-1] = "fracture.dat"
file = open("\\".join(path_l),"w")
file.write(str(len(occor)))
file.write('\n')
for i in range (len(occor)):
file.write("%.15f " % center[i][0])
file.write("%.15f " % center[i][1])
file.write("%.15f " % center[i][2])
file.write ("%.15f " % occor[i][0])
file.write ("%.15f " % occor[i][1])
file.write ("%.15f " % radius[i])
file.write ("0.0001 0.1 30\n")
file.close ()
def collisionDetection_bridge(used_timber_list, not_used_timber_list,
unused_timber, id_connect_1, id_connect_2):
num_used_timber = len(used_timber_list)
num_not_used_timber = len(not_used_timber_list)
sum_timber = num_used_timber + num_not_used_timber
count = 0
timber1 = unused_timber
for i in range(num_used_timber):
# 接合部は衝突とみなさない
if i == id_connect_1:
count = count + 1
elif i == id_connect_2:
count = count + 1
# 接合部材以外のused_timberとの衝突判定
else:
timber2 = used_timber_list[i]
curve = rs.IntersectBreps(timber1.surface, timber2.surface)
if curve is None:
count = count + 1
else:
# 衝突部に目印の球体を生成 --> ただの目印なので接触処理するときはコメントアウトしてもらえればと
# mark_sphere = createMarkSphere(curve)
# rs.ObjectLayer(mark_sphere, "collision")
# objectを削除
rs.DeleteObject(curve[0])
for i in range(num_not_used_timber):
# 接合部材以外のused_timberとの衝突判定
timber2 = not_used_timber_list[i]
curve = rs.IntersectBreps(timber1.surface, timber2.surface)
# 衝突していない場合
if curve is None:
count = count + 1
# 衝突している場合
else:
# 衝突部に目印の球体を生成 --> ただの目印なので接触処理するときはコメントアウトしてもらえればと
# mark_sphere = createMarkSphere(curve)
# rs.ObjectLayer(mark_sphere, "collision")
# objectを削除
rs.DeleteObject(curve[0])
# unused_timberがどの部材とも衝突してない場合
if count == sum_timber:
return False
# unused_timberがいずれかの部材と衝突している場合
else:
return True
def editing_geometry_moving(coarse_pseudo_quad_mesh):
"""Edit the geometry of a pattern with moving.
Parameters
----------
coarse_pseudo_quad_mesh : CoarsePseudoQuadMesh
The pattern to edit.
"""
mesh_to_modify = rs.GetString('mesh to modify?',
strings=[
'coarse_pseudo_quad_mesh',
'pseudo_quad_mesh', 'polygonal_mesh'
])
if mesh_to_modify == 'coarse_pseudo_quad_mesh':
mesh = coarse_pseudo_quad_mesh
elif mesh_to_modify == 'pseudo_quad_mesh':
mesh = coarse_pseudo_quad_mesh.get_quad_mesh()
elif mesh_to_modify == 'polygonal_mesh':
mesh = coarse_pseudo_quad_mesh.get_polygonal_mesh()
else:
return 0
while True:
rs.EnableRedraw(False)
artist = rhino_artist.MeshArtist(mesh)
guid = artist.draw_mesh()
rs.EnableRedraw(True)
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.vertices()})
artist.redraw()
vkeys = rhino_helper.mesh_select_vertices(mesh,
message='vertices to move')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
if vkeys == []:
rs.DeleteObject(guid)
break
rhino_helper.mesh_move_vertices(mesh, vkeys)
rs.DeleteObject(guid)
if mesh_to_modify == 'coarse_pseudo_quad_mesh':
coarse_pseudo_quad_mesh = mesh
elif mesh_to_modify == 'pseudo_quad_mesh':
coarse_pseudo_quad_mesh.set_quad_mesh(mesh)
coarse_pseudo_quad_mesh.set_polygonal_mesh(mesh.copy())
elif mesh_to_modify == 'polygonal_mesh':
coarse_pseudo_quad_mesh.set_polygonal_mesh(mesh)
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 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 drawOpening(distance, length, block=0):
if block == 1 and rs.IsBlock("window") == False:
util.initWindowBlock()
if block == 2 and rs.IsBlock("door") == False:
util.initDoorBlock()
if not rs.IsLayer("Axis"):
util.initCaadLayer("Axis")
twoLines = findTwoParallelLines()
if not twoLines:
return 0
pi, linei, linej = twoLines
if not linej:
return 0
pj = linej.CurveGeometry.Line.ClosestPoint(pi, False)
oldLockMode = rs.LayerLocked("Axis", True)
# side=0 start from startPoint , side=1 start from endPoint
if rs.Distance(linei.CurveGeometry.Line.From, pi) <= rs.Distance(
pi, linei.CurveGeometry.Line.To):
side = 0
else:
side = 1
# direct:
# 0 | 1
# -------
# 2 | 3
vji = rs.VectorCreate(pj, pi)
vi = linei.CurveGeometry.Line.Direction
angle = rs.Angle((0, 0, 0),
rs.VectorRotate(vji, -rs.Angle((0, 0, 0), vi)[0],
(0, 0, 1)))
if abs(angle[0] - 90) < sc.doc.ModelAbsoluteTolerance:
line0 = linei
line1 = linej
if side == 0:
direct = 2
else:
direct = 3
elif abs(angle[0] + 90) < sc.doc.ModelAbsoluteTolerance:
line0 = linej
line1 = linei
if side == 0:
direct = 0
else:
direct = 1
dl = DoubleLine(line0.CurveGeometry.Line, line1.CurveGeometry.Line)
newLayer = rs.ObjectLayer(line0.Id)
oldLayer = rs.CurrentLayer(newLayer)
dl.drawOpening(distance, length, side, block, direct)
rs.DeleteObject(line0.Id)
rs.DeleteObject(line1.Id)
rs.CurrentLayer(oldLayer)
rs.LayerLocked("Axis", oldLockMode)
def plotPoint(pOne, pTwo):
line = rs.AddLine(pOne, pTwo)
coordinates = rs.CurveMidPoint(line)
point = rs.AddPoint(coordinates)
rs.DeleteObject(line)
translation = rs.Distance(pOne, pTwo)
rs.MoveObject(point, (0, 0, translation))
result = rs.PointCoordinates(point)
rs.DeleteObject(point)
return result
def trimSurface(sur):
#sur = getSurfaces()['ref']
pl = rs.AddPlaneSurface(rs.WorldXYPlane(), 40000.0, 6000.0)
rs.MoveObject(pl, (-3000, -500, 2100))
lsrf = rs.SplitBrep(sur, pl)
rs.DeleteObject(pl)
rs.DeleteObject(lsrf[0])
rs.DeleteObject(sur)
rs.ObjectName(lsrf[1], 'mod')
return lsrf[1]
def GenExtrBlock(site_crv, setback, flr_depth, bay_gap, fsr):
setback_crv = rs.OffsetCurve(site_crv,
rs.CurveAreaCentroid(site_crv)[0], setback)
got_ar = rs.CurveArea(setback_crv)[0]
req_ar = rs.CurveArea(site_crv)[0] * fsr
ht = req_ar / got_ar
l = rs.AddLine([0, 0, 0], [0, 0, ht])
pl_srf = rs.AddPlanarSrf(setback_crv)
ext_srf = rs.ExtrudeSurface(pl_srf, l) #
rs.DeleteObject(l)
rs.DeleteObject(pl_srf)
def draw_sikaku(h):
p1 = (1000, 1000, h)
p2 = (1000, -1000, h)
p3 = (1000, 0, h)
p4 = (-1000, 0, h)
path = rs.AddLine(p1, p2)
side = rs.AddLine(p3, p4)
plate = rs.ExtrudeCurve(path, side)
rs.DeleteObject(path)
rs.DeleteObject(side)
return plate
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 draw_sikaku(i):
h = height = 100
r = radius = 100
theta = ma.radians(i)
p1 = (0, 0, 0)
p2 = (0, 0, h)
path = rs.AddLine(p1, p2)
side = rs.AddLine((0, 0, -3), (r * ma.cos(theta), r * ma.sin(theta), -3))
plate = rs.ExtrudeCurve(side, path)
rs.DeleteObject(path)
rs.DeleteObject(side)
return plate
