def find_name(crop_gray, crop_org): template = cv2.UMat( cv2.imread('%s/studentcard/mask/name_mask.jpg' % (currentPath), 0)) # showimg(crop_org) w, h = cv2.UMat.get(template).shape[::-1] res = cv2.matchTemplate(crop_gray, template, cv2.TM_CCOEFF_NORMED) min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res) print max_loc top_left = (max_loc[0] + w, max_loc[1] - int(20 * x)) bottom_right = (top_left[0] + int(1000 * x), top_left[1] + int(400 * x)) result = cv2.UMat.get(crop_org)[top_left[1]:bottom_right[1], top_left[0]:bottom_right[0]] cv2.rectangle(crop_gray, top_left, bottom_right, 255, 2) # showimg(result) return cv2.UMat(result)
def calculate_masked_circle(self, img: cv2.UMat, coordinates: tuple, radius: int) -> cv2.UMat: """ Calculate the mask for the foveated area and the peripheral area :param img: original image :param coordinates: coords of the gaze where the foveated area shall be cropped out :param radius: radius of the foveated area :return: masked foveated area, masked peripheral area """ mask_foveated = cv2.UMat(np.zeros(self.size[::-1], dtype=np.uint8)) cv2.circle(mask_foveated, coordinates, radius, (255, 255, 255), -1, 0, 0) masked_image = cv2.bitwise_or(img, img, mask=mask_foveated) mask_peripheral = cv2.UMat(np.zeros(self.size[::-1], dtype=np.uint8)) return masked_image, mask_peripheral
def plot_non_max_suppression(numpy_img, preds, label, color): """ non max suppression + duplicates suppression""" def suppress(box, boxes, indexes): ious_50 = [ i for i in indexes if intersection_over_union(box, boxes[i]) >= 0.50 ] duplicates = [ i for i in indexes if intersection_over_b_area(box, boxes[i]) >= 0.91 ] for i in set(duplicates).union(set(ious_50)): indexes.remove(i) labels = preds["labels"].detach().numpy() scores = preds["scores"].detach().numpy() boxes = preds["boxes"].detach().numpy()[(labels == label) & (scores >= 0.55)] indexes = list(np.arange(len(boxes))) result_boxes = [] # suppression algorithm while len(indexes) > 0: box = boxes[indexes[0]] indexes.remove(indexes[0]) suppress(box, boxes, indexes) result_boxes.append(box) # adding rectangles nimg = cv2.UMat(numpy_img) for box in result_boxes: nimg = cv2.rectangle(nimg, (box[0], box[1]), (box[2], box[3]), color=color, thickness=2) return (result_boxes, nimg.get())
def annotated_frame(self, annotate_temperature=True, annotate_breath_rate=True): """ Returns a grey frame with annotation, used for visualization. Args: annotate_temperature: Whether the body temperature should be annotated on the returned frame. annotate_breath_rate: Whether the breath rate should be annotated on the returned frame. """ annotated_frame = cv2.UMat(self.grey_frame) for face in self.thermal_faces: cv2.rectangle(annotated_frame, tuple(face.bounding_box[:2]), tuple(face.bounding_box[2:]), (255, 0, 0), 1) if annotate_temperature: temperature = face.temperature if temperature is not None: cv2.putText(annotated_frame, str(temperature)[:5] + ' C', tuple(face.bounding_box[:2]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1) if annotate_breath_rate: breath_rate = face.breath_rate if breath_rate is not None: cv2.putText(annotated_frame, str(breath_rate)[:5] + 'Hz', (face.bounding_box[0], face.bounding_box[3]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1) return annotated_frame
def run(self, feed, visualize_temperature=True, visualize_breath_rate=True, visualize_breath_curve=True): for raw_frame, timestamp in feed: thermal_frame = ThermalFrame(raw_frame, timestamp) if len(self.thermal_frame_queue) > 0: thermal_frame.link(self.thermal_frame_queue[-1]) if len(self.thermal_frame_queue) >= config.MAX_CACHED_FRAMES: self.thermal_frame_queue.pop(0) self.thermal_frame_queue[0].detach() self.thermal_frame_queue.append(thermal_frame) annotation_frame = cv2.UMat( np.stack([thermal_frame.grey_frame] * 3, 2)) self._visualize_bounding_boxes(annotation_frame, thermal_frame.thermal_faces) if visualize_temperature: self._visualize_temperatures(annotation_frame, thermal_frame.thermal_faces) if visualize_breath_rate: self._visualize_breath_rates(annotation_frame, thermal_frame.thermal_faces) if visualize_breath_curve: self._visualize_breath_curves(thermal_frame.thermal_faces) cv2.imshow( 'thermal monitoring', cv2.resize(annotation_frame, config.VISUALIZATION_RESOLUTION)) if cv2.waitKey(1) & 0xFF == ord('q'): break cv2.destroyAllWindows()
def get_domains(img, contour_level=0.5, min_area=1, max_area=100000): """Get crystallite domain information extracted from an image. Use a highly contrasted image, such as one output from the 'get_kmeans_map' function. areas are calculated. Returns a dictionary of countour lines which define each cluster domain and area of each domain.""" # extract contour line ordered pairs from the map contours = skimage.measure.find_contours(img, contour_level) # calculate area of inside each contour line areas = [ cv2.contourArea(cv2.UMat(np.expand_dims(c.astype(np.float32), 1))) for c in contours ] # create zipped list of areas and contour lines below area threshold zipped = [i for i in zip(areas, contours) if min_area <= i[0] <= max_area] # sort from large area to small area domains zipped.sort(key=lambda x: x[0], reverse=True) # get domain statistics tot_area = img.shape[0] * img.shape[1] tot_domain_area = np.sum([z[0] for z in zipped]) domain_percent = 100 * tot_domain_area / tot_area # create dictionary to hold results domains = { 'tot_area': int(tot_area), 'tot_domain_area': int(tot_domain_area), 'domain_percent': domain_percent, 'areas': [z[0] for z in zipped], 'contours': [np.flip(z[1]) for z in zipped], 'mean_x': [np.mean(z[1][:, 1]) for z in zipped], 'mean_y': [np.mean(z[1][:, 0]) for z in zipped] } return domains
def draw_boxes(self, images, bboxes, labels): label_dict = {0: "Cat", 1: "Dog"} for batch in zip(images, bboxes, labels): cv2.destroyAllWindows() image, bbox, label = batch[0].cpu().numpy(), batch[1].cpu().numpy(), torch.argmax(batch[2]).cpu().item() image = np.rollaxis(image, 0, 3) image = ((image - image.min()) * (1 / (image.max() - image.min()) * 255)).astype("uint8") image = cv2.UMat(image) cv2.rectangle(image, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 255, 0), thickness=2) cv2.putText( image, f"{label_dict[label]}", (bbox[1], bbox[3]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1, cv2.LINE_AA, ) cv2.imshow("test", image) cv2.waitKey(1) sleep(1) cv2.destroyAllWindows()
def find_idnum(crop_gray, crop_org): template = cv2.UMat( cv2.imread('%s/idcard/mask/idnum_mask_%s.jpg' % (currentPath, pixel_x), 0)) # showimg(template) #showimg(crop_gray) w, h = cv2.UMat.get(template).shape[::-1] res = cv2.matchTemplate(crop_gray, template, cv2.TM_CCOEFF_NORMED) min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res) top_left = (max_loc[0] + w, max_loc[1] - int(20 * x)) bottom_right = (top_left[0] + int(2300 * x), top_left[1] + int(300 * x)) result = cv2.UMat.get(crop_org)[top_left[1]:bottom_right[1], top_left[0]:bottom_right[0]] cv2.rectangle(crop_gray, top_left, bottom_right, 255, 2) #showimg(crop_gray) return cv2.UMat(result)
def findCollision(folder, is_debug): # folder = './dataset/train/toothpaste_box/21/' before = 0 after = 1 row = 0 col = 1 mask_img_files = sorted(glob.glob(f'{folder}mask/*.png')) mask_img = np.array([plt.imread(mask_img_files[0]), plt.imread(mask_img_files[-1])]) center_before, cnt = findContourCenter(mask_img[before]) center_after, cnt = findContourCenter(mask_img[after]) distance = math.sqrt((center_after[row] - center_before[row]) ** 2 + (center_after[col] - center_before[col])**2) angle = math.atan2((center_after[row] - 220), (center_after[col] - 220)) if is_debug: print(folder) print(f'angle = {angle}', f'distance = {distance}') inter_img = np.array([mask_img[before], mask_img[after], np.zeros(mask_img[after].shape)]) inter_img = np.moveaxis(inter_img, 0, -1) inter_img = cv2.UMat(inter_img) inter_img = cv2.UMat.get(inter_img) cv2.drawContours(inter_img, [cnt], -1, (0, 0, 255), 2) plt.imshow(inter_img) plt.plot([center_before[1], center_after[1]], [center_before[0], center_after[0]]) plt.plot(center_after[1], center_after[0], marker='o') plt.show() return angle, distance
def get_address(img,handle): print('address') _, _, red = cv2.split(img) red = cv2.UMat(red) red = hist_equal(red) #showing(red,'red0') #red=cv2.bilateralFilter(red,0,s,d) #red=cv2.ximgproc.guidedFilter(red,red,50,20,-5) #showing(red,'red1') red = cv2.adaptiveThreshold(red, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,135,40) #print(pytesseract.image_to_string(red, lang='chi_sim', config='-psm 6')) #red=cv2.dilate(red,np.ones((3,3),np.uint8),1) #red=cv2.erode(red,np.ones((5,5),np.uint8),3) #red = cv2.medianBlur(red,3) #red=cv2.GaussianBlur(red, (3, 3),200)#高斯滤波 #red=cv2.boxFilter(red, -1, (3, 3), normalize =1)#方框滤波,效果差 #red=cv2.blur(red, (3, 3))#均值滤波 #showing(red,'red2') red = img_resize(red, 300) img = img_resize(img, 300) address= punc_filter(get_result_vary_length(red,handle, 'chi_sim', img, '--psm 6')) print(address) return address
def manually_get_centroid(img, preprocessed=False): global mask_watershed if isinstance(img, cv2.UMat): img = img.get().astype(int) else: img = img.astype(int) if not preprocessed: img = preprocess(img) mask_watershed = np.zeros(img.shape[0:2]) print("CLic on ROI, then press y if the centroid is correct, n to reset") while (True): cv2.namedWindow("image") cv2.setMouseCallback("image", watershed, img) img_disp = cv2.cvtColor(img.astype("uint8"), cv2.COLOR_HSV2BGR) cv2.imshow("image", img_disp) cv2.imshow( "masked", cv2.bitwise_and(img_disp, img_disp, mask=mask_watershed.astype("uint8"))) key = cv2.waitKey(1) if key & 0XFF == ord('y'): centroid, ret = getCentroid(cv2.UMat(mask_watershed)) break if key & 0XFF == ord('n'): mask_watershed = np.zeros(img.shape[0:2]) cv2.destroyWindow("image") cv2.destroyWindow("masked") return centroid
def generate_preview(dataset_filepath, output_dir): h5file = h5py.File(dataset_filepath, "r") images = h5file["imgs"] num_samples = len(images) idx = np.random.randint(num_samples) images = images[idx] actions = h5file["actions"][idx] text_x = 6 text_y = 10 text_images = [] color = 0 for action, image in zip(actions, images): if image.shape[-1] > 4: image = image.transpose(1, 2, 0) image = cv2.UMat(image) action_text = decode_action(h5file.attrs["action_keys"], action) text_images += [ cv2.putText(img=image, text=action_text, org=(text_x, text_y), fontFace=1, fontScale=1, color=color, thickness=1).get() ] output_filepath = os.path.join(output_dir, "{}.gif".format(idx)) imageio.mimsave(output_filepath, text_images)
def __process_frame(self, frame): frame = cv2.UMat(frame) frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) with torch.no_grad(): frame = cv2.UMat.get(frame) frame = torch.tensor(frame, dtype=torch.float32) if self.device: frame = frame.to(self.device) frame = frame.unsqueeze(0) if (frame.size(1) == 1920 and frame.size(2) == 1080): frame = frame.permute(0, 3, 1, 2) elif (frame.size(2) == 1920 and frame.size(1) == 1080): frame = frame.permute(0, 3, 2, 1) elif (frame.size(1) == 1280 and frame.size(2) == 720): frame = frame.permute(0, 3, 1, 2) frame = functional.interpolate(frame, size=(1920, 1080)) elif (frame.size(2) == 1280 and frame.size(1) == 720): frame = frame.permute(0, 3, 2, 1) frame = functional.interpolate(frame, size=(1920, 1080)) else: # if some other size, will be some stretching etc but w/e frame = frame.permute(0, 3, 2, 1) frame = functional.interpolate(frame, size=(1920, 1080)) frame = frame.squeeze(0) frame = frame / 255. if (self.encoder): encoded = self.encoder(frame)[0] encoded = encoded.view(-1) return encoded else: return frame
def frame(name): if request.method == 'POST': content = request.json hashtable = json.loads(content) time_stamp = hashtable["time_stamp"] frame_type = hashtable["frame_type"] number = hashtable["number"] frame = hashtable["frame"] frame = cv2.UMat(np.array(frame, dtype=np.uint8)) if not os.path.exists('dataLake/%s_%s'%(name, frame_type)): os.makedirs('dataLake/%s_%s'%(name, frame_type)) if not os.path.exists('dataLake/%s_%s/%s'%(name, frame_type, time_stamp)): os.makedirs('dataLake/%s_%s/%s'%(name, frame_type, time_stamp)) cv2.imwrite('dataLake/%s_%s/%s/%s.jpg'%(name, frame_type, time_stamp, number), frame) return ('', 204) if request.method == 'GET': content = request.json hashtable = json.loads(content) time_stamp = hashtable["time_stamp"] frame_type = hashtable["frame_type"] number = hashtable["number"] frame = cv2.imread('dataLake/%s_%s/%s/%s.jpg'%(name, frame_type, time_stamp, number)) print('dataLake/%s_%s/%s/%s.jpg'%(name, frame_type, time_stamp, number)) hashtable = {"frame": frame.tolist()} content = json.dumps(hashtable) return content
def run(self): start = timeit.default_timer() for region in self.region_to_cut: for rotate in self.rotate: for side in self.sides: self.reader = None try: self.reader = PdfFileReader(self.pdf_path) except PyPdfError: raise PyPdfError except FileNotFoundError: raise FileNotFoundError except PermissionError: raise PermissionError self.cut_region(side=side, rotate=rotate, region=region) self.save_cropped_bytes_pdf() self.pdf_to_image() for degree in self.degrees: self.threshold(degree=degree) self.find_qrcode() self.image = cv2.UMat(self.image) if self.decoded_text is not None: self.total_time = timeit.default_timer() - start return self.total_time = timeit.default_timer() - start
def make_video_ci(src,traj,pred,tgt,n_logged,logwandb=True, display_frame_nr=True): seq_len = tgt.shape[1] srcs = np.concatenate([s for s in ((src.permute(0, 2, 3, 1).cpu().numpy()) * 255.).astype(np.uint8)[:n_logged]],axis=1) traj_vis = [] for t in range(traj.shape[1]): arrows = draw_arrow(traj[:n_logged,t].cpu().numpy()) traj_vis.append(arrows) traj_vis = np.stack(traj_vis,axis=0) traj_vis = put_text_to_video_row(traj_vis, "Flow Vectors", display_frame_nr=display_frame_nr) srcs = cv2.UMat.get(cv2.putText(cv2.UMat(srcs), f"Sequence length {seq_len}", (int(srcs.shape[1] // 3), int(srcs.shape[0] / 6)), cv2.FONT_HERSHEY_SIMPLEX, float(srcs.shape[0] / 256), (255, 0, 0), int(srcs.shape[0] / 128))) srcs = np.stack([srcs] * seq_len, axis=0) srcs = put_text_to_video_row(srcs, "Input Image", display_frame_nr=display_frame_nr) pred = ((pred.permute(0, 1, 3, 4, 2).cpu().numpy()) * 255).astype(np.uint8)[:n_logged] pred = np.concatenate(list(pred), axis=2) pred = put_text_to_video_row(pred, "Predicted Video", display_frame_nr=display_frame_nr) tgt = ((tgt.permute(0, 1, 3, 4, 2).cpu().numpy()) * 255).astype(np.uint8)[:n_logged] tgt = np.concatenate(list(tgt), axis=2) tgt = put_text_to_video_row(tgt, "Groundtruth Video", display_frame_nr=display_frame_nr) full = np.concatenate([srcs, pred, tgt, traj_vis], axis=1) if logwandb: full = np.moveaxis(full, [0, 1, 2, 3], [0, 2, 3, 1]) return full
def _findContours(self): contours = [] masks = self.masks.detach().numpy() use_cv2 = True for mask in masks: if use_cv2: mask = cv2.UMat(mask) contour, hierarchy = cv2_util.findContours( mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE # cv2.CHAIN_APPROX_TC89_L1 ) reshaped_contour = [] for entity in contour: assert len(entity.shape) == 3 assert (entity.shape[1] == 1 ), "Hierarchical contours are not allowed" reshaped_contour.append(entity.reshape(-1).tolist()) contours.append(reshaped_contour) else: contour = skimage.measure.find_contours(mask.astype('uint8'), level=0.5) reshaped_contour = [] for entity in contour: assert len(entity.shape) == 2 assert (entity.shape[1] == 2 ), f"wrong contour shape {entity.shape}" entity = np.flip(entity, axis=1) # make it close if not np.all(entity[0, :] == entity[-1, :]): entity = np.vstack([entity, entity[0, :]]) reshaped_contour.append(entity.reshape(-1).tolist()) contours.append(reshaped_contour) return contours
def mask_tank(self): x = int(self.tank.x_px) y = int(self.tank.y_px) R = int(self.tank.r_px) + 1 # ?? if self.threshType == cv2.THRESH_BINARY_INV: tank_mask = 255 * np.ones_like(self.frame) if self.GPU: tank_mask = cv2.UMat(tank_mask) cv2.circle(tank_mask, (x, y), R, (0, 0, 0), thickness=-1) self.frame = cv2.bitwise_or(self.frame, tank_mask) else: tank_mask = np.zeros_like(self.frame) if self.GPU: tank_mask = cv2.UMat(tank_mask) cv2.circle(tank_mask, (x, y), R, (255, 255, 255), thickness=-1) self.frame = cv2.bitwise_and(self.frame, tank_mask)
def run_opencv(b, **kwargs): # see https://www.learnopencv.com/opencv-transparent-api/ time_upload = kwargs.get('time_upload', False) transparent_api = kwargs.get('transparent_api', False) B = kwargs.get('batch_size', 10) b = cv2.UMat(b) if (transparent_api and not time_upload) else b def run_once(): x = cv2.UMat(b) if (transparent_api and time_upload) else b y = cv2.cvtColor(x, cv2.COLOR_BAYER_BG2RGB) return y run_once() run_once() y = run_once() if transparent_api: z = y.get() N = 1000 * B start = time.time() for _ in range(N): y = run_once() if transparent_api: z = y.get() return (time.time() - start) / N * 1000
def read(self): # return the frame most recently read if (self.tapi): # return OpenCV Transparent API UMat frame for H/W acceleration return (self.grabbed, cv2.UMat(self.frame)) # return standard numpy frame return (self.grabbed, self.frame)
def find_address(crop_gray, crop_org): template = cv2.UMat(cv2.imread('address_mask_%s.jpg'%pixel_x, 0)) # showimg(template) #showimg(crop_gray) w, h = cv2.UMat.get(template).shape[::-1] #t1 = round(time.time()*1000) res = cv2.matchTemplate(crop_gray, template, cv2.TM_CCOEFF_NORMED) #t2 = round(time.time()*1000) #print 'time:%s'%(t2-t1) min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res) top_left = (max_loc[0] + w, max_loc[1] - int(20*x)) bottom_right = (top_left[0] + int(1700*x), top_left[1] + int(550*x)) result = cv2.UMat.get(crop_org)[top_left[1]-10:bottom_right[1], top_left[0]-10:bottom_right[0]] cv2.rectangle(crop_gray, top_left, bottom_right, 255, 2) #showimg(crop_gray) return cv2.UMat(result)
def process_gpu3(self, img, sub_factor=1.0): # Takes 1 combined numpy (Mat) array and converts to UMat on the fly # Converts combined image to UMat on gpu then transparent interface produces 2 sub image UMats in OPENCL # OPENCV transparent interface will use OPENCL for processing, uses scaleAdd routine for subtraction step # Approx 2.7 ms processing time on macbook pro (i7 + Intel Iris Pro) uimg = cv2.UMat(img) img_l = cv2.UMat(uimg, (0, self.height), (0, self.width)) img_r = cv2.UMat(uimg, (0, self.height), (self.width, 2 * self.width)) result = cv2.scaleAdd( cv2.remap(img_r, self.defX, self.defY, cv2.INTER_LINEAR, borderMode=cv2.BORDER_CONSTANT, borderValue=0), -sub_factor, img_l) return result
def drawDetectorStatus(image): # obstacle notification notify custom_org = (200, 200) custom_fontscale = 2 custom_color = (0, 150, 250) # orange custom_thickness = 2 image = cv2.UMat(image) # draw side detect # front custom_fontscale = 2 if detector_notify["front"] != 0 or detector_notify["back"] != 0 or detector_notify["left"] != 0 or detector_notify["right"] != 0: image = cv2.putText(image, f"WARNING", (50, 450), GLOBAL_FONT, 2, custom_color, custom_thickness) image = cv2.putText(image, f"obstacle nearby", (50, 480), GLOBAL_FONT, 1, custom_color, custom_thickness) custom_fontscale = 0.8 image = cv2.putText(image, f"Obstacle detector", (50, 560), GLOBAL_FONT, custom_fontscale, custom_color, custom_thickness) image = cv2.putText(image, f"front: {detector_notify['front']} m", (50, 590), GLOBAL_FONT, custom_fontscale, custom_color, custom_thickness) image = cv2.putText(image, f"back: {detector_notify['back']} m", (50, 620), GLOBAL_FONT, custom_fontscale, custom_color, custom_thickness) image = cv2.putText(image, f"left: {detector_notify['left']} m", (50, 650), GLOBAL_FONT, custom_fontscale, custom_color, custom_thickness) image = cv2.putText(image, f"right: {detector_notify['right']} m", (50, 680), GLOBAL_FONT, custom_fontscale, custom_color, custom_thickness) detector_notify["front"] = 0 detector_notify["back"] = 0 detector_notify["left"] = 0 detector_notify["right"] = 0 return image
def prepare_image(self, processor): screen_matrix = ImageGrab.grab(bbox=(0, 60, 960, 560)) screen = np.array(screen_matrix) if processor == GPU: screen = cv2.UMat(screen) return screen
def generate_saliency(self, src): # Convert pixels to 32-bit floats src = src.astype(np.float32) src_dimensions = src.shape[:2] # Use T-API for hardware acceleration src = cv2.UMat(src) if self.ch_3: # Split colour image into RBG channels channel_array = cv2.split(src) # Generate Saliency Map for each channel for channel in range(3): channel_array[channel] = self.divog_saliency( channel_array[channel], src_dimensions) # Merge back into one grayscale image merged_channels = cv2.merge(channel_array) gray_merged_channels = cv2.cvtColor(merged_channels, cv2.COLOR_BGR2GRAY) return gray_merged_channels else: # Convert to grayscale src_bw = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY) # Generate Saliency Map return self.divog_saliency(src_bw, src_dimensions)
def watch_feed(): # Create another socket - UDP for live feed udp_soc = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) udp_soc.bind((Globals.target,Globals.LIVEFEED_PORT)) FRAME_SIZE, addr = udp_soc.recvfrom(4096) print addr, FRAME_SIZE FRAME_SIZE = int(FRAME_SIZE) while True: # Capture frame-by-frame frame = '' while len(frame) < FRAME_SIZE: frame += udp_soc.recv(Globals.UDP_BUFFER_SIZE)#cap.read() #print frame # Display the resulting frame frame = numpy.fromstring(frame, dtype='uint8') frame = numpy.reshape(frame[:1280*720], (720, 1280)) #frame = cv2.imdecode(frame,cv2.IMREAD_COLOR ) frame_mat = cv2.UMat(frame) cv2.imshow('LIVE FEED', frame_mat) # Press Q on keyboard to exit if cv2.waitKey(25) & 0xFF == ord('q'): break # Break the loop cv2.destroyAllWindows() udp_soc.close()
def get_carla_status(vehicle_actor, image): # get carla status # original spawn point = x=-30, y=207.5, z=1 spawnpt = [-30, 207.5, 1] vehicle_tf = vehicle_actor.get_transform() vehicle_loc = [ round(vehicle_tf.location.x - spawnpt[0], 2), round(vehicle_tf.location.y - spawnpt[1], 2), round(vehicle_tf.location.z, 2) ] # display custom_org = (35, 50) custom_fontscale = 0.7 custom_color = (255, 150, 120) # blue custom_thickness = 2 image = cv2.UMat(image) res = cv2.putText( image, f"location:(x={vehicle_loc[0]},y={vehicle_loc[1]},z={vehicle_loc[2]})", custom_org, GLOBAL_FONT, custom_fontscale, custom_color, custom_thickness) return res
def __init__(self, shape, dtype=float64, buffer=None, offset=0, strides=None, order=None, mat=None, UMat=False, usageFlags=USAGE_DEFAULT): self.UMat = UMat if mat is None: mat = np.ndarray(shape, dtype=dtype, buffer=buffer, offset=offset, strides=strides, order=order) self.shape = mat.shape self.dtype = mat.dtype if UMat: self._n = None self.u = cv.UMat(mat) self._ = self.u else: self._n = mat self.u = None self._ = self._n
def __init__(self, source, qsize=128): """ Source must be a path to a video file Utilizes your system's GPU to process the stream """ if not isinstance(source, str): raise ValueError( f'Expected either a filepath. Got {type(source)}. Consider using VideoStream which supports both live video as well as pre-existing videos' ) # initialize the file video stream along with the boolean # used to indicate if the thread should be stopped or not self.stream = cv.VideoCapture(source) self.kill_stream = False self.count = 0 # initialize the queue to store frames self.Q = Queue(maxsize=qsize) self.width = int(self.stream.get(cv.CAP_PROP_FRAME_WIDTH)) self.height = int(self.stream.get(cv.CAP_PROP_FRAME_HEIGHT)) self.res = (self.width, self.height) self.fps = math.ceil(self.stream.get(FPS)) self.frames = int(self.stream.get(FRAME_COUNT)) # since we use UMat to store the images to # we need to initialize them beforehand self.qframes = [0] * qsize for ii in range(qsize): self.qframes[ii] = cv.UMat(self.height, self.width, cv.CV_8UC3)
def visualize_fmap(fmap, window_name='fmap'): # Convert to opencv image fmap_img = fmap.cpu().numpy().astype(np.float32) square_size = int(math.sqrt(fmap_img.shape[2])) index = 0 channel_w, channel_h, channel_depth = fmap_img.shape fmap_img_draw = np.zeros((square_size * channel_w, square_size * channel_h, 3)) channel_img_rgb = np.zeros((channel_w, channel_h, 3), dtype="uint8") for i in range(square_size): for j in range(square_size): # Get channel channel_img = cv2.UMat(fmap_img[:, :, index]).get() # Found on github due to errors # channel_img = cv2.normalize(fmap_img[:, :, index], None, 255, 0, cv2.NORM_MINMAX, cv2.CV_8UC1) channel_img_rgb[:, :, 0] = channel_img channel_img_rgb[:, :, 1] = channel_img channel_img_rgb[:, :, 2] = channel_img # Include channel in image to draw fmap_img_draw[int(i * channel_w):int(i * channel_w + channel_w), int(j * channel_h):int(j * channel_h + channel_h)] = channel_img_rgb # Increase index index += 1 # Show image cv2.namedWindow(window_name, cv2.WINDOW_NORMAL) cv2.resizeWindow(window_name, 500, 500) cv2.imshow(window_name, fmap_img_draw)