HW1

Submission

This assignment was pretty difficult – I wasn't able to fully implement everything, but it was fun and challenging to try. Afterwards I'll try to go back and finish it. While I initially had trouble with noise (it was looking very magenta) this turned out to be a relatively quick fix – since the magenta was the color of the background so in the future I made sure to check that I was setting the alpha channel to 255.

Conceptually, it also took me a while to get how the Gaussian filter was supposed to work, but once I worked that out, sharpen was easy (since it ended up being almost the same thing. Additionally, the process of applying a 'filter' matrix to an image was similar for other types of image manipulation such as edge detection. The sampling parts for scale were pretty straightforward for the two sampling methods I implemented. I started implementing Gaussian sampling, but I ran out of time (and the output I go ended up being a gradient, so I figured I would try my hand at getting other parts working).

Brightness: Brightens an image by a given factor

-brightness 1.5

Random Noise: Add noise to an image by a given factor

-noise .5

Crop: Extract a subimage specified by a corner (x,y) and area

-crop 100 35 300 300

Extract Channel: Leave specified channel intact (R,G,B) and set all others to zero (excluding alpha channel)

-extractChannel 0

Contrast: Change the contrast of an image by a given factor

-contrast 0
-contrast 2

Saturation: Change the saturation of an image by a given factor

-saturation 0
-saturation 5
-saturation -5

Sharpen: Sharpen an image by extrapolating from a blurred version

-sharpen 7

Quantize: Change the number of bits per channel of an image, using simple ronuding

-quantize 1
-quantize 2
-quantize 4
-quantize 8

Random dither: convert an image to a given number of bits per channel, using a randomized threshold

-randomDither 1
-randomDither 2
-randomDither 4
-randomDither 8

Blur: Blur and image by convolving it with a Gaussian low-pass filter

-blur 7 (note: this is with sigma manually set to 1)
-blur 7 (note: this is with sigma manually set to 2)

Edge detect: Detect edges in an image by convolving it with an edge detection kernel

-edgeDetect

Floyd-Steinberg dither: Convert an image to a given number of bits per channel, using dithering with error diffusion

-FloydSteinbergDither 1
-FloydSteinbergDither 2
-FloydSteinbergDither 4
-FloydSteinbergDither 8

Scale: Scale an image up or down in size by a real valued factor

-sampling 0 -scale 3 3
-sampling 1 -scale 3 3

Rotate: Rotate an image by a given angle

-sampling 0 -rotate 25
-sampling 1 -rotate 25
-sampling 0 -rotate 45
-sampling 1 -rotate 45

And a fun one for the art contest

Executable here (Google Drive link) compiled on Mac. Code below.

#include "image.h"
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>

/**
 * Image
 **/
Image::Image (int width_, int height_){

assert(width_ > 0);
    assert(height_ > 0);

width           = width_;
    height          = height_;
    num_pixels      = width * height;
    sampling_method = IMAGE_SAMPLING_POINT;
    
    data.raw = new uint8_t[num_pixels*4];
	int b = 0; //which byte to write to
	for (int j = 0; j < height; j++){
		for (int i = 0; i < width; i++){
			data.raw[b++] = 0;
			data.raw[b++] = 0;
			data.raw[b++] = 0;
			data.raw[b++] = 0;
		}
	}

assert(data.raw != NULL);
}

Image::Image (const Image& src){
	
	width           = src.width;
    height          = src.height;
    num_pixels      = width * height;
    sampling_method = IMAGE_SAMPLING_POINT;
    
    data.raw = new uint8_t[num_pixels*4];
    
    //memcpy(data.raw, src.data.raw, num_pixels);
    *data.raw = *src.data.raw;
}

Image::Image (char* fname){

int numComponents; //(e.g., Y, YA, RGB, or RGBA)
	data.raw = stbi_load(fname, &width, &height, &numComponents, 4);
	
	if (data.raw == NULL){
		printf("Error loading image: %s", fname);
		exit(-1);
	}

num_pixels = width * height;
	sampling_method = IMAGE_SAMPLING_POINT;
	
}

Image::~Image (){
    delete data.raw;
    data.raw = NULL;
}

void Image::Write(char* fname){
	
	int lastc = strlen(fname);

switch (fname[lastc-1]){
	   case 'g': //jpeg (or jpg) or png
	     if (fname[lastc-2] == 'p' || fname[lastc-2] == 'e') //jpeg or jpg
	        stbi_write_jpg(fname, width, height, 4, data.raw, 95);  //95% jpeg quality
	     else //png
	        stbi_write_png(fname, width, height, 4, data.raw, width*4);
	     break;
	   case 'a': //tga (targa)
	     stbi_write_tga(fname, width, height, 4, data.raw);
	     break;
	   case 'p': //bmp
	   default:
	     stbi_write_bmp(fname, width, height, 4, data.raw);
	}
}

void Image::AddNoise (double factor)
{
	int x,y;
	Pixel p;
	for (x = 0 ; x < Width() ; x++)
	{
		for (y = 0 ; y < Height() ; y++)
		{
			double r = (double)rand() / (RAND_MAX); // random double 0 to 1
			if (r <= factor)
			{
				p = PixelRandom();
				p.a = 255;
				GetPixel(x,y) = p;
			}

}
	}
}

void Image::Brighten (double factor)
{
	int x,y;
	for (x = 0 ; x < Width() ; x++)
	{
		for (y = 0 ; y < Height() ; y++)
		{
			Pixel p = GetPixel(x, y);
			Pixel scaled_p = p*factor;
			scaled_p.a = 255;
			GetPixel(x,y) = scaled_p;
		}
	}
}

float Image::AvgLuminance()
{
	float lum = 0;
	int x, y;
	Pixel p;
	for (x = 0; x < Width(); x++)
	{
		for (y = 0; y < Height(); y++)
		{
			p = GetPixel(x,y);
			lum += p.Luminance();
		}
	}
	// lum is the sum of all of the values of luminance right now
	// divide by Width() * Height() to get the average
	lum = lum / (Width() * Height());
	return lum;
}

void Image::ChangeContrast (double factor)
{
	// average gray image for linear interpolation (lerp)
	float avglum = AvgLuminance();
	Pixel avgGray = Pixel(avglum, avglum, avglum);

int x, y;
	Pixel p;
	Pixel scaled_p;
	float lum;
	for (x = 0; x < Width(); x++)
	{
		for (y = 0; y < Height(); y++)
		{
			p = GetPixel(x,y);
			lum = p.Luminance();
			scaled_p = PixelLerp(p, avgGray, (1-factor));
				// linear interpolation between the current pixel and average pixel by given factor
				// do (1-factor) so that factor of 0 will result in a gray image
			scaled_p.a = 255;
				// set alpha channel to 255, avoid magenta pixels
			GetPixel(x,y) = scaled_p;
		}
	}
}

void Image::ChangeSaturation(double factor)
{
	// Three ways to get a gray scale image: lightness, average, and luminosity
	// Implementing luminosity – accounts for differences in how the brightness of colors is pereived
	int x, y;
	Pixel p, gray, scaled_p;
	float lum;
	for (x = 0; x < Width(); x++)
	{
		for (y = 0; y < Height(); y++)
		{
			p = GetPixel(x,y);
			// grayscale pixel for linear interpolation
			lum = p.Luminance();
			gray = Pixel(lum, lum, lum);
			gray.a = 255;
				// set alpha channel to 255, avoid magenta pixels
			scaled_p = PixelLerp(p, gray, (1-factor));
				// linear interpolation between the current pixel and grayscale pixel by given factor
				// do (1-factor) so that factor of 0 will result in a grayscale image
			GetPixel(x,y) = scaled_p;
		}
	}
}

Image* Image::Crop(int x, int y, int w, int h)
{
	Image* result = new Image(w,h);
	int x_i = 0;
	int y_i = 0;
	
	for (x_i = 0; x_i < w; x_i++)
	{
		for (y_i = 0; y_i < h; y_i++)
		{
			result->GetPixel(x_i, y_i) = GetPixel(x+x_i, y+y_i);
		}
	}

// TODO: Error checking

return result;
}

// ExtractChannel
// TODO: add a part to the -help text about these assumptions
// **  NOTE THE FOLLOWING ASSUMPTIONS  **
// Assumptions: channels indexed starting at 0 for R, G, B
// 				this EXCLUDES the alpha channel (otherwise results wouldn't be visible)
void Image::ExtractChannel(int channel)
{
	int x,y;
	Pixel q;
	q.SetClamp(0,0,0);
	if (channel == 0) 		// R
		q.SetClamp(1,0,0);
	else if (channel == 1)  // B
		q.SetClamp(0,1,0);
	else if (channel == 2)	// G
		q.SetClamp(0,0,1);
	Pixel p, extracted_p;
	for (x = 0 ; x < Width() ; x++)
	{
		for (y = 0 ; y < Height() ; y++)
		{
			p = GetPixel(x, y);
			extracted_p = p * q;
			GetPixel(x,y) = extracted_p;
		}
	}
}

void Image::Quantize (int nbits)
{
	int x, y;
	Pixel p;
	for (x = 0; x < Width(); x++)
	{
		for (y = 0; y < Height(); y++)
		{
			p = GetPixel(x,y);
			GetPixel(x,y) = PixelQuant(p, nbits);
		}
	}
}

void Image::RandomDither (int nbits)
{
	int x, y;
	Pixel p, pq;
	int r, g, b;
	//double r;
	for (x = 0; x < Width(); x++)
	{
		for (y = 0; y < Height(); y++)
		{
			p = GetPixel(x,y);
			GetPixel(x,y) = PixelRandQuant(p, nbits);
		}
	}
}

static int Bayer4[4][4] =
{
    {15,  7, 13,  5},
    { 3, 11,  1,  9},
    {12,  4, 14,  6},
    { 0,  8,  2, 10}
};

void Image::OrderedDither(int nbits)
{
	/* WORK HERE */
}

/* Error-diffusion parameters */
const double
    ALPHA = 7.0 / 16.0,
    BETA  = 3.0 / 16.0,
    GAMMA = 5.0 / 16.0,
    DELTA = 1.0 / 16.0;

void Image::FloydSteinbergDither(int nbits)
{
	int x, y;
	Pixel p, tp;
	int red, green, blue;
	int r_qe, g_qe, b_qe; // quantization error for r,g,b

for (x = 0; x < Width(); x++)
	{
		for (y = 0; y < Height(); y++)
		{
			p = GetPixel(x,y);
			tp = p;

int var = pow(2,9-nbits)-1;
			/* round rgb values to nearest threshhold */
			if (p.r%(var+1) > (var+1)/2)
			{
				red = (p.r-(p.r%var)+var);
			}
			else
			{
				red = (p.r-(p.r%var));
			}
			if (p.g%(var+1) > (var+1)/2)
			{
				green = (p.g-(p.g%var)+var);
			}
			else
			{
				green = (p.g-(p.g%var));
			}
			if (p.b%(var+1) > (var+1)/2)
			{
				blue = (p.b-(p.b%var)+var);
			}
			else
			{
				blue = (p.b-(p.b%var));
			}

tp.SetClamp(red,green,blue);
			GetPixel(x,y) = tp;
			
			r_qe = p.r - tp.r;
			g_qe = p.g - tp.g;
			b_qe = p.b - tp.b;
			// Diffuse the error and check bounds
			
			if (x < Width() - 1)
			{
				this->GetPixel(x+1, y).SetClamp(
					this->GetPixel(x+1, y).r + r_qe * ALPHA,
					this->GetPixel(x+1, y).g + g_qe * ALPHA,
					this->GetPixel(x+1, y).b + b_qe * ALPHA
					);
			}
			if ((x > 0) && (y < Height() - 1))
			{
				this->GetPixel(x-1, y+1).SetClamp(
					this->GetPixel(x-1, y+1).r + r_qe * BETA,
					this->GetPixel(x-1, y+1).g + g_qe * BETA,
					this->GetPixel(x-1, y+1).b + b_qe * BETA
					);
			}
			if (y < Height() - 1)
			{
				this->GetPixel(x, y+1).SetClamp(
					this->GetPixel(x, y+1).r + r_qe * GAMMA,
					this->GetPixel(x, y+1).g + g_qe * GAMMA,
					this->GetPixel(x, y+1).b + b_qe * GAMMA
					);
			}
			if ((x < Width() - 1) && (y < Height() - 1) )
			{
				this->GetPixel(x+1, y+1).SetClamp(
					this->GetPixel(x+1, y+1).r + r_qe * DELTA,
					this->GetPixel(x+1, y+1).g + g_qe * DELTA,
					this->GetPixel(x+1, y+1).b + b_qe * DELTA
					);
			}
		}
	}
}

void Image::Blur(int n)
{
	// 1. create the gaussian filter (n by n)
	float sigma = 2; // for now set sigma (std deviation) to 0.5, play around with this value
	sigma = 2*pow(sigma,2); // 2*sigma^2 is used twice in the 2D gaussian equation
	float frc = 1/(M_PI*sigma); // the first half of the 2D gaussian equation, doesn't change based on and y

float filter[n][n];
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			filter[i][j] = frc * exp(-(pow(n/2-i,2)+pow(n/2-j,2))/(sigma));
		}
	}

