Skip to content

O
opencv_contrib
Commit d79ae76a authored by biagio montesano's avatar biagio montesano
Browse files
Options

Some compilation-time problems corrected

parent 523c6782
Hide whitespace changes
Inline Side-by-side
Showing with 761 additions and 308 deletions
modules/line_descriptor/.cproject 0 → 100644
View file @ d79ae76a
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?fileVersion 4.0.0?><cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage">
<storageModule moduleId="org.eclipse.cdt.core.settings">
<cconfiguration id="0.981004926">
<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="0.981004926" moduleId="org.eclipse.cdt.core.settings" name="Default">
<externalSettings/>
<extensions>
<extension id="org.eclipse.cdt.core.VCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="org.eclipse.cdt.core.CWDLocator" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="org.eclipse.cdt.core.GCCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="org.eclipse.cdt.core.GASErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
<extension id="org.eclipse.cdt.core.GLDErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
</extensions>
</storageModule>
<storageModule moduleId="cdtBuildSystem" version="4.0.0">
<configuration buildProperties="" description="" id="0.981004926" name="Default" parent="org.eclipse.cdt.build.core.prefbase.cfg">
<folderInfo id="0.981004926." name="/" resourcePath="">
<toolChain id="org.eclipse.cdt.build.core.prefbase.toolchain.133438668" name="No ToolChain" resourceTypeBasedDiscovery="false" superClass="org.eclipse.cdt.build.core.prefbase.toolchain">
<targetPlatform id="org.eclipse.cdt.build.core.prefbase.toolchain.133438668.560317043" name=""/>
<builder id="org.eclipse.cdt.build.core.settings.default.builder.879389161" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" superClass="org.eclipse.cdt.build.core.settings.default.builder"/>
<tool id="org.eclipse.cdt.build.core.settings.holder.libs.727822257" name="holder for library settings" superClass="org.eclipse.cdt.build.core.settings.holder.libs"/>
<tool id="org.eclipse.cdt.build.core.settings.holder.824167162" name="Assembly" superClass="org.eclipse.cdt.build.core.settings.holder">
<inputType id="org.eclipse.cdt.build.core.settings.holder.inType.571007942" languageId="org.eclipse.cdt.core.assembly" languageName="Assembly" sourceContentType="org.eclipse.cdt.core.asmSource" superClass="org.eclipse.cdt.build.core.settings.holder.inType"/>
</tool>
<tool id="org.eclipse.cdt.build.core.settings.holder.1055483124" name="GNU C++" superClass="org.eclipse.cdt.build.core.settings.holder">
<inputType id="org.eclipse.cdt.build.core.settings.holder.inType.638366895" languageId="org.eclipse.cdt.core.g++" languageName="GNU C++" sourceContentType="org.eclipse.cdt.core.cxxSource,org.eclipse.cdt.core.cxxHeader" superClass="org.eclipse.cdt.build.core.settings.holder.inType"/>
</tool>
<tool id="org.eclipse.cdt.build.core.settings.holder.474752807" name="GNU C" superClass="org.eclipse.cdt.build.core.settings.holder">
<inputType id="org.eclipse.cdt.build.core.settings.holder.inType.1579703533" languageId="org.eclipse.cdt.core.gcc" languageName="GNU C" sourceContentType="org.eclipse.cdt.core.cSource,org.eclipse.cdt.core.cHeader" superClass="org.eclipse.cdt.build.core.settings.holder.inType"/>
</tool>
</toolChain>
</folderInfo>
</configuration>
</storageModule>
<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
</cconfiguration>
</storageModule>
<storageModule moduleId="cdtBuildSystem" version="4.0.0">
<project id="line_descriptor.null.1096558411" name="line_descriptor"/>
</storageModule>
<storageModule moduleId="scannerConfiguration">
<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
<scannerConfigBuildInfo instanceId="0.981004926">
<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
</scannerConfigBuildInfo>
</storageModule>
<storageModule moduleId="org.eclipse.cdt.core.LanguageSettingsProviders"/>
</cproject>
modules/line_descriptor/.project 0 → 100644
View file @ d79ae76a
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>line_descriptor</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
<triggers>clean,full,incremental,</triggers>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
<triggers>full,incremental,</triggers>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.cdt.core.cnature</nature>
<nature>org.eclipse.cdt.core.ccnature</nature>
<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
</natures>
</projectDescription>
modules/line_descriptor/CMakeLists.txt
View file @ d79ae76a
set(the_description "Line descriptor") set(the_description "Line descriptor")
ocv_define_module(line_descriptor) ocv_define_module(line_descriptor opencv_imgproc opencv_optim)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${BIAS_CXX_FLAGS} -std=c++0x")
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${BIAS_C_FLAGS}")
modules/line_descriptor/CMakeLists.txt~ 0 → 100644
View file @ d79ae76a
set(the_description "Line descriptor")
ocv_define_module(line_descriptor opencv_imgproc opencv_optim)
modules/line_descriptor/include/opencv2/line_descriptor/EDLineDetector.hh → modules/line_descriptor/include/opencv2/line_descriptor/EDLineDetector.hpp
View file @ d79ae76a
...@@ -44,11 +44,16 @@ the use of this software, even if advised of the possibility of such damage. ...@@ -44,11 +44,16 @@ the use of this software, even if advised of the possibility of such damage.
#include <iostream> #include <iostream>
#include <list> #include <list>
#include <opencv2/core.hpp> #include <opencv2/core.hpp>
#include <opencv2/features2d/features2d.hpp> //#include <opencv2/features2d/features2d.hpp>
#include <opencv2/imgproc/imgproc.hpp> #include <opencv2/features2d.hpp>
#include <opencv2/highgui/highgui.hpp> //#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/imgproc.hpp>
//#include <opencv2/highgui/highgui.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/core/utility.hpp> #include <opencv2/core/utility.hpp>
#include <array> #include <array>
#include <sstream>
struct Pixel{ struct Pixel{
...@@ -94,6 +99,7 @@ inline void writeMat(cv::Mat m, std::string name, int n) ...@@ -94,6 +99,7 @@ inline void writeMat(cv::Mat m, std::string name, int n)
ss >> s; ss >> s;
std::string fileNameConf = name + s; std::string fileNameConf = name + s;
cv::FileStorage fsConf(fileNameConf, cv::FileStorage::WRITE); cv::FileStorage fsConf(fileNameConf, cv::FileStorage::WRITE);
cv::FileStorage fsConf();
fsConf << "m" << m; fsConf << "m" << m;
fsConf.release(); fsConf.release();
......
modules/line_descriptor/include/opencv2/line_descriptor/LineDescriptor.hh → modules/line_descriptor/include/opencv2/line_descriptor/LineDescriptor.hpp
View file @ d79ae76a
...@@ -41,11 +41,20 @@ the use of this software, even if advised of the possibility of such damage. ...@@ -41,11 +41,20 @@ the use of this software, even if advised of the possibility of such damage.
#define LINEDESCRIPTOR_HH_ #define LINEDESCRIPTOR_HH_
#include "EDLineDetector.hh" //#include "EDLineDetector.hh"
#include "LineStructure.hh" //#include "LineStructure.hh"
//#include "/include/opencv2/line_descriptor/EDLineDetector.hpp"
//#include "opencv2/line_descriptor/LineStructure.hpp"
//#include "opencv2/EDLineDetector.hpp"
//#include "opencv2/LineStructure.hpp"
#include "precomp.hpp"
#include <vector>
#include <map> #include <map>
struct OctaveLine{ struct OctaveLine{
unsigned int octaveCount;//the octave which this line is detected unsigned int octaveCount;//the octave which this line is detected
unsigned int lineIDInOctave;//the line ID in that octave image unsigned int lineIDInOctave;//the line ID in that octave image
...@@ -65,16 +74,15 @@ public: ...@@ -65,16 +74,15 @@ public:
NearestNeighbor=0, //the nearest neighbor is taken as matching NearestNeighbor=0, //the nearest neighbor is taken as matching
NNDR=1//nearest/next ratio NNDR=1//nearest/next ratio
}; };
/*This function is used to detect lines from multi-scale images.*/ /*This function is used to detect lines from multi-scale images.*/
int OctaveKeyLines(cv::Mat & image, ScaleLines &keyLines); int OctaveKeyLines(cv::Mat & image, ScaleLines &keyLines);
int GetLineDescriptor(cv::Mat & image, int GetLineDescriptor(cv::Mat & image, ScaleLines &keyLines);
ScaleLines &keyLines); int GetLineDescriptor(std::vector<cv::Mat> &scale_images, ScaleLines &keyLines);
int GetLineDescriptor(cv::Mat & image,
ScaleLines &keyLines, bool lsd);
void findNearestParallelLines(ScaleLines & keyLines); void findNearestParallelLines(ScaleLines & keyLines);
void GetLineBinaryDescriptor(std::vector<cv::Mat> & oct_binaryDescMat, ScaleLines & keyLines); void GetLineBinaryDescriptor(std::vector<cv::Mat> & oct_binaryDescMat, ScaleLines &keyLines);
int MatchLineByDescriptor(ScaleLines &keyLinesLeft, ScaleLines &keyLinesRight, int MatchLineByDescriptor(ScaleLines &keyLinesLeft, ScaleLines &keyLinesRight,
std::vector<short> &matchLeft, std::vector<short> &matchRight, std::vector<short> &matchLeft, std::vector<short> &matchRight,
int criteria=NNDR); int criteria=NNDR);
...@@ -120,7 +128,7 @@ private: ...@@ -120,7 +128,7 @@ private:
*from the EDLineDetector class without extra computation cost. Another reason is that, if we use *from the EDLineDetector class without extra computation cost. Another reason is that, if we use
*a single EDLineDetector to detect lines in different octave of images, then we need to allocate and release *a single EDLineDetector to detect lines in different octave of images, then we need to allocate and release
*memory for gradient images (dxImg, dyImg, gImg) repeatedly for their varying size*/ *memory for gradient images (dxImg, dyImg, gImg) repeatedly for their varying size*/
std::vector<EDLineDetector*> edLineVec_; std::vector<EDLineDetector*> edLineVec_;
}; };
......
modules/line_descriptor/include/opencv2/line_descriptor/LineStructure.hh → modules/line_descriptor/include/opencv2/line_descriptor/LineStructure.hpp
View file @ d79ae76a
...@@ -41,6 +41,7 @@ the use of this software, even if advised of the possibility of such damage. ...@@ -41,6 +41,7 @@ the use of this software, even if advised of the possibility of such damage.
#define LINESTRUCTURE_HH_ #define LINESTRUCTURE_HH_
#include <vector> #include <vector>
// A 2D line (normal equation parameters). // A 2D line (normal equation parameters).
struct SingleLine struct SingleLine
{ {
......
modules/line_descriptor/include/opencv2/line_descriptor/line_detector.hpp 0 → 100644
View file @ d79ae76a
/*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) 2013, OpenCV Foundation, 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*/
#ifdef __OPENCV_BUILD
#error this is a compatibility header which should not be used inside the OpenCV library
#endif
#include "opencv2/line_descriptor.hpp"
modules/line_descriptor/include/opencv2/line_descriptor/tracking.hpp~ 0 → 100644
View file @ d79ae76a
/*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) 2013, OpenCV Foundation, 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*/
#ifdef __OPENCV_BUILD
#error this is a compatibility header which should not be used inside the OpenCV library
#endif
#include "opencv2/tracking.hpp"
modules/line_descriptor/include/opencv2/line_detector.hpp 0 → 100644
View file @ d79ae76a
/*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) 2013, OpenCV Foundation, 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*/
#ifndef __OPENCV_TRACKING_HPP__
#define __OPENCV_TRACKING_HPP__
#include "opencv2/line_descriptor/line_descriptor.hpp"
namespace cv
{
CV_EXPORTS bool initModule_line_descriptor(void);
}
#endif //__OPENCV_TRACKING_HPP__
modules/line_descriptor/include/opencv2/tracking.hpp~ 0 → 100644
View file @ d79ae76a
/*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) 2013, OpenCV Foundation, 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*/
#ifndef __OPENCV_TRACKING_HPP__
#define __OPENCV_TRACKING_HPP__
#include "opencv2/tracking/tracker.hpp"
namespace cv
{
CV_EXPORTS bool initModule_tracking(void);
}
#endif //__OPENCV_TRACKING_HPP__
modules/line_descriptor/src/EDLineDetector.cpp
View file @ d79ae76a
...@@ -38,7 +38,10 @@ the use of this software, even if advised of the possibility of such damage. ...@@ -38,7 +38,10 @@ the use of this software, even if advised of the possibility of such damage.
*/ */
#include "../include/EDLineDetector.hh" //#include "/include/opencv2/line_descriptor/EDLineDetector.hpp"
//#include "opencv2/EDLineDetector.hpp"
#include "precomp.hpp"
#define Horizontal 255//if |dx|<|dy|; #define Horizontal 255//if |dx|<|dy|;
#define Vertical 0//if |dy|<=|dx|; #define Vertical 0//if |dy|<=|dx|;
......
modules/line_descriptor/src/LineDescriptor.cpp
View file @ d79ae76a
...@@ -37,7 +37,10 @@ or tort (including negligence or otherwise) arising in any way out of ...@@ -37,7 +37,10 @@ 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. the use of this software, even if advised of the possibility of such damage.
*/ */
#include "../include/LineDescriptor.hh" //#include "/include/opencv2/line_descriptor/LineDescriptor.hpp"
//#include "opencv2/LineDescriptor.hpp"
#include "precomp.hpp"
#define SalienceScale 0.9//0.9 #define SalienceScale 0.9//0.9
...@@ -86,10 +89,10 @@ LineDescriptor::LineDescriptor(int n_octave) ...@@ -86,10 +89,10 @@ LineDescriptor::LineDescriptor(int n_octave)
numOfOctave_ = n_octave;//5 numOfOctave_ = n_octave;//5
/* create as many LineVecs as the number of octaves */ /* create as many LineVecs as the number of octaves */
edLineVec_.resize(numOfOctave_); edLineVec_.resize(numOfOctave_);
for(unsigned int i=0; i<numOfOctave_; i++){ for(unsigned int i=0; i<numOfOctave_; i++){
edLineVec_[i] = new EDLineDetector; edLineVec_[i] = new EDLineDetector;
} }
/* set number of bands */ /* set number of bands */
numOfBand_ = 9; // suggested by authors numOfBand_ = 9; // suggested by authors
...@@ -148,10 +151,10 @@ LineDescriptor::LineDescriptor(unsigned int numOfBand, unsigned int widthOfBand, ...@@ -148,10 +151,10 @@ LineDescriptor::LineDescriptor(unsigned int numOfBand, unsigned int widthOfBand,
numOfOctave_ = n_octave; numOfOctave_ = n_octave;
/* create as many LineVecs as the number of octaves */ /* create as many LineVecs as the number of octaves */
edLineVec_.resize(numOfOctave_); edLineVec_.resize(numOfOctave_);
for(unsigned int i=0; i<numOfOctave_; i++){ for(unsigned int i=0; i<numOfOctave_; i++){
edLineVec_[i] = new EDLineDetector; edLineVec_[i] = new EDLineDetector;
} }
/* set number of bands */ /* set number of bands */
numOfBand_ = numOfBand; numOfBand_ = numOfBand;
...@@ -200,11 +203,11 @@ LineDescriptor::LineDescriptor(unsigned int numOfBand, unsigned int widthOfBand, ...@@ -200,11 +203,11 @@ LineDescriptor::LineDescriptor(unsigned int numOfBand, unsigned int widthOfBand,
/* destructor */ /* destructor */
LineDescriptor::~LineDescriptor(){ LineDescriptor::~LineDescriptor(){
for(unsigned int i=0; i<numOfOctave_; i++){ // for(unsigned int i=0; i<numOfOctave_; i++){
if(edLineVec_[i] !=NULL){ // if(edLineVec_[i] !=NULL){
delete edLineVec_[i]; // delete edLineVec_[i];
} // }
} // }
} }
/*Line detection method: element in keyLines[i] includes a set of lines which is the same line /*Line detection method: element in keyLines[i] includes a set of lines which is the same line
...@@ -214,7 +217,7 @@ int LineDescriptor::OctaveKeyLines(cv::Mat & image, ScaleLines &keyLines) ...@@ -214,7 +217,7 @@ int LineDescriptor::OctaveKeyLines(cv::Mat & image, ScaleLines &keyLines)
{ {
/* final number of extracted lines */ /* final number of extracted lines */
unsigned int numOfFinalLine = 0; unsigned int numOfFinalLine = 0;
/* sigma values and reduction factor used in Gaussian pyramids */ /* sigma values and reduction factor used in Gaussian pyramids */
float preSigma2 = 0; //orignal image is not blurred, has zero sigma; float preSigma2 = 0; //orignal image is not blurred, has zero sigma;
...@@ -222,33 +225,33 @@ int LineDescriptor::OctaveKeyLines(cv::Mat & image, ScaleLines &keyLines) ...@@ -222,33 +225,33 @@ int LineDescriptor::OctaveKeyLines(cv::Mat & image, ScaleLines &keyLines)
float factor = sqrt(2); //the down sample factor between connective two octave images float factor = sqrt(2); //the down sample factor between connective two octave images
/* loop over number of octaves */ /* loop over number of octaves */
for(unsigned int octaveCount = 0; octaveCount<numOfOctave_; octaveCount++){ for(unsigned int octaveCount = 0; octaveCount<numOfOctave_; octaveCount++){
/* matrix storing results from blurring processes */ /* matrix storing results from blurring processes */
cv::Mat blur; cv::Mat blur;
/* Compute sigma value for Gaussian filter for each level by adding incremental blur from previous level. /* Compute sigma value for Gaussian filter for each level by adding incremental blur from previous level.
* curSigma = [sqrt(2)]^octaveCount; * curSigma = [sqrt(2)]^octaveCount;
* increaseSigma^2 = curSigma^2 - preSigma^2 */ * increaseSigma^2 = curSigma^2 - preSigma^2 */
float increaseSigma = sqrt(curSigma2-preSigma2); float increaseSigma = sqrt(curSigma2-preSigma2);
/* apply Gaussian blur */ /* apply Gaussian blur */
cv::GaussianBlur(image, blur, cv::Size(ksize_,ksize_), increaseSigma); cv::GaussianBlur(image, blur, cv::Size(ksize_,ksize_), increaseSigma);
/* for current octave, extract lines */ /* for current octave, extract lines */
if((edLineVec_[octaveCount]->EDline(blur,true))!= true){ if((edLineVec_[octaveCount]->EDline(blur,true))!= true){
return -1; return -1;
} }
/* update number of total extracted lines */ /* update number of total extracted lines */
numOfFinalLine += edLineVec_[octaveCount]->lines_.numOfLines; numOfFinalLine += edLineVec_[octaveCount]->lines_.numOfLines;
/* resize image for next level of pyramid */ /* resize image for next level of pyramid */
cv::resize(blur, image, cv::Size(), (1.f/factor), (1.f/factor)); cv::resize(blur, image, cv::Size(), (1.f/factor), (1.f/factor));
/* update sigma values */ /* update sigma values */
preSigma2 = curSigma2; preSigma2 = curSigma2;
curSigma2 = curSigma2*2; curSigma2 = curSigma2*2;
} /* end of loop over number of octaves */ } /* end of loop over number of octaves */
...@@ -266,7 +269,7 @@ int LineDescriptor::OctaveKeyLines(cv::Mat & image, ScaleLines &keyLines) ...@@ -266,7 +269,7 @@ int LineDescriptor::OctaveKeyLines(cv::Mat & image, ScaleLines &keyLines)
unsigned int lineIDInScaleLineVec = 0; unsigned int lineIDInScaleLineVec = 0;
/* floats to compute lines' lengths */ /* floats to compute lines' lengths */
float dx, dy; float dx, dy;
/* loop over lines extracted from scale 0 (original image) */ /* loop over lines extracted from scale 0 (original image) */
for(unsigned int lineCurId=0;lineCurId<edLineVec_[0]->lines_.numOfLines;lineCurId++){ for(unsigned int lineCurId=0;lineCurId<edLineVec_[0]->lines_.numOfLines;lineCurId++){
...@@ -275,253 +278,253 @@ int LineDescriptor::OctaveKeyLines(cv::Mat & image, ScaleLines &keyLines) ...@@ -275,253 +278,253 @@ int LineDescriptor::OctaveKeyLines(cv::Mat & image, ScaleLines &keyLines)
/* set octave from which it was extracted */ /* set octave from which it was extracted */
octaveLines[numOfFinalLine].octaveCount = 0; octaveLines[numOfFinalLine].octaveCount = 0;
/* set ID within its octave */ /* set ID within its octave */
octaveLines[numOfFinalLine].lineIDInOctave = lineCurId; octaveLines[numOfFinalLine].lineIDInOctave = lineCurId;
/* set a unique ID among all lines extracted in all octaves */ /* set a unique ID among all lines extracted in all octaves */
octaveLines[numOfFinalLine].lineIDInScaleLineVec = lineIDInScaleLineVec; octaveLines[numOfFinalLine].lineIDInScaleLineVec = lineIDInScaleLineVec;
/* compute absolute value of difference between X coordinates of line's extreme points */ /* compute absolute value of difference between X coordinates of line's extreme points */
dx = fabs(edLineVec_[0]->lineEndpoints_[lineCurId][0]-edLineVec_[0]->lineEndpoints_[lineCurId][2]); dx = fabs(edLineVec_[0]->lineEndpoints_[lineCurId][0]-edLineVec_[0]->lineEndpoints_[lineCurId][2]);
/* compute absolute value of difference between Y coordinates of line's extreme points */ /* compute absolute value of difference between Y coordinates of line's extreme points */
dy = fabs(edLineVec_[0]->lineEndpoints_[lineCurId][1]-edLineVec_[0]->lineEndpoints_[lineCurId][3]); dy = fabs(edLineVec_[0]->lineEndpoints_[lineCurId][1]-edLineVec_[0]->lineEndpoints_[lineCurId][3]);
/* compute line's length */ /* compute line's length */
octaveLines[numOfFinalLine].lineLength = sqrt(dx*dx+dy*dy); octaveLines[numOfFinalLine].lineLength = sqrt(dx*dx+dy*dy);
/* update counters */ /* update counters */
numOfFinalLine++; numOfFinalLine++;
lineIDInScaleLineVec++; lineIDInScaleLineVec++;
} }
/* create and fill an array to store scale factors */ /* create and fill an array to store scale factors */
float *scale = new float[numOfOctave_]; float *scale = new float[numOfOctave_];
scale[0] = 1; scale[0] = 1;
for(unsigned int octaveCount = 1; octaveCount<numOfOctave_; octaveCount++ ){ for(unsigned int octaveCount = 1; octaveCount<numOfOctave_; octaveCount++ ){
scale[octaveCount] = factor * scale[octaveCount-1]; scale[octaveCount] = factor * scale[octaveCount-1];
} }
/* some variables' declarations */ /* some variables' declarations */
float rho1, rho2, tempValue; float rho1, rho2, tempValue;
float direction, near, length; float direction, near, length;
unsigned int octaveID, lineIDInOctave; unsigned int octaveID, lineIDInOctave;
/*more than one octave image, organize lines in scale space. /*more than one octave image, organize lines in scale space.
*lines corresponding to the same line in octave images should have the same index in the ScaleLineVec */ *lines corresponding to the same line in octave images should have the same index in the ScaleLineVec */
if(numOfOctave_>1){ if(numOfOctave_>1){
/* some other variables' declarations */ /* some other variables' declarations */
float twoPI = 2*M_PI; float twoPI = 2*M_PI;
unsigned int closeLineID; unsigned int closeLineID;
float endPointDis,minEndPointDis,minLocalDis,maxLocalDis; float endPointDis,minEndPointDis,minLocalDis,maxLocalDis;
float lp0,lp1, lp2, lp3, np0,np1, np2, np3; float lp0,lp1, lp2, lp3, np0,np1, np2, np3;
/* loop over list of octaves */ /* loop over list of octaves */
for(unsigned int octaveCount = 1; octaveCount<numOfOctave_; octaveCount++){ for(unsigned int octaveCount = 1; octaveCount<numOfOctave_; octaveCount++){
/*for each line in current octave image, find their corresponding lines in the octaveLines, /*for each line in current octave image, find their corresponding lines in the octaveLines,
*give them the same value of lineIDInScaleLineVec*/ *give them the same value of lineIDInScaleLineVec*/
/* loop over list of lines extracted from current octave */ /* loop over list of lines extracted from current octave */
for(unsigned int lineCurId=0;lineCurId<edLineVec_[octaveCount]->lines_.numOfLines;lineCurId++){ for(unsigned int lineCurId=0;lineCurId<edLineVec_[octaveCount]->lines_.numOfLines;lineCurId++){
/* get (scaled) known term from equation of current line */ /* get (scaled) known term from equation of current line */
rho1 = scale[octaveCount] * fabs(edLineVec_[octaveCount]->lineEquations_[lineCurId][2]); rho1 = scale[octaveCount] * fabs(edLineVec_[octaveCount]->lineEquations_[lineCurId][2]);
/*nearThreshold depends on the distance of the image coordinate origin to current line. /*nearThreshold depends on the distance of the image coordinate origin to current line.
*so nearThreshold = rho1 * nearThresholdRatio, where nearThresholdRatio = 1-cos(10*pi/180) = 0.0152*/ *so nearThreshold = rho1 * nearThresholdRatio, where nearThresholdRatio = 1-cos(10*pi/180) = 0.0152*/
tempValue = rho1 * 0.0152; tempValue = rho1 * 0.0152;
float nearThreshold = (tempValue>6)?(tempValue):6; float nearThreshold = (tempValue>6)?(tempValue):6;
nearThreshold = (nearThreshold<12)?nearThreshold:12; nearThreshold = (nearThreshold<12)?nearThreshold:12;
/* compute scaled lenght of current line */ /* compute scaled lenght of current line */
dx = fabs(edLineVec_[octaveCount]->lineEndpoints_[lineCurId][0]-edLineVec_[octaveCount]->lineEndpoints_[lineCurId][2]);//x1-x2 dx = fabs(edLineVec_[octaveCount]->lineEndpoints_[lineCurId][0]-edLineVec_[octaveCount]->lineEndpoints_[lineCurId][2]);//x1-x2
dy = fabs(edLineVec_[octaveCount]->lineEndpoints_[lineCurId][1]-edLineVec_[octaveCount]->lineEndpoints_[lineCurId][3]);//y1-y2 dy = fabs(edLineVec_[octaveCount]->lineEndpoints_[lineCurId][1]-edLineVec_[octaveCount]->lineEndpoints_[lineCurId][3]);//y1-y2
length = scale[octaveCount] * sqrt(dx*dx+dy*dy); length = scale[octaveCount] * sqrt(dx*dx+dy*dy);
minEndPointDis = 12; minEndPointDis = 12;
/* loop over the octave representations of all lines */ /* loop over the octave representations of all lines */
for(unsigned int lineNextId=0; lineNextId<numOfFinalLine;lineNextId++){ for(unsigned int lineNextId=0; lineNextId<numOfFinalLine;lineNextId++){
/* if a line from same octave is encountered, /* if a line from same octave is encountered,
a comparison with it shouldn't be considered */ a comparison with it shouldn't be considered */
octaveID = octaveLines[lineNextId].octaveCount; octaveID = octaveLines[lineNextId].octaveCount;
if(octaveID==octaveCount){//lines in the same layer of octave image should not be compared. if(octaveID==octaveCount){//lines in the same layer of octave image should not be compared.
break; break;
} }
/* take ID in octave of line to be compared */ /* take ID in octave of line to be compared */
lineIDInOctave = octaveLines[lineNextId].lineIDInOctave; lineIDInOctave = octaveLines[lineNextId].lineIDInOctave;
/*first check whether current line and next line are parallel. /*first check whether current line and next line are parallel.
*If line1:a1*x+b1*y+c1=0 and line2:a2*x+b2*y+c2=0 are parallel, then *If line1:a1*x+b1*y+c1=0 and line2:a2*x+b2*y+c2=0 are parallel, then
*-a1/b1=-a2/b2, i.e., a1b2=b1a2. *-a1/b1=-a2/b2, i.e., a1b2=b1a2.
*we define parallel=fabs(a1b2-b1a2) *we define parallel=fabs(a1b2-b1a2)
*note that, in EDLine class, we have normalized the line equations *note that, in EDLine class, we have normalized the line equations
*to make a1^2+ b1^2 = a2^2+ b2^2 = 1*/ *to make a1^2+ b1^2 = a2^2+ b2^2 = 1*/
direction = fabs(edLineVec_[octaveCount]->lineDirection_[lineCurId] - direction = fabs(edLineVec_[octaveCount]->lineDirection_[lineCurId] -
edLineVec_[octaveID]->lineDirection_[lineIDInOctave]); edLineVec_[octaveID]->lineDirection_[lineIDInOctave]);
/* the angle between two lines are larger than 10degrees /* the angle between two lines are larger than 10degrees
(i.e. 10*pi/180=0.1745), they are not close to parallel */ (i.e. 10*pi/180=0.1745), they are not close to parallel */
if(direction>0.1745 && (twoPI - direction>0.1745)){ if(direction>0.1745 && (twoPI - direction>0.1745)){
continue; continue;
} }
/*now check whether current line and next line are near to each other. /*now check whether current line and next line are near to each other.
*If line1:a1*x+b1*y+c1=0 and line2:a2*x+b2*y+c2=0 are near in image, then *If line1:a1*x+b1*y+c1=0 and line2:a2*x+b2*y+c2=0 are near in image, then
*rho1 = |a1*0+b1*0+c1|/sqrt(a1^2+b1^2) and rho2 = |a2*0+b2*0+c2|/sqrt(a2^2+b2^2) should close. *rho1 = |a1*0+b1*0+c1|/sqrt(a1^2+b1^2) and rho2 = |a2*0+b2*0+c2|/sqrt(a2^2+b2^2) should close.
*In our case, rho1 = |c1| and rho2 = |c2|, because sqrt(a1^2+b1^2) = sqrt(a2^2+b2^2) = 1; *In our case, rho1 = |c1| and rho2 = |c2|, because sqrt(a1^2+b1^2) = sqrt(a2^2+b2^2) = 1;
*note that, lines are in different octave images, so we define near = fabs(scale*rho1 - rho2) or *note that, lines are in different octave images, so we define near = fabs(scale*rho1 - rho2) or
*where scale is the scale factor between to octave images*/ *where scale is the scale factor between to octave images*/
/* get known term from equation to be compared */ /* get known term from equation to be compared */
rho2 = scale[octaveID] * fabs(edLineVec_[octaveID]->lineEquations_[lineIDInOctave][2]); rho2 = scale[octaveID] * fabs(edLineVec_[octaveID]->lineEquations_[lineIDInOctave][2]);
/* compute difference between known ters */ /* compute difference between known ters */
near = fabs(rho1 - rho2); near = fabs(rho1 - rho2);
/* two lines are not close in the image */ /* two lines are not close in the image */
if(near>nearThreshold){ if(near>nearThreshold){
continue; continue;
} }
/*now check the end points distance between two lines, the scale of distance is in the original image size. /*now check the end points distance between two lines, the scale of distance is in the original image size.
* find the minimal and maximal end points distance*/ * find the minimal and maximal end points distance*/
/* get the extreme points of the two lines */ /* get the extreme points of the two lines */
lp0 = scale[octaveCount] *edLineVec_[octaveCount]->lineEndpoints_[lineCurId][0]; lp0 = scale[octaveCount] *edLineVec_[octaveCount]->lineEndpoints_[lineCurId][0];
lp1 = scale[octaveCount] *edLineVec_[octaveCount]->lineEndpoints_[lineCurId][1]; lp1 = scale[octaveCount] *edLineVec_[octaveCount]->lineEndpoints_[lineCurId][1];
lp2 = scale[octaveCount] *edLineVec_[octaveCount]->lineEndpoints_[lineCurId][2]; lp2 = scale[octaveCount] *edLineVec_[octaveCount]->lineEndpoints_[lineCurId][2];
lp3 = scale[octaveCount] *edLineVec_[octaveCount]->lineEndpoints_[lineCurId][3]; lp3 = scale[octaveCount] *edLineVec_[octaveCount]->lineEndpoints_[lineCurId][3];
np0 = scale[octaveID] * edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][0]; np0 = scale[octaveID] * edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][0];
np1 = scale[octaveID] * edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][1]; np1 = scale[octaveID] * edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][1];
np2 = scale[octaveID] * edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][2]; np2 = scale[octaveID] * edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][2];
np3 = scale[octaveID] * edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][3]; np3 = scale[octaveID] * edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][3];
/* get the distance between the two leftmost extremes of lines /* get the distance between the two leftmost extremes of lines
L1(0,1)<->L2(0,1) */ L1(0,1)<->L2(0,1) */
dx = lp0 - np0; dx = lp0 - np0;
dy = lp1 - np1; dy = lp1 - np1;
endPointDis = sqrt(dx*dx + dy*dy); endPointDis = sqrt(dx*dx + dy*dy);
/* set momentaneously min and max distance between lines to /* set momentaneously min and max distance between lines to
the one between left extremes */ the one between left extremes */
minLocalDis = endPointDis; minLocalDis = endPointDis;
maxLocalDis = endPointDis; maxLocalDis = endPointDis;
/* compute distance between right extremes /* compute distance between right extremes
L1(2,3)<->L2(2,3) */ L1(2,3)<->L2(2,3) */
dx = lp2 - np2; dx = lp2 - np2;
dy = lp3 - np3; dy = lp3 - np3;
endPointDis = sqrt(dx*dx + dy*dy); endPointDis = sqrt(dx*dx + dy*dy);
/* update (if necessary) min and max distance between lines */ /* update (if necessary) min and max distance between lines */
minLocalDis = (endPointDis<minLocalDis)?endPointDis:minLocalDis; minLocalDis = (endPointDis<minLocalDis)?endPointDis:minLocalDis;
maxLocalDis = (endPointDis>maxLocalDis)?endPointDis:maxLocalDis; maxLocalDis = (endPointDis>maxLocalDis)?endPointDis:maxLocalDis;
/* compute distance between left extreme of current line and /* compute distance between left extreme of current line and
right extreme of line to be compared right extreme of line to be compared
L1(0,1)<->L2(2,3) */ L1(0,1)<->L2(2,3) */
dx = lp0 - np2; dx = lp0 - np2;
dy = lp1 - np3; dy = lp1 - np3;
endPointDis = sqrt(dx*dx + dy*dy); endPointDis = sqrt(dx*dx + dy*dy);
/* update (if necessary) min and max distance between lines */ /* update (if necessary) min and max distance between lines */
minLocalDis = (endPointDis<minLocalDis)?endPointDis:minLocalDis; minLocalDis = (endPointDis<minLocalDis)?endPointDis:minLocalDis;
maxLocalDis = (endPointDis>maxLocalDis)?endPointDis:maxLocalDis; maxLocalDis = (endPointDis>maxLocalDis)?endPointDis:maxLocalDis;
/* compute distance between right extreme of current line and /* compute distance between right extreme of current line and
left extreme of line to be compared left extreme of line to be compared
L1(2,3)<->L2(0,1) */ L1(2,3)<->L2(0,1) */
dx = lp2 - np0; dx = lp2 - np0;
dy = lp3 - np1; dy = lp3 - np1;
endPointDis = sqrt(dx*dx + dy*dy); endPointDis = sqrt(dx*dx + dy*dy);
/* update (if necessary) min and max distance between lines */ /* update (if necessary) min and max distance between lines */
minLocalDis = (endPointDis<minLocalDis)?endPointDis:minLocalDis; minLocalDis = (endPointDis<minLocalDis)?endPointDis:minLocalDis;
maxLocalDis = (endPointDis>maxLocalDis)?endPointDis:maxLocalDis; maxLocalDis = (endPointDis>maxLocalDis)?endPointDis:maxLocalDis;
/* check whether conditions for considering line to be compared /* check whether conditions for considering line to be compared
worth to be inserted in the same LineVec are satisfied */ worth to be inserted in the same LineVec are satisfied */
if((maxLocalDis<0.8*(length+octaveLines[lineNextId].lineLength)) if((maxLocalDis<0.8*(length+octaveLines[lineNextId].lineLength))
&&(minLocalDis<minEndPointDis)){//keep the closest line &&(minLocalDis<minEndPointDis)){//keep the closest line
minEndPointDis = minLocalDis; minEndPointDis = minLocalDis;
closeLineID = lineNextId; closeLineID = lineNextId;
} }
} }
/* add current line into octaveLines */ /* add current line into octaveLines */
if(minEndPointDis<12){ if(minEndPointDis<12){
octaveLines[numOfFinalLine].lineIDInScaleLineVec = octaveLines[closeLineID].lineIDInScaleLineVec; octaveLines[numOfFinalLine].lineIDInScaleLineVec = octaveLines[closeLineID].lineIDInScaleLineVec;
}else{ }else{
octaveLines[numOfFinalLine].lineIDInScaleLineVec = lineIDInScaleLineVec; octaveLines[numOfFinalLine].lineIDInScaleLineVec = lineIDInScaleLineVec;
lineIDInScaleLineVec++; lineIDInScaleLineVec++;
} }
octaveLines[numOfFinalLine].octaveCount = octaveCount; octaveLines[numOfFinalLine].octaveCount = octaveCount;
octaveLines[numOfFinalLine].lineIDInOctave = lineCurId; octaveLines[numOfFinalLine].lineIDInOctave = lineCurId;
octaveLines[numOfFinalLine].lineLength = length; octaveLines[numOfFinalLine].lineLength = length;
numOfFinalLine++; numOfFinalLine++;
} }
}//end for(unsigned int octaveCount = 1; octaveCount<numOfOctave_; octaveCount++) }//end for(unsigned int octaveCount = 1; octaveCount<numOfOctave_; octaveCount++)
}//end if(numOfOctave_>1) }//end if(numOfOctave_>1)
//////////////////////////////////// ////////////////////////////////////
//Reorganize the detected lines into keyLines //Reorganize the detected lines into keyLines
keyLines.clear(); keyLines.clear();
keyLines.resize(lineIDInScaleLineVec); keyLines.resize(lineIDInScaleLineVec);
unsigned int tempID; unsigned int tempID;
float s1,e1,s2,e2; float s1,e1,s2,e2;
bool shouldChange; bool shouldChange;
OctaveSingleLine singleLine; OctaveSingleLine singleLine;
for(unsigned int lineID = 0;lineID < numOfFinalLine; lineID++){ for(unsigned int lineID = 0;lineID < numOfFinalLine; lineID++){
lineIDInOctave = octaveLines[lineID].lineIDInOctave; lineIDInOctave = octaveLines[lineID].lineIDInOctave;
octaveID = octaveLines[lineID].octaveCount; octaveID = octaveLines[lineID].octaveCount;
direction = edLineVec_[octaveID]->lineDirection_[lineIDInOctave]; direction = edLineVec_[octaveID]->lineDirection_[lineIDInOctave];
singleLine.octaveCount = octaveID; singleLine.octaveCount = octaveID;
singleLine.direction = direction; singleLine.direction = direction;
singleLine.lineLength = octaveLines[lineID].lineLength; singleLine.lineLength = octaveLines[lineID].lineLength;
singleLine.salience = edLineVec_[octaveID]->lineSalience_[lineIDInOctave]; singleLine.salience = edLineVec_[octaveID]->lineSalience_[lineIDInOctave];
singleLine.numOfPixels = edLineVec_[octaveID]->lines_.sId[lineIDInOctave+1]- singleLine.numOfPixels = edLineVec_[octaveID]->lines_.sId[lineIDInOctave+1]-
edLineVec_[octaveID]->lines_.sId[lineIDInOctave]; edLineVec_[octaveID]->lines_.sId[lineIDInOctave];
//decide the start point and end point //decide the start point and end point
shouldChange = false; shouldChange = false;
s1 = edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][0];//sx s1 = edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][0];//sx
s2 = edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][1];//sy s2 = edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][1];//sy
e1 = edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][2];//ex e1 = edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][2];//ex
e2 = edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][3];//ey e2 = edLineVec_[octaveID]->lineEndpoints_[lineIDInOctave][3];//ey
dx = e1 - s1;//ex-sx dx = e1 - s1;//ex-sx
dy = e2 - s2;//ey-sy dy = e2 - s2;//ey-sy
if(direction>=-0.75*M_PI&&direction<-0.25*M_PI){ if(direction>=-0.75*M_PI&&direction<-0.25*M_PI){
if(dy>0){shouldChange = true;} if(dy>0){shouldChange = true;}
} }
if(direction>=-0.25*M_PI&&direction<0.25*M_PI){ if(direction>=-0.25*M_PI&&direction<0.25*M_PI){
if(dx<0){shouldChange = true;} if(dx<0){shouldChange = true;}
} }
if(direction>=0.25*M_PI&&direction<0.75*M_PI){ if(direction>=0.25*M_PI&&direction<0.75*M_PI){
if(dy<0){shouldChange = true;} if(dy<0){shouldChange = true;}
} }
if((direction>=0.75*M_PI&&direction<M_PI)||(direction>=-M_PI&&direction<-0.75*M_PI)){ if((direction>=0.75*M_PI&&direction<M_PI)||(direction>=-M_PI&&direction<-0.75*M_PI)){
if(dx>0){shouldChange = true;} if(dx>0){shouldChange = true;}
} }
tempValue = scale[octaveID]; tempValue = scale[octaveID];
if(shouldChange){ if(shouldChange){
singleLine.sPointInOctaveX = e1; singleLine.sPointInOctaveX = e1;
singleLine.sPointInOctaveY = e2; singleLine.sPointInOctaveY = e2;
singleLine.ePointInOctaveX = s1; singleLine.ePointInOctaveX = s1;
singleLine.ePointInOctaveY = s2; singleLine.ePointInOctaveY = s2;
singleLine.startPointX = tempValue * e1; singleLine.startPointX = tempValue * e1;
singleLine.startPointY = tempValue * e2; singleLine.startPointY = tempValue * e2;
singleLine.endPointX = tempValue * s1; singleLine.endPointX = tempValue * s1;
singleLine.endPointY = tempValue * s2; singleLine.endPointY = tempValue * s2;
}else{ }else{
singleLine.sPointInOctaveX = s1; singleLine.sPointInOctaveX = s1;
singleLine.sPointInOctaveY = s2; singleLine.sPointInOctaveY = s2;
singleLine.ePointInOctaveX = e1; singleLine.ePointInOctaveX = e1;
singleLine.ePointInOctaveY = e2; singleLine.ePointInOctaveY = e2;
singleLine.startPointX = tempValue * s1; singleLine.startPointX = tempValue * s1;
singleLine.startPointY = tempValue * s2; singleLine.startPointY = tempValue * s2;
singleLine.endPointX = tempValue * e1; singleLine.endPointX = tempValue * e1;
singleLine.endPointY = tempValue * e2; singleLine.endPointY = tempValue * e2;
} }
tempID = octaveLines[lineID].lineIDInScaleLineVec; tempID = octaveLines[lineID].lineIDInScaleLineVec;
keyLines[tempID].push_back(singleLine); keyLines[tempID].push_back(singleLine);
} }
//////////////////////////////////// ////////////////////////////////////
delete [] scale; delete [] scale;
return 1; return 1;
...@@ -1122,130 +1125,68 @@ void LineDescriptor::findNearestParallelLines(ScaleLines & keyLines) ...@@ -1122,130 +1125,68 @@ void LineDescriptor::findNearestParallelLines(ScaleLines & keyLines)
} }
int LineDescriptor::GetLineDescriptor(cv::Mat & image, ScaleLines & keyLines, bool lsd) int LineDescriptor::GetLineDescriptor(std::vector<cv::Mat> &scale_images, ScaleLines &keyLines)
{ {
/*check whether image depth is different from 0 */ /*check whether image depth is different from 0
if(image.depth() != 0) if(image.depth() != 0)
{ {
std::cout << "Warning, depth image!= 0" << std::endl; std::cout << "Warning, depth image != 0" << std::endl;
CV_Assert(false); CV_Assert(false);
} }*/
/* make a clone of input image */
cv::Mat original = image.clone();
/* get clock's TIC */
double t = (double)cv::getTickCount();
/* compute LineVecs extraction and in case of failure, return an error code */ for(size_t scaleCounter = 0; scaleCounter<scale_images.size(); scaleCounter++)
if((OctaveKeyLines(image,keyLines))!=true){
cout << "OctaveKeyLines failed" << endl;
return -1;
}
/* get time lapse */
t = ((double)cv::getTickCount() - t)/cv::getTickFrequency();
std::cout << "time line extraction: " << t<< "s" <<std::endl;
// for(int j = 0; j<keyLines.size(); j++)
// {
// for(int k = 0; k<keyLines[j].size(); k++)
// {
// OctaveSingleLine singleLine = keyLines[j][k];
// std::cout<<"-----------["<<j<<"]["<<k<<"]--------------"<<std::endl;
//// std::cout<<"singleLine.octaveCount :"<<singleLine.octaveCount<<std::endl;
// std::cout<<"singleLine.direction :"<<singleLine.direction<<" -- "<<atan2((singleLine.startPointY - singleLine.endPointY),(singleLine.startPointX - singleLine.endPointX))<<" --- "<<atan2((singleLine.endPointY - singleLine.startPointY),(singleLine.endPointX - singleLine.startPointX))<<std::endl;
//// std::cout<<"singleLine.lineLength :"<<singleLine.lineLength<<std::endl;
//// std::cout<<"singleLine.salience :"<<singleLine.salience<<std::endl;
//// std::cout<<"singleLine.numOfPixels :"<<singleLine.numOfPixels<<std::endl;
//// std::cout<<"singleLine.sPointInOctaveX :"<<singleLine.sPointInOctaveX<<std::endl;
//// std::cout<<"singleLine.sPointInOctaveY :"<<singleLine.sPointInOctaveY<<std::endl;
//// std::cout<<"singleLine.ePointInOctaveX :"<<singleLine.ePointInOctaveX<<std::endl;
//// std::cout<<"singleLine.ePointInOctaveY :"<<singleLine.ePointInOctaveY<<std::endl;
//// std::cout<<"singleLine.startPointX :"<<singleLine.startPointX<<std::endl;
//// std::cout<<"singleLine.startPointY :"<<singleLine.startPointY<<std::endl;
//// std::cout<<"singleLine.endPointX :"<<singleLine.endPointX<<std::endl;
//// std::cout<<"singleLine.endPointY :"<<singleLine.endPointY<<std::endl;
//// std::cout<<"--------------------------------"<<std::endl;
// }
// }
if(lsd == true)
{ {
std::cout<<"GetLineDescriptor LSD"<<std::endl; /* get current scaled image */
cv::Mat currentScaledImage = scale_images[scaleCounter];
/* create an LSD detector and store a pointer to it */ /* create an LSD detector and store a pointer to it */
cv::Ptr<cv::LineSegmentDetector> ls = cv::createLineSegmentDetector(cv::LSD_REFINE_STD); cv::Ptr<cv::LineSegmentDetector> ls = cv::createLineSegmentDetector(cv::LSD_REFINE_STD);
/* prepare a vectore to host extracted segments */ /* prepare a vectore to host extracted segments */
std::vector<cv::Vec4i> lines_std; std::vector<cv::Vec4i> lines_std;
ScaleLines scaleLs;
/* use detector to extract segments */ /* use detector to extract segments */
ls->detect(original, lines_std); ls->detect(currentScaledImage, lines_std);
/* make a copy of input image */
cv::Mat drawnLines(original);
/* draw extracted segments on the copy of image */
ls->drawSegments(drawnLines, lines_std);
/* show extracted segments on image */ /* store information for every extracted segment */
cv::imshow("Standard refinement", drawnLines); for (size_t lineCounter = 0; lineCounter<lines_std.size(); lineCounter++)
/* get a matrix representation of segments */
cv::Mat _lines;
_lines = ((cv::InputArray)lines_std).getMat();
// Draw segments
for(int i = 0; i < _lines.size().width; ++i)
{ {
/* get current segment and store its extremes */
/* get current segments and store its extremes */ const cv::Vec4i v = lines_std[lineCounter];
const cv::Vec4i& v = _lines.at<cv::Vec4i>(i);
cv::Point b(v[0], v[1]); cv::Point b(v[0], v[1]);
cv::Point e(v[2], v[3]); cv::Point e(v[2], v[3]);
/* create an object to store line information */ /* create an object to store line information */
OctaveSingleLine osl; OctaveSingleLine osl;
osl.startPointX = b.x; osl.startPointX = b.x;
osl.startPointY = b.y; osl.startPointY = b.y;
osl.endPointX = e.x; osl.endPointX = e.x;
osl.endPointY = e.y; osl.endPointY = e.y;
osl.sPointInOctaveX = b.x; osl.sPointInOctaveX = b.x;
osl.sPointInOctaveY = b.y; osl.sPointInOctaveY = b.y;
osl.ePointInOctaveX = e.x; osl.ePointInOctaveX = e.x;
osl.ePointInOctaveY = e.y; osl.ePointInOctaveY = e.y;
osl.direction = 0; osl.direction = 0;
osl.salience = 0; osl.salience = 0;
osl.lineLength = 0; osl.lineLength = 0;
osl.numOfPixels = std::sqrt((b.x-e.x)*(b.x-e.x) + (b.y-e.y)*(b.y-e.y)); osl.numOfPixels = std::sqrt((b.x-e.x)*(b.x-e.x) + (b.y-e.y)*(b.y-e.y));
osl.octaveCount = 0; osl.octaveCount = scaleCounter;
/* store information about line */ /* create a new LineVec and add new line to it */
LinesVec lineScaleLs; LinesVec lineScaleLs;
lineScaleLs.push_back(osl); lineScaleLs.push_back(osl);
scaleLs.push_back(lineScaleLs);
/* add current LineVec to other ones in the output list */
keyLines.push_back(lineScaleLs);
} }
keyLines = scaleLs;
} }
else
std::cout<<"GetLineDescriptor EDLINE"<<std::endl;
//findNearestParallelLines(keyLines);
/* compute line descriptors */
ComputeLBD_(keyLines); ComputeLBD_(keyLines);
return 1; return 1;
} }
......
modules/line_descriptor/src/line_descriptor_init.cpp 0 → 100644
View file @ d79ae76a
/*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) 2013, OpenCV Foundation, 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*/
#include "precomp.hpp"
#include "opencv2/line_detector.hpp"
namespace cv
{
CV_INIT_ALGORITHM(EDLineDetector, "EDLINEDETECTOR",);
CV_INIT_ALGORITHM(LineDescriptor, "LINEDESCRIPTOR",);
bool initModule_tracking(void)
{
bool all = true;
all &= !EDLineDetector_info_auto.name().empty();
all &= !LineDescriptor_info_auto.name().empty();
return all;
}
}
modules/line_descriptor/src/line_descriptor_init.cpp~ 0 → 100644
View file @ d79ae76a
/*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) 2013, OpenCV Foundation, 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*/
#include "precomp.hpp"
#include "opencv2/tracking.hpp"
namespace cv
{
CV_INIT_ALGORITHM(EDLineDetector, "EDLINEDETECTOR",);
CV_INIT_ALGORITHM(LineDescriptor, "LINEDESCRIPTOR",);
bool initModule_tracking(void)
{
bool all = true;
all &= !EDLineDetector_info_auto.name().empty();
all &= !LineDescriptor_info_auto.name().empty();
return all;
}
}
modules/line_descriptor/src/precomp.cpp 0 → 100644
View file @ d79ae76a
/*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.
//
// Copyright (C) 2013, Alfonso Sanchez-Beato, 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 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*/
#include "precomp.hpp"
modules/line_descriptor/src/precomp.hpp 0 → 100644
View file @ d79ae76a
/*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) 2013, OpenCV Foundation, 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*/
#ifndef __OPENCV_PRECOMP_H__
#define __OPENCV_PRECOMP_H__
#include "opencv2/line_descriptor/EDLineDetector.hpp"
#include "opencv2/line_descriptor/LineDescriptor.hpp"
#include "opencv2/line_descriptor/LineStructure.hpp"
#include "opencv2/core/utility.hpp"
#include "opencv2/core/private.hpp"
#include <algorithm>
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment