ecvGLMatrix.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 "CV_db.h"
#include "ecvGLMatrixTpl.h"
 
// CV_CORE_LIB
#include <Eigen.h>
#include <SquareMatrix.h>
 
class CV_DB_LIB_API ccGLMatrix : public ccGLMatrixTpl<float> {
public:
 
    ccGLMatrix() : ccGLMatrixTpl<float>() {}
 
 
    ccGLMatrix(const ccGLMatrixTpl<float>& mat) : ccGLMatrixTpl<float>(mat) {}
 
 
    explicit ccGLMatrix(const float* mat16f) : ccGLMatrixTpl<float>(mat16f) {}
 
 
    explicit ccGLMatrix(const double* mat16d) : ccGLMatrixTpl<float>(mat16d) {}
 
 
    ccGLMatrix(const Vector3Tpl<float>& X,
               const Vector3Tpl<float>& Y,
               const Vector3Tpl<float>& Z,
               const Vector3Tpl<float>& Tr)
        : ccGLMatrixTpl<float>(X, Y, Z, Tr) {}
};
 
class CV_DB_LIB_API ccGLMatrixd : public ccGLMatrixTpl<double> {
public:
 
    ccGLMatrixd() : ccGLMatrixTpl<double>() {}
 
 
    ccGLMatrixd(const ccGLMatrixTpl<double>& mat)
        : ccGLMatrixTpl<double>(mat) {}
 
 
    explicit ccGLMatrixd(const float* mat16f) : ccGLMatrixTpl<double>(mat16f) {}
 
 
    explicit ccGLMatrixd(const double* mat16d)
        : ccGLMatrixTpl<double>(mat16d) {}
 
 
    ccGLMatrixd(const Vector3Tpl<double>& X,
                const Vector3Tpl<double>& Y,
                const Vector3Tpl<double>& Z,
                const Vector3Tpl<double>& Tr)
        : ccGLMatrixTpl<double>(X, Y, Z, Tr) {}
};
 
/*** Helpers ***/
 
template <typename Tin, typename Tout>
ccGLMatrixTpl<Tout> FromCCLibMatrix(const cloudViewer::SquareMatrixTpl<Tin>& R,
                                    const Vector3Tpl<Tin>& Tr) {
    ccGLMatrixTpl<Tout> outputMat;
    // outputMat.toIdentity(); //already done in the constructor
 
    if (R.isValid() && R.size() == 3) {
        // we copy each column
        Tout* mat = outputMat.data();
        for (unsigned j = 0; j < 3; ++j) {
            *mat++ = static_cast<Tout>(R.m_values[0][j]);
            *mat++ = static_cast<Tout>(R.m_values[1][j]);
            *mat++ = static_cast<Tout>(R.m_values[2][j]);
            mat++;
        }
    }
 
    outputMat.setTranslation(Vector3Tpl<Tout>(static_cast<Tout>(Tr.x),
                                              static_cast<Tout>(Tr.y),
                                              static_cast<Tout>(Tr.z)));
 
    return outputMat;
}
 
template <typename Tin, typename Tout>
ccGLMatrixTpl<Tout> FromCCLibMatrix(const cloudViewer::SquareMatrixTpl<Tin>& R,
                                    const Vector3Tpl<Tin>& Tr,
                                    Tin S) {
    ccGLMatrixTpl<Tout> outputMat;
    // outputMat.toIdentity(); //already done in the constructor
 
    if (R.isValid() && R.size() == 3) {
        // we copy each column
        Tout* mat = outputMat.data();
        for (unsigned j = 0; j < 3; ++j) {
            *mat++ = static_cast<Tout>(R.m_values[0][j] * S);
            *mat++ = static_cast<Tout>(R.m_values[1][j] * S);
            *mat++ = static_cast<Tout>(R.m_values[2][j] * S);
            mat++;
        }
    }
 
    outputMat.setTranslation(Vector3Tpl<Tout>(static_cast<Tout>(Tr.x),
                                              static_cast<Tout>(Tr.y),
                                              static_cast<Tout>(Tr.z)));
 
    return outputMat;
}
 
template <typename Tin, typename Tout>
ccGLMatrixTpl<Tout> FromCCLibMatrix(const cloudViewer::SquareMatrixTpl<Tin>& R,
                                    const Vector3Tpl<Tin>& Tr,
                                    const Vector3Tpl<Tin>& rotCenter) {
    ccGLMatrixTpl<Tout> outputMat = FromCCLibMatrix<Tin, Tout>(R, Tr);
 
    outputMat.shiftRotationCenter(rotCenter);
 
    return outputMat;
}