• 刻字机尖角补偿

    1 刻字机尖角补偿原理

    刀具切割直线段过渡方法在文章旋转偏心裁切刀切向跟踪及半径补偿 已经有过说明。刻字机由于刀具半径的影响，切割直角时会不直会比较圆滑，而且在闭合曲线的下刀点会容易不闭合。使用尖角补偿可以克服这些问题。

    如上图所示，切割俩条相邻线段AB和BC时，刀心需要走的轨迹是从A' --> B' --> B'' -->C'。由于刻字机使用的刻刀刀尖半径都比较小，而且刀具也是固定没有转动轴控制转动，所以从B'过渡到B''时使用圆弧进行过渡。这里B2和B1都是圆弧上的过渡点。示意图中从B'B''采用小线段B'B2、B2B1、B1B''进行圆弧拟合过渡。

    AB的矢量角α，则A'点坐标为(Xa+r*cosα,Ya+r*sinα)。BC的矢量角为β,则B''的坐标为(Xb+r*cosβ,Yb+r*sinβ)。C'的坐标为(Xc+r*cosβ,Yc+r*sinβ）。AB的转角为β-α。

    2 尖角补偿python程序实现

    1. import numpy
    2. import cv2
    3. import math
    4.  
    5. const_ratio = 10
    6. WIDTH = 100
    7. HEIGHT = 60
    8. KNIFE_CIR = 40 #plt中40个单位=1mm
    9. ANGLE_STEP = 30 #圆弧过渡时插补间隔30度
    10.  
    11. def show_img(window,img):
    12.     cv2.namedWindow(window,0)
    13.     cv2.resizeWindow(window,int(img.shape[1]),int(img.shape[0]))
    14.     cv2.imshow(window,img)
    15.  
    16. def proc_line(line):
    17.     i = 0
    18.     signZ = 1
    19.     if len(line) == 0:
    20.         return None
    21.     while line[i]<'0' or line[i]>'9':
    22.         if line[i] == 'U':
    23.             signZ = 0
    24.         if line[i] == '-':
    25.             break
    26.         i = i+1
    27.         if i == len(line):
    28.             return None
    29.         
    30.     line = line[i:]
    31.     if len(line) == 0:
    32.         return None
    33.     strs = line.split(',')
    34.     if len(strs) != 2:
    35.         return None
    36.     axis_y = int(strs[0])
    37.     axis_x = int(strs[1])
    38.     
    39.     if (axis_x is None) or (axis_y is None):
    40.         return None
    41.     return {'x':axis_x,'y':axis_y,'z':signZ}
    42.  
    43. def plot_plt(cv_img,data,print_width,print_height):
    44.     height_total = print_height
    45.     width_total = print_width
    46.     line = ""
    47.     comma = 0
    48.     points = []
    49.     for i in range(len(data)):
    50.         try:
    51.             ch = chr(data[i])
    52.         except:
    53.             ch = data[i]
    54.         if ch == ';':
    55.             point = proc_line(line)
    56.             if point is not None:
    57.                 points.append(point)
    58.             line = ""
    59.             comma = 0
    60.         else:
    61.             line = line+ch
    62.             if ch==',' or ch==' ':
    63.                 comma = comma+1
    64.             if comma == 2:
    65.                 point = proc_line(line)
    66.                 if point is not None:
    67.                     points.append(point)
    68.                 line = ""
    69.                 comma = 0
    70.     max_x = points[0]['x']
    71.     max_y = points[0]['y']
    72.     min_x = points[0]['x']
    73.     min_y = points[0]['y']
    74.    
    75.     for point in points:
    76.         if point['x']>max_x:
    77.             max_x = point['x']
    78.         if point['y']>max_y:
    79.             max_y = point['y']
    80.         if point['x']
    81.             min_x = point['x']
    82.         if point['y']
    83.             min_y = point['y']
    84.     print(max_x,max_y,min_x,min_y)
    85.  
    86.     pre_point = points[0]
    87.     black = (0,255,0)
    88.     
    89.     offset_x = 10*const_ratio
    90.     offset_y = 10*const_ratio
    91.  
    92.     for point in points:
    93.         x = int((point['x'])*const_ratio/40+offset_x)
    94.         y = int((point['y'])*const_ratio/40+offset_y)
    95.         if point['z'] == 1:
    96.             cv2.line(cv_img,(pre_point['x'],pre_point['y']),(width_total*const_ratio-x,height_total*const_ratio-y),black,lineType=cv2.LINE_AA)
    97.         pre_point = {'x':width_total*const_ratio-x,'y':height_total*const_ratio-y}
    98.  
    99. def plot_file(img,filepath):
    100.     with open(filepath) as f:
    101.         data = f.read()
    102.         plot_plt(img,data,WIDTH,HEIGHT)
    103.  
    104. def plot_plt_comp(cv_img,data,print_width,print_height):
    105.     height_total = print_height
    106.     width_total = print_width
    107.     line = ""
    108.     comma = 0
    109.     points = []
    110.     for i in range(len(data)):
    111.         try:
    112.             ch = chr(data[i])
    113.         except:
    114.             ch = data[i]
    115.         if ch == ';':
    116.             point = proc_line(line)
    117.             if point is not None:
    118.                 points.append(point)
    119.             line = ""
    120.             comma = 0
    121.         else:
    122.             line = line+ch
    123.             if ch==',' or ch==' ':
    124.                 comma = comma+1
    125.             if comma == 2:
    126.                 point = proc_line(line)
    127.                 if point is not None:
    128.                     points.append(point)
    129.                 line = ""
    130.                 comma = 0
    131.     max_x = points[0]['x']
    132.     max_y = points[0]['y']
    133.     min_x = points[0]['x']
    134.     min_y = points[0]['y']
    135.    
    136.     for point in points:
    137.         if point['x']>max_x:
    138.             max_x = point['x']
    139.         if point['y']>max_y:
    140.             max_y = point['y']
    141.         if point['x']
    142.             min_x = point['x']
    143.         if point['y']
    144.             min_y = point['y']
    145.     print(max_x,max_y,min_x,min_y)
    146.  
    147.     #这里开始执行尖角补偿插补计算
    148.     angleArr = []
    149.     pointNum = len(points)
    150.     pre_point = {'x':0,'y':0,'z':0}
    151.     pre_angle = 0
    152.     downPoint = None
    153.     downAngle = 0
    154.     off_x = 0
    155.     off_y = 0
    156.     pointsInterpArr = []
    157.     for i in range(pointNum):
    158.         point = points[i]
    159.         angle = math.atan2(point['y']-pre_point['y'],point['x']-pre_point['x'])
    160.         length = math.sqrt((point['y']-pre_point['y'])*(point['y']-pre_point['y'])+(point['x']-pre_point['x'])*(point['x']-pre_point['x']))
    161.         angleArr.append(angle)
    162.         angle_delta = (angle-pre_angle)*180/math.pi
    163.         if angle_delta >= 180:
    164.             angle_delta = angle_delta-360
    165.         elif angle_delta <= -180:
    166.             angle_delta = angle_delta+360
    167.         if angle_delta>0:
    168.             angle_step = ANGLE_STEP
    169.         else:
    170.             angle_step = -ANGLE_STEP
    171.         print(angle_delta,length)
    172.         if length == 0:
    173.             continue
    174.         elif point['z'] == 0: #抬刀时不处理
    175.             pointsInterpArr.append(point)
    176.         elif pre_point['z'] == 0:#由抬刀变为下刀保存下刀点坐标和角度，并进行起点和终点偏移
    177.             downPoint = pre_point
    178.             downAngle = angle
    179.             x1=pre_point['x']+KNIFE_CIR*math.cos(angle)
    180.             y1=pre_point['y']+KNIFE_CIR*math.sin(angle)
    181.             pointsInterpArr.append({'x':int(x1),'y':int(y1),'z':0})
    182.             x2 = point['x']+KNIFE_CIR*math.cos(angle)
    183.             y2 = point['y']+KNIFE_CIR*math.sin(angle)
    184.             pointsInterpArr.append({'x':int(x2),'y':int(y2),'z':1})
    185.             off_x = KNIFE_CIR*math.cos(angle)
    186.             off_y = KNIFE_CIR*math.sin(angle)
    187.         elif abs(angle_delta)>30:#下刀切割时线段转角大于30度时进行圆弧过渡
    188.             count = math.floor(angle_delta/angle_step)
    189.             remain = angle_delta-count*angle_step
    190.             for j in range(0,count):
    191.                 x = pre_point['x']+KNIFE_CIR*math.cos(pre_angle+angle_step*(j+1)*math.pi/180)
    192.                 y = pre_point['y']+KNIFE_CIR*math.sin(pre_angle+angle_step*(j+1)*math.pi/180)
    193.                 pointsInterpArr.append({'x':int(x),'y':int(y),'z':1})
    194.             if abs(remain) > 0.1:
    195.                 x = pre_point['x']+KNIFE_CIR*math.cos(angle)
    196.                 y = pre_point['y']+KNIFE_CIR*math.sin(angle)
    197.                 pointsInterpArr.append({'x':int(x),'y':int(y),'z':1})
    198.             
    199.             delta_x = KNIFE_CIR*math.cos(angle)
    200.             delta_y = KNIFE_CIR*math.sin(angle)
    201.             pointsInterpArr.append({'x':int(point['x']+delta_x),'y':int(point['y']+delta_y),'z':point['z']})  
    202.  
    203.             off_x = KNIFE_CIR*math.cos(angle)
    204.             off_y = KNIFE_CIR*math.sin(angle)
    205.         else:#转角小于30度直接过渡
    206.             delta_x = KNIFE_CIR*math.cos(angle)
    207.             delta_y = KNIFE_CIR*math.sin(angle)
    208.             pointsInterpArr.append({'x':int(point['x']+delta_x),'y':int(point['y']+delta_y),'z':point['z']}) 
    209.  
    210.         #发现是下刀点坐标时代表曲线段闭合，进行闭合圆弧过渡
    211.         if downPoint != None and length > 0 and point['x'] == downPoint['x'] and point['y'] == downPoint['y']:
    212.             angle_delta = (downAngle-angle)*180/math.pi
    213.             if angle_delta >= 180:
    214.                 angle_delta = angle_delta-360
    215.             elif angle_delta <= -180:
    216.                 angle_delta = angle_delta+360
    217.             if angle_delta>0:
    218.                 angle_step = ANGLE_STEP
    219.             else:
    220.                 angle_step = -ANGLE_STEP
    221.             count = math.floor(angle_delta/angle_step)
    222.             remain = angle_delta-count*angle_step
    223.             for j in range(0,count):
    224.                 x = point['x']+KNIFE_CIR*math.cos(angle+angle_step*(j+1)*math.pi/180)
    225.                 y = point['y']+KNIFE_CIR*math.sin(angle+angle_step*(j+1)*math.pi/180)
    226.                 pointsInterpArr.append({'x':int(x),'y':int(y),'z':1})
    227.             if abs(remain) > 0.1:
    228.                 x = point['x']+KNIFE_CIR*math.cos(downAngle)
    229.                 y = point['y']+KNIFE_CIR*math.sin(downAngle)
    230.                 pointsInterpArr.append({'x':int(x),'y':int(y),'z':1})
    231.         pre_point = point
    232.         pre_angle = angle
    233.  
    234.     pre_point = pointsInterpArr[0]
    235.     black = (0,255,0)
    236.     
    237.     offset_x = 10*const_ratio
    238.     offset_y = 10*const_ratio
    239.  
    240.     max_x = pointsInterpArr[0]['x']
    241.     max_y = pointsInterpArr[0]['y']
    242.     min_x = pointsInterpArr[0]['x']
    243.     min_y = pointsInterpArr[0]['y']
    244.     for point in pointsInterpArr:
    245.         if point['x']>max_x:
    246.             max_x = point['x']
    247.         if point['y']>max_y:
    248.             max_y = point['y']
    249.         if point['x']
    250.             min_x = point['x']
    251.         if point['y']
    252.             min_y = point['y']
    253.     print(max_x,max_y,min_x,min_y)
    254.  
    255.     for point in pointsInterpArr:
    256.         x = int((point['x'])*const_ratio/40+offset_x)
    257.         y = int((point['y'])*const_ratio/40+offset_y)
    258.         if point['z'] == 1:
    259.             cv2.line(cv_img,(pre_point['x'],pre_point['y']),(width_total*const_ratio-x,height_total*const_ratio-y),black,lineType=cv2.LINE_AA)
    260.         pre_point = {'x':width_total*const_ratio-x,'y':height_total*const_ratio-y}
    261.  
    262. def plot_file_comp(img,filepath):
    263.     with open(filepath) as f:
    264.         data = f.read()
    265.         plot_plt_comp(img,data,WIDTH,HEIGHT)
    266.  
    267. cv_img = numpy.ones((HEIGHT*const_ratio,WIDTH*const_ratio),dtype=numpy.uint8)
    268. cv_img = cv2.bitwise_not(cv_img)
    269. cv2.rectangle(cv_img,(0,0),(WIDTH*const_ratio-1,HEIGHT*const_ratio-1),(0,0,0))
    270.  
    271. file = 'C:/Users/liuzj/Desktop/plt/rec.plt'
    272. plot_file(cv_img,file)
    273. show_img('img1',cv_img)
    274.  
    275.  
    276. cv_img2 = numpy.ones((HEIGHT*const_ratio,WIDTH*const_ratio),dtype=numpy.uint8)
    277. cv_img2 = cv2.bitwise_not(cv_img2)
    278. cv2.rectangle(cv_img2,(0,0),(WIDTH*const_ratio-1,HEIGHT*const_ratio-1),(0,0,0))
    279.  
    280. plot_file_comp(cv_img2,file)
    281. show_img('img2',cv_img2)
    282.  
    283.  
    284.  
    285. cv2.waitKey(0)

    正方形尖角补偿轨迹：

    三角形尖角补偿轨迹：

    方圆尖角补偿轨迹：

  • 相关阅读:
    Go 语言 设计模式-生成器模式
    NFT Insider #64：电商巨头eBay提交NFT相关商标申请，毕马威将在Web3和元宇宙中投入3000万美元
    CPP-Templates-2nd--第十九章 萃取的实现 19.4-19.5
    基于人工蜂群算法的新型概率密度模型的无人机路径规划（Matlab代码实现）
    PaddleOCR系列-训练模型并部署android手机
    m基于16QAM的自适应波束形成matlab仿真
    计算机网络基础（二）：物理层、数据链路层及网络层
    最新SparkAI创作系统V2.6.2/ChatGPT网站系统H5源码+微信公众号版+AI绘画系统源码/支持GPT联网提问/支持Prompt应用
    16.预处理、动态库、静态库
    ZeroTier CentOS7 网关机配置
  • 原文地址：https://blog.csdn.net/liuzhijun301/article/details/132889246