synfig-core/trunk/src/synfig/valuenode_bline.cpp

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