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 = cv2.CreateImageHeader(pil_im.size, cv2.IPL_DEPTH_8U, 1) cv2.SetData(cv_im, pil_im.tostring(), pil_im.size[0]) return cv_im
def DoNiceConvertRGB(video): 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 faces_from_pil_image(pil_image): "Return a list of (x,y,h,w) tuples for faces detected in the PIL image" storage = cv2.CvMemStorage(0) facial_features = cv2.Load('haarcascade_frontalface_alt.xml', storage=storage) cv_im = cv2.CreateImageHeader(pil_image.size, cv.IPL_DEPTH_8U, 3) cv2.SetData(cv_im, pil_image.tostring()) faces = cv2.HaarDetectObjects(cv2_im, facial_features, storage) # faces includes a `neighbors` field that we aren't going to use here return [f[0] for f in faces]
def DoNiceConvert8(depth): np.clip(depth, 0, 2**10 - 1, depth) depth >>= 2 depth = depth.astype(np.uint8) 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 show_threshold(): global threshold global current_depth depth, timestamp = freenect.sync_get_depth() depth = 255 * np.logical_and(depth >= current_depth - threshold, depth <= current_depth + threshold) depth = depth.astype(np.uint8) threshold_image = cv.CreateImageHeader((depth.shape[1], depth.shape[0]), cv.IPL_DEPTH_8U, 1) cv.SetData(threshold_image, depth.tostring(), depth.dtype.itemsize * depth.shape[1]) cv.ShowImage('Threshold', resize_image(threshold_image))
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 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 depth = pretty_depth(depth) image = cv2.CreateImageHeader((depth.shape[1], depth.shape[0]), cv2.IPL_DEPTH_8U, 1) cv2.SetData(image, depth.tostring(), depth.dtype.itemsize * depth.shape[1]) return image
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 video = video[:, :, ::-1] # RGB -> BGR image = cv2.CreateImageHeader((video.shape[1], video.shape[0]), cv2.IPL_DEPTH_8U, 3) cv2.SetData(image, video.tostring(), video.dtype.itemsize * 3 * video.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 rotateImage(image, angle): 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: pass 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. cv2.SetData(image0, rotated_image.tostring()) return image0
def nao_camera_calibration(robotIP, port): if port == None: port = 9559 width = 160 height = 120 raw_img = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 3) videoProxy = ALProxy("ALVideoDevice", robotIP, port) resolution = vision_definitions.kQQVGA colorSpace = vision_definitions.kRGBColorSpace fps = 30 img_client = videoProxy.subscribe("calib_client", resolution, colorSpace, fps) videoProxy.setActiveCamera("_client", 1) alImg = video_proxy.getImageRemote(img_client) rgb_img = cv.CreateImageHeader((width, height), cv.IPL_DEPTH_8U, 3) cv.SetData(rgb_img, alImg[6]) cv.CvtColor(rgb_img, raw_img, cv.CV_RGB2BGR) videoProxy.unsubscribe(img_client)
def request_image(self, source): # Request the new image start = time.time() self.conn.sendall({"get_image": source}) data = self.conn.wait_data(0.15) for meta, img_string in data: if 'error' in meta: self.logger.warn("Obtaining image failed. Error message: %s" % meta['error']) continue shape = meta['shape'] nchannels = meta['nChannels'] depth = meta['depth'] mtime = meta['time'] img = cv.CreateImageHeader(shape, depth, nchannels) cv.SetData(img, img_string) took = time.time() - start return mtime, img took = time.time() - start return None, None
def yarp_get(): img_array = numpy.ones((480, 640, 3), dtype=numpy.uint8) source = img_array 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]) img_array = bitmap yarp_image = yarp.ImageRgb() yarp_image.resize(640, 480) yarp_image.setExternal(img_array, img_array.shape[1], img_array.shape[0]) # print img_array.__array_interface__['data'][0] #yarp_image.setExternal(img_array.__array_interface__['data'][0], img_array.shape[1], img_array.shape[0]) input_port.read(yarp_image) # print img_array.getIplImage() plt.imshow(img_array) #plt.show() return img_array
def toCVMat(im, channels): image = cv2.CreateImage((im.shape[1], im.shape[0]), cv2.IPL_DEPTH_8U, channels) cv2.SetData(image, im.tostring(), im.dtype.itemsize * channels * im.shape[1]) return image
def DoNiceConvert11(depth): image = cv.CreateImageHeader((depth.shape[1], depth.shape[0]), cv.IPL_DEPTH_16U, 1) cv.SetData(image, depth.tostring(), depth.dtype.itemsize * depth.shape[1]) return image
import socket, time import Image, StringIO import numpy as np HOST, PORT = "10.0.1.13", 9996 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((HOST, PORT)) f = sock.makefile() cv2.NamedWindow("camera_server") while True: msg = f.readline() if not msg: break jpeg = msg.replace("\\-n", "\n") buf = StringIO.StringIO(jpeg[0:-1]) buf.seek(0) pi = Image.open(buf) img = cv2.CreateImageHeader((320, 240), cv.IPL_DEPTH_8U, 3) cv2.SetData(img, pi.tostring()) buf.close() frame_cvmat=cv2.GetMat(img) frame=np.asarray(frame_cvmat) cv2.imshow('frame',frame) if cv2.waitKey(1) && 0xFF == ord('q'): break sock.close() cv2.DistoryAllWindows()
def pygame_to_cv2image(surface): """Convert a pygame surface into a cv2 image""" cv2_image = cv2.CreateImageHeader(surface.get_size(), cv2.IPL_DEPTH_8U, 3) image_string = surface_to_string(surface) cv2.SetData(cv2_image, image_string) return cv2_image
def Dilation(pos): element = cv.CreateStructuringElementEx(pos * 2 + 1, pos * 2 + 1, pos, pos, element_shape) cv.Dilate(src, dest, element, 1) cv.ShowImage("Erosion & Dilation", dest) if __name__ == "__main__": if len(sys.argv) > 1: src = cv.LoadImage(sys.argv[1], cv.CV_LOAD_IMAGE_COLOR) else: url = 'https://code.ros.org/svn/opencv/trunk/opencv/samples/c/fruits.jpg' filedata = urllib2.urlopen(url).read() imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) cv.SetData(imagefiledata, filedata, len(filedata)) src = cv.DecodeImage(imagefiledata, cv.CV_LOAD_IMAGE_COLOR) image = cv.CloneImage(src) dest = cv.CloneImage(src) cv.NamedWindow("Opening & Closing", 1) cv.NamedWindow("Erosion & Dilation", 1) cv.ShowImage("Opening & Closing", src) cv.ShowImage("Erosion & Dilation", src) cv.CreateTrackbar("Open", "Opening & Closing", 0, 10, Opening) cv.CreateTrackbar("Close", "Opening & Closing", 0, 10, Closing) cv.CreateTrackbar("Dilate", "Erosion & Dilation", 0, 10, Dilation) cv.CreateTrackbar("Erode", "Erosion & Dilation", 0, 10, Erosion) cv.WaitKey(0) cv.DestroyWindow("Opening & Closing") cv.DestroyWindow("Erosion & Dilation")
data = client.get_data() for metadata, binary_data in data: # Display the received image shape = metadata['shape'] nchannels = metadata['nChannels'] depth = metadata['depth'] digest = metadata['md5'] h = hashlib.md5() h.update(binary_data) dig = h.hexdigest() if dig == digest: print "Correct MD5 sum on binary data: %s" % dig else: print "Incorrect MD5 sum: %s (should be %s)" % (dig, digest) img = cv.CreateImageHeader(shape, depth, nchannels) cv.SetData(img, binary_data) cv.ShowImage(name, img) cv.WaitKey(30) if not server: # Send an image to the server img = random.choice(images) metadata = { "shape": (img.width, img.height), "nChannels": img.nChannels, "depth": img.depth } binary_data = img.tostring() h = hashlib.md5() h.update(binary_data) metadata['md5'] = h.hexdigest()
def pil2cvGrey(pil_im): 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