1

#!/usr/bin/python2.5

     2

# Copyright 2009 Tero Marttila

     3

#

     4

#   This program is free software: you can redistribute it and/or modify

     5

#   it under the terms of the GNU General Public License as published by

     6

#   the Free Software Foundation, either version 3 of the License, or

     7

#   (at your option) any later version.

     8

#

     9

#   This program is distributed in the hope that it will be useful,

    10

#   but WITHOUT ANY WARRANTY; without even the implied warranty of

    11

#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12

#   GNU General Public License for more details.

    13

#

    14

#   You should have received a copy of the GNU General Public License

    15

#   along with this program.  If not, see <http://www.gnu.org/licenses/>.

    16

#

    17

    18

import werkzeug

    19

from werkzeug.exceptions import HTTPException

    20

    21

from PIL import Image, ImageDraw, ImageFont, ImageEnhance

    22

from cStringIO import StringIO

    23

import random, itertools, time, os.path

    24

    25

if not hasattr(itertools, 'izip_longest') :

    26

    27

    def izip_longest(*args, **kwds):

    28

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

    29

        fillvalue = kwds.get('fillvalue')

    30

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

    31

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

    32

        fillers = itertools.repeat(fillvalue)

    33

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

    34

        try:

    35

            for tup in itertools.izip(*iters):

    36

                yield tup

    37

        except IndexError:

    38

            pass

    39

    40

    itertools.izip_longest = izip_longest 

    41

    42

class Defaults :

    43

    # settings

    44

    45

    text_lang = 'en'

    46

    47

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

    48

    49

    colors = [

    50

        "#0469af",

    51

        "#fbc614",

    52

        "#e1313b",

    53

    ]

    54

    55

    font_name = 'helvetica'

    56

    font_size = 30

    57

    58

    bg_color = "#ffffff"

    59

    line_spacing = -10

    60

    sharpness = 0.6

    61

    62

    img_format = 'png'

    63

    64

TEXT_BY_LANG = dict(

    65

    en = [

    66

        u"aalto",

    67

        u"unive",

    68

        u"rsity"

    69

    ],

    70

    fi = [

    71

        u"aalto",

    72

        u"yliop",

    73

        u"isto"

    74

    ],

    75

    se = [

    76

        u"aalto",

    77

        u"univer",

    78

        u"sitetet",

    79

    ],

    80

)

    81

    82

STATIC_PATH = "static"

    83

    84

FONTS = {

    85

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

    86

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

    87

    }

    88

    89

IMAGE_FORMATS = {

    90

    'jpeg': 'jpeg',

    91

    'png':  'png',

    92

    'bmp':  'bmp'

    93

}

    94

    95

FONT_SIZE_MAX = 1024

    96

IMG_SIZE_MAX  = 1024

    97

    98

TILE_SIZE = (100, 100)

    99

   100

SITE_URL = "http://qmsk.net/stuff/aaltologo/"

   101

SOURCE_URL = "http://hg.qmsk.net/aaltologotin"

   102

   103

# enable debugging

   104

DEBUG = True

   105

   106

   107

def randomize (seq) :

   108

    """

   109

        Returns the given sequence in random order as a list

   110

    """

   111

   112

    # copy

   113

    l = list(seq)

   114

   115

    # rearrange

   116

    random.shuffle(l)

   117

   118

    return l

   119

   120

def randomize_str_char (str) :

   121

    """

   122

        Randomize the given string by moving one char around

   123

    """

   124

   125

    l = list(str)

   126

   127

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

   128

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

   129

   130

    return ''.join(l)

   131

   132

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

   133

    """

   134

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

   135

   136

        [ [ (str, str) ] ]

   137

   138

            text        - list of lines

   139

            chars       - list of random chars to interpse

   140

            line_colors - list of colors to draw the chars in

   141

            random_chars        - randomize the lines the chars go in

   142

            random_text         - randomize the chars in each line

   143

            random_text_char    - randomize each line by moving one char around

   144

    """

   145

   146

    data = []

   147

   148

    # if no chars given, don't insert any

   149

    if not chars :

   150

        chars = []

   151

   152

    # randomize char order across lines?

   153

    if random_chars :

   154

        chars = randomize(chars)

   155

   156

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

   157

        if not line :

   158

            continue

   159

   160

        # pick position to place char

   161

        if len(line) >= 2 :

   162

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

   163

        else :

   164

            pos = random.randint(0, 1)

   165

   166

        # default color

   167

        if not color :

   168

            color = "#000000"

   169

   170

        # randomize text in some way?

   171

        if random_text :

   172

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

   173

   174

        if random_text_char :

   175

            line = randomize_str_char(line)

   176

   177

        # split into three parts

   178

        if char :

   179

            data.append([

   180

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

   181

                    (char, color),

   182

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

   183

                ])

   184

        else :

   185

            data.append([

   186

                    (line, "#000000"),

   187

                ])

   188

   189

    return data

   190

   191

