コード例 #1
0
        public void Dispose()
        {
            if (_file_id != -1)
            {
                //释放内存
            }
            int istat = HDF4Helper.SDend(_sd_id);

            istat = HDF4API.Vend(_file_id);
            istat = HDF4API.Hclose(_file_id);
            if (_datasets != null)
            {
                foreach (H4SDS sds in _datasets)
                {
                    sds.Dispose();
                }
            }
            if (_vdatas != null)
            {
                foreach (H4Vdata vdata in _vdatas)
                {
                    vdata.Dispose();
                }
            }
        }
コード例 #2
0
ファイル: frmMODLSTPro.cs プロジェクト: windygu/hispeed
 private void GetFileAttrInfos(FileListItem fli)
 {
     if (HDF4Helper.IsHdf4(fli.FileName))
     {
         Hdf4Operator oper = new Hdf4Operator(fli.FileName);
         try
         {
             Dictionary <string, string> fileAtrr = null;
             if (oper != null)
             {
                 fileAtrr = oper.GetAttributes();
                 if (fileAtrr != null)
                 {
                     InitFileAttr(fileAtrr);
                 }
                 else
                 {
                     ClearFileAtrr();
                 }
                 InitDataset(oper.GetDatasetNames, oper);
             }
         }
         catch (Exception ex)
         {
             AddLog(fli.FileName + "文件读取失败:" + ex.Message);
         }
         finally
         {
             if (oper != null)
             {
                 oper.Dispose();
             }
         }
     }
 }
コード例 #3
0
        public void Load(string filename, DFACC dfacc)
        {
            sw.Start();
            _filename = filename;
            int file_id, sd_id;

            try
            {
                _fileOpenState = false;
                file_id        = HDF4API.Hopen(filename, DFACC.DFACC_READ, 0);
                HDF4API.Vstart(file_id);
                //_gr_id = HDF4API.GRstart(file_id);
            }
            catch
            {
                string strErrInfo = "HDF4打开文件异常";
                throw new Exception(strErrInfo);
            }
            _fileOpenState = true;
            sd_id          = HDF4Helper.SDstart(filename, HDF4Helper.AccessCodes.DFACC_READ);
            if (sd_id == -1)
            {
                //打开失败
            }
            _file_id = file_id;
            _sd_id   = sd_id;
            sw.Stop();
            em = sw.ElapsedMilliseconds;
            Console.WriteLine("打开" + em + "毫秒");
            // load the file hierarchy
            getRootGroup();
        }
コード例 #4
0
        public override bool IsSupport(string fname, byte[] header1024, Dictionary <string, string> datasetNames)
        {
            string ext = Path.GetExtension(fname).ToUpper();

            if (ext != ".HDF" || !HDF4Helper.IsHdf4(header1024))
            {
                return(false);
            }
            return(HasDatasets(fname));
        }
コード例 #5
0
 public void Close(int sds_id)
 {
     try
     {
         HDF4Helper.SDendaccess(sds_id);
     }
     catch
     {
         Console.WriteLine("Error,SDendaccess:" + sds_id);
     }
 }
コード例 #6
0
ファイル: BandProviderHDF4.cs プロジェクト: configare/hispeed
        public override bool IsSupport(string fname, byte[] header1024, Dictionary <string, string> datasetNames)
        {
            string ext = Path.GetExtension(fname).ToUpper();

            if (ext != ".HDF" || !HDF4Helper.IsHdf4(header1024))
            {
                return(false);
            }
            TryGetBandProviderDefinition(fname, datasetNames);
            return(_matchedBandProviderDef != null);
        }
コード例 #7
0
        /** get the root group and all the alone objects */
        private void getRootGroup()
        {
            sw.Restart();
            //LoadVgroups(_file_id);//暂时取消加载整个树结构,目前这个加载比较慢,暂时也用不着。
            sw.Stop();
            em = sw.ElapsedMilliseconds;
            Console.WriteLine("LoadVgroups" + em + "毫秒");

            sw.Restart();
            int num_ds     = 0;
            int num_global = 0;

            status            = HDF4Helper.SDfileinfo(_sd_id, out num_ds, out num_global);
            _num_datasets     = num_ds;
            _num_global_attrs = num_global;
            for (int i = 0; i < num_ds; i++)
            {
                H4SDS ds = H4SDS.Load(_sd_id, i);
                _datasets.Add(ds);
            }
            for (int i = 0; i < num_global; i++)
            {
                HDFAttribute global_attr = HDFAttribute.Load(_sd_id, i);
                _global_attrs.Add(global_attr);
            }
            sw.Stop();
            em = sw.ElapsedMilliseconds;
            Console.WriteLine("SDfileinfo" + em + "毫秒");


            sw.Restart();
            //Finding All Vdatas that are Not Members of a Vgroup: VSlone
            //初始化Vdata(读取表格数据,表格列名称参数)
            int[] ref_array = new int[1024];
            HDF4API.VSlone(_file_id, ref_array, 1024);

            //初始化Vdata(读取表格数据,表格列名称参数) istat;
            int vdata_ref;
            int istat = HDF4API.Vstart(_file_id);

            vdata_ref = -1;
            List <H4Vdata> vdatas = new List <H4Vdata>();

            while ((vdata_ref = HDF4API.VSgetid(_file_id, vdata_ref)) != HDFConstants.FAIL)
            {
                H4Vdata vdata = LoadVdata(_file_id, vdata_ref);
                vdatas.Add(vdata);
            }
            _vdatas = vdatas;
            sw.Stop();
            em = sw.ElapsedMilliseconds;
            Console.WriteLine("VSlone" + em + "毫秒");
        }
