Global Settings#

The following settings are used to configure the global settings of the application. Generally, you’d better to configure them when you start the application and do not change them during the running time, although some of them can be changed at any time.

Product Information#

struct ProductInfo#

VisionFlow production infomation.

This class is used to describe the production infomation of VisionFlow. include the version, build date, and so on.

Public Members

int version_major#: The major version, such as 1.

int version_minor#: The minor version, such as 2.

int version_patch#: The patch version, such as 35.

uint64_t version_num#: The version number, equal to (version_major * 1000000 + version_minor * 1000 + version_patch). e.g. 1.2.35 is 001002035.

std::string version#: The version string, such as “1.2.35”.

std::string version_full#: The full version string with revision, e.g. “1.2.35.beta.a0f8b8b.0”.

std::string file_hash#: The file hash, e.g. “a0f8b8b.0”.

std::string file_full_hash#: The full file hash.

std::string release_tag#: The release tag, one of “alpha”, “beta”, “preview”, “release”.

int64_t build_timestamp#: The build timestamp, e.g. 1514098983.

std::string copyright#

Public Static Functions

static const ProductInfo &Get()#

Get the release version information of VisionFlow. With this function, you can get the release version information at runtime.

Returns:: the version information.

Logging Settings#

using LogSinkFunc = void (*)(int, const char*, size_t)#: Log sink interface. with this interface, you can implement your own log sink to receive log messages.

struct LoggerOptions#

VisionFlow Logger Options.

Public Members

const char *file_sink = nullptr#: Log file path, should be encoded in utf-8; after setting this option, VisionFlow will write the log to the file; if the file does not exist, VisionFlow will try to create it automatically; if the file already exists , The log information will be appended to the file; the default path is empty, which means that the log will not be output to any file.

LogSinkFunc func_sink = nullptr#: Pass in the function pointer used to receive the log, and output the log to your custom function.

bool stdout_sink = true#: print the log to the standard output device, this option is enabled by default.

bool msvc_sink = false#: When debugging on the Windows platform, you can enable this option to print the log to the debug output window of Visual Studio.

unsigned int flush_level = 4#: control the refreshing level of log file. The flush_level range in [0, 6], include on_trace=0, on_debug=1, on_info=2, on_warn=3, on_error=4, on_critical=5, on_off=6. And the default value is 4 (on_error), which means the log file will be refreshed when error or more serious situation (eg:critical) occurring. When flush_level greater than or equal to 6 (on_off), the log file will not be refreshed.

ILogSink *custom_sink = nullptr#: custom_sink is a pointer to an ILogSink interface implementation, used for custom log handling. It defaults to nullptr, meaning no custom log sink is used.

void visionflow::init_logger(const LoggerOptions &options)#

class ILogSink#

ILogSink is an interface class designed to provide an abstraction for logging functionality.

Public Functions

virtual void log(int level, const std::string &message) = 0#

Pure virtual function log that must be implemented in derived classes for handling logging.

Parameters:

level – The log level.
message – The content of the log message.

Init Settings#

using visionflow::LicenseErrorCallBack = std::function<bool(const std::string &product_name, const std::string &product_version, const std::string &feature_name, const std::string &error_message)>#

struct LicenseOptions#

Public Members

std::string server_addr = {}#: Server IP address (127.0.0.1): 1.If it is empty, the local lock will be used; 2.If it is not empty, the network lock will be used.

std::string license_id = {}#: Dongle unique ID, The sn of the lock or the user_guid of the slock, you can get them with visionflow::helper::license_devices(). 1. If it is empty, it will automatically find a lock that meets the conditions when logging in. 2. If it is not empty, it will only find and use the specified lock.

LicenseErrorCallBack callback_fun = nullptr#: Callback function in case of an error in the authorization verification phase, if the return value is true, the login will be attempted again, otherwise the verification of this feature will be skipped.

struct InitOptions#

Global initialize options.

Public Members

std::string product_mark = {}#: The product identifier, which is written to the project .vfpro file when a new project is created, identifies that the project was created with this product. Normally only projects with an identifier that matches the identifier of this product will be allowed to be opened (this means that it is a project that is recognized by the current product). If you open an old project (i.e. without a product identification field in the .vfpro file), it will be compatible by default and will write the current product’s identification upon successful opening of the project. Finally, it is advisable not to leave this field empty.

std::vector<std::string> compatible_product_marks = {}#: Sometimes you may want to be able to open projects created by other products, and you can do this by writing the mark of those products to this list. If product_mark is not empty, it will be added to this list automatically, if you don’t want to do the checking of the mark field, leave product_mark and compatible_product_marks both empty. If you want to be compatible with products that have empty identifiers (i.e. they have an identifier field, but the identifier field is empty), you need to explicitly add an empty identifier (e.g. “”) to this list.

