/cygdrive/d/src/svn/vrut/trunk/modules/tracking/backup/pparser.cpp

Go to the documentation of this file.

#include "pparser.h"
using namespace VRUT;

const char PacketParser::separators[] =
{
       '[', 
       ']', 
       ' '  
};
const char * PacketParser::tags[] =
{
       "fr",   
       "ts",   
       "6d",   
       "6df",  
       "6df2", 
       "6dmt", 
       "gl",   
       "3d",   
       "6dcal",
       "" // empty cell - see TextParser::KeywordsSwitch()
};
PacketParser::PacketParser(const char * input)
{
       bQueue = NULL;
       frameCounter = 0;
       timeStamp = -1.0;
       textparser = NULL;
}
PacketParser::~PacketParser()
{
       if (textparser != NULL)
       {
              delete textparser;
       }
}
void PacketParser::SetPacket(char *packet)
{
       if (textparser != NULL) delete textparser;
       textparser = new TextParser(packet);
}
float PacketParser::TimeStamp()
{
       return timeStamp;
}
int PacketParser::FrameCounter()
{
       return frameCounter;
}
int PacketParser::CalibratedDevices()
{
       return calibDevs;
}
int PacketParser::ParsedDevices()
{
       return devicesCount;
}
bool PacketParser::Parse()
{
       if (NULL == bQueue)
       {
              LOGERROR(wxT("<Tracking> No Queue is set, where to save devices. Parsing unsuccesful!"));
              return false;
       }
       calibDevs = 0;
       devicesCount = 0;
       while(!textparser->IsEmpty())
       {
              switch (textparser->KeywordsSwitch(tags, separators))
              {
              case 0: // fr
                     {
                            int fCounter;
                            if (!textparser->ParseInt(&fCounter, separators))
                            {
                                   LOGERROR(wxT("<Tracking>Unexpected chunks while parsing fr"));
                                   //frameCounter = 0;
                                   return false;
                            }
                            if (fCounter <= frameCounter) LOGWARNING(wxT("<Tracking>Packet order varied"));
                            frameCounter = fCounter;
                            break;
                     }
              case 1: // ts
                     {
                            if(!textparser->ParseFloat(&timeStamp,separators))
                            {
                                   LOGERROR(wxT("<Tracking>Unexpected chunks while parsing ts"));
                                   //timeStamp = 0;
                                   return false;
                            }
                            break;
                     }
              case 2: // 6d
                     {
                            if (!parse6D())
                            {
                                   LOGERROR(wxT("<tracking>Unexpected chunks while parsing 6d"));
                                   return false;
                            }
                            break;
                     }
              case 3: // 6df
                     {
                            if (!parse6DF())
                            {
                                   LOGERROR(wxT("<tracking>Unexpected chunks while parsing 6df"));
                                   return false;
                            }
                            break;
                     }
              case 4: // 6df2
                     {
                            if (!parse6DF2())
                            {
                                   LOGERROR(wxT("<tracking>Unexpected chunks while parsing 6df2"));
                                   return false;
                            }
                            break;
                     }
              case 5: // 6dmt
                     {
                            if (!parse6DMT())
                            {
                                   LOGERROR(wxT("<tracking>Unexpected chunks while parsing 6dmt"));
                                   return false;
                            }
                            break;
                     }
              case 6: // gl
                     {
                            if (!parseGL())
                            {
                                   LOGERROR(wxT("<tracking>Unexpected chunks while parsing gl"));
                                   return false;
                            }
                            break;
                     }
              case 7: // 3d
                     {
                            if (!parse3D())
                            {
                                   LOGERROR(wxT("<tracking>Unexpected chunks while parsing 3d"));
                                   return false;
                            }
                            break;
                     }
              case 8: // 6dcal
                     {
                            if(!textparser->ParseInt(&calibDevs,separators))
                            {
                                   LOGERROR(wxT("<Tracking>Unexpected chunks while parsing 6dcal"));
                                   return false;
                            }
                            break;
                     }
              default: // bad hit
                     {
                            wxString aaa = wxT("<Tracking> Unexpected token while parsing tag: ") + textparser->GetWxLine();
                            LOGERROR(aaa);
                            // resit co kdyz bylo nacteno nejake zarizeni, ale pak nastala chyba...
                            // >>> otazka, jestli transformovat behem parsovani, nebo ukladat do fronty a pak postupne obsluhovat frontu
                            return false;
                            break;
                     }
              }
       }
       return true; // ujisti se, jestli byl fr parsovany
}