コード例 #8
0
 private IHdfOperator HdfOperatorFactory(string filename)
 {
     if (HDF5Helper.IsHdf5(filename))
     {
         return(new Hdf5Operator(filename));
     }
     if (HDF4Helper.IsHdf4(filename))
     {
         return(new Hdf4Operator(filename));
     }
     return(null);
 }
コード例 #9
0
ファイル: frmMODLSTPro.cs プロジェクト: windygu/hispeed
        private void lstDataSets_SelectedIndexChanged(object sender, EventArgs e)
        {
            ClearDataSetCombox();
            if (lstDataSets.SelectedItems.Count == 0 || lstDataSets.SelectedItems[0].Tag == null ||
                lstFileInfoList.SelectedItems.Count == 0 || (lstFileInfoList.SelectedItems[0]).Tag == null)
            {
                return;
            }
            FileListItem      fli = (lstFileInfoList.SelectedItems[0]).Tag as FileListItem;
            DataSetMosaicInfo dsi = lstDataSets.SelectedItems[0].Tag as DataSetMosaicInfo;

            if (fli == null)
            {
                return;
            }
            if (HDF4Helper.IsHdf4(fli.FileName))
            {
                Hdf4Operator oper = new Hdf4Operator(fli.FileName);
                try
                {
                    Dictionary <string, string> datasetAtrr = new Dictionary <string, string>();
                    if (oper != null)
                    {
                        datasetAtrr = oper.GetAttributes(dsi.DataSetName);
                        if (datasetAtrr != null)
                        {
                            InitDataSetAttr(datasetAtrr, ref dsi);
                        }
                        Size size      = Size.Empty;
                        int  bandCount = 0;
                        Type datatype;
                        int  datatypeSize = 0;
                        HDF4Helper.DataTypeDefinitions hdf4DataType = HDF4Helper.DataTypeDefinitions.DFNT_NUINT16;
                        if (GetDataSetSize(dsi.DataSetName, oper, out size, out bandCount, out hdf4DataType, out datatype, out datatypeSize))
                        {
                            InitHeigthWidth(size.Width, size.Height, bandCount, ref dsi);
                            if (dsi != null)
                            {
                                dsi.HDF4DataType = hdf4DataType;
                            }
                        }
                    }
                }
                finally
                {
                    if (oper != null)
                    {
                        oper.Dispose();
                    }
                }
            }
        }
コード例 #10
0
ファイル: HDF4Driver.cs プロジェクト: configare/hispeed
        protected override bool IsCompatible(string fileName, byte[] header1024, params object[] args)
        {
            if (args == null || args.Length == 0)
            {
                return(false);
            }
            string ext = Path.GetExtension(fileName).ToUpper();

            if (ext != ".HDF" || !HDF4Helper.IsHdf4(header1024))
            {
                return(false);
            }
            return(true);
        }
コード例 #11
0
ファイル: H4Attribute.cs プロジェクト: configare/hispeed
        public static HDFAttribute Load(int sd_id, int attr_index)
        {
            int           status    = 0;
            StringBuilder attr_name = new StringBuilder();

            GeoDo.HDF4.HDF4Helper.DataTypeDefinitions data_type;
            int count;

            status = HDF4Helper.SDattrinfo(sd_id, attr_index, attr_name, out data_type, out count);
            HDFAttribute ds = new HDFAttribute();

            ds._sd_id      = sd_id;
            ds._attr_index = attr_index;
            ds._name       = attr_name.ToString();
            ds._data_type  = data_type;
            ds._count      = count;
            return(ds);
        }
