Exemplo n.º 1
0
void covariance_read_order_nvecs(char *infile, int *order, int *nvecs)
{
  FILE *fp;
  char file_type, asc_or_bin, str[200];
  int i, j;

  if(!(fp = fopen(infile, "rb")))
    fatalerr("covariance_read_order_nvecs", "fopen for reading \
failed", infile);
  for(i = 0; (j = getc(fp)) != '\n'; i++)
    if(j == EOF)
      fatalerr("covariance_read_order_nvecs", "file ends partway \
through description field", infile);
  fgets(str, 200, fp);
  sscanf(str, "%c %c", &file_type, &asc_or_bin);
  if(file_type != PCASYS_COVARIANCE_FILE)
    fatalerr("covariance_read_order_nvecs", "file is not of type \
PCASYS_COVARIANCE_FILE", infile);
  if(asc_or_bin == PCASYS_ASCII_FILE)
    fscanf(fp, "%d %d", order, nvecs);
  else if(asc_or_bin == PCASYS_BINARY_FILE) {
    fread(order, sizeof(int), 1, fp);
    fread(nvecs, sizeof(int), 1, fp);
#ifdef __NBISLE__
    swap_int_bytes(*order);
    swap_int_bytes(*nvecs);
#endif
  }
  else
    fatalerr("covariance_read_order_nvecs", "illegal ascii-or-binary \
code", infile);
  fclose(fp);
}
Exemplo n.º 2
0
void covariance_write(char *outfile, char *desc, const int ascii,
          int order, int nvecs, float *the_floats)
{
  FILE *fp;
  int r, c;
  float *p;
  float *tfloats;

  if(!(fp = fopen(outfile, "wb")))
    fatalerr("covariance_write", "fopen for writing failed", outfile);
  if(strchr(desc, '\n'))
    fatalerr("covariance_write", "description string contains a \
newline", outfile);
  fprintf(fp, "%s\n%c %c\n", desc, PCASYS_COVARIANCE_FILE,
    (ascii ? PCASYS_ASCII_FILE : PCASYS_BINARY_FILE));
  if(ascii) {
    fprintf(fp, "%d %d\n\n", order, nvecs);
    for(r = 0, p = the_floats; r < order; r++) {
      for(c = 0; c < r; c++)
	fprintf(fp, "%14.7e%c", *p++, ((c % 5 < 4) ? ' ' : '\n'));
      fprintf(fp, "%14.7e\n\n", *p++);
    }
  }
  else { /* binary */
#ifdef __NBISLE__
    swap_int_bytes(order);
    swap_int_bytes(nvecs);
#endif

    fwrite(&order, sizeof(int), 1, fp);
    fwrite(&nvecs, sizeof(int), 1, fp);

#ifdef __NBISLE__
    swap_int_bytes(order);
    swap_int_bytes(nvecs);
    swap_float_bytes_vec_cpy(the_floats, (order * (order+1))/2, &tfloats);
    p = the_floats;
    the_floats = tfloats;
#endif

    fwrite(the_floats, sizeof(float), (order * (order + 1)) / 2, fp);

#ifdef __NBISLE__
    free(tfloats);
    the_floats = p;
#endif
  }
  fclose(fp);
}
Exemplo n.º 3
0
/***********************************************************************
************************************************************************
#cat: read_num_pats - Routine opens a binary patterns file, reads, and
#cat:                  returns the number of pattern feature vectors
#cat:                  in the file.

   Input:
      fn           - name of input patterns file
   Return Code:
      Non-negative - number of pattern feature vectors in the file
      Negative     - system error
************************************************************************/
int read_num_pats(char *fn)
{
   FILE  *fp;
   int   n, idum, nPats;

   if ((fp = fopen(fn, "rb")) == (FILE *)NULL){
      fprintf(stderr, "ERROR : read_num_patterns : fopen : %s\n", fn);
      return(-2);
   }

   if ((n = fread(&idum, sizeof(int ), 1, fp)) != 1){
      fprintf(stderr, "ERROR : read_num_patterns : fread : idum1a\n");
      fclose(fp);
      return(-3);
   }

   if ((n = fread(&nPats, sizeof(int ), 1, fp)) != 1){
      fprintf(stderr, "ERROR : read_num_patterns : fread : nPats\n");
      fclose(fp);
      return(-4);
   }

   fclose(fp);

#ifdef __NBISLE__
   swap_int_bytes(nPats);
#endif

   return(nPats);
}
Exemplo n.º 4
0
void classes_read_n(char *infile, int *n)
{
  FILE *fp;
  char file_type, asc_or_bin, str[200];
  int i;

  if(!(fp = fopen(infile, "rb")))
    fatalerr("classes_read_n", "fopen for reading failed", infile);
  while((i = getc(fp)) != '\n')
    if(i == EOF)
      fatalerr("classes_read_n", "file ends partway through \
description field", infile);
  fgets(str, 200, fp);
  sscanf(str, "%c %c", &file_type, &asc_or_bin);
  if(file_type != PCASYS_CLASSES_FILE)
    fatalerr("classes_read_n", "file is not of type \
PCASYS_CLASSES_FILE", infile);
  if(asc_or_bin == PCASYS_ASCII_FILE)
    fscanf(fp, "%d", n);
  else if(asc_or_bin == PCASYS_BINARY_FILE) {
    fread(n, sizeof(int), 1, fp);
#ifdef __NBISLE__
    swap_int_bytes(*n);
#endif
  }
  else
    fatalerr("classes_read_n", "illegal ascii-or-binary code",
      infile);
  fclose(fp);
}
Exemplo n.º 5
0
Arquivo: dataio.c Projeto: E3V3A/JMRTD
int putc_uint(
   unsigned int iint,        /* input unsigned int       */
   unsigned char *odata,     /* output byte buffer       */
   const int oalloc,         /* allocated size of buffer */
   int *olen)                /* filled length of buffer  */
{
   int ret;
   unsigned char *cptr;

#if defined(__i386__) || defined(__x86_64__) || defined(_WIN32)
   swap_int_bytes(iint);
#endif

   cptr = (unsigned char *)(&iint);

   ret = putc_bytes(cptr, sizeof(unsigned int), odata, oalloc, olen);
   if(ret)
      return(ret);

   return(0);
}
Exemplo n.º 6
0
Arquivo: dataio.c Projeto: E3V3A/JMRTD
int getc_uint(
   unsigned int  *oint_dat,  /* pointer to returned unsigned int */
   unsigned char **cbufptr,  /* pointer to next byte in buffer   */
   unsigned char *ebufptr)   /* pointer to end of buffer         */
{
   int ret;
   unsigned int int_dat;
   unsigned char  *cptr;

   cptr = (unsigned char *)(&int_dat);
   ret = getc_bytes(&cptr, sizeof(unsigned int), cbufptr, ebufptr);
   if(ret)
      return(ret);

#if defined(__i386__) || defined(__x86_64__) || defined(_WIN32)
   swap_int_bytes(int_dat);
#endif

   *oint_dat = int_dat;
   return(0);
}
Exemplo n.º 7
0
void classes_write_ind(char *outfile, char *desc, const int ascii, int n,
          unsigned char *the_classes, int ncls, char **long_classnames)
{
  FILE *fp;
  int i;
  unsigned char *ucp;
  int pindex = 1;

  if(!(fp = fopen(outfile, "wb")))
    fatalerr("classes_write", "fopen for writing failed", outfile);
  if(strchr(desc, '\n'))
    fatalerr("classes_write", "description string contains a \
newline", outfile);
  fprintf(fp, "%s\n%c %c\n", desc, PCASYS_CLASSES_FILE,
    (ascii ? PCASYS_ASCII_FILE : PCASYS_BINARY_FILE));
  if(ascii) {
    fprintf(fp, "%d\n", n);
    fprintf(fp, "%d\n", pindex);
    fprintf(fp, "%d\n", ncls);
    for(i = 0; i < ncls; i++)
       fprintf(fp, "%s\n", long_classnames[i]);

    for(i = 0, ucp = the_classes; i < n; i++)
      fprintf(fp, "%d\n", ucp[i]);
  }
  else { /* binary */
#ifdef __NBISLE__
    swap_int_bytes(n);
    swap_int_bytes(pindex);
    swap_int_bytes(ncls);
#endif
    fwrite(&n, sizeof(int), 1, fp);
    fwrite(&pindex, sizeof(int), 1, fp);
    fwrite(&ncls, sizeof(int), 1, fp);
#ifdef __NBISLE__
    swap_int_bytes(n);
    swap_int_bytes(pindex);
    swap_int_bytes(ncls);
#endif
    for(i = 0; i < ncls; i++)
       fwrite(long_classnames[i], sizeof(char), LONG_CLASSNAME_MAXSTRLEN, fp);

    fwrite(the_classes, sizeof(unsigned char), n, fp);
  }
  fclose(fp);
}    
Exemplo n.º 8
0
void covariance_read_old(char *infile, char **desc, int *order,
                     int *nvecs, float **the_floats)
{
  FILE *fp;
  char file_type, asc_or_bin, str[200], *cp, achar;
  int i, j, the_order;
  float *p, *the_floats_yow, *abuf;

  if(!(fp = fopen(infile, "rb"))) {
     fprintf(stderr, "fopen for reading failed %s\n", infile);
     exit(-1);
  }
  for(i = 0; (j = getc(fp)) != '\n'; i++)
    if(j == EOF) {
      fprintf(stderr, "file ends partway through description field %s\n", infile);
      exit(-1);
    }
  if(!(*desc = malloc(i + 1))) {
     fprintf(stderr, "malloc of description buffer failed %s\n", infile);
     exit(-1);
  }
  rewind(fp);
  for(cp = *desc; (achar = getc(fp)) != '\n';)
    *cp++ = achar;
  *cp = 0;
  fgets(str, 200, fp);
  sscanf(str, "%c %c", &file_type, &asc_or_bin);
  if(file_type != PCASYS_COVARIANCE_FILE) {
     fprintf(stderr, "file is not of type PCASYS_COVARIANCE_FILE %s\n", infile);
     exit(-1);
  }
  if(asc_or_bin == PCASYS_ASCII_FILE) {
    fscanf(fp, "%d %d", order, nvecs);
    the_order = *order;
    if(!(*the_floats = (float *)malloc(the_order * the_order *
      sizeof(float)))) {
       fprintf(stderr, "malloc of *the_floats failed %s\n", infile);
       exit(-1);
    }
    the_floats_yow = *the_floats;
    for(j = 0; j < the_order; j++)
      for(i = 0; i <= j; i++)
	fscanf(fp, "%f", the_floats_yow + i * the_order + j);
  }
  else if(asc_or_bin == PCASYS_BINARY_FILE) {
    if(fread(order, sizeof(int), 1, fp) != 1) {
       fprintf(stderr, "Error reading order\n");
       exit(-1);
    }
    if(fread(nvecs, sizeof(int), 1, fp) != 1) {
       fprintf(stderr, "Error reading nvecs\n");
       exit(-1);
    }

#ifdef __NBISLE__
    swap_int_bytes(*order);
    swap_int_bytes(*nvecs);
#endif

    the_order = *order;
    if(!(*the_floats = (float *)malloc(the_order * the_order *
      sizeof(float)))) {
       fprintf(stderr, "malloc of *the_floats failed %s\n", infile);
       exit(-1);
    }
    the_floats_yow = *the_floats;
    if(!(abuf = (float *)malloc(the_order * sizeof(float)))) {
       fprintf(stderr, "malloc of abuf failed %s\n", infile);
       exit(-1);
    }
    for(j = 0; j < the_order; j++) {
      fread(abuf, sizeof(float), j + 1, fp);
      for(i = 0, p = abuf; i <= j; i++) {
#ifdef __NBISLE__
        swap_float_bytes(*p);
#endif
	*(the_floats_yow + i * the_order + j) = *p++;
      }
    }
  }
  else {
     fprintf(stderr, "illegal ascii-or-binary code %s\n", infile);
     exit(-1);
  }
  fclose(fp);
}
Exemplo n.º 9
0
/***********************************************************************
************************************************************************
#cat: read_bin_nnpats - Routine reads feature vectors and their classes
#cat:                   from a file using fast binary io.

   Input:
      ifile       - name of input patterns file
   Output:
      ofeats      - feature vectors read from file
      otargs      - target vectors read from file
      oclasses    - class index read for each feature vector
      oclass_set  - the symbol (string) for each class
      onPats      - number of feature vectors read
      onInps      - length of each feature vector (number of coefs)
      onOuts      - length of each target vector (number of classes)
   Return Code:
      Zero        - successful completion
      Negative    - system error
************************************************************************/
int read_bin_nnpats(char *ifile, float **ofeats, float **otargs,
         int **oclasses, char ***oclass_set,
         int *onPats, int *onInps, int *onOuts)
{

   char **class_set;
   int *classes;
   float *feats, *targs;
   int nPats, nInps, nOuts;
   int nFeats, nTargs, nClass;
   int PINPS, POUTS;

   float *featsptr,  /* temporary pointer to input featss  */
         *targsptr;  /* temporary pointer to class outputs  */
   int   *anintptr;
   FILE  *fp;        /* source input pattern input file  */
   int i, j, k, n;
   int idum, tree, targ_typ, targid;

   if ((fp = fopen(ifile, "rb")) == NULL){
      fprintf(stderr, "ERROR : read_bin_nnpats : fopen : %s\n", ifile);
      return(-2);
   }

   if ((n = fread(&idum, sizeof(int), 1, fp)) != 1){
      fprintf(stderr, "ERROR : read_bin_nnpats : fread : idum1a\n");
      return(-3);
   }

   if ((n = fread(&nPats, sizeof(int), 1, fp)) != 1){
      fprintf(stderr, "ERROR : read_bin_nnpats : fread : nPats\n");
      return(-4);
   }
#ifdef __NBISLE__
   swap_int_bytes(nPats);
#endif

   if ((n = fread(&nInps, sizeof(int), 1, fp)) != 1){
      fprintf(stderr, "ERROR : read_bin_nnpats : fread : nInps\n");
      return(-5);
   }
#ifdef __NBISLE__
   swap_int_bytes(nInps);
#endif

   if ((n = fread(&nOuts, sizeof(int), 1, fp)) != 1){
      fprintf(stderr, "ERROR : read_bin_nnpats : fread : nOuts\n");
      return(-6);
   }
#ifdef __NBISLE__
   swap_int_bytes(nOuts);
#endif

   if ((n = fread(&targ_typ, sizeof(int), 1, fp)) != 1){
      fprintf(stderr, "ERROR : read_bin_nnpats : fread : targ_typ\n");
      return(-7);
   }
#ifdef __NBISLE__
   swap_int_bytes(targ_typ);
#endif

   if ((n = fread(&tree, sizeof(int), 1, fp)) != 1){
      fprintf(stderr, "ERROR : read_bin_nnpats : fread : tree\n");
      return(-8);
   }
#ifdef __NBISLE__
   swap_int_bytes(tree);
#endif

   if ((n = fread(&idum, sizeof(int), 1, fp)) != 1){
      fprintf(stderr, "ERROR : read_bin_nnpats : fread : nPats\n");
      return(-9);
   }

   if ((n = fread(&idum, sizeof(int), 1, fp)) != 1){
      fprintf(stderr, "ERROR : read_bin_nnpats : fread : idum1b\n");
      return(-10);
   }

   if (tree == TREEPATSFILE){
      fprintf(stderr, "ERROR : read_bin_nnpats : ");
      fprintf(stderr, "tree patsfile not supported at this time\n");
      return(-11);
   }

   PINPS = nInps;
   POUTS = nOuts;

   nFeats = nPats * PINPS;
   nTargs = nPats * POUTS;
   nClass = nPats;

   if ((feats = (float *)calloc(nFeats, sizeof(float))) == (float *)NULL){
      fprintf(stderr, "ERROR : read_bin_nnpats : calloc : feats\n");
      return(-12);
   }

   if ((targs = (float *)calloc(nTargs, sizeof(float))) == (float *)NULL){
      fprintf(stderr, "ERROR : read_bin_nnpats : calloc : targs\n");
      return(-13);
   }

   if ((classes = (int *)calloc(nClass, sizeof(int))) == (int *)NULL){
      fprintf(stderr, "ERROR : read_bin_nnpats : calloc : classes\n");
      return(-14);
   }

   if ((class_set = (char **)calloc(nOuts, sizeof(char *))) == (char **)NULL){
      fprintf(stderr, "ERROR : read_bin_nnpats : calloc : class_set\n");
      return(-15);
   }

   if (tree == JUSTPATSFILE){
      if ((n = fread(&idum, sizeof(int), 1, fp)) != 1){
         free(feats);
         free(targs);
         free(classes);
         free(class_set);
         fprintf(stderr, "ERROR : read_bin_nnpats : fread : idum2a\n");
         return(-16);
      }

      for(i = 0; i < nOuts; i++){
         if ((class_set[i] = (char *)calloc(32, sizeof(char))) == NULL){
            free(feats);
            free(targs);
            free(classes);
            free(class_set);
            fprintf(stderr,
            "ERROR : read_bin_nnpats : calloc : class_set[%d]\n", i);
            return(-17);
         }

         if ((n = fread(class_set[i], sizeof(char), 32, fp)) != 32){
            for(k = 0; k < nOuts; k++)
               free(class_set[k]);
            free(feats);
            free(targs);
            free(classes);
            free(class_set);
            fprintf(stderr,
            "ERROR : read_bin_nnpats : fread : class_set[%d]\n", i);
            return(-18);
         }
      }

      if ((n = fread(&idum, sizeof(int), 1, fp)) != 1){
         for(k = 0; k < nOuts; k++)
            free(class_set[k]);
         free(feats);
         free(targs);
         free(classes);
         free(class_set);
         fprintf(stderr,
            "ERROR : read_bin_nnpats : fread : idum2b\n");
         return(-19);
      }

      featsptr = feats;
      targsptr = targs;
      anintptr = classes;

      for (i = 0; i < nPats; i++){
         if ((n = fread(&idum, sizeof(int), 1, fp)) != 1){
            for(k = 0; k < nOuts; k++)
               free(class_set[k]);
            free(feats);
            free(targs);
            free(classes);
            free(class_set);
            fprintf(stderr,
               "ERROR : read_bin_nnpats : fread : idum3a\n");
            return(-20);
         }

         if ((n = fread(featsptr, sizeof(float), nInps, fp)) != nInps){
            for(k = 0; k < nOuts; k++)
               free(class_set[k]);
            free(feats);
            free(targs);
            free(classes);
            free(class_set);
            fprintf(stderr,
               "ERROR : read_bin_nnpats : fread : feature vector\n");
            return(-21);
         }
#ifdef __NBISLE__
         for(j = 0; j < nInps; j++)
            swap_float_bytes(featsptr[j]);
#endif

         featsptr += PINPS;

         if ((n = fread(&idum, sizeof(int), 1, fp)) != 1){
            for(k = 0; k < nOuts; k++)
               free(class_set[k]);
            free(feats);
            free(targs);
            free(classes);
            free(class_set);
            fprintf(stderr,
               "ERROR : read_bin_nnpats : fread : idum3b\n");
            return(-22);
         }

         if ((n = fread(&idum, sizeof(int), 1, fp)) != 1){
            for(k = 0; k < nOuts; k++)
               free(class_set[k]);
            free(feats);
            free(targs);
            free(classes);
            free(class_set);
            fprintf(stderr,
               "ERROR : read_bin_nnpats : fread : idum4a\n");
            return(-23);
         }

         if(targ_typ){
            if ((n = fread(&targid, sizeof(int), 1, fp)) != 1){
               for(k = 0; k < nOuts; k++)
                  free(class_set[k]);
               free(feats);
               free(targs);
               free(classes);
               free(class_set);
               fprintf(stderr,
                  "ERROR : read_bin_nnpats : fread : targid\n");
               return(-24);
            }
#ifdef __NBISLE__
            swap_int_bytes(targid);
#endif

            anintptr[i] = (targid - 1);

            for(j = 0; j < nOuts; j++)
               if(anintptr[i] == j)
                  *targsptr++ = 1.0;
               else
                  *targsptr++ = 0.0;

            targsptr += POUTS - nOuts;
         }
         else {
            if ((n = fread(targsptr, sizeof(float), nOuts, fp)) != nOuts){
               for(k = 0; k < nOuts; k++)
                  free(class_set[k]);
               free(feats);
               free(targs);
               free(classes);
               free(class_set);
               fprintf(stderr,
                  "ERROR : read_bin_nnpats : fread : target vector\n");
               return(-25);
            }
#ifdef __NBISLE__
            for(j = 0; j < nOuts; j++)
               swap_float_bytes(targsptr[j]);
#endif

            targsptr += POUTS;  /* pad to dimension with the */
            /* zeroes returned by calloc */
         }
         if ((n = fread(&idum, sizeof(int), 1, fp)) != 1){
            for(k = 0; k < nOuts; k++)
               free(class_set[k]);
            free(feats);
            free(targs);
            free(classes);
            free(class_set);
            fprintf(stderr,
               "ERROR : read_bin_nnpats : fread : idum4b\n");
            return(-26);
         }
      } /* end for */

      if(!targ_typ){
         targsptr = targs;
         anintptr = classes;

         for(i = 0; i < nPats; i++){ /* obtain from the target list */
            /* the node index (ie class) */
            anintptr[i] = -1;  /* of the node near 1.0  */
            for(j = 0; j < nOuts; j++) {/* 0 0 0 1 0 is class 4 */
               if (*targsptr++ >= 0.99){
                  if (anintptr[i] == -1) /* error: class -1 if no*/
                     anintptr[i] =  j; /* target near 1 is defined */
                  else
                     anintptr[i] = -2; /* error: class is -2 if more */
               }   /* than one target is 1  */
            }
            targsptr += POUTS - nOuts; /* jump over zeroes used to  */
            /* fill dap dimension   */
         }
      }
   }
   /* Otherwise, unrecognized tree type ... */
   else{
      for(k = 0; k < nOuts; k++)
         free(class_set[k]);
      free(feats);
      free(targs);
      free(classes);
      free(class_set);
      fprintf(stderr, "ERROR : read_bin_nnpats : unrecognized tree flag\n");
      return(-27);
   }

   fclose(fp);

   *ofeats = feats;
   *otargs = targs;
   *oclass_set = class_set;
   *oclasses = classes;
   *onPats = nPats;
   *onInps = nInps;
   *onOuts = nOuts;

   return(0);
}
Exemplo n.º 10
0
void classes_read_ind(char *infile, char **desc, int *n,
          unsigned char **the_classes, int *ncls, char ***long_classnames)
{
  FILE *fp;
  char file_type, asc_or_bin, str[200], *cp, achar;
  unsigned char *ucp;
  int i, j, pindex;
  char **lcnptr;

  if(!(fp = fopen(infile, "rb")))
    fatalerr("classes_read_ind", "fopen for reading failed", infile);
  for(i = 0; (j = getc(fp)) != '\n'; i++)
    if(j == EOF)
      fatalerr("classes_read_ind", "file ends partway through \
description field", infile);
  if(!(*desc = malloc(i + 1)))
    fatalerr("classes_read_ind", "malloc of description buffer \
failed", infile);
  rewind(fp);
  for(cp = *desc; (achar = getc(fp)) != '\n';)
    *cp++ = achar;
  *cp = 0;
  fgets(str, 200, fp);
  sscanf(str, "%c %c", &file_type, &asc_or_bin);
  if(file_type != PCASYS_CLASSES_FILE)
    fatalerr("classes_read_ind", "file is not of type \
PCASYS_CLASSES_FILE", infile);
  if(asc_or_bin == PCASYS_ASCII_FILE) {
    fscanf(fp, "%d", n);
    fscanf(fp, "%d", &pindex);
    fscanf(fp, "%d", ncls);
    /* Read the long (full) names of the classes. */
    malloc_dbl_char(&lcnptr, *ncls, LONG_CLASSNAME_MAXSTRLEN + 1,
                    "classes_read_ind long_classnames");
    *long_classnames = lcnptr;
    for(i = 0; i < *ncls; i++)
      fscanf(fp, "%s", lcnptr[i]);

    if(!pindex)
      fatalerr("classes_read_ind","pindex = 0","Need class indices not vectors");
    if(!(*the_classes = (unsigned char *)malloc(*n *
      sizeof(unsigned char))))
      fatalerr("classes_read_ind", "malloc of classes buffer failed",
        infile);
    for(i = 0, ucp = *the_classes; i < *n; i++) {
      fscanf(fp, "%d", &j);
      *ucp++ = j;
    }
  }
  else if(asc_or_bin == PCASYS_BINARY_FILE) {
    fread(n, sizeof(int), 1, fp);
    fread(&pindex, sizeof(int), 1, fp);
    fread(ncls, sizeof(int), 1, fp);
#ifdef __NBISLE__
    swap_int_bytes(*n);
    swap_int_bytes(pindex);
    swap_int_bytes(*ncls);
#endif

    /* Read the long (full) names of the classes. */
    malloc_dbl_char(&lcnptr, *ncls, LONG_CLASSNAME_MAXSTRLEN + 1,
                    "classes_read_ind long_classnames");
    *long_classnames = lcnptr;
    for(i = 0; i < *ncls; i++)
      fread(lcnptr[i], sizeof(char), LONG_CLASSNAME_MAXSTRLEN, fp);

    if(!pindex)
      fatalerr("classes_read_ind","pindex = 0","Need class indices not vectors");

    if(!(*the_classes = (unsigned char *)malloc(*n *
      sizeof(unsigned char))))
      fatalerr("classes_read_ind", "malloc of classes buffer failed",
        infile);
    fread(*the_classes, sizeof(unsigned char), *n, fp);
  }
  else
    fatalerr("classes_read_ind", "illegal ascii-or-binary code", infile);
  fclose(fp);
}