volume.h

Go to the documentation of this file.

/* -----------------------------------------------------------------------
   See COPYRIGHT.TXT and LICENSE.TXT for copyright and license information
   ----------------------------------------------------------------------- */
#ifndef _volume_h_
#define _volume_h_
 
#include "plmbase_config.h"
 
#include "direction_cosines.h"
#include "plm_int.h"
#include "smart_pointer.h"
#include "volume_macros.h"
 
class Volume_header;
class Plm_image_header;
 
enum Volume_pixel_type {
    PT_UNDEFINED,
    PT_UCHAR,
    PT_UINT16,
    PT_SHORT,
    PT_UINT32,
    PT_INT32,
    PT_FLOAT,
    PT_VF_FLOAT_INTERLEAVED,
    PT_VF_FLOAT_PLANAR,
    PT_UCHAR_VEC_INTERLEAVED
};
 
class PLMBASE_API Volume
{
public:
    SMART_POINTER_SUPPORT (Volume);
public:
    plm_long dim[3];            // x, y, z Dims
    plm_long npix;              // # of voxels in volume
                                // = dim[0] * dim[1] * dim[2] 
    float origin[3];
    float spacing[3];
    Direction_cosines direction_cosines;
 
    enum Volume_pixel_type pix_type;    // Voxel Data type
    int vox_planes;                     // # planes per voxel
    int pix_size;                       // # bytes per voxel
    void* img;                          // Voxel Data
 
public:
    float step[9];           // direction_cosines * spacing
    float proj[9];           // inv direction_cosines / spacing
 
public:
    Volume ();
    Volume (
        const plm_long dim[3], 
        const float origin[3], 
        const float spacing[3], 
        const float direction_cosines[9], 
        enum Volume_pixel_type vox_type, 
        int vox_planes
    );
    Volume (
        const plm_long dim[3], 
        const float origin[3], 
        const float spacing[3], 
        const Direction_cosines& direction_cosines, 
        enum Volume_pixel_type vox_type, 
        int vox_planes
    );
    Volume (
        const Volume_header& vh, 
        enum Volume_pixel_type vox_type, 
        int vox_planes
    );
    ~Volume ();
public:
    plm_long index (plm_long i, plm_long j, plm_long k) const {
        return volume_index (this->dim, i, j, k);
    }
    plm_long index (plm_long ijk[3]) const {
        return volume_index (this->dim, ijk);
    }
    void create (
        const plm_long new_dim[3], 
        const float origin[3], 
        const float spacing[3], 
        const float direction_cosines[9], 
        enum Volume_pixel_type vox_type, 
        int vox_planes = 1
    );
    void create (
        const Volume_header& vh, 
        enum Volume_pixel_type vox_type, 
        int vox_planes = 1
    );
    Volume::Pointer clone ();
 
    Volume::Pointer clone (Volume_pixel_type new_type) const;
 
    Volume::Pointer clone_empty ();
 
    void convert (Volume_pixel_type new_type);
 
    const float* get_origin (void) const;
    void get_origin (float *) const;
    void set_origin (const float origin[3]);
    const plm_long *get_dim (void) {
        return dim;
    }
    const float* get_spacing (void) const;
    void get_spacing (float *) const;
    void set_spacing (const float spacing[3]);
    Direction_cosines& get_direction_cosines (void) {
        return direction_cosines;
    }
    const Direction_cosines& get_direction_cosines (void) const {
        return direction_cosines;
    }
    float* get_direction_matrix (void) {
        return direction_cosines.get_matrix();
    }
    const float* get_direction_matrix (void) const {
        return direction_cosines.get_matrix();
    }
    void set_direction_cosines (const float direction_cosines[9]);
 
    void set_header (const Volume_header&);
    void set_header (const Plm_image_header *);
 
    template<class T> T* get_raw ();
    template<class T> const T* get_raw () const;
 
    const float* get_step (void) const;
    const float* get_proj (void) const;
 
    void position (float xyz[3], const plm_long ijk[3]) {
        POSITION_FROM_COORDS (xyz, ijk, this->origin, this->step);
    }
 
    void coordinates (plm_long ijk[3], plm_long idx) {
        COORDS_FROM_INDEX(ijk, idx, this->dim);
    }
 
    float get_ijk_value (const float xyz[3]) const;
    void get_xyz_from_ijk (double xyz[3], const plm_long ijk[3]);
 
    plm_long get_idx_from_xyz (const float xyz[3], bool* in);
    void get_ijk_from_xyz (plm_long ijk[3], const float xyz[3], bool* in);
    void get_ijk_from_xyz (float ijk[3], const float xyz[3], bool* in);
 
    bool is_inside (const float ijk[3]) const;
 
    void move_origin_to_idx (const plm_long ijk[3]);
 
    void scale_inplace (float scale);
 
    void debug ();
    void direction_cosines_debug ();
protected:
    void allocate (void);
    void init ();
public:
    /* Some day, these should become protected */
    Volume* clone_raw ();
private:
    Volume (const Volume&);
    void operator= (const Volume&);
};
 
PLMBASE_C_API void vf_convert_to_interleaved (Volume* ref);
PLMBASE_C_API void vf_convert_to_planar (Volume* ref);
PLMBASE_C_API void vf_pad_planar (Volume* vol, int size);  // deprecated?
PLMBASE_C_API Volume* volume_clone_empty (Volume* ref);
PLMBASE_C_API Volume* volume_clone (const Volume* ref);
PLMBASE_C_API void volume_convert_to_float (Volume* ref);
PLMBASE_C_API void volume_convert_to_int32 (Volume* ref);
PLMBASE_C_API void volume_convert_to_short (Volume* ref);
PLMBASE_C_API void volume_convert_to_uchar (Volume* ref);
PLMBASE_C_API void volume_convert_to_uint16 (Volume* ref);
PLMBASE_C_API void volume_convert_to_uint32 (Volume* ref);
PLMBASE_C_API Volume* volume_difference (Volume* vol, Volume* warped);
PLMBASE_C_API void volume_matrix3x3inverse (float *out, const float *m);
 
#endif