图片去摩尔纹简述实现python代码示例

目录
  • 1、前言
  • 2、网络结构复现
  • 3、数据预处理
  • 4、模型训练
  • 总结

1、前言

当感光元件像素的空间频率与影像中条纹的空间频率接近时,可能产生一种新的波浪形的干扰图案,即所谓的摩尔纹。传感器的网格状纹理构成了一个这样的图案。当图案中的细条状结构与传感器的结构以小角度交叉时,这种效应也会在图像中产生明显的干扰。这种现象在一些细密纹理情况下,比如时尚摄影中的布料上,非常普遍。这种摩尔纹可能通过亮度也可能通过颜色来展现。但是在这里,仅针对在翻拍过程中产生的图像摩尔纹进行处理。

翻拍即从计算机屏幕上捕获图片,或对着屏幕拍摄图片;该方式会在图片上产生摩尔纹现象

论文主要处理思路

  • 对原图作Haar变换得到四个下采样特征图(原图下二采样cA、Horizontal横向高频cH、Vertical纵向高频cV、Diagonal斜向高频cD)
  • 然后分别利用四个独立的CNN对四个下采样特征图卷积池化,提取特征信息
  • 原文随后对三个高频信息卷积池化后的结果的每个channel、每个像素点比对,取max
  • 将上一步得到的结果和cA卷积池化后的结果作笛卡尔积

论文地址

2、网络结构复现

  如下图所示,本项目复现了论文的图像去摩尔纹方法,并对数据处理部分进行了修改,并且网络结构上也参考了源码中的结构,对图片产生四个下采样特征图,而不是论文中的三个,具体处理方式大家可以参考一下网络结构。

import math
import paddle
import paddle.nn as nn
import paddle.nn.functional as F
# import pywt
from paddle.nn import Linear, Dropout, ReLU
from paddle.nn import Conv2D, MaxPool2D
class mcnn(nn.Layer):
    def __init__(self, num_classes=1000):
        super(mcnn, self).__init__()
        self.num_classes = num_classes
        self._conv1_LL = Conv2D(3,32,7,stride=2,padding=1,)
        # self.bn1_LL = nn.BatchNorm2D(128)
        self._conv1_LH = Conv2D(3,32,7,stride=2,padding=1,)
        # self.bn1_LH = nn.BatchNorm2D(256)
        self._conv1_HL = Conv2D(3,32,7,stride=2,padding=1,)
        # self.bn1_HL = nn.BatchNorm2D(512)
        self._conv1_HH = Conv2D(3,32,7,stride=2,padding=1,)
        # self.bn1_HH = nn.BatchNorm2D(256)
        self.pool_1_LL = nn.MaxPool2D(kernel_size=2,stride=2, padding=0)
        self.pool_1_LH = nn.MaxPool2D(kernel_size=2,stride=2, padding=0)
        self.pool_1_HL = nn.MaxPool2D(kernel_size=2,stride=2, padding=0)
        self.pool_1_HH = nn.MaxPool2D(kernel_size=2,stride=2, padding=0)
        self._conv2 = Conv2D(32,16,3,stride=2,padding=1,)
        self.pool_2 = nn.MaxPool2D(kernel_size=2,stride=2, padding=0)
        self.dropout2 = Dropout(p=0.5)
        self._conv3 = Conv2D(16,32,3,stride=2,padding=1,)
        self.pool_3 = nn.MaxPool2D(kernel_size=2,stride=2, padding=0)
        self._conv4 = Conv2D(32,32,3,stride=2,padding=1,)
        self.pool_4 = nn.MaxPool2D(kernel_size=2,stride=2, padding=0)
        self.dropout4 = Dropout(p=0.5)
        # self.bn1_HH = nn.BatchNorm1D(256)
        self._fc1 = Linear(in_features=64,out_features=num_classes)
        self.dropout5 = Dropout(p=0.5)
        self._fc2 = Linear(in_features=2,out_features=num_classes)
    def forward(self, inputs1, inputs2, inputs3, inputs4):
        x1_LL = self._conv1_LL(inputs1)
        x1_LL = F.relu(x1_LL)
        x1_LH = self._conv1_LH(inputs2)
        x1_LH = F.relu(x1_LH)
        x1_HL = self._conv1_HL(inputs3)
        x1_HL = F.relu(x1_HL)
        x1_HH = self._conv1_HH(inputs4)
        x1_HH = F.relu(x1_HH)
        pool_x1_LL = self.pool_1_LL(x1_LL)
        pool_x1_LH = self.pool_1_LH(x1_LH)
        pool_x1_HL = self.pool_1_HL(x1_HL)
        pool_x1_HH = self.pool_1_HH(x1_HH)
        temp = paddle.maximum(pool_x1_LH, pool_x1_HL)
        avg_LH_HL_HH = paddle.maximum(temp, pool_x1_HH)
        inp_merged = paddle.multiply(pool_x1_LL, avg_LH_HL_HH)
        x2 = self._conv2(inp_merged)
        x2 = F.relu(x2)
        x2 = self.pool_2(x2)
        x2 = self.dropout2(x2)
        x3 = self._conv3(x2)
        x3 = F.relu(x3)
        x3 = self.pool_3(x3)
        x4 = self._conv4(x3)
        x4 = F.relu(x4)
        x4 = self.pool_4(x4)
        x4 = self.dropout4(x4)
        x4 = paddle.flatten(x4, start_axis=1, stop_axis=-1)
        x5 = self._fc1(x4)
        x5 = self.dropout5(x5)
        out = self._fc2(x5)
        return out
