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_