2015-03-25 16:35:33 wenymwow 阅读数 4097

Androidk开发之图像局部扭曲算法(瘦脸算法)

和之前的相同,这次是图像局部扭曲算法,参照的文章是浙江某所大学两个教授的论文,具体是哪个忘了,弄了一整天,搞出来了。这个算法还不够严谨,主要处理大图片时效率不高,算法本来就不是我喜欢的,有能力的同学可以优化下,别忘了在回复里贴上。


直接贴出代码,如下

public static Bitmap smallFace(Bitmap bitmap, int tempX, int tempY,
            int PointX, int PointY, int Radius) {
        int width = bitmap.getWidth();
        int height = bitmap.getHeight();
        // int[] pixNew = new int[width * height];
        // int[] pixOld = new int[width * height];
        int Left = tempX - Radius < 0 ? 0 : tempX - Radius; // 计算边界值
        int Top = tempY - Radius < 0 ? 0 : tempY - Radius;
        int Bottom = tempY + Radius >= height ? height - 1 : tempY + Radius;
        int Right = tempX + Radius >= width ? width - 1 : tempX + Radius;
        Bitmap newBitmap = bitmap.copy(Bitmap.Config.RGB_565, true);
        // bitmap.getPixels(pixNew, Top * width + Left, width, Left, Top,
        // Radius * 2, Radius * 2);
        // bitmap.getPixels(pixOld, Top * width + Left, width, Left, Top,
        // Radius * 2, Radius * 2);
        int disX = PointX - tempX;
        int disY = PointY - tempY;
        int PowRadius = Radius * Radius;
        int distance = disY * disY + disX * disX;
        if (distance > Radius * Radius / 4)
            return newBitmap;

        for (int Y = Top; Y <= Bottom; Y++) {
            int offSetY = Y - PointY;
            for (int X = Left; X <= Right; X++) {
                int offSetX = X - PointX;
                double XY = offSetX * offSetX + offSetY * offSetY;
                int PosX = (int) (X + disX * B(XY / PowRadius));
                int PosY = (int) (Y + disY * B(XY / PowRadius));
                if (PosX < 0) { // 放置越界
                    PosX = 0;
                } else if (PosX >= width) {
                    PosX = width - 1;
                }
                if (PosY < 0) {
                    PosY = 0;
                } else if (PosY >= height) {
                    PosY = height - 1;
                }
                // int Speed = Y * width + X;
                // int Index = PosY * width + PosX;
                newBitmap.setPixel(X, Y, bitmap.getPixel(PosX, PosY));
                // pixNew[Speed] = pixOld[Index];
            }
        }
        // bitmap.setPixels(pixNew, Top * width + Left, width, Left, Top,
        // Radius * 2, Radius * 2);
        return newBitmap;
    }

不做注释了,这还要注释就是真正的伸手党了。

2018-11-22 16:44:45 Peter_Changyb 阅读数 334

 卷积神经网络CNN主要用来识别位移、缩放及其他形式扭曲不变性的二维图形。由于CNN的特征检测层通过训练数据进行学习,所以在使用CNN时,避免了显式的特征抽取,而隐式地从训练数据中进行学习;再者由于同一特征映射面上的神经元权值相同,所以网络可以并行学习,这也是卷积网络相对于神经元彼此相连网络的一大优势。卷积神经网络以其局部权值共享的特殊结构在语音识别和图像处理方面有着独特的优越性,其布局更接近于实际的生物神经网络,权值共享降低了网络的复杂性,特别是多维输入向量的图像可以直接输入网络这一特点避免了特征提取和分类过程中数据重建的复杂度。如下是手写识别的案例:

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import  input_data

#载入数据集
mnist = input_data.read_data_sets("MNIST_data", one_hot = True)

#批次大小
batch_size = 100
#计算一共有多少个批次
n_batch = mnist.train._num_examples // batch_size

#占位符
xs = tf.placeholder(tf.float32, [None, 784])
ys = tf.placeholder(tf.float32, [None, 10])
keep_prob = tf.placeholder(tf.float32)
lr = tf.Variable(0.001, dtype = tf.float32)

#创建神经网络层
def add_layer(inputs, in_size, out_size, activation_function=None):

    W = tf.Variable(tf.truncated_normal([in_size, out_size],stddev = 0.1))
    b = tf.Variable(tf.zeros([1, out_size]))
    Wx_plus_b = tf.matmul(inputs, W) + b

    if(activation_function == None):
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return tf.nn.dropout(outputs, keep_prob)



