Easy Multilingual Theming with XDV

I use Plone at work (and love it). Lately I’ve started getting into using XDV to theme my sites (3 so far). It’s fantastic. Our latest site was put up in a week (from start to finish) using Plone, collective.xdv and some team work. Anyways, we only had the English version up initially, while we waited on the translations. When they finally came through, I first plugged it all into Plone (using LinguaPlone), but now I had to update the theme to support the French site. Support for the :lang() CSS pseudo selector is lacking in some browsers, so I contemplated for a few minutes, then added 2 rules to my rules.xml file:

<drop theme="//*[@lang='fr']" if-content="/html[@lang!='fr']" />
<drop theme="//*[@lang='en']" if-content="/html[@lang!='en']" />

Problem solved! To handle language-specific CSS, I just created 2 new css files, one for English and one for French and added a lang attribute in the link element.

<link lang="en" href="style-en.css" rel="stylesheet" type="text/css" />
<link lang="fr" href="style-fr.css" rel="stylesheet" type="text/css" />

I did the same thing for static text and images as well.

2D Convex Hulls: Graham Scan

This is the 2nd post in a series of 3 on 2D convex hull algorithms. The first covered the Jarvis March and here I’ll be covering the Graham Scan. The implementation of the Graham Scan is short, but sweet. It handles degenerate cases very well. The next post will cover Chan’s algorithm.

Graham Scan

Although it may not look it at first glance, the Graham Scan is similar to the Jarvis March. We start with an extreme point and then find the edges of the hull iteratively, one at a time. The main difference is that by sorting the points first, we remove the need to spend O(n) time searching for the next hull point, though at the cost of making some “mistakes” (adding points to the hull that aren’t hull points). Instead, we spend our effort on updating the hull at each iteration, fixing previous mistakes. It turns out that fixing the mistakes is pretty easy and we can find the entire hull in only O(n) comparisons (rather then the O(nh) of the Jarvis March). The time complexity of the algorithm actually comes from having to first sort the points in O(n log n) time. Now, much as we did with the Jarvis March, we will require a function that tells us the “turn” of 3 points (that is, whether p,q,r form a LEFT, RIGHT or straight (NONE) turn):

TURN_LEFT, TURN_RIGHT, TURN_NONE = (1, -1, 0)

def turn(p, q, r):
    return cmp((q[0] - p[0])*(r[1] - p[1]) - (r[0] - p[0])*(q[1] - p[1]), 0)

The original incantation of the Graham Scan sorted the points in angular order relative to some initial extreme point (eg. sorted in CCW order around the furthest left point). The convex hull is then constructed iteratively by going through the sorted list of points, one by one, each time adding the point to the previous hull. However, adding a point to the previous hull in the Graham Scan is not as simple as it was in the Jarvis March. In the Jarvis March, we knew our previous hull points were a subset of our final hull points, so to “update” the previous hull, we simply add the point found at each iteration to the end of our list of hull points. However, in the Graham Scan, updating our list of hull points at each iteration is not as simple.

The hull we have at the start of iteration i is actually the complete convex hull of the first i-1 points in our sorted list. Updating the hull requires us to find the tangents between the previous hull and point p_i, and replacing all hull edges between these 2 tangents with the tangents themselves. This may seem hard at first, but because the points were sorted in CCW order around the first point, p₁, it is actually quite simple.

We know the point p_i lies to the left of p₁p_i-1 and all other points p_k, 1 < k < i-1, lie to the right of p₁p_i-1, so one of the tangents will have to be the edge p_ip₁. Knowing this, we can find the other point of tangency by starting at p_i-1 (the last point in the list of hull points) and working backwards. The point of tangency is the first point p_j, j<i, where p_j-1, p_j, p_i form a left (CCW) turn. After finding the point p_j, we simply remove all points between this and the other point of tangency, p₁ (ie. we simply remove all points after p_j in our hull list). The point p_i is then simply appended to the end of our list of hull points.

In Python, we can implement a function to perform this step (adding a point r to the hull) fairly simply: we just keep popping the last item off our list while hull[-2], hull[-1], r don’t form a left turn.

def _keep_left(hull, r):
    while len(hull) > 1 and turn(hull[-2], hull[-1], r) != TURN_LEFT:
        hull.pop()
    # We check that hull[-1] != r to handle degenerate cases (ie. multisets)
    if not hull or hull[-1] != r:
        hull.append(r)
    return hull

What’s nice is that we only backtrack through the list, starting at the last point, by as many points as we will remove, +1 more point pj (which is where we stop). After we remove these points, they will never be looked at again, since they are no longer in the hull. This means, if we account for the +1 point we don’t remove, we will never look at more than 2n hull points during the entire run of the Graham Scan to find the tangents. Since we only go through the sorted list once, we require only O(n) time to find the convex hull, but O(n log n) time to sort the list first.

