first commit

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/.name

@@ -0,0 +1 @@
+图像风格迁移.py

.idea/encodings.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding">
+    <file url="file://$PROJECT_DIR$/output/time.txt" charset="GBK" />
+  </component>
+</project>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.8" project-jdk-type="Python SDK" />
+  <component name="PythonCompatibilityInspectionAdvertiser">
+    <option name="version" value="3" />
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/数字图像处理.iml" filepath="$PROJECT_DIR$/.idea/数字图像处理.iml" />
+    </modules>
+  </component>
+</project>

.idea/数字图像处理.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

BGR2GRAY.py

@@ -0,0 +1,18 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def bgr2gray(img_path):
+    img = cv2.imread(img_path, 1)  # 读取图片
+    gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    cv2.imwrite('./output/Gray.jpg', gray_image)
+
+
+'''
+输入：彩色图片的地址
+输出：灰度图片
+'''
+if __name__ == '__main__':
+    bgr2gray(sys.argv[1])

Binarization.py

@@ -0,0 +1,23 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def binarization(img_path, T):
+    img = cv2.imread(img_path, 0)  # 读取图片
+    for i in range(0, img.shape[0]):
+        for j in range(0, img.shape[1]):
+            if img[i][j] >= T:  # 阈值，可自定义
+                img[i][j] = 255
+            else:
+                img[i][j] = 0
+    cv2.imwrite('./output/binarization.jpg', img)
+
+
+'''
+输入:img_path,阈值
+输出：二值化图片
+'''
+if __name__ == '__main__':
+    binarization(sys.argv[1], eval(sys.argv[2]))

Canny.py

@@ -0,0 +1,22 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def Canny(img_path, low, high):
+    img = cv2.imread(img_path, 0)  # 读取图片
+    gradx = cv2.Sobel(img, cv2.CV_16SC1, 1, 0)
+    grady = cv2.Sobel(img, cv2.CV_16SC1, 0, 1)
+
+    # 使用Canny函数处理图像，x,y分别是3求出来的梯度，低阈值50，高阈值150
+    edge_output = cv2.Canny(gradx, grady, low, high)
+    cv2.imwrite('./output/Canny.jpg', edge_output)
+
+
+'''
+输入：一张灰度图 ，低阈值，高阈值
+输出：Canny边缘检测的结果
+'''
+if __name__ == '__main__':
+    Canny(sys.argv[1], eval(sys.argv[2]), eval(sys.argv[3]))

Fourier_transform.py

@@ -0,0 +1,24 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def fourier_transform(img_path):
+    img = cv2.imread(img_path, 0)
+    dft = cv2.dft(np.float32(img), flags=cv2.DFT_COMPLEX_OUTPUT)
+    dftShift = np.fft.fftshift(dft)
+    result = 20 * np.log(cv2.magnitude(dftShift[:, :, 0], dftShift[:, :, 1]))
+
+    plt.imshow(result, cmap='gray')
+    plt.title('fft result')
+    plt.axis('off')
+    plt.savefig("./output/fourier_transform.jpg")
+
+
+'''
+输入：一张图片
+输出：傅里叶变换的结果
+'''
+if __name__ == '__main__':
+    fourier_transform(sys.argv[1])

Highpass_filtering.py

