Add CLAUDE.md for Claude Code guidance

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,4 @@
+Sessions
+CAD/Code/input
+CAD/Code/work
+

CAD/Code/bin/create_assemblies.bat

@@ -0,0 +1,18 @@
+@echo off
+setlocal
+SET "MANAGE=%~dp0manage_interpreter.bat"
+
+CALL "%MANAGE%" activate
+if errorlevel 1 (
+    echo ERROR: Failed to activate Python environment
+    exit /b 1
+)
+
+pushd "%PROJECT%"
+
+"%VIRTUAL_ENV%\Scripts\python.exe" -m lib.create_assemblies %*
+set PYTHON_EXIT=%ERRORLEVEL%
+
+popd
+CALL "%MANAGE%" deactivate
+exit /b %PYTHON_EXIT%

CAD/Code/bin/diff_dimensions.bat

@@ -0,0 +1,18 @@
+@echo off
+setlocal
+SET "MANAGE=%~dp0manage_interpreter.bat"
+
+CALL "%MANAGE%" activate
+if errorlevel 1 (
+    echo ERROR: Failed to activate Python environment
+    exit /b 1
+)
+
+pushd "%PROJECT%"
+
+"%VIRTUAL_ENV%\Scripts\python.exe" -m lib.diff_dimensions %*
+set PYTHON_EXIT=%ERRORLEVEL%
+
+popd
+CALL "%MANAGE%" deactivate
+exit /b %PYTHON_EXIT%

CAD/Code/bin/get_all_differences.bat

@@ -0,0 +1,26 @@
+@echo off
+REM ~dp0 steht für das Verzeichnis, in der diese Datei liegt
+
+REM Standardwerte setzen
+set "DEFAULT_TYPE=WEICHE"
+set "DEFAULT_JSON2D=omniflo_weichen.json"
+set "DEFAULT_JSONDIM=dimensions.json"
+set "DEFAULT_TOLERANCE=0.05"
+
+echo Mögliche Werte für --type: BOGEN, WEICHE, TEFBOGEN, TEFWEICHE
+
+REM Benutzereingaben mit Standardwerten
+set /p TYPE=Gib den Typ ein (Standard: %DEFAULT_TYPE%): 
+if "%TYPE%"=="" set "TYPE=%DEFAULT_TYPE%"
+
+set /p JSON2D=Gib den Namen der 2D-JSON-Datei ein (Standard: %DEFAULT_JSON2D%): 
+if "%JSON2D%"=="" set "JSON2D=%DEFAULT_JSON2D%"
+
+set /p JSONDIM=Gib den Namen der Dimensions-JSON-Datei ein (Standard: %DEFAULT_JSONDIM%): 
+if "%JSONDIM%"=="" set "JSONDIM=%DEFAULT_JSONDIM%"
+
+set /p TOLERANCE=Gib die Toleranz ein (Standard: %DEFAULT_TOLERANCE%): 
+if "%TOLERANCE%"=="" set "TOLERANCE=%DEFAULT_TOLERANCE%"
+
+REM Aufruf des Skripts mit den eingegebenen oder Standardwerten
+call "%~dp0diff_dimensions.bat" --type %TYPE% --json_2d %JSON2D% --json_dimensions %JSONDIM% --tolerance %TOLERANCE%

CAD/Code/bin/get_cmd.bat

@@ -0,0 +1,4 @@
+@echo off
+call "%~dp0setenv.bat"
+start
+

CAD/Code/bin/get_dimensions.bat

@@ -0,0 +1,18 @@
+@echo off
+setlocal
+SET "MANAGE=%~dp0manage_interpreter.bat"
+
+CALL "%MANAGE%" activate
+if errorlevel 1 (
+    echo ERROR: Failed to activate Python environment
+    exit /b 1
+)
+
+pushd "%PROJECT%"
+
+"%VIRTUAL_ENV%\Scripts\python.exe" -m lib.read_variables %*
+set PYTHON_EXIT=%ERRORLEVEL%
+
+popd
+CALL "%MANAGE%" deactivate
+exit /b %PYTHON_EXIT%

CAD/Code/bin/install_py.bat

@@ -0,0 +1,15 @@
+call setenv.bat
+if not exist %PROJECT%\.venv (
+   ECHO Initialisiere Python virtual environment...
+   py -m venv %PROJECT%\.venv --upgrade-deps
+   ECHO Erfolgreich.
+
+   call %PROJECT%\.venv\Scripts\activate.bat
+   ECHO Installiere erforderliche Python Packages...
+   pip install -r %PROJECT_LIB%/requirements.txt -q
+   ECHO Erfolgreich
+   deactivate
+
+    ) ELSE (
+        ECHO Erforderliche Python Packages bereits installiert!
+    )

CAD/Code/bin/manage_interpreter.bat

@@ -0,0 +1,35 @@
+@echo off
+CALL "%~dp0setenv.bat"
+
+IF /I "%1"=="activate" GOTO activate
+IF /I "%1"=="deactivate" GOTO deactivate
+IF /I "%1"=="activate_interpreter" GOTO activate
+IF /I "%1"=="deactivate_interpreter" GOTO deactivate
+GOTO :eof
+
+
+:activate
+REM Interpreter wählen
+IF DEFINED NETWORK_PYTHON (
+    SET PYTHON_EXE=%NETWORK_PYTHON%\python.exe
+) ELSE (
+    SET PYTHON_EXE=python
+)
+
+REM venv sicherstellen
+IF NOT EXIST "%PROJECT%\.venv" (
+    "%PYTHON_EXE%" -m venv "%PROJECT%\.venv"
+)
+
+REM venv aktivieren
+CALL "%PROJECT%\.venv\Scripts\activate.bat"
+
+REM Interpreter festnageln
+SET VIRTUAL_ENV_PYTHON=%PYTHON_EXE%
+GOTO :eof
+
+
+:deactivate
+CALL "%PROJECT%\.venv\Scripts\deactivate.bat"
+SET VIRTUAL_ENV_PYTHON=
+GOTO :eof

CAD/Code/bin/save_stl.bat

@@ -0,0 +1,18 @@
+@echo off
+setlocal
+SET "MANAGE=%~dp0manage_interpreter.bat"
+
+CALL "%MANAGE%" activate
+if errorlevel 1 (
+    echo ERROR: Failed to activate Python environment
+    exit /b 1
+)
+
+pushd "%PROJECT%"
+
+"%VIRTUAL_ENV%\Scripts\python.exe" -m lib.save_stl %*
+set PYTHON_EXIT=%ERRORLEVEL%
+
+popd
+CALL "%MANAGE%" deactivate
+exit /b %PYTHON_EXIT%

CAD/Code/bin/setenv.bat

@@ -0,0 +1,23 @@
+@echo off
+REM ~dp0 steht für das Verzeichnis, in der diese Datei liegt
+pushd %~dp0\..
+
+set PROJECT=%cd%
+
+set PROJECT_BIN=%PROJECT%\bin
+set PROJECT_LIB=%PROJECT%\lib
+set PROJECT_WORK=%PROJECT%\work
+set PROJECT_DATA=%PROJECT%\data
+set PROJECT_INPUT=%PROJECT%\input
+set PROJECT_TEMPLATE=\\ssg.local\freigaben\RuleDesigner\Templates\CreateAssemblies
+
+if not exist %PROJECT_WORK% mkdir %PROJECT_WORK%
+if not exist %PROJECT_INPUT% mkdir %PROJECT_INPUT%
+
+set PROJECT_JSON_BOGEN=%SSG_RD_DIR%\SVGs\Omniflo\python\OFBogen\json
+set PROJECT_JSON_WEICHE=%SSG_RD_DIR%\SVGs\Omniflo\python\OFWeiche\json
+set PROJECT_JSON_TEFBOGEN=%SSG_RD_DIR%\SVGs\Omniflo\python\TEFBogen\json
+set PROJECT_JSON_TEFWEICHE=%SSG_RD_DIR%\SVGs\Omniflo\python\TEFWeiche\json
+
+popd
+goto :eof

CAD/Code/doku/README.md

