source: subversion/applications/utils/gary68/mwMulti.pm @ 28794

Last change on this file since 28794 was 28794, checked in by gary68, 7 years ago

mapweaver bug fix area labels

File size: 12.9 KB
Line 
1#
2# PERL mapweaver module by gary68
3#
4#
5#
6#
7# Copyright (C) 2011, Gerhard Schwanz
8#
9# This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the
10# Free Software Foundation; either version 3 of the License, or (at your option) any later version.
11#
12# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14#
15# You should have received a copy of the GNU General Public License along with this program; if not, see <http://www.gnu.org/licenses/>
16#
17
18
19package mwMulti ; 
20
21use strict ;
22use warnings ;
23
24use mwMap ;
25use mwMisc ;
26use mwFile ;
27use mwLabel ;
28use mwConfig ;
29use mwRules ;
30
31use Math::Polygon ;
32
33
34
35use vars qw($VERSION @ISA @EXPORT @EXPORT_OK);
36
37require Exporter ;
38
39@ISA = qw ( Exporter AutoLoader ) ;
40
41@EXPORT = qw (  processMultipolygons
42
43                 ) ;
44
45my $newId = 0 ;
46
47my %multiNodes = () ;
48my %multiTags = () ;
49my %multiPaths = () ;
50
51my %wayUsed = () ;
52
53# -------------------------------------------------------------------------
54
55sub processMultipolygons {
56        my $notDrawnMP = 0 ;
57        my $mp = 0 ;
58        my $mpLabels = 0 ;
59        my $mpNotDrawnLabels = 0 ;
60        print "draw multipolygons...\n" ;
61
62        preprocessMultipolygons() ;
63
64        foreach my $multiId (keys %multiTags) {
65
66                my $ruleRef = getAreaRule ( \@{$multiTags{$multiId}} ) ;
67
68                if (defined $ruleRef) {
69
70                        my $svgText = "" ;
71                        my $icon = "" ;
72                        if ($$ruleRef{'icon'} ne "none") {
73                                $icon = $$ruleRef{'icon'} ;
74                        }
75                        else {
76                                my $col = $$ruleRef{'color'} ;
77                                $svgText = "fill=\"$col\" " ;
78                        }
79
80                        my $ref = $multiPaths{$multiId}[0] ; # first, outer way
81                        my $size = areaSize ( $ref ) ;
82
83                        if ($size >= cv('minareasize') ) {
84                                drawArea ($svgText, $icon, $multiPaths{$multiId}, 1, "multi") ;
85                                $mp++ ;
86
87
88                                # LABELS
89                                my $name = "" ; my $ref1 ;
90                                ($name, $ref1) = createLabel ( $multiTags{$multiId}, $$ruleRef{'label'}, 0, 0) ;
91
92                                if ( ( $$ruleRef{'label'} ne "none") and 
93                                        ( cv('nolabel') eq "1" ) and 
94                                        ($name eq "") ) 
95                                { 
96                                        $name = "NO LABEL" ; 
97                                }
98
99                                if ($name ne "") {
100                                        if ($size >= cv('minarealabelsize') ) {
101                                                $mpLabels++ ;
102                                                if (cv('debug') eq "1") { print "MP LABEL: $name, size: $$ruleRef{'labelsize'}, color: $$ruleRef{'labelcolor'}\n" ; }
103
104                                                my ($x, $y) = areaCenter ( $multiPaths{$multiId}[0] ) ;
105
106
107                                                my $labelFont = $$ruleRef{'labelfont'} ;
108                                                my $labelFontFamily = $$ruleRef{'labelfontfamily'} ;
109                                                my $labelSize = $$ruleRef{'labelsize'} ;
110                                                my $color = $$ruleRef{'labelcolor'} ;
111                                                my $labelBold = $$ruleRef{'labelbold'} ;
112                                                my $labelItalic = $$ruleRef{'labelitalic'} ;
113                                                my $labelHalo = $$ruleRef{'labelhalo'} ;
114                                                my $labelHaloColor = $$ruleRef{'labelhalocolor'} ;
115
116                                                my $svgText = createTextSVG ( $labelFontFamily, $labelFont, $labelBold, $labelItalic, $labelSize, $color, $labelHalo, $labelHaloColor) ; 
117
118
119
120
121
122
123                                                # $svgText = createTextSVG ( undef, undef, $$ruleRef{'labelsize'}, $$ruleRef{'labelcolor'}, undef, undef ) ;
124                                                if (cv('debug') eq "1") { print "MP LABEL: svg: \"$svgText\"\n" ; }
125                                                placeLabelAndIcon ($x, $y, 1, 0, $name, $svgText, "none", 0, 0, "arealabels") ;
126                                        } # if size
127                                        else {
128                                                $mpNotDrawnLabels++ ;
129                                        }
130                                }
131                                else {
132
133                                }
134                        }
135                        else {
136                                $notDrawnMP++ ;
137                        }
138
139                } # if rule
140        } # foreach multi
141        print "$mp multipolygon areas drawn, $notDrawnMP not drawn because they were too small.\n" ;
142        print "$mpLabels multipolygon labels drawn, $mpNotDrawnLabels not drawn because belonging areas were too small.\n" ;
143}
144
145# ------------------------------------------------------------------------------------------
146
147sub preprocessMultipolygons {
148#
149# preprecess all multipolygons
150#
151
152        my ($wayNodesRef, $wayTagsRef) = getWayPointers() ;
153        my ($relationMembersRef, $relationTagsRef) = getRelationPointers() ;
154
155        foreach my $relId (keys %$relationMembersRef) {
156                my $isMulti = 0 ;
157                foreach my $tag (@{$$relationTagsRef{$relId}}) {
158                        if ( ($tag->[0] eq "type") and ($tag->[1] eq "multipolygon") ) { $isMulti = 1 ; }
159                }
160
161                if ($isMulti) {
162                        if (cv('debug') eq "1") { print "\n---------------------------------------------------\n" ; }
163                        if (cv('debug') eq "1") { print "\nRelation $relId is multipolygon!\n" ; }
164                       
165                        # get inner and outer ways
166                        my (@innerWays) = () ; my (@outerWays) = () ;
167                        foreach my $member ( @{$$relationMembersRef{$relId}} ) {
168                                if ( ($member->[0] eq "way") and ($member->[2] eq "outer") and (defined @{$$wayNodesRef{$member->[1]}} ) ) { push @outerWays, $member->[1] ; }
169                                if ( ($member->[0] eq "way") and ($member->[2] eq "inner") and (defined @{$$wayNodesRef{$member->[1]}} )) { push @innerWays, $member->[1] ; }
170                        }
171                        if (cv('debug') eq "1") { print "OUTER WAYS: @outerWays\n" ; }
172                        if (cv('debug') eq "1") { print "INNER WAYS: @innerWays\n" ; }
173
174                        my ($ringsWaysRef, $ringsNodesRef) ;
175                        my @ringWaysInner = () ; my @ringNodesInner = () ; my @ringTagsInner = () ;
176                        # build rings inner
177                        if (scalar @innerWays > 0) {
178                                ($ringsWaysRef, $ringsNodesRef) = buildRings (\@innerWays, 1) ;
179                                @ringWaysInner = @$ringsWaysRef ; 
180                                @ringNodesInner = @$ringsNodesRef ;
181                                for (my $ring=0; $ring<=$#ringWaysInner; $ring++) {
182                                        if (cv('debug') eq "1") { print "INNER RING $ring: @{$ringWaysInner[$ring]}\n" ; }
183                                        my $firstWay = $ringWaysInner[$ring]->[0] ;
184                                        if (scalar @{$ringWaysInner[$ring]} == 1) {$wayUsed{$firstWay} = 1 ; } # way will be marked as used/drawn by multipolygon
185
186                                        @{$ringTagsInner[$ring]} = @{$$wayTagsRef{$firstWay}} ; # ring will be tagged like first contained way
187                                        if (cv('debug') eq "1") {
188                                                print "tags from first way...\n" ;
189                                                foreach my $tag (@{$$wayTagsRef{$firstWay}}) {
190                                                        print "  $tag->[0] - $tag->[1]\n" ;
191                                                }
192                                        }
193                                        if ( (scalar @{$$wayTagsRef{$firstWay}}) == 0 ) {
194                                                if (cv('debug') eq "1") { print "tags set to hole in mp.\n" ; }
195                                                push @{$ringTagsInner[$ring]}, ["multihole", "yes"] ;
196                                        }
197                                }
198                        }
199
200                        # build rings outer
201                        my @ringWaysOuter = () ; my @ringNodesOuter = () ; my @ringTagsOuter = () ;
202                        if (scalar @outerWays > 0) {
203                                ($ringsWaysRef, $ringsNodesRef) = buildRings (\@outerWays, 1) ;
204                                @ringWaysOuter = @$ringsWaysRef ; # not necessary for outer
205                                @ringNodesOuter = @$ringsNodesRef ;
206                                for (my $ring=0; $ring<=$#ringWaysOuter; $ring++) {
207                                        if (cv('debug') eq "1") { print "OUTER RING $ring: @{$ringWaysOuter[$ring]}\n" ; }
208                                        my $firstWay = $ringWaysOuter[$ring]->[0] ;
209                                        if (scalar @{$ringWaysOuter[$ring]} == 1) {$wayUsed{$firstWay} = 1 ; }
210                                        @{$ringTagsOuter[$ring]} = @{$$relationTagsRef{$relId}} ; # tags from relation
211                                        if (cv('debug') eq "1") {
212                                                print "tags from relation...\n" ;
213                                                foreach my $tag (@{$$relationTagsRef{$relId}}) {
214                                                        print "  $tag->[0] - $tag->[1]\n" ;
215                                                }
216                                        }
217                                        if (scalar @{$$relationTagsRef{$relId}} == 1) {
218                                                @{$ringTagsOuter[$ring]} = @{$$wayTagsRef{$firstWay}} ; # ring will be tagged like first way
219                                        }
220                                }
221                        } # outer
222                       
223                        my @ringNodesTotal = (@ringNodesInner, @ringNodesOuter) ;
224                        my @ringWaysTotal = (@ringWaysInner, @ringWaysOuter) ;
225                        my @ringTagsTotal = (@ringTagsInner, @ringTagsOuter) ;
226
227                        processRings (\@ringNodesTotal, \@ringWaysTotal, \@ringTagsTotal) ;
228                } # multi
229
230        } # relIds
231}
232
233# -----------------------------------------------------------------------------------------
234
235sub processRings {
236#
237# process rings of multipolygons and create path data for svg
238#
239        my ($ref1, $ref2, $ref3) = @_ ;
240        my @ringNodes = @$ref1 ;
241        my @ringWays = @$ref2 ;
242        my @ringTags = @$ref3 ;
243        my @polygon = () ;
244        my @polygonSize = () ;
245        my @ringIsIn = () ;
246        my @stack = () ; # all created stacks
247        my %selectedStacks = () ; # stacks selected for processing
248        my $actualLayer = 0 ; # for new tags
249        # rings referenced by array index
250
251        my ($lonRef, $latRef) = getNodePointers() ;
252        my ($wayNodesRef, $wayTagsRef) = getWayPointers() ;
253
254        # create polygons
255        if (cv('debug') eq "1") { print "CREATING POLYGONS\n" ; }
256        for (my $ring = 0 ; $ring <= $#ringWays; $ring++) {
257                my @poly = () ;
258                foreach my $node ( @{$ringNodes[$ring]} ) {
259                        push @poly, [$$lonRef{$node}, $$latRef{$node}] ;
260                }
261                my ($p) = Math::Polygon->new(@poly) ;
262                $polygon[$ring] = $p ;
263                $polygonSize[$ring] = $p->area ;
264                if (cv('debug') eq "1") { 
265                        print "  POLYGON $ring - created, size = $polygonSize[$ring] \n" ; 
266                        foreach my $tag (@{$ringTags[$ring]}) {
267                                print "    $tag->[0] - $tag->[1]\n" ;
268                        }
269                }
270        }
271
272
273        # create is_in list (unsorted) for each ring
274        if (cv('debug') eq "1") { print "CALC isIn\n" ; }
275        for (my $ring1=0 ; $ring1<=$#polygon; $ring1++) {
276                my $res = 0 ;
277                for (my $ring2=0 ; $ring2<=$#polygon; $ring2++) {
278                        if ($ring1 < $ring2) {
279                                $res = isIn ($polygon[$ring1], $polygon[$ring2]) ;
280                                if ($res == 1) { 
281                                        push @{$ringIsIn[$ring1]}, $ring2 ; 
282                                        if (cv('debug') eq "1") { print "  $ring1 isIn $ring2\n" ; }
283                                } 
284                                if ($res == 2) { 
285                                        push @{$ringIsIn[$ring2]}, $ring1 ; 
286                                        if (cv('debug') eq "1") { print "  $ring2 isIn $ring1\n" ; }
287                                } 
288                        }
289                }
290        }
291        if (cv('debug') eq "1") {
292                print "IS IN LIST\n" ;
293                for (my $ring1=0 ; $ring1<=$#ringNodes; $ring1++) {
294                        if (defined @{$ringIsIn[$ring1]}) {
295                                print "  ring $ring1 isIn - @{$ringIsIn[$ring1]}\n" ;
296                        }
297                }
298                print "\n" ;
299        }
300
301        # sort is_in list, biggest first
302        if (cv('debug') eq "1") { print "SORTING isIn\n" ; }
303        for (my $ring=0 ; $ring<=$#ringIsIn; $ring++) {
304                my @isIn = () ;
305                foreach my $ring2 (@{$ringIsIn[$ring]}) {
306                        push @isIn, [$ring2, $polygonSize[$ring2]] ;
307                }
308                @isIn = sort { $a->[1] <=> $b->[1] } (@isIn) ; # sorted array
309
310                my @isIn2 = () ; # only ring numbers
311                foreach my $temp (@isIn) {
312                        push @isIn2, $temp->[0] ;
313                }
314                @{$stack[$ring]} = reverse (@isIn2) ; 
315                push @{$stack[$ring]}, $ring ; # sorted descending and ring self appended
316                if (cv('debug') eq "1") { print "  stack ring $ring sorted: @{$stack[$ring]}\n" ; }
317        }
318
319        # find tops and select stacks
320        if (cv('debug') eq "1") { print "SELECTING STACKS\n" ; }
321        my $actualStack = 0 ;
322        for (my $stackNumber=0 ; $stackNumber<=$#stack; $stackNumber++) {
323                # look for top element
324                my $topElement = $stack[$stackNumber]->[(scalar @{$stack[$stackNumber]} - 1)] ;
325                my $found = 0 ;
326                for (my $stackNumber2=0 ; $stackNumber2<=$#stack; $stackNumber2++) {
327                        if ($stackNumber != $stackNumber2) {
328                                foreach my $ring (@{$stack[$stackNumber2]}) {
329                                        if ($ring == $topElement) { 
330                                                $found = 1 ;
331                                                if (cv('debug') eq "1") { print "      element also found in stack $stackNumber2\n" ; }
332                                        }
333                                }
334                        }
335                }
336
337                if ($found == 0) {
338                        @{$selectedStacks{$actualStack}} = @{$stack[$stackNumber]} ;
339                        $actualStack++ ;
340                        if (cv('debug') eq "1") { print "    stack $stackNumber has been selected.\n" ; }
341                }
342       
343        }
344       
345        # process selected stacks
346
347        if (cv('debug') eq "1") { print "PROCESS SELECTED STACKS\n" ; }
348        # while stacks left
349        while (scalar (keys %selectedStacks) > 0) {
350                my (@k) = keys %selectedStacks ;
351                if (cv('debug') eq "1") { print "  stacks available: @k\n" ; }
352                my @nodes = () ;
353                my @nodesOld ;
354                my @processedStacks = () ;
355
356                # select one bottom element
357                my $key = $k[0] ; # key of first stack
358                if (cv('debug') eq "1") { print "  stack nr $key selected\n" ; }
359                my $ringToDraw = $selectedStacks{$key}[0] ;
360                if (cv('debug') eq "1") { print "  ring to draw: $ringToDraw\n" ; }
361
362                push @nodesOld, @{$ringNodes[$ringToDraw]} ; # outer polygon
363                push @nodes, [@{$ringNodes[$ringToDraw]}] ; # outer polygon as array
364
365                # and remove ring from stacks; store processed stacks
366                foreach my $k2 (keys %selectedStacks) {
367                        if ($selectedStacks{$k2}[0] == $ringToDraw) { 
368                                shift (@{$selectedStacks{$k2}}) ; 
369                                push @processedStacks, $k2 ;
370                                if (scalar @{$selectedStacks{$k2}} == 0) { delete $selectedStacks{$k2} ; }
371                                if (cv('debug') eq "1") { print "  removed $ringToDraw from stack $k2\n" ; }
372                        } 
373                }
374
375                # foreach stack in processed stacks
376                foreach my $k (@processedStacks) {
377                        # if now bottom of a stack is hole, then add this polygon to points
378                        if (defined $selectedStacks{$k}) {
379                                my $tempRing = $selectedStacks{$k}[0] ;
380                                my $temp = $ringTags[$tempRing]->[0]->[0] ;
381                                if (cv('debug') eq "1") { print "           testing for hole: stack $k, ring $tempRing, tag $temp\n" ; }
382                                if ($ringTags[$tempRing]->[0]->[0] eq "multihole") {
383                                        push @nodesOld, @{$ringNodes[$tempRing]} ;
384                                        push @nodes, [@{$ringNodes[$tempRing]}] ;
385                                        # print "      nodes so far: @nodes\n" ;
386                                        # and remove this element from stack
387                                        shift @{$selectedStacks{$k}} ;
388                                        if (scalar @{$selectedStacks{$k}} == 0) { delete $selectedStacks{$k} ; }
389                                        if (cv('debug') eq "1") { print "  ring $tempRing identified as hole\n" ; }
390                                }
391                        }
392                }
393
394                # add way
395
396                @{$multiNodes{$newId}} = @nodesOld ;
397                @{$multiTags{$newId}} = @{$ringTags[$ringToDraw]} ;
398                @{$multiPaths{$newId}} = @nodes ;
399
400                push @{$$wayTagsRef{$newId}}, ["layer", $actualLayer] ;
401                $actualLayer++ ;
402
403                if (cv('debug') eq "1") { 
404                        print "  DRAWN: $ringToDraw, wayId $newId\n" ; 
405                        foreach my $tag (@{$ringTags[$ringToDraw]}) {
406                                print "    k/v $tag->[0] - $tag->[1]\n" ;
407                        }
408                }
409
410                $newId++ ;
411
412        } # (while)
413}
414
415
4161 ;
417
418
Note: See TracBrowser for help on using the repository browser.