home *** CD-ROM | disk | FTP | other *** search
/ gdead.berkeley.edu / gdead.berkeley.edu.tar / gdead.berkeley.edu / pub / cad-tools / ciftomann.tar / poly2mann.c < prev    next >
C/C++ Source or Header  |  1991-09-10  |  8KB  |  314 lines
  1. /*
  2.  * poly2mann - Converts polygons in kic/cif format to mann format for 
  3.  *        the GCA 3600 pattern generator
  4.  *
  5.  *      Copyright (c) 1988 David Giandomenico
  6.  *      University of California, Berkeley
  7.  *      gian@argon.Berkeley.EDU
  8.  *
  9.  *      slighty modified by William Tang   4/4/89
  10.  *      University of California, Berkeley
  11.  *      tang@janus.Berkeley.EDU
  12.  *
  13.  *      modified again by William Tang 11/21/89
  14.  *
  15.  *      All Rights Reserved
  16.  *
  17.  * Permission to use, copy, modify, and distribute this software and its
  18.  * documentation for any purpose and without fee is hereby granted,
  19.  * provided that the above copyright notice appear in all copies and that
  20.  * both that copyright notice and this permission notice appear in
  21.  * supporting documentation.
  22.  * The author makes no representations about the suitability of
  23.  * this software for any purpose.  It is provided "as is"
  24.  * without express or implied warranty.
  25.  */
  26.  
  27. /* To compile:
  28.     cc poly2mann.c -lm -o poly2mann
  29.  */
  30.  
  31. #include <stdio.h>
  32. #include <math.h>
  33. #define MAXLINE 512
  34. #define MAX_APER 9500        /* .95 mm on mask */
  35. #define MIN_APER 20        /* 2 microns on mask */
  36. #define MAX_STAGE 500000    /* +/-50mm */
  37. #ifndef M_PI
  38. #define M_PI    3.14159265358979323846
  39. #endif
  40. #define ABS(X) ((X)<0? -(X):(X))
  41.  
  42. char *progname;
  43. char xxl;
  44. char yyl;
  45. char xxc;
  46. char yyc;
  47. double scale = 0;    /* reduction factor */
  48. FILE *fp = stdin;
  49. main(argc,argv)
  50. int argc;
  51. char *argv[];
  52. {
  53.     char line[MAXLINE];
  54.     progname = argv[0];
  55.     getargs(argc,argv);
  56.  
  57.     while(fgets(line,MAXLINE,stdin) != NULL) poly_to_box(line);
  58. }
  59.  
  60. getargs(argc, argv)
  61. int argc;
  62. char *argv[];
  63. {
  64.     float mpl=0, reduction=0;
  65.     extern double scale;
  66.  
  67.     while ( --argc > 0 ) {
  68.     if ( (*++argv)[0] == '-') {
  69.         switch ( (*argv)[1] ) {
  70.         case 'L':
  71.             --argc;
  72.             if (sscanf(*++argv, "%f", &mpl) != 1) usage();
  73.             break;
  74.         case 'S':
  75.             --argc;
  76.             if (sscanf(*++argv, "%f", &reduction) != 1) usage();
  77.             break;
  78.         default:
  79.             fprintf(stderr,"Unknown option %s\n", *argv);
  80.             usage();
  81.         }
  82.     } else if ( freopen(*argv,"r", stdin) == NULL) usage();
  83.     }
  84.  
  85.     scale = mpl * reduction;
  86.     scale *= 10;    /* units of p.g. are tenths of microns */
  87.     scale /= 100;    /* cif units are 100/micron */
  88. /*    fprintf(stderr, " this is line 87 scale is %f\n", scale);
  89.     printf(" this is line 87 scale is %f\n", scale);   */
  90.     if (scale == 0) usage();
  91. }
  92. usage()
  93. {
  94.     fprintf(stderr,
  95.     "usage: %s file -L mic/lambda -S photo_reduction_factor\n",
  96.     progname);
  97.     exit(1);
  98. }
  99.  
  100. error(ln,line,message)
  101. int ln;
  102. char *line, *message;
  103. {
  104.     static int count = 0;
  105.     count++;
  106.  
  107.     fprintf(stderr, "ERROR #%d: %s\nline %d: %s\n", count, message, ln, line); 
  108.  
  109.     printf("ERROR #%d: %s\nline %d: %s\n", count, message, ln, line);
  110. /* 
  111.  *  if (count > 20) {
  112.  *      fprintf(stderr, "More than 20 errors; quitting\n");
  113.  *
  114.  *      printf("More than 20 errors; quitting\n");
  115.  * 
  116.  *         fflush(stdout);
  117.  *      fflush(stderr);
  118.  *      exit(1);
  119.  *  }
  120.  */
  121. }
  122.  
  123.  
  124. poly_to_box(line)
  125. char *line;
  126. {
  127.     static int ln =0;
  128.     char key[16], semi[16];
  129.     struct XY {
  130.     long int x,y;
  131.     }p1,p2,p3,p4,p5;
  132.     long int x,y;
  133.  
  134.     ln++; /* line count */
  135.     if (sscanf(line, "%s %d %d %d %d %d %d %d %d %d %d %s",
  136.     key,
  137.     &p1.x, &p1.y,
  138.     &p2.x, &p2.y,
  139.     &p3.x, &p3.y,
  140.     &p4.x, &p4.y,
  141.     &p5.x, &p5.y, semi) == 12) {
  142.     if ((p1.x != p5.x) || (p1.y != p5.y)) {
  143.         error(ln,line,"fifth coordinate must match first coordinate");
  144.         return;
  145.     }
  146.     } else if (sscanf(line, "%s %d %d %d %d %d %d %d %d %s",
  147.         key,
  148.         &p1.x, &p1.y,
  149.         &p2.x, &p2.y,
  150.         &p3.x, &p3.y,
  151.         &p4.x, &p4.y, semi) != 10) {
  152.     error(ln,line,"wrong format for polygon-box");
  153.     return;
  154.     }
  155.     if ((strcmp("P", key) != 0) || (strcmp(";", semi) != 0)) {
  156.     error(ln,line,"wrong format for polygon-box");
  157.     return;
  158.     }
  159.     conv_to_box(&p1,&p2,&p3,&p4,ln,line);
  160. }
  161.  
  162. conv_to_box(p1,p2,p3,p4,ln,line)
  163. struct XY {
  164.     long int x,y;
  165.     } *p1,*p2,*p3,*p4;
  166. int ln;    /* line number */
  167. char *line;
  168. {
  169.     extern double scale;
  170.     long int x,y;
  171.     double mag, dot;
  172.     long int vx1,vx2,vy1,vy2;
  173.     int xdir, ydir;
  174.     int decimal, sign;
  175.     double angle, fl;
  176.     double xc,yc,xl,yl;
  177.     int xic, yic, xil, yil;
  178.     char xxc, yyc, xxl, yyl;
  179.     struct XY mid1,mid2;
  180.  
  181.     /* p3 -  p2        <- Arrangement of points, p1-p4
  182.      * |     |
  183.      * p4 -  p1
  184.      */
  185.     /* Check if parallel sides */
  186.     vx1 = p2->x - p1->x; vy1 = p2->y - p1->y;
  187.     vx2 = p3->x - p4->x; vy2 = p3->y - p4->y;
  188.  
  189. /*
  190.  *  printf("vx1 is %d, vy1 is %d, vx2 is %d, vy2 is %d\n", vx1, vy1, vx2, vy2);
  191.  *  fprintf(stderr, "vx1 is %d, vy1 is %d, vx2 is %d, vy2 is %d\n", vx1, vy1, vx2, vy2);
  192.  */
  193.  
  194.     yl  = sqrt((double) vx1*vx1+ (double) vy1*vy1);
  195.     yl += sqrt((double) vx2*vx2+ (double) vy2*vy2);  
  196.  
  197.     yl /= 2.0;
  198. /*
  199.  *  fprintf(stderr," this is line 189 : yl = %f\n", yl);
  200.  *  printf(" this is line 189 : yl = %f\n", yl); 
  201.  */
  202.     if ((ABS(vx1 - vx2) > 2) || (ABS(vy1 - vy2) > 2)) {
  203.         error(ln, line, "sides aren't parallel");
  204.         return;
  205.     }
  206.     vx1 = p3->x - p2->x; vy1 = p3->y - p2->y;
  207.     vx2 = p4->x - p1->x; vy2 = p4->y - p1->y;
  208.  
  209.     xl  = sqrt((double) vx1*vx1+ (double) vy1*vy1);
  210.     xl += sqrt((double) vx2*vx2+ (double) vy2*vy2);  
  211.  
  212.     xl /= 2.0;
  213. /*
  214.  *  fprintf(stderr," this is line 204 : xl = %f\n", xl);
  215.  *  printf(" this is line 204 : xl = %f\n", xl); 
  216.  */
  217.     if ((ABS(vx1 - vx2) > 2) || (ABS(vy1 - vy2) > 2)) {
  218.         error(ln, line, "sides aren't parallel");
  219.         return;
  220.     }
  221.  
  222.     /* Check if rectangular using dot product */
  223.     vx1 = (p2->x - p1->x); vy1 = (p2->y - p1->y);
  224.     vx2 = (p4->x - p1->x); vy2 = (p4->y - p1->y);
  225.  
  226.     mag = (double) vx1 * vx1 +  (double) vy1 * vy1;
  227.     mag *= ((double) vx2 * vx2 +  (double) vy2 * vy2);
  228.     mag = sqrt(mag); 
  229.  
  230.     dot = ((double) vx1 * vx2 + (double)  vy1 * vy2) / mag; 
  231.  
  232.     if ( ABS(dot) > 0.01 )
  233.         {
  234.         angle = (180.0 / M_PI) * acos(dot);
  235. /*      fprintf(stderr, "dot product is %9.3e\n", dot);
  236.  */
  237.         fprintf(stderr, "angle = %5.2f\n", angle);
  238.         error(ln, line, "polygon not square enough");
  239.         return;
  240. /*
  241.         fprintf(stderr, "[%d] %5.2f    ",ln, angle);
  242.         return; 
  243.  */
  244.     }
  245.     /* Make a box */
  246.  
  247.     xc = ((double) p1->x + p2->x + p3->x + p4->x )/4.0;
  248.     yc = ((double) p1->y + p2->y + p3->y + p4->y )/4.0; 
  249.  
  250.     xc *= scale; yc *= scale;
  251.     xl *= scale; yl *= scale;
  252. /*
  253.  *  fprintf(stderr," this is line 236 : yl = %f\n", yl);
  254.  *  printf(" this is line 236 : yl = %f\n", yl); 
  255.  * 
  256.  *  fprintf(stderr," this is line 239 : xl = %f\n", xl);
  257.  *  printf(" this is line 239 : xl = %f\n", xl); 
  258.  */
  259.     /* xc = rint(xc); yc = rint(yc); */
  260.     /* xl = rint(xl); yl = rint(yl); */
  261.  
  262.     if (xc < 0) { fl = -0.5;} else { fl = 0.5;}
  263.     xic = xc + fl;
  264.     if (xl < 0) { fl = -0.5;} else { fl = 0.5;}
  265.     xil = xl + fl;
  266.     if (yc < 0) { fl = -0.5;} else { fl = 0.5;}
  267.     yic = yc + fl;
  268.     if (yl < 0) { fl = -0.5;} else { fl = 0.5;}
  269.     yil = yl + fl;
  270.  
  271. /* Check box is smaller than maximum aperature of pattern generator
  272.  * If not, subdivide the box
  273.  */
  274.     if ( xl > MAX_APER ) {
  275.         /* p3 - mid1 -  p2
  276.          * p4 - mid2 -  p1
  277.      */
  278.     mid1.x = (p3->x + p2->x)/2; mid1.y = (p3->y + p2->y)/2;
  279.     mid2.x = (p4->x + p1->x)/2; mid2.y = (p4->y + p1->y)/2;
  280.         conv_to_box(&mid2,&mid1,p3,p4,ln,line); /* left box */
  281.         conv_to_box(p1,p2,&mid1,&mid2,ln,line); /* right box */
  282.     return;
  283.     }
  284.     else if ( yl > MAX_APER ) {
  285.         /*  p3  -  p2
  286.      * mid2 - mid1
  287.          *  p4  -  p1
  288.      */
  289.     mid1.x = (p1->x + p2->x)/2; mid1.y = (p1->y + p2->y)/2;
  290.     mid2.x = (p3->x + p4->x)/2; mid2.y = (p3->y + p4->y)/2;
  291.         conv_to_box(&mid1,p2,p3,&mid2,ln,line); /* upper box */
  292.         conv_to_box(p1,&mid1,&mid2,p4,ln,line); /* lower box */
  293.     return;
  294.     }
  295.  
  296. /* Check dimensions to make sure they fit pattern gernerator */
  297.     if ( xl < MIN_APER || yl < MIN_APER ) {
  298.     fprintf(stderr," this is line 256 , xl = %f and yl = %f\n", xl, yl);
  299.     printf(" this is line 256 , xl = %f and yl = %f\n", xl, yl);
  300.         error(ln, line,
  301.         "polygon is smaller than minimum aperature size of 20");
  302.     return;
  303.     }
  304.     if ( ABS(xc) > MAX_STAGE || ABS(yc) > MAX_STAGE ) {
  305.         error(ln, line,
  306.         "polygon extends beyond maximum stage position");
  307.     return;
  308.     }
  309.     xdir =  ((p1->x - p4->x) + (p2->x - p3->x));
  310.     ydir =  ((p1->y - p4->y) + (p2->y - p3->y));
  311.     printf("B %d %d %d %d %d %d;\n\0",
  312.     (int)xil, (int)yil, (int)xic, (int)yic, xdir, ydir);
  313. }
  314.