1434 lines
71 KiB
Python
1434 lines
71 KiB
Python
# ##########################################################
|
|
# FlatCAM: 2D Post-processing for Manufacturing #
|
|
# File Author: Marius Adrian Stanciu (c) #
|
|
# Date: 3/10/2019 #
|
|
# MIT Licence #
|
|
# ##########################################################
|
|
|
|
from PyQt6 import QtWidgets, QtGui, QtCore
|
|
from appTool import AppTool
|
|
|
|
from appGUI.GUIElements import FCSpinner, FCDoubleSpinner, RadioSet, FCCheckBox, OptionalInputSection, FCComboBox, \
|
|
FCButton, FCLabel, VerticalScrollArea, FCGridLayout, FCFrame
|
|
from camlib import grace
|
|
|
|
from copy import deepcopy
|
|
import numpy as np
|
|
|
|
import shapely.affinity as affinity
|
|
from shapely.ops import unary_union, linemerge, snap
|
|
from shapely.geometry import LineString, MultiLineString, Polygon
|
|
|
|
import gettext
|
|
import appTranslation as fcTranslate
|
|
import builtins
|
|
import logging
|
|
|
|
fcTranslate.apply_language('strings')
|
|
if '_' not in builtins.__dict__:
|
|
_ = gettext.gettext
|
|
|
|
log = logging.getLogger('base')
|
|
|
|
|
|
class Panelize(AppTool):
|
|
|
|
pluginName = _("Panelize PCB")
|
|
|
|
def __init__(self, app):
|
|
AppTool.__init__(self, app)
|
|
self.decimals = app.decimals
|
|
self.app = app
|
|
|
|
# #############################################################################
|
|
# ######################### Tool GUI ##########################################
|
|
# #############################################################################
|
|
self.ui = PanelizeUI(layout=self.layout, app=self.app)
|
|
self.pluginName = self.ui.pluginName
|
|
self.connect_signals_at_init()
|
|
|
|
# list to hold the temporary objects
|
|
self.objs = []
|
|
|
|
# final name for the panel object
|
|
self.outname = ""
|
|
|
|
# flag to signal the constrain was activated
|
|
self.constrain_flag = False
|
|
|
|
def run(self, toggle=True):
|
|
self.app.defaults.report_usage("ToolPanelize()")
|
|
|
|
if toggle:
|
|
# if the splitter is hidden, display it
|
|
if self.app.ui.splitter.sizes()[0] == 0:
|
|
self.app.ui.splitter.setSizes([1, 1])
|
|
|
|
# if the Tool Tab is hidden display it, else hide it but only if the objectName is the same
|
|
found_idx = None
|
|
for idx in range(self.app.ui.notebook.count()):
|
|
if self.app.ui.notebook.widget(idx).objectName() == "plugin_tab":
|
|
found_idx = idx
|
|
break
|
|
# show the Tab
|
|
if not found_idx:
|
|
try:
|
|
self.app.ui.notebook.addTab(self.app.ui.plugin_tab, _("Plugin"))
|
|
except RuntimeError:
|
|
self.app.ui.plugin_tab = QtWidgets.QWidget()
|
|
self.app.ui.plugin_tab.setObjectName("plugin_tab")
|
|
self.app.ui.plugin_tab_layout = QtWidgets.QVBoxLayout(self.app.ui.plugin_tab)
|
|
self.app.ui.plugin_tab_layout.setContentsMargins(2, 2, 2, 2)
|
|
|
|
self.app.ui.plugin_scroll_area = VerticalScrollArea()
|
|
self.app.ui.plugin_tab_layout.addWidget(self.app.ui.plugin_scroll_area)
|
|
self.app.ui.notebook.addTab(self.app.ui.plugin_tab, _("Plugin"))
|
|
# focus on Tool Tab
|
|
self.app.ui.notebook.setCurrentWidget(self.app.ui.plugin_tab)
|
|
|
|
try:
|
|
if self.app.ui.plugin_scroll_area.widget().objectName() == self.pluginName and found_idx:
|
|
# if the Tool Tab is not focused, focus on it
|
|
if not self.app.ui.notebook.currentWidget() is self.app.ui.plugin_tab:
|
|
# focus on Tool Tab
|
|
self.app.ui.notebook.setCurrentWidget(self.app.ui.plugin_tab)
|
|
else:
|
|
# else remove the Tool Tab
|
|
self.app.ui.notebook.setCurrentWidget(self.app.ui.properties_tab)
|
|
self.app.ui.notebook.removeTab(2)
|
|
|
|
# if there are no objects loaded in the app then hide the Notebook widget
|
|
if not self.app.collection.get_list():
|
|
self.app.ui.splitter.setSizes([0, 1])
|
|
except AttributeError:
|
|
pass
|
|
else:
|
|
if self.app.ui.splitter.sizes()[0] == 0:
|
|
self.app.ui.splitter.setSizes([1, 1])
|
|
|
|
AppTool.run(self)
|
|
self.set_tool_ui()
|
|
|
|
self.app.ui.notebook.setTabText(2, _("Panelization"))
|
|
|
|
def install(self, icon=None, separator=None, **kwargs):
|
|
AppTool.install(self, icon, separator, shortcut='Alt+Z', **kwargs)
|
|
|
|
def connect_signals_at_init(self):
|
|
self.ui.level.toggled.connect(self.on_level_changed)
|
|
self.ui.reference_radio.activated_custom.connect(self.on_reference_radio_changed)
|
|
self.ui.panelize_object_button.clicked.connect(self.on_panelize)
|
|
self.ui.type_obj_combo.currentIndexChanged.connect(self.on_type_obj_index_changed)
|
|
self.ui.type_box_combo.currentIndexChanged.connect(self.on_type_box_index_changed)
|
|
|
|
self.app.proj_selection_changed.connect(self.on_object_selection_changed)
|
|
|
|
self.ui.reset_button.clicked.connect(self.set_tool_ui)
|
|
|
|
def set_tool_ui(self):
|
|
self.clear_ui(self.layout)
|
|
self.ui = PanelizeUI(layout=self.layout, app=self.app)
|
|
self.pluginName = self.ui.pluginName
|
|
|
|
self.reset_fields()
|
|
|
|
self.ui.reference_radio.set_value('bbox')
|
|
|
|
# SELECT THE CURRENT OBJECT
|
|
obj = self.app.collection.get_active()
|
|
if obj:
|
|
obj_name = obj.options['name']
|
|
if obj.kind == 'gerber':
|
|
# run once to make sure that the obj_type attribute is updated in the FCComboBox
|
|
self.ui.type_obj_combo.set_value(_("Gerber"))
|
|
elif obj.kind == 'excellon':
|
|
# run once to make sure that the obj_type attribute is updated in the FCComboBox
|
|
self.ui.type_obj_combo.set_value(_("Excellon"))
|
|
elif obj.kind == 'geometry':
|
|
# run once to make sure that the obj_type attribute is updated in the FCComboBox
|
|
self.ui.type_obj_combo.set_value(_("Geometry"))
|
|
|
|
self.ui.object_combo.set_value(obj_name)
|
|
|
|
sp_c = self.app.defaults["tools_panelize_spacing_columns"] if \
|
|
self.app.defaults["tools_panelize_spacing_columns"] else 0.0
|
|
self.ui.spacing_columns.set_value(float(sp_c))
|
|
|
|
sp_r = self.app.defaults["tools_panelize_spacing_rows"] if \
|
|
self.app.defaults["tools_panelize_spacing_rows"] else 0.0
|
|
self.ui.spacing_rows.set_value(float(sp_r))
|
|
|
|
rr = self.app.defaults["tools_panelize_rows"] if \
|
|
self.app.defaults["tools_panelize_rows"] else 0.0
|
|
self.ui.rows.set_value(int(rr))
|
|
|
|
cc = self.app.defaults["tools_panelize_columns"] if \
|
|
self.app.defaults["tools_panelize_columns"] else 0.0
|
|
self.ui.columns.set_value(int(cc))
|
|
|
|
optimized_path_cb = self.app.defaults["tools_panelize_optimization"] if \
|
|
self.app.defaults["tools_panelize_optimization"] else True
|
|
self.ui.optimization_cb.set_value(optimized_path_cb)
|
|
|
|
c_cb = self.app.defaults["tools_panelize_constrain"] if \
|
|
self.app.defaults["tools_panelize_constrain"] else False
|
|
self.ui.constrain_cb.set_value(c_cb)
|
|
|
|
x_w = self.app.defaults["tools_panelize_constrainx"] if \
|
|
self.app.defaults["tools_panelize_constrainx"] else 0.0
|
|
self.ui.x_width_entry.set_value(float(x_w))
|
|
|
|
y_w = self.app.defaults["tools_panelize_constrainy"] if \
|
|
self.app.defaults["tools_panelize_constrainy"] else 0.0
|
|
self.ui.y_height_entry.set_value(float(y_w))
|
|
|
|
panel_type = self.app.defaults["tools_panelize_panel_type"] if \
|
|
self.app.defaults["tools_panelize_panel_type"] else 'gerber'
|
|
self.ui.panel_type_radio.set_value(panel_type)
|
|
|
|
self.ui.on_panel_type(val=panel_type)
|
|
|
|
# run once the following so the obj_type attribute is updated in the FCComboBoxes
|
|
# such that the last loaded object is populated in the combo boxes
|
|
self.on_type_obj_index_changed()
|
|
self.on_type_box_index_changed()
|
|
|
|
self.connect_signals_at_init()
|
|
|
|
# Show/Hide Advanced Options
|
|
app_mode = self.app.defaults["global_app_level"]
|
|
self.change_level(app_mode)
|
|
|
|
def on_type_obj_index_changed(self):
|
|
obj_type = self.ui.type_obj_combo.currentIndex()
|
|
self.ui.object_combo.setRootModelIndex(self.app.collection.index(obj_type, 0, QtCore.QModelIndex()))
|
|
self.ui.object_combo.setCurrentIndex(0)
|
|
|
|
self.ui.object_combo.obj_type = {0: "Gerber", 1: "Excellon", 2: "Geometry"}[obj_type]
|
|
|
|
# hide the panel type for Excellons, the panel can be only of type Geometry or Gerber
|
|
if obj_type != 1: # not Excellon
|
|
self.ui.panel_type_label.setDisabled(False)
|
|
self.ui.panel_type_radio.setDisabled(False)
|
|
panel_type = self.ui.panel_type_radio.get_value()
|
|
self.ui.on_panel_type(val=panel_type)
|
|
else:
|
|
self.ui.panel_type_label.setDisabled(True)
|
|
self.ui.panel_type_radio.setDisabled(True)
|
|
self.ui.optimization_cb.setDisabled(True)
|
|
|
|
if obj_type in [0, 2]:
|
|
# type_box_combo is missing the Excellon therefore it has only index 0 an 1
|
|
self.ui.type_box_combo.setCurrentIndex(0) if obj_type == 0 else self.ui.type_box_combo.setCurrentIndex(1)
|
|
self.ui.panel_type_radio.set_value(self.ui.object_combo.obj_type.lower())
|
|
|
|
def on_type_box_index_changed(self):
|
|
obj_type = self.ui.type_box_combo.currentIndex()
|
|
obj_type = 2 if obj_type == 1 else obj_type
|
|
self.ui.box_combo.setRootModelIndex(self.app.collection.index(obj_type, 0, QtCore.QModelIndex()))
|
|
self.ui.box_combo.setCurrentIndex(0)
|
|
|
|
self.ui.box_combo.obj_type = {0: "Gerber", 2: "Geometry"}[obj_type]
|
|
|
|
def on_reference_radio_changed(self, current_val):
|
|
if current_val == 'object':
|
|
self.ui.type_box_combo.setDisabled(False)
|
|
self.ui.type_box_combo_label.setDisabled(False)
|
|
self.ui.box_combo.setDisabled(False)
|
|
else:
|
|
self.ui.type_box_combo.setDisabled(True)
|
|
self.ui.type_box_combo_label.setDisabled(True)
|
|
self.ui.box_combo.setDisabled(True)
|
|
|
|
def on_object_selection_changed(self, current, previous):
|
|
try:
|
|
name = current.indexes()[0].internalPointer().obj.options['name']
|
|
kind = current.indexes()[0].internalPointer().obj.kind
|
|
|
|
if kind in ['gerber', 'excellon', 'geometry']:
|
|
obj_type = {
|
|
"gerber": _("Gerber"), "excellon": _("Excellon"), "geometry": _("Geometry")
|
|
}[kind]
|
|
|
|
self.ui.type_obj_combo.set_value(obj_type)
|
|
self.ui.type_box_combo.set_value(obj_type)
|
|
|
|
self.ui.object_combo.set_value(name)
|
|
self.ui.box_combo.set_value(name)
|
|
except Exception:
|
|
pass
|
|
|
|
def change_level(self, level):
|
|
"""
|
|
|
|
:param level: application level: either 'b' or 'a'
|
|
:type level: str
|
|
:return:
|
|
"""
|
|
|
|
if level == 'a':
|
|
self.ui.level.setChecked(True)
|
|
else:
|
|
self.ui.level.setChecked(False)
|
|
self.on_level_changed(self.ui.level.isChecked())
|
|
|
|
def on_level_changed(self, checked):
|
|
if not checked:
|
|
self.ui.level.setText('%s' % _('Beginner'))
|
|
self.ui.level.setStyleSheet("""
|
|
QToolButton
|
|
{
|
|
color: green;
|
|
}
|
|
""")
|
|
|
|
# Parameters section
|
|
self.ui.param_label.hide()
|
|
self.ui.gp_frame.hide()
|
|
else:
|
|
self.ui.level.setText('%s' % _('Advanced'))
|
|
self.ui.level.setStyleSheet("""
|
|
QToolButton
|
|
{
|
|
color: red;
|
|
}
|
|
""")
|
|
|
|
# Parameters section
|
|
self.ui.param_label.show()
|
|
self.ui.gp_frame.show()
|
|
|
|
def on_panelize(self):
|
|
name = self.ui.object_combo.currentText()
|
|
|
|
# delete any selection box
|
|
self.app.delete_selection_shape()
|
|
|
|
# Get source object to be panelized.
|
|
try:
|
|
panel_source_obj = self.app.collection.get_by_name(str(name))
|
|
except Exception as e:
|
|
log.error("Panelize.on_panelize() --> %s" % str(e))
|
|
self.app.inform.emit('[ERROR_NOTCL] %s: %s' % (_("Could not retrieve object"), name))
|
|
return
|
|
|
|
if panel_source_obj is None:
|
|
self.app.inform.emit('[ERROR_NOTCL] %s: %s' %
|
|
(_("Object not found"), panel_source_obj))
|
|
return
|
|
|
|
boxname = self.ui.box_combo.currentText()
|
|
|
|
try:
|
|
box = self.app.collection.get_by_name(boxname)
|
|
except Exception as e:
|
|
log.error("Panelize.on_panelize() --> %s" % str(e))
|
|
self.app.inform.emit('[ERROR_NOTCL] %s: %s' % (_("Could not retrieve object"), boxname))
|
|
return
|
|
|
|
if box is None:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s: %s' % (_("No object Box. Using instead"), panel_source_obj))
|
|
self.ui.reference_radio.set_value('bbox')
|
|
|
|
if self.ui.reference_radio.get_value() == 'bbox':
|
|
box = panel_source_obj
|
|
|
|
self.outname = name + '_panelized'
|
|
|
|
spacing_columns = float(self.ui.spacing_columns.get_value())
|
|
spacing_columns = spacing_columns if spacing_columns is not None else 0
|
|
|
|
spacing_rows = float(self.ui.spacing_rows.get_value())
|
|
spacing_rows = spacing_rows if spacing_rows is not None else 0
|
|
|
|
rows = int(self.ui.rows.get_value())
|
|
rows = rows if rows is not None else 1
|
|
|
|
columns = int(self.ui.columns.get_value())
|
|
columns = columns if columns is not None else 1
|
|
|
|
constrain_dx = float(self.ui.x_width_entry.get_value())
|
|
constrain_dy = float(self.ui.y_height_entry.get_value())
|
|
|
|
panel_type = str(self.ui.panel_type_radio.get_value())
|
|
|
|
if 0 in {columns, rows}:
|
|
self.app.inform.emit('[ERROR_NOTCL] %s' %
|
|
_("Columns or Rows are zero value. Change them to a positive integer."))
|
|
return
|
|
|
|
xmin, ymin, xmax, ymax = box.bounds()
|
|
lenghtx = xmax - xmin + spacing_columns
|
|
lenghty = ymax - ymin + spacing_rows
|
|
|
|
# check if constrain within an area is desired
|
|
if self.ui.constrain_cb.isChecked():
|
|
panel_lengthx = ((xmax - xmin) * columns) + (spacing_columns * (columns - 1))
|
|
panel_lengthy = ((ymax - ymin) * rows) + (spacing_rows * (rows - 1))
|
|
|
|
# adjust the number of columns and/or rows so the panel will fit within the panel constraint area
|
|
if (panel_lengthx > constrain_dx) or (panel_lengthy > constrain_dy):
|
|
self.constrain_flag = True
|
|
|
|
while panel_lengthx > constrain_dx:
|
|
columns -= 1
|
|
panel_lengthx = ((xmax - xmin) * columns) + (spacing_columns * (columns - 1))
|
|
while panel_lengthy > constrain_dy:
|
|
rows -= 1
|
|
panel_lengthy = ((ymax - ymin) * rows) + (spacing_rows * (rows - 1))
|
|
|
|
# ############################################################################################################
|
|
# make a copy of the panelized Excellon or Geometry tools
|
|
# ############################################################################################################
|
|
if panel_source_obj.kind == 'excellon' or panel_source_obj.kind == 'geometry':
|
|
copied_tools = {}
|
|
for tt, tt_val in list(panel_source_obj.tools.items()):
|
|
copied_tools[tt] = deepcopy(tt_val)
|
|
|
|
# ############################################################################################################
|
|
# make a copy of the panelized Gerber apertures
|
|
# ############################################################################################################
|
|
if panel_source_obj.kind == 'gerber':
|
|
copied_apertures = {}
|
|
for tt, tt_val in list(panel_source_obj.tools.items()):
|
|
copied_apertures[tt] = deepcopy(tt_val)
|
|
|
|
to_optimize = self.ui.optimization_cb.get_value()
|
|
|
|
def panelize_worker():
|
|
if panel_source_obj is not None:
|
|
self.app.inform.emit(_("Generating panel ... "))
|
|
|
|
def job_init_excellon(obj_fin, app_obj):
|
|
currenty = 0.0
|
|
# init the storage for drills and for slots
|
|
for tool in copied_tools:
|
|
copied_tools[tool]['drills'] = []
|
|
copied_tools[tool]['slots'] = []
|
|
obj_fin.tools = copied_tools
|
|
obj_fin.solid_geometry = []
|
|
|
|
for option in panel_source_obj.options:
|
|
if option != 'name':
|
|
try:
|
|
obj_fin.options[option] = panel_source_obj.options[option]
|
|
except KeyError:
|
|
log.warning("Failed to copy option. %s" % str(option))
|
|
|
|
# calculate the total number of drills and slots
|
|
geo_len_drills = 0
|
|
geo_len_slots = 0
|
|
for tool in copied_tools:
|
|
geo_len_drills += len(copied_tools[tool]['drills'])
|
|
geo_len_slots += len(copied_tools[tool]['slots'])
|
|
|
|
# panelization
|
|
element = 0
|
|
for row in range(rows):
|
|
currentx = 0.0
|
|
for col in range(columns):
|
|
element += 1
|
|
old_disp_number = 0
|
|
|
|
for tool in panel_source_obj.tools:
|
|
if 'drills' in panel_source_obj.tools[tool]:
|
|
if panel_source_obj.tools[tool]['drills']:
|
|
drill_nr = 0
|
|
for drill in panel_source_obj.tools[tool]['drills']:
|
|
# graceful abort requested by the user
|
|
if self.app.abort_flag:
|
|
raise grace
|
|
|
|
# offset / panelization
|
|
point_offseted = affinity.translate(drill, currentx, currenty)
|
|
obj_fin.tools[tool]['drills'].append(point_offseted)
|
|
|
|
# update progress
|
|
drill_nr += 1
|
|
disp_number = int(np.interp(drill_nr, [0, geo_len_drills], [0, 100]))
|
|
if old_disp_number < disp_number <= 100:
|
|
self.app.proc_container.update_view_text(' %s: %d D:%d%%' %
|
|
(_("Copy"),
|
|
int(element),
|
|
disp_number))
|
|
old_disp_number = disp_number
|
|
else:
|
|
panel_source_obj.tools[tool]['drills'] = []
|
|
|
|
if 'slots' in panel_source_obj.tools[tool]:
|
|
if panel_source_obj.tools[tool]['slots']:
|
|
slot_nr = 0
|
|
for slot in panel_source_obj.tools[tool]['slots']:
|
|
# graceful abort requested by the user
|
|
if self.app.abort_flag:
|
|
raise grace
|
|
|
|
# offset / panelization
|
|
start_offseted = affinity.translate(slot[0], currentx, currenty)
|
|
stop_offseted = affinity.translate(slot[1], currentx, currenty)
|
|
offseted_slot = (
|
|
start_offseted,
|
|
stop_offseted
|
|
)
|
|
obj_fin.tools[tool]['slots'].append(offseted_slot)
|
|
|
|
# update progress
|
|
slot_nr += 1
|
|
disp_number = int(np.interp(slot_nr, [0, geo_len_slots], [0, 100]))
|
|
if old_disp_number < disp_number <= 100:
|
|
self.app.proc_container.update_view_text(' %s: %d S:%d%%' %
|
|
(_("Copy"),
|
|
int(element),
|
|
disp_number))
|
|
old_disp_number = disp_number
|
|
else:
|
|
panel_source_obj.tools[tool]['slots'] = []
|
|
|
|
currentx += lenghtx
|
|
currenty += lenghty
|
|
|
|
obj_fin.create_geometry()
|
|
obj_fin.zeros = panel_source_obj.zeros
|
|
obj_fin.units = panel_source_obj.units
|
|
app_obj.inform.emit('%s' % _("Generating panel ... Adding the source code."))
|
|
obj_fin.source_file = self.app.f_handlers.export_excellon(obj_name=self.outname,
|
|
filename=None,
|
|
local_use=obj_fin,
|
|
use_thread=False)
|
|
app_obj.proc_container.update_view_text('')
|
|
|
|
def job_init_geometry(new_obj, app_obj):
|
|
currentx = 0.0
|
|
currenty = 0.0
|
|
|
|
def translate_recursion(geom):
|
|
if type(geom) == list:
|
|
geoms = []
|
|
for local_geom in geom:
|
|
res_geo = translate_recursion(local_geom)
|
|
try:
|
|
geoms += res_geo
|
|
except TypeError:
|
|
geoms.append(res_geo)
|
|
return geoms
|
|
else:
|
|
return affinity.translate(geom, xoff=currentx, yoff=currenty)
|
|
|
|
new_obj.solid_geometry = []
|
|
|
|
# create the initial structure on which to create the panel
|
|
if panel_source_obj.kind == 'geometry':
|
|
new_obj.multigeo = panel_source_obj.multigeo
|
|
new_obj.tools = copied_tools
|
|
if panel_source_obj.multigeo is True:
|
|
for tool in panel_source_obj.tools:
|
|
new_obj.tools[tool]['solid_geometry'] = []
|
|
else:
|
|
new_obj.solid_geometry = panel_source_obj.solid_geometry
|
|
elif panel_source_obj.kind == 'gerber':
|
|
new_obj.tools = copied_apertures
|
|
for ap in new_obj.tools:
|
|
new_obj.tools[ap]['geometry'] = []
|
|
|
|
# find the number of polygons in the source solid_geometry
|
|
geo_len = 0
|
|
if panel_source_obj.kind == 'geometry':
|
|
if panel_source_obj.multigeo is True:
|
|
for tool in panel_source_obj.tools:
|
|
try:
|
|
geo_len += len(panel_source_obj.tools[tool]['solid_geometry'])
|
|
except TypeError:
|
|
geo_len += 1
|
|
else:
|
|
try:
|
|
geo_len = len(panel_source_obj.solid_geometry)
|
|
except TypeError:
|
|
geo_len = 1
|
|
elif panel_source_obj.kind == 'gerber':
|
|
for ap in panel_source_obj.tools:
|
|
if 'geometry' in panel_source_obj.tools[ap]:
|
|
try:
|
|
geo_len += len(panel_source_obj.tools[ap]['geometry'])
|
|
except TypeError:
|
|
geo_len += 1
|
|
|
|
element = 0
|
|
for row in range(rows):
|
|
currentx = 0.0
|
|
|
|
for col in range(columns):
|
|
element += 1
|
|
old_disp_number = 0
|
|
|
|
# Will panelize a Geometry Object
|
|
if panel_source_obj.kind == 'geometry':
|
|
if panel_source_obj.multigeo is True:
|
|
for tool in panel_source_obj.tools:
|
|
# graceful abort requested by the user
|
|
if app_obj.abort_flag:
|
|
raise grace
|
|
|
|
# calculate the number of polygons
|
|
try:
|
|
geo_len = len(panel_source_obj.tools[tool]['solid_geometry'])
|
|
except TypeError:
|
|
geo_len = 1
|
|
|
|
# panelization
|
|
pol_nr = 0
|
|
|
|
trans_geo = translate_recursion(panel_source_obj.tools[tool]['solid_geometry'])
|
|
try:
|
|
for trans_it in trans_geo:
|
|
if not trans_it.is_empty:
|
|
new_obj.tools[tool]['solid_geometry'].append(trans_it)
|
|
|
|
# update progress
|
|
pol_nr += 1
|
|
disp_number = int(np.interp(pol_nr, [0, geo_len], [0, 100]))
|
|
if old_disp_number < disp_number <= 100:
|
|
app_obj.proc_container.update_view_text(
|
|
' %s: %d %d%%' % (_("Copy"), int(element), disp_number))
|
|
old_disp_number = disp_number
|
|
except TypeError:
|
|
if not trans_geo.is_empty:
|
|
new_obj.tools[tool]['solid_geometry'].append(trans_geo)
|
|
|
|
# update progress
|
|
pol_nr += 1
|
|
disp_number = int(np.interp(pol_nr, [0, geo_len], [0, 100]))
|
|
if old_disp_number < disp_number <= 100:
|
|
app_obj.proc_container.update_view_text(
|
|
' %s: %d %d%%' % (_("Copy"), int(element), disp_number))
|
|
old_disp_number = disp_number
|
|
|
|
# #####################################################################################
|
|
# ########## Panelize the solid_geometry - always done #############################
|
|
# #####################################################################################
|
|
# graceful abort requested by the user
|
|
if app_obj.abort_flag:
|
|
raise grace
|
|
|
|
# calculate the number of polygons
|
|
try:
|
|
geo_len = len(panel_source_obj.solid_geometry)
|
|
except TypeError:
|
|
geo_len = 1
|
|
|
|
# panelization
|
|
pol_nr = 0
|
|
try:
|
|
for geo_el in panel_source_obj.solid_geometry:
|
|
if app_obj.abort_flag:
|
|
# graceful abort requested by the user
|
|
raise grace
|
|
|
|
trans_geo = translate_recursion(geo_el)
|
|
new_obj.solid_geometry.append(trans_geo)
|
|
|
|
# update progress
|
|
pol_nr += 1
|
|
disp_number = int(np.interp(pol_nr, [0, geo_len], [0, 100]))
|
|
if old_disp_number < disp_number <= 100:
|
|
app_obj.proc_container.update_view_text(
|
|
' %s: %d %d%%' % (_("Copy"), int(element), disp_number))
|
|
old_disp_number = disp_number
|
|
|
|
except TypeError:
|
|
trans_geo = translate_recursion(panel_source_obj.solid_geometry)
|
|
new_obj.solid_geometry.append(trans_geo)
|
|
|
|
# Will panelize a Gerber Object
|
|
if panel_source_obj.kind == 'gerber':
|
|
# graceful abort requested by the user
|
|
if self.app.abort_flag:
|
|
raise grace
|
|
|
|
for apid in panel_source_obj.tools:
|
|
# graceful abort requested by the user
|
|
if app_obj.abort_flag:
|
|
raise grace
|
|
|
|
if 'geometry' in panel_source_obj.tools[apid]:
|
|
# calculate the number of polygons
|
|
try:
|
|
geo_len = len(panel_source_obj.tools[apid]['geometry'])
|
|
except TypeError:
|
|
geo_len = 1
|
|
|
|
# panelization -> tools
|
|
pol_nr = 0
|
|
for el in panel_source_obj.tools[apid]['geometry']:
|
|
if app_obj.abort_flag:
|
|
# graceful abort requested by the user
|
|
raise grace
|
|
|
|
new_el = {}
|
|
if 'solid' in el:
|
|
geo_aper = translate_recursion(el['solid'])
|
|
new_el['solid'] = geo_aper
|
|
if 'clear' in el:
|
|
geo_aper = translate_recursion(el['clear'])
|
|
new_el['clear'] = geo_aper
|
|
if 'follow' in el:
|
|
geo_aper = translate_recursion(el['follow'])
|
|
new_el['follow'] = geo_aper
|
|
new_obj.tools[apid]['geometry'].append(deepcopy(new_el))
|
|
|
|
# update progress
|
|
pol_nr += 1
|
|
disp_number = int(np.interp(pol_nr, [0, geo_len], [0, 100]))
|
|
if old_disp_number < disp_number <= 100:
|
|
app_obj.proc_container.update_view_text(
|
|
' %s: %d %d%%' % (_("Copy"), int(element), disp_number))
|
|
old_disp_number = disp_number
|
|
|
|
# #####################################################################################
|
|
# ########## Panelize the solid_geometry - always done #############################
|
|
# #####################################################################################
|
|
try:
|
|
for geo_el in panel_source_obj.solid_geometry:
|
|
# graceful abort requested by the user
|
|
if app_obj.abort_flag:
|
|
raise grace
|
|
|
|
trans_geo = translate_recursion(geo_el)
|
|
new_obj.solid_geometry.append(trans_geo)
|
|
except TypeError:
|
|
trans_geo = translate_recursion(panel_source_obj.solid_geometry)
|
|
new_obj.solid_geometry.append(trans_geo)
|
|
|
|
currentx += lenghtx
|
|
currenty += lenghty
|
|
|
|
# #################################################################################################
|
|
# ########################### Path Optimization ###############################################
|
|
# #################################################################################################
|
|
if panel_source_obj.kind == 'geometry' and panel_source_obj.multigeo is True:
|
|
# I'm going to do this only here as a fix for panelizing cutouts
|
|
# I'm going to separate linestrings out of the solid geometry from other
|
|
# possible type of elements and apply unary_union on them to fuse them
|
|
|
|
if to_optimize is True:
|
|
app_obj.inform.emit('%s' % _("Optimizing the overlapping paths."))
|
|
|
|
for tool in new_obj.tools:
|
|
lines = []
|
|
other_geo = []
|
|
for geo in new_obj.tools[tool]['solid_geometry']:
|
|
if isinstance(geo, LineString):
|
|
lines.append(geo)
|
|
elif isinstance(geo, MultiLineString):
|
|
for line in geo:
|
|
lines.append(line)
|
|
else:
|
|
other_geo.append(geo)
|
|
|
|
if to_optimize is True:
|
|
for idx, line in enumerate(lines):
|
|
for idx_s in range(idx+1, len(lines)):
|
|
line_mod = lines[idx_s]
|
|
# dist = line.distance(line_mod)
|
|
# if dist < 1e-8:
|
|
# print("Disjoint %d: %d -> %s" % (idx, idx_s, str(dist)))
|
|
# print("Distance %f" % dist)
|
|
res = snap(line_mod, line, tolerance=1e-7)
|
|
if res and not res.is_empty:
|
|
lines[idx_s] = res
|
|
|
|
fused_lines = linemerge(lines)
|
|
fused_lines = [unary_union(fused_lines)] if not fused_lines.is_empty else []
|
|
|
|
new_obj.tools[tool]['solid_geometry'] = fused_lines + other_geo
|
|
|
|
if to_optimize is True:
|
|
app_obj.inform.emit('%s' % _("Optimization complete."))
|
|
|
|
if panel_source_obj.kind == 'gerber':
|
|
new_obj.multigeo = True
|
|
|
|
default_data = {}
|
|
for opt_key, opt_val in self.app.options.items():
|
|
if opt_key.find('geometry' + "_") == 0:
|
|
oname = opt_key[len('geometry') + 1:]
|
|
default_data[oname] = self.app.options[opt_key]
|
|
elif opt_key.find('tools_') == 0:
|
|
default_data[opt_key] = self.app.options[opt_key]
|
|
|
|
new_obj.tools = {}
|
|
new_tid = 0
|
|
for apid in new_obj.tools:
|
|
new_tid += 1
|
|
new_sgeo = [g['solid'] for g in new_obj.tools[apid]['geometry'] if 'solid' in g]
|
|
new_sgeo = unary_union(new_sgeo)
|
|
new_obj.tools[new_tid] = {
|
|
'tooldia': self.app.defaults["tools_mill_tooldia"],
|
|
'offset': 'Path',
|
|
'offset_value': 0.0,
|
|
'type': 'Rough',
|
|
'tool_type': 'C1',
|
|
'data': deepcopy(default_data),
|
|
'solid_geometry': deepcopy(new_sgeo)
|
|
}
|
|
new_tid += 1
|
|
new_obj.tools[new_tid] = {
|
|
'tooldia': self.app.defaults["tools_mill_tooldia"],
|
|
'offset': 'Path',
|
|
'offset_value': 0.0,
|
|
'type': 'Rough',
|
|
'tool_type': 'C1',
|
|
'data': deepcopy(default_data),
|
|
'solid_geometry': deepcopy(new_obj.solid_geometry)
|
|
}
|
|
del new_obj.tools
|
|
|
|
app_obj.inform.emit('%s' % _("Generating panel ... Adding the source code."))
|
|
new_obj.source_file = self.app.f_handlers.export_dxf(obj_name=self.outname, filename=None,
|
|
local_use=new_obj, use_thread=False)
|
|
|
|
# new_obj.solid_geometry = unary_union(obj_fin.solid_geometry)
|
|
# app_obj.log.debug("Finished creating a unary_union for the panel.")
|
|
app_obj.proc_container.update_view_text('')
|
|
|
|
def job_init_gerber(new_obj, app_obj):
|
|
currentx = 0.0
|
|
currenty = 0.0
|
|
|
|
def translate_recursion(geom):
|
|
if type(geom) == list:
|
|
geoms = []
|
|
for local_geom in geom:
|
|
res_geo = translate_recursion(local_geom)
|
|
try:
|
|
geoms += res_geo
|
|
except TypeError:
|
|
geoms.append(res_geo)
|
|
return geoms
|
|
else:
|
|
return affinity.translate(geom, xoff=currentx, yoff=currenty)
|
|
|
|
new_obj.solid_geometry = []
|
|
|
|
# create the initial structure on which to create the panel
|
|
if panel_source_obj.kind == 'geometry':
|
|
new_obj.multigeo = panel_source_obj.multigeo
|
|
new_obj.tools = copied_tools
|
|
if panel_source_obj.multigeo is True:
|
|
for tool in panel_source_obj.tools:
|
|
new_obj.tools[tool]['solid_geometry'] = []
|
|
else:
|
|
new_obj.solid_geometry = panel_source_obj.solid_geometry
|
|
elif panel_source_obj.kind == 'gerber':
|
|
new_obj.tools = copied_apertures
|
|
for ap in new_obj.tools:
|
|
new_obj.tools[ap]['geometry'] = []
|
|
|
|
# find the number of polygons in the source solid_geometry
|
|
geo_len = 0
|
|
if panel_source_obj.kind == 'geometry':
|
|
if panel_source_obj.multigeo is True:
|
|
for tool in panel_source_obj.tools:
|
|
try:
|
|
geo_len += len(panel_source_obj.tools[tool]['solid_geometry'])
|
|
except TypeError:
|
|
geo_len += 1
|
|
else:
|
|
try:
|
|
geo_len = len(panel_source_obj.solid_geometry)
|
|
except TypeError:
|
|
geo_len = 1
|
|
elif panel_source_obj.kind == 'gerber':
|
|
for ap in panel_source_obj.tools:
|
|
if 'geometry' in panel_source_obj.tools[ap]:
|
|
try:
|
|
geo_len += len(panel_source_obj.tools[ap]['geometry'])
|
|
except TypeError:
|
|
geo_len += 1
|
|
|
|
element = 0
|
|
for row in range(rows):
|
|
currentx = 0.0
|
|
|
|
for col in range(columns):
|
|
element += 1
|
|
old_disp_number = 0
|
|
|
|
# Will panelize a Geometry Object
|
|
if panel_source_obj.kind == 'geometry':
|
|
if panel_source_obj.multigeo is True:
|
|
for tool in panel_source_obj.tools:
|
|
# graceful abort requested by the user
|
|
if app_obj.abort_flag:
|
|
raise grace
|
|
|
|
# calculate the number of polygons
|
|
try:
|
|
geo_len = len(panel_source_obj.tools[tool]['solid_geometry'])
|
|
except TypeError:
|
|
geo_len = 1
|
|
|
|
# panelization
|
|
pol_nr = 0
|
|
for geo_el in panel_source_obj.tools[tool]['solid_geometry']:
|
|
trans_geo = translate_recursion(geo_el)
|
|
if not trans_geo.is_empty:
|
|
new_obj.tools[tool]['solid_geometry'].append(trans_geo)
|
|
|
|
# update progress
|
|
pol_nr += 1
|
|
disp_number = int(np.interp(pol_nr, [0, geo_len], [0, 100]))
|
|
if old_disp_number < disp_number <= 100:
|
|
app_obj.proc_container.update_view_text(
|
|
' %s: %d %d%%' % (_("Copy"), int(element), disp_number))
|
|
old_disp_number = disp_number
|
|
|
|
# #####################################################################################
|
|
# ########## Panelize the solid_geometry - always done #############################
|
|
# #####################################################################################
|
|
# graceful abort requested by the user
|
|
if app_obj.abort_flag:
|
|
raise grace
|
|
|
|
# calculate the number of polygons
|
|
try:
|
|
geo_len = len(panel_source_obj.solid_geometry)
|
|
except TypeError:
|
|
geo_len = 1
|
|
|
|
# panelization
|
|
pol_nr = 0
|
|
try:
|
|
for geo_el in panel_source_obj.solid_geometry:
|
|
if app_obj.abort_flag:
|
|
# graceful abort requested by the user
|
|
raise grace
|
|
|
|
trans_geo = translate_recursion(geo_el)
|
|
new_obj.solid_geometry.append(trans_geo)
|
|
|
|
# update progress
|
|
pol_nr += 1
|
|
disp_number = int(np.interp(pol_nr, [0, geo_len], [0, 100]))
|
|
if old_disp_number < disp_number <= 100:
|
|
app_obj.proc_container.update_view_text(
|
|
' %s: %d %d%%' % (_("Copy"), int(element), disp_number))
|
|
old_disp_number = disp_number
|
|
|
|
except TypeError:
|
|
trans_geo = translate_recursion(panel_source_obj.solid_geometry)
|
|
new_obj.solid_geometry.append(trans_geo)
|
|
# Will panelize a Gerber Object
|
|
else:
|
|
# graceful abort requested by the user
|
|
if self.app.abort_flag:
|
|
raise grace
|
|
|
|
for apid in panel_source_obj.tools:
|
|
# graceful abort requested by the user
|
|
if app_obj.abort_flag:
|
|
raise grace
|
|
|
|
if 'geometry' in panel_source_obj.tools[apid]:
|
|
# calculate the number of polygons
|
|
try:
|
|
geo_len = len(panel_source_obj.tools[apid]['geometry'])
|
|
except TypeError:
|
|
geo_len = 1
|
|
|
|
# panelization -> apertures
|
|
pol_nr = 0
|
|
for el in panel_source_obj.tools[apid]['geometry']:
|
|
if app_obj.abort_flag:
|
|
# graceful abort requested by the user
|
|
raise grace
|
|
|
|
new_el = {}
|
|
if 'solid' in el:
|
|
geo_aper = translate_recursion(el['solid'])
|
|
new_el['solid'] = geo_aper
|
|
if 'clear' in el:
|
|
geo_aper = translate_recursion(el['clear'])
|
|
new_el['clear'] = geo_aper
|
|
if 'follow' in el:
|
|
geo_aper = translate_recursion(el['follow'])
|
|
new_el['follow'] = geo_aper
|
|
new_obj.tools[apid]['geometry'].append(deepcopy(new_el))
|
|
|
|
# update progress
|
|
pol_nr += 1
|
|
disp_number = int(np.interp(pol_nr, [0, geo_len], [0, 100]))
|
|
if old_disp_number < disp_number <= 100:
|
|
app_obj.proc_container.update_view_text(
|
|
' %s: %d %d%%' % (_("Copy"), int(element), disp_number))
|
|
old_disp_number = disp_number
|
|
|
|
# #####################################################################################
|
|
# ########## Panelize the solid_geometry - always done #############################
|
|
# #####################################################################################
|
|
try:
|
|
for geo_el in panel_source_obj.solid_geometry:
|
|
# graceful abort requested by the user
|
|
if app_obj.abort_flag:
|
|
raise grace
|
|
|
|
trans_geo = translate_recursion(geo_el)
|
|
new_obj.solid_geometry.append(trans_geo)
|
|
except TypeError:
|
|
trans_geo = translate_recursion(panel_source_obj.solid_geometry)
|
|
new_obj.solid_geometry.append(trans_geo)
|
|
|
|
currentx += lenghtx
|
|
currenty += lenghty
|
|
|
|
if panel_source_obj.kind == 'geometry':
|
|
new_obj.multitool = False
|
|
new_obj.multigeo = True
|
|
new_obj.source_file = ''
|
|
new_obj.follow = False
|
|
new_obj.follow_geometry = []
|
|
|
|
if panel_source_obj.multigeo is True:
|
|
new_solid_list = []
|
|
for tool in new_obj.tools:
|
|
if 'solid_geometry' in new_obj.tools[tool]:
|
|
for geo in new_obj.tools[tool]['solid_geometry']:
|
|
try:
|
|
geo = linemerge(geo)
|
|
except Exception:
|
|
pass
|
|
|
|
try:
|
|
geo = Polygon(geo)
|
|
new_el = {
|
|
'solid': geo,
|
|
'follow': geo.exterior
|
|
}
|
|
except Exception:
|
|
new_el = {
|
|
'solid': geo,
|
|
'follow': geo
|
|
}
|
|
new_solid_list.append(deepcopy(new_el))
|
|
|
|
new_obj.tools = {
|
|
0: {
|
|
'type': 'REG',
|
|
'size': 0.0,
|
|
'geometry': deepcopy(new_solid_list)
|
|
}
|
|
}
|
|
all_geo = [g['solid'] for g in new_solid_list if 'solid' in g]
|
|
all_geo = unary_union(all_geo)
|
|
new_obj.solid_geometry = deepcopy(all_geo)
|
|
del new_obj.tools
|
|
else:
|
|
new_obj.tools = {
|
|
0: {
|
|
'type': 'REG',
|
|
'size': 0.0,
|
|
'geometry': deepcopy(new_obj.solid_geometry)
|
|
}
|
|
}
|
|
new_obj.solid_geometry = deepcopy(new_obj.solid_geometry)
|
|
del new_obj.tools
|
|
|
|
app_obj.inform.emit('%s' % _("Generating panel ... Adding the source code."))
|
|
|
|
new_obj.source_file = self.app.f_handlers.export_gerber(obj_name=self.outname, filename=None,
|
|
local_use=new_obj, use_thread=False)
|
|
|
|
# new_obj.solid_geometry = unary_union(new_obj.solid_geometry)
|
|
# app_obj.log.debug("Finished creating a unary_union for the panel.")
|
|
app_obj.proc_container.update_view_text('')
|
|
|
|
self.app.inform.emit('%s: %d' % (_("Generating panel... Spawning copies"), (int(rows * columns))))
|
|
if panel_source_obj.kind == 'excellon':
|
|
self.app.app_obj.new_object(
|
|
"excellon", self.outname, job_init_excellon, plot=True, autoselected=True)
|
|
else:
|
|
if panel_type == 'geometry':
|
|
self.app.app_obj.new_object(
|
|
'geometry', self.outname, job_init_geometry, plot=True, autoselected=True)
|
|
if panel_type == 'gerber':
|
|
self.app.app_obj.new_object(
|
|
'gerber', self.outname, job_init_gerber, plot=True, autoselected=True)
|
|
|
|
if self.constrain_flag is False:
|
|
self.app.inform.emit('[success] %s' % _("Done."))
|
|
else:
|
|
self.constrain_flag = False
|
|
self.app.inform.emit(_("{text} Too big for the constrain area. "
|
|
"Final panel has {col} columns and {row} rows").format(
|
|
text='[WARNING] ', col=columns, row=rows))
|
|
|
|
def job_thread(app_obj):
|
|
with self.app.proc_container.new('%s...' % _("Working")):
|
|
try:
|
|
panelize_worker()
|
|
app_obj.inform.emit('[success] %s' % _("Panel created successfully."))
|
|
except Exception as ee:
|
|
log.error(str(ee))
|
|
return
|
|
|
|
self.app.collection.promise(self.outname)
|
|
self.app.worker_task.emit({'fcn': job_thread, 'params': [self.app]})
|
|
|
|
def reset_fields(self):
|
|
self.ui.object_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
|
|
self.ui.box_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
|
|
|
|
|
|
class PanelizeUI:
|
|
|
|
pluginName = _("Panelization")
|
|
|
|
def __init__(self, layout, app):
|
|
self.app = app
|
|
self.decimals = self.app.decimals
|
|
self.layout = layout
|
|
|
|
self.tools_frame = QtWidgets.QFrame()
|
|
self.tools_frame.setContentsMargins(0, 0, 0, 0)
|
|
self.layout.addWidget(self.tools_frame)
|
|
self.tools_box = QtWidgets.QVBoxLayout()
|
|
self.tools_box.setContentsMargins(0, 0, 0, 0)
|
|
self.tools_frame.setLayout(self.tools_box)
|
|
|
|
self.title_box = QtWidgets.QHBoxLayout()
|
|
self.tools_box.addLayout(self.title_box)
|
|
|
|
# ## Title
|
|
title_label = FCLabel("%s" % self.pluginName)
|
|
title_label.setStyleSheet("""
|
|
QLabel
|
|
{
|
|
font-size: 16px;
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
self.title_box.addWidget(title_label)
|
|
|
|
# App Level label
|
|
self.level = QtWidgets.QToolButton()
|
|
self.level.setToolTip(
|
|
_(
|
|
"Beginner Mode - many parameters are hidden.\n"
|
|
"Advanced Mode - full control.\n"
|
|
"Permanent change is done in 'Preferences' menu."
|
|
)
|
|
)
|
|
self.level.setCheckable(True)
|
|
self.title_box.addWidget(self.level)
|
|
|
|
# #############################################################################################################
|
|
# Source Object Frame
|
|
# #############################################################################################################
|
|
self.object_label = FCLabel('<span style="color:darkorange;"><b>%s</b></span>' % _("Source Object"))
|
|
self.object_label.setToolTip(
|
|
_("Specify the type of object to be panelized\n"
|
|
"It can be of type: Gerber, Excellon or Geometry.\n"
|
|
"The selection here decide the type of objects that will be\n"
|
|
"in the Object combobox.")
|
|
)
|
|
self.tools_box.addWidget(self.object_label)
|
|
|
|
obj_frame = FCFrame()
|
|
self.tools_box.addWidget(obj_frame)
|
|
|
|
# Grid Layout
|
|
grid0 = FCGridLayout(v_spacing=5, h_spacing=3)
|
|
obj_frame.setLayout(grid0)
|
|
|
|
# Type of object to be panelized
|
|
self.type_object_label = FCLabel('%s:' % _("Target"))
|
|
|
|
self.type_obj_combo = FCComboBox()
|
|
self.type_obj_combo.addItems([_("Gerber"), _("Excellon"), _("Geometry")])
|
|
self.type_obj_combo.setItemIcon(0, QtGui.QIcon(self.app.resource_location + "/flatcam_icon16.png"))
|
|
self.type_obj_combo.setItemIcon(1, QtGui.QIcon(self.app.resource_location + "/drill16.png"))
|
|
self.type_obj_combo.setItemIcon(2, QtGui.QIcon(self.app.resource_location + "/geometry16.png"))
|
|
|
|
grid0.addWidget(self.type_object_label, 2, 0)
|
|
grid0.addWidget( self.type_obj_combo, 2, 1)
|
|
|
|
# Object to be panelized
|
|
self.object_combo = FCComboBox()
|
|
self.object_combo.setModel(self.app.collection)
|
|
self.object_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
|
|
self.object_combo.is_last = True
|
|
|
|
self.object_combo.setToolTip(
|
|
_("Object to be panelized. This means that it will\n"
|
|
"be duplicated in an array of rows and columns.")
|
|
)
|
|
|
|
grid0.addWidget(self.object_combo, 4, 0, 1, 2)
|
|
|
|
# #############################################################################################################
|
|
# Reference Object Frame
|
|
# #############################################################################################################
|
|
# Type of box Panel object
|
|
self.box_label = FCLabel('<span style="color:green;"><b>%s</b></span>' % _("Reference"))
|
|
self.box_label.setToolTip(
|
|
_("Choose the reference for panelization:\n"
|
|
"- Object = the bounding box of a different object\n"
|
|
"- Bounding Box = the bounding box of the object to be panelized\n"
|
|
"\n"
|
|
"The reference is useful when doing panelization for more than one\n"
|
|
"object. The spacings (really offsets) will be applied in reference\n"
|
|
"to this reference object therefore maintaining the panelized\n"
|
|
"objects in sync.")
|
|
)
|
|
self.tools_box.addWidget(self.box_label)
|
|
|
|
pr_frame = FCFrame()
|
|
self.tools_box.addWidget(pr_frame)
|
|
|
|
# Grid Layout
|
|
grid1 = FCGridLayout(v_spacing=5, h_spacing=3)
|
|
pr_frame.setLayout(grid1)
|
|
|
|
self.reference_radio = RadioSet([{'label': _('Object'), 'value': 'object'},
|
|
{'label': _('Bounding Box'), 'value': 'bbox'}])
|
|
grid1.addWidget(self.reference_radio, 0, 0, 1, 2)
|
|
|
|
# Type of Box Object to be used as an envelope for panelization
|
|
self.type_box_combo = FCComboBox()
|
|
self.type_box_combo.addItems([_("Gerber"), _("Geometry")])
|
|
|
|
# we get rid of item1 ("Excellon") as it is not suitable for use as a "box" for panelizing
|
|
# self.type_box_combo.view().setRowHidden(1, True)
|
|
self.type_box_combo.setItemIcon(0, QtGui.QIcon(self.app.resource_location + "/flatcam_icon16.png"))
|
|
self.type_box_combo.setItemIcon(1, QtGui.QIcon(self.app.resource_location + "/geometry16.png"))
|
|
|
|
self.type_box_combo_label = FCLabel('%s:' % _("Box Type"))
|
|
self.type_box_combo_label.setToolTip(
|
|
_("Specify the type of object to be used as an container for\n"
|
|
"panelization. It can be: Gerber or Geometry type.\n"
|
|
"The selection here decide the type of objects that will be\n"
|
|
"in the Box Object combobox.")
|
|
)
|
|
grid1.addWidget(self.type_box_combo_label, 2, 0)
|
|
grid1.addWidget(self.type_box_combo, 2, 1)
|
|
|
|
# Box
|
|
self.box_combo = FCComboBox()
|
|
self.box_combo.setModel(self.app.collection)
|
|
self.box_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
|
|
# self.box_combo.is_last = True
|
|
|
|
self.box_combo.setToolTip(
|
|
_("The actual object that is used as container for the\n "
|
|
"selected object that is to be panelized.")
|
|
)
|
|
grid1.addWidget(self.box_combo, 4, 0, 1, 2)
|
|
|
|
# #############################################################################################################
|
|
# Panel Data Frame
|
|
# #############################################################################################################
|
|
panel_data_label = FCLabel('<span style="color:red;"><b>%s</b></span>' % _("Panel Data"))
|
|
panel_data_label.setToolTip(
|
|
_("This informations will shape the resulting panel.\n"
|
|
"The number of rows and columns will set how many\n"
|
|
"duplicates of the original geometry will be generated.\n"
|
|
"\n"
|
|
"The spacings will set the distance between any two\n"
|
|
"elements of the panel array.")
|
|
)
|
|
self.tools_box.addWidget(panel_data_label)
|
|
|
|
pd_frame = FCFrame()
|
|
self.tools_box.addWidget(pd_frame)
|
|
|
|
grid2 = FCGridLayout(v_spacing=5, h_spacing=3)
|
|
pd_frame.setLayout(grid2)
|
|
|
|
# Spacing Columns
|
|
self.spacing_columns = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.spacing_columns.set_range(0, 9999)
|
|
self.spacing_columns.set_precision(4)
|
|
|
|
self.spacing_columns_label = FCLabel('%s:' % _("Spacing cols"))
|
|
self.spacing_columns_label.setToolTip(
|
|
_("Spacing between columns of the desired panel.\n"
|
|
"In current units.")
|
|
)
|
|
grid2.addWidget(self.spacing_columns_label, 0, 0)
|
|
grid2.addWidget(self.spacing_columns, 0, 1)
|
|
|
|
# Spacing Rows
|
|
self.spacing_rows = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.spacing_rows.set_range(0, 9999)
|
|
self.spacing_rows.set_precision(4)
|
|
|
|
self.spacing_rows_label = FCLabel('%s:' % _("Spacing rows"))
|
|
self.spacing_rows_label.setToolTip(
|
|
_("Spacing between rows of the desired panel.\n"
|
|
"In current units.")
|
|
)
|
|
grid2.addWidget(self.spacing_rows_label, 2, 0)
|
|
grid2.addWidget(self.spacing_rows, 2, 1)
|
|
|
|
# Columns
|
|
self.columns = FCSpinner(callback=self.confirmation_message_int)
|
|
self.columns.set_range(0, 10000)
|
|
|
|
self.columns_label = FCLabel('%s:' % _("Columns"))
|
|
self.columns_label.setToolTip(
|
|
_("Number of columns of the desired panel")
|
|
)
|
|
grid2.addWidget(self.columns_label, 4, 0)
|
|
grid2.addWidget(self.columns, 4, 1)
|
|
|
|
# Rows
|
|
self.rows = FCSpinner(callback=self.confirmation_message_int)
|
|
self.rows.set_range(0, 10000)
|
|
|
|
self.rows_label = FCLabel('%s:' % _("Rows"))
|
|
self.rows_label.setToolTip(
|
|
_("Number of rows of the desired panel")
|
|
)
|
|
grid2.addWidget(self.rows_label, 6, 0)
|
|
grid2.addWidget(self.rows, 6, 1)
|
|
|
|
# #############################################################################################################
|
|
# COMMON PARAMETERS Frame
|
|
# #############################################################################################################
|
|
self.param_label = FCLabel('<span style="color:blue;"><b>%s</b></span>' % _("Parameters"))
|
|
self.param_label.setToolTip(_("Parameters that are common for all tools."))
|
|
self.tools_box.addWidget(self.param_label)
|
|
|
|
self.gp_frame = FCFrame()
|
|
self.tools_box.addWidget(self.gp_frame)
|
|
|
|
grid3 = FCGridLayout(v_spacing=5, h_spacing=3)
|
|
self.gp_frame.setLayout(grid3)
|
|
|
|
# Type of resulting Panel object
|
|
self.panel_type_radio = RadioSet([{'label': _('Gerber'), 'value': 'gerber'},
|
|
{'label': _('Geo'), 'value': 'geometry'}])
|
|
self.panel_type_label = FCLabel("<b>%s:</b>" % _("Panel Type"))
|
|
self.panel_type_label.setToolTip(
|
|
_("Choose the type of object for the panel object:\n"
|
|
"- Gerber\n"
|
|
"- Geometry")
|
|
)
|
|
grid3.addWidget(self.panel_type_label, 0, 0)
|
|
grid3.addWidget(self.panel_type_radio, 0, 1)
|
|
|
|
# Path optimization
|
|
self.optimization_cb = FCCheckBox('%s' % _("Path Optimization"))
|
|
self.optimization_cb.setToolTip(
|
|
_("Active only for Geometry panel type.\n"
|
|
"When checked the application will find\n"
|
|
"any two overlapping Line elements in the panel\n"
|
|
"and will remove the overlapping parts, keeping only one of them.")
|
|
)
|
|
grid3.addWidget(self.optimization_cb, 2, 0, 1, 2)
|
|
|
|
# Constrains
|
|
self.constrain_cb = FCCheckBox('%s:' % _("Constrain panel within"))
|
|
self.constrain_cb.setToolTip(
|
|
_("Area define by DX and DY within to constrain the panel.\n"
|
|
"DX and DY values are in current units.\n"
|
|
"Regardless of how many columns and rows are desired,\n"
|
|
"the final panel will have as many columns and rows as\n"
|
|
"they fit completely within selected area.")
|
|
)
|
|
grid3.addWidget(self.constrain_cb, 4, 0, 1, 2)
|
|
|
|
self.x_width_entry = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.x_width_entry.set_precision(self.decimals)
|
|
self.x_width_entry.set_range(0.0000, 10000.0000)
|
|
|
|
self.x_width_lbl = FCLabel('%s:' % _("Width (DX)"))
|
|
self.x_width_lbl.setToolTip(
|
|
_("The width (DX) within which the panel must fit.\n"
|
|
"In current units.")
|
|
)
|
|
grid3.addWidget(self.x_width_lbl, 6, 0)
|
|
grid3.addWidget(self.x_width_entry, 6, 1)
|
|
|
|
self.y_height_entry = FCDoubleSpinner(callback=self.confirmation_message)
|
|
self.y_height_entry.set_range(0, 10000)
|
|
self.y_height_entry.set_precision(self.decimals)
|
|
|
|
self.y_height_lbl = FCLabel('%s:' % _("Height (DY)"))
|
|
self.y_height_lbl.setToolTip(
|
|
_("The height (DY)within which the panel must fit.\n"
|
|
"In current units.")
|
|
)
|
|
grid3.addWidget(self.y_height_lbl, 8, 0)
|
|
grid3.addWidget(self.y_height_entry, 8, 1)
|
|
|
|
self.constrain_sel = OptionalInputSection(
|
|
self.constrain_cb, [self.x_width_lbl, self.x_width_entry, self.y_height_lbl, self.y_height_entry])
|
|
|
|
self.separator_line = QtWidgets.QFrame()
|
|
self.separator_line.setFrameShape(QtWidgets.QFrame.Shape.HLine)
|
|
self.separator_line.setFrameShadow(QtWidgets.QFrame.Shadow.Sunken)
|
|
grid3.addWidget(self.separator_line, 10, 0, 1, 2)
|
|
|
|
FCGridLayout.set_common_column_size([grid0, grid1, grid2, grid3], 0)
|
|
|
|
# #############################################################################################################
|
|
# Generate Panel Button
|
|
# #############################################################################################################
|
|
self.panelize_object_button = FCButton(_("Panelize Object"))
|
|
self.panelize_object_button.setIcon(QtGui.QIcon(self.app.resource_location + '/panelize16.png'))
|
|
self.panelize_object_button.setToolTip(
|
|
_("Panelize the specified object around the specified box.\n"
|
|
"In other words it creates multiple copies of the source object,\n"
|
|
"arranged in a 2D array of rows and columns.")
|
|
)
|
|
self.panelize_object_button.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
self.tools_box.addWidget(self.panelize_object_button)
|
|
|
|
self.layout.addStretch(1)
|
|
|
|
# ## Reset Tool
|
|
self.reset_button = FCButton(_("Reset Tool"))
|
|
self.reset_button.setIcon(QtGui.QIcon(self.app.resource_location + '/reset32.png'))
|
|
self.reset_button.setToolTip(
|
|
_("Will reset the tool parameters.")
|
|
)
|
|
self.reset_button.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
self.layout.addWidget(self.reset_button)
|
|
|
|
# #################################### FINSIHED GUI ###########################
|
|
# #############################################################################
|
|
self.panel_type_radio.activated_custom.connect(self.on_panel_type)
|
|
|
|
def on_panel_type(self, val):
|
|
if val == 'geometry':
|
|
self.optimization_cb.setDisabled(False)
|
|
else:
|
|
self.optimization_cb.setDisabled(True)
|
|
|
|
def confirmation_message(self, accepted, minval, maxval):
|
|
if accepted is False:
|
|
self.app.inform[str, bool].emit('[WARNING_NOTCL] %s: [%.*f, %.*f]' % (_("Edited value is out of range"),
|
|
self.decimals,
|
|
minval,
|
|
self.decimals,
|
|
maxval), False)
|
|
else:
|
|
self.app.inform[str, bool].emit('[success] %s' % _("Edited value is within limits."), False)
|
|
|
|
def confirmation_message_int(self, accepted, minval, maxval):
|
|
if accepted is False:
|
|
self.app.inform[str, bool].emit('[WARNING_NOTCL] %s: [%d, %d]' %
|
|
(_("Edited value is out of range"), minval, maxval), False)
|
|
else:
|
|
self.app.inform[str, bool].emit('[success] %s' % _("Edited value is within limits."), False)
|