stratlayer.h

Go to the documentation of this file.

#ifndef stratlayer_h
#define stratlayer_h

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Bert
 Date:          Sep 2010
 RCS:           $Id$
________________________________________________________________________


-*/

#include "stratmod.h"
#include "compoundkey.h"
#include "stratcontent.h"
#include "typeset.h"
#include "uistring.h"

class PropertyRef;
class PropertyRefSelection;
namespace Math { class Formula; }

namespace Strat
{
class LeafUnitRef;
class RefTree;
class Lithology;
class LayerValue;

mExpClass(Strat) Layer
{ mODTextTranslationClass(Layer);
public:

    typedef CompoundKey ID;

                        Layer(const LeafUnitRef&);
                        Layer(const Layer&);
                        ~Layer();
    Layer&              operator=(const Layer&);

    BufferString        name() const;
    const LeafUnitRef&  unitRef() const                 { return *ref_; }
    inline void         setRef( const LeafUnitRef& r )  { ref_ = &r; }
    const RefTree&      refTree() const;
    const Lithology&    lithology() const;
    const Content&      content() const;

    inline float        zTop() const                    { return ztop_; }
    inline int          nrValues() const                { return vals_.size(); }
    float               thickness() const;
    float               value(int) const;               
    bool                isMath(int) const;
    const LayerValue*   getLayerValue(int) const;
    void                getValues(TypeSet<float>&) const;
    inline float        zBot() const    { return ztop_ + thickness(); }
    inline float        depth() const   { return ztop_ + 0.5f * thickness(); }

    inline void         setZTop( float v )              { ztop_ = v; }
    void                setThickness(float v);
    void                setValue(int,float);
    void                setValue(int,const Math::Formula&,
                                 const PropertyRefSelection&,float xpos=0.5f);
    void                setValue(int,const IOPar&,const PropertyRefSelection&);
    void                setValue(int,LayerValue*); 
    void                setContent( const Content& c )  { content_ = &c; }
    void                setXPos(float); // only affects Math lay vals

    ID                  id() const;     
    Color               dispColor(bool lith_else_upnode) const;

    static const PropertyRef& thicknessRef();

protected:

    const LeafUnitRef*  ref_;
    float               ztop_;
    ObjectSet<LayerValue> vals_;
    const Content*      content_;

    void                setLV(int,LayerValue*);
};


mExpClass(Strat) LayerValue
{ mODTextTranslationClass(LayerValue);
public:

    virtual LayerValue* clone(const Layer* l=0) const   = 0;
    virtual             ~LayerValue()                   {}
    virtual bool        isSimple() const                { return false; }
    virtual float       value() const                   = 0;

    BufferString        dumpStr() const;
    virtual void        setXPos(float)                  {}

};


mExpClass(Strat) SimpleLayerValue : public LayerValue
{ mODTextTranslationClass(SimpleLayerValue);
public:
                        SimpleLayerValue( float val )
                            : val_ (val)                {}
    SimpleLayerValue*   clone(const Layer* l=0) const
                        { return new SimpleLayerValue(val_); }

    virtual bool        isSimple() const                { return true; }
    virtual float       value() const                   { return val_; }
    void                setValue( float val )           { val_ = val; }

protected:

    float               val_;

};


mExpClass(Strat) FormulaLayerValue : public LayerValue
{ mODTextTranslationClass(FormulaLayerValue);
public:

                        FormulaLayerValue(const Math::Formula&,
                                          const Strat::Layer&,
                                          const PropertyRefSelection&,
                                          float xpos);
                        FormulaLayerValue(const IOPar&,const Strat::Layer&,
                                          const PropertyRefSelection&);
                        ~FormulaLayerValue();
    FormulaLayerValue*  clone(const Layer*) const;

    bool                isBad() const           { return !errmsg_.isEmpty(); }
    uiString            errMsg() const          { return errmsg_; }
    void                fillPar(IOPar&) const;
    virtual void        setXPos(float);

    virtual float       value() const;

protected:

                                FormulaLayerValue(const Math::Formula&,
                                      const Strat::Layer&,float,bool c=false);

    const Math::Formula&        form_;
    const Layer&                lay_;
    const bool                  myform_;
    float                       xpos_;

    TypeSet<int>                inpidxs_;
    mutable TypeSet<float>      inpvals_;
    mutable uiString            errmsg_;

    void                        useForm(const PropertyRefSelection&);

};


}; // namespace Strat

#endif