def test_case(name: str):
expr, inputs = example_list(name)
vpoints = parse_vpoints(expr)
exprs = t_config(vpoints, inputs)
result = expr_solving(exprs, vpoints,
{pair: 0.
for pair in inputs})
return result[-1]
def resolve(self) -> None:
"""Resolve: Using three libraries to solve the system.
+ Pyslvs
+ Python-Solvespace
+ Sketch Solve
"""
for b, d, a in self.inputs_widget.input_pairs():
if b == d:
self.vpoint_list[b].set_offset(a)
solve_kernel = self.prefer.planar_solver_option
try:
if solve_kernel == 0:
result = expr_solving(
self.get_triangle(),
{n: f'P{n}'
for n in range(len(self.vpoint_list))}, self.vpoint_list,
tuple(a for b, d, a in self.inputs_widget.input_pairs()
if b != d))
elif solve_kernel == 1:
result, _ = _slvs_solve(self.vpoint_list, {
(b, d): a
for b, d, a in self.inputs_widget.input_pairs()
} if not self.free_move_button.isChecked() else {})
elif solve_kernel == 2:
result = SolverSystem(
self.vpoint_list,
{(b, d): a
for b, d, a in self.inputs_widget.input_pairs()}).solve()
else:
raise ValueError("incorrect kernel")
except ValueError as error:
# Error: Show warning without update data.
if self.prefer.console_error_option:
logger.warn(format_exc())
error_text = f"Error: {error}"
self.conflict.setToolTip(error_text)
self.conflict.setStatusTip(error_text)
self.conflict.setVisible(True)
self.dof_view.setVisible(False)
else:
self.entities_point.update_current_position(result)
for i, c in enumerate(result):
if type(c[0]) is float:
self.vpoint_list[i].move(cast(_Coord, c))
else:
c1, c2 = cast(Tuple[_Coord, _Coord], c)
self.vpoint_list[i].move(c1, c2)
self.__dof = vpoint_dof(self.vpoint_list)
self.dof_view.setText(
f"{self.__dof} ({self.inputs_widget.input_count()})")
self.conflict.setVisible(False)
self.dof_view.setVisible(True)
self.reload_canvas()
def resolve(self) -> None:
"""Resolve: Using three libraries to solve the system.
+ Pyslvs
+ Python-Solvespace
+ Sketch Solve
"""
for b, d, a in self.inputs_widget.input_pairs():
if b == d:
self.vpoint_list[b].set_offset(a)
solve_kernel = self.prefer.planar_solver_option
input_pair = {(b, d): a for b, d, a in self.inputs_widget.input_pairs()}
try:
if solve_kernel == Kernel.PYSLVS:
result = expr_solving(
self.get_triangle(),
self.vpoint_list,
input_pair
)
elif solve_kernel == Kernel.SOLVESPACE:
result, _ = _slvs_solve(
self.vpoint_list,
input_pair if not self.free_move_button.isChecked() else {}
)
elif solve_kernel == Kernel.SKETCH_SOLVE:
result = SolverSystem(self.vpoint_list, input_pair).solve()
else:
raise ValueError("incorrect kernel")
except ValueError as error:
# Error: Show warning without update data.
if self.prefer.console_error_option:
logger.warn(format_exc())
error_text = f"Error: {error}"
self.conflict.setToolTip(error_text)
self.conflict.setStatusTip(error_text)
self.conflict.setVisible(True)
self.dof_view.setVisible(False)
else:
self.entities_point.update_current_position(result)
for i, c in enumerate(result):
if isinstance(c[0], float):
self.vpoint_list[i].move(c)
else:
c1, c2 = c
self.vpoint_list[i].move(c1, c2)
self.__dof = vpoint_dof(self.vpoint_list)
self.dof_view.setText(
f"{self.__dof} ({self.inputs_widget.input_count()})")
self.conflict.setVisible(False)
self.dof_view.setVisible(True)
self.reload_canvas()
def __get_path(self, row: int) -> List[List[_Coord]]:
"""Using result data to generate paths of mechanism."""
result = self.mechanism_data[row]
expression: str = result['expression']
same: Dict[int, int] = result['same']
inputs: List[Tuple[_Pair, _Coord]] = result['input']
input_list = []
for (b, d), _ in inputs:
for i in range(b):
if i in same:
b -= 1
for i in range(d):
if i in same:
d -= 1
input_list.append((b, d))
vpoints = parse_vpoints(expression)
expr = t_config(vpoints, input_list)
b, d = input_list[0]
base_angle = vpoints[b].slope_angle(vpoints[d])
path: List[List[_Coord]] = [[] for _ in range(len(vpoints))]
for angle in range(360 + 1):
try:
result_list = expr_solving(
expr,
{i: f"P{i}" for i in range(len(vpoints))},
vpoints,
[base_angle + angle] + [0] * (len(input_list) - 1)
)
except ValueError:
nan = float('nan')
for i in range(len(vpoints)):
path[i].append((nan, nan))
else:
for i in range(len(vpoints)):
coord = result_list[i]
if type(coord[0]) is tuple:
path[i].append(cast(_Coord, coord[1]))
else:
path[i].append(cast(_Coord, coord))
return path
def __get_path(self, row: int) -> List[List[_Coord]]:
"""Using result data to generate paths of mechanism."""
result = self.mechanism_data[row]
expression: str = result['expression']
same: Mapping[int, int] = result['same']
inputs: List[Tuple[_Pair, _Coord]] = result['input']
input_list = []
for (b, d), _ in inputs:
for i in range(b):
if i in same:
b -= 1
for i in range(d):
if i in same:
d -= 1
input_list.append((b, d))
vpoints = parse_vpoints(expression)
expr = t_config(vpoints, input_list)
b, d = input_list[0]
base_angle = vpoints[b].slope_angle(vpoints[d])
path: List[List[_Coord]] = [[] for _ in range(len(vpoints))]
input_pair = {(b, d): 0. for b, d in input_list}
for angle in range(360 + 1):
input_pair[b, d] = base_angle + angle
try:
result_list = expr_solving(expr, vpoints, input_pair)
except ValueError:
nan = float('nan')
for i in range(len(vpoints)):
path[i].append((nan, nan))
else:
for i in range(len(vpoints)):
coord = result_list[i]
if isinstance(coord[0], tuple):
path[i].append(coord[1])
else:
path[i].append(coord)
return path
def preview_path(self, auto_preview: List[List[Tuple[float, float]]],
slider_auto_preview: Dict[int, List[Tuple[float, float]]],
vpoints: Sequence[VPoint]):
"""Resolve auto preview path."""
if not self.right_input():
auto_preview.clear()
slider_auto_preview.clear()
return
vpoints = tuple(vpoint.copy() for vpoint in vpoints)
solve_kernel = self.prefer.path_preview_option
if solve_kernel == len(kernel_list):
solve_kernel = self.prefer.planar_solver_option
interval_o = self.inputs_widget.interval()
# path: [[p]: ((x0, y0), (x1, y1), (x2, y2), ...), ...]
auto_preview.clear()
slider_auto_preview.clear()
for i, vpoint in enumerate(vpoints):
auto_preview.append([])
if vpoint.type in {VJoint.P, VJoint.RP}:
slider_auto_preview[i] = []
bases = []
drivers = []
angles_o = []
for b, d, a in self.inputs_widget.input_pairs():
bases.append(b)
drivers.append(d)
angles_o.append(a)
i_count = self.inputs_widget.input_count()
# Cumulative angle
angles_cum = [0.] * i_count
nan = float('nan')
for interval in (interval_o, -interval_o):
# Driver pointer
dp = 0
angles = angles_o.copy()
while dp < i_count:
try:
if solve_kernel == 0:
result = expr_solving(
self.get_triangle(vpoints),
{n: f'P{n}'
for n in range(len(vpoints))}, vpoints, angles)
elif solve_kernel == 1:
if self.free_move_button.isChecked():
inputs: _Inputs = {}
else:
inputs = {(bases[i], drivers[i]): angles[i]
for i in range(i_count)}
result, _ = _slvs_solve(vpoints, inputs)
elif solve_kernel == 2:
result = SolverSystem(
vpoints, {(bases[i], drivers[i]): angles[i]
for i in range(i_count)}).solve()
else:
raise ValueError("incorrect kernel")
except ValueError:
# Update with error sign
for i in range(len(vpoints)):
auto_preview[i].append((nan, nan))
# Back to last feasible solution
angles[dp] -= interval
dp += 1
else:
# Update with result
for i, vpoint in enumerate(vpoints):
if vpoint.type == VJoint.R:
auto_preview[i].append(cast(_Coord, result[i]))
vpoint.move(cast(_Coord, result[i]))
elif vpoint.type in {VJoint.P, VJoint.RP}:
slot, pin = cast(Tuple[_Coord, _Coord], result[i])
# Pin path
auto_preview[i].append(pin)
# Slot path
slider_auto_preview[i].append(slot)
vpoint.move(slot, pin)
angles[dp] += interval
angles[dp] %= 360
angles_cum[dp] += abs(interval)
if angles_cum[dp] > 360:
angles[dp] -= interval
dp += 1
def preview_path(
self,
auto_preview: List[List[Tuple[float, float]]],
slider_auto_preview: Dict[int, List[Tuple[float, float]]],
vpoints: Sequence[VPoint]
):
"""Resolve auto preview path."""
auto_preview.clear()
slider_auto_preview.clear()
if not self.right_input():
return
vpoints = tuple(vpoint.copy() for vpoint in vpoints)
solve_kernel = self.prefer.path_preview_option
if solve_kernel == Kernel.SAME_AS_SOLVING:
solve_kernel = self.prefer.planar_solver_option
interval = self.inputs_widget.interval()
# path: [[p]: ((x0, y0), (x1, y1), (x2, y2), ...), ...]
for i, vpoint in enumerate(vpoints):
auto_preview.append([])
if vpoint.type in {VJoint.P, VJoint.RP}:
slider_auto_preview[i] = []
input_pair = {(b, d): a for b, d, a in self.inputs_widget.input_pairs()}
# Cumulative angle
angles_cum = dict.fromkeys(input_pair, 0.)
nan = float('nan')
for dp in input_pair:
for interval in (interval, -interval):
while 0 <= angles_cum[dp] <= 360:
try:
if solve_kernel == Kernel.PYSLVS:
result = expr_solving(
self.get_triangle(vpoints),
vpoints,
input_pair
)
elif solve_kernel == Kernel.SOLVESPACE:
result, _ = _slvs_solve(
vpoints,
{}
if self.free_move_button.isChecked() else
input_pair
)
elif solve_kernel == Kernel.SKETCH_SOLVE:
result = SolverSystem(vpoints, input_pair).solve()
else:
raise ValueError("incorrect kernel")
except ValueError:
# Update with error sign
for i in range(len(vpoints)):
auto_preview[i].append((nan, nan))
# Back to last feasible solution
input_pair[dp] -= interval
break
# Update with result
for i, vpoint in enumerate(vpoints):
if vpoint.type == VJoint.R:
auto_preview[i].append(cast(_Coord, result[i]))
vpoint.move(cast(_Coord, result[i]))
elif vpoint.type in {VJoint.P, VJoint.RP}:
slot, pin = cast(Tuple[_Coord, _Coord], result[i])
# Pin path
auto_preview[i].append(pin)
# Slot path
slider_auto_preview[i].append(slot)
vpoint.move(slot, pin)
angles_cum[dp] += abs(interval)
input_pair[dp] += interval
input_pair[dp] %= 360
for path in auto_preview:
path[:] = path[:-1]
"J[R, color[green], P[%d,%d], L[link_4, link_5]], "
"J[R, color[green], P[%d, %d], L[ground, link_4]], "
"]" % (-0.5 * Total, 0, -0.5 * Total + H * cos(phiLr), H * sin(phiLr),
-0.5 * Total + H * cos(phiLr) + H * cos(theta),
H * sin(phiLr) + H * sin(theta), -0.5 * Total + H * cos(phiLr) +
2 * H * cos(theta), H * sin(phiLr) + 2 * H * sin(theta),
-0.5 * Total + H * cos(phiLr) + 3 * H * cos(theta),
H * sin(phiLr) + 3 * H * sin(theta), 0.5 * Total, 0))
if Case == 1:
exprs = t_config(vpoints, ((0, 1), (1, 2), (2, 3)))
else:
theta_3 = 180 - theta_3
exprs = t_config(vpoints, ((0, 1), (1, 2), (5, 4)))
mapping = {n: f'P{n}' for n in range(len(vpoints))}
data_dict, dof = data_collecting(exprs, mapping, vpoints)
pos = expr_solving(exprs, mapping, vpoints, [theta_1, theta_2, theta_3])
position = [[0 for i in range(2)] for j in range(6)]
for i in range(6):
for j in range(2):
position[i][j] = float(pos[i][j])
print(pos)
x = [
position[0][0], position[1][0], position[2][0], position[3][0],
position[4][0], position[5][0]
]
z = [
position[0][1], position[1][1], position[2][1], position[3][1],
position[4][1], position[5][1]
]
print(x)
print(z)
