Quickstart ========== Installation ------------ Before installing *libuca* itself, you should install any drivers and SDKs needed to access the cameras you want to access through *libuca*. Now you have two options: install pre-built packages or build from source. Installing packages ~~~~~~~~~~~~~~~~~~~ Packages for the core library and all plugins are currently provided for openSUSE and can be obtained from the openSUSE Build Service at https://build.opensuse.org/package/show/home:ufo-kit/libuca. Building on Linux ~~~~~~~~~~~~~~~~~ In order to build *libuca* from source, you need - CMake, - a C compiler (currently tested with gcc and clang), - GLib and GObject development libraries and - any required camera SDKs. For the base system, install :: [Debian] sudo apt-get install libglib2.0 cmake gcc [openSUSE] sudo zypper in glib2-devel cmake gcc In case you want to use the graphical user interface you also need the Gtk+ development libraries:: [Debian] sudo apt-get install libgtk+2.0-dev [openSUSE] sudo zypper in gtk2-devel To generate bindings for third-party languages, you have to install :: [Debian] sudo apt-get install gobject-introspection [openSUSE] sudo zypper in gobject-introspection-devel Fetching the sources ^^^^^^^^^^^^^^^^^^^^ Clone the repository :: git clone https://github.com/ufo-kit/libuca or download the latest release at https://github.com/ufo-kit/libuca/releases and unzip the ``.zip`` file:: unzip libuca-x.y.z.zip or untar the ``.tar.gz`` file:: tar -zxvf libuca-x.y.z.tar.gz and create a new, empty build directory inside:: cd libuca/ mkdir build Configuring and building ^^^^^^^^^^^^^^^^^^^^^^^^ Now you need to create the Makefile with CMake. Go into the build directory and point CMake to the ``libuca`` top-level directory:: cd build/ cmake .. As long as the last line reads "Build files have been written to", the configuration stage is successful. In this case you can build ``libuca`` with :: make and install with :: sudo make install If an *essential* dependency could not be found, the configuration stage will stop and build files will not be written. If a *non-essential* dependency (such as a certain camera SDK) is not found, the configuration stage will continue but that particular camera support not built. If you want to customize the build process you can pass several variables to CMake:: cmake .. -DPREFIX=/usr -DLIBDIR=/usr/lib64 The former tells CMake to install into ``/usr`` instead of ``/usr/local`` and the latter that we want to install the libraries and plugins into the ``lib64`` subdir instead of the default ``lib`` subdir as it is common on SUSE systems. Building on Windows ~~~~~~~~~~~~~~~~~~~ Using MSYS2, the build procedure is similar to Linux but differs in some points. First, download msys2--.exe from `msys2.org `_ (preferably the x86_64 variant) and install it to ``C:\msys64`` or any other location. Run the MSYS2 MinGW shell from the start menu and update the core if this is the first time using:: pacman -Syu Close the terminal and open a new shell again. Install all required dependencies with:: pacman -S gcc make cmake pkg-config git glib2-devel gettext-devel Clone libuca and any plugins you want to use on Windows:: git clone https://github.com/ufo-kit/libuca and create an empty ``build`` directory in libuca's root folder. Change directory to that folder, configure libuca using CMake and build and install it:: cd libuca mkdir build && cd build cmake -DCMAKE_INSTALL_PREFIX=/usr .. make && make install Before proceeding with the plugins you *must* soft link the library to fit the naming scheme:: ln -s /usr/bin/libuca.so /usr/lib/libuca.dll.a To build plugins nothing special is required. Clone the repository, create an empty build directory, configure and build:: git clone https://github.com/ufo-kit/uca-net cd uca-net mkdir build && cd build cmake .. make && make install Usage ----- .. highlight:: c The API for accessing cameras is straightforward. First you need to include the necessary header files:: #include #include Then you need to setup the type system:: int main (int argc, char *argv[]) { UcaPluginManager *manager; UcaCamera *camera; GError *error = NULL; /* this _must_ be set to NULL */ #if !(GLIB_CHECK_VERSION (2, 36, 0)) g_type_init(); #endif Now you can instantiate new camera *objects*. Each camera is identified by a human-readable string, in this case we want to access any pco camera that is supported by `libpco `__. To instantiate a camera we have to create a plugin manager first:: manager = uca_plugin_manager_new (); camera = uca_plugin_manager_get_camera (manager, "pco", &error, NULL); Errors are indicated with a returned value ``NULL`` and ``error`` set to a value other than ``NULL``:: if (camera == NULL) { g_error ("Initialization: %s", error->message); return 1; } You should always remove the `reference `__ from the camera object when not using it in order to free all associated resources:: g_object_unref (camera); return 0; } Compile this program with :: cc `pkg-config --cflags --libs libuca glib-2.0` foo.c -o foo Now, run ``foo`` and verify that no errors occur. Grabbing frames ~~~~~~~~~~~~~~~ To synchronously grab frames, first start the camera:: uca_camera_start_recording (camera, &error); g_assert_no_error (error); Now, you have to allocate a suitably sized buffer and pass it to ``uca_camera_grab``:: gpointer buffer = g_malloc0 (640 * 480 * 2); uca_camera_grab (camera, buffer, &error); You have to make sure that the buffer is large enough by querying the size of the region of interest and the number of bits that are transferred. Getting and setting camera parameters ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Because camera parameters vary tremendously between different vendors and products, they are realized with so-called GObject *properties*, a mechanism that maps string keys to typed and access restricted values. To get a value, you use the ``g_object_get`` function and provide memory where the result is stored:: guint roi_width; gdouble exposure_time; g_object_get (G_OBJECT(camera), "roi-width", &roi_width, "exposure-time", &exposure_time, /* The NULL marks the end! */ NULL ); g_print ("Width of the region of interest: %d\n", roi_width); g_print ("Exposure time: %3.5fs\n", exposure_time); In a similar way, properties are set with ``g_object_set``:: guint roi_width = 512; gdouble exposure_time = 0.001; g_object_set (G_OBJECT (camera), "roi-width", roi_width, "exposure-time", exposure_time, NULL); Each property can be associated with a physical unit. To query for the unit call ``uca_camera_get_unit`` and pass a property name. The function will then return a value from the ``UcaUnit`` enum.