# translate.py - Text-Extraktion und -Übersetzung für DXF-Dateien

## Übersicht

`translate.py` ist ein Python-Tool zur Extraktion, Filterung und Übersetzung von Texten aus DXF/DWG-Dateien. Es unterstützt mehrere Arbeitsweisen und ermöglicht die Erstellung mehrsprachiger technischer Zeichnungen für den internationalen Einsatz.

---

## Quickstart - Haupt-Workflow für DXF-Übersetzung

Dieser Workflow beschreibt die **empfohlene Vorgehensweise** für die Übersetzung technischer Zeichnungen.

### Schritt 1: Text-Extraktion aus DXF

Ziehen Sie die DXF-Datei per **Drag & Drop** auf die Desktop-Verknüpfung **`tr_dxf2txt`**:

<img src="img/Icons/dxf2txt.png" width="113" alt="tr_dxf2txt Icon">

**Was passiert:**
- Alle TEXT, MTEXT und Block-Attribute (TEXT-D) werden aus der DXF extrahiert
- Zwei Dateien werden im `work/` Ordner erstellt:
  - `<dateiname>_texts.json` - JSON-Datei mit allen extrahierten Texten
  - `<dateiname>_texts.txt` - Textdatei mit allen extrahierten Texten

**Beispiel:**
```
Eingabe:  Projekt_Anlage_Rev3.dxf
Ausgabe:  work/Projekt_Anlage_Rev3_texts.json
          work/Projekt_Anlage_Rev3_texts.txt
```

### Schritt 2: Automatische Übersetzung mit Sprach-Config

Ziehen Sie die erzeugte **JSON-Datei** (`<dateiname>_texts.json`) per **Drag & Drop** auf die gewünschte Sprach-Verknüpfung:

- **tr2dxf_CS** (Tschechisches Icon) → Tschechische Übersetzung
- **tr2dxf_EN** (Englisch-Icon) → Englische Übersetzung
- **tr2dxf_FR** (Französisch-Icon) → Französische Übersetzung
- **tr2dxf_ES** (Spanisch-Icon) → Spanische Übersetzung
- **tr2dxf_IT** (Italienisch-Icon) → Italienische Übersetzung

<img src="img/Icons/dxfCs.png" width="113" alt="tr2dxf_CS Icon">
<img src="img/Icons/dxfEN.png" width="113" alt="tr2dxf_EN Icon">
<img src="img/Icons/dxfFR.png" width="113" alt="tr2dxf_FR Icon">
<img src="img/Icons/dxfES.png" width="113" alt="tr2dxf_ES Icon">

**Was passiert:**
- Die JSON-Datei wird mit der aktuellen Sprachkonfiguration (z.B. `CS.cfg`) re-übersetzt
- Alle konfigurierten Begriffe werden automatisch übersetzt
- Der `[translate]` Block in der JSON wird mit Übersetzungen gefüllt
- Nicht-übersetzte Begriffe bleiben im `untranslated` Block

**JSON-Struktur nach diesem Schritt:**
```json
{
  "[CS]": {
    "translations": [
      {"source": "Emergency stop", "target": "Nouzové zastavení"},
      {"source": "Power supply", "target": "Napájení"}
    ],
    "untranslated": [
      {"source": "Custom text XY", "target": ""}
    ]
  },
  "ignored": ["X=123.45", "LAYER=0"]
}
```

### Schritt 3: Sichtkontrolle und manuelle Ergänzung

Öffnen Sie die `_texts.json` Datei mit einem **Texteditor** oder **JSON-Editor** und prüfen Sie:

1. **Translations Block:** Sind alle Übersetzungen korrekt?
2. **Untranslated Block:** Welche Begriffe fehlen noch?

Bei Bedarf:
- Fügen Sie fehlende Übersetzungen **manuell** in die JSON ein:
  ```json
  {"source": "Custom text XY", "target": "Vlastní text XY"}
  ```
- **Oder** ergänzen Sie die Sprach-Config (`translation/CS.cfg`) und wiederholen Sie Schritt 2

