algorithmparameters.h

#pragma once
#include "managed.h"

//cost function
enum { PM_COST = 0, CENSUS_TRANSFORM = 1, ADAPTIVE_CENSUS = 2, CENSUS_SELFSIMILARITY = 3, PM_SELFSIMILARITY = 4, ADCENSUS = 5, ADCENSUS_SELFSIMILARITY = 6, SPARSE_CENSUS = 7 };

//cost combination
enum { COMB_ALL = 0, COMB_BEST_N = 1, COMB_ANGLE = 2, COMB_GOOD = 3};


class AlgorithmParameters : public Managed{
public:
    int algorithm; // algorithm cost type
    float max_disparity; // maximal disparity value CUDA
    float min_disparity; // minimum disparity value (default 0) CUDA
    int box_hsize; // filter kernel width CUDA
    int box_vsize; // filter kernel height CUDA
    float tau_color; // PM_COST max. threshold for color CUDA
    float tau_gradient; // PM_COST max. threshold for gradient CUDA
    float alpha; // PM_COST weighting between color and gradient CUDA
    float gamma; // parameter for weight function (used e.g. in PM_COST) CUDA
    int border_value; // what value should pixel at extended border get (constant or replicate -1)
    int iterations; // number of iterations
    bool color_processing; // use color processing or not (otherwise just grayscale processing)
    float dispTol; //PM Stereo: 1, PM Huber: 0.5
    float normTol; // 0.1 ... about 5.7 degrees
    float census_epsilon; //for census transform
    int self_similarity_n; // number of pixels considered for self similarity
    float cam_scale; //used to rescale K in case of rescaled image size
    int num_img_processed; //number of images that are processed as reference images
    float costThresh; // threshold to decide whether disparity/depth is valid or not
    float good_factor; // for cost aggregation/combination good: factor for truncation CUDA
    int n_best; // CUDA
    int cost_comb; // CUDA
    bool viewSelection;
    float depthMin; // CUDA
    float depthMax; // CUDA
    float min_angle; // CUDA
    float max_angle; // CUDA
    float no_texture_sim; // CUDA
    float no_texture_per; // CUDA
    unsigned int max_views;
    // hack XXX
    int cols;
    int rows;

    AlgorithmParameters(){
        algorithm          = 0; // algorithm cost type
        max_disparity      = 256.0f; // maximal disparity value CUDA
        min_disparity      = 0.0f; // minimum disparity value (default 0) CUDA
        box_hsize          = 19; // filter kernel width CUDA
        box_vsize          = 19; // filter kernel height CUDA
        tau_color          = 10; // PM_COST max. threshold for color CUDA
        tau_gradient       = 2.0f; // PM_COST max. threshold for gradient CUDA
        alpha              = 0.9f; // PM_COST weighting between color and gradient CUDA
        gamma              = 10.0f; // parameter for weight function (used e.g. in PM_COST) CUDA
        border_value       = -1; // what value should pixel at extended border get (constant or replicate -1)
        iterations         = 8; // number of iterations
        color_processing   = false; // use color processing or not (otherwise just grayscale processing)
        dispTol            = 1.0; //PM Stereo: 1, PM Huber: 0.5
        normTol            = 0.1f; // 0.1 ... about 5.7 degrees
        census_epsilon     = 2.5f; //for census transform
        self_similarity_n  = 50; // number of pixels considered for self similarity
        cam_scale          = 1.0f; //used to rescale K in case of rescaled image size
        num_img_processed  = 1; //number of images that are processed as reference images
        costThresh         = 40.0f; // threshold to decide whether disparity/depth is valid or not
         good_factor       = 1.5f; // for cost aggregation/combination good: factor for truncation CUDA
        n_best             = 2; // CUDA
        cost_comb          = 1; // CUDA
        viewSelection      = true;
        depthMin           = -1.0f; // CUDA
        depthMax           = -1.0f; // CUDA
        min_angle          = 5.0f; // CUDA
        max_angle          = 45.0f; // CUDA
        no_texture_sim     = 0.9f; // CUDA
        no_texture_per     = 0.6f; // CUDA
        max_views          = 9;
    }
};