Particle Reassignment works

analysis/analysisview.py

@@ -399,6 +399,7 @@ class ParticleAnalysis(QtWidgets.QMainWindow):
         t0 = time.time()
         self.updateLegend()
         print('update legend:', round((time.time()-t0)*1000))
+        self.dataset.save()
     
     def initializeSpecPlot(self):
         self.specPlot.loadSpectraAndInitializeSpecPlot()

analysis/particleInfo.py

@@ -94,7 +94,7 @@ class ParticleContainer(object):
                 meas.setAssignment(assignmentList[scanIndex])
                 indicesOfTransferredAssignments[scanIndex] = scanIndex
         assert not None in indicesOfTransferredAssignments
-                
+    
     def applyHQIListToParticleMeasurements(self, hqiList):
         '''HQI-List is list of spectra hqis in order of spectra indices'''
         indicesOfTransferredHQIs = [None]*len(hqiList)
@@ -105,6 +105,10 @@ class ParticleContainer(object):
                 indicesOfTransferredHQIs[scanIndex] = scanIndex
         assert not None in indicesOfTransferredHQIs
     
+    def reassignParticleToAssignment(self, particleIndex, newAssignment):
+        particle = self.getParticleOfIndex(particleIndex)
+        particle.setAllSpectraToNewAssignment(newAssignment)
+    
     def getParticleOfIndex(self, index):
         particle = self.particles[index]
         assert particle.index == index, f'particle.index ({particle.index}) does match requested index in particleList ({index})' 
@@ -236,6 +240,11 @@ class Particle(object):
         self.measurements[indexOfMeasurment].pixelcoord_x= x
         self.measurements[indexOfMeasurment].pixelcoord_y = y
 
+    def setAllSpectraToNewAssignment(self, newAssignment):
+        for meas in self.measurements:
+            meas.setAssignment(newAssignment)
+            meas.setHQI(100)
+
     def getParticleAssignment(self):
         return self.getMeasAssignmentWithHighestHQI()   #probably another method could be more suitable...
     

analysis/particleeditor.py

@@ -27,133 +27,189 @@ If not, see <https://www.gnu.org/licenses/>.
 
 import numpy as np
 import cv2
-from PyQt5 import QtWidgets
+from PyQt5 import QtWidgets, QtCore
 
-class ParticleEditor(object):
-    def __init__(self, particleContainer, parent):
+class ParticleContextMenu(QtWidgets.QMenu):
+    combineParticlesSignal = QtCore.pyqtSignal(list, str)
+    reassignParticlesSignal = QtCore.pyqtSignal(list, str)
+    def __init__(self, sampleView):
+        super(ParticleContextMenu, self).__init__()
+        self.sampleView = sampleView
+        self.selectedParticleIndices = self.sampleView.selectedParticleIndices
+        self.particleContainer = self.sampleView.dataset.particleContainer
+        
+    def executeAtScreenPos(self, screenPos):
+        self.combineActs = []
+        self.combineMenu = QtWidgets.QMenu("Combine Particles into")
+        assignments = []
+
+        for particleIndex in self.selectedParticleIndices:
+            assignment = self.particleContainer.getParticleAssignmentByIndex(particleIndex)
+            assignments.append(assignment)
+        
+        for assignment in np.unique(assignments):
+            self.combineActs.append(self.combineMenu.addAction(assignment))
+        self.combineActs.append(self.combineMenu.addAction("other"))
+        
+        self.reassignActs = []
+        self.reassignMenu = QtWidgets.QMenu("Reassign particle(s) into")
+        for polymType in self.particleContainer.getUniquePolymers():
+            self.reassignActs.append(self.reassignMenu.addAction(polymType))
+        self.reassignActs.append(self.reassignMenu.addAction("other"))
+        
+        numParticles = len(self.selectedParticleIndices)
+        if numParticles == 0:
+            self.reassignMenu.setDisabled(True)
+            self.combineMenu.setDisabled(True)
+        elif numParticles == 1:
+            self.combineMenu.setDisabled(True)
+            
+        self.addMenu(self.combineMenu)        
+        self.addMenu(self.reassignMenu)
+        
+        action = self.exec_(screenPos)
+
+        if action in self.combineActs:
+            newAssignment = action.text()
+            self.combineParticlesSignal.emit(self.selectedParticleIndices, newAssignment)
+        elif action in self.reassignActs:
+            newAssignment = action.text()
+            self.reassignParticlesSignal.emit(self.selectedParticleIndices, newAssignment)
+
+
+class ParticleEditor(QtCore.QObject):
+    particlesWereEdited = QtCore.pyqtSignal()
+    def __init__(self, sampleView, particleContainer):
+        super(ParticleEditor, self).__init__()
         self.particleContainer = particleContainer