**Hinweis zur .txt Datei:**
Die parallel erzeugte `.txt` Datei hat folgendes Format:
```
--- translations:

Emergency stop -> Nouzové zastavení
Power supply -> Napájení

--- untranslated:

Custom text XY

--- ignored:

X=123.45
LAYER=0
```

Die `.txt` Datei eignet sich gut für einen **schnellen Überblick**, während die `.json` Datei für die tatsächliche DXF-Übersetzung verwendet wird.

### Schritt 4: DXF-Datei übersetzen

Ziehen Sie die **Original-DXF-Datei** per **Drag & Drop** auf die gewünschte **Sprach-Verknüpfung** (z.B. `tr2dxf_CS`).

**Voraussetzung:**
- Die `<dateiname>_texts.json` muss im `work/` Ordner vorhanden sein
- Die JSON sollte möglichst vollständige Übersetzungen enthalten

**Was passiert:**
- Eine neue DXF-Datei wird erstellt: `<dateiname>_CS.dxf` (oder EN, FR, etc.)
- Alle TEXT, MTEXT und Block-Attribute werden übersetzt
- Die Übersetzungen werden in die entsprechenden Ziel-Attribute geschrieben:
  - TEXT-D → TEXT-CS (bei Tschechisch)
  - TEXT-D → TEXT-E (bei Englisch)
  - TEXT-D → TEXT-ES (bei Spanisch)
  - etc.
- Das Original-Attribut TEXT-D bleibt **unverändert erhalten**

**Beispiel:**
```
Eingabe:  Projekt_Anlage_Rev3.dxf (+ work/Projekt_Anlage_Rev3_texts.json)
Ausgabe:  work/Projekt_Anlage_Rev3_CS.dxf
```

### Zusammenfassung des Workflows

```
1. DXF → [tr_dxf2txt] → _texts.json + _texts.txt
                             ↓
2. _texts.json → [tr2dxf_CS] → _texts.json (mit Übersetzungen)
                             ↓
3. Manuelle Prüfung/Ergänzung der JSON
                             ↓
4. DXF → [tr2dxf_CS] → DXF_CS.dxf (übersetzte Zeichnung)
```

---

## Konfiguration für neue Sprachen

Wenn Sie eine neue Sprache konfigurieren oder bestehende Übersetzungen erweitern möchten, folgen Sie dieser Anleitung.

### Aufbau der Sprach-Konfigurationsdateien

Sprach-Configs befinden sich im Verzeichnis `translation/` (z.B. `CS.cfg`, `EN.cfg`, `FR.cfg`).

Jede Config-Datei hat **vier Sektionen** in festgelegter Prioritätsreihenfolge:

1. **[multi]** - Phrasen mit 4 oder mehr Wörtern
2. **[trigramme]** - Phrasen mit genau 3 Wörtern
3. **[bigramme]** - Phrasen mit genau 2 Wörtern
4. **[single]** - Einzelwörter

**Wichtig:** Die Übersetzung erfolgt in dieser Reihenfolge. Längere Phrasen werden zuerst ersetzt, danach kürzere.

### Empfohlene Vorgehensweise beim Konfigurieren

#### 1. Erste Extraktion durchführen

Führen Sie zunächst eine Text-Extraktion **ohne Übersetzung** durch:

```bash
bin\translate.bat --filename projekt.dxf --extract --outname projekt_texts.json
```

Dies erzeugt `projekt_texts.json` und `projekt_texts.txt` mit allen extrahierten Texten.

#### 2. Zusammenhängende Phrasen identifizieren

Öffnen Sie die `.txt` Datei und suchen Sie nach zusammenhängenden Phrasen:

**Beispiele für zusammenhängende Phrasen:**
- "Main distribution panel" (3 Wörter)
- "Emergency stop button" (3 Wörter)
- "Power supply unit" (3 Wörter)
- "Safety circuit monitoring relay" (4 Wörter)

#### 3. Konfiguration ausfüllen - Sektion [multi]

