// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
H5EbsdVolumeReader::Pointer ReadH5Ebsd::initHEDMEbsdVolumeReader()
{
int err = 0;
H5EbsdVolumeReader::Pointer ebsdReader = H5MicVolumeReader::New();
if(NULL == ebsdReader)
{
setErrorCondition(-1);
PipelineMessage em (getHumanLabel(), "Could not Create H5MicVolumeReader object.", -1);
addErrorMessage(em);
return H5EbsdVolumeReader::NullPointer();
}
H5MicVolumeReader* micReader = dynamic_cast<H5MicVolumeReader*>(ebsdReader.get());
err = loadInfo<H5MicVolumeReader, MicPhase>(micReader);
if(err < 0)
{
setErrorCondition(-1);
PipelineMessage em (getHumanLabel(), "Could not read information about the Ebsd Volume.", -1);
addErrorMessage(em);
return H5EbsdVolumeReader::NullPointer();
}
if (m_SelectedVoxelCellArrays.find(m_CellEulerAnglesArrayName) != m_SelectedVoxelCellArrays.end())
{
m_SelectedVoxelCellArrays.insert(Ebsd::Mic::Euler1);
m_SelectedVoxelCellArrays.insert(Ebsd::Ctf::Euler2);
m_SelectedVoxelCellArrays.insert(Ebsd::Ctf::Euler3);
}
if (m_SelectedVoxelCellArrays.find(m_CellPhasesArrayName) != m_SelectedVoxelCellArrays.end())
{
m_SelectedVoxelCellArrays.insert(Ebsd::Ctf::Phase);
}
return ebsdReader;
}
/*--------------------------------------------------------------------------*/
static int getCommonNamedAllocatedSparseMatrix(void* _pvCtx, const char* _pstName, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
{
SciErr sciErr;
sciErr = readCommonNamedSparseMatrix(_pvCtx, _pstName, _iComplex, _piRows, _piCols, _piNbItem, NULL, NULL, NULL, NULL);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_NAMED_ALLOC_SPARSE, _("%s: Unable to get argument \"%s\""), _iComplex ? "getNamedAllocatedComplexSparseMatrix" : "getNamedAllocatedSparseMatrix", _pstName);
printError(&sciErr, 0);
return sciErr.iErr;
}
*_piNbItemRow = (int*)MALLOC(sizeof(int) * *_piRows);
*_piColPos = (int*)MALLOC(sizeof(int) * *_piNbItem);
*_pdblReal = (double*)MALLOC(sizeof(double) * *_piNbItem);
if(_iComplex)
{
*_pdblImg = (double*)MALLOC(sizeof(double) * *_piNbItem);
}
sciErr = readCommonNamedSparseMatrix(_pvCtx, _pstName, _iComplex, _piRows, _piCols, _piNbItem, *_piNbItemRow, *_piColPos, *_pdblReal, *_pdblImg);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_NAMED_ALLOC_SPARSE, _("%s: Unable to get argument \"%s\""), _iComplex ? "getNamedAllocatedComplexSparseMatrix" : "getNamedAllocatedSparseMatrix", _pstName);
printError(&sciErr, 0);
return sciErr.iErr;
}
return 0;
}
SciErr readCommonNamedMatrixOfPoly(void* _pvCtx, const char* _pstName, int _iComplex, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
{
SciErr sciErr;
sciErr.iErr = 0;
sciErr.iMsgCount = 0;
int* piAddr = NULL;
sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_READ_NAMED_POLY, _("%s: Unable to get variable \"%s\""), _iComplex ? "readNamedComplexMatrixOfPoly" : "readNamedMatrixOfPoly", _pstName);
return sciErr;
}
if (_iComplex == 1)
{
sciErr = getComplexMatrixOfPoly(_pvCtx, piAddr, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
}
else
{
sciErr = getMatrixOfPoly(_pvCtx, piAddr, _piRows, _piCols, _piNbCoef, _pdblReal);
}
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_READ_NAMED_POLY, _("%s: Unable to get variable \"%s\""), _iComplex ? "readNamedComplexMatrixOfPoly" : "readNamedMatrixOfPoly", _pstName);
return sciErr;
}
return sciErr;
}
/*--------------------------------------------------------------------------*/
SciErr getVarDimension(void *_pvCtx, int *_piAddress, int *_piRows, int *_piCols)
{
SciErr sciErr;
sciErr.iErr = 0;
sciErr.iMsgCount = 0;
if (_piAddress != NULL && isVarMatrixType(_pvCtx, _piAddress))
{
*_piRows = _piAddress[1];
*_piCols = _piAddress[2];
}
else
{
*_piRows = 0;
*_piCols = 0;
if (_piAddress == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getVarDimension");
}
else
{
addErrorMessage(&sciErr, API_ERROR_NOT_MATRIX_TYPE, _("%s: matrix argument excepted"), "getVarDimension");
}
}
return sciErr;
}
SciErr createCommonMatrixOfPoly(void* _pvCtx, int _iVar, int _iComplex, char* _pstVarName, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg)
{
SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
int *piAddr = NULL;
int iSize = _iRows * _iCols;
int iNewPos = Top - Rhs + _iVar;
int iAddr = *Lstk(iNewPos);
int iTotalLen = 0;
//return empty matrix
if(_iRows == 0 && _iCols == 0)
{
double dblReal = 0;
sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
}
return sciErr;
}
getNewVarAddressFromPosition(_pvCtx, iNewPos, &piAddr);
sciErr = fillCommonMatrixOfPoly(_pvCtx, piAddr, _pstVarName, _iComplex, _iRows, _iCols, _piNbCoef, _pdblReal, _pdblImg, &iTotalLen);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_CREATE_POLY, _("%s: Unable to create variable in Scilab memory"), _iComplex ? "createComplexMatrixOfPoly" : "createMatrixOfPoly");
return sciErr;
}
updateInterSCI(_iVar, '$', iAddr, iAddr + 4 + 4 + iSize + 1);
updateLstk(iNewPos, iAddr + 4 + 4 + iSize + 1, iTotalLen);
return sciErr;
}
/*--------------------------------------------------------------------------*/
static int getCommonAllocatedNamedSinglePoly(void* _pvCtx, const char* _pstName, int _iComplex, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
{
SciErr sciErr;
int iRows = 0;
int iCols = 0;
double* pdblReal = NULL;
double* pdblImg = NULL;
if(isNamedScalar(_pvCtx, _pstName) == 0)
{
addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_SINGLE_POLY, _("%s: Wrong type for input argument \"%s\": A scalar expected.\n"), _iComplex ? "getAllocatedNamedSingleComplexPoly" : "getAllocatedNamedSinglePoly", _pstName);
printError(&sciErr, 0);
return sciErr.iErr;
}
sciErr = readCommonNamedMatrixOfPoly(_pvCtx, _pstName, _iComplex, &iRows, &iCols, _piNbCoef, &pdblReal, &pdblImg);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_SINGLE_POLY, _("%s: Unable to get argument \"%s\""), _iComplex ? "getAllocatedNamedSingleComplexPoly" : "getAllocatedNamedSinglePoly", _pstName);
printError(&sciErr, 0);
return sciErr.iErr;
}
*_pdblReal = (double*)MALLOC(sizeof(double) * *_piNbCoef);
memcpy(*_pdblReal, pdblReal, sizeof(double) * *_piNbCoef);
if(_iComplex)
{
*_pdblImg = (double*)MALLOC(sizeof(double) * *_piNbCoef);
memcpy(*_pdblImg, pdblImg, sizeof(double) * *_piNbCoef);
}
return 0;
}
SciErr readNamedPointer(void* _pvCtx, const char* _pstName, void** _pvPtr)
{
SciErr sciErr;
sciErr.iErr = 0;
sciErr.iMsgCount = 0;
int* piAddr = NULL;
void *pvPtr = NULL;
sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_READ_POINTER, _("%s: Unable to get variable \"%s\""), "readNamedMatrixOfBoolean", _pstName);
return sciErr;
}
sciErr = getPointer(_pvCtx, piAddr, &pvPtr);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_READ_POINTER, _("%s: Unable to get variable \"%s\""), "readNamedMatrixOfBoolean", _pstName);
return sciErr;
}
*_pvPtr = pvPtr;
return sciErr;
}
SciErr getPointer(void* _pvCtx, int* _piAddress, void** _pvPtr)
{
SciErr sciErr;
sciErr.iErr = 0;
sciErr.iMsgCount = 0;
int iType = 0;
double *pdblTmp = NULL;
if ( _piAddress == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getPointer");
return sciErr;
}
sciErr = getVarType(_pvCtx, _piAddress, &iType);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_POINTER, _("%s: Unable to get argument #%d"), "getPointer", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
if (iType != sci_pointer)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s excepted"), "getPointer", _("pointer"));
return sciErr;
}
pdblTmp = (double*)(_piAddress + 4);
*_pvPtr = (void*)((unsigned long int)(*pdblTmp));
return sciErr;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void TriangleNormalFilter::dataCheck(bool preflight, size_t voxels, size_t fields, size_t ensembles)
{
setErrorCondition(0);
std::stringstream ss;
SurfaceMeshDataContainer* sm = getSurfaceMeshDataContainer();
if(NULL == sm)
{
setErrorCondition(-383);
addErrorMessage(getHumanLabel(), "SurfaceMeshDataContainer is missing", getErrorCondition());
}
else
{
// We MUST have Nodes
if(sm->getVertices().get() == NULL)
{
setErrorCondition(-384);
addErrorMessage(getHumanLabel(), "SurfaceMesh DataContainer missing Nodes", getErrorCondition());
}
// We MUST have Triangles defined also.
if(sm->getFaces().get() == NULL)
{
setErrorCondition(-385);
addErrorMessage(getHumanLabel(), "SurfaceMesh DataContainer missing Triangles", getErrorCondition());
}
else
{
CREATE_NON_PREREQ_DATA(sm, DREAM3D, FaceData, SurfaceMeshTriangleNormals, ss, double, DoubleArrayType, 0, voxels, 3)
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void BinaryNodesTrianglesReader::dataCheck(bool preflight, size_t voxels, size_t fields, size_t ensembles)
{
setErrorCondition(0);
std::stringstream ss;
SurfaceMeshDataContainer* sm = getSurfaceMeshDataContainer();
if(NULL == sm)
{
setErrorCondition(-384);
addErrorMessage(getHumanLabel(), "SurfaceMeshDataContainer is missing", getErrorCondition());
}
if (getBinaryNodesFile().empty() == true)
{
std::stringstream ss;
ss << ClassName() << " needs the Binary Nodes File path set and it was not.";
setErrorCondition(-387);
addErrorMessage(getHumanLabel(), ss.str(), getErrorCondition());
}
if (getBinaryNodesFile().empty() == true)
{
std::stringstream ss;
ss << ClassName() << " needs the Binary Nodes File path set and it was not.";
setErrorCondition(-387);
addErrorMessage(getHumanLabel(), ss.str(), getErrorCondition());
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateSurfaceMeshConnectivity::dataCheck(bool preflight, size_t voxels, size_t fields, size_t ensembles)
{
setErrorCondition(0);
std::stringstream ss;
SurfaceMeshDataContainer* sm = getSurfaceMeshDataContainer();
if(NULL == sm)
{
setErrorCondition(-383);
addErrorMessage(getHumanLabel(), "SurfaceMeshDataContainer is missing", getErrorCondition());
}
else
{
// We MUST have Nodes
if(sm->getVertices().get() == NULL)
{
setErrorCondition(-384);
addErrorMessage(getHumanLabel(), "SurfaceMesh DataContainer missing Nodes", getErrorCondition());
}
// We MUST have Triangles defined also.
if(sm->getFaces().get() == NULL)
{
setErrorCondition(-385);
addErrorMessage(getHumanLabel(), "SurfaceMesh DataContainer missing Triangles", getErrorCondition());
}
}
}
/*--------------------------------------------------------------------------*/
SciErr getDimFromNamedVar(void *_pvCtx, const char *_pstName, int *_piVal)
{
SciErr sciErr;
sciErr.iErr = 0;
sciErr.iMsgCount = 0;
int *piAddr = NULL;
sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_NAMED_DIMFROMVAR, _("%s: Unable to get dimension from variable \"%s\""), "getDimFromNamedVar",
_pstName);
return sciErr;
}
sciErr = getDimFromVar(_pvCtx, piAddr, _piVal);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_NAMED_DIMFROMVAR, _("%s: Unable to get dimension from variable \"%s\""), "getDimFromNamedVar",
_pstName);
return sciErr;
}
return sciErr;
}
/*--------------------------------------------------------------------------*/
SciErr createMatrixOfWideString(void* _pvCtx, int _iVar, int _iRows, int _iCols, const wchar_t* const* _pstwStrings)
{
char **pStrings = NULL;
//return empty matrix
if (_iRows == 0 && _iCols == 0)
{
double dblReal = 0;
SciErr sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
}
return sciErr;
}
pStrings = (char**)MALLOC( sizeof(char*) * (_iRows * _iCols) );
for (int i = 0; i < (_iRows * _iCols) ; i++)
{
pStrings[i] = wide_string_to_UTF8(_pstwStrings[i]);
}
SciErr sciErr = createMatrixOfString(_pvCtx, _iVar, _iRows, _iCols, pStrings);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_CREATE_WIDE_STRING, _("%s: Unable to create variable in Scilab memory"), "createMatrixOfWideString");
}
freeArrayOfString(pStrings, _iRows * _iCols);
return sciErr;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AbaqusSurfaceMeshWriter::dataCheck(bool preflight, size_t voxels, size_t fields, size_t ensembles)
{
setErrorCondition(0);
if (m_OutputFile.empty() == true)
{
setErrorCondition(-1003);
addErrorMessage(getHumanLabel(), "Abaqus Output file is not set.", getErrorCondition());
}
SurfaceMeshDataContainer* sm = getSurfaceMeshDataContainer();
if (NULL == sm)
{
setErrorCondition(-384);
addErrorMessage(getHumanLabel(), "SurfaceMeshDataContainer is missing", getErrorCondition());
}
else
{
if (sm->getFaces().get() == NULL)
{
setErrorCondition(-385);
addErrorMessage(getHumanLabel(), "SurfaceMesh DataContainer missing Triangles",getErrorCondition());
}
if (sm->getVertices().get() == NULL)
{
setErrorCondition(-386);
addErrorMessage(getHumanLabel(), "SurfaceMesh DataContainer missing Nodes",getErrorCondition());
}
std::stringstream ss;
GET_PREREQ_DATA(sm, DREAM3D, FaceData, SurfaceMeshFaceLabels, ss, -30, int32_t, Int32ArrayType, sm->getNumFaceTuples(), 2)
}
}
SciErr createBooleanSparseMatrix(void* _pvCtx, int _iVar, int _iRows, int _iCols, int _iNbItem, const int* _piNbItemRow, const int* _piColPos)
{
SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
int* piNbItemRow = NULL;
int* piColPos = NULL;
if(_iRows == 0 && _iCols == 0)
{
double dblReal = 0;
sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
}
return sciErr;
}
sciErr = allocBooleanSparseMatrix(_pvCtx, _iVar, _iRows, _iCols, _iNbItem, &piNbItemRow, &piColPos);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_CREATE_BOOLEAN_SPARSE, _("%s: Unable to create variable in Scilab memory"), "createBooleanSparseMatrix");
return sciErr;
}
memcpy(piNbItemRow, _piNbItemRow, _iRows * sizeof(int));
memcpy(piColPos, _piColPos, _iNbItem * sizeof(int));
return sciErr;
}
/*--------------------------------------------------------------------------*/
int getNamedAllocatedBooleanSparseMatrix(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos)
{
SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
sciErr = readNamedBooleanSparseMatrix(_pvCtx, _pstName, _piRows, _piCols, _piNbItem, NULL, NULL);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_NAMED_ALLOC_BOOLEAN_SPARSE, _("%s: Unable to get argument \"%s\""), "getNamedAllocatedBooleanSparseMatrix", _pstName);
printError(&sciErr, 0);
return sciErr.iErr;
}
*_piNbItemRow = (int*)MALLOC(sizeof(int) * *_piRows);
*_piColPos = (int*)MALLOC(sizeof(int) * *_piNbItem);
sciErr = readNamedBooleanSparseMatrix(_pvCtx, _pstName, _piRows, _piCols, _piNbItem, *_piNbItemRow, *_piColPos);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_NAMED_ALLOC_BOOLEAN_SPARSE, _("%s: Unable to get argument \"%s\""), "getNamedAllocatedBooleanSparseMatrix", _pstName);
printError(&sciErr, 0);
return sciErr.iErr;
}
return 0;
}
SciErr getMatrixOfBoolean(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int** _piBool)
{
SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
int iType = 0;
if( _piAddress == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getMatrixOfBoolean");
return sciErr;
}
sciErr = getVarType(_pvCtx, _piAddress, &iType);
if(sciErr.iErr || iType != sci_boolean)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s excepted"), "getMatrixOfBoolean", _("boolean matrix"));
return sciErr;
}
sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_BOOLEAN, _("%s: Unable to get argument #%d"), "getMatrixOfBoolean", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
if(_piBool)
{
*_piBool = _piAddress + 3;
}
return sciErr;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AdjustVolumeOrigin::dataCheck(bool preflight, size_t voxels, size_t fields, size_t ensembles)
{
setErrorCondition(0);
std::stringstream ss;
if (m_ApplyToVoxelVolume == true)
{
VoxelDataContainer* m = getVoxelDataContainer();
if(NULL == m)
{
setErrorCondition(-383);
addErrorMessage(getHumanLabel(), "VoxelDataContainer is missing", getErrorCondition());
}
}
if (m_ApplyToSurfaceMesh == true)
{
SurfaceMeshDataContainer* sm = getSurfaceMeshDataContainer();
if(NULL == sm)
{
setErrorCondition(-383);
addErrorMessage(getHumanLabel(), "SurfaceMeshDataContainer is missing", getErrorCondition());
}
else
{
// We MUST have Nodes
if(sm->getVertices().get() == NULL)
{
setErrorCondition(-384);
addErrorMessage(getHumanLabel(), "SurfaceMesh DataContainer missing Nodes", getErrorCondition());
}
}
}
}
/*--------------------------------------------------------------------------*/
int getScalarBoolean(void* _pvCtx, int* _piAddress, int* _piBool)
{
SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
int iRows = 0;
int iCols = 0;
int* piBool = NULL;
sciErr = getMatrixOfBoolean(_pvCtx, _piAddress, &iRows, &iCols, &piBool);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_SCALAR_BOOLEAN, _("%s: Unable to get argument #%d"), "getScalarBoolean", getRhsFromAddress(_pvCtx, _piAddress));
printError(&sciErr, 0);
return sciErr.iErr;
}
if(isScalar(_pvCtx, _piAddress) == 0)
{
addErrorMessage(&sciErr, API_ERROR_GET_SCALAR_BOOLEAN, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "getScalarBoolean", getRhsFromAddress(_pvCtx, _piAddress));
printError(&sciErr, 0);
return sciErr.iErr;
}
if(_piBool != NULL)
{
*_piBool = piBool[0];
}
return 0;
}
/*--------------------------------------------------------------------------*/
int getNamedScalarBoolean(void* _pvCtx, const char* _pstName, int* _piBool)
{
SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
int iRows = 0;
int iCols = 0;
int iBool = 0;
sciErr = readNamedMatrixOfBoolean(_pvCtx, _pstName, &iRows, &iCols, &iBool);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_NAMED_SCALAR_BOOLEAN, _("%s: Unable to get argument \"%s\""), "getNamedScalarBoolean", _pstName);
printError(&sciErr, 0);
return sciErr.iErr;
}
if(isNamedScalar(_pvCtx, _pstName) == 0)
{
addErrorMessage(&sciErr, API_ERROR_GET_NAMED_SCALAR_BOOLEAN, _("%s: Wrong type for input argument \"%s\": A scalar expected.\n"), "getNamedScalarBoolean", _pstName);
printError(&sciErr, 0);
return sciErr.iErr;
}
if(_piBool != NULL)
{
*_piBool = iBool;
}
return 0;
}
SciErr createMatrixOfBoolean(void* _pvCtx, int _iVar, int _iRows, int _iCols, const int* _piBool)
{
SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
int* piBool = NULL;
if(_iRows == 0 && _iCols == 0)
{
double dblReal = 0;
sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
}
return sciErr;
}
sciErr = allocMatrixOfBoolean(_pvCtx, _iVar, _iRows, _iCols, &piBool);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_CREATE_BOOLEAN, _("%s: Unable to create variable in Scilab memory"), "createMatrixOfBoolean");
return sciErr;
}
memcpy(piBool, _piBool, sizeof(int) * _iRows * _iCols);
return sciErr;
}
SciErr readNamedMatrixOfBoolean(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int* _piBool)
{
SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
int* piAddr = NULL;
int* piBool = NULL;
sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_READ_BOOLEAN, _("%s: Unable to get variable \"%s\""), "readNamedMatrixOfBoolean", _pstName);
return sciErr;
}
sciErr = getMatrixOfBoolean(_pvCtx, piAddr, _piRows, _piCols, &piBool);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_READ_BOOLEAN, _("%s: Unable to get variable \"%s\""), "readNamedMatrixOfBoolean", _pstName);
return sciErr;
}
if(_piBool)
{
memcpy(_piBool, piBool, sizeof(int) * *_piRows * *_piCols);
}
return sciErr;
}
/*--------------------------------------------------------------------------*/
int getAllocatedNamedSingleWideString(void* _pvCtx, const char* _pstName, wchar_t** _pwstData)
{
SciErr sciErr = sciErrInit();
int iRows = 0;
int iCols = 0;
int iLen = 0;
if (isNamedScalar(_pvCtx, _pstName) == 0 || isNamedStringType(_pvCtx, _pstName) == 0)
{
addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_SINGLE_WIDE_STRING, _("%s: Wrong type for input argument \"%s\": A single string expected.\n"), "getAllocatedNamedSingleWideString", _pstName);
printError(&sciErr, 0);
return sciErr.iErr;
}
sciErr = readNamedMatrixOfWideString(_pvCtx, _pstName, &iRows, &iCols, &iLen, NULL);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_SINGLE_WIDE_STRING, _("%s: Unable to get argument data"), "getAllocatedNamedSingleWideString");
printError(&sciErr, 0);
return sciErr.iErr;
}
*_pwstData = (wchar_t*)MALLOC(sizeof(wchar_t) * (iLen + 1)); //+1 for null termination
sciErr = readNamedMatrixOfWideString(_pvCtx, _pstName, &iRows, &iCols, &iLen, _pwstData);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_SINGLE_WIDE_STRING, _("%s: Unable to get argument data"), "getAllocatedNamedSingleWideString");
printError(&sciErr, 0);
FREE(*_pwstData);
return sciErr.iErr;
}
return 0;
}
int allocSingleString(void* _pvCtx, int _iVar, int _iLen, const char** _pstStrings)
{
SciErr sciErr = sciErrInit();
types::GatewayStruct* pGstr = (types::GatewayStruct*)_pvCtx;
types::typed_list in = *pGstr->m_pIn;
types::InternalType** out = pGstr->m_pOut;
types::String *pStr = NULL;
char* pstStrings = new char[_iLen];
memset(pstStrings, ' ', _iLen);
if (_pstStrings == NULL)
{
addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), "allocSingleString");
return sciErr.iErr;
}
_pstStrings[0] = pstStrings;
pStr = new types::String(pstStrings);
if (pStr == NULL)
{
addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), "allocSingleString");
return sciErr.iErr;
}
int rhs = _iVar - *getNbInputArgument(_pvCtx);
out[rhs - 1] = pStr;
return sciErr.iErr;
}
/*--------------------------------------------------------------------------*/
int getAllocatedSingleString(void* _pvCtx, int* _piAddress, char** _pstData)
{
SciErr sciErr = sciErrInit();
int iRows = 0;
int iCols = 0;
int iLen = 0;
if (isScalar(_pvCtx, _piAddress) == 0 || isStringType(_pvCtx, _piAddress) == 0)
{
addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_SINGLE_STRING, _("%s: Wrong type for input argument #%d: A single string expected.\n"), "getAllocatedSingleString", getRhsFromAddress(_pvCtx, _piAddress));
printError(&sciErr, 0);
return sciErr.iErr;
}
sciErr = getMatrixOfString(_pvCtx, _piAddress, &iRows, &iCols, &iLen, NULL);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_SINGLE_STRING, _("%s: Unable to get argument data"), "getAllocatedSingleString");
printError(&sciErr, 0);
return sciErr.iErr;
}
*_pstData = (char*)MALLOC(sizeof(char) * (iLen + 1)); //+1 for null termination
sciErr = getMatrixOfString(_pvCtx, _piAddress, &iRows, &iCols, &iLen, _pstData);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_SINGLE_STRING, _("%s: Unable to get argument data"), "getAllocatedSingleString");
printError(&sciErr, 0);
FREE(*_pstData);
return sciErr.iErr;
}
return 0;
}
SciErr getPolyVariableName(void* _pvCtx, int* _piAddress, char* _pstVarName, int* _piVarNameLen)
{
SciErr sciErr = sciErrInit();
if (_piAddress == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getPolyVariableName");
return sciErr;
}
if (!((types::InternalType*)_piAddress)->isPoly())
{
addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), "getPolyVariableName", _("polynomial matrix"));
return sciErr;
}
if (*_piVarNameLen == 0)
{
*_piVarNameLen = (int)((types::InternalType*)_piAddress)->getAs<types::Polynom>()->getVariableName().size();
//No error
}
if (_pstVarName == NULL)
{
return sciErr;
}
char* pstTemp = wide_string_to_UTF8(((types::InternalType*)_piAddress)->getAs<types::Polynom>()->getVariableName().c_str());
strcpy(_pstVarName, pstTemp);
FREE(pstTemp);
*_piVarNameLen = static_cast<int>(strlen(_pstVarName));
return sciErr;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int ReadH5Ebsd::initDataContainerDimsRes(int64_t dims[3], VoxelDataContainer* m)
{
int err = 0;
/* Sanity check what we are trying to load to make sure it can fit in our address space.
* Note that this does not guarantee the user has enough left, just that the
* size of the volume can fit in the address space of the program
*/
#if (CMP_SIZEOF_SSIZE_T==4)
int64_t max = std::numeric_limits<size_t>::max();
#else
int64_t max = std::numeric_limits<int64_t>::max();
#endif
if(dims[0] * dims[1] * dims[2] > max)
{
err = -1;
std::stringstream s;
s << "The total number of elements '" << (dims[0] * dims[1] * dims[2]) << "' is greater than this program can hold. Try the 64 bit version.";
setErrorCondition(err);
addErrorMessage(getHumanLabel(), s.str(), err);
return err;
}
if(dims[0] > max || dims[1] > max || dims[2] > max)
{
err = -1;
std::stringstream s;
s << "One of the dimensions is greater than the max index for this sysem. Try the 64 bit version.";
s << " dim[0]=" << dims[0] << " dim[1]=" << dims[1] << " dim[2]=" << dims[2];
setErrorCondition(err);
addErrorMessage(getHumanLabel(), s.str(), err);
return err;
}
return err;
}
SciErr createCommonMatrixOfPoly(void* _pvCtx, int _iVar, int _iComplex, char* _pstVarName, int _iRows, int _iCols, const int* _piNbCoef, const double* const* _pdblReal, const double* const* _pdblImg)
{
SciErr sciErr = sciErrInit();
if (_pvCtx == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), _iComplex ? "createComplexMatrixOfPoly" : "createMatrixOfPoly");
return sciErr;
}
types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
types::InternalType** out = pStr->m_pOut;
int rhs = _iVar - *getNbInputArgument(_pvCtx);
//return empty matrix
if (_iRows == 0 && _iCols == 0)
{
types::Double *pDbl = new types::Double(_iRows, _iCols);
if (pDbl == NULL)
{
addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
return sciErr;
}
out[rhs - 1] = pDbl;
return sciErr;
}
wchar_t* pstTemp = to_wide_string(_pstVarName);
std::wstring wstTemp(pstTemp);
types::Polynom* pP = new types::Polynom(wstTemp, _iRows, _iCols, _piNbCoef);
FREE(pstTemp);
if (pP == NULL)
{
addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocated variable"), _iComplex ? "createComplexMatrixOfPoly" : "createMatrixOfPoly");
return sciErr;
}
if (_iComplex)
{
pP->setComplex(true);
}
out[rhs - 1] = pP;
for (int i = 0 ; i < pP->getSize() ; i++)
{
types::Double* pD = new types::Double(_piNbCoef[i], 1, _iComplex == 1);
pD->set(_pdblReal[i]);
if (_iComplex)
{
pD->setImg(_pdblImg[i]);
}
pP->setCoef(i, pD);
delete pD;
}
return sciErr;
}
/*--------------------------------------------------------------------------*/
int getAllocatedNamedMatrixOfWideString(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, wchar_t*** _pwstData)
{
int iRows = 0;
int iCols = 0;
int* piLen = 0;
SciErr sciErr = readNamedMatrixOfWideString(_pvCtx, _pstName, &iRows, &iCols, NULL, NULL);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_WIDE_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedNamedMatrixOfWideString");
printError(&sciErr, 0);
return sciErr.iErr;
}
piLen = (int*)MALLOC(sizeof(int) **_piRows **_piCols);
sciErr = readNamedMatrixOfWideString(_pvCtx, _pstName, &iRows, &iCols, piLen, NULL);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_WIDE_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedNamedMatrixOfWideString");
if (piLen)
{
FREE(piLen);
piLen = NULL;
}
printError(&sciErr, 0);
return sciErr.iErr;
}
*_pwstData = (wchar_t**)MALLOC(sizeof(wchar_t*) **_piRows **_piCols);
for (int i = 0 ; i < *_piRows **_piCols ; i++)
{
*_pwstData[i] = (wchar_t*)MALLOC(sizeof(wchar_t) * (piLen[i] + 1));//+1 for null termination
}
sciErr = readNamedMatrixOfWideString(_pvCtx, _pstName, &iRows, &iCols, piLen, *_pwstData);
if (piLen)
{
FREE(piLen);
piLen = NULL;
}
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_ALLOC_NAMED_WIDE_STRING_MATRIX, _("%s: Unable to get argument data"), "getAllocatedNamedMatrixOfWideString");
printError(&sciErr, 0);
for (int i = 0 ; i < *_piRows **_piCols ; i++)
{
FREE((*_pwstData)[i]);
}
FREE(*_pwstData);
return sciErr.iErr;
}
return 0;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GoldfeatherReader::dataCheck(bool preflight, size_t voxels, size_t fields, size_t ensembles)
{
setErrorCondition(0);
std::stringstream ss;
SurfaceMeshDataContainer* sm = getSurfaceMeshDataContainer();
if (getInputFile().empty() == true)
{
ss << ClassName() << " needs the Input File Set and it was not.";
setErrorCondition(-387);
addErrorMessage(getHumanLabel(), ss.str(), getErrorCondition());
}
else if (MXAFileInfo::exists(getInputFile()) == false)
{
ss << "The input file does not exist.";
setErrorCondition(-388);
addErrorMessage(getHumanLabel(), ss.str(), getErrorCondition());
}
DREAM3D::SurfaceMesh::VertListPointer_t vertices = DREAM3D::SurfaceMesh::VertList_t::CreateArray(1, DREAM3D::VertexData::SurfaceMeshNodes);
DREAM3D::SurfaceMesh::FaceListPointer_t triangles = DREAM3D::SurfaceMesh::FaceList_t::CreateArray(1, DREAM3D::FaceData::SurfaceMeshFaces);
sm->setVertices(vertices);
sm->setFaces(triangles);
DoubleArrayType::Pointer normalsPtr = DoubleArrayType::CreateArray(1, 3, DREAM3D::VertexData::SurfaceMeshNodeNormals);
//addCreatedCellData( normalsPtr->GetName());
sm->addVertexData(normalsPtr->GetName(), normalsPtr);
DoubleArrayType::Pointer pcurv1Ptr = DoubleArrayType::CreateArray(1, 1, "Principal_Curvature_1");
//addCreatedCellData( pcurv1Ptr->GetName());
sm->addVertexData(pcurv1Ptr->GetName(), pcurv1Ptr);
DoubleArrayType::Pointer pcurv2Ptr = DoubleArrayType::CreateArray(1, 1, "Principal_Curvature_2");
// addCreatedCellData( pcurv2Ptr->GetName());
sm->addVertexData(pcurv2Ptr->GetName(), pcurv2Ptr);
DoubleArrayType::Pointer pDirection1Ptr = DoubleArrayType::CreateArray(1, 3, "Principal_Direction_1");
// addCreatedCellData( pDirection1Ptr->GetName());
sm->addVertexData(pDirection1Ptr->GetName(), pDirection1Ptr);
DoubleArrayType::Pointer pDirection2Ptr = DoubleArrayType::CreateArray(1, 3, "Principal_Direction_2");
// addCreatedCellData( pDirection2Ptr->GetName());
sm->addVertexData(pDirection2Ptr->GetName(), pDirection2Ptr);
DataArray<int32_t>::Pointer faceLabelPtr = DataArray<int32_t>::CreateArray(1, 2, DREAM3D::FaceData::SurfaceMeshFaceLabels);
// addCreatedFieldData( faceLabelPtr->GetName());
sm->addFaceData(faceLabelPtr->GetName(), faceLabelPtr);
DoubleArrayType::Pointer triNormalsPtr = DoubleArrayType::CreateArray(1, 3, DREAM3D::FaceData::SurfaceMeshFaceNormals);
// addCreatedFieldData( triNormalsPtr->GetName());
sm->addFaceData(triNormalsPtr->GetName(), triNormalsPtr);
}