LSDDetector.h

Go to the documentation of this file.

/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
 //
 //  By downloading, copying, installing or using the software you agree to this license.
 //  If you do not agree to this license, do not download, install,
 //  copy or use the software.
 //
 //
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
 // Copyright (C) 2014, Biagio Montesano, all rights reserved.
 // Third party copyrights are property of their respective owners.
 //
 // Redistribution and use in source and binary forms, with or without modification,
 // are permitted provided that the following conditions are met:
 //
 //   * Redistribution's of source code must retain the above copyright notice,
 //     this list of conditions and the following disclaimer.
 //
 //   * Redistribution's in binary form must reproduce the above copyright notice,
 //     this list of conditions and the following disclaimer in the documentation
 //     and/or other materials provided with the distribution.
 //
 //   * The name of the copyright holders may not be used to endorse or promote products
 //     derived from this software without specific prior written permission.
 //
 // This software is provided by the copyright holders and contributors "as is" and
 // any express or implied warranties, including, but not limited to, the implied
 // warranties of merchantability and fitness for a particular purpose are disclaimed.
 // In no event shall the Intel Corporation or contributors be liable for any direct,
 // indirect, incidental, special, exemplary, or consequential damages
 // (including, but not limited to, procurement of substitute goods or services;
 // loss of use, data, or profits; or business interruption) however caused
 // and on any theory of liability, whether in contract, strict liability,
 // or tort (including negligence or otherwise) arising in any way out of
 // the use of this software, even if advised of the possibility of such damage.
 //
 //M*/

#pragma once

#include <map>
#include <vector>
#include <list>

#if defined _MSC_VER && _MSC_VER <= 1700
#include <stdint.h>
#else
#include <inttypes.h>
#endif

#include <stdio.h>
#include <iostream>

//#include "opencv2/core/utility.hpp"
//#include "opencv2/core/private.hpp"
#include <opencv2/imgproc.hpp>
#include <opencv2/features2d.hpp>
#include <opencv2/core.hpp>

/* define data types */
typedef uint64_t UINT64;
typedef uint32_t UINT32;
typedef uint16_t UINT16;
typedef uint8_t UINT8;

/* define constants */
#define UINT64_1 ((UINT64)0x01)
#define UINT32_1 ((UINT32)0x01)

namespace lsd
{


struct CV_EXPORTS KeyLine
{
 public:
  float angle;

  int class_id;

  int octave;

  cv::Point2f pt;

  float response;

  float size;

  float startPointX;
  float startPointY;
  float endPointX;
  float endPointY;

  float sPointInOctaveX;
  float sPointInOctaveY;
  float ePointInOctaveX;
  float ePointInOctaveY;

  float lineLength;

  int numOfPixels;

  cv::Point2f getStartPoint() const
  {
    return cv::Point2f(startPointX, startPointY);
  }

  cv::Point2f getEndPoint() const
  {
    return cv::Point2f(endPointX, endPointY);
  }

  cv::Point2f getStartPointInOctave() const
  {
    return cv::Point2f(sPointInOctaveX, sPointInOctaveY);
  }

  cv::Point2f getEndPointInOctave() const
  {
    return cv::Point2f(ePointInOctaveX, ePointInOctaveY);
  }

  KeyLine()
  {
  }
};

class CV_EXPORTS LSDDetector : public cv::Algorithm
{
public:

/* constructor */
/*CV_WRAP*/
LSDDetector()
{
}
;

static cv::Ptr<LSDDetector> createLSDDetector();

void detect( const cv::Mat& image, CV_OUT std::vector<KeyLine>& keypoints, int scale, int numOctaves, const cv::Mat& mask = cv::Mat() );

void detect( const std::vector<cv::Mat>& images, std::vector<std::vector<KeyLine> >& keylines, int scale, int numOctaves,
const std::vector<cv::Mat>& masks = std::vector<cv::Mat>() ) const;

private:
/* compute Gaussian pyramid of input image */
void computeGaussianPyramid( const cv::Mat& image, int numOctaves, int scale );

/* implementation of line detection */
void detectImpl( const cv::Mat& imageSrc, std::vector<KeyLine>& keylines, int numOctaves, int scale, const cv::Mat& mask ) const;

/* matrices for Gaussian pyramids */
std::vector<cv::Mat> gaussianPyrs;
};

}