Refoctoring
This commit is contained in:
@@ -0,0 +1,238 @@
|
||||
|
||||
from ezdxf.entities import Line
|
||||
import math
|
||||
from pydantic import BaseModel, Field, field_validator
|
||||
from typing import Optional
|
||||
from plant2dxf import import_block, get_layer
|
||||
|
||||
|
||||
ATTR_TAG = "TeileId" # Attributtag im Block
|
||||
RADIUS = 400 # Radius der Kreiselkreise (mm)
|
||||
|
||||
class Kreisel(BaseModel):
|
||||
"""Pydantic-Modell für Kreisel-Komponenten."""
|
||||
teileid: str
|
||||
x: float = Field(description="X-Koordinate des Kreisel-Zentrums")
|
||||
y: float = Field(description="Y-Koordinate des Kreisel-Zentrums")
|
||||
hoehe: float = Field(description="Höhe in mm")
|
||||
drehung: float = Field(default=0.0, description="Drehung/Winkel in Grad")
|
||||
drehrichtung: Optional[str] = Field(default=None, description="Drehrichtung: UZS oder GUZS")
|
||||
abstand: float = Field(default=20000.0, description="Abstand zwischen Kreiselachsen in mm")
|
||||
kreiselart: Optional[str] = Field(default=None, description="Kreiselart, z.B. 'Pin'")
|
||||
anzahl_scanner: float = Field(default=0.0, description="Anzahl der Scanner")
|
||||
anzahl_separatoren: float = Field(default=0.0, description="Anzahl der Separatoren")
|
||||
|
||||
@field_validator('abstand')
|
||||
@classmethod
|
||||
def validate_abstand(cls, v):
|
||||
"""Konvertiert Abstand von Meter zu mm, falls nötig."""
|
||||
if isinstance(v, str):
|
||||
v = v.replace(",", ".")
|
||||
try:
|
||||
v = float(v) * 1000 # Meter → mm
|
||||
except ValueError:
|
||||
v = 10000.0 # Fallback 10 m
|
||||
return v
|
||||
|
||||
@field_validator('hoehe')
|
||||
@classmethod
|
||||
def validate_hoehe(cls, v):
|
||||
"""Konvertiert Höhe von Meter zu mm, falls nötig."""
|
||||
if isinstance(v, str):
|
||||
v = v.replace(",", ".")
|
||||
try:
|
||||
v = float(v) * 1000 # Meter → mm
|
||||
except ValueError:
|
||||
v = 0.0
|
||||
return v
|
||||
|
||||
@property
|
||||
def halbabstand(self) -> float:
|
||||
"""Halbabstand zwischen den beiden Blöcken."""
|
||||
return self.abstand / 2
|
||||
|
||||
@property
|
||||
def winkel_rad(self) -> float:
|
||||
"""Winkel in Radianten für Berechnungen."""
|
||||
if self.drehung == 270 or self.drehung == 90:
|
||||
return math.radians(self.drehung)
|
||||
else:
|
||||
return math.radians(self.drehung - 180)
|
||||
|
||||
@property
|
||||
def richtung_rad(self) -> float:
|
||||
"""Richtung in Radianten (für am_kreisel_direct_verbunden)."""
|
||||
# Wird aus drehung abgeleitet oder separat gesetzt
|
||||
return math.radians(self.drehung)
|
||||
|
||||
@property
|
||||
def pos1(self) -> tuple[float, float, float]:
|
||||
"""Position des ersten Blocks (x, y, z)."""
|
||||
dx = self.halbabstand * math.cos(self.winkel_rad)
|
||||
dy = self.halbabstand * math.sin(self.winkel_rad)
|
||||
return (self.x - dx, self.y - dy, self.hoehe)
|
||||
|
||||
@property
|
||||
def pos2(self) -> tuple[float, float, float]:
|
||||
"""Position des zweiten Blocks (x, y, z)."""
|
||||
dx = self.halbabstand * math.cos(self.winkel_rad)
|
||||
dy = self.halbabstand * math.sin(self.winkel_rad)
|
||||
return (self.x + dx, self.y + dy, self.hoehe)
|
||||
|
||||
@property
|
||||
def z(self) -> float:
|
||||
"""Z-Koordinate (gleich der Höhe)."""
|
||||
return self.hoehe
|
||||
|
||||
@classmethod
|
||||
def from_merkmale(cls, teileid: str, x: float, y: float, merkmale: dict) -> 'Kreisel':
|
||||
"""Erstellt ein Kreisel-Objekt aus einem merkmale-Dictionary."""
|
||||
hoehe_m = merkmale.get("Höhe in m", "0").replace(",", ".")
|
||||
try:
|
||||
hoehe = float(hoehe_m) * 1000
|
||||
except (ValueError, TypeError):
|
||||
hoehe = 0.0
|
||||
|
||||
abstand_m = merkmale.get("Abstand (Kreiselachse A - Kreiselachse) in Meter", "20").replace(",", ".")
|
||||
try:
|
||||
abstand = float(abstand_m) * 1000
|
||||
except (ValueError, TypeError):
|
||||
abstand = 10000.0
|
||||
|
||||
try:
|
||||
drehung = float(merkmale.get("Drehung", "0"))
|
||||
except (ValueError, TypeError):
|
||||
drehung = 0.0
|
||||
|
||||
try:
|
||||
anzahl_scanner = float(merkmale.get("Anzahl der Scanner", "0"))
|
||||
except (ValueError, TypeError):
|
||||
anzahl_scanner = 0.0
|
||||
|
||||
try:
|
||||
anzahl_separatoren = float(merkmale.get("Anzahl der Separatoren", "0"))
|
||||
except (ValueError, TypeError):
|
||||
anzahl_separatoren = 0.0
|
||||
|
||||
return cls(
|
||||
teileid=teileid,
|
||||
x=x,
|
||||
y=y,
|
||||
hoehe=hoehe,
|
||||
drehung=drehung,
|
||||
drehrichtung=merkmale.get("Drehrichtung"),
|
||||
abstand=abstand,
|
||||
kreiselart=merkmale.get("Kreiselart"),
|
||||
anzahl_scanner=anzahl_scanner,
|
||||
anzahl_separatoren=anzahl_separatoren
|
||||
)
|
||||
|
||||
def draw_kreisel_lines(msp, pos1, pos2, kreisel):
|
||||
"""Zeichnet tangentiale Linien zwischen zwei Kreiselblöcken, unabhängig vom Winkel."""
|
||||
rotation = kreisel.drehung
|
||||
x1, y1, z1 = pos1
|
||||
x2, y2, z1 = pos2
|
||||
# Verbindungsvektor
|
||||
dx = x2 - x1
|
||||
dy = y2 - y1
|
||||
# Länge
|
||||
length = math.hypot(dx, dy)
|
||||
if length == 0:
|
||||
return # keine Linie bei identischen Punkten
|
||||
# Normalenvektor (senkrecht, normiert, Länge = RADIUS)
|
||||
|
||||
nx = -dy / length * RADIUS
|
||||
ny = dx / length * RADIUS
|
||||
# Tangentialpunkte
|
||||
p1a = (x1 + nx, y1 + ny,z1)
|
||||
p1b = (x1 - nx, y1 - ny,z1)
|
||||
p2a = (x2 + nx, y2 + ny,z1)
|
||||
p2b = (x2 - nx, y2 - ny,z1)
|
||||
if kreisel.kreiselart == "Pin":
|
||||
if rotation == 0.0:
|
||||
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)
|
||||
elif rotation == 180.0:
|
||||
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)
|
||||
elif rotation == 90.0:
|
||||
p1a2 = p1a[0] + 50, p1a[1] - 50 + RADIUS , z1
|
||||
p1b2 = p1b[0] - 50, p1b[1] - 50 + RADIUS, z1
|
||||
p2a2 = p2a[0] + 50, p2a[1] + 50 - RADIUS, z1
|
||||
p2b2 = p2b[0] - 50, p2b[1] + 50 - RADIUS, 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)
|
||||
elif rotation == 270.0:
|
||||
p1a2 = p1a[0] - 50, p1a[1] + 50 - RADIUS , z1
|
||||
p1b2 = p1b[0] + 50, p1b[1] + 50 - RADIUS, z1
|
||||
p2a2 = p2a[0] - 50, p2a[1] - 50 + RADIUS, z1
|
||||
p2b2 = p2b[0] + 50, p2b[1] - 50 + RADIUS, 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, kreisel, lib_doc, doc, verbose):
|
||||
drehrichtung = (kreisel.drehrichtung or "").upper()
|
||||
if drehrichtung not in ("UZS", "GUZS"):
|
||||
return
|
||||
x1, y1,z1= pos1
|
||||
x2, y2,z2 = pos2
|
||||
dx = x2 - x1
|
||||
dy = y2 - y1
|
||||
length = math.hypot(dx, dy)
|
||||
if length == 0:
|
||||
return
|
||||
# Normalenvektor (senkrecht, normiert, Länge = RADIUS)
|
||||
nx = -dy / length * RADIUS
|
||||
ny = dx / length * RADIUS
|
||||
# Obere Linie
|
||||
p1_oben = (x1 + nx, y1 + ny)
|
||||
p2_oben = (x2 + nx, y2 + ny)
|
||||
# Untere Linie
|
||||
p1_unten = (x1 - nx, y1 - ny)
|
||||
p2_unten = (x2 - nx, y2 - ny)
|
||||
# S-LP auf oberer Linie (Drehrichtung wie angegeben)
|
||||
for i in range(1, 4):
|
||||
t = i / 4 # 1/4, 2/4, 3/4
|
||||
px = p1_oben[0] + t * (p2_oben[0] - p1_oben[0])
|
||||
py = p1_oben[1] + t * (p2_oben[1] - p1_oben[1])
|
||||
rotation = math.degrees(math.atan2(p2_oben[1] - p1_oben[1], p2_oben[0] - p1_oben[0]))
|
||||
if drehrichtung == "GUZS":
|
||||
rotation += 180
|
||||
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}': 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
|
||||
px = p1_unten[0] + t * (p2_unten[0] - p1_unten[0])
|
||||
py = p1_unten[1] + t * (p2_unten[1] - p1_unten[1])
|
||||
rotation = math.degrees(math.atan2(p2_unten[1] - p1_unten[1], p2_unten[0] - p1_unten[0]))
|
||||
if drehrichtung == "UZS":
|
||||
rotation += 180
|
||||
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}':Richtungspfeil unten bei ({px:.1f}, {py:.1f}), rot={rotation:.1f}")
|
||||
@@ -0,0 +1,457 @@
|
||||
from ezdxf.entities import Line
|
||||
import math
|
||||
from pydantic import BaseModel, Field, field_validator
|
||||
from typing import Optional
|
||||
import plant2dxf
|
||||
from ezdxf.math import Matrix44
|
||||
import re
|
||||
|
||||
class VarioFoerderer(BaseModel):
|
||||
teileid: str
|
||||
x: float = Field(description="X-Koordinate des Foerder-Zentrums")
|
||||
y: float = Field(description="Y-Koordinate des Foerder-Zentrums")
|
||||
laenge:float = Field(description = "Länge des Förderers")
|
||||
winkel: float = Field(description = "Winkel des Färderers")
|
||||
h0: float = Field(description="Höhe Anfang in Merkmale")
|
||||
h1: float = Field(description="Höhe Ende in Merkmale")
|
||||
hat_motor: bool = Field(description="Überprüft ob der Vörderer ein Motor hat")
|
||||
hat_umlenk: bool = Field(description="Überprüft ob der Vörderer eine Umlenkstation hat")
|
||||
drehung: float = Field(default=0.0, description="Drehung/Winkel in Grad")
|
||||
foerderer_richtung : str= Field(description="In welche richtung geförderd wird")
|
||||
gefaelle_laenge: Optional [float] = Field(default=0.0,description="Länge der zusätzlichen Gefälle Strecke falls vorhanden")
|
||||
gefaelle_winkel: Optional [float] = Field(default=0.0,description="Winkel der Gefällestrecke, falls diese Vorhanden ist")
|
||||
anzahl_scanner: int = Field(default=0, description="Anzahl der Scanner")
|
||||
anzahl_separatoren: int = Field(default=0, description="Anzahl der Separatoren")
|
||||
|
||||
@property
|
||||
def hight_zwischen(self):
|
||||
return ((self.h0 + self.h1) /2)
|
||||
|
||||
|
||||
@classmethod
|
||||
def from_merkmale(cls, teileid: str, x: float, y: float, merkmale: dict) -> 'VarioFoerderer':
|
||||
|
||||
h0 = float(merkmale.get("Höhe Anfang")) * 1000
|
||||
h1 = float(merkmale.get("Höhe Ende")) * 1000
|
||||
laenge = float(merkmale.get("Länge in Meter")) * 1000
|
||||
gefaelle_laenge = merkmale.get("Laenge_Gefaellestrecke")
|
||||
if gefaelle_laenge == None:
|
||||
gefaelle_laenge = 0.0
|
||||
gefaelle_winkel = 0.0
|
||||
else:
|
||||
gefaelle_laenge = float(gefaelle_laenge)
|
||||
gefaelle_winkel = float(merkmale.get("Winkel_Gefaellestrecke")),
|
||||
return cls(
|
||||
teileid = teileid,
|
||||
laenge = laenge,
|
||||
x = x,
|
||||
y = y,
|
||||
|
||||
foerderer_richtung =merkmale.get("Förderrichtung"),
|
||||
winkel = float(merkmale.get("Winkel")),
|
||||
hat_motor = bool(merkmale.get("hatMotor")),
|
||||
hat_umlenk = bool(merkmale.get("hatUmlenkung")),
|
||||
h0 = h0,
|
||||
h1 =h1,
|
||||
drehung = float(merkmale.get("Drehung")),
|
||||
gefaelle_laenge = gefaelle_laenge,
|
||||
gefalle_winkel = gefaelle_winkel,
|
||||
anzahl_scanner = int(merkmale.get("Anzahl der Scanner")),
|
||||
anzahl_separatoren = int(merkmale.get("Anzahl der Separatoren"))
|
||||
|
||||
)
|
||||
|
||||
def vario_erstellung(foerderer, doc, lib_doc, config, 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
|
||||
winkel_motor = float(config.get("Ils 2.0 core winkel","winkel_motor"))
|
||||
winkel_umlenk = float(config.get("Ils 2.0 core winkel","winkel_umlenk"))
|
||||
umlenk_laenge = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Umlenkstation")).split(","))
|
||||
motor_laenge = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Motorstation")).split(","))
|
||||
|
||||
vario_abstand = float(config.get("ILS 2.0 Variofoerderer","vario_abstand"))
|
||||
motor_vorhanden = foerderer.hat_motor
|
||||
umlenk_vorhanden = foerderer.hat_umlenk
|
||||
gefahellewinkel =foerderer.gefaelle_winkel
|
||||
gefaelle = foerderer.gefaelle_laenge
|
||||
x = foerderer.x
|
||||
y = foerderer.y
|
||||
hoehe_vario = foerderer.hight_zwischen
|
||||
winkel = int(foerderer.winkel)
|
||||
# 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)
|
||||
|
||||
motor_offset_x = umlenk_laenge[0]* math.cos(math.radians(winkel_motor))
|
||||
motor_offset_z = umlenk_laenge[0]* math.sin(math.radians(winkel_motor))
|
||||
umlenk_offset_x = motor_laenge[0]* math.cos(math.radians(winkel_umlenk))
|
||||
umlenk_offset_z = motor_laenge[0]* math.sin(math.radians(winkel_umlenk))
|
||||
# Berechnung des Gefälles
|
||||
if motor_vorhanden == True:
|
||||
gefaelle = gefaelle - motor_offset_x
|
||||
if umlenk_vorhanden == True:
|
||||
gefaelle = gefaelle - umlenk_offset_x
|
||||
|
||||
#Erstellung des Förderes falls er auf ist oder Horizontal da diese gleich aufgebaut werden
|
||||
if voerder_richtung== "Auf" or voerder_richtung== "Horizontal":
|
||||
# erstellung des gefälles falls es nicht null ist (also keins angegeben ist oder es durch andere Sachen wie Motor ersetzt wird)
|
||||
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:
|
||||
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})
|
||||
line_ende_gefaelle.dxf.layer = "6-SP"
|
||||
copy_ende = line_ende_gefaelle.copy()
|
||||
copy_ende.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy_ende)
|
||||
ende = gefaelle_ende
|
||||
|
||||
gefaelle_start = start[0], start[1] -halbesgefaelle, start[2] +math.sin(math.radians(gefahellewinkel)) * halbesgefaelle
|
||||
line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start})
|
||||
line_start_gefaelle.dxf.layer = "6-SP"
|
||||
copy_start = line_start_gefaelle.copy()
|
||||
copy_start.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy_start)
|
||||
start = gefaelle_start
|
||||
|
||||
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"
|
||||
copy_start = line_start_gefaelle.copy()
|
||||
copy_start.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy_start)
|
||||
start = gefaelle_start
|
||||
|
||||
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"
|
||||
copy_ende = line_ende_gefaelle.copy()
|
||||
copy_ende.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy_ende)
|
||||
ende = gefaelle_ende
|
||||
|
||||
# Den Motorstaton und Umlenkstation auf die richtige position in block einfügen falls nötig
|
||||
block_Vario_Umlenkstation_500mm ="Vario_Umlenkstation_500mm"
|
||||
block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm"
|
||||
plant2dxf.import_block(block_Vario_Motorstation_500mm, lib_doc, doc)
|
||||
plant2dxf.import_block(block_Vario_Umlenkstation_500mm , lib_doc, doc)
|
||||
block_Vario_Motorstation_500mm = plant2dxf.dreh_block(block_Vario_Motorstation_500mm,doc,math.radians(winkel_motor))
|
||||
block_Vario_Umlenkstation_500mm = plant2dxf.dreh_block( block_Vario_Umlenkstation_500mm, doc,math.radians(winkel_umlenk))
|
||||
if umlenk_vorhanden == True:
|
||||
block.add_blockref(block_Vario_Umlenkstation_500mm,(ende[0] -x,ende[1] -y + umlenk_offset_x/2,ende[2] - hoehe_vario -umlenk_offset_z/2 ),dxfattribs={"rotation": 90})
|
||||
ende = (ende[0] ,ende[1] + umlenk_offset_x,ende[2] - umlenk_offset_z)
|
||||
if motor_vorhanden == True:
|
||||
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})
|
||||
start = start[0] , start[1] - motor_offset_x,start[2] + motor_offset_z
|
||||
|
||||
if voerder_richtung== "Auf":
|
||||
# Einfügen der 51 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}°")
|
||||
block_Vario_Bogen_ab = (f"Vario_Bogen_ab_{winkel_plus}°")
|
||||
|
||||
auf_attrib =plant2dxf.import_block(block_Vario_Bogen_auf, lib_doc, doc)
|
||||
ab_attrib =plant2dxf.import_block(block_Vario_Bogen_ab, lib_doc, doc)
|
||||
block_Vario_Bogen_auf = plant2dxf.dreh_block(block_Vario_Bogen_auf, doc,math.radians(winkel_core))
|
||||
block_Vario_Bogen_ab = plant2dxf.dreh_block(block_Vario_Bogen_ab, doc,math.radians(-winkel))
|
||||
|
||||
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"]))
|
||||
|
||||
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)) ]
|
||||
Vario_Bogen_ab_Delta_SP_1 =[ Vario_Bogen_ab_Delta_SP_1 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_1[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_SP_1[1],-Vario_Bogen_ab_Delta_SP_1[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_1[2] * math.cos(math.radians(-winkel)) ]
|
||||
Vario_Bogen_auf_Delta_VP_1 = [Vario_Bogen_auf_Delta_VP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_VP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_VP_1[1],-Vario_Bogen_auf_Delta_VP_1[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_VP_1[2] * math.cos(math.radians(winkel_core)) ]
|
||||
Vario_Bogen_ab_Delta_VP_0 = [Vario_Bogen_ab_Delta_VP_0 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_VP_0[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_VP_0[1],-Vario_Bogen_ab_Delta_VP_0[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_VP_0[2] * math.cos(math.radians(-winkel)) ]
|
||||
|
||||
# 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_Delta_SP_0):
|
||||
if i< 2 and wert < 0:
|
||||
Vario_Bogen_auf_Delta_SP_0[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_auf_Delta_SP_1[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_0):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_Delta_SP_0[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_Delta_SP_1[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_auf_Delta_VP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_auf_Delta_VP_1[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_ab_Delta_VP_0):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_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,(ende[0] -x ,ende[1] +Vario_Bogen_auf_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90})
|
||||
ende_VP = (ende[0] +Vario_Bogen_auf_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_Delta_VP_1[0]+Vario_Bogen_auf_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_Delta_VP_1[2]- Vario_Bogen_auf_Delta_SP_0[2])
|
||||
ende = (ende[0] ,ende[1] +Vario_Bogen_auf_Delta_SP_1[0] + Vario_Bogen_auf_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_Delta_SP_1[2] - Vario_Bogen_auf_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 ,(start[0]-x,start[1] - Vario_Bogen_ab_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_Delta_SP_1[2]),dxfattribs={"rotation": 90})
|
||||
|
||||
start_VP = start[0] +Vario_Bogen_ab_Delta_VP_0[1],start[1]-Vario_Bogen_ab_Delta_VP_0[0] - Vario_Bogen_ab_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_Delta_VP_0[2] - Vario_Bogen_ab_Delta_SP_1[2]
|
||||
start = start[0] ,start[1] - Vario_Bogen_ab_Delta_SP_0[0] - Vario_Bogen_ab_Delta_SP_1[0],start[2] - Vario_Bogen_ab_Delta_SP_1[2]+ Vario_Bogen_ab_Delta_SP_0[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)
|
||||
|
||||
else:
|
||||
# Einfügen der 3 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
|
||||
|
||||
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 =plant2dxf.import_block(block_Vario_Bogen_auf_3, lib_doc, doc)
|
||||
ab_3_attrib = plant2dxf.import_block(block_Vario_Bogen_ab_3, lib_doc, doc)
|
||||
block_Vario_Bogen_auf_3= plant2dxf.dreh_block(block_Vario_Bogen_auf_3, doc,math.radians(3))
|
||||
block_Vario_Bogen_ab_3 = plant2dxf.dreh_block(block_Vario_Bogen_ab_3, doc,math.radians(0))
|
||||
Vario_Bogen_auf_3_Delta_SP_0 = list(float(att)for att in re.split(r"[;,]", auf_3_attrib["DELTA_SP_0"]))
|
||||
Vario_Bogen_auf_3_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", auf_3_attrib["DELTA_SP_1"]))
|
||||
Vario_Bogen_ab_3_Delta_SP_0 = list(float(att) for att in re.split(r"[;,]", ab_3_attrib["DELTA_SP_0"]))
|
||||
Vario_Bogen_ab_3_Delta_SP_1 = list(float(att) for att in re.split(r"[;,]", ab_3_attrib["DELTA_SP_1"]))
|
||||
Vario_Bogen_auf_3_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_3_attrib["DELTA_VP_1"]))
|
||||
Vario_Bogen_ab_3_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_3_attrib["DELTA_VP_0"]))
|
||||
|
||||
Vario_Bogen_auf_3_Delta_SP_0 = [Vario_Bogen_auf_3_Delta_SP_0 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_0[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_3_Delta_SP_0[1],-Vario_Bogen_auf_3_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_0[2] * math.cos(math.radians(3)) ]
|
||||
Vario_Bogen_auf_3_Delta_SP_1 = [Vario_Bogen_auf_3_Delta_SP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_3_Delta_SP_1[1],-Vario_Bogen_auf_3_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_3_Delta_SP_1[2] * math.cos(math.radians(3)) ]
|
||||
Vario_Bogen_ab_3_Delta_SP_0 = [Vario_Bogen_ab_3_Delta_SP_0 [0] ,Vario_Bogen_ab_3_Delta_SP_0[1],Vario_Bogen_ab_3_Delta_SP_0[2] ]
|
||||
Vario_Bogen_ab_3_Delta_SP_1 =[ Vario_Bogen_ab_3_Delta_SP_1 [0] ,Vario_Bogen_ab_3_Delta_SP_1[1],Vario_Bogen_ab_3_Delta_SP_1[2] ]
|
||||
Vario_Bogen_auf_3_Delta_VP_1 = [Vario_Bogen_auf_3_Delta_VP_1 [0] * math.cos(math.radians(3))+ Vario_Bogen_auf_3_Delta_VP_1[2]* math.sin(math.radians(3)) ,Vario_Bogen_auf_3_Delta_VP_1[1],-Vario_Bogen_auf_3_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_auf_3_Delta_VP_1[2] * math.cos(math.radians(3)) ]
|
||||
Vario_Bogen_ab_3_Delta_VP_0 = [Vario_Bogen_ab_3_Delta_VP_0 [0],Vario_Bogen_ab_3_Delta_VP_0[1],Vario_Bogen_ab_3_Delta_VP_0[2] ]
|
||||
|
||||
# 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_3_Delta_SP_0):
|
||||
if i< 2 and wert < 0:
|
||||
Vario_Bogen_auf_3_Delta_SP_0[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_auf_3_Delta_SP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_auf_3_Delta_SP_1[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_ab_3_Delta_SP_0):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_3_Delta_SP_0[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_ab_3_Delta_SP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_3_Delta_SP_1[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_auf_3_Delta_VP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_auf_3_Delta_VP_1[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_ab_3_Delta_VP_0):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_3_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
|
||||
if motor_vorhanden == True:
|
||||
block.add_blockref(block_Vario_Bogen_auf_3,(ende[0] -x ,ende[1] +Vario_Bogen_auf_3_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_3_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90})
|
||||
ende_VP = (ende[0] +Vario_Bogen_auf_3_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_3_Delta_VP_1[0]+Vario_Bogen_auf_3_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_3_Delta_VP_1[2]- Vario_Bogen_auf_3_Delta_SP_0[2])
|
||||
ende = (ende[0] ,ende[1] +Vario_Bogen_auf_3_Delta_SP_1[0] + Vario_Bogen_auf_3_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_3_Delta_SP_1[2] - Vario_Bogen_auf_3_Delta_SP_0[2])
|
||||
else:
|
||||
ende_VP = ende[0] +Vario_Bogen_auf_3_Delta_VP_1[1] ,ende[1] , ende[2]
|
||||
|
||||
#einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
|
||||
if umlenk_vorhanden == True:
|
||||
block.add_blockref(block_Vario_Bogen_ab_3 ,(start[0]-x,start[1] - Vario_Bogen_ab_3_Delta_SP_1[0] -y ,start[2] - hoehe_vario - Vario_Bogen_ab_3_Delta_SP_1[2]),dxfattribs={"rotation": 90})
|
||||
start_VP = start[0] +Vario_Bogen_ab_3_Delta_VP_0[1],start[1]-Vario_Bogen_ab_3_Delta_VP_0[0] - Vario_Bogen_ab_3_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_3_Delta_VP_0[2] - Vario_Bogen_ab_3_Delta_SP_1[2]
|
||||
start = start[0] ,start[1] - Vario_Bogen_ab_3_Delta_SP_0[0] - Vario_Bogen_ab_3_Delta_SP_1[0],start[2] +Vario_Bogen_ab_3_Delta_SP_0[2] - Vario_Bogen_ab_3_Delta_SP_1[2]
|
||||
else:
|
||||
start_VP = start[0] +Vario_Bogen_ab_3_Delta_VP_0[1],start[1] , start[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)
|
||||
|
||||
elif voerder_richtung == "Ab":
|
||||
# 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:
|
||||
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})
|
||||
line_ende_gefaelle.dxf.layer = "6-SP"
|
||||
copy_ende = line_ende_gefaelle.copy()
|
||||
copy_ende.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy_ende)
|
||||
ende = gefaelle_ende
|
||||
|
||||
gefaelle_start = start[0], start[1] -halbesgefaelle, start[2] -math.sin(math.radians(gefahellewinkel)) * halbesgefaelle
|
||||
line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start})
|
||||
line_start_gefaelle.dxf.layer = "6-SP"
|
||||
copy_start = line_start_gefaelle.copy()
|
||||
copy_start.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy_start)
|
||||
start = gefaelle_start
|
||||
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"
|
||||
copy_ende = line_ende_gefaelle.copy()
|
||||
copy_ende.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy_ende)
|
||||
ende = gefaelle_ende
|
||||
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"
|
||||
copy_start = line_start_gefaelle.copy()
|
||||
copy_start.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy_start)
|
||||
start = gefaelle_start
|
||||
|
||||
# Importieren und setzen der UMlenkungstation oder Motorstation falls nötig
|
||||
block_Vario_Umlenkstation_500mm ="Vario_Umlenkstation_500mm"
|
||||
block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm"
|
||||
plant2dxf.import_block( block_Vario_Motorstation_500mm, lib_doc, doc)
|
||||
plant2dxf.import_block( block_Vario_Umlenkstation_500mm , lib_doc, doc)
|
||||
block_Vario_Motorstation_500mm = plant2dxf.dreh_block( block_Vario_Motorstation_500mm, doc,math.radians(winkel_motor))
|
||||
block_Vario_Umlenkstation_500mm = plant2dxf.dreh_block( block_Vario_Umlenkstation_500mm , doc,math.radians(winkel_umlenk))
|
||||
if umlenk_vorhanden == True:
|
||||
block.add_blockref(block_Vario_Umlenkstation_500mm,(start[0] -x,start[1] -y - umlenk_offset_x/2, start[2] - hoehe_vario -umlenk_offset_z/2 ),dxfattribs={"rotation": 270})
|
||||
start_Umlenkstation_VP = start[0] - vario_abstand, start[1] -500 *math.cos(math.radians(-winkel_umlenk))+ math.sin(math.radians(-winkel_umlenk))* -45,start[2] + math.sin(math.radians(-winkel_umlenk))*500+ math.cos(math.radians(-winkel_umlenk))*-45
|
||||
start = (start[0] ,start[1] - umlenk_offset_x,start[2] -umlenk_offset_z)
|
||||
elif winkel == 3:
|
||||
start_Umlenkstation_VP = start[0] - vario_abstand, start[1]+ winkel_VP_offset_vorne[0],start[2] -winkel_VP_offset_hinten[2]
|
||||
if motor_vorhanden == True:
|
||||
block.add_blockref(block_Vario_Motorstation_500mm, (ende[0]-x , ende[1] + motor_offset_x/2 -y ,ende[2] - hoehe_vario + motor_offset_z/2),dxfattribs={"rotation": 270})
|
||||
ende_Motor_VP = ende[0] - vario_abstand, ende[1] +500 *math.cos(math.radians(-winkel_motor))+ math.sin(math.radians(-winkel_motor))* -45,ende[2] - math.sin(math.radians(-winkel_motor))*500+ math.cos(math.radians(-winkel_motor))*-45
|
||||
|
||||
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_hinten[0] ,ende[2] - winkel_VP_offset_vorne[2]
|
||||
|
||||
if winkel != 3:
|
||||
winkel_core = int(config.get("Ils 2.0 core winkel","winkel_boegen"))
|
||||
winkel_minus = winkel - winkel_core
|
||||
block_Vario_Bogen_auf = (f"Vario_Bogen_auf_{winkel_minus}°")
|
||||
block_Vario_Bogen_ab = (f"Vario_Bogen_ab_{winkel_minus}°")
|
||||
ab_attrib =plant2dxf.import_block( block_Vario_Bogen_ab , lib_doc, doc)
|
||||
auf_attrib =plant2dxf.import_block( block_Vario_Bogen_auf, lib_doc, doc)
|
||||
block_Vario_Bogen_ab = plant2dxf.dreh_block( block_Vario_Bogen_ab, doc, math.radians(winkel_core))
|
||||
block_Vario_Bogen_auf= plant2dxf.dreh_block( block_Vario_Bogen_auf, doc, math.radians(winkel))
|
||||
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_0 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_VP_0"]))
|
||||
Vario_Bogen_ab_Delta_VP_1= list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_VP_1"]))
|
||||
|
||||
Vario_Bogen_auf_Delta_SP_0 = [Vario_Bogen_auf_Delta_SP_0 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_0[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_SP_0[1],-Vario_Bogen_auf_Delta_SP_0[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_0[2] * math.cos(math.radians(winkel)) ]
|
||||
Vario_Bogen_auf_Delta_SP_1 = [Vario_Bogen_auf_Delta_SP_1 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_1[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_SP_1[1],-Vario_Bogen_auf_Delta_SP_1[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_1[2] * math.cos(math.radians(winkel)) ]
|
||||
Vario_Bogen_ab_Delta_SP_0 = [Vario_Bogen_ab_Delta_SP_0 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_SP_0[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_SP_0[1],-Vario_Bogen_ab_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_SP_0[2] * math.cos(math.radians(winkel_core)) ]
|
||||
Vario_Bogen_ab_Delta_SP_1 =[ Vario_Bogen_ab_Delta_SP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_SP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_SP_1[1],-Vario_Bogen_ab_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_SP_1[2] * math.cos(math.radians(winkel_core)) ]
|
||||
Vario_Bogen_auf_Delta_VP_0 = [Vario_Bogen_auf_Delta_VP_0 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_VP_0[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_VP_0[1],-Vario_Bogen_auf_Delta_VP_0[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_VP_0[2] * math.cos(math.radians(winkel)) ]
|
||||
Vario_Bogen_ab_Delta_VP_1 = [Vario_Bogen_ab_Delta_VP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_VP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_VP_1[1],-Vario_Bogen_ab_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_VP_1[2] * math.cos(math.radians(winkel_core)) ]
|
||||
|
||||
# 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_Delta_SP_0):
|
||||
if i< 2 and wert < 0:
|
||||
Vario_Bogen_auf_Delta_SP_0[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_auf_Delta_SP_1[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_0):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_Delta_SP_0[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_Delta_SP_1[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_auf_Delta_VP_0):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_auf_Delta_VP_0[i] = abs(wert)
|
||||
for i, wert in enumerate(Vario_Bogen_ab_Delta_VP_1):
|
||||
if i< 2 and wert< 0:
|
||||
Vario_Bogen_ab_Delta_VP_1[i] = abs(wert)
|
||||
|
||||
#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, (start[0]-x,start[1]-y- Vario_Bogen_ab_Delta_SP_0[0], start[2]- hoehe_vario- Vario_Bogen_ab_Delta_SP_0[2]),dxfattribs={"rotation": 270})
|
||||
start_VP = start[0] -Vario_Bogen_ab_Delta_VP_1[1],start[1]- Vario_Bogen_ab_Delta_VP_1[0]- Vario_Bogen_ab_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_Delta_VP_1[2]-Vario_Bogen_ab_Delta_SP_0[2]
|
||||
|
||||
start =(start[0], start[1]- Vario_Bogen_ab_Delta_SP_0[0]- Vario_Bogen_ab_Delta_SP_1[0],start[2]-Vario_Bogen_ab_Delta_SP_0[2]+Vario_Bogen_ab_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_Bogen_auf, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_Delta_SP_1[2]),dxfattribs={"rotation": 270})
|
||||
ende_VP = (ende[0] -Vario_Bogen_auf_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_Delta_VP_0[0]+ Vario_Bogen_auf_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_Delta_VP_0[2]- Vario_Bogen_auf_Delta_SP_1[2])
|
||||
ende = (ende[0],ende[1]+ Vario_Bogen_auf_Delta_SP_1[0]+ Vario_Bogen_auf_Delta_SP_0[0],ende[2]- Vario_Bogen_auf_Delta_SP_1[2]+ Vario_Bogen_auf_Delta_SP_0[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)
|
||||
|
||||
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})
|
||||
line_VP.dxf.layer = "VARIO"
|
||||
copy_VP = line_VP.copy()
|
||||
copy_VP.translate(-x,-y,-hoehe_vario)
|
||||
block.add_entity(copy_VP)
|
||||
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)
|
||||
|
||||
# Erstellung einer Spiegelung an der y achse (hier wird es ausgeführt durch -x) für die erstellung des Förderers mit den vario stationen links
|
||||
matrix = Matrix44.scale(-1,1,1)
|
||||
block_links = doc.blocks.new(block_name_links, base_point=(0,0,0))
|
||||
#spiegelung aller elemente außer es und as elemente falls diese vorhanden sind um die logik wie die platziert werden nicht zu zerstören
|
||||
for entity in block:
|
||||
clone= entity.copy()
|
||||
if entity.dxftype() == "INSERT":
|
||||
if (entity.dxf.name.startswith("400102632_ES-Element_90_links") or entity.dxf.name.startswith("200000146_ES-Element_90_rechts") or
|
||||
entity.dxf.name.startswith("200000241_AS-Element_90_rechts") or entity.dxf.name.startswith("200000217_AS-Element_90_links")
|
||||
):
|
||||
block_links.add_entity(clone)
|
||||
else:
|
||||
clone.transform(matrix)
|
||||
block_links.add_entity(clone)
|
||||
else:
|
||||
clone.transform(matrix)
|
||||
block_links.add_entity(clone)
|
||||
Reference in New Issue
Block a user