wip

rajman01 · rajman01 · commit 9ebfd2c5c0c5 · 2025-09-15T06:24:35.000+01:00
diff --git a/.gitignore b/.gitignore
@@ -66,3 +66,14 @@ Thumbs.db
 # Environment variables
 .env
 .env.*
+
+# Autocad files
+*.dwg
+*.dxf
+*.bak
+*.sv$
+*.dws
+*.dwt
+*.ac$
+*.dwl
+*.dwl2
diff --git a/app.py b/app.py
@@ -1,4 +1,7 @@
-from flask import Flask
+from flask import Flask, request, jsonify
+
+from dxf import SurveyDXFManager
+from models.plan import PlanProps
 
 app = Flask(__name__)
 app.config["SECRET_KEY"] = "secret"
@@ -8,9 +11,54 @@
 def home():
     return "<h1>Hello, Flask 👋</h1><p>You're up and running!</p>"
 
-@app.route("/plans", methods=["POST"])
-def auto_plan():
-    return ""
+@app.route("/cadastral/plan", methods=["POST"])
+def generate_cadastral_plan():
+    data = request.get_json()
+
+    plan = PlanProps(**data)
+    extent = plan.get_extent()
+    beacon_size = extent * 0.05
+
+    drawer = SurveyDXFManager(plan_name=plan.name, scale=plan.scale)
+    drawer.setup_beacon_style(type_=plan.beacon_type, size=beacon_size or 1.0)
+    drawer.setup_font(plan.font)
+
+    # Draw beacon and labels
+    for coord in plan.coordinates:
+        drawer.add_beacon(coord.easting, coord.northing, 0, beacon_size * 0.5, coord.id)
+
+    # create a dictionary of coordinates for easy lookup
+    coord_dict = {coord.id: coord for coord in plan.coordinates}
+
+    # Draw parcels
+    for parcel in plan.parcels:
+        parcel_points = []
+        for point_id in parcel.ids:
+            if point_id in coord_dict:
+                coord = coord_dict[point_id]
+                parcel_points.append((coord.easting, coord.northing, coord.elevation))
+        if parcel_points:
+            drawer.add_parcel(parcel.name, parcel_points)
+
+    # Compute extent sizes
+    min_x, min_y, max_x, max_y = plan.get_bounding_box()
+    width = max_x - min_x
+    height = max_y - min_y
+
+    # Draw frame
+    margin_x = max(width, height) * 0.4
+    margin_y = max(height, width) * 0.75
+    drawer.draw_frame(min_x - margin_x, min_y - margin_y, max_x + margin_x, max_y + margin_y)
+
+    # offset frame
+    offset_x = max(width, height) * 0.43
+    offset_y = max(height, width) * 0.78
+    drawer.draw_frame(min_x - offset_x, min_y - offset_y, max_x + offset_x, max_y + offset_y)
+
+    # add bearing and distance text
+
+    drawer.dxf_to_pdf()
+    return jsonify({"message": "Cadastral plan generated", "filename": plan.name}), 200
 
 if __name__ == '__main__':
