/*
 *  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
 *  (3 - clause BSD License)
 *
 *  Redistribution and use in source and binary forms, with or without modification,
 *  are permitted provided that the following conditions are met :
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *
 *  * Redistributions 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.
 *
 *  * Neither the names of the copyright holders nor the names of the contributors
 *  may 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 copyright holders 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.
 */

#ifndef __OPENCV_SPARSEMATCHINTERPOLATOR_HPP__
#define __OPENCV_SPARSEMATCHINTERPOLATOR_HPP__
#ifdef __cplusplus

#include <opencv2/core.hpp>

namespace cv {
namespace ximgproc {

//! @addtogroup ximgproc_filters
//! @{

/** @brief Main interface for all filters, that take sparse matches as an
input and produce a dense per-pixel matching (optical flow) as an output.
 */
class CV_EXPORTS_W SparseMatchInterpolator : public Algorithm
{
public:
    /** @brief Interpolate input sparse matches.

    @param from_image first of the two matched images, 8-bit single-channel or three-channel.

    @param from_points points of the from_image for which there are correspondences in the
    to_image (Point2f vector, size shouldn't exceed 32767)

    @param to_image second of the two matched images, 8-bit single-channel or three-channel.

    @param to_points points in the to_image corresponding to from_points
    (Point2f vector, size shouldn't exceed 32767)

    @param dense_flow output dense matching (two-channel CV_32F image)
     */
    CV_WRAP virtual void interpolate(InputArray from_image, InputArray from_points,
                                     InputArray to_image  , InputArray to_points,
                                     OutputArray dense_flow) = 0;
};

/** @brief Sparse match interpolation algorithm based on modified locally-weighted affine
estimator from @cite Revaud2015 and Fast Global Smoother as post-processing filter.
 */
class CV_EXPORTS_W EdgeAwareInterpolator : public SparseMatchInterpolator
{
public:
    /** @brief Interface to provide a more elaborated cost map, i.e. edge map, for the edge-aware term.
     *  This implementation is based on a rather simple gradient-based edge map estimation.
     *  To used more complex edge map estimator (e.g. StructuredEdgeDetection that has been
     *  used in the original publication) that may lead to improved accuracies, the internal
     *  edge map estimation can be bypassed here.
     *  @param _costMap a type CV_32FC1 Mat is required.
     *  @see cv::ximgproc::createSuperpixelSLIC
    */
    CV_WRAP virtual void setCostMap(const Mat & _costMap) = 0;
    /** @brief Parameter to tune the approximate size of the superpixel used for oversegmentation.
     *  @see cv::ximgproc::createSuperpixelSLIC
    */
    /** @brief K is a number of nearest-neighbor matches considered, when fitting a locally affine
    model. Usually it should be around 128. However, lower values would make the interpolation
    noticeably faster.
     */
    CV_WRAP virtual void setK(int _k) = 0;
    /** @see setK */
    CV_WRAP virtual int  getK() = 0;

    /** @brief Sigma is a parameter defining how fast the weights decrease in the locally-weighted affine
    fitting. Higher values can help preserve fine details, lower values can help to get rid of noise in the
    output flow.
     */
    CV_WRAP virtual void  setSigma(float _sigma) = 0;
    /** @see setSigma */
    CV_WRAP virtual float getSigma() = 0;

    /** @brief Lambda is a parameter defining the weight of the edge-aware term in geodesic distance,
    should be in the range of 0 to 1000.
     */
    CV_WRAP virtual void  setLambda(float _lambda) = 0;
    /** @see setLambda */
    CV_WRAP virtual float getLambda() = 0;

    /** @brief Sets whether the fastGlobalSmootherFilter() post-processing is employed. It is turned on by
    default.
     */
    CV_WRAP virtual void setUsePostProcessing(bool _use_post_proc) = 0;
    /** @see setUsePostProcessing */
    CV_WRAP virtual bool getUsePostProcessing() = 0;

    /** @brief Sets the respective fastGlobalSmootherFilter() parameter.
     */
    CV_WRAP virtual void  setFGSLambda(float _lambda) = 0;
    /** @see setFGSLambda */
    CV_WRAP virtual float getFGSLambda() = 0;

