Esempio n. 1
1
class ALPR(ContextEngineBase):

    # Trained classifier
    alpr = None;

    # Top n highest confidence predictions
    n = 5

    def __init__(self, complexity, numInputs, outputClassifier, inputClassifiers, appFieldsDict):
        ContextEngineBase.__init__(self,complexity, numInputs, outputClassifier, inputClassifiers, appFieldsDict)
        self.alpr = Alpr("us", "/etc/openalpr/openalpr.conf", "/home/pi/openalpr/runtime_data")
        if not self.alpr.is_loaded():
            print("Error loading OpenALPR")
            sys.exit(1)
        self.alpr.set_top_n(self.n)
        self.alpr.set_default_region("va")

    #  Execute the trained classifier against the given test sample
    #  inputObsVector is a path to the video file
    def execute(self, inputObsVector):
        if(len(inputObsVector) == self.numInputs):
            y_Test = self.predict(inputObsVector);
            return y_Test;
        else:
            print("Wrong dimensions, fail to execute");
            return None;

    #  Grabs frames and returns top n predictions per frame.
    def predict(self, x_Test):
        cap = cv2.VideoCapture(x_Test[0])
        if not cap.isOpened():
            print("vid open error")
            cap.open()
        fps = 25
        timedelta = 0
        detectCounter = [0]
        detectCounter[0] = 0
        plates_list = np.empty([0, self.n])
        while(cap.isOpened()):
            ret, frame = cap.read()
            if (detectCounter[0] < fps*timedelta):
                detectCounter[0] += 1
                continue
            detectCounter[0] = 0
            if ret:
                pretime = time.time()
                ret, enc = cv2.imencode("*.bmp", frame)
                results = self.alpr.recognize_array(bytes(bytearray(enc)))
                posttime = time.time()
                plates = np.empty([1,self.n], dtype='a5')
                for s in range(0, self.n):
                    plates[0][s] = ""
                for plate in results['results']:
                    i = 0
                    for candidate in plate['candidates']:
                        platenum = candidate['plate'].encode('ascii','ignore')
                        plates[0][i] = platenum
                        i += 1
                timedelta = posttime - pretime # in seconds
                plates_list = np.vstack((plates_list, plates))
            else:
                break
        return plates_list;
Esempio n. 2
0
class AlprPredict:
    def __init__(self, task_queue, result_queue):
        self.alpr = Alpr('eu',
                         '/usr/share/openalpr/config/openalpr.defaults.conf',
                         '/usr/share/openalpr/runtime_data')
        self.alpr.set_top_n(1)
        self.alpr.set_default_region('lt')

        self.task_queue = task_queue
        self.result_queue = result_queue

        self.run()

    def run(self):
        while True:
            self.predict()

    def predict(self):
        image = self.task_queue.get()

        result = None
        try:
            recog_results = self.alpr.recognize_array(image)['results']

            if len(recog_results) != 0:
                result = recog_results[0]['plate']
        except Exception as e:
            logging.error(e)
            result['status'] = 0

        self.result_queue.put(result)
def get_license_plates(image_array):
    """
    This function takes an image array and uses the APLR software to scan for license plates
    """
    alpr = Alpr('us', '/etc/openalpr/openalpr.conf',
                '/usr/share/openalpr/runtime_data')
    results = alpr.recognize_array(image_array)
    redis_dict = {}
    plates = []
    try:
        for i in range(len(results["results"])):
            tmp_dict = {}
            tmp_dict.update({"plate": results["results"][i]["plate"]})
            tmp_dict.update(
                {"confidence": results["results"][i]["confidence"]})
            plates.append(tmp_dict)
    except:
        print("License plate not found")

    redis_dict.update({"plates": plates})
    coordinates = getLatLon(image_array)
    redis_dict.update({
        "latitude": coordinates[0],
        "longitude": coordinates[1]
    })

    return redis_dict
Esempio n. 4
0
def coordRetrv(conf, runtime, image_location):
    # configure ALPR setting according to config file
    alpr = Alpr("us", conf, runtime)

    # Tests if ALPR is able to open
    if not alpr.is_loaded():
        print("Error loading OpenALPR")
        sys.exit(1)

    # Gets the top result from ALPR for each plate
    alpr.set_top_n(1)
    alpr.set_default_region("tx")

    # Loads results from the openALPR library
    # jpeg_bytes = open(image_location, "rb").read()
    # img_bytes = image_location.tobytes()
    success, img_numpy = cv2.imencode('.jpg', image_location)
    img_binary = img_numpy.tostring()
    results = alpr.recognize_array(img_binary)

    result = results['results']

    # print(result)
    # Prints the number of license plates
    # print(len(result))

    # TODO: Figure out why this isnt working(maybe needs to be called at end of main
    # alpr.unload()

    # return list of all license plates in picture according to ALPR
    return result
def openALPR():  #reading the picture
    print('STARTED: ALPR')
    try:
        global database
        alpr = None
        alpr = Alpr('gb', '/etc/openalpr/openalpr.conf',
                    '/home/pi/openalpr/runtime_data')
        if not alpr.is_loaded():
            print("Error loading OpenALPR")
            return False
        else:
            database = []
            alpr.set_top_n(7)
            alpr.set_default_region("gb")
            alpr.set_detect_region(False)
            jpeg_bytes = open('Plates/Plate.jpg', "rb").read()  #testing
            results = alpr.recognize_array(jpeg_bytes)
            i = 0
            for plate in results['results']:
                i += 1
                for candidate in plate['candidates']:
                    plate = [candidate['plate'], candidate['confidence']]
                    database.append(plate)
            if database == []:
                remove(filepath)
                print('FINISHED: ALPR unsucessful')
                return False
            else:
                print(database)
                print('FINISHED: ALPR sucessful')
                return True
    except AttributeError:
        print()
