Beispiel #1
0
/*! Set the stored map dimension (rows,sections,columns)
 Only allowed when file is opened in write mode before any data
 is written.  
 Note: the row dimension will be overridden during writing
 \param mfile (CMMFile *)
 \param map_dim (const int *) the map dimension */
void ccp4_cmap_set_dim(CMMFile *mfile, const int *map_dim)
{
  if (ccp4_file_is_write(mfile->stream) && !mfile->data.number) {
    mfile->map_dim[0] = map_dim[0];
    mfile->map_dim[1] = map_dim[1];
    mfile->map_dim[2] = map_dim[2]; 
    mfile->data.section_size = map_dim[0]*map_dim[1]*
      ccp4_file_itemsize(mfile->stream);
    mfile->data.block_size = mfile->data.section_size +
                             mfile->data.header_size;
  }
}
Beispiel #2
0
/*! Set the datamode.
  This is only allowed if the file is opened in write mode, and
  no data has been written.
  \param mfile (CMMFile *)
  \param datamode (unsigned int) major mode of map */
void ccp4_cmap_set_datamode(CMMFile *mfile, unsigned int datamode)
{
  if (ccp4_file_is_write(mfile->stream) && !mfile->data.number && 
      datamode <= 6 && datamode != 5) {
    mfile->data_mode = datamode;
    ccp4_file_setmode(mfile->stream, datamode);
    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;
  }
}
Beispiel #3
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;
}