d8/d7d/tf_mesh_8h_source.html

/*******************************************************************************

 * 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_TFMESH_H_

#define _MODELS_VERTEX_SOLVER_TFMESH_H_


#define TFMESHINV_INCR 100


#include "tfVertex.h"

#include "tfSurface.h"

#include "tfBody.h"

#include "tfMeshQuality.h"


#include <mutex>

#include <set>

#include <vector>

#include <unordered_map>


namespace TissueForge::models::vertex {


    struct MeshRenderer;

    struct MeshSolver;


    class CAPI_EXPORT Mesh {


        std::vector<Vertex> *vertices;

        size_t nr_vertices;

        std::vector<Surface> *surfaces;

        size_t nr_surfaces;

        std::vector<Body> *bodies;

        size_t nr_bodies;


        std::set<unsigned int> vertexIdsAvail, surfaceIdsAvail, bodyIdsAvail;

        std::unordered_map<int, Vertex*> verticesByPID;

        bool isDirty;

        MeshSolver *_solver = NULL;

        MeshQuality *_quality;

        std::mutex meshLock;


        HRESULT incrementVertices(const size_t &numIncr=TFMESHINV_INCR);

        HRESULT incrementSurfaces(const size_t &numIncr=TFMESHINV_INCR);

        HRESULT incrementBodies(const size_t &numIncr=TFMESHINV_INCR);

        HRESULT allocateVertex(Vertex **obj);

        HRESULT allocateSurface(Surface **obj);

        HRESULT allocateBody(Body **obj);

        HRESULT allocateVertices(Vertex*** objs, const size_t& numObjs);

        HRESULT allocateSurfaces(Surface*** objs, const size_t& numObjs);

        HRESULT allocateBodies(Body*** objs, const size_t& numObjs);


    public:


        Mesh();


        ~Mesh();


        std::string str() const;


        std::string toString();


        bool hasQuality() const { return _quality; }


        TissueForge::models::vertex::MeshQuality &getQuality() const { return *_quality; }


        HRESULT setQuality(TissueForge::models::vertex::MeshQuality *quality);


        bool qualityWorking() const { return hasQuality() && getQuality().working(); }


        HRESULT ensureAvailableVertices(const size_t &numAlloc);


        HRESULT ensureAvailableSurfaces(const size_t &numAlloc);


        HRESULT ensureAvailableBodies(const size_t &numAlloc);


        HRESULT create(Vertex **obj, const unsigned int &pid);


        HRESULT create(Vertex*** objs, const std::vector<unsigned int>& pids);


        HRESULT create(Surface **obj);


        HRESULT create(Surface*** objs, const size_t& numObjs);


        HRESULT create(Body **obj);


        HRESULT create(Body*** objs, const size_t& numObjs);


        static Mesh *get();


        void lock() { this->meshLock.lock(); }


        void unlock() { this->meshLock.unlock(); }


        Vertex *findVertex(const FVector3 &pos, const FloatP_t &tol = 0.0001);


        Vertex *getVertexByPID(const unsigned int &pid) const;


        Vertex *getVertex(const unsigned int &idx);


        Surface *getSurface(const unsigned int &idx);


        Body *getBody(const unsigned int &idx);


        unsigned int numVertices() const { return nr_vertices; }


        unsigned int numSurfaces() const { return nr_surfaces; }


        unsigned int numBodies() const { return nr_bodies; }


        unsigned int sizeVertices() const { return vertices->size(); }


        unsigned int sizeSurfaces() const { return surfaces->size(); }


        unsigned int sizeBodies() const { return bodies->size(); }


        bool validate();


        HRESULT makeDirty();


        bool connected(const Vertex *v1, const Vertex *v2) const;


        bool connected(const Surface *s1, const Surface *s2) const;


        bool connected(const Body *b1, const Body *b2) const;


        HRESULT remove(Vertex *v);


        HRESULT remove(Vertex** v, const size_t& numObjs);


        HRESULT remove(Surface *s);


        HRESULT remove(Surface** s, const size_t& numObjs);


        HRESULT remove(Body *b);


        HRESULT remove(Body** b, const size_t& numObjs);


        bool is3D() const { return nr_bodies > 0; }


        friend MeshRenderer;

        friend MeshSolver;


    };


};


#endif // _MODELS_VERTEX_SOLVER_TFMESH_H_

TissueForge::models::vertex::Body
The mesh body is a volume-enclosing object of mesh surfaces.
Definition tfBody.h:59

TissueForge::models::vertex::Mesh::getVertexByPID
Vertex * getVertexByPID(const unsigned int &pid) const
Get the vertex for a given particle id.

TissueForge::models::vertex::Mesh::remove
HRESULT remove(Vertex **v, const size_t &numObjs)
Remove vertices from the mesh; all dependent surfaces and bodies are also removed.

TissueForge::models::vertex::Mesh::numBodies
unsigned int numBodies() const
Get the number of bodies.
Definition tfMesh.h:252

TissueForge::models::vertex::Mesh::getQuality
TissueForge::models::vertex::MeshQuality & getQuality() const
Get the mesh quality instance.
Definition tfMesh.h:104

TissueForge::models::vertex::Mesh::qualityWorking
bool qualityWorking() const
Test whether a mesh quality instance is working on the mesh.
Definition tfMesh.h:118

TissueForge::models::vertex::Mesh::remove
HRESULT remove(Surface *s)
Remove a surface from the mesh; all dependent bodies are also removed.

TissueForge::models::vertex::Mesh::ensureAvailableBodies
HRESULT ensureAvailableBodies(const size_t &numAlloc)
Ensure that there are a given number of allocated bodies.

TissueForge::models::vertex::Mesh::create
HRESULT create(Surface **obj)
Create a surface.

TissueForge::models::vertex::Mesh::connected
bool connected(const Surface *s1, const Surface *s2) const
Check whether two surfaces are connected.

TissueForge::models::vertex::Mesh::getSurface
Surface * getSurface(const unsigned int &idx)
Get the surface at a location in the list of surfaces.

TissueForge::models::vertex::Mesh::remove
HRESULT remove(Body **b, const size_t &numObjs)
Remove bodies from the mesh.

TissueForge::models::vertex::Mesh::create
HRESULT create(Vertex **obj, const unsigned int &pid)
Create a vertex.

TissueForge::models::vertex::Mesh::create
HRESULT create(Vertex ***objs, const std::vector< unsigned int > &pids)
Create vertices.

TissueForge::models::vertex::Mesh::is3D
bool is3D() const
Test whether the mesh is 3D.
Definition tfMesh.h:360

TissueForge::models::vertex::Mesh::sizeSurfaces
unsigned int sizeSurfaces() const
Get the size of the list of surfaces.
Definition tfMesh.h:262

TissueForge::models::vertex::Mesh::getVertex
Vertex * getVertex(const unsigned int &idx)
Get the vertex at a location in the list of vertices.

TissueForge::models::vertex::Mesh::remove
HRESULT remove(Body *b)
Remove a body from the mesh.

TissueForge::models::vertex::Mesh::connected
bool connected(const Vertex *v1, const Vertex *v2) const
Check whether two vertices are connected.

TissueForge::models::vertex::Mesh::remove
HRESULT remove(Vertex *v)
Remove a vertex from the mesh; all dependent surfaces and bodies are also removed.

TissueForge::models::vertex::Mesh::toString
std::string toString()
Get a JSON string representation.

TissueForge::models::vertex::Mesh::get
static Mesh * get()
Get the mesh.

TissueForge::models::vertex::Mesh::sizeBodies
unsigned int sizeBodies() const
Get the size of the list of bodies.
Definition tfMesh.h:267

TissueForge::models::vertex::Mesh::validate
bool validate()
Validate state of the mesh.

TissueForge::models::vertex::Mesh::makeDirty
HRESULT makeDirty()
Manually notify that the mesh has been changed.

TissueForge::models::vertex::Mesh::findVertex
Vertex * findVertex(const FVector3 &pos, const FloatP_t &tol=0.0001)
Find a vertex in this mesh.

TissueForge::models::vertex::Mesh::unlock
void unlock()
Unlocks the mesh for thread-safe operations.
Definition tfMesh.h:200

TissueForge::models::vertex::Mesh::sizeVertices
unsigned int sizeVertices() const
Get the size of the list of vertices.
Definition tfMesh.h:257

TissueForge::models::vertex::Mesh::create
HRESULT create(Body **obj)
Create a body.

TissueForge::models::vertex::Mesh::getBody
Body * getBody(const unsigned int &idx)
Get the body at a location in the list of bodies.

TissueForge::models::vertex::Mesh::create
HRESULT create(Body ***objs, const size_t &numObjs)
Create bodies.

TissueForge::models::vertex::Mesh::create
HRESULT create(Surface ***objs, const size_t &numObjs)
Create surfaces.

TissueForge::models::vertex::Mesh::connected
bool connected(const Body *b1, const Body *b2) const
Check whether two bodies are connected.

TissueForge::models::vertex::Mesh::hasQuality
bool hasQuality() const
Test whether this mesh has a mesh quality instance.
Definition tfMesh.h:99

TissueForge::models::vertex::Mesh::lock
void lock()
Locks the mesh for thread-safe operations.
Definition tfMesh.h:195

TissueForge::models::vertex::Mesh::ensureAvailableSurfaces
HRESULT ensureAvailableSurfaces(const size_t &numAlloc)
Ensure that there are a given number of allocated surfaces.

TissueForge::models::vertex::Mesh::ensureAvailableVertices
HRESULT ensureAvailableVertices(const size_t &numAlloc)
Ensure that there are a given number of allocated vertices.

TissueForge::models::vertex::Mesh::numSurfaces
unsigned int numSurfaces() const
Get the number of surfaces.
Definition tfMesh.h:247

TissueForge::models::vertex::Mesh::remove
HRESULT remove(Surface **s, const size_t &numObjs)
Remove surfaces from the mesh; all dependent bodies are also removed.

TissueForge::models::vertex::Mesh::str
std::string str() const
Get a summary string.

TissueForge::models::vertex::Mesh::numVertices
unsigned int numVertices() const
Get the number of vertices.
Definition tfMesh.h:242

TissueForge::models::vertex::Mesh::setQuality
HRESULT setQuality(TissueForge::models::vertex::MeshQuality *quality)
Set the mesh quality instance.

TissueForge::models::vertex::MeshQuality
An object that schedules topological operations on a mesh to maintain its quality.
Definition tfMeshQuality.h:205

TissueForge::models::vertex::Surface
The mesh surface is an area-enclosed object of implicit mesh edges defined by mesh vertices.
Definition tfSurface.h:65

TissueForge::models::vertex::Vertex
The mesh vertex is a volume of a mesh centered at a point in a space.
Definition tfVertex.h:71

TissueForge::models::vertex::MeshRenderer
Definition tfMeshRenderer.h:35

TissueForge::models::vertex::MeshSolver
Vertex model mesh solver.
Definition tfMeshSolver.h:148

HRESULT
int32_t HRESULT
Definition tf_port.h:255

tfBody.h

tfMeshQuality.h

tfSurface.h

tfVertex.h