IWPS Layout Generator — Technical Architecture

1

Generation Pipeline

The Layout Generator sits downstream of the Zoning Generator. It receives zone assignments and populates them with furniture-level detail, producing CAD-ready output with accommodation metrics.

📐

Floor Plate Input

DXF boundary + core

→

🗺️

Zoning Output

Zone polygons + types

→

⚙️

Layout Engine

Placement + routing

→

🪑

Furniture Layout

Individual placement

→

📊

Metrics + Export

WPI + DXF/DWG

Key Differentiator: Unlike generic space-planning tools, this generator encodes IWPS's proprietary design intelligence — adjacency rules, density standards, and workplace typologies derived from 12+ completed projects. The output includes WPI scoring, making it the only tool that generates AND evaluates layouts simultaneously.

2

System Architecture

3

Core Modules — Detail

Click each module to expand its technical specification.

📐

Floor Plate Parser

INPUT · Handles DXF/DWG ingestion and boundary extraction

▼

Parses incoming floor plate files to extract the usable area boundary, structural columns, core locations (lift lobbies, staircases, toilets, MEP shafts), and fixed elements. This is the foundation geometry everything builds upon.

Inputs

DXF/DWG file	Shell floor plate from architect
Layer mapping	Which CAD layers = walls, columns, core
Scale factor	Drawing units → millimeters

Outputs

Boundary polygon	Usable floor area as coordinates
Column grid	Structural column positions + sizes
Core zones	Fixed/excluded areas
Gross / Carpet area	Auto-calculated sqft

Handling irregular plates: Your layouts show several non-rectangular floor plates (curved edges, angular cuts). The parser must handle arbitrary polygons — not just rectangles. We'll use computational geometry (Shapely/CGAL) for polygon operations.

🗺️

Zoning Integration Layer

INPUT · Receives zone assignments from Zoning Generator

▼

Ingests the output from the IWPS Zoning Generator — a set of named zone polygons with assigned functions. Each zone becomes a container that the Layout Engine populates with furniture.

Zone Types Supported

Zone Type	Layout Behavior	Reference Projects
Open Workstations	Grid-based desk placement, 1500×1200mm or 1500×750mm modules	All 12 layouts
Executive Cabins	L-desk + meeting table + storage, min 120-335 sqft	Hitachi, H&MV, R2
Meeting Rooms	Table-centric, 2/4/6/8/10/14/20/25 pax configurations	All layouts
Collaboration	Mixed informal seating — sofas, high tables, bean bags	Hogarth, R18
Work Café	Café tables + counter + kitchen adjacency	H&MV, Hitachi, Hogarth
Labs / Specialized	Equipment-first placement, bench clusters	Hitachi (CBTC, V&V, FAT)
Support / MEP	Server, UPS, battery, AHU — fixed equipment blocks	All layouts
Arrival / Reception	Reception desk + waiting + ACD/security	All layouts

🪑

Furniture Library & Typology System

DATA · Parametric furniture blocks + workplace typologies

▼

A structured library of 2D furniture blocks with dimensional metadata, clearance requirements, and grouping rules. Each block is parametric — it can scale within defined constraints.

Block	Dimensions (mm)	Clearance	Cluster Config
5'×4' Workstation	1500 × 1200	900mm aisle (primary), 750mm (secondary)	6-pack, 8-pack, linear rows
1500×750 Height-adj	1500 × 750	900mm primary aisle	Back-to-back rows, 6-pack
Manager Cubicle	2000 × 2000 typical	1200mm front clearance	Single row with partition
Pedestal	420 × 560	Under-desk	1 per workstation

Room Type	Min Area (sqft)	Table Size	Equipment
2 Pax Phone Booth	45	Round 600mm	Screen optional
4 Pax	100-120	1200 × 900	Display + whiteboard
6 Pax	150-185	1800 × 900	Display + VC
8 Pax	200-210	2400 × 1200	Display + VC + whiteboard
10 Pax	280-310	3000 × 1200	Dual display + VC
14 Pax Board	325-400	4200 × 1500	Full AV, credenza
25+ Pax Board	500-535	6000+ × 1800	Full AV, 2× credenza

Cabin Type	Area (sqft)	Furniture Set	From Project
Exec Cabin	120-130	L-desk, 4-pax round table, credenza, bookshelf	Hitachi, R2
Director Cabin	150-200	Executive desk, 6-pax table, sofa, credenza	Hitachi R18
CEO Cabin	335	Executive desk, oval meeting table, lounge seating	H&MV R1
COO / MD Cabin	169	Executive desk, meeting table, storage	H&MV R1

