Pasted

#include <GL/glut.h>
#include <stdlib.h>
#include <iostream> 
 
#define KCLR  "\x1B[0m"
#define KRED  "\x1B[31m"
#define KGRN  "\x1B[32m"
 
 
struct coords{
    int x, y;
};
 
void pointDistance (coords prev, coords next, coords &edges);
int xProd(coords prev, coords next);
bool isConcave(int[], int size);
void display();
 
int main(int argc,char *argv[]){
    int nrVertices= 6;
    int xpSum [nrVertices];
    coords edgeDist [nrVertices];   
    coords vertices [nrVertices]= {{0,0},{1,0},{2,1},{3,0},{3,3},{0,3}};
    
    fprintf(stderr, "\t#Calculating Edge distance#\n");
    
    //calculate point distance for adjacent edges
    for (size_t ctr= 0; ctr<nrVertices; ++ctr){
        //compare last with first
        if (ctr == nrVertices-1){
           pointDistance(vertices[ctr], vertices[0], edgeDist[ctr]);
           fprintf(stderr, "E%d= (%2d,%2d)\n", ctr+1, edgeDist[ctr].x, edgeDist[ctr].y);
           continue;   
        }
        
        pointDistance(vertices[ctr], vertices[ctr+1], edgeDist[ctr]);
        fprintf(stderr, "E%d= (%2d,%2d)\n", ctr+1, edgeDist[ctr].x, edgeDist[ctr].y);
    }   
    
    fprintf(stderr, "\n\n\t#Calculating Cross Product#\n");
    
    //calculate cross-product of adjacent edges
    for (size_t ctr= 0; ctr<nrVertices; ++ctr){
        //compare last with first
        if (ctr == nrVertices-1){       
           xpSum [ctr]= xProd(edgeDist[ctr], edgeDist[0]);  
           fprintf(stderr, "xp%d: %2d\n", ctr+1, xpSum[ctr]);
           continue;
        }
 
        xpSum [ctr]= xProd(edgeDist[ctr], edgeDist[ctr+1]); 
        fprintf(stderr, "xp%d: %2d\n", ctr+1, xpSum[ctr]);
    }
    
    //determine if polygon is complex using cross-product results
    fprintf(stderr, "\n\n\t#Cross Product is:\n");
    
    if (isConcave(&xpSum[0], nrVertices))
        fprintf(stderr, "\n\n\t/!\\ The polygon is CONCAVE");
    else
        fprintf(stderr, "\n\n\t/!\\ The polygon is CONVEX");
    
    
    //draw the polygon  
    glutInit(&argc,argv);                   //prepare glut
    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);       //set the display mode
    glutInitWindowSize (500, 500);          //the size of the program window
    glutInitWindowPosition (100, 100);      //initial position for the window
    glutCreateWindow ("points and lines");  //create window with a title
   
    glClearColor(255,255,255,0.0);          //background color
    glMatrixMode (GL_PROJECTION);           //2d envyronment
    gluOrtho2D (-10.0, 310.0, -10.0, 310.0);   //canvas area (LRBT)
   
    glutDisplayFunc(display);               //show thee actual program
    glutMainLoop();
   
    return EXIT_SUCCESS;                    //exit the program
}
 
 
//calculate the distance between vertices: V= (x2-x1, y2-y1) 
void pointDistance (coords prev, coords next, coords &edges){
    //calculate point distance
    edges.x= next.x - prev.x;
    edges.y= next.y - prev.y;
}
 
//determine cross-product: |V1 * V2| = (x1*y2) - (y1*x2)
int xProd (coords prev, coords next){
    return (prev.x * next.y) - (prev.y * next.x);
}
 
//determine if polygon is concave usign cross-product results 
bool isConcave(int xpSum[], int size){
    bool hasPos;
    bool hasNeg;
    
    for (size_t ctr= 0; ctr<size; ++ctr){
        if (xpSum[ctr] > 0){
            hasPos= 1;
            fprintf(stderr, "Positive\n");  
        } else{
            hasNeg= 1;
            fprintf(stderr, "Negative\n");  
        }        
    }
    
    if (hasPos && hasNeg) return 1;
 
    return 0;       
}
 
void display(){
    glClear(GL_COLOR_BUFFER_BIT);   //flush gl
    glColor3f(0.0, 0.0, 1.0);       //blue line color
 
    //outer pentagram, clockwise
    glBegin(GL_LINE_LOOP);
        glVertex2i(0,0);
        glVertex2i(100,0);
        glVertex2i(200,100);
        glVertex2i(300,0);
        glVertex2i(300,300); 
        glVertex2i(0,300);  
    glEnd();
     
    glFlush();  //force immidiate display
}