lab3.c

#include <FPT.h>
#include <D2d_matrix.h>

int WIDTH = 500; int HEIGHT = 500;
int counter = 0;
int points[100]; //number of points in whatever
double x[100][100], y[100][100]; //x and y coordinates
int polys[10];
int shapes[100][100]; //the shapes[what argument][which shape]
int shapeorder[100][100][100]; //where things connect to
double red[100][100], green[100][100], blue[100][100]; //individual colors of each[what arg][which shape]
int boxheight, boxwidth, centerx, centery;
double smallx, smally, bigx, bigy; //specific smallest & largest (X,Y)'s

//determines if a point is on one side of the line or the other
double whatside(double ax, double ay, double bx,
                double by, double x1, double y1,
                double x2, double y2) {

  return ((y1 - y2) * (ax - x1) + (x2 - x1) * (ay - y1)) *
         ((y1 - y2) * (bx - x1) + (x2 - x1) * (by - y1));
}

//Bounding Box For Line Segment
//(x1,y1) = start of the line
//(x2, y2) = the end of the line
int pointincontainer(double x1, double y1, double x2, double y2,
                     double xprime, double yprime) {
  double left, top, right, bottom;
  if (x1 < x2) {
    left = x1;
    right = x2;
  } else {
    left = x2;
    right = x1;
  }
  if (y1 > y2) {
    top = y1;
    bottom = y2;
  } else {
    top = y2;
    bottom = y1;
  }
  //printf("l:%lf, r:%lf, t:%lf, b:%lf\n", left, right, top, bottom);
  //printf("x': %lf, y': %lf\n", xprime, yprime);
  if ((xprime + 0.01) >= left && (xprime - 0.01) <= right &&
      (yprime + 0.01) <= top && (yprime - 0.01) >= bottom) {
    return 1;
  } else {
    return 0;
  }
}

int looper(int i, int n) {
  if (i == n - 1) {
    return 0;
  } else {
    return i + 1;
  }
}

//gets the slope of all the lines; returns them via modified array
void getslope(double *x, double *y, int z, double *slope) {
  int i;
  for (i = 0; i < z; i++) {
    slope[i] = (y[looper(i, z)] - y[i]) / (x[looper(i, z)] - x[i]);
  }
}

//finds the intersection of the all lines
//returns intersection coordinates via array
void f_intersect(double *px, double *py, int pn,
                 double *wx, double *wy, int wn, double *c) {
  int i, j;
  double yprime, xprime, wslope[100], pslope[100], c1, c2;
  getslope(px, py, pn, pslope);
  getslope(wx, wy, wn, wslope);

  for (i = 0; i < wn; i++) {
    for (j = 0; j < pn; j++) {
      c1 = py[j] - pslope[j] * px[j]; //y = mx + c - > c = y -mx
      c2 = wy[i] - wslope[i] * wx[i];

      if ((pslope[j] - wslope[i]) == 0) { //prevents divison by 0
        printf("Slope division by 0; ERROR!\n");
      } else {
        xprime = (c2 - c1) / (pslope[j] - wslope[i]); //intersection of x
        yprime = pslope[j] * xprime + c1; //intersection of y

        if (pointincontainer(px[j], py[j], px[looper(j, pn)], py[looper(j, pn)],
                             xprime, yprime) == 1 &&
            pointincontainer(wx[i], wy[i], wx[looper(i, wn)], wy[looper(i, wn)],
                             xprime, yprime ) == 1) {
          c[counter] = xprime; c[counter + 1] = yprime;
        G_wait_key();
        G_rgb(0,0,0);
        G_fill_circle(xprime,yprime, 2);
          counter += 2;
        }
      }
    }
  }
}


//click a point and it saves it into an array
int clickAndSave(double *x, double *y) {
  double ca[2];
  int i = 0;
  int going = 1;
  G_rgb(0, 0, 0);;
  G_draw_string("Click here to end clipping", 0, 0);
  while (going) {
    G_wait_click(ca);
    //printf("%lf, %lf\n", ca[0], ca[1]);
    if (ca[0] < 260 & ca[1] < 15) {
      going = 0;
      x[i] = x[0];
      y[i] = y[0];
      //printf("done\n");
    } else {
      x[i] = ca[0];
      y[i] = ca[1];
      G_rgb(0, 1, 1);
      G_circle(x[i], y[i], 1);
      G_rgb(0, 0, 0);
      G_circle(x[i], y[i], 2);
      i++;
      //printf(" %d\n", i);
    }

  }
  return i;
}

//draws the polygon; unfilled
void myPolygon(double *x, double *y, int n) {
  int i = 0;
  while (i <= n) {
    if (i != n) {
      G_line(x[i], y[i], x[i + 1], y[i + 1]);
    }
    i++;
  }
}

