void defineParams()
{
addUsageLine("Produces a selfile valid for tomography with an MRC stack and a list of angles");
addParamsLine(" --stack <stack> : Stack file (not necessarily MRC)");
addParamsLine(" --tiltAngles <rawtlt> : Tilt angle file");
addParamsLine(" -o <metadata> : Output metadata");
}
void defineParams()
{
addUsageLine("Testing paralellization with some sleeping program.");
addParamsLine(" [--time <sec=5> ] : Number of seconds to sleep ");
addParamsLine(" [--rand <min=0> <max=2> ] : Randon variation (uniform distributed between min and max");
addParamsLine(" [--tag <string> ] : Tag to monitor. ");
}
//Define Program parameters
void ProgValidationTiltPairs::defineParams()
{
//Usage
addUsageLine("Takes two coordinates sets and defines the coordinate transformation between them");
addUsageLine("First set defines the untilted coordinates, second set defines the tilted coordinates");
addParamsLine(" --tilt <metadata> : Metadata with angular assignment for the tilted images");
addParamsLine(" --untilt <metadata> : Metadata with angular assignment for the untilted images");
addParamsLine(" -o <metadata> : Metadata with matrix transformation");
}
void ProgValidationNonTilt::defineParams()
{
//usage
addUsageLine("Validate a 3D reconstruction from its projections attending to directionality and spread of the angular assignments from a given significant value");
//params
addParamsLine(" [--volume <md_file=\"\">] : Volume to validate");
addParamsLine(" [--odir <outputDir=\".\">] : Output directory");
addParamsLine(" [--sym <symfile=c1>] : Enforce symmetry in projections");
addParamsLine(" [--sampling_rate <s=1>] : Sampling rate in A/px");
}
void ProgCTFPhaseFlipping::defineParams()
{
addUsageLine("Correct the phase of micrographs");
addUsageLine("+This program flips the phase of those frequencies that were already ");
addUsageLine("+flipped by the CTF. Flipping the phase at the level of the micrograph is recommended.");
addParamsLine(" -i <file> : Input micrograph");
addParamsLine(" -o <file> : Output micrograph");
addParamsLine(" --ctf <ctfparam_file> : CTF description");
addParamsLine(" [--downsampling <D=1>] : Downsampling factor of the input micrograph with respect to the original");
addParamsLine(" : micrograph.");
}
void ProgEvaluateClass::defineParams()
{
addUsageLine("Evaluate the quality of a set of classes");
addUsageLine("+The program associates to each class a number of quality measures:");
addUsageLine("+");
addUsageLine("+FRC_05 is the digital frequency (<0.5) at which the Fourier Ring Correlation drops below 0.5 ");
addUsageLine("+(to convert from a digital frequency to one measured in Angstrom invert the digital frequency and multiply by the sampling rate).");
addUsageLine("+");
addUsageLine("+DPR_05 is the Differential Phase Residual at the frequency of FRC_05");
addParamsLine(" -i <infile> : Metadata with the classification (normally the output of CL2D or ML2D)");
addParamsLine(" [-o <outfile=\"\">] : Output file");
addExampleLine("xmipp_classify_evaluate_classes -i 2D/CL2D/run_001/results_level_00_classes.xmd");
}
void defineParams()
{
addParamsLine("-i <description_file> : Input file with the mathematical features");
addParamsLine("-o <output_file> : Output volume in voxels");
addUsageLine("Create phantom volume from a feature description file with two Metadatas.");
addUsageLine("+You may define a mathematical phantom from its geometrical features");
addUsageLine("+(cubes, cylinders, ...) and translate it into a voxel volume with this program.");
addUsageLine("+ File format can be found in this [[http://xmipp.cnb.csic.es/twiki/bin/view/Xmipp/FileFormats][link]].");
addExampleLine("xmipp_phantom_create -i phantom.descr -o phantom.vol");
addExampleLine("++In the following link you can find an example of phantom description file:",false);
addExampleLine("++",false);
addExampleLine("++http://newxmipp.svn.sourceforge.net/viewvc/newxmipp/trunk/testXmipp/input/phantom_descr.descr",false);
}
void defineParams()
{
addUsageLine("Run commands in a text file in a parallel environment");
addUsageLine("+You may use the tag MPI_BARRIER to separate execution blocks.");
addUsageLine("+You may use the tag MPI_NEWLINE to force a line break (this is useful for programs accepting parameters directly from stdin).");
addParamsLine("-i <commandFile> : File with commands in different lines");
}
// usage ===================================================================
void ProgClassifyCL2DCore::defineParams()
{
addUsageLine("Compute the core of a CL2D clustering");
addParamsLine(" --root <rootname> : Rootname of the CL2D");
addParamsLine(" --dir <dir> : Output directory of the CL2D");
addParamsLine(" --computeCore <thPCAZscore=3> <NPCA=2>: The class cores are computed by thresholding the Zscore of");
addParamsLine(" : the class images and their projections onto a nD PCA space (by default, n=2)");
addParamsLine("or --computeStableCore <tolerance=1> : The stable core is formed by all the images in the class that have been");
addParamsLine(" : in the same class (except in tolerance levels) in the whole hierarchy.");
addParamsLine(" : If tolerance=0, then the stable core is formed by the set of images that");
addParamsLine(" : have been always together. For this reason, the stable core can be computed only");
addParamsLine(" : for the level such that level>tolerance");
addExampleLine("mpirun -np 4 `which xmipp_mpi_classify_CL2D_core_analysis` -i 2D/CL2D/run_001/results --computeCore");
addExampleLine("mpirun -np 4 `which xmipp_mpi_classify_CL2D_core_analysis` -i 2D/CL2D/run_001/results --computeStableCore");
}
void defineParams()
{
each_image_produces_an_output = true;
addUsageLine("Adjust the grey level value of the pixels to a specified range.");
addKeywords("mask, normalization");
addSeeAlsoLine("transform_normalize");
XmippMetadataProgram::defineParams();
addParamsLine(" --range <min_val> <max_val> : Output minimum and maximum values.");
addParamsLine(" alias -r;");
addParamsLine(" [--noise <sigma=0>] : Variation of the limit range values.");
mask_prm.defineParams(this,INT_MASK, NULL, "Pixels in the mask area are guaranteed to be into the specified range.");
addExampleLine("Adjust an image in the range [-1, 1]:", false);
addExampleLine("xmipp_transform_range_adjust -i image.xmp -o image_adjust.xmp --range -1 1");
addExampleLine("Adjust images in a stack applying a circular mask:", false);
addExampleLine("xmipp_transform_range_adjust -i images.stk -o image_adjust.stk --range -1 1 --mask circular -32");
addExampleLine("Adjust a selection file in the range [-100, 100] with sigma noise 10:", false);
addExampleLine("xmipp_transform_range_adjust -i selection.sel --oroot images/im_adjust:spi -o selection_adjust.sel --range -100 100 --noise 10");
}
void defineParams()
{
addUsageLine("Shows which is the angular distribution of a set of projections.");
addUsageLine("+There are three kinds of outputs: a bild file (chimera understands this format), a distance histogram and a postscript file. ");
addUsageLine("+In postcript, each projection is represented by a small isosceles triangles (the longest part is pointing to Y in the projection plane). ");
addUsageLine("+In chimera, each projection direction has a sphere whose radius is proportional to the number of images assigned to it");
addUsageLine("+The histogram output is the histogram of the minimum distance (in degrees) among projections. The distance is measured on the sphere surface. This gives an idea of how compact is the angular distribution.");
addParamsLine(" -i <metadata> : Metadata file with the angles");
addParamsLine(" -o <file> <type> : Output file");
addParamsLine(" where <type>");
addParamsLine(" chimera <R=60> <rmax=1.5> <shift_center=0> : R=sphere radius, rmax=maximum point radius, shift_center=shift in pixels applied to all coordinates");
addParamsLine(" : shift_center should be half the volume size and R should be 2/3 the volume size");
addParamsLine(" ps <R=60> <rmax=1.5> <rot=0> <tilt=30> <solid_sphere=0> : R=sphere radius, rmax=maximum point radius, rot and tilt defines the point of view, solid_sphere=0 (=no) or 1 (=yes)");
addParamsLine(" : If the sphere is solid, projections in the back plane are not shown");
addParamsLine(" histogram <stepno=100> : Number of divisions in the histogram");
addParamsLine("[--up_down_correction] : correct angles so that a semisphere is shown");
}
// usage ===================================================================
void ProgVolumePCA::defineParams()
{
addUsageLine("Compute the PCA of a set of volumes, within a mask (optional).");
addParamsLine(" -i <volumes> : Metadata with aligned volumes");
addParamsLine(" [-o <volumes=\"\">] : Output metadata with PCA projections");
addParamsLine(" [--Npca <N=1>] : Number of PCA bases");
addParamsLine(" [--saveBasis <stack=\"\">]: Save the bases as a stack of volumes");
addParamsLine(" [--generatePCAVolumes <...>]: List of percentiles (typically, \"10 90\"), to generate volumes along the 1st PCA basis");
addParamsLine(" [--avgVolume <volume=\"\">] : Volume on which to add the PCA basis");
addParamsLine(" [--opca <stack=\"\">] : Stack of generated volumes");
mask.defineParams(this,INT_MASK);
}
void ProgValidationNonTilt::defineParams()
{
addUsageLine("Validate a 3D reconstruction from its projections attending to directionality and spread of the angular assignments from a given significant value");
addParamsLine(" [--i <md_file=\"\">] : Metadata file with input projections");
addParamsLine(" [--volume <md_file=\"\">] : Volume to validate");
addParamsLine(" [--odir <outputDir=\".\">] : Output directory");
addParamsLine(" [--sym <symfile=c1>] : Enforce symmetry in projections");
addParamsLine(" [--significance_noise<float=0.95>] : Significane of the alignment with respect the noise");
addParamsLine(" [--useSignificant] : Use Significant as alignment method. If not use projection matching");
}
// Usage -------------------------------------------------------------------
void ProgDetectMissingWedge::defineParams()
{
addUsageLine("Detect the orientation of the missing wedge in a tomogram. ");
addUsageLine("+For doing so it fits a couple of planes along which there is a maximum ");
addUsageLine("+variation between the energy of the Fourier transform on its left and ");
addUsageLine("+on its right. The missing wedge is coded with four angles (two for each ");
addUsageLine("+plane). You may also produce a mask with 1 where the missing wedge is, ");
addUsageLine("+and 0 where the data has been actually measured. Finally, you can also ");
addUsageLine("+produce a marked magnitude volume (i.e., the magnitude of the Fourier ");
addUsageLine("+transform where the position of the two planes have been marked). ");
addParamsLine(" -i <file> : Input tomogram");
addParamsLine(" [--maxFreq <f=0.25>] : Maximum frequency to fit the plane (normalized to 0.5)");
addParamsLine(" [--width <w=2>] : Width of the probe plane");
addParamsLine(" [--saveMarks] : Save the magnitude of the FFT with");
addParamsLine(" : marks showing the two planes");
addParamsLine(" [--saveMask] : Save a mask for the FFT of this tomogram");
addParamsLine(" : 1=Missing wedge, 0=non missing wedge");
addExampleLine("xmipp_tomo_detect_missing_wedge -i tomogram.vol");
}
void defineParams()
{
addUsageLine("Separate different disconnected objects in a binary volume. ");
addUsageLine("+In this way, small objects can be separated from large ones in ");
addUsageLine("+reconstructions. This is very useful for reconstructions. Objects ");
addUsageLine("+are written in separate files as binary volumes, too. Output volume ");
addUsageLine("+number 1 is the background, number 2 corresponds to object 1, number 3 ");
addUsageLine("+to object 2 ... This program also tells you the number of voxels on ");
addUsageLine("+each object. ");
addParamsLine(" -i <fn_in> : Input image or volume");
addParamsLine(" [--oroot <fn_root=\"\">] : Root filename for output");
addParamsLine(" : By default, the input name");
addParamsLine(" : The output masks are <fn_root>_000001.vol, ...");
addParamsLine(" [--invert] : Produce inverse masks");
addParamsLine(" [--min_size <size=0>] : Save if size is greater than this");
addSeeAlsoLine("transform_morphology, transform_threshold, transform_mask, volume_segment");
}
/// Define parameters
void defineParams()
{
addUsageLine("Find the best symmetry of rotation of an image or collection of images");
addUsageLine("+It is very useful when you want to calculate the rotational symmetry of ");
addUsageLine("+a set of images (in fact it computes the center of the average image). ");
addUsageLine("+Image dimensions must be less than 512x512.");
addSeeAlsoLine("xmipp_image_rotational_spectrum");
addParamsLine(" -i <file> : Image, image stack or image selfile");
addParamsLine(" --oroot <rootname> : Rootname for output files");
addParamsLine(" :+ <rootname>_center.xmd contains the image center");
addParamsLine(" :+ <rootname>_analyzed_image.xmp (if verbose>=2) contains the image that was actually analyzed");
addParamsLine("[--r1+ <radius=15>] : Lowest integration radius (% of the image radius)");
addParamsLine("[--r2+ <radius=80>] : Highest integration radius (% of the image radius)");
addParamsLine("[--r3+ <radius=90>] : Lowest smoothing radius (% of the image radius)");
addParamsLine("[--r4+ <radius=100>] : Highest smoothing radius (% of the image radius)");
addParamsLine("[--x0 <x>] : Initial center of rotation");
addParamsLine("[--y0 <y>] : Initial center of rotation");
addParamsLine("[--harm+ <n=1>] : Harmonic to optimize");
addParamsLine("[--opt+ <opt=-1>] : Type of optimization (-1=minimize, +1=maximize)");
addExampleLine("xmipp_image_find_center -i image.xmp");
}
/* Usage ------------------------------------------------------------------- */
void ProgAngularProjectLibrary::defineParams()
{
addUsageLine("Create a gallery of projections from a volume");
addUsageLine("+see [[http://xmipp.cnb.csic.es/twiki/bin/view/Xmipp/Angular_project_library_v3][here]] for further information about this program.");
addParamsLine(" -i <input_volume_file> : Input Volume");
addParamsLine(" -o <output_file_name> : stack with output files");
addParamsLine(" [--sym <symmetry=c1>] : Symmetry to define sampling ");
addParamsLine(" : One of the 17 possible symmetries in");
addParamsLine(" : single particle electron microscopy");
addParamsLine(" [--sampling_rate <Ts=5>] : Distance in degrees between sampling points");
addParamsLine("==+Extra parameters==");
addParamsLine(" [--sym_neigh <symmetry>] : symmetry used to define neighbors, by default");
addParamsLine(" : same as sym");
addParamsLine(" [--psi_sampling <psi=360>] : sampling in psi, 360 -> no sampling in psi");
addParamsLine(" [--max_tilt_angle <tmax=180>] : maximum tilt angle in degrees");
addParamsLine(" [--min_tilt_angle <tmin=0>] : minimum tilt angle in degrees");
addParamsLine(" [--experimental_images <docfile=\"\">] : doc file with experimental data");
addParamsLine(" [--angular_distance <ang=20>] : Do not search a distance larger than...");
addParamsLine(" requires --experimental_images;");
addParamsLine(" [--closer_sampling_points] : create doc file with closest sampling points");
addParamsLine(" requires --experimental_images;");
addParamsLine(" [--near_exp_data] : remove points far away from experimental data");
addParamsLine(" requires --experimental_images;");
addParamsLine(" [--compute_neighbors] : create doc file with sampling point neighbors");
addParamsLine(" requires --angular_distance;");
addParamsLine(" [--method <method=fourier>] : Projection method");
addParamsLine(" where <method>");
addParamsLine(" real_space : Makes projections by ray tracing in real space");
addParamsLine(" fourier <pad=1> <maxfreq=0.25> <interp=bspline> : Takes a central slice in Fourier space");
addParamsLine(" : pad controls the padding factor, by default, the padded volume is");
addParamsLine(" : the same than the original volume. ");
addParamsLine(" : maxfreq is the maximum frequency for the pixels and by default ");
addParamsLine(" : pixels with frequency more than 0.25 are not considered.");
addParamsLine(" : interp is the method for interpolation and the values can be: ");
addParamsLine(" : nearest: Nearest Neighborhood ");
addParamsLine(" : linear: Linear ");
addParamsLine(" : bspline: Cubic BSpline ");
addParamsLine(" [--perturb <sigma=0.0>] : gaussian noise projection unit vectors ");
addParamsLine(" : a value=sin(sampling_rate)/4 ");
addParamsLine(" : may be a good starting point ");
addParamsLine(" [--groups <selfile=\"\">] : selfile with groups");
addParamsLine(" [--only_winner] : if set each experimental");
addParamsLine(" : point will have a unique neighbor");
addExampleLine("Sample at 2 degrees and use c6 symmetry:", false);
addExampleLine("xmipp_angular_project_library -i in.vol -o out.stk --sym c6 --sampling_rate 2");
}
void ProgSSNR::defineParams()
{
addUsageLine("Evaluate the reconstruction quality using SSNR or its volumetric distribution VSSNR.");
addUsageLine("+You must produce a reconstruction with gaussian white noise with exactly the same angles and");
addUsageLine("+reconstruction parameters as the signal reconstruction. Our ART program can produce this noisy");
addUsageLine("+reconstruction. If you don't use ART as reconstruction algorithm, you will have to produce the");
addUsageLine("+noisy reconstruction by yourself (see our demo in order to learn how to do this). Finally, the");
addUsageLine("+VSSNR can be visualized using any volume viewer.");
addUsageLine("+++ %BR% %BR%");
addUsageLine("+++* Do not use any mask during the reconstruction since the resolution estimate is biased");
addUsageLine("+++* Before applying this measure make sure that the noise images and the background in the experimental" \
" images have zero average. It is also assumed that the projection of the reconstructed volumes matches the" \
" experimental or the noisy projections (i.e., check that both projections are within the same range");
addUsageLine("+++* The VSSNR is stored in the file as 10*log10(1+VSSNR). Thus, if you want a threshold of VSSNR=1, the" \
" threshold in the visualizer must be set to =10*log10(1+1)=3=");
addUsageLine("+++* If the reconstruction algorithm linearly scales the reconstructed volume so that the reprojected" \
" images do not match the gray values of the experimental images, use adjust_volume to correct for the linear" \
" transformation before computing the SSNR images");
addSeeAlsoLine("resolution_fsc");
addParamsLine("== SSNR or VSSNR Estimation ==");
addParamsLine(" [--signal <signal_file>] : Signal volume");
addParamsLine(" alias -S;");
addParamsLine(" requires --noise;");
addParamsLine(" [--noise <noise_file>] : Noise volume");
addParamsLine(" alias -N;");
addParamsLine(" [--sel_signal <signal_mdfile>] : Metadata file with the images used for the signal reconstruction");
addParamsLine(" alias -selS;");
addParamsLine(" [--sel_noise <noise_mdfile>] : Metadata file with the images used for the noise reconstruction");
addParamsLine(" alias -selN;");
addParamsLine(" [-o <SSNR_file=\"\">] : Output file with the SSNR estimation");
addParamsLine(" :+++If the output filename is not given, then the input filename is taken");
addParamsLine(" :+++from the -S parameter by inserting _SSNR before the extension.");
addParamsLine(" [--fourierProjections] : perform projections in Fourier space");
addParamsLine(" [--ring <w=4>] : Ring width for the SSNR averaging computation (Measured in Fourier pixels)");
addParamsLine(" [--sampling_rate <Ts=1>] : Pixel size (Angstrom)");
addParamsLine(" alias -s;");
addParamsLine(" [--min_power <th=1e-10>] : Minimum power in Fourier space. If at any moment, the SSNR must divide by something");
addParamsLine(" : smaller than this value, then the SSNR at that frequency is assumed to be 0. High ");
addParamsLine(" : values of this threshold result on speckled images. If this is the case, lower ");
addParamsLine(" : this threshold (it must always be positive) ");
addParamsLine(" [--gen_VSSNR] : (Allowed global options: --ring, --sampling_rate, --min_power)");
addParamsLine(" :+++ %BR%");
addParamsLine(" : Generate the individual estimations of the SSNR for each particle and build an ");
addParamsLine(" : interpolation volume (VSSNR) that is compatible with the individual SSNRs.");
addParamsLine(" :+ In fact, the VSSNR is stored as 10*log10(1+SSNR). Thus, after interpolating the threshold");
addParamsLine(" :+ at SSNR = 1 must be shown as the threshold of the output interpolated volume at 3.01 ");
addParamsLine(" :+ (10*log10(1+1)). The threshold at SSNR = 4 must be shown as the threshold of the output");
addParamsLine(" :+ interpolated volume at 6.99 (10*log10(1+4)). The 1D SSNR is also generated as a side-product");
addParamsLine(" requires --signal,--noise,--VSSNR;");
addParamsLine(" [--sym <sym=c1>] : Symmetry for constructing the VSSNR");
addParamsLine(" [--thr <n=1>] : Number of threads to construct the VSSNR");
addParamsLine(" [--VSSNR <fn_vol_file>] : Volume with the Volumetric SSNR");
addParamsLine(" [--oroot <root=\"\">] : Root name for individual SSNR estimations");
addParamsLine("== Estimation by radial averaging of the VSSNR ==");
addParamsLine(" [--radial_avg] : Do radial averaging estimation");
addParamsLine(" : (Allowed global options: --ring, --sampling_rate, --min_power, -o)");
addParamsLine(" requires --VSSNR;");
addExampleLine("SSNR Resolution of a reconstructed volume:", false);
addExampleLine("xmipp_resolution_ssnr -S recFourierSignal.vol -N recFourierNoise.vol -selS projections.xmd -selN noiseProjections.xmd");
addExampleLine("VSSNR Resolution of a reconstructed volume:", false);
addExampleLine("xmipp_resolution_ssnr -S recFourierSignal.vol -N recFourierNoise.vol -selS projections.xmd -selN noiseProjections.xmd --gen_VSSNR --VSSNR volumeout.vol");
}
void defineParams()
{
produces_an_output = true;
get_image_info = false;
XmippMetadataProgram::defineParams();
addUsageLine("Operate with image files headers. By default in Xmipp, geometrical transformations");
addUsageLine("coming in images files headers are ignored. Instead this information is read from");
addUsageLine("the images metadata if exist. With this program geometrical transformations can be");
addUsageLine("extracted to a metadata or assigned to header, also allows print or reset image file headers.");
addParamsLine("[ --print <decompose=0>] : Print the geometrical transformations in image file headers.");
addParamsLine(" : if input is stack and decompose=1 print header of each individual image.");
addParamsLine(" alias -p;");
addParamsLine("or --extract : The output is a selfile with geometrical transformations read from image file headers.");
addParamsLine(" alias -e;");
addParamsLine(" requires -o;");
addParamsLine("or --assign : Write the geometrical transformations from selfile to the image file headers.");
addParamsLine(" alias -a;");
addParamsLine("or --reset : Reset the geometrical transformations in image file headers.");
addParamsLine(" alias -r;");
addParamsLine("or --tree : Print the tree scheme from file containers as hdf5 files.");
addParamsLine(" alias -t;");
addParamsLine("or --sampling_rate <Ts=-1> : Change the sampling rate (in Angstrom units) in the image file header.");
addParamsLine(" : If no value is passed then current value in header is print.");
addParamsLine(" alias -s;");
addParamsLine(" [--round_shifts] :Round shifts to integers");
addExampleLine("Print the header of the images in metadata: ", false);
addExampleLine("xmipp_image_header -i images.sel");
addExampleLine("Extract geometrical transformations from image file headers: ", false);
addExampleLine("xmipp_image_header -i smallStack.stk --extract -o header.doc");
addExampleLine("Assign the geometrical transformations from the metadata to header: ", false);
addExampleLine("xmipp_image_header -i header.doc --assign");
addSeeAlsoLine("transform_geometry");
addKeywords("header, geometric, transformation, print");
}
// usage ===================================================================
void ProgXrayImport::defineParams()
{
addUsageLine("Preprocess X-ray micrograph to be used in tomographic reconstruction software");
addUsageLine(" ");
addUsageLine("+This program converts a single-axis tilt series coming from X-ray");
addUsageLine("+microscopy into a stack. Several corrections are applied ");
addUsageLine("+during this conversion including correction by the beam current, ");
addUsageLine("+the exposure time, and the slitwidth. The flatfield and a possible ");
addUsageLine("+darkfield are also corrected. The exact formula applied is");
addUsageLine("+ ");
addUsageLine("+ (I-darkfield)/(expTime*beamCurrent*slitWidth)",true);
addUsageLine("+Inormalized = -----------------------------------------------------------",true);
addUsageLine("+ Avg{(Iflatfield-darkfield)/(expTime*beamCurrent*slitWidth)}",true);
addUsageLine("+ ");
addUsageLine("+Because the intrinsic self-attenuation, X-ray projections are not optimal to be used ");
addUsageLine("+with EM 3D reconstruction algorithm. To fix that, use --log flag:");
addUsageLine("+ ");
addUsageLine("+log = log10(Inormalized)");
addUsageLine("+ ");
addUsageLine("+In addition to log correction, to apply a contrast inversion, which allows 3DEM ");
addUsageLine("+reconstruction algorithms returning volume coefficients close to the real expected ");
addUsageLine("+absorption values, use --correct flag:");
addUsageLine("+ ");
addUsageLine("+Icorrected = -log10(Inormalized)");
addUsageLine("+ ");
addUsageLine("+If darkfield/flatfield are not available, then they are not used for the correction.");
addUsageLine("+ ");
addUsageLine("+Specific flags to import tomo series from Mistral microscope (Alba synchrotron) and ");
addUsageLine("+U41-TXM (Bessy).");
addUsageLine("+ ");
addUsageLine("+In the general case, the flatfields and the the tilt series may be in any directory.");
addUsageLine("+ If the darkfield are available, they must be within the flatfield and the tilt");
addUsageLine("+series under a directory named darkfields (in small letters). For each");
addUsageLine("+SPE file there must be a positions file. For instance, the file myfile.spe");
addUsageLine("+must have in the same directory the file myfile-positions.txt. The");
addUsageLine("+exposure time, the beam current and the slit width are taken from this file.");
addUsageLine("+ ");
addUsageLine("+The exposure time is the parameter xm:ccd:exp_time, the beam current");
addUsageLine("+is sr:current, and the slit width is xm:mono:slitwidth. The tilt angle");
addUsageLine("+xm:sample:rx.");
addParamsLine("[--input <input_directory> ] : Directory with tomograms, position files and, optionally, ");
addParamsLine(" : darkfields (in a directory called darkfields)");
addParamsLine("[--flat <ff_rootname=\"\">] : Directory with SPE images, position files and, optionally, ");
addParamsLine(" : darkfields (in a directory called darkfields).");
addParamsLine(" : This param can also be used with specific microscopes params to ");
addParamsLine(" : use a stack of flatfields to average, or an averaged flatfield image");
addParamsLine("[--oroot <output_rootname>] : Rootname for output files. If empty, input filename is taken.");
addParamsLine(" :+ The following files are created:");
addParamsLine(" :+ rootname.mrc: MRC stack with tilt series fully corrected as described above");
addParamsLine(" :+ rootname_darkfield.xmp: darkfield for the tilt series");
addParamsLine(" :+ rootname_flatfields_darkfield.xmp: darkfield of the flatfields");
addParamsLine(" :+ rootname_flatfields_avg.xmp: average flatfield corrected by its darkfield");
addParamsLine(" :+ rootname.xmd: selfile with the images in the stack");
addParamsLine(" :+ rootname.tlt: list of angles");
addParamsLine(" [--crop <sizeX=0> <sizeY=sizeX>] : Number of pixels to crop from each side");
addParamsLine(" : This is used to avoid some black pixels of some cameras");
addParamsLine(" [--thr <N=1>] : Number of threads");
addParamsLine(" == Specific microscopes ");
addParamsLine("[--bessy <input_directory> <t_ini> <t_end> <f_ini> <f_end> ] : Directory with raw SPE images and position files acquired in ");
addParamsLine(" : Bessy X-ray microscope:");
addParamsLine(" : t_ini and t_end denotes the range of the tomogram images, and");
addParamsLine(" : f_ini and f_end denotes the range of the flatfield images stored in the same directory");
addParamsLine("[--mistral <input_file>] : hdf5 Nexus file acquired in Mistral microscope at Alba, which contains all data");
addParamsLine(" == Filters ");
addParamsLine(" [--bad_pixels <type=factor>] : Apply a boundaries median filter to bad pixels");
addParamsLine(" where <type> ");
addParamsLine(" factor <k=3.> : Applied at those pixels below [mean - k*std]");
addParamsLine(" mask <mask_file> : Applied at those pixels given by mask");
addParamsLine(" none : Do not apply the filter");
addParamsLine(" [--log] : Apply log to pixel values");
addParamsLine(" alias -l;");
addParamsLine(" [--correct] : Correct for the self-attenuation of X-ray projections applying ");
addParamsLine(" : log and multiplying by -1");
addParamsLine(" alias -c;");
addExampleLine("Standard call for spe files classified in folders is:",false);
addExampleLine("xmipp_xray_import --data 10s --flat flatfields --oroot ProcessedData/img --crop 7");
addExampleLine("Importing data from Alba synchrotron:",false);
addExampleLine("xmipp_xray_import --mistral tomogram.hdf5 --oroot imported_tomogram");
addExampleLine("Correcting for self-áttenuation and cropping:",false);
addExampleLine("xmipp_xray_import --mistral tomogram.hdf5 --oroot imported_tomogram --correct --crop 10");
}
// Params definition ============================================================
void ProgNmaAlignment::defineParams() {
addUsageLine("Align images with an atomic or pseudo-atomic (from EM volume) structure by computing deformation amplitudes along normal modes, three Euler angles, and two in-plane shifts");
addUsageLine("+See [[http://xmipp.cnb.csic.es/twiki/bin/view/Xmipp/Nma_alignment_v3][here]] for further information about the parameters of this program.");
defaultComments["-i"].clear();
defaultComments["-i"].addComment("Metadata with image filenames");
defaultComments["-o"].clear();
defaultComments["-o"].addComment("Metadata with output Euler angles, shifts, and deformation amplitudes");
XmippMetadataProgram::defineParams();
addParamsLine(" --pdb <PDB_filename> : Reference atomic or pseudo-atomic structure in PDB format");
addParamsLine(" [--odir <outputDir=\".\">] : Output directory");
addParamsLine(" [--resume] : Resume processing");
addParamsLine("==Generation of the deformed reference volumes==");
addParamsLine(" --modes <filename> : File with a list of mode filenames");
addParamsLine(" [--sampling_rate <Ts=1>] : Pixel size in Angstroms");
addParamsLine(" [--filterVol <cutoff=15.>] : Filter the volume after deforming. If this option is used, the default cut-off is 15 A.");
addParamsLine(" [--centerPDB] : Center the PDB structure");
addParamsLine(" [--fixed_Gaussian <std=-1>] : For pseudo-atoms fixed_Gaussian must be used.");
addParamsLine(" : Default standard deviation <std> is read from the PDB file.");
addParamsLine("==Combined elastic and rigid-body alignment==");
addParamsLine(" [--trustradius_scale <s=1>] : Positive scaling factor to scale the initial trust region radius");
addParamsLine(" [--mask <m=\"\">] : 2D masking of the projections of the deformed volume");
addParamsLine(" [--projMatch] : Real-space instead of wavelet-space (default) projection matching (global matching) that is refined by local (Fourier central slice) projection matching");
addParamsLine(" :+Note that wavelet-based method needs the image size to be power of 2");
addParamsLine(" [--discrAngStep <ang=10>] : Angular sampling step for computing the reference projections for global matching");
addParamsLine(" [--gaussian_Fourier <s=0.5>] : Sigma of Gaussian weigthing in Fourier space (parameter of central-slice method)");
addParamsLine(" [--gaussian_Real <s=0.5>] : Sigma of Gaussian weigthing in real space for spline interpolation in Fourier space (parameter of central-slice method)");
addParamsLine(" [--zerofreq_weight <s=0.>] : Zero-frequency weight (parameter of central-slice method)");
addExampleLine("xmipp_nma_alignment -i images.sel --pdb 2tbv.pdb --modes modelist.xmd --trustradius_scale 1.2 --sampling_rate 3.2 -o output.xmd --resume");
}
void ProgSortByStatistics::defineParams()
{
addUsageLine("Sorts the input images for identifying junk particles");
addUsageLine("+The program associates to each image four vectors.");
addUsageLine("+One vector is composed by descriptors that encodes the particle shape.");
addUsageLine("+Another two vectors give information about the SNR of the objects.");
addUsageLine("+Finally, the last vector provides information of the particle histogram");
addUsageLine("+");
addUsageLine("+These vector are then scored according to a multivariate Gaussian distribution");
addUsageLine("+");
addUsageLine("+You can reject erroneous particles choosing a threshold, you must take into account");
addUsageLine("+that it is a zscore.");
addUsageLine("+For univariate and mulivariate Gaussian distributions, 99% of the individuals");
addUsageLine("+have a Z-score below 3.");
addUsageLine("+Additionally, you can discard bad particles selecting an inaccurate particle percentage");
addUsageLine("+typically around 10-20%.");
addParamsLine(" -i <selfile> : Selfile with input images");
addParamsLine(" [-o <rootname=\"\">] : Output rootname");
addParamsLine(" : rootname.xmd contains the list of sorted images with their Z-score");
addParamsLine(" : rootname_vectors.xmd (if verbose>=2) contains the vectors associated to each image");
addParamsLine(" : If no rootname is given, these two files are not created");
addParamsLine(" [--train <selfile=\"\">]: Train on selfile with good particles");
addParamsLine(" [--zcut <float=-1>] : Cut-off for Z-scores (negative for no cut-off) ");
addParamsLine(" : Images whose Z-score is larger than the cutoff are disabled");
addParamsLine(" [--percent <float=0>] : Cut-off for particles (zero for no cut-off) ");
addParamsLine(" : Percentage of images with larger Z-scores are disabled");
addParamsLine(" [--addToInput] : Add columns also to input MetaData");
addParamsLine(" [--dim <d=50>] : Scale images to this size if they are larger.");
addParamsLine(" : Set to -1 for no rescaling");
}
/* Usage ------------------------------------------------------------------- */
void ProgResolutionIBW::defineParams()
{
addUsageLine("Evaluate the resolution of a volume through the inverse border widths");
addParamsLine(" -i <file> : Volume to evaluate");
addParamsLine(" [-o <file=\"\">] : Volume with the border widths of the edge voxels");
}
void defineParams()
{
ProgTransformImageGreyLevels::defineParams();
MpiMetadataProgram::defineParams();
addParamsLine(" [--Nsimultaneous <N=1>] : Number of simultaneous processes that can enter in preprocessing");
}
void defineParams()
{
ProgAngularContinuousAssign2::defineParams();
MpiMetadataProgram::defineParams();
addParamsLine(" [--Nsimultaneous <N=1>] : Number of simultaneous processes that can enter in preprocessing");
}
void defineParams()
{
addUsageLine("Align two volumes varying orientation, position and scale");
addParamsLine(" --i1 <volume1> : the first volume to align");
addParamsLine(" --i2 <volume2> : the second one");
addParamsLine(" [--rot <rot0=0> <rotF=0> <step_rot=1>] : in degrees");
addParamsLine(" [--tilt <tilt0=0> <tiltF=0> <step_tilt=1>] : in degrees");
addParamsLine(" [--psi <psi0=0> <psiF=0> <step_psi=1>] : in degrees");
addParamsLine(" [--scale <sc0=1> <scF=1> <step_sc=1>] : size scale margin");
addParamsLine(" [--grey_scale <sc0=1> <scF=1> <step_sc=1>] : grey scale margin");
addParamsLine(" requires --least_squares;");
addParamsLine(" [--grey_shift <sh0=0> <shF=0> <step_sh=1>] : grey shift margin");
addParamsLine(" requires --least_squares;");
addParamsLine(" [-z <z0=0> <zF=0> <step_z=1>] : Z position in pixels");
addParamsLine(" [-y <y0=0> <yF=0> <step_y=1>] : Y position in pixels");
addParamsLine(" [-x <x0=0> <xF=0> <step_x=1>] : X position in pixels");
addParamsLine(" [--show_fit] : Show fitness values");
addParamsLine(" [--apply <file=\"\">] : Apply best movement to --i2 and store results in this file");
addParamsLine(" [--covariance] : Covariance fitness criterion");
addParamsLine(" [--least_squares] : LS fitness criterion");
addParamsLine(" [--local] : Use local optimizer instead of exhaustive search");
addParamsLine(" [--frm <maxFreq=0.25> <maxShift=10>] : Use Fast Rotational Matching");
addParamsLine(" : Maximum frequency is in digital frequencies (<0.5)");
addParamsLine(" : Maximum shift is in pixels");
addParamsLine(" :+ See Y. Chen, et al. Fast and accurate reference-free alignment of subtomograms. JSB, 182: 235-245 (2013)");
addParamsLine(" [--onlyShift] : Only shift");
addParamsLine(" == Mask Options == ");
mask.defineParams(this,INT_MASK,NULL,NULL,true);
addExampleLine("Typically you first look for a rough approximation of the alignment using exhaustive search. For instance, for a global rotational alignment use",false);
addExampleLine("xmipp_volume_align --i1 volume1.vol --i2 volume2.vol --rot 0 360 15 --tilt 0 180 15 --psi 0 360 15");
addExampleLine("Then, assume the best alignment is obtained for rot=45, tilt=60, psi=90",false);
addExampleLine("Now you perform a local search to refine the estimation and apply",false);
addExampleLine("xmipp_volume_align --i1 volume1.vol --i2 volume2.vol --rot 45 --tilt 60 --psi 90 --local --apply volume2aligned.vol");
}