model_res = mcnn(num_classes=2)
paddle.summary(model_res,[(1,3,512,384),(1,3,512,384),(1,3,512,384),(1,3,512,384)])
---------------------------------------------------------------------------
 Layer (type)       Input Shape          Output Shape         Param #
===========================================================================
   Conv2D-1      [[1, 3, 512, 384]]   [1, 32, 254, 190]        4,736
   Conv2D-2      [[1, 3, 512, 384]]   [1, 32, 254, 190]        4,736
   Conv2D-3      [[1, 3, 512, 384]]   [1, 32, 254, 190]        4,736
   Conv2D-4      [[1, 3, 512, 384]]   [1, 32, 254, 190]        4,736
  MaxPool2D-1   [[1, 32, 254, 190]]    [1, 32, 127, 95]          0
  MaxPool2D-2   [[1, 32, 254, 190]]    [1, 32, 127, 95]          0
  MaxPool2D-3   [[1, 32, 254, 190]]    [1, 32, 127, 95]          0
  MaxPool2D-4   [[1, 32, 254, 190]]    [1, 32, 127, 95]          0
   Conv2D-5      [[1, 32, 127, 95]]    [1, 16, 64, 48]         4,624
  MaxPool2D-5    [[1, 16, 64, 48]]     [1, 16, 32, 24]           0
   Dropout-1     [[1, 16, 32, 24]]     [1, 16, 32, 24]           0
   Conv2D-6      [[1, 16, 32, 24]]     [1, 32, 16, 12]         4,640
  MaxPool2D-6    [[1, 32, 16, 12]]      [1, 32, 8, 6]            0
   Conv2D-7       [[1, 32, 8, 6]]       [1, 32, 4, 3]          9,248
  MaxPool2D-7     [[1, 32, 4, 3]]       [1, 32, 2, 1]            0
   Dropout-2      [[1, 32, 2, 1]]       [1, 32, 2, 1]            0
   Linear-1          [[1, 64]]              [1, 2]              130
   Dropout-3          [[1, 2]]              [1, 2]               0
   Linear-2           [[1, 2]]              [1, 2]               6
===========================================================================
Total params: 37,592
Trainable params: 37,592
Non-trainable params: 0
---------------------------------------------------------------------------
Input size (MB): 9.00
Forward/backward pass size (MB): 59.54
Params size (MB): 0.14
Estimated Total Size (MB): 68.68
---------------------------------------------------------------------------
{'total_params': 37592, 'trainable_params': 37592}

3、数据预处理

  与源代码不同的是,本项目将图像的小波分解部分集成在了数据读取部分,即改为了线上进行小波分解,而不是源代码中的线下进行小波分解并且保存图片。首先,定义小波分解的函数

