The photoshopping is quite excellent.  The only real bummer is his website, which is inexplicably all flash-based (baaad idea) and consequently distorts the pictures depending on your resolution.

Fictions by Filip Dujardin 01

Fictions by Filip Dujardin 02

Fictions by Filip Dujardin 03

Fictions by Filip Dujardin 04

Last June, newly equipped with my Canon 60D, I decided to do a little experiment in photoshopping a scene together in my home office at the time.

Hand in Couch

I just used what was immediately around me.  I took several shots of my arm on the couch and of just the couch itself, and some photoshopping later we get this image which looks real but we yet know cannot be real.  I think this juxtaposition is kind of creepy and unsettling.

Just recently I’ve read a lot of strobist.com – that site is awesome.  Armed with my brother’s Canon Speedlite 430 EX as well as a light stand + umbrella I’ve been wreaking some studio quality lighting havoc recently.  Catching up on the work of Dave Hill I got to thinking about how to get multi-light pictures having only one light source (my flash) and possibly outside ambient light.  I thought why not independently light areas of the scene and then stitch them together in PS.  Basically light painting with a flash and shoot-through umbrella.

So I took roughly 60-70 pictures and ultimately ended up taking 32 of them and putting them together in PS.

Lee X 3

All in all this picture was 61 layers (of which 32 were photos) totaling 3GB!  Consequently found out about the .psb file extension through this project, which is Adobe’s large file format as .psd’s only go up to 2 gigs.

Anyway, most of the work was actually in the brackground.  I basically used the light parts of each component picture and used the Lighten blend mode to blend the pics on top of one another.  Getting it just right requires a fair amount fine-tuning, but that was the basic process.  I used the analogy of additive lighting whereby I started with a black background and added light selectively to build up the picture.

The end result is quite interesting. The room is very unrealistically lit and there isn’t an obvious light source.  So just the room in and of itself is “off” somehow but it shows much greater detail – hyperreal so to speak.  Then of course three versions of me cannot be, yet it looks real… though in a fake way.  Some of the shadows could be improved and are to me giveaways (e.g. the right arm of me sitting in the recliner, or the right hand of me on the ground), but you don’t immediately notice it.

To me a quite fascinating space, the edge between reality and imagination.  Though all photography is an illusion (an image on paper or screen ain’t the real thing), there’s an expectation that a photo depicts some kind of reality objectively.  Of course there’s a huge amount of editing (cropping, lighting, etc.) but I guess the expectation is that I could go out and see a depicted scene for myself.  Playing with this expectation through photomontage opens up endless possibilities to surprise and challenge the viewer.

superfLOW – The Unthinkable from Ian Clemmer on Vimeo.

superfLOW – Galactic Flow from Ian Clemmer on Vimeo.

SUPER FLOW from Ian Clemmer on Vimeo.

So I end up not writing anything at all.

Clearly my interest in Python was short-lived.  Not really surprising.  My fickle mind apparently enjoys intense but brief relationships with various subject matter.  Which is great for overall breadth of knowledge, but I never get to be intimately involved with the devil in the details.  Oh well.  I suppose the best thing to do is to simply embrace this shotgun approach to interest and learning and be comfortable with the fact that this place will have no discernible focus, but may be all over the place.

You should be comfortable with that too.  On with the show.

• Delicious Bookmarks (this should really act as this post itself… what are ya gonna do?)
• The Loop
• Template Tags
• Query Posts

Originally posted on my old blog, reposting due to its continued usefulness for myself

You can find the full instructions to back up your WordPress database over at WordPress.org, but here are the settings needed for a phpMyAdmin export (more for my own reference than anything else):

1. Select ONLY those that hold your WordPress site.
2. Check the “Add DROP TABLE” box.
3. Check the “Complete inserts” box.
4. Check the “Save as File” box
5. Check the “None” for compression. If your database is very large use a compression method.
6. Click Go. The data will now be saved into your computer.

O’Reilly’s big “XSLT” book by Doug Tidwell

XML Standards

• XML 1.0: Extensible Markup Language (XML) 1.0 (Fifth Edition) W3C Recommendation 26 November 2008
• XML 1.1: Extensible Markup Language (XML) 1.1 (Second Edition) W3C Recommendation 16 August 2006, edited in place 29 September 2006
• XSL 1.1: Extensible Stylesheet Language (XSL) Version 1.1 W3C Recommendation 05 December 2006
  • FOP: Apache FOP (Formatting Objects Processor) for (mainly) output to PDF
