| OpenCV 3.4.8 Open Source Computer Vision

Functions
Math with F0-transform support
Image processing based on fuzzy mathematics

## Functions
void | cv::ft::FT02D_components (InputArray matrix, InputArray kernel, OutputArray components, InputArray mask=noArray())
| Computes components of the array using direct \(F^0\)-transform. More...
void | cv::ft::FT02D_FL_process (InputArray matrix, const int radius, OutputArray output)
| Sligtly less accurate version of \(F^0\)-transfrom computation optimized for higher speed. The methods counts with linear basic function. More...
void | cv::ft::FT02D_FL_process_float (InputArray matrix, const int radius, OutputArray output)
| Sligtly less accurate version of \(F^0\)-transfrom computation optimized for higher speed. The methods counts with linear basic function. More...
void | cv::ft::FT02D_inverseFT (InputArray components, InputArray kernel, OutputArray output, int width, int height)
| Computes inverse \(F^0\)-transfrom. More...
int | cv::ft::FT02D_iteration (InputArray matrix, InputArray kernel, OutputArray output, InputArray mask, OutputArray maskOutput, bool firstStop)
| Computes \(F^0\)-transfrom and inverse \(F^0\)-transfrom at once and return state. More...
void | cv::ft::FT02D_process (InputArray matrix, InputArray kernel, OutputArray output, InputArray mask=noArray())
| Computes \(F^0\)-transfrom and inverse \(F^0\)-transfrom at once. More...

## Detailed Description

Fuzzy transform ( \(F^0\)-transform) of the 0th degree transforms whole image to a matrix of its components. These components are used in latter computation where each of them represents average color of certain subarea.

## Function Documentation

## § FT02D_components()

void cv::ft::FT02D_components | ( | InputArray | matrix,
|  | InputArray | kernel,
|  | OutputArray | components,
|  | InputArray | mask = `noArray()`
| ) |  |

Python:
| components | = | cv.ft.FT02D_components( | matrix, kernel[, components[, mask]] | )

`#include <opencv2/fuzzy/fuzzy_F0_math.hpp>`

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

Parameters

  matrix | Input array.
  kernel | Kernel used for processing. Function `ft::createKernel` can be used.
  components | Output 32-bit float array for the components.
  mask | Mask can be used for unwanted area marking.

The function computes components using predefined kernel and mask.

## § FT02D_FL_process()

void cv::ft::FT02D_FL_process | ( | InputArray | matrix,
|  | const int | radius,
|  | OutputArray | output
| ) |  |

Python:
| output | = | cv.ft.FT02D_FL_process( | matrix, radius[, output] | )

`#include <opencv2/fuzzy/fuzzy_F0_math.hpp>`

Sligtly less accurate version of \(F^0\)-transfrom computation optimized for higher speed. The methods counts with linear basic function.

Parameters

  matrix | Input 3 channels matrix.
  radius | Radius of the `ft::LINEAR` basic function.
  output | Output array.

This function computes F-transfrom and inverse F-transfotm using linear basic function in one step. It is ~10 times faster than `ft::FT02D_process` method.

## § FT02D_FL_process_float()

void cv::ft::FT02D_FL_process_float | ( | InputArray | matrix,
|  | const int | radius,
|  | OutputArray | output
| ) |  |

Python:
| output | = | cv.ft.FT02D_FL_process_float( | matrix, radius[, output] | )

`#include <opencv2/fuzzy/fuzzy_F0_math.hpp>`

Sligtly less accurate version of \(F^0\)-transfrom computation optimized for higher speed. The methods counts with linear basic function.

Parameters

  matrix | Input 3 channels matrix.
  radius | Radius of the `ft::LINEAR` basic function.
  output | Output array.

This function computes F-transfrom and inverse F-transfotm using linear basic function in one step. It is ~9 times faster then `ft::FT02D_process` method and more accurate than `ft::FT02D_FL_process` method.

## § FT02D_inverseFT()

void cv::ft::FT02D_inverseFT | ( | InputArray | components,
|  | InputArray | kernel,
|  | OutputArray | output,
|  | int | width,
|  | int | height
| ) |  |

Python:
| output | = | cv.ft.FT02D_inverseFT( | components, kernel, width, height[, output] | )

`#include <opencv2/fuzzy/fuzzy_F0_math.hpp>`

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

Parameters

  components | Input 32-bit float single channel array for the components.
  kernel | Kernel used for processing. Function `ft::createKernel` can be used.
  output | Output 32-bit float array.
  width | Width of the output array.
  height | Height of the output array.

Computation of inverse F-transform.

## § FT02D_iteration()

int cv::ft::FT02D_iteration | ( | InputArray | matrix,
|  | InputArray | kernel,
|  | OutputArray | output,
|  | InputArray | mask,
|  | OutputArray | maskOutput,
|  | bool | firstStop
| ) |  |

Python:
| retval, output, maskOutput | = | cv.ft.FT02D_iteration( | matrix, kernel, mask, firstStop[, output[, maskOutput]] | )

`#include <opencv2/fuzzy/fuzzy_F0_math.hpp>`

Computes \(F^0\)-transfrom and inverse \(F^0\)-transfrom at once and return state.

Parameters

  matrix | Input matrix.
  kernel | Kernel used for processing. Function `ft::createKernel` can be used.
  output | Output 32-bit float array.
  mask | Mask used for unwanted area marking.
  maskOutput | Mask after one iteration.
  firstStop | If true function returns -1 when first problem appears. In case of `false` the process is completed and summation of all problems returned.

This function computes iteration of F-transfrom and inverse F-transfotm and handle image and mask change. The function is used in `ft::inpaint` function.

## § FT02D_process()

void cv::ft::FT02D_process | ( | InputArray | matrix,
|  | InputArray | kernel,
|  | OutputArray | output,
|  | InputArray | mask = `noArray()`
| ) |  |

Python:
| output | = | cv.ft.FT02D_process( | matrix, kernel[, output[, mask]] | )

`#include <opencv2/fuzzy/fuzzy_F0_math.hpp>`

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

Parameters

  matrix | Input matrix.
  kernel | Kernel used for processing. Function `ft::createKernel` can be used.
  output | Output 32-bit float array.
  mask | Mask used for unwanted area marking.

This function computes F-transfrom and inverse F-transfotm in one step. It is fully sufficient and optimized for `cv::Mat`.