!pip install PyWavelets
import numpy as np
import pywt
def splitFreqBands(img, levRows, levCols):
    halfRow = int(levRows/2)
    halfCol = int(levCols/2)
    LL = img[0:halfRow, 0:halfCol]
    LH = img[0:halfRow, halfCol:levCols]
    HL = img[halfRow:levRows, 0:halfCol]
    HH = img[halfRow:levRows, halfCol:levCols]
    return LL, LH, HL, HH
def haarDWT1D(data, length):
    avg0 = 0.5;
    avg1 = 0.5;
    dif0 = 0.5;
    dif1 = -0.5;
    temp = np.empty_like(data)
    # temp = temp.astype(float)
    temp = temp.astype(np.uint8)
    h = int(length/2)
    for i in range(h):
        k = i*2
        temp[i] = data[k] * avg0 + data[k + 1] * avg1;
        temp[i + h] = data[k] * dif0 + data[k + 1] * dif1;
    data[:] = temp
# computes the homography coefficients for PIL.Image.transform using point correspondences
def fwdHaarDWT2D(img):
    img = np.array(img)
    levRows = img.shape[0];
    levCols = img.shape[1];
    # img = img.astype(float)
    img = img.astype(np.uint8)
    for i in range(levRows):
        row = img[i,:]
        haarDWT1D(row, levCols)
        img[i,:] = row
    for j in range(levCols):
        col = img[:,j]
        haarDWT1D(col, levRows)
        img[:,j] = col
    return splitFreqBands(img, levRows, levCols)
!cd "data/data188843/" && unzip -q 'total_images.zip'
import os
recapture_keys = [ 'ValidationMoire']
original_keys = ['ValidationClear']
def get_image_label_from_folder_name(folder_name):
    """
    :param folder_name:
    :return:
    """
    for key in original_keys:
        if key in folder_name:
            return 'original'
    for key in recapture_keys:
        if key in folder_name:
            return 'recapture'
    return 'unclear'
label_name2label_id = {
    'original': 0,
    'recapture': 1,}
src_image_dir = "data/data188843/total_images"
dst_file = "data/data188843/total_images/train.txt"
image_folder = [file for file in os.listdir(src_image_dir)]
print(image_folder)
image_anno_list = []
for folder in image_folder:
    label_name = get_image_label_from_folder_name(folder)
    # label_id = label_name2label_id.get(label_name, 0)
    label_id = label_name2label_id[label_name]
    folder_path = os.path.join(src_image_dir, folder)
    image_file_list = [file for file in os.listdir(folder_path) if
                        file.endswith('.jpg') or file.endswith('.jpeg') or
                        file.endswith('.JPG') or file.endswith('.JPEG') or file.endswith('.png')]
    for image_file in image_file_list:
        # if need_root_dir:
        #     image_path = os.path.join(folder_path, image_file)
        # else:
        image_path = image_file
        image_anno_list.append(folder +"/"+image_path +"\t"+ str(label_id) + '\n')
dst_path = os.path.dirname(src_image_dir)
if not os.path.exists(dst_path):
    os.makedirs(dst_path)
with open(dst_file, 'w') as fd:
    fd.writelines(image_anno_list)
