viscacamera_web_logo

ViscaCamera C++ library

v1.0.3

Overview
Versions
Library files
ViscaCamera class description
Data structures
LensParams class description
CameraParams class description
PanTiltParams class description
Build and connect to your project
Simple example
Test application

Overview

The ViscaCamera C++ library is a software controller for VISCA (Trademark of Sony Corporation) compatible cameras and includes camera, lens and pan-tilt control interfaces. The ViscaCamera library inherits Lens, Camera and PanTilt interfaces, so the library has set of three different interfaces to control camera, lens and pan-tilt. It depends on libraries: Lens (provides interface and data structures to control lenses, source code included, Apache 2.0 license), PanTilt (provides interface and data structures to control pan-tilt units, source code included, Apache 2.0 license), Camera (provides interface and data structures to control cameras, source code included, Apache 2.0 license), Logger (provides function to print logs, source code included, Apache 2.0 license), SerialPort (provides functions to work with serial ports, source code included, Apache 2.0 license) and ViscaParser library (provides functions to encode control commands and decode responses from VISCA-compatible cameras, source code included). The ViscaCamera library provides simple interface to be integrated in any C++ projects. The library repository (folder) provided by source code and doesn’t have third-party dependencies to be specially installed in OS. It developed with C++17 standard and compatible with Linux and Windows.

Versions

Table 1 - Library versions.

Version	Release date	What’s new
1.0.0	21.02.2024	- First version of the library.
1.0.1	22.04.2024	- Documentation update.
1.0.2	24.05.2024	- Documentation update. - Submodules updated.
1.0.3	07.08.2024	- CMake structure updated.

Library files

The library is provided as source code only. Users are given a set of files in the form of a CMake project (repository). The repository structure is outlined below:

CMakeLists.txt --------------- Main CMake file of the library.
3rdparty --------------------- Folder with third-party libraries.
    CMakeLists.txt ----------- CMake file which includes third-party libraries.
    Camera ------------------- Folder with the Camera library source code.
    ViscaParser -------------- Folder with the ViscaParser library source code.
    Lens --------------------- Folder with the Lens library source code.
    Logger ------------------- Folder with the Logger library source code.
    SerialPort --------------- Folder with the SerialPort library source code.
src -------------------------- Folder with source code of the library.
    CMakeLists.txt ----------- CMake file of the library.
    ViscaCamera.cpp ---------- Source code file of the library.
    ViscaCamera.h ------------ Header file which includes ViscaCamera class declaration.
    ViscaCameraVersion.h ----- Header file which includes version of the library.
    ViscaCameraVersion.h.in -- CMake service file to generate version file.
test ------------------------- Folder with test application.
    CMakeLists.txt ----------- CMake file for test application.
    main.cpp ----------------- Source code file of test application.
example ---------------------- Folder with example application.
    CMakeLists.txt ----------- CMake file for example application.
    main.cpp ----------------- Source code file of example application.

ViscaCamera class description

ViscaCamera class declaration

ViscaCamera interface class declared in ViscaCamera.h file. The ViscaCamera class includes Lens, Camera and PanTilt interfaces. Class declaration:

class ViscaCamera : public cr::camera::Camera, public cr::lens::Lens, public cr::pantilt::PanTilt
{
public:

    /// Class constructor.
    ViscaCamera();

    /// Class destructor.
    ~ViscaCamera();

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

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

    // #######################################
    // CAMERA CONTROL INTERFACE
    // #######################################

    /// Open controller serial port.
    bool openCamera(std::string initString) override;

    /// Init camera by parameters structure.
    bool initCamera(cr::camera::CameraParams& params) override;

    /// Method closes serial port and stops all threads.
    void closeCamera() override;

    /// Get serial port status.
    bool isCameraOpen() override;

    /// Get camera connection status.
    bool isCameraConnected() override;

    /// Set the camera parameter.
    bool setParam(cr::camera::CameraParam id, float value) override;

    /// Get the camera parameter.
    float getParam(cr::camera::CameraParam id) override;

    /// Get the camera params.
    void getParams(cr::camera::CameraParams& params) override;

    /// Execute camera command.
    bool executeCommand(cr::camera::CameraCommand id) override;

    // #######################################
    // LENS CONTROL INTERFACE
    // #######################################

    /// Open controller serial port.
    bool openLens(std::string initString) override;

    /// Init lens by parameters structure.
    bool initLens(cr::lens::LensParams& params) override;

    /// Closes serial port and stops all threads.
    void closeLens() override;

    /// Get serial port status.
    bool isLensOpen() override;

    /// Get camera connection status.
    bool isLensConnected() override;

    /// Set lens parameter.
    bool setParam(cr::lens::LensParam id, float value) override;

    /// Get lens parameter.
    float getParam(cr::lens::LensParam id) override;

    /// Get the lens parameters.
    void getParams(cr::lens::LensParams& params) override;

    /// Execute lens command.
    bool executeCommand(cr::lens::LensCommand id, float arg = 0) override;

    /// Add video frame for auto focus purposes. Not supported.
    void addVideoFrame(cr::video::Frame& frame) override;
    
    // #######################################
    // PANTILT CONTROL INTERFACE
    // #######################################
    
 	/// Open pan-tilt device.
    bool openPanTilt(std::string initString) override;

	/// Init pan-tilt device with parameters structure.
    bool initPanTilt(cr::pantilt::PanTiltParams& params) override;

	/// Close pan-tilt controller connection.
    void closePanTilt() override;

    /// Get pan-tilt controller is initialized status.
    bool isPanTiltOpen() override;

	/// Get pan-tilt controller is connected status.
    bool isPanTiltConnected() override;

    /// Set the value for a specific library parameter.
    bool setParam(cr::pantilt::PanTiltParam id, float value) override;

    /// Get the value of a specific library parameter.
    float getParam(cr::pantilt::PanTiltParam id) override;

    /// Get the structure containing all library parameters.
    void getParams(cr::pantilt::PanTiltParams& params) override;

    /// Execute a PanTilt command.
    bool executeCommand(cr::pantilt::PanTiltCommand id,
                                 float arg1 = 0.0f, float arg2 = 0.0f) override;
};

getVersion method

The getVersion() returns string of ViscaCamera class version. Method declaration:

static std::string getVersion();

Method can be used without ViscaCamera class instance:

std::cout << "ViscaCamera class version: " << cr::visca::ViscaCamera::getVersion();

Console output:

ViscaCamera class version: 1.0.2

openLens method

The openLens(…) opens serial port to communicate with VISCA based devices. To initialize serial port user can call openCamera(…), openLens(…) or openPanTilt(…) (no matter which one). If serial port is already open the method will return TRUE. Camera, lens and pan-tilt parameters will be initialized by default. Method declaration:

bool openLens(std::string initString) override;

Parameter	Value
initString	Initialization string. initString can have 3 different form of initialization string for the device: - [serial port name];[baudrate];[camera address];[wait data timeout] - [serial port name];[baudrate];[camera address] - [serial port name];[baudrate] When camera address is not given it is set to 1 as default and same for wait data timeout - 100ms. Recommended initialization string format for controllers, which uses serial port: “/dev/ttyUSB0;9600;1;100”

Parameter

Value

initString

Initialization string. initString can have 3 different form of initialization string for the device:
- [serial port name];[baudrate];[camera address];[wait data timeout]
- [serial port name];[baudrate];[camera address]
- [serial port name];[baudrate]
When camera address is not given it is set to 1 as default and same for wait data timeout - 100ms. Recommended initialization string format for controllers, which uses serial port: “/dev/ttyUSB0;9600;1;100”

Returns: TRUE if the controller initialized or FALSE if not.

openCamera method

The openCamera(…) opens serial port and runs threads to communicate with VISCA based devices. To initialize serial port user can call openCamera(…), openLens(…) or openPanTilt(…) (no matter which one). If serial port is already open the method will return TRUE. Camera, lens and pan-tilt parameters will be initialized with default values. Method declaration:

bool openCamera(std::string initString) override;

Parameter	Value
initString	Initialization string. initString can have 3 different form of initialization string for the device: - [serial port name];[baudrate];[camera address];[wait data timeout] - [serial port name];[baudrate];[camera address] - [serial port name];[baudrate] When camera address is not given it is set to 1 as default and same for wait data timeout - 100ms. Recommended initialization string format for controllers, which uses serial port: “/dev/ttyUSB0;9600;1;100”

Parameter

Value

initString

Returns: TRUE if the controller initialized or FALSE if not.

openPanTilt method

The openPanTilt(…) opens serial port and runs threads to communicate with VISCA based devices. To initialize serial port user can call openCamera(…), openLens(…) or openPanTilt(…) (no matter which one). If serial port is already open the method will return TRUE. Camera, lens and pan-tilt parameters will be initialized with default values. Method declaration:

bool openPanTilt(std::string initString) override;

Parameter	Value
initString	Initialization string. initString can have 3 different form of initialization string for the device: - [serial port name];[baudrate];[camera address];[wait data timeout] - [serial port name];[baudrate];[camera address] - [serial port name];[baudrate] When camera address is not given it is set to 1 as default and same for wait data timeout - 100ms. Recommended initialization string format for controllers, which uses serial port: “/dev/ttyUSB0;9600;1;100”

Parameter

Value

initString

Returns: TRUE if the controller initialized or FALSE if not.

initLens method

The initLens(…) initializes controller and sets lens params (Lens interface). The method will set given lens params and after will call openLens(…) method. Camera and PanTilt parameters will be initialized by default (if not initialized by default). After successful initialization the library will run communication threads (thread to communicate with equipment via serial port) if it was not ran before. Method declaration:

bool initLens(cr::lens::LensParams& params) override;

