ProgConvImg Class Reference

#include <xmipp_image_convert.h>

Inheritance diagram for ProgConvImg:

Collaboration diagram for ProgConvImg:

Public Member Functions
	ProgConvImg ()
virtual	~ProgConvImg ()
void	setType (const String &sType)
Public Member Functions inherited from XmippMetadataProgram
MetaData *	getInputMd ()
MetaDataVec &	getOutputMd ()
	XmippMetadataProgram ()
	Empty constructor. More...
virtual int	tryRead (int argc, const char **argv, bool reportErrors=true)
virtual void	setup (MetaData *md, const FileName &o="", const FileName &oroot="", bool applyGeo=false, MDLabel label=MDL_IMAGE)
virtual	~XmippMetadataProgram ()
void	setMode (WriteModeMetaData _mode)
void	setupRowOut (const FileName &fnImgIn, const MDRow &rowIn, const FileName &fnImgOut, MDRow &rowOut) const
	Prepare rowout. More...
virtual void	wait ()
	Wait for the distributor to finish. More...
virtual void	checkPoint ()
	For very long programs, it may be needed to write checkpoints. More...
virtual void	run ()
	Run over all images. More...
Public Member Functions inherited from XmippProgram
const char *	getParam (const char *param, int arg=0)
const char *	getParam (const char *param, const char *subparam, int arg=0)
int	getIntParam (const char *param, int arg=0)
int	getIntParam (const char *param, const char *subparam, int arg=0)
double	getDoubleParam (const char *param, int arg=0)
double	getDoubleParam (const char *param, const char *subparam, int arg=0)
float	getFloatParam (const char *param, int arg=0)
float	getFloatParam (const char *param, const char *subparam, int arg=0)
void	getListParam (const char *param, StringVector &list)
int	getCountParam (const char *param)
bool	checkParam (const char *param)
bool	existsParam (const char *param)
void	addParamsLine (const String &line)
void	addParamsLine (const char *line)
ParamDef *	getParamDef (const char *param) const
virtual void	quit (int exit_code=0) const
virtual int	tryRun ()
void	initProgress (size_t total, size_t stepBin=60)
void	setProgress (size_t value=0)
void	endProgress ()
void	processDefaultComment (const char *param, const char *left)
void	setDefaultComment (const char *param, const char *comment)
void	setProgramName (const char *name)
void	addUsageLine (const char *line, bool verbatim=false)
void	clearUsage ()
void	addExampleLine (const char *example, bool verbatim=true)
void	addSeeAlsoLine (const char *seeAlso)
void	addKeywords (const char *keywords)
const char *	name () const
virtual void	usage (int verb=0) const
virtual void	usage (const String &param, int verb=2)
int	version () const
virtual void	read (int argc, const char **argv, bool reportErrors=true)
virtual void	read (int argc, char **argv, bool reportErrors=true)
void	read (const String &argumentsLine)
	XmippProgram ()
	XmippProgram (int argc, const char **argv)
virtual	~XmippProgram ()

Protected Member Functions
void	init ()
void	defineParams ()
void	readParams ()
void	preProcess ()
void	processImage (const FileName &fnImg, const FileName &fnImgOut, const MDRow &rowIn, MDRow &rowOut)
void	finishProcessing ()
void	show ()
Protected Member Functions inherited from XmippMetadataProgram
virtual void	initComments ()
virtual void	postProcess ()
virtual bool	getImageToProcess (size_t &objId, size_t &objIndex)
void	show () const override
virtual void	startProcessing ()
virtual void	writeOutput ()
virtual void	showProgress ()
virtual void	defineLabelParam ()
Protected Member Functions inherited from XmippProgram
void	defineCommons ()

Additional Inherited Members
Public Attributes inherited from XmippMetadataProgram
FileName	fn_in
	Filenames of input and output Metadata. More...
FileName	fn_out
FileName	baseName
FileName	pathBaseName
FileName	oextBaseName
bool	apply_geo
	Apply geo. More...
size_t	ndimOut
	Output dimensions. More...
size_t	zdimOut
size_t	ydimOut
size_t	xdimOut
DataType	datatypeOut
size_t	mdInSize
	Number of input elements. More...
Public Attributes inherited from XmippProgram
bool	doRun
bool	runWithoutArgs
int	verbose
	Verbosity level. More...
