Out of Memory Exception in C#

Question

i am new to C#. Thus, i am not so sure what the problem is with my program. The program works with small image but it shows "Out of memory exeception" when it works with a large image which is about A4 size. However, the program would be useless if it cannot work with large image. How can I solve the problem? With thanks.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;


namespace ConsoleApplication6
{
    class Program
    {
        static void Main(string[] args)
        {
            //Bitmap objects

            //input image
            Bitmap bmOrg = (Bitmap)Bitmap.FromFile(@"C:\B.png");  
            Bitmap bmTransparentLayover = new Bitmap(bmOrg.Width, bmOrg.Height);

            //Create Graphic Objects.
            Graphics gOriginal = Graphics.FromImage(bmOrg);
            Graphics gTransparentLayover = Graphics.FromImage(bmTransparentLayover);

            //Set Transparent Graphics back ground to an "odd" color 
            //     that hopefully won't be used to
            //Be changed to transparent later.
            gTransparentLayover.FillRectangle
                                ( Brushes.Pink, 
                                  new Rectangle
                                  (0, 
                                   0, 
                                   bmTransparentLayover.Width, 
                                   bmTransparentLayover.Height
                                  )
                                );

            //Draw "transparent" graphics that will look through 
            //  the overlay onto the original.
            //Using LimeGreen in hopes that it's not used.

            Point[] points = new Point[5];
            points[0] = new Point(130, 140);
            points[1] = new Point(130, 370);
            points[2] = new Point(420, 370);
            points[3] = new Point(420, 140);
            points[4] = new Point(130, 140);
            System.Drawing.Drawing2D.GraphicsPath gp = new
            System.Drawing.Drawing2D.GraphicsPath();
            gp.AddPolygon(points);
            gTransparentLayover.FillPath(Brushes.LimeGreen, gp);

            //Now make the LimeGreen Transparent to see through overlay.
            bmTransparentLayover.MakeTransparent(Color.LimeGreen);

            //draw the overlay on top of the original.
            gOriginal.DrawImage(bmTransparentLayover, 
             new Rectangle(0, 0, bmTransparentLayover.Width, bmTransparentLayover.Height));

            //Create new image to make the overlays background tranparent
            Bitmap bm3 = new Bitmap(bmOrg);
            bm3.MakeTransparent(Color.Pink);

            //Save file.
            //to save the output image 
            bm3.Save(@"save.png",System.Drawing.Imaging.ImageFormat.Png);  

            Image img = new Bitmap(480, 480);

            //the background image 
            img = Image.FromFile(@"a.png");  
            Graphics g = Graphics.FromImage(img);

            //to save the combined image 
            g.DrawImage(Image.FromFile(@"save.png"), new Point(-50, -70));
            img.Save(@"final.png", ImageFormat.Png); 
        }
    }
}

Answer 1

it is a 9992x8750 image

Yes, you're in the danger zone for a 32-bit process. That image requires a big chunk of contiguous address space, 334 megabytes. You'll easily get that when you load the image early, right after your program starts. You can get about 650 megabytes at that point, give or take.

But that goes down-hill from there as your program allocates and releases memory and loads a couple of assemblies. The address space gets fragmented, the holes between the allocations are getting smaller. Just loading a DLL with an awkward base address can suddenly cut the largest hole by more than a factor of two. The problem is not the total amount of virtual memory available, it can be a gigabyte or more, it is the size of the largest available chunk. After a while, having a 90 megabyte allocation fail is not entirely unusual. Just that one allocation can fail, you could still allocate a bunch of, say, 50 megabyte chunks.

There is no cure for address space fragmentation and you can't fix the way that the Bitmap class stores the pixel data. But one, specify a 64-bit version of Windows as a requirement for your program. It provides gobs of virtual memory, fragmentation is a non-issue. If you want to chase it down then you can get insight in the VM layout with the SysInternals' VMMap utility. Beware of the information overload you may experience.