// Methods
// NOTE: ANN is special since it supports both regression and classification, we therefore override these methods
void ann::train()
{
const data_type data_type = get_data_type();
GRT::UINT numSamples = data_type == LABELLED_CLASSIFICATION ? classification_data.getNumSamples() : regression_data.getNumSamples();
if (numSamples == 0)
{
flext::error("no observations added, use 'add' to add training data");
return;
}
bool success = false;
if (data_type == LABELLED_CLASSIFICATION)
{
grt_ann.init(
classification_data.getNumDimensions(),
num_hidden_neurons,
classification_data.getNumClasses(),
input_activation_function,
hidden_activation_function,
output_activation_function
);
success = grt_ann.train(classification_data);
}
else if (data_type == LABELLED_REGRESSION)
{
grt_ann.init(
regression_data.getNumInputDimensions(),
num_hidden_neurons,
regression_data.getNumTargetDimensions(),
input_activation_function,
hidden_activation_function,
output_activation_function
);
success = grt_ann.train(regression_data);
}
if (!success)
{
flext::error("training failed");
}
t_atom a_success;
SetInt(a_success, success);
ToOutAnything(1, get_s_train(), 1, &a_success);
}
void ann::error()
{
if (!grt_ann.getTrained())
{
flext::error("model not yet trained, send the \"train\" message to train");
return;
}
float error_f = grt_ann.getTrainingError();
t_atom error_a;
SetFloat(error_a, error_f);
ToOutAnything(0, get_s_error(), 1, &error_a);
}
void regression::train()
{
GRT::UINT numSamples = regression_data.getNumSamples();
GRT::Regressifier ®ressifier = get_Regressifier_instance();
if (numSamples == 0)
{
error("no observations added, use 'add' to add training data");
return;
}
bool success = false;
success = regressifier.train(regression_data);
if (!success)
{
error("training failed");
}
t_atom a_success;
SetInt(a_success, success);
ToOutAnything(1, s_train, 1, &a_success);
}
void ann::map(int argc, const t_atom *argv)
{
const data_type data_type = get_data_type();
GRT::UINT numSamples = data_type == LABELLED_CLASSIFICATION ? classification_data.getNumSamples() : regression_data.getNumSamples();
if (numSamples == 0)
{
flext::error("no observations added, use 'add' to add training data");
return;
}
if (grt_ann.getTrained() == false)
{
flext::error("model has not been trained, use 'train' to train the model");
return;
}
GRT::UINT numInputNeurons = grt_ann.getNumInputNeurons();
GRT::VectorDouble query(numInputNeurons);
if (argc < 0 || (unsigned)argc != numInputNeurons)
{
flext::error("invalid input length, expected %d, got %d", numInputNeurons, argc);
}
for (uint32_t index = 0; index < (uint32_t)argc; ++index)
{
double value = GetAFloat(argv[index]);
query[index] = value;
}
bool success = grt_ann.predict(query);
if (success == false)
{
flext::error("unable to map input");
return;
}
if (grt_ann.getClassificationModeActive())
{
const GRT::VectorDouble likelihoods = grt_ann.getClassLikelihoods();
const GRT::Vector<GRT::UINT> labels = classification_data.getClassLabels();
const GRT::UINT predicted = grt_ann.getPredictedClassLabel();
const GRT::UINT classification = predicted == 0 ? 0 : get_class_id_for_index(predicted);
if (likelihoods.size() != labels.size())
{
flext::error("labels / likelihoods size mismatch");
}
else if (probs)
{
AtomList probs_list;
for (unsigned count = 0; count < labels.size(); ++count)
{
t_atom label_a;
t_atom likelihood_a;
SetFloat(likelihood_a, static_cast<float>(likelihoods[count]));
SetInt(label_a, get_class_id_for_index(labels[count]));
probs_list.Append(label_a);
probs_list.Append(likelihood_a);
}
ToOutAnything(1, get_s_probs(), probs_list);
}
ToOutInt(0, classification);
}
else if (grt_ann.getRegressionModeActive())
{
GRT::VectorDouble regression_data = grt_ann.getRegressionData();
GRT::VectorDouble::size_type numOutputDimensions = regression_data.size();
if (numOutputDimensions != grt_ann.getNumOutputNeurons())
{
flext::error("invalid output dimensions: %d", numOutputDimensions);
return;
}
AtomList result;
for (uint32_t index = 0; index < numOutputDimensions; ++index)
{
t_atom value_a;
double value = regression_data[index];
SetFloat(value_a, value);
result.Append(value_a);
}
ToOutList(0, result);
}
}
void m_bang()
{
Frame frame;
t_atom generalInfo[6];
int num_hands, num_tools, num_gestures;
frame = dispatcher.frame;
num_hands = frame.hands().count();
num_tools = frame.tools().count();
num_gestures = frame.gestures().count();
if(general_flag){
SETFLOAT(&generalInfo[0], (float)frame.id());
SETFLOAT(&generalInfo[1], (float)frame.timestamp());
SETFLOAT(&generalInfo[2], (float)num_hands);
SETFLOAT(&generalInfo[3], (float)frame.fingers().count());
SETFLOAT(&generalInfo[4], (float)frame.tools().count());
SETFLOAT(&generalInfo[5], (float)frame.gestures().count());
ToOutList(0, 6, generalInfo);
}
// tools
for(int i = 0; i<num_tools; i++){
Tool tool;
tool = frame.tools()[i];
t_atom toolInfo[5];
if(tools_position_flag) {
SETFLOAT(&toolInfo[0], i);
SETSYMBOL(&toolInfo[1], gensym("direction"));
SETFLOAT(&toolInfo[2], tool.direction().x);
SETFLOAT(&toolInfo[3], tool.direction().y);
SETFLOAT(&toolInfo[4], tool.direction().z);
ToOutAnything(1, gensym("tool"), 5, toolInfo);
}
if(tools_position_flag) {
SETFLOAT(&toolInfo[0], i);
SETSYMBOL(&toolInfo[1], gensym("position"));
SETFLOAT(&toolInfo[2], tool.tipPosition().x);
SETFLOAT(&toolInfo[3], tool.tipPosition().y);
SETFLOAT(&toolInfo[4], tool.tipPosition().z);
ToOutAnything(1, gensym("tool"), 5, toolInfo);
}
if(tools_velocity_flag){
SETFLOAT(&toolInfo[0], i);
SETSYMBOL(&toolInfo[1], gensym("velocity"));
SETFLOAT(&toolInfo[2], tool.tipVelocity().x);
SETFLOAT(&toolInfo[3], tool.tipVelocity().y);
SETFLOAT(&toolInfo[4], tool.tipVelocity().z);
ToOutAnything(1, gensym("tool"), 5, toolInfo);
}
if(tools_size_flag){
SETFLOAT(&toolInfo[0], i);
SETSYMBOL(&toolInfo[1], gensym("size"));
SETFLOAT(&toolInfo[2], tool.width());
SETFLOAT(&toolInfo[3], tool.length());
ToOutAnything(1, gensym("tool"), 4, toolInfo);
}
}
// hands and fingers
for(int i = 0; i<num_hands; i++){
Hand hand;
hand = frame.hands()[i];
int num_fingers = hand.fingers().count();
int num_tools = hand.tools().count();
t_atom handInfo[5];
if(hands_direction_flag){
// direction
SETFLOAT(&handInfo[0], i);
SETSYMBOL(&handInfo[1], gensym("direction"));
SETFLOAT(&handInfo[2], hand.direction().x);
SETFLOAT(&handInfo[3], hand.direction().y);
SETFLOAT(&handInfo[4], hand.direction().z);
ToOutAnything(1, gensym("hand"), 5, handInfo);
}
if(hands_palm_position_flag){
// position
SETFLOAT(&handInfo[0], i);
SETSYMBOL(&handInfo[1], gensym("palm_position"));
SETFLOAT(&handInfo[2], hand.palmPosition().x);
SETFLOAT(&handInfo[3], hand.palmPosition().y);
SETFLOAT(&handInfo[4], hand.palmPosition().z);
ToOutAnything(1, gensym("hand"), 5, handInfo);
}
if(hands_palm_velocity_flag){
// velocity
SETFLOAT(&handInfo[0], i);
SETSYMBOL(&handInfo[1], gensym("palm_velocity"));
SETFLOAT(&handInfo[2], hand.palmVelocity().x);
SETFLOAT(&handInfo[3], hand.palmVelocity().y);
SETFLOAT(&handInfo[4], hand.palmVelocity().z);
ToOutAnything(1, gensym("hand"), 5, handInfo);
}
if(hands_palm_normal_flag){
// normal
SETFLOAT(&handInfo[0], i);
SETSYMBOL(&handInfo[1], gensym("palm_normal"));
SETFLOAT(&handInfo[2], hand.palmNormal().x);
SETFLOAT(&handInfo[3], hand.palmNormal().y);
SETFLOAT(&handInfo[4], hand.palmNormal().z);
ToOutAnything(1, gensym("hand"), 5, handInfo);
}
if(hands_sphere_radius_flag){
// sphere radius
SETFLOAT(&handInfo[0], i);
SETSYMBOL(&handInfo[1], gensym("sphere_radius"));
SETFLOAT(&handInfo[2], hand.sphereRadius());
ToOutAnything(1, gensym("hand"), 3, handInfo);
}
if(hands_sphere_center_flag){
// sphere center
SETFLOAT(&handInfo[0], i);
SETSYMBOL(&handInfo[1], gensym("sphere_center"));
SETFLOAT(&handInfo[2], hand.sphereCenter().x);
SETFLOAT(&handInfo[3], hand.sphereCenter().y);
SETFLOAT(&handInfo[4], hand.sphereCenter().z);
ToOutAnything(1, gensym("hand"), 5, handInfo);
}
if(hands_finger_count_flag){
// finger count
SETFLOAT(&handInfo[0], i);
SETSYMBOL(&handInfo[1], gensym("finger_count"));
SETFLOAT(&handInfo[2], num_fingers);
ToOutAnything(1, gensym("hand"), 3, handInfo);
}
if(hands_tool_count_flag){
// tool count
SETFLOAT(&handInfo[0], i);
SETSYMBOL(&handInfo[1], gensym("tool_count"));
SETFLOAT(&handInfo[2], num_tools);
ToOutAnything(1, gensym("hand"), 3, handInfo);
}
for(int j = 0; j<num_fingers; j++){
Finger finger;
finger = hand.fingers()[j];
t_atom fingerInfo[7];
if(fingers_direction_flag){
SETFLOAT(&fingerInfo[0], i); // index
SETSYMBOL(&fingerInfo[1], gensym("fingers"));
SETFLOAT(&fingerInfo[2], j);
SETSYMBOL(&fingerInfo[3], gensym("direction"));
SETFLOAT(&fingerInfo[4], finger.direction().x);
SETFLOAT(&fingerInfo[5], finger.direction().y);
SETFLOAT(&fingerInfo[6], finger.direction().z);
ToOutAnything(1, gensym("hand"), 7, fingerInfo);
}
if(fingers_position_flag){
SETFLOAT(&fingerInfo[0], i); // index
SETSYMBOL(&fingerInfo[1], gensym("fingers"));
SETFLOAT(&fingerInfo[2], j);
SETSYMBOL(&fingerInfo[3], gensym("position"));
SETFLOAT(&fingerInfo[4], finger.tipPosition().x);
SETFLOAT(&fingerInfo[5], finger.tipPosition().y);
SETFLOAT(&fingerInfo[6], finger.tipPosition().z);
ToOutAnything(1, gensym("hand"), 7, fingerInfo);
}
if(fingers_velocity_flag){
SETFLOAT(&fingerInfo[0], i); // index
SETSYMBOL(&fingerInfo[1], gensym("fingers"));
SETFLOAT(&fingerInfo[2], j);
SETSYMBOL(&fingerInfo[3], gensym("velocity"));
SETFLOAT(&fingerInfo[4], finger.tipVelocity().x);
SETFLOAT(&fingerInfo[5], finger.tipVelocity().y);
SETFLOAT(&fingerInfo[6], finger.tipVelocity().z);
ToOutAnything(1, gensym("hand"), 7, fingerInfo);
}
if(fingers_size_flag){
SETFLOAT(&fingerInfo[0], i); // index
SETSYMBOL(&fingerInfo[1], gensym("fingers"));
SETFLOAT(&fingerInfo[2], j);
SETSYMBOL(&fingerInfo[3], gensym("size"));
SETFLOAT(&fingerInfo[4], finger.width());
SETFLOAT(&fingerInfo[5], finger.length());
ToOutAnything(1, gensym("hand"), 6, fingerInfo);
}
}
}
t_atom gestureCountInfo[1];
for(int i = 0;i < num_gestures; i++){
Gesture gesture;
gesture = frame.gestures()[i];
//type
t_atom gestureTypeInfo[3];
SETFLOAT(&gestureTypeInfo[0], i);
SETSYMBOL(&gestureTypeInfo[1], gensym("type"));
switch(gesture.type())
{
case Gesture::TYPE_INVALID:
SETSYMBOL(&gestureTypeInfo[2], gensym("TYPE_INVALID"));
break;
case Gesture::TYPE_SWIPE:
SETSYMBOL(&gestureTypeInfo[2], gensym("TYPE_SWIPE"));
break;
case Gesture::TYPE_CIRCLE:
SETSYMBOL(&gestureTypeInfo[2], gensym("TYPE_CIRCLE"));
break;
case Gesture::TYPE_SCREEN_TAP:
SETSYMBOL(&gestureTypeInfo[2], gensym("TYPE_SCREEN_TAP"));
break;
case Gesture::TYPE_KEY_TAP:
SETSYMBOL(&gestureTypeInfo[2], gensym("TYPE_KEY_TAP"));
break;
}
ToOutList(2, 3, gestureTypeInfo);
//state
t_atom gestureStateInfo[3];
SETFLOAT(&gestureStateInfo[0], i);
SETSYMBOL(&gestureStateInfo[1], gensym("state"));
switch(gesture.state())
{
case Gesture::STATE_INVALID:
SETSYMBOL(&gestureStateInfo[2], gensym("STATE_INVALID"));
break;
case Gesture::STATE_START:
SETSYMBOL(&gestureStateInfo[2], gensym("TYPE_START"));
break;
case Gesture::STATE_UPDATE:
SETSYMBOL(&gestureStateInfo[2], gensym("STATE_UPDATE"));
break;
case Gesture::STATE_STOP:
SETSYMBOL(&gestureStateInfo[2], gensym("TYPE_STOP"));
break;
}
ToOutList(2, 3, gestureStateInfo);
t_atom gestureDurationInfo[3];
SETFLOAT(&gestureDurationInfo[0], i);
SETSYMBOL(&gestureDurationInfo[1], gensym("duration"));
SETFLOAT(&gestureDurationInfo[2], gesture.duration());
ToOutList(2, 3, gestureDurationInfo);
t_atom gestureIdInfo[3];
SETFLOAT(&gestureIdInfo[0], i);
SETSYMBOL(&gestureIdInfo[1], gensym("id"));
SETFLOAT(&gestureIdInfo[2], gesture.id());
ToOutList(2, 3, gestureIdInfo);
}
}
