PlanX CAD Toolset

1. How It Works

The tool subclasses SketcherBase. Each canvas press is first routed through QGIS's native QgsSnappingUtils.snapToMap(), so the point is snapped before it is stored. Once two vertices are recorded the tool auto-finishes, building the geometry with QgsGeometry.fromPolylineXY(vertices) and writing it to the active line layer through add_geometry_to_current_layer(), which auto-starts editing, transforms canvas CRS to layer CRS when they differ, and rejects a geometry-type mismatch.

2. Interaction

3. Output & Behaviour

A LineString feature is added to the active editable line layer. Attributes take the layer's default values. The tool stays active after committing, so consecutive lines can be drawn without re-issuing the command.

4. Usage & Tips

1. How It Works

Each left-click appends a snapped vertex; the vertex count is unbounded. Right-click or Enter finishes once at least two vertices exist; Backspace/Z pops the last vertex and rebuilds the rubber-band preview; Esc cancels. On finish the tool builds QgsGeometry.fromPolylineXY(vertices) and commits to the active line layer.

2. Interaction

3. Output & Behaviour

A single LineString feature with an arbitrary number of vertices is added to the active line layer. Unlike a series of Lines, the whole chain is one feature — one attribute row, one selectable object, one geometry for downstream editing.

4. Usage & Tips

1. How It Works

Two opposite-corner clicks are recorded. The four corners are formed by swapping the x and y of the two picked points:

The ring is closed by repeating the first point. In a projected CRS the corner swap happens directly in canvas units; in a geographic CRS both corners are first transformed to local_metric_crs(first, canvas_crs), the axis-aligned corner swap is performed there, and all five points are transformed back — so the sides are right-angle and parallel in metres, not in degrees. The result is a closed-ring polygon.

2. Interaction

3. Output & Behaviour

A Polygon feature (closed ring) is added to the active polygon layer. The tool auto-finishes after the second click and stays active for the next rectangle.

4. Usage & Tips

1. How It Works

On activation a side-count dialog is shown. The first canvas click places the centre; the second places an edge point. The vertex set is computed as:

Vertices are evenly spaced at 2π/sides increments; the first vertex sits on the bearing from the centre to the second click (so the user controls orientation by where they place the edge point), and the ring is closed by emitting sides + 1 points. Geographic CRS → local-metric round-trip as with Rectangle. The result is a closed-ring polygon.

2. Parameters

3. Interaction

4. Output & Behaviour

A regular Polygon is added to the active polygon layer. Orientation is under direct user control via the second click's bearing.

5. Usage & Tips

1. How It Works

The first click is the centre, the second the radius point. In a projected CRS the radius is the Euclidean distance between the two points and the circle is produced with QgsGeometry.fromPointXY(center).buffer(radius, SEGMENTS) where SEGMENTS = 64. In a geographic CRS the centre and radius point are transformed to the local metric CRS, the radius recomputed with math.hypot(dx, dy), the buffer produced there, and the result transformed back — so the circle's radius is a true metre distance on the ground.

2. Interaction

3. Output & Behaviour

A Polygon (64 segments) is added to the active polygon layer. The 64-segment discretisation is fixed, not adaptive, so very large circles are piecewise-linear to that resolution.

4. Usage & Tips

1. How It Works

Three clicks are recorded. The tool solves the circumcircle of the three points using the standard determinant formula:

If |D| < 10⁻¹⁰ the points are collinear and the tool returns a straight polyline instead. Otherwise the radial angles a1, a2, a3 are computed with atan2 and normalised to [0, 2π). The sweep direction is decided by whether d12 < d13 (where d12 = (a2−a1) mod 2π, d13 = (a3−a1) mod 2π): the arc travels from a1 to a3 through the intermediate angle a2. The arc is then discretised into ARC_SEGMENTS = 32 equal steps (33 emitted points) and stored as a LineString.

2. Geometric Formulation

