C++ Image Processing Homework (dynamic 2d array binary i/o trouble)
Well this is my first post on the board; hopefully I got the code tags right.
For my advanced c++ course I had to write a program that read in a .bmp file that was 256 colors and 320x240 pixels.
Here are the instructions:
"Project #4
Image Processing
Write a C++ program to read an image and apply some statistical functions to it.
Write your Image C++ class in a header file, and call an instance of it from the source file.
1. Read an image
2. Find the MEAN of the image
3. Find the STDV of the image
4. Apply the following filter to the image and write the output image to the disk.
1 1 1
1 2 1
1 1 1
5. Write the result buffer to an image."
I managed to do all this but then he threw me a curve ball. He told us to dynamically allocate the buffers. I thought I knew how to do this but I was wrong apparently as I can't get it to work. If anyone can help me I would appreciate it.
Below is the code I have written.
file = Image.h
Code:
#include <fstream>
using namespace std;
typedef unsigned char uchar;
class CImage
{
public:
CImage(const char* filename);
~CImage();
void write(const char* filename);
double mean();
double stdv();
void filter();
private:
ifstream* m_pInFile;
ofstream* m_pOutFile;
uchar m_cHeaderData[1078];
uchar** m_cImageData;
uchar m_cFilter[3][3];
uchar** m_cFilteredData;
};
file = Image.cpp
Code:
#ifndef __IMAGE_H
#define __IMAGE_H
#define WIDTH 320
#define HEIGHT 240
#include "Image.h"
#include <cmath>
#endif
using namespace std;
typedef unsigned char uchar;
///////////////////////////////////////////////////////////////////////////////
// Constructor
///////////////////////////////////////////////////////////////////////////////
CImage::CImage(const char* filename)
{
m_cImageData = new uchar* [HEIGHT];
m_cFilteredData = new uchar* [HEIGHT];
for( int i = 0; i < HEIGHT; i++)
{
m_cImageData[i] = new uchar [WIDTH];
m_cFilteredData[i] = new uchar [WIDTH];
}
m_pInFile = new ifstream;
m_pInFile->open(filename, ios::in | ios::binary);
m_pInFile->seekg(0, ios::beg);
m_pInFile->read(reinterpret_cast<char*>(m_cHeaderData[i]), 1078);
for( i = 0; i < HEIGHT; i++)
{
m_pInFile->read(reinterpret_cast<char*>(m_cImageData[i]), WIDTH);
}
m_pInFile->close();
// define the filter for the image
char m_cFilter[3][3] = {
{1, 1, 1},
{1, 2, 1},
{1, 1, 1}
};
}
///////////////////////////////////////////////////////////////////////////////
// Destructor
///////////////////////////////////////////////////////////////////////////////
CImage::~CImage()
{
delete m_pInFile;
delete m_pOutFile;
for(int i = 0; i < HEIGHT; i++)
{
delete[] m_cImageData[i];
delete[] m_cFilteredData[i];
}
delete[] m_cImageData;
delete[] m_cFilteredData;
}
///////////////////////////////////////////////////////////////////////////////
// Output the filtered image to a new bitmap file
///////////////////////////////////////////////////////////////////////////////
void CImage::write(const char* filename)
{
filter();
m_pOutFile = new ofstream;
m_pOutFile->open(filename, ios::out | ios::trunc | ios::binary);
m_pOutFile->write(reinterpret_cast<char*>(m_cHeaderData), 1078);
for(int i = 0; i < HEIGHT; i++)
{
m_pOutFile->write(reinterpret_cast<char*>(m_cFilteredData[i]), WIDTH);
}
m_pOutFile->close();
}
///////////////////////////////////////////////////////////////////////////////
// Calculate the mean of all the pixels
///////////////////////////////////////////////////////////////////////////////
double CImage::mean()
{
double total = 0;
for(int i = 0; i < HEIGHT; i++)
{
for(int j = 0; j < WIDTH; j++)
{
total += m_cImageData[i][j];
}
}
return (total / (HEIGHT * WIDTH));
}
///////////////////////////////////////////////////////////////////////////////
// Calculate the standard deviation of all the pixels
///////////////////////////////////////////////////////////////////////////////
double CImage::stdv()
{
double avg = mean();
double radicand = 0;
for(int i = 0; i < HEIGHT; i++)
{
for(int j = 0; j < WIDTH; j++)
{
radicand += (m_cImageData[i][j] - avg) * (m_cImageData[i][j] - avg);
}
}
radicand /= (HEIGHT * WIDTH);
return sqrt(radicand);
}
///////////////////////////////////////////////////////////////////////////////
// Filter all the pixels
///////////////////////////////////////////////////////////////////////////////
void CImage::filter()
{
int sumofpixels = 0;
for(int i = 0; i < HEIGHT; i++)
{
strcpy(reinterpret_cast<char*>(m_cFilteredData[i]), reinterpret_cast<char*>(m_cImageData[i]));
}
for( i = 1; i < HEIGHT - 1; i++)
{
for(int j = 1; j < WIDTH - 1; j++)
{
sumofpixels = m_cFilter[0][0] * m_cImageData[i+1][j-1] + // top left corner
m_cFilter[0][1] * m_cImageData[i+1][j] + // top center
m_cFilter[0][2] * m_cImageData[i+1][j+1] + // top right corner
m_cFilter[1][0] * m_cImageData[i][j-1] + // center left
m_cFilter[1][1] * m_cImageData[i][j] + // center center
m_cFilter[1][2] * m_cImageData[i][j+1] + // center right
m_cFilter[2][0] * m_cImageData[i-1][j-1] + // bottom left corner
m_cFilter[2][1] * m_cImageData[i-1][j] + // bottom center
m_cFilter[2][2] * m_cImageData[i-1][j+1]; // bottom right corner
m_cFilteredData[i][j] = (sumofpixels / (m_cFilter[0][0] + m_cFilter[0][1] +
m_cFilter[0][2] + m_cFilter[1][0] +
m_cFilter[1][1] + m_cFilter[1][2] +
m_cFilter[2][0] + m_cFilter[2][1] +
m_cFilter[2][2]) );
}
}
}
file = Project4.cpp
Code:
#include "Image.h"
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
CImage ci("test.bmp");
ci.write("output.bmp");
cout << ci.mean() << endl;
cout << ci.stdv() << endl;
return 0;
}
