Aidge backend OpenCV API#

The OpenCV backend provides its own operators and is particularly useful for data pre-processing. It is possible to create pre-processing pipelines using the same graph IR as Aidge core.

Operators specific to the OpenCV backend are usually suffixed by Transformation.

Example:

aidge_database = aidge_backend_opencv.CIFAR10(data_path="/local/DATABASE/cifar-10-batches-bin", train=True)
aidge_dataprovider = aidge_core.DataProvider(aidge_database,
                                          backend=BACKEND,
                                          batch_size=BATCH_SIZE,
                                          shuffle=True,
                                          drop_last=True)

aidge_dataprovider.transforms(0, aidge_core.sequential([
      aidge_backend_opencv.FlipTransformation(True, True)
   ]))

About ROI interface #

This backend also includes a ROI handling and transformation mechanism. The goal is to allow easy and efficient data augmentation for objects detector training. It will be possible to apply the same pre-processing pipeline to images, pixel-wise labels and ROI labels seamlessly.

Example:

import aidge_core
import aidge_backend_opencv as aicv
import numpy as np

# Image pre-processing flow
preproc = aidge_core.sequential([
   aicv.RandomFlipTransformation(0.5, 0.5)
])

a = aidge_core.Tensor(np.zeros([32, 32], dtype=np.float32))
a.to_backend("opencv")

scheduler = aidge_core.SequentialScheduler(preproc)
scheduler.forward(forward_dims=False, data=[a])[0]

# ROI pre-processing flow
preproc_roi = aicv.ROIGraph(preproc)

r = aicv.CircularROI(1, (1, 2), 3.0)
rois = aicv.ROIs([32, 32])
rois.data = [r]

scheduler = aidge_core.SequentialScheduler(preproc_roi)
out = scheduler.forward(forward_dims=False, data=[rois])[0]

print(out.data[0])

Synchronization between different modalities flow (image and ROI for example) is done with shared Producer_Op for random transformations. The ROI flow can be automatically constructed from the image flow with the ROIGraph method: preproc_roi = aicv.ROIGraph(preproc). The shared Producer_Op output value is set by a forward hook applied to the image flow Producer operator.

        %%{init: {'flowchart': { 'curve': 'monotoneY'}, 'fontFamily': 'Verdana' } }%%
flowchart TB

   subgraph shared operator
      Producer_0("<em>Producer#0</em>"):::producerCls_rootCls
      Producer_roi_0("<em>Producer#0</em>"):::producerCls
   end
   subgraph shared operator
      Producer_1("<em>Producer#1</em>"):::producerCls_rootCls
      Producer_roi_1("<em>Producer#1</em>"):::producerCls
   end
   FlipTransformation_0("<em>FlipTransformation#0</em>")
   Producer_0-->|"0 [1] boolean<br/>&darr;<br/>1"|FlipTransformation_0
   Producer_1-->|"0 [1] boolean<br/>&darr;<br/>2"|FlipTransformation_0
   input0((in#0)):::inputCls--->|" [32, 32] float32<br/>&darr;<br/>0"|FlipTransformation_0
   FlipTransformation_0--->|"0 [32, 32] float32<br/>&darr;"|output0((out#0)):::outputCls
   classDef inputCls fill:#afa
   classDef outputCls fill:#ffa
   classDef externalCls fill:#ccc
   classDef producerCls fill:#ccf
   classDef genericCls fill:#f9f9ff,stroke-width:1px,stroke-dasharray: 5 5
   classDef metaCls stroke-width:5px
   classDef rootCls stroke:#f00
   classDef producerCls_rootCls stroke:#f00,fill:#ccf
   classDef genericCls_rootCls stroke:#f00,fill:#f9f9ff,stroke-width:1px,stroke-dasharray: 5 5
   classDef metaCls_rootCls stroke:#f00,stroke-width:5px

   FlipTransformation_ROI_0("<em>FlipTransformation_ROI#0</em>")
   Producer_roi_1-->|"0 [1] boolean<br/>&darr;<br/>1"|FlipTransformation_ROI_0
   Producer_roi_0-->|"0 [1] boolean<br/>&darr;<br/>2"|FlipTransformation_ROI_0
   input_roi0((in#0)):::inputCls--->|"&darr;<br/>0"|FlipTransformation_ROI_0
   FlipTransformation_ROI_0--->|"0<br/>&darr;"|output_roi0((out#0)):::outputCls

Databases #

MNIST #

Python

class aidge_backend_opencv.MNIST#

__init__(self: aidge_backend_opencv.aidge_backend_opencv.MNIST, dataPath: str, train: bool, load_data_in_memory: bool = False) → None#

get_item(self: aidge_core.aidge_core.Database, index: SupportsInt) → list[Aidge::Tensor]#

get_nb_modalities(self: aidge_core.aidge_core.Database) → int#

len(self: aidge_core.aidge_core.Database) → int#

C++

class MNIST : public Aidge::Database #

Public Types

enum DataType#

Values:

enumerator Unsigned#

enumerator Signed#

enumerator Short#

enumerator Int#

enumerator Float#

enumerator Double#

Public Functions

inline MNIST(const std::string &dataPath, bool train, bool loadDataInMemory = false)#: Data Transformations.

~MNIST() noexcept#

virtual std::vector<std::shared_ptr<Tensor>> getItem(const std::size_t index) const final override#

Fetch an item of the database.

Parameters:: index – index of the item.
Returns:: vector of data mapped to index.

inline virtual std::size_t getLen() const noexcept final override#

Get the number of items in the database.

Returns:: std::size_t

inline virtual std::size_t getNbModalities() const noexcept final override#

Get the number of modalities in one database item.

Returns:: std::size_t

union MagicNumber#

Public Members

std::uint32_t value#

std::uint8_t byte[4]#

UTILS #

Tensor Aidge::cvMatToTensor(const cv::Mat &mat)#

Instantiate an aidge tensor with backend “opencv” from an opencv matrix.

Parameters:: mat – the cv::mat to instantiate the tensor from
Returns:: Tensor aidge tensor

void Aidge::cvMatToTensor(const cv::Mat &mat, Tensor &tensor)#

Aidge backend OpenCV API#

About ROI interface #

Predefined operators #

AffineTransformation #

CentroidCropTransformation #

ChannelExtractionTransformation #

ColorSpaceTransformation #

CompressionNoiseTransformation #

CropTransformation #

FlipTransformation #

PadCropTransformation #

RangeAffineTransformation #

RescaleTransformation #

SliceExtractionTransformation #

TrimTransformation #

Predefined operators acting on ROI #

CropTransformation_ROI #

FlipTransformation_ROI #

PadCropTransformation_ROI #

RescaleTransformation_ROI #

SliceExtractionTransformation_ROI #

Databases #

MNIST #

UTILS #

This Page