@@ -0,0 +1,100 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def Highpass_filtering(img_path, type, D0):
+    print(D0)
+    plt.rcParams['font.sans-serif'] = ['SimHei']
+    plt.rcParams['axes.unicode_minus'] = False
+    img = cv2.imread(img_path)  # 读取图片
+    b = img[:, :, 0]
+    g = img[:, :, 1]
+    r = img[:, :, 2]
+    pltmod = cv2.merge([r, g, b])  # plt的顺序与cv2不同，显示正确结果需要重新组织顺序
+    # 图片的中心（x,y)
+    m, n = b.shape[0], b.shape[1]
+    x = np.floor(m / 2)
+    y = np.floor(n / 2)
+
+    h = np.zeros((m, n))  # 理想高通滤波器
+    if type == 1:
+        for i in range(m):
+            for j in range(n):
+                D = np.sqrt((i - x) ** 2 + (j - y) ** 2)
+                if D >= D0:
+                    h[i, j] = 1
+                else:
+                    h[i, j] = 0
+
+    elif type == 2:
+        n0 = 2  # 参数
+        for i in range(m):
+            for j in range(n):
+                D = np.sqrt((i - x) ** 2 + (j - y) ** 2)
+                if D == 0:
+                    h[i, j] = 0
+                else:
+                    h[i, j] = 1 / (1 + 0.414 * ((D0 / D) ** (2 * n0)))
+
+
+    elif type == 3:
+        n0 = 2  # 参数
+        for i in range(m):
+            for j in range(n):
+                D = np.sqrt((i - x) ** 2 + (j - y) ** 2)
+                if D == 0:
+                    h[i, j] = 0
+                else:
+                    h[i, j] = np.exp(-0.347 * ((D0 / D) ** n0))
+
+    fb = np.fft.fft2(b)
+    fbshift = np.fft.fftshift(fb)
+    fg = np.fft.fft2(g)
+    fgshift = np.fft.fftshift(fg)
+    fr = np.fft.fft2(r)
+    frshift = np.fft.fftshift(fr)
+
+    fbshift = fbshift * h
+    fgshift = fgshift * h
+    frshift = frshift * h
+
+    ibshift = np.fft.ifftshift(fbshift)
+    ibresult = np.fft.ifft2(ibshift)
+    ibresult = np.uint8(np.abs(ibresult))
+    igshift = np.fft.ifftshift(fgshift)
+    igresult = np.fft.ifft2(igshift)
+    igresult = np.uint8(np.abs(igresult))
+    irshift = np.fft.ifftshift(frshift)
+    irresult = np.fft.ifft2(irshift)
+    irresult = np.uint8(np.abs(irresult))
+
+    result1 = cv2.merge([irresult, igresult, ibresult])
+
+    if type == 1:
+        plt.imshow(result1)
+        plt.title('理想高通滤波')
+        plt.axis('off')
+        plt.savefig('./output/理想高通滤波.jpg')
+    elif type == 2:
+        plt.imshow(result1)
+        plt.title('巴特沃斯高通滤波')
+        plt.axis('off')
+        plt.savefig('./output/巴特沃斯高通滤波.jpg')
+
+    elif type == 3:
+        plt.imshow(result1)
+        plt.title('指数高通滤波')
+        plt.axis('off')
+        plt.savefig('./output/指数高通滤波.jpg')
+
+
+'''
+输入：img_path:图片地址
+     type：滤波器类型（1:理想高通滤波、2:巴特沃斯高通滤波、3：指数高通滤波）
+     D0：阈值
+输出：高通滤波的结果
+'''
+if __name__ == '__main__':
+    Highpass_filtering(sys.argv[1], eval(sys.argv[2]), eval(sys.argv[3]))

HistGraph.py

@@ -0,0 +1,24 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def HistGraph(img_path):
+    img = cv2.imread(img_path, 1)
+    color = ["r", "g", "b"]  # 每个通道线的颜色
+    # 因为用到cv2函数读取，但是用matplotlib库函数处理，所以应该转BGR格式为RGB格式
+    img = img[:, :, ::-1]
+    for index, c in enumerate(color):
+        hist = cv2.calcHist([img], [index], None, [256], [0, 255])
+        plt.plot(hist, color=c)
+        plt.xlim([0, 255])
+    plt.savefig("./output/HistGraph.jpg")
+
+
+'''
+输入：一张图片
+输出：rgb三通道的灰度直方图
+'''
+if __name__ == '__main__':
+    HistGraph(sys.argv[1])

HoughLines.py

@@ -0,0 +1,22 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def Houghlines(img_path, threshold, minLineLength, maxLineGap):
+    img = cv2.imread(img_path, 1)  # 读取图片
+    gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    linesP = cv2.HoughLinesP(gray_image, 1, np.pi / 180, threshold, None, minLineLength, maxLineGap)
+    for i_P in linesP:
+        for x1, y1, x2, y2 in i_P:
+            cv2.line(img, (x1, y1), (x2, y2), (0, 0, 255), 1)
+    cv2.imwrite('./output/HoughLinesP.jpg', img)
+
+
+'''
+输入：一张任意某个边缘提取的结果图片，threshold， minLineLength, maxLineGap
+输出：边缘连接的结果的结果
+'''
+if __name__ == '__main__':
+    Houghlines(sys.argv[1], eval(sys.argv[2]), eval(sys.argv[3]), eval(sys.argv[4]))

