1. 程式人生 > >用DCGAN生成手寫體數字影象程式碼解析

用DCGAN生成手寫體數字影象程式碼解析

util.py檔案把專案中用到的工具函式整理到一起,包括onehot,影象剪裁,影象拼接

# !/usr/bin/python
# -*- coding: utf-8 -*-
import cv2
import scipy.misc
import ipdb
import numpy as np

def OneHot(X, n=None, negative_class=0.):
    #將輸入的矩陣壓平,轉化成向量l
    X = np.asarray(X).flatten()
    #得到輸入資料中最大的值
    if n is None:
        n = np.max(X) + 1
#生成l*n的矩陣,初始箇中元素都置為0 Xoh = np.ones((len(X), n)) * negative_class #將矩陣每一行中X的值所對應的第n個位置置1,其他位為0 Xoh[np.arange(len(X)), X] = 1. return Xoh # 例:生成如下的矩陣 # [[ 0. 0. 0. ..., 0. 0. 0.] # [ 0. 0. 0. ..., 0. 0. 1.] # [ 1. 0. 0. ..., 0. 0. 0.] # ..., # [ 0. 0. 0. ..., 0. 0. 1.] # [ 0. 0. 0. ..., 0. 0. 0.]
# [ 0. 0. 0. ..., 0. 0. 0.]] def crop_resize(image_path, resize_shape=(64,64)): #resize_image 必須是個正方形 image = cv2.imread(image_path) height, width, channel = image.shape #得到輸入影象初始的引數 #if width != height, 新正方形的邊長是原來影象較短的那一條邊 #resize_image 位於原來影象的正中間區域 if width == height: resized_image = cv2.resize(image, resize_shape) elif
width > height: resized_image = cv2.resize(image, (int(width * float(resize_shape[0])/height), resize_shape[1])) cropping_length = int( (resized_image.shape[1] - resize_shape[0]) / 2) resized_image = resized_image[:,cropping_length:cropping_length+resize_shape[1]] else: resized_image = cv2.resize(image, (resize_shape[0], int(height * float(resize_shape[1])/width))) cropping_length = int( (resized_image.shape[0] - resize_shape[1]) / 2) resized_image = resized_image[cropping_length:cropping_length+resize_shape[0], :] return resized_image/127.5 - 1#把返回的影象中每個畫素值的範圍壓縮在-1到1之間 #把原圖為28x28的影象拼湊起來組成一個392x392的影象 def save_visualization(X, (nh, nw), save_path='./vis/sample.jpg'): h,w = X.shape[1], X.shape[2] img = np.zeros((h * nh, w * nw, 3)) for n,x in enumerate(X): j = n / nw i = n % nw img[j*h:j*h+h, i*w:i*w+w, :] = x scipy.misc.imsave(save_path, img)

load.py檔案的作用是將MNIST資料匯入並進行資料集的劃分

# !/usr/bin/python
# -*- coding: utf-8 -*-
import sys
sys.path.append('..')

import numpy as np
import os
from time import time
from collections import Counter
import random
from matplotlib import pyplot as plt

data_dir = '/Users/Chris/MNIST_data'
def mnist():
    #訓練集有六萬組資料
    fd = open(os.path.join(data_dir,'train-images-idx3-ubyte'))
    loaded = np.fromfile(file=fd,dtype=np.uint8)
    trX = loaded[16:].reshape((60000,28*28)).astype(float)

    fd = open(os.path.join(data_dir,'train-labels-idx1-ubyte'))
    loaded = np.fromfile(file=fd,dtype=np.uint8)
    trY = loaded[8:].reshape((60000))

    #測試集有一萬組資料
    fd = open(os.path.join(data_dir,'t10k-images-idx3-ubyte'))
    loaded = np.fromfile(file=fd,dtype=np.uint8)
    teX = loaded[16:].reshape((10000,28*28)).astype(float)

    fd = open(os.path.join(data_dir,'t10k-labels-idx1-ubyte'))
    loaded = np.fromfile(file=fd,dtype=np.uint8)
    teY = loaded[8:].reshape((10000))

    trY = np.asarray(trY)
    teY = np.asarray(teY)

    return trX, teX, trY, teY

