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

# monkeypatch 2.5 to add missing 2.6 features

    26

if not hasattr(itertools, 'izip_longest') :

    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

    """

    44

        Default values for parameters

    45

    """

    46

    47

    text_lang = 'en'

    48

    49

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

    50

    51

    colors = [

    52

        "#0469af",

    53

        "#fbc614",

    54

        "#e1313b",

    55

    ]

    56

    57

    font_name = 'helvetica'

    58

    font_size = 30

    59

    60

    bg_color = "#ffffff"

    61

    line_spacing = -10

    62

    sharpness = 0.6

    63

    64

    img_format = 'png'

    65

    66

TEXT_BY_LANG = dict(

    67

    en = [

    68

        u"aalto",

    69

        u"unive",

    70

        u"rsity"

    71

    ],

    72

    fi = [

    73

        u"aalto",

    74

        u"yliop",

    75

        u"isto"

    76

    ],

    77

    se = [

    78

        u"aalto",

    79

        u"univer",

    80

        u"sitetet",

    81

    ],

    82

)

    83

    84

STATIC_PATH = "static"

    85

    86

FONTS = {

    87

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

    88

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

    89

    }

    90

    91

IMAGE_FORMATS = {

    92

    'jpeg': 'jpeg',

    93

    'png':  'png',

    94

    'bmp':  'bmp'

    95

}

    96

    97

FONT_SIZE_MAX = 1024

    98

IMG_SIZE_MAX  = 1024

    99

   100

TILE_SIZE = (100, 100)

   101

   102

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

   103

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

   104

   105

# enable debugging

   106

DEBUG = True

   107

   108

   109

def randomize (seq) :

   110

    """

   111

        Returns the given sequence in random order as a list

   112

    """

   113

   114

    # copy

   115

    l = list(seq)

   116

   117

    # rearrange

   118

    random.shuffle(l)

   119

   120

    return l

   121

   122

def randomize_str_char (str) :

   123

    """

   124

        Randomize the given string by moving one char around

   125

    """

   126

   127

    l = list(str)

   128

   129

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

   130

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

   131

   132

    return ''.join(l)

   133

   134

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

   135

    """

   136

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

   137

   138

        [ [ (str, str) ] ]

   139

   140

            text        - list of lines

   141

            chars       - list of random chars to interpse

   142

            line_colors - list of colors to draw the chars in

   143

            random_chars        - randomize the lines the chars go in

   144

            random_text         - randomize the chars in each line

   145

            random_text_char    - randomize each line by moving one char around

   146

    """

   147

   148

    data = []

   149

   150

    # if no chars given, don't insert any

   151

    if not chars :

   152

        chars = []

   153

   154

    # randomize char order across lines?

   155

    if random_chars :

   156

        chars = randomize(chars)

   157

   158

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

   159

        if not line :

   160

            continue

   161

   162

        # pick position to place char

   163

        if len(line) >= 2 :

   164

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

   165

        else :

   166

            pos = random.randint(0, 1)

   167

   168

        # default color

   169

        if not color :

   170

            color = "#000000"

   171

   172

        # randomize text in some way?

   173

        if random_text :

   174

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

   175

   176

        if random_text_char :

   177

            line = randomize_str_char(line)

   178

   179

        # split into three parts

   180

        if char :

   181

            data.append([

   182

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

   183

                    (char, color),

   184

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

   185

                ])

   186

        else :

   187

            data.append([

   188

                    (line, "#000000"),

   189

                ])

   190

   191

    return data

   192

   193

def load_font (font_name, font_size) :

   194

    """

   195

        Load a font by name

   196

    """

   197

   198

    # load font

   199

    font_path = FONTS[font_name]

   200

    font = ImageFont.truetype(font_path, font_size)

   201

   202

    return font

   203

   204

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

   205

    """

   206

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

   207

    """

   208

   209

    img_width = img_height = 0

   210

   211

    img_data = []

   212

   213

    # compute image/segment width/height

   214

    for segments in data :

   215

        line_width = line_height = 0

   216

   217

        # build a new list of segments with additional info

   218

        line_segments = []

   219

   220

        for seg_text, seg_color in segments :

   221

            # compute rendered text size

   222

            seg_width, seg_height = font.getsize(seg_text)

   223

   224

            # update line_*

   225

            line_width += seg_width

   226

            line_height = max(line_height, seg_height)

   227

   228

            # build the new segments list

   229

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

   230

   231

        # update img_*

   232

        img_width = max(img_width, line_width)

   233

        img_height += line_height

   234

        img_data.append((line_segments, line_height))

   235

   236

    if img_size :

   237

        # override size

   238

        img_width, img_height = img_size

   239

   240

    else :

   241

        # calculate height needed for line spacing

   242

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

   243

   244

    # create image

   245

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

   246

    draw = ImageDraw.Draw(img)

   247

   248

    # draw text

   249

    img_y = 0

   250

    for segments, line_height in img_data :

   251

        img_x = 0

   252

   253

        # draw each segment build above, incremeing along img_x

   254

        for seg_text, seg_color, seg_width in segments :

   255

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

   256

   257

            img_x += seg_width

   258

   259

        img_y += line_height + line_spacing

   260

   261

    return img

   262

   263

