def testColorImage(self): image = ip.Image() image.open(COLOR_IMAGE_PATH) self.assertIsNotNone(image._image) self.assertEqual(COLOR_IMAGE_HEIGHT, image._height) self.assertEqual(COLOR_IMAGE_WIDTH, image._width)
def testGrayscaleImage(self): image = ip.Image(GRAYSCALE_IMAGE_PATH, grayscale=True) copy = image.copy() self.assertNotEqual(id(image._image), id(copy._image)) self.assertEqual(image._height, copy._height) self.assertEqual(image._width, copy._width)
def testWhiteImage(self): HEIGHT = 200 WIDTH = 300 image = ip.Image(height=HEIGHT, width=WIDTH, grayscale=True) self.assertIsNotNone(image._image) self.assertEqual(HEIGHT, image._height) self.assertEqual(WIDTH, image._width)
def testColorImage(self): image = ip.Image(COLOR_IMAGE_PATH) copy = image.copy() self.assertNotEqual(id(image._image), id(copy._image)) self.assertEqual(image._height, copy._height) self.assertEqual(image._width, copy._width)
def mouseImage(event, x, y, flags, param): """Handles incoming mouse input to the Image window.""" if event==cv.CV_EVENT_LBUTTONDOWN: #Clicked the left button print "x, y are", x, y (b,g,r) = D.image[y,x] print "r,g,b is", int(r), int(g), int(b) (h,s,v) = D.hsv[y,x] print "h,s,v is", int(h), int(s), int(v) D.down_coord = (x,y) D.mouse_down = True elif event==cv.CV_EVENT_LBUTTONUP: #Let go of the left button print "x, y are", x, y (b,g,r) = D.image[y,x] print "r,g,b is", int(r), int(g), int(b) (h,s,v) = D.hsv[y,x] print "h,s,v is", int(h), int(s), int(v) D.up_coord = (x,y) D.mouse_down = False if D.mode == "clear": D.sections = [] else: #Start, add, or subtract -- put lower coordinates first x0, y0, x1, y1 = D.down_coord[0], D.down_coord[1], D.up_coord[0], D.up_coord[1] if x0 > x1: x0, x1 = x1, x0 if y0 > y1: y0, y1 = y1, y0 if D.mode == "start": D.sections = [] mode_dict = {"start":'a', "add":'a', "subtract":'s'} D.sections.append([mode_dict[D.mode], (x0, y0), (x1, y1)]) ImageProcessing.process_section(D) elif event == cv.CV_EVENT_RBUTTONDOWN: #Right click D.target_coord = (x, y) ImageProcessing.target_coord(D) elif D.mouse_down and event==cv.CV_EVENT_MOUSEMOVE: #Mouse just moved D.up_coord = (x,y)
def testColorImage(self): image = ip.Image(COLOR_IMAGE_PATH) image[0, 0, 0] = 99 image[0, 0, 1] = 98 image[0, 0, 2] = 97 self.assertEqual(99, image[0, 0, 0]) self.assertEqual(98, image[0, 0, 1]) self.assertEqual(97, image[0, 0, 2])
def processLabeledImages(self): image = self.image_processing_list[0] boundries = ImageProcessing.GetLineBounds(image.imageArray) line_images_array = [] for i in range(len(boundries)): x, y, w, h = boundries[i] cutImage = image.cutImage(image.imageArray, x, y, x + w, y + h) line_images_array.append(cutImage) Main.userSetLabel(line_images_array, self)
def makeHistogram(self): if not os.path.exists("key"): os.makedirs("key") if not os.path.exists("result"): os.makedirs("result") image = iP.get_image(self.file_path) histogram(image) histogram_pixmap = QtGui.QPixmap('result/histogram.png').scaledToWidth(320) self.label_histogram.setPixmap(histogram_pixmap)
def detect_bbox(self, img): ''' [note] : 文字におけるboundingboxを検出する [input] : img -> boundingboxを検出する画像 [return] : boundingbox配列 ''' # ケニー手法にてエッジ抽出 img_canny = ip.canny(img, min_threshold=180, max_threshold=255) # # 膨張縮小用カーネルを取得(とりあえず3x3) kernel = ip.get_kernel((3, 3), molphology="cross") # ケニーエッジを膨張 # 膨張させすぎると周りと結合し認識精度が下がる。 # あまりさせないとfindContoursのRETR_EXTERNALで文字のエリアがうまく囲めない dilate_canny = ip.dilate(img_canny, kernel, iterations=3) _, contours, _ = ip.find_contours(dilate_canny, retr="external", chain="simple") bboxes = [] cnt = 0 for contour in contours: [x, y, w, h] = ip.get_bounding_rect(contour) if w < 10 or h < 10: continue if w > self.width // 2 or h > self.height // 2: continue if w > h * 2: continue bboxes.append({ "id": cnt, "min_x": x, "min_y": y, "max_x": x + w, "max_y": y + h }) cnt += 1 return np.array(bboxes)
def setupUi(self, MainWindow): MainWindow.setObjectName(_fromUtf8("MainWindow")) MainWindow.resize(830, 630) self.centralwidget = QtGui.QWidget(MainWindow) self.centralwidget.setObjectName(_fromUtf8("centralwidget")) self.label_image = QtGui.QLabel(self.centralwidget) self.label_image.setGeometry(QtCore.QRect(10, 0, 480, 480)) self.label_image.setMinimumSize(QtCore.QSize(480, 480)) self.label_image.setText(_fromUtf8("")) self.label_image.setObjectName(_fromUtf8("label_image")) if self.file_path != "": image = iP.get_image(self.file_path) pixmap = self.parse_image(image, 500) self.label_image.setPixmap(pixmap) self.button_encrypt = QtGui.QPushButton(self.centralwidget) self.button_encrypt.setGeometry(QtCore.QRect(300, 540, 100, 50)) self.button_encrypt.setObjectName(_fromUtf8("button_encrypt")) self.button_encrypt.clicked.connect(self.encrypt) self.button_decrypt = QtGui.QPushButton(self.centralwidget) self.button_decrypt.setGeometry(QtCore.QRect(500, 540, 100, 50)) sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.button_decrypt.sizePolicy().hasHeightForWidth()) self.button_decrypt.setSizePolicy(sizePolicy) self.button_decrypt.setObjectName(_fromUtf8("button_decrypt")) self.button_decrypt.clicked.connect(self.decrypt) self.button_chooseFile = QtGui.QPushButton(self.centralwidget) self.button_chooseFile.setGeometry(QtCore.QRect(100, 540, 100, 50)) self.button_chooseFile.setObjectName(_fromUtf8("button_chooseFile")) self.button_chooseFile.clicked.connect(self.open_file) self.label_histogram = QtGui.QLabel(self.centralwidget) self.label_histogram.setGeometry(QtCore.QRect(500, 200, 320, 240)) self.label_histogram.setMinimumSize(QtCore.QSize(320, 240)) self.label_histogram.setText(_fromUtf8("")) self.label_histogram.setObjectName(_fromUtf8("label_histogram")) MainWindow.setCentralWidget(self.centralwidget) self.menubar = QtGui.QMenuBar(MainWindow) self.menubar.setGeometry(QtCore.QRect(0, 0, 830, 21)) self.menubar.setObjectName(_fromUtf8("menubar")) MainWindow.setMenuBar(self.menubar) self.statusbar = QtGui.QStatusBar(MainWindow) self.statusbar.setObjectName(_fromUtf8("statusbar")) MainWindow.setStatusBar(self.statusbar) self.retranslateUi(MainWindow) QtCore.QMetaObject.connectSlotsByName(MainWindow)
def test_add_alpha(self): input_image = cv2.imread("test_1_crop_circle_0.png", 1) result_image = cv2.imread("test_1_add_alpha_0.png", -1) obj = ip.ImageProcessing() result = obj.add_alpha(input_image) boolean = np.all(result == result_image) self.assertTrue(boolean)
def test_nonanimated_image(self): filename = "test_1" obj = ip.ImageProcessing() result = obj.image_processing(filename) comparable = cv2.imread("test_1_unanimated_image_0.png", -1) state = np.all(comparable == result[0]) self.assertTrue(state)
def __init__(self, src=0): self.stream = cv2.VideoCapture(src) (self.grabbed, rawframe) = self.stream.read() self.frame = None self.monoFrame = None self.stopped = False fwidth = int( self.stream.get(cv2.CAP_PROP_FRAME_WIDTH) ) fheight = int( self.stream.get(cv2.CAP_PROP_FRAME_HEIGHT) ) self.preprocessor = ImageProcessing.VideoPreprocessor(fheight, fwidth) self.preprocessor.findSideToCrop() self.preprocessor.findCropPoints()
def test_get_size(self): obj = ip.ImageProcessing() for i in self.frame_count: with self.subTest(i=i): image = cv2.imread("test_2_frame_{}.png".format(i), 1) dimensions = obj.get_size(image) self.assertEqual(dimensions, (212, 314))
def _getIconToPaint(configTable, availableSize): prcSize = configTable.get_or("sizePercent", 0.2) iconSize = QSize(availableSize.width() * prcSize, availableSize.height() * prcSize) color = QtGui.QColor(configTable.get_or("color", "black")) if not color.isValid(): color = Qt.black opacity = configTable.get_or("opacity", 0.5) pixmap = ImageProcessing.coloredPixmap(configTable.get("path"), iconSize, color, opacity) return pixmap
def test_trim_square(self): input_image = cv2.imread("test_1_pre_trim_square_0.png", 1) result_image = cv2.imread("test_1_trim_square_0.png", 1) obj = ip.ImageProcessing() center = 240, 320 result = obj.trim_square(input_image, center, 240) boolean = np.all(result == result_image) self.assertTrue(boolean)
def __init__(self, path): image = iP.get_image(path) self.main_image = image self.image = image self.height = image.shape[0] self.width = image.shape[1] self.vector_height = [] self.vector_width = [] self.modulo_row = 0 self.modulo_column = 0 self.rotated_height_vector = [] self.rotated_width_vector = []
def test_find_min(self): x = [212, 314, 0, -1] y = [314, 212, 0, -2] result = [0, 1, 1, 1] obj = ip.ImageProcessing() for i in range(len(result)): if obj.find_min(x[i], y[i]) != result[i]: self.assertTrue(False) self.assertTrue(True)
def performOCR(inputName): # Check if training database has been made before. If it was not, make a new one. csv_training_db = "Training_fonts.csv" if not os.path.isfile(csv_training_db): makeTrainingDataSetFromImage("./Train_image_bulks", "Training_fonts", "w") # Set up the model and perform training loop. column_names = [ 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'f10', 'f11', 'f12', 'f13', 'f14', 'f15', 'f16', 'f17', 'f18', 'f19', 'f20', 'f21', 'f22', 'f23', 'f24', 'f25', 'f26', 'f27', 'f28', 'f29', 'f30', 'f31', 'f32', 'character' ] train_dataset = createTrainingDataSet(csv_training_db, column_names, 16, csv_training_db) train_dataset = train_dataset.map(pack_features_vector) model = createEmptyModel(32) optimizer = tf.train.AdamOptimizer(learning_rate=0.001) global_step = tf.train.get_or_create_global_step() doTrainingLoop(200, optimizer, train_dataset, global_step, model) # Extract features from the input image. class_names = [ " ", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "*", "/", "+", "-", "#", ".", ",", "(", ")", ":", "=", "@" ] processed = ImageProcessing.processImage(inputName) features = [] for line in processed: line_f = [] for char in line: if char.size != 0: line_f.append(GetFeatures.getFeatures(char)) if line_f: features.append(line_f) with open("text_output.txt", "w") as f: for i in range(len(features)): predict_dataset = tf.convert_to_tensor(features[i]) predictions = model(predict_dataset) line = "" for i, logits in enumerate(predictions): class_idx = tf.argmax(logits).numpy() p = tf.nn.softmax(logits)[class_idx] name = class_names[class_idx] line += name f.write(line + "\n")
def blockImage(self): """ this use the perPoint to create convex hull and logical operation for each slice """ self._logicSlice = ImageProcessing.LogicRegion(self._denoise_volume[:,:,self._denoise_volume.shape[2]//2], self._convex_xy) self._block_volume = np.empty_like(self._denoise_volume) if self._state == False: for i in range(self._denoise_volume.shape[2]): self._block_volume[:,:,i] = self._denoise_volume[:,:,i] * self._logicSlice elif self._state == True: for i in range(self._start, self._end+1): self._block_volume[:,:,i] = self._denoise_volume[:,:,i] * self._logicSlice
def initCamera(self): self.ci = Camera.CameraInterface() # 获取界面中的相机接口 self.ci.openCamera() self.ci.setAttribute() firstFrame = self.ci.getFirstFrame() ip = ImageProcessing.ImageProcessing(firstFrame) if ip.doHoughTrans(): self.HOUGH_LINE_Y = ip.C else: self.HOUGH_LINE_Y = self.IMG_HEIGHT/2 self.ci.setRoi(self.ROIRANGE, ip.C-self.ROIRANGE/2) self.ci.startCapture()
def test_image_processing(self): result_image = cv2.imread("test_1_image_processing_0.png", -1) obj = ip.ImageProcessing() unanimated_image_result = cv2.imread("test_1_generate_circle_0.png", -1) obj.generate_circle = MagicMock(return_value=unanimated_image_result) result = obj.image_processing("test_1") boolean = np.all(result == result_image) self.assertTrue(boolean)
def test_add_alpha(self): for i in self.frame_count: with self.subTest(i=i): input_image = cv2.imread("test_2_crop_circle_{}.png".format(i), 1) result_image = cv2.imread("test_2_add_alpha_{}.png".format(i), -1) obj = ip.ImageProcessing() result = obj.add_alpha(input_image) boolean = np.all(result == result_image) self.assertTrue(boolean)
def handle_image_data(data): """Handles incoming RGB image data from the Kinect.""" #Get the incoming RGB image from the Kinect D.image = D.bridge.imgmsg_to_cv(data, "bgr8") if D.created_images == False: #Initialize the additional images we need for processing ImageProcessing.initialize(D) D.created_images = True # Recalculate threshold image ImageProcessing.threshold_image(D) # Recalculate blob in main image ImageProcessing.find_biggest_region(D) # Check on the display of dragged section ImageProcessing.mouse_section(D) #Display target circle #ImageProcessing.target_coord(D) #Display info box on image ImageProcessing.draw_on_image(D) #Handle incoming key presses key_press = cv.WaitKey(5) & 255 if key_press != 255: #Handle only if it's a real key check_key_press(D, key_press) #(255 = "no key pressed") #Update the displays: #Show main image in the image window cv.ShowImage('Image', D.image) #Show threshold image in the threshold window currentThreshold = getattr(D, D.current_threshold) cv.ShowImage('Threshold', currentThreshold)
def test_trim_square(self): for i in self.frame_count: with self.subTest(i=i): input_image = cv2.imread("test_2_pre_trim_square_{}.png".format(i), 1) result_image = cv2.imread("test_2_trim_square_{}.png".format(i), 1) obj = ip.ImageProcessing() center = 106, 157 result = obj.trim_square(input_image, center, 106) boolean = np.all(result == result_image) self.assertTrue(boolean)
def process_image(image): global time_last_email_sent faces = ImageProcessing.detect_faces(image) print("Processed image.") if len(faces) > 0: current = time.time() if current - time_last_email_sent < email_timeout: print("Email timeout in effect %.1f." % (current - time_last_email_sent)) else: print("Sending email.") send_email(image) time_last_email_sent = current
def test_animated_image(self): filename = "test_2" obj = ip.ImageProcessing() result = obj.image_processing(filename) for i, res in enumerate(result): with self.subTest(i=i): comparable = cv2.imread( "test_2_animated_image_{}.png".format(i), -1) state = np.all(comparable == res) self.assertTrue(state)
def displayEdgeImg(self, oriImg): # 边缘显示区域的处理 if self.isMeasuring == 0: # 打开系统,但是未选择测量时 # 边缘显示区域也显示原始图像 img = q2n.gray2qimage(oriImg) img = img.scaled(self.IMG_WIDTH/2, self.ROIRANGE/2, Qt.KeepAspectRatio) self.label_canny.setPixmap(QPixmap.fromImage(img)) # 在原始图像显示区域写入图像 return elif self.isMeasuring == 2: # 仅仅用于演示和显示边缘图像,不对图像进行运算处理 ip = ImageProcessing.ImageProcessing(oriImg) img = cv2.resize(ip.cannyImg, (self.IMG_WIDTH / 2, self.ROIRANGE / 2), cv2.INTER_NEAREST) img = q2n.gray2qimage(img) # 此方法显示会将边缘放大,但实际处理的数据不会改变 self.label_canny.setPixmap(QPixmap.fromImage(img)) # 在边缘显示区域写入图像 return '''单击【自动测量按钮后】 self.isMeasuring==1的情况''' ip = ImageProcessing.ImageProcessing(oriImg) topCurve, bottomCurve = dp.getEdgeList(ip.cannyImg) # waveHeightByPeak, waveLengthByPeak = dp.getWaveParaByPeak(topCurve, bottomCurve) waveHeightBySin, waveLengthBySin = dp.getWaveParaBySin(topCurve, bottomCurve) # 显示钢丝波高的值 waveShow = "%0.1f" % (waveHeightBySin * 6.6188 - 7.356) waveShow += "um" self.label_wave_height.setText(QString(str(waveShow))) img = cv2.resize(ip.cannyImg, (self.IMG_WIDTH / 2, self.ROIRANGE / 2), cv2.INTER_NEAREST) img = q2n.gray2qimage(img) # 此方法显示会将边缘放大,但实际处理的数据不会改变 self.label_canny.setPixmap(QPixmap.fromImage(img)) # 在边缘显示区域写入图像 self.cntImgMeasuring += 1 self.progressBar.setValue(self.cntImgMeasuring) # 更新进度条当前进度 self.waveHeightList.append(waveHeightBySin) self.waveLengthList.append(waveLengthBySin) # 计数器和数据记录 if self.cntImgMeasuring > self.rotatePeriod: # 测量时间大于设定值 self.completeMeasure() # 测量完成进行相应得清零和整理工作
class TestImageProc(unittest.TestCase): @classmethod def setUpClass(self): pass def setUp(self): self.ImageProc = ImageProcessing(False) def test_get_contours_no_diff(self): array = np.zeros([100, 100], dtype=np.uint8) contours = self.ImageProc.get_contours_of_moved_objects(array) print(len(contours)) self.assertEqual(len(contours), 0) def test_get_contours_diff(self): contours = self.ImageProc.get_contours_of_moved_objects( np.zeros([100, 100], dtype=np.uint8)) img = np.zeros([100, 100], dtype=np.uint8) img[:] = 255 contours = self.ImageProc.get_contours_of_moved_objects(img) self.assertGreater(len(contours), 0) def test_get_median(self): self.ImageProc.get_contours_of_moved_objects( np.zeros([100, 100], dtype=np.uint8)) self.ImageProc.get_contours_of_moved_objects( np.zeros([100, 100], dtype=np.uint8)) img = np.zeros([100, 100], dtype=np.uint8) img[:] = 255 self.ImageProc.get_contours_of_moved_objects(img) old_image = self.ImageProc.get_median() self.assertEqual(old_image[0][0], 0) @classmethod def tearDownClass(self): pass
def test_image_processing(self): for i in self.frame_count: with self.subTest(i=i): result_image = cv2.imread("test_2_image_processing_{}.png".format(i), -1) obj = ip.ImageProcessing() unanimated_image_result = cv2.imread("test_2_generate_circle_{}.png".format(i), -1) obj.generate_circle = MagicMock(return_value=unanimated_image_result) result = obj.image_processing("test_2") boolean = np.all(result == result_image) self.assertTrue(boolean)
correct_circles = (('OnWater1.jpg',((520,312,100),)),('OnDeck.jpg',((731,416,106),)) ,('TwoBalls.jpg',((519,308,106),(1534,312,106)))) circle_comparisons = [] num_balls = 0 for file_name,measur_circle in correct_circles: #Keep track of the number of balls measured num_balls+= len(measur_circle) image = InputOutput.get_image(file_name) InputOutput.display_image(image,"Starting Image") image_hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) # convert to HSV for thresholding image_hsv = cv2.blur(image_hsv, (9,9)) # blur to reduce noise thresh = ImageProcessing.thresholdRed(image_hsv) InputOutput.display_image(thresh,"Thresholded") thresh = ImageProcessing.removeNoise(thresh) #calc_circles = ImageProcessing.houghTransform(thresh) calc_circles = ImageProcessing.blob_circle_detection(thresh) if calc_circles == None: calc_circles = [] #calc_circles = ImageProcessing.get_blob_centroid(image, thresh, 5) InputOutput.display_image_with_circles(image,"Result!",calc_circles) #evalueateSuccess by comparing the circle position with the most similar #red ball's measured circle. #Print basic file facts
import numpy as np import cv2 import ImageProcessing handImg = cv2.imread("../data/hand.png") eyeImg = cv2.imread("../data/eye.png") maskImg = cv2.imread("../data/mask.png") #zmiana obrazka kolorowego na obrazek w skali szarosci mask = np.mean(maskImg, axis=2) eyeImg = ImageProcessing.colorTransfer(handImg, eyeImg, mask) blendedImg = ImageProcessing.blendImages(eyeImg, handImg, mask) cv2.imwrite("../eyeHandBlend.jpg", blendedImg)
if shapes2D is not None: for shape2D in shapes2D: #3D model parameter initialization modelParams = projectionModel.getInitialParameters(mean3DShape[:, idxs3D], shape2D[:, idxs2D]) #3D model parameter optimization modelParams = NonLinearLeastSquares.GaussNewton(modelParams, projectionModel.residual, projectionModel.jacobian, ([mean3DShape[:, idxs3D], blendshapes[:, :, idxs3D]], shape2D[:, idxs2D]), verbose=0) #rendering the model to an image shape3D = utils.getShape3D(mean3DShape, blendshapes, modelParams) renderedImg = renderer.render(shape3D) #blending of the rendered face with the image mask = np.copy(renderedImg[:, :, 0]) renderedImg = ImageProcessing.colorTransfer(cameraImg, renderedImg, mask) cameraImg = ImageProcessing.blendImages(renderedImg, cameraImg, mask) #drawing of the mesh and keypoints if drawOverlay: drawPoints(cameraImg, shape2D.T) drawProjectedShape(cameraImg, [mean3DShape, blendshapes], projectionModel, mesh, modelParams, lockedTranslation) if writer is not None: writer.write(cameraImg) cv2.imshow('image', cameraImg) key = cv2.waitKey(1) if key == 27: