tfSurface.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_TFSURFACE_H_
#define _MODELS_VERTEX_SOLVER_TFSURFACE_H_
 
#include <tf_port.h>
 
#include <state/tfStateVector.h>
#include <rendering/tfStyle.h>
 
#include "tf_mesh.h"
 
#include <io/tfThreeDFFaceData.h>
 
#include <tuple>
 
 
namespace TissueForge::models::vertex { 
 
 
    class Vertex;
    struct VertexHandle;
    class Body;
    struct BodyHandle;
    class Mesh;
 
    struct SurfaceHandle;
    struct SurfaceType;
    struct BodyType;
 
 
    class CAPI_EXPORT Surface {
 
        int _objId;
 
    public:
 
        int typeId;
 
    private:
 
        Body *b1;
        
        Body *b2;
 
        std::vector<Vertex*> vertices;
 
        FVector3 normal;
 
        FVector3 centroid;
 
        FVector3 velocity;
 
        FloatP_t area;
 
        FloatP_t perimeter;
 
        FloatP_t _volumeContr;
 
        FloatP_t density;
 
    public:
 
        std::vector<MeshObjActor*> actors;
 
        state::StateVector *species1;
 
        state::StateVector *species2;
 
        rendering::Style *style;
 
        Surface();
        ~Surface();
 
        static SurfaceHandle create(const std::vector<VertexHandle> &_vertices);
 
        static SurfaceHandle create(TissueForge::io::ThreeDFFaceData *face);
 
        static std::vector<SurfaceHandle> create(const std::vector<std::vector<VertexHandle> > &_vertices);
 
        static std::vector<SurfaceHandle> create(const std::vector<TissueForge::io::ThreeDFFaceData*> &_faces);
 
        MESHBOJ_DEFINES_DECL(Body);
        MESHOBJ_DEFINEDBY_DECL(Vertex);
        MESHOBJ_CLASSDEF(MeshObjTypeLabel::SURFACE)
 
        
        std::string str() const;
 
        std::string toString();
 
        HRESULT add(Vertex *v);
 
        HRESULT insert(Vertex *v, const int &idx);
 
        HRESULT insert(Vertex *v, Vertex *before);
 
        HRESULT insert(Vertex *toInsert, Vertex *v1, Vertex *v2);
 
        HRESULT remove(Vertex *v);
 
        HRESULT replace(Vertex *toInsert, const int &idx);
 
        HRESULT replace(Vertex *toInsert, Vertex *toRemove);
 
        HRESULT add(Body *b);
 
        HRESULT remove(Body *b);
 
        HRESULT replace(Body *toInsert, const int &idx);
 
        HRESULT replace(Body *toInsert, Body *toRemove);
 
        static HRESULT destroy(Surface *target);
 
        static HRESULT destroy(SurfaceHandle &target);
 
        static HRESULT destroy(const std::vector<Surface*>& target);
 
        HRESULT refreshBodies();
 
        SurfaceType *type() const;
 
        HRESULT become(SurfaceType *stype);
 
        std::vector<Body*> getBodies() const;
 
        const std::vector<Vertex*>& getVertices() const { return vertices; }
 
        Vertex *findVertex(const FVector3 &dir) const;
 
        Body *findBody(const FVector3 &dir) const;
 
        std::tuple<Vertex*, Vertex*> neighborVertices(const Vertex *v) const;
 
        std::vector<Surface*> neighborSurfaces() const;
 
        std::vector<Surface*> connectedSurfaces(const std::vector<Vertex*> &verts) const;
 
        std::vector<Surface*> connectedSurfaces() const;
 
        std::vector<Vertex*> connectingVertices(const Surface *other) const;
 
        std::vector<unsigned int> contiguousVertexLabels(const Surface *other) const;
 
        unsigned int numSharedContiguousVertexSets(const Surface *other) const;
 
        std::vector<Vertex*> sharedContiguousVertices(const Surface *other, const unsigned int &edgeLabel) const;
 
        FVector3 getNormal() const;
 
        const FVector3& getUnnormalizedNormal() const { return normal; }
 
        const FVector3& getCentroid() const { return centroid; }
 
        const FVector3& getVelocity() const { return velocity; }
 
        const FloatP_t& getArea() const { return area; }
 
        const FloatP_t& getPerimeter() const { return perimeter; }
 
