Example #1
0
        public void H5Dget_typeTest1()
        {
            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 type = H5D.get_type(dset);

            Assert.IsTrue(type >= 0);
            Assert.IsTrue(H5T.equal(type, H5T.STD_I16LE) > 0);
            Assert.IsTrue(H5T.close(type) >= 0);
            Assert.IsTrue(H5D.close(dset) >= 0);

            dset = H5D.create(m_v2_test_file, "dset", H5T.STD_I16LE,
                              space);
            Assert.IsTrue(dset >= 0);
            type = H5D.get_type(dset);
            Assert.IsTrue(type >= 0);
            Assert.IsTrue(H5T.equal(type, H5T.STD_I16LE) > 0);
            Assert.IsTrue(H5T.close(type) >= 0);
            Assert.IsTrue(H5D.close(dset) >= 0);

            Assert.IsTrue(H5S.close(space) >= 0);
        }
Example #2
0
        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));
                }
            });
        }
Example #3
0
        private static double[,] ReadDataArray(hid_t fileLoc, string name, bool transpose = false)
        {
            hid_t dset   = H5D.open(fileLoc, name);
            hid_t fspace = H5D.get_space(dset);
            hid_t count  = H5S.get_simple_extent_ndims(fspace);

            hid_t type = H5D.get_type(dset);

            hsize_t[] dims    = new hsize_t[count];
            hsize_t[] maxdims = new hsize_t[count];

            H5S.get_simple_extent_dims(fspace, dims, maxdims);
            H5S.close(fspace);


            byte[] rdata = new byte[dims[0] * dims[1] * 8];

            hid_t mem_type = H5T.copy(H5T.NATIVE_DOUBLE);

            H5T.set_size(mem_type, new IntPtr(8));

            GCHandle hnd = GCHandle.Alloc(rdata, GCHandleType.Pinned);

            H5D.read(dset, mem_type, H5S.ALL,
                     H5S.ALL, H5P.DEFAULT, hnd.AddrOfPinnedObject());

            hnd.Free();

            H5T.close(mem_type);

            if (transpose)
            {
                double[,] val = new double[dims[1], dims[0]];
                int cnt = 0;
                for (int i = 0; i < (int)dims[0]; i++)
                {
                    for (int j = 0; j < (int)dims[1]; j++)
                    {
                        val[j, i] = BitConverter.ToDouble(rdata, cnt * 8);
                        cnt++;
                    }
                }
                return(val);
            }
            else
            {
                double[,] val = new double[dims[0], dims[1]];
                int cnt = 0;
                for (int i = 0; i < (int)dims[0]; i++)
                {
                    for (int j = 0; j < (int)dims[1]; j++)
                    {
                        val[i, j] = BitConverter.ToDouble(rdata, cnt * 8);
                        cnt++;
                    }
                }
                return(val);
            }
        }
Example #4
0
        public Dictionary <string, string> TryReadDataTable(string datasetName)
        {
            Dictionary <string, string> result = null;
            var subDsDic = ds.GetSubDatasets();

            if (subDsDic.Count > 0)
            {
                H5ID h5FileId  = H5F.open(fileName, H5F.ACC_RDONLY);
                H5ID datasetId = H5D.open(h5FileId, datasetName);
                H5ID typeId    = H5D.get_type(datasetId);
                H5ID spaceId   = H5D.get_space(datasetId);
                if (H5T.get_class(typeId) == H5T.class_t.COMPOUND)
                {
                    int      numCount = H5T.get_nmembers(typeId);
                    var      size     = H5T.get_size(typeId);
                    byte[]   buffer   = new byte[size.ToInt32()];
                    GCHandle hnd      = GCHandle.Alloc(buffer, GCHandleType.Pinned);
                    int      ndims    = H5S.get_simple_extent_ndims(spaceId);
                    if (ndims == 1)
                    {
                        result = new Dictionary <string, string>();
                        H5D.read(datasetId, typeId, H5S.ALL, H5S.ALL, H5P.DEFAULT, hnd.AddrOfPinnedObject());

                        for (uint i = 0; i < numCount; i++)
                        {
                            string name   = Marshal.PtrToStringAnsi(H5T.get_member_name(typeId, i));
                            int    offset = H5T.get_member_offset(typeId, i).ToInt32();

                            H5ID        subTypeId = H5T.get_member_type(typeId, i);
                            H5T.class_t typeClass = H5T.get_member_class(typeId, i);
                            string      value     = ReadBuffer(buffer, offset, typeClass, subTypeId);
                            result.Add(name, value);
                            H5T.close(subTypeId);
                        }
                    }

                    hnd.Free();
                }

                if (spaceId != 0)
                {
                    H5S.close(spaceId);
                }
                if (typeId != 0)
                {
                    H5T.close(typeId);
                }
                if (datasetId != 0)
                {
                    H5D.close(datasetId);
                }
                if (h5FileId != 0)
                {
                    H5F.close(h5FileId);
                }
            }

            return(result);
        }
Example #5
0
        /// <summary>
        /// WARNING: ADVANCED USE ONLY!! Loads a 2D generic dataset from an H5 file.
        /// The generic loaders only loads data in non-Unity friendly types, such as bytes, uints, longs etc...
        /// You'll have to know the correct cast to retrieve usable data.
        ///
        /// Created With help from https://github.com/LiorBanai/HDF5-CSharp/blob/master/HDF5-CSharp/Hdf5Dataset.cs
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="datasetName"></param>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        /// <exception cref="FileNotFoundException"></exception>
        static T[,] Load2DDataset <T>(string filePath, string datasetName)
        {
            if (!File.Exists(filePath))
            {
                throw new FileNotFoundException($"Loading dataset {datasetName} from file that doesn't exist {filePath}");
            }
            long fileId = H5F.open(filePath, H5F.ACC_RDONLY);

            T[,] resultArray = new T[2, 2];
            try {
                ulong[] start = { 0, 0 };
                ulong[] count = { 0, 0 };

                long    datasetId = H5D.open(fileId, datasetName);
                var     datatype  = H5D.get_type(datasetId);
                var     spaceId   = H5D.get_space(datasetId);
                int     rank      = H5S.get_simple_extent_ndims(spaceId);
                ulong[] maxDims   = new ulong[rank];
                ulong[] dims      = new ulong[rank];
                H5S.get_simple_extent_dims(spaceId, dims, maxDims);

                count[0] = dims[0];
                count[1] = dims[1];

                // Define file hyperslab.
                long status = H5S.select_hyperslab(spaceId, H5S.seloper_t.SET, start, null, count, null);

                // Define the memory dataspace.
                resultArray = new T[dims[0], dims[1]];
                var memId = H5S.create_simple(rank, dims, null);

                // Define memory hyperslab.
                status = H5S.select_hyperslab(memId, H5S.seloper_t.SET, start, null,
                                              count, null);

                // Read data from hyperslab in the file into the hyperslab in
                // memory and display.
                GCHandle handle = GCHandle.Alloc(resultArray, GCHandleType.Pinned);

                try {
                    H5D.read(datasetId, datatype, memId, spaceId,
                             H5P.DEFAULT, handle.AddrOfPinnedObject());
                }
                finally {
                    handle.Free();
                    H5S.close(status);
                    H5S.close(memId);
                    H5S.close(spaceId);
                    H5D.close(datatype);
                    H5D.close(datasetId);
                }
            }
            finally {
                H5F.close(fileId);
            }
            return(resultArray);
        }