Beginnen Sie mit den **längsten Phrasen** (4+ Wörter) in der `[multi]` Sektion:

```ini
[multi]
Safety circuit monitoring relay = Relé sledování bezpečnostního obvodu
Main circuit breaker control unit = Hlavní jistič řízení jednotky
Emergency stop button reset function = Nouzové tlačítko funkce reset
```

**Format:** `Original = Übersetzung`

#### 4. Konfiguration ausfüllen - Sektion [trigramme]

Fügen Sie **3-Wort-Phrasen** in die `[trigramme]` Sektion ein:

```ini
[trigramme]
Main distribution panel = Hlavní rozváděč
Power supply unit = Napájecí zdroj
Emergency stop button = Nouzové tlačítko zastavení
Safety light curtain = Bezpečnostní světelná závěsa
Motor protection switch = Ochrana motoru spínač
```

#### 5. Konfiguration ausfüllen - Sektion [bigramme]

Fügen Sie **2-Wort-Phrasen** in die `[bigramme]` Sektion ein:

```ini
[bigramme]
Emergency stop = Nouzové zastavení
Power supply = Napájení
Control panel = Ovládací panel
Safety relay = Bezpečnostní relé
Main switch = Hlavní spínač
Motor protection = Ochrana motoru
```

#### 6. Konfiguration ausfüllen - Sektion [single]

Fügen Sie **Einzelwörter** in die `[single]` Sektion ein:

```ini
[single]
Weight = Hmotnost
Cable = Kabel
Emergency = Nouzový
Stop = Zastavení
Power = Napájení
Control = Ovládání
Safety = Bezpečnost
Motor = Motor
Switch = Spínač
Panel = Panel
```

**Hinweis:** Einzelwörter werden auch innerhalb von Wörtern mit Sonderzeichen erkannt:
- `"Weight:"` → `"Hmotnost:"`
- `"(Motor)"` → `"(Motor)"`
- `"\\fArial|b0;Switch"` → `"\\fArial|b0;Spínač"`

### Warum diese Reihenfolge?

Die Reihenfolge **Multi → Trigramme → Bigramme → Single** ist entscheidend für korrekte Übersetzungen:

**Beispiel:**
- Text: `"Emergency stop button"`
- Falsche Reihenfolge (single zuerst):
  - "Emergency" → "Nouzový"
  - "stop" → "zastavení"
  - Ergebnis: `"Nouzový zastavení button"` ❌

- Richtige Reihenfolge (trigramme zuerst):
  - "Emergency stop button" → "Nouzové tlačítko zastavení" ✓

### Testen der Konfiguration

Nach dem Ausfüllen der Config testen Sie die Übersetzung:

```bash
# Extraktion mit automatischer Übersetzung
bin\translate.bat --filename projekt.dxf --extract --translate CS --outname test_cs.json

# Prüfen Sie die JSON-Datei:
# - "translations" Block: erfolgreich übersetzte Begriffe
# - "untranslated" Block: fehlende Übersetzungen
```

Ergänzen Sie die Config basierend auf dem `untranslated` Block und wiederholen Sie den Test.

### Re-Übersetzung einer bestehenden JSON

Wenn Sie die Sprach-Config erweitert haben, können Sie eine bestehende JSON-Datei **re-übersetzen**:

```bash
# Manuelle Kommandozeile
bin\translate.bat --retranslate-json projekt_texts.json --translate CS

# ODER: Drag & Drop der JSON auf die Sprach-Verknüpfung (tr2dxf_CS)
```

Dies aktualisiert alle Übersetzungen basierend auf der aktuellen Config.

---

## Hauptfunktionen

- **Text-Extraktion**: Extrahiert TEXT, MTEXT und Block-Attribute aus DXF-Dateien
- **Text-Filterung**: Filtert Texte basierend auf konfigurierbaren Mustern (Wildcards und Regex)
- **Automatische Übersetzung**: Übersetzt Texte mittels konfigurierbarer Wörterbücher (Multi-Phrasen, Trigramme, Bigramme, Einzelwörter)
- **DXF-zu-DXF Übersetzung**: Erstellt übersetzte DXF-Dateien mit mehrsprachigen Attributen
- **Mehrsprachige Übersetzung**: Unterstützt gleichzeitige Übersetzung in mehrere Sprachen
- **Export**: Exportiert Texte in verschiedene Formate (Excel, JSON, Text)

