types::Function::ReturnValue sci_hdf5_listvar(types::typed_list &in, int _iRetCount, types::typed_list &out)
{
int rhs = static_cast<int>(in.size());
if (rhs < 1)
{
Scierror(999, _("%s: Wrong number of input argument(s): at least %d expected.\n"), fname.data(), 1);
return types::Function::Error;
}
if (in[0]->getId() != types::InternalType::IdScalarString)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname.data(), 1);
return types::Function::Error;
}
wchar_t* wfilename = expandPathVariableW(in[0]->getAs<types::String>()->get()[0]);
char* cfilename = wide_string_to_UTF8(wfilename);
std::string filename = cfilename;
FREE(wfilename);
FREE(cfilename);
int iFile = openHDF5File(filename.data(), 0);
if (iFile < 0)
{
Scierror(999, _("%s: Unable to open file: %s\n"), fname.data(), filename.data());
return types::Function::Error;
}
std::wstring wstFuncName;
//manage version information
int version = getSODFormatAttribute(iFile);
closeHDF5File(iFile);
switch (version)
{
case -1:
case 1:
case 2:
{
wstFuncName = L"hdf5_listvar_v2";
break;
}
case 3:
{
wstFuncName = L"hdf5_listvar_v3";
break;
}
default:
{
Scierror(999, _("%s: Wrong SOD file format version. Max Expected: %d Found: %d\n"), fname.data(), SOD_FILE_VERSION, version);
return types::Function::Error;
}
}
ast::ExecVisitor exec;
return Overload::call(wstFuncName, in, _iRetCount, out, &exec);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int writeEulerDataToHDF5File(const std::string &h5File, std::vector<float> &data, int numComp, int32_t rank, hsize_t* dims)
{
int err = 0;
err = openHDF5File(h5File, true);
err = writeScalarData(DREAM3D::HDF5::VoxelDataContainerName, data, DREAM3D::CellData::EulerAngles.c_str(), numComp, rank, dims);
if (err < 0)
{
std::cout << "Error Writing Scalars '" << DREAM3D::CellData::EulerAngles.c_str() << "' to " << DREAM3D::HDF5::VoxelDataContainerName << std::endl;
return err;
}
// Close the file when we are done with it.
err = closeHDF5File();
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int writeEulerDataToHDF5File(const QString& h5File, QVector<float>& data, int numComp, int32_t rank, hsize_t* dims)
{
int err = 0;
err = openHDF5File(h5File, true);
err = writeScalarData(DREAM3D::Defaults::DataContainerName, data, DREAM3D::CellData::EulerAngles, numComp, rank, dims);
if (err < 0)
{
qDebug() << "Error Writing Scalars '" << DREAM3D::CellData::EulerAngles << "' to " << DREAM3D::Defaults::DataContainerName;
return err;
}
// Close the file when we are done with it.
err = closeHDF5File();
return err;
}
types::Function::ReturnValue sci_hdf5_file_version(types::typed_list &in, int _iRetCount, types::typed_list &out)
{
int rhs = static_cast<int>(in.size());
if (rhs < 1)
{
Scierror(999, _("%s: Wrong number of input argument(s): at least %d expected.\n"), fname.data(), 1);
return types::Function::Error;
}
if (in[0]->getId() != types::InternalType::IdScalarString)
{
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), 1);
return types::Function::Error;
}
wchar_t* wfilename = expandPathVariableW(in[0]->getAs<types::String>()->get()[0]);
char* cfilename = wide_string_to_UTF8(wfilename);
std::string filename = cfilename;
FREE(wfilename);
FREE(cfilename);
int iFile = openHDF5File(filename.data(), 0);
if (iFile < 0)
{
Scierror(999, _("%s: Unable to open file: %s\n"), fname.data(), filename.data());
return types::Function::Error;
}
std::wstring wstFuncName;
//manage version information
int version = getSODFormatAttribute(iFile);
closeHDF5File(iFile);
if (version == -1)
{
version = 1;
}
out.push_back(new types::Double(static_cast<double>(version)));
return types::Function::OK;
}
/**
*
* @param h5File
* @param data
* @param nx
* @param ny
* @param nz
* @return
*/
int writePhDataToHDF5File(const QString& h5File, QVector<int>& data, int& nx, int& ny, int& nz)
{
int err = 0;
err = openHDF5File(h5File, true);
int totalPoints = nx * ny * nz;
int32_t rank = 1;
hsize_t dims[1] =
{ totalPoints };
int numComp = 1;
err = writeScalarData(DREAM3D::Defaults::DataContainerName, data, DREAM3D::CellData::FeatureIds, numComp, rank, dims);
if (err < 0)
{
qDebug() << "Error Writing Scalars '" << DREAM3D::CellData::FeatureIds << "' to " << DREAM3D::Defaults::DataContainerName;
return err;
}
// Close the file when we are done with it.
err = closeHDF5File();
return err;
}
/**
*
* @param h5File
* @param data
* @param nx
* @param ny
* @param nz
* @return
*/
int writePhDataToHDF5File(const std::string &h5File, std::vector<int> &data, int &nx, int &ny, int &nz)
{
int err = 0;
err = openHDF5File(h5File, true);
int totalPoints = nx * ny * nz;
int32_t rank = 1;
hsize_t dims[1] =
{ totalPoints };
int numComp = 1;
err = writeScalarData(DREAM3D::HDF5::VoxelDataContainerName, data, DREAM3D::CellData::GrainIds.c_str(), numComp, rank, dims);
if (err < 0)
{
std::cout << "Error Writing Scalars '" << DREAM3D::CellData::GrainIds.c_str() << "' to " << DREAM3D::HDF5::VoxelDataContainerName << std::endl;
return err;
}
// Close the file when we are done with it.
err = closeHDF5File();
return err;
}
int sci_hdf5_listvar_v2(char *fname, int* pvApiCtx)
{
SciErr sciErr;
int *piAddr = NULL;
char* pstFile = NULL;
int iFile = 0;
int iNbItem = 0;
VarInfo* pInfo = NULL;
const int nbIn = nbInputArgument(pvApiCtx);
CheckInputArgument(pvApiCtx, 1, 1);
CheckOutputArgument(pvApiCtx, 1, 4);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstFile))
{
if (pstFile)
{
FREE(pstFile);
}
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
return 1;
}
char* pstFileName = expandPathVariable(pstFile);
iFile = openHDF5File(pstFileName, 0);
if (iFile < 0)
{
Scierror(999, _("%s: Unable to open file: %s\n"), fname, pstFile);
FREE(pstFileName);
FREE(pstFile);
return 1;
}
FREE(pstFileName);
FREE(pstFile);
//manage version information
int iVersion = getSODFormatAttribute(iFile);
if (iVersion != SOD_FILE_VERSION)
{
if (iVersion > SOD_FILE_VERSION)
{
//can't read file with version newer that me !
closeHDF5File(iFile);
Scierror(999, _("%s: Wrong SOD file format version. Max Expected: %d Found: %d\n"), fname, SOD_FILE_VERSION, iVersion);
return 1;
}
else
{
//call older import functions and exit or ... EXIT !
if (iVersion == 1 || iVersion == -1)
{
//sciprint("old sci_listvar_in_hdf5_v1\n");
return sci_listvar_in_hdf5_v1(fname, pvApiCtx);
}
}
}
iNbItem = getVariableNames(iFile, NULL);
if (iNbItem != 0)
{
char** pstVarNameList = (char**)MALLOC(sizeof(char*) * iNbItem);
pInfo = (VarInfo*)MALLOC(iNbItem * sizeof(VarInfo));
int b;
if (Lhs == 1)
{
sciprint("Name Type Size Bytes\n");
sciprint("---------------------------------------------------------------\n");
}
iNbItem = getVariableNames(iFile, pstVarNameList);
for (int i = 0; i < iNbItem; i++)
{
int iDataSetId = getDataSetIdFromName(iFile, pstVarNameList[i]);
if (iDataSetId == 0)
{
break;
}
strncpy(pInfo[i].varName, pstVarNameList[i], sizeof(pInfo[i].varName) - 1);
pInfo[i].iSize = 0;
b = read_data(iDataSetId, 0, NULL, &pInfo[i]) == false;
if (b)
{
break;
}
if (Lhs == 1)
{
sciprint("%s\n", pInfo[i].pstInfo);
}
}
freeArrayOfString(pstVarNameList, iNbItem);
}
else
{
//no variable returms [] for each Lhs
for (int i = 0 ; i < Lhs ; i++)
{
createEmptyMatrix(pvApiCtx, nbIn + i + 1);
AssignOutputVariable(pvApiCtx, i + 1) = nbIn + i + 1;
}
ReturnArguments(pvApiCtx);
return 0;
}
closeHDF5File(iFile);
//1st Lhs
char** pstVarName = (char**)MALLOC(sizeof(char*) * iNbItem);
for (int i = 0 ; i < iNbItem ; i++)
{
pstVarName[i] = pInfo[i].varName;
}
sciErr = createMatrixOfString(pvApiCtx, nbIn + 1, iNbItem, 1, pstVarName);
FREE(pstVarName);
if (sciErr.iErr)
{
FREE(pInfo);
printError(&sciErr, 0);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbIn + 1;
if (Lhs > 1)
{
//2nd Lhs
double* pdblType;
sciErr = allocMatrixOfDouble(pvApiCtx, nbIn + 2, iNbItem, 1, &pdblType);
if (sciErr.iErr)
{
printError(&sciErr, 0);
FREE(pInfo);
return 1;
}
for (int i = 0 ; i < iNbItem ; i++)
{
pdblType[i] = pInfo[i].iType;
}
AssignOutputVariable(pvApiCtx, 2) = nbIn + 2;
if (Lhs > 2)
{
//3rd Lhs
int* pList = NULL;
sciErr = createList(pvApiCtx, nbIn + 3, iNbItem, &pList);
for (int i = 0 ; i < iNbItem ; i++)
{
double* pdblDims = NULL;
allocMatrixOfDoubleInList(pvApiCtx, nbIn + 3, pList, i + 1, 1, pInfo[i].iDims, &pdblDims);
for (int j = 0 ; j < pInfo[i].iDims ; j++)
{
pdblDims[j] = pInfo[i].piDims[j];
}
}
AssignOutputVariable(pvApiCtx, 3) = nbIn + 3;
}
if (Lhs > 3)
{
//4th Lhs
double* pdblSize = NULL;
sciErr = allocMatrixOfDouble(pvApiCtx, nbIn + 4, iNbItem, 1, &pdblSize);
for (int i = 0 ; i < iNbItem ; i++)
{
pdblSize[i] = pInfo[i].iSize;
}
AssignOutputVariable(pvApiCtx, 4) = nbIn + 4;
}
}
FREE(pInfo);
ReturnArguments(pvApiCtx);
return 0;
}
int sci_listvar_in_hdf5_v1(char *fname, int* pvCtx)
{
SciErr sciErr;
int *piAddr = NULL;
char* pstFile = NULL;
int iFile = 0;
int iNbItem = 0;
VarInfo_v1* pInfo = NULL;
CheckInputArgument(pvCtx, 1, 1);
CheckOutputArgument(pvCtx, 1, 4);
sciErr = getVarAddressFromPosition(pvCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvCtx, piAddr, &pstFile))
{
if (pstFile)
{
FREE(pstFile);
}
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 1);
return 1;
}
char* pstFileName = expandPathVariable(pstFile);
iFile = openHDF5File(pstFileName, 0);
if (iFile < 0)
{
FREE(pstFileName);
Scierror(999, _("%s: Unable to open file: %s\n"), fname, pstFile);
FREE(pstFile);
return 1;
}
FREE(pstFileName);
FREE(pstFile);
iNbItem = getVariableNames_v1(iFile, NULL);
if (iNbItem != 0)
{
char** pstVarNameList = (char**)MALLOC(sizeof(char*) * iNbItem);
bool b;
pInfo = (VarInfo_v1*)MALLOC(iNbItem * sizeof(VarInfo_v1));
if (nbOutputArgument(pvCtx) == 1)
{
sciprint("Name Type Size Bytes\n");
sciprint("---------------------------------------------------------------\n");
}
iNbItem = getVariableNames_v1(iFile, pstVarNameList);
for (int i = 0; i < iNbItem; i++)
{
int iDataSetId = getDataSetIdFromName_v1(iFile, pstVarNameList[i]);
if (iDataSetId == 0)
{
break;
}
strncpy(pInfo[i].varName, pstVarNameList[i], sizeof(pInfo[i].varName));
b = read_data_v1(pvCtx, iDataSetId, 0, NULL, &pInfo[i]) == false;
closeDataSet_v1(iDataSetId);
if (b)
{
break;
}
if (nbOutputArgument(pvCtx) == 1)
{
sciprint("%s\n", pInfo[i].pstInfo);
}
}
freeArrayOfString(pstVarNameList, iNbItem);
}
else
{
//no variable returms [] for each Lhs
for (int i = 0 ; i < nbOutputArgument(pvCtx) ; i++)
{
createEmptyMatrix(pvCtx, nbInputArgument(pvCtx) + i + 1);
AssignOutputVariable(pvCtx, i + 1) = nbInputArgument(pvCtx) + i + 1;
}
ReturnArguments(pvCtx);
return 0;
}
closeHDF5File(iFile);
//1st Lhs
char** pstVarName = (char**)MALLOC(sizeof(char*) * iNbItem);
for (int i = 0 ; i < iNbItem ; i++)
{
pstVarName[i] = pInfo[i].varName;
}
sciErr = createMatrixOfString(pvCtx, nbInputArgument(pvCtx) + 1, iNbItem, 1, pstVarName);
FREE(pstVarName);
if (sciErr.iErr)
{
FREE(pInfo);
printError(&sciErr, 0);
return 1;
}
AssignOutputVariable(pvCtx, 1) = nbInputArgument(pvCtx) + 1;
if (nbOutputArgument(pvCtx) > 1)
{
//2nd Lhs
double* pdblType;
sciErr = allocMatrixOfDouble(pvCtx, nbInputArgument(pvCtx) + 2, iNbItem, 1, &pdblType);
if (sciErr.iErr)
{
FREE(pInfo);
printError(&sciErr, 0);
return 1;
}
for (int i = 0 ; i < iNbItem ; i++)
{
pdblType[i] = pInfo[i].iType;
}
AssignOutputVariable(pvCtx, 2) = nbInputArgument(pvCtx) + 2;
if (nbOutputArgument(pvCtx) > 2)
{
//3rd Lhs
int* pList = NULL;
sciErr = createList(pvCtx, nbInputArgument(pvCtx) + 3, iNbItem, &pList);
for (int i = 0 ; i < iNbItem ; i++)
{
double* pdblDims = NULL;
allocMatrixOfDoubleInList(pvCtx, nbInputArgument(pvCtx) + 3, pList, i + 1, 1, pInfo[i].iDims, &pdblDims);
for (int j = 0 ; j < pInfo[i].iDims ; j++)
{
pdblDims[j] = pInfo[i].piDims[j];
}
}
AssignOutputVariable(pvCtx, 3) = nbInputArgument(pvCtx) + 3;
}
if (nbOutputArgument(pvCtx) > 3)
{
//4th Lhs
double* pdblSize;
sciErr = allocMatrixOfDouble(pvCtx, nbInputArgument(pvCtx) + 4, iNbItem, 1, &pdblSize);
for (int i = 0 ; i < iNbItem ; i++)
{
pdblSize[i] = pInfo[i].iSize;
}
AssignOutputVariable(pvCtx, 4) = nbInputArgument(pvCtx) + 4;
}
}
FREE(pInfo);
ReturnArguments(pvCtx);
return 0;
}
types::Function::ReturnValue sci_hdf5_listvar_v3(types::typed_list &in, int _iRetCount, types::typed_list &out)
{
int rhs = static_cast<int>(in.size());
if (rhs != 1)
{
Scierror(999, _("%s: Wrong number of input argument(s): %d expected.\n"), fname.data(), 1);
return types::Function::Error;
}
if (_iRetCount < 1 && _iRetCount > 4)
{
Scierror(999, _("%s: Wrong number of output argument(s): %d to %d expected.\n"), fname.data(), 1, 4);
return types::Function::Error;
}
//get filename
if (in[0]->getId() != types::InternalType::IdScalarString)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname.data(), 1);
return types::Function::Error;
}
//open hdf5 file
wchar_t* wfilename = expandPathVariableW(in[0]->getAs<types::String>()->get()[0]);
char* cfilename = wide_string_to_UTF8(wfilename);
std::string filename = cfilename;
FREE(wfilename);
FREE(cfilename);
int iFile = openHDF5File(filename.data(), 0);
if (iFile < 0)
{
Scierror(999, _("%s: Unable to open file: %s\n"), fname.data(), filename.data());
return types::Function::Error;
}
//manage version information
int iVersion = getSODFormatAttribute(iFile);
if (iVersion != SOD_FILE_VERSION)
{
//can't read file with version newer that me !
closeHDF5File(iFile);
Scierror(999, _("%s: Wrong SOD file format version. Max Expected: %d Found: %d\n"), fname.data(), SOD_FILE_VERSION, iVersion);
return types::Function::Error;
}
int items = getVariableNames6(iFile, nullptr);
std::vector<VarInfo6> info(items);
if (items != 0)
{
std::vector<char*> vars(items);
items = getVariableNames6(iFile, vars.data());
if (_iRetCount == 1)
{
sciprint("Name Type Size Bytes\n");
sciprint("-------------------------------------------------------------\n");
}
for (int i = 0; i < items; i++)
{
info[i].name = vars[i];
FREE(vars[i]);
info[i].size = 0;
int dset = getDataSetIdFromName(iFile, info[i].name.data());
if (dset == 0)
{
break;
}
if (_iRetCount != 2)
{
if (read_data(dset, info[i]) == false)
{
break;
}
if (_iRetCount == 1)
{
sciprint("%s\n", info[i].info);
}
}
else // == 2
{
if (read_short_data(dset, info[i]) == false)
{
break;
}
}
}
}
else
{
//no variable returms [] for each Lhs
for (int i = 0; i < _iRetCount; i++)
{
out.push_back(types::Double::Empty());
}
return types::Function::OK;
}
closeHDF5File(iFile);
//1st Lhs
types::String* out1 = new types::String(items, 1);
for (int i = 0; i < items; i++)
{
out1->set(i, info[i].name.data());
}
out.push_back(out1);
//2nd
if (_iRetCount > 1)
{
types::Double* out2 = new types::Double(items, 1);
double* pout2 = out2->get();
for (int i = 0; i < items; i++)
{
pout2[i] = info[i].type;
}
out.push_back(out2);
}
if (_iRetCount > 2)
{
//3rd Lhs
types::List* out3 = new types::List();
for (int i = 0; i < items; i++)
{
int dims = info[i].dims;
types::Double* item = new types::Double(1, dims);
double* pitem = item->get();
for (int j = 0; j < dims; j++)
{
pitem[j] = static_cast<double>(info[i].pdims[j]);
}
out3->append(item);
}
out.push_back(out3);
}
if (_iRetCount > 3)
{
//4th Lhs
types::Double* out4 = new types::Double(items, 1);
double* pout4 = out4->get();
for (int i = 0; i < items; i++)
{
pout4[i] = info[i].size;
}
out.push_back(out4);
}
return types::Function::OK;
}
types::Function::ReturnValue sci_hdf5_load(types::typed_list &in, int _iRetCount, types::typed_list& out)
{
int rhs = static_cast<int>(in.size());
if (rhs < 1)
{
Scierror(999, _("%s: Wrong number of input argument(s): at least %d expected.\n"), fname.data(), 1);
return types::Function::Error;
}
if (in[0]->getId() != types::InternalType::IdScalarString)
{
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), 1);
return types::Function::Error;
}
wchar_t* wcfilename = expandPathVariableW(in[0]->getAs<types::String>()->get()[0]);
char* cfilename = wide_string_to_UTF8(wcfilename);
std::string filename(cfilename);
std::wstring wfilename(wcfilename);
FREE(cfilename);
FREE(wcfilename);
if (FileExistW(wfilename.data()) == FALSE)
{
Scierror(999, _("%s: Unable to open file: '%s'.\n"), fname.data(), filename.data());
return types::Function::Error;
}
//library ?
if (isHDF5File(filename.data()) == false)
{
//lib file
int err = 0;
types::Library* lib = loadlib(in[0]->getAs<types::String>()->get()[0], &err);
switch (err)
{
case 0:
break;
case 2:
Scierror(999, "%s: %s", fname.data(), _("Redefining permanent variable.\n"));
return types::Function::Error;
default:
Scierror(999, _("%s: %s is not a valid lib file.\n"), fname.data(), filename.data());
return types::Function::Error;
}
lib->killMe();
return types::Function::OK;
}
int iFile = openHDF5File(filename.data(), 0);
if (iFile < 0)
{
Scierror(999, _("%s: Unable to open file: %s\n"), fname.data(), filename.data());
return types::Function::Error;
}
std::wstring wstFuncName;
//manage version information
int version = getSODFormatAttribute(iFile);
closeHDF5File(iFile);
bool needReprocess = false;
switch (version)
{
case -1:
case 1:
{
wstFuncName = L"hdf5_load_v1";
needReprocess = true;
break;
}
case 2:
{
wstFuncName = L"hdf5_load_v2";
needReprocess = true;
break;
}
case 3:
{
wstFuncName = L"hdf5_load_v3";
break;
}
default :
{
Scierror(999, _("%s: Wrong SOD file format version. Max Expected: %d Found: %d\n"), fname.data(), SOD_FILE_VERSION, version);
return types::Function::Error;
}
}
types::typed_list out1;
types::Function::ReturnValue ret = Overload::call(wstFuncName, in, _iRetCount, out1);
if (ret != types::Function::OK)
{
Scierror(999, _("%s: Unable to load '%s'\n"), fname.data(), filename.data());
return types::Function::Error;
}
if (needReprocess)
{
//call %sodload
types::String* vars = out1[0]->getAs<types::String>();
vars->IncreaseRef();
int size = vars->getSize();
types::typed_list in2(1, vars);
types::typed_list out2;
std::wstring wstFuncName = L"%_sodload";
ret = Overload::call(wstFuncName, in2, size, out2);
vars->DecreaseRef();
symbol::Context* ctx = symbol::Context::getInstance();
wchar_t** names = vars->get();
//update context with values return by %_sodload
for (int i = 0; i < size; ++i)
{
ctx->put(symbol::Symbol(names[i]), out2[i]);
}
vars->killMe();
}
else
{
out.push_back(out1.front());
}
return ret;
}
int sci_hdf5_load_v2(char *fn, int* pvApiCtx)
{
SciErr sciErr;
int* piAddr = NULL;
char* pstFilename = NULL;
char* pstExpandedFilename = NULL;
bool bImport = true;
const int nbIn = nbInputArgument(pvApiCtx);
int iSelectedVar = nbIn - 1;
CheckInputArgumentAtLeast(pvApiCtx , 1);
CheckOutputArgument(pvApiCtx, 1, 1);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstFilename))
{
if (pstFilename)
{
freeAllocatedSingleString(pstFilename);
}
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), 2);
return 1;
}
//open hdf5 file
pstExpandedFilename = expandPathVariable(pstFilename);
int iFile = openHDF5File(pstExpandedFilename, 0);
if (iFile < 0)
{
Scierror(999, _("%s: Unable to open file: %s\n"), fname.data(), pstFilename);
FREE(pstExpandedFilename);
FREE(pstFilename);
return 1;
}
FREE(pstExpandedFilename);
FREE(pstFilename);
//manage version information
int iVersion = getSODFormatAttribute(iFile);
if (iVersion != SOD_FILE_VERSION)
{
if (iVersion > SOD_FILE_VERSION)
{
//can't read file with version newer that me !
Scierror(999, _("%s: Wrong SOD file format version. Max Expected: %d Found: %d\n"), fname.data(), SOD_FILE_VERSION, iVersion);
return 1;
}
else
{
//call older import functions and exit or ... EXIT !
if (iVersion == 1 || iVersion == -1)
{
return sci_hdf5_load_v1(fn, pvApiCtx);
}
}
}
std::vector<wchar_t*> varList;
if (iSelectedVar)
{
//selected variable
char* pstVarName = NULL;
for (int i = 0 ; i < iSelectedVar ; i++)
{
sciErr = getVarAddressFromPosition(pvApiCtx, i + 2, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstVarName))
{
if (pstVarName)
{
freeAllocatedSingleString(pstVarName);
}
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), i + 1);
return 1;
}
if (import_variable(pvApiCtx, iFile, pstVarName) == false)
{
FREE(pstVarName);
bImport = false;
break;
}
varList.push_back(to_wide_string(pstVarName));
FREE(pstVarName);
pstVarName = NULL;
}
}
else
{
//all variables
int iNbItem = 0;
iNbItem = getVariableNames(iFile, NULL);
if (iNbItem != 0)
{
char **pstVarNameList = (char **)MALLOC(sizeof(char *) * iNbItem);
iNbItem = getVariableNames(iFile, pstVarNameList);
//import all data
for (int i = 0; i < iNbItem; i++)
{
if (import_variable(pvApiCtx, iFile, pstVarNameList[i]) == false)
{
bImport = false;
break;
}
varList.push_back(to_wide_string(pstVarNameList[i]));
}
freeArrayOfString(pstVarNameList, iNbItem);
}
}
//close the file
closeHDF5File(iFile);
if (bImport == true && varList.size() != 0)
{
createMatrixOfWideString(pvApiCtx, nbIn + 1, 1, static_cast<int>(varList.size()), varList.data());
}
else
{
createEmptyMatrix(pvApiCtx, nbIn + 1);
}
for (auto & i : varList)
{
FREE(i);
}
AssignOutputVariable(pvApiCtx, 1) = nbIn + 1;
ReturnArguments(pvApiCtx);
// printf("End gateway !!!\n");
return 0;
}
/*--------------------------------------------------------------------------*/
types::Function::ReturnValue sci_hdf5_load_v3(types::typed_list &in, int _iRetCount, types::typed_list &out)
{
std::string filename;
int rhs = static_cast<int>(in.size());
if (rhs < 1)
{
Scierror(999, _("%s: Wrong number of input argument(s): at least %d expected.\n"), fname.data(), 1);
return types::Function::Error;
}
if (in[0]->getId() != types::InternalType::IdScalarString)
{
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), 1);
return types::Function::Error;
}
wchar_t* wfilename = expandPathVariableW(in[0]->getAs<types::String>()->get()[0]);
char* cfilename = wide_string_to_UTF8(wfilename);
filename = cfilename;
FREE(wfilename);
FREE(cfilename);
int iFile = openHDF5File(filename.data(), 0);
if (iFile < 0)
{
Scierror(999, _("%s: Unable to open file: %s\n"), fname.data(), filename.data());
return types::Function::Error;
}
//manage version information
int iVersion = getSODFormatAttribute(iFile);
if (iVersion != SOD_FILE_VERSION)
{
//can't read file with version newer that me !
Scierror(999, _("%s: Wrong SOD file format version. Expected: %d Found: %d\n"), fname.data(), SOD_FILE_VERSION, iVersion);
return types::Function::Error;
}
if (rhs > 1)
{
for (int i = 1; i < rhs; ++i)
{
std::string var;
char* cvar = wide_string_to_UTF8(in[i]->getAs<types::String>()->get()[0]);
var = cvar;
FREE(cvar);
if (import_variable(iFile, var) == false)
{
Scierror(999, _("%s: Unable to load \'%s\'.\n"), fname.data(), var.data());
return types::Function::Error;
}
}
}
else
{
//restore all variables
int iNbItem = 0;
iNbItem = getVariableNames6(iFile, NULL);
if (iNbItem != 0)
{
std::vector<char*> vars(iNbItem);
iNbItem = getVariableNames6(iFile, vars.data());
for (auto & var : vars)
{
std::string s(var);
FREE(var);
if (import_variable(iFile, s) == false)
{
Scierror(999, _("%s: Unable to load \'%s\'.\n"), fname.data(), s.data());
return types::Function::Error;
}
}
}
}
//close the file
closeHDF5File(iFile);
out.push_back(new types::Bool(1));
return types::Function::OK;
}
int sci_import_from_hdf5(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int* piAddr = NULL;
char* pstFilename = NULL;
char* pstExpandedFilename = NULL;
bool bImport = true;
int iSelectedVar = Rhs - 1;
CheckInputArgumentAtLeast(pvApiCtx, 1);
CheckOutputArgument(pvApiCtx, 1, 1);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstFilename))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
return 1;
}
//open hdf5 file
pstExpandedFilename = expandPathVariable(pstFilename);
int iFile = openHDF5File(pstExpandedFilename, 0);
if (iFile < 0)
{
Scierror(999, _("%s: Unable to open file: %s\n"), fname, pstFilename);
FREE(pstExpandedFilename);
FREE(pstFilename);
return 1;
}
FREE(pstExpandedFilename);
FREE(pstFilename);
//manage version information
int iVersion = getSODFormatAttribute(iFile);
if (iVersion != SOD_FILE_VERSION)
{
if (iVersion > SOD_FILE_VERSION)
{
//can't read file with version newer that me !
Scierror(999, _("%s: Wrong SOD file format version. Max Expected: %d Found: %d\n"), fname, SOD_FILE_VERSION, iVersion);
return 1;
}
else
{
//call older import functions and exit or ... EXIT !
if (iVersion == 1 || iVersion == -1)
{
//sciprint("old sci_import_from_hdf5_v1\n");
return sci_import_from_hdf5_v1(fname, fname_len);
}
}
}
if (iSelectedVar)
{
//selected variable
char* pstVarName = NULL;
for (int i = 0 ; i < iSelectedVar ; i++)
{
sciErr = getVarAddressFromPosition(pvApiCtx, i + 2, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstVarName))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, i + 1);
return 1;
}
if (import_variable(iFile, pstVarName) == false)
{
bImport = false;
break;
}
FREE(pstVarName);
}
}
else
{
//all variables
int iNbItem = 0;
iNbItem = getVariableNames(iFile, NULL);
if (iNbItem != 0)
{
char **pstVarNameList = (char **)MALLOC(sizeof(char *) * iNbItem);
iNbItem = getVariableNames(iFile, pstVarNameList);
//import all data
for (int i = 0; i < iNbItem; i++)
{
if (import_variable(iFile, pstVarNameList[i]) == false)
{
bImport = false;
break;
}
}
}
}
//close the file
closeHDF5File(iFile);
int *piReturn = NULL;
sciErr = allocMatrixOfBoolean(pvApiCtx, Rhs + 1, 1, 1, &piReturn);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (bImport == true)
{
piReturn[0] = 1;
}
else
{
piReturn[0] = 0;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
// printf("End gateway !!!\n");
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_export_to_hdf5(char *fname, unsigned long fname_len)
{
int iNbVar = 0;
int** piAddrList = NULL;
char** pstNameList = NULL;
char *pstFileName = NULL;
bool bExport = false;
bool bAppendMode = false;
SciErr sciErr;
int iRhs = nbInputArgument(pvApiCtx);
CheckInputArgumentAtLeast(pvApiCtx, 1);
CheckOutputArgument(pvApiCtx, 0, 1);
pstNameList = (char**)MALLOC(sizeof(char*) * iRhs);
iNbVar = extractVarNameList(1, iRhs, pstNameList);
if (iNbVar == 0)
{
FREE(pstNameList);
return 1;
}
piAddrList = (int**)MALLOC(sizeof(int*) * (iNbVar));
for (int i = 1 ; i < iRhs ; i++)
{
if (strcmp(pstNameList[i], "-append") == 0)
{
bAppendMode = true;
}
else
{
sciErr = getVarAddressFromName(pvApiCtx, pstNameList[i], &piAddrList[i]);
if (sciErr.iErr)
{
Scierror(999, _("%s: Wrong value for input argument #%d: Defined variable expected.\n"), fname, i + 1);
printError(&sciErr, 0);
return 1;
}
}
}
iLevel = 0;
// open hdf5 file
pstFileName = expandPathVariable(pstNameList[0]);
int iH5File = 0;
if (bAppendMode)
{
iH5File = openHDF5File(pstFileName, bAppendMode);
if (iH5File < 0)
{
iH5File = createHDF5File(pstFileName);
}
}
else
{
iH5File = createHDF5File(pstFileName);
}
if (iH5File < 0)
{
FREE(pstFileName);
if (iH5File == -2)
{
Scierror(999, _("%s: Wrong value for input argument #%d: \"%s\" is a directory"), fname, 1, pstNameList[0]);
}
else
{
Scierror(999, _("%s: Cannot open file %s.\n"), fname, pstNameList[0]);
}
return 1;
}
if (bAppendMode)
{
int iVersion = getSODFormatAttribute(iH5File);
if (iVersion != -1 && iVersion != SOD_FILE_VERSION)
{
//to update version must be the same
closeHDF5File(iH5File);
Scierror(999, _("%s: Wrong SOD file format version. Expected: %d Found: %d\n"), fname, SOD_FILE_VERSION, iVersion);
return 1;
}
}
// export data
for (int i = 1 ; i < iRhs ; i++)
{
if (strcmp(pstNameList[i], "-append") == 0)
{
continue;
}
if (isVarExist(iH5File, pstNameList[i]))
{
if (bAppendMode)
{
if (deleteHDF5Var(iH5File, pstNameList[i]))
{
closeHDF5File(iH5File);
Scierror(999, _("%s: Unable to delete existing variable \"%s\"."), fname, pstNameList[i]);
return 1;
}
}
else
{
closeHDF5File(iH5File);
Scierror(999, _("%s: Variable \'%s\' already exists in file \'%s\'\nUse -append option to replace existing variable\n."), fname, pstNameList[i], pstNameList[0]);
return 1;
}
}
bExport = export_data(iH5File, piAddrList[i], pstNameList[i]);
if (bExport == false)
{
break;
}
}
if (bExport && iRhs != 1)
{
//add or update scilab version and file version in hdf5 file
if (updateScilabVersion(iH5File) < 0)
{
closeHDF5File(iH5File);
Scierror(999, _("%s: Unable to update Scilab version in \"%s\"."), fname, pstNameList[0]);
return 1;
}
if (updateFileVersion(iH5File) < 0)
{
closeHDF5File(iH5File);
Scierror(999, _("%s: Unable to update HDF5 format version in \"%s\"."), fname, pstNameList[0]);
return 1;
}
}
//close hdf5 file
closeHDF5File(iH5File);
//delete file in case of error but nor in append mode
if (bExport == false && bAppendMode == false && iRhs != 1)
{
//remove file
deleteafile(pstFileName);
}
FREE(pstFileName);
//create boolean return value
int *piReturn = NULL;
sciErr = allocMatrixOfBoolean(pvApiCtx, iRhs + 1, 1, 1, &piReturn);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (bExport == true || iRhs == 1)
{
piReturn[0] = 1;
}
else
{
piReturn[0] = 0;
}
//free memory
for (int i = 0 ; i < iRhs ; i++)
{
FREE(pstNameList[i]);
}
FREE(pstNameList);
FREE(piAddrList);
LhsVar(1) = iRhs + 1;
PutLhsVar();
return 0;
}
int sci_hdf5_load_v1(char *fn, int* pvApiCtx)
{
SciErr sciErr;
int* piAddr = NULL;
char* pstFilename = NULL;
char* pstExpandedFilename = NULL;
bool bImport = true;
const int nbIn = Rhs;
int iSelectedVar = Rhs - 1;
CheckInputArgumentAtLeast(pvApiCtx, 1);
CheckOutputArgument(pvApiCtx, 1, 1);
iCloseList = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstFilename))
{
if (pstFilename)
{
FREE(pstFilename);
}
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), 2);
return 1;
}
//open hdf5 file
pstExpandedFilename = expandPathVariable(pstFilename);
int iFile = openHDF5File(pstExpandedFilename, 0);
if (iFile < 0)
{
FREE(pstExpandedFilename);
Scierror(999, _("%s: Unable to open file: %s\n"), fname.data(), pstFilename);
FREE(pstFilename);
return 1;
}
FREE(pstExpandedFilename);
FREE(pstFilename);
std::vector<wchar_t*> varList;
if (iSelectedVar)
{
//selected variable
char* pstVarName = NULL;
for (int i = 0 ; i < iSelectedVar ; i++)
{
sciErr = getVarAddressFromPosition(pvApiCtx, i + 2, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstVarName))
{
if (pstVarName)
{
FREE(pstVarName);
}
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), i + 1);
return 1;
}
if (import_variable_v1(pvApiCtx, iFile, pstVarName) == false)
{
FREE(pstVarName);
bImport = false;
break;
}
varList.push_back(to_wide_string(pstVarName));
FREE(pstVarName);
pstVarName = NULL;
}
}
else
{
//all variables
int iNbItem = 0;
iNbItem = getVariableNames_v1(iFile, NULL);
if (iNbItem != 0)
{
char **pstVarNameList = (char **)MALLOC(sizeof(char *) * iNbItem);
iNbItem = getVariableNames_v1(iFile, pstVarNameList);
//import all data
for (int i = 0; i < iNbItem; i++)
{
if (import_variable_v1(pvApiCtx, iFile, pstVarNameList[i]) == false)
{
bImport = false;
break;
}
varList.push_back(to_wide_string(pstVarNameList[i]));
}
freeArrayOfString(pstVarNameList, iNbItem);
}
}
//close the file
closeHDF5File(iFile);
if (bImport == true && varList.size() != 0)
{
createMatrixOfWideString(pvApiCtx, nbIn + 1, 1, static_cast<int>(varList.size()), varList.data());
}
else
{
createEmptyMatrix(pvApiCtx, nbIn + 1);
}
for (auto & i : varList)
{
FREE(i);
}
AssignOutputVariable(pvApiCtx, 1) = nbIn + 1;
ReturnArguments(pvApiCtx);
// printf("End gateway !!!\n");
return 0;
}