Parameter	Value
params	LensParams class object. LensParams class includes initString, which is used in openLens(…) method.

Returns: TRUE if the controller initialized and lens parameters were set or FALSE if not.

initCamera method

The initCamera(…) initializes controller and sets camera params (Camera interface). The method will set given camera params and after it will call openCamera(…) method. Lens and PanTilt parameters will be initialized by default (if not initialized by default). After successful initialization the library will run communication threads (thread to communicate with equipment via serial port) if it was not ran before. Method declaration:

bool initCamera(CameraParams& params) override;

Parameter	Value
params	CameraParams class object. CameraParams class includes initString, which is used in openCamera(…) method.

Returns: TRUE if the controller initialized and camera parameters were set or FALSE if not.

initPanTilt method

The initPanTilt(…) initializes controller and sets camera params (PanTilt interface). The method will set given pan-tilt params and after will call openPanTilt(…) method. Camera and PanTilt parameters will be initialized by default (if not initialized by default). After successful initialization the library will run communication threads (thread to communicate with equipment via serial port) if it was not ran before. Method declaration:

bool initPanTilt(PanTiltParams& params) override;

Parameter	Value
params	PanTiltParams class object. PanTiltParams class includes initString, which is used in openPanTilt(…) method.

Returns: TRUE if the controller initialized and camera parameters were set or FALSE if not.

closeLens method

The closeLens() closes serial port and stops all communication threads. The result of the method is equal to closeCamera() or closePanTilt() method (user can use any of them). Method declaration:

void closeLens() override;

closeCamera method

The closeCamera() closes serial port and stops all communication threads. The result of the method is equal to closeLens() or closePanTilt() method (user can use any of them). Method declaration:

void closeCamera() override;

closePanTilt method

The closePanTilt() closes serial port and stops all communication threads. The result of the method is equal to closeLens() or closeCamera() method (user can use any of them). Method declaration:

void closePanTilt() override;

isLensOpen method

The isLensOpen() method returns controller initialization status. Open status shows if the controller initialized (serial port open) but doesn’t show if controller has communication with equipment. For example, if serial port is open (opens serial port file in OS) but equipment can be not active (no power). In this case open status just shows that the serial port is open. This method is equal to isCameraOpen(…) and isPanTiltOpen() method. Method declaration:

bool isLensOpen() override;

Returns: TRUE is the controller initialized (serial port open) or FALSE if not.

isCameraOpen method

The isCameraOpen() method returns controller initialization status. Open status shows if the controller initialized (serial port open) but doesn’t show if controller has communication with equipment. For example, if serial port is open (opens serial port file in OS) but equipment can be not active (no power). In this case open status just shows that the serial port is open. This method is equal to isLensOpen() and isPanTiltOpen() method. Method declaration:

bool isCameraOpen() override;

Returns: TRUE is the controller initialized (serial port open) or FALSE if not.

isPanTiltOpen method

bool isPanTiltOpen() override;

Returns: TRUE is the controller initialized (serial port open) or FALSE if not.

isLensConnected method

The isLensConnected() shows if the controller receives responses from equipment (camera). For example, if serial port open but equipment not active (no power). In this case methods isLensOpen(), isCameraOpen() and isPanTiltOpen() methods will return TRUE but isLensConnected() method will return FALSE. This method is equal to isCameraConnected() and isPanTiltConnected() methods (user can use any of them). Method declaration:

bool isLensConnected() override;

Returns: TRUE if the controller has data exchange with equipment or FALSE if not.

isCameraConnected method

The isCameraConnected() shows if the controller receives responses from equipment (camera). For example, if serial port open but equipment not active (no power). In this case methods isLensOpen(), isCameraOpen() and isPanTiltOpen() methods will return TRUE but isCameraConnected() method will return FALSE. This method is equal to isLensConnected() and isPanTiltConnected() methods (user can use any of them). Method declaration:

bool isCameraConnected() override;

Returns: TRUE if the controller has data exchange with equipment or FALSE if not.

isPanTiltConnected method

The isPanTiltConnected() shows if the controller receives responses from equipment (camera). For example, if serial port open but equipment not active (no power). In this case methods isLensOpen(), isCameraOpen() and isPanTiltOpen() methods will return TRUE but isPanTiltConnected() method will return FALSE. This method is equal to isLensConnected() and isCameraConnected() methods (user can use any of them). Method declaration:

bool isPanTiltConnected() override;

Returns: TRUE if the controller has data exchange with equipment or FALSE if not.

setParam method

The setParam(…) is overloaded method. The method intended to set Camera, Lens or PanTilt parameter value. Method declaration:

bool setParam(LensParam id, float value) override;
bool setParam(CameraParam id, float value) override;
bool setParam(PanTiltParam id, float value) override;

Parameter	Description
id	Lens parameter ID according to LensParam, camera parameter ID according to CameraParam or pan-tilt parameter ID according to PanTiltParam
value	Camera, Lens or PanTilt parameter value. Valid values depend on parameter ID.

Returns: TRUE if the parameter is set or FALSE if not.

getParam method

The getParam(…) is overloaded method. The method intended to obtain Camera, Lens or PanTilt parameter value. Method declaration:

float getParam(LensParam id) override;
float getParam(CameraParam id) override;
float getParam(PanTiltParam id) override;

Parameter	Description
id	Lens parameter ID according to LensParam, camera parameter ID according to CameraParam or pan-tilt parameter ID according to PanTiltParam.

Returns: parameter value or -1 of the parameters not supported.

getParams method

The getParams(…) is overloaded method. The method intended to obtain Camera or Lens parameters structure. Method declaration:

void getParams(LensParams& params) override;
void getParams(CameraParams& params) override;
void getParams(PanTiltParams& params) override;

Parameter	Description
params	Reference to LensParams class object, CameraParams class object or PanTiltParam class object.

executeCommand method

The executeCommand(…) is overloaded method. The method intended to execute Camera or Lens action command. Method declaration:

bool executeCommand(LensCommand id, float arg = 0) override;
bool executeCommand(CameraCommand id) override;
bool executeCommand(PanTiltCommand id, float arg1 = 0, float arg2 = 0) override;

Parameter	Description
id	Camera command ID according to CameraCommand, lens command ID according to LensCommand or pan-tilt command ID according to PanTiltCommand.
arg	Only for lens interface. Lens command argument. Valid values depend on command ID.
arg1	Only for pan-tilt interface. PanTilt command argument. Valid values depend on command ID.
arg2	Only for pan-tilt interface. PanTilt command argument. Valid values depend on command ID.

Returns: TRUE is the command is executed (accepted by controller) or FALSE if not.

addVideoFrame method

The addVideoFrame(…) copies video frame data to lens controller to perform autofocus algorithm. It is not supported by ViscaCamera. Method declaration:

void addVideoFrame(cr::video::Frame& frame) override;

Parameter	Description
frame	Frame class object.

decodeAndExecuteCommand method

The decodeAndExecuteCommand(…) method decodes and executes command on controller side. Method will decode commands which encoded by encodeCommand(…) and encodeSetParamCommand(…) methods of Lens, Camera and PanTilt interface classes. If command is decoded, the method will call setParam(…) or executeCommand(…) methods for lens, camera or pan-tilt interfaces. This method is thread-safe. This means that the 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 and COMMAND.

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

Data structures

LensCommand enum

Enum declaration:

enum class LensCommand
{
    /// Move zoom tele (in).
    ZOOM_TELE = 1,
    /// Move zoom wide (out).
    ZOOM_WIDE,
    /// Move zoom to position.
    ZOOM_TO_POS,
    /// Stop zoom moving including stop zoom to position command.
    ZOOM_STOP,
    /// Move focus far.
    FOCUS_FAR,
    /// Move focus near.
    FOCUS_NEAR,
    /// Move focus to position.
    FOCUS_TO_POS,
    /// Stop focus moving including stop focus to position command.
    FOCUS_STOP,
    /// Move iris open.
    IRIS_OPEN,
    /// Move iris close.
    IRIS_CLOSE,
    /// Move iris to position.
    IRIS_TO_POS,
    /// Stop iris moving including stop iris to position command.
    IRIS_STOP,
    /// Start autofocus.
    AF_START,
    /// Stop autofocus.
    AF_STOP,
    /// Restart lens controller.
    RESTART,
    /// Detect zoom and focus hardware ranges.
    DETECT_HW_RANGES
};

Table 2 - Lens commands description.

Command	Description
ZOOM_TELE	Move zoom tele (in). Command doesn’t have arguments. User can set zoom movement speed via lens parameters.
ZOOM_WIDE	Move zoom wide (out). Command doesn’t have arguments. User can set zoom movement speed via lens parameters.
ZOOM_TO_POS	Move zoom to position. Controller has zoom range from 0 (full wide) to 65535 (full tele) regardless of the hardware value of the zoom position. User can set zoom movement speed via lens parameters.
ZOOM_STOP	Stop zoom moving including stop zoom to position command.
FOCUS_FAR	Move focus far. Command doesn’t have arguments. User can set focus movement speed via lens parameters.
FOCUS_NEAR	Move focus near. Command doesn’t have arguments. User can set focus movement speed via lens parameters.
FOCUS_TO_POS	Move focus to position. Controller has focus range from 0 (full near) to 65535 (full far) regardless of the hardware value of the focus position. User can set focus movement speed via lens parameters.
FOCUS_STOP	Stop focus moving including stop focus to position command.
IRIS_OPEN	Move iris open. Command doesn’t have arguments. User can set iris movement speed via lens parameters.
IRIS_CLOSE	Move iris close. Command doesn’t have arguments. User can set iris movement speed via lens parameters.
IRIS_TO_POS	Move iris to position. Controller has iris range from 0 (full close) to 65535 (full open) regardless of the hardware value of the iris position.
IRIS_STOP	Stop moving iris position including stop iris to position command.
AF_START	Start autofocus. Command doesn’t have arguments.
AF_STOP	Stop autofocus, switch to manual focus. Command doesn’t have arguments.
RESTART	Not supported by ViscaCamera library.
DETECT_HW_RANGES	Not supported by ViscaCamera library.