Putting it together, in Python, we could simply sort the list by angular order, using the turn function as the cmp function, then iterate through the sorted list of points add the points one at a time (with _keep_left). However, a nice (implementation) thing about the Graham Scan is that we can get away with sorting by lexicographical order, instead of angular order. Pretend we added a point at (0, ∞) to the point set. Then sorting by angular order about this point is equivalent to simply sorting by the x-coordinate. The convex hull of this modified point set is actually just the lower hull of our original point set. We can use this idea to split the algorithm into 3 parts. First we sort by x-coordinates (actually, lexicographical order to handle degenerecies) and find the lower hull. Then we reverse this sorted list and find the upper hull. Finally, we merge the upper and lower hull together. Doing this in Python, using the _keep_left function, is actually really straightforward. We simply have to keep in mind that the first point of the lower hull is also the last point of the upper hull and vice versa

def convex_hull(points):
    """Returns points on convex hull of an array of points in CCW order."""
    points = sorted(points)
    l = reduce(_keep_left, points, [])
    u = reduce(_keep_left, reversed(points), [])
    return l.extend(u[i] for i in xrange(1, len(u) - 1)) or l

I posted the full source for the Graham Scan in Python (all 20 lines) as a Gist.

2D Convex Hulls: Jarvis March

I’ve found myself coding convex hull algorithms on a few occasions now, so I decided to implement a few and talk about them here, in case someone new to the subject wants to get the quick ‘n’ dirty. The algorithms I will talk about are the Jarvis March (code), the Graham Scan (code) and Chan’s algorithm (code). I feel they are all different enough that each is worth looking at, but similar enough that they are worth looking at together. I will try and focus more on the actual implementation of the algorithms (all in Python), looking at potential pit falls as well as the niceties, rather then just rehashing what can be found on Wikipedia. This first post looks at the Jarvis March.

Jarvis March

The Jarvis March is probably the simplest convex hull algorithm conceptually. You start with an extreme point p (a vertex of the convex hull) of a point set. You then find the next point on the convex hull of the point set in CCW order. This is done by finding the “furthest right” point, relative to p. The furthest right point q, relative to p, is the point such all other points in the point set lie to the left of the directed line through p, q (this line lies on the hull boundary). We can then update p to q and repeat the process until we end up with the point we started at.

p, q, r forming a left turn

The heart of the algorithm really lies in finding the furthest right point q, relative to an extreme point p. Say you have 3 points p, q and r. We say p, q, r form a left (respectively right) turn if r lies to the left (right) of the directed line through p and q. We can write a simple function to determine the turn of 3 points:

TURN_LEFT, TURN_RIGHT, TURN_NONE = (1, -1, 0)

def turn(p, q, r):
    """Returns -1, 0, 1 if p,q,r forms a right, straight, or left turn."""
    return cmp((q[0] - p[0])*(r[1] - p[1]) - (r[0] - p[0])*(q[1] - p[1]), 0)

Finding the furthest right point relative to p just reduces to simply finding the minimum point q using turn with a fixed parameter p as our comparison function. This can is done in O(n) time:

def _next_hull_pt(points, p):
    """Returns the next point on the convex hull in CCW from p."""
    q = points[0] != p and points[0] or points[1]
    for r in (x for x in points if x != p):
        if turn(p, q, r) == TURN_RIGHT:
            q = r
    return q

p in between q & r

The above function is simple, but it assumes the points are in general position; that there are no 3 collinear points. The first problem arises if there are 2 furthest right points, then we could chose the one that is closer to p, which is not an extreme point (ie. it lies on the hull boundary, but is not a vertex). This becomes a bigger problem if our first comparison relative to this “mid-point” is with the 2 vertices on either side of it. We could possibly “skip” over the furthest right point, since it is not to the right of the furthest left, but collinear and would end up with the incorrect furthest right point. Luckily, handling this is rather simple; we insist that if there is more than 1 furthest right point, we choose the one furthest from p. We can then rewrite our function, handling this case:

def _dist(p, q):
    """Returns the squared Euclidean distance between p and q."""
    dx, dy = q[0] - p[0], q[1] - p[1]
    return dx * dx + dy * dy

def _next_hull_pt(points, p):
    """Returns the next point on the convex hull in CCW from p."""
    q = p
    for r in points:
        t = turn(p, q, r)
        if t == TURN_RIGHT or t == TURN_NONE and _dist(p, r) > _dist(p, q):
            q = r
    return q

