PlanX CAD Toolset

6 Tools with Precision Input

• Line L: 2-click straight segment. Auto-finishes after second click. Builds QgsGeometry.fromPolylineXY().
• Polyline PL: N-click chain; Enter/right-click to finish; Backspace to undo last vertex. Arbitrary vertex count.
• Rectangle REC: 2 opposite-corner clicks. Geographic-safe: transforms corners to local UTM before computing right-angle corners. Builds closed-ring polygon.
• Polygon POL: Dialog for N sides (3–100). Click centre, then radius and orientation. Distributes sides vertices around centre at radius starting from the cursor bearing. Geographic-safe via local UTM.
• Circle C: Centre + edge point. 64-segment circle. Geographic-safe: center.buffer(radius, 64) in local UTM.
• Arc A: 3-point arc via circumcircle. Solves centre using determinant formula: \(D = 2[x_a(y_b - y_c) + x_b(y_c - y_a) + x_c(y_a - y_b)]\). Produces 32-segment arc following the shortest angular path through the intermediate point.

All drawing tools support native QGIS snapping, Backspace undo, Enter finish, and Escape cancel.

Offset, Fillet, Chamfer, Break, Lengthen

Offset O: Enter distance, click side for preview. Uses QgsGeometry.offsetCurve() with round join style in local metric CRS. Computes both left and right offsets, picks nearest to click point.

Buffer B: Dialog for distance, join style (Round/Bevel/Miter), segment count. Pick any readable feature. Output to managed planx_buffer layer.

Hatch H: Pick polygon. Dialog for pattern (parallel/cross/diagonal), spacing, angle, colour. Algorithm creates parallel lines spanning the polygon bounding box diagonal at the specified angle, clips each against the polygon via line.intersection(polygon). Works in local UTM. Max 20,000 candidate lines.

Construction XL/RAY/SEG: Three modes. Infinite mode extends through both points by 10x canvas diagonal. Ray extends from first through second. Segment is bounded. Writes to planx_construction layer with dashed cyan style.

Divide DIV: Dialog for segment count (2–10,000) and method. Split mode uses QgsGeometry.interpolate() at regular intervals along cumulative distance. Points mode creates points on planx_divisions layer.

Multi-Offset MO: Comma-separated distances; left/right/both/pick-side modes. Batched undo for all offsets.

Tangent Arc and Straight Corner Resolution

Both operations follow a common two-step pattern: (1) find intersection of two picked lines, (2) compute cutback points and connection geometry.

Fillet algorithm (create_fillet_and_trims()):

1. Find the intersection point of the two input lines via line_intersection() (determinant-based 2D line intersection).
2. Determine unit vectors from the intersection toward the "keep" end of each line.
3. Compute included angle: \(\theta = \arccos(\mathbf{v}_1 \cdot \mathbf{v}_2)\), clamped to \([-1, 1]\).
4. Tangent distance: \(d_t = r / \tan(\theta/2)\).
5. Tangent points: \(\mathbf{tp}_i = \mathbf{p}_{\mathrm{inter}} + d_t \cdot \mathbf{v}_i\).
6. Arc centre along bisector: \(d_c = r / \sin(\theta/2)\), \(\mathbf{c} = \mathbf{p}_{\mathrm{inter}} + d_c \cdot \frac{\mathbf{v}_1 + \mathbf{v}_2}{\|\mathbf{v}_1 + \mathbf{v}_2\|}\).
7. Construct 20-segment arc through the shortest angular sweep (not forced CCW).
8. Snap first and last arc points exactly to tangent points for topology safety.

Chamfer algorithm (create_chamfer_and_trims()): Similar to fillet but produces a straight line. Cut back along each direction vector by user-specified distances \(d_1\) and \(d_2\). Validates that cutback does not exceed the available leg length. If "equal" checkbox is active, \(d_1 = d_2\). Rejects cutbacks longer than the retained leg.

Both operations work on a single edit command spanning both layers. Live preview shows the arc/line on hover before the final click. Trim operations trim each line to its tangent/cutback point via trim_line_to_point().

Line-Endpoint Operations

Trim TR: Pick cutting boundary, then target line region to remove. Splits target at intersection points via splitGeometry(). Keeps all parts except the one nearest the click point. For multi-part layers, adds extra parts as new features with copied attributes. Fallback: subtracts narrow buffer around cutting boundary.

Extend EX: Pick boundary, then line to extend. Projects a ray from the terminal segment direction, extends by the bounding box diagonal length, intersects with boundary geometry. Picks nearest forward intersection point. Appends to line preserving all existing vertices.

