1

"""

     2

    Per-image gallery state

     3

"""

     4

     5

from __future__ import with_statement

     6

     7

import filesystem, render, html

     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

    19

        """

    20

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

    21

        """

    22

    23

        super(Image, self).__init__(node)

    24

    25

        # links

    27

        self.next = None

    28

    29

        # the .html file for this image

    30

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

    31

    32

        # info

    33

        self.title = self.name

    34

        self.description = None

    35

    36

        # lazy-loading

    37

        self.img = None

    38

        self.exif = None

    39

        self.metadata = None

    40

        self.stat_data = None

    41

    42

    def load_stat (self) :

    43

        """

    44

            Load and return the os.stat info for this file

    45

        """

    46

    47

        if not self.stat_data :

    48

            self.stat_data = self.stat()

    49

    50

        return self.stat_data

    51

    52

    def load_image (self) :

    53

        """

    54

            Loads the image as a PIL.Image

    55

        """

    56

    57

        if not self.img :

    58

            # open it up

    59

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

    60

    61

        return self.img

    62

    63

    def load_exif (self) :

    64

        """

    65

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

    66

    67

            Returns None if no exif data was found

    68

        """

    69

    70

        if self.exif is None :

    71

            # load

    72

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

    73

                # XXX: details=False?

    74

                self.exif = EXIF.process_file(fh)

    75

    76

        # empty dict -> no exif data

    77

        if self.exif :

    78

            return self.exif

    79

    80

        else :

    81

            return None

    82

    83

    def load_metadata (self) :

    84

        """

    85

            Load and return the metadata for the image as a dictionary

    86

        """

    87

    88

        if not self.metadata :

    89

            # load stuff

    90

            stat = self.load_stat()

    91

            exif = self.load_exif()

    92

    93

            # XXX: avoid having to open the image?

    94

            size = self.load_image().size

    95

    96

            # build

    97

            self.metadata = dict({

    98

                "File name":        self.name,

    99

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

   100

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

   101

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

   102

            }, **dict(

   103

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

   104

            ))

   105

   106

        return self.metadata

   107

   108

    @lazy_load

   109

    def thumb (self) :

   110

        """

   111

            Load and update the thumbnail if needed

   112

        """

   113

   114

        # renderer to use

   115

        # XXX: get from elsewhere

   116

        render_machine = self.config.get_renderer()

   117

   118

        # render if needed

   120

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

   121

        )

   122

   123

    @lazy_load

   124

    def preview (self) :

   125

        """

   126

            Load and update the preview if needed

   127

        """

   128

   129

        # renderer to use

   130

        # XXX: get from elsewhere

   131

        render_machine = self.config.get_renderer()

   132

   133

        return render_machine.render_lazy(self, 

   134

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

   135

        )

   136