usMHDSequenceReader.cpp

#include <visp3/ustk_core/usMHDSequenceReader.h>
 
usMHDSequenceReader::usMHDSequenceReader()
  : m_sequenceDirectory(), m_sequenceImageType(us::NOT_SET), m_sequenceFiles(), m_totalImageNumber(0), m_imageCounter(0)
{
}
 
usMHDSequenceReader::~usMHDSequenceReader() {}
 
void usMHDSequenceReader::setSequenceDirectory(const std::string sequenceDirectory)
{
  m_sequenceFiles = vpIoTools::getDirFiles(sequenceDirectory);
  m_sequenceDirectory = sequenceDirectory;
  m_totalImageNumber = (int)m_sequenceFiles.size() / 2; // we have mhd and raw in the directory (2 * m_totalImageNumber)
  m_imageCounter = 0;
}
 
void usMHDSequenceReader::acquire(usImageRF2D<short int> &image, uint64_t &timestamp)
{
 
  if (m_imageCounter > m_totalImageNumber)
    throw(vpException(vpException::fatalError, "usMHDSequenceReader : end of sequence reached !"));
 
  if (usImageIo::getHeaderFormat(m_sequenceFiles.at(2 * m_imageCounter)) !=
      usImageIo::FORMAT_MHD) // check file extention
    throw(vpException(vpException::fatalError, "usMHDSequenceReader trying to open a non-mhd file !"));
 
  usMetaHeaderParser mhdParser;
  mhdParser.read(m_sequenceDirectory + vpIoTools::path("/") +
                 m_sequenceFiles.at(2 * m_imageCounter)); // we skip raw files
  m_sequenceImageType = mhdParser.getImageType();
  if (m_sequenceImageType != us::RF_2D && m_sequenceImageType != us::NOT_SET) {
    throw(vpException(vpException::badValue, "Reading a non rf 2D image!"));
  }
  if (mhdParser.getElementType() != usMetaHeaderParser::MET_SHORT) {
    throw(vpException(vpException::badValue, "Reading a non short image!"));
  }
 
  usMetaHeaderParser::MHDHeader mhdHeader = mhdParser.getMHDHeader();
  timestamp = mhdHeader.timestamp.at(0);
 
  usImagePreScanSettings settings;
  settings.setTransducerRadius(mhdHeader.transducerRadius);
  settings.setScanLinePitch(mhdHeader.scanLinePitch);
  settings.setTransducerConvexity(mhdHeader.isTransducerConvex);
  settings.setAxialResolution(mhdParser.getAxialResolution());
  settings.setDepth(settings.getAxialResolution() * mhdHeader.dim[1]);
  settings.setSamplingFrequency(mhdHeader.samplingFrequency);
  settings.setTransmitFrequency(mhdHeader.transmitFrequency);
  image.setImagePreScanSettings(settings);
 
  // resizing image in memory
  image.resize(mhdHeader.dim[1], mhdHeader.dim[0]);
 
  // data parsing
  usRawFileParser rawParser;
  rawParser.read(image, m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * m_imageCounter + 1));
 
  m_imageCounter++;
}
 
