LSD算法调节参数GUI

程序目的

鉴于LSD算法参数众多，调节起来比较困难，所以本人基于OpenCV，设计了一个简单的GUI程序，专门用来调节各种LSD涉及到的参数

参数解释

具体的LSD算法实现参考本文整理的开源
line_descriptor_opencvm_demo

参数名称	解释
detect_scale	计算当前图像的金字塔下采样倍率，默认1.2，即下采样到原来1/1.2
detect_numOctaves	计算当前图像需要提取几层高斯金字塔，默认值1
refine	是否将提取到的线精调到更细小的线，默认值LSD_REFINE_STD
scale	用于找到线的图像的尺度，默认值下采样到0.8
sigma_scale	不同尺度的高斯滤波器方差参数，默认值0.6
quant	梯度范数的最大量化误差边界，默认值2.0
ang_th	线段支持域中能容纳的最大角度阈值，默认值22.5
log_eps	种子点检测阈值，默认值0
density_th	线段支持域中对齐像素占据的最小比例，默认值0.7
n_bins	像素梯度排序算法的桶数量，默认值1024
min_length	所提取的线段最小像素长度，参考值0.025

CMakeLists.txt文件

cmake_minimum_required(VERSION 3.5)
project(extract_match_line)

set(CMAKE_CXX_STANDARD 11)

#boost
find_package(Boost COMPONENTS
        filesystem
        REQUIRED
        )
include_directories(${Boost_INCLUDE_DIRS})
link_directories(${Boost_LIBRARY_DIRS})

#OpenCV
find_package(OpenCV)
include_directories(OpenCV_INCLUDE_DIRS)

#glogging
find_package(Glog REQUIRED)

#line_descriptor
include_directories(${PROJECT_SOURCE_DIR}/line_descriptor_opencvm/include)



add_executable(extract_line extract_line.cpp
        line_extractor.cpp
        line_matcher.cpp
        )
target_link_libraries(extract_line
        ${OpenCV_LIBS}
        ${Glog_LIBRARIES}
        ${PROJECT_SOURCE_DIR}/line_descriptor_opencvm/lib/liblinedesc.so
        )

main函数

#include <iostream>
#include <vector>
using std::cout;
using std::endl;
using std::string;
using std::vector;

#include <glog/logging.h>

#include <opencv2/opencv.hpp>
#include "descriptor_opencvm.hpp"

std::string window_name("LSD Detect");
//最大真实值
double gd_detect_scale=4;   //1.2;4;0.1;40
int gd_detect_numOctaves=8; //1;8;1;8
int gd_refine=2;   //2;2;1;2
double gd_sigma_scale=1.0;  //0.6;1;0.01;100;
double gd_quant=10.0;    //2.0;10;0.1;100;
double gd_ang_th=100.;  //22.5;100;0.1;1000;
double gd_log_eps=10.;  //1.0;10;0.1;100;
double gd_density_th=1.;   //0.5;1;0.01;100;
int gd_n_bins=10000;  //1024;10000;1;10000;
double gd_min_length=500.; //0.025;500;0.001;500000
double gd_scale=4.;    //1.2;4;0.1;40;

//推荐值，最大值，步长，整数
//最大尺度值
int gm_detect_scale=40;   //1.2;4;0.1;40
int gm_detect_numOctaves=8; //1;8;1;8
int gm_refine=2;   //2;2;1;2
int gm_sigma_scale=100;  //0.6;1;0.01;100;
int gm_quant=100;    //2.0;10;0.1;100;
int gm_ang_th=1000;  //22.5;100;0.1;1000;
int gm_log_eps=100;  //1.0;10;0.1;100;
int gm_density_th=100;   //0.5;1;0.01;100;
int gm_n_bins=10000;  //1024;10000;1;10000;
int gm_min_length=500000; //0.025;500;0.001;500000
int gm_scale=40;    //1.2;4;0.1;40;

//测量尺度值
int gtb_detect_scale=12;   //
int gtb_detect_numOctaves=1;
int gtb_refine=0;
int gtb_sigma_scale=60;
int gtb_quant=20;
int gtb_ang_th=225;
int gtb_log_eps=10;
int gtb_density_th=50;
int gtb_n_bins=1024;
int gtb_min_length=25;
int gtb_scale=12;

cv::Mat color;
cv::Ptr<cvm::line_descriptor::LSDDetector> lsd = cvm::line_descriptor::LSDDetector::createLSDDetector();