// 2. apply the filter
	int x,y, n_x, n_y;
	float r,g,b;
	Pixel p, tp;
	Image* temp = new Image(Width(), Height());
		// temp image, image after filtering
		// avoid changing image while applying filters
	int radius;		// calculate radius of the filter, later when we're apply the filter we'll know where to start
	if (n%2 == 0)	// if even just do N/2, if odd do N/2 + 1
	{
		radius = n/2;
	}
	else
	{
		radius = n/2+1;
	}

for (x = 0; x < Width(); x++)
	{
		for (y = 0; y < Height(); y++)
		{
			r = 0.0;
			g = 0.0;
			b = 0.0;
			// then go through each element of the filter
			for (int i = 0; i < n; i++)
			{
				for (int j = 0; j < n; j++)
				{
					n_x = ((i+x-radius)+Width())%Width();
					n_y = ((j+y-radius)+Height())%Height();
					p = GetPixel(n_x,n_y); // add then mod by width and height ensures wrap around since negative mod-ing not working
					r += p.r * filter[i][j];
					g += p.g * filter[i][j];
					b += p.b * filter[i][j];
				}
			}
			tp.r = fmin(fmax(r,0),255);
			tp.g = fmin(fmax(g,0),255);
			tp.b = fmin(fmax(b,0),255);
			temp->SetPixel(x,y,tp);
		}
	}

