RLEGenerator Class Reference#include <RLEGenerator.h>
Inheritance diagram for RLEGenerator:
[legend]List of all members.
Detailed Description
Generates RLE compressed FilterBankEvents (generally from indexed color images from, say, SegmentedColorGenerator).
Uses the CMVision library for main processing.
getImage() will return the first run, from the upper left hand corner. The type is RLEGenerator::run.
The RLE produced isn't quite optimal in terms of size. To make it easier to directly process the RLE for recognition tasks, each run will be broken at the end of the row. So a solid image will still contain height runs instead of just one.
Also, the run structures contain extra fields to be used for region connecting. These fields aren't sent over wireless, and are filled in by the RegionGenerator. I don't necessarily like the tight coupling between the RLE and Region Generators that this requires, but it saves a copy of the data and allows us to use CMVision instead of rewriting.
Note that since the amount of data for each row is variable (depends on the complexity of that row) the row stride and skip are useless. You'll have to process the RLE yourself to find a given index.
If the incoming events is a SegmentedColorFilterBankEvents, then it will post a SegmentedColorFilterBank to retain additional color information. If the event is of a different format, it will post a regular FilterBankEvent.
Note that although you could hook this class up to a raw intensity image, it is primarily of use with segmented color images because it doesn't handle gradients or noise well at all - this type of encoding/compression assumes cartoonish images of large blocks of flat color. However, if you have some kind of other preprocessing that also provides suitable data, this can encode it for you.
The format used for serialization is: (code is in SaveBuffer())
- <
FilterBankGenerator : superclass header> (First saves the superclass's info) - <
string : "RLEImage"> (remember a 'string' is len+str+0; so this is the literal "\010\0\0\0RLEImage\0"; also remember "\010" is octal for 8) - <
unsigned int : num_runs> (how many runs will follow) - for each of num_runs:
- <
char : color> (index value of color of run) - <
short : x> (x position of start of run ("unknown" runs are skipped - assume index 0 for pixels which are jumped)) - <
short : width> (length of run, will not exceed remaining width of image)
Note that the RLEGenerator doesn't save the color infomation regarding what each index value "means". This is just a compression stage, pure and simple. You'll need to look at the RLEGenerator's source (probably SegmentedColorGenerator, but doesn't have to be) to determine how to interpret the indicies.
- See also:
- SegCamBehavior for information on transmission over wireless.
FilterBankGenerator more information on serialization
Definition at line 64 of file RLEGenerator.h.
|
Public Types |
typedef uchar | cmap_t |
| the type to use for a color index
|
typedef CMVision::run< cmap_t > | run |
| use the CMVision library's run structure
|
Public Member Functions |
| RLEGenerator (EventBase::EventGeneratorID_t gid, unsigned int sid, unsigned int mysid) |
| constructor
|
virtual | ~RLEGenerator () |
| destructor
|
virtual void | processEvent (const EventBase &event) |
| should receive FilterBankEvents from any standard format FilterBankGenerator (like RawCameraGenerator)
|
virtual unsigned int | getBinSize () const |
| calculates space needed to save - if you can't precisely add up the size, overestimate and things will still work.
|
virtual unsigned int | LoadBuffer (const char buf[], unsigned int len) |
virtual unsigned int | SaveBuffer (char buf[], unsigned int len) const |
| Save to a given buffer.
|
virtual unsigned int | getNumRuns (unsigned int layer, unsigned int chan) const |
| returns the number of runs for the image
|
virtual const run * | getRuns (unsigned int layer, unsigned int chan) const |
| returns the actual runs of the specified image
|
virtual const run & | getRun (unsigned int layer, unsigned int chan, unsigned int i) const |
| returns a specific run of the specified image
|
Static Public Member Functions |
std::string | getClassDescription () |
| Gives a short description of what this class of behaviors does... you should override this (but don't have to).
|
Protected Member Functions |
virtual void | setDimensions () |
| sets the width, height, skip and stride, as well as maxRuns
|
virtual void | setNumImages (unsigned int nLayers, unsigned int nChannels) |
| resizes the filter bank information storage area, you should override this to do your setup and call it from your constructor
|
virtual unsigned char * | createImageCache (unsigned int layer, unsigned int chan) const |
| simply creates a new data region and returns it
|
virtual void | calcImage (unsigned int layer, unsigned int chan) const |
| a single call to the CMVision library to do the work, and we're done.
|
virtual void | destruct () |
| deletes the arrays
|
unsigned int | calcExpMaxRuns (unsigned int layer) const |
| uses a heuristic to predict the maximum number of runs expected per layer
|
Protected Attributes |
unsigned int ** | numRuns |
| a matrix of ints, holds the number of used runs for each image
|
unsigned int * | maxRuns |
| the maximum number of runs possible for each layer
|
Static Protected Attributes |
const unsigned int | MIN_EXP_RUN_LENGTH = 8 |
| The expected minimum average length of each run.
|
const unsigned int | XMIT_BYTES_PER_RUN = sizeof(cmap_t)+sizeof(short)+sizeof(short) |
| number of bytes needed to send each run
|
Private Member Functions |
| RLEGenerator (const RLEGenerator &fbk) |
| don't call
|
const RLEGenerator & | operator= (const RLEGenerator &fbk) |
| don't call
|
Member Typedef Documentation
Constructor & Destructor Documentation
RLEGenerator::RLEGenerator |
( |
const RLEGenerator & |
fbk |
) |
[private] |
|
Member Function Documentation
unsigned int RLEGenerator::calcExpMaxRuns |
( |
unsigned int |
layer |
) |
const [inline, protected] |
|
void RLEGenerator::calcImage |
( |
unsigned int |
layer, |
|
|
unsigned int |
chan |
|
) |
const [protected, virtual] |
|
unsigned char * RLEGenerator::createImageCache |
( |
unsigned int |
layer, |
|
|
unsigned int |
chan |
|
) |
const [protected, virtual] |
|
void RLEGenerator::destruct |
( |
|
) |
[protected, virtual] |
|
unsigned int RLEGenerator::getBinSize |
( |
|
) |
const [virtual] |
|
|
calculates space needed to save - if you can't precisely add up the size, overestimate and things will still work.
- Returns:
- number of bytes read/written, 0 if error (or empty)
Reimplemented from FilterBankGenerator.
Definition at line 23 of file RLEGenerator.cc. |
std::string RLEGenerator::getClassDescription |
( |
|
) |
[inline, static] |
|
|
Gives a short description of what this class of behaviors does... you should override this (but don't have to).
Reimplemented from BehaviorBase.
Definition at line 78 of file RLEGenerator.h. |
virtual unsigned int RLEGenerator::getNumRuns |
( |
unsigned int |
layer, |
|
|
unsigned int |
chan |
|
) |
const [inline, virtual] |
|
virtual const run& RLEGenerator::getRun |
( |
unsigned int |
layer, |
|
|
unsigned int |
chan, |
|
|
unsigned int |
i |
|
) |
const [inline, virtual] |
|
|
returns a specific run of the specified image
Definition at line 92 of file RLEGenerator.h. |
virtual const run* RLEGenerator::getRuns |
( |
unsigned int |
layer, |
|
|
unsigned int |
chan |
|
) |
const [inline, virtual] |
|
|
returns the actual runs of the specified image
Definition at line 90 of file RLEGenerator.h. |
unsigned int RLEGenerator::LoadBuffer |
( |
const char |
buf[], |
|
|
unsigned int |
len |
|
) |
[virtual] |
|
|
this isn't really tested, don't rely on it working without a little debugging... specifically, doesn't set parent or next fields
Reimplemented from FilterBankGenerator.
Definition at line 36 of file RLEGenerator.cc. |
void RLEGenerator::processEvent |
( |
const EventBase & |
event |
) |
[virtual] |
|
unsigned int RLEGenerator::SaveBuffer |
( |
char |
buf[], |
|
|
unsigned int |
len |
|
) |
const [virtual] |
|
|
Save to a given buffer.
- Parameters:
-
buf | pointer to the memory where you should begin writing |
len | length of buf available. (this isn't all yours, constrain yourself to what you returned in getBinSize() ) |
- Returns:
- the number of bytes actually used
Reimplemented from FilterBankGenerator.
Definition at line 75 of file RLEGenerator.cc.
Referenced by SegCamBehavior::writeRLE(). |
void RLEGenerator::setDimensions |
( |
|
) |
[protected, virtual] |
|
void RLEGenerator::setNumImages |
( |
unsigned int |
nLayers, |
|
|
unsigned int |
nChannels |
|
) |
[protected, virtual] |
|
|
resizes the filter bank information storage area, you should override this to do your setup and call it from your constructor
In general, it isn't expected that FilterBankGenerator's should necessarily be dynamically resizeable (although it would be nice), which is why this isn't public. If yours is, just add some pubic accessor functions which call this. In general, the included subclasses should be able to handle being resized, but there's no reason to do so since the system won't be changing its available resolutions at run time.
The default implementation is a no-op if(numLayers==nLayers && numChannels==nChannels)
Reimplemented from FilterBankGenerator.
Definition at line 107 of file RLEGenerator.cc. |
Member Data Documentation
The documentation for this class was generated from the following files:
|