xld曲线平滑

已于 2022-11-22 17:51:13 修改
阅读量750 收藏 6
点赞数
文章标签： c++ 算法
于 2022-11-22 17:42:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/myCSDNloveletter/article/details/127986954
版权

基于halcon样条曲线的xld轮廓平滑

1，主要方法：根据轮廓点的角度判断是否需要平滑，由不需要平滑的点将轮廓分段平滑。

对于大角度的轮廓需要在角点周围新添加节点，以便更好的平滑。


*求角点--方法3--求当前点角度---先平滑轮廓后均分轮廓--精确
dev_update_off ()
dev_update_time ('off')
count_seconds (Seconds)
MaxCha:=0.01
JunV:=0.1
count_obj (Contours, Number)
x:=[]
y:=[]
* dev_update_on ()
limAng:=150
*所有角度
ang_re:=[]
*单个轮廓角点下标
indexics:=[]
*设定边长--角点角度小于该值直接平滑
dispp:=0.5
*限定长度
Dislimt:=1
*根据线长舍弃的角度下标
* m_indexs:=[]
*是否是闭合轮廓标志
isclose:=0
*离散精度
prece:=0.02
*需要删除的下标
m_delIndex:=[]
*平滑后轮廓
gen_empty_obj (EmptyObject2)
for Index4 := 1 to Number by 1
    select_obj (Contours, ObjectSelected1, 102)
*     write_contour_xld_dxf (ObjectSelected1, 'C:/Users/zysk/Desktop/测试')
    length_xld (ObjectSelected1, Length)
    get_contour_xld (ObjectSelected1, Row2, Col2)
    if (Row2[0]==Row2[|Row2|-1]and(Col2[0]==Col2[|Col2|-1]))
        isclose:=1    
    else
        isclose:=0
    endif
    if (|Row2|<=2)
         concat_obj (EmptyObject2, ObjectSelected1, EmptyObject2)
         continue
    endif
    indexics:=[]
    *角度在100-150度被舍弃的点需要重新设置权重
    m_angIndex:=[]
    m_angdegree:=[]
    ang_re:=[]
    *加入点个数
    m_indexnum:=0
    *是否需要去掉倒数第二个点
    isaddlastone := 0
    *添加后的点坐标
    Row:=[]
    Col:=[]
    for Index1 := 0 to |Row2|-2 by 1
        if (Index1==0)
            angle_ll (Row2[Index1], Col2[Index1], Row2[Index1+1], Col2[Index1+1], \
                      Row2[Index1], Col2[Index1], Row2[|Row2|-2], Col2[|Row2|-2], ang1)
*              gen_cross_contour_xld (Cross, Row2[|Row2|-1], Col2[|Row2|-1], 0.5, 0)
*             gen_contour_polygon_xld (Contour6, [Row2[Index1], Row2[Index1+1]], [Col2[Index1], Col2[Index1+1]])
        else
            angle_ll (Row2[Index1], Col2[Index1], Row2[Index1+1], Col2[Index1+1], \
                      Row2[Index1], Col2[Index1], Row2[Index1-1], Col2[Index1-1], ang1)
        endif
        if ((Index1==0)or(Index1==|Row2|-1))
            if (isclose)
                
            else
                ang1:=3.14
            endif
        endif
        gen_cross_contour_xld (Cross, Row2[Index1], Col2[Index1], 0.5, 0)
        ang:=deg(ang1)
        ang_re:=[ang_re,ang]
        Isadd:=0

        if ((0<=abs(ang))and(abs(ang)<=100))
            Isadd:=1
            *当线长小于设定值时，去掉该点
*             sheDinV:=0.03
*             if (Index1==0)
*                  distance_pp (Row2[Index1], Col2[Index1], Row2[Index1+1], \
                             Col2[Index1+1], Dis1)
*                  distance_pp (Row2[Index1], Col2[Index1], Row2[|Row2|-2], \
                             Col2[|Row2|-2], Dis2)