-        self.parent = parent    #the assigned analysis widget
+        self.sampleView = sampleView    #the assigned analysis widget
         self.backupFreq = 3     #save a backup every n actions
         self.neverBackedUp = True
         self.actionCounter = 0
-
+    
+    def connectToSignals(self, contextMenu):
+        contextMenu.combineParticlesSignal.connect(self.combineParticles)
+        contextMenu.reassignParticlesSignal.connect(self.reassignParticles)
+        
     def createSafetyBackup(self):
         self.actionCounter += 1
         if self.actionCounter == self.backupFreq-1 or self.neverBackedUp:            
-            backupname = self.parent.dataset.saveBackup()
+            backupname = self.sampleView.dataset.saveBackup()
             print('backing up as', backupname)
             self.neverBackedUp = False
-            self.actionCounter = 0
-        
+            self.actionCounter = 0        
+            
     def getNewEntry(self):
-        text, okClicked = QtWidgets.QInputDialog.getText(self.parent.parent, "Custom assignment", "Enter new assignment")
+        text, okClicked = QtWidgets.QInputDialog.getText(QtWidgets.QWidget(), "Custom assignment", "Enter new assignment")
         if okClicked and text != '':
             return text
     
+    @QtCore.pyqtSlot(list, str)
     def combineParticles(self, contourIndices, new_assignment):
