Creating 2D geometry from a line strip

During development of an old prototype that never saw the light, I found the need to create some 2D geometry from a set of points that form a line.

After searching for any algorithm that could make what I needed, with no success, I decided to develop my own.

The algorithm is very simple, it just takes a rope and a width and creates a set of vertices tha form a TriangleStrip to be rendered on screen.

/// <summary>
/// Triangulates a line, returning a list of vertices that form a triangle strip
/// </summary>
/// <param name="contour">List of points that form the line</param>
/// <param name="width">Desired with of the geometry</param>
/// <returns>list of vertices that form a triangle strip</returns>
public static List<Vector2> Process(ReadOnlyCollection<Vector2> contour,float width)
{
	List<Vector2> result = new List<Vector2>();
	Vector2 normal = Vector2.Zero ;
	// Generate vertices for each point in the line
	for (int i = 0; i < contour.Count; i++)
	{
		// First and last are special cases, the normal is calculated right away
		if (i == contour.Count - 1)
			normal = GameMath.Normal(contour[i] - contour[i - 1]);
		else if (i == 0)
			normal = GameMath.Normal(contour[1] - contour[0]);
		else
		{
			// For the rest of points, determine the normal as the middle angle between the direction of the previous and next segments.
			Vector2 delta1 = contour[i] - contour[i - 1];
			Vector2 delta2 = contour[i + 1] - contour[i];
			if ((delta1.Length()!=0)&amp;&amp;(delta2.Length()!=0))
			{
				delta1.Normalize();
				delta2.Normalize();
				normal = GameMath.Normal(delta1 + delta2);
			}

		}
		// Add two vertices to the vertex list
		result.Add(contour[i] - normal * width / 2f);
		result.Add(contour[i] + normal * width / 2f);
	}
	return result;
}

/// <summary>
/// Returns one normal of the 2D vector
/// </summary>
/// <param name="vector"></param>
/// <returns></returns>
public static Vector2 Normal(Vector2 line)
{
	float x = line.X; float y = line.Y;
	Vector2 normal = new Vector2();
	if (x != 0)
	{
		normal.X = -y / x;
		normal.Y = 1 / (float)Math.Sqrt(normal.X * normal.X + 1);
		normal.Normalize();
	}
	else if (y != 0)
	{
		normal.Y = 0;
		normal.X = (line.Y<0) ? 1 : -1;
	}
	else
	{
		normal.X = 1;
		normal.Y = 0;
	}
	if (x < 0)
	{
		normal *= -1;
	}
	return normal;
}

That code is well enough to generate a credible line in almost all situations. As for UVs, what I did was assign the even vertices the value (X,0) and odd vertices (X,1), where X is the distance elapsed since the line start.