Automating Wall and Door Detection in CAD: Precision Extraction for Indoor Mapping

Facilities engineers and indoor navigation developers routinely encounter CAD files that are structurally sound for drafting but topologically fragmented for computational geometry. Raw DXF/DWG exports are optimized for human readability, not machine parsing. Walls are frequently represented as dual parallel LINE entities, LWPOLYLINE segments with inconsistent widths, or exploded BLOCK references. Doors manifest as intentional topology breaks, custom block inserts, or hatched regions. Automating wall and door detection requires a deterministic pipeline that normalizes raw entities, reconstructs spatial topology, and validates connectivity against wayfinding graph constraints. This guide details exact implementation steps, diagnostic workflows, and Python/GIS integration patterns for production-grade floor plan parsing.

CAD Entity Normalization and Layer Sanitization

When architecting an Automated Floor Plan Parsing & Vectorization pipeline, deterministic layer mapping prevents downstream coordinate drift and false adjacency errors. CAD files rarely present clean, unified geometry out-of-the-box. Drafting history introduces overlapping duplicates, micro-segments, and inconsistent layer naming conventions (A-WALL, WALLS, 0, DEFPOINTS). The first operational step is strict layer filtering and entity type resolution.

Diagnostic: Resolving Exploded Blocks and Polyline Fragmentation

Parsing with ezdxf exposes nested blocks and fragmented polylines that break spatial continuity. Implement a recursive entity flattener that converts all relevant geometry into a unified shapely geometry collection before spatial analysis. Floating-point precision drift during coordinate transformation must be explicitly managed.

import logging
import ezdxf
from shapely.geometry import LineString, MultiLineString
from shapely.ops import linemerge, unary_union
from shapely.validation import make_valid
from typing import List, Optional

logger = logging.getLogger(__name__)

def flatten_cad_entities(
    dxf_path: str, 
    target_layers: Optional[List[str]] = None,
    tolerance: float = 1e-3
) -> MultiLineString:
    """
    Recursively flattens DXF entities into a unified, deduplicated MultiLineString.
    Handles nested blocks, LWPOLYLINEs, and standard LINEs.
    """
    try:
        doc = ezdxf.readfile(dxf_path)
    except Exception as e:
        logger.error(f"Failed to load DXF: {e}")
        return MultiLineString()
        
    msp = doc.modelspace()
    geometries: List[LineString] = []
    
    target_set = set(target_layers) if target_layers else None

    def extract_lines(entity):
        dxftype = entity.dxftype()
        
        if target_set and entity.dxf.layer not in target_set:
            return
            
        if dxftype in ('LINE', 'LWPOLYLINE', 'POLYLINE'):
            try:
                if dxftype == 'LINE':
                    p1, p2 = entity.dxf.start, entity.dxf.end
                    points = [(p1.x, p1.y), (p2.x, p2.y)]
                elif dxftype == 'LWPOLYLINE':
                    # Each tuple is (x, y, start_width, end_width, bulge); take xy only.
                    points = [(p[0], p[1]) for p in entity.get_points()]
                else:  # POLYLINE — iterate the .vertices attribute (sequence of Vertex)
                    points = [(v.dxf.location.x, v.dxf.location.y) for v in entity.vertices]

                if len(points) >= 2:
                    line = LineString(points)
                    if not line.is_empty and line.length > tolerance:
                        geometries.append(line)
            except Exception as e:
                logger.warning(f"Skipping malformed polyline: {e}")
                
        elif dxftype == 'INSERT':
            block_name = entity.dxf.name
            if block_name in doc.blocks:
                block = doc.blocks[block_name]
                # Apply block transformation matrix if needed for absolute coordinates
                for sub_ent in block:
                    extract_lines(sub_ent)

    for entity in msp:
        extract_lines(entity)
        
    if not geometries:
        return MultiLineString()
        
    # Merge collinear segments and remove duplicates
    merged = linemerge(unary_union(geometries))
    return make_valid(merged) if isinstance(merged, (LineString, MultiLineString)) else MultiLineString()

Production Debugging Note: CAD files frequently contain overlapping duplicate lines due to drafting history or copy-paste operations. Apply shapely.ops.linemerge() followed by a tolerance-based deduplication pass (snap at 1e-3 units) to prevent parallel line clustering algorithms from misinterpreting drafting artifacts as structural walls. Refer to the official shapely documentation for advanced topology cleaning functions like buffer(0) and simplify().

Geometric Extraction and Topology Reconstruction

