24小时热门版块排行榜    

CyRhmU.jpeg
查看: 465  |  回复: 7
当前主题已经存档。

shanxixian3877

银虫 (正式写手)

[交流] 【求助】分水岭算法分析三维图片

用分水岭算法做图像三维分析,得到三维图片中孔洞尺寸和孔洞连接通道尺寸的分布情况,帮我编个程序吧,可以提供相关文献资料、给报酬,有的话和我联系 QQ443468935
回复此楼
已阅   回复此楼   关注TA 给TA发消息 送TA红花 TA的回帖

rjjy

木虫 (著名写手)


小木虫(金币+0.5):给个红包,谢谢回帖交流
分水岭算法,说实在第一次听说。知识真是大海!
2楼2009-06-15 00:37:37
已阅   回复此楼   关注TA 给TA发消息 送TA红花 TA的回帖

wangen994

荣誉版主 (著名写手)

将军


小木虫(金币+0.5):给个红包,谢谢回帖交流
分水岭算法还是第一次听说,哈哈
3楼2009-06-15 12:25:57
已阅   回复此楼   关注TA 给TA发消息 送TA红花 TA的回帖

shanxixian3877

银虫 (正式写手)

不论用什么算法。这个目的能实现不?就是得到三维图片中孔洞尺寸和孔洞连接通道尺寸的分布情况,
4楼2009-06-15 16:16:22
已阅   回复此楼   关注TA 给TA发消息 送TA红花 TA的回帖

sayu_yangy

铁杆木虫 (著名写手)

Research Scientist

优秀版主


wangen994(金币+1,VIP+0):感谢你的参与讨论 6-27 08:53
分水岭算法本质上其实就是阈值法而已,很简单的。
我只是不明白你的三维图片是什么东西,我们的图片不都是二维的吗?
好好学习,天天向上!
5楼2009-06-27 07:22:57
已阅   回复此楼   关注TA 给TA发消息 送TA红花 TA的回帖

rsb_long

至尊木虫 (著名写手)

★ ★ ★ ★
小木虫(金币+0.5):给个红包,谢谢回帖交流
wangen994(金币+3,VIP+0):感谢你参与讨论 7-1 18:33
这是一种典型的图像识别算法



标题:分水岭算法  

//Image Watershed Segmentation
//This is the implementation of the algorithm based on immersion model.
// ===========================================================================
// =====      Module: Watershed.cpp
// ===== -------------------------------------------------------------- ======
// =====      Version 01   Date: 04/21/2003
// ===== -------------------------------------------------------------- ======
// ===========================================================================
// =====      Written by Foxhole@smth.org
// =====      e-mail:  gong200@china.com
// ===========================================================================
// Permission to use, copy, or modify this software and its documentation
// for educational and research purposes only is hereby granted without
// fee, provided that this copyright notice appear on all copies and
// related documentation.  For any other uses of this software, in original
// or modified form, including but not limited to distribution in whole
// or in part, specific prior permission must be obtained from
// the author(s).
//
// THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
// EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
// WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//
// IN NO EVENT SHALL RUTGERS UNIVERSITY BE LIABLE FOR ANY SPECIAL,
// INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY
// DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
// WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY
// THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE
// OR PERFORMANCE OF THIS SOFTWARE.
// ===========================================================================

#include
#include
#include


