dataarraywriter.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_GRID_IO_FILE_VTK_DATAARRAYWRITER_HH
#define DUNE_GRID_IO_FILE_VTK_DATAARRAYWRITER_HH
 
#include <cstdint>
#include <iostream>
#include <string>
#include <iomanip>
#include <cstdint>
#include <cmath>
 
#include <dune/common/exceptions.hh>
#include <dune/common/indent.hh>
 
#include <dune/grid/io/file/vtk/streams.hh>
#include <dune/grid/io/file/vtk/common.hh>
 
namespace Dune
{
 
  namespace VTK {
 
 
    class DataArrayWriter
    {
    public:
 
      DataArrayWriter(Precision _prec)
      : prec(_prec)
      {}
 
      template<class T>
      void write(T data)
      {
        switch(prec)
        {
          case Precision::float32:
            writeFloat32(data); break;
          case Precision::float64:
            writeFloat64(data); break;
          case Precision::uint32:
            writeUInt32(data); break;
          case Precision::uint8:
            writeUInt8(data); break;
          case Precision::int32:
            writeInt32(data); break;
          default:
            DUNE_THROW(Dune::NotImplemented, "Unknown precision type");
        }
      }
 
      virtual bool writeIsNoop() const { return false; }
      virtual ~DataArrayWriter () {}
 
    private:
      virtual void writeFloat32 (float data) = 0;
      virtual void writeFloat64 (double data) = 0;
      virtual void writeInt32 (std::int32_t data) = 0;
      virtual void writeUInt8 (std::uint8_t data) = 0;
      virtual void writeUInt32 (std::uint32_t data) = 0;
 
      Precision prec;
    };
 
    class AsciiDataArrayWriter : public DataArrayWriter
    {
    public:
 
      AsciiDataArrayWriter(std::ostream& theStream, std::string name,
                           int ncomps, const Indent& indent_, Precision prec_)
        : DataArrayWriter(prec_), s(theStream), counter(0), numPerLine(12), indent(indent_)
      {
        s << indent << "<DataArray type=\"" << toString(prec_) << "\" "
          << "Name=\"" << name << "\" ";
        s << "NumberOfComponents=\"" << ncomps << "\" ";
        s << "format=\"ascii\">\n";
        ++indent;
      }
 
      ~AsciiDataArrayWriter ()
      {
        if (counter%numPerLine!=0) s << "\n";
        --indent;
        s << indent << "</DataArray>\n";
      }
 
    private:
      void writeFloat64 (double data) final
      { write_float(data); }
      void writeFloat32 (float data) final
      { write_float(data); }
      void writeInt32 (std::int32_t data) final
      { write_(data); }
      void writeUInt32 (std::uint32_t data) final
      { write_(data); }
      void writeUInt8 (std::uint8_t data) final
      { write_(data); }
 
      template<class T>
      void write_(T data)
      {
        typedef typename PrintType<T>::Type PT;
        if(counter%numPerLine==0) s << indent;
        else s << " ";
        const auto original_precision = std::cout.precision();
        s << std::setprecision(std::numeric_limits<PT>::digits10) << (PT) data;
        std::cout.precision(original_precision);
        counter++;
        if (counter%numPerLine==0) s << "\n";
      }
 
      template<class T>
      void write_float(T data)
      {
        typedef typename PrintType<T>::Type PT;
        if(counter%numPerLine==0) s << indent;
        else s << " ";
        PT out_data = (PT) data;
        if (std::fpclassify(out_data) == FP_SUBNORMAL)
        {
          // truncate denormalized data to 0 to avoid Paraview segfaults on macOS
          out_data = 0;
        }
        const auto original_precision = std::cout.precision();
        s << std::setprecision(std::numeric_limits<PT>::digits10) << out_data;
        std::cout.precision(original_precision);
        counter++;
        if (counter%numPerLine==0) s << "\n";
      }
 
      std::ostream& s;
      int counter;
      int numPerLine;
      Indent indent;
    };
 
    class BinaryDataArrayWriter : public DataArrayWriter
    {
    public:
 
