class image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber( "camera/image_raw", Image, self.callback) self.alpr = Alpr("eu", "/etc/openalpr/openalpr.conf", "/usr/local/home/u180107/openalpr/runtime_data") self.alpr.set_detect_region(True) self.currentConfidence = 0 self.currentDistance = 0 criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001) objp = np.float32([ [0, 0, 0], [8, 0, 0], [0, 6, 0], [8, 6, 0] ]) axis = np.float32([[3, 0, 0], [0, 3, 0], [0, 0, -3]]).reshape(-1, 3) with np.load('calibration.npz') as X: mtx, dist = [X[i] for i in ('mtx', 'dist')] def draw(img, corners, imgpts): corner = tuple(corners[0].ravel()) img = cv2.line(img, corner, tuple(imgpts[0].ravel()), (255, 0, 0), 5) img = cv2.line(img, corner, tuple(imgpts[1].ravel()), (0, 255, 0), 5) img = cv2.line(img, corner, tuple(imgpts[2].ravel()), (0, 0, 255), 5) return img
def openALPR(): #reading the picture print('STARTED: ALPR') try: global database alpr = None alpr = Alpr('gb', '/etc/openalpr/openalpr.conf', '/home/pi/openalpr/runtime_data') if not alpr.is_loaded(): print("Error loading OpenALPR") return False else: database = [] alpr.set_top_n(7) alpr.set_default_region("gb") alpr.set_detect_region(False) jpeg_bytes = open('Plates/Plate.jpg', "rb").read() #testing results = alpr.recognize_array(jpeg_bytes) i = 0 for plate in results['results']: i += 1 for candidate in plate['candidates']: plate = [candidate['plate'], candidate['confidence']] database.append(plate) if database == []: remove(filepath) print('FINISHED: ALPR unsucessful') return False else: print(database) print('FINISHED: ALPR sucessful') return True except AttributeError: print()
def faceDetection(self, frame): global value global percentage alpr = Alpr("pak", "path/config/openalpr.conf", "path/openalpr/runtime_data") frame = cv2.resize(frame, (740, 480)) faces = plateCascade.detectMultiScale(frame, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30)) self.allfaces = faces for (x, y, w, h) in faces: cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 4) cv2.putText(frame, str(value) + "-" + str(percentage) + "%", (x - 10, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2) if not alpr.is_loaded(): print("Error loading OpenALPR") else: print("Using OpenALPR " + alpr.get_version()) alpr.set_top_n(7) alpr.set_default_region("wa") alpr.set_detect_region(False) cv2.imwrite("1.png", frame) jpeg_bytes = open("1.png", "rb").read() results = alpr.recognize_array(jpeg_bytes) print("Image size: %dx%d" % (results['img_width'], results['img_height'])) print("Processing Time: %f" % results['processing_time_ms']) #print(str(results['results'][0][0]['candidates']['plate'])) i = 0 count = 0 for plate in results['results']: i = 1 print("Plate #%d" % i) print(" %12s %12s" % ("Plate", "Confidence")) for candidate in plate['candidates']: prefix = "-" if candidate['matches_template']: prefix = "*" if count >= 1: break print( " %s %12s%12f" % (prefix, candidate['plate'], candidate['confidence'])) value = candidate['plate'] percentage = candidate['confidence'] count = count + 1 self.bbFrame = frame
def main(): try: print("Starting...") alpr = Alpr(country, config, runtime_data) if not alpr.is_loaded(): print("Error loading OpenALPR") else: print("Using OpenALPR " + alpr.get_version()) alpr.set_top_n(1) alpr.set_detect_region(False) # initialize the video stream and allow the cammera sensor to warmup video_source = (0 if options["videosource"] == None else options["videosource"]) vs = VideoStream(usePiCamera=options["picamera"] > 0, src=video_source).start() time.sleep(2.0) _frame_number = 0 print("Running...") # loop over the frames from the video stream while True: frame = vs.read() #frame = imutils.resize(frame) #frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) _frame_number += 1 if _frame_number % FRAME_SKIP == 0: frame_array = (cv2.imencode(".jpg", frame)[1]).tostring() results = alpr.recognize_array(frame_array) if len(results["results"]) > 0: pool.apply_async(_validate, args=[frame_array, results, device, iot, storage]) if options["imshow"]: # show the frame cv2.imshow("Frame", frame) key = cv2.waitKey(1) & 0xFF # if the `q` key was pressed, break from the loop if key == ord("q"): break except: print("[main] Unexpected error:", sys.exc_info()) finally: if alpr: alpr.unload() pool.close() cv2.destroyAllWindows() vs.stop()
def plater(image_paths) -> bool: alpr = None found_count = 0 image_dir = "./images/" try: alpr = Alpr("us", "./baller.alpr.config", "/usr/share/openalpr/runtime_data") if not alpr.is_loaded(): print("Error loading OpenALPR") else: print("Using OpenALPR " + alpr.get_version()) alpr.set_top_n(5) alpr.set_default_region("tx") alpr.set_detect_region(True) for entry in image_paths: jpeg_bytes = open(os.path.join(image_dir, entry), "rb").read() results = alpr.recognize_array(jpeg_bytes) # print ("kakakak \n\n\n") # print (results['results']) # for plate in results['results']: # i += 1 # print("Plate #%d" % i) # print(" %12s %12s" % ("Plate", "Confidence")) # for candidate in plate['candidates']: # prefix = "-" # if candidate['matches_template']: # prefix = "*" # print(" %s %12s%12f" % (prefix, candidate['plate'], candidate['confidence'])) if len(results['results']) > 0: found_count += 1 return found_count > 0 finally: if alpr: alpr.unload()
while True: sc, address = s.accept() # sc, address = s.accept() print(address) f = open('file.jpg', 'wb') # open in binary l = 1 while (l): l = sc.recv(1024) while (l): f.write(l) l = sc.recv(1024) f.close() #alpr.set_top_n(20) alpr.set_detect_region(True) f = open("file.jpg", "rb") jpeg_bytes = f.read() results = alpr.recognize_array(jpeg_bytes) # for plate in results['results']: # for candidate in plate['candidates']: # print(candidate['plate']) # print(plate['candidates'][0]['plate']) result = results['results'][0]['candidates'][0]['plate'] print(result) sc.send(result.encode('utf-8')) # i = 0 # for plate in results['results']:
parser.add_argument('plate_image', help='License plate image file') options = parser.parse_args() alpr = None try: alpr = Alpr(options.country, options.config, options.runtime_data) if not alpr.is_loaded(): print("Error loading OpenALPR") else: print("Using OpenALPR " + alpr.get_version()) alpr.set_top_n(7) alpr.set_default_region("wa") alpr.set_detect_region(False) jpeg_bytes = open(options.plate_image, "rb").read() results = alpr.recognize_array(jpeg_bytes) # Uncomment to see the full results structure # import pprint # pprint.pprint(results) print("Image size: %dx%d" % (results['img_width'], results['img_height'])) print("Processing Time: %f" % results['processing_time_ms']) i = 0 for plate in results['results']: i += 1 print("Plate #%d" % i)
def alpr_conf(): alpr = Alpr(country, config, runtime_data) alpr.set_top_n(7) alpr.set_default_region("base") alpr.set_detect_region(False) return alpr
parser.add_argument('plate_image', help='License plate image file') options = parser.parse_args() alpr = None try: alpr = Alpr(options.country, options.config, options.runtime_data) if not alpr.is_loaded(): print("Error loading OpenALPR") else: print("Using OpenALPR " + alpr.get_version()) alpr.set_top_n(7) alpr.set_default_region("wa") alpr.set_detect_region(False) jpeg_bytes = open(options.plate_image, "rb").read() results = alpr.recognize_array(jpeg_bytes) # Uncomment to see the full results structure # import pprint # pprint.pprint(results) print("Image size: %dx%d" %(results['img_width'], results['img_height'])) print("Processing Time: %f" % results['processing_time_ms']) i = 0 for plate in results['results']: i += 1 print("Plate #%d" % i) print(" %12s %12s" % ("Plate", "Confidence"))
try: lastCrawl = None jsonFiles = None start = time.time() logging.basicConfig(level=logging.INFO) if options.verbosity: logging.getLogger().setLevel(logging.DEBUG) logging.info('Lancement de croustibatch') if not options.tesseract: algo = Alpr(options.country, options.config, options.runtime_data) algo.set_detect_region("d") algo.set_top_n(5) algo.set_detect_region(True) logging.info("Using OpenALPR " + algo.get_version()) else: algo = "thresh" # if not algo.is_loaded(): # logging.error("Error loading OpenALPR") # else: ftp = FTP(options.ftphost) ftp.login(options.loginftp, options.passwordftp) #if not os.path.isdir(options.directory): # os.mkdir(options.directory)
def f(data): parser = ArgumentParser(description='OpenALPR Python Test Program') parser.add_argument("-c", "--country", dest="country", action="store", default="us", help="License plate Country" ) OpenALPR_path = "C:/Users/Franco/Documents/Github/control-vehicular/Otros/Deteccion/openalpr_32bit/" parser.add_argument("--config", dest="config", action="store", default=OpenALPR_path+"openalpr.conf", help="Path to openalpr.conf config file" ) parser.add_argument("--runtime_data", dest="runtime_data", action="store", default=OpenALPR_path+"runtime_data", help="Path to OpenALPR runtime_data directory" ) #parser.add_argument('plate_image', help='License plate image file') options = parser.parse_args() print(options.country, options.config, options.runtime_data) alpr = None try: alpr = Alpr(options.country.encode('ascii'), options.config.encode('ascii'), options.runtime_data.encode('ascii')) if not alpr.is_loaded(): print("Error loading OpenALPR") else: print("Using OpenALPR " + alpr.get_version().decode('ascii')) alpr.set_top_n(7) alpr.set_default_region(b"wa") alpr.set_detect_region(False) # jpeg_bytes = open(options.plate_image, "rb").read() # results = alpr.recognize_array(jpeg_bytes) jpeg_bytes = data results = alpr.recognize_array(bytes(bytearray(data))) # Uncomment to see the full results structure # import pprint # pprint.pprint(results) print("Image size: %dx%d" %(results['img_width'], results['img_height'])) print("Processing Time: %f" % results['processing_time_ms']) i = 0 if results['results']: print("%12s%12f" % (results['results'][0]['plate'], results['results'][0]['confidence'])) for plate in results['results']: i += 1 print("Plate #%d" % i) print(" %12s %12s" % ("Plate", "Confidence")) for candidate in plate['candidates']: prefix = "-" if candidate['matches_template']: prefix = "*" print(" %s %12s%12f" % (prefix, candidate['plate'], candidate['confidence'])) finally: if alpr: alpr.unload()
from openalpr import Alpr country = "eu" default_region = "fi" detect_region = False alpr = Alpr(country, "/etc/openalpr/openalpr.conf", "/usr/share/openalpr/runtime_data") alpr.set_top_n(5) alpr.set_default_region(default_region) alpr.set_detect_region(detect_region) print('ALPR config: country={}, default_region={}, detect_region={}'.format( country, default_region, detect_region)) def recognize(file_path): cv_output = [] output = alpr.recognize_file(file_path) for plate in output['results']: for candidate in plate['candidates']: cv_output.append({ "plate": candidate['plate'], "confidence": candidate['confidence'] }) #alpr.unload() return cv_output
class AnalizePlate(object): def __init__(self): """ Simple script init, does not require any params. """ self.last_plate = None self.alpr = None self.db = DB.DB() try: self.alpr = Alpr("rs", "/etc/openalpr/openalpr.conf", "/usr/share/openalpr/runtime_data") if not self.alpr.is_loaded(): print("Error loading OpenALPR") except: print("Error") return False def proccess(self, img, naziv, ip, image_location, thumbnail_location): """ Process the passed image and return the results. :param img: numpy array :return: array """ self.alpr.set_top_n(7) self.alpr.set_detect_region(False) # print "[+] Analiziram tablicu" try: results = self.alpr.recognize_file(naziv) except Exception as e: print "Analize plate array error:", e # exit(0) return False if results['results']: if self.last_plate != results['results'][0]['plate']: self.last_plate = results['results'][0]['plate'] kandidati = "" for plate in results['results'][0]['candidates']: try: kandidati += plate['plate'] + ',' except Exception as e: print str(e) # shutil.copy(naziv, "/home/metro/Programazer/carina-slike/") vreme = time.time() # im = cv2.imread(naziv) obj = datetime.datetime.fromtimestamp(vreme) # ime = obj.strftime("%d-%m-%Y %H:%M:%S") folder = obj.strftime("%d.%m.%Y") ime = "{}_{}".format(time.time(), ip) try: if not os.path.exists("{}{}".format( image_location, folder)): os.makedirs("{}{}".format(image_location, folder)) if not os.path.exists("{}{}".format( thumbnail_location, folder)): os.makedirs("{}{}".format(thumbnail_location, folder)) imwrite("{}{}/{}.jpg".format(image_location, folder, ime), img) try: imwrite( "{}{}/{}.jpg".format(thumbnail_location, folder, ime), resize(img, (0, 0), fx=0.3, fy=0.3)) thumb = True except: thumb = False pass # imwrite("/opt/lampp/htdocs/carina-tablice/{}.jpg".format(ime),img) except Exception as e: print e return False self.add_plate(results['results'][0]['plate'], kandidati, folder + "/" + ime, thumb) notify(folder + "/" + ime, results['results'][0]['plate']) self.checkActivePlates(folder + "/" + ime, results['results'][0]['plate']) # print naziv, results['results'][0]['plate'] # return results try: os.remove(naziv) except: pass return False def add_plate(self, tablica, kandidati, naziv, thumb): try: if thumb: self.db.execute( "INSERT INTO tablice (br_tablice, moguce_tablice,naziv,ostalo) VALUES ('{}', '{}','{}','thumb=true')" .format(tablica, kandidati, naziv)) else: self.db.execute( "INSERT INTO tablice (br_tablice, moguce_tablice,naziv) VALUES ('{}', '{}','{}')" .format(tablica, kandidati, naziv)) return True except: self.db = DB.DB() if thumb: self.db.execute( "INSERT INTO tablice (br_tablice, moguce_tablice,naziv,ostalo) VALUES ('{}', '{}','{}','thumb=true')" .format(tablica, kandidati, naziv)) else: self.db.execute( "INSERT INTO tablice (br_tablice, moguce_tablice,naziv) VALUES ('{}', '{}','{}')" .format(tablica, kandidati, naziv)) return True return False def checkActivePlates(self, ime, plate): res = self.db.execute( "SELECT * FROM aktuelno WHERE tablica LIKE '%{}%'".format(plate)) result = res.fetchall() # print result if len(result) > 0: # print "[!]"*5,rezultat[0][1],"[!]"*5 notify( ime, plate, result[0][1], )
alpr = None files = [] try: __location__ = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__))) alpr = Alpr("eu", options.config, options.runtime_data) if not alpr.is_loaded(): print("Error loading OpenALPR") else: #print("Using OpenALPR " + alpr.get_version()) files += [each for each in os.listdir('.') if each.endswith('.png')] print("<table>"); for file in files: alpr.set_top_n(7) alpr.set_default_region("eu") alpr.set_detect_region(True) jpeg_bytes = open(__location__+file, "rb").read() results = alpr.recognize_array(jpeg_bytes) # Uncomment to see the full results structure # import pprint # pprint.pprint(results) #print("Image size: %dx%d" %(results['img_width'], results['img_height'])) #print("Processing Time: %f" % results['processing_time_ms']) i = 0 if(results['results']): print("<tr><td><img width='640' height='480' src='"+file+"' /></td><td>") for plate in results['results']: i += 1
class image_converter: def __init__(self): self.bridge = CvBridge() self.image_sub = rospy.Subscriber("camera/image_raw", Image, self.callback) self.alpr = Alpr("eu", "/etc/openalpr/openalpr.conf", "/usr/local/home/u180107/openalpr/runtime_data") self.alpr.set_detect_region(True) self.currentConfidence = 0 self.currentDistance = 0 def distanceByArea(self, cv_image): results = self.alpr.recognize_ndarray(cv_image) for i, plate in enumerate(results['results']): best_candidate = plate['coordinates'] corner1 = (best_candidate[0]['x'], best_candidate[0]['y']) corner2 = (best_candidate[2]['x'], best_candidate[2]['y']) platePixelWidth = abs( int(best_candidate[2]['x']) - int(best_candidate[0]['x'])) platePixelHeight = abs( int(best_candidate[2]['y']) - int(best_candidate[0]['y'])) platePixelArea = platePixelHeight * platePixelWidth # The distance equation required that the camera be calibrated, currently they're 'close enough' distance = round(52000 * pow(platePixelArea, -0.368), 2) detected = plate['candidates'][0] if self.currentConfidence < detected['confidence'] or abs( distance - self.currentDistance) > 200: self.currentConfidence = detected['confidence'] # print('Plate #{}: {:7s} ({:.2f}%) - Plate distance: {}mm'.format(i, detected['plate'].upper(), detected['confidence'],distance)) self.currentDistance = distance cv2.rectangle(cv_image, corner1, corner2, (0, 255, 0), 2) cv2.putText(cv_image, ('distance = %dmm' % distance), (i * 330, 460), font, 1, (0, 255, 0), 2, cv2.LINE_AA) return cv_image def distanceByHomography(self, cv_image): cam_mtx = np.array([[767.92632836, 0, 325.7824046], [0, 770.98907555, 157.44636998], [0, 0, 1]]) dist_coeffs = np.zeros((5, 1)) results = self.alpr.recognize_ndarray(cv_image) for i, plate in enumerate(results['results']): best_candidate = plate['coordinates'] worldPoints = np.float32([[0, 0, 0], [510, 0, 0], [510, 110, 0], [0, 110, 0]]) imagePoints = np.float32([(best_candidate[a]['x'], best_candidate[a]['y']) for a in range(0, 4)]) # print(imgPoints) # print(worldPoints) imgPoints = np.ascontiguousarray(imagePoints[:, :2].reshape( 4, 1, 2)) _ret, rvec, tvec = cv2.solvePnP(worldPoints, imgPoints, cam_mtx, dist_coeffs, flags=cv2.SOLVEPNP_P3P) print("Rotation Vector:\n {0}".format(rvec)) print("Translation Vector:\n {0}".format(tvec)) end_point2D, jacobian = cv2.projectPoints( np.array([(0.0, 0.0, 1000.0)]), rvec, tvec, cam_mtx, dist_coeffs) for p in imagePoints: cv2.circle(cv_image, (int(p[0]), int(p[1])), 3, (0, 0, 255), -1) p1 = (int(imagePoints[0][0]), int(imagePoints[0][1])) p2 = (int(end_point2D[0][0][0]), int(end_point2D[0][0][1])) cv2.line(cv_image, p1, p2, (255, 0, 0), 2) return cv_image def callback(self, data): try: cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8") # cv2.imshow(WINDOW_NAME, cv_image) except CvBridgeError as e: print(e) # cv_image_labeled = self.distanceByArea(cv_image) cv_image_labeled = self.distanceByHomography(cv_image) cv2.imshow(WINDOW_NAME, cv_image_labeled) cv2.waitKey(3)
class image_converter: def __init__(self): self.publisher = rospy.Publisher('object_pose', Point, queue_size=10) self.bridge = CvBridge() self.image_sub = rospy.Subscriber("camera/image_raw", Image, self.callback) self.alpr = Alpr("eu", "/etc/openalpr/openalpr.conf", "/usr/local/home/u180107/openalpr/runtime_data") self.alpr.set_detect_region(True) self.currentConfidence = 0 self.currentDistance = 0 self.criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001) self.objp = np.float32([[0, 0, 0], [7, 0, 0], [0, 5, 0], [7, 5, 0]]) self.axis = np.float32([[3, 0, 0], [0, 3, 0], [0, 0, -3]]).reshape(-1, 3) with np.load('calibration.npz') as X: self.mtx, self.dist = [X[i] for i in ('mtx', 'dist')] def draw(self, img, corners, imgpts): corner = tuple(corners[0].ravel()) img = cv2.line(img, corner, tuple(imgpts[0].ravel()), (255, 0, 0), 5) img = cv2.line(img, corner, tuple(imgpts[1].ravel()), (0, 255, 0), 5) img = cv2.line(img, corner, tuple(imgpts[2].ravel()), (0, 0, 255), 5) return img def getPose(self, cv_image): gray = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY) ret, corners = cv2.findChessboardCorners(gray, (8, 6), None, cv2.CALIB_CB_FAST_CHECK) if ret == True: result = np.array( [corners[0], corners[7], corners[40], corners[-1]]) for res in result: cv2.circle(cv_image, (res[0][0], res[0][1]), 5, (0, 0, 255), 3) # print(result) corners2 = cv2.cornerSubPix(gray, result, (11, 11), (-1, -1), self.criteria) ret, rvecs, tvecs, inliers = cv2.solvePnPRansac( self.objp, corners2, self.mtx, self.dist, cv2.SOLVEPNP_P3P) imgpts, jac = cv2.projectPoints(self.axis, rvecs, tvecs, self.mtx, self.dist) img = self.draw(cv_image, corners2, imgpts) platePoint = Point(float(tvecs[0]), float(tvecs[1]), float(tvecs[2])) self.publisher.publish(platePoint) # cv2.imshow('img', img) return (img) successful_frames += 1 cv2.waitKey(1) else: # cv2.imshow('img', cv_image) return (cv_image) cv2.waitKey(1) def distanceByArea(self, cv_image): results = self.alpr.recognize_ndarray(cv_image) for i, plate in enumerate(results['results']): best_candidate = plate['coordinates'] corner1 = (best_candidate[0]['x'], best_candidate[0]['y']) corner2 = (best_candidate[2]['x'], best_candidate[2]['y']) platePixelWidth = abs( int(best_candidate[2]['x']) - int(best_candidate[0]['x'])) platePixelHeight = abs( int(best_candidate[2]['y']) - int(best_candidate[0]['y'])) platePixelArea = platePixelHeight * platePixelWidth # The distance equation required that the camera be calibrated, currently they're 'close enough' distance = round(52000 * pow(platePixelArea, -0.368), 2) detected = plate['candidates'][0] if self.currentConfidence < detected['confidence'] or abs( distance - self.currentDistance) > 200: self.currentConfidence = detected['confidence'] # print('Plate #{}: {:7s} ({:.2f}%) - Plate distance: {}mm'.format(i, detected['plate'].upper(), detected['confidence'],distance)) self.currentDistance = distance cv2.rectangle(cv_image, corner1, corner2, (0, 255, 0), 2) cv2.putText(cv_image, ('distance = %dmm' % distance), (i * 330, 460), font, 1, (0, 255, 0), 2, cv2.LINE_AA) return cv_image def distanceByHomography(self, cv_image): cam_mtx = np.array([[767.92632836, 0, 325.7824046], [0, 770.98907555, 157.44636998], [0, 0, 1]]) dist_coeffs = np.zeros((5, 1)) results = self.alpr.recognize_ndarray(cv_image) for i, plate in enumerate(results['results']): best_candidate = plate['coordinates'] worldPoints = np.float32([[0, 0, 0], [510, 0, 0], [510, 110, 0], [0, 110, 0]]) imagePoints = np.float32([(best_candidate[a]['x'], best_candidate[a]['y']) for a in range(0, 4)]) # print(imgPoints) # print(worldPoints) imgPoints = np.ascontiguousarray(imagePoints[:, :2].reshape( 4, 1, 2)) _ret, rvec, tvec = cv2.solvePnP(worldPoints, imgPoints, cam_mtx, dist_coeffs, flags=cv2.SOLVEPNP_P3P) print("Rotation Vector:\n {0}".format(rvec)) print("Translation Vector:\n {0}".format(tvec)) end_point2D, jacobian = cv2.projectPoints( np.array([(0.0, 0.0, 1000.0)]), rvec, tvec, cam_mtx, dist_coeffs) for p in imagePoints: cv2.circle(cv_image, (int(p[0]), int(p[1])), 3, (0, 0, 255), -1) p1 = (int(imagePoints[0][0]), int(imagePoints[0][1])) p2 = (int(end_point2D[0][0][0]), int(end_point2D[0][0][1])) cv2.line(cv_image, p1, p2, (255, 0, 0), 2) return cv_image def callback(self, data): try: cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8") except CvBridgeError as e: print(e) cv_image_labeled = self.getPose(cv_image) cv2.imshow(WINDOW_NAME, cv_image_labeled) cv2.waitKey(1)