def mnist_with_valid_set():
    trX, teX, trY, teY = mnist()

    #從訓練集取出後1萬組作為驗證集,前5萬組作為新的測試集
    train_inds = range(len(trX))
    np.random.shuffle(train_inds)
    trX = trX[train_inds]
    trY = trY[train_inds]
    #trX, trY = shuffle(trX, trY)
    vaX = trX[50000:]
    vaY = trY[50000:]
    trX = trX[:50000]
    trY = trY[:50000]

    return trX, vaX, teX, trY, vaY, teY

model.py是模型的網路結構,該檔案還包括模型會用到的啟用函式和正則化方法等

# !/usr/bin/python
#-*- coding: utf-8 -*-
import tensorflow as tf
import ipdb

def batchnormalize(X, eps=1e-8, g=None, b=None):
    if X.get_shape().ndims == 4:
        mean = tf.reduce_mean(X, [0,1,2])
        std = tf.reduce_mean( tf.square(X-mean), [0,1,2] )
        X = (X-mean) / tf.sqrt(std+eps)

        if g is not None and b is not None:
            g = tf.reshape(g, [1,1,1,-1])
            b = tf.reshape(b, [1,1,1,-1])
            X = X*g + b

    elif X.get_shape().ndims == 2:
        mean = tf.reduce_mean(X, 0)
        std = tf.reduce_mean(tf.square(X-mean), 0)
        X = (X-mean) / tf.sqrt(std+eps)

        if g is not None and b is not None:
            g = tf.reshape(g, [1,-1])
            b = tf.reshape(b, [1,-1])
            X = X*g + b

    else:
        raise NotImplementedError

    return X

#此模型實用的啟用函式,形狀類似rule,但與rule不同的是x的負半軸那一部分的線段有斜率
def lrelu(X, leak=0.2):
    f1 = 0.5 * (1 + leak)
    f2 = 0.5 * (1 - leak)
    return f1 * X + f2 * tf.abs(X)

def bce(o, t):
    o = tf.clip_by_value(o, 1e-7, 1. - 1e-7)#將o中各個元素的值都壓縮在1e-7至1. - 1e-7之間
    return -(t * tf.log(o) + (1.- t)*tf.log(1. - o))#交叉熵

