c++ 图像处理（十四）距离变换

距离变换

原理：以后再写，有疑问的可以去网上找相关理论，或者在下面留言

代码：

距离变换

• QImage &image 输入图像
• QImage &otpImage 输出图像
• int distant_modle 距离计算模型 1 表示 欧几里德距离

•                                 2 表示 曼哈顿距离(City Block Distance)
  

•                                 3 表示 象棋格距离(Chessboard Distance)
  

/*      距离变换
 *  QImage &image          输入图像
 *  QImage &otpImage       输出图像
 *  int distant_modle      距离计算模型  1 表示 欧几里德距离
 *                                     2 表示 曼哈顿距离(City Block Distance)
 *                                     3 表示 象棋格距离(Chessboard Distance)
 */
void Distance_Transform(QImage &image,QImage &otpImage,int distant_modle)
{
    int height = image.height();
    int width = image.width();
    int all_size = height * width;
    int x,y;
    int w,h;
    int curr_index;
    float distence;
    float min =10000;
    float max = 0;
    float result;


    int p_4[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};
    bool p_condition[4];

    QImage* pImageThreL = new QImage(width,height,QImage::Format_ARGB32);

    QVector mask(all_size);  //前景与背景的模板
    QVector dis_mask(all_size); //距离模板
    //QVector masker(all_size);
    QVector inside; //内部点的集合
    QVector outside; //非内部点的集合
    Point temp;


    Init_Image(otpImage,0);

    //二值化处理
    int nDiffGray;
    BYTE  bThreH = DetectThreshold_pro(&image,300,nDiffGray);
    Threshold_pro(&image,*pImageThreL,bThreH);
    Inversion(*pImageThreL);


    //前景模板
    for(y = 1; y < height-1; y++)
    {
        for(x = 1; x < width-1; x++)
        {
             curr_index = y * width + x;
             mask[curr_index] = (qGray(pImageThreL->pixel(x,y)) == 255) ? 1 : -1;
             dis_mask[curr_index] = 0.0;
        }
    }


    //内部点，外部点，孤立点
    for(y=1; y=0 && curr_index<=all_size && mask[curr_index]==1)
                    {
                        p_condition[k] = true;
                    }
                }
                if(p_condition[0] && p_condition[1] && p_condition[2] && p_condition[3])
                    inside.push_back(temp);
            }
            else {
                for(int k = 0; k<4; k++)
                {
                    p_condition[k] = false;
                    h = y + p_4[k][0];
                    w = x + p_4[k][1];
                    curr_index = h * width + w;
                    if(curr_index>=0 && curr_index<=all_size)
                    {
                        if(mask[curr_index]==1)
                            p_condition[k] = true;
                    }
                }
                if(p_condition[0] || p_condition[1] || p_condition[2] || p_condition[3])
                    outside.push_back(temp);
            }
        }
    }

    //cout<<"outside:"<0)
            {
                int grey = 255*(dis_mask[curr_index] - min) / result;
                otpImage.setPixel(j,i,qRgb(grey,grey,grey));
            }
        }
    }

}

欧式距离计算：

float European_Distance(QVector &qv,int x,int y,float &dist_min,float &dist_max)
{
    Point tem;
    float min = 10000.0;
    float dist;
    float w,h;

    for(int i = 0; i dist_max)
    {
        dist_max = min;
    }
    return min;
}

棋盘距离：

float Chessboard_Distance(QVector &qvp,int x,int y,float &dist_min,float &dist_max)
{
    Point temp;
    float min = 10000;
    float dist;

    for(int i = 0; i dist_max)
    {
        dist_max = min;
    }

    return min;
}

城市街区距离：

float City_blocks_Distance(QVector qvp,int x,int y,float &dist_min,float &dist_max)
{
    Point temp;
    float min = 10000;
    float dist;
    float w,h;

    for(int i = 0; i dist_max)
    {
        dist_max = min;
    }
    return min;
}

效果图：