sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
mapnik/deps/agg/include/agg_math_stroke.h

527 lines
18 KiB
C
Raw Normal View History

remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.4
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
// Permission to copy, use, modify, sell and distribute this software
// is granted provided this copyright notice appears in all copies.
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mcseem@antigrain.com
// mcseemagg@yahoo.com
// http://www.antigrain.com
//----------------------------------------------------------------------------
//
// Stroke math
//
//----------------------------------------------------------------------------
#ifndef AGG_STROKE_MATH_INCLUDED
#define AGG_STROKE_MATH_INCLUDED
#include "agg_math.h"
#include "agg_vertex_sequence.h"
namespace agg
{
//-------------------------------------------------------------line_cap_e
enum line_cap_e
{
butt_cap,
square_cap,
round_cap
};
//------------------------------------------------------------line_join_e
enum line_join_e
{
miter_join = 0,
miter_join_revert = 1,
round_join = 2,
bevel_join = 3,
miter_join_round = 4
};
//-----------------------------------------------------------inner_join_e
enum inner_join_e
{
inner_bevel,
inner_miter,
inner_jag,
inner_round
};
//------------------------------------------------------------math_stroke
template<class VertexConsumer> class math_stroke
{
public:
typedef typename VertexConsumer::value_type coord_type;
math_stroke();
void line_cap(line_cap_e lc) { m_line_cap = lc; }
void line_join(line_join_e lj) { m_line_join = lj; }
void inner_join(inner_join_e ij) { m_inner_join = ij; }
line_cap_e line_cap() const { return m_line_cap; }
line_join_e line_join() const { return m_line_join; }
inner_join_e inner_join() const { return m_inner_join; }
void width(double w);
void miter_limit(double ml) { m_miter_limit = ml; }
void miter_limit_theta(double t);
void inner_miter_limit(double ml) { m_inner_miter_limit = ml; }
void approximation_scale(double as) { m_approx_scale = as; }
double width() const { return m_width * 2.0; }
double miter_limit() const { return m_miter_limit; }
double inner_miter_limit() const { return m_inner_miter_limit; }
double approximation_scale() const { return m_approx_scale; }
void calc_cap(VertexConsumer& vc,
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
const vertex_dist& v0,
const vertex_dist& v1,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
double len);
void calc_join(VertexConsumer& vc,
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
const vertex_dist& v0,
const vertex_dist& v1,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
const vertex_dist& v2,
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
double len1,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
double len2);
private:
AGG_INLINE void add_vertex(VertexConsumer& vc, double x, double y)
{
vc.add(coord_type(x, y));
}
void calc_arc(VertexConsumer& vc,
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
double x, double y,
double dx1, double dy1,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
double dx2, double dy2);
void calc_miter(VertexConsumer& vc,
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
const vertex_dist& v0,
const vertex_dist& v1,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
const vertex_dist& v2,
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
double dx1, double dy1,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
double dx2, double dy2,
line_join_e lj,
double mlimit,
double dbevel);
double m_width;
double m_width_abs;
double m_width_eps;
int m_width_sign;
double m_miter_limit;
double m_inner_miter_limit;
double m_approx_scale;
line_cap_e m_line_cap;
line_join_e m_line_join;
inner_join_e m_inner_join;
};
//-----------------------------------------------------------------------
template<class VC> math_stroke<VC>::math_stroke() :
m_width(0.5),
m_width_abs(0.5),
m_width_eps(0.5/1024.0),
m_width_sign(1),
m_miter_limit(4.0),
m_inner_miter_limit(1.01),
m_approx_scale(1.0),
m_line_cap(butt_cap),
m_line_join(miter_join),
m_inner_join(inner_miter)
{
}
//-----------------------------------------------------------------------
template<class VC> void math_stroke<VC>::width(double w)
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
{
m_width = w * 0.5;
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
if(m_width < 0)
{
m_width_abs = -m_width;
m_width_sign = -1;
}
else
{
m_width_abs = m_width;
m_width_sign = 1;
}
m_width_eps = m_width / 1024.0;
}
//-----------------------------------------------------------------------
template<class VC> void math_stroke<VC>::miter_limit_theta(double t)
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
{
fix std:: prefixing for cmath
2014-08-31 00:13:26 +02:00
m_miter_limit = 1.0 / std::sin(t * 0.5) ;
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
}
//-----------------------------------------------------------------------
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
template<class VC>
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
void math_stroke<VC>::calc_arc(VC& vc,
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
double x, double y,
double dx1, double dy1,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
double dx2, double dy2)
{
fix std:: prefixing for cmath
2014-08-31 00:13:26 +02:00
double a1 = std::atan2(dy1 * m_width_sign, dx1 * m_width_sign);
double a2 = std::atan2(dy2 * m_width_sign, dx2 * m_width_sign);
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
double da = a1 - a2;
int i, n;
fix std:: prefixing for cmath
2014-08-31 00:13:26 +02:00
da = std::acos(m_width_abs / (m_width_abs + 0.125 / m_approx_scale)) * 2;
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
add_vertex(vc, x + dx1, y + dy1);
if(m_width_sign > 0)
{
if(a1 > a2) a2 += 2 * pi;
n = int((a2 - a1) / da);
da = (a2 - a1) / (n + 1);
a1 += da;
for(i = 0; i < n; i++)
{
fix std:: prefixing for cmath
2014-08-31 00:13:26 +02:00
add_vertex(vc, x + std::cos(a1) * m_width, y + std::sin(a1) * m_width);
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
a1 += da;
}
}
else
{
if(a1 < a2) a2 -= 2 * pi;
n = int((a1 - a2) / da);
da = (a1 - a2) / (n + 1);
a1 -= da;
for(i = 0; i < n; i++)
{
fix std:: prefixing for cmath
2014-08-31 00:13:26 +02:00
add_vertex(vc, x + std::cos(a1) * m_width, y + std::sin(a1) * m_width);
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
a1 -= da;
}
}
add_vertex(vc, x + dx2, y + dy2);
}
//-----------------------------------------------------------------------
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
template<class VC>
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
void math_stroke<VC>::calc_miter(VC& vc,
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
const vertex_dist& v0,
const vertex_dist& v1,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
const vertex_dist& v2,
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
double dx1, double dy1,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
double dx2, double dy2,
line_join_e lj,
double mlimit,
double dbevel)
{
double xi = v1.x;
double yi = v1.y;
double di = 1;
double lim = m_width_abs * mlimit;
bool miter_limit_exceeded = true; // Assume the worst
bool intersection_failed = true; // Assume the worst
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))
{
// Calculation of the intersection succeeded
//---------------------
di = calc_distance(v1.x, v1.y, xi, yi);
if(di <= lim)
{
// Inside the miter limit
//---------------------
add_vertex(vc, xi, yi);
miter_limit_exceeded = false;
}
intersection_failed = false;
}
else
{
// Calculation of the intersection failed, most probably
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
// the three points lie one straight line.
// First check if v0 and v2 lie on the opposite sides of vector:
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
// (v1.x, v1.y) -> (v1.x+dx1, v1.y-dy1), that is, the perpendicular
// to the line determined by vertices v0 and v1.
// This condition determines whether the next line segments continues
// the previous one or goes back.
//----------------
double x2 = v1.x + dx1;
double y2 = v1.y - dy1;
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
if((cross_product(v0.x, v0.y, v1.x, v1.y, x2, y2) < 0.0) ==
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
(cross_product(v1.x, v1.y, v2.x, v2.y, x2, y2) < 0.0))
{
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
// This case means that the next segment continues
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
// the previous one (straight line)
//-----------------
add_vertex(vc, v1.x + dx1, v1.y - dy1);
miter_limit_exceeded = false;
}
}
if(miter_limit_exceeded)
{
// Miter limit exceeded
//------------------------
switch(lj)
{
case miter_join_revert:
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
// For the compatibility with SVG, PDF, etc,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
// we use a simple bevel join instead of
// "smart" bevel
//-------------------
add_vertex(vc, v1.x + dx1, v1.y - dy1);
add_vertex(vc, v1.x + dx2, v1.y - dy2);
break;
case miter_join_round:
calc_arc(vc, v1.x, v1.y, dx1, -dy1, dx2, -dy2);
break;
default:
// If no miter-revert, calculate new dx1, dy1, dx2, dy2
//----------------
if(intersection_failed)
{
mlimit *= m_width_sign;
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
add_vertex(vc, v1.x + dx1 + dy1 * mlimit,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
v1.y - dy1 + dx1 * mlimit);
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
add_vertex(vc, v1.x + dx2 - dy2 * mlimit,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
v1.y - dy2 - dx2 * mlimit);
}
else
{
double x1 = v1.x + dx1;
double y1 = v1.y - dy1;
double x2 = v1.x + dx2;
double y2 = v1.y - dy2;
di = (lim - dbevel) / (di - dbevel);
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
add_vertex(vc, x1 + (xi - x1) * di,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
y1 + (yi - y1) * di);
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
add_vertex(vc, x2 + (xi - x2) * di,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
y2 + (yi - y2) * di);
}
break;
}
}
}
//--------------------------------------------------------stroke_calc_cap
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
template<class VC>
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
void math_stroke<VC>::calc_cap(VC& vc,
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
const vertex_dist& v0,
const vertex_dist& v1,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
double len)
{
vc.remove_all();
double dx1 = (v1.y - v0.y) / len;
double dy1 = (v1.x - v0.x) / len;
double dx2 = 0;
double dy2 = 0;
dx1 *= m_width;
dy1 *= m_width;
if(m_line_cap != round_cap)
{
if(m_line_cap == square_cap)
{
dx2 = dy1 * m_width_sign;
dy2 = dx1 * m_width_sign;
}
add_vertex(vc, v0.x - dx1 - dx2, v0.y + dy1 - dy2);
add_vertex(vc, v0.x + dx1 - dx2, v0.y - dy1 - dy2);
}
else
{
fix std:: prefixing for cmath
2014-08-31 00:13:26 +02:00
double da = std::acos(m_width_abs / (m_width_abs + 0.125 / m_approx_scale)) * 2;
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
double a1;
int i;
int n = int(pi / da);
da = pi / (n + 1);
add_vertex(vc, v0.x - dx1, v0.y + dy1);
if(m_width_sign > 0)
{
fix std:: prefixing for cmath
2014-08-31 00:13:26 +02:00
a1 = std::atan2(dy1, -dx1);
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
a1 += da;
for(i = 0; i < n; i++)
{
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
add_vertex(vc, v0.x + std::cos(a1) * m_width,
fix std:: prefixing for cmath
2014-08-31 00:13:26 +02:00
v0.y + std::sin(a1) * m_width);
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
a1 += da;
}
}
else
{
fix std:: prefixing for cmath
2014-08-31 00:13:26 +02:00
a1 = std::atan2(-dy1, dx1);
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
a1 -= da;
for(i = 0; i < n; i++)
{
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
add_vertex(vc, v0.x + std::cos(a1) * m_width,
fix std:: prefixing for cmath
2014-08-31 00:13:26 +02:00
v0.y + std::sin(a1) * m_width);
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
a1 -= da;
}
}
add_vertex(vc, v0.x + dx1, v0.y - dy1);
}
}
//-----------------------------------------------------------------------
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
template<class VC>
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
void math_stroke<VC>::calc_join(VC& vc,
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
const vertex_dist& v0,
const vertex_dist& v1,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
const vertex_dist& v2,
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
double len1,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
double len2)
{
double dx1 = m_width * (v1.y - v0.y) / len1;
double dy1 = m_width * (v1.x - v0.x) / len1;
double dx2 = m_width * (v2.y - v1.y) / len2;
double dy2 = m_width * (v2.x - v1.x) / len2;
vc.remove_all();
double cp = cross_product(v0.x, v0.y, v1.x, v1.y, v2.x, v2.y);
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
if (cp != 0 && (cp > 0) == (m_width > 0) && m_width_abs > 0)
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
{
// Inner join
//---------------
double limit = ((len1 < len2) ? len1 : len2) / m_width_abs;
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
if (limit < m_inner_miter_limit)
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
{
limit = m_inner_miter_limit;
}
switch(m_inner_join)
{
default: // inner_bevel
add_vertex(vc, v1.x + dx1, v1.y - dy1);
add_vertex(vc, v1.x + dx2, v1.y - dy2);
break;
case inner_miter:
calc_miter(vc,
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
v0, v1, v2, dx1, dy1, dx2, dy2,
miter_join_revert,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
limit, 0);
break;
case inner_jag:
case inner_round:
cp = (dx1-dx2) * (dx1-dx2) + (dy1-dy2) * (dy1-dy2);
if(cp < len1 * len1 && cp < len2 * len2)
{
calc_miter(vc,
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
v0, v1, v2, dx1, dy1, dx2, dy2,
miter_join_revert,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
limit, 0);
}
else
{
if(m_inner_join == inner_jag)
{
add_vertex(vc, v1.x + dx1, v1.y - dy1);
add_vertex(vc, v1.x, v1.y );
add_vertex(vc, v1.x + dx2, v1.y - dy2);
}
else
{
add_vertex(vc, v1.x + dx1, v1.y - dy1);
add_vertex(vc, v1.x, v1.y );
calc_arc(vc, v1.x, v1.y, dx2, -dy2, dx1, -dy1);
add_vertex(vc, v1.x, v1.y );
add_vertex(vc, v1.x + dx2, v1.y - dy2);
}
}
break;
}
}
else
{
// Outer join
//---------------
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
// Calculate the distance between v1 and
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
// the central point of the bevel line segment
//---------------
double dx = (dx1 + dx2) / 2;
double dy = (dy1 + dy2) / 2;
double dbevel = sqrt(dx * dx + dy * dy);
if(m_line_join == round_join || m_line_join == bevel_join)
{
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
// This is an optimization that reduces the number of points
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
// in cases of almost collinear segments. If there's no
// visible difference between bevel and miter joins we'd rather
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
// use miter join because it adds only one point instead of two.
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
//
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
// Here we calculate the middle point between the bevel points
// and then, the distance between v1 and this middle point.
// At outer joins this distance always less than stroke width,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
// because it's actually the height of an isosceles triangle of
// v1 and its two bevel points. If the difference between this
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
// width and this value is small (no visible bevel) we can
// add just one point.
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
//
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
// The constant in the expression makes the result approximately
// the same as in round joins and caps. You can safely comment
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
// out this entire "if".
//-------------------
if(m_approx_scale * (m_width_abs - dbevel) < m_width_eps)
{
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,
&dx, &dy))
{
add_vertex(vc, dx, dy);
}
else
{
add_vertex(vc, v1.x + dx1, v1.y - dy1);
}
return;
}
}
switch(m_line_join)
{
case miter_join:
case miter_join_revert:
case miter_join_round:
check m_width_abs > 0 to avoid division by zero (-fsanitize=undefined)
2018-02-13 17:05:12 +01:00
calc_miter(vc,
v0, v1, v2, dx1, dy1, dx2, dy2,
m_line_join,
remove tinyxml, no longer needed by boost ptree as it bundles rapidxml now
2011-10-12 05:02:50 +02:00
m_miter_limit,
dbevel);
break;
case round_join:
calc_arc(vc, v1.x, v1.y, dx1, -dy1, dx2, -dy2);
break;
default: // Bevel join
add_vertex(vc, v1.x + dx1, v1.y - dy1);
add_vertex(vc, v1.x + dx2, v1.y - dy2);
break;
}
}
}
}
#endif
Reference in a new issue Copy permalink