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

    79

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

    80

        """

    81

            request:    werkzeug.Request

    82

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

    83

            items:      [...] items in dir

    84

        """

    85

    86

        if name:

    87

            title = name

    88

        else:

    89

            title = "Index"

    90

    91

        return self.render_html(

    92

            title       = name,

    93

            body        = (

    94

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

    95

                    html.h1(title),

    96

                    html.div(*[

    97

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

    98

                    ]),

    99

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

   100

                        html.ul(class_='list-group', *[html.li(class_='list-group-item', *[

   101

                                html.a(href=item, *[item])

   102

                            ]) for item in items]

   103

                        ),

   104

                    ]),

   105

                ]),

   106

            ),

   107

        )

   108

   109

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

   110

        """

   111

            request:    werkzeug.Request

   112

            image:      pypngtile.Image

   113

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

   114

        """

   115

   116

        image_info = image.info()

   117

   118

        map_config = dict(

   119

            tiles_url       = self.tiles_url(name),

   120

            tiles_mtime     = image_info['cache_mtime'],

   121

   122

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

   123

            tile_size       = pngtile.tile.TILE_SIZE,

   124

            tile_zoom       = pngtile.tile.MAX_ZOOM,

   125

   126

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

   127

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

   128

            image_width     = image_info['img_width'],

   129

            image_height    = image_info['img_height'],

   130

        )

   131

   132

        return self.render_html(

   133

            title       = name,

   134

            body        = (

   135

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

   136

                    html.div(id='map')

   137

                ]),

   138

            ),

   139

            end         = (

   140

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

   141

            ),

   142

        )

   143

   144

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

   145

        """

   146

            Generate response for directory listing.

   147

        """

   148

   149

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

   150

            # we generate HTML with relative links

   151

            return redirect(request.path + '/')

   152

   153

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

   154

   155

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

   156

   157

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

   158

   159

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

   160

        """

   161

            Generate Response for image request.

   162

        """

   163

   164

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

   165

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

   166

            return redirect(self.tiles_url(name,

   167

                w       = request.args['w'],

   168

                h       = request.args['h'],

   169

                x       = request.args['cx'],

   170

                y       = request.args['cy'],

   171

                zoom    = request.args['zl'],

   172

            ))

   173

   174

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

   175

   176

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

   177

   178

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

   179

   180

    def handle (self, request):

   181

        """

   182

            Handle request for an image

   183

        """

   184

   185

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

   186

   187

        # determine handler

   188

        if not type:

   189

            return self.handle_dir(request, name, path)

   190

   191

        else:

   192

            return self.handle_image(request, name, path)

   193

   194

    @Request.application

   195

    def __call__ (self, request):

   196

        """

   197

            WSGI entry point.

   198

        """

   199

   200

        try:

   201

            return self.handle(request)

   202

   203

        except exceptions.HTTPException as error:

   204

            return error

   205