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

     9

    27

class Defaults :

    28

    # settings

    29

    text = [

    30

        "aalto",

    31

        "unive",

    32

        "rsity"

    33

    ]

    34

    35

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

    36

    37

    line_colors = [

    38

        "#0469af",

    39

        "#fbc614",

    40

        "#e1313b",

    41

    ]

    42

    43

    font_name = 'helvetica'

    44

    font_size = 30

    45

    46

    background_color = "#ffffff"

    47

    line_spacing = -10

    48

    sharpness = 0.6

    49

    50

fonts = {

    51

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

    52

        'helvetica':            "HELR65W.TTF",

    53

    }

    54

    55

    56

# enable debugging

    57

debug = True

    58

    59

def randomize (seq) :

    60

    """

    61

        Returns the given sequence in random order as a list

    62

    """

    63

    64

    # copy

    65

    l = list(seq)

    66

    67

    # rearrange

    68

    random.shuffle(l)

    69

    70

    return l

    71

    72

def build_data (text, chars, line_colors) :

    73

    """

    74

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

    75

    76

        [ [ (str, str) ] ]

    77

    78

            text        - list of lines

    79

            chars       - list of random chars to interpse

    80

            line_colors - list of colors to draw the chars in

    81

    """

    82

    83

    data = []

    84

    86

        # pick position to place char

    87

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

    91

    92

        # split into three parts

   103

   104

    return data

   105

   106

def load_font (font_name, font_size) :

   107

    """

   108

        Load a font by name

   109

    """

   110

   111

    # load font

   112

    font_path = fonts[font_name]

   113

    font = ImageFont.truetype(font_path, font_size)

   114

   115

    return font

   116

   117

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

   118

    """

   119

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

   120

    """

   121

   122

    img_width = img_height = 0

   123

   124

    img_data = []

   125

   126

    # compute image width/height

   127

    for segments in data :

   128

        line_width = line_height = 0

   129

   130

        # build a new list of segments with additional info

   131

        line_segments = []

   132

   133

        for seg_text, seg_color in segments :

   134

            # compute rendered text size

   135

            seg_width, seg_height = font.getsize(seg_text)

   136

   137

            # update line_*

   138

            line_width += seg_width

   139

            line_height = max(line_height, seg_height)

   140

   141

            # build the new segments list

   142

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

   143

   144

        # update img_*

   145

        img_width = max(img_width, line_width)

   146

        img_height += line_height

   147

        img_data.append((line_segments, line_height))

   148

   149

    # calculate height needed for line spacing

   150

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

   151

   152

    # create image

   153

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

   154

    draw = ImageDraw.Draw(img)

   155

   156

    # draw text

   157

    img_y = 0

   158

    for segments, line_height in img_data :

   159

        img_x = 0

   160

   161

        # draw each segment build above, incremeing along img_x

   162

        for seg_text, seg_color, seg_width in segments :

   163

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

   164

   165

            img_x += seg_width

   166

   167

        img_y += line_height + line_spacing

   168

   169

    return img

   170

   171

def effect_sharpness (img, factor) :

   172

    """

   173

        Sharpen the image by the given factor

   174

    """

   175

   176

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

   177

   178

def build_png (img) :

   179

    """

   180

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

   181

    """

   182

   183

    # render PNG output

   184

    buf = StringIO()

   185

    img.save(buf, "png")

   186

    data = buf.getvalue()

   187

   188

    return data

   189

   190

def arg_bool (val) :

   191

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

   192

        return True

   193

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

   194

        return False

   195

    else :

   196

        raise ValueError(val)

   197

   198

def arg_color (val) :

   199

    if val.beginswith('#') :

   200

        int(val[1:], 16)

   201

   202

        return val

   203

    else :

   204

        raise ValueError(val)

   205

   206

def handle_request (req) :

   207

    # parse args

   208

    if 'text' in req.args :

   209

        text = req.args.getlist('text', unicode)

   210

    else :

   211

        text = Defaults.text

   212

   213

    if 'chars' in req.args :

   214

        chars = req.args.getlist('chars', unicode)

   215

    else :

   216

        chars = Defaults.chars

   217

   218

    if 'colors' in req.args :

   219

        colors = req.args.getlist('colors', arg_color)

   220

   221

    else :

   222

        colors = Defaults.line_colors

   223

   224

    font_name = req.args.get('font', Defaults.font_name)

   225

    font_size = req.args.get('font-size', Defaults.font_size, int)

   226

    background_color = req.args.get('background-color', Defaults.background_color, arg_color)

   227

    line_spacing = req.args.get('line-spacing', Defaults.line_spacing, int)

   228

    sharpness = req.args.get('sharpness', Defaults.sharpness, float)

   229

   230

    # put the chars in random order by default

   231

    if req.args.get('random-chars', True, arg_bool) :

   232

        chars = randomize(chars)

   233

   234

    # load/prep resources

   235

    data = build_data(text, chars, colors)

   236

    font = load_font(font_name, font_size)

   237

   238

    # render the image

   239

    img = render_img(data, font, background_color, line_spacing)

   240

   241

    img = effect_sharpness(img, sharpness)

   242

   243

    png_data = build_png(img)

   244

   245

    # build the response

   246

    response = werkzeug.Response(png_data, mimetype='image/png')

   247

   248

    return response

   249

   250

@werkzeug.Request.application

   251

def wsgi_application (request) :

   252

    """

   253

        Our werkzeug WSGI handler

   254

    """

   255

   256

    try :

   257

        # request -> response

   258

        response = handle_request(request)

   259

   260

        return response

   261

   262

    except HTTPException, e :

   263

        # return as HTTP response

   264

        return e

   265

   266

def main () :

   267

    handler = wsgiref.handlers.CGIHandler()

   268

    app = wsgi_application

   269

   270

    if debug :

   271

        # enable debugging

   272

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

   273

   274

    handler.run(app)

   275

   276

if __name__ == '__main__' :

   277

    main()

   278