bool PacketParser::parseInt(int *target)
{
       if (!textparser->ParseInt(target, separators)) return false;
       textparser->SkipCharsAndComments(separators);
       return true;
}
bool PacketParser::parseFloat(float *target)
{
       if (!textparser->ParseFloat(target, separators)) return false;
       textparser->SkipCharsAndComments(separators);
       return true;
}
size_t PacketParser::parseVector(float *target, size_t dimension)
{
       size_t read = textparser->ParseVector(target, dimension, true, separators);
       textparser->SkipCharsAndComments(separators);
       return read;
}
bool PacketParser::parse3D()
{
       int devs; // number of devices of type 3D
       if(!parseInt(&devs)) return false;
       devicesCount += devs;
       for (int i = 0 ; i < devs; i++)
       {
              int id;
              float qu;
              float s[3];
              if (!parseInt(&id))        return false;
              if (!parseFloat(&qu))      return false;
              if (3 != parseVector(s,3)) return false;
              Body * b3d = new Body(id,qu,Body::B3D,s);
              bQueue->push(b3d);
       }
       return true;
}
bool PacketParser::parse6D()
{
       int devs; // number of devices of type 3D
       if(!parseInt(&devs)) return false;
       devicesCount += devs;
       for (int i = 0 ; i < devs; i++)
       {
              int id;
              float qu;
              float s[6];
              float b[9];
              if (!parseInt(&id))        return false;
              if (!parseFloat(&qu))      return false;
              if (6 != parseVector(s,6)) return false;
              if (9 != parseVector(b,9)) return false;
              Body * b6d = new Body(id,qu,Body::B6D,s,b);
              bQueue->push(b6d);
       }
       return true;
}
bool PacketParser::parse6DF()
{
       int devs; // number of devices of type 3D
       if(!parseInt(&devs)) return false;
       devicesCount += devs;
       for (int i = 0 ; i < devs; i++)
       {
              int id;
              float qu;
              int bt;
              float s[6];
              float b[9]; // pouzt datovou strukturu
              if (!parseInt(&id))        return false;
              if (!parseFloat(&qu))      return false;
              if (!parseInt(&bt))        return false;
              if (6 != parseVector(s,6)) return false;
              if (9 != parseVector(b,9)) return false;
              FlyStick1 * fs1;
              if (qu != -1) fs1 = new FlyStick1(id, qu, bt, s, b);
              else fs1 = new FlyStick1(id,qu, bt);
              bQueue->push(fs1);
       }
       return true;
}
bool PacketParser::parse6DF2()
{
       int dev_s; // number of devices of type Flystick2 registered
       int devs; // number of followed on the line
       if(!parseInt(&dev_s)) return false;
       if(!parseInt(&devs))  return false;
       devicesCount += devs;
       for (int i = 0 ; i < devs; i++)
       {
              int id;
              float qu;
              int nbt;
              int nct;
              float s[3];
              float b[9]; // pouzit datovou strukturu
              if (!parseInt(&id))        return false;
              if (!parseFloat(&qu))      return false;
              if (!parseInt(&nbt))       return false;
              if (!parseInt(&nct))       return false;
              if (3 != parseVector(s,3)) return false;
              if (9 != parseVector(b,9)) return false;
              FlyStick2 * fs2 = NULL;
              if (qu != -1) fs2 = new FlyStick2(id, qu, nbt, nct, s, b);
              else FlyStick2(id, qu, nbt, nct);
              int intNum = nbt /32;
              if ((nbt%32) != 0) intNum += 1;
              int butt;
              float control;
              for (int j = 0; j < intNum; j++)
              {
                     if (!parseInt(&butt))
                     {
                            delete fs2;
                            return false;
                     }
                     else
                     {
                            fs2->addButtons(j, butt);
                     }
              }
              for (int j = 0; j < nct; j++)
              {
                     if(!parseFloat(&control))
                     {
                            delete fs2;
                            return false;
                     }
                     else
                     {
                            fs2->addControls(j,control);
                     }
              }
              bQueue->push(fs2);
       }
       return true;
}
bool PacketParser::parse6DMT()
{
       int devs; // number of devices of type 3D
       if(!parseInt(&devs)) return false;
       devicesCount += devs;
       for (int i = 0 ; i < devs; i++)
       {
              int id;
              float qu;
              int bt;
              float s[3];
              float b[9];
              if (!parseInt(&id))        return false;
              if (!parseFloat(&qu))      return false;
              if (!parseInt(&bt))        return false;
              if (3 != parseVector(s,3)) return false;
              if (9 != parseVector(b,9)) return false;
              Measurer * dmt;
              if (qu != -1)dmt = new Measurer(id, qu, bt, s, b);
              else dmt = new Measurer(id, qu, bt);
              bQueue->push(dmt);
       }
       return true;
}
bool PacketParser::parseGL()
{
       int devs; // number of devices of type 3D
       if(!textparser->ParseInt(&devs, separators)) return false;
       devicesCount += devs;
       for (int i = 0 ; i < devs; i++)
       {
              int id;
              float qu;
              int hand; // left or right
              int nf;   // number of fingers
              float s[3]; // misto techto 3 pouzit uz datove struktury
              float b[9];
              if (!parseInt(&id))        return false;
              if (!parseFloat(&qu))      return false;
              if (!parseInt(&hand))      return false;
              if (!parseInt(&nf))        return false;
              if (3 != parseVector(s,3)) return false;
              if (9 != parseVector(b,9)) return false;
              bool leftH;
              if (nf == 0) leftH = true; else leftH = false;
              BodyGlove * gl = new BodyGlove(id,qu, nf,leftH,s,b);
              Finger fgrs;
              for (int j = 0 ; j < nf; j++)
              {
                     if(!parseFinger(&fgrs))
                     {
                            delete gl;
                            return false;
                     }
                     else gl->addFinger(j, fgrs);
              }
              bQueue->push(gl);
       }
       return true;
}
bool PacketParser::parseFinger(Finger *finger)
{
       if (3 != parseVector(finger->Position, 3)) return false;
       if (9 != parseVector(finger->Matrix, 9))   return false;
       if (!parseFloat(&finger->Radius))          return false;
       if (!parseFloat(&(finger->Length[0])))     return false;
       if (!parseFloat(&(finger->Angle[0])))      return false;
       if (!parseFloat(&(finger->Length[1])))     return false;
       if (!parseFloat(&(finger->Angle[1])))      return false;
       if (!parseFloat(&(finger->Length[2])))     return false;
       return true;
}

void PacketParser::SetQueue(VRUT::bodyqueue *queue)
{
       this->bQueue = queue;
}

---