def lowpass(image_batch, lda, npad):
image = image_batch[0]
image = np.squeeze(image) # 去掉第一个维度，得到可直接处理的二维数据
# 注意数组操作reshape和transpose的区别，transpose慎用（转置，改变原有数据顺序）
# 定义存放高频信号和低频信号的batch
low_filt_batch, high_filt_batch = tikhonov_filter(image, lda, npad)
# 将low_filt_batch和high_filt_batch增加第一个维度
low_filt_batch = np.expand_dims(low_filt_batch, axis=0)
high_filt_batch = np.expand_dims(high_filt_batch, axis=0)
# 将每个batch中的图像依次提取出来并分解，并各自合并成一个新的bacth
for i in range(1, image_batch.shape[0]):
image = image_batch[i]
image = np.squeeze(image)
low_filt_image, high_filt_image = tikhonov_filter(image, lda, npad)
low_filt_image = np.expand_dims(low_filt_image, axis=0)
high_filt_image = np.expand_dims(high_filt_image, axis=0)
# 对第一个维度进行合并
low_filt_batch = np.concatenate((low_filt_batch, low_filt_image),
axis=0)
high_filt_batch = np.concatenate((high_filt_batch, high_filt_image),
axis=0)
# 增加第二个维度
low_filt_batch = np.expand_dims(low_filt_batch, axis=1)
high_filt_batch = np.expand_dims(high_filt_batch, axis=1)
return low_filt_batch, high_filt_batch
def csc(imgs, D, args, lmbda=None, opt=None):
if lmbda is None:
lmbda = args.lmbda
if opt is None:
opt = sporco.admm.cbpdn.ConvBPDN.Options({
'Verbose': False,
'MaxMainIter': args.nInnerIter,
'HighMemSolve': True,
'RelStopTol': 5e-3,
'AuxVarObj': False
})
s = np.transpose(imgs[..., 0], (1, 2, 0))
sl, sh = util.tikhonov_filter(s, args.lmbdaPre)
ys = []
coefs = []
for i in range(sh.shape[-1]):
coef = sporco.cuda.cbpdn(D, sh[..., i], lmbda, opt, dev=args.device)
y = np.sum(cp2np(sporco.cupy.linalg.fftconv(np2cp(D), np2cp(coef))),
-1) + sl[..., i]
coefs.append(coef)
ys.append(y[np.newaxis, ..., np.newaxis])
return np.concatenate(ys, 0), np.array(coefs)
def decomp_combine_image(ir_image, vi_image):
# 转换为float类型 .astype(np.float)
ir_low, ir_high = tikhonov_filter((ir_image - 127.5) / 127.5, 5, 16)
vi_low, vi_high = tikhonov_filter((vi_image - 127.5) / 127.5, 5, 16)
# 对红外和可见光图像的高频区域进行融合
combine_high = ir_high
row, col = ir_high.shape
for m in range(row):
for n in range(col):
if abs(ir_high[m][n]) > abs(vi_high[m][n]):
combine_high[m][n] = ir_high[m][n]
else:
combine_high[m][n] = vi_high[m][n]
combine_low = (ir_low + vi_low) / 2
combine_average = (ir_image + vi_image) / 2
return combine_low
def default_transform(blob, pad_size=None, tikhonov=True):
if pad_size is not None:
pad = [(pad_size, pad_size), (pad_size, pad_size)] + \
[(0, 0) for _ in range(blob.ndim-2)]
blob = np.pad(blob, pad, mode='constant')
if tikhonov:
# fix lambda to be 5
sl, sh = su.tikhonov_filter(blob, 5.)
else:
sl, sh = np.zeros_like(blob), blob
return sl, sh
def recons(name):
if not os.path.exists(os.path.join(out_path, name)):
impath = os.path.join(im_path, name)
im = get_im(impath)
sl, sh = util.tikhonov_filter(im, fltlmbd, npd)
opt = cbpdn.ConvBPDN.Options({
'Verbose': False,
'MaxMainIter': 200,
'RelStopTol': 5e-3,
'AuxVarObj': False
})
b = cbpdn.ConvBPDN(basis, sh, lmbda, opt)
X = b.solve()
print("ConvBPDN solve time: %.2fs" % b.timer.elapsed('solve'))
shr = b.reconstruct().squeeze()
imgr = sl + shr
cv2.imwrite(os.path.join(out_path, name), 255 * imgr / imgr.max())
else:
# print(name)
pass
def main():
"""Main entry."""
args = parse_args()
if not os.path.exists(args.output_path):
os.makedirs(args.output_path)
log_name = os.path.join(
args.output_path, '{:s}.{:%Y-%m-%d_%H-%M-%S}.log'.format(
args.name,
datetime.datetime.now(),
))
logger = setup_logging(__name__, log_name)
train_data = image_dataset.create_image_blob('fruit',
np.float32,
scaled=True,
gray=False)
sl, sh = su.tikhonov_filter(train_data, 5, 16)
D0 = np.random.randn(8, 8, 3, 64)
solvers = [
globals()['setup_{}'.format(s)](D0, sh, args.lmbda)
for s in ('ConvBPDNDictLearn_FISTA', 'ConvBPDNSliceDictLearnFISTA')
]
for s in solvers:
logger.info('Solving CDL algorithm: %s', type(s).__name__)
D1 = s.solve()
logger.info('%s solve time: %.2fs',
type(s).__name__, s.timer.elapsed('solve'))
np.save(
os.path.join(args.output_path,
'{}_dict.npy'.format(type(s).__name__)), D1.squeeze())
fig = plt.figure()
for s in solvers:
plt.plot(getattr(s.getitstat(), args.xaxis),
getattr(s.getitstat(), args.yaxis),
label=type(s).__name__)
plt.gca().xaxis.set_major_locator(MaxNLocator(integer=True))
plt.legend()
fig.savefig(os.path.join(args.output_path,
'{}_{}.pdf'.format(args.xaxis, args.yaxis)),
bbox_inches='tight')
def train_batch_model(D0, train_blob, opt, args):
"""Train for batch dictlrn model."""
logger = logging.getLogger(__name__)
dname = args.dataset if not args.use_gray else args.dataset + '.gray'
if os.path.exists(os.path.join(args.output_path, 'iter_record.mat')):
iter_record = sio.loadmat(
os.path.join(args.output_path, 'iter_record.mat'))['iter_record']
selected = list(set(iter_record.ravel().tolist()))
if args.batch_max_samples > 0 and args.batch_max_samples < len(
selected):
selected = selected[:args.batch_max_samples]
if len(selected) < train_blob.shape[-1]:
logger.info(
'Selected %d -> %d train samples for training batch model',
train_blob.shape[-1], len(selected))
train_blob = train_blob[..., selected]
if not args.no_tikhonov_filter:
# fix lambda to be 5
_, train_blob = su.tikhonov_filter(train_blob, 5.)
path = os.path.join(args.output_path, 'ConvBPDNDictLearn')
if not os.path.exists(path):
os.makedirs(path)
def _callback(d):
"""Snapshot dictionaries for every iteration."""
_D = d.getdict().squeeze()
np.save(os.path.join(path, '{}.{}.npy'.format(dname, d.j)), _D)
return 0
opt['Callback'] = _callback
solver = cbpdndl.ConvBPDNDictLearn(D0,
train_blob,
args.lmbda,
opt=opt,
xmethod='admm',
dmethod='cns')
solver.solve()
return solver
def train_models(D0, solvers, train_blob, args):
"""Function for training every solvers."""
epochs = args.epochs if args.epochs > 0 else None
batch_size = args.batch_size if args.batch_size > 0 else None
loader = BlobLoader(train_blob, epochs, batch_size)
sample = loader.random_sample()
solvers = {
k: sol_name(D0, sample, args.lmbda, opt=opt)
for k, (sol_name, opt) in solvers.items()
}
dname = args.dataset if not args.use_gray else args.dataset + '.gray'
for e, blob in enumerate(loader):
if args.pad_boundary:
assert args.patch_size % 2 == 1, 'Patch size should be odd'
radius = args.patch_size // 2
pad = [(radius, radius), (radius, radius)] + \
[(0, 0) for _ in range(blob.ndim-2)]
# pad = [(0, args.patch_size-1), (0, args.patch_size-1)] + \
# [(0, 0) for _ in range(blob.ndim-2)]
blob = np.pad(blob, pad, mode='constant')
if not args.no_tikhonov_filter:
# fix lambda to be 5
_, blob = su.tikhonov_filter(blob, 5.)
for k, s in solvers.items():
s.solve(blob.copy())
path = os.path.join(args.output_path, k)
np.save(os.path.join(path, '{}.{}.npy'.format(dname, e)),
s.getdict().squeeze())
if args.visdom is not None:
tiled_dict = su.tiledict(s.getdict().squeeze())
if not args.use_gray:
tiled_dict = tiled_dict.transpose(2, 0, 1)
args.visdom.image(tiled_dict, opts=dict(caption=f'{k}.{e}'))
# snapshot iteration record
sio.savemat(os.path.join(args.output_path, 'iter_record.mat'),
{'iter_record': loader.record})
return solvers
# In[10]:
if showPlots:
plt.figure(figsize=[6,6])
plt.imshow(imgs[0, 128:-128, 128:-128, 0].T, 'gray', vmin=args.vmin, vmax=args.vmax)
# In[20]:
# training, offline learning
np.random.seed(0)
s = np.transpose(imgs[..., 0], (1, 2, 0))
sl, sh = util.tikhonov_filter(s, args.lmbdaPre)
D0 = np.random.normal(size = args.kernelSize + [args.nChannels]).astype(np.float32)
opt = cbpdndl.ConvBPDNDictLearn.Options({'Verbose': True, 'MaxMainIter': args.nPreIter,
'CBPDN': {'rho': 100*args.lmbda + 1,
'AutoRho': {'Enabled': True},
'RelaxParam': 1.8,
'RelStopTol': 1e-7},
'CCMOD': {'rho': 10.0, 'ZeroMean': False}},
dmethod='cns')
learner = cbpdndl.ConvBPDNDictLearn(D0, sh, args.lmbda, opt, dmethod='cns')
learner.solve()
D1 = learner.getdict()
D1 = D1.squeeze()
def lowpass(s, lda, npad):
return tikhonov_filter(s, lda, npad)
# Dr = mysolve(cri, Dr0, Xr, Shr, 1e-4, maxitr=50, debug_dir='./debug')
# # Dr = nakashizuka_solve(cri, Dr0, Xr, Shr, debug_dir='./debug')
# # Dr = sporcosolve(cri, Dr, Shr)
# # fig = plot.figure(figsize=(7, 7))
# # plot.imview(util.tiledict(Dr.squeeze()), fig=fig)
# # fig.savefig('dict.png')
# # # evaluate_result(cri, Dr0, Dr, Shr, Sr_add=Slr)
exim1 = util.ExampleImages(scaled=True, zoom=0.5, pth='./')
S1_test = exim1.image('couple.tiff')
exim2 = util.ExampleImages(scaled=True, zoom=1, pth='./')
S2_test = exim2.image('LENNA.bmp')
S_test = np.dstack((S1_test, S2_test))
cri_test = cnvrep.CSC_ConvRepIndexing(D, S_test)
Sl_test, Sh_test = util.tikhonov_filter(S_test, 5, 16)
Slr_test = np.asarray(Sl_test.reshape(cri_test.shpS), dtype=S_test.dtype)
Shr_test = np.asarray(Sh_test.reshape(cri_test.shpS), dtype=S_test.dtype)
# evaluate_result(cri, Dr0, Dr, Shr_test, Sr_add=Slr_test, lmbda=5e-3)
outdir = './no_low-pass'
#--------実験を行う手法を指定-------
prefix = 'nakashizuka_solve' # 中静先生の論文
# prefix = 'mysolve' # 提案手法
# prefix = 'sporcosolve' # sporcoライブラリに実装された方法（B. Wohlbergによる）
#----------------------------------
if prefix == 'nakashizuka_solve':
def crop(x, n=8):
return x[n:-n, n:-n]
# img = util.ExampleImages().image('monarch.png', zoom=0.5, scaled=True,
# gray=True, idxexp=np.s_[:, 160:672])
img = mpimg.imread('barbara1.png')
np.random.seed(12345)
imgn = img + np.random.normal(0.0, 0.1, img.shape)
print("Noisy image PSNR: %5.2f dB" % sm.psnr(img, imgn))
npd = 16
fltlmbd = 5.0
imgnl, imgnh = util.tikhonov_filter(imgn, fltlmbd, npd)
D = util.convdicts()['G:8x8x32']
D = D[:, :, 0:14]
# D = np.random.randn(8, 8, 14)
imgnpl, imgnph = util.tikhonov_filter(pad(imgn), fltlmbd, npd)
W = spl.irfftn(
np.conj(spl.rfftn(D, imgnph.shape,
(0, 1))) * spl.rfftn(imgnph[..., np.newaxis], None,
(0, 1)), imgnph.shape, (0, 1))
W = W**2
W = 1.0 / (np.maximum(np.abs(W), 1e-8))
lmbda = 1.5e-2
mu = 0.005
opt1 = cbpdn.ConvBPDN.Options({
'Verbose': True,
from sporco.dictlrn import cbpdndl
from sporco import util
from sporco import plot
plot.config_notebook_plotting()
# %%
exim = util.ExampleImages(scaled=True, zoom=0.25, gray=True)
S1 = exim.image('barbara.png', idxexp=np.s_[10:522, 100:612])
S2 = exim.image('kodim23.png', idxexp=np.s_[:, 60:572])
S3 = exim.image('monarch.png', idxexp=np.s_[:, 160:672])
S4 = exim.image('sail.png', idxexp=np.s_[:, 210:722])
S5 = exim.image('tulips.png', idxexp=np.s_[:, 30:542])
S = np.dstack((S1, S2, S3, S4, S5))
npd = 16
fltlmbd = 5
sl, sh = util.tikhonov_filter(S, fltlmbd, npd)
D0 = np.random.randn(10, 10, 32)
lmbda = 0.1
opt = cbpdndl.ConvBPDNDictLearn.Options(
{
'Verbose': True,
'MaxMainIter': 200,
'CBPDN': {
'rho': 50.0 * lmbda + 0.5
},
'CCMOD': {
'rho': 10.0,
'ZeroMean': True
}
},
dmethod='cns')
def lowpass(
s, lda, npad
): # In this function, low pass filtering is done by using Tikhonov filter.
return tikhonov_filter(s, lda, npad)
zoom = 0.25
N = int(512 * 0.25)
K = 5
exim = util.ExampleImages(scaled=True, zoom=zoom, gray=True)
s1 = exim.image('barbara.png', idxexp=np.s_[10:522, 100:612])
s2 = exim.image('kodim23.png', idxexp=np.s_[:, 60:572])
s3 = exim.image('monarch.png', idxexp=np.s_[:, 160:672])
s4 = exim.image('sail.png', idxexp=np.s_[:, 210:722])
s5 = exim.image('tulips.png', idxexp=np.s_[:, 30:542])
ori = np.asarray([s1, s2, s3, s4, s5])
npd = 16
fltlmbd = 10
sl, sh = util.tikhonov_filter(np.moveaxis(ori, 0, -1), fltlmbd, npd)
sl = np.moveaxis(sl, -1, 0)
sh = np.moveaxis(sh, -1, 0)
S = sh.reshape(5, N, N)
# 辞書枚数
M = 16
d_size = 10
K = len(S)
D0 = np.random.randn(M, d_size, d_size)
roopcount = 0
# %%
cap = cv2.VideoCapture(pth)
k = 0
while (cap.isOpened()):
ret, frame = cap.read()
if ret is False:
break
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
vid[..., k] = gray
k += 1
cap.release()
vid = vid[50:114, 50:114, 0:32] / 255.0
# Highpass filter frames
npd = 16
fltlmbd = 5
vl, vh = util.tikhonov_filter(vid, fltlmbd, npd)
# Initial dictionary
np.random.seed(12345)
D0 = np.random.randn(5, 5, 3, 75)
# Set ConvBPDNDictLearn parameters
lmbda = 0.1
opt = cbpdndl.ConvBPDNDictLearn.Options({
'Verbose': True,
'MaxMainIter': 200,
'CBPDN': {
'rho': 1e3 * lmbda,
'AutoRho': {
'Enabled': True
}
Load a reference image and corrupt it with Gaussian white noise with $\sigma = 0.1$. (The call to ``numpy.random.seed`` ensures that the pseudo-random noise is reproducible.)
"""
img = util.ExampleImages().image('monarch.png', zoom=0.5, scaled=True,
gray=True, idxexp=np.s_[:, 160:672])
np.random.seed(12345)
imgn = img + np.random.normal(0.0, 0.1, img.shape)
"""
Highpass filter test image.
"""
npd = 16
fltlmbd = 5.0
imgnl, imgnh = util.tikhonov_filter(imgn, fltlmbd, npd)
"""
Load dictionary.
"""
D = util.convdicts()['G:8x8x128']
"""
Set solver options. See Section 8 of :cite:`wohlberg-2017-convolutional2` for details of construction of $\ell_1$ weighting matrix $W$.
"""
imgnpl, imgnph = util.tikhonov_filter(pad(imgn), fltlmbd, npd)
W = spl.irfftn(np.conj(spl.rfftn(D, imgnph.shape, (0, 1))) *
def test_12(self):
img = np.random.randn(64, 64)
iml, imh = util.tikhonov_filter(img, 5.0)
def test_13(self):
img = np.random.randn(16, 16, 16)
iml, imh = util.tikhonov_filter(img, 2.0, npd=8)
"""
Load example image.
"""
img = util.ExampleImages().image('kodim23.png', scaled=True,
idxexp=np.s_[160:416,60:316])
"""
Highpass filter example image.
"""
npd = 16
fltlmbd = 10
slc, shc = util.tikhonov_filter(img, fltlmbd, npd)
"""
Load greyscale convolutional dictionary.
"""
D = util.convdicts()['G:8x8x64']
"""
Learn a standard dictionary $B$ to represent all pixel colours in the example image. Since the standard dictionary is a $3 \times 6$ matrix, the sparse representation $X$ has 6 pseudo-channels, which are converted to the 3 channels of the example image by right-multiplication by the dictionary $B$, giving $XB$.
"""
S = shc.reshape((-1, shc.shape[-1])).T
np.random.seed(12345)
exim = util.ExampleImages(scaled=True, zoom=0.25)
S1 = exim.image('barbara.png', idxexp=np.s_[10:522, 100:612])
S2 = exim.image('kodim23.png', idxexp=np.s_[:, 60:572])
S3 = exim.image('monarch.png', idxexp=np.s_[:, 160:672])
S4 = exim.image('sail.png', idxexp=np.s_[:, 210:722])
S5 = exim.image('tulips.png', idxexp=np.s_[:, 30:542])
S = np.stack((S1, S2, S3, S4, S5), axis=3)
"""
Highpass filter training images.
"""
npd = 16
fltlmbd = 5
sl, sh = util.tikhonov_filter(S, fltlmbd, npd)
"""
Construct initial dictionary.
"""
np.random.seed(12345)
D0 = np.random.randn(8, 8, 3, 64)
"""
Set regularization parameter and options for dictionary learning solver.
"""
lmbda = 0.2
def test_13(self):
img = np.random.randn(16, 16, 16)
iml, imh = util.tikhonov_filter(img, 2.0, npd=8)
def test_07(self):
img = np.random.randn(64, 64)
iml, imh = util.tikhonov_filter(img, 5.0)
nfrm = reader.get_length()
frmlst = []
for i, frm in enumerate(reader):
if i >= 250:
frm = zoom(util.rgb2gray(frm.astype(np.float32)/255.0), 0.25)
frmlst.append(frm[20:-20, 70:-70])
vid = np.stack(frmlst, axis=2)
"""
Highpass filter video frames.
"""
npd = 16
fltlmbd = 10
vl, vh = util.tikhonov_filter(vid, fltlmbd, npd)
"""
Construct initial dictionary.
"""
np.random.seed(12345)
D0 = np.random.randn(5, 5, 3, 25)
"""
Set regularization parameter and options for dictionary learning solver.
"""
lmbda = 0.1