1

"""

     2

    Image handling.

     3

"""

     4

     5

     6

from werkzeug import Request, Response, exceptions

     7

from werkzeug.utils import html, redirect

     8

import werkzeug.urls

     9

    10

import pngtile.tile

    11

import pngtile.application

    12

import pypngtile

    13

    14

import json

    15

import os, os.path

    16

    17

class ImageApplication (pngtile.application.PNGTileApplication):

    18

    19

    STYLESHEETS = (

    20

        'https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css',

    21

        'https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css',

    22

        'http://cdn.leafletjs.com/leaflet-0.7.3/leaflet.css',

    23

        '/static/pngtile/map.css',

    24

    )

    25

    26

    SCRIPTS = (

    27

        'https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js',

    28

        'https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js',

    29

        'http://cdn.leafletjs.com/leaflet-0.7.3/leaflet.js',

    30

        '/static/pngtile/map.js',

    31

    )

    32

    33

    def __init__ (self, tiles_server=None, **opts):

    34

        """

    35

            http://.../ path to tileserver root

    36

        """

    37

    38

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

    39

    40

        self.tiles_server = tiles_server

    41

    42

    def tiles_url (self, name, **args):

    43

        return werkzeug.urls.Href(self.tiles_server)(name, **args)

    44

    45

    def render_html (self, title, body, stylesheets=None, scripts=None, end=()):

    46

        if stylesheets is None:

    47

            stylesheets = self.STYLESHEETS

    48

    49

        if scripts is None:

    50

            scripts = self.SCRIPTS

    51

    52

        return html.html(lang='en', *[

    53

            html.head(

    54

                html.title(title),

    55

                *[

    56

                    html.link(rel='stylesheet', href=href) for href in stylesheets

    57

                ]

    58

            ),

    59

            html.body(

    60

                *(body + tuple(

    61

                    html.script(src=src) for src in scripts

    62

                ) + end)

    63

            ),

    64

        ])

    65

    66

    67

    def render_dir_breadcrumb (self, name):

    68

        href = werkzeug.urls.Href('/')

    69

        path = []

    70

    71

        yield html.li(html.a(href='/', *[u"Index"]))

    72

    73

        if name:

    74

            for part in name.split('/'):

    75

                path.append(part)

    76

    77

                yield html.li(html.a(href=href(*path), *[part]))

    78

    86

    def render_dir (self, request, name, items):

    87

        """

    88

            request:    werkzeug.Request

    89

            name:       /.../... url to dir

    90

            items:      [...] items in dir

    91

        """

    92

    93

        if name:

    94

            title = name

    95

        else:

    96

            title = "Index"

    97

    98

        return self.render_html(

    99

            title       = name,

   100

            body        = (

   101

                html.div(class_='container', *[

   102

                    html.h1(title),

   103

                    html.div(*[

   104

                        html.ol(class_='breadcrumb', *self.render_dir_breadcrumb(name)),

   105

                    ]),

   106

                    html.div(class_='list', *[

   112

                    ]),

   113

                ]),

   114

            ),

   115

        )

   116

   117

    def render_image (self, request, image, name):

   118

        """

   119

            request:    werkzeug.Request

   120

            image:      pypngtile.Image

   121

            name:       request path for .../.../*.png image

   122

        """

   123

   124

        image_info = image.info()

   125

   126

        map_config = dict(

   127

            tiles_url       = self.tiles_url(name),

   128

            tiles_mtime     = image_info['cache_mtime'],

   129

   130

            tile_url        = '{tiles_url}?t={tiles_mtime}&x={x}&y={y}&zoom={z}',

   131

            tile_size       = pngtile.tile.TILE_SIZE,

   132

            tile_zoom       = pngtile.tile.MAX_ZOOM,

   133

   134

            # do NOT include a mtime in these urls.. we should always revalidate them

   135

            image_url       = '{tiles_url}?w={w}&h={h}&x={x}&y={y}&zoom={z}',

   136

            image_width     = image_info['img_width'],

   137

            image_height    = image_info['img_height'],

   138

        )

   139

   140

        return self.render_html(

   141

            title       = name,

   142

            body        = (

   143

                html.div(id='wrapper', *[

   144

                    html.div(id='map')

   145

                ]),

   146

            ),

   147

            end         = (

   148

                html.script("""$(function() {{ map_init({map_config}); }});""".format(map_config=json.dumps(map_config))),

   149

            ),

   150

        )

   151

   152

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

   153

        """

   154

            Generate response for directory listing.

   155

        """

   156

   157

        if not request.path.endswith('/'):

   158

            # we generate HTML with relative links

   159

            return redirect(request.path + '/')

   160

   161

        items = sorted(self.list(request.path))

   162

   163

        html = self.render_dir(request, name, items)

   164

   165

        return Response(html, content_type="text/html")

   166

   167

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

   168

        """

   169

            Generate Response for image request.

   170

        """

   171

   172

        # backwards-compat redirect from frontend -> tile-server

   173

        if all(attr in request.args for attr in ('cx', 'cy', 'w', 'h', 'zl')):

   174

            return redirect(self.tiles_url(name,

   175

                w       = request.args['w'],

   176

                h       = request.args['h'],

   177

                x       = request.args['cx'],

   178

                y       = request.args['cy'],

   179

                zoom    = request.args['zl'],

   180

            ))

   181

   182

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

   183

   184

        html = self.render_image(request, image, name)

   185

   186

        return Response(html, content_type="text/html")

   187

   188

    def handle (self, request):

   189

        """

   190

            Handle request for an image

   191

        """

   192

   193

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

   194

   195

        # determine handler

   196

        if not type:

   197

            return self.handle_dir(request, name, path)

   198

   199

        else:

   200

            return self.handle_image(request, name, path)

   201

   202

    @Request.application

   203

    def __call__ (self, request):

   204

        """

   205

            WSGI entry point.

   206

        """

   207

   208

        try:

   209

            return self.handle(request)

   210

   211

        except exceptions.HTTPException as error:

   212

            return error

   213