---

## Konfigurationsdateien

### translator.cfg

Hauptkonfigurationsdatei im `cfg/` Verzeichnis:

```ini
[symbol_attribute]
# Zuordnung von Sprachcodes zu Block-Attributnamen
DE = TEXT-D
EN = TEXT-E
ES = TEXT-ES
CS = TEXT-CS
FR = TEXT-F

[symbol_layer]
# Zuordnung von Sprachcodes zu Layer-Namen
DE = 0-0_TEXT-D
EN = 0-0_TEXT-E
ES = 0-0_TEXT-ES
CS = 0-0_TEXT-CS
FR = 0-0_TEXT-F

[ignore_pattern_wildcard]
# Wildcard-Muster für zu ignorierende Texte
coord_x = X=*
coord_y = Y=*
coord_z = Z=*
# ... weitere Muster

[ignore_pattern_regex]
# Regex-Muster für zu ignorierende Texte
coord_arrows = ^\+\d{1,3}(?:[.,]\d{3})\s*(?:<<<|>>>)\s*\+\d{1,3}(?:[.,]\d{3})$
ip_adress = ^.*;(\d{1,3}\.){3}\d{1,3}$
# ... weitere Muster
```

**Zweck der Sektionen:**
- **[symbol_attribute]**: Mapping von Sprach-Codes zu DXF-Block-Attributnamen
- **[symbol_layer]**: Mapping von Sprach-Codes zu DXF-Layer-Namen
- **[ignore_pattern_wildcard]**: Einfache Muster mit `*` und `?` für zu ignorierende Texte
- **[ignore_pattern_regex]**: Reguläre Ausdrücke für komplexere Filter-Muster

### Übersetzungs-Configs (Beispiel: CS.cfg)

Sprachspezifische Konfigurationsdateien im `translation/` Verzeichnis:

```ini
[multi]
# Phrasen mit 4+ Wörtern
Safety circuit monitoring relay = Relé sledování bezpečnostního obvodu
Main circuit breaker control unit = Hlavní jistič řízení jednotky

[trigramme]
# 3-Wort-Phrasen
Main distribution panel = Hlavní rozváděč
Power supply unit = Napájecí zdroj
Emergency stop button = Nouzové tlačítko zastavení

[bigramme]
# 2-Wort-Phrasen
Emergency stop = Nouzové zastavení
Power supply = Napájení
Control panel = Ovládací panel

[single]
# Einzelwörter
Weight = Hmotnost
Cable = Kabel
Emergency = Nouzový
Stop = Zastavení
```

---

## Verwendungsbeispiele (Kommandozeile)

### 1. Text-Extraktion aus DXF

Extrahiert Texte aus einer DXF-Datei und speichert sie in verschiedenen Formaten.

```bash
# Extraktion in JSON (Standard)
bin\translate.bat --filename file.dxf --extract --outname output.json

# Extraktion in Excel
bin\translate.bat --filename file.dxf --extract --export-type excel --outname output.xlsx

# Extraktion in Textdatei
bin\translate.bat --filename file.dxf --extract --export-type text --outname output.txt

# Mehrere Formate gleichzeitig (komma-separiert)
bin\translate.bat --filename file.dxf --extract --export-type excel,json,text --outname output
# Erzeugt: output.xlsx, output.json, output.txt

# Ohne Angabe von --outname: Automatische Namensvergabe
bin\translate.bat --filename easy.dxf --extract --export-type excel,json
# Erzeugt: easy_texts.xlsx, easy_texts.json

# Mit Quellsprache (Standard: DE -> TEXT-D)
bin\translate.bat --filename file.dxf --extract --lang_source EN
```

