Commit a79c38ed authored by JosefBrandt's avatar JosefBrandt
Browse files

Particle Color Detection implemented

Particle colors are detected automatically, but can changed through particle context menu
parent 316bc7ba
Loading
Loading
Loading
Loading
+79 −0
Original line number Diff line number Diff line
# -*- coding: utf-8 -*-
"""
GEPARD - Gepard-Enabled PARticle Detection
Copyright (C) 2018  Lars Bittrich and Josef Brandt, Leibniz-Institut für 
Polymerforschung Dresden e. V. <bittrich-lars@ipfdd.de>    

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 3 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, see COPYING.  
If not, see <https://www.gnu.org/licenses/>.
"""

import pickle

def loadAssigments(fname):
    with open(fname, "rb") as fp:
        assignment = pickle.load(fp)
    return assignment

def saveAssignments(assignment, fname):
    with open(fname, "wb") as fp:
        pickle.dump(assignment, fp, protocol=-1)


class DBAssignment(object):
    def __init__(self):
        self.filename = None
        self.assignments = []
    
    def setFileName(self, fname):
        self.filename = fname
    
    def save(self):
        saveAssignments(self, self.filename)
        
    def hasAssignment(self, polymerName):
        polymIsPresent = False
        for assignment in self.assignments:
            if assignment.polymerName == polymerName:
                polymIsPresent = True
                break
        return polymIsPresent
    
    def getAssignment(self, polymerName):
        for assignment in self.assignments:
            if assignment.polymerName == polymerName:
                return assignment
    
    def createNewAssignment(self, polymerName):
        self.assignments.append(Assignment(polymerName))
    
    def updateAssignment(self, polymerName, result, catRes, indic_paint):
        for assignment in self.assignments:
            if assignment.polymerName == polymerName:
                assignment.update(result, catRes, indic_paint)
                return


class Assignment(object):
    def __init__(self, polymerName):
        self.polymerName = polymerName
        self.result = None
        self.categorizedResult = None
        self.indication_paint = None
    
    def update(self, result, catRes, indic_paint):
        self.result = result
        self.categorizedResult = catRes
        self.indication_paint = indic_paint
    
+2 −2
Original line number Diff line number Diff line
@@ -129,7 +129,7 @@ class SpectraPlot(QtWidgets.QGroupBox):
        self.spectra = self.dataset.particleContainer.getSpectraFromDisk()
        self.canvas.draw()
        
    def updateParticleSpectrum(self, specIndex, assignment, particleSize, hqi):
    def updateParticleSpectrum(self, specIndex, assignment, particleSize, hqi, color):
        #draw Sample Spectrum
        self.spec_axis.axis("on")
        self.spec_axis.clear()
@@ -139,7 +139,7 @@ class SpectraPlot(QtWidgets.QGroupBox):
        
        if self.spectra is not None:
            self.spec_axis.plot(self.spectra[:, 0], self.spectra[:, specIndex+1])
            self.spec_axis.set_title('{}, ScanPoint Number {}, Size = {} µm, HQI = {}'.format(assignment, specIndex+1, particleSize, hqi))
            self.spec_axis.set_title('{}, ScanPoint Number {}, Size = {} µm, HQI = {}, color = {}'.format(assignment, specIndex+1, particleSize, hqi, color))
            self.spec_axis.set_xbound(100, (3400 if self.spectra[-1, 0] > 3400 else self.spectra[-1, 0]))
            wavenumber_diff = list(self.spectra[:, 0]-100)
            y_start = wavenumber_diff.index(min(wavenumber_diff))
+2 −1
Original line number Diff line number Diff line
@@ -455,7 +455,8 @@ class ParticleAnalysis(QtWidgets.QMainWindow):
        particleSize = np.round(self.particleContainer.getSizeOfParticleByIndex(self.currentParticleIndex))
        hqi = self.particleContainer.getHQIOfSpectrumIndex(self.currentSpectrumIndex)
        assignment = self.particleContainer.getParticleAssignmentByIndex(self.currentParticleIndex)
        self.specPlot.updateParticleSpectrum(self.currentSpectrumIndex, assignment, particleSize, hqi)
        color = self.particleContainer.getParticleColorByIndex(self.currentParticleIndex)
        self.specPlot.updateParticleSpectrum(self.currentSpectrumIndex, assignment, particleSize, hqi, color)
            
        if self.refSelector.isEnabled() and self.refSelector.currentText() != '':
            refID = self.dbWin.activeDatabase.spectraNames.index(self.refSelector.currentText())
