#include “C:/Documents and Settings/School/My Documents/Computer Graphics/Open GL/shared/gltools.h”

#include <GL/glut.h>
#include <stdlib.h>

#define GL_PI 3.1415f

static GLfloat xRot = 0.0f;
static GLfloat yRot = 0.0f;

void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity ();             /* clear the matrix */
/* viewing transformation  */
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glScalef (1.0, 2.0, 1.0);      /* modeling transformation */
glRotatef(xRot, 1.0f, 0.0f, 0.0f);
glRotatef(yRot, 0.0f, 1.0f, 0.0f);
glutWireCube (1.0);
glFlush ();
}

void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

void RenderScene(void)
{
GLfloat x,y,z,angle; // Storeage for coordinates and angles

// Clear the window with current clearing color
glClear(GL_COLOR_BUFFER_BIT);

// Save matrix state and do the rotation
glPushMatrix();
glRotatef(xRot, 1.0f, 0.0f, 0.0f);
glRotatef(yRot, 0.0f, 1.0f, 0.0f);

// Call only once for all remaining points
glBegin(GL_LINES);

z = 0.0f;
for(angle = 0.0f; angle <= GL_PI; angle += (GL_PI / 20.0f))
{
// Top half of the circle
x = 50.0f*sin(angle);
y = 50.0f*cos(angle);
glVertex3f(x, y, z);

// Bottom half of the circle
x = 50.0f*sin(angle+GL_PI);
y = 50.0f*cos(angle+GL_PI);
glVertex3f(x, y, z);
}

// Done drawing points
glEnd();

// Restore transformations
glPopMatrix();

// Flush drawing commands
glutSwapBuffers();
}

void SetupRC()
{
// Black background
glClearColor(0.0f, 0.0f, 0.0f, 1.0f );

// Set drawing color to green
glColor3f(0.0f, 1.0f, 0.0f);
}

void SpecialKeys(int key, int x, int y)
{
if(key == GLUT_KEY_UP)
xRot-= 5.0f;

if(key == GLUT_KEY_DOWN)
xRot += 5.0f;

if(key == GLUT_KEY_LEFT)
yRot -= 5.0f;

if(key == GLUT_KEY_RIGHT)
yRot += 5.0f;

if(key > 356.0f)
xRot = 0.0f;

if(key < -1.0f)
xRot = 355.0f;

if(key > 356.0f)
yRot = 0.0f;

if(key < -1.0f)
yRot = 355.0f;

// Refresh the Window
glutPostRedisplay();
}

void ChangeSize(int w, int h)
{
GLfloat nRange = 100.0f;

// Prevent a divide by zero
if(h == 0)
h = 1;

// Set Viewport to window dimensions
glViewport(0, 0, w, h);

// Reset coordinate system
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

// Establish clipping volume (left, right, bottom, top, near, far)
if (w <= h)
glOrtho (-nRange, nRange, -nRange*h/w, nRange*h/w, -nRange, nRange);
else
glOrtho (-nRange*w/h, nRange*w/h, -nRange, nRange, -nRange, nRange);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow (“My Creation”);
glutReshapeFunc(ChangeSize);
glutSpecialFunc(SpecialKeys);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
SetupRC();
glutMainLoop();
return 0;
}

The line of code necessary to draw the Bézier curve was brought in straight from my processing assignment3.  See below:

glVertex3f((pow((1-t), 3) * x1a) + (3 * (pow((1-t), 2)) * t * x2a) + (3 * (1-t) * pow(t, 2) * x3a) + (pow(t, 3) * x4a), (pow((1-t), 3) * y1a) + (3 * (pow((1-t), 2)) * t * y2a) + (3 * (1-t) * pow(t, 2) * y3a) + (pow(t, 3) * y4a), z);
z += .5f;
t += .01f;

Credits

• Circle Intersection Solver for helping me understand the distance formula and using it to test and see if circles were intersecting.
• Haeden H Howland for helping me understand hue by giving me a brief lesson using Photoshop.
• Anthony Mattox for giving me an art reference to base my program off of.

int x1 = -1, x2 = -1, x3 = -1, y1 = -1, y2 = -1, y3 = -1;
float midpoint1, midpoint2, centriodX, centriodY;
Boolean drawing = true;
float count = (PI/2.0);
float[][] result1, result2, result3;

void setup () {
size(600, 600);
}

