matrix3x2.h

Go to the documentation of this file.

#ifndef SDK_MATRIX_3X2_H_
#define SDK_MATRIX_3X2_H_
 
#define _USE_MATH_DEFINES
#include <cmath>
#include <float.h>
#include <base/inc/base_types.h>
#include <base/inc/geometry/geometry_base_types.h>
#include "math_const.h"
#include "matrix_base_types.h"
#include "matrix3x3.h"
 
namespace sdk {
 
template <class _SDKMatrix3X2>
class Matrix3X2T : public _SDKMatrix3X2
{
  typedef Matrix3X2T<_SDKMatrix3X2> _MyType;
public:
  typedef _SDKMatrix3X2 SDKMatrix3X2;
  typedef typename SDKMatrix3X2::coordinate_type coordinate_type;
  Matrix3X2T() noexcept
  { 
    SetIdentity();
  }
  Matrix3X2T(const SDKMatrix3X2& m) noexcept
    : SDKMatrix3X2(m)
  {
  }
  Matrix3X2T(const double s11, const double s12,
             const double s21, const double s22,
             const double s31, const double s32) noexcept
  {
    this->_11 = coordinate_type(s11);  this->_12 = coordinate_type(s12);
    this->_21 = coordinate_type(s21);  this->_22 = coordinate_type(s22);
    this->_31 = coordinate_type(s31);  this->_32 = coordinate_type(s32);
  }
 
  void SetIdentity() noexcept
  {
    this->_11 = this->_22 = 1;
    this->_12 = this->_21 = this->_31 = this->_32 = 0;
  }
 
  bool IsIdentity() const noexcept
  {
    if (this->_11 != 1 || this->_22 != 1
      || this->_12 != 0 || this->_21 != 0 || this->_31 != 0 || this->_32 != 0)
      return false;
    return true;
  }
 
  const _MyType& Rotate(double angle_deg, const SDKPointF2D& center) noexcept
  {
    double angle_rad = (angle_deg / 180.0) * kPI;
    using std::sin;
    using std::cos;
    double s = sin(angle_rad);
    double c = cos(angle_rad);
 
    this->_11 = coordinate_type(c);  
    this->_12 = coordinate_type(s);
    this->_21 = coordinate_type(-s); 
    this->_22 = coordinate_type(c);
    this->_31 = coordinate_type(-center.x * (c - 1) + center.y * s);
    this->_32 = coordinate_type(-center.y * (c - 1) - center.x * s);
 
    return *this;
  }
 
  const _MyType& Translate(const float& x, const float& y) noexcept
  {
    this->_11 = 1;  this->_12 = 0;
    this->_21 = 0;  this->_22 = 1;
    this->_31 = x;  this->_32 = y;
 
    return *this;
  }
 
  const _MyType& Scale(const float& scale_x, const float& scale_y) noexcept
  {
    this->_11 = scale_x;  this->_12 = 0.0;
    this->_21 = 0.0;      this->_22 = scale_y;
    this->_31 = 0.0;      this->_32 = 0.0;
 
    return *this;
  }
 
  // NOTE: It's a fake multiplication function, it's impossible to
  // multiply 3X2 matrix to 3X2 matrix, only 3X2 to 2X3
  // But for geometric operations each of 3X2 matrixes can be converted to 3X3
  // and multiplied
  static _MyType Multiply(const SDKMatrix3X2& m1, const SDKMatrix3X2& m2) 
  {
    typedef Matrix3X3T<SDKMatrixD3X3> CMatrix3X3;
    CMatrix3X3 m1_(m1); // Last column will be 0.0, 0.0, 1.0
    CMatrix3X3 m2_(m2); // Last column will be 0.0, 0.0, 1.0
    CMatrix3X3 res = CMatrix3X3::Multiply(m1_, m2_);
    return _MyType(res._11, res._12, res._21, res._22, res._31, res._32);
  }
 
  _MyType& operator=(const SDKMatrix3X2& m) noexcept
  {
    *static_cast<SDKMatrix3X2*>(this) = m;
    return *this;
  }
 
