1

"""

     2

    Raw tile handling.

     3

"""

     4

     5

from werkzeug import Request, Response, exceptions

     6

from werkzeug.utils import redirect

     7

import werkzeug.urls

     8

     9

import pngtile.application

    10

import pypngtile

    11

    12

## Coordinates

    13

# width of a tile

    14

TILE_SIZE = 256

    15

    16

# maximum zoom out

    17

MAX_ZOOM = 4

    18

    19

# max. output resolution to allow

    20

MAX_PIXELS = 1920 * 1200

    21

    22

def scale (val, zoom):

    23

    """

    24

        Scale dimension by zoom factor

    25

    26

        zl > 0 -> bigger

    27

        zl < 0 -> smaller

    28

    """

    29

    30

    if zoom > 0:

    31

        return val << zoom

    32

    33

    elif zoom < 0:

    34

        return val >> -zoom

    35

    36

    else:

    37

        return val

    38

    39

def scale_center (val, dim, zoom):

    40

    """

    41

        Scale value about center by zoom.

    42

    """

    43

    44

    return scale(val, zoom) - dim / 2

    45

    46

class TileApplication (pngtile.application.PNGTileApplication):

    47

    def __init__ (self, image_server, **opts):

    48

        """

    49

            image_server:       http://.../ url to image-server frontend

    50

        """

    51

    52

        super(TileApplication, self).__init__(**opts)

    53

    54

        self.image_server = image_server

    55

    56

    def image_url (self, name):

    57

        return werkzeug.urls.Href(self.image_server)(path)

    58

    59

    def render_region (self, request, image):

    60

        """

    61

            Handle request for an image region

    62

        """

    63

    64

        width = int(request.args['w'])

    65

        height = int(request.args['h'])

    66

        x = int(request.args['x'])

    67

        y = int(request.args['y'])

    68

        zoom = int(request.args.get('zoom', "0"))

    69

    70

        # safety limit

    71

        if width * height > MAX_PIXELS:

    72

            raise exceptions.BadRequest("Image size: %d * %d > %d" % (width, height, MAX_PIXELS))

    73

    74

        if zoom > MAX_ZOOM:

    75

            raise exceptions.BadRequest("Image zoom: %d > %d" % (zoom, MAX_ZOOM))

    76

    77

        x = scale_center(x, width, zoom)

    78

        y = scale_center(y, height, zoom)

    79

    80

        try:

    81

            return image.tile_mem(width, height, x, y, zoom)

    82

    83

        except pypngtile.Error as error:

    84

            raise exceptions.InternalServerError(str(error))

    85

    86

    def render_tile (self, request, image):

    87

        """

    88

            Handle request for image tile

    89

        """

    90

    91

        width = TILE_SIZE

    92

        height = TILE_SIZE

    93

        x = int(request.args['x'])

    94

        y = int(request.args['y'])

    95

        zoom = int(request.args.get('zoom', "0"))

    96

    97

        if zoom > MAX_ZOOM:

    98

            raise exceptions.BadRequest("Image zoom: %d > %d" % (zoom, MAX_ZOOM))

    99

   100

        x = scale(x * width, zoom)

   101

        y = scale(y * height, zoom)

   102

   103

        try:

   104

            return image.tile_mem(width, height, x, y, zoom)

   105

   106

        except pypngtile.Error as error:

   107

            raise exceptions.InternalServerError(str(error))

   108

   109

    def handle_dir (self, request, name, path):

   110

        """

   111

            Redirect to the image frontend for a non-tile request.

   112

        """

   113

   114

        if not name.endswith('/'):

   115

            # avoid an additional redirect

   116

            name += '/'

   117

   118

        return redirect(self.image_url(name))

   119

   120

    def handle_image (self, request, name, path):

   121

        """

   122

            Redirect to the image frontend for a non-tile request.

   123

        """

   124

   125

        return redirect(self.image_url(name))

   126

   127

    def handle (self, request):

   128

        """

   129

            Handle request for an image

   130

        """

   131

   132

        name, path, type = self.lookup(request.path)

   133

   134

        # determine handler

   135

        if not type:

   136

            return self.handle_dir(request, name, path)

   137

   138

        elif not request.args:

   139

            return self.handle_image(request, name, path)

   140

   141

        elif 'w' in request.args and 'h' in request.args and 'x' in request.args and 'y' in request.args:

   143

   144

        elif 'x' in request.args and 'y' in request.args:

   146

   147

        else:

   148

            raise exceptions.BadRequest("Unknown args")

   152