static void writeInt( gzFile file, int value )
{
int32_t v = value;
uint8_t* bytes = reinterpret_cast<uint8_t*>( &v );
if ( !bigEndian() )
reverse( bytes, bytes+sizeof(v) );
gzwrite( file, bytes, sizeof(int32_t) );
}
static int readInt( gzFile file )
{
int32_t v = 0;
uint8_t* bytes = reinterpret_cast<uint8_t*>( &v );
gzread( file, bytes, sizeof(int32_t) );
if ( !bigEndian() )
reverse( bytes, bytes+sizeof(v) );
return v;
}
int readRAWIVHeader( int *xDim, int *yDim, int *zDim, double *xCenter, double *yCenter, double *zCenter, double *scale, char *fileName )
{
FILE *fp;
if ( ( fp = fopen( fileName, "rb" ) ) == NULL )
{
fprintf( stderr, "\nError: Failed to open file %s!\n\n", fileName );
return 0;
}
RAWIVHeader header;
if ( fread( &header, sizeof( header ), 1, fp ) != 1 )
{
fprintf( stderr, "\nError: Failed to read header from file %s!\n\n", fileName );
fclose( fp );
return 0;
}
if ( !bigEndian( ) )
{
for ( int i = 0; i < 3; i++ )
{
SWAP_32( &( header.minExt[ i ] ) );
SWAP_32( &( header.maxExt[ i ] ) );
SWAP_32( &( header.dim[ i ] ) );
SWAP_32( &( header.origin[ i ] ) );
SWAP_32( &( header.span[ i ] ) );
}
SWAP_32( &( header.numVertices ) );
SWAP_32( &( header.numCells ) );
}
*xCenter = ( header.minExt[ 0 ] + header.maxExt[ 0 ] ) / 2.0;
*yCenter = ( header.minExt[ 1 ] + header.maxExt[ 1 ] ) / 2.0;
*zCenter = ( header.minExt[ 2 ] + header.maxExt[ 2 ] ) / 2.0;
float gridLength1D = header.maxExt[ 0 ] - header.minExt[ 0 ];
*scale = 1.0 / gridLength1D;
*xDim = header.dim[ 0 ];
*yDim = header.dim[ 1 ];
*zDim = header.dim[ 2 ];
fclose( fp );
return 1;
}
uint64_t getBitField(uint64_t data, int startBit, int numBits) {
int startByte = startingByte(startBit);
int endByte = endingByte(startBit, numBits);
uint64_t dataCopy = data;
if(bigEndian()) {
dataCopy = __builtin_bswap64(data);
}
uint8_t* bytes = (uint8_t*)&dataCopy;
uint64_t ret = bytes[startByte];
//debugNoNewline("Reading CAN message, data = 0x");
int i=0;
//while(i < 8) {
// debugNoNewline("%02x ", bytes[i]);
// i++;
//}
//debugNoNewline("\r\n");
uint8_t isLittleEndian = 0;
if(startByte != endByte) {
if(!isLittleEndian) {
// The lowest byte address contains the most significant bit.
for(i = startByte + 1; i <= endByte; i++) {
ret = ret << 8;
ret = ret | bytes[i];
}
} else {
// do something here for little endian?
}
}
ret >>= 8 - findEndBit(startBit, numBits);
ret = ret & bitmask(numBits);
return ret;
}
void ViewReadLinetree3::checkKey(){
if(__open){
if(!getLigFile().isEmpty() && QFile::exists(getLigFile())){
QFile f (getLigFile());
if(f.open(IO_ReadOnly) ) {
QDataStream stream(&f);
if(bigEndian())stream.setByteOrder(QDataStream::BigEndian);
else stream.setByteOrder(QDataStream::LittleEndian);
char t[81];
stream.readRawBytes(t,80);
t[80] = '\0';
QString key = t;
editKey->setText( key );
if(key == PGL(LinetreePrinter)::PROTECTION.c_str()){
labelKey->setText("Key : [AMAPmod]");
}
else {
labelKey->setText("Key : ");
}
f.close();
}
}
else {
editKey->setText("");
labelKey->setText("Key : ");
}
}
else {
if(editKey->text() == PGL(LinetreePrinter)::PROTECTION.c_str()){
labelKey->setText("Key : [AMAPmod]");
}
else {
labelKey->setText("Key : ");
}
}
}
static void OME_EndElement(ParserState *state, const xmlChar *name) {
/* We're at the end of an element. If the element had content, then we
/ need to print "</[elementName]>". If the element did not have
/ content, then we need to print "/>". I'm using a stack to keep track
/ of element's content, so I gotta check the stack and do stack
/ maintence.
/ Iff we are ending a BinData section, then we don't have to touch the
/ stack.
*/
StructElementInfo *elementInfo;
size_t nPix;
OID ImageServerID;
switch( state->state ) {
/**************************************************************************
*
* Process <BinData>
* write <BinData> contents to file & replace <BinData> with an
* <External> that points to the file
*/
case IN_BINDATA:
state->state = PARSER_START;
/* cleanup */
b64z_decode_end ( state->binDataInfo->strm );
free( state->binDataInfo->strm );
state->binDataInfo->strm = NULL;
if( state->binDataInfo->compression ) free( state->binDataInfo->compression );
state->binDataInfo->compression = NULL;
fclose( state->binDataInfo->BinDataOut );
state->binDataInfo->BinDataOut = NULL;
/* omeis transition: replace href with file id
fprintf( stdout, "<External xmlns=\"%s\" href=\"%s\" SHA1=\"\"/>", BinNS, state->pixelInfo->outputPath );
*/
break;
/*
* END 'Process <BinData>'
*
**************************************************************************/
/**************************************************************************
*
* Process <BinData> inside of <Pixels>
*
*/
case IN_BINDATA_UNDER_PIXELS:
state->state = IN_PIXELS;
/* Endian check */
if( state->pixelInfo->bigEndian != bigEndian() &&
state->pixelInfo->bpp > 1 )
byteSwap( state->pixelInfo->binDataBuf, (size_t)state->pixelInfo->X * (size_t)state->pixelInfo->Y, state->pixelInfo->bpp );
/* write a buffered Pixel's plane */
nPix = setPixelPlane(
state->pixelInfo->pixWriter,
state->pixelInfo->binDataBuf,
state->pixelInfo->theZ,
state->pixelInfo->theC,
state->pixelInfo->theT );
if( (unsigned int) nPix * state->pixelInfo->bpp != state->pixelInfo->planeSize ) {
fprintf( stderr, "Error! tried to write a plane. expected to write %u bytes, actually wrote %u bytes!\n", state->pixelInfo->planeSize, (unsigned int) nPix );
assert((unsigned int) nPix * state->pixelInfo->bpp == state->pixelInfo->planeSize);
}
/* logic to increment indexes based on dimOrder */
if( strcmp( state->pixelInfo->dimOrder, "XYZCT" ) == 0 ) {
increment_plane_indexes(
&( state->pixelInfo->theZ ),
&( state->pixelInfo->theC ),
&( state->pixelInfo->theT ),
state->pixelInfo->Z,
state->pixelInfo->C,
state->pixelInfo->T
);
} else if( strcmp( state->pixelInfo->dimOrder, "XYZTC" ) == 0 ) {
increment_plane_indexes(
&( state->pixelInfo->theZ ),
&( state->pixelInfo->theT ),
&( state->pixelInfo->theC ),
state->pixelInfo->Z,
state->pixelInfo->T,
state->pixelInfo->C
);
} else if( strcmp( state->pixelInfo->dimOrder, "XYTZC" ) == 0 ) {
increment_plane_indexes(
&( state->pixelInfo->theT ),
&( state->pixelInfo->theZ ),
&( state->pixelInfo->theC ),
state->pixelInfo->T,
state->pixelInfo->Z,
state->pixelInfo->C
);
} else if( strcmp( state->pixelInfo->dimOrder, "XYTCZ" ) == 0 ) {
increment_plane_indexes(
&( state->pixelInfo->theT ),
&( state->pixelInfo->theC ),
&( state->pixelInfo->theZ ),
state->pixelInfo->T,
state->pixelInfo->C,
state->pixelInfo->Z
);
} else if( strcmp( state->pixelInfo->dimOrder, "XYCZT" ) == 0 ) {
increment_plane_indexes(
&( state->pixelInfo->theC ),
&( state->pixelInfo->theZ ),
&( state->pixelInfo->theT ),
state->pixelInfo->C,
state->pixelInfo->Z,
state->pixelInfo->T
);
} else if( strcmp( state->pixelInfo->dimOrder, "XYCTZ" ) == 0 ) {
increment_plane_indexes(
&( state->pixelInfo->theC ),
&( state->pixelInfo->theT ),
&( state->pixelInfo->theZ ),
state->pixelInfo->C,
state->pixelInfo->T,
state->pixelInfo->Z
);
}
/* cleanup */
b64z_decode_end( state->binDataInfo->strm );
free( state->binDataInfo->strm );
state->binDataInfo->strm = NULL;
if( state->binDataInfo->compression ) free( state->binDataInfo->compression );
state->binDataInfo->compression = NULL;
break;
/*
* END 'Process <BinData> inside of <Pixels>'
*
**************************************************************************/
case IN_PIXELS:
state->state = PARSER_START;
/* get SHA1, print SHA1 attribute */
if (get_md_from_fd (state->pixelInfo->pixWriter->fd_rep, state->pixelInfo->pixWriter->head->sha1) < 0) {
fprintf(stderr, "Unable to retrieve SHA1.");
assert(0);
}
fprintf( stdout, " FileSHA1 = \"" );
print_md( state->pixelInfo->pixWriter->head->sha1 );
fprintf( stdout, "\"" );
/* close pixelsRep object; get ImageServerID from FinishPixels */
if ( (ImageServerID = FinishPixels( state->pixelInfo->pixWriter, 0 )) == 0 ) {
if (errno)
fprintf (stderr,"%s\n",strerror( errno ) );
else
fprintf(stderr, "Access control error - check error log for details.\n");
assert(0);
}
/* set ImageServerID */
fprintf( stdout, " ImageServerID = \"%llu\" ", (unsigned long long)ImageServerID );
/* cleanup */
freePixelsRep (state->pixelInfo->pixWriter);
free( state->pixelInfo->binDataBuf );
free( state->pixelInfo->dimOrder );
free( state->pixelInfo->pixelType );
free( state->pixelInfo );
state->pixelInfo = NULL;
/* DO NOT "break;" Go on to default action of stack cleanup and
/ element closure.
*/
default:
/* Stack maintence */
if( state->elementInfo != NULL ) {
elementInfo = state->elementInfo;
state->elementInfo = elementInfo->prev;
if( elementInfo->hasContent == 0 ) {
fprintf( stdout, "/>" );
} else {
fprintf( stdout, "</%s>", name );
}
free( elementInfo );
}
}
} /* END OME_EndElement */
int writeRAWIV( FFTW_DATA_TYPE *vol, int n, double xCenter, double yCenter, double zCenter, double scale, char *fileName )
{
FILE *fp;
if ( ( fp = fopen( fileName, "wb" ) ) == NULL )
{
fprintf( stderr, "\nError: Failed to create file %s!\n\n", fileName );
return 0;
}
RAWIVHeader header;
float gridLength1D = 1.0 / scale;
header.minExt[ 0 ] = xCenter - gridLength1D / 2.0;
header.minExt[ 1 ] = yCenter - gridLength1D / 2.0;
header.minExt[ 2 ] = zCenter - gridLength1D / 2.0;
header.maxExt[ 0 ] = xCenter + gridLength1D / 2.0;
header.maxExt[ 1 ] = yCenter + gridLength1D / 2.0;
header.maxExt[ 2 ] = zCenter + gridLength1D / 2.0;
header.numVertices = n * n * n;
header.numCells = ( n - 1 ) * ( n - 1 ) * ( n - 1 );
for ( int i = 0; i < 3; i++ )
{
header.dim[ i ] = n;
header.origin[ i ] = header.minExt[ i ];
header.span[ i ] = gridLength1D / ( n - 1 );
}
if ( !bigEndian( ) )
{
for ( int i = 0; i < 3; i++ )
{
SWAP_32( &( header.minExt[ i ] ) );
SWAP_32( &( header.maxExt[ i ] ) );
SWAP_32( &( header.dim[ i ] ) );
SWAP_32( &( header.origin[ i ] ) );
SWAP_32( &( header.span[ i ] ) );
}
SWAP_32( &( header.numVertices ) );
SWAP_32( &( header.numCells ) );
}
if ( fwrite( &header, sizeof( header ), 1, fp ) != 1 )
{
fprintf( stderr, "\nError: Failed to write header to file %s!\n\n", fileName );
fclose( fp );
return 0;
}
int rowLen = n * sizeof( FFTW_DATA_TYPE );
unsigned char *buf = ( unsigned char * ) calloc( rowLen, 1 );
if ( buf == NULL )
{
fprintf( stderr, "\nError: Failed to allocate temporary buffer space!\n\n" );
fclose( fp );
return 0;
}
FFTW_DATA_TYPE *volPtr = vol;
for ( int k = 0; k < n; k++ )
for ( int j = 0; j < n; j++ )
{
memcpy( buf, volPtr, rowLen );
volPtr += n;
if ( !bigEndian( ) )
{
for ( int i = 0; i < n; i++ )
SWAP_FFTW_DATA( buf + i * sizeof( FFTW_DATA_TYPE ) );
}
if ( fwrite( buf, rowLen, 1, fp ) != 1 )
{
fprintf( stderr, "\nError: Failed to write data to file %s!\n\n", fileName );
free( buf );
fclose( fp );
return 0;
}
}
free( buf );
fclose( fp );
return 1;
}
int readRAWIV( FFTW_DATA_TYPE **vol, int *xDim, int *yDim, int *zDim, double *xCenter, double *yCenter, double *zCenter, double *scale, char *fileName )
{
FILE *fp;
if ( ( fp = fopen( fileName, "rb" ) ) == NULL )
{
fprintf( stderr, "\nError: Failed to open file %s!\n\n", fileName );
return 0;
}
fseek( fp, 0, SEEK_END );
long fileSize = ftell( fp );
fseek( fp, 0, SEEK_SET );
RAWIVHeader header;
if ( fread( &header, sizeof( header ), 1, fp ) != 1 )
{
fprintf( stderr, "\nError: Failed to read header from file %s!\n\n", fileName );
fclose( fp );
return 0;
}
if ( !bigEndian( ) )
{
for ( int i = 0; i < 3; i++ )
{
SWAP_32( &( header.minExt[ i ] ) );
SWAP_32( &( header.maxExt[ i ] ) );
SWAP_32( &( header.dim[ i ] ) );
SWAP_32( &( header.origin[ i ] ) );
SWAP_32( &( header.span[ i ] ) );
}
SWAP_32( &( header.numVertices ) );
SWAP_32( &( header.numCells ) );
}
*xCenter = ( header.minExt[ 0 ] + header.maxExt[ 0 ] ) / 2.0;
*yCenter = ( header.minExt[ 1 ] + header.maxExt[ 1 ] ) / 2.0;
*zCenter = ( header.minExt[ 2 ] + header.maxExt[ 2 ] ) / 2.0;
float gridLength1D = header.maxExt[ 0 ] - header.minExt[ 0 ];
*scale = 1.0 / gridLength1D;
*xDim = header.dim[ 0 ];
*yDim = header.dim[ 1 ];
*zDim = header.dim[ 2 ];
int dataTypeSize = ( fileSize - sizeof( header ) ) / ( ( *xDim ) * ( *yDim ) * ( *zDim ) );
int rowLen;
if ( dataTypeSize == 4 ) rowLen = ( *xDim ) * sizeof( float );
else rowLen = ( *xDim ) * sizeof( double );
unsigned char *buf = ( unsigned char * ) calloc( rowLen, 1 );
if ( buf == NULL )
{
fprintf( stderr, "\nError: Failed to allocate temporary buffer space!\n\n" );
fclose( fp );
return 0;
}
*vol = ( FFTW_DATA_TYPE * ) malloc( ( *xDim ) * ( *yDim ) * ( *zDim ) * sizeof( FFTW_DATA_TYPE ) );
if ( *vol == NULL )
{
fprintf( stderr, "\nError: Failed to allocate buffer space for reading file *s!\n\n", fileName );
free( buf );
fclose( fp );
return 0;
}
FFTW_DATA_TYPE *volPtr = ( FFTW_DATA_TYPE * ) *vol;
for ( int k = 0; k < *zDim; k++ )
for ( int j = 0; j < *yDim; j++ )
{
if ( fread( buf, rowLen, 1, fp ) != 1 )
{
fprintf( stderr, "\nError: Failed to read data from file %s!\n\n", fileName );
free( buf );
free( *vol );
fclose( fp );
return 0;
}
if ( dataTypeSize == 4 )
{
if ( !bigEndian( ) )
{
for ( int i = 0; i < *xDim; i++ )
SWAP_32( buf + i * sizeof( float ) );
}
float *bufPtr = ( float * ) buf;
for ( int i = 0; i < *xDim; i++ )
volPtr[ i ] = ( FFTW_DATA_TYPE ) bufPtr[ i ];
}
else
{
if ( !bigEndian( ) )
{
for ( int i = 0; i < *xDim; i++ )
SWAP_64( buf + i * sizeof( double ) );
}
double *bufPtr = ( double * ) buf;
for ( int i = 0; i < *xDim; i++ )
volPtr[ i ] = ( FFTW_DATA_TYPE ) bufPtr[ i ];
}
volPtr += ( *xDim );
}
free( buf );
fclose( fp );
printf( "\n\nREAD %s ( xDim = %d, yDim = %d, zDim = %d, xCenter = %lf, yCenter = %lf, zCenter = %lf, scale = %lf, dataTypeSize = %d )!\n\n",
fileName, *xDim, *yDim, *zDim, *xCenter, *yCenter, *zCenter, *scale, dataTypeSize );
return 1;
}
