Merge pull request #3 from obee58/librarify

Refactor Complete, before proj5 implementation

Author: obee58

Makefile

@@ -11,7 +11,7 @@ endif
 
 # I have spent an hour on fixing this makefile and make refuses to read a list one-by-one
 # just copy the lines and replace the filenames
-default: clean project4	
+default: recompile
 
 project1: imgview
 project3: alphamask compose
@@ -21,13 +21,13 @@ all: imgview alphamask compose convolve
 recompile: clean all
 
 imgview:
-	${CXX} ${CPPFLAGS} -o imgview src/imgview.cpp ${LD}
+	${CXX} ${CPPFLAGS} -o imgview src/imgview.cpp src/gloiioFuncs.cpp ${LD}
 alphamask:
-	${CXX} ${CPPFLAGS} -o alphamask src/alphamask.cpp ${LD}
+	${CXX} ${CPPFLAGS} -o alphamask src/alphamask.cpp src/gloiioFuncs.cpp ${LD}
 compose:
-	${CXX} ${CPPFLAGS} -o compose src/compose.cpp ${LD}
+	${CXX} ${CPPFLAGS} -o compose src/compose.cpp src/gloiioFuncs.cpp ${LD}
 convolve:
-	${CXX} ${CPPFLAGS} -o convolve src/convolve.cpp ${LD}
+	${CXX} ${CPPFLAGS} -o convolve src/convolve.cpp src/gloiioFuncs.cpp ${LD}
 
 clean:
 	rm -f core.* *.o *~ imgview alphamask compose convolve

README.md

@@ -1,10 +1,8 @@
-# cpsc4040-GLOIIO project4 (v0.4)
+# cpsc4040-GLOIIO (v1.0.-1 "librarified")
 #### OpenGL/GLUT Program Suite to read, display, modify, and write images using the OpenImageIO API
-Dr. Karamouzas "Convolution"
-
 by Owen Book ([email protected])
 
-*CPSC 4040 | Fall 2022*
+*CPSC 4040 | Dr. Karamouzas | Fall 2022*
 
 ### Compilation
 Makefile is included. You can run these commands:
@@ -33,8 +31,6 @@ I: invert colors of current image
 
 N: randomly add black noise to current image
 
-*P: display the first set of bytes of the image data in hex*  
-
 Q or ESC: quit program
 
 #### Command line usage

src/alphamask.cpp

@@ -5,11 +5,11 @@
 //	Input can be any image type, output will be png
 //
 //	CPSC 4040 | Owen Book | October 2022
-
+#include "gloiioFuncs.h"
 #include <OpenImageIO/imageio.h>
 #include <iostream>
 #include <string>
-#include <cmath>
+#include <exception>
 
 #ifdef __APPLE__
 #  pragma clang diagnostic ignored "-Wdeprecated-declarations"
@@ -25,266 +25,13 @@ OIIO_NAMESPACE_USING
 //default window dimensions
 #define DEFAULT_WIDTH 600	
 #define DEFAULT_HEIGHT 600
-//assumed maximum value of pixel data - change if modifying for int, float, etc.
-#define MAX_VAL 255
-//preprocess macros
-#define maximum(x,y,z) ((x) > (y)? ((x) > (z)? (x) : (z)) : ((y) > (z)? (y) : (z)))
-#define minimum(x,y,z) ((x) < (y)? ((x) < (z)? (x) : (z)) : ((y) < (z)? (y) : (z)))
-
-//utility struct that holds RGBA 4-tuple of chars
-typedef struct pixel_rgba_t {
-	unsigned char red, green, blue, alpha;
-} pxRGBA;
-//utility struct that holds RGB 3-tuple of chars
-typedef struct pixel_rgb_t {
-	unsigned char red, green, blue;
-} pxRGB;
-//utility struct that holds HSV 3-tuple of doubles
-typedef struct pixel_hsv_t {
-	double hue, saturation, value;
-} pxHSV;
-
-//struct to tie image spec and pixels together
-typedef struct image_rgba_uint8_t {
-	ImageSpec spec;
-	pxRGBA* pixels;
-} ImageRGBA;
-
 
 /** CONTROL & GLOBAL STATICS **/
 //list of read images for multi-image viewing mode
 static vector<ImageRGBA> imageCache;
 //current index in vector to attempt to load (probably won't be touched in this program)
 static int cacheIndex = 0;
 
