Changeset 206

Timestamp:

03/26/07 17:37:35 (2 years ago)

Author:

migurski

Message:

Brought compose.py roughly up to speed with what MMaps AS2 can do

Files:

• trunk/py/compose.py (modified) (1 diff)
• trunk/py/ModestMaps/Core.py (added)
• trunk/py/ModestMaps/Geo.py (added)
• trunk/py/ModestMaps/Microsoft.py (added)
• trunk/py/ModestMaps/Providers.py (modified) (2 diffs)
• trunk/py/ModestMaps/__init__.py (modified) (1 diff)

trunk/py/compose.py

@@ -1 @@
-
-
+
-
-
-
+
+
+
+
+
+
+
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-parser = optparse.OptionParser()
+
+parser.add_option('-v', '--verbose', dest='verbose',
+                  help='Make a bunch of noise',
+                  action='store_true')
-
-parser.add_option('-o', '--out', dest='outfile',
-                  help='Write to output file')
-
-
-
+
+
+
-
-
-
+
+
+
-
-parser.add_option('-p', '--provider', dest='provider',
-
+
+
+
+
+
+
-
-(options, args) = parser.parse_args()
-
-if __name__ == '__main__':
+    if options.verbose:
+        print parser.coord, parser.point, '->', options.outfile, (parser.width, parser.height)
+    
+    corner = ModestMaps.Core.Point(int(parser.point.x + parser.width / 2), int(parser.point.y + parser.height / 2))
+    
+    while corner.x > 0:
+        corner.x -= ModestMaps.TILE_WIDTH
+        parser.coord = parser.coord.left()
+    
+    while corner.y > 0:
+        corner.y -= ModestMaps.TILE_HEIGHT
+        parser.coord = parser.coord.up()
+        
+    jobs = RequestQueue()
+    
+    rowCoord = parser.coord.copy()
+    for y in range(corner.y, parser.height, ModestMaps.TILE_HEIGHT):
+        tileCoord = rowCoord.copy()
+        for x in range(corner.x, parser.width, ModestMaps.TILE_WIDTH):
+            jobs.append(RequestJob(parser.provider, tileCoord, ModestMaps.Core.Point(x, y)))
+            tileCoord = tileCoord.right()
+        rowCoord = rowCoord.down()
+    
+    lock = thread.allocate_lock()
-
-
+
+
+
+
+
+
+
+
+
-    
-
-
-
-
-
-
+
+
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+

trunk/py/ModestMaps/Providers.py

@@ -1 @@
-
+
+
-
-ids = ('MICROSOFT_ROAD', 'MICROSOFT_AERIAL', 'MICROSOFT_HYBRID',
@@ -7 +8 @@
-       'OPEN_STREET_MAP')
-
-
-
-
+
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-
-    if self.id == 'MICROSOFT_HYBRID'
-    return 'http://h%d.ortho.tiles.virtualearth.net/tiles/h%s.jpeg?g=45' % (random.randint(0,3), Tiles.toMicrosoft(column, row, zoom)
+def coordinateLocation(self, location)
+return self.projection.coordinateLocation(location
-
-
-
-
-
-
+
+

trunk/py/ModestMaps/__init__.py

@@ +1 @@
+import math
+
-import Tiles
-import Providers
+import Core
+import Geo
+import Microsoft
+
+TILE_WIDTH = 256
+TILE_HEIGHT = 256
+
+def calculateMapCenter(centerCoord):
+    """ Based on a center coordinate, returns the coordinate
+        of an initial tile and it's point placement, relative to
+        the map center.
+    """
+
+    # initial tile coordinate
+    initTileCoord = Core.Coordinate(math.floor(centerCoord.row), math.floor(centerCoord.column), math.floor(centerCoord.zoom))
+
+    # initial tile position, assuming centered tile well in grid
+    initX = (initTileCoord.column - centerCoord.column) * TILE_WIDTH
+    initY = (initTileCoord.row - centerCoord.row) * TILE_HEIGHT
+    initPoint = Core.Point(round(initX), round(initY))
+    
+    return initTileCoord, initPoint
+
+def calculateMapExtent(provider, width, height, *args):
+
+    coordinates = map(provider.locationCoordinate, args)
+    
+    TL = Core.Coordinate(min([c.row for c in coordinates]),
+                         min([c.column for c in coordinates]),
+                         min([c.zoom for c in coordinates]))
+
+    BR = Core.Coordinate(max([c.row for c in coordinates]),
+                         max([c.column for c in coordinates]),
+                         max([c.zoom for c in coordinates]))
+                    
+    # multiplication factor between horizontal span and map width
+    hFactor = (BR.column - TL.column) / (width / TILE_WIDTH)
+
+    # multiplication factor expressed as base-2 logarithm, for zoom difference
+    hZoomDiff = math.log(hFactor) / math.log(2)
+        
+    # possible horizontal zoom to fit geographical extent in map width
+    hPossibleZoom = TL.zoom - math.ceil(hZoomDiff)
+        
+    # multiplication factor between vertical span and map height
+    vFactor = (BR.row - TL.row) / (height / TILE_HEIGHT)
+        
+    # multiplication factor expressed as base-2 logarithm, for zoom difference
+    vZoomDiff = math.log(vFactor) / math.log(2)
+        
+    # possible vertical zoom to fit geographical extent in map height
+    vPossibleZoom = TL.zoom - math.ceil(vZoomDiff)
+        
+    # initial zoom to fit extent vertically and horizontally
+    initZoom = min(hPossibleZoom, vPossibleZoom)
+
+    ## additionally, make sure it's not outside the boundaries set by provider limits
+    #initZoom = min(initZoom, provider.outerLimits()[1].zoom)
+    #initZoom = max(initZoom, provider.outerLimits()[0].zoom)
+
+    # coordinate of extent center
+    centerRow = (TL.row + BR.row) / 2
+    centerColumn = (TL.column + BR.column) / 2
+    centerZoom = (TL.zoom + BR.zoom) / 2
+    centerCoord = Core.Coordinate(centerRow, centerColumn, centerZoom).zoomTo(initZoom)
+    
+    return calculateMapCenter(centerCoord)