-    app.run()
+    app.run(host="0.0.0.0", port=8080, debug=True)
diff --git a/dxf.py b/dxf.py
@@ -0,0 +1,190 @@
+import ezdxf
+import re
+from ezdxf.enums import TextEntityAlignment
+import matplotlib
+matplotlib.use("Agg")  # no GUI
+import matplotlib.pyplot as plt
+from ezdxf.addons.drawing import Frontend, RenderContext
+from ezdxf.addons.drawing.matplotlib import MatplotlibBackend
+
+class SurveyDXFManager:
+    def __init__(self, plan_name: str = "Survey Plan", scale: float = 1.0):
+        self.plan_name = plan_name
+        self.scale = scale
+        self.doc = ezdxf.new(dxfversion="R2010")
+        self.msp = self.doc.modelspace()
+        self._setup_layers()
+
+
+        # set units
+        # self.doc.header["$INSUNITS"] = 6  # meters
+
+        # dimstyle = self.doc.dimstyles.get("Standard")
+        # dimstyle.dxf.dimlunit = 2 # Decimal
+        # dimstyle.dxf.dimdec = 3  # 3 decimal places
+        # dimstyle.dxf.dimaunit = 1 # Degrees/minutes/seconds
+        # dimstyle.dxf.dimadec = 3  # 3 decimal places
+        # dimstyle.dxf.dimscale = 1.0
+
+    def _setup_layers(self):
+        """Setup standard survey layers"""
+        layers = [
+            ('POINTS', 7),  # Black/White
+            ('LINES', 1),  # Red
+            ('LABELS', 7), # Black/White
+            ('GRID', 8),  # Dark gray
+            ('FRAME', 7),  # Black/White
+            ('DIMENSIONS', 4),  # Cyan
+            ('TITLE_BLOCK', 7),  # White
+            ('TRAVERSE', 6),  # Magenta
+        ]
+
+        for name, color in layers:
+            self.doc.layers.add(name=name, color=color)
+
+    def setup_beacon_style(self, type_: str = "box", size: float = 1.0):
+        # Point styles (using blocks)
+        block = self.doc.blocks.new(name='BEACON_POINT')
+        radius = size * 0.2  # inner hatch radius
+        half = size / 2  # half-size for square
+
+        # Filled (solid hatch) circle
+        if type_ == "circle":
+            block.add_circle((0, 0), radius=size * 0.5)
+
+            # Hatched inner circle
+            hatch = block.add_hatch(color=7)  # 7 = black/white
+            path = hatch.paths.add_edge_path()
+            path.add_arc((0, 0), radius=radius, start_angle=0, end_angle=360)
+        elif type_ == "box":
+            # Square boundary
+            block.add_lwpolyline(
+                [(-half, -half), (half, -half), (half, half), (-half, half)],
+                close=True
+            )
+
+            # Hatched inner circle
+            hatch = block.add_hatch(color=7)
+            path = hatch.paths.add_edge_path()
+            path.add_arc((0, 0), radius=radius, start_angle=0, end_angle=360)
+        elif type_ == "dot":
+            # Just hatched circle (no boundary)
+            hatch = block.add_hatch(color=7)
+            path = hatch.paths.add_edge_path()
+            path.add_arc((0, 0), radius=radius, start_angle=0, end_angle=360)
+
+    def setup_font(self, font_name: str = "Arial"):
+        # Add a new text style with the specified font
+        self.doc.styles.add('SURVEY_TEXT', font=f'{font_name}.ttf')
+
+
+    def add_beacon(self, x: float, y: float, z: float = 0, text_height: float = 1.0, label=None):
+        # Add a beacon point with optional label
+        self.msp.add_blockref(
+            'BEACON_POINT',
+            (x * self.scale, y * self.scale, z * self.scale),
+            dxfattribs={'layer': 'POINTS'}
+        )
+
+        # add label
+        if label is not None:
+            self.msp.add_text(
+                label,
+                dxfattribs={
+                    'layer': 'LABELS',
+                    'height': text_height * self.scale,
+                    'style': 'SURVEY_TEXT'
+                }
+            ).set_placement(
+                (x * self.scale + 1, y * self.scale + 1)
+            )
+
+    def add_parcel(self, parcel_id: str, points: list):
+        """Add a parcel given its ID and list of (x, y) points"""
+        # scale points
+        points = [(x * self.scale, y * self.scale) for x, y, *rest in points]
+
+        self.msp.add_lwpolyline(points, close=True, dxfattribs={
+            'layer': 'LINES'
+        })
+
+        # Add parcel ID label at centroid
+        if points and parcel_id:
+            centroid_x = sum(p[0] for p in points) / len(points)
+            centroid_y = sum(p[1] for p in points) / len(points)
+            self.msp.add_text(
+                parcel_id,
+                dxfattribs={
+                    'layer': 'LABELS',
+                    'height': 2.0 * self.scale,
+                    'style': 'SURVEY_TEXT',
+                    'color': 2  # Yellow
+                }
+            ).set_placement(
+                (centroid_x, centroid_y),
+                align=TextEntityAlignment.MIDDLE_CENTER
+            )
+
+    def draw_frame(self, min_x, min_y, max_x, max_y):
+        """Draw a rectangle given min and max coordinates"""
+        self.msp.add_lwpolyline([
+            (min_x * self.scale, min_y* self.scale),
+            (max_x* self.scale, min_y* self.scale),
+            (max_x* self.scale, max_y* self.scale),
+            (min_x* self.scale, max_y* self.scale)
+        ], close=True, dxfattribs={
+            'layer': 'FRAME',
+        })
+
+    def get_filename(self):
+        plan_name = self.plan_name.lower()
+        plan_name = re.sub(r"\s+", "_",plan_name)
+        plan_name = re.sub(r"[^a-z0-9._-]", "", plan_name)
+        plan_name = re.sub(r"_+", "_", plan_name)
+        return plan_name
+
+    def save_dxf(self):
+        """Save the DXF document to a file"""
+        self.doc.saveas(f"{self.get_filename()}.dxf")
+
+
+    def dxf_to_pdf(self, margin_ratio: float = 0.05):
+
+
+        # doc = ezdxf.readfile(dxf_path)
+        # msp = doc.modelspace()
+
+        # compute bounding box
+        xs, ys = [], []
+        for e in self.msp:
+            if e.dxftype() == "LINE":
+                xs += [e.dxf.start[0], e.dxf.end[0]]
+                ys += [e.dxf.start[1], e.dxf.end[1]]
+            elif e.dxftype() == "CIRCLE":
+                xs += [e.dxf.center[0] - e.dxf.radius, e.dxf.center[0] + e.dxf.radius]
+                ys += [e.dxf.center[1] - e.dxf.radius, e.dxf.center[1] + e.dxf.radius]
+
+        if not xs or not ys:
+            xs = [0, 10]; ys = [0, 10]  # fallback box
+
+        min_x, max_x = min(xs), max(xs)
+        min_y, max_y = min(ys), max(ys)
+
+        width = max(max_x - min_x, 1)   # avoid zero
+        height = max(max_y - min_y, 1)
+
+        fig, ax = plt.subplots(figsize=(8, 8 * height / width))
+        ax.set_xlim(min_x, max_x)
+        ax.set_ylim(min_y, max_y)
+        ax.axis("off")
+
+        ctx = RenderContext(self.doc)
+        out = MatplotlibBackend(ax)
+        Frontend(ctx, out).draw_layout(self.msp, finalize=True)
+
+        pdf_path = f"{self.get_filename()}.pdf"
+        fig.savefig(pdf_path, bbox_inches="tight", pad_inches=0)
+        plt.close(fig)
+
+
+
diff --git a/models/plan.py b/models/plan.py
@@ -1,7 +1,7 @@
 from enum import Enum
 from typing import List, Optional, Union
 from datetime import datetime
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 # ---------- Enums ----------
 class PlanType(str, Enum):