Room	Typical Area	Fixed Equipment	Adjacency Rule
Server Room	100-200 sqft	Racks, raised floor, cooling	Near electrical, away from water
UPS Room	105-235 sqft	UPS units, distribution panel	Adjacent to server + battery
Battery Room	70-145 sqft	Battery banks	Adjacent to UPS, ventilated
AHU Room	165+ sqft	Air handling units	Near external wall / louver
Repro / Print	4-6 stations	Printers, plotters, shredders	Central, accessible from all zones

Typology System: Beyond individual furniture, the library stores pre-configured "typologies" — complete room setups that can be instantiated as a unit. Example: "6-Pax Meeting Room Typology" includes table + 6 chairs + display + whiteboard + clearances, all pre-validated.

⚙️

Layout Generation Engine

CORE · The main placement and optimization engine

▼

The heart of the system. Uses a multi-pass placement algorithm that progresses from macro to micro: first anchoring major elements, then filling with workstations, then optimizing circulation and resolving conflicts.

Four-Pass Generation Sequence

P1

Anchor Pass — Fixed & Major Elements

Places structural columns (from DXF), core areas, arrival zone, CEO/executive cabins near windows, server/UPS/battery cluster. These are "immovable" after placement. Column grid drives the planning grid.

P2

Circulation Pass — Primary Corridors & Paths

Routes primary corridors (2400-3000mm wide) from lift lobby to all zones. Establishes secondary passages (1500mm) along zone boundaries. Ensures fire egress compliance — min 2 exit paths from every point.

P3

Fill Pass — Workstations & Rooms

Populates each zone with the appropriate furniture typology. Workstation zones get desk rows aligned to the grid; meeting rooms get table + chairs; collaboration zones get mixed informal furniture. Density targets guide fill level.

P4

Optimize Pass — Adjust & Validate

Runs collision detection, adjusts furniture positions to resolve overlaps, ensures minimum clearances are met, verifies all rooms have door access, checks WPI compliance. Iterates until all constraints satisfied or reports conflicts.

🚶

Circulation Router

CORE · Pathway generation and fire egress compliance

▼

Generates circulation paths at multiple scales — primary corridors connecting core to zones, secondary passages within zones, and tertiary aisles between desk rows.

Path Type	Width	Purpose	Derived From
Main Corridor	2400-3000mm	Primary spine connecting lift lobby to all departments	H&MV, Hitachi layouts
Secondary Passage	1500mm	Zone-to-zone connection, meeting room access	All layouts — consistent standard
Tertiary Aisle	900mm	Between desk rows	Workstation zones
Fire Egress	1200mm min	Clear path to nearest staircase/exit	NBC compliance

Algorithm: Uses A* pathfinding on a discretized grid, with corridor width as a constraint. Primary corridors are placed first (P2), then secondary paths are routed around placed furniture (P3/P4). Dead-end detection ensures every workstation has at least 2 egress routes.

📊

WPI Scoring Integration

OUTPUT · Real-time Workplace Performance Index calculation

▼

The generated layout is automatically scored against the Workplace Performance Index. This creates a feedback loop — the engine can generate multiple variants and rank them by WPI score.

WPI

Overall Score

1:15-30

Meeting Room Ratio

3.0

Meeting Seat Ratio

60-80

Sqft / Seat Target

WPI parameters extracted from your layouts: the Hitachi R18 achieved a meeting room ratio of 27.1 with meeting seat ratio of 3.0 across 244 total seats. The H&MV R1 achieved a ratio of 16.2 with 97 meeting seats across 291 headcount. The engine uses these as calibration benchmarks.

📁

CAD Export Engine

OUTPUT · DXF/DWG generation with proper layering

▼

Exports the generated layout as production-quality CAD files that designers can immediately open in AutoCAD and refine. Proper layer organization is critical for this to be useful.

Layer Structure

Layer Name	Color	Contents
A-WALL-FULL	White	Full-height walls (meeting rooms, cabins, core)
A-WALL-PART	Cyan	Partitions, half-height screens
A-FURN-DESK	Green	All workstation blocks
A-FURN-CHAIR	Green	Seating — task, meeting, lounge
A-FURN-TABLE	Magenta	Meeting tables, café tables
A-FURN-STOR	Yellow	Pedestals, credenzas, lockers, filing
A-CIRC	Red	Circulation paths (reference)
A-ZONE	Blue	Zone boundaries (reference)
A-DIMS	White	Dimension annotations
A-TEXT	White	Room labels, seat counts, area callouts
A-EQUIP	Orange	Printers, AV equipment, ACD
A-CORE	Gray	Structural columns, core walls (from input)

