This page uses cookies. For details and possible settings refer to our Privacy Policy.
Continuing to use this page means accepting the processing of cookie files.

Accept (hide info)
POL ENG GER 中文(繁體) 中文(简体)

Machine Vision Library for C++ and .NET


Adaptive Vision Library is a machine vision library for C++ and .NET programmers. It provides a comprehensive set of functions for creating industrial image analysis applications – from standard-based image acquisition interfaces, through low-level image processing routines, to ready-made tools such as template matching, measurements or barcode readers. The main strengths of the product include the highest performance, modern design and simple structure making it easy to integrate with the rest of your code.

The functions available in Adaptive Vision Library closely correspond to the filters of Adaptive Vision Studio. Therefore, it is possible to prototype your algorithms quickly in a graphical environment and then translate them to C++ or .NET, or even generate the C++ code automatically.

Adaptive Vision Library gives you instant access to highest quality, well optimized and field-tested code that you need for your machine vision projects!




In Adaptive Vision Library careful design of algorithms goes hand in hand with extensive hardware optimizations, resulting in performance that puts the library among the fastest in the world. Our implementations make use of SSE/AVX instructions and parallel computations on multicore processors.

Modern Design

All types of data feature automatic memory management, errors are handled explicitly with exceptions and optional types are used for type-safe special values. All functions are thread-safe and use data parallelism internally, when possible.

Simplicity & Consistency

The library is a simple collection of types and functions, provided as a single DLL file with appropriate headers. For maximum readability functions follow consistent naming convention (e.g. the VERB + NOUN form as in: SmoothImage, RotateVector). All results are returned via reference output parameters, so that many outputs are always possible.

Example Code

Below is an elementary, yet complete, example of acquiring images from a GigE Vision camera, thresholding them and saving to files on disk, all done with Adaptive Vision Library (C++):

#include <iostream>
#include "Genicam.h"
#include "AVL.h"

using namespace atl;
using namespace avl;

int main( void )
      // Find devices
      Array< GigEVision_DeviceDescriptor > deviceList;
      GigEVision_FindDevices(800, 1, deviceList);
      if (deviceList.Empty())
         return -1;

      // Connect to the first found
      String addr = deviceList[0].IpAddress;
      GigEHandle hDev = GigEVision_OpenDevice(addr);
      GigEVision_StartAcquisition(hDev, "Mono8");

      // Main loop
      Image image1, image2;
      for (int i = 0; i < 100; ++i)
         // Grab image
         GigEVision_ReceiveImage(hDev, image1);

         // Process image
         ThresholdImage(image1, NIL, 128.0f, NIL, 0.0f, image2);

         // Save to file
         char fileName[16];
         sprintf(fileName, "%05d.png", i);
         SaveImage(image2, ImageFileFormat::PNG, fileName, false);
      // Finalize acquisition
      return 0;
   catch( atl::Error& error )
      std::cout << error.Kind() << ": " << error.Message() << std::endl;
      return -2;


Adaptive Vision Library C++ can be used with Microsoft Visual Studio C++ (2010-2019) and GCC compilers. It runs on industrial PCs as well as on embedded devices such as:

  • Raspberry Pi 3 - Raspbian
  • Wandboard Quad - Ubuntu
  • NXT Vegas
  • Tegra TX2 - Jetpack
  • UltraZed-EG - Petalinux

Further Reading

For more code samples go to Code Samples.

For technical documentation refer to AVL Documentation and Function Reference.