1

"""

     2

    Raw tile handling.

     3

"""

     4

     5

import os.path

     6

     7

from werkzeug import Request, Response, exceptions

     8

     9

import pypngtile

    10

    11

## Coordinates

    12

# width of a tile

    13

TILE_WIDTH = 256

    14

TILE_HEIGHT = 256

    15

    16

# max. output resolution to allow

    17

MAX_PIXELS = 1920 * 1200

    18

    19

def scale (val, zoom):

    20

    """

    21

        Scale dimension by zoom factor

    22

    23

        zl > 0 -> bigger

    24

        zl < 0 -> smaller

    25

    """

    26

    27

    if zoom > 0:

    28

        return val << zoom

    29

    30

    elif zoom < 0:

    31

        return val >> -zoom

    32

    33

    else:

    34

        return val

    35

    36

def scale_center (val, dim, zoom):

    37

    """

    38

        Scale value about center by zoom.

    39

    """

    40

    41

    return scale(val - dim / 2, zoom)

    42

    43

class Application (object):

    44

    def __init__ (self, image_root):

    45

        if not os.path.isdir(image_root) :

    46

            raise Exception("Given image_root does not exist: {image_root}".format(image_root=image_root))

    47

    48

        self.image_root = os.path.abspath(image_root)

    49

    50

        self.image_cache = { }

    51

    52

    def lookup_image (self, url):

    53

        """

    54

            Lookup image by request path.

    55

    56

            Returns image_name, image_path.

    57

        """

    58

    59

        if not os.path.isdir(self.image_root):

    60

            raise exceptions.InternalServerError("Server image_root has gone missing")

    61

    62

        # path to image

    63

        name = url.lstrip('/')

    64

    65

        # build absolute path

    66

        path = os.path.abspath(os.path.join(self.image_root, name))

    67

    68

        # ensure the path points inside the data root

    69

        if not path.startswith(self.image_root):

    70

            raise exceptions.NotFound(name)

    71

    72

        return name, path

    73

    74

    def get_image (self, url):

    75

        """

    76

            Return Image object.

    77

        """

    78

    79

        name, path = self.lookup_image(url)

    80

    81

        # get Image object

    82

        image = self.image_cache.get(path)

    83

    84

        if not image:

    85

            # open

    86

            image = pypngtile.Image(path)

    87

    88

            # check

    89

            if image.status() not in (pypngtile.CACHE_FRESH, pypngtile.CACHE_STALE):

    90

                raise exceptions.InternalServerError("Image cache not available: {name}".format(name=name))

    91

    92

            # load

    93

            image.open()

    94

    95

            # cache

    96

            self.image_cache[path] = image

    97

    98

        return image

    99

   100

    def render_region (self, request, image):

   101

        """

   102

            Handle request for an image region

   103

        """

   104

   105

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

   106

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

   107

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

   108

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

   109

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

   110

   111

        # safely limit

   112

        if width * height > MAX_PIXELS:

   113

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

   114

   115

        x = scale(x, zoom)

   116

        y = scale(y, zoom)

   117

   118

        try:

   119

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

   120

   121

        except pypngtile.Error as error:

   122

            raise exceptions.BadRequest(str(error))

   123

   124

    def render_tile (self, request, image):

   125

        """

   126

            Handle request for image tile

   127

        """

   128

   129

        width = TILE_WIDTH

   130

        height = TILE_HEIGHT

   131

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

   132

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

   133

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

   134

   135

        x = scale(row * width, zoom)

   136

        y = scale(col * height, zoom)

   137

   138

        try:

   139

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

   140

   141

        except pypngtile.Error as error:

   142

            raise exceptions.BadRequest(str(error))

   143

   144

    def handle (self, request):

   145

        """

   146

            Handle request for an image

   147

        """

   148

   149

        try:

   150

            image = self.get_image(request.path)

   151

        except pypngtile.Error as error:

   152

            raise exceptions.BadRequest(str(error))

   153

   154

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

   155

            png = self.render_region(request, image)

   156

   157

        elif 'row' in request.args and 'col' in request.args:

   158

            png = self.render_tile(request, image)

   159

   160

        else:

   161

            raise exceptions.BadRequest("Unknown args")

   162

   163

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

   164

   165

    @Request.application

   166

    def __call__ (self, request):

   167

        """

   168

            WSGI entry point.

   169

        """

   170

   171

        try:

   172

            return self.handle(request)

   173

   174

        except exceptions.HTTPException as error:

   175

            return error

   176