Merge branch 'main' of http://gitea.schoenenberger.de/mistangl/kabellaengen

.vscode/launch.json

@@ -66,14 +66,16 @@
             ]
         },
         {
-            "name": "draw cable dxf from easy.dxf",
+            "name": "draw cable dxf from easy.json",
             "type": "debugpy",
             "request": "launch",
             "program": "${file}",
             "console": "integratedTerminal",
             "justMyCode": true,
             "args": [
-                "--filename",
+                "--json",
+                "easy.json",
+                "--dxf",
                 "easy.dxf"
             ]
         }

bin/setenv.bat

@@ -9,6 +9,7 @@ set PROJECT_LIB=%PROJECT%\lib
 set PROJECT_DATA=%PROJECT%\data
 set PROJECT_WORK=%PROJECT%\work
 set PROJECT_LOG=%PROJECT%\log
+set PROJECT_TEST=%PROJECT%\testdata
 
 if not exist %PROJECT%\work mkdir %PROJECT%\work
 if not exist %PROJECT%\log mkdir %PROJECT%\log

lib/drawdxf.py

@@ -1,11 +1,13 @@
 import argparse
 import ezdxf
-import random  # needed for random placing points
+import json
-from ezdxf.enums import TextEntityAlignment
 import os.path
 from dataclasses import dataclass, asdict, fields
 from dacite import from_dict
 from typing import List
+from datetime import datetime 
+import shutil
+
 
 
 @dataclass
@@ -16,91 +18,86 @@ class Point:
 @dataclass
 class Polyline:
     id: str
-    punkte: List[Point]
+    coords: List[Point]
 
-def get_random_point():
+    def to_tuple(self):
-    """Returns random x, y coordinates."""
+        ret = list()
-    x = random.randint(-100, 100)
+        for p in self.coords:
-    y = random.randint(-100, 100)
+            ret.append( (p.x,p.y) )
-    return x, y
+        return ret
  
-# # Create a block with the name 'FLAG'
+@dataclass
-def create_block(doc):
+class Polylines:
-    flag = doc.blocks.new(name='FLAG')
+    kabel: List[Polyline]
  
-    # Add DXF entities to the block 'FLAG'.
-    # The default base point (= insertion point) of the block is (0, 0).
-    flag.add_lwpolyline([(0, 0), (0, 5), (4, 3), (0, 3)])  # the flag symbol as 2D polyline
-    flag.add_circle((0, 0), .4, dxfattribs={'color': 2})  # mark the base point with a circle
-    return flag
 
-def create_points(msp):
+def add_polyline(msp, points:Polyline, dxf_attribs):
-    # Get 50 random placing points.
+    pts = points.to_tuple()
-    placing_points = [get_random_point() for _ in range(50)]
+    pline = msp.add_lwpolyline(points=pts, dxfattribs=dxf_attribs)
+    pline.rgb = (255, 128, 0)
 
-    for point in placing_points:
+def new_dxf(json_file, dxf_file, out_path):
-        # Every flag has a different scaling and a rotation of -15 deg.
+    """ creates a new dxf file with a polyline inside which is created by the given json file
-        random_scale = 0.5 + random.random() * 2.0
+    """
-        # Add a block reference to the block named 'FLAG' at the coordinates 'point'.
+    with open(json_file, encoding='utf-8') as fh:
-        msp.add_blockref('FLAG', point, dxfattribs={
+        data = json.load(fh)
-            'xscale': random_scale,
-            'yscale': random_scale,
-            'rotation': -15
-        })
 