@@ -0,0 +1,251 @@
+# Dokumentation: CAD-Automatisierungsskripte
+
+## Übersicht
+
+| Skript | Batch-Datei | Zweck |
+| ------ | ----------- | ----- |
+| `lib/create_assemblies.py` | `bin/create_assemblies.bat` | Erzeugt .asm-Baugruppen aus .par-Dateien |
+| `lib/save_stl.py` | `bin/save_stl.bat` | Exportiert .asm-Baugruppen als STL-Dateien |
+| `lib/read_variables.py` | `bin/get_dimensions.bat` | Liest Maße aus .par-Dateien und speichert als JSON |
+| `lib/diff_dimensions.py` | `bin/diff_dimensions.bat` | Vergleicht 3D-Maße (JSON) mit 2D-Zeichnungsmaßen |
+| *(kein Python)* | `bin/get_all_differences.bat` | Interaktiver Wrapper für diff_dimensions |
+| *(kein Python)* | `bin/get_cmd.bat` | Öffnet Kommandozeile mit gesetzten Umgebungsvariablen |
+| *(kein Python)* | `bin/setenv.bat` | Setzt alle Umgebungsvariablen für das Projekt |
+
+---
+
+## 1. create_assemblies
+
+### Zweck
+
+Das Skript erstellt für jede .par-Datei im Eingabeordner eine neue .asm-Baugruppe, indem es eine Platzhalter-Baugruppe (dummy.asm) kopiert und darin die Platzhalter-Komponente (dummy.par) durch die jeweilige .par-Datei ersetzt.
+
+### Aufrufmöglichkeiten
+
+**Über die Batch-Datei (empfohlen unter Windows):**
+
+```bat
+bin\create_assemblies.bat --in <Eingabeordner> --out <Ausgabeordner>
+```
+
+Die Batch-Datei setzt Umgebungsvariablen und ruft das Python-Skript mit den übergebenen Parametern auf.
+
+**Direkt über die Kommandozeile:**
+
+```sh
+python lib/create_assemblies.py --in <Eingabeordner> --out <Ausgabeordner>
+```
+
+**Parameter:**
+
+- `--in`: Pfad zum Ordner mit .par-Dateien (optional, Standard: Umgebungsvariable PROJECT_INPUT oder ./input)
+- `--out`: Zielordner für die erzeugten .asm-Dateien (optional, Standard: ./work)
+
+### Input/Output
+
+- **Input:**
+  - .par-Dateien im angegebenen Eingabeordner
+  - dummy.asm und dummy.par im Netzwerkpfad PROJECT_TEMPLATE (werden als Vorlage und Platzhalter verwendet)
+- **Output:**
+  - Für jede .par-Datei wird eine .asm-Datei im Ausgabeverzeichnis erzeugt.
+  - Temporäre Dateien (_temp.asm, .cfg) werden nach Verarbeitung gelöscht.
+
+### Hinweise
+
+- Solid Edge muss installiert sein, da das Skript über COM darauf zugreift.
+- Die Platzhalter-Komponente in dummy.asm muss exakt dummy.par heißen.
+- Die Vorlage (dummy.asm) wird aus dem Netzwerkpfad `PROJECT_TEMPLATE` geladen (Standard: `\\ssg.local\freigaben\RuleDesigner\Templates\CreateAssemblies`).
+- Fehlerhafte oder fehlende Platzhalter werden übersprungen und führen nicht zum Abbruch des gesamten Prozesses.
+
+---
+
+## 2. save_stl
+
+### Zweck
+
+Das Skript exportiert alle .asm-Baugruppen in einem Ordner als STL-Dateien. Es dient dazu, die zuvor erzeugten Baugruppen für die Weiterverarbeitung (z.B. 3D-Druck oder Visualisierung) bereitzustellen.
+
+### Aufrufmöglichkeiten
+
+**Über die Batch-Datei (empfohlen unter Windows):**
+
+```bat
+bin\save_stl.bat --in <Eingabeordner> --out <Ausgabeordner>
+```
+
+Die Batch-Datei setzt Umgebungsvariablen und ruft das Python-Skript mit den übergebenen Parametern auf.
+
+**Direkt über die Kommandozeile:**
+
+```sh
+python lib/save_stl.py --in <Eingabeordner> --out <Ausgabeordner>
+```
+
+**Parameter:**
+
+- `--in`: Pfad zum Ordner mit .asm-Dateien (optional, Standard: Umgebungsvariable PROJECT_WORK oder ./work)
+- `--out`: Zielordner für die STL-Dateien (optional, Standard: ./work/STL_Export)
+
+### Input/Output
+
+- **Input:**
+  - .asm-Dateien im angegebenen Eingabeordner (z.B. aus create_assemblies)
+- **Output:**
+  - Für jede .asm-Datei wird eine .stl-Datei im Ausgabeverzeichnis erzeugt.
+  - Temporäre .cfg- und .log-Dateien werden nach dem Export gelöscht.
+
+### Hinweise
+
+- Solid Edge muss installiert sein, da das Skript über COM darauf zugreift.
+- Das Skript ist robust gegenüber Fehlern beim Export einzelner Dateien (Fehler werden gemeldet, der Prozess läuft weiter).
+- Nach dem Export werden überflüssige .cfg- und .log-Dateien im Eingabe- und Ausgabeverzeichnis entfernt.
+
+---
+
+## 3. read_variables
+
+### Zweck
+
+Das Skript liest aus allen .par-Dateien in einem Verzeichnis die benutzerdefinierten Variablen `Mittiges_Koordinatensystem_X_Translation` und `Mittiges_Koordinatensystem_Y_Translation` aus und speichert die Werte als Breite und Höhe in einer JSON-Datei.
+
+### Aufrufmöglichkeiten
+
+**Über die Batch-Datei (empfohlen unter Windows):**
+
+```bat
+bin\get_dimensions.bat --in <Eingabeordner> --out <Ausgabeordner>
+```
+
+**Direkt über die Kommandozeile:**
+
+```sh
+python lib/read_variables.py --in <Eingabeordner> --out <Ausgabeordner>
+```
+
+**Parameter:**
+
+- `--in`: Pfad zum Ordner mit .par-Dateien (optional, Standard: Umgebungsvariable PROJECT_INPUT oder ./input)
+- `--out`: Zielordner für die JSON-Ausgabe (optional, Standard: Umgebungsvariable PROJECT_WORK oder ./work)
+
+### Input/Output
+
+- **Input:**
+  - .par-Dateien im angegebenen Eingabeordner
+- **Output:**
+  - Eine JSON-Datei im Ausgabeverzeichnis, benannt nach dem Eingabeordner (z.B. input.json), mit folgendem Aufbau:
+
+    ```json
+    {
+      "Dateiname_ohne_Endung": {
+        "breite": <Wert>,
+        "hoehe": <Wert>
+      }
+    }
+    ```
+
+### Hinweise
+
+- Solid Edge muss installiert sein, da das Skript über COM darauf zugreift.
+- Die Variablen werden mit 2000 multipliziert und auf drei Nachkommastellen gerundet.
+- Falls eine .par-Datei die benötigten Variablen nicht enthält, wird sie übersprungen.
+- Fehlerhafte Dateien führen nicht zum Abbruch des gesamten Prozesses.
+
+---
+
+## 4. diff_dimensions
+
+### Zweck
+
+Das Skript vergleicht 3D-Bauteilmaße (aus einer JSON-Datei erzeugt von `read_variables`) mit 2D-Zeichnungsmaßen (aus einer JSON-Datei des SVG-Editors). Einträge, bei denen Breite oder Höhe außerhalb der Toleranz abweichen, werden in einer Ausgabe-JSON gespeichert. So lassen sich Inkonsistenzen zwischen 3D-Modell und 2D-Zeichnung schnell identifizieren.
+
+### Aufrufmöglichkeiten
+
+**Über die Batch-Datei:**
+
+```bat
+bin\diff_dimensions.bat --type <Typ> --json_dimensions <3D-JSON> --json_2d <2D-JSON> [--tolerance <Wert>] [--result <Ausgabedatei>]
+```
+
+**Interaktiv (mit Abfragen):**
+
+```bat
+bin\get_all_differences.bat
+```
+
+Fragt Typ, Dateinamen und Toleranz interaktiv ab und ruft dann `diff_dimensions.bat` auf.
+
+**Direkt über die Kommandozeile:**
+
+```sh
+python lib/diff_dimensions.py --type <Typ> --json_dimensions <3D-JSON> --json_2d <2D-JSON>
+```
+
+**Parameter:**
+
+- `--type`: Art des Bauteils: `BOGEN`, `WEICHE`, `TEFBOGEN` oder `TEFWEICHE` (bestimmt das Eingabeverzeichnis für die 2D-JSON)
+- `--json_dimensions`: Dateiname der 3D-Maße-JSON (aus `read_variables`, liegt in PROJECT_WORK)
+- `--json_2d`: Dateiname der 2D-Maße-JSON (liegt im typabhängigen Verzeichnis)
+- `--tolerance`: Toleranz in Millimetern (optional, Standard: `0.05`)
+- `--result`: Dateiname der Ausgabedatei (optional, Standard: `Differenzen_2D_3D.json`)
+- `--output_dir`: Ausgabeverzeichnis (optional, Standard: Umgebungsvariable PROJECT_WORK)
+
+### Input/Output
+
+- **Input:**
+  - `--json_dimensions`: JSON-Datei mit 3D-Maßen (Schlüssel: SIVAS-Nummer, Felder: `breite`, `hoehe`)
+  - `--json_2d`: JSON-Datei mit 2D-Maßen (Liste mit Feldern `Sivasnr`, `Objekte_width_mm`, `Objekte_height_mm`)
+- **Output:**
+  - JSON-Datei mit allen Einträgen, deren Maße außerhalb der Toleranz liegen, inkl. Differenzwerten (`w_diff`, `h_diff`). Bei übereinstimmenden Maßen wird keine Ausgabedatei erzeugt.
+
+### Beispielaufruf
+
+```bat
+bin\diff_dimensions.bat --type BOGEN --json_dimensions Bogen_3D.json --json_2d Bogen_2D.json --tolerance 0.1 --result diff_bogen.json
+```
+
+### Hinweise
+
+- Erfordert kein Solid Edge — reine JSON-Verarbeitung.
+- Die Umgebungsvariablen `PROJECT_JSON_BOGEN`, `PROJECT_JSON_WEICHE`, `PROJECT_JSON_TEFBOGEN`, `PROJECT_JSON_TEFWEICHE` müssen für den `--type`-Parameter korrekt gesetzt sein (via setenv.bat).
+
+---
+
+## 5. Batch-Hilfsskripte
+
+### setenv.bat
+
+Setzt alle Projektumgebungsvariablen. Wird von allen anderen Batch-Dateien automatisch aufgerufen.
+
+| Variable | Standardwert | Bedeutung |
+| -------- | ------------ | --------- |
+| `PROJECT_DIR` | Verzeichnis des Code-Ordners | Wurzelverzeichnis des Projekts |
+| `PROJECT_BIN` | `%PROJECT_DIR%\bin` | Verzeichnis der Batch-Dateien |
+| `PROJECT_LIB` | `%PROJECT_DIR%\lib` | Verzeichnis der Python-Skripte |
+| `PROJECT_WORK` | `%PROJECT_DIR%\work` | Arbeitsverzeichnis (Zwischenergebnisse) |
+| `PROJECT_DATA` | `%PROJECT_DIR%\data` | Datenverzeichnis |
+| `PROJECT_INPUT` | `%PROJECT_DIR%\input` | Eingabeverzeichnis (.par-Dateien) |
+| `PROJECT_TEMPLATE` | `\\ssg.local\freigaben\RuleDesigner\Templates\CreateAssemblies` | Netzwerkpfad zur dummy.asm-Vorlage |
+| `PROJECT_JSON_BOGEN` | `%SSG_RD_DIR%\SVGs\Omniflo\python\OFBogen\json` | 2D-JSON-Verzeichnis für Bögen |
+| `PROJECT_JSON_WEICHE` | `%SSG_RD_DIR%\SVGs\Omniflo\python\OFWeiche\json` | 2D-JSON-Verzeichnis für Weichen |
+| `PROJECT_JSON_TEFBOGEN` | `%SSG_RD_DIR%\SVGs\Omniflo\python\TEFBogen\json` | 2D-JSON-Verzeichnis für TEF-Bögen |
+| `PROJECT_JSON_TEFWEICHE` | `%SSG_RD_DIR%\SVGs\Omniflo\python\TEFWeiche\json` | 2D-JSON-Verzeichnis für TEF-Weichen |
+
+### get_cmd.bat
+
+Ruft `setenv.bat` auf und öffnet anschließend eine Kommandozeile mit gesetzten Umgebungsvariablen. Nützlich, um Skripte manuell mit korrekter Umgebung zu testen.
+
+### get_all_differences.bat
+
+Interaktiver Wrapper für `diff_dimensions.bat`. Fragt Typ, JSON-Dateinamen und Toleranz per Eingabeaufforderung ab (mit vordefinierten Standardwerten) und startet dann den Vergleich.
+
+---
+
+## Voraussetzungen
+
+- **Python** mit den Paketen `win32com` (pywin32) und `pythoncom`
+- **Solid Edge** (für COM-Zugriff bei `create_assemblies`, `save_stl`, `read_variables`)
+- **Netzwerkzugriff** auf `\\ssg.local\freigaben\RuleDesigner\Templates\CreateAssemblies` (für `create_assemblies`)
+
+## Fehlerbehandlung
+
+Fehlerhafte oder fehlende Dateien werden bei allen Skripten übersprungen — der Prozess läuft jeweils weiter und gibt eine Fehlermeldung aus.

