1

#!/usr/bin/python2.5

     2

import werkzeug

     3

from werkzeug.exceptions import HTTPException

     4

     5

from PIL import Image, ImageDraw, ImageFont, ImageEnhance

     6

from cStringIO import StringIO

     7

import random, itertools, time, os.path

     8

     9

if not hasattr(itertools, 'izip_longest') :

    10

    11

    def izip_longest(*args, **kwds):

    12

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

    13

        fillvalue = kwds.get('fillvalue')

    14

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

    15

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

    16

        fillers = itertools.repeat(fillvalue)

    17

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

    18

        try:

    19

            for tup in itertools.izip(*iters):

    20

                yield tup

    21

        except IndexError:

    22

            pass

    23

    24

    itertools.izip_longest = izip_longest 

    25

    26

class Defaults :

    27

    # settings

    28

    29

    text_lang = 'en'

    30

    31

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

    32

    33

    colors = [

    34

        "#0469af",

    35

        "#fbc614",

    36

        "#e1313b",

    37

    ]

    38

    39

    font_name = 'helvetica'

    40

    font_size = 30

    41

    42

    bg_color = "#ffffff"

    43

    line_spacing = -10

    44

    sharpness = 0.6

    45

    46

    img_format = 'png'

    47

    48

TEXT_BY_LANG = dict(

    49

    en = [

    50

        u"aalto",

    51

        u"unive",

    52

        u"rsity"

    53

    ],

    54

    fi = [

    55

        u"aalto",

    56

        u"yliop",

    57

        u"isto"

    58

    ],

    59

    se = [

    60

        u"aalto",

    61

        u"univer",

    62

        u"sitetet",

    63

    ],

    64

)

    65

    66

STATIC_PATH = "static"

    67

    68

FONTS = {

    69

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

    70

        'helvetica':            "fonts/HELR65W.TTF",

    71

    }

    72

    73

IMAGE_FORMATS = {

    74

    'jpeg': 'jpeg',

    75

    'jpg':  'jpeg',

    76

    'png':  'png',

    77

    'bmp':  'bmp'

    78

}

    79

    80

FONT_SIZE_MAX = 1024

    81

IMG_SIZE_MAX  = 1024

    82

    83

TILE_SIZE = (100, 100)

    84

    85

# enable debugging

    86

DEBUG = True

    87

    88

    89

def randomize (seq) :

    90

    """

    91

        Returns the given sequence in random order as a list

    92

    """

    93

    94

    # copy

    95

    l = list(seq)

    96

    97

    # rearrange

    98

    random.shuffle(l)

    99

   100

    return l

   101

   102

def randomize_str_char (str) :

   103

    """

   104

        Randomize the given string by moving one char around

   105

    """

   106

   107

    l = list(str)

   108

   109

    c = l.pop(random.randint(0, len(l) - 1))

   110

    l.insert(random.randint(0, len(l)), c)

   111

   112

    return ''.join(l)

   113

   114

def build_data (text, chars, line_colors, random_chars=True, random_text=False, random_text_char=False) :

   115

    """

   116

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

   117

   118

        [ [ (str, str) ] ]

   119

   120

            text        - list of lines

   121

            chars       - list of random chars to interpse

   122

            line_colors - list of colors to draw the chars in

   123

            random_chars        - randomize the lines the chars go in

   124

            random_text         - randomize the chars in each line

   125

            random_text_char    - randomize each line by moving one char around

   126

    """

   127

   128

    data = []

   129

   130

    if random_chars :

   131

        chars = randomize(chars)

   132

   133

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

   137

        # pick position to place char

   138

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

   139

   140

        if not color :

   141

            color = "#000000"

   142

   143

        if random_text :

   144

            line = ''.join(randomize(line))

   145

   146

        if random_text_char :

   147

            line = randomize_str_char(line)

   148

   149

        # split into three parts

   150

        if char :

   151

            data.append([

   152

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

   153

                    (char, color),

   154

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

   155

                ])

   156

        else :

   157

            data.append([

   158

                    (line, "#000000"),

   159

                ])

   160

   161

    return data

   162

   163