      BinaryDataArrayWriter(std::ostream& theStream, std::string name,
                            int ncomps, int nitems, const Indent& indent_, Precision prec_)
        : DataArrayWriter(prec_), s(theStream), b64(theStream), indent(indent_)
      {
        s << indent << "<DataArray type=\"" << toString(prec_) << "\" "
          << "Name=\"" << name << "\" ";
        s << "NumberOfComponents=\"" << ncomps << "\" ";
        s << "format=\"binary\">\n";
 
        // write indentation for the data chunk
        s << indent+1;
        // store size, needs to be exactly 32 bit
        std::uint32_t size = ncomps*nitems*typeSize(prec_);
        b64.write(size);
        b64.flush();
      }
 
      ~BinaryDataArrayWriter ()
      {
        b64.flush();
        // append newline to written data
        s << "\n";
        s << indent << "</DataArray>\n";
        s.flush();
      }
 
    private:
      void writeFloat64 (double data) final
      { write_(data); }
      void writeFloat32 (float data) final
      { write_(data); }
      void writeInt32 (std::int32_t data) final
      { write_(data); }
      void writeUInt32 (std::uint32_t data) final
      { write_(data); }
      void writeUInt8 (std::uint8_t data) final
      { write_(data); }
 
      template<class T>
      void write_(T data)
      {
        b64.write(data);
      }
 
      std::ostream& s;
      Base64Stream b64;
      const Indent& indent;
    };
 
    class AppendedRawDataArrayWriter : public DataArrayWriter
    {
    public:
 
      AppendedRawDataArrayWriter(std::ostream& s, std::string name,
                                 int ncomps, unsigned nitems, unsigned& offset,
                                 const Indent& indent, Precision prec_)
      : DataArrayWriter(prec_)
      {
        s << indent << "<DataArray type=\"" << toString(prec_) << "\" "
          << "Name=\"" << name << "\" ";
        s << "NumberOfComponents=\"" << ncomps << "\" ";
        s << "format=\"appended\" offset=\""<< offset << "\" />\n";
        offset += 4; // header
        offset += ncomps*nitems*typeSize(prec_);
      }
 
      bool writeIsNoop() const { return true; }
 
    private:
      void writeFloat64 (double) final {}
      void writeFloat32 (float) final {}
      void writeInt32 (std::int32_t) final {}
      void writeUInt32 (std::uint32_t) final {}
      void writeUInt8 (std::uint8_t) final {}
    };
 
    class AppendedBase64DataArrayWriter : public DataArrayWriter
    {
    public:
 
      AppendedBase64DataArrayWriter(std::ostream& s, std::string name,
                                    int ncomps, unsigned nitems,
                                    unsigned& offset, const Indent& indent, Precision prec_)
      : DataArrayWriter(prec_)
      {
        s << indent << "<DataArray type=\"" << toString(prec_) << "\" "
          << "Name=\"" << name << "\" ";
        s << "NumberOfComponents=\"" << ncomps << "\" ";
        s << "format=\"appended\" offset=\""<< offset << "\" />\n";
        offset += 8; // header
        std::size_t bytes = ncomps*nitems*typeSize(prec_);
        offset += bytes/3*4;
        if(bytes%3 != 0)
          offset += 4;
      }
 
      bool writeIsNoop() const { return true; }
 
    private:
      void writeFloat64 (double) final {}
      void writeFloat32 (float) final {}
      void writeInt32 (std::int32_t) final {}
      void writeUInt32 (std::uint32_t) final {}
      void writeUInt8 (std::uint8_t) final {}
    };
 
    //
    //  Naked ArrayWriters for the appended section
    //
 
    class NakedBase64DataArrayWriter : public DataArrayWriter
    {
    public:
 
      NakedBase64DataArrayWriter(std::ostream& theStream, int ncomps,
                                 int nitems, Precision prec_)
        : DataArrayWriter(prec_), b64(theStream)
      {
        // store size
        std::uint32_t size = ncomps*nitems*typeSize(prec_);
        b64.write(size);
        b64.flush();
      }
 
