Mathematical operations of images and volumes

Collaboration diagram for Mathematical operations of images and volumes:

Classes
class	ProgOperate

Functions
void	ProgOperate::defineParams ()
	Define parameters. More...
void	ProgOperate::readParams ()
	Read input parameters. More...
void	ProgOperate::processImage (const FileName &fnImg, const FileName &fnImgOut, const MDRow &rowIn, MDRow &rowOut)
	Process one image. More...

Image operation procedures
typedef void	ImageBinaryOperator(Image< double > &op1, const Image< double > &op2)
typedef void	ImageUnaryOperator(Image< double > &op)
void	radialAvg (Image< double > &op)

Detailed Description

Typedef Documentation

ImageBinaryOperator

typedef void ImageBinaryOperator(Image< double > &op1, const Image< double > &op2)

This define the prototype of binary operations on images the result will be left in op1

Definition at line 46 of file image_operate.h.

ImageUnaryOperator

typedef void ImageUnaryOperator(Image< double > &op)

This define the prototype of unary operations on images the result will be left in op

Definition at line 50 of file image_operate.h.

Function Documentation

defineParams()

void ProgOperate::defineParams ( )

protectedvirtual

Define parameters.

Reimplemented from XmippMetadataProgram.

Reimplemented in BasicMpiMetadataProgram< ProgOperate >.

Definition at line 314 of file image_operate.cpp.

{
    each_image_produces_an_output = true;
    save_metadata_stack = true;
    keep_input_columns = true;
    addUsageLine("A simple Xmipp images calculator. Binary and unary operations");
    XmippMetadataProgram::defineParams();
    addParamsLine("== Binary operations: ==");
    addParamsLine("   --plus <file_or_value>    :Sums two images, volumes or adds a numerical value to an image");
    addParamsLine("or --minus <file_or_value>   :Subtracts two images, volumes or subtracts a numerical value to an image");
    addParamsLine("or --minusAdjusted <file> :Subtracts two sets of images adjusting the gray values so that error is minimized");
    addParamsLine("                             : If you are comparing a set of noisy and clean images, put the noisy images in -i");
    addParamsLine("or --mult <file_or_value>    :Multiplies two images, volumes, or multiplies per a given number");
    addParamsLine("or --divide <file_or_value>  :Divides two images, volumes, or divides per a given number");
    addParamsLine("or --min <file_or_value>     :Minimum of two images, volumes, or number (pixel-wise)");
    addParamsLine("or --max <file_or_value>     :Maximum of two images, volumes, or number (pixel-wise)");
    addParamsLine("or --compare <file_or_value> :Returns -1 if the left value is less, 0 if are equal or 1 if greater.(pixel-wise)");
    addParamsLine("or --dot_product <file>      :Dot product between two images or volumes");
    addParamsLine("or --dropout <p>             :Set to 0.0 the values of the input with probability p");
    addParamsLine("==+ Relational operations: ==");
    addParamsLine("or --eq <file_or_value>      :Returns 1 if the pixels values are equal, 0 otherwise (pixel-wise)");
    addParamsLine("or --le <file_or_value>      :Returns 1 if the pixels values are less or equal, 0 otherwise (pixel-wise)");
    addParamsLine("or --lt <file_or_value>      :Returns 1 if the pixels values are less than, 0 otherwise (pixel-wise)");
    addParamsLine("or --ge <file_or_value>      :Returns 1 if the pixels values are greater or equal, 0 otherwise (pixel-wise)");
    addParamsLine("or --gt <file_or_value>      :Returns 1 if the pixels values are greater, 0 otherwise (pixel-wise)");
    addParamsLine("or --ne <file_or_value>      :Returns 1 if the pixels values are not equal, 0 otherwise (pixel-wise)");

    addParamsLine("== Unary operations: ==");
    addParamsLine("or --log                     :Computes the natural logarithm of an image");
    addParamsLine("or --log10                   :Computes the decimal logarithm of an image");
    addParamsLine("or --sqrt                    :Computes the square root of an image");
    addParamsLine("or --abs                     :Computes the absolute value of an image");
    addParamsLine("or --pow <value=2>           :Computes the power of an image");
    addParamsLine("or --slice  <value>          :Extracts a given slice from a volume (first slice=0)");
    addParamsLine("or --column <value>          :Extracts a given column from a image or volume");
    addParamsLine("or --row    <value>          :Extracts a given row from a image or volume");
    addParamsLine("or --radial_avg              :Compute the radial average of an image");
    addParamsLine("or --psd_radial_avg          :Compute the radial average of an image");
    addParamsLine("or --reset                   :Set the image to 0");

    addExampleLine("Sum two volumes and save result", false);
    addExampleLine("xmipp_image_operate -i volume1.vol --plus volume2.vol -o result.vol");
    addExampleLine("Calculate the log10 of an image called example.xmp and store the resulting one in example_log.xmp", false);
    addExampleLine("xmipp_image_operate -i example.xmp --log10 -o example_log.xmp");
    addExampleLine("Calculate the square root of a volume called example.vol and store it in expample_sq.vol", false);
    addExampleLine("xmipp_image_operate -i example.vol --sqrt  -o expample_sq.vol");
    addExampleLine("Extract the slice number 10 of a set of of volumes given in the sel file called volumes.sel. The names of the output images its supposed to be in the selfile images.sel", false);
    addExampleLine("xmipp_image_operate -i volumes.sel --slice 10 -o images.sel");
    addExampleLine("Sum 5 to every image in images.sel and rewrite the input images", false);
    addExampleLine("xmipp_image_operate -i images.sel --plus 5");
    addExampleLine("Subtract two volumes:", false);
    addExampleLine("xmipp_image_operate -i volume1.vol --minus volume2.vol -o volume3.vol");
    addExampleLine("Multiply an image by 2 in every pixel:", false);
    addExampleLine("xmipp_image_operate -i image.xmp --mult 2 -o image2.xmp");
    addExampleLine("Divide 2 by the value of every pixel in the image:", false);
    addExampleLine("xmipp_image_operate -i 2 -divide image.xmp -o image2.xmp");
    addExampleLine(" Rotational average", false);
    addExampleLine("xmipp_image_operate -i image.xmp --radial_avg -o radial_avg.xmp");
    addExampleLine("where radial_avg.txt is an ascii file for plotting the radial_averaged profile, radial_avg.xmp a radial_averaged image", false);
    addExampleLine("xmipp_image_operate -i micrograph.psd --psd_radial_avg -o radial_psd.xmp");
    addExampleLine("where radial_psd.txt is an ascii file for plotting the radial_averaged profile, radial_psd.xmp a radial_averaged image", false);
}