class DCGAN():
    def __init__(
            self,
            batch_size=100,
            image_shape=[28,28,1],
            dim_z=100,#噪聲z的維度
            dim_y=10, #數字0 - 9, 10類
            dim_W1=1024,
            dim_W2=128,
            dim_W3=64,
            dim_channel=1,#灰度影象的通道數
            ):

        self.batch_size = batch_size
        self.image_shape = image_shape
        self.dim_z = dim_z
        self.dim_y = dim_y

        self.dim_W1 = dim_W1
        self.dim_W2 = dim_W2
        self.dim_W3 = dim_W3
        self.dim_channel = dim_channel

        #初始化引數,在這裡設定name是為了訓練時獲取引數列表
        self.gen_W1 = tf.Variable(tf.random_normal([dim_z+dim_y, dim_W1], stddev=0.02), name='gen_W1')
        self.gen_W2 = tf.Variable(tf.random_normal([dim_W1+dim_y, dim_W2*7*7], stddev=0.02), name='gen_W2')
        self.gen_W3 = tf.Variable(tf.random_normal([5,5,dim_W3,dim_W2+dim_y], stddev=0.02), name='gen_W3')
        self.gen_W4 = tf.Variable(tf.random_normal([5,5,dim_channel,dim_W3+dim_y], stddev=0.02), name='gen_W4')

        #64個大小為5x5的卷積核,通道數為11
        self.discrim_W1 = tf.Variable(tf.random_normal([5,5,dim_channel+dim_y,dim_W3], stddev=0.02), name='discrim_W1')
        #128個大小為5x5的卷積核,通道數為74
        self.discrim_W2 = tf.Variable(tf.random_normal([5,5,dim_W3+dim_y,dim_W2], stddev=0.02), name='discrim_W2')
        self.discrim_W3 = tf.Variable(tf.random_normal([dim_W2*7*7+dim_y,dim_W1], stddev=0.02), name='discrim_W3')
        self.discrim_W4 = tf.Variable(tf.random_normal([dim_W1+dim_y,1], stddev=0.02), name='discrim_W4')

    def build_model(self):

        Z = tf.placeholder(tf.float32, [self.batch_size, self.dim_z])
        Y = tf.placeholder(tf.float32, [self.batch_size, self.dim_y])

        image_real = tf.placeholder(tf.float32, [self.batch_size]+self.image_shape)
        image_gen = self.generate(Z,Y)

        p_real = self.discriminate(image_real, Y)#真實影象判別概率
        p_gen = self.discriminate(image_gen, Y)#生成影象判別概率

        #判別網路的目標是讓真實影象的判別概率越接近1同時生成影象判別概率越接近0
        discrim_cost_real = bce(p_real, tf.ones_like(p_real))
        discrim_cost_gen = bce(p_gen, tf.zeros_like(p_gen))
        discrim_cost = tf.reduce_mean(discrim_cost_real) + tf.reduce_mean(discrim_cost_gen)

        #生成網路的目標是讓生成影象判別概率越接近1
        gen_cost = tf.reduce_mean(bce( p_gen, tf.ones_like(p_gen) ))

        return Z, Y, image_real, discrim_cost, gen_cost, p_real, p_gen

    def discriminate(self, image, Y):
        yb = tf.reshape(Y, tf.stack([self.batch_size, 1, 1, self.dim_y]))#shape=(128, 1, 1, 10)
        X = tf.concat([image, yb*tf.ones([self.batch_size, 28, 28, self.dim_y])],3)#shape=(128, 28, 28, 11)

        #第一層是個卷積層,得到64個14x14的feature map
        h1 = lrelu( tf.nn.conv2d( X, self.discrim_W1, strides=[1,2,2,1], padding='SAME' ))#shape=(128, 14, 14, 64)
        h1 = tf.concat([h1, yb*tf.ones([self.batch_size, 14, 14, self.dim_y])],3)#shape=(128, 14, 14, 74)

        #第二層是個卷積層,得到128個7x7的feature map
        h2 = lrelu( batchnormalize( tf.nn.conv2d( h1, self.discrim_W2, strides=[1,2,2,1], padding='SAME')) )#shape=(128, 7, 7, 128)
        h2 = tf.reshape(h2, [self.batch_size, -1])#shape=(128, 6272)
        h2 = tf.concat([h2, Y],1)#shape=(128, 6282)

        #第三層是個全連線層,得到1024個輸出節點
        h3 = lrelu( batchnormalize( tf.matmul(h2, self.discrim_W3 ) ))#shape=(128, 1024)
        h3 = tf.concat([h3, Y],1)#shape=(128, 1034)
        y = tf.nn.sigmoid(h3)#shape=(128, 1034)
        return y

    def generate(self, Z, Y):
        #是discriminate()的逆過程
        yb = tf.reshape(Y, [self.batch_size, 1, 1, self.dim_y])#shape=(128, 1, 1, 10)
        Z = tf.concat([Z,Y],1)#shape=(128, 110)

        #第一層是個全連線層
        h1 = tf.nn.relu(batchnormalize(tf.matmul(Z, self.gen_W1)))#shape=(128, 1024)
        h1 = tf.concat([h1, Y],1)#shape=(128, 1034)

        #第二層是個全連線層
        h2 = tf.nn.relu(batchnormalize(tf.matmul(h1, self.gen_W2)))#shape=(128, 6272)
        h2 = tf.reshape(h2, [self.batch_size,7,7,self.dim_W2])#shape=(128, 7, 7, 128)
        h2 = tf.concat([h2, yb*tf.ones([self.batch_size, 7, 7, self.dim_y])],3)#shape=(128, 7, 7, 138)

        #第三層是個反捲積層
        output_shape_l3 = [self.batch_size,14,14,self.dim_W3]
        h3 = tf.nn.conv2d_transpose(h2, self.gen_W3, output_shape=output_shape_l3, strides=[1,2,2,1])#shape=(128, 14, 14, 64)
        h3 = tf.nn.relu( batchnormalize(h3) )#shape=(128, 14, 14, 64)
        h3 = tf.concat([h3, yb*tf.ones([self.batch_size, 14,14,self.dim_y])],3 )#shape=(128, 14, 14, 74)

        #第四層是個反捲積層,得到28x28x1的影象
        output_shape_l4 = [self.batch_size,28,28,self.dim_channel]
        h4 = tf.nn.conv2d_transpose(h3, self.gen_W4, output_shape=output_shape_l4, strides=[1,2,2,1])#shape=(128, 28, 28, 1)
        x = tf.nn.sigmoid(h4)#shape=(128, 28, 28, 1)
        return x

    def samples_generator(self, batch_size):
        #結構與generate()相同,bacth_size設定的值與其不同,是為了將生成的一批影象拼接到一張例圖上
        Z = tf.placeholder(tf.float32, [batch_size, self.dim_z])
        Y = tf.placeholder(tf.float32, [batch_size, self.dim_y])

        yb = tf.reshape(Y, [batch_size, 1, 1, self.dim_y])
        Z_ = tf.concat([Z,Y],1)

        h1 = tf.nn.relu(batchnormalize(tf.matmul(Z_, self.gen_W1)))
        h1 = tf.concat([h1, Y],1)

        h2 = tf.nn.relu(batchnormalize(tf.matmul(h1, self.gen_W2)))
        h2 = tf.reshape(h2, [batch_size,7,7,self.dim_W2])
        h2 = tf.concat( [h2, yb*tf.ones([batch_size, 7, 7, self.dim_y])],3)

        output_shape_l3 = [batch_size,14,14,self.dim_W3]
        h3 = tf.nn.conv2d_transpose(h2, self.gen_W3, output_shape=output_shape_l3, strides=[1,2,2,1])
        h3 = tf.nn.relu( batchnormalize(h3) )
        h3 = tf.concat([h3, yb*tf.ones([batch_size, 14,14,self.dim_y])],3 )

        output_shape_l4 = [batch_size,28,28,self.dim_channel]
        h4 = tf.nn.conv2d_transpose(h3, self.gen_W4, output_shape=output_shape_l4, strides=[1,2,2,1])
        x = tf.nn.sigmoid(h4)
        return Z,Y,x

