zd_useismic.hpp

/* zd_useismic.hpp */
/* $Id: zd_useismic.hpp,v 1.13 2009/02/13 11:57:01 vlad Exp $ */
#ifndef __zd_useismic_hpp
#define __zd_useismic_hpp

#include <vector>
#include <ldb/trset.h>
#include <ldb/trselect.h>
#include <zq/zqb_header.hpp>
#include <zq/zd_seismic_set.hpp>


#define ZDUS_EXTRA_HW_SIZE  8


class ZdUSeismic : public ZdSeismicSet
{
public:

  ZdUSeismic (TrSet* pTS, int nExtraHW = 0, const char* szDocName = NULL);

  ZdUSeismic (const char* szProject, const char* szSeisFile,
          int nExtraHW = 0, const char* szDocName = NULL);

  virtual ~ZdUSeismic ();


  /*
   *  Hacker's facilities
   */

  TrSet*        handle ();

  const TrSet*      handle () const;

  const TrIndexTable*   indexTable () const;

  int           extraHeaderWords () const;


  /*
   *  Basic information
   */

  virtual bool      getCoordRange (double c[2]);

  virtual double    averageCoordStep ();

  virtual const ZqbAbstrTrace&  tracePar () const;

  virtual int       traceCount () const;

  virtual void      getAllTraceIds (TraceIdsV& viTraceIds) const;

  /*
   *  Coordinate based services (see ZdCoordObjStream)
   */

  virtual int       coordCount () const;

  virtual int       coordToTraceId (double fCoord,
                    int iEnsIndex = 0);

  virtual void      coordToTraceIds (double fCoord,
                     TraceIdsV& viTraceIds);

  virtual void      getCoords (CoordsV& vfCoords);

  virtual double    traceIdToCoord (int iTraceId,
                    int* piEnsIndex = NULL);


  /*
   *  Write-only access features
   */

  virtual bool      modify ();

  virtual bool      isModifiable () const;

  virtual bool      setHeader (int id, const ZqbHeader& hdr);

  virtual bool      setTrace (int id, const ZqbRealTrace& rtr);

  virtual bool      setSamples (int id, const float* pSamples);


  /*
   *  Read-only access features
   */

  virtual const ZqbHeader*  headerById (int id);

  virtual const float*      samplesById (int id);

  virtual const ZqbRealTrace*   traceById (int id);


  /*
   * Iterator methods.
   */

  virtual void      setCustomCoord (int iCoordHW,
                    ZqbOrder eOrder = Z_O_ASCENT);

  virtual void      setSecondaryOrder (int iSecondaryHW,
                       ZqbOrder eOrder = Z_O_ASCENT);

  virtual void      setTertiaryOrder (int iTertiaryHW,
                      ZqbOrder eOrder = Z_O_ASCENT);

  virtual void      setCustomHdrWord (int iCustomHW);


  virtual bool      goFirstCoord ();

  virtual bool      goNextCoord ();

  virtual double    coord ();

  virtual void*     custom (int ens_index = 0,
                ZqbType* pRetType = NULL);

  virtual int       ensembleLength ();

  virtual int       maxEnsembleLength ();

  virtual const ZqbRealTrace&   trace (int ens_index = 0); 

  virtual const ZqbHeader&  header (int ens_index = 0); 

  virtual int           traceId (int ens_index = 0);


  /*
   *  Special functionality for sort & split support
   */

  void      getValuesList (int hwId, std::vector<int>& vValues);

  void      getValuesList (int hwId, std::vector<float>& vValues);


  /*
   *  Additional service
   */

  virtual void          globalAmplInfo (double pfAmm[2]);

  virtual const char*       coordMeaning () const;

  virtual const char*       coordUnit () const;

  virtual const char*       timeMeaning () const;

  virtual const char*       timeUnit () const;


  /*
   *  General services
   */

  static void       initialize (int nExtraHW = 0,
                    const ZqbHdrField* pExtraHW = NULL,
                    void (*InitExtraHW)(ZqbHeader&) = NULL);

  static ZqbType    hwType (int hwId);

  static ZqbHdrField*   hwInfo (int hwId);


  /*
   *  Local services
   */

  bool      properOrder () const;

  void      applyOrder ();

protected:

  int       curEnsSize (int iCurTrace);

  void      constructor ();

  void      setSortOrder (ZqbHeader& hdr);

  TrSet         *m_pTS;

  TrIndexTable      m_it;

  struct TraceItem {
    TraceItem ()
      : m_bLoaded(false), m_iTraceId(-1), m_pTrace(NULL) {}

    TraceItem (int id, const ZqbAbstrTrace& atr,
           const ZqbHeader& hdr)
      : m_bLoaded(false), m_iTraceId(id), m_pTrace(NULL)
    {
      m_pTrace = new ZqbRealTrace(atr, hdr);
    }

    TraceItem (const TraceItem& trit)
      : m_bLoaded(trit.m_bLoaded), m_iTraceId(trit.m_iTraceId), m_pTrace(NULL)
    {
      if(NULL != trit.m_pTrace)
    m_pTrace = new ZqbRealTrace(*trit.m_pTrace);
    }

    ~TraceItem ()
    {
      delete m_pTrace;
    }

    bool    operator< (const TraceItem& trit) const
    {
      if(NULL != m_pTrace && NULL != trit.m_pTrace)
    return *m_pTrace < *trit.m_pTrace;
      return m_iTraceId < trit.m_iTraceId;
    }

    TraceItem&  operator= (const TraceItem& trit)
    {
      m_bLoaded = trit.m_bLoaded;
      m_iTraceId = trit.m_iTraceId;
      if(NULL != trit.m_pTrace)
    {
      if(NULL != m_pTrace)
        m_pTrace = new ZqbRealTrace(*trit.m_pTrace);
      else
        *m_pTrace = *trit.m_pTrace;
    }
      return *this;
    }

    void    loadTrace (const float* trace)
    {
      if(NULL != m_pTrace)
    {
      *m_pTrace = trace;
      m_bLoaded = true;
    }
    }

    bool        m_bLoaded;
    int         m_iTraceId;
    ZqbRealTrace    *m_pTrace;
  };

  std::vector<TraceItem>    m_vTraces;

  std::vector<std::pair<int,ZqbOrder> > m_vOrder;

  ZqbAbstrTrace     m_aTrace;

  ZqbRealTrace      m_EmptyTrace;

  int           m_iCurTrace;

  int           m_nExtraHW;

  int           m_nMaxEnsSize;

  static void       (*s_initExtraHW)(ZqbHeader&);

  std::vector<double>   m_vfCoords;

  std::vector<int>  m_viStartEns;

  std::vector<int>  m_viEnsLengths;

  std::map<int,int> m_mId2I;

  UnitId        m_eLengthUnitId;

private:

  int       m_iCustomHW;

  union {
    int     m_iValue;
    float   m_fValue;
    char    m_cValue;
  }         m_rCustom;

  void  loadProjectAttr (const char* szProject);

  TrSet         *m_pOwnTS;

  static int        s_iNameCounter;

  static char       *s_szOwnType;

};


#endif /* zd_useismic.hpp */