Break BR: Pick line, click two break points or Enter after one for break-at-point. Uses line_substring() which walks cumulative segment distances preserving interior vertices. Single-point mode splits at point; two-point mode creates a gap (first part + remainder).

Lengthen LEN: Three modes. Delta: target = current + value (negative shortens). Percent: target = current × value / 100. Total: target = value. Shortening uses line_substring() from the appropriate end. Extending moves the terminal vertex along the terminal segment direction by the extra distance. Pick the line near the end to modify.

Join, Align, Stretch, Explode, Vertex Edit

Join J: Multiple picks (left-click to add, right-click to finish). Dialog tolerance. Iteratively welds paths by checking all four endpoint-pair cases with tolerance distance. Result replaces first feature; deletes originals.

Align AL: Pick feature, source1→dest1, source2→dest2. Enter after first pair = translate only. Optional scaling by pair length ratio. Transform: translate(-src1) + rotate + translate(+dst1) composed into a single QTransform. Two-pair mode derives rotation from source and destination vectors; scale factor = |dest_vector| / |source_vector|.

Stretch S: Crossing window defines vertices to move by (dx, dy). Iterates all vertices; moves those inside QgsRectangle. Operates across all editable layers simultaneously. Polygon rings stay closed. Returns None if no vertex falls in window.

Explode X: Parts mode splits multipart via asGeometryCollection(). Segments mode splits lines/polygon boundaries into individual two-point segments. Optional source removal. Writes to planx_explode layer for cross-type explosions.

Vertex Edit VE: Renders all vertices as orange QgsVertexMarker box handles. Drag to move (via moveVertex()), right-click to delete (via deleteVertex()), click on line to insert (via insertVertex()). Multipart-safe with part/vertex index tracking. Refuses operations leaving fewer than 2 (line) or 4 (polygon ring) vertices.

Affine Transformations with Precision

Move M / Copy CO: Base point + target point. Translation via QgsGeometry.translate(dx, dy). Copy duplicates geometry + attributes as new feature. Both support precision input (relative, polar, direct distance).

Rotate RO: Centre + reference direction + target angle. Hold Ctrl for 90-degree snap (round(angle/90) × 90). Accepts direct angle entry. Uses QgsGeometry.rotate() in local metric CRS.

Scale SC: Centre + reference distance + target distance. Factor = target / reference. Matrix: QTransform(factor, 0, 0, factor, cx(1-factor), cy(1-factor)).

Mirror MI: Two-point axis. Reflection matrix from normalised axis direction (ux, uy): \(m_{11} = 2u_x^2 - 1\), \(m_{12} = m_{21} = 2u_x u_y\), \(m_{22} = 2u_y^2 - 1\), translation = (start - m*start). Adds mirrored copy; never modifies original.

Array AR: Dialog for rectangular (rows, cols, dx, dy) or polar (count, sweep angle) parameters. Rectangular: nested-loop translation. Polar: equal-angle rotation around centre. Max 10,000 copies. Live preview via unaryUnion().

All transforms are multipart, curve, and Z/M-safe via QTransform-based affine operations.

Road Platform Generator ROAD

Dialog: road type (Vehicular/Pedestrian/Bicycle/Collector/Arterial), direction, lane count (1–8), lane width (2–10 m), median width (0–20 m), sidewalks (0–10 m each side). Live total width readout. Sketch centreline on canvas. RoadGenerator.generate() offsets centreline in local CRS for each lane, median, and sidewalk edge. Writes to planx_road_platform MultiLineString layer with 11 attribute fields (road_id, road_type, component, side, lane_no, lane_width, median_width, sidewalk_left, sidewalk_right, direction, visible). Supports one-way and two-way generation.

Block Chamfer BLOCK

One-click corner resolution. Straight mode: finds two nearest intersecting line features near click point, trims both by distance along each line from the intersection, adds straight connection. Curved mode: uses same fillet geometry as the Fillet tool. Remnant cleanup: deletes lines shorter than the cleanup threshold within tolerance of the corner centre. Supports sequential corners (click→result→click→result...).

Geometric Intersection Resolution (JUNCTION)

The junction solver (urban/junction_geometry.py) is a pure-geometry module operating on curb half-edges. Its algorithm proceeds through five phases:

