transformation.hpp

Go to the documentation of this file.

 
/* Copyright (c) 2010-2012,2015 Taneli Kalvas. All rights reserved.
 *
 * You can redistribute this software and/or modify it under the terms
 * of the GNU 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
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this library (file "COPYING" included in the package);
 * if not, write to the Free Software Foundation, Inc., 51 Franklin
 * Street, Fifth Floor, Boston, MA 02110-1301 USA
 * 
 * If you have questions about your rights to use or distribute this
 * software, please contact Berkeley Lab's Technology Transfer
 * Department at TTD@lbl.gov. Other questions, comments and bug
 * reports should be sent directly to the author via email at
 * taneli.kalvas@jyu.fi.
 * 
 * NOTICE. This software was developed under partial funding from the
 * U.S.  Department of Energy.  As such, the U.S. Government has been
 * granted for itself and others acting on its behalf a paid-up,
 * nonexclusive, irrevocable, worldwide license in the Software to
 * reproduce, prepare derivative works, and perform publicly and
 * display publicly.  Beginning five (5) years after the date
 * permission to assert copyright is obtained from the U.S. Department
 * of Energy, and subject to any subsequent five (5) year renewals,
 * the U.S. Government is granted for itself and others acting on its
 * behalf a paid-up, nonexclusive, irrevocable, worldwide license in
 * the Software to reproduce, prepare derivative works, distribute
 * copies to the public, perform publicly and display publicly, and to
 * permit others to do so.
 */
 
#ifndef TRANSFORMATION_HPP
#define TRANSFORMATION_HPP 1
 
 
#include <string.h>
#include "vec3d.hpp"
#include "vec4d.hpp"
 
 
class Transformation
{
 
    double x[16];
 
public:
 
    Transformation();
 
    Transformation( double x11, double x12, double x13, double x14,
                    double x21, double x22, double x23, double x24,
                    double x31, double x32, double x33, double x34,
                    double x41, double x42, double x43, double x44 );
 
    Transformation( const Transformation &m );
 
    Transformation( std::istream &is );
 
    ~Transformation();
 
    double &operator[]( int i ) {
        return( x[i] );
    }
 
    const double &operator[]( int i ) const {
        return( x[i] );
    }
    
    Transformation transpose( void ) const;
 
    double determinant( void ) const;
 
    Transformation inverse( void ) const;
 
    bool operator!=( const Transformation &m ) const;
 
    const Transformation &operator*=( double s );
 
    Transformation operator*( const Transformation &m ) const;
 
    Vec4D operator*( const Vec4D &v ) const;
 
    Vec4D operator%( const Vec4D &v ) const;
 
    Vec4D transform( const Vec4D &xin ) const {
        return( *this * xin );
    }
 
    Vec4D transform_homogenous_point( const Vec3D &xin ) const {
        return( *this * Vec4D( xin[0], xin[1], xin[2], 1.0 ) );
    }
    
    Vec3D transform_point( const Vec3D &xin ) const {
        Vec4D r = *this * Vec4D( xin[0], xin[1], xin[2], 1.0 ); 
        return( Vec3D( r[0], r[1], r[2] ) );
    }
 
    Vec3D inv_transform_point( const Vec3D &xin ) const;
 
    Vec3D transform_vector( const Vec3D &xin ) const {
        Vec4D r = *this * Vec4D( xin[0], xin[1], xin[2], 0.0 ); 
        return( Vec3D( r[0], r[1], r[2] ) );
    }
 
    Vec3D inv_transform_vector( const Vec3D &xin ) const;
 
    void reset( void );
 
    void translate( const Vec3D &d );
 
    void translate_before( const Vec3D &d );
 
    void scale( const Vec3D &s );
 
    void scale_before( const Vec3D &s );
 
    void rotate_x( double a );
 
    void rotate_x_before( double a );
 
    void rotate_y( double a );
 
    void rotate_y_before( double a );
 
    void rotate_z( double a );
 
    void rotate_z_before( double a );
 
    static Transformation unity( void );
 
    static Transformation translation( const Vec3D &d );
 
    static Transformation scaling( const Vec3D &s );
 
    static Transformation rotation_x( double a );
 
    static Transformation rotation_y( double a );
 
    static Transformation rotation_z( double a );
 
    friend std::ostream &operator<<( std::ostream &os, const Transformation &t );
 
    void save( const std::string &filename ) const;
 
    void save( std::ostream &os ) const;
 
    void debug_print( std::ostream &os ) const;
};
 
 
#endif