Simple way to create png image with an input text.

First you need to have the PIL python module and import this.

from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
from PIL import ImageFilter

Next will be this function.Basically will make and return one RGBA image data type.

def make_img(image, textColor, backgroundColor):
  img = image.convert("RGBA")
  img.putdata([textColor if value == 0 else backgroundColor 
                   for value in image.getdata()])
  return img

The next step is to set the text , font and the new image.

I use Arggotsc.ttf. You can use any TrueType font.

text = " Inca un script in python! "
font = ImageFont.truetype('Arggotsc.ttf', 55)
image = Image.new("1", font.getsize(text), '#FFF')

Now we can draw, add text, resize, bur the text and finally save the image.

draw = ImageDraw.Draw(image)
draw.text((0, 0), text, font=font)
image = image.resize([i for i in image.size], Image.NEAREST)
imgText = make_img(image, (200, 200, 200), (0, 0, 0, 0))
blur_img = make_img(image, (0, 0, 0), (0, 0, 0, 0))
for i in range(3): 
  blur_img = blur_img.filter(ImageFilter.BLUR)
blur_img.paste(imgText, (0, 0), imgText)
blur_img.save("text-img.png")

The result is:

See you later with another tutorial.

Using pip for installing and managing Python packages.

An easy_install replacement is pip.

So pip installs packages and managing Python packages.

Let's try to install packages.

$ pip install PyOpenGL_accelerate
bash: pip: command not found 

Install the pip package.

The recommended way to use pip is within virtualenv, since every virtualenv has pip installed in it automatically.

[free-tutorials@free-tutorials ~]$ 
curl -O https://raw.github.com/pypa/virtualenv/master/virtualenv.py
...
[free-tutorials@free-tutorials ~]$ python virtualenv.py my_new_env
New python executable in my_new_env/bin/python
Installing setuptools............................done.
Installing pip.....................done.
[free-tutorials@free-tutorials ~]$ . my_new_env/bin/activate
(my_new_env)[free-tutorials@free-tutorials ~]$ pip --help

Let's try again with PyOpenGL and PyOpenGL_accelerate packages.

(my_new_env)[free-tutorials@free-tutorials ~]$
 pip install PyOpenGL PyOpenGL_accelerate
Downloading/unpacking PyOpenGL
  Downloading PyOpenGL-3.0.2.tar.gz (891kB): 891kB downloaded
  Running setup.py egg_info for package PyOpenGL
      ....
      

Now we can test this two packages.First is PyOpenGL.

