doc/bouml/bbtkk/152962.bodies

   1 class bbfy
   2 !!!202626.cpp!!!        bbfy(in filename : std::string, in package : std::string = "PACKAGE_NAME", in output_path : std::string = "", in verbose : bool = false)
   3   mIsWidget = false;
   4
   5   mFilename = filename;
   6   mPackage = package;
   7   mNamespace = "bb" + mPackage;
   8
   9   mOutputPath = output_path;
  10   mVerbose = verbose;
  11
  12   CreateBlackBox();
  13 !!!202754.cpp!!!        CreateBlackBox() : void
  14   // Parse XML input file
  15   ParseXML();
  16   // Create output files
  17   CreateHeader();
  18   CreateCode();
  19 !!!202882.cpp!!!        ParseXML() : void
  20   XMLResults* res = new XMLResults;
  21   XMLNode BB = XMLNode::parseFile(mFilename.c_str(),"blackbox",res);
  22
  23   if ( res->error != eXMLErrorNone )
  24     {
  25       std::ostringstream str;
  26       str << XMLNode::getError(res->error);
  27       str << " [line " << res->nLine << ", col "<<res->nColumn<<"]";
  28       delete res;
  29       throw bbfyException(str.str());
  30     }
  31   delete res;
  32
  33   // Name
  34   if (!BB.isAttributeSet("name"))
  35     {
  36       throw bbfyException("Error : <blackbox> tag : no 'name' attribute found (mandatory)");
  37     }
  38   mName = BB.getAttribute("name");
  39
  40   if (mVerbose) std::cout << "* Creating BlackBox '"<<mName<<"'"<<std::endl;
  41
  42   // Type
  43   mGeneric = false;
  44   mType = STD;
  45
  46
  47   if (BB.isAttributeSet("type"))
  48     {
  49       std::string bbtype = BB.getAttribute("type");
  50       if (bbtype=="standard")
  51         {
  52           mGeneric = false;
  53           mType = STD;
  54         }
  55       else if (bbtype==itkImageToImageFilterString)
  56         {
  57           mType = itkImageToImageFilter;
  58           // Looks for <itkparent> tag
  59           if (!BB.nChildNode("itkparent"))
  60             {
  61               throw bbfyException("Error : blackbox type '"+itkImageToImageFilterString+"' but no <itkparent> tag found (mandatory)");
  62             }
  63           bbtk::GetTextOrClear(BB.getChildNode("itkparent"),mItkParent);
  64           //
  65           mGeneric = false;
  66           if (BB.isAttributeSet("generic")) mGeneric=true;
  67         }
  68       else if (bbtype == vtkImageAlgorithmString)
  69         {
  70           mType = vtkImageAlgorithm;
  71           // Looks for <vtkobject> tag
  72           if (!BB.nChildNode("vtkobject"))
  73             {
  74               throw bbfyException("Error : blackbox type '"
  75                                   +vtkImageAlgorithmString
  76                                   +"' but no <vtkobject> tag found (mandatory)");
  77             }
  78           bbtk::GetTextOrClear(BB.getChildNode("vtkobject"),mVtkObject);
  79           //
  80         }
  81     else if (bbtype == vtkPolyDataAlgorithmString )
  82         {
  83           mType = vtkPolyDataAlgorithm;
  84           // Looks for <vtkobject> tag
  85           if (!BB.nChildNode("vtkobject"))
  86             {
  87               throw bbfyException("Error : blackbox type '"
  88                                   +vtkPolyDataAlgorithmString
  89                                   +"' but no <vtkobject> tag found (mandatory)");
  90             }
  91           bbtk::GetTextOrClear(BB.getChildNode("vtkobject"),mVtkObject);
  92           //
  93         }
  94      else
  95         {
  96           std::string mess("Error : blackbox type '");
  97           mess += bbtype;
  98           mess += "' unknown. Known types :";
  99           mess += "'" + itkImageToImageFilterString + "' ";
 100           mess += "'" + vtkImageAlgorithmString + "' ";
 101           mess += "'" + vtkPolyDataAlgorithmString + "' ";
 102           throw bbfyException(mess);
 103         }
 104     }
 105
 106   // Is a widget box ?
 107   if (BB.isAttributeSet("widget"))
 108     {
 109       mIsWidget = true;
 110       mParentBlackBox = "bbtk::WxBlackBox";
 111       mInclude.push_back("bbtkWxBlackBox.h");
 112     }
 113   else
 114     {
 115       mIsWidget = false;
 116       mParentBlackBox = "bbtk::AtomicBlackBox";
 117       mInclude.push_back("bbtkAtomicBlackBox.h");
 118     }
 119
 120   // Author
 121   int i,j;
 122   for (i=0,j=0; i<BB.nChildNode("author"); i++)
 123     {
 124       std::string val;
 125       bbtk::GetTextOrClear(BB.getChildNode("author",&j),val);
 126       mAuthor += val;
 127     }
 128
 129   // Description
 130   for (i=0,j=0; i<BB.nChildNode("description"); i++)
 131     {
 132       std::string val;
 133       bbtk::GetTextOrClear(BB.getChildNode("description",&j),val);
 134       mDescription += val;
 135     }
 136
 137   // Category
 138   for (i=0,j=0; i<BB.nChildNode("category"); i++)
 139     {
 140       std::string val;
 141       bbtk::GetTextOrClear(BB.getChildNode("category",&j),val);
 142       mCategory += val;
 143     }
 144
 145   // Namespace
 146   if (BB.nChildNode("namespace"))
 147     {
 148       bbtk::GetTextOrClear(BB.getChildNode("namespace"),mNamespace);
 149     }
 150
 151   // UserSetDefaultValues body
 152   if (BB.nChildNode("defaultValues"))
 153     {
 154       bbtk::GetTextOrClear(BB.getChildNode("defaultValues"),
 155                            mUserSetDefaultValues);
 156     }
 157
 158   // UserInitializeProcessing body
 159   if (BB.nChildNode("initializeProcessing"))
 160     {
 161       bbtk::GetTextOrClear(BB.getChildNode("initializeProcessing"),
 162                            mUserInitializeProcessing);
 163     }
 164
 165  // UserFinalizeProcessing body
 166   if (BB.nChildNode("finalizeProcessing"))
 167     {
 168       bbtk::GetTextOrClear(BB.getChildNode("finalizeProcessing"),
 169                            mUserFinalizeProcessing);
 170     }
 171
 172
 173
 174      // Template parameters
 175   //  mNbTemplateParam = BB.nChildNode("template");
 176
 177   if ( BB.nChildNode("template") > 0)
 178     {
 179       mTemplateDeclaration = "<";
 180       mTemplateImplementation = "<";
 181
 182       for (i=0,j=0; i<BB.nChildNode("template")-1; i++)
 183         {
 184           mTemplateDeclaration += "class ";
 185           std::string val;
 186           bbtk::GetTextOrClear(BB.getChildNode("template",&j),val);
 187           mTemplateDeclaration += val;
 188           mTemplateDeclaration +=  ",";
 189           mTemplateImplementation += val;
 190           mTemplateImplementation +=  ",";
 191           mTemplateParam.push_back(val);
 192         }
 193       mTemplateDeclaration += "class ";
 194       std::string val;
 195       bbtk::GetTextOrClear(BB.getChildNode("template",&j),val);
 196       mTemplateDeclaration += val;
 197       mTemplateDeclaration +=  ">";
 198       mTemplateImplementation += val;
 199       mTemplateImplementation +=  ">";
 200       mTemplateParam.push_back(val);
 201     }
 202
 203   // Includes
 204   for (i=0,j=0; i<BB.nChildNode("include"); i++)
 205     {
 206       std::string val;
 207       bbtk::GetTextOrClear(BB.getChildNode("include",&j),val);
 208       mInclude.push_back(val);
 209     }
 210   // Typedef
 211   for (i=0,j=0; i<BB.nChildNode("typedef"); i++)
 212     {
 213       std::string val;
 214       bbtk::GetTextOrClear(BB.getChildNode("typedef",&j),val);
 215       mTypedef.push_back(val);
 216     }
 217
 218   // Inputs
 219   for (i=0,j=0; i<BB.nChildNode("input"); i++)
 220     {
 221       IO io;
 222       XMLNode n = BB.getChildNode("input",&j);
 223       if (!n.isAttributeSet("name"))
 224         {
 225           throw bbfyException("Error : <input> attribute 'name' not found (mandatory)");
 226         }
 227       io.name = n.getAttribute("name");
 228       if (!n.isAttributeSet("type"))
 229         {
 230           throw bbfyException("Error : <input name=\""+io.name+"\"> attribute 'type' not found (mandatory)");
 231         }
 232       io.type = n.getAttribute("type");
 233       if (!n.isAttributeSet("description"))
 234         {
 235           throw bbfyException("Error : <input name=\""+io.name+"\"> attribute 'description' not found (mandatory)");
 236         }
 237       io.descr = n.getAttribute("description");
 238
 239       if (n.isAttributeSet("special"))
 240         {
 241           io.special =  n.getAttribute("special");
 242         }
 243
 244       if (n.isAttributeSet("nature"))
 245         {
 246           io.nature =  n.getAttribute("nature");
 247         }
 248
 249       if (n.isAttributeSet("generic_type"))
 250         {
 251           io.generic_type =  n.getAttribute("generic_type");
 252         }
 253
 254       mInput.push_back(io);
 255     }
 256
 257   // Outputs
 258   for (i=0,j=0; i<BB.nChildNode("output"); i++)
 259     {
 260       IO io;
 261       XMLNode n = BB.getChildNode("output",&j);
 262       if (!n.isAttributeSet("name"))
 263         {
 264           throw bbfyException("Error : <output> attribute 'name' not found (mandatory)");
 265         }
 266       io.name = n.getAttribute("name");
 267       if (!n.isAttributeSet("type"))
 268         {
 269           throw bbfyException("Error : <output name=\""+io.name+"\"> attribute 'type' not found (mandatory)");
 270         }
 271       io.type = n.getAttribute("type");
 272       if (!n.isAttributeSet("description"))
 273         {
 274           throw bbfyException("Error : <output name=\""+io.name+"\"> attribute 'description' not found (mandatory)");
 275         }
 276       io.descr = n.getAttribute("description");
 277
 278       if (n.isAttributeSet("special"))
 279         {
 280           io.special =  n.getAttribute("special");
 281         }
 282
 283       if (n.isAttributeSet("nature"))
 284         {
 285           io.nature =  n.getAttribute("nature");
 286         }
 287
 288       if (n.isAttributeSet("generic_type"))
 289         {
 290           io.generic_type =  n.getAttribute("generic_type");
 291         }
 292
 293       mOutput.push_back(io);
 294     }
 295
 296
 297   // Process
 298   // process tag given ?
 299    if (BB.nChildNode("process"))
 300      {
 301        bbtk::GetTextOrClear(BB.getChildNode("process"),mProcess);
 302      }
 303
 304   // CreateWidget
 305   // createwidget tag given ?
 306    if (BB.nChildNode("createwidget"))
 307      {
 308        bbtk::GetTextOrClear(BB.getChildNode("createwidget"),mCreateWidget);
 309      }
 310
 311
 312
 313
 314
 315
 316
 317    // OBSOLETE/UNSUPPORTED TAGS
 318   // WARN IF OBSOLETE TAGS PROVIDED
 319   if (BB.nChildNode("constructor"))
 320     {
 321       std::cout << "WARNING !!! The tag <constructor> is obsolete !!"<<std::endl;
 322     }
 323   if (BB.nChildNode("destructor"))
 324     {
 325       std::cout << "WARNING !!! The tag <destructor> is obsolete !!"<<std::endl;
 326     }
 327   if (BB.nChildNode("copy_constructor"))
 328     {
 329       std::cout << "WARNING !!! The tag <copy_constructor> is obsolete !!"<<std::endl;
 330     }
 331
 332
 333
 334 !!!203010.cpp!!!        CreateHeader() : void
 335
 336   mHName = "bb";
 337   mHName += mPackage;
 338   mHName += mName;
 339   mHName += ".h";
 340   if (mVerbose) std::cout << " - Creating header '"<<mHName<<"'"<<std::endl;
 341   std::string fullname = mOutputPath + mHName;
 342   mFile.open(fullname.c_str());
 343   if (!mFile.good())
 344     {
 345       std::string mess("Error : could not open file \"");
 346       mess += fullname + "\"";
 347       throw bbfyException(mess);
 348     }
 349
 350   // If is widget
 351   if (mIsWidget)
 352     {
 353       mFile << "#ifdef _USE_WXWIDGETS_\n";
 354     }
 355
 356   // Prevent multiple inclusions
 357   std::string included("__bb");
 358   included += mPackage + mName + "_h_INCLUDED__";
 359   mFile << "#ifndef " << included <<"\n";
 360   mFile << "#define " << included <<"\n";
 361
 362   // Includes
 363   mFile << "#include \"bb" << mPackage << "_EXPORT.h\"\n";
 364   std::vector<std::string>::iterator i;
 365   for (i=mInclude.begin(); i!=mInclude.end(); ++i)
 366     {
 367       mFile << "#include \"" << *i <<"\"\n";
 368     }
 369   if (mGeneric) mFile << "#include \"bbitkImage.h\"\n";
 370   mFile << "\n";
 371
 372   if (mType == itkImageToImageFilter )
 373     {
 374       mFile << "#include \"bbtkItkBlackBoxMacros.h\"\n";
 375     }
 376   else if ( (mType == vtkImageAlgorithm) ||
 377             (mType == vtkPolyDataAlgorithm) )
 378     {
 379       mFile << "#include \"bbtkVtkBlackBoxMacros.h\"\n";
 380     }
 381   // Namespace
 382   BeginNamespace();
 383
 384   // Interface
 385
 386   // If it is a template class
 387   if (mTemplateParam.size() > 0)
 388     {
 389       mFile << "template " << mTemplateDeclaration <<"\n";
 390     }
 391
 392   // Class declaration and parents
 393   mFile << "class bb"<<mPackage<<"_EXPORT "<<mName<<"\n";
 394   mFile << " : \n";
 395
 396   /*
 397   if (mBB.nChildNode("inherits"))
 398     {
 399       mFile << ",\n";
 400       for (i=0,j=0; i<mBB.nChildNode("inherits")-1; i++)
 401         {
 402           mFile << "   public "
 403                 << mBB.getChildNode("inherits",&j).getText()
 404                 << ",\n";
 405         }
 406       mFile << "   public "
 407             << mBB.getChildNode("Inherits",&j).getText()
 408             <<"\n";
 409     }
 410   */
 411
 412   if (mType == itkImageToImageFilter )
 413     {
 414       mFile << "   public " << mItkParent <<",\n";
 415     }
 416
 417   mFile << "   public "<<mParentBlackBox << "\n";
 418
 419   mFile << "{\n";
 420
 421   // Interface
 422
 423   // ITK
 424   if (mType == itkImageToImageFilter)
 425     {
 426       mFile << "  BBTK_ITK_BLACK_BOX_INTERFACE("
 427             << mName << ","
 428             << mParentBlackBox << ","
 429             << mItkParent
 430             << ");\n";
 431     }
 432   // VTK
 433   else if ( (mType == vtkImageAlgorithm) ||
 434        (mType == vtkPolyDataAlgorithm) )
 435     {
 436       mFile << "  BBTK_VTK_BLACK_BOX_INTERFACE("
 437             << mName << ","
 438             << mParentBlackBox << ","
 439             << mVtkObject
 440             << ");\n";
 441     }
 442
 443   // Default
 444   else
 445     {
 446       mFile << "  BBTK_BLACK_BOX_INTERFACE("
 447             << mName << ","
 448             << mParentBlackBox << ");\n";
 449     }
 450
 451   for (i=mTypedef.begin(); i!=mTypedef.end(); ++i)
 452     {
 453       mFile << *i <<"\n";
 454     }
 455
 456
 457
 458   // Inputs
 459   std::vector<IO>::iterator ioi;
 460   for (ioi=mInput.begin(); ioi!=mInput.end(); ++ioi)
 461     {
 462       if (ioi->special=="")
 463         {
 464           mFile << "  BBTK_DECLARE_INPUT("
 465                 << ioi->name
 466                 << ","
 467                 << ioi->type
 468                 << ");\n";
 469         }
 470       else if (ioi->special=="itk input")
 471         {
 472           mFile << "  BBTK_DECLARE_ITK_INPUT("
 473                 << ioi->name
 474                 << ","
 475                 << ioi->type
 476                 << ");\n";
 477         }
 478       else if (ioi->special=="vtk input")
 479         {
 480           if (mType == vtkImageAlgorithm) {
 481           mFile << "  BBTK_DECLARE_VTK_IMAGE_ALGORITHM_INPUT("
 482                 << ioi->name
 483                 << ","
 484                 << ioi->type
 485                 << ");\n";
 486           }
 487           else if (mType == vtkPolyDataAlgorithm) {
 488           mFile << "  BBTK_DECLARE_POLY_DATA_ALGORITHM_INPUT("
 489                 << ioi->name
 490                 << ","
 491                 << ioi->type
 492                 << ");\n";
 493           }
 494         }
 495       else if (ioi->special=="itk parameter")
 496         {
 497           mFile << "  BBTK_DECLARE_ITK_PARAM("
 498                 << ioi->name
 499                 << ","
 500                 << ioi->type
 501                 << ");\n";
 502         }
 503       else if (ioi->special=="vtk parameter")
 504         {
 505           mFile << "  BBTK_DECLARE_VTK_PARAM("
 506                 << ioi->name
 507                 << ","
 508                 << ioi->type
 509                 << ");\n";
 510         }
 511       else
 512         {
 513           std::string mess("Error : input '");
 514           mess += ioi->name;
 515           mess += "', 'special' attribute '";
 516           mess += ioi->special;
 517           mess += "' unknown";
 518           throw bbfyException(mess);
 519         }
 520     }
 521
 522   // Outputs
 523   for (ioi=mOutput.begin(); ioi!=mOutput.end(); ++ioi)
 524     {
 525       if (ioi->special=="")
 526         {
 527           mFile << "  BBTK_DECLARE_OUTPUT("
 528                 << ioi->name
 529                 << ","
 530                 << ioi->type
 531                 << ");\n";
 532         }
 533       else if (ioi->special=="itk output")
 534         {
 535           mFile << "  BBTK_DECLARE_ITK_OUTPUT("
 536                 << ioi->name
 537                 << ","
 538                 << ioi->type
 539                 << ");\n";
 540         }
 541       else if (ioi->special=="vtk output")
 542         {
 543           mFile << "  BBTK_DECLARE_VTK_OUTPUT("
 544                 << ioi->name
 545                 << ","
 546                 << ioi->type
 547                 << ");\n";
 548         }
 549       else
 550         {
 551           std::string mess("Error : output '");
 552           mess += ioi->name;
 553           mess += "', 'special' attribute '";
 554           mess += ioi->special;
 555           mess += "' unknown";
 556           throw bbfyException(mess);
 557         }
 558     }
 559
 560   // Process
 561   if ((mType == STD)||(mProcess.size()))
 562     {
 563       mFile << "  BBTK_PROCESS(Process);\n" ;
 564       mFile << "  void Process();\n";
 565     }
 566   else if (mType == itkImageToImageFilter)
 567     {
 568       mFile << "  BBTK_ITK_PROCESS();\n" ;
 569     }
 570   else if ((mType == vtkImageAlgorithm) ||
 571            (mType == vtkPolyDataAlgorithm) )
 572
 573     {
 574       mFile << "  BBTK_VTK_PROCESS();\n" ;
 575     }
 576
 577   // CreateWidget
 578   if (mIsWidget)
 579     {
 580        mFile << "  BBTK_CREATE_WIDGET(CreateWidget);\n" ;
 581        mFile << "  void CreateWidget(wxWindow*);\n";
 582     }
 583
 584
 585   // EO black box declaration
 586   mFile << "};\n\n";
 587
 588   // BO black box description
 589   if (mTemplateParam.size()==0)
 590     {
 591       mFile << "BBTK_BEGIN_DESCRIBE_BLACK_BOX("
 592             << mName << ","
 593             << mParentBlackBox << ");\n";
 594       mFile << "BBTK_NAME(\"" << mName <<"\");\n";
 595     }
 596   else if (mTemplateParam.size()==1)
 597     {
 598       mFile << "BBTK_BEGIN_DESCRIBE_TEMPLATE_BLACK_BOX("
 599             << mName //<< ","
 600         //<< mParentBlackBox //<< ","
 601         //   << mTemplateParam[0]
 602             << ");\n";
 603       mFile << "BBTK_NAME(\"" << mName
 604             << "<\"+bbtk::TypeName<" << mTemplateParam[0]
 605             <<">()+\">\");\n";
 606     }
 607  else
 608     {
 609       throw bbfyException("template bb with more than 1 templ param not impl");
 610     }
 611
 612   // Author
 613   mFile << "BBTK_AUTHOR(\""<<mAuthor<< "\");\n";
 614
 615   // Description
 616   mFile << "BBTK_DESCRIPTION(\""<<mDescription<< "\");\n";
 617
 618   // Category
 619   mFile << "BBTK_CATEGORY(\""<<mCategory<< "\");\n";
 620
 621   for (i=mTypedef.begin(); i!=mTypedef.end(); ++i)
 622     {
 623       mFile << *i <<"\n";
 624     }
 625
 626   // Inputs
 627   for (ioi=mInput.begin(); ioi!=mInput.end(); ++ioi)
 628     {
 629       if (mTemplateParam.size()>0)
 630         {
 631           mFile << "BBTK_TEMPLATE_INPUT(";
 632         }
 633       else
 634         {
 635           mFile << "BBTK_INPUT(";
 636         }
 637       mFile << mName << "," << ioi->name << ",\""
 638             << ioi->descr << "\"," <<  ioi->type << ",\""
 639             << ioi->nature<<"\");\n";
 640     }
 641
 642   // Outputs
 643   for (ioi=mOutput.begin(); ioi!=mOutput.end(); ++ioi)
 644     {
 645       if (mTemplateParam.size()>0)
 646         {
 647           mFile << "BBTK_TEMPLATE_OUTPUT(";
 648         }
 649       else
 650         {
 651           mFile << "BBTK_OUTPUT(";
 652         }
 653       mFile << mName << "," << ioi->name << ",\""
 654             << ioi->descr << "\"," <<  ioi->type << ",\""
 655             << ioi->nature<<"\");\n";
 656     }
 657
 658   // EO black box description
 659   if (mTemplateParam.size()==0)
 660     {
 661       mFile << "BBTK_END_DESCRIBE_BLACK_BOX("
 662             << mName << ");\n";
 663     }
 664   else if (mTemplateParam.size()==1)
 665     {
 666       mFile << "BBTK_END_DESCRIBE_TEMPLATE_BLACK_BOX("
 667             << mName //<< ","
 668         // << mTemplateParam[0]
 669             << ");\n";
 670     }
 671   else
 672     {
 673       throw bbfyException("template bb with more than 1 templ param not impl");
 674
 675     }
 676
 677   // Untemplatization of itk filters
 678   if ( mGeneric )
 679     {
 680       WriteGenericITKFilterHeader();
 681     }
 682
 683
 684   // EO namespace
 685   EndNamespace();
 686
 687   // Prevent multiple inclusions
 688   mFile << "#endif // " << included <<"\n";
 689   // If is widget
 690   if (mIsWidget)
 691     {
 692       mFile << "#endif // _USE_WXWIDGETS_\n";
 693     }
 694
 695   // EOF
 696   mFile << "\n";
 697
 698   mFile.close();
 699 !!!203138.cpp!!!        CreateCode() : void
 700   mCxxName = "bb";
 701   mCxxName += mPackage;
 702   mCxxName += mName;
 703   mCxxName += ".cxx";
 704   if (mVerbose) std::cout << " - Creating code   '"<<mCxxName<<"'"<<std::endl;
 705   std::string fullname = mOutputPath + mCxxName;
 706   mFile.open(fullname.c_str());
 707   if (!mFile.good())
 708     {
 709       std::string mess("Error : could not open file \"");
 710       mess += fullname;
 711       mess += "\"";
 712       throw bbfyException(mess);
 713     }
 714
 715   // Includes
 716   // Header of the class
 717   mFile << "#include \"" << mHName << "\"\n";
 718
 719   // Include Package header
 720   mFile << "#include \"bb"<<mPackage << "Package.h\"\n";
 721
 722   // BO namespace
 723   BeginNamespace();
 724
 725
 726   // Template class ?
 727   if (mTemplateParam.size()>0)
 728     {
 729       // Implementation
 730       mFile << "BBTK_BLACK_BOX_TEMPLATE_IMPLEMENTATION("
 731             << mName << ","
 732             << mParentBlackBox << ");\n";
 733
 734       if (mGeneric)
 735         {
 736           // Implementation
 737           mFile << "BBTK_BLACK_BOX_IMPLEMENTATION("
 738                 << mName << "Generic,bbtk::AtomicBlackBox);\n";
 739           // Package
 740           mFile << "BBTK_ADD_BLACK_BOX_TO_PACKAGE("
 741                 << mPackage << ","
 742                 << mName << "Generic)\n";
 743         }
 744     }
 745   else
 746     {
 747       // Non template class
 748       // Package
 749       mFile << "BBTK_ADD_BLACK_BOX_TO_PACKAGE("
 750             << mPackage << ","
 751             << mName << ")\n";
 752
 753       // Implementation
 754       mFile << "BBTK_BLACK_BOX_IMPLEMENTATION("
 755             << mName << ","
 756             << mParentBlackBox << ");\n";
 757     }
 758   // Process
 759   if ((mType == STD)||(mProcess.size()))
 760     {
 761       mFile << "void "<<mName<<"::Process()\n{\n";
 762       mFile << mProcess << "\n";
 763       mFile << "}\n";
 764     }
 765   // CreateWidget
 766   if (mIsWidget)
 767     {
 768       mFile << "void "<<mName<<"::CreateWidget(wxWindow* parent)\n{\n";
 769       mFile << mCreateWidget << "\n";
 770       mFile << "}\n";
 771     }
 772
 773
 774   // User Set Default Values
 775   mFile <<"void "<<mName<<"::bbUserSetDefaultValues()"<<std::endl;
 776   mFile << "{"<<std::endl;
 777         if ( (mType == vtkImageAlgorithm) || (mType == vtkPolyDataAlgorithm) )
 778         {
 779                 mFile << "   BBTK_VTK_SET_DEFAULT_VALUES();\n";
 780         }
 781         mFile << mUserSetDefaultValues << std::endl;
 782   mFile << "}" << std::endl;
 783
 784   // User Initialize Processing
 785   mFile <<"void "<<mName<<"::bbUserInitializeProcessing()"
 786         <<std::endl;
 787   mFile << "{"<<std::endl;
 788         if ( (mType == vtkImageAlgorithm) || (mType == vtkPolyDataAlgorithm) )
 789         {
 790                 mFile <<  "  BBTK_VTK_INITIALIZE_PROCESSING();\n";
 791         }
 792         mFile << mUserInitializeProcessing << std::endl;
 793   mFile << "}" << std::endl;
 794
 795         // User Finalize Processing
 796   mFile <<"void "<<mName<<"::bbUserFinalizeProcessing()"<<std::endl;
 797   mFile << "{"<<std::endl;
 798         if ( (mType == vtkImageAlgorithm) || (mType == vtkPolyDataAlgorithm) )
 799         {
 800                 mFile << "   BBTK_VTK_FINALIZE_PROCESSING();\n";
 801         }
 802         mFile << mUserFinalizeProcessing << std::endl;
 803   mFile << "}" << std::endl;
 804
 805
 806   // EO namespace
 807   EndNamespace();
 808
 809   mFile << "\n";
 810
 811   // EOF
 812   mFile.close();
 813
 814 !!!203266.cpp!!!        WriteGenericITKFilterHeader() : void
 815   mFile << "\n//===================================================\n";
 816   mFile << "// Generic \"untemplatized\" filter\n";
 817   mFile << "//===================================================\n";
 818
 819   // Class declaration and parents
 820   mFile << "class /*BBTK_EXPORT*/ "<<mName<<"Generic\n";
 821   mFile << " : \n";
 822   mFile << "   public bbtk::AtomicBlackBox\n";
 823   mFile << "{\n";
 824
 825   // Interface
 826   mFile << "  BBTK_BLACK_BOX_INTERFACE("
 827         << mName << "Generic,bbtk::AtomicBlackBox);\n";
 828
 829   // Inputs
 830   std::vector<IO>::iterator ioi;
 831   for (ioi=mInput.begin(); ioi!=mInput.end(); ++ioi)
 832     {
 833       mFile << "  BBTK_DECLARE_INPUT("
 834             << ioi->name
 835             << ","
 836             << ioi->generic_type
 837             << ");\n";
 838     }
 839
 840   // Outputs
 841   for (ioi=mOutput.begin(); ioi!=mOutput.end(); ++ioi)
 842     {
 843       mFile << "  BBTK_DECLARE_OUTPUT("
 844             << ioi->name
 845             << ","
 846             << ioi->generic_type
 847             << ");\n";
 848     }
 849
 850   // Process
 851   mFile << "  BBTK_PROCESS(ProcessSwitch);\n";
 852   mFile << "  private :\n";
 853   mFile << "    inline void ProcessSwitch();\n";
 854   mFile << "    template <class T, unsigned int D> void Process();\n";
 855   // EO black box declaration
 856   mFile << "};\n\n";
 857
 858
 859
 860   // BO black box description
 861   mFile << "BBTK_BEGIN_DESCRIBE_BLACK_BOX("
 862         << mName << "Generic,bbtk::AtomicBlackBox);\n";
 863   mFile << "BBTK_NAME(\"" << mName <<"\");\n";
 864
 865   // Author
 866   mFile << "BBTK_AUTHOR(\""<<mAuthor<< "\");\n";
 867
 868   // Description
 869   mFile << "BBTK_DESCRIPTION(\""<<mDescription<< "\");\n";
 870
 871   // Inputs
 872   for (ioi=mInput.begin(); ioi!=mInput.end(); ++ioi)
 873     {
 874       mFile << "BBTK_INPUT(";
 875       mFile << mName << "Generic," << ioi->name << ",\""
 876             << ioi->descr << "\"," <<  ioi->generic_type <<");\n";
 877     }
 878
 879   // Outputs
 880   for (ioi=mOutput.begin(); ioi!=mOutput.end(); ++ioi)
 881     {
 882       mFile << "BBTK_OUTPUT(";
 883       mFile << mName << "Generic," << ioi->name << ",\""
 884             << ioi->descr << "\"," <<  ioi->generic_type <<");\n";
 885     }
 886
 887   // EO black box description
 888   mFile << "BBTK_END_DESCRIBE_BLACK_BOX("
 889         << mName << "Generic);\n";
 890
 891
 892   //=================================================================
 893   // ProcessSwitch implementation
 894   mFile << "void "<< mName <<"Generic::ProcessSwitch()\n"
 895         << "{\n"
 896         << "CALL_FOR_ALL_TYPES_AND_DIM(bbGetInputIn()->GetType(),\n"
 897         << "                           bbGetInputIn()->GetDimension(),\n"
 898         << "                           Process);\n"
 899         << "}\n";
 900   //=================================================================
 901
 902
 903   //=================================================================
 904   // Template process implementation
 905   mFile << "template <class T, unsigned int D>\n"
 906         << "void "<<mName<<"Generic::Process()\n"
 907         << "{\n"
 908         << "  bbtkDebugMessageInc(\"Kernel\",9,\n"
 909         << "      \""<<mName
 910         << "Generic::Process<\"<<TypeName<T>()<<\",\"<<D<<\">()\"<<std::endl);\n"
 911
 912         << "  typedef itk::Image<T,D> ImageType;\n"
 913         << "  typedef "<<mName<<"<ImageType> FilterType;\n"
 914
 915         << "  FilterType* f = new FilterType(\"Temp\");\n"
 916
 917         << "  f->bbSetInputIn( this->bbGetInputIn()->GetImage<T,D>() );\n";
 918
 919   for (ioi=mInput.begin(); ioi!=mInput.end(); ++ioi)
 920     {
 921       if (ioi->name == "In") continue;
 922       mFile << "  f->bbSetInput"<<ioi->name<<" ( this->bbGetInput"
 923             << ioi->name << "() );\n";
 924     }
 925
 926   mFile << "  f->bbUpdate();\n"
 927         << "  this->bbSetOutputOut( new itkImage( f->bbGetOutputOut() ) );\n"
 928         << "  f->UnRegister();\n"
 929         << "  bbtkDebugDecTab(\"Kernel\",9);\n"
 930         << "}\n\n";
 931   //=================================================================
 932
 933
 934 !!!203394.cpp!!!        BeginNamespace() : void
 935   //  if (mIsInNamespace)
 936   // {
 937   mFile << "namespace "<<mNamespace <<"\n{\n\n";
 938   //  }
 939 !!!203522.cpp!!!        EndNamespace() : void
 940   // if (mIsInNamespace)
 941   //  {
 942   mFile << "}\n// EO namespace "<<mNamespace<<"\n\n";
 943   //  }