void usMHDSequenceReader::acquire(usImagePreScan2D<unsigned char> &image, uint64_t &timestamp)
{
  if (m_imageCounter > m_totalImageNumber)
    throw(vpException(vpException::fatalError, "usMHDSequenceReader : end of sequence reached !"));
 
  if (usImageIo::getHeaderFormat(m_sequenceFiles.at(2 * m_imageCounter)) !=
      usImageIo::FORMAT_MHD) // check file extention
    throw(vpException(vpException::fatalError, "usMHDSequenceReader trying to open a non-mhd file !"));
 
  usMetaHeaderParser mhdParser;
  mhdParser.read(m_sequenceDirectory + vpIoTools::path("/") +
                 m_sequenceFiles.at(2 * m_imageCounter)); // we skip raw files
  m_sequenceImageType = mhdParser.getImageType();
  if (m_sequenceImageType != us::PRESCAN_2D && m_sequenceImageType != us::NOT_SET) {
    throw(vpException(vpException::badValue, "Reading a non pre-scan 2D image!"));
  }
  if (mhdParser.getElementType() != usMetaHeaderParser::MET_UCHAR) {
    throw(vpException(vpException::badValue, "Reading a non unsigned char image!"));
  }
 
  usMetaHeaderParser::MHDHeader mhdHeader = mhdParser.getMHDHeader();
  timestamp = mhdHeader.timestamp.at(0);
 
  usImagePreScanSettings settings;
  settings.setTransducerRadius(mhdHeader.transducerRadius);
  settings.setScanLinePitch(mhdHeader.scanLinePitch);
  settings.setTransducerConvexity(mhdHeader.isTransducerConvex);
  settings.setAxialResolution(mhdParser.getAxialResolution());
  settings.setDepth(settings.getAxialResolution() * mhdHeader.dim[1]);
  settings.setSamplingFrequency(mhdHeader.samplingFrequency);
  settings.setTransmitFrequency(mhdHeader.transmitFrequency);
  image.setImagePreScanSettings(settings);
 
  // resizing image in memory
  image.resize(mhdHeader.dim[1], mhdHeader.dim[0]);
 
  // data parsing
  usRawFileParser rawParser;
  rawParser.read(image, m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * m_imageCounter + 1));
 
  m_imageCounter++;
}
 
void usMHDSequenceReader::acquire(usImagePostScan2D<unsigned char> &image, uint64_t &timestamp)
{
  if (m_imageCounter > m_totalImageNumber)
    throw(vpException(vpException::fatalError, "usMHDSequenceReader : end of sequence reached !"));
 
  if (usImageIo::getHeaderFormat(m_sequenceFiles.at(2 * m_imageCounter)) !=
      usImageIo::FORMAT_MHD) // check file extention
    throw(vpException(vpException::fatalError, "usMHDSequenceReader trying to open a non-mhd file !"));
 
  usMetaHeaderParser mhdParser;
  mhdParser.read(m_sequenceDirectory + vpIoTools::path("/") +
                 m_sequenceFiles.at(2 * m_imageCounter)); // we skip raw files
  m_sequenceImageType = mhdParser.getImageType();
  if (m_sequenceImageType != us::POSTSCAN_2D && m_sequenceImageType != us::NOT_SET) {
    throw(vpException(vpException::badValue, "Reading a non post-scan 2D image!"));
  }
  if (mhdParser.getElementType() != usMetaHeaderParser::MET_UCHAR) {
    throw(vpException(vpException::badValue, "Reading a non unsigned char image!"));
  }
 
  usMetaHeaderParser::MHDHeader mhdHeader = mhdParser.getMHDHeader();
  timestamp = mhdHeader.timestamp.at(0);
 
  usImagePreScanSettings settings;
  image.setTransducerRadius(mhdHeader.transducerRadius);
  image.setScanLinePitch(mhdHeader.scanLinePitch);
  image.setTransducerConvexity(mhdHeader.isTransducerConvex);
 
  // computing image depth from the pixel size and the transducer settings
  if (mhdHeader.isTransducerConvex) {
    // distance
    double deltaDepthPostScan2D =
        mhdHeader.transducerRadius *
        (1 - std::cos((double)((mhdHeader.scanLineNumber - 1) * mhdHeader.scanLinePitch / 2.0)));
    image.setDepth(mhdHeader.elementSpacing[1] * mhdHeader.dim[1] - deltaDepthPostScan2D);
  } else // linear transducer
    image.setDepth(mhdHeader.elementSpacing[1] * mhdHeader.dim[1]);
 
  image.setWidthResolution(mhdHeader.dim[0]);
  image.setWidthResolution(mhdHeader.dim[1]);
  image.setSamplingFrequency(mhdHeader.samplingFrequency);
  image.setTransmitFrequency(mhdHeader.transmitFrequency);
 
  // resizing image in memory
  image.resize(mhdHeader.dim[1], mhdHeader.dim[0]);
 
  // data parsing
  usRawFileParser rawParser;
  rawParser.read(image, m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * m_imageCounter + 1));
 
  m_imageCounter++;
}
 
