cimgmatlab.h

this a image processing program

/*****************************************************************
 * cimgmatlab.h
 * -------------
 *
 * cimgmatlab.h is a "plugin" for the CImg library that allows 
 * to convert CImg<T> images from/to matlab arrays, so that CImg
 * can be used to write matlab mex files.
 * How to use it:
 * file cimgmatlab.h must be in a directory that the 
 * compiler can locate.
 * Prior to include CImg.h, mex.h must be included first, else it
 * will result in a compiler error.
 * after the inclusion of mex.h, one must define the macro
 * cimg_plugin as "cimgmatlab.h" or <cimgmatlab.h> or similar
 *
 * // my fantastic mex file source code
 * #include <mex.h>
 * ...
 * #define cimg_plugin  <cimgmatlab.h>
 * #include <CImg.h>
 * ...
 *
 *
 * Copyright: Francois Lauze, The IT University of Copenhagen.
 * Licence: the Gnu General Public License
 *          http://www.gnu.org/copyleft/gpl.html
 * 
 *****************************************************************/


#if !defined mex_h
#error the file mex.h must be included!
#endif

#if !defined cimg_version
#error cimgmatlab.h requires that CImg.h is included
#endif




// begin of included methods
// They are just added as member functions / constructor
// for the CImg<T> class.


 private:
    // internally used to transfer Matlab array values to CImg<> objects, 
    // check wether the array type is a "numerical" one (including logical) 
    static int isNumericalClassID(mxClassID id) {
		// all these constants are defined in matrix.h included by mex.h
        switch (id) { 
        case mxLOGICAL_CLASS:
        case mxDOUBLE_CLASS:
        case mxSINGLE_CLASS:
        case mxINT8_CLASS:
        case mxUINT8_CLASS:
        case mxINT16_CLASS:
        case mxUINT16_CLASS:
        case mxINT32_CLASS:
        case mxUINT32_CLASS:
	case mxINT64_CLASS:
	case mxUINT64_CLASS:
            return 1;
        default:
            return 0;
        }
    }
    
    
    // driving routine that will copy the content of
    // a MatLab array to this->data
    // The type names used are defined in tmwtypes.h 
    void makeImageFromMatlabData(const mxArray *matlabArray, mxClassID classID) {
        if (classID == mxLOGICAL_CLASS) {
            // logical type works a bit differently than the numerical types
            mxLogical *mdata = mxGetLogicals(matlabArray);
            cpMatlabData((const mxLogical *)mdata);
        } else {
            void *mdata = mxGetPr(matlabArray);
            switch (classID) {
            case mxDOUBLE_CLASS:
                cpMatlabData((const real64_T *)mdata);
                break;
            case mxSINGLE_CLASS:
                cpMatlabData((const real32_T *)mdata);
                break;
            case mxINT8_CLASS:
                cpMatlabData((const int8_T *)mdata);
                break;
            case mxUINT8_CLASS:
                cpMatlabData((const uint8_T *)mdata);
                break;
            case mxINT16_CLASS:
                cpMatlabData((const int16_T *)mdata);
                break;
            case mxUINT16_CLASS:
                cpMatlabData((const uint16_T *)mdata);
                break;
            case mxINT32_CLASS:
                cpMatlabData((const int32_T *)mdata);
                break;
            case mxUINT32_CLASS:
                cpMatlabData((const uint32_T *)mdata);
                break;
	    case mxINT64_CLASS:
		cpMatlabData((const int64_T *)mdata);
		break;
	    case mxUINT64_CLASS:
		cpMatlabData((const uint64_T *)mdata);
		break;	
            }
        }
    }
    
    // the actual memory copy and base type conversion
    // is then performed by this routine that handles the 
    // annoying x-y problem of MatLab when dealing with images:
    // we switch line and column storage: Matlab A(x,y) 
    // becones CImg img(y,x)
    template <typename t> void cpMatlabData(const t* mdata) {
        cimg_mapXYZV(*this, x, y, z, v) {
            (*this)(x, y, z, v) = (T)(mdata[((v*depth + z)*width+x)*height+y]);
        }
    }

