meta.h

Go to the documentation of this file.

// Copyright 2017-2020, Schlumberger
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include "../declspec.h"
#include "../exception.h"
#include "file.h"
#include "enum.h"
#include "lookuptable.h"
 
#include <cstdint>
#include <memory>
#include <ostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <cstring>
 
namespace InternalZGY {
#if 0
}
#endif
 
class ZgyInternalWriterArgs
{
public:
  std::string                filename;
  std::array<std::int64_t,3> size;
  std::array<std::int64_t,3> bricksize;
  RawDataType                datatype;
  std::array<float,2>        datarange;
  RawVerticalDimension       zunitdim;
  RawHorizontalDimension     hunitdim;
  std::string                zunitname, hunitname;
  double                     zunitfactor, hunitfactor;
  float                      zstart, zinc;
  std::array<float,2>        annotstart, annotinc;
  std::array<std::array<double,2>,4> corners;
 
public:
  ZgyInternalWriterArgs()
    : filename("")
    , size{0,0,0}
    , bricksize{64,64,64}
    , datatype(RawDataType::Float32)
    , datarange{0, -1}
    , zunitdim(RawVerticalDimension::Unknown)
    , hunitdim(RawHorizontalDimension::Unknown)
    , zunitname("")
    , hunitname("")
    , zunitfactor(1.0)
    , hunitfactor(1.0)
    , zstart(0)
    , zinc(0)
    , annotstart{0,0}
    , annotinc{0,0}
    , corners{0,0,0,0,0,0,0,0}
  {
  }
};
 
class IInfoHeaderAccess;
class IHistHeaderAccess;
 
class IHeaderAccess
{
public:
  typedef std::vector<std::uint8_t> podbytes_t;
  virtual podbytes_t podbytes() const = 0;
  virtual void dump(std::ostream& out, const std::string& prefix = "") = 0;
  // read(), byteswap(), calculate() not useful to abstract at this level.
};
 
//    FileHeader   //////////////////////////////////////////////////////////
 
class IFileHeaderAccess : public IHeaderAccess
{
public:
  virtual void read(const std::shared_ptr<FileADT>& file, std::int64_t offset) = 0;
  virtual void byteswap() = 0;
public:
  virtual std::array<std::uint8_t,4> magic() const = 0;
  virtual std::uint32_t version() const = 0;
};
 
//    OffsetHeader   ////////////////////////////////////////////////////////
 
class IOffsetHeaderAccess : public IHeaderAccess
{
public:
  virtual void read(const std::shared_ptr<FileADT>& file, std::int64_t offset) = 0;
  virtual void byteswap() = 0;
  virtual void calculate(const std::shared_ptr<IInfoHeaderAccess>& ih) = 0;
public:
  virtual std::int64_t infoff()       const = 0;
  virtual std::int64_t stroff()       const = 0;
  virtual std::int64_t alphalupoff()  const = 0;
  virtual std::int64_t bricklupoff()  const = 0;
  virtual std::int64_t histoff()      const = 0;
  virtual std::int64_t infsize()      const = 0;
  virtual std::int64_t histsize()     const = 0;
  virtual std::int64_t alphalupsize() const = 0;
  virtual std::int64_t bricklupsize() const = 0;
};
 
//    InfoHeader   //////////////////////////////////////////////////////////
 
