From 108f11eacf53daab33c65f4629de77280b205b51 Mon Sep 17 00:00:00 2001 From: Marius Stanciu Date: Sun, 21 Apr 2019 04:43:49 +0300 Subject: [PATCH] - finished adding the PDF import tool although it does not support all kinds of outputs from PDF printers. Microsoft PDF printer is not supported. --- FlatCAMApp.py | 1 + README.md | 4 + flatcamTools/ToolPDF.py | 532 ++++++++++++++++++++++++++++++++++------ 3 files changed, 459 insertions(+), 78 deletions(-) diff --git a/FlatCAMApp.py b/FlatCAMApp.py index 8620ed20..bad73459 100644 --- a/FlatCAMApp.py +++ b/FlatCAMApp.py @@ -7606,6 +7606,7 @@ class App(QtCore.QObject): openers = { 'gerber': lambda fname: self.worker_task.emit({'fcn': self.open_gerber, 'params': [fname]}), 'excellon': lambda fname: self.worker_task.emit({'fcn': self.open_excellon, 'params': [fname]}), + 'geometry': lambda fname: self.worker_task.emit({'fcn': self.import_dxf, 'params': [fname]}), 'cncjob': lambda fname: self.worker_task.emit({'fcn': self.open_gcode, 'params': [fname]}), 'project': self.open_project, 'svg': self.import_svg, diff --git a/README.md b/README.md index 54b860da..b8704ad8 100644 --- a/README.md +++ b/README.md @@ -9,6 +9,10 @@ CAD program, and create G-Code for Isolation routing. ================================================= +20.04.2019 + +- finished adding the PDF import tool although it does not support all kinds of outputs from PDF printers. Microsoft PDF printer is not supported. + 19.04.2019 - started to work on PDF import tool diff --git a/flatcamTools/ToolPDF.py b/flatcamTools/ToolPDF.py index b2676a3b..34a3be34 100644 --- a/flatcamTools/ToolPDF.py +++ b/flatcamTools/ToolPDF.py @@ -7,29 +7,33 @@ ############################################################ from FlatCAMTool import FlatCAMTool +from shapely.geometry import Point, Polygon, LineString +from shapely.ops import cascaded_union, unary_union + from FlatCAMObj import * + import math +from copy import copy, deepcopy import numpy as np -import scipy.interpolate import zlib import re import gettext import FlatCAMTranslation as fcTranslate +import builtins fcTranslate.apply_language('strings') -import builtins if '_' not in builtins.__dict__: _ = gettext.gettext class ToolPDF(FlatCAMTool): - ''' + """ Parse a PDF file. Reference here: https://www.adobe.com/content/dam/acom/en/devnet/pdf/pdfs/pdf_reference_archives/PDFReference.pdf Return a list of geometries - ''' + """ toolName = _("PDF Import Tool") def __init__(self, app): @@ -39,50 +43,72 @@ class ToolPDF(FlatCAMTool): self.stream_re = re.compile(b'.*?FlateDecode.*?stream(.*?)endstream', re.S) + # detect 're' command + self.rect_re = re.compile(r'^(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s*re$') + # detect 'm' command + self.start_subpath_re = re.compile(r'^(-?\d+\.?\d*)\s(-?\d+\.?\d*)\sm$') + # detect 'l' command + self.draw_line_re = re.compile(r'^(-?\d+\.?\d*)\s(-?\d+\.?\d*)\sl') + # detect 'c' command + self.draw_arc_3pt_re = re.compile(r'^(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)' + r'\s(-?\d+\.?\d*)\s*c$') + # detect 'v' command + self.draw_arc_2pt_c1start_re = re.compile(r'^(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s*v$') + # detect 'y' command + self.draw_arc_2pt_c2stop_re = re.compile(r'^(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s*y$') + # detect 'h' command + self.end_subpath_re = re.compile(r'^h$') + # detect 'w' command self.strokewidth_re = re.compile(r'^(\d+\.?\d*)\s*w$') - # detect 're' command - self.rect_re = re.compile(r'^(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\sre$') - # detect 'm' command - self.start_path_re = re.compile(r'(-?\d+\.?\d*)\s(-?\d+\.?\d*)\sm$') - # detect 'l' command - self.draw_line_re = re.compile(r'(-?\d+\.?\d*)\s(-?\d+\.?\d*)\sl') - # detect 'c' command - self.draw_arc_3pt_re = re.compile(r'(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\sc$') - # detect 'v' command - self.draw_arc_2pt_23_re = re.compile(r'(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\sv$') - # detect 'y' command - self.draw_arc_2pt_13_re = re.compile(r'(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\sy$') - # detect 'h' command - self.end_path_re = re.compile(r'^h$') + # detect 'S' command + self.stroke_path__re = re.compile(r'^S$') + # detect 's' command + self.close_stroke_path__re = re.compile(r'^s$') + # detect 'f' or 'f*' command + self.fill_path_re = re.compile(r'^[f|F][*]?$') + # detect 'B' or 'B*' command + self.fill_stroke_path_re = re.compile(r'^B[*]?$') + # detect 'b' or 'b*' command + self.close_fill_stroke_path_re = re.compile(r'^b[*]?$') + # detect 'n' + self.no_op_re = re.compile(r'^n$') + # detect offset transformation. Pattern: (1) (0) (0) (1) (x) (y) + self.offset_re = re.compile(r'^1\.?0*\s0?\.?0*\s0?\.?0*\s1\.?0*\s(-?\d+\.?\d*)\s(-?\d+\.?\d*)\s*cm$') + # detect scale transformation. Pattern: (factor_x) (0) (0) (factor_y) (0) (0) + self.scale_re = re.compile(r'^q? (-?\d+\.?\d*) 0\.?0* 0\.?0* (-?\d+\.?\d*) 0\.?0* 0\.?0*\s+cm$') + # detect combined transformation. Should always be the last + self.combined_transform_re = re.compile(r'^q?\s*(-?\d+\.?\d*) (-?\d+\.?\d*) (-?\d+\.?\d*) (-?\d+\.?\d*) ' + r'(-?\d+\.?\d*) (-?\d+\.?\d*)\s+cm$') + # detect clipping path + self.clip_path_re = re.compile(r'^W[*]? n?$') + + self.geo_buffer = [] self.pdf_parsed = '' + # conversion factor to INCH + self.point_to_unit_factor = 0.01388888888 + def run(self, toggle=True): self.app.report_usage("ToolPDF()") - # 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: - # 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) + # init variables for reuse + self.geo_buffer = [] + self.pdf_parsed = '' + + # the UNITS in PDF files are points and here we set the factor to convert them to real units (either MM or INCH) + if self.app.ui.general_defaults_form.general_app_group.units_radio.get_value().upper() == 'MM': + # 1 inch = 72 points => 1 point = 1 / 72 = 0.01388888888 inch = 0.01388888888 inch * 25.4 = 0.35277777778 mm + self.point_to_unit_factor = 0.35277777778 + else: + # 1 inch = 72 points => 1 point = 1 / 72 = 0.01388888888 inch + self.point_to_unit_factor = 0.01388888888 self.set_tool_ui() self.on_open_pdf_click() - # self.app.ui.notebook.setTabText(2, "PDF Tool") - def install(self, icon=None, separator=None, **kwargs): FlatCAMTool.install(self, icon, separator, shortcut='ALT+Q', **kwargs) @@ -104,75 +130,425 @@ class ToolPDF(FlatCAMTool): try: filenames, _f = QtWidgets.QFileDialog.getOpenFileNames(caption=_("Open PDF"), - directory=self.app.get_last_folder(), filter=_filter_) + directory=self.app.get_last_folder(), + filter=_filter_) except TypeError: filenames, _f = QtWidgets.QFileDialog.getOpenFileNames(caption=_("Open PDF"), filter=_filter_) - filenames = [str(filename) for filename in filenames] - if len(filenames) == 0: self.app.inform.emit(_("[WARNING_NOTCL] Open PDF cancelled.")) else: for filename in filenames: if filename != '': - self.app.worker_task.emit({'fcn': self.open_pdf, - 'params': [filename]}) + self.app.worker_task.emit({'fcn': self.open_pdf, 'params': [filename]}) def open_pdf(self, filename): + new_name = filename.split('/')[-1].split('\\')[-1] def obj_init(grb_obj, app_obj): with open(filename, "rb") as f: pdf = f.read() + stream_nr = 0 for s in re.findall(self.stream_re, pdf): + stream_nr += 1 + print("STREAM:", stream_nr, '\n', '\n') s = s.strip(b'\r\n') try: - self.pdf_parsed += zlib.decompress(s).decode('UTF-8') - except: - pass - grb_obj.solid_geometry = [self.bezier_to_linestring(0, 0, 0, 0)] + self.pdf_parsed += (zlib.decompress(s).decode('UTF-8') + '\r\n') + except Exception as e: + app_obj.log.debug("ToolPDF.open_pdf().obj_init() --> %s" % str(e)) + ap_dict = self.parse_pdf(pdf_content=self.pdf_parsed) + grb_obj.apertures = deepcopy(ap_dict) + + poly_buff = [] + for ap in ap_dict: + for k in ap_dict[ap]: + if k == 'solid_geometry': + poly_buff += ap_dict[ap][k] + + poly_buff = unary_union(poly_buff) + poly_buff = poly_buff.buffer(0.0000001) + poly_buff = poly_buff.buffer(-0.0000001) + + grb_obj.solid_geometry = deepcopy(poly_buff) with self.app.proc_container.new(_("Opening PDF.")): - # obj_init() - self.parse_pdf() - ret = self.app.new_object("geometry", "bla", obj_init, autoselected=False) - # Register recent file - self.app.file_opened.emit("geometry", "bla") - # # Object name - # name = outname or filename.split('/')[-1].split('\\')[-1] - # - # ret = self.new_object("excellon", name, obj_init, autoselected=False) - # if ret == 'fail': - # self.inform.emit(_('[ERROR_NOTCL] Open Excellon file failed. Probable not an Excellon file.')) - # return - # - # # Register recent file - # self.file_opened.emit("excellon", filename) - # - # # GUI feedback - # self.inform.emit(_("[success] Opened: %s") % filename) - # # self.progress.emit(100) - def parse_pdf(self): - for pline in self.pdf_parsed: - pass + ret = self.app.new_object("gerber", new_name, obj_init, autoselected=False) + if ret == 'fail': + self.app.inform.emit(_('[ERROR_NOTCL] Open PDF file failed.')) + return - def bezier_to_linestring(self, start, stop, c1, c2): + # Register recent file + self.app.file_opened.emit("gerber", new_name) + + # GUI feedback + self.app.inform.emit(_("[success] Opened: %s") % filename) + + def parse_pdf(self, pdf_content): + path = dict() + path['lines'] = [] # it's a list of points + path['bezier'] = [] # it's a list of sublists each like this [start, c1, c2, stop] + path['rectangle'] = [] # it's a list of sublists of points + + start_point = None + current_point = None + size = None + + # signal that we have encountered a close path command + flag_close_path = False + + # initial values for the transformations, in case they are not encountered in the PDF file + offset_geo = [0, 0] + scale_geo = [1, 1] + + # initial aperture + aperture = 10 + + # store the apertures here + apertures_dict = {} + + line_nr = 0 + lines = pdf_content.splitlines() + + for pline in lines: + line_nr += 1 + log.debug("line %d: %s" % (line_nr, pline)) + + # TRANSFORMATIONS DETECTION # + + # Detect Scale transform + match = self.scale_re.search(pline) + if match: + log.debug( + "ToolPDF.parse_pdf() --> SCALE transformation found on line: %s --> %s" % (line_nr, pline)) + scale_geo = [float(match.group(1)), float(match.group(2))] + continue + + # Detect Offset transform + match = self.offset_re.search(pline) + if match: + log.debug( + "ToolPDF.parse_pdf() --> OFFSET transformation found on line: %s --> %s" % (line_nr, pline)) + offset_geo = [float(match.group(1)), float(match.group(2))] + continue + + # Detect combined transformation. Must be always the last from transformations to be checked. + # TODO: Perhaps it can replace the others transformation detections + match = self.combined_transform_re.search(pline) + if match: + # transformation = TRANSLATION (OFFSET) + if float(match.group(1)) == 1 and float(match.group(2)) == 0 and \ + float(match.group(3)) == 0 and float(match.group(4)) == 1: + pass + + # transformation = SCALING + elif float(match.group(2)) == 0 and float(match.group(3)) == 0 and \ + float(match.group(5)) == 0 and float(match.group(6)) == 0: + pass + + # transformation = ROTATION + elif float(match.group(1)) == float(match.group(4)) and \ + float(match.group(2)) == - float(match.group(3)) and \ + float(match.group(5)) == 0 and float(match.group(6)) == 0: + # rot_angle = math.acos(float(match.group(1))) + pass + + # transformation = SKEW + elif float(match.group(1)) == 1 and float(match.group(4)) == 1 and \ + float(match.group(5)) == 0 and float(match.group(6)) == 0: + # skew_x = math.atan(float(match.group(2))) + # skew_y = math.atan(float(match.group(3))) + pass + + # transformation combined + else: + log.debug("ToolPDF.parse_pdf() --> COMBINED transformation found on line: %s --> %s" % + (line_nr, pline)) + scale_geo = [float(match.group(1)), float(match.group(4))] + offset_geo = [float(match.group(5)), float(match.group(6))] + continue + + # PATH CONSTRUCTION # + + # Start SUBPATH + match = self.start_subpath_re.search(pline) + if match: + x = float(match.group(1)) + offset_geo[0] + y = float(match.group(2)) + offset_geo[1] + pt = (x * self.point_to_unit_factor * scale_geo[0], y * self.point_to_unit_factor * scale_geo[1]) + start_point = pt + current_point = pt + continue + + # Draw Line + match = self.draw_line_re.search(pline) + if match: + x = float(match.group(1)) + offset_geo[0] + y = float(match.group(2)) + offset_geo[1] + pt = (x * self.point_to_unit_factor * scale_geo[0], y * self.point_to_unit_factor * scale_geo[1]) + path['lines'].append(pt) + current_point = pt + continue + + # Draw Bezier 'c' + match = self.draw_arc_3pt_re.search(pline) + if match: + start = current_point + x = float(match.group(1)) + offset_geo[0] + y = float(match.group(2)) + offset_geo[1] + c1 = (x * self.point_to_unit_factor * scale_geo[0], y * self.point_to_unit_factor * scale_geo[1]) + x = float(match.group(3)) + offset_geo[0] + y = float(match.group(4)) + offset_geo[1] + c2 = (x * self.point_to_unit_factor * scale_geo[0], y * self.point_to_unit_factor * scale_geo[1]) + x = float(match.group(5)) + offset_geo[0] + y = float(match.group(6)) + offset_geo[1] + stop = (x * self.point_to_unit_factor * scale_geo[0], y * self.point_to_unit_factor * scale_geo[1]) + + path['bezier'].append([start, c1, c2, stop]) + current_point = stop + continue + + # Draw Bezier 'v' + match = self.draw_arc_2pt_c1start_re.search(pline) + if match: + start = current_point + x = float(match.group(1)) + offset_geo[0] + y = float(match.group(2)) + offset_geo[1] + c2 = (x * self.point_to_unit_factor * scale_geo[0], y * self.point_to_unit_factor * scale_geo[1]) + x = float(match.group(3)) + offset_geo[0] + y = float(match.group(4)) + offset_geo[1] + stop = (x * self.point_to_unit_factor * scale_geo[0], y * self.point_to_unit_factor * scale_geo[1]) + + path['bezier'].append([start, start, c2, stop]) + current_point = stop + continue + + # Draw Bezier 'y' + match = self.draw_arc_2pt_c2stop_re.search(pline) + if match: + start = current_point + x = float(match.group(1)) + offset_geo[0] + y = float(match.group(2)) + offset_geo[1] + c1 = (x * self.point_to_unit_factor * scale_geo[0], y * self.point_to_unit_factor * scale_geo[1]) + x = float(match.group(3)) + offset_geo[0] + y = float(match.group(4)) + offset_geo[1] + stop = (x * self.point_to_unit_factor * scale_geo[0], y * self.point_to_unit_factor * scale_geo[1]) + + path['bezier'].append([start, c1, stop, stop]) + current_point = stop + continue + + # Close SUBPATH + match = self.end_subpath_re.search(pline) + if match: + flag_close_path = True + continue + + # Draw RECTANGLE + match = self.rect_re.search(pline) + if match: + x = (float(match.group(1)) + offset_geo[0]) * self.point_to_unit_factor * scale_geo[0] + y = (float(match.group(2)) + offset_geo[1]) * self.point_to_unit_factor * scale_geo[1] + width = (float(match.group(3)) + offset_geo[0]) * self.point_to_unit_factor * scale_geo[0] + height = (float(match.group(4)) + offset_geo[1]) * self.point_to_unit_factor * scale_geo[1] + pt1 = (x, y) + pt2 = (x+width, y) + pt3 = (x+width, y+height) + pt4 = (x, y+height) + path['rectangle'] += [pt1, pt2, pt3, pt4, pt1] + current_point = pt1 + continue + + # Detect clipping path set + # ignore this and delete the current subpath + match = self.clip_path_re.search(pline) + if match: + path['lines'] = [] + path['bezier'] = [] + path['rectangle'] = [] + continue + + # PATH PAINTING # + + # Detect Stroke width / aperture + match = self.strokewidth_re.search(pline) + if match: + size = float(match.group(1)) * self.point_to_unit_factor * scale_geo[0] + flag = 0 + + if not apertures_dict: + apertures_dict[str(aperture)] = dict() + apertures_dict[str(aperture)]['size'] = size + apertures_dict[str(aperture)]['type'] = 'C' + apertures_dict[str(aperture)]['solid_geometry'] = [] + else: + for k in apertures_dict: + if size == apertures_dict[k]['size']: + flag = 1 + break + if flag == 0: + aperture += 1 + apertures_dict[str(aperture)] = dict() + apertures_dict[str(aperture)]['size'] = size + apertures_dict[str(aperture)]['type'] = 'C' + apertures_dict[str(aperture)]['solid_geometry'] = [] + continue + + # Detect No_Op command, ignore the current subpath + match = self.no_op_re.search(pline) + if match: + path['lines'] = [] + path['bezier'] = [] + path['rectangle'] = [] + continue + + # Stroke the path + match = self.stroke_path__re.search(pline) + if match: + # path['lines'] = [] + # path['bezier'] = [] + # path['rectangle'] = [] + # continue + geo = None + if path['lines']: + path['lines'].insert(0, start_point) + geo = copy(path['lines']) + if flag_close_path: + flag_close_path = False + geo.append(start_point) + path['lines'] = [] + + if path['bezier']: + geo = list() + geo.append(start_point) + for b in path['bezier']: + geo += self.bezier_to_points(start=b[0], c1=b[1], c2=b[2], stop=b[3]) + if flag_close_path: + flag_close_path = False + geo.append(start_point) + path['bezier'] = [] + + if path['rectangle']: + geo = copy(path['rectangle']) + # if flag_close_path: + # flag_close_path = False + # geo.append(start_point) + path['rectangle'] = [] + + ext_geo = LineString(geo) + ext_geo = ext_geo.buffer((float(size) / 2), resolution=self.step_per_circles) + # ext_geo = affinity.scale(ext_geo, scale_geo[0], scale_geo[1]) + # off_x = offset_geo[0] + # off_y = offset_geo[1] + # + # ext_geo = affinity.translate(ext_geo, off_x, off_y) + try: + apertures_dict[str(aperture)]['solid_geometry'].append(deepcopy(ext_geo)) + except KeyError: + # in case there is no stroke width yet therefore no aperture + apertures_dict['0'] = {} + apertures_dict['0']['solid_geometry'] = [] + apertures_dict['0']['size'] = size + apertures_dict['0']['type'] = 'C' + apertures_dict['0']['solid_geometry'].append(deepcopy(ext_geo)) + continue + + # Fill the path + match = self.fill_path_re.search(pline) + match2 = self.fill_stroke_path_re.search(pline) + if match or match2: + + geo = None + if path['lines']: + path['lines'].insert(0, start_point) + geo = copy(path['lines']) + geo.append(start_point) + path['lines'] = [] + + elif path['bezier']: + geo = [] + for b in path['bezier']: + geo += self.bezier_to_points(start=b[0], c1=b[1], c2=b[2], stop=b[3]) + geo.append(start_point) + path['bezier'] = [] + + elif path['rectangle']: + # path['rectangle'].append(start_point) + geo = copy(path['rectangle']) + path['rectangle'] = [] + + ext_geo = Polygon(geo) + ext_geo = ext_geo.buffer(0.000001, resolution=self.step_per_circles) + # ext_geo = affinity.scale(ext_geo, scale_geo[0], scale_geo[1]) + # off_x = offset_geo[0] + # off_y = offset_geo[1] + # + # ext_geo = affinity.translate(ext_geo, off_x, off_y) + try: + apertures_dict[str(aperture)]['solid_geometry'].append(deepcopy(ext_geo)) + except KeyError: + # in case there is no stroke width yet therefore no aperture + apertures_dict['0'] = {} + apertures_dict['0']['solid_geometry'] = [] + apertures_dict['0']['size'] = size + apertures_dict['0']['type'] = 'C' + apertures_dict['0']['solid_geometry'].append(deepcopy(ext_geo)) + continue + + return apertures_dict + + def bezier_to_points(self, start, c1, c2, stop): """ - From here: https://gis.stackexchange.com/questions/106937/python-library-or-algorithm-to-generate-arc-geometry-from-three-coordinate-pairs + # Equation Bezier, page 184 PDF 1.4 reference + # https://www.adobe.com/content/dam/acom/en/devnet/pdf/pdfs/pdf_reference_archives/PDFReference.pdf + # Given the coordinates of the four points, the curve is generated by varying the parameter t from 0.0 to 1.0 + # in the following equation: + # R(t) = P0*(1 - t) ** 3 + P1*3*t*(1 - t) ** 2 + P2 * 3*(1 - t) * t ** 2 + P3*t ** 3 + # When t = 0.0, the value from the function coincides with the current point P0; when t = 1.0, R(t) coincides + # with the final point P3. Intermediate values of t generate intermediate points along the curve. + # The curve does not, in general, pass through the two control points P1 and P2 + :return: LineString geometry """ - coords = np.array([[0, 0], [25, 10], [33, 39], [53, 53]]) - # equation Bezier, page 184 PDF 1.4 reference - # https://www.adobe.com/content/dam/acom/en/devnet/pdf/pdfs/pdf_reference_archives/PDFReference.pdf - # R(t) = P0*(1 - t) ** 3 + P1*3*t*(1 - 5) ** 2 + P2 * 3*(1 - t) * t ** 2 + P3*t ** 3 + # here we store the geometric points + points = [] - domain = [] - i = 0 - while i <=1: - domain.append(i) - for i in domain: + nr_points = np.arange(0.0, 1.0, (1 / self.step_per_circles)) + for t in nr_points: + term_p0 = (1 - t) ** 3 + term_p1 = 3 * t * (1 - t) ** 2 + term_p2 = 3 * (1 - t) * t ** 2 + term_p3 = t ** 3 - return even_line + x = start[0] * term_p0 + c1[0] * term_p1 + c2[0] * term_p2 + stop[0] * term_p3 + y = start[1] * term_p0 + c1[1] * term_p1 + c2[1] * term_p2 + stop[1] * term_p3 + points.append([x, y]) + + return points + + # def bezier_to_circle(self, path): + # lst = [] + # for el in range(len(path)): + # if type(path) is list: + # for coord in path[el]: + # lst.append(coord) + # else: + # lst.append(el) + # + # if lst: + # minx = min(lst, key=lambda t: t[0])[0] + # miny = min(lst, key=lambda t: t[1])[1] + # maxx = max(lst, key=lambda t: t[0])[0] + # maxy = max(lst, key=lambda t: t[1])[1] + # center = (maxx-minx, maxy-miny) + # radius = (maxx-minx) / 2 + # return [center, radius] + # + # def circle_to_points(self, center, radius): + # geo = Point(center).buffer(radius, resolution=self.step_per_circles) + # return LineString(list(geo.exterior.coords)) + #