def pipeline(foto):
alpr = Alpr("us", "/etc/openalpr/openalpr.conf", "openalpr/runtime_data/")
if not alpr.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
alpr.set_top_n(7)
alpr.set_default_region("md")
results = alpr.recognize_ndarray(foto)
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 = "*"
if len(candidate["plate"]
) == 6 and candidate["confidence"] >= 50.0:
print("Plate: " + str(candidate["plate"]) + " Confidence:" +
str(candidate["confidence"]))
# print(" %s %12s%12f" % (prefix, candidate['plate'], candidate['confidence']))
# Call when completely done to release memory
alpr.unload()
def recognize_license_plate(image, obj_meta, confidence):
#silly way to detect license plates
if (obj_meta.class_id == 1):
#Importing openalpr
print('Importing alpr')
alpr_engine = Alpr("eu", "/etc/openalpr/openalpr_rai.conf",
"/usr/share/openalpr/runtime_data")
if not alpr_engine.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
alpr_engine.set_top_n(10)
alpr_engine.set_default_region("fi")
frame_number = random.randint(0, 100)
rect_params = obj_meta.rect_params
top = int(rect_params.top)
left = int(rect_params.left)
width = int(rect_params.width)
height = int(rect_params.height)
lp_cutout = image[top:top + height, left:left + width, :]
cv2.imwrite(
"/opt/nvidia/deepstream/deepstream-5.0/sources/python/apps/deepstream-test10-helloworld6/"
+ str(frame_number) + "_lpcut.jpg", lp_cutout)
cv2.imwrite(
"/opt/nvidia/deepstream/deepstream-5.0/sources/python/apps/deepstream-test10-helloworld6/"
+ str(frame_number) + "_image.jpg", image)
results = alpr_engine.recognize_ndarray(lp_cutout)
print(results)
alpr_engine.unload()
class ALPRContainer(rpc.ModelContainerBase):
def __init__(self):
self.alpr = Alpr(country='us',
config_file='/etc/openalpr/openalpr.conf',
runtime_dir='/usr/share/openalpr/runtime_data')
def predict_floats(self, inputs):
int_inputs = (np.array(inputs) * 255).astype(np.uint8)
reshaped_input = [arr.reshape(224, 224, 3) for arr in int_inputs]
results = [self.alpr.recognize_ndarray(inp) for inp in reshaped_input]
serialized = [json.dumps(result) for result in results]
return serialized
def plate_detection(self, frame):
alpr = Alpr('eu', '/etc/openalpr/openalpr.conf',
'/usr/share/openalpr/runtime_data')
if not alpr.is_loaded():
raise AlprException("Error loading openALPR")
alpr.set_top_n(1)
results = alpr.recognize_ndarray(frame)
if results['results'] != []:
self.plate_as_text(results)
class OpenALPRProcessor:
def __init__(self, config, share_data):
self.__alpr = Alpr("eu-by", config, share_data)
self.__counter = 0
def process_next_frame(self, frame):
self.__counter += self.__counter
frame['detections']['plates'] = []
for idx, roi in enumerate(frame['detections']['rois']):
results = self.__alpr.recognize_ndarray(
frame['image'][roi[0]:roi[0] + roi[2], roi[1]:roi[1] + roi[3]])
if len(results['results']):
frame['detections']['plates'].append(results['results'])
return frame
def detect(frame):
# Configure ALPR setting according to config file
alpr = Alpr("us", "/usr/share/openalpr/config/openalpr.defaults.conf",
"/usr/share/openalpr/runtime_data/")
if not alpr.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
# Get the top result from ALPR for each plate
alpr.set_top_n(1)
alpr.set_default_region("tx")
# Loads results from the openALPR library
results = alpr.recognize_ndarray(frame)
result = results['results']
alpr.unload()
return result
def read_number_plate(im):
#initialize the openalpr class instance
alpr = Alpr("us", "../DATA/runtime_data/config/us.conf",
"../DATA/runtime_data")
if not alpr.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
alpr.set_top_n(20)
alpr.set_default_region("ca")
results = alpr.recognize_ndarray(im)
i = 0
# extracting the json files
plate = results['results'][0]
candidate = plate['candidates'][0]
plate_coordinates = results['results'][0]['coordinates']
alpr.unload()
out = im[plate_coordinates[0]['y']:plate_coordinates[2]['y'] + 20,
plate_coordinates[0]['x']:plate_coordinates[1]['x'] + 20]
return candidate['plate'], candidate['confidence'], out
def main():
alpr = Alpr('eu', 'eu.conf', '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
while True:
ret_val, frame = cap.read()
if not ret_val:
print('VidepCapture.read() failed. Exiting...')
break
_frame_number += 1
if _frame_number % FRAME_SKIP != 0:
continue
cv2.imshow(WINDOW_NAME, frame)
results = alpr.recognize_ndarray(frame)
for i, plate in enumerate(results['results']):
best_candidate = plate['candidates'][0]
print('Plate #{}: {:7s} ({:.2f}%)'.format(
i, best_candidate['plate'].upper(),
best_candidate['confidence']))
if cv2.waitKey(1) == 27:
break
cv2.destroyAllWindows()
cap.release()
alpr.unload()
def recognize_license_plate(image, obj_meta, confidence):
#silly way to detect license plates
if (True): #obj_meta.class_id == 1):
#Importing openalpr
alpr_engine = Alpr("eu", "/etc/openalpr/openalpr.conf",
"/usr/share/openalpr/runtime_data")
if not alpr_engine.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
alpr_engine.set_top_n(10)
alpr_engine.set_default_region("fi")
#frame_number = random.randint(0, 100)
rect_params = obj_meta.rect_params
top = int(rect_params.top)
left = int(rect_params.left)
width = int(rect_params.width)
height = int(rect_params.height)
lp_cutout = image[top:top + height, left:left + width, :]
#cv2.imwrite("/opt/nvidia/deepstream/deepstream-5.0/sources/python/apps/deepstream-test12-helloworld8/"+str(frame_number)+"_lpcut.jpg",lp_cutout)
#cv2.imwrite("/opt/nvidia/deepstream/deepstream-5.0/sources/python/apps/deepstream-test10-helloworld8/"+str(frame_number)+"_image.jpg",image)
results = alpr_engine.recognize_ndarray(lp_cutout)
if 'results' in results:
dets = results['results']
#if (len(dets) > 0 and len(dets[0]['plate'])==6):
# plate_tracker[track.track_id] = dets[0]['plate']
print(dets)
alpr_engine.unload()
label = "{}: {:.2f}%".format('car', confidence * 100)
cv2.rectangle(image, (startX, startY), (endX, endY),
COLORS, 2)
y = startY - 15 if startY - 15 > 15 else startY + 15
cv2.putText(image, label, (startX, y),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, COLORS, 2)
if startX < 0: startX = 0
if endX < 0: endX = 0
if startY < 0: startY = 0
if endY < 0: endY = 0
img2 = image[startY:endY, startX:endX]
#cv2.imshow('test',img2)
#cv2.imwrite("img{}.jpg".format(i), img2)
results = alpr.recognize_ndarray(img2)
if len(results['results']) > 0:
print("|||||||||||||||||||||||||||||||")
print("plate --> {}".format(
results['results'][0]['candidates'][0]['plate']))
print("confidence --> {}".format(
results['results'][0]['candidates'][0]
['confidence']))
fps = "{:3.0f} FPS".format(1 / (time.time() - start_time))
cv2.putText(image, fps, (w - 85, h - 50),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, COLORS2, 2)
cv2.imshow('frame', image)
if cv2.waitKey(1) & 0xFF == ord('q'):
class detectionBox:
def __init__(self, camera_name, name, area, video_stream_reference, config,
runtime, db_reference):
self.camera_name = camera_name
self.name = name
self.area = area # bounding box for the search
self.stream = video_stream_reference # reference to the video feed
self.old_detected_rect = []
# threads cannot share alpr object, needs its own
self.alpr = Alpr("us", config, runtime)
self.alpr.set_top_n(1)
self.fps = FPS().start_timer()
self.stopped = False
# stores license plate objects
self.license_plate_list = []
self.licensePlateService = licensePlateService(self,
db_reference).start()
def start(self):
Thread(target=self.update, args=()).start()
return self
def update(self): # main method, do processing here
while True:
if self.stopped:
return
self.fps.update()
# grab the most recent frame from the video thread
frame = self.stream.read()
frame_copy = copy.deepcopy(frame)
cropped_frame = frame[int(self.area[1]):int(self.area[1] +
self.area[3]),
int(self.area[0]):int(self.area[0] +
self.area[2])]
# run the detector
results = self.alpr.recognize_ndarray(cropped_frame)
detected_rect = []
# finds all rects in frame and stores in detectedRect
if results['results']:
for plate in results['results']:
# offset so points are relative to the frame, not cropped frame, use to find bounding rect
left_bottom = (plate['coordinates'][3]['x'] + self.area[0],
plate['coordinates'][3]['y'] + self.area[1])
right_bottom = (plate['coordinates'][2]['x'] +
self.area[0],
plate['coordinates'][2]['y'] +
self.area[1])
right_top = (plate['coordinates'][1]['x'] + self.area[0],
plate['coordinates'][1]['y'] + self.area[1])
left_top = (plate['coordinates'][0]['x'] + self.area[0],
plate['coordinates'][0]['y'] + self.area[1])
all_points = np.array(
[left_bottom, right_bottom, left_top, right_top])
bounding_rect = cv2.boundingRect(all_points) # X, Y, W, H
detected_rect.append(bounding_rect)
# convert lpr results into a license plate object and store in license_plate_list
plate_number = plate['plate']
#plate_image = frame[int(bounding_rect[1]):int(bounding_rect[1] + bounding_rect[3]), int(bounding_rect[0]):int(bounding_rect[0] + bounding_rect[2])]
plate_image = cv2.resize(frame_copy, (720, 480),
interpolation=cv2.INTER_AREA)
plate_datetime = datetime.datetime.now()
plate_time = get_system_uptime()
plate_confidence = plate['confidence']
new_plate = licensePlate(plate_number, plate_image,
plate_time, self.camera_name,
self.name, plate_datetime,
plate_confidence)
self.license_plate_list.append(new_plate)
self.licensePlateService.notify(
) # help out the poor thread
self.old_detected_rect = detected_rect # this way, detectedRect will be erased and operated on but oldDetectedRect will always have something in it
else:
# no results
self.old_detected_rect = []
def draw(self, frame):
# return frame with drawings on it
# draw plates detected and bounding boxes
# is this necessary? The bounding boxes of the search areas should not overlap
# should check for overlapping bounding boxes in constructor
# draw plates detected
# print(len(self.oldDetectedRect))
for rect in self.old_detected_rect:
cv2.rectangle(frame, rect, (0, 255, 0), 2)
# draw search box and name
cv2.putText(frame, self.name, (self.area[0], self.area[1] - 5),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (15, 15, 255), 2)
cv2.rectangle(frame, self.area, (0, 0, 255), 2)
# return drawn frame
return frame
def stop(self):
self.fps.stop()
print(self.name, "FPS: ", self.fps.fps())
self.licensePlateService.stop()
self.stopped = True
alpr = Alpr("us", "openalpr/config/openalpr.conf.defaults",
"openalpr/runtime_data")
if not alpr.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
alpr.set_top_n(20)
alpr.set_default_region("fl")
'''
video = cv2.VideoCapture(0)
val, frame = video.read()
results = alpr.recognize_ndarray(frame)
'''
img = cv2.imread("img3.jpg")
frame = img
results = alpr.recognize_ndarray(frame)
print(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 = "*"
print(" %s %12s%12f" %
(prefix, candidate['plate'], candidate['confidence']))
ylp0 = min(ylp0, frame.shape[1])
ylp3 = min(ylp3, frame.shape[1])
# cv2.line(imgOriginalScene, tuple(points[0]), tuple(points[1]), (0, 255, 0), 2)
# cv2.line(imgOriginalScene, tuple(points[1]), tuple(points[2]), (0, 255, 0), 2)
# cv2.line(imgOriginalScene, tuple(points[2]), tuple(points[3]), (0, 255, 0), 2)
# cv2.line(imgOriginalScene, tuple(points[3]), tuple(points[0]), (0, 255, 0), 2)
# cv2.imshow('LP', imgOriginalScene)
lp_image = imgOriginalScene[int(ylp1):int(ylp3), int(xlp1):int(xlp3), :]
# cv2.imwrite('cars/car_' + str(indexIDs[i]) + '_lp.png', lp_image)
# cv2.imshow('LP_IMG', lp_image)
"""--------------------------------"""
results = alpr.recognize_ndarray(lp_image)
i = 0
for plate in results['results']:
candidates = sorted(plate['candidates'], key=lambda c: c['confidence'], reverse=True)
candidate = candidates[0]
# print(candidate['confidence'], candidate['matches_template'], candidate['plate'])
license_plate = candidate['plate']
# for c in candidates:
# print(c['confidence'], c['matches_template'], c['plate'], sep='; ')
"""--------------------------------"""
"""-----------------------"""
"""ID"""
# text = "{}".format(indexIDs[i])
# cv2.putText(frame, text, (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
i += 1
#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'])
break
resized = cv2.resize(frame,(0,0),fx=0.3,fy=0.3)
cv2.imshow("frame",resized)
cv2.waitKey(1)
cap.release()
'''
gray = cv2.imread("/home/frank/Tmp/2.jpg", 0)
s = time.time()
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 = "*"
print(" %s %12s%12f" %
(prefix, candidate['plate'], candidate['confidence']))
break
e = time.time()
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)
def main():
alpr = Alpr('fr', 'fr.conf',
'/usr/local/share/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!')
self.label_display.set_text(
"Output Log : Failed to open video file")
#cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_NORMAL)
#cv2.setWindowTitle(WINDOW_NAME, 'Gate Camera test')
#cv2.resizeWindow(WINDOW_NAME, 256, 256)
conn = sqlite3.connect('stu3.db')
c = conn.cursor()
#c.execute('create table pr1 (ID, Name, NP)')
conn.commit()
_frame_number = 0
while True:
ret_val, frame = cap.read()
if not ret_val:
self.label_display.set_text(
"Output Log : VidepCapture.read() failed. Exiting...")
break
_frame_number += 1
if _frame_number % FRAME_SKIP != 0:
continue
#cv2.imshow(WINDOW_NAME, frame)
#cv2.resizeWindow(WINDOW_NAME, frame, 256, 256)
results = alpr.recognize_ndarray(frame)
for i, plate in enumerate(results['results']):
best_candidate = plate['candidates'][0]
J = ('{}'.format(best_candidate['plate'].upper(),
best_candidate))
print str(J)
rows = c.execute("select plate from NP")
conn.text_factory = lambda x: unicode(x, 'utf-8', 'ignore')
for row in rows:
if row[0] == str(J):
self.status_log.set_text(str(J))
print("Matched")
arduino = serial.Serial('/dev/ttyACM0', 9600)
command = str(85)
arduino.write(command)
reachedPos = str(arduino.readline())
ct = datetime.datetime.now()
data_input = '''INSERT INTO logs(plate,entrytime,inside) VALUES(?,?,?);'''
boolean = 1
data_tuple = (J, ct, boolean)
c.execute(data_input, data_tuple)
conn.commit()
print("------------------------")
else:
print("------------------------")
#print(type(row[0]))
if cv2.waitKey(1) == 27:
break
cv2.destroyAllWindows()
cap.release()
alpr.unload()
def main():
writer = None
VIDEO_SOURCE = '/home/ankita/Downloads/video1.mp4'
WINDOW_NAME = 'openalpr'
FRAME_SKIP = 15
alpr = Alpr('us', 'us.conf', '/usr/local/share/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 = cv2.VideoCapture(VIDEO_SOURCE)
if not cap.isOpened():
alpr.unload()
print('Failed to load video file')
#sys.exit('Failed to open video file!')
cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_AUTOSIZE)
cv2.setWindowTitle(WINDOW_NAME, 'OpenALPR video test')
_frame_number = 0
currentFrame = 0
# Get current width of frame
width = cap.get(cv2.CAP_PROP_FRAME_WIDTH) # float
# Get current height of frame
height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT) # float
# Define the codec and create VideoWriter object
fourcc = cv2.VideoWriter_fourcc(*"XVID")
out = cv2.VideoWriter('color_output.avi', fourcc, 2.0, (int(width), int(height)))
while True:
ret_val, frame = cap.read()
if not ret_val:
print('VidepCapture.read() failed. Exiting...')
break
_frame_number += 1
if _frame_number % FRAME_SKIP != 0:
continue
results = alpr.recognize_ndarray(frame)
for i, plate in enumerate(results['results']):
list1 = []
best_candidate = plate['candidates'][0]
min_coord = plate['coordinates'][0]
max_coord = plate['coordinates'][2]
x_min = int(min_coord['x'])
y_min = int(min_coord['y'])
x_max = int(max_coord['x'])
y_max = int(max_coord['y'])
cv2.resize(frame, (500, 500), fx=0, fy=0,
interpolation=cv2.INTER_CUBIC)
cv2.rectangle(frame, (x_min, y_min),
(x_max, y_max), (255, 255, 0), 5)
#cropimg = cv2.getRectSubPix(
# frame, (x_min-10, y_min), (x_min, y_min))
#type(cropimg[0:])
#x = cropimg[0:][0][0]
#list1 = x.tolist()
#list1 = list(map(int,list1))
#print(list1)
#print(type(list1))
#act,pred = get_colour_name(tuple(list1))
#print(pred)
cv2.putText(frame, 'NP: '+str(best_candidate['plate']).upper(), (x_min, y_min), cv2.FONT_HERSHEY_SIMPLEX, 0.85, [255, 255, 0], 2)
if(best_candidate['confidence'] > 50):
print('Plate #{}: {:7s} ({:.2f}%)'.format(i, best_candidate['plate'].upper(), best_candidate['confidence']))
list1 = []
cv2.imshow(WINDOW_NAME, frame)
out.write(frame)
if cv2.waitKey(1) == 27:
break
cv2.destroyAllWindows()
out.release()
cap.release()
alpr.unload()
def main():
lastSaveTime = datetime.now(
) # initialize last-image-save-time to prog. start time
alpr = Alpr("us", CFILE, "/usr/share/openalpr/runtime_data/")
if not alpr.is_loaded():
print('Error loading OpenALPR')
sys.exit(1)
alpr.set_top_n(1)
cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_AUTOSIZE)
cv2.setWindowTitle(WINDOW_NAME, 'OpenALPR video test')
# =========== now have a loaded instance of alpr; do stuff here
cam = cv2.VideoCapture(vidname) # open a video file or stream
img_w = int(cam.get(3)) # input image width
img_h = int(cam.get(4)) # input image height
print("Image w,h = %d %d" % (img_w, img_h))
prlist = re.compile(r"\L<plates>",
plates=[
'7WXY20Z', '7WXYZ02', 'WXY202', '7WXY202',
'WXY20Z', 'WXYZ02', 'WXYZ0Z', '7WXY2Q2'
])
save = True # always save the first image, for reference
lastPstring = "" # haven't seen any plates yet
lastGarageDoor = True # assume we're starting with door closed
lastBright = 0.0 # average brightness of previous frame
lastXcent = 0
lastYcent = 0
mvec = 0
# ================== MAIN LOOP =====================================
while (True):
ret, img = cam.read()
if not ret:
print('VidepCapture.read() failed. Exiting...')
sys.exit(1)
ttnow = datetime.now() # local real time when this frame was received
avgbright = img.mean() # average of all pixels (float)
# print(avgbright)
cv2.imshow(WINDOW_NAME, img) # show camera image
results = alpr.recognize_ndarray(img)
# print(".",end='')
# print(results)
jsonRes = (json.dumps(results, indent=2))
jsonS = json.loads(jsonRes)
rlist = results['results']
pcount = len(rlist) # how many plates we have found
# print("Length = %d" % len(rlist) )
if (pcount < 1):
# print("No plates found, bright: %5.2f" % avgbright )
pstring = "" # null plate (nothing found)
else:
for i, plate in enumerate(rlist):
cor1x = int(jsonS["results"][0]["coordinates"][0]["x"])
cor1y = int(jsonS["results"][0]["coordinates"][0]["y"])
cor2x = int(jsonS["results"][0]["coordinates"][2]["x"])
cor2y = int(jsonS["results"][0]["coordinates"][2]["y"])
xcent = (cor1x + cor2x) / 2
ycent = (cor1y + cor2y) / 2
dx = xcent - lastXcent
dy = ycent - lastYcent
mvec = math.sqrt(dx * dx + dy * dy) # motion vector in pixels
pcrop = img[cor1y:cor2y,
cor1x:cor2x] # crop of image containing plate
cv2.imshow("plate", pcrop) # show just the plate
p = plate['candidates'][0]
pstring = p['plate'].upper() # characters on license plate
# if (pstring != "7WXY202") and (pstring != "WXY202"):
if prlist.search(pstring): # is this the usual garage-door view?
garageDoor = True
else:
garageDoor = False
# here: pstring holds the LP characters, or ""
bRatio = (avgbright + 0.01) / (lastBright + 0.01)
if (bRatio < 1.0):
bRatio = 1 / bRatio
if (bRatio > bRatioThresh):
bChange = True
else:
bChange = False
if (mvec > mThresh):
motion = True
else:
motion = False
tnows = ttnow.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3] # time to msec
if bChange:
print("Brightness change: %5.3f , %s" % (avgbright, tnows))
# save = not garageDoor # save image if normal garage-door view not seen
save = motion # save image if motion of plate detected
if (pstring == ""):
save = False # but don't save image if no plate
if (pstring != lastPstring):
print("# Nothing: brightness %5.3f , %s" % (avgbright, tnows))
if save:
print("%d,%d , %d,%d , " %
(cor1x, img_h - cor1y, cor2x, img_h - cor2y),
end='')
print('%s , %5.2f , %5.2f , %5.2f , %s' %
(pstring, p['confidence'], avgbright, mvec, tnows))
tnowf = ttnow.strftime(
"%Y-%m-%d_%H%M%S_%f")[:-3] # filename time to msec
fname3 = fPrefix + tnowf + "_" + str(i) + ".jpg" # full-size image
# cv.imwrite(fname3, img) # save current image
cv2.imwrite(fname3, pcrop) # save current image
# print("saved: " + fname3)
tSince = (ttnow - lastSaveTime).total_seconds()
# print("seconds since last save = %5.3f" % tSince)
if (tSince > fullInterval):
fname4 = fPrefix2 + tnowf + "_" + str(
i) + ".jpg" # full-size image
cv2.imwrite(fname4, img) # save full image
lastSaveTime = ttnow
save = False
lastXcent = xcent
lastYcent = ycent
lastPstring = pstring # remember what we saw before
lastGarageDoor = garageDoor
lastBright = avgbright # remember last avg brightness
c = cv2.waitKey(1) & 0xFF # get input char if any
if c == ord('q'):
sys.exit(1)
# close up and quit
alpr.unload()
class Lector():
OPEN_ALPR_CONF_PATH = '/opt/openalpr/config/openalpr.conf.user'
RUNTIME_DATA_PATH = '/opt/openalpr/runtime_data'
estado = None
alpr = None
estado_config = None
def __init__(self):
self.estado = 'off'
self.alpr = Alpr("us", self.OPEN_ALPR_CONF_PATH,
self.RUNTIME_DATA_PATH)
self.alpr.set_top_n(1)
def iniciar(self, cam_socket):
if self.estado == 'off':
self.estado = 'on'
placas_candidatas = []
tiempo_post_lectura = 1
tiempo_ultima_lectura = 0
# camara = cv2.VideoCapture(0)
camara = cv2.VideoCapture(
'/home/stalinscj/_dux_test/test/vehiculoTest/portonOriginalSinBorde_640x360.mp4'
)
leyendo = False
success = True
# video = cv2.VideoWriter("output.avi", cv2.VideoWriter_fourcc(*'MJPG'), 20, (640,360))
while self.estado == 'on' and success == True:
success, frame = camara.read()
if not success:
break
if time.time() - tiempo_ultima_lectura > tiempo_post_lectura:
if leyendo == True:
video.release()
threading.Thread(target=self.guardar_video,
args=(video_nombre, )).start()
leyendo = False
else:
if leyendo == False:
video_nombre = "media/{0}.mp4".format(uuid.uuid4().int
& (1 << 64) - 1)
#MP4V
# 0x7634706d
# video = cv2.VideoWriter(video_nombre, cv2.VideoWriter_fourcc(*'MP4V'), 20, (640,360))
video = cv2.VideoWriter(video_nombre, 0x7634706d, 20,
(640, 360))
leyendo = True
video.write(frame)
if not leyendo and placas_candidatas:
placa = self.get_placa(placas_candidatas)
threading.Thread(target=self.procesar_envio,
args=(
placa,
cam_socket,
video_nombre,
)).start()
del placas_candidatas[:]
placa_candidata = self.buscar_placa(frame)
if placa_candidata:
placas_candidatas.append(placa_candidata)
tiempo_ultima_lectura = time.time()
cam_socket.send(
text_data=json.dumps({
'tipo': 'frame',
'img_src': self.img_to_base64(frame)
}))
def detener(self, cam_socket):
if self.estado == 'on':
self.estado = 'off'
frame = cv2.imread(
os.path.join(settings.STATIC_ROOT, 'core/img/live.png'))
time.sleep(2)
cam_socket.send(
text_data=json.dumps({
'tipo': 'frame',
'img_src': self.img_to_base64(frame)
}))
def img_to_base64(self, img):
success, img_codificada = cv2.imencode('.png', img)
if success:
b64_src = 'data:image/png;base64,'
img_src = b64_src + base64.b64encode(img_codificada).decode()
return img_src
return ''
def buscar_placa(self, frame):
buscador = self.alpr.recognize_ndarray(frame)
resultado = buscador['results']
if (resultado):
placa = resultado[0]['plate']
if self.validar_placa(placa):
confianza = resultado[0]['confidence']
coordenadas = resultado[0]['coordinates']
x0 = coordenadas[0]['x']
y0 = coordenadas[0]['y']
x2 = coordenadas[2]['x']
y2 = coordenadas[2]['y']
img_placa = frame[y0:y2, x0:x2]
placa_candidata = (placa, confianza, img_placa, frame)
cv2.rectangle(frame, (x0 - 5, y0 - 5), (x2 + 5, y2 + 5),
(0, 255, 0), 3)
return placa_candidata
return None
def validar_placa(self, placa):
if len(placa) > 5 and len(placa) < 8:
return True
else:
return False
def filtrar_placas(self, placas_candidatas):
flag = False
for placa in placas_candidatas:
if len(placa[0]) > 6:
flag = True
break
if flag:
for placa in placas_candidatas:
if len(placa[0]) < 7:
placas_candidatas.remove(placa)
def get_placa(self, placas_candidatas):
self.filtrar_placas(placas_candidatas)
max_confianza = 0
for i in range(0, len(placas_candidatas)):
confianza = placas_candidatas[i][1]
if (confianza > max_confianza):
max_confianza = confianza
placa = placas_candidatas[i]
return placa
def procesar_envio(self, placa, cam_socket, video_nombre):
placa_str = placa[0]
placa_img = placa[3]
placa_img_mini = placa[2]
config = ConfigParser()
config.read('dux/config.ini')
peaje = Peaje.objects.filter(pk=config.get('peaje', 'id')).first()
lectura = Lectura.objects.create(
peaje=peaje,
matricula=placa_str,
direccion=config.get('camaras', '0'),
imagen=self.img_to_base64(placa_img),
imagen_mini=self.img_to_base64(placa_img_mini),
video=video_nombre)
solicitud = MatriculaSolicitada.objects.filter(matricula=placa_str,
activo=True).first()
avisos = 0
idAlerta = ''
if solicitud:
alerta = Alerta.nueva(solicitud, lectura)
idAlerta = alerta.pk
avisos = alerta.notificacion_set.all().count()
cam_socket.send(
text_data=json.dumps({
'tipo': 'tupla',
'fecha': time.strftime("%d/%m/%Y %H:%M:%S"),
'placa': placa_str,
'img_src': self.img_to_base64(placa_img_mini),
'avisos': avisos,
'alerta_id': idAlerta
}))
def iniciar_config(self, cam_socket):
self.estado_config = 'on'
camara = cv2.VideoCapture(0)
success = True
while self.estado_config == 'on' and success == True:
success, frame = camara.read()
if not success:
break
cam_socket.send(
text_data=json.dumps({'img_src': self.img_to_base64(frame)}))
def terminar_config(self, cam_socket):
if self.estado_config == 'on':
self.estado_config = 'off'
frame = cv2.imread(
os.path.join(settings.STATIC_ROOT, 'core/img/live.png'))
time.sleep(2)
cam_socket.send(
text_data=json.dumps({'img_src': self.img_to_base64(frame)}))
def guardar_video(self, video_nombre):
os.system(
"ffmpeg -i {0}.mp4 -loglevel quiet -an -vcodec libx264 -crf 23 {0}tmp.mp4"
.format(video_nombre[:-4]))
os.system("rm -f " + video_nombre)
os.system("mv {0}tmp.mp4 {0}.mp4".format(video_nombre[:-4]))
def checkRedLightCrossed(self, img):
global count
for v in vehicles:
if v.crossed == False and len(v.points) >= 2:
x1, y1 = v.points[0]
x2, y2 = v.points[-1]
if y1 > yl3 and y2 < yl3:
count += 1
v.crossed = True
bimg = img[int(v.rect[1]):int(v.rect[1] + v.rect[3]),
int(v.rect[0]):int(v.rect[0] + v.rect[2])]
frame2 = bimg
self.bimg = bimg
img2 = Image.fromarray(frame2)
w, h = img2.size
asprto = w / h
frame2 = cv2.resize(frame2, (250, int(250 / asprto)))
cv2image2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2RGBA)
alpr = Alpr(
"us", r"C:\OpenALPR\Agent\etc\openalpr\openalpr.conf",
r"C:\OpenALPR\Agent\usr\share\openalpr\runtime_data")
if not alpr.is_loaded():
print('Error loading OpenALPR')
sys.exit(1)
alpr.set_top_n(3)
results = alpr.recognize_ndarray(frame2)
###########################################################################
resize = cv2.resize(cv2image2, (301, 351),
interpolation=cv2.INTER_LINEAR)
image = qimage2ndarray.array2qimage(resize)
self.label_detect.setPixmap(QPixmap.fromImage(image))
###########################################################################
for i, plate in enumerate(results['results']):
X1 = plate['coordinates'][0]['x']
Y1 = plate['coordinates'][0]['y']
X2 = plate['coordinates'][2]['x']
Y2 = plate['coordinates'][2]['y']
rimg = cv2image2[Y1:Y2, X1:X2]
frame3 = rimg
resize = cv2.resize(frame3, (301, 41),
interpolation=cv2.INTER_LINEAR)
self.image = qimage2ndarray.array2qimage(resize)
self.label_numberplate.setPixmap(
QPixmap.fromImage(self.image))
self.best_candidate = plate['candidates'][0]
# print('Plate #{}: {:7s} ({:.2f}%)'.format(i, best_candidate['plate'].upper(),
# best_candidate['confidence']))
self.label_number_plate.setText(
'number plate: ' +
str(self.best_candidate['plate'].upper()))
detect = self.lineEdit_detect.text()
if detect == str(self.best_candidate['plate'].upper()):
self.label_DETECD_SERACH.show()
print("detect") #ayd2030
else:
self.label_DETECD_SERACH.hide()
###########################################################################
self.name_eligal = r'detection\d- ' + self.best_candidate[
'plate'].upper() + '.jpg'
self.num_plate = r'numberplate\NP- ' + self.best_candidate[
'plate'].upper() + '.jpg'
cv2.imwrite(self.name_eligal, bimg)
cv2.imwrite(self.num_plate, resize)
MainApp.dis(self)
class VehicleID:
region, configuration, runtime = 'us', 'C:\\OpenALPR\\Agent\\etc\\openalpr\\openalpr.conf', 'C:\\OpenALPR\\Agent\\usr\\share\\openalpr\\runtime_data'
frame, small_frame, detect, authorized_users, plate, queue = None, None, True, dict(
), None, queue.Queue(1000)
def __init__(self):
super().__init__()
self.alpr = Alpr(self.region, self.configuration,
self.runtime) # init alpr engine
# self.camera = cv2.VideoCapture("D:\\others\\20191125_141145.mp4") # record frames from video source
self.camera = cv2.VideoCapture(1) # record frames from video source
def main(self):
while True:
self.get_frame()
self.license_plate_recognition()
def get_frame(self):
_, frame = self.camera.read() # read from video source
self.frame = cv2.UMat(frame).get() # use tapi to take advantage of gpu
self.small_frame = cv2.UMat(
cv2.resize(frame, (0, 0), fx=0.25,
fy=0.25)).get() # 1/4 scale for faster processing
def license_plate_recognition(self):
if self.small_frame is not None:
result = self.alpr.recognize_ndarray(self.small_frame).get(
'results') # use alpr engine to detect license plate
if self.detect and result:
self.plate, confidence, _, _, _, _, _, _, coordinates, vehicle_region, _ = result[
0].values(
) # deserialize results of license plate recognition
tl, tr, br, bl = coordinates
cv2.UMat(
cv2.rectangle(
self.frame, (tl['x'] * 4, tl['y'] * 4),
(br['x'] * 4, br['y'] * 4), (0, 255, 255),
8)) # plot coordinates of license plate onto frame
cv2.UMat(
cv2.rectangle(self.frame, (bl['x'] * 4, bl['y'] * 4),
(br['x'] * 4, br['y'] * 4 + 25),
(0, 255, 255), cv2.FILLED))
cv2.UMat(
cv2.putText(self.frame, self.plate,
(bl['x'] * 4 + 40, bl['y'] * 4 + 15),
cv2.QT_FONT_NORMAL, 0.7, (0, 0, 0), 2))
self.authorize_vehicle(
) # search database for vehicle plate and obtain registered owner if present
def authorize_vehicle(self):
user = User.query.filter_by(
license_plate=self.plate).first() # query user that owns vehicle
if user:
self.authorized_users[user.id] = [
user.id, user.name, user.license_plate
] # load user ont authorized list on gate entry
socketio.emit('message', self.authorized_users)
def print_frame(self):
while True:
if self.frame is not None:
yield b'--frame\r\n' b'Content-Type: text/plain\r\n\r\n' + cv2.imencode(
'.jpg', self.frame)[1].tostring() + b'\r\n'
alpr2.set_top_n(200)
video = cv2.VideoCapture(0)
ultimaPlaca = ""
placa = ""
placeHolder = ""
placaTeste1 = ""
placaTeste2 = ""
placaTeste3 = ""
while (True):
_, frame = video.read()
cv2.imshow('CAM', frame)
results = alpr.recognize_ndarray(frame)
for plate in results['results']:
for candidate in plate['candidates']:
if (re.search('^[A-Z]{3}[0-9]{4}', candidate['plate'])):
placeHolder = candidate['plate']
break
resultados = alpr2.recognize_ndarray(frame)
for plate in resultados['results']:
for candidate in plate['candidates']:
if re.search('^[A-Z]{3}[0-9]{4}',
re.sub('[\W_]+', '', candidate['plate'])):
placeHolder = re.sub('[\W_]+', '', candidate['plate'])
break
if (placeHolder != ""):
if (placaTeste1 == ""):
# Image Input
plate_image = cv.imread('res/b3052smd.jpg')
# Resize the Image
scale_percent = 30
width = int(plate_image.shape[1] * scale_percent / 100)
height = int(plate_image.shape[0] * scale_percent / 100)
# dsize
dsize = (width, height)
# Transform
plate_image = cv.resize(plate_image, dsize)
# Plate Recognition
LPR_Result = alpr.recognize_ndarray(plate_image)
# Print all result
pprint.pprint(LPR_Result)
# Check the Result is Empty or Not
if (LPR_Result['results'] != []):
Plate_Result = LPR_Result['results'][0]
return_plate = Plate_Result['plate']
return_confidence = Plate_Result['confidence']
return_coordinate = Plate_Result['coordinates']
# Convert coordinates into bounding box
top_left = return_coordinate[0]
def main():
alpr = Alpr('country', 'country.conf',
'/usr/local/share/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_NORMAL)
cv2.setWindowTitle(WINDOW_NAME, 'Gate Camera test')
_frame_number = 0
while True:
ret_val, frame = cap.read()
if not ret_val:
print('VidepCapture.read() failed. Exiting...')
break
_frame_number += 1
if _frame_number % FRAME_SKIP != 0:
continue
cv2.imshow(WINDOW_NAME, frame)
results = alpr.recognize_ndarray(frame)
for i, plate in enumerate(results['results']):
best_candidate = plate['candidates'][0]
with open('output.txt', 'w') as x:
J = ('{:7s}'.format(best_candidate['plate'].upper(),
best_candidate))
print >> x, str(J)
with open("allowed.txt") as f, open("output.txt") as d:
for line in d:
list_of_lists = []
inner_list = [elt.strip() for elt in line.split(',')]
list_of_lists.append(inner_list)
for line in f:
allowed = []
inner_list2 = [elt.strip() for elt in line.split(',')]
allowed.append(inner_list2)
if list_of_lists == allowed:
print(True)
arduino = serial.Serial('/dev/ttyACM0', 9600)
command = str(85)
arduino.write(command)
reachedPos = str(arduino.readline())
else:
print(False)
if cv2.waitKey(1) == 27:
break
cv2.destroyAllWindows()
cap.release()
alpr.unload()
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)
