# -*- coding: utf-8 -*- from __future__ import absolute_import from __future__ import division ############################################################################ # # Copyright (C) 2008-2015 # Christian Kohlöffel # Jean-Paul Schouwstra # # This file is part of DXF2GCODE. # # DXF2GCODE is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DXF2GCODE is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with DXF2GCODE. If not, see . # ############################################################################ from __future__ import absolute_import from copy import deepcopy, copy import logging from core.point import Point from dxfimport.classes import ContourClass from dxfimport.geoent_arc import GeoentArc from dxfimport.geoent_circle import GeoentCircle from dxfimport.geoent_insert import GeoentInsert from dxfimport.geoent_line import GeoentLine from dxfimport.geoent_polyline import GeoentPolyline from dxfimport.geoent_spline import GeoentSpline from dxfimport.geoent_ellipse import GeoentEllipse from dxfimport.geoent_lwpolyline import GeoentLwPolyline from dxfimport.geoent_point import GeoentPoint import globals.globals as g from globals.six import text_type import globals.constants as c if c.PYQT5notPYQT4: from PyQt5.QtWidgets import QMessageBox from PyQt5 import QtCore else: from PyQt4.QtGui import QMessageBox from PyQt4 import QtCore logger = logging.getLogger("DxfImport.Import") class ReadDXF(QtCore.QObject): # Initialise the class def __init__(self, filename=None): QtCore.QObject.__init__(self) # Setting up logger # logger = g.logger.logger str_ = self.Read_File(filename) g.config.metric = self.Get_Unit(str_) self.update_tool_values() # Load the contour and store the values in the classes self.line_pairs = self.Get_Line_Pairs(str_) # Debug Informationen # logger.info(("\n\nFile has %0.0f Lines" % len(str_)), 1) # logger.info(("\nFile has %0.0f Linepairs" % self.line_pairs.nrs), 1) logger.info(self.tr("Reading DXF Structure")) sections_pos = self.Get_Sections_pos() self.layers = self.Read_Layers(sections_pos) blocks_pos = self.Get_Blocks_pos(sections_pos) self.blocks = self.Read_Blocks(blocks_pos) self.entities = self.Read_Entities(sections_pos) # Aufruf der Klasse um die Konturen zur suchen # Schleife f�r die Anzahl der Bl�cke und den Layern # Call the class to define the contours of search # Loop for the number of blocks and the layer for i in range(len(self.blocks.Entities)): # '\n' # print self.blocks.Entities[i] logger.info(self.tr("Creating Contours of Block Nr: %i") %i) self.blocks.Entities[i].cont = self.Get_Contour(self.blocks.Entities[i]) logger.info(self.tr("Creating Contours of Entities")) self.entities.cont = self.Get_Contour(self.entities) def tr(self, string_to_translate): """ Translate a string using the QCoreApplication translation framework @param: string_to_translate: a unicode string @return: the translated unicode string if it was possible to translate """ return text_type(QtCore.QCoreApplication.translate('ReadDXF', string_to_translate)) def Read_File(self, filename): """ Read_File() - Load the selected DXF files @param: filename: name of the file to load @return: file contents as a list of strings """ encodings = ['utf-8', 'cp1252', 'cp850'] last_exception = None for e in encodings: try: file_ = open(filename, 'r', encoding=e) str_ = file_.readlines() file_.close() return str_ except UnicodeDecodeError as ex: last_exception = ex logger.debug("Read_File: UnicodeDecodeError: {0}".format(ex)) pass # If that happens, please consider to extend the list of supported encodings. raise last_exception def Get_Unit(self, str): """ Get_Unit() - Get unit of measure English (Imperial) or Metric from DXF file """ # Set drawing units: 0 = English; 1 = Metric # Metric will be treated as being in millimeters # English as inches metric = 1 # default: metric for line in range(len(str) - 2): if str[line].startswith("$MEASUREMENT"): metric = int(str[line + 2].strip()) break # Default drawing units for AutoCAD DesignCenter blocks: # 0 = Unitless; 1 = Inches; 2 = Feet; 3 = Miles; 4 = Millimeters; # 5 = Centimeters; 6 = Meters; 7 = Kilometers; 8 = Microinches; # 9 = Mils (thous); 10 = Yards; 11 = Angstroms; 12 = Nanometers; # 13 = Microns; 14 = Decimeters; 15 = Decameters; # 16 = Hectometers; 17 = Gigameters; 18 = Astronomical units; # 19 = Light years; 20 = Parsecs for line in range(len(str) - 2): if str[line].startswith("$INSUNITS"): if int(str[line + 2].strip()) == 1: metric = 0 elif int(str[line + 2].strip()) == 4: metric = 1 break return metric def update_tool_values(self): # update the tool default values depending on the unit of the drawing if g.config.tool_units_metric != g.config.metric: scale = 1/25.4 if g.config.metric == 0 else 25.4 for key in g.config.vars.Plane_Coordinates: g.config.vars.Plane_Coordinates[key] *= scale for key in g.config.vars.Depth_Coordinates: g.config.vars.Depth_Coordinates[key] *= scale for key in g.config.vars.Feed_Rates: g.config.vars.Feed_Rates[key] *= scale for tool in g.config.vars.Tool_Parameters: g.config.vars.Tool_Parameters[tool]['diameter'] *= scale g.config.vars.Tool_Parameters[tool]['start_radius'] *= scale g.config.tool_units_metric = g.config.metric # Convert the uploaded file into line pairs (code & Value). def Get_Line_Pairs(self, string): line = 0 line_pairs = dxflinepairsClass([]) # Start at the first SECTION while not string[line].startswith("SECTION"): line += 1 line -= 1 # Continue to the end if no error occurs. Otherwise abort with error try: while line + 1 < len(string): line_pairs.line_pair.append(dxflinepairClass(int(string[line].strip()), string[line + 1].strip())) line += 2 except ValueError: message = self.tr('Reading stopped at line %i.\n "%s" is not a valid code (number) - please, check/correct dxf file')\ % (line + 1, string[line].strip()) logger.warning(message) QMessageBox.warning(g.window, self.tr("Warning reading linepairs"), message) line_pairs.nrs = len(line_pairs.line_pair) logger.debug(self.tr('Did read %i of linepairs from DXF') % line_pairs.nrs) return line_pairs # Search the sections in the DXF file to recognize Blocke. def Get_Sections_pos(self): """ Get_Sections_pos() """ sections = [] start = self.line_pairs.index_both(0, "SECTION", 0) # Wenn eine Gefunden wurde diese anh�ngen # If a has been found for this attach ??? while start is not None: # Wenn eine Gefunden wurde diese anh�ngen # If a has been found for this attach ??? sections.append(SectionClass(len(sections))) sections[-1].begin = start name_pos = self.line_pairs.index_code(2, start + 1) sections[-1].name = self.line_pairs.line_pair[name_pos].value end = self.line_pairs.index_both(0, "ENDSEC", start + 1) # If section was not properly terminated if end is None: end = self.line_pairs.nrs - 1 sections[-1].end = end start = self.line_pairs.index_both(0, "SECTION", end) # g.logger.logger.info(("\n\nSections found:"), 1) # for sect in sections: # g.logger.logger.info(str(sect), 1) return sections # Search the TABLES section of the sections within this include LAYERS ??? def Read_Layers(self, section): """ Read_Layers() """ for sect_nr in range(len(section)): if section[sect_nr].name.startswith("TABLES"): # tables_section = section[sect_nr] break # If the DXF blocks has, read this??? layers = [] if 'tables_section' in vars(): tables_section = section[sect_nr] start = tables_section.begin while start is not None: start = self.line_pairs.index_both(0, "LAYER", start + 1, tables_section.end) if start is not None: start = self.line_pairs.index_code(2, start + 1) layers.append(LayerClass(len(layers))) layers[-1].name = self.line_pairs.line_pair[start].value # g.logger.logger.info(("Layers found:"), 1) # for lay in layers: # g.logger.logger.info(str(lay), 1) return layers # Search the BLOCKS section within sections def Get_Blocks_pos(self, section): """ Get_Blocks_pos() """ for sect_nr in range(len(section)): if section[sect_nr].name.startswith("BLOCKS"): blocks_section = section[sect_nr] break # If the DXF blocks has, read this??? blocks = [] if 'blocks_section' in vars(): # start = blocks_section.begin start = self.line_pairs.index_both(0, "BLOCK", blocks_section.begin, blocks_section.end) while start is not None: blocks.append(SectionClass()) blocks[-1].Nr = len(blocks) blocks[-1].begin = start name_pos = self.line_pairs.index_code(2, start + 1, blocks_section.end) blocks[-1].name = self.line_pairs.line_pair[name_pos].value end = self.line_pairs.index_both(0, "ENDBLK", start + 1, blocks_section.end) blocks[-1].end = end start = self.line_pairs.index_both(0, "BLOCK", end + 1, blocks_section.end) # g.logger.logger.info(("Blocks found:"), 1) # for bl in blocks: # g.logger.logger.info(str(bl), 1) return blocks def Read_Blocks(self, blocks_pos): """ Read_Blocks() - Read the block geometries """ blocks = BlocksClass([]) for block_nr in range(len(blocks_pos)): logger.info("Reading Block %s; Nr: %i" % (blocks_pos[block_nr].name, block_nr)) blocks.Entities.append(EntitiesClass(block_nr, blocks_pos[block_nr].name, [])) # Read the Baseline values for the block s = blocks_pos[block_nr].begin + 1 e = blocks_pos[block_nr].end - 1 lp = self.line_pairs # X value s = lp.index_code(10, s + 1, e) logger.debug("Found block pos Value 10 at: %s" %s) if s is None: blocks.Entities[-1].basep.x = 0.0 s = blocks_pos[block_nr].begin + 1 else: blocks.Entities[-1].basep.x = float(lp.line_pair[s].value) # Y value s = lp.index_code(20, s + 1, e) if s is None: blocks.Entities[-1].basep.y = 0.0 s = blocks_pos[block_nr].begin + 1 else: blocks.Entities[-1].basep.y = float(lp.line_pair[s].value) # Read the geometries blocks.Entities[-1].geo = self.Get_Geo(s, e) return blocks def Read_Entities(self, sections): """ Read_Entities() - Read the entities geometries """ for section_nr in range(len(sections)): if sections[section_nr - 1].name.startswith("ENTITIES"): # g.logger.logger.info("Reading Entities", 1) entities = EntitiesClass(0, 'Entities', []) entities.geo = self.Get_Geo(sections[section_nr - 1].begin + 1, sections[section_nr - 1].end - 1) return entities def Get_Geo(self, begin, end): """ Get_Geo() - Read the geometries of Blocks and Entities """ geos = [] self.start = self.line_pairs.index_code(0, begin, end) # old_start = self.start while self.start is not None: # Load the currently found geometry name = self.line_pairs.line_pair[self.start].value entitie_geo = self.get_geo_entitie(len(geos), name) # Append only if something was found if entitie_geo is not None: geos.append(entitie_geo) # Start the next search after one just found self.start = self.line_pairs.index_code(0, self.start, end) # Show debugging information if desired # if self.start is not None: # g.logger.logger.info("Found %s at Linepair %0.0f (Line %0.0f till %0.0f)" \ # % (name, old_start, old_start * 2 + 4, end * 2 + 4), 1) # else: # g.logger.logger.info("Found %s at Linepair %0.0f (Line %0.0f till %0.0f)" \ # % (name, old_start, old_start * 2 + 4, self.start * 2 + 4), 1) # if len(geos) > 0: # g.logger.logger.info(str(geos[-1]), 2) # old_start = self.start del self.start return geos # Verteiler f�r die Geo-Instanzen # wird in def Get_Geo aufgerufen # f�r einen Release kann der ganze Code gerne wieder in einer Datei landen. # Distributor for Geo instances ??? # is called in def Get_Geo # For a release of the entire code can be happy again end up in a file. ??? def get_geo_entitie(self, geo_nr, name): """ get_geo_entitie() """ # Entities: # 3DFACE, 3DSOLID, ACAD_PROXY_ENTITY, ARC, ATTDEF, ATTRIB, BODY # CIRCLE, DIMENSTION, ELLIPSE, HATCH, IMAGE, INSERT, LEADER, LINE, # LWPOLYLINE, MLINE, MTEXT, OLEFRAME, OLE2FRAME, POINT, POLYLINE, # RAY, REGION, SEQEND, SHAPE, SOLID, SPLINE, XT, TOLERANCE, TRACE, # VERTEX, VIEWPOINT, XLINE # Instanz des neuen Objekts anlegen und gleichzeitig laden # Create a new instance of the object and at the same load ??? if name == "POLYLINE": geo = GeoentPolyline(geo_nr, self) elif name == "SPLINE": geo = GeoentSpline(geo_nr, self) elif name == "ARC": geo = GeoentArc(geo_nr, self) elif name == "CIRCLE": geo = GeoentCircle(geo_nr, self) elif name == "LINE": geo = GeoentLine(geo_nr, self) elif name == "INSERT": geo = GeoentInsert(geo_nr, self) elif name == "ELLIPSE": geo = GeoentEllipse(geo_nr, self) elif name == "LWPOLYLINE": geo = GeoentLwPolyline(geo_nr, self) elif name == "POINT": geo = GeoentPoint(geo_nr, self) else: logger.info(("Found unsupported geometry type: %s !" % name)) self.start += 1 # Eins hochz�hlen sonst gibts ne dauer Schleife return None return geo def Get_Layer_Nr(self, Layer_Name): """ Get_Layer_Nr() - Find the number of geometry layers """ for i in range(len(self.layers)): if self.layers[i].name == Layer_Name: layer_nr = i return layer_nr layer_nr = len(self.layers) self.layers.append(LayerClass(layer_nr)) self.layers[-1].name = Layer_Name return layer_nr def Get_Block_Nr(self, Block_Name): """ Get_Block_Nr() - Find the number of blocks """ block_nr = -1 for i in range(len(self.blocks.Entities)): if self.blocks.Entities[i].Name == Block_Name: block_nr = i break return block_nr def Get_Contour(self, entities=None): """ Get_Contour() - Find the best contour the composite geometries """ cont = [] points = self.App_Cont_or_Calc_IntPts(entities.geo, cont) points = self.Find_Common_Points(points) # points = self.Remove_Redundant_Geos(points) found_cont = self.Search_Contours(entities.geo, points) # for check_cont in found_cont: # logger.debug("Correcting Contour inaccuracies if found") # for geo_nr in range(1, len(check_cont.order)): # geo1 = check_cont.order[geo_nr - 1] # geo2 = check_cont_order[geo_nr] # logger.debug(geo[geo_nr]) cont += found_cont return cont def App_Cont_or_Calc_IntPts(self, geo=None, cont=None): """ App_Cont_or_Calc_IntPts() Calculate and assign the start and end points """ tol = g.config.point_tolerance points = [] warning = 0 for i in range(len(geo)): # logger.debug("geo: %s" %geo[i]) warning = geo[i].App_Cont_or_Calc_IntPts(cont, points, i, tol, warning) if warning: QMessageBox.warning(g.window, self.tr("Short Elements"), self.tr("Length of some Elements too short!" "\nLength must be greater than tolerance." "\nSkipped Geometries")) return points def Find_Common_Points(self, points=None): """ Find_Common_Points() - Find common points """ # tol = self.config.points_tolerance.get() tol = g.config.point_tolerance p_list = [] # Einen List aus allen Punkten generieren # Generate list of all points for p in points: p_list.append([p.Layer_Nr, p.be.x, p.be.y, p.point_nr, 0]) p_list.append([p.Layer_Nr, p.en.x, p.en.y, p.point_nr, 1]) # Sort the list p_list.sort() # print p_list # Loop for number of list items # Start = where to begin the search of the same elements anf = [] for l_nr in range(len(p_list)): inter = [] # print ("Suche Starten f�r Geometrie Nr: %i, Punkt %i" % (p_list[l_nr][3], l_nr)) if isinstance(anf, list): c_nr = 0 else: c_nr = anf anf = [] # Schleife bis n�chster X Wert Gr��er ist als selbst +tol und Layer Gr��er gleich # Loop until the next X value is greater than yourself and layer Gr + tol he same ??? while p_list[c_nr][0] < p_list[l_nr][0] or \ p_list[c_nr][1] <= (p_list[l_nr][1] + tol): # print ("Suche Punkt %i" % (c_nr)) # Erstes das �bereinstimmt is der n�chste Anfang # First, the match is the next start if isinstance(anf, list) and\ p_list[c_nr][0] == p_list[l_nr][0] and\ abs(p_list[c_nr][1] - p_list[l_nr][1]) <= tol: anf = c_nr # print ("N�chste Suche starten bei" +str(anf)) # Falls gleich anh�ngen # Attach if equal ??? if p_list[c_nr][0] == p_list[l_nr][0] and \ abs(p_list[c_nr][1] - p_list[l_nr][1]) <= tol and\ abs(p_list[c_nr][2] - p_list[l_nr][2]) <= tol and\ c_nr != l_nr: inter.append(c_nr) # print ("Gefunden" +str(inter)) c_nr += 1 if c_nr == len(p_list): break # Anh�ngen der gefundenen Punkte an points # Append the found points for int_p in inter: # Common Anfangspunkt # Common starting point if p_list[l_nr][-1] == 0: points[p_list[l_nr][-2]].be_cp.append(p_list[int_p][3:5]) # Common Endpunkt # Common end point else: points[p_list[l_nr][-2]].en_cp.append(p_list[int_p][3:5]) return points def Remove_Redundant_Geos(self, geo=None, points=None): """ Remove_Redundant_Geos() - Does nothing! """ pass # del_points=[] # for p_nr in range(len(points)): # if not(p_nr in del_points): # for be_p in points[p_nr].be_cp: # for en_p in points[p_nr].en_cp: # if be_p[0] == en_p[0]: # del_points.append(be_p[0]) # print ('Gleiche Punkte in Anfang: %s und Ende %s' % (be_p, en_p)) # # #L�schen der �berfl�ssigen Punkte # #Delete the ? points ??? # for p_nr in del_points: # for j in range(len(points)): # if p_nr == points[j].point_nr: # del points[j] # break # return points def Search_Contours(self, geo = None, all_points = None): """ Search_Contours() - Find the best continuous contours """ found_contours = [] points = deepcopy(all_points) while len(points) > 0: # print '\n Neue Suche' # Wenn nichts gefunden wird dann einfach die Kontur hochz�hlen # If nothing found then count up the contour if len(points[0].be_cp) == 0 and len(points[0].en_cp) == 0: # print '\nGibt Nix' found_contours.append(ContourClass(len(found_contours), 0, [[points[0].point_nr, 0]], 0)) elif len(points[0].be_cp) == 0 and len(points[0].en_cp) > 0: # print '\nGibt was R�ckw�rts (Anfang in neg dir)' new_cont_pos = self.Search_Paths(0, [], points[0].point_nr, 0, points) found_contours.append(self.Get_Best_Contour(len(found_contours), new_cont_pos, geo, points)) elif len(points[0].be_cp) > 0 and len(points[0].en_cp) == 0: # print '\nGibt was Vorw�rt (Ende in pos dir)' new_cont_neg = self.Search_Paths(0, [], points[0].point_nr, 1, points) found_contours.append(self.Get_Best_Contour(len(found_contours), new_cont_neg, geo, points)) elif len(points[0].be_cp) > 0 and len(points[0].en_cp) > 0: # print '\nGibt was in beiden Richtungen' # Suchen der m�glichen Pfade # Search the possible paths new_cont_pos = self.Search_Paths(0, [], points[0].point_nr, 1, points) # Bestimmen des besten Pfades und �bergabe in cont # Determine the best path and Xbergabe in cont ??? found_contours.append(self.Get_Best_Contour(len(found_contours), new_cont_pos, geo, points)) # points = self.Remove_Used_Points(cont[-1], points) # Falls der Pfad nicht durch den ersten Punkt geschlossen ist # If the path is not closed by the first point if found_contours[-1].closed == 0: # print '\nPfad nicht durch den ersten Punkt geschlossen' found_contours[-1].reverse() # print ("Neue Kontur umgedrejt %s" % cont[-1]) new_cont_neg = self.Search_Paths(0, [found_contours[-1]], points[0].point_nr, 0, points) found_contours[-1] = self.Get_Best_Contour(len(found_contours) - 1, new_cont_neg + new_cont_pos, geo, points) else: print('FEHLER !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!') points = self.Remove_Used_Points(found_contours[-1], points) found_contours[-1] = self.Contours_Points2Geo(found_contours[-1], all_points) return found_contours def Search_Paths(self, c_nr=None, c=None, p_nr=None, dir=None, points=None): """ Search_Paths() - Search the paths through the Contour """ # Define the direction of the search (1 = positive, 0 = neg or reverse) # If it is the first call a new contour is to be created if len(c) == 0: c.append(ContourClass(cont_nr=0, order=[[p_nr, dir]])) # Suchen des Punktes innerhalb der points List (n�tig da verwendete Punkte gel�scht werden) # Search for the item within the list of points (ntig used as points gelscht) ??? for new_p_nr in range(len(points)): if points[new_p_nr].point_nr == p_nr: break # Next point depending on the direction if dir == 0: weiter = points[new_p_nr].en_cp elif dir == 1: weiter = points[new_p_nr].be_cp # Schleife f�r die Anzahl der Abzweig M�glichkeiten # Loop for the number of the branch can write ??? for i in range(len(weiter)): # Wenn es die erste M�glichkeit ist Hinzuf�gen zur aktuellen Kontur # If it is the first possibility to add to the current contour if i == 0: if not(c[c_nr].is_contour_closed()): c[c_nr].order.append(weiter[0]) # There is a branch. It is copied to the current contour and the # other branches follow elif i > 0: if not(c[c_nr].is_contour_closed()): # print 'Abzweig ist m�glich' c.append(deepcopy(c[c_nr])) del c[-1].order[-1] c[-1].order.append(weiter[i]) for i in range(len(weiter)): # print 'I ist: ' +str(i) if i == 0: new_c_nr = c_nr else: new_c_nr = len(c) - len(weiter) + i new_p_nr = c[new_c_nr].order[-1][0] new_dir = c[new_c_nr].order[-1][1] if not(c[new_c_nr].is_contour_closed()): c = self.Search_Paths(copy(new_c_nr), c, copy(new_p_nr), copy(new_dir), points) return c def Get_Best_Contour(self, c_nr, c=None, geo=None, points=None): """ Get_Best_Contour() - Seek for the best (in my opinion) countour """ # Shortlist of the new contour best = None best_open = None # print ("Es wurden %0.0f Konturen gefunden" %len(c)) for i in range(len(c)): # if len(c)>1: # print ("Kontur Nr %0.0f" %i) # print c[i] # Korrigieren der Kontur falls sie nicht in sich selbst geschlossen ist # The correct contour if it is not closed in on itself if c[i].closed == 2: c[i].remove_other_closed_contour() c[i].closed = 0 c[i].calc_length(geo) # Search for the best geometry if c[i].closed == 1: c[i].calc_length(geo) if best is None: best = i else: if c[best].length < c[i].length: best = i elif c[i].closed == 0: c[i].calc_length(geo) if best_open is None: best_open = i else: if c[best_open].length < c[i].length: best_open = i # Falls keine Geschschlossene dabei ist Beste = Offene # If no Geschschlossene is best = Open ??? if best is None: best = best_open best_c = c[best] best_c.cont_nr = c_nr # print "Beste Kontur Nr:%s" %best_c return best_c # All the points in the path from Point Clear to accelerate nights Search ??? def Remove_Used_Points(self, cont=None, points=None): """ Remove_Used_Points() """ for p_nr in cont.order: # This has to be 2 separate loops, otherwise one element is missing for Point in points: if p_nr[0] == Point.point_nr: del points[points.index(Point)] for Point in points: for be_cp in Point.be_cp: if p_nr[0] == be_cp[0]: del Point.be_cp[Point.be_cp.index(be_cp)] break for en_cp in Point.en_cp: if p_nr[0] == en_cp[0]: del Point.en_cp[Point.en_cp.index(en_cp)] break # Return to the contour ??? return points # All the points in the path from Point Clear to accelerate nights Search ??? def Contours_Points2Geo(self, cont=None, points=None): """ Contours_Points2Geo() """ # print cont.order for c_nr in range(len(cont.order)): cont.order[c_nr][0] = points[cont.order[c_nr][0]].geo_nr return cont class dxflinepairClass: def __init__(self, code=None, value=None): self.code = code self.value = value def __str__(self): return 'Code ->' + str(self.code) + '\nvalue ->' + self.value class dxflinepairsClass: def __init__(self, line_pair): self.nrs = 0 self.line_pair = line_pair def __str__(self): return 'Number of Line Pairs: ' + str(self.nrs) # Search for information in the line pairs (both code & value) # Optional start and end values for the search def index_both(self, code=0, value=0, start=0, stop= -1): """ index_both() """ # If stop==-1 then stop at the end of the pairs if stop == -1: stop = len(self.line_pair) # Start the search within the specified parameters for i in range(start, stop): if self.line_pair[i].code == code and self.line_pair[i].value == value: return i #If nothing found return "None" return None #Sucht nach Code Angaben in den Line Pairs code & value # optional mit start und endwert f�r die Suche #Search for information in the Line Pairs (both code & value) #Optional start and end values for the search def index_code(self, code=0, start=0, stop= -1): """ index_code() """ # If stop == -1 then stop at the end of the pairs if stop == -1: stop = len(self.line_pair) # Start the search within the specified parameters for i in range(start, stop): if self.line_pair[i].code == code: return i # If nothing found return "None" return None class LayerClass: def __init__(self, Nr=0, name=''): self.Nr = Nr self.name = name def __str__(self): # how to print the object return 'Nr ->' + str(self.Nr) + '\nName ->' + self.name def __len__(self): return self.__len__ class SectionClass: def __init__(self, Nr=0, name='', begin=0, end=1): self.Nr = Nr self.name = name self.begin = begin self.end = end def __str__(self): # how to print the object return 'Nr ->' + str(self.Nr) + '\nName ->' + self.name + '\nBegin ->' + str(self.begin) + '\nEnd: ->' + str(self.end) def __len__(self): return self.__len__ class EntitiesClass: def __init__(self, Nr=0, Name='', geo=[], cont=[]): self.Nr = Nr self.Name = Name self.basep = Point(x=0.0, y=0.0) self.geo = geo self.cont = cont def __str__(self): # how to print the object return "\nNr: %s" % self.Nr +\ "\nName: %s" % self.Name +\ "\nBasep: %s" % self.basep +\ "\nNumber of Geometries: %i" % len(self.geo) +\ "\nNumber of Contours: %i" % len(self.cont) def __len__(self): return self.__len__ # Gibt einen List mit den Benutzten Layers des Blocks oder Entities zur�ck # Is a List back to results with the use of block layer or Entities ??? def get_used_layers(self): used_layers = [] for i in range(len(self.geo)): if (self.geo[i].Layer_Nr in used_layers) == 0: used_layers.append(self.geo[i].Layer_Nr) return used_layers # Gibt die Anzahl der Inserts in den Entities zur�ck # Returns the number of inserts back into the Entities ??? def get_insert_nr(self): insert_nr = 0 for i in range(len(self.geo)): if "Insert" in self.geo[i].Typ: insert_nr += 1 return insert_nr class BlocksClass: def __init__(self, Entities=[]): self.Entities = Entities def __str__(self): # how to print the object s = 'Blocks:\nNumber of Blocks ->' + str(len(self.Entities)) for entitie in self.Entities: s += str(entitie) return s