ColorProcessor C++ library

v1.0.1

Table of contents

• Overview
• Versions
• Library files
• ColorProcessor class description
  • ColorProcessor class declaration
  • getVersion method
  • initVFilter method
  • setParam method
  • getParam method
  • getParams method
  • executeCommand method
  • processFrame method
  • setMask method
  • encodeSetParamCommand method of VFilter class
  • encodeCommand method of VFilter class
  • decodeCommand method of VFilter class
  • decodeAndExecuteCommand method
• Data structures
  • VFilterCommand enum
  • VFilterParam enum
• VFilterParams class description
  • VFilterParams class declaration
  • Serialize VFilter params
  • Deserialize VFilter params
  • Read params from JSON file and write to JSON file
• Build and connect to your project
• Example

Overview

ColorProcessor is a C++ library that implements various color processing operations, including palette adjustments, brightness, contrast, saturation and white balance. The supported palettes for thermal cameras are Inverse (grayscale inversion), Ironbow, Rainbow, and Arctic. Other operations are adjusted in percentage centered in 50% which means no effect. The library depends on VFilter library (provides interface for video filter, source code included, Apache 2.0 license). The library doesn’t have third-party dependencies to be installed in OS. Additionally test application depends on OpenCV library (version >= 4.5, linked, Apache 2.0 license) to provide user interface. The library uses C++17 standard. Example of implemented palettes:

SOURCE	INVERSE
ARCTIC	IRONBOW
RAINBOW

Versions

Table 1 - Library versions.

Version	Release date	What’s new
1.0.0	22.01.2025	- First version.
1.0.1	09.02.2025	- Fix color palette processing.

Library files

The library supplied by source code only. The user would be given a set of files in the form of a CMake project (repository). The repository structure is shown below:

CMakeLists.txt ------------------ Main CMake file of the library.
3rdparty ------------------------ Folder with third-party libraries.
    CMakeLists.txt -------------- CMake file which include third-party libraries.
    VFilter --------------------- Folder with VFilter library source code.
src ----------------------------- Folder with source code of the library.
    CMakeLists.txt -------------- CMake file of the library.
    ColorProcessor.cpp ---------- C++ implementation file.
    ColorProcessor.h ------------ Header file which includes ColorProcessor class declaration.
    ColorProcessorVersion.h ----- Header file which includes version of the library.
    ColorProcessorVersion.h.in -- CMake service file to generate version file.
test ---------------------------- Folder for test application.
    CMakeLists.txt -------------- CMake file for test application.
    main.cpp -------------------- Source code file of the test application.

ColorProcessor class description

ColorProcessor class declaration

The ColorProcessor class declared in ColorProcessor.h file. Class declaration:

namespace cr
{
namespace video
{
class ColorProcessor : public VFilter
{
public:

    /// Get the version of the ColorProcessor class.
    static std::string getVersion();

    /// Initialize ColorProcessor filter with parameters.
    bool initVFilter(VFilterParams& params) override;

    /// Set ColorProcessor filter parameter.
    bool setParam(VFilterParam id, float value) override;

    /// Get the value of a specific ColorProcessor filter parameter.
    float getParam(VFilterParam id) override;

    /// Get the parameters of the ColorProcessor filter.
    void getParams(VFilterParams& params) override;

    /// Execute a ColorProcessor filter action command.
    bool executeCommand(VFilterCommand id) override;

    /// Process frame (Perform ColorProcessor filters : palette, brightness, contrast, white-balance).
    bool processFrame(cr::video::Frame& frame) override;

    /// Set mask for filter. Not supported by ColorProcessor filter.
    bool setMask(cr::video::Frame mask) override;

    /// Decode and execute command.
    bool decodeAndExecuteCommand(uint8_t* data, int size) override;
};
}
}

getVersion method

The getVersion() static method returns string of current class version. Method declaration:

static std::string getVersion();

Method can be used without ColorProcessor class instance:

std::cout << "ColorProcessor version: " << cr::video::ColorProcessor::getVersion();

Console output:

ColorProcessor version: 1.0.0

initVFilter method

The initVFilter(…) method initializes ColorProcessor filter. This method is not necessary for initialization. User can use setParam to change any parameter. Method declaration:

bool initVFilter(VFilterParams& params) override;

Parameter	Value
params	VFilterParams class object. The methods set mode, type, level, custom1, custom2 and custom3 parameters of VFilterParams class.

Returns: TRUE if the video filter initialized or FALSE if not (if one of parameters not set).

setParam method

