python 讀取坐標數據畫出最大面積的輪廓

項目要求，現需要一個能根據Excel的坐標數據，在圖像上進行描點連線，並且連線的方式是以所有的點進行最大輪廓連線。現在實現了要求，但是由於代碼寫得太亂，我只是簡單的說一下實現算法就好了，代碼也會貼出來，時間過於久，我也有些地方忘記了，但是整體算法還是記得的~

下面開始簡單的說一下：

首先，所有點的坐標數據就像下圖所示：

 

 

 

 問題：如何將所有的點以最大的輪廓連線呢？？

 思路：應該是數學問題，如何將坐標列表重新排序成以最大輪廓的坐標列表，因為matplotlib庫可以根據一個列表里面的坐標數據直接生成連線。

我的排序算法是：

1.首先，將所有坐標進行排序，可以以x排序，然后找到最左邊的坐標點和最右邊的坐標；

2.以最左邊和最右邊的坐標進行求解方程，兩點確定一條直線，就是求該直線的方程；

3.將剩余的所有坐標x代入步驟2的方程組，求出解和坐標y進行比較，將線下方的點和上方的點坐標分別求出來，然后存入一個列表備份；

4.將下方坐標的列表進行排序，由小到大，然后存入一個最終列表中，最終列表第一個肯定是最左邊的點，然后就是下方的點；

5.將下方坐標的列表進行排序，由大到小，然后繼續分別存入最終列表，最后在最終列表中在加上最左邊的坐標點，使連線閉合；

6.然后用matplotlib里面的pyplot函數，將最終列表連線即可。

上面的算法我寫在了一個函數里面，這是非常不對的，但是如今還是不想將其整理出來，哈哈，思維不亂就行~~

        try:
            # 先提取成一個個位置坐標
            coordinate = []
            for i in range(len(x)):
                coordinate.append([x[i], y[i]])

            # print(coordinate)

            # 這是基准列表，x最小最大，y最小最大
            sort_list = []
            # 剩下的坐標數據
            ret_list = []
            # 下方的點數據
            under_list = []
            # 總的排序結果
            final_list = []
            # 臨時列表
            temp = []

            # 下方的點
            down_dot = []
            # 上方的點
            up_dot = []

            y_max_and_y_min = []

            # 進行x排序
            sort_x(coordinate)

            # 排序完成肯定是第一個最小，最后一個最大，將這兩個數據添加到確定的基准列表里面
            sort_list.append(coordinate[0])
            sort_list.append(coordinate[len(coordinate) - 1])

            # 這下面進行以y大小進行排序，，重新存儲在一個新列表里面
            sort_y(coordinate)
            y_max_and_y_min.append(coordinate[0])
            y_max_and_y_min.append(coordinate[len(coordinate) - 1])

            # 這句代碼實現的功能是和基准列表進行比對，求除了基准列表剩下的所有坐標數據
            ret_list = [item for item in coordinate if item not in sort_list] + [item for item in sort_list if
                                                                                 item not in coordinate]

            print("確定的坐標：" + str(sort_list))

            print("剩余的坐標: " + str(ret_list))

            # 最左坐標
            left_x = sort_list[0][0]
            left_y = sort_list[0][1]

            # 最右坐標
            right_x = sort_list[1][0]
            right_y = sort_list[1][1]

            # 最下坐標
            down_x = y_max_and_y_min[0][0]
            down_y = y_max_and_y_min[0][1]

            # 最上坐標
            up_x = y_max_and_y_min[1][0]
            up_y = y_max_and_y_min[1][1]

            # 實現兩點之間的公式
            # y = k*x + b

            # 總判斷公式，，蠻重要
            k = (right_y - left_y) / (right_x - left_x)
            b = left_y - k * left_x

            print("y=" + str(k) + "x" + '+' + str(b))

            # 開始進行比對，判斷剩余列表里面的每一個點，如果在直線下方，就加入下方列表里面
            for i in range(len(ret_list)):
                # print(ret_list[i])
                if (under(k, b, ret_list[i])):
                    under_list.append(ret_list[i])

            print("下面列表的數據", under_list)

            # 對下方列表再以x為基准進行排序
            under_list = sort_x(under_list)

            # 排序完成直接都添加到確定的列表里面，先添加一個最左的坐標，在循環結束之后再添加最右的數據
            final_list.append(sort_list[0])

            for t in under_list:
                final_list.append(t)
                # 邊添加還邊讓數據從剩余列表里面去掉
                ret_list.remove(t)

            final_list.append(sort_list[1])

            ################################################################################
            # 到此，，下方的排序已經結束
            print(final_list)
            num_under = len(final_list)

            print(ret_list)

            # 剩下的列表進行冒泡排序，還是由小到大，但是最后翻轉一下列表就可以
            ret_list = sort_x(ret_list)
            ret_list = (list(reversed(ret_list)))

            print(ret_list)

            for t in ret_list:
                """將剩下的坐標添加到處理后的列表里面"""
                final_list.append(t)

            # 這個是再補一個坐標，使曲線閉合
            final_list.append(sort_list[0])

            print(ret_list)
            print("最終列表-----------", final_list)

            # 分離后的x,y坐標數據
            final_x = []
            final_y = []

            for i in range(len(final_list)):
                """將坐標數據從新分離成兩個列表"""
                final_x.append(final_list[i][0])
                final_y.append(final_list[i][1])

            # print(final_x)
            # print(final_y)

            # 在這需要將列表翻裝一下，調試好久才發現
            final_list = list(reversed(final_list))

            # 將圖像顯示出來
            # showResult(final_x, final_y,'title', 'x', 'y')