Once normalized, the pipeline must separate continuous wall segments from intentional architectural gaps. This requires parallel line clustering, thickness inference, and gap threshold calibration. Implementing robust Wall & Door Detection Algorithms demands precise handling of drafting artifacts versus structural voids.

Wall Centerline Inference via Parallel Line Clustering

Walls in architectural CAD are typically drafted as two parallel lines. To extract the navigable centerline, apply a distance-based pairing algorithm. For production scalability, avoid brute-force O(n²) comparisons. Instead, utilize spatial indexing and directional filtering.

import numpy as np
from shapely.geometry import LineString
from shapely.affinity import translate
from scipy.spatial import KDTree

def extract_wall_centerlines(
    wall_lines: MultiLineString,
    max_thickness: float = 0.5,
    min_gap: float = 0.05
) -> MultiLineString:
    """
    Infers wall centerlines by pairing parallel segments and calculating midpoints.
    Returns a unified centerline network for graph traversal.
    """
    if wall_lines.is_empty:
        return MultiLineString()
        
    # Convert to numpy array for vectorized operations
    lines = list(wall_lines.geoms) if hasattr(wall_lines, 'geoms') else [wall_lines]
    centers = []
    used_indices = set()
    
    # Build KDTree for fast spatial queries on line midpoints
    midpoints = np.array([line.centroid.coords[0] for line in lines])
    tree = KDTree(midpoints)
    
    for i, line_a in enumerate(lines):
        if i in used_indices:
            continue
            
        # Query neighbors within max wall thickness
        indices = tree.query_ball_point(midpoints[i], r=max_thickness)
        best_pair = None
        min_dist = float('inf')
        
        for j in indices:
            if j == i or j in used_indices:
                continue
            line_b = lines[j]
            
            # Check parallelism via direction vectors
            dir_a = np.array(line_a.coords[-1]) - np.array(line_a.coords[0])
            dir_b = np.array(line_b.coords[-1]) - np.array(line_b.coords[0])
            
            cos_sim = np.dot(dir_a, dir_b) / (np.linalg.norm(dir_a) * np.linalg.norm(dir_b) + 1e-9)
            
            if abs(abs(cos_sim) - 1.0) < 0.05:  # ~8 degrees tolerance
                # Calculate perpendicular distance
                dist = line_a.distance(line_b)
                if dist < max_thickness and dist > min_gap:
                    if dist < min_dist:
                        min_dist = dist
                        best_pair = (line_a, line_b, j)
                        
        if best_pair:
            line_a, line_b, j = best_pair
            # Interpolate centerline by averaging coordinates
            coords_a = np.array(line_a.coords)
            coords_b = np.array(line_b.coords)
            
            # Handle differing vertex counts via resampling
            if len(coords_a) != len(coords_b):
                # Simplify to endpoints for straight segments
                center = LineString([
                    ((coords_a[0][0] + coords_b[0][0]) / 2, (coords_a[0][1] + coords_b[0][1]) / 2),
                    ((coords_a[-1][0] + coords_b[-1][0]) / 2, (coords_a[-1][1] + coords_b[-1][1]) / 2)
                ])
            else:
                center = LineString((coords_a + coords_b) / 2)
                
            centers.append(center)
            used_indices.add(i)
            used_indices.add(j)
            
    return unary_union(centers) if centers else MultiLineString()

Topology Validation: Centerline extraction must account for T-intersections and L-corners. After pairing, apply linemerge() and snap() to close micro-gaps at junctions. Validate against facility constraints: corridors must maintain minimum ADA clearance widths, and load-bearing walls should be flagged for structural metadata mapping.

Door Detection and Semantic Validation

Doors manifest as topological breaks in the wall centerline network, specific block inserts (e.g., DOOR_SWING, ENTRY), or hatched regions. Detection requires cross-referencing geometric gaps with architectural symbols and validating swing direction via block rotation attributes.

Gap Analysis and Block Attribute Mapping

A deterministic door detection pipeline operates in three phases:

  1. Geometric Gap Identification: Locate discontinuities in the wall centerline exceeding a calibrated threshold (typically 0.7m to 1.2m).
  2. Symbolic Cross-Reference: Match gap centroids to nearby INSERT entities representing door blocks.
  3. Semantic Enrichment: Extract rotation, scale, and layer attributes to infer swing direction, fire rating, and accessibility compliance.
import networkx as nx
from shapely.geometry import Point, box