@@ -21,22 +21,30 @@ class BeaconType(str, Enum):
 
 
 # ---------- Supporting models ----------
-class ParcelProps(BaseModel):
-    name: str
-    ids: List[str]
-
 class CoordinateProps(BaseModel):
-    x: float
-    y: float
-    z: Optional[float] = None
+    id: str
+    northing: Optional[float] = 0.0
+    easting: Optional[float] = 0.0
+    elevation: Optional[float] = 0.0
+
+class BearingProps(BaseModel):
+    degrees: Optional[int] = 0.0
+    minutes: Optional[int] = 0.0
+    seconds: Optional[float] = 0.0
+    decimal: Optional[float] = 0.0
 
 class TraverseLegProps(BaseModel):
-    from_: str  # `from` is reserved in Python
-    to: str
-    bearing: Optional[float] = None
-    observed_angle: Optional[float] = None
-    distance: float
+    from_: CoordinateProps = Field(alias="from")  # 👈 use alias
+    to: CoordinateProps
+    bearing: Optional[BearingProps] = None
+    observed_angle: Optional[BearingProps] = None
+    distance: Optional[float] = None
 
+class ParcelProps(BaseModel):
+    name: str
+    ids: List[str]
+    area: Optional[float] = None  # in square meters
+    legs: List[TraverseLegProps] = []
 
 # ---------- Computation models ----------
 class ForwardComputationData(BaseModel):
@@ -76,3 +84,26 @@ class PlanProps(BaseModel):
     surveyor_name: str = ""
     forward_computation_data: Optional[ForwardComputationData] = None
     traverse_computation_data: Optional[TraverseComputationData] = None
+
+    def get_extent(self) -> float:
+        # get bounding box
+        min_x, min_y, max_x, max_y = self.get_bounding_box()
+        if min_x is None or min_y is None or max_x is None or max_y is None:
+            return 0.0
+
+        width = max_x - min_x
+        height = max_y - min_y
+        extent = max(width, height)
+        return extent
+
+    def get_bounding_box(self) -> Optional[tuple]:
+        if len(self.coordinates) == 0:
+            return None
+
+        xs = [p.easting for p in self.coordinates]
+        ys = [p.northing for p in self.coordinates]
+
+        min_x, max_x = min(xs), max(xs)
+        min_y, max_y = min(ys), max(ys)
+
+        return min_x, min_y, max_x, max_y
diff --git a/requirements.txt b/requirements.txt
@@ -1,10 +1,27 @@
+annotated-types==0.7.0
 blinker==1.9.0
 click==8.2.1
 colorama==0.4.6
 comtypes==1.4.12
+contourpy==1.3.3
+cycler==0.12.1
+ezdxf==1.4.2
 Flask==3.1.2
+fonttools==4.59.2
 itsdangerous==2.2.0
 Jinja2==3.1.6
+kiwisolver==1.4.9
 MarkupSafe==3.0.2
+matplotlib==3.10.6
+numpy==2.3.3
+packaging==25.0
+pillow==11.3.0
 pyautocad==0.2.0
+pydantic==2.11.9
+pydantic_core==2.33.2
+pyparsing==3.2.4
+python-dateutil==2.9.0.post0
+six==1.17.0
+typing-inspection==0.4.1
+typing_extensions==4.15.0
 Werkzeug==3.1.3
diff --git a/utils.py b/utils.py
