SimpleMesh.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
// Local
#include "BoundingBox.h"
#include "GenericIndexedMesh.h"
#include "SimpleTriangle.h"
 
// System
#include <vector>
 
namespace cloudViewer {
 
class GenericIndexedCloud;
 
 
class CV_CORE_LIB_API SimpleMesh : public GenericIndexedMesh {
public:  // constructors
 
    SimpleMesh(GenericIndexedCloud* _theVertices,
               bool linkVerticesWithMesh = false);
 
    ~SimpleMesh() override;
 
public:  // inherited methods
    void forEach(genericTriangleAction action) override;
    void placeIteratorAtBeginning() override;
    GenericTriangle* _getNextTriangle() override;  // temporary
    GenericTriangle* _getTriangle(
            unsigned triangleIndex) override;  // temporary
    VerticesIndexes* getNextTriangleVertIndexes() override;
    VerticesIndexes* getTriangleVertIndexes(unsigned triangleIndex) override;
    virtual unsigned size() const override {
        return static_cast<unsigned>(m_triIndexes.size());
    }
    void getBoundingBox(CCVector3& bbMin, CCVector3& bbMax) override;
    void getTriangleVertices(unsigned triangleIndex,
                             CCVector3& A,
                             CCVector3& B,
                             CCVector3& C) const override;
    virtual void getTriangleVertices(unsigned triangleIndex,
                                     double A[3],
                                     double B[3],
                                     double C[3]) const override;
 
public:  // specific methods
    inline unsigned capacity() const {
        return static_cast<unsigned>(m_triIndexes.capacity());
    }
 
    inline const GenericIndexedCloud* vertices() const { return theVertices; }
 
    inline void clear() { m_triIndexes.resize(0); }
 
 
    virtual void addTriangle(unsigned i1, unsigned i2, unsigned i3);
 
 
    virtual bool reserve(unsigned n);
 
 
    virtual bool resize(unsigned n);
 
    // inherited from GenericIndexedMesh
    bool normalsAvailable() const override;
    bool interpolateNormals(unsigned triIndex,
                            const CCVector3& P,
                            CCVector3& N) override;
 
protected:
    using TriangleIndexesContainer = std::vector<VerticesIndexes>;
    TriangleIndexesContainer m_triIndexes;
 
    unsigned globalIterator;
    SimpleTriangle dummyTriangle;
 
    GenericIndexedCloud* theVertices;
    bool verticesLinked;
 
    BoundingBox m_bbox;
};
 
}  // namespace cloudViewer