def fn_name(resolution, surface_filename, surface_path):
gmdt = apply_mask(resolution, read_surface(surface_filename, surface_path))
currents, u, v = calc_currents(resolution, gmdt)
currents = apply_mask(resolution, currents)
# print(gmdt.min(), gmdt.max(), gmdt.mean())
mdt = centralise_mdt(resolution, gmdt)
# print(mdt.min(), mdt.max(), mdt.mean())
return mdt, currents
def timeseries_avg_3d(file_path,
var_name,
grid,
gtype='t',
time_index=None,
t_start=None,
t_end=None,
time_average=False,
mask=None):
data = read_netcdf(file_path,
var_name,
time_index=time_index,
t_start=t_start,
t_end=t_end,
time_average=time_average)
if len(data.shape) == 3:
# Just one timestep; add a dummy time dimension
data = np.expand_dims(data, 0)
# Process one time index at a time to save memory
timeseries = []
for t in range(data.shape[0]):
if mask is None:
data_tmp = mask_3d(data[t, :], grid, gtype=gtype)
else:
data_tmp = apply_mask(data[t, :],
np.invert(mask),
depth_dependent=True)
# Volume average
timeseries.append(volume_average(data_tmp, grid, gtype=gtype))
return np.array(timeseries)
def eval(net, data_loader, epoch, writer):
print('Evaluatin at epoch %d'%(epoch))
net.eval()
for iter, sample in enumerate(data_loader):
image = sample['image'].cuda()
depth = sample['depth'].cuda()
label = sample['label'].cuda()
with torch.no_grad():
params, pred_masks = net(image)
mask = F.softmax(pred_masks[0], dim=1)
for j in range(image.size(0)):
writer.add_image('Val Input Image/%d' % (j+iter*image.size(0)), tensor_to_X_image(image[j].cpu()),
iter + epoch * len(data_loader))
writer.add_image('Val GT Depth/%d' % (j+iter*image.size(0)), 1. / depth[j], iter + epoch * len(data_loader))
writer.add_image('Val GT Mask/%d' % (j+iter*image.size(0)), label[j], iter + epoch * len(data_loader))
# apply mask to input image
cur_mask = mask[j].detach().cpu().numpy().argmax(axis=0)
masked_image = apply_mask(image[j].cpu(), cur_mask, ignore_index=mask.size(1) - 1)
writer.add_image('Val Masked Image/%d' % (j+iter*image.size(0)), masked_image, iter + epoch * len(data_loader))
# predict mask
for k in range(mask.size(1) - 1):
writer.add_image('Val Mask %d/%d' % (k, j+iter*image.size(0)), mask[j, k:k + 1], iter + epoch * len(data_loader))
# non plane mask
writer.add_image('Val Non-plane Mask/%d' % (j+iter*image.size(0)), mask[j, -1:], iter + epoch * len(data_loader))
def main(r, g, b, negdh, posdh, mins, maxs, minv, maxv, input_path, output_path):
if input_path is None:
camera = cv2.VideoCapture(0)
camera.set(
cv2.CAP_PROP_FRAME_WIDTH, 800
) # Higer value will cause error on FPGA
camera.set(
cv2.CAP_PROP_FRAME_HEIGHT, 600
) # Higer value will cause error on FPGA
camera.set(cv2.CAP_PROP_FPS, 5)
_, frame = camera.read()
else:
frame = cv2.imread(input_path)
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
mask, frame = apply_mask(frame, r, g, b, negdh, posdh, mins, maxs, minv, maxv)
nrpc = calculate_nrpc(mask)
if output_path is not None:
time_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
text = "{}, NRPC: {:.4f}".format(time_str, nrpc)
draw_text(img=frame, text=text)
cv2.imwrite(output_path, frame)
return nrpc
def paintEvent(self, event):
super().paintEvent(event)
frame = self.camera.frame
if frame is not None:
painter = QPainter(self)
(h, w) = frame.shape[:2]
if self.selected_color_rgb[0] is not None:
_, frame = apply_mask(
frame=frame,
r=self.selected_color_rgb[0],
g=self.selected_color_rgb[1],
b=self.selected_color_rgb[2],
negdh=self.hsv_min_hue,
posdh=self.hsv_max_hue,
mins=self.hsv_min_saturation,
maxs=self.hsv_max_saturation,
minv=self.hsv_min_value,
maxv=self.hsv_max_value,
)
q_image = QImage(frame, w, h, QImage.Format_RGB888)
q_pixmap = QPixmap.fromImage(q_image)
painter.drawPixmap(0, 0, q_pixmap)
def _parse_frame_payload(self):
frame = self.frames[-1]
payload = self._get_data()
if frame['mask'] and payload:
payload = apply_mask(payload, frame['mask'])
frame['payload'] = payload
self._handle_frame()
def test_apply_mask(self):
self.assertEqual(utils.apply_mask('192.168.233.89', '255.255.255.0'), '192.168.233.0')
self.assertEqual(utils.apply_mask('192.168.233.89', '255.255.255.254'), '192.168.233.88')
self.assertEqual(utils.apply_mask('192.168.233.89', '0.0.0.0'), '0.0.0.0')
self.assertEqual(utils.apply_mask('192.168.233.89', '255.0.0.0'), '192.0.0.0')
self.assertEqual(utils.apply_mask('192.168.233.89', '255.0.0.0'), '192.0.0.0')
self.assertEqual(utils.apply_mask('192.168.233.89', '1.0.0.0'), 'invalid entry')
self.assertEqual(utils.apply_mask('192.168.233', '255.0.0.0'), 'invalid entry')
def evaluate_model(hyperparams):
means = []
for mask in tqdm(masks):
# generate missing data, model and trainer
data = LinkPredData(args.dataset, seed=args.seed)
apply_mask(data.features, mask) # convert masked number to nan
model = VGAEmf(data, args.nhid, args.latent_dim, hyperparams['dropout'], args.ncomp)
params = {
'lr': hyperparams['lr'],
'weight_decay': hyperparams['weight_decay'],
'epochs': args.epoch,
}
trainer = LinkPredTrainer(data, model, params, niter=20)
# run the model
result = trainer.run()
means.append(result['test_auc'])
return mean(means)
def get_no_of_pixel_and_field(mask, image):
mask = mask.copy()
image = image.copy()
no_of_pixels = np.nansum(mask)
ulta_mask = -1 * (mask - 1)
_masked_image = apply_mask(image, ulta_mask)
return no_of_pixels, np.nansum(_masked_image)
def objective(trial):
# Tune hyperparameters (dropout, weight decay, learning rate) using Optuna
dropout = trial.suggest_uniform('dropout', 0., 0.1)
lr = trial.suggest_loguniform('lr', 5e-4, 2e-2)
weight_decay = trial.suggest_loguniform('weight_decay', 1e-10, 1e-3)
# prepare data and model
data = LinkPredData(args.dataset, seed=args.seed)
apply_mask(data.features, masks[0])
model = VGAEmf(data, args.nhid, args.latent_dim, dropout, args.ncomp)
# run model
params = {
'lr': lr,
'weight_decay': weight_decay,
'epochs': args.epoch,
}
trainer = LinkPredTrainer(data, model, params, niter=10)
result = trainer.run()
return -result['val_auc']
def objective(trial):
# Tune hyperparameters (dropout, weight decay, learning rate) using Optuna
dropout = trial.suggest_uniform('dropout', 0.4, 0.8)
lr = trial.suggest_loguniform('lr', 5e-4, 1e-2)
weight_decay = trial.suggest_loguniform('weight_decay', 1e-6, 1e-1)
# prepare data and model
data = NodeClsData(args.dataset)
apply_mask(data.features, masks[0])
model = GCNmf(data, args.nhid, dropout, args.ncomp)
# run model
params = {
'lr': lr,
'weight_decay': weight_decay,
'epochs': args.epoch,
'patience': args.patience,
'early_stopping': True
}
trainer = NodeClsTrainer(data, model, params, niter=10)
result = trainer.run()
return -result['val_acc']
def evaluate_model(hyperparams):
means = []
dropout = hyperparams['dropout']
for mask in tqdm(masks):
# generate missing data, model and trainer
data = NodeClsData(args.dataset)
apply_mask(data.features, mask) # convert masked number to nan
model = GCNmf(data, args.nhid, dropout, args.ncomp)
params = {
'lr': hyperparams['lr'],
'weight_decay': hyperparams['weight_decay'],
'epochs': args.epoch,
'patience': args.patience,
'early_stopping': True
}
trainer = NodeClsTrainer(data, model, params, niter=20)
# run the model
result = trainer.run()
means.append(result['test_acc'])
return mean(means)
def _ctl_frame_close(self):
frame = self.frames.pop()
payload = frame['payload']
if frame['mask'] and payload:
payload = apply_mask(payload, frame['mask'])
self.log_info('Connection is closing: %s' % payload)
if self._closing_frame_sent:
self.close()
else:
self.send_message(payload, opcode=0x8)
self.close_when_done()
self.on_close(payload)
sys.exit(0)
def render():
"""
Renders a single frame.
Returns
-------
ndarray
Array representing a frame in BGR color format.
"""
global masked_frame, image
ret, frame = camera.read()
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
mask, masked_frame = apply_mask(
frame=frame,
r=selected_color[0][0][2],
g=selected_color[0][0][1],
b=selected_color[0][0][0],
negdh=cv2.getTrackbarPos(hue_delta_minus_name, window_name),
posdh=cv2.getTrackbarPos(hue_delta_plus_name, window_name),
mins=cv2.getTrackbarPos(min_saturation_name, window_name),
maxs=cv2.getTrackbarPos(max_saturation_name, window_name),
minv=cv2.getTrackbarPos(min_value_name, window_name),
maxv=cv2.getTrackbarPos(max_value_name, window_name),
)
# Calculate and draw metric value.
nrpc = calculate_nrpc(mask)
time_str = time.strftime("%H:%M:%S", time.localtime())
text = "{}, FPS: {:05.2f}, NRPC: {:.4f}".format(time_str, fps, nrpc)
draw_text(img=frame, text=text)
# Change color format back from RGB to BGR.
frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
masked_frame = cv2.cvtColor(masked_frame, cv2.COLOR_RGB2BGR)
# Concatenate horizontally (1) frames and (2) colors. Then, concatenate
# vertically (1) and (2) vertically.
frames = np.concatenate((frame, masked_frame), axis=1)
colors = np.concatenate(
(current_color, selected_color, lower_filtered_color, upper_filtered_color),
axis=1,
)
image = np.concatenate((frames, colors), axis=0)
return image
def process_and_respond(self, query):
'''
Processes content for valid query.
Parameters:
query - the parameters provided to the query
'''
body = 'Hello! The subnet is: ' + utils.apply_mask(query[0], query[1])
html = "<!DOCTYPE html><html>"
html += "<head><title>"
html += "Response from L13Server"
html += "</title></head>"
html += "<body><p><h1>"
html += body
html += "</h1></p></body>"
html += "</html>"
self.log_message("page built")
return html
def mask_image(self, image):
mask = utils.mask_from_contour_points(image, self.points)
return utils.apply_mask(image, mask)
def forward(self, x, level, query_in_out_each_level=False, query_hidden=False):
"""
:param x: a 4D input of NN
:param level: level index
:param query_in_out_each_level: if to query the input/output at each level
(maybe used for enforce losses at different levels)
:param query_hidden: if to query hidden representations
:return: output of NN, a list of hidden representations at current level
"""
# collectors
all_hidden = dict()
all_inputs = dict()
all_outputs = dict()
# forward prop
assert level >= 0, print('level index should be a non-negative integer!')
resolved_maps_dict = self.resolved_maps[str(level)]
if level == 0:
if query_in_out_each_level:
all_inputs['0'] = x
encoded = self._modules['L0_Conv_0'](x)
if query_hidden:
all_hidden['L0_0'] = encoded
# ----- pad -----
encoded = torch.nn.functional.pad(encoded, (1, 1, 1, 1), 'replicate')
# ---------------
y = self._modules['L0_deConv_0'](encoded)
# chop off the boundaries
y = y[:, :, 2:-2, 2:-2]
for i in range(1, self.n_filter_groups_each_level['0']):
encoded = self._modules['L0_Conv_{}'.format(i)](x)
if self.use_maps:
masked_encoded = apply_mask(encoded, resolved_maps_dict[str(i - 1)])
else:
masked_encoded = encoded
if query_hidden:
all_hidden['L0_{}'.format(i)] = masked_encoded
y += self._modules['L0_deConv_{}'.format(i)](masked_encoded)
if query_in_out_each_level:
all_outputs['0'] = y
else:
encoded = self._modules['L{}_Conv_0'.format(level)](x)
decoded, ins, outs, hs = \
self.forward(encoded, level-1, query_in_out_each_level, query_hidden)
# ----- pad -----
decoded = torch.nn.functional.pad(decoded, (1, 1, 1, 1), 'replicate')
# ---------------
if query_in_out_each_level:
all_inputs[str(level)] = x
all_inputs.update(ins)
all_outputs.update(outs)
if query_hidden:
all_hidden.update(hs)
all_hidden['L{}_0'.format(level)] = encoded
y = self._modules['L{}_deConv_0'.format(level)](decoded)
y = y[:, :, 2:-2, 2:-2]
for i in range(1, self.n_filter_groups_each_level[str(level)]):
encoded = self._modules['L{}_Conv_{}'.format(level, i)](x)
if self.use_maps:
masked_encoded = apply_mask(encoded, resolved_maps_dict[str(i - 1)])
else:
masked_encoded = encoded
if query_hidden:
all_hidden['L{}_{}'.format(level, i)] = masked_encoded
y += self._modules['L{}_deConv_{}'.format(level, i)](masked_encoded)
if query_in_out_each_level:
all_outputs[str(level)] = y
return y, all_inputs, all_outputs, all_hidden
def actual_process(self, file=None, previous_operation_name=None):
sys.stdout.write(
'Started The Process for MaskingMagnetograms :{}\n'.format(
file.filename))
hmi_ic_chain = Thresholding(
operation_name='mask',
suffix=None,
k=-5,
op=operator.le,
radius_factor=0.96,
do_closing=True).set_prev(
AIAPrep(operation_name='aiaprep', radius_factor=1.0).set_prev(
DownloadFiles(operation_name='data')))
previous_operation_hmi_ic = hmi_ic_chain.process(self._hmi_ic_file)
exclude_mask_hmi_ic = PreviousOperation(file=self._hmi_ic_file,
previous_op='mask',
suffix=None)
hmi_mag_chain = AIAPrep(operation_name='aiaprep',
radius_factor=1.0).set_prev(
DownloadFiles(operation_name='data'))
previous_operation_hmi_mag = hmi_mag_chain.process(file)
aia_prep_chain = AIAPrep(operation_name='aiaprep',
radius_factor=1.0).set_prev(
DownloadFiles(operation_name='data',
fname_from_rec=True))
aia_align_chain = AlignAfterAIAPrep(
'aligned_data', file, radius_factor=1.0).set_prev(aia_prep_chain)
ldr_chain_aia = LimbDarkeningCorrection(
operation_name='ldr', radius_factor=0.96).set_prev(aia_align_chain)
aia_chain_plages = Thresholding(
operation_name='mask',
suffix='plages',
k=1.71,
op=operator.ge,
post_processor=do_area_filtering,
radius_factor=0.96,
do_closing=True,
exclude_mask_file=[exclude_mask_hmi_ic]).set_prev(ldr_chain_aia)
previous_operation_aia_plages = aia_chain_plages.process(
self._aia_file, )
exclude_mask_aia_plages = PreviousOperation(file=self._aia_file,
previous_op='mask',
suffix='plages')
aia_chain_active_networks = Thresholding(operation_name='mask',
suffix='active_networks',
k=2,
op=operator.ge,
k2=6,
op2=operator.ge,
radius_factor=0.96,
value_1=1.0,
value_2=0.0,
do_closing=False,
exclude_mask_file=[
exclude_mask_hmi_ic,
exclude_mask_aia_plages
]).set_prev(ldr_chain_aia)
hmi_crop_task = CropImage(operation_name='crop_hmi_afterprep',
radius_factor=0.96).set_prev(hmi_mag_chain)
previous_operation_active_networks = aia_chain_active_networks.process(
self._aia_file, )
hmi_ic_mask_data, hmi_ic_mask_header = self._hmi_ic_file.get_fits_hdu(
previous_operation_hmi_ic.operation_name)
previous_operation_hmi_mag = hmi_crop_task.process(file)
sys.stdout.write('Performed all the chains for : {}\n'.format(
file.filename))
ampd, amph = self._aia_file.get_fits_hdu(
previous_operation_aia_plages.operation_name, 'plages')
aia_mask_plages_data, _ = ampd, amph
apnd, apnh = self._aia_file.get_fits_hdu(
previous_operation_active_networks.operation_name,
'active_networks')
aia_mask_active_networks_data, _ = apnd, apnh
hmi_mag_image_data, hmi_mag_image_header = file.get_fits_hdu(
previous_operation_hmi_mag.operation_name)
masked_image = hmi_mag_image_data.copy()
total_mask = np.add(
np.add(aia_mask_plages_data, aia_mask_active_networks_data),
hmi_ic_mask_data)
total_mask[total_mask >= 1.0] = 1.0
no_of_pixels_total_field = len(
circle(2048.5 - 1, 2048.5 - 1,
hmi_mag_image_header['R_SUN'] * 0.96)[0])
# apply mask is masking the features in the mask and
# returning the non masked elements
masked_image = apply_mask(masked_image, total_mask)
background_field = np.nansum(masked_image)
no_of_background_field = no_of_pixels_total_field - np.nansum(
total_mask)
total_magnetic_field = np.nansum(hmi_mag_image_data)
def get_no_of_pixel_and_field(mask, image):
mask = mask.copy()
image = image.copy()
no_of_pixels = np.nansum(mask)
ulta_mask = -1 * (mask - 1)
_masked_image = apply_mask(image, ulta_mask)
return no_of_pixels, np.nansum(_masked_image)
mask_active_network_plage = np.add(aia_mask_plages_data,
aia_mask_active_networks_data)
mask_active_network_plage[mask_active_network_plage >= 1.0] = 1.0
a, b = get_no_of_pixel_and_field(mask_active_network_plage,
hmi_mag_image_data)
no_of_pixel_plage_and_active, total_mag_field_plage_active = a, b
no_of_sunspot_pixel, sunspot_field = get_no_of_pixel_and_field(
hmi_ic_mask_data, hmi_mag_image_data)
record = Record(
date=get_date(file),
hmi_filename=file.filename,
hmi_ic_filename=self._hmi_ic_file.filename,
aia_filename=self._aia_file.filename,
time_difference=np.abs(
get_julian_day(file) - get_julian_day(self._aia_file)),
no_of_pixel_sunspot=no_of_sunspot_pixel,
total_mag_field_sunspot=sunspot_field,
no_of_pixel_plage_and_active=no_of_pixel_plage_and_active,
total_mag_field_plage_active=total_mag_field_plage_active,
no_of_pixel_background=no_of_background_field,
total_background_field=background_field,
total_pixels=no_of_pixels_total_field,
total_magnetic_field=total_magnetic_field)
record.save()
return masked_image, hmi_mag_image_header
parser.add_argument('--nhid', default=16, type=int, help='the number of hidden units')
parser.add_argument('--dropout', default=0.5, type=float, help='dropout rate')
# parser.add_argument('--ncomp', default=5, type=int, help='the number of Gaussian components')
parser.add_argument('--lr', default=0.005, type=float, help='learning rate')
parser.add_argument('--wd', default=1e-2, type=float, help='weight decay')
parser.add_argument('--epoch', default=10000, type=int, help='the number of training epoch')
parser.add_argument('--patience', default=100, type=int, help='patience for early stopping')
parser.add_argument('--verbose', action='store_true', help='verbose')
parser.add_argument('--emb1', default=100, type=int, help='k : the size of linear combination')
parser.add_argument('--emb2', default=100, type=int, help='m : the size of rank refularization')
parser.add_argument('--emb3_1', default=100, type=int, help='la : the size of set embedding')
parser.add_argument('--emb3_2', default=100, type=int, help='lb : the size of set embedding')
args = parser.parse_args()
if __name__ == '__main__':
data = NodeClsData(args.dataset)
mask = generate_mask(data.features, args.rate, args.type)
apply_mask(data.features, mask)
model = GCNfse(data, nhid=args.nhid, dropout=args.dropout, n_emb1=args.emb1, n_emb2=args.emb2, n_emb3_1=args.emb3_1, n_emb3_2=args.emb3_2)
params = {
'lr': args.lr,
'weight_decay': args.wd,
'epochs': args.epoch,
'patience': args.patience,
'early_stopping': True
}
trainer = NodeClsTrainer(data, model, params, niter=20, verbose=args.verbose)
trainer.run()
def labelit(img, mask_part, labelbase, rois):
"""
人工给每部分重新打标签
:param img: 图片
:param mask_part: 标签
:return: 重打过后的mask
"""
n_part = len(mask_part)
colors = random_colors(n_part)
minrow = rois[0]
mincol = rois[1]
maxrow = rois[2]
maxcol = rois[3]
newmask = np.zeros(mask_part[0].shape)
newmask = newmask.astype(np.int32)
print("按从左到右顺序输入标签:")
for i in range(n_part):
mask = mask_part[i]
temp = copy.copy(img)
onepart = apply_mask(temp, mask, colors[i])
onepart = onepart[minrow:maxrow, mincol:maxcol, ]
# print(i,onepart.shape)
ax = plt.subplot(1, n_part, i + 1)
# print(ax)
plt.imshow(onepart)
ax.set_title('part')
plt.xticks([]), plt.yticks([])
plt.tight_layout()
plt.gca().xaxis.set_major_locator(plt.NullLocator())
plt.gca().yaxis.set_major_locator(plt.NullLocator())
plt.margins(0, 0)
plt.show()
labels = str(input())
if labels[0] == '.':
return []
# if labels[0]=='r' or labels[0]=='R':
# for i in range(n_part):
# mask = mask_part[i]
# temp = copy.copy(img)
# onepart = apply_mask(temp, mask, colors[i])
# onepart = onepart[minrow:maxrow, mincol:maxcol, ]
# cv2.imwrite(str(i)+'.png',onepart)
# for i in range(n_part):
# onepart=cv2.imread(str(i)+'.png')
# ax = plt.subplot(1, n_part, i + 1)
# plt.imshow(onepart)
# ax.set_title('part')
# plt.xticks([]), plt.yticks([])
# plt.tight_layout()
# plt.gca().xaxis.set_major_locator(plt.NullLocator())
# plt.gca().yaxis.set_major_locator(plt.NullLocator())
# plt.margins(0, 0)
# plt.show()
for i in range(n_part):
if int(labels[i]) == 0:
newmask = np.where(mask_part[i] > 0, np.zeros(newmask.shape),
newmask) # 忽然发现这句好像没用?
else:
newmask = np.where(
mask_part[i] > 0,
np.ones(newmask.shape, dtype=int) *
(labelbase * 10 + int(labels[i])), newmask)
# 一部分一部分标
# for mask in mask_part:
# plt.figure(figsize=(10, 10))
# print("输入这部分的标签:")
# temp=copy.copy(img)
# onepart=apply_mask(temp,mask,colors[0])
# plt.subplot(1,1,1)
# plt.imshow(onepart)
# plt.title("输入这部分的标签")
# plt.xticks([]), plt.yticks([])
# # plt.show()
# plt.ion()
# plt.pause(2)
# plt.close()
# newlabel=int(input())
# newmask=np.where(mask>0,newlabel,newmask)
return newmask
def test_unmasking_text(self):
self.assertEqual(utils.apply_mask('\x7f\x9fMQX', '7\xfa!='), 'Hello')
def train(args, net, optimizer, data_loader, epoch, writer):
net.train()
losses = AverageMeter()
losses_mask = AverageMeter()
losses_depth = AverageMeter()
losses_normal = AverageMeter()
losses_area = AverageMeter()
for iter, sample in enumerate(data_loader):
image = sample['image'].cuda()
depth = sample['depth'].cuda()
label = sample['label'].cuda()
K_inv = sample['K_inv'].cuda()
# normal
normal = depth_2_normal(depth, K_inv[0, 0])
# forward
plane_params, pred_masks = net(image)
# loss
loss_mask, loss_depth, loss_normal = get_loss(plane_params, pred_masks, depth, normal, label, K_inv)
loss = args.mask * loss_mask + args.depth * loss_depth + args.normal * loss_normal
# Backward
optimizer.zero_grad()
loss.backward()
optimizer.step()
losses.update(loss.item())
losses_mask.update(loss_mask.item())
losses_depth.update(loss_depth.item())
losses_normal.update(loss_normal.item())
#losses_area.update(loss_area.item())
if iter % 10 == 0:
print(f"[{epoch:2d}][{iter:4d}/{len(data_loader)}]"
f"Loss:{losses.val:.4f} ({losses.avg:.4f})"
f"Mask:{losses_mask.val:.4f} ({losses_mask.avg:.4f})"
f"Depth:{losses_depth.val:.4f} ({losses_depth.avg:.4f})"
f"Normal:{losses_normal.val:.4f} ({losses_normal.avg:.4f})")
#f"Area:{losses_area.val:.4f} ({losses_area.avg:.4f})")
writer.add_scalar('loss/total_loss', losses.val, iter + epoch * len(data_loader))
writer.add_scalar('loss/mask_loss', losses_mask.val, iter + epoch * len(data_loader))
writer.add_scalar('loss/depth_loss', losses_depth.val, iter + epoch * len(data_loader))
writer.add_scalar('loss/normal_loss', losses_normal.val, iter + epoch * len(data_loader))
#writer.add_scalar('loss/area_loss', losses_area.val, iter + epoch * len(data_loader))
if iter % 100 == 0:
mask = F.softmax(pred_masks[0], dim=1)
normal = (normal + 1) / 2.
for j in range(image.size(0)):
writer.add_image('Train Input Image/%d'%(j), tensor_to_X_image(image[j].cpu()), iter + epoch * len(data_loader))
writer.add_image('Train GT Depth/%d'%(j), 1. / depth[j], iter + epoch * len(data_loader))
writer.add_image('Train GT Mask/%d'%(j), label[j], iter + epoch * len(data_loader))
# apply mask to input image
cur_mask = mask[j].detach().cpu().numpy().argmax(axis=0)
masked_image = apply_mask(image[j].cpu(), cur_mask, ignore_index=mask.size(1) - 1)
writer.add_image('Train Masked Image/%d' % (j), masked_image, iter + epoch * len(data_loader))
# predict mask
for k in range(mask.size(1) - 1):
writer.add_image('Train Mask %d/%d'%(k, j), mask[j, k:k+1], iter + epoch * len(data_loader))
# non plane mask
writer.add_image('Train Non-plane Mask/%d'%(j), mask[j, -1:], iter + epoch * len(data_loader))
writer.add_image('Train Normal/%d'%(j), normal[j], iter + epoch * len(data_loader))
# predict normal map
pred_params = plane_params[j]
cur_mask = mask[j].detach().cpu().numpy()[:-1, :, :].argmax(axis=0)
pred_normal = pred_params[cur_mask, :].detach()
pred_normal = pred_normal.permute(2, 0, 1)
pred_normal /= (torch.norm(pred_normal, p=2, dim=0, keepdim=True) + 1e-6)
pred_normal = (pred_normal + 1) / 2.
writer.add_image('Train Pred Normal/%d'%(j), pred_normal, iter + epoch * len(data_loader))
for i, (imgs, _) in enumerate(dataloader):
if i == num_batches:
break
imgs = imgs.type(Tensor)
save_sample_images(imgs, 'originals', i)
# initial input for generator. This is what we want to optimize
z = create_noise(cuda, imgs.shape[0], opt.latent_dim)
optimizer = torch.optim.Adam([z], lr=opt.lr, betas=(opt.b1, opt.b2))
img_mask = generate_center_mask(Tensor, opt.img_size, opt.channels, 0.3)
# we also want a slightly bigger version of the mask for alpha blending later
fill_mask = generate_center_mask(Tensor, opt.img_size, opt.channels, 0.25)
masked_imgs = apply_mask(Tensor, imgs, img_mask)
save_sample_images(masked_imgs, 'masked', i)
avg_contextual_loss = 0
avg_perceptual_loss = 0
avg_completion_loss = 0
# iterate n times over the same batch and optimize to find the best z input vector
# that will produce the best completed result
for j in range(opt.num_iters):
if z.grad is not None:
z.grad.data.zero_()
discriminator.zero_grad()
generator.zero_grad()
def main():
#
# parse command line
#
args = parse_arguments()
#
# create out folder
#
if not os.path.exists(args.outf):
os.makedirs(args.outf)
#
# load image
#
if not os.path.exists(args.image):
raise FileNotFoundError(args.image)
im = ClickableImage(args.image)
# ******************* PARAMETERS ******************************************
# Intensity of interest: intensity above which a pixel may be considered as a center / an edge
# Assumption: centers and edges are brighter than background
intensity_of_interest = get_quantile(im.img, 0.75)
#
# Ring
#
# - radius: if --typical_edge is not specified, we use the value of --radius, else we heuristically chose it from the 'typical edge length'
# - thickness: if --thickness is not specified, we use (2/3)*radius
if args.typical_edge == "measure_an_edge":
typical_edge_length = im.measure_an_edge()
print(
"You selected an edge of length : {}".format(typical_edge_length))
radius = math.ceil(typical_edge_length * 0.6)
elif args.typical_edge == "count_cells":
n_cells = im.count_cells()
typical_edge_length = im.n_cells_to_edge_length(n_cells)
radius = math.floor(typical_edge_length / 3)
else:
radius = args.radius
thickness = args.thickness if args.thickness is not None else int(
(2 / 3) * radius)
# *************************************************************
#
# Manual selection of the point to analyze
#
center = im.get_point()
center = (math.ceil(center[0]), math.ceil(center[1]))
print("Selected point: {}".format(center))
#************************** STEP 1 ****************************#
# Filter the image with a ring centered on the point of interest
#**************************************************************#
#
# define ring
#
ring = {}
ring["center"] = center
ring["radius"] = (radius - 0.5 * thickness, radius + 0.5 * thickness)
#
# filter image with the ring
#
mask = create_ring_mask(im.img, ring)
img_filtered = apply_mask(im.img, mask)
#
# Visualization of the ring around the selected point
#
# image filtered by the ring
fig, ax = plot_img(img_filtered, title="Image filtered by the ring")
fig.savefig(os.path.join(args.outf, "1_img_filtered.png"))
# image with superimposed ring
img_with_ring = superimpose_ring(im.img, ring, mask)
fig, ax = plot_img(
img_with_ring,
title="Center : ({:.2f}, {:.2f}) \n Radius : ({:.2f}, {:.2f})".format(
ring["center"][0], ring["center"][1], ring["radius"][0],
ring["radius"][1]))
fig.savefig(os.path.join(args.outf, "2_ring.png"))
#********************** STEP 2 **********************#
# Get the 'mountain' relief of intensity in the ring
#****************************************************#
angle2intensity = angle2intensity_in_ring(im.img, ring, mask)
bucket2intensity, intensity2bucket = angular_smoothing(
angle2intensity,
size=args.size_smoothing,
stride=args.stride_smoothing,
cast_to_int=False)
#************************** STEP 3 *********************#
# 'water descent' on our relief, to obtain the barcodes
# of the peaks (birth/death)
#
# Let f be our 'relief' function, f: angle -> intensity
# Compute persistence of the connected components of
# the filtration {f^-1([h, +inf[), for all h real}
#*******************************************************#
barcodes = water_descent(intensity2bucket, args.stride_smoothing)
# Heuristically computes a correct 'min_lifetime', a threshold on duration (death - birth):
# - below: the connected components is considered as noise
# - above: the cc is considered as a peak
# this is the dashed line that "cuts" the persistence diagram
range_intensity = max(bucket2intensity) - min(bucket2intensity)
min_lifetime = max(args.threshold_min_lifetime,
range_intensity * args.coef_min_lifetime)
#****************************** STEP 4 ********************************#
# For visualization, we report the barcodes in a 'persistence diagram'
# We filter out the cc with a persistence < min_lifetime
# The remaining ones are the significant 'peaks'
# We count them to determine if the point of interest is:
# - a corner (3 or more peaks)
# - an edge (2 peaks)
# - a part of background (else)
#***********************************************************************#
# Analysis of the barcodes: persistence diagram and type of the point
peaks = get_peaks(barcodes, cut=min_lifetime)
n_peaks = len(peaks)
#
# Visualization
#
fig, (ax1, ax2) = plt.subplots(1, 2, sharey=True, figsize=(16, 7.3))
# intensity relief in the ring
ax1.plot(range(0, 360, args.stride_smoothing), bucket2intensity)
ax1.set_xlim(0, 360)
ax1.set_xlabel("Angle in the ring (°)")
ax1.set_ylabel("Intensity in [0, 255]")
ax1.set_title(
"Intensity vs. Angle\nafter angular smoothing (size={}, stride={})".
format(args.size_smoothing, args.stride_smoothing))
# corresponding persistence diagram
ax2 = persistence_diagram(ax2, barcodes, min_lifetime,
intensity_of_interest)
ax2.set_title(
"Persistence Diagram (with cut = {}) \nNumber of 'persistent' cc: {}".
format(min_lifetime, n_peaks))
ax2.set_xlabel("Birth intensity")
ax2.set_ylabel("Death intensity")
fig.savefig(os.path.join(args.outf, "3_persistence_diagram.png"),
dpi=90,
bbox_inches='tight')
#
# classify the selected point
#
if n_peaks >= 3:
point_type = "corner"
elif n_peaks == 2:
point_type = "edge"
else:
point_type = "background"
print("\n==> Point type: {} ({} peak(s))".format(point_type, n_peaks))
#
# display detected edges
#
if n_peaks >= 2:
angles_of_edges = []
for cc in peaks:
angle_of_edge = cc.peak.x
angles_of_edges.append(angle_of_edge)
img_with_ring_and_intersections = superimpose_ring_and_intersections(
im.img, ring, angles_of_edges, mask)
fig, ax = plot_img(
img_with_ring_and_intersections,
title="Angles between horizontal and detected edges\n{}".format(
sorted(angles_of_edges)))
fig.savefig(os.path.join(args.outf, "4_edges.png"))
#
# Make animated gif
#
if not args.nogif:
print("\nMaking animated gif...")
make_gif(args.outf, barcodes, min_lifetime, bucket2intensity,
args.stride_smoothing, args.size_smoothing,
intensity_of_interest)
print("Visualizations stored in {}".format(args.outf))
return
rois_dir = runthis.get_rois_dir()
img_paths = next(os.walk(label_dir))[2]
colors=random_colors(10)
for img_path in img_paths:
img = cv2.imread(del_bg_dir + img_path.split('.')[0]+'_delbg.png') # 反常
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # 正常
rois = np.loadtxt(rois_dir + img_path.split('.')[0] + '.rois', dtype=np.int, delimiter=',').tolist()
mask_inone=np.loadtxt(label_dir+img_path,dtype=int,delimiter=',')
minrow = rois[0]
mincol = rois[1]
maxrow = rois[2]
maxcol = rois[3]
temp1=mask_inone.flatten().tolist()
labels = list(set(temp1))
labels.sort()
labels=labels[1:]
mask_part=[]
for i in range(len(labels)):
tempmask=np.zeros(mask_inone.shape,dtype=int)
tempmask=np.where(mask_inone==labels[i],np.ones(tempmask.shape, dtype=int) * labels[i],tempmask)
img=apply_mask(img,tempmask,colors[labels[i]%10])
plt.figure(figsize=(10,5))
ax=plt.subplot(1,2,1)
plt.imshow(img)
plt.xticks([]), plt.yticks([])
ax=plt.subplot(1,2,2)
plt.imshow(img[minrow:maxrow,mincol:maxcol:])
plt.xticks([]), plt.yticks([])
plt.show()