**Extrahierte Entitäten:**
- TEXT-Objekte im Modellbereich
- MTEXT-Objekte im Modellbereich
- Block-Attribute (nur Blöcke mit IO, ID, VERW, BEZEICHNUNG, KENNZEICHNUNG)

### 2. Text-Extraktion mit Übersetzung

Extrahiert und übersetzt Texte automatisch mittels Übersetzungs-Config.

```bash
# Extraktion mit automatischer Übersetzung nach CS (Tschechisch)
bin\translate.bat --filename file.dxf --extract --translate CS --outname output.json

# Extraktion mit Übersetzung nach EN (Englisch)
bin\translate.bat --filename file.dxf --extract --translate EN --export-type excel
```

**Output-Format für eine Sprache (JSON):**
```json
{
  "translations": [
    {"source": "Weight", "target": "Hmotnost"}
  ],
  "untranslated": [
    {"source": "Custom text", "target": ""}
  ],
  "ignored": [
    "X=123.45",
    "LAYER=0"
  ]
}
```

### 3. Mehrsprachige Text-Extraktion

Extrahiert und übersetzt Texte gleichzeitig in mehrere Sprachen mit hierarchischer JSON-Struktur.

```bash
# Extraktion mit mehreren Sprachen (komma-separiert)
bin\translate.bat --filename file.dxf --extract --translate CS,EN --outname output.json

# Drei Sprachen gleichzeitig
bin\translate.bat --filename file.dxf --extract --translate CS,EN,FR --export-type json

# Mit Excel-Export (nur erste Sprache wird in Excel verwendet)
bin\translate.bat --filename file.dxf --extract --translate CS,EN --export-type excel,json
```

**Output-Format für mehrere Sprachen (hierarchische JSON-Struktur):**
```json
{
  "[CS]": {
    "translations": [
      {"source": "Emergency stop", "target": "Nouzové zastavení"},
      {"source": "Weight", "target": "Hmotnost"}
    ],
    "untranslated": [
      {"source": "Custom text", "target": ""}
    ]
  },
  "[EN]": {
    "translations": [
      {"source": "Emergency stop", "target": "Emergency stop"},
      {"source": "Weight", "target": "Weight"}
    ],
    "untranslated": [
      {"source": "Custom text", "target": ""}
    ]
  },
  "ignored": [
    "X=123.45",
    "LAYER=0"
  ]
}
```

### 4. DXF-zu-DXF Übersetzung

Erstellt eine neue DXF-Datei mit übersetzten Texten in mehrsprachigen Attributen.

```bash
# Übersetzung TEXT-D -> TEXT-CS (verwendet automatisch file_texts.json)
bin\translate.bat --filename file.dxf --todxf file_cs.dxf --translate CS

# Mit expliziter JSON-Datei
bin\translate.bat --filename file.dxf --todxf output.dxf --translate CS --translation-json custom.json

# Mit alternativer Quellsprache
bin\translate.bat --filename file.dxf --todxf output.dxf --lang_source EN --translate CS
```

**Verhalten:**
- **TEXT/MTEXT**: Direkt im Entity übersetzt
- **Block-Attribute**:
  - Liest aus Quell-Attribut (z.B. TEXT-D)
  - Schreibt in Ziel-Attribut (z.B. TEXT-CS)
  - Quell-Attribut bleibt unverändert
  - Erstellt fehlende ATTDEF im Block
  - Erstellt fehlende Layer (aus `[symbol_layer]`)

### 5. JSON-Reprocessing

Übersetzt den `untranslated` Block einer JSON-Datei erneut.

```bash
bin\translate.bat --fromjson output.json --translate CS
```

### 6. JSON Re-Translation

Re-übersetzt den `translations` Block mit aktualisierter Sprach-Config.

```bash
bin\translate.bat --retranslate-json output.json --translate CS
```

---

## Umgebungsvariablen

Das Programm benötigt folgende Umgebungsvariablen (werden in `bin/setenv.bat` gesetzt):