Example #6
0
        private void UpdateVariableInfo(FileContext fileContext, long variableGroupId)
        {
            ulong idx;

            idx = 0;

            _variableGroupSet = IOHelper.UpdateAttributeList(variableGroupId, "group_set", _variableGroupSet.ToArray()).ToList();

            if (fileContext.FormatVersion != 1)
            {
                _unitSet             = IOHelper.UpdateAttributeList(variableGroupId, "unit_set", _unitSet.ToArray()).ToList();
                _transferFunctionSet = IOHelper.UpdateAttributeList(variableGroupId, "transfer_function_set", _transferFunctionSet.ToArray()).ToList();
            }

            H5L.iterate(variableGroupId, H5.index_t.NAME, H5.iter_order_t.INC, ref idx, Callback, IntPtr.Zero);

            int Callback(long variableGroupId2, IntPtr intPtrName, ref H5L.info_t info, IntPtr userDataPtr)
            {
                long   datasetId           = -1;
                long   typeId_do_not_close = -1;
                string name;

                DatasetInfo currentDatasetInfo;

                try
                {
                    name = Marshal.PtrToStringAnsi(intPtrName);

                    if (H5L.exists(variableGroupId2, name) > 0)
                    {
                        datasetId = H5D.open(variableGroupId2, name);

                        currentDatasetInfo = _datasetInfoSet.FirstOrDefault(datasetInfo => datasetInfo.Name == name);

                        if (currentDatasetInfo == null)
                        {
                            typeId_do_not_close = H5D.get_type(datasetId);
                            currentDatasetInfo  = new DatasetInfo(name, typeId_do_not_close, this, this.IsLazyLoading);

                            _datasetInfoSet.Add(currentDatasetInfo);
                        }

                        currentDatasetInfo.Update(fileContext);
                    }
                }
                finally
                {
                    if (H5I.is_valid(datasetId) > 0)
                    {
                        H5D.close(datasetId);
                    }
                }

                return(0);
            }
        }
Example #7
0
        private static bool IsHDF5String(hid_t fileLoc, string name)
        {
            hid_t dset = H5D.open(fileLoc, name);
            hid_t type = H5D.get_type(dset);

            H5T.class_t cl = H5T.get_class(type);


            return(cl == H5T.class_t.STRING);
        }
Example #8
0
        /// <summary>
        /// Returns the datatype.
        /// This assumes that the object is already open
        /// </summary>
        /// <param name="_objectId"></param>
        /// <returns></returns>
        public static Hdf5DataType GetDataTypeFromDataset(Hdf5Identifier _objectId)
        {
            var typeId = H5D.get_type(_objectId.Value).ToId();

            if (typeId.Value > 0)
            {
                return(GetDataTypeByType(typeId));
            }

            return(null);
        }
Example #9
0
        private ISimpleDataStorage LoadDataset(long sourceFileId, string datasetPath, ulong start, ulong stride, ulong block, ulong count)
        {
            long datasetId = -1;
            long typeId    = -1;

            Array dataset;
            Array dataset_status;

            Type genericType;

            ExtendedDataStorageBase extendedDataStorage;
            ISimpleDataStorage      simpleDataStorage;

            dataset = IOHelper.ReadDataset(sourceFileId, datasetPath, start, stride, block, count);

            // apply status (only if native dataset)
            if (H5L.exists(sourceFileId, datasetPath + "_status") > 0)
            {
                try
                {
                    datasetId = H5D.open(sourceFileId, datasetPath);
                    typeId    = H5D.get_type(datasetId);

                    dataset_status = IOHelper.ReadDataset(sourceFileId, datasetPath + "_status", start, stride, block, count).Cast <byte>().ToArray();

                    genericType         = typeof(ExtendedDataStorage <>).MakeGenericType(TypeConversionHelper.GetTypeFromHdfTypeId(typeId));
                    extendedDataStorage = (ExtendedDataStorageBase)Activator.CreateInstance(genericType, dataset, dataset_status);

                    dataset_status = null;
                }
                finally
                {
                    if (H5I.is_valid(datasetId) > 0)
                    {
                        H5D.close(datasetId);
                    }
                    if (H5I.is_valid(typeId) > 0)
                    {
                        H5T.close(typeId);
                    }
                }

                simpleDataStorage = extendedDataStorage.ToSimpleDataStorage();
                extendedDataStorage.Dispose();

                return(simpleDataStorage);
            }
            else
            {
                return(new SimpleDataStorage(dataset.Cast <double>().ToArray()));
            }
        }
        /// <summary>
        /// Reads an n-dimensional dataset.
        /// </summary>
        /// <typeparam name="T">Generic parameter strings or primitive type</typeparam>
        /// <param name="groupId">id of the group. Can also be a file Id</param>
        /// <param name="name">name of the dataset</param>
        /// <returns>The n-dimensional dataset</returns>
        public static Array ReadDatasetToArray <T>(hid_t groupId, string name) //where T : struct
        {
            var datatype = GetDatatype(typeof(T));


            var   datasetId = H5D.open(groupId, name);
            var   spaceId   = H5D.get_space(datasetId);
            int   rank      = H5S.get_simple_extent_ndims(spaceId);
            long  count     = H5S.get_simple_extent_npoints(spaceId);
            Array dset;
            Type  type = typeof(T);

            if (rank >= 0 && count >= 0)
            {
                int     rankChunk;
                ulong[] maxDims   = new ulong[rank];
                ulong[] dims      = new ulong[rank];
                ulong[] chunkDims = new ulong[rank];
                hid_t   memId     = H5S.get_simple_extent_dims(spaceId, dims, maxDims);
                long[]  lengths   = dims.Select(d => Convert.ToInt64(d)).ToArray();
                dset = Array.CreateInstance(type, lengths);
                var typeId   = H5D.get_type(datasetId);
                var mem_type = H5T.copy(datatype);
                if (datatype == H5T.C_S1)
                {
                    H5T.set_size(datatype, new IntPtr(2));
                }

                var propId = H5D.get_create_plist(datasetId);

                if (H5D.layout_t.CHUNKED == H5P.get_layout(propId))
                {
                    rankChunk = H5P.get_chunk(propId, rank, chunkDims);
                }

                memId = H5S.create_simple(rank, dims, maxDims);
                GCHandle hnd = GCHandle.Alloc(dset, GCHandleType.Pinned);
                H5D.read(datasetId, datatype, memId, spaceId,
                         H5P.DEFAULT, hnd.AddrOfPinnedObject());
                hnd.Free();
            }
            else
            {
                dset = Array.CreateInstance(type, new long[1] {
                    0
                });
            }
            H5D.close(datasetId);
            H5S.close(spaceId);
            return(dset);
        }
