2. Summary
  3. Files
  4. Support
  5. Report Spam
  6. Create account
  7. Log in

Welcome to Charon-Suite

What is it and why is it useful? With years of experience in computer vision, we learned (the hard way) that image processing libraries are very difficult to maintain and extend when working in a research environment. Typically, the learning curve for such libraries is quite steep and their life-cycle shorter than 10 years. Therefore, we decided to create a framework and associated tools rather than a library.

  • charon is an open source framework for computer vision prototyping.
  • The idea is not to rely on any given image processing library such as OpenCV, Vigra, CImg or even Matlab and Python.
  • Instead we just define interfaces with a dead-simple plugin-architecture we call Charon-core which has been stable since its first implementation in 2009.
  • Each part of a computer vision algorithm is called a module and you can visually connect algorithms in a tool named Tuchulcha. Think LabVIEW, but more generic and sexier.
  • Modules can be implemented in any language and may use any software packages.
  • Modules can be visually plugged together, and then be executed via C++ code or a command line tool.
  • The software is very easy to learn (there is a software assistant called TemplateGenerator which creates the code-template for such modules based on your interface definition).
  • You can choose your favourite programming environment thanks to CMake.
  • It is cross-platform and fully open source under the LGPL. Do what you like with it.
  • The number of existing algorithms and helper code such as file reading and writing, parameter files, etc. is steadily increasing.
  • From a supervisor's perspective it is also very useful as you can experiment with the methods your students implemented.
  • Visualization of results can either be done with special modules or via python or Matlab without writing data converters.
  • Modules can be easily added or removed from a project without recompilation.
  • Developing or changing modules is fast, only the module module itself needs to be (re)compiled. The rest of the project can stay untouched. This can be called the c++ equivalent of rapid prototyping.
  • The environment allows for white box testing to see which module influences the overall outcome to which extent.

An image of a typical workflow for optical flow estimation in order to help you getting an idea of what we do with the software is located here: Tuchulcha.

Here you can find some Screenshots and example workflows.

News

Getting Started

Getting started takes little time, even for beginners! In case you would like to experiment with existing modules:

  • Download the Windows binaries or install the Debian package (InstallationGuide).
  • You will find files ending on .wrp in the data (which are plain-text parameter files, specifiying how modules are plugged together to form an algorithm).
  • Start tuchulcha(.exe on Windows) and load a .wrp file to look at the algorithm details.
  • Klick on individual modules to see the parameters and browse the inline documentation for each module to understand the parameters.
  • Klick on the play button to run the algorithm.
  • Optionally change filenames of the examaple file parameters in the FileReader modules to see what the algorithm does with your data!

In case you want to implement a new model, you need can do this in a maximum of four hours. (Prerequisites are knowledge in C++ and your favourite programming environment). Once you did this the first time, each new module definition and creation takes around 5-10 minutes!

  • First, experiment with existing modules (see above) to get a feeling what charon is about.
  • In case you do not know much about standard tools such as CMake, read the Developer Beginner's Guide.
  • In case you would like to build the project on your own, read the QuickBuildGuide and the Build-FAQ (no need for this, really!).
  • If you want to (or need to, if you are our student ;D) contribute your new modules later on, read the CodingConventions first!
  • Think of a simple plugin. We suggest to write a Thresholder, which takes an input image and sets all image intensities above a threshold (specified as parameter of the module) to one. The output image should be made available as so-called output-slot.
  • Use the TemplateGenerator tool (you will find it in the binaries) to visually create your very first own module!
  • The tool creates three files and a CMake project. Use CMake to create a project in your favourite programming environment. (We recommend Visual Studio Express under Windows and Eclipse under Linux. Both are free and great tools!)
  • The .cpp file created by the TemplateGenerator contains only management code (for shared libraries). Ignore it! The .h file contains a list of input and output slots you defined in TemplateGenerator.
  • Open the generated .hxx-File and look out for a method called execute(). Add your thresholding code here. There is one important note which you will appreciate if your code does not compile or work correctly: InputSlot<T>, OutputSlot<T>, Parameter<T> and ParameterList<T> are templated objects to formalize the module architecture. If you want to access the actual content of a slot or a parameter, you need to use the round bracket operator "()". 
    // Example declaration:
InputSlot<cimg_library::CImg<T> > mySlot;

[...]

// Example usage:
mySlot().get_threshold(15);

Please drop us an email and tell us about your first experiences (daniel *d# kondermann *a# iwr.uni *minus# heidelberg.de)!

More detailed information can be found here:

Module and Application References

The manpages of the applications shipped with charon-suite may be read online: Charon-Suite Manpages.

A synopsis of the existing charon modules with their input/output slots and parameters is available online:

Charon-utils
Modules Grouped
Charon
Modules Grouped

Parts of Charon-Suite

Charon-core (doc)
Basic framework for module management
Charon-utils (doc)
Basic Image manipulation and processing modules such as file reading, writing and display
Charon (doc)
Optical flow estimation modules
Argos
Advanced image viewer
Tuchulcha (doc)
Graphical configuration/workflow editor for algorithm prototyping
TemplateGenerator
Sotware assistant to set up module code templates
Hekate
Feature Detection, 3D Reconstruction and Stereo modules

License

The project is released under the conditions of the LGPL.

© 2012 Geeknet, Inc.   Terms of Use - Privacy Policy