Incorrect output on changing sequence of declarations - c++

Question

Implemention of 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} };
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.
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;
}

Answer 1

You have a memory stomping bug -- you're writing the pointList array with an invalid index, which overwrites the memory immediately afterwards. Your original code just happens to work, because the memory after it isn't used, but when you switch the order of declarations, the memory stomping overwrites the variable numberOfVertices.
I'd suggest running your program with Valgrind to find where the memory stomping is occurring.

Answer 2

In
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 = p;
}
/* Updating number of points and point list */
numberOfVertices = j;
for(i=0 ; i<numberOfVertices ; i++) {
pointList[i] = outputList[i];
}
You can increase numberOfVertices, but pointList has only space for the initial points. Declare it
Point pointList[MAXVERTICES] = { ... };
to have enough space.