Example #11
0
        public static (bool success, IEnumerable <string> result) ReadStrings(long groupId, string name, string alternativeName)
        {
            var datasetId = H5D.open(groupId, Hdf5Utils.NormalizedName(name));

            if (datasetId < 0) //does not exist?
            {
                datasetId = H5D.open(groupId, Hdf5Utils.NormalizedName(alternativeName));
            }

            if (datasetId <= 0)
            {
                Hdf5Utils.LogError?.Invoke($"Error reading {groupId}. Name:{name}. AlternativeName:{alternativeName}");
                return(false, Array.Empty <string>());
            }
            long typeId  = H5D.get_type(datasetId);
            long spaceId = H5D.get_space(datasetId);
            long count   = H5S.get_simple_extent_npoints(spaceId);

            H5S.close(spaceId);

            var strs = new List <string>();

            if (count >= 0)
            {
                IntPtr[] rdata = new IntPtr[count];
                GCHandle hnd   = GCHandle.Alloc(rdata, GCHandleType.Pinned);
                H5D.read(datasetId, typeId, H5S.ALL, H5S.ALL,
                         H5P.DEFAULT, hnd.AddrOfPinnedObject());

                for (int i = 0; i < rdata.Length; ++i)
                {
                    int len = 0;
                    while (Marshal.ReadByte(rdata[i], len) != 0)
                    {
                        ++len;
                    }
                    byte[] buffer = new byte[len];
                    Marshal.Copy(rdata[i], buffer, 0, buffer.Length);
                    string s = Hdf5Utils.ReadStringBuffer(buffer);

                    strs.Add(s);

                    // H5.free_memory(rdata[i]);
                }
                hnd.Free();
            }
            H5T.close(typeId);
            H5D.close(datasetId);
            return(true, strs);
        }
Example #12
0
        public static (long DatasetId, bool IsNew) OpenOrCreateDataset(long locationId, string datasetPath, long datasetTypeId, Func <long> createDatasetCallback)
        {
            Contract.Requires(createDatasetCallback != null);

            long datasetId            = -1;
            long datasetTypeId_actual = -1;

            bool isNew;

            try
            {
                if (IOHelper.CheckLinkExists(locationId, datasetPath))
                {
                    datasetId            = H5D.open(locationId, datasetPath);
                    datasetTypeId_actual = H5D.get_type(datasetId);

                    if (H5T.equal(datasetTypeId_actual, datasetTypeId) <= 0)
                    {
                        throw new Exception($"{ ErrorMessage.IOHelper_DataTypeMismatch } Dataset: '{ datasetPath }'.");
                    }

                    isNew = false;
                }
                else
                {
                    datasetId = createDatasetCallback.Invoke();

                    isNew = true;
                }

                if (H5I.is_valid(datasetId) <= 0)
                {
                    throw new Exception($"{ ErrorMessage.IOHelper_CouldNotOpenOrCreateDataset } Dataset: '{ datasetPath }'.");
                }
            }
            finally
            {
                if (H5I.is_valid(datasetTypeId_actual) > 0)
                {
                    H5T.close(datasetTypeId_actual);
                }
            }

            return(datasetId, isNew);
        }
Example #13
0
        public float[] TryReadFactor(AbstractWarpDataset ds, string datasetName)
        {
            string dsPath = (ds.hdfOperator as Hdf5Operator).GetDatasetNames.Where(t => t.Contains(datasetName))
                            .FirstOrDefault();

            float[] factor    = null;
            int     h5FileId  = H5F.open(ds.fileName, H5F.ACC_RDONLY);
            int     datasetId = H5D.open(h5FileId, dsPath);
            int     typeId    = H5D.get_type(datasetId);
            int     spaceId   = H5D.get_space(datasetId);

            if (H5T.get_class(typeId) == H5T.class_t.FLOAT)
            {
                var     size = H5T.get_size(typeId);
                int     rank = H5S.get_simple_extent_ndims(spaceId);
                ulong[] dims = new ulong[rank];
                int     err  = H5S.get_simple_extent_dims(spaceId, dims, null);
                factor = new float[dims[0]];
                GCHandle hnd = GCHandle.Alloc(factor, GCHandleType.Pinned);
                H5D.read(datasetId, typeId, H5S.ALL, H5S.ALL, H5P.DEFAULT, hnd.AddrOfPinnedObject());

                hnd.Free();
            }

            if (spaceId != 0)
            {
                H5S.close(spaceId);
            }
            if (typeId != 0)
            {
                H5T.close(typeId);
            }
            if (datasetId != 0)
            {
                H5D.close(datasetId);
            }
            if (h5FileId != 0)
            {
                H5F.close(h5FileId);
            }
            return(factor);
        }
Example #14
0
        public static T[,] ReadDataset <T>(int groupId, string name) where T : struct
        {
            var      datatype = GetDatatype(typeof(T));

            name = ToHdf5Name(name);

            var      datasetId = H5D.open(groupId, name);
            var      spaceId   = H5D.get_space(datasetId);
            int      rank      = H5S.get_simple_extent_ndims(spaceId);
            long     count     = H5S.get_simple_extent_npoints(spaceId);
            int      rankChunk;
            ulong[]  maxDims   = new ulong[rank];
            ulong[]  dims      = new ulong[rank];
            ulong[]  chunkDims = new ulong[rank];
            var      memId     = H5S.get_simple_extent_dims(spaceId, dims, maxDims);
            T[,] dset = new T[dims[0], dims[1]];
            var      typeId   = H5D.get_type(datasetId);
            var      mem_type = H5T.copy(datatype);
            if (datatype == H5T.C_S1)
            {
                H5T.set_size(datatype, new IntPtr(2));
            }

            var      propId = H5D.get_create_plist(datasetId);

            if (H5D.layout_t.CHUNKED == H5P.get_layout(propId))
            {
                rankChunk = H5P.get_chunk(propId, rank, chunkDims);
            }

            memId = H5S.create_simple(rank, dims, maxDims);
            GCHandle hnd = GCHandle.Alloc(dset, GCHandleType.Pinned);
            H5D.read(datasetId, datatype, memId, spaceId,
                     H5P.DEFAULT, hnd.AddrOfPinnedObject());
            hnd.Free();
            H5D.close(typeId);
            H5D.close(datasetId);
            H5S.close(spaceId);
            return(dset);
        }
