80f1d30a28
- when clicking Cancel in Preferences now the values are reverted to what they used to be before opening Preferences tab and start changing values
751 lines
30 KiB
Python
751 lines
30 KiB
Python
|
|
from PyQt5 import QtWidgets, QtCore
|
|
|
|
from FlatCAMTool import FlatCAMTool
|
|
from flatcamGUI.GUIElements import RadioSet, FCDoubleSpinner, EvalEntry, FCEntry
|
|
from FlatCAMObj import FlatCAMGerber, FlatCAMExcellon, FlatCAMGeometry
|
|
|
|
from numpy import Inf
|
|
|
|
from shapely.geometry import Point
|
|
from shapely import affinity
|
|
|
|
import logging
|
|
import gettext
|
|
import FlatCAMTranslation as fcTranslate
|
|
import builtins
|
|
|
|
fcTranslate.apply_language('strings')
|
|
if '_' not in builtins.__dict__:
|
|
_ = gettext.gettext
|
|
|
|
log = logging.getLogger('base')
|
|
|
|
|
|
class DblSidedTool(FlatCAMTool):
|
|
|
|
toolName = _("2-Sided PCB")
|
|
|
|
def __init__(self, app):
|
|
FlatCAMTool.__init__(self, app)
|
|
self.decimals = self.app.decimals
|
|
|
|
# ## Title
|
|
title_label = QtWidgets.QLabel("%s" % self.toolName)
|
|
title_label.setStyleSheet("""
|
|
QLabel
|
|
{
|
|
font-size: 16px;
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
self.layout.addWidget(title_label)
|
|
|
|
self.empty_lb = QtWidgets.QLabel("")
|
|
self.layout.addWidget(self.empty_lb)
|
|
|
|
# ## Grid Layout
|
|
grid_lay = QtWidgets.QGridLayout()
|
|
self.layout.addLayout(grid_lay)
|
|
grid_lay.setColumnStretch(0, 1)
|
|
grid_lay.setColumnStretch(1, 0)
|
|
|
|
# ## Gerber Object to mirror
|
|
self.gerber_object_combo = QtWidgets.QComboBox()
|
|
self.gerber_object_combo.setModel(self.app.collection)
|
|
self.gerber_object_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
|
|
self.gerber_object_combo.setCurrentIndex(1)
|
|
|
|
self.botlay_label = QtWidgets.QLabel("<b>%s:</b>" % _("GERBER"))
|
|
self.botlay_label.setToolTip('%s.' % _("Gerber to be mirrored"))
|
|
|
|
self.mirror_gerber_button = QtWidgets.QPushButton(_("Mirror"))
|
|
self.mirror_gerber_button.setToolTip(
|
|
_("Mirrors (flips) the specified object around \n"
|
|
"the specified axis. Does not create a new \n"
|
|
"object, but modifies it.")
|
|
)
|
|
self.mirror_gerber_button.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
self.mirror_gerber_button.setMinimumWidth(60)
|
|
|
|
# grid_lay.addRow("Bottom Layer:", self.object_combo)
|
|
grid_lay.addWidget(self.botlay_label, 0, 0)
|
|
grid_lay.addWidget(self.gerber_object_combo, 1, 0)
|
|
grid_lay.addWidget(self.mirror_gerber_button, 1, 1)
|
|
|
|
# ## Excellon Object to mirror
|
|
self.exc_object_combo = QtWidgets.QComboBox()
|
|
self.exc_object_combo.setModel(self.app.collection)
|
|
self.exc_object_combo.setRootModelIndex(self.app.collection.index(1, 0, QtCore.QModelIndex()))
|
|
self.exc_object_combo.setCurrentIndex(1)
|
|
|
|
self.excobj_label = QtWidgets.QLabel("<b>%s:</b>" % _("EXCELLON"))
|
|
self.excobj_label.setToolTip(_("Excellon Object to be mirrored."))
|
|
|
|
self.mirror_exc_button = QtWidgets.QPushButton(_("Mirror"))
|
|
self.mirror_exc_button.setToolTip(
|
|
_("Mirrors (flips) the specified object around \n"
|
|
"the specified axis. Does not create a new \n"
|
|
"object, but modifies it.")
|
|
)
|
|
self.mirror_exc_button.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
self.mirror_exc_button.setMinimumWidth(60)
|
|
|
|
# grid_lay.addRow("Bottom Layer:", self.object_combo)
|
|
grid_lay.addWidget(self.excobj_label, 2, 0)
|
|
grid_lay.addWidget(self.exc_object_combo, 3, 0)
|
|
grid_lay.addWidget(self.mirror_exc_button, 3, 1)
|
|
|
|
# ## Geometry Object to mirror
|
|
self.geo_object_combo = QtWidgets.QComboBox()
|
|
self.geo_object_combo.setModel(self.app.collection)
|
|
self.geo_object_combo.setRootModelIndex(self.app.collection.index(2, 0, QtCore.QModelIndex()))
|
|
self.geo_object_combo.setCurrentIndex(1)
|
|
|
|
self.geoobj_label = QtWidgets.QLabel("<b>%s</b>:" % _("GEOMETRY"))
|
|
self.geoobj_label.setToolTip(
|
|
_("Geometry Obj to be mirrored.")
|
|
)
|
|
|
|
self.mirror_geo_button = QtWidgets.QPushButton(_("Mirror"))
|
|
self.mirror_geo_button.setToolTip(
|
|
_("Mirrors (flips) the specified object around \n"
|
|
"the specified axis. Does not create a new \n"
|
|
"object, but modifies it.")
|
|
)
|
|
self.mirror_geo_button.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
self.mirror_geo_button.setMinimumWidth(60)
|
|
|
|
# grid_lay.addRow("Bottom Layer:", self.object_combo)
|
|
grid_lay.addWidget(self.geoobj_label, 4, 0)
|
|
grid_lay.addWidget(self.geo_object_combo, 5, 0)
|
|
grid_lay.addWidget(self.mirror_geo_button, 5, 1)
|
|
|
|
# ## Grid Layout
|
|
grid_lay1 = QtWidgets.QGridLayout()
|
|
self.layout.addLayout(grid_lay1)
|
|
|
|
# ## Axis
|
|
self.mirror_axis = RadioSet([{'label': 'X', 'value': 'X'},
|
|
{'label': 'Y', 'value': 'Y'}])
|
|
self.mirax_label = QtWidgets.QLabel(_("Mirror Axis:"))
|
|
self.mirax_label.setToolTip(_("Mirror vertically (X) or horizontally (Y)."))
|
|
|
|
# grid_lay.addRow("Mirror Axis:", self.mirror_axis)
|
|
self.empty_lb1 = QtWidgets.QLabel("")
|
|
grid_lay1.addWidget(self.empty_lb1, 6, 0)
|
|
grid_lay1.addWidget(self.mirax_label, 7, 0)
|
|
grid_lay1.addWidget(self.mirror_axis, 7, 1)
|
|
|
|
# ## Axis Location
|
|
self.axis_location = RadioSet([{'label': _('Point'), 'value': 'point'},
|
|
{'label': _('Box'), 'value': 'box'}])
|
|
self.axloc_label = QtWidgets.QLabel('%s:' % _("Axis Ref"))
|
|
self.axloc_label.setToolTip(
|
|
_("The axis should pass through a <b>point</b> or cut\n "
|
|
"a specified <b>box</b> (in a FlatCAM object) through \n"
|
|
"the center.")
|
|
)
|
|
# grid_lay.addRow("Axis Location:", self.axis_location)
|
|
grid_lay1.addWidget(self.axloc_label, 8, 0)
|
|
grid_lay1.addWidget(self.axis_location, 8, 1)
|
|
|
|
self.empty_lb2 = QtWidgets.QLabel("")
|
|
grid_lay1.addWidget(self.empty_lb2, 9, 0)
|
|
|
|
# ## Grid Layout
|
|
grid_lay2 = QtWidgets.QGridLayout()
|
|
self.layout.addLayout(grid_lay2)
|
|
grid_lay2.setColumnStretch(0, 1)
|
|
grid_lay2.setColumnStretch(1, 0)
|
|
|
|
# ## Point/Box
|
|
self.point_box_container = QtWidgets.QVBoxLayout()
|
|
self.pb_label = QtWidgets.QLabel("<b>%s:</b>" % _('Point/Box Reference'))
|
|
self.pb_label.setToolTip(
|
|
_("If 'Point' is selected above it store the coordinates (x, y) through which\n"
|
|
"the mirroring axis passes.\n"
|
|
"If 'Box' is selected above, select here a FlatCAM object (Gerber, Exc or Geo).\n"
|
|
"Through the center of this object pass the mirroring axis selected above.")
|
|
)
|
|
|
|
self.add_point_button = QtWidgets.QPushButton(_("Add"))
|
|
self.add_point_button.setToolTip(
|
|
_("Add the coordinates in format <b>(x, y)</b> through which the mirroring axis \n "
|
|
"selected in 'MIRROR AXIS' pass.\n"
|
|
"The (x, y) coordinates are captured by pressing SHIFT key\n"
|
|
"and left mouse button click on canvas or you can enter the coords manually.")
|
|
)
|
|
self.add_point_button.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
self.add_point_button.setMinimumWidth(60)
|
|
|
|
grid_lay2.addWidget(self.pb_label, 10, 0)
|
|
grid_lay2.addLayout(self.point_box_container, 11, 0)
|
|
grid_lay2.addWidget(self.add_point_button, 11, 1)
|
|
|
|
self.point_entry = EvalEntry()
|
|
self.point_box_container.addWidget(self.point_entry)
|
|
|
|
self.box_combo = QtWidgets.QComboBox()
|
|
self.box_combo.setModel(self.app.collection)
|
|
self.box_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
|
|
self.box_combo.setCurrentIndex(1)
|
|
|
|
self.box_combo_type = QtWidgets.QComboBox()
|
|
self.box_combo_type.addItem(_("Reference Gerber"))
|
|
self.box_combo_type.addItem(_("Reference Excellon"))
|
|
self.box_combo_type.addItem(_("Reference Geometry"))
|
|
|
|
self.point_box_container.addWidget(self.box_combo_type)
|
|
self.point_box_container.addWidget(self.box_combo)
|
|
self.box_combo.hide()
|
|
self.box_combo_type.hide()
|
|
|
|
separator_line = QtWidgets.QFrame()
|
|
separator_line.setFrameShape(QtWidgets.QFrame.HLine)
|
|
separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
|
|
grid_lay2.addWidget(separator_line, 12, 0, 1, 2)
|
|
|
|
# ## Alignment holes
|
|
self.ah_label = QtWidgets.QLabel("<b>%s:</b>" % _('Alignment Drill Coordinates'))
|
|
self.ah_label.setToolTip(
|
|
_("Alignment holes (x1, y1), (x2, y2), ... "
|
|
"on one side of the mirror axis. For each set of (x, y) coordinates\n"
|
|
"entered here, a pair of drills will be created:\n\n"
|
|
"- one drill at the coordinates from the field\n"
|
|
"- one drill in mirror position over the axis selected above in the 'Mirror Axis'.")
|
|
)
|
|
self.layout.addWidget(self.ah_label)
|
|
|
|
grid_lay3 = QtWidgets.QGridLayout()
|
|
self.layout.addLayout(grid_lay3)
|
|
|
|
self.alignment_holes = EvalEntry()
|
|
|
|
self.add_drill_point_button = QtWidgets.QPushButton(_("Add"))
|
|
self.add_drill_point_button.setToolTip(
|
|
_("Add alignment drill holes coords in the format: (x1, y1), (x2, y2), ... \n"
|
|
"on one side of the mirror axis.\n\n"
|
|
"The coordinates set can be obtained:\n"
|
|
"- press SHIFT key and left mouse clicking on canvas. Then click Add.\n"
|
|
"- press SHIFT key and left mouse clicking on canvas. Then CTRL+V in the field.\n"
|
|
"- press SHIFT key and left mouse clicking on canvas. Then RMB click in the field and click Paste.\n"
|
|
"- by entering the coords manually in the format: (x1, y1), (x2, y2), ...")
|
|
)
|
|
self.add_drill_point_button.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
self.add_drill_point_button.setMinimumWidth(60)
|
|
|
|
grid_lay3.addWidget(self.alignment_holes, 0, 0)
|
|
grid_lay3.addWidget(self.add_drill_point_button, 0, 1)
|
|
|
|
grid0 = QtWidgets.QGridLayout()
|
|
self.layout.addLayout(grid0)
|
|
grid0.setColumnStretch(0, 0)
|
|
grid0.setColumnStretch(1, 1)
|
|
|
|
# ## Drill diameter for alignment holes
|
|
self.dt_label = QtWidgets.QLabel("<b>%s:</b>" % _('Alignment Drill Diameter'))
|
|
self.dt_label.setToolTip(
|
|
_("Diameter of the drill for the "
|
|
"alignment holes.")
|
|
)
|
|
grid0.addWidget(self.dt_label, 0, 0, 1, 2)
|
|
|
|
# Drill diameter value
|
|
self.drill_dia = FCDoubleSpinner()
|
|
self.drill_dia.set_precision(self.decimals)
|
|
self.drill_dia.set_range(0.0000, 9999.9999)
|
|
|
|
self.drill_dia.setToolTip(
|
|
_("Diameter of the drill for the "
|
|
"alignment holes.")
|
|
)
|
|
|
|
grid0.addWidget(self.drill_dia, 1, 0, 1, 2)
|
|
|
|
# ## Buttons
|
|
self.create_alignment_hole_button = QtWidgets.QPushButton(_("Create Excellon Object"))
|
|
self.create_alignment_hole_button.setToolTip(
|
|
_("Creates an Excellon Object containing the\n"
|
|
"specified alignment holes and their mirror\n"
|
|
"images.")
|
|
)
|
|
self.create_alignment_hole_button.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
self.layout.addWidget(self.create_alignment_hole_button)
|
|
|
|
separator_line = QtWidgets.QFrame()
|
|
separator_line.setFrameShape(QtWidgets.QFrame.HLine)
|
|
separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
|
|
self.layout.addWidget(separator_line)
|
|
|
|
self.layout.addWidget(QtWidgets.QLabel(''))
|
|
|
|
grid1 = QtWidgets.QGridLayout()
|
|
self.layout.addLayout(grid1)
|
|
grid1.setColumnStretch(0, 0)
|
|
grid1.setColumnStretch(1, 1)
|
|
|
|
# Xmin value
|
|
self.xmin_entry = FCDoubleSpinner()
|
|
self.xmin_entry.set_precision(self.decimals)
|
|
self.xmin_entry.set_range(-9999.9999, 9999.9999)
|
|
|
|
self.xmin_label = QtWidgets.QLabel('%s:' % _("X min"))
|
|
self.xmin_label.setToolTip(
|
|
_("Minimum location.")
|
|
)
|
|
self.xmin_entry.setReadOnly(True)
|
|
|
|
grid1.addWidget(self.xmin_label, 1, 0)
|
|
grid1.addWidget(self.xmin_entry, 1, 1)
|
|
|
|
# Ymin value
|
|
self.ymin_entry = FCDoubleSpinner()
|
|
self.ymin_entry.set_precision(self.decimals)
|
|
self.ymin_entry.set_range(-9999.9999, 9999.9999)
|
|
|
|
self.ymin_label = QtWidgets.QLabel('%s:' % _("Y min"))
|
|
self.ymin_label.setToolTip(
|
|
_("Minimum location.")
|
|
)
|
|
self.ymin_entry.setReadOnly(True)
|
|
|
|
grid1.addWidget(self.ymin_label, 2, 0)
|
|
grid1.addWidget(self.ymin_entry, 2, 1)
|
|
|
|
# Xmax value
|
|
self.xmax_entry = FCDoubleSpinner()
|
|
self.xmax_entry.set_precision(self.decimals)
|
|
self.xmax_entry.set_range(-9999.9999, 9999.9999)
|
|
|
|
self.xmax_label = QtWidgets.QLabel('%s:' % _("X max"))
|
|
self.xmax_label.setToolTip(
|
|
_("Maximum location.")
|
|
)
|
|
self.xmax_entry.setReadOnly(True)
|
|
|
|
grid1.addWidget(self.xmax_label, 3, 0)
|
|
grid1.addWidget(self.xmax_entry, 3, 1)
|
|
|
|
# Ymax value
|
|
self.ymax_entry = FCDoubleSpinner()
|
|
self.ymax_entry.set_precision(self.decimals)
|
|
self.ymax_entry.set_range(-9999.9999, 9999.9999)
|
|
|
|
self.ymax_label = QtWidgets.QLabel('%s:' % _("Y max"))
|
|
self.ymax_label.setToolTip(
|
|
_("Maximum location.")
|
|
)
|
|
self.ymax_entry.setReadOnly(True)
|
|
|
|
grid1.addWidget(self.ymax_label, 4, 0)
|
|
grid1.addWidget(self.ymax_entry, 4, 1)
|
|
|
|
# Center point value
|
|
self.center_entry = FCEntry()
|
|
|
|
self.center_label = QtWidgets.QLabel('%s:' % _("Centroid"))
|
|
self.center_label.setToolTip(
|
|
_("The center point location for the rectangular\n"
|
|
"bounding shape. Centroid. Format is (x, y).")
|
|
)
|
|
self.center_entry.setReadOnly(True)
|
|
|
|
grid1.addWidget(self.center_label, 5, 0)
|
|
grid1.addWidget(self.center_entry, 5, 1)
|
|
|
|
# Calculate Bounding box
|
|
self.calculate_bb_button = QtWidgets.QPushButton(_("Calculate Bounds Values"))
|
|
self.calculate_bb_button.setToolTip(
|
|
_("Calculate the enveloping rectangular shape coordinates,\n"
|
|
"for the selection of objects.\n"
|
|
"The envelope shape is parallel with the X, Y axis.")
|
|
)
|
|
self.calculate_bb_button.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
self.layout.addWidget(self.calculate_bb_button)
|
|
|
|
self.layout.addStretch()
|
|
|
|
# ## Reset Tool
|
|
self.reset_button = QtWidgets.QPushButton(_("Reset Tool"))
|
|
self.reset_button.setToolTip(
|
|
_("Will reset the tool parameters.")
|
|
)
|
|
self.reset_button.setStyleSheet("""
|
|
QPushButton
|
|
{
|
|
font-weight: bold;
|
|
}
|
|
""")
|
|
self.layout.addWidget(self.reset_button)
|
|
|
|
# ## Signals
|
|
self.mirror_gerber_button.clicked.connect(self.on_mirror_gerber)
|
|
self.mirror_exc_button.clicked.connect(self.on_mirror_exc)
|
|
self.mirror_geo_button.clicked.connect(self.on_mirror_geo)
|
|
self.add_point_button.clicked.connect(self.on_point_add)
|
|
self.add_drill_point_button.clicked.connect(self.on_drill_add)
|
|
self.box_combo_type.currentIndexChanged.connect(self.on_combo_box_type)
|
|
|
|
self.axis_location.group_toggle_fn = self.on_toggle_pointbox
|
|
|
|
self.create_alignment_hole_button.clicked.connect(self.on_create_alignment_holes)
|
|
self.calculate_bb_button.clicked.connect(self.on_bbox_coordinates)
|
|
|
|
self.reset_button.clicked.connect(self.set_tool_ui)
|
|
|
|
self.drill_values = ""
|
|
|
|
def install(self, icon=None, separator=None, **kwargs):
|
|
FlatCAMTool.install(self, icon, separator, shortcut='ALT+D', **kwargs)
|
|
|
|
def run(self, toggle=True):
|
|
self.app.report_usage("Tool2Sided()")
|
|
|
|
if toggle:
|
|
# if the splitter is hidden, display it, else hide it but only if the current widget is the same
|
|
if self.app.ui.splitter.sizes()[0] == 0:
|
|
self.app.ui.splitter.setSizes([1, 1])
|
|
else:
|
|
try:
|
|
if self.app.ui.tool_scroll_area.widget().objectName() == self.toolName:
|
|
# if tab is populated with the tool but it does not have the focus, focus on it
|
|
if not self.app.ui.notebook.currentWidget() is self.app.ui.tool_tab:
|
|
# focus on Tool Tab
|
|
self.app.ui.notebook.setCurrentWidget(self.app.ui.tool_tab)
|
|
else:
|
|
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])
|
|
|
|
FlatCAMTool.run(self)
|
|
self.set_tool_ui()
|
|
|
|
self.app.ui.notebook.setTabText(2, _("2-Sided Tool"))
|
|
|
|
def set_tool_ui(self):
|
|
self.reset_fields()
|
|
|
|
self.point_entry.set_value("")
|
|
self.alignment_holes.set_value("")
|
|
|
|
self.mirror_axis.set_value(self.app.defaults["tools_2sided_mirror_axis"])
|
|
self.axis_location.set_value(self.app.defaults["tools_2sided_axis_loc"])
|
|
self.drill_dia.set_value(self.app.defaults["tools_2sided_drilldia"])
|
|
|
|
self.xmin_entry.set_value(0.0)
|
|
self.ymin_entry.set_value(0.0)
|
|
self.xmax_entry.set_value(0.0)
|
|
self.ymax_entry.set_value(0.0)
|
|
self.center_entry.set_value('')
|
|
|
|
def on_combo_box_type(self):
|
|
obj_type = self.box_combo_type.currentIndex()
|
|
self.box_combo.setRootModelIndex(self.app.collection.index(obj_type, 0, QtCore.QModelIndex()))
|
|
self.box_combo.setCurrentIndex(0)
|
|
|
|
def on_create_alignment_holes(self):
|
|
axis = self.mirror_axis.get_value()
|
|
mode = self.axis_location.get_value()
|
|
|
|
if mode == "point":
|
|
try:
|
|
px, py = self.point_entry.get_value()
|
|
except TypeError:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("'Point' reference is selected and 'Point' coordinates "
|
|
"are missing. Add them and retry."))
|
|
return
|
|
else:
|
|
selection_index = self.box_combo.currentIndex()
|
|
model_index = self.app.collection.index(selection_index, 0, self.gerber_object_combo.rootModelIndex())
|
|
try:
|
|
bb_obj = model_index.internalPointer().obj
|
|
except AttributeError:
|
|
model_index = self.app.collection.index(selection_index, 0, self.exc_object_combo.rootModelIndex())
|
|
try:
|
|
bb_obj = model_index.internalPointer().obj
|
|
except AttributeError:
|
|
model_index = self.app.collection.index(selection_index, 0,
|
|
self.geo_object_combo.rootModelIndex())
|
|
try:
|
|
bb_obj = model_index.internalPointer().obj
|
|
except AttributeError:
|
|
self.app.inform.emit(
|
|
'[WARNING_NOTCL] %s' % _("There is no Box reference object loaded. Load one and retry."))
|
|
return
|
|
|
|
xmin, ymin, xmax, ymax = bb_obj.bounds()
|
|
px = 0.5 * (xmin + xmax)
|
|
py = 0.5 * (ymin + ymax)
|
|
|
|
xscale, yscale = {"X": (1.0, -1.0), "Y": (-1.0, 1.0)}[axis]
|
|
|
|
dia = float(self.drill_dia.get_value())
|
|
if dia is '':
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' %
|
|
_("No value or wrong format in Drill Dia entry. Add it and retry."))
|
|
return
|
|
|
|
tools = {"1": {"C": dia}}
|
|
|
|
# holes = self.alignment_holes.get_value()
|
|
holes = eval('[{}]'.format(self.alignment_holes.text()))
|
|
if not holes:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("There are no Alignment Drill Coordinates to use. "
|
|
"Add them and retry."))
|
|
return
|
|
|
|
drills = []
|
|
|
|
for hole in holes:
|
|
point = Point(hole)
|
|
point_mirror = affinity.scale(point, xscale, yscale, origin=(px, py))
|
|
drills.append({"point": point, "tool": "1"})
|
|
drills.append({"point": point_mirror, "tool": "1"})
|
|
if 'solid_geometry' not in tools:
|
|
tools["1"]['solid_geometry'] = []
|
|
else:
|
|
tools["1"]['solid_geometry'].append(point_mirror)
|
|
|
|
def obj_init(obj_inst, app_inst):
|
|
obj_inst.tools = tools
|
|
obj_inst.drills = drills
|
|
obj_inst.create_geometry()
|
|
|
|
self.app.new_object("excellon", "Alignment Drills", obj_init)
|
|
self.drill_values = ''
|
|
self.app.inform.emit('[success] %s' % _("Excellon object with alignment drills created..."))
|
|
|
|
def on_mirror_gerber(self):
|
|
selection_index = self.gerber_object_combo.currentIndex()
|
|
# fcobj = self.app.collection.object_list[selection_index]
|
|
model_index = self.app.collection.index(selection_index, 0, self.gerber_object_combo.rootModelIndex())
|
|
try:
|
|
fcobj = model_index.internalPointer().obj
|
|
except Exception as e:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("There is no Gerber object loaded ..."))
|
|
return
|
|
|
|
if not isinstance(fcobj, FlatCAMGerber):
|
|
self.app.inform.emit('[ERROR_NOTCL] %s' % _("Only Gerber, Excellon and Geometry objects can be mirrored."))
|
|
return
|
|
|
|
axis = self.mirror_axis.get_value()
|
|
mode = self.axis_location.get_value()
|
|
|
|
if mode == "point":
|
|
try:
|
|
px, py = self.point_entry.get_value()
|
|
except TypeError:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("'Point' coordinates missing. "
|
|
"Using Origin (0, 0) as mirroring reference."))
|
|
px, py = (0, 0)
|
|
|
|
else:
|
|
selection_index_box = self.box_combo.currentIndex()
|
|
model_index_box = self.app.collection.index(selection_index_box, 0, self.box_combo.rootModelIndex())
|
|
try:
|
|
bb_obj = model_index_box.internalPointer().obj
|
|
except Exception as e:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("There is no Box object loaded ..."))
|
|
return
|
|
|
|
xmin, ymin, xmax, ymax = bb_obj.bounds()
|
|
px = 0.5 * (xmin + xmax)
|
|
py = 0.5 * (ymin + ymax)
|
|
|
|
fcobj.mirror(axis, [px, py])
|
|
self.app.object_changed.emit(fcobj)
|
|
fcobj.plot()
|
|
self.app.inform.emit('[success] Gerber %s %s...' % (str(fcobj.options['name']), _("was mirrored")))
|
|
|
|
def on_mirror_exc(self):
|
|
selection_index = self.exc_object_combo.currentIndex()
|
|
# fcobj = self.app.collection.object_list[selection_index]
|
|
model_index = self.app.collection.index(selection_index, 0, self.exc_object_combo.rootModelIndex())
|
|
try:
|
|
fcobj = model_index.internalPointer().obj
|
|
except Exception as e:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("There is no Excellon object loaded ..."))
|
|
return
|
|
|
|
if not isinstance(fcobj, FlatCAMExcellon):
|
|
self.app.inform.emit('[ERROR_NOTCL] %s' % _("Only Gerber, Excellon and Geometry objects can be mirrored."))
|
|
return
|
|
|
|
axis = self.mirror_axis.get_value()
|
|
mode = self.axis_location.get_value()
|
|
|
|
if mode == "point":
|
|
try:
|
|
px, py = self.point_entry.get_value()
|
|
except Exception as e:
|
|
log.debug("DblSidedTool.on_mirror_geo() --> %s" % str(e))
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("There are no Point coordinates in the Point field. "
|
|
"Add coords and try again ..."))
|
|
return
|
|
else:
|
|
selection_index_box = self.box_combo.currentIndex()
|
|
model_index_box = self.app.collection.index(selection_index_box, 0, self.box_combo.rootModelIndex())
|
|
try:
|
|
bb_obj = model_index_box.internalPointer().obj
|
|
except Exception as e:
|
|
log.debug("DblSidedTool.on_mirror_geo() --> %s" % str(e))
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("There is no Box object loaded ..."))
|
|
return
|
|
|
|
xmin, ymin, xmax, ymax = bb_obj.bounds()
|
|
px = 0.5 * (xmin + xmax)
|
|
py = 0.5 * (ymin + ymax)
|
|
|
|
fcobj.mirror(axis, [px, py])
|
|
self.app.object_changed.emit(fcobj)
|
|
fcobj.plot()
|
|
self.app.inform.emit('[success] Excellon %s %s...' % (str(fcobj.options['name']), _("was mirrored")))
|
|
|
|
def on_mirror_geo(self):
|
|
selection_index = self.geo_object_combo.currentIndex()
|
|
# fcobj = self.app.collection.object_list[selection_index]
|
|
model_index = self.app.collection.index(selection_index, 0, self.geo_object_combo.rootModelIndex())
|
|
try:
|
|
fcobj = model_index.internalPointer().obj
|
|
except Exception as e:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("There is no Geometry object loaded ..."))
|
|
return
|
|
|
|
if not isinstance(fcobj, FlatCAMGeometry):
|
|
self.app.inform.emit('[ERROR_NOTCL] %s' % _("Only Gerber, Excellon and Geometry objects can be mirrored."))
|
|
return
|
|
|
|
axis = self.mirror_axis.get_value()
|
|
mode = self.axis_location.get_value()
|
|
|
|
if mode == "point":
|
|
px, py = self.point_entry.get_value()
|
|
else:
|
|
selection_index_box = self.box_combo.currentIndex()
|
|
model_index_box = self.app.collection.index(selection_index_box, 0, self.box_combo.rootModelIndex())
|
|
try:
|
|
bb_obj = model_index_box.internalPointer().obj
|
|
except Exception as e:
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' % _("There is no Box object loaded ..."))
|
|
return
|
|
|
|
xmin, ymin, xmax, ymax = bb_obj.bounds()
|
|
px = 0.5 * (xmin + xmax)
|
|
py = 0.5 * (ymin + ymax)
|
|
|
|
fcobj.mirror(axis, [px, py])
|
|
self.app.object_changed.emit(fcobj)
|
|
fcobj.plot()
|
|
self.app.inform.emit('[success] Geometry %s %s...' % (str(fcobj.options['name']), _("was mirrored")))
|
|
|
|
|
|
def on_point_add(self):
|
|
val = self.app.defaults["global_point_clipboard_format"] % (self.app.pos[0], self.app.pos[1])
|
|
self.point_entry.set_value(val)
|
|
|
|
def on_drill_add(self):
|
|
self.drill_values += (self.app.defaults["global_point_clipboard_format"] %
|
|
(self.app.pos[0], self.app.pos[1])) + ','
|
|
self.alignment_holes.set_value(self.drill_values)
|
|
|
|
def on_toggle_pointbox(self):
|
|
if self.axis_location.get_value() == "point":
|
|
self.point_entry.show()
|
|
self.box_combo.hide()
|
|
self.box_combo_type.hide()
|
|
self.add_point_button.setDisabled(False)
|
|
else:
|
|
self.point_entry.hide()
|
|
self.box_combo.show()
|
|
self.box_combo_type.show()
|
|
self.add_point_button.setDisabled(True)
|
|
|
|
def on_bbox_coordinates(self):
|
|
|
|
xmin = Inf
|
|
ymin = Inf
|
|
xmax = -Inf
|
|
ymax = -Inf
|
|
|
|
obj_list = self.app.collection.get_selected()
|
|
|
|
if not obj_list:
|
|
self.app.inform.emit('[ERROR_NOTCL] %s' % _("Failed. No object(s) selected..."))
|
|
return
|
|
|
|
for obj in obj_list:
|
|
try:
|
|
gxmin, gymin, gxmax, gymax = obj.bounds()
|
|
xmin = min([xmin, gxmin])
|
|
ymin = min([ymin, gymin])
|
|
xmax = max([xmax, gxmax])
|
|
ymax = max([ymax, gymax])
|
|
except Exception as e:
|
|
log.warning("DEV WARNING: Tried to get bounds of empty geometry in DblSidedTool. %s" % str(e))
|
|
|
|
self.xmin_entry.set_value(xmin)
|
|
self.ymin_entry.set_value(ymin)
|
|
self.xmax_entry.set_value(xmax)
|
|
self.ymax_entry.set_value(ymax)
|
|
cx = '%.*f' % (self.decimals, (((xmax - xmin) / 2.0) + xmin))
|
|
cy = '%.*f' % (self.decimals, (((ymax - ymin) / 2.0) + ymin))
|
|
val_txt = '(%s, %s)' % (cx, cy)
|
|
|
|
self.center_entry.set_value(val_txt)
|
|
self.axis_location.set_value('point')
|
|
self.point_entry.set_value(val_txt)
|
|
|
|
def reset_fields(self):
|
|
self.gerber_object_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
|
|
self.exc_object_combo.setRootModelIndex(self.app.collection.index(1, 0, QtCore.QModelIndex()))
|
|
self.geo_object_combo.setRootModelIndex(self.app.collection.index(2, 0, QtCore.QModelIndex()))
|
|
self.box_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
|
|
|
|
self.gerber_object_combo.setCurrentIndex(0)
|
|
self.exc_object_combo.setCurrentIndex(0)
|
|
self.geo_object_combo.setCurrentIndex(0)
|
|
self.box_combo.setCurrentIndex(0)
|
|
self.box_combo_type.setCurrentIndex(0)
|
|
|
|
self.drill_values = ""
|