import paddle
import numpy as np
import pandas as pd
import PIL.Image as Image
from paddle.vision import transforms
# from haar2D import fwdHaarDWT2D
paddle.disable_static()
# 定义数据预处理
data_transforms = transforms.Compose([
    transforms.Resize(size=(448,448)),
    transforms.ToTensor(), # transpose操作 + (img / 255)
    # transforms.Normalize(      # 减均值 除标准差
    #     mean=[0.31169346, 0.25506335, 0.12432463],
    #     std=[0.34042713, 0.29819837, 0.1375536])
    #计算过程:output[channel] = (input[channel] - mean[channel]) / std[channel]
])
# 构建Dataset
class MyDataset(paddle.io.Dataset):
    """
    步骤一:继承paddle.io.Dataset类
    """
    def __init__(self, train_img_list, val_img_list, train_label_list, val_label_list, mode='train', ):
        """
        步骤二:实现构造函数,定义数据读取方式,划分训练和测试数据集
        """
        super(MyDataset, self).__init__()
        self.img = []
        self.label = []
        # 借助pandas读csv的库
        self.train_images = train_img_list
        self.test_images = val_img_list
        self.train_label = train_label_list
        self.test_label = val_label_list
        if mode == 'train':
            # 读train_images的数据
            for img,la in zip(self.train_images, self.train_label):
                self.img.append('/home/aistudio/data/data188843/total_images/'+img)
                self.label.append(paddle.to_tensor(int(la), dtype='int64'))
        else:
            # 读test_images的数据
            for img,la in zip(self.test_images, self.test_label):
                self.img.append('/home/aistudio/data/data188843/total_images/'+img)
                self.label.append(paddle.to_tensor(int(la), dtype='int64'))
    def load_img(self, image_path):
        # 实际使用时使用Pillow相关库进行图片读取即可,这里我们对数据先做个模拟
        image = Image.open(image_path).convert('RGB')
        # image = data_transforms(image)
        return image
    def __getitem__(self, index):
        """
        步骤三:实现__getitem__方法,定义指定index时如何获取数据,并返回单条数据(训练数据,对应的标签)
        """
        image = self.load_img(self.img[index])
        LL, LH, HL, HH = fwdHaarDWT2D(image)
        label = self.label[index]
        # print(LL.shape)
        # print(LH.shape)
        # print(HL.shape)
        # print(HH.shape)
        LL = data_transforms(LL)
        LH = data_transforms(LH)
        HL = data_transforms(HL)
        HH = data_transforms(HH)
        print(type(LL))
        print(LL.dtype)
        return LL, LH, HL, HH, np.array(label, dtype='int64')
    def __len__(self):
        """
        步骤四:实现__len__方法,返回数据集总数目
        """
        return len(self.img)
image_file_txt = '/home/aistudio/data/data188843/total_images/train.txt'
with open(image_file_txt) as fd:
    lines = fd.readlines()
train_img_list = list()
train_label_list = list()
for line in lines:
    split_list = line.strip().split()
    image_name, label_id = split_list
    train_img_list.append(image_name)
    train_label_list.append(label_id)
# print(train_img_list)
# print(train_label_list)
# 测试定义的数据集
train_dataset = MyDataset(mode='train',train_label_list=train_label_list,  train_img_list=train_img_list, val_img_list=train_img_list, val_label_list=train_label_list)
# test_dataset = MyDataset(mode='test')
# 构建训练集数据加载器
train_loader = paddle.io.DataLoader(train_dataset, batch_size=2, shuffle=True)
# 构建测试集数据加载器
valid_loader = paddle.io.DataLoader(train_dataset, batch_size=2, shuffle=True)
print('=============train dataset=============')
for LL, LH, HL, HH, label in train_dataset:
    print('label: {}'.format(label))
    break

4、模型训练

model2 = paddle.Model(model_res)
model2.prepare(optimizer=paddle.optimizer.Adam(parameters=model2.parameters()),
              loss=nn.CrossEntropyLoss(),
              metrics=paddle.metric.Accuracy())
model2.fit(train_loader,
        valid_loader,
        epochs=5,
        verbose=1,
        )

总结

本项目主要介绍了如何使用卷积神经网络去检测翻拍图片,主要为摩尔纹图片;其主要创新点在于网络结构上,将图片的高低频信息分开处理。

在本项目中,CNN 仅使用 1 级小波分解进行训练。 可以探索对多级小波分解网络精度的影响。 CNN 模型可以用更多更难的例子和更深的网络进行训练,更多关于python 图片去摩尔纹的资料请关注我们其它相关文章!

(0)