(my_new_env)[free-tutorials@free-tutorials ~]$ python 
Python 2.7.3 (default, Dec  6 2012, 03:02:26) 
[GCC 4.3.2 20081105 (Red Hat 4.3.2-7)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import OpenGL
>>> dir(OpenGL)

...and PyOpenGL_accelerate:

(my_new_env)[free-tutorials@free-tutorials ~]$ python 
Python 2.7.3 (default, Dec  6 2012, 03:02:26) 
[GCC 4.3.2 20081105 (Red Hat 4.3.2-7)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import OpenGL_accelerate
>>> dir(OpenGL_accelerate)

This is working only on my_new_env.

That is all for now. I will try to do some examples with this packages.

About new release - Python 3.3.0

The new Python 3.3.0 was released on September 29th, 2012.

It's been two weeks since it was launched last version of python and I don't have found complaints about this release.

We can read more about updates and changes made by developers here.

What I think it's more significantly to this version:

• The new "faulthandler" module that helps diagnosing crashes
• The new "unittest.mock" module
• The new "ipaddress" module
• The "sys.implementation" attribute
• A policy framework for the email package, with a provisional (see PEP 411) policy that adds much improved unicode support for email header parsing
• A "collections.ChainMap" class for linking mappings to a single unit
• Wrappers for many more POSIX functions in the "os" and "signal" modules, as well as other useful functions such as "sendfile()"
• Hash randomization, introduced in earlier bugfix releases, is now switched on by default
• A C implementation of the "decimal" module, with up to 120x speedup for decimal-heavy applications
• The import system (__import__) is based on importlib by default
• The new "lzma" module with LZMA/XZ support
• PEP 397, a Python launcher for Windows
• PEP 405, virtual environment support in core

Let's see how to working the new Python 3.3.0

First download it , unzip and install it. See next:

/Python-3.3.0 $ ./configure 
checking build system type... i686-pc-linux-gnu
checking host system type... i686-pc-linux-gnu
checking for --enable-universalsdk... no
checking for --with-universal-archs... 32-bit
checking MACHDEP... linux
checking for --without-gcc... 

The next step is ...

$ make all

And finally ...

# su 
# ./python setup.py build
running build
running build_ext
INFO: Can't locate Tcl/Tk libs and/or headers

Python build finished, but the necessary bits to build these modules were not found:
_bz2               _dbm               _gdbm           
_lzma              _sqlite3           _ssl            
_tkinter           readline                           
To find the necessary bits, look in setup.py in detect_modules() for the module's name.

I will use it without this modules, until I find a way to fix it.

$ ./python 
Python 3.3.0 (default, Oct 14 2012, 21:42:00) 
[GCC 4.4.1] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 
>>> import ipaddress

Tuples can put you in difficulty.

They are two examples of sequence data types in python.

Today I will tell about tuples.

A tuple consists of a number of values separated by commas.

The biggest problem is when we do not know the number of these values ​​or type.

Let me illustrate with a function that returns a tuple.

This is a known tuple but we will use like an unknown tuple.

Let's see the python code and some errors:

>>> import sys
>>> if hasattr(sys, 'version_info'):
...     print sys.version_info()
... 
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
TypeError: 'tuple' object is not callable

Is very correct to got this error.

And the result using the print function:

>>> if hasattr(sys, 'version_info'):
...     print "%s" % str(sys.version_info)
... 
(2, 6, 4, 'final', 0) 

>>> if hasattr(sys, 'version_info'):
...     sys.stderr.write("%s" % str(sys.version_info))
... 
(2, 6, 4, 'final', 0)>>> 

or if you can use the repr function.

>>> if hasattr(sys, 'version_info'):
...     sys.stderr.write("%s" % repr(sys.version_info))
... 
(2, 6, 4, 'final', 0)>>> 

The official Python documentation says __repr__ is used to compute the “official” string representation of an object and __str__ is used to compute the “informal” string representation of an object.

In my opinion , the correct way it's to use repr. For example:

>>> import datetime
>>> today = datetime.datetime.now()
>>> str(today)
'2012-10-02 22:45:57.634977'
>>> repr(today)
'datetime.datetime(2012, 10, 2, 22, 45, 57, 634977)'

As we see all values from tuples it's show.

Setting up Vim to work with Python - part 2

You can customize Vim for editing a specific file.

In this case is our python script files.

To do that you can use modelines, or auto commands, or filetype plugins.

For example , if you want to see the number on rows then just set the boolean number option to true.

set number

The keys PageUp and PageDown are mapped to Ctr+U and Ctr+D.

The next changes of the vimrc file will move cursor only by half of screen.

map <PageUp> <C-U>
map <PageDown> <C-D>
imap <PageUp> <C-O><C-U>
imap <PageDown> <C-O><C-D>

To move the cursor to the end of the screen they have to be triggered twice:

map <PageUp> <C-U><C-U>
map <PageDown> <C-D><C-D>
imap <PageUp> <C-O><C-U><C-O><C-U>
imap <PageDown> <C-O><C-D><C-O><C-D>

Then you can add next line to prevent the cursor from changing the current column when jumping to other lines within the window.

set nostartofline

To add some lines on your python file.

For example many python files start with this:

#!/usr/bin/env python 
#-*- coding: utf-8 -*-

Just add the next line in your vimrc file.

:iabbrev newpy  #!/usr/bin/env python <cr>#-*- coding: utf-8 -*-

On your first line from your python file in the insert mode , write newpy and press Enter key.

Also will be a good idea to take a look at the official .vimrc for following PEP 7 & 8 conventions.

...and the result of this changes.

Setting up Vim to work with Python - part 1

You need to use mercurial.

Mercurial is a free, distributed source control management tool.

It is mainly implemented using the Python programming language and C.

To use it , just see the next command.

# hg clone https://vim.googlecode.com/hg/ vim 
requesting all changes
adding changesets
adding manifests
adding file changes
added 3831 changesets with 24526 changes to 2566 files (+2 heads)
updating working directory
2385 files updated, 0 files merged, 0 files removed, 0 files unresolved

Go to vim folder.

# cd vim/src/

Use configure to builds a Makefile file.

src # ./configure --enable-pythoninterp --with-features=huge --prefix=$HOME/opt/vim
configure: creating cache auto/config.cache
checking whether make sets $(MAKE)... yes
checking for gcc... gcc
checking whether the C compiler works... yes
...

The next commands make builds the program and make install to install the program.

src # make && make install
mkdir objects
...

Now let's try to make working well.

src # mkdir -p $HOME/bin
src # cd $HOME/bin
bin # ls
vim
bin # ln -s $HOME/opt/vim/bin/vim
bin # ls
vim
bin # which vim
/usr/bin/vim
bin # vim --version 
VIM - Vi IMproved 7.2 (2008 Aug 9, compiled Sep 21 2009 11:22:49)
Included patches: 1-245

If you read all the output , will see something like this:

+profile +python +quickfix 

The main goal is to use vimrc.

For example you cand do this.

" Wrapping and tabs spaces.
set tw=78 ts=4 sw=4 sta et sts=4 ai

" Update syntax highlighting.
let python_highlight_all = 1

" Create smart indenting
set smartindent cinwords=if,elif,else,for,while,try,except,finally,def,class

" Auto completion using ctrl-space
set omnifunc=pythoncomplete#Complete
inoremap <nul> <C-x><C-o>

With just few lines can change and improve your work.

How to compile your python script .

There're situations when we want to compile the python script.

In this case , we have a python script named your_script.py.

The next script code will make one new your_script.pyc file.

import py_compile
py_compile.compile('your_script.py')

Note: this will hide the python code, but some strings can be view.

For example , if you use this in your_script.py.

print 'This is a string'

The string This is a string can be show in pyc file.

Simple python script - Voronoi diagram

Today I show you how to make Voronoi diagram using python.

I use this to make textures for underwater.

This is just one example. But you can improve to control all cells of voronoi diagram.

The theory say:

In mathematics, a Voronoi diagram is a special kind of decomposition of a metric space, determined by distances to a specified family of objects (subsets) in the space. These objects are usually called the sites or the generators...Source : wikipedia.

I used the euclidean distance to make the Voronoi diagram because it's the most familiar case.

About wikipedia - Euclidean_distance: In mathematics, the Euclidean distance or Euclidean metric is the "ordinary" distance between two points that one would measure with a ruler, and is given by the Pythagorean formula...

My python script use the next python modules:

PIL - this allow me to use image functions.

random - this module give me... random numbers.

math - some math functions.

Let's see the source code :

from PIL import Image
import random
import math

Now I make the function named gen_voronoi.

This take the height and width of the output image and the number of cells.

The function has some random variables for red , green , blue - nr,ng,nb.

The function hypot is not accessible directly so we need to import math module and using math static object.

The return value is the Euclidean norm : sqrt(x*x + y*y).

def gen_voronoi(w, h, cells):
 image = Image.new("RGB", (w, h))
 putpixel = image.putpixel
 img_x, img_y = image.size
 nx = []
 ny = []
 nr = []
 ng = []
 nb = []
 for i in range(cells):
  nx.append(random.randrange(img_x))
  ny.append(random.randrange(img_y))
  nr.append(random.randrange(256))
  ng.append(random.randrange(256))
  nb.append(random.randrange(256))
 for y in range(img_y):
  for x in range(img_x):
   dmin = math.hypot(img_x-1, img_y-1)
   j = -1
   for i in range(cells):
    d = math.hypot(nx[i]-x, ny[i]-y)
    if d < dmin:
     dmin = d
     j = i
   putpixel((x, y), (nr[j], ng[j], nb[j]))
 image.save("output.png", "PNG")
 image.show()

Use the function to make the output.png image.

gen_voronoi(200, 200, 55)

The result is :

Python script using OpenCV to detect / recognition faces on photos

This is old tutorial make long time ago by me to detect faces on photos.

If you know more about OpenCV module , then is easy to understand source code.

First I load the modules:

import opencv.cv as cv
import opencv.highgui as gui
import opencv

Next I set the variables and data blocks processed some particular features of the modules loaded.

hc = cv.cvLoad("haarcascade_frontalface_default.xml")
img = gui.cvLoadImage("me.jpg",cv.CV_BGR2RGB)
storage = cv.cvCreateMemStorage(0)
cascade = cv.cvLoadHaarClassifierCascade('haarcascade_frontalface_alt.xml',cv.cvSize(1, 1))
grayscale = cv.cvCreateImage(cv.cvSize(img.width, img.height), 8, 1)
cv.cvCvtColor(img, grayscale, cv.CV_BGR2GRAY)

This is part where is detect faces and save the output like a jpeg image.

faces = cv.cvHaarDetectObjects(grayscale, cascade,\ 
storage,1.2,2,cv.CV_HAAR_DO_CANNY_PRUNING, cv.cvSize(5, 5))

if faces:
 for i in faces:
  cv.cvRectangle(img, cv.cvPoint( int(i.x), int(i.y)),cv.cvPoint(int(i.x + i.width), int(i.y + i.height)),cv.CV_RGB(0, 255, 0), 3, 8, 0)
gui.cvSaveImage("faces_detected.jpg", img)

The haarcascade_frontalface_default.xml file it's from internet, but you can create one if you want.

Maybe in the next tutorial I will show how.

Let's see the result. The input image file is:

... and the result is:

The new tutorial about pstats python module.

Today I make a new tutorial about pstats python module.

The pstats module is a statistics browser for reading and examining profiler program.

This is provided in the modules cProfile, profile and pstats.

Because it's a long tutorial with long row , I put this tutorial on my tutorials website.

You can find it here on Python section.

Python 3.2 : Start with Django 1.4.

Although most of us prefer the python version 2.6, today I tried to install the latest version of django and python 2.3.2 .
Make a new folder , named test-dj .

$mkdir test-dj
$cd test-dj/

On the official site, I got the two archives:

django-django-1.4-919-ge57338f.zip
Python-3.2.3.tar.bz2

I will start with the installation of python. We unzip the archive:

$tar xvjf Python-3.2.3.tar.bz2 

We execute the following commands to install python:

$cd Python-3.2.3
$./configure
$make all
$sudo make altinstall
# python3.2 setup.py install 

Let's see what we have.

$ whereis  python3
python3: /usr/lib/python3.0 /usr/local/bin/python3.2m-config
/usr/local/bin/python3.2 /usr/local/bin/python3.2m 
/usr/local/lib/python3.2

As you see it's ...

python3.2
python3.2m
python3.2m-config

In accordance with the PEP-3149 we can got this:
Python implementations MAY include additional flags in the file name tag as appropriate. For example, on POSIX systems these flags will also contribute to the file name:

        * --with-pydebug (flag: d)
        * --with-pymalloc (flag: m)
        * --with-wide-unicode (flag: u)

Now we need to install django.

$unzip django-django-1.4-919-ge57338f.zip

Go to the django folder:

$cd django-django-e57338f/
# python3.2 setup.py install 

Now , we can test it:

# python3.2
Python 3.2.3 (default, Aug 24 2012, 19:24:21) 
[GCC 4.4.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import django 
>>> print(django.get_version())
1.5
>>> 

I will make another tutorial about how to configure the django to have one website.

Access system version information using python platform module.

The platform module includes the tools to take some infos about operating system, and hardware platform where a program is running.

import platform
dir(platform)

Show all about this module.

Also you can use the help.

help(platform)

Let's try another

print platform.win32_ver()
('', '', '', '')

So is not Windosw OS.

print platform.system()
Linux

Can be 'Linux', 'Windows' or 'Java' ...

print platform.version()

Show you the system's release version ( can be Debian , Ubuntu , Fedora ).

print platform.architecture()
('32bit', 'ELF')

print platform.uname()

Show the infos like uname linux command.

print platform.release()

Show the kernel use by system.

print platform.machine()
i686

print platform.node()

Show the computer's network name.

print platform.linux_distribution()

Show you the linux distribution.

Create tile image for your game using python script

What is tile image?
Tile image is a method of storing a sequence of images placed in a single image file.
These images are then processed according to user needs.
Here's an example below:

How we can create these images?
We can use graphics editing software to create them separately.
I used Blender 3D to create separate images.
A tutorial how to do this can be found here on section Blender 3D.
After I rendered images separately and named: 0000.png , 0001.png , 0002.png , 0003.png
I created a python script to put in an tile image, see below:

import os
import PIL
from PIL import Image
from PIL import ImageDraw
o=Image.new("RGBA",(192,48))
d= ImageDraw.Draw(o)
for pic in range(0,4):
        strpic=str(pic)
        filnam="000"+strpic+".png"
        x=pic*48
        img=Image.open(filnam)
        o.paste(img,(0+x,0))
        o.save("out.png")

The script reads the image files of size 48 pixels and puts them into one image called out.png