• Getting you acquainted with the concepts of:
  • frame buffer
  • rasterization
• A chance to do some C++ warm-ups.

Part 1. A Class Modelling a Text-Based Frame Buffer

class FrameBuffer {
public:
    FrameBuffer(int width, int height);
    void setPixel(int x, int y, bool on = true);
    void display(ostream &os = cout);
    int getWidth() const;
    int getHeight() const;
private:
    int height, width;
    bool **pixels;
};
		

• The class' data
  • The data members of the class are the height and width (i.e., the resolution) of the frame buffer, and the buffer itself which is to be dyanmically allocated when the object is created (i.e., when the constructor is executed--see below).
• The class' functions
  • setPixel turnfs on/off the pixel in the buffer at location/position x, y.
  • display sends the contents of the buffer to the specified output (defaulting to cout).
• Creating the buffer
  • Allocating a multidimensional buffer all of whose dimensions are dynamic (i.e., not known until run-time) may be something you've never encountered. Essentially a two-dimesional array in C++ is an array of arrays (in this case we're dealing with an array of arrays of bool). Since the dimensions are not known at compile time, we declare the corresponding variable as bool **, i.e., a pointer (array) to a pointer (array) of bool.

    In order to properly allocate such an array using new, we first allocate the array of arrays, and then create the individual arrays of bools. Rather than giving you the exact code, here is a very close pseudocode version:

    pixels = Create a bool * array of width elements
    for (int i = 0; i < width; i++)
       Create a bool array of height elements and assign it to pixels[i]
    	 					 	

Here is a sample program that produces this output

Part 2. A Simple Line Algorithm ( DDA)

drawLine(x1, y1, x2, y2)
	slope = (y2 - y1) / (x2 - x1)  // slope is not an integer
	
	y = y1
	for x = x1 to x2
		drawPoint(x, y)
		y = y + slope		// need to either truncate, ceiling, or round

• For

   
  slope = (y2 - y1) / (x2 - x1)
  		

  make sure you use floating point division-- integer division will produce an integer slope which will be VERY boring and unsatisfying.
• y is an integer (its the height-portion of a coordinate on our surface, but y + slope will typically not evaluate to an integer (since the slope is not an integer-- see the previous note). Your choices are to
  • truncate (floor function or (int) cast)
  • go up to next integer (ceiling function)
  • round (add 0.5 and truncate, or use a round function)

class Graphic {
public:
    Graphic(int width, int height);
    void ddaLine(int x1, int y1, int x2, int y2);
private:
    FrameBuffer fb;
};
		

• Graphic accepts a resolution and creates the appropriate FrameBuffer object.
• drawLine implements the dda line drawing algorith displayed above; the frame buffer is displayed after the line is drawn.

Make sure your algorith works for the following types of lines:

• line with slope 1
• line with large slope (positive and negative) (steep line)
• line with small slope (positive and negative) (shallow line)
• line with 0 slope (horizontal line)
• line with infinite slope (vertical line)

Here is a sample program that produces this output

Part 3. Adding Color

Modify the frame buffer to accept color pixels. If you wish, come up with your own scheme; alternatively, feel free to copy what I did which is to allow 10 colors -- 0 being black (absence of color) and 1-9 representing 9 other colors. The Graphic class must also change to reflect this modification. Here are the new class declarations (you, obviously are to finsih off the implementations):

class FrameBuffer {
public:
    FrameBuffer(int width, int height);
    void setPixel(int x, int y, int color);
    void display(ostream &os = cout);
    int getWidth() const {return width;}
    int getHeight() const {return height;}
private:
    int height, width;
    int **pixels;
};

class Graphic {
public:
    Graphic(int width, int height);
    void drawLine(int x1, int y1, int x2, int y2, int color);
private:
    FrameBuffer fb;
};
		

Here is a sample program that produces this output

Part 4. Frame-Buffer Color Blending

One possibility is to blend the colors, and in particular, to have the frame buffer blend the colors.

Modify the FrameBuffer class so that when setPixel is called on a pixel that is already on (i.e., not black or color 0), the new color value is blended with the current pixel color.

I blended my colors by taking the average of the new and current color and translating it to the corresponding letter 'A' for 1, 'B' for 2, etc. How YOU blend the color is up to you-- come up with your own scheme, or use mine or some variant.

Notice that the user does not change their application here. We COULD provide a function either in the Graphic and/or FrameBuffer class that allows the user to turn on and off color blending.

Here is a sample program (same as Part 3) that produces this output

Part 5. A First Circle Algorithm (DDA)

r2 = y2 + y2 
					

• Vary x from 0 to 1 and calculate y using the above formula
• Vary y from 0 to 1 and calculate x using the above formula

x = r cos(t)	 		
y = r sin(t)

where t varies from 0 to 2 * PI
					

Add a function to your Graphic class that allows the user to select which circle algorithm they wish to use.

You don't really have to do the calculation on the ENTIRE circle-- calculate the first quadrant-- the others are mirror images around one or both axes (i.e., reverse the sign of the x and/or y coordinate of the resulting point. In actuality, all you really need is one either of the circle in order to use an approach like this). See if you can figure out how to do this.

Part 6. Bresenham's (Midpoint) Algorithm

The original algorithm was for line segments, but was extended to a circle version (look under either Bresenham or midpoint).

Implement Bresenham's algorithm for lines and circles. As in the previous part, provide functionality to allow the user to select which algorithm to use.

Play with the same various slope types as described in Part 2. Try drawing the same line with DDA and Bresenham (with color blending) and see how they compare.

What and How to Submit

• Please do NOT submit anything until you have finished the entire assignment.
• The files:
  • There should be a single parent directory named Assignment01
  • Each part of the assignment should reside in its own directory, Part** beneath a single directory where ** is 01, 02, 03, .., 07
• zip or otherwise compress all files into a single compressed file, maintaining path information
• email me the resulting compressed file, using the subject *** CIS 3620 *** Assignment 01 SUBMISSION. Please do not use a different subject heading
• If you need help, email me with the subject heading *** CIS 3620 *** Assignment 01 HELP.
• When submitting all asking for help, please make sure you attach ALL files necessary to build and run your submission.