LoggerOptions logger = {}#: Logger options.

const char *language = ""#: Language used in VisionFlow. Currently, there are two language you can choose : Chinese (zh_CN) or English (en_US). By default, VisionFlow will use the language consistent with the operating system settings if you don’t set any language or set an empty string.

LicenseOptions license = {}#: Configure license: server addr, license id and callback fun. LicenseOptions.

const char *cloud_project_cache_dir = nullptr#: Where the cloud project cache directory is located, which will be in the user home directory by default or set this option to empty string.

const char *cloud_metadata_cache_dir = nullptr#: Where the cloud metadata cache directory is located, which will be in the user home directory by default or set this option to empty string.

const char *runtime_timing_cache_dir = nullptr#

The directory where the runtime timing cache is located, which will be in the user home directory by default, or you can set this option to empty string to disable timing cache.

The runtime timing cache is used to store the timing information of the runtime initialing, which can be used to analyze the performance of the runtime initialing.

size_t global_thread_pool_size = 0#

The size of the global thread pool. VisionFlow will create a thread pool to running the asynchronous tasks such as inferring sample in asynchronous mode or synchronize data with the cloud. You can set the thread number of the global thread pool by this option. A value automatically determined based on hardware conditions(typically the

number of CPU cores) will be set if the given value is 0 (by default).

double view_tagger_iou_upper_threshold = 0.85#

The larger CIou threshold for opers::ViewTagger to automatically divide into training or testing sets and retain the tags of new views based on the TaggedPolygonList, which is generated from the old views. Default is 0.85.

The input view will be compared with TaggedPolygon to calculate the CIou value.

If the value is greater than view_tagger_iou_upper_threshold, the view will inherit the SplitTag and Tags from the TaggedPolygon.
If the value is between view_tagger_iou_lower_threshold and view_tagger_iou_upper_threshold, the view will be marked as Unknown and an additional “VFLOW-Candidate:=Train” or “VFLOW-Candidate:=Test” Tag will be added, suggesting that it should be added to the training or test set.
If the value is less than view_tagger_iou_lower_threshold, the view will be marked as Unknown and no Tags will be added.

double view_tagger_iou_lower_threshold = 0.1#: The smaller CIou threshold for opers::ViewTagger to automatically set new views as unknow tag (Unlabeled Dataset) based on the TaggedPolygonList, which is generated from the old views. Default is 0.1.

void visionflow::initialize(const InitOptions &options = {})#

Initialize the visionflow library. This function should be called before calling any other interface of the VisionFlow library.

Throws:: excepts::LicenseError – Failed to Initialize authorization verification service or failed to open license client.

Environment Variables#

class Environment#

Environment stores the configurations of environmental variables with a global map.

Public Static Functions

static const std::string &Get(const std::string &key)#

Get the value of the environment with key.

Parameters:: key – The environment key.
Throws:: excepts::DataNotFound – Throws if key not exists in the map.
Returns:: const std::string& the environment value of the key.

static void Set(const std::string &key, const std::string &value)#

Set the environment variable. If the key not exists, it will be added into map. Otherwise, the map will be updated with the new value.

Parameters:

key – The key of the environment variable.
value – The value of the environment variable.

static bool Exists(const std::string &key)#

Check if the environment variable with the key exists.

Parameters:: key – The key of the environment variable.
Returns:: true
Returns:: false

static void Erase(const std::string &key)#

Erase the environment variable in the map with the key.

Note

Nothing will happen if the key not exists in the map.

Parameters:: key – The key of the environment variable.

static void Clear()#: Clear all the environmental variables.

static std::vector<std::string> AllEnvKeys()#

Get all environment variables’ keys in the map.

Returns:: std::vector<std::string>

static bool MeetRequirements(const std::map<std::string, std::string> &env_vars)#

Check if the current configurations of the Environment Management System meets the environmental conditions with a map of environment variables.

Note

The current Environment system meets requirements means all key-value pairs in the env_vars exist in Environment system.

Parameters:: env_vars – The map of environment variables to be checked.
Returns:: true The current environment system meets the requirements of the param’s environmental condition.
Returns:: false The current environment system does not meet the requirements of the param’s environmental condition.

static std::map<std::string, std::string> GetAllEnvironmentVariables()#

Get the All Environment Variables key-value pairs.

Returns:: std::map<std::string, std::string> The key-value pairs of all Environment Variables.