Laplacian.py

@@ -0,0 +1,21 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def laplacian(img_path, ksize):
+    img = cv2.imread(img_path, 0)  # 读取图片
+    dst = cv2.Laplacian(img, cv2.CV_16S, ksize)
+
+    # 数据格式转换
+    Laplacian = cv2.convertScaleAbs(dst)
+
+    cv2.imwrite('./output/Laplacian.jpg', Laplacian)
+
+'''
+输入：一张灰度图 ,滤波器大小ksize
+输出：Laplacian边缘检测的结果
+'''
+if __name__ == '__main__':
+    laplacian(sys.argv[1], eval(sys.argv[2]))

Mirror_flip.py

@@ -0,0 +1,20 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def mirror_flip(img_path, type):
+    img = cv2.imread(img_path, 1)
+    result = cv2.flip(img, type)
+    cv2.imwrite('./output/mirror_flip.jpg', result)
+
+
+'''
+输入：图片地址，镜像类型(1,0,-1)
+输出：type=1 水平镜像
+     type=0 垂直镜像
+     type=-1 对角镜像
+'''
+if __name__ == '__main__':
+    mirror_flip(sys.argv[1], eval(sys.argv[2]))

OTSUthreshold.py

@@ -0,0 +1,21 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def OTSUthreshold(img_path, thresh, maxval):
+    img = cv2.imread(img_path, 0)
+    ret, threshans = cv2.threshold(img, thresh, maxval, type=cv2.THRESH_OTSU)
+    plt.imshow(threshans, cmap='gray')
+    plt.title('OTSUthreshold')
+    plt.axis('off')
+    plt.savefig("./output/OTSUthreshold.jpg")
+
+
+'''
+输入：一张灰度图片(传进彩色图片会被转为灰度图），门限值,结果图片像素的最大值
+输出：OTSU灰度级门限化的结果
+'''
+if __name__ == '__main__':
+    OTSUthreshold(sys.argv[1], eval(sys.argv[2]), eval(sys.argv[3]))

Prewitt.py

@@ -0,0 +1,30 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def Prewitt(img_path):
+    img = cv2.imread(img_path, 0)  # 读取图片
+    # 边缘检测----Prewitt算子
+    kernelx = np.array([[1, 1, 1], [0, 0, 0], [-1, -1, -1]], dtype=int)
+    kernely = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]], dtype=int)
+
+    x = cv2.filter2D(img, cv2.CV_16S, kernelx)
+    y = cv2.filter2D(img, cv2.CV_16S, kernely)
+
+    # 转uint8
+    absX = cv2.convertScaleAbs(x)
+    absY = cv2.convertScaleAbs(y)
+
+    # 加权
+    Prewitt = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
+
+
+    cv2.imwrite('./output/Prewitt.jpg', Prewitt)
+'''
+输入：一张灰度图 
+输出：Prewitt边缘检测的结果
+'''
+if __name__ == '__main__':
+    Prewitt(sys.argv[1])

Roberts.py

@@ -0,0 +1,30 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def Roberts(img_path):
+    img = cv2.imread(img_path, 0)  # 读取图片
+    kernelx = np.array([[-1, 0], [0, 1]], dtype=int)
+    kernely = np.array([[0, -1], [1, 0]], dtype=int)
+
+    # filter后会有负值，还有会大于255的值。而原图像是uint8，会有截断。因此要使用16位有符号的数据类型，即cv2.CV_16S。
+    x = cv2.filter2D(img, cv2.CV_16S, kernelx)
+    y = cv2.filter2D(img, cv2.CV_16S, kernely)
+
+    # 用convertScaleAbs()函数将其转回原来的uint8形式。否则将无法显示图像，而只是一副灰色的窗口
+    absX = cv2.convertScaleAbs(x)
+    absY = cv2.convertScaleAbs(y)
+
+    # 用cv2.addWeighted(...)函数将其组合起来，其中，alpha是第一幅图片中元素的权重，beta是第二个的权重，gamma是加到最后结果上的一个值。
+    Roberts = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
+    cv2.imwrite('./output/Roberts.jpg', Roberts)
+
+
+'''
+输入：一张灰度图  
+输出：Roberts边缘检测的结果
+'''
+if __name__ == '__main__':
+    Roberts(sys.argv[1])

