TransformationsImpl.cpp
Go to the documentation of this file.
00001 // kate: replace-tabs off; indent-width 4; indent-mode normal
00002 // vim: ts=4:sw=4:noexpandtab
00003 /*
00004 
00005 Copyright (c) 2010--2012,
00006 François Pomerleau and Stephane Magnenat, ASL, ETHZ, Switzerland
00007 You can contact the authors at <f dot pomerleau at gmail dot com> and
00008 <stephane at magnenat dot net>
00009 
00010 All rights reserved.
00011 
00012 Redistribution and use in source and binary forms, with or without
00013 modification, are permitted provided that the following conditions are met:
00014     * Redistributions of source code must retain the above copyright
00015       notice, this list of conditions and the following disclaimer.
00016     * Redistributions in binary form must reproduce the above copyright
00017       notice, this list of conditions and the following disclaimer in the
00018       documentation and/or other materials provided with the distribution.
00019     * Neither the name of the <organization> nor the
00020       names of its contributors may be used to endorse or promote products
00021       derived from this software without specific prior written permission.
00022 
00023 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
00024 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
00025 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00026 DISCLAIMED. IN NO EVENT SHALL ETH-ASL BE LIABLE FOR ANY
00027 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
00028 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
00029 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
00030 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00031 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00032 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00033 
00034 */
00035 
00036 #include "TransformationsImpl.h"
00037 #include "Functions.h"
00038 
00039 #include <iostream>
00040 
00041 using namespace PointMatcherSupport;
00042 
00044 TransformationError::TransformationError(const std::string& reason):
00045         runtime_error(reason)
00046 {}
00047 
00049 template<typename T>
00050 typename PointMatcher<T>::DataPoints TransformationsImpl<T>::RigidTransformation::compute(
00051         const DataPoints& input,
00052         const TransformationParameters& parameters) const
00053 {
00054         //typedef typename PointMatcher<T>::Matrix Matrix;
00055         
00056         assert(input.features.rows() == parameters.rows());
00057         assert(parameters.rows() == parameters.cols());
00058 
00059         const TransformationParameters R(parameters.topLeftCorner(parameters.rows()-1, parameters.cols()-1));
00060 
00061         if(this->checkParameters(parameters) == false)  
00062                 throw TransformationError("RigidTransformation: Error, rotation matrix is not orthogonal.");    
00063         
00064         DataPoints transformedCloud(input.featureLabels, input.descriptorLabels, input.features.cols());
00065         
00066         // Apply the transformation to features
00067         transformedCloud.features = parameters * input.features;
00068         
00069         // Apply the transformation to descriptors
00070         int row(0);
00071         const int descCols(input.descriptors.cols());
00072         for (size_t i = 0; i < input.descriptorLabels.size(); ++i)
00073         {
00074                 const int span(input.descriptorLabels[i].span);
00075                 const std::string& name(input.descriptorLabels[i].text);
00076                 const BOOST_AUTO(inputDesc, input.descriptors.block(row, 0, span, descCols));
00077                 BOOST_AUTO(outputDesc, transformedCloud.descriptors.block(row, 0, span, descCols));
00078                 if (name == "normals" || name == "observationDirections")
00079                         outputDesc = R * inputDesc;
00080                 else
00081                         outputDesc = inputDesc;
00082                 row += span;
00083         }
00084         
00085         return transformedCloud;
00086 }
00087 
00089 template<typename T>
00090 bool TransformationsImpl<T>::RigidTransformation::checkParameters(const TransformationParameters& parameters) const
00091 {
00092         //FIXME: FP - should we put that as function argument?
00093         const T epsilon = 0.001;
00094 
00095         const TransformationParameters R(parameters.topLeftCorner(parameters.rows()-1, parameters.cols()-1));
00096         
00097         if(anyabs(1 - R.determinant()) > epsilon)
00098                 return false;
00099         else
00100                 return true;
00101 }
00102 
00104 template<typename T>
00105 typename PointMatcher<T>::TransformationParameters TransformationsImpl<T>::RigidTransformation::correctParameters(const TransformationParameters& parameters) const
00106 {
00107         TransformationParameters ortho = parameters;
00108         if(ortho.cols() == 4)
00109         {
00110                 const Eigen::Matrix<T, 3, 1> col0 = parameters.block(0, 0, 3, 1).normalized();
00111                 const Eigen::Matrix<T, 3, 1> col1 = parameters.block(0, 1, 3, 1).normalized();
00112                 const Eigen::Matrix<T, 3, 1> col2 = parameters.block(0, 2, 3, 1).normalized();
00113 
00114 
00115                 ortho.block(0, 0, 3, 1) = col1.cross(col2);
00116                 ortho.block(0, 1, 3, 1) = col2.cross(col0);
00117                 ortho.block(0, 2, 3, 1) = col2;
00118         }
00119         else if(ortho.cols() == 3)
00120         {
00121                 // R = [ a b]
00122                 //     [-b a]
00123                 
00124                 // mean of a and b
00125                 T a = (parameters(0,0) + parameters(1,1))/2;    
00126                 T b = (-parameters(1,0) + parameters(0,1))/2;
00127                 T sum = sqrt(pow(a,2) + pow(b,2));
00128 
00129                 a = a/sum;
00130                 b = b/sum;
00131 
00132                 ortho(0,0) =  a; ortho(0,1) = b;
00133                 ortho(1,0) = -b; ortho(1,1) = a;
00134         }
00135 
00136 
00137         return ortho;
00138 }
00139 
00140 template struct TransformationsImpl<float>::RigidTransformation;
00141 template struct TransformationsImpl<double>::RigidTransformation;
00142 
00143 template<typename T>
00144 typename PointMatcher<T>::DataPoints TransformationsImpl<T>::PureTranslation::compute(const DataPoints& input,
00145                 const TransformationParameters& parameters) const {
00146         assert(input.features.rows() == parameters.rows());
00147         assert(parameters.rows() == parameters.cols());
00148 
00149         if(this->checkParameters(parameters) == false)
00150                 throw PointMatcherSupport::TransformationError("PureTranslation: Error, left part  not identity.");
00151 
00152         DataPoints transformedCloud(input.featureLabels, input.descriptorLabels, input.features.cols());
00153 
00154         // Apply the transformation to features
00155         transformedCloud.features = parameters * input.features;
00156 
00157         return transformedCloud;
00158 }
00159 
00160 template<typename T>
00161 typename PointMatcher<T>::TransformationParameters TransformationsImpl<T>::PureTranslation::correctParameters(
00162                 const TransformationParameters& parameters) const {
00163         const int rows = parameters.rows();
00164         const int cols = parameters.cols();
00165 
00166         // make a copy of the parameters to perform corrections on
00167         TransformationParameters correctedParameters(parameters);
00168 
00169         // set the top left block to the identity matrix
00170         correctedParameters.block(0,0,rows-1,cols-1).setIdentity();
00171 
00172         // fix the bottom row
00173         correctedParameters.block(rows-1,0,1,cols-1).setZero();
00174         correctedParameters(rows-1,cols-1) = 1;
00175 
00176         return correctedParameters;
00177 }
00178 
00179 template<typename T>
00180 bool TransformationsImpl<T>::PureTranslation::checkParameters(
00181                 const TransformationParameters& parameters) const {
00182         const int rows = parameters.rows();
00183         const int cols = parameters.cols();
00184 
00185         // make a copy of parameters to perform the check
00186         TransformationParameters parameters_(parameters);
00187 
00188         // set the translation components of the transformation matrix to 0
00189         parameters_.block(0,cols-1,rows-1,1).setZero();
00190 
00191         // If we have the identity matrix, than this is indeed a pure translation
00192         if (parameters_.isApprox(TransformationParameters::Identity(rows,cols)))
00193                 return true;
00194         else
00195                 return false;
00196 }
00197 
00198 template struct TransformationsImpl<float>::PureTranslation;
00199 template struct TransformationsImpl<double>::PureTranslation;


upstream_src
Author(s):
autogenerated on Mon Oct 6 2014 10:27:42