def cutAtPlan(level, floorNum):
planPlane = rs.AddPlaneSurface([-1000, -1000, level], 3000, 3000)
baseLayer = rs.AddLayer("60_PLANS")
newParent = rs.AddLayer("Level_" + floorNum, 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:
objName = rs.ObjectName(obj)
rs.ObjectName(tempCrv, objName)
intersectCrvs.append(tempCrv)
for crv in intersectCrvs:
if not None:
rs.ObjectLayer(crv, newChild)
#rs.SetUserText(crv, "PlanID", "PLAN")
rs.DeleteObject(planPlane)
rs.CurrentLayer(origLayer)
def get_faces(mesh, layer=None):
out = None
if layer:
objs = rs.ObjectsByLayer(layer)
selectable = []
for obj in objs:
if "face" in rs.ObjectName(obj):
selectable.append(obj)
else:
selectable = None
faces = rs.GetObjects("Select faces",
4,
group=True,
preselect=False,
select=False,
objects=selectable)
fkeys = []
if faces:
for face in faces:
if face:
name = rs.ObjectName(face)
fkey = name.split(".")[-1]
if fkey:
fkeys.append(fkey)
return fkeys
def get_edge_keys_and_param(message='Select edge.', layer=None):
if layer:
objs = rs.ObjectsByLayer(layer)
selectable = []
for obj in objs:
if "edge" in rs.ObjectName(obj):
selectable.append(obj)
else:
selectable = None
guid = rs.GetObjectEx(message, 4, False, False, selectable)
uv = None
t = None
if guid:
guid = guid[0]
name = rs.ObjectName(guid).split('.')
if 'edge' in name:
pt = rs.GetPointOnCurve(guid, "Select point on edge")
if not pt: return None, None
param = rs.CurveClosestPoint(guid, pt)
lb, ub = rs.CurveDomain(guid)
t = (param - lb) / (ub - lb)
print(lb, ub)
key = name[-1]
uv = tuple(key.split('-'))
return uv, t
def BlockLocation(object, scale):
# WARNING: The basis describes a transformation of the Rhino basis
# with respect to the Rhino basis, which might not match the
# import environment world basis.
x = rs.BlockInstanceXform(object)
p0 = [x.M00, x.M10, x.M20] # X Basis direction
p1 = [x.M01, x.M11, x.M21] # Y Basis direction
p2 = [x.M02, x.M12, x.M22] # Z Basis direction
p3 = [x.M03, x.M13, x.M23] # Origin position
# Rescale transform units
for i in range(3):
p0[i] /= scale
p1[i] /= scale
p2[i] /= scale
# Construct basis tetrahedron
placeholder = LocationMesh(p3, [p0, p1, p2])
# Unity import will render names unique with a _N suffix on the N copy
# so block name is included as a prefix to facilitate matching
# in the case that block objects names are not unique
block = rs.BlockInstanceName(object)
block_name = SafeObjectName(block)
object_name = rs.ObjectName(object)
rs.ObjectName(placeholder, block_name + "=" + object_name)
rs.ObjectLayer(placeholder, rs.ObjectLayer(object))
return placeholder
def LightLocation(light, scale):
if not rs.IsLight(light):
return
# Default light transform
# NOTE: Point light direction is [0, 0, -1]
position = rs.LightLocation(light)
direction = rs.LightDirection(light)
basis = BasisFromDirection(direction)
# Modify transform according to light type
lightType = "UnknownLight"
if rs.IsPointLight(light):
lightType = "PointLight"
#clone = rs.AddPointLight(position)
if rs.IsDirectionalLight(light):
lightType = "DirectionalLight"
#clone = rs.AddDirectionalLight(position, position + direction)
if rs.IsSpotLight(light):
lightType = "SpotLight"
outer = rs.SpotLightRadius(light)
inner = rs.SpotLightHardness(light) * outer
# Encode spot parameters in basis lengths
basis = [basis[0] * outer, basis[1] * inner, direction]
#clone = rs.AddSpotLight(position + direction, outer, position)
#rs.SpotLightHardness(clone, inner / outer)
if rs.IsRectangularLight(light):
# WARNING: Incomplete documentation for Rhino7 in RhinoScript reference:
# https://developer.rhino3d.com/api/rhinoscript/light_methods/rectangularlightplane.htm
lightType = "RectangularLight"
quadVectors, quadLengths = rs.RectangularLightPlane(light)
heightBasis = quadVectors[1] * quadLengths[0] / 2
widthBasis = quadVectors[2] * quadLengths[1] / 2
position = quadVectors[0] + heightBasis + widthBasis # center
direction = -quadVectors[3] # negative of light direction
# Encode quad dimensions in basis lengths
basis = [widthBasis, heightBasis, direction]
#corner = position - (widthBasis + heightBasis)
#clone = rs.AddRectangularLight(corner, corner + widthBasis * 2, corner + heightBasis * 2)
if rs.IsLinearLight(light):
# Encode line segment in first basis
lightType = "LinearLight"
widthBasis = direction / 2
position = position + widthBasis
basis = [widthBasis, basis[1], -basis[0]]
#clone = rs.AddLinearLight (position - widthBasis, position + widthBasis)
# Create placeholder mesh
# NOTE: light dimensions are not scaled
placeholder = LocationMesh(position, basis)
# NOTE: Lights have no corresponding exported block,
# but the same notation will be used to configure lights in the exported model.
# Unity import will render names unique with a _N suffix on the N copy
# so block name is included as a prefix to facilitate matching
# in the case that block instances names are not unique
objectName = rs.ObjectName(light)
rs.ObjectName(placeholder, lightType + "=" + objectName)
rs.ObjectLayer(placeholder, rs.ObjectLayer(light))
return placeholder
def write_strip_data(layer, point_ind):
# get all surfaces on layer
strips = rs.ObjectsByLayer(layer)
strip_ind = 1
strip_dict = {}
for strip in strips:
# get only surfaces
if rs.IsSurface(strip):
if rs.IsSurfacePlanar(strip):
strip_dict['Strip=' + layer + str(strip_ind)] = []
strip_brep = rs.coercebrep(strip)
edges = Rhino.Geometry.Brep.DuplicateEdgeCurves(strip_brep)
edge_ids = []
ind = 0
for edge in edges:
edge_id = sc.doc.Objects.AddCurve(edge)
if edge_id:
rs.ObjectName(edge_id, 'active' + str(ind))
edge_ids.append(edge_id)
ind += 1
# Get strip geometry
# change color to help find strip
rs.ObjectColor(strip, color=(255, 0, 255))
start_edge = rs.GetObject('Select start edge.', 4, False,
False, active_strip_filter)
start_length = rs.CurveLength(start_edge)
sp = rs.CurveMidPoint(start_edge)
rs.ObjectName(rs.AddPoint(sp), name='SP_' + str(point_ind))
end_edge = rs.GetObject('Select end edge.', 4, False, False,
active_strip_filter)
end_length = rs.CurveLength(end_edge)
ep = rs.CurveMidPoint(end_edge)
rs.ObjectName(rs.AddPoint(ep), name='SP_' + str(point_ind))
# Clean up
rs.DeleteObjects(edge_ids)
rs.ObjectColor(strip, color=(128, 0, 128))
# write to json
start = {
'Point': point_ind,
'GlobalX': round(sp.X, 4),
'GlobalY': round(sp.Y, 4),
'WALeft': round(start_length * 0.5, 4),
'WARight': round(start_length * 0.5, 4),
'Autowiden': 'No'
}
point_ind += 1
end = {
'Point': point_ind,
'GlobalX': round(ep.X, 4),
'GlobalY': round(ep.Y, 4),
'WBLeft': round(end_length * 0.5, 4),
'WBRight': round(end_length * 0.5, 4),
}
strip_dict['Strip=' + layer + str(strip_ind)].append(start)
strip_dict['Strip=' + layer + str(strip_ind)].append(end)
point_ind += 1
strip_ind += 1
return strip_dict
def draw_hash():
horizontals = [((10, 20, 0), (40, 20, 0)), ((10, 30, 0), (40, 30, 0))]
verticals = [((20, 10, 0), (20, 40, 0)), ((30, 10, 0), (30, 40, 0))]
for horizontal in horizontals:
guid = rs.AddLine(horizontal[0], horizontal[1])
rs.ObjectName(guid, 'h')
for vertical in verticals:
guid = rs.AddLine(vertical[0], vertical[1])
rs.ObjectName(guid, 'v')
def add_element_set(structure, guids, name):
""" Adds element set information from Rhino curve and mesh guids.
Parameters
----------
structure : obj
Structure object to update.
guids : list
Rhino curve and Rhino mesh guids.
name : str
Name of the new element set.
Returns
-------
None
Notes
-----
- Meshes representing solids must have 'solid' in their name.
"""
elements = []
for guid in guids:
if rs.IsCurve(guid):
sp = structure.check_node_exists(rs.CurveStartPoint(guid))
ep = structure.check_node_exists(rs.CurveEndPoint(guid))
element = structure.check_element_exists([sp, ep])
if element is not None:
elements.append(element)
elif rs.IsMesh(guid):
vertices = rs.MeshVertices(guid)
faces = rs.MeshFaceVertices(guid)
if rs.ObjectName(guid) and ('solid' in rs.ObjectName(guid)):
nodes = [structure.check_node_exists(i) for i in vertices]
element = structure.check_element_exists(nodes)
if element is not None:
elements.append(element)
else:
for face in faces:
nodes = [
structure.check_node_exists(vertices[i]) for i in face
]
if nodes[2] == nodes[3]:
del nodes[-1]
element = structure.check_element_exists(nodes)
if element is not None:
elements.append(element)
structure.add_set(name=name, type='element', selection=elements)
def RevertRename(name_map):
selected = SelectedObjects()
for object in selected:
new_name = rs.ObjectName(object)
if new_name in name_map:
old_name = name_map[new_name]
if old_name is None:
old_name = "" # Restores name is None state
rs.ObjectName(object, old_name)
del name_map[new_name]
def importSrfTypesFromScene(self):
data = []
srfs = rs.ObjectsByLayer('GENTYPESRF')
for f in srfs:
po = PhaseObject()
po.guid = f
po.phase = 'TYPESRF'
po.typeIndex = int(rs.ObjectName(f))
po.strTypeDescription = rs.ObjectName(f)
data.append(po)
self.data = data
def OnOKButtonClick(self, sender, e):
# remove object name to avoid deletion
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.ObjectName(generatedStair, name="www.landarchtools.com")
if generatedHandrail:
rs.ObjectName(generatedHandrail, name="www.landarchtools.com")
self.Close(True)
def select_network_face(network, message='Select face.'):
"""Select one face of a network.
Parameters:
network (compas.datastructures.network.Network): The network object.
message (str): Optional. The message to display to the user.
Default is ``"Select network edges."``
Returns:
tuple: The key of the selected face.
None: If no face was selected.
See Also:
* :func:`select_network_faces`
"""
guid = rs.GetObjects(message, preselect=True, filter=rs.filter.textdot)
if guid:
prefix = network.attributes['name']
name = rs.ObjectName(guid).split('.')
if 'face' in name:
if not prefix or prefix in name:
key = name[-1]
key = ast.literal_eval(key)
return key
return None
def select_network_vertex(network, message="Select a network vertex"):
"""Select one vertex of a network.
Parameters:
network (compas.datastructures.network.Network): The network object.
message (str): Optional. The message to display to the user.
Default is ``"Select network vertex."``
Returns:
* str: The key of the selected vertex.
* None: If no vertex was selected.
See Also:
* :func:`select_network_vertices`
"""
guid = rs.GetObject(message, preselect=True, filter=rs.filter.point | rs.filter.textdot)
if guid:
prefix = network.attributes['name']
name = rs.ObjectName(guid).split('.')
if 'vertex' in name:
if not prefix or prefix in name:
key = name[-1]
key = ast.literal_eval(key)
return key
return None
def select_mesh_faces(mesh, message='Select mesh faces.'):
"""Select faces of a mesh.
Parameters:
mesh (compas.datastructures.mesh.Mesh): The mesh object.
message (str): Optional. The message to display to the user.
Default is ``"Select mesh edges."``
Returns:
list: The keys of the selected faces.
Note:
Selection of faces is based on naming conventions.
When a mesh is drawn using the function :func:`draw_mesh`,
the curve objects representing the edges get assigned a name that
has the following pattern::
'{0}.edge.{1}-{2}'.format(mesh.attributes['name'], u, v)
Example:
.. code-block:: python
:emphasize-lines: 14
import compas
from compas.cad import rhino as compas_rhino as rhino
from compas.datastructures.mesh import Mesh
mesh = Mesh.from_obj(compas.get_data('faces.obj'))
find_mesh_faces(mesh, mesh.leaves())
compas_rhino.draw_mesh(mesh)
compas_rhino.display_mesh_face_labels(mesh)
fkeys = compas_rhino.select_mesh_faces(mesh)
print(fkeys)
See Also:
* :func:`select_mesh_vertices`
* :func:`select_mesh_edges`
"""
keys = []
guids = rs.GetObjects(message, preselect=True, filter=rs.filter.textdot)
if guids:
prefix = mesh.attributes['name']
seen = set()
for guid in guids:
name = rs.ObjectName(guid).split('.')
if 'face' in name:
if not prefix or prefix in name:
key = name[-1]
if not seen.add(key):
key = ast.literal_eval(key)
keys.append(key)
return keys
def RunCommand(is_interactive):
# Get existing props
name_Exg = getAttrs(rs.SelectedObjects(), 'Object Name')
act_Exg = getAttrs(rs.SelectedObjects(), 'Object Activ_Disc')
dialog = Dialog_WindowProperties(name_Exg, act_Exg)
rc = dialog.ShowModal(Rhino.UI.RhinoEtoApp.MainWindow)
name_New, act_New = dialog.GetUserInput()
try:
update = dialog.GetUpdateStatus()
except:
update = False
if update == True:
for eachObj in rs.SelectedObjects():
rs.SetUserText(eachObj, 'Object Name',
'%<ObjectName("{}")>%'.format(str(eachObj)))
if 'varies' not in str(name_New): rs.ObjectName(eachObj, name_New)
if 'varies' not in str(act_New):
rs.SetUserText(eachObj, 'Object Activ_Disc', str(act_New))
return 0
def add_quad(self, obj):
attr = Description(rs.ObjectName(obj))
no = attr.no
corner_numbers = []
pts = rs.SurfacePoints(obj)
for pt in pts:
n = self.add_node(Node(-1, pt, ""))
corner_numbers.append(n.no)
if (no == -1):
no = self.quads.fan
else:
l = len(self.quads.list)
for i in range(0, l):
if (attr.no == self.quads.list[i].no) and (self.current_group == self.quads.list[i].grp):
self.quads.list[i].no = self.quads.fan
q = Quad(self.current_group, no, corner_numbers, attr.prop)
self.quads.list.append(q)
self.output_quads += q.export()
self.quads.update_fan(self.current_group)
def _get_surface_rh_userText(_srfc_GUID, _ghdoc, _ghenv):
""" Takes in an objects GUID and returns the full dictionary of
Attribute UserText Key and Value pairs. Cleans up a bit as well.
Args:
_GUID: <Guid> the Rhino GUID of the surface object to try and read from
_ghdoc: The Grasshopper Component 'ghdoc' object
_ghenv: The Grasshopper Component 'ghenv' object
Returns:
output_dict: a dictionary object with all the keys / values found in the Object's UserText
"""
output_dict = {}
if not _srfc_GUID:
return output_dict
if _srfc_GUID.GetType() != System.Guid:
remark = "Unable to get the stuff dude set _srfc input type hint to guid"
_ghenv.Component.AddRuntimeMessage(ghk.GH_RuntimeMessageLevel.Remark,
remark)
return output_dict
with helpers.context_rh_doc(_ghdoc):
output_dict['Object Name'] = rs.ObjectName(_srfc_GUID)
for eachKey in rs.GetUserText(_srfc_GUID):
if 'Object Name' not in eachKey:
val = rs.GetUserText(_srfc_GUID, eachKey)
if val != 'None':
output_dict[eachKey] = val
else:
output_dict[eachKey] = None
return output_dict
def select_network_edge(network, message="Select a network edge"):
"""Select one edge of a network.
Parameters:
network (compas.datastructures.network.Network): The network object.
message (str): Optional. The message to display to the user.
Default is ``"Select network edges."``
Returns:
tuple: The key of the selected edge.
None: If no edge was selected.
See Also:
* :func:`select_network_edges`
"""
guid = rs.GetObject(message, preselect=True, filter=rs.filter.curve | rs.filter.textdot)
if guid:
prefix = network.attributes['name']
name = rs.ObjectName(guid).split('.')
if 'edge' in name:
if not prefix or prefix in name:
key = name[-1]
u, v = key.split('-')
u = ast.literal_eval(u)
v = ast.literal_eval(v)
return u, v
return None
def get_rh_obj_UserText_dict(_ghdoc, _rh_obj_guid):
""" Get any Rhino-side parameter data for the Object/Element
Note: this only works in Rhino v6.0+ I believe...
Args:
_ghdoc (ghdoc): The 'ghdoc' object from the Grasshopper document.
_rh_obj_guid (Rhino Guid): The Rhino Guid of the Object/Element.
Returns:
object_rh_UserText_dict (dict): A dictionary of all the data found
in the Rhino object's UserText library.
"""
def is_gh_guid(_guid):
"""If its GH generated geom, will have this GUID always """
return str(_guid) == '00000000-0000-0000-0000-000000000000'
if not _rh_obj_guid:
return {}
if is_gh_guid(_rh_obj_guid):
return {}
with context_rh_doc(_ghdoc):
rh_obj = Rhino.RhinoDoc.ActiveDoc.Objects.Find( _rh_obj_guid )
object_rh_UserText_dict = {k:rs.GetUserText(rh_obj, k) for k in rs.GetUserText(rh_obj)}
# Fix the name
object_name = rs.ObjectName(_rh_obj_guid)
object_rh_UserText_dict['Object Name'] = object_name
return object_rh_UserText_dict
def xdraw_mesh(vertices, faces, name=None, color=None, **kwargs):
guid = rs.AddMesh(vertices, faces)
if color:
rs.ObjectColor(guid, color)
if name:
rs.ObjectName(guid, name)
return guid
def importSrfTypesFromScene(self):
data = []
# srfs=rs.ObjectsByLayer(get_layer_name('TYPESRF'))
# for f in srfs:
# #rs.SelectObject(f)
# #rs.ObjectColor(f,(0,0,1))
# po=PhaseObject()
# po.guid=f
# po.phase='TYPESRF'
# po.typeIndex=int(rs.ObjectName(f))
# po.strTypeDescription=rs.ObjectName(f)
# self.updatePhaseObjectColor(po)
# data.append(po)
# self.data=data
# return
objs = rs.ObjectsByLayer(get_layer_name('BLOCK'))
for o in objs:
po = PhaseObject()
po.guid = o
po.phase = 'BLOCK'
name = rs.ObjectName(o)
typeIndex = 0
try:
typeIndex = int(name)
except:
pass
print(name, typeIndex)
self.setObjectType(po, typeIndex, 0)
data.append(po)
self.data = data
def xdraw_mesh(vertices, faces, color, name):
guid = rs.AddMesh(vertices, faces)
if color:
rs.ObjectColor(guid, color)
if name:
rs.ObjectName(guid, name)
return guid
def mesh_select_vertices(mesh, message="Select vertices."):
"""Select multiple vertices of a mesh.
Parameters
----------
mesh: :class:`compas.datastructures.Mesh`
message: str, optional
Returns
-------
list of int
"""
keys = []
guids = rs.GetObjects(message,
preselect=True,
filter=rs.filter.point | rs.filter.textdot)
if guids:
prefix = mesh.attributes['name']
seen = set()
for guid in guids:
name = rs.ObjectName(guid).split('.')
if 'vertex' in name:
if not prefix or prefix in name:
key = name[-1]
if not seen.add(key):
key = ast.literal_eval(key)
keys.append(key)
return keys
def __init__(self):
if constrainToAxis <> None: self.__m_constrainToAxis = constrainToAxis
if _geometry <> []:
for index, obj in enumerate(_geometry):
try:
if type(obj) == System.Guid:
if not rs.IsObject(obj):
self.warningData.append("Invalid geometry at #" +
str(index))
continue
objData = rs.ObjectName(obj) #extract data if any
geo = rc.DocObjects.ObjRef(obj).Brep()
if geo == None: geo = rc.DocObjects.ObjRef(obj).Curve()
geo.SetUserString('Data', objData)
self.__m_geometry.append(geo)
else:
obj.SetUserString('Data', " ")
self.__m_geometry.append(obj)
except:
self.warningData.append("Invalid geometry object item #" +
str(index + 1))
continue
if self.__m_geometry == []:
self.warningData.append("Missing '_geometry' input")
return
if minDist <> None: self.__m_minDist = minDist
if maxDist <> None: self.__m_maxDist = maxDist
if multipliers <> []: self.__m_globalMultiplier = multipliers
else: self.__m_globalMultiplier = [1]
self.__m_instanceMultiplierCounter = 0
def network_select_edges(network, message="Select edges."):
"""Select multiple edges of a network.
Parameters
----------
network: :class:`compas.datastructures.Network`
message: str, optional
Returns
-------
list of tuple of hashable
"""
keys = []
guids = rs.GetObjects(message,
preselect=True,
filter=rs.filter.curve | rs.filter.textdot)
if guids:
prefix = network.attributes['name']
seen = set()
for guid in guids:
name = rs.ObjectName(guid).split('.')
if 'edge' in name:
if not prefix or prefix in name:
key = name[-1]
if not seen.add(key):
u, v = key.split('-')
u = ast.literal_eval(u)
v = ast.literal_eval(v)
keys.append((u, v))
return keys
def network_select_edge(network, message="Select an edge."):
"""Select a single edge of a network.
Parameters
----------
network: :class:`compas.datastructures.Network`
message: str, optional
Returns
-------
tuple of hashable, or None
"""
guid = rs.GetObject(message,
preselect=True,
filter=rs.filter.curve | rs.filter.textdot)
if guid:
prefix = network.attributes['name']
name = rs.ObjectName(guid).split('.')
if 'edge' in name:
if not prefix or prefix in name:
key = name[-1]
u, v = key.split('-')
u = ast.literal_eval(u)
v = ast.literal_eval(v)
return u, v
return None
def exportToSvg(x, state='init'):
points = flipY(rs.CurveEditPoints(x))
parsed = [parse(i) + "\n" for i in points]
parsed[-1] = parsed[-1][:-2]
parsed = "".join(parsed)
with open("{}{}.svg".format(state, rs.ObjectName(x)), "w") as f:
f.write(header.format(minPoint(points), maxPoint(points), parsed))
def RunCommand(is_interactive):
"""Interactive Rhino Command Creates 90 Lap joint on a seleceted Beam
Return:
------
None
"""
#load Derivation and model
derivation = Derivation.from_json(rhino_UI_utilities.get_json_file_location())
model = derivation.get_next_step()
#Select mesh
Obj_ref = rs.GetObject(message = "select mesh(es)", filter = 32, preselect = False, subobjects = True)
selected_beam_name = (rs.ObjectName(Obj_ref)[:-5])
#Loop through all beams in model to identify the selected beam
selected_beam = None
for beam in model.beams:
if(beam.name == selected_beam_name):
selected_beam = beam
break
assert (selected_beam != None)
#list of user inputs(face needs to be implemented through UI)
face_id = rs.GetInteger("face_id",None,0,5)
helper = UI_helpers()
joint_point = helper.Get_SelectPointOnMeshEdge("Select mesh edge","Pick point on edge")
ext_start = rs.GetReal("extension start ",200,None,None)
ext_end = rs.GetReal("extension end ",200,None,None)
name = create_id()
#adding joints to selected Beam
#joint_distance_from_start = Get_distancefromBeamYZFrame(selected_beam,joint_point)
joint_distance_from_start = selected_beam.Get_distancefromBeamYZFrame(joint_point)
match_beam_origin = model.rule_90lap(selected_beam,joint_distance_from_start,face_id,ext_start,ext_end,name)
#Save Derivation (Model is also saved)
derivation.to_json(rhino_UI_utilities.get_json_file_location(), pretty = True)
#Visualization
viz_point = []
for pt in match_beam_origin:
a = (pt[0],pt[1],pt[2])
viz_point.append({
'pos': a,
'color': (0,255,0)
})
#Visualization
artist = MeshArtist(None, layer ='BEAM::Beams_out')
artist.clear_layer()
artist.draw_points(viz_point)
for beam in model.beams:
artist = MeshArtist(beam.mesh, layer ='BEAM::Beams_out')#.mesh is not ideal fix in beam and assemble class
artist.draw_faces(join_faces=True)
def add_mesh_to_rhino(self):
self.remove_rhino_objects()
if self.is_terminal_step():
for shape in self.post_execution_shapes:
mesh = shape.representations['mesh']
guid = Rhino.RhinoDoc.ActiveDoc.Objects.AddMesh(mesh)
self.added_rhino_objects.append(guid)
rs.ObjectName(guid, shape.name)
def RunCommand(is_interactive):
# First, get any properties of the existing object(s)
tfa_Exg = getAttrs(rs.SelectedObjects(), 'TFA_Factor', _defaultVal=1)
name_Exg = getAttrs(rs.SelectedObjects(), 'Object Name', _defaultVal=None)
number_Exg = getAttrs(rs.SelectedObjects(),
'Room_Number',
_defaultVal=None)
v_sup_Exg = getAttrs(rs.SelectedObjects(), 'V_sup', _defaultVal=0)
v_eta_Exg = getAttrs(rs.SelectedObjects(), 'V_eta', _defaultVal=0)
v_trans_Exg = getAttrs(rs.SelectedObjects(), 'V_trans', _defaultVal=0)
use_Exg = getAttrs(rs.SelectedObjects(), 'useType', _defaultVal='-')
lighting_Exg = getAttrs(rs.SelectedObjects(), 'lighting', _defaultVal='-')
motion_Exg = getAttrs(rs.SelectedObjects(), 'motion', _defaultVal='-')
# Call the Dialog Window
dialog = Dialog_WindowProperties(tfa_Exg, name_Exg, number_Exg, v_sup_Exg,
v_eta_Exg, v_trans_Exg, use_Exg,
lighting_Exg, motion_Exg)
rc = dialog.ShowModal(Rhino.UI.RhinoEtoApp.MainWindow)
number_New, name_New, tfa_New, vSup, vEta, vTrans, use, lighting, motion = dialog.GetUserInput(
)
try:
update = dialog.GetUpdateStatus() #True if 'OK', False if 'Cancel'
except:
update = False # on any error with the user input
# Apply the User Inputs to the Object's Attributes if Update==True
if update == True:
for eachObj in rs.SelectedObjects():
# Sort out the name
rs.SetUserText(
eachObj, 'Object Name',
'%<ObjectName("{}")>%'.format(str(eachObj))
) # Formula to auto-set the obj's name in Attribute Inspector
if 'varies' not in str(name_New): rs.ObjectName(eachObj, name_New)
# Set the rest of the Surface Attributes
if use != '<varies>': rs.SetUserText(eachObj, 'useType', use)
if lighting != '<varies>':
rs.SetUserText(eachObj, 'lighting', lighting)
if motion != '<varies>': rs.SetUserText(eachObj, 'motion', motion)
if number_New != '<varies>':
rs.SetUserText(eachObj, 'Room_Number', number_New)
if str(tfa_New) != '<varies>':
rs.SetUserText(eachObj, 'TFA_Factor', str(tfa_New))
if str(vSup) != '<varies>':
rs.SetUserText(eachObj, 'V_sup', str(vSup))
if str(vEta) != '<varies>':
rs.SetUserText(eachObj, 'V_eta', str(vEta))
if str(vTrans) != '<varies>':
rs.SetUserText(eachObj, 'V_trans', str(vTrans))
return 0
# temp for debuggin in editor
#RunCommand(True)