*                 if ((sheDinV>Dis1)and(sheDinV>Dis2))
*                     m_delIndex:=[m_delIndex,Index1+m_indexnum]
*                 elseif(sheDinV>Dis1)
*                     m_delIndex:=[m_delIndex,Index1+1+m_indexnum]
*                 elseif((sheDinV>Dis2))
*                     isaddlastone:=1
*                 endif
*             else
*                 distance_pp (Row2[Index1], Col2[Index1], Row2[Index1+1],\
                             Col2[Index1+1], Dis1)
*                 distance_pp (Row2[Index1], Col2[Index1], Row2[Index1-1], \
                             Col2[Index1-1], Dis2)
*                 if ((sheDinV>Dis1)and(sheDinV>Dis2))
*                     m_delIndex:=[m_delIndex,Index1+m_indexnum]
*                 elseif(sheDinV>Dis1)
*                     m_delIndex:=[m_delIndex,Index1+1+m_indexnum]
*                 elseif((sheDinV>Dis2))
*                     m_delIndex:=[m_delIndex,Index1-1+m_indexnum]
*                 endif
*             endif
        elseif ((100<abs(ang))and(abs(ang)<limAng))
             if (Index1==0)
                distance_pp (Row2[Index1], Col2[Index1], Row2[Index1+1], \
                             Col2[Index1+1], Dis1)
                distance_pp (Row2[Index1], Col2[Index1], Row2[|Row2|-2], \
                             Col2[|Row2|-2], Dis2)
                if ((Dis1>dispp)and(Dis2>dispp))
                    Isadd:=1
                else
*                     Wig:=((limAng-abs(ang))*2.0)*0.01
*                     if (Wig>0.3)
*                         m_angIndex:=[m_angIndex,Index1]
*                         m_angdegree:=[m_angdegree,Wig]
*                     endif
                    *判断是否需要添加点
                    dislim:=prece/cos(abs(ang1*0.5))
                    if (Dis2*0.5>dislim)
                        mCos:=(Col2[|Row2|-2]-Col2[Index1])/Dis2
                        mSin:=(Row2[|Row2|-2]-Row2[Index1])/Dis2
                        addx:=Col2[Index1]+mCos*dislim
                        addy:=Row2[Index1]+mSin*dislim

                        tuple_insert (Col2, |Row2|-1, addx, Col)
                        tuple_insert (Row2, |Row2|-1, addy, Row)
*                         m_indexnum:=m_indexnum+1

                        gen_cross_contour_xld (Cross, addy, addx, 0.05, 0)
                        gen_cross_contour_xld (Cross, Row, Col, 0.05, 0)
                        gen_contour_polygon_xld (Contour5, Row, Col)
                    endif
                    if (Dis1*0.5>dislim)
                        mCos:=(Col2[Index1+1]-Col2[Index1])/Dis1
                        mSin:=(Row2[Index1+1]-Row2[Index1])/Dis1
                        addx:=Col2[Index1]+mCos*dislim
                        addy:=Row2[Index1]+mSin*dislim
                        
                        if (Col==[])
                            tuple_insert (Col2, 1, addx, Col)
                            tuple_insert (Row2, 1, addy, Row)
                            m_indexnum:=m_indexnum+1
                        else
                            tuple_insert (Col, 1, addx, Col)
                            tuple_insert (Row, 1, addy, Row)
                            m_indexnum:=m_indexnum+1 
                        endif

                        
                        gen_cross_contour_xld (Cross, addy, addx, 0.05, 0)
                        gen_cross_contour_xld (Cross, Row, Col, 0.05, 0)
                        gen_contour_polygon_xld (Contour5, Row, Col)
                    endif
                endif
            else
                distance_pp (Row2[Index1], Col2[Index1], Row2[Index1+1],\
                             Col2[Index1+1], Dis1)
                distance_pp (Row2[Index1], Col2[Index1], Row2[Index1-1], \
                             Col2[Index1-1], Dis2)
                if ((Dis1>dispp)and(Dis2>dispp))
                    Isadd:=1
                else
