在哪里可以找到Chaikin的切角算法的Python实现？ [英] Where to find Python implementation of Chaikin's corner cutting algorithm?

问题描述

我正在寻找Chaikin的切角算法（

 导入数学
 
＃可视化
导入matplotlib.pyplot as plt 
导入matplotlib.lines作为行
＃可视化
 
 def Sum_points（P1，P2）：
 x1，y1 = P1 
 x2，y2 = P2 
 return x1 + x2，y1 + y2 
 
 def Multiply_point（乘数， P）：
x，y = P 
 return float（x）* float（乘数），float（y）* float（乘数）
 
 def Check_if_object_is_polygon（Cartesian_coords_list）：
，如果Cartesian_coords_list [0] == Cartesian_coords_list [len（Cartesian_coords_list）-1]：
返回True 
否则：
返回False 
 
类Object（） ：
 
 def __init __（self，Carte sian_coords_list）：
 self.Cartesian_coords_list = Cartesian_coords_list 
 
 def Find_Q_point_position（self，P1，P2）：
 Summand1 = Multiply_point（float（3）/ float（4），P1） 
 Summand2 = Multiply_point（float（1）/ float（4），P2）
 Q = Sum_points（Summand1，Summand2）
 return Q 
 
 def Find_R_point_position（self ，P1，P2）：
 Summand1 = Multiply_point（float（1）/ float（4），P1）
 Summand2 = Multiply_point（float（3）/ float（4），P2）
 R = Sum_points（Summand1，Summand2）
返回R 
 
 def Smooth_by_Chaikin（自我，number_of_refinements）：
改进= 1 
 copy_first_coord = Check_if_object_is_polygon（self.Cartesian_coords_list）
而精炼< =精炼数量：
 self.New_cartesian_coords_list = [] 
 
 for num，枚举中的元组（self.Cartesian_coords_list）：
如果num + 1 ==升en（self.Cartesian_coords_list）：
通过
其他：
 P1，P2 =（元组，self.Cartesian_coords_list [num + 1]）$ ​​b $ b Q = obj.Find_Q_point_position（P1， P2）
 R = obj.Find_R_point_position（P1，P2）
 self.New_cartesian_coords_list.append（Q）
 self.New_cartesian_coords_list.append（R）
 
如果copy_first_coord ：
 self.New_cartesian_coords_list.append（self.New_cartesian_coords_list [0]）
 
 self.Cartesian_coords_list = self.New_cartesian_coords_list 
优化+ = 1 
 return self.Cartesian_coords_list b 
 $ b如果__name__ == __main__：
 Cartesian_coords_list = [（1,1），
（1,3），
（4,5），
（5,1），
（2,0.5），
 （1,1），
] 
 
 obj =对象（Cartesian_coords_list）
 Smoothed_obj = obj.Smooth_by_Chaikin（number_of_refinements = 5）
 
＃可视化
 x1 = [i对i，j在Smoothed_obj中] i 
 y1 = [i对i，j在Smoothed_obj中] 
 x2 = [i对i，j在Cartesian_coords_list中] 
 y2 = [用于笛卡尔坐标列表中的i，j的j] 
 plt.plot（range（7），range（7），'w'，alpha = 0.7）
 myline = lines.Line2D（x1，y1，color ='r'）
 mynewline = lines.Line2D（x2，y2，color ='b'）
 plt.gca（）。add_artist（myline）
 plt.gca（）。add_artist （mynewline）
 plt.show（）
  

I am looking for Chaikin's corner cutting algorithm (link1, link2) implemented in Python 2.7.X but can't find it.

Maybe someone have it and able share the code?

解决方案

Ok, it wasn't so hard, here is the code:

import math

# visualisation
import matplotlib.pyplot as plt
import matplotlib.lines as lines
# visualisation

def Sum_points(P1, P2):
    x1, y1 = P1
    x2, y2 = P2
    return x1+x2, y1+y2

def Multiply_point(multiplier, P):
    x, y = P
    return float(x)*float(multiplier), float(y)*float(multiplier)

def Check_if_object_is_polygon(Cartesian_coords_list):
    if Cartesian_coords_list[0] == Cartesian_coords_list[len(Cartesian_coords_list)-1]:
        return True
    else:
        return False

class Object():

    def __init__(self, Cartesian_coords_list):
        self.Cartesian_coords_list = Cartesian_coords_list

    def Find_Q_point_position(self, P1, P2):
        Summand1 = Multiply_point(float(3)/float(4), P1)
        Summand2 = Multiply_point(float(1)/float(4), P2)
        Q = Sum_points(Summand1, Summand2) 
        return Q

    def Find_R_point_position(self, P1, P2):
        Summand1 = Multiply_point(float(1)/float(4), P1)
        Summand2 = Multiply_point(float(3)/float(4), P2)        
        R = Sum_points(Summand1, Summand2)
        return R

    def Smooth_by_Chaikin(self, number_of_refinements):
        refinement = 1
        copy_first_coord = Check_if_object_is_polygon(self.Cartesian_coords_list)
        while refinement <= number_of_refinements:
            self.New_cartesian_coords_list = []

            for num, tuple in enumerate(self.Cartesian_coords_list):
                if num+1 == len(self.Cartesian_coords_list):
                    pass
                else:
                    P1, P2 = (tuple, self.Cartesian_coords_list[num+1])
                    Q = obj.Find_Q_point_position(P1, P2)
                    R = obj.Find_R_point_position(P1, P2)
                    self.New_cartesian_coords_list.append(Q)
                    self.New_cartesian_coords_list.append(R)

            if copy_first_coord:
                self.New_cartesian_coords_list.append(self.New_cartesian_coords_list[0])

            self.Cartesian_coords_list = self.New_cartesian_coords_list
            refinement += 1
        return self.Cartesian_coords_list

if __name__ == "__main__":
    Cartesian_coords_list = [(1,1),
                             (1,3),
                             (4,5),
                             (5,1),
                             (2,0.5),
                             (1,1),
                             ]

    obj = Object(Cartesian_coords_list)    
    Smoothed_obj = obj.Smooth_by_Chaikin(number_of_refinements = 5)

    # visualisation
    x1 = [i for i,j in Smoothed_obj]
    y1 = [j for i,j in Smoothed_obj]
    x2 = [i for i,j in Cartesian_coords_list]
    y2 = [j for i,j in Cartesian_coords_list]    
    plt.plot(range(7),range(7),'w', alpha=0.7)
    myline = lines.Line2D(x1,y1,color='r')
    mynewline = lines.Line2D(x2,y2,color='b')
    plt.gca().add_artist(myline)
    plt.gca().add_artist(mynewline)
    plt.show()  

这篇关于在哪里可以找到Chaikin的切角算法的Python实现？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！