贴标签算法

最新推荐文章于 2024-04-14 11:27:01 发布
最新推荐文章于 2024-04-14 11:27:01 发布
阅读量2.9k 收藏 6
点赞数 2
分类专栏： java 文章标签： 贴标签算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dreamsky8023/article/details/81663885
版权
该博客详细介绍了贴标签算法，用于处理二值图像的连通域区分。通过扫描图像并检查邻接像素，对不同连通域进行编号。算法首先初始化标签和计数器，然后遍历图像，根据4连通或8连通规则决定当前像素点的标签。遇到新连通域时，创建新的标签；若相邻像素已有相同标签，则沿用该标签。最后，检查标签是否连续，不连续时进行映射编码。提供了Java代码实现。
摘要由CSDN通过智能技术生成

贴标签处理：对二值图像中的每个不同的连通域进行不同的编号，来区分不同的连通域。

假定二值图像为f，标签图像为g，贴标签的算法步骤如下：

（1）设标签flag=0，已贴标签数N=0，按照从左到右，从上到下的顺序进行扫描，寻找像素值为1的目标像素点；

（2）对未贴标签的目标点像素f(i,j)，根据已经扫描的四个邻接像素（8连通），进行如下判断：

                   

      ①4连通                             ②8连通

如果四个邻接像素的值都为0（表示背景），则flag=flag+1，g(i,j)=flag，已贴标签数N=N+1；

如果其标签值相同，即全部为flag，则g(i,j)=flag；

如果标签值有两种：flag和flag'，（0<flag<flag'），令g(i,j)=flag，将所有已经贴标签为flag'的改为flag，同时将标签数进行修正，N=N-1。

（3）将所有像素都进行第（2）步的处理，直到处理完毕；

（4）判断flag是否等于N，如果不相等，则表明标签是不连续的编号，需进行映射编码；如果相等，则完成了贴标签操作。

