scipion-em-xmipp 24.12.2__py3-none-any.whl → 25.6.0__py3-none-any.whl

xmipp3/tests/test_protocols_highres.py

@@ -89,17 +89,56 @@ class TestHighres(BaseTest):
                                    particleRadius=180,
                                    symmetryGroup="i1",
                                    nextResolutionCriterion=0.143,
-                                   alignmentMethod=XmippProtReconstructHighRes.AUTOMATIC_ALIGNMENT,
-                                   maximumTargetResolution="15 10 7",
-                                   numberOfMpi=8)
+                                   alignmentMethod=XmippProtReconstructHighRes.GLOBAL_ALIGNMENT,
+                                   numberOfIterations=1,
+                                   maximumTargetResolution="15",
+                                   numberOfMpi=8,
+                                   postSignificantDenoise=False,
+                                   postFilterBank=False,
+                                   postLaplacian=False,
+                                   postDeconvolve=False,
+                                   postSoftNeg=False,
+                                   postDifference=False)
+
         self.launchProtocol(highres)
         self.assertIsNotNone(highres.outputParticles,
                              "There was a problem with Highres")
 
-        fnResolution = highres._getExtraPath("Iter005/iterInfo.xmd")
+        fnResolution = highres._getExtraPath("Iter001/iterInfo.xmd")
+        if not exists(fnResolution):
+            self.assertTrue(False, fnResolution + " does not exist")
+        else:
+            md = emlib.MetaData("resolution@" + fnResolution)
+            R = md.getValue(emlib.MDL_RESOLUTION_FREQREAL, md.firstObject())
+            self.assertTrue(R < 12.5, "Resolution is not below 12.5A")
+
+        highresLocal = self.newProtocol(XmippProtReconstructHighRes,
+                                   inputParticles=subset.outputParticles,
+                                   inputVolumes=self.protImportVol.outputVolume,
+                                   continueRun=highres,
+                                   doContinue=True,
+                                   particleRadius=180,
+                                   symmetryGroup="i1",
+                                   nextResolutionCriterion=0.143,
+                                   alignmentMethod=XmippProtReconstructHighRes.LOCAL_ALIGNMENT,
+                                   numberOfIterations=1,
+                                   maximumTargetResolution="10",
+                                   numberOfMpi=8,
+                                   postSignificantDenoise=False,
+                                   postFilterBank=False,
+                                   postLaplacian=False,
+                                   postDeconvolve=False,
+                                   postSoftNeg=False,
+                                   postDifference=False)
+
+        self.launchProtocol(highresLocal)
+        self.assertIsNotNone(highresLocal.outputParticles,
+                             "There was a problem with Highres")
+
+        fnResolution = highresLocal._getExtraPath("Iter002/iterInfo.xmd")
         if not exists(fnResolution):
             self.assertTrue(False, fnResolution + " does not exist")
         else:
             md = emlib.MetaData("resolution@" + fnResolution)
             R = md.getValue(emlib.MDL_RESOLUTION_FREQREAL, md.firstObject())
-            self.assertTrue(R < 10, "Resolution is not below 10A")
+            self.assertTrue(R < 12.5, "Resolution is not below 12.5A")

xmipp3/tests/test_protocols_xmipp_2d.py

@@ -1453,54 +1453,6 @@ class TestXmippPickNoise(TestXmippBase):
         self.assertEquals(protPickNoise1.outputCoordinates.getSize(), 143, (MSG_WRONG_SIZE, "noisy particles"))
         self.assertEquals(protPickNoise2.outputCoordinates.getSize(), 140, (MSG_WRONG_SIZE, "noisy particles"))
 
