static bool read_integer(int _iDatasetId, int _iItemPos, int *_piAddress, VarInfo* _pInfo) { int iRet = 0; int iPrec = 0; int iSize = 0; int iComplex = 0; iSize = getDatasetInfo(_iDatasetId, &iComplex, &_pInfo->iDims, _pInfo->piDims); getDatasetPrecision(_iDatasetId, &iPrec); _pInfo->iSize = 16 + iSize * (iPrec % 10); generateInfo(_pInfo, "integer"); closeDataSet(_iDatasetId); return true; }
static int readComplexPoly(int _iDatasetId, int *_piNbCoef, double **_pdblReal, double **_pdblImg) { int iComplex = 0; int iSize = 0; int iDims = 0; //Get the datatype and its size. iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, _piNbCoef); //Allocate space for string data. *_pdblReal = (double *)MALLOC(*_piNbCoef * sizeof(double)); *_pdblImg = (double *)MALLOC(*_piNbCoef * sizeof(double)); //Read the data and return result. return readDoubleComplexMatrix(_iDatasetId, *_pdblReal, *_pdblImg); }
static bool read_poly(int _iDatasetId, int _iItemPos, int *_piAddress, VarInfo* _pInfo) { int iRet = 0; int iComplex = 0; char pstVarName[64] = { 0 }; double **pdblReal = NULL; double **pdblImg = NULL; int *piNbCoef = NULL; int iSize = 0; iSize = getDatasetInfo(_iDatasetId, &iComplex, &_pInfo->iDims, _pInfo->piDims); _pInfo->iSize = 8 * 4 + (iSize + 1) * 4; if (iComplex) { piNbCoef = (int *)MALLOC(iSize * sizeof(int)); pdblReal = (double **)MALLOC(iSize * sizeof(double *)); pdblImg = (double **)MALLOC(iSize * sizeof(double *)); iRet = readPolyComplexMatrix(_iDatasetId, pstVarName, 2, _pInfo->piDims, piNbCoef, pdblReal, pdblImg); } else { piNbCoef = (int *)MALLOC(iSize * sizeof(int)); pdblReal = (double **)MALLOC(iSize * sizeof(double *)); iRet = readPolyMatrix(_iDatasetId, pstVarName, 2, _pInfo->piDims, piNbCoef, pdblReal); } for (int i = 0 ; i < iSize ; i++) { _pInfo->iSize += piNbCoef[i] * 8 * (iComplex + 1); FREE(pdblReal[i]); if (iComplex) { FREE(pdblImg[i]); } } FREE(piNbCoef); FREE(pdblReal); if (iComplex) { FREE(pdblImg); } generateInfo(_pInfo, "polynomial"); return true; }
void litiv::IDataReporter_<litiv::eDatasetEval_BinaryClassifier>::writeEvalReport() const { if(!getTotPackets() || !getDatasetInfo()->isUsingEvaluator()) { IDataReporter_<litiv::eDatasetEval_None>::writeEvalReport(); return; } else if(isGroup() && !isBare()) for(const auto& pBatch : getBatches(true)) pBatch->writeEvalReport(); IMetricsCalculatorConstPtr pMetrics = getMetrics(true); lvAssert(pMetrics.get()); const BinClassifMetricsCalculator& oMetrics = dynamic_cast<const BinClassifMetricsCalculator&>(*pMetrics.get());; std::cout << "\t" << CxxUtils::clampString(std::string(size_t(!isGroup()),'>')+getName(),12) << " => Rcl=" << std::fixed << std::setprecision(4) << oMetrics.dRecall << " Prc=" << oMetrics.dPrecision << " FM=" << oMetrics.dFMeasure << " MCC=" << oMetrics.dMCC << std::endl; std::ofstream oMetricsOutput(PlatformUtils::AddDirSlashIfMissing(getOutputPath())+"../"+getName()+".txt"); if(oMetricsOutput.is_open()) { oMetricsOutput << std::fixed; oMetricsOutput << "Video segmentation evaluation report for '" << getName() << "' :\n\n"; oMetricsOutput << " | Rcl | Spc | FPR | FNR | PBC | Prc | FM | MCC \n"; oMetricsOutput << "------------|------------|------------|------------|------------|------------|------------|------------|------------\n"; oMetricsOutput << IDataReporter_<eDatasetEval_BinaryClassifier>::writeInlineEvalReport(0); oMetricsOutput << "\nHz: " << getTotPackets()/getProcessTime() << "\n"; oMetricsOutput << CxxUtils::getLogStamp(); } }
static bool import_struct(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname) { int iRet = 0; int iComplex = 0; int iDims = 0; int iItems = 0; hobj_ref_t *piItemRef = NULL; // an struct is stored in an mlist if (_iVarType != sci_mlist) { return false; } iRet = getListDims(_iDatasetId, &iItems); if (iRet) { return false; } if (iItems < 2) { // struct have 2 elements minimal return false; } iRet = getListItemReferences(_iDatasetId, &piItemRef); if (iRet) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } // get first item int iItemDataset = 0; iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset); if (iRet || iItemDataset == 0) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } // get first item type int iItemType = getScilabTypeFromDataSet(iItemDataset); if (iItemType != sci_strings) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } // get size of first item iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL); if (iRet < 0 || iDims != 2) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } int* piDims = new int[2]; int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims); if (iSize != iItems) { deleteListItemReferences(_iDatasetId, piItemRef); delete[] piDims; return false; } delete[] piDims; piDims = NULL; // get data of first item for check the type of mlist char** pstData = new char*[iSize]; char** pstDataSave = new char*[iSize - 2]; iRet = readStringMatrix(iItemDataset, pstData); if (iRet || strcmp(pstData[0], "st") != 0) { // if not the good type, do not h5close (deleteListItemReferences) FREE(piItemRef); freeStringMatrix(iItemDataset, pstData); delete[] pstData; delete[] pstDataSave; return false; } for (int i = 2; i < iSize; ++i) { pstDataSave[-2 + i] = new char[strlen(pstData[i]) + 1]; strcpy(pstDataSave[-2 + i], pstData[i]); } freeStringMatrix(iItemDataset, pstData); delete[] pstData; pstData = NULL; // get second item, the Size of struct iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset); if (iRet) { deleteListItemReferences(_iDatasetId, piItemRef); for (int i = 0; i < (-2 + iItems); ++i) { delete pstDataSave[i]; } delete[] pstDataSave; pstDataSave = NULL; return false; } iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL); if (iRet < 0 || iDims != 2) { deleteListItemReferences(_iDatasetId, piItemRef); for (int i = 0; i < (-2 + iItems); ++i) { delete pstDataSave[i]; } delete[] pstDataSave; pstDataSave = NULL; return false; } piDims = new int[2]; iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims); if (piDims[0] != 1) { deleteListItemReferences(_iDatasetId, piItemRef); for (int i = 0; i < (-2 + iItems); ++i) { delete pstDataSave[i]; } delete[] pstDataSave; pstDataSave = NULL; delete[] piDims; return false; } int* piDimsArray = new int[piDims[1]]; iRet = readInteger32Matrix(iItemDataset, piDimsArray); if (iRet) { deleteListItemReferences(_iDatasetId, piItemRef); for (int i = 0; i < (-2 + iItems); ++i) { delete pstDataSave[i]; } delete[] pstDataSave; pstDataSave = NULL; delete[] piDims; delete[] piDimsArray; return false; } types::Struct* pStruct = new types::Struct(piDims[1], piDimsArray); wchar_t* pwstName = NULL; for (int i = 0; i < (-2 + iItems); ++i) { pwstName = to_wide_string(pstDataSave[i]); pStruct->addField(pwstName); delete pstDataSave[i]; FREE(pwstName); } delete[] pstDataSave; pstDataSave = NULL; types::SingleStruct** ppSStruct = pStruct->get(); types::String* pStr = pStruct->getFieldNames(); types::List* pList = new types::List(); // fill the list to avoid api_scilab error about the list size. pList->set(0, types::Double::Empty()); if (pStruct->getSize() == 1) { types::InternalType* pIT = NULL; for (int i = 0; i < pStr->getSize(); ++i) { int iItemDataset = 0; iRet = getListItemDataset(_iDatasetId, piItemRef, i + 2, &iItemDataset); if (iRet || iItemDataset == 0) { deleteListItemReferences(_iDatasetId, piItemRef); delete pList; delete pStruct; return false; } wchar_t* pwcsName = pStr->get(i); char* pcName = wide_string_to_UTF8(pwcsName); bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, pcName); if (bRet == false) { deleteListItemReferences(_iDatasetId, piItemRef); delete pList; delete pStruct; return false; } pIT = pList->get(0); ppSStruct[0]->set(pwcsName, pIT); FREE(pcName); } } else if (pStruct->getSize() > 1) { for (int i = 0; i < pStr->getSize(); ++i) { int iItemDataset = 0; iRet = getListItemDataset(_iDatasetId, piItemRef, i + 2, &iItemDataset); if (iRet || iItemDataset == 0) { deleteListItemReferences(_iDatasetId, piItemRef); delete pList; delete pStruct; return false; } wchar_t* pwcsName = pStr->get(i); char* pcName = wide_string_to_UTF8(pwcsName); bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, pcName); if (bRet == false) { deleteListItemReferences(_iDatasetId, piItemRef); delete pList; delete pStruct; return false; } types::List* pListData = pList->get(0)->getAs<types::List>(); for (int iWriteData = 0; iWriteData < pStruct->getSize(); ++iWriteData) { ppSStruct[iWriteData]->set(pwcsName, pListData->get(iWriteData)); } FREE(pcName); } } delete pList; if (_piAddress == NULL) { pwstName = to_wide_string(_pstVarname); symbol::Context::getInstance()->put(symbol::Symbol(pwstName), pStruct); FREE(pwstName); } else { types::List* pParentList = (types::List*)_piAddress; pParentList->set(_iItemPos - 1, pStruct); } iRet = deleteListItemReferences(_iDatasetId, piItemRef); if (iRet) { return false; } return true; }
static types::InternalType* import_int(int dataset) { types::InternalType* pOut = nullptr; int complex = 0; int dims = 0; int ret = getDatasetInfo(dataset, &complex, &dims, NULL); if (ret < 0) { closeDataSet(dataset); return nullptr; } std::vector<int> d(dims); int size = getDatasetInfo(dataset, &complex, &dims, d.data()); if (dims == 0 || size <= 0) { closeDataSet(dataset); return types::Double::Empty(); } int prec = 0; ret = getDatasetPrecision(dataset, &prec); if (ret != 0) { closeDataSet(dataset); return nullptr; } switch (prec) { case SCI_INT8: { types::Int8* pi = new types::Int8(dims, d.data()); ret = readInteger8Matrix(dataset, pi->get()); pOut = pi; break; } case SCI_INT16: { types::Int16* pi = new types::Int16(dims, d.data()); ret = readInteger16Matrix(dataset, pi->get()); pOut = pi; break; } case SCI_INT32: { types::Int32* pi = new types::Int32(dims, d.data()); ret = readInteger32Matrix(dataset, pi->get()); pOut = pi; break; } case SCI_INT64: { types::Int64* pi = new types::Int64(dims, d.data()); ret = readInteger64Matrix(dataset, pi->get()); pOut = pi; break; } case SCI_UINT8: { types::UInt8* pi = new types::UInt8(dims, d.data()); ret = readUnsignedInteger8Matrix(dataset, pi->get()); pOut = pi; break; } case SCI_UINT16: { types::UInt16* pi = new types::UInt16(dims, d.data()); ret = readUnsignedInteger16Matrix(dataset, pi->get()); pOut = pi; break; } case SCI_UINT32: { types::UInt32* pi = new types::UInt32(dims, d.data()); ret = readUnsignedInteger32Matrix(dataset, pi->get()); pOut = pi; break; } case SCI_UINT64: { types::UInt64* pi = new types::UInt64(dims, d.data()); ret = readUnsignedInteger64Matrix(dataset, pi->get()); pOut = pi; break; } default: return nullptr; break; } return pOut; }
static bool import_poly(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname) { int iRet = 0; int iComplex = 0; char pstVarName[64] = { 0 }; double **pdblReal = NULL; double **pdblImg = NULL; int *piNbCoef = NULL; int iDims = 0; int* piDims = NULL; int iSize = 0; SciErr sciErr; iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL); if (iRet < 0) { return false; } piDims = (int*)MALLOC(sizeof(int) * iDims); iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims); if (iComplex) { piNbCoef = (int *)MALLOC(iSize * sizeof(int)); pdblReal = (double **)MALLOC(iSize * sizeof(double *)); pdblImg = (double **)MALLOC(iSize * sizeof(double *)); iRet = readPolyComplexMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal, pdblImg); } else { piNbCoef = (int *)MALLOC(iSize * sizeof(int)); pdblReal = (double **)MALLOC(iSize * sizeof(double *)); iRet = readPolyMatrix(_iDatasetId, pstVarName, iDims, piDims, piNbCoef, pdblReal); } if (iRet) { FREE(piDims); FREE(piNbCoef); for (int i = 0; i < iSize; i++) { FREE(pdblReal[i]); } FREE(pdblReal); if (iComplex) { for (int i = 0; i < iSize; i++) { FREE(pdblImg[i]); } FREE(pdblImg); } return false; } if (_piAddress == NULL) { if (iComplex) { sciErr = createNamedComplexMatrixOfPoly(pvCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal, pdblImg); } else { sciErr = createNamedMatrixOfPoly(pvCtx, _pstVarname, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal); } } else //if not null this variable is in a list { if (iComplex) { sciErr = createComplexMatrixOfPolyInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal, pdblImg); } else { sciErr = createMatrixOfPolyInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, pstVarName, piDims[0], piDims[1], piNbCoef, pdblReal); } } FREE(piDims); FREE(piNbCoef); for (int i = 0; i < iSize; i++) { FREE(pdblReal[i]); } FREE(pdblReal); if (iComplex) { for (int i = 0; i < iSize; i++) { FREE(pdblImg[i]); } FREE(pdblImg); } if (sciErr.iErr) { printError(&sciErr, 0); return false; } return true; }
static bool read_struct(int dataset, VarInfo6& info) { int complex = 0; int size = getDimsNode(dataset, &complex, info.pdims); info.dims = static_cast<int>(info.pdims.size()); info.size = 0; if (size == 0) { generateInfo(info); closeList6(dataset); return true; } int fieldCount = 0; int ret = getListDims6(dataset, &fieldCount); if (ret < 0) { closeList6(dataset); return false; } //open __refs__ node int refs = getDataSetIdFromName(dataset, "__refs__"); H5O_info_t oinfo; for (int i = 0; i < fieldCount; ++i) { H5Oget_info_by_idx(dataset, ".", H5_INDEX_NAME, H5_ITER_NATIVE, i, &oinfo, H5P_DEFAULT); ssize_t len = H5Lget_name_by_idx(dataset, ".", H5_INDEX_NAME, H5_ITER_INC, i, 0, 0, H5P_DEFAULT) + 1; char* name = (char*)MALLOC(sizeof(char) * len); H5Lget_name_by_idx(dataset, ".", H5_INDEX_NAME, H5_ITER_INC, i, name, len, H5P_DEFAULT); std::string cname(name); FREE(name); if (cname != "__dims__" && cname != "__refs__") { int dataref = getDataSetIdFromName(dataset, cname.data()); if (dataref < 0) { closeList6(dataset); return false; } int refdim = 0; getDatasetInfo(dataref, &complex, &refdim, NULL); std::vector<int> refdims(refdim); int refcount = getDatasetInfo(dataref, &complex, &refdim, refdims.data()); std::vector<hobj_ref_t> vrefs(refcount); ret = H5Dread(dataref, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, vrefs.data()); if (ret < 0) { return false; } //import field for (int j = 0; j < refcount; ++j) { int data = H5Rdereference(refs, H5R_OBJECT, &vrefs[j]); if (data < 0) { return false; } VarInfo6 info2; ret = read_data(data, info2); if (ret == false) { return false; } info.size += info2.size; } closeDataSet(dataref); } } generateInfo(info); closeList6(refs); closeList6(dataset); return true; }
static bool import_double(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname) { SciErr sciErr; int iRet = 0; double *pdblReal = NULL; double *pdblImg = NULL; int iDims = 0; int* piDims = NULL; int iComplex = 0; int iSize = 0; iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL); if (iRet < 0) { return false; } if (iDims) { if (iDims > 2) { //hypermatrix return false; } piDims = (int*)MALLOC(sizeof(int) * iDims); iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims); if (iSize > 0) { pdblReal = (double *)MALLOC(iSize * sizeof(double)); if (iComplex) { pdblImg = (double *)MALLOC(iSize * sizeof(double)); iRet = readDoubleComplexMatrix(_iDatasetId, pdblReal, pdblImg); } else { iRet = readDoubleMatrix(_iDatasetId, pdblReal); } //to be sure ti have 2 dims if (iDims == 1) { FREE(piDims); piDims = (int*)MALLOC(sizeof(int) * 2); piDims[0] = 1; piDims[1] = iSize; } } } if (iDims == 0 || iSize == 0) //empty matrix { if (piDims) { FREE(piDims); } /*bug 7224 : to close dataset */ iRet = readEmptyMatrix(_iDatasetId); if (iRet) { return false; } // Hack to sure that piDims will not be null at line 372. iDims = 2; piDims = (int*)MALLOC(sizeof(int) * iDims); memset(piDims, 0, sizeof(int) * iDims); pdblReal = (double*)MALLOC(sizeof(double) * 1); pdblReal[0] = 0; iComplex = 0; } if (_piAddress == NULL) { if (iComplex) { sciErr = createNamedComplexMatrixOfDouble(pvCtx, _pstVarname, piDims[0], piDims[1], pdblReal, pdblImg); } else { sciErr = createNamedMatrixOfDouble(pvCtx, _pstVarname, piDims[0], piDims[1], pdblReal); } } else //if not null this variable is in a list { if (iComplex) { sciErr = createComplexMatrixOfDoubleInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pdblReal, pdblImg); } else { sciErr = createMatrixOfDoubleInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pdblReal); } } FREE(piDims); FREE(pdblReal); if (iComplex) { FREE(pdblImg); } if (sciErr.iErr) { printError(&sciErr, 0); return false; } return true; }
static bool import_integer(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname) { int iRet = 0; int iDims = 0; int* piDims = NULL; int iComplex = 0; int iSize = 0; int iPrec = 0; SciErr sciErr; iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL); if (iRet < 0) { return false; } piDims = (int*)MALLOC(sizeof(int) * iDims); iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims); iRet = getDatasetPrecision(_iDatasetId, &iPrec); if (iRet) { FREE(piDims); return false; } switch (iPrec) { case SCI_INT8: { char *pcData = NULL; pcData = (char *)MALLOC(sizeof(char) * iSize); iRet = readInteger8Matrix(_iDatasetId, pcData); if (iRet) { FREE(piDims); return false; } if (_piAddress == NULL) { sciErr = createNamedMatrixOfInteger8(pvCtx, _pstVarname, piDims[0], piDims[1], pcData); } else { sciErr = createMatrixOfInteger8InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pcData); } FREE(pcData); } break; case SCI_UINT8: { unsigned char *pucData = NULL; pucData = (unsigned char *)MALLOC(sizeof(unsigned char) * iSize); iRet = readUnsignedInteger8Matrix(_iDatasetId, pucData); if (iRet) { FREE(piDims); return false; } if (_piAddress == NULL) { sciErr = createNamedMatrixOfUnsignedInteger8(pvCtx, _pstVarname, piDims[0], piDims[1], pucData); } else { sciErr = createMatrixOfUnsignedInteger8InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pucData); } FREE(pucData); } break; case SCI_INT16: { short *psData = NULL; psData = (short *)MALLOC(sizeof(short) * iSize); iRet = readInteger16Matrix(_iDatasetId, psData); if (iRet) { FREE(piDims); return false; } if (_piAddress == NULL) { sciErr = createNamedMatrixOfInteger16(pvCtx, _pstVarname, piDims[0], piDims[1], psData); } else { sciErr = createMatrixOfInteger16InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], psData); } FREE(psData); } break; case SCI_UINT16: { unsigned short *pusData = NULL; pusData = (unsigned short *)MALLOC(sizeof(unsigned short) * iSize); iRet = readUnsignedInteger16Matrix(_iDatasetId, pusData); if (iRet) { FREE(piDims); return false; } if (_piAddress == NULL) { sciErr = createNamedMatrixOfUnsignedInteger16(pvCtx, _pstVarname, piDims[0], piDims[1], pusData); } else { sciErr = createMatrixOfUnsignedInteger16InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pusData); } FREE(pusData); } break; case SCI_INT32: { int *piData = NULL; piData = (int *)MALLOC(sizeof(int) * iSize); iRet = readInteger32Matrix(_iDatasetId, piData); if (iRet) { FREE(piDims); return false; } if (_piAddress == NULL) { sciErr = createNamedMatrixOfInteger32(pvCtx, _pstVarname, piDims[0], piDims[1], piData); } else { sciErr = createMatrixOfInteger32InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], piData); } FREE(piData); } break; case SCI_UINT32: { unsigned int *puiData = NULL; puiData = (unsigned int *)MALLOC(sizeof(unsigned int) * iSize); iRet = readUnsignedInteger32Matrix(_iDatasetId, puiData); if (iRet) { FREE(piDims); return false; } if (_piAddress == NULL) { sciErr = createNamedMatrixOfUnsignedInteger32(pvCtx, _pstVarname, piDims[0], piDims[1], puiData); } else { sciErr = createMatrixOfUnsignedInteger32InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], puiData); } FREE(puiData); } break; case SCI_INT64: { #ifdef __SCILAB_INT64__ long long *pllData = NULL; pllData = (long long *)MALLOC(sizeof(long long) * iSize); iRet = readInteger64Matrix(_iDatasetId, pllData); if (iRet) { FREE(piDims); return false; } if (_piAddress == NULL) { sciErr = createNamedMatrixOfInteger64(pvCtx, _pstVarname, piDims[0], piDims[1], pllData); } else { sciErr = createMatrixOfInteger64InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pllData); } FREE(pllData); #else FREE(piDims); return false; #endif } break; case SCI_UINT64: { #ifdef __SCILAB_INT64__ unsigned long long *pullData = NULL; pullData = (unsigned long long *)MALLOC(sizeof(unsigned long long) * iSize); iRet = readUnsignedInteger64Matrix(_iDatasetId, pullData); if (iRet) { FREE(piDims); return false; } if (_piAddress == NULL) { sciErr = createNamedMatrixOfUnsignedInteger64(pvCtx, _pstVarname, piDims[0], piDims[1], pullData); } else { sciErr = createMatrixOfUnsignedInteger64InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pullData); } FREE(pullData); #else FREE(piDims); return false; #endif } break; default: return false; } FREE(piDims); if (sciErr.iErr) { printError(&sciErr, 0); return false; } return true; }
static types::InternalType* import_macro(int dataset) { int complex = 0; int dims = 0; int size = 0; std::vector<int> d(2); std::list<symbol::Variable*>* inputList = new std::list<symbol::Variable*>(); std::list<symbol::Variable*>* outputList = new std::list<symbol::Variable*>(); ast::Exp* body = nullptr; symbol::Context* ctx = symbol::Context::getInstance(); //inputs int inputNode = getDataSetIdFromName(dataset, "inputs"); size = getDatasetInfo(inputNode, &complex, &dims, d.data()); if (size < 0) { delete inputList; delete outputList; closeList6(dataset); return nullptr; } std::vector<char*> inputNames(size); if (size != 0) { readStringMatrix(inputNode, inputNames.data()); for (auto & input : inputNames) { wchar_t* winput = to_wide_string(input); symbol::Variable* var = ctx->getOrCreate(symbol::Symbol(winput)); FREE(winput); inputList->push_back(var); } freeStringMatrix(inputNode, inputNames.data()); } else { closeDataSet(inputNode); } //outputs int outputNode = getDataSetIdFromName(dataset, "outputs"); size = getDatasetInfo(outputNode, &complex, &dims, d.data()); if (size < 0) { delete inputList; delete outputList; closeList6(dataset); return nullptr; } std::vector<char*> outputNames(size); if (size != 0) { readStringMatrix(outputNode, outputNames.data()); for (auto & output : outputNames) { wchar_t* woutput = to_wide_string(output); symbol::Variable* var = ctx->getOrCreate(symbol::Symbol(woutput)); FREE(woutput); outputList->push_back(var); } freeStringMatrix(outputNode, outputNames.data()); } else { closeDataSet(outputNode); } //body int bodyNode = getDataSetIdFromName(dataset, "body"); size = getDatasetInfo(bodyNode, &complex, &dims, d.data()); if (size < 0) { delete inputList; delete outputList; closeList6(dataset); return nullptr; } std::vector<unsigned char> bodybin(size); readUnsignedInteger8Matrix(bodyNode, bodybin.data()); ast::DeserializeVisitor ds(bodybin.data()); body = ds.deserialize(); //wname+1 is to remove "/" at the start of the var name from HDF5 types::Macro* macro = new types::Macro(L"", *inputList, *outputList, *body->getAs<ast::SeqExp>(), L"script"); delete body; closeList6(dataset); return macro; }
static bool import_cell(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname) { int iRet = 0; int iComplex = 0; int iDims = 0; int iItems = 0; hobj_ref_t *piItemRef = NULL; // an hypermatrix is stored in an mlist if (_iVarType != sci_mlist) { return false; } iRet = getListDims(_iDatasetId, &iItems); if (iRet) { return false; } if (iItems != 3) { // cell have 3 elements return false; } iRet = getListItemReferences(_iDatasetId, &piItemRef); if (iRet) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } // get first item int iItemDataset = 0; iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset); if (iRet || iItemDataset == 0) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } // get first item type int iItemType = getScilabTypeFromDataSet(iItemDataset); if (iItemType != sci_strings) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } // get size of first item iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL); if (iRet < 0 || iDims != 2) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } int* piDims = new int[2]; int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims); if (iSize != 3) { deleteListItemReferences(_iDatasetId, piItemRef); delete[] piDims; return false; } delete[] piDims; piDims = NULL; // get data of first item for check the type of mlist char** pstData = new char*[iSize]; iRet = readStringMatrix(iItemDataset, pstData); if (iRet || strcmp(pstData[0], "ce") != 0) { // if not the good type, do not h5close (deleteListItemReferences) FREE(piItemRef); freeStringMatrix(iItemDataset, pstData); delete[] pstData; return false; } freeStringMatrix(iItemDataset, pstData); delete[] pstData; pstData = NULL; // get second item, the Size of cell iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset); if (iRet) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL); if (iRet < 0 || iDims != 2) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } piDims = new int[2]; iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims); if (piDims[0] != 1) { deleteListItemReferences(_iDatasetId, piItemRef); delete[] piDims; return false; } int* piDimsArray = new int[piDims[1]]; iRet = readInteger32Matrix(iItemDataset, piDimsArray); if (iRet) { deleteListItemReferences(_iDatasetId, piItemRef); delete[] piDims; delete[] piDimsArray; return false; } types::Cell* pCell = new types::Cell(piDims[1], piDimsArray); types::List* pList = new types::List(); pList->set(0, types::Double::Empty()); iRet = getListItemDataset(_iDatasetId, piItemRef, 2, &iItemDataset); if (iRet || iItemDataset == 0) { deleteListItemReferences(_iDatasetId, piItemRef); delete pList; delete pCell; return false; } bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, NULL); if (bRet == false) { deleteListItemReferences(_iDatasetId, piItemRef); delete pList; delete pCell; return false; } types::List* pListData = pList->get(0)->getAs<types::List>(); for (int iWriteData = 0; iWriteData < pCell->getSize(); ++iWriteData) { pCell->set(iWriteData, pListData->get(iWriteData)); } delete pList; if (_piAddress == NULL) { wchar_t* pwstName = to_wide_string(_pstVarname); symbol::Context::getInstance()->put(symbol::Symbol(pwstName), pCell); FREE(pwstName); } else { types::List* pParentList = (types::List*)_piAddress; pParentList->set(_iItemPos - 1, pCell); } iRet = deleteListItemReferences(_iDatasetId, piItemRef); if (iRet) { return false; } return true; }
static bool import_hypermat(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname) { int iRet = 0; int iComplex = 0; int iDims = 0; int iItems = 0; hobj_ref_t *piItemRef = NULL; // an hypermatrix is stored in an mlist if (_iVarType != sci_mlist) { return false; } iRet = getListDims(_iDatasetId, &iItems); if (iRet) { return false; } if (iItems != 3) { // hypermatrix have 3 elements return false; } iRet = getListItemReferences(_iDatasetId, &piItemRef); if (iRet) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } // get first item int iItemDataset = 0; iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset); if (iRet || iItemDataset == 0) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } // get first item type int iItemType = getScilabTypeFromDataSet(iItemDataset); if (iItemType != sci_strings) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } // get size of first item iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL); if (iRet < 0 || iDims != 2) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } int* piDims = new int[2]; int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims); if (iSize != 3) { deleteListItemReferences(_iDatasetId, piItemRef); delete[] piDims; return false; } delete[] piDims; piDims = NULL; // get data of first item for check the type of mlist char** pstData = new char*[iSize]; iRet = readStringMatrix(iItemDataset, pstData); if (iRet || strcmp(pstData[0], "hm") != 0) { // if not the good type, do not h5close (deleteListItemReferences) FREE(piItemRef); freeStringMatrix(iItemDataset, pstData); delete[] pstData; return false; } freeStringMatrix(iItemDataset, pstData); delete[] pstData; pstData = NULL; // get second item, the Size of hypermatrix iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset); if (iRet) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL); if (iRet < 0 || iDims != 2) { deleteListItemReferences(_iDatasetId, piItemRef); return false; } piDims = new int[2]; iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims); if (piDims[0] != 1) { deleteListItemReferences(_iDatasetId, piItemRef); delete[] piDims; return false; } int* piDimsArray = new int[piDims[1]]; iRet = readInteger32Matrix(iItemDataset, piDimsArray); if (iRet) { deleteListItemReferences(_iDatasetId, piItemRef); delete[] piDims; delete[] piDimsArray; return false; } // get third item, the Data of hypermatrix // import data like a "type" (Double, Int, ...) instead of mlist iRet = getListItemDataset(_iDatasetId, piItemRef, 2, &iItemDataset); bool bRet = import_data(pvCtx, iItemDataset, _iItemPos, _piAddress, _pstVarname); if (bRet == false) { deleteListItemReferences(_iDatasetId, piItemRef); delete[] piDims; delete[] piDimsArray; return false; } // get imported hypermatrix from List or Context types::GenericType* pGT = NULL; types::InternalType* pIT = NULL; if (_piAddress) { types::List* pL = (types::List*)_piAddress; pIT = pL->get(_iItemPos - 1); } else { wchar_t* pwcsName = to_wide_string(_pstVarname); pIT = symbol::Context::getInstance()->getCurrentLevel(symbol::Symbol(pwcsName)); FREE(pwcsName); } // reshape data with size of hypermatrix pGT = pIT->getAs<types::GenericType>(); pGT->reshape(piDimsArray, piDims[1]); delete[] piDims; delete[] piDimsArray; iRet = deleteListItemReferences(_iDatasetId, piItemRef); if (iRet) { return false; } return true; }
static types::InternalType* import_boolean_sparse(int dataset) { //get sparse dimensions int complex = 0; std::vector<int> pdims; int size = getDimsNode(dataset, &complex, pdims); //get non zeros count int nnz = 0; int datannz = getDataSetIdFromName(dataset, "__nnz__"); readInteger32Matrix(datannz, &nnz); if (nnz == 0) { closeList6(dataset); return new types::SparseBool(pdims[0], pdims[1]); } //get inner vector int datain = getDataSetIdFromName(dataset, "__inner__"); int dimin = 0; int sizein = getDatasetInfo(datain, &complex, &dimin, NULL); std::vector<int> dimsin(dimin); sizein = getDatasetInfo(datain, &complex, &dimin, dimsin.data()); if (sizein < 0) { closeList6(dataset); return nullptr; } std::vector<int> in(sizein); int ret = readInteger32Matrix(datain, in.data()); if (ret < 0) { closeList6(dataset); return nullptr; } //get outer vector int dataout = getDataSetIdFromName(dataset, "__outer__"); int dimout = 0; int sizeout = getDatasetInfo(dataout, &complex, &dimout, NULL); std::vector<int> dimsout(dimout); sizeout = getDatasetInfo(dataout, &complex, &dimout, dimsout.data()); if (sizeout < 0) { closeList6(dataset); return nullptr; } std::vector<int> out(sizeout); ret = readInteger32Matrix(dataout, out.data()); if (ret < 0) { closeList6(dataset); return nullptr; } closeList6(dataset); return new types::SparseBool(pdims[0], pdims[1], nnz, in.data(), out.data()); }
static types::InternalType* import_sparse(int dataset) { types::Sparse* sp = nullptr; //get sparse dimensions int complex = 0; std::vector<int> pdims; int size = getDimsNode(dataset, &complex, pdims); //get non zeros count int nnz = 0; int datannz = getDataSetIdFromName(dataset, "__nnz__"); readInteger32Matrix(datannz, &nnz); if (nnz == 0) { closeList6(dataset); return new types::Sparse(pdims[0], pdims[1]); } //get inner vector int datain = getDataSetIdFromName(dataset, "__inner__"); int dimin = 0; int sizein = getDatasetInfo(datain, &complex, &dimin, NULL); std::vector<int> dimsin(dimin); sizein = getDatasetInfo(datain, &complex, &dimin, dimsin.data()); if (sizein < 0) { closeList6(dataset); return nullptr; } std::vector<int> in(sizein); int ret = readInteger32Matrix(datain, in.data()); if (ret < 0) { closeList6(dataset); return nullptr; } //get outer vector int dataout = getDataSetIdFromName(dataset, "__outer__"); int dimout = 0; int sizeout = getDatasetInfo(dataout, &complex, &dimout, NULL); std::vector<int> dimsout(dimout); sizeout = getDatasetInfo(dataout, &complex, &dimout, dimsout.data()); if (sizeout < 0) { closeList6(dataset); return nullptr; } std::vector<int> out(sizeout); ret = readInteger32Matrix(dataout, out.data()); if (ret < 0) { closeList6(dataset); return nullptr; } //get data int ddata = getDataSetIdFromName(dataset, "__data__"); int dimdata = 0; int sizedata = getDatasetInfo(ddata, &complex, &dimdata, NULL); std::vector<int> dimsdata(dimdata); sizedata = getDatasetInfo(ddata, &complex, &dimdata, dimsdata.data()); if (sizedata < 0) { closeList6(dataset); return nullptr; } std::vector<double> real(sizedata); if (complex) { std::vector<double> img(sizedata); ret = readDoubleComplexMatrix(ddata, real.data(), img.data()); if (ret < 0) { closeList6(dataset); return nullptr; } sp = new types::Sparse(pdims[0], pdims[1], nnz, in.data(), out.data(), real.data(), img.data()); } else { ret = readDoubleMatrix(ddata, real.data()); if (ret < 0) { closeList6(dataset); return nullptr; } sp = new types::Sparse(pdims[0], pdims[1], nnz, in.data(), out.data(), real.data(), nullptr); } closeList6(dataset); return sp; }
static types::InternalType* import_poly(int dataset) { //get poly dims node int complex = 0; std::vector<int> pdims; int size = getDimsNode(dataset, &complex, pdims); //get variable name char* var = NULL; int varname = getDataSetIdFromName(dataset, "__varname__"); readStringMatrix(varname, &var); wchar_t* wvar = to_wide_string(var); std::wstring wvarname(wvar); FREE(wvar); freeStringMatrix(varname, &var); types::Polynom* p = new types::Polynom(wvarname, static_cast<int>(pdims.size()), pdims.data()); types::SinglePoly** pss = p->get(); //open __refs__ node int refs = getDataSetIdFromName(dataset, "__refs__"); size = p->getSize(); //loop on children for (int i = 0; i < size; ++i) { //forge name std::string polyname(std::to_string(i)); int poly = getDataSetIdFromName(refs, polyname.data()); //get dims complex = 0; int dims = 0; int ret = getDatasetInfo(poly, &complex, &dims, NULL); if (ret < 0) { return nullptr; } std::vector<int> d(dims); int datasize = getDatasetInfo(poly, &complex, &dims, d.data()); types::SinglePoly* ss = NULL; //get coef if (dims == 0 || datasize <= 0) { ss = new types::SinglePoly(); } else if (complex) { double* real = NULL; double* img = NULL; //create singlepoly ss = new types::SinglePoly(&real, &img, datasize - 1); readDoubleComplexMatrix(poly, real, img); } else { double* real = NULL; ss = new types::SinglePoly(&real, datasize - 1); readDoubleMatrix(poly, real); } pss[i] = ss; } closeList6(refs); closeList6(dataset); return p; }
static types::InternalType* import_struct(int dataset) { //get struct dims node int complex = 0; std::vector<int> pdims; int size = getDimsNode(dataset, &complex, pdims); types::Struct* str = new types::Struct(static_cast<int>(pdims.size()), pdims.data()); size = str->getSize(); if (size == 0) { //empty struct closeList6(dataset); delete str; return new types::Struct(); } types::SingleStruct** sstr = str->get(); int fieldCount = 0; int ret = getListDims6(dataset, &fieldCount); if (ret < 0) { closeList6(dataset); return str; } //get fields name int dfield = getDataSetIdFromName(dataset, "__fields__"); int dim = 0; getDatasetInfo(dfield, &complex, &dim, NULL); std::vector<int> d(dim); size = getDatasetInfo(dfield, &complex, &dim, d.data()); if (size < 0) { closeList6(dataset); delete str; return nullptr; } //get dims value std::vector<char*> fields(size); readStringMatrix(dfield, fields.data()); //open __refs__ node int refs = getDataSetIdFromName(dataset, "__refs__"); for (const auto & name : fields) { wchar_t* field = to_wide_string(name); str->addField(field); int dataref = getDataSetIdFromName(dataset, name); if (dataref < 0) { closeList6(dataset); freeStringMatrix(dfield, fields.data()); FREE(field); delete str; return nullptr; } int refdim = 0; getDatasetInfo(dataref, &complex, &refdim, NULL); std::vector<int> refdims(refdim); int refcount = getDatasetInfo(dataref, &complex, &refdim, refdims.data()); std::vector<hobj_ref_t> vrefs(refcount); ret = H5Dread(dataref, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, vrefs.data()); if (ret < 0) { freeStringMatrix(dfield, fields.data()); FREE(field); delete str; return nullptr; } //import field for (int j = 0; j < refcount; ++j) { int data = H5Rdereference(refs, H5R_OBJECT, &vrefs[j]); if (data < 0) { freeStringMatrix(dfield, fields.data()); FREE(field); delete str; return nullptr; } types::InternalType* val = import_data(data); if (val == nullptr) { freeStringMatrix(dfield, fields.data()); FREE(field); delete str; return nullptr; } sstr[j]->set(field, val); } FREE(field); closeDataSet(dataref); } freeStringMatrix(dfield, fields.data()); closeList6(refs); closeList6(dataset); return str; }