Esempio n. 6
0
    def faceDetection(self, frame):
        global value
        global percentage
        alpr = Alpr("pak", "path/config/openalpr.conf",
                    "path/openalpr/runtime_data")

        frame = cv2.resize(frame, (740, 480))

        faces = plateCascade.detectMultiScale(frame,
                                              scaleFactor=1.1,
                                              minNeighbors=5,
                                              minSize=(30, 30))
        self.allfaces = faces
        for (x, y, w, h) in faces:
            cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 4)
            cv2.putText(frame,
                        str(value) + "-" + str(percentage) + "%",
                        (x - 10, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 1,
                        (0, 0, 255), 2)

        if not alpr.is_loaded():
            print("Error loading OpenALPR")
        else:
            print("Using OpenALPR " + alpr.get_version())

            alpr.set_top_n(7)
            alpr.set_default_region("wa")
            alpr.set_detect_region(False)

            cv2.imwrite("1.png", frame)
            jpeg_bytes = open("1.png", "rb").read()

            results = alpr.recognize_array(jpeg_bytes)

            print("Image size: %dx%d" %
                  (results['img_width'], results['img_height']))
            print("Processing Time: %f" % results['processing_time_ms'])
            #print(str(results['results'][0][0]['candidates']['plate']))
            i = 0
            count = 0
            for plate in results['results']:
                i = 1
                print("Plate #%d" % i)
                print("   %12s %12s" % ("Plate", "Confidence"))
                for candidate in plate['candidates']:
                    prefix = "-"
                    if candidate['matches_template']:
                        prefix = "*"
                    if count >= 1:
                        break
                    print(
                        "  %s %12s%12f" %
                        (prefix, candidate['plate'], candidate['confidence']))
                    value = candidate['plate']
                    percentage = candidate['confidence']
                    count = count + 1

        self.bbFrame = frame
Esempio n. 7
0
 def test_postimg(self):
     alpr = Alpr("eu", "conf/openalpr.conf", "runtime_data")
     imageFileName = "samples_test/eu-3.jpg"
     jpeg_bytes = open(imageFileName, "rb").read()
     results = alpr.recognize_array(jpeg_bytes)
     post = insight.postimg(imageFileName, "1231231231231231231",
                            str(results['results']),
                            "http://localhost:8080", "admin", "admin")
     open(imageFileName, "rb").close()
     self.assertTrue(post)
Esempio n. 8
0
def start_capture_plates(rtsp):
    cap = cv2.VideoCapture(rtsp)
    global lastPlate

    alpr = Alpr("mx", "openalpr.conf", "runtime_data")
    if not alpr.is_loaded():
        print("Error al Cargar Librería: OpenALPR")

    alpr.set_top_n(20)
    alpr.set_default_region("mx")

    if alpr.is_loaded():
        while cap.isOpened():
            ret, img = cap.read()
            img_str = cv2.imencode('.jpg', img)[1].tostring()
            # cv2.imshow('img', img)

            results = alpr.recognize_array(img_str)
            print(results)

            for plate in results['results']:
                len_plate = len(plate['plate'])
                if len_plate == 7:
                    cv2.putText(img, plate['plate'],
                                (plate['coordinates'][0]['x'],
                                 plate['coordinates'][0]['y']), 0, 2,
                                (255, 0, 0), 3)
                    cv2.rectangle(img, (plate['coordinates'][0]['x'],
                                        plate['coordinates'][0]['y']),
                                  (plate['coordinates'][2]['x'],
                                   plate['coordinates'][2]['y']), (255, 0, 0),
                                  3)
                    cv2.imshow('img', img)
                    report_plate = black_list(plate['plate'])
                    if report_plate.status == 200:
                        access_tagger(plate['plate'])
                        lastPlate = plate['plate']
                        response_json = {
                            'message': 'Acceso Permitido',
                            'payload': {
                                'plate': lastPlate,
                                'description': 'Lorem Ipsum Dolor'
                            }
                        }
                        alpr.unload()
                        cv2.destroyAllWindows()
                        return jsonify(response_json)
                    else:
                        alpr.unload()
                        cv2.destroyAllWindows()
                        response_json = report_plate
                        return response_json
Esempio n. 9
0
def main():
    try:
        print("Starting...")
        alpr = Alpr(country, config, runtime_data)
        
        if not alpr.is_loaded():
            print("Error loading OpenALPR")
        else:
            print("Using OpenALPR " + alpr.get_version())

            alpr.set_top_n(1)
            alpr.set_detect_region(False)

            # initialize the video stream and allow the cammera sensor to warmup
            video_source = (0 if options["videosource"] == None else options["videosource"])
            vs = VideoStream(usePiCamera=options["picamera"] > 0, src=video_source).start()
            time.sleep(2.0)
            _frame_number = 0
            print("Running...")

            # loop over the frames from the video stream
            while True:
                frame = vs.read()
                #frame = imutils.resize(frame)
                #frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

                _frame_number += 1
                if _frame_number % FRAME_SKIP == 0:
                    frame_array = (cv2.imencode(".jpg", frame)[1]).tostring()
                    results = alpr.recognize_array(frame_array)
                    if len(results["results"]) > 0:
                        pool.apply_async(_validate, args=[frame_array, results, device, iot, storage])
                                
                if options["imshow"]:
                    # show the frame
                    cv2.imshow("Frame", frame)
                
                key = cv2.waitKey(1) & 0xFF
                # if the `q` key was pressed, break from the loop
                if key == ord("q"):
                    break

    except:
        print("[main] Unexpected error:", sys.exc_info())

    finally:
        if alpr:
            alpr.unload()
    
        pool.close()
        cv2.destroyAllWindows()
        vs.stop()
Esempio n. 10
0
def plater(image_paths) -> bool:
    alpr = None
    found_count = 0     
    image_dir = "./images/"
    try:
        alpr = Alpr("us", "./baller.alpr.config", "/usr/share/openalpr/runtime_data")

        if not alpr.is_loaded():
            print("Error loading OpenALPR")
        else:
            print("Using OpenALPR " + alpr.get_version())

            alpr.set_top_n(5)
            alpr.set_default_region("tx")
            alpr.set_detect_region(True)


            for entry in image_paths:  
                jpeg_bytes = open(os.path.join(image_dir, entry), "rb").read()
                results = alpr.recognize_array(jpeg_bytes)

                # print ("kakakak \n\n\n")
                # print (results['results'])
                # for plate in results['results']:
                #     i += 1
                #     print("Plate #%d" % i)
                #     print("   %12s %12s" % ("Plate", "Confidence"))
                #     for candidate in plate['candidates']:
                #         prefix = "-"
                #         if candidate['matches_template']:
                #             prefix = "*"

                #         print("  %s %12s%12f" % (prefix, candidate['plate'], candidate['confidence']))
                
                if len(results['results']) > 0:
                    found_count += 1

        return found_count > 0

    finally:
        if alpr:
            alpr.unload()
Esempio n. 11
0
def start_capture_plates_blacklist(data):
    cap = cv2.VideoCapture(data['rtsp'])
    global lastPlate

    alpr = Alpr("mx", "openalpr.conf", "runtime_data")
    if not alpr.is_loaded():
        print("Error al Cargar Librería: OpenALPR")

    alpr.set_top_n(20)
    alpr.set_default_region("mx")

    if alpr.is_loaded():
        while cap.isOpened():
            ret, img = cap.read()
            img_str = cv2.imencode('.jpg', img)[1].tostring()
            # cv2.imshow('img', img)

            results = alpr.recognize_array(img_str)
            # print(results)

            for plate in results['results']:
                len_plate = len(plate['plate'])
                if len_plate == 7:
                    cv2.putText(img, plate['plate'],
                                (plate['coordinates'][0]['x'],
                                 plate['coordinates'][0]['y']), 0, 2,
                                (255, 0, 0), 3)
                    cv2.rectangle(img, (plate['coordinates'][0]['x'],
                                        plate['coordinates'][0]['y']),
                                  (plate['coordinates'][2]['x'],
                                   plate['coordinates'][2]['y']), (255, 0, 0),
                                  3)
                    # cv2.imshow('img', img)
                    response_json = black_list_insert(data, plate['plate'])
                    print(response_json)
                    lastPlate = plate['plate']
                    alpr.unload()
                    cv2.destroyAllWindows()
                    return response_json
Esempio n. 12
0
def recognize(image):
    alpr = Alpr("eu", "/etc/openalpr/openalpr.conf",
                "/usr/share/openalpr/runtime_data")

    #if not alpr.is_loaded():
    #print("Error loading OpenALPR")
    #else:
    #print("Using OpenALPR " + alpr.get_version())

    #alpr.set_top_n(7)
    #alpr.set_default_region("eu")
    #alpr.set_detect_region(False)

    jpeg_bytes = image.tobytes()
    results = alpr.recognize_array(jpeg_bytes)

    if len(results["results"]) > 0:
        recognition_results = RecognitionResult(results)
        return True, recognition_results

    else:
        return False, None
Esempio n. 13
0
def alpr():
    start_time = time.time();
    try:
        print 'recieved image, processing...'

        alpr = Alpr("us", "/etc/openalpr/openalpr.conf", "/usr/share/openalpr/runtime_data")
        alpr.set_top_n(20)

        mid1_time = time.time();

        if 'image' not in request.files:
            print "image was not in files"
            return 'Image parameter not provided'

        jpeg_bytes = request.files['image'].read()

        if len(jpeg_bytes) <= 0:
            print "there are no bytes!"
            return False

        mid2_time = time.time();

        results = alpr.recognize_array(jpeg_bytes)

        print "got results!"

        end_time = time.time();

        print("total_time: " + str(end_time-start_time));
        print("alpr_time: " + str(mid1_time-start_time));
        print("jpeg_time: " + str(mid2_time-mid1_time));
        print("processing_time: " + str(end_time-mid2_time));

        return jsonify(results)
    except Exception, e:
        print e
        raise e
def handle_requests(socket):
    # Load SSD model
    ssd_model = load_SSD_model()

    # Load trained tensorflow car classifier and set tensorflow configs
    tf_config = K.tf.ConfigProto()
    tf_config.gpu_options.per_process_gpu_memory_fraction = CarConfig.crcl[
        "classifier_gpu_memory_frac"]
    K.set_session(K.tf.Session(config=tf_config))

    init = K.tf.global_variables_initializer()
    sess = K.get_session()
    sess.run(init)

    use_plate_recognition = CarConfig.crcl["enable_plate_recognition"]
    if use_plate_recognition:
        print("Plate recognition is on, loading OpenALPR..")
        # Load configs and Alpr() once
        country = PlateConfig.recognition['country']
        region = PlateConfig.recognition['region']
        openalpr_conf_dir = PlateConfig.recognition['openalpr_conf_dir']
        openalpr_runtime_data_dir = PlateConfig.recognition[
            'openalpr_runtime_data_dir']
        top_n = PlateConfig.recognition['top_n']

        # Compile regex that matches with invalid TR plates
        tr_plate_regex = PlateConfig.recognition["tr_plate_regex"]
        plate_pattern = re.compile(tr_plate_regex)

        alpr = Alpr(country, openalpr_conf_dir, openalpr_runtime_data_dir)
        if not alpr.is_loaded():
            print("Error loading OpenALPR")
            return

        alpr.set_top_n(top_n)
        alpr.set_default_region(region)

    # Load model once
    car_classifier_model, car_classifier_loaded_model_json = load_model_and_json(
    )
    print('Loaded both models successfully, ready to roll.')
    print('Server is started on:', tcp_address)

    while True:
        try:
            request = socket.recv()
            image = zmq_comm.decode_request(request)

            found_objects = []
            with isess.as_default():
                found_objects = extract_objects(ssd_model, image)

            clasifications = []
            with sess.as_default():
                # Filter cars, buses and trucks, classify each of them
                for o in found_objects:
                    # Crop image according to empirical margin values
                    cropped = crop_image(image, o['topleft'], o['bottomright'],
                                         float(o['confidence']))
                    if cropped is None:
                        continue

                    # Save a copy for plate recognition
                    original_cropped_img = cropped

                    # cv2.imwrite('/home/taylan/Desktop/res/' + str(uuid.uuid4()) + '.jpg', cropped)
                    # Preprocess the image
                    cropped = cropped * 1. / 255
                    cropped = cv2.resize(cropped, (299, 299))
                    cropped = cropped.reshape((1, ) + cropped.shape)
                    # Feed image to classifier
                    preds = car_classifier_model.predict(cropped)[0]

                    predict_list = classifyIndices(
                        car_classifier_loaded_model_json, preds,
                        CarConfig.crcl["n"])

                    predictions = []
                    tags = ["model", "score"]
                    for index, p in enumerate(predict_list):
                        predictions.append(
                            dict(zip(tags, [p.name, str(p.score)])))

                    # If we are very sure about the found car's model, try to find its plate as well
                    found_plate = ""
                    if use_plate_recognition and float(
                            predictions[0]["score"]) > 0.75:
                        results = alpr.recognize_array(
                            bytes(
                                cv2.imencode('.jpg', original_cropped_img)[1]))
                        # print("Results: ", results)

                        filtered_candidates = []
                        for i, plate in enumerate(results['results']):
                            for candidate in plate['candidates']:
                                # print(candidate['plate'])
                                # If our regex does matches with a plate, then it is a good candidate
                                #WARNING: Since our regex expects spaces and openalpr does not put
                                #any spaces in found plate string, it never matches
                                if plate_pattern.search(candidate['plate']):
                                    filtered_candidates.append(
                                        candidate['plate'])
                            # WARNING: It is assumed that there is only a single plate in the given image
                            # Hence, we break after the first plate, even if there are more plates
                            break

                        # print(filtered_candidates)
                        if len(filtered_candidates) > 0:
                            found_plate = filtered_candidates[0]

                    cl = {
                        'label': o['label'],
                        'confidence': o['confidence'],
                        'topleft': o['topleft'],
                        'bottomright': o['bottomright'],
                        'predictions': predictions,
                        'plate': found_plate
                    }
                    clasifications.append(cl)

            result_dict = {}
            result_dict["result"] = clasifications
            result_dict["message"] = "OK"
            # print(result_dict)
            socket.send_json(result_dict)
        except Exception as e:
            result_dict = {}
            result_dict["result"] = []
            result_dict["message"] = str(e)
            socket.send_json(result_dict)
Esempio n. 15
0
        format_ = "P5"
    else:
        return

    return "%s %d %d 255 " % (format_, width, height) + im2.tostring()


if __name__ == "__main__":
    if v.isOpened():
        rval, frame = v.read()
    else:
        rval = False
    while rval:
        # recognize
        if n % skip == 0:
            result = a.recognize_array(convert2pnm(frame))
            for r in result['results']:
                pprint(r['plate'])
                # If the plate is registered, allow acces and take a snapshoot
                if r['plate'] == 'AB123CD':
                    print('Authorized')
                    cv2.imwrite('plate.png', frame)
                    time.sleep(5)
                    cv2.imshow(r['plate'], frame)

        # resize
        factor = frame.shape[1] / float(width)
        height = int(frame.shape[0]/factor)
        resized = cv2.resize(frame, (width, height))
        # show resized frame
        cv2.imshow("video", resized)
Esempio n. 16
0
    video_writer = cv2.VideoWriter('tailgate2_video.avi',fourcc,5,(600,500))
    widthArray = [1 for k in range(4)]
    heightArray = [1 for h in range(4)]
    j = 0
    count = 0
    while count < 5:
        count = count + 1
        
        stream = io.BytesIO();
        with picamera.PiCamera() as camera:
            camera.resolution = (600,500);
            camera.capture(stream, format ='bmp')
        
        buff = numpy.fromstring(stream.getvalue(),dtype = numpy.uint8)
        image = cv2.imdecode(buff,1)
        results = alpr.recognize_array(bytes(bytearray(buff)))
        
        if count == 1:
            video_writer.write(image)
            cv2.imshow('Video', image)

        for plate in results['results']:
            cv2.putText(frame, "Plate#: " + plate['plate'], (0,22), cv2.FONT_HERSHEY_SIMPLEX, 1,(255,255,0), 2)
            cv2.putText(frame, "Tailgating!!!", (0,100), cv2.FONT_HERSHEY_SIMPLEX, 1,(0,0,255), 2)
            coordinatesFile = open('tailgate.log', 'a')
            coordinatesFile.write('Driver tailgate '),
            coordinatesFile.write('%s\n' % (datetime.datetime.now()))
            coordinatesFile.close()
                        
        for coordinates in results['results']:
            for x in coordinates['coordinates']:
Esempio n. 17
0
from openalpr import Alpr

alpr = Alpr("us", "/etc/openalpr/openalpr.conf",
            "/usr/share/openalpr/runtime_data")
print(alpr.is_loaded())

results = alpr.recognize_file("/home/ubuntu/ea7the.jpg")
print(results)

with open("/home/ubuntu/ea7the.jpg", 'rb') as im_file:
    im_bytes = im_file.read()
    results = alpr.recognize_array(im_bytes)
    print(results)
Esempio n. 18
0
def main():
    alpr = Alpr('gb', '/srv/openalpr/openalpr.conf', '/srv/openalpr/runtime_data')
    if not alpr.is_loaded():
        print('Error loading OpenALPR')
        sys.exit(1)
    alpr.set_top_n(3)
    #alpr.set_default_region('new')

    cap = open_cam_rtsp(RTSP_SOURCE)
    if not cap.isOpened():
        alpr.unload()
        sys.exit('Failed to open video file!')
    #cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_AUTOSIZE)
    #cv2.setWindowTitle(WINDOW_NAME, 'OpenALPR video test')

    _frame_number = 0
    #declare a stamp 10 minutes ago, initialise variable when script starts
    STAMP = datetime.datetime.now() - datetime.timedelta(minutes=10)
    while True:
        ret_val, frame = cap.read()
        if not ret_val:
            print(datetime.datetime.now())
            print('VidepCapture.read() failed. Exiting...')
            break

        _frame_number += 1
        if _frame_number % FRAME_SKIP != 0:
            continue
        #cv2.imshow(WINDOW_NAME, frame)
        ret, enc = cv2.imencode("*.jpg", frame)
        results = alpr.recognize_array(enc.tobytes())

        #results = alpr.recognize_ndarray(frame)
        for i, plate in enumerate(results['results']):
            best_candidate = plate['candidates'][0]
            print(datetime.datetime.now() + ' Plate #{}: {:7s} ({:.2f}%)'.format(i, best_candidate['plate'].upper(), best_candidate['confidence']))
            
            #Does the plate match known plates
            if best_candidate['plate'].upper() in PLATES:

                #Has the gate fired recently? If not in the last 10 minutes then allow to fire again
                if datetime.datetime.now() > STAMP:
                    print("Recognised")
                    #If a plate is recongised set a timestamp to prevent it firing lots of times until time has expired
                    print(datetime.datetime.now())

                    #Open the gate
                    response = requests.post(
                        HA_ENDPOINT,
                        headers={'Content-Type': 'application/json', 'x-ha-access': '' + HA_APIPASS + '' },
                        data='{"entity_id": "script.ANPR"}',
                    )
                    STAMP = STAMP = datetime.datetime.now() + datetime.timedelta(minutes=3)
                else:
                    print("Not firing as time has not exceeded")

        if cv2.waitKey(1) == 27:
            break

    cv2.destroyAllWindows()
    cap.release()
    alpr.unload()
Esempio n. 19
0
options = parser.parse_args()

alpr = None
try:
    alpr = Alpr(options.country, options.config, options.runtime_data)

    if not alpr.is_loaded():
        print("Error loading OpenALPR")
    else:
        print("Using OpenALPR " + alpr.get_version())

        alpr.set_top_n(7)
        alpr.set_default_region("wa")
        alpr.set_detect_region(False)
        jpeg_bytes = open(options.plate_image, "rb").read()
        results = alpr.recognize_array(jpeg_bytes)

        # Uncomment to see the full results structure
        # import pprint
        # pprint.pprint(results)

        print("Image size: %dx%d" %(results['img_width'], results['img_height']))
        print("Processing Time: %f" % results['processing_time_ms'])

        i = 0
        for plate in results['results']:
            i += 1
            print("Plate #%d" % i)
            print("   %12s %12s" % ("Plate", "Confidence"))
            for candidate in plate['candidates']:
                prefix = "-"
Esempio n. 20
0
alpr.set_top_n(20)
alpr.set_default_region("md")

cap = cv2.VideoCapture(
    "rtsp://*****:*****@192.168.1.109:554/cam/realmonitor?channel=1&subtype=0"
)
ret, frame = cap.read()
ret, enc = cv2.imencode("*.bmp", frame)
while (True):

    ret, frame = cap.read()
    cv2.imshow('frame', frame)
    # cv.waitKey(1)
    # gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
    results = alpr.recognize_array(bytes(bytearray(enc)))
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# results = alpr.recognize_ndarray(gray)

    print results['results']
    i = 0
    for plate in results['results']:
        i += 1
        print "Plate #%d" % i
        print "   %12s %12s" % ("Plate", "Confidence")
        for candidate in plate['candidates']:
            prefix = "-"
            if candidate['matches_template']:
                prefix = "*"
Esempio n. 21
0
class Alpr_detection(object):
    def __init__(self,
                 alpr_dir,
                 country=None,
                 config_file=None,
                 runtime_dir=None):
        config_path = alpr_dir + "/openalpr.conf"
        runtime_path = alpr_dir + "/runtime_data"
        country_code = "eu"

        if config_file is not None:
            config_path = config_file
        if runtime_dir is not None:
            runtime_path = runtime_dir
        if country is not None:
            country_code = country

        environ["PATH"] = alpr_dir + ";" + environ["PATH"]
        self.__alpr = Alpr(country_code, config_path, runtime_path)

    def is_loaded(self):
        return self.__alpr.is_loaded()

    # configuration&alpr
    # def alpr_dir(self, alpr_dir):
    #     environ["PATH"] = alpr_dir + ";" + environ["PATH"]
    #     alpr = Alpr("eu", alpr_dir + "/openalpr.conf", alpr_dir + "/runtime_data")

    # plate frame
    # def alpr_detection(self):
    #     video = cv2.VideoCapture(0)  # catch video
    #     best_score = []
    #     k = 0
    #     while True:
    #         # catch video
    #         flag, frame = video.read()
    #         cv2.imshow('Clear_frame', frame)
    #         cv2.waitKey(2)
    #         if not flag:
    #             print('Video read failed.')
    #         # results = alpr.recognize_ndarray(frame)
    #         flag, enc = cv2.imencode("*.jpg", frame)  # ndarray issue
    #         #   results = alpr.recognize_array(bytes(bytearray(enc)))  # ndarray issue
    #         results = self.__alpr.recognize_array(enc.tobytes())

    def detection_photo(self, filePath):
        jpeg_bytes = open(filePath, "rb").read()
        return self.__alpr.recognize_array(jpeg_bytes)

    def detection_video(self, video, showCapFrame):
        # video = cv2.VideoCapture(0)  # catch video
        # catch video
        flag, frame = video.read()
        # width, height, c = frame.shape
        # frame = frame[450:width, 0:height]
        if showCapFrame is True:
            if frame is None:
                return
            cv2.imshow('Clear_frame', frame)
            cv2.waitKey(1)
        if not flag:
            print('Video read failed.')
            return None
        # results = alpr.recognize_ndarray(frame)

        flag, enc = cv2.imencode("*.jpg", frame)  # ndarray issue
        #   results = alpr.recognize_array(bytes(bytearray(enc)))  # ndarray issue
        results = self.__alpr.recognize_array(enc.tobytes())
        return results, frame
        # print results

        # return results, frame
        # print(results['results'])

    # def
    # hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)  # converting BGR to HSV

    #  lower_red = np.array([30, 150, 50])  # define range of red color in HSV
    #  upper_red = np.array([255, 255, 180])

    # mask = cv2.inRange(hsv, lower_red, upper_red)  # create a red HSV colour boundary and threshold HSV image

    #  res = cv2.bitwise_and(frame, frame, mask=mask)  # Bitwise-AND mask and original image

    # cv2.imshow('Original', frame)  # Display an original image

    #  edges = cv2.Canny(frame, 100, 200)  # finds edges in the input image image and marks them in the output map edges

    # cv2.imshow('Original', edges)  # output edges

    # crop_frame = frame[0:480, 320:640]
    # cv2.imshow("Crop_frame", crop_frame)

    # crop_frame = frame[0:500, 0:640*2]
    # cv2.imshow("Crop_frame", crop_frame)
    def crop_frame(self, results, frame):

        if len(results['results']) == 0:
            z = 0  # result
        #  print('No plate detected')
        else:
            y, y1 = json.dumps(
                results["results"][0]["coordinates"][0]["y"]), json.dumps(
                    results["results"][0]["coordinates"][3]["y"])
            x, x1 = json.dumps(
                results["results"][0]["coordinates"][0]["x"]), json.dumps(
                    results["results"][0]["coordinates"][1]["x"])

            crop_frame = frame[int(y):int(y1), int(x):int(x1)]
            cv2.rectangle(frame, (int(x) - 10, int(y) - 10),
                          (int(x1), int(y1)), (0, 255, 0), 3)
            # cv2.imshow("suka", crop_frame)
            # cv2.waitKey(2)
            return crop_frame

        # crop_frame_canny = cv2.Canny(crop_frame, 100, 200)
        # contours, hierarchy = cv2.findContours(crop_frame_canny, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

        # for cnt in contours:
        #     rect = cv2.minAreaRect(cnt)
        #     box = cv2.boxPoints(rect)
        #     box = np.int0(box)
        #     area = int(rect[1][0] * rect[1][1])
        #     if area > 500:
        #         cv2.drawContours(frame, [box], 0, (0, 255, 0), 3)
        # crop_frame = frame[int(x):int(x1), int(y):int(y1)]

    def print_results(self, frame, crop_frame, results):
        #  cv2.imshow("Crop_frame", frame)
        #  cv2.waitKey(2)
        if crop_frame is None:
            return

        # cv2.imshow("True frame", crop_frame)
        # cv2.waitKey(2)
        # cv2.imshow("Crop_frame", frame)
        # cv2.waitKey(2)
        for i, plate in enumerate(results['results']):
            best_candidate = plate['candidates'][0]
            if best_candidate['confidence'] > 85:
                #  for b in enumerate[best_score[b]]:
                best_score = best_candidate['confidence']
                # k += 1
                # if k == 2:
                #    print("plate: " + str(best_candidate['plate'].upper()))
                #    exit()

                print(best_candidate['confidence'])
                print("plate: " + str(best_candidate['plate'].upper()))
Esempio n. 22
0
class AlprDetector:
    def __init__(self,
                 name,
                 config,
                 video_source,
                 event_callback=None,
                 save_images=False):
        self.__name = name
        self.__alpr_instance = Alpr(config.region, config.config_file,
                                    config.runtime_data_file)
        if not self.__alpr_instance.is_loaded():
            print('Alpr instance could not be created')
        self.__frame_skip = config.frame_skip
        self.event_callback = event_callback
        self.__video_source = video_source
        self.__cap = cv2.VideoCapture(video_source)
        self.__running = False
        self.__save_image = save_images
        import os
        self.__directory = os.getcwd()

    def is_working(self):
        return self.__cap.isOpened() and self.__running

    def video_source_properties(self):
        data = dict()
        data['source'] = self.__video_source
        data['fps'] = self.__cap.get(cv2.CAP_PROP_FPS)
        data['width'] = self.__cap.get(cv2.CAP_PROP_FRAME_WIDTH)
        data['height'] = self.__cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
        data['codec'] = self.__cap.get(cv2.CAP_PROP_FOURCC)
        return

    @staticmethod
    def __extract_results(alpr_result):
        if alpr_result is None:
            return None
        if not alpr_result['results']:
            return None
        else:
            result = []
            for plate in alpr_result['results']:
                for candidate in plate['candidates']:
                    result.append(
                        [candidate['plate'], candidate['confidence']])
            return result

    @staticmethod
    def __extract_best_candidate(alpr_result):
        return alpr_result['results'][0]['plate'] if alpr_result[
            'results'] else None

    def __handle_results(self, extracted_results):
        if self.event_callback is not None:
            callback_data = dict()
            # object is list of dict containing 'plate' and 'confidence'
            callback_data['candidates'] = extracted_results
            callback_data['detector'] = self.__name
            print('calling callback , ', extracted_results)
            self.event_callback(callback_data)

    def run(self):
        if self.__running:
            print(self.__name, ' Detector is already running')
            return False
        else:
            self.__running = True

        if not self.is_working():
            print(self.__name, ' Video capture not working.')
            self.__running = False
            return False

        frame_number = 0
        last_recognized_plate = None
        error_state = False
        try:
            print(self.__name, ' starting detector loop for: ',
                  self.__video_source)
            while self.__running:
                a = datetime.datetime.now()
                last_read_status, frame = self.__cap.read()
                if not last_read_status:
                    print('Video capture.read() failed. Stopping the work')
                    self.__running = False
                    error_state = True
                    break
                frame_number += 1
                if frame_number % self.__frame_skip == 0:
                    frame_number = 0
                    continue
                if cv2.waitKey(1) == 27:
                    break
                # cv2.imshow(self.__name, frame)

                # todo: use recognize_ndarray when updated to at least 2.3.1
                # alpr.recognize_ndarray(frame)
                ret, enc = cv2.imencode("*.bmp", frame)
                results = self.__alpr_instance.recognize_array(
                    bytes(bytearray(enc)))
                best_candidate = self.__extract_best_candidate(results)
                if best_candidate is not None and best_candidate != last_recognized_plate:
                    last_recognized_plate = best_candidate
                    print(best_candidate)
                    # send first recognized plate and all candidates
                    extracted_results = self.__extract_results(results)
                    if extracted_results:
                        self.__handle_results(extracted_results)

                    if self.__save_image:
                        print(self.__directory)
                        import os.path
                        cv2.imwrite(
                            os.path.join(
                                self.__directory, self.__name, ''.join(
                                    (best_candidate, '_', self.__name, '_',
                                     datetime.datetime.now().strftime(
                                         "%Y_%m_%d_%H_%M_%S"), '.jpeg'))),
                            frame)

        except cv2.error as e:
            print("OpenCV Exception caught: ", e)
            error_state = True
        except Exception as e:
            print("Exception caught: ", e)
            error_state = True
        finally:
            self.__alpr_instance.unload()
            self.__running = False
            print(self.__name, " is stopping")
            return not error_state

    def stop(self):
        self.__running = False
def f(data):

    parser = ArgumentParser(description='OpenALPR Python Test Program')

    parser.add_argument("-c", "--country", dest="country", action="store", default="us",
                      help="License plate Country" )

    OpenALPR_path = "C:/Users/Franco/Documents/Github/control-vehicular/Otros/Deteccion/openalpr_32bit/"

    parser.add_argument("--config", dest="config", action="store", default=OpenALPR_path+"openalpr.conf",
                      help="Path to openalpr.conf config file" )

    parser.add_argument("--runtime_data", dest="runtime_data", action="store", default=OpenALPR_path+"runtime_data",
                      help="Path to OpenALPR runtime_data directory" )

    #parser.add_argument('plate_image', help='License plate image file')

    options = parser.parse_args()

    print(options.country, options.config, options.runtime_data)

    alpr = None
    try:
        alpr = Alpr(options.country.encode('ascii'), options.config.encode('ascii'), options.runtime_data.encode('ascii'))

        if not alpr.is_loaded():
            print("Error loading OpenALPR")
        else:
            print("Using OpenALPR " + alpr.get_version().decode('ascii'))

            alpr.set_top_n(7)
            alpr.set_default_region(b"wa")
            alpr.set_detect_region(False)
            # jpeg_bytes = open(options.plate_image, "rb").read()
            # results = alpr.recognize_array(jpeg_bytes)
            jpeg_bytes = data
            results = alpr.recognize_array(bytes(bytearray(data)))
            
            # Uncomment to see the full results structure
            # import pprint
            # pprint.pprint(results)

            print("Image size: %dx%d" %(results['img_width'], results['img_height']))
            print("Processing Time: %f" % results['processing_time_ms'])

            i = 0 
            if results['results']:
                print("%12s%12f" % (results['results'][0]['plate'], results['results'][0]['confidence']))
            for plate in results['results']:
                i += 1
                print("Plate #%d" % i)
                print("   %12s %12s" % ("Plate", "Confidence"))
                for candidate in plate['candidates']:
                    prefix = "-"
                    if candidate['matches_template']:
                        prefix = "*"

                    print("  %s %12s%12f" % (prefix, candidate['plate'], candidate['confidence']))



    finally:
        if alpr:
            alpr.unload()
Esempio n. 24
0
class LprRunner(NDUCameraRunner):
    def __init__(self, config, _connector_type):
        super().__init__()
        self.counter = 0
        self._send_data = config.get("send_data", False)

        city_codes_fn = "/data/city_codes.json"
        if not os.path.isfile(city_codes_fn):
            city_codes_fn = os.path.dirname(
                os.path.abspath(__file__)) + city_codes_fn.replace(
                    "/", os.path.sep)
        with open(city_codes_fn, encoding="UTF-8") as f_in:
            self._cities = json.load(f_in)

        conf_fn = "/data/openalpr_64/openalpr.conf"
        #conf_fn = "//usr/local/share/openalpr/config/openalpr.defaults.conf"
        # conf_fn = "/data/openalpr_64/runtime_data/config/eu.conf"
        if not os.path.isfile(conf_fn):
            conf_fn = os.path.dirname(
                os.path.abspath(__file__)) + conf_fn.replace("/", os.path.sep)

        runtime_data = "/data/openalpr_64/runtime_data/"
        #runtime_data = "/usr/local/share/openalpr/runtime_data/"
        if not os.path.isdir(runtime_data):
            runtime_data = os.path.dirname(
                os.path.abspath(__file__)) + runtime_data.replace(
                    "/", os.path.sep)

        # self._alpr = Alpr("us", "/path/to/openalpr.conf", "/path/to/runtime_data")
        # self._alpr = Alpr("eu", conf_fn, runtime_data)
        self._alpr = Alpr("tr", conf_fn, runtime_data)

        if not self._alpr.is_loaded():
            print("Error loading OpenALPR")

        # self._alpr.set_top_n(20)
        # self._alpr.set_default_region("md")
        # self._alpr.set_top_n(1)
        self._alpr.set_default_region("tr")
        self._alpr.set_country("tr")

        # region lp detection,
        onnx_fn = "/data/yolov4-tiny_lp_416_static.onnx"
        self.input_size = 416

        if not os.path.isfile(onnx_fn):
            onnx_fn = os.path.dirname(
                os.path.abspath(__file__)) + onnx_fn.replace("/", os.path.sep)

        classes_filename = "/data/class.names"
        if not os.path.isfile(classes_filename):
            classes_filename = os.path.dirname(
                os.path.abspath(__file__)) + classes_filename.replace(
                    "/", os.path.sep)
        self.class_names = ["lp"]
        self.sess_tuple = onnx_helper.get_sess_tuple(onnx_fn)
        # endregion

    def get_name(self):
        return "lpr"

    def get_settings(self):
        settings = {}
        return settings

    def process_frame(self, frame, extra_data=None):
        def to_bbox(coordinates, rect_, rh_, rw_):
            x1 = coordinates[0]["x"] * rw_
            y1 = coordinates[0]["y"] * rh_
            x2 = coordinates[2]["x"] * rw_
            y2 = coordinates[2]["y"] * rh_
            if rect_ is not None:
                x1 += rect_[1]
                y1 += rect_[0]
                x2 += rect_[1]
                y2 += rect_[0]
            return [y1, x1, y2, x2]

        def enumerate_images(frame_):
            result = yolo_helper.predict_v4(self.sess_tuple, self.input_size,
                                            self.class_names, frame)
            for _class_name, _score, rect0, item_ in NDUUtility.enumerate_result_items(
                    result, return_item=True):
                rect1 = geometry_helper.add_padding_rect(rect0, 0.5)
                yield image_helper.crop(frame, rect1), rect0, item_

        res = []
        for image, rect, item in enumerate_images(frame):
            h0, w0 = image_helper.image_h_w(image)

            # def order_points(pts):
            #     # initialzie a list of coordinates that will be ordered
            #     # such that the first entry in the list is the top-left,
            #     # the second entry is the top-right, the third is the
            #     # bottom-right, and the fourth is the bottom-left
            #     rect = np.zeros((4, 2), dtype="float32")
            #
            #     # the top-left point will have the smallest sum, whereas
            #     # the bottom-right point will have the largest sum
            #     s = pts.sum(axis=1)
            #     rect[0] = pts[np.argmin(s)]
            #     rect[2] = pts[np.argmax(s)]
            #
            #     # now, compute the difference between the points, the
            #     # top-right point will have the smallest difference,
            #     # whereas the bottom-left will have the largest difference
            #     diff = np.diff(pts, axis=1)
            #     rect[1] = pts[np.argmin(diff)]
            #     rect[3] = pts[np.argmax(diff)]
            #
            #     # return the ordered coordinates
            #     return rect
            #
            # def four_point_transform(image, pts):
            #     # obtain a consistent order of the points and unpack them
            #     # individually
            #     rect = order_points(pts)
            #     (tl, tr, br, bl) = rect
            #
            #     # compute the width of the new image, which will be the
            #     # maximum distance between bottom-right and bottom-left
            #     # x-coordiates or the top-right and top-left x-coordinates
            #     widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))
            #     widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))
            #     maxWidth = max(int(widthA), int(widthB))
            #
            #     # compute the height of the new image, which will be the
            #     # maximum distance between the top-right and bottom-right
            #     # y-coordinates or the top-left and bottom-left y-coordinates
            #     heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))
            #     heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))
            #     maxHeight = max(int(heightA), int(heightB))
            #
            #     # now that we have the dimensions of the new image, construct
            #     # the set of destination points to obtain a "birds eye view",
            #     # (i.e. top-down view) of the image, again specifying points
            #     # in the top-left, top-right, bottom-right, and bottom-left
            #     # order
            #     dst = np.array([
            #         [0, 0],
            #         [maxWidth - 1, 0],
            #         [maxWidth - 1, maxHeight - 1],
            #         [0, maxHeight - 1]], dtype="float32")
            #
            #     # compute the perspective transform matrix and then apply it
            #     M = cv2.getPerspectiveTransform(rect, dst)
            #     warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight))
            #     return warped
            #
            # def deskew(image):
            #     gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
            #     gray = cv2.bitwise_not(gray)
            #     thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
            #     coords = np.column_stack(np.where(thresh > 0))
            #     angle = cv2.minAreaRect(coords)[-1]
            #     if angle < -45:
            #         angle = -(90 + angle)
            #     else:
            #         angle = -angle
            #     (h, w) = image.shape[:2]
            #     center = (w // 2, h // 2)
            #     M = cv2.getRotationMatrix2D(center, angle, 1.0)
            #     return cv2.warpAffine(image, M, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)
            #
            # # def remove_noise_and_smooth(file_name):
            # #     img = cv2.imread(file_name, 0)
            # #     filtered = cv2.adaptiveThreshold(img.astype(np.uint8), 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 9, 41)
            # #     kernel = np.ones((1, 1), np.uint8)
            # #     opening = cv2.morphologyEx(filtered, cv2.MORPH_OPEN, kernel)
            # #     closing = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, kernel)
            # #     img = image_smoothening(img)
            # #     or_image = cv2.bitwise_or(img, closing)
            # #     return or_image
            #
            # # image = deskew(image)
            # # image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

            h1, w1 = image_helper.image_h_w(image)
            while w1 < 400:
                image = cv2.pyrUp(image)
                h1, w1 = image_helper.image_h_w(image)
            # cv2.imshow("lpr", image)
            # cv2.waitKey(500)

            success, encoded_image = cv2.imencode('.jpg', image)
            content2 = encoded_image.tobytes()
            results = self._alpr.recognize_array(content2)

            added = False
            #print("LPR: ", item.get(constants.RESULT_KEY_RECT))
            for plate in results['results']:
                txt = plate["plate"]
                if len(txt) > 2:
                    score = plate["confidence"] / 100.0
                    if score > 0.01:
                        city_code = txt[0:2]
                        city_name = None
                        if city_code in self._cities:
                            city_name = self._cities[city_code]
                        if city_name is None:
                            class_name = "PL: {}".format(txt)
                        else:
                            class_name = "PL: {} {}".format(city_name, txt)

                        val = {
                            constants.RESULT_KEY_RECT: rect,
                            constants.RESULT_KEY_SCORE: score,
                            constants.RESULT_KEY_CLASS_NAME: class_name
                        }

                        if self._send_data:
                            if city_name is None:
                                val[constants.RESULT_KEY_DATA] = {"pl": txt}
                            else:
                                val[constants.RESULT_KEY_DATA] = {
                                    "pl": txt,
                                    "city": city_name
                                }

                        res.append(val)
                        added = True
            if not added:
                val = {
                    constants.RESULT_KEY_RECT: rect,
                    constants.RESULT_KEY_SCORE: 0,
                    constants.RESULT_KEY_CLASS_NAME: "PL: "
                }
                res.append(val)
        return res
Esempio n. 25
0
alpr.set_default_region("md")

capture = cv2.VideoCapture(VIDEO_CAPTURE)
# is_to_send = 0
while (True):
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

    frame = None
    while frame is None:
        et, frame = capture.read()

    print("processing frame")

    ret, image = cv2.imencode('.bmp', frame)
    results = alpr.recognize_array(bytes(bytearray(image)))
    print(results)
    print("done")

    i = 0
    hypotheses = []
    for plate in results['results']:
        i += 1
        print("Plate #%d" % i)
        print("   %12s %12s" % ("Plate", "Confidence"))
        for j, candidate in enumerate(plate['candidates']):
            if j > 3:
                break

            prefix = "-"
            if candidate['matches_template']:
Esempio n. 26
0
class ALPR(ContextEngineBase):

    # Trained classifier
    alpr = None

    # Top n highest confidence predictions
    n = 5

    def __init__(self, complexity, numInputs, outputClassifier,
                 inputClassifiers, appFieldsDict):
        ContextEngineBase.__init__(self, complexity, numInputs,
                                   outputClassifier, inputClassifiers,
                                   appFieldsDict)
        self.alpr = Alpr("us", "/etc/openalpr/openalpr.conf",
                         "/home/pi/openalpr/runtime_data")
        if not self.alpr.is_loaded():
            print("Error loading OpenALPR")
            sys.exit(1)
        self.alpr.set_top_n(self.n)
        self.alpr.set_default_region("va")

    #  Execute the trained classifier against the given test sample
    #  inputObsVector is a path to the video file
    def execute(self, inputObsVector):
        if (len(inputObsVector) == self.numInputs):
            y_Test = self.predict(inputObsVector)
            return y_Test
        else:
            print("Wrong dimensions, fail to execute")
            return None

    #  Grabs frames and returns top n predictions per frame.
    def predict(self, x_Test):
        cap = cv2.VideoCapture(x_Test[0])
        if not cap.isOpened():
            print("vid open error")
            cap.open()
        fps = 25
        timedelta = 0
        detectCounter = [0]
        detectCounter[0] = 0
        plates_list = np.empty([0, self.n])
        while (cap.isOpened()):
            ret, frame = cap.read()
            if (detectCounter[0] < fps * timedelta):
                detectCounter[0] += 1
                continue
            detectCounter[0] = 0
            if ret:
                pretime = time.time()
                ret, enc = cv2.imencode("*.bmp", frame)
                results = self.alpr.recognize_array(bytes(bytearray(enc)))
                posttime = time.time()
                plates = np.empty([1, self.n], dtype='a5')
                for s in range(0, self.n):
                    plates[0][s] = ""
                for plate in results['results']:
                    i = 0
                    for candidate in plate['candidates']:
                        platenum = candidate['plate'].encode('ascii', 'ignore')
                        plates[0][i] = platenum
                        i += 1
                timedelta = posttime - pretime  # in seconds
                plates_list = np.vstack((plates_list, plates))
            else:
                break
        return plates_list
Esempio n. 27
0
    print(address)
    f = open('file.jpg', 'wb')  # open in binary

    l = 1
    while (l):
        l = sc.recv(1024)
        while (l):
            f.write(l)
            l = sc.recv(1024)
        f.close()

    #alpr.set_top_n(20)
    alpr.set_detect_region(True)
    f = open("file.jpg", "rb")
    jpeg_bytes = f.read()
    results = alpr.recognize_array(jpeg_bytes)

    # for plate in results['results']:
    #     for candidate in plate['candidates']:
    #        print(candidate['plate'])
    #     print(plate['candidates'][0]['plate'])

    result = results['results'][0]['candidates'][0]['plate']
    print(result)
    sc.send(result.encode('utf-8'))

    # i = 0
    # for plate in results['results']:
    #     i += 1
    #     print("Plate #%d" % i)
    #     print("   %12s %12s" % ("Plate", "Confidence"))
Esempio n. 28
0
class LicensePlateSearcher:
    def __init__(self, plate, country=DEFAULT_COUNTRY):
        self.plate = plate
        self.alpr = Alpr(country, ALPR_CONFIG_PATH, ALPR_RUNTIME_DATA_PATH)
        self.trashhold = 0.70
        self.photo_maker = Process(target=self.photogapher, )

    @property
    def _current_time(self):
        now = datetime.datetime.now()
        return "{:>02}:{:>02}:{:>02}".format(now.hour, now.minute, now.second)

    @staticmethod
    def _get_patterns_similarity(pattern_a, pattern_b):
        similarity = SequenceMatcher(None, pattern_a, pattern_b).ratio()
        return round(similarity, 2)

    def _get_plates(self):
        with open('image.jpg', 'rb') as image:
            jpg_bytes = image.read()
        alpr_report = self.alpr.recognize_array(jpg_bytes)
        alpr_results = alpr_report['results']
        plates = [result['plate'] for result in alpr_results]
        return plates

    def _get_plates_validity(self, plates):
        for plate in plates:
            similarity = self._get_patterns_similarity(plate, self.plate)
            if similarity >= self.trashhold:
                return plate
        return None

    def _process_photo(self):
        try:
            plates = self._get_plates()
        except IndexError:
            print "No numbers, at {}".format(self._current_time)
        else:
            valid_plate = self._get_plates_validity(plates)
            if valid_plate is None:
                print "No correct numbers, at {}".format(self._current_time)
            else:
                print "{} at {}".format(valid_plate, self._current_time)

    def photogapher(self):
        stream = urllib.urlopen(MJPG_STREAM_URL)
        stream_fragment = ''
        while True:
            stream_fragment += stream.read(8096)
            photo_start_ptr = stream_fragment.find('\xff\xd8')
            photo_end_ptr = stream_fragment.find('\xff\xd9')
            if photo_start_ptr < photo_end_ptr and photo_start_ptr != -1 and photo_end_ptr != -1:
                jpg = stream_fragment[photo_start_ptr:photo_end_ptr + 2]
                stream_fragment = stream_fragment[photo_end_ptr + 2:]
                image = cv2.imdecode(numpy.fromstring(jpg, dtype=numpy.uint8),
                                     cv2.IMREAD_COLOR)
                cv2.imwrite('image.jpg', image)
            elif photo_end_ptr > photo_start_ptr:
                stream_fragment = ''
            else:
                pass

    def run(self):
        run_command(
            'mjpg_streamer -i "input_uvc.so -d /dev/video0 -r 1280x720 -y 1 -n" -o "output_http.so -p 8080 -w /usr/share/mjpg-streamer/www/"'
        )
        time.sleep(1)
        self.photo_maker.start()
        time.sleep(1)
        while True:
            self._process_photo()