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
 RCS:           $Id$
________________________________________________________________________
 
-*/
 
#include "geometrymod.h"
#include "task.h"
#include "callback.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 CallBacker
{ mRefCountImpl(MarchingCubesSurface);
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];
};
 
 
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    uiMessage() 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    uiMessage() 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_;
};