1

"""

     2

    State for thumbnails; derivates of Images

     3

"""

     4

     5

import filesystem, exif

     6

     7

import PIL.Image

     8

     9

class Thumbnail (filesystem.File) :

    10

    """

    11

        A Thumbnail is a derivate of an Image, usually resized to some other size.

    12

    """

    13

    14

    def __init__ (self, image, subdir, target_size) :

    15

        """

    16

            Initialize to link against the given `image`.

    17

    18

            `subdir` specifies the directory to store this thumbnail in.

    19

            `target_size` determines the target resolution of the output thumbnail.

    20

        """

    21

    22

        # our file path, image name inside of the given subdir

    23

        super(Thumbnail, self).__init__(subdir, image.fsname)

    24

    25

        # store

    26

        self.image = image

    27

        self.target_size = target_size

    28

    29

    def stale (self) :

    30

        """

    31

            Tests if this thumbnail is stale

    32

        """

    33

    34

        if self.image.older_than(self) :

    35

            # both exist and this is newer

    36

            return False

    37

    38

        else :

    39

            # this thumb doesn't exist or is older

    40

            return True

    41

    42

    def calcsize (self, size) :

    43

        """

    44

            Compute the *real* size of this thumbnail, from the give actual size and our target size.

    45

    46

            Preserves the aspect ratio etc.

    47

        """

    48

    49

        # initial image size

    50

        width, height = size

    51

    52

        # target size

    53

        thumb_width, thumb_height = self.target_size

    54

    55

        # calc new size, preserving aspect ratio

    56

        # calculations ripped from PIL.Image.thumbnail :)

    57

        if width > thumb_width : 

    58

            height = max(height * thumb_width / width, 1)

    59

            width = thumb_width

    60

    61

        if height > thumb_height :

    62

            width = max(width * thumb_height / height, 1)

    63

            height = thumb_height

    64

    65

        return width, height 

    66

    67

    ## operations

    68

    def resize (self, img) :

    69

        """

    70

            Resize the given image as needed.

    71

        """

    72

    73

        return img.resize(self.calcsize(img.size), resample=PIL.Image.ANTIALIAS)

    74

    75

    def transform (self, img, orient_info) :

    76

        """

    77

            Transform this image into the output version, resizing, rotating and mirroring in a single step.

    78

        """

    79

    80

        # get sizes

    81

        img_width, img_height = img_size = img.size

    82

    83

        # unpack

    84

        mirroring, rotation = orient_info

    85

    86

        if mirroring :

    87

            # XXX: does anyone actually use this? Untested

    88

            # interaction with rotate is probably wrong

    89

            p0, p1 = {

    90

                exif.MIRROR_HORIZONTAL: ((0, img_height), (img_width, 0)),

    91

                exif.MIRROR_VERTICAL:   ((img_width, 0), (0, img_height)),

    92

            }

    93

    94

        if rotation in (exif.ROTATE_90, exif.ROTATE_270) :

    95

            # flip the dimensions to take rotate into account

    96

            img_size = img_height, img_width

    97

    98

        # calc new size

    99

        thumb_size = self.calcsize(img_size)

   100

   101

        if rotation in (exif.ROTATE_90, exif.ROTATE_270) :

   102

            # flip the dimensions back before rotate

   103

            thumb_size = thumb_size[1], thumb_size[0]

   104

   105

        if mirroring :

   106

            # perform the transform, can't use ANTIALIAS here :/

   107

            img = img.transform(thumb_size, PIL.Image.EXTENT, p0 + p1, PIL.Image.NEAREST)

   108

   109

        else :

   110

            # resize with ANTIALIAS

   111

            img = img.resize(thumb_size, resample=PIL.Image.ANTIALIAS)

   112

   113

        if rotation :

   114

            # transform can't rotate

   115

            # since these are in steps of 90 degrees, it should keep the right size

   116

            # but gah, PIL wants these as counter-clockwise!

   117

            img = img.rotate(360 - rotation)

   118

   119

        return img

   120

   121

    def update (self) :

   122

        """

   123

            Render new output thumbnail.

   124

        """

   125

   126

        # start with origional image

   127

        img = self.image.img

   128

   129

        if self.image.orientation and (self.image.orientation[0] or self.image.orientation[1]) :

   130

            # rotate

   131

            img = self.transform(img, self.image.orientation)

   132

   133

        else :

   134

            # just create resized copy of main image, using our size

   135

            img = self.resize(img)

   136

   137

        # write it out

   138

        img.save(self.path)

   139