Beispiel #1
0
/*! The file is opened.
 \param filename (char *) the filename
 \param mode (int) the i/o mode , possible values are O_RDONLY, O_WRONLY, 
       O_RDWR, O_APPEND, O_TMP, O_CREAT, O_TRUNC - see ccp4_sysdep.h
 \return (void *) CMMFile structure */
void *ccp4_cmap_open(const char *filename, int mode)
{
  CMMFile *mfile;
  CCP4File *cfile;
  const size_t stamp_offset = 212U;
  
  if ((cfile = ccp4_file_open(filename, mode)) == NULL) {
    ccp4_signal( CCP4_ERRLEVEL(3) | CMAP_ERRNO(CMERR_CantOpenFile),
		 "ccp4_cmap_open",NULL);
    return (NULL); } 
  ccp4_file_raw_setstamp(cfile, stamp_offset);
  /* read or write only */
  if (cfile->read) {
    if (!is_cmap(cfile) || cfile->length < 1025) {
      ccp4_signal( CCP4_ERRLEVEL(3) | CMAP_ERRNO(CMERR_NoHeader),
		 "ccp4_cmap_open",NULL);
      ccp4_file_close(cfile);
      return NULL; }
    ccp4_file_rarch(cfile);
    mfile = init_cmap_read();
    mfile->stream = cfile;
    mfile->file_name = cfile->name;
    parse_mapheader(mfile);
    parse_maplabels(mfile);
  } else if (cfile->write) {
    mfile = init_cmap_write();
    mfile->stream = cfile;
    mfile->file_name = cfile->name;
    write_mapheader(mfile);
    write_maplabels(mfile);
  } else {
    ccp4_signal( CCP4_ERRLEVEL(3) | CMAP_ERRNO(CMERR_CantOpenFile),
		 "ccp4_cmap_open",NULL);
    return (NULL); }
  return (mfile);
}
Beispiel #2
0
/*! Internal: read header from file and fill CMMFile struct.
  Called after file is opened for read.
  \param mfile (CMMFile *)
  \return 1 on success, EOF on failure*/
int parse_mapheader(CMMFile *mfile)
{
  const int read_total = 77;
  const size_t header_size = 1024U, n_byt_symop = 80U;
  unsigned char buffer[224];
  int result;
  float fmean,frms;
  
   ccp4_file_rewind(mfile->stream);

   memset(buffer,'\0',224);
   result = ccp4_file_readint(mfile->stream, &buffer[0], 10) ;
   result += ccp4_file_readfloat(mfile->stream, &buffer[40], 6);
   result += ccp4_file_readint(mfile->stream, &buffer[64], 3);
   result += ccp4_file_readfloat(mfile->stream, &buffer[76], 3);
   result += ccp4_file_readint(mfile->stream, &buffer[88], 3);
   /* skew matrix and translation */
   result += ccp4_file_readfloat(mfile->stream, &buffer[100], 12);
   /* reserved */
   result += ccp4_file_readint(mfile->stream, &buffer[148], 8);
   /* user access */
   result += ccp4_file_readchar(mfile->stream, &buffer[180], 28);
   /* map and machine stamp */
   result += ccp4_file_readint(mfile->stream, &buffer[208], 2);
   /* ARMS */
   result += ccp4_file_readfloat(mfile->stream, &buffer[216], 1);
   result += ccp4_file_readint(mfile->stream, &buffer[220], 1);
   
   if (result != read_total) {
    ccp4_signal( CCP4_ERRLEVEL(3) | CMAP_ERRNO(CMERR_ReadFail),
                 "parse_header",
                 NULL);
    return EOF; }
  
  memcpy(&mfile->map_dim[0],&buffer[0],sizeof(mfile->map_dim));
  memcpy(&mfile->data_mode,&buffer[12],sizeof(int));
  memcpy(&mfile->origin[0],&buffer[16],sizeof(mfile->origin));
  memcpy(&mfile->cell_grid[0],&buffer[28],sizeof(mfile->cell_grid));
  memcpy(&mfile->cell[0],&buffer[40],sizeof(mfile->cell));
  memcpy(&mfile->axes_order[0],&buffer[64],sizeof(mfile->axes_order));
  memcpy(&mfile->stats.min,&buffer[76],sizeof(float));
  memcpy(&mfile->stats.max,&buffer[80],sizeof(float));
  memcpy(&fmean,&buffer[84],sizeof(float));
  mfile->stats.mean = (double) fmean;
  memcpy(&mfile->spacegroup,&buffer[88],sizeof(int));

  /* Additions for EM support.
     Define contents as image, image stack, volume or volume stack.
     In latter case, allows for 400+ispg convention. */
  mfile->EM_spacegroup = mfile->spacegroup;
  strncpy(mfile->EM_contents,"VOLU",4);
  if (mfile->spacegroup > 400 && mfile->spacegroup < 631) {
    mfile->spacegroup = mfile->spacegroup - 400;
    strncpy(mfile->EM_contents,"VLST",4);
  } 
  if (mfile->spacegroup == 0) {
    if (mfile->map_dim[2] == 1) strncpy(mfile->EM_contents,"IMAG",4);
    if (mfile->map_dim[2] > 1) strncpy(mfile->EM_contents,"IMST",4);
  }

  memcpy(&mfile->symop.size,&buffer[92],sizeof(int));
  memcpy(&mfile->user_access,&buffer[180],sizeof(mfile->user_access));
  /* memcpy(&mfile->data.header_size,&buffer[204],sizeof(int)); */
  memcpy(&frms,&buffer[216],sizeof(float));
  mfile->stats.rms = (double) frms;
  memcpy(&mfile->labels.number,&buffer[220],sizeof(int));
  
  memcpy(&result,&buffer[96],sizeof(int));
  if (result !=0) {
    memcpy(&mfile->skew.rotation[0][0],&buffer[100],sizeof(mfile->skew.rotation));
    memcpy(&mfile->skew.translation[0],&buffer[136],sizeof(mfile->skew.translation));
  }
  
  ccp4_file_setmode(mfile->stream, mfile->data_mode);
  /* may go to seperate function */
  mfile->symop.offset = header_size;
  mfile->data.offset = mfile->symop.offset + mfile->symop.size;
  mfile->data.section_size = mfile->map_dim[0]*mfile->map_dim[1]
                             *ccp4_file_itemsize(mfile->stream);
  mfile->data.block_size = mfile->data.section_size + mfile->data.header_size;
  mfile->data.number = mfile->map_dim[2];
  mfile->symop.number = mfile->symop.size / n_byt_symop;
  
  return 1;
}
Beispiel #3
0
/*! Internal: write summary of current CMMFile struct to file.
  Called when file is opened write, and closed write.
  \param mfile (CMMFile *)
  \return 1 on success, EOF on failure */