-        if new_assignment == 'other':
-            new_assignment = self.getNewEntry()
-        if new_assignment is None:
-            return
-        
-        contourIndices = sorted(contourIndices)   #we want to keep the contour with lowest index
-        #get contours:
-        contours = self.particleContainer.getParticleContoursByIndex(contourIndices)
-#        contours = [self.datastats.dataset.particlecontours[i] for i in contourIndices]
-        cnt = np.vstack(tuple(contours))  #combine contous
-        
-        #draw contours
-        xmin, xmax = cnt[:,0,:][:, 0].min(), cnt[:,0,:][:, 0].max()
-        ymin, ymax = cnt[:,0,:][:, 1].min(), cnt[:,0,:][:, 1].max()        
-        
-        padding = 2    #pixel in each direction
-        rangex = int(np.round((xmax-xmin)+2*padding))
-        rangey = int(np.round((ymax-ymin)+2*padding))
-
-        img = np.zeros((rangey, rangex))
-        for i in contourIndices:
-            curCnt = self.particleContainer.getParticleContoursByIndex(i).copy()
-#            curCnt = self.datastats.dataset.particlecontours[i].copy()
-            for i in range(len(curCnt)):
-                curCnt[i][0][0] -= xmin-padding
-                curCnt[i][0][1] -= ymin-padding
-                
-            cv2.drawContours(img, [curCnt], -1, 1, -1)
-            cv2.drawContours(img, [curCnt], -1, 1, 1)
-        
-        img = np.uint8(cv2.morphologyEx(img, cv2.MORPH_CLOSE, np.ones((3, 3))))
-        
-        if cv2.__version__ > '3.5':
-            contours, hierarchy = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
-        else:
-            temp, contours, hierarchy = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
-
-        if len(contours)>1:
-            QtWidgets.QMessageBox.critical(self.parent, 'ERROR!', 
-                                           'Particle contours are not connected and cannot be combined!')
-            return
-        
-        newContour = contours[0]
-        stats = self.characterizeParticle(newContour)
-
-        for i in range(len(newContour)):
-            newContour[i][0][0] += xmin-padding
-            newContour[i][0][1] += ymin-padding
-        
-        print('merging contours:', contourIndices)
-        self.createSafetyBackup()
-        
-#        #check, if dataset contains (already modified) particle2spectra, otherwise create new.
-#        if self.datastats.dataset.particles2spectra is None:  #create default assignment
-#            print('recreating particles2spectra from within edit particles...')
-#            sortindices = self.datastats.dataset.ramanscansortindex
-#            self.datastats.dataset.particles2spectra = [[int(np.where(sortindices == i)[0])] for i in range(len(sortindices))]
-        
-        #Contour indices are the same as the original particlestats, which are contained in the dataset. 
-        #We have to modify that and reload in the analysisview
-        #first, overwrite first index with new particlestats
-        self.datastats.dataset.particlestats[contourIndices[0]] = stats
-        
-        #now, delete the rest...
-        self.datastats.dataset.particlestats = [i for ind, i in enumerate(self.datastats.dataset.particlestats) if ind not in contourIndices[1:]]
-        
-        #same with the contours
-        self.datastats.dataset.particlecontours[contourIndices[0]] = newContour
-        self.datastats.dataset.particlecontours = [i for ind, i in enumerate(self.datastats.dataset.particlecontours) if ind not in contourIndices[1:]]
-        
-        #update particle2spectra_list
-        #what is the current particle index??
-        specIndices = []
-        #other spectra indices:
-        for index in contourIndices:
-            specIndices.append(self.datastats.particles2spectra[index])
-        
-        #flatten index list (in case, that a nested list was created...)
-        specIndices = list(np.concatenate(specIndices))
-        for i in specIndices:
-            self.datastats.spectraResults[i] = new_assignment
-            self.datastats.hqis[i] = 100   #avoid sorting them out again by hqi-filter...
-            print(f'spectrum {i} of particle{contourIndices[0]} is now {new_assignment}')
-        
-        #modify particles2spectra..         
-        self.datastats.dataset.particles2spectra[contourIndices[0]] = specIndices
-        for index in reversed(contourIndices[1:]):
-            print('removing index from particles2spectra:', index)
-            del self.datastats.dataset.particles2spectra[index]
-
-        #update contours in sampleview
-        self.parent.parent.contouritem.resetContours(self.datastats.dataset.particlecontours)
-        self.parent.loadParticleData()
-        #save data
-        minHQI = self.parent.hqiSpinBox.value()
-        compHQI = self.parent.compHqiSpinBox.value()
-        if not self.datastats.saveAnalysisResults(minHQI, compHQI):
-            QtWidgets.QMessageBox.warning(self.parent, 'Error!',
-                    'Data inconsistency after saving!', QtWidgets.QMessageBox.Ok, 
-                    QtWidgets.QMessageBox.Ok)
-        
-       
+        print(contourIndices, new_assignment)
+        
+#        if new_assignment == 'other':
+#            new_assignment = self.getNewEntry()
+#        if new_assignment is None:
+#            return
+#        
+#        contourIndices = sorted(contourIndices)   #we want to keep the contour with lowest index
+#        #get contours:
+#        contours = self.particleContainer.getParticleContoursByIndex(contourIndices)
+##        contours = [self.datastats.dataset.particlecontours[i] for i in contourIndices]
+#        cnt = np.vstack(tuple(contours))  #combine contous
+#        
+#        #draw contours
+#        xmin, xmax = cnt[:,0,:][:, 0].min(), cnt[:,0,:][:, 0].max()
+#        ymin, ymax = cnt[:,0,:][:, 1].min(), cnt[:,0,:][:, 1].max()        
+#        
+#        padding = 2    #pixel in each direction
+#        rangex = int(np.round((xmax-xmin)+2*padding))
+#        rangey = int(np.round((ymax-ymin)+2*padding))
+#
+#        img = np.zeros((rangey, rangex))
+#        for i in contourIndices:
+#            curCnt = self.particleContainer.getParticleContoursByIndex(i).copy()
+##            curCnt = self.datastats.dataset.particlecontours[i].copy()
+#            for i in range(len(curCnt)):
+#                curCnt[i][0][0] -= xmin-padding
+#                curCnt[i][0][1] -= ymin-padding
+#                
+#            cv2.drawContours(img, [curCnt], -1, 1, -1)
+#            cv2.drawContours(img, [curCnt], -1, 1, 1)
+#        
+#        img = np.uint8(cv2.morphologyEx(img, cv2.MORPH_CLOSE, np.ones((3, 3))))
+#        
+#        if cv2.__version__ > '3.5':
+#            contours, hierarchy = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
+#        else:
+#            temp, contours, hierarchy = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
+#
+#        if len(contours)>1:
+#            QtWidgets.QMessageBox.critical(self.parent, 'ERROR!', 
+#                                           'Particle contours are not connected and cannot be combined!')
+#            return
+#        
+#        newContour = contours[0]
+#        stats = self.characterizeParticle(newContour)
+#dateContours()
+#        for i in range(len(newContour)):
+#            newContour[i][0][0] += xmin-padding
+#            newContour[i][0][1] += ymin-padding
+#        
+#        print('merging contours:', contourIndices)
+#        self.createSafetyBackup()
+#        
+##        #check, if dataset contains (already modified) particle2spectra, otherwise create new.
+##        if self.datastats.dataset.particles2spectra is None:  #create default assignment
+##            print('recreating particles2spectra from within edit particles...')
+##            sortindices = self.datastats.dataset.ramanscansortindex
+##            self.datastats.dataset.particles2spectra = [[int(np.where(sortindices == i)[0])] for i in range(len(sortindices))]
+#        
+#        #Contour indices are the same as the original particlestats, which are contained in the dataset. 
+#        #We have to modify that and reload in the analysisview
+#        #first, overwrite first index with new particlestats
+#        self.datastats.dataset.particlestats[contourIndices[0]] = stats
+#        
+#        #now, delete the rest...
+#        self.datastats.dataset.particlestats = [i for ind, i in enumerate(self.datastats.dataset.particlestats) if ind not in contourIndices[1:]]
+#        
+#        #same with the contours
+#        self.datastats.dataset.particlecontours[contourIndices[0]] = newContour
+#        self.datastats.dataset.particlecontours = [i for ind, i in enumerate(self.datastats.dataset.particlecontours) if ind not in contourIndices[1:]]
+#        
+#        #update particle2spectra_list
+#        #what is the current particle index??
+#        specIndices = []
+#        #other spectra indices:
+#        for index in contourIndices:
+#            specIndices.append(self.datastats.particles2spectra[index])
+#        
+#        #flatten index list (in case, that a nested list was created...)
+#        specIndices = list(np.concatenate(specIndices))
+#        for i in specIndices:
+#            self.datastats.spectraResults[i] = new_assignment
+#            self.datastats.hqis[i] = 100   #avoid sorting them out again by hqi-filter...
+#            print(f'spectrum {i} of particle{contourIndices[0]} is now {new_assignment}')
+#        
+#        #modify particles2spectra..         
+#        self.datastats.dataset.particles2spectra[contourIndices[0]] = specIndices
+#        for index in reversed(contourIndices[1:]):
+#            print('removing index from particles2spectra:', index)
+#            del self.datastats.dataset.particles2spectra[index]
+#
+#        #update contours in sampleview
+#        self.parent.parent.contouritem.resetContours(self.datastats.dataset.particlecontours)
+#        self.parent.loadParticleData()
+#        #save data
+#        minHQI = self.parent.hqiSpinBox.value()
+#        compHQI = self.parent.compHqiSpinBox.value()
+#        if not self.datastats.saveAnalysisResults(minHQI, compHQI):
+#            QtWidgets.QMessageBox.warning(self.parent, 'Error!',
+#                    'Data inconsistency after saving!', QtWidgets.QMessageBox.Ok, 
+#                    QtWidgets.QMessageBox.Ok)
     