-class TestXmippScreenDeepLearning(TestXmippBase):
-    """This class checks if the protocol screen deep learning in Xmipp works properly."""
-    @classmethod
-    def setUpClass(cls):
-        setupTestProject(cls)
-        cls.dataset = DataSet.getDataSet('xmipp_tutorial')
-
-    def testXmippScreenDeepLearning(self):
-        protImportParts1 = self.newProtocol(emprot.ProtImportParticles,
-                                            objLabel='First Set of Particles',
-                                            importFrom=emprot.ProtImportParticles.IMPORT_FROM_SCIPION,
-                                            sqliteFile=self.dataset.getFile('particles/BPV_particles.sqlite'),
-                                            magnification=50000,
-                                            samplingRate=7.08,
-                                            haveDataBeenPhaseFlipped=False)
-        self.launchProtocol(protImportParts1)
-        self.assertIsNotNone(protImportParts1.getFiles(), (MSG_WRONG_IMPORT, "the first set of particles"))
-
-        protImportParts2 = self.newProtocol(emprot.ProtImportParticles,
-                                            objLabel='Second Set of Particles',
-                                            importFrom=emprot.ProtImportParticles.IMPORT_FROM_SCIPION,
-                                            sqliteFile=self.dataset.getFile('particles/BPV_particles_aligned.sqlite'),
-                                            magnification=50000,
-                                            samplingRate=7.08,
-                                            haveDataBeenPhaseFlipped=False)
-        self.launchProtocol(protImportParts2)
-        self.assertIsNotNone(protImportParts2.getFiles(), (MSG_WRONG_IMPORT, "the second set of particles"))
-
-        protAddNoise = self.newProtocol(XmippProtAddNoiseParticles,
-                                        input=protImportParts1.outputParticles,
-                                        gaussianStd=15.0)
-        self.launchProtocol(protAddNoise)
-        self.assertIsNotNone(protAddNoise.outputParticles, (MSG_WRONG_PROTOCOL, "add noise"))
-
-        protScreenDeepLearning = self.newProtocol(XmippProtScreenDeepLearning,
-                                                  inTrueSetOfParticles=protImportParts1.outputParticles,
-                                                  numberOfNegativeSets=1,
-                                                  negativeSet_1=protAddNoise.outputParticles,
-                                                  predictSetOfParticles=protImportParts2.outputParticles)
-        self.launchProtocol(protScreenDeepLearning)
-        self.assertIsNotNone(protScreenDeepLearning.getFiles(), (MSG_WRONG_PROTOCOL, "screen deep learning"))
-        self.assertIsNotNone(protScreenDeepLearning.outputParticles, (MSG_WRONG_OUTPUT, "particles"))
-        # Check the size of the output particles
-        self.assertEquals(protScreenDeepLearning.outputParticles.getSize(), 373, (MSG_WRONG_SIZE, "particles"))
-        # Check the dimensions of the first particle
-        self.assertEquals(protScreenDeepLearning.outputParticles.getFirstItem().getDim(), (140, 140, 1), (MSG_WRONG_DIM, "particles"))
-        # Check the sampling rate of the first particle
-        self.assertEqual(protScreenDeepLearning.outputParticles.getFirstItem().getSamplingRate(), 7.08, (MSG_WRONG_SAMPLING, "particles"))
 
 class TestXmippClassifyPca(TestXmippBase):
     """This class check if the protocol Classify PCA (static and in streaming) in Xmipp works properly."""
@@ -1601,6 +1553,7 @@ class TestXmippClassifyPca(TestXmippBase):
 
         self.assertSetSize(prot.outputClasses, size, msg)
 
+
 class TestXmippProtCL2DClustering(TestXmippBase):
     """This class check if the protocol clustering 2d classes in Xmipp works properly."""
 

xmipp3/tests/test_protocols_xmipp_mics.py

@@ -532,7 +532,7 @@ class TestXmippExtractParticles(TestXmippBase):
                              %(micNameCoord, micNamePart))
         compare(83)
         compare(228)
-        self._checkVarianceAndGiniCoeff(outputParts[170], 1.1640, 0.5190)
+        self._checkVarianceAndGiniCoeff(outputParts[170], 1.3000, 0.40817)
 
     def testExtractOriginal(self):
         print("Run extract particles from the original micrographs")
@@ -573,7 +573,7 @@ class TestXmippExtractParticles(TestXmippBase):
                          "Output sampling rate should be equal to input "
                          "sampling rate.")
         self._checkSamplingConsistency(outputParts)
