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

import datetime

    13

    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

    47

    48

class TileApplication (pngtile.application.PNGTileApplication):

    49

    # age in seconds for caching an unknown-mtime image for revalidates

    50

    MIN_AGE = 10 # 10 seconds

    51

    52

    # age in seconds for caching a known-mtime image

    53

    MAX_AGE = 7 * 24 * 60 * 60 # 1 week

    54

    55

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

    56

        """

    57

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

    58

        """

    59

    60

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

    61

    62

        self.image_server = image_server

    63

    64

    def image_url (self, name):

    65

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

    66

    67

    def render_region (self, request, image):

    68

        """

    69

            Handle request for an image region

    70

        """

    71

    72

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

    73

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

    74

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

    75

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

    76

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

    77

    78

        # safety limit

    79

        if width * height > MAX_PIXELS:

    80

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

    81

    82

        if zoom > MAX_ZOOM:

    83

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

    84

    85

        x = scale_center(x, width, zoom)

    86

        y = scale_center(y, height, zoom)

    87

    88

        try:

    89

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

    90

    91

        except pypngtile.Error as error:

    92

            raise exceptions.InternalServerError(str(error))

    93

    94

    def render_tile (self, request, image):

    95

        """

    96

            Handle request for image tile

    97

        """

    98

    99

        width = TILE_SIZE

   100

        height = TILE_SIZE

   101

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

   102

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

   103

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

   104

   105

        if zoom > MAX_ZOOM:

   106

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

   107

   108

        x = scale(x * width, zoom)

   109

        y = scale(y * height, zoom)

   110

   111

        try:

   112

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

   113

   114

        except pypngtile.Error as error:

   115

            raise exceptions.InternalServerError(str(error))

   116

   117

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

   118

        """

   119

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

   120

        """

   121

   122

        if not name.endswith('/'):

   123

            # avoid an additional redirect

   124

            name += '/'

   125

   126

        return redirect(self.image_url(name))

   127

   128

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

   129

        """

   130

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

   131

        """

   132

   133

        return redirect(self.image_url(name))

   134

   135

    def handle (self, request):

   136

        """

   137

            Handle request for an image

   138

        """

   139

   140

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

   141

   142

        # determine handler

   143

        if not type:

   144

            return self.handle_dir(request, name, path)

   145

   146

        elif not request.args:

   147

            return self.handle_image(request, name, path)

   148

   149

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

   150

            render_func = self.render_region

   151

   152

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

   153

            render_func = self.render_tile

   154

   155

        else:

   156

            raise exceptions.BadRequest("Unknown args")

   157

   158

        # handle image

   159

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

   160

   161

        # http caching

   162

        mtime = image.cache_mtime()

   163

   164

        if 't' in request.args:

   165

            try:

   166

                ttime = datetime.datetime.utcfromtimestamp(int(request.args['t']))

   167

            except ValueError:

   168

                ttime = None

   169

        else:

   170

            ttime = None

   171

   172

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

   173

            response = Response(status=304)

   174

        else:

   175

            # render 

   176

            png = render_func(request, image)

   177

   178

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

   179

   180

        # cache out

   181

        response.last_modified = mtime

   182

   183

        if not ttime:

   184

            # cached item may change while url stays the same

   185

            response.headers['Cache-Control'] = 'max-age={min_age:d}'.format(min_age=self.MIN_AGE)

   186

   187

        elif ttime == mtime:

   188

            # url will change if content changes

   189

            response.headers['Cache-Control'] = 'max-age={max_age:d}'.format(max_age=self.MAX_AGE)

   190

   191

        else:

   192

            # XXX: mismatch wtf

   193

            response.headers['Cache-Control'] = 'must-revalidate'

   194

   195

        return response

   196

   197