def load_font (font_name, font_size) :

   192

    """

   193

        Load a font by name

   194

    """

   195

   196

    # load font

   197

    font_path = FONTS[font_name]

   198

    font = ImageFont.truetype(font_path, font_size)

   199

   200

    return font

   201

   202

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

   203

    """

   204

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

   205

    """

   206

   207

    img_width = img_height = 0

   208

   209

    img_data = []

   210

   211

    # compute image/segment width/height

   212

    for segments in data :

   213

        line_width = line_height = 0

   214

   215

        # build a new list of segments with additional info

   216

        line_segments = []

   217

   218

        for seg_text, seg_color in segments :

   219

            # compute rendered text size

   220

            seg_width, seg_height = font.getsize(seg_text)

   221

   222

            # update line_*

   223

            line_width += seg_width

   224

            line_height = max(line_height, seg_height)

   225

   226

            # build the new segments list

   227

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

   228

   229

        # update img_*

   230

        img_width = max(img_width, line_width)

   231

        img_height += line_height

   232

        img_data.append((line_segments, line_height))

   233

   234

    if img_size :

   235

        # override size

   236

        img_width, img_height = img_size

   237

   238

    else :

   239

        # calculate height needed for line spacing

   240

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

   241

   242

    # create image

   243

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

   244

    draw = ImageDraw.Draw(img)

   245

   246

    # draw text

   247

    img_y = 0

   248

    for segments, line_height in img_data :

   249

        img_x = 0

   250

   251

        # draw each segment build above, incremeing along img_x

   252

        for seg_text, seg_color, seg_width in segments :

   253

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

   254

   255

            img_x += seg_width

   256

   257

        img_y += line_height + line_spacing

   258

   259

    return img

   260

   261

def effect_sharpness (img, factor) :

   262

    """

   263

        Sharpen the image by the given factor

   264

    """

   265

   266

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

   267

   268

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

   269

    """

   270

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

   271

   272

        Format should be one of the PIL-supported image foarts

   273

    """

   274

   275

    # render PNG output

   276

    buf = StringIO()

   277

    img.save(buf, format)

   278

    data = buf.getvalue()

   279

   280

    return data

   281

   282

class OptionType (object) :

   283

    def parse (self, val) :

   284

        """

   285

            Unicode value -> object

   286

        """

   287

   288

        abstract

   289

   290

    def build (self, val) :

   291

        """

   292

            object -> unicode value

   293

        """

   294

   295

        return unicode(val)

   296

   297

    def input (self, val) :

   298

        """

   299

            HTML input item

   300

        """

   301

   302

        abstract

   303

   304

class StringOption (OptionType) :

   305

    def parse (self, val) :

   306

        return unicode(val)

   307

   308

    def build (self, val) :

   309

        if val is None :

   310

            return ""

   311

   312

        else :

   313

            return val

   314

   315

    def input (self, opt, val) :

   316

        return """<input type="text" name="%(name)s" id="%(name)s" value="%(value)s" />""" % dict(

   317

            name        = opt.name,

   318

            value       = self.build(val),

   319

        )

   320

   321

    def select (self, opt, val) :

   322

        return """<select name="%(name)s">

   323

%(options)s

   324

</select>""" % dict(

   325

            name        = opt.name,

   326

            options     = '\n'.join(

   327

                "\t<option %(selected)s>%(value)s</option>" % dict(

   328

                    value       = self.build(optval),

   329

                    selected    = 'selected="selected"' if val == optval else "",

   330

                ) for optval in opt.range

   331

            ),

   332

        )

   333

   334