CameraCommand enum

Enum declaration:

enum class CameraCommand
{
    /// Restart camera controller.
    RESTART = 1,
    /// Do NUC.
    NUC,
    /// Apply settings.
    APPLY_PARAMS,
    /// Save params.
    SAVE_PARAMS,
    /// Menu on.
    MENU_ON,
    /// Menu off.
    MENU_OFF,
    /// Menu set.
    MENU_SET,
    /// Menu up.
    MENU_UP,
    /// Menu down.
    MENU_DOWN,
    /// Menu left.
    MENU_LEFT,
    /// Menu right.
    MENU_RIGHT,
    /// Freeze, Argument: time msec.
    FREEZE,
    /// Disable freeze.
    DEFREEZE
};

Table 3 - Camera commands description.

Command	Description
RESTART	Not supported by ViscaCamera library.
NUC	Not supported by ViscaCamera library.
APPLY_PARAMS	Not supported by ViscaCamera library.
SAVE_PARAMS	Not supported by ViscaCamera library.
MENU_ON	Not supported by ViscaCamera library.
MENU_OFF	Not supported by ViscaCamera library.
MENU_SET	Not supported by ViscaCamera library.
MENU_UP	Not supported by ViscaCamera library.
MENU_DOWN	Not supported by ViscaCamera library.
MENU_LEFT	Not supported by ViscaCamera library.
MENU_RIGHT	Not supported by ViscaCamera library.
FREEZE	Run camera freeze on. Command doesn’t have arguments.
DEFREEZE	Run camera defreeze on. Command doesn’t have arguments.

PanTiltCommand enum

Enum declaration:

enum class PanTiltCommand
{
    /// Restart Pan-Tilt device.
    RESTART = 1,
    /// Stop Pan-Tilt device, block all running commands and left device in current state.
    STOP,
    /// Go to given pan motor position.
    GO_TO_PAN_POSITION,
    /// Go to given tilt motor position.
    GO_TO_TILT_POSITION,
    /// Go to given pan and tilt motor position.
    GO_TO_PAN_TILT_POSITION,
    /// Go to given pan angle.
    GO_TO_PAN_ANGLE,
    /// Go to given tilt angle.
    GO_TO_TILT_ANGLE,
    /// Go to given pan and tilt angle.
    GO_TO_PAN_TILT_ANGLE,
    /// Go to home position.
    GO_TO_HOME,
    /// Move pan motor with given speed. Positive speed is clockwise, 
    /// negative is counterclockwise.
    MOVE_PAN,
    /// Move tilt motor with given speed. Positive speed is clockwise,
    /// negative is counterclockwise.
	MOVE_TILT,
	/// Move pan and tilt motors with given speed. Positive speed is clockwise,
    /// negative is counterclockwise. First argument is pan speed, second is tilt speed.
	MOVE_PAN_TILT
};

Table 4 - Commands description.

Command	Description
RESTART	Not supported by ViscaCamera library.
STOP	Not supported by ViscaCamera library.
GO_TO_PAN_POSITION	Not supported by ViscaCamera library.
GO_TO_TILT_POSITION	Not supported by ViscaCamera library.
GO_TO_PAN_TILT_POSITION	Not supported by ViscaCamera library.
GO_TO_PAN_ANGLE	Not supported by ViscaCamera library.
GO_TO_TILT_ANGLE	Not supported by ViscaCamera library.
GO_TO_PAN_TILT_ANGLE	Go to given pan and tilt angle. Valid values from -180.0° to 180.0°. Command accepts two arguments, first one defines pan angle and second one tilt angle.
MOVE_PAN	Not supported by ViscaCamera library.
MOVE_TILT	Not supported by ViscaCamera library.
MOVE_PAN_TILT	Not supported by ViscaCamera library.
GO_TO_HOME	Not supported by ViscaCamera library.

LensParam enum

Enum declaration:

enum class LensParam
{
    /// Zoom position.
    ZOOM_POS = 1,
    /// Hardware zoom position.
    ZOOM_HW_POS,
    /// Focus position.
    FOCUS_POS,
    /// Hardware focus position. 
    FOCUS_HW_POS,
    /// Iris position.
    IRIS_POS,
    /// Hardware iris position.
    IRIS_HW_POS,
    /// Focus mode.
    FOCUS_MODE,
    /// Filter mode.
    FILTER_MODE,
    /// Autofocus ROI top-left corner horizontal position in pixels.
    AF_ROI_X0,
    /// Autofocus ROI top-left corner vertical position in pixels.
    AF_ROI_Y0,
    /// Autofocus ROI bottom-right corner horizontal position in pixels.
    AF_ROI_X1,
    /// Autofocus ROI bottom-right corner vertical position in pixels.
    AF_ROI_Y1,
    /// Zoom speed.
    ZOOM_SPEED,
    /// Zoom hardware speed. 
    ZOOM_HW_SPEED,
    /// Maximum zoom hardware speed. 
    ZOOM_HW_MAX_SPEED,
    /// Focus speed.
    FOCUS_SPEED,
    /// Focus hardware speed. 
    FOCUS_HW_SPEED,
    /// Maximum focus hardware speed. 
    FOCUS_HW_MAX_SPEED,
    /// Iris speed.
    IRIS_SPEED,
    /// Iris hardware speed. 
    IRIS_HW_SPEED,
    /// Maximum iris hardware speed. 
    IRIS_HW_MAX_SPEED,
    /// Zoom hardware tele limit. 
    ZOOM_HW_TELE_LIMIT,
    /// Zoom hardware wide limit. 
    ZOOM_HW_WIDE_LIMIT,
    /// Focus hardware far limit. 
    FOCUS_HW_FAR_LIMIT,
    /// Focus hardware near limit. 
    FOCUS_HW_NEAR_LIMIT,
    /// Iris hardware open limit.
    IRIS_HW_OPEN_LIMIT,
    /// Iris hardware close limit.
    IRIS_HW_CLOSE_LIMIT,
    /// Focus factor if it was calculated.
    FOCUS_FACTOR,
    /// Lens connection status.
    IS_CONNECTED,
    /// Focus hardware speed in autofocus mode. 
    FOCUS_HW_AF_SPEED,
    /// Threshold for changes of focus factor to start refocus.
    FOCUS_FACTOR_THRESHOLD,
    /// Timeout for automatic refocus in seconds.
    REFOCUS_TIMEOUT_SEC,
    /// Flag about active autofocus algorithm.
    AF_IS_ACTIVE,
    /// Iris mode.
    IRIS_MODE,
    /// ROI width (pixels).
    AUTO_AF_ROI_WIDTH,
    /// ROI height (pixels).
    AUTO_AF_ROI_HEIGHT,
    /// Video frame border size (along vertical and horizontal axes).
    AUTO_AF_ROI_BORDER,
    /// AF ROI mode (write/read). Value: 0 - Manual position, 1 - Auto position.
    AF_ROI_MODE,
    /// Lens extender mode.
    EXTENDER_MODE,
    /// Lens stabilization mode.
    STABILIZER_MODE,
    /// Autofocus range.
    AF_RANGE,
    /// Current horizontal Field of view, degree.
    X_FOV_DEG,
    /// Current vertical Field of view, degree.
    Y_FOV_DEG,
    /// Logging mode.
    LOG_MODE,
    /// Lens temperature, degree.
    TEMPERATURE,
    /// Lens controller initialization status.
    IS_OPEN,
    /// Lens type.
    TYPE,
    /// Lens custom parameter.
    CUSTOM_1,
    /// Lens custom parameter.
    CUSTOM_2,
    /// Lens custom parameter.
    CUSTOM_3
};

Table 5 - Lens params description.

