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

Last change on this file since 26507 was 26467, checked in by gary68, 8 years ago

mapweaver: wnsunique

File size: 12.2 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                                                # print "MP LABEL: $name\n" ;
103                                                my ($x, $y) = areaCenter ( $multiPaths{$multiId}[0] ) ;
104                                                $svgText = createTextSVG ( undef, undef, $$ruleRef{'labelsize'}, $$ruleRef{'labelcolor'}, undef, undef ) ;
105                                                placeLabelAndIcon ($x, $y, 1, 0, $name, $svgText, "none", 0, 0, "arealabels") ;
106                                        } # if size
107                                        else {
108                                                $mpNotDrawnLabels++ ;
109                                        }
110                                }
111                                else {
112
113                                }
114                        }
115                        else {
116                                $notDrawnMP++ ;
117                        }
118
119                } # if rule
120        } # foreach multi
121        print "$mp multipolygon areas drawn, $notDrawnMP not drawn because they were too small.\n" ;
122        print "$mpLabels multipolygon labels drawn, $mpNotDrawnLabels not drawn because belonging areas were too small.\n" ;
123}
124
125# ------------------------------------------------------------------------------------------
126
127sub preprocessMultipolygons {
128#
129# preprecess all multipolygons
130#
131
132        my ($wayNodesRef, $wayTagsRef) = getWayPointers() ;
133        my ($relationMembersRef, $relationTagsRef) = getRelationPointers() ;
134
135        foreach my $relId (keys %$relationMembersRef) {
136                my $isMulti = 0 ;
137                foreach my $tag (@{$$relationTagsRef{$relId}}) {
138                        if ( ($tag->[0] eq "type") and ($tag->[1] eq "multipolygon") ) { $isMulti = 1 ; }
139                }
140
141                if ($isMulti) {
142                        if (cv('debug') eq "1") { print "\n---------------------------------------------------\n" ; }
143                        if (cv('debug') eq "1") { print "\nRelation $relId is multipolygon!\n" ; }
144                       
145                        # get inner and outer ways
146                        my (@innerWays) = () ; my (@outerWays) = () ;
147                        foreach my $member ( @{$$relationMembersRef{$relId}} ) {
148                                if ( ($member->[0] eq "way") and ($member->[2] eq "outer") and (defined @{$$wayNodesRef{$member->[1]}} ) ) { push @outerWays, $member->[1] ; }
149                                if ( ($member->[0] eq "way") and ($member->[2] eq "inner") and (defined @{$$wayNodesRef{$member->[1]}} )) { push @innerWays, $member->[1] ; }
150                        }
151                        if (cv('debug') eq "1") { print "OUTER WAYS: @outerWays\n" ; }
152                        if (cv('debug') eq "1") { print "INNER WAYS: @innerWays\n" ; }
153
154                        my ($ringsWaysRef, $ringsNodesRef) ;
155                        my @ringWaysInner = () ; my @ringNodesInner = () ; my @ringTagsInner = () ;
156                        # build rings inner
157                        if (scalar @innerWays > 0) {
158                                ($ringsWaysRef, $ringsNodesRef) = buildRings (\@innerWays, 1) ;
159                                @ringWaysInner = @$ringsWaysRef ; 
160                                @ringNodesInner = @$ringsNodesRef ;
161                                for (my $ring=0; $ring<=$#ringWaysInner; $ring++) {
162                                        if (cv('debug') eq "1") { print "INNER RING $ring: @{$ringWaysInner[$ring]}\n" ; }
163                                        my $firstWay = $ringWaysInner[$ring]->[0] ;
164                                        if (scalar @{$ringWaysInner[$ring]} == 1) {$wayUsed{$firstWay} = 1 ; } # way will be marked as used/drawn by multipolygon
165
166                                        @{$ringTagsInner[$ring]} = @{$$wayTagsRef{$firstWay}} ; # ring will be tagged like first contained way
167                                        if (cv('debug') eq "1") {
168                                                print "tags from first way...\n" ;
169                                                foreach my $tag (@{$$wayTagsRef{$firstWay}}) {
170                                                        print "  $tag->[0] - $tag->[1]\n" ;
171                                                }
172                                        }
173                                        if ( (scalar @{$$wayTagsRef{$firstWay}}) == 0 ) {
174                                                if (cv('debug') eq "1") { print "tags set to hole in mp.\n" ; }
175                                                push @{$ringTagsInner[$ring]}, ["multihole", "yes"] ;
176                                        }
177                                }
178                        }
179
180                        # build rings outer
181                        my @ringWaysOuter = () ; my @ringNodesOuter = () ; my @ringTagsOuter = () ;
182                        if (scalar @outerWays > 0) {
183                                ($ringsWaysRef, $ringsNodesRef) = buildRings (\@outerWays, 1) ;
184                                @ringWaysOuter = @$ringsWaysRef ; # not necessary for outer
185                                @ringNodesOuter = @$ringsNodesRef ;
186                                for (my $ring=0; $ring<=$#ringWaysOuter; $ring++) {
187                                        if (cv('debug') eq "1") { print "OUTER RING $ring: @{$ringWaysOuter[$ring]}\n" ; }
188                                        my $firstWay = $ringWaysOuter[$ring]->[0] ;
189                                        if (scalar @{$ringWaysOuter[$ring]} == 1) {$wayUsed{$firstWay} = 1 ; }
190                                        @{$ringTagsOuter[$ring]} = @{$$relationTagsRef{$relId}} ; # tags from relation
191                                        if (cv('debug') eq "1") {
192                                                print "tags from relation...\n" ;
193                                                foreach my $tag (@{$$relationTagsRef{$relId}}) {
194                                                        print "  $tag->[0] - $tag->[1]\n" ;
195                                                }
196                                        }
197                                        if (scalar @{$$relationTagsRef{$relId}} == 1) {
198                                                @{$ringTagsOuter[$ring]} = @{$$wayTagsRef{$firstWay}} ; # ring will be tagged like first way
199                                        }
200                                }
201                        } # outer
202                       
203                        my @ringNodesTotal = (@ringNodesInner, @ringNodesOuter) ;
204                        my @ringWaysTotal = (@ringWaysInner, @ringWaysOuter) ;
205                        my @ringTagsTotal = (@ringTagsInner, @ringTagsOuter) ;
206
207                        processRings (\@ringNodesTotal, \@ringWaysTotal, \@ringTagsTotal) ;
208                } # multi
209
210        } # relIds
211}
212
213# -----------------------------------------------------------------------------------------
214
215sub processRings {
216#
217# process rings of multipolygons and create path data for svg
218#
219        my ($ref1, $ref2, $ref3) = @_ ;
220        my @ringNodes = @$ref1 ;
221        my @ringWays = @$ref2 ;
222        my @ringTags = @$ref3 ;
223        my @polygon = () ;
224        my @polygonSize = () ;
225        my @ringIsIn = () ;
226        my @stack = () ; # all created stacks
227        my %selectedStacks = () ; # stacks selected for processing
228        my $actualLayer = 0 ; # for new tags
229        # rings referenced by array index
230
231        my ($lonRef, $latRef) = getNodePointers() ;
232        my ($wayNodesRef, $wayTagsRef) = getWayPointers() ;
233
234        # create polygons
235        if (cv('debug') eq "1") { print "CREATING POLYGONS\n" ; }
236        for (my $ring = 0 ; $ring <= $#ringWays; $ring++) {
237                my @poly = () ;
238                foreach my $node ( @{$ringNodes[$ring]} ) {
239                        push @poly, [$$lonRef{$node}, $$latRef{$node}] ;
240                }
241                my ($p) = Math::Polygon->new(@poly) ;
242                $polygon[$ring] = $p ;
243                $polygonSize[$ring] = $p->area ;
244                if (cv('debug') eq "1") { 
245                        print "  POLYGON $ring - created, size = $polygonSize[$ring] \n" ; 
246                        foreach my $tag (@{$ringTags[$ring]}) {
247                                print "    $tag->[0] - $tag->[1]\n" ;
248                        }
249                }
250        }
251
252
253        # create is_in list (unsorted) for each ring
254        if (cv('debug') eq "1") { print "CALC isIn\n" ; }
255        for (my $ring1=0 ; $ring1<=$#polygon; $ring1++) {
256                my $res = 0 ;
257                for (my $ring2=0 ; $ring2<=$#polygon; $ring2++) {
258                        if ($ring1 < $ring2) {
259                                $res = isIn ($polygon[$ring1], $polygon[$ring2]) ;
260                                if ($res == 1) { 
261                                        push @{$ringIsIn[$ring1]}, $ring2 ; 
262                                        if (cv('debug') eq "1") { print "  $ring1 isIn $ring2\n" ; }
263                                } 
264                                if ($res == 2) { 
265                                        push @{$ringIsIn[$ring2]}, $ring1 ; 
266                                        if (cv('debug') eq "1") { print "  $ring2 isIn $ring1\n" ; }
267                                } 
268                        }
269                }
270        }
271        if (cv('debug') eq "1") {
272                print "IS IN LIST\n" ;
273                for (my $ring1=0 ; $ring1<=$#ringNodes; $ring1++) {
274                        if (defined @{$ringIsIn[$ring1]}) {
275                                print "  ring $ring1 isIn - @{$ringIsIn[$ring1]}\n" ;
276                        }
277                }
278                print "\n" ;
279        }
280
281        # sort is_in list, biggest first
282        if (cv('debug') eq "1") { print "SORTING isIn\n" ; }
283        for (my $ring=0 ; $ring<=$#ringIsIn; $ring++) {
284                my @isIn = () ;
285                foreach my $ring2 (@{$ringIsIn[$ring]}) {
286                        push @isIn, [$ring2, $polygonSize[$ring2]] ;
287                }
288                @isIn = sort { $a->[1] <=> $b->[1] } (@isIn) ; # sorted array
289
290                my @isIn2 = () ; # only ring numbers
291                foreach my $temp (@isIn) {
292                        push @isIn2, $temp->[0] ;
293                }
294                @{$stack[$ring]} = reverse (@isIn2) ; 
295                push @{$stack[$ring]}, $ring ; # sorted descending and ring self appended
296                if (cv('debug') eq "1") { print "  stack ring $ring sorted: @{$stack[$ring]}\n" ; }
297        }
298
299        # find tops and select stacks
300        if (cv('debug') eq "1") { print "SELECTING STACKS\n" ; }
301        my $actualStack = 0 ;
302        for (my $stackNumber=0 ; $stackNumber<=$#stack; $stackNumber++) {
303                # look for top element
304                my $topElement = $stack[$stackNumber]->[(scalar @{$stack[$stackNumber]} - 1)] ;
305                my $found = 0 ;
306                for (my $stackNumber2=0 ; $stackNumber2<=$#stack; $stackNumber2++) {
307                        if ($stackNumber != $stackNumber2) {
308                                foreach my $ring (@{$stack[$stackNumber2]}) {
309                                        if ($ring == $topElement) { 
310                                                $found = 1 ;
311                                                if (cv('debug') eq "1") { print "      element also found in stack $stackNumber2\n" ; }
312                                        }
313                                }
314                        }
315                }
316
317                if ($found == 0) {
318                        @{$selectedStacks{$actualStack}} = @{$stack[$stackNumber]} ;
319                        $actualStack++ ;
320                        if (cv('debug') eq "1") { print "    stack $stackNumber has been selected.\n" ; }
321                }
322       
323        }
324       
325        # process selected stacks
326
327        if (cv('debug') eq "1") { print "PROCESS SELECTED STACKS\n" ; }
328        # while stacks left
329        while (scalar (keys %selectedStacks) > 0) {
330                my (@k) = keys %selectedStacks ;
331                if (cv('debug') eq "1") { print "  stacks available: @k\n" ; }
332                my @nodes = () ;
333                my @nodesOld ;
334                my @processedStacks = () ;
335
336                # select one bottom element
337                my $key = $k[0] ; # key of first stack
338                if (cv('debug') eq "1") { print "  stack nr $key selected\n" ; }
339                my $ringToDraw = $selectedStacks{$key}[0] ;
340                if (cv('debug') eq "1") { print "  ring to draw: $ringToDraw\n" ; }
341
342                push @nodesOld, @{$ringNodes[$ringToDraw]} ; # outer polygon
343                push @nodes, [@{$ringNodes[$ringToDraw]}] ; # outer polygon as array
344
345                # and remove ring from stacks; store processed stacks
346                foreach my $k2 (keys %selectedStacks) {
347                        if ($selectedStacks{$k2}[0] == $ringToDraw) { 
348                                shift (@{$selectedStacks{$k2}}) ; 
349                                push @processedStacks, $k2 ;
350                                if (scalar @{$selectedStacks{$k2}} == 0) { delete $selectedStacks{$k2} ; }
351                                if (cv('debug') eq "1") { print "  removed $ringToDraw from stack $k2\n" ; }
352                        } 
353                }
354
355                # foreach stack in processed stacks
356                foreach my $k (@processedStacks) {
357                        # if now bottom of a stack is hole, then add this polygon to points
358                        if (defined $selectedStacks{$k}) {
359                                my $tempRing = $selectedStacks{$k}[0] ;
360                                my $temp = $ringTags[$tempRing]->[0]->[0] ;
361                                if (cv('debug') eq "1") { print "           testing for hole: stack $k, ring $tempRing, tag $temp\n" ; }
362                                if ($ringTags[$tempRing]->[0]->[0] eq "multihole") {
363                                        push @nodesOld, @{$ringNodes[$tempRing]} ;
364                                        push @nodes, [@{$ringNodes[$tempRing]}] ;
365                                        # print "      nodes so far: @nodes\n" ;
366                                        # and remove this element from stack
367                                        shift @{$selectedStacks{$k}} ;
368                                        if (scalar @{$selectedStacks{$k}} == 0) { delete $selectedStacks{$k} ; }
369                                        if (cv('debug') eq "1") { print "  ring $tempRing identified as hole\n" ; }
370                                }
371                        }
372                }
373
374                # add way
375
376                @{$multiNodes{$newId}} = @nodesOld ;
377                @{$multiTags{$newId}} = @{$ringTags[$ringToDraw]} ;
378                @{$multiPaths{$newId}} = @nodes ;
379
380                push @{$$wayTagsRef{$newId}}, ["layer", $actualLayer] ;
381                $actualLayer++ ;
382
383                if (cv('debug') eq "1") { 
384                        print "  DRAWN: $ringToDraw, wayId $newId\n" ; 
385                        foreach my $tag (@{$ringTags[$ringToDraw]}) {
386                                print "    k/v $tag->[0] - $tag->[1]\n" ;
387                        }
388                }
389
390                $newId++ ;
391
392        } # (while)
393}
394
395
3961 ;
397
398
Note: See TracBrowser for help on using the repository browser.