int main (int argc, char *argv [])
{
FILE *in, *out;
clock_t a,b;
img_handle img, cbf_img;
cbf_handle cbf;
int id, index;
unsigned int column, row;
size_t nelem_read;
double pixel_size, gain, wavelength, distance;
int overload, dimension [2], precedence [2];
const char *detector;
char *detector_char;
char detector_id [64];
const char *direction [2], *array_id;
/* Usage */
if (argc < 3)
{
fprintf (stderr, "\n Usage: %s imagefile cbffile\n", argv [0]);
exit (2);
}
/* Read the image */
img = img_make_handle ();
a = clock ();
cbf_failnez (img_read (img, argv [1]))
b = clock ();
fprintf (stderr, " Time to read the image: %.3fs\n", ((b - a) * 1.0) / CLOCKS_PER_SEC);
/* Get some detector parameters */
/* Detector identifier */
detector = img_get_field (img, "DETECTOR");
if (!detector)
detector = "unknown";
strncpy (detector_id, detector, 63);
detector_id [63] = 0;
detector_char = detector_id;
while (*detector_char)
if (isspace (*detector_char))
memmove (detector_char, detector_char + 1, strlen (detector_char));
else
{
*detector_char = tolower (*detector_char);
detector_char++;
}
/* Pixel size */
pixel_size = img_get_number (img, "PIXEL SIZE") * 0.001;
/* Wavelength */
wavelength = img_get_number (img, "WAVELENGTH");
/* Distance */
distance = img_get_number (img, "DISTANCE") * 0.001;
/* Image size and orientation & gain and overload */
if (strcmp (detector_id, "mar180") == 0 ||
strcmp (detector_id, "mar300") == 0)
{
gain = 1.08;
overload = 120000;
dimension [0] = img_rows (img);
dimension [1] = img_columns (img);
precedence [0] = 1;
precedence [1] = 2;
direction [0] = "decreasing";
direction [1] = "increasing";
}
else
if (strcmp (detector_id, "mar345") == 0)
{
gain = 1.55;
overload = 240000;
dimension [0] = img_columns (img);
dimension [1] = img_rows (img);
precedence [0] = 2;
precedence [1] = 1;
direction [0] = "increasing";
direction [1] = "increasing";
}
else
if (strncmp (detector_id, "adscquantum", 11) == 0)
{
gain = 0.20;
overload = 65000;
dimension [0] = img_columns (img);
dimension [1] = img_rows (img);
precedence [0] = 2;
precedence [1] = 1;
direction [0] = "increasing";
direction [1] = "increasing";
}
else
{
gain = 0.0;
overload = 0;
dimension [0] = img_rows (img);
dimension [1] = img_columns (img);
precedence [0] = 1;
precedence [1] = 2;
direction [0] = NULL;
direction [1] = NULL;
}
/* Make a cbf version of the image */
a = clock ();
/* Create the cbf */
cbf_failnez (cbf_make_handle (&cbf))
/* Make a new data block */
cbf_failnez (cbf_new_datablock (cbf, "image_1"))
/* Make the _diffrn category */
cbf_failnez (cbf_new_category (cbf, "diffrn"))
cbf_failnez (cbf_new_column (cbf, "id"))
cbf_failnez (cbf_set_value (cbf, "DS1"))
/* Make the _diffrn_source category */
cbf_failnez (cbf_new_category (cbf, "diffrn_source"))
cbf_failnez (cbf_new_column (cbf, "diffrn_id"))
cbf_failnez (cbf_set_value (cbf, "DS1"))
cbf_failnez (cbf_new_column (cbf, "source"))
cbf_failnez (cbf_set_value (cbf, "synchrotron"))
cbf_failnez (cbf_new_column (cbf, "type"))
cbf_failnez (cbf_set_value (cbf, "ssrl crystallography"))
/* Make the _diffrn_radiation category */
cbf_failnez (cbf_new_category (cbf, "diffrn_radiation"))
cbf_failnez (cbf_new_column (cbf, "diffrn_id"))
cbf_failnez (cbf_set_value (cbf, "DS1"))
cbf_failnez (cbf_new_column (cbf, "wavelength_id"))
cbf_failnez (cbf_set_value (cbf, "L1"))
/* Make the _diffrn_radiation_wavelength category */
cbf_failnez (cbf_new_category (cbf, "diffrn_radiation_wavelength"))
cbf_failnez (cbf_new_column (cbf, "id"))
cbf_failnez (cbf_set_value (cbf, "L1"))
cbf_failnez (cbf_new_column (cbf, "wavelength"))
if (wavelength)
cbf_failnez (cbf_set_doublevalue (cbf, "%.4f", wavelength))
cbf_failnez (cbf_new_column (cbf, "wt"))
cbf_failnez (cbf_set_value (cbf, "1.0"))
/* Make the _diffrn_measurement category */
cbf_failnez (cbf_new_category (cbf, "diffrn_measurement"))
cbf_failnez (cbf_new_column (cbf, "diffrn_id"))
cbf_failnez (cbf_set_value (cbf, "DS1"))
cbf_failnez (cbf_new_column (cbf, "method"))
cbf_failnez (cbf_set_value (cbf, "oscillation"))
cbf_failnez (cbf_new_column (cbf, "sample_detector_distance"))
if (distance)
cbf_failnez (cbf_set_doublevalue (cbf, "%.4f", distance))
/* Make the _diffrn_detector category */
cbf_failnez (cbf_new_category (cbf, "diffrn_detector"))
cbf_failnez (cbf_new_column (cbf, "id"))
cbf_failnez (cbf_set_value (cbf, detector_id))
cbf_failnez (cbf_new_column (cbf, "diffrn_id"))
cbf_failnez (cbf_set_value (cbf, "DS1"))
cbf_failnez (cbf_new_column (cbf, "type"))
cbf_failnez (cbf_set_value (cbf, detector))
/* Make the _diffrn_detector_element category */
cbf_failnez (cbf_new_category (cbf, "diffrn_detector_element"))
cbf_failnez (cbf_new_column (cbf, "id"))
cbf_failnez (cbf_set_integervalue (cbf, 1))
cbf_failnez (cbf_new_column (cbf, "detector_id"))
cbf_failnez (cbf_set_value (cbf, detector_id))
/* Make the _diffrn_frame_data category */
cbf_failnez (cbf_new_category (cbf, "diffrn_frame_data"))
cbf_failnez (cbf_new_column (cbf, "id"))
cbf_failnez (cbf_set_value (cbf, "frame_1"))
cbf_failnez (cbf_new_column (cbf, "detector_element_id"))
cbf_failnez (cbf_set_integervalue (cbf, 1))
cbf_failnez (cbf_new_column (cbf, "detector_id"))
cbf_failnez (cbf_set_value (cbf, detector_id))
cbf_failnez (cbf_new_column (cbf, "array_id"))
cbf_failnez (cbf_set_value (cbf, "image_1"))
cbf_failnez (cbf_new_column (cbf, "binary_id"))
cbf_failnez (cbf_set_integervalue (cbf, 1))
/* Make the _array_structure_list category */
cbf_failnez (cbf_new_category (cbf, "array_structure_list"))
cbf_failnez (cbf_new_column (cbf, "array_id"))
cbf_failnez (cbf_set_value (cbf, "image_1"))
cbf_failnez (cbf_new_row (cbf))
cbf_failnez (cbf_set_value (cbf, "image_1"))
cbf_failnez (cbf_new_column (cbf, "index"))
cbf_failnez (cbf_rewind_row (cbf))
cbf_failnez (cbf_set_integervalue (cbf, 1))
cbf_failnez (cbf_next_row (cbf))
cbf_failnez (cbf_set_integervalue (cbf, 2))
cbf_failnez (cbf_new_column (cbf, "dimension"))
cbf_failnez (cbf_rewind_row (cbf))
cbf_failnez (cbf_set_integervalue (cbf, dimension [0]))
cbf_failnez (cbf_next_row (cbf))
cbf_failnez (cbf_set_integervalue (cbf, dimension [1]))
cbf_failnez (cbf_new_column (cbf, "precedence"))
cbf_failnez (cbf_rewind_row (cbf))
cbf_failnez (cbf_set_integervalue (cbf, precedence [0]))
cbf_failnez (cbf_next_row (cbf))
cbf_failnez (cbf_set_integervalue (cbf, precedence [1]))
cbf_failnez (cbf_new_column (cbf, "direction"))
cbf_failnez (cbf_rewind_row (cbf))
cbf_failnez (cbf_set_value (cbf, direction [0]))
cbf_failnez (cbf_next_row (cbf))
cbf_failnez (cbf_set_value (cbf, direction [1]))
/* Make the _array_element_size category */
cbf_failnez (cbf_new_category (cbf, "array_element_size"))
cbf_failnez (cbf_new_column (cbf, "array_id"))
cbf_failnez (cbf_set_value (cbf, "image_1"))
cbf_failnez (cbf_new_row (cbf))
cbf_failnez (cbf_set_value (cbf, "image_1"))
cbf_failnez (cbf_new_column (cbf, "index"))
cbf_failnez (cbf_rewind_row (cbf))
cbf_failnez (cbf_set_integervalue (cbf, 1))
cbf_failnez (cbf_next_row (cbf))
cbf_failnez (cbf_set_integervalue (cbf, 2))
cbf_failnez (cbf_new_column (cbf, "size"))
if (pixel_size > 0)
{
cbf_failnez (cbf_rewind_row (cbf))
cbf_failnez (cbf_set_doublevalue (cbf, "%.1fe-6", pixel_size * 1e6))
cbf_failnez (cbf_next_row (cbf))
cbf_failnez (cbf_set_doublevalue (cbf, "%.1fe-6", pixel_size * 1e6))
}
/* Make the _array_intensities category */
cbf_failnez (cbf_new_category (cbf, "array_intensities"))
cbf_failnez (cbf_new_column (cbf, "array_id"))
cbf_failnez (cbf_set_value (cbf, "image_1"))
cbf_failnez (cbf_new_column (cbf, "binary_id"))
cbf_failnez (cbf_set_integervalue (cbf, 1))
cbf_failnez (cbf_new_column (cbf, "linearity"))
cbf_failnez (cbf_set_value (cbf, "linear"))
cbf_failnez (cbf_new_column (cbf, "gain"))
if (gain)
cbf_failnez (cbf_set_doublevalue (cbf, "%.3g", gain))
cbf_failnez (cbf_new_column (cbf, "overload"))
if (overload)
cbf_failnez (cbf_set_integervalue (cbf, overload))
cbf_failnez (cbf_new_column (cbf, "undefined"))
cbf_failnez (cbf_set_integervalue (cbf, 0))
/* Make the _array_data category */
cbf_failnez (cbf_new_category (cbf, "array_data"))
cbf_failnez (cbf_new_column (cbf, "array_id"))
cbf_failnez (cbf_set_value (cbf, "image_1"))
cbf_failnez (cbf_new_column (cbf, "binary_id"))
cbf_failnez (cbf_set_integervalue (cbf, 1))
cbf_failnez (cbf_new_column (cbf, "data"))
/* Save the binary data */
cbf_failnez (cbf_set_integerarray_wdims_fs (cbf, CBF_PACKED|CBF_FLAT_IMAGE, 1,
img_pixelptr (img, 0, 0), sizeof (int), 1,
img_rows (img) * img_columns (img),
"little_endian",img_rows (img),img_columns (img),0,0 ))
/* Write the new file */
out = fopen (argv [2], "w+b");
if (!out)
{
fprintf (stderr, " Couldn't open the CBF file %s\n", argv [2]);
exit (1);
}
cbf_failnez (cbf_write_file (cbf, out, 1, CBF, MSG_DIGEST | MIME_HEADERS , 0))
/* Free the cbf */
cbf_failnez (cbf_free_handle (cbf))
b = clock ();
fprintf (stderr, " Time to write the CBF image: %.3fs\n",
((b - a) * 1.0) / CLOCKS_PER_SEC);
/* Read the CBF file and compare the image to the original */
a = clock ();
/* Create the cbf */
cbf_failnez (cbf_make_handle (&cbf))
/* Read the file */
in = fopen (argv [2], "rb");
if (!in)
{
fprintf (stderr, " Couldn't reopen the CBF file %s\n", argv [2]);
exit (1);
}
cbf_failnez (cbf_read_file (cbf, in, MSG_DIGEST))
/* Get the image identifier */
cbf_failnez (cbf_rewind_datablock (cbf))
cbf_failnez (cbf_find_category (cbf, "diffrn_frame_data"))
cbf_failnez (cbf_find_column (cbf, "array_id"))
cbf_failnez (cbf_get_value (cbf, &array_id))
/* Get the image dimensions (second dimension = fast, first = slow) */
cbf_failnez (cbf_find_category (cbf, "array_structure_list"))
cbf_failnez (cbf_rewind_row (cbf))
cbf_failnez (cbf_find_column (cbf, "array_id"))
dimension [0] = dimension [1] = 0;
while (cbf_find_nextrow (cbf, array_id) == 0)
{
cbf_failnez (cbf_find_column (cbf, "precedence"))
cbf_failnez (cbf_get_integervalue (cbf, &index))
if (index >= 1 && index <= 2)
{
cbf_failnez (cbf_find_column (cbf, "dimension"))
cbf_failnez (cbf_get_integervalue (cbf, &dimension [2 - index]))
}
else
exit (1);
cbf_failnez (cbf_find_column (cbf, "array_id"))
}
if (dimension [0] == 0 || dimension [1] == 0)
exit (1);
/* Create the new image */
cbf_img = img_make_handle ();
img_set_dimensions (cbf_img, dimension [0], dimension [1]);
/* Find the binary data */
cbf_failnez (cbf_find_category (cbf, "array_data"))
cbf_failnez (cbf_find_column (cbf, "array_id"))
cbf_failnez (cbf_find_row (cbf, array_id))
cbf_failnez (cbf_find_column (cbf, "data"))
/* Read the binary data */
cbf_failnez (cbf_get_integerarray (cbf,
&id, img_pixelptr (cbf_img, 0, 0), sizeof (int), 1,
img_rows (cbf_img) * img_columns (cbf_img), &nelem_read))
/* Free the cbf */
cbf_failnez (cbf_free_handle (cbf))
b = clock ();
fprintf (stderr, " Time to read the CBF image: %.3fs\n",
((b - a) * 1.0) / CLOCKS_PER_SEC);
/* Compare the images */
if (img_rows (img) != img_rows (cbf_img) || img_columns (img) != img_columns (cbf_img))
{
fprintf (stderr, " The dimensions of the CBF image don't match the original\n");
exit (1);
}
for (column = 0; column < (unsigned int) img_columns (cbf_img); column++)
for (row = 0; row < (unsigned int) img_rows (cbf_img); row++)
if (img_pixel (cbf_img, column, row) != img_pixel (img, column, row))
{
fprintf (stderr, " The CBF image differs from the original at (%d, %d)\n", column, row);
exit (1);
}
fprintf (stderr, " The CBF image matches the original\n");
/* Free the images */
img_free_handle (img);
img_free_handle (cbf_img);
/* Success */
return 0;
}
int main (int argc, char *argv [])
{
int error = CBF_SUCCESS;
cbf_getopt_handle opts = NULL;
int h5_write_flags = 0;
int list = 0;
int noCBFnames = 0;
unsigned int frame = 0;
const char * cifout = NULL;
const char * hdf5in = NULL;
const char * group = NULL;
/* Attempt to read the arguments */
if (CBF_SUCCESS != (error |= cbf_make_getopt_handle(&opts))) {
fprintf(stderr,"Could not create a 'cbf_getopt' handle.\n");
} else if (CBF_SUCCESS != (error |= cbf_getopt_parse(opts, argc, argv, "c(compression):g(group):o(output):Z(register):f(frame):\1(list)\2(no-list)\3(CBFnames)\4(noCBFnames)" ))) {
fprintf(stderr,"Could not parse arguments.\n");
} else {
int errflg = 0;
/* successful so far, try to make sense of the options */
if (!cbf_rewind_getopt_option(opts)) {
int c = 0;
const char * optarg = NULL;
for(; !cbf_get_getopt_data(opts,&c,NULL,NULL,&optarg); cbf_next_getopt_option(opts)) {
switch (c) {
case 'f': { /* the index of the frame to be converted */
if (!optarg) {
++errflg;
} else {
char * end = NULL;
const unsigned int _frame = strtoul(optarg,&end,0);
if (end==optarg) {
fprintf(stderr,"error: Expected a number for the frame index, got '%s'.\n",optarg);
++errflg;
} else {
frame = _frame;
}
}
break;
}
case 'g': { /* group within input file where data should be found */
if (group) ++errflg;
else group = optarg;
break;
}
case 'o': { /* output file */
if (cifout) ++errflg;
else cifout = optarg;
break;
}
case 'Z': { /* automatic or manual filter registration? */
if (cbf_cistrcmp(optarg?optarg:"","manual") == 0) {
h5_write_flags |= CBF_H5_REGISTER_COMPRESSIONS;
} else if (cbf_cistrcmp(optarg?optarg:"","plugin") == 0) {
h5_write_flags &= ~CBF_H5_REGISTER_COMPRESSIONS;
} else {
++errflg;
}
break;
}
case 0: { /* input file */
if (hdf5in) ++errflg;
else hdf5in = optarg;
break;
}
case '\1': {
if (list) ++errflg;
list = 1;
break;
}
case '\2': {
if (list) ++errflg;
list = -1;
break;
}
case '\3': {
if (noCBFnames) ++errflg;
noCBFnames = -1;
break;
}
case '\4': {
if (noCBFnames) ++errflg;
noCBFnames = 1;
break;
}
default: {
++errflg;
break;
}
}
}
}
/* check for missing data */
if (!cifout) {
fprintf(stderr,"No output files given.\n");
++errflg;
}
if (!hdf5in) {
fprintf(stderr,"No input file given.\n");
++errflg;
}
if (errflg) {
fprintf(stderr, "Usage:\n\t%s [options] -o|--output output_cbf input_nexus\n"
"Options:\n"
"\t-g|--group output_group (default: 'entry')\n"
"\t-Z|--register manual|plugin (default: plugin)\n"
"\t-f|--frame <unsigned int> (default: 0)\n",
argv[0]);
error |= CBF_ARGUMENT;
}
}
/* If I could read the arguments then attempt to use them */
if (CBF_SUCCESS == error) {
cbf_h5handle h5in = NULL;
cbf_handle cif = NULL;
/* prepare the input file */
{
hid_t hdf_file = CBF_H5FAIL, fapl = CBF_H5FAIL;
if ((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) {
fprintf(stderr,"Couldn't create file access property list.\n");
error |= CBF_H5ERROR;
} else if ((H5Pset_fclose_degree(fapl,H5F_CLOSE_STRONG)) < 0) {
fprintf(stderr,"Couldn't set a file access property.\n");
error |= CBF_H5ERROR;
} else if ((hdf_file = H5Fopen(hdf5in,H5F_ACC_RDONLY,fapl)) < 0) {
fprintf(stderr,"Couldn't open a HDF5 file.\n");
error |= CBF_H5ERROR;
} else if(CBF_SUCCESS != (error |= cbf_create_h5handle3(&h5in,hdf_file))) {
fprintf(stderr,"Couldn't open the HDF5 file '%s'.\n", hdf5in);
} else if (CBF_SUCCESS != (error |= cbf_h5handle_require_entry(h5in,0,group))) {
fprintf(stderr,"Couldn't create an NXentry group in the HDF5 file '%s'.\n", hdf5in);
} else {
h5in->flags = h5_write_flags;
h5in->slice = frame;
#ifdef CBF_USE_ULP
// set up some parameters for comparing floating point numbers
h5in->cmp_double_as_float = 0;
h5in->float_ulp = 4;
#ifndef NO_UINT64_TYPE
h5in->double_ulp = 4;
#endif
#endif
}
H5Pclose(fapl);
}
/* make the handle for the output file */
if (CBF_SUCCESS != (error |= cbf_make_handle(&cif))) {
fprintf(stderr,"Failed to create handle for input_cif\n");
error |= CBF_ALLOC;
}
/* Time the conversion */
if (CBF_SUCCESS == error) {
clock_t a = clock(), b;
h5in->slice = 0;
if (list > 0) h5in->logfile = stdout;
if (noCBFnames >= 0) h5in->flags |= CBF_H5_CBFNONAMES;
error |= cbf_write_nx2cbf(h5in, cif);
b = clock();
printf("Time to convert '%s': %.3fs\n", cifout, ((float)(b - a))/CLOCKS_PER_SEC);
} else {
fprintf(stderr,"An error occured, will not try to convert the file '%s'\n",hdf5in);
}
/* Write the file */
if (CBF_SUCCESS == error) {
/* start timing */
clock_t a = clock(), b;
FILE * const out = fopen(cifout,"wb");
if (NULL == out) {
fprintf(stderr,"Couldn't open the output CIF file '%s': %s\n", cifout, strerror(errno));
error |= CBF_FILEOPEN;
} else if (CBF_SUCCESS != (error |= cbf_write_file(cif,out,0,CBF,0,0))) {
fprintf(stderr,"Couldn't write the output CIF file '%s': %s\n", cifout, cbf_strerror(error));
error |= CBF_FILEWRITE;
}
if (NULL!=out) fclose(out);
/* stop timing */
b = clock();
printf("Time to write '%s': %.3fs\n", cifout, ((float)(b - a))/CLOCKS_PER_SEC);
} else {
fprintf(stderr,"An error occured, will not try to write the file '%s'\n",cifout);
}
/* Clean up */
if (cif) cbf_free_handle(cif);
if (h5in) cbf_free_h5handle(h5in);
}
/*******************************************************************************************************************/
/* Cleanup */
error |= cbf_free_getopt_handle(opts);
return CBF_SUCCESS==error ? 0 : 1;
}
