pattern.c

来自「细胞自动机的一个源代码」· C语言 代码 · 共 289 行

#include "main.h"


/* like pat_free, except keep pat memory area and deallocate rest */
void pat_reset(pat_t *pat) {
  int i, j;

  if (pat) {
    if (pat->d) free(pat->d);
    if (pat->p) free(pat->p);
    if (pat->pos) free(pat->pos);
    if (pat->name) free(pat->name);
    if (pat->orig) free(pat->orig);
  }

  memset(pat, 0, sizeof(pat_t));

}

/* allocate some memory areas needed for pattern.
   doesn't initialize name area
*/
void pat_init(pat_t *pat, int *p, int *pos, int *d, int dim) {
  int i, j, k;

  pat->dim = dim;

  if (pat->d) free(pat->d);
  pat->d = (int *)malloc(sizeof(int)*dim);

  if (pat->pos) free(pat->pos);
  pat->pos = (int *)malloc(sizeof(int)*dim);

  j = 1;
  for (i=0; i<dim; i++) {
    j *= d[i];
  }
  pat->fd = j;

  if (pat->p) free(pat->p);
  pat->p = (int *)malloc(sizeof(int)*j);
  pat->orig = (int *)malloc(sizeof(int)*j);

  memcpy(pat->p, p, sizeof(int)*j);
  memcpy(pat->d, d, sizeof(int)*dim);
  memcpy(pat->pos, pos, sizeof(int)*dim);

}

/* free pattern */
void pat_free(pat_t *pat) {
  if (pat) {
    if (pat->d) free(pat->d);
    if (pat->p) free(pat->p);
    if (pat->pos) free(pat->pos);
    if (pat->orig) free(pat->orig);
    if (pat->name) free(pat->name);
    free(pat);
  }
}


/* given a point vector p, return position in flat
   memory array */
int pat_point(pat_t *pat, int *p) {
  int i, run=1, n=0;

  for (i=0; i<pat->dim; i++) {
    n += run*p[i];
    run *= pat->d[i];
  }
  return(n);

}

/* given flat point p in memory array, return vector
   into dest */
int pat_vec(pat_t *pat, int *dest, int p) {
  static int *d = NULL, *run = NULL, dim = 0;
  int i, j, k;

  if (dim!=(pat->dim)) {
    if (d) free(d);
    d = (int *)malloc(sizeof(int)*(pat->dim));
    if (run) free(run);
    run = (int *)malloc(sizeof(int)*(pat->dim));
    dim = pat->dim;
  }

  run[0] = 1;
  for (i=0; i<(dim-1); i++) {
    run[i+1] = pat->d[i]*run[i];
  }

  for (i=(dim-1); i>=0; i--) {
    dest[i] = p/run[i];
    p -= (p/run[i])*run[i];
  }
}  


/* debuggin */
void pat_print(pat_t *pat) {
  int i, j, k;

  printf("dim: %i\n", pat->dim);
  printf("name: '%s' (%i)\n", pat->name ? pat->name : "", pat->iname);
  printf("on: %i\n", pat->on);

  printf("pos: (");
  for (i=0; i<pat->dim; i++) {
    printf("%i ", pat->pos[i]);
  }
  printf(")\n");

  printf("d: (");
  for (i=0; i<pat->dim; i++) {
    printf("%i ", pat->d[i]);
  }
  printf(")\n");

  printf("fd: %i\n", pat->fd);
  printf("pattern: ");
  for (i=0; i<pat->fd; i++) {
    printf("%i ", pat->p[i]);
  }
  printf("\n");

  printf("orig: ");
  for (i=0; i<pat->fd; i++) {
    printf("%i ", pat->orig[i]);
  }
  printf("\n");

}