*                     Wig:=((limAng-abs(ang))*2.0)*0.01
*                     if (Wig>0.3)
*                         m_angIndex:=[m_angIndex,Index1]
*                         m_angdegree:=[m_angdegree,Wig]
*                     endif
                    *判断是否需要添加点
                    dislim:=prece/cos(abs(ang1*0.5))
                    if (Dis2*0.5>dislim)
                        mCos:=(Col2[Index1-1]-Col2[Index1])/Dis2
                        mSin:=(Row2[Index1-1]-Row2[Index1])/Dis2
                        addx:=Col2[Index1]+mCos*dislim
                        addy:=Row2[Index1]+mSin*dislim
                        
                        
*                         addxs:=[addxs,addx]
*                         addys:=[addys,addy]
                        if (Col==[])
                            tuple_insert (Col2, Index1+m_indexnum, addx, Col)
                            tuple_insert (Row2, Index1+m_indexnum, addy, Row)
                            m_indexnum:=m_indexnum+1
                        else
                            tuple_insert (Col, Index1+m_indexnum, addx, Col)
                            tuple_insert (Row, Index1+m_indexnum, addy, Row)
                            m_indexnum:=m_indexnum+1 
                        endif
*                         m_indexnums:=m_indexnums+1
*                         gen_cross_contour_xld (Cross, addy, addx, 0.05, 0)
*                         gen_cross_contour_xld (Cross, Row, Col, 0.05, 0)
*                         gen_contour_polygon_xld (Contour5, Row, Col)
                    endif
                    if (Dis1*0.5>dislim)
                        mCos:=(Col2[Index1+1]-Col2[Index1])/Dis1
                        mSin:=(Row2[Index1+1]-Row2[Index1])/Dis1
                        addx:=Col2[Index1]+mCos*dislim
                        addy:=Row2[Index1]+mSin*dislim
                        
                        if (Col==[])
                            tuple_insert (Col2, Index1+m_indexnum+1, addx, Col)
                            tuple_insert (Row2, Index1+m_indexnum+1, addy, Row)
                            m_indexnum:=m_indexnum+1
                        else
                            tuple_insert (Col, Index1+m_indexnum+1, addx, Col)
                            tuple_insert (Row, Index1+m_indexnum+1, addy, Row)
                            m_indexnum:=m_indexnum+1 
                        endif
*                         m_indexnums:=m_indexnums+1
*                         gen_cross_contour_xld (Cross, addy, addx, 0.05, 0)
*                         gen_cross_contour_xld (Cross, Row, Col, 0.05, 0)
*                         gen_contour_polygon_xld (Contour5, Row, Col)
                    endif
                endif
            endif
        elseif ((150<=abs(ang))and(abs(ang)<175))
            gen_cross_contour_xld (Cross, Row2[Index1], Col2[Index1], 0.08, 0)
            if (Index1==0)
                distance_pp (Row2[Index1], Col2[Index1], Row2[Index1+1], \
                             Col2[Index1+1], Dis1)
                distance_pp (Row2[Index1], Col2[Index1], Row2[|Row2|-2], \
                             Col2[|Row2|-2], Dis2)

                *判断是否需要添加点
                    dislim:=prece/cos(abs(ang1*0.5))
                    if (Dis2*0.5>dislim)
                        mCos:=(Col2[|Row2|-2]-Col2[Index1])/Dis2
                        mSin:=(Row2[|Row2|-2]-Row2[Index1])/Dis2
                        addx:=Col2[Index1]+mCos*dislim
                        addy:=Row2[Index1]+mSin*dislim


                        tuple_insert (Col2, |Row2|-1, addx, Col)
                        tuple_insert (Row2, |Row2|-1, addy, Row)
                        

