showme.c

一个用于三角剖分的类.实用性非常好。对于需要从多边形

      (*edgeptr)[index + 1] += 1 - firstnumber;
      if (((*edgeptr)[index + 1] < 1) || ((*edgeptr)[index + 1] > nodes)) {
        printf("Error:  Edge %d has invalid endpoint in %s.\n", i, fname);
        return 1;
      }
    }
    index += 2;
  }
  fclose(infile);
  return 0;
}

int load_part(fname, dim, firstnumber, elems, nodeptr, eleptr, parts,
              partition, partcenter, partshift)
char *fname;
int dim;
int firstnumber;
int elems;
REAL *nodeptr;
int *eleptr;
int *parts;
int **partition;
REAL **partcenter;
REAL **partshift;
{
  FILE *infile;
  char inputline[INPUTLINESIZE];
  char *stringptr;
  int partelems;
  int index;
  int elemnumber;
  int i, j;
  int smallerr;
  int *partsize;

  if (!quiet) {
    printf("Opening %s.\n", fname);
  }
  infile = fopen(fname, "r");
  if (infile == (FILE *) NULL) {
    printf("  Error:  Cannot access file %s.\n", fname);
    return 1;
  }
  stringptr = readline(inputline, infile, fname);
  partelems = (int) strtol (stringptr, &stringptr, 0);
  if (partelems != elems) {
    printf(
      "  Error:  .ele and .part files do not agree on number of triangles.\n");
    return 1;
  }
  stringptr = findfield(stringptr);
  if (*stringptr == '\0') {
    *parts = 1;
  } else {
    *parts = (int) strtol (stringptr, &stringptr, 0);
  }
  if (*parts < 1) {
    printf("  Error:  %s specifies %d subdomains.\n", fname, *parts);
    return 1;
  }
  *partition = (int *) malloc((elems + 1) * sizeof(int));
  if (*partition == (int *) NULL) {
    printf("  Out of memory.\n");
    return 1;
  }
  smallerr = 1;
  for (i = firstnumber; i < firstnumber + partelems; i++) {
    stringptr = readline(inputline, infile, fname);
    elemnumber = (int) strtol (stringptr, &stringptr, 0);
    if ((elemnumber != i) && (smallerr)) {
      printf("  Warning:  Triangles in %s are not numbered correctly.\n",
             fname);
      printf("            (starting with triangle %d).\n", i);
      smallerr = 0;
    }
    stringptr = findfield(stringptr);
    if (*stringptr == '\0') {
      printf("Error:  Triangle %d has no subdomain in %s.\n", i, fname);
      free(*partition);
      return 1;
    }
    j = i + 1 - firstnumber;
    (*partition)[j] = (int) strtol (stringptr, &stringptr, 0) - firstnumber;
    if (((*partition)[j] >= *parts) || ((*partition)[j] < 0)) {
      printf("  Error:  Triangle %d of %s has an invalid subdomain.\n",
             i, fname);
      free(*partition);
      return 1;
    }
  }
  fclose(infile);
  *partcenter = (REAL *) malloc(((*parts + 1) << 1) * sizeof(REAL));
  if (*partcenter == (REAL *) NULL) {
    printf("Error:  Out of memory.\n");
    free(*partition);
    return 1;
  }
  *partshift = (REAL *) malloc((*parts << 1) * sizeof(REAL));
  if (*partshift == (REAL *) NULL) {
    printf("Error:  Out of memory.\n");
    free(*partition);
    free(*partcenter);
    return 1;
  }
  partsize = (int *) malloc((*parts + 1) * sizeof(int));
  if (partsize == (int *) NULL) {
    printf("Error:  Out of memory.\n");
    free(*partition);
    free(*partcenter);
    free(*partshift);
    return 1;
  }
  for (i = 0; i <= *parts; i++) {
    partsize[i] = 0;
    (*partcenter)[i << 1] = 0.0;
    (*partcenter)[(i << 1) + 1] = 0.0;
  }
  index = 3;
  for (i = 1; i <= elems; i++) {
    partsize[(*partition)[i]] += 3;
    for (j = 0; j < 3; j++) {
      (*partcenter)[(*partition)[i] << 1] +=
                nodeptr[eleptr[index] * dim];
      (*partcenter)[((*partition)[i] << 1) + 1] +=
                nodeptr[eleptr[index++] * dim + 1];
    }
  }
  for (i = 0; i < *parts; i++) {
    (*partcenter)[i << 1] /= (REAL) partsize[i];
    (*partcenter)[(i << 1) + 1] /= (REAL) partsize[i];
    (*partcenter)[*parts << 1] += (*partcenter)[i << 1];
    (*partcenter)[(*parts << 1) + 1] += (*partcenter)[(i << 1) + 1];
  }
  (*partcenter)[*parts << 1] /= (REAL) *parts;
  (*partcenter)[(*parts << 1) + 1] /= (REAL) *parts;
  free(partsize);
  return 0;
}

