File: lscm_parametrization.h

package info (click to toggle)
meshlab 2020.09%2Bdfsg1-2
  • links: PTS, VCS
  • area: main
  • in suites: bookworm
  • size: 45,132 kB
  • sloc: cpp: 400,238; ansic: 31,952; javascript: 1,578; sh: 387; yacc: 238; lex: 139; python: 86; makefile: 30
file content (102 lines) | stat: -rw-r--r-- 3,881 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
/****************************************************************************
* VCGLib                                                            o o     *
* Visual and Computer Graphics Library                            o     o   *
*                                                                _   O  _   *
* Copyright(C) 2014                                                \/)\/    *
* 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 GNU General Public License as published by      *
* the Free Software 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             *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
* for more details.                                                         *
*                                                                           *
****************************************************************************/

/* Optimizes given UV-mapping with
 * [Least Square Conformal Maps]
 * (minimizes angle distrotions).
 *
 * Needs:
 * (-) per-vertex texture coords
 * (-) some fixed boundary:
 *     Fixed vertices are the flagged ones.
 *     By default: (use fixedMask parameter to customize)
 *     BORDER or SELECTED verts are fixed.
 *
 * Example of usage:
 *    MyMesh m;
 *    vcg::tri::UpdateFlags< MyMesh >::VertexBorderFromNone( m );
 *    vcg::tri::OptimizeUV_LSCM( m );
 *
 */

#ifndef __VCG_IGL_LEAST_SQUARES_CONFORMAL_MAPS
#define __VCG_IGL_LEAST_SQUARES_CONFORMAL_MAPS

#include <igl/lscm.h>
#include <vcg/complex/algorithms/mesh_to_matrix.h>

namespace vcg{
namespace tri{

template<class MeshType >
void OptimizeUV_LSCM( MeshType& m ,
                      unsigned int fixedMask =
                        MeshType::VertexType::BORDER |
                        MeshType::VertexType::SELECTED
                     )
{

    // check requirements
    vcg::tri::VertexVectorHasPerVertexTexCoord( m.vert );
    vcg::tri::VertexVectorHasPerVertexFlags( m.vert );

    Eigen::MatrixXd V;
    Eigen::MatrixXi F;
    Eigen::VectorXi b;
    Eigen::MatrixXd bc;
    Eigen::MatrixXd V_uv;

    vcg::tri::MeshToMatrix< MeshType >::GetTriMeshData( m, F, V );

    // build fixed points data
    size_t nFixed = 0;
    for (int i=0; i<(int)m.vert.size(); i++) {
        if (m.vert[i].Flags()&fixedMask) nFixed++;
    }

    // all fixed, nothing to do? get out to avoid crashes
    if (nFixed == m.vert.size()) return;

    b.resize(nFixed);
    bc.resize(nFixed,2);
    for (int i=0,k=0; i<(int)m.vert.size(); i++) {
        if (m.vert[i].Flags()&fixedMask)  {
            b(k) = i;
            bc(k,0) = m.vert[i].T().P()[0];
            bc(k,1) = m.vert[i].T().P()[1];
            k++;
        }
    }

    // apply Least Square Conformal Maps
    ::igl::lscm(V,F,b,bc,V_uv);

    // copy results back to mesh
    for (int i=0; i<(int)m.vert.size(); i++) {
        m.vert[i].T().P()[0] = V_uv(i,0);
        m.vert[i].T().P()[1] = V_uv(i,1);
    }
}

}} // namespaces
#endif