wip

Author: rajman01

.gitignore

@@ -77,3 +77,4 @@ Thumbs.db
 *.ac$
 *.dwl
 *.dwl2
+*.pdf

app.py

@@ -1,7 +1,10 @@
+import math
+
 from flask import Flask, request, jsonify
 
 from dxf import SurveyDXFManager
 from models.plan import PlanProps
+from utils import polygon_orientation, line_normals, line_direction
 
 app = Flask(__name__)
 app.config["SECRET_KEY"] = "secret"
@@ -17,29 +20,76 @@ def generate_cadastral_plan():
 
     plan = PlanProps(**data)
     extent = plan.get_extent()
-    beacon_size = extent * 0.05
+    beacon_size = extent * 0.02
 
     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)
 
+    label_height = extent * 0.015 if extent > 0 else 1.0
+
     # 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}
+    parcel_dict = {}
 
     # 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))
+                parcel_points.append((coord.easting, coord.northing))
         if parcel_points:
             drawer.add_parcel(parcel.name, parcel_points)
 
+            # add bearing and distance text
+            orientation = polygon_orientation(parcel_points)
+            for leg in parcel.legs:
+                # compute rotational angle for text
+                angle_rad = math.atan2(leg.to.northing - leg.from_.northing, leg.to.easting - leg.from_.easting)
+                angle_deg = math.degrees(angle_rad)
+
+                first_x = leg.from_.easting + (0.2 * (leg.to.easting - leg.from_.easting))
+                first_y = leg.from_.northing + (0.2 * (leg.to.northing - leg.from_.northing))
+                last_x = leg.from_.easting + (0.8 * (leg.to.easting - leg.from_.easting))
+                last_y = leg.from_.northing + (0.8 * (leg.to.northing - leg.from_.northing))
+                mid_x = (leg.from_.easting + leg.to.easting) / 2
+                mid_y = (leg.from_.northing + leg.to.northing) / 2
+
+                # Offset text above/below the line
+                normals = line_normals((leg.from_.easting, leg.from_.northing), (leg.to.easting, leg.to.northing), orientation)
+                offset_distance = extent * 0.02
+                offset_inside_x = (normals[0][0] / math.hypot(*normals[0])) * offset_distance
+                offset_inside_y = (normals[0][1] / math.hypot(*normals[0])) * offset_distance
+                offset_outside_x = (normals[1][0] / math.hypot(*normals[1])) * offset_distance
+                offset_outside_y = (normals[1][1] / math.hypot(*normals[1])) * offset_distance
+                first_x += offset_outside_x
+                first_y += offset_outside_y
+                last_x += offset_outside_x
+                last_y += offset_outside_y
+                mid_x += offset_inside_x
+                mid_y += offset_inside_y
+
+                # add texts
+                text_angle = angle_deg
+                if text_angle > 90 or text_angle < -90:
+                    text_angle += 180
+
+                drawer.add_text(f"{leg.distance:.2f} m", mid_x, mid_y, angle=text_angle, height=label_height)
+                ld = line_direction(angle_deg)
+                print(leg.from_.id, leg.to.id, ld)
+                if ld == "left → right":
+                    drawer.add_text(f"{leg.bearing.degrees}°", first_x, first_y, angle=text_angle, height=label_height)
+                    drawer.add_text(f"{leg.bearing.minutes}'", last_x, last_y, angle=text_angle, height=label_height)
+                else:
+                    drawer.add_text(f"{leg.bearing.degrees}°", last_x, last_y, angle=text_angle, height=label_height)
+                    drawer.add_text(f"{leg.bearing.minutes}'", first_x, first_y, angle=text_angle, height=label_height)
+            parcel_dict[parcel.name] = parcel_points
+
     # Compute extent sizes
     min_x, min_y, max_x, max_y = plan.get_bounding_box()
     width = max_x - min_x
@@ -55,9 +105,14 @@ def generate_cadastral_plan():
     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
+    # add title block
+    box_width = (max_x + margin_x) - (min_x - margin_x) * 0.6
+    title_x = ((min_x - margin_x) + (max_x + margin_x)) / 2
+    title_y = (max_y + margin_y) - (margin_y * 0.15)
+    text_height = plan.font_size or ((max_y + margin_y) - (min_y - margin_y)) * 0.02
+    drawer.add_title(plan.title.upper(), title_x, title_y, width=box_width, height=text_height)
 