+    @QtCore.pyqtSlot(list, str)
     def reassignParticles(self, contourindices, new_assignment):
         if new_assignment == 'other':
             new_assignment = self.getNewEntry()
@@ -163,31 +219,10 @@ class ParticleEditor(object):
         self.createSafetyBackup()
         print(f'reassigning indices {contourindices} into {new_assignment}')
         for partIndex in contourindices:
-            for specIndex in self.datastats.particles2spectra[partIndex]:
-                self.datastats.currentPolymers[specIndex] = new_assignment
-                self.datastats.spectraResults[specIndex] = new_assignment
-                self.datastats.hqis[specIndex] = 100
+            self.particleContainer.reassignParticleToAssignment(partIndex, new_assignment)
 
-        #update contours in sampleview
-        self.parent.parent.contouritem.resetContours(self.datastats.dataset.particlecontours)
-        self.parent.loadParticleData()
-        #save data
-        minHQI = self.parent.hqiSpinBox.value()
-        compHQI = self.parent.compHqiSpinBox.value()
-        if not self.datastats.saveAnalysisResults(minHQI, compHQI):
-            QtWidgets.QMessageBox.warning(self.parent, 'Error!',
-                                'Data inconsistency after saving!',
-                                QtWidgets.QMessageBox.Ok, QtWidgets.QMessageBox.Ok)
+        self.particlesWereEdited.emit()
             
