1

#!/usr/bin/python2.5

     2

import werkzeug

     3

from werkzeug.exceptions import HTTPException

     4

import wsgiref.handlers

     5

     6

from PIL import Image, ImageDraw, ImageFont, ImageEnhance

     7

from cStringIO import StringIO

     8

import random, itertools

     9

    10

if not hasattr(itertools, 'izip_longest') :

    11

    12

    def izip_longest(*args, **kwds):

    13

        # izip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-

    14

        fillvalue = kwds.get('fillvalue')

    15

        def sentinel(counter = ([fillvalue]*(len(args)-1)).pop):

    16

            yield counter()         # yields the fillvalue, or raises IndexError

    17

        fillers = itertools.repeat(fillvalue)

    18

        iters = [itertools.chain(it, sentinel(), fillers) for it in args]

    19

        try:

    20

            for tup in itertools.izip(*iters):

    21

                yield tup

    22

        except IndexError:

    23

            pass

    24

    25

    itertools.izip_longest = izip_longest 

    26

    27

class Defaults :

    28

    # settings

    31

    32

    chars = [ u'"', u'!', u'?' ]

    33

    35

        "#0469af",

    36

        "#fbc614",

    37

        "#e1313b",

    38

    ]

    39

    40

    font_name = 'helvetica'

    41

    font_size = 30

    42

    44

    line_spacing = -10

    45

    sharpness = 0.6

    46

    47

    img_format = 'png'

    48

    68

        'dejavu-sans-bold':     "/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf",

    69

        'helvetica':            "HELR65W.TTF",

    70

    }

    71

    79

FONT_SIZE_MAX = 1024

    80

    81

# enable debugging

    82

DEBUG = True

    83

    84

    85

def randomize (seq) :

    86

    """

    87

        Returns the given sequence in random order as a list

    88

    """

    89

    90

    # copy

    91

    l = list(seq)

    92

    93

    # rearrange

    94

    random.shuffle(l)

    95

    96

    return l

    97

    98

def build_data (text, chars, line_colors) :

    99

    """

   100

        Returns a matrix of (text, color) tuples representing the data to render

   101

   102

        [ [ (str, str) ] ]

   103

   104

            text        - list of lines

   105

            chars       - list of random chars to interpse

   106

            line_colors - list of colors to draw the chars in

   107

    """

   108

   109

    data = []

   110

   111

    for line, char, color in itertools.izip_longest(text, chars, line_colors, fillvalue=None) :

   112

        # pick position to place char

   113

        pos = random.randint(1, len(line) - 1)

   114

   115

        if not color :

   116

            color = "#000000"

   117

   118

        # split into three parts

   119

        if char :

   120

            data.append([

   121

                    (line[:pos], "#000000"),

   122

                    (char, color),

   123

                    (line[pos:], "#000000"),

   124

                ])

   125

        else :

   126

            data.append([

   127

                    (line, "#000000"),

   128

                ])

   129

   130

    return data

   131

   132

def load_font (font_name, font_size) :

   133

    """

   134

        Load a font by name

   135

    """

   136

   137

    # load font

   139

    font = ImageFont.truetype(font_path, font_size)

   140

   141

    return font

   142

   143

def render_img (data, font, background_color="#ffffff", line_spacing=0) :

   144

    """

   145

        Render the data (as from build_data) as an image, using the given PIL.ImageFont, and return the PIL Image object

   146

    """

   147

   148

    img_width = img_height = 0

   149

   150

    img_data = []

   151

   152

    # compute image width/height

   153

    for segments in data :

   154

        line_width = line_height = 0

   155

   156

        # build a new list of segments with additional info

   157

        line_segments = []

   158

   159

        for seg_text, seg_color in segments :

   160

            # compute rendered text size

   161

            seg_width, seg_height = font.getsize(seg_text)

   162

   163

            # update line_*

   164

            line_width += seg_width

   165

            line_height = max(line_height, seg_height)

   166

   167

            # build the new segments list

   168

            line_segments.append((seg_text, seg_color, seg_width))

   169

   170

        # update img_*

   171

        img_width = max(img_width, line_width)

   172

        img_height += line_height

   173

        img_data.append((line_segments, line_height))

   174

   175

    # calculate height needed for line spacing

   176

    img_height += (len(img_data) - 1) * line_spacing

   177

   178

    # create image

   179

    img = Image.new("RGB", (img_width, img_height), background_color)

   180

    draw = ImageDraw.Draw(img)

   181

   182

    # draw text

   183

    img_y = 0

   184

    for segments, line_height in img_data :

   185

        img_x = 0

   186

   187

        # draw each segment build above, incremeing along img_x

   188

        for seg_text, seg_color, seg_width in segments :

   189

            draw.text((img_x, img_y), seg_text, font=font, fill=seg_color)

   190

   191

            img_x += seg_width

   192

   193

        img_y += line_height + line_spacing

   194

   195

    return img

   196

   197

def effect_sharpness (img, factor) :

   198

    """

   199

        Sharpen the image by the given factor

   200

    """

   201

   202

    return ImageEnhance.Sharpness(img).enhance(factor)

   203

   204

def build_img (img, format='png') :

   205

    """

   206

        Write the given PIL.Image as a string, returning the raw binary data

   207

   208

        Format should be one of the PIL-supported image foarts

   209

    """

   210

   211

    # render PNG output

   212

    buf = StringIO()

   213

    img.save(buf, format)

   214

    data = buf.getvalue()

   215

   216

    return data

   217

   218

def arg_bool (val) :

   219

    if val.lower() in ('true', 't', '1', 'yes', 'y') :

   220

        return True

   221

    elif val.lower() in ('false', 'f', '0', 'no', 'n') :

   222

        return False

   223

    else :

   224

        raise ValueError(val)

   225

   226

def arg_color (val) :

   227

    if val.beginswith('#') :

   228

        int(val[1:], 16)

   229

   230

        return val

   231

    else :

   232

        raise ValueError(val)

   233

   241

   250

   254

   299

   300

    # put the chars in random order by default

   303

   304

    # load/prep resources

   307

   308

    # render the image

   310

   312

   314

   315

    # build the response

   317

   318

    return response

   319

   320

@werkzeug.Request.application

   321

def wsgi_application (request) :

   322

    """

   323

        Our werkzeug WSGI handler

   324

    """

   325

   326

    try :

   327

        # request -> response

   328

        response = handle_request(request)

   329

   330

        return response

   331

   332

    except HTTPException, e :

   333

        # return as HTTP response

   334

        return e

   335

   336

def main () :

   337

    handler = wsgiref.handlers.CGIHandler()

   338

    app = wsgi_application

   339

   340

    if DEBUG :

   341

        # enable debugging

   342

        app = werkzeug.DebuggedApplication(app, evalex=False)

   343

   344

    handler.run(app)

   345

   346

if __name__ == '__main__' :

   347

    main()

   348