Technical approach: DXF output via ezdxf (Python). DWG output via ODA File Converter (DXF → DWG conversion). Block definitions for furniture ensure file size stays manageable — each desk type is defined once and inserted as references with rotation/position.

4

Rules Engine — Codified Design Intelligence

These rules are extracted from your 12 reference layouts and represent IWPS's proprietary design standards. They constrain the generation engine to produce layouts that match your design quality.

Density

Open workstation density	60–80 sqft/seat
Exec cabin min area	120 sqft (standard) / 335 sqft (CEO)
Meeting room per seat ratio	1 room per 15–30 seats
Meeting seat ratio	3.0 (meeting seats ÷ total pax × 100)
Collaboration seats	10–15% of total headcount
Work café seats	15–25% of total headcount

Adjacency

CEO/MD cabin	→ Near arrival zone + board room
Executive cabins	→ Window-facing, near team workstations
Server + UPS + Battery	→ Clustered together, near electrical room
Kitchen / wet pantry	→ Near service lift, away from workstations
Work café	→ Central, accessible from all zones
Arrival zone	→ Adjacent to main lift lobby
Repro / print stations	→ Distributed, max 30m walking distance

Circulation

Main corridor width	2400–3000mm
Secondary passage	1500mm minimum
Desk aisle (primary)	900mm clear
Desk aisle (secondary)	750mm minimum
Meeting room door clearance	1000mm swing + 900mm clear
Fire egress max travel	30m to nearest exit
Dead-end corridor max	6m

Compliance

NBC fire safety	2 exits from every occupied zone
Accessible route	1200mm min clear width
All lab doors	1000mm wide minimum
UPS / Battery doors	1200mm wide minimum
Warehouse doors	2000mm wide minimum
Window access	Workstations within 8m of window preferred
Daylight penetration	Min 60% of workstations in daylight zone

5

Data Models

interface FloorPlate {
  id: string;
  boundary: Polygon;           // Outer boundary as coordinate ring
  cores: CoreElement[];        // Lift lobbies, stairs, toilets, shafts
  columns: Column[];           // Structural columns with position + size
  fixedWalls: LineSegment[];   // Immovable walls from shell
  grossArea: number;           // Total area in sqft
  carpetArea: number;          // Usable area after core exclusion
  windowEdges: LineSegment[]; // Edges with windows — drives daylight calc
  orientation: CompassBearing; // North direction for compass rose
  gridSpacing: number;         // Planning grid in mm (default 1500)
}
      

interface Zone {
  id: string;
  name: string;               // "Engineering Dept", "Work Café", etc.
  type: ZoneType;             // WORKSTATION | EXECUTIVE | MEETING | COLLAB | CAFE | LAB | SUPPORT | ARRIVAL
  polygon: Polygon;           // Zone boundary within floor plate
  area: number;               // Calculated area in sqft
  targetHeadcount: number;    // How many seats this zone should hold
  adjacencyRequired: string[];  // Zone IDs this must be near
  adjacencyAvoid: string[];     // Zone IDs to keep distance from
  windowAccess: boolean;      // Does this zone touch a window edge?
  furnitureTypology: string;  // Which typology template to apply
  densityTarget: number;      // Sqft per seat target for this zone
}
      

interface FurnitureBlock {
  id: string;
  category: string;            // DESK | CHAIR | TABLE | STORAGE | EQUIPMENT
  name: string;                // "5x4_workstation", "6pax_meeting_table"
  width: number;               // In mm
  depth: number;               // In mm
  clearance: {
    front: number;             // Required clearance in mm
    back: number;
    left: number;
    right: number;
  };
  seatCount: number;           // Seats this block provides
  canRotate: boolean;          // Can be placed at 0/90/180/270
  cadBlockName: string;       // Reference name in DXF block table
  cadLayer: string;            // Target layer for CAD export
  clusterWith: string[];      // Other block IDs that form a group
}
      