-/** UTILITY FUNCTIONS **/
-/*	clean up memory of unneeded ImageRGBA
-	don't forget to remove it from imageCache first! */
-void discardImage(ImageRGBA image) {
-	delete image.pixels;
-}
-
-/* functions to quickly create pxRGB, pxRGBA, pxHSV,... from arbitrary values*/
-pxRGB linkRGB(unsigned char r, unsigned char g, unsigned char b) {
-	pxRGB px;
-	px.red = r;
-	px.green = g;
-	px.blue = b;
-	return px;
-}
-pxRGBA linkRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a) {
-	pxRGBA px;
-	px.red = r;
-	px.green = g;
-	px.blue = b;
-	px.alpha = a;
-	return px;
-}
-pxHSV linkHSV(double h, double s, double v) {
-	pxHSV px;
-	px.hue = h;
-	px.saturation = s;
-	px.value = v;
-	return px;
-}
-
-/*convert RGB values into HSV values*/
-pxHSV RGBtoHSV(pxRGB rgb) {
-	pxHSV hsv;
-	double huer, hueg, hueb, max, min, delta;
-	/* convert from 0-255 to 0~1 */
-	huer = rgb.red / 255.0;
-	hueg = rgb.green / 255.0;
-	hueb = rgb.blue / 255.0;
-
-	max = maximum(huer, hueg, hueb);
-	min = minimum(huer, hueg, hueb);
-	hsv.value = max;
-
-	if (max==0) {
-		hsv.hue = 0;
-		hsv.value = 0;
-	}
-	else {
-		delta = max-min;
-		hsv.saturation = delta/max; //https://youtu.be/QYbG1AMSdiY
-		if (delta == 0) {
-			hsv.hue = 0;
-		}
-		else {
-			/* determine hue */
-			if (huer == max) {
-				hsv.hue = (hueg - hueb) / delta;
-			}
-			else if (hueg == max) {
-				hsv.hue = 2.0 + (hueb - huer) / delta;
-			}
-			else {
-				hsv.hue = 4.0 + (huer - hueg) / delta;
-			}
-			hsv.hue *= 60.0;
-			if (hsv.hue < 0) {
-				hsv.hue += 360.0;
-			}
-		}
-	}
-
-	return hsv;
-}
-
-/* shorthand function that double-converts RGBA to HSV, ignoring alpha channel */
-pxHSV RGBAtoHSV(pxRGBA rgba) {
-	return RGBtoHSV(linkRGB(rgba.red, rgba.green, rgba.blue));
-}
-
-/** PROCESSING FUNCTIONS **/
-/*  reads in image from specified filename as RGBA 8bit pixmap
-	puts a new ImageRGBA in the imageCache vector if successful */
-void readImage(string filename) {
-	std::unique_ptr<ImageInput> in = ImageInput::open(filename);
-	if (!in) {
-		std::cerr << "could not open input file! " << geterror();
-		//cancel routine
-		return;
-	}
-
-	//store spec and get metadata from it
-	ImageRGBA image;
-	image.spec = in->spec();
-	int xr = image.spec.width;
-	int yr = image.spec.height;
-	int channels = image.spec.nchannels;
-
-	//declare temp memory to read raw image data
-	unsigned char temp_px[xr*yr*channels];
-
-	// read the image into the temp_px from the input file, flipping it upside down using negative y-stride,
-	// since OpenGL pixmaps have the bottom scanline first, and 
-	// oiio expects the top scanline first in the image file.
-	int scanlinesize = xr * channels * sizeof(unsigned char);
-	if(!in->read_image(TypeDesc::UINT8, temp_px+((yr-1)*scanlinesize), AutoStride, -scanlinesize)){
-		cerr << "Could not read image from " << filename << ", error = " << geterror() << endl;
-		//cancel routine
-		return;
-  	}
-	
-	//allocate data for converted pxRGBA version
-	image.pixels = new pxRGBA[xr*yr];
-	//convert and store raw image data as pxRGBAs
-	for (int i=0; i<yr*xr; i++) {
-		switch(channels) {
-			//this could be more cleanly programmed but the less convoluted the better
-			case 1: //grayscale
-				image.pixels[i].red = temp_px[i];
-				image.pixels[i].green = temp_px[i];
-				image.pixels[i].blue = temp_px[i];
-				image.pixels[i].alpha = 255;
-				break;
-			case 2: //weird grayscale with alpha (just covering my ass here)
-				image.pixels[i].red = temp_px[2*i];
-				image.pixels[i].green = temp_px[2*i];
-				image.pixels[i].blue = temp_px[2*i];
-				image.pixels[i].alpha = temp_px[(2*i)+1];
-				break;
-			case 3: //RGB
-				image.pixels[i].red = temp_px[(3*i)];
-				image.pixels[i].green = temp_px[(3*i)+1];
-				image.pixels[i].blue = temp_px[(3*i)+2];
-				image.pixels[i].alpha = 255;
-				break;
-			case 4: //RGBA
-				image.pixels[i].red = temp_px[(4*i)];
-				image.pixels[i].green = temp_px[(4*i)+1];
-				image.pixels[i].blue = temp_px[(4*i)+2];
-				image.pixels[i].alpha = temp_px[(4*i)+3];
-				break;
-			default: //something weird, just do nothing
-				break;
-		}
-	}
-
-	//close input
-	in->close();
-	//store struct in cache and switch to display this image
-	imageCache.push_back(image);
-	cacheIndex = imageCache.size()-1;
-}
-
-/* writes currently dixplayed pixmap (as RGBA) to a file
-	(mostly the same as sample code) */
-void writeImage(string filename){
-	int xr = imageCache[cacheIndex].spec.width;
-	int yr = imageCache[cacheIndex].spec.height;
-	int channels = 4;
-	//temporary 1d array to stick all the pxRGBA data into
-	//write_image does not like my structs >:(
-	unsigned char temp_px[xr*yr*channels];
-	for (int i=0; i<xr*yr; i++) {
-		temp_px[(4*i)] = imageCache[cacheIndex].pixels[i].red;
-		temp_px[(4*i)+1] = imageCache[cacheIndex].pixels[i].green;
-		temp_px[(4*i)+2] = imageCache[cacheIndex].pixels[i].blue;
-		temp_px[(4*i)+3] = imageCache[cacheIndex].pixels[i].alpha;
-	}
-
-	// create the oiio file handler for the image
-	std::unique_ptr<ImageOutput> outfile = ImageOutput::create(filename);
-	if(!outfile){
-		cerr << "could not create output file! " << geterror() << endl;
-		//cancel routine
-		return;
-	}
-
-	// open a file for writing the image. The file header will indicate an image of
-	// width xr, height yr, and 4 channels per pixel (RGBA). All channels will be of
-	// type unsigned char
-	ImageSpec spec(xr, yr, channels, TypeDesc::UINT8);
-	if(!outfile->open(filename, spec)){
-		cerr << "could not open output file! " << geterror() << endl;
-		return;
-	}
-
-	// write the image to the file. All channel values in the pixmap are taken to be
-	// unsigned chars. flip using stride to undo same effort in readImage
-	int scanlinesize = xr * channels * sizeof(unsigned char);
-	if(!outfile->write_image(TypeDesc::UINT8, temp_px+((yr-1)*scanlinesize), AutoStride, -scanlinesize)){
-		cerr << "could not write to file! " << geterror() << endl;
-		return;
-	}
-	else cout << "successfully written image to " << filename << endl;
-
-	// close the image file after the image is written
-	if(!outfile->close()){
-		cerr << "could not close output file! " << geterror() << endl;
-		return;
-	}
-}
-
-/* chroma-key image to create alphamask using HSV differences
-	"fuzz" arguments determine max difference for each value to keep */
-void chromaKey(pxHSV target, double huefuzz, double satfuzz, double valfuzz) {
-	ImageRGBA image = imageCache[cacheIndex];
-	int xr = image.spec.width;
-	int yr = image.spec.height;
-	for (int i=0; i<xr*yr; i++) {
-		pxHSV comp = RGBAtoHSV(image.pixels[i]);
-		//cut out based on absolute distance from target values
-		//if all three are in range, hide it!
-		double huediff = fabs(comp.hue - target.hue);
-		double satdiff = fabs(comp.saturation - target.saturation);
-		double valdiff = fabs(comp.value - target.value);
-		if (huediff < huefuzz && satdiff < satfuzz && valdiff < valfuzz) {
-			//some smoothing function for pixels way less close
-			double maskalpha = (0.2*(huediff/huefuzz) + 0.4*(satdiff/satfuzz) + 0.4*(valdiff/valfuzz)) - 0.2;
-			//clamp to 0.0~1.0; if the result is like 0.012 don't bother with it
-			maskalpha = (maskalpha < 0.02? 0.0 : maskalpha);
-			maskalpha = (maskalpha > 1.0? 1.0 : maskalpha);
-			
-			//cout << "masking pixel: " << comp.hue << " " << comp.saturation << " " << comp.value << " to alpha value " << maskalpha << endl;
-			image.pixels[i].alpha = (unsigned char)255*maskalpha;
-		}
-	}
-}
-
 /** OPENGL FUNCTIONS **/
 /* main display callback: displays the image of current index from imageCache. 
 if no images are loaded, only draws a black background */
@@ -381,10 +128,10 @@ int main(int argc, char* argv[]){
 		}
 
 		//do the things
-		readImage(instr);
-		chromaKey(target,fuzz.hue,fuzz.saturation,fuzz.value);
+		imageCache.push_back(readImage(instr));
+		chromaKey(imageCache[0],target,fuzz.hue,fuzz.saturation,fuzz.value);
 		cout << "writing alphamask to file " << outstr << endl;
-		writeImage(outstr);
+		writeImage(outstr, imageCache[0]);
 		cout << "press ESC or Q to close" << endl;
 	}
 	else {