Source/Contrib/ComplexSceneManager/Helper/OSGGestureData.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *           Copyright (C) 2008 by the OpenSG Forum                          *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 #include "OSGGestureData.h"
  40 #include "OSGGestureDataFields.h"
  41 #include "OSGFieldContainer.h"
  42
  43 #include "OSGSField.ins"
  44
  45 OSG_BEGIN_NAMESPACE
  46
  47 GestureData::GestureBlob::GestureBlob(      UInt32       uiEvent,
  48                                             Int32        iGestureId,
  49                                       const std::string &szGesture,
  50                                             Real32       rX,
  51                                             Real32       rY,
  52                                             UInt32       uiCoordSys) :
  53
  54     _uiEvent   (uiEvent    ),
  55     _iGestureId(iGestureId ),
  56     _vPosition (rX, rY, 0.f),
  57
  58     _uiCoordSys(uiCoordSys ),
  59
  60     _szGesture (szGesture  )
  61 {
  62 }
  63
  64 //GestureData::GestureBlob::~GestureBlob(void)
  65 //{
  66 //}
  67
  68 bool GestureData::GestureBlob::operator ==(const GestureBlob &rhs) const
  69 {
  70     // gesture id and uievent uniquely identifies the gesture
  71     return (_uiEvent == rhs._uiEvent && _iGestureId == rhs._iGestureId );
  72 }
  73
  74 bool GestureData::GestureBlob::operator !=(const GestureBlob &rhs) const
  75 {
  76     return !(*this == rhs);
  77 }
  78
  79 bool GestureData::GestureBlob::operator < (const GestureBlob &rhs) const
  80 {
  81     return ((_iGestureId <  rhs._iGestureId) ||
  82             (_iGestureId == rhs._iGestureId && _uiEvent < rhs._uiEvent));
  83 }
  84
  85
  86
  87 GestureData::GestureData(void) :
  88     _vBlobs      (     ),
  89     _vActiveBlobs(     ),
  90     _pWindow     (NULL ),
  91     _pCSMWindow  (NULL )
  92 {
  93 }
  94
  95
  96 GestureData::GestureData(const GestureData &source) :
  97     _vBlobs      (source._vBlobs      ),
  98     _vActiveBlobs(source._vActiveBlobs),
  99     _pWindow     (NULL                ),
 100     _pCSMWindow  (NULL                )
 101 {
 102 }
 103
 104 GestureData::~GestureData(void)
 105 {
 106 }
 107
 108 /*------------------------------ access -----------------------------------*/
 109
 110 const GestureData &GestureData::operator = (const GestureData &rhs)
 111 {
 112     _vBlobs     = rhs._vBlobs;
 113
 114     _pWindow    = rhs._pWindow;
 115     _pCSMWindow = rhs._pCSMWindow;
 116
 117     return *this;
 118 }
 119
 120 bool GestureData::operator ==(const GestureData &rhs) const
 121 {
 122     //return (_vBlobs == rhs._vBlobs    &&
 123     //        _pWindow   == rhs._pWindow  );
 124     //        _pCSMWindow   == rhs._pCSMWindow  );
 125
 126     return (_vBlobs == rhs._vBlobs);
 127 }
 128
 129 void GestureData::addGesture(      UInt32       uiId,
 130                              const std::string &szGesture,
 131                                    Real32       rX,
 132                                    Real32       rY,
 133                                    UInt32       uiCoordSys)
 134 {
 135     GestureBlob tmpBlob(GestureData::AddGesture,
 136                         uiId,
 137                         szGesture,
 138                         rX,
 139                         rY,
 140                         uiCoordSys             );
 141
 142     GestureBlobStoreIt tbIt = std::lower_bound(_vBlobs.begin(),
 143                                                _vBlobs.end  (),
 144                                                 tmpBlob       );
 145     if(tbIt == _vBlobs.end())
 146     {
 147         _vBlobs.push_back(tmpBlob);
 148     }
 149     else if(tmpBlob != *tbIt)
 150     {
 151         _vBlobs.insert(tbIt, tmpBlob);
 152     }
 153     else
 154     {
 155         fprintf(stderr, "addC: blob %d mode %d already present\n",
 156                 uiId,
 157                 GestureData::AddGesture);
 158     }
 159 }
 160
 161 void GestureData::updateGesture(      UInt32       uiId,
 162                                 const std::string &szGesture,
 163                                       Real32       rX,
 164                                       Real32       rY,
 165                                       UInt32       uiCoordSys)
 166 {
 167     ActiveBlobsStoreIt aIt = std::lower_bound(_vActiveBlobs.begin(),
 168                                               _vActiveBlobs.end  (),
 169                                                uiId);
 170
 171     UInt32 uiEvent = GestureData::UpdateGesture;
 172
 173     if(aIt == _vActiveBlobs.end())
 174     {
 175         uiEvent = GestureData::AddGesture;
 176
 177         _vActiveBlobs.push_back(uiId);
 178     }
 179     else
 180     {
 181         if(uiId != *aIt)
 182         {
 183             uiEvent = GestureData::AddGesture;
 184
 185             _vActiveBlobs.insert(aIt, uiId);
 186         }
 187     }
 188
 189     GestureBlob tmpBlob(uiEvent, uiId, szGesture, rX, rY, uiCoordSys);
 190
 191 //    fprintf(stderr, "update coursor %d / %f %f\n",
 192 //            uiId, rX, rY);
 193
 194     GestureBlobStoreIt tbIt = std::lower_bound(_vBlobs.begin(),
 195                                                _vBlobs.end  (),
 196                                                 tmpBlob       );
 197
 198     if(tbIt == _vBlobs.end())
 199     {
 200         _vBlobs.push_back(tmpBlob);
 201     }
 202     else if(tmpBlob != *tbIt)
 203     {
 204         _vBlobs.insert(tbIt, tmpBlob);
 205     }
 206     else
 207     {
 208         *tbIt = tmpBlob;
 209     }
 210 }
 211
 212 void GestureData::removeGesture(UInt32 uiId)
 213 {
 214     GestureBlob tmpBlob(GestureData::RemoveGesture, uiId, "", 0.f, 0.f);
 215
 216     GestureBlobStoreIt tbIt = std::lower_bound(_vBlobs.begin(),
 217                                                _vBlobs.end  (),
 218                                                 tmpBlob       );
 219
 220     if(tbIt == _vBlobs.end())
 221     {
 222         _vBlobs.push_back(tmpBlob);
 223     }
 224     else if(tmpBlob != *tbIt)
 225     {
 226         _vBlobs.insert(tbIt, tmpBlob);
 227     }
 228     else
 229     {
 230         fprintf(stderr, "remC: blob %d mode %d already present\n",
 231                 uiId,
 232                 GestureData::RemoveGesture);
 233     }
 234
 235     ActiveBlobsStoreIt aIt = std::lower_bound(_vActiveBlobs.begin(),
 236                                               _vActiveBlobs.end  (),
 237                                                uiId);
 238
 239     if(aIt != _vActiveBlobs.end())
 240     {
 241         if((*aIt) == uiId)
 242         {
 243             _vActiveBlobs.erase(aIt);
 244         }
 245     }
 246 }
 247
 248
 249 void GestureData::prepSubmission(void)
 250 {
 251 }
 252
 253 void GestureData::clear(void)
 254 {
 255 //    fprintf(stderr, "clear\n");
 256 //    this->dump();
 257     _vBlobs.clear();
 258 }
 259
 260 void GestureData::dump(void) const
 261 {
 262     fprintf(stderr, "Blobs (%" PRISize ") :\n", _vBlobs.size());
 263     for(UInt32 i = 0; i < _vBlobs.size(); ++i)
 264     {
 265         fprintf(stderr, "  [%d] : %d %d %d | %f %f\n",
 266                 i,
 267                 _vBlobs[i]._uiEvent,
 268                 _vBlobs[i]._iGestureId,
 269                 _vBlobs[i]._uiCoordSys,
 270                 _vBlobs[i]._vPosition[0],
 271                 _vBlobs[i]._vPosition[1]);
 272     }
 273
 274     fprintf(stderr, "Active Blobs (%" PRISize ") :\n", _vActiveBlobs.size());
 275
 276     for(UInt32 i = 0; i < _vActiveBlobs.size(); ++i)
 277     {
 278         fprintf(stderr, "[%d] : %d\n",
 279                 i,
 280                 _vActiveBlobs[i]);
 281     }
 282 }
 283
 284 DataType FieldTraits<GestureData>::_type("GestureData",        "BaseType"    );
 285
 286 OSG_FIELDTRAITS_GETTYPE (        GestureData    )
 287 OSG_FIELD_DLLEXPORT_DEF1(SField, GestureData    )
 288
 289 OSG_END_NAMESPACE