コード例 #12
0
        /// <summary>
        /// 读取数据集值
        /// </summary>
        /// <param name="start"></param>
        /// <param name="stride"></param>
        /// <param name="edges"></param>
        /// <param name="?"></param>
        /// <returns></returns>
        public bool Read(int[] start, int[] stride, int[] edges, IntPtr ptr)
        {
            int sds_id = -1;

            try
            {
                sds_id = Open();
                if (sds_id == -1)
                {
                    return(false);
                }
                int status = 0;
                status = HDF4Helper.SDreaddata(sds_id, start, stride, edges, ptr);
                return(true);
            }
            finally
            {
                Close(sds_id);
            }
        }
コード例 #13
0
        public static bool IsSupport(string filename, byte[] header1024)
        {
            bool status = false;

            if (header1024 != null)
            {
                status = HDF4Helper.IsHdf4(header1024);
            }
            else
            {
                status = HDF4Helper.IsHdf4(filename);
            }
            if (status)
            {
                DateTime dt;
                string   ptname;
                status = TryParseFileName(filename, out dt, out ptname);
            }
            return(status);
        }
コード例 #14
0
 public static bool IsCompatible(string fileName, byte[] header1024)
 {
     if (header1024 == null)
     {
         header1024 = new byte[1024];
         using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
         {
             fs.Read(header1024, 0, 1024);
             fs.Close();
         }
     }
     if (!HDF5Helper.IsHdf5(header1024) && !HDF4Helper.IsHdf4(header1024))
     {
         return(false);
     }
     L2ProductDefind[] l2Pros = L2ProductDefindParser.GetL2ProductDefs(fileName);
     if (l2Pros == null || l2Pros.Length == 0)
     {
         return(false);
     }
     return(true);
 }
コード例 #15
0
        public static H4SDS Load(int sd_id, int sds_index)
        {
            int           status   = 0;
            int           sds_id   = 0;
            int           sds_ref  = 0;
            StringBuilder sds_name = new StringBuilder();
            int           rank     = 0;

            int[] dimsizes = new int[MAX_DIMSIZES];
            HDF4Helper.DataTypeDefinitions datatype;
            int num_attrs = 0;

            sds_id  = H4SDAPI.SDselect(sd_id, sds_index);
            sds_ref = HDF4API.SDidtoref(sds_id);
            int sds_index2 = HDF4API.SDreftoindex(sd_id, sds_ref);

            //HDF4Helper.SDreaddata

            status = HDF4Helper.SDgetinfo(sds_id, sds_name, out rank, dimsizes, out datatype, out num_attrs);
            status = HDF4Helper.SDendaccess(sds_id);
            int[] dims = new int[rank];
            for (int i = 0; i < rank; i++)
            {
                dims[i] = dimsizes[i];
            }
            H4SDS ds = new H4SDS();

            ds._sd_id     = sd_id;
            ds._sds_ref   = sds_ref;
            ds._sds_id    = sds_id;
            ds._sds_name  = sds_name.ToString();
            ds._rank      = rank;
            ds._dimsizes  = dims;
            ds._datatype  = datatype;
            ds._num_attrs = num_attrs;
            return(ds);
        }
コード例 #16
0
        public int Open()
        {
            int id = -1;

            try
            {
                int index = 0;
                //int tag = (int)oid[0];
                //if (tag == H4SDS.DFTAG_NDG_NETCDF)
                //{
                //    index = (int)oid[1]; //HDFLibrary.SDidtoref(id) fails for netCDF
                //}
                //else
                //{
                index = HDF4API.SDreftoindex(_sd_id, _sds_ref);//(int)oid[1]
                //}
                id = HDF4Helper.SDselect(_sd_id, index);
            }
            catch (Exception ex)
            {
                id = -1;
            }
            return(id);
        }