連線起來的最終效果圖：

 

項目要求2： 判斷一個點是否在所圍的輪廓內。

實現方法：

1.首先判斷是否在x坐標是否在最左，最右之間，y坐標是否在最上，最下坐標之間，如果不在，直接判定不在；

2.判斷是否為原來數據的點，如果是直接判定在輪廓內；

3.然后將需要判斷的坐標代入最左最右組成的方程上，判斷該坐標是該直線的上方還是下方。

4.若在下方，判斷在下方的坐標點哪兩個坐標之間，根據左右兩個坐標點進行直線方程的求解，然后將需判斷坐標的x代入，求解是否大於y坐標，如果大於就判定是在輪廓里面；

5.若在上方，判定條件改成小於才在輪廓里面；

 

代碼如下：

# 下面進行判斷一個點是否在圈內
            # x_judge = 0.396
            # y_judge = 0.592

            x_get = self.input_x.text()
            y_get = self.input_y.text()

            if (len(x_get)==0):
                QMessageBox.critical(self, 'reslult', '請輸入x，y')
                x_judge = final_x[0]
                y_judge = final_y[0]
                judge = [float(x_judge), float(y_judge)]
                self.input_x.setText(str(x_judge))
                self.input_y.setText(str(y_judge))
            else:
                x_judge = float(x_get)
                y_judge = float(y_get)

                judge = [float(x_judge), float(y_judge)]

            if judge == sort_list[0] or judge == sort_list[1] or judge == y_max_and_y_min[0] or judge == \
                    y_max_and_y_min[1]:
                """先判斷是否是基准點"""
                print("在--相等")
                flag=True
                QMessageBox.critical(self,'reslult' , 'in')
            elif is_midle(judge[0], left_x, right_x) and is_midle(judge[1], down_y, up_y):
                """先判斷是否在大圈之內"""
                # 先判斷是在上方的點還是上方的點，如果在下方用下方的公式，否則，相反
                if not under(k, b, judge):
                    print("在下方")
                    for i in range(len(down_dot) - 1):
                        if is_midle(judge[0], down_dot[i][0], down_dot[i + 1][0]):
                            # print(down_dot[i][0],down_dot[i+1][0])
                            print(down_dot[i], down_dot[i + 1])
                            k_test, b_test = generate_equation(down_dot[i], down_dot[i + 1])
                            print(k_test, b_test)
                            if not (under(k_test, b_test, judge)):
                                print("不在")
                                flag = False
                                QMessageBox.critical(self,'reslult' , 'not in')
                                break
                            else:
                                print("在")
                                flag = True
                                QMessageBox.critical(self, 'reslult' ,'in')
                                break
                        else:
                            pass
                elif not up_under(k, b, judge):
                    print("在上方")
                    for i in range(len(up_dot) - 1):
                        if is_midle(judge[0], up_dot[i + 1][0], up_dot[i][0]):
                            print(up_dot[i], up_dot[i + 1])
                            k_test, b_test = generate_equation(up_dot[i], up_dot[i + 1])
                            print(k_test, b_test)
                            if (up_under(k_test, b_test, judge)):
                                print("在")
                                flag = True
                                QMessageBox.critical(self, 'reslult' ,'in')
                                break
                            else:
                                print("不在")
                                flag=False
                                QMessageBox.critical(self,'reslult' , 'not in')
                                break
                        else:
                            pass

            else:
                print("不在")
                flag = False
                QMessageBox.critical(self,'reslult' ,'not in')


            if (flag == True):
                plt.scatter(x_judge, y_judge, color='green', marker='o')
            elif (flag == False):
                plt.scatter(x_judge,y_judge,color='red',marker='o')

            plt.plot(final_x, final_y, color='black', linewidth=2.0)
            plt.scatter(final_x, final_y, color='black', marker='+')
            plt.title(str(flag))
            plt.xlabel('x')
            plt.ylabel('y')
            for x1, y1 in zip(final_x, final_y):
                plt.text(x1,y1, str(x1), ha='center', va='bottom', fontsize=10.5)
            for x2, y2 in zip(final_x, final_y):
                plt.text(x2+0.1,y2, str(y2), ha='center', va='bottom', fontsize=10.5)


            plt.show()

 

至此，項目的要求算為完成，然后組成了GUI界面，所用的庫是PYQT5。其實這個庫真的挺好用的。

 

 

 

說下打包成exe 的時候遇到的問題，最新版的matplotlib庫用pyinstaller根據打包不成功，如果按照網上的說法一個個依賴去尋找，太過於麻煩，

我查了半天資料，發現有個大佬說舊版的matplotlib可以，我連忙卸載新版的，下載舊版的，打包，，成功。就很完美~~~

至此，項目結束。

 

完成代碼我放在了我的網盤上，有點點亂~下面是網盤鏈接：

https://wws.lanzous.com/i7xTKiz7o7g