/* setData */
PyObject *
Image_setData(PyObject *obj, PyObject *args, PyObject *kwargs)
{
ImageObject *self = (ImageObject*) obj;
PyArrayObject * arr = NULL;
if (self != NULL && PyArg_ParseTuple(args, "O", &arr))
{
try
{
ImageGeneric & image = Image_Value(self);
DataType dt = npyType2Datatype(PyArray_TYPE(arr));
int nd = PyArray_NDIM(arr);
//Setup of image
image.setDatatype(dt);
ArrayDim adim;
adim.ndim = (nd == 4 ) ? PyArray_DIM(arr, 0) : 1;
adim.zdim = (nd > 2 ) ? PyArray_DIM(arr, nd - 3) : 1;
adim.ydim = PyArray_DIM(arr, nd - 2);
adim.xdim = PyArray_DIM(arr, nd - 1);
MULTIDIM_ARRAY_GENERIC(image).resize(adim, false);
void *mymem = image().getArrayPointer();
void * data = PyArray_DATA(arr);
memcpy(mymem, data, adim.nzyxdim * gettypesize(dt));
Py_RETURN_NONE;
}
catch (XmippError &xe)
{
PyErr_SetString(PyXmippError, xe.msg.c_str());
}
}
return NULL;
}//function Image_setData
void WriteStep(char *file,long wtype, Plasma &Gas, long step){
FILE *f1;
# ifndef UNIX
f1=_fdopen(_open(file,O_BINARY|O_WRONLY),"wb");
# else
f1=fdopen(open(file,O_WRONLY),"wb");
# endif
if(!f1)serror("Can't reopen file %s",file);
long dsz=gettypesize(wtype,Gas.n);
fseek(f1,400+dsz*step,SEEK_SET);
long pos=ftell(f1);
if(pos!=400+dsz*step)printf("fseek failed!\n");
ref_type=wtype|(VEL|COORD);
new_trj=f1;
anx=Gas.x;
anv=Gas.v;
npart=Gas.n;
Refine_step();
fclose(f1);
}
bool checkImageFileSize(const FileName &name, const ImageInfo &imgInfo, bool error)
{
FileName ext = name.getExtension();
FileName dataFname;
if ( ext.contains("hed"))
dataFname = name.removeLastExtension().addExtension("img");
else if (ext.contains("inf"))
dataFname = name.removeLastExtension();
else if (ext.contains("tif") || ext.contains("jpg") || ext.contains("hdf") || ext.contains("h5"))
return true;
else
dataFname = name;
size_t expectedSize = imgInfo.adim.nzyxdim*gettypesize(imgInfo.datatype) + imgInfo.offset;
size_t actualSize = dataFname.removeAllPrefixes().removeFileFormat().getFileSize();
bool result = (actualSize >= expectedSize);
if (error && !result)
REPORT_ERROR(ERR_IO_SIZE, formatString("Image Extension: File %s has wrong size.\n"
"Expected size (at least) %u bytes. Actual size %u bytes.", name.c_str(), expectedSize, actualSize));
return result;
}
/* getData */
PyObject *
Image_getData(PyObject *obj, PyObject *args, PyObject *kwargs)
{
ImageObject *self = (ImageObject*) obj;
if (self != NULL)
{
try
{
ArrayDim adim;
ImageGeneric & image = Image_Value(self);
DataType dt = image.getDatatype();
int nd = image.image->mdaBase->getDim();
MULTIDIM_ARRAY_GENERIC(image).getDimensions(adim);
npy_intp dims[4];
dims[0] = adim.ndim;
dims[1] = adim.zdim;
dims[2] = adim.ydim;
dims[3] = adim.xdim;
//Get the pointer to data
void *mymem = image().getArrayPointer();
NPY_TYPES type = datatype2NpyType(dt);
//dims pointer is shifted if ndim or zdim are 1
PyArrayObject * arr = (PyArrayObject*) PyArray_SimpleNew(nd, dims+4-nd, type);
void * data = PyArray_DATA(arr);
memcpy(data, mymem, adim.nzyxdim * gettypesize(dt));
return (PyObject*)arr;
}
catch (XmippError &xe)
{
PyErr_SetString(PyXmippError, xe.msg.c_str());
}
}
return NULL;
}//function Image_getData
/** Imagic Writer
* @ingroup Imagic
*/
int ImageBase::writeIMAGIC(size_t select_img, int mode, const String &bitDepth, CastWriteMode castMode)
{
#undef DEBUG
//#define DEBUG
#ifdef DEBUG
printf("DEBUG writeIMAGIC: Reading Imagic file\n");
#endif
IMAGIChead header;
// Cast T to datatype without convert data
DataType wDType, myTypeID = myT();
if (bitDepth == "")
{
switch(myTypeID)
{
case DT_Double:
case DT_Float:
case DT_Int:
case DT_UInt:
wDType = DT_Float;
strncpy(header.type,"REAL", sizeof(header.type));
break;
case DT_UShort:
castMode = CW_CONVERT;
/* no break */
case DT_Short:
wDType = DT_Short;
strncpy(header.type,"INTG", sizeof(header.type));
break;
case DT_SChar:
castMode = CW_CONVERT;
/* no break */
case DT_UChar:
wDType = DT_UChar;
strncpy(header.type,"PACK", sizeof(header.type));
break;
case DT_CFloat:
case DT_CDouble:
wDType = DT_CFloat;
strncpy(header.type,"COMP", sizeof(header.type));
break;
default:
wDType = DT_Unknown;
REPORT_ERROR(ERR_TYPE_INCORRECT, "ERROR: Unsupported data type by IMAGIC format.");
}
}
else //Convert to other data type
{
// Default Value
wDType = (bitDepth == "default") ? DT_Float : datatypeRAW(bitDepth);
switch (wDType)
{
case DT_UChar:
strncpy(header.type,"PACK", sizeof(header.type));
break;
case DT_Short:
strncpy(header.type,"INTG", sizeof(header.type));
break;
case DT_Float:
(strncpy)(header.type,"REAL", sizeof(header.type));
break;
case DT_CFloat:
strncpy(header.type,"COMP", sizeof(header.type));
break;
default:
REPORT_ERROR(ERR_TYPE_INCORRECT,"ERROR: incorrect IMAGIC bits depth value.");
}
}
if (mmapOnWrite)
{
MDMainHeader.setValue(MDL_DATATYPE,(int) wDType);
if (!checkMmapT(wDType))
{
if (dataMode < DATA && castMode == CW_CAST) // This means ImageGeneric wants to know which DataType must use in mapFile2Write
return 0;
else //Mapping is an extra. When not available, go on and do not report an error.
{
/* In this case we cannot map the file because required and feasible datatypes are
* not compatible. Then we denote to MapFile2Write the same incoming datatype to
* keep using this Image object as usual, without mapping on write.
*/
mmapOnWrite = false;
dataMode = DATA;
MDMainHeader.setValue(MDL_DATATYPE,(int) myTypeID);
// In case Image size great then, at least, map the multidimarray
if (mdaBase->nzyxdim*gettypesize(myTypeID) > tiff_map_min_size)
mdaBase->setMmap(true);
// Allocate memory for image data (Assume xdim, ydim, zdim and ndim are already set
//if memory already allocated use it (no resize allowed)
mdaBase->coreAllocateReuse();
return 0;
}
}
else
dataMode = DATA;
}
size_t Xdim, Ydim, Zdim, Ndim;
getDimensions(Xdim, Ydim, Zdim, Ndim);
if (Zdim > 1)
REPORT_ERROR(ERR_MULTIDIM_DIM, "writeIMAGIC: Imagic format does not support volumes.");
size_t datasize, datasize_n;
datasize_n = (size_t)Xdim*Ydim*Zdim;
datasize = datasize_n * gettypesize(wDType);
// fill in the file header
header.nhfr = 1;
header.npix2 = Xdim*Ydim;
header.npixel = header.npix2;
header.iylp = Xdim;
header.ixlp = Ydim;
time_t timer;
time ( &timer );
tm* t = localtime(&timer);
header.ndate = t->tm_mday;
header.nmonth = t->tm_mon + 1;
header.nyear = t->tm_year;
header.nhour = t->tm_hour;
header.nminut = t->tm_min;
header.nsec = t->tm_sec;
double aux;
if (!MDMainHeader.empty())
{
#define SET_MAIN_HEADER_VALUE(field, label) MDMainHeader.getValueOrDefault(label, aux, 0.); header.field = (float)aux
SET_MAIN_HEADER_VALUE(densmin, MDL_MIN);
SET_MAIN_HEADER_VALUE(densmax, MDL_MAX);
SET_MAIN_HEADER_VALUE(avdens, MDL_AVG);
SET_MAIN_HEADER_VALUE(sigma, MDL_STDDEV);
header.varian = header.sigma*header.sigma;
}
memcpy(header.lastpr, "Xmipp", 5);
memcpy(header.name, filename.c_str(), 80);
size_t imgStart = IMG_INDEX(select_img);
header.ifn = replaceNsize - 1 ;
header.imn = 1;
if ( mode == WRITE_APPEND )
{
imgStart = replaceNsize;
header.ifn = replaceNsize + Ndim - 1 ;
}
else if( mode == WRITE_REPLACE && imgStart + Ndim > replaceNsize)
header.ifn = imgStart + Ndim - 1;
else if (Ndim > replaceNsize)
header.ifn = Ndim - 1;
/*
* BLOCK HEADER IF NEEDED
*/
FileLock flockHead, flockImg;
flockHead.lock(fhed);
flockImg.lock(fimg);
if (replaceNsize == 0) // Header written first time
{
if ( swapWrite )
{
IMAGIChead headTemp = header;
swapPage((char *) &headTemp, IMAGICSIZE - 916, DT_Float);
fwrite( &headTemp, IMAGICSIZE, 1, fhed );
}
fwrite( &header, IMAGICSIZE, 1, fhed );
}
else if( header.ifn + 1 > (int)replaceNsize && imgStart > 0 ) // Update number of images when needed
{
fseek( fhed, sizeof(int), SEEK_SET);
if ( swapWrite )
{
int ifnswp = header.ifn;
swapPage((char *) &ifnswp, SIZEOF_INT, DT_Int);
fwrite(&(ifnswp),SIZEOF_INT,1,fhed);
}
else
fwrite(&(header.ifn),SIZEOF_INT,1,fhed);
}
// Jump to the selected imgStart position
fseek(fimg, datasize * imgStart, SEEK_SET);
fseek(fhed, IMAGICSIZE * imgStart, SEEK_SET);
std::vector<MDRow>::iterator it = MD.begin();
for (size_t i = 0; i < Ndim; ++i, ++it)
{
header.iyold=header.ixold=0;
header.euler_alpha=header.euler_beta=header.euler_gamma=0.;
// Write the individual image header
if (it != MD.end() && (dataMode == _HEADER_ALL || dataMode == _DATA_ALL))
{
#define SET_HEADER_VALUEInt(field, label) it->getValueOrDefault((label), (aux), 0); header.field = -(int)(aux)
#define SET_HEADER_VALUEDouble(field, label) it->getValueOrDefault((label), (aux), 0.); header.field = -(float)(aux)
SET_HEADER_VALUEInt(ixold, MDL_SHIFT_X);
SET_HEADER_VALUEInt(iyold, MDL_SHIFT_Y);
SET_HEADER_VALUEDouble(euler_alpha, MDL_ANGLE_ROT);
SET_HEADER_VALUEDouble(euler_beta, MDL_ANGLE_TILT);
SET_HEADER_VALUEDouble(euler_gamma, MDL_ANGLE_PSI);
}
// Update index number of image
header.imn = imgStart + i + 1;
if ( swapWrite )
swapPage((char *) &header, IMAGICSIZE - 916, DT_Float);
fwrite( &header, IMAGICSIZE, 1, fhed );
if (dataMode >= DATA)
{
if (mmapOnWrite && Ndim == 1) // Can map one image at a time only
{
mappedOffset = ftell(fimg);
mappedSize = mappedOffset + datasize;
fseek(fimg, datasize-1, SEEK_CUR);
fputc(0, fimg);
}
else
writeData(fimg, i*datasize_n, wDType, datasize_n, castMode);
}
else
fseek(fimg, datasize, SEEK_CUR);
}
//Unlock
flockHead.unlock();
flockImg.unlock();
if (mmapOnWrite)
mmapFile();
return(0);
}
int ImageBase::readHDF5(size_t select_img)
{
bool isStack = false;
H5infoProvider provider = getProvider(fhdf5); // Provider name
int errCode = 0;
hid_t dataset; /* Dataset and datatype identifiers */
hid_t filespace;
hsize_t dims[4]; // We are not going to support more than 4 dimensions, at this moment.
hsize_t nobjEman;
hid_t cparms;
int rank;
String dsname = filename.getBlockName();
// Setting default dataset name
if (dsname.empty())
{
dsname = provider.second;
switch (provider.first)
{
case EMAN: // Images in stack are stored in separated groups
hid_t grpid;
grpid = H5Gopen(fhdf5,"/MDF/images/", H5P_DEFAULT);
/*herr_t err = */
H5Gget_num_objs(grpid, &nobjEman);
dsname = formatString(dsname.c_str(), IMG_INDEX(select_img));
H5Gclose(grpid);
break;
default:
break;
}
}
else
{
switch (provider.first)
{
case EMAN: // Images in stack are stored in separated groups
nobjEman=1;
break;
default:
break;
}
}
dataset = H5Dopen2(fhdf5, dsname.c_str(), H5P_DEFAULT);
if( dataset < 0)
REPORT_ERROR(ERR_IO_NOTEXIST, formatString("readHDF5: Dataset '%s' not found",dsname.c_str()));
cparms = H5Dget_create_plist(dataset); /* Get properties handle first. */
// Get dataset rank and dimension.
filespace = H5Dget_space(dataset); /* Get filespace handle first. */
// rank = H5Sget_simple_extent_ndims(filespace);
rank = H5Sget_simple_extent_dims(filespace, dims, NULL);
// Offset only set when it is possible to access to data directly
offset = (H5D_CONTIGUOUS == H5Pget_layout(cparms))? H5Dget_offset(dataset) : 0;
// status = H5Dread(dataset, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, bm_out);
hid_t h5datatype = H5Dget_type(dataset);
// Reading byte order
switch(H5Tget_order(h5datatype))
{
case H5T_ORDER_ERROR:
REPORT_ERROR(ERR_IO, "readHDF5: error reading endianness.");
break;
case H5T_ORDER_LE:
swap = IsBigEndian();
break;
case H5T_ORDER_BE:
swap = IsLittleEndian();
break;
default:
REPORT_ERROR(ERR_IO, "readHDF5: unknown endianness type, maybe mixed types.");
break;
}
DataType datatype = datatypeH5(h5datatype);
MDMainHeader.setValue(MDL_DATATYPE,(int) datatype);
// Setting isStack depending on provider
switch (provider.first)
{
case MISTRAL: // rank 3 arrays are stacks
isStack = true;
break;
// case EMAN: // Images in stack are stored in separated groups
default:
break;
}
ArrayDim aDim;
size_t nDimFile;
aDim.xdim = dims[rank-1];
aDim.ydim = (rank>1)?dims[rank-2]:1;
aDim.zdim = (rank>3 || (rank==3 && !isStack))?dims[rank-3]:1;
if ( provider.first == EMAN )
nDimFile = nobjEman;
else
nDimFile = ( rank<3 || !isStack )?1:dims[0] ;
if (select_img > nDimFile)
REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS, formatString("readHDF5 (%s): Image number %lu exceeds stack size %lu", filename.c_str(), select_img, nDimFile));
aDim.ndim = replaceNsize = (select_img == ALL_IMAGES)? nDimFile :1 ;
setDimensions(aDim);
//Read header only
if(dataMode == HEADER || (dataMode == _HEADER_ALL && aDim.ndim > 1))
return errCode;
// EMAN stores each image in a separate dataset
if ( provider.first == EMAN )
select_img = 1;
size_t imgStart = IMG_INDEX(select_img);
size_t imgEnd = (select_img != ALL_IMAGES) ? imgStart + 1 : aDim.ndim;
MD.clear();
MD.resize(imgEnd - imgStart,MDL::emptyHeader);
if (dataMode < DATA) // Don't read data if not necessary but read the header
return errCode;
if ( H5Pget_layout(cparms) == H5D_CONTIGUOUS ) //We can read it directly
readData(fimg, select_img, datatype, 0);
else // We read it by hyperslabs
{
// Allocate memory for image data (Assume xdim, ydim, zdim and ndim are already set
//if memory already allocated use it (no resize allowed)
mdaBase->coreAllocateReuse();
hid_t memspace;
hsize_t offset[4]; // Hyperslab offset in the file
hsize_t count[4]; // Size of the hyperslab in the file
// Define the offset and count of the hyperslab to be read.
switch (rank)
{
case 4:
count[0] = 1;
case 3:
// if (stack)
count[rank-3] = aDim.zdim;
offset[rank-2] = 0;
case 2:
count[rank-2] = aDim.ydim;
offset[rank-2] = 0;
break;
}
count[rank-1] = aDim.xdim;
offset[rank-1] = 0;
aDim.xdim = dims[rank-1];
aDim.ydim = (rank>1)?dims[rank-2]:1;
aDim.zdim = (rank == 4)?dims[1]:1;
// size_t nDimFile = (rank>2)?dims[0]:1 ;
// Define the memory space to read a hyperslab.
memspace = H5Screate_simple(rank,count,NULL);
size_t data = (size_t) this->mdaBase->getArrayPointer();
size_t pad = aDim.zyxdim*gettypesize(myT());
for (size_t idx = imgStart, imN = 0; idx < imgEnd; ++idx, ++imN)
{
// Set the offset of the hyperslab to be read
offset[0] = idx;
if ( H5Sselect_hyperslab(filespace, H5S_SELECT_SET, offset, NULL,
count, NULL) < 0 )
REPORT_ERROR(ERR_IO_NOREAD, formatString("readHDF5: Error selecting hyperslab %d from filename %s",
imgStart, filename.c_str()));
// movePointerTo(ALL_SLICES,imN);
// Read
if ( H5Dread(dataset, H5Datatype(myT()), memspace, filespace,
H5P_DEFAULT, (void*)(data + pad*imN)) < 0 )
REPORT_ERROR(ERR_IO_NOREAD,formatString("readHDF5: Error reading hyperslab %d from filename %s",
imgStart, filename.c_str()));
}
H5Sclose(memspace);
}
H5Pclose(cparms);
H5Sclose(filespace);
H5Dclose(dataset);
return errCode;
}