void usMHDSequenceReader::acquire(usImageRF3D<short int> &image, std::vector<uint64_t> &timestamp)
{
  if (m_imageCounter > m_totalImageNumber)
    throw(vpException(vpException::fatalError, "usMHDSequenceReader : end of sequence reached !"));
 
  if (usImageIo::getHeaderFormat(m_sequenceFiles.at(2 * m_imageCounter)) !=
      usImageIo::FORMAT_MHD) // check file extention
    throw(vpException(vpException::fatalError, "usMHDSequenceReader trying to open a non-mhd file !"));
 
  usMetaHeaderParser mhdParser;
  mhdParser.read(m_sequenceDirectory + vpIoTools::path("/") +
                 m_sequenceFiles.at(2 * m_imageCounter)); // we skip raw files
  m_sequenceImageType = mhdParser.getImageType();
  if (m_sequenceImageType != us::RF_3D && m_sequenceImageType != us::NOT_SET) {
    throw(vpException(vpException::badValue, "Reading a non rf 3D image!"));
  }
  if (mhdParser.getElementType() != usMetaHeaderParser::MET_SHORT) {
    throw(vpException(vpException::badValue, "Reading a non short image!"));
  }
 
  usMetaHeaderParser::MHDHeader mhdHeader = mhdParser.getMHDHeader();
  timestamp = mhdHeader.timestamp;
  if (m_imageCounter % 2 == 1) // odd volume: we reverse it
    std::reverse(timestamp.begin(), timestamp.end());
 
  usImagePreScanSettings settings;
  settings.setTransducerRadius(mhdHeader.transducerRadius);
  settings.setScanLinePitch(mhdHeader.scanLinePitch);
  settings.setTransducerConvexity(mhdHeader.isTransducerConvex);
  settings.setAxialResolution(mhdParser.getAxialResolution());
  settings.setDepth(settings.getAxialResolution() * mhdHeader.dim[1]);
  settings.setSamplingFrequency(mhdHeader.samplingFrequency);
  settings.setTransmitFrequency(mhdHeader.transmitFrequency);
  image.setImagePreScanSettings(settings);
 
  usMotorSettings motorSettings;
  motorSettings.setMotorRadius(mhdHeader.motorRadius);
  motorSettings.setFramePitch(mhdHeader.framePitch);
  motorSettings.setMotorType(mhdHeader.motorType);
  motorSettings.setFrameNumber(mhdHeader.dim[2]);
  image.setMotorSettings(motorSettings);
 
  // resizing image in memory
  image.resize(mhdHeader.dim[1], mhdHeader.dim[0], mhdHeader.dim[2]);
 
  // data parsing
  usRawFileParser rawParser;
  rawParser.read(image, m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * m_imageCounter + 1));
 
  m_imageCounter++;
}
 
void usMHDSequenceReader::acquire(usImagePreScan3D<unsigned char> &image, std::vector<uint64_t> &timestamp)
{
  if (m_imageCounter > m_totalImageNumber)
    throw(vpException(vpException::fatalError, "usMHDSequenceReader : end of sequence reached !"));
 
  if (usImageIo::getHeaderFormat(m_sequenceFiles.at(2 * m_imageCounter)) !=
      usImageIo::FORMAT_MHD) // check file extention
    throw(vpException(vpException::fatalError, "usMHDSequenceReader trying to open a non-mhd file !"));
 
  usMetaHeaderParser mhdParser;
  mhdParser.read(m_sequenceDirectory + vpIoTools::path("/") +
                 m_sequenceFiles.at(2 * m_imageCounter)); // we skip raw files
  m_sequenceImageType = mhdParser.getImageType();
  if (m_sequenceImageType != us::PRESCAN_3D && m_sequenceImageType != us::NOT_SET) {
    throw(vpException(vpException::badValue, "Reading a non pre-scan 3D image!"));
  }
  if (mhdParser.getElementType() != usMetaHeaderParser::MET_UCHAR) {
    throw(vpException(vpException::badValue, "Reading a non unsigned char image!"));
  }
 
  usMetaHeaderParser::MHDHeader mhdHeader = mhdParser.getMHDHeader();
  timestamp = mhdHeader.timestamp;
  if (m_imageCounter % 2 == 1) // odd volume: we reverse it
    std::reverse(timestamp.begin(), timestamp.end());
 
  usImagePreScanSettings settings;
  settings.setTransducerRadius(mhdHeader.transducerRadius);
  settings.setScanLinePitch(mhdHeader.scanLinePitch);
  settings.setTransducerConvexity(mhdHeader.isTransducerConvex);
  settings.setAxialResolution(mhdParser.getAxialResolution());
  settings.setDepth(settings.getAxialResolution() * mhdHeader.dim[1]);
  settings.setSamplingFrequency(mhdHeader.samplingFrequency);
  settings.setTransmitFrequency(mhdHeader.transmitFrequency);
  image.setImagePreScanSettings(settings);
 
  usMotorSettings motorSettings;
  motorSettings.setMotorRadius(mhdHeader.motorRadius);
  motorSettings.setFramePitch(mhdHeader.framePitch);
  motorSettings.setMotorType(mhdHeader.motorType);
  motorSettings.setFrameNumber(mhdHeader.dim[2]);
  image.setMotorSettings(motorSettings);
 
  // resizing image in memory
  image.resize(mhdHeader.dim[1], mhdHeader.dim[0], mhdHeader.dim[2]);
 
  // data parsing
  usRawFileParser rawParser;
  rawParser.read(image, m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * m_imageCounter + 1));
 
  m_imageCounter++;
}
 
