www.pudn.com > vcmatlab20060426WaterMark.zip > iofun_private_imhdfinfo.cpp
//
// MATLAB Compiler: 2.2
// Date: Tue May 10 11:47:30 2005
// Arguments: "-B" "macro_default" "-O" "all" "-O" "fold_scalar_mxarrays:on"
// "-O" "fold_non_scalar_mxarrays:on" "-O" "optimize_integer_for_loops:on" "-O"
// "array_indexing:on" "-O" "optimize_conditionals:on" "-B" "sglcpp" "-p" "-W"
// "main" "-L" "Cpp" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-W" "mainhg"
// "libmwsglm.mlib" "huatu"
//
#include "iofun_private_imhdfinfo.hpp"
#include "libmatlbm.hpp"
#include "libmmfile.hpp"
#include "libmwsglm.hpp"
static mxChar _array1_[164] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'o', 'f', 'u', 'n',
'/', 'p', 'r', 'i', 'v', 'a', 't', 'e', '/',
'i', 'm', 'h', 'd', 'f', 'i', 'n', 'f', 'o',
' ', 'L', 'i', 'n', 'e', ':', ' ', '1', ' ',
'C', 'o', 'l', 'u', 'm', 'n', ':', ' ', '1',
' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n', 'c',
't', 'i', 'o', 'n', ' ', '"', 'i', 'o', 'f',
'u', 'n', '/', 'p', 'r', 'i', 'v', 'a', 't',
'e', '/', 'i', 'm', 'h', 'd', 'f', 'i', 'n',
'f', 'o', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'o',
'u', 't', 'p', 'u', 't', 's', ' ', '(', '2',
')', '.' };
static mwArray _mxarray0_ = mclInitializeString(164, _array1_);
static mxChar _array3_[163] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'o', 'f', 'u', 'n',
'/', 'p', 'r', 'i', 'v', 'a', 't', 'e', '/',
'i', 'm', 'h', 'd', 'f', 'i', 'n', 'f', 'o',
' ', 'L', 'i', 'n', 'e', ':', ' ', '1', ' ',
'C', 'o', 'l', 'u', 'm', 'n', ':', ' ', '1',
' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n', 'c',
't', 'i', 'o', 'n', ' ', '"', 'i', 'o', 'f',
'u', 'n', '/', 'p', 'r', 'i', 'v', 'a', 't',
'e', '/', 'i', 'm', 'h', 'd', 'f', 'i', 'n',
'f', 'o', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'i',
'n', 'p', 'u', 't', 's', ' ', '(', '1', ')',
'.' };
static mwArray _mxarray2_ = mclInitializeString(163, _array3_);
static mxChar _array5_[156] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'h', 'd', 'f',
'i', 'n', 'f', 'o', '/', 'h', 'd', 'f', 'e',
'r', 'r', 'o', 'r', ' ', 'L', 'i', 'n', 'e',
':', ' ', '2', '1', '9', ' ', 'C', 'o', 'l',
'u', 'm', 'n', ':', ' ', '1', ' ', 'T', 'h',
'e', ' ', 'f', 'u', 'n', 'c', 't', 'i', 'o',
'n', ' ', '"', 'i', 'm', 'h', 'd', 'f', 'i',
'n', 'f', 'o', '/', 'h', 'd', 'f', 'e', 'r',
'r', 'o', 'r', '"', ' ', 'w', 'a', 's', ' ',
'c', 'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i',
't', 'h', ' ', 'm', 'o', 'r', 'e', ' ', 't',
'h', 'a', 'n', ' ', 't', 'h', 'e', ' ', 'd',
'e', 'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n',
'u', 'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ',
'o', 'u', 't', 'p', 'u', 't', 's', ' ', '(',
'1', ')', '.' };
static mwArray _mxarray4_ = mclInitializeString(156, _array5_);
static mxChar _array7_[155] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'h', 'd', 'f',
'i', 'n', 'f', 'o', '/', 'h', 'd', 'f', 'e',
'r', 'r', 'o', 'r', ' ', 'L', 'i', 'n', 'e',
':', ' ', '2', '1', '9', ' ', 'C', 'o', 'l',
'u', 'm', 'n', ':', ' ', '1', ' ', 'T', 'h',
'e', ' ', 'f', 'u', 'n', 'c', 't', 'i', 'o',
'n', ' ', '"', 'i', 'm', 'h', 'd', 'f', 'i',
'n', 'f', 'o', '/', 'h', 'd', 'f', 'e', 'r',
'r', 'o', 'r', '"', ' ', 'w', 'a', 's', ' ',
'c', 'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i',
't', 'h', ' ', 'm', 'o', 'r', 'e', ' ', 't',
'h', 'a', 'n', ' ', 't', 'h', 'e', ' ', 'd',
'e', 'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n',
'u', 'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ',
'i', 'n', 'p', 'u', 't', 's', ' ', '(', '0',
')', '.' };
static mwArray _mxarray6_ = mclInitializeString(155, _array7_);
static mxChar _array9_[154] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'h', 'd', 'f',
'i', 'n', 'f', 'o', '/', 'n', 'u', 'm', 'c',
'o', 'm', 'p', ' ', 'L', 'i', 'n', 'e', ':',
' ', '2', '2', '9', ' ', 'C', 'o', 'l', 'u',
'm', 'n', ':', ' ', '1', ' ', 'T', 'h', 'e',
' ', 'f', 'u', 'n', 'c', 't', 'i', 'o', 'n',
' ', '"', 'i', 'm', 'h', 'd', 'f', 'i', 'n',
'f', 'o', '/', 'n', 'u', 'm', 'c', 'o', 'm',
'p', '"', ' ', 'w', 'a', 's', ' ', 'c', 'a',
'l', 'l', 'e', 'd', ' ', 'w', 'i', 't', 'h',
' ', 'm', 'o', 'r', 'e', ' ', 't', 'h', 'a',
'n', ' ', 't', 'h', 'e', ' ', 'd', 'e', 'c',
'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u', 'm',
'b', 'e', 'r', ' ', 'o', 'f', ' ', 'o', 'u',
't', 'p', 'u', 't', 's', ' ', '(', '1', ')',
'.' };
static mwArray _mxarray8_ = mclInitializeString(154, _array9_);
static mxChar _array11_[153] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'h', 'd', 'f',
'i', 'n', 'f', 'o', '/', 'n', 'u', 'm', 'c',
'o', 'm', 'p', ' ', 'L', 'i', 'n', 'e', ':',
' ', '2', '2', '9', ' ', 'C', 'o', 'l', 'u',
'm', 'n', ':', ' ', '1', ' ', 'T', 'h', 'e',
' ', 'f', 'u', 'n', 'c', 't', 'i', 'o', 'n',
' ', '"', 'i', 'm', 'h', 'd', 'f', 'i', 'n',
'f', 'o', '/', 'n', 'u', 'm', 'c', 'o', 'm',
'p', '"', ' ', 'w', 'a', 's', ' ', 'c', 'a',
'l', 'l', 'e', 'd', ' ', 'w', 'i', 't', 'h',
' ', 'm', 'o', 'r', 'e', ' ', 't', 'h', 'a',
'n', ' ', 't', 'h', 'e', ' ', 'd', 'e', 'c',
'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u', 'm',
'b', 'e', 'r', ' ', 'o', 'f', ' ', 'i', 'n',
'p', 'u', 't', 's', ' ', '(', '2', ')', '.' };
static mwArray _mxarray10_ = mclInitializeString(153, _array11_);
static mxChar _array13_[164] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'h', 'd', 'f',
'i', 'n', 'f', 'o', '/', 'U', 'i', 'n', 't',
'1', '6', 'D', 'e', 'c', 'o', 'd', 'e', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '7', '3',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'h', 'd', 'f', 'i', 'n', 'f', 'o', '/', 'U',
'i', 'n', 't', '1', '6', 'D', 'e', 'c', 'o',
'd', 'e', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'o',
'u', 't', 'p', 'u', 't', 's', ' ', '(', '1',
')', '.' };
static mwArray _mxarray12_ = mclInitializeString(164, _array13_);
static mxChar _array15_[163] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'h', 'd', 'f',
'i', 'n', 'f', 'o', '/', 'U', 'i', 'n', 't',
'1', '6', 'D', 'e', 'c', 'o', 'd', 'e', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '7', '3',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'h', 'd', 'f', 'i', 'n', 'f', 'o', '/', 'U',
'i', 'n', 't', '1', '6', 'D', 'e', 'c', 'o',
'd', 'e', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'i',
'n', 'p', 'u', 't', 's', ' ', '(', '1', ')',
'.' };
static mwArray _mxarray14_ = mclInitializeString(163, _array15_);
static mxChar _array17_[162] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'h', 'd', 'f',
'i', 'n', 'f', 'o', '/', 'C', 'o', 'u', 'n',
't', 'I', 'm', 'a', 'g', 'e', 's', ' ', 'L',
'i', 'n', 'e', ':', ' ', '2', '8', '3', ' ',
'C', 'o', 'l', 'u', 'm', 'n', ':', ' ', '1',
' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n', 'c',
't', 'i', 'o', 'n', ' ', '"', 'i', 'm', 'h',
'd', 'f', 'i', 'n', 'f', 'o', '/', 'C', 'o',
'u', 'n', 't', 'I', 'm', 'a', 'g', 'e', 's',
'"', ' ', 'w', 'a', 's', ' ', 'c', 'a', 'l',
'l', 'e', 'd', ' ', 'w', 'i', 't', 'h', ' ',
'm', 'o', 'r', 'e', ' ', 't', 'h', 'a', 'n',
' ', 't', 'h', 'e', ' ', 'd', 'e', 'c', 'l',
'a', 'r', 'e', 'd', ' ', 'n', 'u', 'm', 'b',
'e', 'r', ' ', 'o', 'f', ' ', 'o', 'u', 't',
'p', 'u', 't', 's', ' ', '(', '1', ')', '.' };
static mwArray _mxarray16_ = mclInitializeString(162, _array17_);
static mxChar _array19_[161] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'h', 'd', 'f',
'i', 'n', 'f', 'o', '/', 'C', 'o', 'u', 'n',
't', 'I', 'm', 'a', 'g', 'e', 's', ' ', 'L',
'i', 'n', 'e', ':', ' ', '2', '8', '3', ' ',
'C', 'o', 'l', 'u', 'm', 'n', ':', ' ', '1',
' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n', 'c',
't', 'i', 'o', 'n', ' ', '"', 'i', 'm', 'h',
'd', 'f', 'i', 'n', 'f', 'o', '/', 'C', 'o',
'u', 'n', 't', 'I', 'm', 'a', 'g', 'e', 's',
'"', ' ', 'w', 'a', 's', ' ', 'c', 'a', 'l',
'l', 'e', 'd', ' ', 'w', 'i', 't', 'h', ' ',
'm', 'o', 'r', 'e', ' ', 't', 'h', 'a', 'n',
' ', 't', 'h', 'e', ' ', 'd', 'e', 'c', 'l',
'a', 'r', 'e', 'd', ' ', 'n', 'u', 'm', 'b',
'e', 'r', ' ', 'o', 'f', ' ', 'i', 'n', 'p',
'u', 't', 's', ' ', '(', '1', ')', '.' };
static mwArray _mxarray18_ = mclInitializeString(161, _array19_);
static mwArray _mxarray20_ = mclInitializeCharVector(0, 0, (mxChar *)NULL);
static mwArray _mxarray21_ = mclInitializeDoubleVector(0, 0, (double *)NULL);
static mxChar _array23_[25] = { 'F', 'I', 'L', 'E', 'N', 'A', 'M', 'E', ' ',
'm', 'u', 's', 't', ' ', 'b', 'e', ' ', 'a',
' ', 's', 't', 'r', 'i', 'n', 'g' };
static mwArray _mxarray22_ = mclInitializeString(25, _array23_);
static mxChar _array25_[1] = { 'r' };
static mwArray _mxarray24_ = mclInitializeString(1, _array25_);
static mxChar _array27_[7] = { 'i', 'e', 'e', 'e', '-', 'b', 'e' };
static mwArray _mxarray26_ = mclInitializeString(7, _array27_);
static mwArray _mxarray28_ = mclInitializeDouble(-1.0);
static mwArray _mxarray29_ = mclInitializeDouble(1.0);
static mxChar _array31_[6] = { 'u', 'i', 'n', 't', '3', '2' };
static mwArray _mxarray30_ = mclInitializeString(6, _array31_);
static mxChar _array33_[16] = { 'T', 'r', 'u', 'n', 'c', 'a', 't', 'e',
'd', ' ', 'h', 'e', 'a', 'd', 'e', 'r' };
static mwArray _mxarray32_ = mclInitializeString(16, _array33_);
static mwArray _mxarray34_ = mclInitializeDouble(235082497.0);
static mxChar _array36_[15] = { 'N', 'o', 't', ' ', 'a', 'n', ' ', 'H',
'D', 'F', ' ', 'f', 'i', 'l', 'e' };
static mwArray _mxarray35_ = mclInitializeString(15, _array36_);
static mwArray _mxarray37_ = mclInitializeDouble(306.0);
static mwArray _mxarray38_ = mclInitializeDouble(300.0);
static mwArray _mxarray39_ = mclInitializeDouble(0.0);
static mxChar _array41_[3] = { 'h', 'd', 'f' };
static mwArray _mxarray40_ = mclInitializeString(3, _array41_);
static mxChar _array43_[1] = { 'H' };
static mwArray _mxarray42_ = mclInitializeString(1, _array43_);
static mxChar _array45_[5] = { 'i', 's', 'h', 'd', 'f' };
static mwArray _mxarray44_ = mclInitializeString(5, _array45_);
static double _array47_[4] = { 14.0, 3.0, 19.0, 1.0 };
static mwArray _mxarray46_ = mclInitializeDoubleVector(1, 4, _array47_);
static mxChar _array49_[4] = { 'D', 'F', 'R', '8' };
static mwArray _mxarray48_ = mclInitializeString(4, _array49_);
static mxChar _array51_[7] = { 'r', 'e', 's', 't', 'a', 'r', 't' };
static mwArray _mxarray50_ = mclInitializeString(7, _array51_);
static mxChar _array53_[4] = { 'D', 'F', '2', '4' };
static mwArray _mxarray52_ = mclInitializeString(4, _array53_);
static mxChar _array55_[4] = { 'o', 'p', 'e', 'n' };
static mwArray _mxarray54_ = mclInitializeString(4, _array55_);
static mxChar _array57_[4] = { 'r', 'e', 'a', 'd' };
static mwArray _mxarray56_ = mclInitializeString(4, _array57_);
static mxChar _array59_[14] = { 'g', 'e', 't', 'f', 'i', 'l', 'e',
'v', 'e', 'r', 's', 'i', 'o', 'n' };
static mwArray _mxarray58_ = mclInitializeString(14, _array59_);
static mxChar _array61_[5] = { 'c', 'l', 'o', 's', 'e' };
static mwArray _mxarray60_ = mclInitializeString(5, _array61_);
static mxChar _array63_[8] = { '%', 'd', '.', '%', 'd', '.', '%', 'd' };
static mwArray _mxarray62_ = mclInitializeString(8, _array63_);
static mxChar _array65_[47] = { 'N', 'o', ' ', '8', '-', 'b', 'i', 't',
' ', 'o', 'r', ' ', '2', '4', '-', 'b',
'i', 't', ' ', 'r', 'a', 's', 't', 'e',
'r', ' ', 'i', 'm', 'a', 'g', 'e', ' ',
'd', 'a', 't', 'a', ' ', 's', 'e', 't',
's', ' ', 'f', 'o', 'u', 'n', 'd' };
static mwArray _mxarray64_ = mclInitializeString(47, _array65_);
static mxChar _array67_[9] = { 's', 't', 'a', 'r', 't', 'r', 'e', 'a', 'd' };
static mwArray _mxarray66_ = mclInitializeString(9, _array67_);
static mxChar _array69_[8] = { 'n', 'e', 'x', 't', 'r', 'e', 'a', 'd' };
static mwArray _mxarray68_ = mclInitializeString(8, _array69_);
static mxChar _array71_[7] = { 'c', 'u', 'r', 'r', 'e', 'n', 't' };
static mwArray _mxarray70_ = mclInitializeString(7, _array71_);
static mxChar _array73_[9] = { 'e', 'n', 'd', 'a', 'c', 'c', 'e', 's', 's' };
static mwArray _mxarray72_ = mclInitializeString(9, _array73_);
static mxChar _array75_[7] = { 'i', 'n', 'q', 'u', 'i', 'r', 'e' };
static mwArray _mxarray74_ = mclInitializeString(7, _array75_);
static mxChar _array77_[7] = { 'r', 'e', 'a', 'd', 'r', 'e', 'f' };
static mwArray _mxarray76_ = mclInitializeString(7, _array77_);
static mxChar _array79_[7] = { 'g', 'e', 't', 'd', 'i', 'm', 's' };
static mwArray _mxarray78_ = mclInitializeString(7, _array79_);
static mwArray _mxarray80_ = mclInitializeDouble(8.0);
static mxChar _array82_[7] = { 'i', 'n', 'd', 'e', 'x', 'e', 'd' };
static mwArray _mxarray81_ = mclInitializeString(7, _array82_);
static mxChar _array84_[9] = { 'g', 'r', 'a', 'y', 's', 'c', 'a', 'l', 'e' };
static mwArray _mxarray83_ = mclInitializeString(9, _array84_);
static mwArray _mxarray85_ = mclInitializeDouble(3.0);
static mwArray _mxarray86_ = mclInitializeDouble(24.0);
static mxChar _array88_[9] = { 't', 'r', 'u', 'e', 'c', 'o', 'l', 'o', 'r' };
static mwArray _mxarray87_ = mclInitializeString(9, _array88_);
static mxChar _array90_[54] = { 'C', 'a', 'n', ' ', 'o', 'n', 'l', 'y', ' ',
'r', 'e', 'a', 'd', ' ', '1', '-', ' ', 'o',
'r', ' ', '3', '-', 'c', 'o', 'm', 'p', 'o',
'n', 'e', 'n', 't', ' ', 'r', 'a', 's', 't',
'e', 'r', ' ', 'i', 'm', 'a', 'g', 'e', ' ',
'd', 'a', 't', 'a', ' ', 's', 'e', 't', 's' };
static mwArray _mxarray89_ = mclInitializeString(54, _array90_);
static mxChar _array92_[54] = { 'T', 'h', 'e', ' ', 'N', 'C', 'S', 'A',
' ', 'H', 'D', 'F', ' ', 'l', 'i', 'b',
'r', 'a', 'r', 'y', ' ', 'r', 'e', 'p',
'o', 'r', 't', 'e', 'd', ' ', 't', 'h',
'e', ' ', 'f', 'o', 'l', 'l', 'o', 'w',
'i', 'n', 'g', ' ', 'e', 'r', 'r', 'o',
'r', ':', 0x005c, 'n', '%', 's' };
static mwArray _mxarray91_ = mclInitializeString(54, _array92_);
static mxChar _array94_[2] = { 'H', 'E' };
static mwArray _mxarray93_ = mclInitializeString(2, _array94_);
static mxChar _array96_[6] = { 's', 't', 'r', 'i', 'n', 'g' };
static mwArray _mxarray95_ = mclInitializeString(6, _array96_);
static mxChar _array98_[5] = { 'v', 'a', 'l', 'u', 'e' };
static mwArray _mxarray97_ = mclInitializeString(5, _array98_);
static mwArray _mxarray99_ = mclInitializeDouble(2.0);
static mwArray _mxarray100_ = mclInitializeDouble(14.0);
static mwArray _mxarray101_ = mclInitializeDouble(13.0);
void InitializeModule_iofun_private_imhdfinfo() {
}
void TerminateModule_iofun_private_imhdfinfo() {
}
static mwArray imhdfinfo_hdferror();
#ifdef __cplusplus
extern "C"
#endif
void mlxImhdfinfo_hdferror(int nlhs,
mxArray * plhs[],
int nrhs,
mxArray * prhs[]);
static mwArray imhdfinfo_numcomp(mwArray file_id = mwArray::DIN,
mwArray ref = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxImhdfinfo_numcomp(int nlhs,
mxArray * plhs[],
int nrhs,
mxArray * prhs[]);
static mwArray imhdfinfo_Uint16Decode(mwArray in = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxImhdfinfo_Uint16Decode(int nlhs,
mxArray * plhs[],
int nrhs,
mxArray * prhs[]);
static mwArray imhdfinfo_CountImages(mwArray file_id = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxImhdfinfo_CountImages(int nlhs,
mxArray * plhs[],
int nrhs,
mxArray * prhs[]);
static mwArray Miofun_private_imhdfinfo(mwArray * msg,
int nargout_,
mwArray filename);
static mwArray Mimhdfinfo_hdferror(int nargout_);
static mwArray Mimhdfinfo_numcomp(int nargout_, mwArray file_id, mwArray ref);
static mwArray Mimhdfinfo_Uint16Decode(int nargout_, mwArray in);
static mwArray Mimhdfinfo_CountImages(int nargout_, mwArray file_id);
static mexFunctionTableEntry local_function_table_[4]
= { { "hdferror", mlxImhdfinfo_hdferror, 0, 1, NULL },
{ "numcomp", mlxImhdfinfo_numcomp, 2, 1, NULL },
{ "Uint16Decode", mlxImhdfinfo_Uint16Decode, 1, 1, NULL },
{ "CountImages", mlxImhdfinfo_CountImages, 1, 1, NULL } };
_mexLocalFunctionTable _local_function_table_iofun_private_imhdfinfo
= { 4, local_function_table_ };
//
// The function "iofun_private_imhdfinfo" contains the normal interface for the
// "iofun/private/imhdfinfo" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 1-219).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
mwArray iofun_private_imhdfinfo(mwArray * msg, mwArray filename) {
int nargout(1);
mwArray info(mclGetUninitializedArray());
mwArray msg__(mclGetUninitializedArray());
if (msg != NULL) {
++nargout;
}
info = Miofun_private_imhdfinfo(&msg__, nargout, filename);
if (msg != NULL) {
*msg = msg__;
}
return info;
}
//
// The function "mlxIofun_private_imhdfinfo" contains the feval interface for
// the "iofun/private/imhdfinfo" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 1-219).
// The feval function calls the implementation version of
// iofun/private/imhdfinfo through this function. This function processes any
// input arguments and passes them to the implementation version of the
// function, appearing above.
//
void mlxIofun_private_imhdfinfo(int nlhs,
mxArray * plhs[],
int nrhs,
mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[2];
int i;
mclCppUninitializeArrays(2, mplhs);
if (nlhs > 2) {
error(_mxarray0_);
}
if (nrhs > 1) {
error(_mxarray2_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Miofun_private_imhdfinfo(&mplhs[1], nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
for (i = 1; i < 2 && i < nlhs; ++i) {
plhs[i] = mplhs[i].FreezeData();
}
}
MW_END_MLX();
}
//
// The function "imhdfinfo_hdferror" contains the normal interface for the
// "imhdfinfo/hdferror" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 219-229).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imhdfinfo_hdferror() {
int nargout(1);
mwArray str(mclGetUninitializedArray());
str = Mimhdfinfo_hdferror(nargout);
return str;
}
//
// The function "mlxImhdfinfo_hdferror" contains the feval interface for the
// "imhdfinfo/hdferror" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 219-229).
// The feval function calls the implementation version of imhdfinfo/hdferror
// through this function. This function processes any input arguments and
// passes them to the implementation version of the function, appearing above.
//
void mlxImhdfinfo_hdferror(int nlhs,
mxArray * plhs[],
int nrhs,
mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mplhs[1];
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray4_);
}
if (nrhs > 0) {
error(_mxarray6_);
}
mplhs[0] = Mimhdfinfo_hdferror(nlhs);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "imhdfinfo_numcomp" contains the normal interface for the
// "imhdfinfo/numcomp" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 229-273).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imhdfinfo_numcomp(mwArray file_id, mwArray ref) {
int nargout(1);
mwArray num(mclGetUninitializedArray());
num = Mimhdfinfo_numcomp(nargout, file_id, ref);
return num;
}
//
// The function "mlxImhdfinfo_numcomp" contains the feval interface for the
// "imhdfinfo/numcomp" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 229-273).
// The feval function calls the implementation version of imhdfinfo/numcomp
// through this function. This function processes any input arguments and
// passes them to the implementation version of the function, appearing above.
//
void mlxImhdfinfo_numcomp(int nlhs,
mxArray * plhs[],
int nrhs,
mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[2];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray8_);
}
if (nrhs > 2) {
error(_mxarray10_);
}
for (i = 0; i < 2 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 2; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Mimhdfinfo_numcomp(nlhs, mprhs[0], mprhs[1]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "imhdfinfo_Uint16Decode" contains the normal interface for the
// "imhdfinfo/Uint16Decode" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 273-283).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imhdfinfo_Uint16Decode(mwArray in) {
int nargout(1);
mwArray out(mclGetUninitializedArray());
out = Mimhdfinfo_Uint16Decode(nargout, in);
return out;
}
//
// The function "mlxImhdfinfo_Uint16Decode" contains the feval interface for
// the "imhdfinfo/Uint16Decode" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 273-283).
// The feval function calls the implementation version of
// imhdfinfo/Uint16Decode through this function. This function processes any
// input arguments and passes them to the implementation version of the
// function, appearing above.
//
void mlxImhdfinfo_Uint16Decode(int nlhs,
mxArray * plhs[],
int nrhs,
mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray12_);
}
if (nrhs > 1) {
error(_mxarray14_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Mimhdfinfo_Uint16Decode(nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "imhdfinfo_CountImages" contains the normal interface for the
// "imhdfinfo/CountImages" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 283-302).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imhdfinfo_CountImages(mwArray file_id) {
int nargout(1);
mwArray numImages(mclGetUninitializedArray());
numImages = Mimhdfinfo_CountImages(nargout, file_id);
return numImages;
}
//
// The function "mlxImhdfinfo_CountImages" contains the feval interface for the
// "imhdfinfo/CountImages" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 283-302).
// The feval function calls the implementation version of imhdfinfo/CountImages
// through this function. This function processes any input arguments and
// passes them to the implementation version of the function, appearing above.
//
void mlxImhdfinfo_CountImages(int nlhs,
mxArray * plhs[],
int nrhs,
mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray16_);
}
if (nrhs > 1) {
error(_mxarray18_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Mimhdfinfo_CountImages(nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "Miofun_private_imhdfinfo" is the implementation version of the
// "iofun/private/imhdfinfo" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 1-219).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function [info,msg] = imhdfinfo(filename)
//
static mwArray Miofun_private_imhdfinfo(mwArray * msg,
int nargout_,
mwArray filename) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imhdfinfo);
mwArray info(mclGetUninitializedArray());
mwArray field(mclGetUninitializedArray());
mwArray p(mclGetUninitializedArray());
mwArray fieldNames(mclGetUninitializedArray());
mwArray status24(mclGetUninitializedArray());
mwArray il(mclGetUninitializedArray());
mwArray h24(mclGetUninitializedArray());
mwArray w24(mclGetUninitializedArray());
mwArray status8(mclGetUninitializedArray());
mwArray hasmap(mclGetUninitializedArray());
mwArray h8(mclGetUninitializedArray());
mwArray w8(mclGetUninitializedArray());
mwArray ref(mclGetUninitializedArray());
mwArray junk(mclGetUninitializedArray());
mwArray h_id(mclGetUninitializedArray());
mwArray k(mclGetUninitializedArray());
mwArray numImages(mclGetUninitializedArray());
mwArray status(mclGetUninitializedArray());
mwArray infostr(mclGetUninitializedArray());
mwArray release(mclGetUninitializedArray());
mwArray minor0(mclGetUninitializedArray());
mwArray major0(mclGetUninitializedArray());
mwArray file_id(mclGetUninitializedArray());
mwArray all(mclGetUninitializedArray());
mwArray FAIL(mclGetUninitializedArray());
mwArray DFREF_WILDCARD(mclGetUninitializedArray());
mwArray DFTAG_ID(mclGetUninitializedArray());
mwArray DFTAG_RIG(mclGetUninitializedArray());
mwArray ans(mclGetUninitializedArray());
mwArray val(mclGetUninitializedArray());
mwArray d(mclGetUninitializedArray());
mwArray m(mclGetUninitializedArray());
mwArray fid(mclGetUninitializedArray());
//
// %IMHDFINFO Get information about images in an HDF file.
// % [INFO,MSG] = IMHDFINFO(FILENAME) returns information about the
// % 8-bit and 24-bit raster image data sets in an HDF file. INFO
// % is a structure array with the following fields: Width,
// % Height, NumComponents, HasColormap, Tag, and Reference. The
// % length of the structure array equals the number of image data
// % sets in the file.
// %
// % If any error condition is encountered, such as an error opening
// % the file, MSG will contain a string describing the error and
// % INFO will be empty. Otherwise, MSG will be empty.
// %
// % See also IMREAD, IMWRITE, IMFINFO.
//
// % Steven L. Eddins, June 1996
// % Copyright 1984-2001 The MathWorks, Inc.
// % $Revision: 1.13 $ $Date: 2001/04/15 12:02:00 $
//
// % This function should not call error()! -SLE
//
// msg = '';
//
*msg = _mxarray20_;
//
// info = [];
//
info = _mxarray21_;
//
//
// if (~isstr(filename))
//
if (mclNotBool(mwVe(isstr(mwVa(filename, "filename"))))) {
//
// msg = 'FILENAME must be a string';
//
*msg = _mxarray22_;
//
// return;
//
goto return_;
//
// end
//
}
//
//
// % Find full filename
// [fid,m] = fopen(filename,'r','ieee-be');
//
fid = fopen(&m, mwVa(filename, "filename"), _mxarray24_, _mxarray26_);
//
// if (fid == -1)
//
if (mclEqBool(mwVv(fid, "fid"), _mxarray28_)) {
//
// info = [];
//
info = _mxarray21_;
//
// msg = m;
//
*msg = mwVsv(m, "m");
//
// return;
//
goto return_;
//
// end
//
}
//
//
// filename = fopen(fid);
//
filename = fopen(mwVv(fid, "fid"));
//
// d = dir(filename);
//
d = Ndir(1, mwVa(filename, "filename"));
//
// % Read in the first 4 bytes as a big-endian 32-bit number.
// % If the number is not 235082497, then we don't have an HDF
// % file. By checking here, we can bail out early without
// % loading the HDF gateway MEX-file.
// val = fread(fid, 1, 'uint32');
//
val = fread(mwVv(fid, "fid"), _mxarray29_, _mxarray30_);
//
// fclose(fid);
//
ans.EqAns(fclose(mwVv(fid, "fid")));
//
// if (isempty(val))
//
if (tobool(mwVe(isempty(mwVv(val, "val"))))) {
//
// info = [];
//
info = _mxarray21_;
//
// msg = 'Truncated header';
//
*msg = _mxarray32_;
//
// return;
//
goto return_;
//
// end
//
}
//
// if (val ~= 235082497)
//
if (mclNeBool(mwVv(val, "val"), _mxarray34_)) {
//
// info = [];
//
info = _mxarray21_;
//
// msg = 'Not an HDF file';
//
*msg = _mxarray35_;
//
// return;
//
goto return_;
//
// end
//
}
//
//
// %
// % Initialize the structure to fix the field order
// %
// info.Filename = [];
//
info.field("Filename") = _mxarray21_;
//
// info.FileModDate = '';
//
info.field("FileModDate") = _mxarray20_;
//
// info.FileSize = [];
//
info.field("FileSize") = _mxarray21_;
//
// info.Format = [];
//
info.field("Format") = _mxarray21_;
//
// info.FormatVersion = [];
//
info.field("FormatVersion") = _mxarray21_;
//
// info.Width = [];
//
info.field("Width") = _mxarray21_;
//
// info.Height = [];
//
info.field("Height") = _mxarray21_;
//
// info.BitDepth = [];
//
info.field("BitDepth") = _mxarray21_;
//
// info.ColorType = [];
//
info.field("ColorType") = _mxarray21_;
//
// info.FormatSignature = [];
//
info.field("FormatSignature") = _mxarray21_;
//
// info.NumComponents = [];
//
info.field("NumComponents") = _mxarray21_;
//
// info.HasColormap = [];
//
info.field("HasColormap") = _mxarray21_;
//
// info.Interlace = '';
//
info.field("Interlace") = _mxarray20_;
//
// info.Tag = [];
//
info.field("Tag") = _mxarray21_;
//
// info.Reference = [];
//
info.field("Reference") = _mxarray21_;
//
//
// DFTAG_RIG = 306;
//
DFTAG_RIG = _mxarray37_;
//
// DFTAG_ID = 300;
//
DFTAG_ID = _mxarray38_;
//
// DFREF_WILDCARD = 0;
//
DFREF_WILDCARD = _mxarray39_;
//
// FAIL = -1;
//
FAIL = _mxarray28_;
//
//
// all.Filename = filename;
//
all.field("Filename") = mwVsa(filename, "filename");
//
// all.FileModDate = d.date;
//
all.field("FileModDate") = mwVsv(d, "d").field("date");
//
// all.FileSize = d.bytes;
//
all.field("FileSize") = mwVsv(d, "d").field("bytes");
//
// all.Format = 'hdf';
//
all.field("Format") = _mxarray40_;
//
//
// if (~hdf('H','ishdf',filename))
//
if (mclNotBool(
mwVe(
Nhdf(
0,
mwValueVarargout(),
mwVarargin(
_mxarray42_, _mxarray44_, mwVa(filename, "filename")))))) {
//
// info = [];
//
info = _mxarray21_;
//
// msg = 'Not an HDF file';
//
*msg = _mxarray35_;
//
// return;
//
goto return_;
//
// else
//
} else {
//
// all.FormatSignature = [14 3 19 1];
//
all.field("FormatSignature") = _mxarray46_;
//
// end
//
}
//
//
// hdf('DFR8','restart');
//
ans.EqAns(Nhdf(0, mwAnsVarargout(), mwVarargin(_mxarray48_, _mxarray50_)));
//
// hdf('DF24','restart');
//
ans.EqAns(Nhdf(0, mwAnsVarargout(), mwVarargin(_mxarray52_, _mxarray50_)));
//
//
// file_id = hdf('H', 'open', filename, 'read', 0);
//
file_id
= Nhdf(
0,
mwValueVarargout(),
mwVarargin(
_mxarray42_,
_mxarray54_,
mwVa(filename, "filename"),
_mxarray56_,
_mxarray39_));
//
// if (file_id == FAIL)
//
if (mclEqBool(mwVv(file_id, "file_id"), mwVv(FAIL, "FAIL"))) {
//
// info = [];
//
info = _mxarray21_;
//
// msg = hdferror;
//
*msg = imhdfinfo_hdferror();
//
// return;
//
goto return_;
//
// end
//
}
//
//
// [major,minor,release,infostr,status] = hdf('H','getfileversion',file_id);
//
Nhdf(
0,
mwVarargout(major0, minor0, release, infostr, status),
mwVarargin(_mxarray42_, _mxarray58_, mwVv(file_id, "file_id")));
//
// if (status == FAIL)
//
if (mclEqBool(mwVv(status, "status"), mwVv(FAIL, "FAIL"))) {
//
// info = [];
//
info = _mxarray21_;
//
// msg = hdferror;
//
*msg = imhdfinfo_hdferror();
//
// hdf('H','close',file_id);
//
ans.EqAns(
Nhdf(
0,
mwAnsVarargout(),
mwVarargin(_mxarray42_, _mxarray60_, mwVv(file_id, "file_id"))));
//
// return;
//
goto return_;
//
// end
//
}
//
//
// all.FormatVersion = sprintf('%d.%d.%d', major, minor, release);
//
all.field("FormatVersion")
= sprintf(
_mxarray62_,
mwVarargin(
mwVv(major0, "major"),
mwVv(minor0, "minor"),
mwVv(release, "release")));
//
//
// %
// % Find number of objects in file with the Raster Image Group tag
// %
// % numImages = hdf('H', 'number', file_id, DFTAG_RIG);
// numImages = CountImages(file_id);
//
numImages = imhdfinfo_CountImages(mwVv(file_id, "file_id"));
//
// if (numImages == 0)
//
if (mclEqBool(mwVv(numImages, "numImages"), _mxarray39_)) {
//
// info = [];
//
info = _mxarray21_;
//
// msg = 'No 8-bit or 24-bit raster image data sets found';
//
*msg = _mxarray64_;
//
// hdf('H', 'close', file_id);
//
ans.EqAns(
Nhdf(
0,
mwAnsVarargout(),
mwVarargin(_mxarray42_, _mxarray60_, mwVv(file_id, "file_id"))));
//
// return;
//
goto return_;
//
// end
//
}
//
//
// %
// % Grow the INFO structure array
// %
// info(numImages).Format = 'hdf';
//
info(mwVsv(numImages, "numImages")).field("Format") = _mxarray40_;
//
//
// %
// % Find the reference numbers for all the raster image groups
// %
// for k = 1:numImages
//
{
int v_(mclForIntStart(1));
int e_(mclForIntEnd(mwVv(numImages, "numImages")));
if (v_ > e_) {
k = _mxarray21_;
} else {
//
// if (k == 1)
// h_id = hdf('H', 'startread', file_id, DFTAG_RIG, DFREF_WILDCARD);
// status = h_id;
// else
// status = hdf('H', 'nextread', h_id, DFTAG_RIG, DFREF_WILDCARD, ...
// 'current');
// end
// if (status == FAIL)
// hdf('H','endaccess',h_id);
// hdf('H','close',file_id);
// info = [];
// msg = hdferror;
// return;
// end
// [junk, junk, ref, junk, junk, junk, junk, junk, status] = ...
// hdf('H', 'inquire', h_id);
//
// if (status == FAIL)
// hdf('H','close',file_id);
// info = [];
// msg = hdferror;
// return;
// else
// info(k).Reference = ref;
// end
//
// info(k).NumComponents = numcomp(file_id, ref);
// end
//
for (; ; ) {
if (mclEqBool(v_, _mxarray29_)) {
h_id
= Nhdf(
0,
mwValueVarargout(),
mwVarargin(
_mxarray42_,
_mxarray66_,
mwVv(file_id, "file_id"),
mwVv(DFTAG_RIG, "DFTAG_RIG"),
mwVv(DFREF_WILDCARD, "DFREF_WILDCARD")));
status = mwVsv(h_id, "h_id");
} else {
status
= Nhdf(
0,
mwValueVarargout(),
mwVarargin(
_mxarray42_,
_mxarray68_,
mwVv(h_id, "h_id"),
mwVv(DFTAG_RIG, "DFTAG_RIG"),
mwVv(DFREF_WILDCARD, "DFREF_WILDCARD"),
_mxarray70_));
}
if (mclEqBool(mwVv(status, "status"), mwVv(FAIL, "FAIL"))) {
ans.EqAns(
Nhdf(
0,
mwAnsVarargout(),
mwVarargin(
_mxarray42_, _mxarray72_, mwVv(h_id, "h_id"))));
ans.EqAns(
Nhdf(
0,
mwAnsVarargout(),
mwVarargin(
_mxarray42_, _mxarray60_, mwVv(file_id, "file_id"))));
info = _mxarray21_;
*msg = imhdfinfo_hdferror();
goto return_;
}
Nhdf(
0,
mwVarargout(
junk, junk, ref, junk, junk, junk, junk, junk, status),
mwVarargin(_mxarray42_, _mxarray74_, mwVv(h_id, "h_id")));
if (mclEqBool(mwVv(status, "status"), mwVv(FAIL, "FAIL"))) {
ans.EqAns(
Nhdf(
0,
mwAnsVarargout(),
mwVarargin(
_mxarray42_, _mxarray60_, mwVv(file_id, "file_id"))));
info = _mxarray21_;
*msg = imhdfinfo_hdferror();
goto return_;
} else {
info(v_).field("Reference") = mwVsv(ref, "ref");
}
info(v_).field("NumComponents")
= imhdfinfo_numcomp(
mwVv(file_id, "file_id"), mwVv(ref, "ref"));
if (v_ == e_) {
break;
}
++v_;
}
k = v_;
}
}
//
// hdf('H','endaccess',h_id);
//
ans.EqAns(
Nhdf(
0,
mwAnsVarargout(),
mwVarargin(_mxarray42_, _mxarray72_, mwVv(h_id, "h_id"))));
//
// hdf('H','close',file_id);
//
ans.EqAns(
Nhdf(
0,
mwAnsVarargout(),
mwVarargin(_mxarray42_, _mxarray60_, mwVv(file_id, "file_id"))));
//
//
// %
// % Use the DFR8 and DF24 interfaces to get the rest of the information
// %
// for k = 1:numImages
//
{
int v_(mclForIntStart(1));
int e_(mclForIntEnd(mwVv(numImages, "numImages")));
if (v_ > e_) {
k = _mxarray21_;
} else {
//
// info(k).Format = 'hdf';
// ref = info(k).Reference;
//
// if (info(k).NumComponents == 1)
// hdf('DFR8','readref',filename,ref);
// [w8,h8,hasmap,status8] = hdf('DFR8', 'getdims', filename);
// info(k).Width = w8;
// info(k).Height = h8;
// info(k).BitDepth = 8;
// info(k).HasColormap = hasmap;
// if (info(k).HasColormap)
// info(k).ColorType = 'indexed';
// else
// info(k).ColorType = 'grayscale';
// end
// info(k).Tag = DFTAG_RIG;
//
// elseif (info(k).NumComponents == 3)
// hdf('DF24','readref',filename,ref);
// [w24,h24,il,status24] = hdf('DF24', 'getdims', filename);
// info(k).Width = w24;
// info(k).Height = h24;
// info(k).HasColormap = 0;
// info(k).BitDepth = 24;
// info(k).ColorType = 'truecolor';
// info(k).Interlace = il;
// info(k).Tag = DFTAG_RIG;
//
// else
// info = [];
// msg = 'Can only read 1- or 3-component raster image data sets';
// return;
// end
//
// end
//
for (; ; ) {
info(v_).field("Format") = _mxarray40_;
ref = mwVsv(info, "info")(v_).field("Reference");
if (tobool(
feval(
mwValueVarargout(),
mlxEq,
mwVarargin(
mwVe(mwVsv(info, "info")(v_).field("NumComponents")),
_mxarray29_)))) {
ans.EqAns(
Nhdf(
0,
mwAnsVarargout(),
mwVarargin(
_mxarray48_,
_mxarray76_,
mwVa(filename, "filename"),
mwVv(ref, "ref"))));
Nhdf(
0,
mwVarargout(w8, h8, hasmap, status8),
mwVarargin(
_mxarray48_, _mxarray78_, mwVa(filename, "filename")));
info(v_).field("Width") = mwVsv(w8, "w8");
info(v_).field("Height") = mwVsv(h8, "h8");
info(v_).field("BitDepth") = _mxarray80_;
info(v_).field("HasColormap") = mwVsv(hasmap, "hasmap");
if (tobool(
mwVe(mwVsv(info, "info")(v_).field("HasColormap")))) {
info(v_).field("ColorType") = _mxarray81_;
} else {
info(v_).field("ColorType") = _mxarray83_;
}
info(v_).field("Tag") = mwVsv(DFTAG_RIG, "DFTAG_RIG");
} else if (tobool(
feval(
mwValueVarargout(),
mlxEq,
mwVarargin(
mwVe(
mwVsv(info, "info")(v_).field(
"NumComponents")),
_mxarray85_)))) {
ans.EqAns(
Nhdf(
0,
mwAnsVarargout(),
mwVarargin(
_mxarray52_,
_mxarray76_,
mwVa(filename, "filename"),
mwVv(ref, "ref"))));
Nhdf(
0,
mwVarargout(w24, h24, il, status24),
mwVarargin(
_mxarray52_, _mxarray78_, mwVa(filename, "filename")));
info(v_).field("Width") = mwVsv(w24, "w24");
info(v_).field("Height") = mwVsv(h24, "h24");
info(v_).field("HasColormap") = _mxarray39_;
info(v_).field("BitDepth") = _mxarray86_;
info(v_).field("ColorType") = _mxarray87_;
info(v_).field("Interlace") = mwVsv(il, "il");
info(v_).field("Tag") = mwVsv(DFTAG_RIG, "DFTAG_RIG");
} else {
info = _mxarray21_;
*msg = _mxarray89_;
goto return_;
}
if (v_ == e_) {
break;
}
++v_;
}
k = v_;
}
}
//
//
// % Fill in the individual image info structures with the fields
// % that apply to all images.
// fieldNames = fieldnames(all);
//
fieldNames = fieldnames(mwVv(all, "all"));
//
// for k = 1:length(info)
//
{
int v_(mclForIntStart(1));
int e_(mclForIntEnd(mwArray(mclLengthInt(mwVv(info, "info")))));
if (v_ > e_) {
k = _mxarray21_;
} else {
//
// for p = 1:length(fieldNames)
// field = fieldNames{p};
// info(k) = setfield(info(k), field, getfield(all, field));
// end
// end
//
for (; ; ) {
int v_0(mclForIntStart(1));
int e_0
(mclForIntEnd(
mwArray(mclLengthInt(mwVv(fieldNames, "fieldNames")))));
if (v_0 > e_0) {
p = _mxarray21_;
} else {
for (; ; ) {
field = mwVsv(fieldNames, "fieldNames").cell(v_0);
mclIntArrayAssign(
&info,
setfield(
mwVe(mclIntArrayRef(mwVsv(info, "info"), v_)),
mwVarargin(
mwVv(field, "field"),
mwVe(
getfield(
mwVv(all, "all"),
mwVarargin(mwVv(field, "field")))))),
v_);
if (v_0 == e_0) {
break;
}
++v_0;
}
p = v_0;
}
if (v_ == e_) {
break;
}
++v_;
}
k = v_;
}
}
//
//
// %%%
// %%% Function hdferror
// %%%
// function str = hdferror()
//
return_:
mwValidateOutput(info, 1, nargout_, "info", "iofun/private/imhdfinfo");
mwValidateOutput(*msg, 2, nargout_, "msg", "iofun/private/imhdfinfo");
return info;
//
// %HDFERROR Return the current HDF error string.
//
// str = sprintf('The NCSA HDF library reported the following error:\n%s', ...
// hdf('HE', 'string', hdf('HE', 'value', 1)));
//
//
// %%%
// %%% Function numcomp
// %%%
//
}
//
// The function "Mimhdfinfo_hdferror" is the implementation version of the
// "imhdfinfo/hdferror" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 219-229).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function str = hdferror()
//
static mwArray Mimhdfinfo_hdferror(int nargout_) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imhdfinfo);
mwArray str(mclGetUninitializedArray());
//
// %HDFERROR Return the current HDF error string.
//
// str = sprintf('The NCSA HDF library reported the following error:\n%s', ...
//
str
= sprintf(
_mxarray91_,
mwVarargin(
mwVe(
Nhdf(
0,
mwValueVarargout(),
mwVarargin(
_mxarray93_,
_mxarray95_,
mwVe(
Nhdf(
0,
mwValueVarargout(),
mwVarargin(_mxarray93_, _mxarray97_, _mxarray29_))))))));
mwValidateOutput(str, 1, nargout_, "str", "imhdfinfo/hdferror");
return str;
//
// hdf('HE', 'string', hdf('HE', 'value', 1)));
//
//
// %%%
// %%% Function numcomp
// %%%
// function num = numcomp(file_id, ref)
// %NUMCOMP Number of components in raster image group
//
// FAIL = -1;
// DFTAG_RIG = 306;
// DFTAG_ID = 300;
//
// access_id = hdf('H', 'startread', file_id, DFTAG_RIG, ref);
// if (access_id == FAIL)
// num = [];
// return;
// end
//
// memberList = hdf('H', 'read', access_id, 0);
// hdf('H', 'endaccess', access_id);
//
// memberList = Uint16Decode(memberList);
// memberTags = memberList(1:2:end);
// memberRefs = memberList(2:2:end);
// idx = find(memberTags == DFTAG_ID);
// if (isempty(idx))
// num = [];
// return;
// else
// idx = idx(1);
// end
//
// access_id = hdf('H', 'startread', file_id, DFTAG_ID, memberRefs(idx));
// if (access_id == FAIL)
// num = [];
// return;
// end
// memberList = hdf('H', 'read', access_id, 14);
// hdf('H', 'endaccess', access_id);
// if (length(memberList) < 14)
// num = [];
// return;
// end
// num = Uint16Decode(memberList(13:14));
//
//
// %%%
// %%% Uint16Decode --- turn uint8 input into uint16 integers
// %%%
//
}
//
// The function "Mimhdfinfo_numcomp" is the implementation version of the
// "imhdfinfo/numcomp" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 229-273).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function num = numcomp(file_id, ref)
//
static mwArray Mimhdfinfo_numcomp(int nargout_, mwArray file_id, mwArray ref) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imhdfinfo);
mwArray num(mclGetUninitializedArray());
mwArray idx(mclGetUninitializedArray());
mwArray memberRefs(mclGetUninitializedArray());
mwArray memberTags(mclGetUninitializedArray());
mwArray ans(mclGetUninitializedArray());
mwArray memberList(mclGetUninitializedArray());
mwArray access_id(mclGetUninitializedArray());
mwArray DFTAG_ID(mclGetUninitializedArray());
mwArray DFTAG_RIG(mclGetUninitializedArray());
mwArray FAIL(mclGetUninitializedArray());
//
// %NUMCOMP Number of components in raster image group
//
// FAIL = -1;
//
FAIL = _mxarray28_;
//
// DFTAG_RIG = 306;
//
DFTAG_RIG = _mxarray37_;
//
// DFTAG_ID = 300;
//
DFTAG_ID = _mxarray38_;
//
//
// access_id = hdf('H', 'startread', file_id, DFTAG_RIG, ref);
//
access_id
= Nhdf(
0,
mwValueVarargout(),
mwVarargin(
_mxarray42_,
_mxarray66_,
mwVa(file_id, "file_id"),
mwVv(DFTAG_RIG, "DFTAG_RIG"),
mwVa(ref, "ref")));
//
// if (access_id == FAIL)
//
if (mclEqBool(mwVv(access_id, "access_id"), mwVv(FAIL, "FAIL"))) {
//
// num = [];
//
num = _mxarray21_;
//
// return;
//
goto return_;
//
// end
//
}
//
//
// memberList = hdf('H', 'read', access_id, 0);
//
memberList
= Nhdf(
0,
mwValueVarargout(),
mwVarargin(
_mxarray42_,
_mxarray56_,
mwVv(access_id, "access_id"),
_mxarray39_));
//
// hdf('H', 'endaccess', access_id);
//
ans.EqAns(
Nhdf(
0,
mwAnsVarargout(),
mwVarargin(_mxarray42_, _mxarray72_, mwVv(access_id, "access_id"))));
//
//
// memberList = Uint16Decode(memberList);
//
memberList = imhdfinfo_Uint16Decode(mwVv(memberList, "memberList"));
//
// memberTags = memberList(1:2:end);
//
memberTags
= mclArrayRef(
mwVsv(memberList, "memberList"),
colon(
_mxarray29_,
_mxarray99_,
end(mwVv(memberList, "memberList"), _mxarray29_, _mxarray29_)));
//
// memberRefs = memberList(2:2:end);
//
memberRefs
= mclArrayRef(
mwVsv(memberList, "memberList"),
colon(
_mxarray99_,
_mxarray99_,
end(mwVv(memberList, "memberList"), _mxarray29_, _mxarray29_)));
//
// idx = find(memberTags == DFTAG_ID);
//
idx = find(mwVv(memberTags, "memberTags") == mwVv(DFTAG_ID, "DFTAG_ID"));
//
// if (isempty(idx))
//
if (tobool(mwVe(isempty(mwVv(idx, "idx"))))) {
//
// num = [];
//
num = _mxarray21_;
//
// return;
//
goto return_;
//
// else
//
} else {
//
// idx = idx(1);
//
idx = mclIntArrayRef(mwVsv(idx, "idx"), 1);
//
// end
//
}
//
//
// access_id = hdf('H', 'startread', file_id, DFTAG_ID, memberRefs(idx));
//
access_id
= Nhdf(
0,
mwValueVarargout(),
mwVarargin(
_mxarray42_,
_mxarray66_,
mwVa(file_id, "file_id"),
mwVv(DFTAG_ID, "DFTAG_ID"),
mwVe(
mclArrayRef(
mwVsv(memberRefs, "memberRefs"), mwVsv(idx, "idx")))));
//
// if (access_id == FAIL)
//
if (mclEqBool(mwVv(access_id, "access_id"), mwVv(FAIL, "FAIL"))) {
//
// num = [];
//
num = _mxarray21_;
//
// return;
//
goto return_;
//
// end
//
}
//
// memberList = hdf('H', 'read', access_id, 14);
//
memberList
= Nhdf(
0,
mwValueVarargout(),
mwVarargin(
_mxarray42_,
_mxarray56_,
mwVv(access_id, "access_id"),
_mxarray100_));
//
// hdf('H', 'endaccess', access_id);
//
ans.EqAns(
Nhdf(
0,
mwAnsVarargout(),
mwVarargin(_mxarray42_, _mxarray72_, mwVv(access_id, "access_id"))));
//
// if (length(memberList) < 14)
//
if (mclLengthInt(mwVv(memberList, "memberList")) < 14) {
//
// num = [];
//
num = _mxarray21_;
//
// return;
//
goto return_;
//
// end
//
}
//
// num = Uint16Decode(memberList(13:14));
//
num
= imhdfinfo_Uint16Decode(
mwVe(
mclArrayRef(
mwVsv(memberList, "memberList"),
colon(_mxarray101_, _mxarray100_))));
//
//
//
// %%%
// %%% Uint16Decode --- turn uint8 input into uint16 integers
// %%%
// function out = Uint16Decode(in)
//
return_:
mwValidateOutput(num, 1, nargout_, "num", "imhdfinfo/numcomp");
return num;
//
//
// msb = double(in(1:2:end));
// lsb = double(in(2:2:end));
//
// out = bitshift(msb,8) + lsb;
//
// %%%
// %%% CountImages --- count number of Raster Image Groups in file
// %%%
//
}
//
// The function "Mimhdfinfo_Uint16Decode" is the implementation version of the
// "imhdfinfo/Uint16Decode" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 273-283).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function out = Uint16Decode(in)
//
static mwArray Mimhdfinfo_Uint16Decode(int nargout_, mwArray in) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imhdfinfo);
mwArray out(mclGetUninitializedArray());
mwArray lsb(mclGetUninitializedArray());
mwArray msb(mclGetUninitializedArray());
//
//
// msb = double(in(1:2:end));
//
msb
= double_func(
mwVe(
mclArrayRef(
mwVsa(in, "in"),
colon(
_mxarray29_,
_mxarray99_,
end(mwVa(in, "in"), _mxarray29_, _mxarray29_)))));
//
// lsb = double(in(2:2:end));
//
lsb
= double_func(
mwVe(
mclArrayRef(
mwVsa(in, "in"),
colon(
_mxarray99_,
_mxarray99_,
end(mwVa(in, "in"), _mxarray29_, _mxarray29_)))));
//
//
// out = bitshift(msb,8) + lsb;
//
out = mwVe(bitshift(mwVv(msb, "msb"), _mxarray80_)) + mwVv(lsb, "lsb");
mwValidateOutput(out, 1, nargout_, "out", "imhdfinfo/Uint16Decode");
return out;
//
//
// %%%
// %%% CountImages --- count number of Raster Image Groups in file
// %%%
// function numImages = CountImages(file_id)
//
// DFTAG_RIG = 306;
// DFREF_WILDCARD = 0;
//
// numImages = 0;
// h_id = hdf('H','startread', file_id, DFTAG_RIG, DFREF_WILDCARD);
// if (h_id > 0)
// status = 0;
// else
// status = -1;
// end
//
// while (status == 0)
// numImages = numImages + 1;
// status = hdf('H','nextread',h_id,DFTAG_RIG, DFREF_WILDCARD,'current');
// end
// hdf('H','endaccess',h_id);
//
//
}
//
// The function "Mimhdfinfo_CountImages" is the implementation version of the
// "imhdfinfo/CountImages" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imhdfinfo.m" (lines 283-302).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function numImages = CountImages(file_id)
//
static mwArray Mimhdfinfo_CountImages(int nargout_, mwArray file_id) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imhdfinfo);
mwArray numImages(mclGetUninitializedArray());
mwArray ans(mclGetUninitializedArray());
mwArray status(mclGetUninitializedArray());
mwArray h_id(mclGetUninitializedArray());
mwArray DFREF_WILDCARD(mclGetUninitializedArray());
mwArray DFTAG_RIG(mclGetUninitializedArray());
//
//
// DFTAG_RIG = 306;
//
DFTAG_RIG = _mxarray37_;
//
// DFREF_WILDCARD = 0;
//
DFREF_WILDCARD = _mxarray39_;
//
//
// numImages = 0;
//
numImages = _mxarray39_;
//
// h_id = hdf('H','startread', file_id, DFTAG_RIG, DFREF_WILDCARD);
//
h_id
= Nhdf(
0,
mwValueVarargout(),
mwVarargin(
_mxarray42_,
_mxarray66_,
mwVa(file_id, "file_id"),
mwVv(DFTAG_RIG, "DFTAG_RIG"),
mwVv(DFREF_WILDCARD, "DFREF_WILDCARD")));
//
// if (h_id > 0)
//
if (mclGtBool(mwVv(h_id, "h_id"), _mxarray39_)) {
//
// status = 0;
//
status = _mxarray39_;
//
// else
//
} else {
//
// status = -1;
//
status = _mxarray28_;
//
// end
//
}
//
//
// while (status == 0)
//
while (mclEqBool(mwVv(status, "status"), _mxarray39_)) {
//
// numImages = numImages + 1;
//
numImages = mwVv(numImages, "numImages") + _mxarray29_;
//
// status = hdf('H','nextread',h_id,DFTAG_RIG, DFREF_WILDCARD,'current');
//
status
= Nhdf(
0,
mwValueVarargout(),
mwVarargin(
_mxarray42_,
_mxarray68_,
mwVv(h_id, "h_id"),
mwVv(DFTAG_RIG, "DFTAG_RIG"),
mwVv(DFREF_WILDCARD, "DFREF_WILDCARD"),
_mxarray70_));
//
// end
//
}
//
// hdf('H','endaccess',h_id);
//
ans.EqAns(
Nhdf(
0,
mwAnsVarargout(),
mwVarargin(_mxarray42_, _mxarray72_, mwVv(h_id, "h_id"))));
mwValidateOutput(
numImages, 1, nargout_, "numImages", "imhdfinfo/CountImages");
return numImages;
//
//
//
}