PlanarRansacEstimator.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLGeom/src/ICLGeom/PlanarRansacEstimator.h            **
** Module : ICLGeom                                                **
** Authors: Andre Ueckermann                                       **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.LGPL **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <ICLGeom/GeomDefs.h>
#include <ICLCore/DataSegment.h>
#include <ICLMath/DynMatrix.h>

namespace icl{
  namespace geom{


    class PlanarRansacEstimator{

          public:
            enum Mode {BEST, GPU, CPU};


        PlanarRansacEstimator(Mode mode=BEST);


        ~PlanarRansacEstimator();


        typedef struct{
          int numPoints;//number of destination points
          int countOn;//number of points on the model
          int countAbove;//number of points above the model
          int countBelow;//number of points below the model
          float euclideanThreshold;//selected threshold
          Vec n0;//best model (normal)
          float dist;//best model (distance)
          int tolerance;//tolerance for ON_ONE_SIDE
          int acc;//number of accepted passes for ON_ONE_SIDE (result smaller tolerance)
          int nacc;//number of rejected passes for ON_ONE_SIDE (result bigger tolerance)
          //int maxID;//for assignment of points (all with this id + on plane)
        }Result;


        enum OptimizationCriterion {
          MAX_ON=1,
          ON_ONE_SIDE=2
        };



        Result apply(core::DataSegment<float,4> &xyzh, std::vector<int> &srcIDs, std::vector<int> &dstIDs,
                    float threshold, int passes, int subset, int tolerance, int optimization);



        Result apply(std::vector<Vec> &srcPoints, std::vector<Vec> &dstPoints, float threshold,
                    int passes, int subset, int tolerance, int optimization);



        math::DynMatrix<Result> apply(core::DataSegment<float,4> &xyzh, std::vector<std::vector<int> > &pointIDs,
                    math::DynMatrix<bool> &testMatrix, float threshold, int passes, int tolerance, int optimization, core::Img32s labelImage);



        void relabel(core::DataSegment<float,4> &xyzh, core::Img8u &newMask, core::Img32s &oldLabel, core::Img32s &newLabel,
                     int desiredID, int srcID, float threshold, Result &result);



        static void calculateRandomModels(std::vector<Vec> &srcPoints, std::vector<Vec> &n0, std::vector<float> &dist, int passes);



        static void calculateRandomModels(core::DataSegment<float,4> &xyzh, std::vector<int> &srcPoints, std::vector<Vec> &n0, std::vector<float> &dist, int passes);

      private:

        struct Data;  
        Data *m_data; 

        void calculateMultiCL(core::DataSegment<float,4> &xyzh, core::Img32s labelImage, math::DynMatrix<bool> &testMatrix, float threshold, int passes,
                    std::vector<Vec> &n0, std::vector<float> &dist, std::vector<int> &cAbove, std::vector<int> &cBelow, std::vector<int> &cOn,
                    std::vector<int> &adjs, std::vector<int> &start, std::vector<int> &end);

        void calculateMultiCPU(core::DataSegment<float,4> &xyzh, std::vector<std::vector<int> > &pointIDs, math::DynMatrix<bool> &testMatrix,
                    float threshold, int passes, std::vector<std::vector<Vec> > &n0Pre, std::vector<std::vector<float> > &distPre, std::vector<int> &cAbove,
                    std::vector<int> &cBelow, std::vector<int> &cOn, std::vector<int> &adjs, std::vector<int> &start, std::vector<int> &end);

        void calculateSingleCL(std::vector<Vec> &dstPoints, float threshold, int passes, int subset,
                    std::vector<Vec> &n0, std::vector<float> &dist, std::vector<int> &cAbove, std::vector<int> &cBelow, std::vector<int> &cOn);

        void calculateSingleCPU(std::vector<Vec> &dstPoints, float threshold, int passes, int subset,
                    std::vector<Vec> &n0, std::vector<float> &dist, std::vector<int> &cAbove, std::vector<int> &cBelow, std::vector<int> &cOn);

        void initOpenCL();

        Result createResult(std::vector<Vec> &n0, std::vector<float> &dist, std::vector<int> &cAbove, std::vector<int> &cBelow, std::vector<int> &cOn,
                float threshold, int passes, int tolerance, int optimization, int numPoints);

        math::DynMatrix<Result> createResultMatrix(math::DynMatrix<bool> &testMatrix, std::vector<int> &start, std::vector<int> &end, std::vector<int> &adjs,
                   std::vector<int> &cAbove, std::vector<int> &cBelow, std::vector<int> &cOn, std::vector<std::vector<int> > &pointIDs,
                   std::vector<std::vector<Vec> > &n0Pre, std::vector<std::vector<float> > &distPre, float threshold, int passes, int tolerance, int optimization);

        static void calculateModel(Vec &fa, Vec &fb, Vec &rPoint, Vec &n0, float &dist);

        void relabelCL(core::DataSegment<float,4> &xyzh, core::Img8u &newMask, core::Img32s &oldLabel, core::Img32s &newLabel,
                     int desiredID, int srcID, float threshold, Result &result, int w, int h);

        void relabelCPU(core::DataSegment<float,4> &xyzh, core::Img8u &newMask, core::Img32s &oldLabel, core::Img32s &newLabel,
                     int desiredID, int srcID, float threshold, Result &result, int w, int h);

    };

  } // namespace geom
}