def _read_one(self, idx=None):
if idx is None:
idx = np.random.randint(self.num)
img1_fn = self.metas[idx][0]
img2_fn = self.metas[idx][1]
if self.flow_file_type == 'flo':
flowname = self.metas[idx][2]
else:
flownamex = self.metas[idx][2]
flownamey = self.metas[idx][3]
try:
img1_value = mc.pyvector()
self.mclient.Get(img1_fn, img1_value)
img_value_str1 = mc.ConvertBuffer(img1_value)
img1 = pil_loader(img_value_str1, ch=3)
img2_value = mc.pyvector()
self.mclient.Get(img2_fn, img2_value)
img_value_str2 = mc.ConvertBuffer(img2_value)
img2 = pil_loader(img_value_str2, ch=3)
if img1 is None or img2 is None:
raise Exception("None image")
if self.flow_file_type == "flo":
flo_value = mc.pyvector()
self.mclient.Get(flowname, flo_value)
flo_value_str = mc.ConvertBuffer(flo_value)
flow = read_flo_file(flo_value_str, memcached=True) # w, h, 2
else:
flox_value = mc.pyvector()
self.mclient.Get(flownamex, flox_value)
flox_value_str = mc.ConvertBuffer(flox_value)
flowx = pil_loader(flox_value_str, ch=1)
if flowx is None:
raise Exception("None flowx")
floy_value = mc.pyvector()
self.mclient.Get(flownamey, floy_value)
floy_value_str = mc.ConvertBuffer(floy_value)
flowy = pil_loader(floy_value_str, ch=1)
if flowy is None:
raise Exception("None flowy")
flowx = np.array(flowx).astype(np.float32) / 255 * 100 - 50
flowy = np.array(flowy).astype(np.float32) / 255 * 100 - 50
flow = np.concatenate(
(flowx[:, :, np.newaxis], flowy[:, :, np.newaxis]), axis=2)
except:
if self.flow_file_type == "flo":
print('Read image or flow [{}] failed ({}) ({})'.format(
idx, img1_fn, flowname))
else:
print('Read image or flow [{}] failed ({}) ({}) ({})'.format(
idx, img1_fn, flownamex, flownamey))
return self._read_one()
else:
return img1, img2, flow
def read_file(self, filepath):
if self.read_from == 'fake':
if self.initialized:
filebytes = self.saved_filebytes
else:
filebytes = self.saved_filebytes = np.fromfile(filepath, dtype=np.uint8)
self.initialized = True
elif self.read_from == 'mc':
self._init_memcached()
value = mc.pyvector()
self.mclient.Get(filepath, value)
value_str = mc.ConvertBuffer(value)
filebytes = np.frombuffer(value_str.tobytes(), dtype=np.uint8)
elif self.read_from == 'ceph':
self._init_ceph()
value = self.s3_client.Get(filepath)
filebytes = np.frombuffer(value, dtype=np.uint8)
elif self.read_from == 'petrel':
self._init_petrel()
value = self.client.Get(filepath)
filebytes = np.frombuffer(value, dtype=np.uint8)
elif self.read_from == 'fs':
filebytes = np.fromfile(filepath, dtype=np.uint8)
else:
raise RuntimeError("unknown value for read_from: {}".format(self.read_from))
return filebytes
def __getitem__(self, idx):
filename = self.root_dir + '/' + self.metas[idx][0]
t_cls = self.metas[idx][1]
b_cls = [int(0)] * 4193
for index in t_cls:
b_cls[int(index)] = int(1)
b_cls = torch.FloatTensor(b_cls)
# for id, v in enumerate(t_cls):
# print('label{}: {}'.format(id, v))
# for id, v in enumerate(b_cls):
# print('binary{}: {}'.format(id, v))
## memcached
server_list_config_file = "/mnt/lustre/share/memcached_client/server_list.conf"
client_config_file = "/mnt/lustre/share/memcached_client/client.conf"
mclient = mc.MemcachedClient.GetInstance(server_list_config_file,
client_config_file)
value = mc.pyvector()
mclient.Get(filename, value)
value_str = mc.ConvertBuffer(value)
img = pil_loader(value_str)
#img = np.zeros((350, 350, 3), dtype=np.uint8)
#img = Image.fromarray(img)
#cls = 0
## transform
if self.transform is not None:
img = self.transform(img)
return img, b_cls
def __call__(self, path):
import mc
mclient = mc.MemcachedClient.GetInstance(self.server_list_conf,
self.client_conf)
value = mc.pyvector()
mclient.Get(path, value)
content = mc.ConvertBuffer(value)
return bytes(content)
def _read_img_mc(self, path):
''' Return BGR, HWC, [0, 255], uint8'''
value = mc.pyvector()
self.mclient.Get(path, value)
value_buf = mc.ConvertBuffer(value)
img_array = np.frombuffer(value_buf, np.uint8)
img = cv2.imdecode(img_array, cv2.IMREAD_UNCHANGED)
return img
def _read_img(cls, file_path):
if mc_client is None:
return cv2.imread(file_path, cv2.IMREAD_UNCHANGED) / 255.
else:
pyvector = mc.pyvector()
mc_client.Get(file_path, pyvector)
buf = mc.ConvertBuffer(pyvector)
img_array = np.frombuffer(buf, np.uint8)
img = cv2.imdecode(img_array, cv2.IMREAD_UNCHANGED)
return img / 255.
def _read_img(cls, file_path):
if mc_client is None:
img = Image.open(file_path)
else:
pyvector = mc.pyvector()
mc_client.Get(file_path, pyvector)
buf = mc.ConvertBuffer(pyvector)
img = Image.open(io.BytesIO(np.frombuffer(buf, np.uint8)))
return img
def __call__(self, fn):
try:
img_value = mc.pyvector()
self.mclient.Get(fn, img_value)
img_value_str = mc.ConvertBuffer(img_value)
img = pil_loader(img_value_str)
except:
print('Read image failed ({})'.format(fn))
return None
else:
return img
def read_image_mc(
file_path,
server_list_config_file='/mnt/lustre/share/memcached_client/server_list.conf',
client_config_file='/mnt/lustre/share/memcached_client/client.conf'):
mclient = mc.MemcachedClient.GetInstance(server_list_config_file,
client_config_file)
value = mc.pyvector()
mclient.Get(file_path, value)
value_str = mc.ConvertString(value)
img_array = np.fromstring(value_str, np.uint8)
img = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
return img
def __getitem__(self, index):
self._init_memcached()
img_name, label = self.images[index]
img_name = os.path.join(self.root, img_name)
value = mc.pyvector()
self.mclient.Get(img_name, value)
value_str = mc.ConvertBuffer(value)
img = pil_loader(value_str)
if self.transform is not None:
img = self.transform(img)
return img, torch.Tensor(label)
def _cache_image(self, directory, idx):
if self.modality == 'RGB' or self.modality == 'RGBDiff':
path = os.path.join(directory, self.image_tmpl.format(idx))
server_list_config_file = "/mnt/lustre/share/memcached_client/server_list.conf"
client_config_file = "/mnt/lustre/share/memcached_client/client.conf"
mclient = mc.MemcachedClient.GetInstance(server_list_config_file,
client_config_file)
value = mc.pyvector()
mclient.Get(path, value)
value_str = mc.ConvertBuffer(value)
buff = io.BytesIO(value_str)
return [Image.open(buff).convert('RGB')]
def __getitem__(self, idx):
filename = self.root_dir + '/' + self.metas[idx][0]
cls = self.metas[idx][1]
## memcached
self._init_memcached()
value = mc.pyvector()
self.mclient.Get(filename, value)
value_str = mc.ConvertBuffer(value)
img = pil_loader(value_str)
## transform
if self.transform is not None:
img = self.transform(img)
return img, cls
def read_img_by_pil(img_path, color, mc_client=None):
img_format = "RGB" if color else "L"
if mc_client is not None:
value = mc.pyvector()
mc_client.Get(img_path, value)
value_str = mc.ConvertBuffer(value)
buff = io.BytesIO(value_str)
try:
img = Image.open(buff)
except OSError: # memcached error
img = Image.open(img_path)
else:
img = Image.open(img_path)
return img.convert(img_format)
def _load_image(self, fn):
if self.memcached:
try:
img_value = mc.pyvector()
self.mclient.Get(fn, img_value)
img_value_str = mc.ConvertBuffer(img_value)
img = utils.pil_loader(img_value_str)
except:
print('Read image failed ({})'.format(fn))
raise Exception("Exit")
else:
return img
else:
return Image.open(fn).convert('RGB')
def __init__(self, server_list_cfg, client_cfg, sys_path=None):
if (sys_path is not None):
import sys
sys.path.append(sys_path)
try:
import mc
except ImportError:
raise ImportError(
'Please install memcached to enable MemcachedBackend.')
self.server_list_cfg = server_list_cfg
self.client_cfg = client_cfg
self._client = mc.MemcachedClient.GetInstance(
self.server_list_cfg, self.client_cfg)
self._mc_buffer = mc.pyvector()
def _read_flo(cls, file_path):
if mc_client is None:
with open(file_path, "rb") as f:
buf = f.read()
else:
pyvector = mc.pyvector()
mc_client.Get(file_path, pyvector)
buf = mc.ConvertBuffer(pyvector).tobytes()
if not buf[:4] == b'PIEH':
raise Exception('Invalid .flo file format.')
w = int.from_bytes(buf[4:8], byteorder='little')
h = int.from_bytes(buf[8:12], byteorder='little')
flow = np.frombuffer(buf[12:], dtype=np.float32).reshape(h, w, 2)
return flow
def _read(self, idx=None):
if idx is None:
idx = np.random.randint(self.num)
fn = self.img_lst[idx]
try:
#img = pil_loader(open(fn, 'rb').read())
if self.memcached:
value = mc.pyvector()
self.mclient.Get(fn, value)
value_str = mc.ConvertBuffer(value)
img = pil_loader(value_str)
else:
img = pil_loader(open(fn, 'rb').read())
return img
except Exception as err:
print('Read image[{}, {}] failed ({})'.format(idx, fn, err))
return self._read()
def _read_npy(cls, file_path):
if mc_client is None:
return np.load(file_path)
else:
pyvector = mc.pyvector()
mc_client.Get(file_path, pyvector)
buf = mc.ConvertBuffer(pyvector)
buf_bytes = buf.tobytes()
if not buf_bytes[:6] == b'\x93NUMPY':
raise Exception('Invalid npy file format.')
header_size = int.from_bytes(buf_bytes[8:10], byteorder='little')
header = eval(buf_bytes[10:header_size + 10])
dtype = np.dtype(header['descr'])
nd_array = np.frombuffer(buf[header_size + 10:], dtype).reshape(header['shape'])
return nd_array
def _read_one(self, idx=None):
if idx is None:
idx = np.random.randint(self.num)
img_fn = self.metas[idx]
try:
img_value = mc.pyvector()
self.mclient.Get(img_fn, img_value)
img_value_str = mc.ConvertBuffer(img_value)
img = pil_loader(img_value_str, ch=3)
if img is None:
raise Exception("None image")
except:
print('Read image [{}] failed ({})'.format(idx, img_fn))
return self._read_one()
else:
return img
def _read_one(self, idx=None):
if idx is None:
idx = np.random.randint(self.num_img)
filename = self.lists[idx]
if self.metas is not None:
label = self.metas[idx]
else:
label = 0
try:
value = mc.pyvector()
self.mclient.Get(filename, value)
value_str = mc.ConvertBuffer(value)
img = pil_loader(value_str)
except:
print('Read image[{}] failed ({})'.format(idx, filename))
return self._read_one()
else:
return img, label
def __getitem__(self, idx):
filename = self.root_dir + '/' + self.metas[idx][0]
cls = self.metas[idx][1]
## memcached
server_list_config_file = "/mnt/lustre/share/memcached_client/server_list.conf"
client_config_file = "/mnt/lustre/share/memcached_client/client.conf"
mclient = mc.MemcachedClient.GetInstance(server_list_config_file, client_config_file)
value = mc.pyvector()
mclient.Get(filename, value)
value_str = mc.ConvertBuffer(value)
img = pil_loader(value_str)
# img = np.zeros((350, 350, 3), dtype=np.uint8)
# img = Image.fromarray(img)
# cls = 0
## transform
if self.transform is not None:
img = self.transform(img)
return img, cls
def _read_pcd(cls, file_path):
if mc_client is None:
pc = open3d.io.read_point_cloud(file_path)
ptcloud = np.array(pc.points)
else:
pyvector = mc.pyvector()
mc_client.Get(file_path, pyvector)
text = mc.ConvertString(pyvector).split('\n')
start_line_idx = len(text) - 1
for idx, line in enumerate(text):
if line == 'DATA ascii':
start_line_idx = idx + 1
break
ptcloud = text[start_line_idx:]
ptcloud = np.genfromtxt(BytesIO('\n'.join(ptcloud).encode()), dtype=np.float32)
# ptcloud = np.concatenate((ptcloud, np.array([[0, 0, 0]])), axis=0)
return ptcloud
def __init__(
self,
server_list_cfg="/mnt/lustre/share/memcached_client/server_list.conf",
client_cfg="/mnt/lustre/share/memcached_client/client.conf",
sys_path=None):
if sys_path is not None:
import sys
sys.path.append(sys_path)
try:
import mc
except ImportError:
raise ImportError(
'Please install memcached to enable MemcachedBackend.')
self.server_list_cfg = server_list_cfg
self.client_cfg = client_cfg
self._client = mc.MemcachedClient.GetInstance(self.server_list_cfg,
self.client_cfg)
# mc.pyvector servers as a point which points to a memory cache
self._mc_buffer = mc.pyvector()
def Read_img(self, path, mask=False):
if self.config.memcache.server:
# sensetime memcache
import mc
server_list_config_file = self.config.memcache.server_path
client_config_file = self.config.memcache.client_path
# 然后获取一个mc对象
mclient = mc.MemcachedClient.GetInstance(server_list_config_file,
client_config_file)
value = mc.pyvector()
mclient.Get(path, value)
value_str = mc.ConvertBuffer(value)
img_array = np.frombuffer(value_str, np.uint8)
if not mask:
img = cv2.imdecode(img_array, cv2.IMREAD_COLOR) # RGB
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
else:
img = cv2.imdecode(img_array, cv2.IMREAD_UNCHANGED) # RGB
else:
img = cv2.imread(path, cv2.IMREAD_UNCHANGED)
if not mask:
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
return img
def _load_image_memcached(self, pth):
self._ensure_memcached()
value = mc.pyvector()
self.mclient.Get(pth, value)
value_buf = mc.ConvertBuffer(value)
return imfrombytes(value_buf)
def read_file(self, meta_dict):
self._init_memcached()
value = mc.pyvector()
self.mclient.Get(meta_dict['filename'], value)
value_str = mc.ConvertBuffer(value)
return np.frombuffer(value_str.tobytes(), dtype=np.uint8)
def get_data(self, img_path, label_path, label_cache=None):
height = self.height
width = self.width
if os.environ.get('USE_MEMCACHE', '').lower() == 'true':
mc = self._ensure_memcached()
value = mc.pyvector()
self.mclient.Get(img_path, value)
#ConvertBuffer函数为value创建memoryview对象，用于numpy解析array
value_buf = mc.ConvertBuffer(value)
img_array = np.frombuffer(value_buf, np.uint8)
img = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
else:
img = cv2.imread(img_path) # BGR
if img is None:
raise ValueError('File corrupt {}'.format(img_path))
augment_hsv = True
if self.augment and augment_hsv:
# SV augmentation by 50%
fraction = 0.50
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
S = img_hsv[:, :, 1].astype(np.float32)
V = img_hsv[:, :, 2].astype(np.float32)
a = (random.random() * 2 - 1) * fraction + 1
S *= a
if a > 1:
np.clip(S, a_min=0, a_max=255, out=S)
a = (random.random() * 2 - 1) * fraction + 1
V *= a
if a > 1:
np.clip(V, a_min=0, a_max=255, out=V)
img_hsv[:, :, 1] = S.astype(np.uint8)
img_hsv[:, :, 2] = V.astype(np.uint8)
cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR, dst=img)
h, w, _ = img.shape
img, ratio, padw, padh = letterbox(img, height=height, width=width)
# Load labels
if os.path.isfile(label_path):
if label_cache is not None:
labels0 = label_cache[label_path].copy().astype(
np.float32).reshape(-1, 6)
else:
labels0 = np.loadtxt(label_path,
dtype=np.float32).reshape(-1, 6)
# Normalized xywh to pixel xyxy format
labels = labels0.copy()
labels[:,
2] = ratio * w * (labels0[:, 2] - labels0[:, 4] / 2) + padw
labels[:,
3] = ratio * h * (labels0[:, 3] - labels0[:, 5] / 2) + padh
labels[:,
4] = ratio * w * (labels0[:, 2] + labels0[:, 4] / 2) + padw
labels[:,
5] = ratio * h * (labels0[:, 3] + labels0[:, 5] / 2) + padh
else:
labels = np.array([])
# Augment image and labels
if self.augment:
img, labels, M = random_affine(img,
labels,
degrees=(-5, 5),
translate=(0.10, 0.10),
scale=(0.50, 1.20))
plotFlag = False
if plotFlag:
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
plt.figure(figsize=(50, 50))
plt.imshow(img[:, :, ::-1])
plt.plot(labels[:, [1, 3, 3, 1, 1]].T,
labels[:, [2, 2, 4, 4, 2]].T, '.-')
plt.axis('off')
plt.savefig('test.jpg')
time.sleep(10)
nL = len(labels)
if nL > 0:
# convert xyxy to xywh
labels[:, 2:6] = xyxy2xywh(labels[:, 2:6].copy()) # / height
labels[:, 2] /= width
labels[:, 3] /= height
labels[:, 4] /= width
labels[:, 5] /= height
if self.augment:
# random left-right flip
lr_flip = True
if lr_flip & (random.random() > 0.5):
img = np.fliplr(img)
if nL > 0:
labels[:, 2] = 1 - labels[:, 2]
img = np.ascontiguousarray(img[:, :, ::-1]) # BGR to RGB
if self.transforms is not None:
img = self.transforms(img)
return img, labels, img_path, (h, w)
