# How to Adjust Edge Scaling for Quads in AutoRemesher

> Learn how to adjust edge scaling for quads in AutoRemesher. Use setScaling() to stretch or compress edges for optimized mesh generation.

- Repository: [Jeremy HU/autoremesher](https://github.com/huxingyi/autoremesher)
- Tags: how-to-guide
- Published: 2026-07-09

---

**Set the `scaling` parameter via `AutoRemesher::AutoRemesher::setScaling()` before starting the remesh process, where values greater than 1.0 stretch edges and values less than 1.0 compress them.**

AutoRemesher is an open-source quad mesh generation tool that converts triangle meshes into clean quad layouts. When you need to control the density or size of the resulting quads, you can adjust edge scaling for quads in AutoRemesher through its parameterization system, which modifies how the algorithm stretches or shrinks edges during UV field construction.

## Understanding Edge Scaling in AutoRemesher

Edge scaling controls the target length of edges in the generated quad mesh relative to the input geometry. The parameter is stored internally as `m_scaling` within the `Parameterizer` class, with a default value of **1.0** representing no scaling.

When you increase the scaling factor above 1.0, the algorithm interprets this as a request for longer edges, effectively reducing quad density and creating larger faces. Conversely, values below 1.0 produce shorter edges and denser quad layouts. This scaling factor is applied during the UV parameterization phase, influencing the field that drives final quad extraction.

## Where Edge Scaling Is Stored and Applied

The edge scaling parameter flows through three architectural layers in the huxingyi/autoremesher codebase:

### Core Parameterizer Storage ([`src/AutoRemesher/parameterizer.h`](https://github.com/huxingyi/autoremesher/blob/main/src/AutoRemesher/parameterizer.h))

The actual scaling value resides in the `Parameterizer` class as a private member variable:

```cpp
// src/AutoRemesher/parameterizer.h#L52
void setScaling(double scaling) {
    m_scaling = scaling;
}

```

The `m_scaling` member directly influences the UV field construction algorithm, scaling edge lengths before quad extraction occurs.

### Public API Access ([`src/AutoRemesher/autoremesher.h`](https://github.com/huxingyi/autoremesher/blob/main/src/AutoRemesher/autoremesher.h))

The `AutoRemesher` class exposes a public setter to configure the parameterizer:

```cpp
// src/AutoRemesher/autoremesher.h#L55
void AutoRemesher::setScaling(double scaling);

```

This is the primary entry point for programmatically adjusting edge scaling when using AutoRemesher as a library.

### Frontend Bridge ([`src/quadmeshgenerator.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/quadmeshgenerator.cpp))

The Qt-based `QuadMeshGenerator` acts as the intermediary between user interfaces and the core engine:

```cpp
// src/quadmeshgenerator.cpp#L61
if (m_parameters.scaling > 0)
    m_autoRemesher->setScaling(m_parameters.scaling);

```

This code forwards the user-defined scaling value from the `Parameters` struct to the core remesher instance.

## Three Methods to Adjust Edge Scaling

You can modify the edge scaling parameter through the GUI, command line, or direct API calls.

### GUI Method (Preferences Dialog)

When using the Qt interface, the scaling value is exposed through a spin box typically found in the preferences or settings panel. The UI enforces a practical range of **0.1 to 5.0** with 0.1 increments:

```cpp
auto scalingSpin = new QDoubleSpinBox(this);
scalingSpin->setRange(0.1, 5.0);
scalingSpin->setSingleStep(0.1);
scalingSpin->setValue(currentParameters.scaling);
connect(scalingSpin, QOverload<double>::of(&QDoubleSpinBox::valueChanged),
        [this](double v){ currentParameters.scaling = v; });

```

The value is stored in `QuadMeshGenerator::Parameters::scaling` and automatically passed to the remesher when generation begins.

### CLI Method (Command Line Arguments)

For batch processing or automated pipelines, use the `--scaling` argument handled in [`main.cpp`](https://github.com/huxingyi/autoremesher/blob/main/main.cpp):

```bash
./autoremesher --scaling 1.5 input.obj output.obj

```

The command-line parser injects this value into `QuadMeshGenerator::Parameters` before the remeshing process starts.

### Programmatic Method (Direct API)

When embedding AutoRemesher in your own C++ applications, call `setScaling()` directly on your `AutoRemesher` instance:

```cpp
AutoRemesher::AutoRemesher remesher;
remesher.setScaling(1.5);  // Increase edge lengths by 50%

```

This method provides the most control for custom tools and scripted workflows.

## Code Examples

### Standalone C++ Implementation

Below is a complete example showing how to configure edge scaling when using AutoRemesher as a library:

```cpp
#include <AutoRemesher/AutoRemesher>
#include "quadmeshgenerator.h"

int main() {
    // Prepare input mesh data
    std::vector<AutoRemesher::Vector3> vertices = /* ... */;
    std::vector<std::vector<size_t>> triangles = /* ... */;

    // Configure parameters with custom scaling
    QuadMeshGenerator::Parameters params;
    params.scaling = 1.5;               // Stretch edges by 50%
    params.targetTriangleCount = 2000;  // Optional remeshing target

    // Initialize and run generator
    QuadMeshGenerator generator(vertices, triangles, params);
    generator.process();                // Runs in worker thread

    // Retrieve generated quads
    auto quads = generator.takeRemeshedQuads();   // std::vector<std::vector<size_t>>
}

```

### Qt UI Integration

For developers extending the AutoRemesher GUI, connect UI controls to the parameter system:

```cpp
// In your preferences dialog implementation
void setupScalingControl() {
    auto scalingSpin = new QDoubleSpinBox(this);
    scalingSpin->setRange(0.1, 5.0);
    scalingSpin->setSingleStep(0.1);
    scalingSpin->setValue(currentParameters.scaling);
    
    connect(scalingSpin, QOverload<double>::of(&QDoubleSpinBox::valueChanged),
            [this](double v){ 
                currentParameters.scaling = v; 
            });
}

```

When the user triggers remeshing, `QuadMeshGenerator::generate()` automatically forwards `currentParameters.scaling` to the core engine via `m_autoRemesher->setScaling()`.

## Summary

- **Edge scaling** controls quad density by modifying target edge lengths during UV parameterization, with `m_scaling` defaulting to 1.0 in [`src/AutoRemesher/parameterizer.h`](https://github.com/huxingyi/autoremesher/blob/main/src/AutoRemesher/parameterizer.h).
- **Three entry points** exist for adjusting the parameter: the GUI preferences dialog (0.1–5.0 range), the `--scaling` CLI argument, or direct calls to `AutoRemesher::setScaling()`.
- **Data flow** runs from `QuadMeshGenerator::Parameters` through `src/quadmeshgenerator.cpp#L61` to the core `AutoRemesher` class and ultimately to the `Parameterizer`.
- **Values above 1.0** produce larger, sparser quads, while **values below 1.0** create denser meshes with smaller faces.

## Frequently Asked Questions

### What is the default edge scaling value in AutoRemesher?

The default value is **1.0**, defined as the initial value for `m_scaling` in the `Parameterizer` class. This represents neutral scaling where edge lengths remain proportional to the input mesh's geometric features.

### How does edge scaling affect the final quad mesh?

The scaling factor is applied during UV field construction in the parameterization phase. Values greater than 1.0 stretch the UV coordinates, resulting in fewer, larger quads, while values less than 1.0 compress the field and increase quad density. This directly impacts the resolution and regularity of the output mesh.

### What range of values is recommended for edge scaling?

According to the Qt frontend implementation in the huxingyi/autoremesher repository, the practical range is **0.1 to 5.0**. Values below 0.1 may produce unstable UV parameterizations, while values above 5.0 typically result in overly coarse meshes that lose geometric detail.

### Can I adjust edge scaling after remeshing has started?

No. The scaling parameter must be set before calling `process()` or `generate()` on the remesher instance. Once the `AutoRemesher` begins the isotropic remeshing and parameterization pipeline, the scaling value is locked and cannot be modified for that generation pass.