MRAffineXf.h

Go to the documentation of this file.

#pragma once
 
#include <MRCMesh/MRMatrix2.h>
#include <MRCMesh/MRMatrix3.h>
#include <MRCMesh/MRVector2.h>
#include <MRCMesh/MRVector3.h>
#include <MRCMisc/exports.h>
 
#include <stdbool.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct MR_std_istream MR_std_istream; // Defined in `#include <MRCMisc/iostream.h>`.
typedef struct MR_std_ostream MR_std_ostream; // Defined in `#include <MRCMisc/iostream.h>`.
 
 
typedef struct MR_AffineXf2f
{
    MR_Matrix2f A;
    MR_Vector2f b;
} MR_AffineXf2f;
 
typedef struct MR_AffineXf2d
{
    MR_Matrix2d A;
    MR_Vector2d b;
} MR_AffineXf2d;
 
typedef struct MR_AffineXf3f
{
    MR_Matrix3f A;
    MR_Vector3f b;
} MR_AffineXf3f;
 
typedef struct MR_AffineXf3d
{
    MR_Matrix3d A;
    MR_Vector3d b;
} MR_AffineXf3d;
 
MRC_API MR_AffineXf2f MR_AffineXf2f_DefaultConstruct(void);
 
MRC_API MR_AffineXf2f *MR_AffineXf2f_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_AffineXf2f MR_AffineXf2f_Construct(const MR_Matrix2f *A, const MR_Vector2f *b);
 
MRC_API MR_AffineXf2f MR_AffineXf2f_translation(const MR_Vector2f *b);
 
MRC_API MR_AffineXf2f MR_AffineXf2f_linear(const MR_Matrix2f *A);
 
MRC_API MR_AffineXf2f MR_AffineXf2f_xfAround(const MR_Matrix2f *A, const MR_Vector2f *stable);
 
MRC_API MR_Vector2f MR_AffineXf2f_call(const MR_AffineXf2f *_this, const MR_Vector2f *x);
 
MRC_API MR_Vector2f MR_AffineXf2f_linearOnly(const MR_AffineXf2f *_this, const MR_Vector2f *x);
 
MRC_API MR_AffineXf2f MR_AffineXf2f_inverse(const MR_AffineXf2f *_this);
 
MRC_API MR_AffineXf2f MR_mul_MR_AffineXf2f(const MR_AffineXf2f *u, const MR_AffineXf2f *v);
 
MRC_API bool MR_equal_MR_AffineXf2f(const MR_AffineXf2f *a, const MR_AffineXf2f *b);
 
MRC_API bool MR_not_equal_MR_AffineXf2f(const MR_AffineXf2f *a, const MR_AffineXf2f *b);
 
MRC_API MR_std_ostream *MR_print_MR_AffineXf2f(MR_std_ostream *s, const MR_AffineXf2f *xf);
 
MRC_API MR_std_istream *MR_input_MR_AffineXf2f(MR_std_istream *s, MR_AffineXf2f *xf);
 
MRC_API MR_AffineXf2d MR_AffineXf2d_DefaultConstruct(void);
 
MRC_API MR_AffineXf2d *MR_AffineXf2d_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_AffineXf2d MR_AffineXf2d_Construct(const MR_Matrix2d *A, const MR_Vector2d *b);
 
MRC_API MR_AffineXf2d MR_AffineXf2d_translation(const MR_Vector2d *b);
 
MRC_API MR_AffineXf2d MR_AffineXf2d_linear(const MR_Matrix2d *A);
 
MRC_API MR_AffineXf2d MR_AffineXf2d_xfAround(const MR_Matrix2d *A, const MR_Vector2d *stable);
 
MRC_API MR_Vector2d MR_AffineXf2d_call(const MR_AffineXf2d *_this, const MR_Vector2d *x);
 
MRC_API MR_Vector2d MR_AffineXf2d_linearOnly(const MR_AffineXf2d *_this, const MR_Vector2d *x);
 
MRC_API MR_AffineXf2d MR_AffineXf2d_inverse(const MR_AffineXf2d *_this);
 
MRC_API MR_AffineXf2d MR_mul_MR_AffineXf2d(const MR_AffineXf2d *u, const MR_AffineXf2d *v);
 
MRC_API bool MR_equal_MR_AffineXf2d(const MR_AffineXf2d *a, const MR_AffineXf2d *b);
 
