Writing C++ code to implement Sutherland-Hodgeman polygon clipping. This order of declaration of these 2 statements gives correct output, reverse does not.
int numberOfVertices = 5;
Point pointList[] = { {50,50}, {200,300}, {310,110}, {130,90}, {70,40} };
I am passing the polygon vertex set to clippers in order - LEFT, RIGHT, TOP, BOTTOM.
The exact error which comes when the declarations are reversed is that the bottom clipper, produces an empty set of vertices so no polygon is displayed after clipping.
Correct:
Incorrent:
Confirmed by outputting the number of vertices produced after each pass:
Correct:
Incorrect:
What is the reason for this error?
Code:
#include <iostream>
#include <GL/glut.h>
#define MAXVERTICES 10
#define LEFT 0
#define RIGHT 1
#define TOP 2
#define BOTTOM 3
using namespace std;
/* Clipping window */
struct Window {
double xmin;
double xmax;
double ymin;
double ymax;
};
struct Point {
double x;
double y;
};
/* If I interchange these two lines, the code doesn't work. */
/**************/
int numberOfVertices = 5;
Point pointList[] = { {50,50}, {200,300}, {310,110}, {130,90}, {70,40} };
/**************/
const Window w = { 100, 400, 60, 200 };
/* Checks whether a point is inside or outside a window side */
int isInside(Point p, int side) {
switch(side) {
case LEFT:
return p.x >= w.xmin;
case RIGHT:
return p.x <= w.xmax;
case TOP:
return p.y <= w.ymax;
case BOTTOM:
return p.y >= w.ymin;
}
}
/* Calculates intersection of a segment and a window side */
Point intersection(Point p1, Point p2, int side) {
Point temp;
double slope, intercept;
bool infinite;
/* Find slope and intercept of segment, taking care of inf slope */
if(p2.x - p1.x != 0) {
slope = (p2.y - p1.y) / (p2.x - p1.x);
infinite = false;
} else {
infinite = true;
}
intercept = p1.y - p1.x * slope;
/* Calculate intersections */
switch(side) {
case LEFT:
temp.x = w.xmin;
temp.y = temp.x * slope + intercept;
break;
case RIGHT:
temp.x = w.xmax;
temp.y = temp.x * slope + intercept;
break;
case TOP:
temp.y = w.ymax;
temp.x = infinite ? p1.x : (temp.y - intercept) / slope;
break;
case BOTTOM:
temp.y = w.ymin;
temp.x = infinite ? p1.x : (temp.y - intercept) / slope;
break;
}
return temp;
}
/* Clips polygon against a side, updating the point list
(called once for each side) */
void clipAgainstSide(int sideToClip) {
int i, j=0;
Point s,p;
Point outputList[MAXVERTICES];
/* Main algorithm */
s = pointList[numberOfVertices-1];
for(i=0 ; i<numberOfVertices ; i++) {
p = pointList[i];
if(isInside(p, sideToClip)) {
/* p inside */
if(!isInside(s, sideToClip)) {
/* p inside, s outside */
outputList[j] = intersection(p, s, sideToClip);
j++;
}
outputList[j] = p;
j++;
}
else if(isInside(s, sideToClip)) {
/* s inside, p outside */
outputList[j] = intersection(s, p, sideToClip);
j++;
}
s = p;
}
/* Updating number of points and point list */
numberOfVertices = j;
/* ERROR: In last call with BOTTOM argument, numberOfVertices becomes 0 */
/* all earlier 3 calls have correct output */
cout<<numberOfVertices<<endl;
for(i=0 ; i<numberOfVertices ; i++) {
pointList[i] = outputList[i];
}
}
void SutherlandHodgemanPolygonClip() {
clipAgainstSide(LEFT);
clipAgainstSide(RIGHT);
clipAgainstSide(TOP);
clipAgainstSide(BOTTOM);
}
void init() {
glClearColor(1,1,1,0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0,1000,0,500);
}
void display() {
glClear(GL_COLOR_BUFFER_BIT);
/* Displaying ORIGINAL box and polygon */
glColor3f(0,0,1);
glBegin(GL_LINE_LOOP);
glVertex2i(w.xmin, w.ymin);
glVertex2i(w.xmin, w.ymax);
glVertex2i(w.xmax, w.ymax);
glVertex2i(w.xmax, w.ymin);
glEnd();
glColor3f(1,0,0);
glBegin(GL_LINE_LOOP);
for(int i=0 ; i<numberOfVertices ; i++) {
glVertex2i(pointList[i].x, pointList[i].y);
}
glEnd();
/* Clipping */
SutherlandHodgemanPolygonClip();
/* Displaying CLIPPED box and polygon, 500px right */
glColor3f(0,0,1);
glBegin(GL_LINE_LOOP);
glVertex2i(w.xmin+500, w.ymin);
glVertex2i(w.xmin+500, w.ymax);
glVertex2i(w.xmax+500, w.ymax);
glVertex2i(w.xmax+500, w.ymin);
glEnd();
glColor3f(1,0,0);
glBegin(GL_LINE_LOOP);
for(int i=0 ; i<numberOfVertices ; i++) {
glVertex2i(pointList[i].x+500, pointList[i].y);
}
glEnd();
glFlush();
}
int main(int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(1000,500);
glutCreateWindow("Sutherland-Hodgeman polygon clipping");
init();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
