tfBody.h

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of Tissue Forge.
 * Copyright (c) 2022-2024 T.J. Sego and Tien Comlekoglu
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * 
 ******************************************************************************/

 
#ifndef _MODELS_VERTEX_SOLVER_TFBODY_H_
#define _MODELS_VERTEX_SOLVER_TFBODY_H_
 
#include <tf_port.h>
 
#include <state/tfStateVector.h>
 
#include "tf_mesh.h"
 
#include <io/tfThreeDFMeshData.h>
 
 
namespace TissueForge::models::vertex { 
 
 
    class Vertex;
    struct VertexHandle;
    class Surface;
    struct SurfaceHandle;
    class Mesh;
 
    struct BodyHandle;
    struct BodyType;
    struct SurfaceType;

    class CAPI_EXPORT Body { 

        int _objId;
 
    public:

        int typeId;
 
    private:

        std::vector<Surface*> surfaces;

        FVector3 centroid;

        FloatP_t area;

        FloatP_t volume;

        FloatP_t density;
 
    public:

        std::vector<MeshObjActor*> actors;

        state::StateVector *species;
 
        Body();
        ~Body();

        static BodyHandle create(const std::vector<SurfaceHandle> &_surfaces);

        static BodyHandle create(TissueForge::io::ThreeDFMeshData *ioMesh);
 
        MESHOBJ_DEFINEDBY_DECL(Vertex);
        MESHOBJ_DEFINEDBY_DECL(Surface);
        MESHOBJ_CLASSDEF(MeshObjTypeLabel::BODY)
 
        
        std::string str() const;

        std::string toString();

        void updateInternals();

        HRESULT add(Surface *s);

        HRESULT remove(Surface *s);

        HRESULT replace(Surface *toInsert, Surface *toRemove);

        static HRESULT destroy(Body *target);

        static HRESULT destroy(BodyHandle &target);

        static HRESULT destroy(const std::vector<Body*>& toRemove);

        BodyType *type() const;

        HRESULT become(BodyType *btype);

        const std::vector<Surface*>& getSurfaces() const { return surfaces; }

        std::vector<Vertex*> getVertices() const;

        Vertex *findVertex(const FVector3 &dir) const;

        Surface *findSurface(const FVector3 &dir) const;

        std::vector<Body*> connectedBodies() const;

        std::vector<Body*> adjacentBodies() const;

        std::vector<Surface*> neighborSurfaces(const Surface *s) const;

        const FloatP_t& getDensity() const { return density; }

        void setDensity(const FloatP_t &_density) { density = _density; }

        const FVector3& getCentroid() const { return centroid; }

        FVector3 getVelocity() const;

        const FloatP_t& getArea() const { return area; }

        const FloatP_t& getVolume() const { return volume; }

        FloatP_t getMass() const { return volume * density; }

        FloatP_t getVertexArea(const Vertex *v) const;

        FloatP_t getVertexVolume(const Vertex *v) const;

        FloatP_t getVertexMass(const Vertex *v) const { return getVertexVolume(v) * density; }

        std::vector<Surface*> findInterface(const Body *b) const;

        FloatP_t contactArea(const Body *other) const;

        std::vector<Vertex*> sharedVertices(const Body *other) const;

        bool isOutside(const FVector3 &pos) const;

        Body *split(const FVector3 &cp_pos, const FVector3 &cp_norm, SurfaceType *stype=NULL);
 
 
        friend BodyHandle;
        friend Vertex;
        friend Mesh;
        friend BodyType;
 
    };
 

    struct CAPI_EXPORT BodyHandle {
 
        int id;
 
        BodyHandle(const int &_id=-1);

        Body *body() const;

        bool definedBy(const VertexHandle &v) const;

        bool definedBy(const SurfaceHandle &s) const;

        MeshObjTypeLabel objType() const { return MeshObjTypeLabel::BODY; }

        HRESULT destroy();

        bool validate();

        HRESULT positionChanged();

        std::string str() const;

        std::string toString();

        static BodyHandle fromString(const std::string &s);

        HRESULT add(const SurfaceHandle &s);

        HRESULT remove(const SurfaceHandle &s);

        HRESULT replace(const SurfaceHandle &toInsert, const SurfaceHandle &toRemove);

        BodyType *type() const;

        HRESULT become(BodyType *btype);

        std::vector<SurfaceHandle> getSurfaces() const;

        std::vector<VertexHandle> getVertices() const;

        VertexHandle findVertex(const FVector3 &dir) const;

        SurfaceHandle findSurface(const FVector3 &dir) const;

        std::vector<BodyHandle> connectedBodies() const;

        std::vector<BodyHandle> adjacentBodies() const;

        std::vector<SurfaceHandle> neighborSurfaces(const SurfaceHandle &s) const;

        FloatP_t getDensity() const;

        void setDensity(const FloatP_t &_density);

        FVector3 getCentroid() const;

        FVector3 getVelocity() const;

        FloatP_t getArea() const;

        FloatP_t getVolume() const;

        FloatP_t getMass() const;

        FloatP_t getVertexArea(const VertexHandle &v) const;

        FloatP_t getVertexVolume(const VertexHandle &v) const;

        FloatP_t getVertexMass(const VertexHandle &v) const;

        state::StateVector *getSpecies() const;

        HRESULT setSpecies(state::StateVector *s) const;

        std::vector<SurfaceHandle> findInterface(const BodyHandle &b) const;