The setParam (…) method sets new parameters value. The library provides thread-safe setParam(…) method call. This means that the setParam(…) method can be safely called from any thread. Method declaration:

bool setParam(VFilterParam id, float value) override;

Parameter	Description
id	Parameter ID according to VFilterParam enum.
value	Parameter value. Value depends on parameter ID.

Returns: TRUE if the parameter was set or FALSE if not (not supported or has invalid value).

getParam method

The getParam(…) method returns parameter value. The library provides thread-safe getParam(…) method call. This means that the getParam(…) method can be safely called from any thread. Method declaration:

float getParam(VFilterParam id) override;

Parameter	Description
id	Parameter ID according to VFilterParam enum.

Returns: parameter value or -1 if the parameter is not supported.

getParams method

The getParams(…) method is designed to obtain all ColorProcessor filter params. The library provides thread-safe getParams(…) method call. This means that the getParams(…) method can be safely called from any thread. Method declaration:

void getParams(VFilterParams& params) override;

Parameter	Description
params	Reference to VFilterParams object to store params.

executeCommand method

The executeCommand(…) method executes video filter action command. The library provides thread-safe executeCommand(…) method call. This means that the executeCommand(…) method can be safely called from any thread. Method declaration:

bool executeCommand(VFilterCommand id) override;

Parameter	Description
id	Command ID according to VFilterCommand enum.

Returns: TRUE if the command executed or FALSE if not.

processFrame method

The processFrame(…) method designed to process frame (palette, brightness, contrast, saturation and white-balance filters). The method accepts only YUV pixel format (Fourcc::YUV24). The library provides thread-safe processFrame(…) method call. This means that the processFrame(…) method can be safely called from any thread. Method declaration:

bool processFrame(cr::video::Frame& frame) override;

Parameter	Description
frame	Reference to Frame object. The method accepts only YUV pixel format (Fourcc::YUV24).

Returns: TRUE if frame processed (filters are applied) or FALSE if not. If filter disabled the method will return TRUE without video frame processing.

setMask method

The setMask(…) method designed to set video filter mask. Mask not supported by ColorProcessor class. Method declaration:

bool setMask(cr::video::Frame mask) override;

Parameter	Description
mask	Filter mask is Frame object with GRAY pixel format. Mask not supported by ColorProcessor class.

Returns: TRUE in any cases.

encodeSetParamCommand method of VFilter class

The encodeSetParamCommand(…) static method encodes command to change any VFilter parameter value remote. To control any video filter remotely, the developer has to design his own protocol and according to it encode the command and deliver it over the communication channel. To simplify this, the VFilter class contains static methods for encoding the control command. The VFilter class provides two types of commands: a parameter change command (SET_PARAM) and an action command (COMMAND). encodeSetParamCommand(…) designed to encode SET_PARAM command. Method declaration:

static void encodeSetParamCommand(uint8_t* data, int& size, VFilterParam id, float value);

Parameter	Description
data	Pointer to data buffer for encoded command. Must have size >= 11.
size	Size of encoded data. Size will be 11 bytes.
id	Parameter ID according to VFilterParam enum.
value	Parameter value.

encodeSetParamCommand(…) is static and can be used without VFilter class instance. This method used on client side (control system). Command encoding example:

// Buffer for encoded data.
uint8_t data[11];
// Size of encoded data.
int size = 0;
// Encode command.
VFilter::encodeSetParamCommand(data, size, VFilterParam::TYPE, 2);

encodeCommand method of VFilter class

The encodeCommand(…) static method encodes action command for VFilter remote control. To control any video filter remotely, the developer has to design his own protocol and according to it encode the command and deliver it over the communication channel. To simplify this, the VFilter class contains static methods for encoding the control command. The VFilter class provides two types of commands: a parameter change command (SET_PARAM) and an action command (COMMAND). encodeCommand(…) designed to encode COMMAND (action command). Method declaration:

static void encodeCommand(uint8_t* data, int& size, VFilterCommand id);

Parameter	Description
data	Pointer to data buffer for encoded command. Must have size >= 7.
size	Size of encoded data. Size will be 7 bytes.
id	Command ID according to VFilterCommand enum.

encodeCommand(…) is static and can be used without VFilter class instance. This method used on client side (control system). Command encoding example:

// Buffer for encoded data.
uint8_t data[7];
// Size of encoded data.
int size = 0;
// Encode command.
VFilter::encodeCommand(data, size, VFilterCommand::RESTART);

decodeCommand method of VFilter class

