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