source/pathslider2D.cc

   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 #include <cmath>
  20
  21 #include "shapestypes.h"
  22 #include "shapesexceptions.h"
  23 #include "astexpr.h"
  24 #include "consts.h"
  25 #include "globals.h"
  26 #include "bezier.h"
  27
  28 #include <ctype.h>
  29 #include <stack>
  30 #include <algorithm>
  31
  32 using namespace Shapes;
  33 using namespace std;
  34
  35
  36 Lang::PathSlider2D::PathSlider2D( const Lang::PathSlider2D & orig )
  37         : path_( orig.getPath( ) ), t_( orig.getTime( ) ), info_( orig.getInfo( ) )
  38 { }
  39
  40 Lang::PathSlider2D::PathSlider2D( const RefCountPtr< const Lang::ElementaryPath2D > & path )
  41         : path_( path ), t_( 0 ), info_( Kernel::THE_VOID_VARIABLE )
  42 { }
  43
  44 Lang::PathSlider2D::PathSlider2D( const RefCountPtr< const Lang::ElementaryPath2D > & path, Concrete::SplineTime t )
  45         : path_( path ), t_( t ), info_( Kernel::THE_VOID_VARIABLE )
  46 { }
  47
  48 Lang::PathSlider2D::PathSlider2D( const RefCountPtr< const Lang::ElementaryPath2D > & path, Concrete::SplineTime t, Kernel::VariableHandle info )
  49         : path_( path ), t_( t ), info_( info )
  50 { }
  51
  52 DISPATCHIMPL( PathSlider2D );
  53
  54 Lang::PathSlider2D::~PathSlider2D( )
  55 { }
  56
  57 RefCountPtr< const Lang::Class > Lang::PathSlider2D::TypeID( new Lang::SystemFinalClass( strrefdup( "PathSlider2D" ) ) );
  58 TYPEINFOIMPL( PathSlider2D );
  59
  60 Kernel::VariableHandle
  61 Lang::PathSlider2D::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
  62 {
  63         if( strcmp( fieldID, "p" ) == 0 )
  64                 {
  65                         return Kernel::VariableHandle( new Kernel::Variable( point( ) ) );
  66                 }
  67         if( strcmp( fieldID, "v" ) == 0 )
  68                 {
  69                         return Kernel::VariableHandle( new Kernel::Variable( speed( ) ) );
  70                 }
  71         if( strcmp( fieldID, "rv" ) == 0 )
  72                 {
  73                         return Kernel::VariableHandle( new Kernel::Variable( reverse_speed( ) ) );
  74                 }
  75         if( strcmp( fieldID, "T" ) == 0 )
  76                 {
  77                         return Kernel::VariableHandle( new Kernel::Variable( direction( ) ) );
  78                 }
  79         if( strcmp( fieldID, "rT" ) == 0 )
  80                 {
  81                         return Kernel::VariableHandle( new Kernel::Variable( reverse_direction( ) ) );
  82                 }
  83         if( strcmp( fieldID, "N" ) == 0 )
  84                 {
  85                         return Kernel::VariableHandle( new Kernel::Variable( normal( ) ) );
  86                 }
  87         if( strcmp( fieldID, "rN" ) == 0 )
  88                 {
  89                         return Kernel::VariableHandle( new Kernel::Variable( reverse_normal( ) ) );
  90                 }
  91         if( strcmp( fieldID, "ik" ) == 0 )
  92                 {
  93                         return Kernel::VariableHandle( new Kernel::Variable( radiusOfCurvature( ) ) );
  94                 }
  95         if( strcmp( fieldID, "rik" ) == 0 )
  96                 {
  97                         return Kernel::VariableHandle( new Kernel::Variable( reverse_radiusOfCurvature( ) ) );
  98                 }
  99         if( strcmp( fieldID, "time" ) == 0 )
 100                 {
 101                         return Kernel::VariableHandle( new Kernel::Variable( time( ) ) );
 102                 }
 103         if( strcmp( fieldID, "length" ) == 0 )
 104                 {
 105                         return Kernel::VariableHandle( new Kernel::Variable( length( ) ) );
 106                 }
 107         if( strcmp( fieldID, "past" ) == 0 )
 108                 {
 109                         if( t_.isPast( ) )
 110                                 {
 111                                         return Kernel::THE_TRUE_VARIABLE;
 112                                 }
 113                         return Kernel::THE_FALSE_VARIABLE;
 114                 }
 115         if( strcmp( fieldID, "looped" ) == 0 )
 116                 {
 117                         if( t_.t( ) > Concrete::Time( path_->duration( ) ) ||
 118                                         t_.t( ) < Concrete::Time( 0 ) )
 119                                 {
 120                                         return Kernel::THE_TRUE_VARIABLE;
 121                                 }
 122                         return Kernel::THE_FALSE_VARIABLE;
 123                 }
 124         if( strcmp( fieldID, "mod" ) == 0 )
 125                 {
 126                         return Helpers::newValHandle( new Lang::PathSlider2D( path_, modPhysical( t_.t( ), Concrete::Time( path_->duration( ) ) ) ) );
 127                 }
 128         if( strcmp( fieldID, "info" ) == 0 )
 129                 {
 130                         return info_;
 131                 }
 132         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 133 }
 134
 135 RefCountPtr< Lang::PathSlider2D >
 136 Lang::PathSlider2D::move_time( const Concrete::Time delta ) const
 137 {
 138         Concrete::Time newTime = t_.t( ) + delta;
 139         if( path_->isClosed( ) )
 140                 {
 141                         return RefCountPtr< Lang::PathSlider2D >( new Lang::PathSlider2D( path_, newTime ) );
 142                 }
 143         return RefCountPtr< Lang::PathSlider2D >( new Lang::PathSlider2D( path_,
 144                                                                                                                                                                                                                                                                                 Concrete::SplineTime( newTime,
 145                                                                                                                                                                                                                                                                                                                                                                         Concrete::Time( 0 ) <= newTime &&
 146                                                                                                                                                                                                                                                                                                                                                                         newTime <= Concrete::Time( path_->duration( ) ) ) ) );
 147 }
 148
 149 RefCountPtr< Lang::PathSlider2D >
 150 Lang::PathSlider2D::move_length( const Concrete::Length delta ) const
 151 {
 152         return RefCountPtr< Lang::PathSlider2D >( new Lang::PathSlider2D( path_, path_->arcTime( delta, t_.t( ) ) ) );
 153 }
 154
 155 RefCountPtr< Lang::PathSlider2D >
 156 Lang::PathSlider2D::seek_time( const Concrete::Time newTime ) const
 157 {
 158         if( path_->isClosed( ) )
 159                 {
 160                         return RefCountPtr< Lang::PathSlider2D >( new Lang::PathSlider2D( path_, newTime ) );
 161                 }
 162         return RefCountPtr< Lang::PathSlider2D >( new Lang::PathSlider2D( path_,
 163                                                                                                                                                                                                                                                                                 Concrete::SplineTime( newTime,
 164                                                                                                                                                                                                                                                                                                                                                                         Concrete::Time( 0 ) <= newTime &&
 165                                                                                                                                                                                                                                                                                                                                                                         newTime <= Concrete::Time( path_->duration( ) ) ) ) );
 166 }
 167
 168 RefCountPtr< Lang::PathSlider2D >
 169 Lang::PathSlider2D::seek_start( ) const
 170 {
 171         return RefCountPtr< Lang::PathSlider2D >( new Lang::PathSlider2D( path_, Concrete::ZERO_TIME ) );
 172 }
 173
 174 RefCountPtr< Lang::PathSlider2D >
 175 Lang::PathSlider2D::seek_end( ) const
 176 {
 177         return RefCountPtr< Lang::PathSlider2D >( new Lang::PathSlider2D( path_, Concrete::Time( path_->duration( ) ) ) );
 178 }
 179
 180 RefCountPtr< Lang::PathSlider2D >
 181 Lang::PathSlider2D::seek_length( const Concrete::Length val ) const
 182 {
 183         return RefCountPtr< Lang::PathSlider2D >( new Lang::PathSlider2D( path_, path_->arcTime( val ) ) );
 184 }
 185
 186
 187 RefCountPtr< const Lang::Coords2D >
 188 Lang::PathSlider2D::point( ) const
 189 {
 190         return path_->point( t_.t( ) );
 191 }
 192
 193 RefCountPtr< const Lang::Length >
 194 Lang::PathSlider2D::speed( ) const
 195 {
 196         return path_->speed( t_.t( ) );
 197 }
 198
 199 RefCountPtr< const Lang::Length >
 200 Lang::PathSlider2D::reverse_speed( ) const
 201 {
 202         return path_->reverse_speed( t_.t( ) );
 203 }
 204
 205 RefCountPtr< const Lang::FloatPair >
 206 Lang::PathSlider2D::direction( ) const
 207 {
 208         return path_->direction( t_.t( ) );
 209 }
 210
 211 RefCountPtr< const Lang::FloatPair >
 212 Lang::PathSlider2D::reverse_direction( ) const
 213 {
 214         return path_->reverse_direction( t_.t( ) );
 215 }
 216
 217 RefCountPtr< const Lang::FloatPair >
 218 Lang::PathSlider2D::normal( ) const
 219 {
 220         RefCountPtr< const Lang::FloatPair > tmp = path_->direction( t_.t( ) );
 221         return RefCountPtr< const Lang::FloatPair >( new Lang::FloatPair( -tmp->y_, tmp->x_ ) );
 222 }
 223
 224 RefCountPtr< const Lang::FloatPair >
 225 Lang::PathSlider2D::reverse_normal( ) const
 226 {
 227         RefCountPtr< const Lang::FloatPair > tmp = path_->reverse_direction( t_.t( ) );
 228         return RefCountPtr< const Lang::FloatPair >( new Lang::FloatPair( -tmp->y_, tmp->x_ ) );
 229 }
 230
 231 RefCountPtr< const Lang::Length >
 232 Lang::PathSlider2D::radiusOfCurvature( ) const
 233 {
 234         return path_->radiusOfCurvature( t_.t( ) );
 235 }
 236
 237 RefCountPtr< const Lang::Length >
 238 Lang::PathSlider2D::reverse_radiusOfCurvature( ) const
 239 {
 240         return path_->reverse_radiusOfCurvature( t_.t( ) );
 241 }
 242
 243 RefCountPtr< const Lang::Float >
 244 Lang::PathSlider2D::time( ) const
 245 {
 246         return RefCountPtr< const Lang::Float >( new Lang::Float( t_.t( ).offtype< 0, 1 >( ) ) );
 247 }
 248
 249 RefCountPtr< const Lang::Length >
 250 Lang::PathSlider2D::length( ) const
 251 {
 252         return RefCountPtr< const Lang::Length >( new Lang::Length( path_->arcLength( t_.t( ) ) ) );
 253 }
 254
 255
 256 void
 257 Lang::PathSlider2D::show( std::ostream & os ) const
 258 {
 259         os << "Path slider " ;
 260         if( this->getRear( ) != NullPtr< const Lang::Value >( ) )
 261                 {
 262                         os << "(with rear) " ;
 263                 }
 264         if( this->getFront( ) != NullPtr< const Lang::Value >( ) )
 265                 {
 266                         os << "(with front) " ;
 267                 }
 268         os << "at " << t_.t( ).offtype< 0, 1 >( ) ;
 269         if( t_.isPast( ) )
 270                 {
 271                         os << " (past)" ;
 272                 }
 273         os << " / " << path_->duration( ) ;
 274 }
 275
 276 void
 277 Lang::PathSlider2D::gcMark( Kernel::GCMarkedSet & marked )
 278 {
 279         const_cast< Lang::ElementaryPath2D * >( path_.getPtr( ) )->gcMark( marked );
 280 }
 281
 282
 283 RefCountPtr< const Lang::Value >
 284 Lang::PathSlider2D::getRear( ) const
 285 {
 286         return RefCountPtr< const Lang::Value >( NullPtr< const Lang::Value >( ) );
 287 }
 288
 289 RefCountPtr< const Lang::Value >
 290 Lang::PathSlider2D::getFront( ) const
 291 {
 292         return RefCountPtr< const Lang::Value >( NullPtr< const Lang::Value >( ) );
 293 }
 294
 295
 296 Lang::PathSlider2D_rear::PathSlider2D_rear( const Lang::PathSlider2D & orig, const RefCountPtr< const Lang::Value > & rear )
 297         : PathSlider2D( orig ), rear_( rear )
 298 { }
 299
 300 RefCountPtr< const Lang::Value >
 301 Lang::PathSlider2D_rear::getRear( ) const
 302 {
 303         return rear_;
 304 }
 305
 306 Lang::PathSlider2D_front::PathSlider2D_front( const Lang::PathSlider2D & orig, const RefCountPtr< const Lang::Value > & front )
 307         : PathSlider2D( orig ), front_( front )
 308 { }
 309
 310 RefCountPtr< const Lang::Value >
 311 Lang::PathSlider2D_front::getFront( ) const
 312 {
 313         return front_;
 314 }