def closing(colorModelTag, currentImageChannelIndex, img, mask, maskSize):
if colorModelTag == 'RGB':
tempImg = img.copy()
dilation(colorModelTag, currentImageChannelIndex, img.load(), img.size,
mask, maskSize, tempImg.load())
img = tempImg.copy()
erosion(colorModelTag, currentImageChannelIndex, img.load(), img.size,
mask, maskSize, tempImg.load())
img = tempImg.copy()
if colorModelTag == 'YUV':
colorModel.rgbToYuv(img.load(), img.size)
tempImg = img.copy()
dilation(colorModelTag, currentImageChannelIndex, img.load(), img.size,
mask, maskSize, tempImg.load())
img = tempImg.copy()
erosion(colorModelTag, currentImageChannelIndex, img.load(), img.size,
mask, maskSize, tempImg.load())
img = tempImg.copy()
colorModel.yuvToRgb(img.load(), img.size)
if colorModelTag == 'HSL':
data = numpy.asarray(img, dtype="float")
data = colorModel.rgbToHsl(data)
dataTemp = numpy.copy(data)
dilation(colorModelTag, currentImageChannelIndex, data, data.shape,
mask, maskSize, dataTemp)
data = dataTemp.copy()
erosion(colorModelTag, currentImageChannelIndex, data, data.shape,
mask, maskSize, dataTemp)
data = colorModel.hslToRgb(dataTemp)
img = Image.fromarray(
numpy.asarray(numpy.clip(data, 0, 255), dtype="uint8"))
return img
def cleanerFilterByJimCasaburi(self, colorModelTag,
currentImageChannelIndex, isOriginalImage,
filterWidth, filterHeight, threshold):
"""
Mean filter
"""
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
methodTimer = time.time()
if colorModelTag == 'RGB':
filters.cleanerFilterByJimCasaburi(colorModelTag,
currentImageChannelIndex,
img.load(), img.size,
(filterWidth, filterHeight),
threshold)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(img=img, model=colorModelTag)
if colorModelTag == 'YUV':
colorModel.rgbToYuv(img.load(), img.size)
filters.cleanerFilterByJimCasaburi(colorModelTag,
currentImageChannelIndex,
img.load(), img.size,
(filterWidth, filterHeight),
threshold)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(img=img, model=colorModelTag)
timerTemp = time.time()
colorModel.yuvToRgb(img.load(), img.size)
methodTimer = time.time() - methodTimer
if colorModelTag == 'HSL':
data = numpy.asarray(img, dtype="float")
data = colorModel.rgbToHsl(data)
filters.cleanerFilterByJimCasaburi(colorModelTag,
currentImageChannelIndex, data,
data.shape,
(filterWidth, filterHeight),
threshold)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(data=data, model=colorModelTag)
timerTemp = time.time()
data = colorModel.hslToRgb(data)
img = Image.fromarray(
numpy.asarray(numpy.clip(data, 0, 255), dtype="uint8"))
methodTimer = time.time() - timerTemp + methodTimer
logFile = '{}/temp/log/cleanerFilterByJimCasaburi.log'.format(
self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}: {}\n".format(colorModelTag,
methodTimer))
img.save('{}/temp/processingImage.png'.format(self.appDir))
imageComparison.calculateImageDifference(colorModelTag, logFile)
def hls_thresh(image, channel="h", thresh=(0, 50)):
hls = colorModel.rgbToHsl(image)
if channel=="h":
threshold_channel = hls[:,:,0] * 255
if channel=="l":
threshold_channel = hls[:,:,1] * 255
if channel=="s":
threshold_channel = hls[:,:,2] * 255
hls_threshold = np.zeros_like(threshold_channel)
hls_threshold[(threshold_channel > thresh[0]) & (threshold_channel < thresh[1])] = 1
return hls_threshold
def morphOuterEdge(self, colorModelTag, currentImageChannelIndex,
isOriginalImage, maskWidth, maskHeight):
"""
morphOuterEdge
"""
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
methodTimer = time.time()
if colorModelTag == 'RGB':
tempImg = img.copy()
morphology.dilation(colorModelTag, currentImageChannelIndex,
img.load(), img.size, self.maskList,
(maskWidth, maskHeight), tempImg.load())
methodTimer = time.time() - methodTimer
img = ImageChops.difference(tempImg, img)
self.histogramService.saveHistogram(img=img, model=colorModelTag)
if colorModelTag == 'YUV':
colorModel.rgbToYuv(img.load(), img.size)
tempImg = img.copy()
morphology.dilation(colorModelTag, currentImageChannelIndex,
img.load(), img.size, self.maskList,
(maskWidth, maskHeight), tempImg.load())
img = ImageChops.difference(tempImg, img)
colorModel.yuvToRgb(img.load(), img.size)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(img=img, model=colorModelTag)
if colorModelTag == 'HSL':
data = numpy.asarray(img, dtype="float")
data = colorModel.rgbToHsl(data)
dataTemp = numpy.copy(data)
morphology.dilation(colorModelTag, currentImageChannelIndex, data,
data.shape, self.maskList,
(maskWidth, maskHeight), dataTemp)
methodTimer = time.time() - methodTimer
# data = numpy.copy(dataTemp)
data = numpy.absolute(dataTemp - data)
self.histogramService.saveHistogram(data=data, model=colorModelTag)
timerTemp = time.time()
data = colorModel.hslToRgb(data)
img = Image.fromarray(
numpy.asarray(numpy.clip(data, 0, 255), dtype="uint8"))
methodTimer = time.time() - timerTemp + methodTimer
logFile = '{}/temp/log/morphOuterEdge.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}: {}\n".format(colorModelTag,
methodTimer))
img.save('{}/temp/processingImage.png'.format(self.appDir))
imageComparison.calculateImageDifference(colorModelTag, logFile)
def KMeans(self, colorModelTag, currentImageChannelIndex, isOriginalImage,
countOfClusters):
"""
GaborSegmentation
"""
outImagePath, imgPath = self.imageService.getImagePath(isOriginalImage)
if imgPath is None:
return
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
methodTimer = time.time()
if colorModelTag == 'RGB':
methodTimer = time.time()
kMeans.doKMeans(imgPath, outImagePath, countOfClusters)
methodTimer = time.time() - methodTimer
img = self.imageService.openImage(False)
if img is None:
return
self.histogramService.saveHistogram(img=img, model=colorModelTag)
if colorModelTag == 'YUV':
colorModel.rgbToYuv(img.load(), img.size)
methodTimer = time.time()
kMeans.doKMeans(imgPath, outImagePath, countOfClusters)
methodTimer = time.time() - methodTimer
img = self.imageService.openImage(False)
if img is None:
return
# img.show()
self.histogramService.saveHistogram(img=img, model=colorModelTag)
# colorModel.yuvToRgb(img.load(), img.size)
if colorModelTag == 'HSL':
data = numpy.asarray(img, dtype="float")
data = colorModel.rgbToHsl(data)
methodTimer = time.time()
kMeans.doKMeans(imgPath, outImagePath, countOfClusters)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(data=data, model=colorModelTag)
timerTemp = time.time()
data = colorModel.hslToRgb(data)
img = Image.fromarray(
numpy.asarray(numpy.clip(data, 0, 255), dtype="uint8"))
methodTimer = time.time() - timerTemp + methodTimer
logFile = '{}/temp/log/morphDilation.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}: {}\n".format(colorModelTag,
methodTimer))
# img.save('{}/temp/processingImage.png'.format(self.appDir))
imageComparison.calculateImageDifference(colorModelTag, logFile)
def addMultiplicativeNoise(self, colorModelTag, currentImageChannelIndex,
kmin, kmax, noiseLevel, isOriginalImage):
""" Change color model and channels
@param colorModelTag: The color model tag
@param currentImageChannelIndex: The index of current image channel
"""
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
methodTimer = time.time()
if colorModelTag == 'RGB':
noiseGenerator.multiplicativeNoise(img.load(), img.size,
colorModelTag,
currentImageChannelIndex, kmin,
kmax, noiseLevel)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(img=img, model=colorModelTag)
if colorModelTag == 'YUV':
colorModel.rgbToYuv(img.load(), img.size)
noiseGenerator.multiplicativeNoise(img.load(), img.size,
colorModelTag,
currentImageChannelIndex, kmin,
kmax, noiseLevel)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(img=img, model=colorModelTag)
timerTemp = time.time()
colorModel.yuvToRgb(img.load(), img.size)
methodTimer = time.time() - methodTimer
if colorModelTag == 'HSL':
data = numpy.asarray(img, dtype="float")
data = colorModel.rgbToHsl(data)
noiseGenerator.multiplicativeNoise(data, data.shape, colorModelTag,
currentImageChannelIndex, kmin,
kmax, noiseLevel)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(data=data, model=colorModelTag)
timerTemp = time.time()
data = colorModel.hslToRgb(data)
img = Image.fromarray(
numpy.asarray(numpy.clip(data, 0, 255), dtype="uint8"))
methodTimer = time.time() - timerTemp + methodTimer
logFile = '{}/temp/log/addMultiplicativeNoise.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}: {}\n".format(colorModelTag,
methodTimer))
imageComparison.calculateImageDifference(colorModelTag, logFile)
img.save('{}/temp/processingImage.png'.format(self.appDir))
def segSobel(self, colorModelTag, currentImageChannelIndex,
isOriginalImage, amplifier, threshold):
"""
sobel
"""
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
methodTimer = time.time()
if colorModelTag == 'RGB':
tempPixels = img.copy()
edgeDetection.sobel(colorModelTag, currentImageChannelIndex,
img.load(), img.size, tempPixels.load(),
amplifier, threshold)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(img=img, model=colorModelTag)
if colorModelTag == 'YUV':
colorModel.rgbToYuv(img.load(), img.size)
tempPixels = img.copy()
edgeDetection.sobel(colorModelTag, currentImageChannelIndex,
img.load(), img.size, tempPixels.load(),
amplifier, threshold)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(img=img, model=colorModelTag)
timerTemp = time.time()
colorModel.yuvToRgb(img.load(), img.size)
methodTimer = time.time() - methodTimer
if colorModelTag == 'HSL':
data = numpy.asarray(img, dtype="float")
data = colorModel.rgbToHsl(data)
tempData = numpy.copy(data)
edgeDetection.sobel(colorModelTag, currentImageChannelIndex, data,
data.shape, tempData, amplifier, threshold)
methodTimer = time.time() - methodTimer
# data = numpy.copy(dataTemp)
self.histogramService.saveHistogram(data=data, model=colorModelTag)
timerTemp = time.time()
data = colorModel.hslToRgb(data)
img = Image.fromarray(
numpy.asarray(numpy.clip(data, 0, 255), dtype="uint8"))
methodTimer = time.time() - timerTemp + methodTimer
logFile = '{}/temp/log/segSobel.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}: {}\n".format(colorModelTag,
methodTimer))
img.save('{}/temp/processingImage.png'.format(self.appDir))
imageComparison.calculateImageDifference(colorModelTag, logFile)
def changeHue(self, isOriginalImage, value=None, hValue=0, sValue=0, lValue=0):
""" Change an image hue
@param value: The hue value
@param isOriginalImage: The value for choose original or processing Image
"""
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
methodTimer = time.time()
data = numpy.asarray(img, dtype="float")
data = colorModel.rgbToHsl(data, value=value, hValue=hValue, sValue=sValue,
lValue=lValue)
logFile = '{}/temp/log/changeHue.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}\n".format(time.time() - methodTimer))
imageComparison.calculateImageDifference(None, logFile)
self.histogramService.saveHistogram(data=data, model='HSL')
data = colorModel.hslToRgb(data)
img = Image.fromarray(numpy.asarray(numpy.clip(data, 0, 255), dtype="uint8"))
img.save('{}/temp/processingImage.png'.format(self.appDir))
def adaptiveMedianFilter(self, colorModelTag, currentImageChannelIndex,
isOriginalImage, filterSize):
"""
Adaptive mean filter
"""
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
methodTimer = time.time()
if colorModelTag == 'RGB':
r, g, b = img.split()
if currentImageChannelIndex == 0:
r = adaptiveFilter.adpmedf(r, img.size, filterSize)
g = adaptiveFilter.adpmedf(g, img.size, filterSize)
b = adaptiveFilter.adpmedf(b, img.size, filterSize)
if currentImageChannelIndex == 1:
r = adaptiveFilter.adpmedf(r, img.size, filterSize)
if currentImageChannelIndex == 2:
g = adaptiveFilter.adpmedf(g, img.size, filterSize)
if currentImageChannelIndex == 3:
b = adaptiveFilter.adpmedf(b, img.size, filterSize)
img = Image.merge("RGB", (r, g, b))
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(img=img, model=colorModelTag)
if colorModelTag == 'YUV':
colorModel.rgbToYuv(img.load(), img.size)
r, g, b = img.split()
if currentImageChannelIndex == 0:
r = adaptiveFilter.adpmedf(r, img.size, filterSize)
g = adaptiveFilter.adpmedf(g, img.size, filterSize)
b = adaptiveFilter.adpmedf(b, img.size, filterSize)
if currentImageChannelIndex == 1:
r = adaptiveFilter.adpmedf(r, img.size, filterSize)
if currentImageChannelIndex == 2:
g = adaptiveFilter.adpmedf(g, img.size, filterSize)
if currentImageChannelIndex == 3:
b = adaptiveFilter.adpmedf(b, img.size, filterSize)
img = Image.merge("RGB", (r, g, b))
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(img=img, model=colorModelTag)
timerTemp = time.time()
colorModel.yuvToRgb(img.load(), img.size)
methodTimer = time.time() - methodTimer
if colorModelTag == 'HSL':
data = numpy.asarray(img, dtype="float")
data = colorModel.rgbToHsl(data)
r = data[:, :, 0]
g = data[:, :, 1]
b = data[:, :, 2]
if currentImageChannelIndex == 0:
r = adaptiveFilter.adpmedf(r, img.size, filterSize)
g = adaptiveFilter.adpmedf(g, img.size, filterSize)
b = adaptiveFilter.adpmedf(b, img.size, filterSize)
if currentImageChannelIndex == 1:
r = adaptiveFilter.adpmedf(r, img.size, filterSize)
if currentImageChannelIndex == 2:
g = adaptiveFilter.adpmedf(g, img.size, filterSize)
if currentImageChannelIndex == 3:
b = adaptiveFilter.adpmedf(b, img.size, filterSize)
data = numpy.dstack((r, g, b))
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(data=img, model=colorModelTag)
timerTemp = time.time()
data = colorModel.hslToRgb(data)
img = Image.fromarray(
numpy.asarray(numpy.clip(data, 0, 255), dtype="uint8"))
methodTimer = time.time() - timerTemp + methodTimer
logFile = '{}/temp/log/adaptiveMedianFilter.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}: {}\n".format(colorModelTag,
methodTimer))
img.save('{}/temp/processingImage.png'.format(self.appDir))
imageComparison.calculateImageDifference(colorModelTag, logFile)
def opening(colorModelTag, currentImageChannelIndex, img, mask, maskSize):
if colorModelTag == 'RGB':
tempImg = img.copy()
erosion(colorModelTag, currentImageChannelIndex, img.load(), img.size,
mask, maskSize, tempImg.load())
img = tempImg.copy()
dilation(colorModelTag, currentImageChannelIndex, img.load(), img.size,
mask, maskSize, tempImg.load())
img = tempImg.copy()
if colorModelTag == 'YUV':
colorModel.rgbToYuv(img.load(), img.size)
tempImg = img.copy()
erosion(colorModelTag, currentImageChannelIndex, img.load(), img.size,
mask, maskSize, tempImg.load())
img = tempImg.copy()
dilation(colorModelTag, currentImageChannelIndex, img.load(), img.size,
mask, maskSize, tempImg.load())
img = tempImg.copy()
colorModel.yuvToRgb(img.load(), img.size)
if colorModelTag == 'HSL':
data = numpy.asarray(img, dtype="float")
data = colorModel.rgbToHsl(data)
dataTemp = numpy.copy(data)
erosion(colorModelTag, currentImageChannelIndex, data, data.shape,
mask, maskSize, dataTemp)
data = dataTemp.copy()
dilation(colorModelTag, currentImageChannelIndex, data, data.shape,
mask, maskSize, dataTemp)
data = colorModel.hslToRgb(dataTemp)
img = Image.fromarray(
numpy.asarray(numpy.clip(data, 0, 255), dtype="uint8"))
return img
# def skeleton(colorModelTag, currentImageChannelIndex, img, mask, maskSize):
# tempImg1 = img.copy()
# tempImg2 = img.copy()
# EMsk = []
# OMsk = []
# for i in range(3):
# EMaskRow = []
# OMaskRow = []
# for j in range(3):
# EMaskRow.append(True)
# OMaskRow.append(True)
# EMsk.append(EMaskRow)
# OMsk.append(OMaskRow)
# OMsk[0][0] = False
# OMsk[0][2] = False
# OMsk[2][0] = False
# OMsk[2][2] = False
# differencesCount = 0
# while True:
# tempImg1 = opening(colorModelTag, currentImageChannelIndex, tempImg1, OMsk, maskSize)
# # tempImg1.show()
# # # img = ImageChops.difference(img, tempImg1)
# # differencesCount = 0
# # imgPixels = img.load()
# # tempImg1Pixels = tempImg1.load()
# # tempImg2Pixels = tempImg2.load()
# # for i in range(img.size[0]):
# # QCoreApplication.processEvents()
# # for j in range(img.size[1]):
# # r, g, b = imgPixels[i, j]
# # newR, newG, newB = tempImg1Pixels[i, j]
# # newR = abs(r - newR)
# # newG = abs(g - newG)
# # newB = abs(b - newB)
# # if newR == 0: differencesCount += 1
# # if newG == 0: differencesCount += 1
# # if newB == 0: differencesCount += 1
# # tempImg2Pixels[i, j] = (newR, newG, newB)
# # # apertures = apertureService.getApertureMatrixGenerator(img.size(), maskSize)
# # # pixelsImg = img.load()
# # # pixelstempImg1 = tempImg1.load()
# # # for i, pixels in enumerate(pixelsArray):
# # # QCoreApplication.processEvents()
# # # for j, pixel in enumerate(pixels):
# # # pixelPosX, pixelPosY = apertureCoordinate
# # # # red, green, blue = pixels[pixelPosX, pixelPosY]
# # # pixel = img[x][y] - tempImg1[x][y]
# # # # skel[x][y] = skel[x][y] | pixel;
# # # tempImg = img.copy()
# img = tempImg1.copy()
# erosion(colorModelTag, currentImageChannelIndex, img.load(),
# img.size, EMsk, maskSize, tempImg1.load())
# img = tempImg1.copy()
# differencesCount += 1
# if differencesCount < 30:
# break
# return img
# # Erosion(img, EMask, eimg)
# # if colorModelTag == 'RGB':
# # tempImg = img.copy()
# # erosion(colorModelTag, currentImageChannelIndex, img.load(),
# # img.size, mask, maskSize, tempImg.load())
# # img = tempImg.copy()
# # dilation(colorModelTag, currentImageChannelIndex, img.load(),
# # img.size, mask, maskSize, tempImg.load())
# # img = tempImg.copy()
# # if colorModelTag == 'YUV':
# # colorModel.rgbToYuv(img.load(), img.size)
# # tempImg = img.copy()
# # erosion(colorModelTag, currentImageChannelIndex, img.load(),
# # img.size, mask, maskSize, tempImg.load())
# # img = tempImg.copy()
# # dilation(colorModelTag, currentImageChannelIndex, img.load(),
# # img.size, mask, maskSize, tempImg.load())
# # img = tempImg.copy()
# # colorModel.yuvToRgb(img.load(), img.size)
# # if colorModelTag == 'HSL':
# # data = numpy.asarray(img, dtype="float")
# # data = colorModel.rgbToHsl(data)
# # dataTemp = numpy.copy(data)
# # erosion(colorModelTag, currentImageChannelIndex, data,
# # data.shape, mask, maskSize, dataTemp)
# # data = dataTemp.copy()
# # dilation(colorModelTag, currentImageChannelIndex, data,
# # data.shape, mask, maskSize, dataTemp)
# # data = colorModel.hslToRgb(dataTemp)
# # img = Image.fromarray(numpy.asarray(numpy.clip(data, 0, 255), dtype="uint8"))
# # def skeleton(BIT* img[], BIT* skel[])
# # {
# # BIT eimg[W][H], oimg[W][H]; bool EMsk[3][3], OMsk[3][3];
# # for(m = 0; m < 3; m++)
# # for(n = 0; n < 3; n++)
# # EMask[m][n] = OMask[m][n] = TRUE;
# # OMsk[0][0] = OMsk[0][2] = OMsk[2][0] = OMsk[2][2] = FALSE;
# # while( !empty(img) )
# # {
# # Open(img, OMsk, oimg);
# # for(y = 0; y < H; y++)
# # for(x = 0; x < W; x++)
# # {
# # pixel = img[x][y] – oimg[x][y];
# # skel[x][y] = skel[x][y] | pixel;
# # }
# # Erosion(img, EMask, eimg); Copy(img, eimg);
# # }
# # }
def segLaplacian(self, colorModelTag, currentImageChannelIndex,
isOriginalImage, amplifier, threshold, maskMode):
"""
Laplacian
"""
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
methodTimer = time.time()
if colorModelTag == 'RGB':
gaussianImg = img.copy()
gaussianDeviation = 1.0 ##############################################
gaussianFilterSize = math.floor(gaussianDeviation * 3.0)
filters.gaussianBlur(colorModelTag, currentImageChannelIndex,
gaussianImg.load(), gaussianImg.size,
(gaussianFilterSize, gaussianFilterSize))
edgeDetection.canny(colorModelTag,
currentImageChannelIndex,
img.load(),
img.size,
gaussianImg.load(),
amplifier,
threshold,
maskMode=maskMode)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(img=img, model=colorModelTag)
if colorModelTag == 'YUV':
colorModel.rgbToYuv(img.load(), img.size)
gaussianImg = img.copy()
gaussianDeviation = 1.0 ##############################################
gaussianFilterSize = math.floor(gaussianDeviation * 3.0)
filters.gaussianBlur(colorModelTag, currentImageChannelIndex,
gaussianImg.load(), gaussianImg.size,
(gaussianFilterSize, gaussianFilterSize))
edgeDetection.canny(colorModelTag,
currentImageChannelIndex,
img.load(),
img.size,
gaussianImg.load(),
amplifier,
threshold,
maskMode=maskMode)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(img=img, model=colorModelTag)
timerTemp = time.time()
colorModel.yuvToRgb(img.load(), img.size)
methodTimer = time.time() - methodTimer
if colorModelTag == 'HSL':
data = numpy.asarray(img, dtype="float")
data = colorModel.rgbToHsl(data)
gaussianData = numpy.copy(data)
gaussianDeviation = 1.0 ##############################################
gaussianFilterSize = math.floor(gaussianDeviation * 3.0)
filters.gaussianBlur(colorModelTag, currentImageChannelIndex,
gaussianData, gaussianData.shape,
(gaussianFilterSize, gaussianFilterSize))
edgeDetection.canny(colorModelTag,
currentImageChannelIndex,
gaussianData,
gaussianData.shape,
gaussianData,
amplifier,
threshold,
maskMode=maskMode)
methodTimer = time.time() - methodTimer
# data = numpy.copy(dataTemp)
self.histogramService.saveHistogram(data=data, model=colorModelTag)
timerTemp = time.time()
data = colorModel.hslToRgb(data)
img = Image.fromarray(
numpy.asarray(numpy.clip(data, 0, 255), dtype="uint8"))
methodTimer = time.time() - timerTemp + methodTimer
logFile = '{}/temp/log/segLaplacian.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}: {}\n".format(colorModelTag,
methodTimer))
img.save('{}/temp/processingImage.png'.format(self.appDir))
imageComparison.calculateImageDifference(colorModelTag, logFile)
def EfficientGraphBasedImageSegmentation(self, colorModelTag,
currentImageChannelIndex,
isOriginalImage, sigma,
neighborhood, k, min_comp_size,
xPix, yPix):
"""
EfficientGraphBasedImageSegmentation
"""
if xPix == '' or yPix == '':
pixMouse = None
else:
pixMouse = (int(xPix), int(yPix))
outImagePath, imgPath = self.imageService.getImagePath(isOriginalImage)
if imgPath is None:
return
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
segmentCount = 0
methodTimer = time.time()
if colorModelTag == 'RGB':
methodTimer = time.time()
data1, data2, segmentCount, forest = egbis.segmentateRun(
sigma, neighborhood, k, min_comp_size, img, outImagePath,
pixMouse)
methodTimer = time.time() - methodTimer
img = self.imageService.openImage(False)
if img is None:
return
self.histogramService.saveHistogram(img=img, model=colorModelTag)
if colorModelTag == 'YUV':
colorModel.rgbToYuv(img.load(), img.size)
methodTimer = time.time()
data1, data2, segmentCount, forest = egbis.segmentateRun(
sigma, neighborhood, k, min_comp_size, img, outImagePath,
pixMouse)
methodTimer = time.time() - methodTimer
img = self.imageService.openImage(False)
if img is None:
return
# img.show()
self.histogramService.saveHistogram(img=img, model=colorModelTag)
# colorModel.yuvToRgb(img.load(), img.size)
if colorModelTag == 'HSL':
data = numpy.asarray(img, dtype="float")
data = colorModel.rgbToHsl(data)
methodTimer = time.time()
data1, data2, segmentCount, forest = egbis.segmentateRun(
sigma, neighborhood, k, min_comp_size, data, outImagePath,
pixMouse)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(data=data, model=colorModelTag)
timerTemp = time.time()
data = colorModel.hslToRgb(data)
img = Image.fromarray(
numpy.asarray(numpy.clip(data, 0, 255), dtype="uint8"))
methodTimer = time.time() - timerTemp + methodTimer
logFile = '{}/temp/log/EfficientGraphBasedImageSegmentation.log'.format(
self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}: {}\n".format(colorModelTag,
methodTimer))
# img.save('{}/temp/processingImage.png'.format(self.appDir))
imageComparison.calculateSegmentationCriterias(logFile, data1, data2,
segmentCount)
def CompareEGBISandSPHC(self, colorModelTag, currentImageChannelIndex,
isOriginalImage, sigmaEGBIS, neighborhoodEGBIS,
kEGBIS, min_comp_sizeEGBIS, xPixEGBIS, yPixEGBIS,
numSegmentsSPHC, SigmaSPHC, segmentsToMergeSPHC,
distance_limitSPHC, xPixSPHC, yPixSPHC):
"""
CompareEGBISandSPHC
"""
pixMouseEGBIS = None
pixMouseSPHC = None
# if xPixEGBIS == '' or yPixEGBIS == '':
# pixMouseEGBIS=None
# else:
# pixMouseEGBIS=(int(xPixEGBIS), int(yPixEGBIS))
outImagePath, imgPath = self.imageService.getImagePath(isOriginalImage)
if imgPath is None:
return
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
segmentCountEGBIS = 0
segmentCountSPHC = 0
methodTimer = time.time()
if colorModelTag == 'RGB':
methodTimer = time.time()
data1EGBIS, data2EGBIS, segmentCountEGBIS, forest = egbis.segmentateRun(
sigmaEGBIS, neighborhoodEGBIS, kEGBIS, min_comp_sizeEGBIS, img,
outImagePath, pixMouseEGBIS)
data1SPHC, data2SPHC, segmentCountSPHC, segm_dict = sphc.doSPHC(
imgPath,
outImagePath,
numSegmentsSPHC,
SigmaSPHC,
segmentsToMergeSPHC,
distance_limitSPHC,
pixMouseSPHC,
isTest=True)
methodTimer = time.time() - methodTimer
img = self.imageService.openImage(True)
if img is None:
return
self.histogramService.saveHistogram(img=img, model=colorModelTag)
if colorModelTag == 'YUV':
colorModel.rgbToYuv(img.load(), img.size)
methodTimer = time.time()
data1EGBIS, data2EGBIS, segmentCountEGBIS, forest = egbis.segmentateRun(
sigmaEGBIS, neighborhoodEGBIS, kEGBIS, min_comp_sizeEGBIS, img,
outImagePath, pixMouseEGBIS)
data1SPHC, data2SPHC, segmentCountSPHC, segm_dict = sphc.doSPHC(
imgPath,
outImagePath,
numSegmentsSPHC,
SigmaSPHC,
segmentsToMergeSPHC,
distance_limitSPHC,
pixMouseSPHC,
isTest=True)
methodTimer = time.time() - methodTimer
img = self.imageService.openImage(True)
if img is None:
return
# img.show()
self.histogramService.saveHistogram(img=img, model=colorModelTag)
# colorModel.yuvToRgb(img.load(), img.size)
if colorModelTag == 'HSL':
data = numpy.asarray(img, dtype="float")
data = colorModel.rgbToHsl(data)
methodTimer = time.time()
data1EGBIS, data2EGBIS, segmentCountEGBIS, forest = egbis.segmentateRun(
sigmaEGBIS, neighborhoodEGBIS, kEGBIS, min_comp_sizeEGBIS,
data, outImagePath, pixMouseEGBIS)
data1SPHC, data2SPHC, segmentCountSPHC, segm_dict = sphc.doSPHC(
imgPath,
outImagePath,
numSegmentsSPHC,
SigmaSPHC,
segmentsToMergeSPHC,
distance_limitSPHC,
pixMouseSPHC,
isTest=True)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(data=data, model=colorModelTag)
timerTemp = time.time()
data = colorModel.hslToRgb(data)
img = Image.fromarray(
numpy.asarray(numpy.clip(data, 0, 255), dtype="uint8"))
methodTimer = time.time() - timerTemp + methodTimer
logFile = '{}/temp/log/CompareEGBISandSPHC.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}: {}\n".format(colorModelTag,
methodTimer))
# img.save('{}/temp/processingImage.png'.format(self.appDir))
imageComparison.calculateSegmentationDifferences(
logFile, data1EGBIS, data2EGBIS, segmentCountEGBIS, forest,
data1SPHC, data2SPHC, segmentCountSPHC, segm_dict)
def segSPHC(self, colorModelTag, currentImageChannelIndex, isOriginalImage,
numSegments, Sigma, segmentsToMerge, distance_limit, xPix,
yPix):
"""
segSPHC
"""
if xPix == '' or yPix == '':
pixMouse = None
else:
pixMouse = (int(xPix), int(yPix))
segmentCount = 0
outImagePath, imgPath = self.imageService.getImagePath(isOriginalImage)
if imgPath is None:
return
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
methodTimer = time.time()
if colorModelTag == 'RGB':
methodTimer = time.time()
data1, data2, segmentCount, segm_dict = sphc.doSPHC(
imgPath, outImagePath, numSegments, Sigma, segmentsToMerge,
distance_limit, pixMouse)
methodTimer = time.time() - methodTimer
img = self.imageService.openImage(False)
if img is None:
return
self.histogramService.saveHistogram(img=img, model=colorModelTag)
if colorModelTag == 'YUV':
colorModel.rgbToYuv(img.load(), img.size)
methodTimer = time.time()
data1, data2, segmentCount, segm_dict = sphc.doSPHC(
imgPath, outImagePath, numSegments, Sigma, segmentsToMerge,
distance_limit, pixMouse)
methodTimer = time.time() - methodTimer
img = self.imageService.openImage(False)
if img is None:
return
# img.show()
self.histogramService.saveHistogram(img=img, model=colorModelTag)
# colorModel.yuvToRgb(img.load(), img.size)
if colorModelTag == 'HSL':
data = numpy.asarray(img, dtype="float")
data = colorModel.rgbToHsl(data)
methodTimer = time.time()
data1, data2, segmentCount, segm_dict = sphc.doSPHC(
imgPath, outImagePath, numSegments, Sigma, segmentsToMerge,
distance_limit, pixMouse)
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(data=data, model=colorModelTag)
timerTemp = time.time()
data = colorModel.hslToRgb(data)
img = Image.fromarray(
numpy.asarray(numpy.clip(data, 0, 255), dtype="uint8"))
methodTimer = time.time() - timerTemp + methodTimer
logFile = '{}/temp/log/segSPHC.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}: {}\n".format(colorModelTag,
methodTimer))
# img.save('{}/temp/processingImage.png'.format(self.appDir))
imageComparison.calculateSegmentationCriterias(logFile, data1, data2,
segmentCount)
def changeColorModel(self, colorModelTag,
currentImageChannelIndex,
isOriginalImage,
firstChannel,
secondChannel,
thirdChannel):
""" Change color model and channels
@param colorModelTag: The color model tag
@param currentImageChannelIndex: The index of current image channel
"""
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
if colorModelTag == 'RGB':
methodTimer = time.time()
colorModel.changeRgbBalance(img.load(),
img.size,
firstChannel,
secondChannel,
thirdChannel)
logFile = '{}/temp/log/changeColorModelRGB.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}\n".format(time.time() - methodTimer))
imageComparison.calculateImageDifference(None, logFile)
self.histogramService.saveHistogram(img=img, model=colorModelTag)
if currentImageChannelIndex > 0:
colorModel.viewRGBChannelByID(img.load(),
img.size,
currentImageChannelIndex - 1)
if colorModelTag == 'YUV':
methodTimer = time.time()
colorModel.rgbToYuv(img.load(),
img.size,
firstChannel,
secondChannel,
thirdChannel)
logFile = '{}/temp/log/changeColorModelYUV.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}\n".format(time.time() - methodTimer))
imageComparison.calculateImageDifference(None, logFile)
self.histogramService.saveHistogram(img=img, model=colorModelTag)
if currentImageChannelIndex > 0:
colorModel.viewYUVChannelByID(img.load(),
img.size,
currentImageChannelIndex - 1)
colorModel.yuvToRgb(img.load(), img.size)
if colorModelTag == 'HSL':
methodTimer = time.time()
data = numpy.asarray(img, dtype="float")
data = colorModel.rgbToHsl(data,
None,
firstChannel,
secondChannel,
thirdChannel)
logFile = '{}/temp/log/changeColorModelHSL.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}\n".format(time.time() - methodTimer))
imageComparison.calculateImageDifference(None, logFile)
self.histogramService.saveHistogram(data=data, model=colorModelTag)
if currentImageChannelIndex > 0:
colorModel.viewHslChannelByID(data,
currentImageChannelIndex - 1)
data = colorModel.hslToRgb(data)
img = Image.fromarray(numpy.asarray(numpy.clip(data, 0, 255),
dtype="uint8"))
img.save('{}/temp/processingImage.png'.format(self.appDir))
