Block *¶

Product of two signals.

Block +¶

Sum of two signals.

Block -¶

Implements the difference of two signals, taking care of overflows.

Because that is rarely the semantics you want to give them.

Block /¶

Ratio of two signals.

Block constant¶

Output a numerical constant that never changes.

Example:

|constant value=42| -> ...

Block gain¶

A simple example of a gain block.

Block identity¶

This block outputs the inputs, unchanged.

Block info¶

Prints more compact information about the inputs than Block print.

For numpy arrays it prints their shape and dtype instead of their values.

Block print¶

Print a representation of the input values along with their timestamp.

Block gradient¶

Computes the gradient of an image using a Sobel filter.

Block smooth¶

Smooths an image with a Gaussian filter.

Block block_example¶

This is a documented example of the simplest block possible.

This docstring will be included in the generated documentation.

Block hdfread¶

This block reads a log written with Block hdfwrite.

Block hdfread_many¶

This block is a variation on Block hdfread that can concatenate the output of logs stored in multiple HDF files.

The files are specified using a wildcard: for example, dir/*.h5.

A difference with Block hdfread is that all signals must be specified explicitly (Block hdfread can guess); the reason is that we want to avoid reading unrelated logs with different signals.

We check that all files specified have all required signals.

The logfiles are read in the order compatible with their timestamp.

Block hdfread_many_test¶

This is a simple test for Block hdfread_many.

Block hdfread_test¶

This is a simple test that reading from HDF files is happening correctly.

Block hdfwrite¶

This block writes the incoming signals to a file in HDF format.

The HDF format is organized as follows:

/            (root)
/procgraph             (group with name procgraph)
/procgraph/signal1     (table)
/procgraph/signal2     (table)
...

Each table has the following fields:

time (float64 timestamp) value (the datatype of the signal)

If a signal changes datatype, then an error is thrown.

Block blend¶

Blend two or more images.

RGB images are interpreted as having full alpha (opaque). All images must have the same width and height.

Block border¶

Adds a block around the input image.

Block compose¶

Compose several images in the same canvas. You should probably use Block grid in many situations.

Example configuration:

compose.positions = {y: [0,0], ys: [320,20]}

Block crop¶

Crops an image by the given values

Block files_from_dir¶

This block reads the filenames from a directory according to a given regexp.

For now the timestamp starts from 0 and it is fixed.

Block gray2rgb¶

Converts a H x W grayscale into a H x W x 3 RGB image by replicating the gray channel over R,G,B.

Block grid¶

A block that creates a larger image by arranging them in a grid.

Block posneg¶

Converts a 2D float value to a RGB representation, where red is positive, blue is negative, white is zero.

Block posterize¶

Posterizes the given image with the specified number of levels.

Block reshape2d¶

Reshapes x into (?, width) if x is 1D. If width is not given, it is set to be the sqrt(size).

If x is 2D, it is left alone.

Block rgb2gray¶

Converts a HxWx3 RGB image into a HxW grayscale image by computing the luminance.

Block scale¶

Provides a RGB representation of the values by interpolating the range [min(value),max(value)] into the colorspace [min_color, max_color].

Block skim_top¶

Cuts off the top percentile of the array.

Block skim_top_and_bottom¶

Cuts off the top and bottom percentile of the array.

Block solid¶

to write

Block as_json¶

Converts the input into a JSON string.

TODO: add example

Block pickle¶

Dumps the input as a pickle file.

Block pickle_group¶

Dumps the input as a pickle file, in the form of a dictionary signal name -> value.

Block pickle_load¶

Dumps the input as a pickle file.

Block to_file¶

Prints the input line by line to a given file.

Block plot¶

Plots the inputs using matplotlib.

This block accepts an arbitrary number of signals. Each signals is treated independently and plot separately.

Each signal can either be:

1. A tuple of length 2. It is interpreted as a tuple (x,y), and we plot x versus y (see also Block make_tuple).
2. A list of numbers, or a 1-dimensional numpy array of length N. In this case, it is interpreted as the y values, and we set x = 1:N.

Block mencoder¶

Encodes a video stream using mencoder.

Note that allowed codec and bitrate depend on your version of mencoder.

MP4 output: currently it works by creating a .AVI with mencoder and then converting to MP4 using ffmpeg (MP4 support for mencoder is currently — Feb‘12 — broken).

RGBA videos: not working fully. For now it outputs .AVI with mencoder and encoded using png.

Block mplayer¶

Decodes a video stream.

Block abs¶

Wrapper around numpy.absolute.

Block arctan¶

Wrapper around numpy.arctan.

Block array¶

Converts the value to a Numpy array.

Block astype¶

Converts an array using the astype function.

Block deg2rad¶

Converts degrees to radians (wrapper around numpy.radians.)

Block dstack¶

Wrapper around numpy.ma.dstack.

Block fliplr¶

Flips the array left/right (wrapper for numpy.fliplr().)

Block flipud¶

Flips the array up/down (wrapper for numpy.flipud().)

Block gradient1d¶

Computes the gradient of a 1D array.

Block hstack¶

Wrapper around numpy.ma.hstack.

Block log¶

Wrapper around numpy.log.

Block max¶

Maximum over all elements.

Block maximum¶

Limits the numpy array to the given threshold.

Block mean¶

Wrapper around numpy.mean.

Block minimum¶

Limits the numpy array to the given threshold.

Block norm¶

Returns the norm of the vector.

Block normalize_Linf¶

Normalize a vector such that |x|_inf = max(abs(x))= 1.

Block outer¶

Outer product of two vectors.

This is a wrapper around numpy.multiply.outer().

Block rad2deg¶

Converts radians to degrees (wrapper around numpy.degrees.)

Block real¶

Wrapper around numpy.real.

Block select¶

Selects some of the elements of x.

Block sign¶

Wrapper around numpy.sign.

Block smooth1d¶

Smooth the data using a window with requested size.

This method is based on the convolution of a scaled window with the signal. The signal is prepared by introducing reflected copies of the signal (with the window size) in both ends so that transient parts are minimized in the begining and end part of the output signal.

window must be one of ‘flat’, ‘hanning’, ‘hamming’, ‘bartlett’, ‘blackman’. A flat window will produce a moving average smoothing.

example:

t=linspace(-2,2,0.1)
x=sin(t)+randn(len(t))*0.1
y=smooth(x)

see also:

numpy.hanning, numpy.hamming, numpy.bartlett, numpy.blackman, numpy.convolve scipy.signal.lfilter

TODO: the window parameter could be the window itself if an

array instead of a string

Block square¶

Wrapper around numpy.square.

Block sum¶

Sum over all elements.

Block take¶

to write

Block vstack¶

Wrapper around numpy.ma.vstack.

Block imread¶

Reads an image from a file.

Block imwrite¶

Writes an image to a file.

Block resize¶

Resizes an image.

You should pass at least one of width or height.

Block text¶

This block provides text overlays over an image.

This block is very powerful, but the configuration is a bit complicated.

You should provide a list of dictionary in the configuration variable texts. Each dictionary in the list describes how and where to write one piece of text.

An example of valid configuration is the following:

text.texts = [{string: "raw image", position: [10,30], halign: left,
              color: black, bg: white }]

The meaning of the fields is as follow:

string

Text to display. See the section below about keyword expansion.

position

Array of two integers giving the position of the text in the image

color

Text color. It can be a keyword color or an hexadecimal string (white or #ffffff).

bg

background color

halign

Horizontal alignment. Choose between left (default), center, right.

valign

Vertical alignment. Choose between top (default), middle, center.

size

Font size in pixels

font

Font family. Must be a ttf file (Arial.ttf)

Expansion: Also we expand macros in the text using format(). The available keywords are:

frame

number of frames since the beginning

time

seconds since the beginning of the log

timestamp

absolute timestamp

Block laser_display¶

Produces a plot of a range-finder scan.

Example of configuration:

display_sick.groups = [{ indices: [0,179], theta: [-1.57,+1.57],
     color: 'r', origin: [0,0,0]}]

Block laser_dot_display¶

Produces a plot of a range-finder scan variation (derivative).

It is a variation of Block laser_display; look there for the documentation.

Block organic_scale¶

A (almost failed!) attempt to scale a signal into [-1,1] according to the history.

This one is a mess.

Block pose2commands¶

Computes the velocity commands from the odometry data.

Block pose2vel_¶

Block used by Block pose2commands.

Block skim¶

Cuts off the top and bottom percentile of the array.

Block bagread¶

This block reads a bag file (ROS logging format).

Block bagread_test¶

Test of the bagread block.

Block bagwrite¶

This block writes the incoming signals to a ROS bag file.

By default, the signals are organized as follows:

/            (root)
/procgraph             (group with name procgraph)
/procgraph/signal1     (table)
/procgraph/signal2     (table)
...

Note that the input should be ROS messages; no conversion is done.

Block ros2python¶

Converts a ROS message to a Python object.

Block ros_scan2python¶

to write

Block any¶

Joins the stream of multiple signals onto one output signal.

Block async¶

to write

Block derivative¶

Computes the derivative of a quantity with 3 taps (x[t+1] - x[t-1]). See also Block derivative2.

Block derivative2¶

Computes the derivative of a quantity with 2 taps (x[t+1] - x[t]). See also Block derivative.

Block extract¶

This block extracts some of the components of a vector.

Example: Extracts the first and third component of x.

x -> |extract index=[0,2]| -> x_part

Block forward_difference¶

Computes x[t+1] - x[t-1] normalized with timestamp.

You want to attach this to Block last_n_samples.

Block fps_data_limit¶

This block limits the output update to a certain framerate.

Block fps_limit¶

This block limits the output update to a certain realtime framerate.

Note that this uses realtime wall clock time – not the data time! This is mean for real-time applications, such as visualization.

Block fps_print¶

Prints the fps count for the input signals.

Block history¶

This block collects the history of a quantity, and outputs two signals x and t. See also Block historyt and Block last_n_samples.

Block historyt¶

This block collects the signals samples of a signals, and outputs one signal containing a tuple (t,x). See also Block last_n_samples and Block history.

If natural is true, it uses the time from the beginning of the log.

Block join¶

This block joins multiple signals into one.

Block last_n_samples¶

This block collects the last N samples of a signals, and outputs two signals x and t. See also Block historyt and Block history.

Block low_pass¶

Implements simple low-pass filtering.

Formula used:

y[k] = alpha * u[k] + (1-alpha) * y[k-1]

Block make_tuple¶

Creates a tuple out of the input signals values.

Often used for plotting two signals as (x,y); see Block plot.

Block sieve¶

This block decimates the data in time by transmitting only one in n updates.

Block slice¶

Slices a signal by extracting from index start to index end (INCLUSIVE).

Block sync¶

This block synchronizes a set of streams to the first stream (the master).

The first signal is called the “master” signal. The other (N-1) are slaves.

We guarantee that:

• if the slaves are faster than the master, then we output exactly the same.

Example diagrams:

Master  *  *  *   *   *
Slave   ++++++++++++++++

Master  *  *  *   *   *
output? v  v  x   v
Slave   +    +      +
output? v    v      v

Block two_step_difference¶

Computes x[t+1] - x[t] normalized with timestamp.

Block wait¶

This block waits a given number of updates before transmitting the output signal.

Block cov2corr¶

Compute the correlation matrix from the covariance matrix. If zero_diagonal = True, the diagonal is set to 0 instead of 1.

Block covariance¶

Computes the covariance matrix of the input.

Block expectation¶

Computes the sample expectation of a signal.

Block maximum_over_time¶

Computes the minimum of a signal over time.

Block minimum_over_time¶

Computes the minimum of a signal over time.

Block normalize¶

Removes the mean from a signal.

Block soft_variance¶

Computes the element-wise “soft” variance (exp. of error abs. value)

Block variance¶

Computes the element-wise variance.

Block yaml2object¶

to write