matrix4x4.h

/****************************************************************************
**
** Copyright (c) 2015-2026 RoboDK Global.
** Contact: https://robodk.com/
**
** This file is part of the RoboDK API.
**
** Permission is hereby granted, free of charge, to any person obtaining a copy
** of this software and associated documentation files (the "Software"), to deal
** in the Software without restriction, including without limitation the rights
** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
** copies of the Software, and to permit persons to whom the Software is
** furnished to do so, subject to the following conditions:
**
** The above copyright notice and this permission notice shall be included in all
** copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
** SOFTWARE.
**
** RoboDK is a registered trademark of RoboDK Global.
**
****************************************************************************/
 
#ifndef ROBODK_MATRIX4X4_H
#define ROBODK_MATRIX4X4_H
 
 
#include "deprecated.h"
#include "vector3.h"
 
 
#ifdef QT_GUI_LIB
#include <QString>
#include <QMatrix4x4>
 
namespace robodk
{
typedef ::QMatrix4x4 BaseMatrix4x4;
}
#else // QT_GUI_LIB
#error "This class cannot yet be used without the Qt Framework"
#endif // QT_GUI_LIB
 
 
namespace robodk
{
 
class Matrix4x4 : public BaseMatrix4x4
{
public:
    Matrix4x4();
 
    explicit Matrix4x4(bool valid);
 
    Matrix4x4(const Matrix4x4& matrix);
 
    Matrix4x4(const double* values);
 
    Matrix4x4(const float* values);
 
    Matrix4x4(double x, double y, double z);
 
    Matrix4x4(
        double nx,
        double ox,
        double ax,
        double tx,
        double ny,
        double oy,
        double ay,
        double ty,
        double nz,
        double oz,
        double az,
        double tz);
 
    ~Matrix4x4() = default;
 
    void SetVX(const Vector3& n);
 
    void SetVY(const Vector3& o);
 
    void SetVZ(const Vector3& a);
 
    void SetVX(double x, double y, double z);
 
    void SetVY(double x, double y, double z);
 
    void SetVZ(double x, double y, double z);
 
    void SetPos(double x, double y, double z);
 
    void SetVX(const double* xyz);
 
    void SetVY(const double* xyz);
 
    void SetVZ(const double* xyz);
 
    void SetPos(const double* xyz);
 
    void SetValues(const double* values);
 
    Vector3 VX() const;
 
    Vector3 VY() const;
 
    Vector3 VZ() const;
 
    void VX(double* xyz) const;
 
    void VY(double* xyz) const;
 
    void VZ(double* xyz) const;
 
    void Pos(double* xyz) const;
 
    void Set(int row, int column, double value);
 
    double Get(int row, int column) const;
 
    Matrix4x4 Inverted(bool* invertible = nullptr) const;
 
    bool IsHomogeneous() const;
 
    bool MakeHomogeneous();
 
    void ToXYZRPW(double* xyzwpr) const;
 
    void FromXYZRPW(const double* xyzwpr);
 
 
    static Matrix4x4 XYZRPW_2_Mat(double x, double y, double z, double r, double p, double w);
 
    static Matrix4x4 XYZRPW_2_Mat(const double* xyzwpr);
 
    const double* ValuesD() const;
 
    const float* ValuesF() const;
 
#ifdef ROBODK_API_FLOATS
    const float* Values() const;
#else
    const double* Values() const;
#endif
 
    void Values(double* values) const;
 
    void Values(float* values) const;
 
    bool Valid() const;
 
    Matrix4x4& operator=(const Matrix4x4& matrix);
 
    static Matrix4x4 transl(double x, double y, double z);
 
    static Matrix4x4 rotx(double rx);
 
    static Matrix4x4 roty(double ry);
 
    static Matrix4x4 rotz(double rz);
 
#ifdef QT_GUI_LIB
    Matrix4x4(const BaseMatrix4x4& matrix);
 
    inline operator QString() const { return ToString(); }
 
    bool FromString(const QString& str);
 
 
    QString ToString(
        const ::QString& separator = QLatin1String(", "),
        int precision = 3,
        bool xyzrpwOnly = false) const;
 
    Matrix4x4& operator=(const QMatrix4x4& matrix);
#endif
 
    /* Deprecated methods */
public:
    ROBODK_DEPRECATED("Use Inverted() instead")
    inline Matrix4x4 inv() { return Inverted(); }
 
    ROBODK_DEPRECATED("Use SetPos() instead")
    inline void setPos(double x, double y, double z) { SetPos(x, y, z); }
 
 
 
private:
    double _valid;
    mutable double _md[16];
 
};
 
} // namespace robodk
 
 
#endif // ROBODK_MATRIX4X4_H