def read_image_turbo_jpeg(path: str,
jpeg_reader: TurboJPEG = None) -> np.array:
if not jpeg_reader:
jpeg_reader = TurboJPEG()
file = open(path, "rb")
image = jpeg_reader.decode(file.read(), 1) # 0 - RGB, 1 - BGR
return image
def __init__(self, channels=192):
self.channels = channels
self.jpeg = TurboJPEG('/usr/lib/libturbojpeg.so')
self.subset_channel_index = dct_channel_index
self.subset_y = self.subset_channel_index[channels][0]
self.subset_cb = self.subset_channel_index[channels][1]
self.subset_cr = self.subset_channel_index[channels][2]
def do_mem_profile_decompress(): jpeg = TurboJPEG() out_img = 'jpegs/single_v0.jpg' in_file = open(out_img, 'rb') bgr_array = jpeg.decode(in_file.read()) in_file.close() return None
def enc_ps(shutdown, infd, outfd, rcvhwm, sndhwm):
context = zmq.Context()
socket = context.socket(zmq.PULL)
socket.setsockopt(zmq.RCVHWM, rcvhwm)
socket.connect(infd)
out = context.socket(zmq.PUSH)
out.setsockopt(zmq.SNDHWM, sndhwm)
out.connect(outfd)
poller = zmq.Poller()
poller.register(socket, zmq.POLLIN)
encoder = partial(
TurboJPEG().encode,
quality=QUALITY,
jpeg_subsample=TJSAMP_420,
flags=TJFLAG_FASTDCT,
)
while not shutdown.is_set():
target = time.time() + TIMESTEP
if poller.poll(0):
try:
arr, idx = intf.recv(socket, arr=True, flags=zmq.NOBLOCK)
intf.send(out, idx, buf=encoder(arr), flags=zmq.NOBLOCK)
except zmq.error.Again:
pass
missing = target - time.time()
if missing > 0:
time.sleep(missing)
def enc_ps(*, shutdown, barrier, infd, outfd):
context = zmq.Context()
socket = context.socket(zmq.PULL)
socket.setsockopt(zmq.RCVHWM, ENC_HWM)
socket.connect(infd)
out = context.socket(zmq.PUSH)
out.setsockopt(zmq.SNDHWM, ENC_HWM)
out.connect(outfd)
barrier.wait()
encoder = partial(
TurboJPEG().encode,
quality=QUALITY,
jpeg_subsample=TJSAMP_420,
flags=TJFLAG_FASTDCT,
)
while not shutdown.is_set():
target = time.time() + ENC_TIMESTEP
if socket.poll(0):
data = intf.recv(socket=socket, arr=True, flags=zmq.NOBLOCK)
data["buf"] = encoder(data["arr"])
del data["arr"]
try:
intf.send(
socket=out,
flags=zmq.NOBLOCK,
**data,
)
except zmq.error.Again:
pass
missing = target - time.time()
if missing > 0:
time.sleep(missing)
def test_dec(rounds=100):
enc = partial(
TurboJPEG().encode, quality=80, jpeg_subsample=TJSAMP_420, flags=TJFLAG_FASTDCT
)
dec = partial(TurboJPEG().decode, flags=(TJFLAG_FASTDCT + TJFLAG_FASTUPSAMPLE))
for size in ["1920x1080", "1280x720", "640x480"]:
img = cv2.imread(f"test_imgs/{size}.jpg")
buf = enc(img)
print(f"Testing buffer of shape {len(buf)}, size {getsizeof(buf)}")
print(f"Testing decompression speed...")
input("Press enter to start")
start = time.time()
for i in range(rounds):
img = dec(buf)
if i % 5 == 0:
print(f"FPS: {i/(time.time() - start)}")
def __init__(self,
root,
loader,
extensions=None,
transform=None,
target_transform=None,
is_valid_file=None,
quality=None):
super(TinyDatasetFolder, self).__init__(root)
self.transform = transform
self.target_transform = target_transform
classes, class_to_idx = self._find_classes(self.root)
samples = make_dataset(self.root, class_to_idx, extensions,
is_valid_file)
if len(samples) == 0:
raise (RuntimeError("Found 0 files in subfolders of: " +
self.root + "\n"
"Supported extensions are: " +
",".join(extensions)))
self.jpeg = TurboJPEG('/home/kai.x/work/local/lib/libturbojpeg.so')
self.loader = loader
self.extensions = extensions
self.classes = classes
self.class_to_idx = class_to_idx
self.samples = samples
self.targets = [s[1] for s in samples]
self.quality = quality
def dec_ps(*, shutdown, barrier, infd, outfd, fwdbuf):
context = zmq.Context()
socket = context.socket(zmq.PULL)
socket.setsockopt(zmq.RCVHWM, DEC_HWM)
socket.connect(infd)
out = context.socket(zmq.PUSH)
out.setsockopt(zmq.SNDHWM, DEC_HWM)
out.connect(outfd)
barrier.wait()
decoder = partial(TurboJPEG().decode,
flags=(TJFLAG_FASTDCT + TJFLAG_FASTUPSAMPLE))
while not shutdown.is_set():
target = time.time() + DEC_TIMESTEP
if socket.poll(0):
data = intf.recv(socket=socket, buf=True, flags=zmq.NOBLOCK)
try:
intf.send(
socket=out,
fno=data["fno"],
ftime=data["ftime"],
meta=data["meta"],
arr=decoder(data["buf"]),
buf=data["buf"] if fwdbuf else None,
flags=zmq.NOBLOCK,
)
except zmq.error.Again:
pass
missing = target - time.time()
if missing > 0:
time.sleep(missing)
def __init__(self, filename_queue, parser_queue, *args, **kwargs): super().__init__(*args, **kwargs) self.parser_queue = parser_queue self.jpeg_loader = TurboJPEG() self.num_images = 0 self.file_size_sum = 0 self.pixel_sum = 0 self.filename_queue = filename_queue self.is_running = multiprocessing.Value(ctypes.c_bool, True)
def __init__(self):
"""Try to create TurboJPEG only once."""
try:
TurboJPEGSingleton.__instance = TurboJPEG()
except Exception: # pylint: disable=broad-except
_LOGGER.exception(
"libturbojpeg is not installed, cameras may impact HomeKit performance."
)
TurboJPEGSingleton.__instance = False
def do_mem_profile_compress(): jpeg = TurboJPEG() quality = 100 out_img = 'jpegs/single_v0.jpg' in_img = 'imgs/output_fwd_v0.png' bgr_array = cv2.imread(in_img) out_file = open(out_img, 'wb') out_file.write(jpeg.encode(bgr_array, quality=quality)) out_file.close() return None
def __init__(
self,
csv_path: str,
img_dir: str,
file_extension: str = 'dcm',
mode: str = 'train',
fold: int = 0,
k_fold: int = 5,
transform=None,
network_type: str = 'cnn',
max_sequence: int = 1083,
):
assert mode in ['train', 'val', 'test']
assert network_type in ['cnn', 'rnn', 'cnn_rnn']
assert -1 <= fold < 5
assert 15 % k_fold == 0
self.transform = transform
self.csv_path = Path(csv_path)
self.img_dir = Path(img_dir)
self.file_extension = file_extension
self.mode = mode
self.network_type = network_type
self.max_sequence = max_sequence
if network_type == 'cnn':
self.target_cols = [
'pe_present_on_image',
]
elif network_type == 'rnn':
self.target_cols = [
'negative_exam_for_pe',
'indeterminate',
'chronic_pe', 'acute_and_chronic_pe', # not indeterminate. Only One is true.
'central_pe', 'leftsided_pe', 'rightsided_pe', # not indeterminate. At least One is true.
'rv_lv_ratio_gte_1', 'rv_lv_ratio_lt_1', # not indeterminate. Only One is true.
'pe_present_on_image',
]
if self.file_extension == 'jpg':
self.jpeg_reader = TurboJPEG()
df = pd.read_csv(self.csv_path)
df["file_name"] = df.SOPInstanceUID + '.' + self.file_extension
if self.file_extension != 'dcm':
df.z_pos_order = df.z_pos_order.map(lambda x: f'{x:04}')
df.file_name = df.z_pos_order + '_' + df.file_name
df["image_name"] = str(self.img_dir) + '/' + \
df.StudyInstanceUID + '/' + df.SeriesInstanceUID + '/' + df.file_name
self.df = df if fold == -1 else self._make_fold(df, fold, k_fold, mode=mode)
if self.network_type == 'rnn' or self.network_type == 'cnn_rnn':
self.df["path_to_series_id"] = str(self.img_dir) + '/' + \
self.df.StudyInstanceUID + '/' + self.df.SeriesInstanceUID
self.path_to_series_id = self.df["path_to_series_id"].unique()
def __init__(self, jpeg_quality, jpeg_lib):
"""Constructor.
Args:
jpeg_quality (:obj:`int`): Quality of JPEG encoding, in 0, 100.
"""
Thread.__init__(self)
self.cap = cv2.VideoCapture(3)
self.turbojpeg = TurboJPEG()
self.running = True
self.buffer = None
self.lock = Lock()
if jpeg_lib == 'turbo':
self.jpeg = TurboJPEG()
self.jpeg_encode_func = lambda img, jpeg_quality=jpeg_quality, jpeg=self.jpeg: utils.turbo_encode_image(img, jpeg, jpeg_quality)
else:
self.jpeg_encode_func = lambda img, jpeg_quality=jpeg_quality: utils.cv2_encode_image(img, jpeg_quality)
def __init__(self, channels=None, is_test=False, interpolation='BILINEAR'):
self.jpeg = TurboJPEG('/usr/lib/libturbojpeg.so')
self.channels = channels
self.is_test = is_test
self.interpolation = interpolation
if channels and channels != 192:
self.subset_channel_index = dct_channel_index
self.subset_y = self.subset_channel_index[channels][0]
self.subset_cb = self.subset_channel_index[channels][1]
self.subset_cr = self.subset_channel_index[channels][2]
def __init__(self, train_val_cvs_path, train,
bbox_transform=None,
image_transform=None):
super().__init__()
self.train_folds_path = train_val_cvs_path
self.train = train
self.bbox_transform = bbox_transform
self.image_transform = image_transform
self.turbo_jpeg = TurboJPEG('/usr/lib/x86_64-linux-gnu/libturbojpeg.so.0')
self.images, self.class_indexes, self.bboxes, self.id2class_idx = \
get_samples(train_val_cvs_path, train)
def __init__(
self,
root: str,
image_folder: str,
mask_folder: str,
transforms: Optional[Callable] = None,
):
self.image_folder = os.path.join(root, image_folder)
self.mask_folder = os.path.join(root, mask_folder)
self.imgs = list(sorted(os.listdir(self.image_folder)))
self.masks = list(sorted(os.listdir(self.mask_folder)))
self.transforms = transforms
self.jpeg = TurboJPEG(lib_path=local_libturbo_path)
def do_benchmarking_compress(bgr_array, quality, out_img): timeval = [] jpeg = TurboJPEG() for j in range(100): for i in range(100): out_file = open(out_img, 'wb') start = time.process_time() out_file.write(jpeg.encode(bgr_array, quality=quality)) end = time.process_time() val = (end - start)*1000 #msec timeval.append(val) out_file.close() return timeval
def do_benchmarking_decompress(in_img): timeval = [] jpeg = TurboJPEG() for j in range(100): for i in range(100): in_file = open(in_img, 'rb') start = time.process_time() bgr_array = jpeg.decode(in_file.read()) end = time.process_time() val = (end - start)*1000 #msec timeval.append(val) in_file.close() return timeval
def __init__(self, filename):
try:
# Open mjpeg file
self.mjpeg = open(filename, "rb")
# Initialize TurboJpeg (7x faster than opecv embedded jpeg decoder)
self.tjpeg = TurboJPEG()
# File is open
self.opened = True
except FileNotFoundError:
print("File {0} not found".format(filename))
self.opened = False
def dec_ps(shutdown, infd, outfd, rcvmeta, sndbuf, rcvhwm, sndhwm):
context = zmq.Context()
socket = context.socket(zmq.PULL)
socket.setsockopt(zmq.RCVHWM, rcvhwm)
socket.connect(infd)
out = context.socket(zmq.PUSH)
out.setsockopt(zmq.SNDHWM, sndhwm)
out.connect(outfd)
poller = zmq.Poller()
poller.register(socket, zmq.POLLIN)
decoder = partial(TurboJPEG().decode,
flags=(TJFLAG_FASTDCT + TJFLAG_FASTUPSAMPLE))
while not shutdown.is_set():
target = time.time() + TIMESTEP
if poller.poll(0):
try:
package = intf.recv(socket,
buf=True,
meta=rcvmeta,
flags=zmq.NOBLOCK)
# Handle receiving meta
if rcvmeta:
buf, meta, idx = package
else:
buf, idx = package
meta = None
arr = decoder(buf)
# Handle forwarding buffer
buf = buf if sndbuf else None
intf.send(out,
idx,
arr=arr,
buf=buf,
meta=meta,
flags=zmq.NOBLOCK)
except zmq.error.Again:
pass # ignore send misses to out.
missing = target - time.time()
if missing > 0:
time.sleep(missing)
def __init__(self, idx, worker_stats, filename_queue, color_buffer_queue,
*args, **kwargs):
super().__init__(*args, **kwargs)
self.idx = idx
self.worker_stats = worker_stats
self.parser = ImageParser(idx, worker_stats)
self.jpeg_loader = TurboJPEG()
self.num_images = 0
self.file_size_sum = 0
self.pixel_sum = 0
self.filename_queue = filename_queue
self.color_buffer_queue = color_buffer_queue
self.is_running = mp.Value(ctypes.c_bool, True)
def __init__(self):
"""Try to create TurboJPEG only once."""
try:
# TurboJPEG checks for libturbojpeg
# when its created, but it imports
# numpy which may or may not work so
# we have to guard the import here.
from turbojpeg import TurboJPEG # pylint: disable=import-outside-toplevel
TurboJPEGSingleton.__instance = TurboJPEG()
except Exception: # pylint: disable=broad-except
_LOGGER.exception(
"libturbojpeg is not installed, cameras may impact HomeKit performance."
)
TurboJPEGSingleton.__instance = False
def decode_img(buffer):
if TurboJPEG is not None:
global g_jpeg
if g_jpeg is None:
g_jpeg = TurboJPEG()
img = g_jpeg.decode(buffer, TJCS_RGB)
if img.shape[-1] == 1:
img = img[:, :, 0]
return img
buff = io.BytesIO(buffer)
img = PIL.Image.open(buff)
img = pillow2array(img, 'color')
return img
def __init__(self):
"""Try to create TurboJPEG only once."""
# pylint: disable=unused-private-member
# https://github.com/PyCQA/pylint/issues/4681
try:
# TurboJPEG checks for libturbojpeg
# when its created, but it imports
# numpy which may or may not work so
# we have to guard the import here.
from turbojpeg import TurboJPEG # pylint: disable=import-outside-toplevel
TurboJPEGSingleton.__instance = TurboJPEG()
except Exception: # pylint: disable=broad-except
_LOGGER.exception(
"Error loading libturbojpeg; Cameras may impact HomeKit performance"
)
TurboJPEGSingleton.__instance = False
def use_backend(backend):
"""Select a backend for image decoding.
Args:
backend (str): The image decoding backend type. Options are `cv2` and
`turbojpeg` (see https://github.com/lilohuang/PyTurboJPEG).
`turbojpeg` is faster but it only supports `.jpeg` file format.
"""
assert backend in supported_backends
global imread_backend
imread_backend = backend
if imread_backend == 'turbojpeg':
if TurboJPEG is None:
raise ImportError('`PyTurboJPEG` is not installed')
global jpeg
if jpeg is None:
jpeg = TurboJPEG()
def __init__(self, jpeg_quality, jpeg_lib, resize):
"""Constructor.
Args:
jpeg_quality (:obj:`int`): Quality of JPEG encoding, in 0, 100.
resize (:obj:`float'): resize factor in [0, 1]
"""
Thread.__init__(self)
self.cap = cv2.VideoCapture(0)
self.turbojpeg = TurboJPEG()
self.resize_factor = resize
self.running = True
self.buffer = None
self.lock = Lock()
self.jpeg_handler = utils.make_jpeg_handler(jpeg_lib, jpeg_quality)
def dec_ps(shutdown, infd, outfd):
context = zmq.Context()
socket = context.socket(zmq.PULL)
socket.connect(infd)
out = context.socket(zmq.PUSH)
out.connect(outfd)
poller = zmq.Poller()
poller.register(socket, zmq.POLLIN)
decoder = partial(TurboJPEG().decode,
flags=(TJFLAG_FASTDCT + TJFLAG_FASTUPSAMPLE))
while not shutdown.is_set():
if poller.poll(0):
buf = socket.recv()
idx = socket.recv_pyobj()
frame = decoder(buf)
send_ndarray_idx(frame, out, idx)
def __init__(self, node_name):
super().__init__(node_name, node_type=NodeType.PERCEPTION)
# parameters
self.publish_freq = DTParam("~publish_freq", -1)
self.alpha = DTParam("~alpha", 0.0)
# utility objects
self.jpeg = TurboJPEG()
self.reminder = DTReminder(frequency=self.publish_freq.value)
self.camera_model = None
self.rect_camera_info = None
self.mapx, self.mapy = None, None
# subscribers
self.sub_img = rospy.Subscriber(
"~image_in",
CompressedImage,
self.cb_image,
queue_size=1,
buff_size='10MB'
)
self.sub_camera_info = rospy.Subscriber(
"~camera_info_in",
CameraInfo,
self.cb_camera_info,
queue_size=1
)
# publishers
self.pub_img = rospy.Publisher(
"~image/compressed",
CompressedImage,
queue_size=1,
dt_topic_type=TopicType.PERCEPTION,
dt_healthy_freq=self.publish_freq.value,
dt_help="Rectified image (i.e., image with no distortion effects from the lens)."
)
self.pub_camera_info = rospy.Publisher(
"~camera_info",
CameraInfo,
queue_size=1,
dt_topic_type=TopicType.PERCEPTION,
dt_healthy_freq=self.publish_freq.value,
dt_help="Camera parameters for the (virtual) rectified camera."
)
def __init__(self):
# initialize the video into our
video_url_path = os.path.join("face_mask_detect", "static", "footages",
"cottonbro_2.mp4")
self.vs = FileVideoStream(path=video_url_path).start()
# Client list
self.stream_list = []
# Initialize video server
self.video_server = StreamServer(5001, self.stream_list, "image/jpeg")
self.video_server.activate()
# Initialize json server
self.js_server = ResponseServer(5003, "application/json")
self.js_server.activate()
# turbo jpeg initialization
self.jpeg = TurboJPEG()
def __getitem__(self, index):
img_path_list, org_ball_pos_xy, target_events, seg_path = self.events_infor[
index]
# Load segmentation
seg_img = load_raw_img(seg_path)
self.jpeg_reader = TurboJPEG(
) # improve it later (Only initialize it once)
# Load a sequence of images (-4, 4), resize images before stacking them together
# Use TurboJPEG to speed up the loading images' phase
resized_imgs = []
for img_path in img_path_list:
in_file = open(img_path, 'rb')
resized_imgs.append(
cv2.resize(self.jpeg_reader.decode(in_file.read(), 0),
(self.w_input, self.h_input)))
in_file.close()
resized_imgs = np.dstack(resized_imgs) # (128, 320, 27)
# Adjust ball pos: full HD --> (320, 128)
global_ball_pos_xy = self.__resize_ball_pos__(org_ball_pos_xy,
self.w_resize_ratio,
self.h_resize_ratio)
# Apply augmentation
if self.transform:
resized_imgs, global_ball_pos_xy, seg_img = self.transform(
resized_imgs, global_ball_pos_xy, seg_img)
# Adjust ball pos: (320, 128) --> full HD
org_ball_pos_xy = self.__resize_ball_pos__(global_ball_pos_xy,
1. / self.w_resize_ratio,
1. / self.h_resize_ratio)
# If the ball position is outside of the resized image, set position to -1, -1 --> No ball (just for safety)
self.__check_ball_pos__(org_ball_pos_xy, self.w_org, self.h_org)
self.__check_ball_pos__(global_ball_pos_xy, self.w_input, self.h_input)
# Transpose (H, W, C) to (C, H, W) --> fit input of Pytorch model
resized_imgs = resized_imgs.transpose(2, 0, 1)
target_seg = seg_img.transpose(2, 0, 1).astype(np.float)
# Segmentation mask should be 0 or 1
target_seg[target_seg < 75] = 0.
target_seg[target_seg >= 75] = 1.
return resized_imgs, org_ball_pos_xy.astype(np.int), global_ball_pos_xy.astype(np.int), \
target_events, target_seg