Python和C++多尺度导图

🎯要点

1. 热化学属性观测
2. 蒙特卡罗似然比灵敏度分析时间尺度上动力学
3. 化学催化反应动力学建模
4. 自动微分电化学分析模型
5. 反应动力学数学模型
6. 渔业生态不确定性模型敏感性分析
7. 空间统计地理模型分析技术
8. 多维数据表征实现
9. 生成艺术图案流苏
10. 物体长度比，面积比和复杂度数据统计学分析
11. 二维三维耦合偏微分方程有限元解析
12. 交通标识识别
    

Python(TensorFlow)结构相似性

结构相似性指数测量是一种预测数字电视和电影画面以及其他类型的数字图像和视频的感知质量的方法。它也用于测量两幅图像之间的相似性，此指数是一个完全参考指标，换句话说，图像质量的测量或预测是基于初始未压缩或无失真图像作为参考的。

结构相似性指数测量是一种基于感知的模型，它将图像质量下降视为结构信息的感知变化，同时还结合了重要的感知现象，包括亮度掩蔽和对比度掩蔽项。与其他技术（如 MSE 或 PSNR）的不同之处在于，这些方法估算绝对误差。结构信息是指像素具有很强的相互依赖性，尤其是当它们在空间上接近时。这些依赖关系包含有关视觉场景中物体结构的重要信息。亮度掩蔽是一种现象，即图像失真（在这种情况下）在明亮区域中往往不太明显，而对比度掩蔽是一种现象，即当图像中存在显着活动或“纹理”时，失真会变得不太明显。

算法

此指数是在图像的各个窗口上计算的。共同大小为 $N\times N$ 的两个窗口 $x$ 和 $y$ 之间的度量为：
$$\mathrm{结构相似性指数测量}(x,y)=\frac{\left(2{\mu }_x{\mu }_y+c_1\right)\left(2{\sigma }_{xy}+c_2\right)}{\left({\mu }_x^2+{\mu }_y^2+c_1\right)\left({\sigma }_x^2+{\sigma }_y^2+c_2\right)}$$

