mirror of
https://github.com/HDFGroup/hdf5.git
synced 2024-11-27 02:10:55 +08:00
c8d2f1e17a
----------------------
./src/H5A.c
./src/H5Apublic.h
./test/tattr.c
Switched the order of the second and third argument of
H5Aget_name() to make it consistent with other functions that
take buffers and buffer sizes.
./src/H5G.c
./src/H5Gpublic.h
./src/H5Gprivate.h
The H5Gget_comment() function returns the size of the comment
including the null terminator. If the object has no comment
then zero is returned. If an error occurs then a negative
value is returned.
./MANIFEST
./tools/Makefile.in
./tools/h5tools.h [NEW]
./tools/h5dump.c [NEW]
Created a library for printing values of datasets in a way
that looks nice. It's not done yet, but I needed it for
debugging the contents of files from Jim Reus.
./tools/h5ls.c
Added the `-d' and `--dump' options which cause the contents
of a dataset to be printed. Added `-w N' and `--width=N'
options to control how wide the raw data output should be. If
you want single-column output then say `-w1'.
Printing dataset values can now handle datasets of any integer
or floating point atomic type. As a special case, integers
which are one byte wide are treated a character strings for
now.
Sample output:
$ h5ls --dump --width=60 banana.hdf
ARCHIVE 0:0:0:744 Dataset {52/Inf}
Data:
(0) "U struct complex { double R; double I; };\012V"
(43) " double;\012"
U 0:0:0:2500 Dataset {256/512}
Data: printing of compound data types is not implemented yet
V 0:0:0:3928 Dataset {256/512}
Data:
(0) 0, 0.015625, 0.03125, 0.046875, 0.0625,
(5) 0.078125, 0.09375, 0.109375, 0.125, 0.140625,
(10) 0.15625, 0.171875, 0.1875, 0.203125, 0.21875,
(15) 0.234375, 0.25, 0.265625, 0.28125, 0.296875,
...
328 lines
9.3 KiB
C
328 lines
9.3 KiB
C
/*
|
||
* Copyright © 1998 NCSA
|
||
* All rights reserved.
|
||
*
|
||
* Programmer: Robb Matzke <matzke@llnl.gov>
|
||
* Thursday, July 23, 1998
|
||
*
|
||
* Purpose: A library for displaying the values of a dataset in a human
|
||
* readable format.
|
||
*/
|
||
#include <assert.h>
|
||
#include <ctype.h>
|
||
#include <h5tools.h>
|
||
#include <hdf5.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
|
||
/*
|
||
* The output functions need a temporary buffer to hold a piece of the
|
||
* dataset while it's being printed. This constant sets the limit on the
|
||
* size of that temporary buffer in bytes. For efficiency's sake, choose the
|
||
* largest value suitable for your machine (for testing use a small value).
|
||
*/
|
||
#define H5DUMP_BUFSIZE 1024
|
||
|
||
#define OPT(X,S) ((X)?(X):(S))
|
||
#define MIN(X,Y) ((X)<(Y)?(X):(Y))
|
||
#define NELMTS(X) (sizeof(X)/sizeof(*X))
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: h5dump_prefix
|
||
*
|
||
* Purpose: Prints the prefix to show up at the begining of the line.
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Thursday, July 23, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
h5dump_prefix(char *s/*out*/, const h5dump_t *info, hsize_t elmtno, int ndims,
|
||
hsize_t min_idx[], hsize_t max_idx[])
|
||
{
|
||
hsize_t p_prod[8], p_idx[8];
|
||
hsize_t n, i;
|
||
char temp[1024];
|
||
|
||
/*
|
||
* Calculate the number of elements represented by a unit change in a
|
||
* certain index position.
|
||
*/
|
||
for (i=ndims-1, p_prod[ndims-1]=1; i>0; --i) {
|
||
p_prod[i-1] = (max_idx[i]-min_idx[i]) * p_prod[i];
|
||
}
|
||
|
||
/*
|
||
* Calculate the index values from the element number.
|
||
*/
|
||
for (i=0, n=elmtno; i<(hsize_t)ndims; i++) {
|
||
p_idx[i] = n / p_prod[i] + min_idx[i];
|
||
n %= p_prod[i];
|
||
}
|
||
|
||
/*
|
||
* Print the index values.
|
||
*/
|
||
*temp = '\0';
|
||
for (i=0; i<(hsize_t)ndims; i++) {
|
||
if (i) strcat(temp, OPT(info->idx_sep, ","));
|
||
sprintf(temp+strlen(temp), OPT(info->idx_n_fmt, "%lu"),
|
||
(unsigned long)p_idx[i]);
|
||
}
|
||
|
||
/*
|
||
* Add prefix and suffix to the index.
|
||
*/
|
||
sprintf(s, OPT(info->idx_fmt, "%s: "), temp);
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: h5dump_sprint
|
||
*
|
||
* Purpose: Prints the value pointed to by VP into the string S assuming
|
||
* the data type of VP is TYPE.
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Thursday, July 23, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
h5dump_sprint(char *s/*out*/, const h5dump_t *info, hid_t type, void *vp)
|
||
{
|
||
size_t i, n;
|
||
char temp[1024];
|
||
|
||
if (H5Tequal(type, H5T_NATIVE_DOUBLE)) {
|
||
sprintf(temp, "%g", *((double*)vp));
|
||
} else if (H5Tequal(type, H5T_NATIVE_FLOAT)) {
|
||
sprintf(temp, "%g", *((float*)vp));
|
||
} else if (H5Tequal(type, H5T_NATIVE_CHAR) ||
|
||
H5Tequal(type, H5T_NATIVE_UCHAR)) {
|
||
if ('\\'==*((char*)vp)) strcpy(temp, "\\\\");
|
||
else if (isprint(*((char*)vp))) sprintf(temp, "%c", *((char*)vp));
|
||
else sprintf(temp, "\\%03o", *((unsigned char*)vp));
|
||
} else if (H5Tequal(type, H5T_NATIVE_SHORT)) {
|
||
sprintf(temp, "%d", *((short*)vp));
|
||
} else if (H5Tequal(type, H5T_NATIVE_USHORT)) {
|
||
sprintf(temp, "%u", *((unsigned short*)vp));
|
||
} else if (H5Tequal(type, H5T_NATIVE_INT)) {
|
||
sprintf(temp, "%d", *((int*)vp));
|
||
} else if (H5Tequal(type, H5T_NATIVE_UINT)) {
|
||
sprintf(temp, "%u", *((unsigned*)vp));
|
||
} else if (H5Tequal(type, H5T_NATIVE_LONG)) {
|
||
sprintf(temp, "%ld", *((long*)vp));
|
||
} else if (H5Tequal(type, H5T_NATIVE_ULONG)) {
|
||
sprintf(temp, "%lu", *((unsigned long*)vp));
|
||
} else {
|
||
strcpy(temp, "0x");
|
||
n = H5Tget_size(type);
|
||
for (i=0; i<n; i++) {
|
||
sprintf(temp+strlen(temp), "%02x", ((unsigned char*)vp)[i]);
|
||
}
|
||
}
|
||
|
||
sprintf(s, OPT(info->elmt_fmt, "%s"), temp);
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: h5dump_simple
|
||
*
|
||
* Purpose: Print some values from a dataset with a simple data space.
|
||
* This is a special case of h5dump().
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Thursday, July 23, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static int
|
||
h5dump_simple(FILE *stream, const h5dump_t *info, hid_t dset, hid_t p_type)
|
||
{
|
||
hid_t f_space; /*file data space */
|
||
int ndims; /*dimensionality */
|
||
hsize_t elmtno, i; /*counters */
|
||
int carry; /*counter carry value */
|
||
hssize_t zero[8]; /*vector of zeros */
|
||
int need_prefix=1; /*indices need printing */
|
||
|
||
/* Print info */
|
||
hsize_t p_min_idx[8]; /*min selected index */
|
||
hsize_t p_max_idx[8]; /*max selected index */
|
||
size_t p_type_nbytes; /*size of memory type */
|
||
hsize_t p_nelmts; /*total selected elmts */
|
||
char p_buf[256]; /*output string */
|
||
size_t p_column=0; /*output column */
|
||
size_t p_ncolumns=80; /*default num columns */
|
||
char p_prefix[1024]; /*line prefix string */
|
||
|
||
/* Stripmine info */
|
||
hsize_t sm_size[8]; /*stripmine size */
|
||
hsize_t sm_nbytes; /*bytes per stripmine */
|
||
hsize_t sm_nelmts; /*elements per stripmine*/
|
||
unsigned char *sm_buf; /*buffer for raw data */
|
||
hid_t sm_space; /*stripmine data space */
|
||
|
||
/* Hyperslab info */
|
||
hssize_t hs_offset[8]; /*starting offset */
|
||
hsize_t hs_size[8]; /*size this pass */
|
||
hsize_t hs_nelmts; /*elements in request */
|
||
|
||
/*
|
||
* Check that everything looks okay. The dimensionality must not be too
|
||
* great and the dimensionality of the items selected for printing must
|
||
* match the dimensionality of the dataset.
|
||
*/
|
||
f_space = H5Dget_space(dset);
|
||
ndims = H5Sextent_ndims(f_space);
|
||
if ((size_t)ndims>NELMTS(sm_size)) return -1;
|
||
|
||
/* Assume entire data space to be printed */
|
||
for (i=0; i<(hsize_t)ndims; i++) p_min_idx[i] = 0;
|
||
H5Sextent_dims(f_space, p_max_idx, NULL);
|
||
for (i=0, p_nelmts=1; i<(hsize_t)ndims; i++) {
|
||
p_nelmts *= p_max_idx[i]-p_min_idx[i];
|
||
}
|
||
|
||
/*
|
||
* Determine the strip mine size and allocate a buffer. The strip mine is
|
||
* a hyperslab whose size is manageable.
|
||
*/
|
||
p_type_nbytes = H5Tget_size(p_type);
|
||
for (i=ndims, sm_nbytes=p_type_nbytes; i>0; --i) {
|
||
sm_size[i-1] = MIN (p_max_idx[i-1]-p_min_idx[i-1],
|
||
H5DUMP_BUFSIZE/sm_nbytes);
|
||
sm_nbytes *= sm_size[i-1];
|
||
assert(sm_nbytes>0);
|
||
}
|
||
sm_buf = malloc(sm_nbytes);
|
||
sm_nelmts = sm_nbytes/p_type_nbytes;
|
||
sm_space = H5Screate_simple(1, &sm_nelmts, NULL);
|
||
|
||
/* Local things */
|
||
if (info->line_ncols>0) p_ncolumns = info->line_ncols;
|
||
|
||
/* The stripmine loop */
|
||
memset(hs_offset, 0, sizeof hs_offset);
|
||
memset(zero, 0, sizeof zero);
|
||
for (elmtno=0; elmtno<p_nelmts; elmtno+=hs_nelmts) {
|
||
|
||
/* Calculate the hyperslab size */
|
||
for (i=0, hs_nelmts=1; i<(hsize_t)ndims; i++) {
|
||
hs_size[i] = MIN(sm_size[i], p_max_idx[i]-hs_offset[i]);
|
||
hs_nelmts *= hs_size[i];
|
||
}
|
||
|
||
/* Read the data */
|
||
H5Sselect_hyperslab(f_space, H5S_SELECT_SET, hs_offset, NULL,
|
||
hs_size, NULL);
|
||
H5Sselect_hyperslab(sm_space, H5S_SELECT_SET, zero, NULL,
|
||
&hs_nelmts, NULL);
|
||
H5Dread(dset, p_type, sm_space, f_space, H5P_DEFAULT, sm_buf);
|
||
|
||
/* Print the data */
|
||
for (i=0; i<hs_nelmts; i++) {
|
||
/* Render the element */
|
||
h5dump_sprint(p_buf, info, p_type, sm_buf+i*p_type_nbytes);
|
||
if (i+1<hs_nelmts) {
|
||
strcat(p_buf, OPT(info->elmt_suf1, ","));
|
||
}
|
||
|
||
/* Print the prefix */
|
||
if ((p_column +
|
||
strlen(p_buf) +
|
||
strlen(OPT(info->elmt_suf2, " ")) +
|
||
strlen(OPT(info->line_suf, ""))) > p_ncolumns) {
|
||
need_prefix = 1;
|
||
}
|
||
if (need_prefix) {
|
||
h5dump_prefix(p_prefix, info, elmtno+i, ndims,
|
||
p_min_idx, p_max_idx);
|
||
if (p_column) {
|
||
fputs(OPT(info->line_suf, ""), stream);
|
||
putc('\n', stream);
|
||
fputs(OPT(info->line_sep, ""), stream);
|
||
}
|
||
fputs(p_prefix, stream);
|
||
p_column = strlen(p_prefix);
|
||
need_prefix = 0;
|
||
} else {
|
||
fputs(OPT(info->elmt_suf2, " "), stream);
|
||
p_column += strlen(OPT(info->elmt_suf2, " "));
|
||
}
|
||
|
||
fputs(p_buf, stream);
|
||
p_column += strlen(p_buf);
|
||
}
|
||
|
||
/* Calculate the next hyperslab offset */
|
||
for (i=ndims, carry=1; i>0 && carry; --i) {
|
||
hs_offset[i-1] += hs_size[i-1];
|
||
if (hs_offset[i-1]==(hssize_t)p_max_idx[i-1]) {
|
||
hs_offset[i-1] = p_min_idx[i-1];
|
||
} else {
|
||
carry = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (p_column) {
|
||
fputs(OPT(info->line_suf, ""), stream);
|
||
putc('\n', stream);
|
||
fputs(OPT(info->line_sep, ""), stream);
|
||
}
|
||
H5Sclose(sm_space);
|
||
H5Sclose(f_space);
|
||
return 0;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: h5dump
|
||
*
|
||
* Purpose: Print some values from a dataset. The values to print are
|
||
* determined by the P_SPACE argument and the format to use to
|
||
* print them is determined by the P_TYPE argument.
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Thursday, July 23, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
int
|
||
h5dump(FILE *stream, const h5dump_t *info, hid_t dset, hid_t p_type)
|
||
{
|
||
hid_t f_space;
|
||
|
||
f_space = H5Dget_space(dset);
|
||
if (H5Sis_simple(f_space)<=0) return -1;
|
||
H5Sclose(f_space);
|
||
|
||
return h5dump_simple(stream, info, dset, p_type);
|
||
}
|