habe die Bogen namen ins cofig eingefügt und habe denn namen der layer für die automatisiereung im config geändert um zu verdeutlichen was es tatsächlich ist
This commit is contained in:
+1
-1
@@ -32,4 +32,4 @@ blocks_per_row = 20
|
||||
# Vertikaler Abstand zwischen Zeilen im Raster (in DXF-Einheiten)
|
||||
block_spacing_y = 500
|
||||
# Nicht in die MittelPunkt Berechnung erlaubt
|
||||
not_allowed_in_center = ("A-GRUPPE","B-GRUPPE")
|
||||
automation_layer = ("A-GRUPPE","B-GRUPPE")
|
||||
+28
-4
@@ -5,6 +5,13 @@ offset_symb2 = 0,0
|
||||
rot_symb1 = 0.0
|
||||
rot_symb2 = 0.0
|
||||
|
||||
[ILS 2.0 Kreisel mit Pin]
|
||||
items = SP8, AN8
|
||||
offset_symb1 = 0,0
|
||||
offset_symb2 = 0,0
|
||||
rot_symb1 = 0.0
|
||||
rot_symb2 = 0.0
|
||||
|
||||
[ILS 2.0 Gefällestrecke]
|
||||
items = EE DS, AE DS
|
||||
offset_symb1 = 0,-330
|
||||
@@ -18,7 +25,24 @@ esoffset = 479.95
|
||||
[ILS 2.0 Variofoerderer]
|
||||
Umlenkstation = 499.3148,0,26.1680
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
[ILS 2.0 Variofoerderer_Bogen_block_namen]
|
||||
bogen_51_auf = Vario_Bogen_auf_51°
|
||||
bogen_51_ab = Vario_Bogen_ab_51°
|
||||
bogen_45_auf = Vario_Bogen_auf_45°
|
||||
bogen_45_ab = Vario_Bogen_ab_45°
|
||||
bogen_39_auf = Vario_Bogen_auf_39°
|
||||
bogen_39_ab = Vario_Bogen_ab_39°
|
||||
bogen_33_auf = Vario_Bogen_auf_33°
|
||||
bogen_33_ab = Vario_Bogen_ab_33°
|
||||
bogen_27_auf = Vario_Bogen_auf_27°
|
||||
bogen_27_ab = Vario_Bogen_ab_27°
|
||||
bogen_21_auf = Vario_Bogen_auf_21°
|
||||
bogen_21_ab = Vario_Bogen_ab_21°
|
||||
bogen_15_auf = Vario_Bogen_auf_15°
|
||||
bogen_15_ab = Vario_Bogen_ab_15°
|
||||
bogen_12_auf = Vario_Bogen_auf_12°
|
||||
bogen_12_ab = Vario_Bogen_ab_12°
|
||||
bogen_6_auf = Vario_Bogen_auf_6°
|
||||
bogen_6_ab = Vario_Bogen_ab_6°
|
||||
bogen_3_auf = Vario_Bogen_auf_3°
|
||||
bogen_3_ab = Vario_Bogen_ab_3°
|
||||
+5
-6
@@ -44,8 +44,7 @@ def create_block_library(input_dir, output_file, config, logger=None):
|
||||
max_blockspacing_y = 0
|
||||
|
||||
for filename in os.listdir(input_dir):
|
||||
if filename =='821104043.dxf':
|
||||
test = 2
|
||||
|
||||
if not filename.lower().endswith(".dxf"):
|
||||
continue
|
||||
|
||||
@@ -57,7 +56,7 @@ def create_block_library(input_dir, output_file, config, logger=None):
|
||||
src_doc = ezdxf.readfile(filepath)
|
||||
src_msp = src_doc.modelspace()
|
||||
entities = list(src_msp)
|
||||
allowed_types = {"LINE", "LWPOLYLINE", "POLYLINE", "SPLINE", "CIRCLE", "ARC", "INSERT"}
|
||||
allowed_types = {"LINE", "LWPOLYLINE", "POLYLINE", "SPLINE", "CIRCLE", "ARC", "INSERT","ATTDEF"}
|
||||
filtered_entities = []
|
||||
|
||||
for e in entities:
|
||||
@@ -477,17 +476,17 @@ def get_entity_bounding_box(e, doc,src_doc,filename,config, transform_matrix=Non
|
||||
if sampled:
|
||||
bbox.extend(sampled)
|
||||
|
||||
elif e.dxftype() == 'TEXT':
|
||||
elif e.dxftype() == 'ATTDEF':
|
||||
# Vereinfachung: Nur Insert-Point berücksichtigen
|
||||
insert_point = Vec3(e.dxf.insert)
|
||||
if transform_matrix:
|
||||
insert_point = transform_matrix.transform(insert_point)
|
||||
bbox.extend([insert_point])
|
||||
|
||||
|
||||
elif e.dxftype() == 'INSERT':
|
||||
# INSERT: Block-Inhalt mit Transformation berücksichtigen
|
||||
insert_bbox = calculate_insert_bounding_box(e, doc,src_doc,filename,config, transform_matrix)
|
||||
if insert_bbox and insert_bbox.has_data and e.dxf.layer not in config.get("dxf2lib","not_allowed_in_center"):
|
||||
if insert_bbox and insert_bbox.has_data and e.dxf.layer not in config.get("dxf2lib","automation_layer"):
|
||||
bbox.extend(insert_bbox)
|
||||
|
||||
except Exception as e:
|
||||
|
||||
+307
-212
@@ -13,6 +13,7 @@ import configparser
|
||||
import ezdxf
|
||||
from ezdxf import units
|
||||
from ezdxf.entities import Line
|
||||
from ezdxf.addons import importer
|
||||
from ezdxf.math import Matrix44, X_AXIS,Y_AXIS,Z_AXIS
|
||||
from pathlib import Path
|
||||
import math
|
||||
@@ -20,7 +21,7 @@ import re
|
||||
from utils import check_environment_var, setup_logger
|
||||
|
||||
|
||||
|
||||
global_zaehler = 0
|
||||
# --------------------------------------------------------- CFG-Leser für shapes.cfg
|
||||
def get_shape_cfg(teileart, cfg_path, logger=None):
|
||||
parser = configparser.ConfigParser()
|
||||
@@ -90,8 +91,14 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None:
|
||||
- Stellt sicher, dass benutzte Layer im Ziel existieren (mit Eigenschaften)
|
||||
- Übernimmt Basispunkt und Block-Layer, falls vorhanden
|
||||
"""
|
||||
|
||||
src = from_doc.blocks[block_name]
|
||||
att_def = {}
|
||||
if block_name == "Pinbereich":
|
||||
imp = importer.Importer(from_doc, to_doc)
|
||||
|
||||
# Alle Linientypen importieren
|
||||
imp.import_table("linetypes")
|
||||
if ((block_name in to_doc.blocks)):
|
||||
# speichern der attdef elemente in eine Liste falks diese verhanden sind und gibt diese zurück
|
||||
for ent in src:
|
||||
@@ -103,9 +110,10 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None:
|
||||
|
||||
import_block(ent.dxf.name,from_doc, to_doc,None)
|
||||
|
||||
if att_def != []:
|
||||
if att_def != {}:
|
||||
return att_def
|
||||
return
|
||||
|
||||
if block_name not in from_doc.blocks:
|
||||
raise ValueError(f"Block '{block_name}' nicht in Bibliothek gefunden.")
|
||||
# Sicherstellen, dass alle verwendeten Layer existieren
|
||||
@@ -149,8 +157,9 @@ def import_block(block_name: str, from_doc, to_doc, winkel = None) -> None:
|
||||
|
||||
import_block(ent.dxf.name,from_doc, to_doc,None)
|
||||
tgt.add_entity(copy)
|
||||
if att_def != []:
|
||||
if att_def != {}:
|
||||
return att_def
|
||||
|
||||
|
||||
def dreh_block(block_name: str, to_doc, winkel) :
|
||||
"""Nimmt ein schon importierten Block und erstellt einen neuen der an der y_axis gedreht wird
|
||||
@@ -205,7 +214,34 @@ def transform_coords(x: float, y: float, height: float) -> tuple[float, float]:
|
||||
"""Transformiert Bildschirmkoordinaten (0,0 oben links) ins DXF-KoSy (0,0 unten links)."""
|
||||
return x, y -height
|
||||
|
||||
def handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,strecken_nachbarn,config):
|
||||
def handle_ils_2_0_kreisel_mit_pin(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,strecken_nachbarn,config,config_allgemein):
|
||||
merkmale["pin"] = "True"
|
||||
handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,strecken_nachbarn,config,config_allgemein)
|
||||
|
||||
|
||||
def handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,strecken_nachbarn,config,config_allgemein):
|
||||
|
||||
scanner = float(merkmale.get("Anzahl der Scanner"))
|
||||
separatoren = float(merkmale.get("Anzahl der Separatoren"))
|
||||
block_scanner = "SCAN"
|
||||
block_separatoren = "S-LP"
|
||||
scanner_x = x
|
||||
scanner_y = y
|
||||
separatoren_x = x
|
||||
separatoren_y = y + 160
|
||||
import_block(block_scanner,lib_doc,doc)
|
||||
import_block(block_separatoren,lib_doc,doc)
|
||||
i = 0
|
||||
while i < scanner:
|
||||
msp.add_blockref(block_scanner, (scanner_x,scanner_y,float(merkmale.get("Höhe in m"))* 1000))
|
||||
scanner_x = scanner_x + 300
|
||||
i = i+1
|
||||
|
||||
i = 0
|
||||
while i < separatoren:
|
||||
msp.add_blockref(block_separatoren, (separatoren_x,separatoren_y,float(merkmale.get("Höhe in m"))* 1000))
|
||||
separatoren_x = separatoren_x + 300
|
||||
i = i +1
|
||||
abstand_m = merkmale.get(
|
||||
"Abstand (Kreiselachse A - Kreiselachse) in Meter", "20"
|
||||
).replace(",", ".")
|
||||
@@ -242,11 +278,15 @@ def handle_ils_2_0_kreisel(msp, teileid, merkmale, x, y, doc, lib_doc, verbose,
|
||||
print(f"[INFO] Block '{blockname}' (Kreisel) → {teileid} "
|
||||
f"({pos[0]:.1f}, {pos[1]:.1f}), rot={rotation}")
|
||||
# Linien zeichnen
|
||||
draw_kreisel_lines(msp, pos1, pos2)
|
||||
|
||||
import_block("Pinbereich",lib_doc,doc)
|
||||
draw_kreisel_lines(msp, pos1, pos2,merkmale)
|
||||
draw_kreisel_drehrichtung_markierung(msp, pos1, pos2, merkmale, lib_doc, doc, verbose)
|
||||
|
||||
def draw_kreisel_lines(msp, pos1, pos2):
|
||||
def draw_kreisel_lines(msp, pos1, pos2,merkmale):
|
||||
"""Zeichnet tangentiale Linien zwischen zwei Kreiselblöcken, unabhängig vom Winkel."""
|
||||
|
||||
|
||||
x1, y1, z1 = pos1
|
||||
x2, y2, z1 = pos2
|
||||
# Verbindungsvektor
|
||||
@@ -257,6 +297,7 @@ def draw_kreisel_lines(msp, pos1, pos2):
|
||||
if length == 0:
|
||||
return # keine Linie bei identischen Punkten
|
||||
# Normalenvektor (senkrecht, normiert, Länge = RADIUS)
|
||||
|
||||
nx = -dy / length * RADIUS
|
||||
ny = dx / length * RADIUS
|
||||
# Tangentialpunkte
|
||||
@@ -264,9 +305,20 @@ def draw_kreisel_lines(msp, pos1, pos2):
|
||||
p1b = (x1 - nx, y1 - ny,z1)
|
||||
p2a = (x2 + nx, y2 + ny,z1)
|
||||
p2b = (x2 - nx, y2 - ny,z1)
|
||||
if merkmale.get("Kreiselart") == "Pin":
|
||||
|
||||
p1a2 = p1a[0] + RADIUS + 50, p1a[1] - 50, z1
|
||||
p1b2 = p1b[0] + RADIUS + 50, p1b[1] + 50, z1
|
||||
p2a2 = p2a[0] - RADIUS - 50, p2a[1] - 50, z1
|
||||
p2b2 = p2b[0] - RADIUS - 50, p2b[1] + 50, z1
|
||||
Line1 = Line.new(dxfattribs={"start": p1a2,"end": p2a2,"layer": "Pinbereich"})
|
||||
Line2 = Line.new(dxfattribs={"start": p1b2,"end": p2b2,"layer": "Pinbereich"})
|
||||
msp.add_entity(Line1)
|
||||
msp.add_entity(Line2)
|
||||
# Linien zeichnen
|
||||
msp.add_line(p1a, p2a)
|
||||
msp.add_line(p1b, p2b)
|
||||
|
||||
|
||||
def draw_kreisel_drehrichtung_markierung(msp, pos1, pos2, merkmale, lib_doc, doc, verbose):
|
||||
drehrichtung = merkmale.get("Drehrichtung", "").upper()
|
||||
@@ -296,11 +348,11 @@ def draw_kreisel_drehrichtung_markierung(msp, pos1, pos2, merkmale, lib_doc, doc
|
||||
rotation = math.degrees(math.atan2(p2_oben[1] - p1_oben[1], p2_oben[0] - p1_oben[0]))
|
||||
if drehrichtung == "GUZS":
|
||||
rotation += 180
|
||||
import_block("S-LP", lib_doc, doc)
|
||||
blockref_layer = get_layer(doc, lib_doc, "S-LP")
|
||||
bref = msp.add_blockref("S-LP", (px, py,z1), dxfattribs={"rotation": rotation,"layer": blockref_layer})
|
||||
import_block("Richtungspfeil", lib_doc, doc)
|
||||
blockref_layer = get_layer(doc, lib_doc, "Richtungspfeil")
|
||||
bref = msp.add_blockref("Richtungspfeil", (px, py,z1), dxfattribs={"rotation": rotation,"layer": blockref_layer})
|
||||
if verbose:
|
||||
print(f"[INFO] Drehrichtung '{drehrichtung}': S-LP oben bei ({px:.1f}, {py:.1f}), rot={rotation:.1f}")
|
||||
print(f"[INFO] Drehrichtung '{drehrichtung}': Richtungspfeil oben bei ({px:.1f}, {py:.1f}), rot={rotation:.1f}")
|
||||
# S-LP auf unterer Linie (Drehrichtung invertiert)
|
||||
for i in range(1, 4):
|
||||
t = i / 4
|
||||
@@ -309,11 +361,11 @@ def draw_kreisel_drehrichtung_markierung(msp, pos1, pos2, merkmale, lib_doc, doc
|
||||
rotation = math.degrees(math.atan2(p2_unten[1] - p1_unten[1], p2_unten[0] - p1_unten[0]))
|
||||
if drehrichtung == "UZS":
|
||||
rotation += 180
|
||||
import_block("S-LP", lib_doc, doc)
|
||||
blockref_layer = get_layer(doc, lib_doc, "S-LP")
|
||||
bref = msp.add_blockref("S-LP", (px, py, z1), dxfattribs={"rotation": rotation , "layer": blockref_layer})
|
||||
import_block("Richtungspfeil", lib_doc, doc)
|
||||
blockref_layer = get_layer(doc, lib_doc, "Richtungspfeil")
|
||||
bref = msp.add_blockref("Richtungspfeil", (px, py, z1), dxfattribs={"rotation": rotation , "layer": blockref_layer})
|
||||
if verbose:
|
||||
print(f"[INFO] Drehrichtung '{drehrichtung}': S-LP unten bei ({px:.1f}, {py:.1f}), rot={rotation:.1f}")
|
||||
print(f"[INFO] Drehrichtung '{drehrichtung}':Richtungspfeil unten bei ({px:.1f}, {py:.1f}), rot={rotation:.1f}")
|
||||
|
||||
def handle_standard(msp, blocknames, teileid, x, y, lib_doc, doc, verbose):
|
||||
for blockname in blocknames:
|
||||
@@ -326,15 +378,16 @@ def handle_standard(msp, blocknames, teileid, x, y, lib_doc, doc, verbose):
|
||||
f"({x:.1f}, {y:.1f})")
|
||||
|
||||
|
||||
def handle_ils_2_0_eckrad(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config):
|
||||
def handle_ils_2_0_eckrad(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein):
|
||||
import_block("AN8",lib_doc,doc)
|
||||
hight = float(merkmale.get("Höhe in m"))* 1000
|
||||
msp.add_blockref("AN8",(x,y,hight))
|
||||
|
||||
def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config):
|
||||
def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein):
|
||||
#Vorbereitung der attributen
|
||||
|
||||
|
||||
if teileid == "shape_19c7aab6-f39d-ea60-24e2-e2a7ea7af5ba":
|
||||
test = 3
|
||||
if "6-SP" not in doc.layers:
|
||||
doc.layers.add(name="6-SP", color=7)
|
||||
verbunden_am_einen = False
|
||||
@@ -379,7 +432,8 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
|
||||
hoehe2 = upper_hoehe_gefaehlle
|
||||
upper_hoehe_gefaehlle = lower_hoehe_gefaehlle
|
||||
lower_hoehe_gefaehlle = hoehe2
|
||||
winkel = winkel -180
|
||||
rotation = rotation -180
|
||||
|
||||
|
||||
|
||||
am_kreisel, kreisel_verbunden =am_kreisel_direct_verbunden(x, y, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, x0_kreisel, y0_kreisel, richtung_rad0, abstand0, dx, dy, None, None, None, None)
|
||||
@@ -398,7 +452,16 @@ def handle_ils_2_0_gefaellestrecke(msp, teileid, merkmale, x, y, doc, lib_doc, v
|
||||
hight = "lower"
|
||||
|
||||
blockname = f"Ils_2.0_Gefaellestrecke_{laenge}_{drehung0}_{hoehe_gefaehlle}_{verbunden_am_einen}_{hight}"
|
||||
|
||||
if blockname in doc.blocks:
|
||||
blockref_layer = get_layer(doc, lib_doc, blockname)
|
||||
bref =msp.add_blockref(blockname,(x,y,hoehe_gefaehlle),dxfattribs={"rotation": rotation, "layer": blockref_layer})
|
||||
a =bref.add_attrib(
|
||||
tag= "NAME",
|
||||
text= merkmale.get("bezeichner"),
|
||||
insert = (x,y)
|
||||
)
|
||||
a.is_invisible = True
|
||||
return
|
||||
only_es_or_as = erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoffset, esoffset, upper_hoehe_gefaehlle, lower_hoehe_gefaehlle, hoehe_gefaehlle, drehung0, laenge, blockname,hight)
|
||||
|
||||
if only_es_or_as == False:
|
||||
@@ -623,14 +686,17 @@ def add_attributes_to_block(block, attributes):
|
||||
)
|
||||
a.is_invisible = True
|
||||
|
||||
def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config):
|
||||
def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config,config_allgemein):
|
||||
# für spätere Namens benenung der Vario forderer
|
||||
motor_vorhanden = merkmale.get("Motor")
|
||||
umlenk_vorhanden = merkmale.get("Umlenk")
|
||||
|
||||
gefahellewinkel =float(merkmale.get("Gefahellewinkel"))
|
||||
|
||||
gefaelle = float(merkmale.get("Gefällestrecke"))
|
||||
motor_vorhanden = bool(merkmale.get("hatMotor"))
|
||||
umlenk_vorhanden = bool(merkmale.get("hatUmlenkung"))
|
||||
if merkmale.get("Laenge_Gefaellestrecke") != None:
|
||||
gefahellewinkel =float(merkmale.get("Laenge_Gefaellestrecke"))
|
||||
|
||||
gefaelle = float(merkmale.get("Winkel_Gefaellestrecke"))
|
||||
else:
|
||||
gefahellewinkel = 0.0
|
||||
gefaelle = 0.0
|
||||
# Offsets für die Vario Linie für ab 3 bogen, da es in diesem Fall keine bögen hat die sich mit den nachbarn Bögen für andere Vario Förderer verbinden kann
|
||||
winkel_VP_offset_vorne = None
|
||||
winkel_VP_offset_hinten = None
|
||||
@@ -1144,17 +1210,20 @@ def handle_ils_2_0_variofoerderer(msp, teileid, merkmale, x, y, doc, lib_doc, ve
|
||||
|
||||
def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_vario, laenge, block,block_name_links, start, ende,voerder_richtung,winkel_VP_offset_vorne,winkel_VP_offset_hinten ):
|
||||
# Entnehmen der Motor und Umlenk station um die Gefähle auzurechnen und ob man diese tatsächlich einfügen muss
|
||||
motor_vorhanden = merkmale.get("Motor")
|
||||
umlenk_vorhanden = merkmale.get("Umlenk")
|
||||
|
||||
gefahellewinkel =float(merkmale.get("Gefahellewinkel"))
|
||||
gefaelle = float(merkmale.get("Gefällestrecke"))
|
||||
motor_vorhanden = bool(merkmale.get("hatMotor"))
|
||||
umlenk_vorhanden = bool(merkmale.get("hatUmlenkung"))
|
||||
if merkmale.get("Winkel_Gefaellestrecke") != None:
|
||||
gefahellewinkel =float(merkmale.get("Winkel_Gefaellestrecke"))
|
||||
gefaelle = float(merkmale.get("Laenge_Gefaellestrecke"))
|
||||
else:
|
||||
gefahellewinkel = 0.0
|
||||
gefaelle = 0.0
|
||||
# Aktueller offset des motors und Umlenkungstation, wird wahrscheinlich später einfach berechnet (sobald man entschieden hat ob wir nur 3 grad neigung erlauben oder nicht)
|
||||
umlenk_motor_offset = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Umlenkstation")).split(","))
|
||||
# Berechnung des Gefälles
|
||||
if motor_vorhanden == "True":
|
||||
if motor_vorhanden == True:
|
||||
gefaelle = gefaelle - umlenk_motor_offset[0]
|
||||
if umlenk_vorhanden == "True":
|
||||
if umlenk_vorhanden == True:
|
||||
gefaelle = gefaelle - umlenk_motor_offset[0]
|
||||
|
||||
|
||||
@@ -1165,7 +1234,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
if gefaelle > 0:
|
||||
# Setzng die hälfte des Gefälles auf beide seiten falls dieser nicht mit einem anderen Förder verbunden ist was durch die abwesenheit eines motors/umlenkung gezeigt wird
|
||||
halbesgefaelle = gefaelle/2
|
||||
if motor_vorhanden == "True" and umlenk_vorhanden == "True":
|
||||
if motor_vorhanden == True and umlenk_vorhanden == True:
|
||||
halbesgefaelle = gefaelle/2
|
||||
gefaelle_ende = ende[0], ende[1] +halbesgefaelle, ende[2] -math.sin(math.radians(gefahellewinkel))* halbesgefaelle
|
||||
line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende})
|
||||
@@ -1183,7 +1252,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
block.add_entity(copy_start)
|
||||
start = gefaelle_start
|
||||
|
||||
elif motor_vorhanden== "True":
|
||||
elif motor_vorhanden== True:
|
||||
gefaelle_start = start[0], start[1] -gefaelle, start[2] +math.sin(math.radians(gefahellewinkel)) * gefaelle
|
||||
line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start})
|
||||
line_start_gefaelle.dxf.layer = "6-SP"
|
||||
@@ -1192,7 +1261,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
block.add_entity(copy_start)
|
||||
start = gefaelle_start
|
||||
|
||||
elif umlenk_vorhanden== "True":
|
||||
elif umlenk_vorhanden== True:
|
||||
gefaelle_ende = ende[0], ende[1] +gefaelle, ende[2] -math.sin(math.radians(gefahellewinkel))* gefaelle
|
||||
line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende})
|
||||
line_ende_gefaelle.dxf.layer = "6-SP"
|
||||
@@ -1208,17 +1277,17 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
import_block(block_Vario_Umlenkstation_500mm , lib_doc, doc)
|
||||
block_Vario_Motorstation_500mm = dreh_block(block_Vario_Motorstation_500mm,doc,math.radians(3))
|
||||
block_Vario_Umlenkstation_500mm = dreh_block( block_Vario_Umlenkstation_500mm, doc,math.radians(3))
|
||||
if umlenk_vorhanden == "True":
|
||||
if umlenk_vorhanden == True:
|
||||
block.add_blockref(block_Vario_Umlenkstation_500mm,(ende[0] -x,ende[1] -y + umlenk_motor_offset[0]/2,ende[2] - hoehe_vario -umlenk_motor_offset[2]/2 ),dxfattribs={"rotation": 90})
|
||||
ende = (ende[0] ,ende[1] + umlenk_motor_offset[0],ende[2] -umlenk_motor_offset[2])
|
||||
if motor_vorhanden == "True":
|
||||
if motor_vorhanden == True:
|
||||
block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x , start[1] - umlenk_motor_offset[0]/2 -y ,start[2] - hoehe_vario +umlenk_motor_offset[2]/2),dxfattribs={"rotation": 90})
|
||||
start = start[0] , start[1] - umlenk_motor_offset[0],start[2] +umlenk_motor_offset[2]
|
||||
|
||||
if winkel == 48:
|
||||
# Einfügen der 51 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
block_Vario_Bogen_auf_51 = "Vario_Bogen_auf_51°"
|
||||
block_Vario_Bogen_ab_51 = "Vario_Bogen_ab_51°"
|
||||
block_Vario_Bogen_auf_51 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_51_auf"))
|
||||
block_Vario_Bogen_ab_51 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_51_ab"))
|
||||
|
||||
auf_51_attrib =import_block(block_Vario_Bogen_auf_51, lib_doc, doc)
|
||||
ab_51_attrib =import_block(block_Vario_Bogen_ab_51, lib_doc, doc)
|
||||
@@ -1302,8 +1371,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
|
||||
elif winkel == 36:
|
||||
# Einfügen der 39 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
block_Vario_Bogen_auf_39 = "Vario_Bogen_auf_39°"
|
||||
block_Vario_Bogen_ab_39 = "Vario_Bogen_ab_39°"
|
||||
block_Vario_Bogen_auf_39 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_39_auf"))
|
||||
block_Vario_Bogen_ab_39 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_39_ab"))
|
||||
auf_39_attrib =import_block(block_Vario_Bogen_auf_39, lib_doc, doc)
|
||||
ab_39_attrib =import_block(block_Vario_Bogen_ab_39, lib_doc, doc)
|
||||
block_Vario_Bogen_auf_39= dreh_block(block_Vario_Bogen_auf_39, doc,math.radians(3))
|
||||
@@ -1390,97 +1459,97 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
|
||||
elif winkel == 24:
|
||||
# Einfügen der 27 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
block_Vario_Bogen_auf_27 = "Vario_Bogen_auf_27°"
|
||||
block_Vario_Bogen_ab_27 = "Vario_Bogen_ab_27°"
|
||||
auf_27_attrib =import_block(block_Vario_Bogen_auf_27, lib_doc, doc)
|
||||
ab_27_attrib = import_block(block_Vario_Bogen_ab_27, lib_doc, doc)
|
||||
block_Vario_Bogen_auf_27= dreh_block(block_Vario_Bogen_auf_27, doc,math.radians(3))
|
||||
block_Vario_Bogen_ab_27 = dreh_block(block_Vario_Bogen_ab_27, doc,math.radians(-24))
|
||||
Vario_Bogen_auf_27_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_27_attrib["DELTA_SP_0"]))
|
||||
Vario_Bogen_auf_27_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_27_attrib["DELTA_SP_1"]))
|
||||
Vario_Bogen_ab_27_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_27_attrib["DELTA_SP_0"]))
|
||||
Vario_Bogen_ab_27_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_27_attrib["DELTA_SP_1"]))
|
||||
Vario_Bogen_auf_27_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_27_attrib["DELTA_VP_1"]))
|
||||
Vario_Bogen_ab_27_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_27_attrib["DELTA_VP_0"]))
|
||||
block_Vario_Bogen_auf_27 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_27_auf"))
|
||||
block_Vario_Bogen_ab_27 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_27_ab"))
|
||||
auf_27_attrib =import_block(block_Vario_Bogen_auf_27, lib_doc, doc)
|
||||
ab_27_attrib = import_block(block_Vario_Bogen_ab_27, lib_doc, doc)
|
||||
block_Vario_Bogen_auf_27= dreh_block(block_Vario_Bogen_auf_27, doc,math.radians(3))
|
||||
block_Vario_Bogen_ab_27 = dreh_block(block_Vario_Bogen_ab_27, doc,math.radians(-24))
|
||||
Vario_Bogen_auf_27_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_27_attrib["DELTA_SP_0"]))
|
||||
Vario_Bogen_auf_27_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_27_attrib["DELTA_SP_1"]))
|
||||
Vario_Bogen_ab_27_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_27_attrib["DELTA_SP_0"]))
|
||||
Vario_Bogen_ab_27_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_27_attrib["DELTA_SP_1"]))
|
||||
Vario_Bogen_auf_27_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_27_attrib["DELTA_VP_1"]))
|
||||
Vario_Bogen_ab_27_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_27_attrib["DELTA_VP_0"]))
|
||||
|
||||
|
||||
|
||||
Vario_Bogen_auf_27_Delta_SP_0 = [Vario_Bogen_auf_27_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_27_Delta_SP_0[1],-Vario_Bogen_auf_27_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_0[2] * math.cos(math.radians(3)) ]
|
||||
Vario_Bogen_auf_27_Delta_SP_1 = [Vario_Bogen_auf_27_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_27_Delta_SP_1[1],-Vario_Bogen_auf_27_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_1[2] * math.cos(math.radians(3)) ]
|
||||
Vario_Bogen_ab_27_Delta_SP_0 = [Vario_Bogen_ab_27_Delta_SP_0 [0] * math.cos(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_0[2]* math.sin(math.radians(-24)) ,Vario_Bogen_ab_27_Delta_SP_0[1],-Vario_Bogen_ab_27_Delta_SP_0[0] * math.sin(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_0[2] * math.cos(math.radians(-24)) ]
|
||||
Vario_Bogen_ab_27_Delta_SP_1 =[ Vario_Bogen_ab_27_Delta_SP_1 [0] * math.cos(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_1[2]* math.sin(math.radians(-24)) ,Vario_Bogen_ab_27_Delta_SP_1[1],-Vario_Bogen_ab_27_Delta_SP_1[0] * math.sin(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_1[2] * math.cos(math.radians(-24)) ]
|
||||
Vario_Bogen_auf_27_Delta_VP_1 = [Vario_Bogen_auf_27_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_27_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_27_Delta_VP_1[1],-Vario_Bogen_auf_27_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_27_Delta_VP_1[2] * math.cos(math.radians(3)) ]
|
||||
Vario_Bogen_ab_27_Delta_VP_0 = [Vario_Bogen_ab_27_Delta_VP_0 [0] * math.cos(math.radians(-24))+ Vario_Bogen_ab_27_Delta_VP_0[2]* math.sin(math.radians(-24)) ,Vario_Bogen_ab_27_Delta_VP_0[1],-Vario_Bogen_ab_27_Delta_VP_0[0] * math.sin(math.radians(-24))+ Vario_Bogen_ab_27_Delta_VP_0[2] * math.cos(math.radians(-24)) ]
|
||||
|
||||
# negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss)
|
||||
|
||||
for i, wert in enumerate(Vario_Bogen_auf_27_Delta_SP_0):
|
||||
if i< 2 and wert < 0:
|
||||
|
||||
Vario_Bogen_auf_27_Delta_SP_0[i] = abs(wert)
|
||||
|
||||
for i, wert in enumerate(Vario_Bogen_auf_27_Delta_SP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_auf_27_Delta_SP_1[i] = abs(wert)
|
||||
|
||||
for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_0):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_27_Delta_SP_0[i] = abs(wert)
|
||||
|
||||
for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_27_Delta_SP_1[i] = abs(wert)
|
||||
|
||||
for i, wert in enumerate(Vario_Bogen_auf_27_Delta_VP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_auf_27_Delta_VP_1[i] = abs(wert)
|
||||
|
||||
for i, wert in enumerate(Vario_Bogen_ab_27_Delta_VP_0):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_27_Delta_VP_0[i] = abs(wert)
|
||||
|
||||
|
||||
|
||||
#einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
|
||||
block.add_blockref(block_Vario_Bogen_auf_27,(ende[0] -x ,ende[1] +Vario_Bogen_auf_27_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_27_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90})
|
||||
|
||||
ende_VP = (ende[0] +Vario_Bogen_auf_27_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_27_Delta_VP_1[0]+Vario_Bogen_auf_27_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_27_Delta_VP_1[2]- Vario_Bogen_auf_27_Delta_SP_0[2])
|
||||
ende = (ende[0] ,ende[1] +Vario_Bogen_auf_27_Delta_SP_1[0] + Vario_Bogen_auf_27_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_27_Delta_SP_1[2] - Vario_Bogen_auf_27_Delta_SP_0[2])
|
||||
|
||||
#einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
|
||||
block.add_blockref(block_Vario_Bogen_ab_27 ,(start[0]-x,start[1] - Vario_Bogen_ab_27_Delta_SP_1[0] -y ,start[2] - hoehe_vario - Vario_Bogen_ab_27_Delta_SP_1[2]),dxfattribs={"rotation": 90})
|
||||
start_VP = start[0] +Vario_Bogen_ab_27_Delta_VP_0[1],start[1]-Vario_Bogen_ab_27_Delta_VP_0[0] - Vario_Bogen_ab_27_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_27_Delta_VP_0[2] - Vario_Bogen_ab_27_Delta_SP_1[2]
|
||||
start = start[0] ,start[1] - Vario_Bogen_ab_27_Delta_SP_0[0] - Vario_Bogen_ab_27_Delta_SP_1[0],start[2] +Vario_Bogen_ab_27_Delta_SP_0[2] - Vario_Bogen_ab_27_Delta_SP_1[2]
|
||||
|
||||
# Erstellung der VARIO Line
|
||||
line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP})
|
||||
line_VP.dxf.layer = "VARIO"
|
||||
copy_VP = line_VP.copy()
|
||||
|
||||
copy_VP.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy_VP)
|
||||
Vario_Bogen_auf_27_Delta_SP_0 = [Vario_Bogen_auf_27_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_27_Delta_SP_0[1],-Vario_Bogen_auf_27_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_0[2] * math.cos(math.radians(3)) ]
|
||||
Vario_Bogen_auf_27_Delta_SP_1 = [Vario_Bogen_auf_27_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_27_Delta_SP_1[1],-Vario_Bogen_auf_27_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_27_Delta_SP_1[2] * math.cos(math.radians(3)) ]
|
||||
Vario_Bogen_ab_27_Delta_SP_0 = [Vario_Bogen_ab_27_Delta_SP_0 [0] * math.cos(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_0[2]* math.sin(math.radians(-24)) ,Vario_Bogen_ab_27_Delta_SP_0[1],-Vario_Bogen_ab_27_Delta_SP_0[0] * math.sin(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_0[2] * math.cos(math.radians(-24)) ]
|
||||
Vario_Bogen_ab_27_Delta_SP_1 =[ Vario_Bogen_ab_27_Delta_SP_1 [0] * math.cos(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_1[2]* math.sin(math.radians(-24)) ,Vario_Bogen_ab_27_Delta_SP_1[1],-Vario_Bogen_ab_27_Delta_SP_1[0] * math.sin(math.radians(-24))+ Vario_Bogen_ab_27_Delta_SP_1[2] * math.cos(math.radians(-24)) ]
|
||||
Vario_Bogen_auf_27_Delta_VP_1 = [Vario_Bogen_auf_27_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_27_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_27_Delta_VP_1[1],-Vario_Bogen_auf_27_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_27_Delta_VP_1[2] * math.cos(math.radians(3)) ]
|
||||
Vario_Bogen_ab_27_Delta_VP_0 = [Vario_Bogen_ab_27_Delta_VP_0 [0] * math.cos(math.radians(-24))+ Vario_Bogen_ab_27_Delta_VP_0[2]* math.sin(math.radians(-24)) ,Vario_Bogen_ab_27_Delta_VP_0[1],-Vario_Bogen_ab_27_Delta_VP_0[0] * math.sin(math.radians(-24))+ Vario_Bogen_ab_27_Delta_VP_0[2] * math.cos(math.radians(-24)) ]
|
||||
|
||||
# Erstellung der zwischen Line
|
||||
line = Line.new(dxfattribs={"start": start, "end": ende})
|
||||
line.dxf.layer = "6-SP"
|
||||
# negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss)
|
||||
|
||||
copy= line.copy()
|
||||
for i, wert in enumerate(Vario_Bogen_auf_27_Delta_SP_0):
|
||||
if i< 2 and wert < 0:
|
||||
|
||||
copy.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy)
|
||||
Vario_Bogen_auf_27_Delta_SP_0[i] = abs(wert)
|
||||
|
||||
#Hilfmethode zur ausmessen der bogen
|
||||
for i, wert in enumerate(Vario_Bogen_auf_27_Delta_SP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_auf_27_Delta_SP_1[i] = abs(wert)
|
||||
|
||||
for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_0):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_27_Delta_SP_0[i] = abs(wert)
|
||||
|
||||
# a = msp.add_blockref(block_Vario_Bogen_ab_27,(x,y,0))
|
||||
# msp.add_line((x+1000,y +50,0),(x-1000,y+50,0))
|
||||
# msp.add_line((x,y+1000,0),(x,y-1000,0))
|
||||
# add_attributes_to_block(a, ab_27_attrib)
|
||||
for i, wert in enumerate(Vario_Bogen_ab_27_Delta_SP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_27_Delta_SP_1[i] = abs(wert)
|
||||
|
||||
for i, wert in enumerate(Vario_Bogen_auf_27_Delta_VP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_auf_27_Delta_VP_1[i] = abs(wert)
|
||||
|
||||
for i, wert in enumerate(Vario_Bogen_ab_27_Delta_VP_0):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_27_Delta_VP_0[i] = abs(wert)
|
||||
|
||||
|
||||
|
||||
#einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
|
||||
block.add_blockref(block_Vario_Bogen_auf_27,(ende[0] -x ,ende[1] +Vario_Bogen_auf_27_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_27_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90})
|
||||
|
||||
ende_VP = (ende[0] +Vario_Bogen_auf_27_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_27_Delta_VP_1[0]+Vario_Bogen_auf_27_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_27_Delta_VP_1[2]- Vario_Bogen_auf_27_Delta_SP_0[2])
|
||||
ende = (ende[0] ,ende[1] +Vario_Bogen_auf_27_Delta_SP_1[0] + Vario_Bogen_auf_27_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_27_Delta_SP_1[2] - Vario_Bogen_auf_27_Delta_SP_0[2])
|
||||
|
||||
#einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
|
||||
block.add_blockref(block_Vario_Bogen_ab_27 ,(start[0]-x,start[1] - Vario_Bogen_ab_27_Delta_SP_1[0] -y ,start[2] - hoehe_vario - Vario_Bogen_ab_27_Delta_SP_1[2]),dxfattribs={"rotation": 90})
|
||||
start_VP = start[0] +Vario_Bogen_ab_27_Delta_VP_0[1],start[1]-Vario_Bogen_ab_27_Delta_VP_0[0] - Vario_Bogen_ab_27_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_27_Delta_VP_0[2] - Vario_Bogen_ab_27_Delta_SP_1[2]
|
||||
start = start[0] ,start[1] - Vario_Bogen_ab_27_Delta_SP_0[0] - Vario_Bogen_ab_27_Delta_SP_1[0],start[2] +Vario_Bogen_ab_27_Delta_SP_0[2] - Vario_Bogen_ab_27_Delta_SP_1[2]
|
||||
|
||||
# Erstellung der VARIO Line
|
||||
line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP})
|
||||
line_VP.dxf.layer = "VARIO"
|
||||
copy_VP = line_VP.copy()
|
||||
|
||||
copy_VP.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy_VP)
|
||||
|
||||
# Erstellung der zwischen Line
|
||||
line = Line.new(dxfattribs={"start": start, "end": ende})
|
||||
line.dxf.layer = "6-SP"
|
||||
|
||||
copy= line.copy()
|
||||
|
||||
copy.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy)
|
||||
|
||||
#Hilfmethode zur ausmessen der bogen
|
||||
|
||||
# a = msp.add_blockref(block_Vario_Bogen_ab_27,(x,y,0))
|
||||
# msp.add_line((x+1000,y +50,0),(x-1000,y+50,0))
|
||||
# msp.add_line((x,y+1000,0),(x,y-1000,0))
|
||||
# add_attributes_to_block(a, ab_27_attrib)
|
||||
|
||||
|
||||
|
||||
elif winkel == 15:
|
||||
# Einfügen der 18 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
block_Vario_Bogen_ab_18 = "Vario_Bogen_ab_18°"
|
||||
block_Vario_Bogen_auf_18 = "Vario_Bogen_auf_18°"
|
||||
block_Vario_Bogen_auf_18 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_18_auf"))
|
||||
block_Vario_Bogen_ab_18 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_18_ab"))
|
||||
auf_18_attrib =import_block(block_Vario_Bogen_auf_18, lib_doc, doc)
|
||||
ab_18_attrib = import_block(block_Vario_Bogen_ab_18, lib_doc, doc,)
|
||||
block_Vario_Bogen_auf_18 = dreh_block(block_Vario_Bogen_auf_18, doc,math.radians(3))
|
||||
@@ -1566,8 +1635,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
elif winkel == 12:
|
||||
# Einfügen der 15 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
|
||||
block_Vario_Bogen_ab_15 = "Vario_Bogen_ab_15°"
|
||||
block_Vario_Bogen_auf_15 = "Vario_Bogen_auf_15°"
|
||||
block_Vario_Bogen_auf_15 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_15_auf"))
|
||||
block_Vario_Bogen_ab_15 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_15_ab"))
|
||||
auf_15_attrib =import_block(block_Vario_Bogen_auf_15, lib_doc, doc)
|
||||
ab_15_attrib =import_block(block_Vario_Bogen_ab_15, lib_doc, doc)
|
||||
block_Vario_Bogen_auf_15= dreh_block(block_Vario_Bogen_auf_15, doc,math.radians(3))
|
||||
@@ -1656,8 +1725,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
elif winkel == 9:
|
||||
# Einfügen der 12 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
|
||||
block_Vario_Bogen_ab_12 = "Vario_Bogen_ab_12°"
|
||||
block_Vario_Bogen_auf_12 = "Vario_Bogen_auf_12°"
|
||||
block_Vario_Bogen_auf_12 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_12_auf"))
|
||||
block_Vario_Bogen_ab_12 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_12_ab"))
|
||||
auf_12_attrib =import_block(block_Vario_Bogen_auf_12, lib_doc, doc)
|
||||
ab_12_attrib =import_block(block_Vario_Bogen_ab_12, lib_doc, doc)
|
||||
block_Vario_Bogen_auf_12 = dreh_block(block_Vario_Bogen_auf_12, doc,math.radians(3))
|
||||
@@ -1744,12 +1813,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
elif winkel == 3:
|
||||
# Einfügen der 6 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
|
||||
block_Vario_ab_6 = "Vario_Bogen_ab_6°"
|
||||
block_Vario_auf_6 = "Vario_Bogen_auf_6°"
|
||||
ab_6_attrib =import_block( block_Vario_ab_6 , lib_doc, doc)
|
||||
auf_6_attrib =import_block( block_Vario_auf_6 , lib_doc, doc)
|
||||
block_Vario_ab_6 = dreh_block( block_Vario_ab_6, doc, math.radians(3))
|
||||
block_Vario_auf_6 = dreh_block( block_Vario_auf_6 , doc, math.radians(-3))
|
||||
block_Vario_Bogen_auf_6 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_6_auf"))
|
||||
block_Vario_Bogen_ab_6 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_6_ab"))
|
||||
ab_6_attrib =import_block( block_Vario_Bogen_ab_6 , lib_doc, doc)
|
||||
auf_6_attrib =import_block( block_Vario_Bogen_auf_6 , lib_doc, doc)
|
||||
block_Vario_Bogen_ab_6 = dreh_block( block_Vario_Bogen_ab_6, doc, math.radians(3))
|
||||
block_Vario_Bogen_auf_6 = dreh_block( block_Vario_Bogen_auf_6 , doc, math.radians(-3))
|
||||
Vario_Bogen_auf_6_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_6_attrib["DELTA_SP_0"]))
|
||||
Vario_Bogen_auf_6_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_6_attrib["DELTA_SP_1"]))
|
||||
Vario_Bogen_ab_6_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_6_attrib["DELTA_SP_0"]))
|
||||
@@ -1793,14 +1862,14 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
|
||||
#einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
|
||||
|
||||
block.add_blockref(block_Vario_auf_6,(ende[0] -x ,ende[1] +Vario_Bogen_auf_6_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_6_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90})
|
||||
block.add_blockref(block_Vario_Bogen_auf_6,(ende[0] -x ,ende[1] +Vario_Bogen_auf_6_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_6_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90})
|
||||
|
||||
ende_VP = (ende[0] +Vario_Bogen_auf_6_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_6_Delta_VP_1[0]+Vario_Bogen_auf_6_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_6_Delta_VP_1[2]- Vario_Bogen_auf_6_Delta_SP_0[2])
|
||||
ende = (ende[0] ,ende[1] +Vario_Bogen_auf_6_Delta_SP_1[0] + Vario_Bogen_auf_6_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_6_Delta_SP_1[2] - Vario_Bogen_auf_6_Delta_SP_0[2])
|
||||
|
||||
#einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
|
||||
|
||||
block.add_blockref(block_Vario_ab_6 ,(start[0]-x,start[1] - Vario_Bogen_ab_6_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_6_Delta_SP_1[2]),dxfattribs={"rotation": 90})
|
||||
block.add_blockref(block_Vario_Bogen_ab_6 ,(start[0]-x,start[1] - Vario_Bogen_ab_6_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_6_Delta_SP_1[2]),dxfattribs={"rotation": 90})
|
||||
|
||||
start_VP = start[0] +Vario_Bogen_ab_6_Delta_VP_0[1],start[1]-Vario_Bogen_ab_6_Delta_VP_0[0] - Vario_Bogen_ab_6_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_6_Delta_VP_0[2] - Vario_Bogen_ab_6_Delta_SP_1[2]
|
||||
start = start[0] ,start[1] - Vario_Bogen_ab_6_Delta_SP_0[0] - Vario_Bogen_ab_6_Delta_SP_1[0],start[2] +Vario_Bogen_ab_6_Delta_SP_0[2] - Vario_Bogen_ab_6_Delta_SP_1[2]
|
||||
@@ -1831,8 +1900,8 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
elif winkel == 0:
|
||||
# Einfügen der 3 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
|
||||
block_Vario_Bogen_auf_3 = "Vario_Bogen_auf_3°"
|
||||
block_Vario_Bogen_ab_3 = "Vario_Bogen_ab_3°"
|
||||
block_Vario_Bogen_auf_3 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_3_auf"))
|
||||
block_Vario_Bogen_ab_3 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_3_ab"))
|
||||
auf_3_attrib =import_block(block_Vario_Bogen_auf_3, lib_doc, doc)
|
||||
ab_3_attrib = import_block(block_Vario_Bogen_ab_3, lib_doc, doc)
|
||||
block_Vario_Bogen_auf_3= dreh_block(block_Vario_Bogen_auf_3, doc,math.radians(3))
|
||||
@@ -1919,7 +1988,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
# Setzng die hälfte des Gefälles auf beide seiten falls dieser nicht mit einem anderen Förder verbunden ist was durch die abwesenheit eines motors/umlenkung gezeigt wird
|
||||
|
||||
if gefaelle > 0:
|
||||
if motor_vorhanden == "True" and umlenk_vorhanden == "True":
|
||||
if motor_vorhanden == True and umlenk_vorhanden == True:
|
||||
halbesgefaelle = gefaelle/2
|
||||
gefaelle_ende = ende[0], ende[1] +halbesgefaelle, ende[2] +math.sin(math.radians(gefahellewinkel))* halbesgefaelle
|
||||
line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende})
|
||||
@@ -1936,7 +2005,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
copy_start.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy_start)
|
||||
start = gefaelle_start
|
||||
elif motor_vorhanden == "True":
|
||||
elif motor_vorhanden == True:
|
||||
gefaelle_ende = ende[0], ende[1] +gefaelle, ende[2] +math.sin(math.radians(gefahellewinkel))* gefaelle
|
||||
line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende})
|
||||
line_ende_gefaelle.dxf.layer = "6-SP"
|
||||
@@ -1944,7 +2013,7 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
copy_ende.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy_ende)
|
||||
ende = gefaelle_ende
|
||||
elif umlenk_vorhanden == "True":
|
||||
elif umlenk_vorhanden == True:
|
||||
gefaelle_start = start[0], start[1] -gefaelle, start[2] -math.sin(math.radians(gefahellewinkel)) * gefaelle
|
||||
line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start})
|
||||
line_start_gefaelle.dxf.layer = "6-SP"
|
||||
@@ -1960,13 +2029,13 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
import_block( block_Vario_Umlenkstation_500mm , lib_doc, doc)
|
||||
block_Vario_Motorstation_500mm = dreh_block( block_Vario_Motorstation_500mm, doc,math.radians(3))
|
||||
block_Vario_Umlenkstation_500mm = dreh_block( block_Vario_Umlenkstation_500mm , doc,math.radians(3))
|
||||
if umlenk_vorhanden == "True":
|
||||
if umlenk_vorhanden == True:
|
||||
block.add_blockref(block_Vario_Umlenkstation_500mm,(start[0] -x,start[1] -y - umlenk_motor_offset[0]/2, start[2] - hoehe_vario -umlenk_motor_offset[2]/2 ),dxfattribs={"rotation": 270})
|
||||
start_Umlenkstation_VP = start[0] - 66.5, start[1] -500 *math.cos(math.radians(-3))+ math.sin(math.radians(-3))* -45,start[2] + math.sin(math.radians(-3))*500+ math.cos(math.radians(-3))*-45
|
||||
start = (start[0] ,start[1] - umlenk_motor_offset[0],start[2] -umlenk_motor_offset[2])
|
||||
elif winkel == 3:
|
||||
start_Umlenkstation_VP = start[0] - 66.5, start[1]+ winkel_VP_offset_vorne[0],start[2] -winkel_VP_offset_hinten[2]
|
||||
if motor_vorhanden == "True":
|
||||
if motor_vorhanden == True:
|
||||
block.add_blockref(block_Vario_Motorstation_500mm, (ende[0]-x , ende[1] + umlenk_motor_offset[0]/2 -y ,ende[2] - hoehe_vario +umlenk_motor_offset[2]/2),dxfattribs={"rotation": 270})
|
||||
ende_Motor_VP = ende[0] - 66.5, ende[1] +500 *math.cos(math.radians(-3))+ math.sin(math.radians(-3))* -45,ende[2] - math.sin(math.radians(-3))*500+ math.cos(math.radians(-3))*-45
|
||||
|
||||
@@ -1976,13 +2045,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
|
||||
if winkel == 48:
|
||||
# Einfügen der 45 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
|
||||
block_Vario_ab_45 = "Vario_Bogen_ab_45°"
|
||||
block_Vario_auf_45 = "Vario_Bogen_auf_45°"
|
||||
ab_45_attrib =import_block( block_Vario_ab_45 , lib_doc, doc)
|
||||
auf_45_attrib =import_block( block_Vario_auf_45 , lib_doc, doc)
|
||||
block_Vario_ab_45 = dreh_block( block_Vario_ab_45 , doc, math.radians(3))
|
||||
block_Vario_auf_45 = dreh_block( block_Vario_auf_45 , doc, math.radians(48))
|
||||
block_Vario_Bogen_auf_45 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_45_auf"))
|
||||
block_Vario_Bogen_ab_45 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_45_ab"))
|
||||
ab_45_attrib =import_block( block_Vario_Bogen_ab_45 , lib_doc, doc)
|
||||
auf_45_attrib =import_block( block_Vario_Bogen_auf_45, lib_doc, doc)
|
||||
block_Vario_Bogen_ab_45 = dreh_block( block_Vario_Bogen_ab_45, doc, math.radians(3))
|
||||
block_Vario_Bogen_auf_45= dreh_block( block_Vario_Bogen_auf_45, doc, math.radians(48))
|
||||
Vario_Bogen_auf_45_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_45_attrib["DELTA_SP_0"]))
|
||||
Vario_Bogen_auf_45_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_45_attrib["DELTA_SP_1"]))
|
||||
Vario_Bogen_ab_45_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_45_attrib["DELTA_SP_0"]))
|
||||
@@ -2026,14 +2094,14 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
|
||||
#einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
|
||||
|
||||
block.add_blockref(block_Vario_ab_45, (start[0]-x,start[1]-y- Vario_Bogen_ab_45_Delta_SP_0[0], start[2]- hoehe_vario- Vario_Bogen_ab_45_Delta_SP_0[2]),dxfattribs={"rotation": 270})
|
||||
block.add_blockref(block_Vario_Bogen_ab_45, (start[0]-x,start[1]-y- Vario_Bogen_ab_45_Delta_SP_0[0], start[2]- hoehe_vario- Vario_Bogen_ab_45_Delta_SP_0[2]),dxfattribs={"rotation": 270})
|
||||
start_VP = start[0] -Vario_Bogen_ab_45_Delta_VP_1[1],start[1]- Vario_Bogen_ab_45_Delta_VP_1[0]- Vario_Bogen_ab_45_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_45_Delta_VP_1[2]-Vario_Bogen_ab_45_Delta_SP_0[2]
|
||||
|
||||
start =(start[0], start[1]- Vario_Bogen_ab_45_Delta_SP_0[0]- Vario_Bogen_ab_45_Delta_SP_1[0],start[2]-Vario_Bogen_ab_45_Delta_SP_0[2]+Vario_Bogen_ab_45_Delta_SP_1[2])
|
||||
|
||||
#einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
|
||||
|
||||
block.add_blockref(block_Vario_auf_45, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_45_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_45_Delta_SP_1[2]),dxfattribs={"rotation": 270})
|
||||
block.add_blockref(block_Vario_Bogen_auf_45, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_45_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_45_Delta_SP_1[2]),dxfattribs={"rotation": 270})
|
||||
ende_VP = (ende[0] -Vario_Bogen_auf_45_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_45_Delta_VP_0[0]+ Vario_Bogen_auf_45_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_45_Delta_VP_0[2]- Vario_Bogen_auf_45_Delta_SP_1[2])
|
||||
ende = (ende[0],ende[1]+ Vario_Bogen_auf_45_Delta_SP_1[0]+ Vario_Bogen_auf_45_Delta_SP_0[0],ende[2]- Vario_Bogen_auf_45_Delta_SP_1[2]+ Vario_Bogen_auf_45_Delta_SP_0[2])
|
||||
|
||||
@@ -2064,12 +2132,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
elif winkel == 36:
|
||||
# Einfügen der 33 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
|
||||
block_Vario_ab_33 = "Vario_Bogen_ab_33°"
|
||||
block_Vario_auf_33 = "Vario_Bogen_auf_33°"
|
||||
ab_33_attrib =import_block( block_Vario_ab_33 , lib_doc, doc)
|
||||
auf_33_attrib =import_block( block_Vario_auf_33 , lib_doc, doc)
|
||||
block_Vario_ab_33 = dreh_block( block_Vario_ab_33 , doc, math.radians(3))
|
||||
block_Vario_auf_33 = dreh_block( block_Vario_auf_33 , doc, math.radians(36))
|
||||
block_Vario_Bogen_auf_33 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_33_auf"))
|
||||
block_Vario_Bogen_ab_33 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_33_ab"))
|
||||
ab_33_attrib =import_block( block_Vario_Bogen_ab_33 , lib_doc, doc)
|
||||
auf_33_attrib =import_block(block_Vario_Bogen_auf_33, lib_doc, doc)
|
||||
block_Vario_Bogen_ab_33 = dreh_block(block_Vario_Bogen_ab_33 , doc, math.radians(3))
|
||||
block_Vario_Bogen_auf_33= dreh_block(block_Vario_Bogen_auf_33 , doc, math.radians(36))
|
||||
Vario_Bogen_auf_33_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_33_attrib["DELTA_SP_0"]))
|
||||
Vario_Bogen_auf_33_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_33_attrib["DELTA_SP_1"]))
|
||||
Vario_Bogen_ab_33_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_33_attrib["DELTA_SP_0"]))
|
||||
@@ -2113,13 +2181,13 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
|
||||
#einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
|
||||
|
||||
block.add_blockref(block_Vario_ab_33, (start[0]-x,start[1]-y- Vario_Bogen_ab_33_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_33_Delta_SP_0[2]),dxfattribs={"rotation": 270})
|
||||
block.add_blockref(block_Vario_Bogen_ab_33, (start[0]-x,start[1]-y- Vario_Bogen_ab_33_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_33_Delta_SP_0[2]),dxfattribs={"rotation": 270})
|
||||
start_VP = start[0] -Vario_Bogen_ab_33_Delta_VP_1[1],start[1]- Vario_Bogen_ab_33_Delta_VP_1[0]- Vario_Bogen_ab_33_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_33_Delta_VP_1[2]-Vario_Bogen_ab_33_Delta_SP_0[2]
|
||||
start =(start[0], start[1]- Vario_Bogen_ab_33_Delta_SP_0[0]- Vario_Bogen_ab_33_Delta_SP_1[0],start[2]-Vario_Bogen_ab_33_Delta_SP_0[2]+Vario_Bogen_ab_33_Delta_SP_1[2])
|
||||
|
||||
#einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
|
||||
|
||||
block.add_blockref(block_Vario_auf_33, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_33_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_33_Delta_SP_1[2]),dxfattribs={"rotation": 270})
|
||||
block.add_blockref(block_Vario_Bogen_auf_33, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_33_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_33_Delta_SP_1[2]),dxfattribs={"rotation": 270})
|
||||
ende_VP = (ende[0] -Vario_Bogen_auf_33_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_33_Delta_VP_0[0]+ Vario_Bogen_auf_33_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_33_Delta_VP_0[2]- Vario_Bogen_auf_33_Delta_SP_1[2])
|
||||
ende = (ende[0],ende[1]+ Vario_Bogen_auf_33_Delta_SP_0[0]+ Vario_Bogen_auf_33_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_33_Delta_SP_0[2]- Vario_Bogen_auf_33_Delta_SP_1[2])
|
||||
|
||||
@@ -2148,12 +2216,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
elif winkel == 24:
|
||||
# Einfügen der 21 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
|
||||
block_Vario_ab_21 = "Vario_Bogen_ab_21°"
|
||||
block_Vario_auf_21 = "Vario_Bogen_auf_21°"
|
||||
ab_21_attrib =import_block( block_Vario_ab_21 , lib_doc, doc)
|
||||
auf_21_attrib =import_block( block_Vario_auf_21 , lib_doc, doc)
|
||||
block_Vario_ab_21 = dreh_block( block_Vario_ab_21 , doc, math.radians(3))
|
||||
block_Vario_auf_21 = dreh_block( block_Vario_auf_21 , doc, math.radians(24))
|
||||
block_Vario_Bogen_auf_21 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_21_auf"))
|
||||
block_Vario_Bogen_ab_21 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_21_ab"))
|
||||
ab_21_attrib =import_block(block_Vario_Bogen_ab_21, lib_doc, doc)
|
||||
auf_21_attrib =import_block(block_Vario_Bogen_auf_21 , lib_doc, doc)
|
||||
block_Vario_Bogen_ab_21= dreh_block(block_Vario_Bogen_ab_21 , doc, math.radians(3))
|
||||
block_Vario_Bogen_auf_21 = dreh_block(block_Vario_Bogen_auf_21 , doc, math.radians(24))
|
||||
Vario_Bogen_auf_21_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_21_attrib["DELTA_SP_0"]))
|
||||
Vario_Bogen_auf_21_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_21_attrib["DELTA_SP_1"]))
|
||||
Vario_Bogen_ab_21_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_21_attrib["DELTA_SP_0"]))
|
||||
@@ -2197,14 +2265,14 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
|
||||
#einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
|
||||
|
||||
block.add_blockref(block_Vario_ab_21, (start[0]-x,start[1]-y- Vario_Bogen_ab_21_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_21_Delta_SP_0[2]),dxfattribs={"rotation": 270})
|
||||
block.add_blockref(block_Vario_Bogen_ab_21, (start[0]-x,start[1]-y- Vario_Bogen_ab_21_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_21_Delta_SP_0[2]),dxfattribs={"rotation": 270})
|
||||
|
||||
start_VP = start[0] -Vario_Bogen_ab_21_Delta_VP_1[1],start[1]- Vario_Bogen_ab_21_Delta_VP_1[0]- Vario_Bogen_ab_21_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_21_Delta_VP_1[2]-Vario_Bogen_ab_21_Delta_SP_0[2]
|
||||
|
||||
start =(start[0], start[1]- Vario_Bogen_ab_21_Delta_SP_0[0]- Vario_Bogen_ab_21_Delta_SP_1[0],start[2]-Vario_Bogen_ab_21_Delta_SP_0[2]+Vario_Bogen_ab_21_Delta_SP_1[2])
|
||||
#einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
|
||||
|
||||
block.add_blockref(block_Vario_auf_21, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_21_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_21_Delta_SP_1[2]),dxfattribs={"rotation": 270})
|
||||
block.add_blockref(block_Vario_Bogen_auf_21, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_21_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_21_Delta_SP_1[2]),dxfattribs={"rotation": 270})
|
||||
ende_VP = (ende[0] -Vario_Bogen_auf_21_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_21_Delta_VP_0[0]+ Vario_Bogen_auf_21_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_21_Delta_VP_0[2]- Vario_Bogen_auf_21_Delta_SP_1[2])
|
||||
|
||||
ende = (ende[0],ende[1]+ Vario_Bogen_auf_21_Delta_SP_0[0]+ Vario_Bogen_auf_21_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_21_Delta_SP_0[2]- Vario_Bogen_auf_21_Delta_SP_1[2])
|
||||
@@ -2233,12 +2301,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
elif winkel == 15:
|
||||
# Einfügen der 12 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
|
||||
block_Vario_ab_12 = "Vario_Bogen_ab_12°"
|
||||
block_Vario_auf_12 = "Vario_Bogen_auf_12°"
|
||||
ab_12_attrib =import_block( block_Vario_ab_12 , lib_doc, doc)
|
||||
auf_12_attrib =import_block( block_Vario_auf_12 , lib_doc, doc)
|
||||
block_Vario_ab_12 = dreh_block( block_Vario_ab_12, doc, math.radians(3))
|
||||
block_Vario_auf_12 = dreh_block( block_Vario_auf_12 , doc, math.radians(15))
|
||||
block_Vario_Bogen_auf_12 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_12_auf"))
|
||||
block_Vario_Bogen_ab_12 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_12_ab"))
|
||||
ab_12_attrib =import_block(block_Vario_Bogen_ab_12, lib_doc, doc)
|
||||
auf_12_attrib =import_block( block_Vario_Bogen_auf_12 , lib_doc, doc)
|
||||
block_Vario_Bogen_ab_12 = dreh_block(block_Vario_Bogen_ab_12, doc, math.radians(3))
|
||||
block_Vario_Bogen_auf_12 = dreh_block(block_Vario_Bogen_auf_12 , doc, math.radians(15))
|
||||
Vario_Bogen_auf_12_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_12_attrib["DELTA_SP_0"]))
|
||||
Vario_Bogen_auf_12_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_12_attrib["DELTA_SP_1"]))
|
||||
Vario_Bogen_ab_12_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_12_attrib["DELTA_SP_0"]))
|
||||
@@ -2283,14 +2351,14 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
|
||||
#einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
|
||||
|
||||
block.add_blockref(block_Vario_ab_12, (start[0]-x,start[1]-y- Vario_Bogen_ab_12_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_12_Delta_SP_0[2]),dxfattribs={"rotation": 270})
|
||||
block.add_blockref(block_Vario_Bogen_ab_12, (start[0]-x,start[1]-y- Vario_Bogen_ab_12_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_12_Delta_SP_0[2]),dxfattribs={"rotation": 270})
|
||||
start_VP = start[0] -Vario_Bogen_ab_12_Delta_VP_1[1],start[1]- Vario_Bogen_ab_12_Delta_VP_1[0]- Vario_Bogen_ab_12_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_12_Delta_VP_1[2]-Vario_Bogen_ab_12_Delta_SP_0[2]
|
||||
|
||||
start =(start[0], start[1]- Vario_Bogen_ab_12_Delta_SP_0[0]- Vario_Bogen_ab_12_Delta_SP_1[0],start[2]-Vario_Bogen_ab_12_Delta_SP_0[2]+Vario_Bogen_ab_12_Delta_SP_1[2])
|
||||
|
||||
#einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
|
||||
|
||||
block.add_blockref(block_Vario_auf_12, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_12_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_12_Delta_SP_1[2]),dxfattribs={"rotation": 270})
|
||||
block.add_blockref(block_Vario_Bogen_auf_12, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_12_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_12_Delta_SP_1[2]),dxfattribs={"rotation": 270})
|
||||
|
||||
ende_VP = (ende[0] -Vario_Bogen_auf_12_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_12_Delta_VP_0[0]+ Vario_Bogen_auf_12_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_12_Delta_VP_0[2]- Vario_Bogen_auf_12_Delta_SP_1[2])
|
||||
|
||||
@@ -2321,13 +2389,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
|
||||
elif winkel == 12:
|
||||
# Einfügen der 9 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
|
||||
block_Vario_ab_9 = "Vario_Bogen_ab_9°"
|
||||
block_Vario_auf_9 = "Vario_Bogen_auf_9°"
|
||||
ab_9_attrib =import_block( block_Vario_ab_9 , lib_doc, doc)
|
||||
auf_9_attrib =import_block( block_Vario_auf_9 , lib_doc, doc)
|
||||
block_Vario_ab_9 = dreh_block( block_Vario_ab_9, doc, math.radians(3))
|
||||
block_Vario_auf_9 = dreh_block( block_Vario_auf_9 , doc, math.radians(12))
|
||||
block_Vario_Bogen_auf_9 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_9_auf"))
|
||||
block_Vario_Bogen_ab_9 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_9_ab"))
|
||||
ab_9_attrib =import_block( block_Vario_Bogen_ab_9 , lib_doc, doc)
|
||||
auf_9_attrib =import_block(block_Vario_Bogen_auf_9 , lib_doc, doc)
|
||||
block_Vario_Bogen_ab_9 = dreh_block( block_Vario_Bogen_ab_9, doc, math.radians(3))
|
||||
block_Vario_Bogen_auf_9 = dreh_block(block_Vario_Bogen_auf_9, doc, math.radians(12))
|
||||
Vario_Bogen_auf_9_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_9_attrib["DELTA_SP_0"]))
|
||||
Vario_Bogen_auf_9_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_9_attrib["DELTA_SP_1"]))
|
||||
Vario_Bogen_ab_9_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_9_attrib["DELTA_SP_0"]))
|
||||
@@ -2372,14 +2439,14 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
|
||||
#einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
|
||||
|
||||
block.add_blockref(block_Vario_ab_9, (start[0]-x,start[1]-y- Vario_Bogen_ab_9_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_9_Delta_SP_0[2]),dxfattribs={"rotation": 270})
|
||||
block.add_blockref(block_Vario_Bogen_ab_9, (start[0]-x,start[1]-y- Vario_Bogen_ab_9_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_9_Delta_SP_0[2]),dxfattribs={"rotation": 270})
|
||||
|
||||
start_VP = start[0] -Vario_Bogen_ab_9_Delta_VP_1[1],start[1]- Vario_Bogen_ab_9_Delta_VP_1[0]- Vario_Bogen_ab_9_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_9_Delta_VP_1[2]-Vario_Bogen_ab_9_Delta_SP_0[2]
|
||||
start =(start[0], start[1]- Vario_Bogen_ab_9_Delta_SP_0[0]- Vario_Bogen_ab_9_Delta_SP_1[0],start[2]-Vario_Bogen_ab_9_Delta_SP_0[2]+Vario_Bogen_ab_9_Delta_SP_1[2])
|
||||
|
||||
#einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
|
||||
|
||||
block.add_blockref(block_Vario_auf_9, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_9_Delta_SP_1[2]),dxfattribs={"rotation": 270})
|
||||
block.add_blockref(block_Vario_Bogen_auf_9 , (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_9_Delta_SP_1[2]),dxfattribs={"rotation": 270})
|
||||
ende_VP = (ende[0] -Vario_Bogen_auf_9_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_9_Delta_VP_0[0]+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_9_Delta_VP_0[2]-Vario_Bogen_auf_9_Delta_SP_1[2])
|
||||
|
||||
ende = (ende[0],ende[1]+ Vario_Bogen_auf_9_Delta_SP_0[0]+ Vario_Bogen_auf_9_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_9_Delta_SP_0[2]- Vario_Bogen_auf_9_Delta_SP_1[2])
|
||||
@@ -2413,12 +2480,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
elif winkel == 9:
|
||||
# Einfügen der 6 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
|
||||
block_Vario_ab_6 = "Vario_Bogen_ab_6°"
|
||||
block_Vario_auf_6 = "Vario_Bogen_auf_6°"
|
||||
ab_6_attrib =import_block( block_Vario_ab_6 , lib_doc, doc)
|
||||
auf_6_attrib =import_block( block_Vario_auf_6 , lib_doc, doc)
|
||||
block_Vario_ab_6 = dreh_block( block_Vario_ab_6, doc, math.radians(3))
|
||||
block_Vario_auf_6 = dreh_block( block_Vario_auf_6 , doc, math.radians(9))
|
||||
block_Vario_Bogen_auf_6 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_6_auf"))
|
||||
block_Vario_Bogen_ab_6 = str(config.get("ILS 2.0 Variofoerderer_Bogen_block_namen","bogen_6_ab"))
|
||||
ab_6_attrib =import_block(block_Vario_Bogen_ab_6 , lib_doc, doc)
|
||||
auf_6_attrib =import_block(block_Vario_Bogen_auf_6, lib_doc, doc)
|
||||
block_Vario_Bogen_ab_6 = dreh_block(block_Vario_Bogen_ab_6, doc, math.radians(3))
|
||||
block_Vario_Bogen_auf_6 = dreh_block(block_Vario_Bogen_auf_6 , doc, math.radians(9))
|
||||
Vario_Bogen_auf_6_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_6_attrib["DELTA_SP_0"]))
|
||||
Vario_Bogen_auf_6_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_6_attrib["DELTA_SP_1"]))
|
||||
Vario_Bogen_ab_6_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_6_attrib["DELTA_SP_0"]))
|
||||
@@ -2463,12 +2530,12 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
|
||||
#einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
|
||||
|
||||
block.add_blockref(block_Vario_ab_6, (start[0]-x,start[1]-y- Vario_Bogen_ab_6_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_6_Delta_SP_0[2]),dxfattribs={"rotation": 270})
|
||||
block.add_blockref(block_Vario_Bogen_ab_6, (start[0]-x,start[1]-y- Vario_Bogen_ab_6_Delta_SP_0[0],start[2]-hoehe_vario-Vario_Bogen_ab_6_Delta_SP_0[2]),dxfattribs={"rotation": 270})
|
||||
start_VP = start[0] -Vario_Bogen_ab_6_Delta_VP_1[1],start[1]- Vario_Bogen_ab_6_Delta_VP_1[0]- Vario_Bogen_ab_6_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_6_Delta_VP_1[2]-Vario_Bogen_ab_6_Delta_SP_0[2]
|
||||
start =(start[0], start[1]- Vario_Bogen_ab_6_Delta_SP_0[0]- Vario_Bogen_ab_6_Delta_SP_1[0],start[2]-Vario_Bogen_ab_6_Delta_SP_0[2]+Vario_Bogen_ab_6_Delta_SP_1[2])
|
||||
|
||||
#einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
|
||||
block.add_blockref(block_Vario_auf_6, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_6_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_6_Delta_SP_1[2]),dxfattribs={"rotation": 270})
|
||||
block.add_blockref(block_Vario_Bogen_auf_6, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_6_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_6_Delta_SP_1[2]),dxfattribs={"rotation": 270})
|
||||
ende_VP = (ende[0] -Vario_Bogen_auf_6_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_6_Delta_VP_0[0]+ Vario_Bogen_auf_6_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_6_Delta_VP_0[2]- Vario_Bogen_auf_6_Delta_SP_1[2])
|
||||
|
||||
ende = (ende[0],ende[1]+ Vario_Bogen_auf_6_Delta_SP_0[0]+ Vario_Bogen_auf_6_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_6_Delta_SP_0[2]- Vario_Bogen_auf_6_Delta_SP_1[2])
|
||||
@@ -2530,12 +2597,13 @@ def vario_erstellung(msp,merkmale, x, y, doc, lib_doc, config, winkel, hoehe_var
|
||||
block_links.add_entity(clone)
|
||||
|
||||
|
||||
def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn,config):
|
||||
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).
|
||||
Für alle anderen Omniflo-Typen: Block mit SivasNummer an den Koordinaten.
|
||||
"""
|
||||
# Prüfen, ob es sich um eine Gerade handelt
|
||||
global global_zaehler
|
||||
if merkmale.get("Länge in Meter") is not None and merkmale.get("Winkel") is not None:
|
||||
try:
|
||||
laenge = float(merkmale.get("Länge in Meter", "0").replace(",", ".")) * 1000 # Meter → mm
|
||||
@@ -2573,23 +2641,25 @@ def handle_omniflo(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols,
|
||||
if blockname not in lib_doc.blocks:
|
||||
print(f"[WARN] Omniflo-Block '{blockname}' nicht in Bibliothek {lib_doc.filename}. Überspringe {teileid}.")
|
||||
return
|
||||
import_block(blockname, lib_doc, doc)
|
||||
blockref_layer = get_layer(doc, lib_doc, blockname)
|
||||
blockname = blockname
|
||||
drehung = merkmale.get("Drehung")
|
||||
|
||||
bref = msp.add_blockref(blockname, (x, y,float(merkmale.get("Höhe"))), dxfattribs={"xscale": 1.0, "yscale":1.0,"rotation": drehung, "layer": blockref_layer})
|
||||
|
||||
import_block(blockname, lib_doc, doc)
|
||||
|
||||
# blockref_layer = get_layer(doc, lib_doc, blockname)
|
||||
symblos_layers = config_allgemein.get("dxf2lib","automation_layer")
|
||||
|
||||
drehung = merkmale.get("Drehung")
|
||||
|
||||
bref = msp.add_blockref(blockname, (x, y,float(merkmale.get("Höhe"))), dxfattribs={"rotation": drehung})
|
||||
# Layer, auf dem der Insert liegt
|
||||
|
||||
|
||||
|
||||
|
||||
a =bref.add_attrib(
|
||||
tag= "NAME",
|
||||
text= merkmale.get("bezeichner"),
|
||||
insert = (x,y)
|
||||
|
||||
|
||||
)
|
||||
a.is_invisible = True
|
||||
bref.add_auto_attribs({ATTR_TAG: teileid})
|
||||
if verbose:
|
||||
print(f"[INFO] Block '{blockname}' (Omniflo) → {teileid} ({x:.1f}, {y:.1f})")
|
||||
|
||||
|
||||
|
||||
@@ -2704,8 +2774,10 @@ def erstellung_gefaelle_block_verbunenden_am_einen(msp,x, y, doc, lib_doc, asoff
|
||||
copy.translate(-x ,-y,-hoehe_gefaehlle)
|
||||
block.add_entity(copy)
|
||||
block.add_blockref(block_as,(start[0]-x ,start[1]+asoffset -y,start[2] - hoehe_gefaehlle),dxfattribs={"rotation": 180})
|
||||
return False
|
||||
else:
|
||||
msp.add_blockref(block_as,(x,y,upper_hoehe_gefaehlle),dxfattribs={"rotation": 180})
|
||||
return True
|
||||
|
||||
elif (( blockname not in doc.blocks and hight == "lower" and drehung0 == "UZS") or (vario_richtung == "Auf" and verbungden_höher == True and drehung0 == "UZS") or (vario_richtung == "Ab" and verbungden_höher == False and drehung0 == "UZS")):
|
||||
if hight != None:
|
||||
@@ -3426,7 +3498,7 @@ def get_rotations_of_strecken(csv_path:Path) -> dict:
|
||||
Id = row["TeileId"].strip()
|
||||
NachbarIds = row["NachbarIds"].strip()
|
||||
geraden.append({"Id": Id, "NachbarIds": NachbarIds})
|
||||
if bezeichner == "ILS 2.0 Kreisel":
|
||||
if bezeichner == "ILS 2.0 Kreisel" or bezeichner == "ILS 2.0 Kreisel mit Pin":
|
||||
Id = row["TeileId"].strip()
|
||||
planquadrat = row["Planquadrat"]
|
||||
x, y = extract_coords(planquadrat)
|
||||
@@ -3501,20 +3573,28 @@ def get_rotations_of_strecken(csv_path:Path) -> dict:
|
||||
|
||||
|
||||
# --------------------------------------------------------- Hauptfunktion
|
||||
def main(csv_path: Path, lib_path: Path, cfg_path: Path,
|
||||
def main(csv_path: Path, lib_path: Path, cfg_path: Path, allgemein_cfg_path: Path,
|
||||
output_path: Path, verbose=False, logger=None):
|
||||
|
||||
# Bibliothek nur laden, wenn Datei existiert
|
||||
check_dxflibrary_path(lib_path, verbose, logger)
|
||||
parser = configparser.ConfigParser()
|
||||
parser_cfg_path = configparser.ConfigParser()
|
||||
try:
|
||||
with open(cfg_path, encoding='utf-8') as f:
|
||||
parser.read_file(f)
|
||||
parser_cfg_path.read_file(f)
|
||||
except Exception as e:
|
||||
msg = f"Fehler beim Lesen der Config-Datei {cfg_path}: {e}"
|
||||
# Neue Zielzeichnung (DXF R2018)
|
||||
config =parser
|
||||
doc = ezdxf.new(dxfversion="R2018")
|
||||
config =parser_cfg_path
|
||||
parser_allgemein_path = configparser.ConfigParser()
|
||||
try:
|
||||
with open(allgemein_cfg_path, encoding='utf-8') as f:
|
||||
parser_allgemein_path.read_file(f)
|
||||
except Exception as e:
|
||||
msg = f"Fehler beim Lesen der Config-Datei {cfg_path}: {e}"
|
||||
# Neue Zielzeichnung (DXF R2018)
|
||||
config_allgemein =parser_allgemein_path
|
||||
doc = ezdxf.new(dxfversion="R2018", setup=True)
|
||||
doc.units = units.M
|
||||
doc.header['$INSUNITS'] = 4 # Millimeter
|
||||
msp = doc.modelspace()
|
||||
@@ -3538,6 +3618,8 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path,
|
||||
# rot_of_gf["shape_3ae53a7b-efb8-f66b-eadc-20b99f949ef1"] = ('UZ', 'GUZ')
|
||||
|
||||
# Verarbeitung der Blöcke
|
||||
|
||||
|
||||
with csv_path.open(newline="", encoding="utf-8") as fh:
|
||||
reader = csv.DictReader(fh, delimiter=';')
|
||||
for row in reader:
|
||||
@@ -3590,7 +3672,7 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path,
|
||||
if func_name.startswith('handle_omniflo'):
|
||||
handler = globals().get('handle_omniflo')
|
||||
if handler:
|
||||
handler(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn, config)
|
||||
handler(msp, teileid, merkmale, x, y, doc, lib_doc, verbose, symbols, strecken_nachbarn, config,config_allgemein)
|
||||
else:
|
||||
msg = f"[WARN] Keine Routine für TeileArt '{teileart}'. Überspringe '{teileid}'."
|
||||
if logger:
|
||||
@@ -3600,6 +3682,19 @@ def main(csv_path: Path, lib_path: Path, cfg_path: Path,
|
||||
continue
|
||||
|
||||
# DXF speichern
|
||||
for insert in msp.query("INSERT"):
|
||||
name = insert.dxf.name # Name des referenzierten Blocks
|
||||
position = insert.dxf.insert
|
||||
if name == "834372115":
|
||||
symbol_att = import_block("834372115_symbol",lib_doc,doc)
|
||||
block = doc.blocks["834372115_symbol"]
|
||||
for e in block:
|
||||
if e.dxftype() != "INSERT":
|
||||
block.delete_entity(e)
|
||||
att =msp.add_blockref("834372115_symbol",(position[0],position[1],position[2])) # Einfügepunkt (x, y, z)
|
||||
|
||||
rotation = insert.dxf.rotation # Drehung in Grad (optional)
|
||||
layer = insert.dxf.layer
|
||||
doc.saveas(output_path)
|
||||
if logger:
|
||||
logger.info(f"[DONE] DXF gespeichert unter: {output_path}")
|
||||
@@ -3658,6 +3753,6 @@ if __name__ == "__main__":
|
||||
default_lib_path = Path(args.lib) if args.lib else data_dir / "blocks.dxf"
|
||||
output_path = Path(args.output) if args.output else (work_dir / f"{csv_path.stem}.dxf")
|
||||
|
||||
main(csv_path, default_lib_path, cfg_path, output_path, verbose=args.verbose, logger=logger)
|
||||
main(csv_path, default_lib_path, cfg_path,allgemein_cfg_path, output_path, verbose=args.verbose, logger=logger)
|
||||
logger.info("=== plant2dxf Verarbeitung abgeschlossen ===")
|
||||
|
||||
|
||||
Reference in New Issue
Block a user