def detect_and_classify_doors(
    centerlines: MultiLineString,
    door_blocks: list,  # List of (Point, rotation, layer_name) tuples
    gap_threshold: float = 0.8
) -> list:
    """
    Identifies doors by analyzing centerline gaps and mapping to CAD block inserts.
    Returns a list of door dictionaries with topology and semantic attributes.
    """
    doors = []
    graph = nx.Graph()
    
    # Build spatial graph of centerline endpoints
    for line in centerlines.geoms if hasattr(centerlines, 'geoms') else [centerlines]:
        start, end = Point(line.coords[0]), Point(line.coords[-1])
        graph.add_node(start, pos=(start.x, start.y))
        graph.add_node(end, pos=(end.x, end.y))
        graph.add_edge(start, end, length=line.length)
        
    # Identify gaps (unconnected endpoints within threshold distance)
    nodes = list(graph.nodes())
    for i in range(len(nodes)):
        for j in range(i + 1, len(nodes)):
            if not graph.has_edge(nodes[i], nodes[j]):
                dist = nodes[i].distance(nodes[j])
                if 0.5 < dist < gap_threshold:
                    # Potential door location
                    mid = Point((nodes[i].x + nodes[j].x)/2, (nodes[i].y + nodes[j].y)/2)
                    
                    # Match to nearest door block
                    matched_block = None
                    min_dist = float('inf')
                    for blk_pt, rot, layer in door_blocks:
                        d = mid.distance(blk_pt)
                        if d < 0.3 and d < min_dist:
                            min_dist = d
                            matched_block = (blk_pt, rot, layer)
                            
                    if matched_block:
                        doors.append({
                            "id": f"DOOR_{len(doors)+1:03d}",
                            "location": (mid.x, mid.y),
                            "gap_width": round(dist, 3),
                            "swing_angle": matched_block[1],
                            "layer": matched_block[2],
                            "connects": [nodes[i], nodes[j]]
                        })
                        
    return doors

Wayfinding Integration: Door objects must be injected into the navigation graph as traversable edges with metadata: is_fire_rated, is_ada_compliant, max_clearance_width. This enables routing engines to dynamically exclude egress paths during emergency simulations.

Production Pipeline Integration

Enterprise deployment requires asynchronous batch processing, memory-efficient geometry handling, and real-time topology updates. CAD files often exceed 50MB, making synchronous parsing a bottleneck.

Async Batch Processing and Topology Updates

Leverage asyncio with concurrent.futures.ProcessPoolExecutor for CPU-bound geometry operations. Implement a producer-consumer architecture where DXF ingestion feeds into a normalization queue, topology reconstruction runs in isolated workers, and results are streamed to a PostGIS or GeoJSON output layer.

import asyncio
from concurrent.futures import ProcessPoolExecutor
import json
from pathlib import Path

async def process_floor_plan_batch(dxf_dir: Path, output_dir: Path, max_workers: int = 4):
    """
    Asynchronously processes multiple CAD files using process isolation.
    Streams results to JSON for downstream GIS integration.
    """
    loop = asyncio.get_event_loop()
    executor = ProcessPoolExecutor(max_workers=max_workers)
    
    tasks = []
    for dxf_file in dxf_dir.glob("*.dxf"):
        # Wrap CPU-bound function in executor
        task = loop.run_in_executor(executor, _parse_single_file, dxf_file)
        tasks.append(task)
        
    results = await asyncio.gather(*tasks)
    
    # Write consolidated topology
    output_dir.mkdir(parents=True, exist_ok=True)
    with open(output_dir / "indoor_topology.json", "w") as f:
        json.dump(results, f, indent=2)
        
def _parse_single_file(dxf_path: Path) -> dict:
    # CPU-bound isolation wrapper
    walls = flatten_cad_entities(str(dxf_path), target_layers=["A-WALL", "WALL"])
    centers = extract_wall_centerlines(walls)
    # ... door detection logic ...
    return {"file": dxf_path.name, "wall_count": len(list(centers.geoms))}

Standards Compliance: Export topology to OGC IndoorGML or GeoJSON with indoor extensions. Validate against the OGC IndoorGML standard to ensure interoperability with BIM platforms and facility management systems. For real-time updates, implement a WebSocket or MQTT bridge that pushes topology deltas when CAD revisions are committed to version control.

Diagnostic Checklist for Production:

By enforcing strict normalization, leveraging spatial indexing for parallel line clustering, and validating door semantics against architectural blocks, teams can transform fragmented CAD drafts into deterministic, machine-readable indoor navigation graphs.