def LPDection(carImagePath): wpod_net = load_model(wpod_net_path) print carImagePath Ivehicle = cv2.imread(carImagePath) ratio = float(max(Ivehicle.shape[:2])) / min(Ivehicle.shape[:2]) side = int(ratio * 288.) bound_dim = min(side + (side % (2**4)), 608) Llp, LlpImgs, _ = detect_lp(wpod_net, im2single(Ivehicle), bound_dim, 2**4, (240, 80), lp_threshold) if len(LlpImgs): bname = basename(splitext(carImagePath)[0]) dname = dirname(carImagePath) Ilp = LlpImgs[0] cv2.imwrite('%s/%s_lp_raw.png' % (dname, bname), Ilp * 255.) Ilp = cv2.cvtColor(Ilp, cv2.COLOR_BGR2GRAY) Ilp = cv2.cvtColor(Ilp, cv2.COLOR_GRAY2BGR) s = Shape(Llp[0].pts) LPImagePath = '%s/%s_lp.png' % (dname, bname) cv2.imwrite(LPImagePath, Ilp * 255.) LPTextPath = '%s/%s_lp.txt' % (dname, bname) writeShapes(LPTextPath, [s]) return LPImagePath else: return ""
def __init__(self): self.path_images = "." path_yolo = './' self.output_dir = './tmp/' self.vehicle = Vehicle(path_yolo) self.lp = LP(path_yolo) wpod_net_path = "models/wpod-net_update1.h5" self.wpod_net = load_model(wpod_net_path) self.lp_threshold = .5
def load_network(modelpath,input_dim): model = load_model(modelpath) input_shape = (input_dim,input_dim,3) # Fixed input size for training inputs = keras.layers.Input(shape=(input_dim,input_dim,3)) outputs = model(inputs) output_shape = tuple([s.value for s in outputs.shape[1:]]) output_dim = output_shape[1] model_stride = input_dim / output_dim assert input_dim % output_dim == 0, \ 'The output resolution must be divisible by the input resolution' assert model_stride == 2**4, \ 'Make sure your model generates a feature map with resolution ' \ '16x smaller than the input' return model, model_stride, input_shape, output_shape
def __init__(self, config, det_thresh=0.5, rec_thresh=0.5): ## --- update below versions self.mod_version = "1.2" self.det_version = "1.2" self.rec_version = "1.1" ## ------------------------- if config.det_mod == "": return #self.consolidator = Consolidator() self.utils = Utils() self.det_model = config.det_mod self.rec_model = config.rec_mod self.det_thresh = det_thresh; self.rec_thresh = rec_thresh; self.cons_lp_enabled = config.cons_lp self.roi_det_enabled = config.do_roi_det self.ocr_weights = "" self.ocr_netcfg = "" self.ocr_dataset = "" self.ocr_net = None self.ocr_meta = None self.wpod_net = None self.prev_locs = None if self.det_model != "" and os.path.exists(self.det_model): det_model = [f for f in os.listdir(self.det_model) if ".h5" in f] self.det_model += "/"+det_model[0] print ("INFO:: Loding model: ", self.det_model) self.wpod_net = load_model(self.det_model) self.load_rec_model(self.rec_model) else: print ("\033[93m Warning: Specify detection model by giving \"--det-model <path>\" option.\033[0m")
def __init__(self, wpod_lpd_net_path, modelo_deteccao_veiculos, modelo_deteccao_caracteres, caminho_char_recognition_resnet): self.graph_car_detect = tf.Graph() self.session_car_detection = tf.Session(graph=self.graph_car_detect) self.wpod_net = load_model(wpod_lpd_net_path) self.return_tensors_veichle = utils.read_pb_return_tensors( self.graph_car_detect, modelo_deteccao_veiculos, return_elements) char_dectection_model_pb_file = modelo_deteccao_caracteres + '.pb' char_dectection_model_meta_file = modelo_deteccao_caracteres + '.meta' options_char_detec = { "pbLoad": char_dectection_model_pb_file, "metaLoad": char_dectection_model_meta_file, "gpu": 0.9 } self.yolo_char_seg_model = TFNet(options_char_detec) self.model_char_recog = keras.models.load_model( caminho_char_recognition_resnet) self.color_bbox_car = (255, 0, 0) self.color_text_plate = (0, 255, 0) self.ct = centroidtracker.CentroidTracker()
def load_network(modelpath, input_dim): # input_dim = 208 model = load_model(modelpath) input_shape = (input_dim, input_dim, 3) # Fixed input size for training # Số chiều đầu vào là 208*208 inputs = keras.layers.Input(shape=(input_dim, input_dim, 3)) outputs = model(inputs) output_shape = tuple([s.value for s in outputs.shape[1:]]) output_dim = output_shape[1] model_stride = input_dim / output_dim '''kiểm tra điều kiện, nếu sai > out, kèm exception''' assert input_dim % output_dim == 0, \ 'The output resolution must be divisible by the input resolution' assert model_stride == 2**4, \ 'Make sure your model generates a feature map with resolution ' \ '16x smaller than the input' return model, model_stride, input_shape, output_shape
def exit_gate(): def sample(probs): s = sum(probs) probs = [old_div(a,s) for a in probs] r = random.uniform(0, 1) for i in range(len(probs)): r = r - probs[i] if r <= 0: return i return len(probs)-1 def c_array(ctype, values): arr = (ctype*len(values))() arr[:] = values return arr class BOX(Structure): _fields_ = [("x", c_float), ("y", c_float), ("w", c_float), ("h", c_float)] class DETECTION(Structure): _fields_ = [("bbox", BOX), ("classes", c_int), ("prob", POINTER(c_float)), ("mask", POINTER(c_float)), ("objectness", c_float), ("sort_class", c_int)] class IMAGE(Structure): _fields_ = [("w", c_int), ("h", c_int), ("c", c_int), ("data", POINTER(c_float))] class METADATA(Structure): _fields_ = [("classes", c_int), ("names", POINTER(c_char_p))] class IplROI(Structure): pass class IplTileInfo(Structure): pass class IplImage(Structure): pass IplImage._fields_ = [ ('nSize', c_int), ('ID', c_int), ('nChannels', c_int), ('alphaChannel', c_int), ('depth', c_int), ('colorModel', c_char * 4), ('channelSeq', c_char * 4), ('dataOrder', c_int), ('origin', c_int), ('align', c_int), ('width', c_int), ('height', c_int), ('roi', POINTER(IplROI)), ('maskROI', POINTER(IplImage)), ('imageId', c_void_p), ('tileInfo', POINTER(IplTileInfo)), ('imageSize', c_int), ('imageData', c_char_p), ('widthStep', c_int), ('BorderMode', c_int * 4), ('BorderConst', c_int * 4), ('imageDataOrigin', c_char_p)] class iplimage_t(Structure): _fields_ = [('ob_refcnt', c_ssize_t), ('ob_type', py_object), ('a', POINTER(IplImage)), ('data', py_object), ('offset', c_size_t)] lib = CDLL("./darknet/libdarknet.so", RTLD_GLOBAL) lib.network_width.argtypes = [c_void_p] lib.network_width.restype = c_int lib.network_height.argtypes = [c_void_p] lib.network_height.restype = c_int predict = lib.network_predict predict.argtypes = [c_void_p, POINTER(c_float)] predict.restype = POINTER(c_float) set_gpu = lib.cuda_set_device set_gpu.argtypes = [c_int] make_image = lib.make_image make_image.argtypes = [c_int, c_int, c_int] make_image.restype = IMAGE get_network_boxes = lib.get_network_boxes get_network_boxes.argtypes = [c_void_p, c_int, c_int, c_float, c_float, POINTER(c_int), c_int, POINTER(c_int)] get_network_boxes.restype = POINTER(DETECTION) make_network_boxes = lib.make_network_boxes make_network_boxes.argtypes = [c_void_p] make_network_boxes.restype = POINTER(DETECTION) free_detections = lib.free_detections free_detections.argtypes = [POINTER(DETECTION), c_int] free_ptrs = lib.free_ptrs free_ptrs.argtypes = [POINTER(c_void_p), c_int] network_predict = lib.network_predict network_predict.argtypes = [c_void_p, POINTER(c_float)] reset_rnn = lib.reset_rnn reset_rnn.argtypes = [c_void_p] load_net = lib.load_network load_net.argtypes = [c_char_p, c_char_p, c_int] load_net.restype = c_void_p do_nms_obj = lib.do_nms_obj do_nms_obj.argtypes = [POINTER(DETECTION), c_int, c_int, c_float] do_nms_sort = lib.do_nms_sort do_nms_sort.argtypes = [POINTER(DETECTION), c_int, c_int, c_float] free_image = lib.free_image free_image.argtypes = [IMAGE] letterbox_image = lib.letterbox_image letterbox_image.argtypes = [IMAGE, c_int, c_int] letterbox_image.restype = IMAGE load_meta = lib.get_metadata lib.get_metadata.argtypes = [c_char_p] lib.get_metadata.restype = METADATA load_image = lib.load_image_color load_image.argtypes = [c_char_p, c_int, c_int] load_image.restype = IMAGE rgbgr_image = lib.rgbgr_image rgbgr_image.argtypes = [IMAGE] predict_image = lib.network_predict_image predict_image.argtypes = [c_void_p, IMAGE] predict_image.restype = POINTER(c_float) def classify(net, meta, im): out = predict_image(net, im) res = [] for i in range(meta.classes): res.append((meta.names[i], out[i])) res = sorted(res, key=lambda x: -x[1]) return res def array_to_image(arr): # need to return old values to avoid python freeing memory arr = arr.transpose(2, 0, 1) c, h, w = arr.shape[0:3] arr = np.ascontiguousarray(arr.flat, dtype=np.float32) / 255.0 #print(arr) data = arr.ctypes.data_as(POINTER(c_float)) im = IMAGE(w, h, c, data) return im, arr def detect(net, meta, image,thresh,hier_thresh=.5, nms=.45): im, image = array_to_image(image) rgbgr_image(im) num = c_int(0) pnum = pointer(num) predict_image(net, im) dets = get_network_boxes(net, im.w, im.h, thresh, hier_thresh, None, 0, pnum) num = pnum[0] if nms: do_nms_obj(dets, num, meta.classes, nms) res = [] for j in range(num): a = dets[j].prob[0:meta.classes] if any(a): ai = np.array(a).nonzero()[0] for i in ai: b = dets[j].bbox res.append((meta.names[i], dets[j].prob[i], (b.x, b.y, b.w, b.h))) res = sorted(res, key=lambda x: -x[1]) wh = (im.w, im.h) if isinstance(image, bytes): free_image(im) free_detections(dets, num) return res def cdetect(net, meta, image,thresh=0.3,hier_thresh=.7, nms=.45): im, image = array_to_image(image) rgbgr_image(im) num = c_int(0) pnum = pointer(num) predict_image(net, im) dets = get_network_boxes(net, im.w, im.h, thresh, hier_thresh, None, 0, pnum) num = pnum[0] if nms: do_nms_obj(dets, num, meta.classes, nms) res = [] for j in range(num): a = dets[j].prob[0:meta.classes] if any(a): ai = np.array(a).nonzero()[0] for i in ai: b = dets[j].bbox res.append((meta.names[i], dets[j].prob[i], (b.x, b.y, b.w, b.h))) res = sorted(res, key=lambda x: -x[1]) wh = (im.w, im.h) if isinstance(image, bytes): free_image(im) free_detections(dets, num) return res def adjust_pts(pts, lroi): return pts*lroi.wh().reshape((2, 1)) + lroi.tl().reshape((2, 1)) def text_extract(img_path, height, width): '''gray = cv2.cvtColor(img_path, cv2.COLOR_BGR2GRAY) gray = cv2.threshold( gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1] inv = 255 - gray horizontal_img = inv vertical_img = inv kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (100, 1)) horizontal_img = cv2.erode(horizontal_img, kernel, iterations=1) horizontal_img = cv2.dilate(horizontal_img, kernel, iterations=1) kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 100)) vertical_img = cv2.erode(vertical_img, kernel, iterations=1) vertical_img = cv2.dilate(vertical_img, kernel, iterations=1) mask_img = horizontal_img + vertical_img no_border = np.bitwise_or(gray, mask_img) os.system("convert " + " no.jpg" + " -bordercolor " + " White" + " -border" + " 10x10" + " with_border.jpg") imagez = cv2.imread("with_border.jpg") p1 = (20, 30) p2 = (60, 80) p3 = (60, 15) p4 = (200, 45) (x1, y1) = (20, 30) (x2, y2) = (60, 80) (x3, y3) = (60, 15) (x4, y4) = (200, 45) color = (255, 0, 0) thickness = 2 image1 = cv2.rectangle(imagez, p1, p2, color, thickness) image2 = cv2.rectangle(imagez, p3, p4, color, thickness) roi1 = image1[y1:y2, x1:x2] roi2 = image2[y3:y4, x3:x4]''' ocr_threshold = .4 R = detect( ocr_net, ocr_meta, img_path, thresh=ocr_threshold, nms=None) if len(R): L = dknet_label_conversion(R, width, height) L = nms(L, .45) L.sort(key=lambda x: x.tl()[0]) lp_str1 = ''.join([chr(l.cl()) for l in L]) print("License plate ----",lp_str1) def lp_detector(Ivehicle, wpod_net): lp_threshold = .2 ratio = float(max(Ivehicle.shape[:2]))/min(Ivehicle.shape[:2]) side = int(ratio*288.) bound_dim = min(side + (side%(2**4)), 608) Llp, LlpImgs, _ = detect_lp(wpod_net, im2single( Ivehicle), bound_dim, 2**4, (240, 80), lp_threshold) if len(LlpImgs): Ilp = LlpImgs[0] Ilp = cv2.cvtColor(Ilp, cv2.COLOR_BGR2GRAY) Ilp = cv2.cvtColor(Ilp, cv2.COLOR_GRAY2BGR) cv2.imwrite("lp1.png", Ilp*255.) return len(LlpImgs) def car_detect(Iorig): Lcars=[] R = [] vehicle_threshold = .5 R = detect(vehicle_net, vehicle_meta, Iorig,thresh=vehicle_threshold) R = [r for r in R if r[0] in [b'car','bus']] #print('\t\t%d cars found' % len(R)) if len(R): WH = np.array(Iorig.shape[1::-1],dtype=float) Lcars = [] for i,r in enumerate(R): cx,cy,w,h = (old_div(np.array(r[2]),np.concatenate( (WH,WH) ))).tolist() tl = np.array([cx - w/2., cy - h/2.]) br = np.array([cx + w/2., cy + h/2.]) label = Label(0,tl,br) Icar = crop_region(Iorig,label) cv2.imwrite("crop1.png",Icar) Icar1 = cv2.imread("crop1.png") Lcars.append(label) return Lcars ocr_weights = 'data/exit-ocr/ocr-net.weights' ocr_netcfg = 'data/exit-ocr/ocr-net.cfg' ocr_dataset = 'data/exit-ocr/ocr-net.data' ocr_net = load_net(ocr_netcfg.encode('utf-8'), ocr_weights.encode('utf-8'), 0) ocr_meta = load_meta(ocr_dataset.encode('utf-8')) wpod_net = load_model("data/exit-lp-detector/wpod-net_update1.h5") vehicle_threshold = .5 vehicle_weights = 'data/exit-vehicle-detector/yolov3-tiny.weights' vehicle_netcfg = 'data/exit-vehicle-detector/yolov3-tiny.cfg' vehicle_dataset = 'data/exit-vehicle-detector/coco.data' vehicle_net = load_net(vehicle_netcfg.encode('utf-8'), vehicle_weights.encode('utf-8'), 0) vehicle_meta = load_meta(vehicle_dataset.encode('utf-8')) countd = 1 img = cv2.imread("ar1.jpg") start_veh_det = time.time() lab=car_detect(img) end_veh_det = time.time() veh_det_time = end_veh_det - start_veh_det print("veh-det time(exit) :- ", veh_det_time) if(len(lab)!=0): for i in range(len(lab)): # LP detection start_lp_det = time.time() crop1=cv2.imread("crop1.png") cv2.imshow("Car 1", crop1) lp = lp_detector(crop1, wpod_net) end_lp_det = time.time() end_lp_det = time.time() lp_det_time = end_lp_det - start_lp_det print("lp-det time(exit) :- ",lp_det_time) lp = cv2.imread("lp1.png") cv2.imshow("LP 1", lp) height = lp.shape[0] width = lp.shape[1] # OCR start_ocr = time.time() text = text_extract(lp, height, width) end_ocr = time.time() ocr_time = end_ocr - start_ocr print("ocr time (exit) :- ",ocr_time) cv2.waitKey(10)
if __name__ == '__main__': try: input_file = sys.argv[1] output_file = sys.argv[2] # vehicle detection model vehicle_threshold = .5 vehicle_weights = b'darknetAB/yolov3.weights' vehicle_netcfg = b'darknetAB/cfg/yolov3.cfg' vehicle_dataset = b'darknetAB/cfg/coco.data' vehicle_net = dn.load_net_custom(vehicle_netcfg, vehicle_weights, 0, 1) # batchsize=1 vehicle_meta = dn.load_meta(vehicle_dataset) # license plate detection model wpod_net = load_model('data/lp-detector/wpod-net_update1.h5') # license plate recognition model ocrmodel = LPR("data/ocr-model/ocr_plate_all_gru.h5") # Create an image we reuse for each detect vid = cv2.VideoCapture(input_file) video_width = vid.get(cv2.CAP_PROP_FRAME_WIDTH) video_height = vid.get(cv2.CAP_PROP_FRAME_HEIGHT) video_fps = vid.get(cv2.CAP_PROP_FPS) darknet_image = dn.make_image(int(video_width),int(video_height), 3) fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', 'v') videoWriter = cv2.VideoWriter(output_file, fourcc, int(video_fps), (int(video_width),int(video_height))) print('Searching for vehicles and licenses using YOLO and Keras...') frame = 1
def exit_gate(): def sample(probs): for i in range(len([old_div(a, sum(probs)) for a in probs])): if random.uniform(0, 1) - probs[i] <= 0: return i return len(probs) - 1 def c_array(ctype, values): arr = (ctype * len(values))() arr[:] = values return arr class BOX(Structure): _fields_ = [("x", c_float), ("y", c_float), ("w", c_float), ("h", c_float)] class DETECTION(Structure): _fields_ = [("bbox", BOX), ("classes", c_int), ("prob", POINTER(c_float)), ("mask", POINTER(c_float)), ("objectness", c_float), ("sort_class", c_int)] class IMAGE(Structure): _fields_ = [("w", c_int), ("h", c_int), ("c", c_int), ("data", POINTER(c_float))] class METADATA(Structure): _fields_ = [("classes", c_int), ("names", POINTER(c_char_p))] class IplROI(Structure): pass class IplTileInfo(Structure): pass class IplImage(Structure): pass IplImage._fields_ = [('nSize', c_int), ('ID', c_int), ('nChannels', c_int), ('alphaChannel', c_int), ('depth', c_int), ('colorModel', c_char * 4), ('channelSeq', c_char * 4), ('dataOrder', c_int), ('origin', c_int), ('align', c_int), ('width', c_int), ('height', c_int), ('roi', POINTER(IplROI)), ('maskROI', POINTER(IplImage)), ('imageId', c_void_p), ('tileInfo', POINTER(IplTileInfo)), ('imageSize', c_int), ('imageData', c_char_p), ('widthStep', c_int), ('BorderMode', c_int * 4), ('BorderConst', c_int * 4), ('imageDataOrigin', c_char_p)] class iplimage_t(Structure): _fields_ = [('ob_refcnt', c_ssize_t), ('ob_type', py_object), ('a', POINTER(IplImage)), ('data', py_object), ('offset', c_size_t)] lib = CDLL("./darknet/libdarknet.so", RTLD_GLOBAL) lib.network_width.argtypes = [c_void_p] lib.network_width.restype = c_int lib.network_height.argtypes = [c_void_p] lib.network_height.restype = c_int predict = lib.network_predict predict.argtypes = [c_void_p, POINTER(c_float)] predict.restype = POINTER(c_float) set_gpu = lib.cuda_set_device set_gpu.argtypes = [c_int] make_image = lib.make_image make_image.argtypes = [c_int, c_int, c_int] make_image.restype = IMAGE get_network_boxes = lib.get_network_boxes get_network_boxes.argtypes = [ c_void_p, c_int, c_int, c_float, c_float, POINTER(c_int), c_int, POINTER(c_int) ] get_network_boxes.restype = POINTER(DETECTION) make_network_boxes = lib.make_network_boxes make_network_boxes.argtypes = [c_void_p] make_network_boxes.restype = POINTER(DETECTION) free_detections = lib.free_detections free_detections.argtypes = [POINTER(DETECTION), c_int] free_ptrs = lib.free_ptrs free_ptrs.argtypes = [POINTER(c_void_p), c_int] network_predict = lib.network_predict network_predict.argtypes = [c_void_p, POINTER(c_float)] reset_rnn = lib.reset_rnn reset_rnn.argtypes = [c_void_p] load_net = lib.load_network load_net.argtypes = [c_char_p, c_char_p, c_int] load_net.restype = c_void_p do_nms_obj = lib.do_nms_obj do_nms_obj.argtypes = [POINTER(DETECTION), c_int, c_int, c_float] do_nms_sort = lib.do_nms_sort do_nms_sort.argtypes = [POINTER(DETECTION), c_int, c_int, c_float] free_image = lib.free_image free_image.argtypes = [IMAGE] letterbox_image = lib.letterbox_image letterbox_image.argtypes = [IMAGE, c_int, c_int] letterbox_image.restype = IMAGE load_meta = lib.get_metadata lib.get_metadata.argtypes = [c_char_p] lib.get_metadata.restype = METADATA load_image = lib.load_image_color load_image.argtypes = [c_char_p, c_int, c_int] load_image.restype = IMAGE rgbgr_image = lib.rgbgr_image rgbgr_image.argtypes = [IMAGE] predict_image = lib.network_predict_image predict_image.argtypes = [c_void_p, IMAGE] predict_image.restype = POINTER(c_float) def classify(net, meta, im): out = predict_image(net, im) res = [] for i in range(meta.classes): res.append((meta.names[i], out[i])) return sorted(res, key=lambda x: -x[1]) def array_to_image(arr): # need to return old values to avoid python freeing memory arr = arr.transpose(2, 0, 1) c, h, w = arr.shape[0:3] arr = np.ascontiguousarray(arr.flat, dtype=np.float32) / 255.0 data = arr.ctypes.data_as(POINTER(c_float)) im = IMAGE(w, h, c, data) return im, arr def detect(net, meta, image, thresh, hier_thresh=.5, nms=.45): im, image = array_to_image(image) rgbgr_image(im) pnum = pointer(c_int(0)) predict_image(net, im) dets = get_network_boxes(net, im.w, im.h, thresh, hier_thresh, None, 0, pnum) num = pnum[0] if nms: do_nms_obj(dets, num, meta.classes, nms) res = [] for j in range(num): if any(dets[j].prob[0:meta.classes]): ai = np.array(dets[j].prob[0:meta.classes]).nonzero()[0] for i in ai: b = dets[j].bbox res.append( (meta.names[i], dets[j].prob[i], (b.x, b.y, b.w, b.h))) res = sorted(res, key=lambda x: -x[1]) wh = (im.w, im.h) if isinstance(image, bytes): free_image(im) free_detections(dets, num) return res def adjust_pts(pts, lroi): return pts * lroi.wh().reshape((2, 1)) + lroi.tl().reshape((2, 1)) def text_extract(img_path, height, width): R = detect(ocr_net, ocr_meta, img_path, thresh=0.4, nms=None) if len(R): L = dknet_label_conversion(R, width, height) L = nms(L, .45) L.sort(key=lambda x: x.tl()[0]) lp_str1 = ''.join([chr(l.cl()) for l in L]) print("License plate ----", lp_str1) def lp_detector(Ivehicle, wpod_net): lp_threshold = .2 ratio = float(max(Ivehicle.shape[:2])) / min(Ivehicle.shape[:2]) side = int(ratio * 288.) bound_dim = min(side + (side % (2**4)), 608) Llp, LlpImgs, _ = detect_lp(wpod_net, im2single(Ivehicle), bound_dim, 2**4, (240, 80), lp_threshold) if len(LlpImgs): Ilp = LlpImgs[0] cv2.imwrite("lp1.png", Ilp * 255.) return Ilp * 255 def car_detect(Iorig): Lcars = [] R = [] R = detect(vehicle_net, vehicle_meta, Iorig, thresh=0.5) R = [r for r in R if r[0] in [b'car', 'bus']] if len(R): WH = np.array(Iorig.shape[1::-1], dtype=float) Lcars = [] cars_crop = [] for i, r in enumerate(R): cx, cy, w, h = (old_div(np.array(r[2]), np.concatenate( (WH, WH)))).tolist() tl = np.array([cx - w / 2., cy - h / 2.]) br = np.array([cx + w / 2., cy + h / 2.]) label = Label(0, tl, br) Icar = crop_region(Iorig, label) cv2.imwrite("crop1.png", Icar) Icar1 = cv2.imread("crop1.png") Lcars.append(label) cars_crop.append(Icar1) return Lcars, cars_crop ocr_weights = 'data/exit-ocr/ocr-net.weights' ocr_netcfg = 'data/exit-ocr/ocr-net.cfg' ocr_dataset = 'data/exit-ocr/ocr-net.data' ocr_net = load_net(ocr_netcfg.encode('utf-8'), ocr_weights.encode('utf-8'), 0) ocr_meta = load_meta(ocr_dataset.encode('utf-8')) wpod_net = load_model("data/exit-lp-detector/wpod-net_update1.h5") vehicle_threshold = .5 vehicle_weights = 'data/exit-vehicle-detector/yolov3-tiny.weights' vehicle_netcfg = 'data/exit-vehicle-detector/yolov3-tiny.cfg' vehicle_dataset = 'data/exit-vehicle-detector/coco.data' vehicle_net = load_net(vehicle_netcfg.encode('utf-8'), vehicle_weights.encode('utf-8'), 0) vehicle_meta = load_meta(vehicle_dataset.encode('utf-8')) countd = 1 lab = [] cars = [] img = cv2.imread("ar1.jpg") start_veh_det = time.time() lab, cars = car_detect(img) end_veh_det = time.time() veh_det_time = end_veh_det - start_veh_det print("veh-det time(exit) :- ", veh_det_time) if (len(cars) != 0): for i in range(len(cars)): # LP detection start_lp_det = time.time() cv2.imshow("Car" + str(i), cars[i]) lp = lp_detector(cars[i], wpod_net) end_lp_det = time.time() end_lp_det = time.time() lp_det_time = end_lp_det - start_lp_det print("lp-det time(exit) :- ", lp_det_time) cv2.imshow("LP" + str(i), lp / 255.) height = lp.shape[0] width = lp.shape[1] # OCR start_ocr = time.time() text = text_extract(lp, height, width) end_ocr = time.time() ocr_time = end_ocr - start_ocr print("ocr time (exit) :- ", ocr_time) cv2.waitKey(10)
# Custom code to handle memory allocation problem # config = tf.ConfigProto() # dynamically grow GPU memory # config.gpu_options.allow_growth = True # set_session(tf.Session(config=config)) from src.keras_utils import load_model from gen_outputs import generate_outputs from stdout_capture import Capturing from license_plate_ocr import lp_ocr from license_plate_detection import detect # Necessary for some thread safety stuff, dont really looked into it global graph graph = tf.get_default_graph() WPOD_NET = load_model("./data/lp-detector/wpod-net_update1.h5") app = Flask(__name__) # RUN_SCRIPT_FOLDER = "/alpr-unconstrained" CASE_FOLDER_NAMES = ["0_case", "1_case", "2_case"] MAIN_FOLDER_PATH = "/mnt" # MAIN_FOLDER_PATH = "/home/atoth/temp/generali/prod_test/test" @app.route('/lpr/<session_id>') def run_lpr(session_id): # base_wd = os.getcwd() processed_images_folder = join(MAIN_FOLDER_PATH, session_id, "processed_images")
def __init__(self, lp_model, threshold=0.7): self.wpod_net = load_model(lp_model) self.output_dir = 'output' self.detected_cars_dir = "detected_cars" self.detected_plates_dir = "detected_plates" self.lp_threshold = threshold
def __init__(lp_model): self.wpod_net = load_model(lp_model)
def validate_model(wpod_net_path, validate_dir, output_dir): wpod_net = load_model(wpod_net_path) for layer in wpod_net.layers: print(layer.output_shape) validar_lp_model(validate_dir, output_dir, wpod_net)
def load_lp_net(lp_net_path): return load_model(lp_net_path)
def __init__(self, wpod_net_path="data/lp-detector/wpod-net_update1.h5", lp_threshold=.5): self.wpod_net = load_model(wpod_net_path) self.lp_threshold = lp_threshold
args = parser.parse_args() netname = basename(args.name) train_dir = args.input_dir modelpath = args.model outdir = args.outdir iterations = args.iterations batch_size = args.batch_size dim = 208 if not isdir(outdir): makedirs(outdir) if modelpath: model = load_model(modelpath) else: model = create_model() model_stride = 2**4 model.compile(loss=loss, optimizer='adam') print 'Checking input directory...' Files = image_files_from_folder(train_dir) Data = [] for file in Files: labfile = splitext(file)[0] + '.txt' if isfile(labfile): L = readShapes(labfile)
if __name__ == '__main__': try: # input_dir = sys.argv[1] input_dir = "/home/nam/Desktop/folder/alpr-unconstrained-master/samples/t1" # input_dir = "/home/nam/Desktop/folder/data/car_long" # input_dir = "/home/nam/Desktop/folder/data/GreenParking" output_dir = input_dir lp_threshold = .5 # wpod_net_path = sys.argv[2] # wpod_net_path = "/home/nam/Desktop/folder/alpr-unconstrained-master/data/lp-detector/wpod-net_update1.h5" wpod_net_path = "/home/nam/Desktop/folder/alpr-unconstrained-master/models/eccv-model-scracth.h5" wpod_net = load_model(wpod_net_path) # imgs_paths = glob('%s/*car.png' % input_dir) imgs_paths = input_dir print('Searching for license plates using WPOD-NET') # for i,img_path in enumerate(imgs_paths): for root, dir, file in os.walk(imgs_paths): for img_path in file: print('\t Processing %s' % img_path) img_path = os.path.join(imgs_paths, img_path) bname = splitext(basename(img_path))[0] Ivehicle = cv2.imread(img_path) im = cv2.resize(Ivehicle, (900, 500)) cv2.imshow("asd", im) #cv2.waitKey(0)
unq_ids = ['id' + str(i) for i in range(100)] track_id_list = deque(unq_ids) #track_id_list= deque(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K','L','M','N','O']) avg_fps = 0 debug = False interestedClass = ["car", "truck", "bus", "train"] # Interested classes for yolo #Initialize yolo detector yolo_det = YoloDetector(interestedClass, size=size) #Initialize ReID model reid_model_path = os.path.abspath('ReID_CNN/model_880_base.ckpt') reid_model = ResNet_Loader(reid_model_path, 50, 32) #Intialize License Plate detector lp_model = "data/lp-detector/wpod-net_update1.h5" wpod_net = load_model(lp_model) #License Plate detection threshold lp_threshold = 0.8 # test on a video file. input_file = args.input output_dir = args.output if not os.path.exists(output_dir): os.makedirs(output_dir) input_basename = os.path.basename(input_file) detected_plates_dir = output_dir + '/' + 'license_plates' detected_cars_dir = output_dir + '/' + 'cars' if not os.path.exists(detected_plates_dir): os.makedirs(detected_plates_dir) if not os.path.exists(detected_cars_dir):