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_