imstkGeometry.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 "imstkEventObject.h"
#include "imstkMacros.h"
#include "imstkMath.h"

#include <unordered_map>
#include <string>

namespace imstk
{
class Geometry : public EventObject
{
public:
    enum class TransformType
    {
        ApplyToData,
        ConcatenateToTransform
    };

    enum class DataType
    {
        PreTransform,
        PostTransform
    };

protected:
    Geometry() : m_globalId(getUniqueId()) { }

public:
    Geometry(const Geometry& other)
    {
        m_transformApplied = other.m_transformApplied;
        m_transform = other.m_transform;
        m_globalId  = Geometry::getUniqueId();
    }

    ~Geometry() override = default;

    void operator=(const Geometry& other)
    {
        m_transformApplied = other.m_transformApplied;
        m_transform = other.m_transform;
        m_globalId  = Geometry::getUniqueId();
    }

    virtual const std::string getTypeName() const = 0;

    // *INDENT-OFF*
    SIGNAL(Geometry, modified);
    // *INDENT-ON*

    virtual void print() const;

    virtual double getVolume() { return 0.0; };

    virtual void computeBoundingBox(Vec3d& lowerCorner, Vec3d& upperCorner, const double paddingPercent = 0.0);

    virtual Vec3d getCenter()
    {
        Vec3d min, max;
        computeBoundingBox(min, max);
        return (min + max) * 0.5;
    }

    void translate(const Vec3d& t, TransformType type = TransformType::ConcatenateToTransform);
    void translate(double x, double y, double z, TransformType type = TransformType::ConcatenateToTransform);

    void rotate(const Quatd& q, TransformType type = TransformType::ConcatenateToTransform);
    void rotate(const Mat3d& m, TransformType type = TransformType::ConcatenateToTransform);
    void rotate(const Vec3d& axis, double radians, TransformType type = TransformType::ConcatenateToTransform);

    void scale(const Vec3d& scaling, TransformType type = TransformType::ConcatenateToTransform);
    void scale(const double scaling, TransformType type = TransformType::ConcatenateToTransform);

    void transform(const Mat4d& T, TransformType type = TransformType::ConcatenateToTransform);

    Vec3d getTranslation() const;
    void setTranslation(const Vec3d& t);
    void setTranslation(const double x, const double y, const double z);

    Mat3d getRotation() const;
    void setRotation(const Mat3d& m);
    void setRotation(const Quatd& q);
    void setRotation(const Vec3d& axis, const double angle);

    Vec3d getScaling() const;
    void setScaling(const Vec3d& s);
    void setScaling(const double s);

    const Mat4d& getTransform() const { return m_transform; }
    void setTransform(const Mat4d& m)
    {
        m_transform = m;
        m_transformApplied = false;
    }


    std::unique_ptr<Geometry> clone()
    {
        return std::unique_ptr<Geometry>(cloneImplementation());
    }

    const std::string& getName() const { return m_name; }
    void setName(const std::string& name) { m_name = name; }

    size_t getGlobalId() const { return m_globalId; }

    static size_t getNumGlobalIds() { return s_numGlobalIds; }

    virtual bool isMesh() const { return false; }

    void postModified()
    {
        m_boundsDirty = true;
        this->postEvent(Event(Geometry::modified()));
    }

    virtual void updatePostTransformData() const { }

protected:
    virtual void applyTransform(const Mat4d&) { }

    static size_t getUniqueId()
    {
        const size_t idx = s_numGlobalIds;
        s_numGlobalIds++;
        return idx;
    }

protected:
    mutable bool m_transformApplied = true; // Internally used for lazy evaluation
    mutable bool m_boundsDirty      = true;

    Mat4d m_transform = Mat4d::Identity();  

    size_t      m_globalId;                 
    std::string m_name = "unnamed";

    static std::atomic<size_t> s_numGlobalIds;

private:
    virtual Geometry* cloneImplementation() const = 0;
};
} // namespace imstk