*                         gen_cross_contour_xld (Cross, addy, addx, 0.05, 0)
*                         gen_cross_contour_xld (Cross, Row, Col, 0.05, 0)
*                         gen_contour_polygon_xld (Contour5, Row, Col)
                    endif
                    if (Dis1*0.5>dislim)
                        mCos:=(Col2[Index1+1]-Col2[Index1])/Dis1
                        mSin:=(Row2[Index1+1]-Row2[Index1])/Dis1
                        addx:=Col2[Index1]+mCos*dislim
                        addy:=Row2[Index1]+mSin*dislim
                        
                        if (Col==[])
                            tuple_insert (Col2, 1, addx, Col)
                            tuple_insert (Row2, 1, addy, Row)
                            m_indexnum:=m_indexnum+1
                        else
                            tuple_insert (Col, 1, addx, Col)
                            tuple_insert (Row, 1, addy, Row)
                            m_indexnum:=m_indexnum+1 
                        endif

                        
*                         gen_cross_contour_xld (Cross, addy, addx, 0.05, 0)
*                         gen_cross_contour_xld (Cross, Row, Col, 0.05, 0)
*                         gen_contour_polygon_xld (Contour5, Row, Col)
                    endif
            else
                distance_pp (Row2[Index1], Col2[Index1], Row2[Index1+1],\
                             Col2[Index1+1], Dis1)
                distance_pp (Row2[Index1], Col2[Index1], Row2[Index1-1], \
                             Col2[Index1-1], Dis2)
                *判断是否需要添加点
                dislim:=prece/cos(abs(ang1*0.5))
                if (Dis2*0.5>dislim)
                    mCos:=(Col2[Index1-1]-Col2[Index1])/Dis2
                    mSin:=(Row2[Index1-1]-Row2[Index1])/Dis2
                    addx:=Col2[Index1]+mCos*dislim
                    addy:=Row2[Index1]+mSin*dislim
                    

*                     addx:=Col2[Index1]-cos(abs(ang1*0.5))*prece
*                     addy:=Row2[Index1]+sin(abs(ang1*0.5))*prece
                    

                    if (Col==[])
                        tuple_insert (Col2, Index1+m_indexnum, addx, Col)
                        tuple_insert (Row2, Index1+m_indexnum, addy, Row)
                        m_indexnum:=m_indexnum+1
                    else
                        tuple_insert (Col, Index1+m_indexnum, addx, Col)
                        tuple_insert (Row, Index1+m_indexnum, addy, Row)
                        m_indexnum:=m_indexnum+1 
                    endif
*                     m_indexnums:=m_indexnums+1
                    gen_cross_contour_xld (Cross, addy, addx, 0.05, 0)
*                     gen_cross_contour_xld (Cross, Row, Col, 0.05, 0)
*                     gen_contour_polygon_xld (Contour5, Row, Col)
                endif
                if (Dis1*0.5>dislim)
                    mCos:=(Col2[Index1+1]-Col2[Index1])/Dis1
                    mSin:=(Row2[Index1+1]-Row2[Index1])/Dis1
                    addx:=Col2[Index1]+mCos*dislim
                    addy:=Row2[Index1]+mSin*dislim
                    
                    if (Col==[])
                        tuple_insert (Col2, Index1+m_indexnum+1, addx, Col)
                        tuple_insert (Row2, Index1+m_indexnum+1, addy, Row)
                        m_indexnum:=m_indexnum+1
                    else
                        tuple_insert (Col, Index1+m_indexnum+1, addx, Col)
                        tuple_insert (Row, Index1+m_indexnum+1, addy, Row)
                        m_indexnum:=m_indexnum+1 
                    endif
*                     m_indexnums:=m_indexnums+1
*                     gen_cross_contour_xld (Cross, addy, addx, 0.05, 0)
*                     gen_cross_contour_xld (Cross, Row[Index1+m_indexnum], Col[Index1+m_indexnum], 0.05, 0)
*                     gen_contour_polygon_xld (Contour5, Row, Col)
                endif
            endif
            
        endif
        
        
