def getMat(self): hdc = win32gui.GetWindowDC(self.hwnd) dc_obj = win32ui.CreateDCFromHandle(hdc) memorydc = dc_obj.CreateCompatibleDC() data_bitmap = win32ui.CreateBitmap() data_bitmap.CreateCompatibleBitmap(dc_obj, self.width, self.height) memorydc.SelectObject(data_bitmap) memorydc.BitBlt((0, 0), (self.width, self.height), dc_obj, (self.dx, self.dy), win32con.SRCCOPY) bmpheader = struct.pack("LHHHH", struct.calcsize("LHHHH"), self.width, self.height, 1, 24) c_bmpheader = ctypes.create_string_buffer(bmpheader) # padded_length = (string_length + 3) & -3 for 4-byte aligned. c_bits = ctypes.create_string_buffer(" " * (self.width * ((self.height * 3 + 3) & -3))) res = ctypes.windll.gdi32.GetDIBits(memorydc.GetSafeHdc(), data_bitmap.GetHandle(), 0, self.height, c_bits, c_bmpheader, win32con.DIB_RGB_COLORS) win32gui.DeleteDC(hdc) win32gui.ReleaseDC(self.hwnd, hdc) memorydc.DeleteDC() win32gui.DeleteObject(data_bitmap.GetHandle()) cv_im = cv.CreateImageHeader((self.width, self.height), cv.IPL_DEPTH_8U, 3) cv.SetData(cv_im, c_bits.raw) # flip around x-axis cv.Flip(cv_im, None, 0) mat = cv.GetMat(cv_im) return numpy.asarray(mat)
def initGrabQt(self): image_qt = QtGui.QPixmap.grabWidget(self.view).toImage() image_qt_size = (image_qt.size().width(), image_qt.size().height()) cv_im_4chan = cv.CreateImageHeader(image_qt_size, cv.IPL_DEPTH_8U, 4) cv_im = cv.CreateImage(image_qt_size, cv.IPL_DEPTH_8U, 3) cv.SetData(cv_im_4chan, image_qt.bits().asstring(image_qt.numBytes())) cv.CvtColor(cv_im_4chan, cv_im, cv.CV_RGBA2RGB) fourcc = cv.CV_FOURCC('D','I','V','X') fps = 25 width, height = cv.GetSize(cv_im) self.writer = cv.CreateVideoWriter('out3.avi', fourcc, fps, (int(width), int(height)), 1) cv.WriteFrame(self.writer, cv_im) timer = QtCore.QTimer() time_interval = 1000 / 25 timer.setInterval(time_interval) timer.timeout.connect(self.grabFrameQt) timer.start() self.timer = timer self.stopTimer = QtCore.QTimer() self.stopTimer.setInterval(self.total_time) self.stopTimer.timeout.connect(self.stopCapture) self.stopTimer.setSingleShot(True) self.stopTimer.start()
def initGrab(self): image = ImageGrab.grab(self.geometry) cv_im = cv.CreateImageHeader(image.size, cv.IPL_DEPTH_8U, 3) cv.SetData(cv_im, image.tostring()) cv.CvtColor(cv_im, cv_im, cv.CV_RGB2BGR) fourcc = cv.CV_FOURCC('D','I','V','X') fps = 25 width, height = cv.GetSize(cv_im) #print width, height self.writer = cv.CreateVideoWriter('out3.avi', fourcc, fps, (int(width), int(height)), 1) cv.WriteFrame(self.writer, cv_im) self.frames_count = 1 timer = QtCore.QTimer() time_interval = 1000 / 25 timer.setInterval(time_interval) timer.timeout.connect(self.grabFrame) timer.start() self.timer = timer self.stopTimer = QtCore.QTimer() self.stopTimer.setInterval(self.total_time) self.stopTimer.timeout.connect(self.stopCapture) self.stopTimer.setSingleShot(True) self.stopTimer.start()
def mkdmtx(msg): dm_write = DataMatrix() dm_write.encode(msg) pi = dm_write.image # .resize((14, 14)) cv_im = cv.CreateImageHeader(pi.size, cv.IPL_DEPTH_8U, 3) cv.SetData(cv_im, pi.tostring()) return cv_im
def invoke(self, arg, from_tty): args = gdb.string_to_argv(arg) # generally, we type "plot someimage" in the GDB commandline # where "someimage" is an instance of cv::Mat v = gdb.parse_and_eval(args[0]) # the value v is a gdb.Value object of C++ # code's cv::Mat, we need to translate to # a python object under cv2.cv image_size = (v['cols'],v['rows']) # print v # these two below lines do not work. I don't know why # channel = gdb.execute("call "+ args[0] + ".channels()", False, True) # channel = v.channels(); CV_8U =0 CV_8S =1 CV_16U=2 CV_16S=3 CV_32S=4 CV_32F=5 CV_64F=6 CV_USRTYPE1=7 CV_CN_MAX = 512 CV_CN_SHIFT = 3 CV_MAT_CN_MASK = (CV_CN_MAX - 1) << CV_CN_SHIFT flags = v['flags'] channel = (((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1 CV_DEPTH_MAX = (1 << CV_CN_SHIFT) CV_MAT_DEPTH_MASK = CV_DEPTH_MAX - 1 depth = (flags) & CV_MAT_DEPTH_MASK IPL_DEPTH_SIGN = 0x80000000 cv_elem_size = (((4<<28)|0x8442211) >> depth*4) & 15 if (depth == CV_8S or depth == CV_16S or depth == CV_32S): mask = IPL_DEPTH_SIGN else: mask = 0 ipl_depth = cv_elem_size*8 | mask img = cv.CreateImageHeader(image_size, ipl_depth, channel) # conver the v['data'] type to "char*" type char_type = gdb.lookup_type("char") char_pointer_type =char_type.pointer() buffer = v['data'].cast(char_pointer_type) # read bytes from inferior's memory, because # we run the opencv-python module in GDB's own process # otherwise, we use memory corss processes buf = v['step']['buf'] bytes = buf[0] * v['rows'] # buf[0] is the step? Not quite sure. inferior = gdb.selected_inferior() mem = inferior.read_memory(buffer, bytes) # set the img's raw data cv.SetData(img, mem) mat = np.asarray(img[:,:]) print ("Type: {}".format(mat.dtype)) print (mat)
def ocr(self): if self.last_image is not None: image = self.last_image # Add border to keep the characters off the edges offset = 20 height, width, channel = image.shape image = cv2.copyMakeBorder(image, offset, offset, offset, offset, cv2.BORDER_CONSTANT, value=(255, 255, 255)) # Init and configure tesseract api api = tesseract.TessBaseAPI() api.Init(".", "eng", tesseract.OEM_DEFAULT) api.SetPageSegMode(tesseract.PSM_AUTO) api.SetVariable("tessedit_char_whitelist", self.white_list) # Convert to cv image to to pass to tess api # Derived from example code here: http://blog.mimvp.com/2015/11/python-ocr-recognition/ height, width, channel = image.shape iplimage = cv.CreateImageHeader((width, height), cv.IPL_DEPTH_8U, channel) cv.SetData(iplimage, image.tostring(), image.dtype.itemsize * channel * (width)) tesseract.SetCvImage(iplimage, api) api.Recognize(None) ri = api.GetIterator() level = tesseract.RIL_WORD if (ri): word = ri.GetUTF8Text(level) return word
def pil2cvGrey(pil_im): # Convert a PIL image to a greyscale cv image # from: http://pythonpath.wordpress.com/2012/05/08/pil-to-opencv-image/ pil_im = pil_im.convert('L') cv_im = cv.CreateImageHeader(pil_im.size, cv.IPL_DEPTH_8U, 1) cv.SetData(cv_im, pil_im.tostring(), pil_im.size[0]) return cv_im
def startServer(sndOnly): global mySock global srcSock #global ctlSock global threads global mutexLock global gameDataQRcv, gameDataQSnd global lastScore, imgSnd mySock = socket.socket(socket.AF_INET,socket.SOCK_STREAM) SOCKNUM = 2 HOST = "0.0.0.0" PORT = 9129 mySock.bind((HOST, PORT)) mySock.listen(SOCKNUM) print "Start Server!" srcSock, src_addr = mySock.accept() print "Source Channel Connected by", src_addr ''' ctlSock, dst_addr = mySock.accept() print "Control Channel Connected by", dst_addr ''' lastScore = 0 gameDataQRcv = Queue.Queue(maxsize = 128) #FIFO gameDataQSnd = Queue.Queue(maxsize = 128) ''' t1 = threading.Thread(target=ctrlThread) threads.append(t1) mutex1 = threading.Lock() mutexs.append(mutex1) t1.setDaemon(True) t1.start() ''' mutexLock = threading.Lock() if not sndOnly: t2 = threading.Thread(target=gameDataRcvThread) threads.append(t2) t2.setDaemon(True) t2.start() t21 = threading.Thread(target=gameDataSndThread) threads.append(t21) t21.setDaemon(True) t21.start() else: imgSnd = cv.CreateImageHeader((288, 512), cv.IPL_DEPTH_8U, 3) t21 = threading.Thread(target=gameFrameSndThread) threads.append(t21) t21.setDaemon(True) t21.start() t3 = threading.Thread(target=showInforThread) threads.append(t3) t3.setDaemon(True) t3.start() return 0
def string_to_iplimage(self, im): # Convert the image return by urllib into an OpenCV image pilim = StringIO(im) source = Image.open(pilim).convert("RGB") self.image = cv.CreateImageHeader(source.size, cv.IPL_DEPTH_8U, 3) cv.SetData(self.image, source.tobytes()) cv.CvtColor(self.image, self.image, cv.CV_RGB2BGR)
def capture(self): if (self.count == 0 and self.writer): img_str = pygame.image.tostring(self.surface, 'RGB') cv_image = cv.CreateImageHeader(self.surface.get_size(), cv.IPL_DEPTH_8U, 3) cv.SetData(cv_image, img_str) self.writer.write(np.asarray(cv_image[:, :])) self.count = (self.count + 1) % self.rate
def _capture(self): self._isCapturing = True ts = time.time() buf = self._cap() mat = cv.CreateImageHeader((1280 / self._bin, 1024 / self._bin), cv.IPL_DEPTH_8U, 1) cv.SetData(mat, buf, cv.CV_AUTOSTEP) self._imgBuf = {'img': mat, 'time': ts} self._isCapturing = False
def do_ocr(self, cv2_img): h, w, c = cv2_img.shape cv_img = cv.CreateImageHeader((w, h), cv.IPL_DEPTH_8U, c) cv.SetData(cv_img, cv2_img.tostring(), cv2_img.dtype.itemsize * c * w) # tesseract.SetCvImage(cv_img, self.ocr_api) text = self.ocr_api.GetUTF8Text() # return text
def iplimage_from_array(source): """ The new Python-OpenCV-Binding cv2 uses numpy arrays as images, while the old API uses the same image format (Iplimage) as the c/c++ binding. This function can be used to create a Iplimage from a numpy array. """ w, h = source.shape bitmap = cv.CreateImageHeader((h, w), cv.IPL_DEPTH_8U, 1) cv.SetData(bitmap, source.tostring(), source.dtype.itemsize * h) return bitmap
def grabFrame(self): image = ImageGrab.grab(self.geometry) cv_im = cv.CreateImageHeader(image.size, cv.IPL_DEPTH_8U, 3) cv.SetData(cv_im, image.tostring()) cv.WriteFrame(self.writer, cv_im) self.frames_count += 1 print self.frames_count
def grabFrameQt(self): image_qt = QtGui.QPixmap.grabWidget(self.view).toImage() image_qt_size = (image_qt.size().width(), image_qt.size().height()) cv_im_4chan = cv.CreateImageHeader(image_qt_size, cv.IPL_DEPTH_8U, 4) cv_im = cv.CreateImage(image_qt_size, cv.IPL_DEPTH_8U, 3) cv.SetData(cv_im_4chan, image_qt.bits().asstring(image_qt.numBytes())) cv.CvtColor(cv_im_4chan, cv_im, cv.CV_RGBA2RGB) cv.WriteFrame(self.writer, cv_im)
def _array_to_cv(arr): """Return a NumPy array as an OpenCV image object.""" utils.swap_rgb(arr, utils._PREFERRED_RGB, to=_OCV_RGB) im_channels = utils.depth(arr) im_shape = _swap(*arr.shape) im_size = arr.dtype.itemsize * im_channels * im_shape[0] im_depth = _cv_depths_inv[str(arr.dtype)] im = cv.CreateImageHeader(im_shape, im_depth, im_channels) cv.SetData(im, arr.tostring(), im_size) return im
def __init__(self, camera_id): self._videoProxy = None self._cameraID = camera_id self._resolution = vision_definitions.kQVGA # 320 * 240 self._colorSpace = vision_definitions.kBGRColorSpace self._fps = 30 self._imgClient = "" self._imgData = None self._img = cv.CreateImageHeader((320, 240), cv.IPL_DEPTH_8U, 3) cv.NamedWindow("Camera_OpenCV_" + str(camera_id), 0)
def get_image2(self): try: resp = urllib.urlopen(self.url) jpg = np.asarray(bytearray(resp.read()), dtype="uint8") source = cv2.imdecode(np.fromstring(jpg, dtype=np.uint8),cv2.CV_LOAD_IMAGE_COLOR) bitmap = cv.CreateImageHeader((source.shape[1], source.shape[0]), cv.IPL_DEPTH_8U, 3) cv.SetData(bitmap, source.tostring(), source.dtype.itemsize * 3 * source.shape[1]) self.last_image = bitmap except: bitmap = self.last_image return bitmap
def ocr(self, image): """Return OCR result.""" api = tesseract.TessBaseAPI() api.Init(".", "big", tesseract.OEM_DEFAULT) api.SetPageSegMode(tesseract.PSM_SINGLE_BLOCK) h, w = image.shape w_step = w * image.dtype.itemsize iplimage = cv.CreateImageHeader((w, h), cv.IPL_DEPTH_8U, 1) cv.SetData(iplimage, image.tostring(), image.dtype.itemsize * (w)) tesseract.SetCvImage(iplimage, api) hocr = api.GetHOCRText(0) return hocr
def __init__(self, IP, PORT, CameraID): self._videoProxy = None self._cameraID = CameraID self._resolution = vision_definitions.kQVGA # 320 * 240 self._colorSpace = vision_definitions.kBGRColorSpace self._fps = 30 self._imgClient = "" self._imgData = None self._img = cv.CreateImageHeader((320, 240), cv.IPL_DEPTH_8U, 3) cv.NamedWindow("Camera_OpenCV", 0) self._registerImageClient(IP, PORT)
def callFaceTracker(self, cameraIndex2): arguments = (str(cameraIndex2)) sys.argv = ["FaceTracker.py"] + list(arguments) # sys.argv = ["testing mainf"] + list(m_args) parser = OptionParser( usage="usage: %prog [options] [filename|camera_index]") parser.add_option("-c", "--cascade", action="store", dest="cascade", type="str", help="Haar cascade file, default %default", default=HCDIR + "haarcascade_frontalface_alt_tree.xml") # parser.add_option("-c", "--cascade", action="store", dest="cascade", type="str", help="Haar cascade file, default %default", default = "../data/haarcascades/haarcascade_frontalface_alt.xml") (options, args) = parser.parse_args() self.cascade = cv.Load(options.cascade) # detect eyes self.cascade2 = cv.Load(DATADIR2 + "haarcascade eye.xml") # cascade2 = cv.Load(HCDIR + "..\\eyes\\eye.xml") # cascade3 = cv.Load(HCDIR + "haarcascade_mcs_mouth.xml") self.cascade3 = cv.Load(DATADIR2 + "Mouth.xml") if len(args) != 1: parser.print_help() sys.exit(1) # input_name = args[0] # if input_name.isdigit(): # capture = cv.CreateCameraCapture(int(input_name)) # else: # capture = None # cv.NamedWindow("result", 1) frame_copy = self.cam2.read() # self.cam.read() imageArray = frame_copy[1] imageFrame = cv.CreateImageHeader( (imageArray.shape[1], imageArray.shape[0]), cv.IPL_DEPTH_8U, 3) cv.SetData(imageFrame, imageArray.tostring(), imageArray.dtype.itemsize * 3 * imageArray.shape[1]) # imageArray = np.zeros(()) self.tracker = FaceTracker.FaceTracker() # print frame_copy.shape self.tracker.detect_and_draw(imageFrame, self.cascade, self.cascade2, self.cascade3)
def get_image(self): stream=urllib.urlopen(self.url) bytes='' while True: bytes+=stream.read(1024) a = bytes.find('\xff\xd8') b = bytes.find('\xff\xd9') if a!=-1 and b!=-1: jpg = bytes[a:b+2] bytes= bytes[b+2:] source = cv2.imdecode(np.fromstring(jpg, dtype=np.uint8),cv2.CV_LOAD_IMAGE_COLOR) bitmap = cv.CreateImageHeader((source.shape[1], source.shape[0]), cv.IPL_DEPTH_8U, 3) cv.SetData(bitmap, source.tostring(), source.dtype.itemsize * 3 * source.shape[1]) return bitmap
def ocr(self, image, area, factor): api = tesseract.TessBaseAPI() api.Init(".", "big", tesseract.OEM_DEFAULT) api.SetPageSegMode(tesseract.PSM_SINGLE_BLOCK) h, w = image.shape w_step = w * image.dtype.itemsize iplimage = cv.CreateImageHeader((w, h), cv.IPL_DEPTH_8U, 1) cv.SetData(iplimage, image.tostring(), image.dtype.itemsize * (w)) tesseract.SetCvImage(iplimage, api) api.SetRectangle(int(area[0][0] * factor), int(area[0][1] * factor), int(area[1][0] * factor) - int(area[0][0] * factor), int(area[1][1] * factor) - int(area[0][1] * factor)) res = self.hocrToObject(api.GetHOCRText(0), area, factor) return res
def findImageEx(self, source, x, y, width, height): hdc = win32gui.GetWindowDC(self.hwnd) dc_obj = win32ui.CreateDCFromHandle(hdc) memorydc = dc_obj.CreateCompatibleDC() data_bitmap = win32ui.CreateBitmap() data_bitmap.CreateCompatibleBitmap(dc_obj, self.width, self.height) memorydc.SelectObject(data_bitmap) memorydc.BitBlt((0, 0), (self.width, self.height), dc_obj, (self.dx, self.dy), win32con.SRCCOPY) bmpheader = struct.pack("LHHHH", struct.calcsize("LHHHH"), self.width, self.height, 1, 24) c_bmpheader = ctypes.create_string_buffer(bmpheader) # padded_length = (string_length + 3) & -3 for 4-byte aligned. c_bits = ctypes.create_string_buffer(" " * (self.width * ((self.height * 3 + 3) & -3))) res = ctypes.windll.gdi32.GetDIBits(memorydc.GetSafeHdc(), data_bitmap.GetHandle(), 0, self.height, c_bits, c_bmpheader, win32con.DIB_RGB_COLORS) win32gui.DeleteDC(hdc) win32gui.ReleaseDC(self.hwnd, hdc) memorydc.DeleteDC() win32gui.DeleteObject(data_bitmap.GetHandle()) cv_im = cv.CreateImageHeader((self.width, self.height), cv.IPL_DEPTH_8U, 3) cv.SetData(cv_im, c_bits.raw) # flip around x-axis cv.Flip(cv_im, None, 0) im_region = cv.GetSubRect(cv_im, (x, y, width, height)) #cv.SaveImage('aaak.bmp', im_region) template_source = cv.LoadImage(source) # From the manual of MatchTemplate result_width = im_region.width - template_source.width + 1 result_height = im_region.height - template_source.height + 1; result = cv.CreateImage((result_width, result_height), 32, 1) cv.MatchTemplate(im_region, template_source, result, cv2.TM_CCOEFF_NORMED) minVal, maxVal, minLoc, maxLoc = cv.MinMaxLoc(result) #print minVal, maxVal, minLoc, maxLoc minLoc2 = minLoc[0] + x, minLoc[1] + y maxLoc2 = maxLoc[0] + x, maxLoc[1] + y return minVal, maxVal, minLoc2, maxLoc2
def pretty_depth_cv(depth): """Converts depth into a 'nicer' format for display This is abstracted to allow for experimentation with normalization Args: depth: A numpy array with 2 bytes per pixel Returns: An opencv image who's datatype is unspecified """ import cv2.cv as cv depth = pretty_depth(depth) image = cv.CreateImageHeader((depth.shape[1], depth.shape[0]), cv.IPL_DEPTH_8U, 1) cv.SetData(image, depth.tostring(), depth.dtype.itemsize * depth.shape[1]) return image
def array2cv(a): dtype2depth = { 'uint8': cv.IPL_DEPTH_8U, 'int8': cv.IPL_DEPTH_8S, 'uint16': cv.IPL_DEPTH_16U, 'int16': cv.IPL_DEPTH_16S, 'int32': cv.IPL_DEPTH_32S, 'float32': cv.IPL_DEPTH_32F, 'float64': cv.IPL_DEPTH_64F, } try: nChannels = a.shape[2] except: nChannels = 1 cv_im = cv.CreateImageHeader((a.shape[1], a.shape[0]), dtype2depth[str(a.dtype)], nChannels) cv.SetData(cv_im, a.tostring(), a.dtype.itemsize * nChannels * a.shape[1]) return cv_im
def video_cv(video): """Converts video into a BGR format for opencv This is abstracted out to allow for experimentation Args: video: A numpy array with 1 byte per pixel, 3 channels RGB Returns: An opencv image who's datatype is 1 byte, 3 channel BGR """ import cv2.cv as cv video = video[:, :, ::-1] # RGB -> BGR image = cv.CreateImageHeader((video.shape[1], video.shape[0]), cv.IPL_DEPTH_8U, 3) cv.SetData(image, video.tostring(), video.dtype.itemsize * 3 * video.shape[1]) return image
def update_video(self): (self.readsuccessful,self.f) = self.cam.read() self.gray_im = cv2.cvtColor(self.f, cv2.COLOR_RGB2BGRA) #self.gray_im = cv2.cvtColor(self.f, cv2.COLOR_RGB2GRAY) self.a = Image.fromarray(self.gray_im) self.b = ImageTk.PhotoImage(image=self.a) self.canvas.create_image(0,0,image=self.b,anchor=tk.NW) self.topWindow.update() # call facetracker (readsuccessful,f) = self.cam2.read() imageArray = f imageFrame = cv.CreateImageHeader((imageArray.shape[1], imageArray.shape[0]), cv.IPL_DEPTH_8U, 3) cv.SetData(imageFrame, imageArray.tostring(), imageArray.dtype.itemsize * 3 * imageArray.shape[1]) self.tracker.detect_and_draw(imageFrame, self.cascade, self.cascade2, self.cascade3) self.topWindow.after(1,self.update_video)
def ocr(self, image, area, factor): api = tesseract.TessBaseAPI() #print self.lang if self.lang == "big" or self.lang == "eng": api.Init(".","big",tesseract.OEM_DEFAULT) else: api.Init(".", str(self.lang), tesseract.OEM_DEFAULT) api.SetPageSegMode(tesseract.PSM_SINGLE_BLOCK) h,w = image.shape w_step = w*image.dtype.itemsize iplimage = cv.CreateImageHeader((w,h), cv.IPL_DEPTH_8U, 1) cv.SetData(iplimage, image.tostring(),image.dtype.itemsize * (w)) tesseract.SetCvImage(iplimage,api) ocr_x2 = int((area[1][0]-int((area[1][0]-area[0][0])*0.17))*factor) api.SetRectangle(int(area[0][0]*factor), int(area[0][1]*factor), ocr_x2-int(area[0][0]*factor), int(area[1][1]*factor)-int(area[0][1]*factor)) res = self.hocrToObject(api.GetHOCRText(0).decode('utf-8'), area, factor) return res
def DoBinarizeRegion(self, brightness, contrast): #print brightness, contrast self.UpdateLabelOfInterest() PilImage2 = self.OriginalScreenshot.copy() x = self.AlexaAppImages[self.AppObjectFeedbackIndex].RectX + self.AlexaAppImages[self.AppObjectFeedbackIndex].CropRegionX y = self.AlexaAppImages[self.AppObjectFeedbackIndex].RectY + self.AlexaAppImages[self.AppObjectFeedbackIndex].CropRegionY w = self.AlexaAppImages[self.AppObjectFeedbackIndex].RectX + self.AlexaAppImages[self.AppObjectFeedbackIndex].CropRegionX + self.AlexaAppImages[self.AppObjectFeedbackIndex].CropRegionWidth h = self.AlexaAppImages[self.AppObjectFeedbackIndex].RectY + self.AlexaAppImages[self.AppObjectFeedbackIndex].CropRegionY + self.AlexaAppImages[self.AppObjectFeedbackIndex].CropRegionHeight box = (x, y, w, h) region = PilImage2.crop(box) #region.save("c:\\region.png") enhancer = ImageEnhance.Brightness(region) region = enhancer.enhance(brightness) enhancer = ImageEnhance.Contrast(region) region = enhancer.enhance(contrast) #PilImage2.paste(region, box) cv_im = cv.CreateImageHeader(region.size, cv.IPL_DEPTH_8U, 3) cv.SetData(cv_im, region.tostring()) mat = cv.GetMat(cv_im) img = numpy.asarray(mat) img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) thresh = 100 im_bw = cv2.threshold(gray_image, thresh, 255, cv2.THRESH_BINARY)[1] im = Image.fromarray(im_bw) PilImage2.paste(im, box) self.QtImage1 = ImageQt.ImageQt(PilImage2) self.QtImage2 = QImage(self.QtImage1) self.pixmap = QPixmap.fromImage(self.QtImage2) #self.pixmap.load("im_bw.png") self.update()