X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;ds=sidebyside;f=synfig-core%2Ftrunk%2Fsrc%2Fsynfig%2Fgradient.cpp;h=e206b48484f357a5079abd8ee2a26700012556ae;hb=4f9e4d835da8089a953dfa5f508643c538924921;hp=8132809caddc240643297e023b9a88682e446778;hpb=e3acc0b267b14fda5db3c7bbb2f218b993ef84b3;p=synfig.git diff --git a/synfig-core/trunk/src/synfig/gradient.cpp b/synfig-core/trunk/src/synfig/gradient.cpp index 8132809..e206b48 100644 --- a/synfig-core/trunk/src/synfig/gradient.cpp +++ b/synfig-core/trunk/src/synfig/gradient.cpp @@ -1,20 +1,21 @@ -/* === S I N F G =========================================================== */ +/* === S Y N F I G ========================================================= */ /*! \file gradient.cpp ** \brief Color Gradient Class Member Definitions ** -** $Id: gradient.cpp,v 1.2 2005/01/21 19:29:10 darco Exp $ +** $Id$ ** ** \legal -** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley ** -** This software and associated documentation -** are CONFIDENTIAL and PROPRIETARY property of -** the above-mentioned copyright holder. +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. ** -** You may not copy, print, publish, or in any -** other way distribute this software without -** a prior written agreement with -** the copyright holder. +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. ** \endlegal */ /* ========================================================================= */ @@ -40,7 +41,7 @@ using namespace std; using namespace etl; -using namespace sinfg; +using namespace synfig; /* === M A C R O S ========================================================= */ @@ -50,13 +51,13 @@ using namespace sinfg; /* === M E T H O D S ======================================================= */ -sinfg::Gradient::Gradient(const Color &c1, const Color &c2) +synfig::Gradient::Gradient(const Color &c1, const Color &c2) { push_back(CPoint(0.0,c1)); push_back(CPoint(1.0,c2)); } -sinfg::Gradient::Gradient(const Color &c1, const Color &c2, const Color &c3) +synfig::Gradient::Gradient(const Color &c1, const Color &c2, const Color &c3) { push_back(CPoint(0.0,c1)); push_back(CPoint(0.5,c2)); @@ -69,13 +70,13 @@ sinfg::Gradient::Gradient(const Color &c1, const Color &c2, const Color &c3) // This algorithm will sort a nearly-sorted list at ~O(N), and // it will sort an inverse sorted list at ~O(N*N). void -sinfg::Gradient::sort() -{ +synfig::Gradient::sort() +{ stable_sort(begin(),end()); /* iterator iter; iterator iter2,next; - + for(iter=begin();iter!=end();iter++) { for(next=iter, iter2=next--;iter2!=begin();iter2=next--) @@ -85,7 +86,7 @@ sinfg::Gradient::sort() //insert(next,*iter); //erase(iter); iter_swap(next,iter); - + continue; } else @@ -95,22 +96,19 @@ sinfg::Gradient::sort() */ } -static sinfg::ColorAccumulator -supersample_helper(const sinfg::Gradient::CPoint &color1, const sinfg::Gradient::CPoint &color2, float begin, float end, float &weight) +static synfig::ColorAccumulator +supersample_helper(const synfig::Gradient::CPoint &color1, const synfig::Gradient::CPoint &color2, float begin, float end, float &weight) { if(color1.pos==color2.pos || color1.pos>=end || color2.pos<=begin) { weight=0; return Color::alpha(); - } + } if(color1.pos>=begin && color2.pos=begin && color2.pos>=end) { @@ -118,11 +116,8 @@ supersample_helper(const sinfg::Gradient::CPoint &color1, const sinfg::Gradient: float pos((end+color1.pos)*0.5); float amount((pos-color1.pos)/(color2.pos-color1.pos)); //if(abs(amount)>1)amount=(amount>0)?1:-1; - ColorAccumulator ret(Color::blend(color2.color,color1.color, amount, Color::BLEND_STRAIGHT)); - ret.set_r(ret.get_r()*ret.get_a()); - ret.set_g(ret.get_g()*ret.get_a()); - ret.set_b(ret.get_b()*ret.get_a()); - return ret*weight; + ColorAccumulator ret(Color::blend(color2.color,color1.color, amount, Color::BLEND_STRAIGHT).premult_alpha()*weight); + return ret; } if(color1.pos1)amount=(amount>0)?1:-1; - ColorAccumulator ret(Color::blend(color2.color,color1.color, amount, Color::BLEND_STRAIGHT)); - ret.set_r(ret.get_r()*ret.get_a()); - ret.set_g(ret.get_g()*ret.get_a()); - ret.set_b(ret.get_b()*ret.get_a()); - return ret*weight; + ColorAccumulator ret(Color::blend(color2.color,color1.color, amount, Color::BLEND_STRAIGHT).premult_alpha()*weight); + return ret; } - sinfg::error("color1.pos=%f",color1.pos); - sinfg::error("color2.pos=%f",color2.pos); - sinfg::error("begin=%f",begin); - sinfg::error("end=%f",end); + synfig::error("color1.pos=%f",color1.pos); + synfig::error("color2.pos=%f",color2.pos); + synfig::error("begin=%f",begin); + synfig::error("end=%f",end); weight=0; return Color::alpha(); - + // assert(0); } - + Color -sinfg::Gradient::operator()(const Real &x,float supersample)const +synfig::Gradient::operator()(const Real &x,float supersample)const { if(empty()) return Color(0,0,0,0); @@ -156,13 +148,13 @@ sinfg::Gradient::operator()(const Real &x,float supersample)const supersample=-supersample; if(supersample>2.0) supersample=2.0f; - + float begin_sample(x-supersample*0.5); float end_sample(x+supersample*0.5); if(size()==1 || end_sample<=front().pos || isnan(x)) return front().color; - + if(begin_sample>=back().pos) return back().color; @@ -173,58 +165,58 @@ sinfg::Gradient::operator()(const Real &x,float supersample)const if(begin_sample<=front().pos) begin_sample=front().pos; */ - + const_iterator iter,next; /* //optimizize... Real left = x-supersample/2, right = x+supersample/2; - + if(left < front().pos) left = front().pos; if(right > back().pos) right = back().pos; - + //find using binary search... const_iterator iterl,iterr; - + //the binary search should give us the values BEFORE the point we're looking for... iterl = binary_find(begin(),end(),left); iterr = binary_find(iterl,end(),right); - + //now integrate over the range of left to right... - + if(iterl == iterr) { iterr++; //let's look at the next one shall we :) - + //interpolate neighboring colors const Real one = iterr->pos - iterl->pos; const Real lambda = (x - iterl->pos)/one; - + //(1-l)iterl + (l)iterr return iterl->color.premult_alpha()*(1-lambda) + iterr->color.premult_alpha()*lambda; - + //return Color::blend(iterr->color,iterl->color,lambda,Color::BLEND_STRAIGHT); }else { //itegration madness const_iterator i = iterl, ie = iterr+1; Real wlast = left; - + ColorAccumulator clast,cwork; { const Real lambda = (x - iterl->pos)/(iterr->pos - iterl->pos); - + //premultiply because that's the form in which we can combine things... clast = iterl->color.premult_alpha()*(1-lambda) + iterr->color.premult_alpha()*lambda; //Color::blend((i+1)->color,i->color,(left - i->pos)/((i+1)->pos - i->pos),Color::BLEND_STRAIGHT); } - + ColorAccumulator accum = 0; - + //loop through all the trapezoids and integrate them as we go... // area of trap = (yi + yi1)*(xi1 - xi) - // yi = clast, xi = wlast, yi1 = i->color, xi1 = i->pos - + // yi = clast, xi = wlast, yi1 = i->color, xi1 = i->pos + for(;i<=iterr; wlast=i->pos,clast=i->color.premult_alpha(),++i) { const Real diff = i->pos - wlast; @@ -234,30 +226,30 @@ sinfg::Gradient::operator()(const Real &x,float supersample)const accum += (cwork + clast)*diff; } } - + { - const_iterator ibef = i-1; + const_iterator ibef = i-1; const Real diff = right - ibef->pos; - + if(diff > 0) { const Real lambda = diff/(i->pos - ibef->pos); cwork = ibef->color.premult_alpha()*(1-lambda) + i->color.premult_alpha()*lambda; - + accum += (cwork + clast)*diff; //can probably optimize this more... but it's not too bad } } - + accum /= supersample; //should be the total area it was sampled over... return accum.demult_alpha(); }*/ - + next=begin(),iter=next++; - + //add for optimization next = binary_find(begin(),end(),(Real)begin_sample); - iter = next++; - + iter = next++; + //! As a future optimization, this could be performed faster //! using a binary search. for(;iterpos>x) { weight=x-iter->pos; //weight*=iter->color.get_a(); - pool+=ColorAccumulator(iter->color)*(float)iter->color.get_a()*weight; + pool+=ColorAccumulator(iter->color).premult_alpha()*weight; divisor+=weight; } else @@ -295,7 +287,7 @@ sinfg::Gradient::operator()(const Real &x,float supersample)const { weight=iter2->pos-(begin_sample); //weight*=iter2->color.get_a(); - pool+=ColorAccumulator(iter2->color)*(float)iter2->color.get_a()*weight; + pool+=ColorAccumulator(iter2->color).premult_alpha()*weight; divisor+=weight; break; } @@ -304,7 +296,7 @@ sinfg::Gradient::operator()(const Real &x,float supersample)const divisor+=weight; } } - + next2=iter; iter2=next2++; while(iter2->pos<=end_sample) @@ -312,7 +304,7 @@ sinfg::Gradient::operator()(const Real &x,float supersample)const if(next2==end()) { weight=(end_sample)-iter2->pos; - pool+=ColorAccumulator(iter2->color)*(float)iter2->color.get_a()*weight; + pool+=ColorAccumulator(iter2->color).premult_alpha()*weight; divisor+=weight; break; } @@ -320,7 +312,7 @@ sinfg::Gradient::operator()(const Real &x,float supersample)const divisor+=weight; iter2=next2++; } - + if(divisor && pool.get_a() && pool.is_valid()) { /* @@ -345,13 +337,13 @@ sinfg::Gradient::operator()(const Real &x,float supersample)const // We should never get to this point. - sinfg::error("sinfg::Gradient::operator()(): Logic Error (x=%f)",x); + synfig::error("synfig::Gradient::operator()(): Logic Error (x=%f)",x); assert(0); - throw std::logic_error(strprintf("sinfg::Gradient::operator()(): Logic Error (x=%f)",x)); + throw std::logic_error(strprintf("synfig::Gradient::operator()(): Logic Error (x=%f)",x)); } -sinfg::Gradient::iterator -sinfg::Gradient::proximity(const Real &x) +synfig::Gradient::iterator +synfig::Gradient::proximity(const Real &x) { iterator iter; float dist(100000000); @@ -360,12 +352,12 @@ sinfg::Gradient::proximity(const Real &x) for(iter=begin();iterpos) new_dist=(abs(x-iter->pos-0.00001)); else new_dist=(abs(x-iter->pos)); - + if(new_dist>dist) { iter--; @@ -378,14 +370,14 @@ sinfg::Gradient::proximity(const Real &x) return iter; } -sinfg::Gradient::const_iterator -sinfg::Gradient::proximity(const Real &x)const +synfig::Gradient::const_iterator +synfig::Gradient::proximity(const Real &x)const { return const_cast(this)->proximity(x); /* const_iterator iter; float dist(100000000); - + // This algorithm requires a sorted list. for(iter=begin();iter