Porch Thing

I first saw one of these porch mobiles in Statesville, NC in 1997. Since then I've started to see them on porches around upstate SC. Some are made from PVC pipe and some are made from wood. Almost all are painted in florescent orange or green. 'Porch Thing' is just my own name for them, before I found out that some people call one a 'do-nothing'.

Pictures

This animation was first made using GIFBuilder 0.5. The individual frames were made with Maple V Release 4. (see below) But then along came Maple V R5 -- it can save animations to animated GIF files. So, I did that, but still used GIFBuilder 0.5 to set the GIF so that part of the image is not displayed (the extra margin that Maple won't let you eliminate unless you are using the postscript device and the `shrinkby` plotoption).

Viewed from different angles, one can see a 6-pointed star, two squares sharing a vertex, two triangles and a hexagon, or two line segments sprouting from the top and bottom of a rectangle.

Theory

Construction

Repeat:

Draw a line segment to an allowed bounding edge of this face that has not yet been crossed.

Then draw a line segment from the edge center to the center of the other face that the edge bounds.

When there are no more edges to left to visit subject to the given restrictions, close the path by drawing a segment to the starting point.

The cube itself is just an aid in the construction of the path around the cube. So once the path is constructed, the cube's edges and vertices may be discarded.

A Porch Thing looks best when hung by one of their vertices that is on an edge of the underlying cube structure. A Porch Thing will take on different appearances as a viewer passes one by. Better yet would be to get a swiveling piece of hardware to allow a Porch Thing to rotate freely, giving the stationary viewer the possibility of seeing more than one of the special orientations.

The Pattern

The Porch Thing is made of straight line segments and 90-degree turns, so we can match a 3-d coordinate system with the directions of the segments. Then walking along the Porch Thing we make positive and negative movements along the x,y, and z axes. The sequence of moves we get is:

This sequence is unique up to a shift. Meaning you can start anywhere in the sequence given here and wrap around from end to beginning to arrive at another sequence of equidistant moves that would trace a Porch Thing.

Note that there are several patterns present here. First there's the (xyz) repetition. There's also the (++--) repetition. And another observation is that you can negate the first half of the sequence to get the second half.

If we start the construction with a cube that is 2x2x2 with the origin of our coordinate system in its middle, then the vertices of the Porch Thing are, in a path order:

With Maple...

Here is some simple code for Maple V Release 4 that produces a Porch Thing that you have to rotate manually, or by adjusting view parameters theta and phi.

with(plottools):

pt := curve([[1,0,0], [1,0,-1], [0,0,-1], [0,1,-1], [0,1,0], [-1,1,0], 
[-1,0,0], [-1,0,1], [0,0,1], [0,-1,1], [0,-1,0], [1,-1,0], [1,0,0]], 
color=green, thickness=3):

plots[display](pt, orientation=[45,45]);

Here is some more involved code for Maple V Release 4 that puts the Porch Thing in an orientation suitable for hanging. It can be rotated by tweaking theta, the first number in the orientation.

with(plottools):
 
path:=[[1,0,0], [1,0,-1], [0,0,-1], [0,1,-1], [0,1,0], [-1,1,0], 
[-1,0,0], [-1,0,1], [0,0,1], [0,-1,1], [0,-1,0], [1,-1,0], [1,0,0]]:

with(linalg):

path=innerprod(path, 
[[1,0,0], [0,sqrt(2)/2,-sqrt(2)/2], [0,sqrt(2)/2,sqrt(2)/2]]):

path=[ seq(convert(row(path,i), list), i=1..13) ]:
 
pt := curve(path, color=green, thickness=3):
 
plots[display](pt, orientation=[134,93], 
title=`Porch Thing`, titlefont=[HELVETICA,BOLD,14], 
scaling=constrained);

And finally, here's a Maple file that defines a procedure that produces an animation of a rotating Porch Thing.

path:=[[1,0,0], [1,0,-1], [0,0,-1], [0,1,-1], [0,1,0],
 [-1,1,0], [-1,0,0], [-1,0,1], [0,0,1],
 [0,-1,1], [0,-1,0], [1,-1,0], [1,0,0]]:
 
 path:=linalg[innerprod](path, [[1,0,0],
 [0,sqrt(2)/2,-sqrt(2)/2], [0,sqrt(2)/2,sqrt(2)/2]]):
 
 path:=[seq(convert(linalg[row](path,i),list),i=1..13)]:
 
 pt := plottools[curve](path, color=green, thickness=3):
 
 w:=proc(theta,phi)
    plots[display3d](pt, orientation=[theta,phi]);
 end:
 
 plots[display3d]([seq(w(i*5,93), i=0..35)], insequence=true,
    scaling=constrained, projection=.8);

To get a more realistic looking plot, I tried to use tubeplot (spacecurve(path, scaling=constrained) but I get an error. The error indicated that the tubeplot function required an array, list, or set. It seems that it didn't like a spacecurve, and it also wouldn't work from a list of discrete points (you just get circles drawn around the points).

So I decided to try a piecewise function returning an array of coordinates. Didn't like that (but it was a function returning an array). So I tried using a piecewise function for the coordinates in the array, having added an argument to the function to handle the coordinate index. That worked. Here's the result:

path:=[[1,0,0], [1,0,-1], [0,0,-1], [0,1,-1], [0,1,0],
 [-1,1,0], [-1,0,0], [-1,0,1], [0,0,1],
 [0,-1,1], [0,-1,0], [1,-1,0], [1,0,0]]:
 
 path:=linalg[innerprod](path, [[1,0,0],
 [0,sqrt(2)/2,-sqrt(2)/2], [0,sqrt(2)/2,sqrt(2)/2]]):
 
 path:=[seq(convert(linalg[row](path,i),list),i=1..13)]:
 
 f:= (t,j) -> piecewise(
 t>=0 and t<1, (1-t)*path[1,j]  +t*path[2,j],
 t>=1 and t<2, (2-t)*path[2,j]+(t-1)*path[3,j],
 t>=2 and t<3, (3-t)*path[3,j]+(t-2)*path[4,j],
 t>=3 and t<4, (4-t)*path[4,j]+(t-3)*path[5,j],
 t>=4 and t<5, (5-t)*path[5,j]+(t-4)*path[6,j],
 t>=5 and t<6, (6-t)*path[6,j]+(t-5)*path[7,j],
 t>=6 and t<7, (7-t)*path[7,j]+(t-6)*path[8,j],
 t>=7 and t<8, (8-t)*path[8,j]+(t-7)*path[9,j],
 t>=8 and t<9, (9-t)*path[9,j]+(t-8)*path[10,j],
 t>=9 and t<10, (10-t)*path[10,j]+(t-9)*path[11,j],
 t>=10 and t<11, (11-t)*path[11,j]+(t-10)*path[12,j],
 t>=11 and t=<12, (12-t)*path[12,j]+(t-11)*path[1,j]
 ):
 
 w2:=proc(theta,phi)
    plots[display3d](plots[tubeplot]([f(t,1), f(t,2), f(t,3)],
    t=0..12, numpoints=25, radius=.08, color=[1,1,1]),
    orientation=[theta,phi]);
 end:
 
 plotsetup(default):
 
 plots[display3d]([seq(w2(i*5,93), i=0..35)], insequence=true,
    scaling=constrained, style=patchnogrid, ambientlight=[.8,.8,.32],
    projection=.8, light=[40,-75,1,1,.4]);

The only thing left to do is to clean up the function, f, to make it shorter by adding integer and mod functions in place of all the different cases.