def effect_sharpness (img, factor) :

   264

    """

   265

        Sharpen the image by the given factor

   266

    """

   267

   268

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

   269

   270

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

   271

    """

   272

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

   273

   274

        Format should be one of the PIL-supported image foarts

   275

    """

   276

   277

    # render PNG output

   278

    buf = StringIO()

   279

    img.save(buf, format)

   280

    data = buf.getvalue()

   281

   282

    return data

   283

   284

class OptionType (object) :

   285

    def parse (self, val) :

   286

        """

   287

            Unicode value -> object

   288

        """

   289

   290

        abstract

   291

   292

    def build (self, val) :

   293

        """

   294

            object -> unicode value

   295

        """

   296

   297

        return unicode(val)

   298

   299

    def input (self, val) :

   300

        """

   301

            HTML input item

   302

        """

   303

   304

        abstract

   305

   306

class StringOption (OptionType) :

   307

    def parse (self, val) :

   308

        return unicode(val)

   309

   310

    def build (self, val) :

   311

        if val is None :

   312

            return ""

   313

   314

        else :

   315

            return val

   316

   317

    def input (self, opt, val) :

   318

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

   319

            name        = opt.name,

   320

            value       = self.build(val),

   321

        )

   322

   323

    def select (self, opt, val) :

   324

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

   325

%(options)s

   326

</select>""" % dict(

   327

            name        = opt.name,

   328

            options     = '\n'.join(

   329

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

   330

                    value       = self.build(optval),

   331

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

   332

                ) for optval in opt.range

   333

            ),

   334

        )

   335

   336

class BoolOption (OptionType) :

   337

    def parse (self, val) :

   338

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

   339

            return True

   340

   341

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

   342

            return False

   343

   344

        else :

   345

            raise ValueError(val)

   346

   347

    def input (self, opt, val) :

   348

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

   349

            name        = opt.name,

   350

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

   351

        )

   352

   353

class IntOption (StringOption) :

   354

    def parse (self, val) :

   355

        return int(val)

   356

   357

class FloatOption (StringOption) :

   358

    def parse (self, val) :

   359

        return float(val)

   360

   361

class ColorOption (StringOption) :

   362

    def _parse (self, val) :

   363

        if val.startswith('#') :

   364

            int(val[1:], 16)

   365

   366

            return val

   367

        else :

   368

            raise ValueError(val)

   369

   370

   371

class Option (object) :

   372

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

   373

        self.name = name

   374

        self.is_list = is_list

   375

        self.type = type

   376

        self.default = default

   377

        self.range = range

   378

   379

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

   380

        if self.is_list :

   381

            if self.name in args :

   382

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

   383

   384

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

   385

                if len(l) == 1 :

   386

                    if not l[0] :

   387

                        return None

   388

   389

                    else :

   391

   392

                else :

   393

                    return l

   394

   395

            else :

   396

                return self.default

   397

   398

        else :

   399

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

   400

                return self.name in args

   401

   402

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

   403

                return True

   404

   405

            else :

   406

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

   407

   408

    def build_list (self, value) :

   409

        if self.is_list and value :

   410

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

   411

   412

        else :

   413

            return [self.type.build(value)]

   414

   415

    def _build_input (self, value) :

   416

        if self.is_list :

   417

            return """\

   418

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

   419

%(data)s\

   420

</textarea>""" % dict(

   421

                name        = self.name,

   422

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

   423

            )

   424

   425

        elif self.range :

   426

            return self.type.select(self, value)

   427

   428

        else :

   429

            return self.type.input(self, value)

   430

   431

    def build_form (self, opts) :

   432

        value = opts[self.name]

   433

   434

        return """\

   435

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

   436

        """ % dict(

   437

            name        = self.name,

   438

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

   439

            input       = self._build_input(value)

   440

        )

   441

   442

class Options (object) :

   443

    def __init__ (self, *options) :

   444

        self.options = list(options)

   445

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

   446

   447

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

   448

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

   449

   450

OPTIONS = Options(

   451

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

   452

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

   453

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

   454

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

   455

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

   456

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

   457

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

   458

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

   459

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

   460

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

   461

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

   462

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

   463

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

   464

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

   465

    Option('img-width',     False,  IntOption(),    None,                   None),

   466

    Option('img-height',    False,  IntOption(),    None,                   None),

   467

)

   468

   469

def handle_generic (req, img_size=None) :

   470

    # parse options

   471

    opts = OPTIONS.parse(req.args)

   472

   473

    # postprocess

   474

    if opts['text'] is None :

   475

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

   476

   477

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

   478

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

   479

   480

    if opts['seed'] is None :

   481

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

   482

   483

    if opts['img-width'] and opts['img-height'] :

   484

        img_size = (opts['img-width'], opts['img-height'])

   485

   486

        if opts['img-width'] > IMG_SIZE_MAX or opts['img-height'] > IMG_SIZE_MAX :

   487

            raise ValueError(img_size)

   488

   489

    # load/prep resources

   490

    random.seed(opts['seed'])

   491

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

   492

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

   493

   494

    # render the image

   495

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

   496

   497

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