-/* === 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 $
**
** \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
*/
/* ========================================================================= */
using namespace std;
using namespace etl;
-using namespace sinfg;
+using namespace synfig;
/* === M A C R O S ========================================================= */
/* === 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));
// 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--)
//insert(next,*iter);
//erase(iter);
iter_swap(next,iter);
-
+
continue;
}
else
*/
}
-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<end)
{
weight=color2.pos-color1.pos;
ret.set_b(ret.get_b()*ret.get_a());
return ret*weight;
}
- 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);
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;
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;
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(;iter<end();iter=next++)
// CPoints. So, we need to calculate our coverage amount.
ColorAccumulator pool(Color::alpha());
float divisor(0.0),weight(0);
-
+
const_iterator iter2,next2;
iter2=iter;
if(iter==begin() && iter->pos>x)
divisor+=weight;
}
}
-
+
next2=iter;
iter2=next2++;
while(iter2->pos<=end_sample)
divisor+=weight;
iter2=next2++;
}
-
+
if(divisor && pool.get_a() && pool.is_valid())
{
/*
// 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);
for(iter=begin();iter<end();iter++)
{
float new_dist;
-
+
if(prev_pos==iter->pos)
new_dist=(abs(x-iter->pos-0.00001));
else
new_dist=(abs(x-iter->pos));
-
+
if(new_dist>dist)
{
iter--;
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<Gradient*>(this)->proximity(x);
/*
const_iterator iter;
float dist(100000000);
-
+
// This algorithm requires a sorted list.
for(iter=begin();iter<end();iter++)
{
*/
}
-sinfg::Gradient::iterator
-sinfg::Gradient::find(const UniqueID &id)
+synfig::Gradient::iterator
+synfig::Gradient::find(const UniqueID &id)
{
iterator iter;
-
+
for(iter=begin();iter<end();iter++)
{
if(id==*iter)
return iter;
}
-
- throw Exception::NotFound("sinfg::Gradient::find(): Unable to find UniqueID in gradient");
+
+ throw Exception::NotFound("synfig::Gradient::find(): Unable to find UniqueID in gradient");
}
-
-sinfg::Gradient::const_iterator
-sinfg::Gradient::find(const UniqueID &id)const
+
+synfig::Gradient::const_iterator
+synfig::Gradient::find(const UniqueID &id)const
{
const_iterator iter;
-
+
for(iter=begin();iter<end();iter++)
{
if(id==*iter)
return iter;
}
-
- throw Exception::NotFound("sinfg::Gradient::find()const: Unable to find UniqueID in gradient");
+
+ throw Exception::NotFound("synfig::Gradient::find()const: Unable to find UniqueID in gradient");
}
projects / synfig.git / blobdiff