color.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_UPDATE_COLOR_H
#define VCL_ALGORITHMS_MESH_UPDATE_COLOR_H
 
#include <vclib/algorithms/mesh/stat.h>
 
#include <vclib/mesh.h>
#include <vclib/space/core.h>
 
#include <set>
 
namespace vcl {
 
namespace detail {
 
struct ColorAvgInfo
{
    Point4<uint> c;
    uint         cnt = 0;
};
 
template<uint ELEM_ID, MeshConcept MeshType>
void setPerElemColorFromVertexColor(MeshType& m)
{
    requirePerVertexColor(m);
    requirePerElementComponent<ELEM_ID, CompId::VERTEX_REFERENCES>(m);
    requirePerElementComponent<ELEM_ID, CompId::COLOR>(m);
 
    for (auto& e : m.template elements<ELEM_ID>()) {
        Point4<uint> avg(0, 0, 0, 0);
        for (const auto* v : e.vertices()) {
            avg += v->color().template cast<uint>();
        }
        avg /= e.vertexNumber();
        e.color() = avg.template cast<uint8_t>();
    }
}
 
template<uint ELEM_ID, MeshConcept MeshType>
void setPerVertexColorFromElemColor(MeshType& m)
{
    requirePerVertexColor(m);
    requirePerElementComponent<ELEM_ID, CompId::VERTEX_REFERENCES>(m);
    requirePerElementComponent<ELEM_ID, CompId::COLOR>(m);
 
    std::vector<ColorAvgInfo> avgColors(m.vertexContainerSize());
 
    for (const auto& e : m.template elements<ELEM_ID>()) {
        for (const auto* v : e.vertices()) {
            avgColors[v->index()].c += e.color().template cast<uint>();
            avgColors[v->index()].cnt[v->index()]++;
        }
    }
 
    for (auto& v : m.vertices()) {
        if (avgColors[v.index()].cnt > 0) {
            avgColors[v.index()] /= avgColors[v.index()].cnt[v.index()];
            v.color() = avgColors[v.index()].c.template cast<uint8_t>();
        }
    }
}
 
} // namespace detail
 
template<MeshConcept MeshType>
void setPerVertexColor(
    MeshType& m,
    Color     c            = Color::White,
    bool      onlySelected = false)
{
    requirePerVertexColor(m);
 
    if (onlySelected) {
        std::ranges::fill(m.vertices() | views::selected | views::colors, c);
    }
    else {
        std::ranges::fill(m.vertices() | views::colors, c);
    }
}
 
template<FaceMeshConcept MeshType>
void setPerFaceColor(
    MeshType& m,
    Color     c            = Color::White,
    bool      onlySelected = false)
{
    requirePerFaceColor(m);
 
    if (onlySelected) {
        std::ranges::fill(m.faces() | views::selected | views::colors, c);
    }
    else {
        std::ranges::fill(m.faces() | views::colors, c);
    }
}
 
template<EdgeMeshConcept MeshType>
void setPerEdgeColor(
    MeshType& m,
    Color     c            = Color::White,
    bool      onlySelected = false)
{
    requirePerEdgeColor(m);
 
    if (onlySelected) {
        std::ranges::fill(m.edges() | views::selected | views::colors, c);
    }
    else {
        std::ranges::fill(m.edges() | views::colors, c);
    }
}
 
template<HasColor MeshType>
void setMeshColor(MeshType& m, Color c = Color::White)
{
    m.color() = c;
}
 
template<FaceMeshConcept MeshType>
void setPerVertexColorFromFaceColor(MeshType& m)
{
    detail::setPerVertexColorFromElemColor<ElemId::FACE>(m);
}
 
template<FaceMeshConcept MeshType>
void setPerFaceColorFromVertexColor(MeshType& m)
{
    detail::setPerElemColorFromVertexColor<ElemId::FACE>(m);
}
 
template<EdgeMeshConcept MeshType>
void setPerEdgeColorFromVertexColor(MeshType& m)
{
    detail::setPerElemColorFromVertexColor<ElemId::EDGE>(m);
}
 
template<MeshConcept MeshType>
void setPerVertexColorFromQuality(
    MeshType&       m,
    Color::ColorMap colorMap = Color::ColorMap::RedBlue,
    typename MeshType::VertexType::QualityType minQuality = 0,
    typename MeshType::VertexType::QualityType maxQuality = 0)
{
    requirePerVertexColor(m);
    requirePerVertexQuality(m);
 
    using VertexType  = MeshType::VertexType;
    using QualityType = VertexType::QualityType;
 
    if (minQuality == maxQuality) {
        std::pair<QualityType, QualityType> pair = vertexQualityMinMax(m);
        minQuality                               = pair.first;
        maxQuality                               = pair.second;
    }
    for (VertexType& v : m.vertices()) {
        v.color() =
            colorFromInterval(minQuality, maxQuality, v.quality(), colorMap);
    }
}
 
template<FaceMeshConcept MeshType>
void setPerFaceColorFromQuality(
    MeshType&       m,
    Color::ColorMap colorMap = Color::ColorMap::RedBlue,
    typename MeshType::FaceType::QualityType minQuality = 0,
    typename MeshType::FaceType::QualityType maxQuality = 0)
{
    requirePerFaceColor(m);
    requirePerFaceQuality(m);
 
    using FaceType    = MeshType::FaceType;
    using QualityType = FaceType::QualityType;
 
    if (minQuality == maxQuality) {
        std::pair<QualityType, QualityType> pair = faceQualityMinMax(m);
 
        minQuality = pair.first;
        maxQuality = pair.second;
    }
    for (FaceType& f : m.faces()) {
        f.color() =
            colorFromInterval(minQuality, maxQuality, f.quality(), colorMap);
    }
}
 
template<FaceMeshConcept MeshType>
void setPerVertexColorFromFaceBorderFlag(
    MeshType& m,
    Color     borderColor   = Color::Blue,
    Color     internalColor = Color::White,
    Color     mixColor      = Color::Cyan)
{
    requirePerVertexColor(m);
 
    using FaceType = MeshType::FaceType;
 
    const Color baseColor = Color::Green;
 
    setPerVertexColor(m, baseColor);
 
    for (FaceType& f : m.faces()) {
        for (uint i = 0; i < f.vertexNumber(); ++i) {
            if (f.edgeOnBorder(i)) {
                if (f.vertex(i).color() == baseColor)
                    f.vertex(i).color() = borderColor;
                if (f.vertex(i).color() == internalColor)
                    f.vertex(i).color() = mixColor;
                if (f.vertexMod(i + 1).color() == baseColor)
                    f.vertexMod(i + 1).color() = borderColor;
                if (f.vertexMod(i + 1).color() == internalColor)
                    f.vertexMod(i + 1).color() = mixColor;
            }
            else {
                if (f.vertex(i).color() == baseColor)
                    f.vertex(i).color() = internalColor;
                if (f.vertex(i).color() == borderColor)
                    f.vertex(i).color() = mixColor;
                if (f.vertexMod(i + 1).color() == baseColor)
                    f.vertexMod(i + 1).color() = internalColor;
                if (f.vertexMod(i + 1).color() == borderColor)
                    f.vertexMod(i + 1).color() = mixColor;
            }
        }
    }
}
 
template<FaceMeshConcept MeshType>
void setPerFaceColorFromConnectedComponents(
    MeshType&                          m,
    const std::vector<std::set<uint>>& connectedComponents)
{
    std::vector<Color> vc = colorScattering(connectedComponents.size());
 
    uint cid = 0;
    for (const std::set<uint>& connComp : connectedComponents) {
        for (const uint& fid : connComp) {
            m.face(fid).color() = vc[cid];
        }
        cid++;
    }
}
 
template<FaceMeshConcept MeshType>
void setPerFaceColorFromConnectedComponents(MeshType& m)
{
    requirePerFaceColor(m);
 
    std::vector<std::set<uint>> connComps = connectedComponents(m);
 
    setPerFaceColorFromConnectedComponents(m, connComps);
}
 
template<FaceMeshConcept MeshType>
void setPerFaceColorScattering(
    MeshType& m,
    uint      nColors        = 50,
    bool      checkFauxEdges = true)
{
    requirePerFaceColor(m);
 
    using FaceType = MeshType::FaceType;
 
    Color baseColor = Color::Black;
    setPerFaceColor(m, baseColor);
 
    std::vector<Color> vc = colorScattering(nColors);
 
    for (FaceType& f : m.faces()) {
        if (f.color() == baseColor) {
            f.color() = vc[m.index(f) % nColors];
        }
        if constexpr (HasPerFaceAdjacentFaces<MeshType>) {
            if (checkFauxEdges && isPerFaceAdjacentFacesAvailable(m)) {
                for (uint i = 0; i < f.vertexNumber(); ++i) {
                    if (f.edgeFaux(i)) {
                        assert(f.adjFace(i) != nullptr);
                        f.adjFace(i)->color = f.color();
                    }
                }
            }
        }
    }
}
 
template<MeshConcept MeshType, PointConcept PointType>
void setPerVertexColorPerlinNoise(
    MeshType& m,
    PointType period,
    PointType offset     = PointType(0, 0, 0),
    bool      onSelected = false)
{
    requirePerVertexColor(m);
 
    using VertexType = MeshType::VertexType;
 
    PointType p[3];
 
    for (VertexType& v : m.vertices()) {
        if (!onSelected || v.selected()) {
            p[0]      = (v.position() / period[0]) + offset;
            p[1]      = (v.position() / period[1]) + offset;
            p[2]      = (v.position() / period[2]) + offset;
            v.color() = Color(
                127 + 128.0 * perlinNoise(p[0][0], p[0][1], p[0][2]),
                127 + 128.0 * perlinNoise(p[1][0], p[1][1], p[1][2]),
                127 + 128.0 * perlinNoise(p[2][0], p[2][1], p[2][2]),
                255);
        }
    }
}
 
template<MeshConcept MeshType, PointConcept PointType>
void setPerVertexPerlinColor(
    MeshType& m,
    double    period,
    PointType offset     = PointType(0, 0, 0),
    Color     color1     = Color::Black,
    Color     color2     = Color::White,
    bool      onSelected = false)
{
    requirePerVertexColor(m);
 
    using VertexType = MeshType::VertexType;
 
    for (VertexType& v : m.vertices()) {
        if (!onSelected || v.selected()) {
            PointType p = v.position() / period + offset;
 
            double factor = (perlinNoise(p[0], p[1], p[2]) + 1.0) / 2.0;
 
            int rr = (color1[0] * factor) + (color2[0] * (1.0 - factor));
            int gg = (color1[1] * factor) + (color2[1] * (1.0 - factor));
            int bb = (color1[2] * factor) + (color2[2] * (1.0 - factor));
            int aa = (color1[3] * factor) + (color2[3] * (1.0 - factor));
 
            v.color() = Color(rr, gg, bb, aa);
        }
    }
}
 
} // namespace vcl
 
#endif // VCL_ALGORITHMS_MESH_UPDATE_COLOR_H