The decodeCommand(…) static method decodes command on video filter side (on edge device). Method declaration:

static int decodeCommand(uint8_t* data, int size, VFilterParam& paramId, VFilterCommand& commandId, float& value);

Parameter	Description
data	Pointer to input command.
size	Size of command. Must be 11 bytes for SET_PARAM and 7 bytes for COMMAND (action command).
paramId	VFilter parameter ID according to VFilterParam enum. After decoding SET_PARAM command the method will return parameter ID.
commandId	VFilter command ID according to VFilterCommand enum. After decoding COMMAND the method will return command ID.
value	VFilter parameter value (after decoding SET_PARAM command).

Returns: 0 - in case decoding COMMAND (action command), 1 - in case decoding SET_PARAM command or -1 in case errors.

decodeAndExecuteCommand method

The decodeAndExecuteCommand(…) method decodes and executes command encoded by encodeSetParamCommand(…) and encodeCommand(…) methods on video filter side. The library provides thread-safe decodeAndExecuteCommand(…) method call. This means that the decodeAndExecuteCommand(…) method can be safely called from any thread. Method declaration:

bool decodeAndExecuteCommand(uint8_t* data, int size) override;

Parameter	Description
data	Pointer to input command.
size	Size of command. Must be 11 bytes for SET_PARAM or 7 bytes for COMMAND.

Returns: TRUE if command decoded (SET_PARAM or COMMAND) and executed (action command or set param command).

Data structures

VFilterCommand enum

Enum declaration:

enum class VFilterCommand
{
    /// Reset image filter algorithm.
    RESET = 1,
    /// Enable filter.
    ON,
    /// Disable filter.
    OFF
};

Table 2 - Action commands description.

Command	Description
RESET	Reset all adjustment levels to neutral (50% of contrast, brightness, saturation and white balance also disable palette).
ON	Enable ColorProcessor filter. Turn on processing.
OFF	Disable ColorProcessor filter. Turn off processing.

VFilterParam enum

Enum declaration:

enum class VFilterParam
{
    /// Current filter mode, usually 0 - off, 1 - on.
    MODE = 1,
    /// Enhancement level for particular filter, as a percentage in range from 
    /// 0% to 100%.
    LEVEL,
    /// Processing time in microseconds. Read only parameter.
    PROCESSING_TIME_MCSEC,
    /// Type of the filter. Depends on the implementation.
    TYPE,
    /// VFilter custom parameter. Custom parameters used when particular image 
    /// filter has specific unusual parameter.
    CUSTOM_1,
    /// VFilter custom parameter. Custom parameters used when particular image 
    /// filter has specific unusual parameter.
    CUSTOM_2,
    /// VFilter custom parameter. Custom parameters used when particular image 
    /// filter has specific unusual parameter.
    CUSTOM_3
};

Table 3 - Params description.

Parameter	Access	Description
MODE	read / write	ColorProcessor mode: 0 - disabled, 1 - enabled.
LEVEL	read / write	White-balance level in percentage, 50% means neutral effec.
PROCESSING_TIME_MCSEC	read only	Processing time in microseconds. Read only parameter. Used to check performance of ColorProcessor filter.
TYPE	read / write	Palette type: 0 - [DEFAULT] Original. 1 - Inverse. 2 - Ironbow. 3 - Rainbow. 4 - Arctic.
CUSTOM_1	read / write	Brightness adjustment level in percentage, 50% means neutral effect.
CUSTOM_2	read / write	Contrast adjustment level in percentage, 50% means neutral effect.
CUSTOM_3	read / write	Saturation adjustment level in percentage, 50% means neutral effect.

VFilterParams class description

VFilterParams class declaration

The VFilterParams class is used to provide video filter parameters structure. Also VFilterParams provides possibility to write/read params from JSON files (JSON_READABLE macro) and provides methods to encode and decode params. VFilterParams interface class declared in VFilter.h file. Class declaration:

class VFilterParams
{
public:
    /// Current filter mode, usually 0 - off, 1 - on.
    int mode{ 0 };
    /// Enhancement level for particular filter, as a percentage in range from 
    /// 0% to 100%.
    float level{ 0 };
    /// Processing time in microseconds. Read only parameter.
    int processingTimeMcSec{ 0 };
    /// Type of the filter. Depends on the implementation.
    int type{ 0 };
    /// VFilter custom parameter. Custom parameters used when particular image 
    /// filter has specific unusual parameter.
    float custom1{ 0.0f };
    /// VFilter custom parameter. Custom parameters used when particular image 
    /// filter has specific unusual parameter.
    float custom2{ 0.0f };
    /// VFilter custom parameter. Custom parameters used when particular image 
    /// filter has specific unusual parameter.
    float custom3{ 0.0f };