void usMHDSequenceReader::acquire(usImagePostScan3D<unsigned char> &image, uint64_t &timestamp)
{
  if (m_imageCounter > m_totalImageNumber)
    throw(vpException(vpException::fatalError, "usMHDSequenceReader : end of sequence reached !"));
 
  if (usImageIo::getHeaderFormat(m_sequenceFiles.at(2 * m_imageCounter)) !=
      usImageIo::FORMAT_MHD) // check file extention
    throw(vpException(vpException::fatalError, "usMHDSequenceReader trying to open a non-mhd file !"));
 
  usMetaHeaderParser mhdParser;
  mhdParser.read(m_sequenceDirectory + vpIoTools::path("/") +
                 m_sequenceFiles.at(2 * m_imageCounter)); // we skip raw files
  m_sequenceImageType = mhdParser.getImageType();
  if (m_sequenceImageType != us::POSTSCAN_3D && m_sequenceImageType != us::NOT_SET) {
    throw(vpException(vpException::badValue, "Reading a non post-scan 3D image!"));
  }
  if (mhdParser.getElementType() != usMetaHeaderParser::MET_UCHAR) {
    throw(vpException(vpException::badValue, "Reading a non unsigned char image!"));
  }
 
  usMetaHeaderParser::MHDHeader mhdHeader = mhdParser.getMHDHeader();
  timestamp = 0;
  if (mhdHeader.timestamp.size() > 0)
    timestamp = mhdHeader.timestamp.at(0);
 
  // resizing image in memory
  image.resize(mhdHeader.dim[1], mhdHeader.dim[0], mhdHeader.dim[2]);
 
  image.setTransducerRadius(mhdHeader.transducerRadius);
  image.setScanLinePitch(mhdHeader.scanLinePitch);
  image.setTransducerConvexity(mhdHeader.isTransducerConvex);
  image.setScanLineNumber(mhdHeader.scanLineNumber);
  image.setElementSpacingX(mhdHeader.elementSpacing[0]);
  image.setElementSpacingY(mhdHeader.elementSpacing[1]);
  image.setElementSpacingZ(mhdHeader.elementSpacing[2]);
  image.setMotorRadius(mhdHeader.motorRadius);
  image.setFramePitch(mhdHeader.framePitch);
  image.setFrameNumber(mhdHeader.frameNumber);
  image.setMotorType(mhdHeader.motorType);
  image.setSamplingFrequency(mhdHeader.samplingFrequency);
  image.setTransmitFrequency(mhdHeader.transmitFrequency);
 
  // data parsing
  usRawFileParser rawParser;
  rawParser.read(image, m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * m_imageCounter + 1));
 
  m_imageCounter++;
}
 
bool usMHDSequenceReader::end() { return m_imageCounter >= m_totalImageNumber; }
 