//Creates bounding box around figure
double boundingbox(int i) {
  int k;

  smallx = WIDTH * 2; smally = HEIGHT * 2;
  bigx = WIDTH * -2; bigy = HEIGHT * -2;
  for (k = 0; k < points[i]; k++) {
    if (x[i][k] < smallx) {
      smallx = x[i][k];
    }
    else if (x[i][k] > bigx) {
      bigx = x[i][k];
    }
    if (y[i][k] < smally) {
      smally = y[i][k];
    }
    else if (y[i][k] > bigy) {
      bigy = y[i][k];
    }
  }

  boxheight = bigy - smally;
  boxwidth =  bigx - smallx;
  centerx = (bigx + smallx) / 2;
  centery = (smally + bigy) / 2;

  if (WIDTH / boxwidth < HEIGHT / boxheight) {
    return WIDTH / boxwidth;
  } else {
    return HEIGHT / boxheight;
  }
}


//reads the file and attaches the correct variable to each input
void readobject(FILE *g, int i) {
  int k, j;

  fscanf(g, "%d", &points[i]);
  //printf("there are %d points\n", points[i]);
  for (k = 0; k < points[i]; k++) {
    fscanf(g, "%lf  %lf", &x[i][k], &y[i][k]);
    //printf("(%lf,%lf)\n", x[i][k], y[i][k]);
  }
  fscanf(g, "%d", &polys[i]);
  //printf("there are %d polygons in this whatever\n", polys[i]);

  for (k = 0; k < polys[i]; k++) {
    fscanf(g, "%d", &shapes[i][k]);
    for (j = 0; j < shapes[i][k]; j++) {
      fscanf(g, "%d", &shapeorder[i][k][j]);
      //printf("%d\n", shapeorder[i][k][j]);
    }
  }
  for (k = 0; k < polys[i]; k++) {
    fscanf(g, "%lf %lf %lf", &red[i][k], &green[i][k], &blue[i][k]); //the rgb
    //printf("(%lf, %lf, %lf)\n", red[i][k], green[i][k], blue[i][k]);
  }
}

//draws the image
void drawit(int i) {
  int k, j;
  double tempx[points[i]], tempy[points[i]];

  for (k = 0; k < polys[i]; k++) {
    for (j = 0; j < shapes[i][k]; j++) {
      tempx[j] = x[i][shapeorder[i][k][j]];
      tempy[j] = y[i][shapeorder[i][k][j]];
    }

    G_rgb(red[i][k], green[i][k], blue[i][k]);
    G_fill_polygon(tempx, tempy, j);
  }
}

//controls the movement of the object
void movement(int i, double sf, double m[3][3], double minv[3][3]) {

  D2d_translate(m, minv, -centerx, -centery);
  D2d_scale(m, minv, sf, sf);
  D2d_translate(m, minv, WIDTH / 2, HEIGHT / 2);
  D2d_mat_mult_points(x[i], y[i], m, x[i], y[i], points[i]);
}

//writes the opening instructions
void welcome(int i) {
  printf("Press");
  if (i == 1) {
    printf(" 1 to start,");
  } else if (i == 2) {
    printf(" 1 or 2 to start,");
  } else {
    printf(" 1 through %d to begin,", i);
  }
  printf("\nthen press TAB to begin clipping\n");
}

//the clipping container
void clipping(double *clipx, double *clipy, int i) {
  double c[100];
  int temp_i = clickAndSave(clipx, clipy);
  myPolygon(clipx, clipy, temp_i);
  f_intersect(clipx, clipy, temp_i, x[i], y[i], points[i], c);
  G_wait_key();
}

int main(int argc, char **argv) {
  char key, c;  FILE *g;
  double m[3][3], minv[3][3], sf, clipx[100], clipy[100];
  int cc;
  int inner_cycle = 1;

  for (cc = 1; cc < argc; cc++) {
    g = fopen(argv[cc], "r"); //opens a file; r = read only
    if (g == NULL) { //if the file is empty, it will let me know
      printf("can't open (1)\n");
      exit(1);
    } else {
      readobject(g, cc);

      D2d_make_identity(m); D2d_make_identity(minv);
      sf = boundingbox(cc); //Remember, sf == scale factor
      movement(cc, sf, m, minv); //(arg, scale, m, m inverse)
    }
  }

  welcome(argc - 1);
  scanf("%c", &key);
  int i = key - '0';

  if (i < argc && i > 0) {
    G_init_graphics(WIDTH, HEIGHT);

    D2d_make_identity(m); D2d_make_identity(minv);
    D2d_translate(m, minv, -WIDTH / 2, -HEIGHT / 2);
    D2d_rotate(m, minv, M_PI / 45);
    D2d_translate(m, minv, WIDTH / 2, HEIGHT / 2);

    while (inner_cycle) {
      G_rgb(1, 1, 1);
      G_clear();

      D2d_mat_mult_points(x[i], y[i], m, x[i], y[i], points[i]);

      drawit(i);

      G_rgb(0, 0, 0);

      c = G_wait_key();
      cc = c - '0';

      if (cc > 0 && cc < argc) {
        if (cc != i) {
          i = cc;
        }
      } else if (cc == -39) {

        inner_cycle = 0;

        clipping(clipx, clipy, i);
      } else {
        printf("can't open (2)\n");
        exit(1);
      }
    }
  }
}