int write_mapheader(CMMFile *mfile)
{
  const int write_total = 77;
  unsigned char buffer[224];
  int result;
  float fmean,frms;
    
  memset(buffer,'\0',224);
  memcpy(&buffer[0],&mfile->map_dim[0],sizeof(mfile->map_dim));
  memcpy(&buffer[12],&mfile->data_mode,sizeof(int));
  memcpy(&buffer[16],&mfile->origin[0],sizeof(mfile->origin));
  memcpy(&buffer[28],&mfile->cell_grid[0],sizeof(mfile->cell_grid));
  memcpy(&buffer[40],&mfile->cell[0],sizeof(mfile->cell));
  memcpy(&buffer[64],&mfile->axes_order[0],sizeof(mfile->axes_order));
  memcpy(&buffer[76],&mfile->stats.min,sizeof(float));
  memcpy(&buffer[80],&mfile->stats.max,sizeof(float));
  fmean = (float) mfile->stats.mean;
  memcpy(&buffer[84],&fmean,sizeof(float));

  /* additions for EM support */
  if (!strncmp(mfile->EM_contents,"VLST",4)) {
    memcpy(&buffer[88],&mfile->EM_spacegroup,sizeof(int));
  } else {
    memcpy(&buffer[88],&mfile->spacegroup,sizeof(int));
  }

  memcpy(&buffer[92],&mfile->symop.size,sizeof(int));
  memcpy(&buffer[180],&mfile->user_access,sizeof(mfile->user_access));
  /* memcpy(&buffer[204],&mfile->data.header_size,sizeof(int)); */
  memcpy(&buffer[208],"MAP ",4U);
  frms = (float) mfile->stats.rms;
  memcpy(&buffer[216],&frms,sizeof(float));
  memcpy(&buffer[220],&mfile->labels.number,sizeof(int));
  
  if (skew_set(&mfile->skew) == TRUE) {
    result = 1;
    memcpy(&buffer[96],&result, sizeof(int));
    memcpy(&buffer[100],&mfile->skew.rotation[0][0],sizeof(mfile->skew.rotation));
    memcpy(&buffer[148],&mfile->skew.translation[0],sizeof(mfile->skew.translation));
  }

   ccp4_file_seek(mfile->stream, 0L, SEEK_SET);
    
   result = ccp4_file_writeint(mfile->stream, &buffer[0], 10);
   result += ccp4_file_writefloat(mfile->stream, &buffer[40], 6);
   result += ccp4_file_writeint(mfile->stream, &buffer[64], 3);
   result += ccp4_file_writefloat(mfile->stream, &buffer[76], 3);
   result += ccp4_file_writeint(mfile->stream, &buffer[88], 3);
   result += ccp4_file_writefloat(mfile->stream, &buffer[100], 12);
   result += ccp4_file_writeint(mfile->stream, &buffer[148], 8);
   result += ccp4_file_writechar(mfile->stream, &buffer[180], 28);
   result += ccp4_file_writeint(mfile->stream, &buffer[208], 2);
   result += ccp4_file_writefloat(mfile->stream, &buffer[216], 1);
   result += ccp4_file_writeint(mfile->stream, &buffer[220], 1);
   
   if (result != write_total)
    ccp4_signal( CCP4_ERRLEVEL(3) | CMAP_ERRNO(CMERR_WriteFail),
                 "write_header",
                 NULL);

  return ( (result == write_total) ? 1 : EOF);
}