*         gen_cross_contour_xld (Cross, Row2[Index1], Col2[Index1], 0.08, 0)
*/添加序号有问题
*         gen_cross_contour_xld (Cross, Row[indexics[3]], Col[indexics[3]], 0.08, 0)
        if (Isadd==1)
            x:=[x,Col2[Index1]]
            y:=[y,Row2[Index1]]
            if ((0<=abs(ang))and(abs(ang)<=100))
                indexics:=[indexics,Index1+m_indexnum]
            else
                if (|indexics|>0)
                    if (Index1-indexics[|indexics|-1]==1)
                        distance_pp (Row2[Index1], Col2[Index1], Row2[Index1-1],\
                                     Col2[Index1-1], Dis1)
                        if (Dis1>dispp)
                            indexics:=[indexics,Index1+m_indexnum]
                        else
                            if (abs(ang_re[Index1]<abs(ang_re[Index1-1])))
                                indexics[|indexics|-1]:=Index1
                            endif
                        endif
                    else
                        indexics:=[indexics,Index1+m_indexnum]
                    endif
                else
                    indexics:=[indexics,Index1+m_indexnum]
                endif
            endif
            
        endif
    endfor
*     continue


    *平滑等级
    degree:=0.1
    gen_cross_contour_xld (Cross, y, x, 0.05, 0)
    gen_cross_contour_xld (Cross, Row[m_delIndex], Col[m_delIndex], 0.05, 0)
    gen_cross_contour_xld (Cross, Row[indexics], Col[indexics], 0.5, 0)
    gen_cross_contour_xld (Cross, Row2, Col2, 0.5, 0)
    gen_cross_contour_xld (Cross, Row, Col, 0.05, 0)
    gen_contour_polygon_xld (Contour, Row, Col)

    
*     read_tuple ('C:/Users/zysk/Desktop/hv_m_delIndex.tup', Tuple)

    if (Row!=[])
        if (isaddlastone==1)
            m_delIndex:=[m_delIndex,|Row|-2]
        endif
        tuple_uniq (m_delIndex, m_delIndex)
        tuple_intersection (m_delIndex, indexics, Intersection)
        *删除指定坐标
        tuple_difference (indexics, Intersection, indexics)
        for Index5 := 1 to |m_delIndex| by 1
            mmIndex:=m_delIndex[|m_delIndex|-Index5]
            tuple_remove (Row, mmIndex, Row)
            tuple_remove (Col, mmIndex, Col)
            for Index7 := 0 to |indexics|-1 by 1
                if (mmIndex<=indexics[Index7])
                    indexics[Index7]:=indexics[Index7]-1
                endif
            endfor
        endfor
        tuple_uniq (indexics, indexics)
        Row2:=Row
        Col2:=Col
    endif
    
        *生成需要平滑轮廓并处理
    if (|indexics|<=1)
        isok:=1
        if (|indexics|==1and(isclose==0))
            isok:=0
        endif
    else
        isok:=0
    endif
    *平滑后的轮廓点坐标and(isclose)
    if (isok)
        **没有角点的轮廓
*         m_angdegree:=[10,0.1,0.1,0.1,0.1]
       if ((|indexics|==1))
           if (indexics[0]!=0)
               tuple_gen_const (|Row2|, 0.1, wights)
               wights[m_angIndex]:= m_angdegree
*                m_addwight:=(m_angdegree+0.1)/2
*                wights[m_angIndex+1]:=m_addwight
*                wights[m_angIndex-1]:=m_addwight
               m_Row:=[]
               m_Col:=[]
               wight:=[]
               tuple_gen_sequence (0, indexics[0], 1, Sequence)
               m_Row:=[m_Row,Row2[Sequence]]
               m_Col:=[m_Col,Col2[Sequence]]
               wight:=[wight,wights[Sequence]]
               tuple_gen_sequence (indexics[0], |Row2|-2, 1, Sequence)
               m_Row:=[Row2[indexics[0]]+0.000001,Row2[Sequence],m_Row]
               m_Col:=[Col2[indexics[0]]+0.000001,Col2[Sequence],m_Col]
               wight:=[0.1,wights[Sequence],wight]
                m_degree:=round(|m_Row|*0.05)
               if (m_degree<2)
                   m_degree:= 2
               endif
               gen_contour_nurbs_xld (Contour, m_Row,m_Col, 'auto',\
                                     wight,2 ,  0.001, 'omit')
               get_contour_xld (Contour, Row4, Col4)

           else
                
                m_degree:=round(|Row2|*degree)
                if (m_degree<2)
                   m_degree:= 2
                endif
                Row2[0]:=Row2[0]+0.000001
                Col2[0]:=Col2[0]+0.000001
                tuple_gen_const (|Row2|, 0.1, wights)
                wights[m_angIndex]:= m_angdegree
                gen_contour_nurbs_xld (Contour, Row2, Col2, 'auto',\
                                 wights,2 ,  0.0005, 'omit')
                get_contour_xld (Contour, Row4, Col4)
           endif
           
