4 //#include "DIGFileSnarkProj.h"
5 #include <DIGFileSnark/DIGFileSnarkProj.h>
7 #define DIGFILESNARKPROJ_DEBUG_LEVEL 0
\r
9 static char DIGFileSnarkPrjEmptyStr[1] = "";
14 ProjGeometry::ProjGeometry(double pRadius, double pSrcDetDistance, DetectorTypeEnum pDetectorType)
16 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
17 printf("ProjGeometry::ProjGeometry\n");
\r
21 SrcDetDistance = pSrcDetDistance;
22 DetectorType = pDetectorType;
23 GeometryType = GT_DIVERGENT;
27 ProjGeometry::ProjGeometry(DetectorTypeEnum pDetectorType, ProjTypeEnum pProjType)
29 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
30 printf("ProjGeometry::ProjGeometry\n");
\r
33 DetectorType = pDetectorType;
35 GeometryType = GT_PARALLEL;
41 ProjSpectrum::ProjSpectrum(unsigned int eNum)
43 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
44 printf("ProjSpectrum::ProjSpectrum\n");
\r
47 NumberOfEnergies = eNum;
48 energy = new int[eNum];
49 ratio = new double[eNum];
50 background = new double[eNum];
54 int ProjSpectrum::SetEnergy(int i, int e, double r, double bg)
56 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
57 printf("ProjSpectrum::SetEnergy\n");
\r
67 int PrjSpectrum_class::SetSpectrum(int* e, double* r, double* bg)
69 for(unsigned int i = 0; i < NumberOfEnergies; i++) {
72 background[i] = bg[i];
80 int PrjSpectrum_class::GetNumberOfEnergies(unsigned int* NOE)
82 *NOE = NumberOfEnergies;
88 int PrjSpectrum_class::GetEnergy(int index, int* e, double* r, double* bg)
92 *bg = background[index];
100 ProjNoise::ProjNoise()
102 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
103 printf("ProjNoise::ProjNoise\n");
\r
106 IsQuan = IsScat = IsAdd = IsMult = false;
111 void ProjNoise::SetQuantum(double pMean, double pCalibration, int pGantry)
113 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
114 printf("ProjNoise::SetQuantum\n");
\r
120 QuantumCalibration = pCalibration;
121 QuantumGantry = pGantry;
127 void ProjNoise::SetScatter(double pPeak, double pWidth)
129 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
130 printf("ProjNoise::SetScatter\n");
\r
136 ScatterWidth = pWidth;
142 void ProjNoise::SetAdditive(double pMean, double pStdDev)
144 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
145 printf("ProjNoise::SetAdditive\n");
\r
150 AdditiveMean = pMean;
151 AdditiveStdDev = pStdDev;
157 void ProjNoise::SetMultiplicative(double pMean, double pStdDev)
159 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
160 printf("ProjNoise::SetMultiplicative\n");
\r
165 MultiplicativeMean = pMean;
166 MultiplicativeStdDev = pStdDev;
174 int PrjNoise_class::GetQuantum(double& m, double& cm, double& g)
181 cm = Quantum_Calibration;
190 int PrjNoise_class::GetScatter(double& p, double& w)
205 int PrjNoise_class::GetAdditive(double& m, double& sd)
212 sd = Additive_Std_Dev;
220 int PrjNoise_class::GetMultiplicative(double& m, double& sd)
226 m = Multiplicative_Mean;
227 sd = Multiplicative_Std_Dev;
233 const char* DIGFileSnarkProj::TypeStr = "SNARK05 prjfil";
234 const char* DIGFileSnarkProj::SchemaStr = "DIGFileSnarkProj.xsd";
236 bool DIGFileSnarkProj::XMLStringsInitialized = false;
238 const XMLCh* DIGFileSnarkProj::AppHeaderXMLStr;
239 const XMLCh* DIGFileSnarkProj::GeomHeaderXMLStr;
240 const XMLCh* DIGFileSnarkProj::DivergentXMLStr;
241 const XMLCh* DIGFileSnarkProj::RadiusXMLStr;
242 const XMLCh* DIGFileSnarkProj::SourceDetXMLStr;
243 const XMLCh* DIGFileSnarkProj::DetTypeXMLStr;
244 const XMLCh* DIGFileSnarkProj::ParallelXMLStr;
245 const XMLCh* DIGFileSnarkProj::ProjTypeXMLStr;
246 const XMLCh* DIGFileSnarkProj::NoiseHeaderXMLStr;
247 const XMLCh* DIGFileSnarkProj::QuantumXMLStr;
248 const XMLCh* DIGFileSnarkProj::MeanXMLStr;
249 const XMLCh* DIGFileSnarkProj::CalibMeasXMLStr;
250 const XMLCh* DIGFileSnarkProj::GantryXMLStr;
251 const XMLCh* DIGFileSnarkProj::ScatterXMLStr;
252 const XMLCh* DIGFileSnarkProj::PeakXMLStr;
253 const XMLCh* DIGFileSnarkProj::WidthXMLStr;
254 const XMLCh* DIGFileSnarkProj::AdditiveXMLStr;
255 const XMLCh* DIGFileSnarkProj::StdDevXMLStr;
256 const XMLCh* DIGFileSnarkProj::MultipXMLStr;
257 const XMLCh* DIGFileSnarkProj::SpectrumHeaderXMLStr;
258 const XMLCh* DIGFileSnarkProj::NumOfEnerXMLStr;
259 const XMLCh* DIGFileSnarkProj::EnergyLevelXMLStr;
260 const XMLCh* DIGFileSnarkProj::EnergyXMLStr;
261 const XMLCh* DIGFileSnarkProj::RatioXMLStr;
262 const XMLCh* DIGFileSnarkProj::BackgroundXMLStr;
264 DIGFileSnarkProj::DIGFileSnarkProj()
267 // XML string initialization
268 if(!XMLStringsInitialized) {
270 AppHeaderXMLStr = XMLString::transcode("application_header");
271 GeomHeaderXMLStr = XMLString::transcode("geometric_header");
272 DivergentXMLStr = XMLString::transcode("divergent");
273 RadiusXMLStr = XMLString::transcode("radius");
274 SourceDetXMLStr = XMLString::transcode("source_detector_distance");
275 DetTypeXMLStr = XMLString::transcode("detector_type");
276 ParallelXMLStr = XMLString::transcode("parallel");
277 ProjTypeXMLStr = XMLString::transcode("projection_type");
278 NoiseHeaderXMLStr = XMLString::transcode("noise_header");
279 QuantumXMLStr = XMLString::transcode("quantum");
280 MeanXMLStr = XMLString::transcode("mean");
281 CalibMeasXMLStr = XMLString::transcode("calibration_measurement");
282 GantryXMLStr = XMLString::transcode("gantry_arrangement");
283 ScatterXMLStr = XMLString::transcode("scatter");
284 PeakXMLStr = XMLString::transcode("peak");
285 WidthXMLStr = XMLString::transcode("width");
286 AdditiveXMLStr = XMLString::transcode("additive");
287 StdDevXMLStr = XMLString::transcode("standard_deviation");
288 MultipXMLStr = XMLString::transcode("multiplicative");
289 SpectrumHeaderXMLStr = XMLString::transcode("spectrum_header");
290 NumOfEnerXMLStr = XMLString::transcode("number_of_energies");
291 EnergyLevelXMLStr = XMLString::transcode("energy_level");
292 EnergyXMLStr = XMLString::transcode("energy");
293 RatioXMLStr = XMLString::transcode("ratio");
294 BackgroundXMLStr = XMLString::transcode("background");
302 DIGFileSnarkProj::~DIGFileSnarkProj()
304 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
305 fprintf(stderr, "DIGFileSnarkProj:~DIGFileSnarkProj\n");
\r
308 if(Geometry != NULL) {
312 if(Spectrum != NULL) {
317 ////////////////////////////////////////////////////////////////
318 ////////////////////////////////////////////////////////////////
321 ///////////////////////////////////////////////
322 // main header reading
323 ///////////////////////////////////////////////
325 int DIGFileSnarkProj::GetMainHeader(ProjFileMH* MainHeader)
327 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
328 fprintf(stderr, "DIGFileSnarkProj:GetMainHeader\n");
\r
334 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 1
\r
335 printf("Getting Main Header Title\n");
\r
338 if(GetTitle(&Title) != 0) {
339 printf("Error reading Main Header Title\n");
343 //printf("Main Header Title: %s\n", Title);
\r
344 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 1
\r
345 printf("Seting Main Header Title\n");
\r
348 if(MainHeader->Title.Set(Title) != 0) {
349 printf("Error seting Main Header Title\n");
353 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 1
\r
354 printf("Seting Main Header Dimensions\n");
\r
357 if(GetDimensions(&(MainHeader->Dimensions)) != 0) {
358 printf("Error reading Main Header Dimensions\n");
362 //printf("Main Header Dimensions: %d\n", MainHeader->Dimensions);
364 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 1
\r
365 printf("Seting Main Header Sampling\n");
\r
368 if(GetSampling(&(MainHeader->Sampling)) != 0) {
369 printf("Error reading Main Header Sampling\n");
373 //printf("Main Header Sampling: %f\n", MainHeader->Sampling);
375 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 1
\r
376 printf("Getting Main Header comments\n");
\r
381 if(GetComment(&Comment) != 0) {
382 printf("Error reading Main Header Comment\n");
386 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 1
\r
387 printf("Seting Main Header Comments\n");
\r
390 //printf("Main Header Comment: %s\n", Comment);
392 if(MainHeader->Comment.Set(Comment) != 0) {
393 printf("Error Seting Main Header Comment\n");
400 int DIGFileSnarkProj::GetAppHeader(ProjFileAH* pAppHeader)
402 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
403 fprintf(stderr, "DIGFileSnarkProj:GetAppHeader\n");
\r
406 // application header comment
409 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 1
\r
410 printf("Getting Application Header Comments\n");
\r
413 if(GetAppComment(&Comment) != 0) {
414 printf("Error reading Application Header Comment\n");
418 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 1
\r
419 printf("Setting Application Header Comments\n");
\r
422 //printf("Application Header Comment: %s\n", Comment);
424 if(pAppHeader->Comment.Set(Comment) != 0) {
425 printf("Error Seting Application Header Comment\n");
429 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 1
\r
430 printf("Getting Application Header Geometry Type\n");
\r
434 if(GetGeometryType(&(pAppHeader->GeometryType)) != 0) {
435 printf("Error reading Application Header Geometry Type\n");
439 //printf("Application Header Geometry Type: %s\n", (pAppHeader->GeometryType == GT_DIVERGENT) ? "Divergent": "Parallel");
441 if(pAppHeader->GeometryType == GT_DIVERGENT) { // divergent
443 if(GetGeometry(&(pAppHeader->Radius), &(pAppHeader->SrcDetDistance), &(pAppHeader->DetectorType)) != 0) {
444 printf("Error reading Application Header Geometry\n");
448 //printf("Application Header Geometry Radius: %f\n", pAppHeader->Radius);
449 //printf("Application Header Geometry SrcDetDistance: %f\n", pAppHeader->SrcDetDistance);
454 if(GetGeometry(&(pAppHeader->DetectorType), &(pAppHeader->ProjType)) != 0) {
455 printf("Error reading Application Header Geometry\n");
459 //printf("Application Header Geometry Projection Type: %s\n", (pAppHeader->ProjType == PT_STRIP) ? "Strip": "Line");
464 switch(pAppHeader->DetectorType) {
467 printf("Application Header Geometry Detector Type: TANGENT\n");
471 printf("Application Header Geometry Detector Type: ARC\n");
475 printf("Application Header Geometry Detector Type: UNIFORM\n");
479 printf("Application Header Geometry Detector Type: VARIABLE\n");
486 if(GetNoOfEnergies(&(pAppHeader->NoOfEnergies)) != 0) {
487 printf("Error reading Application Header Spectrum Number Of Energies\n");
491 //printf("Application Header Spectrum Number Of Energies: %u\n", pAppHeader->NoOfEnergies);
493 pAppHeader->Energy = new int[pAppHeader->NoOfEnergies];
494 pAppHeader->Ratio = new double[pAppHeader->NoOfEnergies];
495 pAppHeader->Background = new double[pAppHeader->NoOfEnergies];
497 for(unsigned int k = 0; k < pAppHeader->NoOfEnergies; k++) {
498 if(GetSpectrum(k, &(pAppHeader->Energy[k]), &(pAppHeader->Ratio[k]), &(pAppHeader->Background[k])) != 0) {
499 printf("Error reading Application Header Spectrum Energy\n");
503 //printf("Application Header Spectrum Energy: %u %i %f %f\n", k, pAppHeader->Energy[k], pAppHeader->Ratio[k], pAppHeader->Background[k]);
508 if(HasNoiseQuantum(&(pAppHeader->QuantumFlag)) != 0) {
509 printf("Error reading Application Header Noise Quantum Flag\n");
513 if(pAppHeader->QuantumFlag) {
515 if(GetNoiseQuantum(&(pAppHeader->QuantumM), &(pAppHeader->QuantumCM), &(pAppHeader->QuantumGA)) != 0) {
516 printf("Error reading Application Header Noise Quantum Flag\n");
520 //printf("Application Header Noise Quantum: %f %f %i\n", pAppHeader->QuantumM, pAppHeader->QuantumCM, pAppHeader->QuantumGA);
523 if(HasNoiseScatter(&(pAppHeader->ScatterFlag)) != 0) {
524 printf("Error reading Application Header Noise Scatter Flag\n");
528 if(pAppHeader->ScatterFlag) {
530 if(GetNoiseScatter(&(pAppHeader->ScatterP), &(pAppHeader->ScatterW)) != 0) {
531 printf("Error reading Application Header Noise Scatter\n");
535 //printf("Application Header Noise Scatter: %f %f\n", pAppHeader->ScatterP, pAppHeader->ScatterW);
538 if(HasNoiseAdditive(&(pAppHeader->AdditiveFlag)) != 0) {
539 printf("Error reading Application Header Noise Additive Flag\n");
543 if(pAppHeader->AdditiveFlag) {
544 if(GetNoiseAdditive(&(pAppHeader->AdditiveM), &(pAppHeader->AdditiveSD)) != 0) {
545 printf("Error reading Application Header Noise Additive\n");
549 //printf("Application Header Noise Additive: %f %f\n", pAppHeader->AdditiveM, pAppHeader->AdditiveSD);
552 if(HasNoiseMultiplicative(&(pAppHeader->MultiplicativeFlag)) != 0) {
553 printf("Error reading Application Header Noise Multiplicative Flag\n");
557 if(pAppHeader->MultiplicativeFlag) {
559 if(GetNoiseMultiplicative(&(pAppHeader->MultiplicativeM), &(pAppHeader->MultiplicativeSD)) != 0) {
560 printf("Error reading Application Header Noise Multiplicative\n");
564 //printf("Application Header Noise Multiplicative: %f %f\n", pAppHeader->MultiplicativeM, pAppHeader->MultiplicativeSD);
570 ///////////////////////////////////////////////
571 // Projection header reading
572 ///////////////////////////////////////////////
574 int DIGFileSnarkProj::GetProjHeader(ProjFilePrjH* pProjHeader)
576 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
577 fprintf(stderr, "DIGFileSnarkProj:GetProjHeader\n");
\r
580 // read projection number
582 if(GetProjNo(&(pProjHeader->ProjNo)) != 0) {
583 printf("Error reading Projection Number\n");
587 //printf("Projection Number: %u\n", pProjHeader->ProjNo);
591 if(GetProjAngle(&(pProjHeader->Angle)) != 0) {
592 printf("Error reading Projection Angle\n");
596 //printf("Array Set Parameters: %f\n", pProjHeader->Angle);
601 if(GetProjComment(&Comment) != 0) {
602 printf("Error reading Projection Comment\n");
606 //printf("Projection Comment: %s\n", Comment);
608 if(pProjHeader->Comment.Set(Comment) != 0) {
609 printf("Error Seting Projection Comment\n");
616 ///////////////////////////////////////////////////////////////////////////////
617 ///////////////////////////////////////////////////////////////////////////////
619 ///////////////////////////////////////////////////////////////////////////////
620 ///////////////////////////////////////////////////////////////////////////////
622 ///////////////////////////////////////////////////////////////////////////////
624 ///////////////////////////////////////////////////////////////////////////////
626 int DIGFileSnarkProj::Open(const char* pFileName, ProjFileMH* pMainHeader)
628 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
629 fprintf(stderr, "DIGFileSnarkProj:Open\n");
\r
634 pFileName, // file name
635 pMainHeader->Title.Get(), // title
636 pMainHeader->Dimensions, // dimensions
637 pMainHeader->Sampling, // sampling
638 pMainHeader->Comment.Get() // comment
642 printf("Error opening file\n");
649 int DIGFileSnarkProj::Open(
650 const char* pFileName, // File Name
651 const char* pTitle, // Title
652 unsigned int pNumberOfRays, // USRAYS
653 double pSampling, // PINC
654 const char* pComments // Comments
657 //const char* Schema;
660 DIGSampling samp = { 0.0, 0.0, 0.0 };
662 dim.x = pNumberOfRays;
670 Noise.IsQuan = false;
672 Noise.IsScat = false;
673 Noise.IsMult = false;
675 return DIGFile::Open(
676 pFileName, // File Name
681 DIGValueType_REAL, // ValueType
682 DIGDataType_DOUBLE, // DataType
683 DIGDataFormat_BINARY, // DataFormat
685 DIGBasis_VORONOI, // Basis
686 DIGUnit_UNSPECIFIED, // Unit
691 pComments, // Comments
697 ///////////////////////////////////////////////
698 // application header writing
699 ///////////////////////////////////////////////
701 int DIGFileSnarkProj::SetAppHeader(ProjFileAH* pAppHeader)
703 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
704 fprintf(stderr, "DIGFileSnarkProj:SetAppHeader\n");
\r
709 if(pAppHeader->Comment.Get(&Comment)) {
\r
711 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
712 printf("** Error: Getting Application Header Comments\n");
\r
717 SetAppComment(Comment);
719 switch(pAppHeader->GeometryType) {
721 //pOut->SetGeometry(double r, double d, DetectorTypeEnum t);
722 if(SetGeometry(pAppHeader->Radius, pAppHeader->SrcDetDistance, pAppHeader->DetectorType) != 0) {
\r
724 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
725 printf("** Error: Setting Application Header Geometry\n");
\r
732 if(SetGeometry(pAppHeader->DetectorType, pAppHeader->ProjType) != 0) {
\r
734 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
735 printf("** Error: Setting Application Header Geometry\n");
\r
743 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
744 printf("** Error: Setting Application Header - Unknown Geometry\n");
\r
749 if(SetSpectrum(pAppHeader->NoOfEnergies, pAppHeader->Energy, pAppHeader->Ratio, pAppHeader->Background) != 0) {
\r
751 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
752 printf("** Error: Setting Application Header Spectrum\n");
\r
757 if(pAppHeader->QuantumFlag) {
758 if(SetNoiseQuantum(pAppHeader->QuantumM, pAppHeader->QuantumCM, pAppHeader->QuantumGA) != 0) {
\r
760 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
761 printf("** Error: Setting Application Header Noise - Quantum\n");
\r
767 if(pAppHeader->ScatterFlag) {
768 if(SetNoiseScatter(pAppHeader->ScatterP, pAppHeader->ScatterW) != 0) {
\r
770 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
771 printf("** Error: Setting Application Header Noise - Scatter\n");
\r
777 if(pAppHeader->AdditiveFlag) {
778 if(SetNoiseAdditive(pAppHeader->AdditiveM, pAppHeader->AdditiveSD) != 0) {
\r
780 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
781 printf("** Error: Setting Application Header Noise - Additive\n");
\r
787 if(pAppHeader->MultiplicativeFlag) {
788 if(SetNoiseMultiplicative(pAppHeader->MultiplicativeM, pAppHeader->MultiplicativeSD) != 0) {
\r
790 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
791 printf("** Error: Setting Application Header Noise - Multiplicative\n");
\r
800 ///////////////////////////////////////////////
801 // projection appending
802 ///////////////////////////////////////////////
804 int DIGFileSnarkProj::AppendProj(ProjFilePrjH* pProjHeader, const double* pData)
806 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
807 fprintf(stderr, "DIGFileSnarkProj:AppendProj\n");
\r
813 pProjHeader->Comment.Get(),
818 int DIGFileSnarkProj::AppendProj(
\r
819 unsigned int pProjNo,
821 const char* pComment,
825 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
826 fprintf(stderr, "DIGFileSnarkProj:AppendProj\n");
\r
830 char ProjNoStr[8]; // Projection Number as a String
831 char AngleStr[256]; // angle as a String
834 sprintf(AngleStr, "%.20f", pAngle);
837 sprintf(ProjNoStr, "%d", pProjNo);
839 if((ret = AppendArraySet("projection", ProjNoStr, AngleStr, pComment)) != 0) {
843 return AppendArray(0, "", pData);
846 ////////////////////////////////////////////////////////////////
847 ////////////////////////////////////////////////////////////////
851 int DIGFileSnarkProj::Open(const char* pFileName)
\r
853 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
854 fprintf(stderr, "DIGFileSnarkProj:Open\n");
\r
857 Noise.IsQuan = false;
859 Noise.IsScat = false;
860 Noise.IsMult = false;
862 if(DIGFile::Open(pFileName) != 0) {
\r
864 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
865 printf("** Error: Openning DIG file\n");
\r
867 return -1; // error opening dig file
870 if(strcmp(MainHeader.Type.Get(), TypeStr) != 0) {
\r
872 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
873 printf("** Error: Not a Snark05 prjfil file\n");
\r
875 return -2; // not a DIGFileSnarkProj
883 int DIGFileSnarkProj::GetAppComment(const char** pComment)
885 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
886 fprintf(stderr, "DIGFileSnarkProj:GetAppComment\n");
\r
889 return AppComment.Get(pComment);
892 int DIGFileSnarkProj::GetGeometryType(GeometryTypeEnum* pGeometryType)
894 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
895 fprintf(stderr, "DIGFileSnarkProj:GetGeometryType\n");
\r
898 *pGeometryType = Geometry->GeometryType;
903 int DIGFileSnarkProj::GetGeometry(double* pRadius, double* pSrcDetDistance, DetectorTypeEnum* pDetectorType)
905 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
906 fprintf(stderr, "DIGFileSnarkProj:GetGeometry\n");
\r
909 if(Geometry == NULL) {
\r
911 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
912 printf("** Error: Undefines Geometry\n");
\r
917 *pRadius = Geometry->Radius;
918 *pSrcDetDistance = Geometry->SrcDetDistance;
919 *pDetectorType = Geometry->DetectorType;
925 int DIGFileSnarkProj::GetGeometry(DetectorTypeEnum* pDetectorType, ProjTypeEnum* pProjType)
927 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
928 fprintf(stderr, "DIGFileSnarkProj:GetGeometry\n");
\r
931 if(Geometry == NULL) {
\r
933 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
934 printf("** Error: Undefines Geometry\n");
\r
939 *pDetectorType = Geometry->DetectorType;
940 *pProjType = Geometry->ProjType;
946 int DIGFileSnarkProj::GetNoOfEnergies(unsigned int* NumbOfEnergies)
948 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
949 fprintf(stderr, "DIGFileSnarkProj:GetNoOfEnergies\n");
\r
952 *NumbOfEnergies = Spectrum->NumberOfEnergies;
957 int DIGFileSnarkProj::GetSpectrum(unsigned int i, int* e, double* r, double* bg)
959 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
960 fprintf(stderr, "DIGFileSnarkProj:GetSpectrum\n");
\r
963 if(Spectrum == NULL) {
\r
965 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
966 printf("** Error: GetSpectrum - Undefines Spectrum\n");
\r
971 if(i >= Spectrum->NumberOfEnergies) {
\r
973 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
974 printf("** Error: GetSpectrum - invalid parameter\n");
\r
979 *e = Spectrum->energy[i];
980 *r = Spectrum->ratio[i];
981 *bg = Spectrum->background[i];
987 int DIGFileSnarkProj::HasNoiseQuantum(bool* a)
989 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
990 fprintf(stderr, "DIGFileSnarkProj:HasNoiseQuantum\n");
\r
998 int DIGFileSnarkProj::GetNoiseQuantum(double* pMean, double* pCalibration, int* pGantry)
1000 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1001 fprintf(stderr, "DIGFileSnarkProj:GetNoiseQuantum\n");
\r
1004 if(Noise.IsQuan != true) {
\r
1006 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
1007 printf("** Error: GetNoiseQuantum - Quantum Noise Undefined\n");
\r
1012 *pMean = Noise.QuantumMean;
1013 *pCalibration = Noise.QuantumCalibration;
1014 *pGantry = Noise.QuantumGantry;
1022 int DIGFileSnarkProj::HasNoiseScatter(bool* a)
1024 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1025 fprintf(stderr, "DIGFileSnarkProj:HasNoiseScatter\n");
\r
1032 int DIGFileSnarkProj::GetNoiseScatter(double* pPeak, double* pWidth)
1034 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1035 fprintf(stderr, "DIGFileSnarkProj:GetNoiseScatter\n");
\r
1038 if(Noise.IsScat != true) {
\r
1040 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
1041 printf("** Error: GetNoiseScatter - Scatter Noise Undefined\n");
\r
1046 *pPeak = Noise.ScatterPeak;
1047 *pWidth = Noise.ScatterWidth;
1055 int DIGFileSnarkProj::HasNoiseAdditive(bool* a)
1057 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1058 fprintf(stderr, "DIGFileSnarkProj:HasNoiseAdditive\n");
\r
1066 int DIGFileSnarkProj::GetNoiseAdditive(double* pMean, double* pStdDev)
1068 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1069 fprintf(stderr, "DIGFileSnarkProj:GetNoiseAdditive\n");
\r
1072 if(Noise.IsAdd != true) {
\r
1074 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
1075 printf("** Error: GetNoiseAdditive - Additive Noise Undefined\n");
\r
1080 *pMean = Noise.AdditiveMean;
1081 *pStdDev = Noise.AdditiveStdDev;
1089 int DIGFileSnarkProj::HasNoiseMultiplicative(bool* a)
1091 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1092 fprintf(stderr, "DIGFileSnarkProj:HasNoiseMultiplicative\n");
\r
1100 int DIGFileSnarkProj::GetNoiseMultiplicative(double* pMean, double* pStdDev)
1102 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1103 fprintf(stderr, "DIGFileSnarkProj:GetNoiseMultiplicative\n");
\r
1106 if(Noise.IsMult != true) {
\r
1108 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
1109 printf("** Error: GetNoiseMultiplicative - Multiplicative Noise Undefined\n");
\r
1114 *pMean = Noise.MultiplicativeMean;
1115 *pStdDev = Noise.MultiplicativeStdDev;
1124 int DIGFileSnarkProj::SetAppComment(const char* pComment)
1126 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1127 fprintf(stderr, "DIGFileSnarkProj:SetAppComment\n");
\r
1130 return AppComment.Set(pComment);
1134 int DIGFileSnarkProj::SetGeometry(double pRadius, double pSrcDetDistance, DetectorTypeEnum pDetectorType)
1136 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1137 fprintf(stderr, "DIGFileSnarkProj:SetGeometry\n");
\r
1140 if(Geometry != NULL) {
\r
1142 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
1143 printf("** Error: SetGeometry - Geometry Aleready Defined\n");
\r
1145 return -1; // already set
1148 Geometry = new ProjGeometry(pRadius, pSrcDetDistance, pDetectorType);
1154 int DIGFileSnarkProj::SetGeometry(DetectorTypeEnum pDetectorType, ProjTypeEnum pProjType)
1156 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1157 fprintf(stderr, "DIGFileSnarkProj:SetGeometry\n");
\r
1160 if(Geometry != NULL) {
\r
1162 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
1163 printf("** Error: SetGeometry - Geometry Aleready Defined\n");
\r
1165 return -1; // already set
1168 Geometry = new ProjGeometry(pDetectorType, pProjType);
1173 int DIGFileSnarkProj::SetSpectrum(unsigned int eNum, int* e, double* r, double* bg)
1175 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1176 fprintf(stderr, "DIGFileSnarkProj:SetSpectrum\n");
\r
1179 if(Spectrum != NULL) {
\r
1181 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
1182 printf("** Error: SetSpectrum - Spectrum Aleready Defined\n");
\r
1184 return -1; // already set
1187 Spectrum = new ProjSpectrum(eNum);
1189 for(unsigned int i = 0; i < eNum; i++) {
1190 Spectrum->energy[i] = e[i];
1191 Spectrum->ratio[i] = r[i];
1192 Spectrum->background[i] = bg[i];
1199 int DIGFileSnarkProj::SetNoiseQuantum(double pMean, double pCalibration, int pGantry)
1201 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1202 fprintf(stderr, "DIGFileSnarkProj:SetNoiseQuantum\n");
\r
1205 if(Noise.IsQuan) {
\r
1207 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
1208 printf("** Error: SetNoiseQuantum - Noise Quantum Aleready Defined\n");
\r
1210 return -1; // already set
1213 Noise.SetQuantum(pMean, pCalibration, pGantry);
1221 int DIGFileSnarkProj::SetNoiseScatter(double pPeak, double pWidth)
1223 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1224 fprintf(stderr, "DIGFileSnarkProj:SetNoiseScatter\n");
\r
1227 if(Noise.IsScat) {
\r
1229 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
1230 printf("** Error: SetNoiseScatter - Noise Scatter Aleready Defined\n");
\r
1232 return -1; // already set
1235 Noise.SetScatter(pPeak, pWidth);
1243 int DIGFileSnarkProj::SetNoiseAdditive(double pMean, double pStdDev)
1245 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1246 fprintf(stderr, "DIGFileSnarkProj:SetNoiseAdditive\n");
\r
1251 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
1252 printf("** Error: SetNoiseAdditive - Noise Additive Aleready Defined\n");
\r
1254 return -1; // already set
1257 Noise.SetAdditive(pMean, pStdDev);
1265 int DIGFileSnarkProj::SetNoiseMultiplicative(double pMean, double pStdDev)
1267 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1268 fprintf(stderr, "DIGFileSnarkProj:SetNoiseMultiplicative\n");
\r
1271 if(Noise.IsMult) {
\r
1273 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 0
\r
1274 printf("** Error: SetNoiseMultiplicative - Noise Multiplicative Aleready Defined\n");
\r
1276 return -1; // already set
1279 Noise.SetMultiplicative(pMean, pStdDev);
1285 /////////////////////////////////////////////////////////////////////
1289 /////////////////////////////////////////////////////////////////////
1291 // NOTE: error handling is not included
1292 int DIGFileSnarkProj::ParseApplicationHeader()
1294 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1295 fprintf(stderr, "DIGFileSnarkProj:ParseApplicationHeader\n");
\r
1298 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 1
\r
1299 printf("Parsing Application Header\n");
\r
1302 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 1
\r
1303 printf("Getting Comments\n");
\r
1306 // get Comment Texts
1307 char* tCom = DIGFileSnarkPrjEmptyStr;
\r
1309 DOMNodeList* CommentsList = ApplicationHeaderElement->getElementsByTagName(CommentsXMLStr);
1311 int tNumC = CommentsList->getLength();
1314 DOMElement* CommentsElement = (DOMElement*) CommentsList->item(0);
1316 if(GetElementText(CommentsElement, &tCom) != 0) {
1317 ;// allow empty comments
1321 AppComment.Set(tCom);
1324 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 1
\r
1325 printf("Getting Geometric Header\n");
\r
1328 // get geometric header
1330 DOMNodeList* GeomHeaderList = ApplicationHeaderElement->getElementsByTagName(GeomHeaderXMLStr);
1331 DOMElement* GeomHeaderElement = (DOMElement*) GeomHeaderList->item(0);
1335 DOMNodeList* DivergentList = GeomHeaderElement->getElementsByTagName(DivergentXMLStr);
1336 if(DivergentList->getLength() > 0) {
1337 DOMElement* DivergentElement = (DOMElement*) DivergentList->item(0);
1339 // get radius, source detector distance, detector type
1342 GetDoubleAttributeValue(DivergentElement, RadiusXMLStr, &tRadius);
1344 double tSrcDetDist = 0;
1345 GetDoubleAttributeValue(DivergentElement, SourceDetXMLStr, &tSrcDetDist);
1347 DOMNodeList* DetectList = DivergentElement->getElementsByTagName(DetTypeXMLStr);
1348 DOMElement* DetectElement = (DOMElement*) DetectList->item(0);
1351 DetectorTypeEnum tDet;
1353 GetElementText(DetectElement, &tstring);
1355 if(strcmp(tstring, "tangent") == 0) {
1359 if(strcmp(tstring, "arc") == 0) {
1363 Geometry = new ProjGeometry(tRadius, tSrcDetDist, tDet);
1368 DOMNodeList* ParallelList = GeomHeaderElement->getElementsByTagName(ParallelXMLStr);
1369 DOMElement* ParallelElement = (DOMElement*) ParallelList->item(0);
1371 // get detector type
1373 DOMNodeList* DetectList = ParallelElement->getElementsByTagName(DetTypeXMLStr);
1374 DOMElement* DetectElement = (DOMElement*) DetectList->item(0);
1377 DetectorTypeEnum tDet;
1379 GetElementText(DetectElement, &tstring);
1381 if(strcmp(tstring, "uniform") == 0) {
1385 if(strcmp(tstring, "variable") == 0) {
1389 // get projection type
1391 DOMNodeList* ProjectList = ParallelElement->getElementsByTagName(ProjTypeXMLStr);
1392 DOMElement* ProjectElement = (DOMElement*) ProjectList->item(0);
1396 GetElementText(ProjectElement, &tstring);
1398 if(strcmp(tstring, "line") == 0) {
1401 else if(strcmp(tstring, "strip") == 0) {
1406 Geometry = new ProjGeometry(tDet, tProj);
1409 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 1
\r
1410 printf("Getting Noise Header\n");
\r
1415 DOMNodeList* NoiseHeaderList = ApplicationHeaderElement->getElementsByTagName(NoiseHeaderXMLStr);
1416 DOMElement* NoiseHeaderElement = (DOMElement*) NoiseHeaderList->item(0);
1420 DOMNodeList* QuantumList = NoiseHeaderElement->getElementsByTagName(QuantumXMLStr);
1421 if(QuantumList->getLength() > 0) {
1422 DOMElement* QuantumElement = (DOMElement*) QuantumList->item(0);
1424 // get mean, calibration measurement, gantry arrangement
1426 double tMean = 0, tCal = 0;
1429 GetDoubleAttributeValue(QuantumElement, MeanXMLStr, &tMean);
1430 GetDoubleAttributeValue(QuantumElement, CalibMeasXMLStr, &tCal);
1431 GetIntAttributeValue(QuantumElement, GantryXMLStr, &tGan);
1433 Noise.SetQuantum(tMean, tCal, tGan);
1438 DOMNodeList* ScatterList = NoiseHeaderElement->getElementsByTagName(ScatterXMLStr);
1439 if(ScatterList->getLength() > 0) {
1440 DOMElement* ScatterElement = (DOMElement*) ScatterList->item(0);
1444 double tPeak = 0, tWidth = 0;
1446 GetDoubleAttributeValue(ScatterElement, PeakXMLStr, &tPeak);
1447 GetDoubleAttributeValue(ScatterElement, WidthXMLStr, &tWidth);
1449 Noise.SetScatter(tPeak, tWidth);
1454 DOMNodeList* AdditList = NoiseHeaderElement->getElementsByTagName(AdditiveXMLStr);
1455 if(AdditList->getLength() > 0) {
1456 DOMElement* AdditElement = (DOMElement*) AdditList->item(0);
1458 // get mean, calibration measurement, gantry arrangement
1460 double tMean = 0, tStd = 0;
1462 GetDoubleAttributeValue(AdditElement, MeanXMLStr, &tMean);
1463 GetDoubleAttributeValue(AdditElement, StdDevXMLStr, &tStd);
1465 Noise.SetAdditive(tMean, tStd);
1468 // get multiplicative
1470 DOMNodeList* MultipList = NoiseHeaderElement->getElementsByTagName(MultipXMLStr);
1471 if(MultipList->getLength() > 0) {
1472 DOMElement* MultipElement = (DOMElement*) MultipList->item(0);
1474 // get mean, calibration measurement, gantry arrangement
1476 double tMean = 0, tStd = 0;
1478 GetDoubleAttributeValue(MultipElement, MeanXMLStr, &tMean);
1479 GetDoubleAttributeValue(MultipElement, StdDevXMLStr, &tStd);
1481 Noise.SetMultiplicative(tMean, tStd);
1484 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 1
\r
1485 printf("Getting Specrum Header\n");
\r
1488 // get spectrum header
1490 DOMNodeList* SpectHeaderList = ApplicationHeaderElement->getElementsByTagName(SpectrumHeaderXMLStr);
1491 DOMElement* SpectHeaderElement = (DOMElement*) SpectHeaderList->item(0);
1493 // get number of energies
1495 unsigned int tNumE = 0;
1497 GetUintAttributeValue(SpectHeaderElement, NumOfEnerXMLStr, &tNumE);
1498 //SetEnergyNumber(tNumE);
1500 Spectrum = new ProjSpectrum(tNumE);
1502 // get energy level triplets: energy, ratio, background
1504 DOMNodeList* EnergyList = SpectHeaderElement->getElementsByTagName(EnergyLevelXMLStr);
1506 // NOTE: Error if EnergyList->getLength() != tNumE
1509 double tRatio = 0, tBack = 0;
1510 DOMElement* EnergyElement;
1512 for(unsigned int i = 0; i < EnergyList->getLength(); i++) {
1513 EnergyElement = (DOMElement*) EnergyList->item(i);
1515 GetIntAttributeValue(EnergyElement, EnergyXMLStr, &tEner);
1516 GetDoubleAttributeValue(EnergyElement, RatioXMLStr, &tRatio);
1517 GetDoubleAttributeValue(EnergyElement, BackgroundXMLStr, &tBack);
1519 Spectrum->SetEnergy(i, tEner, tRatio, tBack);
1526 int DIGFileSnarkProj::CreateApplicationHeader()
1528 #if DIGFILESNARKPROJ_DEBUG_LEVEL > 3
\r
1529 fprintf(stderr, "DIGFileSnarkProj:CreateApplicationHeader\n");
\r
1536 // create main header node
1537 ApplicationHeaderElement = Document->createElement(AppHeaderXMLStr);
1541 // there is no attributes
1547 const char* Comment;
1549 AppComment.Get(&Comment);
1551 if(Comment != NULL) {
1553 // create comments node
1554 DOMElement* Comm = Document->createElement(CommentsXMLStr);
1556 // create comments text node
1557 tmpXMLStr = XMLString::transcode(Comment);
1558 DOMText* CommentText = Document->createTextNode(tmpXMLStr);
1560 Comm->appendChild(CommentText);
1562 // append comments to appication header
1563 ApplicationHeaderElement->appendChild(Comm);
1569 // create geometry node
1570 DOMElement* Geom = Document->createElement(GeomHeaderXMLStr);
1572 if(Geometry->GeometryType == GT_DIVERGENT) {
1574 DOMElement* Diver = Document->createElement(DivergentXMLStr);
1577 sprintf(valStr, "%f", Geometry->Radius);
1578 tmpXMLStr = XMLString::transcode(valStr);
1579 Diver->setAttribute(RadiusXMLStr, tmpXMLStr);
1582 // define source detector distanse
1583 sprintf(valStr, "%f", Geometry->SrcDetDistance);
1584 tmpXMLStr = XMLString::transcode(valStr);
1585 Diver->setAttribute(SourceDetXMLStr, tmpXMLStr);
1588 // define detector type
1589 DOMElement* DetT = Document->createElement(DetTypeXMLStr);
1591 // create detector type text node
1592 if(Geometry->DetectorType == DT_TANGENT) {
1593 tmpXMLStr = XMLString::transcode("tangent");
1596 tmpXMLStr = XMLString::transcode("arc");
1599 DOMText* DetTText = Document->createTextNode(tmpXMLStr);
1601 DetT->appendChild(DetTText);
1603 // append detector type to divergent
1604 Diver->appendChild(DetT);
1606 // append divergent to geometry
1607 Geom->appendChild(Diver);
1611 DOMElement* Para = Document->createElement(ParallelXMLStr);
1613 // define detector type
1614 DOMElement* DetT = Document->createElement(DetTypeXMLStr);
1616 if(Geometry->DetectorType == DT_UNIFORM) {
1617 tmpXMLStr = XMLString::transcode("uniform");
1620 tmpXMLStr = XMLString::transcode("variable");
1623 DOMText* DetTText = Document->createTextNode(tmpXMLStr);
1625 DetT->appendChild(DetTText);
1627 // append detector type to parallel
1628 Para->appendChild(DetT);
1631 // define projection type
1632 DOMElement* ProjT = Document->createElement(ProjTypeXMLStr);
1634 if(Geometry->ProjType == PT_STRIP) {
1635 tmpXMLStr = XMLString::transcode("strip");
1638 tmpXMLStr = XMLString::transcode("line");
1641 DOMText* ProjTText = Document->createTextNode(tmpXMLStr);
1643 ProjT->appendChild(ProjTText);
1645 // append projection type to parallel
1646 Para->appendChild(ProjT);
1648 // append parallel to geometry
1649 Geom->appendChild(Para);
1652 // append geometry to application header
1653 ApplicationHeaderElement->appendChild(Geom);
1658 // create noise node
1659 DOMElement* Nois = Document->createElement(NoiseHeaderXMLStr);
1662 DOMElement* Quan = Document->createElement(QuantumXMLStr);
1665 sprintf(valStr, "%f", Noise.QuantumMean);
1666 tmpXMLStr = XMLString::transcode(valStr);
1667 Quan->setAttribute(MeanXMLStr, tmpXMLStr);
1670 // define calibration
1671 sprintf(valStr, "%f", Noise.QuantumCalibration);
1672 tmpXMLStr = XMLString::transcode(valStr);
1673 Quan->setAttribute(CalibMeasXMLStr, tmpXMLStr);
1677 sprintf(valStr, "%i", Noise.QuantumGantry);
1678 tmpXMLStr = XMLString::transcode(valStr);
1679 Quan->setAttribute(GantryXMLStr, tmpXMLStr);
1682 // append quantum to noise
1683 Nois->appendChild(Quan);
1688 DOMElement* Scat = Document->createElement(ScatterXMLStr);
1691 sprintf(valStr, "%f", Noise.ScatterPeak);
1692 tmpXMLStr = XMLString::transcode(valStr);
1693 Scat->setAttribute(PeakXMLStr, tmpXMLStr);
1697 sprintf(valStr, "%f", Noise.ScatterWidth);
1698 tmpXMLStr = XMLString::transcode(valStr);
1699 Scat->setAttribute(WidthXMLStr, tmpXMLStr);
1702 // append scatter to noise
1703 Nois->appendChild(Scat);
1708 DOMElement* Add = Document->createElement(AdditiveXMLStr);
1711 sprintf(valStr, "%f", Noise.AdditiveMean);
1712 tmpXMLStr = XMLString::transcode(valStr);
1713 Add->setAttribute(MeanXMLStr, tmpXMLStr);
1716 // define standard deviation
1717 sprintf(valStr, "%f", Noise.AdditiveStdDev);
1718 tmpXMLStr = XMLString::transcode(valStr);
1719 Add->setAttribute(StdDevXMLStr, tmpXMLStr);
1722 // append additive to noise
1723 Nois->appendChild(Add);
1728 DOMElement* Mul = Document->createElement(MultipXMLStr);
1731 sprintf(valStr, "%f", Noise.MultiplicativeMean);
1732 tmpXMLStr = XMLString::transcode(valStr);
1733 Mul->setAttribute(MeanXMLStr, tmpXMLStr);
1736 // define standard deviation
1737 sprintf(valStr, "%f", Noise.MultiplicativeStdDev);
1738 tmpXMLStr = XMLString::transcode(valStr);
1739 Mul->setAttribute(StdDevXMLStr, tmpXMLStr);
1742 // append multiplicative to noise
1743 Nois->appendChild(Mul);
1746 // append noise to application header
1747 ApplicationHeaderElement->appendChild(Nois);
1752 if(Spectrum == NULL) {
1753 return -2; // undefined spectrum
1756 // create spectrum node
1757 DOMElement* Spec = Document->createElement(SpectrumHeaderXMLStr);
1759 // define number of energies
1760 tmpXMLStr = new XMLCh[5];
1761 XMLString::binToText(Spectrum->NumberOfEnergies, tmpXMLStr, 4, 10);
1762 Spec->setAttribute(NumOfEnerXMLStr, tmpXMLStr);
1765 for(unsigned int i = 0; i < Spectrum->NumberOfEnergies; i++) {
1767 // create energy level node
1768 DOMElement* EnerL = Document->createElement(EnergyLevelXMLStr);
1771 tmpXMLStr = new XMLCh[5];
1772 XMLString::binToText(Spectrum->energy[i], tmpXMLStr, 4, 10);
1773 EnerL->setAttribute(EnergyXMLStr, tmpXMLStr);
1777 sprintf(valStr, "%f", Spectrum->ratio[i]);
1778 tmpXMLStr = XMLString::transcode(valStr);
1779 EnerL->setAttribute(RatioXMLStr, tmpXMLStr);
1782 // define background
1783 sprintf(valStr, "%f", Spectrum->background[i]);
1784 tmpXMLStr = XMLString::transcode(valStr);
1785 EnerL->setAttribute(BackgroundXMLStr, tmpXMLStr);
1788 // append energy level to spectrum
1789 Spec->appendChild(EnerL);
1793 // append spectrum to application header
1794 ApplicationHeaderElement->appendChild(Spec);
1796 // append application header to root
1797 RootElement->appendChild(ApplicationHeaderElement);