marchingcubes.h

Go to the documentation of this file.

#pragma once

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        K. Tingdahl
 Date:          March 2006
________________________________________________________________________

-*/

#include "geometrymod.h"
#include "task.h"
#include "notify.h"
#include "multidimstorage.h"
#include "ranges.h"
#include "refcount.h"
#include "threadlock.h"

#include "od_iosfwd.h"

template <class T> class Array3D;
template <class T> class DataInterpreter;

class Executor;
class MarchingCuebs2ImplicitFloodFiller;
class SeedBasedFloodFiller;

mExpClass(Geometry) MarchingCubesModel
{
public:
                                MarchingCubesModel();
                                MarchingCubesModel(const MarchingCubesModel&);

    MarchingCubesModel&         operator=(const MarchingCubesModel&);
    bool                        operator==(const MarchingCubesModel&) const;

    bool                        set(const Array3D<float>& arr,
                                    int i0,int i1, int i2,float threshold);

    bool                        isEmpty() const;

    static unsigned char        determineModel( bool c000, bool c001, bool c010,
                                                bool c011, bool c100, bool c101,
                                                bool c110, bool c111 );

    static bool                 getCornerSign(unsigned char model, int corner);
    bool                        writeTo(od_ostream&,bool binary=true) const;
    bool                        readFrom(od_istream&,bool binary=true);

    static const unsigned char  cUdfAxisPos;
    static const unsigned char  cMaxAxisPos;
    static const unsigned char  cAxisSpacing;

    unsigned char       model_;         //Don't change the order of these
    unsigned char       submodel_;      //since they are written to
    unsigned char       axispos_[3];    //the stream in this order
};


mExpClass(Geometry) MarchingCubesSurface : public RefCount::Referenced
                                         , public CallBacker
{
public:
                        MarchingCubesSurface();

    bool                setVolumeData(int xorigin,int yorigin,int zorigin,
                                      const Array3D<float>&,float threshold,
                                      TaskRunner* = 0);
    void                removeAll();
    bool                isEmpty() const;

    bool                getModel(const int* pos, unsigned char& model,
                                 unsigned char& submodel) const;

    Executor*           writeTo(od_ostream&,bool binary=true) const;
    Executor*           readFrom(od_istream&,
                                 const DataInterpreter<od_int32>*);

    MultiDimStorage<MarchingCubesModel>         models_;
    mutable Threads::Lock                       modelslock_;

    Notifier<MarchingCubesSurface>              change;
    bool                                        allchanged_;
    Interval<int>                               changepos_[3];
protected:
                                                ~MarchingCubesSurface();
};


mExpClass(Geometry) Implicit2MarchingCubes : public ParallelTask
{ mODTextTranslationClass(Implicit2MarchingCubes);
public:
                Implicit2MarchingCubes(int posx, int posy, int posz,
                                const Array3D<float>&, float threshold,
                                MarchingCubesSurface&);
                ~Implicit2MarchingCubes();

    od_int64    nrIterations() const;
    bool        doWork(od_int64,od_int64,int);
    uiString    message() const
                { return tr("Implicit body to MarchingCubes: Contouring"); }


protected:
    MarchingCubesSurface&       surface_;

    const Array3D<float>&       array_;
    float                       threshold_;

    int                         xorigin_;
    int                         yorigin_;
    int                         zorigin_;
};



mExpClass(Geometry) MarchingCubes2Implicit : public ParallelTask
{ mODTextTranslationClass(MarchingCubes2Implicit);
public:
                MarchingCubes2Implicit(const MarchingCubesSurface&,
                                        Array3D<int>&,
                                        int originx,int originy,int originz,
                                        bool nodistance);
                ~MarchingCubes2Implicit();

    float       threshold() const { return 0; }
    uiString    nrDoneText() const
                { return tr("Flood fills performed"); }
    uiString    message() const
                { return tr("Processing MarchingCubes2Implicit."); }

protected:
    od_int64    nrDone() const;
    od_int64    nrIterations() const;

    bool        doPrepare(int);
    bool        doWork(od_int64,od_int64,int);
    bool        processSeeds( const od_int64*, int nr );

    friend      class MarchingCubes2ImplicitDistGen;

    bool        shouldSetValue(od_int64 offset, int newval );
    void        setValue(od_int64 offset,int newval,bool checkval);

    const MarchingCubesSurface&                 surface_;
    int                                         originx_;
    int                                         originy_;
    int                                         originz_;

    int                                         size_[3];

    bool                                        nodistance_;

    mutable Threads::Barrier                    barrier_;
    Array3D<int>&               result_;
    od_int64                                    nrdefined_;

    bool*                                       newfloodfillers_;
    TypeSet<od_int64>                           activefloodfillers_;
};