mitkEncodedGradientEstimator.h

/*=========================================================================

  Program:   3DMed
  Date:      $Date: 2014-02-25 18:30:00 +0800 $
  Version:   $Version: 4.6.0 $
  Copyright: MIPG, Institute of Automation, Chinese Academy of Sciences

=========================================================================*/


#ifndef __mitkEncodedGradientEstimator_h
#define __mitkEncodedGradientEstimator_h

#include "mitkObject.h"
#include "mitkRCPtr.h"
#include "mitkVolume.h"
#include "mitkDirectionEncoder.h"

class MITK_VISUALIZATION_API mitkEncodedGradientEstimator : public mitkObject
{
public:
    //operations
    MITK_TYPE(mitkEncodedGradientEstimator,mitkObject)
        
    




    void SetInput(mitkVolume *pInVolume);

    mitkVolume* GetInput(){return this->m_Input;}
    
    void SetGradientMagnitudeScale(float fGMS){this->m_GradientMagnitudeScale = fGMS;};

    float GetGradientMagnitudeScale(){return this->m_GradientMagnitudeScale;};

    void SetGradientMagnitudeBias(float fGMB){this->m_GradientMagnitudeBias = fGMB;};

    float GetGradientMagnitudeBias(){return this->m_GradientMagnitudeBias;};    
    
    virtual void SetBoundsClip(int nBoundsClip){
        if (this->m_BoundsClip != (nBoundsClip < 0 ? 0 : (nBoundsClip > 1 ? 1 : nBoundsClip))) 
        { 
            this->m_BoundsClip = (nBoundsClip < 0 ? 0 : (nBoundsClip > 1 ? 1 : nBoundsClip)); 
        } 
    };  

    virtual int GetBoundsClipMinValue(){return 0;};

    virtual int GetBoundsClipMaxValue(){return 1;};

    virtual int GetBoundsClip(){return this->m_BoundsClip;};

    virtual void SetBoundsClipOn(){this->SetBoundsClip(1);};

    virtual void SetBoundsClipOff(){this->SetBoundsClip(0);};
    
    virtual void SetBounds(int arg1, int arg2, int arg3, int arg4, int arg5, int arg6);

    virtual void SetBounds(int arg[6]);

    virtual void GetBounds(int &arg1, int &arg2, int &arg3, int &arg4, int &arg5, int &arg6);

    void GetBounds(int arg[6]);

    int* GetBounds();
    
    void SetComputeGradientMagnitudes(int nCGM){this->m_ComputeGradientMagnitudes = nCGM;};

    int GetComputeGradientMagnitudes(){return this->m_ComputeGradientMagnitudes;};

    virtual void SetComputeGradientMagnitudesOn(){this->SetComputeGradientMagnitudes(1);};

    virtual void SetComputeGradientMagnitudesOff(){this->SetComputeGradientMagnitudes(0);}; 
    
    void SetCylinderClip(int nCC){this->m_CylinderClip = nCC;};

    int GetCylinderClip(){return this->m_CylinderClip;};

    virtual void SetCylinderClipOn(){this->SetCylinderClip(1);};

    virtual void SetCylinderClipOff(){this->SetCylinderClip(0);};   
    
    int GetUseCylinderClip(){return this->m_UseCylinderClip;};

    int *GetCircleLimits() { return this->m_CircleLimits; };
    
    void SetZeroNormalThreshold( float v );

    float GetZeroNormalThreshold(){return this->m_ZeroNormalThreshold; };
    
    virtual void SetZeroPad(int nZeroPad){
        if (this->m_ZeroPad != (nZeroPad < 0 ? 0 : (nZeroPad > 1 ? 1 : nZeroPad))) 
        { 
            this->m_ZeroPad = (nZeroPad < 0 ? 0 : (nZeroPad > 1 ? 1 : nZeroPad)); 
        } 
    };  

    virtual int GetZeroPadMinValue(){return 0;};

