def image_to_HED(path): ''' Here we load all the pretrained models and register the CropLayer class in it. Then we construct a blob from the image and pass it to the net.Then we resize the output to our desired shape and 0-255 colour scale and ensure that its of uint8 type. ''' protoPath = os.path.join("deeppixel", "edge_detection", "hed_model", "deploy.prototxt") modelPath = os.path.join("deeppixel", "edge_detection", "hed_model", "hed_pretrained_bsds.caffemodel") net = cv2.dnn.readNetFromCaffe(protoPath, modelPath) image = cv2.imread(path) cv2.dnn_registerLayer("Crop", CropLayer) (H, W) = image.shape[:2] blob = cv2.dnn.blobFromImage(image, scalefactor=1.0, size=(W, H), mean=(104.00698793, 116.66876762, 122.67891434), swapRB=False, crop=False) net.setInput(blob) hed_img = net.forward() hed_img = cv2.resize(hed_img[0, 0], (W, H)) hed_img = (255 * hed_img).astype("uint8") return hed_img
def do_pb(self): path = pjoin(self.root_path, 'precomp_desc', 'pb') # print('getting probability boundaries...') if (os.path.exists(path)): # print('found directory {}. Delete to re-run'.format(path)) return else: os.makedirs(path) self.get_model() self.model = cv.dnn.readNet(self.model_arch_path, self.model_weights_path) cv.dnn_registerLayer('Crop', CropLayer) print('will save frames to {}'.format(path)) pbar = tqdm(total=len(self.dl)) for s in self.dl: im = (s['image'] * 255).astype(np.uint8) inp = cv.dnn.blobFromImage(im, scalefactor=1.0, size=(512, 512), mean=(104.00698793, 116.66876762, 122.67891434), swapRB=False, crop=False) self.model.setInput(inp) out = self.model.forward() out = out[0, 0] out = cv.resize(out, (im.shape[1], im.shape[0])) out = 255 * out out = out.astype(np.uint8) io.imsave(pjoin(path, s['frame_name']), out) pbar.update(1)
def edgify_picture(self, input_picture: pathlib.Path, output_picture: pathlib.Path): print(input_picture.resolve()) print(output_picture.resolve()) cv2.dnn_registerLayer('Crop', CropLayer) frame = cv2.imread(str(input_picture.resolve())) # Get width and height height, width, ch = frame.shape inp = cv2.dnn.blobFromImage(frame, scalefactor=1.0, size=(width, height), mean=(104.00698793, 116.66876762, 122.67891434), swapRB=False, crop=False) self.net.setInput(inp) out = self.net.forward() out = out[0, 0] out = cv2.resize(out, (frame.shape[1], frame.shape[0])) out = 255 * out out = out.astype(np.uint8) out = cv2.cvtColor(out, cv2.COLOR_GRAY2BGR) cv2.imwrite(str(output_picture.resolve()), out)
def holisticallyNestedEdgeDetection(img, noiseImg, register=False): img = cv.cvtColor(img, cv.COLOR_GRAY2RGB) if register: # ! [Register] cv.dnn_registerLayer('Crop', CropLayer) # ! [Register] # Load the model. net = cv.dnn.readNetFromCaffe( "C:/Users/rebeb/Documents/TU_Wien/Dipl/project/caffe/deploy.prototxt", "C:/Users/rebeb/Documents/TU_Wien/Dipl/project/caffe/hed_pretrained_bsds.caffemodel" ) height, width, _ = img.shape inp = cv.dnn.blobFromImage(img, scalefactor=1.0, size=(width, height), mean=(104.00698793, 116.66876762, 122.67891434), swapRB=False, crop=False) net.setInput(inp) out = net.forward() out = out[0, 0] out = cv.resize(out, (img.shape[1], img.shape[0])) out = out * noiseImg return out
def holistically_nested_edge_image(img, image_path=True): ''' use the hlistically nested edge to detect the edges img: file name or image itself (read by the imread) image_path = True => img is the path = False => already the image, datasets ''' args = { 'image': img, 'edge_detector': './holistically-nested-edge-detection/hed_model' } roots = './holistically-nested-edge-detection/hed_model' protoPath = os.path.join(args['edge_detector'], 'deploy.prototxt') modelPath = os.path.join(args['edge_detector'], 'hed_pretrained_bsds.caffemodel') net = cv2.dnn.readNetFromCaffe(protoPath, modelPath) # register our new layer with the model cv2.dnn_registerLayer('Crop', CropLayer) # load the input image and grab its dimensions if image_path: image = cv2.imread(args['image']) else: image = args['image'] (H, W) = image.shape[:2] # convert the image to grayscale, blur it, and perform Canny edge detection gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # blurred = cv2.GaussianBlur(gray, (5, 5), 0) blurred = cv2.GaussianBlur(gray, (5, 5), 0) # canny = cv2.Canny(blurred, 30, 150) canny = cv2.Canny(gray, 20, 30) # to show the paper edge, stop to do the blur # construct a blob out of the input image for the Holistically-Nested Edge Detector blob = cv2.dnn.blobFromImage(image, scalefactor=1.0, size=(W, H), mean=(104.00698793, 116.66876762, 122.67891434), swapRB=True, crop=True) # set the blob as the input to the network and perform a forward pass to compute the edges net.setInput(blob) hed = net.forward() hed = cv2.resize(hed[0, 0], (W, H)) hed = (255 * hed).astype('uint8') # show the output edge detection results for Canny and Holistically-Nested Edge Detection cv2.imshow('Input', image) cv2.imshow('Canny', canny) cv2.imshow('HED', hed) cv2.waitKey(0)
def remove_background_hed(img_rgb, debug): """ https://www.pyimagesearch.com/2019/03/04/holistically-nested-edge-detection-with-opencv-and-deep-learning/ """ # load our serialized edge detector from disk print("[INFO] loading edge detector...") proto_path = os.path.sep.join(["hed_model", "deploy.prototxt"]) model_path = os.path.sep.join( ["hed_model", "hed_pretrained_bsds.caffemodel"]) net = cv2.dnn.readNetFromCaffe(proto_path, model_path) # register our new layer with the model cv2.dnn_registerLayer("Crop", CropLayer) # load the input image and grab its dimensions (H, W) = img_rgb.shape[:2] # construct a blob out of the input image for the Holistically-Nested # Edge Detector blob = cv2.dnn.blobFromImage(img_rgb, scalefactor=1.0, size=(W, H), mean=(104.00698793, 116.66876762, 122.67891434), swapRB=False, crop=False) # set the blob as the input to the network and perform a forward pass # to compute the edges logger.info("performing holistically-nested edge detection...") net.setInput(blob) hed = net.forward() hed = cv2.resize(hed[0, 0], (W, H)) hed = (255 * hed).astype("uint8") # Sharpen the hed mask hed[hed < 40] = 0 contours, hierarchy = cv2.findContours(image=hed, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE) mask_shape = np.zeros(img_rgb.shape[:2], dtype="uint8") cv2.drawContours(image=mask_shape, contours=contours, contourIdx=-1, color=255, thickness=cv2.FILLED) filtered_img = cv2.bitwise_and(img_rgb, img_rgb, mask=mask_shape) if debug: cv2.imshow("HED", hed) cv2.imshow("Bkgrd Mask", filtered_img) cv2.waitKey(0) return mask_shape
def __init__(self, args): self._args = args if not self._args.use_canny: cv2.dnn_registerLayer('Crop', CropLayer) # Load caffe model self._net = cv2.dnn.readNetFromCaffe(self._args.model_def, self._args.pretrained_model) self._get_img_paths()
def __init__(self, edge_detector_path): # load our serialized edge detector from disk print("[INFO] loading edge detector...") protoPath = os.path.sep.join([edge_detector_path, "deploy.prototxt"]) modelPath = os.path.sep.join( [edge_detector_path, "hed_pretrained_bsds.caffemodel"]) self.net = cv2.dnn.readNetFromCaffe(protoPath, modelPath) # register our new layer with the model cv2.dnn_registerLayer("Crop", CropLayer)
def __init__(self, width=500, height=500, prototxt="deploy.prototxt", caffemodel="hed_pretrained_bsds.caffemodel"): self.prototxt = prototxt self.caffemodel = caffemodel self.height = height self.width = width self.net = cv.dnn.readNet(self.prototxt, self.caffemodel) cv.dnn_registerLayer('Crop', CropLayer)
def holistic_edge(self, name="holistic.png"): net = cv2.dnn.readNetFromCaffe(self.holistic_proto_path, self.holistic_model_path) cv2.dnn_registerLayer("Crop", self.CropLayer) (H, W) = self.image.shape[:2] blob = cv2.dnn.blobFromImage(self.image, scalefactor=1.0, size=(W, H), mean=(104.00698793, 116.66876762, 122.67891434), swapRB=False, crop=False) net.setInput(blob) hed = net.forward() hed = cv2.resize(hed[0, 0], (W, H)) hed = (255 * hed).astype("uint8") cv2.imwrite(name, hed)
def hed_edges(image): import cv2 as cv # based on https://github.com/opencv/opencv/blob/master/samples/dnn/edge_detection.py class CropLayer(object): def __init__(self, params, blobs): self.xstart = 0 self.xend = 0 self.ystart = 0 self.yend = 0 # Our layer receives two inputs. We need to crop the first input blob # to match a shape of the second one (keeping batch size and number of channels) def getMemoryShapes(self, inputs): inputShape, targetShape = inputs[0], inputs[1] batchSize, numChannels = inputShape[0], inputShape[1] height, width = targetShape[2], targetShape[3] self.ystart = int((inputShape[2] - targetShape[2]) / 2) self.xstart = int((inputShape[3] - targetShape[3]) / 2) self.yend = self.ystart + height self.xend = self.xstart + width return [[batchSize, numChannels, height, width]] def forward(self, inputs): return [ inputs[0][:, :, self.ystart:self.yend, self.xstart:self.xend] ] # Load the pretrained model (source: https://github.com/s9xie/hed) script_path = Path(__file__).parent.absolute() hed_path = Path.joinpath(script_path, 'HED') net = cv.dnn.readNetFromCaffe( str(hed_path / 'deploy.prototxt'), str(hed_path / 'hed_pretrained_bsds.caffemodel')) cv.dnn_registerLayer('Crop', CropLayer) image = cv.resize(image, (image.shape[1], image.shape[0])) # prepare image as input dataset (mean values from full image dataset) inp = cv.dnn.blobFromImage( image, scalefactor=1.0, size=(image.shape[1], image.shape[0]), #w,h mean=(104.00698793, 116.66876762, 122.67891434), swapRB=False, crop=False) net.setInput(inp) out = net.forward() cv.dnn_unregisterLayer('Crop') # get rid of issues when run in a loop out = out[0, 0] return out
def holistically_nested(image): p_i("Starting Holistically-Nested Edge Detection...") net = cv2.dnn.readNetFromCaffe( "data/hed_model/deploy.prototxt", "data/hed_model/" + "hed_pretrained_bsds.caffemodel", ) height, width = image.shape[:2] cv2.dnn_registerLayer("Crop", CropLayer) blob = cv2.dnn.blobFromImage(image, size=(width, height)) net.setInput(blob) hed = (255 * cv2.resize(net.forward()[0, 0], (width, height))).astype("uint8") p_i("Holistically-Nested Edge Detection complete!") cv2.dnn_unregisterLayer("Crop") return hed
def __init__(self, image_): # initializing hed model proto_path = os.path.sep.join(['hed_model', "deploy.prototxt"]) model_path = os.path.sep.join( ['hed_model', "hed_pretrained_bsds.caffemodel"]) self.net = cv2.dnn.readNetFromCaffe(proto_path, model_path) # uploading HED # register our new layer with the model cv2.dnn_registerLayer("Crop", CropLayer) # instances of cv2 and PIL images self.image, self.out_pil = image_, image_ # image sizes self.H, self.W = None, None
def edRun(imInput): # load our serialized edge detector from disk print("[INFO] loading edge detector...") protoPath = os.path.sep.join(["hed_model/", "deploy.prototxt"]) modelPath = os.path.sep.join( ["hed_model/", "hed_pretrained_bsds.caffemodel"]) net = cv2.dnn.readNetFromCaffe(protoPath, modelPath) # register our new layer with the model cv2.dnn_registerLayer("Crop", CropLayer) # load the input image and grab its dimensions image = cv2.imread(imInput) #from GUI (H, W) = image.shape[:2] # construct a blob out of the input image for the Holistically-Nested # Edge Detector #blob = cv2.dnn.blobFromImage(image, scalefactor=1.0, size=(W, H), # mean=(104.00698793, 116.66876762, 122.67891434), # swapRB=False, crop=False) blob = cv2.dnn.blobFromImage(image, scalefactor=1.0, size=(W, H), mean=(104.00698793, 116.66876762, 122.67891434), swapRB=False, crop=False) # set the blob as the input to the network and perform a forward pass # to compute the edges print("[INFO] performing holistically-nested edge detection...") net.setInput(blob) hed = net.forward() hed = cv2.resize(hed[0, 0], (W, H)) hed = (255 * hed).astype("uint8") print(hed.shape) new_hed = Image.fromarray(hed) new_hed.save("hed_result.jpg") ''' #for test only cv2.imshow('input', image) cv2.imshow('output', hed) cv2.waitKey(0) ''' return new_hed
def find_hed(image): class CropLayer(): def __init__(self, params, blobs): self.xstart = 0 self.xend = 0 self.ystart = 0 self.yend = 0 def getMemoryShapes(self, inputs): input_shape, target_shape = inputs[0], inputs[1] batch_size, num_channels = input_shape[0], input_shape[1] height, width = target_shape[2], target_shape[3] self.ystart = (input_shape[2] - target_shape[2]) // 2 self.xstart = (input_shape[3] - target_shape[3]) // 2 self.yend = self.ystart + height self.xend = self.xstart + width return [[batch_size, num_channels, height, width]] def forward(self, inputs): return [ inputs[0][:, :, self.ystart:self.yend, self.xstart:self.xend] ] Height, Width = image.shape[:2] cv2.dnn_registerLayer('Crop', CropLayer) net = cv2.dnn.readNet(hed_prototext_path, hed_model_path) blob = cv2.dnn.blobFromImage(image, scalefactor=1.0, size=(Width, Height), mean=(104.00698793, 116.66876762, 122.67891434), swapRB=False, crop=False) net.setInput(blob) hed = net.forward() hed = cv2.resize(hed[0, 0], (Width, Height)) hed = (255 * hed).astype("uint8") return hed
def get_model(model_root_path=os.path.expanduser(pjoin('~', '.models'))): if not os.path.exists(model_root_path): os.makedirs(model_root_path) model_weights_path = os.path.expanduser( pjoin(model_root_path, model_weights_file)) model_arch_path = os.path.expanduser( pjoin(model_root_path, model_arch_file)) if (not os.path.exists(model_weights_path)): print('Downloading HED model weights to {}'.format(model_weights_path)) urllib.request.urlretrieve(model_weights_url, model_weights_path) if (not os.path.exists(model_arch_path)): print('Downloading HED model prototype to {}'.format(model_arch_path)) urllib.request.urlretrieve(model_arch_url, model_arch_path) model = cv.dnn.readNet(model_arch_path, model_weights_path) cv.dnn_registerLayer('Crop', CropLayer) return model
def init_edge_network(self): protoPathEdgeNet = "models/edge/deploy.prototxt" modelPathEdgeNet = "models/edge/hed_pretrained_bsds.caffemodel" self.edgeNet = cv.dnn.readNet(protoPathEdgeNet, modelPathEdgeNet) if self.cpu_type == 1: self.edgeNet.setPreferableTarget(cv2.dnn.DNN_TARGET_MYRIAD) if self.cpu_type == 2: self.edgeNet.setPreferableTarget(cv2.dnn.DNN_TARGET_OPENCL) cv.dnn_registerLayer('Crop', CropLayer) self.pb.pack(expand=True, fill=tki.BOTH, padx=[200, 0]) self.pb.start() text = "Show me what you got :D" self.top_label_text.set(text) img = ImageTk.PhotoImage(Image.open("ui/images/poseestima.png")) self.panel_pass.configure(image=img) self.panel_pass.image = img self.active_menu = 8
def hedConvert(image): protoPath = os.path.sep.join(["hed_model", "deploy.prototxt"]) modelPath = os.path.sep.join( ["hed_model", "hed_pretrained_bsds.caffemodel"]) net = cv2.dnn.readNetFromCaffe(protoPath, modelPath) cv2.dnn_registerLayer("Crop", CropLayer) (H, W) = image.shape[:2] blob = cv2.dnn.blobFromImage(image, scalefactor=1.0, size=(W, H), mean=(104.00698793, 116.66876762, 122.67891434), swapRB=False, crop=False) net.setInput(blob) hed = net.forward() hed = cv2.resize(hed[0, 0], (W, H)) hed = (255 * hed).astype("uint8") cv2.dnn_unregisterLayer("Crop") return hed
batchSize, numChannels = inputShape[0], inputShape[1] height, width = targetShape[2], targetShape[3] self.ystart = (inputShape[2] - targetShape[2]) / 2 self.xstart = (inputShape[3] - targetShape[3]) / 2 self.yend = self.ystart + height self.xend = self.xstart + width return [[batchSize, numChannels, height, width]] def forward(self, inputs): return [inputs[0][:,:,self.ystart:self.yend,self.xstart:self.xend]] #! [CropLayer] #! [Register] cv.dnn_registerLayer('Crop', CropLayer) #! [Register] # Load the model. net = cv.dnn.readNet(cv.samples.findFile(args.prototxt), cv.samples.findFile(args.caffemodel)) kWinName = 'Holistically-Nested Edge Detection' cv.namedWindow('Input', cv.WINDOW_NORMAL) cv.namedWindow(kWinName, cv.WINDOW_NORMAL) cap = cv.VideoCapture(args.input if args.input else 0) while cv.waitKey(1) < 0: hasFrame, frame = cap.read() if not hasFrame: cv.waitKey() break
ap.add_argument("-s", "--start", type=int, required=True, help="start index for images") ap.add_argument("-e", "--end", type=int, required=True, help="end index") ap.add_argument("-p", "--display", type=int, required=True, help="end index") args = vars(ap.parse_args()) # Create Network Connections based off trained model protoPath = os.path.sep.join([args["edge_detector"], "deploy.prototxt"]) modelPath = os.path.sep.join([args["edge_detector"], "hed_pretrained_bsds.caffemodel"]) net = cv2.dnn.readNetFromCaffe(protoPath, modelPath) # register our new layer with the model holding our desired image size cv2.dnn_registerLayer("Crop", HEDmodel.HEDmodel) path = args["path"] + '/*.png' listOfGT = ['images/GT'] # avg_set = [[], [], []] # listOfPaths = ['images/00', 'images/01', 'images/02', 'images/03', 'images/04', 'images/05', 'images/06', 'images/07', 'images/08', 'images/09', 'images/10', 'images/11', 'images/12', 'images/13', 'images/14', 'images/15', 'images/16', 'images/17', 'images/18'] listOfPaths = ['images/Test'] for pathPart in listOfPaths: path = pathPart + '/*.png' verticalStitch = [] start = args["start"] end = args["end"] shouldShow = args["display"] diff = end - start
def __init__(self, name): self.name = name self.net = cv2.dnn_registerLayer('Crop',DNNPreprocessingImgage.CropLayer) self.net = cv2.dnn.readNet(os.path.join("./module",'deploy.prototxt'),os.path.join("./module",'./hed_pretrained_bsds.caffemodel'))
def holistically_nested_edge_video(video_path): ''' use the hlistically nested edge to detect the edges img: file name or image itself (read by the imread) image_path = True => img is the path = False => already the image, datasets ''' args = { 'input': video_path, 'edge_detector': './holistically-nested-edge-detection/hed_model' } roots = './holistically-nested-edge-detection/hed_model' protoPath = os.path.join(args['edge_detector'], 'deploy.prototxt') modelPath = os.path.join(args['edge_detector'], 'hed_pretrained_bsds.caffemodel') # get the video # vs = cv2.VideoCapture(args['input']) fvs = FileVideoStream(args['input']).start() # time.sleep(1.0) fps = FPS().start() net = cv2.dnn.readNetFromCaffe(protoPath, modelPath) # register our new layer with the model cv2.dnn_registerLayer('Crop', CropLayer) # loop over frames from the video streams # while True: while fvs.more(): # grab the next frame and handle if we are reading from either videocapture or video stream # frame = vs.read()[1] frame = fvs.read() # # for the vs part # if frame is None: # break frame = imutils.resize(frame, width=500) (H, W) = frame.shape[:2] # convert the image to grayscale, blur it, and perform Canny edge detection gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # blurred = cv2.GaussianBlur(gray, (5, 5), 0) blurred = cv2.GaussianBlur(gray, (5, 5), 0) # canny = cv2.Canny(blurred, 30, 150) canny = cv2.Canny(gray, 30, 150) # to show the paper edge, stop to do the blur # construct a blob out of the input image for the Holistically-Nested Edge Detector blob = cv2.dnn.blobFromImage(frame, scalefactor=1.0, size=(W, H), mean=(104.00698793, 116.66876762, 122.67891434), swapRB=False, crop=False) # set the blob as the input to the network and perform a forward pass to compute the edges net.setInput(blob) hed = net.forward() hed = cv2.resize(hed[0, 0], (W, H)) hed = (255 * hed).astype('uint8') # show the output edge detection results for Canny and Holistically-Nested Edge Detection cv2.imshow('Frame', frame) cv2.imshow('Canny', canny) cv2.imshow('HED', hed) key = cv2.waitKey(1) & 0xFF fps.update() if key == ord('q'): break fps.stop() # vs.release() cv2.destroyAllWindows() fvs.stop()
def __init__(self): self.net = cv.dnn.readNetFromCaffe( os.path.join("hed", "deploy.prototxt"), os.path.join("hed", "hed_pretrained_bsds.caffemodel")) cv.dnn_registerLayer('Crop', CropLayer)
def HED(input=('ImagePin', 0), img=(REF, ('ImagePin', 0)), _canny=(REF, ('ImagePin', 0))): """Holistically-Nested Edge Detection""" image = input.image class CropLayer(object): def __init__(self, params, blobs): # initialize our starting and ending (x, y)-coordinates of # the crop self.startX = 0 self.startY = 0 self.endX = 0 self.endY = 0 def getMemoryShapes(self, inputs): # the crop layer will receive two inputs -- we need to crop # the first input blob to match the shape of the second one, # keeping the batch size and number of channels (inputShape, targetShape) = (inputs[0], inputs[1]) (batchSize, numChannels) = (inputShape[0], inputShape[1]) (H, W) = (targetShape[2], targetShape[3]) # compute the starting and ending crop coordinates self.startX = int((inputShape[3] - targetShape[3]) / 2) self.startY = int((inputShape[2] - targetShape[2]) / 2) self.endX = self.startX + W self.endY = self.startY + H # return the shape of the volume (we'll perform the actual # crop during the forward pass return [[batchSize, numChannels, H, W]] def forward(self, inputs): # use the derived (x, y)-coordinates to perform the crop return [ inputs[0][:, :, self.startY:self.endY, self.startX:self.endX] ] (H, W) = image.shape[:2] # convert the image to grayscale, blur it, and perform Canny edge detection gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (5, 5), 0) canny = cv2.Canny(blurred, 30, 150) blob = cv2.dnn.blobFromImage(image, scalefactor=1.0, size=(W, H), mean=(104.00698793, 116.66876762, 122.67891434), swapRB=False, crop=False) # set the blob as the input to the network and perform a forward pass to compute the edges protoPath = os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "res", "deploy.prototxt") modelPath = os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "res", "hed_pretrained_bsds.caffemodel") net = cv2.dnn.readNetFromCaffe(protoPath, modelPath) # register our new layer with the model cv2.dnn_registerLayer("Crop", CropLayer) net.setInput(blob) hed = net.forward() hed = cv2.resize(hed[0, 0], (W, H)) hed = (255 * hed).astype("uint8") _canny(canny) img(hed)
# load our serialized edge detector from disk print("[INFO] loading edge detector...") fpath = os.path.abspath(__file__) fdir = os.path.dirname(fpath) print(fdir) protoPath = os.path.sep.join([fdir, "hed_model", "deploy.prototxt"]) print(protoPath) modelPath = os.path.sep.join( [fdir, "hed_model", "hed_pretrained_bsds.caffemodel"]) print(modelPath) net = cv2.dnn.readNetFromCaffe(protoPath, modelPath) # register our new layer with the model cv2.dnn_registerLayer("Crop", CropLayer) # load the input image and grab its dimensions source_img = cv2.imread(path) # -==================================== # cv2.imshow("source_img", source_img) # while cv2.waitKey(1) != 13: pass # cv2.destroyAllWindows() # -==================================== (H, W) = source_img.shape[:2] # image = source_img # image = source_img[y:y+h, x:x+w] imgOut = np.copy(source_img[:, :, 0])
onnx_name = "./yolo-fastest-xl.onnx" model = onnx.load(onnx_name) #检查IR是否良好 onnx.checker.check_model(model) # 添加 ExpLayer class ExpLayer(object): def __init__(self, params, blobs): super(ExpLayer, self).__init__() def getMemoryShapes(self, inputs): return inputs def forward(self, inputs): return [np.exp(inputs[0])] cv2.dnn_registerLayer('Exp', ExpLayer) # opencv dnn加载 import numpy as np net = cv2.dnn.readNetFromONNX(onnx_name) img = inputs.numpy() img = img[0] img = img.transpose((1,2,0)) img = img.astype('uint8') blob = cv2.dnn.blobFromImage(img, size=(320, 320)) # img 必须是uint8 net.setInput(blob) out = net.forward("out0") print(out) # 检查opencv加载onnx以后的结果和原来的结果是否相同 outputs = outputs[0].detach().numpy()
x = [i for i in range(edges.shape[0]) if np.count_nonzero(edges[i] == True, axis = 0)>0] # for i in range(0,edges.shape[0]): # if (edges[i].any() == True): # x.append(i) y = [i for i in range(edges.shape[1]) if np.count_nonzero(edges[:,i] == True, axis = 0)>0] # for i in range(0,edges.transpose().shape[0]): # if (edges.transpose()[i].any() == True): # y.append(i) if ((len(x)>0) and (len(y)>0)): image = image[min(x):max(x),min(y):max(y)] return image# , min(x),max(x),min(y),max(y) cv2.dnn_registerLayer('Crop', CropLayer) # Load the model. net = cv2.dnn.readNet(args.prototxt, args.caffemodel) # load the input image and grab its dimensions image = cv2.imread(args.input) # image =cv2.equalizeHist(img) # image = cv2.pyrMeanShiftFiltering(image1,10,20) ## Create a display window kWinName = 'Holistically-Nested_Edge_Detection' cv2.namedWindow(kWinName, cv2.WINDOW_AUTOSIZE) inp = cv2.dnn.blobFromImage(image, scalefactor=1.0, size=(args.width, args.height),
out_h = inp_w * ratio start = int(center_h - out_h // 2) end = int(center_h + out_h // 2) person_img = person_img[start:end, ...] else: center_w = inp_w // 2 out_w = inp_h / ratio start = int(center_w - out_w // 2) end = int(center_w + out_w // 2) person_img = person_img[:, start:end, :] cloth_img = cv.imread(args.input_cloth) pose = get_pose_map(person_img, findFile(args.openpose_proto), findFile(args.openpose_model), args.backend, args.target) segm_image = parse_human(person_img, args.segmentation_model) segm_image = cv.resize(segm_image, (192, 256), cv.INTER_LINEAR) cv.dnn_registerLayer('Correlation', CorrelationLayer) model = CpVton(args.gmm_model, args.tom_model, args.backend, args.target) agnostic = model.prepare_agnostic(segm_image, person_img, pose) warped_cloth = model.get_warped_cloth(cloth_img, agnostic) output = model.get_tryon(agnostic, warped_cloth) cv.dnn_unregisterLayer('Correlation') winName = 'Virtual Try-On' cv.namedWindow(winName, cv.WINDOW_AUTOSIZE) cv.imshow(winName, output) cv.waitKey()
def test_custom_layer(self): class CropLayer(object): def __init__(self, params, blobs): self.xstart = 0 self.xend = 0 self.ystart = 0 self.yend = 0 # Our layer receives two inputs. We need to crop the first input blob # to match a shape of the second one (keeping batch size and number of channels) def getMemoryShapes(self, inputs): inputShape, targetShape = inputs[0], inputs[1] batchSize, numChannels = inputShape[0], inputShape[1] height, width = targetShape[2], targetShape[3] self.ystart = (inputShape[2] - targetShape[2]) // 2 self.xstart = (inputShape[3] - targetShape[3]) // 2 self.yend = self.ystart + height self.xend = self.xstart + width return [[batchSize, numChannels, height, width]] def forward(self, inputs): return [ inputs[0][:, :, self.ystart:self.yend, self.xstart:self.xend] ] cv.dnn_registerLayer('CropCaffe', CropLayer) proto = ''' name: "TestCrop" input: "input" input_shape { dim: 1 dim: 2 dim: 5 dim: 5 } input: "roi" input_shape { dim: 1 dim: 2 dim: 3 dim: 3 } layer { name: "Crop" type: "CropCaffe" bottom: "input" bottom: "roi" top: "Crop" }''' net = cv.dnn.readNetFromCaffe(bytearray(proto.encode())) for backend, target in self.dnnBackendsAndTargets: if backend != cv.dnn.DNN_BACKEND_OPENCV: continue printParams(backend, target) net.setPreferableBackend(backend) net.setPreferableTarget(target) src_shape = [1, 2, 5, 5] dst_shape = [1, 2, 3, 3] inp = np.arange(0, np.prod(src_shape), dtype=np.float32).reshape(src_shape) roi = np.empty(dst_shape, dtype=np.float32) net.setInput(inp, "input") net.setInput(roi, "roi") out = net.forward() ref = inp[:, :, 1:4, 1:4] normAssert(self, out, ref) cv.dnn_unregisterLayer('CropCaffe')
def load_dnn(prototxt, caffemodel): cv2.dnn_registerLayer('Crop', CropLayer) # Load the model. return cv2.dnn.readNet(prototxt, caffemodel)