train.py檔案用於訓練模型並生成樣例影象

# !/usr/bin/python
#-*- coding: utf-8 -*-
import ipdb
import os
import pandas as pd
import numpy as np
from model import *
from util import *
from load import mnist_with_valid_set

n_epochs = 100
learning_rate = 0.0002
batch_size = 128
image_shape = [28,28,1]
dim_z = 100
dim_W1 = 1024
dim_W2 = 128
dim_W3 = 64
dim_channel = 1

visualize_dim=196#196個生成的樣本影象拼湊在一起儲存為一張樣例圖,樣例圖的尺寸為392x392

trX, vaX, teX, trY, vaY, teY = mnist_with_valid_set()
# trX trY 訓練集
# vaX vaY 驗證集
# teX teY 測試集

dcgan_model = DCGAN(
        batch_size=batch_size,
        image_shape=image_shape,
        dim_z=dim_z,
        dim_W1=dim_W1,
        dim_W2=dim_W2,
        dim_W3=dim_W3,
        )

Z_tf, Y_tf, image_tf, d_cost_tf, g_cost_tf, p_real, p_gen = dcgan_model.build_model()
# Z_tf 輸入隨機的資料
# Y_tf 輸出的類別(0-9個數字)
# image_tf batch_size個真實訓練影象
# d_cost_tf 判別網路的目標函式
# g_cost_tf 生成網路的目標函式
# p_real 真實影象的判別概率
# p_gen 生成影象的判別概率

