rigidbody.h

/*
    OpenMBV - Open Multi Body Viewer.
    Copyright (C) 2009 Markus Friedrich
 
  This library is free software; you can redistribute it and/or 
  modify it under the terms of the GNU Lesser General Public 
  License as published by the Free Software Foundation; either 
  version 2.1 of the License, or (at your option) any later version. 
   
  This library is distributed in the hope that it will be useful, 
  but WITHOUT ANY WARRANTY; without even the implied warranty of 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
  Lesser General Public License for more details. 
   
  You should have received a copy of the GNU Lesser General Public 
  License along with this library; if not, write to the Free Software 
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
*/
 
#ifndef _OPENMBV_RIGIDBODY_H_
#define _OPENMBV_RIGIDBODY_H_
 
#include <openmbvcppinterface/dynamiccoloredbody.h>
#include <vector>
#include <cassert>
#include <hdf5serie/vectorserie.h>
#include <stdexcept>
 
namespace OpenMBV {
 
  class CompoundRigidBody;
 
  class RigidBody : public DynamicColoredBody {
    friend class CompoundRigidBody;
    protected:
      std::string localFrameStr, referenceFrameStr, pathStr, draggerStr;
      std::vector<double> initialTranslation{3};
      std::vector<double> initialRotation{3};
      double scaleFactor{1};
      void createHDF5File() override;
      void openHDF5File() override;
      H5::VectorSerie<double>* data{nullptr};
      std::weak_ptr<CompoundRigidBody> compound;
 
      RigidBody();
      ~RigidBody() override;
    public:
      void setLocalFrame(bool f) { localFrameStr=(f)?"true":"false"; }
 
      bool getLocalFrame() { return localFrameStr=="true"?true:false; }
 
      void setReferenceFrame(bool f) { referenceFrameStr=(f)?"true":"false"; }
 
      bool getReferenceFrame() { return referenceFrameStr=="true"?true:false; }
 
      void setPath(bool p) { pathStr=(p)?"true":"false"; }
 
      bool getPath() { return pathStr=="true"?true:false; }
 
      void setDragger(bool p) { draggerStr=(p)?"true":"false"; }
 
      bool getDragger() { return draggerStr=="true"?true:false; }
 
      void setInitialTranslation(const std::vector<double> &initTrans) {
        if(initTrans.size()!=3) std::runtime_error("the dimension does not match");
        initialTranslation=initTrans;
      }
 
      std::vector<double> getInitialTranslation() { return initialTranslation; }
 
      void setInitialTranslation(double x, double y, double z) {
        initialTranslation[0] = x;
        initialTranslation[1] = y;
        initialTranslation[2] = z;
      }
 
      void setInitialRotation(const std::vector<double>& initRot) {
        if(initRot.size()!=3) throw std::runtime_error("the dimension does not match");
        initialRotation=initRot;
      }
 
      std::vector<double> getInitialRotation() { return initialRotation; }
 
      void setInitialRotation(double a, double b, double g) {
        initialRotation[0] = a;
        initialRotation[1] = b;
        initialRotation[2] = g;
      }
 
      void setScaleFactor(double scale) {
        scaleFactor=scale;
      }
 
      double getScaleFactor() { return scaleFactor; }
 
      template<typename T>
      void append(const T& row) {
        if(data==nullptr) throw std::runtime_error("can not append data to an environment object");
        if(row.size()!=8) throw std::runtime_error("the dimension does not match");
        if(!std::isnan(dynamicColor))
        {
          std::vector<double> tmprow(8);
          std::copy(&row[0], &row[8], tmprow.begin());
          tmprow[7]=dynamicColor;
          data->append(tmprow);
        }
        else
          data->append(row);
      }
 
      int getRows() override { return data?data->getRows():0; }
      std::vector<double> getRow(int i) override { return data?data->getRow(i):std::vector<double>(8); }
 
      void initializeUsingXML(xercesc::DOMElement *element) override;
 
      xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent) override;
 
      std::string getFullName() override;
 
      std::shared_ptr<Group> getTopLevelGroup();
 
      std::weak_ptr<CompoundRigidBody> getCompound() { return compound; }
  };
 
}
 
#endif /* _OPENMBV_RIGIDBODY_H_ */