    /// Macro from ConfigReader to make params readable/writable from JSON.
    JSON_READABLE(VFilterParams, mode, level, type, custom1, custom2, custom3)

    /// operator =
    VFilterParams& operator= (const VFilterParams& src);

    // Encode (serialize) params.
    bool encode(uint8_t* data, int bufferSize, int& size,
                                             VFilterParamsMask* mask = nullptr);
    // Decode (deserialize) params.
    bool decode(uint8_t* data, int dataSize);
};

Table 4 - VFilterParams class fields description is related to VFilterParam enum description.

Field	type	Description
mode	int	ColorProcessor mode: 0 - disabled, 1 - enabled.
level	float	White-balance level in percentage, 50% means neutral effect.
processingTimeMcSec	int	Processing time in microseconds. Read only parameter. Used to check performance of ColorProcessor filter.
type	int	Palette type: 0 - [DEFAULT] Original. 1 - Inverse. 2 - Ironbow. 3 - Rainbow. 4 - Arctic.
custom1	float	Brightness adjustment level in percentage, 50% means neutral effect.
custom2	float	Contrast adjustment level in percentage, 50% means neutral effect.
custom3	float	Saturation adjustment level in percentage, 50% means neutral effect.

None: VFilterParams class fields listed in Table 4 have to reflect params set/get by methods setParam(…) and getParam(…).

Serialize VFilter params

VFilterParams class provides method encode(…) to serialize VFilter params. Serialization of VFilterParams is necessary in case when video filter parameters have to be sent via communication channels. Method provides options to exclude particular parameters from serialization. To do this method inserts binary mask (1 byte) where each bit represents particular parameter and decode(…) method recognizes it. Method declaration:

bool encode(uint8_t* data, int bufferSize, int& size, VFilterParamsMask* mask = nullptr);

Parameter	Value
data	Pointer to data buffer. Buffer size must be >= 32 bytes.
bufferSize	Data buffer size. Buffer size must be >= 32 bytes.
size	Size of encoded data.
mask	Parameters mask - pointer to VFilterParamsMask structure. VFilterParamsMask (declared in VFilter.h file) determines flags for each field (parameter) declared in VFilterParams class. If user wants to exclude any parameters from serialization, he can put a pointer to the mask. If the user wants to exclude a particular parameter from serialization, he should set the corresponding flag in the VFilterParamsMask structure.

Returns: TRUE if params encoded (serialized) or FALSE if not (buffer size < 32).

VFilterParamsMask structure declaration:

struct VFilterParamsMask
{
    bool mode{ true };
    bool level{ true };
    bool processingTimeMcSec{ true };
    bool type{ true };
    bool custom1{ true };
    bool custom2{ true };
    bool custom3{ true };
};

Example without parameters mask:

// Prepare parameters.
cr::video::VFilterParams params;
params.level = 80.0f;

// Encode (serialize) params.
int bufferSize = 128;
uint8_t buffer[128];
int size = 0;
params.encode(buffer, bufferSize, size);

Example with parameters mask:

// Prepare parameters.
cr::video::VFilterParams params;
params.level = 80.0;

// Prepare mask.
cr::video::VFilterParams mask;
// Exclude level.
mask.level = false;

// Encode (serialize) params.
int bufferSize = 128;
uint8_t buffer[128];
int size = 0;
params1.encode(buffer, bufferSize, size, &mask);

Deserialize VFilter params

VFilterParams class provides method decode(…) to deserialize params. Deserialization of VFilterParams is necessary in case when it is needed to receive params via communication channels. Method automatically recognizes which parameters were serialized by encode(…) method. Method declaration:

bool decode(uint8_t* data, int dataSize);

Parameter	Value
data	Pointer to data buffer with serialized params.
dataSize	Size of command data.

Returns: TRUE if params decoded (deserialized) or FALSE if not.

Example:

// Prepare parameters.
cr::video::VFilterParams params1;
params1.level = 80;

// Encode (serialize) params.
int bufferSize = 128;
uint8_t buffer[128];
int size = 0;
params1.encode(buffer, bufferSize, size);

// Decode (deserialize) params.
cr::video::VFilterParams params2;
params2.decode(buffer, size);

Read params from JSON file and write to JSON file

