When working with engineering data, one of the biggest challenges is handling the variety of formats and the sheer complexity of information. Recently, I set out on an experiment: could we go from raw geometry data — just points and lines — to fully classified tower sections?
This post shares the journey of that experiment: the goal, the workflow, the results, and where this could take us next.
The Goal
I wanted to keep the scope short, timeboxed, and experimental. The aim wasn't to build a feature that enables us to get to towers from lines and points but to test whether we could create a proof of concept (POC) for parsing and classifying tower geometry.
Key goals included:
- Handling flexible data inputs — different file formats that contain the data
- Creating an intermediate data structure to bridge raw files and tower geometry - what I’ll call the Shapemaker model
- Exploring whether we could reverse engineer sections from just nodes and members.
- Reducing dependency on full datasets, instead building geometry from minimal input data.
In short: could we reliably move from messy, varied inputs to structured tower geometry?
MSTower and Beyond
For this experiment, I started with MSTower-exported archive files, which contain exactly the node and member data needed to reconstruct a tower’s geometry. Parsing these files gave me a concrete foundation for testing the approach.
But I didn’t stop there. To make the parser more flexible and general-purpose, I extended it to handle Dlubal exported files as well. These files carry the same type of geometric and connectivity information, so it was a natural next step. The result was a parser that could adapt to different file types and data sources while still producing a consistent Shapemaker model.
The Results
The experiment delivered some promising results:
- I could identify and classify structural elements like legs, diagonals, and bracings.
- I detected which face each element belonged to.
- I successfully found panel points and grouped elements by panel.
- I even managed to detect bracing patterns.
In other words, we went from unlabeled lines in MSTower/Dlubal files to a Shapemaker model that captures the meaningful structural layout of a tower.
Beyond Parsing: Next Experiments
Of course, this is just a beginning. I’ve started exploring more advanced approaches, including:
- Machine Learning: leveraging datasets like DeepPatent2 for understanding technical drawings.
- Image Processing: techniques like Hough Line Transform (OpenCV) to detect geometry from drawings.
- Neural Networks: experimenting with PPGNet for image-to-geometry tasks.
These open up possibilities of going not just from data files, but from images of towers.
The Bigger Picture
Why does this matter?
With further refinement, we could integrate this into Shapemaker to go from “lines to towers” automatically. That means:
- Faster tower onboarding
- Strong alignment with our Tower Builder
What started as a three week POC could eventually evolve into a key piece of our system.
Conclusion
This experiment showed that parsing and classifying tower geometry from MSTower and Dlubal exports is possible, and that a flexible parser can handle multiple data sources consistently. With some more work, we can transform this into a production-ready tool that accelerates tower onboarding and creation.
It’s a small step in the journey from raw data to structured engineering models — but one that could open up big opportunities through the Shapemaker model.
Here is a quick video demonstrating different phases of the experiment:
