Mahalanobis TogersonMetricLearner::learnMetric() {
dim = getVectorDim();
sampleCount = getSampleCount();
int iIdx = selectI();
mat B = generateB(iIdx);
mat X = generateX();
mat Y = generateY(B);
mat Z = generateZ(X, Y);
mat A = Z.t() * Z;
// normalize it for convenience
A = 1 / A(0, 0) * A;
return Mahalanobis(A);
}
bool arlCore::Mesh::load( const std::string& fileName, double gaussianNoise )
{
clear();
if(fileName=="") return false;
std::string extractFolder, extractFile, ext;
arlString::splitFilename( fileName, extractFolder, extractFile, ext );
std::string filetype = File::getFiletype( fileName );
if(filetype=="Planes")
{
arlCore::File config(fileName, "Planes");
const double Version = config.readHeader();
if(Version>0.0)
{
std::vector< vgl_homg_plane_3d<double> > planes;
std::vector< double > planeRMS, planeMin, planeMax;
std::vector< unsigned int > planeN;
std::vector< vgl_homg_point_3d<double> > points;
unsigned int i, index;
std::string token, name;
while(config.getToken(token))
{
unsigned int p1, p2, p3;
double x, y, z, outliers=0.0, scalar=0.0;
if(token=="Planes")
{
config.get(name);
config.get(outliers);
std::vector< vnl_vector<double> > vnlPoints;
std::vector< std::string > names;
std::stringstream ss;
ss<<extractFolder<<"/"<<name;
if(arlCore::load( vnlPoints, names, ss.str() ))
{
std::vector< arlCore::PointList > PL;
for( i=0 ; i<vnlPoints.size() ; ++i )
{
if(arlString::valueOf(names[i], index))
{
if(PL.size()<=index) PL.resize(index+1);
arlCore::Point::sptr pt = arlCore::Point::New(vnlPoints[i][0], vnlPoints[i][1], vnlPoints[i][2]);
PL[index].push_back(pt);
}
}
const unsigned int Size = (unsigned int)PL.size();
planes.resize(Size);
planeRMS.resize(Size);
planeMin.resize(Size);
planeMax.resize(Size);
planeN.resize(Size);
for( i=0 ; i<PL.size() ; ++i )
planeN[i] = PL[i].plane( planes[i], planeRMS[i], planeMin[i], planeMax[i], scalar, outliers );
}
}
if(token=="Point")
{
config.get(index);
if(points.size()<=index) points.resize(index+1);
config.getToken(token);
if(token=="Intersection")
{
config.get(p1);
config.get(p2);
config.get(p3);
if(planes.size()>p1 && planes.size()>p2 && planes.size()>p3)
points[index]=vgl_homg_point_3d<double>(planes[p1], planes[p2], planes[p3]);
}
if(token=="Coordinates")
{
config.get(x);
config.get(y);
config.get(z);
points[index]=vgl_homg_point_3d<double>(x, y, z);
}
}
if(token=="Triangle")
{
config.get(p1);
config.get(p2);
config.get(p3);
if(points.size()>p1 && points.size()>p2 && points.size()>p3)
{
points[p1].get_nonhomogeneous( x, y, z );
const arlCore::Point::sptr Pt1 = arlCore::Point::New( x, y, z );
points[p2].get_nonhomogeneous( x, y, z );
const arlCore::Point::sptr Pt2= arlCore::Point::New( x, y, z );
points[p3].get_nonhomogeneous( x, y, z );
const arlCore::Point::sptr Pt3= arlCore::Point::New( x, y, z );
addTriangle( Pt1, Pt2, Pt3 );
}
}
double compareValue = 0.0;
const bool Compare = (token=="Compare");
if(Compare)
config.get(compareValue);
if(token=="Display" || Compare)
{ // FIXME Find another way to display this informations
config.getToken(token);
if(token=="Point")
{
config.get(p1);
if(points.size()>p1)
{
points[p1].get_nonhomogeneous( x, y, z );
std::cout<<"Point "<<p1<<" = "<<x<<" "<<y<<" "<<z<<"\n";
}
}
if(token=="Plane")
{
config.get(p1);
if(planes.size()>p1)
{
std::cout<<"Plane "<<p1<<" RMS="<<planeRMS[p1]<<" Min="<<planeMin[p1];
std::cout<<" Max="<<planeMax[p1]<<" n="<<planeN[p1];
//std::cout<<" : "<<planes[p1];
std::cout<<"\n";
}
}
if(token=="PlaneAngle")
{
config.get(p1);
config.get(p2);
if(planes.size()>p1 && planes.size()>p2)
{
double angle = fmod(vgl_homg_operators_3d<double>::plane_plane_angle(planes[p1], planes[p2]), vnl_math::pi/2.0);
if(angle>=vnl_math::pi/4.0) angle = vnl_math::pi/2.0 - angle;
std::cout<<"Plane Angle "<<p1<<"-"<<p2<<" = "<<angle*arlCore::RadToDeg<<" deg";
if(Compare) std::cout<<" (Delta="<<angle*arlCore::RadToDeg-compareValue<<")";
std::cout<<"\n";
}
}
if(token=="PointDistance")
{
config.get(p1);
config.get(p2);
if(points.size()>p1 && points.size()>p2)
{
const double Distance = vgl_distance(points[p1], points[p2]);
std::cout<<"Point Distance "<<p1<<"-"<<p2<<" = "<<Distance<<" mm";
if(Compare) std::cout<<" (Delta="<<Distance-compareValue<<")";
std::cout<<"\n";
}
}
if(token=="PointAngle")
{
config.get(p1);
config.get(p2);
config.get(p3);
if(points.size()>p1 && points.size()>p2 && points.size()>p3)
{
double x1, x2, x3, y1, y2, y3, z1, z2, z3;
points[p1].get_nonhomogeneous( x1, y1, z1 );
points[p2].get_nonhomogeneous( x2, y2, z2 );
points[p3].get_nonhomogeneous( x3, y3, z3 );
vnl_vector_fixed<double, 3> dir1( x1-x2, y1-y2, z1-z2 );
vnl_vector_fixed<double, 3> dir2( x3-x2, y3-y2, z3-z2 );
dir1.normalize();
dir2.normalize();
double angle = vcl_acos( dot_product( dir1, dir2 ) );
std::cout<<"Point Angle "<<p1<<"-"<<p2<<"-"<<p3<<" = "<<angle*arlCore::RadToDeg<<" deg";
if(Compare) std::cout<<" (Delta="<<angle*arlCore::RadToDeg-compareValue<<")";
std::cout<<"\n"; }
}
}
}
}
config.close();
return m_triangles.size()>0;
}
if(filetype=="Surface")
{
arlCore::File config(fileName, "Surface");
const double Version = config.readHeader();
if(Version>0.0)
{
arlCore::PointList::sptr summits = arlCore::PointList::New(); //VAG FIXME NB New(3)
unsigned int xSize=0, ySize=0;
double xStep = 1.0, yStep = 1.0, degree = 2.0, noise = 0.0;
vnl_vector<double> point(3);
std::string token, name;
while(config.getToken(token))
{
if(token=="Name") config.get(name);
// TODO Generate altitude on X or Y-axis
if(token=="XSize" || token=="Width") config.get(xSize);
if(token=="YSize" || token=="Length") config.get(ySize);
if(token=="XStep") config.get(xStep);
if(token=="YStep") config.get(yStep);
if(token=="Step")
{
config.get(xStep);
yStep = xStep;
}
if(token=="Degree") config.get(degree);
if(token=="GaussianNoise") config.get(noise);
if(token=="Summit")
if(config.get(point, 3))
summits->push_back( Point::New(point[0],point[1],point[2]) );
}
if(gaussianNoise>0.0) noise = gaussianNoise;
generateZ( xSize, ySize, xStep, yStep, degree, noise, summits );
}
config.close();
return m_triangles.size()>0;
}
std::ifstream file;
file.open (fileName.c_str(), std::fstream::in);
if(!file.is_open())
{
std::cerr<<"Mesh Loading error : "<<fileName<<"\n";
return false;
}
const bool Trian = (ext=="trian");
const bool Raw = (ext=="raw");
unsigned int i=0, a, b, c;
double x, y, z;
Point::sptr p = Point::New(3);
if(Trian)
{
unsigned int nbPts, nbTrian;
file>>nbPts;
for( ; i<nbPts ; ++i )
{
file>>x>>y>>z;
p->x(x);
p->y(y);
p->z(z);
addPoint(p, gaussianNoise);
}
file>>nbTrian;
for( i=0 ; i<nbTrian ; ++i )
{
file>>a>>b>>c>>x>>y>>z;
addTriangle(a, b, c);
}
file.close();
return m_triangles.size()>0;
}
if(Raw)
{
while(!file.eof())
{
file>>x>>y>>z;
p->x(x);
p->y(y);
p->z(z);
unsigned int index = addPoint(p, gaussianNoise);
if((i+1)%3==0) addTriangle(index-2, index-1, index);
++i;
}
file.close();
return m_triangles.size()>0;
}
return false;
}
