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

    14

## Coordinates

    15

# width of a tile

    16

TILE_SIZE = 256

    17

    18

# maximum zoom out

    19

MAX_ZOOM = 4

    20

    21

# max. output resolution to allow

    22

MAX_PIXELS = 1920 * 1200

    23

    24

def scale (val, zoom):

    25

    """

    26

        Scale dimension by zoom factor

    27

    28

        zl > 0 -> bigger

    29

        zl < 0 -> smaller

    30

    """

    31

    32

    if zoom > 0:

    33

        return val << zoom

    34

    35

    elif zoom < 0:

    36

        return val >> -zoom

    37

    38

    else:

    39

        return val

    40

    41

def scale_center (val, dim, zoom):

    42

    """

    43

        Scale value about center by zoom.

    44

    """

    45

    46

    return scale(val, zoom) - dim / 2

    47

    48

class TileApplication (pngtile.application.PNGTileApplication):

    52

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

    53

        """

    54

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

    55

        """

    56

    57

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

    58

    59

        self.image_server = image_server

    60

    61

    def image_url (self, name):

    62

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

    63

    64

    def render_region (self, request, image):

    65

        """

    66

            Handle request for an image region

    67

        """

    68

    69

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

    70

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

    71

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

    72

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

    73

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

    74

    75

        # safety limit

    76

        if width * height > MAX_PIXELS:

    77

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

    78

    79

        if zoom > MAX_ZOOM:

    80

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

    81

    82

        x = scale_center(x, width, zoom)

    83

        y = scale_center(y, height, zoom)

    84

    85

        try:

    86

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

    87

    88

        except pypngtile.Error as error:

    89

            raise exceptions.InternalServerError(str(error))

    90

    91

    def render_tile (self, request, image):

    92

        """

    93

            Handle request for image tile

    94

        """

    95

    96

        width = TILE_SIZE

    97

        height = TILE_SIZE

    98

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

    99

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

   100

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

   101

   102

        if zoom > MAX_ZOOM:

   103

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

   104

   105

        x = scale(x * width, zoom)

   106

        y = scale(y * height, zoom)

   107

   108

        try:

   109

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

   110

   111

        except pypngtile.Error as error:

   112

            raise exceptions.InternalServerError(str(error))

   113

   114

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

   115

        """

   116

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

   117

        """

   118

   119

        if not name.endswith('/'):

   120

            # avoid an additional redirect

   121

            name += '/'

   122

   123

        return redirect(self.image_url(name))

   124

   125

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

   126

        """

   127

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

   128

        """

   129

   130

        return redirect(self.image_url(name))

   131

   132

    def handle (self, request):

   133

        """

   134

            Handle request for an image

   135

        """

   136

   137

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

   138

   139

        # determine handler

   140

        if not type:

   141

            return self.handle_dir(request, name, path)

   142

   143

        elif not request.args:

   144

            return self.handle_image(request, name, path)

   145

   146

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

   147

            render_func = self.render_region

   148

   149

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

   150

            render_func = self.render_tile

   151

   152

        else:

   153

            raise exceptions.BadRequest("Unknown args")

   154

   155

        # handle image

   156

        image, name = self.open(request.path)

   157

   158

        # http caching

   159

        mtime = image.cache_mtime()

   160

   169

        if request.if_modified_since and mtime == request.if_modified_since:

   170

            return Response(status=304)

   171

   172

        # render

   173

        png = render_func(request, image)

   174

   175

        # response

   176

        response = Response(png, content_type='image/png')

   177

        response.last_modified = mtime

   178

   191

        return response

   192

   193