Parameter	Access	Description
ZOOM_POS	read / write	Zoom position. Setting a parameter is equivalent to the command ZOOM_TO_POS. Controller should have zoom range from 0 (full wide) to 65535 (full tele) regardless of the hardware value of the zoom position. User can set zoom movement speed via lens parameters.
ZOOM_HW_POS	read / write	Hardware zoom position. Parameter has same value as ZOOM_POS parameter.
FOCUS_POS	read / write	Focus position. Setting a parameter is equivalent to the command FOCUS_TO_POS. Lens controller should have focus range from 0 (full near) to 65535 (full far) regardless of the hardware value of the focus position. User can set focus movement speed via lens parameters.
FOCUS_HW_POS	read / write	Hardware focus position. Parameter has same value as FOCUS_POS parameter.
IRIS_POS	read / write	Iris position. Setting a parameter is equivalent to the command IRIS_TO_POS. Lens controller should have iris range from 0 (full close) to 65535 (full open) regardless of the hardware value of the iris position.
IRIS_HW_POS	read / write	Hardware iris position. Parameter has same value as IRIS_POS parameter.
FOCUS_MODE	read / write	Focus mode. Value : 0 - Manual 1 - AF ON
FILTER_MODE	read / write	Filter mode. Value: 0 - ICR OFF 1 - ICR ON
AF_ROI_X0	read / write	Not supported by ViscaCamera library.
AF_ROI_Y0	read / write	Not supported by ViscaCamera library.
AF_ROI_X1	read / write	Not supported by ViscaCamera library.
AF_ROI_Y1	read / write	Not supported by ViscaCamera library.
ZOOM_SPEED	read / write	Zoom speed. Controller has zoom speed range from 0 to 100%.
ZOOM_HW_SPEED	read / write	Zoom speed. Controller has zoom speed range from 0 to 100%.
ZOOM_HW_MAX_SPEED	read / write	Not supported by ViscaCamera library.
FOCUS_SPEED	read / write	Focus speed. Controller has focus speed range from 0 to 100%.
FOCUS_HW_SPEED	read / write	Focus speed. Controller has focus speed range from 0 to 100%.
FOCUS_HW_MAX_SPEED	read / write	Not supported by ViscaCamera library.
IRIS_SPEED	read / write	Not supported by ViscaCamera library.
IRIS_HW_SPEED	read / write	Not supported by ViscaCamera library.
IRIS_HW_MAX_SPEED	read / write	Not supported by ViscaCamera library.
ZOOM_HW_TELE_LIMIT	read / write	Not supported by ViscaCamera library.
ZOOM_HW_WIDE_LIMIT	read / write	The value of hardware wide zoom limit. It is necessary for proper calculation of zoom movement. Supported values from 0 to 16384.
FOCUS_HW_FAR_LIMIT	read / write	Not supported by ViscaCamera library.
FOCUS_HW_NEAR_LIMIT	read / write	Not supported by ViscaCamera library.
IRIS_HW_OPEN_LIMIT	read / write	Not supported by ViscaCamera library.
IRIS_HW_CLOSE_LIMIT	read / write	Not supported by ViscaCamera library.
FOCUS_FACTOR	read only	Not supported by ViscaCamera library.
IS_CONNECTED	read only	Connection status. Connection status shows if the controller has data exchange with equipment. For example, if serial port open but equipment can be not active (no power). In this case connection status shows that controller doesn’t have data exchange with equipment (methos will return 0). It the controller has data exchange with equipment the method will return 1. If the controller not initialize the connection status always FALSE. Values: 0 - not connected. 1 - connected.
FOCUS_HW_AF_SPEED	read / write	Not supported by ViscaCamera library.
FOCUS_FACTOR_THRESHOLD	read / write	Focus factor threshold parameter supports two states: - value below 50.0 - AutoFocus sensitivity is set to Normal. - value between 50.0 and 100.0 - AutoFocus sensitivity is set to Low.
REFOCUS_TIMEOUT_SEC	read / write	Set timeout of refocusing in seconds. Supported values between 0 and 255. If value is set to 0 refocus will be off.
AF_IS_ACTIVE	read only	Not supported by ViscaCamera library.
IRIS_MODE	read / write	Not supported by ViscaCamera library.
AUTO_AF_ROI_WIDTH	read / write	Not supported by ViscaCamera library.
AUTO_AF_ROI_HEIGHT	read / write	Not supported by ViscaCamera library.
AUTO_AF_ROI_BORDER	read / write	Not supported by ViscaCamera library.
AF_ROI_MODE	read / write	Not supported by ViscaCamera library.
EXTENDER_MODE	read / write	Not supported by ViscaCamera library.
STABILIZER_MODE	read / write	Stabilizer mode. Values: 0 - OFF 1 - ON
AF_RANGE	read / write	Autofocus range. Values: 1 - low 2 - Middle 3 - High others - Low
X_FOV_DEG	read only	Not supported by ViscaCamera library.
Y_FOV_DEG	read only	Not supported by ViscaCamera library.
LOG_MODE	read / write	Logging mode. Values: 0 - Disable, 1 - Only file, 2 - Only terminal (console), 3 - File and terminal.
TEMPERATURE	read only	Not supported by ViscaCamera library.
IS_OPEN	read only	Controller initialization status. Open status shows if the controller initialized or not but doesn’t show if controller has communication with equipment. For example, if serial port open but equipment can be not active (no power). In this case open status just shows that the controller has opened serial port. Values: 0 - not open (not initialized), 1 - open (initialized).
TYPE	read / write	Not supported by ViscaCamera library.
CUSTOM_1	read / write	Not supported by ViscaCamera library.
CUSTOM_2	read / write	Not supported by ViscaCamera library.
CUSTOM_3	read / write	Not supported by ViscaCamera library.

CameraParam enum

Enum declaration:

enum class CameraParam
{
    /// Video frame width. Value from 0 to 16384.
    WIDTH = 1,
    /// Video frame height Value from 0 to 16384.
    HEIGHT,
    /// Display menu mode.
    DISPLAY_MODE,
    /// Video output type.
    VIDEO_OUTPUT,
    /// Logging mode.
    LOG_MODE,
    /// Exposure mode.
    EXPOSURE_MODE,
    /// Exposure time of the camera sensor.
    EXPOSURE_TIME,
    /// White balance mode.
    WHITE_BALANCE_MODE,
    /// White balance area.
    WHITE_BALANCE_AREA,
    /// White dynamic range mode.
    WIDE_DYNAMIC_RANGE_MODE,
    /// Image stabilization mode.
    STABILIZATION_MODE,
    /// ISO sensitivity.
    ISO_SENSITIVITY,
    /// Scene mode.
    SCENE_MODE,
    /// FPS.
    FPS,
    /// Brightness mode.
    BRIGHTNESS_MODE,
    /// Brightness. Value 0 - 100%.
    BRIGHTNESS,
    /// Contrast. Value 1 - 100%.
    CONTRAST,
    /// Gain mode.
    GAIN_MODE,
    /// Gain. Value 1 - 100%.
    GAIN,
    /// Sharpening mode.
    SHARPENING_MODE,
    /// Sharpening. Value 1 - 100%.
    SHARPENING,
    /// Palette.
    PALETTE,
    /// Analog gain control mode.
    AGC_MODE,
    /// Shutter mode.
    SHUTTER_MODE,
    /// Shutter position. 0 (full close) - 65535 (full open).
    SHUTTER_POSITION,
    /// Shutter speed. Value: 0 - 100%.
    SHUTTER_SPEED,
    /// Digital zoom mode.
    DIGITAL_ZOOM_MODE,
    /// Digital zoom. Value 1.0 (x1) - 20.0 (x20).
    DIGITAL_ZOOM,
    /// Exposure compensation mode.
    EXPOSURE_COMPENSATION_MODE,
    /// Exposure compensation position. 
    EXPOSURE_COMPENSATION_POSITION,
    /// Defog mode.
    DEFOG_MODE,
    /// Dehaze mode.
    DEHAZE_MODE,
    /// Noise reduction mode.
    NOISE_REDUCTION_MODE,
    /// Black and white filter mode.
    BLACK_WHITE_FILTER_MODE,
    /// Filter mode.
    FILTER_MODE,
    /// NUC mode for thermal cameras.
    NUC_MODE,
    /// Auto NUC interval for thermal cameras. 
    AUTO_NUC_INTERVAL_MSEC,
    /// Image flip mode.
    IMAGE_FLIP,
    /// DDE mode.
    DDE_MODE,
    /// DDE level.
    DDE_LEVEL,
    /// ROI top-left horizontal position, pixels.
    ROI_X0,
    /// ROI top-left vertical position, pixels.
    ROI_Y0,
    /// ROI bottom-right horizontal position, pixels.
    ROI_X1,
    /// ROI bottom-right vertical position, pixels.
    ROI_Y1,
    /// Camera temperature, degree.
    TEMPERATURE,
    /// ALC gate.
    ALC_GATE,
    /// Sensor sensitivity.
    SENSETIVITY,
    /// Changing mode (day / night).
    CHANGING_MODE,
    /// Changing level (day / night).
    CHANGING_LEVEL,
    /// Chroma level. Values: 0 - 100%.
    CHROMA_LEVEL,
    /// Details, enhancement. Values: 0 - 100%.
    DETAIL,
    /// Camera settings profile.
    PROFILE,
    /// Connection status (read only). Shows if we have respond from camera.
    /// Value: 0 - not connected, 2 - connected.
    IS_CONNECTED,
    /// Open status (read only):
    /// 1 - camera control port open, 0 - not open.
    IS_OPEN,
    /// Camera type.
    TYPE,
    /// Camera custom param.
    CUSTOM_1,
    /// Camera custom param.
    CUSTOM_2,
    /// Camera custom param.
    CUSTOM_3
};

Table 6 - Camera params description.

