void Reflection::resetFlip()
{
for (int j = 0; j < millerCount(); j++)
{
miller(j)->setFlipMatrix(MatrixPtr(new Matrix()));
}
}
template <typename PointT, typename FlannDistance> void
pcl::search::FlannSearch<PointT, FlannDistance>::convertInputToFlannMatrix ()
{
size_t original_no_of_points = indices_ && !indices_->empty () ? indices_->size () : input_->size ();
if (input_copied_for_flann_)
delete input_flann_->ptr();
input_copied_for_flann_ = true;
index_mapping_.clear();
identity_mapping_ = true;
//cloud_ = (float*)malloc (original_no_of_points * dim_ * sizeof (float));
//index_mapping_.reserve(original_no_of_points);
//identity_mapping_ = true;
if (!indices_ || indices_->empty ())
{
// best case: all points can be passed to flann without any conversions
if (input_->is_dense && point_representation_->isTrivial ())
{
// const cast is evil, but flann won't change the data
input_flann_ = MatrixPtr (new flann::Matrix<float> (const_cast<float*>(reinterpret_cast<const float*>(&(*input_) [0])), original_no_of_points, point_representation_->getNumberOfDimensions (),sizeof (PointT)));
input_copied_for_flann_ = false;
}
else
{
input_flann_ = MatrixPtr (new flann::Matrix<float> (new float[original_no_of_points*point_representation_->getNumberOfDimensions ()], original_no_of_points, point_representation_->getNumberOfDimensions ()));
float* cloud_ptr = input_flann_->ptr();
for (size_t i = 0; i < original_no_of_points; ++i)
{
const PointT& point = (*input_)[i];
// Check if the point is invalid
if (!point_representation_->isValid (point))
{
identity_mapping_ = false;
continue;
}
index_mapping_.push_back (static_cast<int> (i)); // If the returned index should be for the indices vector
point_representation_->vectorize (point, cloud_ptr);
cloud_ptr += dim_;
}
}
}
else
{
input_flann_ = MatrixPtr (new flann::Matrix<float> (new float[original_no_of_points*point_representation_->getNumberOfDimensions ()], original_no_of_points, point_representation_->getNumberOfDimensions ()));
float* cloud_ptr = input_flann_->ptr();
for (size_t indices_index = 0; indices_index < original_no_of_points; ++indices_index)
{
int cloud_index = (*indices_)[indices_index];
const PointT& point = (*input_)[cloud_index];
// Check if the point is invalid
if (!point_representation_->isValid (point))
{
identity_mapping_ = false;
continue;
}
index_mapping_.push_back (static_cast<int> (indices_index)); // If the returned index should be for the indices vector
point_representation_->vectorize (point, cloud_ptr);
cloud_ptr += dim_;
}
}
if (input_copied_for_flann_)
input_flann_->rows = index_mapping_.size ();
}
void SwapBuffer::swap()
{
current_ = next_;
next_ = MatrixPtr();
}
/**
Hard-coding the matrix ambiguities for various twinnable space groups.
*/
MatrixPtr Reflection::matrixForAmbiguity(int i)
{
if (i >= ambiguityCount())
std::cout << "Ambiguity issue!" << std::endl;
if (i == 0)
{
MatrixPtr identity = MatrixPtr(new Matrix());
return identity;
}
if (i == 1)
{
if (ambiguityCount() == 2 || ambiguityCount() == 4)
{
MatrixPtr khMinusL = MatrixPtr(new Matrix());
(*khMinusL)[0] = 0;
(*khMinusL)[4] = 1;
(*khMinusL)[1] = 1;
(*khMinusL)[5] = 0;
(*khMinusL)[10] = -1;
return khMinusL;
}
if (ambiguityCount() == 3)
{
// return -h -k -l
MatrixPtr minusHminusKL = MatrixPtr(new Matrix());
(*minusHminusKL)[0] = -1;
(*minusHminusKL)[5] = -1;
(*minusHminusKL)[10] = 1;
return minusHminusKL;
}
}
if (i == 2)
{
if (ambiguityCount() == 3)
{
if (spgNum == 149 || spgNum == 151 || spgNum == 153)
{
// return k h -l
MatrixPtr khMinusL = MatrixPtr(new Matrix());
(*khMinusL)[0] = 0;
(*khMinusL)[4] = 1;
(*khMinusL)[1] = 1;
(*khMinusL)[5] = 0;
(*khMinusL)[10] = -1;
return khMinusL;
}
if (spgNum == 152 || spgNum == 152 || spgNum == 154)
{
// return -k -h -l
MatrixPtr minusAllHKL = MatrixPtr(new Matrix());
(*minusAllHKL)[0] = -1;
(*minusAllHKL)[5] = -1;
(*minusAllHKL)[10] = -1;
return minusAllHKL;
}
}
if (ambiguityCount() == 4)
{
// return k h -l
MatrixPtr khMinusL = MatrixPtr(new Matrix());
(*khMinusL)[0] = 0;
(*khMinusL)[4] = 1;
(*khMinusL)[1] = 1;
(*khMinusL)[5] = 0;
(*khMinusL)[10] = -1;
return khMinusL;
}
}
if (i == 3)
{
if (ambiguityCount() == 4)
{
// return -k -h -l
MatrixPtr minusAllHKL = MatrixPtr(new Matrix());
(*minusAllHKL)[0] = -1;
(*minusAllHKL)[5] = -1;
(*minusAllHKL)[10] = -1;
return minusAllHKL;
}
}
return MatrixPtr(new Matrix());
}
