Esempio n. 1
0
class image_converter:
    def __init__(self):

        self.bridge = CvBridge()
        self.image_sub = rospy.Subscriber(
            "camera/image_raw", Image, self.callback)
        self.alpr = Alpr("eu", "/etc/openalpr/openalpr.conf",
                         "/usr/local/home/u180107/openalpr/runtime_data")
        self.alpr.set_detect_region(True)
        self.currentConfidence = 0
        self.currentDistance = 0
        criteria = (cv2.TERM_CRITERIA_EPS +
                    cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
        objp = np.float32([
            [0, 0, 0],
            [8, 0, 0],
            [0, 6, 0],
            [8, 6, 0]
            ])
        axis = np.float32([[3, 0, 0], [0, 3, 0], [0, 0, -3]]).reshape(-1, 3)
        with np.load('calibration.npz') as X:
            mtx, dist = [X[i] for i in ('mtx', 'dist')]

    def draw(img, corners, imgpts):
        corner = tuple(corners[0].ravel())
        img = cv2.line(img, corner, tuple(imgpts[0].ravel()), (255, 0, 0), 5)
        img = cv2.line(img, corner, tuple(imgpts[1].ravel()), (0, 255, 0), 5)
        img = cv2.line(img, corner, tuple(imgpts[2].ravel()), (0, 0, 255), 5)
        return img
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. 3
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. 4
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. 5
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. 6
0
while True:
    sc, address = s.accept()
    # sc, address = s.accept()
    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']:
Esempio n. 7
0
parser.add_argument('plate_image', help='License plate image file')

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)
def alpr_conf():
    alpr = Alpr(country, config, runtime_data)
    alpr.set_top_n(7)
    alpr.set_default_region("base")
    alpr.set_detect_region(False)
    return alpr
Esempio n. 9
0
parser.add_argument('plate_image', help='License plate image file')

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"))
Esempio n. 10
0

try:
    lastCrawl = None
    jsonFiles = None

    start = time.time()

    logging.basicConfig(level=logging.INFO)
    if options.verbosity:
        logging.getLogger().setLevel(logging.DEBUG)
    logging.info('Lancement de croustibatch')

    if not options.tesseract:
        algo = Alpr(options.country, options.config, options.runtime_data)
        algo.set_detect_region("d")
        algo.set_top_n(5)
        algo.set_detect_region(True)
        logging.info("Using OpenALPR " + algo.get_version())
    else:
        algo = "thresh"

    # if not algo.is_loaded():
    #     logging.error("Error loading OpenALPR")
    # else:

    ftp = FTP(options.ftphost)
    ftp.login(options.loginftp, options.passwordftp)

    #if not os.path.isdir(options.directory):
    #    os.mkdir(options.directory)
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. 12
0
from openalpr import Alpr

country = "eu"
default_region = "fi"
detect_region = False

alpr = Alpr(country, "/etc/openalpr/openalpr.conf",
            "/usr/share/openalpr/runtime_data")
alpr.set_top_n(5)
alpr.set_default_region(default_region)
alpr.set_detect_region(detect_region)

print('ALPR config: country={}, default_region={}, detect_region={}'.format(
    country, default_region, detect_region))


def recognize(file_path):
    cv_output = []

    output = alpr.recognize_file(file_path)
    for plate in output['results']:
        for candidate in plate['candidates']:
            cv_output.append({
                "plate": candidate['plate'],
                "confidence": candidate['confidence']
            })

    #alpr.unload()
    return cv_output
