title: Write RGB values to a BITMAP image file
body: <p>I am currently working on imaging processing using arrays to store R,G,B values from a 24 bit BITMAP image of width 120 and height 100 pixels.
  Visual Studio 2010 is being used. </p>
  
  <p>I have currently extracted the individual R,G,B values into three separate2D  arrays from the 24 bit bitmap (it is assumed correct as the correct R,G,B values have been written to a text file with the right pixel count as well).</p>
  
  <p>These individual R,G,B values need to be restored back into an array (either 1D or 2D), which is then written to an image file. The output should be identical to the original image.</p>
  
  <p>I have tried the following but the output is currently incorrect (same width, height and memory size but colouring is incorrect). </p>
  
  <p>Appreciate your guidance and feedback.</p>
  
  <pre><code>#include &lt;iostream&gt;
  #include &lt;fstream&gt;
  #include &lt;windows.h&gt;
  #include &lt;WinGDI.h&gt;
  
  unsigned char** Allocate2DArray(int w, int h)
  {
       unsigned char ** buffer = new unsigned char * [h];  // allocate the rows
  
       unsigned char * memory_pool = new unsigned char [w*h];  // allocate memory pool
       for (int i = 0; i &lt; h; ++i)
       {
           buffer[i] = memory_pool;   // point row pointer
           memory_pool += w;          // go to next row in memory pool
       }
       return buffer;
  }
  
  void DeAllocate2DArray(unsigned char** buffer) 
  {  
      delete [] buffer[0];  // delete the memory pool
      delete [] buffer;     // delete the row pointers
  }
  
  
  
  using namespace std;
  
  int main()
  {
  
  const int width = 120;
  const int height = 100;
  
      int bytesPerPixel = 3;
      unsigned char m_cHeaderData[54];
      unsigned char** m_cImageData = new unsigned char* [height];
  
      for( int i = 0; i &lt;height; i++)
      {
          m_cImageData[i] = new unsigned char [width*bytesPerPixel];
      }
  
      ifstream* m_pInFile;    
      m_pInFile = new ifstream;
      m_pInFile-&gt;open("image.bmp", ios::in | ios::binary);
      m_pInFile-&gt;seekg(0, ios::beg);
      m_pInFile-&gt;read(reinterpret_cast&lt;char*&gt;(m_cHeaderData), 54); 
      for(int i = 0; i &lt;height; i++)
      {
          m_pInFile-&gt;read(reinterpret_cast&lt;char*&gt;(m_cImageData[i]), width*bytesPerPixel); 
  
      }
  
      m_pInFile-&gt;close();
  
  
      // Declare a pointer of the type you want. 
      // This will point to the 1D array 
      unsigned char* array_1D; 
      array_1D = new unsigned char[height*width*bytesPerPixel]; 
      if(array_1D == NULL) return 0;  // return if memory not allocated 
  
      // Copy contents from the existing 2D array
      int offset = 0;
  
      for(int j=0; j&lt;height; j++)  // traverse height (or rows) 
      {  
          offset = width * bytesPerPixel* j;  
          for(int i=0; i&lt;width*bytesPerPixel; i++) // traverse width  
          {   
              array_1D[offset + i] = m_cImageData[j][i]; 
                       // update value at current (i, j)  
  
          } 
      }
  
  
      // Declare three 2D arrays to store R,G, and B planes of image. 
      unsigned char**arrayR_2D, **arrayG_2D, **arrayB_2D;   
      arrayR_2D = Allocate2DArray(width, height); 
      arrayG_2D = Allocate2DArray(width, height); 
      arrayB_2D = Allocate2DArray(width, height); 
  
      // return if memory not allocated 
      if(arrayR_2D == NULL || arrayG_2D == NULL || arrayB_2D == NULL) return 0; 
  
  
      // Extract R,G,B planes from the existing composite 1D array 
      ofstream RGBdata2D;
      RGBdata2D.open("RGBdata2D.txt");    
      int pixelCount = 0;
      int offsetx = 0; 
      int counter = 0; 
  
      for(int j=0; j&lt;height; j++)  // traverse height (or rows) 
      {  
          offsetx = width * j * bytesPerPixel;  
          for(int i=0; i&lt;width*bytesPerPixel; i+=bytesPerPixel) // width  
          {   
              arrayB_2D[j][counter] = array_1D[offsetx + i+0];   
              arrayG_2D[j][counter] = array_1D[offsetx + i+1];   
              arrayR_2D[j][counter] = array_1D[offsetx + i+2];  
  
           RGBdata2D&lt;&lt;"B: "&lt;&lt; (int)arrayB_2D[j][counter] &lt;&lt; " G: " &lt;&lt; (int)arrayG_2D[j][counter] &lt;&lt; " R: " &lt;&lt; (int)arrayR_2D[j][counter]&lt;&lt; endl;
          pixelCount++;
  
          ++counter;
          }
  
          counter = 0; 
      }
  
      RGBdata2D&lt;&lt;"count of pixels: "&lt;&lt; pixelCount &lt;&lt; endl;
      RGBdata2D.close();
  
  
         //put RGB from 2D array contents back into a 1D array 
      offset = 0; 
      counter = 0; 
      for(int j=0; j&lt;height; j++)  // traverse height (or rows) 
      {  
          offset = width * bytesPerPixel * j;  
          for(int i=0; i&lt;width*bytesPerPixel; i+=bytesPerPixel) // width  
          {   
              array_1D[offset + i+0] = arrayB_2D[j][counter++]; 
              array_1D[offset + i+1] = arrayG_2D[j][counter++]; 
              array_1D[offset + i+2] = arrayR_2D[j][counter++];
  
          } 
          counter = 0; 
      } 
  
      ofstream* m_pOutFileRGB;    
      m_pOutFileRGB = new ofstream;
      m_pOutFileRGB-&gt;open("imageCopyRGB.bmp", ios::out | ios::trunc | ios::binary);    
      m_pOutFileRGB-&gt;write(reinterpret_cast&lt;char*&gt;(m_cHeaderData), 54); 
      for(int i = 0; i &lt;height; i++)
      {
          m_pOutFileRGB-&gt;write(reinterpret_cast&lt;char*&gt;(array_1D), width*bytesPerPixel); 
  
      }
  
      m_pOutFileRGB-&gt;close();
  
  
  
      // After complete usage, delete the memory dynamically allocated 
      DeAllocate2DArray(arrayR_2D); 
      DeAllocate2DArray(arrayG_2D); 
      DeAllocate2DArray(arrayB_2D);
  
  
      // After complete usage, delete the memory dynamically allocated 
      delete[] array_1D; //delete the pointer to pointer 
  
  
      for(int i = 0; i &lt;height; i++)
      {
          delete[] m_cImageData[i];
      }
      delete[] m_cImageData;
  
  
      system("pause");
  
      return 0;
  }
  </code></pre>