Black Face Removal Algorithm for Plane Surfaces in text mode.

#include<stdio.h>
#include<stdlib.h>

int n;
typedef struct {int x, y;} point2D;
point2D WVtx[4];
typedef struct {int x, y, z;} point3D;
point3D Vloc;
typedef struct {float a, b, c;} vector;

typedef struct {point3D vtx[10]; int len; int visible; vector normal;} polygon;
polygon poly[10];
vector viewvector, temp;
int xsize, ysize, DB[50][50];

int inside_poly(polygon, int, int);
int side_check(polygon, int, int, int, int);
int visibility(polygon);

main()
{
 int i, j, k;
 printf("\nHow many planes in object? ");
 scanf("%d", &n);

 for(i=0;i<n;i++)
    {
     printf("\nHow many vertices in plane[%d]? ",i);
     scanf("%d", &k); poly[i].len = k;
     for(j=0;j<k;j++)
        {
         printf("\nGive vertex point[%d]: ",j);
         scanf("%d %d %d", &poly[i].vtx[j].x, &poly[i].vtx[j].y, &poly[i].vtx[j].z);
      }
   }

 for(i=0;i<4;i++)
   {
    printf("\nGive Window vertex point[%d]:",i);
    scanf("%d %d", &WVtx[i].x, &WVtx[i].y);
   }

 printf("\nGive Viewpoint Co-ordinates:");
 scanf("%d %d %d", &Vloc.x, &Vloc.y, &Vloc.z);

 xsize = WVtx[2].x - WVtx[0].x + 1;
 ysize = WVtx[2].y - WVtx[0].y + 1;

 for(i=0;i<n;i++)
   {
    get_surface_normal(poly[i]);
    poly[i].normal = temp;
    }

 get_view_vector();

 for(i = 0; i < xsize; i++)
   for(j = 0; j < ysize; j++)
       DB[i][j] = 0;
                                                                                                    
 printf("\n");
 for(i = 0; i < xsize; i++)
      {
      for(j = 0; j < ysize; j++)
          printf("%d ",DB[i][j]);
      printf("\n");
     }

 Backface();

 printf("\n");
 for(i = 0; i < xsize; i++)
     {
        for(j = 0; j < ysize; j++)
          printf("%d ",DB[i][j]);
      printf("\n");
     }
}


Backface()
{
 int i, j, p;

 for(i=0;i<n;i++)
    {
    poly[i].visible = visibility(poly[i]);
    if (poly[i].visible == 1) printf("\npolygon[%d] is visible", i);
    else printf("\npolygon[%d] is invisible", i);                
   }

 for(p = 0; p < n; p++)
   {
   for(i = 0; i < xsize; i++)
     {
      for(j = 0; j < ysize; j++)
        {
            if(poly[p].visible == 1)
             if(inside_poly(poly[p], i, j) == 1)
                DB[i][j] = p+1;
        }
     }
   }

}


int inside_poly(polygon pg, int x, int y)
{
 int i, inside;
 for(i = 0; i < pg.len - 1; i++)
   {
    inside = side_check(pg, i, i+1, x, y);
    if (inside == 0) break;
   }
 if(inside == 1)
    inside = side_check(pg, pg.len - 1, 0, x, y);
 return(inside);
}


int side_check(polygon pg, int k, int l, int x, int y)
{
 int f;
 f = (pg.vtx[l].x - pg.vtx[k].x) * (y - pg.vtx[k].y) - (pg.vtx[l].y - pg.vtx[k].y) * (x - pg.vtx[k].x);
 if (f > 0.0)//(x, y) is on the left of line;
 return (1); else return (0);
}

get_surface_normal(polygon pg)
{
 temp.a = pg.vtx[0].y * (pg.vtx[1].z - pg.vtx[2].z) + pg.vtx[1].y * (pg.vtx[2].z - pg.vtx[0].z) + pg.vtx[2].y * (pg.vtx[0].z - pg.vtx[1].z);
 temp.b = pg.vtx[0].z * (pg.vtx[1].x - pg.vtx[2].x) + pg.vtx[1].z * (pg.vtx[2].x - pg.vtx[0].x) + pg.vtx[2].z * (pg.vtx[0].x - pg.vtx[1].x);
 temp.c = pg.vtx[0].x * (pg.vtx[1].y - pg.vtx[2].y) + pg.vtx[1].x * (pg.vtx[2].y - pg.vtx[0].y) + pg.vtx[2].x * (pg.vtx[0].y - pg.vtx[1].y);
printf("\ntemp.a = %4.2f, temp.b = %4.2f, temp.c = %4.2f",temp.a, temp.b, temp.c);
}

get_view_vector()
{
 point3D target;

 target.x = xsize/2; target.y = ysize/2; target.z = 0.0;
 viewvector.a = (float)(target.x - Vloc.x); viewvector.b = (float)(target.y - Vloc.y);
 viewvector.c = (float)(target.z - Vloc.z);
 printf("\ntarget.x = %d, target.y = %d, target.z = %d",target.x, target.y, target.z);
 printf("\nvloc.x = %d, vloc.y = %d, vloc.z = %d",Vloc.x, Vloc.y, Vloc.z);

 printf("\nview.a = %4.2f, view.b = %4.2f, view.c = %4.2f",viewvector.a, viewvector.b, viewvector.c);
}

int visibility(polygon pg)
{
 int v;
 v = viewvector.a * pg.normal.a + viewvector.b * pg.normal.b + viewvector.c * pg.normal.c;
 printf("\nVector product = %d", v);
 if(v < 0) return (1); else return(0);
}