// replace image with temp
	for (x = 0; x < Width(); x++)
	{
		for (y = 0; y < Height(); y++)
		{
			tp = temp->GetPixel(x,y);
			GetPixel(x,y) = tp;
		}
	}
}

void Image::Sharpen(int n)
{
	// at the moment, the code from sharpen will be almost identical to blur
	float sigma=0.5;sigma=2*pow(sigma,2);float frc=1/(M_PI*sigma);float filter[n][n];for(int i=0;i<n;i++){for(int j=0;j<n;j++){filter[i][j] = frc*exp(-(pow(n/2-i,2)+pow(n/2-j,2))/(sigma));}}int x,y,n_x,n_y;float r,g,b;Pixel p,tp;Image* temp=new Image(Width(),Height());int radius;if (n%2 == 0){radius = n/2;}else{radius = n/2+1;}for (x=0;x<Width();x++){for(y=0;y< Height();y++){r=0.0;g=0.0;b=0.0;for(int i=0;i<n;i++){for(int j=0;j<n;j++){n_x=((i+x-radius)+Width())%Width();n_y=((j+y-radius)+Height())%Height();p=GetPixel(n_x,n_y);r+=p.r*filter[i][j];g+=p.g*filter[i][j];b+=p.b*filter[i][j];}}tp.r=fmin(fmax(r,0),255);tp.g=fmin(fmax(g,0),255);tp.b=fmin(fmax(b,0),255);temp->SetPixel(x,y,tp);}}
	// the following line is the blur code with all white spaces removed

// replace image with temp
	for (x = 0; x < Width(); x++)
	{
		for (y = 0; y < Height(); y++)
		{
			// temp has the blurry pixel
			p = GetPixel(x,y);
			tp = temp->GetPixel(x,y);
			GetPixel(x,y) = PixelLerp(p,tp,-0.5); // interpolation from the normal image and blurry image
												  // set interpolation factor to -0.5 (arbitrary, just has to be negative since 'inverse' interpolation)
		}
	}
}