us::ImageType usMHDSequenceReader::getImageType() const { return m_sequenceImageType; }
 
uint64_t usMHDSequenceReader::getNextTimeStamp()
{
  usMetaHeaderParser mhdParser;
  mhdParser.read(m_sequenceDirectory + vpIoTools::path("/") +
                 m_sequenceFiles.at(2 * m_imageCounter)); // we skip raw files, imagecounter already incremented
  return mhdParser.getMHDHeader().timestamp.at(0);
}
 
std::vector<uint64_t> usMHDSequenceReader::getNextTimeStamps()
{
  usMetaHeaderParser mhdParser;
  mhdParser.read(m_sequenceDirectory + vpIoTools::path("/") +
                 m_sequenceFiles.at(2 * m_imageCounter)); // we skip raw files, imagecounter already incremented
  std::vector<uint64_t> timestamps = mhdParser.getMHDHeader().timestamp;
  if (m_imageCounter % 2 == 0) // current volume is even => next volume is odd
    std::reverse(timestamps.begin(), timestamps.end());
  return timestamps;
}
 
int usMHDSequenceReader::getImageNumber() const { return m_imageCounter; }
 
int usMHDSequenceReader::getTotalImageNumber() const { return m_totalImageNumber; }
 
void usMHDSequenceReader::getImage(unsigned int imageNumber, usImageRF2D<short int> &image, uint64_t &timestamp)
{
 
  if (imageNumber > (unsigned int)m_totalImageNumber)
    throw(vpException(vpException::fatalError,
                      "usMHDSequenceReader : trying to acquire an image with an index out of sequence bounds !"));
 
  if (usImageIo::getHeaderFormat(m_sequenceFiles.at(2 * imageNumber)) != usImageIo::FORMAT_MHD) // check file extention
    throw(vpException(vpException::fatalError, "usMHDSequenceReader trying to open a non-mhd file !"));
 
  usMetaHeaderParser mhdParser;
  mhdParser.read(m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * imageNumber)); // we skip raw files
  m_sequenceImageType = mhdParser.getImageType();
  if (m_sequenceImageType != us::RF_2D && m_sequenceImageType != us::NOT_SET) {
    throw(vpException(vpException::badValue, "Reading a non rf 2D image!"));
  }
  if (mhdParser.getElementType() != usMetaHeaderParser::MET_SHORT) {
    throw(vpException(vpException::badValue, "Reading a non short image!"));
  }
 
  usMetaHeaderParser::MHDHeader mhdHeader = mhdParser.getMHDHeader();
  timestamp = mhdHeader.timestamp.at(0);
 
  usImagePreScanSettings settings;
  settings.setTransducerRadius(mhdHeader.transducerRadius);
  settings.setScanLinePitch(mhdHeader.scanLinePitch);
  settings.setTransducerConvexity(mhdHeader.isTransducerConvex);
  settings.setAxialResolution(mhdParser.getAxialResolution());
  settings.setDepth(settings.getAxialResolution() * mhdHeader.dim[1]);
  settings.setSamplingFrequency(mhdHeader.samplingFrequency);
  settings.setTransmitFrequency(mhdHeader.transmitFrequency);
  image.setImagePreScanSettings(settings);
 
  // resizing image in memory
  image.resize(mhdHeader.dim[1], mhdHeader.dim[0]);
 
  // data parsing
  usRawFileParser rawParser;
  rawParser.read(image, m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * imageNumber + 1));
}
 