    /** @see setFGSLambda */
    CV_WRAP virtual void  setFGSSigma(float _sigma) = 0;
    /** @see setFGSLambda */
    CV_WRAP virtual float getFGSSigma() = 0;
};

/** @brief Factory method that creates an instance of the
EdgeAwareInterpolator.
*/
CV_EXPORTS_W
Ptr<EdgeAwareInterpolator> createEdgeAwareInterpolator();

/** @brief Sparse match interpolation algorithm based on modified piecewise locally-weighted affine
 * estimator called Robust Interpolation method of Correspondences or RIC from @cite Hu2017 and Variational
 * and Fast Global Smoother as post-processing filter. The RICInterpolator is a extension of the EdgeAwareInterpolator.
 * Main concept of this extension is an piece-wise affine model based on over-segmentation via SLIC superpixel estimation.
 * The method contains an efficient propagation mechanism to estimate among the pieces-wise models.
 */
class CV_EXPORTS_W RICInterpolator : public SparseMatchInterpolator
{
public:
    /** @brief K is a number of nearest-neighbor matches considered, when fitting a locally affine
     *model for a superpixel segment. However, lower values would make the interpolation
     *noticeably faster. The original implementation of @cite Hu2017 uses 32.
    */
    CV_WRAP virtual void setK(int k = 32) = 0;
    /** @copybrief setK
     *  @see setK
     */
    CV_WRAP virtual int getK() const = 0;
    /** @brief Interface to provide a more elaborated cost map, i.e. edge map, for the edge-aware term.
     *  This implementation is based on a rather simple gradient-based edge map estimation.
     *  To used more complex edge map estimator (e.g. StructuredEdgeDetection that has been
     *  used in the original publication) that may lead to improved accuracies, the internal
     *  edge map estimation can be bypassed here.
     *  @param costMap a type CV_32FC1 Mat is required.
     *  @see cv::ximgproc::createSuperpixelSLIC
    */
    CV_WRAP virtual void setCostMap(const Mat & costMap) = 0;
    /** @brief Get the internal cost, i.e. edge map, used for estimating the edge-aware term.
     *  @see setCostMap
     */
    CV_WRAP virtual void setSuperpixelSize(int spSize = 15) = 0;
    /** @copybrief setSuperpixelSize
     *  @see setSuperpixelSize
     */
    CV_WRAP virtual int getSuperpixelSize() const = 0;
    /** @brief Parameter defines the number of nearest-neighbor matches for each superpixel considered, when fitting a locally affine
     *model.
    */
    CV_WRAP virtual void setSuperpixelNNCnt(int spNN = 150) = 0;
    /** @copybrief setSuperpixelNNCnt
     *  @see setSuperpixelNNCnt
    */
    CV_WRAP virtual int getSuperpixelNNCnt() const = 0;
    /** @brief Parameter to tune enforcement of superpixel smoothness factor used for oversegmentation.
     *  @see cv::ximgproc::createSuperpixelSLIC
    */
    CV_WRAP virtual void setSuperpixelRuler(float ruler = 15.f) = 0;
    /** @copybrief setSuperpixelRuler
     *  @see setSuperpixelRuler
     */
    CV_WRAP virtual float  getSuperpixelRuler() const = 0;
    /** @brief Parameter to choose superpixel algorithm variant to use:
     * - cv::ximgproc::SLICType SLIC segments image using a desired region_size (value: 100)
     * - cv::ximgproc::SLICType SLICO will optimize using adaptive compactness factor (value: 101)
     * - cv::ximgproc::SLICType MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels (value: 102).
     *  @see cv::ximgproc::createSuperpixelSLIC
    */
    CV_WRAP virtual void setSuperpixelMode(int mode = 100) = 0;
    /** @copybrief setSuperpixelMode
     *  @see setSuperpixelMode
     */
    CV_WRAP virtual int getSuperpixelMode() const = 0;
    /** @brief Alpha is a parameter defining a global weight for transforming geodesic distance into weight.
     */
    CV_WRAP virtual void setAlpha(float alpha = 0.7f) = 0;
    /** @copybrief setAlpha
     *  @see setAlpha
     */
    CV_WRAP virtual float getAlpha() const = 0;
    /** @brief Parameter defining the number of iterations for piece-wise affine model estimation.
     */
    CV_WRAP virtual void setModelIter(int modelIter = 4) = 0;
    /** @copybrief setModelIter
     *  @see setModelIter
     */
    CV_WRAP virtual int getModelIter() const = 0;
    /** @brief Parameter to choose wether additional refinement of the piece-wise affine models is employed.
    */
    CV_WRAP virtual void setRefineModels(bool refineModles = true) = 0;
    /** @copybrief setRefineModels
     *  @see setRefineModels
     */
    CV_WRAP virtual bool getRefineModels() const = 0;
    /** @brief MaxFlow is a threshold to validate the predictions using a certain piece-wise affine model.
     * If the prediction exceeds the treshold the translational model will be applied instead.
    */
    CV_WRAP virtual void setMaxFlow(float maxFlow = 250.f) = 0;
    /** @copybrief setMaxFlow
     *  @see setMaxFlow
     */
    CV_WRAP virtual float getMaxFlow() const = 0;
    /** @brief Parameter to choose wether the VariationalRefinement post-processing  is employed.
    */
    CV_WRAP virtual void setUseVariationalRefinement(bool use_variational_refinement = false) = 0;
    /** @copybrief setUseVariationalRefinement
     *  @see setUseVariationalRefinement
     */
    CV_WRAP virtual bool  getUseVariationalRefinement() const = 0;
    /** @brief Sets whether the fastGlobalSmootherFilter() post-processing is employed.
    */
    CV_WRAP virtual void setUseGlobalSmootherFilter(bool use_FGS = true) = 0;
    /** @copybrief setUseGlobalSmootherFilter
     *  @see setUseGlobalSmootherFilter
     */
    CV_WRAP virtual bool getUseGlobalSmootherFilter() const = 0;
    /** @brief Sets the respective fastGlobalSmootherFilter() parameter.
     */
    CV_WRAP virtual void  setFGSLambda(float lambda = 500.f) = 0;
    /** @copybrief setFGSLambda
     *  @see setFGSLambda
     */
    CV_WRAP virtual float getFGSLambda() const = 0;
    /** @brief Sets the respective fastGlobalSmootherFilter() parameter.
     */
    CV_WRAP virtual void  setFGSSigma(float sigma = 1.5f) = 0;
    /** @copybrief setFGSSigma
     *  @see setFGSSigma
     */
    CV_WRAP virtual float getFGSSigma() const = 0;
};

/** @brief Factory method that creates an instance of the
RICInterpolator.
*/
CV_EXPORTS_W
Ptr<RICInterpolator> createRICInterpolator();
//! @}
}
}
#endif
#endif