static int edFilter[3][3] =
{
	{-1, -1, -1},
	{-1, 8, -1},
	{-1, -1, -1}
};

void Image::EdgeDetect()
{
	int x, y, i, j;
	int n_x, n_y;
	float r, g, b;
	Pixel p, bp, tp; // pixels from: current image, blurred image, and temp (edge detected) image
	Image* blur = new Image(Width(), Height());
	Image* temp = new Image(Width(), Height());
	for (x = 0; x < Width(); x++)
	{
		for (y = 0; y < Height(); y++)
		{
			p = GetPixel(x,y);
			blur->SetPixel(x,y,p);
		}
	}
	// blur the image (get rid of big details), getting ready for edge detection
	blur->Blur(5);

for (x = 0; x < Width(); x++)
	{
		for (y = 0; y < Height(); y++)
		{
			//bp = blur->GetPixel(x,y);
			r = 0.0;
			g = 0.0;
			b = 0.0;
			// then go through each element of the filter
			for (i = 0; i < 3; i++) // limited by the size (3x3) of the filter
			{
				for (j = 0; j < 3; j++)
				{
					n_x = ((i+x-2)+Width())%Width();
					n_y = ((j+y-2)+Height())%Height();
					bp = blur->GetPixel(n_x,n_y);
					r += bp.r * edFilter[i][j];
					g += bp.g * edFilter[i][j];
					b += bp.b * edFilter[i][j];
				}
			}
			tp.r = fmin(fmax(r,0),255);
			tp.g = fmin(fmax(g,0),255);
			tp.b = fmin(fmax(b,0),255);
			temp->SetPixel(x,y,tp);
		}
	}

// replace image with temp
	for (x = 0; x < Width(); x++)
	{
		for (y = 0; y < Height(); y++)
		{
			// temp has the blurry pixel
			p = GetPixel(x,y);
			tp = temp->GetPixel(x,y);
			GetPixel(x,y) = tp;
		}
	}
}