Esempio n. 13
0
class AnalizePlate(object):
    def __init__(self):
        """
        Simple script init, does not require any params.
        """
        self.last_plate = None
        self.alpr = None
        self.db = DB.DB()
        try:
            self.alpr = Alpr("rs", "/etc/openalpr/openalpr.conf",
                             "/usr/share/openalpr/runtime_data")
            if not self.alpr.is_loaded():
                print("Error loading OpenALPR")
        except:
            print("Error")
            return False

    def proccess(self, img, naziv, ip, image_location, thumbnail_location):
        """
        Process the passed image and return the results.
        :param img: numpy array
        :return: array
        """
        self.alpr.set_top_n(7)
        self.alpr.set_detect_region(False)
        # print "[+] Analiziram tablicu"
        try:
            results = self.alpr.recognize_file(naziv)
        except Exception as e:
            print "Analize plate array error:", e
            # exit(0)
            return False

        if results['results']:
            if self.last_plate != results['results'][0]['plate']:
                self.last_plate = results['results'][0]['plate']
                kandidati = ""
                for plate in results['results'][0]['candidates']:
                    try:
                        kandidati += plate['plate'] + ','
                    except Exception as e:
                        print str(e)
                # shutil.copy(naziv, "/home/metro/Programazer/carina-slike/")
                vreme = time.time()
                # im = cv2.imread(naziv)
                obj = datetime.datetime.fromtimestamp(vreme)
                # ime = obj.strftime("%d-%m-%Y %H:%M:%S")
                folder = obj.strftime("%d.%m.%Y")
                ime = "{}_{}".format(time.time(), ip)
                try:
                    if not os.path.exists("{}{}".format(
                            image_location, folder)):
                        os.makedirs("{}{}".format(image_location, folder))
                    if not os.path.exists("{}{}".format(
                            thumbnail_location, folder)):
                        os.makedirs("{}{}".format(thumbnail_location, folder))
                    imwrite("{}{}/{}.jpg".format(image_location, folder, ime),
                            img)
                    try:
                        imwrite(
                            "{}{}/{}.jpg".format(thumbnail_location, folder,
                                                 ime),
                            resize(img, (0, 0), fx=0.3, fy=0.3))
                        thumb = True
                    except:
                        thumb = False
                        pass
                        # imwrite("/opt/lampp/htdocs/carina-tablice/{}.jpg".format(ime),img)
                except Exception as e:
                    print e
                    return False
                self.add_plate(results['results'][0]['plate'], kandidati,
                               folder + "/" + ime, thumb)
                notify(folder + "/" + ime, results['results'][0]['plate'])
                self.checkActivePlates(folder + "/" + ime,
                                       results['results'][0]['plate'])
                # print naziv, results['results'][0]['plate']
                # return results
        try:
            os.remove(naziv)
        except:
            pass
        return False

    def add_plate(self, tablica, kandidati, naziv, thumb):
        try:
            if thumb:
                self.db.execute(
                    "INSERT INTO tablice (br_tablice, moguce_tablice,naziv,ostalo) VALUES ('{}', '{}','{}','thumb=true')"
                    .format(tablica, kandidati, naziv))
            else:
                self.db.execute(
                    "INSERT INTO tablice (br_tablice, moguce_tablice,naziv) VALUES ('{}', '{}','{}')"
                    .format(tablica, kandidati, naziv))
            return True
        except:
            self.db = DB.DB()
            if thumb:
                self.db.execute(
                    "INSERT INTO tablice (br_tablice, moguce_tablice,naziv,ostalo) VALUES ('{}', '{}','{}','thumb=true')"
                    .format(tablica, kandidati, naziv))
            else:
                self.db.execute(
                    "INSERT INTO tablice (br_tablice, moguce_tablice,naziv) VALUES ('{}', '{}','{}')"
                    .format(tablica, kandidati, naziv))
            return True
        return False

    def checkActivePlates(self, ime, plate):
        res = self.db.execute(
            "SELECT * FROM aktuelno WHERE tablica LIKE '%{}%'".format(plate))
        result = res.fetchall()
        # print result
        if len(result) > 0:
            # print "[!]"*5,rezultat[0][1],"[!]"*5
            notify(
                ime,
                plate,
                result[0][1],
            )
