TMP: first move align_pair
This commit is contained in:
alemuntoni
parent
e7ce2614ec
commit
ec730298fa
|
|
@ -0,0 +1,515 @@
|
|||
/****************************************************************************
|
||||
* VCGLib o o *
|
||||
* Visual and Computer Graphics Library o o *
|
||||
* _ O _ *
|
||||
* Copyright(C) 2004-2016 \/)\/ *
|
||||
* 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. *
|
||||
* *
|
||||
****************************************************************************/
|
||||
#ifndef VCG_ALIGN_PAIR_H
|
||||
#define VCG_ALIGN_PAIR_H
|
||||
|
||||
#include <ctime>
|
||||
#include <vcg/math/histogram.h>
|
||||
#include <vcg/math/matrix44.h>
|
||||
#include <vcg/math/random_generator.h>
|
||||
#include <vcg/math/gen_normal.h>
|
||||
|
||||
#include <vcg/space/point_matching.h>
|
||||
#include <vcg/space/index/grid_static_ptr.h>
|
||||
|
||||
#include <vcg/simplex/face/component_ep.h>
|
||||
|
||||
#include <vcg/complex/complex.h>
|
||||
#include <vcg/complex/algorithms/clean.h>
|
||||
#include <vcg/complex/algorithms/closest.h>
|
||||
#include <vcg/complex/algorithms/update/normal.h>
|
||||
#include <vcg/complex/algorithms/update/bounding.h>
|
||||
#include <vcg/complex/algorithms/update/component_ep.h>
|
||||
#include <vcg/complex/algorithms/update/position.h>
|
||||
#include <vcg/complex/algorithms/update/flag.h>
|
||||
#include <vcg/complex/algorithms/update/normal.h>
|
||||
#include <vcg/complex/algorithms/update/bounding.h>
|
||||
|
||||
|
||||
namespace vcg {
|
||||
/*************************************************************************
|
||||
AlignPair
|
||||
|
||||
Classe per gestire un allineamento tra DUE sole mesh.
|
||||
|
||||
**************************************************************************/
|
||||
|
||||
class AlignPair {
|
||||
public:
|
||||
|
||||
enum ErrorCode {
|
||||
SUCCESS,
|
||||
NO_COMMON_BBOX,
|
||||
TOO_FEW_POINTS,
|
||||
LSQ_DIVERGE,
|
||||
TOO_MUCH_SHEAR,
|
||||
TOO_MUCH_SCALE,
|
||||
FORBIDDEN,
|
||||
INVALID,
|
||||
UNKNOWN_MODE };
|
||||
|
||||
|
||||
/*********************** Classi Accessorie ****************************/
|
||||
|
||||
class A2Vertex;
|
||||
|
||||
class A2Face;
|
||||
|
||||
class A2UsedTypes:
|
||||
public vcg::UsedTypes < vcg::Use<A2Vertex>::AsVertexType,
|
||||
vcg::Use<A2Face >::AsFaceType >{};
|
||||
|
||||
class A2Vertex : public vcg::Vertex<A2UsedTypes,vcg::vertex::Coord3d,vcg::vertex::Normal3d,vcg::vertex::BitFlags> {};
|
||||
class A2Face : public vcg::Face< A2UsedTypes,vcg::face::VertexRef, vcg::face::Normal3d,vcg::face::Mark,vcg::face::BitFlags> {};
|
||||
|
||||
class A2Mesh : public vcg::tri::TriMesh< std::vector<A2Vertex>, std::vector<A2Face> >
|
||||
{
|
||||
public:
|
||||
//bool Import(const char *filename) { Matrix44d Tr; Tr.SetIdentity(); return Import(filename,Tr);}
|
||||
//bool Import(const char *filename, Matrix44d &Tr);
|
||||
|
||||
inline bool InitVert(const Matrix44d &Tr) {
|
||||
Matrix44d Idn; Idn.SetIdentity();
|
||||
if (Tr != Idn)
|
||||
tri::UpdatePosition<A2Mesh>::Matrix(*this, Tr);
|
||||
tri::UpdateNormal<A2Mesh>::NormalizePerVertex(*this);
|
||||
tri::UpdateBounding<A2Mesh>::Box(*this);
|
||||
return true;
|
||||
}
|
||||
inline bool Init(const Matrix44d &Tr) {
|
||||
Matrix44d Idn; Idn.SetIdentity();
|
||||
tri::Clean<A2Mesh>::RemoveUnreferencedVertex(*this);
|
||||
if (Tr != Idn)
|
||||
tri::UpdatePosition<A2Mesh>::Matrix(*this, Tr);
|
||||
tri::UpdateNormal<A2Mesh>::PerVertexNormalizedPerFaceNormalized(*this);
|
||||
tri::UpdateFlags<A2Mesh>::FaceBorderFromNone(*this);
|
||||
tri::UpdateBounding<A2Mesh>::Box(*this);
|
||||
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
typedef A2Mesh::FaceContainer FaceContainer;
|
||||
typedef A2Mesh::FaceType FaceType;
|
||||
typedef GridStaticPtr<FaceType, double > A2Grid;
|
||||
typedef GridStaticPtr<A2Mesh::VertexType, double > A2GridVert;
|
||||
|
||||
class Stat
|
||||
{
|
||||
public:
|
||||
|
||||
class IterInfo
|
||||
{
|
||||
public:
|
||||
IterInfo()
|
||||
{
|
||||
memset ( (void *) this, 0, sizeof(IterInfo));
|
||||
}
|
||||
|
||||
double MinDistAbs;
|
||||
int DistanceDiscarded;
|
||||
int AngleDiscarded;
|
||||
int BorderDiscarded;
|
||||
int SampleTested; // quanti punti ho testato con la mindist
|
||||
int SampleUsed; // quanti punti ho scelto per la computematrix
|
||||
double pcl50;
|
||||
double pclhi;
|
||||
double AVG;
|
||||
double RMS;
|
||||
double StdDev;
|
||||
int Time; // quando e' finita questa iterazione
|
||||
|
||||
};
|
||||
|
||||
std::vector<IterInfo> I;
|
||||
|
||||
double LastPcl50() const
|
||||
{
|
||||
return I.back().pcl50;
|
||||
}
|
||||
|
||||
int LastSampleUsed() const {
|
||||
return I.back().SampleUsed;
|
||||
}
|
||||
|
||||
int MovVertNum;
|
||||
int FixVertNum;
|
||||
int FixFaceNum;
|
||||
|
||||
int TotTime() {
|
||||
return I.back().Time-StartTime;
|
||||
}
|
||||
|
||||
int IterTime(unsigned int i) const
|
||||
{
|
||||
const int clock_per_ms = std::max<int>(CLOCKS_PER_SEC / 1000,1);
|
||||
assert(i<I.size());
|
||||
if(i==0) return (I[i].Time-StartTime )/clock_per_ms;
|
||||
else return (I[i].Time - I[i-1].Time)/clock_per_ms ;
|
||||
}
|
||||
int StartTime;
|
||||
|
||||
inline void clear()
|
||||
{
|
||||
I.clear();
|
||||
StartTime = 0;
|
||||
MovVertNum = 0;
|
||||
FixVertNum = 0;
|
||||
FixFaceNum = 0;
|
||||
}
|
||||
|
||||
inline void Dump(FILE *fp)
|
||||
{
|
||||
if (I.size() == 0) {
|
||||
fprintf(fp, "Empty AlignPair::Stat\n");
|
||||
return;
|
||||
}
|
||||
fprintf(fp, "Final Err %8.5f In %i iterations Total Time %ims\n", LastPcl50(), (int)I.size(), TotTime());
|
||||
fprintf(fp, "Mindist Med Hi Avg RMS StdDev Time Tested Used Dist Bord Angl \n");
|
||||
for (unsigned int qi = 0; qi < I.size(); ++qi)
|
||||
fprintf(
|
||||
fp,
|
||||
"%5.2f (%6.3f:%6.3f) (%6.3f %6.3f %6.3f) %4ims %5i %5i %4i+%4i+%4i\n",
|
||||
I[qi].MinDistAbs,
|
||||
I[qi].pcl50, I[qi].pclhi,
|
||||
I[qi].AVG, I[qi].RMS, I[qi].StdDev,
|
||||
IterTime(qi),
|
||||
I[qi].SampleTested, I[qi].SampleUsed, I[qi].DistanceDiscarded, I[qi].BorderDiscarded, I[qi].AngleDiscarded);
|
||||
}
|
||||
|
||||
// Scrive una tabella con tutti i valori
|
||||
inline void HTMLDump(FILE *fp)
|
||||
{
|
||||
fprintf(fp, "Final Err %8.5f In %i iterations Total Time %ims\n", LastPcl50(), (int)I.size(), TotTime());
|
||||
fprintf(fp, "<table border>\n");
|
||||
fprintf(fp, "<tr> <th>Mindist</th><th> 50ile </th><th> Hi </th><th> Avg </th><th> RMS </th><th> StdDev </th><th> Time </th><th> Tested </th><th> Used </th><th> Dist </th><th> Bord </th><th> Angl \n");
|
||||
for (unsigned int qi = 0; qi < I.size(); ++qi)
|
||||
fprintf(
|
||||
fp, "<tr> <td> %8.5f </td><td align=\"right\"> %9.6f </td><td align=\"right\"> %8.5f </td><td align=\"right\"> %5.3f </td><td align=\"right\"> %8.5f </td><td align=\"right\"> %9.6f </td><td align=\"right\"> %4ims </td><td align=\"right\"> %5i </td><td align=\"right\"> %5i </td><td align=\"right\"> %4i </td><td align=\"right\"> %4i </td><td align=\"right\">%4i </td><td align=\"right\"></tr>\n",
|
||||
I[qi].MinDistAbs,
|
||||
I[qi].pcl50, I[qi].pclhi,
|
||||
I[qi].AVG, I[qi].RMS, I[qi].StdDev,
|
||||
IterTime(qi),
|
||||
I[qi].SampleTested, I[qi].SampleUsed, I[qi].DistanceDiscarded, I[qi].BorderDiscarded, I[qi].AngleDiscarded);
|
||||
fprintf(fp, "</table>\n");
|
||||
}
|
||||
|
||||
// Restituisce true se nelle ultime <lastiter> iterazioni non e' diminuito
|
||||
// l'errore
|
||||
inline bool Stable(int lastiter)
|
||||
{
|
||||
if (I.empty())
|
||||
return false;
|
||||
int parag = int(I.size()) - lastiter;
|
||||
|
||||
if (parag < 0)
|
||||
parag = 0;
|
||||
if (I.back().pcl50 < I[parag].pcl50)
|
||||
return false; // se siamo diminuiti non e' stabile
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
class Param
|
||||
{
|
||||
public:
|
||||
enum MatchModeEnum {MMSimilarity, MMRigid};
|
||||
enum SampleModeEnum {SMRandom, SMNormalEqualized};
|
||||
|
||||
Param()
|
||||
{
|
||||
SampleNum = 2000;
|
||||
MaxPointNum = 100000;
|
||||
MinPointNum = 30;
|
||||
|
||||
MaxIterNum = 75;
|
||||
TrgDistAbs = 0.005f;
|
||||
|
||||
MinDistAbs = 10;
|
||||
MaxAngleRad = math::ToRad(45.0);
|
||||
MaxShear = 0.5;
|
||||
MaxScale = 0.5; // significa che lo scale deve essere compreso tra 1-MaxScale e 1+MaxScale
|
||||
PassHiFilter = 0.75;
|
||||
ReduceFactorPerc = 0.80;
|
||||
MinMinDistPerc = 0.01;
|
||||
EndStepNum = 5;
|
||||
MatchMode = MMRigid;
|
||||
SampleMode = SMNormalEqualized;
|
||||
UGExpansionFactor=10;
|
||||
MinFixVertNum=20000;
|
||||
MinFixVertNumPerc=.25;
|
||||
UseVertexOnly = false;
|
||||
}
|
||||
|
||||
int SampleNum; // numero di sample da prendere sulla mesh fix, utilizzando
|
||||
// il SampleMode scelto tra cui poi sceglierne al piu' <MaxPointNum>
|
||||
// e almeno <MinPointNum> da usare per l'allineamento.
|
||||
int MaxPointNum; // numero di coppie di punti da usare quando si calcola la matrice
|
||||
// di allienamento e che poi si mettono da parte per il globale;
|
||||
// di solito non usato
|
||||
int MinPointNum; // minimo numero di coppie di punti ammissibile perche' sia considerato
|
||||
// valido l'allineamento
|
||||
double MinDistAbs; // distanza minima iniziale perche due punti vengano presi in
|
||||
// considerazione. NON e' piu espressa in percentuale sul bbox della mesh nella ug.
|
||||
// Ad ogni passo puo essere ridotta per
|
||||
// accellerare usando ReduceFactor
|
||||
double MaxAngleRad; // massimo angolo in radianti tra due normali perche' i due
|
||||
// punti vengano presi in considerazione.
|
||||
|
||||
int MaxIterNum; // massimo numero di iterazioni da fare in align
|
||||
double TrgDistAbs; // distanza obiettivo entro la quale devono stare almeno la meta'
|
||||
// dei campioni scelti; di solito non entra in gioco perche' ha un default molto basso
|
||||
|
||||
int EndStepNum; // numero di iterazioni da considerare per decidere se icp ha converso.
|
||||
|
||||
//double PassLoFilter; // Filtraggio utilizzato per decidere quali punti scegliere tra quello trovati abbastanza
|
||||
double PassHiFilter; // vicini. Espresso in percentili. Di solito si scarta il quelli sopra il 75 e quelli sotto il 5
|
||||
double ReduceFactorPerc; // At each step we discard the points farther than a given threshold. The threshold is iterativeley reduced;
|
||||
// StartMinDist= min(StartMinDist, 5.0*H.Percentile(ap.ReduceFactorPerc))
|
||||
|
||||
|
||||
double MinMinDistPerc; // Ratio between initial starting distance (MinDistAbs) and what can reach by the application of the ReduceFactor.
|
||||
|
||||
int UGExpansionFactor; // Grandezza della UG per la mesh fix come rapporto del numero di facce della mesh fix
|
||||
|
||||
// Nel caso si usi qualche struttura multiresolution
|
||||
int MinFixVertNum; // Gli allineamenti si fanno mettendo nella ug come mesh fix una semplificata;
|
||||
float MinFixVertNumPerc; // si usa il max tra MinFixVertNum e OrigMeshSize*MinFixVertNumPerc
|
||||
bool UseVertexOnly; // if true all the Alignment pipeline ignores faces and works over point clouds.
|
||||
|
||||
double MaxShear;
|
||||
double MaxScale;
|
||||
MatchModeEnum MatchMode;
|
||||
SampleModeEnum SampleMode;
|
||||
void Dump(FILE *fp,double BoxDiag);
|
||||
|
||||
};
|
||||
|
||||
// Classe per memorizzare il risultato di un allineamento tra due mesh
|
||||
// i punti si intendono nel sistema di riferimento iniziale delle due mesh.
|
||||
//
|
||||
// se le mesh hanno una trasformazione di base in ingresso,
|
||||
// questa appare solo durante la A2Mesh::Import e poi e' per sempre dimenticata.
|
||||
// Questi punti sono quindi nei sistemi di riferimento costruiti durante la Import
|
||||
// la matrice Tr quella che
|
||||
//
|
||||
// Tr*Pmov[i]== Pfix
|
||||
|
||||
|
||||
class Result
|
||||
{
|
||||
public:
|
||||
int MovName;
|
||||
int FixName;
|
||||
|
||||
Matrix44d Tr;
|
||||
std::vector<Point3d> Pfix; // vertici corrispondenti su fix (rossi)
|
||||
std::vector<Point3d> Nfix; // normali corrispondenti su fix (rossi)
|
||||
std::vector<Point3d> Pmov; // vertici scelti su mov (verdi) prima della trasformazione in ingresso (Original Point Target)
|
||||
std::vector<Point3d> Nmov; // normali scelti su mov (verdi)
|
||||
Histogramf H;
|
||||
Stat as;
|
||||
Param ap;
|
||||
ErrorCode status;
|
||||
bool IsValid() {return status==SUCCESS;}
|
||||
double err;
|
||||
float area; // the overlapping area, a percentage as computed in Occupancy Grid.
|
||||
|
||||
bool operator < (const Result & rr) const {return (err< rr.err);}
|
||||
bool operator <= (const Result & rr) const {return (err<=rr.err);}
|
||||
bool operator > (const Result & rr) const {return (err> rr.err);}
|
||||
bool operator >= (const Result & rr) const {return (err>=rr.err);}
|
||||
bool operator == (const Result & rr) const {return (err==rr.err);}
|
||||
bool operator != (const Result & rr) const {return (err!=rr.err);}
|
||||
|
||||
std::pair<double,double> ComputeAvgErr() const
|
||||
{
|
||||
double sum_before=0;
|
||||
double sum_after=0;
|
||||
for(unsigned int ii=0;ii<Pfix.size();++ii)
|
||||
{
|
||||
sum_before+=Distance(Pfix[ii], Pmov[ii]);
|
||||
sum_after+=Distance(Pfix[ii], Tr*Pmov[ii]);
|
||||
}
|
||||
return std::make_pair(sum_before/double(Pfix.size()),sum_after/double(Pfix.size()) ) ;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
/******************* Fine Classi Accessorie ************************/
|
||||
|
||||
static const char *ErrorMsg( ErrorCode code);
|
||||
void Clear(){status=SUCCESS;}
|
||||
AlignPair() { Clear(); myrnd.initialize(time(NULL)); }
|
||||
|
||||
/******* Data Members *********/
|
||||
|
||||
std::vector<A2Vertex> *mov;
|
||||
A2Mesh *fix;
|
||||
|
||||
ErrorCode status;
|
||||
AlignPair::Param ap;
|
||||
|
||||
math::SubtractiveRingRNG myrnd;
|
||||
|
||||
/**** End Data Members *********/
|
||||
|
||||
template < class MESH >
|
||||
void ConvertMesh(MESH &M1, A2Mesh &M2)
|
||||
{
|
||||
tri::Append<A2Mesh,MESH>::MeshCopy(M2,M1);
|
||||
}
|
||||
|
||||
template < class VERTEX >
|
||||
void ConvertVertex(const std::vector<VERTEX> &vert1, std::vector<A2Vertex> &vert2, Box3d *Clip=0)
|
||||
{
|
||||
|
||||
vert2.clear();
|
||||
typename std::vector<VERTEX>::const_iterator vi;
|
||||
A2Vertex tv;
|
||||
Box3<typename VERTEX::ScalarType> bb;
|
||||
if(Clip){
|
||||
bb.Import(*Clip);
|
||||
for(vi=vert1.begin();vi<vert1.end();++vi)
|
||||
if(!(*vi).IsD() && bb.IsIn((*vi).cP())){
|
||||
tv.P().Import((*vi).cP());
|
||||
tv.N().Import((*vi).cN());
|
||||
vert2.push_back(tv);
|
||||
}
|
||||
}
|
||||
else
|
||||
for(vi=vert1.begin();vi<vert1.end();++vi)
|
||||
if(!(*vi).IsD()){
|
||||
tv.P().Import((*vi).cP());
|
||||
tv.N().Import((*vi).cN());
|
||||
vert2.push_back(tv);
|
||||
}
|
||||
}
|
||||
|
||||
bool SampleMovVert(std::vector<A2Vertex> &vert, int SampleNum, AlignPair::Param::SampleModeEnum SampleMode);
|
||||
bool SampleMovVertRandom(std::vector<A2Vertex> &vert, int SampleNum);
|
||||
bool SampleMovVertNormalEqualized(std::vector<A2Vertex> &vert, int SampleNum);
|
||||
/*
|
||||
*Una volta trovati <SampleNum> coppie di punti corrispondenti se ne sceglie
|
||||
al piu' <PointNum> per calcolare la trasformazione che li fa coincidere.
|
||||
La scelta viene fatta in base ai due parametri PassLo e PassHi;
|
||||
*/
|
||||
bool ChoosePoints(
|
||||
std::vector<Point3d> &Ps, // vertici corrispondenti su fix (rossi)
|
||||
std::vector<Point3d> &Ns, // normali corrispondenti su fix (rossi)
|
||||
std::vector<Point3d> &Pt, // vertici scelti su mov (verdi)
|
||||
std::vector<Point3d> &OPt, // vertici scelti su mov (verdi)
|
||||
//vector<Point3d> &Nt, // normali scelti su mov (verdi)
|
||||
double PassHi,
|
||||
Histogramf &H);
|
||||
|
||||
/*
|
||||
Minimo esempio di codice per l'uso della funzione di allineamento.
|
||||
|
||||
AlignPair::A2Mesh Mov,Fix; // le due mesh da allineare
|
||||
vector<AlignPair::A2Vertex> MovVert; // i punti sulla mov da usare per l'allineamento
|
||||
Matrix44d In; In.SetIdentity(); // la trasformazione iniziale che applicata a mov la porterebbe su fix.
|
||||
|
||||
AlignPair aa; // l'oggetto principale.
|
||||
AlignPair::Param ap;
|
||||
UGrid< AlignPair::A2Mesh::face_container > UG;
|
||||
|
||||
Fix.LoadPly("FixMesh.ply"); // Standard ply loading
|
||||
Mov.LoadPly("MovMesh.ply");
|
||||
Fix.Init( Ident, false); // Inizializzazione necessaria (normali per vert,
|
||||
Mov.Init( Ident, false); // info per distanza punto faccia ecc)
|
||||
|
||||
AlignPair::InitFix(&Fix, ap, UG); // la mesh fix viene messa nella ug.
|
||||
|
||||
aa.ConvertVertex(Mov.vert,MovVert); // si campiona la mesh Mov per trovare un po' di vertici.
|
||||
aa.SampleMovVert(MovVert, ap.SampleNum, ap.SampleMode);
|
||||
|
||||
aa.mov=&MovVert; // si assegnano i membri principali dell'oggetto align pair
|
||||
aa.fix=&Fix;
|
||||
aa.ap = ap;
|
||||
|
||||
aa.Align(In,UG,res); // si spera :)
|
||||
// il risultato sta nella matrice res.Tr;
|
||||
|
||||
res.as.Dump(stdout);
|
||||
*/
|
||||
|
||||
bool Align(const Matrix44d &in, A2Grid &UG, A2GridVert &UGV, Result &res)
|
||||
{
|
||||
res.ap=ap;
|
||||
|
||||
bool ret=Align(UG, UGV, in, res.Tr, res.Pfix, res.Nfix, res.Pmov, res.Nmov, res.H, res.as);
|
||||
|
||||
res.err=res.as.LastPcl50();
|
||||
res.status=status;
|
||||
return ret;
|
||||
}
|
||||
|
||||
double Abs2Perc(double val, Box3d bb) const {return val/bb.Diag();}
|
||||
double Perc2Abs(double val, Box3d bb) const {return val*bb.Diag();}
|
||||
|
||||
/************************************************************************************
|
||||
Versione Vera della Align a basso livello.
|
||||
|
||||
Si assume che la mesh fix sia gia' stata messa nella ug u con le debite trasformazioni.
|
||||
in
|
||||
|
||||
************************************************************************************/
|
||||
|
||||
bool Align(
|
||||
A2Grid &u,
|
||||
A2GridVert &uv,
|
||||
const Matrix44d &in, // trasformazione Iniziale che porta i punti di mov su fix
|
||||
Matrix44d &out, // trasformazione calcolata
|
||||
std::vector<Point3d> &Pfix, // vertici corrispondenti su src (rossi)
|
||||
std::vector<Point3d> &Nfix, // normali corrispondenti su src (rossi)
|
||||
std::vector<Point3d> &OPmov, // vertici scelti su trg (verdi) prima della trasformazione in ingresso (Original Point Target)
|
||||
std::vector<Point3d> &ONmov, // normali scelti su trg (verdi)
|
||||
Histogramf &H,
|
||||
Stat &as);
|
||||
|
||||
|
||||
bool InitMov(
|
||||
std::vector< Point3d > &movvert,
|
||||
std::vector< Point3d > &movnorm,
|
||||
Box3d &movbox,
|
||||
const Matrix44d &in );
|
||||
|
||||
static bool InitFixVert(A2Mesh *fm,
|
||||
AlignPair::Param &pp,
|
||||
A2GridVert &u,
|
||||
int PreferredGridSize=0);
|
||||
|
||||
static bool InitFix(A2Mesh *fm,
|
||||
AlignPair::Param &pp,
|
||||
A2Grid &u,
|
||||
int PreferredGridSize=0);
|
||||
|
||||
}; // end class
|
||||
|
||||
} // end namespace vcg
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue