TailGF::TailGF(const TailGF & t, python::object slL, python::object slR):
IndicesL(t.IndicesL[slL]),IndicesR(t.IndicesR[slR]),
N1(int(PySequence_Size(IndicesL.ptr()))),// int for 64bits
N2(int(PySequence_Size(IndicesR.ptr()))),// int for 64bits
OrderMinMIN(t.OrderMinMIN),OrderMaxMAX(t.OrderMaxMAX),
M(t.M.as_BoostObject() [python::make_tuple( python::slice(), aux1(slL),aux1(slR))]),
OrderMaxArray(t.OrderMaxArray.as_BoostObject() [python::make_tuple(aux1(slL),aux1(slR))]) //VIEW
{
// will never happen
if (M.extent(1)!=N1) TRIQS_RUNTIME_ERROR<<"Tail GF constructor :"<<M.extent(1) <<" "<<N1;
if (M.extent(2)!=N2) TRIQS_RUNTIME_ERROR<<"Tail GF constructor :"<<M.extent(2) <<" "<<N2;
M.reindexSelf(TinyVector<int,3>(OrderMinMIN,1,1));
}
void solver::run2() {
int n = mod2->instance.get_n();
// Getting results
for(IloInt i = 0; i < n; i++){
IloNumArray aux1(getEnv());
IloNumArray aux2(getEnv());
IloNumArray2 aux3(getEnv());
IloNumArray2 aux4(getEnv());
for(IloInt j = 0; j < n; j++){
aux1.add(getValue(mod2->z[i][j]));
aux2.add(getValue(mod2->w[i][j]));
IloNumArray aux5(getEnv());
IloNumArray aux6(getEnv());
for(IloInt k = 0; k < n; k++){
aux5.add(getValue(mod2->x[i][j][k]));
aux6.add(getValue(mod2->y[i][j][k]));
}
aux3.add(aux5);
aux4.add(aux6);
}
z.add(aux1);
w.add(aux2);
x.add(aux3);
y.add(aux4);
}
obj_value = getObjValue();
}
tablero::tablero(const pair<unsigned int,unsigned int>& par){
_tam = par;
list<char> aux(_tam.second,'X');
list<list<char> > aux1(_tam.first, aux);
_matriz = aux1;
}
MatrixXd MinEnFilter::DAk(const MatrixXd& Gk, const MatrixXd& Disps_inhom, int direction) {
MatrixXd Ones = MatrixXd::Ones(1,4);
MatrixXd Eaux = MatrixXd::Identity(6,6);
Matrix4d eta = MEFcommon::matSE(Eaux.col(direction-1));
MatrixXd iEg = (currG.E.lu().solve(Gk.transpose())).transpose();
VectorXd kappa = iEg.col(2);
MatrixXd h = iEg.leftCols(2).cwiseQuotient(kappa*MatrixXd::Ones(1,2));
MatrixXd z = Disps_inhom.leftCols(2) - h;
VectorXd kappaM1 = kappa.cwiseInverse();
VectorXd kappaM2 = (kappa.cwiseProduct(kappa)).cwiseInverse();
VectorXd kappaM3 = (kappa.cwiseProduct(kappa.cwiseProduct(kappa))).cwiseInverse();
MatrixXd lambda = ((currG.E.lu().solve(eta))*(iEg.transpose())).transpose();
VectorXd xi = (lambda.col(2)).cwiseProduct(kappaM2);
// first part of Hessian
VectorXd zeta1 = -2* kappaM3.cwiseProduct((lambda.col(2)).cwiseProduct(iEg.col(0)));
VectorXd zeta2 = -2 * kappaM3.cwiseProduct((lambda.col(2)).cwiseProduct(iEg.col(1)));
VectorXd eta1 = kappaM2.cwiseProduct(lambda.col(0));
VectorXd eta2 = kappaM2.cwiseProduct(lambda.col(1));
VectorXd a31 = zeta1 + eta1;
VectorXd a32 = zeta2 + eta2;
MatrixXd b1row = q1/nPoints * ((z.col(0))*Ones).cwiseProduct(iEg);
MatrixXd b2row = q2/nPoints * ((z.col(1))*Ones).cwiseProduct(iEg);
MatrixXd c1row = ((xi * Ones).cwiseProduct(b1row)).colwise().sum();
MatrixXd c2row = ((xi * Ones).cwiseProduct(b2row)).colwise().sum();
MatrixXd aux1(nPoints,4);
aux1 << (a31.cwiseProduct(b1row.col(0)) + a32.cwiseProduct(b2row.col(0))) , (a31.cwiseProduct(b1row.col(1)) + a32.cwiseProduct(b2row.col(1))), (a31.cwiseProduct(b1row.col(2)) + a32.cwiseProduct(b2row.col(2))), (a31.cwiseProduct(b1row.col(3)) + a32.cwiseProduct(b2row.col(3)));
MatrixXd c3row = aux1.colwise().sum();
MatrixXd C(4,4);
C << c1row,
c2row,
c3row,
MatrixXd::Zero(1,4);
// % second part of Hessian
VectorXd rho1 = -q1/nPoints * kappaM2.cwiseProduct(iEg.col(0));
VectorXd rho2 = -q2/nPoints * kappaM2.cwiseProduct(iEg.col(1));
MatrixXd Frow1 = kappaM1.cwiseProduct(lambda.col(0)) - kappaM2.cwiseProduct((lambda.col(2)).cwiseProduct(iEg.col(0)));
MatrixXd Frow2 = kappaM1.cwiseProduct(lambda.col(1)) - kappaM2.cwiseProduct((lambda.col(2)).cwiseProduct(iEg.col(1)));
MatrixXd G1row1 = (Frow1*Ones).cwiseProduct(iEg);
MatrixXd G1row2 = (Frow2*Ones).cwiseProduct(iEg);
MatrixXd G2row1 = ((z.col(0))*Ones).cwiseProduct(lambda);
MatrixXd G2row2 = ((z.col(1))*Ones).cwiseProduct(lambda);
MatrixXd Grow1 = G1row1 - G2row1;
MatrixXd Grow2 = G1row2 - G2row2;
MatrixXd h1row = (q1/nPoints * (kappaM1*Ones).cwiseProduct(Grow1)).colwise().sum();
MatrixXd h2row = (q2/nPoints * (kappaM1*Ones).cwiseProduct(Grow2)).colwise().sum();
MatrixXd aux2(nPoints,4);
aux2 << rho1.cwiseProduct(Grow1.col(0)) + rho2.cwiseProduct(Grow2.col(0)), rho1.cwiseProduct(Grow1.col(1)) + rho2.cwiseProduct(Grow2.col(1)), rho1.cwiseProduct(Grow1.col(2)) + rho2.cwiseProduct(Grow2.col(2)), rho1.cwiseProduct(Grow1.col(3)) + rho2.cwiseProduct(Grow2.col(3));
MatrixXd h3row = aux2.colwise().sum();
MatrixXd H(4,4);
H << h1row,
h2row,
h3row,
MatrixXd::Zero(1,4);
return C+H;
}
void KrEncoder::PrintSprite( KrConsole* console, const gedString& spriteName, const gedString& actionName,
int frameNum, KrRle* rle )
{
gedString aux1(spriteName);
gedString aux2(actionName);
console->Print( "Sprite: %s :: %s :: %d [hot:%d,%d delta:%d,%d]\n",
aux1.c_str(),
aux2.c_str(),
frameNum,
rle->Hotspot().x, rle->Hotspot().y,
rle->Delta().x, rle->Delta().y );
}
void CodeBar::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
painter->save();
QFont f1 = painter->font();
f1.setPointSize(m_codeSize);
int fh = 0;
if(m_visibleCode)
fh += painter->fontMetrics().height();
QFont f("Free 3 of 9 Extended",m_barSize);
painter->setFont(f);
int fh2 = fh + painter->fontMetrics().height() + 3;
int fw = painter->fontMetrics().width(m_code);
if(m_vertical)
{
this->setRect(0,0,fh2,fw);
QRectF r(this->rect());
QRectF aux1(0,0,r.height(),r.width());
painter->translate(rect().bottomLeft());
painter->rotate(270);
painter->drawText(aux1,Qt::TextWordWrap|Qt::AlignHCenter,m_code);
if(m_visibleCode)
{
painter->setFont(f1);
painter->drawText(aux1,Qt::AlignBottom|Qt::AlignCenter|Qt::TextJustificationForced,m_code);
}
}
else
{
this->setRect(0,0,fw,fh2);
painter->drawText(this->rect(),Qt::AlignTop|Qt::AlignHCenter,m_code);
if(m_visibleCode)
{
painter->setFont(f1);
painter->drawText(this->rect(),Qt::AlignBottom|Qt::AlignCenter|Qt::TextJustificationForced,m_code);
}
}
painter->restore();
// if(this->isSelected())
Container::paint(painter,option,widget);
}
void solver::run1() {
int n = mod1->instance.get_n();
// Getting results
for(IloInt i = 0; i < n; i++){
IloNumArray aux1(getEnv());
IloNumArray3 aux2(getEnv());
for(IloInt j = 0; j < n; j++){
aux1.add(getValue(mod1->z[i][j]));
IloNumArray2 aux3(getEnv());
for(IloInt k = 0; k < n; k++){
IloNumArray aux4(getEnv());
for(IloInt l = 0; l < n; l++)
aux4.add(getValue(mod1->f[i][j][k][l]));
aux3.add(aux4);
}
aux2.add(aux3);
}
z.add(aux1);
f.add(aux2);
}
obj_value = getObjValue();
}
std::vector<double> NNTrainer::gradient( const double lambda)
{
int numExamples = trainingSet->size();
//-- Create n matrices with the dimensions of the weight matrices:
std::vector<Matrix> Delta;
for (int i = 0; i < (int) nn->getWeights().size(); i++)
Delta.push_back( Matrix( nn->getWeights().at(i)->getNumRows(), nn->getWeights().at(i)->getNumCols() ));
//-- Iterate over all training examples
for (int i = 0; i < numExamples; i++)
{
//-- Forward-propagate the network:
nn->setInput( trainingSet->at(i).x );
//-- Create vector to store the increments:
//-- Increments will be stored in reverse order (i.e. the last increment first)
std::vector<Matrix> inc;
//-- Increment for output layer
Matrix output = Matrix(nn->getOutput(), nn->getOutput().size(), 1);
Matrix y = Matrix(trainingSet->at(i).y , trainingSet->at(i).y.size(), 1);
inc.push_back( output - y);
//-- Increment for hidden layers
for (int l = nn->getL() - 2; l > 0; l--)
{
Matrix aux1 = nn->getWeights().at(l)->transpose() * inc.back();
Matrix aux2( aux1.getNumRows()-1, aux1.getNumCols());
for (int j = 0; j < aux2.getNumCols(); j++)
for (int k = 0; k < aux2.getNumRows(); k++)
aux2.set( k, j, aux1.get(k+1, j) * sigmoidGradient( nn->getActivation(l).at(k)) );
inc.push_back( aux2 );
}
//-- Input layer has no error associated (has no weights associated)
//-- Accumulate error:
for (int l = 0; l < (int) Delta.size(); l++)
{
Matrix aux1( Delta.at(l).getNumRows(), Delta.at(l).getNumCols() );
for (int j = 0; j < aux1.getNumRows(); j++)
aux1.set( j, 0, inc.at( inc.size()- l -1).get( j, 0) );
for (int j = 0; j < aux1.getNumRows(); j++)
for (int k = 1; k < aux1.getNumCols(); k++)
aux1.set( j, k, inc.at( inc.size()- l -1).get( j, 0) * nn->getActivation(l).at(k-1));
Delta.at(l) += aux1;
}
}
//-- Divide by number of training examples:
for (int l = 0; l < (int) Delta.size(); l++)
Delta.at(l) /= numExamples;
//-- Regularization
//------------------------------------------------------------------------
if (lambda != 0)
{
for (int l = 0; l < (int) Delta.size(); l++)
{
Matrix aux(nn->getWeights().at(l)->getNumRows(), nn->getWeights().at(l)->getNumCols() );
for (int j = 0; j < aux.getNumRows(); j++)
for (int k = 1; k < aux.getNumCols(); k++)
aux.set( j, k, nn->getWeights().at(l)->get(j, k) * lambda / numExamples);
Delta.at(l) += aux;
}
}
//-- Unroll gradient:
//---------------------------------------------------------------------------
std::vector<double> unrolled = Delta.front().unroll();
for (int l = 1; l < (int) Delta.size(); l++)
for (int j = 0; j < Delta.at(l).getNumRows(); j++)
for (int k = 0; k < Delta.at(l).getNumCols(); k++)
unrolled.push_back( Delta.at(l).get(j, k));
return unrolled;
}
SOrientedBoundingBox *
SOrientedBoundingBox::buildOBB(std::vector<SPoint3> &vertices)
{
#if defined(HAVE_MESH)
int num_vertices = vertices.size();
// First organize the data
std::set<SPoint3> unique;
unique.insert(vertices.begin(), vertices.end());
num_vertices = unique.size();
fullMatrix<double> data(3, num_vertices);
fullVector<double> mean(3);
fullVector<double> vmins(3);
fullVector<double> vmaxs(3);
mean.setAll(0);
vmins.setAll(DBL_MAX);
vmaxs.setAll(-DBL_MAX);
size_t idx = 0;
for(std::set<SPoint3>::iterator uIter = unique.begin(); uIter != unique.end();
++uIter) {
const SPoint3 &pp = *uIter;
for(int d = 0; d < 3; d++) {
data(d, idx) = pp[d];
vmins(d) = std::min(vmins(d), pp[d]);
vmaxs(d) = std::max(vmaxs(d), pp[d]);
mean(d) += pp[d];
}
idx++;
}
for(int i = 0; i < 3; i++) { mean(i) /= num_vertices; }
// Get the deviation from the mean
fullMatrix<double> B(3, num_vertices);
for(int i = 0; i < 3; i++) {
for(int j = 0; j < num_vertices; j++) { B(i, j) = data(i, j) - mean(i); }
}
// Compute the covariance matrix
fullMatrix<double> covariance(3, 3);
B.mult(B.transpose(), covariance);
covariance.scale(1. / (num_vertices - 1));
/*
Msg::Debug("Covariance matrix");
Msg::Debug("%f %f %f", covariance(0,0),covariance(0,1),covariance(0,2) );
Msg::Debug("%f %f %f", covariance(1,0),covariance(1,1),covariance(1,2) );
Msg::Debug("%f %f %f", covariance(2,0),covariance(2,1),covariance(2,2) );
*/
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
if(std::abs(covariance(i, j)) < 10e-16) covariance(i, j) = 0;
}
}
fullMatrix<double> left_eigv(3, 3);
fullMatrix<double> right_eigv(3, 3);
fullVector<double> real_eig(3);
fullVector<double> img_eig(3);
covariance.eig(real_eig, img_eig, left_eigv, right_eigv, true);
// Now, project the data in the new basis.
fullMatrix<double> projected(3, num_vertices);
left_eigv.transpose().mult(data, projected);
// Get the size of the box in the new direction
fullVector<double> mins(3);
fullVector<double> maxs(3);
for(int i = 0; i < 3; i++) {
mins(i) = DBL_MAX;
maxs(i) = -DBL_MAX;
for(int j = 0; j < num_vertices; j++) {
maxs(i) = std::max(maxs(i), projected(i, j));
mins(i) = std::min(mins(i), projected(i, j));
}
}
// double means[3];
double sizes[3];
// Note: the size is computed in the box's coordinates!
for(int i = 0; i < 3; i++) {
sizes[i] = maxs(i) - mins(i);
// means[i] = (maxs(i) - mins(i)) / 2.;
}
if(sizes[0] == 0 && sizes[1] == 0) {
// Entity is a straight line...
SVector3 center;
SVector3 Axis1;
SVector3 Axis2;
SVector3 Axis3;
Axis1[0] = left_eigv(0, 0);
Axis1[1] = left_eigv(1, 0);
Axis1[2] = left_eigv(2, 0);
Axis2[0] = left_eigv(0, 1);
Axis2[1] = left_eigv(1, 1);
Axis2[2] = left_eigv(2, 1);
Axis3[0] = left_eigv(0, 2);
Axis3[1] = left_eigv(1, 2);
Axis3[2] = left_eigv(2, 2);
center[0] = (vmaxs(0) + vmins(0)) / 2.0;
center[1] = (vmaxs(1) + vmins(1)) / 2.0;
center[2] = (vmaxs(2) + vmins(2)) / 2.0;
return new SOrientedBoundingBox(center, sizes[0], sizes[1], sizes[2], Axis1,
Axis2, Axis3);
}
// We take the smallest component, then project the data on the plane defined
// by the other twos
int smallest_comp = 0;
if(sizes[0] <= sizes[1] && sizes[0] <= sizes[2])
smallest_comp = 0;
else if(sizes[1] <= sizes[0] && sizes[1] <= sizes[2])
smallest_comp = 1;
else if(sizes[2] <= sizes[0] && sizes[2] <= sizes[1])
smallest_comp = 2;
// The projection has been done circa line 161.
// We just ignore the coordinate corresponding to smallest_comp.
std::vector<SPoint2 *> points;
for(int i = 0; i < num_vertices; i++) {
SPoint2 *p = new SPoint2(projected(smallest_comp == 0 ? 1 : 0, i),
projected(smallest_comp == 2 ? 1 : 2, i));
bool keep = true;
for(std::vector<SPoint2 *>::iterator point = points.begin();
point != points.end(); point++) {
if(std::abs((*p)[0] - (**point)[0]) < 10e-10 &&
std::abs((*p)[1] - (**point)[1]) < 10e-10) {
keep = false;
break;
}
}
if(keep) { points.push_back(p); }
else {
delete p;
}
}
// Find the convex hull from a delaunay triangulation of the points
DocRecord record(points.size());
record.numPoints = points.size();
srand((unsigned)time(0));
for(std::size_t i = 0; i < points.size(); i++) {
record.points[i].where.h =
points[i]->x() + (10e-6) * sizes[smallest_comp == 0 ? 1 : 0] *
(-0.5 + ((double)rand()) / RAND_MAX);
record.points[i].where.v =
points[i]->y() + (10e-6) * sizes[smallest_comp == 2 ? 1 : 0] *
(-0.5 + ((double)rand()) / RAND_MAX);
record.points[i].adjacent = NULL;
}
try {
record.MakeMeshWithPoints();
} catch(const char *err) {
Msg::Error("%s", err);
}
std::vector<Segment> convex_hull;
for(int i = 0; i < record.numTriangles; i++) {
Segment segs[3];
segs[0].from = record.triangles[i].a;
segs[0].to = record.triangles[i].b;
segs[1].from = record.triangles[i].b;
segs[1].to = record.triangles[i].c;
segs[2].from = record.triangles[i].c;
segs[2].to = record.triangles[i].a;
for(int j = 0; j < 3; j++) {
bool okay = true;
for(std::vector<Segment>::iterator seg = convex_hull.begin();
seg != convex_hull.end(); seg++) {
if(((*seg).from == segs[j].from && (*seg).from == segs[j].to)
// FIXME:
// || ((*seg).from == segs[j].to && (*seg).from == segs[j].from)
) {
convex_hull.erase(seg);
okay = false;
break;
}
}
if(okay) { convex_hull.push_back(segs[j]); }
}
}
// Now, examinate all the directions given by the edges of the convex hull
// to find the one that lets us build the least-area bounding rectangle for
// then points.
fullVector<double> axis(2);
axis(0) = 1;
axis(1) = 0;
fullVector<double> axis2(2);
axis2(0) = 0;
axis2(1) = 1;
SOrientedBoundingRectangle least_rectangle;
least_rectangle.center[0] = 0.0;
least_rectangle.center[1] = 0.0;
least_rectangle.size[0] = -1.0;
least_rectangle.size[1] = 1.0;
fullVector<double> segment(2);
fullMatrix<double> rotation(2, 2);
for(std::vector<Segment>::iterator seg = convex_hull.begin();
seg != convex_hull.end(); seg++) {
// segment(0) = record.points[(*seg).from].where.h -
// record.points[(*seg).to].where.h; segment(1) =
// record.points[(*seg).from].where.v - record.points[(*seg).to].where.v;
segment(0) = points[(*seg).from]->x() - points[(*seg).to]->x();
segment(1) = points[(*seg).from]->y() - points[(*seg).to]->y();
segment.scale(1.0 / segment.norm());
double cosine = axis(0) * segment(0) + segment(1) * axis(1);
double sine = axis(1) * segment(0) - segment(1) * axis(0);
// double sine = axis(0)*segment(1) - segment(0)*axis(1);
rotation(0, 0) = cosine;
rotation(0, 1) = sine;
rotation(1, 0) = -sine;
rotation(1, 1) = cosine;
// TODO C++11 std::numeric_limits<double>
double max_x = -DBL_MAX;
double min_x = DBL_MAX;
double max_y = -DBL_MAX;
double min_y = DBL_MAX;
for(int i = 0; i < record.numPoints; i++) {
fullVector<double> pnt(2);
// pnt(0) = record.points[i].where.h;
// pnt(1) = record.points[i].where.v;
pnt(0) = points[i]->x();
pnt(1) = points[i]->y();
fullVector<double> rot_pnt(2);
rotation.mult(pnt, rot_pnt);
if(rot_pnt(0) < min_x) min_x = rot_pnt(0);
if(rot_pnt(0) > max_x) max_x = rot_pnt(0);
if(rot_pnt(1) < min_y) min_y = rot_pnt(1);
if(rot_pnt(1) > max_y) max_y = rot_pnt(1);
}
/**/
fullVector<double> center_rot(2);
fullVector<double> center_before_rot(2);
center_before_rot(0) = (max_x + min_x) / 2.0;
center_before_rot(1) = (max_y + min_y) / 2.0;
fullMatrix<double> rotation_inv(2, 2);
rotation_inv(0, 0) = cosine;
rotation_inv(0, 1) = -sine;
rotation_inv(1, 0) = sine;
rotation_inv(1, 1) = cosine;
rotation_inv.mult(center_before_rot, center_rot);
fullVector<double> axis_rot1(2);
fullVector<double> axis_rot2(2);
rotation_inv.mult(axis, axis_rot1);
rotation_inv.mult(axis2, axis_rot2);
if((least_rectangle.area() == -1) ||
(max_x - min_x) * (max_y - min_y) < least_rectangle.area()) {
least_rectangle.size[0] = max_x - min_x;
least_rectangle.size[1] = max_y - min_y;
least_rectangle.center[0] = (max_x + min_x) / 2.0;
least_rectangle.center[1] = (max_y + min_y) / 2.0;
least_rectangle.center[0] = center_rot(0);
least_rectangle.center[1] = center_rot(1);
least_rectangle.axisX[0] = axis_rot1(0);
least_rectangle.axisX[1] = axis_rot1(1);
// least_rectangle.axisX[0] = segment(0);
// least_rectangle.axisX[1] = segment(1);
least_rectangle.axisY[0] = axis_rot2(0);
least_rectangle.axisY[1] = axis_rot2(1);
}
}
// TODO C++11 std::numeric_limits<double>::min() / max()
double min_pca = DBL_MAX;
double max_pca = -DBL_MAX;
for(int i = 0; i < num_vertices; i++) {
min_pca = std::min(min_pca, projected(smallest_comp, i));
max_pca = std::max(max_pca, projected(smallest_comp, i));
}
double center_pca = (max_pca + min_pca) / 2.0;
double size_pca = (max_pca - min_pca);
double raw_data[3][5];
raw_data[0][0] = size_pca;
raw_data[1][0] = least_rectangle.size[0];
raw_data[2][0] = least_rectangle.size[1];
raw_data[0][1] = center_pca;
raw_data[1][1] = least_rectangle.center[0];
raw_data[2][1] = least_rectangle.center[1];
for(int i = 0; i < 3; i++) {
raw_data[0][2 + i] = left_eigv(i, smallest_comp);
raw_data[1][2 + i] =
least_rectangle.axisX[0] * left_eigv(i, smallest_comp == 0 ? 1 : 0) +
least_rectangle.axisX[1] * left_eigv(i, smallest_comp == 2 ? 1 : 2);
raw_data[2][2 + i] =
least_rectangle.axisY[0] * left_eigv(i, smallest_comp == 0 ? 1 : 0) +
least_rectangle.axisY[1] * left_eigv(i, smallest_comp == 2 ? 1 : 2);
}
// Msg::Info("Test 1 : %f
// %f",least_rectangle.center[0],least_rectangle.center[1]);
// Msg::Info("Test 2 : %f
// %f",least_rectangle.axisY[0],least_rectangle.axisY[1]);
int tri[3];
if(size_pca > least_rectangle.size[0]) {
// P > R0
if(size_pca > least_rectangle.size[1]) {
// P > R1
tri[0] = 0;
if(least_rectangle.size[0] > least_rectangle.size[1]) {
// R0 > R1
tri[1] = 1;
tri[2] = 2;
}
else {
// R1 > R0
tri[1] = 2;
tri[2] = 1;
}
}
else {
// P < R1
tri[0] = 2;
tri[1] = 0;
tri[2] = 1;
}
}
else { // P < R0
if(size_pca < least_rectangle.size[1]) {
// P < R1
tri[2] = 0;
if(least_rectangle.size[0] > least_rectangle.size[1]) {
tri[0] = 1;
tri[1] = 2;
}
else {
tri[0] = 2;
tri[1] = 1;
}
}
else {
tri[0] = 1;
tri[1] = 0;
tri[2] = 2;
}
}
SVector3 size;
SVector3 center;
SVector3 Axis1;
SVector3 Axis2;
SVector3 Axis3;
for(int i = 0; i < 3; i++) {
size[i] = raw_data[tri[i]][0];
center[i] = raw_data[tri[i]][1];
Axis1[i] = raw_data[tri[0]][2 + i];
Axis2[i] = raw_data[tri[1]][2 + i];
Axis3[i] = raw_data[tri[2]][2 + i];
}
SVector3 aux1;
SVector3 aux2;
SVector3 aux3;
for(int i = 0; i < 3; i++) {
aux1(i) = left_eigv(i, smallest_comp);
aux2(i) = left_eigv(i, smallest_comp == 0 ? 1 : 0);
aux3(i) = left_eigv(i, smallest_comp == 2 ? 1 : 2);
}
center = aux1 * center_pca + aux2 * least_rectangle.center[0] +
aux3 * least_rectangle.center[1];
// center[1] = -center[1];
/*
Msg::Info("Box center : %f %f %f",center[0],center[1],center[2]);
Msg::Info("Box size : %f %f %f",size[0],size[1],size[2]);
Msg::Info("Box axis 1 : %f %f %f",Axis1[0],Axis1[1],Axis1[2]);
Msg::Info("Box axis 2 : %f %f %f",Axis2[0],Axis2[1],Axis2[2]);
Msg::Info("Box axis 3 : %f %f %f",Axis3[0],Axis3[1],Axis3[2]);
Msg::Info("Volume : %f", size[0]*size[1]*size[2]);
*/
return new SOrientedBoundingBox(center, size[0], size[1], size[2], Axis1,
Axis2, Axis3);
#else
Msg::Error("SOrientedBoundingBox requires mesh module");
return 0;
#endif
}