Sobel.py

@@ -0,0 +1,32 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def Sobel(img_path):
+    img = cv2.imread(img_path, 0)  # 读取图片
+    # 边缘检测----Prewitt算子
+    # 边缘检测----Sobel算子
+    # cv2.Sobel(src, ddepth, dx, dy, dst, ksize, scale, delta,borderType)
+    # dx和dy表示的是求导的阶数，0表示这个方向上没有求导
+
+    x = cv2.Sobel(img, cv2.CV_16S, 1, 0)
+    y = cv2.Sobel(img, cv2.CV_16S, 0, 1)
+
+    # 转uint8
+    absX = cv2.convertScaleAbs(x)
+    absY = cv2.convertScaleAbs(y)
+
+    # 加权
+    Sobel = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
+
+    cv2.imwrite('./output/Sobel.jpg', Sobel)
+
+
+'''
+输入：一张灰度图 
+输出：Sobel边缘检测的结果
+'''
+if __name__ == '__main__':
+   Sobel(sys.argv[1])

Split_and_merge.py

@@ -0,0 +1,55 @@
+import sys
+
+import numpy as np
+import cv2
+import matplotlib.pyplot as plt
+
+
+def judge(w0, h0, w, h):
+    a = img[h0: h0 + h, w0: w0 + w]
+    ave = np.mean(a)
+    std = np.std(a, ddof=1)
+    count = 0
+    total = 0
+    for i in range(w0, w0 + w):
+        for j in range(h0, h0 + h):
+            if abs(img[j, i] - ave) < 1 * std:
+                count += 1
+            total += 1
+    if (count / total) < 0.95:
+        return True
+    else:
+        return False
+
+
+def Merge(w0, h0, w, h):
+    for i in range(w0, w0 + w):
+        for j in range(h0, h0 + h):
+            if img[j, i] > 125:
+                img[j, i] = 255
+            else:
+                img[j, i] = 0
+
+
+def function(w0, h0, w, h):
+    if judge(w0, h0, w, h) and (min(w, h) > 5):
+        function(w0, h0, int(w / 2), int(h / 2))
+        function(w0 + int(w / 2), h0, int(w / 2), int(h / 2))
+        function(w0, h0 + int(h / 2), int(w / 2), int(h / 2))
+        function(w0 + int(w / 2), h0 + int(h / 2), int(w / 2), int(h / 2))
+    else:
+        draw(w0, h0, w, h)
+
+
+if __name__ == "__main__":
+    img = cv2.imread(sys.argv[1], 0)
+    img_input = cv2.imread(sys.argv[1], 0)#备份
+
+    height, width = img.shape
+
+    function(0, 0, width, height)
+
+    cv2.imwrite("./output/split_and_merge.jpg",img)
+
+
+

Three-channel.py

@@ -0,0 +1,22 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def three_channel(img_path):
+    img = cv2.imread(img_path, 1)  # 读取图片
+    b = img[:, :, 0]
+    g = img[:, :, 1]
+    r = img[:, :, 2]
+    cv2.imwrite('./output/b.jpg', b)
+    cv2.imwrite('./output/g.jpg', g)
+    cv2.imwrite('./output/r.jpg', r)
+
+
+'''
+输入:img_path
+输出：b,g,r三通道共三张图片
+'''
+if __name__ == '__main__':
+    three_channel(sys.argv[1])

add.py

