From cca150841cd1de4f3b4d24c1188263b9623bc511 Mon Sep 17 00:00:00 2001 From: Wim van Aarle Date: Thu, 26 Feb 2015 13:47:59 +0100 Subject: get_geometry now uses XML config object (for projections) --- include/astra/ConeProjectionGeometry3D.h | 6 + include/astra/ConeVecProjectionGeometry3D.h | 6 + include/astra/FanFlatProjectionGeometry2D.h | 6 + include/astra/FanFlatVecProjectionGeometry2D.h | 7 + include/astra/ParallelProjectionGeometry2D.h | 6 + include/astra/ParallelProjectionGeometry3D.h | 6 + include/astra/ParallelVecProjectionGeometry3D.h | 6 + include/astra/ProjectionGeometry2D.h | 6 + include/astra/ProjectionGeometry3D.h | 6 + include/astra/SparseMatrixProjectionGeometry2D.h | 8 +- matlab/mex/astra_mex_data2d_c.cpp | 6 +- matlab/mex/astra_mex_data3d_c.cpp | 5 +- matlab/mex/astra_mex_projector3d_c.cpp | 4 +- matlab/mex/astra_mex_projector_c.cpp | 5 +- matlab/mex/mexHelpFunctions.cpp | 332 ++++++----------------- matlab/mex/mexHelpFunctions.h | 10 +- src/ConeProjectionGeometry3D.cpp | 18 ++ src/ConeVecProjectionGeometry3D.cpp | 33 +++ src/FanFlatProjectionGeometry2D.cpp | 14 + src/FanFlatVecProjectionGeometry2D.cpp | 24 +- src/ParallelProjectionGeometry2D.cpp | 14 + src/ParallelProjectionGeometry3D.cpp | 17 ++ src/ParallelVecProjectionGeometry3D.cpp | 34 +++ src/SparseMatrixProjectionGeometry2D.cpp | 13 + src/XMLNode.cpp | 10 +- 25 files changed, 328 insertions(+), 274 deletions(-) diff --git a/include/astra/ConeProjectionGeometry3D.h b/include/astra/ConeProjectionGeometry3D.h index 2a0474d..6257f7e 100644 --- a/include/astra/ConeProjectionGeometry3D.h +++ b/include/astra/ConeProjectionGeometry3D.h @@ -148,6 +148,12 @@ public: */ virtual bool isEqual(const CProjectionGeometry3D*) const; + /** Get all settings in a Config object. + * + * @return Configuration Object. + */ + virtual Config* getConfiguration() const; + /** Returns true if the type of geometry defined in this class is the one specified in _sType. * * @param _sType geometry type to compare to. diff --git a/include/astra/ConeVecProjectionGeometry3D.h b/include/astra/ConeVecProjectionGeometry3D.h index 68a80ef..0330066 100644 --- a/include/astra/ConeVecProjectionGeometry3D.h +++ b/include/astra/ConeVecProjectionGeometry3D.h @@ -128,6 +128,12 @@ public: */ virtual bool isEqual(const CProjectionGeometry3D*) const; + /** Get all settings in a Config object. + * + * @return Configuration Object. + */ + virtual Config* getConfiguration() const; + /** Returns true if the type of geometry defined in this class is the one specified in _sType. * * @param _sType geometry type to compare to. diff --git a/include/astra/FanFlatProjectionGeometry2D.h b/include/astra/FanFlatProjectionGeometry2D.h index 8f22c35..180fe68 100644 --- a/include/astra/FanFlatProjectionGeometry2D.h +++ b/include/astra/FanFlatProjectionGeometry2D.h @@ -140,6 +140,12 @@ public: */ virtual bool isOfType(const std::string& _sType); + /** Get all settings in a Config object. + * + * @return Configuration Object. + */ + virtual Config* getConfiguration() const; + /** Return true if this geometry instance is the same as the one specified. * * @return true if this geometry instance is the same as the one specified. diff --git a/include/astra/FanFlatVecProjectionGeometry2D.h b/include/astra/FanFlatVecProjectionGeometry2D.h index 85c994f..825bcbc 100644 --- a/include/astra/FanFlatVecProjectionGeometry2D.h +++ b/include/astra/FanFlatVecProjectionGeometry2D.h @@ -126,6 +126,13 @@ public: */ virtual bool isEqual(CProjectionGeometry2D*) const; + /** Get all settings in a Config object. + * + * @return Configuration Object. + */ + virtual Config* getConfiguration() const; + + /** Get the value for t and theta, based upon the row and column index. * * @param _iRow row index diff --git a/include/astra/ParallelProjectionGeometry2D.h b/include/astra/ParallelProjectionGeometry2D.h index ed9d228..2f7d36f 100644 --- a/include/astra/ParallelProjectionGeometry2D.h +++ b/include/astra/ParallelProjectionGeometry2D.h @@ -136,6 +136,12 @@ public: */ virtual bool isOfType(const std::string& _sType); + /** Get all settings in a Config object. + * + * @return Configuration Object. + */ + virtual Config* getConfiguration() const; + /** * Returns a vector describing the direction of a ray belonging to a certain detector, * the direction is the same for all detectors in one projection diff --git a/include/astra/ParallelProjectionGeometry3D.h b/include/astra/ParallelProjectionGeometry3D.h index da60617..aa93a29 100644 --- a/include/astra/ParallelProjectionGeometry3D.h +++ b/include/astra/ParallelProjectionGeometry3D.h @@ -129,6 +129,12 @@ public: */ virtual bool isEqual(const CProjectionGeometry3D*) const; + /** Get all settings in a Config object. + * + * @return Configuration Object. + */ + virtual Config* getConfiguration() const; + /** Returns true if the type of geometry defined in this class is the one specified in _sType. * * @param _sType geometry type to compare to. diff --git a/include/astra/ParallelVecProjectionGeometry3D.h b/include/astra/ParallelVecProjectionGeometry3D.h index fbc2112..f3ed949 100644 --- a/include/astra/ParallelVecProjectionGeometry3D.h +++ b/include/astra/ParallelVecProjectionGeometry3D.h @@ -128,6 +128,12 @@ public: */ virtual bool isEqual(const CProjectionGeometry3D*) const; + /** Get all settings in a Config object. + * + * @return Configuration Object. + */ + virtual Config* getConfiguration() const; + /** Returns true if the type of geometry defined in this class is the one specified in _sType. * * @param _sType geometry type to compare to. diff --git a/include/astra/ProjectionGeometry2D.h b/include/astra/ProjectionGeometry2D.h index 303ca0a..b8324e2 100644 --- a/include/astra/ProjectionGeometry2D.h +++ b/include/astra/ProjectionGeometry2D.h @@ -157,6 +157,12 @@ public: */ virtual bool isEqual(CProjectionGeometry2D*) const = 0; + /** Get all settings in a Config object. + * + * @return Configuration Object. + */ + virtual Config* getConfiguration() const = 0; + /** Get the number of projection angles. * * @return Number of projection angles diff --git a/include/astra/ProjectionGeometry3D.h b/include/astra/ProjectionGeometry3D.h index 41b1cb7..b6e63a8 100644 --- a/include/astra/ProjectionGeometry3D.h +++ b/include/astra/ProjectionGeometry3D.h @@ -187,6 +187,12 @@ public: */ virtual bool isEqual(const CProjectionGeometry3D *) const = 0; + /** Get all settings in a Config object. + * + * @return Configuration Object. + */ + virtual Config* getConfiguration() const = 0; + /** Get the number of projections. * * @return Number of projections diff --git a/include/astra/SparseMatrixProjectionGeometry2D.h b/include/astra/SparseMatrixProjectionGeometry2D.h index 36964be..d56f95e 100644 --- a/include/astra/SparseMatrixProjectionGeometry2D.h +++ b/include/astra/SparseMatrixProjectionGeometry2D.h @@ -103,7 +103,6 @@ public: * @param _pMatrix Pointer to a CSparseMatrix. The caller is responsible for keeping this matrix valid until it is no longer required. * @return initialization successful? */ - bool setMatrix(CSparseMatrix* _pMatrix); /** Get a pointer to the associated sparse matrix. @@ -128,6 +127,13 @@ public: */ virtual bool isOfType(const std::string& _sType); + /** Get all settings in a Config object. + * + * @return Configuration Object. + */ + virtual Config* getConfiguration() const; + + /** * Returns a vector describing the direction of a ray belonging to a certain detector * diff --git a/matlab/mex/astra_mex_data2d_c.cpp b/matlab/mex/astra_mex_data2d_c.cpp index d07a13a..03d3807 100644 --- a/matlab/mex/astra_mex_data2d_c.cpp +++ b/matlab/mex/astra_mex_data2d_c.cpp @@ -395,13 +395,11 @@ void astra_mex_data2d_get_geometry(int nlhs, mxArray* plhs[], int nrhs, const mx if (1 <= nlhs) { if (pDataObject->getType() == CFloat32Data2D::PROJECTION) { CFloat32ProjectionData2D* pDataObject2 = dynamic_cast(pDataObject); - plhs[0] = createProjectionGeometryStruct(pDataObject2->getGeometry()); + plhs[0] = configToStruct(pDataObject2->getGeometry()->getConfiguration()); } else if (pDataObject->getType() == CFloat32Data2D::VOLUME) { CFloat32VolumeData2D* pDataObject2 = dynamic_cast(pDataObject); - plhs[0] = config2struct(pDataObject2->getGeometry()->getConfiguration()); - // mexErrMsgTxt(pDataObject2->getGeometry()->getConfiguration()->self->toString().c_str()); - // plhs[0] = createVolumeGeometryStruct(pDataObject2->getGeometry()); + plhs[0] = configToStruct(pDataObject2->getGeometry()->getConfiguration()); } } } diff --git a/matlab/mex/astra_mex_data3d_c.cpp b/matlab/mex/astra_mex_data3d_c.cpp index 5abdf50..64c013d 100644 --- a/matlab/mex/astra_mex_data3d_c.cpp +++ b/matlab/mex/astra_mex_data3d_c.cpp @@ -296,11 +296,12 @@ void astra_mex_data3d_get_geometry(int nlhs, mxArray* plhs[], int nrhs, const mx if (1 <= nlhs) { if (pDataObject->getType() == CFloat32Data3D::PROJECTION) { CFloat32ProjectionData3DMemory* pDataObject2 = dynamic_cast(pDataObject); - plhs[0] = createProjectionGeometryStruct(pDataObject2->getGeometry()); + plhs[0] = configToStruct(pDataObject2->getGeometry()->getConfiguration()); + } else if (pDataObject->getType() == CFloat32Data3D::VOLUME) { CFloat32VolumeData3DMemory* pDataObject2 = dynamic_cast(pDataObject); - plhs[0] = config2struct(pDataObject2->getGeometry()->getConfiguration()); + plhs[0] = configToStruct(pDataObject2->getGeometry()->getConfiguration()); } } diff --git a/matlab/mex/astra_mex_projector3d_c.cpp b/matlab/mex/astra_mex_projector3d_c.cpp index 95b3e0f..b2f6b02 100644 --- a/matlab/mex/astra_mex_projector3d_c.cpp +++ b/matlab/mex/astra_mex_projector3d_c.cpp @@ -136,7 +136,7 @@ void astra_mex_projector3d_get_projection_geometry(int nlhs, mxArray* plhs[], in // step3: get projection_geometry and turn it into a MATLAB struct if (1 <= nlhs) { - plhs[0] = createProjectionGeometryStruct(pProjector->getProjectionGeometry()); + plhs[0] = configToStruct(pProjector->getProjectionGeometry()->getConfiguration()); } } @@ -162,7 +162,7 @@ void astra_mex_projector3d_get_volume_geometry(int nlhs, mxArray* plhs[], int nr // step3: get projection_geometry and turn it into a MATLAB struct if (1 <= nlhs) { - plhs[0] = createVolumeGeometryStruct(pProjector->getVolumeGeometry()); + plhs[0] = configToStruct(pProjector->getVolumeGeometry()->getConfiguration()); } } diff --git a/matlab/mex/astra_mex_projector_c.cpp b/matlab/mex/astra_mex_projector_c.cpp index de73f07..4793020 100644 --- a/matlab/mex/astra_mex_projector_c.cpp +++ b/matlab/mex/astra_mex_projector_c.cpp @@ -162,7 +162,7 @@ void astra_mex_projector_projection_geometry(int nlhs, mxArray* plhs[], int nrhs // step3: get projection_geometry and turn it into a MATLAB struct if (1 <= nlhs) { - plhs[0] = createProjectionGeometryStruct(pProjector->getProjectionGeometry()); + plhs[0] = configToStruct(pProjector->getProjectionGeometry()->getConfiguration()); } } @@ -191,7 +191,8 @@ void astra_mex_projector_volume_geometry(int nlhs, mxArray* plhs[], int nrhs, co // step3: get projection_geometry and turn it into a MATLAB struct if (1 <= nlhs) { - plhs[0] = createVolumeGeometryStruct(pProjector->getVolumeGeometry()); + plhs[0] = configToStruct(pProjector->getVolumeGeometry()->getConfiguration()); + } } diff --git a/matlab/mex/mexHelpFunctions.cpp b/matlab/mex/mexHelpFunctions.cpp index b57f27f..c25123a 100644 --- a/matlab/mex/mexHelpFunctions.cpp +++ b/matlab/mex/mexHelpFunctions.cpp @@ -32,6 +32,12 @@ $Id$ */ #include "mexHelpFunctions.h" +#include +#include +#include +#include +#include + #include "astra/SparseMatrixProjectionGeometry2D.h" #include "astra/FanFlatVecProjectionGeometry2D.h" #include "astra/AstraObjectManager.h" @@ -206,188 +212,6 @@ astra::CProjectionGeometry2D* parseProjectionGeometryStruct(const mxArray* prhs) } } -//----------------------------------------------------------------------------------------- -// create 2D projection geometry struct -mxArray* createProjectionGeometryStruct(astra::CProjectionGeometry2D* _pProjGeom) -{ - // temporary map to store the data for the MATLAB struct - std::map mGeometryInfo; - - // parallel beam - if (_pProjGeom->isOfType("parallel")) { - mGeometryInfo["type"] = mxCreateString("parallel"); - mGeometryInfo["DetectorCount"] = mxCreateDoubleScalar(_pProjGeom->getDetectorCount()); - mGeometryInfo["DetectorWidth"] = mxCreateDoubleScalar(_pProjGeom->getDetectorWidth()); - - mxArray* pAngles = mxCreateDoubleMatrix(1, _pProjGeom->getProjectionAngleCount(), mxREAL); - double* out = mxGetPr(pAngles); - for (int i = 0; i < _pProjGeom->getProjectionAngleCount(); i++) { - out[i] = _pProjGeom->getProjectionAngle(i); - } - mGeometryInfo["ProjectionAngles"] = pAngles; - } - - // fanflat - else if (_pProjGeom->isOfType("fanflat")) { - astra::CFanFlatProjectionGeometry2D* pFanFlatGeom = dynamic_cast(_pProjGeom); - - mGeometryInfo["type"] = mxCreateString("fanflat"); - mGeometryInfo["DetectorCount"] = mxCreateDoubleScalar(_pProjGeom->getDetectorCount()); - mGeometryInfo["DetectorWidth"] = mxCreateDoubleScalar(_pProjGeom->getDetectorWidth()); - mGeometryInfo["DistanceOriginSource"] = mxCreateDoubleScalar(pFanFlatGeom->getOriginSourceDistance()); - mGeometryInfo["DistanceOriginDetector"] = mxCreateDoubleScalar(pFanFlatGeom->getOriginDetectorDistance()); - - mxArray* pAngles = mxCreateDoubleMatrix(1, pFanFlatGeom->getProjectionAngleCount(), mxREAL); - double* out = mxGetPr(pAngles); - for (int i = 0; i < pFanFlatGeom->getProjectionAngleCount(); i++) { - out[i] = pFanFlatGeom->getProjectionAngle(i); - } - mGeometryInfo["ProjectionAngles"] = pAngles; - } - - // fanflat_vec - else if (_pProjGeom->isOfType("fanflat_vec")) { - astra::CFanFlatVecProjectionGeometry2D* pVecGeom = dynamic_cast(_pProjGeom); - - mGeometryInfo["type"] = mxCreateString("fanflat_vec"); - mGeometryInfo["DetectorCount"] = mxCreateDoubleScalar(pVecGeom->getDetectorCount()); - - mxArray* pVectors = mxCreateDoubleMatrix(pVecGeom->getProjectionAngleCount(), 6, mxREAL); - double* out = mxGetPr(pVectors); - int iDetCount = pVecGeom->getDetectorCount(); - int iAngleCount = pVecGeom->getProjectionAngleCount(); - for (int i = 0; i < pVecGeom->getProjectionAngleCount(); i++) { - const SFanProjection* p = &pVecGeom->getProjectionVectors()[i]; - out[0*iAngleCount + i] = p->fSrcX; - out[1*iAngleCount + i] = p->fSrcY; - out[2*iAngleCount + i] = p->fDetSX + 0.5f*iDetCount*p->fDetUX; - out[3*iAngleCount + i] = p->fDetSY + 0.5f*iDetCount*p->fDetUY; - out[4*iAngleCount + i] = p->fDetUX; - out[5*iAngleCount + i] = p->fDetUY; - } - mGeometryInfo["Vectors"] = pVectors; - } - - // sparse_matrix - else if (_pProjGeom->isOfType("sparse_matrix")) { - astra::CSparseMatrixProjectionGeometry2D* pSparseMatrixGeom = dynamic_cast(_pProjGeom); - mGeometryInfo["type"] = mxCreateString("sparse_matrix"); - mGeometryInfo["MatrixID"] = mxCreateDoubleScalar(CMatrixManager::getSingleton().getIndex(pSparseMatrixGeom->getMatrix())); - } - - // build and return the MATLAB struct - return buildStruct(mGeometryInfo); -} - -//----------------------------------------------------------------------------------------- -// create 3D projection geometry struct -mxArray* createProjectionGeometryStruct(astra::CProjectionGeometry3D* _pProjGeom) -{ - // temporary map to store the data for the MATLAB struct - std::map mGeometryInfo; - - // parallel beam - if (_pProjGeom->isOfType("parallel3d")) { - mGeometryInfo["type"] = mxCreateString("parallel3d"); - mGeometryInfo["DetectorRowCount"] = mxCreateDoubleScalar(_pProjGeom->getDetectorRowCount()); - mGeometryInfo["DetectorColCount"] = mxCreateDoubleScalar(_pProjGeom->getDetectorColCount()); - mGeometryInfo["DetectorSpacingX"] = mxCreateDoubleScalar(_pProjGeom->getDetectorSpacingX()); - mGeometryInfo["DetectorSpacingY"] = mxCreateDoubleScalar(_pProjGeom->getDetectorSpacingY()); - - mxArray* pAngles = mxCreateDoubleMatrix(1, _pProjGeom->getProjectionCount(), mxREAL); - double* out = mxGetPr(pAngles); - for (int i = 0; i < _pProjGeom->getProjectionCount(); i++) { - out[i] = _pProjGeom->getProjectionAngle(i); - } - mGeometryInfo["ProjectionAngles"] = pAngles; - } - - // parallel beam vector - if (_pProjGeom->isOfType("parallel3d_vec")) { - astra::CParallelVecProjectionGeometry3D* pVecGeom = dynamic_cast(_pProjGeom); - - mGeometryInfo["type"] = mxCreateString("parallel3d_vec"); - mGeometryInfo["DetectorRowCount"] = mxCreateDoubleScalar(pVecGeom->getDetectorRowCount()); - mGeometryInfo["DetectorColCount"] = mxCreateDoubleScalar(pVecGeom->getDetectorColCount()); - - mxArray* pVectors = mxCreateDoubleMatrix(pVecGeom->getProjectionCount(), 12, mxREAL); - double* out = mxGetPr(pVectors); - int iDetRowCount = pVecGeom->getDetectorRowCount(); - int iDetColCount = pVecGeom->getDetectorColCount(); - int iAngleCount = pVecGeom->getProjectionCount(); - for (int i = 0; i < pVecGeom->getProjectionCount(); i++) { - const SPar3DProjection* p = &pVecGeom->getProjectionVectors()[i]; - out[ 0*iAngleCount + i] = p->fRayX; - out[ 1*iAngleCount + i] = p->fRayY; - out[ 2*iAngleCount + i] = p->fRayZ; - out[ 3*iAngleCount + i] = p->fDetSX + 0.5f*iDetRowCount*p->fDetUX + 0.5f*iDetColCount*p->fDetVX; - out[ 4*iAngleCount + i] = p->fDetSY + 0.5f*iDetRowCount*p->fDetUY + 0.5f*iDetColCount*p->fDetVY; - out[ 5*iAngleCount + i] = p->fDetSZ + 0.5f*iDetRowCount*p->fDetUZ + 0.5f*iDetColCount*p->fDetVZ; - out[ 6*iAngleCount + i] = p->fDetUX; - out[ 7*iAngleCount + i] = p->fDetUY; - out[ 8*iAngleCount + i] = p->fDetUZ; - out[ 9*iAngleCount + i] = p->fDetVX; - out[10*iAngleCount + i] = p->fDetVY; - out[11*iAngleCount + i] = p->fDetVZ; - } - mGeometryInfo["Vectors"] = pVectors; - } - - // cone beam - else if (_pProjGeom->isOfType("cone")) { - astra::CConeProjectionGeometry3D* pConeGeom = dynamic_cast(_pProjGeom); - - mGeometryInfo["type"] = mxCreateString("cone"); - mGeometryInfo["DetectorRowCount"] = mxCreateDoubleScalar(pConeGeom->getDetectorRowCount()); - mGeometryInfo["DetectorColCount"] = mxCreateDoubleScalar(pConeGeom->getDetectorColCount()); - mGeometryInfo["DetectorSpacingX"] = mxCreateDoubleScalar(pConeGeom->getDetectorSpacingX()); - mGeometryInfo["DetectorSpacingY"] = mxCreateDoubleScalar(pConeGeom->getDetectorSpacingY()); - mGeometryInfo["DistanceOriginSource"] = mxCreateDoubleScalar(pConeGeom->getOriginSourceDistance()); - mGeometryInfo["DistanceOriginDetector"] = mxCreateDoubleScalar(pConeGeom->getOriginDetectorDistance()); - - mxArray* pAngles = mxCreateDoubleMatrix(1, pConeGeom->getProjectionCount(), mxREAL); - double* out = mxGetPr(pAngles); - for (int i = 0; i < pConeGeom->getProjectionCount(); i++) { - out[i] = pConeGeom->getProjectionAngle(i); - } - mGeometryInfo["ProjectionAngles"] = pAngles; - } - - // cone beam vector - else if (_pProjGeom->isOfType("cone_vec")) { - astra::CConeVecProjectionGeometry3D* pConeVecGeom = dynamic_cast(_pProjGeom); - - mGeometryInfo["type"] = mxCreateString("cone_vec"); - mGeometryInfo["DetectorRowCount"] = mxCreateDoubleScalar(pConeVecGeom->getDetectorRowCount()); - mGeometryInfo["DetectorColCount"] = mxCreateDoubleScalar(pConeVecGeom->getDetectorColCount()); - - mxArray* pVectors = mxCreateDoubleMatrix(pConeVecGeom->getProjectionCount(), 12, mxREAL); - double* out = mxGetPr(pVectors); - int iDetRowCount = pConeVecGeom->getDetectorRowCount(); - int iDetColCount = pConeVecGeom->getDetectorColCount(); - int iAngleCount = pConeVecGeom->getProjectionCount(); - for (int i = 0; i < pConeVecGeom->getProjectionCount(); i++) { - const SConeProjection* p = &pConeVecGeom->getProjectionVectors()[i]; - out[ 0*iAngleCount + i] = p->fSrcX; - out[ 1*iAngleCount + i] = p->fSrcY; - out[ 2*iAngleCount + i] = p->fSrcZ; - out[ 3*iAngleCount + i] = p->fDetSX + 0.5f*iDetRowCount*p->fDetUX + 0.5f*iDetColCount*p->fDetVX; - out[ 4*iAngleCount + i] = p->fDetSY + 0.5f*iDetRowCount*p->fDetUY + 0.5f*iDetColCount*p->fDetVY; - out[ 5*iAngleCount + i] = p->fDetSZ + 0.5f*iDetRowCount*p->fDetUZ + 0.5f*iDetColCount*p->fDetVZ; - out[ 6*iAngleCount + i] = p->fDetUX; - out[ 7*iAngleCount + i] = p->fDetUY; - out[ 8*iAngleCount + i] = p->fDetUZ; - out[ 9*iAngleCount + i] = p->fDetVX; - out[10*iAngleCount + i] = p->fDetVY; - out[11*iAngleCount + i] = p->fDetVZ; - } - mGeometryInfo["Vectors"] = pVectors; - } - - // build and return the MATLAB struct - return buildStruct(mGeometryInfo); -} - //----------------------------------------------------------------------------------------- // parse reconstruction geometry data astra::CVolumeGeometry2D* parseVolumeGeometryStruct(const mxArray* prhs) @@ -445,48 +269,6 @@ astra::CVolumeGeometry2D* parseVolumeGeometryStruct(const mxArray* prhs) fWindowMaxX, fWindowMaxY); } -//----------------------------------------------------------------------------------------- -// create 2D volume geometry struct -// mxArray* createVolumeGeometryStruct(astra::CVolumeGeometry2D* _pVolGeom) -// { -// std::map mGeometryInfo; - -// mGeometryInfo["GridColCount"] = mxCreateDoubleScalar(_pVolGeom->getGridColCount()); -// mGeometryInfo["GridRowCount"] = mxCreateDoubleScalar(_pVolGeom->getGridRowCount()); - -// std::map mGeometryOptions; -// mGeometryOptions["WindowMinX"] = mxCreateDoubleScalar(_pVolGeom->getWindowMinX()); -// mGeometryOptions["WindowMaxX"] = mxCreateDoubleScalar(_pVolGeom->getWindowMaxX()); -// mGeometryOptions["WindowMinY"] = mxCreateDoubleScalar(_pVolGeom->getWindowMinY()); -// mGeometryOptions["WindowMaxY"] = mxCreateDoubleScalar(_pVolGeom->getWindowMaxY()); - -// mGeometryInfo["option"] = buildStruct(mGeometryOptions); - -// return buildStruct(mGeometryInfo); -// } - -//----------------------------------------------------------------------------------------- -// create 3D volume geometry struct -// mxArray* createVolumeGeometryStruct(astra::CVolumeGeometry3D* _pVolGeom) -// { -// std::map mGeometryInfo; - -// mGeometryInfo["GridColCount"] = mxCreateDoubleScalar(_pVolGeom->getGridColCount()); -// mGeometryInfo["GridRowCount"] = mxCreateDoubleScalar(_pVolGeom->getGridRowCount()); -// mGeometryInfo["GridSliceCount"] = mxCreateDoubleScalar(_pVolGeom->getGridRowCount()); - -// std::map mGeometryOptions; -// mGeometryOptions["WindowMinX"] = mxCreateDoubleScalar(_pVolGeom->getWindowMinX()); -// mGeometryOptions["WindowMaxX"] = mxCreateDoubleScalar(_pVolGeom->getWindowMaxX()); -// mGeometryOptions["WindowMinY"] = mxCreateDoubleScalar(_pVolGeom->getWindowMinY()); -// mGeometryOptions["WindowMaxY"] = mxCreateDoubleScalar(_pVolGeom->getWindowMaxY()); -// mGeometryOptions["WindowMinZ"] = mxCreateDoubleScalar(_pVolGeom->getWindowMinZ()); -// mGeometryOptions["WindowMaxZ"] = mxCreateDoubleScalar(_pVolGeom->getWindowMaxZ()); - -// mGeometryInfo["option"] = buildStruct(mGeometryOptions); - -// return buildStruct(mGeometryInfo); -// } //----------------------------------------------------------------------------------------- string matlab2string(const mxArray* pField) @@ -640,7 +422,6 @@ XMLDocument* struct2XML(string rootname, const mxArray* pStruct) // read the struct bool ret = readStruct(rootnode, pStruct); - //doc->getRootNode()->print(); delete rootnode; if (!ret) { @@ -714,8 +495,21 @@ bool mex_is_scalar(const mxArray* pInput) return (mxIsNumeric(pInput) && mxGetM(pInput)*mxGetN(pInput) == 1); } + + + + + + + + + + + + + //----------------------------------------------------------------------------------------- -mxArray* config2struct(astra::Config* cfg) +mxArray* configToStruct(astra::Config* cfg) { return XMLNode2struct(cfg->self); } @@ -730,22 +524,67 @@ mxArray* XML2struct(astra::XMLDocument* xml) } //----------------------------------------------------------------------------------------- -mxArray* XMLNode2option(astra::XMLNode* node) +mxArray* stringToMxArray(std::string input) { + // matrix + if (input.find(';') != std::string::npos) { + + // split rows + std::vector row_strings; + std::vector col_strings; + boost::split(row_strings, input, boost::is_any_of(";")); + boost::split(col_strings, row_strings[0], boost::is_any_of(",")); + + // get dimensions + int rows = row_strings.size(); + int cols = col_strings.size(); + + // init matrix + mxArray* pMatrix = mxCreateDoubleMatrix(rows, cols, mxREAL); + double* out = mxGetPr(pMatrix); + + // loop elements + for (unsigned int row = 0; row < rows; row++) { + boost::split(col_strings, row_strings[row], boost::is_any_of(",")); + // check size + for (unsigned int col = 0; col < col_strings.size(); col++) { + out[col*rows + row] = boost::lexical_cast(col_strings[col]); + } + } + return pMatrix; + } + + // vector + if (input.find(',') != std::string::npos) { + + // split + std::vector items; + boost::split(items, input, boost::is_any_of(",")); + + // init matrix + mxArray* pVector = mxCreateDoubleMatrix(1, items.size(), mxREAL); + double* out = mxGetPr(pVector); + + // loop elements + for (unsigned int i = 0; i < items.size(); i++) { + out[i] = boost::lexical_cast(items[i]); + } + return pVector; + } + + // number char* end; - double content = ::strtod(node->getAttribute("value").c_str(), &end); + double content = ::strtod(input.c_str(), &end); bool isnumber = !*end; - - // float if (isnumber) { return mxCreateDoubleScalar(content); } + // string - else { - return mxCreateString(node->getAttribute("value").c_str()); - } + return mxCreateString(input.c_str()); } +//----------------------------------------------------------------------------------------- mxArray* XMLNode2struct(astra::XMLNode* node) { std::map mList; @@ -760,30 +599,19 @@ mxArray* XMLNode2struct(astra::XMLNode* node) for (list::iterator it = nodes.begin(); it != nodes.end(); it++) { XMLNode* subnode = (*it); - char* end; - double content = ::strtod(subnode->getContent().c_str(), &end); - bool isnumber = !*end; - // option if (subnode->getName() == "Option") { - mOptions[subnode->getAttribute("key")] = XMLNode2option(subnode); - } - // list - // else if (subnode->hasAttribute("listsize")) { - // mList[subnode->getName()] = vectorToMxArray(node->getContentNumericalArray()); - // } - // float - else if (isnumber) { - mList[subnode->getName()] = mxCreateDoubleScalar(content); + mOptions[subnode->getAttribute("key")] = stringToMxArray(subnode->getAttribute("value")); } - // string + + // regular content else { - mList[subnode->getName()] = mxCreateString(subnode->getContent().c_str()); + mList[subnode->getName()] = stringToMxArray(subnode->getContent()); } delete subnode; } - mList["options"] = buildStruct(mOptions); + if (mOptions.size() > 0) mList["options"] = buildStruct(mOptions); return buildStruct(mList); } @@ -791,6 +619,12 @@ mxArray* XMLNode2struct(astra::XMLNode* node) + + + + + +//----------------------------------------------------------------------------------------- void get3DMatrixDims(const mxArray* x, mwSize *dims) { const mwSize* mdims = mxGetDimensions(x); diff --git a/matlab/mex/mexHelpFunctions.h b/matlab/mex/mexHelpFunctions.h index f8a7d48..6c80f8c 100644 --- a/matlab/mex/mexHelpFunctions.h +++ b/matlab/mex/mexHelpFunctions.h @@ -71,17 +71,13 @@ mxArray* anyToMxArray(boost::any _any); astra::CProjectionGeometry2D* parseProjectionGeometryStruct(const mxArray*); astra::CVolumeGeometry2D* parseVolumeGeometryStruct(const mxArray*); -mxArray* createProjectionGeometryStruct(astra::CProjectionGeometry2D*); -mxArray* createProjectionGeometryStruct(astra::CProjectionGeometry3D*); - -// mxArray* createVolumeGeometryStruct(astra::CVolumeGeometry2D* _pReconGeom); -// mxArray* createVolumeGeometryStruct(astra::CVolumeGeometry3D* _pReconGeom); - astra::XMLDocument* struct2XML(string rootname, const mxArray* pStruct); -mxArray* config2struct(astra::Config* cfg); +mxArray* configToStruct(astra::Config* cfg); mxArray* XML2struct(astra::XMLDocument* xml); mxArray* XMLNode2struct(astra::XMLNode* xml); +mxArray* stringToMxArray(std::string input); + void get3DMatrixDims(const mxArray* x, mwSize *dims); diff --git a/src/ConeProjectionGeometry3D.cpp b/src/ConeProjectionGeometry3D.cpp index e6999df..50f2c8f 100644 --- a/src/ConeProjectionGeometry3D.cpp +++ b/src/ConeProjectionGeometry3D.cpp @@ -197,6 +197,24 @@ void CConeProjectionGeometry3D::toXML(XMLNode* _sNode) const _sNode->addChildNode("DistanceOriginDetector", m_fOriginDetectorDistance); _sNode->addChildNode("DistanceOriginSource", m_fOriginSourceDistance); } + +//---------------------------------------------------------------------------------------- +// Get the configuration object +Config* CConeProjectionGeometry3D::getConfiguration() const +{ + Config* cfg = new Config(); + cfg->initialize("ProjectionGeometry3D"); + cfg->self->addAttribute("type", "cone"); + cfg->self->addChildNode("DetectorSpacingX", m_fDetectorSpacingX); + cfg->self->addChildNode("DetectorSpacingY", m_fDetectorSpacingY); + cfg->self->addChildNode("DetectorRowCount", m_iDetectorRowCount); + cfg->self->addChildNode("DetectorColCount", m_iDetectorColCount); + cfg->self->addChildNode("DistanceOriginDetector", m_fOriginDetectorDistance); + cfg->self->addChildNode("DistanceOriginSource", m_fOriginSourceDistance); + cfg->self->addChildNode("ProjectionAngles", m_pfProjectionAngles, m_iProjectionAngleCount); + return cfg; +} + //---------------------------------------------------------------------------------------- CVector3D CConeProjectionGeometry3D::getProjectionDirection(int _iProjectionIndex, int _iDetectorIndex) const diff --git a/src/ConeVecProjectionGeometry3D.cpp b/src/ConeVecProjectionGeometry3D.cpp index 3c32527..4f58188 100644 --- a/src/ConeVecProjectionGeometry3D.cpp +++ b/src/ConeVecProjectionGeometry3D.cpp @@ -210,6 +210,39 @@ void CConeVecProjectionGeometry3D::toXML(XMLNode* _sNode) const // TODO: //_sNode->addChildNode("ProjectionAngles", m_pfProjectionAngles, m_iProjectionAngleCount); } +//---------------------------------------------------------------------------------------- +// Get the configuration object +Config* CConeVecProjectionGeometry3D::getConfiguration() const +{ + Config* cfg = new Config(); + cfg->initialize("ProjectionGeometry3D"); + + cfg->self->addAttribute("type", "cone"); + cfg->self->addChildNode("DetectorRowCount", m_iDetectorRowCount); + cfg->self->addChildNode("DetectorColCount", m_iDetectorColCount); + + std::string vectors = ""; + for (int i = 0; i < m_iProjectionAngleCount; ++i) { + SConeProjection& p = m_pProjectionAngles[i]; + vectors += boost::lexical_cast(p.fSrcX) + ","; + vectors += boost::lexical_cast(p.fSrcY) + ","; + vectors += boost::lexical_cast(p.fSrcZ) + ","; + vectors += boost::lexical_cast(p.fDetSX + 0.5f*m_iDetectorRowCount*p.fDetUX + 0.5f*m_iDetectorColCount*p.fDetVX) + ","; + vectors += boost::lexical_cast(p.fDetSY + 0.5f*m_iDetectorRowCount*p.fDetUY + 0.5f*m_iDetectorColCount*p.fDetVY) + ","; + vectors += boost::lexical_cast(p.fDetSZ + 0.5f*m_iDetectorRowCount*p.fDetUZ + 0.5f*m_iDetectorColCount*p.fDetVZ) + ","; + vectors += boost::lexical_cast(p.fDetUX) + ","; + vectors += boost::lexical_cast(p.fDetUY) + ","; + vectors += boost::lexical_cast(p.fDetUZ) + ","; + vectors += boost::lexical_cast(p.fDetVX) + ","; + vectors += boost::lexical_cast(p.fDetVY) + ","; + vectors += boost::lexical_cast(p.fDetVZ); + if (i < m_iProjectionAngleCount-1) vectors += ';'; + } + cfg->self->addChildNode("Vectors", vectors); + + return cfg; +} +//---------------------------------------------------------------------------------------- CVector3D CConeVecProjectionGeometry3D::getProjectionDirection(int _iProjectionIndex, int _iDetectorIndex) const { diff --git a/src/FanFlatProjectionGeometry2D.cpp b/src/FanFlatProjectionGeometry2D.cpp index bfc7fa9..d757f18 100644 --- a/src/FanFlatProjectionGeometry2D.cpp +++ b/src/FanFlatProjectionGeometry2D.cpp @@ -204,6 +204,20 @@ CVector3D CFanFlatProjectionGeometry2D::getProjectionDirection(int _iProjectionI } //---------------------------------------------------------------------------------------- +// Get the configuration object +Config* CFanFlatProjectionGeometry2D::getConfiguration() const +{ + Config* cfg = new Config(); + cfg->initialize("ProjectionGeometry2D"); + cfg->self->addAttribute("type", "fanflat"); + cfg->self->addChildNode("DetectorCount", getDetectorCount()); + cfg->self->addChildNode("DetectorWidth", getDetectorWidth()); + cfg->self->addChildNode("DistanceOriginSource", getOriginSourceDistance()); + cfg->self->addChildNode("DistanceOriginDetector", getOriginDetectorDistance()); + cfg->self->addChildNode("ProjectionAngles", m_pfProjectionAngles, m_iProjectionAngleCount); + return cfg; +} +//---------------------------------------------------------------------------------------- } // namespace astra diff --git a/src/FanFlatVecProjectionGeometry2D.cpp b/src/FanFlatVecProjectionGeometry2D.cpp index 77f9db7..9c7b596 100644 --- a/src/FanFlatVecProjectionGeometry2D.cpp +++ b/src/FanFlatVecProjectionGeometry2D.cpp @@ -194,7 +194,7 @@ bool CFanFlatVecProjectionGeometry2D::isEqual(CProjectionGeometry2D* _pGeom2) co // Is of type bool CFanFlatVecProjectionGeometry2D::isOfType(const std::string& _sType) { - return (_sType == "fanflat_vec"); + return (_sType == "fanflat_vec"); } //---------------------------------------------------------------------------------------- @@ -226,6 +226,28 @@ bool CFanFlatVecProjectionGeometry2D::_check() } +//---------------------------------------------------------------------------------------- +// Get the configuration object +Config* CFanFlatVecProjectionGeometry2D::getConfiguration() const +{ + Config* cfg = new Config(); + cfg->initialize("ProjectionGeometry2D"); + cfg->self->addAttribute("type", "fanflat_vec"); + cfg->self->addChildNode("DetectorCount", getDetectorCount()); + std::string vectors = ""; + for (int i = 0; i < m_iProjectionAngleCount; ++i) { + SFanProjection& p = m_pProjectionAngles[i]; + vectors += boost::lexical_cast(p.fSrcX) + ","; + vectors += boost::lexical_cast(p.fSrcY) + ","; + vectors += boost::lexical_cast(p.fDetSX + 0.5f * m_iDetectorCount * p.fDetUX) + ","; + vectors += boost::lexical_cast(p.fDetSY + 0.5f * m_iDetectorCount * p.fDetUY) + ","; + vectors += boost::lexical_cast(p.fDetUX) + ","; + vectors += boost::lexical_cast(p.fDetUY); + if (i < m_iProjectionAngleCount-1) vectors += ';'; + } + cfg->self->addChildNode("Vectors", vectors); + return cfg; +} //---------------------------------------------------------------------------------------- diff --git a/src/ParallelProjectionGeometry2D.cpp b/src/ParallelProjectionGeometry2D.cpp index 8f8faa4..cac8f30 100644 --- a/src/ParallelProjectionGeometry2D.cpp +++ b/src/ParallelProjectionGeometry2D.cpp @@ -27,6 +27,7 @@ $Id$ */ #include "astra/ParallelProjectionGeometry2D.h" +#include #include @@ -168,6 +169,19 @@ bool CParallelProjectionGeometry2D::isOfType(const std::string& _sType) { return (_sType == "parallel"); } + +//---------------------------------------------------------------------------------------- +// Get the configuration object +Config* CParallelProjectionGeometry2D::getConfiguration() const +{ + Config* cfg = new Config(); + cfg->initialize("ProjectionGeometry2D"); + cfg->self->addAttribute("type", "parallel"); + cfg->self->addChildNode("DetectorCount", getDetectorCount()); + cfg->self->addChildNode("DetectorWidth", getDetectorWidth()); + cfg->self->addChildNode("ProjectionAngles", m_pfProjectionAngles, m_iProjectionAngleCount); + return cfg; +} //---------------------------------------------------------------------------------------- CVector3D CParallelProjectionGeometry2D::getProjectionDirection(int _iProjectionIndex, int _iDetectorIndex /* = 0 */) diff --git a/src/ParallelProjectionGeometry3D.cpp b/src/ParallelProjectionGeometry3D.cpp index 7130d71..d47a4bb 100644 --- a/src/ParallelProjectionGeometry3D.cpp +++ b/src/ParallelProjectionGeometry3D.cpp @@ -27,6 +27,7 @@ $Id$ */ #include "astra/ParallelProjectionGeometry3D.h" +#include #include @@ -168,6 +169,22 @@ void CParallelProjectionGeometry3D::toXML(XMLNode* _sNode) const _sNode->addChildNode("ProjectionAngles", m_pfProjectionAngles, m_iProjectionAngleCount); } +//---------------------------------------------------------------------------------------- +// Get the configuration object +Config* CParallelProjectionGeometry3D::getConfiguration() const +{ + Config* cfg = new Config(); + cfg->initialize("ProjectionGeometry3D"); + cfg->self->addAttribute("type", "parallel3d"); + cfg->self->addChildNode("DetectorRowCount", m_iDetectorRowCount); + cfg->self->addChildNode("DetectorColCount", m_iDetectorColCount); + cfg->self->addChildNode("DetectorSpacingX", m_fDetectorSpacingX); + cfg->self->addChildNode("DetectorSpacingY", m_fDetectorSpacingY); + cfg->self->addChildNode("ProjectionAngles", m_pfProjectionAngles, m_iProjectionAngleCount); + return cfg; +} +//---------------------------------------------------------------------------------------- + CVector3D CParallelProjectionGeometry3D::getProjectionDirection(int _iProjectionIndex, int _iDetectorIndex) const { float fTheta = m_pfProjectionAngles[_iProjectionIndex]; diff --git a/src/ParallelVecProjectionGeometry3D.cpp b/src/ParallelVecProjectionGeometry3D.cpp index 17f00a4..0f39c4a 100644 --- a/src/ParallelVecProjectionGeometry3D.cpp +++ b/src/ParallelVecProjectionGeometry3D.cpp @@ -211,6 +211,40 @@ void CParallelVecProjectionGeometry3D::toXML(XMLNode* _sNode) const //_sNode->addChildNode("ProjectionAngles", m_pfProjectionAngles, m_iProjectionAngleCount); } +//---------------------------------------------------------------------------------------- +// Get the configuration object +Config* CParallelVecProjectionGeometry3D::getConfiguration() const +{ + Config* cfg = new Config(); + cfg->initialize("ProjectionGeometry3D"); + + cfg->self->addAttribute("type", "parallel3d"); + cfg->self->addChildNode("DetectorRowCount", m_iDetectorRowCount); + cfg->self->addChildNode("DetectorColCount", m_iDetectorColCount); + + std::string vectors = ""; + for (int i = 0; i < m_iProjectionAngleCount; ++i) { + SPar3DProjection& p = m_pProjectionAngles[i]; + vectors += boost::lexical_cast(p.fRayX) + ","; + vectors += boost::lexical_cast(p.fRayY) + ","; + vectors += boost::lexical_cast(p.fRayZ) + ","; + vectors += boost::lexical_cast(p.fDetSX + 0.5f*m_iDetectorRowCount*p.fDetUX + 0.5f*m_iDetectorColCount*p.fDetVX) + ","; + vectors += boost::lexical_cast(p.fDetSY + 0.5f*m_iDetectorRowCount*p.fDetUY + 0.5f*m_iDetectorColCount*p.fDetVY) + ","; + vectors += boost::lexical_cast(p.fDetSZ + 0.5f*m_iDetectorRowCount*p.fDetUZ + 0.5f*m_iDetectorColCount*p.fDetVZ) + ","; + vectors += boost::lexical_cast(p.fDetUX) + ","; + vectors += boost::lexical_cast(p.fDetUY) + ","; + vectors += boost::lexical_cast(p.fDetUZ) + ","; + vectors += boost::lexical_cast(p.fDetVX) + ","; + vectors += boost::lexical_cast(p.fDetVY) + ","; + vectors += boost::lexical_cast(p.fDetVZ); + if (i < m_iProjectionAngleCount-1) vectors += ';'; + } + cfg->self->addChildNode("Vectors", vectors); + + return cfg; +} +//---------------------------------------------------------------------------------------- + CVector3D CParallelVecProjectionGeometry3D::getProjectionDirection(int _iProjectionIndex, int _iDetectorIndex) const { const SPar3DProjection& p = m_pProjectionAngles[_iProjectionIndex]; diff --git a/src/SparseMatrixProjectionGeometry2D.cpp b/src/SparseMatrixProjectionGeometry2D.cpp index 7f14d9d..86357d2 100644 --- a/src/SparseMatrixProjectionGeometry2D.cpp +++ b/src/SparseMatrixProjectionGeometry2D.cpp @@ -189,7 +189,20 @@ bool CSparseMatrixProjectionGeometry2D::isOfType(const std::string& _sType) return (_sType == "sparse_matrix"); } //---------------------------------------------------------------------------------------- +// Get the configuration object +Config* CSparseMatrixProjectionGeometry2D::getConfiguration() const +{ + Config* cfg = new Config(); + cfg->initialize("ProjectionGeometry2D"); + cfg->self->addAttribute("type", "sparse matrix"); + cfg->self->addChildNode("DetectorCount", getDetectorCount()); + cfg->self->addChildNode("DetectorWidth", getDetectorWidth()); + cfg->self->addChildNode("ProjectionAngles", m_pfProjectionAngles, m_iProjectionAngleCount); + cfg->self->addChildNode("MatrixID", CMatrixManager::getSingleton().getIndex(m_pMatrix)); + return cfg; +} +//---------------------------------------------------------------------------------------- CVector3D CSparseMatrixProjectionGeometry2D::getProjectionDirection(int _iProjectionIndex, int _iDetectorIndex) { CVector3D vOutput(0.0f, 0.0f, 0.0f); diff --git a/src/XMLNode.cpp b/src/XMLNode.cpp index a5b6796..4b2bdf4 100644 --- a/src/XMLNode.cpp +++ b/src/XMLNode.cpp @@ -448,13 +448,11 @@ void XMLNode::setContent(float32 _fValue) // Set content - LIST void XMLNode::setContent(float32* pfList, int _iSize) { - addAttribute("listsize", _iSize); - for (int i = 0; i < _iSize; i++) { - XMLNode* item = addChildNode("ListItem"); - item->addAttribute("index", i); - item->addAttribute("value",pfList[i]); - delete item; + std::string str = (_iSize > 0) ? boost::lexical_cast(pfList[0]) : ""; + for (int i = 1; i < _iSize; i++) { + str += "," + boost::lexical_cast(pfList[i]); } + setContent(str); } //----------------------------------------------------------------------------- -- cgit v1.2.3