GestureSensors.h

Go to the documentation of this file.

//
//  GestureSensors.h -- interface code for using CSL with gesture sensors that send out OSC
//  See the copyright notice and acknowledgment of authors in the file COPYRIGHT
//      Controller interfaces by Satoshi Morita, Bo Bell, Lance Putnam, and Stephen Pope
//

#ifndef INCLUDE_GestureSensors_H
#define INCLUDE_GestureSensors_H

#include "CSL_Includes.h"
#include "OSC_cpp.h"

// Prototype for the OSC "glue" code

extern "C" void add_OSC_Method2(char * name, OSC_CALL_BACK function, void * user_data );

namespace csl {

// Abstract class for all gesture sensors -- this does most of the work

class GestureSensor {

public: 
    void * mData;                   // my data array (typically a float *)
    char * mCmd;                    // my OSC command name (without the '/')
    char * mTypeString;             // my OSC type string, e.g., "ffff"
//  OSC_CALL_BACK * mReaderFcn;     // my OSC call-back function (NB: not a class method)
    
                                    // Constructors
    GestureSensor(char * name, OSC_CALL_BACK * callback);
    GestureSensor(char * name, char * types, OSC_CALL_BACK * callback);
    virtual ~GestureSensor();
    
                                    // get my data
    virtual void * get_data() { return mData; };
    
                                    // parse an OSC packet into my data array according to my type string
    virtual status parse_OSC_packet(char * typeString, void * args);
};


// Concrete class for the 5DT Data Glove 5
//
// packet looks like "/Glove, fffffff, thumb, index, middle, ring, little, roll, pitch 
//  mData is a float arrary  -- 0: thumb, 1: index, 2: middle, 3: ring, 4: little, 5: roll, 6: pitch

// OSC callback function -- not part of the class

extern "C" void glove_input(void *inst, int arglen, const void *args, OSCTimeTag when, NetworkReturnAddressPtr ra);

class Glove : public GestureSensor {

public:                 // Constructor
    Glove(char * name) : GestureSensor(name, "fffffff", & glove_input) { };
    ~Glove() { };

};

// Concrete class for the EBeam whiteboard
//
// Ebeam data packet format: address ,ffff x y status color
//      address - "/EB",        pen message
//                "/EBStart",   eBeam app started
//                "/EBStop",    eBeam app stopped
//      x       - 0 = left, ~3670 = right
//      y       - 0 = top, ~1700 = bottom
//      status  - 0 = pen up, 1 = pen down
//      color   - 0 = black, 1 = red, 2 = green, 3 = blue, 4 = eraser

// OSC callback function -- not part of the class

extern "C" void ebeam_input(void *inst, int arglen, const void *args, OSCTimeTag when, NetworkReturnAddressPtr ra);

class EBeam : public GestureSensor {

public:                 // Constructor
    EBeam(char * name) : GestureSensor(name, "ffff", & ebeam_input) { };
    ~EBeam() { };
                        // data accessors
    float get_x() { return ((float * ) mData)[0]; }
    float get_y() { return ((float * ) mData)[1]; }

};

// Concrete class for the flock of birds magnetic trackers
//
// packet is "/Flock, ffffff, x, y, z, azimuth, elevation, roll

// OSC callback function -- not part of the class

extern "C" void bird_input(void *inst, int arglen, const void *args, OSCTimeTag when, NetworkReturnAddressPtr ra);

class Bird : public GestureSensor {

public:
    float mFlockDataOld[6];     // Flock of Birds past data 

                        // Constructor
    Bird(char * name) : GestureSensor(name, "ffffff", & bird_input) { };
    ~Bird() { };
                        // get my data
    float get_x() { return ((float * ) mData)[0]; }
    float get_y() { return ((float * ) mData)[1]; }
    float get_z() { return ((float * ) mData)[2]; }
    float get_az() { return ((float * ) mData)[3]; }
    float get_el() { return ((float * ) mData)[4]; }
    float get_roll() { return ((float * ) mData)[5]; }
    
    float get_delta_x() { return ((float * ) mData)[0] - mFlockDataOld[0]; }
    float get_delta_y() { return ((float * ) mData)[1] - mFlockDataOld[1]; }
    float get_delta_z() { return ((float * ) mData)[2] - mFlockDataOld[2]; }
    float get_delta_az() { return ((float * ) mData)[3] - mFlockDataOld[3]; }
    float get_delta_el() { return ((float * ) mData)[4] - mFlockDataOld[4]; }
    float get_delta_roll() { return ((float * ) mData)[5] - mFlockDataOld[5]; }
    
    void dump();
};

// Concrete class for DanO's Matrix controller
// Since the packet has a variable-length format, we can't use all of the inherited code

// OSC callback function -- not part of the class

extern "C" void matrix_input(void *inst, int arglen, const void *args, OSCTimeTag when, NetworkReturnAddressPtr ra);

class Matrix : public GestureSensor {

public:                 // Matrix data structure (fixed 12 * 12)
    float theMatrix[12][12];        // 12 * 12 floats
    float redMatrix[4][4];          // reduced to 4 * 4 averages
    
                        // Constructor
    Matrix(char * name);            // use the basic constructor
    ~Matrix() {};
                        // get my data
    void * get_data() { return ((void *) theMatrix); }
    
    float get_avg(int top, int left, int height, int width);
    void compute_reduction();
    void dump_matrix();
    void dump_reduced_matrix();
};

// Concrete class for the Essential Reality P5 Data Glove
//
// packet looks like "/p5glove_data, iiiiiiiiiii, ButtA, ButtB, ButtC, thumb, index, middle, ring, little, x, y, z 
//  mData is a float arrary  -- 0: thumb, 1: index, 2: middle, 3: ring, 4: little, 5: x, 6: y, 7: z, ABC

// OSC callback function -- not part of the class

extern "C" void p5_input(void *inst, int arglen, const void *args, OSCTimeTag when, NetworkReturnAddressPtr ra);

class P5Glove : public GestureSensor {

public:                 // Constructor
    P5Glove(char * name) : GestureSensor(name, "iiiiiiiiiii", & p5_input) { };
    ~P5Glove() { };

};


}

#endif

---