  const SDKMatrix3X2&  get() const noexcept
  {
    return *static_cast<const SDKMatrix3X2*>(this);
  }
 
  // Transforms a point according to this matrix.
  //           / a  b  0 \   / a * x + c * y + tx \ T
  // (x y 1) * | c  d  0 | = | b * x + d * y + ty |
  //           \ tx ty 1 /   \         1          /
  SDKPointD2D Transform(const SDKPointD2D& point) const {
    SDKPointD2D res;
    res.x = this->_11 * point.x + this->_21 * point.y + this->_31;
    res.y = this->_12 * point.x + this->_22 * point.y + this->_32;
    return res;
  }
  SDKPointF2D Transform(const SDKPointF2D& point) const {
    SDKPointD2D point_d = {point.x, point.y};
    SDKPointD2D res_d = Transform(point_d);
    SDKPointF2D res;
    res.x = static_cast<float>(res_d.x);
    res.y = static_cast<float>(res_d.y);
    return res;
  }
  SDKPointI2D Transform(const SDKPointI2D& point) const {
    SDKPointD2D point_d = { static_cast<double>(point.x), 
                            static_cast<double>(point.y) };
    SDKPointD2D res_d = Transform(point_d);
    SDKPointI2D res;
    res.x = RoundToNearest<SDKInt32, double>(res_d.x);
    res.y = RoundToNearest<SDKInt32, double>(res_d.y);
    return res;
  }
  SDKRectD2D Transform(const SDKRectD2D& rect) const {
    SDKPointD2D pt_sw = { rect.x, rect.y };
    SDKPointD2D pt_nw = { rect.x, rect.y + rect.height };
    SDKPointD2D pt_se = { rect.x + rect.width, rect.y };
    SDKPointD2D pt_ne = { rect.x + rect.width,
                          rect.y + rect.height };
    pt_sw = Transform(pt_sw);
    pt_nw = Transform(pt_nw);
    pt_se = Transform(pt_se);
    pt_ne = Transform(pt_ne);
    double min_x = min4dbl(pt_sw.x, pt_nw.x, pt_se.x, pt_ne.x);
    double min_y = min4dbl(pt_sw.y, pt_nw.y, pt_se.y, pt_ne.y);
    double max_x = max4dbl(pt_sw.x, pt_nw.x, pt_se.x, pt_ne.x);
    double max_y = max4dbl(pt_sw.y, pt_nw.y, pt_se.y, pt_ne.y);
    SDKRectD2D res = { min_x, min_y, max_x - min_x, max_y - min_y };
    return res;
  }
  SDKRectF2D Transform(const SDKRectF2D& rect) const {
    SDKRectD2D rect_d = { rect.x, rect.y, rect.width, rect.height };
    SDKRectD2D res_d = Transform(rect_d);
    SDKRectF2D res = { static_cast<float>(res_d.x), static_cast<float>(res_d.y),
      static_cast<float>(res_d.width), static_cast<float>(res_d.height) };
    return res;
  }
  SDKRectI2D Transform(const SDKRectI2D& rect) const {
    SDKRectD2D rect_d = { static_cast<double>(rect.x), 
                          static_cast<double>(rect.y), 
                          static_cast<double>(rect.width), 
                          static_cast<double>(rect.height) };
    SDKRectD2D res_d = Transform(rect_d);
    SDKRect2D res = { RoundToNearest<SDKInt32>(res_d.x),
                      RoundToNearest<SDKInt32>(res_d.y), 
                      RoundToNearest<SDKUInt32>(res_d.width),
                      RoundToNearest<SDKUInt32>(res_d.height) };
    return res;
  }
 
};
 
typedef Matrix3X2T<SDKMatrix3X2> Matrix3X2, CMatrix3X2;
typedef Matrix3X2T<SDKMatrixD3X2> MatrixD3X2, CMatrixD3X2;
typedef Matrix3X2T<SDKMatrixF3X2> MatrixF3X2, CMatrixF3X2;
} // namespace sdk 
 
#endif // SDK_MATRIX_3X2_H_