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 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 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 detectRoadLane(self, colorModelTag, currentImageChannelIndex,
isOriginalImage):
outImagePath, imgPath = self.imageService.getImagePath(isOriginalImage)
if imgPath is None:
return
methodTimer = time.time()
detectRoadLane.doFindLane(imgPath, outImagePath)
methodTimer = time.time() - methodTimer
img = self.imageService.openImage(False)
self.histogramService.saveHistogram(img=img, model=colorModelTag)
logFile = '{}/temp/log/detectRoadLane.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}: {}\n".format(colorModelTag,
methodTimer))
imageComparison.calculateImageDifference(colorModelTag, logFile)
def changeGamma(self, isOriginalImage, value):
"""
Change image gamma
"""
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
methodTimer = time.time()
colorCorrector.gamma(img.load(), img.size, value)
logFile = '{}/temp/log/changeGamma.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)
img.save('{}/temp/processingImage.png'.format(self.appDir))
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 toAutolevels(self, isOriginalImage):
"""
Convert image to autolevels
@param isOriginalImage: The value for choose original or processing Image
"""
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
methodTimer = time.time()
colorCorrector.autolevels(img.load(), img.size)
logFile = '{}/temp/log/toAutolevels.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)
img.save('{}/temp/processingImage.png'.format(self.appDir))
def toGrayscale(self, isOriginalImage):
""" Convert image to grayscale
@param isOriginalImage: The value for choose original or processing Image
"""
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
methodTimer = time.time()
colorModel.rgbToYuv(img.load(), img.size)
colorModel.yuvToGrayscaleRgb(img.load(), img.size)
logFile = '{}/temp/log/toGrayscale.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}\n".format(time.time() - methodTimer))
imageComparison.calculateImageDifference(None, logFile)
img.save('{}/temp/processingImage.png'.format(self.appDir))
self.histogramService.saveHistogram(img=img, model='RGB')
def morphOpening(self, colorModelTag, currentImageChannelIndex,
isOriginalImage, maskWidth, maskHeight):
"""
morphOpening
"""
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
methodTimer = time.time()
img = morphology.opening(colorModelTag, currentImageChannelIndex, img,
self.maskList, (maskWidth, maskHeight))
methodTimer = time.time() - methodTimer
self.histogramService.saveHistogram(img=img, model=colorModelTag)
logFile = '{}/temp/log/morphOpening.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 niblackBinarize(self, colorModelTag, currentImageChannelIndex,
isOriginalImage, aperture_height, aperture_width):
"""
Niblack's method
"""
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
img = img.convert(mode='L')
methodTimer = time.time()
localThresholding.niblack(img.load(), img.size,
(aperture_height, aperture_width))
methodTimer = time.time() - methodTimer
logFile = '{}/temp/log/niblackBinarize.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}: {}\n".format(colorModelTag,
methodTimer))
img = img.convert(mode='RGB')
img.save('{}/temp/processingImage.png'.format(self.appDir))
imageComparison.calculateImageDifference(colorModelTag, logFile)
def histThresholdBinarize(self, colorModelTag, currentImageChannelIndex,
isOriginalImage, otsu_k):
"""
Binarize with histogram threshold
"""
img = self.imageService.openImage(isOriginalImage)
if img is None:
return
img = img.convert(mode='L')
methodTimer = time.time()
globalThresholding.histogramSegmentation(img.load(), img.size,
'histPeakValue', otsu_k)
methodTimer = time.time() - methodTimer
logFile = '{}/temp/log/histThresholdBinarize.log'.format(self.appDir)
with open(logFile, "a+") as text_file:
text_file.write("Timer: {}: {}\n".format(colorModelTag,
methodTimer))
img = img.convert(mode='RGB')
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 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 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))
