def pre_process():
# delete all previous user text
all_objs = rs.AllObjects()
for obj in all_objs:
rh_obj = rs.coercerhinoobject(obj)
rh_obj.Attributes.DeleteAllUserStrings()
# remove all blocks
for block in rs.BlockNames():
rs.DeleteBlock(block)
# set current layer
rs.CurrentLayer(relevant_layers_dict["buildings"])
# remove redundant layers
for layer_name in rs.LayerNames():
if layer_name not in relevant_layers_dict.values():
rs.PurgeLayer(layer_name)
# get all objects in building layer
building_objs = rs.ObjectsByLayer(relevant_layers_dict["buildings"])
for building_obj in building_objs:
if rs.IsCurve(building_obj) and rs.IsCurveClosed(building_obj):
# flatten curve to XY plane
matrix = rs.XformPlanarProjection(rg.Plane.WorldXY)
rs.TransformObject(building_obj, matrix, copy=False)
# delete all object with a surface grater or smaller from MIN_BUILDING_AREA_SQ by TOLERANCE or just smaller than MIN_BUILDING_AREA_SQ
TOLERANCE = 2
if rs.CurveArea(building_obj)[0] < MIN_BUILDING_AREA_SQM or abs(
rs.CurveArea(building_obj)[0] -
MIN_BUILDING_AREA_SQM) < TOLERANCE:
rs.DeleteObject(building_obj)
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 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 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 postProcess(self):
REDO=False
ar=0.0
for i in self.FPOLY:
rs.RotateObject(i, CP, -ANGLE)
for i in self.FPOLY:
try:
ar+=rs.CurveArea(i)[0]
except:
pass
mean_ar=ar/len(self.FPOLY)
min_ar_per=0.2*mean_ar
j=0
for i in self.FPOLY:
pts=rs.CurvePoints(i)
if(rs.CurveArea(i)[0]<min_ar_per):
REDO=True
break
p=rs.BoundingBox(pts)
max_poly=rs.AddPolyline([p[0],p[1],p[2],p[3],p[0]])
max_poly_ar=rs.CurveArea(max_poly)[0]
actual_poly_ar=rs.CurveArea(i)[0]
if((max_poly_ar/actual_poly_ar)>2):
REDO=True
rs.DeleteObject(max_poly)
break
else:
rs.DeleteObject(max_poly)
ab=int(rs.Distance(p[0],p[1]))
ad=int(rs.Distance(p[0],p[3]))
if((ab>ad) and (ab/ad)>5):
REDO=True
break
elif((ab<ad) and (ab/ad)<0.2):
REDO=True
break
j+=1
if(REDO==True and self.counter<MAX_REC):
self.counter+=1
print("Redo %s" %(self.counter))
rs.DeleteObjects(self.FPOLY)
self.start()
self.recSplit(bsp.BBpts, 0)
self.postProcess()
else:
j=0
for i in self.FPOLY:
c=rs.CurveAreaCentroid(i)[0]
rs.AddTextDot(str(j), c)
j+=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 __init__(self, x, fsr, c):
self.path = x
self.fsr = fsr
self.site = c
self.req_obj = []
self.site_ar = rs.CurveArea(self.site)[0]
self.bua = float(self.site_ar) * float(self.fsr)
def __init__(self,c,fsr,n,num,a_min,a_max,l_min,l_max,w_min,w_max,h_min,h_max,sep_min,sep_max,colr):
self.name=n
self.crv=c
self.site_area=rs.CurveArea(c)[0]
self.fsr=fsr
self.bua=self.site_area*self.fsr
self.num_floors=0
self.gen_poly=[]
self.req_poly=[]
self.floor_plates=[]
self.min_ht=h_min
self.max_ht=h_max
self.srf=[]
re=int(colr.split("-")[0])
gr=int(colr.split("-")[1])
bl=int(colr.split("-")[2])
self.colr=(re,gr,bl)
self.ar_0=float(a_min)
self.ar_1=float(a_max)
self.d0_0=float(l_min)
self.d0_1=float(l_max)
self.d1_0=float(w_min)
self.d1_1=float(w_max)
self.s_0=float(sep_min)
self.s_1=float(sep_max)
self.number=int(num)
self.ar=random.randint(int(self.ar_0),int(self.ar_1))
self.d0=random.randint(int(self.d0_0),int(self.d0_1))
self.d1=random.randint(int(self.d1_0),int(self.d1_1))
self.sep=random.randint(int(self.s_0),int(self.s_1))
self.b0=self.d0+self.sep
self.b1=self.d1+self.sep
def writeToCsvPcp(self, counter, str_li):
file = 'output' + str(time()) + ".csv"
fs = open(file, "a")
site_area = rs.CurveArea(self.site_crv)[0]
fs.write(
"Run Id,GFA,FSR,Ground Coverage,Num of Floors, Num Plotted, Area of Floor Plate, Image (PNG)\n"
)
for i in range(counter): #2-d str list
total_area = 0
gc = 0
num_flrs = 0
num_plot = 0
area_plate = 0
for j in str_li[i]: #1-d element of str list
#name, area, num_flrs, num_poly, ar_int_poly
#fs.write(str(j[0])+","+str(j[1])+","+str(j[2])+","+str(j[3])+","+str(j[4])+"\n")
total_area += j[2] * j[3] * j[4]
gc += j[2] * j[4]
num_flrs += (j[1])
num_plot += (j[3])
area_plate += (j[4])
run_id = i + 1
gfa = total_area
gc = gc * 100 / site_area
fsr = total_area / site_area
img = str(i + 1) + '.png'
fs.write(
str(run_id) + "," + str(gfa) + "," + str(fsr) + "," + str(gc) +
"," + str(num_flrs) + "," + str(num_plot) + "," +
str(area_plate) + "," + img + "\n")
fs.close()
def areaTag(pline):
#get area
area = rs.CurveArea(pline)[0]
area = str((int(area * 100)) / 100) + "m2"
print area
#move area tag below name tag location
offset = [0, -2.5, 0]
#add text tag
objID = pline
text = '%<area("' + str(objID) + '")>%m2'
pt = rs.AddPoint(rs.CurveAreaCentroid(pline)[0])
rs.MoveObject(pt, offset)
areaTag = rs.AddText(text, pt, 1, justification=131074)
rs.DeleteObject(pt)
parentLayer = rs.ParentLayer(rs.ObjectLayer(pline))
hostLayer = rs.AddLayer("ANNO_AREA", (128, 128, 128), parent=parentLayer)
rs.ObjectLayer(areaTag, hostLayer)
te = rs.coercerhinoobject(areaTag, True, True)
te.Geometry.TextFormula = text
te.CommitChanges()
sc.doc.Views.Redraw()
return None
def ColorBySize():
try:
objs = rs.GetObjects("Select objects to color",
1073815613,
preselect=True)
if objs is None: return
print "Select First Color"
firstColor = rs.GetColor()
if firstColor is None: return
print "Select Second Color"
secondColor = rs.GetColor(firstColor)
if secondColor is None: return
rs.EnableRedraw(False)
colorLine = rs.AddLine(firstColor, secondColor)
areas = []
for obj in objs:
if rs.IsCurve(obj):
if rs.IsCurveClosed(obj):
areas.append(rs.CurveArea(obj)[0])
else:
areas.append(rs.CurveLength(obj))
elif rs.IsSurface(obj):
areas.append(rs.SurfaceArea(obj)[0])
elif rs.IsPolysurface(obj):
if rs.IsPolysurfaceClosed(obj):
areas.append(rs.SurfaceVolume(obj)[0])
elif rs.IsHatch(obj):
areas.append(rs.Area(obj))
else:
print "Only curves, hatches, and surfaces supported"
return
newAreas = list(areas)
objAreas = zip(newAreas, objs)
objAreas.sort()
objSorted = [objs for newAreas, objs in objAreas]
areas.sort()
normalParams = utils.RemapList(areas, 0, 1)
colors = []
for t in normalParams:
param = rs.CurveParameter(colorLine, t)
colors.append(rs.EvaluateCurve(colorLine, param))
for i, obj in enumerate(objSorted):
rs.ObjectColor(obj, (colors[i].X, colors[i].Y, colors[i].Z))
rs.DeleteObject(colorLine)
rs.EnableRedraw(True)
return True
except:
return False
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 writeToCsv(self):
suffix = 'output' + str(time()) + ".csv"
file = suffix
fs = open(file, "a")
fs.write("\n\nentry number," + str(time()) + "\n\n")
fs.write("\nSiteArea" + "," + str(rs.CurveArea(self.site)[0]))
fs.write(
"\n\n\nobjects,NAME,AREA,NUM OF FLOORS,NUMBER OF FOOTPRINTS,TOTAL AREA OCC"
)
sum_area = 0
sum_foot = 0
for i in self.req_obj:
total_area = i.getNumFloors() * rs.CurveArea(i.getReqPoly()[0])[0]
sum_foot += i.getCrvArea()
sum_area += i.getTotalArea()
#print('area of floor=',rs.CurveArea(i.getReqPoly()[0])[0])
fs.write("\nObjects" + "," + str(i.getName()) + "," +
str(i.getArea()) + "," + str(i.getNumFloors()) + "," +
str(len(i.getGenPoly())) + "," + str(total_area))
fs.write("\n\n\ntotal footprint" + "," + str(sum_foot))
fs.write("\n\n\ntotal area occupied" + "," + str(sum_area))
fs.close()
def Offset_total():
off_dist = rs.GetReal("Enter distance of offsets", 2.5)
off_dist = abs(off_dist)
curve_sel = rs.GetObject("Select curve")
off_direct = Offset_Direction(curve_sel)
#off_direct=rs.GetPoint("Pick point")
new_curve = rs.OffsetCurve(curve_sel, off_direct, off_dist)
#get curve area for safety break if offset goes outside (it would be infinite)
if rs.IsCurveClosed(curve_sel):
curve_sel_area = rs.CurveArea(curve_sel)
print(curve_sel_area)
new_curve_area = rs.CurveArea(new_curve)
print(new_curve_area)
i = 0
# while curve_sel_area > new_curve_area and new_curve !=None:
while i < 20:
print "iterating"
curve_sel = new_curve
print curve_sel, off_direct, off_dist
new_curve = rs.OffsetCurve(curve_sel, off_direct, off_dist)
if new_curve is None:
print "Is none"
break
if rs.IsCurve(new_curve):
if len(new_curve) > 1:
print ">1"
rs.DeleteObjects(new_curve)
break
else:
print "It is not curve anymore"
break
i = i + 1
def extr_bld_flr():
# Extrude all buildings according to NUM_FLOORS attribute multiplied by FLOOR_HEIGHT constant
# get all objects in building layer
building_objs = rs.ObjectsByLayer(relevant_layers_dict["buildings"])
for building_obj in building_objs:
if rs.IsCurve(building_obj) and rs.IsCurveClosed(
building_obj
) and rs.CurveArea(building_obj)[0] > MIN_BUILDING_AREA_SQM:
crv = rs.coercecurve(building_obj)
num_of_floors = rs.GetUserText(building_obj, "NUM_FLOORS")
building_height = FLOOR_HEIGHT_M * int(num_of_floors)
srf = rs.ExtrudeCurveStraight(crv, (0, 0, 0),
(0, 0, building_height))
rs.CapPlanarHoles(srf)
rs.ViewDisplayMode(rs.CurrentView(), "Shaded")
def calc_overlap_area_ratio(c1, c2):
c1 = rs.coercecurve(c1)
c2 = rs.coercecurve(c2)
geo_area = rs.CurveArea(c1)[0]
overlap_region = c1.CreateBooleanIntersection(c1, c2)
if overlap_region:
overlap_area = rg.AreaMassProperties.Compute(overlap_region).Area
overlap_area_ratio = (overlap_area / geo_area) * 100
debug_print("overlap area ratio: {}%".format(
round(overlap_area_ratio, 1)))
return overlap_area_ratio
else:
return 0
def writeToCsv(self, counter, str_li):
file = 'output' + str(time()) + ".csv"
fs = open(file, "a")
site_area = rs.CurveArea(self.site_crv)[0]
fs.write("\nSiteArea" + "," + str(site_area))
fs.write("\nF.S.R Required" + "," + str(self.fsr))
fs.write("\nBuilt-up Area Required" + "," + str(site_area * self.fsr))
best_ite = 100
best_index = 0
for i in range(counter): #2-d str list
fs.write("\n\n\n,,ENTRY NUMBER," + str(i + 1))
fs.write(
"\nType of Building,Total Area,Num of floors, Num plotted, Area of floorplate\n"
)
total_area = 0
gc = 0
for j in str_li[i]: #1-d element of str list
#name, area, num_flrs, num_poly, ar_int_poly
fs.write(
str(j[0]) + "," + str(j[1]) + "," + str(j[2]) + "," +
str(j[3]) + "," + str(j[4]) + "\n")
total_area += j[2] * j[3] * j[4]
gc += j[2] * j[4]
fs.write("\nGross Floor Area," + str(total_area))
fsr = total_area / site_area
fs.write("\nF.S.R," + str(fsr))
f_gc = gc * 100 / site_area
fs.write("\nGround Coverage," + str(f_gc))
this_ite = math.fabs(self.fsr - fsr)
#print(this_ite)
if (this_ite < best_ite):
best_ite = this_ite
best_index = i
fs.close()
print(best_index, best_ite)
r = self.res_obj[best_index]
loc_pt = self.loc_pts[best_index]
rs.AddCircle(loc_pt, self.max / 2)
#rs.AddTextDot(best_index,loc_pt)
#print(len(self.res_obj))
"""
def retResult(self):
str = []
sum_area = 0
sum_foot = 0
req_str = []
for i in self.req_obj:
name = i.getName()
area = i.getArea()
num_flrs = i.getNumFloors()
num_poly = len(i.getGenPoly())
#find the area of internal poly
num_int_poly_check = len(i.getReqPoly())
int_poly = []
ar_int_poly = 0
try:
int_poly = i.getReqPoly()[0]
ar_int_poly = rs.CurveArea(int_poly)[0]
except:
pass
#print / add as string
this_str = [name, area, num_poly, num_flrs, ar_int_poly]
req_str.append(this_str)
return req_str
def __init__(self, x, c):
self.path = x
self.site = c
self.req_obj = []
self.site_ar = rs.CurveArea(self.site)[0]
out_loop_counter = 0
xy_found = 0
for attributes_row in rdr:
out_loop_counter += 1
x_val, y_val, z_val = float(attributes_row[x_idx]), float(
attributes_row[y_idx]), float(attributes_row[z_idx])
related_building_pnt = rs.CreatePoint(x_val, y_val, z_val)
xy_found = False
in_loop_counter = 0
for building_obj in building_objs:
in_loop_counter += 1
if rs.IsCurve(building_obj) and rs.IsCurveClosed(
building_obj) and (rs.CurveArea(building_obj)[0] >
MIN_BUILDING_AREA_SQM):
crv = rs.coercecurve(building_obj)
if rs.PointInPlanarClosedCurve(related_building_pnt, crv):
xy_found = True
for attr_label, attr_val in zip(attribute_labels_list,
attributes_row):
rs.SetUserText(building_obj, attr_label, attr_val)
if not xy_found:
rs.SelectObject(building_obj)
print(x_val, y_val, z_val)
print(out_loop_counter)
##########################################################################################################################################
# Extrude all buildings according to NUM_FLOORS attribute multiplied by FLOOR_HEIGHT constant
# get all objects in building layer
def Main():
input_curves = rs.GetObjects("Curves", rs.filter.curve, True, True)
input_points = rs.GetObjects("Points for dogboone placement",
rs.filter.point)
if not input_curves or not input_points: return
#Reads, asks and writes settings to document
data_name = "dogbone2"
values = rs.GetDocumentData(data_name, "settings")
values = json.loads(values)["data"] if values else [
"35.0", "15.0", "9.525", "1"
]
settings = ["Length:", "With:", "Diameter:", "Tolerance Offset:"]
length, width, diam, aperture = [
float(i.replace(" ", "")) for i in rs.PropertyListBox(
settings, values, "DogBone by dfmd", "Settings:")
]
rs.SetDocumentData(data_name, "settings",
json.dumps({"data": [length, width, diam, aperture]}))
sorted_points = []
clean_curves = []
rs.EnableRedraw(False)
for curve in input_curves:
point_list = []
for point in input_points:
if rs.PointInPlanarClosedCurve(point, curve,
rs.CurvePlane(curve)) == 2:
point_list.append(point)
if point_list:
sorted_points.append(rs.SortPointList(point_list))
#Clean curve
# circle = rs.AddCircle(rs.CurveAreaCentroid(curve)[0],10000)
# planar_surface = rs.AddPlanarSrf(circle)
# projected_curve = rs.ProjectCurveToSurface(curve,planar_surface,(0,0,-1))
# clean_curves.append(projected_curve)
# rs.DeleteObjects([circle,planar_surface,curve])
clean_curves.append(curve)
#main_curve = rs.GetCurveObject("Selecciona curva",True)[0]
#main_points = rs.SortPointList(rs.GetObjects("Selecciona puntos de referencia",rs.filter.point))
#input_curves = rebuild_curves(input_curves)
for main_curve in clean_curves:
main_points = sorted_points[clean_curves.index(main_curve)]
bone_curves = [
create_bone(point, main_curve, length, width, diam / 2, aperture)
for point in main_points
]
#new_main_curve = rs.CopyObject(rs.ConvertCurveToPolyline(main_curve,False,False,True))
new_main_curve = rs.CopyObject(main_curve)
completed = True
for bone_curve in bone_curves:
buffer_curve = rs.CurveBooleanDifference(new_main_curve,
bone_curve)
if len(buffer_curve) > 1:
rs.DeleteObjects(buffer_curve)
rs.DeleteObject(new_main_curve)
completed = False
break
rs.DeleteObject(new_main_curve)
new_main_curve = buffer_curve
if not completed:
super_curve = rs.CurveBooleanUnion(bone_curves)
rare_curves = rs.CurveBooleanDifference(main_curve, super_curve)
if len(rare_curves) > 1:
areas = [rs.CurveArea(i) for i in rare_curves]
sorted_curves = [
x for (y, x) in sorted(zip(areas, rare_curves))
]
rs.DeleteObjects(sorted_curves[:-1])
rs.DeleteObject(super_curve)
rs.DeleteObjects(bone_curves + [main_curve])
def getTotalArea(self):
ar=rs.CurveArea(self.getReqPoly()[0])[0]*self.getNumFloors()
return ar
__author__ = "dfmd"
__version__ = "2019.07.12"
import rhinoscriptsyntax as rs
base_curve = rs.GetObject("Reference curve", rs.filter.curve,True,True)
curves = rs.GetObjects("Curves")
tol = rs.GetReal("Tolerance",1)
if base_curve and curves:
try:
base_area = rs.CurveArea(base_curve)
area_curves = []
for curve in curves:
if rs.IsCurveClosed(curve):
if abs(rs.CurveArea(curve)[0] - base_area[0]) < base_area[1] + tol:
area_curves.append(curve)
rs.SelectObjects(area_curves)
print "%s equal area objects found." % len(area_curves)
except Exception as e:
print('Error: %s' % e)
def getCrvArea(self):
ar=0
for i in self.getReqPoly():
ar+=rs.CurveArea(i)[0]
return ar
def isSmall(self, curve_1, curve_2):
if rs.CurveArea(curve_1) < rs.CurveArea(curve_2):
return True
else:
return False
def rc_plot_volumes(use_epsilon):
#get sticky
default_thickness = sticky["defaultThickness"] if sticky.has_key(
"defaultThickness") else 5.5
go = Rhino.Input.Custom.GetObject()
go.GeometryFilter = Rhino.DocObjects.ObjectType.Brep
opt_thickness = Rhino.Input.Custom.OptionDouble(default_thickness, 0.2,
1000)
opt_sections = Rhino.Input.Custom.OptionToggle(False, "No", "Yes")
opt_inplace = Rhino.Input.Custom.OptionToggle(False, "No", "Yes")
opt_heights = Rhino.Input.Custom.OptionToggle(False, "No", "Yes")
go.SetCommandPrompt("Select breps to extract plan cuts")
go.AddOptionDouble("Thickness", opt_thickness)
go.GroupSelect = True
go.SubObjectSelect = False
go.AcceptEnterWhenDone(True)
go.AcceptNothing(True)
go.EnableClearObjectsOnEntry(False)
go.EnableUnselectObjectsOnExit(False)
go.GroupSelect = True
go.SubObjectSelect = False
go.DeselectAllBeforePostSelect = False
res = None
bHavePreselectedObjects = False
while True:
res = go.GetMultiple(1, 0)
#If new option entered, redraw a possible result
if res == Rhino.Input.GetResult.Option:
# print res
go.EnablePreSelect(False, True)
continue
#If not correct
elif res != Rhino.Input.GetResult.Object:
return Rhino.Commands.Result.Cancel
if go.ObjectsWerePreselected:
bHavePreselectedObjects = True
go.EnablePreSelect(False, True)
continue
break
rs.EnableRedraw(False)
global THICKNESS
THICKNESS = opt_thickness.CurrentValue
global LCUT_INDICES
LCUT_INDICES = wla.get_lcut_layers()
#Get brep representations of objects
brep_geo_list = []
for i in xrange(go.ObjectCount):
b_obj = go.Object(i).Object()
brep_geo_list.append(b_obj.Geometry)
#...brep conversion may be necessary
new_brep_list = []
for i, geo in enumerate(brep_geo_list):
if geo.GetType() != Rhino.Geometry.Brep:
new_brep_list.append(wru.extrusion_to_brep(geo))
else:
new_brep_list.append(geo)
#set base for output.
xbase = 0
ybase = 0
#set the amount to move up from the bottom of the brep for cutting the lower outline.
#this should be replaced by a projection of the bottom face of the brep.
epsilon = D_TOL * 2
select_items = []
for i, brep in enumerate(new_brep_list):
#get label prefix and bounding dims for this brep
bdims = wge.get_bounding_dims(brep)
baseplane = rs.MovePlane(rs.WorldXYPlane(), [xbase, ybase, 0])
label_letter = wut.number_to_letter(i)
label_prefix = label_letter + "-"
#prepare heights and labels for each section cut
num_sections = 1
remaining_thickness = 0
cuts_at = [epsilon] if use_epsilon else [0]
brep_label = label_letter
section_labels = [label_letter]
num_sections, remaining_thickness, cuts_at = get_section_division(
bdims.Z, THICKNESS)
if use_epsilon: cuts_at[0] = epsilon
brep_label = label_letter + " r: " + str(round(remaining_thickness, 2))
section_labels = [label_prefix + str(i) for i in xrange(len(cuts_at))]
#get section information for each cut
section_planes = get_brep_section_planes(brep, cuts_at)
#get lowest curve info
section_curves, section_dims = [[], []]
for i, plane in enumerate(section_planes):
curve, dims = [0, 0]
if (not use_epsilon) and (i == 0):
curve, dims = get_lowest_curve_info(brep, D_TOL * 2)
else:
curve, dims = get_section_curve_info_multi_no_ortho(
brep, plane)
section_curves.append(curve)
section_dims.append(dims)
##DO WORK HERE##
drawing_planes = get_drawing_planes(section_dims, baseplane, GAP_SIZE)
#place curves in drawing location
for sp, dp, sc in zip(section_planes, drawing_planes, section_curves):
t = Rhino.Geometry.Transform.ChangeBasis(dp, sp)
for c in sc:
c.Transform(t)
#THIS IS STILL A MESS: LABEL ADDING
#draw curves and add text dots
top_label_pt = get_brep_label_pt(brep)
brep_textdot = rs.AddTextDot(brep_label, top_label_pt)
rs.ObjectLayer(brep_textdot, "XXX_LCUT_00-GUIDES")
label_pts = []
for sc, label in zip(section_curves, section_labels):
temp_area = 0
for i, c in enumerate(sc):
crv = wru.add_curve_to_layer(c, LCUT_INDICES[1])
select_items.append(crv)
if i == 0:
label_pts.append(rs.CurveAreaCentroid(crv)[0])
temp_area = rs.CurveArea(crv)
else:
if rs.CurveArea(crv) > temp_area:
label_pts[-1] = rs.CurveAreaCentroid(crv)[0]
temp_area = rs.CurveArea(crv)
fab_tags = wfa.add_fab_tags(label_pts, section_labels, TEXTSIZE)
for tag in fab_tags:
rs.ObjectLayer(tag, "XXX_LCUT_02-SCORE")
group_name = rs.AddGroup()
rs.AddObjectsToGroup(tag, group_name)
ybase += max([s.Y for s in section_dims]) + GAP_SIZE * 1
for tag in fab_tags:
select_items.extend(tag)
#THIS IS STILL A MESS: LABEL ADDING
sticky["defaultThickness"] = THICKNESS
rs.UnselectAllObjects()
rs.SelectObjects(select_items)
rs.Redraw()
rs.EnableRedraw(True)
def AreaTag(obj, decPlaces):
try:
rhsrf = rs.coercesurface(obj)
if rs.IsCurve(obj):
if rs.IsCurvePlanar(obj) == False:
return [0, False]
if rs.IsCurveClosed(obj) == False:
return [0, False]
#get area
if rs.UnitSystem() == 8:
if rs.IsCurve(obj):
area = rs.CurveArea(obj)[0]*0.0069444444444444
else:
area = rs.Area(obj)*0.0069444444444444
areaText = utils.RoundNumber(area, decPlaces) + " SF"
else:
print "WARNING: Your units are not in inches"
area = rs.CurveArea(obj)[0]
areaText = area + ' ' + rs.UnitSystemName(False, True, True)
#add annotation style
dimStyle = sc.doc.DimStyles.FindName('PCPA_12')
###########################################################################
#CURVES
if rs.IsCurve(obj):
if utils.IsRectangle(obj)[0]:
#RECTANGLES
srf = rs.AddPlanarSrf(obj)
plane = HorizPlaneFromSurface(srf)
rs.DeleteObject(srf)
else:
#OTHER CURVES
srf = rs.AddPlanarSrf(obj)
plane = HorizPlaneFromSurface(srf)
rs.DeleteObject(srf)
###########################################################################
#HATCHES
elif rs.IsHatch(obj):
rhobj = rs.coercegeometry(obj)
boundaryCrvs = []
crvs = rhobj.Get3dCurves(False)
for crv in crvs:
boundaryCrvs.append(crv)
for crv in rhobj.Get3dCurves(True):
boundaryCrvs.append(crv)
srf = sc.doc.Objects.AddBrep(rc.Geometry.Brep.CreatePlanarBreps(boundaryCrvs)[0])
plane = HorizPlaneFromSurface(srf)
rs.DeleteObject(srf)
###########################################################################
#SURFACES
elif rs.IsSurface(obj):
plane = HorizPlaneFromSurface(obj)
###########################################################################
#OTHER/ERROR
else:
pts = rs.BoundingBox(obj)
centerPoint = (pts[0] + pts[6]) / 2
if dimStyle is not None:
textHeight = dimStyle.TextHeight
areaTag = rs.AddText(areaText, plane, height = textHeight, justification = 131074)
else:
areaTag = rs.AddText(areaText, plane, height = 1, justification = 131074)
#Change layers
hostLayer = layers.AddLayerByNumber(8103, False)
rs.ObjectLayer(areaTag, layers.GetLayerNameByNumber(8103))
return [area, True, areaTag]
except:
return [0, False]