def load_font (font_name, font_size) :

   164

    """

   165

        Load a font by name

   166

    """

   167

   168

    # load font

   169

    font_path = FONTS[font_name]

   170

    font = ImageFont.truetype(font_path, font_size)

   171

   172

    return font

   173

   174

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

   175

    """

   176

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

   177

    """

   178

   179

    img_width = img_height = 0

   180

   181

    img_data = []

   182

   183

    # compute image/segment width/height

   184

    for segments in data :

   185

        line_width = line_height = 0

   186

   187

        # build a new list of segments with additional info

   188

        line_segments = []

   189

   190

        for seg_text, seg_color in segments :

   191

            # compute rendered text size

   192

            seg_width, seg_height = font.getsize(seg_text)

   193

   194

            # update line_*

   195

            line_width += seg_width

   196

            line_height = max(line_height, seg_height)

   197

   198

            # build the new segments list

   199

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

   200

   201

        # update img_*

   202

        img_width = max(img_width, line_width)

   203

        img_height += line_height

   204

        img_data.append((line_segments, line_height))

   205

   206

    if img_size :

   207

        # override size

   208

        img_width, img_height = img_size

   209

   210

    else :

   211

        # calculate height needed for line spacing

   212

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

   213

   214

    # create image

   215

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

   216

    draw = ImageDraw.Draw(img)

   217

   218

    # draw text

   219

    img_y = 0

   220

    for segments, line_height in img_data :

   221

        img_x = 0

   222

   223

        # draw each segment build above, incremeing along img_x

   224

        for seg_text, seg_color, seg_width in segments :

   225

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

   226

   227

            img_x += seg_width

   228

   229

        img_y += line_height + line_spacing

   230

   231

    return img

   232

   233

def effect_sharpness (img, factor) :

   234

    """

   235

        Sharpen the image by the given factor

   236

    """

   237

   238

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

   239

   240

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

   241

    """

   242

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

   243

   244

        Format should be one of the PIL-supported image foarts

   245

    """

   246

   247

    # render PNG output

   248

    buf = StringIO()

   249

    img.save(buf, format)

   250

    data = buf.getvalue()

   251

   252

    return data

   253

   254

def arg_bool (val) :

   255

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

   256

        return True

   257

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

   258

        return False

   259

    else :

   260

        raise ValueError(val)

   261

   262

def arg_color (val) :

   263

    if val.beginswith('#') :

   264

        int(val[1:], 16)

   265

   266

        return val

   267

    else :

   268

        raise ValueError(val)

   269

   270

class Option (object) :

   271

    def __init__ (self, name, is_list, type, default, range) :

   272

        self.name = name

   273

        self.is_list = is_list

   274

        self.type = type

   275

        self.default = default

   276

        self.range = range

   277

   278

    def parse (self, args) :

   279

        if self.is_list :

   280

            if self.name in args :

   281

                return args.getlist(self.name, self.type)

   282

            else :

   283

                return self.default

   284

        else :

   285

            if self.type == arg_bool and not self.default and self.name in args :

   286

                return True

   287

   288

            else :

   289

                return args.get(self.name, self.default, self.type)

   290

   291

class Options (object) :

   292

    def __init__ (self, *options) :

   293

        self.options = options

   294

   295

    def parse (self, args) :

   296

        return dict((opt.name, opt.parse(args)) for opt in self.options)

   297

   298

OPTIONS = Options(

   299

    Option('lang',          False,  str,        Defaults.text_lang,     TEXT_BY_LANG.keys()),

   300

    Option('text',          True,   unicode,    None,                   None),

   301

    Option('random-text',   False,  arg_bool,   False,                  None),

   302

    Option('random-text-char', False, arg_bool, False,                  None),

   303

    Option('chars',         True,   unicode,    Defaults.chars,         None),

   304

    Option('random-chars',  False,  arg_bool,   True,                   None),

   305

    Option('colors',        True,   arg_color,  Defaults.colors,        None),

   306

    Option('font',          False,  str,        Defaults.font_name,     FONTS.keys()),

   307

    Option('font-size',     False,  int,        Defaults.font_size,     None),

   308

    Option('bg-color',      False,  arg_color,  Defaults.bg_color,      None),

   309

    Option('line-spacing',  False,  int,        Defaults.line_spacing,  None),

   310

    Option('sharpness',     False,  float,      Defaults.sharpness,     None),

   311

    Option('image-format',  False,  str,        Defaults.img_format,    IMAGE_FORMATS.keys()),

   312

    Option('seed',          False,  int,        None,                   None),

   313

    Option('img_width',     False,  int,        None,                   None),

   314

    Option('img_height',    False,  int,        None,                   None),

   315

)

   316

   317

