1 /* === S Y N F I G ========================================================= */
3 ** \brief Implementation of the "Circle" layer
8 ** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
9 ** Copyright (c) 2008 Chris Moore
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.
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.
22 /* ========================================================================= */
24 /* === H E A D E R S ======================================================= */
34 #include <synfig/string.h>
35 #include <synfig/time.h>
36 #include <synfig/context.h>
37 #include <synfig/paramdesc.h>
38 #include <synfig/renddesc.h>
39 #include <synfig/surface.h>
40 #include <synfig/value.h>
41 #include <synfig/valuenode.h>
47 using namespace synfig
;
51 /* -- G L O B A L S --------------------------------------------------------- */
53 SYNFIG_LAYER_INIT(Circle
);
54 SYNFIG_LAYER_SET_NAME(Circle
,"circle");
55 SYNFIG_LAYER_SET_LOCAL_NAME(Circle
,N_("Circle"));
56 SYNFIG_LAYER_SET_CATEGORY(Circle
,N_("Geometry"));
57 SYNFIG_LAYER_SET_VERSION(Circle
,"0.1");
58 SYNFIG_LAYER_SET_CVS_ID(Circle
,"$Id$");
60 /* -- F U N C T I O N S ----------------------------------------------------- */
63 Layer_Composite (1.0,Color::BLEND_STRAIGHT
),
64 color (Color::black()),
69 falloff (FALLOFF_INTERPOLATION_LINEAR
)
75 Circle::ImportParameters(const String
¶m
, const ValueBase
&value
)
77 IMPORT_PLUS(color
, { if (color
.get_a() == 0) { if (converted_blend_
) {
78 set_blend_method(Color::BLEND_ALPHA_OVER
);
79 color
.set_a(1); } else transparent_color_
= true; } });
81 IMPORT_PLUS(feather
, if(feather
<0)feather
=0;);
86 IMPORT_AS(origin
,"pos");
88 return Layer_Composite::set_param(param
,value
);
92 Circle::set_param(const String
¶m
, const ValueBase
&value
)
94 if(ImportParameters(param
,value
))
104 Circle::get_param(const String
¶m
)const
116 return Layer_Composite::get_param(param
);
120 Circle::get_param_vocab()const
122 Layer::Vocab
ret(Layer_Composite::get_param_vocab());
124 ret
.push_back(ParamDesc("color")
125 .set_local_name(_("Color"))
127 ret
.push_back(ParamDesc("radius")
128 .set_local_name(_("Radius"))
129 .set_origin("origin")
132 ret
.push_back(ParamDesc("feather")
133 .set_local_name(_("Feather"))
136 ret
.push_back(ParamDesc("origin")
137 .set_local_name(_("Origin"))
139 ret
.push_back(ParamDesc("invert")
140 .set_local_name(_("Invert"))
141 .set_description(_("Invert the circle"))
144 ret
.push_back(ParamDesc("falloff")
145 .set_local_name(_("Falloff"))
146 .set_description(_("Determines the falloff function for the feather"))
148 .add_enum_value(FALLOFF_INTERPOLATION_LINEAR
,"linear",_("Linear"))
149 .add_enum_value(FALLOFF_SQUARED
,"squared",_("Squared"))
150 .add_enum_value(FALLOFF_SQRT
,"sqrt",_("Square Root"))
151 .add_enum_value(FALLOFF_SIGMOND
,"sigmond",_("Sigmond"))
152 .add_enum_value(FALLOFF_COSINE
,"cosine",_("Cosine"))
158 synfig::Layer::Handle
159 Circle::hit_check(synfig::Context context
, const synfig::Point
&point
)const
161 Point temp
=origin
-point
;
164 return context
.hit_check(point
);
166 bool in_circle(temp
.mag_squared() <= radius
*radius
);
170 in_circle
=!in_circle
;
171 if(in_circle
&& get_amount()-(feather
/radius
)<=0.1 && get_blend_method()!=Color::BLEND_STRAIGHT
)
176 if(get_amount()-(feather
/radius
)<=0.0)
182 synfig::Layer::Handle tmp
;
183 if(get_blend_method()==Color::BLEND_BEHIND
&& (tmp
=context
.hit_check(point
)))
185 if(Color::is_onto(get_blend_method()) && !(tmp
=context
.hit_check(point
)))
187 return const_cast<Circle
*>(this);
190 return context
.hit_check(point
);
194 Real
Circle::SqdFalloff(const Circle::CircleDataCache
&c
, const Real
&mag_sqd
)
196 //squared proportional falloff
197 return (c
.outer_radius_sqd
- mag_sqd
) / c
.diff_sqd
;
200 Real
Circle::InvSqdFalloff(const Circle::CircleDataCache
&c
, const Real
&mag_sqd
)
202 //squared proportional falloff
203 return 1.0 - (c
.outer_radius_sqd
- mag_sqd
) / c
.diff_sqd
;
207 Real
Circle::SqrtFalloff(const Circle::CircleDataCache
&c
, const Real
&mag_sqd
)
209 //linear distance falloff
210 Real ret
= ( c
.outer_radius
- sqrt(mag_sqd
) ) / c
.double_feather
;
211 //then take the square root of it
216 Real
Circle::InvSqrtFalloff(const Circle::CircleDataCache
&c
, const Real
&mag_sqd
)
218 //linear distance falloff
219 Real ret
= ( c
.outer_radius
- sqrt(mag_sqd
) ) / c
.double_feather
;
220 //then take the square root of it
221 ret
= 1.0 - sqrt(ret
);
225 Real
Circle::LinearFalloff(const Circle::CircleDataCache
&c
, const Real
&mag_sqd
)
227 //linear distance falloff
228 return ( c
.outer_radius
- sqrt(mag_sqd
) ) / c
.double_feather
;
231 Real
Circle::InvLinearFalloff(const Circle::CircleDataCache
&c
, const Real
&mag_sqd
)
233 return 1.0 - ( c
.outer_radius
- sqrt(mag_sqd
) ) / c
.double_feather
;
234 //linear distance falloff
237 Real
Circle::SigmondFalloff(const Circle::CircleDataCache
&c
, const Real
&mag_sqd
)
239 //linear distance falloff
240 Real ret
= ( c
.outer_radius
- sqrt(mag_sqd
) ) / c
.double_feather
;
241 // inverse exponential of the linear falloff (asymptotes at 0 and 1)
242 // \frac{1.0}{ 1 + e^{- \( a*10-5 \)}}
243 ret
= 1.0 / (1 + exp(-(ret
*10-5)) );
247 Real
Circle::InvSigmondFalloff(const Circle::CircleDataCache
&c
, const Real
&mag_sqd
)
249 //linear distance falloff
250 Real ret
= ( c
.outer_radius
- sqrt(mag_sqd
) ) / c
.double_feather
;
251 // inverse exponential of the linear falloff (asymptotes at 0 and 1)
252 // \frac{1.0}{ 1 + e^{- \( a*10-5 \)}}
253 ret
= 1.0 - 1.0 / (1 + exp(-(ret
*10-5)) );
259 Circle::CosineFalloff(const Circle::CircleDataCache
&c
, const Real
&mag_sqd
)
261 //Cosine distance falloff
262 return (1.0f
-cos((( c
.outer_radius
- sqrt(mag_sqd
) ) / c
.double_feather
)*3.1415927))*0.5f
;
266 Circle::InvCosineFalloff(const Circle::CircleDataCache
&c
, const Real
&mag_sqd
)
268 return 1.0f
-(1.0f
-cos((( c
.outer_radius
- sqrt(mag_sqd
) ) / c
.double_feather
)*3.1415927))*0.5f
;
269 //Cosine distance falloff
272 void Circle::constructcache()
274 cache
.inner_radius
= radius
- feather
;
275 if(cache
.inner_radius
< 0)
276 cache
.inner_radius
= 0;
278 cache
.outer_radius
= radius
+ feather
;
280 cache
.inner_radius_sqd
= cache
.inner_radius
> 0 ? (radius
-feather
)*(radius
-feather
) : 0;
281 cache
.outer_radius_sqd
= (radius
+feather
)*(radius
+feather
);
283 cache
.diff_sqd
= feather
*feather
*4.0;
284 cache
.double_feather
= feather
*2.0;
286 falloff_func
= GetFalloffFunc();
289 Circle::FALLOFF_FUNC
*Circle::GetFalloffFunc()const
293 case FALLOFF_SQUARED
: return invert
?InvSqdFalloff
:SqdFalloff
;
295 case FALLOFF_SQRT
: return invert
?InvSqrtFalloff
:SqrtFalloff
;
297 case FALLOFF_INTERPOLATION_LINEAR
: return invert
?InvLinearFalloff
:LinearFalloff
;
299 case FALLOFF_SIGMOND
: return invert
?InvSigmondFalloff
:SigmondFalloff
;
302 default: return invert
?InvCosineFalloff
:CosineFalloff
;
307 Circle::get_color(Context context
, const Point
&point
)const
309 if(is_disabled() || (radius
==0 && invert
==false && !feather
))
310 return context
.get_color(point
);
313 Point temp
=origin
-point
;
315 /*const Real inner_radius = radius-feather;
316 const Real outer_radius = radius+feather;
318 const Real inner_radius_sqd = inner_radius > 0 ? (radius-feather)*(radius-feather) : 0;
319 const Real outer_radius_sqd = (radius+feather)*(radius+feather);
321 const Real diff_radii_sqd = outer_radius_sqd - inner_radius_sqd;
322 const Real double_feather = feather*2.0;*/
324 /*const Real &inner_radius = cache.inner_radius;
325 const Real &outer_radius = cache.outer_radius;*/
327 const Real
&inner_radius_sqd
= cache
.inner_radius_sqd
;
328 const Real
&outer_radius_sqd
= cache
.outer_radius_sqd
;
330 /*const Real &diff_radii_sqd = cache.diff_radii_sqd;
331 const Real &double_feather = cache.double_feather;*/
333 const Vector::value_type mag_squared
= temp
.mag_squared();
335 //Outside the circle, with feathering enabled
336 if( mag_squared
> outer_radius_sqd
)
338 // inverted -> outside == colored in
341 if(get_amount() == 1 && get_blend_method() == Color::BLEND_STRAIGHT
)
344 return Color::blend(color
,context
.get_color(point
),get_amount(),get_blend_method());
347 return Color::blend(Color::alpha(),context
.get_color(point
),get_amount(),get_blend_method());
350 //inside the circle's solid area (with feathering)
351 else if(mag_squared
<= inner_radius_sqd
)
353 // !invert -> solid area
355 if(get_amount() == 1 && get_blend_method() == Color::BLEND_STRAIGHT
)
358 return Color::blend(color
,context
.get_color(point
),get_amount(),get_blend_method());
360 return Color::blend(Color::alpha(),context
.get_color(point
),get_amount(),get_blend_method());
363 //If we get here, the pixel is within the feathering area, and is thus subject to falloff
366 Color::value_type alpha
;
371 case FALLOFF_SQUARED:
372 //squared proportional falloff
373 alpha = (outer_radius_sqd - mag_squared) / diff_radii_sqd;
377 //linear distance falloff
378 alpha = ( outer_radius - sqrt(mag_squared) ) / double_feather;
379 //then take the square root of it
383 case FALLOFF_INTERPOLATION_LINEAR:
384 //linear distance falloff
385 alpha = ( outer_radius - sqrt(mag_squared) ) / double_feather;
388 case FALLOFF_SIGMOND:
390 //linear distance falloff
391 alpha = ( outer_radius - sqrt(mag_squared) ) / double_feather;
392 // inverse exponential of the linear falloff (asymptotes at 0 and 1)
393 // \frac{1.0}{ 1 + e^{- \( a*10-5 \)}}
394 alpha = 1.0 / (1 + exp(-(alpha*10-5)) );
398 //If we're inverted, we need to invert the falloff value
402 alpha
= falloff_func(cache
,mag_squared
);
404 return Color::blend(color
*alpha
,context
.get_color(point
),get_amount(),get_blend_method());
408 Color
NormalBlend(Color a
, Color b
, float amount
)
410 return (b
-a
)*amount
+a
;
415 Circle::accelerated_render(Context context
,Surface
*surface
,int quality
, const RendDesc
&renddesc
, ProgressCallback
*cb
)const
418 if(is_disabled() || (radius
==0 && invert
==false && !feather
))
419 return context
.accelerated_render(surface
,quality
, renddesc
, cb
);
421 // Another trivial case
422 if(invert
&& radius
==0 && is_solid_color())
424 surface
->set_wh(renddesc
.get_w(),renddesc
.get_h());
425 surface
->fill(color
);
426 if(cb
&& !cb
->amount_complete(10000,10000))
432 const Point
tl(renddesc
.get_tl());
433 const Point
br(renddesc
.get_br());
434 const int w(renddesc
.get_w());
435 const int h(renddesc
.get_h());
437 const Real x_neg
= tl
[0] > br
[0] ? -1 : 1;
438 const Real y_neg
= tl
[1] > br
[1] ? -1 : 1;
440 // Width and Height of a pixel
441 const Real pw
= (br
[0] - tl
[0]) / w
;
442 const Real ph
= (br
[1] - tl
[1]) / h
;
444 // Increasing the feather amount by the size of
445 // a pixel will create an anti-aliased appearance
446 // don't render feathering at all when quality is 10
447 const Real newfeather
= (quality
== 10) ? 0 : feather
+ (abs(ph
)+abs(pw
))/4.0;
450 int left
= (int) floor( (origin
[0] - x_neg
*(radius
+newfeather
) - tl
[0]) / pw
);
451 int right
= (int) ceil( (origin
[0] + x_neg
*(radius
+newfeather
) - tl
[0]) / pw
);
452 int top
= (int) floor( (origin
[1] - y_neg
*(radius
+newfeather
) - tl
[1]) / ph
);
453 int bottom
= (int) ceil( (origin
[1] + y_neg
*(radius
+newfeather
) - tl
[1]) / ph
);
455 //clip the rectangle bounds
465 const Real inner_radius
= radius
-newfeather
>0 ? radius
-newfeather
: 0;
466 const Real outer_radius
= radius
+newfeather
;
468 const Real inner_radius_sqd
= inner_radius
*inner_radius
;
469 const Real outer_radius_sqd
= outer_radius
*outer_radius
;
471 const Real diff_radii_sqd
= 4*newfeather
*std::max(newfeather
,radius
);//4.0*radius*newfeather;
472 const Real double_feather
= newfeather
* 2.0;
474 //Compile the temporary cache for the falloff calculations
475 FALLOFF_FUNC
*func
= GetFalloffFunc();
477 const CircleDataCache cache
=
479 inner_radius
,outer_radius
,
480 inner_radius_sqd
,outer_radius_sqd
,
481 diff_radii_sqd
,double_feather
484 //info("Circle: Initialized everything");
486 //let the rendering begin
487 SuperCallback
supercb(cb
,0,9000,10000);
489 //if it's a degenerate circle, do what we need to do, and then leave
490 if(left
>= right
|| top
>= bottom
)
494 if(get_amount() == 1 && get_blend_method() == Color::BLEND_STRAIGHT
)
496 surface
->set_wh(w
,h
);
497 surface
->fill(color
);
501 // Render what is behind us
502 if(!context
.accelerated_render(surface
,quality
,renddesc
,&supercb
))
504 if(cb
)cb
->error(strprintf(__FILE__
"%d: Accelerated Renderer Failure",__LINE__
));
508 Surface::alpha_pen
p(surface
->begin(),get_amount(),_BlendFunc(get_blend_method()));
516 // Render what is behind us
517 if(!context
.accelerated_render(surface
,quality
,renddesc
,&supercb
))
519 if(cb
)cb
->error(strprintf(__FILE__
"%d: Accelerated Renderer Failure",__LINE__
));
526 if( (origin
[0] - tl
[0])*(origin
[0] - tl
[0]) + (origin
[1] - tl
[1])*(origin
[1] - tl
[1]) < inner_radius_sqd
527 && (origin
[0] - br
[0])*(origin
[0] - br
[0]) + (origin
[1] - br
[1])*(origin
[1] - br
[1]) < inner_radius_sqd
528 && (origin
[0] - tl
[0])*(origin
[0] - tl
[0]) + (origin
[1] - br
[1])*(origin
[1] - br
[1]) < inner_radius_sqd
529 && (origin
[0] - br
[0])*(origin
[0] - br
[0]) + (origin
[1] - tl
[1])*(origin
[1] - tl
[1]) < inner_radius_sqd
)
533 // Render what is behind us
534 if(!context
.accelerated_render(surface
,quality
,renddesc
,&supercb
))
536 if(cb
)cb
->error(strprintf(__FILE__
"%d: Accelerated Renderer Failure",__LINE__
));
541 if(get_amount() == 1 && get_blend_method() == Color::BLEND_STRAIGHT
)
543 surface
->set_wh(w
,h
);
544 surface
->fill(color
);
550 //info("Circle: Non degenerate, rasterize %c", invert);
552 //we start in the middle of the left-top pixel
553 Real leftf
= (left
+ 0.5)*pw
+ tl
[0];
554 Real topf
= (top
+ 0.5)*ph
+ tl
[1];
556 //the looping variables
560 //Loop normally, since we are not inverted
563 // Render what is behind us
564 if(!context
.accelerated_render(surface
,quality
,renddesc
,&supercb
))
566 if(cb
)cb
->error(strprintf(__FILE__
"%d: Accelerated Renderer Failure",__LINE__
));
570 //make topf and leftf relative to the center of the circle
577 //Loop over the valid y-values in the bounding square
578 for(;j
<= bottom
; j
++, y
+= ph
)
583 //for each y-value, Loop over the bounding x-values in the bounding square
584 for(;i
<= right
; i
++, x
+= pw
)
586 //for each pixel, figure out the distance and blend
589 //if in the inner circle then the full color shows through
590 if(r
<= inner_radius_sqd
)
592 if(get_amount() == 1 && get_blend_method() == Color::BLEND_STRAIGHT
)
593 (*surface
)[j
][i
]=color
;
595 (*surface
)[j
][i
]=Color::blend(color
,(*surface
)[j
][i
],get_amount(),get_blend_method());
597 //if it's within the outer circle then it's in the feathering range
598 else if(r
<= outer_radius_sqd
)
604 case FALLOFF_SQUARED:
605 myamount = (outer_radius_sqd - r) / diff_radii_sqd;
609 myamount = (outer_radius - sqrt(r)) / double_feather;
610 myamount = sqrt(myamount);
613 case FALLOFF_INTERPOLATION_LINEAR:
614 myamount = (outer_radius - sqrt(r)) / double_feather;
617 case FALLOFF_SIGMOND:
619 myamount = (outer_radius - sqrt(r)) / double_feather;
620 myamount = 1.0 / ( 1 + exp(-(myamount*10 - 5)) );
624 Real myamount
= func(cache
,r
);
626 //if(myamount<0.0)myamount=0.0;
627 //if(myamount>1.0)myamount=1.0;
628 myamount
*= get_amount();
629 (*surface
)[j
][i
] = Color::blend(color
,(*surface
)[j
][i
],myamount
,get_blend_method());
637 RendDesc
desc(renddesc
);
640 int offset_x
=0,offset_y
=0;
642 //fill the surface with the background color initially
643 surface
->set_wh(w
,h
);
644 surface
->fill(color
);
646 //then render the background to an alternate surface
647 if(get_amount() == 1 && get_blend_method() == Color::BLEND_STRAIGHT
)
652 //if there is no background showing through we are done
653 if(right
< left
|| bottom
< top
)
656 desc
.set_subwindow(left
,top
,right
-left
+1,bottom
-top
+1);
658 // Render what is behind us
659 if(!context
.accelerated_render(&background
,quality
,desc
,&supercb
))
661 if(cb
)cb
->error(strprintf(__FILE__
"%d: Accelerated Renderer Failure",__LINE__
));
672 leftf
= /*0.5*pw +*/ tl
[0];
673 topf
= /*0.5*ph +*/ tl
[1];
675 // Render what is behind us
676 if(!context
.accelerated_render(&background
,quality
,renddesc
,&supercb
))
678 if(cb
)cb
->error(strprintf(__FILE__
"%d: Accelerated Renderer Failure",__LINE__
));
689 for(;j
<= bottom
; j
++, y
+=ph
)
694 for(;i
<= right
; i
++, x
+=pw
)
696 Vector::value_type r
= x
*x
+ y
*y
;
698 if(r
< inner_radius_sqd
)
700 (*surface
)[j
][i
] = background
[j
-offset_y
][i
-offset_x
];
702 else if(r
< outer_radius_sqd
)
708 case FALLOFF_SQUARED:
709 amount = (r - inner_radius_sqd) / diff_radii_sqd;
711 case FALLOFF_INTERPOLATION_LINEAR:
712 amount = (sqrt(r) - inner_radius) / double_feather;
715 amount = (outer_radius - sqrt(r)) / double_feather;
716 amount = 1.0 - sqrt(amount);
718 case FALLOFF_SIGMOND:
720 amount = (outer_radius - sqrt(r)) / double_feather;
721 amount = 1.0 - ( 1.0/( 1 + exp(-(amount*10-5)) ) );
725 Real amount
= func(cache
,r
);
727 if(amount
<0.0)amount
=0.0;
728 if(amount
>1.0)amount
=1.0;
730 amount
*=get_amount();
732 (*surface
)[j
][i
]=Color::blend(color
,background
[j
-offset_y
][i
-offset_x
],amount
,get_blend_method());
733 }else if(get_amount() != 1 || get_blend_method() != Color::BLEND_STRAIGHT
)
735 (*surface
)[j
][i
]=Color::blend(color
,background
[j
][i
],get_amount(),get_blend_method());
741 // Mark our progress as finished
742 if(cb
&& !cb
->amount_complete(10000,10000))
749 Circle::get_bounding_rect()const
752 return Rect::full_plane();
755 origin
[0]+(radius
+feather
),
756 origin
[1]+(radius
+feather
),
757 origin
[0]-(radius
+feather
),
758 origin
[1]-(radius
+feather
)
765 Circle::get_full_bounding_rect(Context context
)const
769 if(is_solid_color() && color
.get_a()==0)
772 origin
[0]+(radius
+feather
),
773 origin
[1]+(radius
+feather
),
774 origin
[0]-(radius
+feather
),
775 origin
[1]-(radius
+feather
)
777 return bounds
& context
.get_full_bounding_rect();
779 return Rect::full_plane();
782 return Layer_Composite::get_full_bounding_rect(context
);