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 __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 _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_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_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(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_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_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 get(self, filepath): filepath = str(filepath) import mc self._client.Get(filepath, self._mc_buffer) value_buf = mc.ConvertBuffer(self._mc_buffer) return 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)