imagine two lines meeting at a vital corner. those lines have a lot of point in "RemovedVertices", even slight changes in direction accumulate to a big error. removing a vital corner -> very big error. on the other side, removing vertices on the path between two vital corners won't affect the minimal distance between every removed vertex and the line.

that was of course just the simpelst of the ways to calculate the error. you can improve the error metric without changing the algorithm to improve the situation in various ways.

1. you can calculate 'normals' per vertex by averaging the normals of the two lines connected to it. once you start removing vectors, you do a dot between the normals of the removed vertices and the normal of the line that substitutes those. a vector line that follows a pixel line will have a similar normal as long as you remove vertices within two vital corners. but if you remove a vital corner, you'll change the line normal and even if you do that slightly, accumulated across the whole lines the error will be big.

2. you can weight vertex error by the distance to the vertices of your original shapes (that you've used to draw those.

3. you can try to detect 'vital' edges by calculating the 'hardness' between two neighboring vertex normals. basically, if the angle is beyond a specific treshold, you define that edge as 'vital' and never remove it.

4. more complex error metric would be to draw the reduced shape again. removing some vertices that aren't important will result in a very similar shape, removing 'vital' points will lead to a different bitmap (of course, that's time consuming, but might be ok for an offline process).

alternative: while drawing the original shape, you could first draw the vertices as bigger dots. (different color). then the shapes. all original and important vertices will be surrounded by the dot-colors. so it would be easy to detect those. all vertices within the shape will be overdrawn.

Actually I was thinking more about your original idea and I think it would be the solution after all. I was thinking that vertices would be eliminated if the length error of their absence is within a certain margin, but the actual solution (and what I believe you were trying to say) is to only remove the single least useful vertex after evaluating all of them, and then repeat, until the error from removing any remaining vertex is above the threshold. As the least useful vertices are removed, the error from removing the remaining ones becomes much larger and so they would not be erroneously removed.

Last night I wrote the code to complete step #2 (creating the ordered lists of points for each polygon) so today I will write the simplification algorithm and let you know how it goes.

Update: I had implemented the length-based solution but found that it did not work perfectly; it seemed to eliminate curve definition too much or it allowed unnecessary pixels to remain. I came up with a different technique: for each pixel, I find the longest chain of pixels following it that are near the line drawn from the first pixel to the last of the chain. Then I remove all the pixels between the start and end. This nicely handles all sloped lines and can precisely determine the corner pixels.

I'll post code and sample images later. The code is really sloppy right now but I'll try to clean it up a bit first.

I'm too lazy right now to make the code neatly arranged so attached is the quick'n'dirty code. It's a C# console application that reads an image, figures out the required points, and outputs an image showing them. It also outputs intermediate images showing the steps taken to get to that point. I've also attached one of these sample output images.

EDIT: Apparently it doesn't let me attach source code files. Well here is the entire file:

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;

namespace Vector
{
    struct Point
    {
        public static readonly Point Zero = new Point(0,0);

        public double X;
        public double Y;

        public Point (double x, double y)
        {
            X = x;
            Y = y;
        }

        public override string ToString ()
        {
            return "{" + X + "," + Y + "}";
        }
    }

    class Polygon
    {
        public List<Point> Points;

        public Polygon ()
        {
            Points = new List<Point>();
        }
    }

    class Path
    {
        public List<Point> Points;
        public bool[,] EdgeMap;

        public Path (bool[,] edgeMap, IEnumerable<Point> points)
        {
            EdgeMap = (bool[,])edgeMap.Clone();

            Points = new List<Point>();
            Points.AddRange(points);
        }
    }

    class Program
    {
        static readonly double EDGE_OFFSET_THRESHOLD = 1;
        static readonly string INPUT_PATH = @"A:\Data\shape.png";