The only problem now is finding the first extreme point. This can be done rather simply by choosing the minimum point in lexicographical order. We can then put this together and simply loop until we end up where we started:

def convex_hull(points):
    """Returns the points on the convex hull of points in CCW order."""
    hull = [min(points)]
    for p in hull:
        q = _next_hull_pt(points, p)
        if q != hull[0]:
            hull.append(q)
    return hull

We will end up going through h iterations of the loop, where h is the number of points on the convex hull. Each iteration takes O(n) time to find the furthest right point, so the total time required is O(nh), which is suboptimal. However, it is important to remember that suboptimal does not mean it is useless. The Jarvis March can easily handle very large datasets in memory constrained environments. The only information you need to maintain between iterations is the first and last point found. Finding the next point scans through all points only once; order does not matter. These points could come from a database cursor, for instance. In this case, your function would return an iterator of the hull edges (or points) that generates them on demand, each time next() is called.

You can also download the complete version of the code. Next post I’ll cover the Graham Scan.

Permutations and Combinations

Quite often while programming I find my self going through all possible k-combinations of a list. That is, all possible unordered sets of size k made up of elements of a list. A few times I have needed to iterate through all possible permutations of a list. Getting tired of writing nested for-loops, I wrote a small (~40 SLOC) Python module to handle combinations (and permutations) of lists. It defines two simple iterators, combinations and permutations to iterate through k-combinations and permutations of lists.

Combinations:

If you’ve taken an intro to programming course, you’ve probably coded something similar to this:

def sort(lst, cmp=cmp):
    """Sort the list lst."""
    for i in xrange(len(lst)):
        for j in xrange(i + 1, len(lst)):
            if lst[j] < lst[i]:
                lst[j], lst[i] = lst[i], lst[j]

This will sort, in-place, the list lst in comparisons (ie. not very efficient). However, it illustrates the concepts of combinations. We are actually iterating over all 2-combinations of the set {0,1,..,n-1} (albeit, in a particular order). In this case, we are using the combinations as indices into the list. Now, obviously there are better ways to sort a list, but, though I hate to admit it, I will sometimes brute-force my way to a solution using similar methods (mostly for prototyping or testing more efficient methods for accuracy). For 2-combinations you can just use a loop as above, but what happens when you are going 3 or 4 nested loops deep? Hiding ugly code is never a good thing, but if you gotta do it, you might as well not waste several levels of indentation.

Using the module, we can rewrite the above sorting function as a single for-loop (obviously this still does not change the time complexity).

from permute import combinations
def sort(lst, cmp=cmp):
    """Sort list lst."""
    for i,j in combinations(range(len(lst)), 2):
        if cmp(a[j], a[i]) < 0:
            a[i], a[j] = a[j], a[i]

The function has a couple guarantees. First, the type returned by the iterator’s next function is the same as the type of the list. Second, the function combinations guarantees the order passed to the type constructor will be the same as if you had written k nested for-loops as above… In other words:

x = range(k)
t = type(lst)
for x[0] in xrange(n):
    for x[1] in xrange(x[0] + 1, n):
        ...
        for x[k-1] in xrange(x[k-2] + 1, n):
            v = t(lst[x[i]] for i in xrange(k))
            ...

Is equivalent to:

from permute import combinations
for v in combinations(lst, k):
    ...

Permutations:

The permutations iterator, as you may have guessed, iterates over all permutations of a list (in lexicographical order). Using this, we can solve the Travelling Salesman Problem:

from permute import *

def solve_tsp(weights):
    nodes = list(reduce(lambda s, e: s.update(e) or s, weights.keys(), set()))
    for i,j in combinations(nodes, 2):
        if (i,j) not in weights and (j,i) not in weights:
            weights[(i,j)] = -1
    path, min = [], -1
    for cand in permutations(nodes):
        dist = 0
        for e in ((cand[i-1], cand[i]) for i in xrange(1, len(nodes))):
            d = e in weights and weights[e] or weights[(e[1], e[0])]
            if d < 0:
                dist = -1
                break
            else:
                dist += d
            if dist >= 0 and (min < 0 or dist < min):
                path, min = cand, dist
    return path, min

solve_tsp takes 1 argument, a map of edges to their corresponding weights and returns a 2-tuple of the shortest path and its total distance. The “graph” (the weight map) is assumed to be undirected. For example,

print(solve_tsp({(1,2): 1, (1,3): 2, (1,4): 3, (2,3): 3, (3,4):1}))

Gives us the shortest path and its total distance: ([2, 1, 3, 4], 4). Going through all permutations () isn’t very practical. Once gets larger then you can count on your hands it is really too slow to be of use.

You can grab the permute module from its github repository.