def TestIntersection(obj, tester):
# there are a few possible intersection methods in rhinoscriptsyntax
# as an initial setup only a few intersections are handled
# to make this script faster and more robuste best would be to intersect not with rhinoscriptsyntax
# But use RhinoCommon methods instead.
#
#for now only rhinoscriptsyntax methods are used as an example below:
# if both are breps ( (poly)surface or extrusion
if rs.IsBrep(obj) and rs.IsBrep(tester):
intersections = rs.IntersectBreps(obj, tester)
if intersections:
#Delete intersections if they were made
rs.DeleteObjects(intersections)
return True
if rs.IsMesh(obj) and rs.IsMesh(tester):
intersections = rs.MeshMeshIntersection(obj, tester)
if intersections:
#This method does not create a curve but returns a list of points
#so nothing to delete
return True
#Mixed input needs to be handled different as is with curves.
#if either is a mesh the other needs to be converted to a mesh as well
#catchall return False
return False
def slice_plane(self, target, plane):
### Slice
p = rs.coerceplane(plane)
### Geomrtry Type
if rs.IsMesh(target):
# print("Mesh!!")
m = rs.coercemesh(target)
# print(m)
polylines = rg.Intersect.Intersection.MeshPlane(m, p)
elif rs.IsBrep(target):
# print("Brep!")
b = rs.coercebrep(target)
mp = rg.MeshingParameters.QualityRenderMesh
m = rg.Mesh.CreateFromBrep(b, mp)
# print(m[0])
polylines = rg.Intersect.Intersection.MeshPlane(m[0], p)
else:
# print("N/A")
polylines = None
return polylines
def cutAtPlan(level):
planPlane = rs.AddPlaneSurface([-1000,-1000,level], 3000, 3000)
baseLayer = rs.AddLayer("60_PLANS")
newParent = rs.AddLayer("PLAN_"+str(level), parent = baseLayer)
origLayer = rs.CurrentLayer()
shortName = rs.LayerName(origLayer, fullpath = False)
#newChildsParent = rs.AddLayer( , parent = newParent)
newChild = rs.AddLayer(shortName, parent = newParent, color = rs.LayerColor(origLayer))
rs.CurrentLayer(newChild)
objs = rs.ObjectsByLayer(origLayer)
#if len(objs)<1:
# skip = True
intersectCrvs = []
tempCrv = None
for obj in objs:
if rs.IsBrep(obj):
tempCrv = rs.IntersectBreps(obj, planPlane)
if tempCrv != None:
intersectCrvs.append(tempCrv)
for crv in intersectCrvs:
if not None:
rs.ObjectLayer(crv, newChild)
rs.DeleteObject(planPlane)
rs.CurrentLayer(origLayer)
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 importComponent(path):
imported=rs.Command("-Insert "+path+' Objects Enter 0,0,0 1 0')
if imported:
components=rs.LastCreatedObjects()
polys=[]
breps=[]
for comp in components:
if rs.IsCurve(comp):polys.append(comp)
if rs.IsBrep(comp):breps.append(comp)
print ('polys \n',polys)
print ('breps \n',breps)
return [breps,polys]
def clean_and_coerce_list(brep_list):
#""" Ladybug - This definition cleans the list and adds them to RhinoCommon"""
outputMesh = []
outputBrep = []
for id in brep_list:
if rs.IsMesh(id):
geo = rs.coercemesh(id)
if geo is not None:
outputMesh.append(geo)
try:
rs.DeleteObject(id)
except:
pass
elif rs.IsBrep(id):
geo = rs.coercebrep(id)
if geo is not None:
outputBrep.append(geo)
try:
rs.DeleteObject(id)
except:
pass
else:
# the idea was to remove the problematice surfaces
# not all the geometry which is not possible since
# badGeometries won't pass rs.IsBrep()
tempBrep = []
surfaces = rs.ExplodePolysurfaces(id)
for surface in surfaces:
geo = rs.coercesurface(surface)
if geo is not None:
tempBrep.append(geo)
try:
rs.DeleteObject(surface)
except:
pass
geo = JoinBreps(tempBrep, 0.01)
for Brep in tempBrep:
Brep.Dispose()
try:
rs.DeleteObject(id)
except:
pass
outputBrep.append(geo)
return outputMesh, outputBrep
def importComponent(path):
if path is None: return None
imported = rs.Command("-Insert " + path + ' Objects Enter 0,0,0 1 0')
outComponent = AttrDict()
if imported:
components = rs.LastCreatedObjects()
outComponent.polys = []
outComponent.breps = []
for comp in components:
if rs.IsCurve(comp): outComponent.polys.append(comp)
if rs.IsBrep(comp): outComponent.breps.append(comp)
return outComponent
def IntersectGeo(obj, level):
tolerance = rs.UnitAbsoluteTolerance()
plane = rc.Geometry.Plane(rs.coerce3dpoint((0, 0, level)),
rs.coerce3dvector((0, 0, 1)))
finalCurves = []
#BLOCKS
if rs.IsBlockInstance(obj):
matrix = rs.BlockInstanceXform(obj)
blockObjs = rs.BlockObjects(rs.BlockInstanceName(obj))
for eachBlockObj in blockObjs:
newCopy = rs.CopyObject(eachBlockObj)
xformedObj = rs.TransformObject(newCopy, matrix)
#EXTRUSIONS
if isinstance(xformedObj, rc.Geometry.Extrusion):
temp = sc.doc.Objects.AddBrep(xformedObj.ToBrep(False))
xformedObj = rs.coercebrep(temp)
rs.DeleteObject(temp)
#BREPS IN BLOCK
result = IntersectBrepPlane(xformedObj, plane)
if result is None: continue
for each in result:
if each is not None:
finalCurves.append(each)
rs.DeleteObject(xformedObj)
#MESHES IN BLOCK <---This code might not be necessary
result = IntersectMeshPlane(xformedObj, plane)
if result is None: continue
for each in result:
if each is not None:
finalCurves.append(each)
rs.DeleteObject(xformedObj)
#BREPS
elif rs.IsBrep(obj):
result = IntersectBrepPlane(obj, plane)
if result is None: return None
for each in result:
if each is not None:
finalCurves.append(each)
#MESHES
elif rs.IsMesh(obj):
result = IntersectMeshPlane(obj, plane)
if result is None: return None
for each in result:
if each is not None:
finalCurves.append(each)
return finalCurves
def split(srfs,cutter,stop=False):
##print('iter:{},num srfs:{}'.format(iteration,len(srfs)))
outbin=[]
for s in srfs:
if not rs.IsBrep(s):
continue
result=rs.SplitBrep(s,cutter,True)
#print('$result is ',result)
if result is None:
# pass
outbin.append(s)
else:
outbin+=split(result,cutter)
return outbin
def cutAtPlan(level, join):
cutPlane = rs.AddPlaneSurface([-1000,-1000,level], 3000, 3000)
plane = rs.PlaneFromNormal([-1000,-1000,0], [0,0,1])
planPlane = rs.AddPlaneSurface(plane, 3000, 3000)
objs = rs.VisibleObjects()
intersectCrvs = []
tempCrv = None
for obj in objs:
if rs.IsBrep(obj):
tempCrv = rs.IntersectBreps(obj, cutPlane)
if tempCrv:
rs.MatchObjectAttributes(tempCrv, obj)
newCrvs = flatten(tempCrv)
rs.DeleteObject(cutPlane)
rs.DeleteObject(planPlane)
def contourPt(obj, pt):
"""
creates a contour according to xy plane at specified height
obj: single object to contour
pt: a point to contour at
"""
planPlane = rs.AddPlaneSurface([-10000, -10000, pt[2]], 30000, 30000)
intersectCrvs = []
tempCrv = None
if rs.IsBrep(obj):
tempCrv = rs.IntersectBreps(obj, planPlane)
if tempCrv != None:
objName = rs.ObjectName(obj)
rs.ObjectName(tempCrv, objName)
intersectCrvs.append(tempCrv)
rs.MatchObjectAttributes(tempCrv, obj)
rs.DeleteObject(planPlane)
return intersectCrvs
def on_click_add_hb_object(self, sender, e):
objects = sc.doc.Objects.GetSelectedObjects(False, False)
for obj in objects:
if not rs.IsBrep(obj.Id) and not rs.IsMesh(obj.Id):
return
#check object on list
if obj.Id in self.m_hb_object_ids:
return
#create grid item row
itemText = obj.ShortDescription(False)
if obj.Name:
itemText += " - " + obj.Name
self.m_hb_object_ids += [obj.Id]
datarow = [itemText, self.m_hb_type_items, self.m_hb_material_items]
#update grid values
self.m_hb_objects_gridview.DataStore += \
[RowValues(datarow, self.m_hb_column_cell_type)]
def AddCoordinateTag(obj):
dots = []
if rs.IsCurve(obj):
pts = rs.CurveEditPoints(obj)
elif rs.IsSurface(obj):
pts = rs.SurfaceEditPoints(obj)
elif rs.IsBrep(obj):
srfs = rs.ExplodePolysurfaces(obj)
pts = []
for srf in srfs:
pts+=rs.SurfaceEditPoints(srf)
rs.DeleteObjects(srfs)
try:
pts
except:
return
for pt in pts:
dots.append(rs.AddTextDot('X: '+str(pt.X)+'\nY: '+str(pt.Y)+'\nZ: ' +str( pt.Z), pt))
return dots
def SplitGeometry(objs, plane, dir=1):
global diffRadius
circle = Rhino.Geometry.Circle(plane, diffRadius)
negShape = Rhino.Geometry.Cylinder(circle, diffRadius * dir)
negShapeBrep = negShape.ToBrep(True, True)
negShapeGeo = sc.doc.Objects.AddBrep(negShapeBrep)
visibleGeometry = []
for obj in objs:
if rs.IsBrep(obj):
if rs.IsPolysurfaceClosed(obj):
resultObjs = rs.BooleanDifference(obj, negShapeGeo, False)
if resultObjs is None:
visibleGeometry.append(obj)
elif len(resultObjs) < 1:
visibleGeometry.append(obj)
else:
for each in resultObjs:
visibleGeometry.append(each)
else:
resultObjs = rs.SplitBrep(obj, negShapeGeo)
if resultObjs is None:
visibleGeometry.append(obj)
elif len(resultObjs) < 1:
visibleGeometry.append(obj)
else:
for each in resultObjs:
if IsAbovePlane(each, plane.OriginZ):
if dir == -1:
visibleGeometry.append(each)
else:
rs.DeleteObject(each)
else:
if dir == 1:
visibleGeometry.append(each)
else:
rs.DeleteObject(each)
rs.DeleteObject(negShapeGeo)
return visibleGeometry
def lb_generate_test_points(self):
try:
#load breps/meshes from analysis grid object list
brep_list = []
mesh_list = []
for item in self.m_gridsurfs_list_box.Items:
if rs.IsBrep(item.Tag):
brep_list += [Rhino.DocObjects.ObjRef(item.Tag).Brep()]
elif rs.IsMesh(item.Tag):
mesh_list += [Rhino.DocObjects.ObjRef(item.Tag).Mesh()]
else:
continue
#prepare grid paramers
grid_size = self.m_numeric_gridsize_updown.Value
dist_base_surf = self.m_numeric_distsurf_updown.Value
move_test_mesh = False
#create meshes from breps, add to mesh list
input_mesh = mesh_list + LadybugEto.createMesh(brep_list, grid_size)
self.m_output_mesh = []
self.m_test_points = []
self.m_pts_vectors = []
for index, mesh in enumerate(input_mesh):
test_points, pts_vectors, faces_area, output_mesh = \
LadybugEto.getTestPts(
[mesh],
dist_base_surf,
move_test_mesh)
self.m_test_points += [test_points]
self.m_pts_vectors += [pts_vectors]
self.m_output_mesh += output_mesh
#update meshes in scene
LadybugEto.bakeGeo(self.m_output_mesh, 'lb_sunlighthours')
except Exception as e:
print e
def on_click_add_grid_object(self, sender, e):
objects = sc.doc.Objects.GetSelectedObjects(False, False)
item_list = [item.Tag for item in self.m_gridsurfs_list_box.Items]
for obj in objects:
#invalid selection type?
if not rs.IsBrep(obj.Id) and not rs.IsMesh(obj.Id):
return
#already in list?
if obj.Id in item_list:
return
#create list item
item = forms.ListItem()
item.Text = obj.ShortDescription(False)
if obj.Name:
item.Text += " - " + obj.Name
item.Tag = obj.Id
self.m_gridsurfs_list_box.Items.Add(item)
self.lb_generate_test_points()
def main(north, boundary, timeperiod, monthRange, location):
if sc.sticky.has_key('ladybug_release'):
try:
if not sc.sticky['ladybug_release'].isCompatible(ghenv.Component):
return -1
if sc.sticky['ladybug_release'].isInputMissing(ghenv.Component):
return -1
except:
warning = "You need a newer version of Ladybug to use this component." + \
"Use updateLadybug component to update userObjects.\n" + \
"If you have already updated userObjects drag Ladybug_Ladybug component " + \
"into canvas and try again."
w = gh.GH_RuntimeMessageLevel.Warning
ghenv.Component.AddRuntimeMessage(w, warning)
return -1
lb_sp = sc.sticky["ladybug_SunPath"]()
lb_prep = sc.sticky["ladybug_Preparation"]()
# setting solar noon variables
latitude, longitude, timeZone, elevation = readLocation(_location)
year = datetime.datetime.now().year
day = 21
"""
MONTH_DICT = {0:range(3,7), 1:range(3,10), 2:range(3,13),\
3:range(6,10), 4:range(6,13),\
5:range(9,13)}
"""
mth_lst = MONTH_DICT[monthRange]
t = timeperiod / 2.0
centerPt = rs.CurveAreaCentroid(boundary)[0]
# do geometry operations
boundary = clean_curve(boundary)
brep_lst = []
for mth in mth_lst:
solar_noon = get_solar_noon(mth, year, timeZone, day, latitude,
longitude)
hourlst = [solar_noon - t, solar_noon + t]
#print mth
#print 'month: ',mth,'th;', 'hours: ', hourlst
sun_pts = get_sunpt(lb_sp,
lb_prep,
latitude,
centerPt,
mth,
day,
hourlst,
north_=north,
lon=longitude,
tZ=timeZone,
scale_=100)
brep = rs.coercebrep(make_zone(sun_pts, boundary))
brep_lst.append(brep)
SE = None
TOL = sc.doc.ModelAbsoluteTolerance
for i in range(len(brep_lst) - 1):
brep = brep_lst[i]
brep_ = brep_lst[i + 1]
if not SE and rs.IsBrep(brep):
SE_ = brep
else:
SE_ = SE
if rs.IsBrep(brep_):
SE = rc.Brep.CreateBooleanIntersection(SE_, brep_, TOL)[0]
else:
SE = SE_
return SE
else:
print "You should first let the Ladybug fly..."
ghenv.Component.AddRuntimeMessage(
ERROR_W, "You should first let the Ladybug fly...")
def make_fingers(positive, negative, subdivisions):
"""
intersect two collections of planes
subdivide the intersections
assign each subdivision to a guid from which it will be subtracted
"""
# this vector is used to indicate axis of the intersection.
# it needs to be parallel to the intersection
# (there are other ways of doing this!)
p0 = rs.GetPoint("select start of intersection")
p1 = rs.GetPoint("select end of intersection")
edge = rs.AddLine(p0, p1)
vector = rs.VectorCreate(p0, p1)
rs.EnableRedraw(False)
# this dict maps a pair of planes (ps, ns) to their booleanintersection
intersections = {}
for ps in positive:
for ns in negative:
intersection = rs.BooleanIntersection(ps, ns, False)
if intersection is not None:
intersections[(ps, ns)] = intersection
# here we construct some very large cylinders aligned with the axis you drew
origins = []
cylinders = []
for i in range(subdivisions+1):
origin = rs.EvaluateCurve(edge, rs.CurveParameter(edge, i * 1.0/(subdivisions)))
origins.append(origin)
rs.DeleteObject(edge)
for i in range(subdivisions):
plane = rs.PlaneFromNormal(origins[i], vector)
circle = rs.AddCircle(plane, 100)
planar_circle = rs.AddPlanarSrf(circle)
extrusion_curve = rs.AddLine(origins[i], origins[i+1])
cylinders.append(rs.ExtrudeSurface(planar_circle, extrusion_curve))
rs.DeleteObject(circle)
rs.DeleteObject(planar_circle)
rs.DeleteObject(extrusion_curve)
# we perform a boolean intersection between each intersection and
# the cylinders to construct the fingers
for key, intersection in intersections.items():
ps, ns = key
for i, cylinder in enumerate(cylinders):
print "intersection", intersection
print "cylinder", cylinder
objs = [brep for brep in rs.BooleanIntersection(intersection, cylinder, False) if rs.IsBrep(brep)]
# assign the resulting fingers to either the positive or negative
if i % 2 == 0:
guid_to_difference[ps].extend(objs)
else:
guid_to_difference[ns].extend(objs)
DeleteItemOrList(cylinders)
DeleteItemOrList(intersections.values())
rs.EnableRedraw(True)
def generateAnalysis(test_points, pts_vectors, name, window_groups,
sun_vectors, hoys, timestep, hb_object_ids,
hb_object_types, hb_object_mats, folder, filename,
save_file_only, grid_mesh):
try:
analysis_grids = AnalysisGrid.from_points_and_vectors(
test_points, pts_vectors, name, window_groups)
#get analysis recipe
analysis_recipe = None
if sun_vectors and sun_vectors[0] != None and \
hoys and hoys[0] != None and analysis_grids:
# set a sunlight hours analysis recipe together if there are points
analysis_recipe = SolarAccessGridBased(sun_vectors, hoys,
[analysis_grids],
timestep)
else:
print "missing sun vector data"
return
#HB surfaces
#convert scene hb objects into rhino common
geo_list = []
for id in hb_object_ids:
if rs.IsBrep(id):
geo_list += [rc.DocObjects.ObjRef(id).Brep()]
elif rs.IsMesh(id):
geo_list += [rc.DocObjects.ObjRef(id).Mesh()]
else:
continue
#preapre paramters
if len(geo_list) != 0 and geo_list[0] != None:
names = None #not included yet in eto interface (could use scene object name)
hb_objects = []
for index, geo in enumerate(geo_list):
type = hb_object_types[index]
radMat = hb_object_mats[index]
isNameSetByUser = False
if names:
isNameSetByUser = True
isTypeSetByUser = True
if not type:
isTypeSetByUser = False
rad_prop = RadianceProperties(
radMat) if radMat else RadianceProperties()
ep_prop = None
if radMat and radMat.__class__.__name__ == 'Plastic':
hb_objects += HBSurface.from_geometry(
names, geo, type, isNameSetByUser, isTypeSetByUser,
rad_prop, ep_prop)
elif radMat and radMat.__class__.__name__ == 'Glass':
hb_objects += HBFenSurface.from_geometry(
names, geo, isNameSetByUser, rad_prop, ep_prop)
else:
print "No valid HB surfaces selected"
return
# Run analysis
rad_scene = None
if not hb_objects or not analysis_recipe:
print "Missing HB objects or analysis recipe"
return
try:
for obj in hb_objects:
assert hasattr(obj, 'isHBObject')
except AssertionError:
raise ValueError(
"\n{} is not a valid Honeybee object.".format(obj))
assert hasattr(analysis_recipe, 'isAnalysisRecipe'), \
ValueError("\n{} is not a Honeybee recipe.".format(analysis_recipe))
legend_par = analysis_recipe.legend_parameters
#write to file
# Add Honeybee objects to the recipe
analysis_recipe.hb_objects = hb_objects
analysis_recipe.scene = rad_scene
batch_file = analysis_recipe.write(folder, filename)
#run if 'save file only' is not checked
outputs = None
if not save_file_only:
if analysis_recipe.run(batch_file, False):
try:
outputs = analysis_recipe.results()
except StopIteration:
raise ValueError(
'Length of the results is smaller than the analysis grids '
'point count [{}]. In case you have changed the analysis'
' Grid you must re-calculate daylight/view matrix!'
.format(analysis_recipe.total_point_count))
if outputs:
LadybugEto.displayAnalysis(grid_mesh, outputs, legend_par,
filename)
except Exception as e:
print e
def ExplodeBox(hulls, index):
if rs.IsBrep(hulls):
faces = rs.ExplodePolysurfaces(hulls, True)
for face in faces:
SplitRecursive(face, 0.5, 0, 3, index)
def ArrayBetween():
def OnDynamicDraw(sender, e):
i = optBasePoint[0]
pts = []
count = optInt.CurrentValue
if i == 0: #center
basept.X = center.X
basept.Y = center.Y
if i == 1: #lowerleft
basept.X = center.X - width / 2
basept.Y = center.Y - depth / 2
if i == 2: #upperleft
basept.X = center.X - width / 2
basept.Y = center.Y + depth / 2
if i == 3: #lowerright
basept.X = center.X + width / 2
basept.Y = center.Y - depth / 2
if i == 4: #upperright
basept.X = center.X + width / 2
basept.Y = center.Y + depth / 2
vec = e.CurrentPoint - basept
gp.SetBasePoint(basept, False)
line = Rhino.Geometry.Line(basept, e.CurrentPoint)
curve = line.ToNurbsCurve()
params = curve.DivideByCount(count - 1, True)
for param in params:
pts.append(line.PointAt(param))
length = vec.Length
dist = length / (count - 1)
vec.Unitize()
for i in range(1, count):
translate = vec * i * dist
xf = Rhino.Geometry.Transform.Translation(translate)
newobj = obj.Duplicate()
newobj.Transform(xf)
if obj.ObjectType == Rhino.DocObjects.ObjectType.Curve:
e.Display.DrawCurve(newobj, Color.LightCyan, 2)
if obj.ObjectType == Rhino.DocObjects.ObjectType.Brep:
e.Display.DrawBrepWires(newobj, Color.LightCyan)
e.Display.DrawLine(line, Color.Blue, 2)
def getPoint():
while True:
result = gp.Get()
if result == Rhino.Input.GetResult.Point:
count = optInt.CurrentValue
line = Rhino.Geometry.Line(center, gp.Point())
curve = line.ToNurbsCurve()
params = curve.DivideByCount(count - 1, True)
pts = []
for param in params:
pts.append(line.PointAt(param))
vec = gp.Point() - basept
length = vec.Length
dist = length / (count - 1)
vec.Unitize()
for i in range(1, count):
translate = vec * i * dist
xf = Rhino.Geometry.Transform.Translation(translate)
newobj = obj.Duplicate()
newobj.Transform(xf)
if obj.ObjectType == Rhino.DocObjects.ObjectType.Curve:
sc.doc.Objects.AddCurve(newobj)
if obj.ObjectType == Rhino.DocObjects.ObjectType.Brep:
sc.doc.Objects.AddBrep(newobj)
sc.doc.Views.Redraw()
elif result == Rhino.Input.GetResult.Option:
optionindex = gp.Option().CurrentListOptionIndex
optBasePoint[0] = optionindex
getPoint()
break
docobj = rs.GetObject("select object to array", 28)
if rs.IsCurve(docobj):
obj = rs.coercecurve(docobj)
if rs.IsBrep(docobj):
obj = rs.coercebrep(docobj)
if not obj: return
plane = Rhino.Geometry.Plane.WorldXY
bb = obj.GetBoundingBox(plane)
if bb == None:
print "can't calculate boundingbox"
return
center = bb.Center
basept = bb.Center
minimum = bb.Min
maximum = bb.Max
center.Z = minimum.Z
width = maximum.X - minimum.X
depth = maximum.Y - minimum.Y
gp = Rhino.Input.Custom.GetPoint()
gp.SetCommandPrompt("point to array to / distance")
optInt = Rhino.Input.Custom.OptionInteger(3, 3, 999)
gp.AddOptionInteger("Count", optInt)
basepoints = [
"center", "lower_left", "upper_left", "lower_right", "upper_right"
]
gp.AddOptionList("basepoint", basepoints, 0)
optBasePoint = [0] #equal to index 0 of basepoints option
gp.DynamicDraw += OnDynamicDraw
getPoint()
def onAddRhinoObject(self, sender, e):
obj = rs.FirstObject()
isBrep = rs.IsBrep(obj)
if self.interaction_mode.auto_block and isBrep:
self.addObject(obj, 'BLOCK', 0, None)