public:

    // Consruct a CImg<T> object from a MatLab mxArray.
    // The Matlab array must be AT MOST 4-dimensional.
    // the boolean argument vdata is employed in the 
    // case the the input mxArray has dimension 3,
    // say M x N x K.
    // In that case, if vdata is true, the last dimension
    // is assumed to be "vectorial" and the resulting CImg<T>
    // object has dimension N x M x 1 x K. Otherwise, the
    // resulting object has dimension N x M x K x 1.
    // When Matlab array has dimension 2 or 4, vdata
    // has no effects.	// We do not use shared memory mechanisms.
	CImg(const mxArray *matlabArray, bool vdata = false) : is_shared(false) {
        int nbdims = mxGetNumberOfDimensions(matlabArray);
        mxClassID classID = mxGetClassID(matlabArray);
        if (nbdims > 4 || !isNumericalClassID(classID)) {
            data=NULL; width=height=depth=dim=0;
#if cimg_debug>1
            cimg::warn(1,"Matlab array is more than 4D"
                       " or/and not numerical, returning null image.");
#endif      
        } else {
            const mwSize *dims = mxGetDimensions(matlabArray);
            depth = dim = 1;
            width = (unsigned int)dims[1]; height = (unsigned int)dims[0];
            if (nbdims == 4) {
                depth = (unsigned int)dims[2];  
                dim = (unsigned int)dims[3];
            } else if (nbdims == 3) {
                if (vdata) dim = (unsigned int)dims[2];
                else depth = (unsigned int)dims[2];
            }
            data = new T[size()];
            makeImageFromMatlabData(matlabArray, classID);
        }
    }
    
    
    
    // operator=(). Copy  mxMarray data mArray into the current image
    // Works as the previous constructor, but without the vdata stuff.
    // don't know if it is of any use...
    CImg & operator=(const mxArray *matlabArray) {
        int nbdims = mxGetNumberOfDimensions(matlabArray);
        int classID = mxGetClassID(matlabArray);
        if (nbdims > 4 || !isNumericalClassID(classID)) {
            delete [] data; data = NULL; width=height=depth=dim=0;
#if cimg_debug>1
            cimg::warn(1,"Matlab array is more than 4D "
                       "or/and not numerical, returning null image.");
#endif      
        } else {
            const size_t *dims = mxGetDimensions(matlabArray);
            depth = dim = 1;
            width = (unsigned int)dims[1]; height = (unsigned int)dims[0]; 
            if (nbdims > 2) depth = (unsigned int)dims[2];
            if (nbdims > 3) dim = (unsigned int)dims[3];
            delete [] data;
            data = new T[size()];
            makeImageFromMatlabData(matlabArray, classID);
        }
    }
    
 private:      
    // private routines used for transfering a CImg<T> to a mxArray
    // here also, we have to exchange the x and y dims so we get the 
    // expected matlab array
    template <typename c>
        void populate_maltlab_array(c *mdata) const {
        cimg_mapXYZV(*this, x, y, z, v) 
            mdata[((v*depth + z)*width+x)*height+y] = (c)(*this)(x, y, z, v);
    }
    // the specialized version for "logical" entries
    void populate_maltlab_array(mxLogical *mdata) const {
        cimg_mapXYZV(*this, x, y, z, v) 
            mdata[((v*depth + z)*width+x)*height+y] = (mxLogical)((*this)(x, y, z, v)!=0);
    }
    
    
 public:
    // export a CImg image to a matlab array.  
    mxArray *toMatlab(mxClassID classID = mxDOUBLE_CLASS, bool squeeze = false) const {
        if (!isNumericalClassID(classID)) {
#if cimg_debug>1
            cimg::warn(1,"Invalid Matlab Class Id Specified.");
#endif
            return NULL;
        }
        mwSize dims[4];
        dims[0] = height;
        dims[1] = width;
        dims[2] = depth;
        dims[3] = dim;
        if (squeeze && depth == 1) {
            dims[2] = dim;
            dims[3] = 1;
        }
        mxArray *matlabArray = mxCreateNumericArray(4,dims,classID,mxREAL);
        if (classID == mxLOGICAL_CLASS) {
            mxLogical *mdata = mxGetLogicals(matlabArray);
            populate_maltlab_array(mdata);
        } else {
            void *mdata = mxGetPr(matlabArray);
            switch (classID) {
            case mxDOUBLE_CLASS:
                populate_maltlab_array((real64_T *)mdata);
                break;
            case mxSINGLE_CLASS:
                populate_maltlab_array((real32_T *)mdata);
                break;
            case mxINT8_CLASS:
                populate_maltlab_array((int8_T *)mdata);
                break;
            case mxUINT8_CLASS:
                populate_maltlab_array((uint8_T *)mdata);
                break;
            case mxINT16_CLASS:
                populate_maltlab_array((int16_T *)mdata);
                break;
            case mxUINT16_CLASS:
                populate_maltlab_array((uint16_T *)mdata);
                break;  
            case mxINT32_CLASS:
                populate_maltlab_array((int32_T *)mdata);
                break;
            case mxUINT32_CLASS:
                populate_maltlab_array((uint32_T *)mdata);
                break;
			case mxINT64_CLASS:
                populate_maltlab_array((int64_T *)mdata);
                break;
			case mxUINT64_CLASS:
                populate_maltlab_array((uint64_T *)mdata);
                break;
            }   
        }
        return matlabArray;
    }   

// end of cimgmatlab.h