Parameter	Access	Description
WIDTH	read / write	Not supported by ViscaCamera library.
HEIGHT	read / write	Not supported by ViscaCamera library.
DISPLAY_MODE	read / write	Not supported by ViscaCamera library.
VIDEO_OUTPUT	read / write	Not supported by ViscaCamera library.
LOG_MODE	read / write	Logging mode. Values: 0 - Disable, 1 - Only file, 2 - Only terminal (console), 3 - File and terminal.
EXPOSURE_MODE	read / write	Exposure mode. Values: 0 - Manual exposure mode. 1 - Full auto exposure mode. 2 - Set exposure mode to shutter priority. 3 - Set exposure mode to iris priority.
EXPOSURE_TIME	read / write	Exposure time of the camera sensor. The exposure time is limited by the frame interval. Camera controller should interpret the values as 100 µs units, where the value 1 stands for 1/10000th of a second, 10000 for 1 second and 100000 for 10 seconds.
WHITE_BALANCE_MODE	read / write	White balance mode. Value: 0 - White balance manual mode. 1 - White balance auto mode.
WHITE_BALANCE_AREA	read / write	Not supported by ViscaCamera library.
WHITE_DINAMIC_RANGE_MODE	read / write	Wide dynamic range mode. Value: 0 - Off. 1 - On.
STABILIZATION_MODE	read / write	Stabilization mode. Value: 0 - Off. 1 - On.
ISO_SENSITIVITY	read / write	Not supported by ViscaCamera library.
SCENE_MODE	read / write	Not supported by ViscaCamera library.
FPS	read / write	Not supported by ViscaCamera library.
BRIGHTNESS_MODE	read / write	Not supported by ViscaCamera library.
BRIGHTNESS	read / write	Not supported by ViscaCamera library.
CONTRAST	read / write	Contrast. Value 1 - 100%.
GAIN_MODE	read / write	Not supported by ViscaCamera library.
GAIN	read / write	Camera gain. Value 1 - 100%.
SHARPENING_MODE	read / write	Not supported by ViscaCamera library.
SHARPENING	read / write	Not supported by ViscaCamera library.
PALETTE	read / write	Not supported by ViscaCamera library.
AGC_MODE	read / write	Not supported by ViscaCamera library.
SHUTTER_MODE	read / write	Shutter mode. Values: 0 - Auto slow shutter off. 1 - Auto slow shutter on.
SHUTTER_POSITION	read / write	Shutter position value. Supported values from 0 (full close) to 65535 (full open).
SHUTTER_SPEED	read / write	Shutter speed value, as a percentage.
DIGITAL_ZOOM_MODE	read / write	Digital zoom mode. Values: 0 - Off. 1 - On.
DIGITAL_ZOOM	read only	Digital zoom. Values: 1.0 (x1.0) - 20.0 (x20.0).
EXPOSURE_COMPENSATION_MODE	read only	Exposure compensation mode. Values: 0 - Off. 1 - On.
EXPOSURE_COMPENSATION_POSITION	read / write	Exposure compensation position. Supported values from 0 to 65535 .
DEFOG_MODE	read / write	Defog mode. Values: 0 - Off 1 - Low. 2 - Mid. 3 - High.
DEHAZE_MODE		Not supported by ViscaCamera library.
NOISE_REDUCTION_MODE	read / write	Noise reduction mode. Values: 0 - Off. 1 - On - 2D.
BLACK_WHITE_FILTER_MODE	read only	Black white filter mode. Values: 0 - Off. 1 - On - 2D.
FILTER_MODE	read / write	Not supported by ViscaCamera library.
NUC_MODE	read / write	Not supported by ViscaCamera library.
AUTO_NUC_INTERVAL	read / write	Not supported by ViscaCamera library.
IMAGE_FLIP	read / write	Image flip mode. Values: 0 - Off. 1 - On.
DDE_MODE	read / write	Not supported by ViscaCamera library.
DDE_LEVEL	read / write	Not supported by ViscaCamera library.
ROI_X0	read / write	Not supported by ViscaCamera library.
ROI_Y0	read / write	Not supported by ViscaCamera library.
ROI_X1	read / write	Not supported by ViscaCamera library.
ROI_Y1	read / write	Not supported by ViscaCamera library.
TEMPERATURE	read only	Not supported by ViscaCamera library.
ALC_GATE	read / write	Not supported by ViscaCamera library.
SENSITIVITY	read / write	Sensitivity mode. Values: 0 - High sensitivity mode off. 1 - High sensitivity mode on.
CHANGING_MODE	read / write	Not supported by ViscaCamera library.
CHANGING_LEVEL	read / write	Not supported by ViscaCamera library.
CHROMA_LEVEL	read / write	Not supported by ViscaCamera library.
DETAIL	read / write	Chroma level value, as percentage. Supported values between 0 an 100.
PROFILE	read / write	Not supported by ViscaCamera library.
IS_CONNECTED	read only	Connection status. Connection status shows if the controller has data exchange with equipment. For example, if serial port open but equipment can be not active (no power). In this case connection status shows that controller doesn’t have data exchange with equipment (methos will return 0). It the controller has data exchange with equipment the method will return 1. If the controller not initialize the connection status always FALSE. Value: 0 - not connected. 1 - connected.
IS_OPEN	read only	Controller initialization status. Open status shows if the controller initialized or not but doesn’t show if controller has communication with equipment. For example, if serial port open but equipment can be not active (no power). In this case open status just shows that the controller has opened serial port. Values: 0 - not open (not initialized), 1 - open (initialized).
TYPE	read / write	Not supported by ViscaCamera library.
CUSTOM_1	read / write	Not supported by ViscaCamera library.
CUSTOM_2	read / write	Not supported by ViscaCamera library.
CUSTOM_3	read / write	Not supported by ViscaCamera library.

PanTiltParam enum

Enum declaration:

enum class PanTiltParam
{
    /// Pan motor position for encoder. Range: 0 - 65535.
    PAN_MOTOR_POSITION = 1,
    /// Tilt motor position for encoder. Range: 0 - 65535.
    TILT_MOTOR_POSITION,
    /// Pan angle. Range: -180.0 to 180.0.
    PAN_ANGLE,
    /// Tilt angle. Range: -180.0 to 180.0.
    TILT_ANGLE,
    /// Pan motor speed. Positive speed is clockwise, 
    /// negative is counterclockwise.
    PAN_MOTOR_SPEED,
    /// Tilt motor speed. Positive speed is clockwise, 
    /// negative is counterclockwise.
    TILT_MOTOR_SPEED,
    /// Status defining if the pan-tilt device is connected.
    IS_CONNECTED,
    /// Status defining if the pan-tilt device is initialized.
    IS_INITIALIZED, 
    /// PanTilt custom param. Not used in current implementation.
    CUSTOM_1,
    /// PanTilt custom param. Not used in current implementation.
    CUSTOM_2,
    /// PanTilt custom param. Not used in current implementation.
    CUSTOM_3
};

Table 3 - Params description.

Parameter	Access	Description
PAN_MOTOR_POSITION	read / write	Not supported by ViscaCamera library.
TILT_MOTOR_POSITION	read / write	Not supported by ViscaCamera library.
PAN_ANGLE	read / write	Pan angle. Range: -180.0 to 180.0.
TILT_ANGLE	read / write	Tilt angle. Range: -180.0 to 180.0.
PAN_MOTOR_SPEED	read / write	Not supported by ViscaCamera library.
TILT_MOTOR_SPEED	read / write	Not supported by ViscaCamera library.
IS_CONNECTED	read only	Connection status (read only): 1 - pan-tilt control port connected, 0 - not connected.
IS_INITIALIZED	read only	Initialization status (read only): 1 - pan-tilt control port initialized, 0 - not initialized.

LensParams class description

LensParams class used for lens initialization or to get all actual params. Also LensParams provides structure to write/read params from JSON files (JSON_READABLE macro) and provides methos to encode and decode params.

LensParams class declaration

LensParams interface class declared in Lens.h file. Class declaration:

class LensParams
{
public:
    /// Initialization string.
    std::string initString{"/dev/ttyUSB0;9600;7"};
    /// Zoom position.
    int zoomPos{0};
    /// Hardware zoom position.
    int zoomHwPos{0};
    /// Focus position.
    int focusPos{0};
    /// Hardware focus position.
    int focusHwPos{0};
    /// Iris position.
    int irisPos{0};
    /// Hardware iris position.
    int irisHwPos{0};
    /// Focus mode.
    int focusMode{0};
    /// Filter mode.
    int filterMode{0};
    /// Autofocus ROI top-left corner horizontal position in pixels.
    int afRoiX0{0};
    /// Autofocus ROI top-left corner vertical position in pixels.
    int afRoiY0{0};
    /// Autofocus ROI bottom-right corner horizontal position in pixels.
    int afRoiX1{0};
    /// Autofocus ROI bottom-right corner vertical position in pixels.
    int afRoiY1{0};
    /// Zoom speed.
    int zoomSpeed{50};
    /// Zoom hardware speed.
    int zoomHwSpeed{50};
    /// Maximum zoom hardware speed.
    int zoomHwMaxSpeed{50};
    /// Focus speed.
    int focusSpeed{50};
    /// Focus hardware speed.
    int focusHwSpeed{50};
    /// Maximum focus hardware speed.
    int focusHwMaxSpeed{50};
    /// Iris speed.
    int irisSpeed{50};
    /// Iris hardware speed.
    int irisHwSpeed{50};
    /// Maximum iris hardware speed.
    int irisHwMaxSpeed{50};
    /// Zoom hardware tele limit.
    int zoomHwTeleLimit{65535};
    /// Zoom hardware wide limit.
    int zoomHwWideLimit{0};
    /// Focus hardware far limit.
    int focusHwFarLimit{65535};
    /// Focus hardware near limit.
    int focusHwNearLimit{0};
    /// Iris hardware open limit.
    int irisHwOpenLimit{65535};
    /// Iris hardware close limit.
    int irisHwCloseLimit{0};
    /// Focus factor if it was calculated.
    float focusFactor{0.0f};
    /// Lens connection status.
    bool isConnected{false};
    /// Focus hardware speed in autofocus mode.
    int afHwSpeed{50};
    /// Timeout for automatic refocus in seconds.
    float focusFactorThreshold{0.0f};
    /// Timeout for automatic refocus in seconds.
    int refocusTimeoutSec{0};
    /// Flag about active autofocus algorithm.
    bool afIsActive{false};
    /// Iris mode.
    int irisMode{0};
    /// ROI width (pixels) for autofocus algorithm.
    int autoAfRoiWidth{150};
    /// ROI height (pixels) for autofocus algorithm.
    int autoAfRoiHeight{150};
    /// Video frame border size (along vertical and horizontal axes).
    int autoAfRoiBorder{100};
    /// AF ROI mode (write/read).
    int afRoiMode{0};
    /// Lens extender mode.
    int extenderMode{0};
    /// Lens stabilization mode.
    int stabiliserMode{0};
    /// Autofocus range.
    int afRange{0};
    /// Current horizontal Field of view, degree.
    float xFovDeg{1.0f};
    /// Current vertical Field of view, degree.
    float yFovDeg{1.0f};
    /// Logging mode.
    int logMode{0};
    /// Lens temperature, degree (read only).
    float temperature{0.0f};
    /// Lens controller initialization status.
    bool isOpen{false};
    /// Lens type. Value depends on implementation.
    int type{0};
    /// Lens custom parameter.
    float custom1{0.0f};
    /// Lens custom parameter.
    float custom2{0.0f};
    /// Lens custom parameter.
    float custom3{0.0f};
    /// List of points to calculate fiend of view.
    std::vector<FovPoint> fovPoints{std::vector<FovPoint>()};

