def add_salt_pepper_noise(image): # Need to produce a copy as to not modify the original image X_imgs_copy = image.copy() row, col, _ = image.shape salt_vs_pepper = 0.2 amount = 0.004 num_salt = np.ceil(amount * X_imgs_copy.size * salt_vs_pepper) num_pepper = np.ceil(amount * X_imgs_copy.size * (1.0 - salt_vs_pepper)) seed = random.random() if seed > 0.75: # Add Salt noise coords = [ np.random.randint(0, i - 1, int(num_salt)) for i in X_imgs_copy.shape ] X_imgs_copy[coords[0], coords[1], :] = 1 elif seed > 0.5: # Add Pepper noise coords = [ np.random.randint(0, i - 1, int(num_pepper)) for i in X_imgs_copy.shape ] X_imgs_copy[coords[0], coords[1], :] = 0 else: return image return X_imgs_copy
def annotate_image(image, model): # copy to draw on draw = image.copy() # preprocess image for network image = preprocess_image(image) image, scale = resize_image(image) # process image start = time.time() _, _, detections = model.predict_on_batch(np.expand_dims(image, axis=0)) print("processing time: ", time.time() - start) # compute predicted labels and scores predicted_labels = np.argmax(detections[0, :, 4:], axis=1) scores = detections[0, np.arange(detections.shape[1]), 4 + predicted_labels] # correct for image scale detections[0, :, :4] /= scale # visualize detections for idx, (label, score) in enumerate(zip(predicted_labels, scores)): if score < 0.3: continue b = detections[0, idx, :4].astype(int) cv2.rectangle(draw, (b[0], b[1]), (b[2], b[3]), (0, 0, 255), 3) return draw
def detectAlphabets(imageToRecognize): args = parse_args() args.val_path = imageToRecognize # os.environ["CUDA_VISIBLE_DEVICES"] = "0" keras.backend.tensorflow_backend.set_session(get_session()) model = keras.models.load_model(os.path.join(dir, '../snapshots/resnet50_csv_wtext.h5'), custom_objects=custom_objects) test_image_data_generator = keras.preprocessing.image.ImageDataGenerator() # # # create a generator for testing data test_generator = CSVGenerator( csv_data_file=args.annotations, csv_class_file=args.classes, image_data_generator=test_image_data_generator, batch_size=args.batch_size ) # index = 0 # load image image = read_image_bgr(args.val_path) # copy to draw on draw = image.copy() draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB) # preprocess image for network image = preprocess_image(image) image, scale = resize_image(image) # process image start = time.time() _, _, detections = model.predict_on_batch(np.expand_dims(image, axis=0)) print("processing time: ", time.time() - start) print('detections:', detections) # compute predicted labels and scores predicted_labels = np.argmax(detections[0, :, 4:], axis=1) scores = detections[0, np.arange(detections.shape[1]), 4 + predicted_labels] print("label=", predicted_labels) # correct for image scale scaled_detection = detections[0, :, :4] / scale # visualize detections recognized = {} plt.figure(figsize=(15, 15)) plt.axis('off') for idx, (label, score) in enumerate(zip(predicted_labels, scores)): if score < 0.35: continue b = scaled_detection[idx, :4].astype(int) cv2.rectangle(draw, (b[0], b[1]), (b[2], b[3]), (0, 0, 255), 1) caption = test_generator.label_to_name(label) if caption == "equal": caption = "=" cv2.putText(draw, caption, (b[0], b[1] - 1), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255), 1) recognized[caption] = b print(caption + ", score=" + str(score)) plt.imshow(draw) plt.show() return recognized, draw
def logopreds(prediction_model,image,p): draw = image.copy() draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB) image = preprocess_image(image) image, scale = resize_image(image) _, _, detections = prediction_model.predict_on_batch(np.expand_dims(image, axis=0)) predicted_labels = np.argmax(detections[0, :, 4:], axis=1) scores = detections[0, np.arange(detections.shape[1]), 4 + predicted_labels] detections[:, :4] /= scale for idx, (label, score) in enumerate(zip(predicted_labels, scores)): if score < 0.5: continue b = detections[0, idx, :4].astype(int) cv2.rectangle(draw, (b[0], b[1]), (b[2], b[3]), (0, 0, 255), 3) caption = "{} {:.3f}".format(p['l2n'][label], score) cv2.putText(draw, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 0, 0), 3) cv2.putText(draw, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1.5, (255, 255, 255), 2) return draw
def predict_level(crop_image, original_image, trigger): # if(trigger == True): # isLevel1 = detect_level_1(graph, sess, crop_image) # if(isLevel1 == True): # prediction = 'Level 1' # return prediction # else: # prediction = 'Nothing detected' # return prediction image = cv2.imread(crop_image) original_image = cv2.imread(original_image) # cv2.imshow('ori', original_image) # cv2.imshow('crop', image) # cv2.waitKey(0) # detect level 4 ( black ) isLevel1 = detect_level_1(crop_image) if (isLevel1 == True): prediction = 1 return prediction isLevel4 = detect_level_4(image.copy()) if (isLevel4 == True): prediction = 4 return prediction n_cluster = 3 img = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) img = img.reshape((img.shape[0] * img.shape[1], 3)) clt = KMeans(n_cluster) clt.fit(img) hist = find_histogram(clt) bar, color = plot_colors2(hist, clt.cluster_centers_) # plt.axis('off') # plt.imshow(bar) # plt.show() depth_score = verify_pothole(color) # print('depth: ', depth_score) # print('image size', image.size) # print('original size', original_image.size) ratio = image.size / original_image.size # print('ratio:', ratio) final_ratio = ratio + depth_score # print('final ratio', final_ratio) if (final_ratio <= 1.0): prediction = 2 else: prediction = 3 # print(prediction) return prediction # graph = tf.Graph() # sess = tf.Session(graph = graph) # with graph.as_default(): # with sess.as_default(): # #predict._init_(graph, sess) # _init_(graph, sess) # predict_level(graph, sess, crop_image, original_image, trigger)
def threaded_resize(image, y, x, patch_width, patch_height, resize=False): clone = image.copy() crop_img = clone[y:y + patch_width, x:x + patch_height] if resize: return cv2.resize(crop_img, (224, 224)) else: return crop_img
def run_avg(image, accumWeight): global bg if bg is None: bg = image.copy().astype("float") return cv2.accumulateWeighted( image, bg, accumWeight ) # compute weighted average, accumulate it and update the background
def predict(): # initialize the data dictionary that will be returned from the # view app_id = request.args.get('app-id') logging.basicConfig(format='%(asctime)s - %(message)s', level=logging.INFO) logging.info('app-id = ' + app_id) data = {"success": False} # ensure an image was properly uploaded to our endpoint if flask.request.method == "POST": if flask.request.files.get("image"): # read the image in PIL format and prepare it for # classification image = flask.request.files["image"].read() image = Image.open(io.BytesIO(image)) image = prepare_image( image, (settings.IMAGE_WIDTH, settings.IMAGE_HEIGHT)) # ensure our NumPy array is C-contiguous as well, # otherwise we won't be able to serialize it image = image.copy(order="C") # generate an ID for the classification then add the # classification ID + image to the queue k = app_id + '.' + str(uuid.uuid4()) print(k) image = helpers.base64_encode_image(image) d = {"id": k, "image": image} db.rpush(settings.IMAGE_QUEUE, json.dumps(d)) # keep looping until our model server returns the output # predictions while True: # attempt to grab the output predictions output = db.get(k) # check to see if our model has classified the input # image if output is not None: # add the output predictions to our data # dictionary so we can return it to the client output = output.decode("utf-8") data["predictions"] = json.loads(output) # delete the result from the database and break # from the polling loop db.delete(k) break # sleep for a small amount to give the model a chance # to classify the input image time.sleep(settings.CLIENT_SLEEP) # indicate that the request was a success data["success"] = True # return the data dictionary as a JSON response return flask.jsonify(data)
def callback(self, image): self.step += 1 self.styled_image = image.copy() if self.verbose: print('Optimization step: %d/%d' % (self.step, self.iteration)) if self.step == 1 or self.step % self.save_every_n_steps == 0: self.save_image(image)
def quick_composite(image, mask, offset): if mask.ndim < 3: mask = np.dstack([mask] * 3) fg = cv2.cvtColor((image.copy() * 255).astype(np.uint8), cv2.COLOR_RGB2Lab) fg[:, :, 0] = np.clip(fg[:, :, 0] * offset, 0, 255) fg = cv2.cvtColor(fg, cv2.COLOR_Lab2RGB) / 255. comp = fg * mask + image * (1 - mask) comp = np.clip(comp, 0.0, 1.0) return comp
def mask_image_with_mean_background(mask_object_found, image): new_image = image.copy() size_image = np.shape(mask_object_found) for j in range(size_image[0]): for i in range(size_image[1]): if mask_object_found[j][i] == 1: new_image[j, i, 0] = 103.939 new_image[j, i, 1] = 116.779 new_image[j, i, 2] = 123.68 return new_image
def cv2pil(image): """ OpenCV型 -> PIL型 """ new_image = image.copy() if new_image.ndim == 2: # モノクロ pass elif new_image.shape[2] == 3: # カラー new_image = cv2.cvtColor(new_image, cv2.COLOR_BGR2RGB) elif new_image.shape[2] == 4: # 透過 new_image = cv2.cvtColor(new_image, cv2.COLOR_BGRA2RGBA) new_image = Image.fromarray(new_image) return new_image
def classify_gesture(image): pred_image = image.copy() pred_image = np.expand_dims(pred_image, axis=0) pred_image = pred_image.reshape((-1, 28, 28, 1)) image_class = model.predict(pred_image) try: gesture = GESTURES[image_class[0].tolist().index(1.0)] except ValueError: gesture = "NA" return gesture
def mask_nth_digit_in_image(image, n, out=None): """Return a copy of `image` with all but the `n`th digit masked.""" # If we sum the image vertically, a plot of the column sums will present # four humps, each corresponding to a digit. This masking routine detects # the humps and masks the image so only the pixels contributing to the n'th # hump are visible. colsum = np.sum(image, axis=0).ravel() # # Now we need to find the least t such that image > t obtains four separate # # contiguous 'True' regions. We'll scan up from t = 0... # thresholded = colsum > 0 # These two lines are just for # labels = sp.ndimage.label(thresholded)[0] # memory allocation. # for t in range(int(max(colsum))): # np.greater(colsum, t, out=thresholded) # if sp.ndimage.label(thresholded, output=labels) == 4: break # else: # raise RuntimeError('mask_nth_digit could not find four distinct digits ' # 'in an image.') # # We can now mask off the columns not containing the n'th digit. # if out is None: # out = image.copy() # else: # np.copyto(out, image) # out[:, labels != (n + 1)] = 0 # return out # These columns are not allowed to have image boundaries in them. colsum[:7] = 1000 colsum[9:13] = 1000 colsum[16:19] = 1000 colsum[23:] = 1000 # The columns containing the four digits are separated by the three smallest # minima of colsum not at the edges of the image. left_less = colsum[:-1] < colsum[1:] # True entries in this array are 4 pixels left of all local minima in colsum. # This 4-offset allows us to ignore pixels at the edges of the image. minima_mask = left_less[4:-3] & ~left_less[3:-4] # So these are the minima's indices: minima_inds = np.argwhere(minima_mask).ravel() + 4 # Find which three indices are associated with the smallest minima. boundaries = np.sort(minima_inds[np.argsort(colsum[minima_inds])[:3]]) # Perform the masking now. if out is None: out = image.copy() elif out is not image: np.copyto(out, image) if n > 0: out[:, :(boundaries[n - 1]), ...] = 0 if n < 3: out[:, (boundaries[n] + 1):, ...] = 0 return out
def classify_gesture_alt(image): pred_image = image.copy() pred_image = pred_image / 255 pred_image = pred_image.reshape(-1, 28, 28, 1) image_class = model.predict(pred_image) try: gesture = GESTURES[image_class[0].tolist().index(1.0)] except ValueError: gesture = "NA" return gesture
def Objectdetection_Predict_Click(self): print("Objectdetection predict proceeding.....") if self.model_changed: keras.backend.tensorflow_backend.set_session(self.get_session()) self.obd_model = models.load_model(self.model_path, backbone_name='resnet50') self.model_changed = False # keras.backend.tensorflow_backend.set_session(self.get_session()) # model = models.load_model(self.model_path, backbone_name='resnet50') labels_to_names = {} if self.classes_flag: for i in range(len(self.classes)): labels_to_names[i] = self.classes[i] # 여기에 labels_to_names = 추가 image = read_image_bgr(self.img_path) self.draw = image.copy() self.draw = cv2.cvtColor(self.draw, cv2.COLOR_BGR2RGB) image = preprocess_image(image) image, scale = resize_image(image) start = time.time() boxes, scores, labels = self.obd_model.predict_on_batch( np.expand_dims(image, axis=0)) print('Loaded in : ', round(time.time() - start, 2), ' sec') print('Threshold : ', 0.5) boxes /= scale cnt = 0 for box, score, label in zip(boxes[0], scores[0], labels[0]): cnt += 1 # scores are sorted so we can break if score < 0.5: break color = label_color(label) b = box.astype(int) draw_box(self.draw, b, color=color) if self.classes_flag: caption = "{} {:.2f}%".format(labels_to_names[label], score * 100) print('Box', cnt, ' : ', box, labels_to_names[label], score) else: caption = "{} {:.2f}%".format(label, score * 100) print('Box', cnt, ' : ', box, ', ', label, ', ', score) draw_caption(self.draw, b, caption) self.update_signal.run() self.save_button.setEnabled(True) self.model_path_button.setEnabled(True) self.change_button_signal.run()
def Draw_out(path): # load image image = read_image_bgr(path) # copy to draw ondraw = image.copy() draw = image.copy() draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB) # preprocess image for network image = preprocess_image(image) image, scale = resize_image(image) #print ('scale',scale) # process image start = time.time() boxes, scores, labels = model.predict_on_batch( np.expand_dims(image, axis=0)) #boxes是检测到的可能目标的框框 #print ('boxes',boxes) #是对应的分值 #print ('scores',scores) #对应的第几个标签 #print ('labels',labels) #print("processing time: ", time.time() - start) # correct for image scale boxes /= scale # visualize detections for box, score, label in zip(boxes[0], scores[0], labels[0]): # scores are sorted so we can break if score < 0.4: break color = label_color(label) #print ('label',label) b = box.astype(int) #b是box取整 #print ('b ',b) draw_box(draw, b, color=color) caption = "{} {:.3f}".format(labels_to_names[label], score) #single 0.431 是标签和分值 #print ('caption ',caption) draw_caption(draw, b, caption) plt.figure(figsize=(10, 10)) plt.axis('on') plt.imshow(draw) #plt.show() plt.savefig("static/js/powerbank_out.png") return caption
def mask_image_with_mean_background(mask_object_found, image, color): new_image = image.copy() size_image = np.shape(mask_object_found) for j in range(size_image[0]): for i in range(size_image[1]): if mask_object_found[j][i] == 1: if (j == 0 or mask_object_found[j - 1][i] == 0) or ( j == size_image[0] - 1 or mask_object_found[j + 1][i] == 0) or (i == 0 or mask_object_found[j][i - 1] == 0) or (i == size_image[1] - 1 or mask_object_found[j][i + 1] == 0): new_image[j, i, 0] = color[0] new_image[j, i, 1] = color[1] new_image[j, i, 2] = color[2] return new_image
def showImageCV(preds, imagePath, letter): # find the class label index with the largest corresponding # probability i = preds.argmax(axis=1)[0] # label = lb.classes_[i] # draw the class label + probability on the output image text = "{}: {:.2f}%".format(letter, preds[0][i] * 100) image = cv2.imread(imagePath) output = image.copy() cv2.putText(output, text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2) # show the output image cv2_imshow(output) cv2.waitKey(0)
def analyse_images(model, val_generator): for index in val_generator.size(): # for index in range(11, 12): # load image image = val_generator.load_image(index) # copy to draw on draw = image.copy() # draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB) # preprocess image for network image = val_generator.preprocess_image(image) height, width, channels = image.shape font_size = int(height / 1000) if font_size < 1: font_size = 1 image, scale = val_generator.resize_image(image) start = time.time() _, _, detections = get_predictions(model, image) print("processing time: ", time.time() - start) # compute predicted labels and scores predicted_labels = np.argmax(detections[0, :, 4:], axis=1) scores = detections[0, np.arange(detections.shape[1]), 4 + predicted_labels] # correct for image scale detections[0, :, :4] /= scale # visualize detections for idx, (label, score) in enumerate(zip(predicted_labels, scores)): if score < 0.5: continue b = detections[0, idx, :4].astype(int) cv2.rectangle(draw, (b[0], b[1]), (b[2], b[3]), (0, 255, 0), 3) caption = "{} {:.3f}".format(val_generator.label_to_name(label), score) cv2.putText(draw, caption, (b[0] - 50, b[1]), cv2.FONT_HERSHEY_DUPLEX, font_size, (0, 0, 0), 3) cv2.putText(draw, caption, (b[0] - 50, b[1]), cv2.FONT_HERSHEY_DUPLEX, font_size, (255, 255, 255), 2) cv2.imwrite('c:/test/' + str(index) + '.png', draw)
def region(rects): #number of region proposals to show while True: # create a copy of original image imOut = image.copy() # itereate over all the region proposals for i, rect in enumerate(rects): # draw rectangle for region proposal till numShowRec if (i < numShowRects): x, y, w, h = rect r = [] r.append(union(rects[i], rects[i + 1])) for (startX, startY, endX, endY) in r: cv2.rectangle(imOut, (startX, startY), (endX, endY), (0, 255, 0), 1) else: break return imOut
def visualize_bboxes(img_path,bboxes): # load image image = read_image_bgr(img_path) # copy to draw on draw = image.copy() draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB) #print(bboxes) labels_to_names = labelsToNames() for i in range(bboxes.shape[0]): b = bboxes[i,0:4].astype(int) label = bboxes[i,4] score = bboxes[i,5] cv2.rectangle(draw, (b[0], b[1]), (b[2], b[3]), (0, 0, 255), 3) plt.figure(figsize=(15, 15)) plt.axis('off') plt.imshow(draw) plt.show()
def logopreds(prediction_model, image, p): draw = image.copy() # Masking을 위한 프레임 생성 mask = np.zeros(image.shape, np.uint8) mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY) image = preprocess_image(image) image, scale = resize_image(image) _, _, detections = prediction_model.predict_on_batch(np.expand_dims(image, axis=0)) predicted_labels = np.argmax(detections[0, :, 4:], axis=1) scores = detections[0, np.arange(detections.shape[1]), 4 + predicted_labels] detections[:, :4] /= scale for idx, (label, score) in enumerate(zip(predicted_labels, scores)): if score < 0.3: continue b = detections[0, idx, :4].astype(int) # 타원으로 마스킹 하기 위한 계산(center: 타원 중심, axes: 중심에서 가장 큰 거리와 작은 거리) center = ((int)((b[0] + b[2]) / 2), (int)((b[1] + b[3]) / 2)) axes = ((int)(abs((b[0] - b[2]) / 2)), (int)(abs((b[1] - b[3]) / 2))) if p['erase'] == "erase": # Detect된 영역 Masking(사각형) # cv2.rectangle(mask, (b[0], b[1]), (b[2], b[3]), (255, 255, 255), -1) # Detect된 영역 Masking(타원) cv2.ellipse(mask, center, axes, 0, 0, 360, 255, -1) # cv2.INPAINT_TELEA / cv2.INPAINT_NS dst = cv2.inpaint(draw, mask, 0.01, cv2.INPAINT_NS) draw = dst else: cv2.rectangle(draw, (b[0], b[1]), (b[2], b[3]), (0, 0, 255), 3) caption = "{} {:.3f}".format(p['l2n'][label], score) cv2.putText(draw, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 0, 0), 3) cv2.putText(draw, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1.5, (255, 255, 255), 2) #cv2.imshow("mask", mask) return draw
def extractSkin(image): # Taking a copy of the image img = image.copy() # Converting from BGR Colours Space to HSV img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) # Defining HSV Threadholds lower_threshold = np.array([0, 48, 80], dtype=np.uint8) upper_threshold = np.array([20, 255, 255], dtype=np.uint8) # Single Channel mask,denoting presence of colours in the about threshold skinMask = cv2.inRange(img, lower_threshold, upper_threshold) # Cleaning up mask using Gaussian Filter skinMask = cv2.GaussianBlur(skinMask, (3, 3), 0) # Extracting skin from the threshold mask skin = cv2.bitwise_and(img, img, mask=skinMask) # Return the Skin image return cv2.cvtColor(skin, cv2.COLOR_HSV2BGR)
def _get_body_part_partitions(image, rows, cols): front_cols, side_cols, rows = _get_grid_axes(rows, cols) image = image.copy() image = [np.rot90(image[:, :, i]) for i in range(0, 16, 4)] image[1] = np.fliplr(image[1]) image[2] = np.fliplr(image[2]) ret = [] for label in _get_body_part_partition_labels(): images = [] for angle, p1, p2 in label: r1, c1 = p1 r2, c2 = p2 cols = front_cols if angle in (0, 2) else side_cols images.append( _crop_image(image[angle][rows[r1]:rows[r2 + 1], cols[c1]:cols[c2 + 1]])) ret.append(skimage.transform.resize(_concat_images(images), (256, 256))) return ret
def visualize_pred(img_path,bboxes): # load image image = read_image_bgr(img_path) # copy to draw on draw = image.copy() draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB) #print(bboxes) labels_to_names = labelsToNames() for i in range(bboxes.shape[0]): b = bboxes[i,0:4].astype(int) label = bboxes[i,4] score = bboxes[i,5] cv2.rectangle(draw, (b[0], b[1]), (b[2], b[3]), (0, 0, 255), 3) caption = "{} {:.3f}".format(labels_to_names[label], score) cv2.putText(draw, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 0, 0), 3) cv2.putText(draw, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1.5, (255, 255, 255), 2) plt.figure(figsize=(15, 15)) plt.axis('off') plt.imshow(draw) plt.show()
def select_region(self, image): """ select area manually """ # first, define the polygon by vertices rows, cols = image.shape[:2] pt_1 = [cols * 0.05, rows * 0.90] pt_2 = [cols * 0.05, rows * 0.70] pt_3 = [cols * 0.30, rows * 0.55] pt_4 = [cols * 0.6, rows * 0.15] pt_5 = [cols * 0.90, rows * 0.15] pt_6 = [cols * 0.90, rows * 0.90] vertices = np.array([[pt_1, pt_2, pt_3, pt_4, pt_5, pt_6]], dtype=np.int32) point_img = image.copy() point_img = cv2.cvtColor(point_img, cv2.COLOR_GRAY2RGB) for point in vertices[0]: cv2.circle(point_img, (point[0], point[1]), 10, (0, 0, 255), 4) self.cv_show('point_img', point_img) return self.filter_region(image, vertices)
# Set the width and height of the frame for video to be saved width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) # Create a writer object to save the frames writer = cv2.VideoWriter(r'C:\Users\Sharan Babu\Desktop\trimmed_video.mp4', cv2.VideoWriter_fourcc(*'XVID'), 25, (width, height)) final_video = [] while True: success, image = cap.read() if success == True: final_video.append(image) img = image.copy() # Draw a rectangle to indicate the region of interest img = cv2.flip(img, 1) cv2.rectangle(img, pt1=(450, 100), pt2=(620, 300), color=(0, 255, 0), thickness=3) cv2.imshow("Video", img) roi = img[102:298, 448:618] # Image pre-processing for making predictions of the image data = cv2.resize(roi, (224, 224)) data = np.array(data, dtype=np.float32)
li = [] odir = "parse_imgs" for filename in glob.glob(odir + "/*.png"): x.append(filename[11:]) new_set = [int(s.replace('.png', '')) for s in x] new_set.sort() new_n_set = ["parse_imgs/" + str(s) + ".png" for s in new_set] # print(new_n_set) for filename in new_n_set: model = "abc.model" # load the image image = cv2.imread(filename) orig = image.copy() # pre-process the image for classification image = cv2.resize(image, (30, 30)) image = image.astype("float") / 255.0 image = keras.preprocessing.image.img_to_array(image) image = np.expand_dims(image, axis=0) # load the trained convolutional neural network print("[INFO] loading network...") model = load_model(model) a = model.predict(image)[0] # print(a) pred = str(np.argmax(a)) li.append(pred) print(str(np.argmax(a)) + "\t" + filename)
def detect_one(image=None, index=0, threshold=0.5): # load image if none given: if type(image) == type(None): image = val_generator.load_image(index) # copy to draw on draw = image.copy() draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB) # preprocess image for network image = val_generator.preprocess_image(image) image, scale = val_generator.resize_image(image) # annotations = val_generator.load_annotations(index) # index += 1 # process image start = time.time() _, _, detections = model.predict_on_batch(np.expand_dims(image, axis=0)) print("processing time: ", time.time() - start) # compute predicted labels and scores predicted_labels = np.argmax(detections[0, :, 4:], axis=1) scores = detections[0, np.arange(detections.shape[1]), 4 + predicted_labels] # correct for image scale detections[0, :, :4] /= scale # visualize detections count = 0 max_score = -1 from collections import OrderedDict # dets = [] # max_score2 = -1 caption = "" for idx, (label, score) in enumerate(zip(predicted_labels, scores)): max_score = max(max_score, score) if score < threshold: continue b = detections[0, idx, :4].astype(int) assert len(b) == 4 cv2.rectangle(draw, (b[0], b[1]), (b[2], b[3]), (0, 0, 255), 3) caption = f'{val_generator.label_to_name(label)} {score:.3f}' cv2.putText(draw, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0, 0, 0), 3, cv2.LINE_AA) cv2.putText(draw, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 255, 255), 2, cv2.LINE_AA) print(caption) plt.figure(figsize=(15, 15)) plt.axis('off') plt.imshow(draw) plt.show()