A small dental technology company approached Elf.3D with a highly specialized challenge: they needed to turn raw intraoral 3D scans of patients’ mouths into precise, printable surgical guide models with minimal human intervention. This client, a niche innovator in dental surgical guides, was frustrated with the slow, manual CAD workflows traditionally used for such tasks. They lacked an affordable way to automatically process polygonal mesh scans (from intraoral or laser scanners) into ready-to-print guides without relying on expensive CAD software or tedious hand-editing. In conventional approaches, one often has to reverse-engineer scan meshes into CAD surfaces, which is both time-consuming and costly. Elf.3D’s mission was to eliminate that overhead by working directly with the mesh data, building a robust, customizable pipeline tailored to the client’s workflow. We collaborated closely with the client’s engineers to understand every nuance of their process, from scan quirks to surgical requirements, ensuring the solution would fit like a glove – both literally (the guide fitting the patient) and figuratively (integrating smoothly into their software stack).
Key Solution Features: Our custom pipeline introduced several advanced, adaptive algorithms to address the project needs.
Each of these components was developed from scratch by Elf.3D, using smart logic and fuzzy heuristics (no black-box AI or off-the-shelf CAD kernels) to handle the messy realities of 3D scan data. In the sections below, we delve into how each part of the solution works and how it helped transform the client’s workflow.
Every great model starts with clean geometry. The intraoral scans provided by the client were detailed but came with typical scan artifacts – small noise clusters, holes where data was missing, and occasional self-intersecting facets due to reflective surfaces and tight corners in the mouth. Elf.3D’s pipeline begins by automatically healing the raw mesh to ensure it is watertight, manifold (no weird topological errors), and free of self-intersections.We implemented an “automagic” mesh repair module similar to what one finds in high-end mesh libraries, but tuned to dental data. This module identifies and fixes a variety of issues: tiny gaps or cracks are sealed, stray “noise” triangles and floating micro-shells are removed, and any degenerate or overlapping faces are corrected. Crucially, large holes in the scan (for example, where the scanner couldn’t capture due to saliva glare or obstructions) are filled in a curvature-sensitive way – our algorithm analyzes the surrounding surface curvature and intelligently extrapolates it across the void. This means that instead of patching a hole with a flat disk, the fill follows the natural contours of the teeth or gums, yielding a smooth, anatomically plausible surface. By the end of this healing stage, the mesh is a clean, solid foundation: no unwelcome surprises lurk in the geometry that might trip up later steps. The output is a waterproof digital model of the patient’s oral anatomy, ready for guide design.
(Why is this important?) Robust mesh healing is critical because downstream operations like booleans and offsets assume a valid starting model. Non-manifold edges, self-intersections, or missing faces could cause errors in later boolean cuts or result in a guide that’s not printable. Our adaptive healing uses a mix of rules and tolerances – for example, distinguishing between genuine small holes that need filling versus intentional openings (like a missing tooth gap that should remain open). The result is achieved with essentially zero human cleanup; the technician no longer has to spend hours in third-party software fixing scan files. This aligns perfectly with the client’s goal of minimal human post-processing.
With a clean mouth scan in hand, the next challenge was to prepare the implant site on the model. In this case, the client’s surgical guides are tooth-borne: they often rest on existing teeth but provide a pathway for drilling into an implant location (often a site of a missing or extracted tooth). Elf.3D developed custom Boolean geometry operations to modify the mesh precisely in these regions. For example, if the scan still included a tooth that is to be replaced, our pipeline can digitally remove that tooth geometry by subtracting it out from the mesh – essentially performing a virtual extraction. This is done by selecting the tooth region (either via the client’s input or via an automatic feature-detection in the mesh) and using a Boolean difference operation to cut it away cleanly. The result is a socket in the mesh exactly where the guide needs to fit over the gums or neighboring teeth. We also used Booleans to carve out the cylindrical hole through which the implant drill will be guided. Rather than manually modeling these holes, our software procedurally generates a cylinder at the specified implant angle and position, and subtracts it from the guide body (later in the process) with a Boolean difference. Boolean union operations are used as well to add any auxiliary structures; for instance, if the design calls for small stabilizing flanges or rest extensions on neighboring teeth, those can be generated as primitives and unioned into the main guide mesh.
Modern mesh processing pipelines heavily rely on robust Boolean operations for such tasks, and our solution is no exception. The core geometric engine we built performs fast, reliable Booleans on triangle meshes, even for complex dental shapes. We paid special attention to handling edge cases (literally and figuratively) – like ensuring no sliver polygons or bad edges remain after a subtraction. The result is that implant-site modifications (removing a tooth or adding a hole) are done algorithmically, with surgeon-defined parameters (e.g. drill diameter, angles) as inputs, rather than laborious CAD edits. This approach mirrored what high-end libraries achieve, , but we implemented it in a lightweight module that integrates directly into the client’s workflow. By directly operating on the mesh, we avoided any conversion to NURBS or BREP geometry (and thus avoided needing costly CAD software). All geometry preparation happens on the mesh itself – a key factor that kept the solution efficient and cost-effective.
One of the trickiest aspects of guide design is turning the patient’s anatomy surface into an actual guide that can be 3D printed. Essentially, the guide is like a cap or shell that snugly fits over the teeth/gums and has a certain thickness. We achieved this by using offset and hollowing operations. After preparing the regions for implants, our software takes the cleaned patient mesh and generates an offset surface outward by a specified thickness (for example, 2–3 mm, or whatever the guide’s plastic thickness needs to be). This offset is done in a manner analogous to a Minkowski sum or morphological dilation of the mesh – effectively “inflating” the surface outward uniformly. The offset surface becomes the outer surface of the surgical guide. We then form a solid shell by connecting the offset surface to the original (or slightly reduced) surface at the edges of the guide’s intended coverage area. In simpler terms, we create a hollow shell that conforms perfectly to the patient’s mouth geometry on the inside and is smooth on the outside, with a roughly constant wall thickness.
To illustrate, imagine the scanned teeth region as a snug mold – we are creating the negative of that mold with a bit of added thickness. Our hollowing tool ensures that the interior of the guide replicates the patient’s anatomy (so it seats firmly), while the bulk of the guide is hollow to save material and weight. Only the shell remains, rather than a heavy solid block. We again utilize Boolean operations under the hood: one way to hollow is to take the offset mesh and subtract the original mesh from it, leaving a shell volume. Our custom boolean engine handled this solid offset creation robustly. The algorithms had to be adaptive – dental scans can have very fine details (like tooth cusps or interdental gaps), so the offsetting process uses smart logic to avoid creating tiny, hard-to-print features. For example, sharp concave features might get smoothed out slightly on the offset to ensure uniform wall thickness. These are heuristic decisions encoded into the pipeline, balancing fidelity and manufacturability. The end product of this stage is a closed mesh representing the guide body – a shell that, on its inner surface, fits the patient anatomy and, on its outer surface, has a nice smooth form. This guide body is now ready for functional details like cylinders and labels.
Surgical guides typically have metal sleeves or simply cylindrical holes that guide the drill to the exact planned implant position and angle. Placing these guide cylinders digitally into our mesh is another challenge we overcame with a combination of geometry and logic. The client’s planning software would provide the desired position and angulation for each implant’s guide tube. Elf.3D’s module takes those parameters and inserts a cylinder (modeled as a mesh) into the scene. However, it’s not as simple as just jamming a cylinder through the mesh – we must ensure it integrates cleanly with the guide and doesn’t cause unwanted collisions or protrusions. Our solution uses collision detection to evaluate how the cylinder intersects the guide shell. Essentially, we perform an intersection test between the cylinder mesh and the current guide mesh to identify any interfering triangles or misalignments. If the cylinder intersects significantly (beyond just where it is meant to cut through), the software can flag or automatically adjust the placement slightly. In one instance, an initial position for a cylinder was colliding with a tall tooth cusp – our algorithm detected this and we were able to adjust the cylinder’s position or the guide shape locally to resolve it, all in software.
We also employed a sweep-based logic to verify that a drill could actually travel through the guide without obstruction. This meant computing the swept volume of a cylinder (representing the path of the drill) along the insertion direction and ensuring no part of the guide mesh intrudes into that volume. By simulating a virtual “insertion” of the cylinder through the guide, we confirmed that the guide had proper clearance. This technique is analogous to how one might check assembly clearances in CAD, but here done on mesh data. It’s similar to generating a swept volume or using a “sweep” function for undercut removal, except applied to the cylinder path. Only after these checks pass do we perform the Boolean subtraction that actually cuts the cylindrical hole in the guide mesh for the drill. The result is a perfectly placed hole that matches the planned angle and diameter, with no stray collisions – essentially a digital drill guide aligned to the surgical plan. By automating this placement and validation, Elf.3D removed yet another manual step that the client previously had to do by visual inspection. The collision detection routines are optimized (bounding-volume hierarchies and other acceleration structures) so that even testing multiple cylinders is very fast, keeping the pipeline efficient. The guide now has all its critical geometry: a shell that fits and holes where needed for implants.
In a production environment, especially in medical devices, traceability is important. The client wanted each surgical guide to carry a unique identifier(such as a serial number or patient ID) embossed or engraved on its surface. Doing this manually for each guide would be impractical, so we developed a nifty embossing tool within the pipeline. This component takes a text string (the ID) and a target area on the mesh (typically the outer surface of the guide where there’s some flat or smooth space) and automatically imprints the text onto the mesh geometry. Under the hood, the text is converted into 3D curves and surfaces (essentially creating a small mesh of the letters/numbers). Our algorithm then projects this text mesh onto the curved guide surface and performs a Boolean union or subtraction depending on whether an embossed (raised) or debossed (engraved) label is desired. In practice, we slightly emboss (raise) the text by a small amount (say 0.5 mm) so that it’s easily readable on the printed guide. We built in heuristics to ensure the text isn’t placed on a highly curved or crucial functional area, and that it’s scaled appropriately to the guide size.
This feature was implemented with flexibility in mind – the client can customize the font, size, depth, and position template for the ID label. Once set up, the pipeline stamps each generated guide with its own identifier automatically. The imprint & emboss logic was one of the few places we had to blend pure geometry with a bit of typographic handling, but the result worked great. It ensures that if the guides ever get mixed up or need tracking, one can quickly identify them by the embossed code. Importantly, all of this happens without any user modeling effort – previously, adding text would have required importing the mesh into a CAD program or MeshMixer and painstakingly performing the emboss operation for each guide. Now it’s one click (or fully scriptable) in Elf.3D’s module. This modest addition underscores our focus on small details that make a big difference for workflow efficiency.
(Note: Out of an abundance of caution, we avoided placing the embossing on any critical surfaces and kept it shallow, so it does not impact the guide’s strength or how it fits on the teeth.)
One of the final and most crucial steps was handling undercuts. In dentistry, an undercut is an area where the geometry of the teeth or gums would lock a rigid appliance in place. Imagine a tooth that is wider at the top than at the base – a guide that wraps around it could get stuck because the wider top prevents it from lifting off. To ensure the surgical guide can be easily placed on and taken off the patient’s teeth, we had to automatically detect and remove undercut regions from the guide interior. Elf.3D tackled this with an algorithmic approach inspired by “sweep” or path-of-insertion analysis. We simulate the process of the guide being inserted (or removed) along a chosen direction (usually perpendicular to the occlusal plane, i.e., roughly “upwards” from the teeth). As we do this, we compute the volume that the teeth occupy when “swept” along that direction. Any part of the guide that would intersect with that swept volume is an undercut that would cause an interference during insertion/removal.
In practice, our software generates a temporary mesh representing the space the teeth take up when moved upward – essentially a swept volume of the dentition. We then use a Boolean subtraction to cut this swept volume out of the guide’s inner surface. What remains is a slightly adjusted inner surface where concave undercuts have been relieved (filled or smoothed out). This process is analogous to methods reported in research for removing undercuts in dental splints, and it ensures that all concave curvatures on the guide correspond to convex or at least neutral shapes on the teeth, so nothing hooks or locks in place. We incorporated fuzzy heuristics here to decide how much to compensate for undercuts – for example, a very tiny undercut might be left as-is to preserve fit, whereas a significant undercut is fully removed. These heuristics can be tuned (the client can adjust an “undercut tolerance” parameter) to balance between a snug fit and ease of removal.
By automating undercut removal, Elf.3D’s pipeline guarantees that the printed guide can seat completely and also be taken off without a struggle. This was verified by the client in test prints – guides designed with our software snapped on and off with just the right amount of friction. The use of a sweep-based algorithm with Booleans to trim the guide is a powerful solution also employed by advanced dental CAD systems, but we delivered it in a lightweight, custom package. The result is an optimized guide geometry: it not only matches the patient’s anatomy closely for stability, but also has no traps that would prevent its removal after surgery. In short, the guide is both secure and user-friendly, thanks to these final geometric tweaks.
Elf.3D’s custom solution was delivered as a standalone software module that plugged directly into the client’s existing workflow. From the beginning, our approach was one of close collaboration and agility. Being small companies, both Elf.3D and the client could iterate quickly and focus on the deep technical details rather than bureaucracy. We worked hand-in-hand with the client’s dental experts and software team, refining our algorithms through multiple cycles. For instance, when an early version of the mesh healing tool was closing a gap that should have remained open, the client’s feedback helped us introduce smarter heuristics for hole filling. When our initial offset caused slight pressure points on a particularly irregular tooth, we fine-tuned the algorithm’s smoothing. This flexibility and willingness to custom-fit the solution set our approach apart from off-the-shelf tools that force users to adapt to the software. Instead, we adapted the software to the user’s unique needs.
The final product integrated seamlessly: it can be run as an automatic pipeline with minimal clicks, or even headlessly as part of the client’s cloud processing service. It does not require any expensive CAD licenses or external dependencies – everything runs within the client’s application stack. The client now has the ability to go from a raw intraoral scan to a ready-for-print surgical guide in a fraction of the time it used to take, and with virtually no manual model fixing. This not only saves labor but also reduces the possibility of human error, leading to more consistent guides.
Both Elf.3D and our client take pride in this success. It showcases how deep, hands-on innovation in a narrow 3D domain can yield results that rival, and even exceed, those of much larger systems – all while staying modest in scope and cost. By focusing on the algorithmic core (mesh healing, Booleans, offsets, etc.) and tailoring it to the problem at hand, we delivered a solution that is smart in every sense: it’s intelligent in how it processes geometry, and it’s a smart business move by avoiding unnecessary overhead. This project stands as a testament to the power of collaborative development and the effectiveness of custom, heuristic-driven algorithms in solving real-world 3D workflow challenges.
Conclusion: What started as a daunting request – “Can we automate the creation of a surgical guide from scan data without buying a big CAD system?” – ended as a resounding success. Elf.3D’s bespoke pipeline empowered our dental tech client to ramp up their guide production with confidence. By removing noise, filling holes, carving precise features, and adding final polish (literally embossing their signature on each piece), we helped turn their vision of an efficient, fully digital workflow into reality. This success story exemplifies Elf.3D’s philosophy: combine technical excellence in algorithms with close client collaboration, and even the smallest companies can achieve big innovations in 3D technology.
About Elf.3D: We are a small team of three engineers and one project manager. Rather than selling the same software to everyone, we create new code for each partner and their specific data. If your 3-D workflow suffers from geometry issues that mainstream tools overlook, contact us at info@elf3d.com. We will start with a blank repository and craft a solution around your needs.