usSequenceWriter.h

/****************************************************************************
 *
 * This file is part of the ustk software.
 * Copyright (C) 2016 - 2017 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ustk with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at ustk@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Authors:
 * Marc Pouliquen
 *
 *****************************************************************************/
 
#ifndef __usSequenceWriter_h_
#define __usSequenceWriter_h_
 
#include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
 
#include <visp3/core/vpDebug.h>
#include <visp3/core/vpException.h>
#include <visp3/core/vpImage.h>
#include <visp3/io/vpImageIo.h>
 
#include <visp3/ustk_core/usImageIo.h>
#include <visp3/ustk_core/usImageSettingsXmlParser.h>
 
template <class ImageType> class usSequenceWriter
{
public:
  usSequenceWriter();
  virtual ~usSequenceWriter();
 
  void close();
 
  double getFrameRate() const;
 
  void saveImage(const ImageType &image, uint64_t timestamp = 0);
 
  void setFirstFrameIndex(long firstIndex);
  void setFrameRate(double frameRate);
  void setImageFileName(const std::string &imageFileName);
  void setSequenceFileName(const std::string &sequenceFileName);
 
private:
  ImageType m_frame;
 
  double m_frameRate;
 
  long m_firstFrame;
  bool m_firstFrameIsSet;
  long m_frameCount;
 
  std::string m_sequenceFileName;
  std::string m_genericImageFileName;
  bool m_headerFileNameIsSet;
  bool m_imageFileNameIsSet;
 
  bool is_open;
 
  void open(const ImageType &image, uint64_t timestamp = 0);
};
 
/****************************************************************************
* Template implementations.
****************************************************************************/
 
template <class ImageType>
usSequenceWriter<ImageType>::usSequenceWriter()
  : m_frame(), m_frameRate(0.0), m_firstFrame(0), m_firstFrameIsSet(false), m_frameCount(0), m_sequenceFileName(""),
  m_genericImageFileName(""), m_headerFileNameIsSet(false), m_imageFileNameIsSet(false), is_open(false)
{ }
 
template <class ImageType> usSequenceWriter<ImageType>::~usSequenceWriter() { close(); }
 
template <class ImageType> void usSequenceWriter<ImageType>::setFrameRate(double frameRate) { m_frameRate = frameRate; }
 
template <class ImageType> double usSequenceWriter<ImageType>::getFrameRate() const { return m_frameRate; }
 
template <class ImageType> void usSequenceWriter<ImageType>::setSequenceFileName(const std::string &sequenceFileName)
{
  m_sequenceFileName = sequenceFileName;
  m_headerFileNameIsSet = true;
}
 
template <class ImageType> void usSequenceWriter<ImageType>::setImageFileName(const std::string &imageFileName)
{
  // create subdirectory if there is one
  if (m_headerFileNameIsSet) {
    std::string relativePathToHeader = vpIoTools::getParent(imageFileName);
    if (!relativePathToHeader.empty()) {
      std::string fullDirName = vpIoTools::getParent(m_sequenceFileName) + vpIoTools::path("/") + relativePathToHeader;
      vpIoTools::makeDirectory(fullDirName);
    }
    m_genericImageFileName = imageFileName;
    m_imageFileNameIsSet = true;
  }
}
 
template <class ImageType> void usSequenceWriter<ImageType>::setFirstFrameIndex(long firstIndex)
{
  m_firstFrame = firstIndex;
  m_firstFrameIsSet = true;
}
 
template <class ImageType> void usSequenceWriter<ImageType>::open(const ImageType &image, uint64_t timestamp)
{
  if (!m_headerFileNameIsSet || !m_imageFileNameIsSet)
    throw(vpException(vpException::badValue, "file names not set"));
 
  // if not first index set, we begin at index 0
  if (!m_firstFrameIsSet) {
    m_firstFrame = 0;
    m_frameCount = 0;
    m_firstFrameIsSet = true;
  }
 
  // saving the settings for all the sequence
  m_frame = image;
 
  // Reading image
  char buffer[FILENAME_MAX];
  snprintf(buffer, FILENAME_MAX, m_genericImageFileName.c_str(), m_frameCount);
 
  // case of timestamp to add
  if (timestamp != 0) {
    std::vector<std::string> splitted = vpIoTools::splitChain(std::string(buffer), std::string("."));
    std::string base = splitted.at(0);
    base.append(std::string(".%lld."));
    base.append(splitted.at(1));
    snprintf(buffer, FILENAME_MAX, base.c_str(), timestamp);
    std::vector<std::string> splittedGeneric =
      vpIoTools::splitChain(std::string(m_genericImageFileName), std::string("."));
    m_genericImageFileName = splittedGeneric.at(0) + std::string(".TIMESTAMP.") + splittedGeneric.at(1);
  }
 
  std::string imageFileName = vpIoTools::getParent(m_sequenceFileName) + vpIoTools::path("/") + buffer;
 
  vpImageIo::write(image, imageFileName);
 
  m_frameCount = m_firstFrame + 1;
  is_open = true;
}
 