-def add_text(msp):
+    anlage = from_dict(
-    # Use method set_placement() to define the TEXT alignment, because the
+        data_class=Polylines,
-    # relations between the DXF attributes 'halign', 'valign', 'insert' and
+        data=data
-    # 'align_point' are tricky.
-    msp.add_text("A Simple Text").set_placement(
-        (2, 3),
-        align=TextEntityAlignment.MIDDLE_RIGHT
         )
-
+    #print(anlage)
-    # Using a predefined text style:
-    msp.add_text(
-        "Text Style Example: Liberation Serif",
-        height=0.35,
-        dxfattribs={"style": "LiberationSerif"}
-    ).set_placement((2, 6), align=TextEntityAlignment.LEFT)
-
-def add_polyline(msp):
-    # add a LINE entity
-    msp.add_line((0, 0), (50, 0))
-
-    points = [(0, 0), (3, 0), (6, 3), (6, 6)]
-    msp.add_lwpolyline(points)  
-
-def new_dxf(path):
-    
 
     # Create a new drawing in the DXF format of AutoCAD 2010
-    doc = ezdxf.new('R2018', setup=True)
+    #doc = ezdxf.new('R2018', setup=True)
+    
+    # 1. Bestehende DXF-Datei laden
+    doc = ezdxf.readfile(dxf_file)
+    msp = doc.modelspace()
+
+    # 2. Layer mit Zeitstempel erstellen (z. B. "Layer_2025-05-07_14-30")
+    timestamp = datetime.now().strftime("Kabel_%Y-%m-%d_%H-%M")
+    if timestamp not in doc.layers:
+        doc.layers.add(name=timestamp, color=7)
 
     # add new entities to the modelspace
     msp = doc.modelspace()
     # # Beispiel für Text und Polyline
     # add_text(msp)
-    # add_polyline(msp)
+    dxfattribs={"layer": timestamp}
+    for pl in  anlage.kabel:
+        add_polyline(msp, pl, dxfattribs)
 
-    # Beispiel für Block
+    doc.saveas(out_path)
-    create_block(doc)
-    create_points(msp)
-
-    doc.saveas(path)
 
 
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(description='draws a dxf file with the given cable coordinates', prog='drawdxf')
-    parser.add_argument('-f', '--filename', action='store', required=True, default="easy.dwg", help='which file should be fetched', metavar='myfile.dwg')
+    parser.add_argument('-j', '--jsonfile', action='store', required=True, help='this json file contains all cables and its coordinates which should be drawn', metavar='myfile.json')
+    parser.add_argument('-d', '--dxf', action='store', required=True,  help='this dxf drawing will be copied and the new layer with the cables will be added', metavar='myfile.dxf')
 
     args = parser.parse_args()
 
-    work_dir = os.environ.get('PROJECT_WORK')
+    work_dir = os.fspath(os.environ.get('PROJECT_WORK'))
-    filename = os.fspath(args.filename)
+    jfile = args.jsonfile
-    path = os.path.join(work_dir, filename + '_cable.dxf')
+    dxf_file = args.dxf
 
-    if args.filename:
+    if args.jsonfile and args.dxf:
-        res_pos = new_dxf(filename)
+        jpath = os.path.join(work_dir, os.fspath(jfile))
+        dxf_path = os.path.join(work_dir, os.fspath(dxf_file))
+
+        if not os.path.exists(jpath):
+            print("file %s does not exit", jpath)
+            exit()
+        if not os.path.exists(dxf_path):
+            print("file %s does not exit", dxf_path)
+            exit()
+
+        basename = os.path.splitext(dxf_path)[0]
+        timestamp = datetime.now().strftime(basename+"_%Y%m%d-%H%M%S.dxf")
+        out_path = os.path.join(work_dir, timestamp)
+
+        # erzeuge eine neue dxf Datei mit aktuellen Zeitstempel im Namen
+        res_pos = new_dxf(jpath, dxf_path, out_path)
     else:
         parser.print_help()

work/easy.json

@@ -0,0 +1,29 @@
+{
+  "kabel": [
+    {
+      "id": "BG3241-UC0101",
+      "coords": [
+        { "x": 45, "y": 1235 }, { "x": 40, "y": 4000 }      ]
+    } ,
+    {
+      "id": "BG3240-UC0101",
+      "coords": [
+	{ "x": 4950,"y": 5595 },{ "x": 4946,"y": 5595 },{ "x": 4946,"y": 3879 },{ "x": 40,"y": 3879 },{ "x": 40,"y": 4000 }
+    
+      ]
+    },
+    {
+      "id": "FC0062-UC0101",
+      "coords": [
+	{ "x": 4975,"y": 8068 },{ "x": 4946,"y": 8068 },{ "x": 4946,"y": 3879 },{ "x": 40,"y": 3879 },{ "x": 40,"y": 4000 }    
+      ]
+    },
+    {
+      "id": "MA0062-UC0101",
+      "coords": [
+	{ "x": 4975,"y": 8068 },{ "x": 4946,"y": 8068 },{ "x": 4946,"y": 3879 },{ "x": 40,"y": 3879 },{ "x": 40,"y": 4000 }
+      ]
+    }
+  ]
+}
+