Example #15
0
        private static string ReadDataCharArray(hid_t fileLoc, string name)
        {
            hid_t dset   = H5D.open(fileLoc, name);
            hid_t fspace = H5D.get_space(dset);
            hid_t count  = H5S.get_simple_extent_ndims(fspace);

            hid_t type = H5D.get_type(dset);


            hsize_t[] dims    = new hsize_t[count];
            hsize_t[] maxdims = new hsize_t[count];

            H5S.get_simple_extent_dims(fspace, dims, maxdims);
            H5S.close(fspace);


            byte[] rdata = new byte[dims[0]];

            hid_t mem_type = H5T.copy(type);

            H5T.set_size(mem_type, new IntPtr(1));

            GCHandle hnd = GCHandle.Alloc(rdata, GCHandleType.Pinned);

            H5D.read(dset, mem_type, H5S.ALL,
                     H5S.ALL, H5P.DEFAULT, hnd.AddrOfPinnedObject());

            hnd.Free();

            H5T.close(mem_type);

            char[] val = new char[dims[0]];
            for (int i = 0; i < (int)dims[0]; i += 2)
            {
                val[i] = BitConverter.ToChar(rdata, i);
            }


            return(val.ToString());
        }
Example #16
0
        public static IEnumerable ReadStrings(string filename, string dataset)
        {
            var f = H5F.open(filename, H5F.ACC_RDONLY);

            if (f < 0)
            {
                throw new Exception("Could not open file: " + filename);
            }

            var dset = H5D.open(f, Encoding.ASCII.GetBytes(dataset), H5P.DEFAULT);

            if (dset < 0)
            {
                throw new Exception("Could not open dataset: " + dataset);
            }

            var filetype = H5D.get_type(dset);
            var sdim     = H5T.get_size(filetype) + 1;

            var space = H5D.get_space(dset);
            var ndims = H5S.get_simple_extent_ndims(space);

            ulong[] dims = new ulong[ndims];
            H5S.get_simple_extent_dims(space, dims, null);
            var memtype = H5T.copy(H5T.C_S1);
            var status  = H5T.set_size(memtype, sdim);

            int len = (int)(dims[0] * (ulong)sdim * SIZEOF_CHAR);

            byte[] buffer = new byte[len];
            IntPtr ptr    = Marshal.AllocHGlobal(len);

            status = H5D.read(dset, memtype, H5S.ALL, H5S.ALL, H5P.DEFAULT, ptr);
            Marshal.Copy(ptr, buffer, 0, len);
            Marshal.FreeHGlobal(ptr);

            string s = Encoding.ASCII.GetString(buffer);

            return(s.Split(new char[] { '\0' }, StringSplitOptions.RemoveEmptyEntries));
        }
Example #17
0
        public static T[] LoadDataset <T>(string filePath, string datasetName)
        {
            if (!File.Exists(filePath))
            {
                throw new FileNotFoundException($"Loading dataset {datasetName} from file that doesn't exist {filePath}");
            }
            long fileId = H5F.open(filePath, H5F.ACC_RDONLY);

            T[] resultArray;

            try {
                long datasetId = H5D.open(fileId, datasetName);
                if (datasetId == -1)
                {
                    throw new ArgumentException($"Dataset could not be opened. Check filepath exists and is correct. FilePath = {filePath}");
                }
                long typeId  = H5D.get_type(datasetId);
                long spaceID = H5D.get_space(datasetId);

                int[] dimensions = GetDatasetDimensions(spaceID);

                resultArray = new T[dimensions[0]];
                GCHandle gch = GCHandle.Alloc(resultArray, GCHandleType.Pinned);

                try {
                    H5D.read(datasetId, typeId, H5S.ALL, H5S.ALL, H5P.DEFAULT, gch.AddrOfPinnedObject());
                }
                finally {
                    gch.Free();
                    H5D.close(typeId);
                    H5D.close(spaceID);
                    H5D.close(datasetId);
                }
            }
            finally {
                H5F.close(fileId);
            }

            return(resultArray);
        }
Example #18
0
        public static string ReadUnicodeString(hid_t groupId, string name)
        {
            hid_t datatype = H5T.create(H5T.class_t.STRING, H5T.VARIABLE);

            H5T.set_cset(datatype, H5T.cset_t.UTF8);
            H5T.set_strpad(datatype, H5T.str_t.NULLTERM);

            var datasetId = H5D.open(groupId, name);
            var typeId    = H5D.get_type(datasetId);

            var    classId = H5T.get_class(typeId);
            var    order   = H5T.get_order(typeId);
            IntPtr size    = H5T.get_size(typeId);
            int    strLen  = (int)size;

            var   spaceId = H5D.get_space(datasetId);
            hid_t count   = H5S.get_simple_extent_npoints(spaceId);

            IntPtr[] rdata = new IntPtr[count];
            byte[]   wdata = new byte[strLen];

            GCHandle hnd = GCHandle.Alloc(rdata, GCHandleType.Pinned);

            H5D.read(datasetId, datatype, H5S.ALL, H5S.ALL,
                     H5P.DEFAULT, hnd.AddrOfPinnedObject());

            for (int i = 0; i < strLen; i++)
            {
                Marshal.ReadByte(rdata[0], i);
            }
            Marshal.Copy(rdata[0], wdata, 0, strLen);
            string s = Encoding.UTF8.GetString(wdata);

            hnd.Free();
            H5S.close(spaceId);
            H5T.close(datatype);
            H5D.close(datasetId);
            return(s);
        }
Example #19
0
        public static string[] LoadStringDataset(string filePath, string dataSetName)
        {
            //With much Help from:  https://stackoverflow.com/questions/23295545/reading-string-array-from-a-hdf5-dataset
            long fileId = H5F.open(filePath, H5F.ACC_RDONLY);

            string longJoinedString;
            int    stringLength;

            try {
                long datasetId = H5D.open(fileId, dataSetName);
                long spaceID   = H5D.get_space(datasetId);
                long dataType  = H5D.get_type(datasetId);

                int[] dimensions = GetDatasetDimensions(spaceID);

                stringLength = (int)H5T.get_size(dataType);
                byte[] buffer = new byte[dimensions[0] * stringLength];

                GCHandle gch = GCHandle.Alloc(buffer, GCHandleType.Pinned);


                try {
                    H5D.read(datasetId, dataType, H5S.ALL, H5S.ALL, H5P.DEFAULT, gch.AddrOfPinnedObject());
                    longJoinedString = Encoding.ASCII.GetString(buffer);
                }
                finally {
                    gch.Free();
                    H5D.close(dataType);
                    H5D.close(spaceID);
                    H5D.close(datasetId);
                }
            }
            finally {
                H5F.close(fileId);
            }

            return(longJoinedString.SplitInParts(stringLength).Select(ss => (string)(object)ss).ToArray());
        }