/*====================================================================
函数名                        :        Watershed
功能                        :        用标记-分水岭算法对输入图像进行分割
算法实现                :        无
输入参数说明        :        OriginalImage --输入图像(灰度图,0~255)
                                          SeedImage     --标记图像(二值图,0-非标记,1-标记)
                                          LabelImage    --输出图像(1-第一个分割区域,2-第二个分割区域,...)
                                          row           --图像行数
                                          col           --图像列数
返回值说明                :         无       
====================================================================*/
void Watershed(const int **OriginalImage, char** SeedImage, int **LabelImage, int row, int col)
{
        using namespace std;

        //标记区域标识号,从1开始
        int Num=0;
        int i,j;

        //保存每个队列种子个数的数组
        vector SeedCounts;
        //临时种子队列
        queue que;
        //保存所有标记区域种子队列的数组
        vector* > qu;
       
        int* array;
        queue *uu;
        POINT temp;

        for(i=0;i                 for(j=0;j                         LabelImage[j]=0;
       

        int m,n,k=0;
        int up,down,right,left,upleft,upright,downleft,downright;

        //预处理,提取区分每个标记区域,并初始化每个标记的种子队列
        //种子是指标记区域边缘的点,他们可以在水位上升时向外淹没(或者说生长)
        for(i=0;i         {
                for(j=0;j                 {
                        //如果找到一个标记区域
                        if(SeedImage[j]==1)
                        {
                                //区域的标识号加一
                                Num++;
                                //分配数组并初始化为零
                                array=new int[256];
                                ZeroMemory(array,256*sizeof(int));
                                //
                                SeedCounts.push_back(array);
                                //分配本标记的优先队列
                                uu=new queue[256];
                                //加入到队列数组中
                                qu.push_back(uu);
                                //当前点放入本标记区域的临时种子队列中
                                temp.x=i;
                                temp.y=j;
                                que.push(temp);
                                //当前点标记为已处理
                                LabelImage[j]=Num;
                                SeedImage[j]=127;
                               
                                //让种子队列中的种子进行生长直到所有的种子都生长完毕
                                while(!que.empty())
                                {
                                        up=down=right=left=0;
                                        upleft=upright=downleft=downright=0;
                                        //队列中取出一个种子
                                        temp=que.front();
                                        m=temp.x;
                                        n=temp.y;
                                        que.pop();

                                        if(m>0)
                                        {
                                                //上方若为可生长点则加为新种子
                                                if(SeedImage[m-1][n]==1)
                                                {
                                                        temp.x=m-1;
                                                        temp.y=n;
                                                        que.push(temp);
                                                        //新种子点标记为已淹没区域
                                                        LabelImage[m-1][n]=Num;
                                                        SeedImage[m-1][n]=127;
                                                }else//否则上方为不可生长
                                                {
                                                        up=1;
                                                }
                                        }
                                        if(m>0&&n>0)
                                        {
                                                if(SeedImage[m-1][n-1]==1)//左上方若为可生长点则加为新种子
                                                {
                                                        temp.x=m-1;
                                                        temp.y=n-1;
                                                        que.push(temp);
                                                        //新种子点标记为已淹没区域
                                                        LabelImage[m-1][n-1]=Num;
                                                        SeedImage[m-1][n-1]=127;
                                                }else//否则左上方为不可生长
                                                {
                                                        upleft=1;
                                                }
                                        }

                                        if(m                                         {
                                                if(SeedImage[m+1][n]==1)//下方若为可生长点则加为新种子
                                                {
                                                        temp.x=m+1;
                                                        temp.y=n;
                                                        que.push(temp);
                                                        //新种子点标记为已淹没区域
                                                        LabelImage[m+1][n]=Num;
                                                        SeedImage[m+1][n]=127;
                                                }else//否则下方为不可生长
                                                {
                                                        down=1;
                                                }
                                        }
                                        if(m<(row-1)&&n<(col-1))
                                        {
                                                if(SeedImage[m+1][n+1]==1)//下方若为可生长点则加为新种子
                                                {
                                                        temp.x=m+1;
                                                        temp.y=n+1;
                                                        que.push(temp);
                                                        //新种子点标记为已淹没区域
                                                        LabelImage[m+1][n+1]=Num;
                                                        SeedImage[m+1][n+1]=127;
                                                }else//否则下方为不可生长
                                                {
                                                        downright=1;
                                                }
                                        }
                               
                                        if(n                                         {
                                                if(SeedImage[m][n+1]==1)//右方若为可生长点则加为新种子
                                                {
                                                        temp.x=m;
                                                        temp.y=n+1;
                                                        que.push(temp);
                                                        //新种子点标记为已淹没区域
                                                        LabelImage[m][n+1]=Num;
                                                        SeedImage[m][n+1]=127;
                                                }else//否则右方为不可生长
                                                {
                                                        right=1;
                                                }
                                        }
                                        if(m>0&&n<(col-1))
                                        {
                                                if(SeedImage[m-1][n+1]==1)//右上方若为可生长点则加为新种子
                                                {
                                                        temp.x=m-1;
                                                        temp.y=n+1;
                                                        que.push(temp);
                                                        //新种子点标记为已淹没区域
                                                        LabelImage[m-1][n+1]=Num;
                                                        SeedImage[m-1][n+1]=127;
                                                }else//否则右上方为不可生长
                                                {
                                                        upright=1;
                                                }
                                        }

                                        if(n>0)
                                        {
                                                if(SeedImage[m][n-1]==1)//左方若为可生长点则加为新种子
                                                {
                                                        temp.x=m;
                                                        temp.y=n-1;
                                                        que.push(temp);
                                                        //新种子点标记为已淹没区域
                                                        LabelImage[m][n-1]=Num;
                                                        SeedImage[m][n-1]=127;
                                                }else//否则左方为不可生长
                                                {
                                                        left=1;
                                                }
                                        }
                                        if(m<(row-1)&&n>0)
                                        {
                                                if(SeedImage[m+1][n-1]==1)//左下方若为可生长点则加为新种子
                                                {
                                                        temp.x=m+1;
                                                        temp.y=n-1;
                                                        que.push(temp);
                                                        //新种子点标记为已淹没区域
                                                        LabelImage[m+1][n-1]=Num;
                                                        SeedImage[m+1][n-1]=127;
                                                }else//否则左方为不可生长
                                                {
                                                        downleft=1;
                                                }
                                        }

                                        //上下左右只要有一点不可生长,那么本点为初始种子队列中的一个
                                        if(up||down||right||left||
                                                upleft||downleft||upright||downright)
                                        {
                                                temp.x=m;
                                                temp.y=n;
                                                qu[Num-1][OriginalImage[m][n]].push(temp);
                                                SeedCounts[Num-1][OriginalImage[m][n]]++;
                                        }

                                }//while结束
                        }
                }
        }

        bool actives;//在某一水位处,所有标记的种子生长完的标志
        int WaterLevel;

        //淹没过程开始,水位从零开始上升
        for(WaterLevel=0;WaterLevel<256;WaterLevel++)
        {
                actives=true;
                while(actives)
                {
                        actives=false;
                        //依次处理每个标记区域
                        for(i=0;i                         {
                        if(!qu[WaterLevel].empty())
                        {
                                actives=true;
                                while(SeedCounts[WaterLevel]>0)
                                {
                                        SeedCounts[WaterLevel]--;
                                        temp=qu[WaterLevel].front();
                                        qu[WaterLevel].pop();
                                        m = temp.x;
                                        n = temp.y;//当前种子的坐标
                                        if(m>0)
                                        {
                                                if(!LabelImage[m-1][n])//上方若未处理
                                                {
                                                        temp.x=m-1;
                                                        temp.y=n;
                                                        LabelImage[m-1][n]=i+1;//上方点标记为已淹没区域

                                                        if(OriginalImage[m-1][n]<=WaterLevel)//上方若为可生长点则加入当前队列
                                                        {
                                                                qu[WaterLevel].push(temp);
                                                        }
                                                        else//否则加入OriginalImage[m-1][n]级队列
                                                        {
                                                                qu[OriginalImage[m-1][n]].push(temp);
                                                                SeedCounts[OriginalImage[m-1][n]]++;
                                                        }
                                                }
                                        }

                                        if(m                                         {
                                                if(!LabelImage[m+1][n])//下方若未处理
                                                {
                                                        temp.x=m+1;
                                                        temp.y=n;
                                                        LabelImage[m+1][n]=i+1;//下方点标记为已淹没区域

                                                        if(OriginalImage[m+1][n]<=WaterLevel)//下方若为可生长点则加入当前队列
                                                        {
                                                                qu[WaterLevel].push(temp);
                                                        }
                                                        else//否则加入OriginalImage[m+1][n]级队列
                                                        {
                                                                qu[OriginalImage[m+1][n]].push(temp);
                                                                SeedCounts[OriginalImage[m+1][n]]++;
                                                        }
                                                }
                                        }
                       
                                        if(n                                         {
                                                if(!LabelImage[m][n+1])//右边若未处理
                                                {
                                                        temp.x=m;
                                                        temp.y=n+1;
                                                        LabelImage[m][n+1]=i+1;//右边点标记为已淹没区域

                                                        if(OriginalImage[m][n+1]<=WaterLevel)//右边若为可生长点则加入当前队列
                                                        {
                                                                qu[WaterLevel].push(temp);
                                                        }
                                                        else//否则加入OriginalImage[m][n+1]级队列
                                                        {
                                                                qu[OriginalImage[m][n+1]].push(temp);
                                                                SeedCounts[OriginalImage[m][n+1]]++;
                                                        }
                                                }
                                        }

                                        if(n>0)
                                        {
                                                if(!LabelImage[m][n-1])//左边若未处理
                                                {
                                                        temp.x=m;
                                                        temp.y=n-1;
                                                        LabelImage[m][n-1]=i+1;//左边点标记为已淹没区域

                                                        if(OriginalImage[m][n-1]<=WaterLevel)//左边若为可生长点则加入当前队列
                                                        {
                                                                qu[WaterLevel].push(temp);
                                                        }
                                                        else//否则加入OriginalImage[m][n-1]级队列
                                                        {
                                                                qu[OriginalImage[m][n-1]].push(temp);
                                                                SeedCounts[OriginalImage[m][n-1]]++;
                                                        }
                                                }
                                        }
                                }//while循环结束
                                SeedCounts[WaterLevel]=qu[WaterLevel].size();
                        }//if结束
                        }//for循环结束
                }//while循环结束
        }//for循环结束
        while(!qu.empty())
        {
                uu=qu.back();
                delete[] uu;
                qu.pop_back();
        }
        while(!SeedCounts.empty())
        {
                array=SeedCounts.back();
                delete[] array;
                SeedCounts.pop_back();
        }
}
6楼2009-07-01 11:18:19
已阅   回复此楼   关注TA 给TA发消息 送TA红花 TA的回帖
支持,顶一下~~
7楼2009-07-04 08:32:25
已阅   回复此楼   关注TA 给TA发消息 送TA红花 TA的回帖

shanxixian3877

银虫 (正式写手)

看不懂
8楼2009-07-09 20:16:54
已阅   回复此楼   关注TA 给TA发消息 送TA红花 TA的回帖
相关版块跳转 我要订阅楼主 shanxixian3877 的主题更新
普通表情 高级回复(可上传附件)
信息提示
请填处理意见