Programming in C BMP Composite Images Write a program that takes a color BMP fil

Question

Programming in C BMP Composite Images

Write a program that takes a color BMP file and produces a composite image, as shown below,
containing the original image, a grayscale version of it, a monochrome version of it, and a BBC codeword
image.

Each image should be 640 (width) x 480 (height).
Each image should be surrounded by a 4-pixel thick brown border (RGB = 139, 69, 19).
Each image should be separated by 16 pixels of white.
The entire composite image should have a 4-pixel thick brown border at the very outside edge.
There should be 20 pixels of white between the overall border and the outer border of each image.
Starting with the original color image, your program should first produce a grayscale image.
From the grayscale image your program should produce the monochrome image using the Floyd-
Steinberg dithering algorithm:
https://en.wikipedia.org/wiki/Floyd%E2%80%93Steinberg_dithering

The average intensity of the original color image should be adjusted so that the black density of the
monochrome image is about 33% (anything between 30% and 35% is acceptable).

Your program should then produce the BBC codeword image that approximates the monochrome
image. The density of the codeword image should be approximately the same as that of the
monochrome image.

The message that is used to generate the codeword should be written to a text file using Base-64
encoding.

Finally, your program should panelize the four images into a single image, add the borders, and save the
result to the file.

For simplicity, hardcode the file names in your program as follows:
Original color image: color.bmp
Composite image: composite.bmp
Base-64 encoded codeword: codeword.txt

Deliverables
In addition to your source code files, you need to include the three files mentioned above (the original
color image, the composite image, and the codeword file). The resulting ZIP file may be fairly large since
the two image files will total to approximately 5 MB. The codeword file will probably be on the order of
20 kB. However, you are likely to get significant compression, perhaps in the 75% to 90% range.

Explanation / Answer

public void SetColorFilter(ColorFilterTypes colorFilterType)
{
Bitmap temp = (Bitmap)_currentBitmap;
Bitmap bmap = (Bitmap)temp.Clone();
Color c;
for (int i = 0; i < bmap.Width; i++)
{
for (int j = 0; j < bmap.Height; j++)
{
c = bmap.GetPixel(i, j);
int nPixelR = 0;
int nPixelG = 0;
int nPixelB = 0;
if (colorFilterType == ColorFilterTypes.Red)
{
nPixelR = c.R;
nPixelG = c.G - 255;
nPixelB = c.B - 255;
}
else if (colorFilterType == ColorFilterTypes.Green)
{
nPixelR = c.R - 255;
nPixelG = c.G;
nPixelB = c.B - 255;
}
else if (colorFilterType == ColorFilterTypes.Blue)
{
nPixelR = c.R - 255;
nPixelG = c.G - 255;
nPixelB = c.B;
}
nPixelR = Math.Max(nPixelR, 0);
nPixelR = Math.Min(255, nPixelR);

nPixelG = Math.Max(nPixelG, 0);
nPixelG = Math.Min(255, nPixelG);

nPixelB = Math.Max(nPixelB, 0);
nPixelB = Math.Min(255, nPixelB);

bmap.SetPixel(i, j, Color.FromArgb((byte)nPixelR,
                   (byte)nPixelG, (byte)nPixelB));
}
}
_currentBitmap = (Bitmap)bmap.Clone();
}
ublic void SetGamma(double red, double green, double blue)
{
Bitmap temp = (Bitmap)_currentBitmap;
Bitmap bmap = (Bitmap)temp.Clone();
Color c;
byte[] redGamma = CreateGammaArray(red);
byte[] greenGamma = CreateGammaArray(green);
byte[] blueGamma = CreateGammaArray(blue);
for (int i = 0; i < bmap.Width; i++)
{
for (int j = 0; j < bmap.Height; j++)
{
c = bmap.GetPixel(i, j);
bmap.SetPixel(i, j, Color.FromArgb(redGamma[c.R],
                   greenGamma[c.G], blueGamma[c.B]));
}
}
_currentBitmap = (Bitmap)bmap.Clone();
}
ublic void SetGrayscale()
{
   Bitmap temp = (Bitmap)_currentBitmap;
Bitmap bmap = (Bitmap)temp.Clone();
Color c;
for (int i = 0; i < bmap.Width; i++)
{
for (int j = 0; j < bmap.Height; j++)
{
c = bmap.GetPixel(i, j);
byte gray = (byte)(.299 * c.R + .587 * c.G + .114 * c.B);

bmap.SetPixel(i, j, Color.FromArgb(gray, gray, gray));
}
}
_currentBitmap = (Bitmap)bmap.Clone();
}
public void Resize(int newWidth, int newHeight)
{
   if (newWidth != 0 && newHeight != 0)
{
Bitmap temp = (Bitmap)_currentBitmap;
Bitmap bmap = new Bitmap(newWidth, newHeight, temp.PixelFormat);

double nWidthFactor = (double)temp.Width / (double)newWidth;
double nHeightFactor = (double)temp.Height / (double)newHeight;

double fx, fy, nx, ny;
int cx, cy, fr_x, fr_y;
Color color1 = new Color();
Color color2 = new Color();
Color color3 = new Color();
Color color4 = new Color();
byte nRed, nGreen, nBlue;

byte bp1, bp2;

for (int x = 0; x < bmap.Width; ++x)
{
for (int y = 0; y < bmap.Height; ++y)
{

fr_x = (int)Math.Floor(x * nWidthFactor);
fr_y = (int)Math.Floor(y * nHeightFactor);
cx = fr_x + 1;
if (cx >= temp.Width) cx = fr_x;
cy = fr_y + 1;
if (cy >= temp.Height) cy = fr_y;
fx = x * nWidthFactor - fr_x;
fy = y * nHeightFactor - fr_y;
nx = 1.0 - fx;
ny = 1.0 - fy;

color1 = temp.GetPixel(fr_x, fr_y);
color2 = temp.GetPixel(cx, fr_y);
color3 = temp.GetPixel(fr_x, cy);
color4 = temp.GetPixel(cx, cy);

bp1 = (byte)(nx * color1.B + fx * color2.B);

bp2 = (byte)(nx * color3.B + fx * color4.B);

nBlue = (byte)(ny * (double)(bp1) + fy * (double)(bp2));

bp1 = (byte)(nx * color1.G + fx * color2.G);

bp2 = (byte)(nx * color3.G + fx * color4.G);

nGreen = (byte)(ny * (double)(bp1) + fy * (double)(bp2));

bp1 = (byte)(nx * color1.R + fx * color2.R);

bp2 = (byte)(nx * color3.R + fx * color4.R);

nRed = (byte)(ny * (double)(bp1) + fy * (double)(bp2));

bmap.SetPixel(x, y, System.Drawing.Color.FromArgb
                       (255, nRed, nGreen, nBlue));
}
}
_currentBitmap = (Bitmap)bmap.Clone();
}
}

Related Questions

Navigate

• Browse (All)
• Browse P
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.