def updateCurrentPosition(self, coords: Sequence[Tuple[float, float]]):
"""Update the current coordinate for a point."""
for i, c in enumerate(coords):
if type(c[0]) == float:
text = f"({c[0]}, {c[1]})"
else:
text = "; ".join(f"({x}, {y})" for x, y in c)
item = QTableWidgetItem(text)
item.setToolTip(text)
self.setItem(i, 6, item)
def update_current_position(self, coords: Sequence[Union[_Coord, Tuple[_Coord, _Coord]]]):
"""Update the current coordinate for a point."""
for i, c in enumerate(coords):
if type(c[0]) == float:
text = f"({c[0]:.06f}, {c[1]:.06f})"
else:
text = "; ".join(f"({x:.06f}, {y:.06f})" for x, y in c)
item = QTableWidgetItem(text)
item.setToolTip(text)
self.setItem(i, 6, item)
def updateCurrentPosition(self, coords: Tuple[Tuple[Tuple[float, float]]]):
"""Update the current coordinate for a point."""
for i, c in enumerate(coords):
if type(c[0]) == float:
text = "({}, {})".format(*c)
else:
text = "; ".join("({}, {})".format(x, y) for x, y in c)
item = QTableWidgetItem(text)
item.setToolTip(text)
self.setItem(i, 6, item)
def addCommit(self, commit: CommitModel):
"""Add commit data to all widgets.
+ Commit ID
+ Date
+ Description
+ Author
+ Previous commit
+ Branch
+ Add to table widget.
"""
row = self.CommitTable.rowCount()
self.CommitTable.insertRow(row)
self.commit_current_id.setValue(commit.id)
button = LoadCommitButton(commit.id, self)
button.loaded.connect(self.loadCommitID)
self.load_id.connect(button.isLoaded)
self.CommitTable.setCellWidget(row, 0, button)
date = ("{t.year:02d}-{t.month:02d}-{t.day:02d} " +
"{t.hour:02d}:{t.minute:02d}:{t.second:02d}").format(
t=commit.date)
self.CommitTable.setItem(row, 2, QTableWidgetItem(commit.description))
author_name = commit.author.name
all_authors = [
self.AuthorList.item(row).text()
for row in range(self.AuthorList.count())
]
if author_name not in all_authors:
self.AuthorList.addItem(author_name)
if commit.previous:
previous_id = "#{}".format(commit.previous.id)
else:
previous_id = "None"
branch_name = commit.branch.name
all_branchs = [
self.BranchList.item(row).text()
for row in range(self.BranchList.count())
]
if branch_name not in all_branchs:
self.BranchList.addItem(branch_name)
self.branch_current.setText(branch_name)
for i, text in enumerate(
[date, commit.description, author_name, previous_id, branch_name]):
item = QTableWidgetItem(text)
item.setToolTip(text)
self.CommitTable.setItem(row, i + 1, item)
def writeTable(Integers: List[Tuple[str, str, str]],
Floats: List[Tuple[str, str, str]]):
"""Use to write table data."""
i = 0
for Types, box, maxV in zip([Integers, Floats],
[QSpinBox, QDoubleSpinBox], [9, 10.]):
for name, vname, tooltip in Types:
self.APTable.insertRow(i)
name_cell = QTableWidgetItem(name)
name_cell.setToolTip(tooltip)
self.APTable.setItem(i, 0, name_cell)
spinbox = box()
spinbox.setMaximum(maxV)
spinbox.setToolTip(vname)
self.APTable.setCellWidget(i, 1, spinbox)
i += 1
def writeTable(Length: List[Tuple[str, str, str]],
Degrees: List[Tuple[str, str, str]]):
"""Use to write table data."""
i = 0
for Types, maxV, minV in zip([Length, Degrees], [1000., 360.],
[0.1, 0.]):
for name, vname, tooltip in Types:
self.PLTable.insertRow(i)
name_cell = QTableWidgetItem(name)
name_cell.setToolTip(tooltip)
self.PLTable.setItem(i, 0, name_cell)
spinbox = QDoubleSpinBox()
spinbox.setMaximum(maxV)
spinbox.setMinimum(minV)
spinbox.setToolTip(vname)
self.PLTable.setCellWidget(i, 1, spinbox)
i += 1
def __add_commit(self, commit: CommitModel):
"""Add commit data to all widgets.
+ Commit ID
+ Date
+ Description
+ Author
+ Previous commit
+ Branch
+ Add to table widget.
"""
row = self.CommitTable.rowCount()
self.CommitTable.insertRow(row)
self.commit_current_id.setValue(commit.id)
button = LoadCommitButton(commit.id, self)
button.loaded.connect(self.__load_commit_id)
self.load_id.connect(button.set_loaded)
self.CommitTable.setCellWidget(row, 0, button)
self.CommitTable.setItem(row, 2, QTableWidgetItem(commit.description))
author_name = commit.author.name
for row in range(self.AuthorList.count()):
if author_name == self.AuthorList.item(row).text():
break
else:
self.AuthorList.addItem(author_name)
branch_name = commit.branch.name
for row in range(self.BranchList.count()):
if branch_name == self.BranchList.item(row).text():
break
else:
self.BranchList.addItem(branch_name)
self.branch_current.setText(branch_name)
t = commit.date
for i, text in enumerate(
(f"{t.year:02d}-{t.month:02d}-{t.day:02d} "
f"{t.hour:02d}:{t.minute:02d}:{t.second:02d}", commit.description,
author_name,
f"#{commit.previous.id}" if commit.previous else "None",
branch_name)):
item = QTableWidgetItem(text)
item.setToolTip(text)
self.CommitTable.setItem(row, i + 1, item)
def write_table(integers: Optional[List[Tuple[str, str, str]]] = None,
floats: Optional[List[Tuple[str, str, str]]] = None):
"""Use to write table data."""
if integers is None:
integers = []
if floats is None:
floats = []
i = 0
for options, box, max_value in ((integers, QSpinBox, 9),
(floats, QDoubleSpinBox, 10.)):
for name, tooltip, tooltip in options:
self.alg_table.insertRow(i)
name_cell = QTableWidgetItem(name)
name_cell.setToolTip(tooltip)
self.alg_table.setItem(i, 0, name_cell)
spinbox = box()
spinbox.setMaximum(max_value)
spinbox.setToolTip(tooltip)
self.alg_table.setCellWidget(i, 1, spinbox)
i += 1
def set_expr(
self,
exprs: ExpressionStack,
data_dict: Dict[str, Union[Coordinate, float]],
unsolved: Tuple[int, ...]
):
"""Set the table items for new coming expression."""
exprs = exprs.as_list()
if exprs != self.exprs:
self.clear()
self.setRowCount(len(exprs) + len(unsolved))
row = 0
for expr in exprs:
# Target
self.setItem(row, self.columnCount() - 1, QTableWidgetItem(expr[-1]))
# Parameters
for column, e in enumerate(expr[:-1]):
if e in data_dict:
if type(data_dict[e]) == float:
# Pure digit
text = f"{e}:{data_dict[e]:.02f}"
else:
# Coordinate
c = data_dict[e]
text = f"{e}:({c.x:.02f}, {c.y:.02f})"
else:
# Function name
text = e
item = QTableWidgetItem(text)
item.setToolTip(text)
self.setItem(row, column, item)
row += 1
for p in unsolved:
# Declaration
self.setItem(row, 0, QTableWidgetItem("Unsolved"))
# Target
self.setItem(row, self.columnCount() - 1, QTableWidgetItem(f"P{p}"))
row += 1
self.exprs = exprs
def __set_profile(self, profile_name: str, params: Dict[str, Any]):
"""Set profile to sub-widgets."""
self.__clear_settings()
self.mech_params = deepcopy(params)
expression: str = self.mech_params['Expression']
self.expression_string.setText(expression)
target: Dict[int, List[_Coord]] = self.mech_params['Target']
for name in sorted(target):
self.target_points.addItem(f"P{name}")
path = target[name]
if path:
self.path[name] = path.copy()
else:
self.path[name] = []
if self.target_points.count():
self.target_points.setCurrentRow(0)
# Parameter of link length and input angle.
link_list = set()
for vlink in parse_vlinks(expression):
if len(vlink.points) < 2:
continue
a = vlink.points[0]
b = vlink.points[1]
link_list.add(f"P{a}<->P{b}")
for c in vlink.points[2:]:
for d in (a, b):
link_list.add(f"P{c}<->P{d}")
link_count = len(link_list)
angle_list = set()
input_list: List[Tuple[int, int]] = self.mech_params['input']
for b, d in input_list:
angle_list.add(f"P{b}->P{d}")
angle_count = len(angle_list)
self.parameter_list.setRowCount(0)
placement: Dict[int, Tuple[float, float,
float]] = self.mech_params['Placement']
self.parameter_list.setRowCount(
len(placement) + link_count + angle_count)
def spinbox(v: float,
*,
minimum: float = 0.,
maximum: float = 9999.,
prefix: bool = False) -> QDoubleSpinBox:
double_spinbox = QDoubleSpinBox()
double_spinbox.setMinimum(minimum)
double_spinbox.setMaximum(maximum)
double_spinbox.setSingleStep(10.0)
double_spinbox.setValue(v)
if prefix:
double_spinbox.setPrefix("±")
return double_spinbox
# Position.
pos_list = parse_pos(expression)
same: Dict[int, int] = self.mech_params['same']
for node, ref in sorted(same.items()):
pos_list.insert(node, pos_list[ref])
pos: Dict[int, _Coord] = dict(enumerate(pos_list))
row = 0
for name in sorted(placement):
coord = placement[name]
self.parameter_list.setItem(row, 0, QTableWidgetItem(f"P{name}"))
self.parameter_list.setItem(row, 1, QTableWidgetItem('Placement'))
x, y = pos[name]
for i, s in enumerate([
spinbox(coord[0] if coord else x, minimum=-9999.),
spinbox(coord[1] if coord else y, minimum=-9999.),
spinbox(coord[2] if coord else 25., prefix=True),
]):
s.valueChanged.connect(self.update_range)
self.parameter_list.setCellWidget(row, i + 2, s)
row += 1
# Default value of upper and lower.
for name in ('upper', 'lower'):
if name not in self.mech_params:
self.mech_params[name] = [0.] * (link_count + angle_count)
upper_list: List[float] = self.mech_params['upper']
lower_list: List[float] = self.mech_params['lower']
def set_by_center(
index: int,
get_range: Callable[[], float]) -> Callable[[float], None]:
"""Return a slot function use to set limit value by center."""
@Slot(float)
def func(value: float):
range_value = get_range()
upper_list[index] = value + range_value
lower_list[index] = value - range_value
return func
def set_by_range(
index: int,
get_value: Callable[[], float]) -> Callable[[float], None]:
"""Return a slot function use to set limit value by range."""
@Slot(float)
def func(value: float):
center = get_value()
upper_list[index] = center + value
lower_list[index] = center - value
return func
for i, name in enumerate(sorted(link_list) + sorted(angle_list)):
name_item = QTableWidgetItem(name)
name_item.setToolTip(name)
self.parameter_list.setItem(row, 0, name_item)
if name in link_list:
type_name = "Link"
else:
type_name = "Input"
self.parameter_list.setItem(row, 1, QTableWidgetItem(type_name))
# Set values (it will be same if not in the 'mech_params').
upper = upper_list[i]
if upper == 0.:
upper = 100. if name in link_list else 360.
lower = lower_list[i]
if lower == 0. and name in link_list:
lower = 0.
upper_list[i] = upper
lower_list[i] = lower
# Spin box.
error_range = (upper - lower) / 2
default_value = error_range + lower
if name in link_list:
s1 = spinbox(default_value)
else:
s1 = spinbox(default_value, maximum=360.)
self.parameter_list.setCellWidget(row, 2, s1)
s2 = spinbox(error_range, prefix=True)
self.parameter_list.setCellWidget(row, 4, s2)
# Signal connections.
s1.valueChanged.connect(set_by_center(i, s2.value))
s2.valueChanged.connect(set_by_range(i, s1.value))
row += 1
self.preview_canvas.from_profile(self.mech_params)
self.update_range()
self.profile_name.setText(profile_name)
# Default value of algorithm option.
if 'settings' in self.mech_params:
self.alg_options.update(self.mech_params['settings'])
else:
self.__set_algorithm_default()
self.__able_to_generate()
