source/pathtypes.h

   1 /* This file is part of Shapes.
   2  *
   3  * Shapes is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * any later version.
   7  *
   8  * Shapes 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 Shapes.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright 2008, 2009 Henrik Tidefelt
  17  */
  18
  19 #pragma once
  20
  21 #include <cmath>
  22
  23 #include "Shapes_Lang_decls.h"
  24 #include "Shapes_Computation_decls.h"
  25 #include "Shapes_Kernel_decls.h"
  26 #include "Shapes_Concrete_decls.h"
  27 #include "Shapes_Ast_decls.h"
  28
  29 #include "ptrowner.h"
  30 #include "refcount.h"
  31 #include "pdfstructure.h"
  32 #include "shapesvalue.h"
  33 #include "environment.h"
  34 #include "charptrless.h"
  35 #include "functiontypes.h"
  36 #include "elementarycoords.h"
  37 #include "statetypes.h"
  38
  39 #include <list>
  40 #include <iostream>
  41 #include <stack>
  42 #include <set>
  43
  44
  45
  46 namespace Shapes
  47 {
  48
  49         Concrete::Time computeDt( Concrete::Length segLength ); // it is sufficient to provide an over-estimate of the segment's length
  50         Concrete::Time straightLineArcTime( double fraction );
  51
  52         namespace Lang
  53         {
  54                 class PolarHandleBase : public Lang::Value
  55                 {
  56                 public:
  57                         PolarHandleBase( );
  58                         virtual ~PolarHandleBase( );
  59                         TYPEINFODECL;
  60                         DISPATCHDECL;
  61                 };
  62
  63         class PolarHandle2D : public Lang::PolarHandleBase
  64         {
  65         public:
  66                 RefCountPtr< const Kernel::PolarHandlePromise > rPromise_;
  67                 double a_;
  68                 PolarHandle2D( const RefCountPtr< const Kernel::PolarHandlePromise > & rPromise, double a );
  69                 virtual ~PolarHandle2D( );
  70                 virtual void show( std::ostream & os ) const;
  71                 virtual void gcMark( Kernel::GCMarkedSet & marked );
  72         };
  73
  74         class PolarHandle2DFree_a : public Lang::PolarHandleBase
  75         {
  76         public:
  77                 RefCountPtr< const Kernel::PolarHandlePromise > rPromise_;
  78                 PolarHandle2DFree_a( const RefCountPtr< const Kernel::PolarHandlePromise > & rPromise );
  79                 virtual ~PolarHandle2DFree_a( );
  80                 virtual void show( std::ostream & os ) const;
  81                 virtual void gcMark( Kernel::GCMarkedSet & marked );
  82         };
  83
  84         class PolarHandle2DFree_r : public Lang::PolarHandleBase
  85         {
  86         public:
  87                 RefCountPtr< const Kernel::PolarHandlePromise > defaultModulus_;
  88                 double a_;
  89                 PolarHandle2DFree_r( const RefCountPtr< const Kernel::PolarHandlePromise > & defaultModulus, double a );
  90                 virtual ~PolarHandle2DFree_r( );
  91                 virtual void show( std::ostream & os ) const;
  92                 virtual void gcMark( Kernel::GCMarkedSet & marked );
  93         };
  94
  95         class PolarHandle2DFree_ra : public Lang::PolarHandleBase
  96         {
  97         public:
  98                 RefCountPtr< const Kernel::PolarHandlePromise > defaultModulus_;
  99                 PolarHandle2DFree_ra( const RefCountPtr< const Kernel::PolarHandlePromise > & defaultModulus );
 100                 virtual ~PolarHandle2DFree_ra( );
 101                 virtual void show( std::ostream & os ) const;
 102                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 103         };
 104
 105         class PathPoint2D : public Lang::Geometric2D
 106         {
 107         public:
 108                 Kernel::ValueRef rear_;
 109                 RefCountPtr< const Lang::Coords2D > mid_;
 110                 Kernel::ValueRef front_;
 111                 PathPoint2D( const PathPoint2D & orig );
 112                 PathPoint2D( RefCountPtr< const Lang::Coords2D > mid );
 113                 virtual Kernel::VariableHandle getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const;
 114                 virtual RefCountPtr< const Lang::Geometric2D > transformed( const Lang::Transform2D & tf, const RefCountPtr< const Lang::Geometric2D > & self ) const;
 115                 virtual RefCountPtr< const Lang::Geometric3D > to3D( const RefCountPtr< const Lang::Geometric2D > & self ) const;
 116                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 117                 TYPEINFODECL;
 118                 DISPATCHDECL;
 119         };
 120
 121         class Path2D : public Lang::Geometric2D
 122         {
 123         protected:
 124                 bool closed_;
 125         public:
 126                 Path2D( );
 127                 virtual ~Path2D( );
 128
 129                 void close( );
 130                 bool isClosed( ) const;
 131                 virtual RefCountPtr< const Lang::Geometric2D > transformed( const Lang::Transform2D & tf, const RefCountPtr< const Lang::Geometric2D > & self ) const;
 132                 virtual RefCountPtr< const Lang::Geometric3D > to3D( const RefCountPtr< const Lang::Geometric2D > & self ) const;
 133                 virtual RefCountPtr< const Lang::Path2D > typed_transformed( const Lang::Transform2D & tf ) const = 0;
 134                 virtual RefCountPtr< const Lang::Path3D > typed_to3D( const RefCountPtr< const Lang::Path2D > & self ) const = 0;
 135                 virtual void writePath( std::ostream & os ) const = 0;
 136                 virtual void elementaryJob( std::stack< const Lang::Value * > * nodeStack, Lang::ElementaryPath2D * pth, Concrete::Coords2D * basePoint ) const = 0;
 137                 TYPEINFODECL;
 138                 DISPATCHDECL;
 139         };
 140
 141         class CompositePath2D : public Lang::Path2D
 142         {
 143         protected:
 144                 mutable RefCountPtr< const ElementaryPath2D > elementaryPath_;
 145         public:
 146                 CompositePath2D( );
 147                 virtual ~CompositePath2D( );
 148                 virtual Kernel::VariableHandle getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const;
 149
 150                 virtual void writePath( std::ostream & os ) const;
 151                 virtual RefCountPtr< const Lang::Path2D > typed_transformed( const Lang::Transform2D & tf ) const;
 152                 virtual RefCountPtr< const Lang::Path3D > typed_to3D( const RefCountPtr< const Lang::Path2D > & self ) const;
 153                 RefCountPtr< const Lang::ElementaryPath2D > getElementaryPath( ) const;
 154                 virtual void show( std::ostream & os ) const;
 155         protected:
 156                 void computeElementaryPath( ) const;
 157         };
 158
 159         class ClosedPath2D : public Lang::CompositePath2D
 160         {
 161         public:
 162                 RefCountPtr< const Lang::Path2D > openPath_;
 163                 ClosedPath2D( RefCountPtr< const Lang::Path2D > openPath );
 164                 virtual ~ClosedPath2D( );
 165                 virtual void elementaryJob( std::stack< const Lang::Value * > * nodeStack, Lang::ElementaryPath2D * pth, Concrete::Coords2D * basePoint ) const;
 166                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 167         };
 168
 169         class ElementaryPath2D : public PtrOwner_back_Access< std::list< Concrete::PathPoint2D * > >, public Lang::Path2D
 170         {
 171         public:
 172                 bool allComplete_;
 173                 ElementaryPath2D( );
 174                 virtual ~ElementaryPath2D( );
 175                 virtual Kernel::VariableHandle getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const;
 176                 virtual Kernel::VariableHandle getField( const char * fieldID, const RefCountPtr< const Lang::ElementaryPath2D > & selfRef ) const;
 177
 178                 virtual void writePath( std::ostream & os ) const;
 179                 virtual void writeInputForm( std::ostream & os ) const;
 180                 virtual RefCountPtr< const Lang::ElementaryPath2D > elementaryTransformed( const Lang::Transform2D & tf ) const;
 181                 virtual RefCountPtr< const Lang::ElementaryPath3D > elementaryTransformed( const Lang::Transform3D & tf ) const;
 182                 virtual RefCountPtr< const Lang::Path2D > typed_transformed( const Lang::Transform2D & tf ) const;
 183                 virtual RefCountPtr< const Lang::Path3D > typed_to3D( const RefCountPtr< const Lang::Path2D > & self ) const;
 184                 virtual RefCountPtr< const Lang::Geometric3D > to3D( const RefCountPtr< const Lang::Geometric2D > & self ) const;
 185                 virtual void elementaryJob( std::stack< const Lang::Value * > * nodeStack, Lang::ElementaryPath2D * pth, Concrete::Coords2D * basePoint ) const;
 186
 187                 size_t duration( ) const;
 188                 bool controllingMaximizer( const Lang::FloatPair & d, Lang::Coords2D * dst ) const;
 189                 bool boundingRectangle( Concrete::Coords2D * dstll, Concrete::Coords2D * dstur ) const;
 190                 bool lineSegmentIntersection( Concrete::Time * dstSelf, Concrete::Time * dstLine, const Concrete::Coords2D & l0, const Concrete::Coords2D & l1 ) const;
 191
 192                 RefCountPtr< const Lang::Coords2D > point( Concrete::Time t ) const;
 193                 RefCountPtr< const Lang::Length > speed( Concrete::Time t ) const;
 194                 RefCountPtr< const Lang::Length > reverse_speed( Concrete::Time t ) const;
 195                 RefCountPtr< const Lang::FloatPair > direction( Concrete::Time t ) const;
 196                 RefCountPtr< const Lang::FloatPair > reverse_direction( Concrete::Time t ) const;
 197                 RefCountPtr< const Lang::Length > radiusOfCurvature( Concrete::Time t ) const;
 198                 RefCountPtr< const Lang::Length > reverse_radiusOfCurvature( Concrete::Time t ) const;
 199
 200                 RefCountPtr< const Lang::Coords2D > discreteMean( ) const;
 201                 RefCountPtr< const Lang::Coords2D > continuousMean( ) const;
 202                 RefCountPtr< const Lang::Coords2D > controllingMaximizer( const Lang::FloatPair & d ) const;
 203                 Concrete::Length arcLength( ) const;
 204                 Concrete::Length arcLength( Concrete::Time tFinal ) const;
 205                 int windingNumber( const Concrete::Coords2D & p ) const;
 206
 207                 Concrete::SplineTime arcTime( const Concrete::Length & t, Concrete::Time t0 = 0 ) const;
 208                 Concrete::SplineTime discreteMaximizer( const Lang::FloatPair & d ) const;
 209                 Concrete::SplineTime continuousMaximizer( const Lang::FloatPair & d ) const;
 210                 Concrete::SplineTime discreteApproximator( const Lang::Coords2D & p ) const;
 211                 Concrete::SplineTime continuousApproximator( const Lang::Coords2D & p ) const;
 212                 Concrete::SplineTime continuousApproximator( const RefCountPtr< const Lang::ElementaryPath2D > & p2, RefCountPtr< const Lang::Structure > * dstInfo ) const;
 213                 Concrete::SplineTime intersection( const RefCountPtr< const Lang::ElementaryPath2D > & p2, RefCountPtr< const Lang::Structure > * dstInfo ) const;
 214
 215                 RefCountPtr< const Lang::ElementaryPath2D > subpath( const Concrete::SplineTime t1, const Concrete::SplineTime t2 ) const;
 216                 RefCountPtr< const Lang::ElementaryPath2D > reverse( ) const;
 217                 RefCountPtr< const Lang::ElementaryPath2D > controlling_hull( ) const;
 218                 RefCountPtr< const Lang::ElementaryPath2D > upsample( const Computation::Upsampler2D & sampler ) const;
 219
 220                 bool isConvexPoly( Concrete::Length tol ) const;
 221                 bool convexPolyContains( const Concrete::Coords2D & p, Concrete::Length tol ) const;
 222
 223                 virtual void show( std::ostream & os ) const;
 224                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 225
 226         private:
 227                 Concrete::Time timeCheck( Concrete::Time t ) const;
 228                 void findSegment( Concrete::Time t, Concrete::Time * tRes, const Concrete::PathPoint2D ** p1, const Concrete::PathPoint2D ** p2 ) const;
 229                 void findSegmentReverse( Concrete::Time t, Concrete::Time * tRes, const Concrete::PathPoint2D ** p1, const Concrete::PathPoint2D ** p2 ) const;
 230                 static void pushOverlappingDeleteOther( std::list< Computation::SegmentSectionPair2D * > & work, Computation::SegmentSectionPair2D * item );
 231                 static void pushCloseDeleteOther( std::list< Computation::SegmentSectionPair2D * > * work, Computation::SegmentSectionPair2D * item, Concrete::LengthSquared closeDist );
 232                 Concrete::Length negative_arcLength( Concrete::Time tFinal ) const;
 233                 Concrete::SplineTime negative_arcTime( const Concrete::Length dist, Concrete::Time t0 = 0 ) const;
 234         };
 235
 236         class PathSlider2D : public Lang::Value
 237         {
 238                 RefCountPtr< const Lang::ElementaryPath2D > path_;
 239                 Concrete::SplineTime t_;
 240                 Kernel::VariableHandle info_; /* Generally, this is a void value, but it may also be a structure with information about how this slider was computed.  Different computations may lead to structures with different signatures. */
 241         public:
 242                 PathSlider2D( const Lang::PathSlider2D & orig );
 243                 PathSlider2D( const RefCountPtr< const Lang::ElementaryPath2D > & path );
 244                 PathSlider2D( const RefCountPtr< const Lang::ElementaryPath2D > & path, Concrete::SplineTime t );
 245                 PathSlider2D( const RefCountPtr< const Lang::ElementaryPath2D > & path, Concrete::SplineTime t, Kernel::VariableHandle info );
 246                 virtual ~PathSlider2D( );
 247                 virtual Kernel::VariableHandle getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const;
 248                 RefCountPtr< const Lang::ElementaryPath2D > getPath( ) const { return path_; }
 249                 Concrete::SplineTime getTime( ) const { return t_; }
 250                 Kernel::VariableHandle getInfo( ) const { return info_; }
 251
 252                 RefCountPtr< Lang::PathSlider2D > move_time( const Concrete::Time delta ) const;
 253                 RefCountPtr< Lang::PathSlider2D > move_length( const Concrete::Length delta ) const;
 254                 RefCountPtr< Lang::PathSlider2D > seek_time( const Concrete::Time val ) const;
 255                 RefCountPtr< Lang::PathSlider2D > seek_start( ) const;
 256                 RefCountPtr< Lang::PathSlider2D > seek_end( ) const;
 257                 RefCountPtr< Lang::PathSlider2D > seek_length( const Concrete::Length val ) const;
 258
 259                 RefCountPtr< const Lang::Coords2D > point( ) const;
 260                 RefCountPtr< const Lang::Length > speed( ) const;
 261                 RefCountPtr< const Lang::Length > reverse_speed( ) const;
 262                 RefCountPtr< const Lang::FloatPair > direction( ) const;
 263                 RefCountPtr< const Lang::FloatPair > reverse_direction( ) const;
 264                 RefCountPtr< const Lang::FloatPair > normal( ) const;
 265                 RefCountPtr< const Lang::FloatPair > reverse_normal( ) const;
 266                 RefCountPtr< const Lang::Length > radiusOfCurvature( ) const;
 267                 RefCountPtr< const Lang::Length > reverse_radiusOfCurvature( ) const;
 268                 RefCountPtr< const Lang::Float > time( ) const;
 269                 RefCountPtr< const Lang::Length > length( ) const;
 270
 271                 virtual RefCountPtr< const Lang::Value > getRear( ) const;
 272                 virtual RefCountPtr< const Lang::Value > getFront( ) const;
 273
 274                 virtual void show( std::ostream & os ) const;
 275                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 276                 TYPEINFODECL;
 277                 DISPATCHDECL;
 278         };
 279
 280         class PathSlider2D_rear : public Lang::PathSlider2D
 281         {
 282                 RefCountPtr< const Lang::Value > rear_;
 283         public:
 284                 PathSlider2D_rear( const Lang::PathSlider2D & orig, const RefCountPtr< const Lang::Value > & rear );
 285                 virtual RefCountPtr< const Lang::Value > getRear( ) const;
 286         };
 287
 288         class PathSlider2D_front : public Lang::PathSlider2D
 289         {
 290                 RefCountPtr< const Lang::Value > front_;
 291         public:
 292                 PathSlider2D_front( const Lang::PathSlider2D & orig, const RefCountPtr< const Lang::Value > & front );
 293                 virtual RefCountPtr< const Lang::Value > getFront( ) const;
 294         };
 295
 296         class Connection2D : public Lang::CompositePath2D
 297         {
 298         public:
 299                 Kernel::ValueRef rear_;
 300                 Kernel::ValueRef front_;
 301                 Connection2D( Kernel::ValueRef rear, Kernel::ValueRef front );
 302                 ~Connection2D( );
 303                 virtual void elementaryJob( std::stack< const Lang::Value * > * nodeStack, Lang::ElementaryPath2D * pth, Concrete::Coords2D * basePoint ) const;
 304                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 305         };
 306
 307         class SinglePointPath2D : public Lang::CompositePath2D
 308         {
 309         public:
 310                 Kernel::ValueRef thePoint_;
 311                 SinglePointPath2D( Kernel::ValueRef thePoint );
 312                 ~SinglePointPath2D( );
 313                 virtual void elementaryJob( std::stack< const Lang::Value * > * nodeStack, Lang::ElementaryPath2D * pth, Concrete::Coords2D * basePoint ) const;
 314                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 315         };
 316
 317         class HeadedPath2D_helper : public Lang::CompositePath2D
 318         {
 319                 RefCountPtr< const Lang::ElementaryPath2D > bodyPath_;
 320         public:
 321                 HeadedPath2D_helper( const RefCountPtr< const Lang::ElementaryPath2D > & bodyPath );
 322                 ~HeadedPath2D_helper( );
 323                 virtual void elementaryJob( std::stack< const Lang::Value * > * nodeStack, Lang::ElementaryPath2D * pth, Concrete::Coords2D * basePoint ) const;
 324                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 325         };
 326
 327         class HeadedPath2D : public Lang::CompositePath2D
 328         {
 329                 RefCountPtr< const Lang::HeadedPath2D_helper > bodyPath_;
 330                 Kernel::ValueRef rearPathPoint_;
 331                 Kernel::ValueRef frontPathPoint_;
 332         public:
 333                 HeadedPath2D( Kernel::ValueRef rear, const RefCountPtr< const Lang::ElementaryPath2D > & bodyPath, Kernel::ValueRef front );
 334                 ~HeadedPath2D( );
 335                 virtual void elementaryJob( std::stack< const Lang::Value * > * nodeStack, Lang::ElementaryPath2D * pth, Concrete::Coords2D * basePoint ) const;
 336                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 337         };
 338
 339         class MultiPath2D : public Lang::Geometric2D, public std::list< RefCountPtr< const Path2D > >
 340         {
 341         public:
 342                 MultiPath2D( );
 343                 ~MultiPath2D( );
 344                 MultiPath2D * clone( ) const;
 345                 virtual RefCountPtr< const Lang::Geometric2D > transformed(const Lang::Transform2D & tf, const RefCountPtr< const Lang::Geometric2D > & self ) const;
 346                 virtual RefCountPtr< const Lang::Geometric3D > to3D( const RefCountPtr< const Lang::Geometric2D > & self ) const;
 347                 void writePath( std::ostream & os ) const;
 348                 TYPEINFODECL;
 349                 virtual void show( std::ostream & os ) const;
 350                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 351                 DISPATCHDECL;
 352         };
 353
 354
 355         class PathPoint3D : public Lang::Geometric3D
 356         {
 357         public:
 358                 RefCountPtr< const Lang::Coords3D > rear_;
 359                 RefCountPtr< const Lang::Coords3D > mid_;
 360                 RefCountPtr< const Lang::Coords3D > front_;
 361                 PathPoint3D( const PathPoint3D & orig );
 362                 PathPoint3D( const RefCountPtr< const Lang::Coords3D > & mid );
 363                 virtual Kernel::VariableHandle getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const;
 364                 void elementaryJob( Lang::ElementaryPath3D * pth, Concrete::Coords3D * basePoint ) const;
 365                 virtual RefCountPtr< const Lang::Geometric3D > transformed( const Lang::Transform3D & tf, const RefCountPtr< const Lang::Geometric3D > & self ) const;
 366                 virtual RefCountPtr< const Lang::Geometric2D > to2D( const Kernel::PassedDyn & dyn, const RefCountPtr< const Lang::Geometric3D > & self ) const;
 367                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 368                 TYPEINFODECL;
 369                 DISPATCHDECL;
 370         };
 371
 372
 373         class Path3D : public Lang::Geometric3D
 374         {
 375         protected:
 376                 bool closed_;
 377         public:
 378                 Path3D( );
 379                 virtual ~Path3D( );
 380
 381                 void close( );
 382                 bool isClosed( ) const;
 383                 virtual RefCountPtr< const Lang::Geometric3D > transformed( const Lang::Transform3D & tf, const RefCountPtr< const Lang::Geometric3D > & self ) const;
 384                 virtual RefCountPtr< const Lang::Path3D > typed_transformed( const Lang::Transform3D & tf ) const = 0;
 385                 virtual RefCountPtr< const Lang::Geometric2D > to2D( const Kernel::PassedDyn & dyn, const RefCountPtr< const Lang::Geometric3D > & self ) const;
 386                 virtual RefCountPtr< const Lang::ElementaryPath2D > make2D( Concrete::Length eyez ) const = 0;
 387                 virtual void elementaryJob( std::stack< const Lang::Path3D * > * nodeStack, Lang::ElementaryPath3D * pth, Concrete::Coords3D * basePoint ) const = 0;
 388                 TYPEINFODECL;
 389                 DISPATCHDECL;
 390         };
 391
 392         class CompositePath3D : public Lang::Path3D
 393         {
 394         protected:
 395                 mutable RefCountPtr< const ElementaryPath3D > elementaryPath_;
 396         public:
 397                 CompositePath3D( );
 398                 virtual ~CompositePath3D( );
 399                 virtual Kernel::VariableHandle getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const;
 400
 401                 virtual RefCountPtr< const Lang::ElementaryPath2D > make2D( Concrete::Length eyez ) const;
 402                 virtual RefCountPtr< const Lang::Path3D > typed_transformed( const Lang::Transform3D & tf ) const;
 403                 RefCountPtr< const Lang::ElementaryPath3D > getElementaryPath( ) const;
 404                 virtual void show( std::ostream & os ) const;
 405         protected:
 406                 void computeElementaryPath( ) const;
 407         };
 408
 409         class Path2Din3D : public Lang::CompositePath3D
 410         {
 411                 RefCountPtr< const Lang::ElementaryPath2D > elementaryPath2D_;
 412         public:
 413                 Path2Din3D( const RefCountPtr< const Lang::ElementaryPath2D > & _elementaryPath2D );
 414                 ~Path2Din3D( );
 415                 virtual RefCountPtr< const Lang::ElementaryPath2D > make2D( Concrete::Length eyez ) const;
 416                 virtual RefCountPtr< const Lang::Path3D > typed_transformed( const Lang::Transform3D & tf ) const;
 417                 virtual void elementaryJob( std::stack< const Lang::Path3D * > * nodeStack, Lang::ElementaryPath3D * pth, Concrete::Coords3D * basePoint ) const;
 418                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 419         };
 420
 421         class ClosedPath3D : public Lang::CompositePath3D
 422         {
 423         public:
 424                 RefCountPtr< const Lang::Path3D > openPath_;
 425                 ClosedPath3D( RefCountPtr< const Lang::Path3D > openPath );
 426                 virtual ~ClosedPath3D( );
 427                 virtual void elementaryJob( std::stack< const Lang::Path3D * > * nodeStack, Lang::ElementaryPath3D * pth, Concrete::Coords3D * basePoint ) const;
 428                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 429         };
 430
 431         class ElementaryPath3D : public PtrOwner_back_Access< std::list< Concrete::PathPoint3D * > >, public Lang::Path3D
 432         {
 433         public:
 434                 ElementaryPath3D( );
 435                 virtual ~ElementaryPath3D( );
 436                 virtual Kernel::VariableHandle getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const;
 437                 virtual Kernel::VariableHandle getField( const char * fieldID, const RefCountPtr< const Lang::ElementaryPath3D > & selfRef ) const;
 438
 439                 virtual RefCountPtr< const Lang::ElementaryPath2D > make2D( Concrete::Length eyez ) const;
 440                 void dashifyIn2D( RefCountPtr< const Lang::Group2D > * res, Concrete::Length eyez, const RefCountPtr< const Kernel::GraphicsState > & metaState ) const;
 441                 virtual RefCountPtr< const Lang::ElementaryPath3D > elementaryTransformed( const Lang::Transform3D & tf ) const;
 442                 virtual RefCountPtr< const Lang::Path3D > typed_transformed( const Lang::Transform3D & tf ) const;
 443                 virtual void elementaryJob( std::stack< const Lang::Path3D * > * nodeStack, Lang::ElementaryPath3D * pth, Concrete::Coords3D * basePoint ) const;
 444
 445                 size_t duration( ) const;
 446                 bool controllingMaximizer( const Lang::FloatTriple & d, Lang::Coords3D * dst ) const;
 447
 448                 RefCountPtr< const Lang::Coords3D > point( Concrete::Time t ) const;
 449                 RefCountPtr< const Lang::Length > speed( Concrete::Time t ) const;
 450                 RefCountPtr< const Lang::Length > reverse_speed( Concrete::Time t ) const;
 451                 RefCountPtr< const Lang::FloatTriple > direction( Concrete::Time t ) const;
 452                 RefCountPtr< const Lang::FloatTriple > reverse_direction( Concrete::Time t ) const;
 453                 RefCountPtr< const Lang::FloatTriple > normal( Concrete::Time t ) const;
 454                 RefCountPtr< const Lang::FloatTriple > reverse_normal( Concrete::Time t ) const;
 455                 RefCountPtr< const Lang::Length > radiusOfCurvature( Concrete::Time t ) const;
 456                 RefCountPtr< const Lang::Length > reverse_radiusOfCurvature( Concrete::Time t ) const;
 457                 RefCountPtr< const Lang::Length > radiusOfTorsion( Concrete::Time t ) const;
 458                 RefCountPtr< const Lang::Length > reverse_radiusOfTorsion( Concrete::Time t ) const;
 459
 460                 RefCountPtr< const Lang::Coords3D > discreteMean( ) const;
 461                 RefCountPtr< const Lang::Coords3D > continuousMean( ) const;
 462                 RefCountPtr< const Lang::Coords3D > controllingMaximizer( const Lang::FloatTriple & d ) const;
 463                 Concrete::Length arcLength( ) const;
 464                 Concrete::Length arcLength( Concrete::Time tFinal ) const;
 465
 466                 Concrete::SplineTime arcTime( const Concrete::Length & t, Concrete::Time t0 = 0 ) const;
 467                 Concrete::SplineTime discreteMaximizer( const Lang::FloatTriple & d ) const;
 468                 Concrete::SplineTime continuousMaximizer( const Lang::FloatTriple & d ) const;
 469                 Concrete::SplineTime discreteApproximator( const Lang::Coords3D & p ) const;
 470                 Concrete::SplineTime continuousApproximator( const Lang::Coords3D & p ) const;
 471                 Concrete::SplineTime continuousApproximator( const RefCountPtr< const Lang::ElementaryPath3D > & p2, RefCountPtr< const Lang::Structure > * dstInfo ) const;
 472
 473                 RefCountPtr< const Lang::ElementaryPath3D > subpath( const Concrete::SplineTime t1, const Concrete::SplineTime t2 ) const;
 474                 RefCountPtr< const Lang::ElementaryPath3D > reverse( ) const;
 475                 RefCountPtr< const Lang::ElementaryPath3D > upsample( const Computation::Upsampler3D & sampler ) const;
 476
 477                 virtual void show( std::ostream & os ) const;
 478                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 479
 480                 void getRepresentativePoints( const Lang::Transform3D & tf, Concrete::Coords3D * p0, Concrete::Coords3D * p1, Concrete::Coords3D * p2 ) const;
 481
 482         private:
 483                 Concrete::Time timeCheck( Concrete::Time t ) const;
 484                 void findSegment( Concrete::Time t, Concrete::Time * tRes, const Concrete::PathPoint3D ** p1, const Concrete::PathPoint3D ** p2 ) const;
 485                 void findSegmentReverse( Concrete::Time t, Concrete::Time * tRes, const Concrete::PathPoint3D ** p1, const Concrete::PathPoint3D ** p2 ) const;
 486                 Concrete::Length negative_arcLength( Concrete::Time tFinal ) const;
 487                 Concrete::SplineTime negative_arcTime( const Concrete::Length dist, Concrete::Time t0 = 0 ) const;
 488                 static void makeSegment2D( Lang::ElementaryPath2D * dst, Concrete::Coords2D ** passedRear, const Concrete::Coords3D * p0, const Concrete::Coords3D * p1, const Concrete::Coords3D * p2, const Concrete::Coords3D * p3, Concrete::Length eyez );
 489                 static double viewDistortionTooBig( const Concrete::Coords3D & p0, const Concrete::Coords3D & p1, const Concrete::Coords3D & p2, const Concrete::Coords3D & p3, Concrete::Length eyez, double threshold );
 490                 static void dashifySegment( RefCountPtr< const Lang::Group2D > * res, Lang::ElementaryPath3D & newPath, Concrete::Length remainingLength, Concrete::Coords3D ** passedRear, const Concrete::Coords3D * p0, const Concrete::Coords3D * p1, const Concrete::Coords3D * p2, const Concrete::Coords3D * p3, Concrete::Length eyez, const RefCountPtr< const Kernel::GraphicsState > & solidState, Lang::Dash::Iterator & dashi );
 491                 static void laterArcTime( const Concrete::Bezier & x0, const Concrete::Bezier & y0, const Concrete::Bezier & z0, const Concrete::Bezier & x1, const Concrete::Bezier & y1, const Concrete::Bezier & z1, const Concrete::Bezier & x2, const Concrete::Bezier & y2, const Concrete::Bezier & z2, const Concrete::Bezier & x3, const Concrete::Bezier & y3, const Concrete::Bezier & z3, Concrete::Time * _t, Concrete::Length * l, const Concrete::Time & dt );
 492                 static void pushCloseDeleteOther( std::list< Computation::SegmentSectionPair3D * > * work, Computation::SegmentSectionPair3D * item, Concrete::LengthSquared closeDist );
 493         };
 494
 495         class PathSlider3D : public Lang::Value
 496         {
 497                 RefCountPtr< const Lang::ElementaryPath3D > path_;
 498                 Concrete::SplineTime t_;
 499                 Kernel::VariableHandle info_; /* See comment in PathSlider2D. */
 500         public:
 501                 PathSlider3D( const Lang::PathSlider3D & orig );
 502                 PathSlider3D( const RefCountPtr< const Lang::ElementaryPath3D > & _path );
 503                 PathSlider3D( const RefCountPtr< const Lang::ElementaryPath3D > & _path, Concrete::SplineTime _t );
 504                 PathSlider3D( const RefCountPtr< const Lang::ElementaryPath3D > & _path, Concrete::SplineTime _t, Kernel::VariableHandle info );
 505                 virtual ~PathSlider3D( );
 506                 virtual Kernel::VariableHandle getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const;
 507                 RefCountPtr< const Lang::ElementaryPath3D > getPath( ) const { return path_; }
 508                 Concrete::SplineTime getTime( ) const { return t_; }
 509                 Kernel::VariableHandle getInfo( ) const { return info_; }
 510
 511                 RefCountPtr< Lang::PathSlider3D > move_time( const Concrete::Time delta ) const;
 512                 RefCountPtr< Lang::PathSlider3D > move_length( const Concrete::Length delta ) const;
 513                 RefCountPtr< Lang::PathSlider3D > seek_time( const Concrete::Time val ) const;
 514                 RefCountPtr< Lang::PathSlider3D > seek_start( ) const;
 515                 RefCountPtr< Lang::PathSlider3D > seek_end( ) const;
 516                 RefCountPtr< Lang::PathSlider3D > seek_length( const Concrete::Length val ) const;
 517
 518                 RefCountPtr< const Lang::Coords3D > point( ) const;
 519                 RefCountPtr< const Lang::Length > speed( ) const;
 520                 RefCountPtr< const Lang::Length > reverse_speed( ) const;
 521                 RefCountPtr< const Lang::FloatTriple > direction( ) const;
 522                 RefCountPtr< const Lang::FloatTriple > reverse_direction( ) const;
 523                 RefCountPtr< const Lang::FloatTriple > normal( ) const;
 524                 RefCountPtr< const Lang::FloatTriple > reverse_normal( ) const;
 525                 RefCountPtr< const Lang::FloatTriple > binormal( ) const;
 526                 RefCountPtr< const Lang::FloatTriple > reverse_binormal( ) const;
 527                 RefCountPtr< const Lang::Length > radiusOfCurvature( ) const;
 528                 RefCountPtr< const Lang::Length > reverse_radiusOfCurvature( ) const;
 529                 RefCountPtr< const Lang::Length > radiusOfTorsion( ) const;
 530                 RefCountPtr< const Lang::Length > reverse_radiusOfTorsion( ) const;
 531                 RefCountPtr< const Lang::Float > time( ) const;
 532                 RefCountPtr< const Lang::Length > length( ) const;
 533
 534                 virtual RefCountPtr< const Lang::Value > getRear( ) const;
 535                 virtual RefCountPtr< const Lang::Value > getFront( ) const;
 536
 537                 virtual void show( std::ostream & os ) const;
 538                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 539                 TYPEINFODECL;
 540                 DISPATCHDECL;
 541         };
 542
 543         class PathSlider3D_rear : public Lang::PathSlider3D
 544         {
 545                 RefCountPtr< const Lang::Value > rear_;
 546         public:
 547                 PathSlider3D_rear( const Lang::PathSlider3D & orig, const RefCountPtr< const Lang::Value > & rear );
 548                 virtual RefCountPtr< const Lang::Value > getRear( ) const;
 549         };
 550
 551         class PathSlider3D_front : public Lang::PathSlider3D
 552         {
 553                 RefCountPtr< const Lang::Value > front_;
 554         public:
 555                 PathSlider3D_front( const Lang::PathSlider3D & orig, const RefCountPtr< const Lang::Value > & front );
 556                 virtual RefCountPtr< const Lang::Value > getFront( ) const;
 557         };
 558
 559         class Connection3D : public Lang::CompositePath3D
 560         {
 561         public:
 562                 RefCountPtr< const Lang::Path3D > rear_;
 563                 RefCountPtr< const Lang::Path3D > front_;
 564                 Connection3D( const RefCountPtr< const Lang::Path3D > & rear, const RefCountPtr< const Lang::Path3D > & front );
 565                 ~Connection3D( );
 566                 virtual void elementaryJob( std::stack< const Lang::Path3D * > * nodeStack, Lang::ElementaryPath3D * pth, Concrete::Coords3D * basePoint ) const;
 567                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 568         };
 569
 570         class SinglePointPath3D : public Lang::CompositePath3D
 571         {
 572         public:
 573                 RefCountPtr< const Lang::PathPoint3D > thePoint_;
 574                 SinglePointPath3D( const RefCountPtr< const Lang::PathPoint3D > & thePoint );
 575                 SinglePointPath3D( const RefCountPtr< const Lang::Coords3D > & mid );
 576                 ~SinglePointPath3D( );
 577                 virtual void elementaryJob( std::stack< const Lang::Path3D * > * nodeStack, Lang::ElementaryPath3D * pth, Concrete::Coords3D * basePoint ) const;
 578                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 579         };
 580
 581         class HeadedPath3D_helper : public Lang::CompositePath3D
 582         {
 583                 RefCountPtr< const Lang::ElementaryPath3D > bodyPath_;
 584         public:
 585                 HeadedPath3D_helper( const RefCountPtr< const Lang::ElementaryPath3D > & bodyPath );
 586                 ~HeadedPath3D_helper( );
 587                 virtual void elementaryJob( std::stack< const Lang::Path3D * > * nodeStack, Lang::ElementaryPath3D * pth, Concrete::Coords3D * basePoint ) const;
 588                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 589         };
 590
 591         class HeadedPath3D : public Lang::CompositePath3D
 592         {
 593                 RefCountPtr< const Lang::HeadedPath3D_helper > bodyPath_;
 594                 RefCountPtr< const Lang::SinglePointPath3D > rearPathPoint_;
 595                 RefCountPtr< const Lang::SinglePointPath3D > frontPathPoint_;
 596         public:
 597                 HeadedPath3D( Kernel::ValueRef rear, const RefCountPtr< const Lang::ElementaryPath3D > & bodyPath, Kernel::ValueRef front );
 598                 ~HeadedPath3D( );
 599                 virtual void elementaryJob( std::stack< const Lang::Path3D * > * nodeStack, Lang::ElementaryPath3D * pth, Concrete::Coords3D * basePoint ) const;
 600                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 601         };
 602
 603         class MultiPath3D : public Lang::Geometric3D, public std::list< RefCountPtr< const Path3D > >
 604         {
 605         public:
 606                 MultiPath3D( );
 607                 ~MultiPath3D( );
 608                 MultiPath3D * clone( ) const;
 609                 virtual RefCountPtr< const Lang::Geometric3D > transformed( const Lang::Transform3D & tf, const RefCountPtr< const Lang::Geometric3D > & self ) const;
 610                 virtual RefCountPtr< const Lang::Geometric2D > to2D( const Kernel::PassedDyn & dyn, const RefCountPtr< const Lang::Geometric3D > & self ) const;
 611                 TYPEINFODECL;
 612                 virtual void show( std::ostream & os ) const;
 613                 virtual void gcMark( Kernel::GCMarkedSet & marked );
 614                 DISPATCHDECL;
 615         };
 616
 617         }
 618
 619
 620         namespace Kernel
 621         {
 622                 class PolarHandlePromise
 623                 {
 624                 public:
 625                         PolarHandlePromise( );
 626                         virtual ~PolarHandlePromise( );
 627                         virtual double force( const Concrete::PathPoint2D * specialUnitP0, const Concrete::PathPoint2D * specialUnitP1, bool reverse ) const = 0;
 628                         virtual void gcMark( Kernel::GCMarkedSet & marked ) const = 0;
 629                         virtual void show( std::ostream & os ) const = 0;
 630                 };
 631
 632                 class PolarHandleEmptyPromise : public PolarHandlePromise
 633                 {
 634                 public:
 635                         PolarHandleEmptyPromise( );
 636                         virtual ~PolarHandleEmptyPromise( );
 637                         virtual double force( const Concrete::PathPoint2D * specialUnitP0, const Concrete::PathPoint2D * specialUnitP1, bool reverse ) const;
 638                         virtual void gcMark( Kernel::GCMarkedSet & marked ) const;
 639                         virtual void show( std::ostream & os ) const;
 640                 };
 641
 642                 class PolarHandleTruePromise : public PolarHandlePromise
 643                 {
 644                         Kernel::Thunk * thunk_; /* this thunk always waits to be forced, since it will be evaluated in different dynamic contexts each time */
 645                 public:
 646                         PolarHandleTruePromise( Kernel::Thunk * thunk );
 647                         virtual ~PolarHandleTruePromise( );
 648                         virtual double force( const Concrete::PathPoint2D * specialUnitP0, const Concrete::PathPoint2D * specialUnitP1, bool reverse ) const;
 649                         virtual void gcMark( Kernel::GCMarkedSet & marked ) const;
 650                         virtual void show( std::ostream & os ) const;
 651                 };
 652         }
 653
 654         namespace Concrete
 655         {
 656
 657                 class PathPoint2D
 658                 {
 659                 public:
 660                         enum HandleState { COMPLETE = 0x0000, FREE_ANGLE = 0x0001, FREE_MODULUS = 0x0002, FREE = 0x0003, UNFORCED_M = 0x0004, UNFORCED_A = 0x0008 };
 661
 662                         int rearState_;
 663                         double rearAngle_;
 664                         Concrete::Length rearModulus_;
 665                         RefCountPtr< const Kernel::PolarHandlePromise > rearModulusPromise_;
 666
 667                         int frontState_;
 668                         double frontAngle_;
 669                         Concrete::Length frontModulus_;
 670                         RefCountPtr< const Kernel::PolarHandlePromise > frontModulusPromise_;
 671
 672                         double defaultAngle_;
 673
 674                         Concrete::Coords2D * rear_;
 675                         Concrete::Coords2D * mid_;
 676                         Concrete::Coords2D * front_;
 677
 678                         PathPoint2D( const Concrete::PathPoint2D & orig );
 679                         PathPoint2D( Concrete::Coords2D * _mid );
 680                         PathPoint2D( Concrete::Length midx, Concrete::Length midy );
 681                         ~PathPoint2D( );
 682                         Concrete::PathPoint2D * transformed( const Lang::Transform2D & tf ) const;
 683                         Concrete::PathPoint3D * transformed( const Lang::Transform3D & tf ) const; // treat as z = 0
 684                         Concrete::PathPoint3D * typed_to3D( ) const; // treat as z = 0
 685                 };
 686
 687                 class PathPoint3D
 688                         {
 689                         public:
 690                                 Concrete::Coords3D * rear_;
 691                                 Concrete::Coords3D * mid_;
 692                                 Concrete::Coords3D * front_;
 693
 694                                 PathPoint3D( const Concrete::PathPoint3D & orig );
 695                                 PathPoint3D( Concrete::Coords3D * mid );
 696                                 PathPoint3D( const Concrete::Coords2D & mid );  // treat as z = 0
 697                                 PathPoint3D( Concrete::Length midx, Concrete::Length midy, Concrete::Length midz );
 698                                 ~PathPoint3D( );
 699                                 Concrete::PathPoint3D * transformed( const Lang::Transform3D & tf ) const;
 700                                 Concrete::PathPoint2D * make2D( Concrete::Length eyez ) const;
 701                         };
 702
 703         }
 704
 705 }