1

import os, os.path

     2

     3

import PIL.Image

     4

     5

import dexif

     6

     7

import settings, utils, log

     8

from template import image as image_tpl

    14

class Image (object) :

    15

    def __init__ (self, dir, name) :

    16

        # the image filename, e.g. DSC3948.JPG

    17

        self.name = unicode(name)

    18

    19

        # the Folder object that we are in

    20

        self.dir = dir

    21

    22

        # the relative path from the root to us

    23

        self.path = dir.pathFor(self.name)

    24

    25

        # the basename+ext, e.g. DSCR3948, .JPG

    26

        self.base_name, self.ext = os.path.splitext(self.name)

    27

    28

        # our user-friendly title

    29

        self.title = self.name

    30

    31

        # our long-winded description

    32

        self.descr = ''

    33

    34

        # the image before and after us, both may be None

    35

        self.prev = self.next = None

    36

    37

        # the image-relative names for the html page, thumb and preview images

    38

        self.html_name = self.name + ".html"

    39

        self.thumb_name = utils.url_join(settings.THUMB_DIR, self.name)

    40

        self.preview_name = utils.url_join(settings.PREVIEW_DIR, self.name)

    41

    42

        # the root-relative paths to the html page, thumb and preview images

    43

        self.html_path = self.dir.pathFor(self.html_name)

    44

        self.thumb_path = self.dir.pathFor(settings.THUMB_DIR, self.name)

    45

        self.preview_path = self.dir.pathFor(settings.PREVIEW_DIR, self.name)        

    46

    47

        #

    48

        # Figured out after prepare

    49

        #

    50

    51

        # (w, h) tuple

    52

        self.img_size = None

    53

    54

        # the ShortURL code for this image

    55

        self.shorturl_code = None

    56

    57

	# EXIF data

    58

	self.exif_data = {}

    59

    60

        # what to use in the rendered templates, intended to be overridden by subclasses

    61

        self.series_act = "add"

    62

        self.series_verb = "Add to"

    63

    64

    def getObjInfo (self) :

    65

        """

    66

            Metadata for shorturl2.db

    67

        """

    68

        return 'img', self.dir.path, self.name

    69

    70

    def breadcrumb (self) :

    71

        """

    72

            Returns a [(fname, title)] list of this image's parents

    73

       """

    74

    75

        return self.dir.breadcrumb(forImg=self) + [(self.html_name, self.title)]

    76

    77

    def render (self) :

    78

        """

    79

            Write out the .html file

    80

        """

    81

    82

        # stat the image file to get the filesize and mtime

    83

        st = os.stat(self.path)

    84

    85

        self.filesize = st.st_size

    86

        self.timestamp = st.st_mtime

    87

    88

        # open the image in PIL to get image attributes + generate thumbnails

    89

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

    90

    91

        self.img_size = img.size

    92

    93

        for out_path, geom in ((self.thumb_path, settings.THUMB_GEOM), (self.preview_path, settings.PREVIEW_GEOM)) :

    94

            # if it doesn't exist, or it's older than the image itself, generate

    95

            if utils.mtime(out_path) < self.timestamp :

    96

                log.info("render [%sx%s]", geom[0], geom[1], wait=True)

    97

    98

                # XXX: is this the most efficient way to do this? It seems slow

    99

                out_img = img.copy()

   100

                out_img.thumbnail(geom, resample=True)

   101

                out_img.save(out_path)

   102

   103

                log.done()

   104

   105

        # look for the metadata file

   106

        title_path = self.dir.pathFor(self.base_name + '.txt')

   107

   108

        self.title, self.descr = utils.readTitleDescr(title_path)

   109

   110

        if not self.title :

   111

            self.title = self.name

   112

   113

        if utils.mtime(self.html_path) < self.timestamp :

   114

            log.info("render %s.html", self.name)

   115

   116

            # parse the exif data from the file

   117

            try :

   118

                    self.exif_data = dexif.parse_exif(self.path)

   119

            except dexif.ExifError, message:

   120

                    log.warning("Reading EXIF data for %s failed: %s" % (self.filename, message))

   121

                    self.exif_data = {}

   122

   123

   124

            image_tpl.render_to(self.html_path,

   125

                stylesheet_url             = self.dir.inRoot('style.css'),

   126

                title                      = self.title,

   127

                breadcrumb                 = self.breadcrumb(),

   128

   129

                prev                       = self.prev,

   130

                next                       = self.next,

   131

                img                        = self,

   132

   133

                description                = self.descr,

   134

   135

                filename                   = self.name,

   136

                img_size                   = self.img_size,

   137

                file_size                  = self.filesize,

   138

                timestamp                  = self.timestamp,

   139

		exif_data		   = self.exif_data,

   140

   141

                shorturl                   = self.dir.inRoot('s', self.shorturl_code),

   142

                shorturl_code              = self.shorturl_code,

   143

   144

                series_url                 = self.dir.inRoot('series/%s/%s' % (self.series_act, self.shorturl_code)),

   145

                series_verb                = self.series_verb,

   146

            )   

   147

   148

    def __str__ (self) :

   149

        return "Image `%s' in `%s'" % (self.name, self.dir.path)

   150