def generate(N, K):
zss, gt = _sample(N)
gt[0] = resize_img(gt[0], gt[1])
for key, (mu, std) in zss.items():
# sample from particular gaussian by multiplying + adding
if key == 'gen_samples':
sample = torch.randn(N * N, model.n_latents).to(device)
sample = sample.mul(std).add_(mu)
else:
sample = torch.randn(N, model.n_latents).to(device)
sample = sample.mul(std).add_(mu)
# generate
mnist_mean = torch.sigmoid(model.image_dec(sample)).view(-1, 1, 28, 28)
mnist_std = torch.tensor([0.1]).expand_as(mnist_mean).to(device)
svhn_mean = torch.sigmoid(model.sent_dec(sample)).view(-1, 3, 32, 32)
svhn_std = torch.tensor([0.1]).expand_as(svhn_mean).to(device)
if key == 'gen_samples':
mnist_sample = torch.randn((K,*(mnist_mean.size()))).to(device)
mnist_gen = mnist_sample.mul(mnist_std).add_(mnist_mean).transpose(0,1)
ms = [make_grid(t, nrow=int(sqrt(K)), padding=0) for t in mnist_gen.data.cpu()]
save_image(torch.stack(ms), '{}/gen_samples_0_{:03d}.png'.format(runPath, epoch), nrow=N)
svhn_sample = torch.randn((K,*(svhn_mean.size()))).to(device)
svhn_gen = svhn_sample.mul(svhn_std).add_(svhn_mean).transpose(0,1)
ss = [make_grid(t, nrow=int(sqrt(K)), padding=0) for t in svhn_gen.data.cpu()]
save_image(torch.stack(ss), '{}/gen_samples_1_{:03d}.png'.format(runPath, epoch), nrow=N)
else:
gt_idx = key.split('_')[-1]
mnist_recon = torch.cat([gt[int(gt_idx)].cpu(), resize_img(mnist_mean.cpu().data, svhn_mean)])
svhn_recon = torch.cat([gt[int(gt_idx)].cpu(), svhn_mean.cpu().data])
save_image(mnist_recon, '{}/{}x0_{:03d}.png'.format(runPath, key, epoch))
save_image(svhn_recon, '{}/{}x1_{:03d}.png'.format(runPath, key, epoch))
def on_created(self, event):
img_name = event.src_path.split('/')[-1]
img_path = 'static/img/'
resize_img(img_name, f'{img_path}/original/', f'{img_path}/small/')
add_watermark('ЛЁХА', img_name, f'{img_path}/original/', f'{img_path}/copyright/')
print(event)
def test_model(env, model):
model.eval()
env.max_path_length = 200
with torch.no_grad():
obs = env.reset()
for _ in range(env.max_path_length):
#Prepare tensors
img = env._get_viewer('human')._read_pixels_as_in_window()
img = resize_img(img)
img = np.expand_dims(img, axis=0)
t_img = torch.from_numpy(img).to(dtype=torch.float,
device=args.device)
config = np.expand_dims(obs[:3], axis=0)
t_config = torch.from_numpy(config).to(dtype=torch.float,
device=args.device)
#Execute action
action = model(t_img, t_config)
a = action.squeeze().cpu().numpy()
obs, reward, done, info = env.step(a)
env.render()
# Save video
if (_ < 1):
time.sleep(0.25)
close(env)
def _next(self, lr_size, hr_size, img_idx=None): if img_idx == None: img_idx = np.random.randint(self.ds_size) gt = self.gt[img_idx] h, w, _ = gt.shape y, x = randPos(h, w, hr_size) hr = np_crop(gt, y, x, hr_size) hr_flip, hr_rot = get_rand_aug() hr = augmentation(hr, hr_flip, hr_rot) lr = resize_img(hr, lr_size, lr_size, Image.BICUBIC) upcubic = resize_img(lr, hr_size, hr_size, Image.BICUBIC) return lr, upcubic, hr
def pair_embedding_to_video(sequence, model, params, video_name, fps):
class_num = params.NUM_CLASSES
embedding_dim = params.EMBEDDING_DIM
image_size = params.IMG_SIZE
OS = params.OUTPUT_SIZE
boards = []
for i in range(len(sequence) - 1):
prev_image = sequence[i]['image']
image = sequence[i + 1]['image']
board = np.zeros((image_size * 2, image_size * 2, 3))
x, _ = utils.prep_double_frame(sequence[i], sequence[i + 1])
outputs = model.predict(x)
outputs = np.squeeze(outputs)
embedding_pred = outputs[:, :, (class_num * 2):(class_num * 2 +
embedding_dim)]
prev_embedding_pred = outputs[:, :,
(class_num * 2 +
embedding_dim):((class_num * 2 +
embedding_dim * 2))]
combined_embedding_pred = np.zeros((OS, OS * 2, embedding_dim))
combined_embedding_pred[:, :OS, :] = prev_embedding_pred
combined_embedding_pred[:, OS:, :] = embedding_pred
board[:image_size, :image_size, :] = prev_image
board[:image_size, image_size:, :] = image
pc = principal_component_analysis(combined_embedding_pred,
embedding_dim)
pc = utils.resize_img(pc, image_size, image_size * 2)
board[image_size:, image_size:, :] = pc[:, image_size:, :]
board[image_size:, :image_size, :] = pc[:, :image_size, :]
board = float_to_uint8(board)
boards.append(board)
imgs_to_video(boards, video_name, fps)
return
def validate(scale):
dbs = []
for i in range(len(eval_gt_imgs)):
hr = eval_gt_imgs[i]
hr = modular_crop(hr, scale)
h, w, _ = hr.shape
lr = resize_img(hr, h // scale, w // scale)
upcubic = resize_img(lr, h, w)
inputs = np.asarray([lr], np.float32), np.asarray([upcubic],
np.float32), scale
output = net(inputs)
y_pred = clip255(unnormalize(output))
dbs.append(psnr(y_pred, hr))
return np.mean(dbs)
def submit(self):
if self.canvas.coords_list:
img = resize_img(list_to_sparse_matrix(self.canvas.coords_list))
preds = self.model.predict(img)[0].tolist()
preds_dict = {i: j for i, j in enumerate(preds)}
max_val = max(preds_dict, key=preds_dict.get)
self.popup(f"Prediction: {max_val} Confidence: {round(preds_dict[max_val]*100,2)}%")
else:
self.popup('You must enter a digit.')
def main(img_name: str, foreground_art: str, background_art: str,
operator_color: str) -> None:
"""Given the necessary information, create a wallpaper for the operator using PIL.
"""
# Create a new RGBA image
wip_img = Image.new("RGBA", DIMENSIONS)
draw = ImageDraw.Draw(wip_img)
# Verify that the operator has E2 art (rather, there's an URL for it)
# has_e2_img = str(background_art) != "nan"
ignore_bg_image = background_art == ""
# Load the background
bg_path = os.path.join("static", "resources", "bg.png")
bg = Image.open(bg_path, mode="r").convert("RGBA")
# Load E2 image if there is one
if ignore_bg_image != True:
res = requests.get(background_art)
e2_img = Image.open(BytesIO(res.content), mode="r").convert("RGBA")
# Change the image's opacity
e2_img = utils.change_alpha(e2_img, E2_ALPHA)
# Resize the image
e2_img = utils.resize_img(e2_img, 1.05)
# Center the E2 image horizontally
e2_coords = utils.calculate_e2_coordinates(e2_img, DIMENSIONS)
# Load E0 image
res = requests.get(foreground_art)
e0_img = Image.open(BytesIO(res.content), mode="r").resize(
(1024, 1024)).convert("RGBA")
# Calculate the drawing coordinates for the E0 image
e0_coords = utils.calculate_e0_coordinates(e0_img, DIMENSIONS)
# Create the E0 image shadow
shadow = Image.new("RGBA", e0_img.size, color=operator_color)
# Calculate the drawing coordinates for the E0 image shadow
shadow_coords = [coord + SHADOW_OFFSET for coord in e0_coords]
# Add the background
wip_img.paste(bg)
# Add the colored footer polygon
utils.create_and_paste_footer(wip_img, operator_color)
# Add the E2 image if there is one
if ignore_bg_image != True:
wip_img.paste(e2_img, e2_coords, mask=e2_img)
# Add the E0 image shadow
wip_img.paste(shadow, shadow_coords, mask=e0_img)
# Add the E0 image
wip_img.paste(e0_img, e0_coords, mask=e0_img)
# Save the resulting wallpaper
wip_img.save(img_name)
def standardize_img(img_file_path, img_w, img_h):
"""
Input:
img_file_path : this is path to image file
Output:
img : an three dimensions numpy array of the image above. It is standardized by
resizing the image to particular shape (img_w, img_h)
and dividing by 255 to make value range (0, 1)
"""
img = cv2.imread(img_file_path)
img = resize_img(img, (img_w, img_h))
img = img / 255
return np.array(img)
def process_cameras():
cameras = dbmngr.get_all_cameras()
# Download a frame from each of the cameras added
for camera in cameras:
camera_id = camera['camera_id']
camera_url = camera['url']
camera_coord = camera['coordinates']
original_img, img = resize_img(in_url=camera_url)
img_to_predict = np.asarray([img])
fight_prediction = fights_detector.predict(img_to_predict)
print('Fight prediction: ', fight_prediction,
np.argmax(fight_prediction))
fire_prediction = fire_detector.predict(img_to_predict)
print('Fire prediction: ', fire_prediction, np.argmax(fire_prediction))
crash_prediction = crash_detector.predict(img_to_predict)
print('Crash prediction: ', crash_prediction,
np.argmax(crash_prediction))
#gun_detection = detect_gun(original_img)
#print('Gun detection: ', gun_detection)
fight_prediction = np.argmax(fight_prediction)
fire_prediction = np.argmax(fire_prediction)
crash_prediction = np.argmax(crash_prediction)
if fight_prediction == 0:
print('Camera #%s - Fight detected!' % camera_id)
incident_id = dbmngr.add_incident(camera_id, 'warning',
incident_descriptions['fight'],
camera_coord)
save_footage(incident_id, original_img)
if fire_prediction == 0:
print('Camera #%s - Fire detected!' % camera_id)
incident_id = dbmngr.add_incident(camera_id, 'danger',
incident_descriptions['fire'],
camera_coord)
save_footage(incident_id, original_img)
if crash_prediction == 0:
print('Camera #%s - Car crash detected!' % camera_id)
incident_id = dbmngr.add_incident(
camera_id, 'danger', incident_descriptions['car_crash'],
camera_coord)
save_footage(incident_id, original_img)
#if gun_detection:
#print('Camera #%s - Gun detected!' % camera_id)
#incident_id = dbmngr.add_incident(camera_id, 'danger', incident_descriptions['weapon'], camera_coord)
#save_footage(incident_id, original_img)
dbmngr.count_incidents(camera_id)
def process_batch(
self, batch_sample
): # batch_sample: a list containing the paths to the center/left/right images and steering angle.
'''
Samples in each batch are processed.
The center, left, right, and horizontally flipped images are used and processed.
'''
# New augmented images and steering angles
images = []
steering_angles = []
# original measured steering_angle
steering_angle = np.float32(batch_sample[3]) # 4th column in csv
for image_directory_index in range(3):
image_file_name = batch_sample[image_directory_index].split(
'/'
)[-1] # split using '/' and [-1] indicates the last element in the list
# addition from center/left/right images
image = cv2.imread(
self.image_directory +
image_file_name) # opencv reads images in BGR color
cropped_image = utils.crop_img(image)
blurred_image = utils.blur_img(cropped_image) # gaussian blurring
resized_image = utils.resize_img(blurred_image)
yuv_image = utils.bgr2yuv(
resized_image) # bgr to yuv (as nVidia suggested)
images.append(yuv_image)
# steer angle correction on left/right images to balance the dataset with non-zero steering angles
if image_directory_index == 1: # left camera
steering_angles.append(steering_angle +
self.steering_recovery_factor)
elif image_directory_index == 2: # right camera
steering_angles.append(steering_angle -
self.steering_recovery_factor)
else: # center camera
steering_angles.append(steering_angle)
# if the magnitude of steering angle is bigger than 0.2, flipped image of center is added.
if image_directory_index == 0 and abs(steering_angle) > 0.2:
# if image_directory_index == 0:
images.append(utils.flip_img(yuv_image))
# images.append(utils.flip_img(cropped_resized))
steering_angles.append(steering_angle * (-1.0))
return images, steering_angles
def read_image(img_path):
"""
读取图片
:param img_path:
:return:
"""
origin = Image.open(img_path)
img = resize_img(origin, target_size)
if img.mode != 'RGB':
img = img.convert('RGB')
img = np.array(img).astype('float32').transpose((2, 0, 1)) # HWC to CHW
img -= 127.5
img *= 0.007843
img = img[np.newaxis, :]
return origin, img
def get_flow_from_shapes(shapes_info, image_size):
img = Image.new(mode='RGB', size=(image_size, image_size), color=(0, 0, 0))
draw_img = ImageDraw.Draw(img)
num = len(shapes_info)
for i in range(num):
shape_info = shapes_info[i]
draw_img = draw_flow(shape_info, draw_img)
flow = np.asarray(img, dtype = np.float)
flow = np.copy(flow[:, :, :2])
flow[flow != 0] -= 100
max_v = int(0.1 * image_size)
flow = flow / max_v
output_size = image_size // 4
flow = utils.resize_img(flow, output_size, output_size)
return flow
def detect_face(frame: Frame) -> dict:
ts = time.time()
cfg = frame.cfg.face_detect
img, scale = resize_img(
frame.img_gray if cfg.convert_gray else frame.image,
cfg.resize_img_pixel)
dets = detector(img, cfg.upsample)
count = len(dets)
max_area = 0
zones = []
for d in dets:
l, t, r, b = d.left(), d.top(), d.right(), d.bottom()
left = int(l / scale)
top = int(t / scale)
width = int((r - l) / scale)
height = int((b - t) / scale)
area = width * height
if max_area < area:
max_area = area
zones.append((left, top, width, height))
if cfg.draw_rect:
print('Rect:', (l, t, r, b), scale, ':',
(left, top, width, height), area, max_area)
cv2.rectangle(frame.image, (left, top),
(left + width, top + height), cfg.draw_rect_color,
cfg.draw_rect_thickness)
ret = {
'face_detected': count,
'face_area': max_area,
'face_zones': zones,
'face_ts': time.time() - ts,
'face_img': frame.image
}
img_path = cfg.save_image_path
if count > 0 and img_path:
file_name = (f'face-{frame.index}-{count}-{max_area}.jpg')
cv2.imwrite(img_path + '/' + file_name, frame.image)
ret['face_file'] = file_name
return ret
def get(self):
src = request.args.get("src")
url = request.args.get("url")
headers = {
'User-Agent':
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36',
'Referer': urlparse(url).scheme + '://' + urlparse(url).netloc
}
r = requests.get(src, headers=headers)
if r.status_code == requests.codes.OK:
if src.split('.')[-1] == 'gif':
res = make_response(r.content)
res.headers['Content-Type'] = r.headers['Content-Type']
return res
raw = resize_img(io.BytesIO(r.content))
return send_file(raw, mimetype='image/jpeg')
else:
r.raise_for_status()
def paint(self, event):
x, y = event.x, event.y
if self.canvas.old_coords:
x1, y1 = self.canvas.old_coords
d = math.sqrt(((x - x1)**2) + ((y - y1)**2))
if d <= 20:
self.canvas.create_line(x, y, x1, y1, capstyle=tk.ROUND, width=10)
else:
self.canvas.old_coords = None
self.canvas.old_coords = x, y
if x < self.canvas.winfo_width() and y < self.canvas.winfo_height():
self.canvas.coords_list.append((x, y))
img = resize_img(list_to_sparse_matrix(self.canvas.coords_list))
preds = self.model.predict(img)[0].tolist()
preds_dict = {i: j for i, j in enumerate(preds)}
self.plot.update_plot(preds_dict.values())
def __getitem__(self, idx):
self.current_item_path = self.inputs[idx]
input_img = correct_dims(nib.load(self.inputs[idx]).get_data())
label_img = gen_mask(self.labels[idx])
# Resize to input image and label to size (self.size x self.size x self.size)
if self.sampling_mode == "resize":
ex, label = resize_img(input_img, label_img, self.size)
# Constant center-crop sample of size (self.size x self.size x self.size)
elif self.sampling_mode == 'center':
ex, label = center_crop(input_img, label_img, self.size)
# Find centers of lesion masks and crop image to include them
# to measure consistent validation performance with small crops
elif self.sampling_mode == "center_val":
ex, label = find_and_crop_lesions(input_img, label_img, self.size,
self.deterministic)
# Randomly crop sample of size (self.size x self.size x self.size)
elif self.sampling_mode == "random":
ex, label = random_crop(input_img, label_img, self.size)
else:
print("Invalid sampling mode.")
exit()
ex = np.divide(ex, 255.0)
label = np.array([(label > 0).astype(int)]).squeeze()
# (experimental) APPLY RANDOM FLIPPING ALONG EACH AXIS
if not self.deterministic:
for i in range(3):
if random() > 0.5:
ex = np.flip(ex, i)
label = np.flip(label, i)
inputs = torch.from_numpy(ex.copy()).type(
torch.FloatTensor).unsqueeze(0)
labels = torch.from_numpy(label.copy()).type(
torch.FloatTensor).unsqueeze(0)
return inputs, labels
def preprocess(img, bbox_labels, input_size, mode):
"""
数据预处理，如果是训练模型，还会做一些图像增强和标注的轻微扰动
:param img:
:param bbox_labels:
:param input_size:
:param mode:
:return:
"""
sample_labels = np.array(bbox_labels)
if mode == 'train':
img = distort_image(img)
im_width, im_height = img.size
sample_labels = disturbance_box(sample_labels, im_width, im_height)
img, sample_labels = ramdom_rotate(img, sample_labels)
img = resize_img(img, input_size)
img = np.array(img).astype('float32')
img -= train_parameters['mean_rgb']
img = img.transpose((2, 0, 1)) # HWC to CHW
img *= 0.007843
return img, sample_labels
def transdir(imgdir, size):
filenum = 0
try:
list = os.listdir(imgdir)
except:
print "Donot exist image dir: " + imgdir
return
for line in list:
filepath = os.path.join(imgdir, line)
if os.path.isdir(filepath):
continue
elif os.path:
if filepath.find("jpg") or filepath.find("jpeg") or filepath.find(
"png"):
output_file_name = str(filenum) + '.png'
if utils.resize_img(filepath,
imgdir + '/resize/' + output_file_name,
size, False, size) == RESIZE_SUCCESS:
filenum += 1
print "Transform file " + filepath + " to " + output_file_name + " size:" + str(
size)
print "Transform file " + imgdir + " finished. filenum: " + str(filenum)
def _sample(N):
model.eval()
for batch_idx, dataT in enumerate(test_loader):
mnist, svhn = unpack_data(dataT, device=device)
break
gt = [mnist[:N], svhn[:N], torch.cat([resize_img(mnist[:N], svhn[:N]), svhn[:N]])]
zss = OrderedDict()
# mode 1: generate
zss['gen_samples'] = [torch.zeros((N * N, model.n_latents)).to(device),
torch.ones((N * N, model.n_latents)).to(device)]
# mode 2: mnist --> mnist, mnist --> svhn
mu, logvar = model.infer(image=gt[0])
zss['recon_0'] = [mu, logvar.mul(0.5).exp_()]
# mode 3: svhn --> mnist, svhn --> svhn
mu, logvar = model.infer(sent=gt[1])
zss['recon_1'] = [mu, logvar.mul(0.5).exp_()]
# mode 4: mnist, svhn --> mnist, mnist, svhn --> svhn
mu, logvar = model.infer(image=gt[0], sent=gt[1])
zss['recon_2'] = [mu, logvar.mul(0.5).exp_()]
return zss, gt
def telemetry(sid, data):
if data:
# The current steering angle of the car
steering_angle = data["steering_angle"]
# The current throttle of the car
throttle = data["throttle"]
# The current speed of the car
speed = data["speed"]
# The current image from the center camera of the car
imgString = data["image"]
image = Image.open(BytesIO(base64.b64decode(imgString)))
image_array = np.asarray(image)
## modified lines ##
image_array = utils.crop_img(image_array)
image_array = utils.blur_img(image_array)
image_array = utils.resize_img(image_array)
image_array = utils.rgb2yuv(image_array)
# This model currently assumes that the features of the model are just the images. Feel free to change this.
steering_angle = float(
model.predict(image_array[None, :, :, :], batch_size=1))
# Speed control using PI Controller
throttle = controller.update(float(speed))
print(steering_angle, throttle)
send_control(steering_angle, throttle)
# save frame
if args.image_folder != '':
timestamp = datetime.utcnow().strftime('%Y_%m_%d_%H_%M_%S_%f')[:-3]
image_filename = os.path.join(args.image_folder, timestamp)
image.save('{}.jpg'.format(image_filename))
else:
# NOTE: DON'T EDIT THIS.
sio.emit('manual', data={}, skip_sid=True)
def Generator(image_paths, mask_paths, shape=(256,256), batch_size = 32, \
preprocessing_mask_paths=None):
# ================ Debugging routine follows =============
if DEBUG_LEVEL >= 2:
assert image_paths, \
"Empty list of image paths provided in Generator"
assert mask_paths, \
"Empty list od mask_paths provided in Generator"
# ========================================================
batch_size = batch_size if batch_size < len(image_paths) else len(
image_paths)
idx = 0
while True:
images_to_load = image_paths[idx * batch_size:idx * batch_size +
batch_size]
corresponding_masks = mask_paths[idx * batch_size:idx * batch_size +
batch_size]
X = list(map(lambda path: cv2.imread(path), images_to_load)
) #TODO: this should be updated to a no cv2 solution
y = list(map(lambda path: cv2.imread(path), corresponding_masks))
# ================ Debugging routine follows =============
if DEBUG_LEVEL >= 2:
X_shapes = list(map(lambda x: x.shape, X))
y_shapes = list(map(lambda x: x.shape, y))
assert X_shapes == y_shapes
# ========================================================
if preprocessing_mask_paths:
preprocessing_masks_to_load = preprocessing_mask_paths[
idx * batch_size:idx * batch_size + batch_size]
preprocessing_masks = list(
map(lambda path: cv2.imread(path),
preprocessing_masks_to_load))
# ================ Debugging routine follows =============
if DEBUG_LEVEL >= 2:
preprocess_mask_shapes = list(map(lambda x: x.shape, \
preprocessing_masks))
assert preprocess_mask_shapes == X_shapes, \
"Preprocessing masks and images do not feature the same shape"
# ========================================================
l = list(zip(X, preprocessing_masks))
# do segment the X,y with the preprocessing mask
X = list(map(lambda el: get_segment_crop(el[0], mask=el[1]), l))
l = zip(y, preprocessing_masks)
y = list(map(lambda el: get_segment_crop(el[0], mask=el[1]), l))
# FIXME: set the shape here ...
X = list(map(lambda img: resize_img(img), X))
y = list(map(lambda mask: resize_img(mask), y))
for i, img in enumerate(y):
if img is None:
print(' [EROOR INFO] None image Loaded: ',
corresponding_masks[i])
exit(1)
#X = list(map(lambda img: cv2.resize(img, shape) if img.shape!=shape else img, X))
#y = list(map(lambda img: cv2.resize(img, shape) if img.shape!=shape else img, y))
#X, y = augment(X, y) #FIXME: this is an issue ...
X = list(map(lambda img: cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), X))
y = list(map(lambda img: cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), y))
X = list(map(lambda img: exposure.equalize_hist(img), X))
y = list(map(lambda img: img // 255, y))
# expand dims to fit the network architecture
X = list(map(lambda x: np.expand_dims(x, 2), X))
y = list(map(lambda x: np.expand_dims(x, 2), y))
if len(image_paths) < batch_size:
batch_size = len(image_paths)
# ================ Debugging routine follows =============
if DEBUG_LEVEL > 1:
assert image_paths, "Empty image_paths list"
if DEBUG_LEVEL > 0:
assert batch_size, "Batch_size is 0 really?"
# ========================================================
idx = (idx + 1) % (len(image_paths) // batch_size)
yield np.array(X), np.array(y)
def stabilize(args):
# args.resize = True
print("reading images")
if args.img_dir[-4:] == '.mp4' or args.img_dir[-4:] == '.avi':
from utils import vid2img_lists
img_lists = vid2img_lists(args.img_dir)
else:
from utils import file2lists
img_lists = file2lists(os.path.join(args.img_dir, 'img_lists.txt'))
img_lists = [item_i for item_i in img_lists if item_i[-3:] == 'png']
img_lists = sorted(img_lists)
img_lists = [
os.path.join(args.img_dir, item_i) for item_i in img_lists
]
img_lists = [cv2.imread(fn)[:, :, ::-1] for fn in img_lists]
raw_shape = img_lists[0].shape
if args.resize:
img_lists = [pad_img(img, pwc_opt.pyr_lvls) for img in img_lists]
else:
from utils import resize_img
img_lists = [resize_img(img, pwc_opt.pyr_lvls) for img in img_lists]
first_img_p, mid_img_p, end_img_p = tf.placeholder(dtype=tf.float32, shape=[None, None, None, 3]), \
tf.placeholder(dtype=tf.float32, shape=[None, None, None, 3]), \
tf.placeholder(dtype=tf.float32, shape=[None, None, None, 3])
out_img_ts, debug_out_ts = build_model_test(first_img_p,
mid_img_p,
end_img_p,
training=False,
trainable=True)
sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False))
# sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(
sess, checkpoint_path + args.lr_str + '/stab.ckpt-' + str(args.modeli))
for iter in range(args.stab_iter):
print("--------iter {}---------".format(iter))
next_img_lists = []
for k in range(args.skip):
next_img_lists.append(img_lists[k])
for k in range(args.skip, len(img_lists) - args.skip):
cur_img = img_lists[k]
first_img = img_lists[k - args.skip]
end_img = img_lists[k + args.skip]
cur_img_, first_img_, end_img_ = list(
map(lambda x: np.expand_dims(x, 0),
[cur_img, first_img, end_img]))
out_img, debug_out = sess.run([out_img_ts, debug_out_ts],
feed_dict={
first_img_p: first_img_,
mid_img_p: cur_img_,
end_img_p: end_img_
})
out_img = out_img.squeeze()
out_img = np.array(out_img * 255.0).astype(np.uint8)
next_img_lists.append(out_img)
if args.debug:
debug_img_lists_k = [
'first_img', 'cur_img', 'end_img', 'out_img'
]
debug_img_lists_v = [
first_img[:, :, ::-1], cur_img[:, :, ::-1],
end_img[:, :, ::-1], out_img[:, :, ::-1]
]
debug_img_lists = dict(
zip(debug_img_lists_k, debug_img_lists_v))
# write_imgs(debug_img_lists, k, args.debug_out_dir)
[
warped_first, warped_end, img_int, flow_pred0, flow_pred1,
flow_pred2
] = debug_out
debug_flow_lists_k = [
'first2end_flow', 'end2first_flow', 'mid2int_flow'
]
debug_flow_lists_v = [
flow_pred0[0], flow_pred2[0], flow_pred1[0]
]
debug_flow_lists = dict(
zip(debug_flow_lists_k, debug_flow_lists_v))
write_flows(debug_flow_lists, k, args.debug_out_dir)
for k in range(len(img_lists) - args.skip, len(img_lists)):
next_img_lists.append(img_lists[k])
img_lists = next_img_lists
if args.resize:
img_lists = [unpad_img(img, raw_shape) for img in img_lists]
else:
from utils import back_resize_img
img_lists = [back_resize_img(img, raw_shape) for img in img_lists]
# import pdb;pdb.set_trace();
if args.img_dir[-4:] == '.mp4':
from utils import save2vid
save2vid(img_lists, args.out_dir, args.img_dir)
else:
save_img_lists(img_lists, args.out_dir)
#Open Software Project - Final project / 홍유진 장다솜
import cv2
import numpy as np
import os
import argparse
from utils import find_vertices, resize_img
for file in os.listdir("./input"):
filename, extention = file.split(".")
# Read the image and resize it
image = cv2.imread("./input/" + file)
image = resize_img(image)
# Show the resized original image.
# cv2.imshow('INPUT',image)
# Convert to grayscale and find edges
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(gray, (5, 5), 0)
edge = cv2.Canny(blur, 50, 150)
#cv2.imshow('Canny',edge)
#Find and draw contours
contours, _ = cv2.findContours(edge.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(image, contours, -1, [0, 255, 0], 2)
#cv2.imshow('Contours',image)
#Find the part of the document(maximum area) in the image devided by contours
segmentation_model.load_weights(weight_file[0])
# make directories
out_dir = os.path.join(out_home_dir, task)
if not os.path.isdir(out_dir):
os.makedirs(out_dir)
# iterate all images
for img_dir in img_dirs:
filenames = utils.all_files_under(img_dir)
for filename in filenames:
assert "IDRiD_" in os.path.basename(filename)
# load an img (tensor shape of [1,h,w,3])
img = utils.imagefiles2arrs([filename])
_, h, w, _ = img.shape
assert h == 2848 and w == 4288
resized_img = utils.resize_img(img)
# run inference
segmented = segmentation_model.predict(
utils.normalize(resized_img), batch_size=1)
# cut by threshold
segmented = segmented[0, ..., 0]
segmented_sizeup = utils.sizeup(segmented)
# save the result
Image.fromarray(
(segmented_sizeup * 255).astype(np.uint8)).save(
os.path.join(out_dir, os.path.basename(filename)))
def resize(img):
return utils.resize_img(img, target_size=(input_height, input_width))
import cv2
import math
import numpy as np
import matplotlib.pyplot as plt
import subprocess, os
import utils
import subprocess, os
orb = cv2.ORB_create()
# orb is an alternative to SIFT
test_img = utils.read_img('test1.jpg')
#resizing must be dynamic
test_img = utils.resize_img(test_img, 0.2)
# display('original', original)
# keypoints and descriptors
# (kp1, des1) = orb.detectAndCompute(test_img, None)
(kp1, des1) = orb.detectAndCompute(test_img, None)
training_set = os.listdir('training-data/')
for ind in range(0, len(training_set)):
training_set[ind] = 'training-data/' + training_set[ind]
max_val = 8
max_pt = -1
max_kp = 0
good = []
SAA - self adaptive algorithm
FAS - fast adaptive similarity filter
Images from https://pixabay.com/images/search/
"""
import time
import utils
import constants
import NEAVF
start = time.time()
# Read, resize and plot images
size = (300, 400)
img_list = utils.read_images(constants.DATASET_PATH)
img_list = utils.resize_img(img_list, size)
# utils.show_image_list(img_list, "Initial images!")
img_list_gauss = []
img_list_impulsive = []
index = 0
for img in img_list:
img_list_gauss.append(utils.gaussian_noise(img, 0.1))
img_list_impulsive.append(utils.salt_and_pepper(img, 0.1))
index += 1
# utils.show_image_list(img_list_gauss, "Images with gaussian noise! 0.1")
# utils.show_image_list(img_list_impulsive, "Image with salt and pepper noise! 0.1")
# Two images with 2 values of noise
img_list_gauss_005 = []
img_list_gauss_015 = []
IMG_HEIGHT = 256
IMG_WIDTH = 256
list_shapes = []
print('Reading train and val..')
for i in range(total_train):
print(i)
img_path = train_fold + '/' + train_ids[i] + '/images/' + train_ids[i] + '.png'
img = cv2.imread(img_path,1) #256 x 256 x 3?
# pdb.set_trace()
mask = create_mask(train_fold + '/' + train_ids[i], shape = (img.shape[0], img.shape[1],1))
print(mask.shape)
old_shape = img.shape
img = np.dstack([normalize_img(img[:,:,q]) for q in range(3) ])
if (img.shape != (IMG_HEIGHT, IMG_WIDTH, 3)): # resize it
img = resize_img(img, shape = (IMG_HEIGHT, IMG_WIDTH, 3))
mask = resize_img(mask, shape = (IMG_HEIGHT, IMG_WIDTH,1))
# if img.shape in list_shapes:
# pass
# else:
# list_shapes.append(img.shape)
# pdb.set_trace()
# cv2.imshow('image',img)
# cv2.waitKey(0)
# cv2.imshow('mask',mask)
# cv2.waitKey(0)
# pdb.set_trace()
if i<n_train:
train_imgs[i,:,:,:] = img
train_masks[i,:,:,:] = mask
def get_image_from_shapes(shapes, image_size):
output_size = image_size // 4
img = Image.new(mode='RGB', size=(image_size, image_size), color=(255, 255, 255))
mask = Image.new(mode='I', size=(image_size, image_size), color=0)
full_mask = Image.new(mode='I', size=(image_size, image_size), color=0)
class_mask = Image.new(mode='I', size=(image_size, image_size), color=0)
draw_img = ImageDraw.Draw(img)
draw_mask = ImageDraw.Draw(mask)
draw_full_mask = ImageDraw.Draw(full_mask)
draw_class_mask = ImageDraw.Draw(class_mask)
background_all_ones = np.array([
(0, 0), (image_size, 0), (image_size, image_size), (0, image_size), (0, 0)])
corners = utils.totuple(background_all_ones)
draw_full_mask.polygon([tuple(p) for p in corners], fill=1, outline=1)
full_masks_list = []
full_masks_list.append(full_mask)
draws = {
'draw_img': draw_img,
'draw_mask': draw_mask,
'draw_class_mask': draw_class_mask
}
num_shapes = len(shapes)
instance_to_class = np.zeros(shape=(num_shapes+1))
velocities = np.zeros((num_shapes, 2))
for i in range(num_shapes):
shape_info = shapes[i]
if 'velocity' in shape_info:
velocities[i, :] = shape_info['velocity']
full_mask = Image.new(mode='I', size=(image_size, image_size), color=0)
draw_full_mask = ImageDraw.Draw(full_mask)
draws['draw_full_mask'] = draw_full_mask
draws = draw_shapes(shape_info, draws, i+1)
full_masks_list.append(full_mask)
instance_to_class[i+1] = shape_info['shape_choice_int']
image = np.asarray(img) / 255.0
mask = np.asarray(mask)
class_mask = np.asarray(class_mask)
stacked_full_masks = np.zeros((image_size, image_size, num_shapes+1))
full_masks = []
# NOTE: The values of [x_center] [y_center] [width] [height]
# are normalized by the width/height of the image, so they are
# float numbers ranging from 0 to 1.
bboxes = []
for i in range(num_shapes+1):
full_mask = np.asarray(full_masks_list[i], dtype=np.uint8)
stacked_full_masks[:, :, i] = full_mask
if i > 0:
bbox = utils.mask2bbox(full_mask, image_size)
if bbox:
bboxes.append(bbox)
full_mask = utils.resize_img(full_mask, output_size, output_size)
full_masks.append(full_mask)
mask_count = np.sum(stacked_full_masks, axis=2)
occ_mask = np.zeros((image_size, image_size))
update_idx = (mask_count >= 3)
obj_idx_array = stacked_full_masks[update_idx]
obj_idx_pool = np.linspace(0, num_shapes, num_shapes+1)
obj_idx = np.multiply(obj_idx_pool, (obj_idx_array).astype(int))
num_update_pixels = obj_idx.shape[0]
obj_unique_idx = np.zeros((num_update_pixels, 1))
for i in range(num_update_pixels):
obj_unique_idx[i] = np.unique(obj_idx[i, :])[-2]
occ_mask[update_idx] = np.squeeze(obj_unique_idx)
occ_class_mask = np.zeros_like(class_mask)
for i in range(num_shapes+1):
occ_class_mask[occ_mask == i] = instance_to_class[i]
classes = [shape_info['shape_choice_int'] for shape_info in shapes]
# cast to data-efficient type
image = image.astype(np.uint8)
mask = mask.astype(np.uint8)
occ_mask = occ_mask.astype(np.uint8)
class_mask = class_mask.astype(np.uint8)
occ_class_mask = occ_class_mask.astype(np.uint8)
# resize before saving
mask = utils.resize_img(mask, output_size, output_size)
occ_mask = utils.resize_img(occ_mask, output_size, output_size)
class_mask = utils.resize_img(class_mask, output_size, output_size)
occ_class_mask = utils.resize_img(occ_class_mask, output_size, output_size)
image_info = {
'image': image,
'instance_mask': mask,
'occ_instance_mask': occ_mask,
'class_mask': class_mask,
'occ_class_mask': occ_class_mask,
'full_masks': full_masks,
'velocities': velocities,
'classes': classes,
'bboxes': bboxes
}
return image_info
