vpBasicKeyPoint.h

/****************************************************************************
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2017 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See http://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * Key point used in matching algorithm.
 *
 * Authors:
 * Nicolas Melchior
 *
 *****************************************************************************/


#ifndef vpBasicKeyPoint_H
#define vpBasicKeyPoint_H

#include <visp3/core/vpColor.h>
#include <visp3/core/vpImage.h>
#include <visp3/core/vpImagePoint.h>
#include <visp3/core/vpRect.h>

#include <vector>


class VISP_EXPORT vpBasicKeyPoint
{
  public:
    vpBasicKeyPoint();

   virtual ~vpBasicKeyPoint() {
    matchedReferencePoints.resize(0);
    currentImagePointsList.resize(0);
    referenceImagePointsList.resize(0);
   };

   virtual unsigned int buildReference(const vpImage<unsigned char> &I) =0;

   virtual unsigned int buildReference(const vpImage<unsigned char> &I,
            const vpImagePoint &iP,
            const unsigned int height, const unsigned int width) =0;

   virtual unsigned int buildReference(const vpImage<unsigned char> &I,
            const vpRect& rectangle) =0;

   virtual unsigned int matchPoint(const vpImage<unsigned char> &I) =0;

   virtual unsigned int matchPoint(const vpImage<unsigned char> &I,
        const vpImagePoint &iP,
        const unsigned int height, const unsigned int width) =0;

   virtual unsigned int matchPoint(const vpImage<unsigned char> &I,
        const vpRect& rectangle) =0;

   virtual void display(const vpImage<unsigned char> &Iref,
                        const vpImage<unsigned char> &Icurrent, unsigned int size=3) =0;

   virtual void display(const vpImage<unsigned char> &Icurrent, unsigned int size=3,
                        const vpColor &color=vpColor::green) =0;

   bool referenceBuilt() const {return _reference_computed;}

   inline const vpImagePoint* getAllPointsInReferenceImage() {
     return &referenceImagePointsList[0];
   } ;

   inline void getReferencePoint (const unsigned int index, vpImagePoint &referencePoint )
   {
     if (index >= referenceImagePointsList.size())
     {
       vpTRACE("Index of the reference point out of range");
       throw(vpException(vpException::fatalError,"Index of the reference point out of range"));
     }

     referencePoint.set_ij(referenceImagePointsList[index].get_i(), referenceImagePointsList[index].get_j());
   }

   inline void getMatchedPoints(const unsigned int index, vpImagePoint &referencePoint, vpImagePoint &currentPoint) {
     if (index >= matchedReferencePoints.size())
     {
       vpTRACE("Index of the matched points out of range");
       throw(vpException(vpException::fatalError,"Index of the matched points out of range"));
     }
     referencePoint.set_ij(referenceImagePointsList[matchedReferencePoints[index]].get_i(),referenceImagePointsList[matchedReferencePoints[index]].get_j());
     currentPoint.set_ij(currentImagePointsList[index].get_i(), currentImagePointsList[index].get_j());
   };

    inline unsigned int getIndexInAllReferencePointList ( const unsigned int indexInMatchedPointList ) {
    if (indexInMatchedPointList >= matchedReferencePoints.size())
    {
      vpTRACE("Index of the matched reference point out of range");
      throw(vpException(vpException::fatalError,"Index of the matched reference point out of range"));
    }
    return matchedReferencePoints[indexInMatchedPointList];
    }

    inline unsigned int getReferencePointNumber() const {return (unsigned int)referenceImagePointsList.size();};

    inline unsigned int getMatchedPointNumber() const {return (unsigned int)matchedReferencePoints.size();};

    const std::vector<vpImagePoint>& getReferenceImagePointsList() const {return referenceImagePointsList;}

    const std::vector<vpImagePoint>& getCurrentImagePointsList() const {return currentImagePointsList;}

    const std::vector<unsigned int>& getMatchedReferencePoints() const {return matchedReferencePoints;}

  private:
    virtual void init()=0;

  protected:
    std::vector<vpImagePoint> referenceImagePointsList;

    std::vector<vpImagePoint> currentImagePointsList;

    std::vector<unsigned int> matchedReferencePoints;

    bool _reference_computed;
};

#endif

/*
 * Local variables:
 * c-basic-offset: 2
 * End:
 */