matrix_2d.h

Go to the documentation of this file.

// -*-c++-*-
 
/*
 *Copyright:
 
 Copyright (C) Hidehisa Akiyama
 
 This code is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 3 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 *EndCopyright:
 */
 
 
#ifndef RCSC_GEOM_MATRIX2D_H
#define RCSC_GEOM_MATRIX2D_H
 
#include <rcsc/geom/vector_2d.h>
#include <rcsc/geom/angle_deg.h>
 
#include <iostream>
#include <cmath>
 
namespace rcsc {
 
class Matrix2D {
private:
 
    double M_11; 
    double M_12; 
    double M_21; 
    double M_22; 
    double M_dx; 
    double M_dy; 
 
public:
 
    Matrix2D()
        : M_11( 1.0 ),
          M_12( 0.0 ),
          M_21( 0.0 ),
          M_22( 1.0 ),
          M_dx( 0.0 ),
          M_dy( 0.0 )
      { }
 
    Matrix2D( const double m11, const double m12,
              const double m21, const double m22,
              const double dx, const double dy )
        : M_11( m11 ), M_12( m12 ),
          M_21( m21 ), M_22( m22 ),
          M_dx( dx ),  M_dy( dy )
      { }
 
    const Matrix2D & reset()
      {
          M_11 = M_22 = 1.0;
          M_12 = M_21 = M_dx = M_dy = 0.0;
          return *this;
      }
 
    const Matrix2D & assign( const double m11, const double m12,
                             const double m21, const double m22,
                             const double dx, const double dy )
      {
          M_11 = m11; M_12 = m12;
          M_21 = m21; M_22 = m22;
          M_dx = dx;  M_dy = dy;
          return *this;
      }
 
    static
    Matrix2D make_translation( const double dx,
                               const double dy )
      {
          return Matrix2D( 1.0, 0.0,
                           0.0, 1.0,
                           dx, dy );
      }
 
    static
    Matrix2D make_scaling( const double sx,
                           const double sy )
      {
          return Matrix2D( sx, 0.0,
                           0.0, sy,
                           0.0, 0.0 );
      }
 
    static
    Matrix2D make_rotation( const AngleDeg & angle )
      {
          double cosa = angle.cos();
          double sina = angle.sin();
          return Matrix2D( cosa, -sina,
                           sina, cosa,
                           0.0, 0.0 );
      }
 
    double m11() const
      {
          return M_11;
      }
 
    double m12() const
      {
          return M_12;
      }
 
    double m21() const
      {
          return M_21;
      }
 
    double m22() const
      {
          return M_22;
      }
 
    double dx() const
      {
          return M_dx;
      }
 
    double dy() const
      {
          return M_dy;
      }
 
    double det() const
      {
          return M_11*M_22 - M_12*M_21;
      }
 
    bool invertible() const
      {
          return ! ( std::fabs( det() ) < 0.00000000001 );
      }
 
    Matrix2D inverted() const;
 
    Matrix2D & translate( const double dx,
                          const double dy )
      {
          // translation matrix
          // T = ( 1, 0, dx )
          //     ( 0, 1, dy )
          //     ( 0, 0,  1 )
 
          /*
          // this = this * T
          M_dx += M_11*dx + M_12*dy;
          M_dy += M_21*dx + M_22*dy;
          */
 
          // this = T * this
          // *this = make_translation(dx,dy) * *this;
 
          M_dx += dx;
          M_dy += dy;
          return *this;
      }
 
    Matrix2D & scale( const double sx,
                      const double sy )
      {
          // scaling matrixa
          // S = ( Sx,  0, 0 )
          //     (  0, Sy, 0 )
          //     (  0,  0, 1 )
 
          /*
            this = this * S
            *this *= make_scaling(sx,sy)
            M_11 *= sx; M_12 *= sy;
            M_21 *= sx; M_22 *= sy;
          */
 
          // this = S * this
          // *this = make_scaling(sx,sy) * *this;
 
          M_11 *= sx; M_12 *= sx; M_dx *= sx;
          M_21 *= sy; M_22 *= sy; M_dy *= sy;
          return *this;
      }
 
    /*
    Matrix2D & shear( const double sh,
                      const double sv )
      {
          double tm11 = sv * M_21;
          double tm12 = sv * M_22;
          double tm21 = sh * M_11;
          double tm22 = sh * M_12;
          M_11 += tm11; M_12 += tm12;
          M_21 += tm21; M_22 += tm22;
          return *this;
      }
    */
 
    Matrix2D & rotate( const AngleDeg & angle );
 
    const Matrix2D & operator*=( const Matrix2D & m )
      {
          double tm11 = M_11*m.M_11 + M_12*m.M_21;
          double tm12 = M_11*m.M_12 + M_12*m.M_22;
          double tm21 = M_21*m.M_11 + M_22*m.M_21;
          double tm22 = M_21*m.M_12 + M_22*m.M_22;
 
          double tdx  = M_11*m.M_dx + M_12*m.M_dy + M_dx;
          double tdy =  M_21*m.M_dx + M_22*m.M_dy + M_dy;
 
          M_11 = tm11; M_12 = tm12;
          M_21 = tm21; M_22 = tm22;
          M_dx = tdx; M_dy = tdy;
          return *this;
      }
 
    Vector2D transform( const Vector2D & v ) const
      {
          return Vector2D( M_11*v.x + M_12*v.y + M_dx,
                           M_21*v.x + M_22*v.y + M_dy );
      }
 
    Vector2D transform( const double x,
                        const double y ) const
      {
          return Vector2D( M_11*x + M_12*y + M_dx,
                           M_21*x + M_22*y + M_dy );
      }
 
    void transform( Vector2D * v ) const
      {
          double tx = M_11*v->x + M_12*v->y + M_dx;
          double ty = M_21*v->x + M_22*v->y + M_dy;
          v->assign( tx, ty );
      }
 
#if 0
    Segment2D transform( const Segment2D & s ) const
      {
          return Segment2D( transform( s.a() ),
                            transform( s.b() ) );
      }
 
    /*
      Line2D transform( const Line2D & l ) const
      {
      }
     */
 
    Rai2D transform( const Ray2D & r ) const
      {
          return Ray2D( transform( r.origin() ),
                        transform( r.origin() + Vector2D::polar2vector( 1.0, r.dir() ) ) );
      }
 
    Circle2D transform( const Circle2D & c ) const
      {
          return Circle2D( transform( c.center() ),
                           c.radius() );
      }
 
    /*
    Sector2D transform( const Sector2D & s ) const
      {
 
      }
    */
 
    Triangle2D transform( const Triangle2D & t ) const
      {
          return Triangle2D( transform( t.a() ),
                             transform( t.b() ),
                             transform( t.c() ) );
      }
#endif
 
    std::ostream & print( std::ostream & os ) const
      {
          os << M_11 << ' '
             << M_12 << ' '
             << M_21 << ' '
             << M_22 << ' '
             << M_dx << ' '
             << M_dy;
          return os;
      }
 
};
 
}
 
inline
const
rcsc::Matrix2D
operator*( const rcsc::Matrix2D & lhs,
           const rcsc::Matrix2D & rhs )
{
    return rcsc::Matrix2D( lhs ) *= rhs;
}
 
inline
rcsc::Vector2D
operator*( const rcsc::Matrix2D & lhs,
           const rcsc::Vector2D & rhs )
{
    return lhs.transform( rhs );
}
 
inline
std::ostream &
operator<<( std::ostream & os,
            const rcsc::Matrix2D & m )
{
    return m.print( os );
}
 
 
#endif