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

Last change on this file since 26424 was 26372, checked in by gary68, 8 years ago

new mapweaver version

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