void usMHDSequenceReader::getImage(unsigned int imageNumber, usImagePreScan2D<unsigned char> &image,
                                   uint64_t &timestamp)
{
  if (imageNumber > (unsigned int)m_totalImageNumber)
    throw(vpException(vpException::fatalError,
                      "usMHDSequenceReader : trying to acquire an image with an index out of sequence bounds !"));
 
  if (usImageIo::getHeaderFormat(m_sequenceFiles.at(2 * imageNumber)) != usImageIo::FORMAT_MHD) // check file extention
    throw(vpException(vpException::fatalError, "usMHDSequenceReader trying to open a non-mhd file !"));
 
  usMetaHeaderParser mhdParser;
  mhdParser.read(m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * imageNumber)); // we skip raw files
  m_sequenceImageType = mhdParser.getImageType();
  if (m_sequenceImageType != us::PRESCAN_2D && m_sequenceImageType != us::NOT_SET) {
    throw(vpException(vpException::badValue, "Reading a non pre-scan 2D image!"));
  }
  if (mhdParser.getElementType() != usMetaHeaderParser::MET_UCHAR) {
    throw(vpException(vpException::badValue, "Reading a non unsigned char image!"));
  }
 
  usMetaHeaderParser::MHDHeader mhdHeader = mhdParser.getMHDHeader();
  timestamp = mhdHeader.timestamp.at(0);
 
  usImagePreScanSettings settings;
  settings.setTransducerRadius(mhdHeader.transducerRadius);
  settings.setScanLinePitch(mhdHeader.scanLinePitch);
  settings.setTransducerConvexity(mhdHeader.isTransducerConvex);
  settings.setAxialResolution(mhdParser.getAxialResolution());
  settings.setDepth(settings.getAxialResolution() * mhdHeader.dim[1]);
  settings.setSamplingFrequency(mhdHeader.samplingFrequency);
  settings.setTransmitFrequency(mhdHeader.transmitFrequency);
  image.setImagePreScanSettings(settings);
 
  // resizing image in memory
  image.resize(mhdHeader.dim[1], mhdHeader.dim[0]);
 
  // data parsing
  usRawFileParser rawParser;
  rawParser.read(image, m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * imageNumber + 1));
}
 
void usMHDSequenceReader::getImage(unsigned int imageNumber, usImagePostScan2D<unsigned char> &image,
                                   uint64_t &timestamp)
{
  if (imageNumber > (unsigned int)m_totalImageNumber)
    throw(vpException(vpException::fatalError,
                      "usMHDSequenceReader : trying to acquire an image with an index out of sequence bounds !"));
 
  if (usImageIo::getHeaderFormat(m_sequenceFiles.at(2 * imageNumber)) != usImageIo::FORMAT_MHD) // check file extention
    throw(vpException(vpException::fatalError, "usMHDSequenceReader trying to open a non-mhd file !"));
 
  usMetaHeaderParser mhdParser;
  mhdParser.read(m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * imageNumber)); // we skip raw files
  m_sequenceImageType = mhdParser.getImageType();
  if (m_sequenceImageType != us::POSTSCAN_2D && m_sequenceImageType != us::NOT_SET) {
    throw(vpException(vpException::badValue, "Reading a non post-scan 2D image!"));
  }
  if (mhdParser.getElementType() != usMetaHeaderParser::MET_UCHAR) {
    throw(vpException(vpException::badValue, "Reading a non unsigned char image!"));
  }
 
  usMetaHeaderParser::MHDHeader mhdHeader = mhdParser.getMHDHeader();
  timestamp = mhdHeader.timestamp.at(0);
 
  usImagePreScanSettings settings;
  image.setTransducerRadius(mhdHeader.transducerRadius);
  image.setScanLinePitch(mhdHeader.scanLinePitch);
  image.setTransducerConvexity(mhdHeader.isTransducerConvex);
 
  // computing image depth from the pixel size and the transducer settings
  if (mhdHeader.isTransducerConvex) {
    // distance
    double deltaDepthPostScan2D =
        mhdHeader.transducerRadius *
        (1 - std::cos((double)((mhdHeader.scanLineNumber - 1) * mhdHeader.scanLinePitch / 2.0)));
    image.setDepth(mhdHeader.elementSpacing[1] * mhdHeader.dim[1] - deltaDepthPostScan2D);
  } else // linear transducer
    image.setDepth(mhdHeader.elementSpacing[1] * mhdHeader.dim[1]);
 
  image.setWidthResolution(mhdHeader.dim[0]);
  image.setWidthResolution(mhdHeader.dim[1]);
  image.setSamplingFrequency(mhdHeader.samplingFrequency);
  image.setTransmitFrequency(mhdHeader.transmitFrequency);
 
  // resizing image in memory
  image.resize(mhdHeader.dim[1], mhdHeader.dim[0]);
 
  // data parsing
  usRawFileParser rawParser;
  rawParser.read(image, m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * imageNumber + 1));
}
 