*            gen_contour_polygon_xld (Contour5, Row4, Col4)
       else
           if (isclose)
                tuple_gen_const (|Row2|-1, 0.1, wights)
                wights[m_angIndex]:= m_angdegree
            else
                tuple_gen_const (|Row2|, 0.1, wights)
                wights[m_angIndex]:= m_angdegree
            endif
           m_degree:=round(|Row2|*degree)
           if (m_degree<2)
               m_degree:= 2
           endif
           gen_contour_nurbs_xld (Contour, Row2, Col2, 'auto',\
                                 'auto',  5 , 0.001 , 'omit')
           write_contour_xld_dxf (Contour, 'D:/项目/线平滑处理/图形/111.dxf')
           write_contour_xld_dxf (ObjectSelected1, 'D:/项目/线平滑处理/图形/222.dxf')
           get_contour_xld (Contour, Row4, Col4)
       endif
*        write_contour_xld_dxf (Contour, 'C:/Users/zysk/Desktop/2.dxf')
      
       gen_cross_contour_xld (Cross, Row4, Col4, 0.1, 0)
       concat_obj (EmptyObject2, Contour, EmptyObject2)
       continue
    endif
    one_R:=[]
    one_C:=[]

    for Index6 := 0 to |indexics| by 1
        if (Index6==|indexics|)
            if(isclose)
                break
            else
                tuple_gen_sequence (indexics[|indexics|-1], |Row2|-1, 1, Sequence2)
                            gen_cross_contour_xld (Cross, Row2[0], Col2[0], 0.5, 0)
            endif
        else
            if (indexics[0]!=0and(Index6==0))
                if (Row2[0]==Row2[|Row2|-1]and(Col2[0]==Col2[|Col2|-1]))
                    tuple_gen_sequence (indexics[|indexics|-1], |Row2|-1, 1, Sequence2)
                    tuple_gen_sequence (1, indexics[0], 1, Sequence3)
                    tuple_concat (Sequence2, Sequence3, Sequence2)
*                     gen_contour_polygon_xld (Contour3, Row2[Sequence2], Col2[Sequence2])
                else
                    tuple_gen_sequence (0, indexics[0], 1, Sequence2)
                endif
            else
                if (indexics[0]!=0)
                    tuple_gen_sequence (indexics[Index6-1], indexics[Index6], 1, Sequence2)
                else
                    if (Index6==|indexics|-1)
                        tuple_gen_sequence (indexics[Index6], |Row2|-1, 1, Sequence2)
                    else
                        tuple_gen_sequence (indexics[Index6], indexics[Index6+1], 1, Sequence2)
                    endif
                endif
*             gen_cross_contour_xld (Cross, Row2[0], Col2[0], 0.05, 0)
            endif
        endif
        

        if (|Sequence2|<=2)
*             distance_pp (Row2[Sequence2[0]], Col2[Sequence2[0]], Row2[Sequence2[1]],\
                             Col2[Sequence2[1]], Dis)
*             contour_mean (Row2[Sequence2], Col2[Sequence2], JunV, Row_end, col_end)
*             one_R:=[one_R,Row_end]
*             one_C:=[one_C,col_end]
            one_R:=[one_R,Row2[Sequence2]]
            one_C:=[one_C,Col2[Sequence2]]
            gen_cross_contour_xld (Cross, one_R, one_C, 0.05, 0)
            continue
        endif