- `PROJECT_WORK`: Arbeitsverzeichnis für Ein-/Ausgabe-Dateien
- `PROJECT_CFG`: Konfigurationsverzeichnis (`cfg/`)
- `PROJECT_TRANSLATION`: Übersetzungs-Konfigurationsverzeichnis (`translation/`)

---

## Fehlerbehandlung und Ausgabe

Das Programm gibt detaillierte Statusmeldungen aus:

```
Anzahl gefundener TEXT Objekte: 150
Anzahl gefundener MTEXT Objekte: 25
Anzahl gefundener TEXT-D in Blöcken: 340
Duplikate entfernt: 75
Eindeutige Texte extrahiert: 440

Filterung abgeschlossen:
  Akzeptierte Texte: 380
  Ignorierte Texte: 60

DXF-Übersetzung abgeschlossen:
  TEXT übersetzt: 140, übersprungen: 10, ignoriert: 0
  MTEXT übersetzt: 20, übersprungen: 5, ignoriert: 0
  TEXT-CS (Blöcke) erstellt/aktualisiert: 310, übersprungen: 30, ignoriert: 0
  Gesamt: 470 übersetzt, 45 übersprungen, 0 ignoriert
```

---

## Tipps und Hinweise

- Texte werden als Set verarbeitet → Duplikate werden automatisch entfernt
- Leere Texte werden ignoriert
- Übersetzungen erfolgen in der Reihenfolge: Multi → Trigramme → Bigramme → Einzelwörter
- Bei DXF-zu-DXF Übersetzung bleibt das Original-Attribut immer unverändert
- Layer und ATTDEF werden nur bei Bedarf erstellt (lazy creation)
- Alle Ausgabedateien landen im `PROJECT_WORK` Verzeichnis
- Die `.txt` Ausgabe eignet sich für schnelle Übersicht und Textverarbeitung
- Die `.json` Ausgabe wird für DXF-zu-DXF Übersetzung verwendet
- Die `.xlsx` Ausgabe eignet sich für externe Übersetzungsdienstleister

---

## Anhang A: Python-Modul translate.py

### Kommandozeilen-Parameter

#### Eingabe-Modi (mutual exclusive)

- `--extract` / `-e`: Extrahiere Texte aus DXF/DWG (benötigt `--filename`)
- `--fromtxt FILE.txt`: Filtere Texte aus Textdatei
- `--fromjson FILE.json`: Re-prozessiere JSON (benötigt `--translate`)
- `--retranslate-json FILE.json`: Re-übersetzt translations Block mit aktueller Config (benötigt `--translate`)
- `--todxf OUTPUT.dxf`: DXF-zu-DXF Übersetzung (benötigt `--filename`)

#### Hauptparameter

- `--filename FILE` / `-f FILE`: Eingabe-DXF/DWG-Datei
- `--outname NAME` / `-o NAME`: Name der Ausgabedatei (ohne Endung bei mehreren Formaten)
- `--translate LANG`: Übersetzungssprache (CS, EN, FR, etc.) oder mehrere kommasepariert (CS,EN,FR)
- `--lang_source LANG`: Quellsprache für Block-Attribute (Standard: DE)
- `--export-type TYPE`: Exportformat(e): `json` (Standard), `excel`, `text` oder komma-separiert (z.B. `excel,json,text`)
- `--translation-json FILE`: JSON-Datei mit Übersetzungen für `--todxf`
- `--debug` / `-d`: Debug-Ausgabe für Pattern-Matching

### Wichtige Funktionen

#### extract_text_from_dxf(filename, text_attr_name='TEXT-D')
Extrahiert alle TEXT, MTEXT und Block-Attribute aus einer DXF-Datei.

**Parameter:**
- `filename`: Pfad zur DXF-Datei
- `text_attr_name`: Name des Text-Attributs in Blöcken (Standard: "TEXT-D")

**Rückgabe:**
- Alphabetisch sortierte Liste aller gefundenen Texte (ohne Duplikate)

#### filter_texts(texts, wildcard_patterns, regex_patterns, debug=False)
Filtert Texte basierend auf Wildcard- und Regex-Mustern.

