Original Teapot Obj File

I found this Pyramid Obj File online:

This is the Teapot OBJ file with lighting added (Note you can now see the rim of the lid and voided space for the spout)

I have now completed the basic requirements of the project. I am able to display a full obj file with no errors.  Here are pics of my progress:

So I pretty much have the program completed. I ran into a little issue of it drawing a few extra lines that it is not suppose to but otherwise my program has exposed the Utah Teapot as the posted obj file for download.

al

For the chapter 4 example I have modified the code to show a Cube.  This example demonstrates use of 3d perspective view as well as lighting commands not seen in previous examples.  In this example,  a face is composed of verticies.

int screen_width = 720;
int screen_height = 480;
float [][] rotateMatrix = new float[2][2];
int x0,y0,x1,y1,x2,y2;

void setup()
{
size(screen_width,screen_height);
x0 = int(random(screen_width));
y0 = int(random(screen_height));
x1 = int(random(screen_width));
y1 = int(random(screen_height));
x2 = int(random(screen_width));
y2 = int(random(screen_height));
}

void draw()
{

for(float i = 0; i<2; i+=.5)
rotateShape(x0, y0, x1, y1, x2, y2, (i*PI));

saveFrame(“HMWK4_pt1.jpg”);

noLoop();
}

void rotateShape(int x0, int y0, int x1, int y1, int x2, int y2, float radian_num)
{
rotateMatrix=setRotate(radian_num);

int x_origin = int((x0+x1+x2)/3);
int y_origin = int((y0+y1+y2)/3);

float[][] pointMatrix = {{x0-x_origin,y0-y_origin},{x1-x_origin,y1-y_origin},{x2-x_origin,y2-y_origin}};

pointMatrix = matrixMultiply(pointMatrix,rotateMatrix);

for(int x = 0; x < pointMatrix.length; x++) {
for(int y = 0; y < pointMatrix[0].length; y++) {
if(y == 0)
pointMatrix[x][y] += x_origin;
else
pointMatrix[x][y] += y_origin;
}
}

triangle(pointMatrix[0][0], pointMatrix[0][1], pointMatrix[1][0], pointMatrix[1][1], pointMatrix[2][0], pointMatrix[2][1]);
}

float[][] setRotate(float radian)
{

float[][] rotates=new float[2][2];

rotates[0][0] = cos(radian);
rotates[0][1] = sin(radian);
rotates[1][0] = -sin(radian);
rotates[1][1] = cos(radian);

return rotates;
}

float[][] matrixMultiply(float[][] m1, float[][] m2)
{
float[][] m3 = new float[m1.length][m2[0].length];

for(int x = 0; x < m3.length; x++)
{
for(int y = 0; y < m3[0].length; y++)
{
for(int z = 0; z < m2.length; z++)
{
m3[x][y] += m1[x][z] * m2[z][y];
}
}
}

return m3;

}

Homework Part II

void setup() {
size(720, 480);
noLoop();
}
void draw() {
pushMatrix();
translate(360, 240);

scale(10);
for(float i = 0; i< 2; i += .01) {
rotate(i * PI);
fill(10,0,255);
triangle(0,0,0,10,10,20);

}

scale(.5);
for(float i = 0; k < 2; i += .01) {
rotate(i * PI);
fill(0,250,0);
triangle(0,0,0,10,10,20);

}

scale(.25);
for(float i = 0; i < 2; i += .01) {
rotate(i * PI);
fill(10,0,155);
triangle(0,0,0,10,10,20);

}

}

int x1, x2, x3;
int y1, y2, y3;
int xmax=540, xmin=180;
int ymax=360, ymin=120;
int screenWidth=720, screenHeight = 480;
int[] outcodep, outcodeq;
boolean top=false, bottom=false, left=false, right=false;

void setup()
{
size(screenWidth, screenHeight);
background(255,255,255);
stroke(255,0,0);
rect(xmin, ymin,(xmax-xmin),(ymax-ymin));
stroke(0,0,0);

x1 = int(random(720));
y1 = int(random(480));
x2 = int(random(720));
y2 = int(random(480));
x3 = int(random(720));
y3 = int(random(480));

outcodep = new int[4];
outcodeq = new int[4];

clipLine(x1, y1, x2, y2);
clipLine(x2, y2, x3, y3);
clipLine(x1, y1, x3, y3);

saveFrame(“HMWK4_clip.jpg”);

}

