FBL_Begin_Namespace
/**********************************************************************************************/
I_IStream* CreateTextStream( I_Location_Ptr inLoc )
{
return new Text_Stream_OnFile( CreateTextFile(inLoc) );
}
///////////////////////////////////////////////////////////////////////////////
// OnTest
void CXZipTestDlg::OnTest()
{
#ifdef _UNICODE
ZIPENTRYW ze;
#else
ZIPENTRY ze;
#endif
memset(&ze, 0, sizeof(ze));
TCHAR * pszArchive1 = _T("_TestZipTmp1.zip");
TCHAR * pszArchive2 = _T("_TestZipTmp2.zip");
// text files
TCHAR * pszName1 = _T("_TestZipTmp1.txt");
TCHAR * pszName2 = _T("_TestZipTmp2.txt");
TCHAR * pszName3 = _T("_TestZipTmp3.txt");
// binary files
TCHAR * pszName4 = _T("_TestZipTmp4.bin");
TCHAR * pszName5 = _T("_TestZipTmp5.bin");
TCHAR * pszName6 = _T("_TestZipTmp6.bin");
TCHAR * pszName7 = _T("_TestZipTmp7.bin");
TCHAR * pszName8 = _T("_TestZipTmp8.bin");
TCHAR * pszName9 = _T("_TestZipTmp9.bin");
// delete zip files
::DeleteFile(pszArchive1);
::DeleteFile(pszArchive2);
// create .txt files
CreateTextFile(pszName1, 10000);
CreateTextFile(pszName2, 100);
CreateTextFile(pszName3, 10);
// create .bin files
CreateBinaryFile(pszName4, 16384);
CreateBinaryFile(pszName5, 3*16384);
CreateBinaryFile(pszName6, 8*16384);
CreateBinaryFile(pszName7, 123);
CreateBinaryFile(pszName8, 17000);
CreateBinaryFile(pszName9, 8*16384+1);
///////////////////////////////////////////////////////////////////////////
// single-file zip
m_List.AddLine(CXListBox::Blue, CXListBox::White, _T(""));
m_List.Printf(CXListBox::Navy, CXListBox::White, 0,
_T(" === Testing single-file zip ==="));
BOOL bRet = Zip(pszArchive1, pszName1);
if (bRet)
{
m_List.Printf(CXListBox::Green, CXListBox::White, 0,
_T(" Zip archive created OK"));
m_List.Printf(CXListBox::Black, CXListBox::White, 0,
_T(" === Testing unzip ==="));
HZIP hz = OpenZip(pszArchive1, 0, ZIP_FILENAME);
if (hz)
{
ZRESULT zr = GetZipItem(hz, -1, &ze);
if (zr == ZR_OK)
{
int numitems = ze.index;
if (numitems == 1)
{
m_List.Printf(CXListBox::Green, CXListBox::White, 0,
_T(" Zip archive contains 1 file ==> OK"));
VerifyZip(hz, pszName1);
CloseZip(hz);
}
else
{
m_List.Printf(CXListBox::Red, CXListBox::White, 0,
_T(" Zip contents bad"));
}
}
else
{
m_List.Printf(CXListBox::Red, CXListBox::White, 0,
_T(" GetZipItem failed"));
}
}
else
{
m_List.Printf(CXListBox::Red, CXListBox::White, 0,
_T(" Failed to open zip file '%s'"), pszArchive1);
}
}
else
{
m_List.Printf(CXListBox::Red, CXListBox::White, 0,
_T(" Failed to create zip"));
}
///////////////////////////////////////////////////////////////////////////
// multi-file zip
m_List.AddLine(CXListBox::Blue, CXListBox::White, _T(""));
m_List.Printf(CXListBox::Navy, CXListBox::White, 0,
_T(" === Testing multi-file zip ==="));
HZIP hz = CreateZip(pszArchive2, 0, ZIP_FILENAME);
if (hz)
{
m_List.Printf(CXListBox::Green, CXListBox::White, 0,
_T(" Zip archive created OK"));
if ((ZipAdd(hz, pszName1, pszName1, 0, ZIP_FILENAME) == ZR_OK) &&
(ZipAdd(hz, pszName2, pszName2, 0, ZIP_FILENAME) == ZR_OK) &&
(ZipAdd(hz, pszName3, pszName3, 0, ZIP_FILENAME) == ZR_OK) &&
(ZipAdd(hz, pszName4, pszName4, 0, ZIP_FILENAME) == ZR_OK) &&
(ZipAdd(hz, pszName5, pszName5, 0, ZIP_FILENAME) == ZR_OK) &&
(ZipAdd(hz, pszName6, pszName6, 0, ZIP_FILENAME) == ZR_OK) &&
(ZipAdd(hz, pszName7, pszName7, 0, ZIP_FILENAME) == ZR_OK) &&
(ZipAdd(hz, pszName8, pszName8, 0, ZIP_FILENAME) == ZR_OK) &&
(ZipAdd(hz, pszName9, pszName9, 0, ZIP_FILENAME) == ZR_OK))
{
m_List.Printf(CXListBox::Green, CXListBox::White, 0,
_T(" Files added to zip archive OK"));
CloseZip(hz);
hz = OpenZip(pszArchive2, 0, ZIP_FILENAME);
if (hz)
{
m_List.Printf(CXListBox::Green, CXListBox::White, 0,
_T(" Zip archive opened OK"));
GetZipItem(hz, -1, &ze);
int numitems = ze.index;
if (numitems == 9)
{
m_List.Printf(CXListBox::Green, CXListBox::White, 0,
_T(" Zip archive contains correct number of entries"));
for (int i = 0; i < numitems; i++)
{
GetZipItem(hz, i, &ze);
m_List.Printf(CXListBox::Black, CXListBox::White, 0,
_T(" %d: %s"), i, ze.name);
}
VerifyZip(hz, pszName1);
VerifyZip(hz, pszName2);
VerifyZip(hz, pszName3);
VerifyZip(hz, pszName4);
VerifyZip(hz, pszName5);
VerifyZip(hz, pszName6);
VerifyZip(hz, pszName7);
VerifyZip(hz, pszName8);
VerifyZip(hz, pszName9);
}
else
{
m_List.Printf(CXListBox::Red, CXListBox::White, 0,
_T(" Number of entries in zip archive is incorrect"));
}
}
else
{
m_List.Printf(CXListBox::Red, CXListBox::White, 0,
_T(" Failed to open zip archive"));
}
}
else
{
m_List.Printf(CXListBox::Red, CXListBox::White, 0,
_T(" Failed to add file to zip archive"));
}
}
else
{
m_List.Printf(CXListBox::Red, CXListBox::White, 0,
_T(" Failed to create zip archive"));
}
CloseZip(hz);
// the files are not deleted - you can inspect them after running test
//::DeleteFile(pszArchive1);
//::DeleteFile(pszArchive2);
//::DeleteFile(pszName1);
//::DeleteFile(pszName2);
//::DeleteFile(pszName3);
m_List.AddLine(CXListBox::Blue, CXListBox::White, _T(""));
}
static void
e5_export_bov(
const char* bov_file,
eid_t e5_file_id,
e5_grid_dataset* grid)
{
static const int min_bricklet = 1;
static const int max_bricklet = 32;
int i;
int d;
bov_header_t header;
e5_bov_attrs_t attrs;
memset(&header, 0, sizeof(bov_header_t));
memset(&attrs, 0, sizeof(e5_bov_attrs_t));
size_t len = strlen(bov_file) + 8;
char *data_file = malloc(len);
snprintf(data_file, len, "%s.data", e5_basename(bov_file));
eid_t e5_group_id = e5_open_group(e5_file_id, "/Emissivity/real scalars");
e5_attr real_scalars_attr[] = { {"time", &(attrs.time), E5_TYPE_DOUBLE, 0}, {0} };
estatus_t status = e5_read_attr_list(e5_group_id, real_scalars_attr);
E5_EXIT_ON_ERROR(status);
e5_close_group(e5_group_id);
e5_group_id = e5_open_group(e5_file_id, "/Emissivity/real runtime parameters");
e5_attr real_param_attr[] = {
{"xmin", &(attrs.xmin), E5_TYPE_DOUBLE, 0},
{"xmax", &(attrs.xmax), E5_TYPE_DOUBLE, 0},
{"ymin", &(attrs.ymin), E5_TYPE_DOUBLE, 0},
{"ymax", &(attrs.ymax), E5_TYPE_DOUBLE, 0},
{"zmin", &(attrs.zmin), E5_TYPE_DOUBLE, 0},
{"zmax", &(attrs.zmax), E5_TYPE_DOUBLE, 0},
{0}
};
status = e5_read_attr_list(e5_group_id, real_param_attr);
E5_EXIT_ON_ERROR(status);
e5_close_group(e5_group_id);
header.variable = grid->name;
header.time = (float)attrs.time;
header.data_file = data_file;
header.data_size[0] = (int)grid->dim[0];
header.data_size[1] = (int)grid->dim[1];
header.data_size[2] = (int)grid->dim[2];
header.centering = "zonal";
header.data_components = 1;
header.brick_origin[0] = (attrs.xmax + attrs.xmin) * 0.5;
header.brick_origin[1] = (attrs.ymax + attrs.ymin) * 0.5;
header.brick_origin[2] = (attrs.zmax + attrs.zmin) * 0.5;
header.brick_size[0] = attrs.xmax - attrs.xmin;
header.brick_size[1] = attrs.ymax - attrs.ymin;
header.brick_size[2] = attrs.zmax - attrs.zmin;
for(i=min_bricklet; i <= max_bricklet; i++)
{
for(d=0; d<3; d++)
header.data_bricklets[d] = ((header.data_size[d] % i) == 0) ? i : header.data_bricklets[d];
}
if(grid->type == E5_TYPE_FLOAT)
header.data_format = "FLOAT";
else if(grid->type == E5_TYPE_DOUBLE)
header.data_format = "DOUBLE";
else if(grid->type == E5_TYPE_INT)
header.data_format = "INT";
FILE* fd = CreateTextFile(bov_file);
if(!fd)
{
printf("Failed to create BOV header file '%s'! Exiting...\n", bov_file);
exit(EXIT_FAILURE);
}
printf("Writing header to '%s'...\n", bov_file);
fprintf(fd, "TIME: %f\n", header.time);
fprintf(fd, "DATA_FILE: %s\n", header.data_file);
fprintf(fd, "DATA_SIZE: %d %d %d\n",
header.data_size[0], header.data_size[1], header.data_size[2]);
fprintf(fd, "DATA_FORMAT: %s\n", header.data_format);
fprintf(fd, "VARIABLE: %s\n", header.variable);
fprintf(fd, "DATA_ENDIAN: LITTLE\n");
fprintf(fd, "CENTERING: %s\n", header.centering);
fprintf(fd, "BRICK_ORIGIN: %f %f %f\n",
header.brick_origin[0], header.brick_origin[1], header.brick_origin[2]);
fprintf(fd, "BRICK_SIZE: %f %f %f\n",
header.brick_size[0], header.brick_size[1], header.brick_size[2]);
fprintf(fd, "DIVIDE_BRICK: true\n");
fprintf(fd, "DATA_BRICKLETS: %d %d %d\n",
header.data_bricklets[0], header.data_bricklets[1], header.data_bricklets[2]);
fprintf(fd, "DATA_COMPONENTS: %d\n", 1);
CloseTextFile(fd);
snprintf(data_file, len, "%s.data", (bov_file));
fd = CreateRawFile(header.data_file);
if(!fd)
{
printf("Failed to create BOV data file '%s'! Exiting...\n", bov_file);
exit(EXIT_FAILURE);
}
printf("Writing data to '%s'...\n", header.data_file);
WriteRaw(fd, grid->data, e5_sizeof(grid->type), grid->dim[0] * grid->dim[1] * grid->dim[2]);
CloseRawFile(fd);
printf("DONE!\n");
}