コード例 #17
0
ファイル: H4Attribute.cs プロジェクト: configare/hispeed
        private void GetValue()
        {
            int status = 0;

            switch (_data_type)
            {
            case HDF4Helper.DataTypeDefinitions.DFNT_CHAR8:    //string
            //case HDF4Helper.DataTypeDefinitions.DFNT_CHAR:
            case HDF4Helper.DataTypeDefinitions.DFNT_UCHAR8:
                //case HDF4Helper.DataTypeDefinitions.DFNT_UCHAR:
            {
                IntPtr ptr = Marshal.AllocHGlobal(_count * 8);
                status = HDF4Helper.SDreadattr(_sd_id, _attr_index, ptr);
                var buffer = new byte[_count];
                Marshal.Copy(ptr, buffer, 0, _count);
                Marshal.FreeHGlobal(ptr);
                _value = Encoding.ASCII.GetString(buffer);        //new ASCIIEncoding()
            }
            break;

            case HDF4Helper.DataTypeDefinitions.DFNT_INT8:
            case HDF4Helper.DataTypeDefinitions.DFNT_UINT8:
            {
                IntPtr ptr = Marshal.AllocHGlobal(_count * 8);
                status = HDF4Helper.SDreadattr(_sd_id, _attr_index, ptr);
                var buffer = new byte[_count];
                Marshal.Copy(ptr, buffer, 0, _count);
                Marshal.FreeHGlobal(ptr);
                _value = buffer;
            }
            break;

            case HDF4Helper.DataTypeDefinitions.DFNT_INT16:
            case HDF4Helper.DataTypeDefinitions.DFNT_UINT16:
            {
                IntPtr ptr = Marshal.AllocHGlobal(_count * 16);
                status = HDF4Helper.SDreadattr(_sd_id, _attr_index, ptr);
                var buffer = new short[_count];
                Marshal.Copy(ptr, buffer, 0, _count);
                Marshal.FreeHGlobal(ptr);
                _value = buffer;
            }
            break;

            case HDF4Helper.DataTypeDefinitions.DFNT_INT32:
            case HDF4Helper.DataTypeDefinitions.DFNT_UINT32:
            {
                IntPtr ptr = Marshal.AllocHGlobal(_count * 32);
                status = HDF4Helper.SDreadattr(_sd_id, _attr_index, ptr);
                var buffer = new int[_count];
                Marshal.Copy(ptr, buffer, 0, _count);
                Marshal.FreeHGlobal(ptr);
                _value = buffer;
            }
            break;

            case HDF4Helper.DataTypeDefinitions.DFNT_FLOAT32:
            {
                IntPtr ptr = Marshal.AllocHGlobal(_count * 32);
                status = HDF4Helper.SDreadattr(_sd_id, _attr_index, ptr);
                var buffer = new float[_count];
                Marshal.Copy(ptr, buffer, 0, _count);
                Marshal.FreeHGlobal(ptr);
                _value = buffer;
            }
            break;

            case HDF4Helper.DataTypeDefinitions.DFNT_FLOAT64:
            {
                IntPtr ptr = Marshal.AllocHGlobal(_count * 64);
                status = HDF4Helper.SDreadattr(_sd_id, _attr_index, ptr);
                var buffer = new double[_count];
                Marshal.Copy(ptr, buffer, 0, _count);
                Marshal.FreeHGlobal(ptr);
                _value = buffer;
            }
            break;

            case HDF4Helper.DataTypeDefinitions.DFNT_NINT8:
                break;

            case HDF4Helper.DataTypeDefinitions.DFNT_NUINT8:
                break;

            case HDF4Helper.DataTypeDefinitions.DFNT_NINT16:
                break;

            case HDF4Helper.DataTypeDefinitions.DFNT_NUINT16:
                break;

            case HDF4Helper.DataTypeDefinitions.DFNT_NINT32:
                break;

            case HDF4Helper.DataTypeDefinitions.DFNT_NUINT32:
                break;

            case HDF4Helper.DataTypeDefinitions.DFNT_NFLOAT32:
                break;

            case HDF4Helper.DataTypeDefinitions.DFNT_NFLOAT64:
                break;

            default:
                break;
            }
        }
コード例 #18
0
        public HObject Get(string path)
        {
            //if (objList == null) {
            //    objList = new Vector();
            //}

            if (string.IsNullOrWhiteSpace(path))
            {
                return(null);
            }
            path = path.Replace('\\', '/');
            if (!path.StartsWith("/"))
            {
                path = "/" + path;
            }
            string name = null, pPath = null;
            bool   isRoot = false;

            if (path.Equals("/"))
            {
                name   = "/"; // the root
                isRoot = true;
            }
            else
            {
                if (path.EndsWith("/"))
                {
                    path = path.Substring(0, path.Length - 2);
                }
                int idx = path.LastIndexOf('/');
                name = path.Substring(idx + 1);
                if (idx == 0)
                {
                    pPath = "/";
                }
                else
                {
                    pPath = path.Substring(0, idx);
                }
            }
            HObject obj        = null;
            bool    isReadOnly = false;

            if (_file_id < 0)
            {
                _file_id = HDF4API.Hopen(_filename, DFACC.DFACC_WRITE, 0);
                if (_file_id < 0)
                {
                    isReadOnly = true;
                    _file_id   = HDF4API.Hopen(_filename, DFACC.DFACC_READ, 0);
                }
                HDF4API.Vstart(_file_id);
                //grid = HDF4API.GRstart(_file_id);
                _sd_id = HDF4Helper.SDstart(_filename, HDF4Helper.AccessCodes.DFACC_READ);
            }
            //if (isRoot)
            //{
            //    obj = getRootGroup();
            //}
            //else
            //{
            //    obj = getAttachedObject(pPath, name);
            //}
            return(obj);
        }