class IInfoHeaderAccess : public IHeaderAccess
{
public:
  virtual void       read(const std::shared_ptr<FileADT>& file, std::int64_t offset, std::int64_t size) = 0;
  virtual void       byteswap() = 0;
  virtual void       calculate_cache() = 0;
  virtual void       calculate_read(const podbytes_t& slbuf, const std::shared_ptr<IHistHeaderAccess>& hh) = 0;
  virtual podbytes_t calculate_write() = 0;
public:
  virtual std::array<std::int64_t,3> bricksize() const = 0;
  virtual std::array<float,2>        codingrange() const = 0;
  virtual std::array<std::uint8_t,16>dataid() const = 0;
  virtual std::array<std::uint8_t,16>verid() const = 0;
  virtual std::array<std::uint8_t,16>previd() const = 0;
  virtual std::string                srcname() const = 0;
  virtual std::string                srcdesc() const = 0;
  virtual RawDataType                srctype() const = 0;
  virtual std::array<std::int64_t,3> size() const = 0;
  virtual std::array<float,3>        orig() const = 0;
  virtual std::array<float,3>        inc()  const = 0;
  virtual std::int64_t               scnt() const = 0;
  virtual double                     ssum() const = 0;
  virtual double                     sssq() const = 0;
  virtual float                      smin() const = 0;
  virtual float                      smax() const = 0;
  virtual std::array<float,4>        gpiline() const = 0;
  virtual std::array<float,4>        gpxline() const = 0;
  virtual std::array<double,4>       gpx() const = 0;
  virtual std::array<double,4>       gpy() const = 0;
  virtual RawDataType                datatype() const = 0;
  virtual std::string                hprjsys() const = 0;
  virtual RawHorizontalDimension     hdim() const = 0;
  virtual double                     hunitfactor() const = 0;
  virtual std::string                hunitname() const = 0;
  virtual RawVerticalDimension       vdim() const = 0;
  virtual double                     vunitfactor() const = 0;
  virtual std::string                vunitname() const = 0;
  virtual std::uint32_t              slbufsize() const = 0;
  virtual const std::array<std::array<double,2>,4>& ocp_index() const = 0;
  virtual const std::array<std::array<double,2>,4>& ocp_annot() const = 0;
  virtual const std::array<std::array<double,2>,4>& ocp_world() const = 0;
  virtual std::int32_t               nlods() const = 0;
  // The next three are derived but cannot possibly change after being set,
  // so returning a reference to cached data shold be safe.
  virtual const std::vector<std::array<std::int64_t,3>>& lodsizes() const = 0;
  virtual const std::vector<std::int64_t>& alphaoffsets() const = 0;
  virtual const std::vector<std::int64_t>& brickoffsets() const = 0;
  // More derived stuff, TODO-Performance may be cached.
  virtual std::int64_t bytesperalpha() const = 0;
  virtual std::int64_t bytesperbrick() const = 0;
  virtual std::int64_t bytespersample() const = 0;
  virtual std::array<double,2>       storagetofloat() const = 0;
  virtual double                     storagetofloat_slope() const = 0;
  virtual double                     storagetofloat_intercept() const = 0;
  virtual double                     defaultstorage() const = 0;
  virtual double                     defaultvalue() const = 0;
  // Write support.
  virtual void setstats(std::int64_t scnt, double ssum, double sssq,
                        float smin, float smax) = 0;
};
 
//    HistHeader   //////////////////////////////////////////////////////////
 
class IHistHeaderAccess : public IHeaderAccess
{
public:
  virtual void read(const std::shared_ptr<FileADT>& file, std::int64_t offset, std::int64_t size) = 0;
  virtual void byteswap() = 0;
  virtual void calculate() = 0;
public:
  virtual std::int64_t bincount()    const = 0;
  virtual std::int64_t samplecount() const = 0;
  virtual double       minvalue()    const = 0;
  virtual double       maxvalue()    const = 0;
  virtual const std::int64_t* bins() const = 0;
  // Write support.
  virtual void sethisto(double minvalue, double maxvalue,
                        const std::int64_t* bins, std::int64_t bincount) = 0;
};
 
//    AlphaLUP, BrickLUP   //////////////////////////////////////////////////
 
class ILookupTableAccess : public IHeaderAccess
{
public:
  virtual void read(const std::shared_ptr<FileADT>& file, std::int64_t offset, std::int64_t size) = 0;
  virtual void byteswap() = 0;
public:
  virtual std::uint64_t lookupLinearIndex(std::int64_t index) const = 0;
  virtual std::vector<std::uint64_t>& lup() = 0;
  virtual std::vector<std::uint64_t>& lupend() = 0;
  virtual const std::vector<std::uint64_t>& lup() const = 0;
  virtual const std::vector<std::uint64_t>& lupend() const = 0;
};
 