-    drawer.dxf_to_pdf()
+    drawer.save_dxf()
     return jsonify({"message": "Cadastral plan generated", "filename": plan.name}), 200
 
 if __name__ == '__main__':

dxf.py

@@ -1,6 +1,6 @@
 import ezdxf
 import re
-from ezdxf.enums import TextEntityAlignment
+from ezdxf.enums import TextEntityAlignment, MTextParagraphAlignment
 import matplotlib
 matplotlib.use("Agg")  # no GUI
 import matplotlib.pyplot as plt
@@ -125,6 +125,31 @@ def add_parcel(self, parcel_id: str, points: list):
                 align=TextEntityAlignment.MIDDLE_CENTER
             )
 
+    def add_text(self, text: str, x: float, y: float, angle: float = 0.0, height: float = 1.0):
+        """Add arbitrary text at given coordinates with optional rotation"""
+        self.msp.add_text(
+            text,
+            dxfattribs={
+                'layer': 'LABELS',
+                'height': height * self.scale,
+                'style': 'SURVEY_TEXT',
+                'rotation': angle
+            }
+        ).set_placement(
+            (x * self.scale, y * self.scale),
+            align=TextEntityAlignment.MIDDLE_CENTER
+        )
+
+    def add_title(self, text: str, x: float, y: float, width: float, height: float = 1.0):
+        print(width)
+        """Add title text at given coordinates with optional rotation"""
+        mtext = self.msp.add_mtext(text, dxfattribs={'layer': 'TITLE_BLOCK', 'style': 'SURVEY_TEXT'})
+        mtext.set_location((x * self.scale, y * self.scale))
+        mtext.dxf.char_height = height * self.scale
+        mtext.dxf.width = 60
+        mtext.dxf.attachment_point = 2  # top center
+        # mtext.dxf.paragraphs = MTextParagraphAlignment.JUSTIFIED
+
     def draw_frame(self, min_x, min_y, max_x, max_y):
         """Draw a rectangle given min and max coordinates"""
         self.msp.add_lwpolyline([
@@ -149,14 +174,15 @@ def save_dxf(self):
 
 
     def dxf_to_pdf(self, margin_ratio: float = 0.05):
+        self.save_dxf()
 
-
-        # doc = ezdxf.readfile(dxf_path)
-        # msp = doc.modelspace()
+        dxf_path = f"{self.get_filename()}.dxf"
+        doc = ezdxf.readfile(dxf_path)
+        msp = doc.modelspace()
 
         # compute bounding box
         xs, ys = [], []
-        for e in self.msp:
+        for e in msp:
             if e.dxftype() == "LINE":
                 xs += [e.dxf.start[0], e.dxf.end[0]]
                 ys += [e.dxf.start[1], e.dxf.end[1]]
@@ -178,9 +204,11 @@ def dxf_to_pdf(self, margin_ratio: float = 0.05):
         ax.set_ylim(min_y, max_y)
         ax.axis("off")
 
-        ctx = RenderContext(self.doc)
+        ctx = RenderContext(doc)
         out = MatplotlibBackend(ax)
-        Frontend(ctx, out).draw_layout(self.msp, finalize=True)
+        out.set_background("black")
+        # out.set_color_mapper(lambda entity: 'black' if entity.dxf.color == 7 else None)
+        Frontend(ctx, out).draw_layout(msp, finalize=True)
 
         pdf_path = f"{self.get_filename()}.pdf"
         fig.savefig(pdf_path, bbox_inches="tight", pad_inches=0)

utils.py

@@ -0,0 +1,25 @@
+def polygon_orientation(coords):
+    # coords = [(x1,y1), (x2,y2), ...]
+    area = 0
+    for i in range(len(coords)):
+        x1, y1 = coords[i]
+        x2, y2 = coords[(i + 1) % len(coords)]
+        area += (x2 - x1) * (y2 + y1)
+    return "CW" if area > 0 else "CCW"
+
+def line_normals(p1, p2, orientation="CCW"):
+    dx, dy = p2[0]-p1[0], p2[1]-p1[1]
+    if orientation == "CCW":  # inside = left normal
+        inside = (-dy, dx)
+        outside = (dy, -dx)
+    else:  # CW polygon
+        inside = (dy, -dx)
+        outside = (-dy, dx)
+    return inside, outside
+
+def line_direction(angle) -> str:
+    # Normalize angle between -180 and 180
+    if -90 <= angle <= 90:
+        return "left → right"
+    else:
+        return "right → left"