def handle_generic (req, img_size=None) :

   318

    # parse options

   319

    opts = OPTIONS.parse(req.args)

   320

   321

    # postprocess

   322

    if opts['text'] is None :

   323

        opts['text'] = TEXT_BY_LANG[opts['lang']]

   324

   325

    if opts['font-size'] > FONT_SIZE_MAX :

   326

        raise ValueError(opts['font-size'])

   327

   328

    if opts['seed'] is None :

   329

        opts['seed'] = time.time()

   330

   331

    if opts['img_width'] and opts['img_height'] :

   332

        img_size = (opts['img_width'], opts['img_height'])

   333

   334

        if opts['img_width'] > IMG_SIZE_MAX or opts['img_height'] > IMG_SIZE_MAX :

   335

            raise ValueError(img_size)

   336

   337

    # load/prep resources

   338

    random.seed(opts['seed'])

   339

    data = build_data(opts['text'], opts['chars'], opts['colors'], opts['random-chars'], opts['random-text'], opts['random-text-char'])

   340

    font = load_font(opts['font'], opts['font-size'])

   341

   342

    # render the image

   343

    img = render_img(data, font, opts['bg-color'], opts['line-spacing'], img_size)

   344

   345

    img = effect_sharpness(img, opts['sharpness'])

   346

   347

    png_data = build_img(img, opts['image-format'])

   348

   349

    # build the response

   350

    response = werkzeug.Response(png_data, mimetype='image/%s' % opts['image-format'])

   351

   352

    return response

   353

   354

def handle_help (req) :

   355

    return werkzeug.Response('\n'.join(

   356

        "%-15s %4s  %-10s %-20s %s" % data for data in [

   357

            ("name", "", "type", "default", "range"),

   358

            ("", "", "", "", ""),

   359

        ] + [(

   360

            opt.name, 

   361

            'list' if opt.is_list else 'item', 

   362

            opt.type.__name__, 

   363

            repr(opt.default), 

   364

            opt.range if opt.range else ""

   365

        ) for opt in OPTIONS.options]

   366

    ), mimetype='text/plain')

   367

   368

def handle_logo (req) :

   369

    if 'help' in req.args :

   370

        return handle_help(req)

   371

   372

    return handle_generic(req)

   373

   374

def handle_tile (req) :

   375

    return handle_generic(req, img_size=TILE_SIZE)

   376

   377

def handle_request (req) :

   378

    if req.path == '/' or req.path.startswith('/logo.') :

   379

        return handle_logo(req)

   380

   381

    elif req.path == '/tile' :

   382

        return handle_tile(req)

   383

   384

    else :

   385

        raise ValueError(req)

   386

   387

@werkzeug.Request.application

   388

def wsgi_application (request) :

   389

    """

   390

        Our werkzeug WSGI handler

   391

    """

   392

   393

    try :

   394

        # request -> response

   395

        response = handle_request(request)

   396

   397

        return response

   398

   399

    except HTTPException, e :

   400

        # return as HTTP response

   401

        return e

   402

   403

def build_app () :

   404

    """

   405

        Build and return a WSGI application

   406

    """

   407

   408

    app = wsgi_application

   409

   410

    # add other middleware

   411

    app = werkzeug.SharedDataMiddleware(app, {

   412

        '/static': STATIC_PATH,

   413

    })

   414

   415

   416

    if DEBUG :

   417

        # enable debugging

   418

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

   419

   420

    return app

   421

   422

def main_cgi (app) :

   423

    import wsgiref.handlers

   424

   425

    handler = wsgiref.handlers.CGIHandler()

   426

    handler.run(app)

   427

   428

def main_fastcgi (app) :

   429

    import flup.server.fcgi

   430

   431

    server = flup.server.fcgi.WSGIServer(app,

   432

        multithreaded   = False,

   433

        multiprocess    = False,

   434

        multiplexed     = False,

   435

   436

        bindAddress     = None,

   437

   438

        umask           = None,

   439

        debug           = True,

   440

    )

   441

   442

    server.run()

   443

   444

def main () :

   445

    from sys import argv

   446

   447

    # get our file extension

   448

    root, ext = os.path.splitext(argv[0])

   449

   450

    # get our handler

   451

    handler = {

   452

        '.cgi':     main_cgi,

   453

        '.fcgi':    main_fastcgi,

   454

    }[ext]

   455

   456

    # get our app

   457

    app = build_app()

   458

   459

    # run

   460

    handler(app)

   461

   462

if __name__ == '__main__' :

   463

    main()

   464