        FloatP_t contactArea(const BodyHandle &other) const;

        std::vector<VertexHandle> sharedVertices(const BodyHandle &other) const;

        bool isOutside(const FVector3 &pos) const;

        BodyHandle split(const FVector3 &cp_pos, const FVector3 &cp_norm, SurfaceType *stype=NULL);
 
        operator bool() const { return id >= 0; }
    };
 

    struct CAPI_EXPORT BodyType : MeshObjType {

        std::string name;

        FloatP_t density;
 
        BodyType(const bool &noReg=false);

        MeshObjTypeLabel objType() const override { return MeshObjTypeLabel::BODY; }

        virtual std::string str() const override;

        std::string toString();

        static BodyType *fromString(const std::string &str);

        static BodyType *findFromName(const std::string &_name);

        virtual HRESULT registerType();

        virtual void on_register() {}

        bool isRegistered();

        virtual BodyType *get();

        HRESULT add(const BodyHandle &i);

        HRESULT remove(const BodyHandle &i);

        HRESULT remove(const std::vector<BodyHandle>& i);

        std::vector<BodyHandle> getInstances();

        std::vector<int> getInstanceIds() { return _instanceIds; }

        unsigned int getNumInstances();

        BodyHandle operator() (const std::vector<SurfaceHandle> &surfaces);

        BodyHandle operator() (TissueForge::io::ThreeDFMeshData* ioMesh, SurfaceType *stype);

        BodyHandle extend(const SurfaceHandle &base, const FVector3 &pos);

        BodyHandle extrude(const SurfaceHandle &base, const FloatP_t &normLen);
 
    private:
 
        std::vector<int> _instanceIds;
 
    };
 
    inline bool operator< (const TissueForge::models::vertex::Body& lhs, const TissueForge::models::vertex::Body& rhs) { return lhs.objectId() < rhs.objectId(); }
    inline bool operator> (const TissueForge::models::vertex::Body& lhs, const TissueForge::models::vertex::Body& rhs) { return rhs < lhs; }
    inline bool operator<=(const TissueForge::models::vertex::Body& lhs, const TissueForge::models::vertex::Body& rhs) { return !(lhs > rhs); }
    inline bool operator>=(const TissueForge::models::vertex::Body& lhs, const TissueForge::models::vertex::Body& rhs) { return !(lhs < rhs); }
    inline bool operator==(const TissueForge::models::vertex::Body& lhs, const TissueForge::models::vertex::Body& rhs) { return lhs.objectId() == rhs.objectId(); }
    inline bool operator!=(const TissueForge::models::vertex::Body& lhs, const TissueForge::models::vertex::Body& rhs) { return !(lhs == rhs); }
 
    inline bool operator< (const TissueForge::models::vertex::BodyHandle& lhs, const TissueForge::models::vertex::BodyHandle& rhs) { return lhs.id < rhs.id; }
    inline bool operator> (const TissueForge::models::vertex::BodyHandle& lhs, const TissueForge::models::vertex::BodyHandle& rhs) { return rhs < lhs; }
    inline bool operator<=(const TissueForge::models::vertex::BodyHandle& lhs, const TissueForge::models::vertex::BodyHandle& rhs) { return !(lhs > rhs); }
    inline bool operator>=(const TissueForge::models::vertex::BodyHandle& lhs, const TissueForge::models::vertex::BodyHandle& rhs) { return !(lhs < rhs); }
    inline bool operator==(const TissueForge::models::vertex::BodyHandle& lhs, const TissueForge::models::vertex::BodyHandle& rhs) { return lhs.id == rhs.id; }
    inline bool operator!=(const TissueForge::models::vertex::BodyHandle& lhs, const TissueForge::models::vertex::BodyHandle& rhs) { return !(lhs == rhs); }
 
    inline bool operator< (const TissueForge::models::vertex::BodyType& lhs, const TissueForge::models::vertex::BodyType& rhs) { return lhs.id < rhs.id; }
    inline bool operator> (const TissueForge::models::vertex::BodyType& lhs, const TissueForge::models::vertex::BodyType& rhs) { return rhs < lhs; }
    inline bool operator<=(const TissueForge::models::vertex::BodyType& lhs, const TissueForge::models::vertex::BodyType& rhs) { return !(lhs > rhs); }
    inline bool operator>=(const TissueForge::models::vertex::BodyType& lhs, const TissueForge::models::vertex::BodyType& rhs) { return !(lhs < rhs); }
    inline bool operator==(const TissueForge::models::vertex::BodyType& lhs, const TissueForge::models::vertex::BodyType& rhs) { return lhs.id == rhs.id; }
    inline bool operator!=(const TissueForge::models::vertex::BodyType& lhs, const TissueForge::models::vertex::BodyType& rhs) { return !(lhs == rhs); }
 
}
 
 
inline std::ostream &operator<<(std::ostream& os, const TissueForge::models::vertex::Body &o)
{
    os << o.str().c_str();
    return os;
}
 
inline std::ostream &operator<<(std::ostream& os, const TissueForge::models::vertex::BodyType &o)
{
    os << o.str().c_str();
    return os;
}
 
namespace std {
 
    template <> 
    struct hash<TissueForge::models::vertex::BodyHandle> {
        size_t operator() (const TissueForge::models::vertex::BodyHandle& h) const {
            return hash<int>()(h.id);
        }
    };
}
 
#endif // _MODELS_VERTEX_SOLVER_TFBODY_H_