VTK  9.3.20240722
vtkMatrix4x4.h
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2// SPDX-License-Identifier: BSD-3-Clause
132#ifndef vtkMatrix4x4_h
133#define vtkMatrix4x4_h
134
135#include "vtkCommonMathModule.h" // For export macro
136#include "vtkObject.h"
137#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
138
139VTK_ABI_NAMESPACE_BEGIN
140class VTKCOMMONMATH_EXPORT VTK_MARSHALAUTO vtkMatrix4x4 : public vtkObject
141{
142public:
144 double Element[4][4];
145
149 static vtkMatrix4x4* New();
150
151 vtkTypeMacro(vtkMatrix4x4, vtkObject);
152 void PrintSelf(ostream& os, vtkIndent indent) override;
153
159 {
160 vtkMatrix4x4::DeepCopy(*this->Element, source);
161 this->Modified();
162 }
163
168 static void DeepCopy(double destination[16], const vtkMatrix4x4* source)
169 {
170 vtkMatrix4x4::DeepCopy(destination, *source->Element);
171 }
172
177 static void DeepCopy(double destination[16], const double source[16]);
178
183 void DeepCopy(const double elements[16])
184 {
185 vtkMatrix4x4::DeepCopy(*this->Element, elements);
186 this->Modified();
187 }
188
192 void Zero()
193 {
194 vtkMatrix4x4::Zero(*this->Element);
195 this->Modified();
196 }
197 static void Zero(double elements[16]);
198
202 void Identity()
203 {
204 vtkMatrix4x4::Identity(*this->Element);
205 this->Modified();
206 }
207 static void Identity(double elements[16]);
208
212 bool IsIdentity();
213
218 static void Invert(const vtkMatrix4x4* in, vtkMatrix4x4* out)
219 {
221 out->Modified();
222 }
223 void Invert() { vtkMatrix4x4::Invert(this, this); }
224 static void Invert(const double inElements[16], double outElements[16]);
225
229 static void Transpose(const vtkMatrix4x4* in, vtkMatrix4x4* out)
230 {
232 out->Modified();
233 }
234 void Transpose() { vtkMatrix4x4::Transpose(this, this); }
235 static void Transpose(const double inElements[16], double outElements[16]);
236
238
241 static void MatrixFromRotation(double angle, double x, double y, double z, vtkMatrix4x4* result);
242 static void MatrixFromRotation(double angle, double x, double y, double z, double matrix[16]);
244
251 static void PoseToMatrix(double pos[3], double ori[4], vtkMatrix4x4* mat);
252
257 void MultiplyPoint(const float in[4], float out[4])
258 {
259 vtkMatrix4x4::MultiplyPoint(*this->Element, in, out);
260 }
261 void MultiplyPoint(const double in[4], double out[4])
262 {
263 vtkMatrix4x4::MultiplyPoint(*this->Element, in, out);
264 }
265
266 static void MultiplyPoint(const double elements[16], const float in[4], float out[4]);
267 static void MultiplyPoint(const double elements[16], const double in[4], double out[4]);
268
272 float* MultiplyPoint(const float in[4]) VTK_SIZEHINT(4) { return this->MultiplyFloatPoint(in); }
273 double* MultiplyPoint(const double in[4]) VTK_SIZEHINT(4)
274 {
275 return this->MultiplyDoublePoint(in);
276 }
277 float* MultiplyFloatPoint(const float in[4]) VTK_SIZEHINT(4)
278 {
279 this->MultiplyPoint(in, this->FloatPoint);
280 return this->FloatPoint;
281 }
282 double* MultiplyDoublePoint(const double in[4]) VTK_SIZEHINT(4)
283 {
284 this->MultiplyPoint(in, this->DoublePoint);
285 return this->DoublePoint;
286 }
287
289
292 static void Multiply4x4(const vtkMatrix4x4* a, const vtkMatrix4x4* b, vtkMatrix4x4* c);
293 static void Multiply4x4(const double a[16], const double b[16], double c[16]);
294 static void Multiply4x4(const double a[16], const double b[16], float c[16]);
295 static void MultiplyAndTranspose4x4(const double a[16], const double b[16], float c[16]);
297
301 void Adjoint(const vtkMatrix4x4* in, vtkMatrix4x4* out)
302 {
304 }
305 static void Adjoint(const double inElements[16], double outElements[16]);
306
310 double Determinant() { return vtkMatrix4x4::Determinant(*this->Element); }
311 static double Determinant(const double elements[16]);
312
316 void SetElement(int i, int j, double value);
317
321 double GetElement(int i, int j) const { return this->Element[i][j]; }
322
326 double* GetData() VTK_SIZEHINT(16) { return *this->Element; }
327
331 const double* GetData() const { return *this->Element; }
332
336 void SetData(const double data[16]) { vtkMatrix4x4::DeepCopy(data); }
337
338protected:
340 ~vtkMatrix4x4() override = default;
341
342 float FloatPoint[4];
343 double DoublePoint[4];
344
345private:
346 vtkMatrix4x4(const vtkMatrix4x4&) = delete;
347 void operator=(const vtkMatrix4x4&) = delete;
348};
349
350//----------------------------------------------------------------------------
351// Multiplies matrices a and b and stores the result in c.
352inline void vtkMatrix4x4::Multiply4x4(const double a[16], const double b[16], double c[16])
353{
354 double tmp[16];
355
356 for (int i = 0; i < 16; i += 4)
357 {
358 for (int j = 0; j < 4; j++)
359 {
360 tmp[i + j] =
361 a[i + 0] * b[j + 0] + a[i + 1] * b[j + 4] + a[i + 2] * b[j + 8] + a[i + 3] * b[j + 12];
362 }
363 }
364
365 for (int k = 0; k < 16; k++)
366 {
367 c[k] = tmp[k];
368 }
369}
370
371//----------------------------------------------------------------------------
372// Multiplies matrices a and b and stores the result in c.
373inline void vtkMatrix4x4::Multiply4x4(const double a[16], const double b[16], float c[16])
374{
375 for (int i = 0; i < 16; i += 4)
376 {
377 for (int j = 0; j < 4; j++)
378 {
379 c[i + j] =
380 a[i + 0] * b[j + 0] + a[i + 1] * b[j + 4] + a[i + 2] * b[j + 8] + a[i + 3] * b[j + 12];
381 }
382 }
383}
384
385//----------------------------------------------------------------------------
386// Multiplies matrices a and b and stores the result in c.
388 const double a[16], const double b[16], float c[16])
389{
390 for (int i = 0; i < 4; i++)
391 {
392 for (int j = 0; j < 4; j++)
393 {
394 int it4 = i * 4;
395 c[i + j * 4] = a[it4 + 0] * b[j + 0] + a[it4 + 1] * b[j + 4] + a[it4 + 2] * b[j + 8] +
396 a[it4 + 3] * b[j + 12];
397 }
398 }
399}
400
401//----------------------------------------------------------------------------
403{
405}
406
407//----------------------------------------------------------------------------
408inline void vtkMatrix4x4::SetElement(int i, int j, double value)
409{
410 if (this->Element[i][j] != value)
411 {
412 this->Element[i][j] = value;
413 this->Modified();
414 }
415}
416
417//----------------------------------------------------------------------------
419{
420 double* M = *this->Element;
421 return M[0] == 1.0 && M[1] == 0.0 && M[2] == 0.0 && M[3] == 0.0 && M[4] == 0.0 && M[5] == 1.0 &&
422 M[6] == 0.0 && M[7] == 0.0 && M[8] == 0.0 && M[9] == 0.0 && M[10] == 1.0 && M[11] == 0.0 &&
423 M[12] == 0.0 && M[13] == 0.0 && M[14] == 0.0 && M[15] == 1.0;
424}
425
426VTK_ABI_NAMESPACE_END
427#endif
a simple class to control print indentation
Definition vtkIndent.h:108
represent and manipulate 4x4 transformation matrices
static void Transpose(const double inElements[16], double outElements[16])
static double Determinant(const double elements[16])
void DeepCopy(const vtkMatrix4x4 *source)
Set the elements of the matrix to the same values as the elements of the given source matrix.
static vtkMatrix4x4 * New()
Construct a 4x4 identity matrix.
void DeepCopy(const double elements[16])
Non-static member function.
double GetElement(int i, int j) const
Returns the element i,j from the matrix.
static void MatrixFromRotation(double angle, double x, double y, double z, double matrix[16])
Construct a matrix from a rotation.
double * MultiplyDoublePoint(const double in[4])
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
static void Multiply4x4(const vtkMatrix4x4 *a, const vtkMatrix4x4 *b, vtkMatrix4x4 *c)
Multiplies matrices a and b and stores the result in c.
void MultiplyPoint(const double in[4], double out[4])
static void Adjoint(const double inElements[16], double outElements[16])
void MultiplyPoint(const float in[4], float out[4])
Multiply a homogeneous coordinate by this matrix, i.e.
void Adjoint(const vtkMatrix4x4 *in, vtkMatrix4x4 *out)
Compute adjoint of the matrix and put it into out.
void SetData(const double data[16])
Copies data into the matrix.
void Identity()
Set equal to Identity matrix.
static void MatrixFromRotation(double angle, double x, double y, double z, vtkMatrix4x4 *result)
Construct a matrix from a rotation.
double Determinant()
Compute the determinant of the matrix and return it.
void SetElement(int i, int j, double value)
Sets the element i,j in the matrix.
static void DeepCopy(double destination[16], const vtkMatrix4x4 *source)
Set the elements of the given destination buffer to the same values as the elements of the given sour...
void Zero()
Set all of the elements to zero.
double * GetData()
Returns the raw double array holding the matrix.
double Element[4][4]
The internal data is public for historical reasons. Do not use!
static void MultiplyAndTranspose4x4(const double a[16], const double b[16], float c[16])
Multiplies matrices a and b and stores the result in c.
static void DeepCopy(double destination[16], const double source[16])
Copies the given source buffer to the given destination buffer.
static void Invert(const double inElements[16], double outElements[16])
static void Invert(const vtkMatrix4x4 *in, vtkMatrix4x4 *out)
Matrix Inversion (adapted from Richard Carling in "Graphics Gems," Academic Press,...
static void PoseToMatrix(double pos[3], double ori[4], vtkMatrix4x4 *mat)
Given an orientation and position this function will fill in a matrix representing the transformation...
float * MultiplyPoint(const float in[4])
For use in Java or Python.
double * MultiplyPoint(const double in[4])
float * MultiplyFloatPoint(const float in[4])
static void Identity(double elements[16])
static void MultiplyPoint(const double elements[16], const double in[4], double out[4])
static void Zero(double elements[16])
static void Transpose(const vtkMatrix4x4 *in, vtkMatrix4x4 *out)
Transpose the matrix and put it into out.
const double * GetData() const
Returns the raw double array holding the matrix.
~vtkMatrix4x4() override=default
static void MultiplyPoint(const double elements[16], const float in[4], float out[4])
bool IsIdentity()
Returns true if this matrix is equal to the identity matrix.
abstract base class for most VTK objects
Definition vtkObject.h:162
virtual void Modified()
Update the modification time for this object.
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
#define VTK_SIZEHINT(...)
#define VTK_MARSHALAUTO