JeVois processing engine - gets images from camera sensor, processes them, and sends results over USB.
The Engine is orchestrating the execution of vision processing software. It is a Manager, i.e., it is the root of a hierarchy of Component objects and it handles access to their Parameter settings and their construction, init(), unInit(), and destruction. The component hierarchy consists of Engine at the root, then one Module which is selected by the user at runtime, e.g., by selecting a given video format on video camera software running on a host computer connected to the JeVois hardware. The Module may then contain an arbitrarily complex hierarchy of Component objects with Parameter settings in them. Module derives from Component and thus may also have its own Parameter settings.
Engine contains the following basic elements:
- A VideoInput, instantiated as either a Camera for live video streaming or a MovieInput for processing of pre-recorded video files or sequences of images (useful during algorithm development, to test and optimize on reproducible inputs);
- A VideoOutput, instantiated either as a USB Gadget driver when running on the JeVois hardware platform, or as a VideoDisplay when running on a computer that has a graphics display, or as a MovieOutput to save output video frames to disk, or as a VideoOutputNone if desired for benchmarking of vision algorithms while discounting any work related to transmitting output frames.
- A DynamicLoader which handles loading the chosen vision processing Module at runtime depending on user selections;
- Any number of UserInterface objects, instantiated as either a hardware Serial port (for the 4-pin JST 1.0mm connector on the platform hardware), a serial-over-USB Serial port (visible on the host computer to which the JeVois hardware is connected by USB), or an StdioInterface (used to accept commands and print results directly in the terminal where the JeVois Engine was started, particularly useful when running on a generic computer as opposed to the platform hardware). When running on platform hardware, usually two UserInterface objects are created (one hardware Serial, one serial-over-USB Serial), while, when running on a generic computer, usually only one UserInterface is created (of type StdioInterface to accept commands directly in the terminal in which the jevois-daemon was started);
- The list of VideoMapping definitions imported from your videomappings.cfg file. These definitions specify which video output modes are available over USB and their corresponding Camera settings and which Module to use, as well as which modes are available that do not have any sreaming video output over USB (e.g., when connecting the hardware platform to an Arduino only).
The main loop of Engine runs until the user decides to quit, and basically goes through the following steps:
- Create an InputFrame object which is an exception-safe wrapper around the next available Camera frame. The frame may not have been captured yet. The InputFrame can be understood as a mechanism to gain access to that frame in the future, when it has become available (i.e., has been captured by the camera). This is very similar to the std::future framework of C++11.
- When the current VideoMapping specifies that we will be streaming video frames out over USB, also create an OutputFrame object which is an exception-safe wrapper around the next available Gadget frame. This is also just a mechanism for gaining access to the next blank video buffer that is available from the USB driver and that we should fill with interesting pixel data before sending it over USB to a host computer.
- Call the currently-loaded Module's process() function, either as process(InputFrame, OutputFrame) when the current VideoMapping specifies that some video output is to be sent over USB, or as process(InputFrame) when the current VideoMapping specifies no video output. Any exception thrown by the Module's process() function will be caught, reported, and ignored. The process() function would typically request the next available camera image through the InputFrame wrapper (this request may block until the frame has been captured by the camera sensor hardware), process that image, request the next available output image through the OutputFrame wrapper (when VideoMapping specifies that there is USB video output), and paint some results into that output image, which will then be sent to the host coputer over USB, for display by some webcam program or for further processing by some custom vision software running on that computer. In addition, the currently loaded Module may issue messages over the UserInterface ports (e.g., indicating the location at which an object was found, to let an Arduino know about it).
- Read any new commands issued by users over the UserInterface ports and execute the appropriate commands.
- Handle user requests to change VideoMapping, when they select a different video mode in their webcam software running on the host computer connected to the JeVois hardware. Such requests may trigger unloading of the current Module and loading a new one, and changing camera pixel format, image size, etc. These changes are guaranteed to occur when the Module's process() function is not running, i.e., Module programmers do not have to worry about possible changes in image dimensions or pixel formats during execution of their process() function.
- Pass any user requests received over USB or UserInterface to adjust camera parameters to the actual Camera hardware driver (e.g., when users change contrast in their webcam program, that request is sent to the Engine over USB, and the Engine then forwards it to the Camera hardware driver).
Definition at line 387 of file Engine.H.
|
| Engine (std::string const &instance) |
| Constructor. More...
|
|
| Engine (int argc, char const *argv[], std::string const &instance) |
| Constructor with command-line parsing. More...
|
|
| ~Engine () |
| Destructor. More...
|
|
void | reloadVideoMappings () |
| Re-load video mappings from videomappings.cfg. More...
|
|
const VideoMapping & | findVideoMapping (unsigned int oformat, unsigned int owidth, unsigned int oheight, float oframespersec) const |
| Find the VideoMapping that has the given output specs, or throw if not found. More...
|
|
const VideoMapping & | getCurrentVideoMapping () const |
| Get the current video mapping. More...
|
|
size_t | numVideoMappings () const |
| Return the number of video mappings. More...
|
|
const VideoMapping & | getVideoMapping (size_t idx) const |
| Allow access to our video mappings which are parsed from file at construction. More...
|
|
size_t | getVideoMappingIdx (unsigned int iformat, unsigned int iframe, unsigned int interval) const |
| Get the video mapping index for a given UVC iformat, iframe and interval. More...
|
|
const VideoMapping & | getDefaultVideoMapping () const |
| Allow access to the default video mapping. More...
|
|
size_t | getDefaultVideoMappingIdx () const |
| Allow access to the default video mapping index. More...
|
|
void | foreachVideoMapping (std::function< void(VideoMapping const &m)> &&func) |
| Run a function on every video mapping. More...
|
|
void | requestSetFormat (int idx) |
| Use this to request a format change from within process() More...
|
|
void | quit () |
| Terminate the program. More...
|
|
void | reboot () |
| Request a reboot. More...
|
|
void | setFormat (size_t idx) |
| Callback for when the user selects a new output video format. More...
|
|
void | streamOn () |
| Start streaming on video from camera, processing, and USB. More...
|
|
void | streamOff () |
| Stop streaming on video from camera, processing, and USB. More...
|
|
int | mainLoop () |
| Main loop: grab, process, send over USB. Should be called by main application thread. More...
|
|
void | sendSerial (std::string const &str, bool islog=false) |
| Send a string to all serial ports. More...
|
|
std::shared_ptr< Module > | module () const |
| Get a pointer to our current module (may be null) More...
|
|
std::shared_ptr< IMU > | imu () const |
| Get a pointer to our IMU (may be null) More...
|
|
std::shared_ptr< Camera > | camera () const |
| Get a pointer to our Camera (may be null, especially if not using a camera but, eg, movie input) More...
|
|
void | drawCameraGUI () |
| Draw all camera controls into our GUI. More...
|
|
void | registerPythonComponent (Component *comp, void *pyinst) |
| Register a component as linked to some python code, used by dynamic params created in python. More...
|
|
void | unRegisterPythonComponent (Component *comp) |
| Unregister a component as linked to some python code, used by dynamic params created in python. More...
|
|
Component * | getPythonComponent (void *pyinst) const |
| Get the component registered with a given python instance. More...
|
|
void | reportError (std::string const &err) |
|
void | clearErrors () |
| Clear all errors currently displayed in the JeVois-Pro GUI. More...
|
|
void | nextDemo () |
| When in demo mode, switch to next demo. More...
|
|
void | abortDemo () |
| When in demo mode, abort demo mode. More...
|
|
| Manager (std::string const &instance="TheManager") |
| Constructor without command-line args. More...
|
|
| Manager (int argc, char const *argv[], std::string const &instance="TheManager") |
| Constructor. More...
|
|
void | setCommandLineArgs (int argc, char const *argv[]) |
| Set the command-line arguments, call this before start() if args were not passed at construction. More...
|
|
virtual | ~Manager () |
| Destructor. More...
|
|
template<class Comp , typename... Args> |
std::shared_ptr< Comp > | addComponent (std::string const &instanceName, Args &&...args) |
| Pseudo-constructor: construct a top-level Component. More...
|
|
template<class Comp , typename... Args> |
std::shared_ptr< Comp > | addSubComponent (std::string const &instanceName, Args &&...args)=delete |
| Use addComponent() on the Manager as opposed to jevois::Component::addSubComponent() More...
|
|
template<class Comp > |
void | removeComponent (std::shared_ptr< Comp > &component) |
| Remove a top-level Component from the Manager, by shared_ptr. More...
|
|
template<class Comp > |
void | removeSubComponent (std::shared_ptr< Comp > &component)=delete |
| Use removeComponent() on the Manager as opposed to jevois::Component::removeSubComponent() More...
|
|
void | removeComponent (std::string const &instanceName, bool warnIfNotFound=true) |
| Remove a top-level Component from the Manager, by instance name. More...
|
|
void | removeSubComponent (std::string const &instanceName, bool warnIfNotFound)=delete |
| Use removeComponent() on the Manager as opposed to jevois::Component::removeSubComponent() More...
|
|
template<class Comp = jevois::Component> |
std::shared_ptr< Comp > | getComponent (std::string const &instanceName) const |
| Get a top-level component by instance name. More...
|
|
template<class Comp > |
std::shared_ptr< Comp > | getSubComponent (std::string const &instanceName) const =delete |
| Use getComponent() on the Manager as opposed to jevois::Component::getSubComponent() More...
|
|
const std::vector< std::string > & | remainingArgs () const |
| Get the remaining arguments that were not parsed by the command line. More...
|
|
| Component (std::string const &instance) |
| Constructor. More...
|
|
virtual | ~Component () |
| Virtual destructor for safe inheritance. More...
|
|
template<class Comp , typename... Args> |
std::shared_ptr< Comp > | addSubComponent (std::string const &instance, Args &&...args) |
| Pseudo-constructor: construct and add another component as a subcomponent of this one. More...
|
|
template<class Comp > |
void | removeSubComponent (std::shared_ptr< Comp > &component) |
| Remove a sub-Component from this Component, by shared_ptr. More...
|
|
void | removeSubComponent (std::string const &instance, bool warnIfNotFound=true) |
| Remove a sub-Component from this Component, by instance name. More...
|
|
template<class Comp = jevois::Component> |
std::shared_ptr< Comp > | getSubComponent (std::string const &instance) const |
| Get a sub-component by instance name. More...
|
|
bool | isTopLevel () const |
| Returns true if this component is top-level, i.e., its parent is jevois::Manager. More...
|
|
Engine * | engine () const |
| Get a handle to our Engine, or throw if we do not have an Engine as root ancestor. More...
|
|
bool | initialized () const |
| Has this component been initialized yet? More...
|
|
const std::string & | className () const |
| The class name of this component. More...
|
|
const std::string & | instanceName () const |
| The instance name of this component. More...
|
|
template<typename T > |
std::vector< std::string > | setParamVal (std::string const ¶mdescriptor, T const &val) |
| Set a parameter value. More...
|
|
template<typename T > |
void | setParamValUnique (std::string const ¶mdescriptor, T const &val) |
| Set a parameter value, simple version assuming only one parameter match. More...
|
|
template<typename T > |
std::vector< std::pair< std::string, T > > | getParamVal (std::string const ¶mdescriptor) const |
| Get parameter(s) value(s) by descriptor. More...
|
|
template<typename T > |
T | getParamValUnique (std::string const ¶mdescriptor) const |
| Get a parameter value, simple version assuming only one parameter match. More...
|
|
std::vector< std::string > | setParamString (std::string const ¶mdescriptor, std::string const &val) |
| Set a parameter value, by string. More...
|
|
void | setParamStringUnique (std::string const ¶mdescriptor, std::string const &val) |
| Set a parameter value by string, simple version assuming only one parameter match. More...
|
|
std::vector< std::pair< std::string, std::string > > | getParamString (std::string const ¶mdescriptor) const |
| Get a parameter value, by string. More...
|
|
std::string | getParamStringUnique (std::string const ¶mdescriptor) const |
| Get a parameter value by string, simple version assuming only one parameter match. More...
|
|
void | freezeParam (std::string const ¶mdescriptor) |
| Freeze a parameter, by name, see ParameterBase::freeze() More...
|
|
void | unFreezeParam (std::string const ¶mdescriptor) |
| Unfreeze a parameter, by name, see ParameterBase::unFreeze() More...
|
|
void | freezeAllParams () |
| Freeze all parameters. More...
|
|
void | unFreezeAllParams () |
| Unfreeze all parameters. More...
|
|
std::string | descriptor () const |
| Get our full descriptor (including all parents) as [Instancename]:[...]:[...]. More...
|
|
void | setParamsFromFile (std::string const &filename) |
| Set some parameters from a file. More...
|
|
std::istream & | setParamsFromStream (std::istream &is, std::string const &absfile) |
| Set some parameters from an open stream. More...
|
|
virtual void | paramInfo (std::shared_ptr< UserInterface > s, std::map< std::string, std::string > &categs, bool skipFrozen, std::string const &cname="", std::string const &pfx="") |
| Get machine-oriented descriptions of all parameters. More...
|
|
void | foreachParam (std::function< void(std::string const &compname, ParameterBase *p)> func, std::string const &cname="") |
| Run a function on every param we hold. More...
|
|
template<typename T > |
std::shared_ptr< DynamicParameter< T > > | addDynamicParameter (std::string const &name, std::string const &description, T const &defaultValue, ParameterCategory const &category) |
| Add a new parameter after the Component has already been constructed. More...
|
|
template<typename T , template< typename > class ValidValuesSpec> |
std::shared_ptr< DynamicParameter< T > > | addDynamicParameter (std::string const &name, std::string const &description, T const &defaultValue, ValidValuesSpec< T > const &validValuesSpec, ParameterCategory const &category) |
| Add a new parameter after the Component has already been constructed. More...
|
|
template<typename T > |
void | setDynamicParameterCallback (std::string const &name, std::function< void(T const &)> cb, bool callnow=true) |
| Register a callback with a previously created dynamic parameter. More...
|
|
void | removeDynamicParameter (std::string const &name) |
| Remove a previously added dynamic parameter. More...
|
|
void | setPath (std::string const &path) |
| Assign a filesystem path to this component. More...
|
|
std::filesystem::path | absolutePath (std::filesystem::path const &path="") |
| If given path is relative (not starting with /), prepend the Component path to it. More...
|
|
virtual | ~ParameterRegistry () |
| Virtual destructor for safe inheritance. More...
|
|
|
void | runScriptFromFile (std::string const &filename, std::shared_ptr< UserInterface > ser, bool throw_no_file) |
| Run a script from file. More...
|
|
void | onParamChange (engine::serialdev const ¶m, std::string const &newval) override |
| Parameter callback. More...
|
|
void | onParamChange (engine::usbserialdev const ¶m, std::string const &newval) override |
| Parameter callback. More...
|
|
void | onParamChange (engine::cpumode const ¶m, engine::CPUmode const &newval) override |
| Parameter callback. More...
|
|
void | onParamChange (engine::cpumax const ¶m, unsigned int const &newval) override |
| Parameter callback. More...
|
|
void | onParamChange (engine::videoerrors const ¶m, bool const &newval) override |
| Parameter callback. More...
|
|
void | onParamChange (engine::gui const ¶m, bool const &newval) override |
| Parameter callback. More...
|
|
void | onParamChange (engine::cpumaxl const ¶m, unsigned int const &newval) override |
| Parameter callback. More...
|
|
void | onParamChange (engine::cpumodel const ¶m, engine::CPUmode const &newval) override |
| Parameter callback. More...
|
|
void | onParamChange (engine::demomode const ¶m, float const &newval) override |
| Parameter callback. More...
|
|
void | preInit () override |
| Override of Manager::preInit() More...
|
|
void | postInit () override |
| Override of Manager::postInit() More...
|
|
bool | parseCommand (std::string const &str, std::shared_ptr< UserInterface > s, std::string const &pfx="") |
| Parse a user command received over serial port. More...
|
|
void | onParamChange (manager::loglevel const ¶m, manager::LogLevel const &newval) override |
| Parameter callback. More...
|
|
void | onParamChange (manager::tracelevel const ¶m, unsigned int const &newval) override |
| Parameter callback. More...
|
|
void | constructHelpMessage (std::ostream &out) const |
| Constructs a help message from all parameters in the model, and outputs it to 'out'. More...
|
|
void | printHelpMessage () const |
| Constructs a help message and tries to send it to /usr/bin/less. More...
|
|
virtual void | preUninit () |
| Called before all sub-Components are uninit()ed. More...
|
|
virtual void | postUninit () |
| Called after all sub-Components are uninit()ed. More...
|
|
void | addParameter (ParameterBase *const param) |
| The Parameter class uses this method to register itself on construction with its owning Component. More...
|
|
void | removeParameter (ParameterBase *const param) |
| The Parameter class uses this method to un-register itself on destruction with its owning Component. More...
|
|
void | callbackInitCall () |
| For all parameters that have a callback which has never been called, call it with the default param value. More...
|
|
|
(Note that these are not member functions.)
|
size_t | frameNum () |
| Get the current video processing frame number. More...
|
|
| JEVOIS_DECLARE_PARAMETER (cameradev, std::string, "Camera device name (if starting with /dev/v...), or movie " "file name (e.g., movie.mpg) or image sequence (e.g., im%02d.jpg, to read frames " "im00.jpg, im01.jpg, etc).", JEVOIS_CAMERA_DEFAULT, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (camerasens, CameraSensor, "Camera sensor. Users would usually not set this parameter " "manually, it is set through boot-time configuration.", JEVOIS_CAMERASENS_DEFAULT, CameraSensor_Values, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (cameranbuf, unsigned int, "Number of video input (camera) buffers, or 0 for automatic.", 0, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (gadgetdev, std::string, "Gadget device name. This is used on platform hardware only. " "On host hardware, a display window will be used unless gadgetdev is None (useful " "for benchmarking) or is a file stem for a movie file that does not start with /dev/ " "(and which should contain a printf-style directive for a single int argument, " "the movie number).", JEVOIS_GADGET_DEFAULT, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (gadgetnbuf, unsigned int, "Number of video output (USB video) buffers, or 0 for auto", 0, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (videomapping, int, "Index of Video Mapping to use, or -1 to use the default mapping. " "Note that this parameter is only available when parsing command-line arguments. " "At runtime, the setmapping command should be used instead.", -1, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER_WITH_CALLBACK (serialdev, std::string, "Hardware (4-pin connector) serial device name, " "or 'stdio' to use the console, or empty for no hardware serial port", JEVOIS_SERIAL_DEFAULT, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER_WITH_CALLBACK (usbserialdev, std::string, "Over-the-USB serial device name, or empty", JEVOIS_USBSERIAL_DEFAULT, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (camreg, bool, "Enable raw access to camera registers through setcamreg and getcamreg", false, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (imureg, bool, "Enable raw access to IMU registers through setimureg and getimureg", false, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (camturbo, bool, "Enable camera turbo mode by relaxing the need for DMA-coherent video " "buffer memory. This can accelerate severalfolds access to the captured image data, but " "it may also yield stripe artifacts with some modules, such as PassThrough. The stripes " "are pieces of incorrect data in the cache. You should experiment with each particular " "module. Turbo mode is not recommended for any production-grade application.", false, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DEFINE_ENUM_CLASS (SerPort,(None)(All)(Hard)(USB)) |
| Enum for Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (serlog, SerPort, "Show log and debug messages on selected serial port(s)", SerPort::None, SerPort_Values, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER_WITH_CALLBACK (videoerrors, bool, "Show any machine vision module errors (exceptions) " "in the video stream. Only takes effect if streaming video to USB.", true, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (serout, SerPort, "Send module serial messages to selected serial port(s)", SerPort::None, SerPort_Values, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DEFINE_ENUM_CLASS (CPUmode,(PowerSave)(Conservative)(OnDemand)(Interactive)(Performance)) |
| Enum for Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER_WITH_CALLBACK (cpumode, CPUmode, "CPU frequency modulation mode" " for A73 big cores", CPUmode::Performance, CPUmode_Values, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER_WITH_CALLBACK (cpumodel, CPUmode, "CPU frequency modulation mode for A53 little cores", CPUmode::Performance, CPUmode_Values, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER_WITH_CALLBACK (cpumax, unsigned int, "CPU maximum frequency in MHz" ". To enable overclock frequencies above 2208 MHz, you need to first edit " "/boot/env.txt and change max_freq_a73, then reboot. Use with caution!", 2208, { 500, 667, 1000, 1200, 1398, 1512, 1608, 1704, 1800, 1908, 2016, 2100, 2208, 2304, 2400 }, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER_WITH_CALLBACK (cpumaxl, unsigned int, "CPU maximum frequency in MHz, for A53 little cores. " "To enable overclock frequencies above 1800 MHz, you need to first edit " "/boot/env.txt and change max_freq_a53, then reboot. Use with caution!", 1800, { 500, 667, 1000, 1200, 1398, 1512, 1608, 1704, 1800, 1908, 2016, 2100, 2208 }, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (multicam, bool, "Allow up to 3 JeVois cameras on one USB bus. Enabling this " "reduces the amount of USB bandwidth used by each JeVois camera, from 3kb " "per USB isochronous microframe to 1kb. All 3 JeVois cameras must have this " "option enabled, and the JeVois linux kernel module should also have " "been loaded with multicam on.", false, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (quietcmd, bool, "When true, do not issue a message 'OK' after every correct command " "received at the command-line interface. Recommended for advanced users only.", false, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (python, bool, "When true, enable support for modules written in Python. Otherwise, " "attempting to load a python module will throw an exception. Disabling python saves " "a lot of memory and may be useful when using C++ modules that run large deep neural " "networks.", true, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (serlimit, size_t, "Maximum number of serial messages that can be sent by a module " "using sendSerial(), for each video frame, or 0 for no limit. Any message sent by " "the module beyond the first serlimit ones will be dropped. This is useful to avoid " "overloading the serial link, for example in case one is running a ArUco detector and " "a large number of ArUco tags are present in the field of view of JeVois.", 0, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER_WITH_CALLBACK (gui, bool, "Use a graphical user interface instead of plain display " "when true", true, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (conslock, bool, "Lock the console and capture the keyboard and mouse to avoid " "interference, only effective on JeVois-Pro Platform, otherwise ignored. Set conslock " "to false if you are experiencing hard crashes and want to run jevoispro-daemon in gdb.", true, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (watchdog, double, "Timeout in seconds after which we kill this process if the main loop " "is stuck somehow, or 0.0 for no watchdog", 10.0, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER_WITH_CALLBACK (demomode, float, "Show a demonstration of some available JeVois-Pro " "machine vision modules, cycling to the next modules after a number " "of seconds specified by this parameter (or 0.0 for no demo mode).", 0.0F, ParamCateg) |
| Parameter. More...
|
|
static const ParameterCategory | ParamCateg ("General Options") |
| Parameter category. More...
|
|
| JEVOIS_DECLARE_PARAMETER (help, bool, "Print this help message", false, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DEFINE_ENUM_CLASS (LogLevel,(fatal)(error)(info)(debug)) |
| Enum for Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER_WITH_CALLBACK (loglevel, LogLevel, "Set the minimum log level to display", LogLevel::info, LogLevel_Values, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER_WITH_CALLBACK (tracelevel, unsigned int, "Set the minimum trace level to display", 0, ParamCateg) |
| Parameter. More...
|
|
| JEVOIS_DECLARE_PARAMETER (nickname, std::string, "Nickname associated with this camera, useful when multiple " "JeVois cameras are connected to a same USB bus", "jevois", ParamCateg) |
| Parameter. More...
|
|