This is the three-point-circumcircle construction (see O'Rourke 1998 and the Graphics Gems collections). Note two deliberate behaviours. First, the arc is not forced to be the shorter of the two possible arcs: it is the arc that passes through the intermediate point, so a three-point arc spanning more than 180° produces a major arc. Second, the segment count is fixed at 32 — the arc is a polyline approximation of a true circle, not a QGIS curve geometry, so it can live on a plain line layer.

3. Interaction

4. Output & Behaviour

A 32-segment LineString arc is added to the active line layer. Collinear input degenerates to a straight three-point polyline rather than failing.

5. Usage & Tips

6. Literature

O'Rourke, J. (1998). Computational Geometry in C (2nd ed.) — the circumcircle and collinearity test used here. Goldman, R. (2003). Pyramid Algorithms — parametric circle/arc evaluation. Glassner, A. S. (Ed.) (1990). Graphics Gems — robust three-point circle fitting. Full citations in the references appendix.

1. Modes

2. How It Works

Two clicks define the direction. The infinite and ray modes extend by _INF_EXTEND_FACTOR = 10.0 times the canvas diagonal so the reference line always spans the visible canvas (and re-extends on pan/zoom). A degenerate two-click pair (norm ≤ 1e-9) is returned as-is rather than failing. Each line is written as a LineString to the managed planx_construction layer and styled with a dashed cyan pen (0,188,212, width 0.4, round cap) applied once via a custom-property guard.

3. Interaction

4. Output & Behaviour

5. Usage & Tips

1. How It Works

After the distance is entered and the feature picked, the tool transforms the feature into a local metric CRS (from the feature centroid) so the distance is true metres. It computes QgsGeometry.offsetCurve(distance, 8, Qgis.JoinStyle.Round, 2.0) on both sides, then selects the side whose result is nearer the click point (left.distance(click) vs right.distance(click)). The chosen curve is transformed back to the layer CRS and added as a new feature with attributes copied from the source.

2. Parameters

3. Interaction

4. Output & Behaviour

A new parallel feature is added to the picked layer, with all attributes copied from the source. A valid source CRS is required; if only one side is computable it is used, and if neither is, the tool reports Offset could not be calculated.

5. Usage & Tips

6. Literature

The parallel-curve (offset) construction and its straight-skeleton relationship follow from de Berg et al. (2008); the round-join offsetCurve is QGIS's GEOS implementation of that construction. See the references appendix.

1. Parameters

2. How It Works

Distances are parsed by splitting on commas. For each distance the tool calls the shared offset_geometry helper — offsetCurve(d, 8, Qgis.JoinStyle.Round, 2.0) — on the requested side(s), transforms results back to the layer CRS, and batch-adds them as new features with copied attributes. In Pick Side on Canvas mode the first distance is tested on both sides and the nearer is chosen.

3. Interaction

4. Output & Behaviour

Parallel lines are added to the source layer (attributes copied). Line geometry only; an empty geometry or a list with no valid distance is reported as an error rather than silently producing nothing.

5. Usage & Tips

1. How It Works

The first click selects the cutting boundary; the second click re-picks a target feature excluding the boundary (self-pick protection). The boundary is transformed into the target's CRS, and intersection points are computed, ordered along the target with lineLocatePoint, and used to split it with splitGeometry(points, False). The segment nearest the click is removed and the rest kept. If the split yields fewer than two segments, a fallback subtracts a narrow buffer (cutting.buffer(0.001, 4)) and keeps the part farthest from the click.

2. Interaction

3. Output & Behaviour

The target feature's geometry is replaced with the kept portion. On a single-part layer, if a second surviving part results it is added as a new feature with copied attributes (edit command PlanX CAD: trim). A feature cannot trim itself; a non-intersecting boundary produces no change.

4. Usage & Tips

1. How It Works

After the boundary is picked, the target's final segment direction is read and a ray is projected whose length is max(distance(endpoint, bbox_corner)) * 1.01 + segment_length over the four boundary bounding-box corners (an overshoot factor of 1.01 guarantees the ray clears the boundary). The ray is intersected with the boundary, only candidate vertices in front of the endpoint are kept (along > max(length·1e-9, 1e-12)), and the nearest one is appended to the line, preserving every existing vertex.

2. Interaction

3. Output & Behaviour

The target feature's geometry is updated with the extension appended. The boundary is excluded from the second pick (no self-extend). If no forward intersection exists, the tool reports Extension failed.

4. Usage & Tips

1. How It Works

The radius is entered first, then the two lines are picked. The tool solves in a local metric CRS: find the intersection point, the unit vectors toward the retained end of each line, and the included angle. Tangent distance and arc centre are computed from the radius, the arc is built through the shortest angular sweep with segments = 20, and each line is trimmed to its tangent point via trim_line_to_point. Both trims and the arc are written in a single PlanX CAD: fillet edit command.

2. Geometric Formulation

Let r be the fillet radius and θ the included angle between the two lines at their intersection. The tangent distance from the intersection to each tangent point, and the distance to the arc centre along the angle bisector, are:

Tangent points are tpi = pinter + dt·vi; the centre is c = pinter + dc·(v₁+v₂)/|v₁+v₂|. The 20-segment arc runs through the shortest angular sweep and its first/last points are snapped exactly to the tangent points for topology safety. Parallel or collinear lines yield no result, and a line cannot fillet against itself.

3. Parameters

4. Output & Behaviour

Both source lines are trimmed to their tangent points, and a new arc feature is added to the first line's layer (attributes copied from the first feature). The whole operation is atomic — one edit command, full rollback on failure.

5. Usage & Tips

6. Literature

The tangent-circle fillet is the canonical computational-geometry construction — see de Berg et al. (2008) and O'Rourke (1998). The bisector solution (r/tan(θ/2), r/sin(θ/2)) is the standard treatment in Farin (2002). Full citations in the references appendix.

1. How It Works

Two cutback distances are collected (optionally equal). The intersection point and retained-end unit vectors are computed, cutback points are placed at dist1 and dist2 along each line, and a straight line connects them. Both source lines are trimmed to their cutback points and the chamfer line is added to the first layer in a single PlanX CAD: chamfer edit command. A cutback longer than the retained leg is rejected, as are parallel/collinear lines.

2. Parameters

3. Interaction

4. Output & Behaviour

Both lines are trimmed to their cutback points and a new chamfer line feature is added to the first layer (attributes copied). Distances stay metre-accurate in geographic projects via the local metric CRS.

5. Usage & Tips

1. How It Works

Both break points are located along the line with lineLocatePoint, with a numeric tolerance of max(total·1e-9, 1e-12). One point splits into [0, first] and [first, total]; two points keep [0, low] and [high, total] (removing the span between). Segmentation uses line_substring, which walks cumulative segment distances and therefore preserves every interior vertex of the original. The first part replaces the feature; the second is added as a new feature with copied attributes.

2. Interaction

3. Output & Behaviour

The picked feature keeps the first part; the remainder is added as a new feature with the same attributes. A break point must lie strictly between the line's endpoints; a break on an endpoint is refused. A gap reaching an endpoint simply shortens the line.

4. Usage & Tips

1. How It Works

The clicked end is identified, then the target length is computed by mode: delta → current + value, percent → current·value/100, total → value. If the target is shorter than the current length, the line is trimmed via line_substring; if longer, the terminal vertex is moved along the terminal segment's direction by the extra distance. Values are metres and remain metre-accurate in geographic projects.

2. Parameters

3. Interaction

4. Output & Behaviour

The selected feature is modified in place. A target ≤ 1e-9 is rejected; empty or CRS-failed geometry is skipped. Shortening trims cleanly through interior vertices.

5. Usage & Tips

1. How It Works

One source→destination pair applies a pure translation. Two pairs derive a rotation from the difference of the two direction vectors and, when scaling is enabled, a factor target_length / source_length. The full transformation is composed into a single QTransform(m11, m12, m21, m22, dx, dy) — pre-translate by −src1, rotate/scale, then translate by +dst1 — and applied through one affine transform, so curves and Z/M values survive intact. Degenerate source lengths (≤ 1e-12) are rejected.

2. Parameters

3. Interaction

4. Output & Behaviour

The selected feature is modified in place. Precision input is supported for the point picks.

5. Usage & Tips

1. How It Works

Two opposite clicks define the crossing window. The tool iterates every editable vector layer, transforms the window into each layer's CRS, and selects features that intersect it. For each selected feature it iterates the geometry's vertices and applies moveVertex(point + (dx, dy)) only to vertices inside the window. Edits are grouped per layer and applied with changeGeometry in a per-layer edit command. Polygon rings stay closed, and a failed write rolls back all edited layers.

2. Interaction

3. Output & Behaviour

Vertices of one or more features move, potentially across multiple layers. A zero-area window or a window that crosses no editable feature is rejected. Polygon rings remain closed, so areas stay valid.

4. Usage & Tips

1. How It Works

In parts mode, a multipart feature is decomposed via asGeometryCollection(). In segments mode, polygon rings and lines are broken into two-point segments (skipping zero-length segments ≤ 1e-12). Pieces that match the source layer's geometry type are added to the same layer; otherwise they go to the managed planx_explode line layer (because a polygon layer cannot hold segment lines). If remove source is on, the original is deleted.

2. Parameters

3. Interaction

4. Output & Behaviour

Pieces land on the source layer (or planx_explode for cross-type segment output). A single-part feature cannot be split in parts mode; polygon segments always route to the managed line layer.

5. Usage & Tips

1. How It Works

The feature is transformed to a local metric CRS, buffered with buffer(distance, segments, Qgis.EndCapStyle.Round, join_enum, 2.0) (miter limit 2.0), transformed back, and written to planx_buffer with source_layer, buffer_distance, and join_style attributes. The source only needs to be readable (require_editable = False).

2. Parameters

3. Interaction

4. Output & Behaviour

5. Usage & Tips

1. How It Works

In a local metric CRS the tool computes the polygon's bounding-box diagonal (diag = hypot(w, h)·1.2 + spacing·2) and the number of candidate lines (n_steps = int(diag/spacing) + 2), refusing when 2·n_steps + 1 > 20 000. Parallel lines are generated across the box at the chosen angle(s) and each is clipped against the polygon with line.intersection(polygon); multi-line results are split to single parts. Angles map as parallel → [angle], diag_up → [45°], diag_down → [−45°], cross → [angle, angle+90°].

2. Parameters

3. Interaction

4. Output & Behaviour

5. Usage & Tips

1. How It Works

Cumulative distances are computed per part. In split mode, seg_len = total/N and each boundary is located with interpolate(), preserving interior vertices; the first segment replaces the source feature and the rest are added with copied attributes. In points mode, points are placed at interpolate(i·seg_len) for i = 1…N−1, written to the active point layer or the managed planx_divisions layer. Parts with fewer than two vertices are dropped and zero-length lines (≤ 1e-6) are rejected.

2. Parameters

3. Interaction

4. Output & Behaviour

Split mode edits the source layer (first segment replaces the feature; the rest are added). Points mode writes to the active point layer or planx_divisions (Point, field source_fid).

5. Usage & Tips

1. How It Works

Segments are added by left-click; right-click or Enter joins. The join algorithm iteratively welds paths whose endpoints fall within the tolerance, checking all four endpoint-pair cases (A-end–B-start, A-end–B-end, A-start–B-start, A-start–B-end). The first selected feature is updated in place (changeGeometry) and the others are deleted (deleteFeatures) in one PlanX CAD: join lines edit command.

2. Parameters

3. Interaction

4. Output & Behaviour

A merged feature occupies the first selected feature's slot; the other source features are deleted. Line/polyline only; at least two lines from the same layer are required; if no endpoints match, an error is reported.

5. Usage & Tips

1. How It Works

After a line/polygon is picked, an orange box handle (QgsVertexMarker, icon size 9) renders on every vertex, each tracked by (part_idx, vertex_idx). Dragging a handle moves it via moveVertex(); clicking on an edge inserts a vertex via closestSegmentWithContext + insertVertex(); right-clicking a handle deletes it via deleteVertex(). Multipart-safe through a linear vertex index computed from ring sizes. Deletes are refused when a ring would fall below its minimum — 2 vertices for a line, 4 for a closed polygon ring.

2. Interaction

3. Output & Behaviour

The selected feature is edited in place. Line/polygon geometry only. The handle hit-tolerance is 10 px; the insert tolerance is 8 px.

4. Usage & Tips

1. How It Works

The picked base point and the target point define dx, dy; the geometry is translated with QgsGeometry.translate(dx, dy) and applied through the shared edit machinery.

2. Interaction

3. Output & Behaviour

The selected feature is modified in place. Precision input is supported (@dx,dy or a bare distance along the cursor bearing).

4. Usage & Tips

1. How It Works

The base→target delta is applied with QgsGeometry.translate(dx, dy) and the result is added as a new feature with attributes copied from the source.

2. Interaction

3. Output & Behaviour

A new feature is added to the source layer; the original is untouched. Precision input is supported.

4. Usage & Tips

1. How It Works

The picked feature's centre is the rotation centre. The reference direction and target direction are measured with atan2 in a local metric CRS, and the rotation is target_angle − ref_angle. When Ctrl is held the rotation snaps to round(rotation/90)·90. The geometry is rotated with rotate_geometry(geom, center, −rotation, crs), computed in the local metric CRS for metre-accurate angular behaviour in any project CRS.

2. Interaction

3. Output & Behaviour

The selected feature is modified in place. Precision input accepts a signed angle in degrees.

4. Usage & Tips

1. How It Works

The factor is target_distance / ref_distance (a reference distance below 0.001 is rejected as too small). Scaling composes into a single QTransform:

The transform preserves curves and Z/M values. Precision input accepts a positive factor.

2. Interaction

3. Output & Behaviour

The selected feature is scaled in place. The factor must be positive and finite; a reference distance < 0.001 is refused.

4. Usage & Tips

1. How It Works

The reflection is computed in a local metric CRS from the normalised axis direction (ux, uy):

The result is added as a mirrored copy with copied attributes; the source is never modified. A degenerate axis (zero length) produces no result.

2. Interaction

3. Output & Behaviour

A mirrored copy is added to the source layer; the original is unchanged.

4. Usage & Tips

5. Literature

The reflection matrix is the standard affine form in Farin (2002) and Schneider & Eberly, Geometric Tools for Computer Graphics. Full citations in the references appendix.

1. How It Works

Rectangular mode produces rows·cols − 1 copies, each translate(c·dx, r·dy). Polar mode rotates the feature around a centre: step_angle = sweep/count (full circle) or sweep/max(count−1, 1), each copy rotate_geometry(geom, center, angle). A full circle does not duplicate the source at angle 0 (the source stays in place). Requests exceeding MAX_ARRAY_COPIES = 10 000 are refused. Polar mode shows a live combined preview via unaryUnion().

2. Parameters

3. Interaction

4. Output & Behaviour

Copies are added to the source layer with copied attributes. The 10 000-copy cap guards against accidental runaway arrays.

5. Usage & Tips

1. How It Works

Points accumulate on the canvas; each is snapped. The distance is computed with QgsDistanceArea configured to the project CRS and ellipsoid (setSourceCrs + setEllipsoid), so measurement follows the ellipsoid rather than raw canvas units. A live rubber-band polyline previews the path; the result is shown in a message bar.

2. Interaction

3. Output & Behaviour

No geometry is written — the result is a message-bar total. The running total updates live as points are added.

4. Usage & Tips

1. How It Works

Points accumulate to trace a region; the ring is closed on move for the live preview. Area is computed with QgsDistanceArea (project CRS + ellipsoid) via measureArea; on finish the perimeter is also summed. Areas at or above 10 000 m² are formatted in hectares (area/10000).

2. Interaction

3. Output & Behaviour

Message-bar result only; no geometry is created. Values switch from m² to hectares above the 10 000 m² threshold.

4. Usage & Tips

1. How It Works

A line feature is picked (read-only — no edit session needed). QgsDistanceArea is configured with the layer's CRS and the project ellipsoid, and measureLength returns the length, shown in a message box.

2. Interaction

3. Output & Behaviour

Message-box result only. Line mode requires a line feature.

4. Usage & Tips

1. How It Works

A polygon feature is picked. QgsDistanceArea is configured with the layer CRS and project ellipsoid; measureArea and measurePerimeter return the values, with the area converted to hectares (/10000) for readability.

2. Interaction

3. Output & Behaviour

Message-box result only. Polygon mode requires a polygon feature.

4. Usage & Tips

1. How It Works

Two clicks define the measured span. The distance is computed with QgsDistanceArea.measureLine in the project CRS/ellipsoid and formatted (≥ 1000 m → km, else metres). A LineString is written to planx_dimensions and QGIS labelling is enabled once on the label field (text size 10, colour #1a237e). The tool stays active for consecutive dimensions.

2. Interaction

3. Output & Behaviour

4. Usage & Tips

1. How It Works

Parameters are collected first, then the centreline is sketched on the canvas (left-click adds vertices, right-click/Enter finishes). RoadGenerator.generate() transforms the centreline to a local metric CRS so every offset is in true metres, writes the centerline component first, then emits lanes, median edges, and sidewalks by offsetting the centreline on the appropriate side(s). The total width is derived from the cross-section:

One-way platforms offset lane_count + 1 lane lines across the platform width; two-way platforms emit a median pair (when the median width is positive) plus lane_count lane lines per side, then sidewalks at the outer road edge. Each feature is tagged with component, side, lane number, widths, and a visibility flag so a styling can later distinguish road edges from construction lines.

2. Parameters

A live total-width readout recomputes on every dimension or direction change.

3. Output & Behaviour

4. Usage & Tips

1. The Five-Phase Algorithm

The solver is a pure-geometry module (urban/junction_geometry.py) operating on curb half-edges:

1. Half-edge extraction. A circular buffer (impact radius, 48 segments) is drawn at the junction centre and intersected with road-platform features. Outward curb rays (CurbHalfEdge) are extracted from sidewalk components; median components are collected separately for caps.
2. Approach clustering. Half-edges are grouped by road_id, sorted by angle, and clustered within an angular tolerance (default 12°) with a wrap-around merge across 0°/360°; clusters with fewer than two distinct curbs are dropped. Each cluster becomes an Approach with a signed left/right curb.
3. Sector pairing. Each approach's left curb is paired with the next (counter-clockwise) approach's right curb. Sectors whose directed sweep ≥ π − 1e-7 are skipped — a straight-through or reflex gap is not a local corner.
4. Corner solving. The true intersection of the two support lines is found (support_line_intersection). A chamfer extends the cutback distance along each ray and connects with a straight line; a fillet uses the same tangent-circle construction as the Fillet tool (r/tan(θ/2), r/sin(θ/2), 16-segment arc with endpoints snapped to the exact cut points).
5. Application. Non-sidewalk components are trimmed with an annular trim, sidewalk curbs are trimmed at the solved cut points, connection features are written (junction_chamfer/junction_fillet, road_type="junction"), median caps are added, and the island is created.

2. Parameters

3. Output & Behaviour

Trimmed features and new connection features are written to planx_road_platform; islands are written to planx_junction_islands (Polygon, fields junction_id, island_type, island_radius). All road edits and island edits are kept in one atomic rollback unit — the road is committed only after the island succeeds, and a committed island is compensated if the road later fails.

4. Usage & Tips

5. Literature

The half-edge data structure and angular clustering follow the computational-geometry treatment in de Berg et al. (2008); the tangent-circle corner solver is the same construction documented under Fillet. Full citations in the references appendix.

1. How It Works

The tool searches all project line layers for features within tolerance·3 of the click, finds the nearest intersecting pair (a true intersection, or a virtual one when the gap is within tolerance). Straight mode trims both lines by the distance and connects the cut points with a straight segment; curved mode uses the shared create_fillet_and_trims to trim to the tangent points and connect with a fillet arc. The connector inherits the first line's attributes. A cleanup pass deletes sub-threshold remnant segments within tolerance·5, restricted to the two source layers and excluding the connector. The tool repeats (click → result → click) until right-click/Esc.

2. Parameters

3. Output & Behaviour

The two curb lines are trimmed and a connector (line or arc) is added, inheriting the first line's attributes. Edits preserve an existing user edit session. Remnant cleanup removes short leftover segments near the resolved corner.

4. Usage & Tips