interface GeneratedLayout {
  id: string;
  floorPlate: FloorPlate;
  zones: Zone[];
  placements: FurniturePlacement[];  // Every placed item with position + rotation
  walls: WallSegment[];             // Generated partition walls
  doors: DoorPlacement[];          // Door positions in walls
  circulation: CirculationPath[];   // Generated corridors and aisles
  accommodationSummary: {
    totalSeats: number;
    workstations: number;
    meetingRooms: number;
    meetingSeats: number;
    meetingRoomRatio: number;
    meetingSeatRatio: number;
    collabSeats: number;
    cafeSeats: number;
    lineItems: AccommodationLineItem[];  // Matches R18/R1 format
  };
  wpiScore: WPIScorecard;
  variant: string;              // "density_optimized" | "collaboration" | "balanced"
  generatedAt: Date;
}
      

6

Algorithm Deep Dive

Placement Algorithm — Constraint Satisfaction with Optimization

The core challenge: place N furniture items within irregularly-shaped zones such that all clearance, adjacency, circulation, and density constraints are satisfied, while maximizing seat yield and WPI score.

Approach: Hybrid CSP + Greedy Optimization

// Pseudocode: Main generation loop

function generateLayout(floorPlate, zones, brief) {
  // PASS 1: Anchor immovable elements
  grid = createPlanningGrid(floorPlate, 1500);  // 1500mm grid
  placeCore(floorPlate.cores, grid);
  placeColumns(floorPlate.columns, grid);

  // PASS 2: Route primary circulation
  mainCorridors = routeCorridors(
    floorPlate.cores.liftLobby,
    zones.centroids(),
    width: 2400,  // mm
    algorithm: "weighted_astar"
  );
  secondaryPaths = routeSecondaryPaths(zones, width: 1500);
  markCirculationZones(mainCorridors, secondaryPaths, grid);

  // PASS 3: Fill zones with furniture
  for (zone of zones.sortByPriority()) {
    typology = furnitureLibrary.getTypology(zone.type);

    if (zone.type === "WORKSTATION") {
      // Determine optimal desk orientation (parallel vs perpendicular to window)
      orientation = calcOptimalOrientation(zone, floorPlate.windowEdges);
      // Fill with desk rows, respecting aisle widths
      fillWithDeskRows(zone, typology, orientation, grid);
    }

    if (zone.type === "MEETING") {
      // Place meeting rooms as enclosed typologies
      placeMeetingRooms(zone, brief.meetingRoomMix, grid);
    }

    if (zone.type === "EXECUTIVE") {
      // Place cabins along windows, sorted by seniority
      placeExecCabins(zone, brief.execCabinList, grid);
    }
    // ... other zone types
  }

  // PASS 4: Optimize
  conflicts = detectCollisions(grid);
  while (conflicts.length > 0 && iterations < 100) {
    resolveConflicts(conflicts, grid);
    validateClearances(grid);
    validateEgress(grid, floorPlate);
    conflicts = detectCollisions(grid);
  }

  // Score and generate output
  wpi = calculateWPI(grid, brief);
  summary = generateAccommodationSummary(grid);
  return { grid, wpi, summary };
}
        

Variant Generation: The engine runs 3 times with different weight parameters to produce 3 layout options:
Density-optimized (maximize seats, tighter clearances) · Collaboration-heavy (more collab area, lower density) · Balanced (IWPS recommended ratios).

Desk Row Filling Algorithm

The most frequently used sub-algorithm. Places workstation rows within a zone polygon, maximizing seat count while maintaining aisle widths.

// Desk row filling — the "bread and butter" algorithm

function fillWithDeskRows(zone, typology, orientation, grid) {
  deskModule = typology.primaryDesk;  // e.g., 1500×1200mm
  aisleWidth = 900;  // mm, primary aisle

  // Calculate row pitch: desk_depth × 2 (back-to-back) + aisle
  rowPitch = (deskModule.depth * 2) + aisleWidth;  // e.g., 3300mm

  // Sweep across zone in orientation direction
  scanLines = generateScanLines(zone.polygon, orientation, rowPitch);

  for (line of scanLines) {
    // Clip scan line to zone boundary
    segments = clipToPolygon(line, zone.polygon);

    for (seg of segments) {
      // Place desks along segment, snapping to 1500mm grid
      count = Math.floor(seg.length / deskModule.width);
      for (i = 0; i < count; i++) {
        pos = seg.start + (i * deskModule.width);
        placeFurniture(deskModule, pos, orientation, grid);
        placeFurniture(deskModule, pos + deskModule.depth, orientation + 180, grid);  // Back-to-back
      }
    }
  }
}
      

7

CAD Export Architecture

DXF Generation

Primary export format. Uses ezdxf Python library for precise control over entities, layers, blocks, and dimensions.

