paweld/lazarus
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/lazarus/lazarus.git synced 2025-06-27 20:11:43 +02:00
Code Issues Packages Projects Releases Wiki Activity
4f51ba5b51
lazarus/components/aggpas/src/agg_math_stroke.pas
mattias 36a2b1ea07 added aggpas 
git-svn-id: trunk@21942 -
2009-10-01 12:24:32 +00:00

1170 lines
23 KiB
ObjectPascal
Raw Blame History

//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.4 (Public License)
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Anti-Grain Geometry - Version 2.4 Release Milano 3 (AggPas 2.4 RM3)
// Pascal Port By: Milan Marusinec alias Milano
// milan@marusinec.sk
// http://www.aggpas.org
// Copyright (c) 2005-2006
//
// Permission to copy, use, modify, sell and distribute this software
// is granted provided this copyright notice appears in all copies.
// 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
//
// [Pascal Port History] -----------------------------------------------------
//
// 18.10.2007-Milano: math_stroke
// 10.01.2006-Milano: stroke_calc_join ,stroke_calc_miter ,stroke_calc_arc
// 09.01.2006-Milano: stroke_calc_cap
// 19.12.2005-Milano: Unit port establishment
//
{ agg_math_stroke.pas }
unit
agg_math_stroke ;
INTERFACE
{$I agg_mode.inc }
uses
Math ,
agg_basics ,
agg_math ,
agg_vertex_sequence ,
agg_array ;
{ TYPES DEFINITION }
const
butt_cap = 0;
square_cap = 1;
round_cap = 2;
miter_join = 0;
miter_join_revert = 1;
miter_join_round = 4;
round_join = 2;
bevel_join = 3;
inner_bevel = 0;
inner_miter = 1;
inner_jag = 2;
inner_round = 3;
// Minimal angle to calculate round joins, less than 0.1 degree.
stroke_theta = 0.001;
type
line_cap_e = int;
line_join_e = int;
inner_join_e = int;
//------------------------------------------------------------math_stroke
math_stroke = object
m_width ,
m_width_abs ,
m_width_eps : double;
m_width_sign : int;
m_miter_limit ,
m_inner_miter_limit ,
m_approx_scale : double;
m_line_cap : line_cap_e;
m_line_join : line_join_e;
m_inner_join : inner_join_e;
constructor Construct;
procedure line_cap_ (lc : line_cap_e );
procedure line_join_ (lj : line_join_e );
procedure inner_join_(ij : inner_join_e );
function _line_cap : line_cap_e;
function _line_join : line_join_e;
function _inner_join : inner_join_e;
procedure width_ (w : double );
procedure miter_limit_ (ml : double );
procedure miter_limit_theta_ (t : double );
procedure inner_miter_limit_ (ml : double );
procedure approximation_scale_(as_ : double );
function _width : double;
function _miter_limit : double;
function _inner_miter_limit : double;
function _approximation_scale : double;
procedure calc_cap(
vc : pod_bvector_ptr;
v0 ,v1 : vertex_dist_ptr;
len : double );
procedure calc_join(
vc : pod_bvector_ptr;
v0 ,v1 ,v2 : vertex_dist_ptr;
len1 ,len2 : double );
procedure add_vertex(vc : pod_bvector_ptr; x ,y : double );
procedure calc_arc(
vc : pod_bvector_ptr;
x ,y ,dx1 ,dy1 ,dx2 ,dy2 : double );
procedure calc_miter(
vc : pod_bvector_ptr;
v0 ,v1 ,v2 : vertex_dist_ptr;
dx1 ,dy1 ,dx2 ,dy2 : double;
lj : line_join_e;
mlimit ,dbevel : double );
end;
{ GLOBAL PROCEDURES }
procedure stroke_calc_arc(
out_vertices : pod_deque_ptr;
x ,y ,dx1 ,dy1 ,dx2 ,dy2 ,width ,approximation_scale : double );
procedure stroke_calc_miter(
out_vertices : pod_deque_ptr;
v0 ,v1 ,v2 : vertex_dist_ptr;
dx1 ,dy1 ,dx2 ,dy2 ,width : double;
line_join : unsigned;
miter_limit ,approximation_scale : double );
procedure stroke_calc_cap(
out_vertices : pod_deque_ptr;
v0 ,v1 : vertex_dist_ptr;
len : double;
line_cap : unsigned;
width ,approximation_scale : double );
procedure stroke_calc_join(
out_vertices : pod_deque_ptr;
v0 ,v1 , v2 : vertex_dist_ptr;
len1 ,len2 ,width : double;
line_join ,inner_join : unsigned;
miter_limit ,inner_miter_limit ,approximation_scale : double );
IMPLEMENTATION
{ LOCAL VARIABLES & CONSTANTS }
{ UNIT IMPLEMENTATION }
{ CONSTRUCT }
constructor math_stroke.Construct;
begin
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;
end;
{ LINE_CAP_ }
procedure math_stroke.line_cap_(lc : line_cap_e );
begin
m_line_cap:=lc;
end;
{ LINE_JOIN_ }
procedure math_stroke.line_join_(lj : line_join_e );
begin
m_line_join:=lj;
end;
{ INNER_JOIN_ }
procedure math_stroke.inner_join_(ij : inner_join_e );
begin
m_inner_join:=ij;
end;
{ _LINE_CAP }
function math_stroke._line_cap : line_cap_e;
begin
result:=m_line_cap;
end;
{ _LINE_JOIN }
function math_stroke._line_join : line_join_e;
begin
result:=m_line_join;
end;
{ _INNER_JOIN }
function math_stroke._inner_join : inner_join_e;
begin
result:=m_inner_join;
end;
{ WIDTH_ }
procedure math_stroke.width_(w : double );
begin
m_width:=w * 0.5;
if m_width < 0 then
begin
m_width_abs :=-m_width;
m_width_sign:=-1;
end
else
begin
m_width_abs :=m_width;
m_width_sign:=1;
end;
m_width_eps:=m_width / 1024.0;
end;
{ MITER_LIMIT_ }
procedure math_stroke.miter_limit_(ml : double );
begin
m_miter_limit:=ml;
end;
{ MITER_LIMIT_THETA_ }
procedure math_stroke.miter_limit_theta_(t : double );
begin
m_miter_limit:=1.0 / Sin(t * 0.5 ) ;
end;
{ INNER_MITER_LIMIT_ }
procedure math_stroke.inner_miter_limit_(ml : double );
begin
m_inner_miter_limit:=ml;
end;
{ APPROXIMATION_SCALE_ }
procedure math_stroke.approximation_scale_(as_ : double );
begin
m_approx_scale:=as_;
end;
{ _WIDTH }
function math_stroke._width : double;
begin
result:=m_width * 2.0;
end;
{ _MITER_LIMIT }
function math_stroke._miter_limit : double;
begin
result:=m_miter_limit;
end;
{ _INNER_MITER_LIMIT }
function math_stroke._inner_miter_limit : double;
begin
result:=m_inner_miter_limit;
end;
{ _APPROXIMATION_SCALE }
function math_stroke._approximation_scale : double;
begin
result:=m_approx_scale;
end;
{ CALC_CAP }
procedure math_stroke.calc_cap(
vc : pod_bvector_ptr;
v0 ,v1 : vertex_dist_ptr;
len : double );
var
dx1 ,dy1 ,dx2 ,dy2 ,da ,a1 : double;
i ,n : int;
begin
vc.remove_all;
dx1:=(v1.y - v0.y ) / len;
dy1:=(v1.x - v0.x ) / len;
dx2:=0;
dy2:=0;
dx1:=dx1 * m_width;
dy1:=dy1 * m_width;
if m_line_cap <> round_cap then
begin
if m_line_cap = square_cap then
begin
dx2:=dy1 * m_width_sign;
dy2:=dx1 * m_width_sign;
end;
add_vertex(vc ,v0.x - dx1 - dx2 ,v0.y + dy1 - dy2 );
add_vertex(vc ,v0.x + dx1 - dx2 ,v0.y - dy1 - dy2 );
end
else
begin
da:=ArcCos(m_width_abs / (m_width_abs + 0.125 / m_approx_scale ) ) * 2;
n :=int(Trunc(pi / da ) );
da:=pi / (n + 1 );
add_vertex(vc ,v0.x - dx1 ,v0.y + dy1 );
if m_width_sign > 0 then
begin
a1:=ArcTan2(dy1 ,-dx1 );
a1:=a1 + da;
i :=0;
while i < n do
begin
add_vertex(
vc ,
v0.x + Cos(a1 ) * m_width ,
v0.y + Sin(a1 ) * m_width );
a1:=a1 + da;
inc(i );
end;
end
else
begin
a1:=ArcTan2(-dy1 ,dx1 );
a1:=a1 - da;
i :=0;
while i < n do
begin
add_vertex(
vc ,
v0.x + Cos(a1 ) * m_width ,
v0.y + Sin(a1 ) * m_width );
a1:=a1 - da;
inc(i );
end;
end;
add_vertex(vc ,v0.x + dx1 ,v0.y - dy1 );
end;
end;
{ CALC_JOIN }
procedure math_stroke.calc_join(
vc : pod_bvector_ptr;
v0 ,v1 ,v2 : vertex_dist_ptr;
len1 ,len2 : double );
var
dx1 ,dy1 ,dx2 ,dy2 ,cp ,limit ,dx ,dy ,dbevel : double;
begin
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;
vc.remove_all;
cp:=cross_product(v0.x ,v0.y ,v1.x ,v1.y ,v2.x ,v2.y );
if (cp <> 0 ) and
((cp > 0 ) = (m_width > 0 ) ) then
begin
// Inner join
if len1 < len2 then
limit:=len1 / m_width_abs
else
limit:=len2 / m_width_abs;
if limit < m_inner_miter_limit then
limit:=m_inner_miter_limit;
case m_inner_join of
inner_miter :
calc_miter(vc ,v0 ,v1 ,v2 ,dx1 ,dy1 ,dx2 ,dy2 ,miter_join_revert ,limit ,0 );
inner_jag ,inner_round :
begin
cp:=(dx1 - dx2 ) * (dx1 - dx2 ) + (dy1 - dy2 ) * (dy1 - dy2 );
if (cp < len1 * len1 ) and
(cp < len2 * len2 ) then
calc_miter(vc ,v0 ,v1 ,v2 ,dx1 ,dy1 ,dx2 ,dy2 ,miter_join_revert ,limit ,0 )
else
if m_inner_join = inner_jag then
begin
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 );
end
else
begin
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 );
end;
end;
else
begin
// inner_bevel
add_vertex(vc ,v1.x + dx1 ,v1.y - dy1 );
add_vertex(vc ,v1.x + dx2 ,v1.y - dy2 );
end;
end;
end
else
begin
// Outer join
//---------------
// Calculate the distance between v1 and
// the central point of the bevel line segment
dx:=(dx1 + dx2 ) / 2;
dy:=(dy1 + dy2 ) / 2;
dbevel:=Sqrt(dx * dx + dy * dy );
if (m_line_join = round_join ) or
(m_line_join = bevel_join ) then
begin
// This is an optimization that reduces the number of points
// in cases of almost collinear segments. If there's no
// visible difference between bevel and miter joins we'd rather
// use miter join because it adds only one point instead of two.
//
// 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,
// because it's actually the height of an isosceles triangle of
// v1 and its two bevel points. If the difference between this
// width and this value is small (no visible bevel) we can
// add just one point.
//
// The constant in the expression makes the result approximately
// the same as in round joins and caps. You can safely comment
// out this entire "if".
if m_approx_scale * (m_width_abs - dbevel ) < m_width_eps then
begin
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 ) then
add_vertex(vc ,dx ,dy )
else
add_vertex(vc ,v1.x + dx1 ,v1.y - dy1 );
exit;
end;
end;
case m_line_join of
miter_join ,miter_join_revert ,miter_join_round :
calc_miter(
vc ,v0 ,v1 ,v2 ,dx1 ,dy1 ,dx2 ,dy2 ,
m_line_join ,m_miter_limit ,dbevel );
round_join :
calc_arc(vc ,v1.x ,v1.y ,dx1 ,-dy1 ,dx2 ,-dy2 );
else
begin
// Bevel join
add_vertex(vc ,v1.x + dx1 ,v1.y - dy1 );
add_vertex(vc ,v1.x + dx2 ,v1.y - dy2 );
end;
end;
end;
end;
{ ADD_VERTEX }
procedure math_stroke.add_vertex(vc : pod_bvector_ptr; x ,y : double );
var
pt : point_type;
begin
pt.x:=x;
pt.y:=y;
vc.add(@pt );
end;
{ CALC_ARC }
procedure math_stroke.calc_arc(
vc : pod_bvector_ptr;
x ,y ,dx1 ,dy1 ,dx2 ,dy2 : double );
var
a1 ,a2 ,da : double;
i ,n : int;
begin
a1:=ArcTan2(dy1 * m_width_sign ,dx1 * m_width_sign );
a2:=ArcTan2(dy2 * m_width_sign ,dx2 * m_width_sign );
da:=a1 - a2;
da:=ArcCos(m_width_abs / (m_width_abs + 0.125 / m_approx_scale ) ) * 2;
add_vertex(vc ,x + dx1 ,y + dy1 );
if m_width_sign > 0 then
begin
if a1 > a2 then
a2:=a2 + 2 * pi;
n :=int(Trunc((a2 - a1 ) / da ) );
da:=(a2 - a1 ) / (n + 1 );
a1:=a1 + da;
i :=0;
while i < n do
begin
add_vertex(vc ,x + Cos(a1 ) * m_width ,y + Sin(a1 ) * m_width );
a1:=a1 + da;
inc(i );
end;
end
else
begin
if a1 < a2 then
a2:=a2 - 2 * pi;
n :=int(Trunc((a1 - a2 ) / da ) );
da:=(a1 - a2 ) / (n + 1 );
a1:=a1 - da;
i :=0;
while i < n do
begin
add_vertex(vc ,x + Cos(a1 ) * m_width ,y + Sin(a1 ) * m_width );
a1:=a1 - da;
inc(i );
end;
end;
add_vertex(vc ,x + dx2 ,y + dy2 );
end;
{ CALC_MITER }
procedure math_stroke.calc_miter(
vc : pod_bvector_ptr;
v0 ,v1 ,v2 : vertex_dist_ptr;
dx1 ,dy1 ,dx2 ,dy2 : double;
lj : line_join_e;
mlimit ,dbevel : double );
var
xi ,yi ,di ,lim ,x2 ,y2 ,x1 ,y1 : double;
miter_limit_exceeded ,intersection_failed : boolean;
begin
xi :=v1.x;
yi :=v1.y;
di :=1;
lim:=m_width_abs * mlimit;
miter_limit_exceeded:=true; // Assume the worst
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 ) then
begin
// Calculation of the intersection succeeded
di:=calc_distance(v1.x ,v1.y ,xi ,yi );
if di <= lim then
begin
// Inside the miter limit
add_vertex(vc, xi, yi);
miter_limit_exceeded:=false;
end;
intersection_failed:=false;
end
else
begin
// Calculation of the intersection failed, most probably
// the three points lie one straight line.
// First check if v0 and v2 lie on the opposite sides of vector:
// (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.
x2:=v1.x + dx1;
y2:=v1.y - dy1;
if (cross_product(v0.x ,v0.y ,v1.x ,v1.y ,x2 ,y2 ) < 0.0 ) =
(cross_product(v1.x ,v1.y ,v2.x ,v2.y ,x2 ,y2 ) < 0.0 ) then
begin
// This case means that the next segment continues
// the previous one (straight line)
add_vertex(vc ,v1.x + dx1 ,v1.y - dy1 );
miter_limit_exceeded:=false;
end;
end;
// Miter limit exceeded
if miter_limit_exceeded then
case lj of
miter_join_revert :
begin
// For the compatibility with SVG, PDF, etc,
// 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 );
end;
miter_join_round :
calc_arc(vc ,v1.x ,v1.y ,dx1 ,-dy1 ,dx2 ,-dy2 );
// If no miter-revert, calculate new dx1, dy1, dx2, dy2
else
if intersection_failed then
begin
mlimit:=mlimit * m_width_sign;
add_vertex(
vc ,
v1.x + dx1 + dy1 * mlimit ,
v1.y - dy1 + dx1 * mlimit );
add_vertex(
vc ,
v1.x + dx2 - dy2 * mlimit ,
v1.y - dy2 - dx2 * mlimit );
end
else
begin
x1:=v1.x + dx1;
y1:=v1.y - dy1;
x2:=v1.x + dx2;
y2:=v1.y - dy2;
di:=(lim - dbevel ) / (di - dbevel );
add_vertex(
vc ,
x1 + (xi - x1 ) * di ,
y1 + (yi - y1 ) * di );
add_vertex(
vc ,
x2 + (xi - x2 ) * di ,
y2 + (yi - y2 ) * di );
end;
end;
end;
{ STROKE_CALC_ARC }
procedure stroke_calc_arc;
var
pt : point_type;
a1 ,a2 ,da : double;
ccw : boolean;
begin
a1:=ArcTan2(dy1 ,dx1 );
a2:=ArcTan2(dy2 ,dx2 );
da:=a1 - a2;
// Possible optimization. Not important at all; consumes time but happens rarely
// if Abs(da ) < stroke_theta then
// begin
// pt.x:=(x + x + dx1 + dx2 ) * 0.5;
// pt.y:=(y + y + dy1 + dy2 ) * 0.5;
//
// out_vertices.add(@pt );
// exit;
//
// end;
ccw:=(da > 0.0 ) and (da < pi );
if width < 0 then
width:=-width;
if approximation_scale = 0 then
approximation_scale:=0.00001;
da:=ArcCos(width / (width + 0.125 / approximation_scale ) ) * 2;
pt.x:=x + dx1;
pt.y:=y + dy1;
out_vertices.add(@pt );
if not ccw then
begin
if a1 > a2 then
a2:=a2 + (2 * pi );
a2:=a2 - (da / 4 );
a1:=a1 + da;
while a1 < a2 do
begin
pt.x:=x + Cos(a1 ) * width;
pt.y:=y + Sin(a1 ) * width;
out_vertices.add(@pt );
a1:=a1 + da;
end;
end
else
begin
if a1 < a2 then
a2:=a2 - (2 * pi );
a2:=a2 + (da / 4 );
a1:=a1 - da;
while a1 > a2 do
begin
pt.x:=x + Cos(a1 ) * width;
pt.y:=y + Sin(a1 ) * width;
out_vertices.add(@pt );
a1:=a1 - da;
end;
end;
pt.x:=x + dx2;
pt.y:=y + dy2;
out_vertices.add(@pt );
end;
{ STROKE_CALC_MITER }
procedure stroke_calc_miter;
var
pt : point_type;
xi ,yi ,d1 ,lim ,x2 ,y2 : double;
miter_limit_exceeded : boolean;
begin
xi:=v1.x;
yi:=v1.y;
miter_limit_exceeded:=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 ) then
begin
// Calculation of the intersection succeeded
//---------------------
d1 :=calc_distance(v1.x ,v1.y ,xi ,yi );
lim:=width * miter_limit;
if d1 <= lim then
begin
// Inside the miter limit
//---------------------
pt.x:=xi;
pt.y:=yi;
out_vertices.add(@pt );
miter_limit_exceeded:=false;
end;
end
else
begin
// Calculation of the intersection failed, most probably
// the three points lie one straight line.
// First check if v0 and v2 lie on the opposite sides of vector:
// (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.
//----------------
x2:=v1.x + dx1;
y2:=v1.y - dy1;
if (((x2 - v0.x ) * dy1 - (v0.y - y2 ) * dx1 < 0.0 ) <>
((x2 - v2.x ) * dy1 - (v2.y - y2 ) * dx1 < 0.0 ) ) then
begin
// This case means that the next segment continues
// the previous one (straight line)
//-----------------
pt.x:=v1.x + dx1;
pt.y:=v1.y - dy1;
out_vertices.add(@pt );
miter_limit_exceeded:=false;
end;
end;
if miter_limit_exceeded then
// Miter limit exceeded
//------------------------
case line_join of
miter_join_revert :
begin
// For the compatibility with SVG, PDF, etc,
// we use a simple bevel join instead of
// "smart" bevel
//-------------------
pt.x:=v1.x + dx1;
pt.y:=v1.y - dy1;
out_vertices.add(@pt );
pt.x:=v1.x + dx2;
pt.y:=v1.y - dy2;
out_vertices.add(@pt );
end;
miter_join_round :
stroke_calc_arc(
out_vertices ,
v1.x ,v1.y ,dx1 ,-dy1 ,dx2 ,-dy2 ,
width ,approximation_scale );
else
begin
// If no miter-revert, calculate new dx1, dy1, dx2, dy2
//----------------
pt.x:=v1.x + dx1 + dy1 * miter_limit;
pt.y:=v1.y - dy1 + dx1 * miter_limit;
out_vertices.add(@pt );
pt.x:=v1.x + dx2 - dy2 * miter_limit;
pt.y:=v1.y - dy2 - dx2 * miter_limit;
out_vertices.add(@pt );
end;
end;
end;
{ STROKE_CALC_CAP }
procedure stroke_calc_cap;
var
pt : point_type;
dx1 ,dy1 ,
dx2 ,dy2 ,
a1 ,a2 ,da : double;
begin
out_vertices.remove_all;
dx1:=(v1.y - v0.y ) / len;
dy1:=(v1.x - v0.x ) / len;
dx2:=0;
dy2:=0;
dx1:=dx1 * width;
dy1:=dy1 * width;
if line_cap <> round_cap then
begin
if line_cap = square_cap then
begin
dx2:=dy1;
dy2:=dx1;
end;
pt.x:=v0.x - dx1 - dx2;
pt.y:=v0.y + dy1 - dy2;
out_vertices.add(@pt );
pt.x:=v0.x + dx1 - dx2;
pt.y:=v0.y - dy1 - dy2;
out_vertices.add(@pt );
end
else
begin
a1:=ArcTan2(dy1 ,-dx1 );
a2:=a1 + pi;
if approximation_scale = 0 then
approximation_scale:=0.00001;
da:=ArcCos(width / (width + 0.125 / approximation_scale ) ) * 2;
pt.x:=v0.x - dx1;
pt.y:=v0.y + dy1;
out_vertices.add(@pt );
a1:=a1 + da;
a2:=a2 - (da / 4 );
while a1 < a2 do
begin
pt.x:=v0.x + Cos(a1 ) * width;
pt.y:=v0.y + Sin(a1 ) * width;
out_vertices.add(@pt );
a1:=a1 + da;
end;
pt.x:=v0.x + dx1;
pt.y:=v0.y - dy1;
out_vertices.add(@pt );
end;
end;
{ STROKE_CALC_JOIN }
procedure stroke_calc_join;
var
pt : point_type;
d ,dx1 ,dy1 ,dx2 ,dy2 : double;
begin
dx1:=width * (v1.y - v0.y ) / len1;
dy1:=width * (v1.x - v0.x ) / len1;
dx2:=width * (v2.y - v1.y ) / len2;
dy2:=width * (v2.x - v1.x ) / len2;
out_vertices.remove_all;
if calc_point_location(v0.x ,v0.y ,v1.x ,v1.y ,v2.x ,v2.y ) > 0 then
// Inner join
//---------------
case inner_join of
inner_miter :
stroke_calc_miter(
out_vertices ,
v0 ,v1 ,v2 ,dx1 ,dy1 ,dx2 ,dy2 ,
width ,
miter_join_revert ,
inner_miter_limit ,
1.0 );
inner_jag ,inner_round :
begin
d:=(dx1 - dx2 ) * (dx1 - dx2 ) + (dy1 - dy2 ) * (dy1 - dy2 );
if (d < len1 * len1 ) and
(d < len2 * len2 ) then
stroke_calc_miter(
out_vertices ,
v0 ,v1 ,v2 ,dx1 ,dy1 ,dx2 ,dy2 ,
width ,
miter_join_revert ,
inner_miter_limit ,
1.0 )
else
if inner_join = inner_jag then
begin
pt.x:=v1.x + dx1;
pt.y:=v1.y - dy1;
out_vertices.add(@pt );
pt.x:=v1.x;
pt.y:=v1.y;
out_vertices.add(@pt );
pt.x:=v1.x + dx2;
pt.y:=v1.y - dy2;
out_vertices.add(@pt );
end
else
begin
pt.x:=v1.x + dx1;
pt.y:=v1.y - dy1;
out_vertices.add(@pt );
pt.x:=v1.x;
pt.y:=v1.y;
out_vertices.add(@pt );
stroke_calc_arc(
out_vertices ,
v1.x ,v1.y ,dx2 ,-dy2 ,dx1 ,-dy1 ,
width ,approximation_scale );
pt.x:=v1.x;
pt.y:=v1.y;
out_vertices.add(@pt );
pt.x:=v1.x + dx2;
pt.y:=v1.y - dy2;
out_vertices.add(@pt );
end;
end;
else // inner_bevel
begin
pt.x:=v1.x + dx1;
pt.y:=v1.y - dy1;
out_vertices.add(@pt );
pt.x:=v1.x + dx2;
pt.y:=v1.y - dy2;
out_vertices.add(@pt );
end;
end
else
// Outer join
//---------------
case line_join of
miter_join ,miter_join_revert ,miter_join_round :
stroke_calc_miter(
out_vertices ,
v0 ,v1 ,v2 ,dx1 ,dy1 ,dx2 ,dy2 ,
width ,
line_join ,
miter_limit ,
approximation_scale );
round_join :
stroke_calc_arc(
out_vertices ,
v1.x ,v1.y ,dx1 ,-dy1 ,dx2 ,-dy2 ,
width ,approximation_scale );
else // Bevel join
begin
pt.x:=v1.x + dx1;
pt.y:=v1.y - dy1;
out_vertices.add(@pt );
pt.x:=v1.x + dx2;
pt.y:=v1.y - dy2;
out_vertices.add(@pt );
end;
end;
end;
END.
Reference in New Issue View Git Blame Copy Permalink