        const FloatP_t& getDensity() const { return density; }
 
        void setDensity(const FloatP_t &_density) { density = _density; }
 
        FloatP_t getMass() const { return area * density; }
 
        FloatP_t volumeSense(const Body *body) const;
 
        FloatP_t getVolumeContr(const Body *body) const { return _volumeContr * volumeSense(body); }
 
        FVector3 getOutwardNormal(const Body *body) const;
 
        FloatP_t getVertexArea(const Vertex *v) const;
 
        FloatP_t getVertexMass(const Vertex *v) const { return getVertexArea(v) * density; }
 
        FVector3 triangleNormal(const unsigned int &idx) const;
 
        FloatP_t normalDistance(const FVector3 &pos) const;
 
        bool isOutside(const FVector3 &pos) const;
 
        bool contains(const FVector3 &pos, Vertex **v0, Vertex **v1) const;
 
        bool contains(const FVector3 &pos) const;
 
        static bool testSew(Surface* s1, Surface* s2, const FloatP_t& distCf, std::vector<int>& indicesMatched);
 
        static HRESULT sew(Surface *s1, Surface *s2, const FloatP_t &distCf=0.01);
 
        static HRESULT sew(const SurfaceHandle &s1, const SurfaceHandle &s2, const FloatP_t &distCf=0.01);
 
        static HRESULT sew(const std::vector<Surface*>& _surfaces, const FloatP_t &distCf=0.01);
 
        static HRESULT sew(const std::vector<SurfaceHandle>& _surfaces, const FloatP_t &distCf=0.01);
 
        HRESULT merge(Surface *toRemove, const std::vector<FloatP_t> &lenCfs);
 
        Surface *extend(const unsigned int &vertIdxStart, const FVector3 &pos);
 
        Surface *extrude(const unsigned int &vertIdxStart, const FloatP_t &normLen);
 
        Surface *split(Vertex *v1, Vertex *v2);
 
        Surface *split(const FVector3 &cp_pos, const FVector3 &cp_norm);
 
 
        friend SurfaceHandle;
        friend Vertex;
        friend Body;
        friend BodyType;
        friend Mesh;
 
    };
 
 
    struct CAPI_EXPORT SurfaceHandle {
 
        int id;
 
        SurfaceHandle(const int &_id=-1);
 
        Surface *surface() const;
 
        bool defines(const BodyHandle &b) const;
 
        bool definedBy(const VertexHandle &v) const;
 
        MeshObjTypeLabel objType() const { return MeshObjTypeLabel::SURFACE; }
 
        HRESULT destroy();
 
        bool validate();
 
        HRESULT positionChanged();
 
        std::string str() const;
 
        std::string toString();
 
        static SurfaceHandle fromString(const std::string &s);
 
        HRESULT add(const VertexHandle &v);
 
        HRESULT insert(const VertexHandle &v, const int &idx);
 
        HRESULT insert(const VertexHandle &v, const VertexHandle &before);
 
        HRESULT insert(const VertexHandle &toInsert, const VertexHandle &v1, const VertexHandle &v2);
 
        HRESULT remove(const VertexHandle &v);
 
        HRESULT replace(const VertexHandle &toInsert, const int &idx);
 
        HRESULT replace(const VertexHandle &toInsert, const VertexHandle &toRemove);
 
        HRESULT add(const BodyHandle &b);
 
        HRESULT remove(const BodyHandle &b);
 
        HRESULT replace(const BodyHandle &toInsert, const int &idx);
 
        HRESULT replace(const BodyHandle &toInsert, const BodyHandle &toRemove);
 
        HRESULT refreshBodies();
 
        SurfaceType *type() const;
 
        HRESULT become(SurfaceType *stype);
 
        std::vector<BodyHandle> getBodies() const;
 
        std::vector<VertexHandle> getVertices() const;
 
        VertexHandle findVertex(const FVector3 &dir) const;
 
        BodyHandle findBody(const FVector3 &dir) const;
 
        std::tuple<VertexHandle, VertexHandle> neighborVertices(const VertexHandle &v) const;
 
        std::vector<SurfaceHandle> neighborSurfaces() const;
 
        std::vector<SurfaceHandle> connectedSurfaces(const std::vector<VertexHandle> &verts) const;
 
        std::vector<SurfaceHandle> connectedSurfaces() const;
 
