| OpenCV 3.4.3 Open Source Computer Vision

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

## 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] | )

Computes components of the array using direct \(F^1\)-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.

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] | )

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

Parameters

  radius | Radius of the basic function.
  matrix | The horizontal matrix.
  chn | Number 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] | )

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

Parameters

  radius | Radius of the basic function.
  matrix | The vertical matrix.
  chn | Number 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] | )

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

Parameters

  components | Input 32-bit float single channel array for the components.
  kernel | Kernel used for processing. The same kernel as for components computation must be used.
  output | Output 32-bit float array.
  width | Width of the output array.
  height | Height 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]]]]] | )

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

Parameters

  matrix | Input array.
  kernel | Kernel used for processing. Function `ft::createKernel` can be used.
  c00 | Elements represent average color.
  c10 | Elements represent average vertical gradient.
  c01 | Elements represent average horizontal gradient.
  components | Output 32-bit float array for the components.
  mask | Mask 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]] | )

Computes \(F^1\)-transfrom and inverse \(F^1\)-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^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 [200].