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)