int	debug
Protected Attributes inherited from XmippMetadataProgram
WriteModeMetaData	mode
	Metadata writing mode: OVERWRITE, APPEND. More...
FileName	oext
	Output extension and root. More...
FileName	oroot
MDLabel	image_label
	MDLabel to be used to read/write images, usually will be MDL_IMAGE. More...
bool	produces_an_output
	Indicate that a unique final output is produced. More...
bool	produces_a_metadata
	Indicate that the unique final output file is a Metadata. More...
bool	each_image_produces_an_output
	Indicate that an output is produced for each image in the input. More...
bool	allow_apply_geo
bool	decompose_stacks
	Input Metadata will treat a stack file as a set of images instead of a unique file. More...
bool	delete_output_stack
	Delete previous output stack file prior to process images. More...
bool	get_image_info
	Get the input image file dimensions to further operations. More...
bool	save_metadata_stack
	Save the associated output metadata when output file is a stack. More...
bool	track_origin
	Include the original input image filename in the output stack. More...
bool	keep_input_columns
	Keep input metadata columns. More...
bool	remove_disabled
	Remove disabled images from the input selfile. More...
bool	allow_time_bar
	Show process time bar. More...
bool	input_is_metadata
	Input is a metadata. More...
bool	single_image
	Input is a single image. More...
bool	input_is_stack
	Input is a stack. More...
bool	output_is_stack
	Output is a stack. More...
bool	create_empty_stackfile
bool	delete_mdIn
size_t	time_bar_step
	Some time bar related counters. More...
size_t	time_bar_size
size_t	time_bar_done
Protected Attributes inherited from XmippProgram
int	errorCode
ProgramDef *	progDef
	Program definition and arguments parser. More...
std::map< String, CommentList >	defaultComments
int	argc
	Original command line arguments. More...
const char **	argv

Detailed Description

Definition at line 42 of file xmipp_image_convert.h.

Constructor & Destructor Documentation

ProgConvImg()

ProgConvImg::ProgConvImg

(

)

Constructor

Definition at line 30 of file xmipp_image_convert.cpp.

{
    init();
}

~ProgConvImg()

virtual ProgConvImg::~ProgConvImg ( )

inlinevirtual

Definition at line 60 of file xmipp_image_convert.h.

                           {
        if (imOut) {
            delete imOut;
        }
    }

Member Function Documentation

defineParams()

void ProgConvImg::defineParams ( )

protectedvirtual

Function in which the param of each Program are defined.

Reimplemented from XmippMetadataProgram.

Definition at line 55 of file xmipp_image_convert.cpp.