1. Half-edge extraction: Click the junction centre. Creates a circular buffer at the specified impact radius (3–100 m). Intersects with road platform features. Extracts outward curb rays (CurbHalfEdge objects) with cut points, outward direction vectors, and road/component metadata.
2. Approach clustering (cluster_approaches()): Groups half-edges by road ID, sorts by angle, clusters edges within an angular tolerance (default 12°). Merges wrap-around clusters near 0/360°. Discards clusters with fewer than 2 edges. Each cluster becomes an Approach with left_curb() and right_curb() (signed lateral offset via cross product).
3. Sector pairing: For each approach in counter-clockwise order, the active corner sector spans between the current approach's left curb and the next approach's right curb. Sectors with sweep angle ≥ π (straight-through or reflex) are skipped—these are not local corners.
4. Corner solving: Uses the support_line_intersection() method (2D cross-product intersection of directed support lines). Chamfer mode: extends from intersection by distance along each ray, connects with straight line. Fillet mode: uses the tangent-circle algorithm from the Fillet tool, adapted for directed rays. Validates each solution against distance constraints.
5. Application: Trims road platform components at tangent/cutback points. Creates connection geometry (arc or line) from the first road's attributes. Optionally creates round or teardrop traffic islands on planx_junction_islands layer. All within a single rollback-safe edit command.

Four Input Formats, Metre-Accurate in All CRS

The precision input system (core/precision_input.py) supports four coordinate formats, all resolved through a local UTM work CRS for metre-accuracy:

• x,y — absolute Cartesian coordinates in the canvas CRS.
• @dx,dy — relative Cartesian offset in metres (not canvas units). Transforms base point to local UTM, adds dx,dy, transforms back.
• @distance<angle — relative polar: distance in metres, angle in degrees. Computes target as: target = base + distance × (cos(angle), sin(angle)) in local UTM.
• distance — direct distance along the cursor bearing in metres. Transforms both base and cursor to UTM, normalises direction vector, scales by distance.

Type a number, minus sign, or @ directly on the canvas, or focus the command line with Ctrl+Shift+S. Supported by Line, Polyline, Rectangle, Circle, Polygon, Arc, Move, Copy, Rotate, and Scale.

AutoCAD-Style Command Interface

The dock includes a command line (CommandLineEdit) with: muscle-memory aliases (65 entries: L = Line, TR = Trim, CO = Copy, F = Fillet, CHA = Chamfer, XL = Construction Infinite, DIM = Dimension, etc.), full autocomplete by alias, tool key, and fuzzy name match (QCompleter with PopupCompletion), 50-entry history ring with consecutive duplicate skipping, empty-Enter to repeat the last tool or finish an in-progress sketch, and session persistence for recent tools and pinned favourites. Ctrl+Shift+Space repeats the last tool instantly. Ctrl+Shift+S focuses the command line. Ctrl+Shift+Q opens the Command Palette dialog with fuzzy search across all 39 tools.

Eight Output Layers, Auto-Created on First Use

The plugin uses managed memory layers for output tools rather than writing to the user's active layer:

Layers are reused across sessions: get_or_create_layer() searches existing project layers by name, validates WKB type, CRS, and field schema. If no compatible layer exists, creates a new in-memory layer. The road platform layer supports bilingual (English/Turkish) schemas with road_field_name() translation for legacy compatibility.

Local Metric Work CRS for Distance-Bearing Operations

The function local_metric_crs(point, source_crs) creates a local work CRS where distances are true metres:

1. Transform the work point to WGS84 geographic coordinates.
2. For normal latitudes (−80° to 84°): compute UTM zone as \(\lfloor(\lambda + 180)/6\rfloor + 1\), EPSG = 32600 + zone (north) or 32700 + zone (south).
3. For polar regions: use Azimuthal Equidistant projection (AEQD) centred on the work point, which preserves distances and angles from the centre.

This CRS is used by: precision input resolution, rotate/mirror operations, circle/polygon/rectangle geometry building in geographic projects, offset/fillet/chamfer/hatch, road generator, junction solver, and block chamfer. Each operation gets its own CRS based on its specific work location, so even operations far apart in the project receive the appropriate zone.

Transactional Geometry Operations

Every geometry-modifying operation uses beginEditCommand()/endEditCommand() for transactional safety with full rollback on failure. Multi-layer operations (Fillet, Chamfer, Junction) open edit commands on all involved layers simultaneously and only commit if all succeed. The Junction solver keeps its edit command open across trim operations, corner connection adds, and median cap creation. Tools that write to managed layers check layer.isEditable() before starting their own session; if the layer is already being edited by the user, they use the existing session without auto-committing. Drawing tools auto-start editing if the target layer is not already editable.

For single-part layers, operations that would produce disconnected MultiLineString results (Trim, Divide) replace the original feature with the first part and add remaining parts as new features with copied attributes incremented through the self-pick exclusion buffer.