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()