int load_adj(fname, subdomains, ptr)
char *fname;
int *subdomains;
int **ptr;
{
  FILE *infile;
  char inputline[INPUTLINESIZE];
  char *stringptr;
  int i, j;

  if (!quiet) {
    printf("Opening %s.\n", fname);
  }
  infile = fopen(fname, "r");
  if (infile == (FILE *) NULL) {
    printf("  Error:  Cannot access file %s.\n", fname);
    return 1;
  }
  stringptr = readline(inputline, infile, fname);
  *subdomains = (int) strtol (stringptr, &stringptr, 0);
  if (*subdomains < 1) {
    printf("  Error:  %s contains %d subdomains.\n", fname, *subdomains);
    return 1;
  }
  *ptr = (int *) malloc(*subdomains * *subdomains * sizeof(int));
  if (*ptr == (int *) NULL) {
    printf("  Out of memory.\n");
    return 1;
  }
  for (i = 0; i < *subdomains; i++) {
    for (j = 0; j < *subdomains; j++) {
      stringptr = readline(inputline, infile, fname);
      (*ptr)[i * *subdomains + j] = (int) strtol (stringptr, &stringptr, 0);
    }
  }
  return 0;
}

void findpartshift(parts, explosion, partcenter, partshift)
int parts;
REAL explosion;
REAL *partcenter;
REAL *partshift;
{
  int i;

  for (i = 0; i < parts; i++) {
    partshift[i << 1] = explosion *
          (partcenter[i << 1] - partcenter[parts << 1]);
    partshift[(i << 1) + 1] = explosion *
          (partcenter[(i << 1) + 1] - partcenter[(parts << 1) + 1]);
  }
}

