/**
* Equivalent to (mol.x, mol.y, mol.z)
* You have to free *x, *y, *z!
*/
int get_coordinates(PyObject *mol, float **x, float **y, float **z)
{
int nx, ny, nz;
*x = get_float_array(mol, "x", &nx);
*y = get_float_array(mol, "y", &ny);
*z = get_float_array(mol, "z", &nz);
// These coordinate arrays should all be the same length
if(!(nx == ny && ny == nz))
{
fprintf(stderr, "Error: Coordinate arrays are not the same size.\n");
return -1;
}
return nx;
}
PyObject* compression_decompressData(PyObject* self, PyObject* args)
{
int status;
int nUcTiles = 0;
int* inDataLen = 0;
int naxis;
int numzVals;
int* numUncompressedVals = 0;
int cn_zblank;
int cn_zscale;
int cn_zzero;
int cn_uncompressed;
int bitpix;
int datatype;
int firstelem;
int anynul;
long nelem;
long* naxes = 0;
long* tileSize = 0;
long* zval = 0;
double nulval;
double* bscale;
double* bzero;
double quantize_level;
double hcomp_scale;
long* nullDVals;
unsigned char** inData = 0;
void** uncompressedData = 0;
int i;
int ii;
char* compressTypeStr = "";
PyObject* inDataObj;
PyObject* naxesObj;
PyObject* tileSizeObj;
PyObject* uncompressedDataObj;
PyObject* zvalObj;
FITSfile fileParms;
fitsfile theFile;
PyArrayObject* bscaleArray;
PyArrayObject* bzeroArray;
PyArrayObject* nullDvalsArray;
PyArrayObject* decompDataArray;
PyArrayObject* bscaleArray1 = 0;
PyArrayObject* bzeroArray1 = 0;
PyArrayObject* nullDvalsArray1 = 0;
/* Get Python arguments */
if (!PyArg_ParseTuple(args,
"OiOOO!iO!iO!iOiddOsiildO!:compression.decompressData",
&inDataObj,
&naxis, &naxesObj, &tileSizeObj, &PyArray_Type,
&bscaleArray, &cn_zscale, &PyArray_Type, &bzeroArray,
&cn_zzero, &PyArray_Type, &nullDvalsArray,
&cn_zblank, &uncompressedDataObj,
&cn_uncompressed, &quantize_level, &hcomp_scale,
&zvalObj, &compressTypeStr, &bitpix, &firstelem,
&nelem, &nulval, &PyArray_Type, &decompDataArray))
{
PyErr_SetString(PyExc_TypeError,"Couldn't parse arguments");
return NULL;
}
/* Convert the input lists into C type arrays */
inData = get_char_array(inDataObj, "Compressed Data", NULL, &inDataLen);
if (!inData)
{
goto error;
}
naxes = get_long_array(naxesObj, "ZNAXISn", NULL);
if (!naxes)
{
goto error;
}
tileSize = get_long_array(tileSizeObj, "ZTILEn", NULL);
if (!tileSize)
{
goto error;
}
if (cn_zzero != 1)
{
bzero = (double*)bzeroArray->data;
}
else
{
bzeroArray1 = (PyArrayObject*)PyArray_ContiguousFromObject(
(PyObject*)bzeroArray, PyArray_DOUBLE, 1, 1);
bzero = (double*)bzeroArray1->data;
}
if (cn_zscale != 1)
{
bscale = (double*)bscaleArray->data;
}
else
{
bscaleArray1 = (PyArrayObject*)PyArray_ContiguousFromObject(
(PyObject*)bscaleArray, PyArray_DOUBLE, 1, 1);
bscale = (double*)bscaleArray1->data;
}
if (cn_zblank != 1)
{
nullDVals = (long*)nullDvalsArray->data;
}
else
{
nullDvalsArray1 = (PyArrayObject*)PyArray_ContiguousFromObject(
(PyObject*)nullDvalsArray, PyArray_LONG, 1, 1);
nullDVals = (long*)nullDvalsArray1->data;
}
zval = get_long_array(zvalObj, "ZVALn", &numzVals);
if (!zval)
{
goto error;
}
switch (bitpix)
{
case BYTE_IMG:
datatype = TBYTE;
break;
case SHORT_IMG:
datatype = TSHORT;
break;
case LONG_IMG:
datatype = TINT;
break;
case LONGLONG_IMG:
datatype = TLONGLONG;
break;
case FLOAT_IMG:
datatype = TFLOAT;
if (cn_uncompressed == 1)
{
nUcTiles = PyList_Size(uncompressedDataObj);
uncompressedData = (void**) PyMem_Malloc(nUcTiles*sizeof(float*));
if (!uncompressedData)
{
goto error;
}
numUncompressedVals = PyMem_Malloc(nUcTiles*sizeof(int));
if (!numUncompressedVals)
{
goto error;
}
for (i = 0; i < nUcTiles; i++)
{
uncompressedData[i] =
get_float_array(PyList_GetItem(uncompressedDataObj, i),
"Uncompressed Data",
&numUncompressedVals[i]);
if (!uncompressedData[i])
{
goto error;
}
}
}
break;
case DOUBLE_IMG:
datatype = TDOUBLE;
if (cn_uncompressed == 1)
{
nUcTiles = PyList_Size(uncompressedDataObj);
uncompressedData = (void**) PyMem_Malloc(nUcTiles*sizeof(double*));
if (!uncompressedData)
{
goto error;
}
numUncompressedVals = PyMem_Malloc(nUcTiles*sizeof(int));
if (!numUncompressedVals)
{
goto error;
}
for (i = 0; i < nUcTiles; i++)
{
uncompressedData[i] =
get_double_array(PyList_GetItem(uncompressedDataObj, i),
"Uncompressed Data",
&numUncompressedVals[i]);
if (!uncompressedData[i])
{
goto error;
}
}
}
break;
default:
PyErr_SetString(PyExc_ValueError,"Invalid value for BITPIX");
return NULL;
}
/* Set up the fitsfile object */
theFile.Fptr = &fileParms;
(theFile.Fptr)->rice_blocksize = 32;
(theFile.Fptr)->hcomp_smooth = 0;
(theFile.Fptr)->rice_bytepix = 4;
if (strcmp(compressTypeStr, "RICE_1") == 0)
{
(theFile.Fptr)->compress_type = RICE_1;
if (numzVals > 0)
{
(theFile.Fptr)->rice_blocksize = zval[0];
if (numzVals > 1)
{
(theFile.Fptr)->rice_bytepix = zval[1];
}
}
}
else if (strcmp(compressTypeStr, "GZIP_1") == 0)
{
(theFile.Fptr)->compress_type = GZIP_1;
}
else if (strcmp(compressTypeStr, "HCOMPRESS_1") == 0)
{
(theFile.Fptr)->compress_type = HCOMPRESS_1;
if (numzVals > 0)
{
(theFile.Fptr)->hcomp_smooth = zval[1];
}
}
else if (strcmp(compressTypeStr, "PLIO_1") == 0)
{
(theFile.Fptr)->compress_type = PLIO_1;
}
else
{
(theFile.Fptr)->compress_type = 0;
}
(theFile.Fptr)->zndim = naxis;
(theFile.Fptr)->maxtilelen = 1;
(theFile.Fptr)->zbitpix = bitpix;
(theFile.Fptr)->data = inData;
(theFile.Fptr)->dataLen = inDataLen;
(theFile.Fptr)->bscale = bscale;
(theFile.Fptr)->cn_zscale = cn_zscale;
(theFile.Fptr)->quantize_level = quantize_level;
(theFile.Fptr)->hcomp_scale = hcomp_scale;
if (cn_zscale == -1)
{
(theFile.Fptr)->zscale = bscale[0];
(theFile.Fptr)->cn_bscale = bscale[0];
}
else
{
(theFile.Fptr)->zscale = 1.0;
(theFile.Fptr)->cn_bscale = 1.0;
}
(theFile.Fptr)->bzero = bzero;
(theFile.Fptr)->cn_zzero = cn_zzero;
if (cn_zzero == -1)
{
(theFile.Fptr)->zzero = bzero[0];
(theFile.Fptr)->cn_bzero = bzero[0];
}
else
{
(theFile.Fptr)->zzero = 0.0;
(theFile.Fptr)->cn_bzero = 0.0;
}
(theFile.Fptr)->blank = nullDVals;
(theFile.Fptr)->cn_zblank = cn_zblank;
if (cn_zblank == -1)
{
(theFile.Fptr)->zblank = nullDVals[0];
}
else
{
(theFile.Fptr)->zblank = 0;
}
/* Initialize arrays */
for (ii = 0; ii < MAX_COMPRESS_DIM; ii++)
{
((theFile.Fptr)->tilesize)[ii] = 1;
((theFile.Fptr)->znaxis)[ii] = 1;
}
for (ii = 0; ii < naxis; ii++)
{
((theFile.Fptr)->znaxis)[ii] = naxes[ii];
((theFile.Fptr)->tilesize)[ii] = tileSize[ii];
(theFile.Fptr)->maxtilelen *= tileSize[ii];
}
(theFile.Fptr)->cn_uncompressed = cn_uncompressed;
if (cn_uncompressed == 1)
{
(theFile.Fptr)->ucData = uncompressedData;
(theFile.Fptr)->ucDataLen = numUncompressedVals;
}
/* Call the C function */
status = 0;
status = _astropy_fits_read_img(&theFile, datatype, firstelem,
nelem, &nulval, decompDataArray->data,
&anynul, &status);
if (status != 0)
{
processStatusErr(status);
}
error:
PyMem_Free(inData);
PyMem_Free(inDataLen);
PyMem_Free(naxes);
PyMem_Free(tileSize);
PyMem_Free(zval);
if (cn_uncompressed == 1)
{
for (i = 0; i < nUcTiles; i++)
{
PyMem_Free(uncompressedData[i]);
}
PyMem_Free(uncompressedData);
PyMem_Free(numUncompressedVals);
}
if (bscaleArray1 != 0)
{
Py_DECREF(bscaleArray1);
}
if (bzeroArray1 != 0)
{
Py_DECREF(bzeroArray1);
}
if (nullDvalsArray1 != 0)
{
Py_DECREF(nullDvalsArray1);
}
if (status != 0)
{
return NULL;
}
else
{
return Py_BuildValue("i",status);
}
}
