From ce2420b6409d3a7e8353871ccd385d4081060428 Mon Sep 17 00:00:00 2001
From: XIE <2598330413@qq.com>
Date: Fri, 29 Jul 2022 20:30:38 +0800
Subject: [PATCH] first commit
---
.idea/.gitignore | 8 +
.idea/.name | 1 +
.idea/inspectionProfiles/Project_Default.xml | 35 ++
.../inspectionProfiles/profiles_settings.xml | 6 +
.idea/misc.xml | 4 +
.idea/modules.xml | 8 +
.idea/数字图像处理.iml | 10 +
DIP.py | 300 +++++++++++++
DIP.ui | 412 ++++++++++++++++++
EdgeDetection.py | 78 ++++
FrequencySmoothing.py | 66 +++
GeometricalChange.py | 47 ++
Histogram.py | 74 ++++
Hough.py | 41 ++
LogicalAlgorithm.py | 61 +++
NoiseCanceller.py | 78 ++++
SpatialSmoothing.py | 18 +
__pycache__/DIP.cpython-36.pyc | Bin 0 -> 8839 bytes
__pycache__/EdgeDetection.cpython-36.pyc | Bin 0 -> 3296 bytes
__pycache__/FrequencySmoothing.cpython-36.pyc | Bin 0 -> 2698 bytes
__pycache__/GeometricalChange.cpython-36.pyc | Bin 0 -> 2300 bytes
__pycache__/Histogram.cpython-36.pyc | Bin 0 -> 2509 bytes
__pycache__/Hough.cpython-36.pyc | Bin 0 -> 1863 bytes
__pycache__/LogicalAlgorithm.cpython-36.pyc | Bin 0 -> 2841 bytes
__pycache__/NoiseCanceller.cpython-36.pyc | Bin 0 -> 2703 bytes
__pycache__/SpatialSmoothing.cpython-36.pyc | Bin 0 -> 926 bytes
__pycache__/morphology.cpython-36.pyc | Bin 0 -> 1622 bytes
driver.py | 324 ++++++++++++++
morphology.py | 34 ++
test Img/123.png | Bin 0 -> 318499 bytes
test Img/20220712152435.jpg | Bin 0 -> 10415775 bytes
test Img/a.png | Bin 0 -> 1520326 bytes
test Img/edu.png | Bin 0 -> 85034 bytes
test Img/ex_1.jpg | Bin 0 -> 66131 bytes
test Img/image (1).bmp | Bin 0 -> 366 bytes
test Img/image (2).bmp | Bin 0 -> 672852 bytes
test Img/image (3).bmp | Bin 0 -> 1432540 bytes
test Img/image (4).bmp | Bin 0 -> 2051 bytes
test Img/image (5).bmp | Bin 0 -> 2362 bytes
test Img/image (6).png | Bin 0 -> 73023 bytes
test Img/image (7).png | Bin 0 -> 403702 bytes
test Img/image.bmp | Bin 0 -> 476 bytes
test Img/test.png | Bin 0 -> 684062 bytes
test Img/zao.png | Bin 0 -> 85585 bytes
test Img/zero.bmp | Bin 0 -> 66614 bytes
test Img/zero1.bmp | Bin 0 -> 66614 bytes
信号.txt | 39 ++
数字图像处理大类.txt | 46 ++
48 files changed, 1690 insertions(+)
create mode 100644 .idea/.gitignore
create mode 100644 .idea/.name
create mode 100644 .idea/inspectionProfiles/Project_Default.xml
create mode 100644 .idea/inspectionProfiles/profiles_settings.xml
create mode 100644 .idea/misc.xml
create mode 100644 .idea/modules.xml
create mode 100644 .idea/数字图像处理.iml
create mode 100644 DIP.py
create mode 100644 DIP.ui
create mode 100644 EdgeDetection.py
create mode 100644 FrequencySmoothing.py
create mode 100644 GeometricalChange.py
create mode 100644 Histogram.py
create mode 100644 Hough.py
create mode 100644 LogicalAlgorithm.py
create mode 100644 NoiseCanceller.py
create mode 100644 SpatialSmoothing.py
create mode 100644 __pycache__/DIP.cpython-36.pyc
create mode 100644 __pycache__/EdgeDetection.cpython-36.pyc
create mode 100644 __pycache__/FrequencySmoothing.cpython-36.pyc
create mode 100644 __pycache__/GeometricalChange.cpython-36.pyc
create mode 100644 __pycache__/Histogram.cpython-36.pyc
create mode 100644 __pycache__/Hough.cpython-36.pyc
create mode 100644 __pycache__/LogicalAlgorithm.cpython-36.pyc
create mode 100644 __pycache__/NoiseCanceller.cpython-36.pyc
create mode 100644 __pycache__/SpatialSmoothing.cpython-36.pyc
create mode 100644 __pycache__/morphology.cpython-36.pyc
create mode 100644 driver.py
create mode 100644 morphology.py
create mode 100644 test Img/123.png
create mode 100644 test Img/20220712152435.jpg
create mode 100644 test Img/a.png
create mode 100644 test Img/edu.png
create mode 100644 test Img/ex_1.jpg
create mode 100644 test Img/image (1).bmp
create mode 100644 test Img/image (2).bmp
create mode 100644 test Img/image (3).bmp
create mode 100644 test Img/image (4).bmp
create mode 100644 test Img/image (5).bmp
create mode 100644 test Img/image (6).png
create mode 100644 test Img/image (7).png
create mode 100644 test Img/image.bmp
create mode 100644 test Img/test.png
create mode 100644 test Img/zao.png
create mode 100644 test Img/zero.bmp
create mode 100644 test Img/zero1.bmp
create mode 100644 信号.txt
create mode 100644 数字图像处理大类.txt
diff --git a/.idea/.gitignore b/.idea/.gitignore
new file mode 100644
index 0000000..13566b8
--- /dev/null
+++ b/.idea/.gitignore
@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
diff --git a/.idea/.name b/.idea/.name
new file mode 100644
index 0000000..001cba9
--- /dev/null
+++ b/.idea/.name
@@ -0,0 +1 @@
+driver.py
\ No newline at end of file
diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
new file mode 100644
index 0000000..d0a1ee7
--- /dev/null
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -0,0 +1,35 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml
new file mode 100644
index 0000000..105ce2d
--- /dev/null
+++ b/.idea/inspectionProfiles/profiles_settings.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 0000000..2517932
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 0000000..69bb3a4
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/数字图像处理.iml b/.idea/数字图像处理.iml
new file mode 100644
index 0000000..8ad733e
--- /dev/null
+++ b/.idea/数字图像处理.iml
@@ -0,0 +1,10 @@
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/DIP.py b/DIP.py
new file mode 100644
index 0000000..981c0a8
--- /dev/null
+++ b/DIP.py
@@ -0,0 +1,300 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'DIP.ui'
+#
+# Created by: PyQt5 UI code generator 5.15.6
+#
+# WARNING: Any manual changes made to this file will be lost when pyuic5 is
+# run again. Do not edit this file unless you know what you are doing.
+
+
+from PyQt5 import QtCore, QtGui, QtWidgets
+
+
+class Ui_DigitalImageProcessing(object):
+ def setupUi(self, DigitalImageProcessing):
+ DigitalImageProcessing.setObjectName("DigitalImageProcessing")
+ DigitalImageProcessing.resize(975, 614)
+ self.centralwidget = QtWidgets.QWidget(DigitalImageProcessing)
+ self.centralwidget.setObjectName("centralwidget")
+ self.groupBox = QtWidgets.QGroupBox(self.centralwidget)
+ self.groupBox.setGeometry(QtCore.QRect(30, 40, 421, 321))
+ font = QtGui.QFont()
+ font.setFamily("Agency FB")
+ font.setPointSize(14)
+ self.groupBox.setFont(font)
+ self.groupBox.setObjectName("groupBox")
+ self.original_img = QtWidgets.QLabel(self.groupBox)
+ self.original_img.setGeometry(QtCore.QRect(40, 30, 351, 261))
+ self.original_img.setStyleSheet("background : rgb(0, 170, 255)")
+ self.original_img.setText("")
+ self.original_img.setObjectName("original_img")
+ self.groupBox_2 = QtWidgets.QGroupBox(self.centralwidget)
+ self.groupBox_2.setGeometry(QtCore.QRect(520, 40, 411, 321))
+ font = QtGui.QFont()
+ font.setFamily("Agency FB")
+ font.setPointSize(14)
+ self.groupBox_2.setFont(font)
+ self.groupBox_2.setObjectName("groupBox_2")
+ self.fixed_img = QtWidgets.QLabel(self.groupBox_2)
+ self.fixed_img.setGeometry(QtCore.QRect(30, 30, 361, 261))
+ self.fixed_img.setStyleSheet("background : rgb(0, 170, 255)")
+ self.fixed_img.setText("")
+ self.fixed_img.setObjectName("fixed_img")
+ self.pushButton = QtWidgets.QPushButton(self.centralwidget)
+ self.pushButton.setGeometry(QtCore.QRect(390, 410, 191, 91))
+ self.pushButton.setObjectName("pushButton")
+ DigitalImageProcessing.setCentralWidget(self.centralwidget)
+ self.menubar = QtWidgets.QMenuBar(DigitalImageProcessing)
+ self.menubar.setGeometry(QtCore.QRect(0, 0, 975, 21))
+ self.menubar.setObjectName("menubar")
+ self.menu = QtWidgets.QMenu(self.menubar)
+ self.menu.setObjectName("menu")
+ self.menu_2 = QtWidgets.QMenu(self.menubar)
+ self.menu_2.setObjectName("menu_2")
+ self.menu_3 = QtWidgets.QMenu(self.menubar)
+ self.menu_3.setObjectName("menu_3")
+ self.menu_Hough = QtWidgets.QMenu(self.menubar)
+ self.menu_Hough.setObjectName("menu_Hough")
+ self.menu_4 = QtWidgets.QMenu(self.menubar)
+ self.menu_4.setObjectName("menu_4")
+ self.menu_5 = QtWidgets.QMenu(self.menubar)
+ self.menu_5.setObjectName("menu_5")
+ self.menu_6 = QtWidgets.QMenu(self.menubar)
+ self.menu_6.setObjectName("menu_6")
+ self.menu_7 = QtWidgets.QMenu(self.menubar)
+ self.menu_7.setObjectName("menu_7")
+ self.menu_8 = QtWidgets.QMenu(self.menubar)
+ self.menu_8.setObjectName("menu_8")
+ DigitalImageProcessing.setMenuBar(self.menubar)
+ self.statusbar = QtWidgets.QStatusBar(DigitalImageProcessing)
+ self.statusbar.setObjectName("statusbar")
+ DigitalImageProcessing.setStatusBar(self.statusbar)
+ self.actionyu = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionyu.setObjectName("actionyu")
+ self.actionhuo = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionhuo.setObjectName("actionhuo")
+ self.actionfei = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionfei.setObjectName("actionfei")
+ self.actionjiafa = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionjiafa.setObjectName("actionjiafa")
+ self.actionjianfa = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionjianfa.setObjectName("actionjianfa")
+ self.actionchengfa = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionchengfa.setObjectName("actionchengfa")
+ self.actionchufa = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionchufa.setObjectName("actionchufa")
+ self.actionkuozhansuofang = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionkuozhansuofang.setObjectName("actionkuozhansuofang")
+ self.actiontuxiangpingyi = QtWidgets.QAction(DigitalImageProcessing)
+ self.actiontuxiangpingyi.setObjectName("actiontuxiangpingyi")
+ self.actiontuxiangxuanzhuan = QtWidgets.QAction(DigitalImageProcessing)
+ self.actiontuxiangxuanzhuan.setObjectName("actiontuxiangxuanzhuan")
+ self.actiontuxiangfanzhuan = QtWidgets.QAction(DigitalImageProcessing)
+ self.actiontuxiangfanzhuan.setObjectName("actiontuxiangfanzhuan")
+ self.actionchuizhifanzhuan = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionchuizhifanzhuan.setObjectName("actionchuizhifanzhuan")
+ self.actionhuiduzhifangtu = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionhuiduzhifangtu.setObjectName("actionhuiduzhifangtu")
+ self.actioncaisezhifangtu = QtWidgets.QAction(DigitalImageProcessing)
+ self.actioncaisezhifangtu.setObjectName("actioncaisezhifangtu")
+ self.actionhuizhizhifangtu = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionhuizhizhifangtu.setObjectName("actionhuizhizhifangtu")
+ self.actionfenduanxianxingbianhuanduizhifangtuxiugai = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionfenduanxianxingbianhuanduizhifangtuxiugai.setObjectName("actionfenduanxianxingbianhuanduizhifangtuxiugai")
+ self.actionbianyuanjiancedejibenyuanli = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionbianyuanjiancedejibenyuanli.setObjectName("actionbianyuanjiancedejibenyuanli")
+ self.actionRoberts = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionRoberts.setObjectName("actionRoberts")
+ self.actionPrewitt_Sobel = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionPrewitt_Sobel.setObjectName("actionPrewitt_Sobel")
+ self.actionLaplacian = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionLaplacian.setObjectName("actionLaplacian")
+ self.actionLoG = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionLoG.setObjectName("actionLoG")
+ self.actionCanny = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionCanny.setObjectName("actionCanny")
+ self.actionxingtaixue = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionxingtaixue.setObjectName("actionxingtaixue")
+ self.actionjiegouyuan = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionjiegouyuan.setText("")
+ self.actionjiegouyuan.setObjectName("actionjiegouyuan")
+ self.actionjiegouyuandefenlei = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionjiegouyuandefenlei.setObjectName("actionjiegouyuandefenlei")
+ self.actionfushi = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionfushi.setObjectName("actionfushi")
+ self.actionpengzhang = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionpengzhang.setObjectName("actionpengzhang")
+ self.actionkaiyunsuan = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionkaiyunsuan.setObjectName("actionkaiyunsuan")
+ self.actionbiyunsuan = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionbiyunsuan.setObjectName("actionbiyunsuan")
+ self.actionzao_sheng_miaoshuqi = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionzao_sheng_miaoshuqi.setObjectName("actionzao_sheng_miaoshuqi")
+ self.actionjunzhileilvboqi = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionjunzhileilvboqi.setObjectName("actionjunzhileilvboqi")
+ self.actionpaixutongjileilvboqi = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionpaixutongjileilvboqi.setObjectName("actionpaixutongjileilvboqi")
+ self.actionxuanzexinglvboqi = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionxuanzexinglvboqi.setObjectName("actionxuanzexinglvboqi")
+ self.actionfangshebianhuan = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionfangshebianhuan.setObjectName("actionfangshebianhuan")
+ self.actionHough = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionHough.setObjectName("actionHough")
+ self.actionHoughP = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionHoughP.setObjectName("actionHoughP")
+ self.actionlingyupingjunfa = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionlingyupingjunfa.setObjectName("actionlingyupingjunfa")
+ self.actionzhongzhilvbo = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionzhongzhilvbo.setObjectName("actionzhongzhilvbo")
+ self.actionlixiang = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionlixiang.setObjectName("actionlixiang")
+ self.actionButterworth = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionButterworth.setObjectName("actionButterworth")
+ self.actionGauss = QtWidgets.QAction(DigitalImageProcessing)
+ self.actionGauss.setObjectName("actionGauss")
+ self.menu.addAction(self.actionyu)
+ self.menu.addAction(self.actionhuo)
+ self.menu.addAction(self.actionfei)
+ self.menu.addAction(self.actionjiafa)
+ self.menu.addAction(self.actionjianfa)
+ self.menu.addAction(self.actionchengfa)
+ self.menu.addAction(self.actionchufa)
+ self.menu_2.addAction(self.actionkuozhansuofang)
+ self.menu_2.addAction(self.actiontuxiangpingyi)
+ self.menu_2.addAction(self.actiontuxiangxuanzhuan)
+ self.menu_2.addAction(self.actiontuxiangfanzhuan)
+ self.menu_2.addAction(self.actionchuizhifanzhuan)
+ self.menu_2.addAction(self.actionfangshebianhuan)
+ self.menu_3.addAction(self.actionhuiduzhifangtu)
+ self.menu_3.addAction(self.actioncaisezhifangtu)
+ self.menu_3.addAction(self.actionhuizhizhifangtu)
+ self.menu_3.addAction(self.actionfenduanxianxingbianhuanduizhifangtuxiugai)
+ self.menu_Hough.addAction(self.actionHough)
+ self.menu_Hough.addAction(self.actionHoughP)
+ self.menu_4.addAction(self.actionbianyuanjiancedejibenyuanli)
+ self.menu_4.addAction(self.actionRoberts)
+ self.menu_4.addAction(self.actionPrewitt_Sobel)
+ self.menu_4.addAction(self.actionLaplacian)
+ self.menu_4.addAction(self.actionLoG)
+ self.menu_4.addAction(self.actionCanny)
+ self.menu_5.addAction(self.actionfushi)
+ self.menu_5.addAction(self.actionpengzhang)
+ self.menu_5.addAction(self.actionkaiyunsuan)
+ self.menu_5.addAction(self.actionbiyunsuan)
+ self.menu_6.addAction(self.actionzao_sheng_miaoshuqi)
+ self.menu_6.addAction(self.actionjunzhileilvboqi)
+ self.menu_6.addAction(self.actionpaixutongjileilvboqi)
+ self.menu_6.addAction(self.actionxuanzexinglvboqi)
+ self.menu_7.addAction(self.actionlingyupingjunfa)
+ self.menu_7.addAction(self.actionzhongzhilvbo)
+ self.menu_8.addAction(self.actionlixiang)
+ self.menu_8.addAction(self.actionButterworth)
+ self.menu_8.addAction(self.actionGauss)
+ self.menubar.addAction(self.menu.menuAction())
+ self.menubar.addAction(self.menu_2.menuAction())
+ self.menubar.addAction(self.menu_3.menuAction())
+ self.menubar.addAction(self.menu_Hough.menuAction())
+ self.menubar.addAction(self.menu_4.menuAction())
+ self.menubar.addAction(self.menu_5.menuAction())
+ self.menubar.addAction(self.menu_6.menuAction())
+ self.menubar.addAction(self.menu_7.menuAction())
+ self.menubar.addAction(self.menu_8.menuAction())
+
+ self.retranslateUi(DigitalImageProcessing)
+ self.pushButton.clicked.connect(DigitalImageProcessing.openImg)
+ self.actionyu.triggered.connect(DigitalImageProcessing.alAnd)
+ self.actionhuo.triggered.connect(DigitalImageProcessing.alOr)
+ self.actionfei.triggered.connect(DigitalImageProcessing.alNegation)
+ self.actionjiafa.triggered.connect(DigitalImageProcessing.alAdd)
+ self.actionjianfa.triggered.connect(DigitalImageProcessing.alSubtract)
+ self.actionchengfa.triggered.connect(DigitalImageProcessing.alMulty)
+ self.actionchufa.triggered.connect(DigitalImageProcessing.alDivide)
+ self.actiontuxiangfanzhuan.triggered.connect(DigitalImageProcessing.horizonal)
+ self.actionchuizhifanzhuan.triggered.connect(DigitalImageProcessing.vertical)
+ self.actiontuxiangpingyi.triggered.connect(DigitalImageProcessing.moveImg)
+ self.actiontuxiangxuanzhuan.triggered.connect(DigitalImageProcessing.rotation)
+ self.actionkuozhansuofang.triggered.connect(DigitalImageProcessing.extend)
+ self.actionfangshebianhuan.triggered.connect(DigitalImageProcessing.affine)
+ self.actionhuiduzhifangtu.triggered.connect(DigitalImageProcessing.histGrey)
+ self.actioncaisezhifangtu.triggered.connect(DigitalImageProcessing.histRGB)
+ self.actionhuizhizhifangtu.triggered.connect(DigitalImageProcessing.histD)
+ self.actionfenduanxianxingbianhuanduizhifangtuxiugai.triggered.connect(DigitalImageProcessing.editHist)
+ self.actionHough.triggered.connect(DigitalImageProcessing.houghLines)
+ self.actionHoughP.triggered.connect(DigitalImageProcessing.houghLinesP)
+ self.actionbianyuanjiancedejibenyuanli.triggered.connect(DigitalImageProcessing.basic_of_edge_detection)
+ self.actionRoberts.triggered.connect(DigitalImageProcessing.roberts)
+ self.actionPrewitt_Sobel.triggered.connect(DigitalImageProcessing.sobel)
+ self.actionLaplacian.triggered.connect(DigitalImageProcessing.laplacian)
+ self.actionLoG.triggered.connect(DigitalImageProcessing.LoG)
+ self.actionCanny.triggered.connect(DigitalImageProcessing.canny)
+ self.actionfushi.triggered.connect(DigitalImageProcessing.corrode)
+ self.actionpengzhang.triggered.connect(DigitalImageProcessing.dilation)
+ self.actionkaiyunsuan.triggered.connect(DigitalImageProcessing.open)
+ self.actionbiyunsuan.triggered.connect(DigitalImageProcessing.close)
+ self.actionzao_sheng_miaoshuqi.triggered.connect(DigitalImageProcessing.describe)
+ self.actionjunzhileilvboqi.triggered.connect(DigitalImageProcessing.meanFilter)
+ self.actionpaixutongjileilvboqi.triggered.connect(DigitalImageProcessing.sortFilter)
+ self.actionxuanzexinglvboqi.triggered.connect(DigitalImageProcessing.selectiveFilter)
+ self.actionlingyupingjunfa.triggered.connect(DigitalImageProcessing.avg_blur)
+ self.actionzhongzhilvbo.triggered.connect(DigitalImageProcessing.mid_blur)
+ self.actionlixiang.triggered.connect(DigitalImageProcessing.low_pass)
+ self.actionButterworth.triggered.connect(DigitalImageProcessing.butterworth)
+ self.actionGauss.triggered.connect(DigitalImageProcessing.gauss)
+ QtCore.QMetaObject.connectSlotsByName(DigitalImageProcessing)
+
+ def retranslateUi(self, DigitalImageProcessing):
+ _translate = QtCore.QCoreApplication.translate
+ DigitalImageProcessing.setWindowTitle(_translate("DigitalImageProcessing", "数字图像处理"))
+ self.groupBox.setTitle(_translate("DigitalImageProcessing", "原始图片"))
+ self.groupBox_2.setTitle(_translate("DigitalImageProcessing", "修改后图片"))
+ self.pushButton.setText(_translate("DigitalImageProcessing", "打开图片"))
+ self.menu.setTitle(_translate("DigitalImageProcessing", "数字图像的计算"))
+ self.menu_2.setTitle(_translate("DigitalImageProcessing", "数字图像的几何变换"))
+ self.menu_3.setTitle(_translate("DigitalImageProcessing", "数字图像直方图"))
+ self.menu_Hough.setTitle(_translate("DigitalImageProcessing", "使用Hough变换实现线条变换检测"))
+ self.menu_4.setTitle(_translate("DigitalImageProcessing", "边缘检测"))
+ self.menu_5.setTitle(_translate("DigitalImageProcessing", "数字图像形态学"))
+ self.menu_6.setTitle(_translate("DigitalImageProcessing", "噪声滤除"))
+ self.menu_7.setTitle(_translate("DigitalImageProcessing", "空域的平滑"))
+ self.menu_8.setTitle(_translate("DigitalImageProcessing", "频域的平滑"))
+ self.actionyu.setText(_translate("DigitalImageProcessing", "与运算"))
+ self.actionhuo.setText(_translate("DigitalImageProcessing", "或运算"))
+ self.actionfei.setText(_translate("DigitalImageProcessing", "非运算"))
+ self.actionjiafa.setText(_translate("DigitalImageProcessing", "加法运算"))
+ self.actionjianfa.setText(_translate("DigitalImageProcessing", "减法运算"))
+ self.actionchengfa.setText(_translate("DigitalImageProcessing", "乘法运算"))
+ self.actionchufa.setText(_translate("DigitalImageProcessing", "除法运算"))
+ self.actionkuozhansuofang.setText(_translate("DigitalImageProcessing", "扩展缩放"))
+ self.actiontuxiangpingyi.setText(_translate("DigitalImageProcessing", "图像平移"))
+ self.actiontuxiangxuanzhuan.setText(_translate("DigitalImageProcessing", "图像旋转"))
+ self.actiontuxiangfanzhuan.setText(_translate("DigitalImageProcessing", "图像水平翻转"))
+ self.actionchuizhifanzhuan.setText(_translate("DigitalImageProcessing", "图像垂直翻转"))
+ self.actionhuiduzhifangtu.setText(_translate("DigitalImageProcessing", "灰度直方图"))
+ self.actioncaisezhifangtu.setText(_translate("DigitalImageProcessing", "彩色直方图"))
+ self.actionhuizhizhifangtu.setText(_translate("DigitalImageProcessing", "绘制直方图"))
+ self.actionfenduanxianxingbianhuanduizhifangtuxiugai.setText(_translate("DigitalImageProcessing", "分段线性变换对直方图修改"))
+ self.actionbianyuanjiancedejibenyuanli.setText(_translate("DigitalImageProcessing", "边缘检测的基本原理与图像增强"))
+ self.actionRoberts.setText(_translate("DigitalImageProcessing", "Roberts"))
+ self.actionPrewitt_Sobel.setText(_translate("DigitalImageProcessing", "Prewitt & Sobel"))
+ self.actionLaplacian.setText(_translate("DigitalImageProcessing", "Laplacian"))
+ self.actionLoG.setText(_translate("DigitalImageProcessing", "LoG"))
+ self.actionCanny.setText(_translate("DigitalImageProcessing", "Canny"))
+ self.actionxingtaixue.setText(_translate("DigitalImageProcessing", "图像形态学操作"))
+ self.actionjiegouyuandefenlei.setText(_translate("DigitalImageProcessing", "jiegouyuandefenlei"))
+ self.actionfushi.setText(_translate("DigitalImageProcessing", "腐蚀"))
+ self.actionpengzhang.setText(_translate("DigitalImageProcessing", "膨胀"))
+ self.actionkaiyunsuan.setText(_translate("DigitalImageProcessing", "开运算"))
+ self.actionbiyunsuan.setText(_translate("DigitalImageProcessing", "闭运算"))
+ self.actionzao_sheng_miaoshuqi.setText(_translate("DigitalImageProcessing", "噪声描述器"))
+ self.actionjunzhileilvboqi.setText(_translate("DigitalImageProcessing", "均值滤波器"))
+ self.actionpaixutongjileilvboqi.setText(_translate("DigitalImageProcessing", "排序统计类滤波器"))
+ self.actionxuanzexinglvboqi.setText(_translate("DigitalImageProcessing", "选择性滤波器"))
+ self.actionfangshebianhuan.setText(_translate("DigitalImageProcessing", "仿射变换"))
+ self.actionHough.setText(_translate("DigitalImageProcessing", "使用Hough变换实现线条变化检测"))
+ self.actionHoughP.setText(_translate("DigitalImageProcessing", "HoughP"))
+ self.actionlingyupingjunfa.setText(_translate("DigitalImageProcessing", "邻域平均法"))
+ self.actionzhongzhilvbo.setText(_translate("DigitalImageProcessing", "中值滤波法"))
+ self.actionlixiang.setText(_translate("DigitalImageProcessing", "理想低通滤波"))
+ self.actionButterworth.setText(_translate("DigitalImageProcessing", "巴特沃斯低通滤波"))
+ self.actionGauss.setText(_translate("DigitalImageProcessing", "高斯低通滤波"))
diff --git a/DIP.ui b/DIP.ui
new file mode 100644
index 0000000..2a535fe
--- /dev/null
+++ b/DIP.ui
@@ -0,0 +1,412 @@
+
+
+ DigitalImageProcessing
+
+
+
+ 0
+ 0
+ 975
+ 614
+
+
+
+ 数字图像处理
+
+
+
+
+
+ 30
+ 40
+ 421
+ 321
+
+
+
+
+ Agency FB
+ 14
+
+
+
+ 原始图片
+
+
+
+
+ 40
+ 30
+ 351
+ 261
+
+
+
+ background : rgb(0, 170, 255)
+
+
+
+
+
+
+
+
+
+ 520
+ 40
+ 411
+ 321
+
+
+
+
+ Agency FB
+ 14
+
+
+
+ 修改后图片
+
+
+
+
+ 30
+ 30
+ 361
+ 261
+
+
+
+ background : rgb(0, 170, 255)
+
+
+
+
+
+
+
+
+
+ 390
+ 410
+ 191
+ 91
+
+
+
+ 打开图片
+
+
+
+
+
+
+
+ 与运算
+
+
+
+
+ 或运算
+
+
+
+
+ 非运算
+
+
+
+
+ 加法运算
+
+
+
+
+ 减法运算
+
+
+
+
+ 乘法运算
+
+
+
+
+ 除法运算
+
+
+
+
+ 扩展缩放
+
+
+
+
+ 图像平移
+
+
+
+
+ 图像旋转
+
+
+
+
+ 图像水平翻转
+
+
+
+
+ 图像垂直翻转
+
+
+
+
+ 灰度直方图
+
+
+
+
+ 彩色直方图
+
+
+
+
+ 绘制直方图
+
+
+
+
+ 分段线性变换对直方图修改
+
+
+
+
+ 边缘检测的基本原理与图像增强
+
+
+
+
+ Roberts
+
+
+
+
+ Prewitt & Sobel
+
+
+
+
+ Laplacian
+
+
+
+
+ LoG
+
+
+
+
+ Canny
+
+
+
+
+ 图像形态学操作
+
+
+
+
+
+
+
+
+
+ jiegouyuandefenlei
+
+
+
+
+ 腐蚀
+
+
+
+
+ 膨胀
+
+
+
+
+ 开运算
+
+
+
+
+ 闭运算
+
+
+
+
+ 噪声描述器
+
+
+
+
+ 均值滤波器
+
+
+
+
+ 排序统计类滤波器
+
+
+
+
+ 选择性滤波器
+
+
+
+
+ 仿射变换
+
+
+
+
+ 使用Hough变换实现线条变化检测
+
+
+
+
+ HoughP
+
+
+
+
+ 邻域平均法
+
+
+
+
+ 中值滤波法
+
+
+
+
+ 理想低通滤波
+
+
+
+
+ 巴特沃斯低通滤波
+
+
+
+
+ 高斯低通滤波
+
+
+
+
+
+
diff --git a/EdgeDetection.py b/EdgeDetection.py
new file mode 100644
index 0000000..84095b4
--- /dev/null
+++ b/EdgeDetection.py
@@ -0,0 +1,78 @@
+import cv2
+import numpy as np
+
+
+class edgeDetect:
+ def __init__(self, imgPath):
+ self.path = imgPath
+
+ def graphicsEnhance(self):
+ img_gray = cv2.imread(self.path, 0)
+ h, w = img_gray.shape
+ gradient = np.zeros((h, w))
+ # 计算图像梯度
+ img_gray = img_gray.astype('float')
+ for i in range(h - 1):
+ for j in range(w - 1):
+ gx = abs(img_gray[i + 1, j] - img_gray[i, j])
+ gy = abs(img_gray[i, j + 1] - img_gray[i, j])
+ gradient[i, j] = gx + gy
+ # sharp为结果
+ sharp = img_gray + gradient
+ sharp = np.where(sharp > 255, 255, sharp)
+ sharp = np.where(sharp < 0, 0, sharp)
+ cv2.imwrite("saved Img/sharp.bmp", sharp)
+
+ def roberts(self):
+ img = cv2.imread(self.path)
+ img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+ kernelx = np.array([[-1, 0], [0, 1]], dtype=int)
+ kernely = np.array([[0, -1], [1, 0]], dtype=int)
+ x = cv2.filter2D(img, cv2.CV_16S, kernelx)
+ y = cv2.filter2D(img, cv2.CV_16S, kernely)
+ absX = cv2.convertScaleAbs(x)
+ absY = cv2.convertScaleAbs(y)
+ Roberts = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
+ cv2.imwrite("saved Img/roberts.bmp", Roberts)
+
+ def sobel(self):
+ Sobel = cv2.imread(self.path)
+ Sobel = cv2.cvtColor(Sobel, cv2.COLOR_BGR2GRAY)
+ x = cv2.Sobel(Sobel, cv2.CV_16S, 1, 0)
+ y = cv2.Sobel(Sobel, cv2.CV_16S, 0, 1)
+ absX = cv2.convertScaleAbs(x)
+ absY = cv2.convertScaleAbs(y)
+ Sobel = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
+ cv2.imwrite("saved Img/sobel.bmp", Sobel)
+
+ def laplacian(self):
+ img = cv2.imread(self.path)
+ grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+ dst = cv2.Laplacian(grayImage, cv2.CV_16S, ksize=3)
+ Laplacian = cv2.convertScaleAbs(dst)
+ cv2.imwrite("saved Img/laplacian.bmp", Laplacian)
+
+ def LoG(self):
+ img = cv2.imread(self.path)
+ grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+ img = cv2.copyMakeBorder(grayImage, 2, 2, 2, 2, borderType=cv2.BORDER_REPLICATE)
+ img = cv2.GaussianBlur(img, (3, 3), 0, 0)
+ m1 = np.array(
+ [[0, 0, -1, 0, 0], [0, -1, -2, -1, 0], [-1, -2, 16, -2, -1], [0, -1, -2, -1, 0], [0, 0, -1, 0, 0]],
+ dtype=np.int32)
+ image1 = np.zeros(img.shape).astype(np.int32)
+ h, w, _ = img.shape
+ for i in range(2, h - 2):
+ for j in range(2, w - 2):
+ image1[i, j] = np.sum(m1 * img[i - 2:i + 3, j - 2:j + 3, 1])
+ image1 = cv2.convertScaleAbs(image1)
+ cv2.imwrite("saved Img/log.bmp", image1)
+
+ def canny(self):
+ src = cv2.imread(self.path)
+ blur = cv2.GaussianBlur(src, (3, 3), 0)
+ grayImage = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY)
+ gradx = cv2.Sobel(grayImage, cv2.CV_16SC1, 1, 0)
+ grady = cv2.Sobel(grayImage, cv2.CV_16SC1, 0, 1)
+ edge_output = cv2.Canny(gradx, grady, 50, 150)
+ cv2.imwrite("saved Img/canny.bmp", edge_output)
diff --git a/FrequencySmoothing.py b/FrequencySmoothing.py
new file mode 100644
index 0000000..c514e56
--- /dev/null
+++ b/FrequencySmoothing.py
@@ -0,0 +1,66 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+class frequency_filter:
+ def __init__(self, img_path):
+ self.path = img_path
+
+ def Ideal_low_pass_filtering_smooth(self):
+ img = cv2.imread(self.path)
+ img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+ img = np.float32(img)
+ dft = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
+ dft = np.fft.fftshift(dft)
+ rows, cols = img.shape
+ mask = np.zeros((rows, cols, 2), dtype=np.uint8)
+ mask[int(rows / 2) - 20:int(rows / 2) + 20, int(cols / 2) - 20:int(cols / 2) + 20] = 1
+ f = dft * mask
+ f = np.fft.ifftshift(f)
+ img = cv2.idft(f)
+ img = cv2.magnitude(img[:, :, 0], img[:, :, 1])
+ filename = "saved Img/ideal_low_pass.bmp"
+ plt.imsave(filename, img, cmap='gray')
+
+ def butterworth(self, D0, N):
+ D0 = int(D0)
+ N = int(N)
+ img = cv2.imread(self.path)
+ img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+ img = np.float32(img)
+ dft = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
+ dft = np.fft.fftshift(dft)
+ rows, cols = img.shape
+ mask = np.zeros((rows, cols, 2))
+ for i in range(rows):
+ for j in range(cols):
+ D = np.sqrt((i - rows / 2) ** 2 + (j - cols / 2) ** 2)
+ mask[i, j, 0] = mask[i, j, 1] = 1.0 / (1.0 + ((D / D0) ** (2 * N)))
+ f = dft * mask
+ f = np.fft.ifftshift(f)
+ img = cv2.idft(f)
+ img = cv2.magnitude(img[:, :, 0], img[:, :, 1])
+ filename = "saved Img/butterworth.bmp"
+ plt.imsave(filename, img, cmap='gray')
+
+ def gauss(self, D0):
+ D0 = int(D0)
+ img = cv2.imread(self.path)
+ img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+ img = np.float32(img)
+ dft = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
+ dft = np.fft.fftshift(dft)
+ rows, cols = img.shape
+ crow, ccol = int(rows / 2), int(cols / 2)
+ mask = np.zeros((rows, cols, 2))
+ for i in range(rows):
+ for j in range(cols):
+ D = np.sqrt((i - crow) ** 2 + (j - ccol) ** 2)
+ mask[i, j, 0] = mask[i, j, 1] = np.exp(-(D * D) / (2 * D0 * D0))
+ f = dft * mask
+ f = np.fft.ifftshift(f)
+ img = cv2.idft(f)
+ img = cv2.magnitude(img[:, :, 0], img[:, :, 1])
+ filename = "saved Img/gauss.bmp"
+ plt.imsave(filename, img, cmap='gray')
diff --git a/GeometricalChange.py b/GeometricalChange.py
new file mode 100644
index 0000000..939acae
--- /dev/null
+++ b/GeometricalChange.py
@@ -0,0 +1,47 @@
+import cv2
+import numpy as np
+
+
+class GeoChange:
+ def __init__(self, imgPath):
+ self.path = imgPath
+
+ def extend(self, size):
+ img = cv2.imread(self.path)
+ img = cv2.resize(img, (0, 0), fx=size, fy=size, interpolation=cv2.INTER_LINEAR)
+ cv2.imwrite("saved Img/size.bmp", img)
+
+ def move(self, x, y):
+ img = cv2.imread(self.path)
+ height, width, channel = img.shape
+ # 构建平移矩阵
+ matrix = np.float32([[1, 0, x], [0, 1, y]])
+ img = cv2.warpAffine(img, matrix, (width, height))
+ cv2.imwrite("saved Img/move.bmp", img)
+
+ def horizon_flip(self):
+ img = cv2.imread(self.path)
+ horizon = cv2.flip(img, 1, dst=None)
+ cv2.imwrite("saved Img/horizon.bmp", horizon)
+
+ def vertical_flip(self):
+ img = cv2.imread(self.path)
+ vertical = cv2.flip(img, 0, dst=None)
+ cv2.imwrite("saved Img/vertical.bmp", vertical)
+
+ def rotation(self, degree):
+ img = cv2.imread(self.path)
+ rows, cols, depth = img.shape
+ matrix = cv2.getRotationMatrix2D((cols / 2, rows / 2), degree, 1)
+ img = cv2.warpAffine(img, matrix, (cols, rows))
+ cv2.imwrite("saved Img/rotation.bmp", img)
+
+ def affine(self):
+ img = cv2.imread(self.path)
+ img = cv2.resize(img, (256, 256))
+ rows, cols = img.shape[: 2]
+ post1 = np.float32([[50, 50], [200, 50], [50, 200]])
+ post2 = np.float32([[10, 100], [200, 50], [100, 250]])
+ M = cv2.getAffineTransform(post1, post2)
+ result = cv2.warpAffine(img, M, (rows, cols))
+ cv2.imwrite("saved Img/affine.bmp", result)
diff --git a/Histogram.py b/Histogram.py
new file mode 100644
index 0000000..14134ed
--- /dev/null
+++ b/Histogram.py
@@ -0,0 +1,74 @@
+import cv2
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+class Histogram:
+ def __init__(self, imgPath):
+ self.path = imgPath
+
+ def histGrey(self):
+ img1 = cv2.imread(self.path)
+ img = cv2.cvtColor(img1, cv2.COLOR_RGB2GRAY)
+ hist = cv2.calcHist([img], [0], None, [256], [0, 255])
+ plt.plot(hist)
+ plt.xlim([0, 255])
+ plt.show()
+
+ def histRGB(self):
+ src = cv2.imread(self.path)
+ color = ["r", "g", "b"]
+ b, g, r = cv2.split(src)
+ src = cv2.merge([r, g, b])
+ for index, c in enumerate(color):
+ hist = cv2.calcHist([src], [index], None, [256], [0, 255])
+ plt.plot(hist, color=c)
+ plt.xlim([0, 255])
+ plt.show()
+
+ def hist(self):
+ src = cv2.imread(self.path)
+ b, g, r = cv2.split(src)
+ src = cv2.merge([r, g, b])
+ histr = cv2.calcHist([src], [0], None, [256], [0, 256])
+ plt.plot(histr, color='r')
+ plt.xlim([0, 256])
+ histr = cv2.calcHist([src], [1], None, [256], [0, 256])
+ plt.plot(histr, color='g')
+ plt.xlim([0, 256])
+ histr = cv2.calcHist([src], [2], None, [256], [0, 256])
+ plt.plot(histr, color='b')
+ plt.xlim([0, 256])
+ plt.show()
+
+ def editHist(self):
+ img = cv2.imread(self.path, 0)
+ h, w = img.shape[:2]
+ out = np.zeros(img.shape, np.uint8)
+ for i in range(h):
+ for j in range(w):
+ pix = img[i][j]
+ if pix < 50:
+ out[i][j] = 0.5 * pix
+ elif pix < 150:
+ out[i][j] = 3.6 * pix - 310
+ else:
+ out[i][j] = 0.238 * pix + 194
+ out = np.around(out)
+ out = out.astype(np.uint8)
+ plt.subplot(121)
+ plt.imshow(img, 'gray')
+ plt.subplot(122)
+ pixelSequence = img.ravel()
+ numberBins = 256
+ histogram, bins, patch = plt.hist(pixelSequence, numberBins)
+ plt.axis([0, 255, 0, np.max(histogram)])
+ plt.show()
+ plt.subplot(121)
+ plt.imshow(out, 'gray')
+ plt.subplot(122)
+ pixelSequence = out.ravel()
+ numberBins = 256
+ histogram, bins, patch = plt.hist(pixelSequence, numberBins)
+ plt.axis([0, 255, 0, np.max(histogram)])
+ plt.show()
diff --git a/Hough.py b/Hough.py
new file mode 100644
index 0000000..e0b5d07
--- /dev/null
+++ b/Hough.py
@@ -0,0 +1,41 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+class Hough:
+ def __init__(self, imgPath):
+ self.path = imgPath
+
+ def line_change_detection(self):
+ img = cv2.imread(self.path)
+ img = cv2.GaussianBlur(img, (3, 3), 0)
+ edges = cv2.Canny(img, 50, 150, apertureSize=3)
+ lines = cv2.HoughLines(edges, 1, np.pi / 2, 118)
+ result = img.copy()
+ for i_line in lines:
+ for line in i_line:
+ rho = line[0]
+ theta = line[1]
+ if (theta < (np.pi / 4.)) or (theta > (3. * np.pi / 4.0)): # 垂直直线
+ pt1 = (int(rho / np.cos(theta)), 0)
+ pt2 = (int((rho - result.shape[0] * np.sin(theta)) / np.cos(theta)), result.shape[0])
+ cv2.line(result, pt1, pt2, (0, 0, 255))
+ else:
+ pt1 = (0, int(rho / np.sin(theta)))
+ pt2 = (result.shape[1], int((rho - result.shape[1] * np.cos(theta)) / np.sin(theta)))
+ cv2.line(result, pt1, pt2, (0, 0, 255), 1)
+ cv2.imwrite('saved Img/result.bmp', result)
+
+ def line_change_detection_P(self):
+ img = cv2.imread(self.path)
+ img = cv2.GaussianBlur(img, (3, 3), 0)
+ edges = cv2.Canny(img, 50, 150, apertureSize=3)
+ minLineLength = 200
+ maxLineGap = 15
+ linesP = cv2.HoughLinesP(edges, 1, np.pi / 180, 80, minLineLength, maxLineGap)
+ result_P = img.copy()
+ for i_P in linesP:
+ for x1, y1, x2, y2 in i_P:
+ cv2.line(result_P, (x1, y1), (x2, y2), (0, 255, 0), 3)
+ cv2.imwrite('saved Img/result_p.bmp', result_P)
diff --git a/LogicalAlgorithm.py b/LogicalAlgorithm.py
new file mode 100644
index 0000000..2ff0b15
--- /dev/null
+++ b/LogicalAlgorithm.py
@@ -0,0 +1,61 @@
+import cv2
+import numpy as np
+
+
+class logicalAlgorithm:
+ def __init__(self, img_path1, img_path2):
+ self.path1 = img_path1
+ self.path2 = img_path2
+
+ def alAnd(self):
+ x = cv2.imread(self.path1, 1)
+ y = cv2.imread(self.path2, 1)
+ rows, cols = x.shape[:2]
+ y_dst = cv2.resize(y, (cols, rows), interpolation=cv2.INTER_CUBIC)
+ result = (x & y_dst)
+ cv2.imwrite("saved Img/And.bmp", result)
+
+ def alOr(self):
+ x = cv2.imread(self.path1, 1)
+ y = cv2.imread(self.path2, 1)
+ rows, cols = x.shape[:2]
+ y_dst = cv2.resize(y, (cols, rows), interpolation=cv2.INTER_CUBIC)
+ result = (x | y_dst)
+ cv2.imwrite("saved Img/Or.bmp", result)
+
+ def alNegation(self):
+ x = cv2.imread(self.path1, 1)
+ result = (~x)
+ cv2.imwrite("saved Img/Negation.bmp", result)
+
+ def alAdd(self):
+ x = cv2.imread(self.path1, 1)
+ y = cv2.imread(self.path2, 1)
+ rows, cols = x.shape[:2]
+ y_dst = cv2.resize(y, (cols, rows), interpolation=cv2.INTER_CUBIC)
+ result = cv2.add(x, y_dst)
+ cv2.imwrite("saved Img/Add.bmp", result)
+
+ def alSubtract(self):
+ x = cv2.imread(self.path1, 1)
+ y = cv2.imread(self.path2, 1)
+ rows, cols = x.shape[:2]
+ y_dst = cv2.resize(y, (cols, rows), interpolation=cv2.INTER_CUBIC)
+ result = cv2.subtract(x, y_dst)
+ cv2.imwrite("saved Img/Subtract.bmp", result)
+
+ def alMulty(self):
+ x = cv2.imread(self.path1, 1).astype(np.float64)/255
+ y = cv2.imread(self.path2, 1).astype(np.float64)/255
+ rows, cols = x.shape[:2]
+ y_dst = cv2.resize(y, (cols, rows), interpolation=cv2.INTER_CUBIC)
+ result = cv2.multiply(x, y_dst) * 255
+ cv2.imwrite("saved Img/Multiply.bmp", result)
+
+ def alDivide(self):
+ x = cv2.imread(self.path1, 1).astype(np.float64)/255
+ y = cv2.imread(self.path2, 1).astype(np.float64)/255
+ rows, cols = x.shape[:2]
+ y_dst = cv2.resize(y, (cols, rows), interpolation=cv2.INTER_CUBIC)
+ result = cv2.divide(x, y_dst) * 255
+ cv2.imwrite("saved Img/Divide.bmp", result)
diff --git a/NoiseCanceller.py b/NoiseCanceller.py
new file mode 100644
index 0000000..71fa3ff
--- /dev/null
+++ b/NoiseCanceller.py
@@ -0,0 +1,78 @@
+import random
+
+import cv2
+import numpy as np
+
+
+class noiseCanceller:
+ def __init__(self, imgPath):
+ self.path = imgPath
+
+ def noiseDescriber(self):
+ image = cv2.imread(self.path, cv2.IMREAD_GRAYSCALE)
+ output = np.zeros(image.shape, np.uint8)
+ prob = 0.2
+ thres = 1 - prob
+ # 遍历图像，获取叠加噪声后的图像
+ for i in range(image.shape[0]):
+ for j in range(image.shape[1]):
+ rdn = random.random()
+ if rdn < prob:
+ # 添加胡椒噪声
+ output[i][j] = 0
+ elif rdn > thres:
+ # 添加食盐噪声
+ output[i][j] = 255
+ else:
+ # 不添加噪声
+ output[i][j] = image[i][j]
+ cv2.imwrite("saved Img/out.bmp", output)
+
+ def meanFilter(self):
+ image = cv2.imread(self.path, cv2.IMREAD_GRAYSCALE)
+ output = np.zeros(image.shape, np.uint8)
+ for i in range(image.shape[0]):
+ for j in range(image.shape[1]):
+ ij = 1
+ for m in range(-1, 2):
+ if 0 <= j + m < image.shape[1]:
+ ij *= image[i][j + m]
+ output[i][j] = ij ** (1 / 3)
+ cv2.imwrite("saved Img/mean filter.bmp", output)
+
+ def sortFilter(self):
+ def get_max(array):
+ length = len(array)
+ for i in range(length):
+ for j in range(i + 1, length):
+ if array[j] > array[i]:
+ temp = array[j]
+ array[j] = array[i]
+ array[i] = temp
+ return array[0]
+
+ image = cv2.imread(self.path, cv2.IMREAD_GRAYSCALE)
+ output = np.zeros(image.shape, np.uint8)
+ array = []
+ for i in range(image.shape[0]):
+ for j in range(image.shape[1]):
+ array.clear()
+ for m in range(-1, 2):
+ for n in range(-1, 2):
+ if 0 <= i + m < image.shape[0] and 0 <= j + n < image.shape[1]:
+ array.append(image[i + m][j + n])
+
+ output[i][j] = get_max(array)
+ cv2.imwrite("saved Img/sort filter.bmp", output)
+
+ def selectiveFilter(self):
+ image = cv2.imread(self.path, cv2.IMREAD_GRAYSCALE)
+ output = np.zeros(image.shape, np.uint8)
+ minimum = 200
+ for i in range(image.shape[0]):
+ for j in range(image.shape[1]):
+ if minimum < image[i][j]:
+ output[i][j] = image[i][j]
+ else:
+ output[i][j] = 0
+ cv2.imwrite("saved Img/selective filter.bmp", output)
diff --git a/SpatialSmoothing.py b/SpatialSmoothing.py
new file mode 100644
index 0000000..b053e22
--- /dev/null
+++ b/SpatialSmoothing.py
@@ -0,0 +1,18 @@
+import cv2
+
+
+class spatial:
+ def __init__(self, img_path):
+ self.path = img_path
+
+ def average_blur(self, ksize):
+ ksize = int(ksize)
+ img = cv2.imread(self.path)
+ avg_blur = cv2.blur(img, (ksize, ksize))
+ cv2.imwrite("saved Img/avg_blur.bmp", avg_blur)
+
+ def mid_blur(self, ksize):
+ ksize = int(ksize)
+ img = cv2.imread(self.path)
+ mid_blur = cv2.medianBlur(img, ksize)
+ cv2.imwrite("saved Img/mid_blur.bmp", mid_blur)
diff --git a/__pycache__/DIP.cpython-36.pyc b/__pycache__/DIP.cpython-36.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fc5297a952b8ae2e215290f8438e562f2891a2cf
GIT binary patch
literal 8839
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
E4_&4TaR2}S
literal 0
HcmV?d00001
diff --git a/__pycache__/EdgeDetection.cpython-36.pyc b/__pycache__/EdgeDetection.cpython-36.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..605caeb2589410ce201b4559d57df9d3e8c79675
GIT binary patch
literal 3296
zcmai0%Wm676y@+O+LmRZO;eUAWk@HM
zK&_lEv+Wmj)1T<3f6(Qu3S?9LLKjWX9m=w*x+n?WxpU{qd(PZDH)m$NrC(p|KAG0E
zSK8QPK)-`8eHVgjoHeytQL>u8u5q0kFEnl(>otS32U^t}pr5u`CwcPdQ10MMS0O^J
z#<*6~Ipg{Z4WkThqBOb1ZIl*wxQo)}CGMeg_!OT;>GBy~Mp@#sSfwJpkVoNan1%JM
zPV>`4C4DRSQV$|$x#nZH7{NBHOq!h_+pp@Saz2uV2!R
z*{b%W(YKB`Eb!yd^004bF8u;2dmJiPv0rpbDMgc(eCC>?qaN2jJl;g
z-Fl=wz5R&hF)wQU682WgOWZs#xtW)ajgf^NfFVPR*6_FmU1tRX_NE{wNNcaz4zdC1
zgVzwfb7}A_L&SNa#KnaTZoRVPbI21=@Zjg05uyl0BC$bRLIECRr?5qozkk
z__}Hl(NT;j1feBo(Yv!B*VDCRKS=6f3C8pagvQFuV`bfA^LVe~y`;NJ?_C+=!Nl+p
z9cUinj-ta)P)_JTP(wFzk|t3jvp@lmAkuN@ScEcjxbYHXQ7t-m(1JrX)?#2Rr~p~Y
zb--kf)eY1w)Vbq#029)jyN_SHbj}@LcRu(4^B3SVJ
z{&nyCDWIag8;UF?NC&U+h_}$CIwKHfG%-U$A?wzkWh?DwTgdXt{d@Pf{pI!TrSnaQdO*Fzdt`W@#0Mml
z!)@hoag7Wgk*JdRn8YU}$OU7^%Sve`8lF}l3a`?E8hW%c=26vkX2>SoYs2K6{dl!HqD?V!@V
zlb&NvQvR_D|9prgWQn4ZN;T5pX(pCnoODoWwB`-8s^oU!B#-qL#@sXNIC2pkRr-{R
zZXoXdpNl{@^(t5CFKrcxoSY#gBjAH}EOQ%5=N?%i3leD>DVp>$pGBOi@Hu6l=jZss
zu#d^l7yTm(GkDxV^fI7LA-zo>v&IZr2@b07AU^f&zH_vfm622|&XBxxq`ZfH_h?hu
z0OZhi3n|EL%;t!fxl2|^B)1=Qq$#SEiW;}}jLX^rk|2_so0s-9
zNMxAfI6@;bT-Y2?Zm+VMx7!vx6b}*a1Rmo+6ixJ^zZyhA
zP({MQUnen9RmGRopv0)lM72797Tx5`Y1rIeUzX*1yVLzPI0%>3c4cMx{`TtHw!gi$
zb#G(k?!z@Xy&fFmQWGT0%|oH0tat~DOA9gf=8~YF5oHo{B<88fNDo`ZIad@e@~R*T
zi<{K0w-za1@?BMbWKIk<0w{Vb(d!CLM37Ev;ivN+1`mFRN=yh4sdx
zt?Ia0_2{ab1g+5brRV#tHa~2VKJEKY4})gWB3w)*2utxPiR&ajBe6_kgT!gzR~q3b
z=xh;)YA-Hx4R_9+c0Jc|E2^z(DpyG>Ic#;h1zBm#S(8ckRPIvF4fs>w
ACjbBd
literal 0
HcmV?d00001
diff --git a/__pycache__/FrequencySmoothing.cpython-36.pyc b/__pycache__/FrequencySmoothing.cpython-36.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..20c111685004ad93b67ee69df47f6f42366eb36b
GIT binary patch
literal 2698
zcmb`JNpBoQ6vwN2o1V?<*pA~s!WI}nj!7gGp$GytiGqS{Wg%f?)M`)ljA!UsT-{D=
ztLB0Ox7_#=d=5SU_qyif8)r`ZU$tjE&LS?f)c<<*YU!%3-+SHH%H_hdKVNMBm1pb)
z8@p`SH*qJQLIe{$X0@#3HOtiPwo`L&Ghqq)858!ARr3VD&#KNbMzHld>F}~(+{A5W
zi&%{dhFQ3}tuzR7^kB0Zez^GZGM9(F>KxtZ
z@^RCUY`yTNtc?}7ts_3*ux&-^99gKjZBOwNf6n-Q!Jk_L3oZF}LD3jX@pf^`8rTB|
z-jcGFBdmrEyDV(B5
znHoqW9$
z_Nx_b*PmR~UaKRcP)K50`}HU3YA^0dJ+ZoRcjI1g@AfxWZ{Pd+M{RZcI@gGMVS4SV
zwnZb=Gi$dV1gjh0Z{Gd(aj^05!REsU+HRo1ha@{KSZ=Zt_9N{cMzWV^cdyk=uWK8s
z^Q}=Qr$w{n0T-~@6Op$2aZ1agy;Oba(86rsDd)*@WbbK$E%ah&Crp0U9P|SIs2g@7
z!)_)7lfHQ8%xgFa5}+C+23iV?~sUOT6Te&6`>hH?ijg?3Rn7=!-p5-4}U
zo!2faS9wG^T5|jQ;MYCkYwV|Z;O{q31D~kX26^}uLr
zw7(fd-FQ@(2zbed8BJ8!!W)#**>*)ChAI1vq9Tu|kVwr;(kV7^ysi0~{E%E9
zkx*V9W4k!ECt5^8;~2Ola!*;Ff<3`6^Xub8UwDP+vB^f?5PC@?dLNI|drGZks3j$8
zEu497M7FQUpHWLZ6SanDWf^Lnft!MsEXTq!JRWfi85Nn3ct(ys;o09$DIXhxcLw?W
z?GfES3<~HwNd%v;Tu`~pG8_|!pimVntVksD3Nmm7Bp-3G43ZT{H!Nqi;d=LXu>2cX
zwv`W-OJ?=cssxrxhG4R2ce84k+cTmu6Egf+-!Q{l!X1>;N_$R~(ZdtD5zGD=md6mD
zJw><~?q!Mm47~II54`eYoVEM}qU~tE|7LtA48D^7d|n4{&8Z_nLy@2j$a0x_ULjc_
zc_YrQ*&lTrfjo}!d8B3n`E7n<9OU^|KsM8?S9A0yLZ5^n(1jrA^u%6Fb}0yU_rf@9
zkwmwwl6*#TjpQ`Uj78rONnc&6B{TpLX8TkAobgt3CUI!DyVvO-m|UT!J7L<7duiO-
h#xD_B+RMr;572C{dyMvPWb6ErzUB!%kfOO@{|g8?SXlr7
literal 0
HcmV?d00001
diff --git a/__pycache__/GeometricalChange.cpython-36.pyc b/__pycache__/GeometricalChange.cpython-36.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0d2dd042350445f1821d8ac6d47871fdcbd750ba
GIT binary patch
literal 2300
zcmb_dTWcFf6yCY)MT+dWPU_M)DNb8j1jV5aeJQ0R#32|OVO&26!LreeR%`a6&aQ7_
z_2l$1(5L=~{*(TOc`Ectzo3w(o-?DH)jW2^oEgoWvvbZj-+cRYW25=#pTFMx?m5oi
z&dS4J{0v(8IT+yxk~&@6lP-Pb2rAfHN3a{(WrF+!)J+Y4xA6HHBNCxm1nfOOhK^HEd{+f?&Xrh~4ZWbrXf{NX4UoZo+U_CS$q(CL6V>iLrs6X8nr;?IoF#kx-bE_LM~5ZtJLX
z`tl_F>8SJa`H2RYE>%*=Hd7qEIQnP?;2GGg!P>PauPT{~28>Iba7c^nknz?M3+vFw
z-S7#ZA@l}`Qy8ou!D@EKdThcc?!>G3nTvd>Nz8z8q^2>85icJiyqeX1?bduiZ`g#v
zj1O1=BWGCg&J?jSb+6)*6&DtlKw-)X8DoKP%V9Ki3f#qGzNzc|D-&eNJ2&KuUlf%2LQ
zvg_2Kth>$t*e{Ub9;~=Et-YGp%y1r6!&^J-DJqdU@l_;LQ5k(ONcd}Ktv-T~?!8!6
zCo{L#hPVfZ>OQ{A(B8MS_k@gcyUW7euH4BcdnRo;x}&S1T+&A6E487^i!utClu7cMPvl1g@Ee-7QQwy
zs0U~VH*4_KS*&@&pRKvDgAe$+@K(e-06q2qbBi~sPD2E>ztEUwXX*g?)MH3)ikd$C
z6AenrRG@heW_*81$;c?lOqRcfMTMr_TtAXKxP<4Tw$a=J)7^#>vPyKSqP!dwDqA@q
zt4ro!)E5}@CC0d;qO88P-GL^rjo6>3)%qEEHZe@5M7c1s1fuj1ek~NI6*af6opuwy
zfq9h4Fx1U3%nEUy;OJv3jTd4gui7c)ZAD5Np|D^V!}
r60pDx0%&gFo3%DKkZCtR&qmi4B}4rWyi5l_*yMghp(yclhHv~AeBby-
literal 0
HcmV?d00001
diff --git a/__pycache__/Histogram.cpython-36.pyc b/__pycache__/Histogram.cpython-36.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d5ff98c810fa5df8f67abf4b9a4e4f53ce307f93
GIT binary patch
literal 2509
zcmbtWOOG2x5bmDod3e^|7a_?)Kth}>AQB5g5CyU%kv2%tCQ1&0(IRWsJ=kN$kL?+6
z?A6Q#ha*x>{0Hv*0!|!&AJC@=PQG&F0$=s4_eH{mwz|5y`Z3+#S5@uz8jax3?(ci5
z#@HY1RI#CNp=NJGNG5s8!m8yxE3}P8gw8gTmb9NRY0s?CmHZ)ViaA!Woi@ouv7l_B
zX75A9EaZ}fmgLfU!myVu1zI5;>7sR{Cw;W8tjPeaCzr5mUDxg;Sw8HjsNbgTs8CDw
z7HSqi6ue+991{!pPLpdfit=vL(jtq~ue6u+JNIGufhiZ0|9a>4wcY#EygMB1-cCA6
z9;Ki4qfUHZ4cl>+C4ieC2vnMDju%47
zSq}&7Sul9XpOO6UmNt1TRnmMJNyFIV4XPh%={*k@v)n<%W*A+X8
zK08OB&Hskh47A-o*wk*)S8*g25vu+6L4IqP4wYWMb?@%I2dxL&H#fH*eEJ1OqO?tS
z(e^0K0bDwSoTNz~;B|+On?libLIDil)i$IST}(GfR)VgoeKKyVcuI6+bqL1me3@V2
z0pw}8788%*f(tSq)xh->%4xXBSpbM_paO6+zH66uDN2VRESy3V7$smQcXL2F*t@W7UauEgp=aMR}}NXv!*yH4^J2UV>=W
z4Ak1rR9n45)(sMuNnC=^PBM`3MDw;~z|m1&Gz
zd9lth3{~!bcAfj5>%14P^PjuU?VW^9tqL7Vffc|_ZeX8NKpEKQ6zqnDW^j&P^(qZr
zA@M>!UBjn(eX+?2m7zoMt8)|@T3^HLjMyjoh&-Z>;^;&kE}y0Gn8OBE5sxO4zQHws
zuSq>-bumLs4s-7)h6bfG>7oaI5mCD(BB^jTSmAE4
z(nH+XUo)koD7*^{F=$4vv;8|5aWL{!x-=ra%V$OEH`y{TfC0x!uLTb{GF=ck>>t9C_KB;AOrE(LqIdc4PiMn$EAkP^oVvAAqmU
z>gON*`18SUH|9TKY(9n10#Dy`eh9VlRFihr&$**^vTihrwKW)N=P*{oOgrObkbkHh
z6%CMo+(-?_1Bo`vr=!^9pU}(3dnV!Iv7ls6lMmw5_@NfjB+0bhk0w=iYE<5QfzHIc
znm^X|aGYzNXxGf7?e;lRNh@$66T_o`a36pL=Cha8W8jTXBq9j2*^H0R*zU}+|lD}f?
yP0tV&uJxmwkWQ05{H3TcuUf-|c7WArs@_`c_q-2j|9W-YPbfiU^hvt2Z~p@zIw5iZ
literal 0
HcmV?d00001
diff --git a/__pycache__/Hough.cpython-36.pyc b/__pycache__/Hough.cpython-36.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b7982d44663dc2b8d49c1bba927b5ff5167e9688
GIT binary patch
literal 1863
zcma)6PjBNy6rUOYjgz$9Qo0M(LbXC5OQ_Jo39V4YRw^r1Rm2_^Sw)tcaT15vamP+c
zqwy(wMeK=Bz=b<}2QGYpIRXbFapJfacyFABid|NWG{1TO=FNEC@A-pv+xz*OU(SED
z3Hg=W7zW6PFpGBqIN@|ef_kL^)4DM<1M8S@#*HV08*>)eoIWDHxquzyw2OE>7zl?j
zi?;w`5>QSc3+3zy2@Gy<6IPR3+=kWS4rFna_33!hA9Qgm4qS0QfLV9|l1dW7l^~d&
z`c#>DR1SQm%pxB3l#`_W4j8^C0zQpA^N&6{>s*zCadvi;^pi3gJxrs1+!5n$Tog&x
zKhwwUJQIHKud7HDj
zp*0gU_*(dK>ua-O;I|~>c4-eC?(7im&dmyT4Ba`Y%%^1fOd3bzi$5!C`iHbY`mM61
z&Dm?Da$vP#b)~C!H+IOEq!^&rZ!E9GhKoFrLXD3;}l<%u%8W1yOmWF=%77s@II@EOVg
zDk^gXp~&E`L{i3nQ<#|A07fe-=6%RwVML+q`tE_9glG_Vb(|QCl~oSnGEzof?js!N
zCa3{ftzO0WusevdejM_+jJstr&akbDdjN#C=o;Om+tdZg19a&wXz$ZahWI+2?bHqN
z!aS?)XhEt~cYFs5RP}#%2e&JOJC(WYk`>RnCk^0*U0KUcv8VTScYIhm(>>`xpS*o$
zR&Ld(ys8Pi8`74pZ1kA)WV6Tk8mF3RJzyHJ4I(^Xn!RG$`f1Grq>{il5!mHE75F)e
zpAgp3+D7RIgbu36lG*mZi52GmMJu%p;?U$HBg
z(*szaBh2j=7CP+U@de)NnldIefgUc9W|Q8dv%4>$N!U5{ZT#J4Q5uJ#^1?73^T`P1
zRv2DPqEYP;F60;QAnYUHAN>X(qXo7++6x5WtKn{GoA2nyRaQ1h^DF&?>Q)++`Dk2@
kl5_asqonNRYUHC*@4Jy-AE(>Ky^Fz8
zKiERkaeRn9eSiQAc*vT$*Vn
z%!dcRFk#_7e?B?>wDn?;T_kbqIOqhK7oJ33$A2M`wx6a!+-W^uF>1dzkdEsHagez#
z?U5P?j9YxTyXwIHbX}X%8f-Rp6T9-Hg@cTB(U&fAc%_Z`$PKYZFk?`x
z)8hsK1+dsem=Gqm=#RGuwh8VK>=3+7Kryz!mf?k`O5-M3cM8Zl6*I2L7V1aX(}xI?
zXq&{|h;OhlMU@WPNSnow-cUXdcjkUJ{Emts<*l*mt@2D)p^$r4qz4Y15pd+jy{8^HgT$4~TzksDz@>a|)>%7lB?M#5o0;b~GjI3%-h2Dbkt3Cr
zZ=bGJXBd0RCYp))HT3ubgkXYqSu-Dblk2t7G(Tp-5auH$%sr!N34WK=tbN$CMw{e8
zGcdV^9$$v=8SQTxf(zpjYns9o7Dh|h!og^Zl5jCPqAV&HOJWA6&Z@bn7sUPzFKYYU
zt}okkCN&zV-$0Km5GhYt3!Y*ZZ`8Q5`d+eLGn5tk-G{0agq>9=er3{u@!yx~A3Rvy
zP1bwSgL=>j60f@wdL4gN_S$|N2T|uiKyw1K9
znLYSwq%%gk+nJM;H_Ce~E2X8>++UZLLCUZCdg>VI9))+yYh;w)fc9
z@;&mgBJ9-IGkE?=okr*9pQ!zDb)TM0lGuL+F+3J~JH9x(5_aD1Z6`}>VZSz`%=XSD
z9xJ*KglcM$}jK(3ibf+3~v9_m#aJM9F)~mR{8H
zm4iX_Lc;DF86P
zFS%Wnz0Wc`MR=VcoV6aDxDTA`=odBC&~Of`TNFgwpt2+hNxYUofk
zicmE>6rz6uIOvKHeFD%Pk95`u;9oK)wJ1b68$1G_C1Gnoce2u;kF`5muVpSm*G@|X
zz&{?GT>w0Qg_F94#S?9To5mKnt3p9d=TH(LYx0D%tpPw^zem~9+5=6-Numh+8R4X$
z+bHnMjp8*?7NdR_J$?w0uoQ=8eDGPqQ?B#Vt;`sFh!wKfA}-Mnc`-9nrkMu@!c9w_
z&)1oS5gJ-86JN0cH_yYB<8Tp0rb_ADY-lQKQX-+7T|d&ysoBc*r1W-`162nJU`!e-
z@x%T!XG$GEX@%b4EqVZAAw#^+fhO}9XCa3drpOZaWRjC?X}Q~Ld)@fT(&&(Jj7Ul&
zli@+TCc;CW#{XK>X8%)YD7)SDJ*gb8-}fVtM@l)5l-KFZak#uj%i{6n87vilE(cb|
z&+{fMM)}XJAW2bH=IXLub6Z-~<)ZqPqQn#Z<_=u(}Ptp2~F%gwd^$?x51W
zi>zf5O~DUTGOB9h709jiV9PDk%83=Yb9t20Q0)pD+l~F-;oTUt;hAwd!xw_zPJ$hO
z0<`~?#hj@urb;2c7{cvv0vdW_6J_aWae2$xM0FaTnP%sK-}%-?
z&82UY$P4{eOI2E}uqU>=G@os?wzj=){*R
z#T36LitpK!Dmo!?@D1!_yg=R_2Es9rdj>2e;7O)TQN^ywlq;?RxC0fc2<}kzAdB!l
zw@NCVYOgE!JUAlC=BqdOv@6>z8HnEC($mND~zOY?Itw8=?99&)J?`arh1u-N6iL1BZ>bk6p4!)zedx
zJx?~7oabvhnwwP|d9I7f^Tp<+kF>FAqAae)2k7E^+I+IQO5?y{8$SHt^frYUlX=l5
zs^`(L9y$%6l!Z~$RRm}pGC~C%&;z=C)S~UW{e~DDs1d&a;a`aV1Fg}jgVx@Gj25?T
z?;@+A_D!mEQoIGgb_m*Au=XB$+y~}Go8=Fv_90l&t%GpT*=HLzhB?FLi^QZ-`o5H=
zRO=k&fs`NDN#0m2&dEMNhKW1H@WojiuEi&Vt8l0iRB#d1x|lVv(EhhTFJ3oA-@u>P
Iygb2w0`Az(xBvhE
literal 0
HcmV?d00001
diff --git a/__pycache__/morphology.cpython-36.pyc b/__pycache__/morphology.cpython-36.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..005d0be2ce8c86863e65281675c1736afe34f841
GIT binary patch
literal 1622
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