    private:
      void writeFloat64 (double data) final
      { write_(data); }
      void writeFloat32 (float data) final
      { write_(data); }
      void writeInt32 (std::int32_t data) final
      { write_(data); }
      void writeUInt32 (std::uint32_t data) final
      { write_(data); }
      void writeUInt8 (std::uint8_t data) final
      { write_(data); }
 
      template<class T>
      void write_(T data)
      {
          b64.write(data);
      }
 
      Base64Stream b64;
    };
 
    class NakedRawDataArrayWriter : public DataArrayWriter
    {
      RawStream s;
 
    public:
 
      NakedRawDataArrayWriter(std::ostream& theStream, int ncomps,
                              int nitems, Precision prec_)
        : DataArrayWriter(prec_), s(theStream)
      {
        s.write((unsigned int)(ncomps*nitems*typeSize(prec_)));
      }
 
    private:
      void writeFloat64 (double data) final
      { write_(data); }
      void writeFloat32 (float data) final
      { write_(data); }
      void writeInt32 (std::int32_t data) final
      { write_(data); }
      void writeUInt32 (std::uint32_t data) final
      { write_(data); }
      void writeUInt8 (std::uint8_t data) final
      { write_(data); }
 
      template<class T>
      void write_(T data)
      {
        s.write(data);
      }
    };
 
    //
    //  Factory
    //
 
 
    class DataArrayWriterFactory {
      enum Phase { main, appended };
 
      OutputType type;
      std::ostream& stream;
      unsigned offset;
      Phase phase;
 
    public:
 
      inline DataArrayWriterFactory(OutputType type_, std::ostream& stream_)
        : type(type_), stream(stream_), offset(0), phase(main)
      { }
 
 
      inline bool beginAppended() {
        phase = appended;
        switch(type) {
        case ascii :          return false;
        case base64 :         return false;
        case appendedraw :    return true;
        case appendedbase64 : return true;
        }
        DUNE_THROW(IOError, "Dune::VTK::DataArrayWriter: unsupported "
                   "OutputType " << type);
      }
 
      const std::string& appendedEncoding() const {
        static const std::string rawString = "raw";
        static const std::string base64String = "base64";
 
        switch(type) {
        case ascii :
        case base64 :
          DUNE_THROW(IOError, "DataArrayWriterFactory::appendedEncoding(): No "
                     "appended encoding for OutputType " << type);
        case appendedraw :    return rawString;
        case appendedbase64 : return base64String;
        }
        DUNE_THROW(IOError, "DataArrayWriterFactory::appendedEncoding(): "
                   "unsupported OutputType " << type);
      }
 
 
      DataArrayWriter* make(const std::string& name, unsigned ncomps,
                            unsigned nitems, const Indent& indent,
                            Precision prec)
      {
        switch(phase) {
        case main :
          switch(type) {
          case ascii :
            return new AsciiDataArrayWriter(stream, name, ncomps, indent, prec);
          case base64 :
            return new BinaryDataArrayWriter(stream, name, ncomps, nitems,
                                             indent, prec);
          case appendedraw :
            return new AppendedRawDataArrayWriter(stream, name, ncomps,
                                                  nitems, offset, indent, prec);
          case appendedbase64 :
            return new AppendedBase64DataArrayWriter(stream, name, ncomps,
                                                     nitems, offset,
                                                     indent, prec);
          }
          break;
        case appended :
          switch(type) {
          case ascii :
          case base64 :
            break; // invlid in appended mode
          case appendedraw :
            return new NakedRawDataArrayWriter(stream, ncomps, nitems, prec);
          case appendedbase64 :
            return new NakedBase64DataArrayWriter(stream, ncomps, nitems, prec);
          }
          break;
        }
        DUNE_THROW(IOError, "Dune::VTK::DataArrayWriter: unsupported "
                   "OutputType " << type << " in phase " << phase);
      }
    };
 
  } // namespace VTK
 
 
} // namespace Dune
 
#endif // DUNE_GRID_IO_FILE_VTK_DATAARRAYWRITER_HH