OpenCV  4.5.1-pre
Open Source Computer Vision
Functions
Math with F1-transform support

Functions

void cv::ft::FT12D_components (InputArray matrix, InputArray kernel, OutputArray components)
 Computes components of the array using direct \(F^1\)-transform. More...
 
void cv::ft::FT12D_createPolynomMatrixHorizontal (int radius, OutputArray matrix, const int chn)
 Creates horizontal matrix for \(F^1\)-transform computation. More...
 
void cv::ft::FT12D_createPolynomMatrixVertical (int radius, OutputArray matrix, const int chn)
 Creates vertical matrix for \(F^1\)-transform computation. More...
 
void cv::ft::FT12D_inverseFT (InputArray components, InputArray kernel, OutputArray output, int width, int height)
 Computes inverse \(F^1\)-transfrom. More...
 
void cv::ft::FT12D_polynomial (InputArray matrix, InputArray kernel, OutputArray c00, OutputArray c10, OutputArray c01, OutputArray components, InputArray mask=noArray())
 Computes elements of \(F^1\)-transform components. More...
 
void cv::ft::FT12D_process (InputArray matrix, InputArray kernel, OutputArray output, InputArray mask=noArray())
 Computes \(F^1\)-transfrom and inverse \(F^1\)-transfrom at once. More...
 

Detailed Description

Fuzzy transform ( \(F^1\)-transform) of the 1th degree transforms whole image to a matrix of its components. Each component is polynomial of the 1th degree carrying information about average color and average gradient of certain subarea.

Function Documentation

◆ FT12D_components()

void cv::ft::FT12D_components ( InputArray  matrix,
InputArray  kernel,
OutputArray  components 
)
Python:
components=cv.ft.FT12D_components(matrix, kernel[, components])

#include <opencv2/fuzzy/fuzzy_F1_math.hpp>

Computes components of the array using direct \(F^1\)-transform.

Parameters
matrixInput array.
kernelKernel used for processing. Function ft::createKernel can be used.
componentsOutput 32-bit float array for the components.

The function computes linear components using predefined kernel.

◆ FT12D_createPolynomMatrixHorizontal()

void cv::ft::FT12D_createPolynomMatrixHorizontal ( int  radius,
OutputArray  matrix,
const int  chn 
)
Python:
matrix=cv.ft.FT12D_createPolynomMatrixHorizontal(radius, chn[, matrix])

#include <opencv2/fuzzy/fuzzy_F1_math.hpp>

Creates horizontal matrix for \(F^1\)-transform computation.

Parameters
radiusRadius of the basic function.
matrixThe horizontal matrix.
chnNumber of channels.

The function creates helper horizontal matrix for \(F^1\)-transfrom processing. It is used for gradient computation.

◆ FT12D_createPolynomMatrixVertical()

void cv::ft::FT12D_createPolynomMatrixVertical ( int  radius,
OutputArray  matrix,
const int  chn 
)
Python:
matrix=cv.ft.FT12D_createPolynomMatrixVertical(radius, chn[, matrix])

#include <opencv2/fuzzy/fuzzy_F1_math.hpp>

Creates vertical matrix for \(F^1\)-transform computation.

Parameters
radiusRadius of the basic function.
matrixThe vertical matrix.
chnNumber of channels.

The function creates helper vertical matrix for \(F^1\)-transfrom processing. It is used for gradient computation.

◆ FT12D_inverseFT()

void cv::ft::FT12D_inverseFT ( InputArray  components,
InputArray  kernel,
OutputArray  output,
int  width,
int  height 
)
Python:
output=cv.ft.FT12D_inverseFT(components, kernel, width, height[, output])

#include <opencv2/fuzzy/fuzzy_F1_math.hpp>

Computes inverse \(F^1\)-transfrom.

Parameters
componentsInput 32-bit float single channel array for the components.
kernelKernel used for processing. The same kernel as for components computation must be used.
outputOutput 32-bit float array.
widthWidth of the output array.
heightHeight of the output array.

Computation of inverse \(F^1\)-transform.

◆ FT12D_polynomial()

void cv::ft::FT12D_polynomial ( InputArray  matrix,
InputArray  kernel,
OutputArray  c00,
OutputArray  c10,
OutputArray  c01,
OutputArray  components,
InputArray  mask = noArray() 
)
Python:
c00, c10, c01, components=cv.ft.FT12D_polynomial(matrix, kernel[, c00[, c10[, c01[, components[, mask]]]]])

#include <opencv2/fuzzy/fuzzy_F1_math.hpp>

Computes elements of \(F^1\)-transform components.

Parameters
matrixInput array.
kernelKernel used for processing. Function ft::createKernel can be used.
c00Elements represent average color.
c10Elements represent average vertical gradient.
c01Elements represent average horizontal gradient.
componentsOutput 32-bit float array for the components.
maskMask can be used for unwanted area marking.

The function computes components and its elements using predefined kernel and mask.

◆ FT12D_process()

void cv::ft::FT12D_process ( InputArray  matrix,
InputArray  kernel,
OutputArray  output,
InputArray  mask = noArray() 
)
Python:
output=cv.ft.FT12D_process(matrix, kernel[, output[, mask]])

#include <opencv2/fuzzy/fuzzy_F1_math.hpp>

Computes \(F^1\)-transfrom and inverse \(F^1\)-transfrom at once.

Parameters
matrixInput matrix.
kernelKernel used for processing. Function ft::createKernel can be used.
outputOutput 32-bit float array.
maskMask used for unwanted area marking.

This function computes \(F^1\)-transfrom and inverse \(F^1\)-transfotm in one step. It is fully sufficient and optimized for cv::Mat.

Note
F-transform technique of first degreee is described in paper [252].