python_image.h File Reference

#include "Python.h"
#include "core/xmipp_image_generic.h"
#include <numpy/ndarraytypes.h>
#include <numpy/arrayobject.h>
#include <memory>

Include dependency graph for python_image.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	ImageObject

Macros
#define	NPY_NO_DEPRECATED_API   NPY_1_7_API_VERSION
#define	Image_Check(v)   (((v)->ob_type == &ImageType))
#define	Image_Value(v)   ((*((ImageObject*)(v))->image))

Functions
void	Image_dealloc (ImageObject *self)
PyObject *	Image_new (PyTypeObject *type, PyObject *args, PyObject *kwargs)
PyObject *	Image_repr (PyObject *obj)
PyObject *	Image_RichCompareBool (PyObject *obj, PyObject *obj2, int opid)
PyObject *	Image_equal (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_write (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_read (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_readPreview (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_readPreviewSmooth (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_convertPSD (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_readApplyGeo (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_applyGeo (PyObject *obj, PyObject *args, PyObject *kwargs)
NPY_TYPES	datatype2NpyType (DataType dt)
DataType	npyType2Datatype (int npy)
PyObject *	Image_getData (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_projectVolumeDouble (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_setData (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_getPixel (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_setPixel (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_initConstant (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_mirrorY (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_applyTransforMatScipion (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_warpAffine (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_applyCTF (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_initRandom (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_resize (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_scale (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_reslice (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_writeSlices (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_patch (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_getDataType (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_setDataType (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_convert2DataType (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_getDimensions (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_resetOrigin (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_getEulerAngles (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_getMainHeaderValue (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_setMainHeaderValue (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_getHeaderValue (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_setHeaderValue (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_computeStats (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_computePSD (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_adjustAndSubtract (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_correlation (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_correlationAfterAlignment (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_window2D (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_add (PyObject *obj1, PyObject *obj2)
PyObject *	Image_iadd (PyObject *obj1, PyObject *obj2)
PyObject *	Image_inplaceAdd (PyObject *self, PyObject *args, PyObject *kwargs)
PyObject *	Image_subtract (PyObject *obj1, PyObject *obj2)
PyObject *	Image_isubtract (PyObject *obj1, PyObject *obj2)
PyObject *	Image_inplaceSubtract (PyObject *self, PyObject *args, PyObject *kwargs)
PyObject *	Image_multiply (PyObject *obj1, PyObject *obj2)
PyObject *	Image_imultiply (PyObject *obj1, PyObject *obj2)
PyObject *	Image_inplaceMultiply (PyObject *self, PyObject *args, PyObject *kwargs)
PyObject *	Image_true_divide (PyObject *obj1, PyObject *obj2)
PyObject *	Image_idivide (PyObject *obj1, PyObject *obj2)
PyObject *	Image_inplaceDivide (PyObject *self, PyObject *args, PyObject *kwargs)
PyObject *	Image_radialAvgAxis (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	Image_centerOfMass (PyObject *obj)

Variables
PyObject *	PyXmippError
PyNumberMethods	Image_NumberMethods
PyMethodDef	Image_methods []
PyTypeObject	ImageType

Macro Definition Documentation

Image_Check

#define Image_Check

(

v

)

(((v)->ob_type == &ImageType))

Definition at line 43 of file python_image.h.

Image_Value

#define Image_Value

(

v

)

((*((ImageObject*)(v))->image))

Definition at line 44 of file python_image.h.

NPY_NO_DEPRECATED_API

#define NPY_NO_DEPRECATED_API   NPY_1_7_API_VERSION

Definition at line 30 of file python_image.h.

Function Documentation

datatype2NpyType()

NPY_TYPES datatype2NpyType

(

DataType

dt

)

Definition at line 520 of file python_image.cpp.

{
    switch (dt)
    {
    case DT_Float:
        return NPY_FLOAT;
    case DT_Double:
        return NPY_DOUBLE;
    case DT_Int:
        return NPY_INT;
    case DT_UInt:
        return NPY_UINT;
    case DT_Short:
        return NPY_SHORT;
    case DT_UShort:
        return NPY_USHORT;
    case DT_SChar:
        return NPY_BYTE;
    case DT_UChar:
        return NPY_UBYTE;
    case DT_Bool:
        return NPY_BOOL;
    case DT_CFloat:
        return NPY_CFLOAT;
    case DT_CDouble:
        return NPY_CDOUBLE;
    case DT_HalfFloat:
        return NPY_HALF;
    default:
        return NPY_NOTYPE;
    }
}

Image_add()

PyObject* Image_add	(	PyObject *	obj1,
		PyObject *	obj2
	)

Definition at line 1376 of file python_image.cpp.

{
    ImageObject * result = (ImageObject*)PyObject_CallFunction((PyObject*)&ImageType, "");
    if (result != nullptr)
    {
        try
        {
            result->image = std::make_unique<ImageGeneric>(Image_Value(obj1));
            Image_Value(result).add(Image_Value(obj2));
        }
        catch (XmippError &xe)
        {
            result=nullptr;
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return (PyObject *)result;
}//operator +

Image_adjustAndSubtract()

PyObject* Image_adjustAndSubtract	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1273 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    PyObject *pimg2 = nullptr;
    ImageObject * result = (ImageObject*)PyObject_CallFunction((PyObject*)&ImageType, "");
    if (self != nullptr)
    {
        try
        {
            if (PyArg_ParseTuple(args, "O", &pimg2))
            {
                ImageObject *img2=(ImageObject *)pimg2;
                result->image = std::make_unique<ImageGeneric>(Image_Value(img2));
                MULTIDIM_ARRAY_GENERIC(*result->image).rangeAdjust(MULTIDIM_ARRAY_GENERIC(*self->image));
                MULTIDIM_ARRAY_GENERIC(*result->image) *=-1;
                MULTIDIM_ARRAY_GENERIC(*result->image) += MULTIDIM_ARRAY_GENERIC(*self->image);
            }
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return (PyObject *)result;
}//function Image_adjustAndSubtract

Image_applyCTF()

PyObject* Image_applyCTF	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1236 of file xmippmodule.cpp.

{
    PyObject *pimg = nullptr;
    PyObject *input = nullptr;
    double Ts=1.0;
    size_t rowId;
    auto *pyReplace = Py_False;
    bool absPhase = false;

    try
    {
        PyArg_ParseTuple(args, "OOd|kO", &pimg, &input,&Ts,&rowId,&pyReplace);
        if (pimg != nullptr && input != nullptr)
        {
            if(PyBool_Check(pyReplace))
                absPhase = pyReplace == Py_True;

            PyObject *pyStr;
            if (PyUnicode_Check(input) || MetaData_Check(input))
            {
                auto *img = (ImageObject*) pimg;
                auto &image = img->image;
                image->convert2Datatype(DT_Double);
                MultidimArray<double> * mImage=nullptr;
                MULTIDIM_ARRAY_GENERIC(*image).getMultidimArrayPointer(mImage);

                // COSS: This is redundant? image->data->getMultidimArrayPointer(mImage);

                CTFDescription ctf;
                ctf.enable_CTF=true;
                ctf.enable_CTFnoise=false;
                if (MetaData_Check(input))
                    ctf.readFromMetadataRow(MetaData_Value(input), rowId );
                else
               {
                   pyStr = PyObject_Str(input);
                   FileName fnCTF = (char*)PyUnicode_AsUTF8(pyStr);
                   ctf.read(fnCTF);
               }
                ctf.produceSideInfo();
                ctf.applyCTF(*mImage,Ts,absPhase);
                Py_RETURN_NONE;
            }
        }
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}

Image_applyGeo()

PyObject* Image_applyGeo	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1860 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);

    if (self != nullptr)
    {
        PyObject *md = nullptr;
        PyObject *only_apply_shifts = Py_False;
        PyObject *wrap = (xmipp_transformation::WRAP ? Py_True : Py_False);
        size_t objectId = BAD_OBJID;
        bool boolOnly_apply_shifts = false;
        bool boolWrap = xmipp_transformation::WRAP;

        if (PyArg_ParseTuple(args, "Ok|OO", &md, &objectId, &only_apply_shifts, &wrap))
        {
            try
            {
                if (PyBool_Check(only_apply_shifts))
                    boolOnly_apply_shifts = (only_apply_shifts == Py_True);
                else
                    PyErr_SetString(PyExc_TypeError, "ImageGeneric::applyGeo: Expecting boolean value");
                if (PyBool_Check(wrap))
                    boolWrap = (wrap == Py_True);
                else
                    PyErr_SetString(PyExc_TypeError, "ImageGeneric::applyGeo: Expecting boolean value");
                ApplyGeoParams params;
                params.only_apply_shifts = boolOnly_apply_shifts;
                params.wrap = boolWrap;
                self->image->applyGeo(MetaData_Value(md), objectId, params);
                Py_RETURN_NONE;
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
            }
        }
    }
    return nullptr;
}

Image_applyTransforMatScipion()

PyObject* Image_applyTransforMatScipion	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Image inplace subtraction, equivalent to -= operator

Definition at line 1672 of file python_image.cpp.

{

    PyObject * list = nullptr;
    PyObject * item = nullptr;
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    ImageBase * img;
    PyObject *only_apply_shifts = Py_False;
    PyObject *wrap = (xmipp_transformation::WRAP ? Py_True : Py_False);
    img = self->image->image;
    bool boolOnly_apply_shifts = false;
    bool boolWrap = xmipp_transformation::WRAP;

    try
    {
        PyArg_ParseTuple(args, "O|OO", &list, &only_apply_shifts, &wrap);
        if (PyList_Check(list))
        {
            if (PyBool_Check(only_apply_shifts))
                boolOnly_apply_shifts = (only_apply_shifts == Py_True);
            else
                PyErr_SetString(PyExc_TypeError, "ImageGeneric::applyGeo: Expecting boolean value");
            if (PyBool_Check(wrap))
                boolWrap = (wrap == Py_True);
            else
                PyErr_SetString(PyExc_TypeError, "ImageGeneric::applyGeo: Expecting boolean value");


            size_t size = PyList_Size(list);
            Matrix2D<double> A;
            A.initIdentity(4);
            for (size_t i = 0; i < size; ++i)
            {
                item  = PyList_GetItem(list, i);
                MAT_ELEM(A,i/4,i%4 ) = PyFloat_AsDouble(item);
            }
            double scale;
            double shiftX;
            double shiftY;
            double rot;
            double tilt;
            double psi;
            tilt = 0.0;
            rot = 0.0;
            bool flip;
            transformationMatrix2Parameters2D(A, flip, scale, shiftX, shiftY, psi);//, shiftZ, rot,tilt, psi);
            img->setEulerAngles(rot,tilt,psi);
            img->setShifts(shiftX,shiftY);
            img->setScale(scale);
            img->setFlip(flip);
            img->selfApplyGeometry(xmipp_transformation::LINEAR, boolWrap, boolOnly_apply_shifts);//wrap, onlyShifts
            Py_RETURN_NONE;
        }
        else
        {
            PyErr_SetString(PyExc_TypeError, "ImageGeneric::applyTransforMatScipion: Expecting a list");

        }
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}//operator +=

Image_centerOfMass()

PyObject* Image_centerOfMass

(

PyObject *

obj

)

Definition at line 1975 of file python_image.cpp.

{
    auto *self = (ImageObject*) obj;
    if (self != nullptr)
    {
        try
        {
            Matrix1D< double > center;
            self->image->convert2Datatype(DT_Double);
            MultidimArray<double> *in;
            MULTIDIM_ARRAY_GENERIC(*self->image).getMultidimArrayPointer(in);
            in->centerOfMass(center);
            return Py_BuildValue("fff", XX(center), YY(center), ZZ(center));
        }
        catch (const XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

Image_computePSD()

PyObject* Image_computePSD	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1235 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    if (nullptr == self) return nullptr;
    try {
        // keep default values consistent with the python
        float overlap = 0.4f;
        int dimX = 384;
        int dimY = 384;
        unsigned threads = 1;
        ImageObject *result = (ImageObject*)PyObject_CallFunction((PyObject*)&ImageType, "");
        if (PyArg_ParseTuple(args, "|fIIb", &overlap, &dimX, &dimY, &threads)
                && (nullptr != result)) {
            // prepare dims
            auto dims = Dimensions(dimX, dimY);
            // prepare input image
            auto &image = self->image;
            image->convert2Datatype(DT_Double);
            MultidimArray<double> *in;
            MULTIDIM_ARRAY_GENERIC(*image).getMultidimArrayPointer(in);
            // prepare output image
            result->image = std::make_unique<ImageGeneric>(DT_Double);
            MultidimArray<double> *out;
            MULTIDIM_ARRAY_GENERIC(*result->image).getMultidimArrayPointer(out);
            // call the estimation
            PSDEstimator<double>::estimatePSD(*in, overlap, dims, *out, threads, false);
        } else {
            PyErr_SetString(PyXmippError, "Unknown error while allocating data for output or parsing data");
        }
        return (PyObject *)result;
    } catch (XmippError &xe) {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return Py_BuildValue("");
}

Image_computeStats()

PyObject* Image_computeStats	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1212 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    if (self != nullptr)
    {
        try
        {
            double mean=0.0;
            double dev=0.0;
            double min=0.0;
            double max=0.0;
            self->image->data->computeStats(mean, dev, min, max);
            return Py_BuildValue("ffff", mean, dev, min, max);
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_computeStats

Image_convert2DataType()

PyObject* Image_convert2DataType	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1003 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    int datatype;
    int castMode=CW_CONVERT;

    if (self != nullptr && PyArg_ParseTuple(args, "i|i", &datatype, &castMode))
    {
        try
        {
            self->image->convert2Datatype((DataType)datatype, (CastWriteMode)castMode);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_setDataType

Image_convertPSD()

PyObject* Image_convertPSD	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1169 of file xmippmodule.cpp.

{
    auto *self = (ImageObject*) obj;

    if (self != nullptr)
    {
        try
        {
            auto &image = self->image;
            image->convert2Datatype(DT_Double);
            MultidimArray<double> *in;
            MULTIDIM_ARRAY_GENERIC(*image).getMultidimArrayPointer(in);
            xmipp2PSD(*in, *in, true);

            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_convertPSD

Image_correlation()

PyObject* Image_correlation	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1301 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    if (self != nullptr)
    {
        try
        {
            PyObject *pimg2 = nullptr;
            if (PyArg_ParseTuple(args, "O", &pimg2))
            {
                auto &image = self->image;
                image->convert2Datatype(DT_Double);
                MultidimArray<double> * pImage=nullptr;
                MULTIDIM_ARRAY_GENERIC(*image).getMultidimArrayPointer(pImage);

                ImageObject *img2=(ImageObject *)pimg2;
                auto &image2 = img2->image;
                image2->convert2Datatype(DT_Double);
                MultidimArray<double> * pImage2=nullptr;
                MULTIDIM_ARRAY_GENERIC(*image2).getMultidimArrayPointer(pImage2);

                double corr=correlationIndex(*pImage,*pImage2);
                return Py_BuildValue("f", corr);
            }
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_correlation

Image_correlationAfterAlignment()

PyObject* Image_correlationAfterAlignment	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1336 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    if (self != nullptr)
    {
        try
        {
            PyObject *pimg2 = nullptr;
            if (PyArg_ParseTuple(args, "O", &pimg2))
            {
                auto &image = self->image;
                image->convert2Datatype(DT_Double);
                MultidimArray<double> * pImage=nullptr;
                MULTIDIM_ARRAY_GENERIC(*image).getMultidimArrayPointer(pImage);

                ImageObject *img2=(ImageObject *)pimg2;
                auto &image2 = img2->image;
                image2->convert2Datatype(DT_Double);
                MultidimArray<double> * pImage2=nullptr;
                MULTIDIM_ARRAY_GENERIC(*image2).getMultidimArrayPointer(pImage2);
                pImage->setXmippOrigin();
                pImage2->setXmippOrigin();

                Matrix2D<double> M;
                MultidimArray<double> I2Copy=*pImage2;

                double corr=alignImagesConsideringMirrors(*pImage, I2Copy, M, xmipp_transformation::WRAP);
                return Py_BuildValue("f", corr);
            }
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

Image_dealloc()

void Image_dealloc

(

ImageObject *

self

)

Definition at line 205 of file python_image.cpp.

{
    self->~ImageObject(); // Call the destructor
    Py_TYPE(self)->tp_free((PyObject*)self);
}//function Image_dealloc

Image_equal()

PyObject* Image_equal	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 313 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    if (self != nullptr)
    {
        double precision = 1.e-3;
        PyObject *image2 = nullptr;
        if (PyArg_ParseTuple(args, "O|d", &image2, &precision))
        {
            try
            {
                if (Image_Value(obj).equal(Image_Value(image2), precision))
                    Py_RETURN_TRUE;
                else
                    Py_RETURN_FALSE;
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
            }
        }
    }
    return nullptr;
}//function Image_equal

Image_getData()

PyObject* Image_getData	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 604 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);

    if (self != nullptr)
    {
        try
        {
            ArrayDim adim;
            ImageGeneric & image = Image_Value(self);
            DataType dt = image.getDatatype();
            int nd = image.image->mdaBase->getDim();
            MULTIDIM_ARRAY_GENERIC(image).getDimensions(adim);
            npy_intp dims[4];
            dims[0] = adim.ndim;
            dims[1] = adim.zdim;
            dims[2] = adim.ydim;
            dims[3] = adim.xdim;
            //Get the pointer to data
            void *mymem = image().getArrayPointer();
            NPY_TYPES type = datatype2NpyType(dt);
            //dims pointer is shifted if ndim or zdim are 1
            PyArrayObject * arr = (PyArrayObject*) PyArray_SimpleNew(nd, dims+4-nd, type);
            void * data = PyArray_DATA(arr);
            memcpy(data, mymem, adim.nzyxdim * gettypesize(dt));

            return (PyObject*)arr;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_getData

Image_getDataType()

PyObject* Image_getDataType	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 959 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);

    if (self != nullptr)
    {
        try
        {
            ImageGeneric & image = Image_Value(self);
            DataType dt = image.getDatatype();
            return  Py_BuildValue("i", dt);
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_getDataType

Image_getDimensions()

PyObject* Image_getDimensions	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1026 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    if (self != nullptr)
    {
        try
        {
            size_t xdim;
            size_t ydim;
            size_t zdim;
            size_t ndim;
            MULTIDIM_ARRAY_GENERIC(*self->image).getDimensions(xdim, ydim, zdim, ndim);
            return Py_BuildValue("iiik", xdim, ydim, zdim, ndim);
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_getDimensions

Image_getEulerAngles()

PyObject* Image_getEulerAngles	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1070 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    if (self != nullptr)
    {
        try
        {
            double rot;
            double tilt;
            double psi;
            self->image->getEulerAngles(rot, tilt, psi);
            return Py_BuildValue("fff", rot, tilt, psi);

        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_getEulerAngles

Image_getHeaderValue()

PyObject* Image_getHeaderValue	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1154 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    PyObject *pyValue;
    int label;

    if (self != nullptr && PyArg_ParseTuple(args, "i", &label))
    {
        try
        {
            MDRow &mainHeader = *(self->image->image->MD[0]);
            if (mainHeader.containsLabel((MDLabel)label))
            {
                MDObject * object = mainHeader.getObject((MDLabel) label);
                pyValue = getMDObjectValue(object);
                return pyValue;
            }
            else
                Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

Image_getMainHeaderValue()

PyObject* Image_getMainHeaderValue	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1095 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    PyObject *pyValue;
    int label;

    if (self != nullptr && PyArg_ParseTuple(args, "i", &label))
    {
        try
        {
            MDRow &mainHeader = self->image->image->MDMainHeader;
            if (mainHeader.containsLabel((MDLabel)label))
            {
                MDObject * object = mainHeader.getObject((MDLabel) label);
                pyValue = getMDObjectValue(object);
                return pyValue;
            }
            else
                Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

Image_getPixel()

PyObject* Image_getPixel	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 680 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    int i;
    int j;
    int k;
    int n;
    double value;

    if (self != nullptr && PyArg_ParseTuple(args, "iiii", &n, &k, &i, &j ))
    {
        try
        {
            self->image->data->im->resetOrigin();
            if (n==0 && k==0)
                 value = self->image->getPixel(i, j);
            else
                 value = self->image->getPixel(n, k , i, j);
            return PyFloat_FromDouble(value);
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_getPixel

Image_iadd()

PyObject* Image_iadd	(	PyObject *	obj1,
		PyObject *	obj2
	)

Image inplace add, equivalent to += operator

Definition at line 1397 of file python_image.cpp.

{
    ImageObject * result = nullptr;
    try
    {
        Image_Value(obj1).add(Image_Value(obj2));
        if ((result = (ImageObject*)PyObject_CallFunction((PyObject*)&ImageType, "")))
            result->image = std::make_unique<ImageGeneric>(Image_Value(obj1));
        //return obj1;
    }
    catch (XmippError &xe)
    {
        result=nullptr;
        PyErr_SetString(PyXmippError, xe.what());
    }
    return (PyObject *)result;
}//operator +=

Image_idivide()

PyObject* Image_idivide	(	PyObject *	obj1,
		PyObject *	obj2
	)

Image division NOTE (JM): For efficiency reasons, we break the Python convention and return None instead of a new reference of Image just to avoid creating a new Image object.

Definition at line 1618 of file python_image.cpp.

{
    std::cerr << "TODO: not working Image_idivide_____________________________" << std::endl;
    try
    {
      ImageObject * result = nullptr;
      if ((result = (ImageObject*)PyObject_CallFunction((PyObject*)&ImageType, "")))
          result->image = std::make_unique<ImageGeneric>(Image_Value(obj1));
      double value = PyFloat_AsDouble(obj2);
      Image_Value(result).divide(value);
      return (PyObject*) result;
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}//operator /=

Image_imultiply()

PyObject* Image_imultiply	(	PyObject *	obj1,
		PyObject *	obj2
	)

Definition at line 1539 of file python_image.cpp.

{
    try
    {
        ImageObject * result = nullptr;
        if ((result = (ImageObject*)PyObject_CallFunction((PyObject*)&ImageType, "")))
            result->image = std::make_unique<ImageGeneric>(Image_Value(obj1));
        double value = PyFloat_AsDouble(obj2);
        Image_Value(result).multiply(value);
        return (PyObject*) result;
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}//operator *=

Image_initConstant()

PyObject* Image_initConstant	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 740 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    double value = -1;

    if (self != nullptr && PyArg_ParseTuple(args, "d", &value))
    {
        try
        {
            self->image->initConstant(value);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_initConstant

Image_initRandom()

PyObject* Image_initRandom	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 779 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    double op1 = 0;
    double op2 = 1;
    RandomMode mode = RND_UNIFORM;
    int pyMode = -1;

    if (self != nullptr && PyArg_ParseTuple(args, "|ddi", &op1, &op2, &pyMode))
    {
        try
        {
            if (pyMode != -1)
                mode = (RandomMode) pyMode;

            self->image->initRandom(op1, op2, mode);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_initRandom

Image_inplaceAdd()

PyObject* Image_inplaceAdd	(	PyObject *	self,
		PyObject *	args,
		PyObject *	kwargs
	)

Image inplace add, equivalent to *= operator but this not return a new instance of image, mainly for efficiency reasons.

Definition at line 1420 of file python_image.cpp.

{
    try
    {
      PyObject *other = nullptr;
      if (PyArg_ParseTuple(args, "O", &other) &&
          Image_Check(other))
      {
          STARTINGX(MULTIDIM_ARRAY_BASE(Image_Value(self)))=
                  STARTINGX(MULTIDIM_ARRAY_BASE(Image_Value(other)));
          STARTINGY(MULTIDIM_ARRAY_BASE(Image_Value(self)))=
                  STARTINGY(MULTIDIM_ARRAY_BASE(Image_Value(other)));
          STARTINGZ(MULTIDIM_ARRAY_BASE(Image_Value(self)))=
                  STARTINGZ(MULTIDIM_ARRAY_BASE(Image_Value(other)));

        Image_Value(self).add(Image_Value(other));
        Py_RETURN_NONE;
      }
      else
        PyErr_SetString(PyXmippError, "Expecting Image as second argument");
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}// similar to -=

Image_inplaceDivide()

PyObject* Image_inplaceDivide	(	PyObject *	self,
		PyObject *	args,
		PyObject *	kwargs
	)

Image inplace divide, equivalent to /= operator but this not return a new instance of image, mainly for efficiency reasons.

Definition at line 1642 of file python_image.cpp.

{
  try
  {
    PyObject *other = nullptr;
    if (PyArg_ParseTuple(args, "O", &other))
    {
      if (Image_Check(other))
      {
        Image_Value(self).divide(Image_Value(other));
      }
      else
      {
        Image_Value(self).divide(PyFloat_AsDouble(other));
      }
      Py_RETURN_NONE;
    }
    else
      PyErr_SetString(PyXmippError, "Expecting Number or Image as second argument");
  }
  catch (XmippError &xe)
  {
      PyErr_SetString(PyXmippError, xe.what());
  }
  return nullptr;

}// similar to /=

Image_inplaceMultiply()

PyObject* Image_inplaceMultiply	(	PyObject *	self,
		PyObject *	args,
		PyObject *	kwargs
	)

Image inplace multiply, equivalent to *= operator but this not return a new instance of image, mainly for efficiency reasons.

Definition at line 1562 of file python_image.cpp.

{
  try
  {
    PyObject *other = nullptr;
    if (PyArg_ParseTuple(args, "O", &other))
    {
      if (Image_Check(other))
      {
        Image_Value(self).multiply(Image_Value(other));
      }
      else
      {
        Image_Value(self).multiply(PyFloat_AsDouble(other));
      }
      Py_RETURN_NONE;
    }
    else
      PyErr_SetString(PyXmippError, "Expecting Number or Image as second argument");
  }
  catch (XmippError &xe)
  {
      PyErr_SetString(PyXmippError, xe.what());
  }
  return nullptr;
}// similar to *=

Image_inplaceSubtract()

PyObject* Image_inplaceSubtract	(	PyObject *	self,
		PyObject *	args,
		PyObject *	kwargs
	)

Image inplace subtract, equivalent to *= operator but this not return a new instance of image, mainly for efficiency reasons.

Definition at line 1494 of file python_image.cpp.

{
  try
  {
    PyObject *other = nullptr;
    if (PyArg_ParseTuple(args, "O", &other) &&
        Image_Check(other))
    {
      Image_Value(self).subtract(Image_Value(other));
      Py_RETURN_NONE;
    }
    else
      PyErr_SetString(PyXmippError, "Expecting Image as second argument");
  }
  catch (XmippError &xe)
  {
      PyErr_SetString(PyXmippError, xe.what());
  }
  return nullptr;
}

Image_isubtract()

PyObject* Image_isubtract	(	PyObject *	obj1,
		PyObject *	obj2
	)

Image inplace subtraction, equivalent to -= operator

Definition at line 1472 of file python_image.cpp.

{
    ImageObject * result = nullptr;
    try
    {
        Image_Value(obj1).subtract(Image_Value(obj2));
        if ((result = (ImageObject*)PyObject_CallFunction((PyObject*)&ImageType, "")))
            result->image = std::make_unique<ImageGeneric>(Image_Value(obj1));
    }
    catch (XmippError &xe)
    {
        result = nullptr;
        PyErr_SetString(PyXmippError, xe.what());
    }
    return (PyObject *)result;
}//operator -=

Image_mirrorY()

PyObject* Image_mirrorY	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 762 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    try
    {
        self->image->mirrorY();
        Py_RETURN_NONE;
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}//function Image_initConstant

Image_multiply()

PyObject* Image_multiply	(	PyObject *	obj1,
		PyObject *	obj2
	)

Definition at line 1517 of file python_image.cpp.

{
    ImageObject * result = (ImageObject*)PyObject_CallFunction((PyObject*)&ImageType, "");
    if (result != nullptr)
    {
        try
        {
            result->image = std::make_unique<ImageGeneric>(Image_Value(obj1));
            double value = PyFloat_AsDouble(obj2);
            Image_Value(result).multiply(value);
        }
        catch (XmippError &xe)
        {
            result = nullptr;
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return (PyObject *)result;
}//operator *

Image_new()

PyObject* Image_new	(	PyTypeObject *	type,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 213 of file python_image.cpp.

{
    ImageObject *self = (ImageObject*)type->tp_alloc(type, 0);

    if (self != nullptr)
    {
        PyObject *input = nullptr;

        if (PyArg_ParseTuple(args, "|O", &input))
        {
            if (input != nullptr)
            {
                try
                {
                    PyObject *pyStr;
                    // If the input object is a tuple, consider it (index, filename)
                    if (PyTuple_Check(input))
                    {
                      // Get the index and filename from the Python tuple object
                      size_t index = PyLong_AsSsize_t(PyTuple_GetItem(input, 0));
                      PyObject* repr = PyObject_Str(PyTuple_GetItem(input, 1));
                      const char * filename = PyUnicode_AsUTF8(repr);
                      // Now read using both of index and filename
                      self->image = std::make_unique<ImageGeneric>();
                      self->image->read(filename, DATA, index);

                    }
                    else if ((pyStr = PyObject_Str(input)) != nullptr)
                    {
                        self->image = std::make_unique<ImageGeneric>(PyUnicode_AsUTF8(pyStr));
                        //todo: add copy constructor
                    }
                    else
                    {
                        PyErr_SetString(PyExc_TypeError,
                                        "Image_new: Expected string, FileName or tuple as first argument");
                        return nullptr;
                    }
                }
                catch (XmippError &xe)
                {
                    PyErr_SetString(PyXmippError, xe.what());
                    return nullptr;
                }
            }
            else
                self->image = std::make_unique<ImageGeneric>();
        }
        else
            return nullptr;
    }
    return (PyObject *)self;
}//function Image_new

Image_patch()

PyObject* Image_patch	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 935 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    PyObject *patch;
    int x = 0;
    int y = 0;

    if (self != nullptr && PyArg_ParseTuple(args, "Oii", &patch, &x, &y))
    {
        try
        {
            MULTIDIM_ARRAY_GENERIC(Image_Value(self)).patch(MULTIDIM_ARRAY_GENERIC(Image_Value(patch)), x, y);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_patch

Image_projectVolumeDouble()

PyObject* Image_projectVolumeDouble	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1290 of file xmippmodule.cpp.

{
    PyObject *pvol = nullptr;
    ImageObject * result = nullptr;
    double rot;
    double tilt;
    double psi;

    if (PyArg_ParseTuple(args, "Oddd", &pvol, &rot,&tilt,&psi))
    {
        try
        {
            // We use the following macro to release the Python Interpreter Lock (GIL)
            // while running this C extension code and allows threads to run concurrently.
            // See: https://docs.python.org/2.7/c-api/init.html for details.
            Py_BEGIN_ALLOW_THREADS
            Projection P;
            auto *vol = (ImageObject*) pvol;
            MultidimArray<double> * mVolume;
            vol->image->data->getMultidimArrayPointer(mVolume);
            ArrayDim aDim;
            mVolume->getDimensions(aDim);
            mVolume->setXmippOrigin();
            projectVolume(*mVolume, P, aDim.xdim, aDim.ydim,rot, tilt, psi);
            result = (ImageObject*)PyObject_CallFunction((PyObject*)&ImageType, "");
            Image <double> I;
            result->image = std::make_unique<ImageGeneric>();
            result->image->setDatatype(DT_Double);
            result->image->data->setImage(MULTIDIM_ARRAY(P));
            Py_END_ALLOW_THREADS
            return (PyObject *)result;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_projectVolumeDouble

Image_radialAvgAxis()

PyObject* Image_radialAvgAxis	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1943 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
        if (nullptr == self) return nullptr;
        try {
            char axis = 'z';
            ImageObject *result = (ImageObject*)PyObject_CallFunction((PyObject*)&ImageType, "");
            if (PyArg_ParseTuple(args, "|c", &axis)
                    && (nullptr != result)) {
                // prepare input image
                auto &volume = self->image;
                volume->convert2Datatype(DT_Double);
                MultidimArray<double> *in;
                MULTIDIM_ARRAY_GENERIC(*volume).getMultidimArrayPointer(in);
                // prepare output image
                result->image = std::make_unique<ImageGeneric>(DT_Double);
                MultidimArray<double> *out;
                MULTIDIM_ARRAY_GENERIC(*result->image).getMultidimArrayPointer(out);
                // call the estimation
                radialAverageAxis(*in, axis, *out);
            } else {
                PyErr_SetString(PyXmippError, "Unknown error while allocating data for output or parsing data");
            }
            return (PyObject *)result;
        } catch (XmippError &xe) {
            PyErr_SetString(PyXmippError, xe.what());
        }
    return Py_BuildValue("");
}

Image_read()

PyObject* Image_read	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 388 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);

    if (self != nullptr)
    {
        int datamode = DATA;
        PyObject *input = nullptr;
        if (PyArg_ParseTuple(args, "O|i", &input, &datamode))
        {

            try
            {
              PyObject *pyStr;
              // If the input object is a tuple, consider it (index, filename)
              if (PyTuple_Check(input))
              {
                // Get the index and filename from the Python tuple object
                size_t index = PyLong_AsSsize_t(PyTuple_GetItem(input, 0));
                PyObject* repr = PyObject_Str(PyTuple_GetItem(input, 1));
                const char *filename = PyUnicode_AsUTF8(repr);
                // Now read using both of index and filename
                self->image->read(filename,(DataMode)datamode, index);
                Py_RETURN_NONE;
              }
              else if ((pyStr = PyObject_Str(input)) != nullptr)
              {
                  self->image->read(PyUnicode_AsUTF8(pyStr),(DataMode)datamode);
                  Py_RETURN_NONE;
              }
              else
              {
                  PyErr_SetString(PyExc_TypeError,
                                  "Image_write: Expected an string or FileName as first argument");
              }
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
            }
        }
    }
    return nullptr;
}//function Image_read

Image_readApplyGeo()

PyObject* Image_readApplyGeo	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1740 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);

    if (self != nullptr)
    {
        PyObject *md = nullptr;
        PyObject *only_apply_shifts = Py_False;
        PyObject *wrap = (xmipp_transformation::WRAP ? Py_True : Py_False);
        size_t objectId = BAD_OBJID;
        bool boolOnly_apply_shifts = false;
        bool boolWrap = xmipp_transformation::WRAP;
        int datamode = DATA;
        size_t select_img = ALL_IMAGES;

        if (PyArg_ParseTuple(args, "Ok|OikO", &md, &objectId, &only_apply_shifts, &datamode, &select_img, &wrap))
        {
            try
            {
                if (PyBool_Check(only_apply_shifts))
                    boolOnly_apply_shifts = (only_apply_shifts == Py_True);
                else
                    PyErr_SetString(PyExc_TypeError, "ImageGeneric::readApplyGeo: Expecting boolean value");
                if (PyBool_Check(wrap))
                    boolWrap = (wrap == Py_True);
                else
                    PyErr_SetString(PyExc_TypeError, "ImageGeneric::readApplyGeo: Expecting boolean value");
                ApplyGeoParams params;
                params.only_apply_shifts = boolOnly_apply_shifts;
                params.datamode = (DataMode)datamode;
                params.select_img = select_img;
                params.wrap = boolWrap;
                self->image->readApplyGeo(MetaData_Value(md), objectId, params);
                Py_RETURN_NONE;
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
            }
        }
    }
    return nullptr;
}

Image_readPreview()

PyObject* Image_readPreview	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 446 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);

    if (self != nullptr)
    {
        PyObject *input = nullptr;
        int x = 0;
        int slice = CENTRAL_SLICE;

        if (PyArg_ParseTuple(args, "O|ii", &input, &x, &slice))
        {
            try
            {
              PyObject *pyStr;
              if ((pyStr = PyObject_Str(input)) != nullptr)
              {
                  readImagePreview(self->image.get(), PyUnicode_AsUTF8(pyStr), x, slice);
                  Py_RETURN_NONE;
              }
              else
              {
                  PyErr_SetString(PyExc_TypeError,
                                  "Image_readPreview: Expected string or FileName as first argument");
              }
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
            }
        }
        else
          PyErr_SetString(PyXmippError,"Error with input arguments, expected filename and optional size");
    }
    return nullptr;
}//function Image_readPreview

Image_readPreviewSmooth()

PyObject* Image_readPreviewSmooth	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 485 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);

    if (self != nullptr)
    {
        PyObject *input = nullptr;
        int x;
        if (PyArg_ParseTuple(args, "Oi", &input, &x))
        {
            try
            {

              PyObject *pyStr;
              if ((pyStr = PyObject_Str(input)) != nullptr)
              {
                self->image->readPreviewSmooth(PyUnicode_AsUTF8(pyStr), x);
                Py_RETURN_NONE;
              }
              else
              {
                  PyErr_SetString(PyExc_TypeError,
                                  "Image_readPreviewSmooth: Expected string or FileName as first argument");
              }
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
            }
        }
    }
    return nullptr;
}//function Image_readPreviewSmooth

Image_repr()

PyObject* Image_repr

(

PyObject *

obj

)

Definition at line 269 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    String s;
    self->image->toString(s);
    return PyUnicode_FromString(s.c_str());
}//function Image_repr

Image_resetOrigin()

PyObject* Image_resetOrigin	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1050 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    if (self != nullptr)
    {
        try
        {
            self->image->data->im->resetOrigin();
            Py_RETURN_NONE; 
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_getDimensions

Image_resize()

PyObject* Image_resize	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 807 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    int xDim = 0;
    int yDim = 0;
    int zDim = 1;
    size_t nDim = 1;

    if (self != nullptr && PyArg_ParseTuple(args, "ii|in", &xDim, &yDim, &zDim, &nDim))
    {
        try
        {
            self->image->resize(xDim, yDim, zDim, nDim, false); // TODO: Take care of copy mode if needed
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_resize

Image_reslice()

PyObject* Image_reslice	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 862 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    int axis = VIEW_Z_NEG;

    if (self != nullptr && PyArg_ParseTuple(args, "i", &axis))
    {
        try
        {
            self->image->reslice((AxisView) axis);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_reslice

Image_RichCompareBool()

PyObject* Image_RichCompareBool	(	PyObject *	obj,
		PyObject *	obj2,
		int	opid
	)

Definition at line 279 of file python_image.cpp.

{
    if (obj != nullptr && obj2 != nullptr)
    {
        try
        {
            if (opid == Py_EQ)
                {
                    if (Image_Value(obj) == Image_Value(obj2))
                        Py_RETURN_TRUE;
                    else
                       Py_RETURN_FALSE;
                }
            else if  (opid == Py_NE)
                    {
                        if (Image_Value(obj) == Image_Value(obj2))
                            Py_RETURN_FALSE;
                        else
                           Py_RETURN_TRUE;
                    }
            else
                return Py_NotImplemented;

        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_compare

Image_scale()

PyObject* Image_scale	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 832 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    int xDim = 0;
    int yDim = 0;
    int zDim = 1;
    int forceVolume=0;
    if (self != nullptr && PyArg_ParseTuple(args, "ii|ii", &xDim, &yDim, &zDim, &forceVolume))
    {
        try
        {
            MultidimArrayGeneric& I=MULTIDIM_ARRAY_GENERIC(Image_Value(self));
            I.setXmippOrigin();
            size_t xdim, ydim, zdim, ndim;
            I.getDimensions(xdim, ydim, zdim, ndim);
            if (forceVolume && zdim==1 && ndim>1)
               I.setDimensions(xdim,ydim,ndim,1);
            selfScaleToSize(xmipp_transformation::LINEAR, I, xDim, yDim, zDim);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_scale

Image_setData()

PyObject* Image_setData	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 644 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    PyArrayObject * arr = nullptr;

    if (self != nullptr && PyArg_ParseTuple(args, "O", &arr))
    {
        try
        {
            ImageGeneric & image = Image_Value(self);
            DataType dt = npyType2Datatype(PyArray_TYPE(arr));
            int nd = PyArray_NDIM(arr);
            //Setup of image
            image.setDatatype(dt);
            ArrayDim adim;
            adim.ndim = (nd == 4 ) ? PyArray_DIM(arr, 0) : 1;
            adim.zdim = (nd > 2 ) ? PyArray_DIM(arr, nd - 3) : 1;
            adim.ydim = PyArray_DIM(arr, nd - 2);
            adim.xdim = PyArray_DIM(arr, nd - 1);

            MULTIDIM_ARRAY_GENERIC(image).resize(adim, false);
            void *mymem = image().getArrayPointer();
            void * data = PyArray_DATA(arr);
            memcpy(mymem, data, adim.nzyxdim * gettypesize(dt));
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_setData

Image_setDataType()

PyObject* Image_setDataType	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 981 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    int datatype;

    if (self != nullptr && PyArg_ParseTuple(args, "i", &datatype))
    {
        try
        {
            self->image->setDatatype((DataType)datatype);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_setDataType

Image_setHeaderValue()

PyObject* Image_setHeaderValue	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1183 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);

    int label;
    PyObject *pyValue; //Only used to skip label and value

    if (self != nullptr && PyArg_ParseTuple(args, "iO", &label, &pyValue))
    {
        try
        {
            MDRow &mainHeader = *(self->image->image->MD[0]);

            auto object = createMDObject(label, pyValue);
            if (!object)
                return nullptr;
            mainHeader.setValue(*object);
            Py_RETURN_TRUE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

Image_setMainHeaderValue()

PyObject* Image_setMainHeaderValue	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1125 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);

    int label;
    PyObject *pyValue; //Only used to skip label and value

    if (self != nullptr && PyArg_ParseTuple(args, "iO", &label, &pyValue))
    {
        try
        {
            MDRow &mainHeader = self->image->image->MDMainHeader;

            auto object = createMDObject(label, pyValue);
            if (!object)
                return nullptr;
            mainHeader.setValue(*object);
            Py_RETURN_TRUE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

Image_setPixel()

PyObject* Image_setPixel	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 710 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    int i;
    int j;
    int k;
    int n;
    double value = -1;

    if (self != nullptr && PyArg_ParseTuple(args, "iiiid", &n, &k, &i, &j, &value))
    {
        try
        {
            if (n==0 && k==0)
                self->image->setPixel(i, j, value);
            else
                self->image->setPixel(n, k, i, j, value);

            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}//function Image_setPixel

Image_subtract()

PyObject* Image_subtract	(	PyObject *	obj1,
		PyObject *	obj2
	)

Definition at line 1451 of file python_image.cpp.

{
    ImageObject * result = (ImageObject*)PyObject_CallFunction((PyObject*)&ImageType, "");
    if (result != nullptr)
    {
        try
        {
            result->image = std::make_unique<ImageGeneric>(Image_Value(obj1));
            Image_Value(result).subtract(Image_Value(obj2));
        }
        catch (XmippError &xe)
        {
            result = nullptr;
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return (PyObject *)result;
}//operator -

Image_true_divide()

PyObject* Image_true_divide	(	PyObject *	obj1,
		PyObject *	obj2
	)

Definition at line 1591 of file python_image.cpp.

{
    std::cerr << "TODO: not working Image_divide_____________________________" << std::endl;
    ImageObject * result = (ImageObject*)PyObject_CallFunction((PyObject*)&ImageType, "");
    if (result != nullptr)
    {
        try
        {
            result->image = std::make_unique<ImageGeneric>(Image_Value(obj1));
            double value = PyFloat_AsDouble(obj2);
            Image_Value(result).divide(value);
        }
        catch (XmippError &xe)
        {
            result = nullptr;
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return (PyObject *)result;
}//operator /

Image_warpAffine()

PyObject* Image_warpAffine	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Image inplace subtraction, equivalent to -= operator

Definition at line 1786 of file python_image.cpp.

{

    PyObject * list = nullptr;
    PyObject * item = nullptr;
    PyObject * dsize = nullptr;
    PyObject * wrap = Py_True;
    PyObject * border_value = nullptr;

    const auto *self = reinterpret_cast<ImageObject*>(obj);
    auto &image = self->image;
    double doubleBorder_value = 1.0;
    size_t Xdim;
    size_t Ydim;
    size_t Zdim;
    bool doWrap = true;
    image->getDimensions(Xdim, Ydim, Zdim);
    try
    {
        PyArg_ParseTuple(args, "O|OOO", &list, &dsize, &wrap, &border_value);
        if (PyList_Check(list))
        {
            if (nullptr != dsize)
            {
                Ydim = PyLong_AsSsize_t(PyTuple_GetItem(dsize, 0));
                Xdim = PyLong_AsSsize_t(PyTuple_GetItem(dsize, 1));
            }
            if (PyBool_Check(wrap))
                doWrap = (wrap == Py_True);
            else
                PyErr_SetString(PyExc_TypeError, "ImageGeneric::warpAffine: Expecting boolean value for wrapping");
            if (border_value!=nullptr)
                doubleBorder_value = PyFloat_AsDouble(border_value);

            size_t size = PyList_Size(list);
            Matrix2D<double> A;
            A.initIdentity(3);
            for (size_t i = 0; i < size; ++i)
            {
                item  = PyList_GetItem(list, i);
                MAT_ELEM(A,i/3,i%3 ) = PyFloat_AsDouble(item);
            }

            image->convert2Datatype(DT_Double);
            MultidimArray<double> *in;
            MULTIDIM_ARRAY_GENERIC(*image).getMultidimArrayPointer(in);
            in->setXmippOrigin();

            ImageObject *result = (ImageObject*)PyObject_CallFunction((PyObject*)&ImageType, "");
            result->image = std::make_unique<ImageGeneric>(DT_Double);
            MultidimArray<double> *out;
            MULTIDIM_ARRAY_GENERIC(*result->image).getMultidimArrayPointer(out);
            out->resize(Ydim,Xdim);
            out->initConstant(doubleBorder_value);
            out->setXmippOrigin();

            applyGeometry(3, *out, *in, A, false, doWrap, doubleBorder_value);
            return (PyObject *)result;
        }
        else
        {
            PyErr_SetString(PyExc_TypeError, "ImageGeneric::warpAffine: Expecting a list");

        }
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}

Image_window2D()

PyObject* Image_window2D	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1902 of file python_image.cpp.

{
    ImageObject *self = (ImageObject*) obj;

    if (self != nullptr)
    {
        try {
            int x0;
            int y0;
            int xF;
            int yF;
            ImageObject *result = (ImageObject*)PyObject_CallFunction((PyObject*)&ImageType, "");

            if (PyArg_ParseTuple(args, "|IIII", &x0, &y0, &xF, &yF)
                    && (nullptr != result)) {
                // prepare input image
                const auto& image = self->image;
                image->convert2Datatype(DT_Double);
                MultidimArray<double> *pImage_in;
                MULTIDIM_ARRAY_GENERIC(*image).getMultidimArrayPointer(pImage_in);
                // prepare output image
                result->image = std::make_unique<ImageGeneric>(DT_Double);
                MultidimArray<double> *pImage_out;
                MULTIDIM_ARRAY_GENERIC(*result->image).getMultidimArrayPointer(pImage_out);
                // call the estimation
                window2D(*pImage_in, *pImage_out, (size_t)y0, (size_t)x0, (size_t)yF, (size_t)xF);

            } else {
                PyErr_SetString(PyXmippError, "Unknown error while allocating data for output or parsing data");
            }
            return (PyObject *)result;
        } catch (XmippError &xe) {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

Image_write()

PyObject* Image_write	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 340 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    if (self != nullptr)
    {
        PyObject *input = nullptr;
        if (PyArg_ParseTuple(args, "O", &input))
        {
            try
            {
              PyObject *pyStr;
              // If the input object is a tuple, consider it (index, filename)
              if (PyTuple_Check(input))
              {
                // Get the index and filename from the Python tuple object
                size_t index = PyLong_AsSsize_t(PyTuple_GetItem(input, 0));
                PyObject* repr = PyObject_Str(PyTuple_GetItem(input, 1));
                const char * filename = PyUnicode_AsUTF8(repr);
                // Now read using both of index and filename
                bool isStack = (index > 0);
                WriteMode writeMode = isStack ? WRITE_REPLACE : WRITE_OVERWRITE;
                self->image->write(filename, index, isStack, writeMode);

                Py_RETURN_NONE;
              }
              if ((pyStr = PyObject_Str(input)) != nullptr)
              {
                  const char * filename = PyUnicode_AsUTF8(pyStr);
                  self->image->write(filename);
                  Py_RETURN_NONE;
              }
              else
              {
                  PyErr_SetString(PyExc_TypeError,
                                  "Image_write: Expected an string or FileName as first argument");
              }
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
            }
        }
    }
    return nullptr;
}//function Image_write

Image_writeSlices()

PyObject* Image_writeSlices	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 884 of file python_image.cpp.

{
    const auto *self = reinterpret_cast<ImageObject*>(obj);
    if (self != nullptr)
    {
        PyObject *oRootname = nullptr;
        PyObject *oExt = nullptr;
        PyObject *oAxis = nullptr;
        if (PyArg_ParseTuple(args, "OOO", &oRootname, &oExt, &oAxis))
        {
            try
            {
                // Get the index and filename from the Python tuple object
                const char * rootname = PyUnicode_AsUTF8(PyObject_Str(oRootname));
                const char * ext = PyUnicode_AsUTF8(PyObject_Str(oExt));
                const char * axis = PyUnicode_AsUTF8(PyObject_Str(oAxis));
                // Now read using both of index and filename

                ImageGeneric Iout;
                Iout.setDatatype(self->image->getDatatype());

                size_t xdim;
                size_t ydim;
                size_t zdim;
                size_t ndim;
                MULTIDIM_ARRAY_GENERIC(*(self->image)).getDimensions(xdim, ydim, zdim, ndim);
                size_t N=zdim;
                char caxis=axis[0];
                if (caxis=='Y')
                    N=ydim;
                else if (caxis=='X')
                    N=xdim;
                for (size_t n=0; n<N; n++)
                {
                    MULTIDIM_ARRAY_GENERIC(*(self->image)).getSlice(n,&MULTIDIM_ARRAY_GENERIC(Iout),caxis);
                    Iout.write(formatString("%s_%04d.%s",rootname,n,ext));
                }
                Py_RETURN_NONE;
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
            }
        }
    }
    return nullptr;

}//function writeSlices

npyType2Datatype()

DataType npyType2Datatype

(

int

npy

)

Definition at line 553 of file python_image.cpp.

{
    switch (npy)
    {
    case NPY_FLOAT:
        return DT_Float;
    case NPY_DOUBLE:
        return DT_Double;
    case NPY_INT:
        return DT_Int;
    case NPY_UINT:
        return DT_UInt;
    case NPY_SHORT:
        return DT_Short;
    case NPY_USHORT:
        return DT_UShort;
    case NPY_BYTE:
        return DT_SChar;
    case NPY_UBYTE:
        return DT_UChar;
    case NPY_BOOL:
        return DT_Bool;
    case NPY_CFLOAT:
        return DT_CFloat;
    case NPY_CDOUBLE:
        return DT_CDouble;
    case NPY_HALF:
        return DT_HalfFloat;
    default:
        return DT_Unknown;
    }
}

Variable Documentation

Image_methods

PyMethodDef Image_methods[]

Definition at line 64 of file python_image.cpp.

Image_NumberMethods

PyNumberMethods Image_NumberMethods

Definition at line 40 of file python_image.cpp.

ImageType

PyTypeObject ImageType

Definition at line 163 of file python_image.cpp.

PyXmippError

PyObject* PyXmippError

Definition at line 47 of file xmippmodule.cpp.