Ignore:
Timestamp:
11/03/09 15:36:44 (11 years ago)
Author:
curtis
Message:

Add exception handling for Bio-Formats calls.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/components/native/itk-plugin/itkBioFormatsImageIO.cxx

    r5649 r5663  
    5757// 
    5858 
    59 namespace itk 
    60 { 
    61  
    62   BioFormatsImageIO::BioFormatsImageIO() 
    63   { 
     59namespace itk { 
     60 
     61  BioFormatsImageIO::BioFormatsImageIO() { 
    6462    DebugOn(); // NB: For debugging. 
    65     itkDebugMacro(<<"BioFormatsImageIO constuctor"); 
     63    itkDebugMacro(<<"BioFormatsImageIO constructor"); 
    6664    m_FileType = Binary; 
    6765 
    68     // initialize the Java virtual machine 
    69     itkDebugMacro(<<"Creating JVM..."); 
    70     jace::StaticVmLoader loader(JNI_VERSION_1_4); 
    71     jace::OptionList list; 
    72     list.push_back(jace::ClassPath( 
    73       "jace-runtime.jar:bio-formats.jar:loci_tools.jar" 
    74     )); 
    75     list.push_back(jace::CustomOption("-Xcheck:jni")); 
    76     list.push_back(jace::CustomOption("-Xmx256m")); 
    77     list.push_back(jace::CustomOption("-Djava.awt.headless=true")); 
    78     //list.push_back(jace::CustomOption("-verbose")); 
    79     //list.push_back(jace::CustomOption("-verbose:jni")); 
    80     jace::helper::createVm(loader, list, false); 
    81     itkDebugMacro(<<"JVM created."); 
    82  
    83     itkDebugMacro(<<"Creating Bio-Formats objects..."); 
    84     reader = new ChannelFiller; 
    85     writer = new ImageWriter; 
    86     itkDebugMacro(<<"Created reader and writer."); 
    87   } 
    88  
    89   BioFormatsImageIO::~BioFormatsImageIO() 
    90   { 
     66    try { 
     67      // initialize the Java virtual machine 
     68      itkDebugMacro(<<"Creating JVM..."); 
     69      jace::StaticVmLoader loader(JNI_VERSION_1_4); 
     70      jace::OptionList list; 
     71      list.push_back(jace::ClassPath( 
     72        "jace-runtime.jar:bio-formats.jar:loci_tools.jar" 
     73      )); 
     74      list.push_back(jace::CustomOption("-Xcheck:jni")); 
     75      list.push_back(jace::CustomOption("-Xmx256m")); 
     76      list.push_back(jace::CustomOption("-Djava.awt.headless=true")); 
     77      //list.push_back(jace::CustomOption("-verbose")); 
     78      //list.push_back(jace::CustomOption("-verbose:jni")); 
     79      jace::helper::createVm(loader, list, false); 
     80      itkDebugMacro(<<"JVM created."); 
     81    } 
     82    catch (JNIException& jniException) { 
     83      itkDebugMacro(<<"Exception creating JVM: " << jniException.what()); 
     84    } 
     85 
     86    try { 
     87      itkDebugMacro(<<"Creating Bio-Formats objects..."); 
     88      reader = new ChannelFiller; 
     89      writer = new ImageWriter; 
     90      itkDebugMacro(<<"Created reader and writer."); 
     91    } 
     92    catch (FormatException& fe) { 
     93      //fe.printStackTrace(); 
     94      itkDebugMacro( 
     95        <<"An unexpected Java format error occurred. " << fe.what()); 
     96    } 
     97    catch (IOException& ioe) { 
     98      //ioe.printStackTrace(); 
     99      itkDebugMacro(<<"An unexpected Java I/O error occurred. " << ioe.what()); 
     100    } 
     101    catch (JNIException& jniException) { 
     102      itkDebugMacro( 
     103        <<"An unexpected JNI error occurred. " << jniException.what()); 
     104    } 
     105    catch (std::exception& e) { 
     106      itkDebugMacro(<<"An unexpected C++ error occurred. " << e.what()); 
     107    } 
     108  } // end constructor 
     109 
     110  BioFormatsImageIO::~BioFormatsImageIO() { 
    91111    delete reader; 
    92112    delete writer; 
    93   } 
    94  
    95   bool 
    96   BioFormatsImageIO::CanReadFile(const char* FileNameToRead) 
    97   { 
    98     itkDebugMacro(<<"BioFormatsImageIO::CanReadFile: FileNameToRead=" << FileNameToRead); 
     113  } // end destructor 
     114 
     115  bool BioFormatsImageIO::CanReadFile(const char* FileNameToRead) { 
     116    itkDebugMacro( 
     117      <<"BioFormatsImageIO::CanReadFile: FileNameToRead=" << FileNameToRead); 
    99118    std::string filename(FileNameToRead); 
    100119 
    101     if ( filename == "" ) 
    102     { 
     120    if (filename == "") { 
    103121      itkExceptionMacro(<<"A FileName must be specified."); 
    104122      return false; 
    105123    } 
    106124 
    107     // call Bio-Formats to check file type 
    108     bool isType = reader->isThisType(filename); 
    109     itkDebugMacro(<<"BioFormatsImageIO::CanReadFile: isType=" << isType); 
     125    bool isType = 0; 
     126    try { 
     127      // call Bio-Formats to check file type 
     128      isType = reader->isThisType(filename); 
     129      itkDebugMacro(<<"BioFormatsImageIO::CanReadFile: isType=" << isType); 
     130    } 
     131    catch (FormatException& fe) { 
     132      //fe.printStackTrace(); 
     133      itkDebugMacro( 
     134        <<"An unexpected Java format error occurred. " << fe.what()); 
     135    } 
     136    catch (IOException& ioe) { 
     137      //ioe.printStackTrace(); 
     138      itkDebugMacro(<<"An unexpected Java I/O error occurred. " << ioe.what()); 
     139    } 
     140    catch (JNIException& jniException) { 
     141      itkDebugMacro( 
     142        <<"An unexpected JNI error occurred. " << jniException.what()); 
     143    } 
     144    catch (std::exception& e) { 
     145      itkDebugMacro(<<"An unexpected C++ error occurred. " << e.what()); 
     146    } 
    110147    return isType; 
    111   } 
    112  
    113   void 
    114   BioFormatsImageIO::ReadImageInformation() 
    115   { 
    116     itkDebugMacro(<<"BioFormatsImageIO::ReadImageInformation: m_FileName=" << m_FileName); 
    117  
    118     // attach OME metadata object 
    119     IMetadata omeMeta = MetadataTools::createOMEXMLMetadata(); 
    120     reader->setMetadataStore(omeMeta); 
    121  
    122     // initialize dataset 
    123     itkDebugMacro(<<"Initializing..."); 
    124     reader->setId(m_FileName); 
    125     itkDebugMacro(<<"Initialized."); 
    126  
    127     int seriesCount = reader->getSeriesCount(); 
    128     itkDebugMacro(<<"\tSeriesCount = " << seriesCount); 
    129  
    130     // set ITK byte order 
    131     bool little = reader->isLittleEndian(); 
    132     if (little) SetByteOrderToLittleEndian(); // m_ByteOrder 
    133     else SetByteOrderToBigEndian(); // m_ByteOrder 
    134  
    135     // set ITK component type 
    136     int pixelType = reader->getPixelType(); 
    137     int bpp = FormatTools::getBytesPerPixel(pixelType); 
    138     itkDebugMacro(<<"\tBytes per pixel = " << bpp); 
    139     IOComponentType itkComponentType; 
    140     if (pixelType == FormatTools::UINT8()) 
    141       itkComponentType = UCHAR; 
    142     else if (pixelType == FormatTools::INT8()) 
    143       itkComponentType = CHAR; 
    144     else if (pixelType == FormatTools::UINT16()) 
    145       itkComponentType = USHORT; 
    146     else if (pixelType == FormatTools::INT16()) 
    147       itkComponentType = SHORT; 
    148     else if (pixelType == FormatTools::UINT32()) 
    149       itkComponentType = UINT; 
    150     else if (pixelType == FormatTools::INT32()) 
    151       itkComponentType = INT; 
    152     else if (pixelType == FormatTools::FLOAT()) 
    153       itkComponentType = FLOAT; 
    154     else if (pixelType == FormatTools::DOUBLE()) 
    155       itkComponentType = DOUBLE; 
    156     else 
    157       itkComponentType = UNKNOWNCOMPONENTTYPE; 
    158     SetComponentType(itkComponentType); // m_ComponentType 
    159     if (itkComponentType == UNKNOWNCOMPONENTTYPE) 
    160     { 
    161       itkExceptionMacro(<<"Unknown pixel type: " << pixelType); 
    162     } 
    163  
    164     // get pixel resolution and dimensional extents 
    165     int sizeX = reader->getSizeX(); 
    166     int sizeY = reader->getSizeY(); 
    167     int sizeZ = reader->getSizeZ(); 
    168     int sizeC = reader->getSizeC(); 
    169     int sizeT = reader->getSizeT(); 
    170     int effSizeC = reader->getEffectiveSizeC(); 
    171     int rgbChannelCount = reader->getRGBChannelCount(); 
    172     int imageCount = reader->getImageCount(); 
    173  
    174     itkDebugMacro("Dimensional extents:" << std::endl 
    175       <<"\tSizeX = " << sizeX << std::endl 
    176       <<"\tSizeY = " << sizeY << std::endl 
    177       <<"\tSizeZ = " << sizeZ << std::endl 
    178       <<"\tSizeC = " << sizeC << std::endl 
    179       <<"\tSizeT = " << sizeT << std::endl 
    180       <<"\tRGB Channel Count = " << rgbChannelCount << std::endl 
    181       <<"\tEffective SizeC = " << rgbChannelCount << std::endl 
    182       <<"\tImage Count = " << imageCount); 
    183  
    184     int numDims = 2; // X and Y 
    185     if (sizeZ > 1) numDims++; // multiple focal planes 
    186     if (sizeT > 1) numDims++; // multiple time points 
    187     if (effSizeC > 1) numDims++; // multiple independent channels 
    188     SetNumberOfDimensions(numDims); 
    189     m_Dimensions[0] = sizeX; 
    190     m_Dimensions[1] = sizeY; 
    191     int dim = 2; 
    192     if (sizeZ > 1) m_Dimensions[dim++] = sizeZ; 
    193     if (sizeT > 1) m_Dimensions[dim++] = sizeT; 
    194     if (effSizeC > 1) m_Dimensions[dim++] = effSizeC; 
    195  
    196     // set ITK pixel type 
    197     IOPixelType itkPixelType; 
    198     if (rgbChannelCount == 1) 
    199       itkPixelType = SCALAR; 
    200     else if (rgbChannelCount == 3) 
    201       itkPixelType = RGB; 
    202     else 
    203       itkPixelType = VECTOR; 
    204     SetPixelType(itkPixelType); // m_PixelType 
    205     SetNumberOfComponents(rgbChannelCount); // m_NumberOfComponents 
    206  
    207     // get physical resolution 
    208     MetadataRetrieve retrieve = MetadataTools::asRetrieve(omeMeta); 
    209     double physX = retrieve.getDimensionsPhysicalSizeX(0, 0).doubleValue(); 
    210     double physY = retrieve.getDimensionsPhysicalSizeY(0, 0).doubleValue(); 
    211     m_Spacing[0] = physX; 
    212     m_Spacing[1] = physY; 
    213     if (imageCount > 1) m_Spacing[2] = 1; 
    214  
    215     itkDebugMacro(<<"\tPhysicalSizeX = " << physX); 
    216     itkDebugMacro(<<"\tPhysicalSizeY = " << physY); 
    217   } 
    218  
    219   void 
    220   BioFormatsImageIO::Read(void* pData) 
    221   { 
     148  } // end CanReadFile function 
     149 
     150  void BioFormatsImageIO::ReadImageInformation() { 
     151    itkDebugMacro( 
     152      <<"BioFormatsImageIO::ReadImageInformation: m_FileName=" << m_FileName); 
     153 
     154    try { 
     155      // attach OME metadata object 
     156      IMetadata omeMeta = MetadataTools::createOMEXMLMetadata(); 
     157      reader->setMetadataStore(omeMeta); 
     158 
     159      // initialize dataset 
     160      itkDebugMacro(<<"Initializing..."); 
     161      reader->setId(m_FileName); 
     162      itkDebugMacro(<<"Initialized."); 
     163 
     164      int seriesCount = reader->getSeriesCount(); 
     165      itkDebugMacro(<<"\tSeriesCount = " << seriesCount); 
     166 
     167      // set ITK byte order 
     168      bool little = reader->isLittleEndian(); 
     169      if (little) SetByteOrderToLittleEndian(); // m_ByteOrder 
     170      else SetByteOrderToBigEndian(); // m_ByteOrder 
     171 
     172      // set ITK component type 
     173      int pixelType = reader->getPixelType(); 
     174      int bpp = FormatTools::getBytesPerPixel(pixelType); 
     175      itkDebugMacro(<<"\tBytes per pixel = " << bpp); 
     176      IOComponentType itkComponentType; 
     177      if (pixelType == FormatTools::UINT8()) 
     178        itkComponentType = UCHAR; 
     179      else if (pixelType == FormatTools::INT8()) 
     180        itkComponentType = CHAR; 
     181      else if (pixelType == FormatTools::UINT16()) 
     182        itkComponentType = USHORT; 
     183      else if (pixelType == FormatTools::INT16()) 
     184        itkComponentType = SHORT; 
     185      else if (pixelType == FormatTools::UINT32()) 
     186        itkComponentType = UINT; 
     187      else if (pixelType == FormatTools::INT32()) 
     188        itkComponentType = INT; 
     189      else if (pixelType == FormatTools::FLOAT()) 
     190        itkComponentType = FLOAT; 
     191      else if (pixelType == FormatTools::DOUBLE()) 
     192        itkComponentType = DOUBLE; 
     193      else 
     194        itkComponentType = UNKNOWNCOMPONENTTYPE; 
     195      SetComponentType(itkComponentType); // m_ComponentType 
     196      if (itkComponentType == UNKNOWNCOMPONENTTYPE) 
     197      { 
     198        itkExceptionMacro(<<"Unknown pixel type: " << pixelType); 
     199      } 
     200 
     201      // get pixel resolution and dimensional extents 
     202      int sizeX = reader->getSizeX(); 
     203      int sizeY = reader->getSizeY(); 
     204      int sizeZ = reader->getSizeZ(); 
     205      int sizeC = reader->getSizeC(); 
     206      int sizeT = reader->getSizeT(); 
     207      int effSizeC = reader->getEffectiveSizeC(); 
     208      int rgbChannelCount = reader->getRGBChannelCount(); 
     209      int imageCount = reader->getImageCount(); 
     210 
     211      itkDebugMacro("Dimensional extents:" << std::endl 
     212        <<"\tSizeX = " << sizeX << std::endl 
     213        <<"\tSizeY = " << sizeY << std::endl 
     214        <<"\tSizeZ = " << sizeZ << std::endl 
     215        <<"\tSizeC = " << sizeC << std::endl 
     216        <<"\tSizeT = " << sizeT << std::endl 
     217        <<"\tRGB Channel Count = " << rgbChannelCount << std::endl 
     218        <<"\tEffective SizeC = " << rgbChannelCount << std::endl 
     219        <<"\tImage Count = " << imageCount); 
     220 
     221      int numDims = 2; // X and Y 
     222      if (sizeZ > 1) numDims++; // multiple focal planes 
     223      if (sizeT > 1) numDims++; // multiple time points 
     224      if (effSizeC > 1) numDims++; // multiple independent channels 
     225      SetNumberOfDimensions(numDims); 
     226      m_Dimensions[0] = sizeX; 
     227      m_Dimensions[1] = sizeY; 
     228      int dim = 2; 
     229      if (sizeZ > 1) m_Dimensions[dim++] = sizeZ; 
     230      if (sizeT > 1) m_Dimensions[dim++] = sizeT; 
     231      if (effSizeC > 1) m_Dimensions[dim++] = effSizeC; 
     232 
     233      // set ITK pixel type 
     234      IOPixelType itkPixelType; 
     235      if (rgbChannelCount == 1) 
     236        itkPixelType = SCALAR; 
     237      else if (rgbChannelCount == 3) 
     238        itkPixelType = RGB; 
     239      else 
     240        itkPixelType = VECTOR; 
     241      SetPixelType(itkPixelType); // m_PixelType 
     242      SetNumberOfComponents(rgbChannelCount); // m_NumberOfComponents 
     243 
     244      // get physical resolution 
     245      MetadataRetrieve retrieve = MetadataTools::asRetrieve(omeMeta); 
     246      double physX = retrieve.getDimensionsPhysicalSizeX(0, 0).doubleValue(); 
     247      double physY = retrieve.getDimensionsPhysicalSizeY(0, 0).doubleValue(); 
     248      m_Spacing[0] = physX; 
     249      m_Spacing[1] = physY; 
     250      if (imageCount > 1) m_Spacing[2] = 1; 
     251 
     252      itkDebugMacro(<<"\tPhysicalSizeX = " << physX); 
     253      itkDebugMacro(<<"\tPhysicalSizeY = " << physY); 
     254    } 
     255    catch (FormatException& fe) { 
     256      //fe.printStackTrace(); 
     257      itkDebugMacro( 
     258        <<"An unexpected Java format error occurred. " << fe.what()); 
     259    } 
     260    catch (IOException& ioe) { 
     261      //ioe.printStackTrace(); 
     262      itkDebugMacro(<<"An unexpected Java I/O error occurred. " << ioe.what()); 
     263    } 
     264    catch (JNIException& jniException) { 
     265      itkDebugMacro( 
     266        <<"An unexpected JNI error occurred. " << jniException.what()); 
     267    } 
     268    catch (std::exception& e) { 
     269      itkDebugMacro(<<"An unexpected C++ error occurred. " << e.what()); 
     270    } 
     271  } // end ReadImageInformation function 
     272 
     273  void BioFormatsImageIO::Read(void* pData) { 
    222274    char* data = (char*) pData; 
    223275    itkDebugMacro(<<"BioFormatsImageIO::Read"); 
    224276 
    225     int pixelType = reader->getPixelType(); 
    226     int bpp = FormatTools::getBytesPerPixel(pixelType); 
    227     int rgbChannelCount = reader->getRGBChannelCount(); 
    228  
    229     itkDebugMacro(<<"Pixel type code = " << pixelType); 
    230     itkDebugMacro(<<"Bytes per pixel = " << bpp); 
    231  
    232     // check IO region to identify the planar extents desired 
    233     ImageIORegion region = GetIORegion(); 
    234     int regionDim = region.GetImageDimension(); 
    235     int xIndex = region.GetIndex(0); 
    236     int xCount = region.GetSize(0); 
    237     int yIndex = region.GetIndex(1); 
    238     int yCount = region.GetSize(1); 
    239     int pIndex = 0, pCount = 1; 
    240     if (regionDim > 2) { 
    241       pIndex = region.GetIndex(2); 
    242       pCount = region.GetSize(2); 
    243     } 
    244     int bytesPerSubPlane = xCount * yCount * bpp * rgbChannelCount; 
    245  
    246     itkDebugMacro("Region extents:" << std::endl 
    247       <<"\tRegion dimension = " << regionDim << std::endl 
    248       <<"\tX index = " << xIndex << std::endl 
    249       <<"\tX count = " << xCount << std::endl 
    250       <<"\tY index = " << yIndex << std::endl 
    251       <<"\tY count = " << yCount << std::endl 
    252       <<"\tPlane index = " << pIndex << std::endl 
    253       <<"\tPlane count = " << pCount << std::endl 
    254       <<"\tBytes per plane = " << bytesPerSubPlane); 
    255  
    256     int p = 0; 
    257     ByteArray buf(bytesPerSubPlane); // pre-allocate buffer 
    258     for (int no=pIndex; no<pIndex+pCount; no++) 
    259     { 
    260       int imageCount = reader->getImageCount(); 
    261       itkDebugMacro(<<"Reading image plane " << no << 
    262         " (" << (no - pIndex + 1) << "/" << pCount << 
    263         " of " << imageCount << " available planes)"); 
    264       reader->openBytes(no, buf, xIndex, yIndex, xCount, yCount); 
    265       for (int i=0; i<bytesPerSubPlane; i++) data[p++] = buf[i]; 
    266     } 
    267  
    268     reader->close(); 
     277    try { 
     278      int pixelType = reader->getPixelType(); 
     279      int bpp = FormatTools::getBytesPerPixel(pixelType); 
     280      int rgbChannelCount = reader->getRGBChannelCount(); 
     281 
     282      itkDebugMacro(<<"Pixel type code = " << pixelType); 
     283      itkDebugMacro(<<"Bytes per pixel = " << bpp); 
     284 
     285      // check IO region to identify the planar extents desired 
     286      ImageIORegion region = GetIORegion(); 
     287      int regionDim = region.GetImageDimension(); 
     288      int xIndex = region.GetIndex(0); 
     289      int xCount = region.GetSize(0); 
     290      int yIndex = region.GetIndex(1); 
     291      int yCount = region.GetSize(1); 
     292      int pIndex = 0, pCount = 1; 
     293      if (regionDim > 2) { 
     294        pIndex = region.GetIndex(2); 
     295        pCount = region.GetSize(2); 
     296      } 
     297      int bytesPerSubPlane = xCount * yCount * bpp * rgbChannelCount; 
     298 
     299      itkDebugMacro("Region extents:" << std::endl 
     300        <<"\tRegion dimension = " << regionDim << std::endl 
     301        <<"\tX index = " << xIndex << std::endl 
     302        <<"\tX count = " << xCount << std::endl 
     303        <<"\tY index = " << yIndex << std::endl 
     304        <<"\tY count = " << yCount << std::endl 
     305        <<"\tPlane index = " << pIndex << std::endl 
     306        <<"\tPlane count = " << pCount << std::endl 
     307        <<"\tBytes per plane = " << bytesPerSubPlane); 
     308 
     309      int p = 0; 
     310      ByteArray buf(bytesPerSubPlane); // pre-allocate buffer 
     311      for (int no=pIndex; no<pIndex+pCount; no++) { 
     312        int imageCount = reader->getImageCount(); 
     313        itkDebugMacro(<<"Reading image plane " << no << 
     314          " (" << (no - pIndex + 1) << "/" << pCount << 
     315          " of " << imageCount << " available planes)"); 
     316        reader->openBytes(no, buf, xIndex, yIndex, xCount, yCount); 
     317        for (int i=0; i<bytesPerSubPlane; i++) data[p++] = buf[i]; 
     318      } 
     319 
     320      reader->close(); 
     321    } 
     322    catch (FormatException& fe) { 
     323      //fe.printStackTrace(); 
     324      itkDebugMacro( 
     325        <<"An unexpected Java format error occurred. " << fe.what()); 
     326    } 
     327    catch (IOException& ioe) { 
     328      //ioe.printStackTrace(); 
     329      itkDebugMacro(<<"An unexpected Java I/O error occurred. " << ioe.what()); 
     330    } 
     331    catch (JNIException& jniException) { 
     332      itkDebugMacro( 
     333        <<"An unexpected JNI error occurred. " << jniException.what()); 
     334    } 
     335    catch (std::exception& e) { 
     336      itkDebugMacro(<<"An unexpected C++ error occurred. " << e.what()); 
     337    } 
    269338    itkDebugMacro(<<"Done."); 
    270339  } // end Read function 
    271340 
    272   bool 
    273   BioFormatsImageIO::CanWriteFile(const char* name) 
    274   { 
     341  bool BioFormatsImageIO::CanWriteFile(const char* name) { 
    275342    itkDebugMacro(<<"BioFormatsImageIO::CanWriteFile: name=" << name); 
    276343    std::string filename(name); 
    277344 
    278     if ( filename == "" ) 
    279     { 
     345    if (filename == "") { 
    280346      itkExceptionMacro(<<"A FileName must be specified."); 
    281347      return false; 
    282348    } 
    283349 
    284     // call Bio-Formats to check file type 
    285     ImageWriter writer; 
    286     bool isType = writer.isThisType(filename); 
    287     itkDebugMacro(<<"BioFormatsImageIO::CanWriteFile: isType=" << isType); 
    288  
     350    bool isType = 0; 
     351    try { 
     352      // call Bio-Formats to check file type 
     353      ImageWriter writer; 
     354      isType = writer.isThisType(filename); 
     355      itkDebugMacro(<<"BioFormatsImageIO::CanWriteFile: isType=" << isType); 
     356    } 
     357    catch (FormatException& fe) { 
     358      //fe.printStackTrace(); 
     359      itkDebugMacro( 
     360        <<"An unexpected Java format error occurred. " << fe.what()); 
     361    } 
     362    catch (IOException& ioe) { 
     363      //ioe.printStackTrace(); 
     364      itkDebugMacro(<<"An unexpected Java I/O error occurred. " << ioe.what()); 
     365    } 
     366    catch (JNIException& jniException) { 
     367      itkDebugMacro( 
     368        <<"An unexpected JNI error occurred. " << jniException.what()); 
     369    } 
     370    catch (std::exception& e) { 
     371      itkDebugMacro(<<"An unexpected C++ error occurred. " << e.what()); 
     372    } 
    289373    return isType; 
    290   } 
    291  
    292   void 
    293   BioFormatsImageIO::WriteImageInformation() 
    294   { 
     374  } // end CanWriteFile function 
     375 
     376  void BioFormatsImageIO::WriteImageInformation() { 
    295377    itkDebugMacro(<<"BioFormatsImageIO::WriteImageInformation"); 
    296378    // NB: Nothing to do. 
    297   } 
    298  
    299   void 
    300   BioFormatsImageIO::Write(const void* buffer) 
    301   { 
     379  } // end WriteImageInformation function 
     380 
     381  void BioFormatsImageIO::Write(const void* buffer) { 
    302382    itkDebugMacro(<<"BioFormatsImageIO::Write"); 
    303383    // CTR TODO - implement Write function 
    304384  } // end Write function 
    305385 
    306 } // end NAMESPACE ITK 
     386} // end namespace itk 
Note: See TracChangeset for help on using the changeset viewer.