💻 computer science

Adaptive Scaling with Geometric and Visual Continuity of completed 3D objects

This paper introduces a part-aware scaling framework that transforms static, rigid 3D object completions into editable, structurally coherent models by automatically segmenting parts and applying smooth, repetition-preserving interpolation to enable flexible and artifact-free geometric and visual deformation.

Original authors: Jelle Vermandere, Maarten Bassier, Maarten Vergauwen

Published 2026-02-16

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Jelle Vermandere, Maarten Bassier, Maarten Vergauwen

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a digital 3D model of a chair, a bookshelf, or a sofa that was scanned from a real room. Because the scanner couldn't see behind the object or through other things, the computer had to "guess" and fill in the missing parts to make a complete, solid object. This is called Object Completion.

The problem? These completed digital objects are like frozen statues. They look perfect, but if you try to stretch them to make a chair taller or a bookshelf wider, they turn into a weird, distorted blob. The legs might get fat and short, or the shelves might stretch into long, thin noodles.

This paper introduces a new way to fix that. Think of it as giving these frozen statues elasticity and intelligence. Here is how they did it, explained simply:

1. The "Lego" Breakdown (Part Segmentation)

Instead of treating the whole object as one giant, solid block of clay, the researchers teach the computer to break the object down into its natural "Lego bricks."

The Analogy: Imagine a wooden chair. If you stretch the whole thing, the legs get weird. But if you realize the chair is made of a seat, four legs, and a backrest, you can stretch just the legs to make the chair taller without messing up the seat.
The Tech: They use a mathematical trick called "Convex Decomposition" to slice the object into smooth, logical chunks (like separating the legs from the seat) without needing to know what the object is beforehand. It just looks at the shape and says, "This part curves differently, so it's a separate piece."

2. The "Sliding Door" (Scaling Zones)

Once the object is broken into pieces, how do you tell the computer which part to stretch?

The Analogy: Imagine a sliding glass door. You can set a "Start Line" and an "End Line" anywhere on the object. Everything between those lines is the "Scaling Zone."
The Tech: The user draws two invisible planes (flat sheets) through the object. Everything between them is the area that gets stretched. Everything outside stays exactly the same. This gives you precise control, like using a ruler to measure exactly how much you want to grow.

3. The "Seamless Stretch" (Interpolation)

Now, you tell the computer to stretch the "Scaling Zone." If you just pull the pixels apart, you get a blurry mess.

The Analogy: Imagine stretching a rubber band that has a pattern painted on it. If you stretch it too fast, the pattern distorts. But if you have a smart rubber band that knows how to smoothly blend the colors and shapes as it stretches, the pattern stays crisp.
The Tech: The computer uses a technique called Linear Interpolation. It looks at the distance and color at the start of the stretch and the end of the stretch, then mathematically "fills in the middle" so the transition is smooth. It does this for the shape (geometry) and the color (texture) simultaneously, so the object doesn't look like a melted wax figure.

4. The "Pattern Repeat" (For Big Changes)

What if you want to turn a short bookshelf into a massive wall-to-wall library? Just stretching the one shelf would make the books look like giant, stretched-out blobs.

The Analogy: Imagine you have a wallpaper with a flower pattern. If you need to cover a huge wall, you don't stretch one flower until it's huge; you copy and paste the flower pattern over and over again.
The Tech: If the user wants a huge stretch, the system detects that the object has a repeating pattern (like shelves or cushions). Instead of stretching the single part, it repeats that part multiple times to fill the new space. This keeps the object looking realistic and structurally sound.

Why Does This Matter?

Currently, if an architect wants to redesign a room or a game designer wants to change the size of a prop, they have to manually rebuild the 3D model from scratch. That takes hours.

This method allows them to:

Take a messy, incomplete scan of a real room.
Let the computer fill in the gaps.
Instantly resize specific parts (like making a table longer or a sofa wider) while keeping the rest looking perfect.

In a nutshell: This paper turns rigid, unchangeable 3D models into smart, flexible clay that you can stretch, shrink, and repeat parts of without breaking the illusion of reality. It bridges the gap between "scanning a real object" and "designing a new one."

1. Problem Statement

Current 3D object completion networks, particularly those utilizing Signed Distance Fields (SDFs) and Texture Fields, produce high-quality, watertight, and textured 3D models from incomplete scans. However, these resulting models are static and rigid.

The Limitation: Standard scaling methods (global or naive selective scaling) applied to these SDFs cause severe structural distortions. Uniform scaling stretches all parts equally, ruining proportions (e.g., widening chair legs unnaturally). Naive selective scaling often fails on complex geometries or repetitive structures, leading to artifacts and loss of visual coherence.
The Gap: There is a lack of a framework that allows for part-aware, proportional scaling of completed SDFs while preserving geometric integrity and texture continuity, specifically for applications in indoor redesign, simulation, and digital content creation.