int load_image(inc, image)
int inc;
int image;
{
  int error;

  switch (image) {
    case NODE:
      error = load_node(nodefilename[inc], &firstnumber[inc], &nodes[inc],
                        &node_dim[inc], &nodeptr[inc], &xlo[inc][NODE],
                        &ylo[inc][NODE], &xhi[inc][NODE], &yhi[inc][NODE]);
      break;
    case POLY:
      error = load_poly(inc, polyfilename[inc], &firstnumber[inc],
                        &polynodes[inc], &poly_dim[inc], &polyedges[inc],
                        &polyholes[inc], &polynodeptr[inc], &polyedgeptr[inc],
                        &polyholeptr[inc],
                        &xlo[inc][POLY], &ylo[inc][POLY],
                        &xhi[inc][POLY], &yhi[inc][POLY]);
      break;
    case ELE:
      error = load_ele(elefilename[inc], firstnumber[inc], nodes[inc],
                       &elems[inc], &ele_corners[inc], &eleptr[inc]);
      xlo[inc][ELE] = xlo[inc][NODE];
      ylo[inc][ELE] = ylo[inc][NODE];
      xhi[inc][ELE] = xhi[inc][NODE];
      yhi[inc][ELE] = yhi[inc][NODE];
      break;
    case EDGE:
      error = load_edge(edgefilename[inc], firstnumber[inc], nodes[inc],
                        &edges[inc], &edgeptr[inc], &normptr[inc]);
      xlo[inc][EDGE] = xlo[inc][NODE];
      ylo[inc][EDGE] = ylo[inc][NODE];
      xhi[inc][EDGE] = xhi[inc][NODE];
      yhi[inc][EDGE] = yhi[inc][NODE];
      break;
    case PART:
      error = load_part(partfilename[inc], node_dim[inc], firstnumber[inc],
                        elems[inc], nodeptr[inc], eleptr[inc],
                        &subdomains[inc], &partpart[inc], &partcenter[inc],
                        &partshift[inc]);
      if (!error) {
        findpartshift(subdomains[inc], explosion, partcenter[inc],
                      partshift[inc]);
      }
      xlo[inc][PART] = xlo[inc][NODE];
      ylo[inc][PART] = ylo[inc][NODE];
      xhi[inc][PART] = xhi[inc][NODE];
      yhi[inc][PART] = yhi[inc][NODE];
      break;
    case ADJ:
      error = load_adj(adjfilename[inc], &adjsubdomains[inc], &adjptr[inc]);
      xlo[inc][ADJ] = xlo[inc][NODE];
      ylo[inc][ADJ] = ylo[inc][NODE];
      xhi[inc][ADJ] = xhi[inc][NODE];
      yhi[inc][ADJ] = yhi[inc][NODE];
      break;
    case VORO:
      error = load_node(vnodefilename[inc], &firstnumber[inc], &vnodes[inc],
                        &vnode_dim[inc], &vnodeptr[inc], &xlo[inc][VORO],
                        &ylo[inc][VORO], &xhi[inc][VORO], &yhi[inc][VORO]);
      if (!error) {
        error = load_edge(vedgefilename[inc], firstnumber[inc], vnodes[inc],
                          &vedges[inc], &vedgeptr[inc], &vnormptr[inc]);
      }
      break;
    default:
      error = 1;
  }
  if (!error) {
    loaded[inc][image] = 1;
  }
  return error;
}

void choose_image(inc, image)
int inc;
int image;
{
  if (!loaded[inc][image]) {
    if ((image == ELE) || (image == EDGE) || (image == PART)
        || (image == ADJ)) {
      if (!loaded[inc][NODE]) {
        if (load_image(inc, NODE)) {
          return;
        }
      }
    }
    if ((image == PART) || (image == ADJ)) {
      if (!loaded[inc][ELE]) {
        if (load_image(inc, ELE)) {
          return;
        }
      }
    }
    if (image == ADJ) {
      if (!loaded[inc][PART]) {
        if (load_image(inc, PART)) {
          return;
        }
      }
    }
    if (load_image(inc, image)) {
      return;
    }
  }
  current_inc = inc;
  current_image = image;
}

Window make_button(name, x, y, width)
char *name;
int x;
int y;
int width;
{
  XSetWindowAttributes attr;
  XSizeHints hints;
  Window button;

  attr.background_pixel = black;
  attr.border_pixel = white;
  attr.backing_store = NotUseful;
  attr.event_mask = ExposureMask | ButtonReleaseMask | ButtonPressMask;
  attr.bit_gravity = SouthWestGravity;
  attr.win_gravity = SouthWestGravity;
  attr.save_under = False;
  button = XCreateWindow(display, mainwindow, x, y, width, BUTTONHEIGHT - 4,
                         2, 0, InputOutput, CopyFromParent,
                         CWBackPixel | CWBorderPixel | CWEventMask |
                         CWBitGravity | CWWinGravity | CWBackingStore |
                         CWSaveUnder, &attr);
  hints.width = width;
  hints.height = BUTTONHEIGHT - 4;
  hints.min_width = 0;
  hints.min_height = BUTTONHEIGHT - 4;
  hints.max_width = width;
  hints.max_height = BUTTONHEIGHT - 4;
  hints.width_inc = 1;
  hints.height_inc = 1;
  hints.flags = PMinSize | PMaxSize | PSize | PResizeInc;
  XSetStandardProperties(display, button, name, "showme", None, (char **) NULL,
                         0, &hints);
  return button;
}