processImage()

void ProgOperate::processImage ( const FileName &  fnImg, const FileName &  fnImgOut, const MDRow &  rowIn, MDRow &  rowOut  )

protectedvirtual

Process one image.

Implements XmippMetadataProgram.

Definition at line 565 of file image_operate.cpp.

{
    Image<double> img;
    img.readApplyGeo(fnImg, rowIn);

    if (unaryOperator != nullptr)
        unaryOperator(img);
    else
    {
        if (!isValue)
        {
            img2.readApplyGeo(md2, **md2IdIterator);
            ++(*md2IdIterator);
        }
        binaryOperator(img, img2);
    }
    img.write(fnImgOut);
}

radialAvg()

void radialAvg

(

Image< double > &

op

)

Substitute op by its radial average

Definition at line 269 of file image_operate.cpp.

{
    MultidimArray<double> &mOp = op();
    mOp.setXmippOrigin();
    Matrix1D<int> center(3);
    center.initZeros();
    MultidimArray<double> radial_mean;
    MultidimArray<int> radial_count;
    radialAverage(mOp, center, radial_mean, radial_count);
    radial_mean.write((fnOut.withoutExtension()).addExtension("txt"));

    int my_rad;
    FOR_ALL_ELEMENTS_IN_ARRAY3D(mOp)
    {
        my_rad = (int)floor(sqrt((double)(i * i + j * j + k * k)));
        op(k, i, j) = radial_mean(my_rad);
    }
}

readParams()

void ProgOperate::readParams ( )

protectedvirtual

Read input parameters.

Relational operations

Unary operations

Reimplemented from XmippMetadataProgram.

Reimplemented in BasicMpiMetadataProgram< ProgOperate >.

Definition at line 377 of file image_operate.cpp.

