CGenericTool.h

Go to the documentation of this file.

//==============================================================================
/*
    Software License Agreement (BSD License)
    Copyright (c) 2003-2016, CHAI3D.
    (www.chai3d.org)

    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    * Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above
    copyright notice, this list of conditions and the following
    disclaimer in the documentation and/or other materials provided
    with the distribution.

    * Neither the name of CHAI3D nor the names of its contributors may
    be used to endorse or promote products derived from this software
    without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE. 

    \author    <http://www.chai3d.org>
    \author    Francois Conti
    \version   3.2.0 $Rev: 2188 $
*/
//==============================================================================

//------------------------------------------------------------------------------
#ifndef CGenericToolH
#define CGenericToolH
//------------------------------------------------------------------------------
#include "collisions/CGenericCollision.h"
#include "devices/CGenericHapticDevice.h"
#include "forces/CAlgorithmFingerProxy.h"
#include "forces/CAlgorithmPotentialField.h"
#include "timers/CFrequencyCounter.h"
#include "tools/CHapticPoint.h"
#include "world/CGenericObject.h"
#include "world/CWorld.h"
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
namespace chai3d {
//------------------------------------------------------------------------------

//==============================================================================
//==============================================================================

//==============================================================================
//==============================================================================
class cGenericTool : public cGenericObject
{
    //--------------------------------------------------------------------------
    // CONSTRUCTOR & DESTRUCTOR:
    //--------------------------------------------------------------------------

public:

    cGenericTool(cWorld* a_parentWorld);

    virtual ~cGenericTool();


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - HAPTIC DEVICE
    //--------------------------------------------------------------------------

public:

    void setHapticDevice(cGenericHapticDevicePtr a_hapticDevice) { if (a_hapticDevice != nullptr) { m_hapticDevice = a_hapticDevice; } }

    cGenericHapticDevicePtr getHapticDevice() { return (m_hapticDevice); }

    virtual bool start();

    virtual bool stop();


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - FORCE CONTROL
    //--------------------------------------------------------------------------

public:

    virtual void initialize();

    virtual void updateFromDevice();

    virtual void computeInteractionForces();

    virtual bool applyToDevice();

    virtual bool setForcesON();

    virtual bool setForcesOFF();


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - STARTUP MODES
    //--------------------------------------------------------------------------

public:

    inline void setWaitForSmallForce(const bool a_value) { m_useWaitForSmallForce = a_value; }

    inline bool getWaitForSmallForce() { return (m_useWaitForSmallForce); }

    void setSmallForceThresh(const double a_smallForceThresh) { m_smallForceThresh = fabs(a_smallForceThresh); }

    double getSmallForceThresh() { return (m_smallForceThresh); }

    void setUseForceRise(const bool a_value) { m_useForceRise = a_value; if (a_value) m_forceEngaged = true; }

    bool getUseForceRise() { return (m_useForceRise); }

    void setRiseTime(const double a_riseTime) { m_forceRiseTime = fabs(a_riseTime); }

