class ALPR(ContextEngineBase):
# Trained classifier
alpr = None;
# Top n highest confidence predictions
n = 5
def __init__(self, complexity, numInputs, outputClassifier, inputClassifiers, appFieldsDict):
ContextEngineBase.__init__(self,complexity, numInputs, outputClassifier, inputClassifiers, appFieldsDict)
self.alpr = Alpr("us", "/etc/openalpr/openalpr.conf", "/home/pi/openalpr/runtime_data")
if not self.alpr.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
self.alpr.set_top_n(self.n)
self.alpr.set_default_region("va")
# Execute the trained classifier against the given test sample
# inputObsVector is a path to the video file
def execute(self, inputObsVector):
if(len(inputObsVector) == self.numInputs):
y_Test = self.predict(inputObsVector);
return y_Test;
else:
print("Wrong dimensions, fail to execute");
return None;
# Grabs frames and returns top n predictions per frame.
def predict(self, x_Test):
cap = cv2.VideoCapture(x_Test[0])
if not cap.isOpened():
print("vid open error")
cap.open()
fps = 25
timedelta = 0
detectCounter = [0]
detectCounter[0] = 0
plates_list = np.empty([0, self.n])
while(cap.isOpened()):
ret, frame = cap.read()
if (detectCounter[0] < fps*timedelta):
detectCounter[0] += 1
continue
detectCounter[0] = 0
if ret:
pretime = time.time()
ret, enc = cv2.imencode("*.bmp", frame)
results = self.alpr.recognize_array(bytes(bytearray(enc)))
posttime = time.time()
plates = np.empty([1,self.n], dtype='a5')
for s in range(0, self.n):
plates[0][s] = ""
for plate in results['results']:
i = 0
for candidate in plate['candidates']:
platenum = candidate['plate'].encode('ascii','ignore')
plates[0][i] = platenum
i += 1
timedelta = posttime - pretime # in seconds
plates_list = np.vstack((plates_list, plates))
else:
break
return plates_list;
def pred_alpr(image1): #### SHould add the region
alpr = Alpr("us", "C:\\Users\\shobeir.mazinani\\Desktop\\BasharsALPR\\OpenALPR-Python\\openalpr_64\\openalpr.conf", "C:\\Users\\shobeir.mazinani\\Desktop\\BasharsALPR\\OpenALPR-Python\\openalpr_64\\runtime_data")
if not alpr.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
else:
print("OpenALPR was loaded correctly")
alpr.set_top_n(1)
alpr.set_default_region("ca")
results = alpr.recognize_file(image1)
#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']))
# Call when completely done to release memory
# alpr.unload()
#print("Sleep for some time")
#time.sleep(5)
#print("I am done")
return candidate['plate'], candidate['confidence']
def initNumPlateRecognizer(region="eu"):
alpr = Alpr("eu", "nplate_train/openalpr.conf.in", "nplate_train/runtime_data")
if not alpr.is_loaded():
print ("Error loading OpenALPR")
sys.exit(1)
alpr.set_default_region(region)
return alpr
def license_read(filenames=[]):
alpr = None
#tell alpr which country license plate to use and where to find the openalpr.conf file and the
#runtime_data folder
alpr = Alpr("us", "/etc/openalpr/openalpr.conf", "/home/baus/Documents/openalpr/runtime_data/")
#Ensures that the alpr is loaded and can be used
if not alpr.is_loaded():
print("Error loading OpenALPR")
return "Error"
elif(alpr.is_loaded()):
alpr.set_top_n(1)
alpr.set_default_region('md')
license_plates=[]
#for all the images that was sent, check if license plate exists
for x in range(5):
results = alpr.recognize_file(filenames[x])
for plate in results["results"]:
for candidate in plate["candidates"]:
#Appends the license plate to the list
#Appends nothing if it didnt find any license plate
license_plates.append(candidate["plate"])
return license_plates
return "Error"
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()
options = parser.parse_args()
dst = os.getcwd() + '\cropedImages' # destination to save the images
if not os.path.exists(dst):
os.makedirs(dst)
fieldnames = ['ID', 'Plate number', 'Image Path', 'Date', 'Time']
fileID = open('file.csv', 'w') # file to save the data
newFileWriter = csv.writer(fileID)
newFileWriter.writerow(fieldnames)
alpr = Alpr(options.country, options.config, options.runtime_data)
#alpr = Alpr("mx", "C:/openALPR_1/openalpr_64/openalpr.conf", "C:/openALPR_1/openalpr_64/runtime_data")
#alpr.set_top_n(10)
alpr.set_default_region("md")
if not alpr.is_loaded():
sys.exit(1)
print("Using OpenALPR " + alpr.get_version())
cap = cv2.VideoCapture(options.Video_Source)
bg_subtractor = cv2.createBackgroundSubtractorMOG2(history=500,
detectShadows=True)
print('Training BG Subtractor...')
cv2.namedWindow('op', cv2.WINDOW_NORMAL)
cnt = 0
while True:
ok, frame = cap.read()
if not ok:
from openalpr import Alpr
import sys
import cv2
alpr = Alpr('us', 'openalpr.conf', 'runtime_data')
if not alpr.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
alpr.set_top_n(20)
alpr.set_default_region("ca")
#img1 = cv2.imread("us-4.jpg",1)
#cv2.imshow('Image',img1)
#cv2.waitKey(0)
results = alpr.recognize_file('us-3.jpg')
i = 0
print results
if len(results['results']) == 0:
print "No results found"
sys.exit()
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']:
def process_video(video, license_plate, _id):
alpr = Alpr('us', ALPR_CONFIG, RUNTIME_DATA)
if not alpr.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
alpr.set_top_n(5)
alpr.set_default_region("md")
def get_output_layers(net):
layer_names = net.getLayerNames()
output_layers = [
layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()
]
return output_layers
def get_info(frame, file_type):
if file_type == 'array':
results = alpr.recognize_ndarray(frame)
else:
results = alpr.recognize_file(frame)
if results['results']:
top_plate = results['results'][0]['candidates'][0]['plate']
confidence = results['results'][0]['candidates'][0]['confidence']
x1 = results["results"][0]["coordinates"][0]["x"]
y1 = results["results"][0]["coordinates"][0]["y"]
x2 = results["results"][0]["coordinates"][2]["x"]
y2 = results["results"][0]["coordinates"][2]["y"]
return [x1, y1, x2, y2], top_plate, confidence
else:
return False
def draw_boxes(regions_of_interest, plate_number, confidence, img):
x, y, x1, y1 = regions_of_interest[0], regions_of_interest[
1], regions_of_interest[2], regions_of_interest[3]
cv2.rectangle(img, (x, y), (x1, y1), (0, 255, 0), 2)
text = "{} {:.1f}%".format(plate_number, confidence)
cv2.putText(img, text, (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX, 1,
(255, 0, 0), 2)
video = cv2.VideoCapture(video)
w, h = None, None
while True:
grabbed, frame = video.read()
if not grabbed:
break
start = time.time()
try:
regions_of_interest, top_plate, confidence = get_info(
frame, 'array')
print(regions_of_interest, top_plate, confidence)
#confirming license plate
if str(top_plate) == license_plate:
draw_boxes(regions_of_interest, top_plate, confidence, frame)
cv2.imwrite(f'{IMAGE_FOLDER}/confirmation{_id}.png', frame)
return f'{IMAGE_FOLDER}/confirmation{_id}.png'
except:
print('License Plate not Detected')
end = time.time()
print(f"[INFO] Processing Time - {end-start}")
video.release()
alpr.unload()
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)
class recognizer(threading.Thread):
min_conf_patternmatch = 75.0
min_conf_nopatternmatch = 85.0
lock = None
def __init__(self,
source_dir,
postproc_hit_dir,
postproc_nohit_dir,
postproc_nohit_lowconf_dir=None,
output_json_dir=None,
output_csv_file=None,
default_region=None,
lock=None):
threading.Thread.__init__(self)
## save the lock (if specified)
## passing in a lock object allows
## multiple recognizer threads to run
## without bumping into each other
self.lock = lock
## check and clean up config
## TODO: use os.path to test files and directories, then raise appropriate errors
self.source_dir = source_dir.rstrip("/")
self.postproc_hit_dir = postproc_hit_dir.rstrip("/")
self.postproc_nohit_dir = postproc_nohit_dir
if (self.postproc_nohit_dir):
self.postproc_nohit_dir = self.postproc_nohit_dir.rstrip("/")
self.postproc_nohit_lowconf_dir = postproc_nohit_lowconf_dir
if (self.postproc_nohit_lowconf_dir):
self.postproc_nohit_lowconf_dir = self.postproc_nohit_lowconf_dir.rstrip(
"/")
else:
self.postproc_nohit_lowconf_dir = self.postproc_nohit_dir
if not (output_json_dir) and not (output_csv_file):
raise (TypeError(
'must specify output_csv_file and/or output_json_dir'))
self.output_json_dir = output_json_dir.rstrip("/")
self.output_csv_file = output_csv_file
print "recognizer:init - initializing alpr"
self.alpr = Alpr("us", "/etc/openalpr/openalpr.conf",
"/usr/share/openalpr/runtime_data")
if not self.alpr.is_loaded():
print("recognizer:init - error loading OpenALPR")
sys.exit(1)
self.alpr.set_top_n(10)
if (default_region):
self.alpr.set_default_region(default_region)
self.running = True
print "recognizer:init - done initializing alpr"
def __del__(self):
print "recognizer:del - unloading alpr"
self.alpr.unload()
print "recognizer:del - done"
def stop(self):
print "recognizer:stop - waiting for recognizer thread to finish"
self.running = False
self.join()
print "recognizer:stop - recognizer thread finished"
def run(self):
tid = self.ident
while (self.running):
sys.stdout.flush()
time.sleep(0.05)
files = sorted(os.listdir(self.source_dir))
# if (len(files) > 0):
# print "recognizer:run[{}] - found {} files in {}".format(tid, len(files), self.source_dir)
for file in files:
# if we're supposed to be shutting down, then break out of the file processing loop
if (self.running == False):
break
matches = []
lowconf_hit = False
# make sure it looks like one of ours
if (not (re.match('^\d+(.*)\.jpg$', file))):
if file == "README" or file.startswith(".") or re.search(
'.lock$', file):
pass # silently ignore lock files and hidden files
else:
print "recognizer:run - ignoring file with bad name {}".format(
file)
else:
# to be thread safe, create a lock file while we process
img_file = self.source_dir + "/" + file
lock_file = img_file + ".lock"
# set up file lock while blocking other threads
try:
if (self.lock):
self.lock.acquire()
# does the file still exist? if not, skip it silently -- another thread processed already
if not (os.path.exists(img_file)):
continue
# is the file already locked? if so, skip it and say something -- could be another thread working on it or could be a stale lock
## TODO: auto remove old locks
try:
lock_stat = os.stat(lock_file)
if lock_stat: # lock file exists
lock_age = time.time() - lock_stat.st_mtime
if (lock_age > STALE_LOCK_AGE):
print "recognizer:run - removing stale lock file ({:.0f}s) for {}".format(
lock_age, file)
os.unlink(lock_file)
else:
continue # file recently locked -- skip it silently
except OSError:
pass # ignore this error -- indicates lock file doesn't exist
# create the lock file
with open(lock_file, "w") as f:
f.write("{}".format(self.ident))
finally:
if (self.lock):
self.lock.release()
# do plate recognition
start_time = time.time()
results = self.alpr.recognize_file(self.source_dir + "/" +
file)
recognize_secs = time.time() - start_time
print "recognizer:run - recognized {:s} in {:.4f}s found {:2d} possible plates".format(
self.source_dir + "/" + file, recognize_secs,
len(results['results']))
# remove lock file
os.remove(lock_file)
# review results
for plate in results['results']:
best_match_plate = None
best_match_template = None
best_match_confidence = 0.0
for candidate in plate['candidates']:
if (candidate['matches_template']):
if (candidate['confidence'] >
self.min_conf_patternmatch
and candidate['confidence'] >
best_match_confidence):
best_match_plate = candidate['plate']
best_match_confidence = candidate[
'confidence']
best_match_template = True
else:
if (candidate['confidence'] >
self.min_conf_nopatternmatch
and candidate['confidence'] >
best_match_confidence):
best_match_plate = candidate['plate']
best_match_confidence = candidate[
'confidence']
best_match_template = False
if (best_match_plate):
print "recognizer:run - best match: {} (confidence: {:.3f}, template: {})".format(
best_match_plate, best_match_confidence,
"yes" if best_match_template else "no")
match = {
'recognize_time':
time.strftime("%Y-%m-%d %H:%M:%S"),
'recognize_epoch_time':
"{:.0f}".format(start_time),
'recognize_secs':
"{:0.4f}".format(recognize_secs),
'plate':
best_match_plate,
'confidence':
"{:0.2f}".format(best_match_confidence),
'matches_template':
best_match_template,
'file':
file
}
matches.append(match)
else:
lowconf_hit = True
print "recognizer:run - insufficient confidence"
# record matches (if any) and move the file away
if (len(matches) > 0):
# extract GPS and other EXIF data, append to match record, then write output
with open(self.source_dir + "/" + file,
'rb') as jpgfile:
tags = exifread.process_file(jpgfile,
details=False)
# extract the image capture date and time
if (tags['EXIF DateTimeOriginal']):
exif_datetimeoriginal = time.strptime(
"{}".format(tags['EXIF DateTimeOriginal']),
'%Y:%m:%d %H:%M:%S')
# extract the GPS coordinates (convert from DMS to DD) and altitude
exif_gpslongitude = 0.0
exif_gpslatitude = 0.0
exif_gpsaltitude = 0
tag_lat = tags['GPS GPSLatitude']
if (tag_lat and len(tag_lat.values) == 3
and tag_lat.values[0].den > 0):
exif_gpslatitude = (
float(tag_lat.values[0].num) /
float(tag_lat.values[0].den)) + (
(float(tag_lat.values[1].num) /
float(tag_lat.values[1].den)) / 60.0
) + ((float(tag_lat.values[2].num) / float(
tag_lat.values[2].den)) / 3600.0)
exif_gpslatitude *= -1 if (str(
tags['GPS GPSLatitudeRef']) == "S") else 1
tag_lon = tags['GPS GPSLongitude']
if (tag_lon and len(tag_lon.values) == 3
and tag_lon.values[0].den > 0):
exif_gpslongitude = (
float(tag_lon.values[0].num) /
float(tag_lon.values[0].den)) + (
(float(tag_lon.values[1].num) /
float(tag_lon.values[1].den)) / 60.0
) + ((float(tag_lon.values[2].num) / float(
tag_lon.values[2].den)) / 3600.0)
exif_gpslongitude *= -1 if (str(
tags['GPS GPSLongitudeRef']) == "W") else 1
tag_altitude = tags['GPS GPSAltitude']
if (tag_altitude
and tag_altitude.values[0].den > 0):
exif_gpsaltitude = float(
tag_altitude.values[0].num) / float(
tag_altitude.values[0].den)
# store EXIF data in match records
for match in (matches):
if (exif_datetimeoriginal):
match[
'capture_epoch_time'] = '{:.0f}'.format(
time.mktime(exif_datetimeoriginal))
match['capture_time'] = time.strftime(
"%Y-%m-%d %H:%M:%S",
exif_datetimeoriginal)
else:
match['capture_epoch_time'] = 0
match['capture_time'] = ''
match['capture_longitude'] = "{:0.7f}".format(
exif_gpslongitude)
match['capture_latitude'] = "{:0.7f}".format(
exif_gpslatitude)
match['capture_altitude_m'] = "{:0.2f}".format(
exif_gpsaltitude)
# write matches to CSV
if (self.output_csv_file):
write_header = False if os.access(
self.output_csv_file, os.F_OK) else True
try:
# only one thread can write to the CSV at a time
if (self.lock):
self.lock.acquire()
with open(self.output_csv_file,
"a") as csvfile:
writer = csv.DictWriter(
csvfile, [
"recognize_time",
"recognize_epoch_time", "plate",
"confidence", "matches_template",
"file", "recognize_secs",
'capture_time',
'capture_epoch_time',
'capture_latitude',
'capture_longitude',
'capture_altitude_m'
])
if (write_header):
writer.writeheader()
writer.writerow(match)
finally:
if (self.lock):
self.lock.release()
# write JSON (each file is unique, so no thread locking needed)
if (self.output_json_dir):
json_file = self.output_json_dir + "/" + file[:file.index(
".jpg")] + ".json"
with open(json_file, "w") as jsonfile:
jsonfile.write(json.dumps(matches))
# move the file
os.rename(self.source_dir + "/" + file,
self.postproc_hit_dir + "/" + file)
elif (lowconf_hit): #insufficient confidence
if (self.postproc_nohit_lowconf_dir):
os.rename(
self.source_dir + "/" + file,
self.postproc_nohit_lowconf_dir + "/" + file)
else:
os.unlink(self.source_dir + "/" + file)
else: #no hit
if (self.postproc_nohit_dir):
os.rename(self.source_dir + "/" + file,
self.postproc_nohit_dir + "/" + file)
else:
os.unlink(self.source_dir + "/" + file)
license_plates = []
# OpenALPR object for license plate detection based on the us configuration
alpr = Alpr(
'us',
'C:/Users/dhruv/Desktop/Git/openalpr-2.3.0-win-64bit/openalpr_64/openalpr.conf',
'C:/Users/dhruv/Desktop/Git/openalpr-2.3.0-win-64bit/openalpr_64/runtime_data'
)
if not alpr.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
alpr.set_top_n(
10
) # Maximum number of unique license plate numbers detected by API per frame
alpr.set_default_region("on") # Set default license plate region to Ontario
print("! starting video capture")
cap = cv2.VideoCapture(0) # OpenCV Video capture
if not cap.isOpened():
alpr.unload()
sys.exit('Failed to open video file!')
curr_plate = '' # Plate currently being read
# initialize a flask object
app = Flask(__name__)
# initialize the video stream and allow the camera sensor to
# warmup
# vs = VideoStream(usePiCamera=1).start()
from openalpr import Alpr
alpr = Alpr("us", "/path/to/openalpr.conf", "/path/to/runtime_data")
if not alpr.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
alpr.set_top_n(20)
alpr.set_default_region("md")
results = alpr.recognize_file("./image/DSCN0416.jpg")
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']))
# Call when completely done to release memory
alpr.unload()
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>")
parser.add_argument('--interval', help='interval between polling for a new image to process', type=int, default=10)
parser.add_argument('--preprocess',
nargs='*',
help='prewarp value to apply against each, and/or the x1,y1,x2,y2 values to crop',
default=[],
action=PreProcessRulesAction)
args = parser.parse_args()
config_path = os.getenv('OPEN_ALPR_CONFIG_PATH')
open_alpr = Alpr(args.country, config_path, "/usr/share/openalpr/runtime_data")
if not open_alpr.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
open_alpr.set_default_region(args.region)
def poll(alpr, input_url, output_url, interval, preprocessing_rules):
if args.verbose:
print("Polling {}".format(input_url))
image = None
try:
image = download_image(input_url)
except urllib.URLError:
eprint("Failed to poll {}".format(input_url))
pass
if image is not None:
alpr_results = process_image(alpr, image, preprocessing_rules)
import sys
import os
import requests
import json
headers = {'content-type': 'application/json'}
url = "http://requestb.in/vd5wylvd"
alpr = Alpr("us", "/etc/openalpr/openalpr.conf",
"/usr/share/openalpr/runtime_data")
if not alpr.is_loaded():
print "Error loading OpenALPR"
sys.exit(1)
alpr.set_top_n(1)
alpr.set_default_region("us")
cap = cv2.VideoCapture(1)
probablePlates = {}
wasPlate = False
numEx = 5
count = 0
while True:
ret, frame = cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
temp = "frame%d.jpg" % ret
cv2.imwrite(temp, frame)
results = alpr.recognize_file(temp)
def main(args):
# Check input arguments
if len(args) < 2:
sys.stderr.write("usage: %s <uri1> [uri2] ... [uriN]\n" % args[0])
sys.exit(1)
global global_alpr_engine
global_alpr_engine = Alpr("eu", "/etc/openalpr/openalpr.conf", "/usr/share/openalpr/runtime_data")
if not global_alpr_engine.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
global_alpr_engine.set_top_n(10)
global_alpr_engine.set_default_region("fi")
for i in range(0,len(args)-1):
fps_streams["stream{0}".format(i)]=GETFPS(i)
number_sources=len(args)-1
# Standard GStreamer initialization
GObject.threads_init()
Gst.init(None)
# Create gstreamer elements
# Create Pipeline element that will form a connection of other elements
print("Creating Pipeline \n ")
pipeline = Gst.Pipeline()
is_live = False
if not pipeline:
sys.stderr.write(" Unable to create Pipeline \n")
print("Creating streamux \n ")
#IK: read stream/mp4 file
# Create nvstreammux instance to form batches from one or more sources.
streammux = Gst.ElementFactory.make("nvstreammux", "Stream-muxer")
if not streammux:
sys.stderr.write(" Unable to create NvStreamMux \n")
pipeline.add(streammux)
#IK: number_sources is important!!!
for i in range(number_sources):
print("Creating source_bin ",i," \n ")
uri_name=args[i+1]
if uri_name.find("rtsp://") == 0 :
is_live = True
source_bin=create_source_bin(i, uri_name)
if not source_bin:
sys.stderr.write("Unable to create source bin \n")
pipeline.add(source_bin)
padname="sink_%u" %i
sinkpad= streammux.get_request_pad(padname)
if not sinkpad:
sys.stderr.write("Unable to create sink pad bin \n")
srcpad=source_bin.get_static_pad("src")
if not srcpad:
sys.stderr.write("Unable to create src pad bin \n")
srcpad.link(sinkpad)
print("Creating Pgie \n ")
#IK: Primary neural net
# Use nvinfer to run inferencing on decoder's output,
# behaviour of inferencing is set through config file
pgie1 = Gst.ElementFactory.make("nvinfer", "primary-inference-1")
if not pgie1:
sys.stderr.write(" Unable to create pgie1 \n")
#IK: tracker
tracker = Gst.ElementFactory.make("nvtracker", "tracker")
if not tracker:
sys.stderr.write(" Unable to create tracker \n")
#IK: secondary network 1
sgie = Gst.ElementFactory.make("nvinfer", "secondary1-nvinference-engine")
if not sgie:
sys.stderr.write(" Unable to make sgie \n")
tiler=Gst.ElementFactory.make("nvmultistreamtiler", "nvtiler")
if not tiler:
sys.stderr.write(" Unable to create tiler \n")
print("Creating nvvidconv \n ")
nvvidconv = Gst.ElementFactory.make("nvvideoconvert", "convertor")
if not nvvidconv:
sys.stderr.write(" Unable to create nvvidconv \n")
# Create OSD to draw on the converted RGBA buffer
nvosd = Gst.ElementFactory.make("nvdsosd", "onscreendisplay")
if not nvosd:
sys.stderr.write(" Unable to create nvosd \n")
nvvidconv_postosd = Gst.ElementFactory.make("nvvideoconvert", "convertor_postosd")
if not nvvidconv_postosd:
sys.stderr.write(" Unable to create nvvidconv_postosd \n")
# Create a caps filter
caps = Gst.ElementFactory.make("capsfilter", "filter")
caps.set_property("caps", Gst.Caps.from_string("video/x-raw(memory:NVMM), format=I420"))
# Make the encoder
if codec == "H264":
encoder = Gst.ElementFactory.make("nvv4l2h264enc", "encoder")
print("Creating H264 Encoder")
elif codec == "H265":
encoder = Gst.ElementFactory.make("nvv4l2h265enc", "encoder")
print("Creating H265 Encoder")
if not encoder:
sys.stderr.write(" Unable to create encoder")
encoder.set_property('bitrate', bitrate)
if is_aarch64():
encoder.set_property('preset-level', 1)
encoder.set_property('insert-sps-pps', 1)
encoder.set_property('bufapi-version', 1)
# Make the payload-encode video into RTP packets
if codec == "H264":
rtppay = Gst.ElementFactory.make("rtph264pay", "rtppay")
print("Creating H264 rtppay")
elif codec == "H265":
rtppay = Gst.ElementFactory.make("rtph265pay", "rtppay")
print("Creating H265 rtppay")
if not rtppay:
sys.stderr.write(" Unable to create rtppay")
#IK: RTSP sink
# Make the UDP sink
updsink_port_num = 5400
sink = Gst.ElementFactory.make("udpsink", "udpsink")
if not sink:
sys.stderr.write(" Unable to create udpsink")
sink.set_property('host', '224.224.255.255')
sink.set_property('port', updsink_port_num)
sink.set_property('async', False)
sink.set_property('sync', 1)
if is_live:
print("Atleast one of the sources is live")
streammux.set_property('live-source', 1)
streammux.set_property('width', 1920)
streammux.set_property('height', 1080)
streammux.set_property('batch-size', 1)
streammux.set_property('batched-push-timeout', 4000000)
#IK: set config file for each network
#Set properties of pgie and sgie
pgie1.set_property('config-file-path', "dstest2_pgie1_config.txt")
sgie.set_property('config-file-path', "dstest2_sgie_config.txt")
tiler.set_property("rows",1)
tiler.set_property("columns",1)
tiler.set_property("width", TILED_OUTPUT_WIDTH)
tiler.set_property("height", TILED_OUTPUT_HEIGHT)
#Set properties of tracker
config = configparser.ConfigParser()
config.read('dstest2_tracker_config.txt')
config.sections()
for key in config['tracker']:
if key == 'tracker-width' :
tracker_width = config.getint('tracker', key)
tracker.set_property('tracker-width', tracker_width)
if key == 'tracker-height' :
tracker_height = config.getint('tracker', key)
tracker.set_property('tracker-height', tracker_height)
if key == 'gpu-id' :
tracker_gpu_id = config.getint('tracker', key)
tracker.set_property('gpu_id', tracker_gpu_id)
if key == 'll-lib-file' :
tracker_ll_lib_file = config.get('tracker', key)
tracker.set_property('ll-lib-file', tracker_ll_lib_file)
if key == 'll-config-file' :
tracker_ll_config_file = config.get('tracker', key)
tracker.set_property('ll-config-file', tracker_ll_config_file)
if key == 'enable-batch-process' :
tracker_enable_batch_process = config.getint('tracker', key)
tracker.set_property('enable_batch_process', tracker_enable_batch_process)
#IK: populate pipeline
print("Adding elements to Pipeline \n")
pipeline.add(streammux)
pipeline.add(pgie1)
pipeline.add(tracker)
pipeline.add(sgie)
pipeline.add(tiler)
pipeline.add(nvvidconv)
pipeline.add(nvosd)
pipeline.add(nvvidconv_postosd)
pipeline.add(caps)
pipeline.add(encoder)
pipeline.add(rtppay)
pipeline.add(sink)
#IK: elements linked together
# we link the elements together
# file-source -> h264-parser -> nvh264-decoder ->
# nvinfer -> nvvidconv -> nvosd -> video-renderer
print("Linking elements in the Pipeline \n")
streammux.link(pgie1)
pgie1.link(tracker)
tracker.link(sgie)
sgie.link(tiler)
tiler.link(nvvidconv)
nvvidconv.link(nvosd)
nvosd.link(nvvidconv_postosd)
nvvidconv_postosd.link(caps)
caps.link(encoder)
encoder.link(rtppay)
rtppay.link(sink)
# create and event loop and feed gstreamer bus mesages to it
loop = GObject.MainLoop()
bus = pipeline.get_bus()
bus.add_signal_watch()
bus.connect ("message", bus_call, loop)
# Start streaming
rtsp_port_num = 8554
server = GstRtspServer.RTSPServer.new()
server.props.service = "%d" % rtsp_port_num
server.attach(None)
factory = GstRtspServer.RTSPMediaFactory.new()
factory.set_launch( "( udpsrc name=pay0 port=%d buffer-size=524288 caps=\"application/x-rtp, media=video, clock-rate=90000, encoding-name=(string)%s, payload=96 \" )" % (updsink_port_num, codec))
factory.set_shared(True)
server.get_mount_points().add_factory("/ds-test", factory)
print("\n *** DeepStream: Launched RTSP Streaming at rtsp://localhost:%d/ds-test ***\n\n" % rtsp_port_num)
# Lets add probe to get informed of the meta data generated, we add probe to
# the sink pad of the osd element, since by that time, the buffer would have
# had got all the metadata.
sink_pad = nvosd.get_static_pad("sink")
if not sink_pad:
sys.stderr.write(" Unable to get sink pad \n")
else:
#IK: Custom method call to display data on screen
sink_pad.add_probe(Gst.PadProbeType.BUFFER, osd_sink_pad_buffer_probe, 0)
print("Starting pipeline \n")
# start play back and listed to events
pipeline.set_state(Gst.State.PLAYING)
try:
loop.run()
except:
pass
# cleanup
pipeline.set_state(Gst.State.NULL)
import os
import requests
import json
# import paho.mqtt.client as client
headers = {'content-type': 'application/json'}
url = "http://requestb.in/vd5wylvd"
alpr = Alpr("us", "/etc/openalpr/openalpr.conf",
"/usr/share/openalpr/runtime_data")
if not alpr.is_loaded():
print "Error loading OpenALPR"
sys.exit(1)
alpr.set_top_n(1)
alpr.set_default_region("us")
cap = cv2.VideoCapture(0)
# mqttc = client.Client()
# mqttc.connect("localhost", 1883, 60)
probablePlates = {}
wasPlate = False
numEx = 5
count = 0
while True:
ret, frame = cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
temp = "frame%d.jpg" % ret
import sys
import cv2
import time
video = "../../Images/vid1.mp4"
alpr = Alpr("in", "/usr/local/share/openalpr/config/openalpr.defaults.conf", "./openalpr/runtime_data")
if not alpr.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
# select top 10 results
alpr.set_top_n(10)
alpr.set_default_region("in")
cap = cv2.VideoCapture(video)
# for smooth termination after video ends
frame_counter = 0
length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
print(length)
start_time = time.time()
while(frame_counter < length):
ret,frame = cap.read()
frame_counter += 3
results = alpr.recognize_ndarray(frame)
from openalpr import Alpr
import sys
alpr = Alpr("eu", "nplate_train/openalpr.conf.in", "nplate_train/runtime_data")
if not alpr.is_loaded():
print("Error loading OpenALPR")
sys.exit(1)
#alpr.set_top_n(20)
alpr.set_default_region("eu")
results = alpr.recognize_file("/home/riaz/Desktop/hack/2009_09_08_drive_0010/I1_000388.png")
for plate in results['results']:
if len(plate['candidates']) > 0:
print "Found: %12s %12f" % ( plate['candidates'][0]['plate'],plate['candidates'][0]['confidence'])
# Call when completely done to release memory
alpr.unload()
class LprRunner(NDUCameraRunner):
def __init__(self, config, _connector_type):
super().__init__()
self.counter = 0
self._send_data = config.get("send_data", False)
city_codes_fn = "/data/city_codes.json"
if not os.path.isfile(city_codes_fn):
city_codes_fn = os.path.dirname(
os.path.abspath(__file__)) + city_codes_fn.replace(
"/", os.path.sep)
with open(city_codes_fn, encoding="UTF-8") as f_in:
self._cities = json.load(f_in)
conf_fn = "/data/openalpr_64/openalpr.conf"
#conf_fn = "//usr/local/share/openalpr/config/openalpr.defaults.conf"
# conf_fn = "/data/openalpr_64/runtime_data/config/eu.conf"
if not os.path.isfile(conf_fn):
conf_fn = os.path.dirname(
os.path.abspath(__file__)) + conf_fn.replace("/", os.path.sep)
runtime_data = "/data/openalpr_64/runtime_data/"
#runtime_data = "/usr/local/share/openalpr/runtime_data/"
if not os.path.isdir(runtime_data):
runtime_data = os.path.dirname(
os.path.abspath(__file__)) + runtime_data.replace(
"/", os.path.sep)
# self._alpr = Alpr("us", "/path/to/openalpr.conf", "/path/to/runtime_data")
# self._alpr = Alpr("eu", conf_fn, runtime_data)
self._alpr = Alpr("tr", conf_fn, runtime_data)
if not self._alpr.is_loaded():
print("Error loading OpenALPR")
# self._alpr.set_top_n(20)
# self._alpr.set_default_region("md")
# self._alpr.set_top_n(1)
self._alpr.set_default_region("tr")
self._alpr.set_country("tr")
# region lp detection,
onnx_fn = "/data/yolov4-tiny_lp_416_static.onnx"
self.input_size = 416
if not os.path.isfile(onnx_fn):
onnx_fn = os.path.dirname(
os.path.abspath(__file__)) + onnx_fn.replace("/", os.path.sep)
classes_filename = "/data/class.names"
if not os.path.isfile(classes_filename):
classes_filename = os.path.dirname(
os.path.abspath(__file__)) + classes_filename.replace(
"/", os.path.sep)
self.class_names = ["lp"]
self.sess_tuple = onnx_helper.get_sess_tuple(onnx_fn)
# endregion
def get_name(self):
return "lpr"
def get_settings(self):
settings = {}
return settings
def process_frame(self, frame, extra_data=None):
def to_bbox(coordinates, rect_, rh_, rw_):
x1 = coordinates[0]["x"] * rw_
y1 = coordinates[0]["y"] * rh_
x2 = coordinates[2]["x"] * rw_
y2 = coordinates[2]["y"] * rh_
if rect_ is not None:
x1 += rect_[1]
y1 += rect_[0]
x2 += rect_[1]
y2 += rect_[0]
return [y1, x1, y2, x2]
def enumerate_images(frame_):
result = yolo_helper.predict_v4(self.sess_tuple, self.input_size,
self.class_names, frame)
for _class_name, _score, rect0, item_ in NDUUtility.enumerate_result_items(
result, return_item=True):
rect1 = geometry_helper.add_padding_rect(rect0, 0.5)
yield image_helper.crop(frame, rect1), rect0, item_
res = []
for image, rect, item in enumerate_images(frame):
h0, w0 = image_helper.image_h_w(image)
# def order_points(pts):
# # initialzie a list of coordinates that will be ordered
# # such that the first entry in the list is the top-left,
# # the second entry is the top-right, the third is the
# # bottom-right, and the fourth is the bottom-left
# rect = np.zeros((4, 2), dtype="float32")
#
# # the top-left point will have the smallest sum, whereas
# # the bottom-right point will have the largest sum
# s = pts.sum(axis=1)
# rect[0] = pts[np.argmin(s)]
# rect[2] = pts[np.argmax(s)]
#
# # now, compute the difference between the points, the
# # top-right point will have the smallest difference,
# # whereas the bottom-left will have the largest difference
# diff = np.diff(pts, axis=1)
# rect[1] = pts[np.argmin(diff)]
# rect[3] = pts[np.argmax(diff)]
#
# # return the ordered coordinates
# return rect
#
# def four_point_transform(image, pts):
# # obtain a consistent order of the points and unpack them
# # individually
# rect = order_points(pts)
# (tl, tr, br, bl) = rect
#
# # compute the width of the new image, which will be the
# # maximum distance between bottom-right and bottom-left
# # x-coordiates or the top-right and top-left x-coordinates
# widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))
# widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))
# maxWidth = max(int(widthA), int(widthB))
#
# # compute the height of the new image, which will be the
# # maximum distance between the top-right and bottom-right
# # y-coordinates or the top-left and bottom-left y-coordinates
# heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))
# heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))
# maxHeight = max(int(heightA), int(heightB))
#
# # now that we have the dimensions of the new image, construct
# # the set of destination points to obtain a "birds eye view",
# # (i.e. top-down view) of the image, again specifying points
# # in the top-left, top-right, bottom-right, and bottom-left
# # order
# dst = np.array([
# [0, 0],
# [maxWidth - 1, 0],
# [maxWidth - 1, maxHeight - 1],
# [0, maxHeight - 1]], dtype="float32")
#
# # compute the perspective transform matrix and then apply it
# M = cv2.getPerspectiveTransform(rect, dst)
# warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight))
# return warped
#
# def deskew(image):
# gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# gray = cv2.bitwise_not(gray)
# thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
# coords = np.column_stack(np.where(thresh > 0))
# angle = cv2.minAreaRect(coords)[-1]
# if angle < -45:
# angle = -(90 + angle)
# else:
# angle = -angle
# (h, w) = image.shape[:2]
# center = (w // 2, h // 2)
# M = cv2.getRotationMatrix2D(center, angle, 1.0)
# return cv2.warpAffine(image, M, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)
#
# # def remove_noise_and_smooth(file_name):
# # img = cv2.imread(file_name, 0)
# # filtered = cv2.adaptiveThreshold(img.astype(np.uint8), 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 9, 41)
# # kernel = np.ones((1, 1), np.uint8)
# # opening = cv2.morphologyEx(filtered, cv2.MORPH_OPEN, kernel)
# # closing = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, kernel)
# # img = image_smoothening(img)
# # or_image = cv2.bitwise_or(img, closing)
# # return or_image
#
# # image = deskew(image)
# # image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
h1, w1 = image_helper.image_h_w(image)
while w1 < 400:
image = cv2.pyrUp(image)
h1, w1 = image_helper.image_h_w(image)
# cv2.imshow("lpr", image)
# cv2.waitKey(500)
success, encoded_image = cv2.imencode('.jpg', image)
content2 = encoded_image.tobytes()
results = self._alpr.recognize_array(content2)
added = False
#print("LPR: ", item.get(constants.RESULT_KEY_RECT))
for plate in results['results']:
txt = plate["plate"]
if len(txt) > 2:
score = plate["confidence"] / 100.0
if score > 0.01:
city_code = txt[0:2]
city_name = None
if city_code in self._cities:
city_name = self._cities[city_code]
if city_name is None:
class_name = "PL: {}".format(txt)
else:
class_name = "PL: {} {}".format(city_name, txt)
val = {
constants.RESULT_KEY_RECT: rect,
constants.RESULT_KEY_SCORE: score,
constants.RESULT_KEY_CLASS_NAME: class_name
}
if self._send_data:
if city_name is None:
val[constants.RESULT_KEY_DATA] = {"pl": txt}
else:
val[constants.RESULT_KEY_DATA] = {
"pl": txt,
"city": city_name
}
res.append(val)
added = True
if not added:
val = {
constants.RESULT_KEY_RECT: rect,
constants.RESULT_KEY_SCORE: 0,
constants.RESULT_KEY_CLASS_NAME: "PL: "
}
res.append(val)
return res
