def operate(self, design):
safe_buffer1 = self.buffer_val * popupcad.csg_processing_scaling
safe_buffer2 = self.buffer_val * popupcad.csg_processing_scaling
safe_buffer3 = self.buffer_val * popupcad.csg_processing_scaling
parent_id, parent_output_index = self.operation_links['parent'][0]
parent_index = design.operation_index(parent_id)
parent = design.operations[parent_index].output[
parent_output_index].csg
layerdef = design.return_layer_definition()
allgeoms = []
allhingelines = []
buffered_splits = []
for joint_def in self.joint_defs:
allgeoms4, buffered_split, hingelines = self.gen_geoms(joint_def, layerdef, design,self.buffer_val)
allgeoms.extend(allgeoms4)
allhingelines.extend(hingelines)
buffered_splits.append(buffered_split)
safe_sections = []
for ii in range(len(allgeoms)):
unsafe = Laminate.unaryoperation(allgeoms[:ii] +allgeoms[ii +1:],
'union')
unsafe_buffer = unsafe.buffer(safe_buffer1,resolution=self.resolution)
safe_sections.append(allgeoms[ii].difference(unsafe_buffer))
safe = Laminate.unaryoperation(safe_sections, 'union')
safe_buffer = safe.buffer(safe_buffer2, resolution=self.resolution)
unsafe = Laminate.unaryoperation(allgeoms,'union').difference(safe_buffer)
unsafe2 = unsafe.buffer(safe_buffer3, resolution=self.resolution)
split1 = parent.difference(unsafe2)
return split1
def operate(self,design):
if len(self.operation_links1)>0:
laminates1 = [design.op_from_ref(link).output[ii].csg for link,ii in self.operation_links1]
else:
laminates1 = [Laminate(design.return_layer_definition())]
if len(self.operation_links2)>0:
laminates2 = [design.op_from_ref(link).output[ii].csg for link,ii in self.operation_links2]
else:
laminates2 = [Laminate(design.return_layer_definition())]
if self.function in self.unaryoperationtypes:
return Laminate.unaryoperation(laminates1,self.function)
elif self.function in self.pairoperationtypes:
laminate1 = Laminate.unaryoperation(laminates1,'union')
laminate2 = Laminate.unaryoperation(laminates2,'union')
return laminate1.binaryoperation(laminate2,self.function)
def operate(self, design):
if len(self.operation_links['unary']) > 0:
laminates1 = [
design.op_from_ref(link).output[ii].csg
for link, ii in self.operation_links['unary']
]
else:
laminates1 = [Laminate(design.return_layer_definition())]
if len(self.operation_links['binary']) > 0:
laminates2 = [
design.op_from_ref(link).output[ii].csg
for link, ii in self.operation_links['binary']
]
else:
laminates2 = [Laminate(design.return_layer_definition())]
if self.function in self.unaryoperationtypes:
return Laminate.unaryoperation(laminates1, self.function)
elif self.function in self.pairoperationtypes:
laminate1 = Laminate.unaryoperation(laminates1, 'union')
laminate2 = Laminate.unaryoperation(laminates2, 'union')
return laminate1.binaryoperation(laminate2, self.function)
def operate(self, design):
safe_buffer1 = self.buffer_val * popupcad.csg_processing_scaling
safe_buffer2 = self.buffer_val * popupcad.csg_processing_scaling
safe_buffer3 = self.buffer_val * popupcad.csg_processing_scaling
parent_id, parent_output_index = self.operation_links['parent'][0]
parent_index = design.operation_index(parent_id)
parent = design.operations[parent_index].output[
parent_output_index].csg
layerdef = design.return_layer_definition()
allgeoms = []
allhingelines = []
buffered_splits = []
for joint_def in self.joint_defs:
allgeoms4, buffered_split, hingelines = self.gen_geoms(
joint_def, layerdef, design, self.buffer_val)
allgeoms.extend(allgeoms4)
allhingelines.extend(hingelines)
buffered_splits.append(buffered_split)
safe_sections = []
for ii in range(len(allgeoms)):
unsafe = Laminate.unaryoperation(allgeoms[:ii] + allgeoms[ii + 1:],
'union')
unsafe_buffer = unsafe.buffer(safe_buffer1,
resolution=self.resolution)
safe_sections.append(allgeoms[ii].difference(unsafe_buffer))
safe = Laminate.unaryoperation(safe_sections, 'union')
safe_buffer = safe.buffer(safe_buffer2, resolution=self.resolution)
unsafe = Laminate.unaryoperation(allgeoms,
'union').difference(safe_buffer)
unsafe2 = unsafe.buffer(safe_buffer3, resolution=self.resolution)
split1 = parent.difference(unsafe2)
return split1
def find_rigid(generic, layerdef):
csg1 = generic.to_csg()
laminate_results = []
for ii,layer in enumerate(layerdef.layers):
if layer.is_rigid:
rigid_layer_csg = csg1.layer_sequence[layer]
laminate_result = Laminate(layerdef)
laminate_result.replacelayergeoms(layer,rigid_layer_csg.geoms)
lower_layers = layerdef.layers[ii::-1]
upper_layers = layerdef.layers[ii:]
for list1 in [lower_layers,upper_layers]:
a = list1[:-1]
b = list1[1:]
c = zip(a,b)
for aa,bb in c:
if aa.is_adhesive or bb.is_adhesive:
if bb.is_rigid:
break
csga = laminate_result.layer_sequence[aa]
csgb = csg1.layer_sequence[bb]
layer_result = csga.intersection(csgb)
laminate_result.replacelayergeoms(bb,layer_result.geoms)
else:
break
laminate_results.append(laminate_result)
laminate_results = [item for item in laminate_results if not item.isEmpty()]
result = Laminate.unaryoperation(laminate_results,'union')
return result
def generate(self, design):
layerdef = design.return_layer_definition()
sublaminate_layers = layerdef.layers
sketch_result = self.operate(design)
hingelayer = layerdef.getlayer(self.layer_links[0])
hingelines = sketch_result.to_generic_laminate().geoms[hingelayer]
hingelayer_ii = layerdef.getlayer_ii(self.layer_links[0])
safe_sections = []
allgeoms2 = [geom.to_shapely() for geom in hingelines]
allgeoms3 = [Laminate(layerdef) for item in allgeoms2]
allgeoms4 = []
for laminate, geom in zip(allgeoms3, allgeoms2):
laminate[hingelayer_ii] = [geom]
allgeoms4.append(
laminate.buffer(
self.hinge_gap,
resolution=self.resolution))
for ii, lam in enumerate(allgeoms4):
unsafe = Laminate.unaryoperation(
allgeoms4[
:ii] +
allgeoms4[
ii +
1:],
'union')
safe_sections.append(
lam.difference(
unsafe.buffer(
self.safe_buffer1,
resolution=self.resolution)))
safe = Laminate.unaryoperation(safe_sections, 'union')
unsafe = Laminate.unaryoperation(
allgeoms4,
'union').difference(
safe.buffer(
self.safe_buffer2,
resolution=self.resolution))
unsafe2 = unsafe.unarylayeroperation(
'union',
[hingelayer],
sublaminate_layers).buffer(
self.safe_buffer3,
resolution=self.resolution)
buffered2 = sketch_result.buffer(
self.split_buffer,
resolution=self.resolution)
self_index = design.operation_index(self.id)
last = design.operations[self_index - 1].output[0].csg
split1 = last.difference(unsafe2)
split2 = split1.difference(buffered2)
bodies = popupcad.algorithms.body_detection.find(
split2.to_generic_laminate())
bodies_generic = [item.to_generic_laminate() for item in bodies]
connections = {}
connections2 = {}
for line, geom in zip(hingelines, safe_sections):
connections[line] = []
connections2[line] = []
for body, body_generic in zip(bodies, bodies_generic):
if not geom.intersection(body).isEmpty():
connections[line].append(body_generic)
connections2[line].append(body)
for line, geoms in connections2.items():
connections2[line] = Laminate.unaryoperation(geoms, 'union')
self.connections = [(key, connections[key]) for key in hingelines]
laminates = [sketch_result,
safe,
unsafe2,
split1,
split2] + bodies + list(connections2.values())
self.output = []
for ii, item in enumerate(laminates):
self.output.append(
OperationOutput(
item,
'Body {0:d}'.format(ii),
self))
self.output.insert(0, self.output[0])
def generate(self, design):
safe_buffer1 = .5 *popupcad.csg_processing_scaling
safe_buffer2 = .5 *popupcad.csg_processing_scaling
safe_buffer3 = .5 *popupcad.csg_processing_scaling
parent_id, parent_output_index = self.operation_links['parent'][0]
parent_index = design.operation_index(parent_id)
parent = design.operations[parent_index].output[
parent_output_index].csg
fixed_id, fixed_output_index = self.operation_links['fixed'][0]
fixed_index = design.operation_index(fixed_id)
fixed = design.operations[fixed_index].output[fixed_output_index].csg
layerdef = design.return_layer_definition()
allgeoms = []
allhingelines = []
buffered_splits = []
all_joint_props = {}
for joint_def in self.joint_defs:
allgeoms4, buffered_split, hingelines, joint_props = self.gen_geoms(
joint_def, layerdef, design)
allgeoms.extend(allgeoms4)
allhingelines.extend(hingelines)
buffered_splits.append(buffered_split)
for jointline,jointprop in zip(hingelines,joint_props):
all_joint_props[jointline]=jointprop
#allhingelines, buffered_splits = zip(*sorted(zip(allhingelines, allgeoms, buffered_splits)))
#allhingelines = list(allhingelines)
#allgeoms = list(allgeoms)
#buffered_splits = list(buffered_splits)
safe_sections = []
for ii in range(len(allgeoms)):
unsafe = Laminate.unaryoperation(
allgeoms[
:ii] +
allgeoms[
ii +
1:],
'union')
unsafe_buffer = unsafe.buffer(
safe_buffer1,
resolution=self.resolution)
safe_sections.append(allgeoms[ii].difference(unsafe_buffer))
safe = Laminate.unaryoperation(safe_sections, 'union')
buffered_splits2 = Laminate.unaryoperation(buffered_splits, 'union')
safe_buffer = safe.buffer(safe_buffer2, resolution=self.resolution)
unsafe = Laminate.unaryoperation(
allgeoms,
'union').difference(safe_buffer)
unsafe2 = unsafe.buffer(safe_buffer3, resolution=self.resolution)
split1 = parent.difference(unsafe2)
split2 = split1.difference(buffered_splits2)
bodies = popupcad.algorithms.body_detection.find(
split2.to_generic_laminate())
bodies_generic = [item.to_generic_laminate() for item in bodies]
connections = {}
connections2 = {}
for line, geom in zip(allhingelines, safe_sections):
connections[line] = []
connections2[line] = []
for body, body_generic in zip(bodies, bodies_generic):
if not geom.intersection(body).isEmpty():
connections[line].append(body_generic)
connections2[line].append(body)
for line, geoms in connections2.items():
connections2[line] = Laminate.unaryoperation(geoms, 'union')
self.fixed_bodies = []
fixed_csg = []
for body, body_generic in zip(bodies, bodies_generic):
if not fixed.intersection(body).isEmpty():
self.fixed_bodies.append(body_generic)
fixed_csg.append(body)
self.bodies_generic = bodies_generic
allhingelines.sort() #Sort here to prevent interfering with geometry. We only care about order of the joint props
self.connections = sorted([(key, connections[key]) for key in allhingelines if len(connections[key]) == 2])
self.all_joint_props = [all_joint_props[key] for key in allhingelines if len(connections[key]) == 2]
self.output = []
self.output.append(OperationOutput(safe,'Safe',self))
self.output.append(OperationOutput(unsafe,'Unsafe',self))
self.output.append(OperationOutput(split1,'Split1',self))
self.output.append(OperationOutput(split2,'Split2',self))
#TODO Change output to match the names that get exported to Gazebo
self.output.extend([OperationOutput(item,'Fixed {0:d}'.format(ii),self) for ii,item in enumerate(fixed_csg)])
self.output.extend([OperationOutput(item,'Body {0:d}'.format(ii),self) for ii,item in enumerate(bodies)])
self.output.extend([OperationOutput(item,'Connection {0:d}'.format(ii),self) for ii,item in enumerate(connections2.values())])
self.output.insert(0, self.output[3])
def generate(self, design):
safe_buffer1 = .5 *popupcad.csg_processing_scaling
safe_buffer2 = .5 *popupcad.csg_processing_scaling
safe_buffer3 = .5 *popupcad.csg_processing_scaling
parent_id, parent_output_index = self.operation_links['parent'][0]
parent_index = design.operation_index(parent_id)
parent = design.operations[parent_index].output[
parent_output_index].csg
fixed_id, fixed_output_index = self.operation_links['fixed'][0]
fixed_index = design.operation_index(fixed_id)
fixed = design.operations[fixed_index].output[fixed_output_index].csg
layerdef = design.return_layer_definition()
allgeoms = []
allhingelines = []
buffered_splits = []
all_joint_props = {}
for joint_def in self.joint_defs:
allgeoms4, buffered_split, hingelines, joint_props = self.gen_geoms(
joint_def, layerdef, design)
allgeoms.extend(allgeoms4)
allhingelines.extend(hingelines)
buffered_splits.append(buffered_split)
for jointline,jointprop in zip(hingelines,joint_props):
all_joint_props[jointline]=jointprop
#allhingelines, buffered_splits = zip(*sorted(zip(allhingelines, allgeoms, buffered_splits)))
#allhingelines = list(allhingelines)
#allgeoms = list(allgeoms)
#buffered_splits = list(buffered_splits)
safe_sections = []
if len(allgeoms)>1:
for ii in range(len(allgeoms)):
unsafe = Laminate.unaryoperation(allgeoms[:ii] +allgeoms[ii + 1:],'union')
unsafe_buffer = unsafe.buffer(safe_buffer1,resolution=self.resolution)
safe_sections.append(allgeoms[ii].difference(unsafe_buffer))
safe = Laminate.unaryoperation(safe_sections, 'union')
else:
safe_sections.append(allgeoms[0])
safe = allgeoms[0]
buffered_splits2 = Laminate.unaryoperation(buffered_splits, 'union')
safe_buffer = safe.buffer(safe_buffer2, resolution=self.resolution)
unsafe = Laminate.unaryoperation(
allgeoms,
'union').difference(safe_buffer)
unsafe2 = unsafe.buffer(safe_buffer3, resolution=self.resolution)
split1 = parent.difference(unsafe2)
split2 = split1.difference(buffered_splits2)
bodies = popupcad.algorithms.body_detection.find(
split2.to_generic_laminate())
bodies_generic = [item.to_generic_laminate() for item in bodies]
connections = {}
connections2 = {}
for line, geom in zip(allhingelines, safe_sections):
connections[line] = []
connections2[line] = []
for body, body_generic in zip(bodies, bodies_generic):
if not geom.intersection(body).isEmpty():
connections[line].append(body_generic)
connections2[line].append(body)
for line, geoms in connections2.items():
connections2[line] = Laminate.unaryoperation(geoms, 'union')
self.fixed_bodies = []
fixed_csg = []
for body, body_generic in zip(bodies, bodies_generic):
if not fixed.intersection(body).isEmpty():
self.fixed_bodies.append(body_generic)
fixed_csg.append(body)
self.bodies_generic = bodies_generic
allhingelines.sort() #Sort here to prevent interfering with geometry. We only care about order of the joint props
self.connections = sorted([(key, connections[key]) for key in allhingelines if len(connections[key]) == 2])
self.all_joint_props = [all_joint_props[key] for key in allhingelines if len(connections[key]) == 2]
self.output = []
self.output.append(OperationOutput(safe,'Safe',self))
self.output.append(OperationOutput(unsafe,'Unsafe',self))
self.output.append(OperationOutput(split1,'Split1',self))
self.output.append(OperationOutput(split2,'Split2',self))
#TODO Change output to match the names that get exported to Gazebo
self.output.extend([OperationOutput(item,'Fixed {0:d}'.format(ii),self) for ii,item in enumerate(fixed_csg)])
self.output.extend([OperationOutput(item,'Body {0:d}'.format(ii),self) for ii,item in enumerate(bodies)])
self.output.extend([OperationOutput(item,'Connection {0:d}'.format(ii),self) for ii,item in enumerate(connections2.values())])
self.output.insert(0, self.output[3])
def generate(self,design):
safe_buffer1 = .5*popupcad.internal_argument_scaling
safe_buffer2 = .5*popupcad.internal_argument_scaling
safe_buffer3 = .5*popupcad.internal_argument_scaling
# split_buffer = .1
parent_id,parent_output_index = self.operation_links['parent'][0]
parent_index = design.operation_index(parent_id)
parent = design.operations[parent_index].output[parent_output_index].csg
fixed_id,fixed_output_index = self.operation_links['fixed'][0]
fixed_index = design.operation_index(fixed_id)
fixed = design.operations[fixed_index].output[fixed_output_index].csg
layerdef = design.return_layer_definition()
allgeoms = []
allhingelines = []
buffered_splits = []
all_joint_props = []
for joint_def in self.joint_defs:
allgeoms4,buffered_split,hingelines,joint_props= self.gen_geoms(joint_def,layerdef,design)
allgeoms.extend(allgeoms4)
allhingelines.extend(hingelines)
buffered_splits.append(buffered_split)
all_joint_props.extend(joint_props)
safe_sections = []
for ii in range(len(allgeoms)):
unsafe = Laminate.unaryoperation(allgeoms[:ii]+allgeoms[ii+1:],'union')
unsafe_buffer = unsafe.buffer(safe_buffer1,resolution = self.resolution)
safe_sections.append(allgeoms[ii].difference(unsafe_buffer))
safe = Laminate.unaryoperation(safe_sections,'union')
buffered_splits2 = Laminate.unaryoperation(buffered_splits,'union')
safe_buffer = safe.buffer(safe_buffer2,resolution = self.resolution)
unsafe = Laminate.unaryoperation(allgeoms,'union').difference(safe_buffer)
# unsafe2 = unsafe.unarylayeroperation('union',[hingelayer],sublaminate_layers)
unsafe2 = unsafe.buffer(safe_buffer3,resolution = self.resolution)
split1 = parent.difference(unsafe2)
# for item in buffered_splits:
# split1 = split1.difference(item)
# split2 = split1
split2 = split1.difference(buffered_splits2)
bodies= popupcad_manufacturing_plugins.algorithms.bodydetection.find(split2.genericfromls(),layerdef)
bodies_generic = [item.genericfromls() for item in bodies]
bodies_generic = [GenericLaminate(layerdef,item) for item in bodies_generic]
connections = {}
connections2 = {}
for line,geom in zip(allhingelines,safe_sections):
connections[line]=[]
connections2[line]=[]
for body,body_generic in zip(bodies,bodies_generic):
if not geom.intersection(body).isEmpty():
connections[line].append(body_generic)
connections2[line].append(body)
for line,geoms in connections2.items():
connections2[line]=Laminate.unaryoperation(geoms,'union')
self.fixed_bodies = []
for body,body_generic in zip(bodies,bodies_generic):
if not fixed.intersection(body).isEmpty():
self.fixed_bodies.append(body_generic)
self.bodies_generic = bodies_generic
self.connections = [(key,connections[key]) for key in allhingelines]
self.all_joint_props = all_joint_props
laminates = [safe,unsafe2,split1,split2]+bodies+list(connections2.values())
# laminates = [safe,unsafe2,split1,split2]+bodies
self.output = []
for ii,item in enumerate(laminates):
self.output.append(OperationOutput(item,'Body {0:d}'.format(ii),self))
self.output.insert(0,self.output[0])
