Processing can certainly do it... if you have the right algorithm! That's something I would like to know, too...

First, is the shape just a bitmap, or something like a PShape?
In the latter case, a potential way to do it is to take points on the curve (Bézier points), and move them in a direction perpendicular to the curve tangent (it has to be adapted to cases like the lower point of your example... Perhaps taking the line that bisects the angle between the two tangents at this point).

You can search for things like polygon offset and straight skeleton. For example check out this page for quite a few good suggestions.

Or you could use the offsetShape() method in the Toxiclibs Polygon2D class. Note this method has been added after the last official release of Toxiclibs. So either build from the source yourself or download this pre-release. The order of the vertices matters for the direction of the offset. Clockwise versus counter-clockwise, in or out. The complexity of the polygon also matters. This is just a math method, so it will do the math. It doesn't really care about intersections or other weird stuff happening to your polygons. Finally Polygon2D's are made out of straight lines, but they do have a laplacian smooth method also. All in all another option to consider for quick results, although not exactly as your image example.

Code Example

1. // NOTE: only works with pre-release Toxiclibs 0021
2. 
   
3. import toxi.geom.*;
4. import toxi.processing.*;
5.  
6. ArrayList <Polygon2D> polygons = new ArrayList <Polygon2D> ();
7. ToxiclibsSupport gfx;
8.  
9. void setup() {
10.   size(800,800);
11.   gfx = new ToxiclibsSupport(this);
12.   startingPoly();
13.   offsetPoly(20);
14.   noFill();
15.   smooth();
16. }
17.  
18. void draw() {
19.   background(255);
20.   translate(width/2, height/2);
21.   for (Polygon2D p : polygons) {
22.     gfx.polygon2D(p);
23.   }
24. }
25.  
26. void keyPressed() {
27.   startingPoly();
28.   offsetPoly(20);
29. }
30.  
31. void startingPoly() {
32.   polygons.clear();
33.   Polygon2D poly = new Polygon2D();
34.   int numpoints = 10;
35.   for(int i=0; i<numpoints; i++) {
36.     float x = sin(radians(i*360/numpoints))*random(15, 30);
37.     float y = cos(radians(i*360/numpoints))*random(15, 30);;
38.     poly.add(x, y);
39.   }
40.   polygons.add(poly);
41. }
42.  
43. void offsetPoly(int num) {
44.   for (int i=0; i<num; i++) {
45.     Polygon2D poly = polygons.get(polygons.size()-1).copy();
46.     poly = poly.offsetShape(-10);
47.     polygons.add(poly);
48.   }
49. }

Another keyword you may be interested on is centerline computation.  Although this refers to the "skeleton" of the shape.  I remember some time ago I was looking into this and found a method based on performing a Voronoi computation of the points on the contour and then finding the edges of interest.  Haven't done any further research since.  But I am interested in the results you may achieve!

1. // SIMPLIFY SHAPE HERE and  
2. //  REMOVE s PATHS FROM ts