def __getitem__(self, idx):
"""
Indexed by video ID, then frame number
Returns self.window_size frames before the indexed frame to self.window_size
frames after the indexed frame
"""
video_id, start_frame, end_frame, label, path = self.items[idx]
# print(video_id, start_frame, end_frame)
if self.preload:
start_index = self.frames[video_id]['frame_nums'].index(
start_frame)
img_tensors = self.frames[video_id]['frames'][
start_index:start_index + self.window_size]
else:
# print((video_id, start_frame, end_frame, Video.objects.get(id=video_id).num_frames))
# img_tensors = [
# self.transform(f)
# for f in (Video.objects.get(id=video_id).for_scannertools() if self.local_path is None
# else st.Video(os.path.join(self.local_path, path))).frames(
# list(range(start_frame, end_frame))
# )
# ]
img_tensors = [
self.transform(f) for f in hwang.Decoder(
storehouse.RandomReadFile(
self.storehouse_backend,
os.path.join(self.local_path, path).encode('ascii'))).
retrieve(list(range(start_frame, end_frame)))
]
return torch.stack(img_tensors).permute(
1, 0, 2, 3), label, (video_id, start_frame, end_frame)
def as_hwang(self):
try:
video_file = storehouse.RandomReadFile(self._storage._storehouse(),
self._path.encode('ascii'))
except UserWarning:
raise Exception('Path to video `{}` does not exist.'.format(
self._path))
return hwang.Decoder(video_file)
def __init__(self, src, name, limit=-1, origin=np.array((0, 0))):
super().__init__(src, limit, name, origin)
import hwang
self.frame_count = 0
self.decoder = hwang.Decoder(self.src)
self.width = self.decoder.video_index.frame_width()
self.height = self.decoder.video_index.frame_height()
if limit == -1:
cap = cv2.VideoCapture(self.src)
self.frame_num = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
else:
self.frame_num = limit
self.frames = self.decoder.retrieve(
list(range(self.frame_num)
)) # TODO(ted): make sure that this is getting every frame?
self.iters = {}
def __init__(self,
src,
limit=-1,
origin=np.array((0, 0)),
offset=0,
rows=None,
hwang=False):
"""Constructs a videostream object
Input: src- Source camera or file or url
limit- Number of frames to pull
origin- Set coordinate origin
"""
self.src = src
self.limit = limit
self.origin = origin
self.propIds = None
self.cap = None
self.time_elapsed = 0
self.hwang = hwang
self.finished = False
# moved from __iter__ to __init__ due to continuous iterating
if hwang:
import hwang
if rows == None:
cap = cv2.VideoCapture(self.src)
rows = range(int(cap.get(cv2.CAP_PROP_FRAME_COUNT)))
print(rows)
self.rows = rows
self.frame_count = offset
self.frames = None
self.decoder = hwang.Decoder(self.src)
else:
self.offset = offset
self.frame_count = offset
self.cap = cv2.VideoCapture(self.src)
self.scale = get_scale(src)
def for_hwang(self):
import hwang, storehouse
backend = storehouse.StorageBackend.make_from_config(
storehouse.StorageConfig.make_posix_config())
dec = hwang.Decoder(storehouse.RandomReadFile(backend, self.path))
return dec