VFilter depends on open source ConfigReader library which provides method to read params from JSON file and to write params to JSON file. Example of writing and reading params to JSON file:

// Prepare random params.
cr::video::VFilterParams params1;
params1.mode = 1;
params1.level = 10.1f;
params1.processingTimeMcSec = 10;
params1.type = 2;
params1.custom1 = 22.3;
params1.custom2 = 23.4;
params1.custom3 = 24.5;

// Save to JSON.
cr::utils::ConfigReader configReader1;
if (!configReader1.set(params1, "Params"))
    std::cout << "Can't set params" << std::endl;
if (!configReader1.writeToFile("VFilterParams.json"))
    std::cout << "Can't write to file" << std::endl;

// Read params from file.
cr::utils::ConfigReader configReader2;
if (!configReader2.readFromFile("VFilterParams.json"))
    std::cout << "Can't read from file" << std::endl;
cr::video::VFilterParams params2;
if (!configReader2.get(params2, "Params"))
    std::cout << "Can't get params" << std::endl;

VFilterParams.json will look like:

{
    "Params": {
        "custom1": 22.3,
        "custom2": 23.4,
        "custom3": 24.5,
        "level": 10.1,
        "mode": 1,
        "type": 2
    }
}

Build and connect to your project

Typical commands to build ColorProcessor:

cd ColorProcessor
mkdir build
cd build
cmake ..
make

By default the test application will be built. To exclude test application from compiling change _COLOR_PROCESSOR_TEST variable to OFF on CMakeLists.txt. To build test application in Linux the user must install OpenCV library by command: sudo apt-get install libopencv-dev. If you want connect ColorProcessor to your CMake project as source code you can make follow. For example, if your repository has structure:

CMakeLists.txt
src
    CMakeList.txt
    yourLib.h
    yourLib.cpp

Create folder 3rdparty in your repository and copy ColorProcessor repository folder there. New structure of your repository:

CMakeLists.txt
src
    CMakeList.txt
    yourLib.h
    yourLib.cpp
3rdparty
    ColorProcessor

Create CMakeLists.txt file in 3rdparty folder. CMakeLists.txt should contain:

cmake_minimum_required(VERSION 3.13)

################################################################################
## 3RD-PARTY
## dependencies for the project
################################################################################
project(3rdparty LANGUAGES CXX)

################################################################################
## SETTINGS
## basic 3rd-party settings before use
################################################################################
# To inherit the top-level architecture when the project is used as a submodule.
SET(PARENT ${PARENT}_YOUR_PROJECT_3RDPARTY)
# Disable self-overwriting of parameters inside included subdirectories.
SET(${PARENT}_SUBMODULE_CACHE_OVERWRITE OFF CACHE BOOL "" FORCE)

################################################################################
## CONFIGURATION
## 3rd-party submodules configuration
################################################################################
SET(${PARENT}_SUBMODULE_COLOR_PROCESSOR                 ON  CACHE BOOL "" FORCE)
if (${PARENT}_SUBMODULE_COLOR_PROCESSOR)
    SET(${PARENT}_COLOR_PROCESSOR                       ON  CACHE BOOL "" FORCE)
    SET(${PARENT}_COLOR_PROCESSOR_TEST                  OFF CACHE BOOL "" FORCE)
endif()

################################################################################
## INCLUDING SUBDIRECTORIES
## Adding subdirectories according to the 3rd-party configuration
################################################################################
if (${PARENT}_SUBMODULE_COLOR_PROCESSOR)
    add_subdirectory(ColorProcessor)
endif()

File 3rdparty/CMakeLists.txt adds folder ColorProcessor to your project and excludes test application from compiling (by default test application excluded from compiling if ColorProcessor included as sub-repository). Your repository new structure will be:

CMakeLists.txt
src
    CMakeList.txt
    yourLib.h
    yourLib.cpp
3rdparty
    CMakeLists.txt
    ColorProcessor

Next you need include folder 3rdparty in main CMakeLists.txt file of your repository. Add string at the end of your main CMakeLists.txt:

add_subdirectory(3rdparty)

Next you have to include ColorProcessor library in your src/CMakeLists.txt file:

target_link_libraries(${PROJECT_NAME} ColorProcessor)

Done!

Example

The simple example application shows how to process images by ColorProcessor. The example creates window and sliders to control parameters. The example is using OpenCV library to provide user interface. Source code:

#include <iostream>
#include <cstdint>
#include <string.h>
#include <opencv2/opencv.hpp>
#include "ColorProcessor.h"