Example #20
0
        public static string ReadUnicodeString(hid_t groupId, string name)
        {
            hid_t datatype = H5T.create(H5T.class_t.STRING, H5T.VARIABLE);

            H5T.set_cset(datatype, H5T.cset_t.UTF8);
            H5T.set_strpad(datatype, H5T.str_t.SPACEPAD);

            var datasetId = H5D.open(groupId, name);
            var typeId    = H5D.get_type(datasetId);

            var    classId = H5T.get_class(typeId);
            var    order   = H5T.get_order(typeId);
            IntPtr size    = H5T.get_size(typeId);
            int    strLen  = (int)size;

            var spaceId = H5D.get_space(datasetId);

            byte[] wdata = new byte[strLen];

            //IntPtr ptr = new IntPtr();
            GCHandle hnd = GCHandle.Alloc(wdata, GCHandleType.Pinned);

            H5D.read(datasetId, datatype, H5S.ALL, H5S.ALL,
                     H5P.DEFAULT, hnd.AddrOfPinnedObject());
            hnd.Free();

            //int len = 0;
            //while (Marshal.ReadByte(ptr, len) != 0) { ++len; }
            //byte[] name_buf = new byte[len];
            //Marshal.Copy(ptr, name_buf, 0, len);
            string s = Encoding.UTF8.GetString(wdata);

            H5S.close(spaceId);
            H5T.close(datatype);
            H5D.close(datasetId);
            return(s);
        }
Example #21
0
        private static double[] ReadDataVector(hid_t fileLoc, string name)
        {
            hid_t dset   = H5D.open(fileLoc, name);
            hid_t fspace = H5D.get_space(dset);
            hid_t count  = H5S.get_simple_extent_ndims(fspace);

            hid_t type = H5D.get_type(dset);

            hsize_t[] dims    = new hsize_t[count];
            hsize_t[] maxdims = new hsize_t[count];

            H5S.get_simple_extent_dims(fspace, dims, maxdims);
            H5S.close(fspace);


            byte[] rdata = new byte[dims[0] * 8];

            hid_t mem_type = H5T.copy(H5T.NATIVE_DOUBLE);

            H5T.set_size(mem_type, new IntPtr(8));

            GCHandle hnd = GCHandle.Alloc(rdata, GCHandleType.Pinned);

            H5D.read(dset, mem_type, H5S.ALL,
                     H5S.ALL, H5P.DEFAULT, hnd.AddrOfPinnedObject());

            hnd.Free();
            H5T.close(mem_type);

            double[] val = new double[dims[0]];
            for (int i = 0; i < (int)dims[0]; i++)
            {
                val[i] = BitConverter.ToDouble(rdata, i * 8);
            }

            return(val);
        }
Example #22
0
        private static string ReadDataString(hid_t fileLoc, string name)
        {
            hid_t dset = H5D.open(fileLoc, name);
            hid_t type = H5D.get_type(dset);
            // H5T.is_variable_str(type);
            IntPtr size = H5T.get_size(type);

            hid_t fspace   = H5D.get_space(dset);
            hid_t mem_type = H5T.copy(type);

            H5T.set_size(mem_type, size);


            byte[]   buffer = new byte[size.ToInt32()];
            GCHandle hnd    = GCHandle.Alloc(buffer, GCHandleType.Pinned);

            H5D.read(dset, mem_type, H5S.ALL,
                     H5S.ALL, H5P.DEFAULT, hnd.AddrOfPinnedObject());

            hnd.Free();

            H5T.close(mem_type);

            // remove the last "/0"
            if (buffer[buffer.Length - 1] == 0)
            {
                byte[] buffer2 = new byte[buffer.Length - 1];
                for (int i = 0; i < buffer2.Length; i++)
                {
                    buffer2[i] = buffer[i];
                }


                return(ASCIIEncoding.ASCII.GetString(buffer2));
            }
            return(ASCIIEncoding.ASCII.GetString(buffer));
        }
Example #23
0
        public Array Get()
        {
            Array result = null;

            WithDataSpace((h5Ref, dsRef) =>
            {
                var success = H5S.select_none(dsRef);
                if (success < 0)
                {
                    throw new H5SSException("Error with dataspace: select_none");
                }
                success = H5S.select_all(dsRef);
                if (success < 0)
                {
                    throw new H5SSException("Error with dataspace: select_all");
                }
                int selectElemNpoints = (int)H5S.get_select_npoints(dsRef);
                var effectiveSize     = ElementSize * selectElemNpoints;
                if (DataType == HDF5DataType.String)
                {
                    effectiveSize *= _stringLength;
                }
                IntPtr iPtr = Marshal.AllocHGlobal(effectiveSize); // TODO Deallocate

                try
                {
                    var dtype = H5D.get_type(h5Ref); // Return?
                    success   = H5D.read(h5Ref, dtype, H5S.ALL, dsRef, H5P.DEFAULT, iPtr);
                    H5T.close(dtype);

                    if (success < 0)
                    {
                        throw new H5SSException("Error reading dataset");
                    }

                    var tmp   = CreateClrArray(iPtr, selectElemNpoints);
                    var shape = Shape.Select(ul => (long)ul).ToArray();
                    if (ClrType == typeof(byte))
                    {
                        shape = shape.Concat(new[] { (long)_stringLength }).ToArray();
                    }

                    result = Array.CreateInstance(ClrType, shape);
                    Buffer.BlockCopy(tmp, 0, result, 0, effectiveSize);
                }
                finally
                {
                    Marshal.FreeHGlobal(iPtr);
                }

                // Convert bytes to characters...
                if (DataType == HDF5DataType.String)
                {
                    byte[,] byteArray = (byte[, ])result;
                    result            = Enumerable.Range(0, byteArray.GetLength(0)).Select(i =>
                    {
                        var slice = Enumerable.Range(0, byteArray.GetLength(1)).Select(j => byteArray[i, j]).ToArray();
                        //return System.Text.Encoding.Default.GetString(slice);
                        return(Encoding.ASCII.GetString(slice).TrimEnd((Char)0));
                    }).ToArray();
                }
                H5S.get_simple_extent_dims(dsRef, _shape, _maxDims); // WTF?
            });
            return(result);
        }
