# ##########################################################
# FlatCAM: 2D Post-processing for Manufacturing #
# File Author: Marius Adrian Stanciu (c) #
# Date: 3/10/2019 #
# MIT Licence #
# ##########################################################
from PyQt5 import QtWidgets, QtCore, QtGui
from FlatCAMTool import FlatCAMTool
from flatcamGUI.GUIElements import FCDoubleSpinner, EvalEntry, FCCheckBox, OptionalInputSection
from flatcamGUI.GUIElements import FCTable, FCComboBox, RadioSet
from flatcamEditors.FlatCAMTextEditor import TextEditor
from shapely.geometry import Point
from shapely.geometry.base import *
import math
from datetime import datetime
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 ToolCalibration(FlatCAMTool):
toolName = _("Calibration Tool")
def __init__(self, app):
FlatCAMTool.__init__(self, app)
self.app = app
self.canvas = self.app.plotcanvas
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.layout.addWidget(QtWidgets.QLabel(''))
# ## Grid Layout
grid_lay = QtWidgets.QGridLayout()
self.layout.addLayout(grid_lay)
grid_lay.setColumnStretch(0, 0)
grid_lay.setColumnStretch(1, 1)
grid_lay.setColumnStretch(2, 0)
step_1 = QtWidgets.QLabel('%s' % _("STEP 1: Acquire Calibration Points"))
step_1.setToolTip(
_("Pick four points by clicking inside the drill holes.\n"
"Those four points should be in the four\n"
"(as much as possible) corners of the Excellon object.")
)
grid_lay.addWidget(step_1, 0, 0, 1, 3)
self.cal_source_lbl = QtWidgets.QLabel("%s:" % _("Source Type"))
self.cal_source_lbl.setToolTip(_("The source of calibration points.\n"
"It can be:\n"
"- Object -> click a hole geo for Excellon or a pad for Gerber\n"
"- Free -> click freely on canvas to acquire the calibration points"))
self.cal_source_radio = RadioSet([{'label': _('Object'), 'value': 'object'},
{'label': _('Free'), 'value': 'free'}],
stretch=False)
grid_lay.addWidget(self.cal_source_lbl, 1, 0)
grid_lay.addWidget(self.cal_source_radio, 1, 1, 1, 2)
self.obj_type_label = QtWidgets.QLabel("%s:" % _("Object Type"))
self.obj_type_combo = FCComboBox()
self.obj_type_combo.addItem(_("Gerber"))
self.obj_type_combo.addItem(_("Excellon"))
self.obj_type_combo.setCurrentIndex(1)
grid_lay.addWidget(self.obj_type_label, 2, 0)
grid_lay.addWidget(self.obj_type_combo, 2, 1, 1, 2)
self.object_combo = FCComboBox()
self.object_combo.setModel(self.app.collection)
self.object_combo.setRootModelIndex(self.app.collection.index(1, 0, QtCore.QModelIndex()))
self.object_combo.setCurrentIndex(1)
self.object_label = QtWidgets.QLabel("%s:" % _("Source object selection"))
self.object_label.setToolTip(
_("FlatCAM Object to be used as a source for reference points.")
)
grid_lay.addWidget(self.object_label, 3, 0, 1, 3)
grid_lay.addWidget(self.object_combo, 4, 0, 1, 3)
self.points_table_label = QtWidgets.QLabel('%s' % _('Calibration Points'))
self.points_table_label.setToolTip(
_("Contain the expected calibration points and the\n"
"ones measured.")
)
grid_lay.addWidget(self.points_table_label, 5, 0, 1, 3)
self.points_table = FCTable()
self.points_table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
# self.points_table.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.AdjustToContents)
grid_lay.addWidget(self.points_table, 6, 0, 1, 3)
self.points_table.setColumnCount(4)
self.points_table.setHorizontalHeaderLabels(
[
'#',
_("Name"),
_("Target"),
_("Found Delta")
]
)
self.points_table.setRowCount(8)
row = 0
# BOTTOM LEFT
id_item_1 = QtWidgets.QTableWidgetItem('%d' % 1)
flags = QtCore.Qt.ItemIsEnabled
id_item_1.setFlags(flags)
self.points_table.setItem(row, 0, id_item_1) # Tool name/id
self.bottom_left_coordx_lbl = QtWidgets.QLabel('%s' % _('Bot Left X'))
self.points_table.setCellWidget(row, 1, self.bottom_left_coordx_lbl)
self.bottom_left_coordx_tgt = EvalEntry()
self.points_table.setCellWidget(row, 2, self.bottom_left_coordx_tgt)
self.bottom_left_coordx_tgt.setReadOnly(True)
self.bottom_left_coordx_found = EvalEntry()
self.points_table.setCellWidget(row, 3, self.bottom_left_coordx_found)
row += 1
self.bottom_left_coordy_lbl = QtWidgets.QLabel('%s' % _('Bot Left Y'))
self.points_table.setCellWidget(row, 1, self.bottom_left_coordy_lbl)
self.bottom_left_coordy_tgt = EvalEntry()
self.points_table.setCellWidget(row, 2, self.bottom_left_coordy_tgt)
self.bottom_left_coordy_tgt.setReadOnly(True)
self.bottom_left_coordy_found = EvalEntry()
self.points_table.setCellWidget(row, 3, self.bottom_left_coordy_found)
self.bottom_left_coordx_found.set_value(_("Origin"))
self.bottom_left_coordy_found.set_value(_("Origin"))
self.bottom_left_coordx_found.setDisabled(True)
self.bottom_left_coordy_found.setDisabled(True)
row += 1
# BOTTOM RIGHT
id_item_2 = QtWidgets.QTableWidgetItem('%d' % 2)
flags = QtCore.Qt.ItemIsEnabled
id_item_2.setFlags(flags)
self.points_table.setItem(row, 0, id_item_2) # Tool name/id
self.bottom_right_coordx_lbl = QtWidgets.QLabel('%s' % _('Bot Right X'))
self.points_table.setCellWidget(row, 1, self.bottom_right_coordx_lbl)
self.bottom_right_coordx_tgt = EvalEntry()
self.points_table.setCellWidget(row, 2, self.bottom_right_coordx_tgt)
self.bottom_right_coordx_tgt.setReadOnly(True)
self.bottom_right_coordx_found = EvalEntry()
self.points_table.setCellWidget(row, 3, self.bottom_right_coordx_found)
row += 1
self.bottom_right_coordy_lbl = QtWidgets.QLabel('%s' % _('Bot Right Y'))
self.points_table.setCellWidget(row, 1, self.bottom_right_coordy_lbl)
self.bottom_right_coordy_tgt = EvalEntry()
self.points_table.setCellWidget(row, 2, self.bottom_right_coordy_tgt)
self.bottom_right_coordy_tgt.setReadOnly(True)
self.bottom_right_coordy_found = EvalEntry()
self.points_table.setCellWidget(row, 3, self.bottom_right_coordy_found)
row += 1
# TOP LEFT
id_item_3 = QtWidgets.QTableWidgetItem('%d' % 3)
flags = QtCore.Qt.ItemIsEnabled
id_item_3.setFlags(flags)
self.points_table.setItem(row, 0, id_item_3) # Tool name/id
self.top_left_coordx_lbl = QtWidgets.QLabel('%s' % _('Top Left X'))
self.points_table.setCellWidget(row, 1, self.top_left_coordx_lbl)
self.top_left_coordx_tgt = EvalEntry()
self.points_table.setCellWidget(row, 2, self.top_left_coordx_tgt)
self.top_left_coordx_tgt.setReadOnly(True)
self.top_left_coordx_found = EvalEntry()
self.points_table.setCellWidget(row, 3, self.top_left_coordx_found)
row += 1
self.top_left_coordy_lbl = QtWidgets.QLabel('%s' % _('Top Left Y'))
self.points_table.setCellWidget(row, 1, self.top_left_coordy_lbl)
self.top_left_coordy_tgt = EvalEntry()
self.points_table.setCellWidget(row, 2, self.top_left_coordy_tgt)
self.top_left_coordy_tgt.setReadOnly(True)
self.top_left_coordy_found = EvalEntry()
self.points_table.setCellWidget(row, 3, self.top_left_coordy_found)
row += 1
# TOP RIGHT
id_item_4 = QtWidgets.QTableWidgetItem('%d' % 4)
flags = QtCore.Qt.ItemIsEnabled
id_item_4.setFlags(flags)
self.points_table.setItem(row, 0, id_item_4) # Tool name/id
self.top_right_coordx_lbl = QtWidgets.QLabel('%s' % _('Top Right X'))
self.points_table.setCellWidget(row, 1, self.top_right_coordx_lbl)
self.top_right_coordx_tgt = EvalEntry()
self.points_table.setCellWidget(row, 2, self.top_right_coordx_tgt)
self.top_right_coordx_tgt.setReadOnly(True)
self.top_right_coordx_found = EvalEntry()
self.points_table.setCellWidget(row, 3, self.top_right_coordx_found)
row += 1
self.top_right_coordy_lbl = QtWidgets.QLabel('%s' % _('Top Right Y'))
self.points_table.setCellWidget(row, 1, self.top_right_coordy_lbl)
self.top_right_coordy_tgt = EvalEntry()
self.points_table.setCellWidget(row, 2, self.top_right_coordy_tgt)
self.top_right_coordy_tgt.setReadOnly(True)
self.top_right_coordy_found = EvalEntry()
self.points_table.setCellWidget(row, 3, self.top_right_coordy_found)
vertical_header = self.points_table.verticalHeader()
vertical_header.hide()
self.points_table.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
horizontal_header = self.points_table.horizontalHeader()
horizontal_header.setMinimumSectionSize(10)
horizontal_header.setDefaultSectionSize(70)
self.points_table.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.AdjustToContents)
# for x in range(4):
# self.points_table.resizeColumnToContents(x)
self.points_table.resizeColumnsToContents()
self.points_table.resizeRowsToContents()
horizontal_header.setSectionResizeMode(0, QtWidgets.QHeaderView.Fixed)
horizontal_header.resizeSection(0, 20)
horizontal_header.setSectionResizeMode(1, QtWidgets.QHeaderView.Fixed)
horizontal_header.setSectionResizeMode(2, QtWidgets.QHeaderView.Stretch)
horizontal_header.setSectionResizeMode(3, QtWidgets.QHeaderView.Stretch)
self.points_table.setMinimumHeight(self.points_table.getHeight() + 2)
self.points_table.setMaximumHeight(self.points_table.getHeight() + 3)
# ## Get Points Button
self.start_button = QtWidgets.QPushButton(_("Get Points"))
self.start_button.setToolTip(
_("Pick four points by clicking on canvas if the source choice\n"
"is 'free' or inside the object geometry if the source is 'object'.\n"
"Those four points should be in the four squares of\n"
"the object.")
)
self.start_button.setStyleSheet("""
QPushButton
{
font-weight: bold;
}
""")
grid_lay.addWidget(self.start_button, 7, 0, 1, 3)
separator_line = QtWidgets.QFrame()
separator_line.setFrameShape(QtWidgets.QFrame.HLine)
separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
grid_lay.addWidget(separator_line, 8, 0, 1, 3)
grid_lay.addWidget(QtWidgets.QLabel(''), 9, 0)
# STEP 2 #
step_2 = QtWidgets.QLabel('%s' % _("STEP 2: Verification GCode"))
step_2.setToolTip(
_("Generate GCode file to locate and align the PCB by using\n"
"the four points acquired above.")
)
grid_lay.addWidget(step_2, 10, 0, 1, 3)
self.gcode_title_label = QtWidgets.QLabel('%s' % _('GCode Parameters'))
self.gcode_title_label.setToolTip(
_("Parameters used when creating the GCode in this tool.")
)
grid_lay.addWidget(self.gcode_title_label, 11, 0, 1, 3)
# Travel Z entry
travelz_lbl = QtWidgets.QLabel('%s:' % _("Travel Z"))
travelz_lbl.setToolTip(
_("Height (Z) for travelling between the points.")
)
self.travelz_entry = FCDoubleSpinner()
self.travelz_entry.set_range(-9999.9999, 9999.9999)
self.travelz_entry.set_precision(self.decimals)
self.travelz_entry.setSingleStep(0.1)
grid_lay.addWidget(travelz_lbl, 12, 0)
grid_lay.addWidget(self.travelz_entry, 12, 1, 1, 2)
# Verification Z entry
verz_lbl = QtWidgets.QLabel('%s:' % _("Verification Z"))
verz_lbl.setToolTip(
_("Height (Z) for checking the point.")
)
self.verz_entry = FCDoubleSpinner()
self.verz_entry.set_range(-9999.9999, 9999.9999)
self.verz_entry.set_precision(self.decimals)
self.verz_entry.setSingleStep(0.1)
grid_lay.addWidget(verz_lbl, 13, 0)
grid_lay.addWidget(self.verz_entry, 13, 1, 1, 2)
# Zero the Z of the verification tool
self.zeroz_cb = FCCheckBox('%s' % _("Zero Z tool"))
self.zeroz_cb.setToolTip(
_("Include a sequence to zero the height (Z)\n"
"of the verification tool.")
)
grid_lay.addWidget(self.zeroz_cb, 14, 0, 1, 3)
# Toochange Z entry
toolchangez_lbl = QtWidgets.QLabel('%s:' % _("Toolchange Z"))
toolchangez_lbl.setToolTip(
_("Height (Z) for mounting the verification probe.")
)
self.toolchangez_entry = FCDoubleSpinner()
self.toolchangez_entry.set_range(0.0000, 9999.9999)
self.toolchangez_entry.set_precision(self.decimals)
self.toolchangez_entry.setSingleStep(0.1)
grid_lay.addWidget(toolchangez_lbl, 15, 0)
grid_lay.addWidget(self.toolchangez_entry, 15, 1, 1, 2)
self.z_ois = OptionalInputSection(self.zeroz_cb, [toolchangez_lbl, self.toolchangez_entry])
# ## GCode Button
self.gcode_button = QtWidgets.QPushButton(_("Generate GCode"))
self.gcode_button.setToolTip(
_("Generate GCode file to locate and align the PCB by using\n"
"the four points acquired above.")
)
self.gcode_button.setStyleSheet("""
QPushButton
{
font-weight: bold;
}
""")
grid_lay.addWidget(self.gcode_button, 16, 0, 1, 3)
separator_line1 = QtWidgets.QFrame()
separator_line1.setFrameShape(QtWidgets.QFrame.HLine)
separator_line1.setFrameShadow(QtWidgets.QFrame.Sunken)
grid_lay.addWidget(separator_line1, 17, 0, 1, 3)
grid_lay.addWidget(QtWidgets.QLabel(''), 18, 0, 1, 3)
# STEP 3 #
step_3 = QtWidgets.QLabel('%s' % _("STEP 3: Adjustments"))
step_3.setToolTip(
_("Calculate Scale and Skew factors based on the differences (delta)\n"
"found when checking the PCB pattern. The differences must be filled\n"
"in the fields Found (Delta).")
)
grid_lay.addWidget(step_3, 19, 0, 1, 3)
# ## Factors Button
self.generate_factors_button = QtWidgets.QPushButton(_("Calculate Factors"))
self.generate_factors_button.setToolTip(
_("Calculate Scale and Skew factors based on the differences (delta)\n"
"found when checking the PCB pattern. The differences must be filled\n"
"in the fields Found (Delta).")
)
self.generate_factors_button.setStyleSheet("""
QPushButton
{
font-weight: bold;
}
""")
grid_lay.addWidget(self.generate_factors_button, 20, 0, 1, 3)
self.scalex_label = QtWidgets.QLabel(_("Scale Factor X:"))
self.scalex_label.setToolTip(
_("Factor for Scale action over X axis.")
)
self.scalex_entry = FCDoubleSpinner()
self.scalex_entry.set_range(0, 9999.9999)
self.scalex_entry.set_precision(self.decimals)
self.scalex_entry.setSingleStep(0.1)
grid_lay.addWidget(self.scalex_label, 21, 0)
grid_lay.addWidget(self.scalex_entry, 21, 1, 1, 2)
self.scaley_label = QtWidgets.QLabel(_("Scale Factor Y:"))
self.scaley_label.setToolTip(
_("Factor for Scale action over Y axis.")
)
self.scaley_entry = FCDoubleSpinner()
self.scaley_entry.set_range(0, 9999.9999)
self.scaley_entry.set_precision(self.decimals)
self.scaley_entry.setSingleStep(0.1)
grid_lay.addWidget(self.scaley_label, 22, 0)
grid_lay.addWidget(self.scaley_entry, 22, 1, 1, 2)
self.scale_button = QtWidgets.QPushButton(_("Apply Scale Factors"))
self.scale_button.setToolTip(
_("Apply Scale factors on the calibration points.")
)
self.scale_button.setStyleSheet("""
QPushButton
{
font-weight: bold;
}
""")
grid_lay.addWidget(self.scale_button, 23, 0, 1, 3)
self.skewx_label = QtWidgets.QLabel(_("Skew Angle X:"))
self.skewx_label.setToolTip(
_("Angle for Skew action, in degrees.\n"
"Float number between -360 and 359.")
)
self.skewx_entry = FCDoubleSpinner()
self.skewx_entry.set_range(-360, 360)
self.skewx_entry.set_precision(self.decimals)
self.skewx_entry.setSingleStep(0.1)
grid_lay.addWidget(self.skewx_label, 24, 0)
grid_lay.addWidget(self.skewx_entry, 24, 1, 1, 2)
self.skewy_label = QtWidgets.QLabel(_("Skew Angle Y:"))
self.skewy_label.setToolTip(
_("Angle for Skew action, in degrees.\n"
"Float number between -360 and 359.")
)
self.skewy_entry = FCDoubleSpinner()
self.skewy_entry.set_range(-360, 360)
self.skewy_entry.set_precision(self.decimals)
self.skewy_entry.setSingleStep(0.1)
grid_lay.addWidget(self.skewy_label, 25, 0)
grid_lay.addWidget(self.skewy_entry, 25, 1, 1, 2)
self.skew_button = QtWidgets.QPushButton(_("Apply Skew Factors"))
self.skew_button.setToolTip(
_("Apply Skew factors on the calibration points.")
)
self.skew_button.setStyleSheet("""
QPushButton
{
font-weight: bold;
}
""")
grid_lay.addWidget(self.skew_button, 26, 0, 1, 3)
# final_factors_lbl = QtWidgets.QLabel('%s' % _("Final Factors"))
# final_factors_lbl.setToolTip(
# _("Generate verification GCode file adjusted with\n"
# "the factors above.")
# )
# grid_lay.addWidget(final_factors_lbl, 27, 0, 1, 3)
#
# self.fin_scalex_label = QtWidgets.QLabel(_("Scale Factor X:"))
# self.fin_scalex_label.setToolTip(
# _("Final factor for Scale action over X axis.")
# )
# self.fin_scalex_entry = FCDoubleSpinner()
# self.fin_scalex_entry.set_range(0, 9999.9999)
# self.fin_scalex_entry.set_precision(self.decimals)
# self.fin_scalex_entry.setSingleStep(0.1)
#
# grid_lay.addWidget(self.fin_scalex_label, 28, 0)
# grid_lay.addWidget(self.fin_scalex_entry, 28, 1, 1, 2)
#
# self.fin_scaley_label = QtWidgets.QLabel(_("Scale Factor Y:"))
# self.fin_scaley_label.setToolTip(
# _("Final factor for Scale action over Y axis.")
# )
# self.fin_scaley_entry = FCDoubleSpinner()
# self.fin_scaley_entry.set_range(0, 9999.9999)
# self.fin_scaley_entry.set_precision(self.decimals)
# self.fin_scaley_entry.setSingleStep(0.1)
#
# grid_lay.addWidget(self.fin_scaley_label, 29, 0)
# grid_lay.addWidget(self.fin_scaley_entry, 29, 1, 1, 2)
#
# self.fin_skewx_label = QtWidgets.QLabel(_("Skew Angle X:"))
# self.fin_skewx_label.setToolTip(
# _("Final value for angle for Skew action, in degrees.\n"
# "Float number between -360 and 359.")
# )
# self.fin_skewx_entry = FCDoubleSpinner()
# self.fin_skewx_entry.set_range(-360, 360)
# self.fin_skewx_entry.set_precision(self.decimals)
# self.fin_skewx_entry.setSingleStep(0.1)
#
# grid_lay.addWidget(self.fin_skewx_label, 30, 0)
# grid_lay.addWidget(self.fin_skewx_entry, 30, 1, 1, 2)
#
# self.fin_skewy_label = QtWidgets.QLabel(_("Skew Angle Y:"))
# self.fin_skewy_label.setToolTip(
# _("Final value for angle for Skew action, in degrees.\n"
# "Float number between -360 and 359.")
# )
# self.fin_skewy_entry = FCDoubleSpinner()
# self.fin_skewy_entry.set_range(-360, 360)
# self.fin_skewy_entry.set_precision(self.decimals)
# self.fin_skewy_entry.setSingleStep(0.1)
#
# grid_lay.addWidget(self.fin_skewy_label, 31, 0)
# grid_lay.addWidget(self.fin_skewy_entry, 31, 1, 1, 2)
separator_line1 = QtWidgets.QFrame()
separator_line1.setFrameShape(QtWidgets.QFrame.HLine)
separator_line1.setFrameShadow(QtWidgets.QFrame.Sunken)
grid_lay.addWidget(separator_line1, 32, 0, 1, 3)
grid_lay.addWidget(QtWidgets.QLabel(''), 32, 0, 1, 3)
# STEP 4 #
step_4 = QtWidgets.QLabel('%s' % _("STEP 4: Adjusted GCode"))
step_4.setToolTip(
_("Generate verification GCode file adjusted with\n"
"the factors above.")
)
grid_lay.addWidget(step_4, 34, 0, 1, 3)
# ## Adjusted GCode Button
self.adj_gcode_button = QtWidgets.QPushButton(_("Generate Adjusted GCode"))
self.adj_gcode_button.setToolTip(
_("Generate verification GCode file adjusted with\n"
"the factors above.")
)
self.adj_gcode_button.setStyleSheet("""
QPushButton
{
font-weight: bold;
}
""")
grid_lay.addWidget(self.adj_gcode_button, 35, 0, 1, 3)
separator_line1 = QtWidgets.QFrame()
separator_line1.setFrameShape(QtWidgets.QFrame.HLine)
separator_line1.setFrameShadow(QtWidgets.QFrame.Sunken)
grid_lay.addWidget(separator_line1, 36, 0, 1, 3)
grid_lay.addWidget(QtWidgets.QLabel(''), 37, 0, 1, 3)
# STEP 5 #
step_5 = QtWidgets.QLabel('%s' % _("STEP 5: Calibrate FlatCAM Objects"))
step_5.setToolTip(
_("Adjust the FlatCAM objects\n"
"with the factors determined and verified above.")
)
grid_lay.addWidget(step_5, 38, 0, 1, 3)
self.adj_object_type_combo = QtWidgets.QComboBox()
self.adj_object_type_combo.addItems([_("Gerber"), _("Excellon"), _("Geometry")])
self.adj_object_type_combo.setCurrentIndex(0)
self.adj_object_type_label = QtWidgets.QLabel("%s:" % _("Adjusted object type"))
self.adj_object_type_label.setToolTip(
_("Type of the FlatCAM Object to be adjusted.")
)
grid_lay.addWidget(self.adj_object_type_label, 39, 0, 1, 3)
grid_lay.addWidget(self.adj_object_type_combo, 40, 0, 1, 3)
self.adj_object_combo = FCComboBox()
self.adj_object_combo.setModel(self.app.collection)
self.adj_object_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
self.adj_object_combo.setCurrentIndex(0)
self.adj_object_label = QtWidgets.QLabel("%s:" % _("Adjusted object selection"))
self.adj_object_label.setToolTip(
_("The FlatCAM Object to be adjusted.")
)
grid_lay.addWidget(self.adj_object_label, 41, 0, 1, 3)
grid_lay.addWidget(self.adj_object_combo, 42, 0, 1, 3)
# ## Adjust Objects Button
self.cal_button = QtWidgets.QPushButton(_("Calibrate"))
self.cal_button.setToolTip(
_("Adjust (scale and/or skew) the objects\n"
"with the factors determined above.")
)
self.cal_button.setStyleSheet("""
QPushButton
{
font-weight: bold;
}
""")
grid_lay.addWidget(self.cal_button, 43, 0, 1, 3)
separator_line2 = QtWidgets.QFrame()
separator_line2.setFrameShape(QtWidgets.QFrame.HLine)
separator_line2.setFrameShadow(QtWidgets.QFrame.Sunken)
grid_lay.addWidget(separator_line2, 44, 0, 1, 3)
grid_lay.addWidget(QtWidgets.QLabel(''), 45, 0, 1, 3)
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)
self.mr = None
self.units = ''
# here store 4 points to be used for calibration
self.click_points = list()
# store the status of the grid
self.grid_status_memory = None
self.target_obj = None
# if the mouse events are connected to a local method set this True
self.local_connected = False
# reference for the tab where to open and view the verification GCode
self.gcode_editor_tab = None
# calibrated object
self.cal_object = None
# ## Signals
self.start_button.clicked.connect(self.on_start_collect_points)
self.gcode_button.clicked.connect(self.generate_verification_gcode)
self.generate_factors_button.clicked.connect(self.calculate_factors)
self.reset_button.clicked.connect(self.set_tool_ui)
self.cal_source_radio.activated_custom.connect(self.on_cal_source_radio)
self.obj_type_combo.currentIndexChanged.connect(self.on_obj_type_combo)
self.adj_object_type_combo.currentIndexChanged.connect(self.on_adj_obj_type_combo)
self.cal_button.clicked.connect(self.on_cal_button_click)
def run(self, toggle=True):
self.app.report_usage("ToolCalibration()")
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, _("Calibrate Tool"))
def install(self, icon=None, separator=None, **kwargs):
FlatCAMTool.install(self, icon, separator, shortcut='ALT+E', **kwargs)
def set_tool_ui(self):
self.units = self.app.defaults['units'].upper()
if self.local_connected is True:
self.disconnect_cal_events()
self.reset_calibration_points()
self.cal_source_radio.set_value(self.app.defaults['tools_cal_calsource'])
self.travelz_entry.set_value(self.app.defaults['tools_cal_travelz'])
self.verz_entry.set_value(self.app.defaults['tools_cal_verz'])
self.zeroz_cb.set_value(self.app.defaults['tools_cal_zeroz'])
self.toolchangez_entry.set_value(self.app.defaults['tools_cal_toolchangez'])
self.scalex_entry.set_value(1.0)
self.scaley_entry.set_value(1.0)
self.skewx_entry.set_value(0.0)
self.skewy_entry.set_value(0.0)
# calibrated object
self.cal_object = None
self.app.inform.emit('%s...' % _("Tool initialized"))
def on_obj_type_combo(self):
obj_type = self.obj_type_combo.currentIndex()
self.object_combo.setRootModelIndex(self.app.collection.index(obj_type, 0, QtCore.QModelIndex()))
self.object_combo.setCurrentIndex(0)
def on_adj_obj_type_combo(self):
obj_type = self.adj_object_type_combo.currentIndex()
self.adj_object_combo.setRootModelIndex(self.app.collection.index(obj_type, 0, QtCore.QModelIndex()))
self.adj_object_combo.setCurrentIndex(0)
def on_cal_source_radio(self, val):
if val == 'object':
self.obj_type_label.setDisabled(False)
self.obj_type_combo.setDisabled(False)
self.object_label.setDisabled(False)
self.object_combo.setDisabled(False)
else:
self.obj_type_label.setDisabled(True)
self.obj_type_combo.setDisabled(True)
self.object_label.setDisabled(True)
self.object_combo.setDisabled(True)
def on_start_collect_points(self):
# disengage the grid snapping since it will be hard to find the drills on grid
if self.app.ui.grid_snap_btn.isChecked():
self.grid_status_memory = True
self.app.ui.grid_snap_btn.trigger()
else:
self.grid_status_memory = False
self.mr = self.canvas.graph_event_connect('mouse_release', self.on_mouse_click_release)
if self.app.is_legacy is False:
self.canvas.graph_event_disconnect('mouse_release', self.app.on_mouse_click_release_over_plot)
else:
self.canvas.graph_event_disconnect(self.app.mr)
self.local_connected = True
if self.cal_source_radio.get_value() == 'object':
selection_index = self.object_combo.currentIndex()
model_index = self.app.collection.index(selection_index, 0, self.object_combo.rootModelIndex())
try:
self.target_obj = model_index.internalPointer().obj
except Exception:
self.app.inform.emit('[WARNING_NOTCL] %s' % _("There is no target object loaded ..."))
return
self.reset_calibration_points()
self.app.inform.emit(_("Get First calibration point. Bottom Left..."))
def on_mouse_click_release(self, event):
if event.button == 1:
if self.app.is_legacy is False:
event_pos = event.pos
else:
event_pos = (event.xdata, event.ydata)
pos_canvas = self.canvas.translate_coords(event_pos)
click_pt = Point([pos_canvas[0], pos_canvas[1]])
if self.cal_source_radio.get_value() == 'object':
if self.target_obj.kind.lower() == 'excellon':
for tool, tool_dict in self.target_obj.tools.items():
for geo in tool_dict['solid_geometry']:
if click_pt.within(geo):
center_pt = geo.centroid
self.click_points.append(
(
float('%.*f' % (self.decimals, center_pt.x)),
float('%.*f' % (self.decimals, center_pt.y))
)
)
self.check_points()
else:
for apid, apid_val in self.target_obj.apertures.items():
for geo_el in apid_val['geometry']:
if 'solid' in geo_el:
if click_pt.within(geo_el['solid']):
if isinstance(geo_el['follow'], Point):
center_pt = geo_el['solid'].centroid
self.click_points.append(
(
float('%.*f' % (self.decimals, center_pt.x)),
float('%.*f' % (self.decimals, center_pt.y))
)
)
self.check_points()
else:
self.click_points.append(
(
float('%.*f' % (self.decimals, click_pt.x)),
float('%.*f' % (self.decimals, click_pt.y))
)
)
self.check_points()
def check_points(self):
if len(self.click_points) == 1:
self.bottom_left_coordx_tgt.set_value(self.click_points[0][0])
self.bottom_left_coordy_tgt.set_value(self.click_points[0][1])
self.app.inform.emit(_("Get Second calibration point. Bottom Right..."))
elif len(self.click_points) == 2:
self.bottom_right_coordx_tgt.set_value(self.click_points[1][0])
self.bottom_right_coordy_tgt.set_value(self.click_points[1][1])
self.app.inform.emit(_("Get Third calibration point. Top Left..."))
elif len(self.click_points) == 3:
self.top_left_coordx_tgt.set_value(self.click_points[2][0])
self.top_left_coordy_tgt.set_value(self.click_points[2][1])
self.app.inform.emit(_("Get Forth calibration point. Top Right..."))
elif len(self.click_points) == 4:
self.top_right_coordx_tgt.set_value(self.click_points[3][0])
self.top_right_coordy_tgt.set_value(self.click_points[3][1])
self.app.inform.emit('[success] %s' % _("Done. All four points have been acquired."))
self.disconnect_cal_events()
def reset_calibration_points(self):
self.click_points = list()
self.bottom_left_coordx_tgt.set_value('')
self.bottom_left_coordy_tgt.set_value('')
self.bottom_right_coordx_tgt.set_value('')
self.bottom_right_coordy_tgt.set_value('')
self.top_left_coordx_tgt.set_value('')
self.top_left_coordy_tgt.set_value('')
self.top_right_coordx_tgt.set_value('')
self.top_right_coordy_tgt.set_value('')
def gcode_header(self):
log.debug("ToolCalibration.gcode_header()")
time_str = "{:%A, %d %B %Y at %H:%M}".format(datetime.now())
gcode = '(G-CODE GENERATED BY FLATCAM v%s - www.flatcam.org - Version Date: %s)\n' % \
(str(self.app.version), str(self.app.version_date)) + '\n'
gcode += '(Name: ' + _('Verification GCode for FlatCAM Calibrate Tool') + ')\n'
gcode += '(Units: ' + self.units.upper() + ')\n' + "\n"
gcode += '(Created on ' + time_str + ')\n' + '\n'
gcode += 'G20\n' if self.units.upper() == 'IN' else 'G21\n'
gcode += 'G90\n'
gcode += 'G17\n'
gcode += 'G94\n\n'
return gcode
def close_tab(self):
for idx in range(self.app.ui.plot_tab_area.count()):
if self.app.ui.plot_tab_area.tabText(idx) == _("Gcode Viewer"):
wdg = self.app.ui.plot_tab_area.widget(idx)
wdg.deleteLater()
self.app.ui.plot_tab_area.removeTab(idx)
def generate_verification_gcode(self):
travel_z = '%.*f' % (self.decimals, self.travelz_entry.get_value())
toolchange_z = '%.*f' % (self.decimals, self.toolchangez_entry.get_value())
verification_z = '%.*f' % (self.decimals, self.verz_entry.get_value())
if len(self.click_points) != 4:
self.app.inform.emit('[WARNING_NOTCL] %s' % _("Cancelled. Four points are needed for GCode generation."))
return 'fail'
gcode = self.gcode_header()
if self.zeroz_cb.get_value():
gcode += 'M5\n'
gcode += f'G00 Z{toolchange_z}\n'
gcode += 'M0\n'
gcode += 'G01 Z0\n'
gcode += 'M0\n'
gcode += f'G00 Z{toolchange_z}\n'
gcode += 'M0\n'
gcode += f'G00 Z{travel_z}\n'
gcode += f'G00 X{self.click_points[0][0]} Y{self.click_points[0][1]}\n'
gcode += f'G01 Z{verification_z}\n'
gcode += 'M0\n'
gcode += f'G00 Z{travel_z}\n'
gcode += f'G00 X{self.click_points[2][0]} Y{self.click_points[2][1]}\n'
gcode += f'G01 Z{verification_z}\n'
gcode += 'M0\n'
gcode += f'G00 Z{travel_z}\n'
gcode += f'G00 X{self.click_points[3][0]} Y{self.click_points[3][1]}\n'
gcode += f'G01 Z{verification_z}\n'
gcode += 'M0\n'
gcode += f'G00 Z{travel_z}\n'
gcode += f'G00 X{self.click_points[1][0]} Y{self.click_points[1][1]}\n'
gcode += f'G01 Z{verification_z}\n'
gcode += 'M0\n'
gcode += f'G00 Z{travel_z}\n'
gcode += f'G00 X0 Y0\n'
gcode += f'G00 Z{toolchange_z}\n'
gcode += 'M2'
self.gcode_editor_tab = TextEditor(app=self.app, plain_text=True)
# add the tab if it was closed
self.app.ui.plot_tab_area.addTab(self.gcode_editor_tab, '%s' % _("Gcode Viewer"))
self.gcode_editor_tab.setObjectName('gcode_viewer_tab')
# delete the absolute and relative position and messages in the infobar
self.app.ui.position_label.setText("")
self.app.ui.rel_position_label.setText("")
# first clear previous text in text editor (if any)
self.gcode_editor_tab.code_editor.clear()
self.gcode_editor_tab.code_editor.setReadOnly(False)
self.gcode_editor_tab.code_editor.completer_enable = False
self.gcode_editor_tab.buttonRun.hide()
# Switch plot_area to CNCJob tab
self.app.ui.plot_tab_area.setCurrentWidget(self.gcode_editor_tab)
self.gcode_editor_tab.t_frame.hide()
# then append the text from GCode to the text editor
try:
self.gcode_editor_tab.code_editor.setPlainText(gcode)
except Exception as e:
self.app.inform.emit('[ERROR] %s %s' % ('ERROR -->', str(e)))
return
self.gcode_editor_tab.code_editor.moveCursor(QtGui.QTextCursor.Start)
self.gcode_editor_tab.t_frame.show()
self.app.proc_container.view.set_idle()
self.app.inform.emit('[success] %s...' % _('Loaded Machine Code into Code Editor'))
_filter_ = "G-Code Files (*.nc);;All Files (*.*)"
self.gcode_editor_tab.buttonSave.clicked.disconnect()
self.gcode_editor_tab.buttonSave.clicked.connect(
lambda: self.gcode_editor_tab.handleSaveGCode(name='fc_ver_gcode', filt=_filter_, callback=self.close_tab))
def calculate_factors(self):
origin_x = self.click_points[0][0]
origin_y = self.click_points[0][1]
top_left_x = float('%.*f' % (self.decimals, self.click_points[2][0]))
top_left_y = float('%.*f' % (self.decimals, self.click_points[2][1]))
try:
top_left_dx = float('%.*f' % (self.decimals, self.top_left_coordx_found.get_value()))
except TypeError:
top_left_dx = top_left_x
try:
top_left_dy = float('%.*f' % (self.decimals, self.top_left_coordy_found.get_value()))
except TypeError:
top_left_dy = top_left_y
# top_right_x = float('%.*f' % (self.decimals, self.click_points[3][0]))
# top_right_y = float('%.*f' % (self.decimals, self.click_points[3][1]))
# try:
# top_right_dx = float('%.*f' % (self.decimals, self.top_right_coordx_found.get_value()))
# except TypeError:
# top_right_dx = top_right_x
#
# try:
# top_right_dy = float('%.*f' % (self.decimals, self.top_right_coordy_found.get_value()))
# except TypeError:
# top_right_dy = top_right_y
bot_right_x = float('%.*f' % (self.decimals, self.click_points[1][0]))
bot_right_y = float('%.*f' % (self.decimals, self.click_points[1][1]))
try:
bot_right_dx = float('%.*f' % (self.decimals, self.bottom_right_coordx_found.get_value()))
except TypeError:
bot_right_dx = bot_right_x
try:
bot_right_dy = float('%.*f' % (self.decimals, self.bottom_right_coordy_found.get_value()))
except TypeError:
bot_right_dy = bot_right_y
# ------------------------------------------------------------------------------- #
# --------------------------- FACTORS CALCULUS ---------------------------------- #
# ------------------------------------------------------------------------------- #
if top_left_dy != float('%.*f' % (self.decimals, 0.0)):
# we have scale on Y
scale_y = (top_left_dy + top_left_y - origin_y) / (top_left_y - origin_y)
self.scaley_entry.set_value(scale_y)
if top_left_dx != float('%.*f' % (self.decimals, 0.0)):
# we have skew on X
dx = top_left_dx
dy = top_left_y - origin_y
skew_angle_x = math.degrees(math.atan(dx / dy))
self.skewx_entry.set_value(skew_angle_x)
if bot_right_dx != float('%.*f' % (self.decimals, 0.0)):
# we have scale on X
scale_x = (bot_right_dx + bot_right_x - origin_x) / (bot_right_x - origin_x)
self.scalex_entry.set_value(scale_x)
if bot_right_dy != float('%.*f' % (self.decimals, 0.0)):
# we have skew on Y
dx = bot_right_x - origin_x
dy = bot_right_dy + origin_y
skew_angle_y = math.degrees(math.atan(dy / dx))
self.skewy_entry.set_value(skew_angle_y)
def on_cal_button_click(self):
# get the FlatCAM object to calibrate
selection_index = self.adj_object_combo.currentIndex()
model_index = self.app.collection.index(selection_index, 0, self.adj_object_combo.rootModelIndex())
try:
self.cal_object = model_index.internalPointer().obj
except Exception as e:
log.debug("ToolCalibration.on_cal_button_click() --> %s" % str(e))
self.app.inform.emit('[WARNING_NOTCL] %s' % _("There is no FlatCAM object selected..."))
return 'fail'
# create a new object adjusted (calibrated)
# TODO
def disconnect_cal_events(self):
# restore the Grid snapping if it was active before
if self.grid_status_memory is True:
self.app.ui.grid_snap_btn.trigger()
self.app.mr = self.canvas.graph_event_connect('mouse_release', self.app.on_mouse_click_release_over_plot)
if self.app.is_legacy is False:
self.canvas.graph_event_disconnect('mouse_release', self.on_mouse_click_release)
else:
self.canvas.graph_event_disconnect(self.mr)
self.local_connected = False
def reset_fields(self):
self.object_combo.setRootModelIndex(self.app.collection.index(1, 0, QtCore.QModelIndex()))
self.adj_exc_object_combo.setRootModelIndex(self.app.collection.index(1, 0, QtCore.QModelIndex()))
self.adj_geo_object_combo.setRootModelIndex(self.app.collection.index(2, 0, QtCore.QModelIndex()))
# end of file