    JSON_READABLE(LensParams, initString, focusMode, filterMode,
                  afRoiX0, afRoiY0, afRoiX1, afRoiY1, zoomHwMaxSpeed,
                  focusHwMaxSpeed, irisHwMaxSpeed, zoomHwTeleLimit,
                  zoomHwWideLimit, focusHwFarLimit, focusHwNearLimit,
                  irisHwOpenLimit, irisHwCloseLimit, afHwSpeed,
                  focusFactorThreshold, refocusTimeoutSec, irisMode,
                  autoAfRoiWidth, autoAfRoiHeight, autoAfRoiBorder,
                  afRoiMode, extenderMode, stabiliserMode, afRange,
                  logMode, type, custom1, custom2, custom3, fovPoints);

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

    /// Encode params.
    bool encode(uint8_t* data, int bufferSize, int& size,
                LensParamsMask* mask = nullptr);

    /// Decode params.
    bool decode(uint8_t* data, int dataSize);
};

LensParams class fields description is equivalent to LensParam enum description except initString. initString can have 3 different form of initialization string for the device:
- [serial port name];[baudrate];[camera address];[wait data timeout]
- [serial port name];[baudrate];[camera address]
- [serial port name];[baudrate]
When camera address is not given it is set to 1 as default and same for wait data timeout - 100ms.

Serialize lens params

The LensParams class provides method encode(…) to serialize lens params. Serialization of lens params necessary in case when you need to send lens params via communication channels. Method doesn’t encode initString string field and fovPoints. Method provides options to exclude particular parameters from serialization. To do this method inserts binary mask (7 bytes) where each bit represents particular parameter and decode(…) method recognizes it. Method declaration:

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

Parameter	Value
data	Pointer to data buffer.
size	Size of encoded data.
bufferSize	Data buffer size. Buffer size must be >= 201 bytes.
mask	Parameters mask - pointer to LensParamsMask structure. LensParamsMask (declared in Lens.h file) determines flags for each field (parameter) declared in LensParams class. If the 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 LensParamsMask structure.

LensParamsMask structure declaration:

typedef struct LensParamsMask
{
    bool zoomPos{true};
    bool zoomHwPos{true};
    bool focusPos{true};
    bool focusHwPos{true};
    bool irisPos{true};
    bool irisHwPos{true};
    bool focusMode{true};
    bool filterMode{true};
    bool afRoiX0{true};
    bool afRoiY0{true};
    bool afRoiX1{true};
    bool afRoiY1{true};
    bool zoomSpeed{true};
    bool zoomHwSpeed{true};
    bool zoomHwMaxSpeed{true};
    bool focusSpeed{true};
    bool focusHwSpeed{true};
    bool focusHwMaxSpeed{true};
    bool irisSpeed{true};
    bool irisHwSpeed{true};
    bool irisHwMaxSpeed{true};
    bool zoomHwTeleLimit{true};
    bool zoomHwWideLimit{true};
    bool focusHwFarLimit{true};
    bool focusHwNearLimit{true};
    bool irisHwOpenLimit{true};
    bool irisHwCloseLimit{true};
    bool focusFactor{true};
    bool isConnected{true};
    bool afHwSpeed{true};
    bool focusFactorThreshold{true};
    bool refocusTimeoutSec{true};
    bool afIsActive{true};
    bool irisMode{true};
    bool autoAfRoiWidth{true};
    bool autoAfRoiHeight{true};
    bool autoAfRoiBorder{true};
    bool afRoiMode{true};
    bool extenderMode{true};
    bool stabiliserMode{true};
    bool afRange{true};
    bool xFovDeg{true};
    bool yFovDeg{true};
    bool logMode{true};
    bool temperature{true};
    bool isOpen{false};
    bool type{true};
    bool custom1{true};
    bool custom2{true};
    bool custom3{true};
} LensParamsMask;

Example without parameters mask:

// Encode data.
LensParams in;
in.logMode = 3;
uint8_t data[1024];
int size = 0;
in.encode(data, 1024, size);
cout << "Encoded data size: " << size << " bytes" << endl;

Example with parameters mask:

// Prepare params.
LensParams in;
in.logMode = 3;

// Prepare mask.
LensParamsMask mask;
mask.logMode = false; // Exclude logMode. Others by default.

// Encode.
uint8_t data[1024];
int size = 0;
in.encode(data, 1024, size, &mask);
cout << "Encoded data size: " << size << " bytes" << endl;

Deserialize lens params

The LensParams class provides method decode(…) to deserialize lens params. Deserialization of lens params necessary in case when you need to receive lens params via communication channels. Method automatically recognizes which parameters were serialized by encode(…) method. Method doesn’t decode fields: initString and fovPoints. Method declaration:

bool decode(uint8_t* data, int dataSize);

Parameter	Value
data	Pointer to data buffer.
dataSize	Size of data.

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

Example:

// Encode data.
LensParams in;
uint8_t data[1024];
int size = 0;
in.encode(data, 1024, size);
cout << "Encoded data size: " << size << " bytes" << endl;

// Decode data.
LensParams out;
if (!out.decode(data, size))
    cout << "Can't decode data" << endl;

Read and write lens params to JSON file

Lens interface class library depends on 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.
LensParams in;
for (int i = 0; i < 5; ++i)
{
    FovPoint pt;
    pt.hwZoomPos = rand() % 255;
    pt.xFovDeg = rand() % 255;
    pt.yFovDeg = rand() % 255;
    in.fovPoints.push_back(pt);
}

// Write params to file.
cr::utils::ConfigReader inConfig;
inConfig.set(in, "lensParams");
inConfig.writeToFile("TestLensParams.json");

// Read params from file.
cr::utils::ConfigReader outConfig;
if(!outConfig.readFromFile("TestLensParams.json"))
{
    cout << "Can't open config file" << endl;
    return false;
}

TestLensParams.json will look like:

{
    "lensParams": {
        "afHwSpeed": 93,
        "afRange": 128,
        "afRoiMode": 239,
        "afRoiX0": 196,
        "afRoiX1": 252,
        "afRoiY0": 115,
        "afRoiY1": 101,
        "autoAfRoiBorder": 70,
        "autoAfRoiHeight": 125,
        "autoAfRoiWidth": 147,
        "custom1": 91.0,
        "custom2": 236.0,
        "custom3": 194.0,
        "extenderMode": 84,
        "filterMode": 49,
        "focusFactorThreshold": 98.0,
        "focusHwFarLimit": 228,
        "focusHwMaxSpeed": 183,
        "focusHwNearLimit": 47,
        "focusMode": 111,
        "fovPoints": [
            {
                "hwZoomPos": 55,
                "xFovDeg": 6.0,
                "yFovDeg": 51.0
            },
            {
                "hwZoomPos": 63,
                "xFovDeg": 249.0,
                "yFovDeg": 33.0
            },
            {
                "hwZoomPos": 4,
                "xFovDeg": 121.0,
                "yFovDeg": 144.0
            },
            {
                "hwZoomPos": 53,
                "xFovDeg": 214.0,
                "yFovDeg": 153.0
            },
            {
                "hwZoomPos": 143,
                "xFovDeg": 15.0,
                "yFovDeg": 218.0
            }
        ],
        "initString": "dfhglsjirhuhjfb",
        "irisHwCloseLimit": 221,
        "irisHwMaxSpeed": 79,
        "irisHwOpenLimit": 211,
        "irisMode": 206,
        "logMode": 216,
        "refocusTimeoutSec": 135,
        "stabiliserMode": 137,
        "type": 125,
        "zoomHwMaxSpeed": 157,
        "zoomHwTeleLimit": 68,
        "zoomHwWideLimit": 251
    }
}

CameraParams class description

CameraParams class used for camera controller initialization or to get all actual params. Also CameraParams provide structure to write/read params from JSON files (JSON_READABLE macro) and provide methos to encode and decode params.

CameraParams Class declaration

CameraParams interface class declared in Camera.h file. Class declaration:

class CameraParams
{
public:
    /// Initialization string.
    std::string initString{"/dev/ttyUSB0;9600;7"};
    /// Video frame width. Value from 0 to 16384.
    int width{0};
    /// Video frame height Value from 0 to 16384.
    int height{0};
    /// Display menu mode. 
    int displayMode{0};
    /// Video output type.
    int videoOutput{0};
    /// Logging mode.
    int logMode{0};
    /// Exposure mode. 
    int exposureMode{1};
    /// Exposure time of the camera sensor.
    int exposureTime{0};
    /// White balance mode. 
    int whiteBalanceMode{1};
    /// White balance area.
    int whiteBalanceArea{0};
    /// White dynamic range mode.
    int wideDynamicRangeMode{0};
    /// Image stabilization mode.
    int stabilisationMode{0};
    /// ISO sensitivity.
    int isoSensetivity{0};
    /// Scene mode.
    int sceneMode{0};
    /// FPS.
    float fps{0.0f};
    /// Brightness mode.
    int brightnessMode{1};
    /// Brightness. Value 0 - 100%.
    int brightness{0};
    /// Contrast. Value 1 - 100%.
    int contrast{0};
    /// Gain mode.
    int gainMode{1};
    /// Gain. Value 1 - 100%.
    int gain{0};
    /// Sharpening mode.
    int sharpeningMode{0};
    /// Sharpening. Value 1 - 100%.
    int sharpening{0};
    /// Palette.
    int palette{0};
    /// Analog gain control mode.
    int agcMode{1};
    /// Shutter mode.
    int shutterMode{1};
    /// Shutter position. 0 (full close) - 65535 (full open).
    int shutterPos{0};
    /// Shutter speed. Value: 0 - 100%.
    int shutterSpeed{0};
    /// Digital zoom mode.
    int digitalZoomMode{0};
    /// Digital zoom. Value 1.0 (x1) - 20.0 (x20).
    float digitalZoom{1.0f};
    /// Exposure compensation mode.
    int exposureCompensationMode{0};
    /// Exposure compensation position.
    int exposureCompensationPosition{0};
    /// Defog mode. 
    int defogMode{0};
    /// Dehaze mode.
    int dehazeMode{0};
    /// Noise reduction mode.
    int noiseReductionMode{0};
    /// Black and white filter mode.
    int blackAndWhiteFilterMode{0};
    /// Filter mode.
    int filterMode{0};
    /// NUC mode for thermal cameras.
    int nucMode{0};
    /// Auto NUC interval for thermal cameras.
    int autoNucIntervalMsec{0};
    /// Image flip mode. 
    int imageFlip{0};
    /// DDE mode.
    int ddeMode{0};
    /// DDE level.
    float ddeLevel{0};
    /// ROI top-left horizontal position, pixels.
    int roiX0{0};
    /// ROI top-left vertical position, pixels.
    int roiY0{0};
    /// ROI bottom-right horizontal position, pixels.
    int roiX1{0};
    /// ROI bottom-right vertical position, pixels.
    int roiY1{0};
    /// Camera temperature, degree.
    float temperature{0.0f};
    /// ALC gate.
    int alcGate{0};
    /// Sensor sensitivity.
    float sensitivity{0};
    /// Changing mode (day / night).
    int changingMode{0};
    /// Changing level (day / night).
    float changingLevel{0.0f};
    /// Chroma level. Values: 0 - 100%.
    int chromaLevel{0};
    /// Details, enhancement. Values: 0 - 100%.
    int detail{0};
    /// Camera settings profile.
    int profile{0};
    /// Connection status (read only).
    bool isConnected{false};
    /// Open status (read only).
    bool isOpen{false};
    /// Camera type.
    int type{0};
    /// Camera custom param.
    float custom1{0.0f};
    /// Camera custom param.
    float custom2{0.0f};
    /// Camera custom param.
    float custom3{0.0f};

    JSON_READABLE(CameraParams, initString, width, height, displayMode,
                  videoOutput, logMode, exposureMode, exposureTime,
                  whiteBalanceMode, whiteBalanceArea, wideDynamicRangeMode,
                  stabilisationMode, isoSensetivity, sceneMode, fps,
                  brightnessMode, brightness, contrast, gainMode, gain,
                  sharpeningMode, sharpening, palette, agcMode, shutterMode,
                  shutterPos, shutterSpeed, digitalZoomMode, digitalZoom,
                  exposureCompensationMode, exposureCompensationPosition,
                  defogMode, dehazeMode, noiseReductionMode,
                  blackAndWhiteFilterMode, filterMode, nucMode,
                  autoNucIntervalMsec, imageFlip, ddeMode, ddeLevel,
                  roiX0, roiY0, roiX1, roiY1, alcGate, sensitivity,
                  changingMode, changingLevel, chromaLevel, detail,
                  profile, type, custom1, custom2, custom3)

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

    /// Encode params. The method doesn't encode initString.
    bool encode(uint8_t* data, int bufferSize, int& size,
                CameraParamsMask* mask = nullptr);

    /// Decode params. The method doesn't decode initString.
    bool decode(uint8_t* data, int dataSize);
};

CameraParams class fields description is equivalent to CameraParam enum description except initString. Initialization string. initString can have 3 different form of initialization string for the device:
- [serial port name];[baudrate];[camera address];[wait data timeout]
- [serial port name];[baudrate];[camera address]
- [serial port name];[baudrate]
When camera address is not given it is set to 1 as default and same for wait data timeout - 100ms.

Serialize camera params

CameraParams class provides method encode(…) to serialize camera params. Serialization of camera params necessary in case when you have to send camera params via communication channels. Method doesn’t encode initString field. Method provides options to exclude particular parameters from serialization. To do this method inserts binary mask (8 bytes) where each bit represents particular parameter and decode(…) method recognizes it. Method declaration:

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

Parameter	Value
data	Pointer to data buffer. Buffer size must be >= 237 bytes.
bufferSize	Data buffer size. Buffer size must be >= 237 bytes.
size	Size of encoded data.
mask	Parameters mask - pointer to CameraParamsMask structure. CameraParamsMask (declared in Camera.h file) determines flags for each field (parameter) declared in CameraParams class. If the 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 CameraParamsMask structure.

Returns: TRUE if params encoded (serialized) or FALSE if not.

CameraParamsMask structure declaration:

typedef struct CameraParamsMask
{
    bool width{true};
    bool height{true};
    bool displayMode{true};
    bool videoOutput{true};
    bool logMode{true};
    bool exposureMode{true};
    bool exposureTime{true};
    bool whiteBalanceMode{true};
    bool whiteBalanceArea{true};
    bool wideDynamicRangeMode{true};
    bool stabilisationMode{true};
    bool isoSensetivity{true};
    bool sceneMode{true};
    bool fps{true};
    bool brightnessMode{true};
    bool brightness{true};
    bool contrast{true};
    bool gainMode{true};
    bool gain{true};
    bool sharpeningMode{true};
    bool sharpening{true};
    bool palette{true};
    bool agcMode{true};
    bool shutterMode{true};
    bool shutterPos{true};
    bool shutterSpeed{true};
    bool digitalZoomMode{true};
    bool digitalZoom{true};
    bool exposureCompensationMode{true};
    bool exposureCompensationPosition{true};
    bool defogMode{true};
    bool dehazeMode{true};
    bool noiseReductionMode{true};
    bool blackAndWhiteFilterMode{true};
    bool filterMode{true};
    bool nucMode{true};
    bool autoNucIntervalMsec{true};
    bool imageFlip{true};
    bool ddeMode{true};
    bool ddeLevel{true};
    bool roiX0{true};
    bool roiY0{true};
    bool roiX1{true};
    bool roiY1{true};
    bool temperature{true};
    bool alcGate{true};
    bool sensitivity{true};
    bool changingMode{true};
    bool changingLevel{true};
    bool chromaLevel{true};
    bool detail{true};
    bool profile{true};
    bool isConnected{true};
    bool isOpen{true};
    bool type{true};
    bool custom1{true};
    bool custom2{true};
    bool custom3{true};
} CameraParamsMask;

Example without parameters mask:

// Encode data.
CameraParams in;
in.profile = 10;
uint8_t data[1024];
int size = 0;
in.encode(data, 1024, size);
cout << "Encoded data size: " << size << " bytes" << endl;

Example with parameters mask:

// Prepare params.
CameraParams in;
in.profile = 3;

// Prepare mask.
CameraParamsMask mask;
mask.profile = false; // Exclude profile. Others by default.

// Encode.
uint8_t data[1024];
int size = 0;
in.encode(data, 1024, size, &mask);
cout << "Encoded data size: " << size << " bytes" << endl;

Deserialize camera params

CameraParams class provides method decode(…) to deserialize camera params (fields of CameraParams class, see Table 4). Deserialization of camera params necessary in case when you need to receive params via communication channels. Method automatically recognizes which parameters were serialized by encode(…) method. Method doesn’t decode initString field. Method declaration:

bool decode(uint8_t* data, int dataSize);

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

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

Example:

// Encode data.
CameraParams in;
uint8_t data[1024];
int size = 0;
in.encode(data, 1024, size);
cout << "Encoded data size: " << size << " bytes" << endl;

// Decode data.
CameraParams out;
if (!out.decode(data, size))
    cout << "Can't decode data" << endl;

Read and write camera params to JSON file

Camera library depends on 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:

// Write params to file.
cr::utils::ConfigReader inConfig;
inConfig.set(in, "cameraParams");
inConfig.writeToFile("TestCameraParams.json");

// Read params from file.
cr::utils::ConfigReader outConfig;
if(!outConfig.readFromFile("TestCameraParams.json"))
{
    cout << "Can't open config file" << endl;
    return false;
}

TestCameraParams.json will look like:

{
    "cameraParams": {
        "agcMode": 252,
        "alcGate": 125,
        "autoNucIntervalMsec": 47,
        "blackAndWhiteFilterMode": 68,
        "brightness": 67,
        "brightnessMode": 206,
        "changingLevel": 84.0,
        "changingMode": 239,
        "chromeLevel": 137,
        "contrast": 65,
        "custom1": 216.0,
        "custom2": 32.0,
        "custom3": 125.0,
        "ddeLevel": 25,
        "ddeMode": 221,
        "defogMode": 155,
        "dehazeMode": 239,
        "detail": 128,
        "digitalZoom": 47.0,
        "digitalZoomMode": 157,
        "displayMode": 2,
        "exposureCompensationMode": 213,
        "exposureCompensationPosition": 183,
        "exposureMode": 192,
        "exposureTime": 16,
        "filterMode": 251,
        "fps": 19.0,
        "gain": 111,
        "gainMode": 130,
        "height": 219,
        "imageFlip": 211,
        "initString": "dfhglsjirhuhjfb",
        "isoSensetivity": 32,
        "logMode": 252,
        "noiseReductionMode": 79,
        "nucMode": 228,
        "palette": 115,
        "profile": 108,
        "roiX0": 93,
        "roiX1": 135,
        "roiY0": 98,
        "roiY1": 206,
        "sceneMode": 195,
        "sensitivity": 70.0,
        "sharpening": 196,
        "sharpeningMode": 49,
        "shutterMode": 101,
        "shutterPos": 157,
        "shutterSpeed": 117,
        "stabilisationMode": 170,
        "type": 55,
        "videoOutput": 18,
        "whiteBalanceArea": 236,
        "whiteBalanceMode": 30,
        "wideDynamicRangeMode": 21,
        "width": 150
    }
}