+3 −1
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ If not, see <https://www.gnu.org/licenses/>.
"""
import numpy as np
from viewitems import SegmentationContour, RamanScanIndicator
from .particleCharacterization import getParticleColor

class Particle(object):
    def __init__(self):
@@ -32,7 +33,8 @@ class Particle(object):
        self.area = None
        self.contour = None
        self.measurements = []
        self.viewItem = None
        self.color = None
        self.shape = None
    
    def addMeasurement(self, refToMeasurement):
        refToMeasurement.assignedParticle = self
+150 −0
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ If not, see <https://www.gnu.org/licenses/>.

import numpy as np
import cv2
from copy import deepcopy

def getContourStatsWithPixelScale(cnt, pixelscale):
        long, short, longellipse, shortellipse, area = getContourStats(cnt)
@@ -43,3 +44,152 @@ def getContourStats(cnt):
        area = cv2.contourArea(cnt)
    
        return long, short, longellipse, shortellipse, area

class ColorRangeHSV(object):
    def __init__(self, name, hue, hue_tolerance, min_sat, max_sat):
        self.name = name
        self.minHue = hue-hue_tolerance/2
        self.maxHue = hue+hue_tolerance/2
        self.minSat = min_sat
        self.maxSat = max_sat
    
    def containsHSV(self, hsv):
        hue = hsv[0]
        sat = hsv[1]
        
        if self.minHue <= hue <= self.maxHue and self.minSat <= sat <= self.maxSat:
            return True
        else:
            if self.name != 'white':
                return False
            else:
                if sat < 128 and hsv[2] > 70:
                    return True

class ColorClassifier(object):
    def __init__(self):
        hue_tolerance = 30
        self.colors = [ColorRangeHSV('yellow', 30, hue_tolerance, 30, 255),
                  ColorRangeHSV('blue', 120, hue_tolerance, 80, 255),
                  ColorRangeHSV('red', 180, hue_tolerance, 50, 255),
                  ColorRangeHSV('red', 0, hue_tolerance, 50, 255),
                  ColorRangeHSV('green', 70, hue_tolerance, 50, 255),
                  ColorRangeHSV('white', 128, 256, 0, 50)]
    
    def classifyColor(self, meanHSV):
        result = 'non-determinable'
        for color in self.colors:
            if color.containsHSV(meanHSV):
                result = color.name
                break
        
        return result

def getParticleColor(imgRGB, colorClassifier=None):
    img = cv2.cvtColor(imgRGB, cv2.COLOR_RGB2HSV_FULL)
    meanHSV = cv2.mean(img)
    if colorClassifier is None:
        colorClassifier = ColorClassifier()
    color = colorClassifier.classifyColor(meanHSV)
    return color

def mergeContours(contours):
    img, xmin, ymin, padding = contoursToImg(contours)
    return imgToCnt(img, xmin, ymin, padding)

def getParticleImageFromFullimage(contour, fullimage):
    contourCopy = deepcopy(contour)
    xmin, xmax, ymin, ymax = getContourExtrema(contourCopy)

    img = fullimage[ymin:ymax, xmin:xmax]
    mask = np.zeros(img.shape[:2])
    
    for i in range(len(contourCopy)):
        contourCopy[i][0][0] -= xmin
        contourCopy[i][0][1] -= ymin
        
    cv2.drawContours(mask, [contourCopy], -1, (255, 255, 255), -1)
    cv2.drawContours(mask, [contourCopy], -1, (255, 255, 255), 1)
    
    img[mask == 0] = 0
    img = np.array(img, dtype = np.uint8)
    return img
    
def contoursToImg(contours, padding=2):
    contourCopy = deepcopy(contours)
    xmin, xmax, ymin, ymax = getContourExtrema(contourCopy)
    
    padding = padding   #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 curCnt in contourCopy:
        for i in range(len(curCnt)):
            curCnt[i][0][0] -= xmin-padding
            curCnt[i][0][1] -= ymin-padding
        cv2.drawContours(img, [curCnt], -1, 255, -1)
        cv2.drawContours(img, [curCnt], -1, 255, 1)
    
    img = np.uint8(cv2.morphologyEx(img, cv2.MORPH_CLOSE, np.ones((3, 3))))
    return img, xmin, ymin, padding

def imgToCnt(img, xmin, ymin, padding):
    def getSimpleContour(img):
        if cv2.__version__ > '3.5':
            contour, hierarchy = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
        else:
            temp, contour, hierarchy = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
        
        if len(contour)>1:
            raise NotConnectedContoursError
        return contour
    
    def getFullContour(img):
        if cv2.__version__ > '3.5':
            contour, hierarchy = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
        else:
            temp, contour, hierarchy = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
        
        if len(contour)>1:
            raise NotConnectedContoursError
        return contour
    
    contour = getSimpleContour(img)
    
    if len(contour[0]) < 5:
        contour = getFullContour(img)
    
    newContour = contour[0]
    for i in range(len(newContour )):
        newContour [i][0][0] += xmin-padding
        newContour [i][0][1] += ymin-padding
        
    return newContour 

def getContourExtrema(contours):
    try:
        cnt = np.vstack(tuple(contours))
        xmin, xmax = cnt[:,0,:][:, 0].min(), cnt[:,0,:][:, 0].max()
        ymin, ymax = cnt[:,0,:][:, 1].min(), cnt[:,0,:][:, 1].max()        
    except IndexError: #i.e., not a list of contours was passed, but an individual contour. Hence, the above indexing does not work
        xmin, xmax = cnt[:, 0].min(), cnt[:, 0].max()
        ymin, ymax = cnt[:, 1].min(), cnt[:, 1].max()        
    return xmin, xmax, ymin, ymax

class NotConnectedContoursError(Exception):
    pass

if __name__ == '__main__':
    colors = {'white': (41, 25, 66),
              "red": (128, 121, 57),
              "red2": (23, 88, 49), 
              "yellow": (25, 121, 91),
              "pink": (11, 79, 51),
              "brown": (32, 38, 64),
              "green": (54, 99, 53)}
    classifier= ColorClassifier()
#    print(classifier.hsv)
    for name, mean in colors.items():
        print(name, classifier.classifyColor(mean))
              
 No newline at end of file
Loading