        static void Main (string[] args)
        {
            Bitmap bmp = (Bitmap) Image.FromFile(INPUT_PATH);
            bool[,] edgeMap;
            int edgeCount;

            FindEdges(bmp, out edgeMap, out edgeCount);

            Bitmap output = new Bitmap(bmp.Width, bmp.Height);

            for (int y = 0; y < bmp.Height; y++)
                for (int x = 0; x < bmp.Width; x++)
                {
                    if (edgeMap[x,y])
                        output.SetPixel(x, y, Color.White);
                    else
                        output.SetPixel(x, y, Color.Black);
                }

            output.Save(INPUT_PATH + ".edges.png", ImageFormat.Png);

            // Now find the polygons:

            List<Polygon> polygons = new List<Polygon>();

            while (edgeCount > 0)
            {
                // Remove any point to start a new polygon
                Point point = FindRandomEdge(edgeMap);
                edgeMap[(int) point.X, (int) point.Y] = false;

                // Create the first path
                Path path = new Path(edgeMap, new Point[0]);
                path.Points.Add(point);
                List<Path> paths = new List<Path>();
                paths.Add(path);

                EvaluatePath(path, paths);

                // Now look through the list of paths to find the one(s) with the
                // most points. There may be two with the same number of points;
                // just choose the first one arbitrarily in that case.

                Path bestPath = null;
                int bestCount = 0;

                foreach (Path option in paths)
                {
                    Point first = option.Points[0];
                    Point last = option.Points[option.Points.Count-1];

                    // Look for the path that has all the points and that
                    // correctly forms a closed polygon.

                    if (first.X >= last.X-1 &&
                        first.X <= last.X+1 &&
                        first.Y >= last.Y-1 &&
                        first.Y <= last.Y+1 &&
                        option.Points.Count > bestCount)
                    {
                        bestCount = option.Points.Count;
                        bestPath = option;
                    }
                }

                edgeCount -= bestCount;

                // Create the new polygon
                Polygon polygon = new Polygon();
                polygon.Points.AddRange(bestPath.Points);
                polygons.Add(polygon);

                edgeMap = bestPath.EdgeMap;
            }

            output = new Bitmap(bmp.Width, bmp.Height);

            for (int y = 0; y < bmp.Height; y++)
                for (int x = 0; x < bmp.Width; x++)
                    output.SetPixel(x, y, Color.Black);

            for (int n = 0; n < polygons.Count; n++)
            {
                for (int p = 0; p < polygons[n].Points.Count; p++)
                    output.SetPixel((int) polygons[n].Points[p].X, (int) polygons[n].Points[p].Y, GetPolygonColor(n));
            }

            output.Save(INPUT_PATH + ".polygons.png", ImageFormat.Png);

            // Now we need to remove useless edge pixels until we only have the corners remaining.

            foreach (Polygon polygon in polygons)
            {
                int p = 0;
                while (p < polygon.Points.Count)
                {
                    Point start = polygon.Points[p];
                    int removeCount = 0;

                    for (int n = 2; n < polygon.Points.Count; n++)
                    {
                        int endIndex = (p+n) % polygon.Points.Count;
                        Point end = polygon.Points[endIndex];
                        bool removeToEnd = true;

                        // Now see if all pixels between start and end are within the allowed distance
                        // from the line from start to end. If so then keep going. Otherwise we are done
                        // and can eliminate any pixels between start and end.

                        for (int m = 1; m < n; m++)
                        {
                            int middleIndex = (p+m) % polygon.Points.Count;
                            Point middle = polygon.Points[middleIndex];
                            double distance = GetPointSegmentDistance(middle, start, end);
                            if (distance > EDGE_OFFSET_THRESHOLD)
                            {
                                // We've found a pixel that must not be removed so stop here.
                                removeToEnd = false;
                                break;
                            }
                        }

                        if (removeToEnd)
                            removeCount = n-1;
                        else
                            break;
                    }

                    if (removeCount > 0)
                    {
                        int firstRemoval = (p+1) % polygon.Points.Count;
                        int lastRemoval = (p+removeCount) % polygon.Points.Count;

                        // We've found at least one pixel to remove.
                        if (firstRemoval <= lastRemoval)
                        {
                            polygon.Points.RemoveRange(firstRemoval, 1+lastRemoval-firstRemoval);
                            p++;
                        }
                        else
                        {
                            polygon.Points.RemoveRange(firstRemoval, polygon.Points.Count - firstRemoval);
                            polygon.Points.RemoveRange(0, 1+lastRemoval);
                            break;
                        } 
                    }
                    else
                        p++;
                }
            }

            for (int n = 0; n < polygons.Count; n++)
            {
                for (int p = 0; p < polygons[n].Points.Count; p++)
                    output.SetPixel((int) polygons[n].Points[p].X, (int) polygons[n].Points[p].Y, Color.White);
            }

            output.Save(INPUT_PATH + ".corners.png", ImageFormat.Png);
        }

        static void FindEdges (Bitmap bmp, out bool[,] edgeMap, out int edgeCount)
        {
            edgeMap = new bool[bmp.Width, bmp.Height];
            edgeCount = 0;

            // Important: do not count diagonals.

            for (int y = 1; y < bmp.Height-1; y++)
            {
                for (int x = 1; x < bmp.Width-1; x++)
                {
                    if (bmp.GetPixel(x, y).R > 0)
                    {
                        // This is a foreground pixel (part of the polygon).
                        // Count how many surrounded pixels are the background.

                        int count = (bmp.GetPixel(x-1, y).R == 0 ? 1 : 0) +
                                    (bmp.GetPixel(x+1, y).R == 0 ? 1 : 0) +
                                    (bmp.GetPixel(x, y-1).R == 0 ? 1 : 0) +
                                    (bmp.GetPixel(x, y+1).R == 0 ? 1 : 0);

                        if (count > 0 && count < 4)
                        {
                            // It counts as an edge
                            edgeMap[x, y] = true;
                            edgeCount++;
                        }
                    }
                }
            }

            // Now we have to eliminate any edge pixels that are adjacent (including diagonally)
            // to only one other edge pixel; they are dead-ends.

            bool outliersFound = true;
            while (outliersFound)
            {
                outliersFound = false;

                for (int y = 1; y < bmp.Height-1; y++)
                {
                    for (int x = 1; x < bmp.Width-1; x++)
                    {
                        if (edgeMap[x, y])
                        {
                            int count = (edgeMap[x-1, y-1] ? 1 : 0) +
                                        (edgeMap[x-1, y] ? 1 : 0) +
                                        (edgeMap[x-1, y+1] ? 1 : 0) +
                                        (edgeMap[x, y-1] ? 1 : 0) +
                                        (edgeMap[x, y+1] ? 1 : 0) +
                                        (edgeMap[x+1, y-1] ? 1 : 0) +
                                        (edgeMap[x+1, y] ? 1 : 0) +
                                        (edgeMap[x+1, y+1] ? 1 : 0);

                            if (count == 1)
                            {
                                edgeMap[x, y] = false;
                                edgeCount--;
                                outliersFound = true;
                            }
                        }
                    }
                }
            }
        }