{
    init();
    CommentList &comments = defaultComments["-i"];
    comments.addComment("++ Supported read formats are:");
    comments.addComment("++ dm3 : Digital Micrograph 3");
    comments.addComment("++ em  : Electron Microscopy");
    comments.addComment("++ jpg : JPEG");
    comments.addComment("++ img : Imagic");
    comments.addComment("++ inf,raw : RAW file with header INF file");
    comments.addComment("++ mrc, map : CCP4");
    comments.addComment("++ pif  : Portable Image Format");
    comments.addComment("++ ser : Tecnai Imaging and Analysis");
    comments.addComment("++ spe : Princeton Instruments CCD camera");
    comments.addComment("++ spi, xmp : Spider");
    comments.addComment("++ tif : TIFF");
    comments.addComment("++ raw#xDim,yDim,[zDim],offset,datatype,[r] : RAW image file without header file");
    comments.addComment("++ where datatype can be: uint8,int8,uint16,int16,uint32,int32,long,float,double,");
    comments.addComment("++                        cint16,cint32,cfloat,cdouble,bool");
    XmippMetadataProgram::defineParams();

    addUsageLine("Convert among stacks, volumes and images, and change the file format.");
    addUsageLine("+Conversion to a lower bit_depth automatically adjusts the gray level range. If it is between same bit ");
    addUsageLine("+depths and different sign, then only a histogram shift is done. If parameter --depth is not passed, then ");
    addUsageLine("+bit_depth is automatically chosen equal to or higher than input bit_depth. For stack output format, ");
    addUsageLine("+a selection file with the images in the stack is optionally created, replicating the labels of the input sel file.");
    addUsageLine("+If output file extension is not set when --oroot is used (neither setting --oext nor :ext), then input format is chosen.");
    addKeywords("conversion, convert, image, stack, volume, format, extension ");
    //Parameters
    addParamsLine("  [--oext <extension=\"\">] :  Output file format extension.");
    addParamsLine("    where <extension>");
    addParamsLine("         img : Imagic (Data types: uint8, int16, float* and cfloat).");
    addParamsLine("         inf : RAW file with header INF file (Data types: (u)int8, (u)int16 and float*).");
    addParamsLine("         raw : RAW file with header INF file (Data types: (u)int8, (u)int16 and float*).");
    addParamsLine("         mrc : CCP4 (Data types: uint8, (u)int16, float* and cfloat).");
    addParamsLine("         spi : Spider (Data types: float* and cfloat).");
    addParamsLine("         xmp : Spider (Data types: float* and cfloat).");
    addParamsLine("         tif : TIFF (Data types: uint8*, uint16, uint32 and float).");
    addParamsLine("         jpg : JPEG (Data types: uint8*).");
    addParamsLine("         custom <ext> : Custom extension name, the real format will be Spider.");
    addParamsLine("  [--type <output_type=auto>] : Force output file type.");
    addParamsLine("          where <output_type>");
    addParamsLine("          auto: Autodetect output type according to output extension and whether --oroot is passed or not.");
    addParamsLine("          img : Image");
    addParamsLine("          vol : Volume");
    addParamsLine("          stk : Stack ");
    addParamsLine("  alias -t;");
    addParamsLine("== Bit options == ");
    addParamsLine("  [--depth+ <bit_depth=default>] : Image bit depth.");
    addParamsLine("          where <bit_depth>");
    addParamsLine("                 default: Default selected value (*)");
    addParamsLine("                 uint8 : Equivalent to uchar");
    addParamsLine("                 int8  : Equivalent to char");
    addParamsLine("                 uint16: Equivalent to ushort");
    addParamsLine("                 int16 : Equivalent to short");
    addParamsLine("                 uint32");
    addParamsLine("                 int32");
    addParamsLine("                 long");
    addParamsLine("                 float");
    addParamsLine("                 double");
    addParamsLine("                 cint16 : Complex int16");
    addParamsLine("                 cint32 : Complex int32");
    addParamsLine("                 cfloat : Complex float");
    addParamsLine("                 cdouble: Complex double");
    addParamsLine("                 bool");
    addParamsLine("  alias -d;");
    addParamsLine("  [--swap <type=arch>]        : Swap the endianness of the image file");
    addParamsLine("          where <type>");
    addParamsLine("                arch   : Set the opposite endian of the architecture");
    addParamsLine("                little : Set to little endian");
    addParamsLine("                big    : Set to big endian");

    addParamsLine("  [--range_adjust] : Adjust the histogram to fill the gray level range");
    addParamsLine("  alias -r;");
    addParamsLine("or --dont_convert : Do not apply any conversion to gray levels when writing");
    addParamsLine("                  : in a lower bit depth or changing the sign");
    addParamsLine("== Stack options == ");
    addParamsLine("  [--append]           : Append the input to the output stack instead of overwriting it");
    addParamsLine("  alias -a;");

    //Examples
    addExampleLine("Put a selection file into a stack:",false);
    addExampleLine("xmipp_image_convert -i list.sel -o images.stk");
    addExampleLine("Convert a Spider volume to a MRC stack:",false);
    addExampleLine("xmipp_image_convert -i spider.vol -o stack.mrcs -t stk");
    addExampleLine("Create a stack of volumes with a Spider volume :",false);
    addExampleLine("xmipp_image_convert -i spider.vol -o vol_stack.stk -t vol");
    addExampleLine("Append a volume to a volume stack:",false);
    addExampleLine("xmipp_image_convert -i spider.vol -o vol_stack.stk -a");
    addExampleLine("Substitute a volume in a volume stack:",false);
    addExampleLine("xmipp_image_convert -i spider.vol -o 3@vol_stack.stk");
    addExampleLine("Save images in a stack as independent TIFF files in image directory with \"newimage\" basename in 8bit format:",false);
    addExampleLine("xmipp_image_convert -i stackFile.stk -o tiffImages.sel --oroot images/newimage:tif -d uint8");
    addExampleLine("Convert a selection file of 16bit TIFF images to 8bit and overwrites files and sel file:",false);
    addExampleLine("xmipp_image_convert -i tiff16.sel -d uint8");
    addExampleLine("Append a single image to a stack:",false);
    addExampleLine("xmipp_image_convert -i img.spi -o stackFile.stk --append");
    addExampleLine("Append a selection file to a stack:",false);
    addExampleLine("xmipp_image_convert -i selFile.sel -o stackFile.stk --append");
    addExampleLine("Replace a single image into a stack:",false);
    addExampleLine("xmipp_image_convert -i img.spi -o 3@stackFile.stk");
    addExampleLine("Convert a MRC stack to a MRC volume:",false);
    addExampleLine("xmipp_image_convert -i stack.mrc -o volume.mrc -t vol");
}

