class NplateExtraction: def __init__(self, confgpath): self.confgpath = confgpath config = ConfigParser() config.read(self.confgpath) self.confsect = config['NPEConfig'] self.alprconfig = self.confsect['alprconfig'] self.alprruntime = self.confsect['alprruntime'] self.imagepath = self.confsect['objImage'] self.alpr = Alpr("us", self.alprconfig, self.alprruntime) self.alpr.set_top_n(4) #self.alpr.set_default_region("us") print(self.alpr.is_loaded()) if not self.alpr.is_loaded(): print("Error loading OpenALPR") sys.exit(1) #print(self.alprconfig) def getplate(self, imagepath): results = self.alpr.recognize_file(imagepath) xtop = results['results'][0]['coordinates'][0]['x'] ytop = results['results'][0]['coordinates'][0]['y'] width = int(results['results'][0]['coordinates'][1]['x']) - int(xtop) height = int(results['results'][0]['coordinates'][3]['x']) - int(ytop) retresult = { "plate": results['results'][0]['candidates'][0]['plate'], "confidence": results['results'][0]['candidates'][0]['confidence'], "xtop": xtop, "ytop": ytop, "width": width, "height": height } return json.dumps( retresult, indent=4 ) #(results['results'][0]['candidates'][0],results['results'][0]['coordinates'])
def recognise(image: str) -> str: """ Args: image(str): Image path Returns: Plate number string """ # TODO: To find a way to merge open_alpr with open_alpr_window by making the config paths platform independent # Change this paths correspondingly config_file = 'C:\\Users\\Ani\\Downloads\\openalpr\\openalpr-2.3.0\\config\\openalpr.conf.defaults' runtime_dir = "C:\\Users\\Ani\\Downloads\\openalpr\\openalpr-2.3.0\\runtime_data" alpr = Alpr('eu', config_file, runtime_dir) if not alpr.is_loaded(): print("Error loading OpenALPR") sys.exit(1) alpr.set_top_n(1) results = alpr.recognize_file(image) plate_number = results['results'][0]['plate'][-7:] if plate_number: return plate_number return "Plate number not found"
def scan(): # change definitions to define parameters of openalpr subprocess.call( "fswebcam -r 1920x1080 -S 20 --set brightness=50% --no-banner /home/pi/Desktop/BruinLabsParking/license_plate.jpg", shell=True) alpr = Alpr(location, config_path, runtime_path) if not alpr.is_loaded(): print("Failed to load OpenALPR") sys.exit() plates = alpr.recognize_file("license_plate.jpg") # checks if there is car in frame else returns if len(plates['results']) == 0: return else: # return the top 3 candidates candidates = [ plates['results'][0]['candidates'][i]['plate'] for i in range(0, 3) ] return candidates alpr.unload()
def recognize(): global first_plate alpr = Alpr("auwide", "openalpr/config/openalpr.conf", "openalpr/runtime_data") if not alpr.is_loaded(): print("Error loading OpenALPR") sys.exit(1) alpr.set_top_n(1) #alpr.set_default_region("vic") results = alpr.recognize_file("test_out.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'])) first_plate = candidate['plate'] # Call when completely done to release memory alpr.unload()
def detect(path): alpr = Alpr("us", "/etc/openalpr/openalp.conf", "/usr/share/openalpr/runtime_data") if not alpr.is_loaded(): print("Error loading OpenALPR") sys.exit(1) alpr.set_top_n(20) #top candidates alpr.set_default_region("ca") #default region results = alpr.recognize_file(path) largestPlate = None largestArea = 0 for plate in results['results']: coords = plate['coordinates'] topLeft = coords[0] bottomRight = coords[2] w = bottomRight['x'] - topLeft['x'] h = bottomRight['y'] - topLeft['y'] prevArea = largestArea largestArea = max(w * h, largestArea) if (prevArea != largestArea): largestPlate = plate # Call when completely done to release memory alpr.unload() if largestPlate == None: return [] return largestPlate['candidates']
def process(): alpr = Alpr(REGION, OPENALPR_CONF, RUNTIME_DIR) if not alpr.is_loaded(): LOGGER.info("Error loading OpenALPR") sys.exit(1) # 5 cikarimda bulun alpr.set_top_n(5) results = alpr.recognize_file(ARGS['image']) i = 0 for plate in results['results']: i += 1 print("Plaka #%d" % i) print(" %12s %12s" % ("Plaka", "Dogruluk")) 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()
class Plate: def __init__(self): self.alpr = Alpr("eu", "/etc/openalpr/conf", "/usr/share/openalpr/runtime_data") if not self.alpr.is_loaded(): print("Erro ao carregar o ALPR..") sys.exit(1) self.alpr.set_top_n(10) self.alpr.set_default_region("") def plate_ocr(self, placa): results = self.alpr.recognize_file(placa) i = 0 plate = "" for plate in results['results']: i += 1 for candidate in plate['candidates']: if candidate['matches_template']: prefix = "*" teste = candidate['plate'] x = re.search('^[A-Z]{3}[0-9]{1}[A-Z]{1}[0-9]{2}', teste) if (x): plate = candidate['plate'] #return plate break self.alpr.unload() if (plate != ""): print(plate) return plate
class MariaBack: def __init__(self): self.alpr = Alpr("mx", "/etc/openalpr/openalpr.conf", "/usr/share/openalpr/runtime_data") if not self.alpr.is_loaded(): print("Error loading OpenALPR") sys.exit(1) self.alpr.set_top_n(3) def startWatchingaBack(self): cap = cv2.VideoCapture(0) while(True): ret, frame = cap.read() filename = "temp2.jpg" time.sleep(5) cv2.imwrite(filename, frame) results = self.alpr.recognize_file("./temp2.jpg") if len(results['results']) != 0: yield results['results'] if cv2.waitKey(1) & 0xFF == ord('q'): break def sendRecognizedPlateBack(self, plate): r = requests.post("http://192.168.0.10:80/maria/recognize-plate/?username=BenjaminGuzman&password=MariaUribe&plate={}".format(plate), auth=("BenjaminGuzman", "MariaUribe")) print(r.status_code) print("Esta es la respuesta del servido "+str(r.text)) if r.text != "true": return 0 return 1
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 numplate(image_path, num_coincidence=10): ''' Retorna los patrones encontrados en la imagen que se ingresa y que concuerdan con el archivo de patrones que configuramos anteriormente. Parameters ---------- image_path: Recibe el path de la imagen a procesar (obligatorio) num_coincidence: El numero de patrones posibles que deseamos analizar (no es obligatorio, por default es 10) Returns ------- De salida nos entrega una lista con diccionarios con los patrones posibles y su porcentaje de coincidencia ''' alpr = Alpr(COUNTRY_CODE, CONF_PATH, RUNTIME_PATH) if not alpr.is_loaded(): print('Error cargando openALPR') sys.exit(1) alpr.set_top_n(num_coincidence) alpr.set_default_region(REGION_CODE) results = alpr.recognize_file(image_path) correct_plates = [] for plate in results['results']: correct_plates = get_candidates(plate) alpr.unload() return correct_plates
def Alpr_run(): camera = PiCamera() camera.resolution = (1920, 1080) # TODO: change these depending on platform alpr = Alpr("us", "/home/zib/Senior-Design-ALPR/src/build/config/openalpr.conf", "/home/zib/Senior-Design-ALPR/runtime_data") if not alpr.is_loaded(): print("Error loading OpenALPR") foundmatch[0] = 7 sys.exit(1) alpr.set_top_n(10) try: while True: camera.capture('/home/zib/plates/image.jpg') results = alpr.recognize_file("/home/zib/plates/image.jpg") if foundmatch[0] == 8: alpr.unload() #print "Thead exitted" sys.exit() for plate in results['results']: if foundmatch[0] == 8: alpr.unload() #print "Thead exitted" sys.exit() for candidate in plate['candidates']: if candidate['confidence'] >= 85: # hit_index will be used by the gui to fill in the desired info for display when a match occurs # May or may not be useful if separate processes between gui and this hit_index = 0 for entry in dBase: if candidate['plate'] == entry['plate']: # XXX: Location to add logging, like copy picture, or add to a log file #Conditional works as both a lock and the signal to wake the thread back up alprwake.acquire() foundmatch[0] = 1 foundindex[0] = hit_index alprwake.wait() #Sleeps till notified alprwake.release() break else: hit_index += 1 if foundmatch[0] == 8: alpr.unload() #print "Thead exitted" sys.exit() alpr.unload() #print "Thead exitted" except KeyboardInterrupt: alprwake.acquire() foundmatch[0] = 7 alprwake.release() alpr.unload() #print "Thread exitted" sys.exit()
def main(): global license_plates 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) alpr.set_default_region("on") cap = cv2.VideoCapture(0) if not cap.isOpened(): alpr.unload() sys.exit('Failed to open video file!') curr_plate = '' while cap.isOpened(): ret, frame = cap.read() cv2.imshow('frame', frame) frame = cv2.resize(frame, (1280, 780)) cv2.imwrite('temp.png', frame) results = alpr.recognize_file("temp.png") array_of_plates = [] for plate in results['results']: for candidate in plate['candidates']: if candidate['matches_template']: array_of_plates.append( [candidate['plate'], candidate['confidence']]) if len(array_of_plates) > 0: plate = array_of_plates[0][0] max_confidence = array_of_plates[0][1] for i in array_of_plates: if i[1] > max_confidence: print("MAX") max_confidence = i[1] plate = i[0] license_plates.append(plate) print("{} {}".format(plate, max_confidence)) if len(license_plates) >= 36: print("License Plate Detected: {}".format( most_frequent(license_plates))) license_plates = [] if cv2.waitKey(1) == 27: break cv2.destroyAllWindows() cap.release() alpr.unload()
def main(webpage_to_scrape, database_config): alpr = Alpr("eu", "/config/alprd.conf.defaults", "/Users/matejsamler/Downloads/openalpr-master/runtime_data") if not alpr.is_loaded(): print "Error loading OpenALPR" return -1 con = mysql.connector.connect(**database_config) cursor = con.cursor() alpr.set_top_n(20) alpr.set_default_region("md") results = alpr.recognize_file(sys.argv[1]) most_likely_plate = "" for plate in results['results']: for candidate in plate['candidates']: if candidate['confidence'] == plate['confidence']: most_likely_plate = candidate['plate'] webpage_to_scrape = webpage_to_scrape + most_likely_plate try: soup = BeautifulSoup(urllib2.urlopen(webpage_to_scrape), "html.parser") except urllib2.HTTPError: con.commit() cursor.close() con.close() alpr.unload() return -1 else: information_table = soup.findAll("div", class_="col1") indatabasequerry = "SELECT * FROM cars WHERE Plate = '" + most_likely_plate + "'" querry = "INSERT INTO `cars` (`Plate`, `Region`, `Insurance`, `Duration`, `Type`, `Brand`) VALUES ('" + most_likely_plate + "'" cursor.execute(indatabasequerry) rows = cursor.fetchall() if len(rows) > 0: return rows[0][0] else: for information in make_information_list(information_table): querry = querry + " ,'" + information + "'" querry = querry + ");" cursor.execute(querry) con.commit() cursor.execute(indatabasequerry) rows = cursor.fetchall() if len(rows) > 0: return rows[0][0] # Call when completely done to release memory cursor.close() con.close() alpr.unload()
def get_license(file_name): l = [] alpr = Alpr('us', '/etc/openalpr/openalpr.conf', '/usr/share/openalpr/runtime_data') results = alpr.recognize_file(file_name) if len(results['results']) == 0: print("Can't find a plate in image:", file_name) else: for i in range(len(results['results'][0]['candidates'])): l.append([results['results'][0]['candidates'][i]['plate'],results['results'][0]['candidates'][i]['confidence']]) return l
def get_plate_alpr(img_path): openalprConf = r"F:\Kerja\PT AGIT\Bootcamp\AGIT Bootcamp Task\OJT\openalpr64-sdk-2.8.101\openalpr.conf" openalprRuntimeData = r"F:\Kerja\PT AGIT\Bootcamp\AGIT Bootcamp Task\OJT\openalpr64-sdk-2.8.101\runtime_data" alpr = Alpr("id", openalprConf, openalprRuntimeData) if not alpr.is_loaded(): print("Error loading OpenALPR") sys.exit(1) results = alpr.recognize_file(img_path) # alpr.unload() return results
def scan(): try: print("Starting scan") # Send information over carplateNum = "" carplateList = [] # Take Photo print("Taking picture") cam = PiCamera() cam.start_preview() time.sleep(2) pictime = datetime.datetime.now() picname = pictime.strftime( "/home/pi/Desktop/%Y-%m-%d_%H-%M-%S_pic.jpg") cam.capture(picname) cam.stop_preview() cam.close() # Scan with ALPR print("Scanning picture") result = ["0"] alpr = Alpr("eu", "/etc/openalpr/openalp.conf", "/usr/share/openalpr/runtime_data") if not alpr.is_loaded(): print("Failed to load OpenALPR", "error") result[0] = "-1" return result results = alpr.recognize_file(picname) if os.path.exists(picname): os.remove(picname) else: print("The file does not exist") if len(results['results']) > 0: # Print out carplates for plate in results['results']: for candidate in plate['candidates']: carplateNum = candidate['plate'] # TODO: Filter irrelevant carplate result before sending to note carplateList.append(carplateNum) print(carplateList) response = requests.post(url=endpoint, json={'carplates': carplateList}) # Print out status code print(response) # Print out the information sent over except Exception: print("error") return
def add_shot_by_creenj(number, image, current_plate): setlocale(0, "C") db = Database() logger.info('So, here we get vals from queue at creenj') logger.info(number + '\n' + current_plate + '\n' + image) logging.info('from gf_sqlite_creenj, so number is %s' % number) if number == '': try: alpr = Alpr('eu', '/usr/share/openalpr/config/openalpr.defaults.conf', '/usr/share/openalpr/runtime_data') print("Camed to ALPR") if not alpr.is_loaded(): print("Error loading OpenALPR") sys.exit(1) alpr.set_top_n(20) alpr.set_default_region("lt") results = alpr.recognize_file(image) answer = results['results'][0]['plate'] alpr.unload() except Exception as e: print('Couldn\'t load ALPR') answer = 'Unsolved' return if answer == '': return print('creenj Answer is ', answer) json_obj = { 'number': answer, 'image': image, 'current_plate': current_plate } conn = sqlite3.connect(config.DB_PATH) c = conn.cursor() query = 'INSERT INTO ' + db.SHOTS_TABLE_NAME + ' VALUES (?,?,?)' values = [json_obj['number'], json_obj['current_plate'], json_obj['image']] values = list(map( str, values)) # conversion of int (values[0]) to str is ok here c.executemany(query, [values]) # actually executes only once conn.commit() # apply changes c.close() conn.close() logger.info('So, it should be in DB')
class ManFirebase(): global url, write_data, accuracy, lpn, region, topn, plate_link, config, child def __init__(self): self.config = config self.child = child #### self.firebase = pyrebase.initialize_app(self.config) self.db = self.firebase.database() self.write_data = write_data self.accuracy = accuracy self.lpn = lpn self.post_date = strftime("%a, %d %b %Y %H:%M:%S", gmtime()) self.region = region self.topn = topn self.plate_link = plate_link self.start = 0 self.alpr = Alpr(self.region, './conf/def_one.defaults', './openalpr/runtime_data') self.alpr.set_top_n(self.topn) self.alpr.set_default_region('md') def get_data(self): self.data = self.db.child(self.child).get() print(self.data) def write(self): new_car = { 'accuracy': self.accuracy, 'date': self.post_date, 'lpn': self.lpn } self.db.child(self.child).push(new_car) print(new_car) def recognize_plates(self): self.plate_result = self.alpr.recognize_file(self.plate_link) for plate_number in self.plate_result['results']: self.start += 1 for candiate in plate_number['candidates']: self.lpn = candiate['plate'] self.accuracy = candiate['confidence'] self.alpr.unload() if self.lpn == '': print("No plates recognozed") sys.exit(1) self.write()
def recognizePlate(self): self.camera.capture('images/1.jpg') 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(20) alpr.set_default_region("md") results = alpr.recognize_file("images/1.jpg") nPos = 2 sepPos = [259, 480] tmpPlate = {} i = 0 for plate in results['results']: i += 1 x = plate['coordinates'][0]['x'] number = plate['candidates'][0]['plate'] tmpPlate[x] = number print( "Plate #%d, (%d,%d)(%d,%d)" % (i, plate['coordinates'][0]['x'], plate['coordinates'][0]['y'], plate['coordinates'][1]['x'], plate['coordinates'][1]['y'])) print(" %12s %12s" % ("Plate", "Confidence")) for candidate in plate['candidates']: print(" %12s%12f" % (candidate['plate'], candidate['confidence'])) sortedKey = sorted(tmpPlate) res = {1: "", 2: "", 3: ""} nPlate = len(tmpPlate) pos = 0 keyIndex = 0 while pos < nPos and keyIndex < nPlate: if sepPos[pos] > sortedKey[keyIndex]: res[pos + 1] = tmpPlate[sortedKey[keyIndex]] keyIndex += 1 pos += 1 while keyIndex < nPlate: res[pos + 1] = tmpPlate[sortedKey[keyIndex]] keyIndex += 1 pos += 1 # alpr.unload() print(res) return res
class PlateProcessorThread(threading.Thread): def __init__(self, metadata, thread_number=0, total_threads=1): global processing_threads threading.Thread.__init__(self) self.metadata = metadata self.thread_number = thread_number self.total_threads = total_threads self.complete = False def run(self): global processing_threads bench_config = os.path.join(SCRIPT_DIR, "config/bench.conf") self.alpr = Alpr(options.country, bench_config, "/usr/share/openalpr/runtime_data/") print("Initiating thread #%d" % (self.thread_number)) counter = 0 for plate in self.metadata: image_path = os.path.join(options.folder, plate['image_file']) if counter % self.total_threads != self.thread_number: # Skip this because another thread is processing it counter += 1 continue counter += 1 if self.thread_number == 0: print "Processing %d / %d" % (counter, len(self.metadata)) if not os.path.isfile(image_path): print "Could not find: %s" % (image_path) sys.exit(1) results = self.alpr.recognize_file(image_path) # print json.dumps(results, indent=2) threadLock.acquire() for result in results['results']: benchstats.add_result(plate['image_file'], result) threadLock.release() threadLock.acquire() processing_thread_status[self.thread_number] = 0 threadLock.release() self.complete = True print "Thread %d complete" % (self.thread_number)
def identifica_us_eu(str_padrao): autorizado = False alpr = Alpr(str_padrao, "openalpr.conf", "runtime_data") if not alpr.is_loaded(): print("Error loading OpenALPR") sys.exit(1) alpr.set_top_n(1) alpr.set_default_region("md") results = alpr.recognize_file( "/home/marcos/Desktop/prototipo 3/placas mercosul/4.jpg") i = 0 for plate in results['results']: i += 1 for candidate in plate['candidates']: prefix = "-" if candidate['matches_template']: prefix = "*" licPlate = results print(" %s %12s%12f" % (prefix, candidate['plate'], candidate['confidence'])) obj = json.load(open("cadastros.json")) for i in xrange(len(obj)): if obj[i]["id"] == candidate[ 'plate']: # se encontrar no cadastro grava entrada autorizado = True with open('entradas.json') as data_file: old_data = json.load(data_file) data = [{ "placa": candidate['plate'], "dia": time.strftime("%d/%m/%Y"), "hora": time.strftime("%H:%M:%S"), "liberadopor": "Open VCR" }] data = old_data + data path = '/home/marcos/Desktop/prototipo 3' filePathNameWExt = path + '/' + 'entradas' + '.json' with open(filePathNameWExt, 'w') as fp: json.dump(data, fp) break if autorizado: print(" %12s %12s" % ("Placa", "Certeza")) print(" %s %12s%12f" % (prefix, candidate['plate'], candidate['confidence'])) # printa dentro da funcao, so para demonstrar que identifica a placa, no final nao ira precisar desse print return autorizado
def callback(ch, method, properties, body): obj1, obj2, obj3 = pickle.loads(body) f = open(obj1, "wb") f.write(obj3) f.close() image = Image.open(obj1) exif_data = GetLatLon.get_exif_data(image) print(GetLatLon.get_lat_lon(exif_data)) latlon = GetLatLon.get_lat_lon(exif_data) list1.append(latlon) alpr = Alpr('us', '/etc/openalpr/openalpr.conf', '/usr/share/openalpr/runtime_data') results = alpr.recognize_file(obj1) if len(results['results']) == 0: print("Can't find a plate") else: count = 0 # print(results['results'][0]['candidates'][0]) licensename = results['results'][0]['candidates'][0]['plate'] for key in results['results'][0]['candidates']: if (count <= 3): list1.append((key['plate'], key['confidence'])) print("Most likely plate is", key['confidence']) print("Most likely confidence is", key['plate']) count = count + 1 redisHash = redis.Redis(host="redis", db=1) redisHash.set(obj2, pickle.dumps(list1)) list1.clear() print("Redis get by Hash Value") print(obj2) val1 = pickle.loads(redisHash.get(obj2)) print(val1) redisName = redis.Redis(host="redis", db=2) redisName.set(obj1, obj2) print("Redis get by Name") print(obj1) val2 = redisName.get(obj1) print(val2) if (len(results['results']) != 0): redisLicense = redis.Redis(host="redis", db=3) redisLicense.set(licensename, obj2) print("Redis get by License") print(licensename) val3 = redisLicense.get(licensename) print(val3)
def find_images(Filename, car_where): #while(True): alpr = Alpr("kr", "/etc/openalpr/openalpr.conf", "/usr/local/share/openalpr/runtime_data") print("find_image arrive") 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(Filename) i = 0 car_info = [] if (results['results'] == []): return for plate in results['results']: i += 1 print("Plate #%d" % i) print(" %12s %12s" % ("Plate", "Confidence")) #print plate for candidate in plate['candidates']: #plate의 갯수대로 #print"plate",plate['candidates'] prefix = "-" if candidate['matches_template']: prefix = "*" print(" %s %12s%12f" % (prefix, candidate['plate'], candidate['confidence'])) #max =candidate['confidence'] car_info.append(candidate['plate'].encode("UTF-8")) print "car_info", str(car_info[0]) #print(accuracy) #print(car_full_info) car_1st_info = str(car_info[0]) car_string = car_1st_info[:5] car_number = car_1st_info[5:] print car_string, car_number, car_where send_data.send_server(Filename, car_1st_info, car_string, car_number, car_where) # Call when completely done to release me mory alpr.unload()
def get_regions_occupied_by_license_plates(image_path: str, model_region: str="eu") -> List[Polygon]: openalpr_recognizer = Alpr(model_region, "/usr/local/etc/openalpr/openalpr.conf", "/usr/local/Cellar/openalpr/HEAD-de93f21_1/share/openalpr/runtime_data/") if not openalpr_recognizer.is_loaded(): print("Error loading OpenALPR") sys.exit(1) results = openalpr_recognizer.recognize_file(image_path) license_plate_regions = [result['coordinates'] for result in results['results']] license_plate_regions_as_tuples = [[(point['x'], point['y']) for point in region] for region in license_plate_regions] openalpr_recognizer.unload() # release memory return license_plate_regions_as_tuples
def detectPlate(): alpr = Alpr("eu", "/path/to/openalpr.conf", "/home/pi/openalpr/runtime_data") if not alpr.is_loaded(): print "Erro! Verifique se a lib Openalpr foi instalada corretamente." sys.exit(1) alpr.set_top_n(20) alpr.set_default_region("md") results = alpr.recognize_file("cart.jpg") plate = "" acuraccy = "" for plate in results['results']: for candidate in plate['candidates']: plate = candidate['plate'] acuraccy = candidate['confidence'] break alpr.unload() return plate
def neiron(img_path): try: alpr = Alpr('eu', '/usr/share/openalpr/config/openalpr.defaults.conf', '/usr/share/openalpr/runtime_data') print("Camed to ALPR") if not alpr.is_loaded(): print("Error loading OpenALPR") sys.exit(1) alpr.set_top_n(20) alpr.set_default_region("lt") results = alpr.recognize_file(img_file) answer = results['results'][0]['plate'] alpr.unload() except Exception as e: print('Couldn\'t load ALPR') answer = 'Unsolved' return answer
def scanImage(imageFilePath): alpr = Alpr("gb", "/etc/openalpr/openalpr.conf", "/usr/local/src/openalpr/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(imageFilePath) alpr.unload() if results and results['results'] and results['results'][0] and results['results'][0]['plate']: plate = results['results'][0]['plate'] confidence = results['results'][0]['confidence'] print("Suspected number plate: " + plate + " - " + str(confidence) + "%") return {"plate": plate, "confidence": confidence} return False
def generate_DB_files(): #TODO checking start_recognition = time.time() ec_elgamal.prepare(pub_key_file, priv_key_file) plates = [] if (args.cars_folder != ""): alpr = Alpr("us", "/etc/openalpr/openalpr.conf", "/usr/share/openalpr/runtime_data") start_recognition = time.time() # do not include initialization time for root, dirs, files in os.walk(args.cars_folder): for img in files: results = alpr.recognize_file(os.path.join(root, img)) if results.values()[5] != []: plates.append(results.values()[5][0].values()[0]) # get the result with the best confidence elif (args.cars_file != "") : if not os.path.isfile(args.cars_file): print("generate_DB_files: ERROR! File {} does not exist!".format(args.cars_file)) with open(args.cars_file) as fp: for line in fp: plates.append(line) else : print("generate_DB_files: ERROR! No source file/directory specified") exit(0) if plates == []: print("generate_DB_files: No plates have been detected. Exiting...") exit(0) encoded_plates = [encode_plate_number(plate) for plate in plates] end_recognition = time.time() if args.verbose: print("generate_DB_files: Plates generated in {} ms".format((end_recognition-start_recognition)*1000)) start_enc = time.time() if args.verbose: print("generate_DB_files: Generating encrypted DB...") pool = Pool(processes=args.cpus) DB = pool.map(encrypt_for_DB, (encoded_plates[int(i*len(encoded_plates)/args.cpus):int((i+1)*len(encoded_plates)/args.cpus)] for i in range(args.cpus))) DB = [ent for sublist in DB for ent in sublist] end_enc = time.time() if args.verbose: print("generate_DB_files: Encrypted DB generated in: {} ms, nbr of plates: {}".format((end_enc-start_enc)*1000, len(DB))) np.save(DB_file, DB) del DB results_file = open("server_results.txt", "a+") results_file.write("Offline:M= {} CPUs_srvr= {} recog= {} DB_gen= {} storage/off_comm= {}\n"\ .format(len(encoded_plates), args.cpus, (end_recognition-start_recognition)*1000, (end_enc-start_enc)*1000, plate_size*len(encoded_plates)*128*1.00/1024)) results_file.close()
def main(): alpr = Alpr("us", "/etc/openalpr/openalp.conf", "/usr/share/openalpr/runtime_data") if not alpr.is_loaded(): print("Error loading OpenALPR") sys.exit(1) alpr.set_top_n(20) #top candidates alpr.set_default_region("ca") #default region fileName = "snapshot.jpg" results = alpr.recognize_file(fileName) #file = cv2.imread(fileName) #cv2.imshow("test", file) i = 0 print(len(results['results'])) for plate in results['results']: i += 1 coords = plate['coordinates'] topLeft = coords[0] bottomRight = coords[2] w = bottomRight['x'] - topLeft['x'] h = bottomRight['y'] - topLeft['y'] print("Plate #%d" % i) print("Width: %d" % w) print("Height: %d" % h) 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()
class PlateID(): def __init__(self): self.alpr = Alpr("br", "/usr/share/openalpr/config/openalpr.defaults.conf", "/usr/share/openalpr/runtime_data") if not self.alpr.is_loaded(): print("Error loading OpenALPR") sys.exit(1) self.alpr.set_top_n(20) self.alpr.set_default_region("br") def getPlate(self, arq='/home/pi/imgteste.jpg'): results = self.alpr.recognize_file(arq) plate = None pat = re.compile('[A-Z][A-Z][A-Z][0-9][0-9][0-9][0-9]') for plates in results['results']: for candidate in plates['candidates']: if pat.match(candidate['plate']): plate = candidate['plate'] break; return plate
def find_images(Filename) : while(True): alpr = Alpr("kr", "/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(20) alpr.set_default_region("md") results = alpr.recognize_file(Filename) i = 0 for plate in results['results']: i += 1 print("Plate #%d" % i) print(" %12s %12s" % ("Plate", "Confidence")) for candidate , a in plate['candidates']: prefix = "-" if candidate['matches_template']: prefix = "*" print(" %s %12s%12f" % (prefix, candidate['plate'], candidate['confidence'])) car_full_info[a] = candidate['plate'].encode('UTF-8') car_String = car_full_info[:5] print(type(car_String)) car_number = car_full_info[5:] print (car_String,car_number) #send_data.send_data(filename,car_full_info,car_String,car_number) # Call when completely done to release me mory alpr.unload() sec =10 time.sleep(sec)
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"
with open(log_file,'a+') as sl: sl.write('%f ' % S ) ci += 1 # Go to next line in log with open(log_file,'a+') as sl: sl.write('\n') # If spot occupation has changed and someone's there... if occupied is not now_occupied and np.any(now_occupied): # Write image with all biggest contours sfname = 'occupied.jpg' cv2.imwrite(sfname,ims) res = alpr.recognize_file(fname) lpn = '' try: lpn = str( res['results'][0]['plate'] ) print "LPN = %s" % lpn except: print "no dice with lpr..." sub = 'Occupation has changed' msg = 'Spot Status = %s' % str(now_occupied) print '%s\n%s' % (sub,msg) msg += '\nLPN = %s' % lpn #notify.send_msg_with_jpg( sub, msg, sfname, team ) # Set occupation to current status occupied = now_occupied
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()
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()
from openalpr import Alpr plate_db = open('plates.txt').read() try: alpr = Alpr("us", "/usr/share/openalpr/openalpr.default.conf", "/usr/share/openalpr/runtime_data") #laods alpr if not alpr.is_loaded(): print("Error loading library (openalpr)") alpr.set_top_n(1) #determines which text to display with most confidence results = alpr.recognize_file("image.jpg") for plate in results['results']: #preliminary data to post canidate plate number for candidate in plate['candidates']: prefix = "-" if candidate['matches_template']: prefix = "*" plate_text = str(candidate['plate']) if plate_text not in plate_db:#logic to test if number is database. print ("NOT IN LIST! NO PASSAGE!") alert = "Plate number is: " + plate_text print (alert) question = raw_input("Would you like to add to the database? ") if question == "Yes" or question == "y" or question == "yes": plate_db = open('plates.txt', 'a'); appendage = str(' ' + plate_text) plate_db.write(appendage) print ("Okay added")
# 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 cv2.imwrite(temp, frame) results = alpr.recognize_file(temp) if not wasPlate: count = 0 if count == numEx: items = probablePlates.items() mostProbable = items[0] for plate in items: if plate[1] > mostProbable[1]: mostProbable = plate[0] data = {"plate": mostProbable} data = json.dumps(data) r = requests.post(url, params=data, headers=headers) # mqttc.publish("plates", payload=data, qos=0, retain=True)