Xmipp  v3.23.11-Nereus
Macros | Functions | Variables
xmippmoduleCore.h File Reference
#include <Python.h>
#include "../../core/metadata_extension.h"
#include "../../core/xmipp_image_generic.h"
#include "../../core/xmipp_image_extension.h"
#include "../../core/xmipp_color.h"
#include "../../core/symmetries.h"
#include "python_filename.h"
#include "python_image.h"
#include "python_program.h"
#include "python_metadata.h"
#include "python_symmetry.h"
Include dependency graph for xmippmoduleCore.h:

Go to the source code of this file.

Macros

#define NPY_NO_DEPRECATED_API   NPY_1_7_API_VERSION
 
#define SymList_Check(v)   (((v)->ob_type == &SymListType))
 
#define SymList_Value(v)   ((*((SymListObject*)(v))->symlist))
 

Functions

PyObject * xmipp_str2Label (PyObject *obj, PyObject *args)
 
PyObject * xmipp_label2Str (PyObject *obj, PyObject *args)
 
PyObject * xmipp_colorStr (PyObject *obj, PyObject *args)
 
PyObject * xmipp_labelType (PyObject *obj, PyObject *args)
 
PyObject * xmipp_labelHasTag (PyObject *obj, PyObject *args)
 
PyObject * xmipp_labelIsImage (PyObject *obj, PyObject *args)
 