class BoolOption (OptionType) :

   335

    def parse (self, val) :

   336

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

   337

            return True

   338

   339

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

   340

            return False

   341

   342

        else :

   343

            raise ValueError(val)

   344

   345

    def input (self, opt, val) :

   346

        return """<input type="checkbox" name="%(name)s" id="%(name)s" %(checked)s/>""" % dict(

   347

            name        = opt.name,

   348

            checked     = 'checked="checked"' if val else '',

   349

        )

   350

   351

class IntOption (StringOption) :

   352

    def parse (self, val) :

   353

        return int(val)

   354

   355

class FloatOption (StringOption) :

   356

    def parse (self, val) :

   357

        return float(val)

   358

   359

class ColorOption (StringOption) :

   360

    def _parse (self, val) :

   361

        if val.startswith('#') :

   362

            int(val[1:], 16)

   363

   364

            return val

   365

        else :

   366

            raise ValueError(val)

   367

   368

   369

class Option (object) :

   370

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

   371

        self.name = name

   372

        self.is_list = is_list

   373

        self.type = type

   374

        self.default = default

   375

        self.range = range

   376

   377

    def parse (self, args, force_bool=False) :

   378

        if self.is_list :

   379

            if self.name in args :

   380

                l = args.getlist(self.name, self.type.parse)

   381

   382

                # special-case to handle a single param with a newline-separtated list

   383

                if len(l) == 1 :

   384

                    if not l[0] :

   385

                        return None

   386

   387

                    else :

   388

                        return l[0].split('\r\n')

   389

   390

                else :

   391

                    return l

   392

   393

            else :

   394

                return self.default

   395

   396

        else :

   397

            if isinstance(self.type, BoolOption) and force_bool :

   398

                return self.name in args

   399

   400

            elif isinstance(self.type, BoolOption) and not self.default and self.name in args :

   401

                return True

   402

   403

            else :

   404

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

   405

   406

    def build_list (self, value) :

   407

        if self.is_list and value :

   408

            return [self.type.build(val) for val in value]

   409

   410

        else :

   411

            return [self.type.build(value)]

   412

   413

    def _build_input (self, value) :

   414

        if self.is_list :

   415

            return """\

   416

<textarea name="%(name)s" cols="30">\

   417

%(data)s\

   418

</textarea>""" % dict(

   419

                name        = self.name,

   420

                data        = '\n'.join(self.type.build(val) for val in value) if value else '',

   421

            )

   422

   423

        elif self.range :

   424

            return self.type.select(self, value)

   425

   426

        else :

   427

            return self.type.input(self, value)

   428

   429

    def build_form (self, opts) :

   430

        value = opts[self.name]

   431

   432

        return """\

   433

<div class="param"><label for="%(name)s">%(title)s</label>%(input)s</div>\

   434

        """ % dict(

   435

            name        = self.name,

   436

            title       = self.name.title().replace('-', ' '),

   437

            input       = self._build_input(value)

   438

        )

   439

   440

class Options (object) :

   441

    def __init__ (self, *options) :

   442

        self.options = list(options)

   443

        self.options_by_name = dict((opt.name, opt) for opt in options)

   444

   445

    def parse (self, args, **kwargs) :

   446

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

   447

   448

OPTIONS = Options(

   449

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

   450

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

   451

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

   452

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

   453

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

   454

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

   455

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

   456

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

   457

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

   458

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

   459

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

   460

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

   461

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

   462

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

   465

)

   466

   467

def handle_generic (req, img_size=None) :

   468

    # parse options

   469

    opts = OPTIONS.parse(req.args)

   470

   471

    # postprocess

   472

    if opts['text'] is None :

   473

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

   474

   475

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

   476

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

   477

   478

    if opts['seed'] is None :

   479

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

   480

   483

   485

            raise ValueError(img_size)

   486

   487

    # load/prep resources

   488

    random.seed(opts['seed'])

   489

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

   490

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

   491

   492

    # render the image

   493

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

   494

   495

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

   496

   497

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