def npArray2cvMat(inputMat, dataType=cv.CV_32FC1):
"""
This function is a utility for converting numpy arrays to the cv.cvMat format.
Returns: cvMatrix
"""
if( type(inputMat) == np.ndarray ):
sz = len(inputMat.shape)
temp_mat = None
if( dataType == cv.CV_32FC1 or dataType == cv.CV_32FC2 or dataType == cv.CV_32FC3 or dataType == cv.CV_32FC4 ):
temp_mat = np.array(inputMat, dtype='float32')
elif( dataType == cv.CV_8UC1 or dataType == cv.CV_8UC2 or dataType == cv.CV_8UC3 or dataType == cv.CV_8UC3):
temp_mat = np.array(inputMat,dtype='uint8')
else:
logger.warning("MatrixConversionUtil: the input matrix type is not supported")
return None
if( sz == 1 ): #this needs to be changed so we can do row/col vectors
retVal = cv.CreateMat(inputMat.shape[0], 1, dataType)
cv.SetData(retVal, temp_mat.tostring(), temp_mat.dtype.itemsize * temp_mat.shape[0])
elif( sz == 2 ):
retVal = cv.CreateMat(temp_mat.shape[0], temp_mat.shape[1], dataType)
cv.SetData(retVal, temp_mat.tostring(), temp_mat.dtype.itemsize * temp_mat.shape[1])
elif( sz > 2 ):
logger.warning("MatrixConversionUtil: the input matrix type is not supported")
return None
return retVal
else:
logger.warning("MatrixConversionUtil: the input matrix type is not supported")
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
v = gdb.parse_and_eval(args[0])
strType = gdb.execute("print " + args[0] + ".type()", False, True)
# strType contains gdb answers as a string of the form "$2 = 42"
img = cv.CreateMat(v['rows'], v['cols'], int(strType.split(" ")[2]))
# convert v['data'] to char*
char_type = gdb.lookup_type("char")
char_pointer_type = char_type.pointer()
buffer = v['data'].cast(char_pointer_type)
# read bytes from inferior's process memory
buf = v['step']['buf']
bytes = buf[0] * v['rows']
inferior = gdb.selected_inferior()
mem = inferior.read_memory(buffer, bytes)
# set the matrix raw data
cv.SetData(img, mem)
# save matrix as an xml file and open it with matrix viewer
cv.Save("/tmp/dump.xml", img, "matrix")
call(["matrix-viewer", "/tmp/dump.xml"])
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 processa_frame(imagem):
cv.SetData(imagem_cv, imagem)
if maos:
for id in maos:
cv.PutText(imagem_cv, efeito, maos[id]['atual'] ,fonte_do_texto , cv.CV_RGB(0,0,150))
cv.PutText(imagem_cv, 'Efeito: '+efeito, (10,20) ,fonte_do_texto , cv.CV_RGB(200,0,0))
cv.ShowImage('Video', imagem_cv)
def set_frame(self, frame):
#im image("RGB",(640,480))
jpegPIL = Image.fromstring("RGB", (640, 480), frame, "jpeg", "RGB",
"raw")
cv_im = cv.CreateImage((640, 480), cv.IPL_DEPTH_8U, 3)
cv.SetData(cv_im, jpegPIL.tostring())
cv.ShowImage(self.name, 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 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 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 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 rotateImage(self, image, angle):
if DEBUG:
print "We are now rotating this photo"
image0 = image
if hasattr(image, 'shape'):
image_center = tuple(np.array(image.shape) / 2)
shape = tuple(image.shape)
elif hasattr(image, 'width') and hasattr(image, 'height'):
image_center = tuple(np.array((image.width / 2, image.height / 2)))
shape = (image.width, image.height)
else:
raise Exception, 'Unable to acquire dimensions of image for type %s.' % (
type(image), )
rot_mat = cv2.getRotationMatrix2D(image_center, angle, 1.0)
image = np.asarray(image[:, :])
rotated_image = cv2.warpAffine(image,
rot_mat,
shape,
flags=cv2.INTER_LINEAR)
# Copy the rotated data back into the original image object.
cv.SetData(image0, rotated_image.tostring())
return image0
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 frame(self, i):
rnds = self.rnds
roll = math.sin(i * .01 * rnds[0] + rnds[1])
pitch = math.sin(i * .01 * rnds[2] + rnds[3])
yaw = math.pi * math.sin(i * .01 * rnds[4] + rnds[5])
x = math.sin(i * 0.01 * rnds[6])
y = math.sin(i * 0.01 * rnds[7])
x, y, z = -0.5, 0.5, 1
roll, pitch, yaw = (0, 0, 0)
z = 4 + 3 * math.sin(i * 0.1 * rnds[8])
print z
rz = transformations.euler_matrix(roll, pitch, yaw)
p = Plane(Vec3(x, y, z), under(Vec3(0, 0, -1), rz),
under(Vec3(1, 0, 0), rz))
acc = 0
for r in self.r:
(pred, h, norm) = p.hit(r)
l = numpy.where(pred, texture(p.localxy(r.project(h))), 0.0)
acc += l
acc *= (1.0 / len(self.r))
# print "took", time.time() - st
img = cv.CreateMat(self.h, self.w, cv.CV_8UC1)
cv.SetData(img,
(clamp(0, acc, 1) * 255).astype(numpy.uint8).tostring(),
self.w)
return img
def url_jpg_contours(url):
position = 100
filedata = urllib2.urlopen(url).read()
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1)
cv.SetData(imagefiledata, filedata, len(filedata))
im = cv.DecodeImage(imagefiledata, cv.CV_LOAD_IMAGE_COLOR)
col_edge = cv.CreateImage((im.width, im.height), 8, 3)
# convert to grayscale
gray_im = cv.CreateImage((im.width, im.height), 8, 1)
edge_im = cv.CreateImage((im.width, im.height), 8, 1)
cv.CvtColor(im, gray_im, cv.CV_BGR2GRAY)
cv.Canny(gray_im, edge_im, position, position * 3, 3)
cv.SetZero(col_edge)
# copy edge points
cv.Copy(im, col_edge, edge_im)
edge_im_array = np.asarray(edge_im[:])
ret, edge_im_array = cv2.threshold(edge_im_array, 127, 255,
cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(edge_im_array, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
scale = 10000.0
points = []
for contour in contours:
for i in contour:
for j in i:
lng_offset = j[0] / scale
lat_offset = j[1] / scale
points.append([lng_offset, lat_offset])
return points
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 detect_ball(self, video_proxy):
self._imgData = video_proxy.getImageRemote(self._imgClient)
cv.SetData(self._img, self._imgData[6])
mat = self._img[:]
frame = np.array(mat) # Frame: An image
frame2 = frame
center_ra = Select_color.select_color(frame2)
self.__show_image(center_ra = center_ra, frame = frame2)
return center_ra
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 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 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 npArray2cvMat(inputMat, dataType=cv.CV_32FC1):
"""
This function is a utility for converting numpy arrays to the cv.cvMat format.
Returns: cvMatrix
"""
if( type(inputMat) == np.ndarray ):
sz = len(inputMat.shape)
if( sz == 1 ): #this needs to be changed so we can do row/col vectors
retVal = cv.CreateMat(inputMat.shape[0], 1, dataType)
cv.SetData(retVal, inputMat.tostring(), inputMat.dtype.itemsize * inputMat.shape[0])
elif( sz == 2 ):
retVal = cv.CreateMat(inputMat.shape[0], inputMat.shape[1], dataType)
cv.SetData(retVal, inputMat.tostring(), inputMat.dtype.itemsize * inputMat.shape[1])
elif( sz > 2 ):
retVal = cv.CreateMat(inputMat.shape, dataType)
#I am going to hold off on this..... no good approach... may not be needed
return retVal
else:
warnings.warn("MatrixConversionUtil: the input matrix type is not supported")
def image_from_archive(archive, name):
"""
Load image PGM file from tar archive.
Used for tarfile loading and unit test.
"""
member = archive.getmember(name)
filedata = archive.extractfile(member).read()
imagefiledata = cv.CreateMat(1, len(filedata), cv.CV_8UC1)
cv.SetData(imagefiledata, filedata, len(filedata))
return cv.DecodeImageM(imagefiledata)
def processa_frame(imagem):
cv.SetData(imagem_cv, imagem)
if gesto == False:
cv.PutText(imagem_cv, 'Acene para ser Rastreado!', (80, 50),
fonte_do_texto, cv.CV_RGB(0, 0, 0))
cv.Circle(imagem_cv, centro, 16, cv.CV_RGB(0, 0, 255), 2, cv.CV_AA, 0)
cv.PutText(imagem_cv, 'Real(mm): ' + coordenada_real, (80, 435),
fonte_do_texto, cv.CV_RGB(255, 255, 255))
cv.PutText(imagem_cv, 'Convertido(px): ' + coordenada_projecao, (80, 465),
fonte_do_texto, cv.CV_RGB(255, 255, 255))
cv.ShowImage('Video', imagem_cv)
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 set_frame(self, frame, resize_size=None):
jpegPIL = Image.fromstring("RGB", self.framesize, frame, "jpeg", "RGB",
"raw")
temp_img = cv.CreateImage(self.framesize, cv.IPL_DEPTH_8U, 3)
cv.SetData(temp_img, jpegPIL.tostring())
#resize operation
if resize_size is None:
resize_size = self.framesize
resize_image = cv.CreateImage(resize_size, cv.IPL_DEPTH_8U, 3)
cv.Resize(temp_img, resize_image)
def img(self):
'''return a cv image for the thumbnail'''
if self._img is not None:
return self._img
self._img = cv.CreateImage((self.width, self.height), 8, 3)
cv.SetData(self._img, self.imgstr)
cv.CvtColor(self._img, self._img, cv.CV_BGR2RGB)
if self.border_width and self.border_colour is not None:
cv.Rectangle(self._img, (0, 0), (self.width - 1, self.height - 1),
self.border_colour, self.border_width)
return self._img
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