void usMHDSequenceReader::getImage(unsigned int imageNumber, usImageRF3D<short int> &image,
                                   std::vector<uint64_t> &timestamp)
{
  if (imageNumber > (unsigned int)m_totalImageNumber)
    throw(vpException(vpException::fatalError, "usMHDSequenceReader : end of sequence reached !"));
 
  if (usImageIo::getHeaderFormat(m_sequenceFiles.at(2 * imageNumber)) != usImageIo::FORMAT_MHD) // check file extention
    throw(vpException(vpException::fatalError, "usMHDSequenceReader trying to open a non-mhd file !"));
 
  usMetaHeaderParser mhdParser;
  mhdParser.read(m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * imageNumber)); // we skip raw files
  m_sequenceImageType = mhdParser.getImageType();
  if (m_sequenceImageType != us::RF_3D && m_sequenceImageType != us::NOT_SET) {
    throw(vpException(vpException::badValue, "Reading a non rf 3D image!"));
  }
  if (mhdParser.getElementType() != usMetaHeaderParser::MET_SHORT) {
    throw(vpException(vpException::badValue, "Reading a non short image!"));
  }
 
  usMetaHeaderParser::MHDHeader mhdHeader = mhdParser.getMHDHeader();
  timestamp = mhdHeader.timestamp;
  if (imageNumber % 2 == 1) // odd volume: we reverse it
    std::reverse(timestamp.begin(), timestamp.end());
 
  usImagePreScanSettings settings;
  settings.setTransducerRadius(mhdHeader.transducerRadius);
  settings.setScanLinePitch(mhdHeader.scanLinePitch);
  settings.setTransducerConvexity(mhdHeader.isTransducerConvex);
  settings.setAxialResolution(mhdParser.getAxialResolution());
  settings.setDepth(settings.getAxialResolution() * mhdHeader.dim[1]);
  settings.setSamplingFrequency(mhdHeader.samplingFrequency);
  settings.setTransmitFrequency(mhdHeader.transmitFrequency);
  image.setImagePreScanSettings(settings);
 
  usMotorSettings motorSettings;
  motorSettings.setMotorRadius(mhdHeader.motorRadius);
  motorSettings.setFramePitch(mhdHeader.framePitch);
  motorSettings.setMotorType(mhdHeader.motorType);
  motorSettings.setFrameNumber(mhdHeader.dim[2]);
  image.setMotorSettings(motorSettings);
 
  // resizing image in memory
  image.resize(mhdHeader.dim[1], mhdHeader.dim[0], mhdHeader.dim[2]);
 
  // data parsing
  usRawFileParser rawParser;
  rawParser.read(image, m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * imageNumber + 1));
}
 