/* open gl code to display to screen */
void pat_display(pat_t *pat, ca_t *ca) {
  int i, j, k;
  int ip, *p, *one;
  int l;

  p = (int *)malloc(sizeof(int)*pat->dim);

  for (i=0; i<pat->fd; i++) {
    pat_vec(pat, p, i);
    for (j=0; j<pat->dim; j++) {
      p[j] += pat->pos[j];
    }

    glPushMatrix();

    for (j=0; j<(pat->dim); j++) {
      glTranslatef(((float)p[j])*(ca->b[j][0]),
		   ((float)p[j])*(ca->b[j][1]),
		   ((float)p[j])*(ca->b[j][2]));
    }
      
    glColor3f(0.0, 0.5, 0.0);
    glutWireCube(0.7);

    /*
    if (pat->p[i]) {
      l = pat->p[i];
      if (g_dl->dl[l]) {
        glCallList(g_dl->dl[l]);
      }
    }
    */

    //glCallList(g_dl->dl[l]);
    //printf("display list: %i (%i)\n", g_dl->dl[k], k);
    //printf("glerror? %s\n", gluErrorString(glGetError()));

    glPopMatrix();

  }  

  free(p);

}

/* save memory area that we are overwritting in the
   ca (we write the pattern when positioning the pattern,
   but need to save a copy of the underlying ca covered
   by the pattern in case we cancel the pattern put). */
void pat_orig_get(pat_t *pat, ca_t *ca) {
  int i, j, k;
  int *p;

  p = (int *)malloc(sizeof(int)*pat->fd);
  for (i=0; i<pat->fd; i++) {
    pat_vec(pat, p, i);
    for (j=0; j<pat->dim; j++) {
      p[j] += pat->pos[j];
    }
    k = ca_point(ca, p);
    pat->orig[i] = ca->ca[ca->cur][k];
  }
  free(p);

}

/* put the saved ca memory area back into the ca from
   the pattern */
void pat_orig_put(pat_t *pat, ca_t *ca) {
  int i, j, k;
  int *p;

  p = (int *)malloc(sizeof(int)*pat->fd);
  for (i=0; i<pat->fd; i++) {
    pat_vec(pat, p, i);
    for (j=0; j<pat->dim; j++) {
      p[j] += pat->pos[j];
    }
    k = ca_point(ca, p);
    ca->ca[ca->cur][k] = pat->orig[i];
  }
  free(p);

}

/* put the pattern onto the memory area */
void pat_ca_put(pat_t *pat, ca_t *ca) {
  int i, j, k;
  int *p;

  p = (int *)malloc(sizeof(int)*pat->fd);
  for (i=0; i<pat->fd; i++) {
    pat_vec(pat, p, i);
    for (j=0; j<pat->dim; j++) {
      p[j] += pat->pos[j];
    }
    k = ca_point(ca, p);
    ca->ca[ca->cur][k] = pat->p[i];
  }
  free(p);

}

/* load pattern from file */
int pat_load_file(pat_t *pat, FILE *fp) {
  char line[CA_MAX_LINE];
  char *c;
  int i, j, k;
  int *p_p, *p_pos, *p_d;
  int dim;
  int fd;

  c = ca_readcfgl(line, fp);
  if (atoi(c)!=CA_PATTERN_FILE_TOKEN) {
    printf("not a pattern file???\n");
    return(-1);
  }

  c = ca_readcfgl(line, fp);
  pat->name = strdup(c);

  c = ca_readcfgl(line, fp);
  dim = atoi(c);

  p_pos = (int *)malloc(sizeof(int)*dim);
  p_d = (int *)malloc(sizeof(int)*dim);

  fd = 1;
  c = ca_readcfgl(line, fp);
  for (i=0; i<dim; i++) {
    p_d[i] = atoi(c);
    c = strchr(c+1, ' ');
    fd *= p_d[i];
  }

  p_p = (int *)malloc(sizeof(int)*fd);
  c = ca_readcfgl(line, fp);
  for (i=0; i<fd; i++) {
    p_p[i] = atoi(c);
    c = strchr(c+1, ' ');
  }

  pat_init(pat, p_p, p_pos, p_d, dim);

  free(p_p);
  free(p_pos);
  free(p_d);

  return(0);

}