quality.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2025                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                       *
 *                                                                           *
 * This program is distributed in the hope that it will be useful,           *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_ALGORITHMS_MESH_STAT_QUALITY_H
#define VCL_ALGORITHMS_MESH_STAT_QUALITY_H
 
#include <vclib/math/base.h>
#include <vclib/math/histogram.h>
#include <vclib/mesh/requirements.h>
#include <vclib/views/mesh.h>
 
namespace vcl {
 
template<MeshConcept MeshType>
auto vertexQualityMinMax(const MeshType& m)
{
    requirePerVertexQuality(m);
 
    auto [min, max] = std::ranges::minmax(m.vertices() | views::quality);
    return std::make_pair(min, max);
}
 
template<FaceMeshConcept MeshType>
auto faceQualityMinMax(const MeshType& m)
{
    requirePerFaceQuality(m);
 
    auto [min, max] = std::ranges::minmax(m.faces() | views::quality);
 
    return std::make_pair(min, max);
}
 
template<MeshConcept MeshType>
auto vertexQualityAverage(const MeshType& m)
{
    requirePerVertexQuality(m);
 
    using VertexType  = MeshType::VertexType;
    using QualityType = VertexType::QualityType;
 
    QualityType avg = 0;
 
    for (const VertexType& v : m.vertices())
        avg += v.quality();
 
    return avg / m.vertexNumber();
}
 
template<FaceMeshConcept MeshType>
auto faceQualityAverage(const MeshType& m)
{
    requirePerFaceQuality(m);
 
    using FaceType    = MeshType::FaceType;
    using QualityType = FaceType::QualityType;
 
    QualityType avg = 0;
 
    for (const FaceType& f : m.faces())
        avg += f.quality();
 
    return avg / m.faceNumber();
}
 
template<MeshConcept MeshType>
std::vector<typename MeshType::VertexType::QualityType> vertexRadiusFromQuality(
    const MeshType& m,
    double          diskRadius,
    double          radiusVariance,
    bool            invert = false)
{
    requirePerVertexQuality(m);
 
    using VertexType  = MeshType::VertexType;
    using QualityType = VertexType::QualityType;
 
    std::vector<QualityType>            radius(m.vertexContainerSize());
    std::pair<QualityType, QualityType> minmax = vertexQualityMinMax(m);
 
    float minRad   = diskRadius;
    float maxRad   = diskRadius * radiusVariance;
    float deltaQ   = minmax.second - minmax.first;
    float deltaRad = maxRad - minRad;
    for (const VertexType& v : m.vertices()) {
        radius[m.index(v)] =
            minRad + deltaRad * ((invert ? minmax.second - v.quality() :
                                           v.quality() - minmax.first) /
                                 deltaQ);
    }
 
    return radius;
}
 
template<MeshConcept MeshType, typename HScalar = double>
Histogram<HScalar> vertexQualityHistogram(
    const MeshType& m,
    bool            selectionOnly = false,
    uint            histSize      = 10000)
{
    requirePerVertexQuality(m);
 
    using VertexType = MeshType::VertexType;
 
    auto minmax = vertexQualityMinMax(m);
 
    Histogram<HScalar> h(minmax.first, minmax.second, histSize);
    for (const VertexType& v : m.vertices()) {
        if (!selectionOnly || v.selected()) {
            assert(!isDegenerate(v.quality()));
            h.addValue(v.quality());
        }
    }
    return h;
}
 
template<FaceMeshConcept MeshType, typename HScalar = double>
Histogram<HScalar> faceQualityHistogram(
    const MeshType& m,
    bool            selectionOnly = false,
    uint            histSize      = 10000)
{
    requirePerFaceQuality(m);
 
    using FaceType = MeshType::FaceType;
 
    auto minmax = vertexQualityMinMax(m);
 
    Histogram<HScalar> h(minmax.first, minmax.second, histSize);
    for (const FaceType& f : m.faces()) {
        if (!selectionOnly || f.selected()) {
            assert(!isDegenerate(f.quality()));
            h.addValue(f.quality());
        }
    }
    return h;
}
 
} // namespace vcl
 
#endif // VCL_ALGORITHMS_MESH_STAT_QUALITY_H