smoothing_utils.h

/*
 * Copyright 2025 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
#pragma once
 
#include <lagrange/SurfaceMesh.h>
 
#include <lagrange/solver/DirectSolver.h>
 
// Include before any ShapeGradientDomain header to override their threadpool implementation.
#include "ThreadPool.h"
#define MULTI_THREADING_INCLUDED
using namespace lagrange::filtering::threadpool;
 
// clang-format off
#include <lagrange/utils/warnoff.h>
#include <Include/PreProcessor.h>
#include <Include/GradientDomain.h>
#include <Include/CurvatureMetric.h>
#include <Misha/Geometry.h>
#include <Misha/Miscellany.h>
#include <lagrange/utils/warnon.h>
// clang-format on
 
#include <string_view>
#include <vector>
 
namespace lagrange::filtering {
 
namespace {
 
using namespace MishaK;
 
// Using `Point` directly leads to ambiguity with Apple Accelerate types.
template <typename T, unsigned N>
using Vector = MishaK::Point<T, N>;
 
// The dimension of the manifold.
static const unsigned int K = 2;
 
// The dimension of the space into which the manifold is embedded.
static const unsigned int Dim = 3;
 
using Real = double;
 
using Solver = lagrange::solver::SolverLDLT<Eigen::SparseMatrix<Real>>;
 
} // namespace

namespace smoothing_utils {

template <typename Scalar, typename Index>
void get_triangles(
    const SurfaceMesh<Scalar, Index>& t_mesh,
    std::vector<SimplexIndex<K, int>>& triangles);

template <typename Scalar, typename Index>
void get_vertices_and_normals(
    const SurfaceMesh<Scalar, Index>& t_mesh,
    std::vector<Vector<Real, Dim>>& vertices,
    std::vector<Vector<Real, Dim>>& normals,
    AttributeId normal_id);

template <typename Scalar, typename Index>
void set_vertices(SurfaceMesh<Scalar, Index>& mesh, const std::vector<Vector<Real, Dim>>& vertices);

template <typename Scalar, typename Index>
std::unique_ptr<FEM::RiemannianMesh<Real>> setup_for_smoothing(
    SurfaceMesh<Scalar, Index>& mesh,
    SurfaceMesh<Scalar, Index>& _mesh,
    std::vector<SimplexIndex<K, int>>& triangles,
    std::vector<Vector<Real, Dim>>& vertices,
    std::vector<Vector<Real, Dim>>& normals,
    Solver& solver,
    Real& original_area);

void adjust_metric_for_curvature(
    FEM::RiemannianMesh<Real>& r_mesh,
    const std::vector<Vector<Real, Dim>>& vertices,
    const std::vector<Vector<Real, Dim>>& normals,
    Real original_area,
    double curvature_weight,
    double normal_smoothing_weight,
    Solver& solver);
 
} // namespace smoothing_utils
 
} // namespace lagrange::filtering