// Link namespaces.
using namespace cv;
using namespace std;
using namespace cr::video;

/// Brightness level (scaled 0-100). Default 50 - no change.
int g_brightness = 50;
/// Contrast level (scaled 0-100). Default 50 - no change.
int g_contrast = 50;
/// Saturation level (scaled 0-100). Default 50 - no change.
int g_saturation = 50;
/// White balance level (scaled 0-100). Default 50 - no change.
int g_whiteBalance = 50;
/// Color processor.
ColorProcessor g_colorProcessor;

/// Trackbar callback.
void onTrackbarChange(int, void* userData)
{
    // Set params.
    g_colorProcessor.setParam(VFilterParam::CUSTOM_1, (float)g_brightness);
    g_colorProcessor.setParam(VFilterParam::CUSTOM_2, (float)g_contrast);
    g_colorProcessor.setParam(VFilterParam::CUSTOM_3, (float)g_saturation);
    g_colorProcessor.setParam(VFilterParam::LEVEL, (float)g_whiteBalance);
}

// Entry point.
int main()
{
    cout << "ColorProcessor v" << ColorProcessor::getVersion() << endl;

    // Set image name.
    string fileName = "";
    cout << "Set image file name: ";
    cin >> fileName;

    // Open Image.
    Mat srcImg = imread(fileName, IMREAD_COLOR);
    if (srcImg.empty())
    {
        cout << "Can't open image" << endl;
        return -1;
    }

    // Init windows and trackbars.
    namedWindow("ColorProcessor", WINDOW_AUTOSIZE);
    createTrackbar("Brightness", "ColorProcessor", &g_brightness, 100, onTrackbarChange);
    createTrackbar("Contrast", "ColorProcessor", &g_contrast, 100, onTrackbarChange);
    createTrackbar("Saturation", "ColorProcessor", &g_saturation, 100, onTrackbarChange);
    createTrackbar("White balance", "ColorProcessor", &g_whiteBalance, 100, onTrackbarChange);

    // Enable processing.
    g_colorProcessor.setParam(VFilterParam::MODE, 1);

    // Main loop.
    while (true)
    {
        // Convert BGR to YUV (necessary for ColorProcessor).
        Mat frameOpenCv;
        cvtColor(srcImg, frameOpenCv, COLOR_BGR2YUV);

        // Prepare Frame object without copy data.
        Frame frame;
        frame.width = frameOpenCv.cols;
        frame.height = frameOpenCv.rows;
        frame.size = frame.width * frame.height * 3;
        frame.data = frameOpenCv.data; // Pointer to frame data.
        frame.fourcc = Fourcc::YUV24;

        // Process frame.
        g_colorProcessor.processFrame(frame);

        // Get current params.
        VFilterParams params;
        g_colorProcessor.getParams(params);

        // Convert YUV to BGR.
        Mat resultFrame(frame.height, frame.width, CV_8UC3, frame.data);
        cvtColor(resultFrame, frameOpenCv, COLOR_YUV2BGR);

        string paletteType;
        switch (params.type) 
        {
            case 0: paletteType = "Original"; break;
            case 1: paletteType = "Inverse"; break;
            case 2: paletteType = "Ironbow"; break;
            case 3: paletteType = "Rainbow"; break;
            case 4: paletteType = "Arctic"; break;
            default: paletteType = "Inverse"; break;
        }

        // Show params.
        putText(frameOpenCv, "[button 1 to change] Palette: " + paletteType,
        Point(5, 20), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255, 255, 0));
        putText(frameOpenCv, "[SPACE to change] Mode: " + string(params.mode == 1 ? "On" : "Off"),
        Point(5, 40), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255, 255, 0));
        putText(frameOpenCv, "Processing time: " + to_string(params.processingTimeMcSec) + " usec",
        Point(5, 60), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255, 255, 0));
        putText(frameOpenCv, "[ESC to exit]",
        Point(5, 80), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255, 255, 0));

        // Show result frame.
        imshow("ColorProcessor", frameOpenCv);

        // Process keyboard events.
        switch (waitKey(30))
        {
        case 27: // ESC.
            return 1;
        case 32: // SPACE.
            g_colorProcessor.setParam(VFilterParam::MODE, 1.0f - (float)params.mode);
            break;
        case 49: // 1.
            params.type++;
            if (params.type > 4)
                params.type = 0;
            g_colorProcessor.setParam(VFilterParam::TYPE, (float)params.type);
            break;
        }
    }
    return 0;
}

Example user interface:

---

Table of contents