You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
191 lines
6.9 KiB
191 lines
6.9 KiB
/**
|
|
This file is part of Kig, a KDE program for Interactive Geometry...
|
|
Copyright (C) 2002 Maurizio Paolini <paolini@dmf.unicatt.it>
|
|
Copyright (C) 2003 Dominique Devriese <devriese@kde.org>
|
|
|
|
This program is free software; you can redistribute it 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 program 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 program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
|
|
USA
|
|
**/
|
|
|
|
#ifndef KIG_MISC_KIGTRANSFORM_H
|
|
#define KIG_MISC_KIGTRANSFORM_H
|
|
|
|
#include "coordinate.h"
|
|
#include <vector>
|
|
|
|
class LineData;
|
|
|
|
/**
|
|
* Class representing a transformation. More specifically, this class
|
|
* represents a pretty generic 2-dimensional transformation. Various
|
|
* common transformations can be used. Construct a Transformation by
|
|
* using one of its static members, and use it either with its
|
|
* Transformation::apply method, or the ObjectImp::transform method.
|
|
*/
|
|
class Transformation
|
|
{
|
|
double mdata[3][3];
|
|
bool mIsHomothety;
|
|
bool mIsAffine;
|
|
Transformation();
|
|
public:
|
|
~Transformation();
|
|
Transformation( double data[3][3], bool ishomothety );
|
|
|
|
/**
|
|
* Apply this Tranformation. Apply this transformation to the
|
|
* Coordinate c. Can return an invalid Coordinate.
|
|
* apply0 assumes that c indicates a point at infinity, having
|
|
* [0, c.x, c.y] as homogeneous coordinates
|
|
*/
|
|
const Coordinate apply( const double x0, const double x1, const double x2 ) const;
|
|
const Coordinate apply( const Coordinate& c ) const;
|
|
const Coordinate apply0( const Coordinate& c ) const;
|
|
|
|
/**
|
|
* Returns whether this is a homothetic (affine) transformation.
|
|
*/
|
|
bool isHomothetic() const;
|
|
bool isAffine() const;
|
|
double getProjectiveIndicator( const Coordinate& c ) const;
|
|
double getAffineDeterminant() const;
|
|
double getRotationAngle() const;
|
|
const Coordinate apply2by2only( const Coordinate& c ) const;
|
|
/**
|
|
* \ifnot creating-python-scripting-doc
|
|
* a homothetic transformation maintains the ratio's of lengths.
|
|
* This means that every length is multiplied by a fixed number when
|
|
* it is projected... This function does that calculation for
|
|
* you..
|
|
* \endif
|
|
*/
|
|
double apply( double length ) const;
|
|
double data( int r, int c ) const;
|
|
/**
|
|
* The inverse Transformation. Returns the inverse Transformation
|
|
* of this Transformation.
|
|
*/
|
|
const Transformation inverse( bool& valid ) const;
|
|
|
|
/**
|
|
* Identity. Returns the Identity Transformation, i.e. a
|
|
* Transformation that doesn't do anything.
|
|
*/
|
|
static const Transformation identity();
|
|
/**
|
|
* Scaling over Point. Returns a Transformation that scales points
|
|
* by a certain factor with relation to a center point.
|
|
*/
|
|
static const Transformation scalingOverPoint( double factor, const Coordinate& center = Coordinate() );
|
|
/**
|
|
* Scaling over Line. Returns a Transformation that scales points
|
|
* by a certain factor with relation to a line. Note: This is not a
|
|
* homothetic transformation.
|
|
*/
|
|
static const Transformation scalingOverLine( double factor, const LineData& l );
|
|
/**
|
|
* Translation. Returns a Translation by a vector c.
|
|
*/
|
|
static const Transformation translation( const Coordinate& c );
|
|
/**
|
|
* Rotation. Returns a Rotation by a certain angle, around a
|
|
* certain center.
|
|
*/
|
|
static const Transformation rotation( double angle, const Coordinate& center = Coordinate() );
|
|
/**
|
|
* Point Reflection. Returns a reflection over a point
|
|
* \note This equals scaling( -1, c );
|
|
*/
|
|
static const Transformation pointReflection( const Coordinate& c );
|
|
/**
|
|
* Line Reflection. Returns a reflection over a line
|
|
* \note This equals scaling( -1, l );
|
|
*/
|
|
static const Transformation lineReflection( const LineData& l );
|
|
/**
|
|
* Harmonic Homology. Returns a Transformation that transforms points in
|
|
* such a way that it appears to cast a shadow, given a certain
|
|
* light source (center), and a line (axis) indicating a plane.
|
|
*/
|
|
static const Transformation harmonicHomology( const Coordinate& center,
|
|
const LineData& axis );
|
|
/**
|
|
* Affinity given the image of 3 points. Returns the unique
|
|
* affinity that transforms 3 given points into 3 given points.
|
|
*/
|
|
static const Transformation affinityGI3P(
|
|
const std::vector<Coordinate>& FromPoints,
|
|
const std::vector<Coordinate>& ToPoints,
|
|
bool& valid );
|
|
/**
|
|
* Projectivity given the image of 4 points. Returns the unique
|
|
* projectivity that transforms 4 given points into 4 given points.
|
|
*/
|
|
static const Transformation projectivityGI4P(
|
|
const std::vector<Coordinate>& FromPoints,
|
|
const std::vector<Coordinate>& ToPoints,
|
|
bool& valid );
|
|
/**
|
|
* Cast Shadow. Returns a Transformation that transforms points in
|
|
* such a way that it appears to cast a shadow, given a certain
|
|
* light source, and a line indicating a plane.
|
|
*/
|
|
static const Transformation castShadow( const Coordinate& ls,
|
|
const LineData& d );
|
|
/**
|
|
* Projective Rotation. This is really only a test example of a
|
|
* projective non-affine transformation...
|
|
*/
|
|
static const Transformation projectiveRotation( double alpha,
|
|
const Coordinate& d,
|
|
const Coordinate& t );
|
|
|
|
/**
|
|
* Similitude. Sequence of a rotation and a scaling with relation
|
|
* to a certain center.
|
|
*/
|
|
static const Transformation similitude(
|
|
const Coordinate& center, double theta, double factor );
|
|
|
|
/**
|
|
* Sequence. This creates a Transformation that executes first
|
|
* transformation b, and then a.
|
|
*/
|
|
friend const Transformation operator*( const Transformation& a, const Transformation& b );
|
|
|
|
/**
|
|
* Equality. Tests two Transformation's for equality.
|
|
*/
|
|
friend bool operator==( const Transformation& lhs, const Transformation& rhs );
|
|
};
|
|
|
|
const Transformation operator*( const Transformation&, const Transformation& );
|
|
bool operator==( const Transformation& lhs, const Transformation& rhs );
|
|
|
|
// enum tWantArgsResult { tComplete, tNotComplete, tNotGood };
|
|
|
|
// Transformation getProjectiveTransformation(
|
|
// int transformationsnum, Object *mtransformations[],
|
|
// bool& valid );
|
|
|
|
// tWantArgsResult WantTransformation ( Objects::const_iterator& i,
|
|
// const Objects& os );
|
|
|
|
// TQString getTransformMessage ( const Objects& os, const Object *o );
|
|
|
|
// bool isHomoteticTransformation ( double transformation[3][3] );
|
|
|
|
#endif // KIG_MISC_KIGTRANSFORM_H
|