#创建神经网络
l1 = add_layer(xs, 784,500,tf.nn.tanh)
l2 = add_layer(l1, 500, 300, tf.nn.tanh)
prediction = add_layer(l2, 300, 10, tf.nn.softmax)

#损失函数为 交叉熵
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels = ys, logits = prediction))
#使用梯度下降法
# train_op = tf.train.GradientDescentOptimizer(0.2).minimize(loss)
train_op = tf.train.AdamOptimizer(lr).minimize(loss)
#初始化变量
init = tf.global_variables_initializer()
#结果存放在一个布尔型变量
correct_prediction = tf.equal(tf.argmax(ys, 1), tf.argmax(prediction, 1))
#求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))


with tf.Session() as sess:
    sess.run(init)
    for epoch in range(51):  
        sess.run(tf.assign(lr, 0.001*(0.95**epoch)))
        for batch in range(n_batch):
            batch_xs, batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_op, feed_dict = {xs: batch_xs, ys:batch_ys,keep_prob:1.0})
        test_acc = sess.run(accuracy, feed_dict={xs: mnist.test.images, ys:mnist.test.labels,keep_prob:1.0})
        learing_rate = sess.run(lr)
        print "Iter", epoch, "test_acc: ",test_acc,"learning_rate", learing_rate

 

2019-03-06 20:42:20 qq_42495866 阅读数 1268

CNN优点:

CNN主要用来识别位移、缩放及其他形式扭曲不变性的二维图形。由于CNN的特征检测层通过训练数据进行学习,所以在使用CNN时,避免了显示的特征抽取,而隐式地从训练数据中进行学习;再者由于同一特征映射面上的神经元权值相同,所以网络可以并行学习,这也是卷积网络相对于神经元彼此相连网络的一大优势。卷积神经网络以其局部权值共享的特殊结构在语音识别和图像处理方面有着独特的优越性,其布局更接近于实际的生物神经网络,权值共享降低了网络的复杂性,特别是多维输入向量的图像可以直接输入网络这一特点避免了特征提取和分类过程中数据重建的复杂度。

卷积神经网络在图像处理中,往往把图像表示为像素的向量

 

卷积网络各个层作用:

1.卷积层:用它来进行特征提取。

2.池化层:对输入的特征图进行压缩,一方面使特征图变小,简化网络计算复杂度;一方面进行特征压缩,提取主要特征。

3.全连接层:连接所有的特征,将输出值送给分类器。

 

2019-09-21 23:58:43 qq_26623879 阅读数 46

Sequential Adversarial Learning for Self-Supervised Deep Visual Odometry

摘要

我们提出了一个视觉里程计(vo)的自监督学习框架,该框架结合了连续帧的相关性,并利用了对抗学习的优势。以前的方法将自监督vo作为运动局部结构(sfm)来处理,通过最小化扭曲图像和捕获图像之间的光度损失,从图像对中恢复单个图像的深度和相对姿态。由于单视深度估计是一个不适定问题,且光度损失无法识别扭曲图像的畸变伪影,估计的深度模糊,姿态不准确。与以往的方法相比,我们的框架学习了一种帧间相关性的紧凑表示,并通过合并序列信息来更新。更新后的表示用于深度估计。此外,我们将vo作为一个自监督的图像生成任务来处理,并利用生成性对抗网络(gan)。生成器学习估计深度和姿势以生成扭曲的目标图像。该鉴别器利用高层次的结构感知对生成的图像进行质量评价,克服了以往方法中像素丢失的问题。在kitti和cityscapes数据集上的实验表明,我们的方法在保留细节的情况下获得了更精确的深度,并且预测的姿态明显优于art自监督方法。

贡献

本文的主要贡献概括如下:
•我们建议利用长序列上的时空相关性来显著减少自监督vo的估计误差和尺度漂移。
•我们将自我监督的vo视为生成模型,利用对抗学习进行自我监督姿势和深度估计。

方法

我们的方法不同于以往的技术,将自监督vo表示为一个序列学习问题,将帧间相关性表示为一个压缩码,并通过lstm集成序列信息。与目前流行的单视点深度估计方法不同,我们的框架是根据单个图像的编码来估计深度,并将vo作为一个生成任务来处理。通过对抗学习,我们的方法提供了更清晰的深度和更准确的姿态估计。
视觉里程计估计连续图像对之间的相机运动。在经典的vo/slam中,这种估计是通过特征对应或光度一致性来计算的。与以往直接从原始图像进行估计的自监督方法不同,我们为网络提供了一种用于深度和姿态估计的帧间对应表示。
在这里插入图片描述

