imstkProgrammableClient.h

/*
** This file is part of the Interactive Medical Simulation Toolkit (iMSTK)
** iMSTK is distributed under the Apache License, Version 2.0.
** See accompanying NOTICE for details.
*/

#pragma once

#include "imstkDeviceClient.h"
#include "imstkPbdObject.h"
#include "imstkPbdObjectGrasping.h"
#include "imstkSurfaceMesh.h"

#include <unordered_map>

namespace imstk
{
class ProgrammableClient : public DeviceClient
{
public:
    ProgrammableClient(const std::string& name = "") : DeviceClient(name, "localhost") {}

    ~ProgrammableClient() override;

    enum  DeformationType { Compression, Tension, SimpleShear, PureShear };
protected:
    void run()     = delete;
    void cleanUp() = delete;

    enum class CommandState { WAITING=0, ACTIVE, COMPLETE };

    struct Command
    {
        virtual ~Command() = default;
        CommandState state = CommandState::WAITING;
        double startTime   = 0.0;
        double duration    = 0.0;
        virtual void activate(ProgrammableClient&) { state = CommandState::ACTIVE; }
        virtual void updateDevice(ProgrammableClient&) = 0;
        virtual void complete(ProgrammableClient&) { state = CommandState::COMPLETE; }
    };
    friend Command;

    struct LinearMovement : Command
    {
        Vec3d startPosition = Vec3d::Zero();
        Vec3d stopPosition  = Vec3d::Zero();
        void activate(ProgrammableClient&) override;
        void updateDevice(ProgrammableClient&) override;
        void complete(ProgrammableClient&) override;
    };

    struct CircularMovement : Command
    {
        Vec3d startPosition  = Vec3d::Zero();
        Vec3d centerPosition = Vec3d::Zero();
        double radius    = 0.0;
        double angle     = 0;
        double angleStep = 0;
        void activate(ProgrammableClient&) override;
        void updateDevice(ProgrammableClient&) override;
        void complete(ProgrammableClient&) override;
    };

    struct GraspAction : Command
    {
        std::shared_ptr<PbdObjectGrasping> objectGrasping;
        std::shared_ptr<PbdObject> tool;
        void activate(ProgrammableClient&) override;
        void updateDevice(ProgrammableClient&) override { return; }
        void complete(ProgrammableClient&) override;
    };

    struct LinearVertexMovement : Command
    {
        std::shared_ptr<PbdObject> object;
        Vec3d translation = Vec3d::Zero();
        std::vector<bool> pin{ true, true, true };
        std::vector<int> vertexIds;
        std::vector<Vec3d> currPos;
        void activate(ProgrammableClient&) override;
        void updateDevice(ProgrammableClient&) override;
        void complete(ProgrammableClient&) override;
    };

    struct Deformation : Command
    {
        std::shared_ptr<PbdObject> object;
        Mat3d defGrad     = Mat3d::Identity();
        double strain     = 0.0;
        double strainRate = 0.0;
        double poissons   = 0.49;
        std::vector<bool> pin{ true, true, true };
        std::vector<int> vertexIds;

        DeformationType type;

        void activate(ProgrammableClient&) override;
        void updateDevice(ProgrammableClient&) override;
        void complete(ProgrammableClient&) override;
    };

    struct WaitCommand : Command
    {
        void activate(ProgrammableClient& pc) override { Command::activate(pc); }
        void updateDevice(ProgrammableClient&) override { return; }
        void complete(ProgrammableClient& pc) override { Command::complete(pc); }
    };

    struct HoldCommand : Command
    {
        std::shared_ptr<PbdObject> object;
        std::vector<int> vertexIds;
        std::vector<Vec3d> holdPosition;
        void activate(ProgrammableClient& pc) override;
        void updateDevice(ProgrammableClient&) override;
        void complete(ProgrammableClient& pc) override;
    };

    double m_dt = 0.0;
    double m_currentTime = 0.0;
    bool   m_complete    = false;
    std::vector<Command*> m_commands;

public:

    void setDeltaTime(double dt) { m_dt = dt; }

    void update() override;

    bool addLinearMovement(Vec3d startPos, Vec3d stopPos, double startTime, double duration);

    bool addCircularMovement(Vec3d startPos, Vec3d centerPos, double startTime, double duration);

    bool addGrasping(std::shared_ptr<PbdObject> tool, std::shared_ptr<PbdObjectGrasping> objectGrasping, double startTime, double duration);

    bool addLinearVertexMovement(std::shared_ptr<PbdObject> object, std::vector<int> vertexIds, Vec3d translation, std::vector<bool> pin, double startTime, double duration);

    bool addDeformation(std::shared_ptr<PbdObject> object, std::vector<int> initPos, double strain, DeformationType defType, double poisson, std::vector<bool> pin, double startTime, double duration);

    // TODO remove once addDeformation has been updated
    std::vector<int> findVertex(std::shared_ptr<PointSet> mesh, std::vector<Vec3d> initPos);

    bool addWaitCommand(double startTime, double duration);

    bool addHoldCommand(std::shared_ptr<PbdObject> object, double startTime, double duration, std::vector<int> vertexIds);

    double getTotalDuration();

    bool isFinished() { return this->m_complete; }

    void setOrientation(Quatd temp) { m_orientation = temp; }
};
} // namespace imstk