Library	ezdxf v1.x
DXF Version	R2018 (AC1032)
Units	Millimeters
Block Strategy	1 block definition per furniture type → INSERT references
Hatching	Zone fills as HATCH entities with transparency
Dimensions	Auto-placed for rooms, corridors, key distances
Text	Room names, seat counts, area annotations

DWG Conversion

Native AutoCAD format. Generated by converting the DXF output using ODA File Converter.

Converter	ODA File Converter (free CLI tool)
Pipeline	Generate DXF → Run ODA → Output DWG
Fallback	LibreCAD CLI as secondary converter
Validation	Auto-open check via ezdxf audit

Note: True DWG generation without ODA requires licensing from Autodesk (RealDWG SDK). The DXF → DWG pipeline via ODA is the industry-standard workaround used by most non-Autodesk CAD tools.

8

Technology Stack

Backend / Engine

Language	Python 3.11+
Geometry	Shapely + CGAL bindings
CAD I/O	ezdxf (DXF read/write)
Optimization	OR-Tools (constraint solver)
Pathfinding	NetworkX (graph-based routing)
API Framework	FastAPI

Frontend / Viewer

Framework	React + TypeScript
2D Rendering	Fabric.js or Konva
SVG Export	Built-in canvas → SVG
UI Components	Tailwind + shadcn/ui
State	Zustand

Infrastructure

Hosting	Standalone Docker → later IIP
Database	PostgreSQL + PostGIS
File Storage	S3-compatible (Supabase Storage)
DWG Convert	ODA File Converter (CLI)
Auth	Supabase Auth (matches IIP)

9

Implementation Roadmap

16

Weeks Total

4

Phases

MVP

Week 8 Target

CAD

Week 12 Target

Phase 1 — Foundation Weeks 1–4

Core geometry engine + rules database

Build floor plate parser (DXF ingestion via ezdxf), implement planning grid system, create furniture block library with all types from your 12 layouts, build the rules engine with density/adjacency/circulation constraints. Deliverable: Can parse a DXF floor plate and overlay a zone grid.

Phase 2 — Generation Engine Weeks 5–8

Core placement algorithm + basic viewer

Implement the 4-pass generation algorithm (anchor → circulate → fill → optimize). Build the desk row filling algorithm, meeting room placement, exec cabin placement. Create basic React viewer to visualize output. Deliverable: MVP — generates a furniture-level layout from zones + brief, viewable in browser.

Phase 3 — CAD Export + WPI Weeks 9–12

DXF/DWG export, WPI scoring, accommodation summary

Build the DXF export engine with proper layering and block definitions. Integrate ODA File Converter for DWG output. Wire up WPI scoring engine. Auto-generate accommodation summary matching your R18/R1 format. Deliverable: Full standalone tool with CAD export.

Phase 4 — Polish + Variants Weeks 13–16

3 layout variants, benchmark comparison, IIP prep

Implement variant generation (density/collaboration/balanced). Add industry benchmark comparison (Gensler/CBRE/JLL standards). Refine collision resolution and edge cases (irregular floor plates, very small zones). Prepare API contracts for future IIP integration. Deliverable: Production-ready standalone tool.

10

Technical Risks & Mitigations

HIGH

Irregular floor plate handling

Several of your layouts have curved edges, angular cuts, and non-convex shapes. The placement algorithm must handle arbitrary polygons without generating furniture outside the boundary.

Mitigation: Use Shapely polygon clipping for all placement operations. Every furniture item's bounding box is intersection-tested against the zone polygon before confirming placement.

MED

DWG export fidelity

The DXF → DWG conversion via ODA can occasionally lose certain entity types or properties. Designers need pixel-perfect CAD output.

Mitigation: Stick to well-supported DXF entity types (LINE, CIRCLE, ARC, POLYLINE, INSERT, HATCH, TEXT, MTEXT, DIMENSION). Avoid complex entities. Run automated audit after conversion.

MED

Circulation routing in complex geometries

A* pathfinding on discretized grids can produce non-optimal paths in irregular floor plates, especially around curves and angles.

Mitigation: Use visibility graph pathfinding as a secondary algorithm for complex geometries. Fall back to manual corridor placement for extreme cases.

LOW

Constraint satisfaction convergence

The optimizer (Pass 4) may not converge for some input combinations — e.g., too many seats requested for available area.

Mitigation: Pre-validate inputs against density ranges before generation. If optimizer doesn't converge in 100 iterations, report specific conflicts to user with suggested adjustments.