- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

# C:/AngioLocalizeNoAuto/MevisLabNoAutoReg/STUMevisApp/General/Sources/ML/STUImportRTStructure/STUImportRTStructure.cpp

    00001 /*
    00002 * Copyright (c) 2009 Stanford University, School of Medicine All rights reserved.
    00003 *
    00004 * STANFORD ACADEMIC SOFTWARE LICENSE AGREEMENT
    00005 * FOR AngioLocalize SOURCE CODE:
    00006 *
    00007 * 1.  This is a legal agreement between you, RECIPIENT, and STANFORD UNIVERSITY.
    00008 *       By accepting, receiving, and using AngioLocalize.including any accompanying information, materials or
    00009 *       manuals (Program), you are agreeing to be bound by the terms of this Agreement.
    00010 *       If you do not agree to the terms of this Agreement, promptly return the Program to the STANFORD.
    00011
    00012 * 2.  STANFORD grants to RECIPIENT a royalty-free, nonexclusive, and nontransferable license to use the Program
    00013 *       and accompanying source code furnished hereunder, upon the terms and conditions set out below.
    00014 *       documentation and/or other materials provided with the distribution.
    00015 * 3.  RECIPIENT acknowledges that the Program is a research tool still in the development stage and that
    00016 *       it is being supplied as is, without any accompanying services, support or improvements from STANFORD.
    00017 * 4.  RECIPIENT agrees to use the Program solely for internal non-commercial purposes.
    00018 * 5.  RECIPIENT may create derivatives and further transfer the Program under the following terms and conditions:
    00019 *        A) Recipient agrees to not commercially exploit the Program and agrees all uses will be for non-commercial purposes; and,
    00020 *        B) Recipient may not mark any derivatives with the title of Program and may not to use iPad mark for any derivatives; and,
    00021 *        C) Recipient agrees to mark and acknowledge all derivatives as follows: "This is a derivative work based on AngioLocalize:
    00022 *           Frameless AVM localization with 2D Digital Subtraction Angiography (DSA) and 3D Rotational Angiography (DRA) Images developed
    00023 *           by Dimitre Hristov, Lina Liu.
    00024 *        D) Recipient agrees to make all improvements, enhancements and derivatives available under
    00025 *           similar terms and conditions to the research community.
    00026 * 6.   RECIPIENT warrants that RECIPIENT will not remove or export any part of the software or Program from the United
    00027 *       States except in full compliance with all United States and other applicable laws and regulations.
    00028 * 7.  RECIPIENT will use the Program in compliance with all applicable laws, policies and regulations including, but not
    00029 *       limited to, any approvals, informed consent and patient confidentiality principles.
    00030 * 8.   RECIPIENT will indemnify, hold harmless, and defend Stanford against any claim of any kind arising out of or
    00031 *       related to the exercise of any rights granted under this Agreement or the breach of this Agreement by RECIPIENT.
    00032 * 9.  Title and copyright to the Program and any associated documentation shall at all times remain with STANFORD,
    00033 *       and RECIPIENT agrees to preserve same.
    00034 */
    00035 //----------------------------------------------------------------------------------
    00037
    00044 //----------------------------------------------------------------------------------
    00045
    00046 // Local includes
    00047 #include "STUImportRTStructure.h"
    00048 #include <iostream>
    00049
    00050 ML_START_NAMESPACE
    00051
    00052
    00054 ML_BASEOP_CLASS_SOURCE(ImportRTStructure, BaseOp);
    00055
    00056 //----------------------------------------------------------------------------------
    00058 //----------------------------------------------------------------------------------
    00059 ImportRTStructure::ImportRTStructure ()
    00060   : BaseOp(0, 0)
    00061 {
    00062   ML_TRACE_IN("ImportRTStructure::ImportRTStructure ()")
    00063
    00064   // Suppress calls of handleNotification on field changes to
    00065   // avoid side effects during initialization phase.
    00066   handleNotificationOff();
    00067
    00069   FieldContainer &fields = *getFieldContainer();
    00070
    00071   ML_CHECK(&fields);
    00072
    00074   (_outListFld = fields.addBase("outCSOList"))->setBaseValue(NULL);
    00075   _inDCMFileFld = fields.addString("inputDCMFile");
    00076   _thresholdFld = fields.addInt("threshold");
    00077   _dividendFld = fields.addInt("interpOpt1");
    00078   _divisorFld = fields.addInt("interpOpt2");
    00079   _allTagsFld = fields.addString("allTags");
    00080   _applyFld = fields.addNotify("apply");
    00081   _dcmObjFld = fields.addBase("outputBase");
    00082   _dcmObjFld->setBaseValue(NULL);
    00083
    00084
    00085   _dicmFileFld = fields.addString("dicomFile");
    00086   std::string name("tagName");
    00087   std::string value("tagValue");
    00088   for (int i = 0; i < tagFieldNum; i++) {
    00089           std::stringstream strName;
    00090           strName << name;
    00091           strName << i;
    00092
    00093           std::stringstream strValue;
    00094           strValue << value;
    00095           strValue << i;
    00096           _tagNameFld[i] = fields.addString(strName.str().c_str());
    00097       _tagValueFld[i] = fields.addString(strValue.str().c_str());
    00098   }
    00099
    00100   _getValuesFld = fields.addNotify("getValues");
    00101   _trimSpacesFld = fields.addBool("trimSpaces");
    00102   _printFld = fields.addNotify("print");
    00103
    00105   _outList = NULL;
    00106   _objToTransfer = NULL;
    00107   // Reactivate calls of handleNotification on field changes.
    00108   handleNotificationOn();
    00109
    00110   // Activate inplace data buffers for output outIndex and input inIndex.
    00111   // setOutImgInplace(outIndex, inIndex);
    00112
    00113   // Activate page data bypass from input inIdx to output outIdx.
    00114   // Note that the module must still be able to calculate the output image.
    00115   // setBypass(outIndex, inIndex);
    00116
    00117   // Activate parallel execution of calcOutSubImage.
    00118   // setThreadSupport(supportMode);
    00119   // with supportMode =
    00120   //   NO_THREAD_SUPPORT                 //! The module is not thread safe at all.
    00121   //   CALC_OUTSUBIMAGE_ON_STD_TYPES     //! calcOutSubImage can be called in parallel for scalar voxel types.
    00122   //   CALC_OUTSUBIMAGE_ON_CARRIER_TYPES //! calcOutSubImage can be called in parallel for carrier voxel types.
    00123   //   CALC_OUTSUBIMAGE_ON_ALL_TYPES     //! calcOutSubImage can be called in parallel for all voxel types.
    00124   // Warning: You should be familiar with multithreading before activating this feature.
    00125
    00126   // Specify whether the module can only process standard scalar voxel types or
    00127   // also registered voxel types (vec2, mat2, complexf, Vector, etc.)
    00128   // setVoxelDataTypeSupport(permittedTypes);
    00129   // with permittedTypes =
    00130   //   ONLY_STANDARD_TYPES               //! Only standard scalar voxels are supported.
    00131   //   FULLY_OPERATIONAL                 //! Scalar and registered voxels types are supported.
    00132   //   MINIMUM_OPERATIONAL               //! Scalar and registered voxel types are supported.
    00133   //                                     //! Voxel operators are not used by algorithm.
    00134   //
    00135   // See ML Programming Guide, "Configuring Image Processing Behaviour of the BaseOp"
    00136   // for further details.
    00137 }
    00138
    00139 //----------------------------------------------------------------------------------
    00141 //----------------------------------------------------------------------------------
    00142 void ImportRTStructure::handleNotification (Field *field)
    00143 {
    00144   ML_TRACE_IN("ImportRTStructure::handleNotification ()")
    00145
    00146   // Handle changes of module parameters and connectors here.
    00147   if (field == _applyFld) {
    00148           std::string inDCMFile = _inDCMFileFld->getStringValue();
    00149           if (inDCMFile.empty()) {
    00150           //ML_PRINT_WARNING("ImportRTStructure::_HandleNotification",ML_BAD_PARAMETER, "Please load the dcm file first.");
    00151                   return;
    00152           }
    00153           if (RTStructure2CSO(inDCMFile) == false)
    00154                   return;
    00155           _outListFld->setBaseValue(_outList);
    00156           _outListFld->activateAttachments();
    00157           _allTagsFld->setStringValue(_allTagValues);
    00158           _dicmFileFld->setStringValue(inDCMFile);
    00159           removeContourData();
    00160           _objToTransfer = new RTStructure();
    00161       std::ostringstream mystream;
    00162           _treePtr->toStream(_objToTransfer->stream, true);
    00163       _dcmObjFld->setBaseValue(_objToTransfer);
    00164           mystream.clear();
    00165   } else if (field == _getValuesFld) {
    00166           if (_treePtr == NULL) {
    00167                 //ML_PRINT_INFORMATION("ImportRTStructure::_HandleNotification",ML_BAD_PARAMETER, "Please load the dcm file first.");
    00168                 return;
    00169           }
    00170           if(_treePtr->tagsSize() == 0)
    00171                   return;
    00172
    00173           for (int i = 0; i < tagFieldNum; i ++) {
    00174                   std::string tagName = _tagNameFld[i]->getStringValue();
    00175                   if (tagName.empty()) {
    00176                           continue;
    00177                   }
    00178                   DCMTree::Const_TagPtr tagPtr;
    00179                   if (tagName.find(",") != std::string::npos) {
    00180                           // tags are in (****,****) format
    00181                           tagPtr = _treePtr->getTag(DCMTree::TagId(tagName));
    00182                           _tagValueFld[i]->setStringValue(std::string(reinterpret_cast<const char*> (tagPtr->getValue().data())));
    00183                   } else {
    00184              //tags are in their name
    00185                           tagPtr = _treePtr->getTag(tagName);
    00186                   }
    00187
    00188                   std::string value = getTagValue(tagPtr);
    00189                   if (_trimSpacesFld->getBoolValue() == true) {
    00190                                   std::string::iterator end_pos = std::remove(value.begin(), value.end(), ' ');
    00191                                   value.erase(end_pos, value.end());
    00192                           }
    00193                           _tagValueFld[i]->setStringValue(value);
    00194                   }
    00195   } else if (field == _printFld) {
    00196           std::cout << _allTagValues << std::endl;
    00197           _allTagValues.clear();
    00198
    00199   }
    00200
    00201 }
    00202
    00203 //-----------------------------------------------------------------------------------------
    00205 //-----------------------------------------------------------------------------------------
    00206 std::string ImportRTStructure::getTagValue(DCMTree::Const_TagPtr constTagPtr)
    00207 {
    00208         std::string value;
    00209         DCMTree::TagInfo tagInfo = constTagPtr->info();
    00210         if (constTagPtr!= NULL && !constTagPtr->isEmpty()) {
    00211                                 DCMTree::Vr vr = tagInfo.vr();
    00212
    00213                                 switch(vr)
    00214                                 {
    00215                                         case(DCMTree::UL) :
    00216                                         case(DCMTree::FL):
    00217                                         case(DCMTree::FD):
    00218                                         case(DCMTree::IS):
    00219                                         case(DCMTree::LO):
    00220                                                 value = constTagPtr->toString();
    00221                                                 break;
    00222                                         default:
    00223                                                 value = reinterpret_cast<const char*> (constTagPtr->getValue().data());
    00224                                 }
    00225
    00226         }
    00227         return value;
    00228 }
    00229
    00230 //-----------------------------------------------------------------------------------------
    00232 //-----------------------------------------------------------------------------------------
    00233 void ImportRTStructure::activateAttachments ()
    00234 {
    00235   ML_TRACE_IN("ImportRTStructure::activateAttachments ()")
    00236
    00237   // Update members to new field state here.
    00238   // Call super class functionality to enable notification handling again.
    00239   BaseOp::activateAttachments ();
    00240 }
    00241
    00242 //----------------------------------------------------------------------------------
    00244 //----------------------------------------------------------------------------------
    00245 void  ImportRTStructure::getDCMTreeFromFile(std::string inDCMFile)
    00246 {
    00247         DCMTree::TreePtr treePtr;
    00248         try {
    00249                 DCMTree::IOParameterPtr ioParamPtr = DCMTree::IOParameter::create(std::string(inDCMFile), false);
    00250         DCMTree::ReaderPtr      reader     = DCMTree::Reader::create(DCMTree::Dict::singleton());
    00251         DCMTree::MessagePtr     messagePtr = reader->read(ioParamPtr);
    00252         _treePtr    = messagePtr->tags();
    00253     }catch(DCMTree::Exception& ex){
    00254                  ML_PRINT_ERROR("ImportRTStructure::_HandleNotification",ML_BAD_PARAMETER, ex.toString().c_str());
    00255     }
    00256 }
    00257
    00258 //----------------------------------------------------------------------------------
    00260 //----------------------------------------------------------------------------------
    00261 bool  ImportRTStructure::RTStructure2CSO(std::string inDCMFile)
    00262 {
    00263         getDCMTreeFromFile(inDCMFile);
    00264         if (_treePtr == NULL)
    00265                 return false;
    00266         ML_DELETE(_outList);
    00267         _outList = new CSOList();
    00268         parseCSOGroup();
    00269         parseCSO();
    00270         fillUpDCMTagViewer();
    00271         return true;
    00272 }
    00273
    00274 //------------------------------------------------------------------------------------------------------------------
    00276 //------------------------------------------------------------------------------------------------------------------
    00277 void ImportRTStructure::fillUpDCMTagViewer()
    00278 {
    00279          _allTagValues.clear();
    00280          const DCMTree::TagPtrMap map= _treePtr->tags();
    00281          std::map<DCMTree::TagId,DCMTree::TagPtr>::const_iterator itr;
    00282          for (itr = map.begin(); itr != map.end(); ++itr) {
    00283                 DCMTree::TagId id = itr->first;
    00284                 DCMTree::TagPtr ptr = itr->second;
    00285                 DCMTree::Const_TagPtr constTagPtr = _treePtr->getTag(id);
    00286                 if (!constTagPtr->isSequence()) {
    00287                         std::string idChar = id.toString();
    00288                         DCMTree::TagInfo tagInfo = constTagPtr->info();
    00289                         std::string name = _treePtr->getDict()->name(tagInfo.id());
    00290                         std::string value;
    00291                         value = getTagValue(constTagPtr);
    00292                         _allTagValues.append(idChar);
    00293                         _allTagValues.append(" ");
    00294                         _allTagValues.append(name);
    00295                         _allTagValues.append(": ");
    00296                         _allTagValues.append(value);
    00297                         _allTagValues.append("\n");
    00298
    00299                 }
    00300          }
    00301 }
    00302
    00303 //----------------------------------------------------------------------------------
    00305 //----------------------------------------------------------------------------------
    00306 void ImportRTStructure::parseCSOGroup()
    00307 {
    00308         // find the tagPtr for "StructureSetROISequence"-- create CSOGroup
    00309         DCMTree::Const_TagPtr groupTagPtr = _treePtr->getTag(DCMTree::TagId(0x3006,0x0020));
    00310         if (groupTagPtr != NULL && groupTagPtr->isSequence()) {
    00311                 for (unsigned int groupIndex = 0; groupIndex < groupTagPtr->numberOfSequenceItems(); groupIndex ++) {
    00312                         DCMTree::TreePtr embeddedTreePtr = groupTagPtr->sequenceItems()[groupIndex];
    00313                         CSOGroup  *group = group = _outList->addGroup();
    00314
    00315                         // find ROINumber -- group ID
    00316             DCMTree::Const_TagPtr ROINumTagPtr = embeddedTreePtr->getTag(DCMTree::TagId(0x3006,0x0022));
    00317                         group->setId(ROINumTagPtr->toInt());
    00318
    00319                         // find ROINname -- group Label
    00320                         DCMTree::Const_TagPtr ROILabelTagPtr = embeddedTreePtr->getTag(DCMTree::TagId(0x3006,0x0026));
    00321                         group->setLabel(ROILabelTagPtr->toString());
    00322
    00323                         // find ROIGenerationAlgorithm
    00324             DCMTree::Const_TagPtr ROIUIDTagPtr = embeddedTreePtr->getTag(DCMTree::TagId(0x3006,0x0024));
    00325             DCMTree::Const_TagPtr ROIAlgTagPtr = embeddedTreePtr->getTag(DCMTree::TagId(0x3006,0x0036));
    00326
    00327                         group->setDescription(ROIUIDTagPtr->toString() + ":"+ ROIAlgTagPtr->toString());
    00328                 }
    00329         }
    00330 }
    00331
    00332 //----------------------------------------------------------------------------------
    00334 //----------------------------------------------------------------------------------
    00335 void ImportRTStructure::removeContourData()
    00336 {
    00337         DCMTree::Const_TagPtr tagPtr = _treePtr->getTag(DCMTree::TagId(0x3006,0x0039));
    00338         if (tagPtr != NULL && tagPtr->isSequence()) {
    00339        for (unsigned int i = 0; i < tagPtr->numberOfSequenceItems(); i++) {
    00340                    DCMTree::TreePtr embeddedTreePtr = tagPtr->sequenceItems()[i];
    00341                    DCMTree::Const_TagPtr contourSeqTagPtr = embeddedTreePtr->getTag(DCMTree::TagId(0x3006,0x0040));
    00342
    00343                         if (contourSeqTagPtr != NULL && !contourSeqTagPtr->isEmpty() && contourSeqTagPtr->isSequence()) {
    00344                                 for (unsigned int embeddedIndex = 0; embeddedIndex < contourSeqTagPtr->numberOfSequenceItems(); embeddedIndex ++) {
    00345                                         DCMTree::TreePtr contourSeqTreePtr = contourSeqTagPtr->sequenceItems()[embeddedIndex];
    00346                                         // find the tagPtr for "contourData"
    00347                                         DCMTree::TagPtr contourDataTagPtr = contourSeqTreePtr->getTag_rw(DCMTree::TagId(0x3006,0x0050));
    00348                                         contourDataTagPtr->dropValues();
    00349                                 }
    00350                         }
    00351                 }
    00352         }
    00353
    00354 }
    00355
    00356 //----------------------------------------------------------------------------------
    00358 //----------------------------------------------------------------------------------
    00359 void ImportRTStructure::parseCSO()
    00360 {
    00361         // find the tagPtr for "ROIContourSequence"
    00362         DCMTree::Const_TagPtr tagPtr = _treePtr->getTag(DCMTree::TagId(0x3006,0x0039));
    00363         if (tagPtr != NULL && tagPtr->isSequence()) {
    00364                 bool ignore = false;
    00365                 int threshold = atoi(_thresholdFld->getStringValue().c_str());
    00366         int dividend = atoi(_dividendFld->getStringValue().c_str());
    00367                 int divisor = atoi(_divisorFld->getStringValue().c_str());
    00368
    00369                 if (threshold == 0 || divisor == 0 || dividend == 0)
    00370                         ignore = true;
    00371                 for (unsigned int i = 0; i < tagPtr->numberOfSequenceItems(); i++) {
    00372                         DCMTree::TreePtr embeddedTreePtr = tagPtr->sequenceItems()[i];
    00373
    00374             // find display color
    00375             DCMTree::Const_TagPtr colorTagPtr = embeddedTreePtr->getTag(DCMTree::TagId(0x3006,0x002a));
    00376                         vec3 color(colorTagPtr->toFloat(0)/255.0, colorTagPtr->toFloat(1)/255.0, colorTagPtr->toFloat(2)/255.0);
    00377             // find the tagPtr for "ReferencedROINumber"
    00378                         DCMTree::Const_TagPtr refROITagPtr = embeddedTreePtr->getTag(DCMTree::TagId(0x3006,0x0084));
    00379
    00380                         std::string refImgFrame;
    00381
    00382                         // find the tagPtr for "ContourSequence"
    00383                         DCMTree::Const_TagPtr contourSeqTagPtr = embeddedTreePtr->getTag(DCMTree::TagId(0x3006,0x0040));
    00384
    00385                         if (contourSeqTagPtr != NULL && !contourSeqTagPtr->isEmpty() && contourSeqTagPtr->isSequence()) {
    00386                                 for (unsigned int embeddedIndex = 0; embeddedIndex < contourSeqTagPtr->numberOfSequenceItems(); embeddedIndex ++) {
    00387                                         DCMTree::TreePtr contourSeqTreePtr = contourSeqTagPtr->sequenceItems()[embeddedIndex];
    00388
    00389                                         // find the tag " contour Image Sequence--find the reference image frame
    00390                                         DCMTree::Const_TagPtr contourImgSeqTagPtr = contourSeqTreePtr->getTag(DCMTree::TagId(0x3006,0x0016));
    00391                                         if (contourImgSeqTagPtr != NULL && contourImgSeqTagPtr->isSequence()) {
    00392                         for (unsigned int imgSeqIndex = 0; imgSeqIndex < contourImgSeqTagPtr->numberOfSequenceItems(); imgSeqIndex ++) {
    00393                                                         DCMTree::TreePtr contourImgSeqTreePtr = contourImgSeqTagPtr->sequenceItems()[imgSeqIndex];
    00394                                                         DCMTree::Const_TagPtr refImgTagPtr = contourImgSeqTreePtr->getTag(DCMTree::TagId(0x0008, 0x1150));
    00395                                                         DCMTree::Const_TagPtr refImgFrameTagPtr = contourImgSeqTreePtr->getTag(DCMTree::TagId(0x0008, 0x1155));
    00396                                                         refImgFrame = refImgTagPtr->toString() + ":" + refImgFrameTagPtr->toString();
    00397                                                 }
    00398                                         }
    00399                     // find the tag " NumberOfContourPoints--number of seed points in the contour
    00400                                         DCMTree::Const_TagPtr numOfSeedPtsTagPtr = contourSeqTreePtr->getTag(DCMTree::TagId(0x3006,0x0046));
    00401                                         int numOfSeedPts = numOfSeedPtsTagPtr->toInt();
    00402
    00403                                         // find the tagPtr for "contourData"
    00404                                         DCMTree::Const_TagPtr contourDataTagPtr = contourSeqTreePtr->getTag(DCMTree::TagId(0x3006,0x0050));
    00405
    00406                                         // find the tagPtr for "ContourGeometricType"
    00407                                         DCMTree::Const_TagPtr geoTagPtr = contourSeqTreePtr->getTag(DCMTree::TagId(0x3006,0x0042));
    00408                             bool csoShouldbeClosed = false;
    00409
    00410                                         if (std::string("CLOSED_PLANAR") == geoTagPtr->toString()) {
    00411                                                 csoShouldbeClosed = true;
    00412                                         }
    00413
    00414                                         // create new CSO and fill it in with coordinates
    00415                                         int actualSeedPts = numOfSeedPts;
    00416                                         if (ignore == false && threshold < numOfSeedPts) {
    00417                                           //int reminder = _cpp_min((numOfSeedPts % divisor), dividend);
    00418                                                 int reminder = numOfSeedPts % divisor > dividend ?  dividend : numOfSeedPts % divisor;
    00419                                                 actualSeedPts = numOfSeedPts - numOfSeedPts/divisor * dividend - reminder;
    00420                                         }
    00421                                         CSO* cso = _outList->addCSO(actualSeedPts, csoShouldbeClosed, true);
    00422                                         cso->setColor(color);
    00423                                         cso->setDescription(refImgFrame);
    00424                                         cso->setMarkerSize(0.1);
    00425                                         cso->setMarkerColor(color);
    00426                                         cso->setLineStyle(LINE_STYLE_SOLID);
    00427                                         cso->setCreatorId(1);
    00428                     cso->setType("CSOFreehandProcessor");
    00429                                         cso->setSubType("SUB_TYPE_CLOSED_SPLINE");
    00430
    00431                                         int contourIndex = 0;
    00432                                         int index = 0;
    00433                                         double p1, p2, p3;
    00434                                         for (unsigned int valIndex = 0; valIndex < contourDataTagPtr->numberOfValues() && contourIndex < actualSeedPts; valIndex++) {
    00435                                                 if (ignore == false && threshold < numOfSeedPts && index % divisor < dividend ) {
    00436                                                         index ++;
    00437                                                         valIndex +=2;
    00438                                                         continue;
    00439                                                 }
    00440                                                 // create positions in CSO
    00441                                                 p1 = contourDataTagPtr->toDouble(valIndex);
    00442                                                 p2 = contourDataTagPtr->toDouble(++ valIndex);
    00443                                                 p3 = contourDataTagPtr->toDouble(++ valIndex);
    00444                                                 cso->getSeedPointAt(contourIndex ++)->worldPosition.assign(p1, p2, p3);
    00445                                                 index ++;
    00446                                         }
    00447                                         CSOGeneratePathPoints::fillAllPathPointsSplineInterpolation(cso, 1);
    00448                                         CSOGroup  *group = _outList->getGroupById(refROITagPtr->toInt());
    00449                                         group->setColor(color);
    00450                                         _outList->combineCSOandGroup(cso, group);
    00451                                 }
    00452                         }
    00453                 }
    00454         }
    00455
    00456 }
    00457
    00458 //----------------------------------------------------------------------------------
    00460 //----------------------------------------------------------------------------------
    00461 ImportRTStructure::~ImportRTStructure()
    00462 {
    00463     ML_DELETE(_outList);
    00464         _outList = NULL;
    00465         ML_DELETE(_objToTransfer);
    00466         _objToTransfer = NULL;
    00467 }
    00468
    00469 ML_END_NAMESPACE
    00470

All Classes Namespaces Files Functions Variables Enumerator Friends