PanTiltParams class description

PanTiltParams class declaration

PanTiltParams class is used to provide pan-tilt parameters structure. Also PanTiltParams provides possibility to write/read params from JSON files (JSON_READABLE macro) and provides methods to encode and decode params. PanTiltParams interface class declared in PanTilt.h file. Class declaration:

class PanTiltParams
{
public:
    /// Pan motor position for encoder. Range: 0 - 65535.
    int panMotorPosition{ 0 };
    /// Tilt motor position for encoder. Range: 0 - 65535.
    int tiltMotorPosition{ 0 };
    /// Pan angle. Range: -180.0 to 180.0.
    float panAngle{ 0.0f };
    /// Tilt angle. Range: -180.0 to 180.0.
    float tiltAngle{ 0.0f };
    /// Pan motor speed. Range: -100.0 to 100.0.
    float panMotorSpeed{ 0.0f };
    /// Tilt motor speed. Range: -100.0 to 100.0. 
    float tiltMotorSpeed{ 0.0f };
    /// Status defining if the pan-tilt device is connected.
    bool isConnected{ false };
	/// Status defining if the pan-tilt device is initialized.
    bool isInitialized{ false };
    /// Init string. Format depends on target controller.
    std::string initString{ "" };
    /// PanTilt custom parameter. Value depends on particular pan-tilt
    /// controller. Custom parameters used when particular pan-tilt equipment
    /// has specific unusual parameter.
    float custom1{ 0.0f };
    /// PanTilt custom parameter. Value depends on particular pan-tilt
    /// controller. Custom parameters used when particular pan-tilt equipment
    /// has specific unusual parameter.
    float custom2{ 0.0f };
    /// PanTilt custom parameter. Value depends on particular pan-tilt
    /// controller. Custom parameters used when particular pan-tilt equipment
    /// has specific unusual parameter.
    float custom3{ 0.0f };

    /// Macro from ConfigReader to make params readable/writable from JSON.
    JSON_READABLE(PanTiltParams, panMotorPosition, tiltMotorPosition, panAngle,
        tiltAngle, panMotorSpeed, tiltMotorSpeed, isConnected, isInitialized,
        initString, custom1, custom2, custom3)

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

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

PanTiltParams class fields description is equivalent to PanTiltParam enum description except initString. Initialization string. initString can have 3 different form of initialization string for the device:
- [serial port name];[baudrate];[camera address];[wait data timeout]
- [serial port name];[baudrate];[camera address]
- [serial port name];[baudrate]
When camera address is not given it is set to 1 as default and same for wait data timeout - 100ms.

Serialize PanTilt params

PanTiltParams class provides method encode(…) to serialize PanTilt params. Serialization of PanTilt params is necessary in case when PanTilt params 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, PanTiltParamsMask* mask = nullptr);

Parameter	Value
data	Pointer to data buffer. Buffer size must be >= 48 bytes.
bufferSize	Data buffer size. Buffer size must be >= 48 bytes.
size	Size of encoded data.
mask	Parameters mask - pointer to PanTiltParamsMask structure. PanTiltParamsMask (declared in PanTilt.h file) determines flags for each field (parameter) declared in PanTiltParams class. If the 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 PanTiltParamsMask structure.

Returns: TRUE if params encoded (serialized) or FALSE if not.

PanTiltParamsMask structure declaration:

struct PanTiltParamsMask
{
    bool panMotorPosition{ true };
    bool tiltMotorPosition{ true };
    bool panAngle{ true };
    bool tiltAngle{ true };
    bool panMotorSpeed{ true };
    bool tiltMotorSpeed{ true };
    bool isConnected{ true };
    bool isInitialized{ true };
    bool custom1{ true };
    bool custom2{ true };
    bool custom3{ true };
};

Example without parameters mask:

// Prepare parameters.
cr::pantilt::PanTiltParams params;
params.panAngle = 160.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::pantilt::PanTiltParams params;
params.panAngle = 160.0f;

// Prepare mask.
cr::pantilt::PanTiltParamsMask mask;
// Exclude tiltAngle.
mask.tiltAngle = false;

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

Deserialize PanTilt params

PanTiltParams class provides method decode(…) to deserialize params. Deserialization of PanTilt params 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::pantilt::PanTiltParams params1;
params1.panAngle = 160.0f;

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

// Decode (deserialize) params.
cr::pantilt::PanTiltParams params2;
params2.decode(buffer, size);

Read params from JSON file and write to JSON file

PanTilt 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:

// Write params to file.
cr::utils::ConfigReader inConfig;
cr::pantilt::PanTiltParams in;
inConfig.set(in, "panTiltParams");
inConfig.writeToFile("PanTiltParams.json");

// Read params from file.
cr::utils::ConfigReader outConfig;
if(!outConfig.readFromFile("PanTiltParams.json"))
{
    cout << "Can't open config file" << endl;
    return false;
}

PanTiltParams.json will look like:

{
    "panTiltParams":
    {
        "panMotorPosition": 43565,
        "tiltMotorPosition": 10500,
        "panAngle": 30.5f,
        "tiltAngle": 89.9f,
        "panMotorSpeed": 50.0f,
        "tiltMotorSpeed": 100.0f,
        "isConnected": true,
        "isInitialized": true,
        "custom1": 0.7f,
        "custom2": 12.0f,
        "custom3": 0.61f
    }
}

Build and connect to your project

Typical commands to build ViscaCamera library:

cd ViscaCamera
mkdir build
cd build
cmake ..
make

If you want connect ViscaCamera library 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 and copy folder of ViscaCamera repository there. New structure of your repository:

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

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_VISCA_CAMERA                    ON  CACHE BOOL "" FORCE)
if (${PARENT}_SUBMODULE_VISCA_CAMERA)
    SET(${PARENT}_VISCA_CAMERA                          ON  CACHE BOOL "" FORCE)
    SET(${PARENT}_VISCA_CAMERA_TEST                     OFF CACHE BOOL "" FORCE)
endif()

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

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

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

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 Lens library in your src/CMakeLists.txt file:

target_link_libraries(${PROJECT_NAME} ViscaCamera)

Done!

Simple example

Simple example is application which initializes controller and provide few options to user to control camera.

#include <iostream>
#include "ViscaCamera.h"

int main(void)
{
    // Init camera controller.
    cr::visca::ViscaCamera controller;
    if (!controller.openCamera("/dev/ttyUSB0"))
        return -1;

    while (true)
    {
        // Main dialog.
        int option = -1;
        std::cout << "Options (1:Zoom tele, 2:Zoom wide, 3:Zoom stop), " <<
        "4:Brightness+1, 5:Brightness-1 : ";
        std::cin >> option;

        // Get all camera params.
        cr::camera::CameraParams cameraParams;
        controller.getParams(cameraParams);

        // Get all lens params.
        cr::lens::LensParams lensParams;
        controller.getParams(lensParams);

        switch (option)
        {
        case 1: // Zoom tele.
            controller.executeCommand(cr::lens::LensCommand::ZOOM_TELE);
            break;
        case 2: // Zoom wide.
            controller.executeCommand(cr::lens::LensCommand::ZOOM_WIDE);
            break;
        case 3: // Zoom stop.
            controller.executeCommand(cr::lens::LensCommand::ZOOM_STOP);
            break;
        case 4:
            controller.setParam(cr::camera::CameraParam::BRIGHTNESS,
            cameraParams.brightness + 1);
            break;
        case 5:
            controller.setParam(cr::camera::CameraParam::BRIGHTNESS,
            cameraParams.brightness - 1);
            break;
        default:
            break;
        }
    }
    return 1;
}

Test application

ViscaCamera/test folder contains test application which demonstrates how to use ViscaCamera library. Test application allows to connect to camera and then set and get camera params. Test application can be used to test camera controller and to set/get camera params.

Test application will connect to camera and will show main menu. Main menu allows to set and get camera params and execute commands.

Test application output will look like:

================================================
VentusCamera tester v1.0.3
================================================

Choose option:
1 - Set lens param
2 - Get lens param
3 - Set camera param
4 - Get camera param
5 - Execute lens command
5 - Execute camera command
-1 - Exit

ViscaCamera C++ library

Table of contents

Overview

Versions

Library files

ViscaCamera class description

ViscaCamera class declaration

getVersion method

openLens method

openCamera method

openPanTilt method

initLens method

initCamera method

initPanTilt method

closeLens method

closeCamera method

closePanTilt method

isLensOpen method

isCameraOpen method

isPanTiltOpen method

isLensConnected method

isCameraConnected method

isPanTiltConnected method

setParam method

getParam method

getParams method

executeCommand method

addVideoFrame method

decodeAndExecuteCommand method

Data structures

LensCommand enum

CameraCommand enum

PanTiltCommand enum

LensParam enum

CameraParam enum

PanTiltParam enum

LensParams class description

LensParams class declaration

Serialize lens params

Deserialize lens params

Read and write lens params to JSON file

CameraParams class description

CameraParams Class declaration

Serialize camera params

Deserialize camera params

Read and write camera params to JSON file

PanTiltParams class description

PanTiltParams class declaration

Serialize PanTilt params

Deserialize PanTilt params

Read params from JSON file and write to JSON file

Build and connect to your project

Simple example

Test application