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 pil_image (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

    @lazy_load

    50

    def exif (self) :

    51

        """

    52

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

    53

    54

            Returns None if no exif data was found

    55

        """

    56

    57

        # load

    58

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

    59

            # XXX: details=False?

    60

            exif = EXIF.process_file(fh)

    61

    62

        # empty dict -> no exif data

    63

        if exif :

    64

            return exif

    65

    66

        else :

    67

            return None

    68

    69

    @lazy_load

    70

    def metadata (self) :

    71

        """

    72

            Load and return the metadata for the image as a dictionary

    73

        """

    74

    75

        # load stuff

    76

        stat = self.stat()

    77

        exif = self.exif

    78

    79

        # XXX: avoid having to open the image?

    80

        size = self.pil_image.size

    81

    82

        # build

    83

        return dict({

    84

            "File name":        self.name,

    85

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

    86

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

    87

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

    88

        }, **dict(

    89

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

    90

        ))

    91

    92

    def stale (self) :

    93

        """

    94

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

    95

        """

    96

    97

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

    98

    99

    def update (self) :

   100

        """

   101

            Updates this Image's thumb/preview

   102

        """

   103

   106