Example #24
0
        public Dictionary <string, string> GetDatasetAttributes(string originalDatasetName)
        {
            H5DataSetId   datasetId = 0;
            H5GroupId     groupId   = 0;
            H5DataTypeId  typeId    = 0;
            H5DataSpaceId spaceId   = 0;

            try
            {
                if (_h5FileId < 0)
                {
                    return(null);
                }
                string datasetName = GetDatasetFullNames(originalDatasetName, _h5FileId);
                if (string.IsNullOrEmpty(datasetName))
                {
                    return(null);
                }
                int groupIndex = datasetName.LastIndexOf('/');
                if (groupIndex == -1)
                {
                    datasetId = H5D.open(_h5FileId, datasetName);
                }
                else
                {
                    string groupName = datasetName.Substring(0, groupIndex + 1);
                    string dsName    = datasetName.Substring(groupIndex + 1);
                    groupId   = H5G.open(_h5FileId, groupName);
                    datasetId = H5D.open(groupId, dsName);
                }
                if (datasetId == 0)
                {
                    return(null);
                }
                Dictionary <string, string> attValues = new Dictionary <string, string>();

                typeId = H5D.get_type(datasetId);
                H5T.class_t type  = H5T.get_class(typeId);
                IntPtr      tSize = H5T.get_size(typeId);

                spaceId = H5D.get_space(datasetId);

                int     length = H5S.get_simple_extent_ndims(spaceId);
                ulong[] dims   = new ulong[length];
                H5S.get_simple_extent_dims(spaceId, dims, null);
                ulong storageSize = H5D.get_storage_size(datasetId);

                attValues.Add("DataSetName", datasetName);
                attValues.Add("DataType", type.ToString());
                attValues.Add("DataTypeSize", tSize.ToString() + "Byte");
                attValues.Add("Dims", String.Join("*", dims));
                attValues.Add("StorageSize", storageSize.ToString() + "Byte");


                //所有Attributes的键
                ArrayList arrayList = new ArrayList();
                GCHandle  handle    = GCHandle.Alloc(arrayList);
                ulong     n         = 0;
                // the callback is defined in H5ATest.cs
                H5A.operator_t cb = (int location_id, IntPtr attr_name, ref H5A.info_t ainfo, IntPtr op_data) =>
                {
                    GCHandle  hnd = (GCHandle)op_data;
                    ArrayList al  = (hnd.Target as ArrayList);
                    int       len = 0;
                    while (Marshal.ReadByte(attr_name, len) != 0)
                    {
                        ++len;
                    }
                    byte[] buf = new byte[len];
                    Marshal.Copy(attr_name, buf, 0, len);
                    al.Add(Encoding.UTF8.GetString(buf));
                    return(0);
                };
                H5A.iterate(datasetId, H5.index_t.NAME, H5.iter_order_t.NATIVE, ref n, cb, (IntPtr)handle);
                handle.Free();

                foreach (string attName in arrayList)
                {
                    attValues.Add(attName, ReadAttributeValue(datasetId, attName));
                }
                return(attValues);
            }
            finally
            {
                if (spaceId != 0)
                {
                    H5S.close(spaceId);
                }
                if (typeId != 0)
                {
                    H5T.close(typeId);
                }
                if (datasetId != 0)
                {
                    H5D.close(datasetId);
                }
                if (groupId != 0)
                {
                    H5G.close(groupId);
                }
            }
        }