finishProcessing()

void ProgConvImg::finishProcessing ( )

protectedvirtual

Reimplemented from XmippMetadataProgram.

Definition at line 341 of file xmipp_image_convert.cpp.

{
    switch(convMode)
    {
    case MD2VOL:
        if (swap)
            imOut->image->swapOnWrite();
        imOut->write();
        single_image = true;
        progress_bar(time_bar_size);
        break;
    default:
        break;
    }

    XmippMetadataProgram::finishProcessing();
}

init()

void ProgConvImg::init ( void  )

protectedvirtual

Initialization of variables should be done here

Reimplemented from XmippMetadataProgram.

Definition at line 35 of file xmipp_image_convert.cpp.

{
    each_image_produces_an_output = true;
    save_metadata_stack = false;
    keep_input_columns = true;
    delete_output_stack = false;

    castMode = CW_CONVERT;
    appendToStack = false;
    // output extension
    oext = "";
    // output type
    type = "auto";
    // Set default write mode
    writeMode = WRITE_OVERWRITE;
    depth = "";
    swap = false;
}

preProcess()

void ProgConvImg::preProcess ( )

protectedvirtual

Reimplemented from XmippMetadataProgram.

Definition at line 197 of file xmipp_image_convert.cpp.

{
    if (type == "auto")
    {
        if (oroot.empty())
        {
            /* It is stack if extension is stack compatible, or if --oroot is not passed
             * and there are more than one image. Same for volumes.
             * Firstly, we must check extensions, then stack and volume sizes.*/
            if (( mdInSize > 1 || zdimOut > 1 ) && fn_out.hasStackExtension())
                type = "stk";
            else if (( mdInSize > 1 || zdimOut > 1 ) && fn_out.hasVolumeExtension()) // if it is volume
                type = "vol";
            else if (mdInSize > 1 || appendToStack) // If --append we suppose output is stack
                type = "stk";
            else if (zdimOut > 1) // if it is volume
                type = "vol";
            else
                type = "img";
        }
        else
            type = "img";
    }

    // Set write mode
    if (single_image && fn_out.isInStack()) // Replace a single image in a stack
    {
        type = "img";
        writeMode = WRITE_REPLACE;
    }
    else if (type == "stk" && appendToStack)
        writeMode = WRITE_APPEND;
    else
    {
        writeMode = WRITE_OVERWRITE;
        delete_output_stack = true;
    }

    if (delete_output_stack)
    {
        FileName fn_stack_plain = fn_out.removeFileFormat();
        fn_stack_plain.deleteFile();
        delete_output_stack = false;
    }

    create_empty_stackfile = (create_empty_stackfile && !appendToStack);

    convMode = MD2MD;

    if (!single_image && type == "vol")
    {
        convMode = MD2VOL;

        if (zdimOut != 1)
            REPORT_ERROR(ERR_MULTIDIM_DIM,
                         "Only 2D images can be converted into volumes");
        imOut = new ImageGeneric(datatypeOut);
        imOut->mapFile2Write(xdimOut, ydimOut, mdInSize, fn_out);
        k = 0;
    }
    else if (single_image)
    {
        // If --append is set, or fn_out is in a stack, then it is supposed not to convert VOL2MD
        if ( zdimOut > 1 && !(type == "vol" || fn_out.isInStack() || appendToStack))
        {
            convMode = VOL2MD;
            single_image = false;

            MetaData * md = getInputMd();
            md->clear();

            FileName fnTemp;

            /* Fill mdIn to allow XmippMetaDataProgram create the fnImgOut,
            but not used to read input images. Input volume is read here. */
            for (k = 1; k <= zdimOut; k++)
            {
                fnTemp.compose(k, fn_in);
                size_t id = md->addObject();
                md->setValue(MDL_IMAGE, fnTemp, id);
                md->setValue(MDL_ENABLED, 1, id);
            }
            imIn.read(fn_in, DATA, ALL_IMAGES, true);
            imOut = new ImageGeneric(datatypeOut);
            k = 0; // Reset to zero to select the slices when working with volumes
            if (!fn_out.empty())
            {
                if (depth.empty())
                    depth = "%"+datatype2Str(datatypeOut);
                createEmptyFile(fn_out+depth, xdimOut, ydimOut, 1, zdimOut, true, WRITE_OVERWRITE, swap, &imIn.image->MDMainHeader);
            }
        }
    }
    else if (create_empty_stackfile)
    {
        if (depth.empty())
            depth = "%"+datatype2Str(datatypeOut);
        
        FileName first_image;
        getInputMd()->getValue(image_label, first_image, 1);
        imIn.read(first_image, DATA, FIRST_IMAGE, true);
        createEmptyFile(fn_out+depth, xdimOut, ydimOut, zdimOut, mdInSize, true, WRITE_OVERWRITE, swap, &imIn.image->MDMainHeader);
    }
    create_empty_stackfile = false;
}//function preprocess

