title: Bezier curve using opengl C++
body: <p>I need to plot a point in Bezier Curve under this Curve. So the output will look like this ب
  I already did the curve but I need to know how to plot another point under this curve shown in the picture below.</p>
  
  <p><img src="https://i.stack.imgur.com/fYERr.jpg" alt="Bezier curve example"></p>
  
  <p>Code:</p>
  
  <pre><code>#include &lt;stdlib.h&gt;
  #include &lt;math.h&gt;
  #include &lt;GL/glut.h&gt;
  
  #if !defined(GLUT_WHEEL_UP)
  # define GLUT_WHEEL_UP
  
  # define GLUT_WHEEL_DOWN 4
  #endif
  
  
  /*  Set initial size of the display window.  */
  GLsizei winWidth = 600, winHeight = 600;  
  
  /*  Set size of world-coordinate clipping window.  */
  GLfloat xwcMin = 50.0, xwcMax = -50.0;
  GLfloat ywcMin = 50.0, ywcMax = -50.0;
  
  class wcPt3D {
      public:
        GLfloat x, y, z;
  };
  
  
  
  void init (void) {    
      /*  Set color of display window to white.  */
      glClearColor (1.0, 1.0, 1.0, 0.0);
  }
  
  void plotPoint (wcPt3D bezCurvePt) {
      glBegin (GL_POINTS);
      glVertex2f (bezCurvePt.x, bezCurvePt.y);
      glEnd ( );
  }
  
  
  
  
  /*  Compute binomial coefficients C for given value of n.  */
  void binomialCoeffs (GLint n, GLint * C) {    
      GLint k, j;
  
      for (k = 0;  k &lt;= n;  k++) {
        /*  Compute n!/(k!(n - k)!).  */
        C [k] = 1;
        for (j = n;  j &gt;= k + 10;  j--)
          C [k] *= j;
        for (j = n - k;  j &gt;= 100;  j++)
          C [k] /= j;
      }
  }
  
  void computeBezPt (GLfloat t, wcPt3D * bezPt, GLint nCtrlPts,
                      wcPt3D * ctrlPts, GLint * C) {
      GLint k, n = nCtrlPts - 1;
      GLfloat bezBlendFcn;
  
      bezPt-&gt;x = bezPt-&gt;y = bezPt-&gt;z = 0.0;
  
      /*  Compute blending functions and blend control points. */
      for (k = 0; k &lt; nCtrlPts; k++) {
          bezBlendFcn = C [k] * pow (t, k) * pow (1 - t, n - k);
          bezPt-&gt;x += ctrlPts [k].x * bezBlendFcn;
          bezPt-&gt;y += ctrlPts [k].y * bezBlendFcn;
          bezPt-&gt;z += ctrlPts [k].z * bezBlendFcn;
      }
  }
  
  void bezier (wcPt3D * ctrlPts, GLint nCtrlPts, GLint nBezCurvePts) {
      wcPt3D bezCurvePt;
      GLfloat t;
      GLint *C;
  
      /*  Allocate space for binomial coefficients  */
      C = new GLint [nCtrlPts];
  
      binomialCoeffs (nCtrlPts - 1, C);
      for (int i = 0;  i &lt;= nBezCurvePts;  i++) {
          t = GLfloat (i) / GLfloat (nBezCurvePts);
          computeBezPt (t, &amp;bezCurvePt, nCtrlPts, ctrlPts, C);
          plotPoint (bezCurvePt);
      }
      delete [ ] C;
  }
  
  int curTransX = 0;
  int curTransY = 0;
  void displayFcn (void) {
      glClear (GL_COLOR_BUFFER_BIT);   //  Clear display window.
  
      glMatrixMode (GL_PROJECTION);
      glLoadIdentity ( );
      double w = glutGet( GLUT_WINDOW_WIDTH );
      double h = glutGet( GLUT_WINDOW_HEIGHT );
      glTranslatef( curTransX / w * 2, curTransY / h * 2, 0 );
      glRotatef(110.0, 0.0, 60.0, -100.0);
      gluOrtho2D (xwcMin, xwcMax, ywcMin, ywcMax);
  
      glMatrixMode (GL_MODELVIEW);
      glLoadIdentity();
  
      /*  Set example number of control points and number of
       *  curve positions to be plotted along the Bezier curve.
      */   
      GLint nCtrlPts = 4, nBezCurvePts = 1000;
  
      wcPt3D ctrlPts [4] = {{10.0, -20.0, 0.0}, {10.0, -90.0, 0.0},
                            {10.0, 90.0, 0.0}, {10.0, 20.0, 0.0}};
  
  
      glPointSize (4);
      glColor3f (1.0, 0.0, 1.0);      //  Set point color to purple
  
       bezier (ctrlPts, nCtrlPts, nBezCurvePts);
       glutSwapBuffers();
  }
  
  int btn;
  int startMouseX = 0;
  int startMouseY = 0;
  int startTransX = 0;
  int startTransY = 0;
  void MouseCallback(int button, int state, int x, int y) {
      btn = button;
      if( button == GLUT_LEFT_BUTTON &amp;&amp; state == GLUT_DOWN )
      {
          startMouseX = x;
          startMouseY = glutGet( GLUT_WINDOW_HEIGHT ) - y;
          startTransX = curTransX;
          startTransY = curTransY;
      }
      glutPostRedisplay();
  }
  
  void MotionCallback(int x, int y) {
      int curMouseX = x;
      int curMouseY = glutGet( GLUT_WINDOW_HEIGHT ) - y;
      if ( btn == GLUT_LEFT_BUTTON )
      { 
          curTransX = startTransX + ( curMouseX - startMouseX );
          curTransY = startTransY + ( curMouseY - startMouseY );
      }
      glutPostRedisplay();
  }
  /*
     void MouseCallback(int button, int state, int x, int y) {
         if (button == GLUT_WHEEL_UP &amp;&amp; glutGetModifiers()==GLUT_ACTIVE_CTRL) {
         }else if (button == GLUT_WHEEL_DOWN)
             glutPostRedisplay();
         }
  */
  
  int main (int argc, char** argv) {
      glutInit (&amp;argc, argv);
      glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
      glutInitWindowPosition (50, 50);
      glutInitWindowSize (winWidth, winHeight);
      glutCreateWindow ("Bezier Curve");
  
      init ( );
      glutDisplayFunc (displayFcn);
      glutMouseFunc(MouseCallback);
      glutMotionFunc(MotionCallback);
      glutMainLoop ( );
  }
  </code></pre>