lib/kernel_ManagerContour_NDimensions/ParserOsirix/OsirixParser.cxx

   1
   2 //----------------------------------------------------------------------------------------------------------------
   3 // Class definition include
   4 //----------------------------------------------------------------------------------------------------------------
   5 #include "OsirixParser.h"
   6
   7 #include <stdio.h>
   8
   9
  10 OsirixParser::OsirixParser(std::string xsdfile, double* spacing, int* extent)
  11 {
  12         schema=xsdfile;
  13
  14         OSIRIX_DICT = "dict";
  15         OSIRIX_KEY = "key";
  16         OSIRIX_IMAGES = "Images";
  17         OSIRIX_ARRAY = "array";
  18         OSIRIX_IMAGEINDEX = "ImageIndex";
  19         OSIRIX_INTEGER = "integer";
  20         OSIRIX_NUMBEROFROIS = "NumberOfROIs";
  21         OSIRIX_ROIS = "ROIs";
  22         OSIRIX_POINT_MM = "Point_mm";
  23         OSIRIX_POINT_PX = "Point_px";
  24         OSIRIX_STRING = "string";
  25
  26         if(spacing != NULL){
  27                 _spacing[0] = spacing[0];
  28                 _spacing[1] = spacing[1];
  29                 _spacing[2] = spacing[2];
  30         }else{
  31                 _spacing[0] = 1;
  32                 _spacing[1] = 1;
  33                 _spacing[2] = 1;
  34         }
  35
  36         if(extent != NULL){
  37                 _extent[0] = extent[0];
  38                 _extent[1] = extent[1];
  39                 _extent[2] = extent[2];
  40                 _extent[3] = extent[3];
  41                 _extent[4] = extent[4];
  42                 _extent[5] = extent[5];
  43
  44         }else{
  45                 _extent[0] = 1;
  46                 _extent[1] = 1;
  47                 _extent[2] = 1;
  48                 _extent[3] = 1;
  49                 _extent[4] = 1;
  50                 _extent[5] = 1;
  51         }
  52
  53
  54         /*HEADER*/
  55         CREACONTOUR = "--CreaContour--";
  56         CREACONTOUR_VERSION = "Version 1.0.2";
  57         CREACONTOUR_IMAGEDIMENSIONS = "ImageDimensions";
  58         CREACONTOUR_IMAGESPACING = "ImageSpacing";
  59         CREACONTOUR_NUMBEROFCONTOURS = "NumberOfContours";
  60         /*FOR EACH CONTOUR*/
  61         CREACONTOUR_INSTANT = "Instant";
  62         CREACONTOUR_TYPEMODEL = "TypeModel";
  63         CREACONTOUR_NUMBEROFCONTROLPOINTS = "NumberOfControlPoints";
  64         CREACONTOUR_TYPEVIEW = "TypeView";
  65         /*STATICCONTOURS*/
  66         CREACONTOUR_NUMBEROFCONTOURSSTATIC = "NumberOfContoursStatic";
  67
  68
  69 #ifdef WIN32
  70
  71         char currentPath[_MAX_PATH];
  72         GetModuleFileName(NULL, currentPath, _MAX_PATH);
  73         TEMPIMPORTOSIRIXFILE = currentPath;
  74
  75         TEMPIMPORTOSIRIXFILE = TEMPIMPORTOSIRIXFILE.substr(0,TEMPIMPORTOSIRIXFILE.find_last_of("\\"));
  76
  77         TEMPIMPORTOSIRIXFILE.append("\\data\\TEMPIMPORTOSIRIXFILE.roi");
  78
  79 #else
  80         TEMPIMPORTOSIRIXFILE = "./data/TEMPIMPORTOSIRIXFILE";
  81 #endif
  82
  83 }
  84 OsirixParser::~OsirixParser(){
  85
  86 }
  87
  88 int OsirixParser::ParseFile(const char* xmlfile){
  89
  90         xercesc::DOMDocument *doc;
  91
  92
  93         try {
  94             XMLPlatformUtils::Initialize();
  95         }
  96         catch (const XMLException& toCatch) {
  97             char* message = XMLString::transcode(toCatch.getMessage());
  98             cout << "Error during initialization! :\n"
  99                  << message << "\n";
 100             XMLString::release(&message);
 101             return 1;
 102         }
 103
 104         XercesDOMParser* OsirixParser = new XercesDOMParser();
 105
 106
 107                 OsirixParser->setDoNamespaces(true);
 108                 OsirixParser->setDoSchema(true);
 109                 OsirixParser->setValidationScheme(XercesDOMParser::Val_Always );
 110                 OsirixParser->setExternalNoNamespaceSchemaLocation(XMLString::transcode(schema.c_str()));
 111                 OsirixParser->setValidationSchemaFullChecking(true);
 112                 OsirixParser->setValidationConstraintFatal(true);
 113                 OsirixParser->setExitOnFirstFatalError(true);
 114
 115
 116         ErrorHandler* errHandler = (ErrorHandler*) new OsirixParserErrorHandler();
 117
 118         OsirixParser->setErrorHandler(errHandler);
 119
 120
 121         try {
 122             OsirixParser->parse(xmlfile);
 123
 124
 125                         if(OsirixParser->getErrorCount() > 0){
 126
 127                                 errorline = ((OsirixParserErrorHandler*)OsirixParser->getErrorHandler())->getErrorMsg();
 128
 129
 130                                 delete OsirixParser;
 131                                 delete errHandler;
 132                                 return -2;
 133                         }
 134
 135
 136
 137         }
 138         catch (const XMLException& toCatch) {
 139             char* message = XMLString::transcode(toCatch.getMessage());
 140             cout << "Exception message is: \n"
 141                  << message << "\n";
 142             XMLString::release(&message);
 143                         delete OsirixParser;
 144                     delete errHandler;
 145             return -1;
 146         }
 147         catch (const DOMException& toCatch) {
 148             char* message = XMLString::transcode(toCatch.msg);
 149             cout << "Exception message is: \n"
 150                  << message << "\n";
 151             XMLString::release(&message);
 152                         delete OsirixParser;
 153                         delete errHandler;
 154             return -1;
 155         }
 156         catch (...) {
 157             cout << "Unexpected Exception \n" ;
 158                         delete OsirixParser;
 159                         delete errHandler;
 160             return -1;
 161         }
 162
 163                 std::cout<<"parsing document..."<<std::endl;
 164
 165
 166         doc = OsirixParser->getDocument();
 167 //              DOMNodeList* list = doc->getChildNodes();
 168                 getUserData(doc->getDocumentElement());
 169
 170
 171                 saveCreaContoursFormat();
 172
 173         delete OsirixParser;
 174         delete errHandler;
 175
 176
 177
 178                 return 0;
 179
 180 }
 181
 182 void OsirixParser::setErrorLine(DOMNodeList* list){
 183
 184         DOMNode* node = list->item(0);
 185         this->errorline =       XMLString::transcode(node->getTextContent());
 186
 187 }
 188 DOMNode* OsirixParser::getLastNode(DOMNodeList* list){
 189
 190
 191         DOMNode* node;
 192         /*for(int i = list->getLength()-1; i >= 0 ;i--){
 193
 194                 node = list->item(i);
 195
 196                 if(node->getNodeType() == DOMNode::ELEMENT_NODE){
 197                         i = -1;
 198                 }
 199
 200         }*/
 201         node = list->item(list->getLength()-1);
 202
 203
 204
 205         if(node->getChildNodes()->getLength()>0){
 206                 return getLastNode(node->getChildNodes());
 207         }
 208         return node;
 209
 210 }
 211
 212 void OsirixParser::getUserData(DOMElement* element){
 213         parseOSIRIX_DICT(element->getElementsByTagName(XMLString::transcode(OSIRIX_DICT)));
 214 }
 215
 216 void OsirixParser::parseOSIRIX_DICT(DOMNodeList* list){
 217         int i, j;
 218         DOMNode* node, *childnode, *childnode1, *childarray;
 219         std::string point_mm, point_px, osirixinteger, imageindex, temp;
 220         DOMNodeList* childlist;
 221         point_mm = OSIRIX_POINT_MM;
 222         point_px = OSIRIX_POINT_PX;
 223         imageindex = OSIRIX_IMAGEINDEX;
 224         osirixinteger = OSIRIX_INTEGER;
 225
 226
 227
 228         for(i = 0; i < (int)(list->getLength()); i++){
 229                 node = list->item(i);
 230                 childlist = node->getChildNodes();
 231                 for(j = 0; j < (int)(childlist->getLength());j++){
 232                         childnode = childlist->item(j);
 233                         temp = XMLString::transcode(childnode->getTextContent());
 234
 235
 236                         if(point_mm.compare(temp)==0){
 237                                 childarray = childlist->item(j+2);
 238                                 //temp = XMLString::transcode(childarray->getNodeName());
 239                                 if(childarray != 0){
 240                                         parseOSIRIX_POINT_MM(childarray->getChildNodes());
 241                                 }
 242                         }else if(point_px.compare(temp)==0){
 243                                 childarray = childlist->item(j+2);
 244                                 //temp = XMLString::transcode(childarray->getNodeName());
 245                                 if(childarray != 0){
 246                                         parseOSIRIX_POINT_PX(childarray->getChildNodes());
 247                                 }
 248                         }else if(imageindex.compare(temp) == 0){
 249                                 childnode1 = childlist->item(j+2);
 250                                 if(childnode1 != NULL && osirixinteger.compare(XMLString::transcode(childnode1->getNodeName())) == 0){
 251                                         _imageindex = atoi(XMLString::transcode(childnode1->getTextContent()));
 252                                 }
 253                         }
 254                 }
 255         }
 256 }
 257
 258 void OsirixParser::parseOSIRIX_POINT_MM(DOMNodeList* list){
 259         int i, stringfound0, stringfound1;
 260         DOMNode* node;
 261         string temp, osirix_string, numx, numy, numz;
 262         vector<double>* vectorx;
 263         vector<double>* vectory;
 264         vector<double>* vectorz;
 265         vectorXYZ vectorxyz;
 266         double x, y, z;
 267
 268         vectorx = new vector<double>;
 269         vectory = new vector<double>;
 270         vectorz = new vector<double>;
 271
 272         osirix_string = OSIRIX_STRING;
 273
 274         for(i = 0; i < (int)(list->getLength()); i++){
 275                 node = list->item(i);
 276                 if(osirix_string.compare(XMLString::transcode(node->getNodeName()))==0){
 277                         temp = XMLString::transcode(node->getTextContent());
 278
 279                         stringfound0 = temp.find(",",0);
 280                         numx = temp.substr(1, stringfound0-1);
 281
 282                         stringfound1 = temp.find(",",stringfound0+1);
 283                         numy = temp.substr(stringfound0+1, stringfound1-stringfound0-1);
 284
 285                         stringfound0 = temp.find(")",stringfound1+1);
 286                         numz = temp.substr(stringfound1+1, stringfound0-stringfound1-1);
 287
 288                         x = atof(numx.c_str());
 289                         y = atof(numy.c_str());
 290                         z = atof(numz.c_str());
 291
 292                         vectorx->push_back(x);
 293                         vectory->push_back(y);
 294                         vectorz->push_back(z);
 295                 }
 296         }
 297         if(vectorx->size() > 0){
 298                 vectorxyz.push_back(*vectorx);
 299                 vectorxyz.push_back(*vectory);
 300                 vectorxyz.push_back(*vectorz);
 301                 contoursmapMM.insert(pair<int, vectorXYZ>(contoursmapMM.size(), vectorxyz));
 302         }
 303 }
 304
 305 void OsirixParser::parseOSIRIX_POINT_PX(DOMNodeList* list){
 306         int i, stringfound0, stringfound1;
 307         DOMNode* node;
 308         string temp, osirix_string, numx, numy;
 309         vector<double>* vectorx;
 310         vector<double>* vectory;
 311         vector<double>* vectorz;
 312         vectorXYZ vectorxyz;
 313         double x, y, z;
 314
 315         vectorx = new vector<double>;
 316         vectory = new vector<double>;
 317         vectorz = new vector<double>;
 318
 319         osirix_string = OSIRIX_STRING;
 320
 321         for(i = 0; i < (int)(list->getLength()); i++){
 322                 node = list->item(i);
 323                 if(osirix_string.compare(XMLString::transcode(node->getNodeName()))==0){
 324                         temp = XMLString::transcode(node->getTextContent());
 325
 326                         stringfound0 = temp.find(",",0);
 327                         numx = temp.substr(1, stringfound0-1);
 328
 329                         stringfound1 = temp.find(")",stringfound0+1);
 330                         numy = temp.substr(stringfound0+1, stringfound1-stringfound0-1);
 331
 332                         x = atof(numx.c_str());
 333                         y = atof(numy.c_str());
 334
 335                         vectorx->push_back(x);
 336                         vectory->push_back(y);
 337                         vectorz->push_back(_imageindex);
 338                 }
 339         }
 340         if(vectorx->size() > 0){
 341                 vectorxyz.push_back(*vectorx);
 342                 vectorxyz.push_back(*vectory);
 343                 vectorxyz.push_back(*vectorz);
 344                 contoursmapPX.insert(pair<int, vectorXYZ>(contoursmapPX.size(), vectorxyz));
 345         }
 346 }
 347
 348
 349
 350 void OsirixParser::getData(DOMNodeList* list, std::vector<std::string>& vect, std::string tagname){
 351
 352         for(int i = 0; i < (int)(list->getLength()); i++){
 353                 DOMNode* node = list->item(i);
 354                 if(tagname.compare(XMLString::transcode(node->getNodeName()))==0){
 355                         std::cout<<"NODENAME "<<XMLString::transcode(node->getTextContent())<<std::endl;
 356                         vect.push_back(XMLString::transcode(node->getTextContent()));
 357                 }
 358
 359         }
 360 }
 361
 362 void OsirixParser::saveCreaContoursFormat(){
 363         FILE *pFile=fopen(TEMPIMPORTOSIRIXFILE.c_str(),"w+");
 364
 365         if(pFile){
 366                 writeHeader(pFile);
 367                 writeContours(pFile);
 368                 writeContoursStatic(pFile);
 369                 fclose(pFile);
 370         }
 371 }
 372
 373 void OsirixParser::writeContoursStatic(FILE* pFile){
 374         fprintf(pFile, CREACONTOUR_IMAGEDIMENSIONS);
 375         fprintf(pFile, " %d %d %d\n", _extent[1] - _extent[0],_extent[3] - _extent[2], _extent[5] - _extent[4]);
 376         fprintf(pFile, CREACONTOUR_IMAGESPACING);
 377         fprintf(pFile, " %f %f %f\n", _spacing[0], _spacing[1], _spacing[2]);
 378         fprintf(pFile, CREACONTOUR_NUMBEROFCONTOURSSTATIC);
 379         fprintf(pFile, " 0\n");
 380 }
 381
 382 void OsirixParser::writeContours(FILE* pFile){
 383
 384         map<int, vectorXYZ>::iterator itPX;
 385         vector<double> vectx, vecty, vectz;
 386         int i, valuez;
 387         int dimz = 0, dimy = 0;
 388
 389         if(_extent != 0){
 390                 dimz = _extent[5] - _extent[4] + 1;
 391                 dimy = _extent[3] - _extent[2] + 1;
 392         }
 393
 394         /*for (itMM = contoursmapMM.begin(),  itPX = contoursmapPX.begin();
 395                         itMM != contoursmapMM.end(), itPX != contoursmapPX.end();
 396                         itMM++, itPX++ ){*/
 397         for (itPX = contoursmapPX.begin(); itPX != contoursmapPX.end(); itPX++ ){
 398
 399                 vectx = ((*itPX).second)[0];
 400                 vecty = ((*itPX).second)[1];
 401                 vectz = ((*itPX).second)[2];
 402
 403                 if(!vectz.empty()){
 404
 405                         valuez = (int) vectz[0] / _spacing[2];
 406
 407                         fprintf(pFile, CREACONTOUR_INSTANT);
 408                         fprintf(pFile, " 1 %d 1 1 1 1\n",dimz - valuez);
 409                         fprintf(pFile, CREACONTOUR_TYPEMODEL);
 410                         fprintf(pFile, " 1\n");
 411                         fprintf(pFile, CREACONTOUR_NUMBEROFCONTROLPOINTS);
 412                         fprintf(pFile, " %d\n", vectz.size());
 413                         for(i = 0; i < vectx.size(); i++){
 414                                 fprintf(pFile, "%f %f 900.00\n", vectx[i]/ _spacing[0],dimy - vecty[i]/ _spacing[1]);
 415                         }
 416                         fprintf(pFile, CREACONTOUR_TYPEVIEW);
 417                         fprintf(pFile, " 1\n");
 418
 419                 }
 420         }
 421 }
 422
 423 void OsirixParser::writeHeader(FILE* pFile){
 424
 425
 426         fprintf(pFile, CREACONTOUR);
 427         fprintf(pFile, "\n");
 428         fprintf(pFile, CREACONTOUR_VERSION);
 429         fprintf(pFile, "\n");
 430         fprintf(pFile, CREACONTOUR_IMAGEDIMENSIONS);
 431         fprintf(pFile, " %d %d %d\n", _extent[1] - _extent[0],_extent[3] - _extent[2], _extent[5] - _extent[4]);
 432         fprintf(pFile, CREACONTOUR_IMAGESPACING);
 433         fprintf(pFile, " %f %f %f\n", _spacing[0], _spacing[1], _spacing[2]);
 434         fprintf(pFile, CREACONTOUR_NUMBEROFCONTOURS);
 435         fprintf(pFile, " %d\n", contoursmapPX.size());
 436
 437
 438
 439 }
 440
 441
 442 std::string OsirixParser::getContoursFileName(){
 443         return TEMPIMPORTOSIRIXFILE;
 444 }
 445
 446 /**
 447 **      The Error Handler's interface implementation
 448 **/
 449
 450 /**
 451         ** Default Constructor
 452         **/
 453 OsirixParserErrorHandler::OsirixParserErrorHandler()
 454 : ErrorHandler(){
 455
 456
 457
 458
 459 }
 460         /**
 461         ** Desctructor by defect
 462         **/
 463 OsirixParserErrorHandler::~OsirixParserErrorHandler(){
 464 }
 465
 466 void    OsirixParserErrorHandler::warning (const SAXParseException &exc){
 467 }
 468
 469 void    OsirixParserErrorHandler::error (const SAXParseException &exc){
 470         char c[1000];
 471         errormsg = "Column ";
 472 //      errormsg +=     itoa(exc.getColumnNumber(),c,10);
 473         sprintf_s(c,"%d",(int)(exc.getColumnNumber()));
 474         errormsg +=     std::string(c);
 475
 476         errormsg += " Line ";
 477 //      errormsg +=     itoa(exc.getLineNumber(),c,10);
 478         sprintf_s(c,"%d",(int)(exc.getLineNumber()));
 479         errormsg +=     std::string(c);
 480
 481         errormsg += " ";
 482         errormsg += XMLString::transcode(exc.getMessage());
 483
 484 }
 485
 486 void    OsirixParserErrorHandler::fatalError (const SAXParseException &exc){
 487         char c[1000];
 488         errormsg = "Column ";
 489 //      errormsg +=     itoa(exc.getColumnNumber(),c,10);
 490         sprintf_s(c,"%d",(int)(exc.getColumnNumber()));
 491         errormsg +=     std::string(c);
 492
 493         errormsg += " Line ";
 494 //      errormsg +=     itoa(exc.getLineNumber(),c,10);
 495         sprintf_s(c,"%d",(int)(exc.getLineNumber()));
 496         errormsg +=     std::string(c);
 497
 498         errormsg += " ";
 499         errormsg += XMLString::transcode(exc.getMessage());
 500 }
 501
 502 void    OsirixParserErrorHandler::resetErrors (){
 503 }
 504
 505 std::string OsirixParserErrorHandler::getErrorMsg(){
 506         return this->errormsg;
 507 }