1

"""

     2

    Per-image gallery state

     3

"""

     4

     5

from __future__ import with_statement

     6

     7

import filesystem, format, thumbnail

     8

from utils import lazy_load

     9

    10

import PIL.Image

    11

from lib import EXIF

    12

    13

class Image (filesystem.File) :

    14

    """

    15

        An Image is a filesystem File that represents an image that can be thumbnailed, and handled.

    16

    """

    17

    18

    def __init__ (self, *args, **kwargs) :

    19

        """

    20

            Initialize as an Image based on the given Node, linked with the given previous node

    21

        """

    22

    23

        super(Image, self).__init__(*args, **kwargs)

    24

    25

        # links

    26

        self.prev = None

    27

        self.next = None

    28

    29

        # the .html file for this image

    30

        self.html = self.parent.subfile(self.basename + '.html')

    31

    32

        # our preview/thumbnail

    33

        self.preview = thumbnail.Thumbnail(self, self.parent.preview_dir, self.config.preview_size)

    34

        self.thumb = thumbnail.Thumbnail(self, self.parent.thumb_dir, self.config.thumb_size)

    35

    36

        # info

    37

        self.title = self.name

    38

        self.description = None

    39

    40

    @lazy_load

    41

    def img (self) :

    42

        """

    43

            Loads the image as a PIL.Image

    44

        """

    45

    46

        # open it up

    47

        return PIL.Image.open(self.path)

    48

    49

    @property

    50

    def img_size (self) :

    51

        """

    52

            Returns the pixel (width, height) resolution tuple of this image.

    53

        """

    54

    55

        return self.img.size

    56

    57

    @lazy_load

    58

    def exif (self) :

    59

        """

    60

            Loads the EXIF data for the image and returns as a dict of EXIF tag names -> values.

    61

    62

            Returns None if no exif data was found

    63

        """

    64

    65

        # load

    66

        with self.open('rb') as fh :

    67

            # XXX: details=False?

    68

            exif = EXIF.process_file(fh)

    69

    70

        # empty dict -> no exif data

    71

        if exif :

    72

            return exif

    73

    74

        else :

    75

            return None

    76

    77

    @lazy_load

    78

    def metadata (self) :

    79

        """

    80

            Load and return the metadata for the image as a dictionary

    81

        """

    82

    83

        # load stuff

    84

        stat = self.stat()

    85

    86

        # XXX: avoid having to open the image?

    87

        size = self.img_size

    88

    89

        # build

    90

        metadata = dict({

    91

            "File name":        self.name,

    92

            "Resolution":       "%dx%d" % size,

    93

            "File size":        format.filesize(stat.st_size),

    94

            "Last modified":    format.filetime(stat.st_mtime),

    95

        })

    96

    97

        # optionally load Exif metadata

    99

            exif = self.exif

   100

   101

            # Get the wanted tags

   102

            metadata.update(dict(

   103

                (name, exif[tag]) for tag, name in self.config.exif_tags if exif and tag in exif

   104

            ))

   105

   106

        return metadata

   107

   108

    def stale (self) :

   109

        """

   110

            Tests if this Image is stale, based on preview/thumb.

   111

        """

   112

   113

        return self.preview.stale() or self.thumb.stale()

   114

   115

    def update (self) :

   116

        """

   117

            Updates this Image's thumb/preview

   118

        """

   119

   120

        self.preview.update()

   121

        self.thumb.update()

   122