实验

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2016-07-29 11:42:13 haoji007 阅读数 1937


图像的形变与缩放,使用的是skimage的transform模块,函数比较多,功能齐全。

1、改变图片尺寸resize

函数格式为:

skimage.transform.resize(imageoutput_shape)

image: 需要改变尺寸的图片

output_shape: 新的图片尺寸

复制代码
from skimage import transform,data
import matplotlib.pyplot as plt
img = data.camera()
dst=transform.resize(img, (80, 60))
plt.figure('resize')

plt.subplot(121)
plt.title('before resize')
plt.imshow(img,plt.cm.gray)

plt.subplot(122)
plt.title('before resize')
plt.imshow(dst,plt.cm.gray)

plt.show()
复制代码

将camera图片由原来的512*512大小,变成了80*60大小。从下图中的坐标尺,我们能够看出来:

 

2、按比例缩放rescale

函数格式为:

skimage.transform.rescale(image, scale[, ...])

scale参数可以是单个float数,表示缩放的倍数,也可以是一个float型的tuple,如[0.2,0.5],表示将行列数分开进行缩放

from skimage import transform,data
img = data.camera()
print(img.shape)  #图片原始大小 
print(transform.rescale(img, 0.1).shape)  #缩小为原来图片大小的0.1倍
print(transform.rescale(img, [0.5,0.25]).shape)  #缩小为原来图片行数一半,列数四分之一
print(transform.rescale(img, 2).shape)   #放大为原来图片大小的2倍

结果为:

(512, 512)
(51, 51)
(256, 128)
(1024, 1024)

3、旋转 rotate

skimage.transform.rotate(image, angle[, ...],resize=False)

angle参数是个float类型数,表示旋转的度数

resize用于控制在旋转时,是否改变大小 ,默认为False

复制代码
from skimage import transform,data
import matplotlib.pyplot as plt
img = data.camera()
print(img.shape)  #图片原始大小
img1=transform.rotate(img, 60) #旋转90度,不改变大小 
print(img1.shape)
img2=transform.rotate(img, 30,resize=True)  #旋转30度,同时改变大小
print(img2.shape)   

plt.figure('resize')

plt.subplot(121)
plt.title('rotate 60')
plt.imshow(img1,plt.cm.gray)

plt.subplot(122)
plt.title('rotate  30')
plt.imshow(img2,plt.cm.gray)

plt.show()
复制代码

显示结果:

4、图像金字塔

以多分辨率来解释图像的一种有效但概念简单的结构就是图像金字塔。图像金字塔最初用于机器视觉和图像压缩,一幅图像的金字塔是一系列以金字塔形状排列的分辨率逐步降低的图像集合。金字塔的底部是待处理图像的高分辨率表示,而顶部是低分辨率的近似。当向金字塔的上层移动时,尺寸和分辨率就降低。

在此,我们举一个高斯金字塔的应用实例,函数原型为:

skimage.transform.pyramid_gaussian(image, downscale=2)
downscale控制着金字塔的缩放比例
复制代码
import numpy as np
import matplotlib.pyplot as plt
from skimage import data,transform

image = data.astronaut()  #载入宇航员图片
rows, cols, dim = image.shape  #获取图片的行数,列数和通道数
pyramid = tuple(transform.pyramid_gaussian(image, downscale=2))  #产生高斯金字塔图像
#共生成了log(512)=9幅金字塔图像,加上原始图像共10幅,pyramid[0]-pyramid[1]

composite_image = np.ones((rows, cols + cols / 2, 3), dtype=np.double)  #生成背景

composite_image[:rows, :cols, :] = pyramid[0]  #融合原始图像

i_row = 0
for p in pyramid[1:]:
    n_rows, n_cols = p.shape[:2]
    composite_image[i_row:i_row + n_rows, cols:cols + n_cols] = p  #循环融合9幅金字塔图像
    i_row += n_rows

plt.imshow(composite_image)
plt.show()
复制代码

上右图,就是10张金字塔图像,下标为0的表示原始图像,后面每层的图像行和列变为上一层的一半,直至变为1

除了高斯金字塔外,还有其它的金字塔,如:

skimage.transform.pyramid_laplacian(image, downscale=2):

没有更多推荐了,返回首页