-        self._checkVarianceAndGiniCoeff(outputParts[170], 1.2081, 0.5754)
+        self._checkVarianceAndGiniCoeff(outputParts[170], 1.2859, 0.3991)
 
     def testNoExtractBorders(self):
         print("Run extract particles avoiding extract in borders")
@@ -620,7 +620,7 @@ class TestXmippExtractParticles(TestXmippBase):
         self.assertAlmostEquals(outputParts.getSize(), 403, delta=1)
         self._checkSamplingConsistency(outputParts)
         # Particle 335 is outbourder with this boxsize. Checking it...
-        self._checkVarianceAndGiniCoeff(outputParts[335], 1.2191, 0.5795)
+        self._checkVarianceAndGiniCoeff(outputParts[335], 1.2101, 0.7079)
 
     def testExtractOther(self):
         print("Run extract particles from original micrographs, with downsampling")
@@ -671,7 +671,7 @@ class TestXmippExtractParticles(TestXmippBase):
         for particle in outputParts:
             self.assertTrue(particle.getCoordinate().getMicId() in micsId)
             self.assertAlmostEqual(outputSampling, particle.getSamplingRate())
-        self._checkVarianceAndGiniCoeff(outputParts[170], 1.099442, 0.396918)
+        self._checkVarianceAndGiniCoeff(outputParts[170], 1.00277, 0.42318)
 
     def testExtractNoise(self):
         # here we will try a different patchSize than the default
@@ -694,7 +694,7 @@ class TestXmippExtractParticles(TestXmippBase):
         outputParts = protExtract.outputParticles
         self.assertIsNotNone(outputParts, "There was a problem generating the output.")
         self.assertAlmostEquals(outputParts.getSize(), 403, delta=1)
-        self._checkVarianceAndGiniCoeff(outputParts[170], 1.161262, 0.5702)
+        self._checkVarianceAndGiniCoeff(outputParts[170], 1.0374, 0.476623)
 
     def testExtractCTF(self):
         print("Run extract particles with CTF")
@@ -738,7 +738,7 @@ class TestXmippExtractParticles(TestXmippBase):
                              "There was a problem generating the output.")
         self.assertTrue(outputParts.hasCTF(), "Output does not have CTF.")
         self._checkSamplingConsistency(outputParts)
-        self._checkVarianceAndGiniCoeff(outputParts[170], 1.1640, 0.5190)
+        self._checkVarianceAndGiniCoeff(outputParts[170], 1.3000, 0.4082)
 
 
 class TestXmippVarianceFiltering(TestXmippBase):
@@ -960,26 +960,28 @@ class TestXmippParticlesPickConsensus(TestXmippBase):
         self.proj.launchProtocol(protAutomaticPP, wait=True)
 
         # NON streaming tests
-        protCons1 = self.newProtocol(XmippProtConsensusPicking,
-                                     objLabel="Xmipp - consensus pick AND")
+        protCons1 = self.newProtocol(XmippProtConsensusPicking)
+        protCons1.setObjLabel("Xmipp - consensus pick AND")
+
         protCons1.inputCoordinates.set([self.protFaPi.outputCoordinates,
                                         protAutomaticPP.outputCoordinates])
         self.launchProtocol(protCons1)
 
         self.assertTrue(protCons1.isFinished(), "Consensus failed")
