Micrograph Downsample

Collaboration diagram for Micrograph Downsample:

Classes
class	ProgTransformDownsample

Functions
void	downsampleKernel (const ImageGeneric &M, double step, ImageGeneric &Mp)
void	downsampleFourier (const ImageGeneric &M, double step, ImageGeneric &Mp, int nThreads)
void	downsampleSmooth (const ImageGeneric &M, ImageGeneric &Mp)

Detailed Description

Function Documentation

downsampleFourier()

void downsampleFourier	(	const ImageGeneric &	M,
		double	step,
		ImageGeneric &	Mp,
		int	nThreads
	)

Downsample a micrograph in Fourier space. The input and output micrographs must be already open.

Definition at line 202 of file transform_downsample.cpp.

{
    size_t Ydim, Xdim, Ypdim, Xpdim;
    M().getDimensions(Xdim, Ydim);
    Mp().getDimensions(Xpdim, Ypdim);

    // Read the micrograph in memory as doubles
    MultidimArray<double> Mmem;
    Mmem.setMmap(true);
    Mmem.resizeNoCopy(Ydim,Xdim);
    MultidimArray<std::complex<double> > MmemFourier;
    M().getImage(Mmem);

    // Perform the Fourier transform
    FourierTransformer transformerM;
    transformerM.setThreadsNumber(nThreads);
    transformerM.FourierTransform(Mmem, MmemFourier, false);

    // Create space for the downsampled image and its Fourier transform
    MultidimArray<double> Mpmem(Ypdim,Xpdim);
    MultidimArray<std::complex<double> > MpmemFourier;
    FourierTransformer transformerMp;
    transformerMp.setThreadsNumber(nThreads);
    transformerMp.setReal(Mpmem);
    transformerMp.getFourierAlias(MpmemFourier);

    int ihalf=YSIZE(MpmemFourier)/2+1;
    for (int i=0; i<ihalf; i++)
        for (size_t j=0; j<XSIZE(MpmemFourier); j++)
            A2D_ELEM(MpmemFourier,i,j)=A2D_ELEM(MmemFourier,i,j);
    for (size_t i=ihalf; i<YSIZE(MpmemFourier); i++)
    {
        size_t ip=YSIZE(MmemFourier)-YSIZE(MpmemFourier)+i;
        for (size_t j=0; j<XSIZE(MpmemFourier); j++)
            A2D_ELEM(MpmemFourier,i,j)=A2D_ELEM(MmemFourier,ip,j);
    }

    // Transform data
    transformerMp.inverseFourierTransform();

    // Find minimun and range in output data
    double omin=0.,omax=0.;
    Mpmem.computeDoubleMinMax(omin,omax);
    double orange = omax - omin;
    double a = (pow(2.0, Mp.getDatatypeDepth()) - 1.0) / orange;
    double b = -omin;
    double scale=1;
    if (M.getDatatype() != DT_Float)
        scale = (pow(2.0, Mp.getDatatypeDepth()) - 1.0) /
                (pow(2.0, M.getDatatypeDepth()) - 1.0);
    else if (M.getDatatype() == DT_Float)
        scale = 1;

    // Copy back data
    if (Mp.datatype!=DT_Float)
        FOR_ALL_ELEMENTS_IN_ARRAY2D(Mpmem)
        Mp.setPixel(i, j, a*(A2D_ELEM(Mpmem,i,j)*scale + b));
    else
        FOR_ALL_ELEMENTS_IN_ARRAY2D(Mpmem)
        Mp.setPixel(i, j, A2D_ELEM(Mpmem,i,j));
}

downsampleKernel()

void downsampleKernel	(	const ImageGeneric &	M,
		double	step,
		ImageGeneric &	Mp
	)

Downsample a micrograph using a rectangular kernel. The input and output micrographs must be already open.

Definition at line 114 of file transform_downsample.cpp.