*         gen_contour_nurbs_xld (Contour, Row2[Sequence2], Col2[Sequence2], 'auto', 'auto', 2,  MaxCha, 'omit')
        if (|Sequence2|==3)
            wight:=[0.1,0.9,0.1]
            gen_contour_nurbs_xld (Contour, Row2[Sequence2], Col2[Sequence2], \
                                   'auto', wight, 2,  0.001,'omit')
            gen_cross_contour_xld (Cross, Row2[Sequence2], Col2[Sequence2], 0.5, 0)
        else
            m_degree:=round(|Sequence2|*0.1)
            if (m_degree>|Sequence2|-1)
                m_degree:=|Sequence2|-1
            endif
            if (m_degree<2)
                m_degree:= 2
            endif
            if (m_degree>20)
                m_degree:=20
            endif
*             gen_contour_polygon_xld (Contour6, Row2[Sequence2], Col2[Sequence2])
*             a:=int((Length/|Row2|)*10)
*             m_degree:=min([m_degree,a])
            gen_contour_nurbs_xld (Contour, Row2[Sequence2], Col2[Sequence2], \
                                   'auto', 'auto', m_degree,  'omit',0.1)
        endif
       get_contour_xld (Contour, Row, Col)
*        gen_cross_contour_xld (Cross, Row2[Sequence2], Col2[Sequence2], 0.05, 0)
*        gen_cross_contour_xld (Cross, Row4, Col4, 0.05, 0)

       one_R:=[one_R,Row]
       one_C:=[one_C,Col]
    endfor
    gen_cross_contour_xld (Cross, one_R, one_C, 0.05, 0)
    gen_contour_polygon_xld (Contour3, one_R, one_C)
    concat_obj (EmptyObject2, Contour3, EmptyObject2)
*     get_contour_angle_xld (Contour3, 'abs', 'range', 2, Angles)
*     stop ()
endfor
count_seconds (Seconds1)
time:=Seconds1-Seconds
gen_cross_contour_xld (Cross, y, x, 0.5, 0)

dev_display (Contours)
dev_display (Cross)
stop ()

                                                                平滑效果 

 

 

 