-        self.assertSetSize(protCons1.consensusCoordinates,382,
+        self.assertSetSize(protCons1.consensusCoordinates,306,
                         "Output coordinates size for AND consensus is wrong.")
 
         protConsOr = self.newProtocol(XmippProtConsensusPicking,
-                                      objLabel="Xmipp - consensus pick OR",
                                       consensus=1)
+        protConsOr.setObjLabel("Xmipp - consensus pick OR")
+
         protConsOr.inputCoordinates.set(
             [Pointer(self.protFaPi, extended="outputCoordinates"),
              Pointer(protAutomaticPP, extended="outputCoordinates")])
         self.launchProtocol(protConsOr)
 
         self.assertTrue(protConsOr.isFinished(), "Consensus failed")
-        self.assertSetSize(protConsOr.consensusCoordinates, 432,
+        self.assertSetSize(protConsOr.consensusCoordinates, 439,
                         "Output coordinates size for OR consensus is wrong.")
 
         kwargs = {'nDim': 3,  # 3 objects
@@ -1000,8 +1002,9 @@ class TestXmippParticlesPickConsensus(TestXmippBase):
         self._waitOutput(protAutoPP, 'outputCoordinates')
 
         # Consensus Picking launching
-        protCons2 = self.newProtocol(XmippProtConsensusPicking,
-                                     objLabel="Xmipp - consensus pick streaming")
+        protCons2 = self.newProtocol(XmippProtConsensusPicking)
+        protCons2.setObjLabel("Xmipp - consensus streaming")
+
         protCons2.inputCoordinates.set(
             [Pointer(self.protFaPi, extended="outputCoordinates"),
              Pointer(protAutoPP, extended="outputCoordinates")])
@@ -1009,17 +1012,18 @@ class TestXmippParticlesPickConsensus(TestXmippBase):
 
         # Remove Duplicates launching
         protDupl2 = self.newProtocol(XmippProtPickingRemoveDuplicates,
-                                     objLabel="Xmipp - remove duplicates streaming",
                                      consensusRadius=110)
+        protDupl2.setObjLabel("Xmipp - remove duplicates streaming")
+
         protDupl2.inputCoordinates.set(protAutoPP.outputCoordinates)
         self.proj.launchProtocol(protDupl2, wait=True)  # don't wait to make the final checks
 
         time.sleep(3)  # protDupl2 should be as long as protCons2, but just in case
         protCons2 = self._updateProtocol(protCons2)
-        self.assertSetSize(protCons2.consensusCoordinates, 382,
+        self.assertSetSize(protCons2.consensusCoordinates, 306,
                         "Output coordinates size does not is wrong.")
         protDupl2 = self._updateProtocol(protDupl2)
-        self.assertSetSize(protDupl2.outputCoordinates, 245,
+        self.assertSetSize(protDupl2.outputCoordinates, 203,
                         "Output coordinates size does not is wrong.")
 
 

xmipp3/tests/test_protocols_xmipp_movies.py

@@ -30,6 +30,7 @@ from pyworkflow.tests import *
 
 from xmipp3.convert import *
 from xmipp3.protocols import *
+from pwem.objects import SetOfMovies, MovieAlignment
 from pwem.protocols import ProtImportMovies, ProtImportCoordinates
 import pyworkflow.utils as pwutils
 from contextlib import redirect_stdout
@@ -774,8 +775,7 @@ class TestMovieAlignmentConsensus(BaseTest):
         self.launchProtocol(protConsensus1)
 
         sizeAccepted = protConsensus1.outputMovies.getSize()
-        self.assertEqual(sizeAccepted, 2, 'Number of accepted movies must be 2 and its '
-                                           '%d' % sizeAccepted)
+        self.assertEqual(sizeAccepted, 2, 'Number of accepted movies must be 2 and its %d' % sizeAccepted)
 
     def testMovieAlignmentConsensusFiltering2(self):
         """ This must discard movies by movie alignment consensus.
@@ -784,6 +784,7 @@ class TestMovieAlignmentConsensus(BaseTest):
         protConsensus2 = self.newProtocol(XmippProtConsensusMovieAlignment,
                                           objLabel=label,
                                           minConsCorrelation=0.9,
+                                          minRangeShift=0.01,
                                           trajectoryPlot=True
                                           )
 
@@ -796,5 +797,4 @@ class TestMovieAlignmentConsensus(BaseTest):
         self.launchProtocol(protConsensus2)
 
         sizeDiscarded = protConsensus2.outputMoviesDiscarded.getSize()
-        self.assertEqual(sizeDiscarded, 2, 'Number of accepted movies must be 2 and its '
-                                           '%d' % sizeDiscarded)
+        self.assertEqual(sizeDiscarded, 2, 'Number of discarded movies must be 0 and its %d' % sizeDiscarded)

xmipp3/version.py

@@ -28,11 +28,11 @@
 type_of_version = 'release' #'release' 'devel'
 _logo = "xmipp_logo" + ("" if type_of_version == 'release' else '_devel') + '.png'
 
-_binVersion = 'v3.24.12.0' # Increase it if hotfix in binaries (xmipp, xmippCore and/or XmippViz)
-_pluginVersion = 'v3.24.12.2' # Increase it if hotfix in binaries (xmipp, xmippCore and/or XmippViz) or in scipion-em-xmipp
+_binVersion = 'v3.25.06.0' # Increase it if hotfix in binaries (xmipp, xmippCore and/or XmippViz)
+_pluginVersion = 'v3.25.06.0' # Increase it if hotfix in binaries (xmipp, xmippCore and/or XmippViz) or in scipion-em-xmipp
 
-_binTagVersion = _binVersion + '-Poseidon' #'devel' or _binVersion + '-Poseidon'
-_pluginTagVersion = _pluginVersion + '-Poseidon'  #'devel' or _pluginVersion + '-Poseidon'
+_binTagVersion = _binVersion + '-Rhea' #'devel' or _binVersion + '-Poseidon'
+_pluginTagVersion = _pluginVersion + '-Rhea'  #'devel' or _pluginVersion + '-Poseidon'
 
 _currentDepVersion = '1.0'
-__version__ = _pluginVersion # Name of the pypi package
+__version__ = _pluginVersion[3:] # Name of the pypi package

xmipp3/viewers/__init__.py

@@ -27,7 +27,6 @@
 from .viewer import XmippViewer
 from .plotter import XmippPlotter
 
-#from .viewer_angular_resolution_alignment import XmippProtAngResAlignViewer
 from .viewer_apply_tilt_to_ctf import XmippApplyTiltToCTFViewer
 from .viewer_cl2d import XmippCL2DViewer
 from .viewer_ctf_consensus import XmippCTFConsensusViewer
@@ -61,6 +60,7 @@ from .viewer_cl2d_clustering import XmippCL2DClusteringViewer
 #from .viewer_combine_pdb import XmippProtCombinePdbViewer
 
 from .viewer_projmatch import XmippProjMatchViewer
+from .viewer_LL_matrix import XmippLogLikelihoodViewer
 
 from .viewer_volume_deform_zernike3d import XmippVolumeDeformZernike3DViewer
 from .viewer_structure_map import XmippProtStructureMapViewer

xmipp3/viewers/viewer_LL_matrix.py

@@ -0,0 +1,273 @@
+# **************************************************************************
+# *
+# * Authors:     J.M. De la Rosa Trevin (jmdelarosa@cnb.csic.es)
+# *              Slavica Jonic  (slavica.jonic@upmc.fr)
+# *              James Krieger (jmkrieger@cnb.csic.es)
+# *              Ricardo Serrano Gutiérrez (rserranogut@hotmail.com)  
+# *
+# * This program is free software; you can redistribute it and/or modify
+# * it under the terms of the GNU General Public License as published by
+# * the Free Software Foundation; either version 2 of the License, or
+# * (at your option) any later version.
+# *
+# * This program is distributed in the hope that it will be useful,
+# * but WITHOUT ANY WARRANTY; without even the implied warranty of
+# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# * GNU General Public License for more details.
+# *
+# * You should have received a copy of the GNU General Public License
+# * along with this program; if not, write to the Free Software
+# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+# * 02111-1307  USA
+# *
+# *  All comments concerning this program package may be sent to the
+# *  e-mail address 'scipion@cnb.csic.es'
+# *
+# **************************************************************************
+"""
+This module implement the wrappers around ProDy GNM 
+visualization programs.
+"""
+import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
+import numpy as np
+import os
+
+from pwem.viewers.plotter import EmPlotter
+from pwem.objects.data import Volume
+
+from pyworkflow.protocol.params import LabelParam, IntParam, FloatParam, BooleanParam
+from pyworkflow.viewer import ProtocolViewer, DESKTOP_TKINTER, WEB_DJANGO
+
+from xmipp3.protocols.protocol_compute_likelihood import XmippProtComputeLikelihood
+
+_invalidInputStr = 'Invalid input'
+
+class XmippLogLikelihoodViewer(ProtocolViewer):
+    """ Visualization of results from the Xmipp log likelihood protocol.
+    """
+    _label = 'Log likelihood matrix viewer'
+    _targets = [XmippProtComputeLikelihood]
+    _environments = [DESKTOP_TKINTER, WEB_DJANGO]
+    
+    def _defineParams(self, form):
+
+        self.particles = self.protocol.inputParticles.get()
+        self.refs = self.protocol.inputRefs.get()
+        self.outputs = self.protocol.reprojections
+
+        if isinstance(self.refs, Volume):
+            self.refs = [self.refs]
+
+        form.addSection(label='Visualization')
+
+        group = form.addGroup('Particles range')
+        group.addParam('partNumber1', IntParam, default=-1,
+                      label='Initial particle id',
+                      help='')
+        group.addParam('partNumber2', IntParam, default=-1,
+                      label='Final particle id')
+        
+        group = form.addGroup('Volumes range')
+        group.addParam('volNumber1', IntParam, default=-1,
+                      label='Initial volume number')
+        group.addParam('volNumber2', IntParam, default=-1,
+                      label='Final volume number')
+
+        group = form.addGroup('Values for matrix plot')
+        group.addParam('normalise', BooleanParam, default=False,
+                      label='Normalise LL matrix by dividing by mean value of each column?',
+                      help='This may increase the contrast to help with interpretability. '
+                           'Note: we keep the sign negative to keep the order of values.')
+
+        group.addParam('subtract', BooleanParam, default=True,
+                      label='Shift LL matrix by subtracting mean value of each column?',
+                      help='This may increase the contrast to help with interpretability. ')
+
+        group.addParam('vmin', FloatParam, default=-1,
+                      label='Minimum blue value',
+                      help='All values below this will be coloured blue if not -1')
+        group.addParam('vmax', FloatParam, default=-1,
+                      label='Maximum yellow value',
+                      help='All values above this will be coloured yellow if not -1')
+        group.addParam('percentile', FloatParam, default=-1,
+                      label='Percentile alternative to vmin and vmax',
+                      help='If either of the above values is -1, they will be estimated as this percentile')
+
+        group.addParam('displayLL', LabelParam, default=False,
+                label="Plot log likelihood matrix?",
+                help="Matrices are shown as heatmaps.")
+        
+        group = form.addGroup('Values for histogram')
+        group.addParam('nBins', IntParam, default=100, label='Number of bins for histogram')
+
+        group.addParam('vminH', FloatParam, default=-1,
+                      label='Minimum axis value',
+                      help='All values below this will be cropped off the axis if not -1')
+        group.addParam('vmaxH', FloatParam, default=-1,
+                      label='Maximum axis value',
+                      help='All values above this will be cropped off the axis if not -1')
+        group.addParam('percentileH', FloatParam, default=-1,
+                      label='Percentile alternative to axis vmin and vmax',
+                      help='If either of the above values is -1, they will be estimated as this percentile')
+
+        group.addParam('displayRelativeLL', LabelParam, default=False,
+                label="Plot relative log likelihood histogram?",
+                help="Subtracted log likelihood is shown as a histogram.")
+
+    def _getVisualizeDict(self):
+        return {'displayLL': self._viewLL,
+                'displayRelativeLL': self._viewRelativeLL}
+
+    def _viewLL(self, paramName):
+        """ visualization of log likelihood matrix for selected particles and ref volumes."""
+        x = self._checkNumbers('particle')
+        if x is not True:
+            return x
+
+        x = self._checkNumbers('volume')
+        if x is not True:
+            return x
+        
+        matrix = np.load(self.protocol._getExtraPath('matrix.npy'))
+
+        if self.normalise.get():
+            matrix = np.divide(matrix, np.mean(matrix, axis=0)) * np.sign(np.mean(matrix))
+
+        elif self.subtract.get():
+            matrix = np.subtract(matrix, np.mean(matrix, axis=0))
+
+        if self.vmin.get() != -1:
+            vmin = self.vmin.get()
+        elif self.percentile.get() != -1:
+            vmin = np.percentile(matrix, self.percentile.get())
+        else:
+            vmin = None
+
+        if self.vmax.get() != -1:
+            vmax = self.vmax.get()
+        elif self.percentile.get() != -1:
+            vmax = np.percentile(matrix, 100-self.percentile.get())
+        else:
+            vmax = None
+
+        plotter = EmPlotter()
+        im = plt.imshow(matrix, aspect='auto',
+                        vmin=vmin, vmax=vmax)
+        plt.colorbar(mappable=im)
+
+        plt.ylabel('Reference volumes')
+        plt.ylim([self.volNum1-1.5, self.volNum2-0.5])
+        ylocs, _ = plt.yticks()
+        plt.yticks([int(loc) for loc in ylocs[:-1] if loc >= self.volNum1-1],
+                   [str(int(loc)+1) for loc in ylocs[:-1] if loc >= self.volNum1-1])
+
+        plt.xlabel('Input particles')
+        plt.xlim([self.partNum1-1.5, self.partNum2-0.5])
+        xlocs, _ = plt.xticks()
+        plt.xticks([int(loc) for loc in xlocs[:-1] if loc >= self.partNum1-1],
+                   [str(int(loc)+1) for loc in xlocs[:-1] if loc >= self.partNum1-1])
+
+        return [plotter]
+
+    def _viewRelativeLL(self, paramName):
+        """ visualization of relative log likelihood histogram for  for selected particles and ref volumes."""
+        x = self._checkNumbers('particle')
+        if x is not True:
+            return x
+
+        x = self._checkNumbers('volume')
+        if x is not True:
+            return x
+
+        if isinstance(self.refs, Volume):
+            self.refs = [self.refs]
+
+        matrix = np.load(self.protocol._getExtraPath('matrix.npy'))
+        matrix = np.subtract(matrix[self.volNum1-1, self.partNum1-1:self.partNum2],
+                             matrix[self.volNum2-1, self.partNum1-1:self.partNum2])
+
+        plotter = EmPlotter()
+        _ = plt.hist(matrix, bins=self.nBins.get())
+        plt.xlabel('Relative log likelihood')
+
+        if self.vminH.get() != -1:
+            vmin = self.vminH.get()
+        elif self.percentileH.get() != -1:
+            vmin = np.percentile(matrix, self.percentileH.get())
+        else:
+            vmin = None
+
+        if self.vmaxH.get() != -1:
+            vmax = self.vmaxH.get()
+        elif self.percentileH.get() != -1:
+            vmax = np.percentile(matrix, 100-self.percentileH.get())
+        else:
+            vmax = None
+
+        plt.xlim([vmin, vmax])
+
+        return [plotter]
+
+
+    def _checkNumbers(self, string):
+
+        if self.normalise.get() and self.subtract.get():
+                return [self.errorMessage("Please select normalise or subtract, not both",
+                                        title=_invalidInputStr)]
+
+        items, number1, number2 = self._setNumbers(string)
+
+        if len(self.refs) == 1:
+            return True
+
+        if number1+1 > number2:
+            return [self.errorMessage("Invalid {0} range\n"
+                                      "Initial {0} number can not be " 
+                                      "bigger than the final one.".format(string), 
+                                      title=_invalidInputStr)]
+
+        elif number1 < -1:
+            return [self.errorMessage("Invalid {0} range\n"
+                                      "Initial {0} number can not be " 
+                                      "smaller than -1.".format(string), 
+                                      title=_invalidInputStr)]
+
+        elif number2 < -1:
+            return [self.errorMessage("Invalid {0} range\n"
+                                      "Final {0} number can not be " 
+                                      "smaller than -1.".format(string), 
+                                      title=_invalidInputStr)]
+        
+        if number1 != -1:
+            try:
+                _ = items[number1]
+            except IndexError:
+                return [self.errorMessage("Invalid initial {0} number {1}\n"
+                                         "Display the output {0}s to see "
+                                         "the availables ones.".format(string, number1+1),
+                                         title=_invalidInputStr)]
+            
+        if number2 != -1:
+            try:
+                _ = items[number2-1]
+            except IndexError:
+                return [self.errorMessage("Invalid final {0} number {1}\n"
+                                         "Display the output {0}s to see "
+                                         "the availables ones.".format(string, number2),
+                                         title=_invalidInputStr)]
+
+        return True
+
+    def _setNumbers(self, string):
+
+        if string == 'particle':
+            items = self.particles
+            number1 = self.partNum1 = self.partNumber1.get() if self.partNumber1.get() != -1 else 1
+            number2 = self.partNum2 = self.partNumber2.get() if self.partNumber2.get() != -1 else len(self.particles)
+        else:
+            items = self.refs
+            number1 = self.volNum1 = self.volNumber1.get() if self.volNumber1.get() != -1 else 1
+            number2 = self.volNum2 = self.volNumber2.get() if self.volNumber2.get() != -1 else len(self.refs)
+
+        return items, number1, number2

xmipp3/viewers/viewer_deep_consensus.py

@@ -33,7 +33,6 @@ from pyworkflow.viewer import DESKTOP_TKINTER, WEB_DJANGO, ProtocolViewer
 
 from pwem import emlib
 from xmipp3.protocols.protocol_screen_deepConsensus import XmippProtScreenDeepConsensus
-from xmipp3.protocols.protocol_screen_deeplearning import XmippProtScreenDeepLearning
 from .plotter import XmippPlotter
 
 class XmippDeepConsensusViewer(ProtocolViewer):
@@ -45,7 +44,7 @@ class XmippDeepConsensusViewer(ProtocolViewer):
     """
     _label = 'viewer deepConsensus'
     _environments = [DESKTOP_TKINTER, WEB_DJANGO]
-    _targets = [XmippProtScreenDeepConsensus, XmippProtScreenDeepLearning]
+    _targets = [XmippProtScreenDeepConsensus]
 
     def _defineParams(self, form):
         form.addSection(label='Visualization')
@@ -83,11 +82,6 @@ class XmippDeepConsensusViewer(ProtocolViewer):
             objId = self.protocol.outputCoordinates.strId()
             otherParam = {'other': 'deepCons'}
 
-        elif (isinstance(self.protocol, XmippProtScreenDeepLearning) and
-              self.protocol.hasAttribute('outputParticles')):
-            parts = self.protocol.outputParticles
-            fnParts = parts.getFileName()
-            objId = parts.strId()
 
         if objId:
             views.append(ObjectView(

xmipp3/viewers/viewer_dose_analysis.py

@@ -75,19 +75,35 @@ class XmippMovieDoseAnalysisViewer(EmProtocolViewer):
     def _visualizeDoseTime(self, e=None):
         if os.path.exists(self.protocol.getDosePlot()):
             image = plt.imread(self.protocol.getDosePlot())
-            plt.figure()
+            # Get the image dimensions (height, width)
+            height, width, _ = image.shape
+            # Convert pixels to inches for the figure size (assuming 100 DPI)
+            dpi = 100
+            figsize = (width / dpi, height / dpi)
+            # Create the figure with the calculated size
+            plt.figure(figsize=figsize)
+            # Display the image without axes
             fig = plt.imshow(image)
             fig.axes.get_xaxis().set_visible(False)
             fig.axes.get_yaxis().set_visible(False)
+            # Show the image
             plt.show()
 
     def _visualizeDoseDiffTime(self, e=None):
         if os.path.exists(self.protocol.getDoseDiffPlot()):
             image = plt.imread(self.protocol.getDoseDiffPlot())
-            plt.figure()
+            # Get the image dimensions (height, width)
+            height, width, _ = image.shape
+            # Convert pixels to inches for the figure size (assuming 100 DPI)
+            dpi = 100
+            figsize = (width / dpi, height / dpi)
+            # Create the figure with the calculated size
+            plt.figure(figsize=figsize)
+            # Display the image without axes
             fig = plt.imshow(image)
             fig.axes.get_xaxis().set_visible(False)
             fig.axes.get_yaxis().set_visible(False)
+            # Show the image
             plt.show()
 
     def _visualizeMovies(self, objName):