template <class ImageType> void usSequenceWriter<ImageType>::close()
{
  throw(vpException(vpException::notImplementedError));
}
 
template <> inline void usSequenceWriter<usImageRF2D<unsigned char> >::close()
{
  if (!is_open)
    return;
 
  // saving settings
  usImageSettingsXmlParser xmlParser;
  xmlParser.setImageSettings(m_frame.getTransducerRadius(), m_frame.getScanLinePitch(), m_frame.isTransducerConvex(),
                             m_frame.getAxialResolution(), us::RF_2D, m_frame.getSamplingFrequency(),
                             m_frame.getTransmitFrequency());
  xmlParser.setSequenceFrameRate(m_frameRate);
  xmlParser.setSequenceStartNumber(m_firstFrame);
  xmlParser.setSequenceStopNumber(m_frameCount - 1);
  xmlParser.setImageFileName(m_genericImageFileName);
  xmlParser.save(m_sequenceFileName);
  vpXmlParser::cleanup();
}
 
template <> inline void usSequenceWriter<usImagePreScan2D<unsigned char> >::close()
{
  if (!is_open)
    return;
 
  // saving settings
  usImageSettingsXmlParser xmlParser;
  xmlParser.setImageSettings(m_frame.getTransducerRadius(), m_frame.getScanLinePitch(), m_frame.isTransducerConvex(),
                             m_frame.getAxialResolution(), us::PRESCAN_2D, m_frame.getSamplingFrequency(),
                             m_frame.getTransmitFrequency());
  xmlParser.setImageType(us::PRESCAN_2D);
  xmlParser.setSequenceFrameRate(m_frameRate);
  xmlParser.setSequenceStartNumber(m_firstFrame);
  xmlParser.setSequenceStopNumber(m_frameCount - 1);
  xmlParser.setImageFileName(m_genericImageFileName);
  xmlParser.save(m_sequenceFileName);
  vpXmlParser::cleanup();
}
 
template <> inline void usSequenceWriter<usImagePostScan2D<unsigned char> >::close()
{
  if (!is_open)
    return;
 
  // saving settings
  usImageSettingsXmlParser xmlParser;
  xmlParser.setImageSettings(m_frame.getTransducerRadius(), m_frame.getScanLinePitch(), m_frame.isTransducerConvex(),
                             m_frame.getScanLineNumber(), m_frame.getWidthResolution(), m_frame.getHeightResolution(),
                             m_frame.getSamplingFrequency(), m_frame.getTransmitFrequency());
 
  xmlParser.setImageType(us::POSTSCAN_2D);
  xmlParser.setSequenceFrameRate(m_frameRate);
  xmlParser.setSequenceStartNumber(m_firstFrame);
  xmlParser.setSequenceStopNumber(m_frameCount - 1);
  xmlParser.setImageFileName(m_genericImageFileName);
  xmlParser.save(m_sequenceFileName);
  vpXmlParser::cleanup();
}
 
template <class ImageType> void usSequenceWriter<ImageType>::saveImage(const ImageType &image, uint64_t timestamp)
{
  if (!is_open) {
    open(image, timestamp);
    return; // first image has been written by open();
  }
 
  // Writing image
  char buffer[FILENAME_MAX];
  snprintf(buffer, FILENAME_MAX, m_genericImageFileName.c_str(), m_frameCount);
 
  // case of timestamp to add
  if (timestamp != 0) {
    std::vector<std::string> splitted = vpIoTools::splitChain(std::string(buffer), std::string("."));
    std::string base = splitted.at(0);
    base.append(std::string(".%lld."));
    base.append(splitted.at(2));
    snprintf(buffer, FILENAME_MAX, base.c_str(), timestamp);
  }
 
  std::string imageFileName = vpIoTools::getParent(m_sequenceFileName) + vpIoTools::path("/") + buffer;
 
  vpImageIo::write(image, imageFileName);
 
  m_frameCount = m_frameCount + 1;
}
 
#endif // __usSequenceWriter_h_