Esempio n. 14
0
alpr = None
files = []
try:
    __location__ = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__)))
    alpr = Alpr("eu", options.config, options.runtime_data)

    if not alpr.is_loaded():
        print("Error loading OpenALPR")
    else:
        #print("Using OpenALPR " + alpr.get_version())
        files += [each for each in os.listdir('.') if each.endswith('.png')]
        print("<table>");
        for file in files:
            alpr.set_top_n(7)
            alpr.set_default_region("eu")
            alpr.set_detect_region(True)
            jpeg_bytes = open(__location__+file, "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
            if(results['results']):
                print("<tr><td><img width='640' height='480' src='"+file+"' /></td><td>")
            for plate in results['results']:
                i += 1
Esempio n. 15
0
class image_converter:
    def __init__(self):

        self.bridge = CvBridge()
        self.image_sub = rospy.Subscriber("camera/image_raw", Image,
                                          self.callback)
        self.alpr = Alpr("eu", "/etc/openalpr/openalpr.conf",
                         "/usr/local/home/u180107/openalpr/runtime_data")
        self.alpr.set_detect_region(True)
        self.currentConfidence = 0
        self.currentDistance = 0

    def distanceByArea(self, cv_image):

        results = self.alpr.recognize_ndarray(cv_image)
        for i, plate in enumerate(results['results']):
            best_candidate = plate['coordinates']
            corner1 = (best_candidate[0]['x'], best_candidate[0]['y'])
            corner2 = (best_candidate[2]['x'], best_candidate[2]['y'])
            platePixelWidth = abs(
                int(best_candidate[2]['x']) - int(best_candidate[0]['x']))
            platePixelHeight = abs(
                int(best_candidate[2]['y']) - int(best_candidate[0]['y']))
            platePixelArea = platePixelHeight * platePixelWidth

            # The distance equation required that the camera be calibrated, currently they're 'close enough'
            distance = round(52000 * pow(platePixelArea, -0.368), 2)
            detected = plate['candidates'][0]
            if self.currentConfidence < detected['confidence'] or abs(
                    distance - self.currentDistance) > 200:
                self.currentConfidence = detected['confidence']
                # print('Plate #{}: {:7s} ({:.2f}%) - Plate distance: {}mm'.format(i, detected['plate'].upper(), detected['confidence'],distance))
            self.currentDistance = distance

            cv2.rectangle(cv_image, corner1, corner2, (0, 255, 0), 2)
            cv2.putText(cv_image, ('distance = %dmm' % distance),
                        (i * 330, 460), font, 1, (0, 255, 0), 2, cv2.LINE_AA)

        return cv_image

    def distanceByHomography(self, cv_image):
        cam_mtx = np.array([[767.92632836, 0, 325.7824046],
                            [0, 770.98907555, 157.44636998], [0, 0, 1]])
        dist_coeffs = np.zeros((5, 1))
        results = self.alpr.recognize_ndarray(cv_image)
        for i, plate in enumerate(results['results']):
            best_candidate = plate['coordinates']
            worldPoints = np.float32([[0, 0, 0], [510, 0, 0], [510, 110, 0],
                                      [0, 110, 0]])
            imagePoints = np.float32([(best_candidate[a]['x'],
                                       best_candidate[a]['y'])
                                      for a in range(0, 4)])
            # print(imgPoints)
            # print(worldPoints)
            imgPoints = np.ascontiguousarray(imagePoints[:, :2].reshape(
                4, 1, 2))
            _ret, rvec, tvec = cv2.solvePnP(worldPoints,
                                            imgPoints,
                                            cam_mtx,
                                            dist_coeffs,
                                            flags=cv2.SOLVEPNP_P3P)
            print("Rotation Vector:\n {0}".format(rvec))
            print("Translation Vector:\n {0}".format(tvec))

            end_point2D, jacobian = cv2.projectPoints(
                np.array([(0.0, 0.0, 1000.0)]), rvec, tvec, cam_mtx,
                dist_coeffs)

            for p in imagePoints:
                cv2.circle(cv_image, (int(p[0]), int(p[1])), 3, (0, 0, 255),
                           -1)

            p1 = (int(imagePoints[0][0]), int(imagePoints[0][1]))
            p2 = (int(end_point2D[0][0][0]), int(end_point2D[0][0][1]))

            cv2.line(cv_image, p1, p2, (255, 0, 0), 2)

        return cv_image

    def callback(self, data):
        try:
            cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
            # cv2.imshow(WINDOW_NAME, cv_image)
        except CvBridgeError as e:
            print(e)

        # cv_image_labeled = self.distanceByArea(cv_image)
        cv_image_labeled = self.distanceByHomography(cv_image)

        cv2.imshow(WINDOW_NAME, cv_image_labeled)
        cv2.waitKey(3)
Esempio n. 16
0
class image_converter:
    def __init__(self):
        self.publisher = rospy.Publisher('object_pose', Point, queue_size=10)
        self.bridge = CvBridge()
        self.image_sub = rospy.Subscriber("camera/image_raw", Image,
                                          self.callback)
        self.alpr = Alpr("eu", "/etc/openalpr/openalpr.conf",
                         "/usr/local/home/u180107/openalpr/runtime_data")
        self.alpr.set_detect_region(True)
        self.currentConfidence = 0
        self.currentDistance = 0
        self.criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER,
                         30, 0.001)
        self.objp = np.float32([[0, 0, 0], [7, 0, 0], [0, 5, 0], [7, 5, 0]])
        self.axis = np.float32([[3, 0, 0], [0, 3, 0], [0, 0,
                                                       -3]]).reshape(-1, 3)
        with np.load('calibration.npz') as X:
            self.mtx, self.dist = [X[i] for i in ('mtx', 'dist')]

    def draw(self, img, corners, imgpts):
        corner = tuple(corners[0].ravel())
        img = cv2.line(img, corner, tuple(imgpts[0].ravel()), (255, 0, 0), 5)
        img = cv2.line(img, corner, tuple(imgpts[1].ravel()), (0, 255, 0), 5)
        img = cv2.line(img, corner, tuple(imgpts[2].ravel()), (0, 0, 255), 5)
        return img

    def getPose(self, cv_image):

        gray = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
        ret, corners = cv2.findChessboardCorners(gray, (8, 6), None,
                                                 cv2.CALIB_CB_FAST_CHECK)

        if ret == True:
            result = np.array(
                [corners[0], corners[7], corners[40], corners[-1]])
            for res in result:
                cv2.circle(cv_image, (res[0][0], res[0][1]), 5, (0, 0, 255), 3)

            # print(result)
            corners2 = cv2.cornerSubPix(gray, result, (11, 11), (-1, -1),
                                        self.criteria)

            ret, rvecs, tvecs, inliers = cv2.solvePnPRansac(
                self.objp, corners2, self.mtx, self.dist, cv2.SOLVEPNP_P3P)

            imgpts, jac = cv2.projectPoints(self.axis, rvecs, tvecs, self.mtx,
                                            self.dist)
            img = self.draw(cv_image, corners2, imgpts)
            platePoint = Point(float(tvecs[0]), float(tvecs[1]),
                               float(tvecs[2]))
            self.publisher.publish(platePoint)
            # cv2.imshow('img', img)
            return (img)

            successful_frames += 1
            cv2.waitKey(1)
        else:
            # cv2.imshow('img', cv_image)
            return (cv_image)
            cv2.waitKey(1)

    def distanceByArea(self, cv_image):
        results = self.alpr.recognize_ndarray(cv_image)
        for i, plate in enumerate(results['results']):
            best_candidate = plate['coordinates']
            corner1 = (best_candidate[0]['x'], best_candidate[0]['y'])
            corner2 = (best_candidate[2]['x'], best_candidate[2]['y'])
            platePixelWidth = abs(
                int(best_candidate[2]['x']) - int(best_candidate[0]['x']))
            platePixelHeight = abs(
                int(best_candidate[2]['y']) - int(best_candidate[0]['y']))
            platePixelArea = platePixelHeight * platePixelWidth

            # The distance equation required that the camera be calibrated, currently they're 'close enough'
            distance = round(52000 * pow(platePixelArea, -0.368), 2)
            detected = plate['candidates'][0]
            if self.currentConfidence < detected['confidence'] or abs(
                    distance - self.currentDistance) > 200:
                self.currentConfidence = detected['confidence']
                # print('Plate #{}: {:7s} ({:.2f}%) - Plate distance: {}mm'.format(i, detected['plate'].upper(), detected['confidence'],distance))
            self.currentDistance = distance

            cv2.rectangle(cv_image, corner1, corner2, (0, 255, 0), 2)
            cv2.putText(cv_image, ('distance = %dmm' % distance),
                        (i * 330, 460), font, 1, (0, 255, 0), 2, cv2.LINE_AA)

        return cv_image

    def distanceByHomography(self, cv_image):
        cam_mtx = np.array([[767.92632836, 0, 325.7824046],
                            [0, 770.98907555, 157.44636998], [0, 0, 1]])
        dist_coeffs = np.zeros((5, 1))
        results = self.alpr.recognize_ndarray(cv_image)
        for i, plate in enumerate(results['results']):
            best_candidate = plate['coordinates']
            worldPoints = np.float32([[0, 0, 0], [510, 0, 0], [510, 110, 0],
                                      [0, 110, 0]])
            imagePoints = np.float32([(best_candidate[a]['x'],
                                       best_candidate[a]['y'])
                                      for a in range(0, 4)])
            # print(imgPoints)
            # print(worldPoints)
            imgPoints = np.ascontiguousarray(imagePoints[:, :2].reshape(
                4, 1, 2))
            _ret, rvec, tvec = cv2.solvePnP(worldPoints,
                                            imgPoints,
                                            cam_mtx,
                                            dist_coeffs,
                                            flags=cv2.SOLVEPNP_P3P)
            print("Rotation Vector:\n {0}".format(rvec))
            print("Translation Vector:\n {0}".format(tvec))

            end_point2D, jacobian = cv2.projectPoints(
                np.array([(0.0, 0.0, 1000.0)]), rvec, tvec, cam_mtx,
                dist_coeffs)

            for p in imagePoints:
                cv2.circle(cv_image, (int(p[0]), int(p[1])), 3, (0, 0, 255),
                           -1)

            p1 = (int(imagePoints[0][0]), int(imagePoints[0][1]))
            p2 = (int(end_point2D[0][0][0]), int(end_point2D[0][0][1]))

            cv2.line(cv_image, p1, p2, (255, 0, 0), 2)

        return cv_image

    def callback(self, data):
        try:
            cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
        except CvBridgeError as e:
            print(e)

        cv_image_labeled = self.getPose(cv_image)
        cv2.imshow(WINDOW_NAME, cv_image_labeled)
        cv2.waitKey(1)