h5core_segy.h

#ifndef H5CORE_SEGY_H
#define H5CORE_SEGY_H
 
// to suppress undef var errors in IDE
#include "h5geo/h5core.h"
 
#include <cstring>
#include <cmath>
#include <bitset>
#include <fstream>
 
class H5Seis;
class H5Vol;
 
namespace h5geo {
 
template <class To, class From>
typename std::enable_if<(sizeof(To) == sizeof(From)) &&
std::is_trivially_copyable<From>::value &&
std::is_trivial<To>::value,
// this implementation requires that To is
// trivially default constructible
To>::type
// constexpr support needs compiler magic
inline bit_cast(const From &src) noexcept {
  To dst;
  std::memcpy(&dst, &src, sizeof(To));
  return dst;
}
 
inline float ibm2ieee(const int &from) {
  std::bitset<32> bits_from(from);
  float to;
  const int constnum1 = 2130706432;      // hex2dec('7f000000') (Matlab)
  const int constnum2 = 16777215;        // hex2dec('00ffffff') (Matlab)
  const float constnum3 = 16777216;      // 2^24
 
  int sgn = (1 - 2 * bits_from[31]);
  int expon = (from & constnum1) >> 24;
  int mantiss = (from & constnum2);
 
  to = float(sgn) * float(pow(16, expon - 64)) * float(mantiss) / constnum3;
 
  return to;
}
 
inline unsigned char ebc_to_ascii_table(unsigned char ascii) {
  unsigned char asc;
 
  int Tableebc2Asc[256] = {
      32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
      32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
      32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
      32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
      32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  91,
      46,  60,  40,  43,  33,  38,  32,  32,  32,  32,  32,  32,  32,  32,  32,
      93,  36,  42,  41,  59,  94,  45,  47,  32,  32,  32,  32,  32,  32,  32,
      32,  124, 44,  37,  95,  62,  63,  32,  32,  32,  32,  32,  32,  238, 160,
      161, 96,  58,  35,  64,  39,  61,  34,  230, 97,  98,  99,  100, 101, 102,
      103, 104, 105, 164, 165, 228, 163, 229, 168, 169, 106, 107, 108, 109, 110,
      111, 112, 113, 114, 170, 171, 172, 173, 174, 175, 239, 126, 115, 116, 117,
      118, 119, 120, 121, 122, 224, 225, 226, 227, 166, 162, 236, 235, 167, 232,
      237, 233, 231, 234, 158, 128, 129, 150, 132, 133, 148, 131, 123, 65,  66,
      67,  68,  69,  70,  71,  72,  73,  149, 136, 137, 138, 139, 140, 125, 74,
      75,  76,  77,  78,  79,  80,  81,  82,  141, 142, 143, 159, 144, 145, 92,
      32,  83,  84,  85,  86,  87,  88,  89,  90,  146, 147, 134, 130, 156, 155,
      48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  135, 152, 157, 153, 151,
      32};
 
  asc = Tableebc2Asc[ascii];
  return (asc);
}
 
 
template <typename T>
inline T bswap(T val) {
    T retVal;
    char *pVal = (char*) &val;
    char *pRetVal = (char*)&retVal;
    int size = sizeof(T);
    for(int i=0; i<size; i++) {
        pRetVal[size-1-i] = pVal[i];
    }
 
    return retVal;
}
 
template <typename Scalar, typename II, typename OI>
inline void bswap(II begin, II end, OI dest) {
    std::transform(begin, end, dest, bswap<Scalar>);
}
 
template <typename T>
inline T to_big_endian(T val, h5geo::Endian fromEndian) {
  if (fromEndian == h5geo::Endian::Little){
    return bswap(val);
  }
  return val;
}
 
template <typename Scalar, typename II, typename OI>
inline void to_big_endian(II begin, II end, OI dest, h5geo::Endian fromEndian) {
  if (fromEndian == h5geo::Endian::Little){
    bswap<Scalar>(begin, end, dest);
  }
}
 
template <typename T>
inline T to_little_endian(T val, h5geo::Endian fromEndian) {
  if (fromEndian == h5geo::Endian::Big){
    return bswap(val);
  }
  return val;
}
 
template <typename Scalar, typename II, typename OI>
inline void to_little_endian(II begin, II end, OI dest, h5geo::Endian fromEndian) {
  if (fromEndian == h5geo::Endian::Big){
    bswap<Scalar>(begin, end, dest);
  }
}
 
template <typename T>
inline T to_native_endian(T val, h5geo::Endian fromEndian) {
  if (O32_HOST_ORDER == O32_LITTLE_ENDIAN){
    if (fromEndian == h5geo::Endian::Big){
      return bswap(val);
    }
  } else if (O32_HOST_ORDER == O32_BIG_ENDIAN){
    if (fromEndian == h5geo::Endian::Little){
      return bswap(val);
    }
  }
  return val;
}
 
template <typename Scalar, typename II, typename OI>
inline void to_native_endian(II begin, II end, OI dest, h5geo::Endian fromEndian) {
  if (O32_HOST_ORDER == O32_LITTLE_ENDIAN){
    if (fromEndian == h5geo::Endian::Big){
      bswap<Scalar>(begin, end, dest);
    }
  } else if (O32_HOST_ORDER == O32_BIG_ENDIAN){
    if (fromEndian == h5geo::Endian::Little){
      bswap<Scalar>(begin, end, dest);
    }
  }
}
 
H5GEO_EXPORT bool isSEGY(const std::string& segy);
 
H5GEO_EXPORT TextEncoding getSEGYTextEncoding(const std::string& segy);
 
H5GEO_EXPORT Endian getSEGYEndian(const std::string& segy);
 
H5GEO_EXPORT SegyFormat getSEGYFormat(
    const std::string& segy, h5geo::Endian endian = static_cast<h5geo::Endian>(0));
 
H5GEO_EXPORT bool readSEGYTextHeader(
    const std::string& segy,
    char txtHdr[40][80], h5geo::TextEncoding encoding = static_cast<h5geo::TextEncoding>(0));
 
H5GEO_EXPORT bool writeSEGYTextHeader(
    const std::string& segy,
    char txtHdr[40][80], bool truncate);
 
H5GEO_EXPORT bool readSEGYBinHeader(
    const std::string& segy,
    double binHdr[30], h5geo::Endian endian = static_cast<h5geo::Endian>(0));
 
H5GEO_EXPORT bool writeSEGYBinHeader(
    const std::string& segy,
    double binHdr[30], bool truncate, 
    h5geo::Endian endian = h5geo::Endian::Big);
 
H5GEO_EXPORT double getSEGYSampRate(
    const std::string& segy, h5geo::Endian endian = static_cast<h5geo::Endian>(0));
 
H5GEO_EXPORT size_t getSEGYNSamp(
    const std::string& segy, h5geo::Endian endian = static_cast<h5geo::Endian>(0));
 
H5GEO_EXPORT size_t getSEGYNTrc(
    const std::string& segy, size_t nSamp = 0, h5geo::Endian endian = static_cast<h5geo::Endian>(0));
 
H5GEO_EXPORT Eigen::VectorX<ptrdiff_t> readSEGYTraceHeader(
    const std::string& segy,
    const size_t& hdrOffset,
    const size_t& hdrSize,
    size_t fromTrc = 0,
    size_t toTrc = std::numeric_limits<size_t>::max(),
    size_t nSamp = 0,
    size_t nTrc = 0,
    h5geo::Endian endian = static_cast<h5geo::Endian>(0),
    std::function<void(double)> progressCallback = nullptr);
 
H5GEO_EXPORT void readSEGYTrace(
    std::ifstream& file,
    size_t trcInd,
    h5geo::SegyFormat format,
    h5geo::Endian endian,
    Eigen::Ref<Eigen::VectorXf> trace);
 
H5GEO_EXPORT bool writeSEGYTraces(
    const std::string& segy,
    Eigen::Ref<Eigen::MatrixXd> HDR,
    Eigen::Ref<Eigen::MatrixXf> TRACE,
    h5geo::Endian endian = h5geo::Endian::Big);
 
H5GEO_EXPORT Eigen::MatrixXf readSEGYTraces(
    const std::string& segy,
    size_t fromSamp = 0,
    size_t toSamp = std::numeric_limits<size_t>::max(),
    size_t fromTrc = 0,
    size_t toTrc = std::numeric_limits<size_t>::max(),
    size_t nSamp = 0,
    size_t nTrc = 0,
    h5geo::SegyFormat format = static_cast<h5geo::SegyFormat>(0),
    h5geo::Endian endian = static_cast<h5geo::Endian>(0),
    std::function<void(double)> progressCallback = nullptr);
 
H5GEO_EXPORT bool readSEGYTracesMMap(
    H5Seis* seis,
    const std::string& segy,
    bool appendTraces = false,
    size_t nSamp = 0,
    size_t nTrc = 0,
    h5geo::SegyFormat format = static_cast<h5geo::SegyFormat>(0),
    h5geo::Endian endian = static_cast<h5geo::Endian>(0),
    std::vector<std::string> trcHdrNames = std::vector<std::string>(),
    size_t trcBuffer = 10000,
    int nThreads = -1,
    std::function<void(double)> progressCallback = nullptr);
 
H5GEO_EXPORT bool readSEGYTraces(
    H5Seis* seis,
    const std::string& segy,
    bool appendTraces = false,
    size_t nSamp = 0,
    size_t nTrc = 0,
    h5geo::SegyFormat format = static_cast<h5geo::SegyFormat>(0),
    h5geo::Endian endian = static_cast<h5geo::Endian>(0),
    std::vector<std::string> trcHdrNames = std::vector<std::string>(),
    size_t trcBuffer = 10000,
    std::function<void(double)> progressCallback = nullptr);
 
H5GEO_EXPORT bool readSEGYSTACK(
    H5Vol* vol,
    const std::string& segy,
    const size_t& ilHdrOffset,
    const size_t& ilHdrSize,
    const size_t& xlHdrOffset,
    const size_t& xlHdrSize,
    const size_t& xHdrOffset,
    const size_t& xHdrSize,
    const size_t& yHdrOffset,
    const size_t& yHdrSize,
    double sampRate,
    size_t nSamp = 0,
    size_t nTrc = 0,
    h5geo::SegyFormat format = static_cast<h5geo::SegyFormat>(0),
    h5geo::Endian endian = static_cast<h5geo::Endian>(0),
    std::function<void(double)> progressCallback = nullptr);
 
}
 
#endif // H5CORE_SEGY_H