FlowDesigner_User's_Guide

Back to Documentation Main Page

• Introduction
• The Idea Behind FlowDesigner
• Available Nodes
• Terminology
  • Nodes
  • Built-in nodes
  • Node terminals (inputs/outputs)
  • Node parameters
  • Links
  • Data Types
• Getting Started with FlowDesigner
• Tutorials

Introduction

http://flowdesigner.sourceforge.net/FlowDesigner is a free (GPL/LGPL) ``data-flow oriented_ development environment. It can be used to build complex applications by combining small, reusable building blocks. In some way, it has similarities with Simulink and LabView, although it is not designed (and far) to be a "clone" of any of them._

FlowDesigner features a GUI that allows rapid application development and includes a visual debugger. Although FlowDesigner can be seen as a rapid prototyping tool, it can also be used for building real-time applications, such as audio effects processing. Since FlowDesigner is not really an ``interpreted language_, it can be quite fast._

It is written in C++ and features a plug-in mechanism that allows new nodes/toolboxes to be easily added. FlowDesigner currently includes the following toolboxes:

   * Signal processing
   * Speech processing (GMMs)
   * Vector quantization (VQ)
   * Neural network (MLP)
   * Fuzzy logic
   * Real-time audio effect processing (early stage)
   * Linear algebra using LAPACK/BLAS/ATLAS (early stage)
   * Image processing (early stage)

The Idea Behind FlowDesigner

FlowDesigner was designed with the following goals in mind:

• Ease of use
• Speed
• Flexibility
• Extendibility
• Modularity

One thing to note with respect to speed is that we tried the same approach as for the C++ language which can be summarized by "you don't pay for the features you don't use".

Available Nodes

• Available nodes can be found here : http://flowdesigner.sourceforge.net/doc/nodes.html

Terminology

This section defines the concepts and terms used by FlowDesigner and shows how they relate to C or Matlab constructs.

Nodes

The basic processing using in FlowDesigner is a Node, a Node is in all ways similar to a C or Matlab function. It takes some input data, performs some operations and send data out.

Built-in nodes

A built-in FlowDesigner node is written in C++ and is part of the FlowDesigner code (or compiled in an FlowDesigner toolbox, like Matlab's .mex files). In FlowDesigner, all nodes are implemented as a class that derive (directly or indirectly) from a base class called "Node" (note that most nodes derive from "BufferedNode"). Although the FlowDesigner implementation of different nodes uses C++ inheritance mechanism (using classes), there's no reason for the user to be aware of that. For that reason, it's not recommended to refer to nodes as "types" or ``classes_ (e.g. if FlowDesigner were written in C, nodes would be implemented as functions)._

Sub-networks (composite nodes)

A FlowDesigner sub-network (or subnet) is a collection of connected nodes that can be used as if they were a single node. Most FlowDesigner subnets will be saved into .n files, which are almost the exact equivalent of Matlab's .m files. There's no real C equivalent because C is a compiled language (although it could be seen as a C function calling other C function).

Node terminals (inputs/outputs)

The inputs of a FlowDesigner nodes are equivalent to the arguments to a Matlab/C function. The same for outputs, but while C is restricted to one return value, FlowDesigner and Matlab can have several outputs. Node inputs and outputs are sometimes referred to as ``terminals_._

Node parameters

FlowDesigner node parameters are also equivalent to C/Matlab function arguments. The difference between node parameters and node inputs is that parameters cannot change at run-time. They are specified at "build-time" and stay constant throughout the run. For instance, the "Constant" node has no input, but has a parameter called "VALUE" that is returned as the output of the node. Using constants, you can always "transform" another node's input into a parameter (to the constant). The reverse is not true, however. Why then have parameters and not define every argument as an input? Mostly simplicity and run-time performance. Sometimes, it is just a lot easier to know certain arguments in advance and be sure that they don't change during the run. However, when possible, it is better to implement arguments as inputs, as this allows more flexibility.

Links

There's no real correspondence between FlowDesigner links and C or Matlab constructs. The best analogy would be to say that Links represent the order of the lines in a C/Matlab function. You also need to keep in mind that FlowDesigner uses a "pull method" in order to compute data. What does that mean? When you run a network, the last node (output node) of the main network (called "MAIN" - how original!) is asked for its output. In order to compute its output, it needs to ask its input nodes for their output. That way everything propagates from the end to the beginning recursively.

Now, why going backwards like that? That's a bit long to explain. The quick answer is "because". The longer answer involves faster handling of dependencies, faster processing, buffer management and things like that.

Data Types

Unlike Matlab, that only supports the complex-double-matrix type (well, that's not totally true, but...), FlowDesigner (like C and C++) has support for many different types. The ``basic_ FlowDesigner types are: Bool, Int, Float, Stream, String and Vector. There are also toolbox-specific types, like FFNet (neural network), VQ (Vector Quantizer), GMM (Gaussian Mixture Model), ..._

Right now, the only way to define a new type in FlowDesigner is by adding C++ code for it in a toolbox (or the core). Eventually, there will (could?) be a way to pack data in a "struct" using FlowDesigner nodes, but this is not implemented yet.

Some FlowDesigner Nodes expect a certain type of data as input/parameter and will generate a run-time exception (which will abort execution) if the wrong data type is used (e.g.. a Load node expects a Stream as input and nothing else). Some nodes, like the NOP (no-op) node, can take any type as input. Some node have more complex behavior, like the Add node that can add two floats, two Vectors of the same dimension, but cannot add a Bool and a Vector.

Getting Started with FlowDesigner

Please follow the [Getting_Started_with_FlowDesigner] link for information on how to use FlowDesigner.

Tutorials

• [Hello_world_tutorial] : Simple "Hello world!" program.
• [Hello_world_loop_tutorial] : Example on how to do a loop (same as the "while(Condition)" in programming).
• [Probing_tutorial] : How to use the probing ability of FlowDesigner.
• [Remote_probing_tutorial] : How to probe a process running on another machine.
• [Using_Composite_Types_Tutorial_] : Learn how to use Composite Types data structures.