//    HeaderAccessFactory   (for all known header types)   //////////////////
 
class HeaderAccessFactory
{
  HeaderAccessFactory() = delete;
  HeaderAccessFactory(const HeaderAccessFactory&) = delete;
public:
  static std::shared_ptr<IFileHeaderAccess>   createFileHeader();
  static std::shared_ptr<IOffsetHeaderAccess> createOffsetHeader(std::uint32_t);
  static std::shared_ptr<IInfoHeaderAccess>   createInfoHeader(std::uint32_t);
  static std::shared_ptr<IHistHeaderAccess>   createHistHeader(std::uint32_t);
  static std::shared_ptr<ILookupTableAccess>  createAlphaLookup(std::uint32_t);
  static std::shared_ptr<ILookupTableAccess>  createBrickLookup(std::uint32_t);
};
 
//    ZgyInternalMeta   (this is the top level)   ///////////////////////////
 
class OPENZGY_TEST_API ZgyInternalMeta
{
public:
  typedef std::function<bool(int, const std::string&)> LoggerFn;
 
private:
  std::shared_ptr<IFileHeaderAccess>   _fh;
  std::shared_ptr<IOffsetHeaderAccess>   _oh;
  std::shared_ptr<IInfoHeaderAccess>     _ih;
  std::shared_ptr<IHistHeaderAccess>     _hh;
  std::shared_ptr<ILookupTableAccess>   _alup;
  std::shared_ptr<ILookupTableAccess>   _blup;
  LoggerFn                              _loggerfn;
  bool _is_bad;
 
public:
  // Actually internal. Used by OpenZGY::ZgyMeta, ZgyInternalBulk, GenLodC.
  const IFileHeaderAccess&  fh()   const { return *_fh; }
  //const IOffsetHeaderAccess& oh() const { return *_oh; }
  const IInfoHeaderAccess&  ih()   const { return *_ih; }
  const IHistHeaderAccess&  hh()   const { return *_hh; }
  const ILookupTableAccess& alup() const { return *_alup; }
  const ILookupTableAccess& blup() const { return *_blup; }
  // Writing a file needs writable lookup tables and
  // writable statistics and histogram. Stats are inside
  // the info header so this grants a bit more than needed.
  IInfoHeaderAccess&  ih()   { return *_ih; }
  IHistHeaderAccess&  hh()   { return *_hh; }
  ILookupTableAccess& alup() { return *_alup; }
  ILookupTableAccess& blup() { return *_blup; }
 
public:
  ZgyInternalMeta();
  ZgyInternalMeta(const ZgyInternalMeta&) = delete;
  ZgyInternalMeta& operator=(const ZgyInternalMeta&) = delete;
  explicit ZgyInternalMeta(const std::shared_ptr<FileADT>& file,
                           const LoggerFn& logger = LoggerFn());
  explicit ZgyInternalMeta(const ZgyInternalWriterArgs& args,
                           const LoggerFn& logger = LoggerFn());
public:
  void dump(std::ostream& out, const std::string& prefix = "");
  bool errorflag() const        { return _is_bad; }
  void set_errorflag(bool flag) { _is_bad = flag; }
  LoggerFn set_logger(const LoggerFn& logger) {
    LoggerFn old = _loggerfn;
    _loggerfn = logger;
    return old;
  }
  void flushMeta(const std::shared_ptr<FileADT>& file);
private:
  bool _logger(int priority, const std::string& ss = std::string()) const;
  bool _logger(int priority, const std::ios& ss) const;
  void initFromOpenFile(const std::shared_ptr<FileADT>&);
  void initFromScratch(const ZgyInternalWriterArgs&);
  ZgyInternalWriterArgs validateCreateNewFile(const ZgyInternalWriterArgs&);
  class ErrorsWillCorruptFile;
};
 
} // namespace