/// <summary>
/// Writes the entire matrix table
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="matName"></param>
/// <param name="rowIndex"></param>
/// <returns></returns>
public void SetMatrix <T>(string matName, T[,] data)
{
// check that matrix exists
if (tables.ContainsKey(matName))
{
H5DataSetId matId;
tables.TryGetValue(matName, out matId);
H5DataTypeId matDataId = H5D.getType(matId);
H5DataSpaceId spaceId = H5S.create_simple(2, Shape);
long[] start = { 0, 0 };
long[] count = { Shape[0], Shape[1] };
var h5matrix = new H5Array <T>(data);
H5S.selectHyperslab(spaceId, H5S.SelectOperator.SET, start, count);
H5DataSpaceId readSpaceId = H5S.create_simple(2, count);
H5D.write(matId, matDataId, readSpaceId, spaceId, H5P.create(H5P.PropertyListClass.DATASET_XFER), h5matrix);
H5S.close(spaceId);
H5S.close(readSpaceId);
}
else
{
Console.WriteLine("table {0} not found in matrix file", matName);
}
return;
}
public void H5SdecodeTest1()
{
hsize_t[] dims = { 1, 2, 3 };
hid_t space = H5S.create_simple(dims.Length, dims, dims);
Assert.IsTrue(space > 0);
size_t nalloc = new IntPtr();
Assert.IsTrue(H5S.encode(space, null, ref nalloc) >= 0);
byte[] buf = new byte [nalloc.ToInt32()];
Assert.IsTrue(H5S.encode(space, buf, ref nalloc) >= 0);
Assert.IsTrue(H5S.close(space) >= 0);
space = H5S.decode(buf);
Assert.IsTrue(space >= 0);
Assert.IsTrue(H5S.get_simple_extent_ndims(space) == dims.Length);
hsize_t[] tdims = new hsize_t[dims.Length];
Assert.IsTrue(
H5S.get_simple_extent_dims(space, tdims, null) == dims.Length);
for (int i = 0; i < dims.Length; ++i)
{
Assert.IsTrue(tdims[i] == dims[i]);
}
Assert.IsTrue(H5S.close(space) >= 0);
}
public void AppendOrCreateDataset(Array dataset)
{
if (_chunkDims == null)
{
_chunkDims = new[]
{ Convert.ToUInt64(dataset.GetLongLength(0)), Convert.ToUInt64(dataset.GetLongLength(1)) };
Rank = dataset.Rank;
_currentDims = GetDims(dataset);
/* Create the data space with unlimited dimensions. */
_spaceId = H5S.create_simple(Rank, _currentDims, _maxDims);
/* Modify dataset creation properties, i.e. enable chunking */
_propId = H5P.create(H5P.DATASET_CREATE);
_status = H5P.set_chunk(_propId, Rank, _chunkDims);
/* Create a new dataset within the file using chunk creation properties. */
_datasetId = H5D.create(GroupId, Hdf5Utils.NormalizedName(Datasetname), _datatype, _spaceId, H5P.DEFAULT, _propId);
/* Write data to dataset */
GCHandle hnd = GCHandle.Alloc(dataset, GCHandleType.Pinned);
_status = H5D.write(_datasetId, _datatype, H5S.ALL, H5S.ALL, H5P.DEFAULT,
hnd.AddrOfPinnedObject());
hnd.Free();
H5S.close(_spaceId);
_spaceId = -1;
}
else
{
AppendDataset(dataset);
}
}
public static unsafe void AddSomeLinks(long fileId)
{
long res;
var groupId = H5G.create(fileId, "simple");
var groupId_sub = H5G.create(groupId, "sub");
// datasets
var dataspaceId1 = H5S.create_simple(1, new ulong[] { 1 }, new ulong[] { 1 });
var datasetId1 = H5D.create(fileId, "D", H5T.NATIVE_INT8, dataspaceId1);
var data1 = new byte[] { 1 };
fixed(void *ptr = data1)
{
res = H5D.write(datasetId1, H5T.NATIVE_INT8, dataspaceId1, dataspaceId1, 0, new IntPtr(ptr));
}
res = H5D.close(datasetId1);
res = H5S.close(dataspaceId1);
var dataspaceId2 = H5S.create_simple(1, new ulong[] { 1 }, new ulong[] { 1 });
var datasetId2 = H5D.create(groupId, "D1", H5T.NATIVE_INT8, dataspaceId2);
res = H5D.close(datasetId2);
res = H5S.close(dataspaceId2);
var dataspaceId3 = H5S.create_simple(1, new ulong[] { 1 }, new ulong[] { 1 });
var datasetId3 = H5D.create(groupId_sub, "D1.1", H5T.NATIVE_INT8, dataspaceId3);
res = H5D.close(datasetId3);
res = H5S.close(dataspaceId3);
res = H5G.close(groupId);
res = H5G.close(groupId_sub);
}
/// <summary>
/// 写数据集属性
/// </summary>
public void WriteDatasetAttribute(string datasetName, string attrName, string value)
{
H5DataSetId datasetId = H5D.open(_fileId, datasetName);
H5DataTypeId typeId = H5T.copy(H5T.H5Type.C_S1);
H5DataSpaceId spaceId = H5S.create(H5S.H5SClass.SCALAR);
H5T.setSize(typeId, value.Length);
H5AttributeId attrId = H5A.create(datasetId, attrName, typeId, spaceId);
if (value != "")
{
H5Array <byte> buffer = new H5Array <byte>(Encoding.Default.GetBytes(value));
H5A.write(attrId, typeId, buffer);
}
if (typeId != null)
{
H5T.close(typeId);
}
if (spaceId != null)
{
H5S.close(spaceId);
}
if (attrId != null)
{
H5A.close(attrId);
}
if (datasetId != null)
{
H5D.close(datasetId);
}
}
private static void AppendData <T>(hid_t dataSet, T[] data, ref int rows)
{
var fileSpace = H5D.get_space(dataSet);
if (fileSpace < 0)
{
throw new Exception("Failed to get data space of data set.");
}
var offset = new ulong[] { (ulong)rows };
var count = new ulong[] { (ulong)data.Length };
if (H5S.select_hyperslab(fileSpace, H5S.seloper_t.SET, offset, null, count, null) < 0)
{
throw new Exception("H5S.select_hyperslab failed.");
}
var memSpace = H5S.create_simple(1, count, null);
if (memSpace < 0)
{
throw new Exception("H5S.create_simple failed.");
}
if (H5D.write(dataSet, NumericTypeToHDF5Type <T>(), memSpace, fileSpace, H5P.DEFAULT, new PinnedObject(data)) < 0)
{
throw new Exception("H5D.write failed.");
}
H5S.close(memSpace);
H5S.close(fileSpace);
rows += data.Length;
}
public void H5DfillTest1()
{
hsize_t[] dims = { 10 };
hid_t space = H5S.create_simple(1, dims, null);
Assert.IsTrue(H5S.select_all(space) >= 0);
double[] v = new double[10];
double fill = 1.0;
GCHandle v_hnd = GCHandle.Alloc(v, GCHandleType.Pinned);
GCHandle fill_hnd = GCHandle.Alloc(fill, GCHandleType.Pinned);
Assert.IsTrue(
H5D.fill(fill_hnd.AddrOfPinnedObject(), H5T.NATIVE_DOUBLE,
v_hnd.AddrOfPinnedObject(), H5T.NATIVE_DOUBLE, space) >= 0);
fill_hnd.Free();
v_hnd.Free();
for (int i = 0; i < v.Length; ++i)
{
Assert.IsTrue(v[i] == 1.0);
}
Assert.IsTrue(H5S.close(space) >= 0);
}
public void H5Sget_select_hyper_blocklistTest1()
{
hsize_t[] dims = { 1, 2, 3 };
hid_t space = H5S.create_simple(dims.Length, dims, dims);
Assert.IsTrue(space > 0);
hsize_t[] start = { 0, 0, 0 };
hsize_t[] count = { 1, 1, 1 };
hsize_t[] block = { 1, 2, 3 };
Assert.IsTrue(
H5S.select_hyperslab(space, H5S.seloper_t.SET, start, null,
count, block) >= 0);
Assert.IsTrue(H5S.get_select_hyper_nblocks(space) == 1);
hsize_t[] buf = new hsize_t [2 * dims.Length];
Assert.IsTrue(
H5S.get_select_hyper_blocklist(space, 0, 1, buf) >= 0);
for (int i = 0; i < dims.Length; ++i)
{
buf[i] = 0;
buf[i + 3] = dims[i] - 1;
}
Assert.IsTrue(H5S.close(space) >= 0);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static Hdf5Dataspace GetDataspace(Hdf5Identifier _datasetId)
{
var dataspaceId = H5D.get_space(_datasetId.Value).ToId();
int rank = H5S.get_simple_extent_ndims(dataspaceId.Value);
ulong[] dims = new ulong[rank];
ulong[] maxDims = new ulong[rank];
H5S.get_simple_extent_dims(dataspaceId.Value, dims, maxDims);
Hdf5Dataspace dataspace = new Hdf5Dataspace
{
Id = dataspaceId,
NumberOfDimensions = rank
};
for (int i = 0; i < dims.Length; i++)
{
Hdf5DimensionProperty property = new Hdf5DimensionProperty
{
CurrentSize = dims[i],
//MaximumSize = maxDims[i]
};
dataspace.DimensionProperties.Add(property);
}
H5S.close(dataspaceId.Value);
return(dataspace);
}
public void H5Dcreate_anonTest2()
{
hsize_t[] dims = { 10, 10, 10 };
hsize_t[] max_dims = { H5S.UNLIMITED, H5S.UNLIMITED, H5S.UNLIMITED };
hid_t space = H5S.create_simple(3, dims, max_dims);
hid_t dcpl = H5P.create(H5P.DATASET_CREATE);
Assert.IsTrue(dcpl >= 0);
hsize_t[] chunk = { 64, 64, 64 };
Assert.IsTrue(H5P.set_chunk(dcpl, 3, chunk) >= 0);
Assert.IsTrue(H5P.set_deflate(dcpl, 9) >= 0);
hid_t dset = H5D.create_anon(m_v0_test_file, H5T.IEEE_F32BE,
space, dcpl);
Assert.IsTrue(dset >= 0);
Assert.IsTrue(H5D.close(dset) >= 0);
dset = H5D.create_anon(m_v2_test_file, H5T.IEEE_F32BE,
space, dcpl);
Assert.IsTrue(dset >= 0);
Assert.IsTrue(H5D.close(dset) >= 0);
Assert.IsTrue(H5P.close(dcpl) >= 0);
Assert.IsTrue(H5S.close(space) >= 0);
}
public void H5DiterateTest1()
{
int[] buf = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
IntPtr count_ptr = Marshal.AllocHGlobal(sizeof(int));
Marshal.WriteInt32(count_ptr, 0);
hsize_t[] dims = { 10 };
hid_t space = H5S.create_simple(1, dims, null);
Assert.IsTrue(space >= 0);
Assert.IsTrue(H5S.select_all(space) >= 0);
GCHandle buf_hnd = GCHandle.Alloc(buf, GCHandleType.Pinned);
H5D.operator_t cb = DelegateMethod;
Assert.IsTrue(
H5D.iterate(buf_hnd.AddrOfPinnedObject(), H5T.NATIVE_INT,
space, cb, count_ptr) >= 0);
buf_hnd.Free();
int count = Marshal.ReadInt32(count_ptr);
// expect the sum of the buffer elements
Assert.IsTrue(count == 45);
Assert.IsTrue(H5S.close(space) >= 0);
Marshal.FreeHGlobal(count_ptr);
}
// information: https://www.hdfgroup.org/ftp/HDF5/examples/examples-by-api/hdf5-examples/1_8/C/H5T/h5ex_t_cmpd.c
//or: https://www.hdfgroup.org/HDF5/doc/UG/HDF5_Users_Guide-Responsive%20HTML5/index.html#t=HDF5_Users_Guide%2FDatatypes%2FHDF5_Datatypes.htm%3Frhtocid%3Dtoc6.5%23TOC_6_8_Complex_Combinationsbc-22
public static int WriteCompounds <T>(hid_t groupId, string name, IEnumerable <T> list) //where T : struct
{
Type type = typeof(T);
var size = Marshal.SizeOf(type);
var cnt = list.Count();
var typeId = create_type(type);
var log10 = (int)Math.Log10(cnt);
ulong pow = (ulong)Math.Pow(10, log10);
ulong c_s = Math.Min(1000, pow);
ulong[] chunk_size = new ulong[] { c_s };
ulong[] dims = new ulong[] { (ulong)cnt };
long dcpl = 0;
if (list.Count() == 0 || log10 == 0)
{
}
else
{
dcpl = create_property(chunk_size);
}
// Create dataspace. Setting maximum size to NULL sets the maximum
// size to be the current size.
var spaceId = H5S.create_simple(dims.Length, dims, null);
// Create the dataset and write the compound data to it.
var datasetId = H5D.create(groupId, name, typeId, spaceId, H5P.DEFAULT, dcpl);
IntPtr p = Marshal.AllocHGlobal(size * (int)dims[0]);
var ms = new MemoryStream();
BinaryWriter writer = new BinaryWriter(ms);
foreach (var strct in list)
{
writer.Write(getBytes(strct));
}
var bytes = ms.ToArray();
GCHandle hnd = GCHandle.Alloc(bytes, GCHandleType.Pinned);
var statusId = H5D.write(datasetId, typeId, spaceId, H5S.ALL,
H5P.DEFAULT, hnd.AddrOfPinnedObject());
hnd.Free();
/*
* Close and release resources.
*/
H5D.close(datasetId);
H5S.close(spaceId);
H5T.close(typeId);
H5P.close(dcpl);
Marshal.FreeHGlobal(p);
return(statusId);
}
public void H5Dget_storage_sizeTest1()
{
hsize_t[] dims = { 1024, 2048 };
hid_t space = H5S.create_simple(2, dims, null);
hid_t dcpl = H5P.create(H5P.DATASET_CREATE);
Assert.IsTrue(dcpl >= 0);
Assert.IsTrue(
H5P.set_alloc_time(dcpl, H5D.alloc_time_t.EARLY) >= 0);
hid_t dset = H5D.create(m_v0_test_file, "dset", H5T.STD_I16LE,
space, H5P.DEFAULT, dcpl);
Assert.IsTrue(dset >= 0);
Assert.IsTrue(H5D.get_storage_size(dset) == 4194304);
Assert.IsTrue(H5D.close(dset) >= 0);
dset = H5D.create(m_v2_test_file, "dset", H5T.STD_I16LE,
space, H5P.DEFAULT, dcpl);
Assert.IsTrue(dset >= 0);
Assert.IsTrue(H5D.get_storage_size(dset) == 4194304);
Assert.IsTrue(H5D.close(dset) >= 0);
Assert.IsTrue(H5P.close(dcpl) >= 0);
Assert.IsTrue(H5S.close(space) >= 0);
}
private bool setOMXFileAttributes()
{
// write OMX attributes
H5DataSpaceId dspace;
H5DataTypeId dtype;
H5AttributeId attr;
// OMX version
dspace = H5S.create(H5S.H5SClass.SCALAR);
dtype = H5T.copy(H5T.H5Type.C_S1); // string datatype
H5T.setSize(dtype, dllVersion[0].Length);
attr = H5A.create(fileId, omxVersionName, dtype, dspace);
ASCIIEncoding ascii = new ASCIIEncoding();
H5A.write(attr, dtype, new H5Array <System.Byte>(ascii.GetBytes(dllVersion[0])));
H5A.close(attr);
// OMX shape - only 2D tables
dspace = H5S.create_simple(1, new long[] { 2 });
dtype = H5T.copy(H5T.H5Type.NATIVE_INT);
attr = H5A.create(fileId, omxShapeAttr, dtype, dspace);
int[] shape = new int[2];
shape[0] = (int)Shape[0];
shape[1] = (int)Shape[1];
H5A.write <int>(attr, dtype, new H5Array <int>(shape));
H5S.close(dspace);
H5A.close(attr);
return(true);
}
private void Write(H5GroupId parent, string name, IEnumerable <IMeasurement> measurements)
{
H5DataSpaceId spaceId = H5S.create_simple(1, new long[1] {
(long)measurements.Count()
});
// Set compression options for dataset
H5PropertyListId dataSetPropertyList = H5P.create(H5P.PropertyListClass.DATASET_CREATE);
H5P.setDeflate(dataSetPropertyList, NumericDataCompression);
H5P.setChunk(dataSetPropertyList, new long[] { (long)measurements.Count() });
H5DataSetId dataSetId = H5D.create(parent,
name,
measurement_t,
spaceId,
new H5PropertyListId(H5P.Template.DEFAULT),
dataSetPropertyList,
new H5PropertyListId(H5P.Template.DEFAULT));
MeasurementT[] ms = new MeasurementT[measurements.Count()];
int ilmCount = 0;
foreach (IMeasurement m in measurements)
{
MeasurementT mt = Convert(m);
ms[ilmCount++] = mt;
}
H5D.write <MeasurementT>(dataSetId, measurement_t, new H5Array <MeasurementT>(ms));
H5D.close(dataSetId);
H5S.close(spaceId);
}
public static int WritePrimitiveAttribute <T>(hid_t groupId, string name, Array attributes, string datasetName = null) //where T : struct
{
var tmpId = groupId;
if (!string.IsNullOrWhiteSpace(datasetName))
{
var datasetId = H5D.open(groupId, datasetName);
if (datasetId > 0)
{
groupId = datasetId;
}
}
int rank = attributes.Rank;
ulong[] dims = Enumerable.Range(0, rank).Select(i =>
{ return((ulong)attributes.GetLength(i)); }).ToArray();
ulong[] maxDims = null;
var spaceId = H5S.create_simple(rank, dims, maxDims);
var datatype = GetDatatype(typeof(T));
var typeId = H5T.copy(datatype);
var attributeId = H5A.create(groupId, name, datatype, spaceId);
GCHandle hnd = GCHandle.Alloc(attributes, GCHandleType.Pinned);
var result = H5A.write(attributeId, datatype, hnd.AddrOfPinnedObject());
hnd.Free();
H5A.close(attributeId);
H5S.close(spaceId);
H5T.close(typeId);
if (tmpId != groupId)
{
H5D.close(groupId);
}
return(result);
}
public void H5SencodeTest2()
{
size_t nalloc = IntPtr.Zero;
Assert.IsFalse(H5S.encode(Utilities.RandomInvalidHandle(),
null, ref nalloc) >= 0);
}
public static double[,] ReadFieldData2D(string file, string dataSet)
{
H5FileId fileId = H5F.open(file, H5F.OpenMode.ACC_RDONLY);
H5DataSetId fDataSetId = H5D.open(fileId, dataSet);
H5DataTypeId fDataTypeId = H5D.getType(fDataSetId);
long[] dims = H5S.getSimpleExtentDims(H5D.getSpace(fDataSetId)).ToArray();
double[,] data = new double[dims[0], dims[1]];
H5D.read(fDataSetId, fDataTypeId, new H5Array <double>(data));
double[,] fieldValues = new double[dims[1], dims[0]];
for (int i = 0; i < dims[1]; i++)
{
for (int j = 0; j < dims[0]; j++)
{
fieldValues[i, j] = (double)data[j, i];
}
}
H5T.close(fDataTypeId);
H5D.close(fDataSetId);
H5F.close(fileId);
return(fieldValues);
}
//Load weights from hdf5 file. Weights must be saved as a vector per layer
public static float[] loadH5(string path, string dsname)
{
//Get file id
var h5fid = H5F.open(path, H5F.OpenMode.ACC_RDONLY);
//Get dataset id
var h5did = H5D.open(h5fid, dsname);
//Dataset size
var h5space = H5D.getSpace(h5did);
var h5size = H5S.getSimpleExtentDims(h5space);
//Dataset size to array
var S = h5size.ToArray();
//Empty double array for the data
double[] data = new double[S[0]];
//Read the dataset
var h5array = new H5Array <double>(data);
var h5dtype = H5D.getType(h5did);
H5D.read(h5did, h5dtype, h5array);
//Convert to float
float[] newarray = new float[data.Length];
Parallel.For(0, data.Length, (k) =>
{
newarray[k] = (float)data[k];
});
return(newarray);
}
public static double ReadAttribute(string file, string dataSetOrGroup, string attribute)
{
double attr = Double.NaN;
try
{
H5FileId fileId = H5F.open(file, H5F.OpenMode.ACC_RDONLY);
H5ObjectInfo objectInfo = H5O.getInfoByName(fileId, dataSetOrGroup);
H5GroupId groupId = null;
H5DataSetId dataSetId = null;
H5AttributeId attrId;
if (objectInfo.objectType == H5ObjectType.GROUP)
{
groupId = H5G.open(fileId, dataSetOrGroup);
attrId = H5A.open(groupId, attribute);
}
else
{
dataSetId = H5D.open(fileId, dataSetOrGroup);
attrId = H5A.open(dataSetId, attribute);
}
H5DataTypeId attrTypeId = H5A.getType(attrId);
double[] dAttrs = new double[] { };
if (H5T.equal(attrTypeId, H5T.copy(H5T.H5Type.NATIVE_FLOAT)))
{
float[] fAttrs = new float[H5S.getSimpleExtentNPoints(H5A.getSpace(attrId))];
H5A.read(attrId, attrTypeId, new H5Array <float>(fAttrs));
dAttrs = (from f in fAttrs select(double) f).ToArray();
}
else if (H5T.equal(attrTypeId, H5T.copy(H5T.H5Type.NATIVE_DOUBLE)))
{
dAttrs = new double[H5S.getSimpleExtentNPoints(H5A.getSpace(attrId))];
H5A.read(attrId, attrTypeId, new H5Array <double>(dAttrs));
}
H5T.close(attrTypeId);
H5A.close(attrId);
if (groupId != null)
{
H5G.close(groupId);
}
if (dataSetId != null)
{
H5D.close(dataSetId);
}
H5F.close(fileId);
return((double)dAttrs[0]);
}
catch (HDFException e)
{
Console.WriteLine("Error: Unhandled HDF5 exception");
Console.WriteLine(e.Message);
}
return(attr);
}
public void FirstDataset(Array dataset)
{
if (FalseGroupId)
{
throw new Exception("cannot call FirstDataset because group or file couldn't be created");
}
if (DatasetExists)
{
throw new Exception("cannot call FirstDataset because dataset already exists");
}
Rank = dataset.Rank;
currentDims = GetDims(dataset);
/* Create the data space with unlimited dimensions. */
spaceId = H5S.create_simple(Rank, currentDims, maxDims);
/* Modify dataset creation properties, i.e. enable chunking */
propId = H5P.create(H5P.DATASET_CREATE);
status = H5P.set_chunk(propId, Rank, chunkDims);
/* Create a new dataset within the file using chunk creation properties. */
datasetId = H5D.create(GroupId, Datasetname, datatype, spaceId, H5P.DEFAULT, propId, H5P.DEFAULT);
/* Write data to dataset */
GCHandle hnd = GCHandle.Alloc(dataset, GCHandleType.Pinned);
status = H5D.write(datasetId, datatype, H5S.ALL, H5S.ALL, H5P.DEFAULT,
hnd.AddrOfPinnedObject());
hnd.Free();
H5S.close(spaceId);
}
public static double[, ,] ReadFieldData3D(string fileName)
{
H5FileId fileId = H5F.open(fileName, H5F.OpenMode.ACC_RDONLY);
H5DataSetId fDataSetId = H5D.open(fileId, "/FieldData/FD/f0");
H5DataTypeId fDataTypeId = H5D.getType(fDataSetId);
if (!H5T.equal(fDataTypeId, H5T.copy(H5T.H5Type.NATIVE_FLOAT)))
{
Console.WriteLine("Error: Invalid dataset type, expected {0}", H5T.H5Type.NATIVE_FLOAT);
}
long[] dims = H5S.getSimpleExtentDims(H5D.getSpace(fDataSetId)).ToArray();
if (dims.Length != 3)
{
Console.WriteLine("Error: Invalid field data dimensions");
}
float[, ,] data = new float[dims[0], dims[1], dims[2]];
H5D.read(fDataSetId, fDataTypeId, new H5Array <float>(data));
// Reorder
double[, ,] fieldValues = new double[dims[2], dims[1], dims[0]];
for (int i = 0; i < dims[0]; i++)
{
for (int j = 0; j < dims[1]; j++)
{
for (int k = 0; k < dims[2]; k++)
{
fieldValues[k, j, i] = data[i, j, k];
}
}
}
return(fieldValues);
}
public static unsafe void AddDataspaceNull(long fileId, ContainerType container)
{
var spaceId = H5S.create(H5S.class_t.NULL);
TestUtils.Add(container, fileId, "dataspace", "null", H5T.NATIVE_DOUBLE, null, spaceId);
H5S.close(spaceId);
}
public static int WriteDatasetFromArray <T>(hid_t groupId, string name, Array dset, string datasetName = null) //where T : struct
{
int rank = dset.Rank;
ulong[] dims = Enumerable.Range(0, rank).Select(i => { return((ulong)dset.GetLength(i)); }).ToArray();
ulong[] maxDims = null;
var spaceId = H5S.create_simple(rank, dims, maxDims);
var datatype = GetDatatype(typeof(T));
var typeId = H5T.copy(datatype);
if (datatype == H5T.C_S1)
{
H5T.set_size(datatype, new IntPtr(2));
}
var datasetId = H5D.create(groupId, name, datatype, spaceId);
GCHandle hnd = GCHandle.Alloc(dset, GCHandleType.Pinned);
var result = H5D.write(datasetId, datatype, H5S.ALL, H5S.ALL, H5P.DEFAULT,
hnd.AddrOfPinnedObject());
hnd.Free();
H5D.close(datasetId);
H5S.close(spaceId);
H5T.close(typeId);
return(result);
}
public void Put(Array data, ulong[] location = null)
{
ulong[] shape = data.Shape();
WithDataSpace((h5Ref, dsRef) =>
{
long memDataSpace = H5S.ALL;
if (location != null)
{
int selection = H5S.select_none(dsRef);
if (selection < 0)
{
throw new H5SSException("Couldn't clear dataspace selection");
}
ulong[] stride = Ones(shape.Length);
selection = H5S.select_hyperslab(dsRef,
H5S.seloper_t.SET,
location,
stride,
stride,
shape
);
if (selection < 0)
{
throw new H5SSException("Couldn't select hyperslab");
}
memDataSpace = H5S.create_simple(shape.Length, shape, shape);
}
IntPtr iPtr;
var effectiveSize = data.Length * ElementSize;
//if (DataType == HDF5DataType.String)
//{
// // Convert to byte array...
//}
//else
//{
//}
var dtype = H5D.get_type(h5Ref); // Return?
iPtr = CreateNativeArray(data, dtype);
// copy to unmanaged array?
var success = H5D.write(h5Ref, dtype, memDataSpace, dsRef, H5P.DEFAULT, iPtr);
H5T.close(dtype);
if (location != null)
{
H5S.close(memDataSpace);
}
Marshal.FreeHGlobal(iPtr);
if (success < 0)
{
throw new H5SSException(string.Format("Couldn't write to dataset: {0}", this.Path));
}
});
}
private unsafe void WriteData(ulong fileOffset, ulong bufferOffset, ulong length, ChannelContext channelContext)
{
Contract.Requires(channelContext != null, nameof(channelContext));
long groupId = -1;
long datasetId = -1;
long dataspaceId = -1;
long dataspaceId_Buffer = -1;
try
{
groupId = H5G.open(_fileId, $"/{ channelContext.ChannelDescription.ChannelName }");
var datasetName = $"dataset_{ channelContext.ChannelDescription.DatasetName.Replace(" ", "_") }";
datasetId = H5D.open(groupId, datasetName);
dataspaceId = H5D.get_space(datasetId);
dataspaceId_Buffer = H5S.create_simple(1, new ulong[] { length }, null);
var simpleBuffers = channelContext.Buffer.ToSimpleBuffer();
// dataset
H5S.select_hyperslab(dataspaceId,
H5S.seloper_t.SET,
new ulong[] { fileOffset },
new ulong[] { 1 },
new ulong[] { 1 },
new ulong[] { length });
var offset = (int)bufferOffset * simpleBuffers.ElementSize;
var buffer = simpleBuffers.RawBuffer[offset..];
private static Hdf5Container_LidarDaimler ReadContainer(string sFilePath_inp)
{
int status = 0;
long file_id = H5F.open(sFilePath_inp, H5F.ACC_RDWR);
long testDataset_id = H5D.open(file_id, "distance");
long testDataspace_id = H5D.get_space(testDataset_id);
ulong[] dims = new ulong[2];
status = H5S.get_simple_extent_dims(testDataspace_id, dims, null);
int rows = Convert.ToInt32(dims[0]);
int cols = Convert.ToInt32(dims[1]);
Hdf5Container_LidarDaimler outContainer = new Hdf5Container_LidarDaimler(rows, cols)
{
_distances = Hdf5IO.GetFloatDataset(H5D.open(file_id, "distance"), rows, cols),
_intensity = Hdf5IO.GetFloatDataset(H5D.open(file_id, "intensity"), rows, cols),
_labelProbabilities = Hdf5IO.GetFloatDataset(H5D.open(file_id, "labelProbabilities"), rows, cols),
_labelWorkingSet = Hdf5IO.GetLabelWorkingSet(H5G.open(file_id, "labelWorkingSet")),
_labels = Hdf5IO.GetUintDataset(H5D.open(file_id, "labels"), rows, cols),
_pointValid = Hdf5IO.GetIntDataset(H5D.open(file_id, "pointValid"), rows, cols),
_sensorX = Hdf5IO.GetFloatDataset(H5D.open(file_id, "sensorX"), rows, cols),
_sensorY = Hdf5IO.GetFloatDataset(H5D.open(file_id, "sensorY"), rows, cols),
_sensorZ = Hdf5IO.GetFloatDataset(H5D.open(file_id, "sensorZ"), rows, cols),
_vehicleX = Hdf5IO.GetFloatDataset(H5D.open(file_id, "vehicleX"), rows, cols),
_vehicleY = Hdf5IO.GetFloatDataset(H5D.open(file_id, "vehicleY"), rows, cols),
_vehicleZ = Hdf5IO.GetFloatDataset(H5D.open(file_id, "vehicleZ"), rows, cols)
};
status = H5F.close(file_id);
return(outContainer);
}
private static void WriteAttribute(H5ObjectWithAttributes target, string name, string value)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Name must not be empty (or null)", "name");
}
if (string.IsNullOrEmpty(value))
{
throw new ArgumentException("Value must not be empty or null", "value");
}
H5DataTypeId dtype;
byte[] strdata = EncodeStringData(value, out dtype);
H5DataSpaceId spaceId = H5S.create(H5S.H5SClass.SCALAR);
H5AttributeId attributeId = H5A.create(target, name, dtype, spaceId);
H5A.write(attributeId, dtype, new H5Array <byte>(strdata));
H5A.close(attributeId);
H5T.close(dtype);
H5S.close(spaceId);
}
/// <summary>
/// Dispose function as suggested in the stackoverflow discussion below
/// See: http://stackoverflow.com/questions/538060/proper-use-of-the-idisposable-interface/538238#538238
/// </summary>
/// <param name="itIsSafeToAlsoFreeManagedObjects"></param>
protected virtual void Dispose(bool itIsSafeToAlsoFreeManagedObjects)
{
if (!Hdf5Utils.GetRealName(GroupId, Datasetname, string.Empty).valid)
{
Hdf5Utils.LogInfo?.Invoke("Dataset does not exist.");
return;
}
if (_datasetId >= 0)
{
H5D.close(_datasetId);
}
if (_propId >= 0)
{
H5P.close(_propId);
}
if (_spaceId >= 0)
{
H5S.close(_spaceId);
}
if (itIsSafeToAlsoFreeManagedObjects)
{
}
}
public void H5Dget_spaceTest1()
{
hsize_t[] dims = { 1024, 2048 };
hid_t space = H5S.create_simple(3, dims, null);
hid_t dset = H5D.create(m_v0_test_file, "dset", H5T.STD_I16LE,
space);
Assert.IsTrue(dset >= 0);
hid_t space1 = H5D.get_space(dset);
Assert.IsTrue(space1 >= 0);
Assert.IsTrue(H5S.extent_equal(space, space1) > 0);
Assert.IsTrue(H5S.close(space1) >= 0);
Assert.IsTrue(H5D.close(dset) >= 0);
dset = H5D.create(m_v2_test_file, "dset", H5T.STD_I16LE,
space);
Assert.IsTrue(dset >= 0);
space1 = H5D.get_space(dset);
Assert.IsTrue(space1 >= 0);
Assert.IsTrue(H5S.extent_equal(space, space1) > 0);
Assert.IsTrue(H5S.close(space1) >= 0);
Assert.IsTrue(H5D.close(dset) >= 0);
Assert.IsTrue(H5S.close(space) >= 0);
}
