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)