-    
-    def deleteParticles(self):
-        self.createSafetyBackup()
-        pass
-    
-    def splitParticles(self):
-        self.createSafetyBackup()
-        pass
-    
     def characterizeParticle(self, contours):
         ##characterize particle
         longellipse, shortellipse = np.nan, np.nan

sampleview.py

@@ -21,6 +21,8 @@ If not, see <https://www.gnu.org/licenses/>.
 from PyQt5 import QtCore, QtGui, QtWidgets
 import numpy as np
 import os
+import cv2
+
 from dataset import DataSet, loadData
 from ramancom.ramancontrol import RamanControl, simulatedRaman
 from opticalscan import OpticalScan
@@ -31,8 +33,9 @@ from zeissimporter import ZeissImporter
 from viewitems import FitPosIndicator, Node, Edge, ScanIndicator, RamanScanIndicator, SegmentationContour
 from analysis.colorlegend import getColorFromNameWithSeed
 from helperfunctions import polygoncovering, cv2imread_fix
-import cv2
+
 from ramancom.configRaman import RamanConfigWin
+from analysis.particleeditor import ParticleEditor
 
 class SampleView(QtWidgets.QGraphicsView):
     ScalingChanged = QtCore.pyqtSignal(float)
@@ -71,6 +74,7 @@ class SampleView(QtWidgets.QGraphicsView):
         self.drag = None
         self.mode = None
         self.dataset = None
+        self.particleEditor = None
         self.fititems = []
         self.boundaryitems = [[],[]]
         self.scanitems = []
@@ -78,7 +82,7 @@ class SampleView(QtWidgets.QGraphicsView):
         self.imgdata = None
         self.isblocked = False
         self.contourItems = []
-        self.selectedContours = []
+        self.selectedParticleIndices = []
         
         self.detectionwidget = None
         self.ramanwidget = RamanScanUI(self.ramanctrl, None, self.logpath, self)
@@ -90,10 +94,6 @@ class SampleView(QtWidgets.QGraphicsView):
         self.setMinimumSize(600, 600)
         self.darkenPixmap = False
         self.microscopeMode = None
-#        self.coordTestMode = False
-        
-        
-        
         
     def takeScreenshot(self):
         #TODO:
@@ -146,7 +146,7 @@ class SampleView(QtWidgets.QGraphicsView):
     def saveDataSet(self):
         if self.dataset is not None:
             self.dataset.save()