processImage()

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

protectedvirtual

Implements XmippMetadataProgram.

Definition at line 303 of file xmipp_image_convert.cpp.

{
    switch(convMode)
    {
    case MD2MD:
        {
            FileName tempName, _fnImgOut;
            if (fnImg == fnImgOut)
            {
                tempName.initUniqueName("tempConvert_XXXXXX");
                _fnImgOut = tempName + ":" + fnImgOut.getExtension();
            }
            else
                _fnImgOut= fnImgOut;

            imIn.read(fnImg, DATA, ALL_IMAGES, true);
            imIn.write(_fnImgOut+depth, ALL_IMAGES, type == "stk", writeMode, castMode, swap);

            if ((fnImg == fnImgOut) && (rename(tempName.c_str(),fnImgOut.c_str())!=0))
                REPORT_ERROR(ERR_IO, formatString("ProgConvImg:: Error renaming the file from %s to %s.",tempName.c_str(), fnImgOut.c_str()));

            break;
        }
    case MD2VOL:
        {
            imIn.read(fnImg,DATA, ALL_IMAGES,true);
            imOut->data->setSlice(k++,imIn.data);
            break;
        }
    case VOL2MD:
        {
            imIn.data->getSlice(k++,imOut->data);
            imOut->write(fnImgOut+depth, ALL_IMAGES, type == "stk", writeMode, castMode, swap);
            break;
        }
    }
}//function processImage

readParams()

void ProgConvImg::readParams ( )

protectedvirtual

Function in which each program will read parameters that it need. If some error occurs the usage will be printed out.

Reimplemented from XmippMetadataProgram.

Definition at line 160 of file xmipp_image_convert.cpp.

{
    XmippMetadataProgram::readParams();

    //fn_out = (checkParam("-o"))? getParam("-o") : "";
    castMode = (checkParam("--range_adjust"))? CW_ADJUST: \
               (checkParam("--dont_convert"))? CW_CAST: CW_CONVERT;

    appendToStack = checkParam("--append");

    // output extension
    oext = checkParam("--oext") ? getParam("--oext") : "";
    if ( oext == "custom" )
        oext = getParam("--oext",1);

    // Check output type
    type = getParam("--type");

    if (checkParam("--depth"))
    {
        auto depthTemp = (String)getParam("--depth");
        if (depthTemp != "default")
            depth = "%" + depthTemp;
    }

    if ( (swap = checkParam("--swap")) )
    {
        String swapType = getParam("--swap");

        if (swapType != "arch")
        {
            bool setLE = swapType == "little";
            swap = IsLittleEndian()^setLE;
        }
    }
}

setType()

void ProgConvImg::setType ( const String &  sType )

inline

Definition at line 65 of file xmipp_image_convert.h.

    {
        type = sType;
    }

show()

void ProgConvImg::show ( )

protected

Definition at line 359 of file xmipp_image_convert.cpp.

{
    XmippMetadataProgram::show();
    if (each_image_produces_an_output)
    {
        if (!oext.empty())
            std::cout << "Output Extension: " << oext << std::endl;
    }
}

---

The documentation for this class was generated from the following files:

• xmipp/libraries/data/xmipp_image_convert.h
• xmipp/libraries/data/xmipp_image_convert.cpp