RFunction::coord_type
function_algebra_hermite::derive(const RFunction::coord_type& x,
const RFunction::coord_type& h) const
{
double t = (x[1]-a)/(b-a);
if (t <= 0.0) return coord_type(0.0);
else if (t<= 1.0) return coord_type(h*(6.0*t*(1.0-t)/(b-a)) );
else return coord_type(0.0);
}
KTL_INLINE void SpriteCoord::setCenter(tTVInteger v1, tTVInteger v2) {
instance_->setCenter(
coord_type(
boost::numeric_cast<NativeSpriteCoord::coord_element_type>(v1),
boost::numeric_cast<NativeSpriteCoord::coord_element_type>(v2)
)
);
}
function_algebra_impl::coord_type
function_algebra_polynomial1D::eval(const coord_type& x) const
{
int n= degree();
double bk=coeffs[n+1],x1=x[1];
for(int k=1;k<=n;k++) {
bk = x1*bk +coeffs[n+1-k];
}
return coord_type(bk);
}
function_algebra_impl::coord_type
function_algebra_polynomial1D::derive(const coord_type& x, const coord_type& h) const
{
int n= degree();
double bk=n*coeffs[n+1],x1=x[1];
for(int k=1;k<=n-1;k++) {
bk = x1*bk +(n-k)*coeffs[n+1-k];
}
return coord_type(bk*h[1]);
}
//------------------------------------------------------------------------
void gen_stroke::calc_miter(const vertex_dist& v0,
const vertex_dist& v1,
const vertex_dist& v2,
double dx1, double dy1,
double dx2, double dy2)
{
double xi = v1.x;
double yi = v1.y;
if(!calc_intersection(v0.x + dx1, v0.y - dy1,
v1.x + dx1, v1.y - dy1,
v1.x + dx2, v1.y - dy2,
v2.x + dx2, v2.y - dy2,
&xi, &yi))
{
m_out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1));
}
else
{
double d1 = calc_distance(v1.x, v1.y, xi, yi);
double lim = m_width * m_miter_limit;
if(d1 > lim)
{
d1 = lim / d1;
double x1 = v1.x + dx1;
double y1 = v1.y - dy1;
double x2 = v1.x + dx2;
double y2 = v1.y - dy2;
x1 += (xi - x1) * d1;
y1 += (yi - y1) * d1;
x2 += (xi - x2) * d1;
y2 += (yi - y2) * d1;
m_out_vertices.add(coord_type(x1, y1));
m_out_vertices.add(coord_type(x2, y2));
}
else
{
m_out_vertices.add(coord_type(xi, yi));
}
}
}
//------------------------------------------------------------------------
void vcgen_markers_term::add_vertex(double x, double y, unsigned cmd)
{
if(is_move_to(cmd))
{
if(m_markers.size() & 1)
{
// Initial state, the first coordinate was added.
// If two of more calls of start_vertex() occures
// we just modify the last one.
m_markers.modify_last(coord_type(x, y));
}
else
{
m_markers.add(coord_type(x, y));
}
}
else
{
if(is_vertex(cmd))
{
if(m_markers.size() & 1)
{
// Initial state, the first coordinate was added.
// Add three more points, 0,1,1,0
m_markers.add(coord_type(x, y));
m_markers.add(m_markers[m_markers.size() - 1]);
m_markers.add(m_markers[m_markers.size() - 3]);
}
else
{
if(m_markers.size())
{
// Replace two last points: 0,1,1,0 -> 0,1,2,1
m_markers[m_markers.size() - 1] = m_markers[m_markers.size() - 2];
m_markers[m_markers.size() - 2] = coord_type(x, y);
}
}
}
}
}
//------------------------------------------------------------------------
void gen_stroke::calc_join(const vertex_dist& v0,
const vertex_dist& v1,
const vertex_dist& v2,
double len1, double len2)
{
double dx1, dy1, dx2, dy2;
dx1 = m_width * (v1.y - v0.y) / len1;
dy1 = m_width * (v1.x - v0.x) / len1;
dx2 = m_width * (v2.y - v1.y) / len2;
dy2 = m_width * (v2.x - v1.x) / len2;
m_out_vertices.remove_all();
if(m_line_join == miter_join)
{
calc_miter(v0, v1, v2, dx1, dy1, dx2, dy2);
}
else
{
if(calc_point_location(v0.x, v0.y, v1.x, v1.y, v2.x, v2.y) > 0.0)
{
calc_miter(v0, v1, v2, dx1, dy1, dx2, dy2);
}
else
{
if(m_line_join == round_join)
{
calc_arc(v1.x, v1.y, dx1, -dy1, dx2, -dy2);
}
else
{
m_out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1));
m_out_vertices.add(coord_type(v1.x + dx2, v1.y - dy2));
}
}
}
}
//------------------------------------------------------------------------
void gen_stroke::calc_arc(double x, double y,
double dx1, double dy1,
double dx2, double dy2)
{
double a1 = atan2(dy1, dx1);
double a2 = atan2(dy2, dx2);
double da = a1 - a2;
if(fabs(da) < gen_stroke_theta)
{
m_out_vertices.add(coord_type(x + dx1, y + dy1));
m_out_vertices.add(coord_type(x + dx2, y + dy2));
return;
}
bool ccw = da > 0.0 && da < pi;
da = fabs(1.0 / (m_width * m_approx_scale));
if(!ccw)
{
if(a1 > a2) a2 += 2 * pi;
while(a1 < a2)
{
m_out_vertices.add(coord_type(x + cos(a1) * m_width, y + sin(a1) * m_width));
a1 += da;
}
}
else
{
if(a1 < a2) a2 -= 2 * pi;
while(a1 > a2)
{
m_out_vertices.add(coord_type(x + cos(a1) * m_width, y + sin(a1) * m_width));
a1 -= da;
}
}
m_out_vertices.add(coord_type(x + dx2, y + dy2));
}
//------------------------------------------------------------------------
void gen_stroke::calc_cap(const vertex_dist& v0,
const vertex_dist& v1,
double len)
{
m_out_vertices.remove_all();
double dx1 = m_width * (v1.y - v0.y) / len;
double dy1 = m_width * (v1.x - v0.x) / len;
double dx2 = 0;
double dy2 = 0;
if(m_line_cap == square_cap)
{
dx2 = dy1;
dy2 = dx1;
}
if(m_line_cap == round_cap)
{
double a1 = atan2(dy1, -dx1);
double a2 = a1 + pi;
double da = fabs(1.0 / (m_width * m_approx_scale));
while(a1 < a2)
{
m_out_vertices.add(coord_type(v0.x + cos(a1) * m_width,
v0.y + sin(a1) * m_width));
a1 += da;
}
m_out_vertices.add(coord_type(v0.x + dx1, v0.y - dy1));
}
else
{
m_out_vertices.add(coord_type(v0.x - dx1 - dx2, v0.y + dy1 - dy2));
m_out_vertices.add(coord_type(v0.x + dx1 - dx2, v0.y - dy1 - dy2));
}
}
virtual coord_type eval(const coord_type& x) const { return coord_type(x*x);}
coord_type derive(const coord_type& x,const coord_type& h) const {return coord_type((2.0*(x*h)));}
coord_type derive(const coord_type& x,const coord_type& h) const {
return coord_type(h[1] *0.5/(eval(coord_type(x[1])))[1]);}
virtual coord_type eval(const coord_type& x) const { return coord_type(atan2(x[2],x[1]));}
coord_type derive(const coord_type& x,const coord_type& h) const
{
double n= x.length2();
return coord_type(coord_type(-x[2]/n,x[1]/n)*h);
}
rect screen::bounds( bool active ) const
{
return rect( coord_type( 0 ), coord_type( 0 ), coord_type( 1024 ), coord_type( 720 ) );
}
coord_type derive(const coord_type& x,const coord_type& h) const {
return coord_type(1.0/(1.0+x*x)*h[1]);
}
virtual coord_type eval(const coord_type& x) const {return coord_type((x-m).length() - r);}
coord_type derive(const coord_type& x, const coord_type& h) const { return coord_type(((x-m)*h)/(x-m).length());}
coord_type derive(const coord_type& /*x*/, const coord_type& h) const { return coord_type(h*normal);}
coord_type derive(const coord_type& /*x*/, const coord_type& /*h*/) const { return coord_type(0.0);}
virtual coord_type eval(const coord_type& x) const
{ return coord_type(ap::squared_norm_2(x)); }
coord_type derive(const coord_type& x,const coord_type& h) const {return coord_type(-sin(x[1])*h[1]);}
coord_type derive(const coord_type& /*x*/, const coord_type& h) const { return coord_type(h[i]);}
virtual coord_type eval(const coord_type& x) const { return coord_type(cos(x[1]));}
vertex(vertex<T2,2> const& rhs)
: x(coord_type(rhs.x)),
y(coord_type(rhs.y)),
cmd(rhs.cmd) {}
virtual coord_type eval(const coord_type& x) const { return coord_type(x*normal-dist);}
virtual coord_type eval(const coord_type& x) const
{ return coord_type(hermite(a,b,x[1]));}