void make_buttons(y)
int y;
{
  int i;

  for (i = 1; i >= 0; i--) {
    nodewin[i] = make_button("node", 0, y + (1 - i) * BUTTONHEIGHT, 42);
    XMapWindow(display, nodewin[i]);
    polywin[i] = make_button("poly", 44, y + (1 - i) * BUTTONHEIGHT, 42);
    XMapWindow(display, polywin[i]);
    elewin[i] = make_button("ele", 88, y + (1 - i) * BUTTONHEIGHT, 33);
    XMapWindow(display, elewin[i]);
    edgewin[i] = make_button("edge", 123, y + (1 - i) * BUTTONHEIGHT, 42);
    XMapWindow(display, edgewin[i]);
    partwin[i] = make_button("part", 167, y + (1 - i) * BUTTONHEIGHT, 42);
    XMapWindow(display, partwin[i]);
    adjwin[i] = make_button("adj", 211, y + (1 - i) * BUTTONHEIGHT, 33);
    XMapWindow(display, adjwin[i]);
    voronoiwin[i] = make_button("voro", 246, y + (1 - i) * BUTTONHEIGHT, 42);
    XMapWindow(display, voronoiwin[i]);
  }
  versionpluswin = make_button("    +", 290, y, 52);
  XMapWindow(display, versionpluswin);
  versionminuswin = make_button("    -", 290, y + BUTTONHEIGHT, 52);
  XMapWindow(display, versionminuswin);

  quitwin = make_button("Quit", 0, y + 2 * BUTTONHEIGHT, 42);
  XMapWindow(display, quitwin);
  leftwin = make_button("<", 44, y + 2 * BUTTONHEIGHT, 14);
  XMapWindow(display, leftwin);
  rightwin = make_button(">", 60, y + 2 * BUTTONHEIGHT, 14);
  XMapWindow(display, rightwin);
  upwin = make_button("^", 76, y + 2 * BUTTONHEIGHT, 14);
  XMapWindow(display, upwin);
  downwin = make_button("v", 92, y + 2 * BUTTONHEIGHT, 14);
  XMapWindow(display, downwin);
  resetwin = make_button("Reset", 108, y + 2 * BUTTONHEIGHT, 52);
  XMapWindow(display, resetwin);
  widthpluswin = make_button("Width+", 162, y + 2 * BUTTONHEIGHT, 61);
  XMapWindow(display, widthpluswin);
  widthminuswin = make_button("-", 225, y + 2 * BUTTONHEIGHT, 14);
  XMapWindow(display, widthminuswin);
  expwin = make_button("Exp", 241, y + 2 * BUTTONHEIGHT, 33);
  XMapWindow(display, expwin);
  exppluswin = make_button("+", 276, y + 2 * BUTTONHEIGHT, 14);
  XMapWindow(display, exppluswin);
  expminuswin = make_button("-", 292, y + 2 * BUTTONHEIGHT, 14);
  XMapWindow(display, expminuswin);
  fillwin = make_button("Fill", 308, y + 2 * BUTTONHEIGHT, 41);
  XMapWindow(display, fillwin);
  pswin = make_button("PS", 351, y + 2 * BUTTONHEIGHT, 24);
  XMapWindow(display, pswin);
  epswin = make_button("EPS", 377, y + 2 * BUTTONHEIGHT, 33);
  XMapWindow(display, epswin);
}

void fill_button(button)
Window button;
{
  int x, y;
  unsigned int w, h, d, b;
  Window rootw;

  XGetGeometry(display, button, &rootw, &x, &y, &w, &h, &d, &b);
  XFillRectangle(display, button, fontgc, 0, 0, w, h);
}

void draw_buttons()
{
  char numberstring[32];
  char buttonstring[6];
  int i;

  for (i = 1; i >= 0; i--) {
    if ((curr