-        
+
     @QtCore.pyqtSlot() 
     def zoomIn(self):
         self.scaleImage(1.25)
@@ -163,7 +163,6 @@ class SampleView(QtWidgets.QGraphicsView):
 
     @QtCore.pyqtSlot() 
     def fitToWindow(self):
-#        print("fitting to Window")
         brect = self.item.sceneBoundingRect()
         self.fitInView(0, 0, brect.width(), brect.height(), QtCore.Qt.KeepAspectRatio)
         self.scaleFactor = self.transform().m11()
@@ -178,7 +177,6 @@ class SampleView(QtWidgets.QGraphicsView):
             self.detectionwidget.close()
             self.detectionwidget.destroy()
         self.ramanwidget.setVisible(False)
-#        self.contouritem.resetContours([])
         self.updateParticleContours()
         self.mode = mode
         self.loadPixmap(self.microscopeMode)
@@ -204,6 +202,7 @@ class SampleView(QtWidgets.QGraphicsView):
                 print('creating new analysiswidget')
                 self.analysiswidget = ParticleAnalysis(self.dataset, self)
                 self.analysiswidget.showMaximized()
+                self.particleEditor.particlesWereEdited.connect(self.analysiswidget.updateDisplays)
             else:
                 print('show maximized already exisiting analysiswidget')
                 self.analysiswidget.showMaximized()
@@ -229,16 +228,10 @@ class SampleView(QtWidgets.QGraphicsView):
                 widget.destroy()
                 del widget
                 
-#        self.contouritem.resetContours()
         self.updateParticleContours()
-#        if self.dataset is not None:
-#            del self.dataset
-#            self.scene().removeItem(self.contouritem)
-#            del self.contouritem
-#            self.contouritem = SegmentationContours(self)
-#            self.scene().addItem(self.contouritem)
             
         self.dataset = loadData(fname)
+        self.particleEditor = ParticleEditor(self, self.dataset.particleContainer)
         self.setMicroscopeMode()
         self.imparent.setWindowTitle(self.dataset.name + (" SIMULATION" if simulatedRaman else ""))
         self.imgdata = None
@@ -257,6 +250,7 @@ class SampleView(QtWidgets.QGraphicsView):
         if self.dataset is not None:
             self.dataset.save()
         self.dataset = DataSet(fname, newProject=True)
+        self.particleEditor = ParticleEditor(self, self.dataset.particleContainer)
         self.setMicroscopeMode()
         self.imparent.setWindowTitle(self.dataset.name + (" SIMULATION" if simulatedRaman else ""))
         self.imgdata = None
@@ -296,7 +290,7 @@ class SampleView(QtWidgets.QGraphicsView):
             maxmode = "ParticleDetection"
             if len(self.dataset.ramanpoints)>0:
                 maxmode = "RamanScan"
-            if self.dataset.ramanscandone:        #uncomment!!
+            if self.dataset.ramanscandone:  
                 maxmode = "ParticleAnalysis"
         return maxmode
 
@@ -357,12 +351,12 @@ class SampleView(QtWidgets.QGraphicsView):
         def addContourToSelection(cnt):
             cnt.isSelected = True
             cnt.update()
-            self.selectedContours.append(cnt.particleIndex)
+            self.selectedParticleIndices.append(cnt.particleIndex)
         
         def removeContourFromSelection(cnt):
             cnt.isSelected = False
             cnt.update()
-            self.selectedContours.remove(cnt.particleIndex)
+            self.selectedParticleIndices.remove(cnt.particleIndex)
             
         p = self.mapToScene(event.pos())
         p = QtCore.QPointF(p.x(), p.y())
@@ -373,41 +367,17 @@ class SampleView(QtWidgets.QGraphicsView):
                 if not event.modifiers()==QtCore.Qt.ShiftModifier:
                     addContourToSelection(cnt)
                 else:
-                    if cnt.particleIndex not in self.selectedContours:
+                    if cnt.particleIndex not in self.selectedParticleIndices:
                         addContourToSelection(cnt)
-                    elif cnt.particleIndex in self.selectedContours:
+                    elif cnt.particleIndex in self.selectedParticleIndices:
                         removeContourFromSelection(cnt)
             
             else:    #not clicked on particle
                 
-                if event.modifiers()!=QtCore.Qt.ShiftModifier and cnt.particleIndex in self.selectedContours:
+                if event.modifiers()!=QtCore.Qt.ShiftModifier and cnt.particleIndex in self.selectedParticleIndices:
                     removeContourFromSelection(cnt)
-                
-                
-                
-                
-                
-                
-#                if event.modifiers()==QtCore.Qt.ShiftModifier:
-#                    if index not in self.selectedContours:
-#                        cnt.isSelected = True
-#                        self.selectedContours.append(cnt.particleIndex)
-#                    else:
-#                        cnt.isSelected = False
-#                        self.selectedContours.remove(cnt.particleIndex)
-#                else:
-#                    cnt.isSelected = True
-#                    self.selectedContours = [cnt.particleIndex]                
-#
-#            elif cnt.particleIndex not in self.selectedContours:
-#                cnt.isSelected = False
-                
-                
-#        self.selectedContours = []   #reset selection, if nothing was hit...
-        self.update()
 
-    
-        
+        self.update()
 
     def scaleImage(self, factor):
         if factor<1 and not self.imparent.zoomOutAct.isEnabled():
@@ -441,7 +411,6 @@ class SampleView(QtWidgets.QGraphicsView):
 
     @QtCore.pyqtSlot(str)
     def detectionUpdate(self):
-#        self.contouritem.resetContours(self.dataset.particlecontours)
         self.updateParticleContours()
         self.prepareAnalysis()
         self.update()
@@ -455,7 +424,6 @@ class SampleView(QtWidgets.QGraphicsView):
             data = self.imgdata
             fname = self.dataset.getImageName()
             if self.mode == "ParticleDetection" or self.mode == "ParticleAnalysis":
-#                self.contouritem.resetContours(self.dataset.particlecontours)
                 self.updateParticleContours()
             if data is None and os.path.exists(fname):
                 data = cv2.cvtColor(cv2imread_fix(fname), cv2.COLOR_BGR2RGB)
@@ -476,8 +444,7 @@ class SampleView(QtWidgets.QGraphicsView):
                 else:
                     self.scene().setBackgroundBrush(QtCore.Qt.darkGray)
                     self.item.setOpacity(1)
-                
-                
+
             else:
                 self.item.setPixmap(QtGui.QPixmap())
             if self.mode == "OpticalScan":
@@ -502,7 +469,6 @@ class SampleView(QtWidgets.QGraphicsView):
             p = n.pos().x(), n.pos().y()
             boundary.append(self.dataset.mapToLength(p, self.microscopeMode, force=True))
         boundary = np.array(boundary)
-#        print(boundary)
         self.dataset.boundary = boundary
         if micMode == 'df':
             width, height, angle = self.dataset.imagedim_df
@@ -549,19 +515,13 @@ class SampleView(QtWidgets.QGraphicsView):
             self.scene().addItem(e)
         self.boundaryitems = edges, nodes
         self.resetScanPositions()
-        
-#    @QtCore.pyqtSlot(int, bool)
-#    def selectContour(self, index, centerOn=True):
-#        if self.analysiswidget is not None:
-#            self.analysiswidget.selectContour(index, centerOn)
     
     def prepareAnalysis(self):
         self.clearItems()
         if self.dataset.ramanscansortindex is not None and len(self.dataset.ramanscansortindex)>0:
             data = []
             for i in self.dataset.ramanscansortindex:
-#                data.append(list(self.dataset.ramanpoints[i])+list(self.dataset.particlestats[i]))
-                data.append(list(self.dataset.ramanpoints[i]))  #particlestats are not needed here. Plus, they dont need to match spectra indices anymore..