tfVertex.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_TFVERTEX_H_
#define _MODELS_VERTEX_SOLVER_TFVERTEX_H_
 
#include <tf_port.h>
 
#include <tfParticle.h>
#include <rendering/tfStyle.h>
 
#include "tfMeshObj.h"
#include "tfMesh.h"
 
#include <io/tfThreeDFVertexData.h>
 
#include <vector>
 
 
namespace TissueForge::models::vertex { 
 
 
    class Surface;
    struct SurfaceHandle;
    class Body;
    struct BodyHandle;
    class Mesh;
 
    struct VertexHandle;
 
 
    struct CAPI_EXPORT MeshParticleType : ParticleType { 
 
        MeshParticleType() : ParticleType(true) {
            std::memcpy(this->name, "MeshParticleType", sizeof("MeshParticleType"));
            style->setVisible(false);
            dynamics = PARTICLE_OVERDAMPED;
            registerType();
        };
 
    };
 
    CAPI_FUNC(MeshParticleType*) MeshParticleType_get();
 

    class CAPI_EXPORT Vertex {

        int _objId;

        int pid;

        std::vector<Surface*> surfaces;

        FloatP_t _particleMass;

        FVector3 _particlePosition;

        FVector3 _particleVelocity;

        std::vector<Vertex*> _connectedVertices;
 
    public:
 
        Vertex();
        ~Vertex();

        static VertexHandle create(const unsigned int &_pid);

        static VertexHandle create(const FVector3 &position);

        static VertexHandle create(TissueForge::io::ThreeDFVertexData *vdata);

        static std::vector<VertexHandle> create(const std::vector<unsigned int>& _pids);

        static std::vector<VertexHandle> create(const std::vector<FVector3>& positions);

        static std::vector<VertexHandle> create(const std::vector<TissueForge::io::ThreeDFVertexData*>& vdata);
 
        MESHBOJ_DEFINES_DECL(Surface);
        MESHBOJ_DEFINES_DECL(Body);
        MESHOBJ_CLASSDEF(MeshObjTypeLabel::VERTEX)
 
        
        std::string str() const;

        std::string toString();

        HRESULT add(Surface *s);

        HRESULT insert(Surface *s, const int &idx);

        HRESULT insert(Surface *s, Surface *before);

        HRESULT remove(Surface *s);

        HRESULT replace(Surface *toInsert, const int &idx);

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

        static HRESULT destroy(const std::vector<Vertex*>& toDestroy);

        const int getPartId() const { return pid; }

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

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

        Surface *findSurface(const FVector3 &dir) const;

        Body *findBody(const FVector3 &dir) const;

        void updateConnectedVertices();

        const std::vector<Vertex*>& connectedVertices() const { return _connectedVertices; }

        std::vector<Surface*> sharedSurfaces(const Vertex *other) const;

        FloatP_t getArea() const;

        FloatP_t getVolume() const;

        FloatP_t getMass() const;

        HRESULT updateProperties();

        ParticleHandle *particle() const;

        const FVector3& getPosition() const { return _particlePosition; }

        HRESULT setPosition(const FVector3 &pos, const bool &updateChildren=true);

        const FVector3& getVelocity() const { return _particleVelocity; }

        const FloatP_t& getCachedParticleMass() const { return _particleMass; }

        HRESULT transferBondsTo(Vertex *other);

        static HRESULT transferBondsTo(const std::vector<std::pair<Vertex*, Vertex*> >& targets);

        HRESULT replace(Surface *toReplace);

        static Vertex *replace(const FVector3 &position, Surface *toReplace);

        static VertexHandle replace(const FVector3 &position, SurfaceHandle &toReplace);

        HRESULT replace(Body *toReplace);

        static Vertex *replace(const FVector3 &position, Body *toReplace);

        static VertexHandle replace(const FVector3 &position, BodyHandle &toReplace);

        HRESULT merge(Vertex *toRemove, const FloatP_t &lenCf=0.5f);

        static HRESULT merge(const std::vector<std::vector<Vertex*> >& toMerge, const FloatP_t &lenCf=0.5f);

        HRESULT insert(Vertex *v1, Vertex *v2);

        static Vertex *insert(const FVector3 &position, Vertex *v1, Vertex *v2);

        static VertexHandle insert(const FVector3 &position, const VertexHandle &v1, const VertexHandle &v2);

        HRESULT insert(Vertex *vf, std::vector<Vertex*> nbs);

        static Vertex *insert(const FVector3 &position, Vertex *vf, std::vector<Vertex*> nbs);

        static VertexHandle insert(const FVector3 &position, const VertexHandle &vf, const std::vector<VertexHandle> &nbs);

        HRESULT splitPlan(const FVector3 &sep, std::vector<Vertex*> &verts_v, std::vector<Vertex*> &verts_new_v);

        Vertex *splitExecute(const FVector3 &sep, const std::vector<Vertex*> &verts_v, const std::vector<Vertex*> &verts_new_v);