    double getRiseTime() { return (m_forceRiseTime); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - USER SWITCH DATA
    //--------------------------------------------------------------------------

public:

    virtual bool getUserSwitch(const unsigned int a_switchIndex) const { return (cCheckBit(m_userSwitches, a_switchIndex)); }

    virtual void setUserSwitch(const unsigned int a_switchIndex, const bool a_value);

    virtual unsigned int getUserSwitches() const { return (m_userSwitches); }

    virtual void setUserSwitches(const unsigned int a_userSwitches);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - GRIPPER ANGLE POSITION AND ANGULAR VELOCITY
    //--------------------------------------------------------------------------

public:

    virtual double getGripperAngleRad() const { return (m_gripperAngle); }

    virtual void setGripperAngleRad(const double& a_gripperAngleRad);

    virtual double getGripperAngleDeg() const { return (cRadToDeg(m_gripperAngle)); }

    virtual void setGripperAngleDeg(const double& a_gripperAngleDeg);

    virtual double getGripperAngVel() const { return (m_gripperAngVel); }

    virtual void setGripperAngVel(const double& a_gripperAngVel);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - DEVICE POSITION AND VELOCITY
    //--------------------------------------------------------------------------

public:

    virtual cVector3d getDeviceLocalPos() const { return (m_deviceLocalPos); }

    virtual void setDeviceLocalPos(const cVector3d& a_localPos);

    void setDeviceLocalPos(const double& a_x, const double& a_y, const double& a_z) { setDeviceLocalPos(cVector3d(a_x, a_y, a_z)); }

    virtual cVector3d getDeviceGlobalPos() const { return (m_deviceGlobalPos); }

    virtual void setDeviceGlobalPos(const cVector3d& a_globalPos);

    void setDeviceGlobalPos(const double& a_x, const double& a_y, const double& a_z) { setDeviceGlobalPos(cVector3d(a_x, a_y, a_z)); }

    virtual cVector3d getDeviceLocalLinVel() const { return (m_deviceLocalLinVel); }

    virtual void setDeviceLocalLinVel(const cVector3d& a_localLinVel);

    void setDeviceLocalLinVel(const double& a_x, const double& a_y, const double& a_z) { setDeviceLocalLinVel(cVector3d(a_x, a_y, a_z)); }

    virtual cVector3d getDeviceGlobalLinVel() const { return (m_deviceGlobalLinVel); }

    virtual void setDeviceGlobalLinVel(const cVector3d& a_globalLinVel);

    void setDeviceGlobalLinVel(const double& a_x, const double& a_y, const double& a_z) { setDeviceGlobalLinVel(cVector3d(a_x, a_y, a_z)); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - DEVICE ROTATION AND ANGULAR VELOCITY
    //--------------------------------------------------------------------------

public:

    virtual cMatrix3d getDeviceLocalRot() const { return (m_deviceLocalRot); }

    virtual void setDeviceLocalRot(const cMatrix3d& a_localRot);

    virtual void setDeviceGlobalRot(const cMatrix3d& a_globalRot);

    virtual cMatrix3d getDeviceGlobalRot() const { return (m_deviceGlobalRot); }

    virtual cVector3d getDeviceLocalAngVel() const { return (m_deviceLocalAngVel); }

    virtual void setDeviceLocalAngVel(const cVector3d& a_localAngVel);

    void setDeviceLocalAngVel(const double& a_x, const double& a_y, const double& a_z) { setDeviceLocalAngVel(cVector3d(a_x, a_y, a_z)); }

    virtual cVector3d getDeviceGlobalAngVel() const { return (m_deviceGlobalAngVel); }

    virtual void setDeviceGlobalAngVel(const cVector3d& a_globalAngVel);

    void setDeviceGlobalAngVel(const double& a_x, const double& a_y, const double& a_z) { setDeviceGlobalAngVel(cVector3d(a_x, a_y, a_z)); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - DEVICE POSITION AND ROTATION TRANSFORM
    //--------------------------------------------------------------------------

public:

    virtual cTransform getDeviceLocalTransform() const { return (cTransform(m_deviceLocalPos, m_deviceLocalRot)); }

    virtual void setDeviceLocalTransform(const cTransform& a_localTransform);

    virtual cTransform getDeviceGlobalTransform() const { return (cTransform(m_deviceGlobalPos, m_deviceGlobalRot)); }

    virtual void setDeviceGlobalTransform(const cTransform& a_globalTransform);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - GRIPPER FORCE
    //--------------------------------------------------------------------------

public:

    virtual double getGripperForce() const { return (m_gripperForce); }

    virtual void setGripperForce(const double& a_gripperForce);

    virtual void addGripperForce(const double& a_gripperForce);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - DEVICE FORCE
    //--------------------------------------------------------------------------

public:

    virtual cVector3d getDeviceLocalForce() const { return (m_deviceLocalForce); }

    virtual void setDeviceLocalForce(const cVector3d& a_localForce);

    void setDeviceLocalForce(const double& a_x, const double& a_y, const double& a_z) { setDeviceLocalForce(cVector3d(a_x, a_y, a_z)); }

    virtual void addDeviceLocalForce(const cVector3d& a_localForce);

    void addDeviceLocalForce(const double& a_x, const double& a_y, const double& a_z) { addDeviceLocalForce(cVector3d(a_x, a_y, a_z)); }

    virtual cVector3d getDeviceGlobalForce() const { return (m_deviceGlobalForce); }

    virtual void setDeviceGlobalForce(const cVector3d& a_globalForce);

    void setDeviceGlobalForce(const double& a_x, const double& a_y, const double& a_z) { setDeviceGlobalForce(cVector3d(a_x, a_y, a_z)); }

    virtual void addDeviceGlobalForce(const cVector3d& a_globalForce);

    void addDeviceGlobalForce(const double& a_x, const double& a_y, const double& a_z) { addDeviceGlobalForce(cVector3d(a_x, a_y, a_z)); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - DEVICE TORQUE
    //--------------------------------------------------------------------------

public:

    virtual cVector3d getDeviceLocalTorque() const { return (m_deviceLocalTorque); }

    virtual void setDeviceLocalTorque(const cVector3d& a_localTorque);

    void setDeviceLocalTorque(const double& a_x, const double& a_y, const double& a_z) { setDeviceLocalTorque(cVector3d(a_x, a_y, a_z)); }

    virtual void addDeviceLocalTorque(const cVector3d& a_localTorque);

    void addDeviceLocalTorque(const double& a_x, const double& a_y, const double& a_z) { addDeviceLocalTorque(cVector3d(a_x, a_y, a_z)); }

    virtual cVector3d getDeviceGlobalTorque() const { return (m_deviceGlobalTorque); }

    virtual void setDeviceGlobalTorque(const cVector3d& a_globalTorque);

    void setDeviceGlobalTorque(const double& a_x, const double& a_y, const double& a_z) { setDeviceGlobalTorque(cVector3d(a_x, a_y, a_z)); }

    virtual void addDeviceGlobalTorque(const cVector3d& a_globalTorque);

    void addDeviceGlobalTorque(const double& a_x, const double& a_y, const double& a_z) { addDeviceGlobalTorque(cVector3d(a_x, a_y, a_z)); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - WORKSPACE SETTINGS
    //--------------------------------------------------------------------------

public:

    bool setWorkspaceRadius(const double& a_workspaceRadius);

    double getWorkspaceRadius() { return(m_workspaceRadius); }

    bool setWorkspaceScaleFactor(const double& a_workspaceScaleFactor);

    double getWorkspaceScaleFactor() { return (m_workspaceScaleFactor); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - HAPTIC POINTS
    //--------------------------------------------------------------------------

public:

    virtual bool isInContact(cGenericObject* a_object);

    int getNumHapticPoints() { return (int)(m_hapticPoints.size()); }

    cHapticPoint* getHapticPoint(int a_index) { return (m_hapticPoints[a_index]); }

    virtual void setRadius(double a_radius);

    virtual void setRadius(double a_radiusDisplay, double a_radiusContact);

    virtual void setRadiusContact(double a_radiusContact);

    virtual void setRadiusDisplay(double a_radiusDisplay); 

    virtual void setShowContactPoints(bool a_showProxy = true, 
                                      bool a_showGoal = false, 
                                      cColorf a_colorLine = cColorf(0.5, 0.5, 0.5));


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - WORLD
    //--------------------------------------------------------------------------

public:

    cWorld* getParentWorld() { return (m_parentWorld); }

    virtual void enableDynamicObjects(bool a_enabled);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - AUDIO
    //--------------------------------------------------------------------------

public:

    bool createAudioSource(cAudioDevice* a_audioDevice);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - GRAPHIC REPRESENTATION
    //--------------------------------------------------------------------------

public:

    virtual void render(cRenderOptions& a_options) {};

    virtual void setShaderProgram(cShaderProgramPtr a_shaderProgram, const bool a_affectChildren = false);


    //--------------------------------------------------------------------------
    // PUBLIC MEMBERS 
    //--------------------------------------------------------------------------

public:

    cGenericObject* m_image;


    //--------------------------------------------------------------------------
    // PROTECTED MEMBERS - HAPTIC POINTS
    //--------------------------------------------------------------------------

protected:

    std::vector <cHapticPoint*> m_hapticPoints;


    //--------------------------------------------------------------------------
    // PROTECTED MEMBERS - HAPTIC DEVICE
    //--------------------------------------------------------------------------

protected:

    cGenericHapticDevicePtr m_hapticDevice;

    unsigned int m_userSwitches;

    bool m_enabled;


    //--------------------------------------------------------------------------
    // PROTECTED MEMBERS - FORCE DATA
    //--------------------------------------------------------------------------

protected:

    cVector3d m_deviceLocalForce;

    cVector3d m_deviceGlobalForce;

    cVector3d m_deviceLocalTorque;

    cVector3d m_deviceGlobalTorque;

    double m_gripperForce;


    //--------------------------------------------------------------------------
    // PROTECTED MEMBERS - TOOL POSE AND WORKSPACE SETTINGS
    //--------------------------------------------------------------------------

protected:

    double m_workspaceRadius;

    double m_workspaceScaleFactor;

    cVector3d m_deviceLocalPos;

    cVector3d m_deviceGlobalPos;

    cMatrix3d m_deviceLocalRot;

    cMatrix3d m_deviceGlobalRot;

    cVector3d m_deviceLocalLinVel;

    cVector3d m_deviceGlobalLinVel;

    cVector3d m_deviceLocalAngVel;

    cVector3d m_deviceGlobalAngVel;

    double m_gripperAngle;

    double m_gripperAngVel;


    //--------------------------------------------------------------------------
    // PROTECTED MEMBERS - INTERNAL
    //--------------------------------------------------------------------------

protected:

    cWorld* m_parentWorld;

    bool m_forceOn;

    bool m_forceEngaged;

    bool m_useWaitForSmallForce;

    int m_smallForceCounter;

    double m_smallForceThresh;

    bool m_useForceRise;

    double m_forceRiseTime;

    cPrecisionClock m_forceRiseClock;

    bool m_flagForceRiseFirstTime;

    bool m_flagForceRiseActivated;

    cFrequencyCounter m_freqRead;

    cFrequencyCounter m_freqWrite;


    //--------------------------------------------------------------------------
    // PROTECTED METHODS:
    //--------------------------------------------------------------------------

protected:

    virtual void updateToolImagePosition();

    virtual void updateGlobalPositions(const bool a_frameOnly);
};

//------------------------------------------------------------------------------
} // namespace chai3d
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
#endif
//------------------------------------------------------------------------------