def __record_images_from_fs(self,
                                manifest=None,
                                ros_topic=None,
                                sensor=None,
                                frame_id=None):

        image_reader = dict()
        image_data = dict()
        image_ts = dict()

        image_request = self.request.get("image", "original")
        if image_request == "undistorted":
            lens, dist_parms, intr_mat_dist, intr_mat_undist = self.__get_camera_info(
                sensor=sensor)

        while True:
            files = None
            while not files and manifest.is_open():
                files = manifest.fetch()
            if not files:
                break

            count = read_images_from_fs(data_store=self.data_store,
                                        files=files,
                                        image_reader=image_reader,
                                        image_data=image_data,
                                        image_ts=image_ts)

            for i in range(0, count):
                image_reader[i].join()
                if image_request == "undistorted":
                    image = RosUtil.undistort_image(
                        image=image_data[i],
                        lens=lens,
                        dist_parms=dist_parms,
                        intr_mat_dist=intr_mat_dist,
                        intr_mat_undist=intr_mat_undist)
                else:
                    image = image_data[i]
                self.__record_image_msg(ros_topic=ros_topic,
                                        image=image,
                                        image_ts=image_ts[i],
                                        frame_id=frame_id)

            if self.request['preview']:
                break

        self.topic_active[ros_topic] = False
 def __process_s3_image_files(self,
                              ros_topic=None,
                              files=None,
                              resp=None,
                              frame_id=None,
                              s3_client=None,
                              image_request=None,
                              lens=None,
                              dist_parms=None,
                              intr_mat_dist=None,
                              intr_mat_undist=None):
     for f in files:
         try:
             path = resp.get(block=True).split(" ", 1)[0]
             image_data = cv2.imread(path)
             if image_request == "undistorted":
                 image = RosUtil.undistort_image(
                     image_data,
                     lens=lens,
                     dist_parms=dist_parms,
                     intr_mat_dist=intr_mat_dist,
                     intr_mat_undist=intr_mat_undist)
             else:
                 image = image_data
             image_ts = int(f[2])
             self.__record_image_msg(ros_topic=ros_topic,
                                     image=image,
                                     image_ts=image_ts,
                                     frame_id=frame_id,
                                     s3_client=s3_client)
             os.remove(path)
         except BaseException as _:
             exc_type, exc_value, exc_traceback = sys.exc_info()
             traceback.print_tb(exc_traceback, limit=20, file=sys.stdout)
             self.logger.error(str(exc_type))
             self.logger.error(str(exc_value))