def operate(self,design):
sketch = design.sketches[self.sketchid]
operationgeom = customshapely.unary_union_safe([item.outputshapely() for item in sketch.operationgeometry])
lsout = Laminate(design.return_layer_definition())
for layer in design.return_layer_definition().layers:
lsout.replacelayergeoms(layer,customshapely.multiinit(operationgeom))
return lsout
def to_csg(self):
from popupcad.filetypes.laminate import Laminate
new = Laminate(self.layerdef)
for ii, layer in enumerate(self.layerdef.layers):
geoms = [item.to_shapely() for item in self.geoms[layer]]
new.replacelayergeoms(layer, geoms)
return new
def sketch_operation(sketch, layerdef, layers):
from popupcad.filetypes.laminate import Laminate
operationgeom = sketch.output_csg()
laminate = Laminate(layerdef)
for layer in layers:
laminate.replacelayergeoms(layer, operationgeom)
return laminate
def shift_flip(ls1, shift, flip, rotate):
from popupcad.filetypes.laminate import Laminate
lsout = Laminate(ls1.layerdef)
layers = ls1.layerdef.layers
step = 1
if flip:
step = -1
if rotate:
for layerout, layerin in zip(
layers[shift:] + layers[:shift], layers[::step]):
lsout.replacelayergeoms(
layerout,
ls1.layer_sequence[layerin].geoms)
else:
if shift > 0:
outshift = shift
inshift = 0
elif shift < 0:
outshift = 0
inshift = -shift
else:
outshift = 0
inshift = 0
for layerout, layerin in zip(
layers[outshift:], layers[::step][inshift:]):
lsout.replacelayergeoms(layerout,ls1.layer_sequence[layerin].geoms)
return lsout
def gen_geoms(self,joint_def,layerdef,design):
hinge_gap = joint_def.width*popupcad.internal_argument_scaling
# safe_buffer1 = .5*hinge_gap
# safe_buffer2 = .5*hinge_gap
# safe_buffer3 = .5*hinge_gap
split_buffer = .1*hinge_gap
stiffness = joint_def.stiffness
damping = joint_def.damping
preload_angle = joint_def.preload_angle
sublaminate_layers = [layerdef.getlayer(item) for item in joint_def.sublaminate_layers]
hingelayer = layerdef.getlayer(joint_def.joint_layer)
operationgeom = design.sketches[joint_def.sketch].output_csg()
sketch_result = Laminate(design.return_layer_definition())
sketch_result.replacelayergeoms(hingelayer,operationgeom)
hingelines = sketch_result.genericfromls()[hingelayer]
buffered_split= sketch_result.buffer(split_buffer,resolution = self.resolution)
allgeoms4 = []
for geom in hingelines:
geom = geom.outputshapely()
laminate = Laminate(layerdef)
for layer in sublaminate_layers:
laminate.replacelayergeoms(layer,[geom])
allgeoms4.append(laminate.buffer(hinge_gap,resolution = self.resolution))
joint_props = [(stiffness,damping,preload_angle) for item in hingelines]
return allgeoms4, buffered_split,hingelines,joint_props
def sketch_operation(sketch, layerdef, layers):
from popupcad.filetypes.laminate import Laminate
operationgeom = sketch.output_csg()
laminate = Laminate(layerdef)
for layer in layers:
laminate.replacelayergeoms(layer, operationgeom)
return laminate
def shift_flip_rotate(ls1, shift, flip, rotate):
from popupcad.filetypes.laminate import Laminate
lsout = Laminate(ls1.layerdef)
layers = ls1.layerdef.layers
step = 1
if flip:
step = -1
if rotate:
for layerout, layerin in zip(
layers[shift:] + layers[:shift], layers[::step]):
lsout.replacelayergeoms(
layerout,
ls1.layer_sequence[layerin].geoms)
else:
if shift > 0:
outshift = shift
inshift = 0
elif shift < 0:
outshift = 0
inshift = -shift
else:
outshift = 0
inshift = 0
for layerout, layerin in zip(layers[outshift:], layers[::step][inshift:]):
lsout.replacelayergeoms(layerout,ls1.layer_sequence[layerin].geoms)
return lsout
def transform_csg(layerdef_from, layerdef_to, inshift, outshift, step,
geom_from, geoms_to, csg_laminate, scale_x, scale_y):
from popupcad.filetypes.laminate import Laminate
import shapely.affinity as aff
from popupcad.algorithms.points import calctransformfrom2lines
lsout = Laminate(layerdef_to)
for layer_from, layer_to in zip(layerdef_from.layers[::step][inshift:],
layerdef_to.layers[outshift:]):
newgeoms = []
for geom in geoms_to:
for designgeom in csg_laminate.layer_sequence[layer_from].geoms:
try:
from_line = geom_from.exteriorpoints(
scaling=popupcad.csg_processing_scaling)
to_line = geom.exteriorpoints(
scaling=popupcad.csg_processing_scaling)
transform = calctransformfrom2lines(from_line,
to_line,
scale_x=scale_x,
scale_y=scale_y)
transformed_geom = aff.affine_transform(
designgeom, transform)
newgeoms.append(transformed_geom)
except IndexError:
pass
result1 = popupcad.algorithms.csg_shapely.unary_union_safe(newgeoms)
results2 = popupcad.algorithms.csg_shapely.condition_shapely_entities(
result1)
lsout.replacelayergeoms(layer_to, results2)
return lsout
def gen_geoms(self, joint_def, layerdef, design, split_buffer):
print('Generating geometry')
hinge_gap = joint_def.width * popupcad.csg_processing_scaling
# split_buffer = .1 * hinge_gap
sublaminate_layers = [
layerdef.getlayer(item) for item in joint_def.sublaminate_layers
]
hingelayer = layerdef.getlayer(joint_def.joint_layer)
operationgeom = design.sketches[joint_def.sketch].output_csg()
sketch_result = Laminate(design.return_layer_definition())
sketch_result.replacelayergeoms(hingelayer, operationgeom)
hingelines = sketch_result.to_generic_laminate().geoms[hingelayer]
hingelines = [item for item in hingelines if item.is_valid_bool()]
buffered_split = sketch_result.buffer(split_buffer,
resolution=self.resolution)
allgeoms4 = []
for geom in hingelines:
geom = geom.to_shapely(scaling=popupcad.csg_processing_scaling)
laminate = Laminate(layerdef)
for layer in sublaminate_layers:
laminate.replacelayergeoms(layer, [geom])
allgeoms4.append(
laminate.buffer(hinge_gap, resolution=self.resolution))
return allgeoms4, buffered_split, hingelines
def gen_geoms(self, joint_def, layerdef, design,split_buffer):
print('Generating geometry')
hinge_gap = joint_def.width *popupcad.csg_processing_scaling
# split_buffer = .1 * hinge_gap
sublaminate_layers = [
layerdef.getlayer(item) for item in joint_def.sublaminate_layers]
hingelayer = layerdef.getlayer(joint_def.joint_layer)
operationgeom = design.sketches[joint_def.sketch].output_csg()
sketch_result = Laminate(design.return_layer_definition())
sketch_result.replacelayergeoms(hingelayer, operationgeom)
hingelines = sketch_result.to_generic_laminate().geoms[hingelayer]
hingelines = [item for item in hingelines if item.is_valid_bool()]
buffered_split = sketch_result.buffer(split_buffer,resolution=self.resolution)
allgeoms4 = []
for geom in hingelines:
geom = geom.to_shapely()
laminate = Laminate(layerdef)
for layer in sublaminate_layers:
laminate.replacelayergeoms(layer, [geom])
allgeoms4.append(
laminate.buffer(hinge_gap,resolution=self.resolution))
return allgeoms4, buffered_split, hingelines
def gen_geoms(self, joint_def, layerdef, design):
hinge_gap = joint_def.width *popupcad.csg_processing_scaling
split_buffer = .1 * hinge_gap
stiffness = joint_def.stiffness
damping = joint_def.damping
preload_angle = joint_def.preload_angle
sublaminate_layers = [
layerdef.getlayer(item) for item in joint_def.sublaminate_layers]
hingelayer = layerdef.getlayer(joint_def.joint_layer)
operationgeom = design.sketches[joint_def.sketch].output_csg()
sketch_result = Laminate(design.return_layer_definition())
sketch_result.replacelayergeoms(hingelayer, operationgeom)
hingelines = sketch_result.to_generic_laminate().geoms[hingelayer]
hingelines = [item for item in hingelines if item.is_valid_bool()]
buffered_split = sketch_result.buffer(split_buffer,resolution=self.resolution)
allgeoms4 = []
for geom in hingelines:
geom = geom.to_shapely()
laminate = Laminate(layerdef)
for layer in sublaminate_layers:
laminate.replacelayergeoms(layer, [geom])
allgeoms4.append(laminate.buffer(hinge_gap,resolution=self.resolution))
joint_props = [(stiffness, damping, preload_angle)
for item in hingelines]
return allgeoms4, buffered_split, hingelines, joint_props
def to_csg(self):
from popupcad.filetypes.laminate import Laminate
new = Laminate(self.layerdef)
for ii, layer in enumerate(self.layerdef.layers):
geoms = [item.to_shapely() for item in self.geoms[layer]]
new.replacelayergeoms(layer, geoms)
return new
def operate(self,design):
operation_link1,outputref = self.operation_links['parent'][0]
ls1 = design.op_from_ref(operation_link1).output[outputref].csg
lsout = Laminate(ls1.layerdef)
layers = ls1.layerdef.layers
step = 1
if self.flip:
step=-1
if self.rotate:
for layerout,layerin in zip(layers[self.shift:]+layers[:self.shift],layers[::step]):
lsout.replacelayergeoms(layerout,ls1.layer_sequence[layerin].geoms)
else:
if self.shift > 0:
outshift = self.shift
inshift = 0
elif self.shift <0:
outshift = 0
inshift = -self.shift
else:
outshift = 0
inshift = 0
for layerout,layerin in zip(layers[outshift:],layers[::step][inshift:]):
lsout.replacelayergeoms(layerout,ls1.layer_sequence[layerin].geoms)
return lsout
def operate(self,design):
operationgeom = design.sketches[self.sketch_links['sketch'][0]].output_csg()
# operationgeom = popupcad.geometry.customshapely.multiinit(operationgeom)
layers = [design.return_layer_definition().getlayer(item) for item in self.layer_links]
laminate = Laminate(design.return_layer_definition())
for layer in layers:
laminate.replacelayergeoms(layer,operationgeom)
return laminate
def jointholes(sketch_result,layerdef):
import popupcad
import operator
import math
from popupcad.filetypes.laminate import Laminate
generic = sketch_result.genericfromls()
for key,value in generic.items():
if not not value:
allgeoms = value
hingelayer = key
allpoints = []
for geom in allgeoms:
allpoints.extend(geom.exteriorpoints())
allpoints.sort()
commonpoints = []
for ii,point1 in enumerate(allpoints[1:-1]):
point0 = allpoints[ii]
point2 = allpoints[ii+2]
a = popupcad.algorithms.points.twopointsthesame(point1,point2,1e-5)
b = popupcad.algorithms.points.twopointsthesame(point0,point1,1e-5)
if ii==0:
if b:
commonpoints.append(point1)
elif a:
commonpoints.append(point1)
else:
if (a and (not b)):
commonpoints.append(point1)
shapelys = []
for point in commonpoints:
lineset = {}
for item in allgeoms:
points = numpy.array(item.exteriorpoints())
points -= point
l = (points[:,0]**2+points[:,1]**2)**.5
test = l<1e-5
if True in test:
ii = 1-test.nonzero()[0][0]
lineset[item] = math.atan2(points[ii,1],points[ii,0])
q_s = sorted(lineset.items(),key = operator.itemgetter(1))
gaps = [item1[1]-item0[1] for item0,item1 in zip(q_s[:-1],q_s[1:])] + [2*math.pi+q_s[0][1]-q_s[-1][1]]
min_gap = min(gaps)
bufferval = 1.1/math.sin(min_gap/2)
# print(gaps,min_gap,bufferval)
shapely = popupcad.geometry.vertex.DrawnPoint(position = point).outputshapely()
shapely = shapely.buffer(bufferval*popupcad.internal_argument_scaling)
shapelys.append(shapely)
shapelys = popupcad.geometry.customshapely.multiinit(*shapelys)
# generics = [popupcad.geometry.vertex.DrawnPoint(position = point) for point in commonpoints]
# shapelys = [item.outputshapely() for item in generics]
# layer = Layer(shapelys)
holes = Laminate(layerdef)
holes.replacelayergeoms(hingelayer,shapelys)
return holes,allgeoms,hingelayer
def operate(self, design):
sketch = design.sketches[self.sketchid]
operationgeom = popupcad.algorithms.csg_shapely.unary_union_safe(
[item.to_shapely() for item in sketch.operationgeometry])
lsout = Laminate(design.return_layer_definition())
for layer in design.return_layer_definition().layers:
lsout.replacelayergeoms(
layer,
popupcad.algorithms.csg_shapely.condition_shapely_entities(operationgeom))
return lsout
def operate(self,design):
import shapely.affinity as aff
subdesign = design.subdesigns[self.subdesignid]
locateline = subdesign.findlocateline()
try:
designgeometry = subdesign.operations[subdesign.operation_index(self.subopid)].output[self.getoutputref()].csg
except AttributeError:
subdesign.reprocessoperations()
designgeometry = subdesign.operations[subdesign.operation_index(self.subopid)].output[self.getoutputref()].csg
sketch = design.sketches[self.sketchid]
if self.transformtype==self.transformtypes.place:
scale_x = 1.
scale_y = 1.
elif self.transformtype==self.transformtypes.stretch:
scale_x = None
scale_y = 1.
if self.transformtype==self.transformtypes.scale:
scale_x = None
scale_y = None
if self.transformtype==self.transformtypes.custom:
scale_x = self.scalex
scale_y = self.scaley
lsout = Laminate(design.return_layer_definition())
step = 1
if self.flip:
step = -1
if self.shift > 0:
outshift = self.shift
inshift = 0
elif self.shift <0:
outshift = 0
inshift = -self.shift
else:
outshift = 0
inshift = 0
for layerout,layerin in zip(design.return_layer_definition().layers[outshift:],subdesign.return_layer_definition().layers[::step][inshift:]):
newgeoms = []
for geom in sketch.operationgeometry:
for designgeom in designgeometry.layer_sequence[layerin].geoms:
try:
newgeoms.append(aff.affine_transform(designgeom,calctransformfrom2lines(locateline.exteriorpoints(),geom.exteriorpoints(),scale_x = scale_x,scale_y = scale_y)))
except IndexError:
pass
newgeoms = customshapely.unary_union_safe(newgeoms)
newgeoms = popupcad.geometry.customshapely.multiinit(newgeoms)
lsout.replacelayergeoms(layerout,newgeoms)
return lsout
def operate(self, design):
sketchid = self.sketch_links['sketch'][0]
sketch = design.sketches[sketchid]
operationgeom = popupcad.algorithms.csg_shapely.unary_union_safe(
[item.to_shapely() for item in sketch.operationgeometry])
lsout = Laminate(design.return_layer_definition())
for layer in design.return_layer_definition().layers:
lsout.replacelayergeoms(
layer,
popupcad.algorithms.csg_shapely.condition_shapely_entities(
operationgeom))
return lsout
def generate(self,design):
operationgeom = design.sketches[self.sketch_link].output_csg()
layers = [design.return_layer_definition().getlayer(item) for item in self.layer_links]
support = Laminate(design.return_layer_definition())
for layer in layers:
support.replacelayergeoms(layer,operationgeom)
device = design.op_from_ref(self.device_link).output[self.deviceoutputref].csg
modified_device,supports,cuts = algorithms.modify_device.modify_device(device,support,self.support_width*popupcad.internal_argument_scaling,self.support_out*popupcad.internal_argument_scaling,self.hole_radius*popupcad.internal_argument_scaling,self.cut_width*popupcad.internal_argument_scaling)
s = OperationOutput(supports,'supports',self)
c = OperationOutput(cuts,'cuts',self)
d = OperationOutput(modified_device,'device',self)
self.output = [d,s,c]
def operate(self,design):
operationgeom = design.sketches[self.sketchid].output_csg()
layers = [design.return_layer_definition().getlayer(item) for item in self.layer_links]
try:
laminate1 = design.op_from_ref(self.operation_link1).output[self.getoutputref()].csg
except NoOperation:
laminate1 = Laminate(design.return_layer_definition())
laminate2 = Laminate(design.return_layer_definition())
for layer in layers:
laminate2.replacelayergeoms(layer,operationgeom)
lsout = laminate1.binaryoperation(laminate2,self.function)
return lsout
def find_outer(ls,minpoint):
import popupcad.algorithms.points as points
lsouter = Laminate(ls.layerdef)
lsinner = Laminate(ls.layerdef)
for layer,layer_geometry in ls.layer_sequence.items():
outergeoms = []
innergeoms = []
for geom in layer_geometry.geoms:
if points.pointinpoints(minpoint,GenericShapeBase.genfromshapely(geom).exteriorpoints(),GenericShapeBase.tolerance):
outergeoms.append(geom)
else:
innergeoms.append(geom)
lsouter.replacelayergeoms(layer,outergeoms)
lsinner.replacelayergeoms(layer,innergeoms)
return lsouter,lsinner
def cross_section(layerdef, sketch, parent, scale_value):
from popupcad.filetypes.laminate import Laminate
from popupcad.filetypes.genericshapes import GenericLine
import shapely.affinity as aff
import popupcad.algorithms.points as points
import shapely.geometry as sg
import numpy
laminate = Laminate(layerdef)
for item in sketch.operationgeometry:
if isinstance(item, GenericLine):
line = item
b = line.exteriorpoints(scaling=popupcad.csg_processing_scaling)[0]
c = numpy.array(b) + numpy.array([1, 0])
a = points.calctransformfrom2lines(
line.exteriorpoints(scaling=popupcad.csg_processing_scaling),
[b, c.tolist()],
scale_x=1,
scale_y=1)
sketch_csg = sketch.output_csg()
for layer in layerdef.layers:
laminate.replacelayergeoms(layer, sketch_csg)
result = parent.intersection(laminate)
laminate2 = Laminate(layerdef)
for ii, layerid in enumerate(layerdef.layers):
yshift = layerdef.z_values[
layerid] * popupcad.csg_processing_scaling * scale_value
layer = result.layer_sequence[layerid]
thickness = layerid.thickness * popupcad.csg_processing_scaling * scale_value
newgeoms = [item for item in layer.geoms]
newgeoms = [aff.affine_transform(item, a) for item in newgeoms]
newgeoms2 = []
for geom in newgeoms:
newgeom = sg.box(geom.coords[0][0], geom.coords[0][1],
geom.coords[-1][0],
geom.coords[-1][1] + thickness)
newgeoms2.append(newgeom)
newgeoms = newgeoms2
newgeoms = [
aff.translate(item, yoff=yshift) for item in newgeoms
]
newgeoms = popupcad.algorithms.csg_shapely.condition_shapely_entities(
*newgeoms)
laminate2[ii] = newgeoms
return laminate2
return laminate
def operate(self,design):
from popupcad.filetypes.genericshapes import GenericLine
import shapely.affinity as aff
import popupcad.algorithms.points as points
import popupcad
import shapely.geometry as sg
import numpy
parent_ref,parent_index = self.operation_links['source'][0]
parent = design.op_from_ref(parent_ref).output[parent_index].csg
sketch = design.sketches[self.sketch_links['cross_section'][0]]
layerdef = design.return_layer_definition()
laminate = Laminate(layerdef)
for item in sketch.operationgeometry:
if isinstance(item,GenericLine):
line = item
b = line.exteriorpoints()[0]
c = numpy.array(b)+numpy.array([1,0])
a = points.calctransformfrom2lines(line.exteriorpoints(),[b,c.tolist()],scale_x=1,scale_y=1)
sketch_csg = sketch.output_csg()
for layer in layerdef.layers:
laminate.replacelayergeoms(layer,sketch_csg)
result = parent.intersection(laminate)
laminate2 = Laminate(layerdef)
for ii,layerid in enumerate(layerdef.layers):
# for ii,layer in enumerate(result):
yshift = layerdef.zvalue[layerid] * self.scale_value
layer = result.layer_sequence[layerid]
thickness = layerid.thickness*popupcad.internal_argument_scaling*self.scale_value
newgeoms = [item for item in layer.geoms]
newgeoms = [aff.affine_transform(item,a) for item in newgeoms]
# newgeoms = [item.buffer(bufferval) for item in newgeoms]
newgeoms2 = []
for geom in newgeoms:
newgeom = sg.box(geom.coords[0][0],geom.coords[0][1],geom.coords[-1][0],geom.coords[-1][1]+thickness)
newgeoms2.append(newgeom)
newgeoms = newgeoms2
newgeoms = [aff.translate(item,yoff = yshift) for item in newgeoms]
newgeoms = popupcad.geometry.customshapely.multiinit(*newgeoms)
laminate2[ii] = newgeoms
return laminate2
return laminate
def cross_section(layerdef, sketch, parent, scale_value):
from popupcad.filetypes.laminate import Laminate
from popupcad.filetypes.genericshapes import GenericLine
import shapely.affinity as aff
import popupcad.algorithms.points as points
import shapely.geometry as sg
import numpy
laminate = Laminate(layerdef)
for item in sketch.operationgeometry:
if isinstance(item, GenericLine):
line = item
b = line.exteriorpoints(scaling = popupcad.csg_processing_scaling)[0]
c = numpy.array(b) + numpy.array([1, 0])
a = points.calctransformfrom2lines(
line.exteriorpoints(scaling = popupcad.csg_processing_scaling), [
b, c.tolist()], scale_x=1, scale_y=1)
sketch_csg = sketch.output_csg()
for layer in layerdef.layers:
laminate.replacelayergeoms(layer, sketch_csg)
result = parent.intersection(laminate)
laminate2 = Laminate(layerdef)
for ii, layerid in enumerate(layerdef.layers):
# for ii,layer in enumerate(result):
yshift = layerdef.zvalue[layerid] * popupcad.csg_processing_scaling * scale_value
layer = result.layer_sequence[layerid]
thickness = layerid.thickness * popupcad.csg_processing_scaling * scale_value
newgeoms = [item for item in layer.geoms]
newgeoms = [aff.affine_transform(item, a) for item in newgeoms]
# newgeoms = [item.buffer(bufferval) for item in newgeoms]
newgeoms2 = []
for geom in newgeoms:
newgeom = sg.box(geom.coords[0][0],
geom.coords[0][1],
geom.coords[-1][0],
geom.coords[-1][1] + thickness)
newgeoms2.append(newgeom)
newgeoms = newgeoms2
newgeoms = [aff.translate(item,yoff=yshift) for item in newgeoms]
newgeoms = popupcad.algorithms.csg_shapely.condition_shapely_entities(*newgeoms)
laminate2[ii] = newgeoms
return laminate2
return laminate
def find_outer(ls, minpoint):
import popupcad.algorithms.points as points
lsouter = Laminate(ls.layerdef)
lsinner = Laminate(ls.layerdef)
for layer, layer_geometry in ls.layer_sequence.items():
outergeoms = []
innergeoms = []
for geom in layer_geometry.geoms:
if points.pointinpoints(
minpoint,
popupcad.algorithms.csg_shapely.to_generic(geom).exteriorpoints(scaling = popupcad.csg_processing_scaling),
popupcad.distinguishable_number_difference):
outergeoms.append(geom)
else:
innergeoms.append(geom)
lsouter.replacelayergeoms(layer, outergeoms)
lsinner.replacelayergeoms(layer, innergeoms)
return lsouter, lsinner
def find_outer(ls, minpoint):
import popupcad.algorithms.points as points
lsouter = Laminate(ls.layerdef)
lsinner = Laminate(ls.layerdef)
for layer, layer_geometry in ls.layer_sequence.items():
outergeoms = []
innergeoms = []
for geom in layer_geometry.geoms:
if points.pointinpoints(
minpoint,
popupcad.algorithms.csg_shapely.to_generic(geom).
exteriorpoints(scaling=popupcad.csg_processing_scaling),
popupcad.distinguishable_number_difference):
outergeoms.append(geom)
else:
innergeoms.append(geom)
lsouter.replacelayergeoms(layer, outergeoms)
lsinner.replacelayergeoms(layer, innergeoms)
return lsouter, lsinner
def transform(
layerdef,
layerdef_subdesign,
inshift,
outshift,
step,
sketch,
designgeometry,
locateline,
scale_x,
scale_y):
from popupcad.filetypes.laminate import Laminate
import shapely.affinity as aff
from popupcad.algorithms.points import calctransformfrom2lines
lsout = Laminate(layerdef)
for layerout, layerin in zip(
layerdef.layers[
outshift:], layerdef_subdesign.layers[
::step][
inshift:]):
newgeoms = []
for geom in sketch.operationgeometry:
if not geom.is_construction():
for designgeom in designgeometry.layer_sequence[layerin].geoms:
try:
newgeoms.append(
aff.affine_transform(
designgeom,
calctransformfrom2lines(
locateline.exteriorpoints(scaling = popupcad.csg_processing_scaling),
geom.exteriorpoints(scaling = popupcad.csg_processing_scaling),
scale_x=scale_x,
scale_y=scale_y)))
except IndexError:
pass
result1 = popupcad.algorithms.csg_shapely.unary_union_safe(newgeoms)
results2 = popupcad.algorithms.csg_shapely.condition_shapely_entities(result1)
lsout.replacelayergeoms(layerout, results2)
return lsout
def generate(self, design):
devicelink, outputindex = self.operation_links['device'][0]
sketch = design.sketches[self.sketch_links['sketch'][0]]
operationgeom = sketch.output_csg()
layers = [design.return_layer_definition().getlayer(item)
for item in self.layer_links]
support = Laminate(design.return_layer_definition())
for layer in layers:
support.replacelayergeoms(layer, operationgeom)
device = design.op_from_ref(devicelink).output[outputindex].csg
modified_device, supports, cuts = algorithms.modify_device.modify_device(device, support, self.support_width *
popupcad.csg_processing_scaling, self.support_out *
popupcad.csg_processing_scaling, self.hole_radius *
popupcad.csg_processing_scaling, self.cut_width *
popupcad.csg_processing_scaling)
s = OperationOutput(supports, 'supports', self)
c = OperationOutput(cuts, 'cuts', self)
d = OperationOutput(modified_device, 'device', self)
self.output = [d, s, c]
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 supportsheet(layerdef,lsin,value):
allext = []
for layer,layer_geometry in lsin.layer_sequence.items():
for geom in layer_geometry.geoms:
geom2 = GenericShapeBase.genfromshapely(geom)
allext.extend(geom2.exteriorpoints())
allext = numpy.array(allext)
minx = allext[:,0].min()-value
miny = allext[:,1].min()-value
maxx = allext[:,0].max()+value
maxy = allext[:,1].max()+value
exterior = [[minx,miny],[maxx,miny],[maxx,maxy],[minx,maxy]]
geom = GenericShapeBase.gengenericpoly(exterior,[])
geom = geom.outputshapely()
ls = Laminate(layerdef)
[ls.replacelayergeoms(layer,[geom]) for layer in layerdef.layers]
return ls,exterior[0]
def supportsheet(layerdef, lsin, value):
allext = []
for layer, layer_geometry in lsin.layer_sequence.items():
for geom in layer_geometry.geoms:
geom2 = popupcad.algorithms.csg_shapely.to_generic(geom)
allext.extend(geom2.exteriorpoints(scaling = popupcad.csg_processing_scaling))
allext = numpy.array(allext)
minx = allext[:, 0].min() - value
miny = allext[:, 1].min() - value
maxx = allext[:, 0].max() + value
maxy = allext[:, 1].max() + value
exterior = [[minx, miny], [maxx, miny], [maxx, maxy], [minx, maxy]]
exterior_scaled = (numpy.array(exterior)/popupcad.csg_processing_scaling).tolist()
geom = GenericPoly.gen_from_point_lists(exterior_scaled, [])
geom = geom.to_shapely()
ls = Laminate(layerdef)
[ls.replacelayergeoms(layer, [geom]) for layer in layerdef.layers]
return ls, exterior[0]
def supportsheet(layerdef, lsin, value):
allext = []
for layer, layer_geometry in lsin.layer_sequence.items():
for geom in layer_geometry.geoms:
geom2 = popupcad.algorithms.csg_shapely.to_generic(geom)
allext.extend(
geom2.exteriorpoints(scaling=popupcad.csg_processing_scaling))
allext = numpy.array(allext)
minx = allext[:, 0].min() - value
miny = allext[:, 1].min() - value
maxx = allext[:, 0].max() + value
maxy = allext[:, 1].max() + value
exterior = [[minx, miny], [maxx, miny], [maxx, maxy], [minx, maxy]]
exterior_scaled = (numpy.array(exterior) /
popupcad.csg_processing_scaling).tolist()
geom = GenericPoly.gen_from_point_lists(exterior_scaled, [])
geom = geom.to_shapely(scaling=popupcad.csg_processing_scaling)
ls = Laminate(layerdef)
[ls.replacelayergeoms(layer, [geom]) for layer in layerdef.layers]
return ls, exterior[0]
def promote(self, layerdef):
from popupcad.filetypes.laminate import Laminate
lsout = Laminate(layerdef)
for layer in layerdef.layers:
lsout.replacelayergeoms(layer, self.geoms)
return lsout
def promote(self, layerdef):
from popupcad.filetypes.laminate import Laminate
lsout = Laminate(layerdef)
for layer in layerdef.layers:
lsout.replacelayergeoms(layer, self.geoms)
return lsout
