blib/lib/Math/Clipper.pm

filter: Statementstmt 94.6% 106 / 112 Branchbran 78.0% 39 / 50 Conditioncond 46.4% 13 / 28 MC/DCmcdc 15.3% 2 / 13 Subroutinesub 92.3% 12 / 13 Podpod 75.0% 3 / 4 totaltotal 79.5% 175 / 220 CC 37 SCAR 29.7
CC
37
Cov
83%
integerize_coordinate_sets
31.4
unscale_coordinate_sets
6.0
offset
5.1
CRAP 19.4
↑ Summary src/poly2av.h »
1 package Math::Clipper;
2  
3 12 ▶use 5.008;
Subroutine BEGIN: called CC=1 SCAR=0.0
4 12 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 12 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 12 ▶use Carp qw(croak carp);
Subroutine BEGIN: called CC=1 SCAR=0.0
7 12 ▶use Config;
Subroutine BEGIN: called CC=1 SCAR=0.0
8  
9 12 ▶use Exporter();
Subroutine BEGIN: called CC=1 SCAR=0.0
10 12 our $VERSION;
11 12 our @ISA = qw(Exporter);
12  
13 12 ▶BEGIN {
Subroutine BEGIN: called CC=1 SCAR=0.0
14 12 ▶ use XSLoader;
Subroutine BEGIN: called CC=1 SCAR=0.0
15 12 $VERSION = '1.30';
16 12 XSLoader::load('Math::Clipper', $VERSION);
17 }
18  
19 # TODO: keep in sync with docs below and xsp/Clipper.xsp
20  
21 12 our %EXPORT_TAGS = (
22 cliptypes => [qw/CT_INTERSECTION CT_UNION CT_DIFFERENCE CT_XOR/],
23 #polytypes => [qw/PT_SUBJECT PT_CLIP/],
24 polyfilltypes => [qw/PFT_EVENODD PFT_NONZERO PFT_POSITIVE PFT_NEGATIVE/],
25 jointypes => [qw/JT_MITER JT_ROUND JT_SQUARE/],
26 utilities => [qw/area offset is_counter_clockwise orientation integerize_coordinate_sets unscale_coordinate_sets
27 simplify_polygon simplify_polygons int_offset ex_int_offset ex_int_offset2/],
28 );
29  
30 12 $EXPORT_TAGS{all} = [ map { @$_ } values %EXPORT_TAGS ];
31 12 our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
32 12 our @EXPORT = qw();
33  
34 12 my %intspecs = (
35 '64' => {
36 maxint => 4611686018427387902, # Clipper-imposed max when using 64 bit integer math
37 maxdigits => 19
38 },
39 '53' => {
40 maxint => 9007199254740992, # signed 53 bit integer max, for integers stored in double precision floats
41 maxdigits => 16
42 },
43 '32' => {
44 maxint => 1073741822, # Clipper-imposed max to avoid calculations with large integer types
45 maxdigits => 10
46 },
47 );
48  
49 my $is64safe = ((defined($Config{use64bitint}) && $Config{use64bitint} eq 'define') || $Config{longsize} >= 8 ) &&
50 12 ▶ ((defined($Config{uselongdouble}) && $Config{uselongdouble} eq 'define') || $Config{doublesize} >= 10);
Condition33%5/15
(defined $Math::Clipper::Config{'use64bitint'} && $Math::Clipper::Config{'use64bitint'} eq 'define' || $Math::Clipper::Config{'longsize'} >= 8) && (defined $Math::Clipper::Config{'uselongdouble'} && $Math::Clipper::Config{'uselongdouble'} eq 'define' || $Math::Clipper::Config{'doublesize'} >= 10)
!ll&&!rl&&r
0120
defined $Math::Clipper::Config{"use64bitint"} and $Math::Clipper::Config{"use64bitint"} eq "define" or $Math::Clipper::Config{"longsize"} >= 8
l!l&&r!l&&!r
1200
defined $Math::Clipper::Config{"use64bitint"} and $Math::Clipper::Config{"use64bitint"} eq "define"
!ll&&!rl&&r
0012
defined $Math::Clipper::Config{"uselongdouble"} and $Math::Clipper::Config{"uselongdouble"} eq "define" or $Math::Clipper::Config{"doublesize"} >= 10
l!l&&r!l&&!r
0012
defined $Math::Clipper::Config{"uselongdouble"} and $Math::Clipper::Config{"uselongdouble"} eq "define"
!ll&&!rl&&r
1200
MC/DC0%0/6
(defined $Math::Clipper::Config{'use64bitint'} && $Math::Clipper::Config{'use64bitint'} eq 'define' || $Math::Clipper::Config{'longsize'} >= 8) && (defined $Math::Clipper::Config{'uselongdouble'} && $Math::Clipper::Config{'uselongdouble'} eq 'define' || $Math::Clipper::Config{'doublesize'} >= 10)
defined $Math::Clipper::Config{"use64bitint"} $Math::Clipper::Config{"use64bitint"} eq "define" $Math::Clipper::Config{"longsize"} >= 8 defined $Math::Clipper::Config{"uselongdouble"} $Math::Clipper::Config{"uselongdouble"} eq "define" $Math::Clipper::Config{"doublesize"} >= 10
Truth table5%1/17
A and B or C && D and E or F
A= defined $Math::Clipper::Config{"use64bitint"}B= $Math::Clipper::Config{"use64bitint"} eq "define"C= $Math::Clipper::Config{"longsize"} >= 8D= defined $Math::Clipper::Config{"uselongdouble"}E= $Math::Clipper::Config{"uselongdouble"} eq "define"F= $Math::Clipper::Config{"doublesize"} >= 10
ABCDEFresult
0X0XXX0
100XXX0
11X0X00
11X1000
0X10X00
0X11000
1010X00
1011000
11X11X1
11X0X11
11X1011
0X111X1
0X10X11
0X11011
10111X1
1010X11
1011011
51  
52 5 ▶sub offset {
Subroutine offset: called CC=5 SCAR=16.4
Pod documented
53 5 my ($polygons, $delta, $scale, $jointype, $miterlimit) = @_;
54 5 ▶ $scale ||= 100;
Condition50%1/2
$scale ||= 100
l!l
50
MC/DC0%0/1
$scale ||= 100
$scale
Truth table50%1/2
A
A= $scale
Aresult
11
00
55 5 ▶ $jointype = JT_MITER if !defined $jointype;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $jointype 5 0 5
56 5 ▶ $miterlimit ||= 2;
Condition50%1/2
$miterlimit ||= 2
l!l
05
MC/DC0%0/1
$miterlimit ||= 2
$miterlimit
Truth table50%1/2
A
A= $miterlimit
Aresult
11
00
57  
58 5 my $scalevec=[$scale,$scale];
59 5 my $polyscopy=[(map {[(map {[(map {$_*$scalevec->[0]} @{$_})]} @{$_})]} @{$polygons})];
60 5 my $ret = _offset($polyscopy,$delta*$scale, $jointype, $miterlimit);
61 5 ▶ unscale_coordinate_sets($scalevec , $ret) if @$ret;
Branch: 1 branch
BranchTrueFalseTotal
if @$ret 5 0 5
62 5 return $ret;
63 }
64  
65 12 *is_counter_clockwise = *orientation;
66  
67 9 ▶sub unscale_coordinate_sets { # to undo what integerize_coordinate_sets() does
Subroutine unscale_coordinate_sets: called CC=6 SCAR=17.9
Pod documented
68 9 my $scale_vector=shift;
69 9 my $coord_sets=shift;
70 9 my $coord_count=scalar(@{$coord_sets->[0]->[0]});
71 9 ▶ if (!ref($scale_vector)) {$scale_vector=[(map {$scale_vector} (0..$coord_count-1))];}
Branch: 1 branch
BranchTrueFalseTotal
unless (ref $scale_vector) 1 8 9
72 9 foreach my $set (@{$coord_sets}) {
73 11 foreach my $vector (@{$set}) {
74 39 ▶ for (my $ci=0;$ci<$coord_count;$ci++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($ci < $coord_count) 86 39 125
75 86 ▶ $vector->[$ci] /= $scale_vector->[$ci] if $scale_vector->[$ci]; # avoid divide by zero
Branch: 1 branch
BranchTrueFalseTotal
if $scale_vector->[$ci] 86 0 86
76 }
77 }
78 }
79 }
80  
81 5 ▶sub integerize_coordinate_sets {
Subroutine integerize_coordinate_sets: called CC=28 SCAR=34.5
Pod documented
82 5 my %opts=();
83 5 ▶ if (ref($_[0]) =~ /HASH/) {%opts=%{(shift)};}
Branch: 1 branch
BranchTrueFalseTotal
if (ref($_[0]) =~ /HASH/) 4 1 5
84 5 ▶ $opts{constrain} = 1 if !defined($opts{constrain});
Branch: 1 branch
BranchTrueFalseTotal
unless defined $opts{"constrain"} 1 4 5
85 5 ▶ $opts{bits} = ($is64safe ? 64 : 53) if !defined($opts{bits});
Branch: 2 branches
BranchTrueFalseTotal
unless defined $opts{"bits"} 3 2 5
$is64safe ? : 0 3 3
86 0 ▶ if ($opts{bits} == 64 && !$is64safe) {$opts{bits} = 53; carp "Integerize to 64 bits requires both long long and long double underlying Perl's default integer and double types. Using 53 bits instead.";}
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{"bits"} == 64 and not $is64safe) 0 5 5
Condition33%1/3
$opts{"bits"} == 64 and not $is64safe
!ll&&!rl&&r
500
MC/DC0%0/2
$opts{"bits"} == 64 and not $is64safe
$opts{"bits"} == 64 not $is64safe
Truth table33%1/3
A and not(B)
A= $opts{"bits"} == 64B= not $is64safe
ABresult
0X0
100
111
87 5 ▶ $opts{margin} = 0 if !defined($opts{margin});
Branch: 1 branch
BranchTrueFalseTotal
unless defined $opts{"margin"} 5 0 5
88  
89 # assume all coordinate vectors (points) have same number of coordinates; get that count from first one
90 5 my $coord_count=scalar(@{$_[0]->[0]});
91  
92 # return this array of each column's calculated scale factor, so users can "unscale" Clipper results
93 5 my @scale_vector;
94  
95 # deal with each coordinate column (eg. x column, y column, ... possibly more)
96 5 ▶ for (my $ci=0;$ci<$coord_count;$ci++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($ci < $coord_count) 12 5 17
97 12 my $maxc=$_[0]->[0]->[$ci];
98 12 my $max_exp;
99  
100 # go through all the coordinate sets, looking just at the current column
101 12 foreach my $set (@_) {
102 # for each "point"
103 15 foreach my $vector (@{$set}) {
104 # possibly update the the maximum magnitude seen in the column
105 39 ▶ if ($maxc<abs($vector->[$ci]) + $opts{margin}) {$maxc=abs($vector->[$ci]) + $opts{margin};}
Branch: 1 branch
BranchTrueFalseTotal
if ($maxc < abs($vector->[$ci]) + $opts{"margin"}) 16 23 39
106 # look for the maximum exponent, when coords are in scientific notation
107 39 ▶ if (sprintf("%.20e",$vector->[$ci] + ($vector->[$ci]<0?-1:1)*$opts{margin}) =~ /[eE]([+-])0*(\d+)$/) {
Branch: 2 branches
BranchTrueFalseTotal
if (sprintf('%.20e', $vector->[$ci] + ($vector->[$ci] < 0 ? -1 : 1) * $opts{'margin'}) =~ /[eE]([+-])0*(\d+)$/) { } 39 0 39
$vector->[$ci] < 0 ? : 9 30 39
108 39 my $exp1 = eval($1.$2);
109 39 ▶ if (defined $vector->[$ci] && (!defined($max_exp) || $max_exp<$exp1)) {$max_exp=$exp1;}
Branch: 1 branch
BranchTrueFalseTotal
if (defined $vector->[$ci] and !defined($max_exp) || $max_exp < $exp1) 17 22 39
Condition83%5/6
defined $vector->[$ci] and !defined($max_exp) || $max_exp < $exp1
!ll&&!rl&&r
02217
not defined $max_exp or $max_exp < $exp1
l!l&&r!l&&!r
12522
MC/DC66%2/3
defined $vector->[$ci] and !defined($max_exp) || $max_exp < $exp1
defined $vector->[$ci] not defined $max_exp $max_exp < $exp1
Truth table75%3/4
A and not(B) or C
A= defined $vector->[$ci]B= not defined $max_expC= $max_exp < $exp1
ABCresult
0XX0
1000
11X1
1011
110 }
111 0 else {croak "some coordinate didn't look like a number: ",$vector->[$ci];}
112 }
113 }
114  
115 # Set scale for this coordinate column to the largest value that will convert the
116 # largest coordinate in the set to near the top of the available integer range.
117 # There's never any question of how much precision the user wants -
118 # we just always give as much as possible, within the integer limit in effect (53 bit or 64 bit)
119  
120 12 $scale_vector[$ci] = 1;
121 12 my $power = -$max_exp + ($intspecs{$opts{bits}}->{maxdigits} - 1);
122  
123 # We explicitly calculate the equivalent to 1**$power because
124 # the results of the system's pow() function underlying
125 # Perl's ** operator are sometimes inconsistent between
126 # BSD/clang and other systems.
127  
128 12 ▶ for (my $pi = 0; $pi < abs($power); $pi++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pi < abs $power) 170 12 182
129 170 ▶ if ($power > 0) { $scale_vector[$ci] *= 10; }
Branch: 2 branches
BranchTrueFalseTotal
if ($power > 0) { } 170 0 170
elsif ($power < 0) { } 0 0 0
130 0 elsif ($power < 0) { $scale_vector[$ci] /= 10; }
131 }
132  
133 12 ▶ if ($maxc * $scale_vector[$ci] > $intspecs{$opts{bits}}->{maxint}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($maxc * $scale_vector[$ci] > $intspecs{$opts{"bits"}}{"maxint"}) 0 12 12
134 # Both 53 bit and 64 bit integers
135 # have max values near 9*10**(16 or 19).
136 # So usually you have 16 or 19 digits to use.
137 # But if your scaled-up max values enter the
138 # zone just beyond the integer max, we'll only
139 # scale up to 15 or 18 digit integers instead.
140  
141 0 $scale_vector[$ci] /= 10;
142 }
143 }
144  
145 # If the "constrain" option is set false,
146 # scaling is independent for each
147 # coordinate column - all the Xs get one scale
148 # all the Ys something else - to take the greatest
149 # advantage of the available integer domain.
150 # But if the "constrain" option is set true, we use
151 # the minimum scale from all the coordinate columns.
152 # The minimum scale is the one that will work
153 # for all columns, without overflowing our integer limits.
154 5 ▶ if ($opts{constrain}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts{"constrain"}) 2 3 5
155 2 my $min_scale=(sort {$a<=>$b} @scale_vector)[0];
156 2 @scale_vector = map {$min_scale} @scale_vector;
157 }
158  
159 # Scale the original data
160 5 foreach my $set (@_) {
161 6 foreach my $vector (@{$set}) {
162 16 ▶ for (my $ci=0;$ci<$coord_count;$ci++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($ci < $coord_count) 39 16 55
163 39 $vector->[$ci] *= $scale_vector[$ci];
164 39 ▶ if (abs($vector->[$ci]) < 0.5) { $vector->[$ci] = 0; }
Branch: 2 branches
BranchTrueFalseTotal
if (abs $vector->[$ci] < 0.5) { } 7 32 39
elsif (abs $vector->[$ci] < 1) { } 2 30 32
165 2 ▶ elsif (abs($vector->[$ci]) < 1) { $vector->[$ci] = $vector->[$ci] < 0 ? -1:1; }
Branch: 1 branch
BranchTrueFalseTotal
$vector->[$ci] < 0 ? : 1 1 2
166 39 $vector->[$ci] = _floor($vector->[$ci]);
167 }
168 }
169 }
170  
171 5 return \@scale_vector;
172 }
173  
174 # keep this method as a no-op, as it was removed in Clipper 4.5.5
175 4 ▶sub use_full_coordinate_range {}
Subroutine use_full_coordinate_range: called CC=1 SCAR=0.0
Pod undocumented
176  
177 0 ▶sub CLONE_SKIP { 1 }
Subroutine CLONE_SKIP: not called CC=1 SCAR=6.9
178  
179 12 1;
180 __END__
↑ Summary src/poly2av.h »