ecvGenericMesh.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
 
// CV_CORE_LIB
#include <GenericIndexedMesh.h>
 
// LOCAL
#include "ecvAdvancedTypes.h"
#include "ecvBBox.h"
#include "ecvShiftedObject.h"
 
namespace cloudViewer {
class GenericProgressCallback;
class ReferenceCloud;
}  // namespace cloudViewer
 
class ccGenericPointCloud;
class ccPointCloud;
class ccMaterialSet;
 
class CV_DB_LIB_API ccGenericMesh : public cloudViewer::GenericIndexedMesh,
                                    public ccShiftedObject {
public:
 
    ccGenericMesh(QString name = QString());
 
    ~ccGenericMesh() override = default;
 
    // inherited methods (ccDrawableObject)
    void showNormals(bool state) override;
 
    // inherited methods (ccHObject)
    bool isSerializable() const override { return true; }
 
    virtual ccGenericPointCloud* getAssociatedCloud() const = 0;
 
    virtual void refreshBB() = 0;
 
    virtual unsigned capacity() const = 0;
 
    virtual bool hasMaterials() const = 0;
 
    virtual const ccMaterialSet* getMaterialSet() const = 0;
 
    virtual int getTriangleMtlIndex(unsigned triangleIndex) const = 0;
 
    virtual bool hasTextures() const = 0;
 
    virtual TextureCoordsContainer* getTexCoordinatesTable() const = 0;
 
    virtual void getTriangleTexCoordinates(unsigned triIndex,
                                           TexCoords2D*& tx1,
                                           TexCoords2D*& tx2,
                                           TexCoords2D*& tx3) const = 0;
    virtual void getTexCoordinates(unsigned index, TexCoords2D*& tx) const = 0;
 
    virtual bool hasPerTriangleTexCoordIndexes() const = 0;
 
 
    virtual void getTriangleTexCoordinatesIndexes(unsigned triangleIndex,
                                                  int& i1,
                                                  int& i2,
                                                  int& i3) const = 0;
 
    virtual bool hasTriNormals() const = 0;
 
 
    virtual void getTriangleNormalIndexes(unsigned triangleIndex,
                                          int& i1,
                                          int& i2,
                                          int& i3) const = 0;
 
 
    virtual bool getTriangleNormals(unsigned triangleIndex,
                                    CCVector3& Na,
                                    CCVector3& Nb,
                                    CCVector3& Nc) const = 0;
    virtual bool getTriangleNormals(unsigned triangleIndex,
                                    double Na[3],
                                    double Nb[3],
                                    double Nc[3]) const {
        return false;
    };
    virtual bool getTriangleNormals(unsigned triangleIndex,
                                    Eigen::Vector3d& Na,
                                    Eigen::Vector3d& Nb,
                                    Eigen::Vector3d& Nc) const {
        return false;
    };
 
    virtual NormsIndexesTableType* getTriNormsTable() const = 0;
 
    virtual void computeInterpolationWeights(unsigned triIndex,
                                             const CCVector3& P,
                                             CCVector3d& weights) const;
 
 
    virtual bool interpolateNormalsBC(unsigned triIndex,
                                      const CCVector3d& w,
                                      CCVector3& N) = 0;
 
 
    virtual bool interpolateColors(unsigned triIndex,
                                   const CCVector3& P,
                                   ecvColor::Rgb& C) = 0;
 
    //  \param P point where to grab color (should be inside the triangle!)
    //  \param[out] C vertex color
    //  \param interpolateColorIfNoTexture whether to return the color
    // interpolated from the RGB field if no texture/material is associated to
    // the given triangles  \return success
    //**/
    virtual bool getColorFromMaterial(unsigned triIndex,
                                      const CCVector3& P,
                                      ecvColor::Rgb& C,
                                      bool interpolateColorIfNoTexture) = 0;
 
    //  \param vertIndex vertex index inside triangle (i.e. 0, 1 or 2!)
    //  \param[out] C vertex color
    //  \param returnColorIfNoTexture whether to return the color from the
    // vertex RGB field if no texture/material is associated to the given
    // triangle     \return success
    //**/
    virtual bool getVertexColorFromMaterial(unsigned triIndex,
                                            unsigned char vertIndex,
                                            ecvColor::Rgb& C,
                                            bool returnColorIfNoTexture) = 0;
 
    virtual bool isShownAsWire() const { return m_showWired; }
 
    virtual void showWired(bool state) { m_showWired = state; }
 
    virtual bool isShownAsPoints() const { return m_showPoints; }
 
    virtual void showPoints(bool state) { m_showPoints = state; }
 
    virtual bool triNormsShown() const { return m_triNormsShown; }
 
    virtual void showTriNorms(bool state) { m_triNormsShown = state; }
 
    virtual bool materialsShown() const { return m_materialsShown; }
 
    virtual void showMaterials(bool state) { m_materialsShown = state; }
 
    virtual bool stipplingEnabled() const { return m_stippling; }
 
    void enableStippling(bool state) { m_stippling = state; }
 
    ccPointCloud* samplePoints(
            bool densityBased,
            double samplingParameter,
            bool withNormals,
            bool withRGB,
            bool withTexture,
            cloudViewer::GenericProgressCallback* pDlg = nullptr);
 
 
    void importParametersFrom(const ccGenericMesh* mesh);
 
    virtual bool trianglePicking(const CCVector2d& clickPos,
                                 const ccGLCameraParameters& camera,
                                 int& nearestTriIndex,
                                 double& nearestSquareDist,
                                 CCVector3d& nearestPoint,
                                 CCVector3d* barycentricCoords = nullptr) const;
 
    virtual bool trianglePicking(unsigned triIndex,
                                 const CCVector2d& clickPos,
                                 const ccGLCameraParameters& camera,
                                 CCVector3d& point,
                                 CCVector3d* barycentricCoords = nullptr) const;
 
    bool computePointPosition(unsigned triIndex,
                              const CCVector2d& uv,
                              CCVector3& P,
                              bool warningIfOutside = true) const;
 
    static bool IsCloudVerticesOfMesh(ccGenericPointCloud* cloud,
                                      ccGenericMesh** mesh = nullptr);
 
    // inherited methods (ccShiftedObject)
    void setGlobalShift(const CCVector3d& shift) override;
    void setGlobalScale(double scale) override;
    const CCVector3d& getGlobalShift() const override;
    double getGlobalScale() const override;
 
    // inherited methods (GenericIndexedMesh)
    bool normalsAvailable() const override { return hasNormals(); }
 
    bool updateTextures(const std::string& texture_file);
    bool updateTextures(const std::vector<std::string>& texture_files);
 
protected:
    // inherited from ccHObject
    bool toFile_MeOnly(QFile& out, short dataVersion) const override;
    short minimumFileVersion_MeOnly() const override;
    bool fromFile_MeOnly(QFile& in,
                         short dataVersion,
                         int flags,
                         LoadedIDMap& oldToNewIDMap) override;
 
    // Static arrays for OpenGL drawing
    static CCVector3* GetVertexBuffer();
    static CCVector3* GetNormalsBuffer();
    static ecvColor::Rgb* GetColorsBuffer();
 
    virtual bool trianglePicking(unsigned triIndex,
                                 const CCVector2d& clickPos,
                                 const ccGLMatrix& trans,
                                 bool noGLTrans,
                                 const ccGenericPointCloud& vertices,
                                 const ccGLCameraParameters& camera,
                                 CCVector3d& point,
                                 CCVector3d* barycentricCoords = nullptr) const;
 
 
    static unsigned* GetWireVertexIndexes();
 
    // static void EnableGLStippleMask(const QOpenGLContext* context, bool
    // state);
 
    // inherited from ccHObject
    void drawMeOnly(CC_DRAW_CONTEXT& context) override;
 
    void handleColorRamp(CC_DRAW_CONTEXT& context);
 
    bool m_triNormsShown;
 
    bool m_materialsShown;
 
    bool m_showWired;
 
    bool m_showPoints;
 
    bool m_stippling;
};