CAD/Code/lib/create_assemblies.py

@@ -0,0 +1,122 @@
+import os
+import sys
+import shutil
+import argparse
+import win32com.client
+
+
+def start_solid_edge():
+    """Startet Solid Edge über COM."""
+    print("Starting instance of SolidEdge...")
+    se = win32com.client.Dispatch("SolidEdge.Application")
+    se.Visible = True
+    print("done\n")
+    return se.Documents
+
+
+def find_placeholder_occurrence(occurrences, placeholder_name):
+    """Sucht die Occurrence mit dem Namen placeholder_name."""
+    for occ in occurrences:
+        filename = os.path.basename(occ.OccurrenceFileName)
+        if filename.lower() == placeholder_name.lower():
+            return occ
+    return None
+
+
+def process_part(par_name, par_path, dummy_asm_path, placeholder_name, work_dir, output_dir, documents):
+    """Kopiert Dummy-ASM, ersetzt Platzhalter mit .par, speichert Ergebnis."""
+    temp_asm = os.path.join(work_dir, "_temp.asm")
+    temp_cfg = os.path.splitext(temp_asm)[0] + ".cfg"
+
+    shutil.copyfile(dummy_asm_path, temp_asm)
+
+    asm_doc = documents.Open(temp_asm)
+    occurrences = asm_doc.Occurrences
+
+    target_occ = find_placeholder_occurrence(occurrences, placeholder_name)
+
+    if not target_occ:
+        print(f"[{par_name}] Placeholder '{placeholder_name}' not found in 'dummy.asm'. Skipping.")
+        asm_doc.Close(False)
+
+        # Cleanup bei Fehler
+        if os.path.exists(temp_asm):
+            os.remove(temp_asm)
+        if os.path.exists(temp_cfg):
+            os.remove(temp_cfg)
+        return
+
+    print(f"[{par_name}] Replacing '{placeholder_name}' with '{par_name}'...")
+    target_occ.Replace(par_path, True)
+
+    ziel_name = os.path.splitext(par_name)[0] + ".asm"
+    ziel_path = os.path.join(output_dir, ziel_name)
+
+    asm_doc.SaveAs(ziel_path)
+    print(f"→ Saved: {ziel_path}")
+
+    asm_doc.Close(False)
+
+    # Lösche ggf. erzeugte .cfg-Datei zur Ziel-ASM
+    ziel_cfg = os.path.splitext(ziel_path)[0] + ".cfg"
+    if os.path.exists(ziel_cfg):
+        os.remove(ziel_cfg)
+
+    # Lösche temporäre ASM und deren CFG
+    if os.path.exists(temp_asm):
+        os.remove(temp_asm)
+    if os.path.exists(temp_cfg):
+        os.remove(temp_cfg)
+
+
+if __name__ == "__main__":
+    # Argumente parsen
+    parser = argparse.ArgumentParser(description="Solid Edge Occurrence-Replacer")
+    parser.add_argument("--in", dest="input_dir", required=False, help="Path to .par files (Standard: INPUT env or ./input)")
+    parser.add_argument("--out", dest="output_dir", required=False, help="Optional target-directory for .asm files (Standard: ./work)")
+    
+    if len(sys.argv) == 2 and sys.argv[1] in ("-h", "--help"):
+        parser.print_help()
+        sys.exit(0)
+
+    args = parser.parse_args()
+
+    # Umgebungsvariablen & Ordner
+    work_dir = os.environ.get("PROJECT_WORK", "../work")
+    data_dir = os.environ.get("PROJECT_DATA", "../data")
+    template_dir = os.environ.get("PROJECT_TEMPLATE", "//ssg.local/freigaben/RuleDesigner/Templates/CreateAssemblies")
+
+    if args.input_dir:
+        input_dir = args.input_dir
+        print("Using provided input directory.")  
+    else: 
+        input_dir = os.environ.get("PROJECT_INPUT", "../input")
+        print("No input directory provided. Using standard input directory.")
+    
+    if args.output_dir:
+        output_dir = args.output_dir
+    else:
+        output_dir = work_dir
+
+    os.makedirs(work_dir, exist_ok=True)
+    os.makedirs(output_dir, exist_ok=True)
+
+    dummy_asm_path = os.path.join(template_dir, "dummy.asm")
+    placeholder_name = "dummy.par"
+
+    documents = start_solid_edge()
+
+    par_dateien = [f for f in os.listdir(input_dir) if f.lower().endswith(".par")]
+
+    if not par_dateien:
+        print("No .par-files found in input-directory. Exiting...")
+        exit(1)
+
+    for par_name in par_dateien:
+        par_path = os.path.join(input_dir, par_name)
+        process_part(par_name, par_path, dummy_asm_path, placeholder_name, work_dir, output_dir, documents)
+
+    if output_dir == work_dir:
+        print("\nNo output folder (--out) specified. Files saved into 'work' folder.")
+    else:
+        print("\nAll .par files processed and saved into given target folder.")

