diff options
Diffstat (limited to 'kig/objects/transform_types.cc')
| -rw-r--r-- | kig/objects/transform_types.cc | 874 |
1 files changed, 874 insertions, 0 deletions
diff --git a/kig/objects/transform_types.cc b/kig/objects/transform_types.cc new file mode 100644 index 00000000..3a8d32db --- /dev/null +++ b/kig/objects/transform_types.cc @@ -0,0 +1,874 @@ +// 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. + +#include "transform_types.h" + +#include "bogus_imp.h" +#include "point_imp.h" +#include "line_imp.h" +#include "other_imp.h" +#include "polygon_imp.h" +#include "../misc/coordinate.h" +#include "../misc/kigtransform.h" + +#include <cmath> + +static const ArgsParser::spec argsspecTranslation[] = +{ + { ObjectImp::stype(), I18N_NOOP("Translate this object"), + I18N_NOOP( "Select the object to translate..." ), false }, + { VectorImp::stype(), I18N_NOOP("Translate by this vector"), + I18N_NOOP( "Select the vector to translate by..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( TranslatedType ) + +TranslatedType::TranslatedType() + : ArgsParserObjectType( "Translation", argsspecTranslation, 2 ) +{ +} + +TranslatedType::~TranslatedType() +{ +} + +const TranslatedType* TranslatedType::instance() +{ + static const TranslatedType t; + return &t; +} + +ObjectImp* TranslatedType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + Coordinate dir = static_cast<const VectorImp*>( args[1] )->dir(); + Transformation t = Transformation::translation( dir ); + + return args[0]->transform( t ); +} + +static const ArgsParser::spec argsspecPointReflection[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Reflect this object" ), + I18N_NOOP( "Select the object to reflect..." ), false }, + { PointImp::stype(), I18N_NOOP( "Reflect in this point" ), + I18N_NOOP( "Select the point to reflect in..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( PointReflectionType ) + +PointReflectionType::PointReflectionType() + : ArgsParserObjectType( "PointReflection", argsspecPointReflection, 2 ) +{ +} + +PointReflectionType::~PointReflectionType() +{ +} + +const PointReflectionType* PointReflectionType::instance() +{ + static const PointReflectionType t; + return &t; +} + +ObjectImp* PointReflectionType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + Coordinate center = static_cast<const PointImp*>( args[1] )->coordinate(); + Transformation t = Transformation::pointReflection( center ); + + return args[0]->transform( t ); +} + +static const ArgsParser::spec argsspecLineReflection[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Reflect this object" ), + I18N_NOOP( "Select the object to reflect..." ), false }, + { AbstractLineImp::stype(), I18N_NOOP( "Reflect in this line" ), + I18N_NOOP( "Select the line to reflect in..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( LineReflectionType ) + +LineReflectionType::LineReflectionType() + : ArgsParserObjectType( "LineReflection", argsspecLineReflection, 2 ) +{ +} + +LineReflectionType::~LineReflectionType() +{ +} + +const LineReflectionType* LineReflectionType::instance() +{ + static const LineReflectionType t; + return &t; +} + +ObjectImp* LineReflectionType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + LineData d = static_cast<const AbstractLineImp*>( args[1] )->data(); + Transformation t = Transformation::lineReflection( d ); + + return args[0]->transform( t ); +} + +static const ArgsParser::spec argsspecRotation[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Rotate this object" ), + I18N_NOOP( "Select the object to rotate..." ), false }, + { PointImp::stype(), I18N_NOOP( "Rotate around this point" ), + I18N_NOOP( "Select the center point of the rotation..." ), false }, + { AngleImp::stype(), I18N_NOOP( "Rotate by this angle" ), + I18N_NOOP( "Select the angle of the rotation..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( RotationType ) + +RotationType::RotationType() + : ArgsParserObjectType( "Rotation", argsspecRotation, 3 ) +{ +} + +RotationType::~RotationType() +{ +} + +const RotationType* RotationType::instance() +{ + static const RotationType t; + return &t; +} + +ObjectImp* RotationType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + Coordinate center = static_cast<const PointImp*>( args[1] )->coordinate(); + double angle = static_cast<const AngleImp*>( args[2] )->size(); + + return args[0]->transform( Transformation::rotation( angle, center ) ); +} + +static const ArgsParser::spec argsspecScalingOverCenter[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Scale this object" ), + I18N_NOOP( "Select the object to scale..." ), false }, + { PointImp::stype(), I18N_NOOP( "Scale with this center" ), + I18N_NOOP( "Select the center point of the scaling..." ), false }, + { SegmentImp::stype(), I18N_NOOP( "Scale by the length of this segment" ), + I18N_NOOP( "Select a segment whose length is the factor of the scaling..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ScalingOverCenterType ) + +ScalingOverCenterType::ScalingOverCenterType() + : ArgsParserObjectType( "ScalingOverCenter", argsspecScalingOverCenter, 3 ) +{ +} + +ScalingOverCenterType::~ScalingOverCenterType() +{ +} + +const ScalingOverCenterType* ScalingOverCenterType::instance() +{ + static const ScalingOverCenterType t; + return &t; +} + +ObjectImp* ScalingOverCenterType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + Coordinate center = static_cast<const PointImp*>( args[1] )->coordinate(); + double ratio = static_cast<const SegmentImp*>( args[2] )->length(); + + return args[0]->transform( Transformation::scalingOverPoint( ratio, center ) ); +} + +static const ArgsParser::spec argsspecScalingOverCenter2[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Scale this object" ), + I18N_NOOP( "Select the object to scale..." ), false }, + { PointImp::stype(), I18N_NOOP( "Scale with this center" ), + I18N_NOOP( "Select the center point of the scaling..." ), false }, + { SegmentImp::stype(), I18N_NOOP( "Scale the length of this segment..." ), + I18N_NOOP( "Select the first of two segments whose ratio is the factor of the scaling..." ), false }, + { SegmentImp::stype(), I18N_NOOP( "...to the length of this other segment" ), + I18N_NOOP( "Select the second of two segments whose ratio is the factor of the scaling..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ScalingOverCenter2Type ) + +ScalingOverCenter2Type::ScalingOverCenter2Type() + : ArgsParserObjectType( "ScalingOverCenter2", argsspecScalingOverCenter2, 4 ) +{ +} + +ScalingOverCenter2Type::~ScalingOverCenter2Type() +{ +} + +const ScalingOverCenter2Type* ScalingOverCenter2Type::instance() +{ + static const ScalingOverCenter2Type t; + return &t; +} + +ObjectImp* ScalingOverCenter2Type::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + Coordinate center = static_cast<const PointImp*>( args[1] )->coordinate(); + double ratio = static_cast<const SegmentImp*>( args[3] )->length()/ + static_cast<const SegmentImp*>( args[2] )->length(); + + return args[0]->transform( Transformation::scalingOverPoint( ratio, center ) ); +} + +static const ArgsParser::spec argsspecScalingOverLine[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Scale this object" ), I18N_NOOP( "Select the object to scale" ), false }, + { AbstractLineImp::stype(), I18N_NOOP( "Scale over this line" ), I18N_NOOP( "Select the line to scale over" ), false }, + { SegmentImp::stype(), I18N_NOOP( "Scale by the length of this segment" ), I18N_NOOP( "Select a segment whose length is the factor for the scaling" ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ScalingOverLineType ) + +ScalingOverLineType::ScalingOverLineType() + : ArgsParserObjectType( "ScalingOverLine", argsspecScalingOverLine, 3 ) +{ +} + +ScalingOverLineType::~ScalingOverLineType() +{ +} + +const ScalingOverLineType* ScalingOverLineType::instance() +{ + static const ScalingOverLineType t; + return &t; +} + +ObjectImp* ScalingOverLineType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + LineData line = static_cast<const AbstractLineImp*>( args[1] )->data(); + double ratio = static_cast<const SegmentImp*>( args[2] )->length(); + + return args[0]->transform( Transformation::scalingOverLine( ratio, line ) ); +} + +static const ArgsParser::spec argsspecScalingOverLine2[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Scale this object" ), I18N_NOOP( "Select the object to scale" ), false }, + { AbstractLineImp::stype(), I18N_NOOP( "Scale over this line" ), I18N_NOOP( "Select the line to scale over" ), false }, + { SegmentImp::stype(), I18N_NOOP( "Scale the length of this segment..." ), I18N_NOOP( "Select the first of two segments whose ratio is the factor for the scaling" ), false }, + { SegmentImp::stype(), I18N_NOOP( "...to the length of this segment" ), I18N_NOOP( "Select the second of two segments whose ratio is the factor for the scaling" ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ScalingOverLine2Type ) + +ScalingOverLine2Type::ScalingOverLine2Type() + : ArgsParserObjectType( "ScalingOverLine2", argsspecScalingOverLine2, 4 ) +{ +} + +ScalingOverLine2Type::~ScalingOverLine2Type() +{ +} + +const ScalingOverLine2Type* ScalingOverLine2Type::instance() +{ + static const ScalingOverLine2Type t; + return &t; +} + +ObjectImp* ScalingOverLine2Type::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + LineData line = static_cast<const AbstractLineImp*>( args[1] )->data(); + double ratio = static_cast<const SegmentImp*>( args[3] )->length()/ + static_cast<const SegmentImp*>( args[2] )->length(); + + return args[0]->transform( Transformation::scalingOverLine( ratio, line ) ); +} + +static const ArgsParser::spec argsspecProjectiveRotation[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Projectively rotate this object" ), I18N_NOOP( "Select the object to rotate projectively" ), false }, + { RayImp::stype(), I18N_NOOP( "Projectively rotate with this half-line" ), I18N_NOOP( "Select the half line of the projective rotation that you want to apply to the object" ), false }, + { AngleImp::stype(), I18N_NOOP( "Projectively rotate by this angle" ), I18N_NOOP( "Select the angle of the projective rotation that you want to apply to the object" ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ProjectiveRotationType ) + +ProjectiveRotationType::ProjectiveRotationType() + : ArgsParserObjectType( "ProjectiveRotation", argsspecProjectiveRotation, 3 ) +{ +} + +ProjectiveRotationType::~ProjectiveRotationType() +{ +} + +const ProjectiveRotationType* ProjectiveRotationType::instance() +{ + static const ProjectiveRotationType t; + return &t; +} + +ObjectImp* ProjectiveRotationType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + const RayImp* ray = static_cast<const RayImp*>( args[1] ); + Coordinate c1 = ray->data().a; + Coordinate dir = ray->data().dir().normalize(); + double alpha = static_cast<const AngleImp*>( args[2] )->size(); + + return args[0]->transform( + Transformation::projectiveRotation( alpha, dir, c1 ) ); +} + +static const ArgsParser::spec argsspecHarmonicHomology[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Harmonic Homology of this object" ), + I18N_NOOP( "Select the object to transform..." ), false }, + { PointImp::stype(), I18N_NOOP( "Harmonic Homology with this center" ), + I18N_NOOP( "Select the center point of the harmonic homology..." ), false }, + { AbstractLineImp::stype(), I18N_NOOP( "Harmonic Homology with this axis" ), + I18N_NOOP( "Select the axis of the harmonic homology..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( HarmonicHomologyType ) + +HarmonicHomologyType::HarmonicHomologyType() + : ArgsParserObjectType( "HarmonicHomology", argsspecHarmonicHomology, 3 ) +{ +} + +HarmonicHomologyType::~HarmonicHomologyType() +{ +} + +const HarmonicHomologyType* HarmonicHomologyType::instance() +{ + static const HarmonicHomologyType t; + return &t; +} + +ObjectImp* HarmonicHomologyType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + Coordinate center = static_cast<const PointImp*>( args[1] )->coordinate(); + LineData axis = static_cast<const AbstractLineImp*>( args[2] )->data(); + return args[0]->transform( + Transformation::harmonicHomology( center, axis ) ); +} + +static const ArgsParser::spec argsspecAffinityB2Tr[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Generic affinity of this object" ), + I18N_NOOP( "Select the object to transform..." ), false }, + { PolygonImp::stype3(), I18N_NOOP( "Map this triangle" ), + I18N_NOOP( "Select the triangle that has to be transformed onto a given triangle..." ), false }, + { PolygonImp::stype3(), I18N_NOOP( "onto this other triangle" ), + I18N_NOOP( "Select the triangle that is the image by the affinity of the first triangle..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( AffinityB2TrType ) + +AffinityB2TrType::AffinityB2TrType() + : ArgsParserObjectType( "AffinityB2Tr", argsspecAffinityB2Tr, 3 ) +{ +} + +AffinityB2TrType::~AffinityB2TrType() +{ +} + +const AffinityB2TrType* AffinityB2TrType::instance() +{ + static const AffinityB2TrType t; + return &t; +} + +ObjectImp* AffinityB2TrType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + std::vector<Coordinate> frompoints = static_cast<const PolygonImp*>( args[1] )->points(); + std::vector<Coordinate> topoints = static_cast<const PolygonImp*>( args[2] )->points(); + + bool valid = true; + Transformation t = Transformation::affinityGI3P( frompoints, topoints, + valid ); + + if (valid == false) return new InvalidImp; + return args[0]->transform( t ); +} + +static const ArgsParser::spec argsspecAffinityGI3P[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Generic affinity of this object" ), + I18N_NOOP( "Select the object to transform..." ), false }, + { PointImp::stype(), I18N_NOOP( "First of 3 starting points" ), + I18N_NOOP( "Select the first of the three starting points of the generic affinity..." ), false }, + { PointImp::stype(), I18N_NOOP( "Second of 3 starting points" ), + I18N_NOOP( "Select the second of the three starting points of the generic affinity..." ), false }, + { PointImp::stype(), I18N_NOOP( "Third of 3 starting points" ), + I18N_NOOP( "Select the third of the three starting points of the generic affinity..." ), false }, + { PointImp::stype(), I18N_NOOP( "Transformed position of first point" ), + I18N_NOOP( "Select the first of the three end points of the generic affinity..." ), false }, + { PointImp::stype(), I18N_NOOP( "Transformed position of second point" ), + I18N_NOOP( "Select the second of the three end points of the generic affinity..." ), false }, + { PointImp::stype(), I18N_NOOP( "Transformed position of third point" ), + I18N_NOOP( "Select the third of the three end points of the generic affinity..." ), false }, +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( AffinityGI3PType ) + +AffinityGI3PType::AffinityGI3PType() + : ArgsParserObjectType( "AffinityGI3P", argsspecAffinityGI3P, 7 ) +{ +} + +AffinityGI3PType::~AffinityGI3PType() +{ +} + +const AffinityGI3PType* AffinityGI3PType::instance() +{ + static const AffinityGI3PType t; + return &t; +} + +ObjectImp* AffinityGI3PType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + std::vector<Coordinate> frompoints; + std::vector<Coordinate> topoints; + for ( uint i = 0; i < 3; ++i ) + { + frompoints.push_back( + static_cast<const PointImp*>( args[i+1] )->coordinate() ); + topoints.push_back( + static_cast<const PointImp*>( args[i+4] )->coordinate() ); + } + + bool valid = true; + Transformation t = Transformation::affinityGI3P( frompoints, topoints, + valid ); + + if (valid == false) return new InvalidImp; + return args[0]->transform( t ); +} + +static const ArgsParser::spec argsspecProjectivityB2Qu[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Generic projective transformation of this object" ), + I18N_NOOP( "Select the object to transform..." ), false }, + { PolygonImp::stype4(), I18N_NOOP( "Map this quadrilateral" ), + I18N_NOOP( "Select the quadrilateral that has to be transformed onto a given quadrilateral..." ), false }, + { PolygonImp::stype4(), I18N_NOOP( "onto this other quadrilateral" ), + I18N_NOOP( "Select the quadrilateral that is the image by the projective transformation of the first quadrilateral..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ProjectivityB2QuType ) + +ProjectivityB2QuType::ProjectivityB2QuType() + : ArgsParserObjectType( "ProjectivityB2Qu", argsspecProjectivityB2Qu, 3 ) +{ +} + +ProjectivityB2QuType::~ProjectivityB2QuType() +{ +} + +const ProjectivityB2QuType* ProjectivityB2QuType::instance() +{ + static const ProjectivityB2QuType t; + return &t; +} + +ObjectImp* ProjectivityB2QuType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + std::vector<Coordinate> frompoints = static_cast<const PolygonImp*>( args[1] )->points(); + std::vector<Coordinate> topoints = static_cast<const PolygonImp*>( args[2] )->points(); + + bool valid = true; + Transformation t = Transformation::projectivityGI4P( frompoints, topoints, + valid ); + + if (valid == false) return new InvalidImp; + return args[0]->transform( t ); +} + +static const ArgsParser::spec argsspecProjectivityGI4P[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Generic projective transformation of this object" ), + I18N_NOOP( "Select the object to transform..." ), false }, + { PointImp::stype(), I18N_NOOP( "First of 4 starting points" ), + I18N_NOOP( "Select the first of the four starting points of the generic projectivity..." ), false }, + { PointImp::stype(), I18N_NOOP( "Second of 4 starting points" ), + I18N_NOOP( "Select the second of the four starting points of the generic projectivity..." ), false }, + { PointImp::stype(), I18N_NOOP( "Third of 4 starting points" ), + I18N_NOOP( "Select the third of the four starting points of the generic projectivity..." ), false }, + { PointImp::stype(), I18N_NOOP( "Fourth of 4 starting points" ), + I18N_NOOP( "Select the fourth of the four starting points of the generic projectivity..." ), false }, + { PointImp::stype(), I18N_NOOP( "Transformed position of first point" ), + I18N_NOOP( "Select the first of the four end points of the generic projectivity..." ), false }, + { PointImp::stype(), I18N_NOOP( "Transformed position of second point" ), + I18N_NOOP( "Select the second of the four end points of the generic projectivity..." ), false }, + { PointImp::stype(), I18N_NOOP( "Transformed position of third point" ), + I18N_NOOP( "Select the third of the four end points of the generic projectivity..." ), false }, + { PointImp::stype(), I18N_NOOP( "Transformed position of fourth point" ), + I18N_NOOP( "Select the fourth of the four end points of the generic projectivity..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ProjectivityGI4PType ) + +ProjectivityGI4PType::ProjectivityGI4PType() + : ArgsParserObjectType( "ProjectivityGI4P", argsspecProjectivityGI4P, 9 ) +{ +} + +ProjectivityGI4PType::~ProjectivityGI4PType() +{ +} + +const ProjectivityGI4PType* ProjectivityGI4PType::instance() +{ + static const ProjectivityGI4PType t; + return &t; +} + +ObjectImp* ProjectivityGI4PType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + std::vector<Coordinate> frompoints; + std::vector<Coordinate> topoints; + for ( uint i = 0; i < 4; ++i ) + { + frompoints.push_back( + static_cast<const PointImp*>( args[i+1] )->coordinate() ); + topoints.push_back( + static_cast<const PointImp*>( args[i+5] )->coordinate() ); + } + + bool valid = true; + Transformation t = Transformation::projectivityGI4P( frompoints, topoints, + valid ); + + if (valid == false) return new InvalidImp; + return args[0]->transform( t ); +} + +static const ArgsParser::spec argsspecCastShadow[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Cast the shadow of this object" ), + I18N_NOOP( "Select the object of which you want to construct the shadow..." ), false }, + { PointImp::stype(), I18N_NOOP( "Cast a shadow from this light source" ), + I18N_NOOP( "Select the light source from which the shadow should originate..." ), false }, + { AbstractLineImp::stype(), + I18N_NOOP( "Cast a shadow on the horizon represented by this line" ), + I18N_NOOP( "Select the horizon for the shadow..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( CastShadowType ) + +CastShadowType::CastShadowType() + : ArgsParserObjectType( "CastShadow", argsspecCastShadow, 3 ) +{ +} + +CastShadowType::~CastShadowType() +{ +} + +const CastShadowType* CastShadowType::instance() +{ + static const CastShadowType t; + return &t; +} + +ObjectImp* CastShadowType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + Coordinate lightsrc = static_cast<const PointImp*>( args[1] )->coordinate(); + LineData d = static_cast<const AbstractLineImp*>( args[2] )->data(); + return args[0]->transform( + Transformation::castShadow( lightsrc, d ) ); +} + +const ObjectImpType* TranslatedType::resultId() const +{ + return ObjectImp::stype(); +} + +const ObjectImpType* PointReflectionType::resultId() const +{ + return ObjectImp::stype(); +} + +const ObjectImpType* LineReflectionType::resultId() const +{ + return ObjectImp::stype(); +} + +const ObjectImpType* RotationType::resultId() const +{ + return ObjectImp::stype(); +} + +const ObjectImpType* ScalingOverCenterType::resultId() const +{ + return ObjectImp::stype(); +} + +const ObjectImpType* ScalingOverCenter2Type::resultId() const +{ + return ObjectImp::stype(); +} + +const ObjectImpType* ScalingOverLineType::resultId() const +{ + return ObjectImp::stype(); +} + +const ObjectImpType* ScalingOverLine2Type::resultId() const +{ + return ObjectImp::stype(); +} + +const ObjectImpType* ProjectiveRotationType::resultId() const +{ + return ObjectImp::stype(); +} + +const ObjectImpType* HarmonicHomologyType::resultId() const +{ + return ObjectImp::stype(); +} + +const ObjectImpType* AffinityB2TrType::resultId() const +{ + return ObjectImp::stype(); +} + +const ObjectImpType* AffinityGI3PType::resultId() const +{ + return ObjectImp::stype(); +} + +const ObjectImpType* ProjectivityB2QuType::resultId() const +{ + return ObjectImp::stype(); +} + +const ObjectImpType* ProjectivityGI4PType::resultId() const +{ + return ObjectImp::stype(); +} + +const ObjectImpType* CastShadowType::resultId() const +{ + return ObjectImp::stype(); +} + +bool TranslatedType::isTransform() const +{ + return true; +} + +bool PointReflectionType::isTransform() const +{ + return true; +} + +bool LineReflectionType::isTransform() const +{ + return true; +} + +bool RotationType::isTransform() const +{ + return true; +} + +bool ScalingOverCenterType::isTransform() const +{ + return true; +} + +bool ScalingOverCenter2Type::isTransform() const +{ + return true; +} + +bool ScalingOverLineType::isTransform() const +{ + return true; +} + +bool ScalingOverLine2Type::isTransform() const +{ + return true; +} + +bool ProjectiveRotationType::isTransform() const +{ + return true; +} + +bool HarmonicHomologyType::isTransform() const +{ + return true; +} + +bool AffinityB2TrType::isTransform() const +{ + return true; +} + +bool AffinityGI3PType::isTransform() const +{ + return true; +} + +bool ProjectivityB2QuType::isTransform() const +{ + return true; +} + +bool ProjectivityGI4PType::isTransform() const +{ + return true; +} + +bool CastShadowType::isTransform() const +{ + return true; +} + +static const ArgsParser::spec argsspecApplyTransformation[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Transform this object" ), "SHOULD NOT BE SEEN", false }, + { TransformationImp::stype(), I18N_NOOP( "Transform using this transformation" ), "SHOULD NOT BE SEEN", false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ApplyTransformationObjectType ) + +ApplyTransformationObjectType::ApplyTransformationObjectType() + : ArgsParserObjectType( "ApplyTransformation", argsspecApplyTransformation, 2 ) +{ +} + +ApplyTransformationObjectType::~ApplyTransformationObjectType() +{ +} + +const ApplyTransformationObjectType* ApplyTransformationObjectType::instance() +{ + static const ApplyTransformationObjectType t; + return &t; +} + +ObjectImp* ApplyTransformationObjectType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + return args[0]->transform( static_cast<const TransformationImp*>( args[1] )->data() ); +} + +const ObjectImpType* ApplyTransformationObjectType::resultId() const +{ + return ObjectImp::stype(); +} + +bool ApplyTransformationObjectType::isTransform() const +{ + return true; +} + +bool SimilitudeType::isTransform() const +{ + return true; +} + +const ObjectImpType* SimilitudeType::resultId() const +{ + return ObjectImp::stype(); +} + +const SimilitudeType* SimilitudeType::instance() +{ + static const SimilitudeType t; + return &t; +} + +ObjectImp* SimilitudeType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + Coordinate c = static_cast<const PointImp*>( args[1] )->coordinate(); + Coordinate a = static_cast<const PointImp*>( args[2] )->coordinate(); + Coordinate b = static_cast<const PointImp*>( args[3] )->coordinate(); + a -= c; + b -= c; + double factor = sqrt( b.squareLength()/a.squareLength() ); + double theta = atan2( b.y, b.x ) - atan2( a.y, a.x ); + + return args[0]->transform( Transformation::similitude( c, theta, factor ) ); +} + +SimilitudeType::~SimilitudeType() +{ +} + +static const ArgsParser::spec argsspecSimilitude[] = +{ + { ObjectImp::stype(), I18N_NOOP( "Apply a similitude to this object" ), + I18N_NOOP( "Select the object to transform..." ), false }, + { PointImp::stype(), I18N_NOOP( "Apply a similitude with this center" ), + I18N_NOOP( "Select the center for the similitude..." ), false }, + { PointImp::stype(), I18N_NOOP( "Apply a similitude mapping this point onto another point" ), + I18N_NOOP( "Select the point which the similitude should map onto another point..." ), false }, + { PointImp::stype(), I18N_NOOP( "Apply a similitude mapping a point onto this point" ), + I18N_NOOP( "Select the point onto which the similitude should map the first point..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( SimilitudeType ) + +SimilitudeType::SimilitudeType() + : ArgsParserObjectType( "Similitude", argsspecSimilitude, 4 ) +{ +} |