Draw a 9 point circle in openGL?

Question

I'm trying to draw a 9 point circle for my openGL class project, the problem? My teacher has not taught us how to do hardly anything with circles. He gave us code on how to 'draw' a triangle and told us what the formula to find vertex and center points for normal circles. But never once even touched on how to use them for coding, especially with his way he wants us to do it. He told us to use

class GLintPoint {
public:
GLint x, y;
};

and we could name them A, B, C then find the vertex say a = B - A. I assume this would be a.x = B.x - A.x and same for why, but I don't know for sure. He had to leave for a medical thing(I assume surgery) so I can't ask him and he still has it due at the end of the week.

He gave us this code before he left.

#include <stdlib.h>
#include <math.h>
#include <GL/glut.h>
#include "canvas.h"

const int screenWidth = 640;
const int screenHeight = 480;

Canvas cvs(screenWidth, screenHeight, "Relative Drawing Example", 1);



class GLintPoint {
public:
GLint x, y;
};

#define NUM 3
static GLintPoint List[NUM];

// myInit

void myInit(void)
{
glClearColor(1.0, 1.0, 1.0, 0.0);
glColor3f(0.0f, 0.0f, 0.0f);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, (GLdouble )screenWidth, 0.0, (GLdouble)screenHeight);
}

// myDisplay
void myDisplay(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}

void mykey(unsigned char key, int x, int y)
{
if (key == 'Q' || key == 'q') exit(0);
}



// draw arc 

void draw_arc(GLdouble cx, GLdouble cy, GLdouble r, GLdouble startAngle,
GLdouble sweepAngle)
{
glBegin(GL_LINE_STRIP);
for (GLdouble t = startAngle; t < startAngle+sweepAngle; t += 0.001)
{
    GLdouble x = cx + r*cos(DEG2RAD*t);
    GLdouble y = cy + r*sin(DEG2RAD*t);
    glVertex2d(x, y);
}
glEnd();
}  


// myMouse

void myMouse(int button, int state, int x, int y)
{

static int last = -1;



if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN && last < (NUM -1))
{
    List[++last].x = x;
    List[  last].y = screenHeight - y;
    glClear(GL_COLOR_BUFFER_BIT);
    glBegin(GL_LINE_STRIP);
        for (int i = 0; i <= last; i++) {           
    if(last <=0){
    cvs.moveTo(List[i].x, List[i].y);       
    }
    else
    cvs.lineTo(List[i].x, List[i].y);
    }
    int i = 0;
    cvs.lineTo(List[i].x, List[i].y);
    glEnd();
    glFlush();
}
else if(button == GLUT_RIGHT_BUTTON && state == GLUT_DOWN)
    last = -1;

GLintPoint a.x = 

}

// main



int main(int argc, char ** argv)
{ 
//glutInit(&argc, argv);
//glutInitDisplayMode(GLUT_SINGLE| GLUT_RGB);
//glutInitWindowSize(screenWidth, screenHeight);
//glutInitWindowPosition(100, 150);
//glutCreateWindow("case study 4.2");
glutDisplayFunc(myDisplay);
glutMouseFunc(myMouse);
glutKeyboardFunc(mykey);
myInit();
glutMainLoop();
return 0;
}

and

#include <math.h>
// define some ascii key names
#define GLUT_KEY_ESC 27

// Keeps track of a single point ( turtle position )
class Point2d {
public:
Point2d() { x = y = 0.0f; }
Point2d( float xx, float yy ) { x = xx; y = yy; }
void set( float xx, float yy ) { x = xx; y = yy; }
void setX( float xx ) { x = xx; }
void setY( float yy ) { y = yy; }
float getX() { return x; }
float getY() { return y; }
void draw( void ) { glBegin( GL_POINTS );
                    glVertex2f( (GLfloat)x, (GLfloat)y );
                    glEnd();
                  }
private:
float x, y;
};

//Data type for an array of points
class Point2dArray {
 static const int MAX_NUM = 100;
 public:
    int num;
Point2d pt[MAX_NUM];
};

class IntRect {
public:
 IntRect() { l = 0; r = 100; b = 0; t = 100; }
 IntRect( int left, int right, int bottom, int top )
    { l = left; r = right; b = bottom; t = top; }
 void set( int left, int right, int bottom, int top )
    { l = left; r = right; b = bottom; t = top; }
 void draw( void ) { glRecti( l, b, r, t ); }
 int getL() { return l; }
 int getR() { return r; }
 int getT() { return t; }
 int getB() { return b; }

  private:
   int l, r, b, t;
 };

class RealRect {
public:
RealRect() { l = 0; r = 100; b = 0; t = 100; }
RealRect( float left, float right, float bottom, float top )
    { l = left; r = right; b = bottom; t = top; }
void set( float left, float right, float bottom, float top )
    { l = left; r = right; b = bottom; t = top; }
void draw( void ) { glRectf( l, b, r, t ); }
float ratio( void ) { return (r - l)/(t - b); }
float getL() { return l; }
float getR() { return r; }
float getT() { return t; }
float getB() { return b; }

  private:
   float l, r, b, t;
};