{
    XmippMetadataProgram::readParams();
    binaryOperator = nullptr;
    unaryOperator = nullptr;
    isValue = false;
    // Check operation to do
    //Binary operations
    if (checkParam("--plus"))
    {
        file_or_value = getParam("--plus");
        binaryOperator = plus;
    }
    else if (checkParam("--minus"))
    {
        file_or_value = getParam("--minus");
        binaryOperator = minus;
    }
    else if (checkParam("--minusAdjusted"))
    {
        file_or_value = getParam("--minusAdjusted");
        binaryOperator = minusAdjusted;
    }
    else if (checkParam("--mult"))
    {
        file_or_value = getParam("--mult");
        binaryOperator = mult;
    }
    else if (checkParam("--divide"))
    {
        file_or_value = getParam("--divide");
        binaryOperator = divide;
    }
    else if (checkParam("--max"))
    {
        file_or_value = getParam("--max");
        binaryOperator = max;
    }
    else if (checkParam("--min"))
    {
        file_or_value = getParam("--min");
        binaryOperator = min;
    }
    else if (checkParam("--compare"))
    {
        file_or_value = getParam("--compare");
        binaryOperator = compare;
    }
    else if (checkParam("--dot_product"))
    {
        file_or_value = getParam("--dot_product");
        binaryOperator = imageDotProduct;
    }
    else if (checkParam("--dropout"))
    {
        pDropout = getDoubleParam("--dropout");
        unaryOperator = dropOut;
    }
    else if (checkParam("--eq"))
    {
        file_or_value = getParam("--eq");
        binaryOperator = eq;
    }
    else if (checkParam("--ne"))
    {
        file_or_value = getParam("--ne");
        binaryOperator = ne;
    }
    else if (checkParam("--lt"))
    {
        file_or_value = getParam("--lt");
        binaryOperator = lt;
    }
    else if (checkParam("--le"))
    {
        file_or_value = getParam("--le");
        binaryOperator = le;
    }
    else if (checkParam("--gt"))
    {
        file_or_value = getParam("--gt");
        binaryOperator = gt;
    }
    else if (checkParam("--ge"))
    {
        file_or_value = getParam("--ge");
        binaryOperator = ge;
    }
    else if (checkParam("--log10"))
        unaryOperator = log10;
    else if (checkParam("--sqrt"))
        unaryOperator = sqrt;
    else if (checkParam("--abs"))
        unaryOperator = abs;
    else if (checkParam("--pow"))
    {
        powerExp = getDoubleParam("--pow");
        unaryOperator = power;
    }
    else if (checkParam("--slice"))
    {
        axis = 'Z';
        nSlice = getIntParam("--slice");
        unaryOperator = getSlice;
    }
    else if (checkParam("--column"))
    {
        axis = 'X';
        nSlice = getIntParam("--column");
        unaryOperator = getSlice;
    }
    else if (checkParam("--row"))
    {
        axis = 'Y';
        nSlice = getIntParam("--row");
        unaryOperator = getSlice;
    }
    else if (checkParam("--radial_avg"))
    {
        fnOut = fn_out;
        unaryOperator = radialAvg;
    }
    else if (checkParam("--psd_radial_avg"))
    {
        fnOut = fn_out;
        unaryOperator = psdRadialAvg;
    }
    else if (checkParam("--reset"))
    {
        fnOut = fn_out;
        unaryOperator = reset;
    }
    else if (checkParam("--log"))
        unaryOperator = log;
    else if (checkParam("--log10"))
        unaryOperator = log10;
    else
    {
        doRun = false;
        REPORT_ERROR(ERR_VALUE_INCORRECT, "No valid operation specified");
    }
    int dotProduct = false;
    if (binaryOperator != nullptr)
    {
        if (!file_or_value.exists())
        {
            isValue = true;
            try {
                value = textToFloat(file_or_value);
            } catch (XmippError &XE)
            {
                doRun = false;
                REPORT_ERROR(ERR_ARG_INCORRECT, (String)"Cannot understand "+file_or_value+". Either it is not a number or it is a non-existing file.");
            }
            img2().resizeNoCopy(zdimOut, ydimOut, xdimOut);
            img2().initConstant(value);
        }
        else
        {
            dotProduct = true;
            isValue = false;
            fn2 = file_or_value;
            md2.read(fn2);
            if (md2.isMetadataFile || md2.size() > 1)
            {
                if (mdInSize != md2.size())
                {
                    doRun = false;
                    REPORT_ERROR(ERR_MD, "Both metadatas operands should be of same size.");
                }
                md2IdIterator = memoryUtils::make_unique<MetaDataVec::id_iterator>(md2.ids().begin());
            }
            else
            {
                isValue = true;
                img2.read(fn2);
            }
        }
        if (!dotProduct && checkParam("--dot_product"))
        {
            doRun = false;
            REPORT_ERROR(ERR_ARG_INCORRECT,"Dot product can only be computed between two files");
        }
    }
}