void callback(int value, void* userdata){
    double detect_scale=gd_detect_scale*gtb_detect_scale/gm_detect_scale;
    int detect_numOctaves=gtb_detect_numOctaves;
    int refine=gtb_refine;
    double sigma_scale=gd_sigma_scale*gtb_sigma_scale/gm_sigma_scale;
    double quant=gd_quant*gtb_quant/gm_quant;
    double ang_th=gd_ang_th*gtb_ang_th/gm_ang_th;
    double log_eps=gd_log_eps*gtb_log_eps/gm_log_eps;
    double density_th=gd_density_th*gtb_density_th/gm_density_th;
    int n_bins=gtb_n_bins;
    double min_length=gd_min_length*gtb_min_length/gm_min_length;
    double scale=gd_scale*gtb_scale/gm_scale;

    std::vector <cvm::line_descriptor::KeyLine> keylines;
    cvm::line_descriptor::LSDDetector::LSDOptions opts;
    opts.refine = refine;    //optim=0
    opts.scale = scale;
    opts.sigma_scale = sigma_scale;
    opts.quant = quant;
    opts.ang_th = ang_th;
    opts.log_eps = log_eps;
    opts.density_th = density_th;
    opts.n_bins = n_bins;
    opts.min_length = min_length;    //待定
    LOG(INFO)<<"=============================";
    LOG(INFO)<<"detect_scale="<<detect_scale;
    LOG(INFO)<<"detect_numOctaves="<<detect_numOctaves;
    LOG(INFO)<<"refine="<<refine;
    LOG(INFO)<<"scale="<<scale;
    LOG(INFO)<<"sigma_scale="<<sigma_scale;
    LOG(INFO)<<"quant="<<quant;
    LOG(INFO)<<"ang_th="<<ang_th;
    LOG(INFO)<<"log_eps="<<log_eps;
    LOG(INFO)<<"density_th="<<density_th;
    LOG(INFO)<<"n_bins="<<n_bins;
    LOG(INFO)<<"min_length="<<min_length;
    lsd->detect(color, keylines, detect_scale,detect_numOctaves,opts);  //提取线特征并计算描述子
//    lsd->detect(color, keylines, detect_scale,detect_numOctaves);  //提取线特征并计算描述子
    cv::Mat result(color.size(),CV_8UC3,cv::Scalar::all(0));
    cvm::line_descriptor::drawKeylines(color,keylines,result);
    cv::imshow(window_name,result);
}

int main(int argc, char **argv)
{
    //读入图像
    google::InitGoogleLogging(argv[0]);
    google::InstallFailureSignalHandler();
    FLAGS_logtostderr = true;


    //读入图像
    cv::Mat color1 = cv::imread("../0.png", -1); //先读入一帧RGB和depth
    if (color1.empty())  cout << "wrong input rgb image" << endl;



    color=color1;
    cv::namedWindow(window_name);
    int t1=1;
    int t2=2;
    int t3=3;
    int t4=4;
    int t5=5;
    int t6=6;
    int t7=7;
    int t8=8;
    int t9=9;
    int t10=10;
    int t11=11;
    cv::createTrackbar("gtb_detect_scale",window_name,&gtb_detect_scale,gm_detect_scale,callback,&t1);
    cv::createTrackbar("gtb_detect_numOctaves",window_name,&gtb_detect_numOctaves,gm_detect_numOctaves,callback,&t2);
    cv::createTrackbar("gtb_refine",window_name,&gtb_refine,gm_refine,callback,&t3);
    cv::createTrackbar("gtb_sigma_scale",window_name,&gtb_sigma_scale,gm_sigma_scale,callback,&t4);
    cv::createTrackbar("gtb_quant",window_name,&gtb_quant,gm_quant,callback,&t5);
    cv::createTrackbar("gtb_ang_th",window_name,&gtb_ang_th,gm_ang_th,callback,&t6);
    cv::createTrackbar("gtb_log_eps",window_name,&gtb_log_eps,gm_log_eps,callback,&t7);
    cv::createTrackbar("gtb_density_th",window_name,&gtb_density_th,gm_density_th,callback,&t8);
    cv::createTrackbar("gtb_n_bins",window_name,&gtb_n_bins,gm_n_bins,callback,&t9);
    cv::createTrackbar("gtb_min_length",window_name,&gtb_min_length,gm_min_length,callback,&t10);
    cv::createTrackbar("gtb_scale",window_name,&gtb_scale,gm_scale,callback,&t11);

    cv::waitKey(0);
    return 0;
}