imgproc.h

Go to the documentation of this file.

/*
* ECVL - European Computer Vision Library
* Version: 0.3.4
* copyright (c) 2021, Università degli Studi di Modena e Reggio Emilia (UNIMORE), AImageLab
* Authors:
*    Costantino Grana (costantino.grana@unimore.it)
*    Federico Bolelli (federico.bolelli@unimore.it)
*    Michele Cancilla (michele.cancilla@unimore.it)
*    Laura Canalini (laura.canalini@unimore.it)
*    Stefano Allegretti (stefano.allegretti@unimore.it)
* All rights reserved.
*/

#ifndef ECVL_IMGPROC_H_
#define ECVL_IMGPROC_H_

#include <random>
#include "image.h"
#include "saturate_cast.h"

namespace ecvl
{
enum class ThresholdingType
{
    BINARY,     
    BINARY_INV, 
};

enum class InterpolationType
{
    nearest,    
    linear,     
    area,       
    cubic,      
    lanczos4    
};

int GetOpenCVInterpolation(InterpolationType interp);

void ResizeDim(const ecvl::Image& src, ecvl::Image& dst, const std::vector<int>& newdims, InterpolationType interp = InterpolationType::linear);

void ResizeScale(const ecvl::Image& src, ecvl::Image& dst, const std::vector<double>& scales, InterpolationType interp = InterpolationType::linear);

void Flip2D(const ecvl::Image& src, ecvl::Image& dst);

void Mirror2D(const ecvl::Image& src, ecvl::Image& dst);

void Rotate2D(const ecvl::Image& src, ecvl::Image& dst, double angle, const std::vector<double>& center = {}, double scale = 1.0, InterpolationType interp = InterpolationType::linear);

void RotateFullImage2D(const ecvl::Image& src, ecvl::Image& dst, double angle, double scale = 1.0, InterpolationType interp = InterpolationType::linear);

void ChangeColorSpace(const Image& src, Image& dst, ColorType new_type);

void Threshold(const Image& src, Image& dst, double thresh, double maxval, ThresholdingType thresh_type = ThresholdingType::BINARY);

void MultiThreshold(const Image& src, Image& dst, const std::vector<int>& thresholds, int minval = 0, int maxval = 255);

int OtsuThreshold(const Image& src);

std::vector<int> OtsuMultiThreshold(const Image& src, int n_thresholds = 2);

void Filter2D(const Image& src, Image& dst, const Image& ker, DataType type = DataType::none /* type of border */);

void SeparableFilter2D(const Image& src, Image& dst, const std::vector<double>& kerX, const std::vector<double>& kerY, DataType type = DataType::none);

void GaussianBlur(const Image& src, Image& dst, int sizeX, int sizeY, double sigmaX, double sigmaY = 0);
void GaussianBlur(const Image& src, Image& dst, double sigma);

void AdditiveLaplaceNoise(const Image& src, Image& dst, double std_dev);

void AdditivePoissonNoise(const Image& src, Image& dst, double lambda);

void GammaContrast(const Image& src, Image& dst, double gamma);

void CoarseDropout(const Image& src, Image& dst, double p, double drop_size, bool per_channel);

void IntegralImage(const Image& src, Image& dst, DataType dst_type = DataType::float64);

void NonMaximaSuppression(const Image& src, Image& dst);

std::vector<ecvl::Point2i> GetMaxN(const Image& src, size_t n);

void ConnectedComponentsLabeling(const Image& src, Image& dst);

void FindContours(const Image& src, std::vector<std::vector<Point2i>>& contours);

void Stack(const std::vector<Image>& src, Image& dst);

void HConcat(const std::vector<Image>& src, Image& dst);

void VConcat(const std::vector<Image>& src, Image& dst);

enum class MorphType
{
    MORPH_ERODE   ,
    MORPH_DILATE  ,
    MORPH_OPEN    , 
    MORPH_CLOSE   , 
    MORPH_GRADIENT, 
    MORPH_TOPHAT  , 
    MORPH_BLACKHAT, 
    MORPH_HITMISS   
};

enum class BorderType
{
    BORDER_CONSTANT,     
    BORDER_REPLICATE,    
    BORDER_REFLECT,      
    BORDER_WRAP,         
    BORDER_REFLECT_101,  
    BORDER_TRANSPARENT   
};

void Morphology(const Image& src, Image& dst, MorphType op, Image& kernel,
    Point2i anchor = { -1, -1 },
    int iterations = 1,
    BorderType border_type = BorderType::BORDER_CONSTANT,
    const int& border_value = 0 /*morphologyDefaultBorderValue()*/
);

enum class InpaintType
{
    INPAINT_NS,     
    INPAINT_TELEA   
};

void Inpaint(const Image& src, Image& dst, const Image& inpaintMask, double inpaintRadius, InpaintType flag = InpaintType::INPAINT_TELEA);

void MeanStdDev(const Image& src, std::vector<double>& mean, std::vector<double>& stddev);

void Transpose(const Image& src, Image& dst);

void GridDistortion(const Image& src, Image& dst,
    int num_steps = 5,
    const std::array<float, 2>& distort_limit = { -0.3f, 0.3f },
    InterpolationType interp = InterpolationType::linear,
    BorderType border_type = BorderType::BORDER_REFLECT_101,
    const int& border_value = 0,
    const unsigned seed = std::default_random_engine::default_seed
);

void ElasticTransform(const Image& src, Image& dst,
    double alpha = 34.,
    double sigma = 4.,
    InterpolationType interp = InterpolationType::linear,
    BorderType border_type = BorderType::BORDER_REFLECT_101,
    const int& border_value = 0,
    const unsigned seed = std::default_random_engine::default_seed
);

void OpticalDistortion(const Image& src, Image& dst,
    const std::array<float, 2>& distort_limit = { -0.3f, 0.3f },
    const std::array<float, 2>& shift_limit = { -0.1f, 0.1f },
    InterpolationType interp = InterpolationType::linear,
    BorderType border_type = BorderType::BORDER_REFLECT_101,
    const int& border_value = 0,
    const unsigned seed = std::default_random_engine::default_seed
);

void Salt(const Image& src, Image& dst, double p, bool per_channel = false, const unsigned seed = std::default_random_engine::default_seed);

void Pepper(const Image& src, Image& dst, double p, bool per_channel = false, const unsigned seed = std::default_random_engine::default_seed);

void SaltAndPepper(const Image& src, Image& dst, double p, bool per_channel = false, const unsigned seed = std::default_random_engine::default_seed);

void SliceTimingCorrection(const Image& src, Image& dst, bool odd = false, bool down = false);

void Moments(const Image& src, Image& moments, int order = 3, DataType type = DataType::float64);

void CentralMoments(const Image& src, Image& moments, std::vector<double> center, int order = 3, DataType type = DataType::float64);


void DrawEllipse(Image& src, ecvl::Point2i center, ecvl::Size2i axes, double angle, const ecvl::Scalar& color, int thickness = 1);

void DropColorChannel(Image& src);

void Normalize(const Image& src, Image& dst, const double& mean, const double& std);

void Normalize(const Image& src, Image& dst, const std::vector<double>& mean, const std::vector<double>& std);

void CenterCrop(const ecvl::Image& src, ecvl::Image& dst, const std::vector<int>& size);

void ScaleTo(const Image& src, Image& dst, const double& new_min, const double& new_max);

} // namespace ecvl

#endif // ECVL_IMGPROC_H_