        static double GetPointLineDistance (Point p, Point lineA, Point lineB)
        {
            double length = GetLength(lineA, lineB);
            double xAP = lineA.X - p.X;
            double yAP = lineA.Y - p.Y;
            double xBA = (lineB.X - lineA.X) / length;
            double yBA = (lineB.Y - lineA.Y) / length;

			return (xAP * yBA) - (yAP * xBA);
        }

        static double GetNearestPointOffsetOnLine (Point p, Point lineA, Point lineB)
        {
            double xAP = p.X - lineA.X;
            double yAP = p.Y - lineA.Y;
            double xAB = lineB.X - lineA.X;
            double yAB = lineB.Y - lineA.Y;

            double ABdotAB = (xAB*xAB) + (yAB*yAB);
            double APdotAB = (xAP*xAB) + (yAP*yAB);

            if (ABdotAB != 0)
                return APdotAB / ABdotAB;
            else
                return double.NaN;
        }

        static Point GetPointOnLine (Point lineA, Point lineB, double offset)
        {
            double x = lineA.X + (offset * (lineB.X - lineA.X));
            double y = lineA.Y + (offset * (lineB.Y - lineA.Y));
            return new Point(x, y);
        }

        static double GetPointSegmentDistance (Point p, Point segmentA, Point segmentB)
        {
            double offset = GetNearestPointOffsetOnLine(p, segmentA, segmentB);
            if (offset <= 0)
                return GetLength(p, segmentA);
            else if (offset >= 1)
                return GetLength(p, segmentB);
            else
                return GetLength(p, GetPointOnLine(segmentA, segmentB, offset));
        }

        static double GetLength (Point p1, Point p2)
        {
            double dx = p1.X - p2.X;
            double dy = p1.Y - p2.Y;

            return Math.Sqrt((dx*dx) + (dy*dy));
        }

        static Color GetPolygonColor (int index)
        {
            switch (index)
            {
                case 0:
                    return Color.FromArgb(64, 0, 0);
                case 1:
                    return Color.FromArgb(64, 64, 0);
                case 2:
                    return Color.FromArgb(0, 64, 0);
                case 3:
                    return Color.FromArgb(0, 64, 64);
                case 4:
                    return Color.FromArgb(0, 0, 64);
                case 5:
                    return Color.FromArgb(64, 0, 64);
                default:
                    return Color.FromArgb(64, 64, 64);
            }
        }

        static void EvaluatePath (Path path, IList<Path> allPaths)
        {
            while (true)
            {
                List<Point> adjacent = FindAdjacentEdges(path.EdgeMap, path.Points[path.Points.Count-1]);
                if (adjacent.Count >= 2)
                {
                    // Multiple options so create new paths for each option.
                    for (int a = 0; a < adjacent.Count; a++)
                    {
                        Path branch = new Path(path.EdgeMap, path.Points);
                        branch.Points.Add(adjacent[a]);
                        branch.EdgeMap[(int) adjacent[a].X, (int) adjacent[a].Y] = false;
                        allPaths.Add(branch);

                        EvaluatePath(branch, allPaths);
                    }

                    // This path must be abandoned now.
                    break;
                }
                else if (adjacent.Count == 1)
                {
                    // Only one direction to go.
                    path.Points.Add(adjacent[0]);
                    path.EdgeMap[(int) adjacent[0].X, (int) adjacent[0].Y] = false;
                }
                else
                {
                    // No more adjacent pixels; we're done with this path
                    break;
                }
            }
        }

        static Point FindRandomEdge (bool[,] edgeMap)
        {
            for (int y = 1; y < edgeMap.GetLength(1)-1; y++)
                for (int x = 1; x < edgeMap.GetLength(0)-1; x++)
                {
                    if (edgeMap[x, y])
                        return new Point(x, y);
                }

            return Point.Zero;
        }

        static List<Point> FindAdjacentEdges (bool[,] edgeMap, Point point)
        {
            List<Point> list = new List<Point>();

            for (int y = (int) point.Y-1; y <= (int) point.Y+1; y++)
                for (int x = (int) point.X-1; x <= (int) point.X+1; x++)
                {
                    if (x == point.X && y == point.Y)
                        continue;

                    if (edgeMap[x, y])
                        list.Add(new Point(x, y));
                }

            return list;
        }
    }
}