下面为代码实现部分：

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class AttachLabel {
    public static final int[] dX = { 0, -1, -1, -1 };
    public static final int[] dY = { -1, -1, 0, 1 };

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] str = sc.nextLine().split(",");
        int m = Integer.parseInt(str[0]);
        int n = Integer.parseInt(str[1]);
        int[][] map = new int[m][n];
        for (int i = 0; i < m; i++) {
            String[] strs = sc.nextLine().split(",");
            for (int j = 0; j < n; j++)
                map[i][j] = Integer.parseInt(strs[j]);
        }
        sc.close();
        //int[] result=searchIce(m,n,map);//方法一
        int[] result = connectDomain(m, n, map);//方法二
        System.out.println(result[0] + "," + result[1]);
    }

    public static int[] connectDomain(int m, int n, int[][] map) {
        int[] result = new int[2];
        int[][] status = new int[m][n];// 标签图像
        int flag = 0;//标签
        int N = 0;// 标签数
        for (int x = 0; x < m; x++) {
            for (int y = 0; y < n; y++) {
                if (map[x][y] == 1) {
                    int[] tempX = new int[4];
                    int[] tempY = new int[4];
                    for (int i = 0; i < 4; i++) {
                        tempX[i] = x + dX[i];
                        tempY[i] = y + dY[i];
                    }
                    if (x == 0 && y == 0) {
                        flag = flag + 1;
                        status[x][y] = flag;
                        N = N + 1;
                    } else if (x == 0 && y > 0) {// 第一行
                        if (status[tempX[0]][tempY[0]] == 0) {
                            flag = flag + 1;
                            status[x][y] = flag;
                            N = N + 1;
                        } else if (status[tempX[0]][tempY[0]] == flag) {
                            status[x][y] = flag;
                        }
                    } else if (x > 0 && y == 0) {//第一列
                        if (status[tempX[2]][tempY[2]] == 0 && status[tempX[3]][tempY[3]] == 0) {
                            flag = flag + 1;
                            status[x][y] = flag;
                            N = N + 1;
                        } else if (status[tempX[2]][tempY[2]] == flag && status[tempX[3]][tempY[3]] == flag) {
                            status[x][y] = flag;
                        } else {
                            Set<Integer> st=new TreeSet<>();
                            int flag_p=flag;
                            for (int k = 2; k < 4; k++) {
                                if (status[tempX[k]][tempY[k]] != 0) {
                                    st.add(status[tempX[k]][tempY[k]]);
                                }
                            }
                            for(Integer s:st) {
                                flag_p = s;
                                break;
                            }
                            status[x][y] = flag_p;
                            if(st.size()==2) {
                                for (int k = 2; k < 4; k++) {
                                    if (status[tempX[k]][tempY[k]] != 0) {
                                        status[tempX[k]][tempY[k]] = flag_p;
                                    }
                                }
                                N = N - 1;
                            }
                        }
                    } else if (x > 0 && y == n - 1) {//最后一列
                        if (status[tempX[0]][tempY[0]] == 0 && status[tempX[1]][tempY[1]] == 0
                                && status[tempX[2]][tempY[2]] == 0) {
                            flag = flag + 1;
                            status[x][y] = flag;
                            N = N + 1;
                        } else if (status[tempX[0]][tempY[0]] == flag && status[tempX[1]][tempY[1]] == flag
                                && status[tempX[2]][tempY[2]] == flag) {
                            status[x][y] = flag;
                        } else {
                            Set<Integer> st=new TreeSet<>();
                            int flag_p=flag;
                            for (int k = 0; k < 3; k++) {
                                if (status[tempX[k]][tempY[k]] != 0) {
                                    st.add(status[tempX[k]][tempY[k]]);
                                }
                            }
                            for(Integer s:st) {
                                flag_p = s;
                                break;
                            }    
                            status[x][y] = flag_p;                        
                            if(st.size()==2) {
                                for (int k = 0; k < 3; k++) {
                                    if (status[tempX[k]][tempY[k]] != 0) {
                                        status[tempX[k]][tempY[k]] = flag_p;
                                    }
                                }
                                N = N - 1;
                            }
                        }
                    } else if (x > 0 && y > 0 && y < n - 1) {//其余的行和列
                        if (status[tempX[0]][tempY[0]] == 0 && status[tempX[1]][tempY[1]] == 0
                                && status[tempX[2]][tempY[2]] == 0 && status[tempX[3]][tempY[3]] == 0) {
                            flag = flag + 1;
                            status[x][y] = flag;
                            N = N + 1;
                        } else if (status[tempX[0]][tempY[0]] == flag && status[tempX[1]][tempY[1]] == flag
                                && status[tempX[2]][tempY[2]] == flag && status[tempX[3]][tempY[3]] == flag) {
                            status[x][y] = flag;
                        } else {
                            Set<Integer> st=new TreeSet<>();
                            int flag_p=flag;
                            for (int k = 0; k < 4; k++) {
                                if (status[tempX[k]][tempY[k]] != 0) {
                                    st.add(status[tempX[k]][tempY[k]]);                                
                                }
                            }
                            for(Integer s:st) {
                                flag_p = s;
                                break;
                            }            
                            status[x][y] = flag_p;                            
                            if(st.size()==2) {
                                for (int k = 0; k < 4; k++) {
                                    if (status[tempX[k]][tempY[k]] != 0) {

最低0.47元/天 解锁文章
Dreamsky8023
关注
专栏目录
Push-Relabel 最大流 推送重贴标签算法
qq_45824536的博客
12-27 1074
原理： 源点 ->高度从高到低的盈余点 ->汇点 结束标志： 除了源点、汇点的盈余为0，流汇聚到汇点后，盈余返回到源点） 伪代码： Push-Relabel( G, s, t )： Initialize(); WHILE 存在盈余点 DO 选择最大高度盈余点v； IF ∃????(????,????)满足????(????)=????(????)+???? THEN Push( v, e); ELSE h(v)++; //Relabel E
数学形态学之贴标签算法VC++实现
03-13
### 数学形态学之贴标签算法VC++实现 #### 知识点概述 数学形态学是一种基于集合论的图像处理方法，广泛应用于图像分析、模式识别等领域。在数学形态学中，贴标签算法（Labeling Algorithm）是针对二值图像处理的...
贴标签算法.docx
04-23
自己编写的程序，水平有限，欢迎指正。 贴标签处理是对二值图像的每个不同的连通域进行不同的编号，来区分不同的连通域。以八连通为例，贴标签的方法实际上包括了两个关键步骤：首先是按照从上到下，从左到右的顺序扫描所有像素值为1的像素，并判断是否与已经贴过标签的像素属于同一个连通域，如果是，则贴相同的标签，否则暂时判定为不同的连通域，贴新的标签。另一个关键步骤是，对已经贴好的标签进行校正，对在下方连接在一起的，已经贴不同标签的像素归并为同一个标签，并对整体的标签号进行调整。
【算法】标签算法及其运作流程
最新发布
再来一下！
04-14 995
常用的算法包括基于规则的算法、基于统计的算法（如朴素贝叶斯分类器、支持向量机）以及基于深度学习的算法（如卷积神经网络、循环神经网络）等。虽然降维算法本身不直接进行标签的添加，但是它们可以帮助提取数据的特征，从而为其他标签算法提供更好的输入。以上只是一些常见的标签算法，实际上还有许多其他方法和技术可用于数据的自动标记和分类，具体选择取决于数据的特点、问题的需求以及算法的性能。标签算法是一个广泛的概念，它涵盖了许多不同的技术和方法，用于自动标记或分类数据。使用训练好的模型对新的未标记数据进行标签预测。
最大流学习笔记（6）-前置重贴标签算法二
weixin_33699914的博客
11-02 174
上一篇 8、前置重贴标签操作算法流程：将维护一个链表$L$,该表由$V-\{s,t\}$中的所有节点构成，$L$中的节点的顺序将按照许可网络中的拓扑排序存放。$u.next$是链表$L$的下一个节点。下面是算法的伪代码： 9、 为了证明RELABEL-TO-FRONT确定计算出了一个最大流，下面将证明该算法就是GENERIC-PUSH-RELABEL的一种实现。首先，7证明了推...
标签传播算法（LPA)
叨叨的博客
06-24 1231
算法步骤 为网络中每个节点设置一个唯一的标签，并将其作为单独的社团。通常以节点的序号作为初始标签。 遍历所有节点，按以下标签传播规则更新每个节点的标签：选择其邻居节点数值最大的那个标签作为节点的标签。当数值最大的标签不唯一时，随机选择一个标签去更新节点标签 迭代执行步骤2，直到所有节点标签不再更新或达到迭代次数，算法结束。 具有相同标签的节点集就认为是一个社团 优点 思想简单，易于实现，效率较高 具有近似线性时间复杂度 缺点 迭代更新过程中随机选取节点更新标签，导致算法不稳定 容易形成巨型社区 初
matlab处理数字图像贴标签
09-03
使用matlab处理数字图像的贴标签程序
【Algorithm】Push-Relabel算法
Esperanto.的博客
04-08 2656
最大流问题 Push-Relabel算法
网络流-推送-重贴标签算法
远见望远的博客
07-19 173
网络流的推送-重贴标签算法代码 1 #include<iostream> 2 #include<algorithm> 3 using namespace std; 4 struct pointtype{ 5 int e; 6 int h; 7 }point[1001]; 8 int map[1001][1001]; 9 int c[10...
对二值化的图像进行标记
11-27
对二值化的图像进行标记，对不同的联通区域标记不同的数字。
自编程序实现matlab对图像矩阵贴标签求连通域
05-06
这是我自己写的程序，矩阵根据贴标签算法的原理写的，亲测可用，数字图像处理实验题
二值图贴标签算法
acpfxld1555的博客
12-01 1152
/*二值图处理 --- 贴标签法f(i,j) 检测图像 g(i,j) 标签图像初始值为设lab = 01. 从左到右从上到下扫描f(i,j)2. 如果f图像点(i,j)不为指定的值而回到看该点(i,j) 的在g图像的邻域内的lab值情况如果值都为0 则lab +=1 , g(i,j) = lab;如果不为0的值都相同则...
二值图像的贴标签算法
weixin_30555125的博客
01-25 1055
　　贴标签就是将二值图中属于同一个连通域的像素标记起来。之前编的程序需要多次遍历图像，所以速度比较慢，最近有朋友告诉我一种更简单的方法。这里对二值图中白色的连通域进行贴标签，具体步骤是： 　　1、按行遍历图像，当遇到一个白点时，说明遇到了一个标签区域； 　　2、将当前白点的坐标作为种子点入栈； 　　3、判断栈是否为空，若栈非空，则在栈顶元素所在位置贴上对应的标签号，同时将二值图上的该位置赋成...
图像处理技术：图像切割、标签、贴纸花字，超细开发详解
HarmonyOS SDK闭源开放能力技术团队
05-17 547
上一篇：图像处理之滤镜、图文排版的开发详解中，详解了如何给应用增加图片编辑能力中的滤镜和图文排版能力，今天我们继续带来华为图像能力中五大图像编辑能力的另外三大能力：图像切割、主题标签，以及贴纸花字，相信认真学习的同学已经可以成功打造出属于自己的图像编辑应用。 话不多说，直接上手！ 图片剪裁 开发步骤 编辑调整服务，图片裁剪服务的所有接口的实现都是基于CropLayoutView，是一个自定义View，import的包名为com.huawei.hms.image.vision.crop.Cro
各种网络流模板整合(EK,Dinic,推送-重贴标签,前置重贴标签)
Hardict的算法日记
11-23 742
本文不涉及讲解,仅罗列各种算法模板(都是自己写的,不一定最优,且一个算法不一定只有一种)——不定期更新 目录 Edmond-Karp()——包含邻接矩阵,邻接表,储存边三种 Dinic()——包含基础与当前弧优化两种 推送重贴标签()——一种 前置重贴标签()——一种 注:最后两种来自与《算法导论》,不一定保证最优实现，且该两种算法下界大致为，故要谨慎使用！！(以及残存容量实时更新,不...
实现贴标签功能
夜独醉╋心碎
09-11 593
首先要引入jquery-1.8.0.min.js 然后css //按钮样式 .btn, button, input[type="button"] { -moz-border-bottom-colors: none; -moz-border-left-colors: none; -moz-border-right-colors: none; -moz-border-t
图像连通区域标记
黑条纹的白斑马的博客
10-25 2116
由于最近做实验用到二值图像连通区域（八连通）标记，刚开始的时候为了验证算法有效性，用了递归的方法（太慢了，而且图像一大就容易栈溢出），最后查看了opencv和MATLAB的实现，做个记录。（为了简单说明，以下说明已四连通为例） 扫描法连通区域标记： 例：对于二值图像、四连通 第一次遍历： 1.建立一个和图像大小一样的矩阵保存结果，原图记为im,结果矩阵记为mask,mask各元素值可初始化...
有监督学习贴标签算法
09-17
有监督学习贴标签算法是一种利用已有的带有标签的数据集来训练模型，然后使用该模型对新的未标签数据进行标签预测的方法。下面是一些常见的有监督学习贴标签算法： 1. 决策树：基于树形结构进行决策的算法，可以根据不同特征值进行分割和分类。 2. 随机森林：通过多个决策树的集成来提高模型的预测准确性。 3. 逻辑回归：用于二分类问题，通过线性回归模型来预测样本属于某一类别的概率。 4. 支持向量机（SVM）：通过在高维空间中找到最优超平面来进行分类。 5. K近邻算法（KNN）：通过计算与待分类样本最近的K个样本的类别来进行分类。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值