egs_triangle_mesh.h

Go to the documentation of this file.

/*
###############################################################################
#
#  EGSnrc egs++ triangle mesh geometry library headers.
#  Copyright (C) 2022 Max Orok
#
#  This file is part of EGSnrc.
#
#  EGSnrc is free software: you can redistribute it and/or modify it under
#  the terms of the GNU Affero General Public License as published by the
#  Free Software Foundation, either version 3 of the License, or (at your
#  option) any later version.
#
#  EGSnrc 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 Affero General Public License for
#  more details.
#
#  You should have received a copy of the GNU Affero General Public License
#  along with EGSnrc. If not, see <http://www.gnu.org/licenses/>.
#
###############################################################################
#
#  Author:          Max Orok, 2022
#
#  Contributors:    Alexandre Demelo
#
###############################################################################
*/
 
 
#ifndef EGS_TRIANGLE_MESH
#define EGS_TRIANGLE_MESH
 
#include "egs_base_geometry.h"
#include "egs_vector.h"
 
#include <array>
#include <memory>
#include <string>
#include <vector>
#include <fstream>
 
#ifdef WIN32
 
    #ifdef BUILD_EGS_TRIANGLE_MESH_DLL
        #define EGS_TRIANGLE_MESH_EXPORT __declspec(dllexport)
    #else
        #define EGS_TRIANGLE_MESH_EXPORT __declspec(dllimport)
    #endif
    #define EGS_TRIANGLE_MESH_LOCAL
 
#else
 
    #ifdef HAVE_VISIBILITY
        #define EGS_TRIANGLE_MESH_EXPORT __attribute__ ((visibility ("default")))
        #define EGS_TRIANGLE_MESH_LOCAL  __attribute__ ((visibility ("hidden")))
    #else
        #define EGS_TRIANGLE_MESH_EXPORT
        #define EGS_TRIANGLE_MESH_LOCAL
    #endif
 
#endif
 
class EGS_TRIANGLE_MESH_EXPORT EGS_TriangleMeshSpec {
public:
 
    // A triangle with a unit normal facing outward from the surface.
    struct Triangle {
        Triangle() = default;
        Triangle(EGS_Vector a, EGS_Vector b, EGS_Vector c, EGS_Vector n) :
            a(a), b(b), c(c), n(n) {}
        // nodes
        EGS_Vector a;
        EGS_Vector b;
        EGS_Vector c;
        // normal
        EGS_Vector n;
    };
 
    EGS_TriangleMeshSpec() = default;
    EGS_TriangleMeshSpec(std::vector<Triangle> elements) :
        elements(std::move(elements)) {}
 
    // EGS_TriangleMeshSpec is move-only
    EGS_TriangleMeshSpec(const EGS_TriangleMeshSpec &) = delete;
    EGS_TriangleMeshSpec &operator=(const EGS_TriangleMeshSpec &) = delete;
    EGS_TriangleMeshSpec(EGS_TriangleMeshSpec &&) = default;
    EGS_TriangleMeshSpec &operator=(EGS_TriangleMeshSpec &&) = default;
    ~EGS_TriangleMeshSpec() = default;
 
    void scale(EGS_Float factor) {
        for (auto &e: elements) {
            e.a *= factor;
            e.b *= factor;
            e.c *= factor;
        }
    }
 
    std::size_t num_elements() const {
        return elements.size();
    }
 
    // Public members
 
    std::vector<EGS_TriangleMeshSpec::Triangle> elements;
};
 
// exclude from doxygen
class EGS_TriangleMeshBbox;
class EGS_TriangleMeshNode;
class EGS_TriangleMesh_Octree;
 
class EGS_TRIANGLE_MESH_EXPORT EGS_TriangleMesh : public EGS_BaseGeometry {
public:
    explicit EGS_TriangleMesh(EGS_TriangleMeshSpec spec, bool oct_set, bool use_stored_normals);
 
    // EGS_TriangleMesh is move-only
    EGS_TriangleMesh(const EGS_TriangleMesh &) = delete;
    EGS_TriangleMesh &operator=(const EGS_TriangleMesh &) = delete;
    EGS_TriangleMesh(EGS_TriangleMesh &&);
    EGS_TriangleMesh &operator=(EGS_TriangleMesh &&);
    ~EGS_TriangleMesh();
 
    int num_triangles() const {
        return n_tris;
    }
 
    const std::array<EGS_Float, 3> &triangle_xs(int tri) const {
        return xs.at(tri);
    }
 
    const std::array<EGS_Float, 3> &triangle_ys(int tri) const {
        return ys.at(tri);
    }
 
    const std::array<EGS_Float, 3> &triangle_zs(int tri) const {
        return zs.at(tri);
    }
 
    const EGS_Vector &triangle_normal(int tri) const {
        return ns.at(tri);
    }
 
    // EGS_BaseGeometry interface
 
    const std::string &getType() const override {
        return EGS_TriangleMesh::type;
    }
 
    void setOctBool(bool octset) {
        octree_acc_on=octset;
    }
    bool getOctBool() {
        return octree_acc_on;
    }
    void inctricheck_OHF() {
        tri_check_OHF++;
    }
    void inctricheck_OHN() {
        tri_check_OHN++;
    }
    void inctricheck_OIW() {
        tri_check_OIW++;
    }
    void inctricheck_NHF() {
        tri_check_NHF++;
    }
    void inctricheck_NHN() {
        tri_check_NHN++;
    }
    void inctricheck_NIW() {
        tri_check_NIW++;
    }
 
    bool isInside(const EGS_Vector &x) override;
    int inside(const EGS_Vector &x) override;
    int isWhere(const EGS_Vector &x) override;
    int howfar(int ireg, const EGS_Vector &x, const EGS_Vector &u,
               EGS_Float &t, int *newmed=0, EGS_Vector *normal=0) override;
    EGS_Float hownear(int ireg, const EGS_Vector &x) override;
    void initializeOctree();
 
    static const std::string type;
 
private:
    int n_tris = -1;
    int n_hist=0;
 
    // Vectors with len = n_tris
    std::vector<std::array<EGS_Float, 3>> xs;
    std::vector<std::array<EGS_Float, 3>> ys;
    std::vector<std::array<EGS_Float, 3>> zs;
    std::vector<EGS_Vector> ns;
 
    // Axis-aligned mesh bounding box used to accelerate geometry routines
    std::unique_ptr<EGS_TriangleMeshBbox> bbox;
    std::unique_ptr<EGS_TriangleMesh_Octree> surface_tree_;
    bool octree_acc_on;
    int tri_check_OHF=0,tri_check_OHN=0,tri_check_OIW=0,tri_check_NHF=0,tri_check_NHN=0,tri_check_NIW=0;
};
 
#endif // EGS_TRIANGLE_MESH