def visual(self, img, img_name='img', save_flag=False): if self.visual_flag: cv2.imshow(img_name, img) cv2.waitKey(0) cv2.destroyAllWindows() if save_flag: cv2.write(img_name, img)
def splitTransform(self): """ 将透视变换后的图像拆分 """ path_merge = './images/deform/de_merge' path_train = './images/deform/de_train/' path_label = './images/deform/de_label/' train_imgs = glob.glob(path_merge + '/*.' + self.img_type) for imgname in train_imgs: midname = imgname[imgname.rindex("/") + 1 : imgname.rindex("." + self.img_type)] img = cv2.imread(imgname) img_train = img[:,:,2] img_label = img[:,:,0] cv2.write(path_train + midname + '.' + self.img_type, img_train) cv2.write(path_label + midname + '.' + self.img_type, img_label)
def screenRecorder(): fourcc = cv2.VideoWritter_fourcc(*'XVID') out = cv2.VideoWritter("output.avi", fourcc, (1366, 768)) while True: img = ImageGrab.grab() img_np = np.array(img) frame = cv2.cvtcolor(img_np, cv2.COLOR_BGRGB) cv2.imshow("Screen Recorder", frame) cv2.write(frame) if cv2.waitKey(1) == 27: break out.release() cv2.destroyAllWindow()
def Test(): print("For test.\n") transform = torchvision.transforms.Compose([ torchvision.transforms.RandomRotation(30), torchvision.transforms.RandomHorizontalFlip(), torchvision.transforms.RandomResizedCrop(112, scale=(0.8, 1.2)), torchvision.transforms.ToTensor() ]) dataset = MyDataSet(transform=transform, root="/home/diqong/output/") #dataset = MyDataSet(transform=transform, root="./output/") trainloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=True, num_workers=32) inputdata, target = dataset.__getitem__(2) img = inputdata.data.cpu().numpy() cv2.write("1.jpg", img)
def getPrintscreen(): while(1): img = ImageGrab.grab() imgPath = 'pictures\\' img.save(imgPath + 'printscreen.jpg') print("print screen saved") rawImg = cv2.imread(imgPath + 'printscreen.jpg') print("print screen loaded") imgGrey = cv2.cvtColor(rawImg, cv2.COLOR_BGR2GRAY) print("print screen converted to grey scale") # imgGrey = cv2q.GaussianBlur(imgGrey, (3, 3), 0) # print("print screen blurred") # sift = cv2.SIFT() sift = cv2.xfeatures2s.SIFT_create() kp = sift.detect(imgGrey, None) imgSift = cv2. drawKeypoins(imgGrey, kp) cv2.write(imgPath + 'siftKeypoints.jpg', imgSift) # detect edges in the image imgEdged = cv2.Canny(imgGrey, 180, 200) print("Image edges detected") # image close operation Imgkernel = cv2.getStructuringElement(cv2.MORPH_RECT, (7, 7)) Imgclosed = cv2.morphologyEx(imgEdged, cv2.MORPH_CLOSE, Imgkernel) print("Image close operation") circles = cv2.HoughCircles(imgEdged,cv2.HOUGH_GRADIENT,1,10, param1=90,param2=90,minRadius=0,maxRadius=150) circles = np.uint16(np.around(circles)) print("Hough transformation performed") for i in circles[0,:]: print(i) # draw the outer circle cv2.circle(rawImg,(i[0],i[1]),i[2],(0,255,0),2) # draw the center of the circle cv2.circle(rawImg,(i[0],i[1]),2,(0,0,255),3) print("save modified jpg") cv2.imwrite(imgPath + 'rawImg.jpg', rawImg) cv2.imwrite(imgPath + 'imgEdged.jpg', Imgclosed) # cv2.imshow("Edged", edged) # cv2.waitKey(0) time.sleep(300)
def detect_faces(image_path): image = cv2.imread(image_path, 0) #image_grey = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) faces = FACE_CASCADE.detectMultiScale(image, scaleFactor=1.16, minNeighbors=5, minSize=(25, 25), flags=0) for x, y, w, h in faces: sub_image = image[y - 10:y + h + 10, x - 10:x + w + 10] os.chdir("Extracted") cv2.write(str(randint(0, 10000)) + ".jpg", sub_image) os.chdir("../") cv2.rectangle(image, (x, y), (x + w, y + h), (255, 255, 0), 2) cv2.imshow("Faces Found", image) if (cv2.waitKey(0) & 0xFF == ord('q')) or (cv2.waitKey(0) & 0xFF == ord('Q')): cv2.destroyAllWindows()
def find_pose(self, img, draw=True, save_img_path=None): """ Parameters ---------- img : image variable Image on which the pose has to be estimated. draw : bool, optional Whether to draw the pose on the image/video. The default is True. save_img_path : bool, optional Whether to save the image. Works only when self.mode = True. To save the image assign the path to the save_img_path variable. The default is None. Returns ------- img : list The input image """ if self.mode: save_img_path = None img = cv.cvtColor(img, cv.COLOR_BGR2RGB) self.results = self.pose.process(img) if self.results.pose_landmarks: if draw: if not self.mode: img = cv.cvtColor(img, cv.COLOR_RGB2BGR) self.mp_draw.draw_landmarks(img, self.results.pose_landmarks, self.mp_pose.POSE_CONNECTIONS) if save_img_path: cv.write(save_img_path + ".png", img) else: print("Pose detection failed. No objects/images/poses found") return img
def infer_on_stream(args, client): """ Initialize the inference network, stream video to network, and output stats and video. :param args: Command line arguments parsed by `build_argparser()` :param client: MQTT client :return: None """ args=build_argparser().parse_args() single_image_mode=False # Initialise the class infer_network = Network() # Set Probability threshold for detections prob_threshold = args.prob_threshold ###Load the model through `infer_network` ### num_requests=2 infer_network.load_model(args.model, args.device,args.cpu_extension) input_shape=infer_network.get_input_shape() n,c,h,w=input_shape ### TODO: Handle the input stream ### # Checks for live feed if args.input == 'CAM': args.input= 0 # Checks for input image elif args.input.endswith('.jpg') or args.input.endswith('.bmp') : single_image_mode = True # Capture video capture=cv2.VideoCapture(args.input) capture.open(args.input) if single_image_mode: out=None else: out=cv2.VideoWriter('output.mp4',0x00000021,30,(100,100)) if not capture.isOpened(): log.error("Input not supported") width_=capture.get(3) height_=capture.get(4) #Init Variables fcounter=0 etime=0 c_count=0 pcount=0 tcount=0 count_list=deque(maxlen=FRAME_KEEP) #Loop until stream is over while capture.isOpened(): flag,frame=capture.read() if not flag: break key_pressed=cv2.waitKey(60) #Pre-processing the input/frame proc_frame=cv2.resize(frame,(w,h)) proc_frame=proc_frame.transpose((2,0,1)) proc_frame=proc_frame.reshape(1, *proc_frame.shape) #Async inference infer_network.init_async_infer(proc_frame) start=time.time() fcounter=fcounter+1 #Waiting for result if infer_network.wait()==0: end=time.time() time_difference=end-start #Result from the inference result=infer_network.get_output() #Extract the desired stats from the result frame,c_counter=draw_box(frame,result,args.prob_threshold,width_,height_) #Calculate and send relevant information on current_count, total_count and duration to the MQTT server # ### Topic "person": keys of "count" and "total" ### ### Topic "person": keys of "count" and "total" ### message="Time: {:.3f}ms".format(time_difference*1000) cv2.putText(frame,message,(15,15),cv2.FONT_HERSHEY_COMPLEX,0.5,(10,200,10),1) count_list.append(c_count) average_count=sum(count_list)/4 keep_count=int(np.ceil(average_count)) if fcounter%FRAME_KEEP==0: if keep_count>pcount: etime=time.time() tcount+=(keep_count-pcount) client.publish("person",json.dumps({"total":tcount})) if keep_count<pcount: duration=int(time.time()-etime) client.publish("person/duration",json.dumps({"duration":duration})) client.publish("person",json.dumps({"count":keep_count})) pcount=keep_count if key_pressed==27: break if not single_image_mode: sys.stdout.buffer.write(frame) sys.stdout.flush() if single_image_mode: cv2.write('output_img.jpg',frame) capture.release() cv2.destroyAllWindows() client.disconnect()
def create_dataset(img, id, img_id): cv2.write("data/pic." + str(id) + "." + str(img_id) + ".jpg", img)
def main(args=None): parser = argparse.ArgumentParser(description='Simple training script for training a RetinaNet network.') parser.add_argument('--dataset', help='Dataset type, must be one of csv or coco.') parser.add_argument('--coco_path', help='Path to COCO directory') parser.add_argument('--csv_classes', help='Path to file containing class list (see readme)') parser.add_argument('--csv_val', help='Path to file containing validation annotations (optional, see readme)') parser.add_argument('--img_path', help='Path to file to save val images') parser.add_argument('--model', help='Path to model (.pt) file.') parser = parser.parse_args(args) if parser.dataset == 'coco': dataset_val = CocoDataset(parser.coco_path, set_name='train2017', transform=transforms.Compose([Normalizer(), Resizer()])) elif parser.dataset == 'csv': dataset_val = CSVDataset(train_file=parser.csv_train, class_list=parser.csv_classes, transform=transforms.Compose([Normalizer(), Resizer()])) else: raise ValueError('Dataset type not understood (must be csv or coco), exiting.') sampler_val = AspectRatioBasedSampler(dataset_val, batch_size=1, drop_last=False) dataloader_val = DataLoader(dataset_val, num_workers=1, collate_fn=collater, batch_sampler=sampler_val) retinanet = torch.load(parser.model) use_gpu = True if use_gpu: if torch.cuda.is_available(): retinanet = retinanet.cuda() if torch.cuda.is_available(): retinanet = torch.nn.DataParallel(retinanet).cuda() else: retinanet = torch.nn.DataParallel(retinanet) retinanet.eval() unnormalize = UnNormalizer() def draw_caption(image, box, caption): b = np.array(box).astype(int) cv2.putText(image, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1, (0, 0, 0), 2) cv2.putText(image, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255), 1) for idx, data in enumerate(dataloader_val): with torch.no_grad(): st = time.time() if torch.cuda.is_available(): scores, classification, transformed_anchors = retinanet(data['img'].cuda().float()) else: scores, classification, transformed_anchors = retinanet(data['img'].float()) print('Elapsed time: {}'.format(time.time()-st)) idxs = np.where(scores.cpu()>0.5) img = np.array(255 * unnormalize(data['img'][0, :, :, :])).copy() img[img<0] = 0 img[img>255] = 255 img = np.transpose(img, (1, 2, 0)) img = cv2.cvtColor(img.astype(np.uint8), cv2.COLOR_BGR2RGB) for j in range(idxs[0].shape[0]): bbox = transformed_anchors[idxs[0][j], :] x1 = int(bbox[0]) y1 = int(bbox[1]) x2 = int(bbox[2]) y2 = int(bbox[3]) label_name = dataset_val.labels[int(classification[idxs[0][j]])] draw_caption(img, (x1, y1, x2, y2), label_name) cv2.rectangle(img, (x1, y1), (x2, y2), color=(0, 0, 255), thickness=2) print(label_name) cv2.write(img_path + str(idx) + ".jpeg", img) cv2.waitKey(0)
import numpy as np import pandas as pd import cv2 as cv from matplotlib import pyplot as plt img = cv.imread('/home/ai3/Desktop/common/ML/Day12/walking.png', 0) ret, thresh1 = cv.threshold(img, 127, 255, cv.THRESH_BINARY) titles = ['OriginalImg', 'BINARY'] images = [img, thresh1] imgx = np.hstack([thresh1]) cv.imshow("desd", imgx) cv.waitKey(0) cv.write("walking binary.jpg")
import cv2 img=cv2.imread('imagem.png',cv2.IMREAD_UNCHANGED) print("Dimensao Original: " img.shape) scale_percent=20 largura = int (img.shape[1]* scale_percent/100) altura = int (img.shape[0]* scale_percent/100) dim=(largura,altura) resized= cv2.resized(img, dim, interpolationcv2.INTER_AREA) print("Dimensao Obtida: ", resized.shape) cv2.write('escala.png', resized)
parser.add_argument('--gpu', dest="gpu", type=int, default=-1, help='enter the number of gpu') parser.add_argument('--image_out', dest="out", default="out.jpg", help='enter the path to the output') args = parser.parse_args() files = glob("Images/normal/*") from Inference import Infer Inference_class = Infer(detect_thresh=0.5, gpu=args.gpu) for n, i in enumerate(files): i = cv2.imread(i) bboxes, classes, scores = Inference_class.infer(image_path=i, out="out/Classification/" + str(n) + ".jpg") for s, b in enumerate(bboxes): y, x, y2, x2 = b cv2.putText(l, classes[s], (int(x), int(y)), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA) cv2.rectangle(l, (int(x), int(y)), (int(x2), int(y2)), (0, 255, 0), 2) cv2.write("out/Classification/" + str(n) + ".jpg", i)
if retval: #first, make sure that the image exists! if None in [dim == 0 for dim in img.shape].any(): raise (Exception( "snapped an empty image, you should restart the camera")) else: return img else: return False if __name__ == "__main__": cs = cameraService(timeout=5) img = cs.snap("front") if img: cv2.write("front_img.png") print("snapped a new front image, check it out!") else: print("failed to snap a front image :(") #-------------------------- REFERENCE JUNK BELOW ------------------------------- quit() while True: for i in [-1, -2]: cameras[i] = cv2.VideoCapture(i) print("camera", i, "is opened:", cameras[i].isOpened()) if all([camera.isOpened() for camera in cameras]): break firstTime = time.time() lastTime = time.time()
# from dataloaders import dataloader_rgbd # import numpy as np # import cv2 # import os # dataset_path = '/tmp/Projects2021/rgbd_dataset/nyu_data/' # dtloader = nyu2_dataloader(dataset_path, 8, image_size=[256, 128]) # X_test, y_test = dtloader.get_testing_sample() # dataset_path2 = '/tmp/Projects2021/depth_estimation/final-project-monodepth-ccny/extrascripts/depth_pred/' # depth_images = os.listdir(dataset_path2) # depth_images.sort() # depth_images = [str(dataset_path2) + file for file in depth_images] # image_main = np.array([]) # for i, depth_file in enumerate(depth_images): # depth_img = cv2.imread(depth_file) # depth_orig = y_test[i] # depth_img = np.concatenate((depth_img, depth_orig), axis=1) # image_main = np.append(image_main, depth_img) # if i > 8: # break cv2.write('res_figure1.png', image_main) dataset_path = '/tmp/Projects2021/rgbd_dataset/indoor' dtloader = dataloader_rgbdfft(dataset_path, 8, image_size=[256, 256, 1]) X, y = dtloader.__getitem__(0) print(X.shape) print(y.shape)
def infer_on_stream(args, client): """ Initialize the inference network, stream video to network, and output stats and video. :param args: Command line arguments parsed by `build_argparser()` :param client: MQTT client :return: None """ num_requests = 0 # Flag for the single image single_image_mode = False # Initialise the class infer_network = Network() # Set Probability threshold for detections prob_threshold = args.prob_threshold ### TODO: Load the model through `infer_network` ### n, c, h, w = infer_network.load_model(args.model, args.device, 1, 1, num_requests, args.cpu_extension)[1] ### TODO: Handle the input stream ### # Check for Webcam if args.input =="CAM": input_stream = 0 # Check for Image (jpg, bmp, png) elif args.input.endswith(".jpg") or args.input.endswith(".bmp") or args.input.endswith(".png") : single_image_mode = True input_stream = args.input # Check for video else: input_stream = args.input assert os.path.isfile(args.input), "There is no video file" ### TODO: Loop until stream is over ### cap = cv2.VideoCapture(input_stream) if input_stream: cap.open(args.input) if not cap.isOpened(): log.error("Error: No video source") ### Variables total_count = 0 duration = 0 person_on_screen = False person_count = 0 no_person_count = 0 people_count = 0 duration_time = 0 width = cap.get(3) height = cap.get(4) durration_flag = 0 new_person_flag = 0 person_leaves_flag = 0 request_id = 0 i_start = 0 person_detected = 0 ### TODO: Read from the video capture ### while cap.isOpened(): flag, frame = cap.read() if not flag: break key_pressed = cv2.waitKey(60) ### TODO: Pre-process the image as needed ### image = cv2.resize(frame, (w, h)) # HWC to CHW image = image.transpose((2, 0, 1)) image = image.reshape((n, c, h, w)) ### TODO: Start asynchronous inference for specified request ### infer_network.exec_net(image,request_id) inf_start_time = time.time() ### TODO: Wait for the result ### if infer_network.wait(request_id) == 0: det_time = time.time() - inf_start_time current_count = 0 ### TODO: Get the results of the inference request ### result = infer_network.get_output(request_id) ##Put the inference time in the frame ### time_message = "Inference time: {:.3f}ms".format(det_time * 1000) mes_on_frame_01 = "Model: " + args.model mes_on_frame_02 = "Threshold: " + str(prob_threshold) cv2.putText(frame,time_message, (15, 15),cv2.FONT_HERSHEY_COMPLEX, 0.5, (200, 10, 10), 1) cv2.putText(frame,mes_on_frame_01, (15, 30),cv2.FONT_HERSHEY_COMPLEX, 0.5, (200, 10, 10), 1) cv2.putText(frame,mes_on_frame_02, (15, 45),cv2.FONT_HERSHEY_COMPLEX, 0.5, (200, 10, 10), 1) for obj in result[0][0]: if obj[2] > prob_threshold: current_count = current_count + 1 xmin = int(obj[3] * width) xmin = int(obj[3] * width) ymin = int(obj[4] * height) xmax = int(obj[5] * width) ymax = int(obj[6] * height) cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), (0, 55, 255),1) person_detected = 1 if person_detected: person_count = person_count + 1 no_person_count = 0 else: no_person_count = no_person_count +1 person_count = 0 person_detected = 0 if person_count == 5 and person_on_screen == False: person_on_screen = True current_count = 1 i_start = time.time() person_count = 0 no_person_count = 0 durration_flag = 0 elif no_person_count == 5 and person_on_screen == True: person_on_screen = False current_count = 0 i_start = time.time() - i_start person_count = 0 no_person_count = 0 total_count = total_count +1 duration_time = duration_time + i_start i_start = 0 duration = round(duration_time / total_count) durration_flag = 1 client.publish("person", json.dumps({"count":current_count})) if durration_flag: client.publish("person/duration", json.dumps({"duration": duration})) durration_flag = 0 ### TODO: Send the frame to the FFMPEG server ### sys.stdout.buffer.write(frame) sys.stdout.flush() ### TODO: Write an output image if `single_image_mode` ### if single_image_mode: cv2.write("out.jpg", frame) cap.release() cv2.destroyAllWindows() client.disconnect() infer_network.clean()
def rescale_frame(frame, percent=75): width = int(frame.shape[1] * percent/ 100) height = int(frame.shape[0] * percent/ 100) dim = (width, height) return cv2.resize(frame, dim, interpolation =cv2.INTER_AREA) while(True): # Capture frame-by-frame ret, frame = cap.read() #frame = rescale_frame(frame, percent=150) # Our operations on the frame come here gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectmultiScale(gray,scaleFactor=1.5, minNeighbour=5) for(x, y, w, h) in faces: print(x,y,w,h) roi_gray = gray[y:y+h, x:x+w] img_item ="my-image.png" cv2.write(img_item, roi_gray) # Display the resulting frame cv2.imshow('frame',frame) #cv2.imshow('gray',gray) if cv2.waitKey(20) & 0xFF == ord('q'): break # When everything done, release the capture cap.release() cv2.destroyAllWindows()
if len(sys.argv) > 2: im = sys.argv[1] else: print("Please pass a image file as argument") exit(1); image = cv2.imread(im) # Predict result with network result = network.predict(format_image(image)) SAVE_DIR = os.path.join("..","output"); # Write results to output folder if result is not None: for index, emotion in enumerate(EMOTIONS): # Appends a descriptive text of the detected image cv2.putText(image, emotion, (10, index * 20 + 20), cv2.FONT_HERSHEY_PLAIN, 0.5, (0, 255, 0), 1); # Append a rectangle area against the detect image cv2.rectangle(image, (130, index * 20 + 10), (130 + int(result[0][index] * 100), (index + 1) * 20 + 4), (255, 0, 0), -1) #Appends the emotion face_image = feelings_faces[result[0].index(max(result[0]))] cv2.write(os.path.join(SAVE_DIR,"app_output.jpg"),face_image)
def infer_on_stream(args, client): """ Initialize the inference network, stream video to network, and output stats and video. :param args: Command line arguments parsed by `build_argparser()` :param client: MQTT client :return: None """ args = build_argparser().parse_args() single_image_mode = False # Initialise the class infer_network = Network() model = args.model video_file = args.input extnsn = args.cpu_extension device = args.device start_time = 0 cur_request_id = 0 last_count = 0 total_count = 0 n, c, h, w = infer_network.load_model(model, device, 1, 1, cur_request_id, extnsn)[1] ### TODO: Handle the input stream ### # Checks for live feed if video_file == 'CAM': input_stream = 0 # Checks for input image elif video_file.endswith('.jpg') or video_file.endswith('.bmp'): single_image_mode = True input_stream = video_file else: input_stream = video_file assert os.path.isfile(video_file), "File doesn't exist" try: # Capture video capture = cv2.VideoCapture(video_file) except FileNotFoundError: print("Cannot locate the file: " + video_file) except Exception as e: print("Something went wrong with the file: " + e) global initial_w, initial_h, prob_threshold total_count = 0 duration = 0 initial_w = capture.get(3) initial_h = capture.get(4) # Set Probability threshold for detections prob_threshold = args.prob_threshold temp = 0 tk = 0 #Loop until stream is over while capture.isOpened(): flag, frame = capture.read() if not flag: break key_pressed = cv2.waitKey(60) #Pre-processing the input/frame image = cv2.resize(frame, (w, h)) image = image.transpose((2, 0, 1)) image.reshape((n, c, h, w)) #Async inference inf_start = time.time() infer_network.exec_net(cur_request_id, image) color = (255, 0, 0) #Waiting for result if infer_network.wait(cur_request_id) == 0: time_elapsed = time.time() - inf_start #Result from the inference result = infer_network.get_output(cur_request_id) #Bounting box frame, current_count, d, tk = draw_box(result, frame, initial_w, initial_h, temp, tk) #inference time inf_timemsg = "Inference Time: {:,3f}ms".format(time_elapsed * 1000) cv2.putText(frame, inf_timemsg, (15, 15), cv2.FONT_HERSHEY_COMPLEX, 0.5, color, 1) #Calculating and sending info if current_count > last_count: start_time = time.time() total_count = total_count + current_count - last_count client.publish("person", json.dumps({"total": total_count})) if current_count < last_count: duration = int(time.time() - start_time) client.publish("person/duration", json.dumps({"duration": duration})) text_2 = "Distance: %d" % d + " Lost frame: %d" % tk cv2.putText(frame, text_2, (15, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, color, 1) text_2 = "Current count: %d" % current_count cv2.putText(frame, text_2, (15, 45), cv2.FONT_HERSHEY_COMPLEX, 0.5, color, 1) if current_count > 3: text_2 = "Maximum count reached!!!" (text_width, text_height) = cv2.getTextSize(text_2, cv2.FONT_HERSHEY_COMPLEX, 0.5, thickness=1)[0] text_offset_x = 10 text_offset_y = frame.shape[0] - 10 box_coords = ((text_offset_x, text_offset_y + 2), (text_offset_x + text_width, text_offset_y - text_height - 2)) cv2.rectangle(frame, box_coords[0], box_coords[1], (0, 0, 0), cv2.FILLED) cv2.putText(frame, text_2, (text_offset_x, text_offset_y), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 255), 1) client.publish("person", json.dumps({"count": current_count})) last_count = current_count temp = d if key_pressed == 27: break sys.stdout.buffer.write(frame) sys.stdout.flush() #Saving Image if single_image_mode: cv2.write('output_image.jpg', frame) capture.release() cv2.destroyAllWindows() client.disconnect() infer_network.clean()
import math from fish2pano_cv2_rgb import fish2pano import time import os import subprocess as sp import sys cap = cv2.VideoCapture(0) while (cap.isOpened()): ret, frame = cap.read() #print(type(frame), frame.dtype) # print(frame.shape[0], frame.shape[1]) start = time.time() pano = fish2pano(frame) #.astype('u8') #pano= cv2.logPolar(frame, (frame.shape[0]/2, frame.shape[1]/2), 100, cv2.WARP_FILL_OUTLIERS) # [0]: height; [1]: width cv2.write('frame.png', pano) # % count, pano) sp.call( '/usr/local/bin/ffmpeg -f image2 -s 240x960 -r 1/2 -i frame.png -vcodec mjpeg http://localhost:8090/cam2.ffm', shell=True) #sp.call('/usr/local/bin/ffmpeg -f image2 -s 240x960 -r 1/5 -i frame.png -f mpegts udp://localhost:1234', shell=True) # to simply display #cv2.imshow('preview', pano) end = time.time() print(end - start) #cv2.waitKey(1000) #sp.call(['/usr/local/bin/ffmpeg -f image2 -s 240x960 -r 1 -i image2pipe -vcodec mpeg4 -y mvoei.mpeg'], shell=True) cap.release()
imgPath = urllib.request.urlopen(url) imgNp = numpy.array(bytearray(imgPath.read()), dtype=numpy.uint8) im = cv2.imdecode(imgNp, -1) gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.3, 5) for (x, y, w, h) in faces: cv2.rectangle(im, (x, y), (x + w, y + h), (255, 255, 255), 4) face = gray[y:y + h, x:x + w] face_resize = cv2.resize(face, (width, height)) prediction = model.predict(face_resize) cv2.rectangle(im, (x, y), (x + w, y + h), (255, 255, 255), 4) if prediction[1] < 800: cv2.putText(im, '%s - %.0f' % (names[prediction[0]], prediction[1]), (x - 10, y - 10), cv2.FONT_HERSHEY_PLAIN, 2, (0, 255, 255)) print(names[prediction[0]]) cnt = 0 else: cnt += 1 cv2.putText(im, 'unknowN', (x - 10, y - 10), cv2.FONT_HERSHEY_PLAIN, 2, (0, 0, 255)) print("Unknown") cv2.write("unknown.jpg", im) cnt = 0 cv2.imshow("FaceRecongintion", im) if cv2.waitKey(10) == 27: break cv2.destroyAllWindows()