Image* Image::Scale(double sx, double sy)
{
	int width_n = sx*Width();
	int height_n = sy*Height();

float u,v;

Image* ret = new Image(width_n, height_n);

for (int x = 0; x < width_n; x++)
	{
		for (int y = 0; y < height_n; y++)
		{
			u = x/sx;
			v = y/sy;
			ret->GetPixel(x,y) = Sample(u,v);
		}
	}
	return ret;
}

Image *Image::Rotate(double angle)
{
	angle = -angle;
	angle = angle * M_PI/180.0; // convert from degrees to radians

// get size of new image
	int width_n  = Height() * abs(sin(angle)) + Width() * abs(sin(M_PI / 2 - angle));
	int height_n = Height() * abs(cos(angle)) + Width() * abs(cos(M_PI / 2 - angle));

int x_diff = (width_n - Width()) / 2;
	int y_diff = (height_n - Height()) / 2;

Image* ret = new Image(width_n, height_n);
	int half_w = Width() / 2;
	int half_h = Height() / 2;

float u, v;
	for (int x = 0; x < width_n; x++)
	{
		for (int y = 0; y < height_n; y++)
		{
			int x_n = x - x_diff;
			int y_n = y - y_diff;
			u = (x_n - half_w) * cos(angle) - (y_n - half_h) * sin(angle) + half_w;
			v = (x_n - half_w) * sin(angle) + (y_n - half_h) * cos(angle) + half_h;

if (!ValidCoord(u,v))
			{
				// do nothing, before this red was to test
				//ret->GetPixel(x,y) = Pixel(255,0,0);
			}
			else
			{
				ret->GetPixel(x,y) = Sample(u,v);
			}
		}
	}
  	return ret;
}

void Image::Fun()
{
	/* WORK HERE */
}

/**
 * Image Sample
 **/
void Image::SetSamplingMethod(int method)
{
    assert((method >= 0) && (method < IMAGE_N_SAMPLING_METHODS));
    sampling_method = method;
}

