Штриховка замкнутой области в заданном графике функции

#include <graphics.h>
#include <stdio.h>
#include <conio.h>
#include <time.h>
#include <stdlib.h>
#include <math.h>
 
const int X0 = 100, Y0 = 400, // начало координат
        k = 40;             // масштаб
// глобальные переменные
 
// процедуры и функции
//-----------------------------------------
// SCREENX - перевод X в координаты экрана
//-----------------------------------------
int ScreenX (float x)
{
    return X0+k*x;
}
//-----------------------------------------
// SCREENY - перевод Y в координаты экрана
//-----------------------------------------
int ScreenY (float y)
{
    return Y0-k*y;
}
void Axes()
{
    int i, xe, ye;
    char s[15];
    line ( X0, 0, X0, 599 );
    line ( 0, Y0, 519, Y0 );
    for (i = 0; i <= (520-X0)/k; i++)
        {
        xe = ScreenX(i);
        line ( xe, Y0-10, xe, Y0+10 );
        sprintf ( s, "%d", i );
        outtextxy ( xe-6, Y0+2, s );
        }
    for (i = 1; i <= (600-X0)/k; i++)
        {
        ye = ScreenY(i);
        line ( X0-3, ye, X0+3, ye );
        sprintf ( s, "%d", i );
        outtextxy ( X0-30, ye, s );
        }
}
//-----------------------------------------
// POINT выводит пиксели с проверкой и 
//          пересчетом координат
//-----------------------------------------
void Point ( float x, float y, int color )
{
    int xe, ye;
    xe = ScreenX(x);
    ye = ScreenY(y);
    if ( xe >= 0 && xe < 520 &&
        ye >= 0 && ye < 600)
        putpixel(xe, ye, color);
}
float f1 ( float x )
{
    return x*x-2;
}
float f2 ( float x )
{
    return x;
}
int odz1 ( float x )
{
    return ( x<= 4 );
}
//-----------------------------------------
// PLOT выводит графики функий
//-----------------------------------------
void Plot ()
{
    float xmin = - 1. * X0 / k,
        xmax = (520. - X0) / k;
    float x,
        h = (xmax - xmin) / 1000;
  for ( x = xmin; x <= xmax; x += h)
        if ( odz1(x) )
            Point(x, f1(x), LIGHTRED);
            for ( x = xmin; x <= xmax; x += h)
    Point (x, f2(x), LIGHTRED);
}
 //--------------------------------------------
// Solve находит точку пересечения на [a, b]
// Вход: a, b - границы интервала, a < b
//       eps - точность решения
// Выход: x - решение уравнения f1(x)=f2(x)
//---------------------------------------------
float Solve ( float a, float b, float eps )
{
float c, fa, fc;
while ( fabs(b-a)> eps ) { // пока не достигли заданной точности
    c = (a+b) / 2.;       // середина отрезка [a, b]
    fa = f1(a) - f2(a);   // разность функций в точке x=a
    fc = f1(c) - f2(c);   // разность функций в точке x=с
    if ( fa*fc < 0 ) b = c; // сужаем область поиска
    else            a=c;
    }
return (a + b) / 2.; // результат - середина отрезка
}
 
void Cross()
{
    float y, x1, x2;
    int xe, ye;
   char s[15];
    
    x1 = Solve(-1., -1., 0.001); // найти x-координату точки
    y = f1(x1);                 // найти y-координату точки
    xe = ScreenX(x1);           // вычислить экранные координаты
    ye = ScreenY(y);
    sprintf(s, "x1:%5.2f", x1 ); // вывод координат на экран
    outtextxy(xe-60, ye+2, s);
    sprintf(s, "y:%5.2f", y );
    outtextxy(xe-60, ye+22, s);
    
    x2 = Solve(2., 2., 0.001); // найти x-координату точки
    y = f1(x2);               // найти y-координату точки
    xe = ScreenX(x2);         // вычислить экранные координаты
    ye = ScreenY(y);
    sprintf(s, "x2:%5.2f", x2 ); // вывод координат на экран
    outtextxy(xe+5, ye+2, s);
    sprintf(s, "y2:%5.2f", y );
    outtextxy(xe+5, ye+22, s);
}
 
 
 void Hatch()
{
    const int N = 15;
    float x, x1 = -1, x2 = 2, h = ( x2-x1 ) / (N + 1);
    int xe, yUp, yDown;
    for (x = x1+h; x < x2; x += h)
        {
        xe = ScreenX ( x ); 
        yUp = ScreenY ( f1(x) );
        yDown = ScreenY ( f2(x) );
        line ( xe, yUp, xe, yDown );
        }   
}
 
 
 
void Hatch2()
{
    const int N = 15;
    float x, xc1 = -2, xc2 = 5, h = ( xc2-xc1 ) / (N + 1);
    int xe, yUp, yDown;
    for (x = xc1+h; x < xc2; x += h)
        {
        xe = ScreenX (x);   
        yUp = ScreenY ( f1(x*x-2));
        yDown = ScreenY ( f2(sqrt(-2)));
        line ( xe, yUp, xe, yDown );
        }   
}
//---------------------------------------------
// randf - случайное вещественное число
//        в заданоном интервале
//---------------------------------------------
float randf ( float a, float b)
{
return (b-a)*rand() /RAND_MAX + a;
}
//---------------------------------------------
// Inside - определяет, находится ли точка
//              внутри фигуры
// Вход: x, y - координаты точки
// Выход: 1, если точка внутри фигуры,
//        0, если точка вне фигуры
//---------------------------------------------
int Inside ( float x, float y )
{
    if ( x*x-2 <= y && y <= x )  //Down(x) <= y && y <= Up(x);
        return 1;
   else return 0;
}
 //---------------------------------------------
// Area - вычисление площади методом Монте-Карло
//----------------------------------------------
void Area ()
{
 
    int i, N = 200000, M = 0;
    float x1 = -2, x2 = 2, y1 = -2, y2 = 2;
    float x, y, S;
    char out[20];
    for (i=1; i<=N; i++)
    {
        x = randf ( x1, x2);
        y = randf ( y1, y2);
        if ( Inside(x,y) ) M++;
    }
    S = (x2-x1) * (y2-y1) *M/N;
    sprintf(out, "S=%7.3f", S);
    outtextxy (300, 320, out);
}
 
main()
{
 initwindow(520, 600);
 //// основная часть
Axes(); // ось координат
Plot(); // график функции
Cross();
 Hatch();
 // точки пересечения графиков // штриховка
Hatch2();
 Area();  // площадь (способ 1)
 // Area2();  // площадь (способ 2)
 
 getch();
 closegraph(); 
}