Mega Data: Turning a Company's Accumulated BIM Models and Drawings into AI-Ready Data for Generative Design

For a while now, my generative design (GD) work has fed AI with data that GD makes for itself. It works as a source of labels — GD knows the right answer for every design it generates — but the AI in that loop never meets a real model or a real drawing. The bigger fuel is already sitting in every company's archive. I call it mega data, and this series is about turning it into material a GD–AI loop can actually use.

Animation: files from a company archive pass a six-step chain, become AI-ready material, and feed a generate–evaluate–learn loop whose results return to the archive.
From archive to loop — where this series is heading. Files from past projects pass a six-step chain to become AI-ready material for the GD–AI loop, and the loop's results return to the archive. Today the chain works for models and partly for drawings; the full loop does not run yet. Plans: rooms extracted from Autodesk's public Snowdon Towers sample. Sections: synthetic sheets from my tunnel-section engine.
IN PRACTICE
Four real screens: an IFC model colored by validation verdict, automatic line detection on a tunnel drawing, generated plant layouts flooded on one Omniverse stage, and 120 buildings evacuating on one GPU stage.
The real screens behind this series. Top left: our IFC review tool colors every element of a real IFC model by its check (Buildings paper, Fig. A1, CC BY 4.0). Top right: automatic line detection on a tunnel drawing picks up dimension lines as confidently as walls — it cannot tell them apart (tunnel series). Bottom: every alternative on one NVIDIA Omniverse Kit stage (flood series: batch run) and 120 buildings evacuating on one GPU stage (Lab Notes #8).

What I mean by mega data

By mega data I mean everything a company has already built: the models and drawing sets of every past project. Nobody can read all of it by hand — so it has to become something a machine can read. It sits in three piles:

  • BIM models (RVT). Rooms, equipment, parameters — inside proprietary files, named by each team's habit.
  • Exchange models (IFC). The same buildings in an open format. A file can be valid and still be incomplete.
  • Drawing folders (DWG / PDF). Sections, dimensions and notes, stored as lines and text rather than data.

None of it is AI-ready on day one. In this series, AI-ready has a narrow meaning: every item can be found, read, counted, and traced back to its source. It is the same point I made in Why AI in AEC Stalls: the problem is not a lack of data, it is a lack of structure.

Three piles of company data: BIM models as a floor plan, exchange models as exploded levels, and drawing folders as a tunnel section sheet.
Three piles every company already has. The material is there; what's missing is structure. Plan and exploded levels: Autodesk's public Snowdon Towers sample. Section: synthetic.

Here is what “structure missing” looks like on a real project: a tunnel model that is geometrically complete, with nothing in it linked back to the spreadsheet that defined it.

IN PRACTICE
A tunnel model viewer showing an 892-meter tunnel solid, with a long list of branches and parameters beside it.
Geometry is there; its data links are not — an 892 m tunnel solid in a 3D model viewer (tunnel series).

And this is what one item looks like once it is AI-ready: one room from the public sample, as a Revit add-in exports it (excerpt; the shape is stored as a JSON string and decoded here, coordinates rounded). A name, a level, an ID that points back to the model element, and a boundary with its holes. All 54 rooms in the sample came out this way, 0 invalid.

{
  "Room_Name": "Live/Work Unit 407",
  "Room_Number": "407",
  "Level": "L4",
  "Room_ID_Auto": "830682",
  "SourceFile": "Snowdon Towers Sample Architectural.rvt",
  "RoomShapeJson": {
    "unit": "ft", "boundary_mode": "EVEN_ODD",
    "loop_count": 3, "loop_roles": ["Outer", "Hole", "Hole"],
    "loops": [[{"x": 4.073, "y": 1.5, "z": 32.167},
               {"x": 4.073, "y": -11.708, "z": 32.167}, …], …]
  }
}

Loop 1.0 ran on synthetic data

Earlier I wrote that generative design can become a synthetic data factory: GD produces thousands of designs, and because GD built them, the labels come for free. It is a clean way to train a model — but the model only ever sees GD's own world.

IN PRACTICE
Revit Generative Design explorer: a grid of layout alternatives and a parallel-coordinates panel linking rotation inputs to routing-length outputs.
Loop 1.0 in practice: many alternatives, each with known inputs and outputs — from our Applied Sciences paper, Fig. 9 (CC BY 4.0).

Accumulated data enters the same loop at three points:

  1. Starting points. A past design seeds the next GD run instead of a random start. Lab Notes #7 showed this at small scale, with a design from another site.
  2. Rules. Judgments the AI keeps making the same way on real drawings become engine rules that run without AI — that is how real drawings become material the loop can read.
  3. Validation. A reader trained on synthetic sheets has to prove itself on real ones.
Two loops compared: Loop 1.0 learns only from data GD makes; with mega data, an archive feeds the loop at three points — starting points, rules and validation.
Loop 1.0 learns only from what GD makes. With mega data, the archive feeds three points: starting points, rules and validation.
IN PRACTICE
A past three-floor design from another L-shaped site moved onto a new lot, and a chart of valid designs per generation for warm-started versus random runs.
Entry point 1 at small scale: the only design in the initial population that satisfied every rule came from another site; warm-started runs (blue) versus random starts (gray) below (Lab Notes #7, Figure 3).

From pile to material: six steps

Every chain I have built for this — from folders of Revit models and from folders of drawings — ends up with the same six steps:

  1. Gather — take the folder as it is, convert formats, fingerprint (hash) every file.
  2. Split — a model into levels and rooms; a drawing file into sheets, a sheet into views and dimension marks.
  3. Read — coordinates, areas and dimensions come from geometry, never from a guess.
  4. Judge — names, types, duplicates, mismatches. By rule where a rule exists; by AI, citing the source element it judged, where it doesn't.
  5. Reconcile — every input is accounted for, and a person confirms the points where a wrong answer would cost money.
  6. Use — library rows, section parameters, models: the material.

The short version: code measures, AI judges with evidence, people confirm.

Animation: one level of a public sample model and one synthetic tunnel sheet go through gather, split, read, judge, reconcile and use, with chips showing whether code, AI or a person acts.
The same six steps on one level of a public sample model and one synthetic tunnel sheet. Chips show who acts: code (gray), AI (pink), a person (orange). The sheet's radius mismatch (R1: 6,755 mm written, 6,455 mm drawn) was planted on purpose.

On drawings anyone can open. I ran the same drawing engine, unchanged, on the Civil sample sheet set that ships with AutoCAD. It counted every file (17 scanned = 14 drawings + 3 other), converted all 14 to DXF, and found 28 “sheets” — for a set of 10. The ten sheet files came out as one sheet each. The four shared reference files that the sheets pull in did not: one base drawing was cut into 14 “sheets” because its closed outlines looked like sheet borders, the title-block file became 2, and the other two were counted as sheets of their own. It is the same splitting failure as the unseen batch described below — which is why splitting sheets is the next thing to fix.

IN PRACTICE
Two panels from Autodesk's public Civil sample sheet set: left, the Erosion Control Plan sheet with teal region boxes around its details; right, a base drawing covered by fourteen red rectangles the engine mistook for sheet borders.
A public sheet set through the same engine: left, one sheet and the regions found on it; right, a shared base drawing wrongly cut into 14 sheets. Autodesk's Civil sample sheet set (ships with AutoCAD), read-only; drawings rendered from the engine's own output.

Count everything

One rule makes the rest auditable: every input lands in exactly one bin — used, duplicate (kept apart), failed with a reason, or waiting for a person. If the bins don't add up to the input, nothing is exported. Silence is not success.

On the public sample, the room export reports 54 rooms in, 54 valid shapes, 0 invalid. Field runs are messier — and that is the point: a failed bin with reasons is where the next fix comes from.

Animation: 120 items fall into four bins — used, duplicate, failed with a reason, review; export stays blocked until the last item is placed and the bins add up to the input.
Illustrative counts, not the sample above — the rule is real: in = out, or no export.
IN PRACTICE
A tunnel drawing detail overlaid with a distance map in green, amber and red, showing where the generated output departs from the source drawing.
The same idea at pixel level: a distance map between the source drawing and the generated geometry — green under 2 px, amber under 8 px, red over 8 px. The failures are located, not just counted (tunnel series).

Two sources, two different jobs for AI

BIM models. AI doesn't read the RVT files. It writes the reader — a Revit add-in that extracts rooms and equipment from whole folders of models — and then fixes that reader from the logs the field sends back. Three field rounds so far: the first kept “same name, different family” apart instead of overwriting it; the second turned silent misses into a sheet of reasons; the third added per-element guards, so one bad element no longer stops a whole file. I wrote about this way of building add-ins in AI-Assisted Revit Add-in Development.

Drawings. Here AI judges first, and its repeated judgments become rules. On the road-project set the rules were written from, rules alone agreed with the AI's region judgments in 63% of regions, then 85%, then 92% as more judgments became rules. Then I ran the engine, unchanged, on a batch it had never seen. It broke at the Split step: an architectural set of 23 sheets was split into 59. That failure is now the first task of the next round — which is exactly what an unseen test is for.

Two rows: for BIM models, AI writes an add-in, it runs on model folders, field logs come back and AI fixes the tool; for drawings, a bar chart rises from 63 to 85 to 92 percent, then an unseen batch splits 23 sheets into 59.
AI's job depends on the source. For models it builds and repairs the extraction tool; for drawings its judgments turn into rules — and an unseen batch shows where they break.
IN PRACTICE
A tunnel drawing detail where dashed gray shows the drawn symbol and solid colors show geometry driven by the numeric dimensions.
On the drawing side, every judgment says which source wins: dashed gray is the drawn symbol, solid color is the geometry driven by the numeric dimension (tunnel series).

Where the bridge stands

Honest status, because this series is a journey rather than a finished product:

  • Archive → material: working for models; partly for drawings.
  • Material → GD: working in places. In one large industrial program, equipment data from a previous phase already seeds the next phase's layout runs, and a set of measured real tunnel sections checks my section engine.
  • Material → AI learning: not started. First comes a pre-registered test (pass criteria fixed before the run) of whether learning from this material is needed at all — if a rule or a fast simulation answers in time, no model gets trained.
Status grid: archive to material is working for BIM models and partial for drawings; material to GD is partial for both; material to AI learning has not started for either.
Where the bridge stands today: working, partial, not yet.

The series

Part 1 makes the material, Part 2 feeds it into the loop, Part 3 is about running the chain day to day. Only 2-2 is already published; the cards link to the posts and papers each part builds on.

0 · Mega data — this post
Part 1 · Make the material
  • 1-1 Folders of RVT models → an add-in → a library (coming)
  • 1-2 Counting what's usable: IFC validation (next — based on our Buildings paper)
  • 1-3 Drawing folders → an information model (after the next unseen test)
Part 2 · Feed the loop
Part 3 · Run it
  • 3-1 Code measures, AI judges, people confirm (coming)

Resources

What is sitting in your company's archive — and what would you want an AI to do with it first?

댓글

이 블로그의 인기 게시물

Structural Analysis Workflow with Dynamo and Robot

Dynamo with the Gemini Vision API test(Nano Banana)

Geometry test 0506 stair and routing