• XML Schema
  • XML Schema Part 0: Primer Second Edition W3C Recommendation 28 October 2004
  • XML Schema Part 1: Structures Second Edition W3C Recommendation 28 October 2004
  • XML Schema Part 2: Datatypes Second Edition W3C Recommendation 28 October 2004
• OASIS Relax NG TC
• Schematron
• SAX: Simple API for XML
• DOM: Document Object Model
• Namespaces in XML 1.0 (Second Edition) W3C Recommendation 16 August 2006
• Namespaces in XML 1.1 (Second Edition) W3C Recommendation 16 August 2006
• Associating Style Sheets with XML documents Version 1.0 W3C Recommendation 29 June 1999
• SVG: Scalable Vector Graphics (SVG) 1.1 Specification W3C Recommendation 14 January 2003, edited in place 30 April 2009
• XPointer: XPointer Framework W3C Recommendation 25 March 2003
• XLink: XML Linking Language (XLink) Version 1.0 W3C Recommendation 27 June 2001

XSLT Standards

• XSLT 1.0: XSL Transformations (XSLT) Version 1.0 W3C Recommendation 16 November 1999
• XSLT 2.0: XSL Transformations (XSLT) Version 2.0 W3C Recommendation 23 January 2007
• XPath 1.0: XML Path Language (XPath) Version 1.0 W3C Recommendation 16 November 1999
• XPath 2.0: XML Path Language (XPath) 2.0 W3C Recommendation 23 January 2007
• XDM: XQuery 1.0 and XPath 2.0 Data Model (XDM) W3C Recommendation 23 January 2007
• F&O: XQuery 1.0 and XPath 2.0 Functions and Operators W3C Recommendation 23 January 2007
• XQuery 1.0 and XPath 2.0 Formal Semantics W3C Recommendation 23 January 2007
• XSLT 2.0 and XQuery 1.0 Serialization W3C Recommendation 23 January 2007
• XQuery 1.0: An XML Query Language W3C Recommendation 23 January 2007
• XQueryX: XML Syntax for XQuery 1.0 (XQueryX) W3C Recommendation 23 January 2007

 by Mark Pilgrim (also available

In Chapter 3, Mark introduces:

• Dictionaries
• Lists
• Tuples
• Variables
• Strings

Dictionaries

A dictionary defines a one-to-one relationship between a key and a value.  Here’s how you define a dictionary:

>>> d = {"firstname":"lee","lastname":"clemmer","age":"26"}

To access the value of a specific key:

>>> d["firstname"]
'lee'

Note, however, that you cannot get keys by values:

>>> d["clemmer"]

Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    d["clemmer"]
KeyError: 'clemmer'

To add a key:

>>> d["hometown"] = "Bremen"
>>> d
{'lastname': 'clemmer', 'age': '26', 'firstname': 'lee', 'hometown': 'Bremen'}

To overwrite a key:

>>> d["age"] = "21"
>>> d
{'lastname': 'clemmer', 'age': '21', 'firstname': 'lee', 'hometown': 'Bremen'}

Note that this is the same syntax as adding a key.

To delete a key:

>>> del d["age"]
>>> d
{'lastname': 'clemmer', 'firstname': 'lee', 'hometown': 'Bremen'}

To clear the whole dictionary:

>>> d.clear()
>>> d
{}

Important to note:

• Dictionaries are unordered.  This is why the sequence they appear in seems random.  It is.  They’re not “out of order”, there is no order.
• Dictionaries cannot have duplicate keys
• Dictionary keys are case-sensitive: d["key"] and d["Key"] are different
• Dictionary values can be of any datatype (strings, integers, objects, dictionaries, etc.)
• Dictonary keys can only be certain datatypes (immutables, like strings, integers, or tuples of immutables)
• Both key and value datatypes can be mixed and matched within a single dictionary

Dictionary have a built-in function that returns a list of tuples of all or some of the data in the dictionary:

>>> d.keys()
['lastname', 'age', 'firstname']
>>> d.values()
['clemmer', '26', 'lee']
>>> d.items()
[('lastname', 'clemmer'), ('age', '26'), ('firstname', 'lee')]

Although dictionaries are unordered, note that d.values()[n] == d.keys()[n] for all values of n.

Further reading on dictionaries:

• “Dictionaries” in “How to Think Like a Computer Scientist: Learning With Python”
• Questions about dictionaries on the Python Knowledge Base
• “To sort a dictionary” in the Python Cookbook
• “Mapping Types — dict” in the Python Library Reference

Lists

Top

Lists are ordered sets of elements, as opposed to unordered dictionaries.  They are similar to zero-based arrays.

To create a list:

>>> list = ["1", 2, "three", 4, "lee"]
>>> list
['1', 2, 'three', 4, 'lee']

As you can see, I’ve mixed and matched strings and integers.

To access one of the elements, you indicate its position, with the first one being 0:

>>> list[0]
'1'
>>> list[3]
4

You can also use a negative index to access elements.  The last element always corresponds to -1, or li[-n] == li[len(li) - n]:

>>> list[-1]
'lee'
>>> list[-5]
'1'

You can slice a list by specifying the first index and the index after the last element you want returned, which is a bit counterintuitive.  For example:

>>> list = ["one", "two", "three", "four", "five"]
>>> list
['one', 'two', 'three', 'four', 'five']
>>> list[1:3]
['two', 'three']
>>> list[-4:-1]
['two', 'three', 'four']
>>> list[:3]
['one', 'two', 'three']
>>> list[3:]
['four', 'five']
>>> list[:]
['one', 'two', 'three', 'four', 'five']

Some notes about these examples:

• [1:3] specifies element at index [1] (‘two’) until element at index before [3], i.e. [2] (‘three’)
• Negative indices work as well
• You can use shorthand: [:3] implies “start from index [0]“; [3:] implies “until last index”
• [:] returns all list elements as a copy of that list

There are several different ways to add elements onto or into a list:

>>> list
['one', 'two', 'three', 'four', 'five']
>>> list.append("seven")
>>> list
['one', 'two', 'three', 'four', 'five', 'seven']
>>> list.insert(5,"six")
>>> list
['one', 'two', 'three', 'four', 'five', 'six', 'seven']
>>> list.extend(["eight","nine"])
>>> list
['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine']

•  append adds a single element to the end of list
• insert inserts an element and bumps up the element referenced in the call ([5] in the example: it inserted the string “six” in the sixth position at index [5])
• extend concatenates lists; you call it with one list as the argument as opposed to multiple arguments.  This adds each list element as a new element.  If you were to do append(["one","two"]) this would append a list as one element

To query the length of a list, simply:

>>> len(list)
9

To search for the index of an element:

>>> list.index('four') 3 >>> list.index('ten') Traceback (most recent call last): File "<pyshell#82>", line 1, in <module> list.index('ten') ValueError: list.index(x): x not in list >>> "ten" in list False 

• index returns the index of the first occurrence of an element
• search for an element that doesn’t exist raises an exception and crashes your program (instead of returning in invalid index)
• to see if a value is present in a list, use in, which will return True or False

To delete an element from a list:

>>> list
['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine']
>>> list.remove('three')
>>> list
['one', 'two', 'four', 'five', 'six', 'seven', 'eight', 'nine']
>>> list.remove('three')

Traceback (most recent call last):
  File "<pyshell#99>", line 1, in <module>
    list.remove('three')
ValueError: list.remove(x): x not in list
>>> list.pop()
'nine'
>>> list
['one', 'two', 'four', 'five', 'six', 'seven', 'eight']

• remove removes only the first occurrence of the given value
• if the value isn’t found, Python raises an exception
• pop does two things
  1. removes the last element
  2. returns that element

There are a number of different operators that you can use on lists:

>>> list = ["one", "two"]
>>> list = list + ["three", "four"]
>>> list
['one', 'two', 'three', 'four']
>>> list += ["five"]
>>> list
['one', 'two', 'three', 'four', 'five']
>>> list *= 3
>>> list
['one', 'two', 'three', 'four', 'five', 'one', 'two', 'three', 'four', 'five', 'one', 'two',
'three', 'four', 'five']
>>> list = [1,2] * 4
>>> list
[1, 2, 1, 2, 1, 2, 1, 2]

• The + operator concatenates two lists into a new list. This is the same as the extend function, except that concatenation creates a new string, where as extend just extends an existing string, making it much faster, especially for large lists.
• list += ["five"] is the same as list = list + ["five"] or list.extend(["five"])
• The * operator acts as a repeater on a list

Further reading on lists:

• “Lists” in “How to Think Like a Computer Scientist: Learning With Python”
• “More on Lists” in the Python Tutorial
• Questions about lists on the Python Knowledge Base
• “Mutable Sequence Types” (all list functions) in the Python Library Reference

Mapping Lists

List comprehension provides a way to map a list onto another list.  Note that this does not change the original list, unless you assign it as such:

>>> list = ["item 1", 2, "three", 4]
>>> [elem*2 for elem in list]
['item 1item 1', 4, 'threethree', 8]
>>> list
['item 1', 2, 'three', 4]
>>> list = [elem*3 for elem in list]
>>> list
['item 1item 1item 1', 6, 'threethreethree', 12]

Further reading on list comprehension

• “List Comprehensions” in the Python Tutorial

Tuples

Top

A tuple is an immutable list.  That would be a list that you can’t change.  Once it’s created, you can’t change it. It’s immutable.  However, other than not changing, it acts very much like a list:

>>> t = ("lee","clemmer")
>>> t
('lee', 'clemmer')
>>> t[1]
'clemmer'
>>> t[:1]
('lee',)
>>> t[-2]
'lee'
>>> t.remove("clemmer")

Traceback (most recent call last):
  File "<pyshell#122>", line 1, in <module>
    t.remove("clemmer")
AttributeError: 'tuple' object has no attribute 'remove'
>>> t.pop()

Traceback (most recent call last):
  File "<pyshell#123>", line 1, in <module>
    t.pop()
AttributeError: 'tuple' object has no attribute 'pop'
>>> t.append("albert")

Traceback (most recent call last):
  File "<pyshell#124>", line 1, in <module>
    t.append("albert")
AttributeError: 'tuple' object has no attribute 'append'
>>> t.insert("albert")

Traceback (most recent call last):
  File "<pyshell#126>", line 1, in <module>
    t.insert("albert")
AttributeError: 'tuple' object has no attribute 'insert'

As you can see, defining a tuple and calling an element thereof is very much like working with lists. However, trying to change it throws an exception.  Tuples have no methods.

Why use a tuple? It’s faster.  Therefore, use tuples for constants that don’t change.

Further reading on tuples:

• “Sorting tuples” on the Python Knowledge Base
• “Tuples and Sequence” in the Python Tutorial

Declaring Variables

Top

Python has local and global variables, but doesn’t explicitly declare variables.  A variable is created when you assign a value to it, and is destroyed once out of scope.  You cannot reference a variable that hasn’t been assigned a value (and hence doesn’t exist):

>>> myParams = { "firstname":"lee",
	     "lastname":"clemmer",
	     "age":"26"}
>>> myParams
{'lastname': 'clemmer', 'age': '26', 'firstname': 'lee'}
>>> x

Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    x
NameError: name 'x' is not defined
>>> x = 1
>>> x
1

When creating variables, you can assign multiple values to variables at once:

>>> numbers = (1,2,3)
>>> numbers
(1, 2, 3)
>>> (x,y,z) = numbers
>>> x
1
>>> y
2
>>> z
3
>>> (a,b,c,d) = numbers

Traceback (most recent call last):
  File "<pyshell#16>", line 1, in <module>
    (a,b,c,d) = numbers
ValueError: need more than 3 values to unpack

As you can see by the last example, the number of variables have to match the number of elements in the tuple, list, or dictionary.  You can also assign variables using the range function:

>>> (one, two, three, four) = range(4)
>>> one
0
>>> two
1
>>> three
2
>>> four
3

For more information on range:

>>> print range.__doc__
range([start,] stop[, step]) -> list of integers

Return a list containing an arithmetic progression of integers.
range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.
When step is given, it specifies the increment (or decrement).
For example, range(4) returns [0, 1, 2, 3].  The end point is omitted!
These are exactly the valid indices for a list of 4 elements.
>>> range(1,100,3)
[1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52,
55, 58, 61, 64, 67, 70, 73, 76, 79, 82, 85, 88, 91, 94, 97]

Further reading on variables:

• “Variables” in “How to Think Like a Computer Scientist: Learning With Python

Formatting Strings

Top

Python allows you to format values into strings, for example by using the string placeholder %s:

>>> x = "a string"
>>> y = "another string"
>>> "%s and %s" % (x,y)
'a string and another string'

Importantly, the expression evaluates to a string.  This implies that you can coerce types into strings.

This kind of string formatting allows you to “join” a string and, say, a number, which you normally couldn’t concatenate:

>>> x = "you can concatenate "
>>> y = "two strings"
>>> print x + y
you can concatenate two strings
>>> "%s%s like this also" % (x,y)
'you can concatenate two strings like this also'
>>> number = 2
>>> print x + number + " a string and number - not!"

Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    print x + number + " a string and number - not!"
TypeError: cannot concatenate 'str' and 'int' objects
>>> "%s%d different types like so - to make a string" % (x,number)
'you can concatenate 2 different types like so - to make a string'

You can also work with floats:

>>> print "This is a float: %f" % 3.1425
This is a float: 3.142500
>>> print "To control decimal places: %.2f" % 3.1425
To control decimal places: 3.14
>>> print "How about a +/- sign: %+.2f" % -3.1425
How about a +/- sign: -3.14

Further reading on formatting strings:

• “String Formatting Operations“ in the Python Library Reference

Joining Lists and Splitting Strings

All strings are themselves objects, and as such have a built-in join() function.  The join function takes a list and joins its elements into a single string, separated by the string that made the join call:

>>> list
['Monday', 'Tuesday', 'Make sense?']
>>> " is a day. ".join(list)
'Monday is a day. Tuesday is a day. Make sense?'

You can also reverse this using split():

>>> sentences = " is a day. ".join(list)
>>> sentences
'Monday is a day. Tuesday is a day. Make sense?'
>>> sentences.split(" is a day. ")
['Monday', 'Tuesday', 'Make sense?']
>>> list
['Monday', 'Tuesday', 'Make sense?']
>>> sentences.split(" is a day. ", 1)
['Monday', 'Tuesday is a day. Make sense?']

The last example shows that split takes an optional argument, in this case how many times the split should occur.

Further reading on string methods:

• Questions about strings and sample string code on the Python Knowledge Base
• “String Methods” and the string module in the Python Library Reference
• Why is join() a string method instead of a list or tuple method? on Python FAQ

Top

Note: I’m currently in the process of learning Python.  These are notes on “Dive Into Python” by Mark Pilgrim (also available online), an excellent book if you’re like me and learn by the “do first, understand later” method.

Declaring functions

def functionName(params):

Defining a function’s doc string

def functionName(params):
   """This is the explanation of the function, surrounded by triple quotes.
   Returns a string."""

Further reading on document strings:

• Python Enhancement Proposals (PEP) 257: Docstring Conventions
• PEP 8: Style Guide for Python Code
• Documentation Strings in Python Tutorial (2.5.2)

Import search path

When importing a module, python looks in several places as defined in sys.path:

>>> import sys
>>> sys.path
['C:\Python25\Lib\idlelib', 'C:\Python25\lib\site-packages\setuptools-0.6c7-py2.5.egg',
'C:\WINDOWS\system32\python25.zip', 'C:\Python25\DLLs', 'C:\Python25\lib',
'C:\Python25\lib\plat-win', 'C:\Python25\lib\lib-tk', 'C:\Python25',
'C:\Python25\lib\site-packages']
>>> sys
<module 'sys' (built-in)>
>>> sys.path.append('/my/new/path')

The last line illustrates how to add a path to look in.

Everything is an object

Everything is an object! Functions, modules, strings, lists, everything!  Python objects are objects in the sense that they can be passed as an argument to a function or be assigned to variables.

As an example, all functions have a built-in attribute called __doc__, which you can access like this:

>>> print importedModule.functionName.__doc__
This is the explanation of the function, surrounded by triple quotes.
Returns a string.

Further reading on objects:

• “Objects, values, and types” in the Python Reference Manual
• “Python Objects” on effbot.org

Indenting code

As a newbie to Python, the built-in syntax rules are particularly appealing to me.

There are no braces for functions, no semicolons to end a line; simply indent and a code block is defined (for if statements, functions, etc.).  The only delimiter here is the colon”:”.

Further reading on indenting code:

• “Indentation” in the Python Reference Manual
• PEP 8: Style Guide for Python Code

Testing modules with if __name__

All modules have a built-in attribute __name__.  The value of this attribute depends on how the module is being used; is it imported or run on its own?

• If the module is imported, __name__ equals the filename (without path, without file extension)
• If the module is run as a stand-alone program, the value of __name__ is a special default value, __main__

Why is this important? It means that you can embed a test suite in the module itself.  In other words, it’s code that will only execute when running the module directly, not when it’s being imported.  To do this, you would include the following in the module:

if __name__ == "__main__":
    """Insert test code here."""

Further reading on importing modules:

• “The import statement” in the Python Reference Manual