kig/objects/intersection_types.cc

   1 // Copyright (C)  2003  Dominique Devriese <devriese@kde.org>
   2
   3 // This program is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU General Public License
   5 // as published by the Free Software Foundation; either version 2
   6 // of the License, or (at your option) any later version.
   7
   8 // This program is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 // GNU General Public License for more details.
  12
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  16 // 02111-1307, USA.
  17
  18 #include "intersection_types.h"
  19
  20 #include "bogus_imp.h"
  21 #include "circle_imp.h"
  22 #include "conic_imp.h"
  23 #include "cubic_imp.h"
  24 #include "line_imp.h"
  25 #include "other_imp.h"
  26 #include "point_imp.h"
  27
  28 #include <klocale.h>
  29
  30 static const char intersectlinestat[] = I18N_NOOP( "Intersect with this line" );
  31
  32 static const ArgsParser::spec argsspecConicLineIntersection[] =
  33 {
  34   { ConicImp::stype(), I18N_NOOP( "Intersect with this conic" ),
  35     "SHOULD NOT BE SEEN", true },
  36   { AbstractLineImp::stype(), intersectlinestat, "SHOULD NOT BE SEEN", true },
  37   { IntImp::stype(), "param", "SHOULD NOT BE SEEN", false }
  38 };
  39
  40 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ConicLineIntersectionType )
  41
  42 ConicLineIntersectionType::ConicLineIntersectionType()
  43   : ArgsParserObjectType( "ConicLineIntersection",
  44                          argsspecConicLineIntersection, 3 )
  45 {
  46 }
  47
  48 ConicLineIntersectionType::~ConicLineIntersectionType()
  49 {
  50 }
  51
  52 const ConicLineIntersectionType* ConicLineIntersectionType::instance()
  53 {
  54   static const ConicLineIntersectionType t;
  55   return &t;
  56 }
  57
  58 ObjectImp* ConicLineIntersectionType::calc( const Args& parents, const KigDocument& ) const
  59 {
  60   if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
  61
  62   int side = static_cast<const IntImp*>( parents[2] )->data();
  63   assert( side == 1 || side == -1 );
  64   const LineData line = static_cast<const AbstractLineImp*>( parents[1] )->data();
  65
  66   Coordinate ret;
  67   if ( parents[0]->inherits( CircleImp::stype() ) )
  68   {
  69     // easy case..
  70     const CircleImp* c = static_cast<const CircleImp*>( parents[0] );
  71     ret = calcCircleLineIntersect(
  72       c->center(), c->squareRadius(), line, side );
  73   }
  74   else
  75   {
  76     // harder case..
  77     ret = calcConicLineIntersect(
  78       static_cast<const ConicImp*>( parents[0] )->cartesianData(),
  79       line, 0.0, side );
  80   }
  81   if ( ret.valid() ) return new PointImp( ret );
  82   else return new InvalidImp;
  83 }
  84
  85 static const ArgsParser::spec argsspecConicLineOtherIntersection[] =
  86 {
  87   { ConicImp::stype(), I18N_NOOP( "Intersect with this conic" ),
  88     "SHOULD NOT BE SEEN", true },
  89   { AbstractLineImp::stype(), intersectlinestat, "SHOULD NOT BE SEEN", true },
  90   { PointImp::stype(), I18N_NOOP( "Already computed intersection point"),
  91     "SHOULD NOT BE SEEN", true }
  92 };
  93
  94 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ConicLineOtherIntersectionType )
  95
  96 ConicLineOtherIntersectionType::ConicLineOtherIntersectionType()
  97   : ArgsParserObjectType( "ConicLineOtherIntersection",
  98                          argsspecConicLineOtherIntersection, 3 )
  99 {
 100 }
 101
 102 ConicLineOtherIntersectionType::~ConicLineOtherIntersectionType()
 103 {
 104 }
 105
 106 const ConicLineOtherIntersectionType* ConicLineOtherIntersectionType::instance()
 107 {
 108   static const ConicLineOtherIntersectionType t;
 109   return &t;
 110 }
 111
 112 ObjectImp* ConicLineOtherIntersectionType::calc( const Args& parents, const KigDocument& ) const
 113 {
 114   if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
 115
 116   Coordinate p = static_cast<const PointImp*>( parents[2] )->coordinate();
 117   const LineData line = static_cast<const AbstractLineImp*>( parents[1] )->data();
 118
 119   Coordinate ret;
 120 //  if ( parents[0]->inherits( CircleImp::stype() ) )
 121 //  {
 122 //    // easy case..
 123 //    const CircleImp* c = static_cast<const CircleImp*>( parents[0] );
 124 //    ret = calcCircleLineIntersect(
 125 //      c->center(), c->squareRadius(), line, side, valid );
 126 //  }
 127 //  else
 128 //  {
 129     // harder case..
 130     double pax = p.x - line.a.x;
 131     double pay = p.y - line.a.y;
 132     double bax = line.b.x - line.a.x;
 133     double bay = line.b.y - line.a.y;
 134     double knownparam = (pax*bax + pay*bay)/(bax*bax + bay*bay);
 135     ret = calcConicLineIntersect(
 136       static_cast<const ConicImp*>( parents[0] )->cartesianData(),
 137       line, knownparam, 0 );
 138 //  }
 139   if ( ret.valid() ) return new PointImp( ret );
 140   else return new InvalidImp;
 141 }
 142
 143 static const ArgsParser::spec argsspecLineLineIntersection[] =
 144 {
 145   { AbstractLineImp::stype(), intersectlinestat, "SHOULD NOT BE SEEN", true },
 146   { AbstractLineImp::stype(), intersectlinestat, "SHOULD NOT BE SEEN", true }
 147 };
 148
 149 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( LineLineIntersectionType )
 150
 151 LineLineIntersectionType::LineLineIntersectionType()
 152   : ArgsParserObjectType( "LineLineIntersection",
 153                          argsspecLineLineIntersection, 2 )
 154 {
 155 }
 156
 157 LineLineIntersectionType::~LineLineIntersectionType()
 158 {
 159 }
 160
 161 const LineLineIntersectionType* LineLineIntersectionType::instance()
 162 {
 163   static const LineLineIntersectionType t;
 164   return &t;
 165 }
 166
 167 ObjectImp* LineLineIntersectionType::calc( const Args& parents, const KigDocument& d ) const
 168 {
 169   if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
 170
 171   Coordinate p =
 172     calcIntersectionPoint(
 173       static_cast<const AbstractLineImp*>( parents[0] )->data(),
 174       static_cast<const AbstractLineImp*>( parents[1] )->data() );
 175   if ( static_cast<const AbstractLineImp*>( parents[0] )->containsPoint( p, d ) &&
 176        static_cast<const AbstractLineImp*>( parents[1] )->containsPoint( p, d ) )
 177     return new PointImp( p );
 178   else return new InvalidImp();
 179 }
 180
 181 static const ArgsParser::spec argsspecLineCubicIntersection[] =
 182 {
 183   { CubicImp::stype(), I18N_NOOP( "Intersect with this cubic curve" ),
 184     "SHOULD NOT BE SEEN", true },
 185   { AbstractLineImp::stype(), intersectlinestat, "SHOULD NOT BE SEEN", true },
 186   { IntImp::stype(), "param", "SHOULD NOT BE SEEN", false }
 187 };
 188
 189 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( LineCubicIntersectionType )
 190
 191 LineCubicIntersectionType::LineCubicIntersectionType()
 192   : ArgsParserObjectType( "LineCubicIntersection",
 193                          argsspecLineCubicIntersection, 3 )
 194 {
 195 }
 196
 197 LineCubicIntersectionType::~LineCubicIntersectionType()
 198 {
 199 }
 200
 201 const LineCubicIntersectionType* LineCubicIntersectionType::instance()
 202 {
 203   static const LineCubicIntersectionType t;
 204   return &t;
 205 }
 206
 207 ObjectImp* LineCubicIntersectionType::calc( const Args& parents, const KigDocument& ) const
 208 {
 209   if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
 210
 211   int which = static_cast<const IntImp*>( parents[2] )->data();
 212   bool valid = true;
 213   const Coordinate c = calcCubicLineIntersect(
 214     static_cast<const CubicImp*>( parents[0] )->data(),
 215     static_cast<const AbstractLineImp*>( parents[1] )->data(),
 216     which, valid );
 217   if ( valid ) return new PointImp( c );
 218   else return new InvalidImp;
 219 }
 220
 221 const ObjectImpType* ConicLineIntersectionType::resultId() const
 222 {
 223   return PointImp::stype();
 224 }
 225
 226 const ObjectImpType* ConicLineOtherIntersectionType::resultId() const
 227 {
 228   return PointImp::stype();
 229 }
 230
 231 const ObjectImpType* LineLineIntersectionType::resultId() const
 232 {
 233   return PointImp::stype();
 234 }
 235
 236 const ObjectImpType* LineCubicIntersectionType::resultId() const
 237 {
 238   return PointImp::stype();
 239 }
 240
 241 static const ArgsParser::spec argsspecCircleCircleIntersection[] =
 242 {
 243   { CircleImp::stype(), I18N_NOOP( "Intersect with this circle" ),
 244     "SHOULD NOT BE SEEN", true },
 245   { CircleImp::stype(), I18N_NOOP( "Intersect with this circle" ),
 246     "SHOULD NOT BE SEEN", true },
 247   { IntImp::stype(), "param", "SHOULD NOT BE SEEN", false }
 248 };
 249
 250 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( CircleCircleIntersectionType )
 251
 252 CircleCircleIntersectionType::CircleCircleIntersectionType()
 253   : ArgsParserObjectType( "CircleCircleIntersection",
 254                          argsspecCircleCircleIntersection, 3 )
 255 {
 256 }
 257
 258 CircleCircleIntersectionType::~CircleCircleIntersectionType()
 259 {
 260 }
 261
 262 const CircleCircleIntersectionType* CircleCircleIntersectionType::instance()
 263 {
 264   static const CircleCircleIntersectionType t;
 265   return &t;
 266 }
 267
 268 ObjectImp* CircleCircleIntersectionType::calc( const Args& parents, const KigDocument& ) const
 269 {
 270   if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
 271
 272   int side = static_cast<const IntImp*>( parents[2] )->data();
 273   assert( side == 1 || side == -1 );
 274   const CircleImp* c1 = static_cast<const CircleImp*>( parents[0] );
 275   const CircleImp* c2 = static_cast<const CircleImp*>( parents[1] );
 276   const Coordinate o1 = c1->center();
 277   const Coordinate o2 = c2->center();
 278   const double r1sq = c1->squareRadius();
 279   const Coordinate a = calcCircleRadicalStartPoint(
 280     o1, o2, r1sq, c2->squareRadius()
 281     );
 282   const LineData line = LineData (a, Coordinate ( a.x -o2.y + o1.y, a.y + o2.x - o1.x ));
 283   Coordinate ret = calcCircleLineIntersect( o1, r1sq, line, side );
 284   if ( ret.valid() ) return new PointImp( ret );
 285   else return new InvalidImp;
 286 }
 287
 288 const ObjectImpType* CircleCircleIntersectionType::resultId() const
 289 {
 290   return PointImp::stype();
 291 }
 292
 293 static const ArgsParser::spec argsspecArcLineIntersection[] =
 294 {
 295   { ArcImp::stype(), I18N_NOOP( "Intersect with this arc" ),
 296     "SHOULD NOT BE SEEN", true },
 297   { AbstractLineImp::stype(), intersectlinestat, "SHOULD NOT BE SEEN", true },
 298   { IntImp::stype(), "param", "SHOULD NOT BE SEEN", false }
 299 };
 300
 301 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ArcLineIntersectionType )
 302
 303 ArcLineIntersectionType::ArcLineIntersectionType()
 304   : ArgsParserObjectType( "ArcLineIntersection",
 305                          argsspecArcLineIntersection, 3 )
 306 {
 307 }
 308
 309 ArcLineIntersectionType::~ArcLineIntersectionType()
 310 {
 311 }
 312
 313 const ArcLineIntersectionType* ArcLineIntersectionType::instance()
 314 {
 315   static const ArcLineIntersectionType t;
 316   return &t;
 317 }
 318
 319 ObjectImp* ArcLineIntersectionType::calc( const Args& parents, const KigDocument& ) const
 320 {
 321   if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
 322
 323   int side = static_cast<const IntImp*>( parents[2] )->data();
 324   assert( side == 1 || side == -1 );
 325   const LineData line = static_cast<const AbstractLineImp*>( parents[1] )->data();
 326
 327   const ArcImp* c = static_cast<const ArcImp*>( parents[0] );
 328   const double r = c->radius();
 329   Coordinate ret = calcArcLineIntersect( c->center(), r*r, c->startAngle(),
 330                                          c->angle(), line, side );
 331   if ( ret.valid() ) return new PointImp( ret );
 332   else return new InvalidImp;
 333 }
 334
 335 const ObjectImpType* ArcLineIntersectionType::resultId() const
 336 {
 337   return PointImp::stype();
 338 }