def get_minibatch(self,
list_used,
drawing_per_char=20,
mb_dim=32):
mb_x_i = np.zeros((mb_dim, self.n_samples, self.x_dim, self.x_dim, 1))
mb_y_i = np.zeros((mb_dim, self.n_samples), dtype=np.int)
mb_x_hat = np.zeros((mb_dim, self.x_dim, self.x_dim, 1))
mb_y_hat = np.zeros((mb_dim,), dtype=np.int)
for i in range(mb_dim):
ind = 0
pinds = np.random.permutation(self.n_samples)
class_indexes = np.random.choice(list_used.shape[0], self.y_dim, False)
x_hat_class = np.random.randint(self.y_dim)
for j, cur_class in enumerate(class_indexes): #each class
example_inds = np.random.choice(drawing_per_char, self.n_samples_per_class, False)
drawing_list = np.sort(glob.glob(os.path.join(list_used[cur_class][0], '*.png')))
for eind in example_inds:
cur_data = transform(get_image(drawing_list[eind]),
105, 105, resize_height=self.x_dim, resize_width=self.x_dim, crop=False)
mb_x_i[i, pinds[ind], :, :, 0] = np.rot90(cur_data, np.random.randint(4))
mb_y_i[i, pinds[ind]] = j
ind +=1
if j == x_hat_class:
eval_idx = np.random.choice(drawing_per_char, 1, False)[0]
cur_data = transform(get_image(drawing_list[eval_idx]),
105, 105, resize_height=self.x_dim, resize_width=self.x_dim, crop=False)
mb_x_hat[i, :, :, 0] = np.rot90(cur_data, np.random.randint(4))
mb_y_hat[i] = j
return mb_x_i, mb_y_i, mb_x_hat, mb_y_hat
def __getitem__(self, index):
key = self.samples[self.idx[index]]
image, seg = self.dataset[key[0]]["slices"][str(key[1])]
label = self.labels[index]
image = Image.fromarray(image)
# Make the segmentation the entire image if it isn't in masks_selector.
if not self.masks_selector[index]:
seg = np.ones(seg.shape)
# Make the segmentation the entire image if it is the negative class.
if int(label) == 0:
seg = np.ones(seg.shape)
# If there is a segmentation, blur it a bit.
if (self.blur > 0) and (seg.max() != 0):
seg = skimage.filters.gaussian(seg, self.blur)
seg = seg / seg.max()
seg = (seg > 0) * 1.
seg = Image.fromarray(seg)
if self.mode == "train":
image, seg = transform(image, seg, True, self.new_size)
else:
image, seg = transform(image, seg, False, self.new_size)
# Control condition where we mask all data. Used to see if traditional
# training works.
if self.mask_all:
image *= seg
return (image, seg), int(label), self.masks_selector[index]
def crop(img, center, scale, res, rot=0):
img = im_to_numpy(img)
# Preprocessing for efficient cropping
ht, wd = img.shape[0], img.shape[1]
sf = scale * 200.0 / res[0]
if sf < 2:
sf = 1
else:
new_size = int(np.math.floor(max(ht, wd) / sf))
new_ht = int(np.math.floor(ht / sf))
new_wd = int(np.math.floor(wd / sf))
if new_size < 2:
return torch.zeros(res[0], res[1], img.shape[2]) \
if len(img.shape) > 2 else torch.zeros(res[0], res[1])
else:
img = skimage.transform.resize(img, [new_ht, new_wd])
center = center * 1.0 / sf
scale = scale / sf
# print(scale)
# Upper left point
ul = np.array(transform([0, 0], center, scale, res, invert=1))
# Bottom right point
br = np.array(transform(res, center, scale, res, invert=1))
# print([ul, br])
# Padding so that when rotated proper amount of context is included
pad = int(np.linalg.norm(br - ul) / 2 - float(br[1] - ul[1]) / 2)
if not rot == 0:
ul -= pad
br += pad
new_shape = [br[1] - ul[1], br[0] - ul[0]]
if len(img.shape) > 2:
new_shape += [img.shape[2]]
new_img = np.zeros(new_shape)
# Range to fill new array
new_x = max(0, -ul[0]), min(br[0], len(img[0])) - ul[0]
new_y = max(0, -ul[1]), min(br[1], len(img)) - ul[1]
# Range to sample from original image
old_x = max(0, ul[0]), min(len(img[0]), br[0])
old_y = max(0, ul[1]), min(len(img), br[1])
new_img[new_y[0]:new_y[1], new_x[0]:new_x[1]] = img[old_y[0]:old_y[1], old_x[0]:old_x[1]]
if not rot == 0:
# Remove padding
new_img = scipy.misc.imrotate(new_img, rot)
new_img = new_img[pad:-pad, pad:-pad]
new_img = im_to_torch(skimage.transform.resize(new_img, res))
return new_img
def __getitem__(self, idx):
# str.split(' ')表示以空格分割字符串
image_path = self.root_dir + self.files_list[idx].split(' ')[0]
if not os.path.isfile(image_path):
print(image_path + 'does not exist!')
return None
image = io.imread(image_path) # use skitimage
label = int(self.files_list[idx].split(' ')[1])
if self.transform:
transform(image)
return image, label
def pad_to_bounding_box(image, offset_height, offset_width, target_height,
target_width):
transform = torchvision.transforms.Pad(
(offset_width, offset_height, 0, 0)) #left,top,right,bottom
image = transform(image)
(x, y) = image.size
if target_height > y:
transform = torchvision.transforms.Pad((0, 0, 0, target_height - y))
image = transform(image)
if target_width > x:
transform = torchvision.transforms.Pad((0, 0, target_width - x, 0))
image = transform(image)
return image
def get_picture(self, pic_name, transform):
img = skimage.io.imread(pic_name)
img = skimage.transform.resize(img, (256, 256))
img = np.asarray(img, dtype=np.float32)
# skimage.io.imshow(img)
# plt.show()
return transform(img)
def __getitem__(self, index):
video = os.path.join(self.video_root, self.num_video[index])
frames_list = sorted(listdir(video))
# print(len(frames_list))
# df = pd.read_csv(os.path.join(self.csv_root, self.num_csv[index]),header=None,squeeze=True)
# df = torch.tensor(df.values.tolist())
frames = []
labels = []
for img in frames_list:
# image = np.load(os.path.join(video,img))
# image = torch.from_numpy(image)
image = io.imread(os.path.join(video, img))
image = transform(image)
image = image.unsqueeze(dim=0)
image = vgg_feature(image.cuda()).view(-1)
# print(image.size())
frames.append(image)
frames = torch.stack(frames).cuda()
# frames = vgg_feature(frames)
# print("frames",frames.size())
print("num_video", self.num_video[index])
return self.num_video[index], frames
def main():
# initialise runner
logging.info('==> Initializing ModelInferRunner ...')
runner = ModelInferRunner(args)
# load model
logging.info('==> Loading model ...')
model = runner.load_model(
update_model_fn=create_update_model_fn(),
update_state_dict_fn=create_update_state_dict_fn())
model.eval()
logging.info('==> Loading an image from {} ...'.format(args.image))
image = Image.open(args.image)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])
x = transform(image)
y = model.forward(x.view([1, *x.shape]))
label = torch.argmax(F.softmax(y, dim=1), dim=1)[0]
print('Predicted label index: {}'.format(label))
def pad_to_bounding_box(image, offset_y, offset_x, target_y, target_x):
tensor2PIL = transforms.ToPILImage()
PIL2tensor = transforms.ToTensor()
transform = torchvision.transforms.Pad((offset_x, offset_y, 0, 0),
fill=0) #left,top,right,bottom
image = tensor2PIL(image)
image = transform(image)
(x, y) = image.size
if target_y > y:
transform = torchvision.transforms.Pad((0, 0, 0, target_y - y))
image = transform(image)
if target_x > x:
transform = torchvision.transforms.Pad((0, 0, target_x - x, 0))
image = transform(image)
image = PIL2tensor(image)
return image
def get_patch(path, size):
patch = Image.open(path).convert('RGB')
#patch.show()
patch = transform(patch, size)
return patch
def stretch_img(data, contrast=0.25):
""" Apply z-scale stretch to image """
transform = ZScaleInterval(contrast=contrast)
data_stretched = transform(data)
return data_stretched
def getImageTensor(rad_jimg):
paths = rad_jimg['file_paths'] # radiology
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([normalize])
# IMAGE
image_tensor = torch.zeros(len(paths), 3, 224, 224).to(device)
for i, path in enumerate(paths):
#image = Image.open(path).convert('RGB')
# Read image and process
img = imread(path)
if len(img.shape) == 2:
img = img[:, :, np.newaxis]
img = np.concatenate([img, img, img], axis=2)
img = resize(img, (224, 224))
img = img.transpose(2, 0, 1)
img = img / 255.
img = torch.FloatTensor(img).to(device)
if transform is not None:
img = transform(img)
image_tensor[i] = img
return image_tensor
def __getitem__(self, i):
# Read image
image = Image.open(self.images[i], mode='r')
image = image.convert('RGB')
# Read objects in this image (bounding boxes, labels, difficulties)
objects = self.objects[i]
boxes = torch.FloatTensor(objects['boxes']) # (n_objects, 4)
labels = torch.LongTensor(objects['labels']) # (n_objects)
difficulties = torch.ByteTensor(objects['difficulties']) # (n_objects)
# Discard difficult objects, if desired
if not self.keep_difficult:
boxes = boxes[1 - difficulties]
labels = labels[1 - difficulties]
difficulties = difficulties[1 - difficulties]
# Apply transformations
image, boxes, labels, difficulties = transform(image,
boxes,
labels,
difficulties,
split=self.split)
return image, boxes, labels, difficulties
def __getitem__(self, index):
ellipse_name = re.search(self.ELLIPSE_MATCH_PATTERN,
self._images[index])
if ellipse_name is None:
return None
ellipse_name = ellipse_name.group()
ellipse_image = skimage.io.imread(
os.path.join(self._root_dir, 'pics', self._images[index]))
ellipse_metadata_match = [
metadata_entry for metadata_entry in self._metadata
if re.search(ellipse_name, metadata_entry) is not None
]
assert len(ellipse_metadata_match) == 1
ellipse_metadata_strings = open(
os.path.join(self._root_dir, 'T',
ellipse_metadata_match[0])).readlines()
ellipse_metadata = torch.Tensor(
[float(line) for line in ellipse_metadata_strings])
print("Loading photo . . . ")
print(ellipse_name)
transform = torchvision.transforms.ToTensor()
ellipse_image = transform(ellipse_image)
return {
'image_tensor': ellipse_image,
'metadata_tensor': ellipse_metadata,
}
def loadjson(path, root_dir='./', transform=None):
load_f = open(path, 'r')
load_dict = json.load(load_f)
img_name = load_dict['imgName']
img_name = os.path.join(root_dir, img_name)
image = io.imread(img_name)
if transform:
image = transform(image)
d1, d2, d3 = image.shape
image = image.reshape([1, d1, d2, d3])
objs = load_dict['objs']
annotations = {'labels': np.empty((0, )), 'bboxes': np.empty((0, 4))}
for i in range(len(objs)):
annotations['labels'] = np.concatenate(
[annotations['labels'], [label_dic[objs[i]['label']]]], axis=0)
annotations['bboxes'] = np.concatenate([
annotations['bboxes'],
[[
objs[i]['xmin'],
objs[i]['ymin'],
objs[i]['xmax'],
objs[i]['ymax'],
]]
],
axis=0)
sample = {'image': image, 'annotations': annotations}
return sample
def __getitem__(self, idx):
if torch.is_tensor(idx):
idx = idx.tolist()
# get name of current image
img_name = self.mandelbrot_frame.iloc[idx, 0].split('_')
full_name = os.path.join(
self.root_dir,
img_name[0],
img_name[1] + '.jpg'
)
# load current image
image = io.imread(full_name)
coords = self.mandelbrot_frame.iloc[idx, 1:]
frame = np.asarray([coords])
frame = frame.astype('float').reshape(-1, 2)
sample = {'image': image, 'coords': coords}
if self.transform:
sample = transform(sample)
#print(f'TYPE of sample: {type(sample)}')
#print(f'TYPE of frame: {type(frame)}')
return sample
def augmented_sliding_window(patches, flip=False, mirror=False, rotations=[]):
transformed_patches = []
for patch in patches:
transformed_patches.extend(transform(patch, flip, mirror, rotations))
return transformed_patches
def preprocess_image(image):
'''
Preprocesses the image to load into the prebuilt network.
[input]
* image: numpy.ndarray of shape (H,W,3)
[output]
* image_processed: torch.Tensor of shape (3,H,W)
'''
# ----- TODO -----
#image = image.astype('float')
image = skimage.transform.resize(image, (224, 224))
h, w, channel = np.shape(image)
if channel == 1: # grey
image = np.matlib.repmat(image, 1, 1, 3)
if channel == 4: # special case
image = image[:, :, 0:3]
#print(image)
transform = torchvision.transforms.Compose([
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize((0.485, 0.456, 0.406),
(0.229, 0.224, 0.225))
])
image = transform(image)
image = image.unsqueeze(0)
return (image)
def get_imgs(img_path, imsize, bbox=None, transform=None, normalize=None):
img = Image.open(img_path).convert('RGB')
width, height = img.size
if bbox is not None:
r = int(np.maximum(bbox[2], bbox[3]) * 0.75)
center_x = int((2 * bbox[0] + bbox[2]) / 2)
center_y = int((2 * bbox[1] + bbox[3]) / 2)
y1 = np.maximum(0, center_y - r)
y2 = np.minimum(height, center_y + r)
x1 = np.maximum(0, center_x - r)
x2 = np.minimum(width, center_x + r)
img = img.crop([x1, y1, x2, y2])
if transform is not None:
img = transform(img)
ret = []
if cfg.GAN.B_DCGAN:
ret = [normalize(img)]
else:
for i in range(cfg.TREE.BRANCH_NUM):
# print(imsize[i])
if i < (cfg.TREE.BRANCH_NUM - 1):
re_img = transforms.Scale(imsize[i])(img)
else:
re_img = img
ret.append(normalize(re_img))
return ret
def __getitem__(self, idx):
row = self.df.iloc[idx].to_numpy() # get row out of big csv
# getting image
img_name = row[0]
image = io.imread(img_name)
# getting ground truth label
index = row[1]
label_name = img_name.replace('image_2',
'label_2').replace('png', 'txt')
label = ''
with open(label_name, 'r') as f:
lines = f.readlines()
if index >= len(lines):
# bad label bc yolo found more objects than reality
label = "Pedestrian 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00"
else:
label = lines[index]
label = label.split()
label[0] = self.types[label[0]]
label = [float(x) for x in label]
label = torch.Tensor(label)
# getting yolo outputs
yolo_outputs = row[2]
yolo_outputs = yolo_outputs.split(',')
yolo_outputs = [float(x) for x in yolo_outputs]
yolo_outputs = yolo_outputs[:-1]
yolo_outputs = torch.Tensor(yolo_outputs)
if self.transform:
image = transform(image)
return image, yolo_outputs, label
def preprocess(image):
label_3 = np.zeros(image.shape)
label = np.zeros(label_3.shape[0:2])
if 3 == len(label_3.shape):
label = label_3[:, :, 0]
elif 2 == len(label_3.shape):
label = label_3
if 3 == len(image.shape) and 2 == len(label.shape):
label = label[:, :, np.newaxis]
elif 2 == len(image.shape) and 2 == len(label.shape):
image = image[:, :, np.newaxis]
label = label[:, :, np.newaxis]
transform = transforms.Compose(
[data_loader.RescaleT(320),
data_loader.ToTensorLab(flag=0)])
sample = transform({
"imidx": np.array([0]),
"image": image,
"label": label
})
return sample
def applyTransforms(img):
img = np.array(img)
allTransforms = [
[colorPrecisionReduction], [jpegNoise], [swirl], [fftPerturbation],
[alterHSV, alterXYZ, alterLAB, alterYUV],
[
greyScaleMix, greyScalePartialMix, greyScaleMixTwoThirds,
oneChannelPartialGrey
], [gaussianBlur, chambolleDenoising, nonlocalMeansDenoising]
]
numTransforms = random.randint(0, 5)
id = str(img[0][0])
# savedImage = Image.fromarray(np.uint8(img), 'RGB')
# savedImage.save("sample_data/transform" + str(id) + str(0) + ".png")
#print("Original.")
img = img / 255.0
#for i in range(numTransforms):
for i in range(numTransforms):
transformGroup = random.choice(allTransforms)
transform = random.choice(transformGroup)
#transform = alterHSV
# print(img)
img = transform(img)
# savedImage = Image.fromarray(np.uint8(img * 255.0), 'RGB')
# savedImage.save("sample_data/transform" + str(id) + str(i + 1) + str(transform) + ".png")
allTransforms.remove(transformGroup)
return torch.from_numpy(np.swapaxes(img, 0, 2)).float()
def __getitem__(self, idx):
if self.train:
s = str(int(idx)+4000).zfill(5)
img_name = os.path.join(self.root_dir,
'train_images_128x128/train_{}.png'.format(s))
image = pil_loader(img_name)
img_name = os.path.join(self.root_dir,
'train_images_64x64/train_{}.png'.format(s))
image64 = pil_loader(img_name)
if self.transform:
if random.random() > 0.5:
image = TF.hflip(image)
image64 = TF.hflip(image64)
if random.random() > 0.5:
image = TF.vflip(image)
image64 = TF.vflip(image64)
image = self.transform(image)
image64 = self.transform(image64)# Random horizontal flipping
sample = {'img128': image, 'img64': image64, 'img_name':s}
else:
s = str(int(idx)+1).zfill(5)
img_name = os.path.join(self.root_dir,
'test_images_64x64/test_{}.png'.format(s))
image64 = pil_loader(img_name)
transform = transforms.Compose([
transforms.Grayscale(),
transforms.ToTensor()
])
if self.transform:
image64 = transform(image64)
sample = {'img64': image64, 'img_name':s}
return sample
def preprocess(image):
#print('Start image preprocess')
label_3 = np.zeros(image.shape)
label = np.zeros(label_3.shape[0:2])
if (3 == len(label_3.shape)):
label = label_3[:, :, 0]
elif (2 == len(label_3.shape)):
label = label_3
if (3 == len(image.shape) and 2 == len(label.shape)):
label = label[:, :, np.newaxis]
elif (2 == len(image.shape) and 2 == len(label.shape)):
image = image[:, :, np.newaxis]
label = label[:, :, np.newaxis]
transform = transforms.Compose([RescaleT(320), ToTensorLab(flag=0)])
sample = transform({
'imidx': np.array([0]),
'image': image,
'label': label
})
#print('Preprocess completed')
return sample
def CNN_features_1(encoder, image_path):
img = imread(image_path)
if len(img.shape) == 2:
img = img[:, :, np.newaxis]
img = np.concatenate([img, img, img], axis=2)
img = imresize(img, (256, 256))
img = img.transpose(2, 0, 1)
img = img / 255.
img = torch.FloatTensor(img).to(device)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([normalize])
image = transform(img) # (3, 256, 256)
# Encode
image = image.unsqueeze(0) # (1, 3, 256, 256)
encoder_out = encoder(
image) # (1, enc_image_size, enc_image_size, encoder_dim)
enc_image_size = encoder_out.size(1)
encoder_dim = encoder_out.size(3)
# Flatten encoding
encoder_out = encoder_out.view(1, -1,
encoder_dim) # (1, num_pixels, encoder_dim)
num_pixels = encoder_out.size(1)
return encoder_out[0, :, :]
def image_to_tensor(image, image_size=64):
transform = torchvision.transforms.Compose([
torchvision.transforms.Resize(image_size),
torchvision.transforms.ToTensor()
])
return transform(image).unsqueeze(0)
def __getitem__(self, index):
img_name = self.data[index]['name']
bbox = self.data[index]['bbox']
image = Image.open(os.path.join(self.img_dir, img_name))
if self.crop == True:
region = crop_data_of_img(bbox)
image = image.crop(tuple(region[0:4]))
if self.mode == 'test':
trans_crop = transforms.CenterCrop([54, 54])
else:
trans_crop = transforms.RandomCrop([54, 54])
transform = transforms.Compose([
transforms.Resize([64, 64]), trans_crop,
transforms.ToTensor(),
transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
image = transform(image)
length = len(bbox)
digits = [10 for i in range(5)]
# print('img_name : {}'.format(os.path.join(self.img_dir,img_name)))
for index in range(length):
if index >= 5:
break
# print('index : {}'.format(index) )
digits[index] = bbox[index][-1]
return image, length, digits
def preprocess_image(image):
'''
Preprocesses the image to load into the prebuilt network.
[input]
* image: numpy.ndarray of shape (H,W,3)
[output]
* image_processed: torch.Tensor of shape (3,H,W)
'''
image = skimage.transform.resize(image, (224, 224))
c = image.shape[2]
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
if c == 1:
image = np.matlib.repmat(image, 1, 1, 3)
if c == 4: # Weird, but found this error while processing
image = image[:, :, 0:3]
transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize(mean=mean, std=std)])
image = transform(image)
image = image.unsqueeze(0)
return image
def translate_coords(self, bias, y, x):
pattern_shape = self._raw_pattern.shape
ysize, xsize = pattern_shape
transform, lyscale, lxscale = bias
lyscale *= ysize
lxscale *= xsize
x, y = transform([[x / lxscale, y / lyscale]])
return y * lyscale, x * lxscale
def __getitem__(self, index):
# start = time.time()
with h5py.File(self.filename, "r") as f:
key = self.samples[self.idx[index]] # self.samples는 ('liver_0.nii.gz', '123')이 담겨있음. 환자와 그 환자의 몇번째 slice인지
image, seg = [], []
for num in range(self.depth):
# print(str(key[1]+num))
image_tmp, seg_tmp = f[key[0]]["slices"][str(key[1]+num)] # self.dataset는 hdf5 읽을 때 쓰는 f와 같음
image.append(image_tmp)
seg.append(seg_tmp)
image = np.stack(image, axis=2)
seg = np.stack(seg, axis=2).mean(2, keepdims=True)
label = self.labels[index]
use_mask = key[2]
# print(image.shape, seg.shape)
# Make the segmentation the entire image if it isn't in masks_selector.
# if not self.masks_selector[index]:
# seg = np.zeros(seg.shape)
# Make the segmentation the entire image if it is the negative class.
# if int(label) == 0:
# seg = np.ones(seg.shape)
# If there is a segmentation, blur it a bit.
# if (self.blur > 0) and (seg.max() != 0):
# seg = skimage.filters.gaussian(seg, self.blur)
# seg = seg / seg.max()
# seg = (seg > 0) * 1.
# print(time.time() - start, '1')
# start = time.time()
# data가 synthetic일 때는 flipping을 하면 안되므로 is_train을 False로 한다
if self.mode == "train" and 'synthetic' not in self.dataroot:
image, seg = transform(image, seg, True, self.new_size, self.mask_size, self.aug)
else:
image, seg = transform(image, seg, False, self.new_size, self.mask_size, self.aug)
# print(time.time() - start, '2')
return (image, seg), int(label), use_mask
def throw_party(out_file, img):
"""Make a party img. Might overwrite `img`!"""
offsets = [0, 2, 4, 2, 0, -2, -4, -2]
images = []
NUM_CHANNELS = 3
if len(img.shape) == 3 and img.shape[2] > 3:
img = img[:, :, :3]
for i in range(16):
offset = offsets[i % len(offsets)]
c = i % NUM_CHANNELS
images.append(transform(img, emphasize_channel=c, offset=offset))
writeGif(out_file, images, loops=float('inf'))
def throw_party_in_memory(img: np.array) -> bytes:
"""Make `img` party and return it as bytes."""
offsets_x = OFFSET_MULTIPLIER * np.sin(np.arange(-np.pi, np.pi, OFFSET_STEP))
offsets_y = OFFSET_MULTIPLIER * np.cos(np.arange(-np.pi, np.pi, OFFSET_STEP))
images = []
NUM_CHANNELS = 3
if len(img.shape) == 3 and img.shape[2] > 3:
img = img[:, :, :3]
for i, (offset_x, offset_y) in enumerate(zip(offsets_x, offsets_y)):
c = i % NUM_CHANNELS
images.append(
transform(img, emphasize_channel=c, offset_x=offset_x, offset_y=offset_y)
)
return imageio.mimwrite(imageio.RETURN_BYTES, images, format="gif", fps=FPS)
ctswarp_names = ['Reference', 'Rotate 90', 'Rotate 45', 'Dilation',
'Erosion', 'Y Reflection', 'X Shift', 'Row Shuffle',
'Sin()', 'Cosine', 'Rand.', 'Gauss',
'Rand. Affine', 'Gauss Noise','More Noise']
warp_continuous( sine )
# Call Metrics on list of test patterns
structural_sim( ctswarp_data )
reg_mse( ctswarp_data )
procrustes_analysis( ctswarp_data )
make_quadrants( ctswarp_data )
imse(ctswarp_data)
cw_ssim_value(ctswarp_data, 30)
transform( ctswarp_data )
disccost( ctswarp_data )
# Zip names, data, metrics, quadrants into a mega list!
# Generally this is indavisable because it relies on index locations...in the next cell we will make a dictionary.
cts_zip = zip(ctswarp_names, ctswarp_data, mse_vals, ssim_vals, disp_vals, top_lefts, top_rights, low_lefts, low_rights,
imse_vals, imse_maps, mse_maps, ssim_maps, cw_ssim_vals, cw_ssim_maps, mag_maps, freqs, dct_maps, dct_curves )
# In[15]:
continuous_dict = defaultdict(dict)
# Making a look up dictionary from all the patterns and their comparison scores.
# zipped list [i][0] is namne, 1 is full array, 2 is mse val, 3 is SSIM, 4 is PD,
# 5 through 8 are quadrants
# Subplot Titles and Dictionary Keys
binwarp_names = ['Original', 'Half Phase Shift', 'Rotate 90','Rotate 45',
'Dilation', 'Erosion','Y - Reflection', 'X Shift',
'Row Shuffle', 'Random Affine', 'Gauss', 'Random','Edges']
warp_binary(stripes)
# Call Metrics on list of test patterns
structural_sim( binwarp_data )
reg_mse( binwarp_data )
make_quadrants( binwarp_data )
imse(binwarp_data)
cw_ssim_value(binwarp_data, 30)
transform( binwarp_data )
disccost( binwarp_data )
# Match names and arrays
binary_zip = zip(binwarp_names,binwarp_data, mse_vals, ssim_vals, top_lefts,
top_rights, low_lefts, low_rights, imse_vals, imse_maps, mse_maps,
ssim_maps, cw_ssim_vals, cw_ssim_maps, mag_maps, freqs, dct_maps, dct_curves)
binary_dict = defaultdict(dict)
# Making a look up dictionary from all the patterns and their comparison scores.
# zipped list [i][0] is namne, 1 is full array, 2 is mse val, 3 is SSIM, 4 is PD,
# 5 through 8 are quadrants
# 9 is IMSE, 10 is IMSE Map...
def to_dict_w_hists( data_dict, keys, data_zip ):
# Call It.
warp_snow( snow_test )
# Call Metrics on list of test snows
structural_sim( snow_data )
reg_mse( snow_data )
procrustes_analysis( snow_data )
make_quadrants( snow_data )
imse(snow_data)
cw_ssim_value(snow_data, 30)
transform( snow_data )
disccost( snow_data )
# Zip names, data, metrics, quadrants into a mega list!
# Generally this is indavisable because it relies on indexing...in the next cell we will make a dictionary.
snow_zip = zip(snow_names,snow_data, mse_vals, ssim_vals, disp_vals, top_lefts, top_rights, low_lefts, low_rights,
imse_vals, imse_maps, mse_maps, ssim_maps, cw_ssim_vals, cw_ssim_maps, mag_maps, freqs, dct_maps, dct_curves )
# In[5]:
snow_dict = defaultdict(dict)
'''
# Making a look up dictionary from all the patterns and their comparison scores.
# zipped list [i][0] is namne, 1 is full array, 2 is mse val, 3 is SSIM, 4 is PD,