tfMeshQuality.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_TFMESHQUALITY_H_
#define _MODELS_VERTEX_SOLVER_TFMESHQUALITY_H_
 
 
#include "tfMeshObj.h"
 
#include <tf_port.h>
 
#include <mutex>
#include <set>
#include <unordered_set>
#include <vector>
 
 
namespace TissueForge::models::vertex {
 
 
    class Mesh;
 
 
    struct MeshQualityOperation {
 
        enum Flag : unsigned int {
            None    = 0, 
            Active  = 1 << 0, 
            Custom  = 1 << 1
        };
 
        unsigned int flags;
 
        std::vector<int> targets;
 
        std::set<MeshQualityOperation*> prev;
 
        std::set<MeshQualityOperation*> next;
 
        std::mutex lock;
 
        MeshQualityOperation(Mesh *_mesh);
 
        virtual ~MeshQualityOperation() {};
 
        HRESULT appendNext(MeshQualityOperation *_next);
 
        HRESULT removeNext(MeshQualityOperation *_next);
 
        std::set<MeshQualityOperation*> upstreams() const;
 
        std::set<MeshQualityOperation*> downstreams() const;
 
        std::set<MeshQualityOperation*> headOperations() const;
 
        virtual HRESULT validate() { return S_OK; }
 
        virtual bool check() { return !(flags & Flag::None); };
 
        virtual void prep() {}
 
        virtual size_t numNewVertices() const { return 0; };
 
        virtual size_t numNewSurfaces() const { return 0; };
 
        virtual size_t numNewBodies() const { return 0; };
 
        virtual std::vector<int> implement() { return {}; }
 
    protected:
 
        Mesh *mesh;
    };
 
 
    struct CAPI_EXPORT CustomQualityOperation : MeshQualityOperation {
 
        typedef bool (*OperationCheck)();
        typedef void (*OperationPrep)();
        typedef std::vector<int> (*OperationFunction)(std::vector<int>);
 
        OperationCheck *opCheck;
        OperationPrep *opPrep;
        OperationFunction *opFunc;
 
        CustomQualityOperation(Mesh *_mesh, OperationFunction *_opFunc, OperationCheck *_opCheck=NULL, OperationPrep *_opPrep=NULL) : 
            MeshQualityOperation(_mesh), 
            opFunc{_opFunc}, 
            opCheck{_opCheck}, 
            opPrep{_opPrep}
        {
            flags = Flag::Active | Flag::Custom;
        };
 
        virtual ~CustomQualityOperation() {
            if(opCheck) {
                delete opCheck;
                opCheck = 0;
            }
            delete opFunc;
            opFunc = 0;
        };
 
        bool check() override {
            if(opCheck) return (*opCheck)();
            return true;
        }
 
        void prep() override {
            if(opPrep) (*opPrep)();
        }
 
        std::vector<int> implement() override { return (*opFunc)(targets); }
    };
 
 
    class CAPI_EXPORT MeshQuality {
 
        FloatP_t vertexMergeDist;
 
        FloatP_t surfaceDemoteArea;
 
        FloatP_t bodyDemoteVolume;
 
        FloatP_t edgeSplitDist;
 
        bool collision2D;
 
        bool _working;
 
        std::unordered_set<unsigned int> excludedVertices;
 
        std::unordered_set<unsigned int> excludedSurfaces;
 
        std::unordered_set<unsigned int> excludedBodies;
 
    public:
 
        MeshQuality(
            const FloatP_t &vertexMergeDistCf=0.0001, 
            const FloatP_t &surfaceDemoteAreaCf=0.0001, 
            const FloatP_t &bodyDemoteVolumeCf=0.0001, 
            const FloatP_t &_edgeSplitDistCf=2.0
        );
 
        std::string str() const;
 
        std::string toString();
 
        static MeshQuality fromString(const std::string &s);
 
        HRESULT doQuality();
 
        const bool working() const { return _working; }
 
        FloatP_t getVertexMergeDistance() const { return vertexMergeDist; };
 
        HRESULT setVertexMergeDistance(const FloatP_t &_val);
 
        FloatP_t getSurfaceDemoteArea() const { return surfaceDemoteArea; };
 
        HRESULT setSurfaceDemoteArea(const FloatP_t &_val);
 
        FloatP_t getBodyDemoteVolume() const { return bodyDemoteVolume; }
 
        HRESULT setBodyDemoteVolume(const FloatP_t &_val);
 
        FloatP_t getEdgeSplitDist() const { return edgeSplitDist; };
 
        HRESULT setEdgeSplitDist(const FloatP_t &_val);
 
        bool getCollision2D() const { return collision2D; }
 
        HRESULT setCollision2D(const bool &_collision2D);
 
        HRESULT excludeVertex(const unsigned int &id);
 
        HRESULT excludeSurface(const unsigned int &id);
 
        HRESULT excludeBody(const unsigned int &id);
 
        HRESULT includeVertex(const unsigned int &id);
 
        HRESULT includeSurface(const unsigned int &id);
 
        HRESULT includeBody(const unsigned int &id);
 
        std::unordered_set<unsigned int> getExcludedVertices() const { return excludedVertices; }
 
        std::unordered_set<unsigned int> getExcludedSurfaces() const { return excludedSurfaces; }
 
        std::unordered_set<unsigned int> getExcludedBodies() const { return excludedBodies; }
    };
}
 
 
#endif // _MODELS_VERTEX_SOLVER_TFMESHQUALITY_H_