synfig-core/tags/0.61.09/src/synfig/valuenode_bline.cpp

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file valuenode_bline.cpp
   3 **      \brief Implementation of the "BLine" valuenode conversion.
   4 **
   5 **      $Id$
   6 **
   7 **      \legal
   8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
   9 **      Copyright (c) 2007, 2008 Chris Moore
  10 **
  11 **      This package is free software; you can redistribute it and/or
  12 **      modify it under the terms of the GNU General Public License as
  13 **      published by the Free Software Foundation; either version 2 of
  14 **      the License, or (at your option) any later version.
  15 **
  16 **      This package is distributed in the hope that it will be useful,
  17 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19 **      General Public License for more details.
  20 **      \endlegal
  21 */
  22 /* ========================================================================= */
  23
  24 /* === H E A D E R S ======================================================= */
  25
  26 #ifdef USING_PCH
  27 #       include "pch.h"
  28 #else
  29 #ifdef HAVE_CONFIG_H
  30 #       include <config.h>
  31 #endif
  32
  33 #include "valuenode_bline.h"
  34 #include "valuenode_const.h"
  35 #include "valuenode_composite.h"
  36 #include "general.h"
  37 #include "exception.h"
  38 #include "blinepoint.h"
  39 #include <vector>
  40 #include <list>
  41 #include <algorithm>
  42 #include <ETL/hermite>
  43 #include <ETL/calculus>
  44 #include "segment.h"
  45 #include "curve_helper.h"
  46
  47 #endif
  48
  49 /* === U S I N G =========================================================== */
  50
  51 using namespace std;
  52 using namespace etl;
  53 using namespace synfig;
  54
  55 /* === M A C R O S ========================================================= */
  56
  57 #define EPSILON 0.0000001f
  58
  59 /* === G L O B A L S ======================================================= */
  60
  61 /* === P R O C E D U R E S ================================================= */
  62
  63 inline float
  64 linear_interpolation(const float& a, const float& b, float c)
  65 { return (b-a)*c+a; }
  66
  67 inline Vector
  68 linear_interpolation(const Vector& a, const Vector& b, float c)
  69 { return (b-a)*c+a; }
  70
  71 inline Vector
  72 radial_interpolation(const Vector& a, const Vector& b, float c)
  73 {
  74         // if either extreme is zero then use linear interpolation instead
  75         if (a.is_equal_to(Vector::zero()) || b.is_equal_to(Vector::zero()))
  76                 return linear_interpolation(a, b, c);
  77
  78         affine_combo<Real,float> mag_combo;
  79         affine_combo<Angle,float> ang_combo;
  80
  81         Real mag(mag_combo(a.mag(),b.mag(),c));
  82         Angle ang(ang_combo(Angle::tan(a[1],a[0]),Angle::tan(b[1],b[0]),c));
  83
  84         return Point( mag*Angle::cos(ang).get(),mag*Angle::sin(ang).get() );
  85 }
  86
  87 inline void
  88 transform_coords(Vector in, Vector& out, const Point& coord_origin, const Point *coord_sys)
  89 {
  90         in -= coord_origin;
  91         out[0] = in * coord_sys[0];
  92         out[1] = in * coord_sys[1];
  93 }
  94
  95 inline void
  96 untransform_coords(const Vector& in, Vector& out, const Point& coord_origin, const Point *coord_sys)
  97 {
  98         out[0] = in * coord_sys[0];
  99         out[1] = in * coord_sys[1];
 100         out += coord_origin;
 101 }
 102
 103 ValueBase
 104 synfig::convert_bline_to_segment_list(const ValueBase& bline)
 105 {
 106         std::vector<Segment> ret;
 107
 108 //      std::vector<BLinePoint> list(bline.operator std::vector<BLinePoint>());
 109         //std::vector<BLinePoint> list(bline);
 110         std::vector<BLinePoint> list(bline.get_list().begin(),bline.get_list().end());
 111         std::vector<BLinePoint>::const_iterator iter;
 112
 113         BLinePoint prev,first;
 114
 115         //start with prev = first and iter on the second...
 116
 117         if(list.empty()) return ValueBase(ret,bline.get_loop());
 118         first = prev = list.front();
 119
 120         for(iter=++list.begin();iter!=list.end();++iter)
 121         {
 122                 ret.push_back(
 123                         Segment(
 124                                 prev.get_vertex(),
 125                                 prev.get_tangent2(),
 126                                 iter->get_vertex(),
 127                                 iter->get_tangent1()
 128                         )
 129                 );
 130                 prev=*iter;
 131         }
 132         if(bline.get_loop())
 133         {
 134                 ret.push_back(
 135                         Segment(
 136                                 prev.get_vertex(),
 137                                 prev.get_tangent2(),
 138                                 first.get_vertex(),
 139                                 first.get_tangent1()
 140                         )
 141                 );
 142         }
 143         return ValueBase(ret,bline.get_loop());
 144 }
 145
 146 ValueBase
 147 synfig::convert_bline_to_width_list(const ValueBase& bline)
 148 {
 149         std::vector<Real> ret;
 150 //      std::vector<BLinePoint> list(bline.operator std::vector<BLinePoint>());
 151         //std::vector<BLinePoint> list(bline);
 152         std::vector<BLinePoint> list(bline.get_list().begin(),bline.get_list().end());
 153         std::vector<BLinePoint>::const_iterator iter;
 154
 155         if(bline.empty())
 156                 return ValueBase(ValueBase::TYPE_LIST);
 157
 158         for(iter=list.begin();iter!=list.end();++iter)
 159                 ret.push_back(iter->get_width());
 160
 161         if(bline.get_loop())
 162                 ret.push_back(list.front().get_width());
 163
 164         return ValueBase(ret,bline.get_loop());
 165 }
 166
 167 Real
 168 synfig::find_closest_point(const ValueBase &bline, const Point &pos, Real &radius, bool loop, Point *out_point)
 169 {
 170         Real d,step;
 171         float time = 0;
 172         float best_time = 0;
 173         int best_index = -1;
 174         synfig::Point best_point;
 175
 176         if(radius==0)radius=10000000;
 177         Real closest(10000000);
 178
 179         int i=0;
 180         std::vector<BLinePoint> list(bline.get_list().begin(),bline.get_list().end());
 181         typedef std::vector<BLinePoint>::const_iterator iterT;
 182         iterT iter, prev, first;
 183         for(iter=list.begin(); iter!=list.end(); ++i, ++iter)
 184         {
 185                 if( first == iterT() )
 186                         first = iter;
 187
 188                 if( prev != iterT() )
 189                 {
 190                         bezier<Point>   curve;
 191
 192                         curve[0] = (*prev).get_vertex();
 193                         curve[1] = curve[0] + (*prev).get_tangent2()/3;
 194                         curve[3] = (*iter).get_vertex();
 195                         curve[2] = curve[3] - (*iter).get_tangent1()/3;
 196                         curve.sync();
 197
 198                         #if 0
 199                         // I don't know why this doesn't work
 200                         time=curve.find_closest(pos,6);
 201                         d=((curve(time)-pos).mag_squared());
 202
 203                         #else
 204                         //set the step size based on the size of the picture
 205                         d = (curve[1] - curve[0]).mag() + (curve[2]-curve[1]).mag()     + (curve[3]-curve[2]).mag();
 206
 207                         step = d/(2*radius); //want to make the distance between lines happy
 208
 209                         step = max(step,0.01); //100 samples should be plenty
 210                         step = min(step,0.1); //10 is minimum
 211
 212                         d = find_closest(curve,pos,step,&closest,&time);
 213                         #endif
 214
 215                         if(d < closest)
 216                         {
 217                                 closest = d;
 218                                 best_time = time;
 219                                 best_index = i;
 220                                 best_point = curve(best_time);
 221                         }
 222
 223                 }
 224
 225                 prev = iter;
 226         }
 227
 228         // Loop if necessary
 229         if( loop && ( first != iterT() ) && ( prev != iterT() ) )
 230         {
 231                 bezier<Point>   curve;
 232
 233                 curve[0] = (*prev).get_vertex();
 234                 curve[1] = curve[0] + (*prev).get_tangent2()/3;
 235                 curve[3] = (*first).get_vertex();
 236                 curve[2] = curve[3] - (*first).get_tangent1()/3;
 237                 curve.sync();
 238
 239                 #if 0
 240                 // I don't know why this doesn't work
 241                 time=curve.find_closest(pos,6);
 242                 d=((curve(time)-pos).mag_squared());
 243
 244                 #else
 245                 //set the step size based on the size of the picture
 246                 d = (curve[1] - curve[0]).mag() + (curve[2]-curve[1]).mag()     + (curve[3]-curve[2]).mag();
 247
 248                 step = d/(2*radius); //want to make the distance between lines happy
 249
 250                 step = max(step,0.01); //100 samples should be plenty
 251                 step = min(step,0.1); //10 is minimum
 252
 253                         d = find_closest(curve,pos,step,&closest,&time);
 254                 #endif
 255
 256                 if(d < closest)
 257                 {
 258                         closest = d;
 259                         best_time = time;
 260                         best_index = 0;
 261                         best_point = curve(best_time);
 262                 }
 263         }
 264
 265         if(best_index != -1)
 266         {
 267                 if(out_point)
 268                         *out_point = best_point;
 269
 270                 int loop_adjust(loop ? 0 : -1);
 271                 int size = list.size();
 272                 Real amount = (best_index + best_time + loop_adjust) / (size + loop_adjust);
 273                 return amount;
 274         }
 275
 276         return 0.0;
 277
 278 }
 279
 280 /* === M E T H O D S ======================================================= */
 281
 282
 283 ValueNode_BLine::ValueNode_BLine():
 284         ValueNode_DynamicList(ValueBase::TYPE_BLINEPOINT)
 285 {
 286 }
 287
 288 ValueNode_BLine::~ValueNode_BLine()
 289 {
 290 }
 291
 292 ValueNode_BLine*
 293 ValueNode_BLine::create(const ValueBase &value)
 294 {
 295         if(value.get_type()!=ValueBase::TYPE_LIST)
 296                 return 0;
 297
 298         ValueNode_BLine* value_node(new ValueNode_BLine());
 299
 300         if(!value.empty())
 301         {
 302                 switch(value.get_contained_type())
 303                 {
 304                 case ValueBase::TYPE_BLINEPOINT:
 305                 {
 306 //                      std::vector<BLinePoint> bline_points(value.operator std::vector<BLinePoint>());
 307                         //std::vector<BLinePoint> bline_points(value);
 308                         std::vector<BLinePoint> bline_points(value.get_list().begin(),value.get_list().end());
 309                         std::vector<BLinePoint>::const_iterator iter;
 310
 311                         for(iter=bline_points.begin();iter!=bline_points.end();iter++)
 312                         {
 313                                 value_node->add(ValueNode::Handle(ValueNode_Composite::create(*iter)));
 314                         }
 315                         value_node->set_loop(value.get_loop());
 316                 }
 317                         break;
 318                 case ValueBase::TYPE_SEGMENT:
 319                 {
 320                         // Here, we want to convert a list of segments
 321                         // into a list of BLinePoints. We make an assumption
 322                         // that the segment list is continuous(sp), but not necessarily
 323                         // smooth.
 324
 325                         value_node->set_loop(false);
 326 //                      std::vector<Segment> segments(value.operator std::vector<Segment>());
 327 //                      std::vector<Segment> segments(value);
 328                         std::vector<Segment> segments(value.get_list().begin(),value.get_list().end());
 329                         std::vector<Segment>::const_iterator iter,last(segments.end());
 330                         --last;
 331                         ValueNode_Const::Handle prev,first;
 332
 333                         for(iter=segments.begin();iter!=segments.end();iter++)
 334                         {
 335 #define PREV_POINT      prev->get_value().get(BLinePoint())
 336 #define FIRST_POINT     first->get_value().get(BLinePoint())
 337 #define CURR_POINT      curr->get_value().get(BLinePoint())
 338                                 if(iter==segments.begin())
 339                                 {
 340                                         prev=ValueNode_Const::create(ValueBase::TYPE_BLINEPOINT);
 341                                         {
 342                                                 BLinePoint prev_point(PREV_POINT);
 343                                                 prev_point.set_vertex(iter->p1);
 344                                                 prev_point.set_tangent1(iter->t1);
 345                                                 prev_point.set_width(0.01);
 346                                                 prev_point.set_origin(0.5);
 347                                                 prev_point.set_split_tangent_flag(false);
 348                                                 prev->set_value(prev_point);
 349                                         }
 350                                         first=prev;
 351                                         value_node->add(ValueNode::Handle(prev));
 352
 353                                 }
 354                                 if(iter==last && iter->p2.is_equal_to(FIRST_POINT.get_vertex()))
 355                                 {
 356                                         value_node->set_loop(true);
 357                                         if(!iter->t2.is_equal_to(FIRST_POINT.get_tangent1()))
 358                                         {
 359                                                 BLinePoint first_point(FIRST_POINT);
 360                                                 first_point.set_tangent1(iter->t2);
 361                                                 first->set_value(first_point);
 362                                         }
 363                                         continue;
 364                                 }
 365
 366                                 ValueNode_Const::Handle curr;
 367                                 curr=ValueNode_Const::create(ValueBase::TYPE_BLINEPOINT);
 368                                 {
 369                                         BLinePoint curr_point(CURR_POINT);
 370                                         curr_point.set_vertex(iter->p2);
 371                                         curr_point.set_tangent1(iter->t2);
 372                                         curr_point.set_width(0.01);
 373                                         curr_point.set_origin(0.5);
 374                                         curr_point.set_split_tangent_flag(false);
 375                                         curr->set_value(curr_point);
 376                                 }
 377                                 if(!PREV_POINT.get_tangent1().is_equal_to(iter->t1))
 378                                 {
 379                                         BLinePoint prev_point(PREV_POINT);
 380                                         prev_point.set_split_tangent_flag(true);
 381                                         prev_point.set_tangent2(iter->t1);
 382                                         prev->set_value(prev_point);
 383                                 }
 384                                 value_node->add(ValueNode::Handle(curr));
 385                                 prev=curr;
 386                         }
 387
 388                 }
 389                         break;
 390                 default:
 391                         // We got a list of who-knows-what. We don't have any idea
 392                         // what to do with it.
 393                         return 0;
 394                         break;
 395                 }
 396         }
 397
 398         return value_node;
 399 }
 400
 401 ValueNode_BLine::ListEntry
 402 ValueNode_BLine::create_list_entry(int index, Time time, Real origin)
 403 {
 404         ValueNode_BLine::ListEntry ret;
 405
 406         synfig::BLinePoint prev,next;
 407
 408         int prev_i,next_i;
 409
 410         index=index%link_count();
 411
 412         assert(index>=0);
 413         ret.index=index;
 414         ret.set_parent_value_node(this);
 415
 416         if(!list[index].status_at_time(time))
 417                 next_i=find_next_valid_entry(index,time);
 418         else
 419                 next_i=index;
 420         prev_i=find_prev_valid_entry(index,time);
 421
 422         //synfig::info("index=%d, next_i=%d, prev_i=%d",index,next_i,prev_i);
 423
 424         next=(*list[next_i].value_node)(time);
 425         prev=(*list[prev_i].value_node)(time);
 426
 427         etl::hermite<Vector> curve(prev.get_vertex(),next.get_vertex(),prev.get_tangent2(),next.get_tangent1());
 428         etl::derivative< etl::hermite<Vector> > deriv(curve);
 429
 430         synfig::BLinePoint bline_point;
 431         bline_point.set_vertex(curve(origin));
 432         bline_point.set_width((next.get_width()-prev.get_width())*origin+prev.get_width());
 433         bline_point.set_tangent1(deriv(origin)*min(1.0-origin,origin));
 434         bline_point.set_tangent2(bline_point.get_tangent1());
 435         bline_point.set_split_tangent_flag(false);
 436         bline_point.set_origin(origin);
 437
 438         ret.value_node=ValueNode_Composite::create(bline_point);
 439
 440         return ret;
 441 }
 442
 443 ValueBase
 444 ValueNode_BLine::operator()(Time t)const
 445 {
 446         std::vector<BLinePoint> ret_list;
 447
 448         std::vector<ListEntry>::const_iterator iter,first_iter;
 449         bool first_flag(true);
 450         bool rising;
 451         int index(0);
 452         float next_scale(1.0f);
 453
 454         BLinePoint prev,first;
 455         first.set_origin(100.0f);
 456
 457         // loop through all the list's entries
 458         for(iter=list.begin();iter!=list.end();++iter,index++)
 459         {
 460                 // how 'on' is this vertex?
 461                 float amount(iter->amount_at_time(t,&rising));
 462
 463                 assert(amount>=0.0f);
 464                 assert(amount<=1.0f);
 465
 466                 // it's fully on
 467                 if (amount > 1.0f - EPSILON)
 468                 {
 469                         if(first_flag)
 470                         {
 471                                 first_iter=iter;
 472                                 first=prev=(*iter->value_node)(t).get(prev);
 473                                 first_flag=false;
 474                                 ret_list.push_back(first);
 475                                 continue;
 476                         }
 477
 478                         BLinePoint curr;
 479                         curr=(*iter->value_node)(t).get(prev);
 480
 481                         if(next_scale!=1.0f)
 482                         {
 483                                 ret_list.back().set_split_tangent_flag(true);
 484                                 ret_list.back().set_tangent2(prev.get_tangent2()*next_scale);
 485
 486                                 ret_list.push_back(curr);
 487
 488                                 ret_list.back().set_split_tangent_flag(true);
 489                                 ret_list.back().set_tangent2(curr.get_tangent2());
 490                                 ret_list.back().set_tangent1(curr.get_tangent1()*next_scale);
 491
 492                                 next_scale=1.0f;
 493                         }
 494                         else
 495                         {
 496                                 ret_list.push_back(curr);
 497                         }
 498
 499                         prev=curr;
 500                 }
 501                 // it's partly on
 502                 else if(amount>0.0f)
 503                 {
 504                         std::vector<ListEntry>::const_iterator begin_iter,end_iter;
 505
 506                         // This is where the interesting stuff happens
 507                         // We need to seek forward in the list to see what the next
 508                         // active point is
 509
 510                         BLinePoint blp_here_on;  // the current vertex, when fully on
 511                         BLinePoint blp_here_off; // the current vertex, when fully off
 512                         BLinePoint blp_here_now; // the current vertex, right now (between on and off)
 513                         BLinePoint blp_prev_off; // the beginning of dynamic group when fully off
 514                         BLinePoint blp_next_off; // the end of the dynamic group when fully off
 515
 516                         int dist_from_begin(0), dist_from_end(0);
 517                         Time off_time, on_time;
 518
 519                         if(!rising)     // if not rising, then we were fully on in the past, and will be fully off in the future
 520                         {
 521                                 try{ on_time=iter->find_prev(t)->get_time(); }
 522                                 catch(...) { on_time=Time::begin(); }
 523                                 try{ off_time=iter->find_next(t)->get_time(); }
 524                                 catch(...) { off_time=Time::end(); }
 525                         }
 526                         else // otherwise we were fully off in the past, and will be fully on in the future
 527                         {
 528                                 try{ off_time=iter->find_prev(t)->get_time(); }
 529                                 catch(...) { off_time=Time::begin(); }
 530                                 try{ on_time=iter->find_next(t)->get_time(); }
 531                                 catch(...) { on_time=Time::end(); }
 532                         }
 533
 534                         blp_here_on=(*iter->value_node)(on_time).get(blp_here_on);
 535 //                      blp_here_on=(*iter->value_node)(t).get(blp_here_on);
 536
 537                         // Find "end" of dynamic group - ie. search forward along
 538                         // the bline from the current point until we find a point
 539                         // which is more 'on' than the current one
 540                         end_iter=iter;
 541 //                      for(++end_iter;begin_iter!=list.end();++end_iter)
 542                         for(++end_iter;end_iter!=list.end();++end_iter)
 543                                 if(end_iter->amount_at_time(t)>amount)
 544                                         break;
 545
 546                         // If we did not find an end of the dynamic group...
 547                         // Writeme!  at least now it doesn't crash if first_iter
 548                         // isn't set yet
 549                         if(end_iter==list.end())
 550                         {
 551                                 if(get_loop() && !first_flag)
 552                                         end_iter=first_iter;
 553                                 else
 554                                         end_iter=--list.end();
 555                         }
 556
 557                         blp_next_off=(*end_iter->value_node)(off_time).get(prev);
 558
 559                         // Find "begin" of dynamic group
 560                         begin_iter=iter;
 561                         blp_prev_off.set_origin(100.0f); // set the origin to 100 (which is crazy) so that we can check to see if it was found
 562                         do
 563                         {
 564                                 if(begin_iter==list.begin())
 565                                 {
 566                                         if(get_loop())
 567                                                 begin_iter=list.end();
 568                                         else
 569                                                 break;
 570                                 }
 571
 572                                 --begin_iter;
 573                                 dist_from_begin++;
 574
 575                                 // if we've gone all around the loop, give up
 576                                 if(begin_iter==iter)
 577                                         break;
 578
 579                                 if(begin_iter->amount_at_time(t)>amount)
 580                                 {
 581                                         blp_prev_off=(*begin_iter->value_node)(off_time).get(prev);
 582                                         break;
 583                                 }
 584                         }while(true);
 585
 586                         // If we did not find a begin
 587                         if(blp_prev_off.get_origin()==100.0f)
 588                         {
 589                                 // Writeme! - this needs work, but at least now it
 590                                 // doesn't crash
 591                                 if(first_flag)
 592                                         begin_iter=list.begin();
 593                                 else
 594                                         begin_iter=first_iter;
 595                                 blp_prev_off=(*begin_iter->value_node)(off_time).get(prev);
 596                         }
 597
 598                         // this is how the curve looks when we have completely vanished
 599                         etl::hermite<Vector> curve(blp_prev_off.get_vertex(),   blp_next_off.get_vertex(),
 600                                                                            blp_prev_off.get_tangent2(), blp_next_off.get_tangent1());
 601                         etl::derivative< etl::hermite<Vector> > deriv(curve);
 602
 603                         // where would we be on this curve, how wide will we be, and
 604                         // where will our tangents point (all assuming that we hadn't vanished)
 605                         blp_here_off.set_vertex(curve(blp_here_on.get_origin()));
 606                         blp_here_off.set_width((blp_next_off.get_width()-blp_prev_off.get_width())*blp_here_on.get_origin()+blp_prev_off.get_width());
 607                         blp_here_off.set_tangent1(deriv(blp_here_on.get_origin()));
 608                         blp_here_off.set_tangent2(deriv(blp_here_on.get_origin()));
 609
 610                         float prev_tangent_scalar(1.0f);
 611                         float next_tangent_scalar(1.0f);
 612
 613                         //synfig::info("index_%d:dist_from_begin=%d",index,dist_from_begin);
 614                         //synfig::info("index_%d:dist_from_end=%d",index,dist_from_end);
 615
 616                         // If we are the next to the begin
 617                         if(begin_iter==--std::vector<ListEntry>::const_iterator(iter) || dist_from_begin==1)
 618                                 prev_tangent_scalar=linear_interpolation(blp_here_on.get_origin(), 1.0f, amount);
 619                         else
 620                                 prev_tangent_scalar=linear_interpolation(blp_here_on.get_origin()-prev.get_origin(), 1.0f, amount);
 621
 622                         // If we are the next to the end
 623                         if(end_iter==++std::vector<ListEntry>::const_iterator(iter) || dist_from_end==1)
 624                                 next_tangent_scalar=linear_interpolation(1.0-blp_here_on.get_origin(), 1.0f, amount);
 625                         else if(list.end()!=++std::vector<ListEntry>::const_iterator(iter))
 626                         {
 627                                 BLinePoint next;
 628                                 next=((*(++std::vector<ListEntry>::const_iterator(iter))->value_node)(t).get(prev));
 629                                 next_tangent_scalar=linear_interpolation(next.get_origin()-blp_here_on.get_origin(), 1.0f, amount);
 630                         }
 631                         else
 632                                 //! \todo this isn't quite right; we should handle looped blines identically no matter where the loop happens
 633                                 //! and we currently don't.  this at least makes it a lot better than it was before
 634                                 next_tangent_scalar=linear_interpolation(blp_next_off.get_origin()-blp_here_on.get_origin(), 1.0f, amount);
 635                         next_scale=next_tangent_scalar;
 636
 637                         //blp_here_now.set_vertex(linear_interpolation(blp_here_off.get_vertex(), blp_here_on.get_vertex(), amount));
 638                         // if(false)
 639                         // {
 640                         //      // My first try
 641                         //      Point ref_point_begin(((*begin_iter->value_node)(off_time).get(prev).get_vertex() +
 642                         //                                                 (*end_iter->value_node)(off_time).get(prev).get_vertex()) * 0.5);
 643                         //      Point ref_point_end(((*begin_iter->value_node)(on_time).get(prev).get_vertex() +
 644                         //                                               (*end_iter->value_node)(on_time).get(prev).get_vertex()) * 0.5);
 645                         //      Point ref_point_now(((*begin_iter->value_node)(t).get(prev).get_vertex() +
 646                         //                                               (*end_iter->value_node)(t).get(prev).get_vertex()) * 0.5);
 647                         //      Point ref_point_linear(linear_interpolation(ref_point_begin, ref_point_end, amount));
 648                         //
 649                         //      blp_here_now.set_vertex(linear_interpolation(blp_here_off.get_vertex(), blp_here_on.get_vertex(), amount) +
 650                         //                                                      (ref_point_now-ref_point_linear));
 651                         //      blp_here_now.set_tangent1(linear_interpolation(blp_here_off.get_tangent1(), blp_here_on.get_tangent1(), amount));
 652                         //      blp_here_now.set_split_tangent_flag(blp_here_on.get_split_tangent_flag());
 653                         //      if(blp_here_now.get_split_tangent_flag())
 654                         //              blp_here_now.set_tangent2(linear_interpolation(blp_here_off.get_tangent2(), blp_here_on.get_tangent2(), amount));
 655                         // }
 656                         // else
 657                         {
 658                                 // My second try
 659
 660                                 // define 3 coordinate systems:
 661                                 Point off_coord_sys[2],   off_coord_origin; // when the current vertex is completely off
 662                                 Point on_coord_sys[2] ,    on_coord_origin; // when the current vertex is completely on
 663                                 Point curr_coord_sys[2], curr_coord_origin; // the current state - somewhere in between
 664
 665                                 // for each of the 3 systems, the origin is half way between the previous and next active point
 666                                 // and the axes are based on a vector from the next active point to the previous
 667                                 {
 668                                         const Point   end_pos_at_off_time((  *end_iter->value_node)(off_time).get(prev).get_vertex());
 669                                         const Point begin_pos_at_off_time((*begin_iter->value_node)(off_time).get(prev).get_vertex());
 670                                         off_coord_origin=(begin_pos_at_off_time + end_pos_at_off_time)/2;
 671                                         off_coord_sys[0]=(begin_pos_at_off_time - end_pos_at_off_time).norm();
 672                                         off_coord_sys[1]=off_coord_sys[0].perp();
 673
 674                                         const Point   end_pos_at_on_time((  *end_iter->value_node)(on_time).get(prev).get_vertex());
 675                                         const Point begin_pos_at_on_time((*begin_iter->value_node)(on_time).get(prev).get_vertex());
 676                                         on_coord_origin=(begin_pos_at_on_time + end_pos_at_on_time)/2;
 677                                         on_coord_sys[0]=(begin_pos_at_on_time - end_pos_at_on_time).norm();
 678                                         on_coord_sys[1]=on_coord_sys[0].perp();
 679
 680                                         const Point   end_pos_at_current_time((  *end_iter->value_node)(t).get(prev).get_vertex());
 681                                         const Point begin_pos_at_current_time((*begin_iter->value_node)(t).get(prev).get_vertex());
 682                                         curr_coord_origin=(begin_pos_at_current_time + end_pos_at_current_time)/2;
 683                                         curr_coord_sys[0]=(begin_pos_at_current_time - end_pos_at_current_time).norm();
 684                                         curr_coord_sys[1]=curr_coord_sys[0].perp();
 685
 686                                         // Invert (transpose) the last of these matrices, since we use it for transform back
 687                                         swap(curr_coord_sys[0][1],curr_coord_sys[1][0]);
 688                                 }
 689
 690                                 /* The code that was here before used just end_iter as the origin, rather than the mid-point */
 691
 692                                 // We know our location and tangent(s) when fully on and fully off
 693                                 // Transform each of these into their corresponding coordinate system
 694                                 Point trans_on_point, trans_off_point;
 695                                 Vector trans_on_t1, trans_on_t2, trans_off_t1, trans_off_t2;
 696
 697                                 transform_coords(blp_here_on.get_vertex(),  trans_on_point,  on_coord_origin,  on_coord_sys);
 698                                 transform_coords(blp_here_off.get_vertex(), trans_off_point, off_coord_origin, off_coord_sys);
 699
 700 #define COORD_SYS_RADIAL_TAN_INTERP 1
 701
 702 #ifdef COORD_SYS_RADIAL_TAN_INTERP
 703                                 transform_coords(blp_here_on.get_tangent1(),  trans_on_t1,  Point::zero(), on_coord_sys);
 704                                 transform_coords(blp_here_off.get_tangent1(), trans_off_t1, Point::zero(), off_coord_sys);
 705
 706                                 if(blp_here_on.get_split_tangent_flag())
 707                                 {
 708                                         transform_coords(blp_here_on.get_tangent2(),  trans_on_t2,  Point::zero(), on_coord_sys);
 709                                         transform_coords(blp_here_off.get_tangent2(), trans_off_t2, Point::zero(), off_coord_sys);
 710                                 }
 711 #endif
 712
 713                                 {
 714                                         // Interpolate between the 'on' point and the 'off' point and untransform to get our point's location
 715                                         Point tmp;
 716                                         untransform_coords(linear_interpolation(trans_off_point, trans_on_point, amount),
 717                                                                            tmp, curr_coord_origin, curr_coord_sys);
 718                                         blp_here_now.set_vertex(tmp);
 719                                 }
 720
 721 #define INTERP_FUNCTION         radial_interpolation
 722 //#define INTERP_FUNCTION       linear_interpolation
 723
 724 #ifdef COORD_SYS_RADIAL_TAN_INTERP
 725                                 {
 726                                         Vector tmp;
 727                                         untransform_coords(INTERP_FUNCTION(trans_off_t1,trans_on_t1,amount), tmp, Point::zero(), curr_coord_sys);
 728                                         blp_here_now.set_tangent1(tmp);
 729                                 }
 730 #else
 731                                 blp_here_now.set_tangent1(radial_interpolation(blp_here_off.get_tangent1(),blp_here_on.get_tangent1(),amount));
 732 #endif
 733
 734                                 if (blp_here_on.get_split_tangent_flag())
 735                                 {
 736                                         blp_here_now.set_split_tangent_flag(true);
 737 #ifdef COORD_SYS_RADIAL_TAN_INTERP
 738                                         {
 739                                                 Vector tmp;
 740                                                 untransform_coords(INTERP_FUNCTION(trans_off_t2,trans_on_t2,amount), tmp, Point::zero(), curr_coord_sys);
 741                                                 blp_here_now.set_tangent2(tmp);
 742                                         }
 743 #else
 744                                         blp_here_now.set_tangent2(radial_interpolation(blp_here_off.get_tangent2(),blp_here_on.get_tangent2(),amount));
 745 #endif
 746                                 }
 747                                 else
 748                                         blp_here_now.set_split_tangent_flag(false);
 749                         }
 750
 751                         blp_here_now.set_origin(blp_here_on.get_origin());
 752                         blp_here_now.set_width(linear_interpolation(blp_here_off.get_width(), blp_here_on.get_width(), amount));
 753
 754                         // Handle the case where we are the first vertex
 755                         if(first_flag)
 756                         {
 757                                 blp_here_now.set_tangent1(blp_here_now.get_tangent1()*prev_tangent_scalar);
 758                                 first_iter=iter;
 759                                 first=prev=blp_here_now;
 760                                 first_flag=false;
 761                                 ret_list.push_back(blp_here_now);
 762                                 continue;
 763                         }
 764
 765                         ret_list.back().set_split_tangent_flag(true);
 766                         ret_list.back().set_tangent2(prev.get_tangent2()*prev_tangent_scalar);
 767                         ret_list.push_back(blp_here_now);
 768                         ret_list.back().set_split_tangent_flag(true);
 769                         //ret_list.back().set_tangent2(blp_here_now.get_tangent1());
 770                         ret_list.back().set_tangent1(blp_here_now.get_tangent1()*prev_tangent_scalar);
 771
 772                         prev=blp_here_now;
 773                 }
 774         }
 775
 776         if(next_scale!=1.0f)
 777         {
 778                 ret_list.back().set_split_tangent_flag(true);
 779                 ret_list.back().set_tangent2(prev.get_tangent2()*next_scale);
 780         }
 781
 782 /*
 783         if(get_loop() && !first_flag)
 784         {
 785                 ret_list.push_back(
 786                         Segment(
 787                         prev.get_vertex(),
 788                         prev.get_tangent2(),
 789                         first.get_vertex(),
 790                         first.get_tangent1()
 791                         )
 792                 );
 793         }
 794 */
 795
 796         if(list.empty())
 797                 synfig::warning(string("ValueNode_BLine::operator()():")+_("No entries in list"));
 798         else
 799         if(ret_list.empty())
 800                 synfig::warning(string("ValueNode_BLine::operator()():")+_("No entries in ret_list"));
 801
 802         return ValueBase(ret_list,get_loop());
 803 }
 804
 805 String
 806 ValueNode_BLine::link_local_name(int i)const
 807 {
 808         assert(i>=0 && (unsigned)i<list.size());
 809         return etl::strprintf(_("Vertex %03d"),i+1);
 810 }
 811
 812 ValueNode*
 813 ValueNode_BLine::clone(const GUID& deriv_guid)const
 814 {
 815         { ValueNode* x(find_value_node(get_guid()^deriv_guid).get()); if(x)return x; }
 816
 817         ValueNode_BLine* ret=new ValueNode_BLine();
 818         ret->set_guid(get_guid()^deriv_guid);
 819
 820         std::vector<ListEntry>::const_iterator iter;
 821
 822         for(iter=list.begin();iter!=list.end();++iter)
 823         {
 824                 if(iter->value_node->is_exported())
 825                         ret->add(*iter);
 826                 else
 827                 {
 828                         ListEntry list_entry(*iter);
 829                         //list_entry.value_node=find_value_node(iter->value_node->get_guid()^deriv_guid).get();
 830                         //if(!list_entry.value_node)
 831                                 list_entry.value_node=iter->value_node->clone(deriv_guid);
 832                         ret->add(list_entry);
 833                         //ret->list.back().value_node=iter->value_node.clone();
 834                 }
 835         }
 836         ret->set_loop(get_loop());
 837
 838         return ret;
 839 }
 840
 841 String
 842 ValueNode_BLine::get_name()const
 843 {
 844         return "bline";
 845 }
 846
 847 String
 848 ValueNode_BLine::get_local_name()const
 849 {
 850         return _("BLine");
 851 }
 852
 853 LinkableValueNode*
 854 ValueNode_BLine::create_new()const
 855 {
 856         assert(0);
 857         return 0;
 858 }
 859
 860 bool
 861 ValueNode_BLine::check_type(ValueBase::Type type)
 862 {
 863         return type==ValueBase::TYPE_LIST;
 864 }