diff --git a/testing/examples/RTBioModelExampleTest.cpp b/testing/examples/RTBioModelExampleTest.cpp
index 0bf268a..23c9d6b 100644
--- a/testing/examples/RTBioModelExampleTest.cpp
+++ b/testing/examples/RTBioModelExampleTest.cpp
@@ -1,415 +1,415 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See rttbCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html [^]
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notices for more information.
//
//------------------------------------------------------------------------
/*!
// @file
// @version $Revision$ (last changed revision)
// @date $Date$ (last change date)
// @author $Author$ (last changed by)
*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include <boost/shared_ptr.hpp>
#include "litCheckMacros.h"
#include "rttbBioModel.h"
-#include "rttbDVHTxtFileReader.h"
#include "rttbDVH.h"
#include "rttbTCPLQModel.h"
#include "rttbNTCPLKBModel.h"
#include "rttbNTCPRSModel.h"
#include "rttbBioModelScatterPlots.h"
#include "rttbBioModelCurve.h"
#include "rttbDvhBasedModels.h"
#include "rttbDoseIteratorInterface.h"
+#include "rttbDVHXMLFileReader.h"
namespace rttb
{
namespace testing
{
/*! @brief RTBioModelTest.
TCP calculated using a DVH PTV and LQ Model.
NTCP tested using 3 Normal Tissue DVHs and LKB/RS Model.
Test if calculation in new architecture returns similar results to the
original implementation.
WARNING: The values for comparison need to be adjusted if the input files are changed!
*/
int RTBioModelExampleTest(int argc, char* argv[])
{
PREPARE_DEFAULT_TEST_REPORTING;
typedef rttb::models::CurveDataType CurveDataType;
typedef std::multimap<double , std::pair<double, double> > ScatterPlotType;
typedef core::DVH::DVHPointer DVHPointer;
//increased accuracy requires double values in the calculation (rttbBaseType.h)
double toleranceEUD = 1e-5;
double tolerance = 1e-7;
//ARGUMENTS: 1: ptv dvh file name
// 2: normal tissue 1 dvh file name
// 3: normal tissue 2 dvh file name
// 4: normal tissue 3 dvh file name
//...........5: Virtuos MPM_LR_ah dvh lung file name
//...........6: Virtuos MPM_LR_ah dvh target file name
std::string DVH_FILENAME_PTV;
std::string DVH_FILENAME_NT1;
std::string DVH_FILENAME_NT2;
std::string DVH_FILENAME_NT3;
std::string DVH_FILENAME_TV_TEST;
std::string DVH_Virtuos_Target;
std::string DVH_Virtuos_Lung;
if (argc > 1)
{
DVH_FILENAME_PTV = argv[1];
}
if (argc > 2)
{
DVH_FILENAME_NT1 = argv[2];
}
if (argc > 3)
{
DVH_FILENAME_NT2 = argv[3];
}
if (argc > 4)
{
DVH_FILENAME_NT3 = argv[4];
}
if (argc > 5)
{
DVH_FILENAME_TV_TEST = argv[5];
}
if (argc > 6)
{
DVH_Virtuos_Lung = argv[6];
}
if (argc > 7)
{
DVH_Virtuos_Target = argv[7];
}
//DVH PTV
- rttb::io::other::DVHTxtFileReader dvhReader = rttb::io::other::DVHTxtFileReader(DVH_FILENAME_PTV);
+ rttb::io::other::DVHXMLFileReader dvhReader = rttb::io::other::DVHXMLFileReader(DVH_FILENAME_PTV);
DVHPointer dvhPtr = dvhReader.generateDVH();
CHECK_CLOSE(6.04759613161786830000e+001, models::getEUD(dvhPtr, 10), toleranceEUD);
- rttb::io::other::DVHTxtFileReader dvhReader_test_tv = rttb::io::other::DVHTxtFileReader(
+ rttb::io::other::DVHXMLFileReader dvhReader_test_tv = rttb::io::other::DVHXMLFileReader(
DVH_FILENAME_TV_TEST);
DVHPointer dvh_test_tv = dvhReader_test_tv.generateDVH();
//test TCP LQ Model
models::BioModelParamType alpha = 0.35;
models::BioModelParamType beta = 0.023333333333333;
models::BioModelParamType roh = 10000000;
int numFractions = 2;
DoseTypeGy normalizationDose = 68;
rttb::models::TCPLQModel tcplq = rttb::models::TCPLQModel(dvhPtr, alpha, beta, roh, numFractions);
CHECK_EQUAL(alpha, tcplq.getAlphaMean());
CHECK_EQUAL(alpha / beta, tcplq.getAlphaBeta());
CHECK_EQUAL(roh, tcplq.getRho());
CHECK_NO_THROW(tcplq.init());
if (tcplq.init())
{
CHECK_CLOSE(1.00497232941856940000e-127, tcplq.getValue(), tolerance);
}
CurveDataType curve = models::getCurveDoseVSBioModel(tcplq, normalizationDose);
CurveDataType::iterator it;
for (it = curve.begin(); it != curve.end(); ++it)
{
if ((*it).first < 72)
{
CHECK_EQUAL(0, (*it).second);
}
else if ((*it).first > 150)
{
CHECK((*it).second > 0.9);
}
}
models::BioModelParamType alphaBeta = 10;
tcplq.setParameters(alpha, alphaBeta, roh, 0.08);
CHECK_EQUAL(alpha, tcplq.getAlphaMean());
CHECK_EQUAL(alphaBeta, tcplq.getAlphaBeta());
CHECK_EQUAL(roh, tcplq.getRho());
if (tcplq.init())
{
CHECK_CLOSE(1.84e-005, tcplq.getValue(), tolerance);
}
normalizationDose = 40;
curve = models::getCurveDoseVSBioModel(tcplq, normalizationDose);
alpha = 1;
alphaBeta = 14.5;
tcplq.setAlpha(alpha);
tcplq.setAlphaBeta(alphaBeta);
tcplq.setRho(roh);
CHECK_EQUAL(alpha, tcplq.getAlphaMean());
CHECK_EQUAL(alphaBeta, tcplq.getAlphaBeta());
CHECK_EQUAL(roh, tcplq.getRho());
if (tcplq.init())
{
CHECK_CLOSE(0.954885, tcplq.getValue(), toleranceEUD);
}
alpha = 0.9;
alphaBeta = 1;
tcplq.setAlpha(alpha);
tcplq.setAlphaBeta(alphaBeta);
tcplq.setRho(roh);
CHECK_EQUAL(alpha, tcplq.getAlphaMean());
CHECK_EQUAL(alphaBeta, tcplq.getAlphaBeta());
CHECK_EQUAL(roh, tcplq.getRho());
if (tcplq.init())
{
CHECK_EQUAL(1, tcplq.getValue());
}
//TCP LQ Test
alpha = 0.3;
beta = 0.03;
roh = 10000000;
numFractions = 20;
rttb::models::TCPLQModel tcplq_test = rttb::models::TCPLQModel(dvh_test_tv, alpha, beta, roh,
numFractions);
CHECK_EQUAL(alpha, tcplq_test.getAlphaMean());
CHECK_EQUAL(alpha / beta, tcplq_test.getAlphaBeta());
CHECK_EQUAL(roh, tcplq_test.getRho());
CHECK_NO_THROW(tcplq_test.init());
if (tcplq_test.init())
{
CHECK_CLOSE(9.79050278878883180000e-001, tcplq_test.getValue(), tolerance);
}
normalizationDose = 60;
curve = models::getCurveDoseVSBioModel(tcplq_test, normalizationDose);
//DVH HT 1
- rttb::io::other::DVHTxtFileReader dvhReader2 = rttb::io::other::DVHTxtFileReader(DVH_FILENAME_NT1);
+ rttb::io::other::DVHXMLFileReader dvhReader2 = rttb::io::other::DVHXMLFileReader(DVH_FILENAME_NT1);
DVHPointer dvhPtr2 = dvhReader2.generateDVH();
CHECK_CLOSE(1.07920836034015810000e+001, models::getEUD(dvhPtr2, 10), toleranceEUD);
//test RTNTCPLKBModel
rttb::models::NTCPLKBModel lkb = rttb::models::NTCPLKBModel();
models::BioModelParamType aVal = 10;
models::BioModelParamType mVal = 0.16;
models::BioModelParamType d50Val = 55;
CHECK_EQUAL(0, lkb.getA());
CHECK_EQUAL(0, lkb.getM());
CHECK_EQUAL(0, lkb.getD50());
lkb.setDVH(dvhPtr2);
CHECK_EQUAL(dvhPtr2, lkb.getDVH());
lkb.setA(aVal);
CHECK_EQUAL(aVal, lkb.getA());
lkb.setM(mVal);
CHECK_EQUAL(mVal, lkb.getM());
lkb.setD50(d50Val);
CHECK_EQUAL(d50Val, lkb.getD50());
CHECK_NO_THROW(lkb.init());
if (lkb.init())
{
CHECK_CLOSE(2.53523522831366570000e-007, lkb.getValue(), tolerance);
}
//test RTNTCPRSModel
rttb::models::NTCPRSModel rs = rttb::models::NTCPRSModel();
models::BioModelParamType gammaVal = 1.7;
models::BioModelParamType sVal = 1;
CHECK_EQUAL(0, rs.getGamma());
CHECK_EQUAL(0, rs.getS());
CHECK_EQUAL(0, rs.getD50());
rs.setDVH(dvhPtr2);
CHECK_EQUAL(dvhPtr2, rs.getDVH());
rs.setD50(d50Val);
CHECK_EQUAL(d50Val, rs.getD50());
rs.setGamma(gammaVal);
CHECK_EQUAL(gammaVal, rs.getGamma());
rs.setS(sVal);
CHECK_EQUAL(sVal, rs.getS());
CHECK_NO_THROW(rs.init());
if (rs.init())
{
CHECK_CLOSE(3.70385888626145740000e-009, rs.getValue(), tolerance);
}
//DVH HT 2
- rttb::io::other::DVHTxtFileReader dvhReader3 = rttb::io::other::DVHTxtFileReader(DVH_FILENAME_NT2);
+ rttb::io::other::DVHXMLFileReader dvhReader3 = rttb::io::other::DVHXMLFileReader(DVH_FILENAME_NT2);
DVHPointer dvhPtr3 = dvhReader3.generateDVH();
CHECK_CLOSE(1.26287047025885110000e+001, models::getEUD(dvhPtr3, 10), toleranceEUD);
//test RTNTCPLKBModel
aVal = 10;
mVal = 0.16;
d50Val = 55;
lkb.setDVH(dvhPtr3);
CHECK_EQUAL(dvhPtr3, lkb.getDVH());
lkb.setA(aVal);
CHECK_EQUAL(aVal, lkb.getA());
lkb.setM(mVal);
CHECK_EQUAL(mVal, lkb.getM());
lkb.setD50(d50Val);
CHECK_EQUAL(d50Val, lkb.getD50());
if (lkb.init())
{
CHECK_CLOSE(7.36294657754956700000e-007, lkb.getValue(), tolerance);
}
//test RTNTCPRSModel
rs = rttb::models::NTCPRSModel();
gammaVal = 1.7;
sVal = 1;
CHECK_EQUAL(0, rs.getGamma());
CHECK_EQUAL(0, rs.getS());
CHECK_EQUAL(0, rs.getD50());
rs.setDVH(dvhPtr3);
CHECK_EQUAL(dvhPtr3, rs.getDVH());
rs.setD50(d50Val);
CHECK_EQUAL(d50Val, rs.getD50());
rs.setGamma(gammaVal);
CHECK_EQUAL(gammaVal, rs.getGamma());
rs.setS(sVal);
CHECK_EQUAL(sVal, rs.getS());
if (rs.init())
{
CHECK_CLOSE(1.76778795490939440000e-007, rs.getValue(), tolerance);
}
//DVH HT 3
- rttb::io::other::DVHTxtFileReader dvhReader4 = rttb::io::other::DVHTxtFileReader(DVH_FILENAME_NT3);
+ rttb::io::other::DVHXMLFileReader dvhReader4 = rttb::io::other::DVHXMLFileReader(DVH_FILENAME_NT3);
DVHPointer dvhPtr4 = dvhReader4.generateDVH();
CHECK_CLOSE(2.18212982041056310000e+001, models::getEUD(dvhPtr4, 10), toleranceEUD);
//test RTNTCPLKBModel
aVal = 10;
mVal = 0.16;
d50Val = 55;
lkb.setDVH(dvhPtr4);
CHECK_EQUAL(dvhPtr4, lkb.getDVH());
lkb.setA(aVal);
CHECK_EQUAL(aVal, lkb.getA());
lkb.setM(mVal);
CHECK_EQUAL(mVal, lkb.getM());
lkb.setD50(d50Val);
CHECK_EQUAL(d50Val, lkb.getD50());
if (lkb.init())
{
CHECK_CLOSE(8.15234192641929420000e-005, lkb.getValue(), tolerance);
}
//test RTNTCPRSModel
rs = rttb::models::NTCPRSModel();
gammaVal = 1.7;
sVal = 1;
CHECK_EQUAL(0, rs.getGamma());
CHECK_EQUAL(0, rs.getS());
CHECK_EQUAL(0, rs.getD50());
rs.setDVH(dvhPtr4);
CHECK_EQUAL(dvhPtr4, rs.getDVH());
rs.setD50(d50Val);
CHECK_EQUAL(d50Val, rs.getD50());
rs.setGamma(gammaVal);
CHECK_EQUAL(gammaVal, rs.getGamma());
rs.setS(sVal);
CHECK_EQUAL(sVal, rs.getS());
if (rs.init())
{
CHECK_CLOSE(2.02607985020919480000e-004, rs.getValue(), tolerance);
}
//test using Virtuos Pleuramesotheliom MPM_LR_ah
//DVH PTV
- rttb::io::other::DVHTxtFileReader dR_Target = rttb::io::other::DVHTxtFileReader(DVH_Virtuos_Target);
+ rttb::io::other::DVHXMLFileReader dR_Target = rttb::io::other::DVHXMLFileReader(DVH_Virtuos_Target);
DVHPointer dvhPtrTarget = dR_Target.generateDVH();
- rttb::io::other::DVHTxtFileReader dR_Lung = rttb::io::other::DVHTxtFileReader(DVH_Virtuos_Lung);
+ rttb::io::other::DVHXMLFileReader dR_Lung = rttb::io::other::DVHXMLFileReader(DVH_Virtuos_Lung);
DVHPointer dvhPtrLung = dR_Lung.generateDVH();
//test TCP LQ Model
models::BioModelParamType alphaMean = 0.34;
models::BioModelParamType alphaVarianz = 0.02;
models::BioModelParamType alpha_beta = 28;
models::BioModelParamType rho = 1200;
int numFractionsVirtuos = 27;
rttb::models::TCPLQModel tcplqVirtuos = rttb::models::TCPLQModel(dvhPtrTarget, rho,
numFractionsVirtuos, alpha_beta,
alphaMean, alphaVarianz);
if (tcplqVirtuos.init())
{
CHECK_CLOSE(0.8894, tcplqVirtuos.getValue(), 1e-4);
}
models::BioModelParamType d50Mean = 20;
models::BioModelParamType m = 0.36;
models::BioModelParamType a = 1.06;
rttb::models::NTCPLKBModel lkbVirtuos = rttb::models::NTCPLKBModel(dvhPtrLung, d50Mean, m, a);
if (lkbVirtuos.init())
{
CHECK_CLOSE(0.0397, lkbVirtuos.getValue(), 1e-4);
}
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
diff --git a/testing/examples/RTBioModelScatterPlotExampleTest.cpp b/testing/examples/RTBioModelScatterPlotExampleTest.cpp
index aa96469..1fce076 100644
--- a/testing/examples/RTBioModelScatterPlotExampleTest.cpp
+++ b/testing/examples/RTBioModelScatterPlotExampleTest.cpp
@@ -1,479 +1,479 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See rttbCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html [^]
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notices for more information.
//
//------------------------------------------------------------------------
/*!
// @file
// @version $Revision$ (last changed revision)
// @date $Date$ (last change date)
// @author $Author$ (last changed by)
*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include <boost/shared_ptr.hpp>
#include "litCheckMacros.h"
#include "rttbBioModel.h"
-#include "rttbDVHTxtFileReader.h"
#include "rttbDVH.h"
#include "rttbTCPLQModel.h"
#include "rttbNTCPLKBModel.h"
#include "rttbNTCPRSModel.h"
#include "rttbBioModelScatterPlots.h"
#include "rttbBioModelCurve.h"
#include "rttbDvhBasedModels.h"
#include "../models/rttbScatterTester.h"
#include "rttbInvalidParameterException.h"
+#include "rttbDVHXmlFileReader.h"
namespace rttb
{
namespace testing
{
/*! @brief RTBioModelScatterPlotExampleTest.
calculating Curves and Scatterplots for TCP and NTCP models.
The values on curve and scatterplot need to be similar for similar dose values.
The range of difference is given by the variance used to generate the scatter.
WARNING: The values for comparison need to be adjusted if the input files are changed!
*/
int RTBioModelScatterPlotExampleTest(int argc, char* argv[])
{
PREPARE_DEFAULT_TEST_REPORTING;
typedef rttb::models::CurveDataType CurveDataType;
typedef rttb::models::ScatterPlotType ScatterPlotType;
typedef core::DVH::DVHPointer DVHPointer;
//increased accuracy requires double values in the calculation (rttbBaseType.h)
double toleranceEUD = 1e-5;
//ARGUMENTS: 1: ptv dvh file name
// 2: normal tissue 1 dvh file name
// 3: TV dvh file name
std::string DVH_FILENAME_PTV;
std::string DVH_FILENAME_NT1;
std::string DVH_FILENAME_TV_TEST;
if (argc > 1)
{
DVH_FILENAME_PTV = argv[1];
}
if (argc > 2)
{
DVH_FILENAME_NT1 = argv[2];
}
if (argc > 3)
{
DVH_FILENAME_TV_TEST = argv[3];
}
//DVH PTV
- rttb::io::other::DVHTxtFileReader dvhReader = rttb::io::other::DVHTxtFileReader(DVH_FILENAME_PTV);
+ rttb::io::other::DVHXMLFileReader dvhReader = rttb::io::other::DVHXMLFileReader(DVH_FILENAME_PTV);
DVHPointer dvhPtr = dvhReader.generateDVH();
- rttb::io::other::DVHTxtFileReader dvhReader_test_tv = rttb::io::other::DVHTxtFileReader(
+ rttb::io::other::DVHXMLFileReader dvhReader_test_tv = rttb::io::other::DVHXMLFileReader(
DVH_FILENAME_TV_TEST);
DVHPointer dvh_test_tv = dvhReader_test_tv.generateDVH();
//test TCP LQ Model
models::BioModelParamType alpha = 0.35;
models::BioModelParamType beta = 0.023333333333333;
models::BioModelParamType roh = 10000000;
int numFractions = 2;
DoseTypeGy normalizationDose = 68;
rttb::models::TCPLQModel tcplq = rttb::models::TCPLQModel(dvhPtr, alpha, beta, roh, numFractions);
CHECK_NO_THROW(tcplq.init());
CurveDataType curve = models::getCurveDoseVSBioModel(tcplq, normalizationDose);
CHECK_NO_THROW(models::getScatterPlotVary1Parameter(tcplq, 0, alpha, 0, normalizationDose, 100));
ScatterPlotType tcpScatter = models::getScatterPlotVary1Parameter(tcplq, 0, alpha, 0,
normalizationDose, 100);
CHECK_EQUAL(100, tcpScatter.size());
ScatterTester scatterCompare(curve, tcpScatter);
CHECK_TESTER(scatterCompare);
//test also with other parameter
tcpScatter = models::getScatterPlotVary1Parameter(tcplq, 3, roh, 0, normalizationDose, 100);
scatterCompare.setCompareScatter(tcpScatter);
CHECK_TESTER(scatterCompare);
std::vector<int> paramIdVec;
models::BioModel::ParamVectorType meanVec;
models::BioModel::ParamVectorType meanVecTest;
meanVecTest.push_back(alpha);
models::BioModel::ParamVectorType varianceVec;
//"alphaMean":0,"alphaVariance":1,"alpha_beta":2, "rho":3
paramIdVec.push_back(0);
meanVec.push_back(tcplq.getAlphaMean());
varianceVec.push_back(0);
//setting parameter 1 will change the resulting scatter plot dramatically - is it meant to?
//this is unexpected since the value was taken from the original calculation
//paramIdVec.push_back(1); meanVec.push_back(tcplq.getAlphaVariance()); varianceVec.push_back(0);
paramIdVec.push_back(2);
meanVec.push_back(tcplq.getAlphaBeta());
varianceVec.push_back(0);
paramIdVec.push_back(3);
meanVec.push_back(tcplq.getRho());
varianceVec.push_back(0);
CHECK_THROW_EXPLICIT(models::getScatterPlotVaryParameters(tcplq, paramIdVec, meanVecTest,
varianceVec, normalizationDose, 50), core::InvalidParameterException);
ScatterPlotType scatterVary = models::getScatterPlotVaryParameters(tcplq, paramIdVec, meanVec,
varianceVec, normalizationDose, 50);
CHECK_EQUAL(50, scatterVary.size());
scatterCompare.setCompareScatter(scatterVary);
CHECK_TESTER(scatterCompare);
models::BioModelParamType variance = 0.00015;
CHECK_NO_THROW(models::getScatterPlotVary1Parameter(tcplq, 0, alpha, variance, normalizationDose,
100));
tcpScatter = models::getScatterPlotVary1Parameter(tcplq, 0, alpha, variance, normalizationDose,
100);
scatterCompare.setVariance(variance);
scatterCompare.setCompareScatter(tcpScatter);
//allow 5% of the points to deviate more
scatterCompare.setAllowExceptions(true);
CHECK_TESTER(scatterCompare);
//test also with other parameter
tcpScatter = models::getScatterPlotVary1Parameter(tcplq, 3, roh, variance, normalizationDose, 100);
scatterCompare.setCompareScatter(tcpScatter);
//allow 5% of the points to deviate more
scatterCompare.setAllowExceptions(true);
CHECK_TESTER(scatterCompare);
paramIdVec.clear();
meanVec.clear();
varianceVec.clear();
paramIdVec.push_back(0);
meanVec.push_back(tcplq.getAlphaMean());
varianceVec.push_back(variance);
//paramIdVec.push_back(1); meanVec.push_back(tcplq.getAlphaVariance()); varianceVec.push_back(variance);
paramIdVec.push_back(2);
meanVec.push_back(tcplq.getAlphaBeta());
varianceVec.push_back(variance);
paramIdVec.push_back(3);
meanVec.push_back(tcplq.getRho());
varianceVec.push_back(variance);
scatterVary = models::getScatterPlotVaryParameters(tcplq, paramIdVec, meanVec, varianceVec,
normalizationDose, 50);
scatterCompare.setCompareScatter(scatterVary);
//allow 5% of the points to deviate more
scatterCompare.setAllowExceptions(true);
CHECK_TESTER(scatterCompare);
models::BioModelParamType alphaBeta = 10;
tcplq.setParameters(alpha, alphaBeta, roh, 0.08);
tcplq.init();
normalizationDose = 40;
curve = models::getCurveDoseVSBioModel(tcplq, normalizationDose);
CHECK_NO_THROW(models::getScatterPlotVary1Parameter(tcplq, 0, alpha, 0, normalizationDose, 100));
tcpScatter = models::getScatterPlotVary1Parameter(tcplq, 0, alpha, 0, normalizationDose, 100);
scatterCompare.setReferenceCurve(curve);
scatterCompare.setVariance(0);
//do not allow larger deviations
scatterCompare.setAllowExceptions(false);
scatterCompare.setCompareScatter(tcpScatter);
CHECK_TESTER(scatterCompare);
variance = 0.25;
CHECK_NO_THROW(models::getScatterPlotVary1Parameter(tcplq, 0, alpha, variance, normalizationDose,
100));
tcpScatter = models::getScatterPlotVary1Parameter(tcplq, 0, alpha, variance, normalizationDose,
100);
scatterCompare.setCompareScatter(tcpScatter);
scatterCompare.setVariance(variance);
//allow 5% of the points to deviate more
scatterCompare.setAllowExceptions(true);
CHECK_TESTER(scatterCompare);
/*TCP LQ Test*/
alpha = 0.3;
beta = 0.03;
roh = 10000000;
numFractions = 20;
rttb::models::TCPLQModel tcplq_test = rttb::models::TCPLQModel(dvh_test_tv, alpha, beta, roh,
numFractions);
CHECK_NO_THROW(tcplq_test.init());
normalizationDose = 60;
curve = models::getCurveDoseVSBioModel(tcplq_test, normalizationDose);
CHECK_NO_THROW(models::getScatterPlotVary1Parameter(tcplq_test, 0, alpha, 0, normalizationDose,
100));
tcpScatter = models::getScatterPlotVary1Parameter(tcplq_test, 0, alpha, 0, normalizationDose, 100);
scatterCompare.setReferenceCurve(curve);
scatterCompare.setVariance(0);
scatterCompare.setCompareScatter(tcpScatter);
CHECK_TESTER(scatterCompare);
//test also with other parameter
tcpScatter = models::getScatterPlotVary1Parameter(tcplq_test, 3, roh, 0, normalizationDose, 100);
scatterCompare.setCompareScatter(tcpScatter);
CHECK_TESTER(scatterCompare);
paramIdVec.clear();
meanVec.clear();
varianceVec.clear();
paramIdVec.push_back(0);
meanVec.push_back(tcplq_test.getAlphaMean());
varianceVec.push_back(0);
//paramIdVec.push_back(1); meanVec.push_back(tcplq_test.getAlphaVariance()); varianceVec.push_back(0);
paramIdVec.push_back(2);
meanVec.push_back(tcplq_test.getAlphaBeta());
varianceVec.push_back(0);
paramIdVec.push_back(3);
meanVec.push_back(tcplq_test.getRho());
varianceVec.push_back(0);
scatterVary = models::getScatterPlotVaryParameters(tcplq_test, paramIdVec, meanVec, varianceVec,
normalizationDose, 50);
scatterCompare.setCompareScatter(scatterVary);
CHECK_TESTER(scatterCompare);
variance = 0.00025;
CHECK_NO_THROW(models::getScatterPlotVary1Parameter(tcplq_test, 0, alpha, variance,
normalizationDose, 100));
tcpScatter = models::getScatterPlotVary1Parameter(tcplq_test, 0, alpha, variance, normalizationDose,
100);
scatterCompare.setCompareScatter(tcpScatter);
scatterCompare.setVariance(variance);
CHECK_TESTER(scatterCompare);
//test also with other parameter
tcpScatter = models::getScatterPlotVary1Parameter(tcplq_test, 3, roh, variance, normalizationDose,
100);
scatterCompare.setCompareScatter(tcpScatter);
scatterCompare.setAllowExceptions(true);
CHECK_TESTER(scatterCompare);
scatterCompare.setAllowExceptions(false);
paramIdVec.clear();
meanVec.clear();
varianceVec.clear();
paramIdVec.push_back(0);
meanVec.push_back(tcplq_test.getAlphaMean());
varianceVec.push_back(variance);
//paramIdVec.push_back(1); meanVec.push_back(tcplq_test.getAlphaVariance()); varianceVec.push_back(variance);
paramIdVec.push_back(2);
meanVec.push_back(tcplq_test.getAlphaBeta());
varianceVec.push_back(variance);
paramIdVec.push_back(3);
meanVec.push_back(tcplq_test.getRho());
varianceVec.push_back(variance);
scatterVary = models::getScatterPlotVaryParameters(tcplq_test, paramIdVec, meanVec, varianceVec,
normalizationDose, 50);
scatterCompare.setCompareScatter(scatterVary);
//allow 5% of the points to deviate more
scatterCompare.setAllowExceptions(true);
CHECK_TESTER(scatterCompare);
//DVH HT 1
- rttb::io::other::DVHTxtFileReader dvhReader2 = rttb::io::other::DVHTxtFileReader(DVH_FILENAME_NT1);
+ rttb::io::other::DVHXMLFileReader dvhReader2 = rttb::io::other::DVHXMLFileReader(DVH_FILENAME_NT1);
DVHPointer dvhPtr2 = dvhReader2.generateDVH();
CHECK_CLOSE(1.07920836034015810000e+001, models::getEUD(dvhPtr2, 10), toleranceEUD);
//test RTNTCPLKBModel
rttb::models::NTCPLKBModel lkb = rttb::models::NTCPLKBModel();
models::BioModelParamType aVal = 10;
models::BioModelParamType mVal = 0.16;
models::BioModelParamType d50Val = 55;
lkb.setDVH(dvhPtr2);
lkb.setA(aVal);
lkb.setM(mVal);
lkb.setD50(d50Val);
CHECK_NO_THROW(lkb.init());
normalizationDose = 60;
curve = models::getCurveDoseVSBioModel(lkb, normalizationDose);
CHECK_NO_THROW(models::getScatterPlotVary1Parameter(lkb, 2, aVal, 0, normalizationDose, 100));
ScatterPlotType scatter = models::getScatterPlotVary1Parameter(lkb, 2, aVal, 0, normalizationDose,
100);
scatterCompare.setReferenceCurve(curve);
scatterCompare.setVariance(0);
scatterCompare.setCompareScatter(scatter);
CHECK_TESTER(scatterCompare);
//"d50":0,"m":1,"a":2
//test also with other parameter
scatter = models::getScatterPlotVary1Parameter(lkb, 0, d50Val, 0, normalizationDose, 100);
scatterCompare.setCompareScatter(scatter);
CHECK_TESTER(scatterCompare);
paramIdVec.clear();
meanVec.clear();
varianceVec.clear();
paramIdVec.push_back(0);
meanVec.push_back(lkb.getD50());
varianceVec.push_back(0);
paramIdVec.push_back(1);
meanVec.push_back(lkb.getM());
varianceVec.push_back(0);
paramIdVec.push_back(2);
meanVec.push_back(lkb.getA());
varianceVec.push_back(0);
scatterVary = models::getScatterPlotVaryParameters(lkb, paramIdVec, meanVec, varianceVec,
normalizationDose, 50);
scatterCompare.setCompareScatter(scatterVary);
CHECK_TESTER(scatterCompare);
variance = 0.00025;
CHECK_NO_THROW(models::getScatterPlotVary1Parameter(lkb, 2, aVal, variance, normalizationDose,
100));
scatter = models::getScatterPlotVary1Parameter(lkb, 2, aVal, variance, normalizationDose, 100);
scatterCompare.setCompareScatter(scatter);
scatterCompare.setVariance(variance);
CHECK_TESTER(scatterCompare);
//test also with other parameter
scatter = models::getScatterPlotVary1Parameter(lkb, 0, d50Val, variance, normalizationDose, 100);
scatterCompare.setCompareScatter(scatter);
CHECK_TESTER(scatterCompare);
paramIdVec.clear();
meanVec.clear();
varianceVec.clear();
paramIdVec.push_back(0);
meanVec.push_back(lkb.getD50());
varianceVec.push_back(variance);
paramIdVec.push_back(1);
meanVec.push_back(lkb.getM());
varianceVec.push_back(variance);
paramIdVec.push_back(2);
meanVec.push_back(lkb.getA());
varianceVec.push_back(variance);
scatterVary = models::getScatterPlotVaryParameters(lkb, paramIdVec, meanVec, varianceVec,
normalizationDose, 50);
scatterCompare.setCompareScatter(scatterVary);
CHECK_TESTER(scatterCompare);
//test RTNTCPRSModel
rttb::models::NTCPRSModel rs = rttb::models::NTCPRSModel();
models::BioModelParamType gammaVal = 1.7;
models::BioModelParamType sVal = 1;
rs.setDVH(dvhPtr2);
rs.setD50(d50Val);
rs.setGamma(gammaVal);
rs.setS(sVal);
CHECK_NO_THROW(rs.init());
normalizationDose = 60;
curve = models::getCurveDoseVSBioModel(rs, normalizationDose);
CHECK_NO_THROW(models::getScatterPlotVary1Parameter(rs, 0, d50Val, 0, normalizationDose, 100));
scatter = models::getScatterPlotVary1Parameter(rs, 0, d50Val, 0, normalizationDose, 100);
scatterCompare.setReferenceCurve(curve);
scatterCompare.setVariance(0);
scatterCompare.setCompareScatter(scatter);
CHECK_TESTER(scatterCompare);
//"d50":0,"gamma":1,"s":2
//test also with other parameter
scatter = models::getScatterPlotVary1Parameter(rs, 1, gammaVal, 0, normalizationDose, 100);
scatterCompare.setCompareScatter(scatter);
CHECK_TESTER(scatterCompare);
paramIdVec.clear();
meanVec.clear();
varianceVec.clear();
paramIdVec.push_back(0);
meanVec.push_back(rs.getD50());
varianceVec.push_back(0);
paramIdVec.push_back(1);
meanVec.push_back(rs.getGamma());
varianceVec.push_back(0);
paramIdVec.push_back(2);
meanVec.push_back(rs.getS());
varianceVec.push_back(0);
scatterVary = models::getScatterPlotVaryParameters(rs, paramIdVec, meanVec, varianceVec,
normalizationDose, 50);
scatterCompare.setCompareScatter(scatterVary);
CHECK_TESTER(scatterCompare);
variance = 0.0075;
CHECK_NO_THROW(models::getScatterPlotVary1Parameter(rs, 0, d50Val, variance, normalizationDose,
100));
scatter = models::getScatterPlotVary1Parameter(rs, 0, d50Val, variance, normalizationDose, 100);
scatterCompare.setCompareScatter(scatter);
scatterCompare.setVariance(variance);
CHECK_TESTER(scatterCompare);
//test also with other parameter
scatter = models::getScatterPlotVary1Parameter(rs, 2, sVal, variance, normalizationDose, 100);
scatterCompare.setCompareScatter(scatter);
CHECK_TESTER(scatterCompare);
paramIdVec.clear();
meanVec.clear();
varianceVec.clear();
paramIdVec.push_back(0);
meanVec.push_back(rs.getD50());
varianceVec.push_back(variance);
paramIdVec.push_back(1);
meanVec.push_back(rs.getGamma());
varianceVec.push_back(variance);
paramIdVec.push_back(2);
meanVec.push_back(rs.getS());
varianceVec.push_back(variance);
scatterVary = models::getScatterPlotVaryParameters(rs, paramIdVec, meanVec, varianceVec,
normalizationDose, 50);
scatterCompare.setCompareScatter(scatterVary);
CHECK_TESTER(scatterCompare);
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
diff --git a/testing/examples/RTDVHTest.cpp b/testing/examples/RTDVHTest.cpp
index 36b1b4d..3ef2e8f 100644
--- a/testing/examples/RTDVHTest.cpp
+++ b/testing/examples/RTDVHTest.cpp
@@ -1,110 +1,110 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See rttbCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html [^]
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notices for more information.
//
//------------------------------------------------------------------------
/*!
// @file
// @version $Revision$ (last changed revision)
// @date $Date$ (last change date)
// @author $Author$ (last changed by)
*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include "litCheckMacros.h"
#include "rttbDVH.h"
-#include "rttbDVHTxtFileReader.h"
#include "rttbBaseType.h"
#include "rttbDvhBasedModels.h"
+#include "rttbDVHXMLFileReader.h"
namespace rttb
{
namespace testing
{
/*! @brief RTDVHTest. Max, min, mean, modal, median, Vx, Dx, EUD, BED, LQED2 are tested.
Test if calculation in new architecture returns similar results to the
original implementation.
Comparison of actual DVH values is performed in DVHCalculatorComparisonTest.cpp.
WARNING: The values for comparison need to be adjusted if the input files are changed!
*/
int RTDVHTest(int argc, char* argv[])
{
PREPARE_DEFAULT_TEST_REPORTING;
//ARGUMENTS: 1: dvh file name
std::string RTDVH_FILENAME_PTV;
if (argc > 1)
{
RTDVH_FILENAME_PTV = argv[1];
}
typedef core::DVH::DVHPointer DVHPointer;
/*test RT dvh*/
- rttb::io::other::DVHTxtFileReader dvhReader = rttb::io::other::DVHTxtFileReader(RTDVH_FILENAME_PTV);
+ rttb::io::other::DVHXMLFileReader dvhReader = rttb::io::other::DVHXMLFileReader(RTDVH_FILENAME_PTV);
const DoseCalcType expectedValue = 0.01305;
//dvhReader
DVHPointer dvh = dvhReader.generateDVH();
CHECK_CLOSE(expectedValue, models::getEUD(dvh, 10), errorConstant);
std::cout << models::getEUD(dvh, 10) << std::endl;
CHECK_NO_THROW(models::calcBEDDVH(dvh, 15, 15));
CHECK_NO_THROW(models::calcLQED2DVH(dvh, 15, 10));
CHECK_NO_THROW(dvh->getDataDifferential(true));
CHECK_EQUAL(1, dvh->getDataCumulative(true).at(0));
CHECK_NO_THROW(models::calcBEDDVH(dvh, 15, 15, true));
CHECK_NO_THROW(models::calcLQED2DVH(dvh, 15, 10, true));
//test statistics (relative cumulative data)
CHECK_CLOSE(expectedValue, dvh->getMaximum(), errorConstant);
CHECK_CLOSE(expectedValue, dvh->getMinimum(), errorConstant);
CHECK_CLOSE(expectedValue, dvh->getMean(), errorConstant);
CHECK_CLOSE(expectedValue, dvh->getMedian(), errorConstant);
CHECK_CLOSE(expectedValue, dvh->getModal(), errorConstant);
CHECK_EQUAL(0, dvh->getVx(0.014));
CHECK_EQUAL(250, dvh->getVx(0.01));
CHECK_CLOSE(0.0131, dvh->getDx(100), errorConstant + errorConstant * 10);
CHECK_CLOSE(0.013, dvh->getDx(249), errorConstant);
CHECK_EQUAL(0, dvh->getDx(251));
//test statistics (absolute cumulative data)
CHECK_EQUAL(2000, dvh->getDataCumulative(false).at(0));
CHECK_EQUAL(0, dvh->getVx(0.014));
CHECK_EQUAL(250, dvh->getVx(0.01));
CHECK_CLOSE(0.0131, dvh->getDx(100), errorConstant + errorConstant * 10);
CHECK_CLOSE(0.013, dvh->getDx(249), errorConstant);
CHECK_EQUAL(0, dvh->getDx(251));
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
diff --git a/testing/examples/RTDoseIndexTest.cpp b/testing/examples/RTDoseIndexTest.cpp
index b8c142b..4680166 100644
--- a/testing/examples/RTDoseIndexTest.cpp
+++ b/testing/examples/RTDoseIndexTest.cpp
@@ -1,209 +1,209 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See rttbCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html [^]
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notices for more information.
//
//------------------------------------------------------------------------
/*!
// @file
// @version $Revision$ (last changed revision)
// @date $Date$ (last change date)
// @author $Author$ (last changed by)
*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include "litCheckMacros.h"
#include "rttbDoseIndex.h"
#include "rttbDVHSet.h"
-#include "rttbDVHTxtFileReader.h"
#include "rttbBaseType.h"
#include "rttbNullPointerException.h"
#include "rttbConformalIndex.h"
#include "rttbConformationNumber.h"
#include "rttbConformityIndex.h"
#include "rttbCoverageIndex.h"
#include "rttbHomogeneityIndex.h"
#include "rttbException.h"
#include "rttbInvalidParameterException.h"
+#include "rttbDVHXMLFileReader.h"
#include <math.h>
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
namespace rttb
{
namespace testing
{
/*! @brief DoseIndexTest. ConformationNumber ConformalIndex ConformityIndex CoverageIndex HomogeneityIndex are tested.
test dvh: deltaV 0.125, deltaD 0.5
1. dvh TV: number of voxels 2900, maximum dose bin 133, dose bin 127~133
2. dvh HT1: number of voxels 5410, maximum dose bin 40, dose bin 0~2,40
3. dvh HT2: number of voxels 10210, maximum dose bin 50, dose bin 0~2,50
4. dvh HT3: number of voxels 1210, maximum dose bin 70, dose bin 0~2,70
Test if calculation in new architecture returns similar results to the
original implementation.
WARNING: The values for comparison need to be adjusted if the input files are changed!
*/
int RTDoseIndexTest(int argc, char* argv[])
{
PREPARE_DEFAULT_TEST_REPORTING;
//ARGUMENTS: 1: ptv dvh file name
// 2: normal tissue 1 dvh file name
// 3: normal tissue 2 dvh file name
// 4: normal tissue 3 dvh file name
std::string DVH_FILENAME_PTV;
std::string DVH_FILENAME_NT1;
std::string DVH_FILENAME_NT2;
std::string DVH_FILENAME_NT3;
if (argc > 1)
{
DVH_FILENAME_PTV = argv[1];
}
if (argc > 2)
{
DVH_FILENAME_NT1 = argv[2];
}
if (argc > 3)
{
DVH_FILENAME_NT2 = argv[3];
}
if (argc > 4)
{
DVH_FILENAME_NT3 = argv[4];
}
/*test dvh: deltaV 0.125, deltaD 0.5*/
/*dvh TV: number of voxels 2900, maximum dose bin 133, dose bin 127~133*/
- rttb::io::other::DVHTxtFileReader dvhReader = rttb::io::other::DVHTxtFileReader(DVH_FILENAME_PTV);
+ rttb::io::other::DVHXMLFileReader dvhReader = rttb::io::other::DVHXMLFileReader(DVH_FILENAME_PTV);
rttb::core::DVH dvhPTV = *(dvhReader.generateDVH());
/*dvh HT1: number of voxels 5410, maximum dose bin 40, dose bin 0~2,40*/
- rttb::io::other::DVHTxtFileReader dvhReader1 = rttb::io::other::DVHTxtFileReader(DVH_FILENAME_NT1);
+ rttb::io::other::DVHXMLFileReader dvhReader1 = rttb::io::other::DVHXMLFileReader(DVH_FILENAME_NT1);
core::DVH dvhNT1 = *(dvhReader1.generateDVH());
/*dvh HT2: number of voxels 10210, maximum dose bin 50, dose bin 0~2,50*/
- rttb::io::other::DVHTxtFileReader dvhReader2 = rttb::io::other::DVHTxtFileReader(DVH_FILENAME_NT2);
+ rttb::io::other::DVHXMLFileReader dvhReader2 = rttb::io::other::DVHXMLFileReader(DVH_FILENAME_NT2);
core::DVH dvhNT2 = *(dvhReader2.generateDVH());
/*dvh HT3: number of voxels 1210, maximum dose bin 70, dose bin 0~2,70*/
- rttb::io::other::DVHTxtFileReader dvhReader3 = rttb::io::other::DVHTxtFileReader(DVH_FILENAME_NT3);
+ rttb::io::other::DVHXMLFileReader dvhReader3 = rttb::io::other::DVHXMLFileReader(DVH_FILENAME_NT3);
core::DVH dvhNT3 = *(dvhReader3.generateDVH());
std::vector<core::DVH> dvhTVSet;
std::vector<core::DVH> dvhHTSet;
dvhTVSet.push_back(dvhPTV);
dvhHTSet.push_back(dvhNT1);
dvhHTSet.push_back(dvhNT2);
dvhHTSet.push_back(dvhNT3);
::boost::shared_ptr<core::DVHSet> dvhSetPtr = ::boost::make_shared<core::DVHSet>(dvhTVSet, dvhHTSet,
"testStrSet", dvhPTV.getDoseID());
/*test exception*/
::boost::shared_ptr<core::DVHSet> dvhSetNullPtr;
CHECK_THROW_EXPLICIT(indices::ConformalIndex(dvhSetNullPtr, 0), core::InvalidParameterException);
CHECK_THROW_EXPLICIT(indices::ConformationNumber(dvhSetNullPtr, 0),
core::InvalidParameterException);
CHECK_THROW_EXPLICIT(indices::ConformityIndex(dvhSetNullPtr, 0), core::InvalidParameterException);
CHECK_THROW_EXPLICIT(indices::CoverageIndex(dvhSetNullPtr, 0), core::InvalidParameterException);
CHECK_THROW_EXPLICIT(indices::HomogeneityIndex(dvhSetNullPtr, 0), core::InvalidParameterException);
/*test exception for invalid reference dose*/
CHECK_THROW_EXPLICIT(indices::ConformalIndex(dvhSetPtr, 100), core::InvalidParameterException);
CHECK_THROW_EXPLICIT(indices::ConformationNumber(dvhSetPtr, 100), core::InvalidParameterException);
CHECK_THROW_EXPLICIT(indices::ConformityIndex(dvhSetPtr, 100), core::InvalidParameterException);
CHECK_THROW_EXPLICIT(indices::HomogeneityIndex(dvhSetPtr, 0), core::InvalidParameterException);
/*test index calculation*/
/*RTConformationNumber */
//PTV covered by reference dose 30 = the whole PTV =362.5; Volume of the referece 30=362.5+1.25
indices::ConformationNumber cn = indices::ConformationNumber(dvhSetPtr, 30);
//check if values are close. Equality is only achieved with double precission.
CHECK_CLOSE(362.5 / 363.75, cn.getValue(), errorConstant);
//cn==1*TV0/V0=362.5/2466.25
cn.setDoseReference(0);
CHECK_CLOSE(362.5 / 2466.25, cn.getValue(), errorConstant);
cn.setDoseReference(65);
CHECK_CLOSE(2300 / 2900.0, cn.getValue(),
errorConstant); //ref dose: 65 -> TVref=Vref -> cn=TVref/TV=2300/2900
CHECK_EQUAL(cn.getValue(), cn.getValueAt(0));
CHECK_THROW_EXPLICIT(cn.getValueAt(1), core::InvalidParameterException);
/*ConformalIndex */
//HT 1 covered by ref=HT2 covered by ref=0, HT3 covered by ref=1.25
indices::ConformalIndex coin = indices::ConformalIndex(dvhSetPtr, 30);
CHECK_CLOSE((362.5 / 363.75) * (1 - 1.25 / 151.25), coin.getValue(), errorConstant);
coin.setDoseReference(0);
CHECK_EQUAL(0, coin.getValue());
coin.setDoseReference(65);
CHECK_CLOSE(2300 / 2900.0, coin.getValue(),
errorConstant); //ref dose: 65 -> Vref=0 for all HT -> cn=cn*(1-0)=cn
CHECK_EQUAL(coin.getValue(), coin.getValueAt(0));
CHECK_THROW_EXPLICIT(coin.getValueAt(1), core::InvalidParameterException);
/*ConformityIndex */
indices::ConformityIndex ci = indices::ConformityIndex(dvhSetPtr, 30);
CHECK_CLOSE(362.5 / 363.75, ci.getValue(), errorConstant);
ci.setDoseReference(65);
CHECK_CLOSE(2300 / 2900.0, ci.getValue(), errorConstant); //ref dose: 65->ci=2300/2900*1*1*1
CHECK_EQUAL(ci.getValue(), ci.getValueAt(0));
CHECK_THROW_EXPLICIT(ci.getValueAt(1), core::InvalidParameterException);
/*CoverageIndex*/
indices::CoverageIndex coverageI = indices::CoverageIndex(dvhSetPtr, 30);
CHECK_CLOSE(362.5 / 362.5, coverageI.getValue(), errorConstant); //ref dose: 30 -> coverage index=1
coverageI.setDoseReference(65);
CHECK_CLOSE(2300 / 2900.0, coverageI.getValue(),
errorConstant); //ref dose: 65->coverage index=2300/2900
CHECK_EQUAL(coverageI.getValue(), coverageI.getValueAt(0));
CHECK_THROW_EXPLICIT(coverageI.getValueAt(1), core::InvalidParameterException);
/*HomogeneityIndex TV max: 133*0.5=66.5, TV min: 127*0.5=63.5 -> hi=(66.5-63.5)/30*/
indices::HomogeneityIndex hi = indices::HomogeneityIndex(dvhSetPtr, 30);
CHECK_CLOSE(3 / 30.0, hi.getValue(), errorConstant);
hi.setDoseReference(65);
CHECK_CLOSE(3 / 65.0, hi.getValue(), errorConstant);
CHECK_EQUAL(hi.getValue(), hi.getValueAt(0));
CHECK_THROW_EXPLICIT(hi.getValueAt(1), core::InvalidParameterException);
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
\ No newline at end of file
diff --git a/testing/io/other/DVHTXTIOTest.cpp b/testing/io/other/DVHTXTIOTest.cpp
deleted file mode 100644
index 0ced178..0000000
--- a/testing/io/other/DVHTXTIOTest.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-// -----------------------------------------------------------------------
-// RTToolbox - DKFZ radiotherapy quantitative evaluation library
-//
-// Copyright (c) German Cancer Research Center (DKFZ),
-// Software development for Integrated Diagnostics and Therapy (SIDT).
-// ALL RIGHTS RESERVED.
-// See rttbCopyright.txt or
-// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
-//
-// This software is distributed WITHOUT ANY WARRANTY; without even
-// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the above copyright notices for more information.
-//
-//------------------------------------------------------------------------
-/*!
-// @file
-// @version $Revision$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
-
-// this file defines the rttbCoreTests for the test driver
-// and all it expects is that you have a function called RegisterTests
-
-#include <boost/make_shared.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/lexical_cast.hpp>
-
-#include "litCheckMacros.h"
-
-#include "rttbBaseType.h"
-#include "rttbDVH.h"
-#include "rttbDVHSet.h"
-#include "rttbDVHTxtFileReader.h"
-#include "rttbDVHTxtFileWriter.h"
-#include "rttbInvalidParameterException.h"
-#include "rttbNullPointerException.h"
-
-#include "../../core/DummyDVHGenerator.h"
-
-#include "CompareDVH.h"
-
-namespace rttb
-{
-
- namespace testing
- {
-
- /*! @brief DVHTXTIOTest - test the IO for DVH txt data
- 1) test writing dvh to text file
- 2) test reading DVH from text file
- 3) test reading and writing the same dvh
- */
-
- int DVHTXTIOTest(int argc, char* argv[])
- {
- typedef core::DVH::DVHPointer DVHPointer;
-
- PREPARE_DEFAULT_TEST_REPORTING;
-
- std::string DVHTXT_FILENAME;
-
- if (argc > 1)
- {
- DVHTXT_FILENAME = argv[1];
- }
-
- /* generate dummy DVH */
- const IDType structureIDPrefix = "myStructure";
- const IDType doseID = "myDose";
-
- DummyDVHGenerator dvhGenerator;
-
- DVHPointer spMyDVH = boost::make_shared<core::DVH>(dvhGenerator.generateDVH(structureIDPrefix,
- doseID));
-
- // 1) test writing DVH to text file
- DVHType typeCum = {DVHType::Cumulative};
- DVHType typeDiff = {DVHType::Differential};
- FileNameString fN1 = "test.txt";
- CHECK_NO_THROW(io::other::DVHTxtFileWriter(fN1, typeDiff));
- CHECK_NO_THROW(io::other::DVHTxtFileWriter(fN1, typeCum));
-
-
- io::other::DVHTxtFileWriter dvhWriter(fN1, typeCum);
-
- CHECK_EQUAL(fN1, dvhWriter.getFileName());
-
- FileNameString fN2 = "otherFile.txt";
- CHECK_NO_THROW(dvhWriter.setFileName(fN2));
- CHECK_EQUAL(fN2, dvhWriter.getFileName());
-
- CHECK_EQUAL(DVHType::Cumulative, dvhWriter.getDVHType().Type);
- CHECK_NO_THROW(dvhWriter.setDVHType(typeDiff));
- CHECK_EQUAL(DVHType::Differential, dvhWriter.getDVHType().Type);
-
- DVHPointer emptyDvh;
- CHECK_THROW_EXPLICIT(dvhWriter.writeDVH(emptyDvh), core::NullPointerException);
- CHECK_NO_THROW(dvhWriter.setDVHType(typeDiff));
- CHECK_NO_THROW(dvhWriter.writeDVH(spMyDVH));
-
- // 2) test reading DVH from text file
- CHECK_NO_THROW(io::other::DVHTxtFileReader dvhReader(fN1));
- io::other::DVHTxtFileReader dvhReaderTest(fN1);
- CHECK_THROW_EXPLICIT(dvhReaderTest.generateDVH(), core::InvalidParameterException);
- CHECK_NO_THROW(io::other::DVHTxtFileReader dvhReader(fN2));
-
- io::other::DVHTxtFileReader dvhReader(fN2);
-
- CHECK_NO_THROW(dvhReader.resetFileName(fN1));
- CHECK_THROW_EXPLICIT(dvhReader.generateDVH(), core::InvalidParameterException);
- CHECK_NO_THROW(dvhReader.resetFileName(fN2));
-
- CHECK_NO_THROW(dvhReader.generateDVH());
-
- DVHPointer importedDVH = dvhReader.generateDVH();
-
- CHECK_EQUAL(*importedDVH, *spMyDVH);
-
- // 3) test reading and writing the same dvh
- //read dvh from a txt file
- io::other::DVHTxtFileReader dvhReader_R(DVHTXT_FILENAME);
- rttb::core::DVHGeneratorInterface::DVHPointer dvhP_R = dvhReader_R.generateDVH();
-
- //write the dvh to another file as cumulative
- io::other::DVHTxtFileWriter dvhWriter_R_Cum("test_Cum.txt", typeCum);
- dvhWriter_R_Cum.writeDVH(dvhP_R);
-
- //read the file
- io::other::DVHTxtFileReader dvhReader_W_Cum("test_Cum.txt");
- rttb::core::DVHGeneratorInterface::DVHPointer dvhP_W_Cum = dvhReader_W_Cum.generateDVH();
-
- //check equal
- CHECK(checkEqualDVH(dvhP_R, dvhP_W_Cum));
-
- //write the dvh to another file as differential
- io::other::DVHTxtFileWriter dvhWriter_R_Diff("test_Diff.txt", typeDiff);
- dvhWriter_R_Diff.writeDVH(dvhP_R);
-
- //read the file
- io::other::DVHTxtFileReader dvhReader_W_Diff("test_Diff.txt");
- rttb::core::DVHGeneratorInterface::DVHPointer dvhP_W_Diff = dvhReader_W_Diff.generateDVH();
-
- //check equal
- CHECK(checkEqualDVH(dvhP_R, dvhP_W_Diff));
-
- RETURN_AND_REPORT_TEST_SUCCESS;
- }
-
- }//testing
-}//rttb
-
diff --git a/testing/io/other/DVHXMLIOTest.cpp b/testing/io/other/DVHXMLIOTest.cpp
index a8517ce..ba254bb 100644
--- a/testing/io/other/DVHXMLIOTest.cpp
+++ b/testing/io/other/DVHXMLIOTest.cpp
@@ -1,167 +1,107 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See rttbCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notices for more information.
//
//------------------------------------------------------------------------
/*!
// @file
// @version $Revision$ (last changed revision)
// @date $Date$ (last change date)
// @author $Author$ (last changed by)
*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/lexical_cast.hpp>
#include "litCheckMacros.h"
#include "rttbBaseType.h"
#include "rttbDVH.h"
#include "rttbDVHSet.h"
-#include "rttbDVHTxtFileReader.h"
-#include "rttbDVHTxtFileWriter.h"
#include "rttbDVHXMLFileReader.h"
#include "rttbDVHXMLFileWriter.h"
#include "rttbInvalidParameterException.h"
#include "rttbNullPointerException.h"
#include "../../core/DummyDVHGenerator.h"
#include "CompareDVH.h"
namespace rttb
{
namespace testing
{
/*! @brief DVHXMLIOTest - test the IO for DVH xml data
1) test writing dvh to xml file
2) test reading DVH from xml file
- 3) test reading dvh from txt file and writing to xml, check equal
*/
int DVHXMLIOTest(int argc, char* argv[])
{
typedef core::DVH::DVHPointer DVHPointer;
PREPARE_DEFAULT_TEST_REPORTING;
- std::string DVHTXT_FILENAME;
-
- if (argc > 1)
- {
- DVHTXT_FILENAME = argv[1];
- }
-
/* generate dummy DVH */
const IDType structureIDPrefix = "myStructure";
const IDType doseID = "myDose";
DummyDVHGenerator dvhGenerator;
DVHPointer spMyDVH = boost::make_shared<core::DVH>(dvhGenerator.generateDVH(structureIDPrefix,
doseID));
// 1) test writing DVH to xml file
DVHType typeCum = {DVHType::Cumulative};
DVHType typeDiff = {DVHType::Differential};
FileNameString fN1 = "test.xml";
CHECK_NO_THROW(io::other::DVHXMLFileWriter(fN1, typeDiff));
CHECK_NO_THROW(io::other::DVHXMLFileWriter(fN1, typeCum));
io::other::DVHXMLFileWriter dvhWriter(fN1, typeCum);
CHECK_EQUAL(fN1, dvhWriter.getFileName());
FileNameString fN2 = "otherFile.xml";
CHECK_NO_THROW(dvhWriter.setFileName(fN2));
CHECK_EQUAL(fN2, dvhWriter.getFileName());
CHECK_EQUAL(DVHType::Cumulative, dvhWriter.getDVHType().Type);
CHECK_NO_THROW(dvhWriter.setDVHType(typeDiff));
CHECK_EQUAL(DVHType::Differential, dvhWriter.getDVHType().Type);
DVHPointer emptyDvh;
CHECK_THROW_EXPLICIT(dvhWriter.writeDVH(emptyDvh), core::NullPointerException);
//CHECK_THROW_EXPLICIT(dvhWriter.writeDVH(spMyDVH), core::InvalidParameterException);
CHECK_NO_THROW(dvhWriter.setDVHType(typeDiff));
CHECK_NO_THROW(dvhWriter.writeDVH(spMyDVH));
// 2) test reading DVH from xml file
io::other::DVHXMLFileReader dvhReader(fN2);
DVHPointer importedDVH = dvhReader.generateDVH();
CHECK_EQUAL(*importedDVH, *spMyDVH);
- //3) test reading dvh from txt file and writing to xml
- io::other::DVHTxtFileReader dvhReader2(DVHTXT_FILENAME);
- DVHPointer importedDVH2 = dvhReader2.generateDVH();
-
- //write dvh to a xml file as differential
- FileNameString toWrite_diff = "test_diff.xml";
- io::other::DVHXMLFileWriter xmlWriter(toWrite_diff, typeDiff);
- xmlWriter.writeDVH(importedDVH2);
-
- io::other::DVHXMLFileReader xmlReader(toWrite_diff);
- DVHPointer readDVH = xmlReader.generateDVH();
-
- CHECK(checkEqualDVH(importedDVH2, readDVH));
-
- //write dvh to a xml file as cummulative
- FileNameString toWrite_cum = "test_cum.xml";
- io::other::DVHXMLFileWriter xmlWriter_cum(toWrite_cum, typeCum);
- xmlWriter_cum.writeDVH(importedDVH2);
-
- io::other::DVHXMLFileReader xmlReader_cum(toWrite_cum);
- DVHPointer readDVH_cum = xmlReader_cum.generateDVH();
-
- CHECK(checkEqualDVH(importedDVH2, readDVH_cum));
-
- //write dvh to a normalized xml file as differential
- FileNameString toWrite_normalized_diff = "test_normalized_diff.xml";
- io::other::DVHXMLFileWriter xmlWriter_normalized_dif(toWrite_normalized_diff, typeDiff);
- xmlWriter_normalized_dif.writeDVH(importedDVH2, true);
-
- io::other::DVHXMLFileReader xmlReader_normalized_diff(toWrite_normalized_diff);
- DVHPointer readDVH_normalized_diff = xmlReader.generateDVH();
-
- CHECK(checkEqualDVH(importedDVH2, readDVH_normalized_diff));
-
- //write dvh to a normalized xml file as cummulative
- FileNameString toWrite_normalized_cum = "test_normalized_cum.xml";
- io::other::DVHXMLFileWriter xmlWriter_normalized_cum(toWrite_normalized_cum, typeCum);
- xmlWriter_normalized_cum.writeDVH(importedDVH2, true);
-
- io::other::DVHXMLFileReader xmlReader_normalized_cum(toWrite_normalized_cum);
- DVHPointer readDVH_normalized_cum = xmlReader_normalized_cum.generateDVH();
-
- CHECK(checkEqualDVH(importedDVH2, readDVH_normalized_cum));
-
- //delete files again
- CHECK_EQUAL(std::remove(toWrite_diff.c_str()), 0);
- CHECK_EQUAL(std::remove(toWrite_cum.c_str()), 0);
- CHECK_EQUAL(std::remove(toWrite_normalized_diff.c_str()), 0);
- CHECK_EQUAL(std::remove(toWrite_normalized_cum.c_str()), 0);
-
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
diff --git a/testing/io/other/files.cmake b/testing/io/other/files.cmake
index 7cf627d..687ddb7 100644
--- a/testing/io/other/files.cmake
+++ b/testing/io/other/files.cmake
@@ -1,17 +1,16 @@
SET(CPP_FILES
../../core/DummyDoseAccessor.cpp
../../core/DummyDVHGenerator.cpp
CompareDVH.cpp
CompareDoseStatistic.cpp
DoseStatisticsIOTest.cpp
DVHXMLIOTest.cpp
- DVHTXTIOTest.cpp
rttbIOTests.cpp
)
SET(H_FILES
../../core/DummyDoseAccessor.h
../../core/DummyDVHGenerator.h
CompareDVH.h
CompareDoseStatistic.h
)
diff --git a/testing/io/other/rttbIOTests.cpp b/testing/io/other/rttbIOTests.cpp
index 30d557e..6d552b4 100644
--- a/testing/io/other/rttbIOTests.cpp
+++ b/testing/io/other/rttbIOTests.cpp
@@ -1,62 +1,61 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See rttbCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notices for more information.
//
//------------------------------------------------------------------------
/*!
// @file
// @version $Revision$ (last changed revision)
// @date $Date$ (last change date)
// @author $Author$ (last changed by)
*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif
#include "litMultiTestsMain.h"
namespace rttb
{
namespace testing
{
void registerTests()
{
LIT_REGISTER_TEST(DoseStatisticsIOTest);
LIT_REGISTER_TEST(DVHXMLIOTest);
- LIT_REGISTER_TEST(DVHTXTIOTest);
}
}
}
int main(int argc, char* argv[])
{
int result = 0;
rttb::testing::registerTests();
try
{
result = lit::multiTestsMain(argc, argv);
}
catch (...)
{
result = -1;
}
return result;
}