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 layerSet(text, color):
#deletes existing information regarding this layer
if rs.LayerId(text):
rs.DeleteObjects(rs.ObjectsByLayer(text))
rs.PurgeLayer(text)
#recomputes layer as new layer
rs.AddLayer(text, color)
def delete_layers(layers):
"""Delete layers and all contained objects.
Parameters
----------
layers : :obj:`dict` or :obj:`list` of :obj:`str`
Can be given as either a list of strings or as a dictionary.
When given as a list the list elements should be name of layers given
with ``"::"`` as a separator between hierarchies.
It can also be defined as a dictionary of layers with the keys
representing layer names, and the values also dictionaries defining
optional nested layers.
Examples
--------
.. code-block:: python
layers = {'COMPAS': {'layers': {'Datastructures': {'layers': {'Mesh': {}, 'Network': {}}}}}}
create_layers(layers)
delete_layers(['COMPAS::Datastructures::Network'])
delete_layers({'COMPAS': {'layers': {'Datastructures': {'layers': {'Mesh': {}}}}}})
"""
to_delete = []
def recurse(layers, parent=None):
for name in layers:
if not name:
continue
fullname = name
if parent:
fullname = parent + '::' + name
try:
attr = layers[name]
except TypeError:
attr = {}
if 'layers' in attr:
recurse(attr['layers'], fullname)
to_delete.append(fullname)
rs.EnableRedraw(False)
recurse(layers)
for layer in to_delete:
if rs.IsLayer(layer):
if rs.IsLayerCurrent(layer):
print(
"Can't delete {} as it is the current layer".format(layer))
continue
rs.PurgeLayer(layer)
rs.EnableRedraw(True)
def RestoreWorldCoordinate():
try:
rs.EnableRedraw(False)
# retreive northing and easting from text object
obj = rs.ObjectsByName("_ORIGIN_TEXT_")
if obj:
text = rs.TextObjectText(obj)
textList = text.split()
easting = float(textList[1])
northing = float(textList[3])
# create reference coordinates to make vector
orPoint = (easting, northing, 0)
point = rs.PointCoordinates(rs.ObjectsByName("_ORIGIN_POINT_"))
vector = rs.VectorCreate(orPoint, point)
# move all objects back to original origin point
allObj = rs.AllObjects()
rs.MoveObjects(allObj, vector)
# delete coordinate geometry
isCurrent = rs.IsLayerCurrent("_ORIGIN_")
if isCurrent == False:
rs.PurgeLayer("_ORIGIN_")
if isCurrent == True:
defaultCheck = rs.IsLayer("Default")
if defaultCheck == True:
rs.CurrentLayer("Default")
rs.PurgeLayer("_ORIGIN_")
if defaultCheck == False:
rs.AddLayer("Default")
rs.CurrentLayer("Default")
rs.PurgeLayer("_ORIGIN_")
rs.EnableRedraw(True)
except:
print("Failed to execute")
rs.EnableRedraw(True)
return
def bake_layer(from_layer, to_layer, options):
default_rotation = options[KEY_ROT]
scale = options['scale']
draw_order = options['drawOrder']
pattern = options['pattern']
target_layer_index = sc.doc.Layers.FindByFullPath(to_layer, True)
pattern_index = sc.doc.HatchPatterns.Find(pattern, True)
if pattern_index < 0:
print('Hatch pattern %s does not exist' % pattern)
return
source_objects = find_layer_objects(is_match_for_hatch_source, from_layer)
if len(source_objects) == 0:
print('Layer %s has no objects to bake' % from_layer)
return
normalize_objects(source_objects)
custom_hatch_objects = get_modified_hatches(to_layer, options)
for h in custom_hatch_objects:
save_hatch_options(h, options)
rs.PurgeLayer(to_layer)
curves = [x.Geometry for x in source_objects]
tolerance = sc.doc.ModelAbsoluteTolerance
hatches = Rhino.Geometry.Hatch.Create(curves, pattern_index,
default_rotation, scale, tolerance)
proxies = [HatchProxy(x) for x in hatches]
# bind main curve to created hatch
for obj in source_objects:
obj_bb = obj.Geometry.GetBoundingBox(True)
hp = find_by_bounding_box(proxies, obj_bb)
if not hp:
continue
hp.set_origin(obj)
# Add created hatches to rhino doc + set attributes
for hp in proxies:
hp.apply_options(defaults=options)
hatch = hp.hatch
hatch_guid = sc.doc.Objects.AddHatch(hatch)
hatch_obj = sc.doc.Objects.Find(hatch_guid)
# save origin curve in hatch user text
if hp.has_origin():
rs.SetUserText(hatch_obj, KEY_ORIGIN, hp.origin.Id)
hatch_obj.Attributes.LayerIndex = target_layer_index
hatch_obj.Attributes.DisplayOrder = draw_order
hatch_obj.CommitChanges()
def RunCommand(is_interactive):
config = get_sisufile()
if not config:
print('Sisufile not configured')
return Rhino.Commands.Result.Failure
layers = get_related_layers(config, derived_only=True)
for layer in layers:
if rs.IsLayerCurrent(layer):
parent = rs.ParentLayer(layer)
rs.CurrentLayer(parent)
rs.PurgeLayer(layer)
return Rhino.Commands.Result.Success
def Reset():
print("■start reset■")
sc.doc = Rhino.RhinoDoc.ActiveDoc
rs.PurgeLayer("Make2D")
sc.doc = ghdoc
rs.Command("_CPlane " + "_W " + "_T ")
rs.Command("_Setview " + "_W " + "_P ")
rs.Command("_SelLight")
rs.Command("_SelPt")
rs.Command("_SelCrv")
rs.Command("_Invert")
rs.Command("_Zoom " + "_S ")
rs.Command("_SelNone")
print("■end reset■")
def PurgeAll():
'''
Delete all objects within document
'''
rs.CurrentLayer('Default')
for layer in rs.LayerNames():
if rs.IsLayer(layer) and layer != 'Default':
rs.PurgeLayer(layer)
objs = []
objTable = doc.Objects
for obj in objTable.GetObjectList(Rhino.DocObjects.ObjectType.AnyObject):
objs.append(obj.Id)
for guid in objs:
objTable.Delete(guid, True)
def show(pts):
if rs.IsLayer('Points'):
rs.PurgeLayer('Points')
colors = [pt['color'] for pt in pts]
d_max = sorted(colors)[-1]
for pt in pts:
color = remap(pt['color'], (0, d_max), (0, 255))
rs.AddLayer('Points')
pos = pt['pos']
guid = add_point(Point3d(*pos))
obj = find_object(guid)
attr = obj.Attributes
attr.ObjectColor = FromArgb(color, color, color)
attr.ColorSource = ColorFromObject
index = find_layer_by_fullpath('Points', True)
if index >= 0:
attr.LayerIndex = index
obj.CommitChanges()
##########################################################################################################################################
# set scriptcontext.doc to Rhino.ActiveDoc
sc.doc = rh.RhinoDoc.ActiveDoc
# 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)
##########################################################################################################################################
# set current working dir
os.chdir(working_dir_path)
def lengqiuta():
# (x/a)**2-(z - zz[3] / b)**2=1
a = 46000
b = 110269
# no.4 is the neck, that is [3]
# z space
z = [26212, 21259, 17815, 15649, 13900, 12725, 11911, 11386, 11103, 11040, 11192, 11572]
# segment
n = 32
# get z coordinate
zz = []
for i in range(len(z)):
zz.append(sum(z[i:len(z)]))
zz.append(0)
# get x coordinate
x = []
for i in range(len(zz)):
x1 = a * math.sqrt(1 + ((zz[i] - zz[3]) / b) **2)
x.append(x1)
rs.CurrentView("top")
# add guide circle and points
rs.AddLayer("guide")
rs.CurrentLayer("guide")
epts = []
opts = []
ptss = []
for i in range(len(zz)):
if (i % 2) == 1:
# even number circle: 0 2 4 6 8 10 12
cir = rs.AddCircle([0, 0, zz[i]], x[i])
epts = rs.DivideCurve(cir, 2 * n)
for j in range(len(epts)):
if (j % 2) == 0:
ptss.append(list(epts[j]))
elif (i % 2) == 0:
# odd number circle: 1 3 5 7 9 11
cir = rs.AddCircle([0, 0, zz[i]], x[i])
opts = rs.DivideCurve(cir, 2 * n)
for j in range(len(opts)):
if (j % 2) == 1:
ptss.append(list(opts[j]))
# vertical members
rs.AddLayer("hbar", (0, 255 ,0))
rs.CurrentLayer("hbar")
i = 0
while (i < (len(zz) * n)):
if i in range((n - 1), len(zz) * n, n):
rs.AddLine(ptss[i], ptss[i - n + 1])
else:
rs.AddLine(ptss[i], ptss[i + 1])
i = i + 1
# vertical members
rs.AddLayer("vbar", (0, 0, 255))
rs.CurrentLayer("vbar")
for i in range(n):
for j in range(0, (len(zz) - 1), 2): #0, 2, 4, 6, 8, 10, 12
t = n * j + i
rs.AddLine(ptss[t], ptss [t + n])
if t == (n * (j + 1) - 1):
rs.AddLine(ptss[t], ptss[t + 1])
else:
rs.AddLine(ptss[t], ptss[t + n + 1])
for i in range(n):
for j in range(1, (len(zz)), 2): #1, 3, 5, 7, 9, 11
t = n * j + i
rs.AddLine(ptss[t], ptss[t + n])
if t == n * j:
rs.AddLine(ptss[t], ptss[t + 2 * n - 1])
else:
rs.AddLine(ptss[t], ptss[t + n - 1])
# add plane
rs.AddLayer("plane", (255, 0, 0))
rs.CurrentLayer("plane")
for j in range(0, len(zz) - 1, 2):
for i in range(j * n, j * n + n - 1, 1):
rs.AddSrfPt([(ptss[i + 1]), (ptss[i]), (ptss[n + i + 1])])
rs.AddSrfPt([(ptss[j * n]), (ptss[j * n + n - 1]), (ptss[j * n + n])])
for j in range(0, len(zz) - 1, 2):
for i in range(j * n + n, j * n + 2 * n - 1, 1):
rs.AddSrfPt([(ptss[i]), (ptss[i + 1]), (ptss[i - n])])
rs.AddSrfPt([(ptss[j * n + 2 * n - 1]), (ptss[j * n + n]), (ptss[j * n + n - 1])])
for j in range(0, len(zz) - 1, 2):
for i in range(j * n + 2 * n, j * n + 3 * n -1, 1):
rs.AddSrfPt([(ptss[i]), (ptss[i + 1]), (ptss[i - n + 1])])
rs.AddSrfPt([(ptss[j * n + 3 * n -1]), (ptss[j * n + 2 * n]), (ptss[j * n + n])])
for j in range(0, len(zz) - 1, 2):
for i in range(j * n + n, j * n + 2 * n - 1, 1):
rs.AddSrfPt([(ptss[i + 1]), (ptss[i]), (ptss[i + n])])
rs.AddSrfPt([(ptss[j * n + n]), (ptss[j * n + 2 * n -1]), (ptss[j * n + 3 * n - 1])])
# delete guide layer
rs.PurgeLayer("guide")
def flush_data(self):
print 'Adding polylines to CAD environment ... wait'
_FILE = self.corePath + r'\Mesh.gcode'
pl = [] # polyline list
pc = [] # pointcloud list
poly_fail = 0
_add_point_cloud = False
_z_level_change = False
first_z_move_in_layer = True
# it is possible to define a layer range that is displayed in CAD
# default is layer 1 to end -> [1, -1]
layer_start = 0
layer_end = -1
_from_to_layer = [layer_start, layer_end]
_layer = 1
LayerPoints = {}
line_in_file = 0
end_of_file = False
# check if a previous calculation exists
if rs.IsLayer('MW 3D Printer PointCloud'):
if rs.IsLayer('MW 3D Printer PointCloud_OLD'):
rs.PurgeLayer('MW 3D Printer PointCloud_OLD')
rs.RenameLayer('MW 3D Printer PointCloud',
'MW 3D Printer PointCloud_OLD')
rs.LayerVisible('MW 3D Printer PointCloud_OLD', visible=False)
else:
rs.RenameLayer('MW 3D Printer PointCloud',
'MW 3D Printer PointCloud_OLD')
rs.LayerVisible('MW 3D Printer PointCloud_OLD', visible=False)
rs.AddLayer(name='MW 3D Printer PointCloud', visible=False)
else:
rs.AddLayer(name='MW 3D Printer PointCloud', visible=False)
if rs.IsLayer('MW 3D Printer Perimeter'):
if rs.IsLayer('MW 3D Printer Perimeter_OLD'):
rs.PurgeLayer('MW 3D Printer Perimeter_OLD')
rs.RenameLayer('MW 3D Printer Perimeter',
'MW 3D Printer Perimeter_OLD')
rs.LayerVisible('MW 3D Printer Perimeter_OLD', visible=False)
else:
rs.RenameLayer('MW 3D Printer Perimeter',
'MW 3D Printer Perimeter_OLD')
rs.LayerVisible('MW 3D Printer Perimeter_OLD', visible=False)
rs.AddLayer(name='MW 3D Printer Perimeter', visible=True)
else:
rs.AddLayer(name='MW 3D Printer Perimeter', visible=True)
# open G-Code
fid = open(_FILE, 'r')
# Begin G-Code processing
last_pos = []
last_pos.append(fid.tell())
for line in fid:
last_pos.append(fid.tell())
line_in_file += 1
if len(line) == 1:
continue
if self.runstat: # external functions can inject a command to stop threading
# proof if there is a comment with layer information
if line.strip()[0] == ';':
if line.find('gCode file finished') != -1:
end_of_file = True
if line.find(
'WARNING') == -1: # if we do NOT find a WARNING
split_line = line.split(',')
_segment = split_line[0][1:].strip().rstrip()
_backplot_width = split_line[0][1:].strip().rstrip()
if _segment not in self.segmentIdxDict:
self.segmentIdxDict[_segment] = 0
segment = _segment + str(self.segmentIdxDict[_segment])
else:
pass
# print 'WARNING'
# coordinates of G1 and G0 moves are processed
if line[0:3] == 'G1 ' or line[0:3] == 'G0 ':
# filter z coordinates and proof if its the first inital or the next layer
pos_Z = line.find('Z')
if pos_Z != -1:
pos_ws = line[pos_Z:].find(' ')
if pos_ws == -1:
Z = float(line[pos_Z + 1:])
else:
try:
Z = float(line[pos_Z + 1:pos_ws + pos_Z + 1])
except:
Z = float(line[pos_Z + 1:pos_ws + pos_Z + 1])
if first_z_move_in_layer:
first_z_move_in_layer = False
else:
_z_level_change = True
fid.seek(last_pos[-3]) # revert file position
last_pos.pop()
last_pos.pop()
last_pos.pop()
line_in_file = line_in_file - 2
if not _z_level_change:
# filter coordinates from G1 move
if line[0:3] == 'G1 ':
pos_X = line.find('X')
if pos_X != -1:
pos_ws = line[pos_X:].find(' ')
X = float(line[pos_X + 1:pos_ws + pos_X + 1])
pos_Y = line.find('Y')
if pos_Y != -1:
pos_ws = line[pos_Y:].find(' ')
if pos_ws == -1:
Y = float(line[pos_Y + 1:])
else:
Y = float(line[pos_Y + 1:pos_ws + pos_Y +
1])
# filter coordinates from G0 move
elif line[0:3] == 'G0 ':
pos_X = line.find('X')
if pos_X != -1:
pos_ws = line[pos_X:].find(' ')
X_G0 = float(line[pos_X + 1:pos_ws + pos_X +
1])
pos_Y = line.find('Y')
if pos_Y != -1:
pos_ws = line[pos_Y:].find(' ')
if pos_ws == -1:
Y_G0 = float(line[pos_Y + 1:])
else:
Y_G0 = float(line[pos_Y + 1:pos_ws +
pos_Y + 1])
# add coordinates to layer dictionary
if _layer >= _from_to_layer[0]:
if line[0:3] == 'G0 ':
if _segment in self.segmentIdxDict:
self.segmentIdxDict[_segment] += 1
else:
self.segmentIdxDict[_segment] = 0
segment = _segment + str(
self.segmentIdxDict[_segment])
LayerPoints[segment] = [[
X_G0, Y_G0, Z
]] # first point of next segment
else:
if len(LayerPoints) == 0:
LayerPoints[segment] = [[X, Y, Z]]
else:
if segment in LayerPoints:
LayerPoints[segment].append([X, Y, Z])
# add lines and points to Rhino environment
if _z_level_change and self.runstat or end_of_file:
try:
if _layer >= _from_to_layer[0]:
if len(LayerPoints) > 1:
for segment, points in LayerPoints.iteritems():
if self.runstat:
if len(points) > 1:
try:
# .NET
try:
int(segment[-1])
lenIdx = 1
int(segment[-2:])
lenIdx = 2
int(segment[-3:])
lenIdx = 3
int(segment[-4:])
lenIdx = 4
except:
pass
if segment[:
-lenIdx] in self.colorDict:
pl.append(
AddPolyline(
points,
_layer,
objColor=self.
colorDict[
segment[:
-lenIdx]],
segment=segment))
else:
pl.append(
AddPolyline(
points,
_layer,
objColor=(255, 0,
0),
segment=segment))
# print 'Segment not found'
# add point cloud
if _add_point_cloud:
pc.append(
rs.AddPointCloud(
points))
except:
raise
poly_fail += 1
LayerPoints = {} # clear point information from dict
self.segmentIdxDict = {} # clear segment counter dict
_z_level_change = False
_layer += 1
first_z_move_in_layer = True
except:
raise
pass
if _from_to_layer[1] != -1:
if _layer == _from_to_layer[1]:
break
scriptcontext.doc.Views.Redraw()
# rs.ObjectLayer(pl, layer='MW 3D Printer Perimeter')
print 'Flushing path data finished.'
print 'Polylines ignored: ' + str(poly_fail)
def CreateBoundary(self, box_side_length):
"""
creates some extened boundaries to check for out of bounds fractures.
An auxilliary method to trim extruding fractures.
Parameters
----------
box_side_length: str
the domain length
Raises
------
ValueError
if the box length is not > 0.
"""
try:
if box_side_length <= 0:
raise ValueError
except ValueError:
print("CreateBoundary(): The box side length should be\
greater than 0")
else:
# Put boundary layers in a new layer
boundary_layer_name = "Boundaries"
# To make sure we do not overwrite existing boundary surfaces,
# delete the old layer if it is there
# To avoid error messages about deleting current layers:
rs.AddLayer('Blank Layer')
rs.CurrentLayer('Blank Layer')
if rs.IsLayer(boundary_layer_name):
rs.PurgeLayer(boundary_layer_name) # Deletes layer
rs.AddLayer(boundary_layer_name)
rs.CurrentLayer(boundary_layer_name)
rs.LayerColor(boundary_layer_name, [0, 0, 0])
L = box_side_length
# L = distance from 0 to corner along each axis
# Make corner points on boundaries
# Delete them later
bps = []
bps.append(rs.AddPoint((0, 0, 0))) # p0
bps.append(rs.AddPoint((L, 0, 0))) # p1
bps.append(rs.AddPoint((L, L, 0))) # p2
bps.append(rs.AddPoint((0, L, 0))) # p3
bps.append(rs.AddPoint((L, 0, L))) # p4
bps.append(rs.AddPoint((L, L, L))) # p5
bps.append(rs.AddPoint((0, L, L))) # p6
bps.append(rs.AddPoint((0, 0, L))) # p7
# Make surfaces which are the boundaries
bsurfs = []
bsurfs.append(rs.AddSrfPt([bps[0], bps[1], bps[2], bps[3]])) # s0
bsurfs.append(rs.AddSrfPt([bps[4], bps[5], bps[6], bps[7]])) # s1
bsurfs.append(rs.AddSrfPt([bps[0], bps[1], bps[4], bps[7]])) # s2
bsurfs.append(rs.AddSrfPt([bps[1], bps[2], bps[5], bps[4]])) # s3
bsurfs.append(rs.AddSrfPt([bps[2], bps[3], bps[6], bps[5]])) # s4
bsurfs.append(rs.AddSrfPt([bps[3], bps[0], bps[7], bps[6]])) # s5
# Remove points as they are not needed
rs.DeleteObjects(bps)
# Return these boundaries for use elsewhere
return bsurfs
' _Width=' + str(img_wid) + ' _Height=' + str(img_hei) +
' _Scale=' + str(img_sca) + ' _TransparentBackground=No' +
' _Enter' + ' _Enter')
#Prepare the environment for the next iteration
pla_pos[1] = pla_pos[1] - vis_ste
rs.ShowObjects(obj_all)
rs.DeleteObjects(pla_obj)
sec_cur = rs.ObjectsByType(4)
rs.DeleteObjects(sec_cur)
if 'Default' in lay_lis:
rs.CurrentLayer(layer='Default')
else:
rs.AddLayer(name='Default')
rs.CurrentLayer(layer='Default')
#Leave the rest of the layers as they were at start
rs.CurrentLayer(lay_act)
for i in lay_vis:
rs.LayerVisible(i, visible=True)
#Purge the environment
rs.PurgeLayer('lay_axo_sec')
rs.PurgeLayer('lay_axo_pla')
rs.PurgeLayer('lay_fro_sec')
rs.PurgeLayer('lay_fro_pla')
rs.PurgeLayer('lay_wor')
print('\n Section views ready! \n')
def RemoveSurfacesOutsideOfBox(self, b_length):
"""
Main method which calls all auxilliary functions to trim out of bounds
fractures.
Parameter
--------
b_length: float
length of domain/boundary
Raises
------
ValueError
if boundary length is less than zero.
"""
try:
if b_length <= 0:
raise ValueError
except ValueError:
print("Value of boundary should be greater than 0")
else:
# Create boundary surfaces
boundaries = self.CreateBoundary(b_length)
# Get all layers in the document
all_layers = rs.LayerNames()
# To avoid error messages about deleting current layers:
# make a blank layer
rs.AddLayer('Blank Layer')
rs.CurrentLayer('Blank Layer')
# Make a layer for intersecting fractures
boundary_intersection_layer = "Boundary_Intersections"
if rs.IsLayer(boundary_intersection_layer):
rs.PurgeLayer(boundary_intersection_layer) # Deletes layer
# make boundary_intersection_layer the current layer
rs.AddLayer(boundary_intersection_layer)
rs.CurrentLayer(boundary_intersection_layer)
rs.LayerColor(boundary_intersection_layer, [200, 0, 0])
# Make a polysurface of all the boundaries
# This polysurf can be used with SplitBrep
# If you compare surfaces individually, then fractures which
# intersect more than one surface (i.e. corners)
# do not get split correctly.
box = rs.JoinSurfaces(boundaries)
all_surfaces = []
# Go over all the layers to find fractures
for layer in all_layers:
# Only act if layer is a fracture layer
# Some layers have short names, so ask for 1st
# letter first, then rest
if layer[0] == 'F':
if layer[0:8] == 'FRACTURE':
# Get surfaces in this layer
surfs = self.GetSurfaceFromFractureLayer(layer)
for surf in surfs: # BUT SURFS IS JUST A GUID
all_surfaces.append(surf)
all_new_surfaces = [] # Store the split surfaces of the fractures
# print "Number of surfaces examined for splitting: ",
# len(all_surfaces)
for surf in all_surfaces:
# Run intersection test
boundaries_touched = 0
# for boundary in boundaries:
# Use splitbrep here to split the fracture
# surfaces by the boundaries directly
# Brings back a polysurf which must be converted into a surface
new_polysurfs = rs.SplitBrep(surf, box)
if type(new_polysurfs) == list:
boundaries_touched += 1
for polysurf in new_polysurfs:
# Because sometimes there are multiple surfaces
new_surfs = self.ConvertPolysurfaceToSurface(polysurf)
for new_surfs_i in new_surfs[1]:
all_new_surfaces.append(new_surfs_i)
# append to domain fracture list
self.my_fractures.append(new_surfs_i)
if boundaries_touched == 0:
# This means the fracture didn't intersect a boundary
# Add it to the list as well, so the final layer
# has all the fracs
copied_surf = rs.CopyObject(surf)
rs.ObjectLayer(copied_surf, boundary_intersection_layer)
# ARE WE APPENDING THE FRAC OUTSIDE OR INSIDE
all_new_surfaces.append(copied_surf)
# append to domain fracture list
self.my_fractures.append(copied_surf)
# print "Number of surfaces after splitting: ",
# len(all_new_surfaces)
# Make extended boundary surfaces to check
ext_boundaries = self.CreateSetOfExtendedBoundaries(
boundaries, b_length)
# Now, remove any surfaces which aren't inside the volume
for surf in all_new_surfaces:
self.RemoveSurfacesIfAnyIntersectBoundary(surf, ext_boundaries)
# We don't need the extra boundaries anymore
for boundary in ext_boundaries:
rs.DeleteObject(boundary)
for boundary in boundaries:
rs.DeleteObject(boundary)
rs.DeleteObject(box)
return
def clear_layers():
rs.CurrentLayer('Default')
rs.PurgeLayer('left')
rs.PurgeLayer('right')
rs.PurgeLayer('infrastructure')
def wangqiao():
l = 8000
f = 2000
m = 5
n = 12
# circle center and radius
xn = l / (2 * m)
r = (f**2 + (l / 2)**2) / (2 * f)
ctrs = []
rads = []
# from top circle to devide circle
for i in range(m):
x = xn * (i + 1)
z = math.sqrt(r**2 - x**2) - (r - f)
ctrs.append([0, 0, z])
rads.append(x)
# create guide circle
pts = []
ptss = []
rs.CurrentView("top")
rs.AddLayer("guide")
rs.CurrentLayer("guide")
for i in range(m):
cir = rs.AddCircle(ctrs[i], rads[i])
pts = rs.DivideCurve(cir, n)
ptss.append(pts)
# vertical direction
rs.AddLayer("hdir", (0, 255, 0))
rs.CurrentLayer("hdir")
toppt = [0, 0, f]
for i in range(n):
rs.AddLine(toppt, ptss[0][i])
for i in range(m - 1):
for j in range(n):
rs.AddLine(ptss[i][j], ptss[i + 1][j])
# horizonal direction
rs.AddLayer("vdir", (0, 0, 255))
rs.CurrentLayer("vdir")
for i in range(m):
for j in range(n - 1):
rs.AddLine(ptss[i][j], ptss[i][j + 1])
rs.AddLine(ptss[i][n - 1], ptss[i][0])
# add shell
rs.AddLayer("plane", (255, 0, 0))
rs.CurrentLayer("plane")
for i in range(n - 1):
rs.AddSrfPt([(ptss[0][i]), (ptss[0][i + 1]), (0, 0, f)])
rs.AddSrfPt([(ptss[0][n - 1]), (ptss[0][0]), (0, 0, f)])
for i in range(m - 1):
for j in range(n - 1):
rs.AddSrfPt([(ptss[i][j]), (ptss[i + 1][j]), (ptss[i + 1][j + 1]),
(ptss[i][j + 1])])
rs.AddSrfPt([(ptss[i][n - 1]), (ptss[i + 1][n - 1]), (ptss[i + 1][0]),
(ptss[i][0])])
# delete guide layer
rs.PurgeLayer("guide")
import rhinoscriptsyntax as rs
#delete empty layers(simple clean up code)
count = rs.LayerCount()
layerNames = rs.LayerNames()
for i in range(count):
if rs.IsLayerEmpty(layerNames[i]):
rs.PurgeLayer(layerNames[i])
else:
print "The layer" + layerNames[i] + "is not empty."
def main():
# create globally used array of copies
copies = []
biesse_layers = []
# promt convert for biesse
items = (
['convert_to_biesse_layers', 'no', 'yes'],
['export_clamex_txt', 'no', 'yes'],
['open_after_export', 'no', 'yes'],
)
default_values = getDefaultValues()
options = rs.GetBoolean("conversion options", items, default_values)
if not options or len(options) < 2:
print "checkAndExport aborted"
return
convert_for_biesse = options[0]
export_clamex_txt = options[1]
open_after_export = options[2]
storeDefaultValues(convert_for_biesse, export_clamex_txt,
open_after_export)
# get objects to export
objs = rs.GetObjects("select objects to export", 0, True, True)
if not objs:
print "checkAndExport aborted"
return
rs.EnableRedraw(False)
# create copies of all block contents
copies = rs.CopyObjects(objs)
# explodeblock
copies = explodeBlock(copies)
copies = explodeTextObjects(copies)
# filter objects to only curves and textobjects
copies = filterObjects(copies)
# check curves for deviation from c-plane
if checkCurvePosition(copies):
clamexdata = None
if export_clamex_txt:
clamexdata = extractClamexOrientation(copies)
# obj properties are lost here
copies = joinCurves(copies)
simplify(copies)
if checkCurveIntegrity(copies):
# rs.UnselectAllObjects()
# check curve dir
if not setCurveDir(copies):
print "checkAndExport aborted"
return
#get left bottom
rs.EnableRedraw(True)
selection_origin = rs.GetPoint("Pick export base point")
rs.EnableRedraw(False)
# move to origin
result = moveToOrigin(copies, selection_origin)
if convert_for_biesse:
biesse_layers = convertLayers(copies)
if result:
# export
rs.SelectObjects(copies)
redraw()
filename = rs.SaveFileName("Save", "dxf Files (*.dxf)|*.dxf||")
if filename:
result = rs.Command('! _-Export "' + filename + '" _Enter',
False)
if open_after_export:
if os.path.isfile(
'C:\Program Files\Rhinoceros 5 (64-bit)\System\Rhino.exe'
):
print(
'"C:\Program Files\Rhinoceros 5 (64-bit)\System\Rhino.exe" /nosplash /runscript="_-open ""'
+ filename + '"" _Enter"')
Popen(
'"C:\Program Files\Rhinoceros 5 (64-bit)\System\Rhino.exe" /nosplash /runscript="_-open ""'
+ filename + '"" _Enter"')
else:
rs.MessageBox(
'dxf cannot be openened automatically. Could not find:\nC:\Program Files\Rhinoceros 5 (64-bit)\System\Rhino.exe'
)
filename_stripped, file_extension = os.path.splitext(
filename)
if clamexdata:
with open(filename_stripped + '.txt', 'w') as the_file:
the_file.write('')
with open(filename_stripped + '.txt', 'a') as the_file:
for line in clamexdata:
str = 'CLAMEX POSX=%.3f POSY=%.3f RICHTING="%s"\n' % (
line[0], line[1], line[2])
print str
the_file.write(str)
if result: print 'exported succesfully'
rs.DeleteObjects(copies)
if biesse_layers and len(biesse_layers) > 0:
for layer in biesse_layers:
rs.PurgeLayer(layer)
rs.EnableRedraw(True)