Pixel Image::Sample (double u, double v){
    // take two floats and make them ints

Pixel p; // pixel
	int x, y;

// for bilinear interpolation
	Pixel p1, p2, p3, p4;
	int x_l, x_h, y_l, y_h; // x and y low and high (floor and ceil)
	int w1, w2, w3, w4;
	float fx, fy, fx1, fy1;

if (sampling_method == 0) // nearest-neighbor (I think)
    {
    	//printf("point\n");
    	// cast doubles as ints (will round down)
    	x = (int)u;
    	y = (int)v;
    	p = GetPixel(x,y);
    }
    else if (sampling_method == 1) // 2D bilinear interpolation
    {
    	int r, g, b;
 		x_l = (int)u%Width();
 		y_l = (int)v%Height();
    	x_h = ceil(u);
    	x_h = x_h%Width();
    	y_h = ceil(v);
    	y_h = y_h%Height();
 
		p1 = GetPixel(x_l, y_l);
		p2 = GetPixel(x_h, y_l);
		p3 = GetPixel(x_l, y_h);
		p4 = GetPixel(x_h, y_h);
 
		// Calculate the weights for each pixel
		fx = u - x_l;
		fy = v - y_l;
		fx1 = 1.0f - fx;
		fy1 = 1.0f - fy;

w1 = fx1 * fy1 * 256.0f;
		w2 = fx  * fy1 * 256.0f;
		w3 = fx1 * fy  * 256.0f;
		w4 = fx  * fy  * 256.0f;
 
		// Calculate the weighted sum of pixels (for each color channel)
		r = p1.r * w1 + p2.r * w2 + p3.r * w3 + p4.r * w4;
		g = p1.g * w1 + p2.g * w2 + p3.g * w3 + p4.g * w4;
		b = p1.b * w1 + p2.b * w2 + p3.b * w3 + p4.b * w4;

return Pixel(r >> 8, g >> 8, b >> 8, 255);
    }
    else if (sampling_method == 2) // gaussian
    {
    	/*
    	int n = 5;
		// 1. create the gaussian filter (n by n)
		float sigma = 2; // for now set sigma (std deviation) to 0.5, play around with this value
		sigma = 2*pow(sigma,2); // 2*sigma^2 is used twice in the 2D gaussian equation
		float frc = 1/(M_PI*sigma); // the first half of the 2D gaussian equation, doesn't change based on and y
		float filter[n][n];
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				filter[i][j] = frc * exp(-(pow(n/2-i,2)+pow(n/2-j,2))/(sigma));
			}
		}
		// 2. apply the filter
		int n_x, n_y;
		float r,g,b;
		Pixel p, tp;
		Image* temp = new Image(Width(), Height());
			// temp image, image after filtering
			// avoid changing image while applying filters
		int radius;		// calculate radius of the filter, later when we're apply the filter we'll know where to start
		if (n%2 == 0)	// if even just do N/2, if odd do N/2 + 1
		{
			radius = n/2;
		}
		else
		{
			radius = n/2+1;
		}*/
/*
		for (x = 0; x < Width(); x++)
		{
			for (y = 0; y < Height(); y++)
			{
				r = 0.0;
				g = 0.0;
				b = 0.0;
				// then go through each element of the filter
				for (int i = 0; i < n; i++)
				{
					for (int j = 0; j < n; j++)
					{
						n_x = ((i+x-radius)+Width())%Width();
						n_y = ((j+y-radius)+Height())%Height();
						p = GetPixel(n_x,n_y); // add then mod by width and height ensures wrap around since negative mod-ing not working
						r += p.r * filter[i][j];
						g += p.g * filter[i][j];
						b += p.b * filter[i][j];
					}
				}
				tp.r = fmin(fmax(r,0),255);
				tp.g = fmin(fmax(g,0),255);
				tp.b = fmin(fmax(b,0),255);
				temp->SetPixel(x,y,tp);
			}
		}
		*/
/*
		// replace image with temp
		for (x = 0; x < Width(); x++)
		{
			for (y = 0; y < Height(); y++)
			{
				tp = temp->GetPixel(x,y);
				GetPixel(x,y) = tp;
			}
		}
		return GetPixel(x,y);*/
		return Pixel(0,0,0);

}

return p;
}