class Canvas {
public:
Canvas( int width, int height, char* windowTitle, int buffer );
void setWindow( float l, float r, float b, float t );
void setViewport( int w, int h );
void autoSetWindow(void);

 float getWindowAspectRatio( void );

 void lineTo( float x, float y );
 void lineTo( Point2d p );
void moveTo( float x, float y );
void moveTo( Point2d p );
void turnTo( float angle );
void turn( float angle );
void forward( float dist, int visible );
int getWinId(void);
void initCT(void);
void scale2D(double, double);
void translate2D(double, double);
void rotate2D(double);

  private:
  Point2d CP;
  float CD;
  IntRect viewport;
  RealRect window;
  int winId;
  float delx, dely;
  char code1, code2;
  char formCode(Point2d p);
  void chopLine(Point2d &p, char c);
  int clipSegment(Point2d &p1, Point2d &p2);
  };

Canvas::Canvas( int width, int height, char* windowTitle, int buffer = 1 ) {
 char* argv[1];
 char dummyString[1];
 argv[0] = dummyString;
 int argc = 1;

 glutInit( &argc, argv );

 glutInitDisplayMode( ((buffer == 1) ? GLUT_SINGLE : GLUT_DOUBLE) | GLUT_RGB );
 glutInitWindowSize( width, height );
 glutInitWindowPosition( (1024 - width) / 2, (768 - height) / 2 );
 winId = glutCreateWindow( windowTitle );
 setWindow( 1000.0f, -1000.0f, 1000.0f, -1000.0f );
 CP.set( 0.0f, 0.0f );
 CD = 0.0f;
 }  

int Canvas::getWinId(void)
{
  return winId;
}

float Canvas::getWindowAspectRatio(void)
{
  return (window.getR() - window.getL())/(window.getT() - window.getB());
}

void Canvas::setWindow( float l, float r, float b, float t ) {
window.set( l, r, b, t );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluOrtho2D( (GLdouble) l, (GLdouble) r, (GLdouble) b, (GLdouble) t );
}

void Canvas::autoSetWindow(void) {
float l = window.getL();
float r = window.getR();
float b = window.getB();
float t = window.getT();

glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluOrtho2D( (GLdouble) l, (GLdouble) r, (GLdouble) b, (GLdouble) t);
}

void Canvas::setViewport( GLsizei width, GLsizei height) {
float aspectRatio = getWindowAspectRatio();
GLint l, b;
GLsizei w, h;

 if ((float) width / (float) height >= aspectRatio) {
l = (GLint) ((width - height * aspectRatio)/2.0);
    b = 0;
    w = (GLsizei) (height * aspectRatio);
h = height;
   }
   else {
    l = 0;
b = (int) ((height - width / aspectRatio)/2.0);
w = width;
    h = (GLsizei) (width / aspectRatio);
    }
    glViewport( l, b, w, h );
    }

void Canvas::lineTo( float x, float y ) {
glBegin( GL_LINES );
glVertex2f( (GLfloat) CP.getX(), (GLfloat) CP.getY() );
glVertex2f( (GLfloat) x, (GLfloat) y );
glEnd();
CP.set( x, y );
glFlush();
}

void Canvas::lineTo( Point2d p ) {
glBegin( GL_LINES );
glVertex2f( (GLfloat) CP.getX(), (GLfloat) CP.getY() );
glVertex2f( (GLfloat) p.getX(), (GLfloat) p.getY() );
glEnd();
CP.set( p.getX(), p.getY() );
glFlush();
}

void Canvas::moveTo( float x, float y ) {
CP.set( x, y );
}

void Canvas::moveTo( Point2d p ) {
CP.set( p.getX(), p.getY() );
}

void Canvas::turn(float angle) {
CD += angle;
}

void Canvas::turnTo(float angle) {
CD = angle;
}

void Canvas::forward( float dist, int visible ) {
 const float RadPerDeg=0.017453393;
float x = CP.getX()+dist*cos(RadPerDeg*CD);
float y = CP.getY()+dist*sin(RadPerDeg*CD);
float l = window.getL();
float r = window.getR();
float b = window.getB();
float t = window.getT();

 l = (x < l)?x:l;
 r = (x > r)?x:r;
 b = (y < b)?y:b;
 t = (y > t)?y:t;
 window.set(l, r, b, t);
 if (visible)
lineTo(x, y);
 else 
moveTo(x, y);
 }

And these formulas. Written just as the piece of paper he gave me reads a = B -A b = C - B c - A - C

c = A = 1/2((a + ((b(dot product) c)/(matrix of a (dotproduct)c)) * (matrix of a))

r = (magnitude of a)/2 squareroot(((b(dot product) c)/(matrix of a (dotproduct)c))^2 +          1)

I hate to ask, but I know when I'm in over my head, can anyone make heads or tails of what hes asking me to do? Or can anyone lead me in the right direction for how to make a 9 point circle? Its worth 10% of my final grade, so I'm not asking for the code to just copy/paste just "wtf do I do?" is all I'm asking.

Answer 1

You can't really draw curves in OpenGL, just polygons. So if someone asked me to draw a nine point circle in OpenGL, I would assume they meant a polygon with 9 sides, where each each point is evenly spaced along the perimeter of a circle.