{
    auto istep=(int)step;
    MultidimArray<double> kernel;
    kernel.resizeNoCopy(istep,istep);
    kernel.initConstant(1.0/MULTIDIM_SIZE(kernel));

    size_t Ydim, Xdim, Ypdim, Xpdim;
    M().getDimensions(Xdim, Ydim);
    Mp().getDimensions(Xpdim, Ypdim);

    // Look for input/output ranges
    double a = 1;
    double b = 0;
    double scale = 1;
    size_t ii, jj, i2, j2, i, j, y, x;
    if (Mp.getDatatype() != DT_Float)
    {
        double imin, imax;
        double omin=0., omax=0.;
        imin=imax=M.getPixel(0,0);
        bool ofirst = true;

        if (M.getDatatype() != DT_Float)
            scale = (pow(2.0, Mp.getDatatypeDepth()) - 1.0) /
                    (pow(2.0, M.getDatatypeDepth()) - 1.0);
        else if (M.getDatatype() == DT_Float)
            scale = 1;
        for (ii = 0, y = 0; y < Ydim && ii < Ypdim; y += istep, ++ii)
            for (jj = 0, x = 0; x < Xdim && jj < Xpdim; x += istep, ++jj)
            {
                double pixval = 0;
                for (i=0, i2=y; i<YSIZE(kernel) && i2<Ydim; ++i, ++i2)
                    for (j=0, j2=x; j<XSIZE(kernel) && j2<Xdim; ++j, ++j2)
                    {
                        double aux=M.getPixel(i2, j2);
                        imin = XMIPP_MIN(imin, aux);
                        imax = XMIPP_MAX(imax, aux);
                        pixval += A2D_ELEM(kernel,i, j) * aux;
                    }
                pixval *= scale;
                if (ofirst)
                {
                    omin = omax = pixval;
                    ofirst = false;
                }
                else
                {
                    omin = XMIPP_MIN(omin, pixval);
                    omax = XMIPP_MAX(omax, pixval);
                }
            }

        // Compute range transformation
        double irange = imax - imin;
        double orange = omax - omin;

        if (M.getDatatype() != DT_Float)
        {
            a = scale * irange / orange;
            b = -omin;
        }
        else if (Mp.getDatatype() != DT_Float)
        {
            a = (pow(2.0, Mp.getDatatypeDepth()) - 1.0) / orange;
            scale = 1;
            b = -omin;
        }
    }

    // Really downsample
    for (ii = 0, y = 0; y < Ydim && ii < Ypdim; y += istep, ++ii)
        for (jj = 0, x = 0; x < Xdim && jj < Xpdim; x += istep, ++jj)
        {
            double pixval = 0;
            for (i=0, i2=y; i<YSIZE(kernel) && i2<Ydim; ++i, ++i2)
                for (j=0, j2=x; j<XSIZE(kernel)&& j2<Xdim; ++j, ++j2)
                    pixval += A2D_ELEM(kernel,i, j) * M.getPixel(i2, j2);
            if (ii < Ypdim && jj < Xpdim)
            {
                if (Mp.datatype != DT_Float)
                    Mp.setPixel(ii, jj, floor(a*(pixval*scale + b)));
                else
                    Mp.setPixel(ii, jj, pixval);
            }
        }
}

downsampleSmooth()

void downsampleSmooth	(	const ImageGeneric &	M,
		ImageGeneric &	Mp
	)

Downsample a micrograph using smooth and color dithering. The input and output micrographs must be already open.

Definition at line 264 of file transform_downsample.cpp.

{
    if (Mp.datatype!=DT_UChar)
        REPORT_ERROR(ERR_ARG_INCORRECT,formatString("Smooth downsampling is only valid for 8 bit images. \n"
                "Choose a supporting 8bit file format different from %s",Mp.image->name().c_str()));

    size_t Ydim, Xdim, Ypdim, Xpdim;
    M().getDimensions(Xdim, Ydim);
    Mp().getDimensions(Xpdim, Ypdim);
    byte *inputImage=nullptr;
    MultidimArray<unsigned char> Maux;
    if (M.datatype==DT_UChar)
        M().getArrayPointer(inputImage);
    else
    {
        Maux.setMmap(true);
        M().getImage(Maux);
        inputImage=MULTIDIM_ARRAY(Maux);
    }
    unsigned char *outputImage;
    Mp().getArrayPointer(outputImage);
    SmoothResize(inputImage,outputImage, Xdim, Ydim, Xpdim, Ypdim);
}