        Vertex *split(const FVector3 &sep);
 
 
        friend VertexHandle;
        friend Surface;
        friend Body;
        friend Mesh;
 
    };
 

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

        Vertex *vertex() const;

        bool defines(const SurfaceHandle &s) const;

        bool defines(const BodyHandle &b) const;

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

        HRESULT destroy();

        bool validate();

        HRESULT positionChanged();

        std::string str() const;

        std::string toString() const;

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

        HRESULT add(const SurfaceHandle &s) const;

        HRESULT insert(const SurfaceHandle &s, const int &idx) const;

        HRESULT insert(const SurfaceHandle &s, const SurfaceHandle &before) const;

        HRESULT remove(const SurfaceHandle &s) const;

        HRESULT replace(const SurfaceHandle &toInsert, const int &idx) const;

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

        const int getPartId() const;

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

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

        SurfaceHandle findSurface(const FVector3 &dir) const;

        BodyHandle findBody(const FVector3 &dir) const;

        void updateConnectedVertices() const;

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

        std::vector<SurfaceHandle> sharedSurfaces(const VertexHandle &other) const;

        FloatP_t getArea() const;

        FloatP_t getVolume() const;

        FloatP_t getMass() const;

        HRESULT updateProperties() const;

        ParticleHandle *particle() const;

        FVector3 getPosition() const;

        HRESULT setPosition(const FVector3 &pos, const bool &updateChildren=true);

        FVector3 getVelocity() const;

        HRESULT transferBondsTo(const VertexHandle &other) const;

        HRESULT replace(SurfaceHandle &toReplace) const;

        HRESULT replace(BodyHandle &toReplace);

        HRESULT merge(VertexHandle &toRemove, const FloatP_t &lenCf=0.5f);

        HRESULT insert(const VertexHandle &v1, const VertexHandle &v2);

        HRESULT insert(const VertexHandle &vf, const std::vector<VertexHandle> &nbs);

        HRESULT splitPlan(const FVector3 &sep, const std::vector<VertexHandle> &verts_v, const std::vector<VertexHandle> &verts_new_v);

        VertexHandle splitExecute(const FVector3 &sep, const std::vector<VertexHandle> &verts_v, const std::vector<VertexHandle> &verts_new_v);

        VertexHandle split(const FVector3 &sep);
 
        operator bool() const { return id >= 0; }
    };
 
 
    inline bool operator< (const TissueForge::models::vertex::Vertex& lhs, const TissueForge::models::vertex::Vertex& rhs) { return lhs.objectId() < rhs.objectId(); }
    inline bool operator> (const TissueForge::models::vertex::Vertex& lhs, const TissueForge::models::vertex::Vertex& rhs) { return rhs < lhs; }
    inline bool operator<=(const TissueForge::models::vertex::Vertex& lhs, const TissueForge::models::vertex::Vertex& rhs) { return !(lhs > rhs); }
    inline bool operator>=(const TissueForge::models::vertex::Vertex& lhs, const TissueForge::models::vertex::Vertex& rhs) { return !(lhs < rhs); }
    inline bool operator==(const TissueForge::models::vertex::Vertex& lhs, const TissueForge::models::vertex::Vertex& rhs) { return lhs.objectId() == rhs.objectId(); }
    inline bool operator!=(const TissueForge::models::vertex::Vertex& lhs, const TissueForge::models::vertex::Vertex& rhs) { return !(lhs == rhs); }
 
    inline bool operator< (const TissueForge::models::vertex::VertexHandle& lhs, const TissueForge::models::vertex::VertexHandle& rhs) { return lhs.id < rhs.id; }
    inline bool operator> (const TissueForge::models::vertex::VertexHandle& lhs, const TissueForge::models::vertex::VertexHandle& rhs) { return rhs < lhs; }
    inline bool operator<=(const TissueForge::models::vertex::VertexHandle& lhs, const TissueForge::models::vertex::VertexHandle& rhs) { return !(lhs > rhs); }
    inline bool operator>=(const TissueForge::models::vertex::VertexHandle& lhs, const TissueForge::models::vertex::VertexHandle& rhs) { return !(lhs < rhs); }
    inline bool operator==(const TissueForge::models::vertex::VertexHandle& lhs, const TissueForge::models::vertex::VertexHandle& rhs) { return lhs.id == rhs.id; }
    inline bool operator!=(const TissueForge::models::vertex::VertexHandle& lhs, const TissueForge::models::vertex::VertexHandle& rhs) { return !(lhs == rhs); }
 
}
 
 
inline std::ostream &operator<<(std::ostream& os, const TissueForge::models::vertex::Vertex &o)
{
    os << o.str().c_str();
    return os;
}
 
namespace std {
 
    template <> 
    struct hash<TissueForge::models::vertex::VertexHandle> {
        size_t operator() (const TissueForge::models::vertex::VertexHandle& h) const {
            return hash<int>()(h.id);
        }
    };
}
 
#endif // _MODELS_VERTEX_SOLVER_TFVERTEX_H_