CAD/Code/lib/diff_dimensions.py

@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+"""
+JSON Integration Script
+Erzeugt neue JSON Datei mit den SIVAS-Nummern, dessen Maße von 3D (.par) und 2D (.dwg) nicht übereinstimmen.
+"""
+
+import json
+import argparse
+import sys
+import os
+from pathlib import Path
+import math
+
+def load_json_file(file_path):
+    """
+    Lädt eine JSON-Datei und gibt den Inhalt zurück.
+    
+    Args:
+        file_path (str): Pfad zur JSON-Datei
+        
+    Returns:
+        list: JSON-Daten als Liste
+        
+    Raises:
+        FileNotFoundError: Wenn die Datei nicht gefunden wird
+        json.JSONDecodeError: Wenn die JSON-Datei ungültig ist
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        print(f"Fehler: Datei '{file_path}' nicht gefunden.")
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        print(f"Fehler beim Parsen der JSON-Datei '{file_path}': {e}")
+        sys.exit(1)
+
+
+def save_json_file(data, file_path):
+    """
+    Speichert Daten in eine JSON-Datei.
+    
+    Args:
+        data (list): Zu speichernde Daten
+        file_path (str): Pfad zur Ausgabedatei
+    """
+    try:
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        print(f"Integrierte Daten erfolgreich in '{file_path}' gespeichert.")
+    except Exception as e:
+        print(f"Fehler beim Speichern der Datei '{file_path}': {e}")
+        sys.exit(1)
+
+
+def integrate_json_data(json_dimensions_data, json_2d_data, tolerance):
+    """
+    Integriert Daten aus JSON_1 in JSON_2 über die Sivasnr.
+    Nur Einträge mit NICHT übereinstimmenden Objekt_width_mm und Objekt_height_mm werden integriert.
+   
+    Args:
+        json_dimensions_data (dict): Dictionary mit Sivasnr als Key und Dimensionsdaten als Value
+        json_2d_data (list): Daten aus JSON_2
+        tolerance (float): Toleranz für die Übereinstimmung der Objekt-Abmessungen
+       
+    Returns:
+        list: Integrierte Daten
+    """
+    # Erstelle eine Kopie des Dictionary für die Verarbeitung
+    json_dimensions_dict = json_dimensions_data.copy()
+   
+    integrated_data = []
+    updated_count = 0
+    new_count = 0
+    skipped_count = 0
+   
+    # Durchlaufe JSON_2 und aktualisiere mit Daten aus JSON_1
+    for json_2d_item in json_2d_data:
+        sivasnr = json_2d_item['Sivasnr']
+        # Konvertiere Sivasnr zu String für Dictionary-Lookup
+        sivasnr_str = str(sivasnr)
+       
+        if sivasnr_str in json_dimensions_dict:
+            json_dimensions_item = json_dimensions_dict[sivasnr_str]
+           
+            # Prüfe Übereinstimmung der Objekt-Abmessungen
+            # Mapping der Attributnamen: 'breite' -> 'Objekt_width_mm', 'hoehe' -> 'Objekt_height_mm'
+            dimensions_width = json_dimensions_item.get('breite', 0)
+            dimensions_height = json_dimensions_item.get('hoehe', 0)
+            
+            width_match = round(abs(dimensions_width - json_2d_item.get('Objekte_width_mm', 0)), 3) <= tolerance
+            height_match = round(abs(dimensions_height - json_2d_item.get('Objekte_height_mm', 0)), 3) <= tolerance
+           
+            if not (width_match and height_match):
+                # Abmessungen stimmen NICHT überein - Eintrag mit Werten aus json_dimensions_data verwenden
+                width_diff = abs(dimensions_width - json_2d_item.get('Objekte_width_mm', 0))
+                height_diff = abs(dimensions_height - json_2d_item.get('Objekte_height_mm', 0))
+                print(f"Integriere Sivasnr {sivasnr}: Abmessungen stimmen nicht überein (Toleranz: {tolerance})")
+                print(f"  Width-Differenz: {width_diff:.3f}mm, Height-Differenz: {height_diff:.3f}mm")
+                print(f"  Verwende Werte aus json_dimensions_data")
+               
+                # Erstelle einen neuen Eintrag mit den Werten aus json_dimensions_data
+                # und konvertiere die Attributnamen
+                integrated_item = {
+                    'Sivasnr': sivasnr,  # Verwende die ursprüngliche Sivasnr aus json_2d_data
+                    'Objekt_width_mm': dimensions_width,
+                    'Objekt_height_mm': dimensions_height,
+                    'w_diff': round(width_diff, 3),
+                    'h_diff': round(height_diff,3),
+                    'tolerance': tolerance
+                }
+                # Weitere Attribute aus json_dimensions_data hinzufügen (falls vorhanden)
+                for key, value in json_dimensions_item.items():
+                    if key not in ['breite', 'hoehe']:
+                        integrated_item[key] = value
+                integrated_data.append(integrated_item)
+                updated_count += 1
+            else:
+                # Abmessungen stimmen überein - Eintrag überspringen
+                print(f"Überspringe Sivasnr {sivasnr}: Abmessungen stimmen überein, w_diff={abs(dimensions_width-json_2d_item.get('Objekte_width_mm', 0))}, h_diff={abs(dimensions_height-json_2d_item.get('Objekte_height_mm', 0))}, (innerhalb der Toleranz)")
+                skipped_count += 1
+           
+            # Entferne das verarbeitete Item aus dem Dictionary
+            del json_dimensions_dict[sivasnr_str]
+        # Wenn Sivasnr nicht in JSON_1 gefunden wird, wird der Eintrag nicht zur Ausgabe hinzugefügt
+   
+    # Füge verbleibende Items aus JSON_1 hinzu (die nicht in JSON_2 waren)
+    for sivasnr_str, json_dimensions_item in json_dimensions_dict.items():
+        # Erstelle einen neuen Eintrag mit konvertierten Attributnamen
+        integrated_item = {
+            'Sivasnr': sivasnr_str,  # Verwende die String-Version der Sivasnr
+            'Objekt_width_mm': json_dimensions_item.get('breite', 0),
+            'Objekt_height_mm': json_dimensions_item.get('hoehe', 0)
+        }
+        # Weitere Attribute aus json_dimensions_data hinzufügen (falls vorhanden)
+        for key, value in json_dimensions_item.items():
+            if key not in ['breite', 'hoehe']:
+                integrated_item[key] = value
+        
+        integrated_data.append(integrated_item)
+        new_count += 1
+        print(f"Neue Sivasnr {sivasnr_str} aus JSON_1 hinzugefügt (nicht in JSON_2 vorhanden).")
+   
+    print(f"\nIntegration abgeschlossen:")
+    print(f"- {updated_count} Einträge integriert (Abmessungen stimmen nicht überein)")
+    print(f"- {new_count} neue Einträge hinzugefügt (nur in JSON_1 vorhanden)")
+    print(f"- {skipped_count} Einträge übersprungen (Abmessungen stimmen überein)")
+    print(f"- {len(integrated_data)} Einträge gesamt")
+   
+    return integrated_data
+def main():
+    """
+    Hauptfunktion des Programms.
+    """
+    parser = argparse.ArgumentParser(
+        description="Integriert JSON-Daten aus JSON_1 in JSON_2 über die Sivasnr",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Beispiel:
+    python json_integration.py --json_dimensions file1.json --json_2d file2.json --result result.json
+    python json_integration.py --type=BOGEN --output_dir /custom/output --json_dimensions file1.json --json_2d file2.json --result result.json
+        """
+    )
+    
+    parser.add_argument(
+        '--output_dir', 
+        dest='output_dir',
+        required=False, 
+        help='Ausgabeverzeichnis für integrierte Daten (Standard: PROJECT_WORK)'
+    )
+    
+    parser.add_argument(
+        '--json_dimensions', 
+        required=True,
+        help='Dateiname der ersten JSON-Datei (Quelldaten)',
+        metavar='[Weiche_3D, Bogen_3D, TEFWeiche_3D, TEFBogen_3D].json'
+    )
+    
+    parser.add_argument(
+        '--json_2d', 
+        required=True, 
+        help='Dateiname der zweiten JSON-Datei (Zieldaten)',
+        metavar='[Weiche_2D, Bogen_2D, TEFWeiche_2D, TEFBogen_2D].json'
+    )
+    
+    parser.add_argument(
+        '--tolerance',
+        type=float,
+        default=0.05,
+        required=False, 
+        help='Toleranz in Millimetern, welche als Differenz akzeptiert wird.',
+        metavar='0.05'
+    )
+    
+    parser.add_argument(
+        '--result',
+        default='Differenzen_2D_3D.json',
+        required=False, 
+        help='Dateiname für die Ausgabedatei mit integrierten Daten'
+    )
+
+    parser.add_argument("--type", type=str, choices=["BOGEN", "WEICHE", "TEFBOGEN", "TEFWEICHE"], help="Art des Exports (BOGEN, WEICHE, TEFBOGEN, TEFWEICHE).")
+    
+    if len(sys.argv) == 2 and sys.argv[1] in ("-h", "--help"):
+        parser.print_help()
+        sys.exit(0)
+    
+    args = parser.parse_args()
+    
+    # Umgebungsvariablen & Ordner
+    output_dir = args.output_dir or os.environ.get("PROJECT_WORK", "./output")
+    input_3d_dir = os.environ.get("PROJECT_WORK")
+    bogen = os.environ.get("PROJECT_JSON_BOGEN")
+    weiche = os.environ.get("PROJECT_JSON_WEICHE")
+    tefbogen = os.environ.get("PROJECT_JSON_TEFBOGEN")
+    tefweiche = os.environ.get("PROJECT_JSON_TEFWEICHE")
+    tolerance = args.tolerance
+
+    if args.type == "BOGEN":
+        input_dir = bogen
+    elif args.type == "WEICHE":
+        input_dir = weiche
+    elif args.type == "TEFBOGEN":
+        input_dir = tefbogen
+    elif args.type == "TEFWEICHE":
+        input_dir = tefweiche
+
+    
+    # Erstelle Verzeichnisse falls sie nicht existieren
+    if not Path(input_dir).exists():
+        print(f"Fehler: Eingabeverzeichnis existiert nicht.")
+        sys.exit(1)
+
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    
+    # Vollständige Pfade zu den Dateien
+    json_dimensions_path = Path(input_3d_dir) / args.json_dimensions
+    json_2d_path = Path(input_dir) / args.json_2d
+    output_path = Path(output_dir) / args.result
+    
+    # Validiere Eingabedateien
+    if not json_dimensions_path.exists():
+        print(f"Fehler: JSON_1 Datei '{json_dimensions_path}' existiert nicht.")
+        sys.exit(1)
+    
+    if not json_2d_path.exists():
+        print(f"Fehler: JSON_2 Datei '{json_2d_path}' existiert nicht.")
+        sys.exit(1)
+    
+    
+    # Lade JSON-Dateien
+    print(f"Lade JSON_1: {json_dimensions_path}")
+    json_dimensions_data = load_json_file(json_dimensions_path)
+    
+    print(f"Lade JSON_2: {json_2d_path}")
+    json_2d_data = load_json_file(json_2d_path)
+    
+    # # Validiere Datenstruktur
+    # if not isinstance(json_dimensions_data, list) or not isinstance(json_2d_data, list):
+    #     print("Fehler: Beide JSON-Dateien müssen Arrays (Listen) enthalten.")
+    #     parser.print_help()
+    #     sys.exit(1)
+    
+    # # Prüfe ob Sivasnr in allen Einträgen vorhanden ist
+    # for i, item in enumerate(json_dimensions_data):
+    #     if 'Sivasnr' not in item:
+    #         print(f"Fehler: Sivasnr fehlt in JSON_1 Eintrag {i}")
+    #         parser.print_help()
+    #         sys.exit(1)
+    
+    for i, item in enumerate(json_2d_data):
+        if 'Sivasnr' not in item:
+            print(f"Fehler: Sivasnr fehlt in JSON_2 Eintrag {i}")
+            parser.print_help()
+            sys.exit(1)
+    
+    print(f"JSON_1 enthält {len(json_dimensions_data)} Einträge")
+    print(f"JSON_2 enthält {len(json_2d_data)} Einträge")
+    
+    # Integriere Daten
+    integrated_data = integrate_json_data(json_dimensions_data, json_2d_data, tolerance)
+    
+    if len(integrated_data) > 0:
+        # Speichere integrierte Daten
+        save_json_file(integrated_data, output_path)
+    else:
+        print(f"Dateien enthalten keine Unterschiede")
+
+
+if __name__ == "__main__":
+    main()