        std::vector<VertexHandle> connectingVertices(const SurfaceHandle &other) const;
 
        std::vector<unsigned int> contiguousVertexLabels(const SurfaceHandle &other) const;
 
        unsigned int numSharedContiguousVertexSets(const SurfaceHandle &other) const;
 
        std::vector<VertexHandle> sharedContiguousVertices(const SurfaceHandle &other, const unsigned int &edgeLabel) const;
 
        FVector3 getNormal() const;
 
        FVector3 getUnnormalizedNormal() const;
 
        FVector3 getCentroid() const;
 
        FVector3 getVelocity() const;
 
        FloatP_t getArea() const;
 
        FloatP_t getPerimeter() const;
 
        FloatP_t getDensity() const;
 
        void setDensity(const FloatP_t &_density) const;
 
        FloatP_t getMass() const;
 
        FloatP_t volumeSense(const BodyHandle &body) const;
 
        FloatP_t getVolumeContr(const BodyHandle &body) const;
 
        FVector3 getOutwardNormal(const BodyHandle &body) const;
 
        FloatP_t getVertexArea(const VertexHandle &v) const;
 
        FloatP_t getVertexMass(const VertexHandle &v) const;
 
        state::StateVector *getSpeciesOutward() const;
 
        HRESULT setSpeciesOutward(state::StateVector *s) const;
 
        state::StateVector *getSpeciesInward() const;
 
        HRESULT setSpeciesInward(state::StateVector *s) const;
 
        rendering::Style *getStyle() const;
 
        HRESULT setStyle(rendering::Style *s) const;
 
        FVector3 triangleNormal(const unsigned int &idx) const;
 
        FloatP_t normalDistance(const FVector3 &pos) const;
 
        bool isOutside(const FVector3 &pos) const;
 
        bool contains(const FVector3 &pos, VertexHandle &v0, VertexHandle &v1) const;
 
        bool contains(const FVector3 &pos) const;
 
        HRESULT merge(SurfaceHandle &toRemove, const std::vector<FloatP_t> &lenCfs);
 
        SurfaceHandle extend(const unsigned int &vertIdxStart, const FVector3 &pos);
 
        SurfaceHandle extrude(const unsigned int &vertIdxStart, const FloatP_t &normLen);
 
        SurfaceHandle split(const VertexHandle &v1, const VertexHandle &v2);
 
        SurfaceHandle split(const FVector3 &cp_pos, const FVector3 &cp_norm);
 
        operator bool() const { return id >= 0; }
    };
 
 
    struct CAPI_EXPORT SurfaceType : MeshObjType {
 
        std::string name;
 
        rendering::Style *style;
 
        FloatP_t density;
 
        SurfaceType(const FloatP_t &flatLam, const FloatP_t &convexLam, const bool &noReg=false);
 
        SurfaceType(const bool &noReg=false) : SurfaceType(0.1, 0.1, noReg) {};
 
        MeshObjTypeLabel objType() const override { return MeshObjTypeLabel::SURFACE; }
 
        virtual std::string str() const override;
 
        std::string toString();
 
        static SurfaceType *fromString(const std::string &str);
 
        static SurfaceType *findFromName(const std::string &_name);
 
        virtual HRESULT registerType();
 
        virtual void on_register() {}
 
        bool isRegistered();
 
        virtual SurfaceType *get();
 
        HRESULT add(const SurfaceHandle &i);
 
        HRESULT add(const std::vector<SurfaceHandle>& i);
 
        HRESULT remove(const SurfaceHandle &i);
 
        HRESULT remove(const std::vector<SurfaceHandle>& i);
 
        std::vector<SurfaceHandle> getInstances();
 
        std::vector<int> getInstanceIds() { return _instanceIds; }
 
        unsigned int getNumInstances();
 
        SurfaceHandle operator() (const std::vector<VertexHandle> &_vertices);
 
        SurfaceHandle operator() (const std::vector<FVector3> &_positions);
 
        SurfaceHandle operator() (TissueForge::io::ThreeDFFaceData *face);
 
        std::vector<SurfaceHandle> operator() (const std::vector<std::vector<VertexHandle> >& _vertices);
 
        std::vector<SurfaceHandle> operator() (const std::vector<std::vector<FVector3> > &_positions);
 
        std::vector<SurfaceHandle> operator() (const std::vector<TissueForge::io::ThreeDFFaceData*>& faces, const bool& safe=true);
 