Example #25
0
        public Task <string> GetData(DateTime dateTimeBegin, DateTime dateTimeEnd, string sampleRateDescription, FileFormat fileFormat, FileGranularity fileGranularity, Dictionary <string, Dictionary <string, List <string> > > campaignInfoSet)
        {
            long fileId    = -1;
            long datasetId = -1;

            ulong start;
            ulong stride;
            ulong block;
            ulong count;

            ulong segmentLength;
            ulong segmentSize;
            ulong bytesPerRow;

            double sampleRate;

            DateTime epochStart;
            DateTime epochEnd;

            string zipFilePath;

            // task
            return(Task.Run(() =>
            {
                this.CheckState();

                if (!campaignInfoSet.Any())
                {
                    return string.Empty;
                }

                // zip file
                zipFilePath = Path.Combine(_options.SupportDirectoryPath, "EXPORT", $"OneDAS_{ dateTimeBegin.ToString("yyyy-MM-ddTHH-mm") }_{ sampleRateDescription }_{ Guid.NewGuid().ToString() }.zip");

                // sampleRate
                sampleRate = sampleRateDescription.ToSampleRate();

                // epoch & hyperslab
                epochStart = new DateTime(2000, 01, 01);
                epochEnd = new DateTime(2030, 01, 01);

                if (!(epochStart <= dateTimeBegin && dateTimeBegin <= dateTimeEnd && dateTimeEnd <= epochEnd))
                {
                    throw new Exception("requirement >> epochStart <= dateTimeBegin && dateTimeBegin <= dateTimeEnd && dateTimeBegin <= epochEnd << is not matched");
                }

                start = (ulong)(Math.Floor((dateTimeBegin - epochStart).TotalSeconds * sampleRate));
                stride = 1;
                block = (ulong)(Math.Ceiling((dateTimeEnd - dateTimeBegin).TotalSeconds * sampleRate));
                count = 1;

                try
                {
                    // open file
                    fileId = H5F.open(_options.VdsFilePath, H5F.ACC_RDONLY);

                    // byte count
                    bytesPerRow = 0;

                    foreach (var campaignInfo in campaignInfoSet)
                    {
                        foreach (var variableInfo in campaignInfo.Value)
                        {
                            foreach (string datasetInfo in variableInfo.Value)
                            {
                                try
                                {
                                    datasetId = H5D.open(fileId, $"{ campaignInfo.Key }/{ variableInfo.Key }/{ datasetInfo }");
                                    bytesPerRow += (ulong)OneDasUtilities.SizeOf(TypeConversionHelper.GetTypeFromHdfTypeId(H5D.get_type(datasetId)));
                                }
                                finally
                                {
                                    if (H5I.is_valid(datasetId) > 0)
                                    {
                                        H5D.close(datasetId);
                                    }
                                }
                            }
                        }
                    }

                    this.GetClient().SendByteCount(bytesPerRow * block);

                    segmentSize = (50 * 1024 * 1024) / bytesPerRow * bytesPerRow;
                    segmentLength = segmentSize / bytesPerRow;

                    // ensure that dataset length is multiple of 1 minute
                    if ((segmentLength / sampleRate) % 60 != 0)
                    {
                        segmentLength = (ulong)((ulong)(segmentLength / sampleRate / 60) * 60 * sampleRate);
                    }

                    // start
                    _stateManager.SetState(this.Context.ConnectionId, HdfExplorerState.Loading);

                    using (ZipArchive zipArchive = ZipFile.Open(zipFilePath, ZipArchiveMode.Create))
                    {
                        foreach (var campaignInfo in campaignInfoSet)
                        {
                            HdfDataLoader hdfDataLoader;

                            hdfDataLoader = new HdfDataLoader(_stateManager.GetToken(this.Context.ConnectionId));
                            hdfDataLoader.ProgressUpdated += this.OnProgressUpdated;

                            if (!hdfDataLoader.WriteZipFileCampaignEntry(zipArchive, fileGranularity, fileFormat, new ZipSettings(dateTimeBegin, campaignInfo, fileId, sampleRate, start, stride, block, count, segmentLength)))
                            {
                                return string.Empty;
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    this.WriteLogEntry(ex.Message, true);
                    throw;
                }
                finally
                {
                    _stateManager.SetState(this.Context.ConnectionId, HdfExplorerState.Idle);

                    if (H5I.is_valid(fileId) > 0)
                    {
                        H5F.close(fileId);
                    }
                }

                this.WriteLogEntry($"{ this.Context.GetHttpContext().Connection.RemoteIpAddress } requested data: { dateTimeBegin.ToString("yyyy-MM-dd HH:mm:ss") } to { dateTimeEnd.ToString("yyyy-MM-dd HH:mm:ss") }", false);

                return $"download/{ Path.GetFileName(zipFilePath) }";
            }, _stateManager.GetToken(this.Context.ConnectionId)));
        }
Example #26
0
        public bool WriteZipFileCampaignEntry(ZipArchive zipArchive, FileGranularity fileGranularity, FileFormat fileFormat, ZipSettings zipSettings)
        {
            IList <VariableDescription> variableDescriptionSet;
            IList <CustomMetadataEntry> customMetadataEntrySet;

            ZipArchiveEntry zipArchiveEntry;
            DataWriterExtensionLogicBase    dataWriter;
            DataWriterExtensionSettingsBase settings;
            DataWriterContext dataWriterContext;

            string directoryPath;

            string[] campaignName_splitted;
            string[] filePathSet;

            int currentFile;
            int fileCount;

            // build variable descriptions
            variableDescriptionSet = new List <VariableDescription>();

            zipSettings.CampaignInfo.Value.ToList().ForEach(variableInfo =>
            {
                variableInfo.Value.ForEach(datasetName =>
                {
                    long groupId   = -1;
                    long typeId    = -1;
                    long datasetId = -1;

                    string displayName;
                    string groupName;
                    string unit;

                    ulong samplesPerDay;

                    OneDasDataType oneDasDataType;

                    hdf_transfer_function_t[] hdf_transfer_function_t_set;
                    List <TransferFunction> transferFunctionSet;

                    try
                    {
                        groupId   = H5G.open(zipSettings.SourceFileId, $"{ zipSettings.CampaignInfo.Key }/{ variableInfo.Key }");
                        datasetId = H5D.open(groupId, datasetName);
                        typeId    = H5D.get_type(datasetId);

                        displayName = IOHelper.ReadAttribute <string>(groupId, "name_set").Last();
                        groupName   = IOHelper.ReadAttribute <string>(groupId, "group_set").Last();
                        unit        = IOHelper.ReadAttribute <string>(groupId, "unit_set").LastOrDefault();
                        hdf_transfer_function_t_set = IOHelper.ReadAttribute <hdf_transfer_function_t>(groupId, "transfer_function_set");
                        transferFunctionSet         = hdf_transfer_function_t_set.Select(tf => new TransferFunction(DateTime.ParseExact(tf.date_time, "yyyy-MM-ddTHH-mm-ssZ", CultureInfo.InvariantCulture), tf.type, tf.option, tf.argument)).ToList();

                        oneDasDataType = OneDasUtilities.GetOneDasDataTypeFromType(TypeConversionHelper.GetTypeFromHdfTypeId(typeId));
                        samplesPerDay  = OneDasUtilities.GetSamplesPerDayFromString(datasetName);

                        variableDescriptionSet.Add(new VariableDescription(new Guid(variableInfo.Key), displayName, datasetName, groupName, oneDasDataType, samplesPerDay, unit, transferFunctionSet, typeof(ISimpleDataStorage)));
                    }
                    finally
                    {
                        if (H5I.is_valid(datasetId) > 0)
                        {
                            H5D.close(datasetId);
                        }
                        if (H5I.is_valid(groupId) > 0)
                        {
                            H5G.close(groupId);
                        }
                        if (H5I.is_valid(typeId) > 0)
                        {
                            H5T.close(typeId);
                        }
                    }
                });
            });

            dataWriter = null; // REMOVE ONE IMPLEMENTED PROPERLY

            switch (fileFormat)
            {
            case FileFormat.CSV:

                //settings = new CsvSettings() { FileGranularity = fileGranularity };
                //dataWriter = new CsvWriter((CsvSettings)settings, new LoggerFactory());

                break;

            case FileFormat.GAM:

                //settings = new GamSettings() { FileGranularity = fileGranularity };
                //dataWriter = new GamWriter((GamSettings)settings, new LoggerFactory());

                break;

            case FileFormat.MAT73:

                //settings = new Mat73Settings() { FileGranularity = fileGranularity };
                //dataWriter = new Mat73Writer((Mat73Settings)settings, new LoggerFactory());

                break;

            default:
                throw new NotImplementedException();
            }

            // create temp directory
            directoryPath = Path.Combine(Path.GetTempPath(), "OneDas.Hdf.Explorer", Guid.NewGuid().ToString());
            Directory.CreateDirectory(directoryPath);

            // create custom meta data
            customMetadataEntrySet = new List <CustomMetadataEntry>();
            //customMetadataEntrySet.Add(new CustomMetadataEntry("system_name", "HDF Explorer", CustomMetadataEntryLevel.File));

            // initialize data writer
            campaignName_splitted = zipSettings.CampaignInfo.Key.Split('/');
            dataWriterContext     = new DataWriterContext("HDF Explorer", directoryPath, new OneDasCampaignDescription(Guid.Empty, 0, campaignName_splitted[1], campaignName_splitted[2], campaignName_splitted[3]), customMetadataEntrySet);
            dataWriter.Configure(dataWriterContext, variableDescriptionSet);

            // create temp files
            try
            {
                if (!this.CreateFiles(dataWriter, zipSettings))
                {
                    this.CleanUp(directoryPath);

                    return(false);
                }
            }
            finally
            {
                dataWriter.Dispose();
            }

            // write zip archive entries
            filePathSet = Directory.GetFiles(directoryPath, "*", SearchOption.AllDirectories);
            currentFile = 0;
            fileCount   = filePathSet.Count();

            foreach (string filePath in filePathSet)
            {
                zipArchiveEntry = zipArchive.CreateEntry(Path.GetFileName(filePath), CompressionLevel.Optimal);

                this.OnProgressUpdated(new ProgressUpdatedEventArgs(currentFile / (double)fileCount * 100, $"Writing file { currentFile + 1 } / { fileCount } to ZIP archive ..."));

                using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.Read))
                {
                    using (Stream zipArchiveEntryStream = zipArchiveEntry.Open())
                    {
                        fileStream.CopyTo(zipArchiveEntryStream);
                    }
                }

                currentFile++;
            }

            this.CleanUp(directoryPath);

            return(true);
        }
Example #27
0
        static void Main_Read(string[] args)
        {
            int DATA_ARRAY_LENGTH = 5;

            //var h5 = H5F.open(@"E:\HDF5\HDF5DotNet-src\examples\CSharpExample\CSharpExample1\table.h5", H5F.ACC_RDONLY);

            //var h5 = H5F.open(@"D:\test.h5", H5F.ACC_RDONLY);
            //var h5 = H5F.open(@"E:\HDF5\Hdf5DotnetTools-master\ToolTest\bin\Debug\table.h5", H5F.ACC_RDONLY);
            var h5 = H5F.open(@"E:\HDF5\test_gzip.h5", H5F.ACC_RDONLY);

            var dataset = H5D.open(h5, "trans_detail/20160929");
            var spaceid = H5D.get_space(dataset);
            var npoints = H5S.get_simple_extent_npoints(spaceid);
            //var dims = H5S.get_simple_extent_dims(spaceid);
            int rank = H5S.get_simple_extent_ndims(spaceid);

            // 是不是不能用自己的type
            var dtype = H5D.get_type(dataset);
            var dtcls = H5T.get_class(dtype);
            var size  = H5T.get_size(dtype);
            var sz    = Marshal.SizeOf(typeof(ComType));

            var dtype_n = H5T.get_nmembers(dtype);

            for (uint i = 0; i < dtype_n; ++i)
            {
                var x  = H5T.get_member_name(dtype, i);
                var x4 = Marshal.PtrToStringAnsi(x);
                var y  = H5T.get_member_type(dtype, i);
                var z  = H5T.get_class(y);
                var x1 = H5T.get_member_offset(dtype, i);
                var x3 = H5T.get_size(y);

                Console.WriteLine(x4);
                Console.WriteLine(z);
                Console.WriteLine(x1);
                //var x2 = Marshal.OffsetOf(typeof(ComType), x4).ToInt32();
                //Console.WriteLine(x2);
                Console.WriteLine(x3);
            }

            int    ss1 = Marshal.SizeOf(typeof(ComType));
            IntPtr p   = Marshal.AllocHGlobal(ss1 * 11);

            H5D.read(dataset, dtype, H5S.ALL, H5S.ALL, H5P.DEFAULT, p);
            var s = Marshal.PtrToStructure(p, typeof(ComType));

            Console.WriteLine(s);
            var s2 = Marshal.PtrToStructure(p + ss1, typeof(ComType));

            Console.WriteLine(s2);
            var s3 = Marshal.PtrToStructure(p + ss1 * 4, typeof(ComType));

            Console.WriteLine(s3);
            var s4 = Marshal.PtrToStructure(p + ss1 * 5, typeof(ComType));

            Console.WriteLine(s4);
            var s6 = Marshal.PtrToStructure(p + ss1 * 10, typeof(ComType));

            Console.WriteLine(s6);
        }
Example #28
0
 /// <summary>
 /// Read the appropriate H5Type from a *dataset* with ID `dset_id`.
 /// </summary>
 public static H5Type FromDataset(hid_t dset_id)
 {
     return(new H5Type(H5D.get_type(dset_id)));
 }
Example #29
0
        public static string ReadUnicodeString(hid_t groupId, string name)
        {
            var datasetId = H5D.open(groupId, name);
            var typeId    = H5D.get_type(datasetId);

            if (H5T.is_variable_str(typeId) > 0)
            {
                var   spaceId = H5D.get_space(datasetId);
                hid_t count   = H5S.get_simple_extent_npoints(spaceId);

                IntPtr[] rdata = new IntPtr[count];

                GCHandle hnd = GCHandle.Alloc(rdata, GCHandleType.Pinned);
                H5D.read(datasetId, typeId, H5S.ALL, H5S.ALL,
                         H5P.DEFAULT, hnd.AddrOfPinnedObject());

                var attrStrings = new List <string>();
                for (int i = 0; i < rdata.Length; ++i)
                {
                    int attrLength = 0;
                    while (Marshal.ReadByte(rdata[i], attrLength) != 0)
                    {
                        ++attrLength;
                    }

                    byte[] buffer = new byte[attrLength];
                    Marshal.Copy(rdata[i], buffer, 0, buffer.Length);

                    string stringPart = Encoding.UTF8.GetString(buffer);

                    attrStrings.Add(stringPart);

                    H5.free_memory(rdata[i]);
                }

                hnd.Free();
                H5S.close(spaceId);
                H5D.close(datasetId);

                return(attrStrings[0]);
            }

            // Must be a non-variable length string.
            int    size = H5T.get_size(typeId).ToInt32();
            IntPtr iPtr = Marshal.AllocHGlobal(size);

            int result = H5D.read(datasetId, typeId, H5S.ALL, H5S.ALL,
                                  H5P.DEFAULT, iPtr);

            if (result < 0)
            {
                throw new IOException("Failed to read dataset");
            }

            var strDest = new byte[size];

            Marshal.Copy(iPtr, strDest, 0, size);
            Marshal.FreeHGlobal(iPtr);

            H5D.close(datasetId);

            return(Encoding.UTF8.GetString(strDest).TrimEnd((Char)0));
        }
Example #30
0
        private List <float[]> ReadDataSetToSingle(AbstractWarpDataset srcbandpro, int[] bands)
        {
            List <float[]> datas    = new List <float[]>();
            var            prjBands = PrjBandTable.GetPrjBands(srcbandpro);
            H5ID           h5FileId = H5F.open(srcbandpro.fileName, H5F.ACC_RDONLY);

            foreach (int index in bands)
            {
                //Single[] data = new Single[srcSize.Width * srcSize.Height];
                var    bandIndex = prjBands[index - 1].DataSetIndex;
                string dsName    = "CALChannel" + bandIndex.ToString("00");


                H5ID datasetId = H5D.open(h5FileId, dsName);
                if (datasetId <= 0)
                {
                    throw new ArgumentNullException(string.Format("FY4辐射定标,未找到名称为{0}的数据.",
                                                                  "CALChannel" + index.ToString("00")));
                }
                H5ID typeId  = H5D.get_type(datasetId);
                H5ID spaceId = H5D.get_space(datasetId);
                if (H5T.get_class(typeId) == H5T.class_t.FLOAT)
                {
                    int     rank    = H5S.get_simple_extent_ndims(spaceId);
                    ulong[] dims    = new ulong[rank];
                    ulong[] maxDims = new ulong[rank];
                    H5S.get_simple_extent_dims(spaceId, dims, maxDims);

                    float[]  buffer = new float[dims[0]];
                    GCHandle hnd    = GCHandle.Alloc(buffer, GCHandleType.Pinned);
                    H5D.read(datasetId, typeId, H5S.ALL, H5S.ALL, H5P.DEFAULT, hnd.AddrOfPinnedObject());
                    hnd.Free();
                    if (buffer.Any(t => t > Math.Pow(10, 10) || t < -Math.Pow(10, 10)))
                    {
                        for (int i = 0; i < buffer.Length; i++)
                        {
                            var t = BitConverter.GetBytes(buffer[i]);
                            Array.Reverse(t);
                            buffer[i] = BitConverter.ToSingle(t, 0);
                        }
                    }

                    datas.Add(buffer);
                }

                if (spaceId != 0)
                {
                    H5S.close(spaceId);
                }
                if (typeId != 0)
                {
                    H5T.close(typeId);
                }
                if (datasetId != 0)
                {
                    H5D.close(datasetId);
                }
            }

            if (h5FileId != 0)
            {
                H5F.close(h5FileId);
            }

            return(datas);
        }