念769
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HALCON轮廓整理.docx
07-23
HALCON轮廓整理,,轮廓的创建，区域边缘生成轮廓，提取，分割，合并,图像边缘提取得到轮廓
Halcon中XLD的概念
zxmyoung的博客
11-22 5652
XLD 1.halcon中什么是XLD？ XLD（eXtended Line Descriptions）：换句话说XDL就是一个轮廓函数，它不是基于像素，人们通常称他为亚像素，只不过它比像素更精确，可以精确到像素内部的一种描述。 在Halcon中，使用XLD表示亚像素的轮廓和多边形。常用edges_sub_pix算子来提取亚像素轮廓。 我们都知道图片是由像素组成，当我们用halcon读取图像Image或者region的时候，获得的数据就是像素。这些数据结构都是像素级...
halcon学习笔记——（11）Image，region，xld初步
liuxiaomao1988的专栏
10-11 8445
转自：http://www.cnblogs.com/hanzhaoxin/archive/2013/01/07/2848686.html 一 读取的3种方式：  read_image( image,'filename') //image 是输出对象，后面是输入文件的路径和名称 读取多图：  1，申明一个数组，分别保存路径  Imag
机器视觉——（三）halcon的XLD技术拟合圆
qq_40278194的博客
07-13 2745
利用halcon的XLD技术拟合圆。
基于Halcon学习的测量拟合【三】pm_measure_board.hdev例程
BoomBiuBiu的博客
02-13 1009
此示例程序显示了使用形状模型进行模板匹配找到一个物体。此外，它还显示了如何使用检测到的位置以及对象的旋转，进行对芯片引脚的测量拟合 *关闭pc的更新 dev_update_pc ('off') *关闭窗口的更新 dev_update_window ('off') *关闭程序运行过程中变量窗口的更新 dev_update_var ('off') *虚拟图像采集，seq文件是一个文本序列，对其中的文字逐行读取，打开对应文本路径的图像，模拟一个相机采集图像 open_framegrabber ('Fil.
MFC显示Halcon XLD 滚轮缩放 EasySize 控件缩放
12-21
Halcon中XLD轮廓在MFC对话框中pictrue控件上显示，并且可以通过滚动鼠标滚轮，放大缩小，同时对话框中的所有控件使用EasySize实现了控件跟随对话框缩放的功能。软件还对曲线进行了特征分析。需要安装halcon才能使用
HALCON算子函數Chapter 19XLD.doc
04-12
- `gen_contour_nurbs_xld` 通过NURBS曲线生成XLD轮廓。 - `gen_contour_polygon_rounded_xld` 根据带有圆角的多边形创建XLD轮廓。 - `gen_contour_polygon_xld` 直接从多边形数据生成XLD轮廓。 - `gen_contour_...
XLD-XWD卧式与立式摆线减速电机
09-23
XLD-XWD卧式与立式摆线减速电机，图纸均按比例绘制，各路大侠可以放心的使用
XLD-XWD卧式与立式摆线减速电机图纸
09-23
XLD-XWD卧式与立式摆线减速电机，图纸均按比例绘制，各路大侠可以放心的使用
Halcon使用XLD检测贴片.pdf
04-27
Halcon使用XLD检测贴片.pdf set_system ('int2_bits', 10) read_image (Image, 'smd/smd_capacitors_01') get_image_size (Image, Width, Height) dev_close_window () dev_open_window (0, 0, Width, Height, '...
halcon 轮廓 模板匹配
11-01
用halcon实现轮廓模板匹配，可运行已调试，可作为学习参考
Halcon拟合系列（6）：轮廓平滑算子smooth_contours_xld
$firecat利白的代码足迹$
12-25 8831
----inspect_frame_width.hdev（经典） 计算两个轮廓之间的距离 1、length_xld 获取轮廓的长度 2、tuple_sort_index( : : Tuple : Indices) 按升序对元组的所有元素进行排序，Indices中...
smooth_contours_xld:轮廓平滑
Major_S的博客
11-01 1358
smooth_contours_xld:轮廓平滑 read_image (Image, 'printer_chip/printer_chip_01') threshold (Image, Region, 128, 255) gen_contour_region_xld (Region, Contours, 'border') 轮廓平滑后 * 轮廓平滑 smooth_contours_xld (Contours, SmoothedContours, 3) ...
HALCON_根据XLD轮廓 把图像摆正
qq_42905899的博客
06-16 464
HALCON_XLD 轮廓
halcon中将xld轮廓或者region区域绘制在图像上并保存
m0_67136031的博客
10-05 8994
xld或region绘制在图像上并保存图像
halcon xld相关算子
weixin_37772351的博客
07-14 1307
halcon xld算子
HALCON的图像平滑算子
m0_47015717的博客
12-02 2415
1. 时域平均 采集同一场景的n幅图像，然后对这些图像进行平均，噪声方差降低到原来的1/n。 缺点：必须采集多幅图像，运行速度慢。 2. 均值滤波器 在像素数是（2n+1）X（2m+1）的一个空间窗口（掩码）内，计算窗口内所有像素的平均，噪声方差降低到1/(（2n+1）X（2m+1）)。 优点：计算速度快 缺点：并不能完全消除高频噪声 3. 高斯滤波器 基于正态分布随机变量的概率密度函数构造的滤波器。相比均值滤波器，更能有效消除高频噪声。关注滤波质量时优先考虑的滤波器。 缺点：速度稍逊均值
halcon合并xld
最新发布
12-09
以下是halcon合并xld的方法： ```python import halcon as ha # 读取xld xld1 = ha.read_xld_cont('xld1.hobj') xld2 = ha.read_xld_cont('xld2.hobj') # 合并xld xld_union = ha.union2_obj(xld1, xld2) # 显示...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值