3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-10-31 04:31:15 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 5
OrcaSlicer/src/igl/AABB.cpp

1076 lines
43 KiB
C++
Raw Blame History

// This file is part of libigl, a simple c++ geometry processing library.
//
// Copyright (C) 2013 Alec Jacobson <alecjacobson@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla Public License
// v. 2.0. If a copy of the MPL was not distributed with this file, You can
// obtain one at http://mozilla.org/MPL/2.0/.
#include "AABB.h"
#include "EPS.h"
#include "barycenter.h"
#include "colon.h"
#include "doublearea.h"
#include "point_simplex_squared_distance.h"
#include "project_to_line_segment.h"
#include "sort.h"
#include "volume.h"
#include "ray_box_intersect.h"
#include "parallel_for.h"
#include "ray_mesh_intersect.h"
#include <iostream>
#include <iomanip>
#include <limits>
#include <list>
#include <queue>
#include <stack>
template <typename DerivedV, int DIM>
template <typename DerivedEle, typename Derivedbb_mins, typename Derivedbb_maxs, typename Derivedelements>
IGL_INLINE void igl::AABB<DerivedV,DIM>::init(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele,
const Eigen::MatrixBase<Derivedbb_mins> & bb_mins,
const Eigen::MatrixBase<Derivedbb_maxs> & bb_maxs,
const Eigen::MatrixBase<Derivedelements> & elements,
const int i)
{
using namespace std;
using namespace Eigen;
deinit();
if(bb_mins.size() > 0)
{
assert(bb_mins.rows() == bb_maxs.rows() && "Serial tree arrays must match");
assert(bb_mins.cols() == V.cols() && "Serial tree array dim must match V");
assert(bb_mins.cols() == bb_maxs.cols() && "Serial tree arrays must match");
assert(bb_mins.rows() == elements.rows() &&
"Serial tree arrays must match");
// construct from serialization
m_box.extend(bb_mins.row(i).transpose());
m_box.extend(bb_maxs.row(i).transpose());
m_primitive = elements(i);
// Not leaf then recurse
if(m_primitive == -1)
{
m_left = new AABB();
m_left->init( V,Ele,bb_mins,bb_maxs,elements,2*i+1);
m_right = new AABB();
m_right->init( V,Ele,bb_mins,bb_maxs,elements,2*i+2);
//m_depth = std::max( m_left->m_depth, m_right->m_depth)+1;
}
}else
{
VectorXi allI = colon<int>(0,Ele.rows()-1);
MatrixXDIMS BC;
if(Ele.cols() == 1)
{
// points
BC = V;
}else
{
// Simplices
barycenter(V,Ele,BC);
}
MatrixXi SI(BC.rows(),BC.cols());
{
MatrixXDIMS _;
MatrixXi IS;
igl::sort(BC,1,true,_,IS);
// Need SI(i) to tell which place i would be sorted into
const int dim = IS.cols();
for(int i = 0;i<IS.rows();i++)
{
for(int d = 0;d<dim;d++)
{
SI(IS(i,d),d) = i;
}
}
}
init(V,Ele,SI,allI);
}
}
template <typename DerivedV, int DIM>
template <typename DerivedEle>
void igl::AABB<DerivedV,DIM>::init(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele)
{
using namespace Eigen;
// deinit will be immediately called...
return init(V,Ele,MatrixXDIMS(),MatrixXDIMS(),VectorXi(),0);
}
template <typename DerivedV, int DIM>
template <
typename DerivedEle,
typename DerivedSI,
typename DerivedI>
IGL_INLINE void igl::AABB<DerivedV,DIM>::init(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele,
const Eigen::MatrixBase<DerivedSI> & SI,
const Eigen::MatrixBase<DerivedI> & I)
{
using namespace Eigen;
using namespace std;
deinit();
if(V.size() == 0 || Ele.size() == 0 || I.size() == 0)
{
return;
}
assert(DIM == V.cols() && "V.cols() should matched declared dimension");
//const Scalar inf = numeric_limits<Scalar>::infinity();
m_box = AlignedBox<Scalar,DIM>();
// Compute bounding box
for(int i = 0;i<I.rows();i++)
{
for(int c = 0;c<Ele.cols();c++)
{
m_box.extend(V.row(Ele(I(i),c)).transpose());
m_box.extend(V.row(Ele(I(i),c)).transpose());
}
}
switch(I.size())
{
case 0:
{
assert(false);
}
case 1:
{
m_primitive = I(0);
break;
}
default:
{
// Compute longest direction
int max_d = -1;
m_box.diagonal().maxCoeff(&max_d);
// Can't use median on BC directly because many may have same value,
// but can use median on sorted BC indices
VectorXi SIdI(I.rows());
for(int i = 0;i<I.rows();i++)
{
SIdI(i) = SI(I(i),max_d);
}
// Pass by copy to avoid changing input
const auto median = [](VectorXi A)->int
{
size_t n = (A.size()-1)/2;
nth_element(A.data(),A.data()+n,A.data()+A.size());
return A(n);
};
const int med = median(SIdI);
VectorXi LI((I.rows()+1)/2),RI(I.rows()/2);
assert(LI.rows()+RI.rows() == I.rows());
// Distribute left and right
{
int li = 0;
int ri = 0;
for(int i = 0;i<I.rows();i++)
{
if(SIdI(i)<=med)
{
LI(li++) = I(i);
}else
{
RI(ri++) = I(i);
}
}
}
//m_depth = 0;
if(LI.rows()>0)
{
m_left = new AABB();
m_left->init(V,Ele,SI,LI);
//m_depth = std::max(m_depth, m_left->m_depth+1);
}
if(RI.rows()>0)
{
m_right = new AABB();
m_right->init(V,Ele,SI,RI);
//m_depth = std::max(m_depth, m_right->m_depth+1);
}
}
}
}
template <typename DerivedV, int DIM>
IGL_INLINE bool igl::AABB<DerivedV,DIM>::is_leaf() const
{
return m_primitive != -1;
}
template <typename DerivedV, int DIM>
template <typename DerivedEle, typename Derivedq>
IGL_INLINE std::vector<int> igl::AABB<DerivedV,DIM>::find(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele,
const Eigen::MatrixBase<Derivedq> & q,
const bool first) const
{
using namespace std;
using namespace Eigen;
assert(q.size() == DIM &&
"Query dimension should match aabb dimension");
assert(Ele.cols() == V.cols()+1 &&
"AABB::find only makes sense for (d+1)-simplices");
const Scalar epsilon = igl::EPS<Scalar>();
// Check if outside bounding box
bool inside = m_box.contains(q.transpose());
if(!inside)
{
return std::vector<int>();
}
assert(m_primitive==-1 || (m_left == NULL && m_right == NULL));
if(is_leaf())
{
// Initialize to some value > -epsilon
Scalar a1=0,a2=0,a3=0,a4=0;
switch(DIM)
{
case 3:
{
// Barycentric coordinates
typedef Eigen::Matrix<Scalar,1,3> RowVector3S;
const RowVector3S V1 = V.row(Ele(m_primitive,0));
const RowVector3S V2 = V.row(Ele(m_primitive,1));
const RowVector3S V3 = V.row(Ele(m_primitive,2));
const RowVector3S V4 = V.row(Ele(m_primitive,3));
a1 = volume_single(V2,V4,V3,(RowVector3S)q);
a2 = volume_single(V1,V3,V4,(RowVector3S)q);
a3 = volume_single(V1,V4,V2,(RowVector3S)q);
a4 = volume_single(V1,V2,V3,(RowVector3S)q);
break;
}
case 2:
{
// Barycentric coordinates
typedef Eigen::Matrix<Scalar,2,1> Vector2S;
const Vector2S V1 = V.row(Ele(m_primitive,0));
const Vector2S V2 = V.row(Ele(m_primitive,1));
const Vector2S V3 = V.row(Ele(m_primitive,2));
// Hack for now to keep templates simple. If becomes bottleneck
// consider using std::enable_if_t
const Vector2S q2 = q.head(2);
a1 = doublearea_single(V1,V2,q2);
a2 = doublearea_single(V2,V3,q2);
a3 = doublearea_single(V3,V1,q2);
break;
}
default:assert(false);
}
// Normalization is important for correcting sign
Scalar sum = a1+a2+a3+a4;
a1 /= sum;
a2 /= sum;
a3 /= sum;
a4 /= sum;
if(
a1>=-epsilon &&
a2>=-epsilon &&
a3>=-epsilon &&
a4>=-epsilon)
{
return std::vector<int>(1,m_primitive);
}else
{
return std::vector<int>();
}
}
std::vector<int> left = m_left->find(V,Ele,q,first);
if(first && !left.empty())
{
return left;
}
std::vector<int> right = m_right->find(V,Ele,q,first);
if(first)
{
return right;
}
left.insert(left.end(),right.begin(),right.end());
return left;
}
template <typename DerivedV, int DIM>
IGL_INLINE int igl::AABB<DerivedV,DIM>::subtree_size() const
{
// 1 for self
int n = 1;
int n_left = 0,n_right = 0;
if(m_left != NULL)
{
n_left = m_left->subtree_size();
}
if(m_right != NULL)
{
n_right = m_right->subtree_size();
}
n += 2*std::max(n_left,n_right);
return n;
}
template <typename DerivedV, int DIM>
template <typename Derivedbb_mins, typename Derivedbb_maxs, typename Derivedelements>
IGL_INLINE void igl::AABB<DerivedV,DIM>::serialize(
Eigen::PlainObjectBase<Derivedbb_mins> & bb_mins,
Eigen::PlainObjectBase<Derivedbb_maxs> & bb_maxs,
Eigen::PlainObjectBase<Derivedelements> & elements,
const int i) const
{
using namespace std;
using namespace Eigen;
// Calling for root then resize output
if(i==0)
{
const int m = subtree_size();
//cout<<"m: "<<m<<endl;
bb_mins.resize(m,DIM);
bb_maxs.resize(m,DIM);
elements.resize(m,1);
}
//cout<<i<<" ";
bb_mins.row(i) = m_box.min();
bb_maxs.row(i) = m_box.max();
elements(i) = m_primitive;
if(m_left != NULL)
{
m_left->serialize(bb_mins,bb_maxs,elements,2*i+1);
}
if(m_right != NULL)
{
m_right->serialize(bb_mins,bb_maxs,elements,2*i+2);
}
}
template <typename DerivedV, int DIM>
template <typename DerivedEle>
IGL_INLINE typename igl::AABB<DerivedV,DIM>::Scalar
igl::AABB<DerivedV,DIM>::squared_distance(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele,
const RowVectorDIMS & p,
int & i,
Eigen::PlainObjectBase<RowVectorDIMS> & c) const
{
return squared_distance(V,Ele,p,std::numeric_limits<Scalar>::infinity(),i,c);
}
template <typename DerivedV, int DIM>
template <typename DerivedEle>
IGL_INLINE typename igl::AABB<DerivedV,DIM>::Scalar
igl::AABB<DerivedV,DIM>::squared_distance(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele,
const RowVectorDIMS & p,
Scalar low_sqr_d,
Scalar up_sqr_d,
int & i,
Eigen::PlainObjectBase<RowVectorDIMS> & c) const
{
using namespace Eigen;
using namespace std;
//assert(low_sqr_d <= up_sqr_d);
if(low_sqr_d > up_sqr_d)
{
return low_sqr_d;
}
Scalar sqr_d = up_sqr_d;
//assert(DIM == 3 && "Code has only been tested for DIM == 3");
assert((Ele.cols() == 3 || Ele.cols() == 2 || Ele.cols() == 1)
&& "Code has only been tested for simplex sizes 3,2,1");
assert(m_primitive==-1 || (m_left == NULL && m_right == NULL));
if(is_leaf())
{
leaf_squared_distance(V,Ele,p,low_sqr_d,sqr_d,i,c);
}else
{
bool looked_left = false;
bool looked_right = false;
const auto & look_left = [&]()
{
int i_left;
RowVectorDIMS c_left = c;
Scalar sqr_d_left =
m_left->squared_distance(V,Ele,p,low_sqr_d,sqr_d,i_left,c_left);
this->set_min(p,sqr_d_left,i_left,c_left,sqr_d,i,c);
looked_left = true;
};
const auto & look_right = [&]()
{
int i_right;
RowVectorDIMS c_right = c;
Scalar sqr_d_right =
m_right->squared_distance(V,Ele,p,low_sqr_d,sqr_d,i_right,c_right);
this->set_min(p,sqr_d_right,i_right,c_right,sqr_d,i,c);
looked_right = true;
};
// must look left or right if in box
if(m_left->m_box.contains(p.transpose()))
{
look_left();
}
if(m_right->m_box.contains(p.transpose()))
{
look_right();
}
// if haven't looked left and could be less than current min, then look
Scalar left_up_sqr_d =
m_left->m_box.squaredExteriorDistance(p.transpose());
Scalar right_up_sqr_d =
m_right->m_box.squaredExteriorDistance(p.transpose());
if(left_up_sqr_d < right_up_sqr_d)
{
if(!looked_left && left_up_sqr_d<sqr_d)
{
look_left();
}
if( !looked_right && right_up_sqr_d<sqr_d)
{
look_right();
}
}else
{
if( !looked_right && right_up_sqr_d<sqr_d)
{
look_right();
}
if(!looked_left && left_up_sqr_d<sqr_d)
{
look_left();
}
}
}
return sqr_d;
}
template <typename DerivedV, int DIM>
template <typename DerivedEle>
IGL_INLINE typename igl::AABB<DerivedV,DIM>::Scalar
igl::AABB<DerivedV,DIM>::squared_distance(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele,
const RowVectorDIMS & p,
Scalar up_sqr_d,
int & i,
Eigen::PlainObjectBase<RowVectorDIMS> & c) const
{
return squared_distance(V,Ele,p,0.0,up_sqr_d,i,c);
}
template <typename DerivedV, int DIM>
template <
typename DerivedEle,
typename DerivedP,
typename DerivedsqrD,
typename DerivedI,
typename DerivedC>
IGL_INLINE void igl::AABB<DerivedV,DIM>::squared_distance(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele,
const Eigen::MatrixBase<DerivedP> & P,
Eigen::PlainObjectBase<DerivedsqrD> & sqrD,
Eigen::PlainObjectBase<DerivedI> & I,
Eigen::PlainObjectBase<DerivedC> & C) const
{
assert(P.cols() == V.cols() && "cols in P should match dim of cols in V");
sqrD.resize(P.rows(),1);
I.resize(P.rows(),1);
C.resizeLike(P);
// O( #P * log #Ele ), where log #Ele is really the depth of this AABB
// hierarchy
//for(int p = 0;p<P.rows();p++)
igl::parallel_for(P.rows(),[&](int p)
{
RowVectorDIMS Pp = P.row(p), c;
int Ip;
sqrD(p) = squared_distance(V,Ele,Pp,Ip,c);
I(p) = Ip;
C.row(p).head(DIM) = c;
},
10000);
}
template <typename DerivedV, int DIM>
template <
typename DerivedEle,
typename Derivedother_V,
typename Derivedother_Ele,
typename DerivedsqrD,
typename DerivedI,
typename DerivedC>
IGL_INLINE void igl::AABB<DerivedV,DIM>::squared_distance(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele,
const AABB<Derivedother_V,DIM> & other,
const Eigen::MatrixBase<Derivedother_V> & other_V,
const Eigen::MatrixBase<Derivedother_Ele> & other_Ele,
Eigen::PlainObjectBase<DerivedsqrD> & sqrD,
Eigen::PlainObjectBase<DerivedI> & I,
Eigen::PlainObjectBase<DerivedC> & C) const
{
assert(other_Ele.cols() == 1 &&
"Only implemented for other as list of points");
assert(other_V.cols() == V.cols() && "other must match this dimension");
sqrD.setConstant(other_Ele.rows(),1,std::numeric_limits<double>::infinity());
I.resize(other_Ele.rows(),1);
C.resize(other_Ele.rows(),other_V.cols());
// All points in other_V currently think they need to check against root of
// this. The point of using another AABB is to quickly prune chunks of
// other_V so that most points just check some subtree of this.
// This holds a conservative estimate of max(sqr_D) where sqr_D is the
// current best minimum squared distance for all points in this subtree
double up_sqr_d = std::numeric_limits<double>::infinity();
squared_distance_helper(
V,Ele,&other,other_V,other_Ele,0,up_sqr_d,sqrD,I,C);
}
template <typename DerivedV, int DIM>
template <
typename DerivedEle,
typename Derivedother_V,
typename Derivedother_Ele,
typename DerivedsqrD,
typename DerivedI,
typename DerivedC>
IGL_INLINE typename igl::AABB<DerivedV,DIM>::Scalar
igl::AABB<DerivedV,DIM>::squared_distance_helper(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele,
const AABB<Derivedother_V,DIM> * other,
const Eigen::MatrixBase<Derivedother_V> & other_V,
const Eigen::MatrixBase<Derivedother_Ele> & other_Ele,
const Scalar /*up_sqr_d*/,
Eigen::PlainObjectBase<DerivedsqrD> & sqrD,
Eigen::PlainObjectBase<DerivedI> & I,
Eigen::PlainObjectBase<DerivedC> & C) const
{
using namespace std;
using namespace Eigen;
// This implementation is a bit disappointing. There's no major speed up. Any
// performance gains seem to come from accidental cache coherency and
// diminish for larger "other" (the opposite of what was intended).
// Base case
if(other->is_leaf() && this->is_leaf())
{
Scalar sqr_d = sqrD(other->m_primitive);
int i = I(other->m_primitive);
RowVectorDIMS c = C.row( other->m_primitive);
RowVectorDIMS p = other_V.row(other->m_primitive);
leaf_squared_distance(V,Ele,p,sqr_d,i,c);
sqrD( other->m_primitive) = sqr_d;
I( other->m_primitive) = i;
C.row(other->m_primitive) = c;
//cout<<"leaf: "<<sqr_d<<endl;
//other->m_low_sqr_d = sqr_d;
return sqr_d;
}
if(other->is_leaf())
{
Scalar sqr_d = sqrD(other->m_primitive);
int i = I(other->m_primitive);
RowVectorDIMS c = C.row( other->m_primitive);
RowVectorDIMS p = other_V.row(other->m_primitive);
sqr_d = squared_distance(V,Ele,p,sqr_d,i,c);
sqrD( other->m_primitive) = sqr_d;
I( other->m_primitive) = i;
C.row(other->m_primitive) = c;
//other->m_low_sqr_d = sqr_d;
return sqr_d;
}
//// Exact minimum squared distance between arbitrary primitives inside this and
//// othre's bounding boxes
//const auto & min_squared_distance = [&](
// const AABB<DerivedV,DIM> * A,
// const AABB<Derivedother_V,DIM> * B)->Scalar
//{
// return A->m_box.squaredExteriorDistance(B->m_box);
//};
if(this->is_leaf())
{
//if(min_squared_distance(this,other) < other->m_low_sqr_d)
if(true)
{
this->squared_distance_helper(
V,Ele,other->m_left,other_V,other_Ele,0,sqrD,I,C);
this->squared_distance_helper(
V,Ele,other->m_right,other_V,other_Ele,0,sqrD,I,C);
}else
{
// This is never reached...
}
//// we know other is not a leaf
//other->m_low_sqr_d = std::max(other->m_left->m_low_sqr_d,other->m_right->m_low_sqr_d);
return 0;
}
// FORCE DOWN TO OTHER LEAF EVAL
//if(min_squared_distance(this,other) < other->m_low_sqr_d)
if(true)
{
if(true)
{
this->squared_distance_helper(
V,Ele,other->m_left,other_V,other_Ele,0,sqrD,I,C);
this->squared_distance_helper(
V,Ele,other->m_right,other_V,other_Ele,0,sqrD,I,C);
}else // this direction never seems to be faster
{
this->m_left->squared_distance_helper(
V,Ele,other,other_V,other_Ele,0,sqrD,I,C);
this->m_right->squared_distance_helper(
V,Ele,other,other_V,other_Ele,0,sqrD,I,C);
}
}else
{
// this is never reached ... :-(
}
//// we know other is not a leaf
//other->m_low_sqr_d = std::max(other->m_left->m_low_sqr_d,other->m_right->m_low_sqr_d);
return 0;
#if 0 // False
// _Very_ conservative approximation of maximum squared distance between
// primitives inside this and other's bounding boxes
const auto & max_squared_distance = [](
const AABB<DerivedV,DIM> * A,
const AABB<Derivedother_V,DIM> * B)->Scalar
{
AlignedBox<Scalar,DIM> combo = A->m_box;
combo.extend(B->m_box);
return combo.diagonal().squaredNorm();
};
//// other base-case
//if(other->is_leaf())
//{
// double sqr_d = sqrD(other->m_primitive);
// int i = I(other->m_primitive);
// RowVectorDIMS c = C.row(m_primitive);
// RowVectorDIMS p = other_V.row(m_primitive);
// leaf_squared_distance(V,Ele,p,sqr_d,i,c);
// sqrD(other->m_primitive) = sqr_d;
// I(other->m_primitive) = i;
// C.row(m_primitive) = c;
// return;
//}
std::vector<const AABB<DerivedV,DIM> * > this_list;
if(this->is_leaf())
{
this_list.push_back(this);
}else
{
assert(this->m_left);
this_list.push_back(this->m_left);
assert(this->m_right);
this_list.push_back(this->m_right);
}
std::vector<AABB<Derivedother_V,DIM> *> other_list;
if(other->is_leaf())
{
other_list.push_back(other);
}else
{
assert(other->m_left);
other_list.push_back(other->m_left);
assert(other->m_right);
other_list.push_back(other->m_right);
}
//const std::function<Scalar(
// const AABB<Derivedother_V,DIM> * other)
// > low_sqr_d = [&sqrD,&low_sqr_d](const AABB<Derivedother_V,DIM> * other)->Scalar
// {
// if(other->is_leaf())
// {
// return sqrD(other->m_primitive);
// }else
// {
// return std::max(low_sqr_d(other->m_left),low_sqr_d(other->m_right));
// }
// };
//// Potentially recurse on all pairs, if minimum distance is less than running
//// bound
//Eigen::Matrix<Scalar,Eigen::Dynamic,1> other_low_sqr_d =
// Eigen::Matrix<Scalar,Eigen::Dynamic,1>::Constant(other_list.size(),1,up_sqr_d);
for(size_t child = 0;child<other_list.size();child++)
{
auto other_tree = other_list[child];
Eigen::Matrix<Scalar,Eigen::Dynamic,1> this_low_sqr_d(this_list.size(),1);
for(size_t t = 0;t<this_list.size();t++)
{
const auto this_tree = this_list[t];
this_low_sqr_d(t) = max_squared_distance(this_tree,other_tree);
}
if(this_list.size() ==2 &&
( this_low_sqr_d(0) > this_low_sqr_d(1))
)
{
std::swap(this_list[0],this_list[1]);
//std::swap(this_low_sqr_d(0),this_low_sqr_d(1));
}
const Scalar sqr_d = this_low_sqr_d.minCoeff();
for(size_t t = 0;t<this_list.size();t++)
{
const auto this_tree = this_list[t];
//const auto mm = low_sqr_d(other_tree);
//const Scalar mc = other_low_sqr_d(child);
//assert(mc == mm);
// Only look left/right in this_list if can possible decrease somebody's
// distance in this_tree.
const Scalar min_this_other = min_squared_distance(this_tree,other_tree);
if(
min_this_other < sqr_d &&
min_this_other < other_tree->m_low_sqr_d)
{
//cout<<"before: "<<other_low_sqr_d(child)<<endl;
//other_low_sqr_d(child) = std::min(
// other_low_sqr_d(child),
// this_tree->squared_distance_helper(
// V,Ele,other_tree,other_V,other_Ele,other_low_sqr_d(child),sqrD,I,C));
//cout<<"after: "<<other_low_sqr_d(child)<<endl;
this_tree->squared_distance_helper(
V,Ele,other_tree,other_V,other_Ele,0,sqrD,I,C);
}
}
}
//const Scalar ret = other_low_sqr_d.maxCoeff();
//const auto mm = low_sqr_d(other);
//assert(mm == ret);
//cout<<"non-leaf: "<<ret<<endl;
//return ret;
if(!other->is_leaf())
{
other->m_low_sqr_d = std::max(other->m_left->m_low_sqr_d,other->m_right->m_low_sqr_d);
}
return 0;
#endif
}
template <typename DerivedV, int DIM>
template <typename DerivedEle>
IGL_INLINE void igl::AABB<DerivedV,DIM>::leaf_squared_distance(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele,
const RowVectorDIMS & p,
const Scalar low_sqr_d,
Scalar & sqr_d,
int & i,
Eigen::PlainObjectBase<RowVectorDIMS> & c) const
{
using namespace Eigen;
using namespace std;
if(low_sqr_d > sqr_d)
{
sqr_d = low_sqr_d;
return;
}
RowVectorDIMS c_candidate;
Scalar sqr_d_candidate;
igl::point_simplex_squared_distance<DIM>(
p,V,Ele,m_primitive,sqr_d_candidate,c_candidate);
set_min(p,sqr_d_candidate,m_primitive,c_candidate,sqr_d,i,c);
}
template <typename DerivedV, int DIM>
template <typename DerivedEle>
IGL_INLINE void igl::AABB<DerivedV,DIM>::leaf_squared_distance(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele,
const RowVectorDIMS & p,
Scalar & sqr_d,
int & i,
Eigen::PlainObjectBase<RowVectorDIMS> & c) const
{
return leaf_squared_distance(V,Ele,p,0,sqr_d,i,c);
}
template <typename DerivedV, int DIM>
IGL_INLINE void igl::AABB<DerivedV,DIM>::set_min(
const RowVectorDIMS &
#ifndef NDEBUG
p
#endif
,
const Scalar sqr_d_candidate,
const int i_candidate,
const RowVectorDIMS & c_candidate,
Scalar & sqr_d,
int & i,
Eigen::PlainObjectBase<RowVectorDIMS> & c) const
{
#ifndef NDEBUG
//std::cout<<matlab_format(c_candidate,"c_candidate")<<std::endl;
//// This doesn't quite make sense to check with bounds
// const Scalar pc_norm = (p-c_candidate).squaredNorm();
// const Scalar diff = fabs(sqr_d_candidate - pc_norm);
// assert(diff<=1e-10 && "distance should match norm of difference");
#endif
if(sqr_d_candidate < sqr_d)
{
i = i_candidate;
c = c_candidate;
sqr_d = sqr_d_candidate;
}
}
template <typename DerivedV, int DIM>
template <typename DerivedEle>
IGL_INLINE bool
igl::AABB<DerivedV,DIM>::intersect_ray(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele,
const RowVectorDIMS & origin,
const RowVectorDIMS & dir,
std::vector<igl::Hit> & hits) const
{
hits.clear();
const Scalar t0 = 0;
const Scalar t1 = std::numeric_limits<Scalar>::infinity();
{
Scalar _1,_2;
if(!ray_box_intersect(origin,dir,m_box,t0,t1,_1,_2))
{
return false;
}
}
if(this->is_leaf())
{
// Actually process elements
assert((Ele.size() == 0 || Ele.cols() == 3) && "Elements should be triangles");
// Cheesecake way of hitting element
bool ret = ray_mesh_intersect(origin,dir,V,Ele.row(m_primitive),hits);
// Since we only gave ray_mesh_intersect a single face, it will have set
// any hits to id=0. Set these to this primitive's id
for(auto & hit : hits)
{
hit.id = m_primitive;
}
return ret;
}
std::vector<igl::Hit> left_hits;
std::vector<igl::Hit> right_hits;
const bool left_ret = m_left->intersect_ray(V,Ele,origin,dir,left_hits);
const bool right_ret = m_right->intersect_ray(V,Ele,origin,dir,right_hits);
hits.insert(hits.end(),left_hits.begin(),left_hits.end());
hits.insert(hits.end(),right_hits.begin(),right_hits.end());
return left_ret || right_ret;
}
template <typename DerivedV, int DIM>
template <typename DerivedEle>
IGL_INLINE bool
igl::AABB<DerivedV,DIM>::intersect_ray(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele,
const RowVectorDIMS & origin,
const RowVectorDIMS & dir,
igl::Hit & hit) const
{
// FIXME: Needs a proper path
#if /*false*/ 0
// BFS
std::queue<const AABB *> Q;
// Or DFS
//std::stack<const AABB *> Q;
Q.push(this);
bool any_hit = false;
hit.t = std::numeric_limits<Scalar>::infinity();
while(!Q.empty())
{
const AABB * tree = Q.front();
//const AABB * tree = Q.top();
Q.pop();
{
Scalar _1,_2;
if(!ray_box_intersect(
origin,dir,tree->m_box,Scalar(0),Scalar(hit.t),_1,_2))
{
continue;
}
}
if(tree->is_leaf())
{
// Actually process elements
assert((Ele.size() == 0 || Ele.cols() == 3) && "Elements should be triangles");
igl::Hit leaf_hit;
if(
ray_mesh_intersect(origin,dir,V,Ele.row(tree->m_primitive),leaf_hit)&&
leaf_hit.t < hit.t)
{
// correct the id
leaf_hit.id = tree->m_primitive;
hit = leaf_hit;
}
continue;
}
// Add children to queue
Q.push(tree->m_left);
Q.push(tree->m_right);
}
return any_hit;
#else
// DFS
return intersect_ray(
V,Ele,origin,dir,std::numeric_limits<Scalar>::infinity(),hit);
#endif
}
template <typename DerivedV, int DIM>
template <typename DerivedEle>
IGL_INLINE bool
igl::AABB<DerivedV,DIM>::intersect_ray(
const Eigen::MatrixBase<DerivedV> & V,
const Eigen::MatrixBase<DerivedEle> & Ele,
const RowVectorDIMS & origin,
const RowVectorDIMS & dir,
const Scalar _min_t,
igl::Hit & hit) const
{
//// Naive, slow
//std::vector<igl::Hit> hits;
//intersect_ray(V,Ele,origin,dir,hits);
//if(hits.size() > 0)
//{
// hit = hits.front();
// return true;
//}else
//{
// return false;
//}
Scalar min_t = _min_t;
const Scalar t0 = 0;
{
Scalar _1,_2;
if(!ray_box_intersect(origin,dir,m_box,t0,min_t,_1,_2))
{
return false;
}
}
if(this->is_leaf())
{
// Actually process elements
assert((Ele.size() == 0 || Ele.cols() == 3) && "Elements should be triangles");
// Cheesecake way of hitting element
bool ret = ray_mesh_intersect(origin,dir,V,Ele.row(m_primitive),hit);
hit.id = m_primitive;
return ret;
}
// Doesn't seem like smartly choosing left before/after right makes a
// differnce
igl::Hit left_hit;
igl::Hit right_hit;
bool left_ret = m_left->intersect_ray(V,Ele,origin,dir,min_t,left_hit);
if(left_ret && left_hit.t<min_t)
{
// It's scary that this line doesn't seem to matter....
min_t = left_hit.t;
hit = left_hit;
left_ret = true;
}else
{
left_ret = false;
}
bool right_ret = m_right->intersect_ray(V,Ele,origin,dir,min_t,right_hit);
if(right_ret && right_hit.t<min_t)
{
min_t = right_hit.t;
hit = right_hit;
right_ret = true;
}else
{
right_ret = false;
}
return left_ret || right_ret;
}
// This is a bullshit template because AABB annoyingly needs templates for bad
// combinations of 3D V with DIM=2 AABB
//
// _Define_ as a no-op rather than monkeying around with the proper code above
//
// Meanwhile, GCC seems to have a bug. Let's see if GCC likes using explicit
// namespace block instead. https://stackoverflow.com/a/25594681/148668
namespace igl
{
template<> template<> IGL_INLINE float AABB<Eigen::Matrix<float, -1, 3, 1, -1, 3>, 2>::squared_distance( Eigen::MatrixBase<Eigen::Matrix<float, -1, 3, 1, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> > const&, Eigen::Matrix<float, 1, 2, 1, 1, 2> const&, int&, Eigen::PlainObjectBase<Eigen::Matrix<float, 1, 2, 1, 1, 2> >&) const { assert(false);return -1;};
template<> template<> IGL_INLINE float igl::AABB<Eigen::Matrix<float, -1, 3, 1, -1, 3>, 2>::squared_distance( Eigen::MatrixBase<Eigen::Matrix<float, -1, 3, 1, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> > const&, Eigen::Matrix<float, 1, 2, 1, 1, 2> const&, float, float, int&, Eigen::PlainObjectBase<Eigen::Matrix<float, 1, 2, 1, 1, 2> >&) const { assert(false);return -1;};
template<> template<> IGL_INLINE void igl::AABB<Eigen::Matrix<float, -1, 3, 1, -1, 3>, 2>::init (Eigen::MatrixBase<Eigen::Matrix<float, -1, 3, 1, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> > const&) { assert(false);};
template<> template<> IGL_INLINE double AABB<Eigen::Matrix<double, -1, 3, 1, -1, 3>, 2>::squared_distance( Eigen::MatrixBase<Eigen::Matrix<double, -1, 3, 1, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> > const&, Eigen::Matrix<double, 1, 2, 1, 1, 2> const&, int&, Eigen::PlainObjectBase<Eigen::Matrix<double, 1, 2, 1, 1, 2> >&) const { assert(false);return -1;};
template<> template<> IGL_INLINE double igl::AABB<Eigen::Matrix<double, -1, 3, 1, -1, 3>, 2>::squared_distance( Eigen::MatrixBase<Eigen::Matrix<double, -1, 3, 1, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> > const&, Eigen::Matrix<double, 1, 2, 1, 1, 2> const&, double, double, int&, Eigen::PlainObjectBase<Eigen::Matrix<double, 1, 2, 1, 1, 2> >&) const { assert(false);return -1;};
template<> template<> IGL_INLINE void igl::AABB<Eigen::Matrix<double, -1, 3, 1, -1, 3>, 2>::init (Eigen::MatrixBase<Eigen::Matrix<double, -1, 3, 1, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> > const&) { assert(false);};
template<> template<> IGL_INLINE void igl::AABB<Eigen::Matrix<float, -1, 3, 0, -1, 3>, 2>::init(Eigen::MatrixBase<Eigen::Matrix<float, -1, 3, 0, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&) {assert(false);};
template<> template<> IGL_INLINE float igl::AABB<Eigen::Matrix<float, -1, 3, 0, -1, 3>, 2>::squared_distance(Eigen::MatrixBase<Eigen::Matrix<float, -1, 3, 0, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::Matrix<float, 1, 2, 1, 1, 2> const&, float, float, int&, Eigen::PlainObjectBase<Eigen::Matrix<float, 1, 2, 1, 1, 2> >&) const { assert(false);return -1;};
}
#ifdef IGL_STATIC_LIBRARY
// Explicit template instantiation
// generated by autoexplicit.sh
template double igl::AABB<Eigen::Matrix<double, -1, 3, 1, -1, 3>, 3>::squared_distance<Eigen::Matrix<int, -1, 3, 1, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, 3, 1, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> > const&, Eigen::Matrix<double, 1, 3, 1, 1, 3> const&, double, double, int&, Eigen::PlainObjectBase<Eigen::Matrix<double, 1, 3, 1, 1, 3> >&) const;
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<double, -1, 3, 1, -1, 3>, 3>::init<Eigen::Matrix<int, -1, 3, 1, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, 3, 1, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> > const&);
// generated by autoexplicit.sh
// generated by autoexplicit.sh
template float igl::AABB<Eigen::Matrix<float, -1, 3, 0, -1, 3>, 3>::squared_distance<Eigen::Matrix<int, -1, 3, 0, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<float, -1, 3, 0, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::Matrix<float, 1, 3, 1, 1, 3> const&, float, float, int&, Eigen::PlainObjectBase<Eigen::Matrix<float, 1, 3, 1, 1, 3> >&) const;
// generated by autoexplicit.sh
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<float, -1, 3, 0, -1, 3>, 3>::init<Eigen::Matrix<int, -1, 3, 0, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<float, -1, 3, 0, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&);
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 3>::serialize<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&, int) const;
// generated by autoexplicit.sh
template std::vector<int, std::allocator<int> > igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 3>::find<Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, 1, -1, 1, 1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, 1, -1, 1, 1, -1> > const&, bool) const;
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 2>::serialize<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&, int) const;
// generated by autoexplicit.sh
template std::vector<int, std::allocator<int> > igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 2>::find<Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, 1, -1, 1, 1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, 1, -1, 1, 1, -1> > const&, bool) const;
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 3>::init<Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, int);
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 2>::init<Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, int);
// generated by autoexplicit.sh
template float igl::AABB<Eigen::Matrix<float, -1, 3, 1, -1, 3>, 3>::squared_distance<Eigen::Matrix<int, -1, 3, 1, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<float, -1, 3, 1, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> > const&, Eigen::Matrix<float, 1, 3, 1, 1, 3> const&, int&, Eigen::PlainObjectBase<Eigen::Matrix<float, 1, 3, 1, 1, 3> >&) const;
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 3>::squared_distance<Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&) const;
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 3>::squared_distance<Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<long, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 3, 0, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<long, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> >&) const;
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 3>::squared_distance<Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&) const;
// generated by autoexplicit.sh
template double igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 3>::squared_distance<Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::Matrix<double, 1, 3, 1, 1, 3> const&, int&, Eigen::PlainObjectBase<Eigen::Matrix<double, 1, 3, 1, 1, 3> >&) const;
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 2>::squared_distance<Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&) const;
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 2>::squared_distance<Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<long, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 3, 0, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<long, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> >&) const;
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 2>::squared_distance<Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&) const;
// generated by autoexplicit.sh
template double igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 2>::squared_distance<Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::Matrix<double, 1, 2, 1, 1, 2> const&, int&, Eigen::PlainObjectBase<Eigen::Matrix<double, 1, 2, 1, 1, 2> >&) const;
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<float, -1, 3, 1, -1, 3>, 3>::init<Eigen::Matrix<int, -1, 3, 1, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<float, -1, 3, 1, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> > const&);
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 3>::init<Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&);
// generated by autoexplicit.sh
template void igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 2>::init<Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&);
template double igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 3>::squared_distance<Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::Matrix<double, 1, 3, 1, 1, 3> const&, double, int&, Eigen::PlainObjectBase<Eigen::Matrix<double, 1, 3, 1, 1, 3> >&) const;
template bool igl::AABB<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 3>::intersect_ray<Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::Matrix<double, 1, 3, 1, 1, 3> const&, Eigen::Matrix<double, 1, 3, 1, 1, 3> const&, igl::Hit&) const;
#endif
Reference in a new issue View git blame Copy permalink