相关推荐

  • Python使用PIL.image保存图片

    目录 1.原图 1.首先PIL保存图片的时候,图片类型一定要是ndarray类型,不能是tensor类型,否则报错 2.tensor转成ndarray类型保存 3.如果不进行归一化处理,也会报错 总结 1.原图 1.首先PIL保存图片的时候,图片类型一定要是ndarray类型,不能是tensor类型,否则报错 img=cv2.imread("./epoch034_iter100_target.png") img1=torch.tensor(img) image_pil=Image.fr

  • Python实现普通图片转ico图标的方法详解

    目录 简介 历史攻略 下载安装包 下载地址 安装后缀pythonmagick - whl文件 案例源码 效果图 简介 ICO是一种图标文件格式,图标文件可以存储单个图案.多尺寸.多色板的图标文件.一个图标实际上是多张不同格式的图片的集合体,并且还包含了一定的透明区域.它是图标文件格式的一种,可以存储单个图案.多尺寸.多色板的图标文件.图标是具有明确指代含义的计算机图形.其中桌面图标是软件标识,界面中的图标是功能标识. 历史攻略 pip安装第三方库全攻略:普通安装.安装whl后缀文件.使用国内镜像

  • Python Matplotlib中使用plt.savefig存储图片的方法举例

    目录 前言 主要功能: 函数源码:(根据需要进行选择) 参数解释: 注意事项: 补充:解决plt.savefig() 保存多张图片有重叠的问题 总结 前言 plt.show()展示图片的时候,截图进行保存,图片不是多么清晰 如何保存高清图也是一知识点 函数包名:import matplotlib.pyplot as plt 主要功能: 保存绘制数据后创建的图形.使用此方法可以将创建的图形保存 函数源码:(根据需要进行选择) savefig(fname, dpi=None, facecolor='

  • Python自制一个PDF转PNG图片小工具

    使用PyQt5应用程序制作PDF转换成图片的小工具,可以导入PDF文档后一键生成对应的PNG图片. PDF图片转换小工具使用的中间件: python版本:3.6.8 UI应用版本:PyQt5 PDF文件操作非标准库:PyPDF2 PNG图片生成库:PyMuPDF pip install PyQt5 pip install PyPDF2 pip install PyMuPDF==1.18.17 将需要使用到的python标准库或非标准库全部导入到我们的代码块中进入开发环节. # Importing

  • 详解python实现多张多格式图片转PDF并打包成exe

    目录 转PDF初始代码 转PDF最终代码 GUI界面设计代码 打包成可执行文件 完整代码 附录 转PDF初始代码 从文件夹中读取图片数据,然后将他们保存为PDF格式. 不长,大概10行代码. from PIL import Image from os import * def PictureToPDF(picture_path, name): pictures = [] picture_file = listdir(picture_path) for file in picture_file:

  • 图片去摩尔纹简述实现python代码示例

    目录 1.前言 2.网络结构复现 3.数据预处理 4.模型训练 总结 1.前言 当感光元件像素的空间频率与影像中条纹的空间频率接近时,可能产生一种新的波浪形的干扰图案,即所谓的摩尔纹.传感器的网格状纹理构成了一个这样的图案.当图案中的细条状结构与传感器的结构以小角度交叉时,这种效应也会在图像中产生明显的干扰.这种现象在一些细密纹理情况下,比如时尚摄影中的布料上,非常普遍.这种摩尔纹可能通过亮度也可能通过颜色来展现.但是在这里,仅针对在翻拍过程中产生的图像摩尔纹进行处理. 翻拍即从计算机屏幕上捕获

  • python使用邻接矩阵构造图代码示例

    问题 如何使用list构造图 邻接矩阵的方式 Python代码示例 # !/usr/bin/env python # -*-encoding: utf-8-*- # author:LiYanwei # version:0.1 # 邻接矩阵 ''' a---b\ | | \ | | c | | / e---d/ 对于无向图顶点之间存在边,则为1,反之则为0 a b c d e a 0 1 0 0 1 b 1 0 1 1 0 c 0 1 0 1 0 d 0 1 1 0 1 e 1 0 0 1 0 观

  • python代码实现TSNE降维数据可视化教程

    TSNE降维 降维就是用2维或3维表示多维数据(彼此具有相关性的多个特征数据)的技术,利用降维算法,可以显式地表现数据.(t-SNE)t分布随机邻域嵌入 是一种用于探索高维数据的非线性降维算法.它将多维数据映射到适合于人类观察的两个或多个维度. python代码 km.py #k_mean算法 import pandas as pd import csv import pandas as pd import numpy as np #参数初始化 inputfile = 'x.xlsx' #销量及

  • python图片验证码识别最新模块muggle_ocr的示例代码

    一.官方文档 https://pypi.org/project/muggle-ocr/ 二模块安装 pip install muggle-ocr # 因模块过新,阿里/清华等第三方源可能尚未更新镜像,因此手动指定使用境外源,为了提高依赖的安装速度,可预先自行安装依赖:tensorflow/numpy/opencv-python/pillow/pyyaml 三.使用代码 # 导入包 import muggle_ocr # 初始化:model_type 包含了 ModelType.OCR/Model

  • python编程羊车门问题代码示例

    问题: 有3扇关闭的门,一扇门后面停着汽车,其余门后是山羊,只有主持人知道每扇门后面是什么.参赛者可以选择一扇门,在开启它之前,主持人会开启另外一扇门,露出门后的山羊,然后允许参赛者更换自己的选择. 请问: 1.按照你的第一感觉回答,你觉得不换选择能有更高的几率获得汽车,还是换选择能有更高的几率获得汽车?或几率没有发生变化? 答:第一感觉换与不换获奖几率没有发生变化. 2.请自己认真分析一下"不换选择能有更高的几率获得汽车,还是换选择能有更高的几率获得汽车?或几率没有发生变化?" 写出

  • Python随机生成均匀分布在单位圆内的点代码示例

    Python有一随机函数可以产生[0,1)区间内的随机数,但是如果我们想生成随机分布在单位圆上的,那么我们可以首先生成随机分布在单位圆边上的点,然后随机调整每个点距离原点的距离,但是我们发现这个距离不是均匀分布于[0,1]的,而是与扇形的面积相关的 我们使用另外的随机函数生成从[0,1)的随机数r,我们发现r<s0的概率为s0,显而易见,如果r为0,那么对应的距离应该为0,如果是1,对应的距离自然也应该是1,假设我们产生了m个随机数,那么小于s0的随机数应该为s0*m左右,而且这些应该对应于扇形

  • python+opencv实现的简单人脸识别代码示例

    # 源码如下: #!/usr/bin/env python #coding=utf-8 import os from PIL import Image, ImageDraw import cv def detect_object(image): '''检测图片,获取人脸在图片中的坐标''' grayscale = cv.CreateImage((image.width, image.height), 8, 1) cv.CvtColor(image, grayscale, cv.CV_BGR2GR

  • Python利用turtle库绘制彩虹代码示例

    语言:Python IDE:Python.IDE 需求 做出彩虹效果 颜色空间 RGB模型:光的三原色,共同决定色相 HSB/HSV模型:H色彩,S深浅,B饱和度,H决定色相 需要将HSB模型转换为RGB模型 代码示例: #-*- coding:utf-8 –*- from turtle import * def HSB2RGB(hues): hues = hues * 3.59 #100转成359范围 rgb=[0.0,0.0,0.0] i = int(hues/60)%6 f = hues/

  • 快速了解Python开发中的cookie及简单代码示例

    cookie :是用户保存在用户浏览器端的一对键值对,是为了解决http的无状态连接.服务端是可以把 cookie写到用户浏览器上,用户每次发请求会携带cookie. 存放位置: 每次发请求cookie是放在请求头里面的. 应用场景: ·登陆用户和密码的记住密码 ·显示每页显示的数据,以后都是按照设定的数目显示 ·投票机制 案例用户登录 创建用户登录的url url(r'^login/', views.login), 创建登录页面 代码为: <!DOCTYPE html> <html l

  • selenium python浏览器多窗口处理代码示例

    本文主要研究的是selenium python浏览器多窗口处理的相关内容,分享了操作实例代码,具体如下: #!/usr/bin/python # -*- coding: utf-8 -*- __author__ = 'zuoanvip' #在测试过程中有时候会遇到出现多个浏览器窗口的情况,这时候我们可以通过窗口的句柄来操作不同窗口的元素 from selenium import webdriver import os import time driver =webdriver.Firefox()

随机推荐