giuliof
/
flatcam
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

- Tool Copper Thieving - added pattern plating mask generation feature

This commit is contained in:
Marius Stanciu 2019-12-03 01:39:19 +02:00 committed by Marius
parent 3812de6439
commit fc7d3b3fba
2 changed files with 215 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
README.md
View File

@ -18,6 +18,7 @@ CAD program, and create G-Code for Isolation routing.
- added a Cancel button in Tools DB when requesting to add a tool in the Geometry Tool Table
- modified the default values for the METRIC system; the app now starts in the METRIC units since the majority of the world use the METRIC units system
- small changes, updated the estimated release date
- Tool Copper Thieving - added pattern plating mask generation feature
28.11.2019

241
flatcamTools/ToolCopperThieving.py
View File

@ -383,7 +383,56 @@ class ToolCopperThieving(FlatCAMTool):
"at a certain distance.\n"
"Required when doing holes pattern plating.")
)
self.layout.addWidget(self.rb_button)
grid_lay_1.addWidget(self.rb_button, 4, 0, 1, 2)
separator_line_2 = QtWidgets.QFrame()
separator_line_2.setFrameShape(QtWidgets.QFrame.HLine)
separator_line_2.setFrameShadow(QtWidgets.QFrame.Sunken)
grid_lay_1.addWidget(separator_line_2, 5, 0, 1, 2)
self.patern_mask_label = QtWidgets.QLabel('<b>%s</b>' % _('Pattern Plating Mask'))
self.patern_mask_label.setToolTip(
_("Generate a mask for pattern plating.")
)
grid_lay_1.addWidget(self.patern_mask_label, 6, 0, 1, 2)
self.sm_obj_label = QtWidgets.QLabel("%s:" % _("Select Soldermask object"))
self.sm_obj_label.setToolTip(
_("Gerber Object with the soldermask.\n"
"It will be used as a base for\n"
"the pattern plating mask.")
)
self.sm_object_combo = QtWidgets.QComboBox()
self.sm_object_combo.setModel(self.app.collection)
self.sm_object_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
self.sm_object_combo.setCurrentIndex(1)
grid_lay_1.addWidget(self.sm_obj_label, 7, 0, 1, 2)
grid_lay_1.addWidget(self.sm_object_combo, 8, 0, 1, 2)
# Openings CLEARANCE #
self.clearance_ppm_label = QtWidgets.QLabel('%s:' % _("Clearance"))
self.clearance_ppm_label.setToolTip(
_("The distance between the possible copper thieving elements\n"
"and/or robber bar and the actual openings in the mask.")
)
self.clearance_ppm_entry = FCDoubleSpinner()
self.clearance_ppm_entry.set_range(-9999.9999, 9999.9999)
self.clearance_ppm_entry.set_precision(self.decimals)
self.clearance_ppm_entry.setSingleStep(0.1)
grid_lay_1.addWidget(self.clearance_ppm_label, 9, 0)
grid_lay_1.addWidget(self.clearance_ppm_entry, 9, 1)
# ## Pattern Plating Mask
self.ppm_button = QtWidgets.QPushButton(_("Generate pattern plating mask"))
self.ppm_button.setToolTip(
_("Will add to the soldermask gerber geometry\n"
"the geometries of the copper thieving and/or\n"
"the robber bar if those were generated.")
)
grid_lay_1.addWidget(self.ppm_button, 10, 0, 1, 2)
self.layout.addStretch()
@ -391,6 +440,7 @@ class ToolCopperThieving(FlatCAMTool):
self.grb_object = None
self.ref_obj = None
self.sel_rect = list()
self.sm_object = None
# store the flattened geometry here:
self.flat_geometry = list()
@ -411,6 +461,15 @@ class ToolCopperThieving(FlatCAMTool):
self.margin_val = None
self.geo_steps_per_circle = 128
# Thieving geometry storage
self.new_solid_geometry = list()
# Robber bar geometry storage
self.robber_geo = None
self.robber_line = None
self.rb_thickness = None
# SIGNALS
self.box_combo_type.currentIndexChanged.connect(self.on_combo_box_type)
self.reference_radio.group_toggle_fn = self.on_toggle_reference
@ -418,6 +477,7 @@ class ToolCopperThieving(FlatCAMTool):
self.fill_button.clicked.connect(self.execute)
self.rb_button.clicked.connect(self.add_robber_bar)
self.ppm_button.clicked.connect(self.on_add_ppm)
def run(self, toggle=True):
self.app.report_usage("ToolCopperThieving()")
@ -471,6 +531,8 @@ class ToolCopperThieving(FlatCAMTool):
# INIT SECTION
self.area_method = False
self.robber_geo = None
self.new_solid_geometry = None
def on_combo_box_type(self):
obj_type = self.box_combo_type.currentIndex()
@ -527,7 +589,7 @@ class ToolCopperThieving(FlatCAMTool):
def add_robber_bar(self):
rb_margin = self.rb_margin_entry.get_value()
rb_thickness = self.rb_thickness_entry.get_value()
self.rb_thickness = self.rb_thickness_entry.get_value()
# get the Gerber object on which the Robber bar will be inserted
selection_index = self.grb_object_combo.currentIndex()
@ -545,23 +607,23 @@ class ToolCopperThieving(FlatCAMTool):
except TypeError:
outline_pol = MultiPolygon(self.grb_object.solid_geometry).envelope
rb_distance = rb_margin + (rb_thickness / 2.0)
robber_line = outline_pol.buffer(rb_distance).exterior
rb_distance = rb_margin + (self.rb_thickness / 2.0)
self.robber_line = outline_pol.buffer(rb_distance).exterior
robber_geo = robber_line.buffer(rb_thickness / 2.0)
self.robber_geo = self.robber_line.buffer(self.rb_thickness / 2.0)
self.app.proc_container.update_view_text(' %s' % _("Append geometry"))
aperture_found = None
for ap_id, ap_val in self.grb_object.apertures.items():
if ap_val['type'] == 'C' and ap_val['size'] == rb_thickness:
if ap_val['type'] == 'C' and ap_val['size'] == self.rb_thickness:
aperture_found = ap_id
break
if aperture_found:
geo_elem = dict()
geo_elem['solid'] = robber_geo
geo_elem['follow'] = robber_line
geo_elem['solid'] = self.robber_geo
geo_elem['follow'] = self.robber_line
self.grb_object.apertures[aperture_found]['geometry'].append(deepcopy(geo_elem))
else:
ap_keys = list(self.grb_object.apertures.keys())
@ -572,12 +634,12 @@ class ToolCopperThieving(FlatCAMTool):
self.grb_object.apertures[new_apid] = dict()
self.grb_object.apertures[new_apid]['type'] = 'C'
self.grb_object.apertures[new_apid]['size'] = rb_thickness
self.grb_object.apertures[new_apid]['size'] = self.rb_thickness
self.grb_object.apertures[new_apid]['geometry'] = list()
geo_elem = dict()
geo_elem['solid'] = robber_geo
geo_elem['follow'] = robber_line
geo_elem['solid'] = self.robber_geo
geo_elem['follow'] = self.robber_line
self.grb_object.apertures[new_apid]['geometry'].append(deepcopy(geo_elem))
geo_obj = self.grb_object.solid_geometry
@ -585,12 +647,12 @@ class ToolCopperThieving(FlatCAMTool):
s_list = list()
for pol in geo_obj.geoms:
s_list.append(pol)
s_list.append(robber_geo)
s_list.append(self.robber_geo)
geo_obj = MultiPolygon(s_list)
elif isinstance(geo_obj, list):
geo_obj.append(robber_geo)
geo_obj.append(self.robber_geo)
elif isinstance(geo_obj, Polygon):
geo_obj = MultiPolygon([geo_obj, robber_geo])
geo_obj = MultiPolygon([geo_obj, self.robber_geo])
self.grb_object.solid_geometry = geo_obj
@ -984,7 +1046,7 @@ class ToolCopperThieving(FlatCAMTool):
# ########## Generate filling geometry. ###################################################
# #########################################################################################
new_solid_geometry = bounding_box.difference(clearance_geometry)
app_obj.new_solid_geometry = bounding_box.difference(clearance_geometry)
# determine the bounding box polygon for the entire Gerber object to which we add copper thieving
# if isinstance(geo_n, list):
@ -1037,9 +1099,9 @@ class ToolCopperThieving(FlatCAMTool):
thieving_box_geo = affinity.translate(thieving_box_geo, xoff=dx, yoff=dy)
try:
_it = iter(new_solid_geometry)
_it = iter(app_obj.new_solid_geometry)
except TypeError:
new_solid_geometry = [new_solid_geometry]
app_obj.new_solid_geometry = [app_obj.new_solid_geometry]
try:
_it = iter(thieving_box_geo)
@ -1048,11 +1110,11 @@ class ToolCopperThieving(FlatCAMTool):
thieving_geo = list()
for dot_geo in thieving_box_geo:
for geo_t in new_solid_geometry:
for geo_t in app_obj.new_solid_geometry:
if dot_geo.within(geo_t):
thieving_geo.append(dot_geo)
new_solid_geometry = thieving_geo
app_obj.new_solid_geometry = thieving_geo
if fill_type == 'line':
half_thick_line = line_size / 2.0
@ -1140,7 +1202,7 @@ class ToolCopperThieving(FlatCAMTool):
rest_line = line_poly.difference(clearance_geometry)
diff_lines_geo.append(rest_line)
app_obj.flatten([outline_geometry, box_outline_geometry, diff_lines_geo])
new_solid_geometry = app_obj.flat_geometry
app_obj.new_solid_geometry = app_obj.flat_geometry
app_obj.app.proc_container.update_view_text(' %s' % _("Append geometry"))
geo_list = app_obj.grb_object.solid_geometry
@ -1154,7 +1216,7 @@ class ToolCopperThieving(FlatCAMTool):
app_obj.grb_object.apertures['0']['size'] = 0.0
try:
for poly in new_solid_geometry:
for poly in app_obj.new_solid_geometry:
# append to the new solid geometry
geo_list.append(poly)
@ -1165,12 +1227,12 @@ class ToolCopperThieving(FlatCAMTool):
app_obj.grb_object.apertures['0']['geometry'].append(deepcopy(geo_elem))
except TypeError:
# append to the new solid geometry
geo_list.append(new_solid_geometry)
geo_list.append(app_obj.new_solid_geometry)
# append into the '0' aperture
geo_elem = dict()
geo_elem['solid'] = new_solid_geometry
geo_elem['follow'] = new_solid_geometry.exterior
geo_elem['solid'] = app_obj.new_solid_geometry
geo_elem['follow'] = app_obj.new_solid_geometry.exterior
app_obj.grb_object.apertures['0']['geometry'].append(deepcopy(geo_elem))
app_obj.grb_object.solid_geometry = MultiPolygon(geo_list).buffer(0.0000001).buffer(-0.0000001)
@ -1190,6 +1252,116 @@ class ToolCopperThieving(FlatCAMTool):
else:
job_thread_thieving(self)
def on_add_ppm(self):
run_threaded = True
if run_threaded:
proc = self.app.proc_container.new('%s ...' % _("P-Plating Mask"))
else:
QtWidgets.QApplication.processEvents()
self.app.proc_container.view.set_busy('%s ...' % _("P-Plating Mask"))
# get the Gerber object on which the Copper thieving will be inserted
selection_index = self.sm_object_combo.currentIndex()
model_index = self.app.collection.index(selection_index, 0, self.sm_object_combo.rootModelIndex())
try:
self.sm_object = model_index.internalPointer().obj
except Exception as e:
log.debug("ToolCopperThieving.on_add_ppm() --> %s" % str(e))
self.app.inform.emit('[WARNING_NOTCL] %s' % _("There is no Gerber object loaded ..."))
return 'fail'
ppm_clearance = self.clearance_ppm_entry.get_value()
def job_thread_ppm(app_obj):
app_obj.app.proc_container.update_view_text(' %s' % _("Append PP-M geometry"))
geo_list = app_obj.sm_object.solid_geometry
if isinstance(app_obj.sm_object.solid_geometry, MultiPolygon):
geo_list = list(app_obj.sm_object.solid_geometry.geoms)
# if we have copper thieving geometry, add it
if app_obj.new_solid_geometry:
if '0' not in app_obj.sm_object.apertures:
app_obj.sm_object.apertures['0'] = dict()
app_obj.sm_object.apertures['0']['geometry'] = list()
app_obj.sm_object.apertures['0']['type'] = 'REG'
app_obj.sm_object.apertures['0']['size'] = 0.0
try:
for poly in app_obj.new_solid_geometry:
poly_b = poly.buffer(ppm_clearance)
# append to the new solid geometry
geo_list.append(poly_b)
# append into the '0' aperture
geo_elem = dict()
geo_elem['solid'] = poly_b
geo_elem['follow'] = poly_b.exterior
app_obj.sm_object.apertures['0']['geometry'].append(deepcopy(geo_elem))
except TypeError:
# append to the new solid geometry
geo_list.append(app_obj.new_solid_geometry.buffer(ppm_clearance))
# append into the '0' aperture
geo_elem = dict()
geo_elem['solid'] = app_obj.new_solid_geometry.buffer(ppm_clearance)
geo_elem['follow'] = app_obj.new_solid_geometry.buffer(ppm_clearance).exterior
app_obj.sm_object.apertures['0']['geometry'].append(deepcopy(geo_elem))
# if we have robber bar geometry, add it
if app_obj.robber_geo:
aperture_found = None
for ap_id, ap_val in app_obj.sm_object.apertures.items():
if ap_val['type'] == 'C' and ap_val['size'] == app_obj.rb_thickness + ppm_clearance:
aperture_found = ap_id
break
if aperture_found:
geo_elem = dict()
geo_elem['solid'] = app_obj.robber_geo
geo_elem['follow'] = app_obj.robber_line
app_obj.sm_object.apertures[aperture_found]['geometry'].append(deepcopy(geo_elem))
else:
ap_keys = list(app_obj.sm_object.apertures.keys())
if ap_keys:
new_apid = str(int(max(ap_keys)) + 1)
else:
new_apid = '10'
app_obj.sm_object.apertures[new_apid] = dict()
app_obj.sm_object.apertures[new_apid]['type'] = 'C'
app_obj.sm_object.apertures[new_apid]['size'] = app_obj.rb_thickness + ppm_clearance
app_obj.sm_object.apertures[new_apid]['geometry'] = list()
geo_elem = dict()
geo_elem['solid'] = app_obj.robber_geo.buffer(ppm_clearance)
geo_elem['follow'] = Polygon(app_obj.robber_line).buffer(ppm_clearance / 2.0).exterior
app_obj.sm_object.apertures[new_apid]['geometry'].append(deepcopy(geo_elem))
geo_list.append(app_obj.robber_geo.buffer(ppm_clearance))
app_obj.sm_object.solid_geometry = MultiPolygon(geo_list).buffer(0.0000001).buffer(-0.0000001)
app_obj.app.proc_container.update_view_text(' %s' % _("Append source file"))
# update the source file with the new geometry:
app_obj.sm_object.source_file = app_obj.app.export_gerber(obj_name=app_obj.sm_object.options['name'],
filename=None,
local_use=app_obj.sm_object,
use_thread=False)
app_obj.app.proc_container.update_view_text(' %s' % '')
app_obj.on_exit()
app_obj.app.inform.emit('[success] %s' % _("Generating Pattern Plating Mask done."))
if run_threaded:
self.app.worker_task.emit({'fcn': job_thread_ppm, 'params': [self]})
else:
job_thread_ppm(self)
def replot(self, obj):
def worker_task():
with self.app.proc_container.new('%s...' % _("Plotting")):
@ -1198,8 +1370,12 @@ class ToolCopperThieving(FlatCAMTool):
self.app.worker_task.emit({'fcn': worker_task, 'params': []})
def on_exit(self):
# plot the object
self.replot(obj=self.grb_object)
# plot the objects
if self.grb_object:
self.replot(obj=self.grb_object)
if self.sm_object:
self.replot(obj=self.sm_object)
# update the bounding box values
try:
@ -1209,10 +1385,21 @@ class ToolCopperThieving(FlatCAMTool):
self.grb_object.options['xmax'] = c
self.grb_object.options['ymax'] = d
except Exception as e:
log.debug("ToolCopperThieving.on_exit() bounds error --> %s" % str(e))
log.debug("ToolCopperThieving.on_exit() bounds -> copper thieving Gerber error --> %s" % str(e))
# update the bounding box values
try:
a, b, c, d = self.sm_object.bounds()
self.sm_object.options['xmin'] = a
self.sm_object.options['ymin'] = b
self.sm_object.options['xmax'] = c
self.sm_object.options['ymax'] = d
except Exception as e:
log.debug("ToolCopperThieving.on_exit() bounds -> pattern plating mask error --> %s" % str(e))
# reset the variables
self.grb_object = None
self.sm_object = None
self.ref_obj = None
self.sel_rect = list()