void usMHDSequenceReader::getImage(unsigned int imageNumber, usImagePreScan3D<unsigned char> &image,
                                   std::vector<uint64_t> &timestamp)
{
  if (imageNumber > (unsigned int)m_totalImageNumber)
    throw(vpException(vpException::fatalError, "usMHDSequenceReader : end of sequence reached !"));
 
  if (usImageIo::getHeaderFormat(m_sequenceFiles.at(2 * imageNumber)) != usImageIo::FORMAT_MHD) // check file extention
    throw(vpException(vpException::fatalError, "usMHDSequenceReader trying to open a non-mhd file !"));
 
  usMetaHeaderParser mhdParser;
  mhdParser.read(m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * imageNumber)); // we skip raw files
  m_sequenceImageType = mhdParser.getImageType();
  if (m_sequenceImageType != us::PRESCAN_3D && m_sequenceImageType != us::NOT_SET) {
    throw(vpException(vpException::badValue, "Reading a non pre-scan 3D image!"));
  }
  if (mhdParser.getElementType() != usMetaHeaderParser::MET_UCHAR) {
    throw(vpException(vpException::badValue, "Reading a non unsigned char image!"));
  }
 
  usMetaHeaderParser::MHDHeader mhdHeader = mhdParser.getMHDHeader();
  timestamp = mhdHeader.timestamp;
  if (imageNumber % 2 == 1) // odd volume: we reverse it
    std::reverse(timestamp.begin(), timestamp.end());
 
  usImagePreScanSettings settings;
  settings.setTransducerRadius(mhdHeader.transducerRadius);
  settings.setScanLinePitch(mhdHeader.scanLinePitch);
  settings.setTransducerConvexity(mhdHeader.isTransducerConvex);
  settings.setAxialResolution(mhdParser.getAxialResolution());
  settings.setDepth(settings.getAxialResolution() * mhdHeader.dim[1]);
  settings.setSamplingFrequency(mhdHeader.samplingFrequency);
  settings.setTransmitFrequency(mhdHeader.transmitFrequency);
  image.setImagePreScanSettings(settings);
 
  usMotorSettings motorSettings;
  motorSettings.setMotorRadius(mhdHeader.motorRadius);
  motorSettings.setFramePitch(mhdHeader.framePitch);
  motorSettings.setMotorType(mhdHeader.motorType);
  motorSettings.setFrameNumber(mhdHeader.dim[2]);
  image.setMotorSettings(motorSettings);
 
  // resizing image in memory
  image.resize(mhdHeader.dim[1], mhdHeader.dim[0], mhdHeader.dim[2]);
 
  // data parsing
  usRawFileParser rawParser;
  rawParser.read(image, m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * imageNumber + 1));
}
 
void usMHDSequenceReader::getImage(unsigned int imageNumber, usImagePostScan3D<unsigned char> &image,
                                   uint64_t &timestamp)
{
  if (imageNumber > (unsigned int)m_totalImageNumber)
    throw(vpException(vpException::fatalError,
                      "usMHDSequenceReader : trying to acquire an image with an index out of sequence bounds !"));
 
  if (usImageIo::getHeaderFormat(m_sequenceFiles.at(2 * imageNumber)) != usImageIo::FORMAT_MHD) // check file extention
    throw(vpException(vpException::fatalError, "usMHDSequenceReader trying to open a non-mhd file !"));
 
  usMetaHeaderParser mhdParser;
  mhdParser.read(m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * imageNumber)); // we skip raw files
  m_sequenceImageType = mhdParser.getImageType();
  if (m_sequenceImageType != us::POSTSCAN_3D && m_sequenceImageType != us::NOT_SET) {
    throw(vpException(vpException::badValue, "Reading a non post-scan 3D image!"));
  }
  if (mhdParser.getElementType() != usMetaHeaderParser::MET_UCHAR) {
    throw(vpException(vpException::badValue, "Reading a non unsigned char image!"));
  }
 
  usMetaHeaderParser::MHDHeader mhdHeader = mhdParser.getMHDHeader();
  timestamp = 0;
  if (mhdHeader.timestamp.size() > 0)
    timestamp = mhdHeader.timestamp.at(0);
 
  // resizing image in memory
  image.resize(mhdHeader.dim[1], mhdHeader.dim[0], mhdHeader.dim[2]);
 
  image.setTransducerRadius(mhdHeader.transducerRadius);
  image.setScanLinePitch(mhdHeader.scanLinePitch);
  image.setTransducerConvexity(mhdHeader.isTransducerConvex);
  image.setScanLineNumber(mhdHeader.scanLineNumber);
  image.setElementSpacingX(mhdHeader.elementSpacing[0]);
  image.setElementSpacingY(mhdHeader.elementSpacing[1]);
  image.setElementSpacingZ(mhdHeader.elementSpacing[2]);
  image.setMotorRadius(mhdHeader.motorRadius);
  image.setFramePitch(mhdHeader.framePitch);
  image.setFrameNumber(mhdHeader.frameNumber);
  image.setMotorType(mhdHeader.motorType);
  image.setSamplingFrequency(mhdHeader.samplingFrequency);
  image.setTransmitFrequency(mhdHeader.transmitFrequency);
 
  // data parsing
  usRawFileParser rawParser;
  rawParser.read(image, m_sequenceDirectory + vpIoTools::path("/") + m_sequenceFiles.at(2 * imageNumber + 1));
}