Can't use GDI+. Can a line be drawn on a bitmap using Windows API call?

Question

We have an app written in C++ 6 that fills in blank polygons on a traffic map to show current traffic conditions. Green for good, yellow more congested, etc.

The "shell maps" are bitmaps of the roadways using rectangles and polygons that have nothing filled in them. Data is collected from roadway sensors (wire inductor loops) and the polygons are filled based on loop detector data.

When the maps change, someone has to manually zoom in the bitmap in paint, and get the coordinates around the inside of each new shape, where the congestion color will be filled in. The polygons that make the map skeleton are all drawn in navy blue, on a white background.

I made an app. where when the user clicks anywhere inside the white part of the polygon, the points for the inside perimeter are displayed to the user, with a zoomed in thumbnail showing the inside permiter painted.

In .Net, the perimeter is painted perfectly.

In the C++ 6 app, some of the polyon points my app. collects don't display correctly.

I looked at msPaint, and .Net does not draw the points the same way as MS Paint.

Here's a quick example. Code is from one form with one button and one label. A line is drawn on a bitmap, the bitmap is "zoomed in" so you can see it, and displayed on the label.

The line segment drawn is not the same as the line segment that you draw in MS Paint if you draw a line in Paint using the same two points.

  private void button1_Click(object sender, EventArgs e)
    {
        Bitmap bm = new Bitmap(16, 16);
        Graphics g = Graphics.FromImage(bm);
        //g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.Half;
        //g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
        //g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighSpeed;
        //g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.None;
        g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.Default;
        Point pt = new Point(1, 3);
        Point pt2 = new Point(5, 1);
        // If you reverse the points, the same line is drawn.
        g.DrawLine(Pens.Orange, pt, pt2);
        // label1.Image = bm;
        Bitmap bm2 = ZoomMap(8, bm);
        g.Dispose();
        bm.Dispose();
        label1.Image = bm2;
    }

    private Bitmap ZoomMap(int zoomValue, Bitmap bm)
    {
        Bitmap zoomedBitMap;
        Size sz = bm.Size;// new Size(75, 75);
        Size newSize = new Size(sz.Width * zoomValue, sz.Height * zoomValue);
        zoomedBitMap = new Bitmap(newSize.Width, newSize.Height);
        Graphics gr = Graphics.FromImage(zoomedBitMap);
        gr.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor;
        gr.PageUnit = GraphicsUnit.Pixel;
        gr.DrawImage(bm, 1, 1, newSize.Width, newSize.Height);
        gr.Dispose();
        return zoomedBitMap;
    }

No matter what settings I apply, there is no way to mimic MS Paint in C#, but in C++ 6 mimics MS Paint perfectly.

Is there any type of windows API I can call to draw on an existing bitmap?

Thanks in advance for any replies.

Answer 1

Using either digital differential analizer (DDA) or the Bresenham algorithm will yield the same results you see for GDI+, but if you look at the standard GDI line drawing implementation you will notice that the standard GDI LineTo implementation actually draws the line one pixel shorter than what you specify, to quote the MSDN

'The LineTo function draws a line from the current position up to, but not including, the specified point.'

Because of this, using GDI your line is drawn from (1,3)-(4,1), if you use these same coordinates in GDI+ you will see that the pixel structure of the line matches what you see in older versions of Paint, except of course that the last pixel at (5,1) is not drawn. A program like Paint would then just add the additional pixel to complete the line.

Using straight GDI would require that you handle the interop for creating pens, selecting object into the DC deleteing the objects etc. all very possible but ultimately inconvenient. You could rather simulate this in GDI+ by drawing a line that is one pixel short and then draw a line from that endpoint to the final endpoint, this will fill in the last pixel.

Note: I say older versions of Paint, because if you use Paint in Windows 7 for example you will see that the line is drawn correctly.

For fun I thought I would quickly show how you might use classic GDI from .NET, here is some interop code.

[DllImport("gdi32")]
static extern bool MoveToEx(IntPtr hdc, int x, int y, out Point point);

[DllImport("gdi32")]
static extern bool LineTo(IntPtr hdc, int x, int y);

[DllImport("gdi32")]
static extern IntPtr SelectObject(IntPtr hdc, IntPtr hgdiobj);

[DllImport("gdi32")]
static extern IntPtr CreatePen(int penStyle, int width, int color);

[DllImport("gdi32")]
static extern bool DeleteObject(IntPtr hgiobj);

private void Form1_Paint(object sender, PaintEventArgs e)
{
  Point ignore;
  IntPtr hdc = e.Graphics.GetHdc();
  IntPtr pen = CreatePen(1, 1, ColorTranslator.ToWin32(Color.Red));
  IntPtr oldPen = SelectObject(hdc, pen);
  MoveToEx(hdc, 1, 3, out ignore);
  LineTo(hdc, 5, 1);                
  SelectObject(hdc, oldPen);
  DeleteObject(pen);      
}

Notice how the line is actually one pixel short. Personally I would go with a native .NET solution using the Graphics device and just dermine the correct line coordinate to replicate the clasic GDI functionality.

I thought you might be interested to know why GDI leaves off the last pixel, it was common to use XOR to draw a line on the screen that would make removing the same line very simple, just redraw the line with XOR and it is removed with the original background intact. Of course this ment that you need to be careful not to draw over a pixel twice otherwise you would leave artifacts on the screen.

Since it is common to use draw a shape using multiple LineTo calls you can now call LineTo 3 time to draw a triangle for example and not be concerned that the first point of each line will overlap the last point of the previous line and cause the said artifacts when using XOR for example, susequent calls to LineTo can safely start at where the previous line ended because the last pixel of the previous line was not drawn.