PyObject * xmipp_isValidLabel (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_createEmptyFile (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_getImageSize (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_ImgSize (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_CheckImageFileSize (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_CheckImageCorners (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_ImgCompare (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_compareTwoFiles (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_compareTwoImageTolerance (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_bsoftRemoveLoopBlock (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_bsoftRestoreLoopBlock (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_readMetaDataWithTwoPossibleImages (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_substituteOriginalImages (PyObject *obj, PyObject *args, PyObject *kwargs)
 
bool validateInputImageString (PyObject *pyImage, PyObject *pyStrFn, FileName &fn)
 
PyObject * xmipp_compareTwoMetadataFiles (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_dumpToFile (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_Euler_angles2matrix (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * xmipp_Euler_direction (PyObject *obj, PyObject *args, PyObject *kwargs)
 
PyObject * MetaData_activateMathExtensions (PyObject *obj, PyObject *args, PyObject *kwargs)
 
void addIntConstant (PyObject *dict, const char *name, const long &value)
 
void addLabels (PyObject *dict)
 

Variables

PyObject * PyXmippError
 

Macro Definition Documentation

◆ NPY_NO_DEPRECATED_API

#define NPY_NO_DEPRECATED_API   NPY_1_7_API_VERSION

Definition at line 30 of file xmippmoduleCore.h.

◆ SymList_Check

#define SymList_Check (   v)    (((v)->ob_type == &SymListType))

Definition at line 48 of file xmippmoduleCore.h.

◆ SymList_Value

#define SymList_Value (   v)    ((*((SymListObject*)(v))->symlist))

Definition at line 49 of file xmippmoduleCore.h.

Function Documentation

◆ addIntConstant()

void addIntConstant ( PyObject *  dict,
const char *  name,
const long &  value 
)

Definition at line 40 of file python_constants.cpp.

41 {
42  PyObject * pyValue = PyLong_FromLong(value);
43  PyDict_SetItemString(dict, name, pyValue);
44  Py_DECREF(pyValue);
45 }

◆ addLabels()

void addLabels ( PyObject *  dict)

RELION labels

< ID for the area (or field of view). If one does not use (tilt) series, area would be the same as micrograph...

< Name for the area (or field of view). If one does not use (tilt) series, area would be the same as micrograph...

< B-factor

< linear scale-factor

< Sampling rate

< Microscope voltage (kV)

< Defocus U (Angstroms)

< Defocus V (Angstroms)

< Defocus angle (degrees)

< Spherical aberration

< Chromatic aberration

< Pixel size for detector as used in CTF-determination

< Energy loss

< ctffind3 FOM (CC) for quality of CTF-fit

< name of an image describing the CTF model

< Lens stability

< Magnification used for CTF-determination

< Convergence cone

< Longitudinal displacement

< Transversal displacemente

< Amplitude contrast

< CTF gain

< CTF value

< Phase-shift from a phase-plate (in degrees)

< Detector MTF value

Definition at line 52 of file python_constants.cpp.

53 {
54 
55  //Add constants
61 
62 
68 
78  ADD_CONST(LEFT);
81  ADD_CONST(EQ);
82  ADD_CONST(NE);
83  ADD_CONST(GT);
84  ADD_CONST(LT);
85  ADD_CONST(GE);
86  ADD_CONST(LE);
91 
92  //Metadata Labels
114 
118 
126 
142 
145 
149 
222 
238 
240 
244 
246 
251 
254 
269 
271 
276  ADD_CONST(MDL_LL);
307 
323 
328 
333 
359 
380 
431 
435 
436 
440 
442 
447 
449 
458 
474 
478  ADD_CONST(MDL_X);
479 
482  ADD_CONST(MDL_Y);
485  ADD_CONST(MDL_Z);
500 
501  /* Label types */
519  ADD_CONST(_NONE);
520  ADD_CONST(HEADER);
521  ADD_CONST2("HEADER_ALL", _HEADER_ALL);
522  ADD_CONST(DATA);
523  ADD_CONST2("DATA_ALL", _DATA_ALL);
524  ADD_CONST(xmipp_transformation::WRAP);
527  ADD_CONST2("XMIPP_BLACK", BLACK);
528  ADD_CONST2("XMIPP_RED", RED);
529  ADD_CONST2("XMIPP_GREEN", GREEN);
530  ADD_CONST2("XMIPP_YELLOW", YELLOW);
531  ADD_CONST2("XMIPP_BLUE", BLUE);
532  ADD_CONST2("XMIPP_MAGENTA", MAGENTA);
533  ADD_CONST2("XMIPP_CYAN", CYAN);
534  ADD_CONST2("XMIPP_WHITE", WHITE);
535  ADD_CONST2("XMIPP_RND_UNIFORM", RND_UNIFORM);
536  ADD_CONST2("XMIPP_RND_GAUSSIAN", RND_GAUSSIAN);
537 
538  ADD_CONST2("DT_DEFAULT", DT_Default);
539  ADD_CONST2("DT_UNKNOWN", DT_Unknown);
540  ADD_CONST2("DT_UCHAR", DT_UChar);
541  ADD_CONST2("DT_SCHAR", DT_SChar);
542  ADD_CONST2("DT_USHORT", DT_UShort);
543  ADD_CONST2("DT_SHORT", DT_Short);
544  ADD_CONST2("DT_UINT", DT_UInt);
545  ADD_CONST2("DT_INT", DT_Int);
546  ADD_CONST2("DT_LONG", DT_Long);
547  ADD_CONST2("DT_FLOAT", DT_Float);
548  ADD_CONST2("DT_DOUBLE", DT_Double);
549  ADD_CONST2("DT_COMPLEXSHORT", DT_CShort);
550  ADD_CONST2("DT_COMPLEXINT", DT_CInt);
551  ADD_CONST2("DT_COMPLEXFLOAT", DT_CFloat);
552  ADD_CONST2("DT_COMPLEXDOUBLE", DT_CDouble);
553  ADD_CONST2("DT_BOOL", DT_Bool);
554  ADD_CONST2("DT_HALFFLOAT", DT_HalfFloat);
555  ADD_CONST2("DT_LASTENTRY", DT_LastEntry);
556 
563 
564  ADD_CONST2("XMIPP_EQUAL_ACCURACY",XMIPP_EQUAL_ACCURACY);
565 
570 
574  ADD_CONST(RLN_COMMENT); // The RLN_COMMENT is handled specially as well
575 
598 
629 
639 
646 
768 
783 
784  // New helical labes in Relion 2.x
811 
812  // New SGD labels in Relion 2.1
824 
855 
861 
866 
867 }
object id (int), NOTE: This label is special and shouldn&#39;t be used
Logarithm of the structure factor.
scale y of continuous assignment
CTF Background parameter.
linear scale-factor
Z size (int)
CTF gain.
contribution of an image to log-likelihood value
correlation of references assigned by two methods
Feature vectors used to classify particles (vector double)
< Micrographs Gini Coeff. (double)
X shift of continuous assignment.
Name of Metadata file for all references(string)
Name of the original micrograph, MDL_MICROGRAPH is probably a downsampled version of this one (std::s...
Particular neighbor (pointed myNEIGHBORS)
tsne coefficients in 2D
Rotation angle of an image (double,degrees)
< Score 2 for volumes
score by alignability (double)
Current block number (for incremental EM)
Weight due to Alignability Precision and Accuracy.
Defocus U (Angstroms)
Name of the corresponding original, tilted micrograph (std::string)
weighted correlation value between a particle and its assigned projection taking into the difference ...
Tilting angle of an image (double,degrees)
CTF gain.
Fourier shell correlation (double)
Fourier shell occupancy (double)
shift difference (double)
sampling rate in A/pixel (double)
Frequency in A of the local resolution of a residue (double)
Shift for the image in the Y axis (double)
CTF Background parameter.
Amplitude contrast.
Symmetry number for a projection (used in ART)
Defocus V (Angstroms)
sampling rate in A/pixel (double)
Cell location for crystals.
Weight due to Alignability Precision.
Not equal.
Feature vectors used to classify particles (vector double)
Less than.
sampling rate in A/pixel (double)
Weight due to angular jumping.
Name of a position file (std::string)
Image associated to this object (std::string)
score by alignability experimental particles (double)
Defocus angle (degrees)
Microscope voltage (kV)
Longitudinal displacement.
difference between rot angles (double,degrees)
Feature vectors used to classify particles (vector double)
Initial tilt angle in X for missing region in subtomogram.
Index of an image within a list (size_t)
Correlation between the denoised image and the projection proposed.
Sum of elements of a given type (double) [this is a genereic type do not use to transfer information ...
< Type of randomness for Tilt (std::string)
score by alignability references (double)
Parameters file for the CTF Model (std::string)
Flip of continuous assignment.
CTF Background parameter.
Name for the reconstructed tomogram volume (std::string)
Cost percentile for the image (double)
Z component (double)
Distance to graph filtered max.
< Rotational angle dev and mean noise (vector double)
Maximum frequency (in Angstroms) at which non-astigmatic CTF correction is valid. ...
Signal change for an image.
Maximum value (double)
Resolution anisotropy used to store the significance of the Bingham Test (double) ...
Tilting angle of an image (double,degrees)
Particle size for particle picking.
Weight due correlation between two images/subtomos.
Number of automatic particles picked.
difference between two angles (double,degrees)
Initial tilt angle in Y for missing region in subtomogram.
Shift for the image in the X axis (double)
score by alignability (double)
First zero average (in Angstroms)
Tilt series id (std::string)
#define ADD_CONST(label)
Convergence cone.
Z Score (double)
File for generated angles.
Z Score (double)
Percentage of images assigned to the same class as this image.
CTF Background parameter.
Average change in offset (double pixels)
PSD correlation at 90 degrees.
Special label to be used when gathering MDs in MpiMetadataPrograms.
Feature vectors used to classify particles (vector double)
CTF Background parameter.
Name for the CTF Model (std::string)
difference in Shift along Y axis (double)
A collection of micrographs, e.g. a tilt serie (std::string)
if read from file original image datatype, this is an struct defined in image
Noise description for projected angles.
Defocus U (Angstroms)
Z Score (double)
Weight of t-student distribution in robust Maximum likelihood.
Chromatic aberration.
Lens stability.
<Bfactor of a map, or even a local bfactor
Store a score for the coords. consensus (it will change the behavoir of the viewer) ...
auxiliary label to be used as an index (long)
CTF Background parameter.
Maximum value observed for a given NMA mode.
Z Score (double)
NMA Atom shift in Angstroms.
Y shift of continuous assignment.
Coefficients of the defocus adjustment plane.
A Power Spectrum Density file name (std::string)
CTF Background parameter.
CTF Background parameter.
Weight assigned to the image accordint to its clusterability with a significance with respect noise (...
Spherical aberration.
Z Score (double)
Name of the tilted images associated to MDL_IMAGE.
correlation value between a particle and its assigned projection
CTF value.
Angle between y-axis and tilt-axis (double, degrees) for tilted micrographs.
when previous assignment validation
< Lattice vector for projection (vector double)
Is this image enabled? (int [-1 or 1])
differential phase residual (double)
Mean of the movement in y direction of the motion map> (double)
Unique identifier for items inside a list or set (std::size_t)
Microscope voltage (kV)
CTF Background parameter.
Correlation between the 1st and 3rd ring of the CTF.
Y size (int)
Shift for the image in the Z axis (double) for crystals.
Score corresponding to the mean of cc with cc>threshold.
Detector MTF value.
P-value (1-percentile) of the class size compared to a random distribution (double in [0...
Image associated to this object (std::string)
Store a second class (int)
Rotation angle of an image (double,degrees)
tsne coefficicient in 1D
Minimum value (double)
Name for the area (or field of view). If one does not use (tilt) series, area would be the same as mi...
score by alignability references (double)
Score of the fitting.
Shift for the image in the Y axis (double) for crystals.
Weight due to Angular significance.
NMA Score of a given mode.
shift difference (double)
Name of an image from which MDL_IMAGE is coming from.
Number of elements of a type (int) [this is a genereic type do not use to transfer information to ano...
Score corresponding to the min of cc with cc>threshold.
Micrograph state for particle picking.
Half map/image file name (string)
NMA Collectivity of a given mode.
Name of an image (std::string)
difference between psi angles (double,degrees)
< Shift file for crystal projection
<Orthogonal projection or not (bool)
The label MDL_OBJID is special and should not be used.
Inelastic absorption.
Frequency in 1/A squared (double)
Integral of the radial PSD.
Standard deviation of the movement in y direction of the motion map> (double)
original sampling rate in A/pixel (double)
Equal.
Weight due to angular jumping.
< Score corresponding to the sum of cc with cc>threshold
CTF Background parameter.
Deformation in voxels.
Defocus angle (degrees)
a value of continuous assignment
Minimum damping at border.
Origin for the image in the Y axis (double)
Longitudinal displacement.
Frequency in A (double)
Y component in tilted micrograph (int)
< Have a crystal projection (bool)
Unique id of frame inside a Movie.
group images by defocus
Defocus group.
Cost for the image (double)
NMA Eigenvalue of a given mode.
average defocus (Angtroms)
R2 coefficient of subtracted particle.
< Particle variance (double)
< Score 3 for volumes
Feature vectors used to classify particles (vector double)
Angle between y-axis and tilt-axis (double, degrees) for untilted micrographs.
State for particle picking.
Number of manual particles picked.
Convergence cone.
#define XMIPP_EQUAL_ACCURACY
Definition: xmipp_macros.h:119
X component (int)
Flip the image? (bool)
Name for a Metadata file (std::string)
Name of a movie (std::string)
Normality test between histogram of micrography and gaussian distribution.
Greater equal.
Size of data vectors for classification (int)
MLF signal (double)
< Number of non-redundant projections directions (size_t)
Unique identifier of a movie.
CTF Background parameter.
Phase-shift from a phase-plate (in degrees)
Maximum value of normalized probability function (now called "Pmax/sumP") (double) ...
Number of elements of a type (int) [this is a genereic type do not use to transfer information to ano...
CTF Background parameter.
Image associated to this object (std::string)
Sum of all weights in ML model.
Normal mode displacements (vector double)
Maximum frequency at which the envelope drops below 0.1 (in Angstroms)
Standard deviation of the noise in ML model.
Half map/image 1 file name (string)
Projection onto a reduced manifold (vector double)
Average change in class assignment(double dimensionaless)
Weight due phase correlation between two images/subtomos.
Greater than.
Name of a residual image associated to this image.
Noise description for pixels&#39; gray level (when projecting)
Image associated to this object (std::string)
Intensity scale for an image.
Digital frequency at which the FRC drops below 0.5 (double)
Z Score (double)
Maximum cross-correlation for the image (double)
Micrograph unique id for reference (MDL_ITEM_ID should be used for Micrographs list) ...
Name of a mask associated to image.
Defocus coefficient of determination.
CTF Background parameter.
Model fraction (alpha_k) for a Maximum Likelihood model.
Number of missing region in subtomogram.
scaling factor for an image or volume (double)
Z Score of the mean of the residuals (double)
name of an image describing the CTF model
Name of a micrograph (std::string)
score by alignability experimental particles (double)
< Psi angle dev and mean noise (vector double)
KS-test statistics.
Cumulative SSNR (double)
Image associated to this object (std::string)
First zero disagreement with second model (in Angstroms)
Psi angle of an image (double,degrees)
Runs test on the projection of the PSD on the first principal component.
CTF_ CTF Background parameter.
X component in tilted micrograph (int)
Standard deviation of the offsets in ML model.
Type of missing region in subtomogram.
Z component (int)
3D Class to which the image belongs (int)
Frequency in 1/A (double)
difference between two angles (double,degrees)
Particle unique identifier for reference. (The MDL_ITEM_ID should be used when particle list) ...
Weight due to SSNR.
Standatd deviation of the movement in x direction of the motion map> (double)
Correlation from previous alignment.
Name of the covariance imagee associated to this image.
Downsampling performed to estimate the CTF.
Pixel size for detector as used in CTF-determination.
#define ADD_CONST2(name, label)
CTF Background parameter.
score by alignability noise (double)
A enhanced Power Spectrum Density file name (std::string)
Beta 0 coefficient of adjusted model for subtract particle.
Class to which the image belongs (int)
Difference between the observed defocus value and the estimated defocus value.
Variance in the first principal component of the PSDs.
Weight due to angular continuous assignment.
Vector of indexes to points some "neighbors".
Shift for the image in the X axis (double)
ctffind3 FOM (CC) for quality of CTF-fit
b value of continuous assignment
X size (int)
Global Z Score (double)
Number of images assigned to the same class as this image.
< Lattice vector for projection (vector double)
Name of Metadata file for all images (string)
Small values represent worse particles. Much larger than 1 for good particles.
Name for another CTF model (std::string)
score by mirror (double)
Y component (double)
Mean of the movement in x direction of the motion map> (double)
ID for the area (or field of view). If one does not use (tilt) series, area would be the same as micr...
MLF CTF estimated value (double)
Iceness of the micrograph.
Error in l2 (double)
Fourier shell correlation noise (double)
Percentile of the maximum cross-correlation for the image (double)
Deformation coefficients.
#define ALL_IMAGES
Name of the corresponding tilted micrograph (std::string)
Data vector for classification (vector double)
transformation matrix in numpy string format or space separated (std::string)
Figure of Merit in 0-1 range (double)
Shift for the image in the Z axis (double)
Average change in angular orientation (double degrees)
X component (double)
average value in the micrograph (double)
Index within a list (size_t)
Final tilt angle in Y for missing region in subtomogram.
#define FILENAMENUMBERLENGTH
Angular temperature (double,degrees)
P-value (1-percentile) of the relative class size (size/max(original_classes)) compared to a random d...
CTF Background parameter.
difference between two angles (double,degrees)
Weight due to Mirror Precision.
< Type of randomness for Rotational (std::string)
Weight due to Alignability Accuracy.
< Score 1 for volumes
scale x of continuous assignment
Correlation between the denoised image and the noisy version.
Origin for the image in the Z axis (double)
average value (double)
difference between tilt angles (double,degrees)
Average intraclass distance (double)
score by alignability (double)
Y component (int)
Less equal.
Defocus change with respect to previous defoucs (Angstroms)
Z Score of the stddev of the residuals (double)
Final tilt angle in X for missing region in subtomogram.
Ratio sigma(firstMinimum-firstZero)/sigma(firstZero)
Mirror fraction for a Maximum Likelihood model.
when previous assignment validation
Weight due to angular jumping.
Minimum value observed for a given NMA mode.
Shift for the image in the Y axis (double)
Radius of the neighborhood (radians)
Z Score of the covariance matrix of the residuals (double)
< Disappearing threshold (double)
Transversal displacemente.
shift difference (double)
< Psi angle range (vector double)
Current iteration number (int)
Spherical aberration.
< Tilt angle dev and mean noise (vector double)
Defocus V (Angstroms)
Chromatic aberration.
Transversal displacemente.
MLF Wiener filter (double)
Correlation between assigned direction and graph filtered maximum.
File with an NMA mode.
Name of an image (std::string)
Lens stability.
Magnification used for CTF-determination.
< Type of randomness for Psi (std::string)
Name of of the class image from which MDL_IMAGE is coming from.
Number of templates.
Color for particle picking.
Feature vectors used to classify particles (vector double)
MLF Wiener filter (double)
Beta 1 coefficient of adjusted model for subtract particle.
< Score 4 for volumes
Cell location for crystals.
imed value between a particle and its assigned projection
Fourier shell correlation (double)
masked correlation value between a particle and its assigned projection inside the region with pixel ...
Dose e/A^2 (double)
Serve to make annotations on the metadata row.
Differential Phase Residual evaluated at FRC=0.5.
difference in Shift along X axis (double)
A comment for this object /*** NOTE THIS IS A SPECIAL CASE AND SO IS TREATED ***/.
CTF Background parameter.
Seed for random number generator.
Noise description for particle&#39;s center coordenates (when projecting)

◆ MetaData_activateMathExtensions()

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

◆ validateInputImageString()

bool validateInputImageString ( PyObject *  pyImage,
PyObject *  pyStrFn,
FileName fn 
)

Definition at line 663 of file xmippmodule.cpp.

664 {
665  if (!Image_Check(pyImage))
666  {
667  PyErr_SetString(PyExc_TypeError,
668  "bad argument: Expected Image as first argument");
669  return false;
670  }
671  if (PyUnicode_Check(pyStrFn))
672  fn = (char*)PyUnicode_AsUTF8(pyStrFn);
673 
674  else if (FileName_Check(pyStrFn))
675  fn = FileName_Value(pyStrFn);
676  else
677  {
678  PyErr_SetString(PyExc_TypeError,
679  "bad argument:Expected string or FileName as second argument");
680  return false;
681  }
682  return true;
683 }
#define FileName_Check(v)
#define Image_Check(v)
Definition: python_image.h:43
#define FileName_Value(v)

◆ xmipp_bsoftRemoveLoopBlock()

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

Definition at line 459 of file xmippmodule.cpp.

460 {
461  PyObject *filename1;
462  PyObject *filename2;
463  if (PyArg_ParseTuple(args, "OO", &filename1, &filename2))
464  {
465  try
466  {
467  PyObject * pyStr1 = PyObject_Str(filename1);
468  PyObject * pyStr2 = PyObject_Str(filename2);
469 
470  auto * str1 = (char*)PyUnicode_AsUTF8(pyStr1);
471  auto * str2 = (char*)PyUnicode_AsUTF8(pyStr2);
472  bsoftRemoveLoopBlock(str1, str2);
473  Py_DECREF(pyStr1);
474  Py_DECREF(pyStr2);
475  Py_RETURN_TRUE;
476  }
477  catch (XmippError &xe)
478  {
479  PyErr_SetString(PyXmippError, xe.what());
480  }
481  }
482  return nullptr;
483 }
void bsoftRemoveLoopBlock(const FileName &_inFile, const FileName &_outFile)
PyObject * PyXmippError
Definition: xmippmodule.cpp:47

◆ xmipp_bsoftRestoreLoopBlock()

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

Definition at line 487 of file xmippmodule.cpp.

488 {
489  PyObject *filename1;
490  PyObject *filename2;
491  if (PyArg_ParseTuple(args, "OO", &filename1, &filename2))
492  {
493  try
494  {
495  PyObject * pyStr1 = PyObject_Str(filename1);
496  PyObject * pyStr2 = PyObject_Str(filename2);
497 
498  auto * str1 = (char*)PyUnicode_AsUTF8(pyStr1);
499  auto * str2 = (char*)PyUnicode_AsUTF8(pyStr2);
500  bsoftRestoreLoopBlock(str1, str2);
501  Py_DECREF(pyStr1);
502  Py_DECREF(pyStr2);
503  Py_RETURN_TRUE;
504  }
505  catch (XmippError &xe)
506  {
507  PyErr_SetString(PyXmippError, xe.what());
508  }
509  }
510  return nullptr;
511 }
PyObject * PyXmippError
Definition: xmippmodule.cpp:47
void bsoftRestoreLoopBlock(const FileName &_inFile, const FileName &_outFile)

◆ xmipp_CheckImageCorners()

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

Definition at line 370 of file xmippmodule.cpp.

371 {
372  PyObject *filename;
373 
374  if (PyArg_ParseTuple(args, "O", &filename))
375  {
376  try
377  {
378  PyObject * pyStr = PyObject_Str(filename);
379  auto * str = (char*)PyUnicode_AsUTF8(pyStr);
380  bool result = checkImageCorners(str);
381  Py_DECREF(pyStr);
382  if (result)
383  Py_RETURN_TRUE;
384  else
385  Py_RETURN_FALSE;
386  }
387  catch (XmippError &xe)
388  {
389  PyErr_SetString(PyXmippError, xe.what());
390  }
391  }
392  return nullptr;
393 }
PyObject * PyXmippError
Definition: xmippmodule.cpp:47
bool checkImageCorners(const FileName &name)

◆ xmipp_CheckImageFileSize()

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

Definition at line 344 of file xmippmodule.cpp.

345 {
346  PyObject *filename;
347 
348  if (PyArg_ParseTuple(args, "O", &filename))
349  {
350  try
351  {
352  PyObject * pyStr = PyObject_Str(filename);
353  auto *str = (char*)PyUnicode_AsUTF8(pyStr);
354  bool result = checkImageFileSize(str);
355  Py_DECREF(pyStr);
356  if (result)
357  Py_RETURN_TRUE;
358  else
359  Py_RETURN_FALSE;
360  }
361  catch (XmippError &xe)
362  {
363  PyErr_SetString(PyXmippError, xe.what());
364  }
365  }
366  return nullptr;
367 }
PyObject * PyXmippError
Definition: xmippmodule.cpp:47
bool checkImageFileSize(const FileName &name, const ImageInfo &imgInfo, bool error)

◆ xmipp_colorStr()

PyObject* xmipp_colorStr ( PyObject *  obj,
PyObject *  args 
)

Definition at line 74 of file xmippmodule.cpp.

75 {
76  char *str;
77  int color;
78  int attrib = BRIGHT;
79  if (PyArg_ParseTuple(args, "is|i", &color, &str, &attrib))
80  {
81  String labelStr = colorString(str, color, attrib);
82  return PyUnicode_FromString(labelStr.c_str());
83  }
84  return nullptr;
85 }
String colorString(const char *msg, int color, int attribute, int bgcolor)
Definition: xmipp_color.cpp:28
std::string String
Definition: xmipp_strings.h:34

◆ xmipp_compareTwoFiles()

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

Definition at line 427 of file xmippmodule.cpp.

428 {
429  PyObject *filename1;
430  PyObject *filename2;
431  size_t offset=0;
432  if (PyArg_ParseTuple(args, "OO|i", &filename1, &filename2, &offset))
433  {
434  try
435  {
436  PyObject * pyStr1 = PyObject_Str(filename1);
437  PyObject * pyStr2 = PyObject_Str(filename2);
438 
439  auto * str1 = (char*)PyUnicode_AsUTF8(pyStr1);
440  auto * str2 = (char*)PyUnicode_AsUTF8(pyStr2);
441  bool result = compareTwoFiles(str1, str2, offset);
442  Py_DECREF(pyStr1);
443  Py_DECREF(pyStr2);
444  if (result)
445  Py_RETURN_TRUE;
446  else
447  Py_RETURN_FALSE;
448  }
449  catch (XmippError &xe)
450  {
451  PyErr_SetString(PyXmippError, xe.what());
452  }
453  }
454  return nullptr;
455 }
PyObject * PyXmippError
Definition: xmippmodule.cpp:47
bool compareTwoFiles(const FileName &fn1, const FileName &fn2, size_t offset)
binary comparison of two files skipping first "offset" bytes

◆ xmipp_compareTwoImageTolerance()

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

Definition at line 514 of file xmippmodule.cpp.

515 {
516  PyObject *input1;
517  PyObject *input2;
518  double tolerance=0.;
519 
520  if (PyArg_ParseTuple(args, "OO|d", &input1, &input2, &tolerance))
521 
522  {
523  try
524  {
525  size_t index1 = 0;
526  size_t index2 = 0;
527  char * fn1;
528  char * fn2;
529 
530  // If the inputs objects are tuples, consider it (index, filename)
531  if (PyTuple_Check(input1))
532  {
533  // Get the index and filename from the Python tuple object
534  index1 = PyLong_AsSsize_t(PyTuple_GetItem(input1, 0));
535  fn1 = (char*)PyUnicode_AsUTF8(PyObject_Str(PyTuple_GetItem(input1, 1)));
536  }
537  else
538  fn1 = (char*)PyUnicode_AsUTF8(PyObject_Str(input1));
539 
540  if (PyTuple_Check(input2))
541  {
542  // Get the index and filename from the Python tuple object
543  index2 = PyLong_AsSsize_t(PyTuple_GetItem(input2, 0));
544  fn2 = (char*)PyUnicode_AsUTF8(PyObject_Str(PyTuple_GetItem(input2, 1)));
545  }
546  else
547  fn2 = (char*)PyUnicode_AsUTF8(PyObject_Str(input2));
548 
549  bool result = compareTwoImageTolerance(fn1, fn2, tolerance, index1, index2);
550 
551  if (result)
552  Py_RETURN_TRUE;
553  else
554  Py_RETURN_FALSE;
555  }
556  catch (XmippError &xe)
557  {
558  PyErr_SetString(PyXmippError, xe.what());
559  }
560  }
561  return nullptr;
562 }
PyObject * PyXmippError
Definition: xmippmodule.cpp:47
bool compareTwoImageTolerance(const FileName &fn1, const FileName &fn2, double tolerance, size_t index1, size_t index2)
binary comparison of two images with a tolerance factor

◆ xmipp_compareTwoMetadataFiles()

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

Definition at line 686 of file xmippmodule.cpp.

687 {
688  PyObject *pyStrFn1;
689  PyObject *pyStrFn2;
690  PyObject *pyStrAux;
691 
692  if (PyArg_ParseTuple(args, "OO", &pyStrFn1, &pyStrFn2))
693  {
694  try
695  {
696  FileName fn1;
697  FileName fn2;
698 
699  pyStrAux = PyObject_Str(pyStrFn1);
700 
701  if (pyStrAux != nullptr)
702  fn1 = (char*)PyUnicode_AsUTF8(pyStrAux);
703  else
704  PyErr_SetString(PyExc_TypeError, "Expected string or FileName as first argument");
705 
706  pyStrAux = PyObject_Str(pyStrFn2);
707  if (pyStrAux != nullptr)
708  fn2 = (char*)PyUnicode_AsUTF8(pyStrAux);
709 
710  else
711  PyErr_SetString(PyExc_TypeError,
712  "Expected string or FileName as first argument");
713 
714  if (compareTwoMetadataFiles(fn1, fn2))
715  Py_RETURN_TRUE;
716  else
717  Py_RETURN_FALSE;
718  }
719  catch (XmippError &xe)
720  {
721  PyErr_SetString(PyXmippError, xe.what());
722  }
723  }
724  return nullptr;
725 }
PyObject * PyXmippError
Definition: xmippmodule.cpp:47
bool compareTwoMetadataFiles(const FileName &fn1, const FileName &fn2)

◆ xmipp_createEmptyFile()

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

Definition at line 195 of file xmippmodule.cpp.

196 {
197  int Xdim;
198  int Ydim;
199  int Zdim=1;
200  size_t Ndim=1;
201  DataType dataType = DT_Float;
202 
203  PyObject * input;
204  if (PyArg_ParseTuple(args, "Oii|iii", &input, &Xdim, &Ydim, &Zdim,
205  &Ndim, &dataType))
206  {
207  try
208  {
209 
210  auto inputStr = (std::string)(char*)PyUnicode_AsUTF8(PyObject_Str(input));
211  inputStr += "%";
212  inputStr += datatype2Str(dataType);
213  createEmptyFile(inputStr, Xdim, Ydim, Zdim, Ndim, true, WRITE_REPLACE);
214  Py_RETURN_NONE;
215  }
216  catch (XmippError &xe)
217  {
218  PyErr_SetString(PyXmippError, xe.what());
219  }
220  }
221  return nullptr;
222 }
std::string datatype2Str(DataType datatype)
PyObject * PyXmippError
Definition: xmippmodule.cpp:47
DataType
void createEmptyFile(const FileName &filename, int xdim, int ydim, int Zdim, size_t select_img, bool isStack, int mode, int _swapWrite, const MDRowVec *md)

◆ xmipp_dumpToFile()

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

Definition at line 753 of file xmippmodule.cpp.

754 {
755  PyObject *pyStrFn;
756  PyObject *pyStrAux;
757  FileName fn;
758 
759  if (PyArg_ParseTuple(args, "O", &pyStrFn))
760  {
761  pyStrAux = PyObject_Str(pyStrFn);
762  if (pyStrAux != nullptr)
763  {
764  fn = (char*)PyUnicode_AsUTF8(pyStrAux);
765  MDSql::dumpToFile(fn);
766  Py_RETURN_NONE;
767  }
768  }
769  return nullptr;
770 }
static void dumpToFile(const FileName &fileName)

◆ xmipp_Euler_angles2matrix()

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

Definition at line 773 of file xmippmodule.cpp.

774 {
775  import_array();
776  double rot;
777  double tilt;
778  double psi;
779  if (PyArg_ParseTuple(args, "ddd", &rot,&tilt,&psi))
780  {
781  npy_intp dims[2];
782  dims[0] = 3;
783  dims[1] = 3;
784  auto * arr = (PyArrayObject*) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
785  void * data = PyArray_DATA(arr);
786  Matrix2D<double> euler(3,3);
787  Euler_angles2matrix(rot, tilt, psi,euler,false);
788  memcpy(data, (euler.mdata), 9 * sizeof(double));
789  return (PyObject*)arr;
790  }
791  return nullptr;
792 }
void Euler_angles2matrix(T alpha, T beta, T gamma, Matrix2D< T > &A, bool homogeneous)
Definition: geometry.cpp:624
double psi(const double x)

◆ xmipp_Euler_direction()

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

Definition at line 834 of file xmippmodule.cpp.

835 {
836  double rot;
837  double tilt;
838  double psi;
839  if (PyArg_ParseTuple(args, "ddd", &rot,&tilt,&psi))
840  {
842  Euler_direction(rot, tilt, psi, direction);
843  return Py_BuildValue("fff", VEC_ELEM(direction, 0), VEC_ELEM(direction, 1), VEC_ELEM(direction, 2));//fff three real
844  }
845  return nullptr;
846 }
#define VEC_ELEM(v, i)
Definition: matrix1d.h:245
void Euler_direction(double alpha, double beta, double gamma, Matrix1D< double > &v)
Definition: geometry.cpp:721
void direction(const MultidimArray< double > &orMap, MultidimArray< double > &qualityMap, double lambda, int size, MultidimArray< double > &dirMap, int x, int y)
double psi(const double x)

◆ xmipp_getImageSize()

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

Definition at line 225 of file xmippmodule.cpp.

226 {
227  PyObject *pyValue;
228 
229  if (PyArg_ParseTuple(args, "O", &pyValue))
230  {
231  try
232  {
233 
234  PyObject * pyStr = PyObject_Str(pyValue);
235  auto *str = (char*)PyUnicode_AsUTF8(pyStr);
236  size_t xdim;
237  size_t ydim;
238  size_t zdim;
239  size_t ndim;
240  getImageSize(str, xdim, ydim, zdim, ndim);
241  Py_DECREF(pyStr);
242  return Py_BuildValue("kkkk", xdim, ydim, zdim, ndim);
243  }
244  catch (XmippError &xe)
245  {
246  PyErr_SetString(PyXmippError, xe.what());
247  }
248  }
249  return nullptr;
250 }
PyObject * PyXmippError
Definition: xmippmodule.cpp:47
void getImageSize(const MetaData &md, size_t &Xdim, size_t &Ydim, size_t &Zdim, size_t &Ndim, MDLabel image_label)

◆ xmipp_ImgCompare()

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

Definition at line 396 of file xmippmodule.cpp.

397 {
398  PyObject *filename1;
399  PyObject *filename2;
400 
401  if (PyArg_ParseTuple(args, "OO", &filename1, &filename2))
402  {
403  try
404  {
405  PyObject * pyStr1 = PyObject_Str(filename1);
406  PyObject * pyStr2 = PyObject_Str(filename2);
407 
408  auto * str1 = (char*)PyUnicode_AsUTF8(pyStr1);
409  auto * str2 = (char*)PyUnicode_AsUTF8(pyStr2);
410  bool result = compareImage(str1, str2);
411  Py_DECREF(pyStr1);
412  Py_DECREF(pyStr2);
413  if (result)
414  Py_RETURN_TRUE;
415  else
416  Py_RETURN_FALSE;
417  }
418  catch (XmippError &xe)
419  {
420  PyErr_SetString(PyXmippError, xe.what());
421  }
422  }
423  return nullptr;
424 }
PyObject * PyXmippError
Definition: xmippmodule.cpp:47
bool compareImage(const FileName &filename1, const FileName &filename2)
compare two image files

◆ xmipp_ImgSize()

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

◆ xmipp_isValidLabel()

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

Definition at line 176 of file xmippmodule.cpp.

177 {
178  char *str;
179  int label;
180  if (PyArg_ParseTuple(args, "s", &str))
181  label = MDL::str2Label(str);
182  else if (PyArg_ParseTuple(args, "i", &label))
183  ;
184  else
185  return nullptr;
186  if (MDL::isValidLabel((MDLabel) label))
187  Py_RETURN_TRUE;
188  else
189  Py_RETURN_FALSE;
190 }
static MDLabel str2Label(const String &labelName)
static bool isValidLabel(const MDLabel &label)
MDLabel

◆ xmipp_label2Str()

PyObject* xmipp_label2Str ( PyObject *  obj,
PyObject *  args 
)

Definition at line 62 of file xmippmodule.cpp.

63 {
64  int label;
65  if (PyArg_ParseTuple(args, "i", &label))
66  {
67  String labelStr = MDL::label2Str((MDLabel) label);
68  return PyUnicode_FromString(labelStr.c_str());
69  }
70  return nullptr;
71 }
std::string String
Definition: xmipp_strings.h:34
static String label2Str(const MDLabel &label)
MDLabel

◆ xmipp_labelHasTag()

PyObject* xmipp_labelHasTag ( PyObject *  obj,
PyObject *  args 
)

Definition at line 109 of file xmippmodule.cpp.

110 {
111  PyObject * input;
112  PyObject* str_exc_type = nullptr;
113  PyObject* pyStr = nullptr;
114  int tag;
115 
116  if (PyArg_ParseTuple(args, "Oi", &input, &tag))
117  {
118  MDLabel label = MDL_UNDEFINED;
119 
120  if (PyUnicode_Check(input))
121  {
122 // str_exc_type = PyObject_Repr(input); //Now a unicode object
123 // pyStr = PyUnicode_AsEncodedString(str_exc_type, "utf-8", "Error ~");
124 // label = MDL::str2Label(PyBytes_AS_STRING(pyStr));
125  label = MDL::str2Label((char*)PyUnicode_AsUTF8(input));
126  }
127  else if (PyLong_Check(input))
128  label = (MDLabel) PyLong_AsLong(input);
129 
130  if (label != MDL_UNDEFINED)
131  {
132  if (MDL::hasTag(label, tag))
133  Py_RETURN_TRUE;
134  else
135  Py_RETURN_FALSE;
136  }
137 
138  PyErr_SetString(PyExc_TypeError,
139  "labelHasTag: Input label should be int or string");
140  }
141  return nullptr;
142 }
static MDLabel str2Label(const String &labelName)
static bool hasTag(const MDLabel label, const int tags)
MDLabel

◆ xmipp_labelIsImage()

PyObject* xmipp_labelIsImage ( PyObject *  obj,
PyObject *  args 
)

Definition at line 145 of file xmippmodule.cpp.

146 {
147  PyObject * input;
148  int tag = TAGLABEL_IMAGE;
149 
150  if (PyArg_ParseTuple(args, "O", &input))
151  {
152  MDLabel label = MDL_UNDEFINED;
153 
154  if (PyUnicode_Check(input))
155  label = MDL::str2Label((char*)PyUnicode_AsUTF8(PyObject_Str(input)));
156 
157  else if (PyLong_Check(input))
158  label = (MDLabel) PyLong_AsLong(input);
159 
160  if (label != MDL_UNDEFINED)
161  {
162  if (MDL::hasTag(label, tag))
163  Py_RETURN_TRUE;
164  else
165  Py_RETURN_FALSE;
166  }
167 
168  PyErr_SetString(PyExc_TypeError,
169  "labelIsImage: Input label should be int or string");
170  }
171  return nullptr;
172 }
static MDLabel str2Label(const String &labelName)
static bool hasTag(const MDLabel label, const int tags)
MDLabel

◆ xmipp_labelType()

PyObject* xmipp_labelType ( PyObject *  obj,
PyObject *  args 
)

Definition at line 88 of file xmippmodule.cpp.

89 {
90  PyObject * input;
91  PyObject* str_exc_type = nullptr;
92  PyObject* pyStr = nullptr;
93  if (PyArg_ParseTuple(args, "O", &input))
94  {
95  if (PyUnicode_Check(input))
96  return Py_BuildValue("i", (int) MDL::labelType((char*)PyUnicode_AsUTF8(PyObject_Str(input))));
97 
98  else if (PyLong_Check(input))
99  return Py_BuildValue("i", (int) MDL::labelType((MDLabel) PyLong_AsLong(input)));
100 
101  else
102  PyErr_SetString(PyExc_TypeError,
103  "labelType: Only int or string are allowed as input");
104  }
105  return nullptr;
106 }
static MDLabelType labelType(const MDLabel label)
MDLabel

◆ xmipp_readMetaDataWithTwoPossibleImages()

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

Definition at line 569 of file xmippmodule.cpp.

571 {
572  PyObject *pyStr;
573  PyObject *pyMd; //Only used to skip label and value
574 
575  if (PyArg_ParseTuple(args, "OO", &pyStr, &pyMd))
576  {
577  try
578  {
579  if (!MetaData_Check(pyMd))
580  PyErr_SetString(PyExc_TypeError,
581  "Expected MetaData as second argument");
582  else
583  {
584  if (PyUnicode_Check(pyStr))
585  {
586  readMetaDataWithTwoPossibleImages((char*)PyUnicode_AsUTF8(pyStr),
587  MetaData_Value(pyMd));
588  }
589  else if (FileName_Check(pyStr))
591  MetaData_Value(pyMd));
592  else
593  PyErr_SetString(PyExc_TypeError,
594  "Expected string or FileName as first argument");
595  Py_RETURN_NONE;
596  }
597  }
598  catch (XmippError &xe)
599  {
600  PyErr_SetString(PyXmippError, xe.what());
601  }
602  }
603  return nullptr;
604 }
#define FileName_Check(v)
PyObject * PyXmippError
Definition: xmippmodule.cpp:47
#define MetaData_Check(v)
#define FileName_Value(v)
void readMetaDataWithTwoPossibleImages(const FileName &fn, MetaData &md)
#define MetaData_Value(v)

◆ xmipp_str2Label()

PyObject* xmipp_str2Label ( PyObject *  obj,
PyObject *  args 
)

Definition at line 53 of file xmippmodule.cpp.

54 {
55  char * str;
56  if (PyArg_ParseTuple(args, "s", &str))
57  return Py_BuildValue("i", (int) MDL::str2Label(str));
58  return nullptr;
59 }
static MDLabel str2Label(const String &labelName)

◆ xmipp_substituteOriginalImages()

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

Definition at line 608 of file xmippmodule.cpp.

609 {
610  PyObject *pyStrFn;
611  PyObject *pyStrFnOrig;
612  PyObject *pyStrFnOut;
613  int label;
614  int skipFirstBlock;
615 
616  if (PyArg_ParseTuple(args, "OOOii", &pyStrFn, &pyStrFnOrig, &pyStrFnOut,
617  &label, &skipFirstBlock))
618  {
619  try
620  {
621  FileName fn;
622  FileName fnOrig;
623  FileName fnOut;
624  if (PyUnicode_Check(pyStrFn))
625  fn = (char*)PyUnicode_AsUTF8(pyStrFn);
626 
627  else if (FileName_Check(pyStrFn))
628  fn = FileName_Value(pyStrFn);
629  else
630  PyErr_SetString(PyExc_TypeError,
631  "Expected string or FileName as first argument");
632 
633  if (PyUnicode_Check(pyStrFnOrig))
634  fnOrig = (char*)PyUnicode_AsUTF8(pyStrFnOrig);
635 
636  else if (FileName_Check(pyStrFnOrig))
637  fnOrig = FileName_Value(pyStrFnOrig);
638  else
639  PyErr_SetString(PyExc_TypeError,
640  "Expected string or FileName as second argument");
641 
642  if (PyUnicode_Check(pyStrFnOut))
643  fnOut = (char*)PyUnicode_AsUTF8(pyStrFnOut);
644 
645  else if (FileName_Check(pyStrFnOut))
646  fnOut = FileName_Value(pyStrFnOut);
647  else
648  PyErr_SetString(PyExc_TypeError,
649  "Expected string or FileName as third argument");
650 
651  substituteOriginalImages(fn, fnOrig, fnOut, (MDLabel) label,
652  (bool) skipFirstBlock);
653  Py_RETURN_NONE;
654  }
655  catch (XmippError &xe)
656  {
657  PyErr_SetString(PyXmippError, xe.what());
658  }
659  }
660  return nullptr;
661 }
#define FileName_Check(v)
PyObject * PyXmippError
Definition: xmippmodule.cpp:47
void substituteOriginalImages(const FileName &fn, const FileName &fnOrig, const FileName &fnOut, MDLabel label, bool skipFirstBlock)
FileName fnOut
#define FileName_Value(v)
MDLabel

Variable Documentation

◆ PyXmippError

PyObject* PyXmippError

Definition at line 47 of file xmippmodule.cpp.