imstkGeometryAlgorithm.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 "imstkLogger.h"
#include "imstkMacros.h"

#include <functional>
#include <memory>
#include <unordered_map>

namespace imstk
{
class Geometry;

template<class Base, class Target>
std::function<bool(Base*)>
makeTypeCheck()
{
    return [](Base* p) {
               return (dynamic_cast<Target*>(p) != nullptr);
           };
}

class GeometryAlgorithm
{
protected:
    GeometryAlgorithm() = default;

public:
    virtual ~GeometryAlgorithm() = default;

    std::shared_ptr<Geometry> getInput(size_t port = 0) const
    {
        return (m_inputs.count(port) == 0) ? nullptr : m_inputs.at(port);
    }

    std::shared_ptr<Geometry> getOutput(size_t port = 0) const
    {
        return m_outputs.count(port) == 0 ? nullptr : m_outputs.at(port);
    }

    void setInput(std::shared_ptr<Geometry> inputGeometry, size_t port = 0);

    void update()
    {
        if (!areInputsValid())
        {
            LOG(WARNING) << "GeometryAlgorithm failed to run, inputs not satisfied";
            return;
        }
        //if (m_modified)
        //{
        requestUpdate();
        //}
        //m_modified = false;
    }

protected:
    void setOutput(std::shared_ptr<Geometry> inputGeometry, const size_t port = 0);

    void setNumInputPorts(const size_t numPorts);
    imstkGetMacro(NumInputPorts, size_t);

    void setNumOutputPorts(const size_t numPorts);
    imstkGetMacro(NumOutputPorts, size_t);

    template<typename T>
    void setRequiredInputType(const size_t port)
    {
        CHECK(m_optionalTypeChecks.find(port) == m_optionalTypeChecks.end())
            << "There is already an optional type for this port " << port << ", can't assign another one.";
        m_requiredTypeChecks[port] = makeTypeCheck<Geometry, T>();
    }

    template<typename T>
    void setOptionalInputType(const size_t port)
    {
        CHECK(m_requiredTypeChecks.find(port) == m_requiredTypeChecks.end())
            << "There is already a required type for port " << port << " , can't assign another one.";
        m_optionalTypeChecks[port] = makeTypeCheck<Geometry, T>();
    }

    virtual void requestUpdate() = 0;

    virtual bool areInputsValid();

    using GeometryCheck      = std::function<bool (Geometry*)>;
    using TypeCheckContainer = std::unordered_map<size_t, GeometryCheck>;

    TypeCheckContainer m_requiredTypeChecks;
    TypeCheckContainer m_optionalTypeChecks;

private:

    std::unordered_map<size_t, std::shared_ptr<Geometry>> m_inputs;
    std::unordered_map<size_t, std::shared_ptr<Geometry>> m_outputs;

    //bool m_modified = true;
    size_t m_NumInputPorts  = 1;
    size_t m_NumOutputPorts = 1;
};
} // namespace imstk