kindred/create
1
1
Fork 0
Code Issues 53 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity
Files
bf0b19c175e6c744f3b681f0069d23f18d5032d4
create/src/Base/MatrixPyImp.cpp
wmayer 7c00932fa0 fix readability-isolate-declarations
2023-11-16 01:22:08 +01:00

1120 lines
30 KiB
C++
Raw Blame History

/***************************************************************************
* Copyright (c) 2008 Werner Mayer <wmayer[at]users.sourceforge.net> *
* *
* This file is part of the FreeCAD CAx development system. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Library General Public *
* License as published by the Free Software Foundation; either *
* version 2 of the License, or (at your option) any later version. *
* *
* This library 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 Library General Public License for more details. *
* *
* You should have received a copy of the GNU Library General Public *
* License along with this library; see the file COPYING.LIB. If not, *
* write to the Free Software Foundation, Inc., 59 Temple Place, *
* Suite 330, Boston, MA 02111-1307, USA *
* *
***************************************************************************/
#include "PreCompiled.h"
// inclusion of the generated files (generated out of MatrixPy.xml)
#include "RotationPy.h"
#include "VectorPy.h"
#include "GeometryPyCXX.h"
#include "QuantityPy.h"
#include "MatrixPy.h"
#include "MatrixPy.cpp"
using namespace Base;
// returns a string which represents the object e.g. when printed in python
std::string MatrixPy::representation() const
{
const Base::Matrix4D& m = *(this->getMatrixPtr());
std::stringstream str;
str << "Matrix (";
str << "(" << m[0][0] << "," << m[0][1] << "," << m[0][2] << "," << m[0][3] << ")"
<< ",";
str << "(" << m[1][0] << "," << m[1][1] << "," << m[1][2] << "," << m[1][3] << ")"
<< ",";
str << "(" << m[2][0] << "," << m[2][1] << "," << m[2][2] << "," << m[2][3] << ")"
<< ",";
str << "(" << m[3][0] << "," << m[3][1] << "," << m[3][2] << "," << m[3][3] << ")";
str << ")";
return str.str();
}
PyObject* MatrixPy::PyMake(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/)
{
// create a new instance of MatrixPy and the Twin object
return new MatrixPy(new Matrix4D);
}
// constructor method
int MatrixPy::PyInit(PyObject* args, PyObject* /*kwd*/)
{
// NOLINTBEGIN
double a11 = 1.0, a12 = 0.0, a13 = 0.0, a14 = 0.0;
double a21 = 0.0, a22 = 1.0, a23 = 0.0, a24 = 0.0;
double a31 = 0.0, a32 = 0.0, a33 = 1.0, a34 = 0.0;
double a41 = 0.0, a42 = 0.0, a43 = 0.0, a44 = 1.0;
// NOLINTEND
// clang-format off
if (PyArg_ParseTuple(args,
"|dddddddddddddddd",
&a11, &a12, &a13, &a14,
&a21, &a22, &a23, &a24,
&a31, &a32, &a33, &a34,
&a41, &a42, &a43, &a44)) {
MatrixPy::PointerType ptr = getMatrixPtr();
(*ptr) = Matrix4D(a11, a12, a13, a14,
a21, a22, a23, a24,
a31, a32, a33, a34,
a41, a42, a43, a44);
return 0;
}
PyErr_Clear();
PyObject* o {};
if (PyArg_ParseTuple(args, "O!", &(Base::MatrixPy::Type), &o)) {
MatrixPy::PointerType ptr = getMatrixPtr();
(*ptr) = static_cast<MatrixPy*>(o)->value();
return 0;
}
PyErr_Clear();
PyObject* o1 {};
PyObject* o2 {};
PyObject* o3 {};
PyObject* o4 {};
if (PyArg_ParseTuple(args, "O!O!O!|O!",
&(Base::VectorPy::Type), &o1,
&(Base::VectorPy::Type), &o2,
&(Base::VectorPy::Type), &o3,
&(Base::VectorPy::Type), &o4)) {
Base::Vector3d v1 = Py::Vector(o1, false).toVector();
Base::Vector3d v2 = Py::Vector(o2, false).toVector();
Base::Vector3d v3 = Py::Vector(o3, false).toVector();
Base::Vector3d v4;
if (o4) {
v4 = Py::Vector(o4, false).toVector();
}
MatrixPy::PointerType ptr = this->getMatrixPtr();
(*ptr)[0][0] = v1.x;
(*ptr)[1][0] = v1.y;
(*ptr)[2][0] = v1.z;
(*ptr)[0][1] = v2.x;
(*ptr)[1][1] = v2.y;
(*ptr)[2][1] = v2.z;
(*ptr)[0][2] = v3.x;
(*ptr)[1][2] = v3.y;
(*ptr)[2][2] = v3.z;
(*ptr)[0][3] = v4.x;
(*ptr)[1][3] = v4.y;
(*ptr)[2][3] = v4.z;
return 0;
}
// clang-format on
PyErr_SetString(PyExc_TypeError, "Base.Matrix, four Base.Vector or up to 16 floats expected");
return -1;
}
PyObject* MatrixPy::number_add_handler(PyObject* self, PyObject* other)
{
if (!PyObject_TypeCheck(self, &(MatrixPy::Type))) {
PyErr_SetString(PyExc_TypeError, "First arg must be Matrix");
return nullptr;
}
if (!PyObject_TypeCheck(other, &(MatrixPy::Type))) {
PyErr_SetString(PyExc_TypeError, "Second arg must be Matrix");
return nullptr;
}
Base::Matrix4D a = static_cast<MatrixPy*>(self)->value();
Base::Matrix4D b = static_cast<MatrixPy*>(other)->value();
return new MatrixPy(a + b);
}
PyObject* MatrixPy::number_subtract_handler(PyObject* self, PyObject* other)
{
if (!PyObject_TypeCheck(self, &(MatrixPy::Type))) {
PyErr_SetString(PyExc_TypeError, "First arg must be Matrix");
return nullptr;
}
if (!PyObject_TypeCheck(other, &(MatrixPy::Type))) {
PyErr_SetString(PyExc_TypeError, "Second arg must be Matrix");
return nullptr;
}
Base::Matrix4D a = static_cast<MatrixPy*>(self)->value();
Base::Matrix4D b = static_cast<MatrixPy*>(other)->value();
return new MatrixPy(a - b);
}
PyObject* MatrixPy::number_multiply_handler(PyObject* self, PyObject* other)
{
if (PyObject_TypeCheck(self, &(MatrixPy::Type))) {
Base::Matrix4D a = static_cast<MatrixPy*>(self)->value();
if (PyObject_TypeCheck(other, &(VectorPy::Type))) {
auto b = static_cast<VectorPy*>(other)->value();
return new VectorPy(a * b);
}
if (PyObject_TypeCheck(other, &(RotationPy::Type))) {
auto r = static_cast<RotationPy*>(other)->value();
Matrix4D b;
r.getValue(b);
return new MatrixPy(a * b);
}
if (PyObject_TypeCheck(other, &(PlacementPy::Type))) {
auto b = static_cast<PlacementPy*>(other)->value();
return new MatrixPy(a * b.toMatrix());
}
if (PyObject_TypeCheck(other, &(MatrixPy::Type))) {
Base::Matrix4D b = static_cast<MatrixPy*>(other)->value();
return new MatrixPy(a * b);
}
if (PyNumber_Check(other)) {
double v = PyFloat_AsDouble(other);
return new MatrixPy(a * v);
}
}
PyErr_SetString(PyExc_NotImplementedError, "Not implemented");
return nullptr;
}
PyObject* MatrixPy::number_power_handler(PyObject* self, PyObject* other, PyObject* arg)
{
if (!PyObject_TypeCheck(self, &(MatrixPy::Type)) ||
!PyLong_Check(other) || arg != Py_None) {
PyErr_SetString(PyExc_NotImplementedError, "Not implemented");
return nullptr;
}
Base::Matrix4D a = static_cast<MatrixPy*>(self)->value();
long b = Py::Int(other);
if (b == 0) {
return new MatrixPy(Matrix4D());
}
if (b < 0) {
if (fabs(a.determinant()) > DBL_EPSILON) {
a.inverseGauss();
}
else {
PyErr_SetString(PyExc_RuntimeError, "Cannot invert singular matrix");
return nullptr;
}
b = -b;
}
auto res = a;
for (--b; b; --b) {
res *= a;
}
return new MatrixPy(res);
}
PyObject* MatrixPy::richCompare(PyObject* v, PyObject* w, int op)
{
if (PyObject_TypeCheck(v, &(MatrixPy::Type)) && PyObject_TypeCheck(w, &(MatrixPy::Type))) {
Matrix4D m1 = static_cast<MatrixPy*>(v)->value();
Matrix4D m2 = static_cast<MatrixPy*>(w)->value();
PyObject* res = nullptr;
if (op != Py_EQ && op != Py_NE) {
PyErr_SetString(PyExc_TypeError, "no ordering relation is defined for Matrix");
return nullptr;
}
if (op == Py_EQ) {
res = (m1 == m2) ? Py_True : Py_False; // NOLINT
Py_INCREF(res);
return res;
}
res = (m1 != m2) ? Py_True : Py_False; // NOLINT
Py_INCREF(res);
return res;
}
else {
// This always returns False
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
}
PyObject* MatrixPy::move(PyObject* args)
{
double x {};
double y {};
double z {};
Base::Vector3d vec;
PyObject* pcVecObj {};
do { // dummy do..while for cascaded if
if (PyArg_ParseTuple(args, "ddd", &x, &y, &z)) {
vec.x = x;
vec.y = y;
vec.z = z;
break;
}
// clears the error from previous PyArg_ParseTuple()
PyErr_Clear();
if (PyArg_ParseTuple(args, "O!", &PyTuple_Type, &pcVecObj)) {
vec = getVectorFromTuple<double>(pcVecObj);
break;
}
// clears the error from previous PyArg_ParseTuple()
PyErr_Clear();
if (PyArg_ParseTuple(args,
"O!;three floats, or a tuple, or a vector is needed",
&(Base::VectorPy::Type),
&pcVecObj)) {
Base::VectorPy* pcObject = static_cast<Base::VectorPy*>(pcVecObj);
Base::Vector3d* val = pcObject->getVectorPtr();
vec.Set(val->x, val->y, val->z);
break;
}
return nullptr;
} while (false);
PY_TRY
{
getMatrixPtr()->move(vec);
Py_Return;
}
PY_CATCH;
}
PyObject* MatrixPy::scale(PyObject* args)
{
double x {};
double y {};
double z {};
Base::Vector3d vec;
PyObject* pcVecObj {};
do { // dummy do..while for cascaded if
if (PyArg_ParseTuple(args, "ddd", &x, &y, &z)) {
vec.x = x;
vec.y = y;
vec.z = z;
break;
}
// clears the error from previous PyArg_ParseTuple()
PyErr_Clear();
if (PyArg_ParseTuple(args, "d", &x)) {
vec.x = vec.y = vec.z = x;
break;
}
// clears the error from previous PyArg_ParseTuple()
PyErr_Clear();
if (PyArg_ParseTuple(args, "O!", &PyTuple_Type, &pcVecObj)) {
vec = getVectorFromTuple<double>(pcVecObj);
break;
}
// clears the error from previous PyArg_ParseTuple()
PyErr_Clear();
if (PyArg_ParseTuple(args,
"O!;one or three floats, or a tuple, or a vector is needed",
&(Base::VectorPy::Type),
&pcVecObj)) {
Base::VectorPy* pcObject = static_cast<Base::VectorPy*>(pcVecObj);
Base::Vector3d* val = pcObject->getVectorPtr();
vec.Set(val->x, val->y, val->z);
break;
}
return nullptr;
} while (false);
PY_TRY
{
getMatrixPtr()->scale(vec);
Py_Return;
}
PY_CATCH;
}
PyObject* MatrixPy::hasScale(PyObject* args)
{
double tol = 0;
if (!PyArg_ParseTuple(args, "|d", &tol)) {
return nullptr;
}
ScaleType type = getMatrixPtr()->hasScale(tol);
Py::Module mod("FreeCAD");
return Py::new_reference_to(
mod.callMemberFunction("ScaleType", Py::TupleN(Py::Int(static_cast<int>(type)))));
}
PyObject* MatrixPy::decompose(PyObject* args)
{
if (!PyArg_ParseTuple(args, "")) {
return nullptr;
}
auto ms = getMatrixPtr()->decompose();
Py::Tuple tuple(4);
for (int i = 0; i < 4; i++) {
tuple.setItem(i, Py::Matrix(ms[i]));
}
return Py::new_reference_to(tuple);
}
PyObject* MatrixPy::nullify()
{
PY_TRY
{
getMatrixPtr()->nullify();
Py_Return;
}
PY_CATCH;
}
PyObject* MatrixPy::isNull()
{
PY_TRY
{
bool ok = getMatrixPtr()->isNull();
return Py::new_reference_to(Py::Boolean(ok));
}
PY_CATCH;
}
PyObject* MatrixPy::unity()
{
PY_TRY
{
getMatrixPtr()->setToUnity();
Py_Return;
}
PY_CATCH;
}
PyObject* MatrixPy::isUnity(PyObject* args)
{
double tol = 0.0;
if (!PyArg_ParseTuple(args, "|d", &tol)) {
return nullptr;
}
PY_TRY
{
bool ok = getMatrixPtr()->isUnity(tol);
return Py::new_reference_to(Py::Boolean(ok));
}
PY_CATCH;
}
PyObject* MatrixPy::transform(PyObject* args)
{
Base::Vector3d vec;
Matrix4D mat;
PyObject* pcVecObj {};
PyObject* pcMatObj {};
if (!PyArg_ParseTuple(
args,
"O!O!: a transform point (Vector) and a transform matrix (Matrix) is needed",
&(Base::VectorPy::Type),
&pcVecObj,
&(MatrixPy::Type),
&pcMatObj)) {
return nullptr;
}
Base::VectorPy* pcObject = static_cast<Base::VectorPy*>(pcVecObj);
Base::Vector3d* val = pcObject->getVectorPtr();
vec.Set(val->x, val->y, val->z);
mat = *(static_cast<MatrixPy*>(pcMatObj)->getMatrixPtr());
getMatrixPtr()->transform(vec, mat);
Py_Return;
}
PyObject* MatrixPy::col(PyObject* args)
{
int index {};
if (!PyArg_ParseTuple(args, "i", &index)) {
return nullptr;
}
if (index < 0 || index > 3) {
PyErr_SetString(PyExc_ValueError, "Index expected in the range [0, 3]");
return nullptr;
}
Matrix4D* mat = getMatrixPtr();
Base::Vector3d v = mat->getCol(index);
return Py::new_reference_to(Py::Vector(v));
}
PyObject* MatrixPy::setCol(PyObject* args)
{
int index {};
PyObject* o {};
if (!PyArg_ParseTuple(args, "iO!", &index, &(VectorPy::Type), &o)) {
return nullptr;
}
if (index < 0 || index > 3) {
PyErr_SetString(PyExc_ValueError, "Index expected in the range [0, 3]");
return nullptr;
}
Base::Vector3d v = Py::Vector(o, false).toVector();
Matrix4D* mat = getMatrixPtr();
mat->setCol(index, v);
Py_Return;
}
PyObject* MatrixPy::row(PyObject* args)
{
int index {};
if (!PyArg_ParseTuple(args, "i", &index)) {
return nullptr;
}
if (index < 0 || index > 3) {
PyErr_SetString(PyExc_ValueError, "Index expected in the range [0, 3]");
return nullptr;
}
Matrix4D* mat = getMatrixPtr();
Base::Vector3d v = mat->getRow(index);
return Py::new_reference_to(Py::Vector(v));
}
PyObject* MatrixPy::setRow(PyObject* args)
{
int index {};
PyObject* o {};
if (!PyArg_ParseTuple(args, "iO!", &index, &(VectorPy::Type), &o)) {
return nullptr;
}
if (index < 0 || index > 3) {
PyErr_SetString(PyExc_ValueError, "Index expected in the range [0, 3]");
return nullptr;
}
Base::Vector3d v = Py::Vector(o, false).toVector();
Matrix4D* mat = getMatrixPtr();
mat->setRow(index, v);
Py_Return;
}
PyObject* MatrixPy::diagonal()
{
Matrix4D* mat = getMatrixPtr();
Base::Vector3d v = mat->diagonal();
return Py::new_reference_to(Py::Vector(v));
}
PyObject* MatrixPy::setDiagonal(PyObject* args)
{
PyObject* o {};
if (!PyArg_ParseTuple(args, "O!", &(VectorPy::Type), &o)) {
return nullptr;
}
Base::Vector3d v = Py::Vector(o, false).toVector();
Matrix4D* mat = getMatrixPtr();
mat->setDiagonal(v);
Py_Return;
}
PyObject* MatrixPy::rotateX(PyObject* args)
{
double angle = 0;
do {
PyObject* object {};
if (PyArg_ParseTuple(args, "O!", &(Base::QuantityPy::Type), &object)) {
Quantity* q = static_cast<Base::QuantityPy*>(object)->getQuantityPtr();
if (q->getUnit() == Base::Unit::Angle) {
angle = q->getValueAs(Base::Quantity::Radian);
break;
}
}
PyErr_Clear();
if (PyArg_ParseTuple(args, "d: angle to rotate (double) needed", &angle)) {
break;
}
PyErr_SetString(PyExc_TypeError, "For angle either float or Quantity expected");
return nullptr;
} while (false);
PY_TRY
{
getMatrixPtr()->rotX(angle);
Py_Return;
}
PY_CATCH;
}
PyObject* MatrixPy::rotateY(PyObject* args)
{
double angle = 0;
do {
PyObject* object {};
if (PyArg_ParseTuple(args, "O!", &(Base::QuantityPy::Type), &object)) {
Quantity* q = static_cast<Base::QuantityPy*>(object)->getQuantityPtr();
if (q->getUnit() == Base::Unit::Angle) {
angle = q->getValueAs(Base::Quantity::Radian);
break;
}
}
PyErr_Clear();
if (PyArg_ParseTuple(args, "d: angle to rotate (double) needed", &angle)) {
break;
}
PyErr_SetString(PyExc_TypeError, "For angle either float or Quantity expected");
return nullptr;
} while (false);
PY_TRY
{
getMatrixPtr()->rotY(angle);
Py_Return;
}
PY_CATCH;
}
PyObject* MatrixPy::rotateZ(PyObject* args)
{
double angle = 0;
do {
PyObject* object {};
if (PyArg_ParseTuple(args, "O!", &(Base::QuantityPy::Type), &object)) {
Quantity* q = static_cast<Base::QuantityPy*>(object)->getQuantityPtr();
if (q->getUnit() == Base::Unit::Angle) {
angle = q->getValueAs(Base::Quantity::Radian);
break;
}
}
PyErr_Clear();
if (PyArg_ParseTuple(args, "d: angle to rotate (double) needed", &angle)) {
break;
}
PyErr_SetString(PyExc_TypeError, "For angle either float or Quantity expected");
return nullptr;
} while (false);
PY_TRY
{
getMatrixPtr()->rotZ(angle);
Py_Return;
}
PY_CATCH;
}
PyObject* MatrixPy::multiply(PyObject* args)
{
PyObject* o {};
if (PyArg_ParseTuple(args, "O!", &(MatrixPy::Type), &o)) {
Matrix4D mat = (*getMatrixPtr()) * static_cast<Base::MatrixPy*>(o)->value();
return new MatrixPy(new Matrix4D(mat));
}
PyErr_Clear();
if (PyArg_ParseTuple(args, "O!", &(VectorPy::Type), &o)) {
Vector3d vec = (*getMatrixPtr()) * static_cast<Base::VectorPy*>(o)->value();
return new VectorPy(new Vector3d(vec));
}
PyErr_SetString(PyExc_TypeError, "either vector or matrix expected");
return nullptr;
}
PyObject* MatrixPy::multVec(PyObject* args)
{
PyObject* obj {};
if (!PyArg_ParseTuple(args, "O!", &(VectorPy::Type), &obj)) {
return nullptr;
}
Base::Vector3d vec(static_cast<VectorPy*>(obj)->value());
getMatrixPtr()->multVec(vec, vec);
return new VectorPy(new Vector3d(vec));
}
PyObject* MatrixPy::invert()
{
PY_TRY
{
if (fabs(getMatrixPtr()->determinant()) > DBL_EPSILON) {
getMatrixPtr()->inverseGauss();
Py_Return;
}
PyErr_SetString(Base::PyExc_FC_GeneralError, "Cannot invert singular matrix");
return nullptr;
}
PY_CATCH;
}
PyObject* MatrixPy::inverse()
{
PY_TRY
{
if (fabs(getMatrixPtr()->determinant()) > DBL_EPSILON) {
Base::Matrix4D m = *getMatrixPtr();
m.inverseGauss();
return new MatrixPy(m);
}
PyErr_SetString(Base::PyExc_FC_GeneralError, "Cannot invert singular matrix");
return nullptr;
}
PY_CATCH;
}
PyObject* MatrixPy::determinant()
{
return PyFloat_FromDouble(getMatrixPtr()->determinant());
}
PyObject* MatrixPy::submatrix(PyObject* args)
{
int dim {};
if (!PyArg_ParseTuple(args, "i", &dim)) {
return nullptr;
}
if (dim < 1 || dim > 4) {
PyErr_SetString(PyExc_IndexError, "Dimension out of range");
return nullptr;
}
const Base::Matrix4D& mat = *getMatrixPtr();
Base::Matrix4D sub;
switch (dim) {
case 1:
sub[0][0] = mat[0][0];
break;
case 2:
sub[0][0] = mat[0][0];
sub[0][1] = mat[0][1];
sub[1][0] = mat[1][0];
sub[1][1] = mat[1][1];
break;
case 3:
sub[0][0] = mat[0][0];
sub[0][1] = mat[0][1];
sub[0][2] = mat[0][2];
sub[1][0] = mat[1][0];
sub[1][1] = mat[1][1];
sub[1][2] = mat[1][2];
sub[2][0] = mat[2][0];
sub[2][1] = mat[2][1];
sub[2][2] = mat[2][2];
break;
default:
sub = mat;
break;
}
return new MatrixPy(sub);
}
PyObject* MatrixPy::isOrthogonal(PyObject* args)
{
double eps = 1.0e-06;
if (!PyArg_ParseTuple(args, "|d", &eps)) {
return nullptr;
}
const Base::Matrix4D& mat = *getMatrixPtr();
Base::Matrix4D trp = mat;
trp.transpose();
trp = trp * mat;
bool ok = true;
double mult = trp[0][0];
for (unsigned short i = 0; i < 4 && ok; i++) {
for (unsigned short j = 0; j < 4 && ok; j++) {
if (i != j) {
if (fabs(trp[i][j]) > eps) {
ok = false;
break;
}
}
else { // the main diagonal
if (fabs(trp[i][j] - mult) > eps) {
ok = false;
break;
}
}
}
}
return Py::new_reference_to(Py::Float(ok ? mult : 0.0));
}
PyObject* MatrixPy::transposed()
{
PY_TRY
{
Base::Matrix4D m = *getMatrixPtr();
m.transpose();
return new MatrixPy(m);
}
PY_CATCH;
}
PyObject* MatrixPy::transpose()
{
PY_TRY
{
getMatrixPtr()->transpose();
Py_Return;
}
PY_CATCH;
}
PyObject* MatrixPy::analyze()
{
PY_TRY
{
std::string type = getMatrixPtr()->analyse();
return PyUnicode_FromString(type.c_str());
}
PY_CATCH;
}
Py::Float MatrixPy::getA11() const
{
double val = (*this->getMatrixPtr())[0][0];
return Py::Float(val);
}
void MatrixPy::setA11(Py::Float arg)
{
(*this->getMatrixPtr())[0][0] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA12() const
{
double val = (*this->getMatrixPtr())[0][1];
return Py::Float(val);
}
void MatrixPy::setA12(Py::Float arg)
{
(*this->getMatrixPtr())[0][1] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA13() const
{
double val = (*this->getMatrixPtr())[0][2];
return Py::Float(val);
}
void MatrixPy::setA13(Py::Float arg)
{
(*this->getMatrixPtr())[0][2] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA14() const
{
double val = (*this->getMatrixPtr())[0][3];
return Py::Float(val);
}
void MatrixPy::setA14(Py::Float arg)
{
(*this->getMatrixPtr())[0][3] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA21() const
{
double val = (*this->getMatrixPtr())[1][0];
return Py::Float(val);
}
void MatrixPy::setA21(Py::Float arg)
{
(*this->getMatrixPtr())[1][0] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA22() const
{
double val = (*this->getMatrixPtr())[1][1];
return Py::Float(val);
}
void MatrixPy::setA22(Py::Float arg)
{
(*this->getMatrixPtr())[1][1] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA23() const
{
double val = (*this->getMatrixPtr())[1][2];
return Py::Float(val);
}
void MatrixPy::setA23(Py::Float arg)
{
(*this->getMatrixPtr())[1][2] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA24() const
{
double val = (*this->getMatrixPtr())[1][3];
return Py::Float(val);
}
void MatrixPy::setA24(Py::Float arg)
{
(*this->getMatrixPtr())[1][3] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA31() const
{
double val = (*this->getMatrixPtr())[2][0];
return Py::Float(val);
}
void MatrixPy::setA31(Py::Float arg)
{
(*this->getMatrixPtr())[2][0] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA32() const
{
double val = (*this->getMatrixPtr())[2][1];
return Py::Float(val);
}
void MatrixPy::setA32(Py::Float arg)
{
(*this->getMatrixPtr())[2][1] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA33() const
{
double val = (*this->getMatrixPtr())[2][2];
return Py::Float(val);
}
void MatrixPy::setA33(Py::Float arg)
{
(*this->getMatrixPtr())[2][2] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA34() const
{
double val = (*this->getMatrixPtr())[2][3];
return Py::Float(val);
}
void MatrixPy::setA34(Py::Float arg)
{
(*this->getMatrixPtr())[2][3] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA41() const
{
double val = (*this->getMatrixPtr())[3][0];
return Py::Float(val);
}
void MatrixPy::setA41(Py::Float arg)
{
(*this->getMatrixPtr())[3][0] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA42() const
{
double val = (*this->getMatrixPtr())[3][1];
return Py::Float(val);
}
void MatrixPy::setA42(Py::Float arg)
{
(*this->getMatrixPtr())[3][1] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA43() const
{
double val = (*this->getMatrixPtr())[3][2];
return Py::Float(val);
}
void MatrixPy::setA43(Py::Float arg)
{
(*this->getMatrixPtr())[3][2] = static_cast<double>(arg);
}
Py::Float MatrixPy::getA44() const
{
double val = (*this->getMatrixPtr())[3][3];
return Py::Float(val);
}
void MatrixPy::setA44(Py::Float arg)
{
(*this->getMatrixPtr())[3][3] = static_cast<double>(arg);
}
Py::Sequence MatrixPy::getA() const
{
double mat[16];
this->getMatrixPtr()->getMatrix(mat);
Py::Tuple tuple(16);
for (int i = 0; i < 16; i++) {
tuple[i] = Py::Float(mat[i]);
}
return std::move(tuple);
}
void MatrixPy::setA(Py::Sequence arg)
{
double mat[16];
this->getMatrixPtr()->getMatrix(mat);
int index = 0;
for (Py::Sequence::iterator it = arg.begin(); it != arg.end() && index < 16; ++it) {
mat[index++] = static_cast<double>(Py::Float(*it));
}
this->getMatrixPtr()->setMatrix(mat);
}
PyObject* MatrixPy::getCustomAttributes(const char* /*attr*/) const
{
return nullptr;
}
int MatrixPy::setCustomAttributes(const char* /*attr*/, PyObject* /*obj*/)
{
return 0;
}
PyObject* MatrixPy::number_divide_handler(PyObject* /*self*/, PyObject* /*other*/)
{
PyErr_SetString(PyExc_NotImplementedError, "Not implemented");
return nullptr;
}
PyObject* MatrixPy::number_remainder_handler(PyObject* /*self*/, PyObject* /*other*/)
{
PyErr_SetString(PyExc_NotImplementedError, "Not implemented");
return nullptr;
}
PyObject* MatrixPy::number_divmod_handler(PyObject* /*self*/, PyObject* /*other*/)
{
PyErr_SetString(PyExc_NotImplementedError, "Not implemented");
return nullptr;
}
PyObject* MatrixPy::number_negative_handler(PyObject* self)
{
if (!PyObject_TypeCheck(self, &(MatrixPy::Type))) {
PyErr_SetString(PyExc_TypeError, "arg must be Matrix");
return nullptr;
}
Base::Matrix4D a = static_cast<MatrixPy*>(self)->value();
return new MatrixPy(a * -1);
}
PyObject* MatrixPy::number_positive_handler(PyObject* self)
{
if (!PyObject_TypeCheck(self, &(MatrixPy::Type))) {
PyErr_SetString(PyExc_TypeError, "arg must be Matrix");
return nullptr;
}
Base::Matrix4D a = static_cast<MatrixPy*>(self)->value();
return new MatrixPy(a);
}
PyObject* MatrixPy::number_absolute_handler(PyObject* /*self*/)
{
PyErr_SetString(PyExc_NotImplementedError, "Not implemented");
return nullptr;
}
int MatrixPy::number_nonzero_handler(PyObject* /*self*/)
{
return 1;
}
PyObject* MatrixPy::number_invert_handler(PyObject* /*self*/)
{
PyErr_SetString(PyExc_NotImplementedError, "Not implemented");
return nullptr;
}
PyObject* MatrixPy::number_lshift_handler(PyObject* /*self*/, PyObject* /*other*/)
{
PyErr_SetString(PyExc_NotImplementedError, "Not implemented");
return nullptr;
}
PyObject* MatrixPy::number_rshift_handler(PyObject* /*self*/, PyObject* /*other*/)
{
PyErr_SetString(PyExc_NotImplementedError, "Not implemented");
return nullptr;
}
PyObject* MatrixPy::number_and_handler(PyObject* /*self*/, PyObject* /*other*/)
{
PyErr_SetString(PyExc_NotImplementedError, "Not implemented");
return nullptr;
}
PyObject* MatrixPy::number_xor_handler(PyObject* /*self*/, PyObject* /*other*/)
{
PyErr_SetString(PyExc_NotImplementedError, "Not implemented");
return nullptr;
}
PyObject* MatrixPy::number_or_handler(PyObject* /*self*/, PyObject* /*other*/)
{
PyErr_SetString(PyExc_NotImplementedError, "Not implemented");
return nullptr;
}
PyObject* MatrixPy::number_int_handler(PyObject* /*self*/)
{
PyErr_SetString(PyExc_NotImplementedError, "Not implemented");
return nullptr;
}
PyObject* MatrixPy::number_float_handler(PyObject* /*self*/)
{
PyErr_SetString(PyExc_NotImplementedError, "Not implemented");
return nullptr;
}
Reference in New Issue View Git Blame Copy Permalink