sess = tf.InteractiveSession() #互動式使用對話
saver = tf.train.Saver(max_to_keep=10)

#得到判別網路和生成網路的引數列表
discrim_vars = filter(lambda x: x.name.startswith('discrim'), tf.trainable_variables())
gen_vars = filter(lambda x: x.name.startswith('gen'), tf.trainable_variables())

#訓練使用Adam進行優化,學習率設為0.0002
train_op_discrim = tf.train.AdamOptimizer(learning_rate, beta1=0.5).minimize(d_cost_tf, var_list=discrim_vars)
train_op_gen = tf.train.AdamOptimizer(learning_rate, beta1=0.5).minimize(g_cost_tf, var_list=gen_vars)

Z_tf_sample, Y_tf_sample, image_tf_sample = dcgan_model.samples_generator(batch_size=visualize_dim)

tf.initialize_all_variables().run()

Z_np_sample = np.random.uniform(-1, 1, size=(visualize_dim,dim_z))#從-1到1的均勻分佈中隨機取樣,得到196x100的矩陣
Y_np_sample = OneHot( np.random.randint(10, size=[visualize_dim]))#生成196x10的矩陣,對於每一行,隨機地在某一列置1
iterations = 0
k = 2

for epoch in range(n_epochs):
    index = range(len(trY))#得到訓練資料的下標序列
    np.random.shuffle(index)#置亂下標
    #得到新的訓練資料序列
    trX = trX[index]
    trY = trY[index]
    for start, end in zip(
            range(0, len(trY), batch_size),#生成一個從0開始,至訓練資料數量大小結尾,間隔是128的序列,近似於[0,128,256,...]
            range(batch_size, len(trY), batch_size)#與上一行得到的list相比,少了開始的一個0,[128,256,384,...]
            ):
    #zip生成一個序列對[(0, 128), (128, 256), (256, 384),...],每一對相當於一個batch_size
        Xs = trX[start:end].reshape( [-1, 28, 28, 1]) / 255.#畫素值限制在1以下
        Ys = OneHot(trY[start:end])#生成128x10的矩陣,對於每一行,隨機地在某一列置1
        Zs = np.random.uniform(-1, 1, size=[batch_size, dim_z]).astype(np.float32)#生成128組維數為100的隨機向量

        #先訓練判別網路的引數,再訓練生成網路中的引數,交替進行
        if np.mod( iterations, k ) != 0:
            #喂進去Z、Y,得到生成影象;得到生成影象的判別概率;得到生成網路的目標函式,訓練優化其中的引數
            _, gen_loss_val = sess.run(
                    [train_op_gen, g_cost_tf],
                    feed_dict={
                        Z_tf:Zs,
                        Y_tf:Ys
                        })
            #喂進去Z、X、Y,得到生成影象,得到真實影象;得到生成影象判別概率和真實影象判別概率;得到判別網路的目標函式(未優化)
            discrim_loss_val, p_real_val, p_gen_val = sess.run([d_cost_tf,p_real,p_gen], feed_dict={Z_tf:Zs, image_tf:Xs, Y_tf:Ys})
            print "=========== updating G =========="
            print "iteration:", iterations
            print "gen loss:", gen_loss_val
            print "discrim loss:", discrim_loss_val

        else:
            # 喂進去Z、X、Y,得到生成影象,得到真實影象;得到生成影象判別概率和真實影象判別概率;得到判別網路的目標函式,訓練優化其中的引數
            _, discrim_loss_val = sess.run(
                    [train_op_discrim, d_cost_tf],
                    feed_dict={
                        Z_tf:Zs,
                        Y_tf:Ys,
                        image_tf:Xs
                        })
            #喂進去Z、Y,得到生成影象;得到生成影象的判別概率;得到生成網路的目標函式(未優化)
            gen_loss_val, p_real_val, p_gen_val = sess.run([g_cost_tf, p_real, p_gen], feed_dict={Z_tf:Zs, image_tf:Xs, Y_tf:Ys})
            print "=========== updating D =========="
            print "iteration:", iterations
            print "gen loss:", gen_loss_val
            print "discrim loss:", discrim_loss_val

        print "Average P(real)=", p_real_val.mean()
        print "Average P(gen)=", p_gen_val.mean()

        #每200次epoch生成一張樣例圖。由於samples_generator中的引數和generate中的引數是一樣的,直接餵給其資料,就能享受到訓練了200*n輪後的成果
        if np.mod(iterations, 200) == 0:
            generated_samples = sess.run(
                    image_tf_sample,
                    feed_dict={
                        Z_tf_sample:Z_np_sample,
                        Y_tf_sample:Y_np_sample
                        })
            generated_samples = (generated_samples + 1.)/2.#把畫素值的範圍由在-1到1轉化成0到1
            save_visualization(generated_samples, (14,14), save_path='./vis/sample_'+str(iterations/200)+'.jpg')

        iterations += 1

