ARToolKit.h

Go to the documentation of this file.

/* This file is part of COVISE.
 
   You can use it under the terms of the GNU Lesser General Public License
   version 2.1 or later, see lgpl-2.1.txt.
 
 * License: LGPL 2+ */
 
#ifndef ARTOOLKIT_H
#define ARTOOLKIT_H
 
#include <list>
#include <osg/Matrix>
#include <osg/MatrixTransform>
#include <osg/Drawable>
#include <osg/Geode>
#include <osg/Geometry>
#include <osg/Vec3>
 
namespace opencover
{
class ARToolKitMarker;
class coTUILabel;
class coTUIToggleButton;
class coTUIEditFloatField;
class coTUIEditFloatField;
class coTUITab;
class coTUIElement;
}
 
#include <net/covise_connect.h>
#include <net/message.h>
 
#include "coTUIListener.h"
 
namespace opencover
{
class COVEREXPORT ARToolKitNode : public osg::Drawable
{
private:
    bool displayVideo; // true if CoviseConfig.displayVideo is set
    bool renderTextures;
    std::string m_artoolkitVariant;
 
public:
    ARToolKitNode(std::string artoolkitVariant);
    virtual ~ARToolKitNode();
    static ARToolKitNode *theNode;
    virtual void drawImplementation(osg::RenderInfo &renderInfo) const;
    virtual osg::Object *cloneType() const;
 
    virtual osg::Object *clone(const osg::CopyOp &) const;
};
 
class COVEREXPORT ARToolKitInterface
{
public:
    ARToolKitInterface(){};
    virtual ~ARToolKitInterface(){};
    virtual int loadPattern(const char *)
    {
        return -1;
    };
    virtual bool isVisible(int)
    {
        return false;
    };
    virtual osg::Matrix getMat(int /* pattID */, double /*pattCenter*/[2], double /*pattSize*/, double /* pattTrans */[3][4])
    {
        osg::Matrix m;
        return m;
    };
    virtual void updateViewerPos(const osg::Vec3f &vp)
    {
        (void)vp;
    }
    virtual void updateMarkerParams(){};
    virtual bool isARToolKit()
    {
        return false;
    };
};
 
class COVEREXPORT RemoteARInterface
{
public:
    RemoteARInterface()
    {
    }
    virtual ~RemoteARInterface()
    {
    }
    virtual void update() = 0;
    virtual void receiveImage(const char *data) = 0;
    virtual void updateBitrate(const int bitrate) = 0;
    virtual bool usesIRMOS() const
    {
        return false;
    }
    virtual bool isReceiver() const
    {
        return false;
    }
    virtual covise::ClientConnection *getIRMOSClient() const
    {
        return NULL;
    }
};
 
class COVEREXPORT ARToolKit
{
private:
    static ARToolKit *art;
    ARToolKit();
    std::string m_configPath;
    covise::Message msg;
 
    bool objTracking;
    int numObjectMarkers;
    std::list<ARToolKitMarker *> objectMarkers;
 
public:
    bool running;
    virtual ~ARToolKit();
    static ARToolKit *instance();
    coTUITab *artTab;
    bool flipH;
    ARToolKitInterface *arInterface;
    RemoteARInterface *remoteAR;
 
    void update();
    void config();
    bool isRunning();
 
    unsigned char *videoData;
    unsigned char *videoDataRight;
    int videoWidth;
    int videoHeight;
    int videoMode;
    int videoDepth;
    bool stereoVideo;
    bool videoMirrorLeft;
    bool videoMirrorRight;
    std::string m_artoolkitVariant;
    std::list<ARToolKitMarker *> markers;
    void addMarker(ARToolKitMarker *);
    bool doMerge;
    bool testImage;
};
 
class COVEREXPORT ARToolKitMarker : public coTUIListener
{
private:
    int pattID;
    double pattSize;
    double pattCenter[2];
    double pattTrans[3][4];
    bool VrmlToPf;
    bool objectMarker;
    float x, y, z, h, p, r;
    bool visible;
    osg::Matrix offset;
    osg::Matrix Ctrans;
    osg::Matrix Mtrans;
    coTUILabel *markerLabel = nullptr;
    coTUIToggleButton *vrmlToPfFlag = nullptr;
    coTUIEditFloatField *size = nullptr;
    coTUIEditFloatField *posX = nullptr;
    coTUIEditFloatField *posY = nullptr;
    coTUIEditFloatField *posZ = nullptr;
    coTUIEditFloatField *rotH = nullptr;
    coTUIEditFloatField *rotP = nullptr;
    coTUIEditFloatField *rotR = nullptr;
 
public:
    ARToolKitMarker(const std::string &configName,int MarkerID,double size,osg::Matrix&mat, osg::Matrix& hostMat,bool VrmlToOSG);
    ARToolKitMarker(const char* Name);
    void updateData(double markerSize, osg::Matrix& mat, osg::Matrix& hostMat, bool vrmlToOsg);
    virtual ~ARToolKitMarker();
    osg::Matrix &getCameraTrans();
    osg::Matrix &getMarkerTrans();
    osg::Matrix &getOffset()
    {
        return offset;
    };
    virtual void tabletEvent(coTUIElement *tUIItem);
    double getSize();
    int getPattern();
    bool isVisible();
    bool isObjectMarker()
    {
        return objectMarker;
    };
    void setObjectMarker(bool o)
    {
        objectMarker = o;
    };
    void setColor(float r, float g, float b);
    osg::Geode *quadGeode = nullptr;
    osg::ref_ptr<osg::MatrixTransform> markerQuad;
    osg::MatrixTransform *posSize=nullptr;
    osg::Vec4Array *colors = nullptr;
    osg::Geometry *geom = nullptr;
    coTUIToggleButton *displayQuad = nullptr;
    coTUIToggleButton *calibrate = nullptr;
    int numCalibSamples;
    osg::Matrix matrixSumm;
    bool lastVisible;
    void setOffset(osg::Matrix &mat);
    osg::Matrix OpenGLToOSGMatrix;
    osg::Matrix PfToOpenGLMatrix;
};
}
#endif