void clipLine(int xp, int yp, int xq, int yq)
{

int[] orcode = new int[4];
int[] andcode = new int[4];

for(int i=0; i<4; i++)
{
outcodep[i]=0;
outcodeq[i]=0;
andcode[i]=0;
orcode[i]=0;
}

if(xp>=xmax)
outcodep[1]=1;
else if(xp<=xmin)
outcodep[0]=1;

if(yp>=ymax)
outcodep[3]=1;
else if(yp<=ymin)
outcodep[2]=1;

if(xq>=xmax)
outcodeq[1]=1;
else if(xq<=xmin)
outcodeq[0]=1;

if(yq>=ymax)
outcodeq[3]=1;
else if(yq<=ymin)
outcodeq[2]=1;

for(int i = 0; i<4; i++)
{
orcode[i] = (outcodep[i] | outcodeq[i]);
andcode[i] = (outcodep[i] & outcodeq[i]);
}

if(orcode[0] == 0 && orcode[1] == 0 && orcode[2] == 0 && orcode[3]==0)
line(xp,yp,xq,yq); //draw line as line is completely within viewable region

else if(andcode[0]!=0 ||andcode[1] !=0 || andcode[2] !=0 || andcode[3] !=0)
{
//draws nothing as line is completely outside viewable region
}

else
{
int temp_xp = xp;
int temp_yp = yp;

int temp_xq = xq;
int temp_yq = yq;

if(outcodep[0]==1)
{
temp_xp =xmin;
temp_yp = yp + (yq-yp)*(xmin-xp)/(xq-xp);
}
else if(outcodep[1]==1)
{
temp_xp = xp + (xq-xp)*(ymax-yp)/(yq-yp);
temp_yp = ymax;
}

if(outcodep[2] == 1)
{
if(temp_xp > ymax || temp_yp < ymin)
{
temp_yp = yp + (yq-yp)*(xmin-xp)/(xq-xp);
temp_xp = ymin;
}
}
else if(outcodep[3] == 1)
{
if(temp_xp > ymax || temp_yp <= ymin)
{
temp_xp = xp + (xq-xp)*(ymax-yp)/(yq-yp);
temp_yp = ymax;
}
}

if (outcodeq[0] == 1)
{
temp_yq = yp + (yq-yp)*(xmin-xp)/(xq-xp);
temp_xq = xmin;
}
else if (outcodeq[1] == 1)
{
temp_xq = xmax;
temp_yq = yp+(yq-yp)*(xmax-xp)/(xq-xp);
}

if (outcodeq[2] == 1)
{
if(temp_yq >= ymax || temp_yq <=ymin)
{
temp_xq = xp+(xq-xp)*(ymin-yp)/(yq-yp);
temp_yq = ymin;
}
}
else if (outcodeq[3]==1)
{
if(temp_yq >= ymax || temp_yq <=ymin)
{
temp_xq = xp+(xq-xp)*(ymax-yp)/(yq-yp);
temp_yq = ymax;
}
}

line(temp_xp,temp_yp,temp_xq,temp_yq);

}

}

void setup()
{
size(720,480);
fiveTriangle();
}
void myTriangle(int x0,int y0,int x1,int y1,int x2, int y2)
{

line(x0,y0,x1,y1);
line(x1,y1,x2,y2);
line(x2,y2,x0,y0);

}

void fiveTriangle()
{
int x0, x1, x2, y0, y1, y2;

for(int x = 0; x < 5; x++)
{
x0 = int(random(720));
x1 = int(random(720));
x2 = int(random(720));
y0 = int(random(480));
y1 = int(random(480));
y2 = int(random(480));

line(x0, y0, x1, y1);
line(x1, y1, x2, y2);
line(x2, y2, x0, y0);
}
}

ftp://student.uncw.edu/ana6997/hmwk4cubicApplet.jar

Here’s the code:
int click=0;
int x_0,y_0,x_1,y_1,x_2,y_2,x_3,y_3;

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

void draw()
{

}

void myCubic(int x0,int y0,int x1,int y1,int x2, int y2,int x3, int y3)
{

float x, y;

for(float t=0; t<=1; t+=0.0005) {
x = ((pow(1-t,3)*x0) + (3*pow(1-t,2)*t*x1) + (3*(1-t)*pow(t,2)*x2) + (pow(t,3)*x3));
y = ((pow(1-t,3)*y0) + (3*pow(1-t,2)*t*y1) + (3*(1-t)*pow(t,2)*y2) + (pow(t,3)*y3));

point(x,y);
}
}