2. Methodology

The proposed framework transforms static completed SDFs into editable, structurally coherent objects through a four-stage pipeline:

A. Preprocessing: Generating Colored SDFs (CSDFs)

Input: Partially scanned indoor scenes.
Completion: Uses state-of-the-art models (AutoSDF for geometry and IF-Net/TextureFields for color) to reconstruct missing parts.
Representation: The output is a unified Colored Signed Distance Function (CSDF) discretized into a $128 \times 128 \times 128$ $128 \times 128 \times 128$ voxel grid.
- RGB Channels: Store color/texture information.
- Alpha Channel: Stores the SDF distance values.
- This 3D texture format allows for simultaneous manipulation of geometry and appearance.

B. Part Segmentation (Approximate Convex Decomposition)

Technique: The method employs Approximate Convex Decomposition (ACD) using the CoACD algorithm.
Process:
1. Extracts a watertight mesh from the SDF via Marching Cubes.
2. Uses a multi-step tree search to cut the mesh into nearly convex parts using cutting planes.
3. Merges adjacent convex pairs to minimize unnecessary cuts.
Outcome: The object is segmented into distinct, non-overlapping parts. These part indices are remapped to the CSDF voxel grid. This geometry-based segmentation is class-agnostic (does not rely on semantic labels), ensuring generalizability.

C. Scaling Zone Definition

Interaction: Users define a scaling region using two parallel planes along a chosen axis (Start Plane and End Plane).
Control: The user moves the End Plane to a new location, defining the target size.
Logic:
- Parts before the Start Plane remain static.
- Parts beyond the End Plane are translated.
- Parts within the zone are isolated for deformation.

D. Interpolation and Deformation Strategies

The core innovation lies in how the isolated zone is deformed based on the object's characteristics:

Linear Interpolation (Standard Scaling):
- SDF: Linearly interpolated between the start and end boundaries to ensure smooth geometric transitions.
- Color: RGB values are linearly interpolated across the zone.
- Part Indices: Since indices are discrete, the boundary between parts is identified where the SDF magnitude changes significantly, ensuring parts do not blend unnaturally.
- Refinement: After interpolation, the SDF is re-evaluated to correct discontinuities by recalculating distances for voxels affected by the new surface.
Repetition-Based Scaling (Tiling):
- Use Case: For objects with repetitive patterns (e.g., bookshelf shelves, sofa cushions).
- Mechanism: Instead of stretching a single part, the system repeats the selected component $N$ times to fill the new distance.
- Continuity: The repeated sections are slightly scaled up/down via linear interpolation to fit the exact target length, and the transition layers between repetitions are smoothed to match the original neighbor, preventing visual seams.

3. Key Contributions

Part-Aware Scaling Framework: A novel method to transform static SDF completions into editable objects without requiring pre-defined semantic part libraries.
Unified CSDF Manipulation: Simultaneous interpolation of geometry (SDF), texture (RGB), and topology (Part Indices) within a single voxel grid.
Repetition Strategy: A specific algorithm for handling large-scale deformations on repetitive structures by tiling components rather than stretching them, preserving structural logic.
Convex Decomposition Integration: Utilizing CoACD for robust, class-agnostic segmentation that ensures smooth interpolation boundaries.

4. Experimental Results

Datasets: Evaluated on Matterport3D (indoor scans) and Sketchfab (high-quality scans).
Comparison:
- Global Scaling: Resulted in unnatural proportions (e.g., fat legs, wide gaps).
- Naive Selective Scaling: Worked for simple shapes but failed on complex, multi-constraint geometries (e.g., shelves), causing distortion.
- Proposed Method:
  - Successfully preserved proportions in non-scaling zones.
  - Tiling Mode: Excelled at scaling repetitive objects (bookshelves, sofas) by maintaining the visual frequency and structural integrity of the pattern.
Implementation: Integrated into a Unity interface using raymarching shaders for real-time visualization and user interaction.

5. Significance and Future Work

Significance: This work bridges the gap between procedural generation (which relies on pre-defined parts) and SDF-based editing (which is usually rigid). It enables dynamic, realistic manipulation of 3D assets in AECO (Architecture, Engineering, Construction, Operations) and gaming, specifically for renovation and simulation where object dimensions must change without breaking visual realism.
Limitations:
- Resolution trade-offs: The fixed $128^3$ grid may lose fine details during resampling.
- Segmentation: Convex decomposition is geometric, not semantic; it may not always align with human-perceived "parts" (e.g., splitting a complex organic shape).
Future Directions: Improving segmentation robustness, implementing adaptive voxel resolutions, and integrating learned deformation priors to handle highly organic, non-repetitive shapes.