@@ -0,0 +1,19 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def add(img1_path, img2_path):
+    img1 = cv2.imread(img1_path, 1)
+    img2 = cv2.imread(img2_path, 1)
+    result = cv2.add(img1, img2)
+    cv2.imwrite('./output/add.jpg', result)
+
+
+'''
+输入：两张图片（大小相同） 
+输出：求和之后的结果
+'''
+if __name__ == '__main__':
+    add(sys.argv[1], sys.argv[2])

circle.py

@@ -0,0 +1,18 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def circle(img_path, center, radius, color, thickness):
+    img = cv2.imread(img_path, 1)  # 读取图片
+    cv2.circle(img, center, radius, color, thickness)
+    cv2.imwrite('./output/circle.jpg', img)
+
+
+'''
+输入:img_path, center, radius, color, thickness
+输出：在传入的img上添加一个圆形
+'''
+if __name__ == '__main__':
+    circle(sys.argv[1], eval(sys.argv[2]), eval(sys.argv[3]), eval(sys.argv[4]), eval(sys.argv[5]))

divide.py

@@ -0,0 +1,19 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def divide(img1_path, img2_path):
+    img1 = cv2.imread(img1_path, 1)
+    img2 = cv2.imread(img2_path, 1)
+    result = cv2.divide(img1, img2)
+    cv2.imwrite('./output/divide.jpg', result)
+
+
+'''
+输入：两张图片（大小相同） 
+输出：相除之后的结果
+'''
+if __name__ == '__main__':
+    divide(sys.argv[1], sys.argv[2])

ellipse.py

@@ -0,0 +1,18 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def ellipse(img_path, centerCoordinates, axesLength, angle, startAngle, endAngle, color, thickness):
+    img = cv2.imread(img_path, 1)  # 读取图片
+    cv2.ellipse(img, centerCoordinates, axesLength, angle, startAngle, endAngle, color, thickness)
+    cv2.imwrite('./output/ellipse.jpg', img)
+
+
+'''
+输入:img_path, centerCoordinates, axesLength, angle, startAngle, endAngle, color, thickness
+输出：在传入的img上添加一个椭圆
+'''
+if __name__ == '__main__':
+    ellipse(sys.argv[1], eval(sys.argv[2]), eval(sys.argv[3]), eval(sys.argv[4]), eval(sys.argv[5]), eval(sys.argv[6]), eval(sys.argv[7]), eval(sys.argv[8]))

equalizeHist.py

@@ -0,0 +1,21 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def equalizeHist(img_path):
+    img = cv2.imread(img_path, 1)
+    r = cv2.equalizeHist(img[:, :, 0])
+    g = cv2.equalizeHist(img[:, :, 1])
+    b = cv2.equalizeHist(img[:, :, 2])
+    res = cv2.merge([r, g, b])
+    cv2.imwrite('./output/equalizeHist.jpg', res)
+
+
+'''
+输入：一张图片
+输出：直方图均衡化的结果
+'''
+if __name__ == '__main__':
+    equalizeHist(sys.argv[1])

exp_grayscale_transformation.py

@@ -0,0 +1,33 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def exp_grayscale_transformation(img, a, b, c):
+    ans = np.zeros((img.shape[0], img.shape[1]))
+    for i in range(img.shape[0]):
+        for j in range(img.shape[1]):
+            ans[i][j] = np.power(b, c * (img[i][j] / 255 - a)) - 1
+    return ans
+
+
+def exp_grayscale_transformation_threeChannel(img_path, a, b, c):
+    img = cv2.imread(img_path, 1)
+    img = np.array(img, dtype=np.float64)
+    # 三个通道分别变换
+    r = exp_grayscale_transformation(img[:, :, 0], a, b, c)
+    g = exp_grayscale_transformation(img[:, :, 1], a, b, c)
+    b = exp_grayscale_transformation(img[:, :, 2], a, b, c)
+    # 三通道合并
+    res = cv2.merge([r, g, b])
+    res = res*255
+    cv2.imwrite('./output/exp_grayscale_transformation.jpg', res)
+
+
+'''
+输入：一张图片，参数a,b,c
+输出：对数灰度变换的结果
+'''
+if __name__ == '__main__':
+    exp_grayscale_transformation_threeChannel(sys.argv[1], eval(sys.argv[2]), eval(sys.argv[3]), eval(sys.argv[4]))