CAD/Code/lib/read_variables.py

@@ -0,0 +1,103 @@
+import os
+import sys
+import json
+import argparse
+import win32com.client
+
+def read_custom_properties(par_path):
+    """Liest benutzerdefinierte Variablen 'Mittiges_Koordinatensystem_X/Y_Translation'."""
+    try:
+        app = win32com.client.Dispatch("SolidEdge.Application")
+        app.Visible = False  # Optional auf True für Debug
+
+        doc = app.Documents.Open(par_path)
+        variables = doc.Variables
+
+        breite = None
+        hoehe = None
+
+        for i in range(1, variables.Count + 1):
+            variable = variables.Item(i)
+            name = variable.Name
+            value = variable.Value
+
+            if name == 'Mittiges_Koordinatensystem_X_Translation':
+                breite = round(value*2000, 3)
+            elif name == 'Mittiges_Koordinatensystem_Y_Translation':
+                hoehe = round(value*2000, 3)
+
+        doc.Close(False)
+
+        if breite is not None and hoehe is not None:
+            return breite, hoehe
+        else:
+            raise ValueError("Benötigte Variablen nicht gefunden.")
+
+    except Exception as e:
+        print(f"Fehler beim Lesen von {par_path}: {e}")
+        return None, None
+
+    finally:
+        try:
+            if doc:
+                doc.Close(False)
+        except:
+            pass
+
+
+def extract_all(input_dir):
+    """Verarbeitet alle .par Dateien im Verzeichnis."""
+    result = {}
+
+    for file in os.listdir(input_dir):
+        if file.lower().endswith(".par"):
+            par_path = os.path.join(input_dir, file)
+            print(f"Processing: {file}")
+            breite, hoehe = read_custom_properties(par_path)
+
+            if breite is not None and hoehe is not None:
+                key = os.path.splitext(file)[0]  # Dateiname ohne .par
+                result[key] = {
+                    "breite": breite,
+                    "hoehe": hoehe
+                }
+
+    return result
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Extrahiert 'Breite' und 'Höhe' aus .par-Dateien in JSON.")
+    parser.add_argument("--in", dest="input_dir", required=False, help="Ordner mit .par-Dateien (Standard: PROJECT_INPUT oder ./input)")
+    parser.add_argument("--out", dest="output_dir", required=False, help="Ordner für JSON-Ausgabe (Standard: PROJECT_WORK oder ./work)")
+
+    if len(sys.argv) == 2 and sys.argv[1] in ("-h", "--help"):
+        parser.print_help()
+        sys.exit(0)
+
+    args = parser.parse_args()
+
+    input_dir = args.input_dir or os.environ.get("PROJECT_INPUT", "./input")
+    output_dir = args.output_dir or os.environ.get("PROJECT_WORK", "./work")
+
+    # Hole den Namen des Input-Ordners (ohne Pfad)
+    input_basename = os.path.basename(os.path.normpath(input_dir))
+    output_filename = input_basename + ".json"
+
+    # Pfad zur Zieldatei
+    json_output_path = os.path.join(output_dir, output_filename)
+
+    print(f"Input directory: {input_dir}")
+    print(f"Output JSON will be saved to: {json_output_path}\n")
+
+    if not os.path.exists(input_dir):
+        print(f"Input folder not found: {input_dir}")
+        sys.exit(1)
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    data = extract_all(input_dir)
+
+    with open(json_output_path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+
+    print("\nDone! Data saved to:", json_output_path)

CAD/Code/lib/requirements.txt

@@ -0,0 +1 @@
+pywin32

CAD/Code/lib/save_stl.py

@@ -0,0 +1,108 @@
+import os
+import sys
+import argparse
+import win32com.client
+import pythoncom
+
+def export_assemblies_to_stl(input_dir, output_dir, filter_name=None, minimized=False):
+    pythoncom.CoInitialize()
+
+    try:
+        # Solid Edge starten oder verbinden
+        se_app = win32com.client.Dispatch("SolidEdge.Application")
+        se_app.Visible = True
+        se_app.WindowState = 2 if minimized else 1
+
+        documents = se_app.Documents
+
+        os.makedirs(output_dir, exist_ok=True)
+
+        for filename in os.listdir(input_dir):
+            if filename.lower().endswith(".asm"):
+                if filter_name and filter_name.lower() not in filename.lower():
+                    continue
+                asm_path = os.path.join(input_dir, filename)
+                stl_filename = os.path.splitext(filename)[0] + ".stl"
+                stl_path = os.path.join(output_dir, stl_filename)
+
+                print(f"Processing: {asm_path}")
+
+                try:
+                    # Baugruppe öffnen
+                    doc = documents.Open(asm_path)
+                    # STL exportieren in den Unterordner
+                    doc.SaveAs(stl_path)
+                    print(f"-> Exported to: {stl_path}")
+                except Exception as e:
+                    print(f"Error processing {filename}: {e}")
+                finally:
+                    # Datei schließen
+                    doc.Close(False)
+
+        # --- Aufräumen: .cfg und .log im Hauptordner ---
+        print("")
+        for file in os.listdir(input_dir):
+            if file.lower().endswith((".cfg", ".log")):
+                file_path = os.path.join(input_dir, file)
+                try:
+                    os.remove(file_path)
+                    print(f"Deleted (input): {file}")
+                except Exception as e:
+                    print(f"Error deleting {file}: {e}")
+
+        # --- Aufräumen: .log im STL-Unterordner ---
+        for file in os.listdir(output_dir):
+            if file.lower().endswith(".log"):
+                file_path = os.path.join(output_dir, file)
+                try:
+                    os.remove(file_path)
+                    print(f"Deleted (output): {file}")
+                except Exception as e:
+                    print(f"Error deleting {file}: {e}")
+
+        print("\nExport and cleanup completed.")
+    finally:
+        try:
+            if 'doc' in locals():
+                doc.Close(False)
+        except:
+            pass
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Exportiert alle .asm-Dateien in einem Ordner nach STL.")
+    parser.add_argument("--in", dest="input_dir", required=False, help="Ordner mit .asm-Dateien (Standard: WORK oder ../work)")
+    parser.add_argument("--out", dest="output_dir", required=False, help="Zielordner für STL-Dateien (Standard: work/STL_Export)")
+    parser.add_argument("--filter", dest="filter_name", required=False, help="Nur Dateien verarbeiten, deren Name diesen String enthält")
+    parser.add_argument("--se-minimized", dest="minimized", action="store_true", default=False, help="Solid Edge minimiert starten")
+
+    if len(sys.argv) == 2 and sys.argv[1] in ("-h", "--help"):
+        parser.print_help()
+        sys.exit(0)
+
+    args = parser.parse_args()
+
+    work_dir = os.environ.get("PROJECT_WORK", "../work")
+
+    if args.input_dir:
+        input_dir = args.input_dir
+        print("Using provided input directory.\n")  
+    else: 
+        input_dir = os.environ.get("PROJECT_WORK", "../work")
+        print("No input directory provided. Using 'work' directory as input.\n")
+
+    if args.output_dir:
+        output_dir = args.output_dir
+        print(f"Saving exported STL files to provided output directory.\n")
+    else:
+        output_dir = os.path.join(work_dir, "STL_Export")
+        print(f"No output directory provided. Exporting STL files to 'work'.\n")
+
+
+    if not os.path.exists(input_dir):
+        print(f"Input folder not found: {input_dir}")
+        sys.exit(1)
+
+    if args.filter_name:
+        print(f"Filtering files containing: '{args.filter_name}'\n")
+
+    export_assemblies_to_stl(input_dir, output_dir, args.filter_name, args.minimized)