11

## Settings

    12

# path to images

    15

# only open each image once

    18

# width of a tile

    25

def dir_url (prefix, name, item) :

    26

    """

    27

        Join together an absolute URL prefix, an optional directory name, and a directory item

    28

    """

    29

    30

    url = prefix

    31

    32

    if name :

    33

        url = os.path.join(url, name)

    34

    35

    url = os.path.join(url, item)

    36

    37

    return url

    38

    39

def dir_list (dir_path) :

    40

    """

    41

        Yield a series of directory items to show for the given dir

    42

    """

    43

    44

    # link to parent

    45

    yield '..'

    46

    47

    for item in os.listdir(dir_path) :

    48

        path = os.path.join(dir_path, item)

    49

    50

        # skip dotfiles

    51

        if item.startswith('.') :

    52

            continue

    53

    54

        # show dirs

    55

        if os.path.isdir(path) :

    56

            yield item

    57

    58

        # examine ext

    59

        base, ext = os.path.splitext(path)

    60

    61

        # show .png files with a .cache file

    62

        if ext == '.png' and os.path.exists(base + '.cache') :

    63

            yield item

    64

    65

### Render HTML data

    66

def render_dir (req, name, path) :

    67

    """

    68

        Directory index

    69

    """

    70

    90

        dir             = '/' + name,

    93

            # <li> link

    95

                # URL to dir

    96

                url         = dir_url(script_prefix, name, item),

    97

    98

                # item name

   100

            ) for item in dir_list(path)

   104

def render_img_viewport (req, name, image) :

   105

    """

   106

        HTML for image

   107

    """

   108

   109

    # a little slow, but not so bad - two stats(), heh

   110

    info = image.info()

   111

    img_width, img_height = info['img_width'], info['img_height']

   146

        title           = name,

   158

    """

   159

        Scale coordinates by zoom factor

   160

    """

   161

   171

### Render PNG Data

   172

def render_img_tile (image, x, y, zoom, width=TILE_WIDTH, height=TILE_HEIGHT) :

   173

    """

   174

        Render given tile, returning PNG data

   175

    """

   176

   183

def render_img_region (image, cx, cy, zoom, width, height) :

   184

    """

   185

        Render arbitrary tile, returning PNG data

   186

    """

   187

   201

   202

### Manipulate request data

   203

def get_req_path (req) :

   204

    """

   205

        Returns the name and path requested

   206

    """

   207

   218

    return image_name, image_path

   220

def get_image (name, path) :

   221

    """

   222

        Gets an Image object from the cache, ensuring that it is cached

   223

    """

   226

    if path in IMAGE_CACHE :

   228

        image = IMAGE_CACHE[path]

   231

        # open

   232

        image = pt.Image(path)

   233

   234

        # check

   235

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

   236

            raise exceptions.InternalServerError("Image cache not available: %s" % name)

   237

   238

        # load

   239

        image.open()

   242

        IMAGE_CACHE[path] = image

   244

    return image

   245

   246

   247

   248

### Handle request

   249

def handle_dir (req, name, path) :

   250

    """

   251

        Handle request for a directory

   252

    """

   253

   254

    return Response(render_dir(req, name, path), content_type="text/html")

   255

   256

   257

   258

def handle_img_viewport (req, image, name) :

   259

    """

   260

        Handle request for image viewport

   261

    """

   262

   263

    # viewport

   264

    return Response(render_img_viewport(req, name, image), content_type="text/html")

   265

   266

   267

def handle_img_region (req, image) :

   268

    """

   269

        Handle request for an image region

   270

    """

   271

   272

    # specific image

   273

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

   274

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

   275

    cx = int(req.args['cx'])

   276

    cy = int(req.args['cy'])

   277

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

   278

   279

    # yay full render

   280

    return Response(render_img_region(image, cx, cy, zoom, width, height), content_type="image/png")

   281

   282

   283

def handle_img_tile (req, image) :

   284

    """

   285

        Handle request for image tile

   286

    """

   287

   288

    # tile

   289

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

   290

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

   291

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

   292

   293

    # yay render

   294

    return Response(render_img_tile(image, x, y, zoom), content_type="image/png")

   295

   296

## Dispatch req to handle_img_*

   297

def handle_img (req, name, path) :

   298

    """

   299

        Handle request for an image

   300

    """

   301

   302

    # get image object

   303

    image = get_image(name, path)

   307

        return handle_img_viewport(req, image, name)

   310

        return handle_img_region(req, image)

   313

        return handle_img_tile(req, image)

   314

   317

   318

   319

   320

## Dispatch request to handle_*

   321

def handle_req (req) :

   322

    """

   323

        Main request handler

   324

    """

   325

   326

    # decode req

   327

    name, path = get_req_path(req)

   328

   329

    # determine dir/image

   330

    if os.path.isdir(path) :

   331

        # directory

   332

        return handle_dir(req, name, path)

   333

   334

    elif not os.path.exists(path) :

   335

        # no such file

   336

        raise exceptions.NotFound(name)

   337

   338

    elif not name or not name.endswith('.png') :

   339

        # invalid file

   340

        raise exceptions.BadRequest("Not a PNG file")

   341

   342

    else :

   343

        # image

   344

        return handle_img(req, name, path)

   345

   346

   347

   351

    """

   352

        Main WSGI entry point

   353

    """

   354

   358

        return handle_req(req)