1

"""

     2

    Per-image gallery state

     3

"""

     4

     5

from __future__ import with_statement

     6

     7

import filesystem, render, html

     8

     9

import PIL.Image

    10

from lib import EXIF

    11

    12

class Image (filesystem.File) :

    13

    """

    14

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

    15

    """

    16

    17

    def __init__ (self, node, prev) :

    18

        """

    19

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

    20

        """

    21

    22

        super(Image, self).__init__(node)

    23

    24

        # links

    25

        self.prev = prev

    26

        self.next = None

    27

    28

        # the .html file for this image

    29

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

    30

    31

        # info

    32

        self.title = self.name

    33

        self.description = None

    34

    35

        # lazy-loading

    36

        self.img = None

    37

        self.exif = None

    38

        self.metadata = None

    39

        self.stat_data = None

    40

    41

    def load_stat (self) :

    42

        """

    43

            Load and return the os.stat info for this file

    44

        """

    45

    46

        if not self.stat_data :

    47

            self.stat_data = self.stat()

    48

    49

        return self.stat_data

    50

    51

    def load_image (self) :

    52

        """

    53

            Loads the image as a PIL.Image

    54

        """

    55

    56

        if not self.img :

    57

            # open it up

    58

            self.img = PIL.Image.open(self.path)

    59

    60

        return self.img

    61

    62

    def load_exif (self) :

    63

        """

    64

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

    65

    66

            Returns None if no exif data was found

    67

        """

    68

    69

        if self.exif is None :

    70

            # load

    71

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

    72

                # XXX: details=False?

    73

                self.exif = EXIF.process_file(fh)

    74

    75

        # empty dict -> no exif data

    76

        if self.exif :

    77

            return self.exif

    78

    79

        else :

    80

            return None

    81

    82

    def load_metadata (self) :

    83

        """

    84

            Load and return the metadata for the image as a dictionary

    85

        """

    86

    87

        if not self.metadata :

    88

            # load stuff

    89

            stat = self.load_stat()

    90

            exif = self.load_exif()

    91

    92

            # XXX: avoid having to open the image?

    93

            size = self.load_image().size

    94

    95

            # build

    96

            self.metadata = dict({

    97

                "File name":        self.name,

    98

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

    99

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

   100

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

   101

            }, **dict(

   102

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

   103

            ))

   104

   105

        return self.metadata

   106

   107

    @lazy_load

   108

    def thumb (self) :

   109

        """

   110

            Load and update the thumbnail if needed

   111

        """

   112

   113

        # renderer to use

   114

        # XXX: get from elsewhere

   115

        render_machine = self.config.get_renderer()

   116

   117

        # render if needed

   118

        return render_machine.render_lazy(self

   119

            self.config.thumb_size, self.parent.load_thumb_dir.subnode(self.name)

   120

        )

   121

   122

    @lazy_load

   123

    def preview (self) :

   124

        """

   125

            Load and update the preview if needed

   126

        """

   127

   128

        # renderer to use

   129

        # XXX: get from elsewhere

   130

        render_machine = self.config.get_renderer()

   131

   132

        return render_machine.render_lazy(self, 

   133

            self.config.preview_size, self.parent.load_preview_dir.subnode(self.name)

   134

        )

   135