        SurfaceHandle nPolygon(const unsigned int &n, const FVector3 &center, const FloatP_t &radius, const FVector3 &ax1, const FVector3 &ax2);
 
        SurfaceHandle replace(VertexHandle &toReplace, std::vector<FloatP_t> lenCfs);
 
    private:
 
        std::vector<int> _instanceIds;
 
    };
 
    inline bool operator< (const TissueForge::models::vertex::Surface& lhs, const TissueForge::models::vertex::Surface& rhs) { return lhs.objectId() < rhs.objectId(); }
    inline bool operator> (const TissueForge::models::vertex::Surface& lhs, const TissueForge::models::vertex::Surface& rhs) { return rhs < lhs; }
    inline bool operator<=(const TissueForge::models::vertex::Surface& lhs, const TissueForge::models::vertex::Surface& rhs) { return !(lhs > rhs); }
    inline bool operator>=(const TissueForge::models::vertex::Surface& lhs, const TissueForge::models::vertex::Surface& rhs) { return !(lhs < rhs); }
    inline bool operator==(const TissueForge::models::vertex::Surface& lhs, const TissueForge::models::vertex::Surface& rhs) { return lhs.objectId() == rhs.objectId(); }
    inline bool operator!=(const TissueForge::models::vertex::Surface& lhs, const TissueForge::models::vertex::Surface& rhs) { return !(lhs == rhs); }
 
    inline bool operator< (const TissueForge::models::vertex::SurfaceHandle& lhs, const TissueForge::models::vertex::SurfaceHandle& rhs) { return lhs.id < rhs.id; }
    inline bool operator> (const TissueForge::models::vertex::SurfaceHandle& lhs, const TissueForge::models::vertex::SurfaceHandle& rhs) { return rhs < lhs; }
    inline bool operator<=(const TissueForge::models::vertex::SurfaceHandle& lhs, const TissueForge::models::vertex::SurfaceHandle& rhs) { return !(lhs > rhs); }
    inline bool operator>=(const TissueForge::models::vertex::SurfaceHandle& lhs, const TissueForge::models::vertex::SurfaceHandle& rhs) { return !(lhs < rhs); }
    inline bool operator==(const TissueForge::models::vertex::SurfaceHandle& lhs, const TissueForge::models::vertex::SurfaceHandle& rhs) { return lhs.id == rhs.id; }
    inline bool operator!=(const TissueForge::models::vertex::SurfaceHandle& lhs, const TissueForge::models::vertex::SurfaceHandle& rhs) { return !(lhs == rhs); }
 
    inline bool operator< (const TissueForge::models::vertex::SurfaceType& lhs, const TissueForge::models::vertex::SurfaceType& rhs) { return lhs.id < rhs.id; }
    inline bool operator> (const TissueForge::models::vertex::SurfaceType& lhs, const TissueForge::models::vertex::SurfaceType& rhs) { return rhs < lhs; }
    inline bool operator<=(const TissueForge::models::vertex::SurfaceType& lhs, const TissueForge::models::vertex::SurfaceType& rhs) { return !(lhs > rhs); }
    inline bool operator>=(const TissueForge::models::vertex::SurfaceType& lhs, const TissueForge::models::vertex::SurfaceType& rhs) { return !(lhs < rhs); }
    inline bool operator==(const TissueForge::models::vertex::SurfaceType& lhs, const TissueForge::models::vertex::SurfaceType& rhs) { return lhs.id == rhs.id; }
    inline bool operator!=(const TissueForge::models::vertex::SurfaceType& lhs, const TissueForge::models::vertex::SurfaceType& rhs) { return !(lhs == rhs); }
 
}
 
 
inline std::ostream &operator<<(std::ostream& os, const TissueForge::models::vertex::Surface &o)
{
    os << o.str().c_str();
    return os;
}
 
inline std::ostream &operator<<(std::ostream& os, const TissueForge::models::vertex::SurfaceType &o)
{
    os << o.str().c_str();
    return os;
}
 
namespace std {
 
    template <> 
    struct hash<TissueForge::models::vertex::SurfaceHandle> {
        size_t operator() (const TissueForge::models::vertex::SurfaceHandle& h) const {
            return hash<int>()(h.id);
        }
    };
}
 
#endif // _MODELS_VERTEX_SOLVER_TFSURFACE_H_