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 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 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 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 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 dir_thresh(image, thresh=(0, np.pi/2)):
gray = colorModel.rgbToYuv(image, gray.shape)
gray = colorModel.yuvToGrayscaleRgb(gray, gray.shape)
gaussianImg = img.copy()
gaussianDeviation = 1.0 ##############################################
gaussianFilterSize = math.floor(gaussianDeviation*3.0)
filters.gaussianBlur('RGB', 0, gaussianImg.load(),
gaussianImg.size, (gaussianFilterSize, gaussianFilterSize))
edgeDetection.canny('RGB', 0, img.load(), img.size,
gaussianImg.load(), 1, thresh)
dir_threshold = np.zeros_like(gray)
dir_threshold[(gray > thresh[0]) & (gray < thresh[1])] = 1
return dir_threshold
def mag_thresh(image, thresh=(1, 5)):
gray = colorModel.rgbToYuv(image, gray.shape)
gray = colorModel.yuvToGrayscaleRgb(gray, gray.shape)
gaussianImg = img.copy()
gaussianDeviation = 1.0 ##############################################
gaussianFilterSize = math.floor(gaussianDeviation*3.0)
filters.gaussianBlur('RGB', 0, gaussianImg.load(),
gaussianImg.size, (gaussianFilterSize, gaussianFilterSize))
edgeDetection.canny('RGB', 0, img.load(), img.size,
gaussianImg.load(), 1, thresh)
scaled_magnitude = np.uint8(255*gray_magnitude/np.max(gray_magnitude))
mag_thresh = np.zeros_like(scaled_magnitude)
mag_thresh[(scaled_magnitude > thresh[0]) & (scaled_magnitude < thresh[1])] = 1
return mag_thresh
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 detect(self, frame):
#img = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
colorModel.rgbToYuv(frame, frame.shape)
colorModel.yuvToGrayscaleRgb(frame, frame.shape)
roiy_end = frame.shape[0]
roix_end = frame.shape[1]
img = Image.fromarray(
numpy.asarray(numpy.clip(frame, 0, 255), dtype="uint8"))
img.show()
roi = frame[self.road_horizon:roiy_end, 0:roix_end]
print(roi)
#blur = cv2.medianBlur(roi, 5)
blur = numpy.copy(frame)
filters.medianFilter('RGB', 0, blur, blur.shape, (5, 5))
# contours = cv2.Canny(blur, 60, 120)
contours = numpy.copy(blur)
gaussianData = numpy.copy(blur)
gaussianDeviation = 1.0 ##############################################
gaussianFilterSize = math.floor(gaussianDeviation * 3.0)
filters.gaussianBlur('RGB', 0, gaussianData, gaussianData.shape,
(gaussianFilterSize, gaussianFilterSize))
edgeDetection.canny('RGB',
0,
contours,
contours.shape,
gaussianData,
amplifier=1.0,
threshold=(60, 120))
# if self.prob_hough:
# lines = cv2.HoughLinesP(contours, 1, numpy.pi/180, self.vote, minLineLength=30, maxLineGap=100)
# else:
lines = self._standard_hough(contours, self.vote)
if lines is not None:
# find nearest lines to center
lines = lines + numpy.array([
0, self.road_horizon, 0, self.road_horizon
]).reshape(
(1, 1, 4)
) # scale points from ROI coordinates to full frame coordinates
left_bound = None
right_bound = None
for l in lines:
# find the rightmost line of the left half of the frame and the leftmost line of the right half
for x1, y1, x2, y2 in l:
theta = numpy.abs(numpy.arctan2(
(y2 - y1), (x2 - x1))) # line angle WRT horizon
if theta > self.roi_theta: # ignore lines with a small angle WRT horizon
dist = self._base_distance(x1, y1, x2, y2,
frame.shape[1])
if left_bound is None and dist < 0:
left_bound = (x1, y1, x2, y2)
left_dist = dist
elif right_bound is None and dist > 0:
right_bound = (x1, y1, x2, y2)
right_dist = dist
elif left_bound is not None and 0 > dist > left_dist:
left_bound = (x1, y1, x2, y2)
left_dist = dist
elif right_bound is not None and 0 < dist < right_dist:
right_bound = (x1, y1, x2, y2)
right_dist = dist
if left_bound is not None:
left_bound = self._scale_line(left_bound[0], left_bound[1],
left_bound[2], left_bound[3],
frame.shape[0])
if right_bound is not None:
right_bound = self._scale_line(right_bound[0], right_bound[1],
right_bound[2], right_bound[3],
frame.shape[0])
return [left_bound, right_bound]
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 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))
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 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 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 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)