void mousePressed () {
if (drawing) {
if (x1 == -1) {
x1 = mouseX;
y1 = mouseY;
}
else if (x2 == -1) {
x2 = mouseX;
y2 = mouseY;
}
else if (x3 == -1) {
x3 = mouseX;
y3 = mouseY;
}
}

centriodX = (.3333333)*(x1 + x2 + x3);
centriodY = (.3333333)*(y1 + y2 + y3);

if (x3 != -1 && count < (2*PI)) {
if (count == (PI/2)) {
println (“Point1 ” + x1 + “, ” + y1);
println (“Point2 ” + x2 + “, ” + y2);
println (“Point3 ” + x3 + “, ” + y3);

println(“MP ” + centriodX + “, ” + centriodY);

strokeWeight(1);
fill(1);
triangle(x1, y1, x2, y2, x3, y3);

// strokeWeight(5);
// stroke(255);
point(centriodX, centriodY);

float[][] triANGLE = {
{
x1, x2, x3 }
, {
y1, y2, y3 }
, {
1, 1, 1 }
};

float[][] firstTrans = translate2Origin(centriodX, centriodY);
println(“Translate to origin”);
result1 = matrixMult(firstTrans, triANGLE);
}

float[][] rotateMatrix = {
{
round(cos(count)), round(-sin(count)), 0 }
, {
round(sin(count)), round(cos(count)), 0 }
, {
0, 0, 1 }
};

println(“Rotate”);
float[][] result2 = matrixMult(rotateMatrix, result1);

float[][] secTrans = translate2mp(centriodX, centriodY);

println(“Translate to mp”);
float[][] result3 = matrixMult(secTrans, result2);

noFill();
triangle(result3[0][0], result3[1][0], result3[0][1], result3[1][1], result3[0][2], result3[1][2]);

count = count + (PI/2);

}

}

void draw() {

}

float[][] matrixMult (float[][] a, float[][] b) {
float[][] c = new float[a.length][b[0].length];

for (int i = 0; i < b.length; i++) {
for (int j = 0; j < a[0].length; j++) {
for (int k = 0; k < b.length; k ++) {
c[i][j] += a[i][k] * b[k][j];
}
print(“C ” + c[i][j] + ” “);
}
println(” “);
}

return c;
}

float[][] translate2Origin (float a, float b) {
float[][] trans = {
{
1, 0, -a }
, {
0, 1, -b }
, {
0, 0, 1 }
};
for (int i = 0; i < trans.length; i++) {
for (int j = 0; j < trans[0].length; j++) {
// println(“making sure it’s negated ” + trans[i][j]);
}
}
return trans;
}

float[][] translate2mp (float a, float b) {
float[][] trans = {
{
1, 0, a }
, {
0, 1, b }
, {
0, 0, 1 }
};

return trans;
}

float x1, y1, x2, y2, x3, y3;
float Xmin = 180.0;
float Xmax = 540.0;
float Ymin = 120.0;
float Ymax = 360.0;

int count = 0;

void setup () {
noStroke();
size(720, 480);
background(70);
fill(0);
rectMode(CENTER);
rect(360, 240, 360, 240);
}

void mousePressed () {
x1 = random(0, 720);
y1 = random(0, 480);
x2 = random(0, 720);
y2 = random(0, 480);
x3 = random(0, 720);
y3 = random(0, 480);

if (count < 100) {
setup();
stroke(204, 102, 0);
strokeWeight(3);
noFill();
clip(x1, y1, x2, y2);
clip(x2, y2, x3, y3);
clip(x1, y1, x3, y3);

}
count++;
}

void draw () {

}

