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()
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
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()
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()
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']:
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
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"))
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()
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
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],
)
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
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)
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)
