Sketch<bool>		Binary pixels.
Sketch<uchar>		Unsigned char. Useful for storing color-segmented images, since the color index easily fits within one byte.
Sketch<uint>		Unsigned int. Used to represent array indices for subscripting sketches (except on the AIBO, where short ints are used). Also used to represent areas and Euclidean distances.
Sketch<usint>		Unsigned short (2-byte) int. Used to represent array indices on the AIBO, for subscripting sketches. (This assumes there are fewer than 65,536 pixels. A full-resolution ERS-7 camera image has 208*160 = 33280 pixels.)
Sketch<float>		Floating point values; for experimentation.

The easiest way to get started with sketches is to grab a segmented camera frame from the vision stream and turn it into a Sketch<uchar>. The sketchFromSeg() function does this for you. The NEW_SKETCH macro is used to declare new variables that point to sketches. We'll call our first sketch "camFrame".

NEW_SKETCH(camFrame, uchar, sketchFromSeg());

NEW_SKETCH(orange_stuff, bool, visops::colormask(camFrame,"orange"));

NEW_SKETCH(neighbors, uchar, visops::neighborSum(orange_stuff, visops::EightWayConnect));

NEW_SKETCH(edges, bool, orange_stuff & neighbors < 8);

Another way to look at images is to extract just the intensity information, which is the Y-channel in the AIBO's native YUV encoding. The function sketchFromRawY() returns a Sketch<uchar> where the values from 0 to 255 are intensity values (brightness).

NEW_SKETCH(camY, uchar, sketchFromRawY());

#include "Behaviors/StateMachine.h"
using namespace DualCoding;

$nodeclass DstBehavior : VisualRoutinesStateNode : doStart {
  NEW_SKETCH(camFrame, uchar, sketchFromSeg());
  NEW_SKETCH(orange_stuff, bool, visops::colormask(camFrame,"orange"));
  NEW_SKETCH(neighbors, uchar, visops::neighborSum(orange_stuff, visops::EightWayConnect));
  NEW_SKETCH(edges, bool, orange_stuff & neighbors < 8);
  NEW_SKETCH(camY, uchar, sketchFromRawY());
}

This behavior does not produce any printed output. But we can use the SketchGUI tool to examine the results of the computation.

From this example you can discern the basic structure of a "sketch space":

• Every sketch has a unique id number. camFrame has id 4, and edges has id 33.

• Sketches are organized hierarchically, forming a derivation tree. orange_stuff was derived from camFrame , and neighbors was derived from orange_stuff.

• Although edges was derived from both orange_stuff and neighbors, its parent is orange_stuff. The rule is that inheritance is always from the sketch that is the left argument of a binary operator.

• Color can either be assigned to a sketch by the function that creates it or inherited from the sketch's parent. orange_stuff acquired its color from the colormask function, and edges inherited its color from orange_stuff. For arithmetic and logical operators such as < and &, color is inherited from the sketch that is the left argument. You can change the color of a sketch with the setColor function.

• Sketches can have different color maps. The default is segMap, which uses whatever colors are defined for the color-segmented image stream. But camY uses grayMap, and neighbors uses jetMapScaled. You can change the colormap of a Sketch with the setColorMap function.

• Not all sketches are visible. Sketches the system creates internally to store intermediate results of a computation are generally not made visible. You might want to hide some of your own sketches as well, to keep the SketchGUI display from becoming cluttered. If a sketch's parent is not visible, the SketchGUI will try to attach the sketch to its parent's parent, and so on, until a visible ancestor is found.

1. Try switching the order of the arguments to the & operator in the definition of edges. What effects do you observe in the listing displayed by the SketchGUI?

2. Write a program to find all the pixels that have both a blue neighbor and a green neighbor.

Constructors

NEW_SKETCH is the easiest way to construct a sketch. NEW_SKETCH_N can be used when you don't want the sketch to be visible. But it is sometimes convenient to call one of the Sketch constructor functions directly. There are two constructor functions plus one copy constructor. The first Sketch constructor requires a SketchSpace and a sketch name as inputs. We will use camSkS, the camera sketch space:

Sketch<bool> foo(camSkS, "foo");   // first Sketch constructor
foo = false;                       // clear all the pixels
for ( int i=50; i<90; i++ )
  foo(i,i) = true;                 // draw a diagonal line
foo->V();                          // make foo visible to the SketchGUI

If you run the above example and look at the result with the SketchGUI, you will see that the sketch named "foo" has no parent; it is a root node in the set of derivation trees. Also, since we did not specify a color for the sketch, it was assigned the default color 1, meaning the first color in the color list given in the .col file the robot is using.

The expression foo = false makes use of the overloaded assignment operator; it clears all the pixels in sketch foo. This is necessary because the sketch constructor simply allocates space for the sketch; it does not bother initializing the pixels, since this may be unnecessary.

The second Sketch constructor is used when we want to create a child of an existing sketch. The first argument is the new sketch name, and the second argument is the parent sketch. (We don't have to specify the sketch space because the parent's space must be used.)

Sketch<uchar> bar("bar", foo);     // second Sketch constructor
bar = (Sketch<uchar>)foo + 2;      // element-wise addition 
bar->V();

While foo is a Sketch<bool>, bar is a Sketch<uchar>, so the "color" it inherits from foo is ignored (but preserved), and its pixel values are treated as indices into the default color map. Whereas foo's values were 0's and 1's, bar's values will be 2's and 3's.

NEW_SKETCH doesn't use either of the above constructor functions. It uses the copy constructor to create a new smart pointer to reference an existing sketch that has already been created by some expression. So when we write this:

NEW_SKETCH(orange_stuff, bool, visops::colormask(camFrame,"orange"));

Sketch<bool> orange_stuff(visops::colormask(camFrame,"orange"));    // copy constructor
orange_stuff->V("orange_stuff");                                    // rename and make visible