diff options
Diffstat (limited to 'kig/objects/conic_types.cpp')
| -rw-r--r-- | kig/objects/conic_types.cpp | 689 |
1 files changed, 689 insertions, 0 deletions
diff --git a/kig/objects/conic_types.cpp b/kig/objects/conic_types.cpp new file mode 100644 index 00000000..be94cf56 --- /dev/null +++ b/kig/objects/conic_types.cpp @@ -0,0 +1,689 @@ +// 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 "conic_types.h" + +#include "bogus_imp.h" +#include "conic_imp.h" +#include "point_imp.h" +#include "circle_imp.h" +#include "line_imp.h" +#include "object_calcer.h" +#include "../misc/conic-common.h" +#include "../misc/common.h" +#include "../kig/kig_commands.h" +#include "../kig/kig_part.h" + +#include <tdelocale.h> + +static const char conic_constructstatement[] = I18N_NOOP( "Construct a conic through this point" ); + +static const struct ArgsParser::spec argsspecConicB5P[] = +{ + { PointImp::stype(), conic_constructstatement, + I18N_NOOP( "Select a point for the new conic to go through..." ), true }, + { PointImp::stype(), conic_constructstatement, + I18N_NOOP( "Select a point for the new conic to go through..." ), true }, + { PointImp::stype(), conic_constructstatement, + I18N_NOOP( "Select a point for the new conic to go through..." ), true }, + { PointImp::stype(), conic_constructstatement, + I18N_NOOP( "Select a point for the new conic to go through..." ), true }, + { PointImp::stype(), conic_constructstatement, + I18N_NOOP( "Select a point for the new conic to go through..." ),true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ConicB5PType ) + +ConicB5PType::ConicB5PType() + : ArgsParserObjectType( "ConicB5P", argsspecConicB5P, 5 ) +{ +} + +ConicB5PType::~ConicB5PType() +{ +} + +ObjectImp* ConicB5PType::calc( const Args& parents, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( parents, 1 ) ) return new InvalidImp; + std::vector<Coordinate> points; + + for ( Args::const_iterator i = parents.begin(); i != parents.end(); ++i ) + points.push_back( static_cast<const PointImp*>( *i )->coordinate() ); + + ConicCartesianData d = + calcConicThroughPoints( points, zerotilt, parabolaifzt, ysymmetry ); + if ( d.valid() ) + return new ConicImpCart( d ); + else return new InvalidImp; +} + +const ConicB5PType* ConicB5PType::instance() +{ + static const ConicB5PType t; + return &t; +} + +static const ArgsParser::spec argsspecConicBAAP[] = +{ + { AbstractLineImp::stype(), I18N_NOOP( "Construct a conic with this asymptote" ), + I18N_NOOP( "Select the first asymptote of the new conic..." ), false }, + { AbstractLineImp::stype(), I18N_NOOP( "Construct a conic with this asymptote" ), + I18N_NOOP( "Select the second asymptote of the new conic..." ), false }, + { PointImp::stype(), I18N_NOOP( "Construct a conic through this point" ), + I18N_NOOP( "Select a point for the new conic to go through..." ), true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ConicBAAPType ) + +ConicBAAPType::ConicBAAPType() + : ArgsParserObjectType( "ConicBAAP", argsspecConicBAAP, 3 ) +{ +} + +ConicBAAPType::~ConicBAAPType() +{ +} + +const ConicBAAPType* ConicBAAPType::instance() +{ + static const ConicBAAPType t; + return &t; +} + +ObjectImp* ConicBAAPType::calc( const Args& parents, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( parents ) ) + return new InvalidImp; + const LineData la = static_cast<const AbstractLineImp*>( parents[0] )->data(); + const LineData lb = static_cast<const AbstractLineImp*>( parents[1] )->data(); + const Coordinate c = static_cast<const PointImp*>( parents[2] )->coordinate(); + + return new ConicImpCart( calcConicByAsymptotes( la, lb, c ) ); +} + +ObjectImp* ConicBFFPType::calc( const Args& parents, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( parents, 2 ) ) return new InvalidImp; + std::vector<Coordinate> cs; + + for ( Args::const_iterator i = parents.begin(); i != parents.end(); ++i ) + cs.push_back( static_cast<const PointImp*>( *i )->coordinate() ); + + return new ConicImpPolar( calcConicBFFP( cs, type() ) ); +} + +ConicBFFPType::ConicBFFPType( const char* fullname, const ArgsParser::spec* spec, int n ) + : ArgsParserObjectType( fullname, spec, n ) +{ +} + +ConicBFFPType::~ConicBFFPType() +{ +} + +static const char constructellipsewithfocusstat[] = + I18N_NOOP( "Construct an ellipse with this focus" ); + +static const ArgsParser::spec argsspecEllipseBFFP[] = +{ + { PointImp::stype(), constructellipsewithfocusstat, + I18N_NOOP( "Select the first focus of the new ellipse..." ), false }, + { PointImp::stype(), constructellipsewithfocusstat, + I18N_NOOP( "Select the second focus of the new ellipse..." ), false }, + { PointImp::stype(), I18N_NOOP( "Construct an ellipse through this point" ), + I18N_NOOP( "Select a point for the new ellipse to go through..." ), true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( EllipseBFFPType ) + +EllipseBFFPType::EllipseBFFPType() + : ConicBFFPType( "EllipseBFFP", argsspecEllipseBFFP, 3 ) +{ +} + +EllipseBFFPType::~EllipseBFFPType() +{ +} + +int EllipseBFFPType::type() const +{ + return 1; +} + +const EllipseBFFPType* EllipseBFFPType::instance() +{ + static const EllipseBFFPType t; + return &t; +} + +static const char constructhyperbolawithfocusstat[] = + I18N_NOOP( "Construct a hyperbola with this focus" ); + +static const ArgsParser::spec argsspecHyperbolaBFFP[] = +{ + { PointImp::stype(), constructhyperbolawithfocusstat, + I18N_NOOP( "Select the first focus of the new hyperbola..." ), false }, + { PointImp::stype(), constructhyperbolawithfocusstat, + I18N_NOOP( "Select the second focus of the new hyperbola..." ), false }, + { PointImp::stype(), I18N_NOOP( "Construct a hyperbola through this point" ), + I18N_NOOP( "Select a point for the new hyperbola to go through..." ), true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( HyperbolaBFFPType ) + +HyperbolaBFFPType::HyperbolaBFFPType() + : ConicBFFPType( "HyperbolaBFFP", argsspecHyperbolaBFFP, 3 ) +{ +} + +HyperbolaBFFPType::~HyperbolaBFFPType() +{ +} + +const HyperbolaBFFPType* HyperbolaBFFPType::instance() +{ + static const HyperbolaBFFPType t; + return &t; +} + +int HyperbolaBFFPType::type() const +{ + return -1; +} + +const ConicBDFPType* ConicBDFPType::instance() +{ + static const ConicBDFPType t; + return &t; +} + +static const struct ArgsParser::spec argsspecConicBDFP[] = +{ + { AbstractLineImp::stype(), I18N_NOOP( "Construct a conic with this line as directrix" ), + I18N_NOOP( "Select the directrix of the new conic..." ), false }, + { PointImp::stype(), I18N_NOOP( "Construct a conic with this point as focus" ), + I18N_NOOP( "Select the focus of the new conic..." ), false }, + { PointImp::stype(), I18N_NOOP( "Construct a conic through this point" ), + I18N_NOOP( "Select a point for the new conic to go through..." ), true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ConicBDFPType ) + +ConicBDFPType::ConicBDFPType() + : ArgsParserObjectType( "ConicBDFP", argsspecConicBDFP, 3 ) +{ +} + +ConicBDFPType::~ConicBDFPType() +{ +} + +ObjectImp* ConicBDFPType::calc( const Args& parents, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( parents, 2 ) ) return new InvalidImp; + + const LineData line = static_cast<const AbstractLineImp*>( parents[0] )->data(); + const Coordinate focus = + static_cast<const PointImp*>( parents[1] )->coordinate(); + + Coordinate point; + if ( parents.size() == 3 ) + point = static_cast<const PointImp*>( parents[2] )->coordinate(); + else + { + /* !!!! costruisci point come punto medio dell'altezza tra fuoco e d. */ + Coordinate ba = line.dir(); + Coordinate fa = focus - line.b; + double balsq = ba.x*ba.x + ba.y*ba.y; + double scal = (fa.x*ba.x + fa.y*ba.y)/balsq; + point = 0.5*(line.a + focus + scal*ba); + }; + return new ConicImpPolar( calcConicBDFP( line, focus, point ) ); +} + +static const char constructparabolathroughpointstat[] = + I18N_NOOP( "Construct a parabola through this point" ); + +static const ArgsParser::spec argsspecParabolaBTP[] = +{ + { PointImp::stype(), constructparabolathroughpointstat, + I18N_NOOP( "Select a point for the new parabola to go through..." ), true }, + { PointImp::stype(), constructparabolathroughpointstat, + I18N_NOOP( "Select a point for the new parabola to go through..." ), true }, + { PointImp::stype(), constructparabolathroughpointstat, + I18N_NOOP( "Select a point for the new parabola to go through..." ), true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ParabolaBTPType ) + +ParabolaBTPType::ParabolaBTPType() + : ArgsParserObjectType( "ParabolaBTP", argsspecParabolaBTP, 3 ) +{ +} + +ParabolaBTPType::~ParabolaBTPType() +{ +} + +const ParabolaBTPType* ParabolaBTPType::instance() +{ + static const ParabolaBTPType t; + return &t; +} + +ObjectImp* ParabolaBTPType::calc( const Args& parents, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( parents, 2 ) ) return new InvalidImp; + + std::vector<Coordinate> points; + for ( Args::const_iterator i = parents.begin(); i != parents.end(); ++i ) + points.push_back( static_cast<const PointImp*>( *i )->coordinate() ); + + ConicCartesianData d = + calcConicThroughPoints( points, zerotilt, parabolaifzt, ysymmetry ); + if ( d.valid() ) + return new ConicImpCart( d ); + else + return new InvalidImp; +} + +static const ArgsParser::spec argsspecConicPolarPoint[] = +{ + { ConicImp::stype(), I18N_NOOP( "Construct a polar point wrt. this conic" ), + I18N_NOOP( "Select the conic wrt. which you want to construct a polar point..." ), false }, + { AbstractLineImp::stype(), I18N_NOOP( "Construct the polar point of this line" ), + I18N_NOOP( "Select the line of which you want to construct the polar point..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ConicPolarPointType ) + +ConicPolarPointType::ConicPolarPointType() + : ArgsParserObjectType( "ConicPolarPoint", argsspecConicPolarPoint, 2 ) +{ +} + +ConicPolarPointType::~ConicPolarPointType() +{ +} + +const ConicPolarPointType* ConicPolarPointType::instance() +{ + static const ConicPolarPointType t; + return &t; +} + +ObjectImp* ConicPolarPointType::calc( const Args& parents, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp; + + const ConicCartesianData c = static_cast<const ConicImp*>( parents[0] )->cartesianData(); + const LineData l = static_cast<const AbstractLineImp*>( parents[1] )->data(); + const Coordinate p = calcConicPolarPoint( c, l ); + if ( p.valid() ) return new PointImp( p ); + else return new InvalidImp; +} + +static const ArgsParser::spec argsspecConicPolarLine[] = +{ + { ConicImp::stype(), I18N_NOOP( "Construct a polar line wrt. this conic" ), + I18N_NOOP( "Select the conic wrt. which you want to construct a polar point..." ), false }, + { PointImp::stype(), I18N_NOOP( "Construct the polar line of this point" ), + I18N_NOOP( "Select the line of which you want to construct the polar point..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ConicPolarLineType ) + +ConicPolarLineType::ConicPolarLineType() + : ArgsParserObjectType( "ConicPolarLine", argsspecConicPolarLine, 2 ) +{ +} + +ConicPolarLineType::~ConicPolarLineType() +{ +} + +const ConicPolarLineType* ConicPolarLineType::instance() +{ + static const ConicPolarLineType t; + return &t; +} + +ObjectImp* ConicPolarLineType::calc( const Args& parents, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp; + + const ConicCartesianData c = static_cast<const ConicImp*>( parents[0] )->cartesianData(); + const Coordinate p = static_cast<const PointImp*>( parents[1] )->coordinate(); + bool valid = true; + const LineData l = calcConicPolarLine( c, p, valid ); + if ( valid ) return new LineImp( l ); + else return new InvalidImp; +} + +static const ArgsParser::spec argsspecConicDirectrix[] = +{ + { ConicImp::stype(), I18N_NOOP( "Construct the directrix of this conic" ), + I18N_NOOP( "Select the conic of which you want to construct the directrix..." ), false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ConicDirectrixType ) + +ConicDirectrixType::ConicDirectrixType() + : ArgsParserObjectType( "ConicDirectrix", argsspecConicDirectrix, 1 ) +{ +} + +ConicDirectrixType::~ConicDirectrixType() +{ +} + +const ConicDirectrixType* ConicDirectrixType::instance() +{ + static const ConicDirectrixType t; + return &t; +} + +ObjectImp* ConicDirectrixType::calc( const Args& parents, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp; + + const ConicPolarData data = + static_cast<const ConicImp*>( parents[0] )->polarData(); + + double ec = data.ecostheta0; + double es = data.esintheta0; + double eccsq = ec*ec + es*es; + + Coordinate a = data.focus1 - data.pdimen/eccsq*Coordinate(ec,es); + Coordinate b = a + Coordinate(-es,ec); + return new LineImp( a, b ); +} + +static const char hyperbolatpstatement[] = I18N_NOOP( "Construct a hyperbola through this point" ); + +static const ArgsParser::spec argsspecHyperbolaB4P[] = +{ + { PointImp::stype(), hyperbolatpstatement, + I18N_NOOP( "Select a point for the new hyperbola to go through..." ), true }, + { PointImp::stype(), hyperbolatpstatement, + I18N_NOOP( "Select a point for the new hyperbola to go through..." ), true }, + { PointImp::stype(), hyperbolatpstatement, + I18N_NOOP( "Select a point for the new hyperbola to go through..." ), true }, + { PointImp::stype(), hyperbolatpstatement, + I18N_NOOP( "Select a point for the new hyperbola to go through..." ), true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( EquilateralHyperbolaB4PType ) + +EquilateralHyperbolaB4PType::EquilateralHyperbolaB4PType() + : ArgsParserObjectType( "EquilateralHyperbolaB4P", argsspecHyperbolaB4P, 4 ) +{ +} + +EquilateralHyperbolaB4PType::~EquilateralHyperbolaB4PType() +{ +} + +const EquilateralHyperbolaB4PType* EquilateralHyperbolaB4PType::instance() +{ + static const EquilateralHyperbolaB4PType t; + return &t; +} + +ObjectImp* EquilateralHyperbolaB4PType::calc( const Args& parents, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( parents, 1 ) ) return new InvalidImp; + + std::vector<Coordinate> pts; + for ( Args::const_iterator i = parents.begin(); i != parents.end(); ++i ) + pts.push_back( static_cast<const PointImp*>( *i )->coordinate() ); + + ConicCartesianData d = calcConicThroughPoints( pts, equilateral ); + if ( d.valid() ) + return new ConicImpCart( d ); + else + return new InvalidImp; +} + +static const ArgsParser::spec argsspecParabolaBDP[] = +{ + { AbstractLineImp::stype(), I18N_NOOP( "Construct a parabola with this directrix" ), + I18N_NOOP( "Select the directrix of the new parabola..." ), false }, + { PointImp::stype(), I18N_NOOP( "Construct a parabola with this focus" ), + I18N_NOOP( "Select the focus of the new parabola..." ), true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ParabolaBDPType ) + +ParabolaBDPType::ParabolaBDPType() + : ObjectLPType( "ParabolaBDP", argsspecParabolaBDP, 2 ) +{ +} + +ParabolaBDPType::~ParabolaBDPType() +{ +} + +const ParabolaBDPType* ParabolaBDPType::instance() +{ + static const ParabolaBDPType t; + return &t; +} + +ObjectImp* ParabolaBDPType::calc( const LineData& l, const Coordinate& c ) const +{ + ConicPolarData ret; + Coordinate ldir = l.dir(); + ldir = ldir.normalize(); + ret.focus1 = c; + ret.ecostheta0 = - ldir.y; + ret.esintheta0 = ldir.x; + Coordinate fa = c - l.a; + ret.pdimen = fa.y*ldir.x - fa.x*ldir.y; + ConicImpPolar* r = new ConicImpPolar( ret ); + kdDebug() << k_funcinfo << r->conicTypeString() << endl; + return r; +} + +static const ArgsParser::spec argsspecConicAsymptote[] = +{ + { ConicImp::stype(), I18N_NOOP( "Construct the asymptotes of this conic" ), + I18N_NOOP( "Select the conic of which you want to construct the asymptotes..." ), false }, + { IntImp::stype(), "param", "SHOULD NOT BE SEEN", false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ConicAsymptoteType ) + +ConicAsymptoteType::ConicAsymptoteType() + : ArgsParserObjectType( "ConicAsymptote", argsspecConicAsymptote, 2 ) +{ +} + +ConicAsymptoteType::~ConicAsymptoteType() +{ +} + +const ConicAsymptoteType* ConicAsymptoteType::instance() +{ + static const ConicAsymptoteType t; + return &t; +} + +ObjectImp* ConicAsymptoteType::calc( const Args& parents, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp; + + bool valid = true; + const LineData ret = calcConicAsymptote( + static_cast<const ConicImp*>( parents[0] )->cartesianData(), + static_cast<const IntImp*>( parents[1] )->data(), + valid ); + + if ( valid ) + return new LineImp( ret ); + else + return new InvalidImp; +} + +static const char radicallinesstatement[] = I18N_NOOP( "Construct the radical lines of this conic" ); + +static const ArgsParser::spec argsspecConicRadical[] = +{ + { ConicImp::stype(), radicallinesstatement, + I18N_NOOP( "Select the first of the two conics of which you want to construct the radical line..." ), false }, + { ConicImp::stype(), radicallinesstatement, + I18N_NOOP( "Select the other of the two conic of which you want to construct the radical line..." ), false }, + { IntImp::stype(), "param", "SHOULD NOT BE SEEN", false }, + { IntImp::stype(), "param", "SHOULD NOT BE SEEN", false } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ConicRadicalType ) + +ConicRadicalType::ConicRadicalType() + : ArgsParserObjectType( "ConicRadical", argsspecConicRadical, 4 ) +{ +} + +const ConicRadicalType* ConicRadicalType::instance() +{ + static const ConicRadicalType t; + return &t; +} + +ObjectImp* ConicRadicalType::calc( const Args& parents, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp; + if ( parents[0]->inherits( CircleImp::stype() ) && + parents[1]->inherits( CircleImp::stype() ) ) + { + if( static_cast<const IntImp*>( parents[2] )->data() != 1 ) + return new InvalidImp; + else + { + const CircleImp* c1 = static_cast<const CircleImp*>( parents[0] ); + const CircleImp* c2 = static_cast<const CircleImp*>( parents[1] ); + const Coordinate a = calcCircleRadicalStartPoint( + c1->center(), c2->center(), c1->squareRadius(), c2->squareRadius() + ); + return new LineImp( a, calcPointOnPerpend( + LineData( c1->center(), c2->center() ), a ) ); + }; + } + else + { + bool valid = true; + const LineData l = calcConicRadical( + static_cast<const ConicImp*>( parents[0] )->cartesianData(), + static_cast<const ConicImp*>( parents[1] )->cartesianData(), + static_cast<const IntImp*>( parents[2] )->data(), + static_cast<const IntImp*>( parents[3] )->data(), valid ); + if ( valid ) + return new LineImp( l ); + else + return new InvalidImp; + }; +} + +ConicRadicalType::~ConicRadicalType() +{ +} + +const ObjectImpType* ConicB5PType::resultId() const +{ + return ConicImp::stype(); +} + +const ObjectImpType* ConicBAAPType::resultId() const +{ + return ConicImp::stype(); +} + +const ObjectImpType* ConicBFFPType::resultId() const +{ + return ConicImp::stype(); +} + +const ObjectImpType* ConicBDFPType::resultId() const +{ + return ConicImp::stype(); +} + +const ObjectImpType* ParabolaBTPType::resultId() const +{ + return ConicImp::stype(); +} + +const ObjectImpType* EquilateralHyperbolaB4PType::resultId() const +{ + return ConicImp::stype(); +} + +const ObjectImpType* ConicPolarPointType::resultId() const +{ + return PointImp::stype(); +} + +const ObjectImpType* ConicPolarLineType::resultId() const +{ + return LineImp::stype(); +} + +const ObjectImpType* ConicDirectrixType::resultId() const +{ + return LineImp::stype(); +} + +const ObjectImpType* ParabolaBDPType::resultId() const +{ + return ConicImp::stype(); +} + +const ObjectImpType* ConicAsymptoteType::resultId() const +{ + return LineImp::stype(); +} + +const ObjectImpType* ConicRadicalType::resultId() const +{ + return LineImp::stype(); +} + +TQStringList ConicRadicalType::specialActions() const +{ + TQStringList ret; + ret << i18n( "Switch Radical Lines" ); + return ret; +} + +void ConicRadicalType::executeAction( int i, ObjectHolder&, ObjectTypeCalcer& t, + KigPart& d, KigWidget&, NormalMode& ) const +{ + assert( i == 0 ); + std::vector<ObjectCalcer*> parents = t.parents(); + assert( dynamic_cast<ObjectConstCalcer*>( parents[3] ) ); + ObjectConstCalcer* zeroindexo = static_cast<ObjectConstCalcer*>( parents[3] ); + MonitorDataObjects mon( zeroindexo ); + assert( zeroindexo->imp()->inherits( IntImp::stype() ) ); + int oldzeroindex = static_cast<const IntImp*>( zeroindexo->imp() )->data(); + int newzeroindex = oldzeroindex % 3 + 1; + zeroindexo->setImp( new IntImp( newzeroindex ) ); + KigCommand* kc = new KigCommand( d, "Switch Conic Radical Lines" ); + mon.finish( kc ); + d.history()->addCommand( kc ); +} + |