void mousePressed() {

if(click<4)
{
switch(click) {
case 0:
x_0 = mouseX;
y_0 = mouseY;
point(x_0,y_0);
click++;
break;
case 1:
x_1 = mouseX;
y_1 = mouseY;
point(x_1,y_1);
click++;
break;
case 2:
x_2 = mouseX;
y_2 = mouseY;
point(x_2,y_2);
click++;
break;
case 3:
x_3 = mouseX;
y_3 = mouseY;
point(x_3,y_3);
myCubic(x_0,y_0,x_1,y_1,x_2,y_2,x_3,y_3);
click=0;
break;
}

}

}

MyLinear Line

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

void draw()
{
myLine(300,200,150,280,0,1);
myLine(10,30,70,80,0,1);
myLine(50,200,100,280,0,1);

}

void myLine(int x0,int y0,int x1,int y1,int t0,int t1)
{
float x, y,tStart, tEnd;

tStart = t0;
tEnd = t1;

for(float t=tStart; t<=tEnd; t+=0.005) {
x = x0 + t*(x1-x0);
y = y0 + t*(y1-y0);
point(x,y);
}

}

My Quadratic Line

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

void draw()
{

myQuad(100,150,200,180,340,160);
myQuad(130,100,200,20,370,80);

saveFrame(“HMWK3_MyQuad.jpg”);
}

void myQuad(int x0,int y0,int x1,int y1,int x2, int y2)
{
float x, y;

for(float t=0; t<=1; t+=0.0005) {
x = ((pow(1-t,2)*x0) + (2*(1-t)*t*x1) + (pow(t,2)*x2));
y = ((pow(1-t,2)*y0) + (2*(1-t)*t*y1) + (pow(t,2)*y2));

point(x,y);
}
}

My Cubic Line

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

void draw()
{

myCubic(120, 100, 150, 200, 200, 100, 250, 100);
myCubic(80, 300, 75, 200, 100, 350, 250, 200);
saveFrame(“HMWK3_MyCubic.jpg”);
}

void myCubic(int x0,int y0,int x1,int y1,int x2, int y2,int x3, int y3)
{
float x, y;

for(float t=0; t<=1; t+=0.0005) {
x = ((pow(1-t,3)*x0) + (3*pow(1-t,2)*t*x1) + (3*(1-t)*pow(t,2)*x2) + (pow(t,3)*x3));
y = ((pow(1-t,3)*y0) + (3*pow(1-t,2)*t*y1) + (3*(1-t)*pow(t,2)*y2) + (pow(t,3)*y3));

point(x,y);
}
}

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

void draw()
{

drawCircle(100,100,20);
drawWeb(200,10);
drawLine(300,100,300,200);

}

void drawLine(int xa, int ya, int xb, int yb)
{
int x1 = xa;
int x2 = xb;
int y1 = ya;
int y2 = yb;
boolean steep=false;

if(abs(y2-y1) > abs(x2-x1))
steep=true;

if(steep)
{
x1 = ya;
y1 = xa;

x2 = yb;
y2 = xb;

}

if(x1>x2)
{
x1 = yb;
x2 = ya;

y1 = xb;
y2 = xa;
}

if(x1>x2)
{
x1 = xb;
x2 = xa;

y1 = yb;
y2 = ya;
}

int run = x2 – x1;
int rise = abs(y1 – y2);
float error = 0;
float slope =(float)(1.0*rise)/ run;
int ystep;
int y = y1;

if (y1 < y2)
ystep = 1;
else
ystep = -1;

for(int x=x1; x<x2; x++)
{
if(steep)
point(y,x);
else
point(x,y);

error=error + slope;

if (error >= 0.5)
{
y = y + ystep;
error = error – 1.0;
}

}

}
void drawCircle(int x1, int y1, int radius)
{
int f = 1 – radius;
int ddF_x = 1;
int ddF_y = -2 * radius;
int x = 0;
int y = radius;

point(x1, y1 + radius);
point(x1, y1 – radius);
point(x1 + radius, y1);
point(x1 – radius, y);

while(x < y)
{
assert(ddF_x == 2 * x + 1);
assert(ddF_y == -2 * y);
assert(f == x*x + y*y – radius*radius + 2*x – y + 1);
if(f >= 0)
{
y–;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
point(x1 + x, y1 + y);
point(x1 – x, y1 + y);
point(x1 + x, y1 – y);
point(x1 – x, y1 – y);
point(x1 + y, y1 + x);
point(x1 – y, y1 + x);
point(x1 + y, y1 – x);
point(x1 – y, y1 – x);
}
}

void drawWeb(int size, int step)
{

for (int x2 = 0; x2 < size; x2+=step)
{
int y1 = size-x2;
drawLine(0, y1, x2, 0);

}
}