void clip (float Xp, float Yp, float Xb, float Yb) {
int[] Bp = new int[4];
for (int i = 0; i < Bp.length; i++) {
Bp[i] = 0;
}

if (Xp Xmax) {
Bp[1] = 1;
}

if (Yp Ymax) {
Bp[3] = 1;
}

int[] Bq = new int[4];
for (int i = 0; i < Bq.length; i++) {
Bq[i] = 0;
}

if (Xb Xmax) {
Bq[1] = 1;
}

if (Yb Ymax) {
Bq[3] = 1;
}

int[] or = new int[4];
for (int i = 0; i < Bp.length ; i++) {
or[i] = (Bp[i] | Bq[i]);
}

int[] and = new int[4];
for (int i = 0; i < Bp.length ; i++) {
and[i] = (Bp[i] & Bq[i]);
}

if(or[0] == 0 && or[1] == 0 && or[2] == 0 && or[3] == 0) {

stroke(204, 102, 0);
line(Xp, Yp, Xb, Yb);

} else if(and[0] != 0 || and[1] != 0 || and[2] != 0 || and[3] != 0) {

} else {

float tempXp = Xp;
float tempYp = Yp;
float tempXb = Xb;
float tempYb = Yb;

if (Bp[0] == 1) {
tempYp = Yp + (Yb – Yp) * (Xmin – Xp) / (Xb – Xp);
tempXp = Xmin;
} else if (Bp[1] == 1) {
tempYp = Yp + (Yb – Yp) * (Xmax – Xp) / (Xb – Xp);
tempXp = Xmax;
}

if (Bp[2] == 1) {
if (tempYp Ymax) {
tempXp = Xp + (Xb – Xp) * (Ymin – Yp) / (Yb – Yp);
tempYp = Ymin;
}
} else if (Bp[3] == 1) {
if (tempYp > Ymax || tempYp < Ymin) {
tempXp = Xp + (Xb – Xp) * (Ymax – Yp) / (Yb – Yp);
tempYp = Ymax;
}
}

if (Bq[0] == 1) {
tempYb = Yp + (Yb – Yp) * (Xmin – Xp) / (Xb – Xp);
tempXb = Xmin;
} else if (Bq[1] == 1) {
tempYb = Yp + (Yb – Yp) * (Xmax – Xp) / (Xb – Xp);
tempXb = Xmax;
}

if (Bq[2] == 1) {
if (tempYb Ymax) {
tempXb = Xp + (Xb – Xp) * (Ymin – Yp) / (Yb – Yp);
tempYb = Ymin;
}
} else if (Bq[3] == 1) {
if (tempYb > Ymax || tempYb = Xmin && tempXp = Xmin && tempXb = Ymin && tempYp = Ymin && tempYb <= Ymax) {
line(tempXp, tempYp, tempXb, tempYb);
}
}

}
}

float x1a = 40;
float y1a = 70;
float x1b = 100;
float y1b = 590;
float x2a = 150;
float y2a = 222;
float x2b = 590;
float y2b = 590;
float x3a = 486;
float y3a = 50;
float x3b = 500;
float y3b = 333;
float x4a = 555;
float y4a = 113;
float x4b = 300;
float y4b = 400;
float i;
float z1, w1, z2, w2, z3, w3;

void setup () {
size(600, 600);
}
void draw() {
point (x1a, y1a);
point (x1b, y1b);
point (x2a, y2a);
point (x2b, y2b);
point (x3a, y3a);
point (x3b, y3b);
point (x4a, y4a);
point (x4b, y4b);

for (i = 0.0 ; i < 1 ; i=i + 0.001) {
myLine1(i);
myLine2(i);
myLine3(i);
}
}

void myLine1(float t) {

z1 = x1a + t * (x2a – x1a);
w1 = y1a + t * (y2a – y1a);

z2 = x1b + t * (x2b – x1b);
w2 = y3b + t * (y4b – y3b);

z3 = x3a + t * (x4a – x3a);
w3 = y2a + t * (y3a – y2a);

point(z1, w1);
point(z2, w2);
point(z3, w3);

}

void myLine2(float t) {
z1 = (pow((1-t), 2) * x1a) + (2 * (1-t) * t * x2a) + (pow(t, 2) * x3a);
w1 = (pow((1-t), 2) * y1a) + (2 * (1-t) * t * y2a) + (pow(t, 2) * y3a);

z2 = (pow((1-t), 2) * x1b) + (2 * (1-t) * t * x2b) + (pow(t, 2) * x3b);
w2 = (pow((1-t), 2) * y1b) + (2 * (1-t) * t * y2b) + (pow(t, 2) * y3b);

point(z1, w1);
point(z2, w2);
}

void myLine3(float t) {
z1 = (pow((1-t), 3) * x1a) + (3 * (pow((1-t), 2)) * t * x2a) + (3 * (1-t) * pow(t, 2) * x3a) + (pow(t, 3) * x4a);
w1 = (pow((1-t), 3) * y1a) + (3 * (pow((1-t), 2)) * t * y2a) + (3 * (1-t) * pow(t, 2) * y3a) + (pow(t, 3) * y4a);

z2 = (pow((1-t), 3) * x1b) + (3 * (pow((1-t), 2)) * t * x2b) + (3 * (1-t) * pow(t, 2) * x3b) + (pow(t, 3) * x4b);
w2 = (pow((1-t), 3) * y1b) + (3 * (pow((1-t), 2)) * t * y2b) + (3 * (1-t) * pow(t, 2) * y3b) + (pow(t, 3) * y4b);

point(z1, w1);
point(z2, w2);

}