From 212ec79ce8c693786b592ab08b60719f0fea65eb Mon Sep 17 00:00:00 2001 From: Paul Wolok Date: Wed, 21 Jan 2026 11:09:08 +0100 Subject: [PATCH] =?UTF-8?q?=C3=84nderung=20paar=20Umvormulierungen=20zusat?= =?UTF-8?q?z=20von=20paar=20Kommentarten?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lib/Elemente/VarioFoerderer.py | 31 ++++++---- lib/plant2dxf.py | 108 ++++++++++++++------------------- 2 files changed, 66 insertions(+), 73 deletions(-) diff --git a/lib/Elemente/VarioFoerderer.py b/lib/Elemente/VarioFoerderer.py index 03158d3..0822531 100644 --- a/lib/Elemente/VarioFoerderer.py +++ b/lib/Elemente/VarioFoerderer.py @@ -305,7 +305,10 @@ class VarioFoerderer(BaseModel): winkel_VP_offset_vorne = (SP_1_nachbar[0] -VP_1_nachbar[0] ),0,( SP_1_nachbar[2]- VP_1_nachbar[2]) return winkel_VP_offset_vorne,winkel_VP_offset_hinten + def horizontale_ausrichtung(x, y, voerder_richtung, rotation, x0_kreisel, y0_kreisel): + """Schaut was für eine Ausrichtung der Horizontale Förder hat""" + # mit_horizontal_verbunden None als String für einen späteren vergleich mit_horizontal_verbunden = "None" if voerder_richtung == "Horizontal": if rotation == 0.0: @@ -330,25 +333,27 @@ class VarioFoerderer(BaseModel): mit_horizontal_verbunden = "oben_drehung_-180_or_-270" return mit_horizontal_verbunden def vario_verbuden_am_kreisel(foerderer, block_vario, start, ende, mit_horizontal_verbunden = None,kreisel_verbunden = None,am_kreisel = None,erster_kreisel_höher = None): + """""Methode für Erstellung der Gefällestrecke für Vario Förderrer die direkt am dem Kreisel hängt""" lower_hoehe_vario = foerderer.h0 upper_hoehe_vario = foerderer.h1 voerder_richtung = foerderer.foerderer_richtung hoehe_vario = foerderer.hight_zwischen x = foerderer.x y = foerderer.y + gefaelle_länge = 500 if (kreisel_verbunden == 2 or (am_kreisel == 1 and erster_kreisel_höher == True)or (am_kreisel == 2 and erster_kreisel_höher == False))and voerder_richtung != "Horizontal": l = (start[0],start[1],upper_hoehe_vario) # Eine 500 mm gefällestrecke an anfang und am ende reintuen if voerder_richtung =="Auf": - m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario +500* math.sin(math.radians(3))) + m = (start[0],start[1] - gefaelle_länge*math.cos(math.radians(3)),upper_hoehe_vario +gefaelle_länge* math.sin(math.radians(3))) start = m elif voerder_richtung == "Ab": - m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario -500* math.sin(math.radians(3))) + m = (start[0],start[1] - gefaelle_länge*math.cos(math.radians(3)),upper_hoehe_vario -gefaelle_länge* math.sin(math.radians(3))) start = m else: - m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario ) + m = (start[0],start[1] - gefaelle_länge*math.cos(math.radians(3)),upper_hoehe_vario ) start = m if kreisel_verbunden == 1: z1 = m[2] @@ -362,14 +367,14 @@ class VarioFoerderer(BaseModel): if (kreisel_verbunden == 2 or (am_kreisel == 1 and erster_kreisel_höher == False)or (am_kreisel == 2 and erster_kreisel_höher == True)) and voerder_richtung != "Horizontal": l = (ende[0],ende[1],lower_hoehe_vario) if voerder_richtung =="Auf": - m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario - 500* math.sin(math.radians(3))) + m = (ende[0],ende[1] + gefaelle_länge*math.cos(math.radians(3)) ,lower_hoehe_vario - gefaelle_länge* math.sin(math.radians(3))) ende = m elif voerder_richtung == "Ab": - m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario + 500* math.sin(math.radians(3))) + m = (ende[0],ende[1] + gefaelle_länge*math.cos(math.radians(3)) ,lower_hoehe_vario + gefaelle_länge* math.sin(math.radians(3))) ende = m else: - m = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario ) + m = (ende[0],ende[1] + gefaelle_länge*math.cos(math.radians(3)) ,lower_hoehe_vario ) ende = m line = Line.new(dxfattribs={"start": l,"end":m }) line.dxf.layer = "6-SP" @@ -382,7 +387,7 @@ class VarioFoerderer(BaseModel): elif voerder_richtung == "Horizontal": if mit_horizontal_verbunden == "oben_drehung_0_or_-90" or mit_horizontal_verbunden == "unten_drehung_-180_or_-270": l = (start[0],start[1],upper_hoehe_vario) - m = (start[0],start[1] - 500*math.cos(math.radians(3)),upper_hoehe_vario) + m = (start[0],start[1] - gefaelle_länge*math.cos(math.radians(3)),upper_hoehe_vario) start = m line = Line.new(dxfattribs={"start": l,"end":m }) line.dxf.layer = "6-SP" @@ -391,7 +396,7 @@ class VarioFoerderer(BaseModel): block_vario.add_entity(copy) else: end = (ende[0],ende[1],lower_hoehe_vario) - en = (ende[0],ende[1] + 500*math.cos(math.radians(3)) ,lower_hoehe_vario ) + en = (ende[0],ende[1] + gefaelle_länge*math.cos(math.radians(3)) ,lower_hoehe_vario ) ende = en line = Line.new(dxfattribs={"start": end,"end":en }) line.dxf.layer = "6-SP" @@ -403,6 +408,7 @@ class VarioFoerderer(BaseModel): else: return start, ende def vario_erstellung(foerderer, doc, lib_doc, config, block, block_name_links, start, ende, voerder_richtung, winkel_VP_offset_vorne, winkel_VP_offset_hinten ): + """Erstellung der Vario Blöcke""" # Entnehmen der Motor und Umlenk station um die Gefähle auzurechnen und ob man diese tatsächlich einfügen muss winkel_motor = float(config.get("Ils 2.0 core winkel","winkel_motor")) winkel_umlenk = float(config.get("Ils 2.0 core winkel","winkel_umlenk")) @@ -488,7 +494,7 @@ class VarioFoerderer(BaseModel): block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x , start[1] - motor_offset_x/2 -y ,start[2] - hoehe_vario +motor_offset_z/2),dxfattribs={"rotation": 90, "layer":layer_motor,"color": color_motor}) start = start[0] , start[1] - motor_offset_x,start[2] + motor_offset_z - # Einfügen der 51 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block + # Einfügen der grad Bogen und deren notwendigen Werten von den attributen des bogens in den block winkel_core = int(config.get("Ils 2.0 core winkel","winkel_boegen")) winkel_plus = winkel + winkel_core block_Vario_Bogen_auf = (f"Vario_Bogen_auf_{winkel_plus}°") @@ -501,14 +507,14 @@ class VarioFoerderer(BaseModel): block_Vario_Bogen_auf = block_methoden.dreh_block(block_Vario_Bogen_auf, doc,lib_doc,math.radians(winkel_core)) block_Vario_Bogen_ab = block_methoden.dreh_block(block_Vario_Bogen_ab, doc,lib_doc,math.radians(-winkel)) - + #Entnehmen der Werte von den Attributen Vario_Bogen_auf_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_attrib["DELTA_SP_0"])) Vario_Bogen_auf_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_SP_1"])) Vario_Bogen_ab_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_0"])) Vario_Bogen_ab_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_1"])) Vario_Bogen_auf_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_VP_1"])) Vario_Bogen_ab_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_VP_0"])) - + # Werte von den Attributen durch den Winkel ändern wegen der Neugung in 3 Dimensionalen raum Vario_Bogen_auf_Delta_SP_0 = [Vario_Bogen_auf_Delta_SP_0 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_0[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_SP_0[1],-Vario_Bogen_auf_Delta_SP_0[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_0[2] * math.cos(math.radians(winkel_core)) ] Vario_Bogen_auf_Delta_SP_1 = [Vario_Bogen_auf_Delta_SP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_SP_1[1],-Vario_Bogen_auf_Delta_SP_1[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_1[2] * math.cos(math.radians(winkel_core)) ] Vario_Bogen_ab_Delta_SP_0 = [Vario_Bogen_ab_Delta_SP_0 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_0[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_SP_0[1],-Vario_Bogen_ab_Delta_SP_0[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_0[2] * math.cos(math.radians(-winkel)) ] @@ -656,6 +662,7 @@ class VarioFoerderer(BaseModel): ende = ende[0] , ende[1] + motor_offset_x,ende[2] +motor_offset_z elif winkel == 3: ende_Motor_VP = ende[0] - vario_abstand, ende[1]- winkel_VP_offset_vorne[0] ,ende[2] - winkel_VP_offset_hinten[2] + if winkel != 3: winkel_core = int(config.get("Ils 2.0 core winkel","winkel_boegen")) winkel_minus = winkel - winkel_core @@ -728,7 +735,7 @@ class VarioFoerderer(BaseModel): copy = line.copy() copy.translate(-x,-y,-hoehe_vario) block.add_entity(copy) - + #Sonderlogik für grad 3, weil es kein bogen braucht elif winkel == 3: # Nur erstellung der zwischen und Vario linie weil der Bogen hier nicht nötig ist line_VP = Line.new(dxfattribs={"start": start_Umlenkstation_VP,"end": ende_Motor_VP}) diff --git a/lib/plant2dxf.py b/lib/plant2dxf.py index 1ef9275..b29ae67 100644 --- a/lib/plant2dxf.py +++ b/lib/plant2dxf.py @@ -17,7 +17,6 @@ from Elemente import Kreisel, VarioFoerderer,Gefaehllestrecke,Angetriebene_Kurve import as_es_methoden import block_methoden import arbeiten_mit_csv - # --------------------------------------------------------- Konstante Parameter ATTR_TAG = "TeileId" # Attributtag im Block RADIUS = 400 # Radius der Kreiselkreise (mm) @@ -102,7 +101,6 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v lower_hoehe_gefaehlle = gefaelle_objekt.h0 hoehe_gefaehlle = gefaelle_objekt.hight_zwischen laenge = gefaelle_objekt.laenge - halbe_laenge = laenge / 2 rotation= gefaelle_objekt.drehung winkel = math.radians(float(rotation)) @@ -179,7 +177,6 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v start = [x , y + dy ,upper_hoehe_gefaehlle] ende = [x , y - dy ,lower_hoehe_gefaehlle] start, ende = Gefaehllestrecke.Gefaellestrecke.ein_motor_oder_eine_umlenk(x, y,start,ende, doc, lib_doc, hoehe_gefaehlle, block_Vario_Umlenkstation_500mm, block_Vario_Motorstation_500mm, blockname_motor_links, blockname_umlenk_links, hat_motor_0, hat_umlenk_0, tefkurve_0, block,umlenk_gerade,motor_gerade) - line = Line.new(dxfattribs={"start":start,"end":ende}) line.translate(-x,-y,-hoehe_gefaehlle) block.add_entity(line) @@ -229,9 +226,8 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v as_es_rotation= 0 else: as_es_rotation= -180 - + # Fügt as oder es Element ein oder fügt nur as oder es element hinzu falls nötig only_es_or_as = as_es_methoden.erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge, blockname,config,hight,None,None,None,block,start,ende,None,as_es_rotation) - if only_es_or_as == False: bref =msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation,"layer": gefaelle_layer}) a =bref.add_attrib( @@ -351,51 +347,6 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation,"layer": gefaelle_layer}) - -def anzahl_seperatoren_oder_scan(msp, x, y, doc, lib_doc, klassen_objekt, hoehe, rotation): - """Importiert alle seperatoren und/oder scanner für das nötige objekt""" - separatoren = klassen_objekt.anzahl_separatoren - scanner = klassen_objekt.anzahl_scanner - # Schauen welche Ausrichtung das Objekt hat, damit man die Separtoren unbd Scanner nicht in das Objekt tut - if rotation == 0 or rotation == -180: - ausrichtung = "V" - else: - ausrichtung = "H" - if ausrichtung == "V": - einsatz_fest = [x + 300, y,hoehe] - modular = 2 - else: - einsatz_fest = [x,y - 150,hoehe] - modular = 3 - block_scanner = "SCAN" - block_separatoren = "S-LP" - block_methoden.import_block(block_scanner,lib_doc,doc) - block_methoden.import_block(block_separatoren,lib_doc,doc) - layer_scan, color_scan = block_methoden.get_insert_color_layer(lib_doc, block_scanner) - layer_separatioren, color_separatioren = block_methoden.get_insert_color_layer(lib_doc, block_separatoren) - einsatz_zwischen =[ einsatz_fest[0],einsatz_fest[1],einsatz_fest[2]] - anzahl =0 - while anzahl < separatoren: - anzahl = anzahl + 1 - msp.add_blockref(block_separatoren,einsatz_zwischen, dxfattribs={"layer": layer_separatioren,"color": color_separatioren}) - if anzahl % modular == 0: - einsatz_fest[1] = einsatz_fest[1] - 150 - einsatz_zwischen = einsatz_fest.copy() - else: - einsatz_zwischen[0] = einsatz_zwischen[0]+ 300 - - if anzahl % modular != 0: - einsatz_fest[1] = einsatz_fest[1] - 150 - einsatz_zwischen = einsatz_fest.copy() - anzahl =0 - while anzahl < scanner: - anzahl = anzahl + 1 - msp.add_blockref(block_scanner,einsatz_zwischen,dxfattribs={"layer": layer_scan,"color": color_scan}) - if anzahl % modular == 0: - einsatz_fest[1] = einsatz_fest[1] - 150 - einsatz_zwischen = einsatz_fest.copy() - else: - einsatz_zwischen[0] = einsatz_zwischen[0]+ 300 def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein): """Erstellt ein Vario Förderer in der neuen Dxf""" @@ -435,8 +386,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Korrektur der rotation mit der Umstellung der Höhe rotation = rotation -180 foerderer.drehung = rotation - - # Hollen der Information der Nachbarn strukturen ob diese Kreisel sind for nachbarn in strecken_nachbarn: if teileid == nachbarn.get("Id"): @@ -450,6 +399,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Für spätere berechnung schauen ob der erste Kreis in der Liste höher ist if upper_hoehe_vario == gefaellestrecke_vario.get("Hoehe0"): ein_kreisel_höher = True + # Falls der Förderer mit einem Eckrad verbunden ist if "Eckrad_x" in gefaellestrecke_vario and "Eckrad_x_1" not in gefaellestrecke_vario: x0_eckrad = gefaellestrecke_vario.get("Eckrad_x") y0_eckrad = gefaellestrecke_vario.get("Eckrad_y") @@ -476,6 +426,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve elif merkmale.get("Motorseite")== "rechts": msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) return + # Falls der Förderer mit zwei Eckrads verbunden ist if "Eckrad_x" in gefaellestrecke_vario and "Eckrad_x_1" in gefaellestrecke_vario: blockname = (f"Vario_Foerderer_{winkel}_{voerder_richtung}_{laenge}_{hoehe_vario}_rechts_2_{motor_vorhanden}_{umlenk_vorhanden}_{gefaelle}_{gefahellewinkel}") @@ -496,7 +447,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) return - # Aufruf falls nur mit einem Kreisel verbunden if "Drehung0" in gefaellestrecke_vario and "Drehung1" not in gefaellestrecke_vario: # Vorbereitund der Daten des Kreisel @@ -511,9 +461,7 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve y0_kreisel = float(gefaellestrecke_vario.get("y0")) richtung0 = float(gefaellestrecke_vario.get("rotation0")) richtung_rad0= math.radians(richtung0) - # Herausfinden ob der Förderere direkt mit dem Kreisel verbunden ist, die Werte für den Zweiten Kreisel wird auf None gesetzt weil diese nicht existieren - # None als string für späteren vergleich mit_horizontal_verbunden = VarioFoerderer.VarioFoerderer.horizontale_ausrichtung(x, y, voerder_richtung, rotation, x0_kreisel, y0_kreisel) am_kreisel,kreseil_verbunden =as_es_methoden.am_kreisel_direct_verbunden(x, y, upper_hoehe_vario, lower_hoehe_vario, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, None, None, None, None ) if am_kreisel == 1: @@ -536,7 +484,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve # Erstellung einer Gefällestrecke von 500 mm in der Vario rein, wo es verbunden ist start, ende = VarioFoerderer.VarioFoerderer.vario_verbuden_am_kreisel(foerderer, block_vario, start, ende, mit_horizontal_verbunden,kreseil_verbunden,am_kreisel,ein_kreisel_höher) - # Erstellung des Vario_förderes selber VarioFoerderer.VarioFoerderer.vario_erstellung(foerderer, doc, lib_doc, config, block_vario,block_name_links, start, ende,voerder_richtung ,winkel_VP_offset_vorne,winkel_VP_offset_hinten) # reintuen des förderes in den Modelspace @@ -685,7 +632,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve elif merkmale.get("Motorseite")== "rechts": msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) return - # Erstellung des Blocks und diesen in die Modelspace tuen. Die Linke version wird bei der vario erstellung selber am ende gemacht block_vario = doc.blocks.new(blockname, base_point=(0,0,0)) # Schauen welche es oder as element man braucht man braucht und diese in den block einfügen @@ -732,8 +678,6 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve if merkmale.get("Motorseite")== "rechts": msp.add_blockref(blockname,(x,y,hoehe_vario),dxfattribs={"rotation": rotation}) - - def handle_ils_2_0_kurve_angetrieben(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein): """Erstellt eine Angetriebene Kurve (Förderer Kurve) in der neuen Dxf""" voerder_kurve = Angetriebene_Kurve.Angetriebene_Kurve.from_merkmale(teileid,x,y,merkmale) @@ -746,7 +690,6 @@ def handle_ils_2_0_kurve_angetrieben(msp, teileid, merkmale, x, y, doc, lib_doc, block_methoden.import_block(blockname,lib_doc,doc) layer, color = block_methoden.get_insert_color_layer(lib_doc, blockname) msp.add_blockref(blockname,(x,y,h_zwischen),dxfattribs={"rotation": rotation,"layer": layer, "color":color}) - def handle_ils_2_0_kurve(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein): """Erstellt eine Kurve (Gefälle Kurve) in der neuen Dxf""" @@ -778,7 +721,6 @@ def handle_bt___entladung(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, s block_methoden.import_block(blockname,lib_doc,doc) msp.add_blockref(blockname,(x,y,hight),dxfattribs={"rotation": rotation}) - def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein): """ Für Omniflo Gerade: zeichnet eine Linie (Mitte = Koordinate, Länge und Winkel aus Merkmale). @@ -812,6 +754,50 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, layer, color = block_methoden.get_insert_color_layer(lib_doc, omniflo_objekt.sivasnummer) msp.add_blockref(blockname, (x, y,omniflo_objekt.hoehe), dxfattribs={"rotation": rotation,"layer": layer, "color": color}) +def anzahl_seperatoren_oder_scan(msp, x, y, doc, lib_doc, klassen_objekt, hoehe, rotation): + """Importiert alle seperatoren und/oder scanner für das nötige objekt""" + separatoren = klassen_objekt.anzahl_separatoren + scanner = klassen_objekt.anzahl_scanner + # Schauen welche Ausrichtung das Objekt hat, damit man die Separtoren unbd Scanner nicht in das Objekt tut + if rotation == 0 or rotation == -180: + ausrichtung = "V" + else: + ausrichtung = "H" + if ausrichtung == "V": + einsatz_fest = [x + 300, y,hoehe] + modular = 2 + else: + einsatz_fest = [x,y - 150,hoehe] + modular = 3 + block_scanner = "SCAN" + block_separatoren = "S-LP" + block_methoden.import_block(block_scanner,lib_doc,doc) + block_methoden.import_block(block_separatoren,lib_doc,doc) + layer_scan, color_scan = block_methoden.get_insert_color_layer(lib_doc, block_scanner) + layer_separatioren, color_separatioren = block_methoden.get_insert_color_layer(lib_doc, block_separatoren) + einsatz_zwischen =[ einsatz_fest[0],einsatz_fest[1],einsatz_fest[2]] + anzahl =0 + while anzahl < separatoren: + anzahl = anzahl + 1 + msp.add_blockref(block_separatoren,einsatz_zwischen, dxfattribs={"layer": layer_separatioren,"color": color_separatioren}) + if anzahl % modular == 0: + einsatz_fest[1] = einsatz_fest[1] - 150 + einsatz_zwischen = einsatz_fest.copy() + else: + einsatz_zwischen[0] = einsatz_zwischen[0]+ 300 + + if anzahl % modular != 0: + einsatz_fest[1] = einsatz_fest[1] - 150 + einsatz_zwischen = einsatz_fest.copy() + anzahl =0 + while anzahl < scanner: + anzahl = anzahl + 1 + msp.add_blockref(block_scanner,einsatz_zwischen,dxfattribs={"layer": layer_scan,"color": color_scan}) + if anzahl % modular == 0: + einsatz_fest[1] = einsatz_fest[1] - 150 + einsatz_zwischen = einsatz_fest.copy() + else: + einsatz_zwischen[0] = einsatz_zwischen[0]+ 300 def get_libfile_cfg(teileart, cfg_path): """Liest den Bibliotheksdateinamen für eine TeileArt aus der allgemein.cfg.""" parser = configparser.ConfigParser()