MRC_API bool MR_not_equal_MR_AffineXf2d(const MR_AffineXf2d *a, const MR_AffineXf2d *b);
 
MRC_API MR_std_ostream *MR_print_MR_AffineXf2d(MR_std_ostream *s, const MR_AffineXf2d *xf);
 
MRC_API MR_std_istream *MR_input_MR_AffineXf2d(MR_std_istream *s, MR_AffineXf2d *xf);
 
MRC_API MR_AffineXf3f MR_AffineXf3f_DefaultConstruct(void);
 
MRC_API MR_AffineXf3f *MR_AffineXf3f_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_AffineXf3f MR_AffineXf3f_Construct(const MR_Matrix3f *A, const MR_Vector3f *b);
 
// Here `U == V` doesn't seem to cause any issues in the C++ code, but we're still disabling it because it somehow gets emitted
//   when generating the bindings, and results in duplicate functions in C#.
MRC_API MR_AffineXf3f MR_AffineXf3f_Construct_MR_Vector3d(const MR_AffineXf3d *xf);
 
MRC_API MR_AffineXf3f MR_AffineXf3f_translation(const MR_Vector3f *b);
 
MRC_API MR_AffineXf3f MR_AffineXf3f_linear(const MR_Matrix3f *A);
 
MRC_API MR_AffineXf3f MR_AffineXf3f_xfAround(const MR_Matrix3f *A, const MR_Vector3f *stable);
 
MRC_API MR_Vector3f MR_AffineXf3f_call(const MR_AffineXf3f *_this, const MR_Vector3f *x);
 
MRC_API MR_Vector3f MR_AffineXf3f_linearOnly(const MR_AffineXf3f *_this, const MR_Vector3f *x);
 
MRC_API MR_AffineXf3f MR_AffineXf3f_inverse(const MR_AffineXf3f *_this);
 
MRC_API MR_AffineXf3f MR_mul_MR_AffineXf3f(const MR_AffineXf3f *u, const MR_AffineXf3f *v);
 
MRC_API bool MR_equal_MR_AffineXf3f(const MR_AffineXf3f *a, const MR_AffineXf3f *b);
 
MRC_API bool MR_not_equal_MR_AffineXf3f(const MR_AffineXf3f *a, const MR_AffineXf3f *b);
 
MRC_API MR_std_ostream *MR_print_MR_AffineXf3f(MR_std_ostream *s, const MR_AffineXf3f *xf);
 
MRC_API MR_std_istream *MR_input_MR_AffineXf3f(MR_std_istream *s, MR_AffineXf3f *xf);
 
MRC_API MR_AffineXf3d MR_AffineXf3d_DefaultConstruct(void);
 
MRC_API MR_AffineXf3d *MR_AffineXf3d_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_AffineXf3d MR_AffineXf3d_Construct(const MR_Matrix3d *A, const MR_Vector3d *b);
 
MRC_API MR_AffineXf3d MR_AffineXf3d_translation(const MR_Vector3d *b);
 
MRC_API MR_AffineXf3d MR_AffineXf3d_linear(const MR_Matrix3d *A);
 
MRC_API MR_AffineXf3d MR_AffineXf3d_xfAround(const MR_Matrix3d *A, const MR_Vector3d *stable);
 
MRC_API MR_Vector3d MR_AffineXf3d_call(const MR_AffineXf3d *_this, const MR_Vector3d *x);
 
MRC_API MR_Vector3d MR_AffineXf3d_linearOnly(const MR_AffineXf3d *_this, const MR_Vector3d *x);
 
MRC_API MR_AffineXf3d MR_AffineXf3d_inverse(const MR_AffineXf3d *_this);
 
MRC_API MR_AffineXf3d MR_mul_MR_AffineXf3d(const MR_AffineXf3d *u, const MR_AffineXf3d *v);
 
MRC_API bool MR_equal_MR_AffineXf3d(const MR_AffineXf3d *a, const MR_AffineXf3d *b);
 
MRC_API bool MR_not_equal_MR_AffineXf3d(const MR_AffineXf3d *a, const MR_AffineXf3d *b);
 
MRC_API MR_std_ostream *MR_print_MR_AffineXf3d(MR_std_ostream *s, const MR_AffineXf3d *xf);
 
MRC_API MR_std_istream *MR_input_MR_AffineXf3d(MR_std_istream *s, MR_AffineXf3d *xf);
 
#ifdef __cplusplus
} // extern "C"
#endif