It’s slow.

And it’s repetitive.

That’s the problem we set out to solve.

Instead of redrawing cabinets manually, we designed a system that interprets architectural drawings and builds the 3D model automatically.

But the challenge wasn’t just reading a PDF.

PDF drawings are not machine-friendly.

To a computer vision model, lines, text, and symbols all look almost the same.

A single sheet can contain a floor plan, multiple elevations, section cuts, and detailed callouts — all mixed together.

Before we could generate any 3D model, the system first had to understand what it was looking at.

So we didn’t build one big model.
We broke the system into modules.

PDF analysis.
Region detection.
Cabinet detection.
Measurement extraction.
Coordinate mapping.
3D rendering.
CAD export.

Each module solves a specific problem in the pipeline.

The first step is simple but important.

When a user uploads a drawing, the PDF is converted into high-resolution images.

Resolution matters here.

If the image quality is too low, small dimension texts and thin lines disappear, and detection accuracy drops immediately.

Once we have images, the system identifies different regions inside the sheet.

Not every part of a drawing is useful.

Some regions contain floor plans.

Others contain section cuts or detail diagrams.

The system prioritizes the base floor plan because that’s where the cabinet layout usually lives.

After that, object detection takes over.

We use a YOLO model trained on annotated architectural drawings.

It detects cabinet types such as upper cabinets, base cabinets, tall cabinets, and appliances.

The model produces bounding boxes and confidence scores.

Low-confidence detections are filtered out so the system doesn’t pollute the pipeline with false positives.

But detecting cabinets is only half the problem.

Measurements are where things get complicated.

Dimensions in drawings can appear in many formats.

2′-6″
30″

Or sometimes just 30 with the unit defined somewhere else on the sheet.

They can be rotated, overlapping, or connected with leader lines.

Traditional OCR struggles with this.

So we added a second layer.

For each detected cabinet, we crop the surrounding region and send it to a vision-enabled LLM.

The prompt asks the model to extract three things:

Width.
Height.
Depth.

Those values are attached to the cabinet object.

But we don’t blindly trust the result.

If the LLM returns something unrealistic for that cabinet type, the system flags it for review instead of accepting it silently.

This small guardrail prevents hallucinated dimensions from breaking the model.

Next comes coordinate extraction.

Architectural drawings include a scale marker like:

1/8″ = 1′-0″

Once the scale is detected, the system converts pixel distances into real-world measurements.

Every cabinet gets X, Y, and Z coordinates inside the plan.

Now the system finally has enough information to generate geometry.

That data feeds directly into a 3D viewer built with Three.js.

Cabinets appear in a 3D canvas with their detected dimensions and positions.

Architects can move objects.

Fix mistakes.

Delete false detections.

Or add cabinets the system missed.

The goal isn’t perfect automation.

It’s reducing the workload.

Instead of building the model from scratch, architects are correcting a generated model.

That’s where the real time savings appear.

Once the model is finalized, the system exports the geometry to AutoCAD.

The output file is a .DWG generated using the AutoCAD SDK.

Cabinet blocks are placed with correct measurements and real-world coordinates.

If the upstream data is accurate, the export works cleanly.

Interestingly, this final step turned out to be one of the most stable parts of the system.

The real difficulty isn’t exporting CAD files.

It’s interpreting messy architectural drawings in the first place.

Right now the system works well on clean digital drawings.

But older scanned drawings still create edge cases.

Dense dimension strings.

Overlapping annotations.

Complex sheets with many detail views.

Those are the areas we’re still improving.

That’s the reality of production AI systems.

The hardest part isn’t the AI model.

It’s the pipeline around it.