Replot: From Floor Plans to Structured Insight
Replot
What is Replot?
Replot is a comprehensive system that converts architectural floor plans into structured, reviewable data. The platform combines computer vision techniques with a modern web architecture to transform static floor plan images into interpretable geometric data, making architectural information accessible and actionable.System Architecture
The system is built around a clean separation of concerns, with three main components working together to deliver a seamless experience:
+-------------------------------------------+ +-------------------------------------------+
| FRONTEND (UI) | | DJANGO API |
| Next.js + TypeScript (private) | | REST endpoints for jobs & results |
|-------------------------------------------| |-------------------------------------------|
| - Upload plan images | | - Create processing jobs |
| - Track job status | | - Poll job status / fetch results |
| - Review parsed outputs | | - Typed OpenAPI schema for client |
+-------------------------------------------+ +-------------------+-----------------------+
|
v
+------------+-----------------+
| PIPELINE ORCHESTRATOR |
| (private, modular steps) |
+------------+-----------------+
|
+--------------------------+----------------------+-------------------------+-----------------------+
| | | | |
v v v v v
+--------------------+ +--------------------+ +----------------------+ +--------------------+ +--------------------+
| INPUT | | DETECTION | | PROCESSING | | OUTPUT | | STORAGE |
| - Normalize assets | | - Parse primitives | | - Merge/refine shapes| | - Visualizations | | - Media, results |
| - Prepare metadata | | - Extract regions | | - Snap/regularize | | - JSON structures | | - Thumbnails |
+--------------------+ +--------------------+ +----------------------+ +--------------------+ +--------------------+
UI <---- polls status / fetches results ----> API <---- orchestrates ----> Pipeline
The architecture consists of a Next.js frontend for user interactions, a Django API for job orchestration, and a modular pipeline for image processing. This separation allows each component to be optimized for its specific role while maintaining clear interfaces between them.
The Processing Pipeline
The heart of Replot is its four-stage processing pipeline that transforms raw floor plan images into structured data:
Pipeline Stages:
- Input: Normalize assets and prepare metadata for processing
- Detection: Parse primitives and extract key architectural regions
- Processing: Merge results, refine geometry, and snap shapes to regular forms
- Output: Generate visualizations and structured artifacts for review
Each stage is self-contained and modular, enabling targeted improvements without affecting other components. This design makes the system maintainable and allows for safe experimentation with new processing techniques.
API and Orchestration
A Django-powered REST API serves as the central orchestrator for all processing jobs. The API handles job creation, status polling, and result retrieval while maintaining strong typing through OpenAPI schemas.
Key API features include:
- Job Management: Create and track long-running processing tasks
- Real-time Status: Monitor job progress and receive updates
- Typed Responses: OpenAPI schema ensures type safety across the stack
- Asset Serving: Deliver thumbnails, overlays, and structured outputs
The API abstracts away pipeline complexity, providing a clean interface that keeps the frontend lightweight and responsive.
User Interface and Review
The private Next.js interface streamlines the entire workflow from upload to review. Users can upload floor plan images, monitor processing progress in real-time, and interact with the results through an intuitive web interface.
The UI provides:
- Drag-and-drop upload for floor plan images
- Real-time progress tracking with detailed status updates
- Interactive overlays comparing original plans with detected elements
- Export capabilities for downstream use of structured data
Technology Stack
Replot is built with a modern, maintainable stack. The frontend uses Next.js and TypeScript to provide a robust user interface, with React powering interactive elements and Tailwind CSS ensuring responsive styling. On the backend, a Django application—extended with the Django REST Framework—serves as the API layer, generating OpenAPI schemas for type safety and using Python for all image processing and computer vision tasks.
The processing pipeline itself combines computer vision libraries for image analysis with geometric algorithms for shape refinement, all organized in a modular architecture that allows independent updates to each component.
Why Modularity Matters
The modular design of Replot's pipeline is one of its key strengths. By separating input, detection, processing, and output into distinct phases, the system enables:
- Targeted iteration on individual processing stages
- Safe experimentation with new algorithms and techniques
- Clear interfaces that simplify maintenance and debugging
- Independent scaling of different processing components
This architecture makes Replot adaptable to evolving requirements and new processing techniques while maintaining system stability.
Processing Results
Advanced refinement techniques that clean and regularize detected shapes for low confidence regions.
Overlay visualization showing detected regions and architectural components for quick validation.
Future Development
Replot's architecture is designed for growth and adaptation. The modular pipeline can accommodate new processing steps, the API can evolve without breaking existing clients, and the visualization tools can expand as requirements become more sophisticated.
Future enhancements may include support for additional architectural drawing types, integration with CAD systems, and advanced machine learning techniques for improved detection accuracy.