• ${\mu }_x$ 是$x$ 的像素样本平均值
• ${\mu }_y$是 $y$ 的像素样本平均值
• ${\sigma }_x^2$是$x$ 的方差
• ${\sigma }_y^2$是$y$的方差
• ${\sigma }_{xy}$是$x$ 和 $y$ 的协方差
• $c_1={\left(k_{1}L\right)}^2,c_2={\left(k_{2}L\right)}^2$两个变量来稳定弱分母除法
• $L$ 像素值的动态范围（通常为 $2^{\#\text{ Wits per Pixel }}-1$ ）
• 默认情况下 $k_1=0.01$ 和 $k_2=0.03$

公式基于 $x$ 和 $y$ 样本之间的三个比较测量值：亮度 $(l)$、对比度 $(c)$ 和结构 (s)。各个比较函数是：
$$\begin{array}{rl}& l(x,y)=\frac{2{\mu }_x{\mu }_y+c_1}{{\mu }_x^2+{\mu }_y^2+c_1}\\ & c(x,y)=\frac{2{\sigma }_x{\sigma }_y+c_2}{{\sigma }_x^2+{\sigma }_y^2+c_2}\\ & s(x,y)=\frac{{\sigma }_{xy}+c_3}{{\sigma }_x{\sigma }_y+c_3}\end{array}$$

结构相似性指数测量的更高级形式称为多尺度结构相似性指数测量，它通过多阶段子采样过程在多个尺度上进行，让人想起早期视觉系统中的多尺度处理。事实证明，它在不同的主观图像和视频数据库上的表现与结构相似性指数测量相当或更好。

Python(TensorFlow)多尺度结构相似性指数测量

import numpy as np
from scipy import signal
from scipy.ndimage.filters import convolve
import tensorflow as tf


tf.flags.DEFINE_string('original_image', None, 'Path to PNG image.')
tf.flags.DEFINE_string('compared_image', None, 'Path to PNG image.')
FLAGS = tf.flags.FLAGS


def _FSpecialGauss(size, sigma):

  radius = size // 2
  offset = 0.0
  start, stop = -radius, radius + 1
  if size % 2 == 0:
    offset = 0.5
    stop -= 1
  x, y = np.mgrid[offset + start:stop, offset + start:stop]
  assert len(x) == size
  g = np.exp(-((x**2 + y**2)/(2.0 * sigma**2)))
  return g / g.sum()

def _SSIMForMultiScale(img1, img2, max_val=255, filter_size=11,
                       filter_sigma=1.5, k1=0.01, k2=0.03):

  if img1.shape != img2.shape:
    raise RuntimeError('Input images must have the same shape (%s vs. %s).',
                       img1.shape, img2.shape)
  if img1.ndim != 4:
    raise RuntimeError('Input images must have four dimensions, not %d',
                       img1.ndim)

  img1 = img1.astype(np.float64)
  img2 = img2.astype(np.float64)
  _, height, width, _ = img1.shape

  size = min(filter_size, height, width)

  sigma = size * filter_sigma / filter_size if filter_size else 0

  if filter_size:
    window = np.reshape(_FSpecialGauss(size, sigma), (1, size, size, 1))
    mu1 = signal.fftconvolve(img1, window, mode='valid')
    mu2 = signal.fftconvolve(img2, window, mode='valid')
    sigma11 = signal.fftconvolve(img1 * img1, window, mode='valid')
    sigma22 = signal.fftconvolve(img2 * img2, window, mode='valid')
    sigma12 = signal.fftconvolve(img1 * img2, window, mode='valid')
  else:

    mu1, mu2 = img1, img2
    sigma11 = img1 * img1
    sigma22 = img2 * img2
    sigma12 = img1 * img2

  mu11 = mu1 * mu1
  mu22 = mu2 * mu2
  mu12 = mu1 * mu2
  sigma11 -= mu11
  sigma22 -= mu22
  sigma12 -= mu12

  c1 = (k1 * max_val) ** 2
  c2 = (k2 * max_val) ** 2
  v1 = 2.0 * sigma12 + c2
  v2 = sigma11 + sigma22 + c2
  ssim = np.mean((((2.0 * mu12 + c1) * v1) / ((mu11 + mu22 + c1) * v2)))
  cs = np.mean(v1 / v2)
  return ssim, cs


def MultiScaleSSIM(img1, img2, max_val=255, filter_size=11, filter_sigma=1.5,
                   k1=0.01, k2=0.03, weights=None):

  if img1.shape != img2.shape:
    raise RuntimeError('Input images must have the same shape (%s vs. %s).',
                       img1.shape, img2.shape)
  if img1.ndim != 4:
    raise RuntimeError('Input images must have four dimensions, not %d',
                       img1.ndim)

  # Note: default weights don't sum to 1.0 but do match the paper / matlab code.
  weights = np.array(weights if weights else
                     [0.0448, 0.2856, 0.3001, 0.2363, 0.1333])
  levels = weights.size
  downsample_filter = np.ones((1, 2, 2, 1)) / 4.0
  im1, im2 = [x.astype(np.float64) for x in [img1, img2]]
  mssim = np.array([])
  mcs = np.array([])
  for _ in range(levels):
    ssim, cs = _SSIMForMultiScale(
        im1, im2, max_val=max_val, filter_size=filter_size,
        filter_sigma=filter_sigma, k1=k1, k2=k2)
    mssim = np.append(mssim, ssim)
    mcs = np.append(mcs, cs)
    filtered = [convolve(im, downsample_filter, mode='reflect')
                for im in [im1, im2]]
    im1, im2 = [x[:, ::2, ::2, :] for x in filtered]
  return (np.prod(mcs[0:levels-1] ** weights[0:levels-1]) *
          (mssim[levels-1] ** weights[levels-1]))


def main(_):
  if FLAGS.original_image is None or FLAGS.compared_image is None:
    print('\nUsage: python msssim.py --original_image=original.png '
          '--compared_image=distorted.png\n\n')
    return

  if not tf.gfile.Exists(FLAGS.original_image):
    print('\nCannot find --original_image.\n')
    return

  if not tf.gfile.Exists(FLAGS.compared_image):
    print('\nCannot find --compared_image.\n')
    return

  with tf.gfile.FastGFile(FLAGS.original_image) as image_file:
    img1_str = image_file.read()
  with tf.gfile.FastGFile(FLAGS.compared_image) as image_file:
    img2_str = image_file.read()

  input_img = tf.placeholder(tf.string)
  decoded_image = tf.expand_dims(tf.image.decode_png(input_img, channels=3), 0)

  with tf.Session() as sess:
    img1 = sess.run(decoded_image, feed_dict={input_img: img1_str})
    img2 = sess.run(decoded_image, feed_dict={input_img: img2_str})

  print((MultiScaleSSIM(img1, img2, max_val=255)))


if __name__ == '__main__':
  tf.app.run()

执行：

python msssim.py --original_image=original.png --compared_image=distorted.png

👉更新：亚图跨际