**Parameter:**
- `texts`: Liste der zu filternden Texte
- `wildcard_patterns`: Liste der Wildcard-Muster
- `regex_patterns`: Liste der Regex-Muster
- `debug`: Debug-Ausgabe aktivieren

**Rückgabe:**
- Tuple mit (akzeptierte Texte, ignorierte Texte)

#### translate_text(text, multi, trigramme, bigramme, single)
Übersetzt einen Text durch Ersetzen von Multi-Phrasen, Trigrammen, Bigrammen und Einzelwörtern.

**Parameter:**
- `text`: Zu übersetzender Text
- `multi`: Dictionary mit Multi-Wort-Phrasen
- `trigramme`: Dictionary mit Drei-Wort-Phrasen
- `bigramme`: Dictionary mit Zwei-Wort-Phrasen
- `single`: Dictionary mit Einzelwörtern

**Rückgabe:**
- Übersetzter Text (leer wenn keine Übersetzung gefunden)

#### translate_dxf_texts(input_dxf, output_dxf, translations, ...)
Übersetzt alle TEXT, MTEXT Objekte und Text-Attribute in Blöcken einer DXF-Datei.

**Parameter:**
- `input_dxf`: Pfad zur Quell-DXF
- `output_dxf`: Pfad zur Ziel-DXF
- `translations`: Dictionary mit source -> target Mappings
- `wildcard_patterns`: Wildcard-Muster zum Filtern
- `regex_patterns`: Regex-Muster zum Filtern
- `text_source_attr`: Quell-Attributname (Standard: "TEXT-D")
- `text_target_attr`: Ziel-Attributname (Standard: "TEXT-CS")
- `target_layer`: Ziel-Layername für neue Attribute

#### retranslate_json_file(json_path, translation_dicts_all, translation_languages)
Re-übersetzt eine JSON-Datei mit neuen Übersetzungs-Configs.

**Parameter:**
- `json_path`: Pfad zur JSON-Datei
- `translation_dicts_all`: Dict mit {LANG: (multi, trigramme, bigramme, single)}
- `translation_languages`: Liste der Sprachen

### Interne Arbeitsweise

1. **Extraktion**: Texte werden aus DXF gelesen und in einem Set gespeichert (Duplikate werden entfernt)
2. **Filterung**: Ignore-Patterns werden angewendet (erst Wildcard, dann Regex)
3. **Übersetzung**: Texte werden in der Reihenfolge Multi → Trigramme → Bigramme → Single übersetzt
4. **Export**: Ergebnisse werden in gewünschte Formate geschrieben
5. **DXF-Übersetzung**: Neue DXF wird mit übersetzten Texten erstellt (Quell-Attribute bleiben erhalten)

### Block-Attribute und ATTDEF-Erstellung

Wenn ein Block noch kein ATTDEF für das Ziel-Attribut hat:

1. **ATTDEF wird erstellt** in der Block-Definition
2. **Layer wird erstellt** (falls nicht vorhanden, aus `[symbol_layer]`)
3. **Eigenschaften werden übernommen** vom Quell-ATTDEF:
   - Position (`insert`)
   - Höhe (`height`)
   - Stil (`style`)
   - Rotation (`rotation`)
   - Layer (aus Config oder vom Quell-Attribut)

### Erforderliche Block-Attribute

Blöcke müssen folgende Attribute haben, um verarbeitet zu werden:
- `IO`
- `ID`
- `VERW`
- `BEZEICHNUNG`
- `KENNZEICHNUNG`
- Quell-Textattribut (z.B. `TEXT-D`)

---

## Siehe auch

- [CLAUDE.md](../CLAUDE.md) - Allgemeine Projektdokumentation
- `cfg/translator.cfg` - Hauptkonfiguration
- `translation/*.cfg` - Sprachspezifische Übersetzungs-Configs
- `bin/tr2dxf.bat` - Zentrale Batch-Datei für Übersetzungen
- `bin/tr2dxf_*.bat` - Sprachspezifische Wrapper-Skripte