source/corepoint.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, 2014 Henrik Tidefelt
  17  */
  18
  19 #include <cmath>
  20
  21 #include "Shapes_Helpers_decls.h"
  22
  23 #include "shapescore.h"
  24 #include "ast.h"
  25 #include "globals.h"
  26 #include "shapesexceptions.h"
  27 #include "consts.h"
  28 #include "simplepdfi.h"
  29
  30 #include <iostream>
  31 #include <sstream>
  32 #include <fstream>
  33 #include <vector>
  34 #include <stdio.h>
  35
  36 using namespace Shapes;
  37
  38
  39 namespace Shapes
  40 {
  41         namespace Lang
  42         {
  43                 class Core_duration : public Lang::CoreFunction
  44                 {
  45                 public:
  46                         Core_duration( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
  47                         virtual void
  48                         call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
  49                         {
  50                                 const size_t ARITY = 1;
  51                                 CHECK_ARITY( args, ARITY, id_ );
  52
  53                                 try
  54                                         {
  55                                                 typedef const Lang::ElementaryPath2D ArgType;
  56                                                 RefCountPtr< ArgType > arg = Helpers::elementaryPathTry2D( args.getValue( 0 ) );
  57                                                 Kernel::ContRef cont = evalState->cont_;
  58                                                 cont->takeValue( Kernel::ValueRef( new Lang::Integer( arg->duration( ) ) ),
  59                                                                                                                  evalState );
  60                                                 return;
  61                                         }
  62                                 catch( const NonLocalExit::NotThisType & ball )
  63                                         {
  64                                                 /* Wrong type; never mind!.. but see below!
  65                                                  */
  66                                         }
  67
  68                                 try
  69                                         {
  70                                                 typedef const Lang::ElementaryPath3D ArgType;
  71                                                 RefCountPtr< ArgType > arg = Helpers::elementaryPathTry3D( args.getValue( 0 ) );
  72                                                 Kernel::ContRef cont = evalState->cont_;
  73                                                 cont->takeValue( Kernel::ValueRef( new Lang::Integer( arg->duration( ) ) ),
  74                                                                                                                  evalState );
  75                                                 return;
  76                                         }
  77                                 catch( const NonLocalExit::NotThisType & ball )
  78                                         {
  79                                                 /* Wrong type; never mind!.. but see below!
  80                                                  */
  81                                         }
  82
  83                                 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, 0, Helpers::typeSetString( Lang::ElementaryPath2D::staticTypeName( ), Lang::ElementaryPath3D::staticTypeName( ) ) );
  84                         }
  85                 };
  86
  87                 class Core_controlling_maximizer : public Lang::CoreFunction
  88                 {
  89                 public:
  90                         Core_controlling_maximizer( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
  91                         virtual void
  92                         call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
  93                         {
  94                                 const size_t ARITY = 2;
  95                                 CHECK_ARITY( args, ARITY, id_ );
  96
  97                                 {
  98                                         typedef const Lang::ElementaryPath2D ArgType0;
  99                                         RefCountPtr< ArgType0 > p = NullPtr< ArgType0 >( );
 100                                         size_t argsi = 0;
 101                                         try
 102                                                 {
 103                                                         p = Helpers::elementaryPathTry2D( args.getValue( argsi ) );
 104                                                 }
 105                                         catch( const NonLocalExit::NotThisType & ball )
 106                                                 {
 107                                                         goto nextType1;
 108                                                 }
 109
 110                                         ++argsi;
 111
 112                                         typedef const Lang::FloatPair ArgType1;
 113                                         RefCountPtr< ArgType1 > d = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, argsi, callLoc );
 114
 115                                         Kernel::ContRef cont = evalState->cont_;
 116                                         cont->takeValue( p->controllingMaximizer( *d ),
 117                                                                                                          evalState );
 118                                         return;
 119                                 }
 120
 121                         nextType1:
 122
 123                                 {
 124                                         typedef const Lang::ElementaryPath3D ArgType0;
 125                                         RefCountPtr< ArgType0 > p = NullPtr< ArgType0 >( );
 126                                         size_t argsi = 0;
 127                                         try
 128                                                 {
 129                                                         p = Helpers::elementaryPathTry3D( args.getValue( argsi ) );
 130                                                 }
 131                                         catch( const NonLocalExit::NotThisType & ball )
 132                                                 {
 133                                                         goto nextType2;
 134                                                 }
 135
 136                                         ++argsi;
 137
 138                                         typedef const Lang::FloatTriple ArgType1;
 139                                         RefCountPtr< ArgType1 > d = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, argsi, callLoc );
 140
 141                                         Kernel::ContRef cont = evalState->cont_;
 142                                         cont->takeValue( p->controllingMaximizer( *d ),
 143                                                                                                          evalState );
 144                                         return;
 145                                 }
 146
 147                         nextType2:
 148                                 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, 0, Helpers::typeSetString( Lang::ElementaryPath2D::staticTypeName( ), Lang::ElementaryPath3D::staticTypeName( ) ) );
 149                         }
 150                 };
 151
 152                 class Core_discrete_mean : public Lang::CoreFunction
 153                 {
 154                 public:
 155                         Core_discrete_mean( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
 156                         virtual void
 157                         call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
 158                         {
 159                                 const size_t ARITY = 1;
 160                                 CHECK_ARITY( args, ARITY, id_ );
 161
 162                                 size_t argsi = 0;
 163
 164                                 try
 165                                         {
 166                                                 typedef const Lang::ElementaryPath2D ArgType;
 167                                                 RefCountPtr< ArgType > p = Helpers::elementaryPathTry2D( args.getValue( argsi ) );
 168                                                 Kernel::ContRef cont = evalState->cont_;
 169                                                 cont->takeValue( p->discreteMean( ),
 170                                                                                                                  evalState );
 171                                                 return;
 172                                         }
 173                                 catch( const NonLocalExit::NotThisType & ball )
 174                                         {
 175                                                 /* Wrong type; never mind!.. but see below!
 176                                                  */
 177                                         }
 178
 179                                 try
 180                                         {
 181                                                 typedef const Lang::ElementaryPath3D ArgType;
 182                                                 RefCountPtr< ArgType > p = Helpers::elementaryPathTry3D( args.getValue( argsi ) );
 183                                                 Kernel::ContRef cont = evalState->cont_;
 184                                                 cont->takeValue( p->discreteMean( ),
 185                                                                                                                  evalState );
 186                                                 return;
 187                                         }
 188                                 catch( const NonLocalExit::NotThisType & ball )
 189                                         {
 190                                                 /* Wrong type; never mind!.. but see below!
 191                                                  */
 192                                         }
 193
 194                                 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, 0, Helpers::typeSetString( Lang::ElementaryPath2D::staticTypeName( ), Lang::ElementaryPath3D::staticTypeName( ) ) );
 195                         }
 196                 };
 197
 198                 class Core_discrete_maximizer : public Lang::CoreFunction
 199                 {
 200                 public:
 201                         Core_discrete_maximizer( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
 202                         virtual void
 203                         call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
 204                         {
 205                                 const size_t ARITY = 2;
 206                                 CHECK_ARITY( args, ARITY, id_ );
 207
 208                                 {
 209                                         typedef const Lang::ElementaryPath2D ArgType0;
 210                                         RefCountPtr< ArgType0 > p = NullPtr< ArgType0 >( );
 211                                         size_t argsi = 0;
 212                                         try
 213                                                 {
 214                                                         p = Helpers::elementaryPathTry2D( args.getValue( argsi ) );
 215                                                 }
 216                                         catch( const NonLocalExit::NotThisType & ball )
 217                                                 {
 218                                                         goto nextType1;
 219                                                 }
 220
 221                                         ++argsi;
 222
 223                                         typedef const Lang::FloatPair ArgType1;
 224                                         RefCountPtr< ArgType1 > d = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, argsi, callLoc );
 225
 226                                         Kernel::ContRef cont = evalState->cont_;
 227                                         typedef const Lang::PathSlider2D ResultType;
 228                                         cont->takeValue( RefCountPtr< ResultType >( new ResultType( p, p->discreteMaximizer( *d ) ) ),
 229                                                                                                          evalState );
 230                                         return;
 231                                 }
 232
 233                         nextType1:
 234
 235                                 {
 236                                         typedef const Lang::ElementaryPath3D ArgType0;
 237                                         RefCountPtr< ArgType0 > p = NullPtr< ArgType0 >( );
 238                                         size_t argsi = 0;
 239                                         try
 240                                                 {
 241                                                         p = Helpers::elementaryPathTry3D( args.getValue( argsi ) );
 242                                                 }
 243                                         catch( const NonLocalExit::NotThisType & ball )
 244                                                 {
 245                                                         goto nextType2;
 246                                                 }
 247
 248                                         ++argsi;
 249
 250                                         typedef const Lang::FloatTriple ArgType1;
 251                                         RefCountPtr< ArgType1 > d = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, argsi, callLoc );
 252
 253                                         Kernel::ContRef cont = evalState->cont_;
 254                                         typedef const Lang::PathSlider3D ResultType;
 255                                         cont->takeValue( RefCountPtr< ResultType >( new ResultType( p, p->discreteMaximizer( *d ) ) ),
 256                                                                                                          evalState );
 257                                         return;
 258                                 }
 259
 260                         nextType2:
 261                                 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, 0, Helpers::typeSetString( Lang::ElementaryPath2D::staticTypeName( ), Lang::ElementaryPath3D::staticTypeName( ) ) );
 262                         }
 263                 };
 264
 265                 class Core_discrete_approximator : public Lang::CoreFunction
 266                 {
 267                 public:
 268                         Core_discrete_approximator( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
 269                         virtual void
 270                         call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
 271                         {
 272                                 const size_t ARITY = 2;
 273                                 CHECK_ARITY( args, ARITY, id_ );
 274
 275                                 {
 276                                         typedef const Lang::ElementaryPath2D ArgType0;
 277                                         RefCountPtr< ArgType0 > p = NullPtr< ArgType0 >( );
 278                                         size_t argsi = 0;
 279                                         try
 280                                                 {
 281                                                         p = Helpers::elementaryPathTry2D( args.getValue( argsi ) );
 282                                                 }
 283                                         catch( const NonLocalExit::NotThisType & ball )
 284                                                 {
 285                                                         goto nextType1;
 286                                                 }
 287
 288                                         ++argsi;
 289
 290                                         typedef const Lang::Coords2D ArgType1;
 291                                         RefCountPtr< ArgType1 > d = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, argsi, callLoc );
 292
 293                                         Kernel::ContRef cont = evalState->cont_;
 294                                         typedef const Lang::PathSlider2D ResultType;
 295                                         cont->takeValue( RefCountPtr< ResultType >( new ResultType( p, p->discreteApproximator( *d ) ) ),
 296                                                                                                          evalState );
 297                                         return;
 298                                 }
 299
 300                         nextType1:
 301
 302                                 {
 303                                         typedef const Lang::ElementaryPath3D ArgType0;
 304                                         RefCountPtr< ArgType0 > p = NullPtr< ArgType0 >( );
 305                                         size_t argsi = 0;
 306                                         try
 307                                                 {
 308                                                         p = Helpers::elementaryPathTry3D( args.getValue( argsi ) );
 309                                                 }
 310                                         catch( const NonLocalExit::NotThisType & ball )
 311                                                 {
 312                                                         goto nextType2;
 313                                                 }
 314
 315                                         ++argsi;
 316
 317                                         typedef const Lang::Coords3D ArgType1;
 318                                         RefCountPtr< ArgType1 > d = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, argsi, callLoc );
 319
 320                                         Kernel::ContRef cont = evalState->cont_;
 321                                         typedef const Lang::PathSlider3D ResultType;
 322                                         cont->takeValue( RefCountPtr< ResultType >( new ResultType( p, p->discreteApproximator( *d ) ) ),
 323                                                                                                          evalState );
 324                                         return;
 325                                 }
 326
 327                         nextType2:
 328                                 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, 0, Helpers::typeSetString( Lang::ElementaryPath2D::staticTypeName( ), Lang::ElementaryPath3D::staticTypeName( ) ) );
 329                         }
 330                 };
 331
 332                 class Core_continuous_mean : public Lang::CoreFunction
 333                 {
 334                 public:
 335                         Core_continuous_mean( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
 336                         virtual void
 337                         call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
 338                         {
 339                                 const size_t ARITY = 1;
 340                                 CHECK_ARITY( args, ARITY, id_ );
 341
 342                                 size_t argsi = 0;
 343
 344                                 try
 345                                         {
 346                                                 typedef const Lang::ElementaryPath2D ArgType;
 347                                                 RefCountPtr< ArgType > p = Helpers::elementaryPathTry2D( args.getValue( argsi ) );
 348                                                 Kernel::ContRef cont = evalState->cont_;
 349                                                 cont->takeValue( p->continuousMean( ),
 350                                                                                                                  evalState );
 351                                                 return;
 352                                         }
 353                                 catch( const NonLocalExit::NotThisType & ball )
 354                                         {
 355                                                 /* Wrong type; never mind!.. but see below!
 356                                                  */
 357                                         }
 358
 359                                 try
 360                                         {
 361                                                 typedef const Lang::ElementaryPath3D ArgType;
 362                                                 RefCountPtr< ArgType > p = Helpers::elementaryPathTry3D( args.getValue( argsi ) );
 363                                                 Kernel::ContRef cont = evalState->cont_;
 364                                                 cont->takeValue( p->continuousMean( ),
 365                                                                                                                  evalState );
 366                                                 return;
 367                                         }
 368                                 catch( const NonLocalExit::NotThisType & ball )
 369                                         {
 370                                                 /* Wrong type; never mind!.. but see below!
 371                                                  */
 372                                         }
 373
 374                                 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, 0, Helpers::typeSetString( Lang::ElementaryPath2D::staticTypeName( ), Lang::ElementaryPath3D::staticTypeName( ) ) );
 375                         }
 376                 };
 377
 378                 class Core_continuous_maximizer : public Lang::CoreFunction
 379                 {
 380                 public:
 381                         Core_continuous_maximizer( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
 382                         virtual void
 383                         call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
 384                         {
 385                                 const size_t ARITY = 2;
 386                                 CHECK_ARITY( args, ARITY, id_ );
 387
 388                                 {
 389                                         typedef const Lang::ElementaryPath2D ArgType0;
 390                                         RefCountPtr< ArgType0 > p = NullPtr< ArgType0 >( );
 391                                         size_t argsi = 0;
 392                                         try
 393                                                 {
 394                                                         p = Helpers::elementaryPathTry2D( args.getValue( argsi ) );
 395                                                 }
 396                                         catch( const NonLocalExit::NotThisType & ball )
 397                                                 {
 398                                                         goto nextType1;
 399                                                 }
 400
 401                                         ++argsi;
 402
 403                                         typedef const Lang::FloatPair ArgType1;
 404                                         RefCountPtr< ArgType1 > d = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, argsi, callLoc );
 405
 406                                         Kernel::ContRef cont = evalState->cont_;
 407                                         typedef const Lang::PathSlider2D ResultType;
 408                                         cont->takeValue( RefCountPtr< ResultType >( new ResultType( p, p->continuousMaximizer( *d ) ) ),
 409                                                                                                          evalState );
 410                                         return;
 411                                 }
 412
 413                         nextType1:
 414
 415                                 {
 416                                         typedef const Lang::ElementaryPath3D ArgType0;
 417                                         RefCountPtr< ArgType0 > p = NullPtr< ArgType0 >( );
 418                                         size_t argsi = 0;
 419                                         try
 420                                                 {
 421                                                         p = Helpers::elementaryPathTry3D( args.getValue( argsi ) );
 422                                                 }
 423                                         catch( const NonLocalExit::NotThisType & ball )
 424                                                 {
 425                                                         goto nextType2;
 426                                                 }
 427
 428                                         ++argsi;
 429
 430                                         typedef const Lang::FloatTriple ArgType1;
 431                                         RefCountPtr< ArgType1 > d = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, argsi, callLoc );
 432
 433                                         Kernel::ContRef cont = evalState->cont_;
 434                                         typedef const Lang::PathSlider3D ResultType;
 435                                         cont->takeValue( RefCountPtr< ResultType >( new ResultType( p, p->continuousMaximizer( *d ) ) ),
 436                                                                                                          evalState );
 437                                         return;
 438                                 }
 439
 440                         nextType2:
 441                                 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, 0, Helpers::typeSetString( Lang::ElementaryPath2D::staticTypeName( ), Lang::ElementaryPath3D::staticTypeName( ) ) );
 442                         }
 443                 };
 444
 445                 class Core_continuous_approximator : public Lang::CoreFunction
 446                 {
 447                 public:
 448                         Core_continuous_approximator( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
 449                         virtual void
 450                         call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
 451                         {
 452                                 const size_t ARITY = 2;
 453                                 CHECK_ARITY( args, ARITY, id_ );
 454
 455                                 {
 456                                         typedef const Lang::ElementaryPath2D ArgType0;
 457                                         RefCountPtr< ArgType0 > p = NullPtr< ArgType0 >( );
 458                                         size_t argsi = 0;
 459                                         try
 460                                                 {
 461                                                         p = Helpers::elementaryPathTry2D( args.getValue( argsi ) );
 462                                                 }
 463                                         catch( const NonLocalExit::NotThisType & ball )
 464                                                 {
 465                                                         goto nextType1;
 466                                                 }
 467
 468                                         ++argsi;
 469
 470                                         {
 471                                                 typedef const Lang::Coords2D ArgType1;
 472                                                 try
 473                                                         {
 474                                                                 RefCountPtr< ArgType1 > d = Helpers::try_cast_CoreArgument< ArgType1 >( args.getValue( argsi ) );
 475
 476                                                                 Kernel::ContRef cont = evalState->cont_;
 477                                                                 typedef const Lang::PathSlider2D ResultType;
 478                                                                 cont->takeValue( RefCountPtr< ResultType >( new ResultType( p, p->continuousApproximator( *d ) ) ),
 479                                                                                                                                  evalState );
 480                                                                 return;
 481                                                         }
 482                                                 catch( const NonLocalExit::NotThisType & ball )
 483                                                         {
 484                                                                 goto nextType11;
 485                                                         }
 486                                         }
 487
 488                                 nextType11:
 489                                         {
 490                                                 typedef const Lang::ElementaryPath2D ArgType1;
 491                                                 RefCountPtr< ArgType1 > p2 = NullPtr< ArgType1 >( );
 492                                                 try
 493                                                         {
 494                                                                 p2 = Helpers::elementaryPathTry2D( args.getValue( argsi ) );
 495                                                                 RefCountPtr< const Lang::Structure > info = NullPtr< typeof *info >( );
 496                                                                 Concrete::SplineTime t = p->continuousApproximator( p2, & info );
 497                                                                 Kernel::ContRef cont = evalState->cont_;
 498                                                                 typedef const Lang::PathSlider2D ResultType;
 499                                                                 cont->takeValue( RefCountPtr< ResultType >( new ResultType( p, t, Kernel::VariableHandle( new Kernel::Variable( info ) ) ) ),
 500                                                                                                                                  evalState );
 501                                                                 return;
 502                                                         }
 503                                                 catch( const NonLocalExit::NotThisType & ball )
 504                                                         {
 505                                                                 goto nextType12;
 506                                                         }
 507                                         }
 508
 509                                 nextType12:
 510                                         throw Exceptions::CoreTypeMismatch( callLoc, id_, args, 1, Helpers::typeSetString( Lang::Coords2D::staticTypeName( ), Lang::ElementaryPath2D::staticTypeName( ) ) );
 511                                 }
 512
 513                         nextType1:
 514
 515                                 {
 516                                         typedef const Lang::ElementaryPath3D ArgType0;
 517                                         RefCountPtr< ArgType0 > p = NullPtr< ArgType0 >( );
 518                                         size_t argsi = 0;
 519                                         try
 520                                                 {
 521                                                         p = Helpers::elementaryPathTry3D( args.getValue( argsi ) );
 522                                                 }
 523                                         catch( const NonLocalExit::NotThisType & ball )
 524                                                 {
 525                                                         goto nextType2;
 526                                                 }
 527
 528                                         ++argsi;
 529
 530                                         {
 531                                                 typedef const Lang::Coords3D ArgType1;
 532                                                 try
 533                                                         {
 534                                                                 RefCountPtr< ArgType1 > d = Helpers::try_cast_CoreArgument< ArgType1 >( args.getValue( argsi ) );
 535
 536                                                                 Kernel::ContRef cont = evalState->cont_;
 537                                                                 typedef const Lang::PathSlider3D ResultType;
 538                                                                 cont->takeValue( RefCountPtr< ResultType >( new ResultType( p, p->continuousApproximator( *d ) ) ),
 539                                                                                                                                  evalState );
 540                                                                 return;
 541                                                         }
 542                                                 catch( const NonLocalExit::NotThisType & ball )
 543                                                         {
 544                                                                 goto nextType21;
 545                                                         }
 546                                         }
 547
 548                                 nextType21:
 549                                         {
 550                                                 typedef const Lang::ElementaryPath3D ArgType1;
 551                                                 RefCountPtr< ArgType1 > p2 = NullPtr< ArgType1 >( );
 552                                                 try
 553                                                         {
 554                                                                 p2 = Helpers::elementaryPathTry3D( args.getValue( argsi ) );
 555                                                                 RefCountPtr< const Lang::Structure > info = NullPtr< typeof *info >( );
 556                                                                 Concrete::SplineTime t = p->continuousApproximator( p2, & info );
 557                                                                 Kernel::ContRef cont = evalState->cont_;
 558                                                                 typedef const Lang::PathSlider3D ResultType;
 559                                                                 cont->takeValue( RefCountPtr< ResultType >( new ResultType( p, t, Kernel::VariableHandle( new Kernel::Variable( info ) ) ) ),
 560                                                                                                                                  evalState );
 561                                                                 return;
 562                                                         }
 563                                                 catch( const NonLocalExit::NotThisType & ball )
 564                                                         {
 565                                                                 goto nextType22;
 566                                                         }
 567                                         }
 568
 569                                 nextType22:
 570                                         throw Exceptions::CoreTypeMismatch( callLoc, id_, args, 1, Helpers::typeSetString( Lang::Coords3D::staticTypeName( ), Lang::ElementaryPath3D::staticTypeName( ) ) );
 571                                 }
 572
 573                         nextType2:
 574                                 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, 0, Helpers::typeSetString( Lang::ElementaryPath2D::staticTypeName( ), Lang::ElementaryPath3D::staticTypeName( ) ) );
 575                         }
 576                 };
 577
 578
 579                 class Core_intersection : public Lang::CoreFunction
 580                 {
 581                         mutable Kernel::Environment::LexicalKey * idKey;
 582                 public:
 583                         Core_intersection( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ), idKey( 0 ) { }
 584                         virtual ~Core_intersection( ) { if( idKey != 0 ){ delete idKey; } }
 585                         virtual void
 586                         call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
 587                         {
 588                                 const size_t ARITY = 2;
 589                                 CHECK_ARITY( args, ARITY, id_ );
 590
 591                                 typedef const Lang::ElementaryPath2D ArgType1;
 592                                 size_t argsi = 0;
 593                                 RefCountPtr< ArgType1 > p = Helpers::elementaryPathCast2D( id_, args, argsi, callLoc );
 594
 595                                 ++argsi;
 596
 597                                 typedef const Lang::ElementaryPath2D ArgType2;
 598                                 RefCountPtr< ArgType2 > p2 = Helpers::elementaryPathCast2D( id_, args, argsi, callLoc );
 599
 600                                 Kernel::ContRef cont = evalState->cont_;
 601                                 try
 602                                         {
 603                                                 RefCountPtr< const Lang::Structure > info = NullPtr< typeof *info >( );
 604                                                 Concrete::SplineTime t = p->intersection( p2, & info );
 605                                                 typedef const Lang::PathSlider2D ResultType;
 606                                                 cont->takeValue( RefCountPtr< ResultType >( new ResultType( p, t, Kernel::VariableHandle( new Kernel::Variable( info ) ) ) ),
 607                                                                                                                  evalState );
 608                                         }
 609                                 catch( const Exceptions::OutOfRange & ball )
 610                                         {
 611                                                 if( idKey == 0 )
 612                                                         {
 613                                                                 Ast::Identifier * handlerId = Lang::HANDLER_NO_INTERSECTION.newAbsolute( );
 614                                                                 idKey = new Kernel::Environment::LexicalKey( Ast::theGlobalAnalysisEnvironment->findLexicalDynamicKey( callLoc, *handlerId ) );
 615                                                                 delete handlerId;
 616                                                         }
 617
 618                                                 const Kernel::DynamicVariableProperties & dynProps = Kernel::theGlobalEnvironment->lookupDynamicVariable( *idKey );
 619
 620                                                 Kernel::VariableHandle handler = dynProps.fetch( evalState->dyn_ );
 621
 622                                                 typedef const Lang::Function HandlerType;
 623
 624                                                 RefCountPtr< HandlerType > fun( handler->getVal< HandlerType >( callLoc ) );
 625                                                 fun->call( evalState, args.getValue( 0 ), args.getValue( 1 ), callLoc );
 626                                         }
 627                         }
 628                 };
 629         }
 630 }
 631
 632
 633 void
 634 Kernel::registerCore_point( Kernel::Environment * env )
 635 {
 636         env->initDefineCoreFunction( new Lang::Core_duration( Lang::THE_NAMESPACE_Shapes_Geometry, "duration" ) );
 637         env->initDefineCoreFunction( new Lang::Core_controlling_maximizer( Lang::THE_NAMESPACE_Shapes_Geometry, "controlling_maximizer" ) );
 638         env->initDefineCoreFunction( new Lang::Core_discrete_mean( Lang::THE_NAMESPACE_Shapes_Geometry, "pathpoint_mean" ) );
 639         env->initDefineCoreFunction( new Lang::Core_discrete_maximizer( Lang::THE_NAMESPACE_Shapes_Geometry, "pathpoint_maximizer" ) );
 640         env->initDefineCoreFunction( new Lang::Core_discrete_approximator( Lang::THE_NAMESPACE_Shapes_Geometry, "pathpoint_approximator" ) );
 641         env->initDefineCoreFunction( new Lang::Core_continuous_mean( Lang::THE_NAMESPACE_Shapes_Geometry, "mean" ) );
 642         env->initDefineCoreFunction( new Lang::Core_continuous_maximizer( Lang::THE_NAMESPACE_Shapes_Geometry, "maximizer" ) );
 643         env->initDefineCoreFunction( new Lang::Core_continuous_approximator( Lang::THE_NAMESPACE_Shapes_Geometry, "approximator" ) );
 644         env->initDefineCoreFunction( new Lang::Core_intersection( Lang::THE_NAMESPACE_Shapes_Geometry, "intersection" ) );
 645 }