How do I 'scale' a path? First of all, I'm a programmer with a less than stellar understanding of some areas of math. I am working on making a cheap approximation of a human silhouette, using only a few points representing limbs (left hand, left elbow, left shoulder, etc). 
One method I was considering was drawing a path between each of those points, and then 'scaling' outwards. How would I calculate the vectors for these points along the path? From what I understand, that is what I am doing, creating vector points and scaling them outwards.
Currently I am able to accomplish what is at the left, drawing the path counter-clockwise using  (cos(2PIx) , cos(2PIy)). I just don't know what I need to do to have it draw the image on the left, some sort of vector multiplication?

 A: This is a cool problem. I believe it is fruitful not to try to find a single purpose formula but to do it by casework (otherwise it gets unnecessarily expensive, and if this is rendering on a front end that might be using up a user's resources unnecessarily)
Observe the right-picture (with circle radius r) can be approximated by calling it a half circle on top, two line segments interpolating both sides, and an upside-down half circle on the bottom. 
The top half circle has center $(x_t, y_t)$ the bottom half circle has center $(x_b, y_b)$ 
From here we note we can get the correct vectors for the line segments by looking at 
$$ \cos(2 \pi (x - x_t)) , \sin(2 \pi (y - y_t)) $$ 
For the top and 
$$ \cos(2 \pi (x - x_b)), \sin(2 \pi (y - y_b)) $$ 
For the bottom. 
Now the line segments that are adjacent are easily computed as just being $(0,1)$ since they are vertical lines. Observe that the vertical lines lines contain points p such that the $y$ component of p lies between $y_t, y_b$
So a sample routine you can build in python:
def direction(x,y,xt, yt,xb, yb): #outputs a pair
    if yt >= y: # we are not on the top circle
        if y >= yb: #we are above the bottom circle
            return (0,1)
        #we are on the bottom circle
        return (math.cos(2*math.PI*(x - xb)), math.sin(2*math.sin(2*math.PI*(y-yb))))

    #the first if statement failed so we must be on the top circle
   return (math.cos(2*math.PI*(x - xt)), math.sin(2*math.sin(2*math.PI*(y-yt))))

(untested, you might need to balance a parenthesis). 
You might be interested in looking at "slope fields" they are very relevant here:
https://en.wikipedia.org/wiki/Slope_field

General Purpose Solution:

Suppose you have an arbitrary path of points $(x_0,y_0), (x_1, y_1) ... $ If the path is sufficiently dense, what can do is just consider $\frac{1}{(x_{k+1}- x_k)^2 + (y_{k+1} - y_k)^2} \cdot (x_{k+1}-x_k, y_{k+1}-y_k)$ (the factor in front just makes it the right size (namely 1)).
If you sample a lot of points, even in the example ABOVE, this will do the trick. But if the sampling isn't dense then this won't be a very pretty image.
A: The offset problem is a bit more complicated than may appear at first.
Here is a paper discussing a bit more general problem: An offset algorithm for polyline curves