對於此專案,我還存在一些疑惑,比如說網路結構中Y(標籤)的數量10為什麼總被用於改變網路的結構:

h2 = tf.reshape(h2,[self.batch_size,7,7,self.dim_W2])#shape =(128,7,7,128)

h2 = tf.concat([h2,yb * tf.ones([self.batch_size,7,7,self.dim_y])],3#shape =(128,7,7,138)

在這裡,h2增加了10個通道。它的作用是什麼呢?

相關推薦

DCGAN生成手寫體數字影象程式碼解析

util.py檔案把專案中用到的工具函式整理到一起,包括onehot,影象剪裁,影象拼接 # !/usr/bin/python # -*- coding: utf-8 -*- import cv2 import scipy.misc import ip

基於MNIST資料集通過樸素貝葉斯學習生成隨機手寫體數字影象

        好久沒寫部落格了,話不多說,進入主題。 1、貝葉斯方法 2、訓練資料集 3、具體實現過程         3.1 匯入資料集         上面提到的資料由於編碼問題,需要自己寫匯入方法,如果你也是用python的話,有現成的模板可以使用。推薦一個Gi

(二) svm 識別手寫體數字圖片

一、解決問題 手寫體數字識別 二、程式碼分析 1、載入資料 from sklearn.datasets import load_digits digits = load_digits() d

javaaxis2生成webservice客戶端程式碼及使用方法

這兩天javaweb專案需要呼叫c#釋出的webService介面。自己琢磨了半天,到網上趙各種資料,有java自帶的wsimport方法,還有用axis2的jar包去生成。在實現中也遇到了一些問題,

12.【基礎】手寫體數字影象聚類--KMeans

本文所有實現程式碼均來自《Python機器學習及實戰》 #-*- coding:utf-8 -*- #分別匯入numpy、matplotlib、pandas,用於數學運算、作圖以及資料分析 import numpy as np import matplo

Android Java程式碼編寫一款動態生成幸運數字的小遊戲

  截圖: 程式碼如下:   第三方依賴庫地址:https://github.com/AndroidMsky/RandomTextView 第一步:新增倉庫 allprojects { repositories { ... maven {

生成對抗網路GAN---生成mnist手寫數字影象示例(附程式碼

Ian J. Goodfellow等人於2014年在論文Generative Adversarial Nets中提出了一個通過對抗過程估計生成模型的新框架。框架中同時訓練兩個模型:一個生成模型(generative model)G,用來捕獲資料分佈;一個判別模型(discri

zxing生成解析二維碼

ont 跳轉 char log trac -s ioe hints pan package test; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOExceptio

程式設計師軟體生成前端程式碼,前端妹子看完直接傻眼!卻遭領導批評

作為程式設計師經常會有一些口頭禪,比如說“程式碼複用思想”,“寫高質量的程式碼”,“程式碼在精不在多”,“思路比努力更重要”,這些話中大多強調的是策略的重要性,在工作中,勤奮固然重要,如果能在勤奮的基礎上強調一下方法與策略,那便會使工作起到事半功倍的效果,最近有一個程式設計師網友異於其他程式設計師,

[深度學習]半監督學習、無監督學習之DCGAN深度卷積生成對抗網路(附程式碼)

論文全稱:《Generative Adversarial Nets》 論文地址:https://arxiv.org/pdf/1406.2661.pdf 論文全稱:《UNSUPERVISED REPRESENTATION LEARNING WITH DEEP CONVOLUTIONAL GEN

數字影象處理——Java對影象做映象變換

水平映象變換,也就是把影象的畫素點按照垂直中線做調換。 程式碼實現也很簡單: import javax.imageio.ImageIO; import java.awt.image.Buffer

NVIDIA新作解讀:GAN生成前所未有的高清影象(附PyTorch復現) | PaperDaily #15

在碎片化閱讀充斥眼球的時代,越來越少的人會去關注每篇論文背後的探索和思考。 在這個欄目裡,你會快速 get 每篇精選論文的亮點和痛點,時刻緊跟 AI 前沿成果。 點選本文底部的「閱讀

數字影象處理MATLAB實現(第2版)岡薩雷斯 書中程式碼-2.1 intrans函式

持續更新。。。 function g = intrans(f, method,varargin) %INTRANS Performs intensity (gray-level) transformations. % G = INTRANS(F, 'n

數字影象處理之(三)】影象增強談灰度變換

調整索引色影象的調色盤map。如果low_in, high_in, low_out, high_out 和 gamma 都是標量,那麼對 r,g,b 分量同時都做此對映。對於每個顏色分量都有唯一的對映,當 low_in 和 high_in 同時為1*3向量或者 low_out 和 high_out 同時為1

數字影象處理Matlab程式碼【1基本原理】

今天開始學習岡薩雷斯的《數字影象處理》。本文主要記錄書中的例題,以便今後學習參考。-----------------------------------------------------------20180619------------------------------

wsdl介面,cmd生成客戶端程式碼

wsimport -s D:\cos\pa -p com.sf.customer.service.core.web.ws.client.cos.paramTypeService -keep http://127.0.0.1:8080/cos_webservice/servi

數字影象處理原理與實踐(MATLAB版)》一書之程式碼Part3

本文系《數字影象處理原理與實踐(MATLAB版)》一書之程式碼系列的Part3,輯錄該書第135至第184頁之程式碼,供有需要讀者下載研究使用。程式碼執行結果請參見原書配圖。-------------------------------------------P139orig

求旋轉陣列的最小數字演算法的解析以及完整c語言程式碼實現

          首先了解什麼是旋轉陣列:即把一個數組的最開始的若干個元素搬到陣列的末尾,即成為旋轉陣列,例如陣列{3,7,1,8,2}為{1,8,2,3,7}的一個旋轉陣列。         題目:輸入一個遞增排序的陣列的一個旋轉,輸出旋轉陣列的最小元素,例如{1,2,

c# 圖形驗證碼生成 程式碼解析

之前做登入時,傳送簡訊驗證碼需要做安全控制,使用到了圖形驗證碼 使用的思路是: 1、建立一個驗證碼圖片生成器頁面 2、生成字母或數字組成的隨機字串 3、在Cookie中儲存隨機驗證碼 4、根據生成的隨機驗證碼,生成驗證碼圖片 5、前端呼叫該頁面,填寫

數字影象處理原理與實踐(MATLAB版)》一書之程式碼Part1

本文系《數字影象處理原理與實踐(MATLAB版)》一書之程式碼系列的Part1(P1~42),程式碼執行結果請參見原書配圖。P20I = imread('lena.jpg');BW1 = im2bw(I