source/pathslider3D.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::PathSlider3D::PathSlider3D( const Lang::PathSlider3D & orig )
  37         : path_( orig.getPath( ) ), t_( orig.getTime( ) ), info_( orig.getInfo( ) )
  38 { }
  39
  40 Lang::PathSlider3D::PathSlider3D( const RefCountPtr< const Lang::ElementaryPath3D > & path )
  41         : path_( path ), t_( 0 ), info_( Kernel::THE_VOID_VARIABLE )
  42 { }
  43
  44 Lang::PathSlider3D::PathSlider3D( const RefCountPtr< const Lang::ElementaryPath3D > & path, Concrete::SplineTime t )
  45         : path_( path ), t_( t ), info_( Kernel::THE_VOID_VARIABLE )
  46 { }
  47
  48 Lang::PathSlider3D::PathSlider3D( const RefCountPtr< const Lang::ElementaryPath3D > & path, Concrete::SplineTime t, Kernel::VariableHandle info )
  49         : path_( path ), t_( t ), info_( info )
  50 { }
  51
  52 DISPATCHIMPL( PathSlider3D );
  53
  54 Lang::PathSlider3D::~PathSlider3D( )
  55 { }
  56
  57 RefCountPtr< const Lang::Class > Lang::PathSlider3D::TypeID( new Lang::SystemFinalClass( strrefdup( "PathSlider3D" ) ) );
  58 TYPEINFOIMPL( PathSlider3D );
  59
  60 Kernel::VariableHandle
  61 Lang::PathSlider3D::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, "B" ) == 0 )
  92                 {
  93                         return Kernel::VariableHandle( new Kernel::Variable( binormal( ) ) );
  94                 }
  95         if( strcmp( fieldID, "rB" ) == 0 )
  96                 {
  97                         return Kernel::VariableHandle( new Kernel::Variable( reverse_binormal( ) ) );
  98                 }
  99         if( strcmp( fieldID, "ik" ) == 0 )
 100                 {
 101                         return Kernel::VariableHandle( new Kernel::Variable( radiusOfCurvature( ) ) );
 102                 }
 103         if( strcmp( fieldID, "rik" ) == 0 )
 104                 {
 105                         return Kernel::VariableHandle( new Kernel::Variable( reverse_radiusOfCurvature( ) ) );
 106                 }
 107         if( strcmp( fieldID, "it" ) == 0 )
 108                 {
 109                         return Kernel::VariableHandle( new Kernel::Variable( radiusOfTorsion( ) ) );
 110                 }
 111         if( strcmp( fieldID, "rit" ) == 0 )
 112                 {
 113                         return Kernel::VariableHandle( new Kernel::Variable( reverse_radiusOfTorsion( ) ) );
 114                 }
 115         if( strcmp( fieldID, "time" ) == 0 )
 116                 {
 117                         return Kernel::VariableHandle( new Kernel::Variable( time( ) ) );
 118                 }
 119         if( strcmp( fieldID, "length" ) == 0 )
 120                 {
 121                         return Kernel::VariableHandle( new Kernel::Variable( length( ) ) );
 122                 }
 123         if( strcmp( fieldID, "past" ) == 0 )
 124                 {
 125                         if( t_.isPast( ) )
 126                                 {
 127                                         return Kernel::THE_TRUE_VARIABLE;
 128                                 }
 129                         return Kernel::THE_FALSE_VARIABLE;
 130                 }
 131         if( strcmp( fieldID, "looped" ) == 0 )
 132                 {
 133                         if( t_.t( ) > Concrete::Time( path_->duration( ) ) ||
 134                                         t_.t( ) < Concrete::Time( 0 ) )
 135                                 {
 136                                         return Kernel::THE_TRUE_VARIABLE;
 137                                 }
 138                         return Kernel::THE_FALSE_VARIABLE;
 139                 }
 140         if( strcmp( fieldID, "mod" ) == 0 )
 141                 {
 142                         return Helpers::newValHandle( new Lang::PathSlider3D( path_, modPhysical( t_.t( ), Concrete::Time( path_->duration( ) ) ) ) );
 143                 }
 144         if( strcmp( fieldID, "info" ) == 0 )
 145                 {
 146                         return info_;
 147                 }
 148         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 149 }
 150
 151 RefCountPtr< Lang::PathSlider3D >
 152 Lang::PathSlider3D::move_time( const Concrete::Time delta ) const
 153 {
 154         Concrete::Time newTime = t_.t( ) + delta;
 155         if( path_->isClosed( ) )
 156                 {
 157                         return RefCountPtr< Lang::PathSlider3D >( new Lang::PathSlider3D( path_, newTime ) );
 158                 }
 159         return RefCountPtr< Lang::PathSlider3D >( new Lang::PathSlider3D( path_,
 160                                                                                                                                                                                                                                                                                 Concrete::SplineTime( newTime,
 161                                                                                                                                                                                                                                                                                                                                                                         Concrete::Time( 0 ) <= newTime &&
 162                                                                                                                                                                                                                                                                                                                                                                         newTime <= Concrete::Time( path_->duration( ) ) ) ) );
 163 }
 164
 165 RefCountPtr< Lang::PathSlider3D >
 166 Lang::PathSlider3D::move_length( const Concrete::Length delta ) const
 167 {
 168         return RefCountPtr< Lang::PathSlider3D >( new Lang::PathSlider3D( path_, path_->arcTime( delta, t_.t( ) ) ) );
 169 }
 170
 171 RefCountPtr< Lang::PathSlider3D >
 172 Lang::PathSlider3D::seek_time( const Concrete::Time newTime ) const
 173 {
 174         if( path_->isClosed( ) )
 175                 {
 176                         return RefCountPtr< Lang::PathSlider3D >( new Lang::PathSlider3D( path_, newTime ) );
 177                 }
 178         return RefCountPtr< Lang::PathSlider3D >( new Lang::PathSlider3D( path_,
 179                                                                                                                                                                                                                                                                                 Concrete::SplineTime( newTime,
 180                                                                                                                                                                                                                                                                                                                                                                         Concrete::Time( 0 ) <= newTime &&
 181                                                                                                                                                                                                                                                                                                                                                                         newTime <= Concrete::Time( path_->duration( ) ) ) ) );
 182 }
 183
 184 RefCountPtr< Lang::PathSlider3D >
 185 Lang::PathSlider3D::seek_start( ) const
 186 {
 187         return RefCountPtr< Lang::PathSlider3D >( new Lang::PathSlider3D( path_, Concrete::Time( 0. ) ) );
 188 }
 189
 190 RefCountPtr< Lang::PathSlider3D >
 191 Lang::PathSlider3D::seek_end( ) const
 192 {
 193         return RefCountPtr< Lang::PathSlider3D >( new Lang::PathSlider3D( path_, Concrete::Time( path_->duration( ) ) ) );
 194 }
 195
 196 RefCountPtr< Lang::PathSlider3D >
 197 Lang::PathSlider3D::seek_length( const Concrete::Length val ) const
 198 {
 199         return RefCountPtr< Lang::PathSlider3D >( new Lang::PathSlider3D( path_, path_->arcTime( val ) ) );
 200 }
 201
 202
 203 RefCountPtr< const Lang::Coords3D >
 204 Lang::PathSlider3D::point( ) const
 205 {
 206         return path_->point( t_.t( ) );
 207 }
 208
 209 RefCountPtr< const Lang::Length >
 210 Lang::PathSlider3D::speed( ) const
 211 {
 212         return path_->speed( t_.t( ) );
 213 }
 214
 215 RefCountPtr< const Lang::Length >
 216 Lang::PathSlider3D::reverse_speed( ) const
 217 {
 218         return path_->reverse_speed( t_.t( ) );
 219 }
 220
 221 RefCountPtr< const Lang::FloatTriple >
 222 Lang::PathSlider3D::direction( ) const
 223 {
 224         return path_->direction( t_.t( ) );
 225 }
 226
 227 RefCountPtr< const Lang::FloatTriple >
 228 Lang::PathSlider3D::reverse_direction( ) const
 229 {
 230         return path_->reverse_direction( t_.t( ) );
 231 }
 232
 233 RefCountPtr< const Lang::FloatTriple >
 234 Lang::PathSlider3D::normal( ) const
 235 {
 236         return path_->normal( t_.t( ) );
 237 }
 238
 239 RefCountPtr< const Lang::FloatTriple >
 240 Lang::PathSlider3D::reverse_normal( ) const
 241 {
 242         return path_->reverse_normal( t_.t( ) );
 243 }
 244
 245 RefCountPtr< const Lang::FloatTriple >
 246 Lang::PathSlider3D::binormal( ) const
 247 {
 248         RefCountPtr< const Lang::FloatTriple > tmp_T = path_->direction( t_.t( ) );
 249         RefCountPtr< const Lang::FloatTriple > tmp_N = path_->normal( t_.t( ) );
 250         return RefCountPtr< const Lang::FloatTriple >( new Lang::FloatTriple( Lang::cross( *tmp_T, *tmp_N ) ) );
 251 }
 252
 253 RefCountPtr< const Lang::FloatTriple >
 254 Lang::PathSlider3D::reverse_binormal( ) const
 255 {
 256         RefCountPtr< const Lang::FloatTriple > tmp_T = path_->reverse_direction( t_.t( ) );
 257         RefCountPtr< const Lang::FloatTriple > tmp_N = path_->reverse_normal( t_.t( ) );
 258         return RefCountPtr< const Lang::FloatTriple >( new Lang::FloatTriple( Lang::cross( *tmp_T, *tmp_N ) ) );
 259 }
 260
 261 RefCountPtr< const Lang::Length >
 262 Lang::PathSlider3D::radiusOfCurvature( ) const
 263 {
 264         return path_->radiusOfCurvature( t_.t( ) );
 265 }
 266
 267 RefCountPtr< const Lang::Length >
 268 Lang::PathSlider3D::reverse_radiusOfCurvature( ) const
 269 {
 270         return path_->reverse_radiusOfCurvature( t_.t( ) );
 271 }
 272
 273 RefCountPtr< const Lang::Length >
 274 Lang::PathSlider3D::radiusOfTorsion( ) const
 275 {
 276         return path_->radiusOfTorsion( t_.t( ) );
 277 }
 278
 279 RefCountPtr< const Lang::Length >
 280 Lang::PathSlider3D::reverse_radiusOfTorsion( ) const
 281 {
 282         return path_->reverse_radiusOfTorsion( t_.t( ) );
 283 }
 284
 285 RefCountPtr< const Lang::Float >
 286 Lang::PathSlider3D::time( ) const
 287 {
 288         return RefCountPtr< const Lang::Float >( new Lang::Float( t_.t( ).offtype< 0, 1 >( ) ) );
 289 }
 290
 291 RefCountPtr< const Lang::Length >
 292 Lang::PathSlider3D::length( ) const
 293 {
 294         return RefCountPtr< const Lang::Length >( new Lang::Length( path_->arcLength( t_.t( ) ) ) );
 295 }
 296
 297
 298 void
 299 Lang::PathSlider3D::show( std::ostream & os ) const
 300 {
 301         os << "Path slider " ;
 302         if( this->getRear( ) != NullPtr< const Lang::Value >( ) )
 303                 {
 304                         os << "(with rear) " ;
 305                 }
 306         if( this->getFront( ) != NullPtr< const Lang::Value >( ) )
 307                 {
 308                         os << "(with front) " ;
 309                 }
 310         os << " at " << t_.t( ).offtype< 0, 1 >( ) ;
 311         if( t_.isPast( ) )
 312                 {
 313                         os << " (past)" ;
 314                 }
 315         os << " / " << path_->duration( );
 316 }
 317
 318 void
 319 Lang::PathSlider3D::gcMark( Kernel::GCMarkedSet & marked )
 320 {
 321         const_cast< Lang::ElementaryPath3D * >( path_.getPtr( ) )->gcMark( marked );
 322 }
 323
 324
 325 RefCountPtr< const Lang::Value >
 326 Lang::PathSlider3D::getRear( ) const
 327 {
 328         return RefCountPtr< const Lang::Value >( NullPtr< const Lang::Value >( ) );
 329 }
 330
 331 RefCountPtr< const Lang::Value >
 332 Lang::PathSlider3D::getFront( ) const
 333 {
 334         return RefCountPtr< const Lang::Value >( NullPtr< const Lang::Value >( ) );
 335 }
 336
 337
 338 Lang::PathSlider3D_rear::PathSlider3D_rear( const Lang::PathSlider3D & orig, const RefCountPtr< const Lang::Value > & rear )
 339         : PathSlider3D( orig ), rear_( rear )
 340 { }
 341
 342 RefCountPtr< const Lang::Value >
 343 Lang::PathSlider3D_rear::getRear( ) const
 344 {
 345         return rear_;
 346 }
 347
 348 Lang::PathSlider3D_front::PathSlider3D_front( const Lang::PathSlider3D & orig, const RefCountPtr< const Lang::Value > & front )
 349         : PathSlider3D( orig ), front_( front )
 350 { }
 351
 352 RefCountPtr< const Lang::Value >
 353 Lang::PathSlider3D_front::getFront( ) const
 354 {
 355         return front_;
 356 }