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