    virtual int GetZeroPadMaxValue(){return 1;};

    virtual int GetZeroPad(){return this->m_ZeroPad;}; 

    virtual void SetZeroPadOn(){this->SetZeroPad(1);};

    virtual void SetZeroPadOff(){this->SetZeroPad(0);}; 
    
    void  Update();
    
    unsigned short  *GetEncodedNormals(); 

    mitkVolume* GetEncodedNormalsVol();
    
    
    int   GetEncodedNormalIndex( int xyz_index );


    int   GetEncodedNormalIndex( int x_index, int y_index, int z_index );
    
    unsigned char *GetGradientMagnitudes();

    mitkVolume* GetGradientMagnitudesVol();
    
    void SetDirectionEncoder( mitkDirectionEncoder *direnc );

    mitkDirectionEncoder* GetDirectionEncoder(){return this->m_DirectionEncoder;}
    
    //attributes:
    // These variables should be protected but are being
    // made public to be accessible to the templated function.
    // We used to have the templated function as a friend, but
    // this does not work with all compilers
    
    // The input scalar data on which the normals are computed
    mitkRCPtr<mitkVolume> m_Input;
    
    // The encoded normals (2 bytes) and the size of the encoded normals
    unsigned short        *m_EncodedNormals;
    int                   m_EncodedNormalsSize[3];
    
    // The magnitude of the gradient array and the size of this array
    unsigned char         *m_GradientMagnitudes;

    // in case of out-of-core data
    mitkVolume *m_EncodedNormalsVol;
    mitkVolume *m_GradientMagnitudesVol;
    
    int *GetInputSize(){return this->m_InputSize;};
    void GetInputSize(int data[3]){for (int i = 0; i < 3; i++) data[i] = this->m_InputSize[i];};
    float *GetInputAspect(){return this->m_InputAspect;};
    void GetInputAspect(float data[3]){for (int i = 0; i < 3; i++) data[i] = this->m_InputAspect[i];};
    
    
protected:
    mitkEncodedGradientEstimator();
    virtual ~mitkEncodedGradientEstimator();    
    
    //Attributes:
    
    mitkRCPtr<mitkDirectionEncoder> m_DirectionEncoder;
    
    float                      m_GradientMagnitudeScale;
    float                      m_GradientMagnitudeBias;
    
    float                      m_ZeroNormalThreshold;
    
    int                        m_CylinderClip;
    int                        *m_CircleLimits;
    int                        m_CircleLimitsSize;
    int                        m_UseCylinderClip;
    
    int                        m_BoundsClip;
    int                        m_Bounds[6];
    
    int                        m_InputSize[3];
    float                      m_InputAspect[3];
    
    int                        m_ComputeGradientMagnitudes;
    
    int                        m_ZeroPad;   

    bool                       m_EnalbleOoC;
    //operations:
    virtual void               _updateNormals( void ) = 0;
    void                       _computeCircleLimits( int size );

private:
    mitkEncodedGradientEstimator(const mitkEncodedGradientEstimator&);
    void operator=(const mitkEncodedGradientEstimator&);
};

 
//#define DEFINED_mitkEncodedGradientEstimator
 


#endif

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    $RCSfile$
  Language:  C++
  Date:      $Date: 2006-08-02 17:05:13 +0800 (ÐÇÆÚÈý, 02 °ËÔÂ 2006) $
  Version:   $Revision: 35 $


Copyright (c) 1993-2002 Ken Martin, Will Schroeder, Bill Lorensen 
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

 * Redistributions of source code must retain the above copyright notice,
   this list of conditions and the following disclaimer.

 * Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

 * Neither name of Ken Martin, Will Schroeder, or Bill Lorensen nor the names
   of any contributors may be used to endorse or promote products derived
   from this software without specific prior written permission.

 * Modified source versions must be plainly marked as such, and must not be
   misrepresented as being the original software.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

=========================================================================*/ 

---