line.py

@@ -0,0 +1,18 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def line(img_path, pt1, pt2, color, thickness):
+    img = cv2.imread(img_path, 1)  # 读取图片
+    cv2.line(img, pt1, pt2, color, thickness)
+    cv2.imwrite('./output/line.jpg', img)
+
+
+'''
+输入:img_path,pt1,pt2,color,thickness
+输出：在传入的img上添加一根直线
+'''
+if __name__ == '__main__':
+    line(sys.argv[1], eval(sys.argv[2]), eval(sys.argv[3]), eval(sys.argv[4]), eval(sys.argv[5]))

linear_grayscale_transformation.py

@@ -0,0 +1,39 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def linear_grayscale_transformation(img, a, b, c, d):
+    ans = np.zeros((img.shape[0], img.shape[1]))
+    for i in range(img.shape[0]):
+        for j in range(img.shape[1]):
+            if img[i][j] > b:
+                ans[i][j] = d
+            elif a <= img[i][j] <= b:
+                ans[i][j] = (d - c) / (b - a) * (img[i][j] - a) + c
+            else:
+                ans[i][j] = c
+    return ans / 255
+
+
+def linear_grayscale_transformation_threeChannel(img_path, a, b, c, d):
+    img = cv2.imread(img_path, 1)
+    img = np.array(img, dtype=np.float64)
+    # 三个通道分别变换
+    r = linear_grayscale_transformation(img[:, :, 0], a, b, c, d)
+    g = linear_grayscale_transformation(img[:, :, 1], a, b, c, d)
+    b = linear_grayscale_transformation(img[:, :, 2], a, b, c, d)
+    # 三通道合并
+    res = cv2.merge([r, g, b])
+    res = res*255
+    cv2.imwrite('./output/linear_grayscale_transformation.jpg', res)
+
+
+'''
+输入：一张图片，参数a,b,c,d
+输出：线性灰度变换的结果
+'''
+if __name__ == '__main__':
+    linear_grayscale_transformation_threeChannel(sys.argv[1], eval(sys.argv[2]), eval(sys.argv[3]), eval(sys.argv[4]),
+                                                 eval(sys.argv[5]))

log_grayscale_transformation.py

@@ -0,0 +1,33 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def log_grayscale_transformation(img, a, b, c):
+    ans = np.zeros((img.shape[0], img.shape[1]))
+    for i in range(img.shape[0]):
+        for j in range(img.shape[1]):
+            ans[i][j] = a + np.log(img[i][j] + 1) / (b * np.log(c))
+    return ans
+
+
+def log_grayscale_transformation_threeChannel(img_path, a, b, c):
+    img = cv2.imread(img_path, 1)
+    img = np.array(img, dtype=np.float64)
+    # 三个通道分别变换
+    r = log_grayscale_transformation(img[:, :, 0], a, b, c)
+    g = log_grayscale_transformation(img[:, :, 1], a, b, c)
+    b = log_grayscale_transformation(img[:, :, 2], a, b, c)
+    # 三通道合并
+    res = cv2.merge([r, g, b])
+    res = res*255
+    cv2.imwrite('./output/log_grayscale_transformation.jpg', res)
+
+
+'''
+输入：一张图片，参数a,b,c
+输出：对数灰度变换的结果
+'''
+if __name__ == '__main__':
+    log_grayscale_transformation_threeChannel(sys.argv[1], eval(sys.argv[2]), eval(sys.argv[3]), eval(sys.argv[4]))

multiply.py

@@ -0,0 +1,19 @@
+import sys
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def multiply(img1_path, img2_path):
+    img1 = cv2.imread(img1_path, 1)
+    img2 = cv2.imread(img2_path, 1)
+    result = cv2.multiply(img1, img2)
+    cv2.imwrite('./output/multiply.jpg', result)
+
+
+'''
+输入：两张图片（大小相同） 
+输出：相乘之后的结果
+'''
+if __name__ == '__main__':
+    multiply(sys.argv[1], sys.argv[2])

output/time.txt

@@ -0,0 +1 @@
+识别出来的时间为: 11:20:40