用编程解决习题【计算机图像处理】

用编程解决习题【计算机图像处理】

  • 前言
  • 版权
    • 第三章 03采样量化与像素间关系
      • 三种距离计算
      • 编程
    • 第六章 06图像的直方图变换
      • 均衡化直方图
      • 编程
      • 规定化直方图
      • 编程
    • 第七章 07图像的噪声抑制
      • 均值滤波 中值滤波计算
      • 编程
      • knn滤波计算
      • 编程
    • 第十章 10二值图像的分析
      • 贴标签 膨胀 腐蚀
      • 编程
  • 最后

前言

2023-12-27 21:11:27

以下内容源自《【计算机图像处理】》
仅供学习交流使用

版权

禁止其他平台发布时删除以下此话
本文首次发布于CSDN平台
作者是CSDN@日星月云
博客主页是https://jsss-1.blog.csdn.net
禁止其他平台发布时删除以上此话

第三章 03采样量化与像素间关系

三种距离计算

一、请计算像素点a(0,1)和像素点b（6,9）之间的欧氏距离，棋盘距离以及城区距离。

欧氏距离：((6-0)^2+(9-1)^2)^0.5=10   345 6810勾股数
棋盘距离：max(|0-6|,|1-9|)=8
城区距离:(|0-6|+|1-9|)=14

编程

import java.util.Scanner;/*** 第三章作业** 2023-12-27 21:19:15** 一、请计算像素点a(0,1)和像素点b（6,9）之间的欧氏距离，棋盘距离以及城区距离。*  欧氏距离：((6-0)^2+(9-1)^2)^0.5=10   345 6810勾股数*  棋盘距离：max(|0-6|,|1-9|)=8*  城区距离:(|0-6|+|1-9|)=14****/
public class Main3 {static class Point{int x;int y;public Point(){}public Point(int x,int y){this.x=x;this.y=y;}//欧式距离public static double distance1(Point p1,Point p2){return Math.sqrt(Math.pow(p1.x-p2.x,2)+Math.pow(p1.y-p2.y,2));}//棋盘距离public static double distance2(Point p1,Point p2){return Math.max(Math.abs(p1.x-p2.x),Math.abs(p1.y-p2.y));}//城区距离public static double distance3(Point p1,Point p2){return Math.abs(p1.x-p2.x)+Math.abs(p1.y-p2.y);}}public static Point p1;public static Point p2;//手动改值初始化public static void init(){p1=new Point(0,1);p2=new Point(6,9);}//自动输入初始化//0 1 6 9static void input() {Scanner scanner=new Scanner(System.in);int x1=scanner.nextInt();int y1=scanner.nextInt();int x2=scanner.nextInt();int y2=scanner.nextInt();p1=new Point(x1,y1);p2=new Point(x2,y2);}public static void main(String[] args) {
//        input(); //输入init();//手动改值System.out.println(Point.distance1(p1,p2));//10.0System.out.println(Point.distance2(p1,p2));//8.0System.out.println(Point.distance3(p1,p2));//14.0}}

第六章 06图像的直方图变换

均衡化直方图

一幅灰度级为8的图像对应的归一化直方图为[0.17，0.25，0.21，0.16，0.07，0.08，0.04，0.02]。用列表法计算直方图均衡化后图像的灰度级和对应的概率，并画出处理前后直方图的对比图。

原始灰度级k01234567
原始直方图sk0.170.250.210.160.070.080.040.02
累计直方图tk0.170.420.630.790.860.940.981.0
扩展取整12456667
映射0->11->22->43->54->65->66->67->7
均衡化直方图0.170.250.210.160.190.02

编程

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;public class Main6 {//原始直方图static double[] sk;static int n;static int l;//累计直方图static double[] tk;//扩展取整static int [] extend;//均衡化后的直方图static double[] equalized;//手动改值初始化public static void init(){sk =new double[]{0.17,0.25,0.21,0.16,0.07,0.08,0.04,0.02};n= sk.length;l= n-1;}//自动输入初始化//8//0.17 0.25 0.21 0.16 0.07 0.08 0.04 0.02static void input() {Scanner scanner=new Scanner(System.in);//输入长度n= scanner.nextInt();l=n-1;sk =new double[n];int c=0;for (int i = 0; i < n; i++) {sk[c++]= scanner.nextDouble();}}public static void main(String[] args) {
//        input(); //输入init();//手动改值equalize();}//均衡化public static void equalize(){System.out.println("输出原始直方图：");System.out.println(Arrays.toString(sk));tk=new double[n];tk[0]=sk[0];for (int i = 1; i < n; i++) {tk[i]=tk[i-1]+sk[i];}System.out.println("输出累计直方图：");System.out.println(Arrays.toString(tk));extend=new int[n];for (int i = 0; i < n; i++) {extend[i]=(int)(tk[i]*l);}System.out.println("输出扩展取整：");System.out.println(Arrays.toString(extend));ArrayList<ArrayList<Integer>> map=new ArrayList<>();for (int i = 0; i < n; i++) {map.add(new ArrayList<>());}for (int i = 0; i < n; i++) {map.get(extend[i]).add(i);}System.out.println("输出映射关系：");for (int i = 0; i < n; i++) {ArrayList<Integer> cur=map.get(i);if (!cur.isEmpty()){System.out.print(cur+"->"+i+"\t");}}System.out.println();equalized=new double[n];for (int i = 0; i < n; i++) {ArrayList<Integer> cur=map.get(i);if (!cur.isEmpty()){for (Integer j : cur) {equalized[i]+=sk[j];}}}System.out.println("输出均衡化的直方图：");System.out.println(Arrays.toString(equalized));}
}
输出原始直方图：
[0.17, 0.25, 0.21, 0.16, 0.07, 0.08, 0.04, 0.02]
输出累计直方图：
[0.17, 0.42000000000000004, 0.63, 0.79, 0.8600000000000001, 0.9400000000000001, 0.9800000000000001, 1.0]
输出扩展取整：
[1, 2, 4, 5, 6, 6, 6, 7]
输出映射关系：
[0]->1	[1]->2	[2]->4	[3]->5	[4, 5, 6]->6	[7]->7	
输出均衡化的直方图：
[0.0, 0.17, 0.25, 0.0, 0.21, 0.16, 0.19000000000000003, 0.02]

规定化直方图

请添加图片描述

请添加图片描述

编程

import java.util.Arrays;
import java.util.Scanner;public class Main6_2 {//原始直方图static double[] sk;static int n;static int l;//累计直方图static double[] tk;//扩展取整static int [] extend;//均衡化后的直方图static double[] equalized;//手动改值初始化public static void init1(){sk =new double[]{0.19,0.25,0.21,0.16,0.08,0.06,0.03,0.02};n= sk.length;l= n-1;}//自动输入初始化/*80.17 0.25 0.21 0.16 0.07 0.08 0.04 0.02*/static void input1() {Scanner scanner=new Scanner(System.in);//输入长度n= scanner.nextInt();l=n-1;sk =new double[n];int c=0;for (int i = 0; i < n; i++) {sk[c++]= scanner.nextDouble();}}public static void init2(){sk =new double[]{0,0,0,0.2,0,0.6,0,0.2};n= sk.length;l= n-1;}/*80 0 0 0.2 0 0.6 0 0.2*/static void input2() {Scanner scanner=new Scanner(System.in);//输入长度n= scanner.nextInt();l=n-1;sk =new double[n];int c=0;for (int i = 0; i < n; i++) {sk[c++]= scanner.nextDouble();}}static double[] sk1;public static void main(String[] args) {double[] tk1 = op1();double[] tk2 = op2();sml(tk1,tk2);gml(tk1,tk2);}private static double[] op1() {//输入原始直方图
//        input1(); //输入init1();//手动改值sk1=new double[n];for (int i = 0; i < n; i++) {sk1[i]=sk[i];}System.out.println("原始直方图");System.out.println(Arrays.toString(sk1));step1();double[] tk1=new double[n];for (int i = 0; i < n; i++) {tk1[i]=tk[i];}System.out.println("原始累积直方图");System.out.println(Arrays.toString(tk1));record1=new int[n];for (int i = 0; i < n; i++) {record1[i]=record[i];}System.out.println("record1");System.out.println(Arrays.toString(record1));return tk1;}private static double[] op2() {//输入规定直方图
//        input1(); //输入init2();//手动改值System.out.println("规定直方图");System.out.println(Arrays.toString(sk));step1();double[] tk2=new double[n];for (int i = 0; i < n; i++) {tk2[i]=tk[i];}System.out.println("规定累积直方图");System.out.println(Arrays.toString(tk2));record2=new int[n];for (int i = 0; i < n; i++) {record2[i]=record[i];}System.out.println("record2");System.out.println(Arrays.toString(record2));return tk2;}//就是tk1距离tk2中的哪个最近，则tk1的下标对应tk2中的下标//因为都是非递减数列，所以使用双指针就好了，只是O(n)的复杂度//有个问题就是可能和原来的不对应，就是原来是0，加了前面的值才有值的//所以需要使用record来记录public static void sml(double[] tk1,double[] tk2){int[] map=new int[n];for (int i = 0,j=0 ; i <n; i++) {for (; j < n;j++ ) {if (j+1==n||Math.abs(tk1[i]-tk2[j])<Math.abs(tk1[i]-tk2[j+1])){break;}}map[i]=record2[j];//不一定是j，而是j所前面的值}System.out.println("sml映射");System.out.println(Arrays.toString(map));double[] smled=new double[n];for (int i = 0; i < n; i++) {smled[map[i]]+=sk1[i];}System.out.println("变换后直方图");System.out.println(Arrays.toString(smled));}//tk2到tk1的距离//因为都是非递减数列，所以使用双指针就好了，只是O(n)的复杂度public static void gml(double[] tk1,double[] tk2){int[] map=new int[n];for (int i = 0,j=0 ; i <n; i++) {//跳过为0的或者和之前一样的if(tk2[i]==0||(i-1>=0&&tk2[i]==tk2[i-1])){continue;}//只要tk[i]到tk1[j]的距离一直递减就一直映射j->ifor (; j < n;j++ ) {if (j-1<0||Math.abs(tk1[j]-tk2[i])<Math.abs(tk1[j-1]-tk2[i])){map[j]=i;}else {break;}}}System.out.println("gml映射");System.out.println(Arrays.toString(map));double[] gmled =new double[n];for (int i = 0; i < n; i++) {gmled[map[i]]+=sk1[i];}System.out.println("变换后直方图");System.out.println(Arrays.toString(gmled));}static int[] record;static int[] record1;static int[] record2;private static void step1() {record=new int[n];tk=new double[n];tk[0]=sk[0];record[0]=0;for (int i = 1; i < n; i++) {if(sk[i]==0){record[i]=record[i-1];}else {record[i]=i;}tk[i]=tk[i-1]+sk[i];}}}
原始直方图
[0.19, 0.25, 0.21, 0.16, 0.08, 0.06, 0.03, 0.02]
原始累积直方图
[0.19, 0.44, 0.65, 0.81, 0.89, 0.95, 0.98, 1.0]
record1
[0, 1, 2, 3, 4, 5, 6, 7]
规定直方图
[0.0, 0.0, 0.0, 0.2, 0.0, 0.6, 0.0, 0.2]
规定累积直方图
[0.0, 0.0, 0.0, 0.2, 0.2, 0.8, 0.8, 1.0]
record2
[0, 0, 0, 3, 3, 5, 5, 7]
sml映射
[3, 3, 5, 5, 5, 7, 7, 7]
变换后直方图
[0.0, 0.0, 0.0, 0.44, 0.0, 0.45, 0.0, 0.11]
gml映射
[3, 5, 5, 5, 7, 7, 7, 7]
变换后直方图
[0.0, 0.0, 0.0, 0.19, 0.0, 0.62, 0.0, 0.19]

第七章 07图像的噪声抑制

均值滤波 中值滤波计算

此处注意，要点明凡是代替的点就是噪声点。
在这里插入图片描述
1.均值滤波
周围所有邻居的平均值
2.中值滤波
周围所有邻居的中位数
3.KNN滤波
周围和他差值最小的K个邻居的平均值

编程


import java.util.Arrays;
import java.util.Scanner;/**** 1、设原图像为* 4 4* 59 60 58 57* 61 90 59 57* 62 59 0  58* 56 61 60 56*** 请对其进行均值滤波和中值滤波，并分析结果异同***/public class Main7 {static int[][] grid;static int n;static int m;//------------------------------------------------------------------------------------public static void init(){grid= new int[][]{{59, 60, 58, 57},{61, 90, 59, 57},{62, 59, 0, 58},{56, 61, 60, 56}};n= grid.length;m=grid[0].length;}/*4 459 60 58 5761 90 59 5762 59 0  5856 61 60 56*/public static void input(){Scanner scanner=new Scanner(System.in);n=scanner.nextInt();m=scanner.nextInt();grid=new int[n][m];for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {grid[i][j]=scanner.nextInt();}}}//------------------------------------------------------------------------------------public static void main(String[] args) {
//        input(); //输入init();//手动改值System.out.println("输出原始图像");for (int i = 0; i < n; i++) {System.out.println(Arrays.toString(grid[i]));}System.out.println("输出均值滤波图像");int[][] meanFiltered=meanFiltering();for (int i = 0; i < n; i++) {System.out.println(Arrays.toString(meanFiltered[i]));}//输出中值滤波图像System.out.println("输出中值滤波图像");int[][] medianFiltered=medianFiltering();for (int i = 0; i < n; i++) {System.out.println(Arrays.toString(medianFiltered[i]));}}//------------------------------------------------------------------------------------private static int[][] meanFiltering(){int[][] meanFiltered=new int[n][m];for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {meanFiltered[i][j]=grid[i][j];}}for (int i = 1; i < n-1; i++) {for (int j = 1; j < m-1; j++) {meanFiltered[i][j]=mean(i,j);}}return meanFiltered;}//返回(x,y)周围9个点的均值// 四舍五入private static int mean(int x, int y) {int sum=0;for (int i = x-1; i <= x+1; i++) {for (int j = y-1; j <= y+1; j++) {sum+=grid[i][j];}}return (int)(sum/9.0+0.5);}//------------------------------------------------------------------------------------private static int[][] medianFiltering() {int[][] medianFiltered=new int[n][m];for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {medianFiltered[i][j]=grid[i][j];}}for (int i = 1; i < n-1; i++) {for (int j = 1; j < m-1; j++) {medianFiltered[i][j]=median(i,j);}}return medianFiltered;}private static int median(int x, int y) {int[] arr=new int[9];int c=0;for (int i = x-1; i <= x+1; i++) {for (int j = y-1; j <= y+1; j++) {arr[c++]=grid[i][j];}}Arrays.sort(arr);int m=(9+1)/2;return arr[m];}}
输出原始图像
[59, 60, 58, 57]
[61, 90, 59, 57]
[62, 59, 0, 58]
[56, 61, 60, 56]
输出均值滤波图像
[59, 60, 58, 57]
[61, 56, 55, 57]
[62, 56, 56, 58]
[56, 61, 60, 56]
输出中值滤波图像
[59, 60, 58, 57]
[61, 60, 59, 57]
[62, 61, 59, 58]
[56, 61, 60, 56]

knn滤波计算

此处注意，要点明凡是代替的点就是噪声点。
在这里插入图片描述
1.均值滤波
周围所有邻居的平均值
2.中值滤波
周围所有邻居的中位数
3.KNN滤波
周围和他差值最小的K个邻居的平均值

编程

/***  2、对下图进行KNN平滑滤波，并由结果指出图中的噪声点。**     1 5 255 100 200 200*     1 7 254 101 10 9*     3 7 10 100 2 6*     1 0 8 7 2 1*     1 1 6 50 2 2*     2 3 9 7 2 0*/import java.util.ArrayList;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;public class Main7_2 {static int[][] grid;static int n;static int m;static int k=5;//------------------------------------------------------------------------------------public static void init(){grid= new int[][]{{1, 5, 255, 100, 200, 200},{1, 7, 254, 101, 10, 9},{3, 7, 10, 100, 2, 6},{1, 0, 8, 7, 2, 1},{1, 1, 6, 50, 2, 2},{2, 3, 9, 7, 2, 0}};n= grid.length;m=grid[0].length;}/*6 61 5 255 100 200 2001 7 254 101 10 93 7 10 100 2 61 0 8 7 2 11 1 6 50 2 22 3 9 7 2 0*/public static void input(){Scanner scanner=new Scanner(System.in);n=scanner.nextInt();m=scanner.nextInt();grid=new int[n][m];for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {grid[i][j]=scanner.nextInt();}}}public static void main(String[] args) {
//        input(); //输入init();//手动改值System.out.println("输出原始图像");for (int i = 0; i < n; i++) {System.out.println(Arrays.toString(grid[i]));}System.out.println("输出knn滤波图像");int[][] knnFiltered=knnFiltering();for (int i = 0; i < n; i++) {System.out.println(Arrays.toString(knnFiltered[i]));}noise(knnFiltered);}private static void noise(int[][] knnFiltered) {System.out.println("输出是否为噪声点");int[][] isNoisePoint=new int[n][m];for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {if(grid[i][j]!= knnFiltered[i][j]){isNoisePoint[i][j]=1;}}}for (int i = 0; i < n; i++) {System.out.println(Arrays.toString(isNoisePoint[i]));}System.out.println("噪声点坐标");ArrayList<int[]> noisePoints=new ArrayList<>();for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {if(isNoisePoint[i][j]==1){noisePoints.add(new int[]{i,j});}}}for (int[] noise:noisePoints) {System.out.print("("+noise[0]+","+noise[1]+")\t");}System.out.println();}private static int[][] knnFiltering() {int[][] knnFiltered=new int[n][m];for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {knnFiltered[i][j]=grid[i][j];}}for (int i = 1; i < n-1; i++) {for (int j = 1; j < m-1; j++) {knnFiltered[i][j]=knn(i,j);}}return knnFiltered;}private static int knn(int x, int y) {//优先队列：差值 和 本身的值PriorityQueue<int[]> queue=new PriorityQueue<>((a,b)->a[0]-b[0]);//按差值排列for (int i = x-1; i <= x+1; i++) {for (int j = y-1; j <= y+1; j++) {queue.add(new int[]{Math.abs(grid[i][j]-grid[x][y]),grid[i][j]});}}int sum=0;for (int i = 0; i < k; i++) {sum+=queue.poll()[1];}return (int)(1.0*sum/k+0.5);}}
输出原始图像
[1, 5, 255, 100, 200, 200]
[1, 7, 254, 101, 10, 9]
[3, 7, 10, 100, 2, 6]
[1, 0, 8, 7, 2, 1]
[1, 1, 6, 50, 2, 2]
[2, 3, 9, 7, 2, 0]
输出knn滤波图像
[1, 5, 255, 100, 200, 200]
[1, 6, 162, 64, 25, 9]
[3, 7, 8, 46, 4, 6]
[1, 1, 8, 7, 2, 1]
[1, 1, 7, 16, 2, 2]
[2, 3, 9, 7, 2, 0]
输出是否为噪声点
[0, 0, 0, 0, 0, 0]
[0, 1, 1, 1, 1, 0]
[0, 0, 1, 1, 1, 0]
[0, 1, 0, 0, 0, 0]
[0, 0, 1, 1, 0, 0]
[0, 0, 0, 0, 0, 0]
噪声点坐标
(1,1)	(1,2)	(1,3)	(1,4)	(2,2)	(2,3)	(2,4)	(3,1)	(4,2)	(4,3)

第十章 10二值图像的分析

贴标签 膨胀 腐蚀

在这里插入图片描述

1）

原始图像
1 1 1 0 0 0
1 0 0 1 0 1
1 0 0 0 0 1
0 0 1 0 1 1
0 1 0 0 1 0
0 0 0 1 0 0添标签
1 1 1 0 0 0
1 0 0 1 0 2
1 0 0 0 0 2
0 0 3 0 2 2
0 3 0 0 2 0
0 0 0 2 0 0

2）

原始图像
1 1 1 0 0 0
1 0 0 1 0 1
1 0 0 0 0 1
0 0 1 0 1 1
0 1 0 0 1 0
0 0 0 1 0 0腐蚀
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0膨胀
1 1 1 1 1 0
1 0 0 1 1 1
1 1 1 1 1 1
1 1 1 1 1 1
0 1 1 1 1 0
0 0 0 1 0 0

编程

import java.util.Arrays;
import java.util.Scanner;/**** 设一个二值图像为1 1 1 0 0 01 0 0 1 0 11 0 0 0 0 10 0 1 0 1 10 1 0 0 1 00 0 0 1 0 0* 1)在8连通意义下，对该图贴标签* 2)对上图分别进行一次腐蚀和膨胀运算，结构元素为S=[[1,0],[1,1]]* 结构元素原点在S的 (1,1) 坐标处*/public class Main8 {static int[][] grid;static int n;static int m;static int k=2;static int[][] s=new int[][]{{1,0},{1,1}};//------------------------------------------------------------------------------------public static void init(){grid= new int[][]{{1, 1, 1, 0, 0, 0},{1, 0, 0, 1, 0, 1},{1, 0, 0, 0, 0, 1},{0, 0, 1, 0, 1, 1},{0, 1, 0, 0, 1, 0},{0, 0, 0, 1, 0, 0}};n= grid.length;m=grid[0].length;}/*6 61 1 1 0 0 01 0 0 1 0 11 0 0 0 0 10 0 1 0 1 10 1 0 0 1 00 0 0 1 0 0*/public static void input(){Scanner scanner=new Scanner(System.in);n=scanner.nextInt();m=scanner.nextInt();grid=new int[n][m];for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {grid[i][j]=scanner.nextInt();}}}//------------------------------------------------------------------------------------public static void main(String[] args) {
//        input(); //输入init();//手动改值System.out.println("输出原始图像");for (int i = 0; i < n; i++) {System.out.println(Arrays.toString(grid[i]));}int[][] label=labeling();System.out.println("输出标签图像");for (int i = 0; i < n; i++) {System.out.println(Arrays.toString(label[i]));}int[][] corrosion=corrode();System.out.println("输出腐蚀图像");for (int i = 0; i < n; i++) {System.out.println(Arrays.toString(corrosion[i]));}int[][] expansion=expand();System.out.println("输出膨胀图像");for (int i = 0; i < n; i++) {System.out.println(Arrays.toString(expansion[i]));}}static boolean[][] visited;static int labelCount=1;//    /*//8邻域static int[][] step=new int[][]{{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}};static int stepN=8;
//     *//*//4邻域static int[][] step=new int[][]{{-1,0}, {0,-1}, {0,1}, {1,0}};static int stepN=4;*/private static int[][] labeling() {int[][] label=new int[n][m];for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {label[i][j]=grid[i][j];}}visited=new boolean[n][m];for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {if (grid[i][j]==1){if (!visited[i][j]){dfs(i,j,label);labelCount++;}}}}return label;}private static void dfs(int x, int y,int[][] label) {visited[x][y]=true;label[x][y]=labelCount;for (int i = 0; i < stepN; i++) {int nextX=x+step[i][0];int nextY=y+step[i][1];if(nextX>=0&&nextX<n&&nextY>=0&&nextY<m){if (grid[nextX][nextY]==1){if (!visited[nextX][nextY]){dfs(nextX,nextY,label);}}}}}//------------------------------------------------------------------------------------//求腐蚀图像private static int[][] corrode(){int[][] corrosion=new int[n][m];for (int i = 0; i < n-1; i++) {for (int j = 0; j < m-1; j++) {if (grid[i][j]==1){corrosion[i][j]=co(i,j);}}}return corrosion;}//腐蚀操作private static int co(int x, int y) {//是否被腐蚀int flag=1;for (int i = 0; i < k; i++) {for (int j = 0; j < k; j++) {if(s[i][j]==1){if (grid[x+i][y+j]!=1){flag=0;break;}}}if (flag==0){break;}}return flag;}//------------------------------------------------------------------------------------//求膨胀图像private static int[][] expand() {int[][] expansion=new int[n][m];for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {expansion[i][j]=grid[i][j];}}for (int i = 0; i < n-1; i++) {for (int j = 0; j < m-1; j++) {if (grid[i][j]==0){expansion[i][j]=ex(i,j);}}}return expansion;}//膨胀操作private static int ex(int x, int y) {//是否被膨胀int flag=0;for (int i = 0; i < k; i++) {for (int j = 0; j < k; j++) {if(s[i][j]==1){if (grid[x+i][y+j]==1){flag=1;break;}}}if (flag==1){break;}}return flag;}}
输出原始图像
[1, 1, 1, 0, 0, 0]
[1, 0, 0, 1, 0, 1]
[1, 0, 0, 0, 0, 1]
[0, 0, 1, 0, 1, 1]
[0, 1, 0, 0, 1, 0]
[0, 0, 0, 1, 0, 0]
输出标签图像
[1, 1, 1, 0, 0, 0]
[1, 0, 0, 1, 0, 2]
[1, 0, 0, 0, 0, 2]
[0, 0, 3, 0, 2, 2]
[0, 3, 0, 0, 2, 0]
[0, 0, 0, 2, 0, 0]
输出腐蚀图像
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
输出膨胀图像
[1, 1, 1, 1, 1, 0]
[1, 0, 0, 1, 1, 1]
[1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1]
[0, 1, 1, 1, 1, 0]
[0, 0, 0, 1, 0, 0]

4邻域下的贴标签

输出原始图像
[1, 1, 1, 0, 0, 0]
[1, 0, 0, 1, 0, 1]
[1, 0, 0, 0, 0, 1]
[0, 0, 1, 0, 1, 1]
[0, 1, 0, 0, 1, 0]
[0, 0, 0, 1, 0, 0]
输出标签图像
[1, 1, 1, 0, 0, 0]
[1, 0, 0, 2, 0, 3]
[1, 0, 0, 0, 0, 3]
[0, 0, 4, 0, 3, 3]
[0, 5, 0, 0, 3, 0]
[0, 0, 0, 6, 0, 0]

最后

2023-12-28 10:36:51

我们都有光明的未来

祝大家考研上岸
祝大家工作顺利
祝大家得偿所愿
祝大家如愿以偿
点赞收藏关注哦

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/581552.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Hadoop安装笔记_单机/伪分布式配置_Hadoop3.1.3——备赛笔记——2024全国职业院校技能大赛“大数据应用开发”赛项——任务2：离线数据处理

Hadoop安装笔记_单机/伪分布式配置_Hadoop3.1.3——备赛笔记——2024全国职业院校技能大赛“大数据应用开发”赛项——任务2：离线数据处理

将下发的ds_db01.sql数据库文件放置mysql中 12、编写Scala代码&#xff0c;使用Spark将MySQL的ds_db01库中表user_info的全量数据抽取到Hive的ods库中表user_info。字段名称、类型不变&#xff0c;同时添加静态分区&#xff0c;分区字段为etl_date&#xff0c;类型为String&am…
阅读更多...
代码审计必要性探讨

代码审计必要性探讨

1、背景 为了保证代码的质量&#xff0c;需要一系列的流程来进行保证&#xff1a; 今天要探讨的是代码审计的必要性。 2、代码审计 代码审计的做法多种多样&#xff0c;我理解必须解决以下问题 &#xff0c;才可能有效&#xff1a; 核心&#xff1a;审计的本质是对比&#…
阅读更多...
RabbitMQ 报错：Failed to declare queue(s):[QD, QA, QB]

RabbitMQ 报错：Failed to declare queue(s):[QD, QA, QB]

实在没想到会犯这种低级错误。 回顾整理一下吧&#xff1a; 原因&#xff1a;SpringBoot主配置类默认只会扫描自己所在的包及其子包下面的组件。其他位置的配置不会被扫描。 如果非要使用其他位置&#xff0c;就需要在启动类上面指定新的扫描位置。注意新的扫描位置会覆盖默…
阅读更多...
C# 运算符重载

C# 运算符重载

C# 运算符重载 运算符重载运算符重载的实现1. 类中重载的方法必须是public公有的2. 类中定义的重载方法必须是静态的3. 在运算符前需要加上关键字 operator 使用如下可重载和不可重载运算符实例 运算符重载 一提到 - * / %这种类似的运算符都应该很清楚是什么&#xff0c;但是…
阅读更多...
Unity网格篇Mesh（二）

Unity网格篇Mesh（二）

Unity网格篇Mesh&#xff08;二&#xff09; 介绍4.生成额外的顶点数据未计算法线计算法线没有法线vs有法线错误的UV坐标Clamping vs warpping正确的UV纹理&#xff0c;平铺&#xff08;1,1&#xff09; vs 平铺&#xff08;2,1&#xff09;凹凸不平的表面&#xff0c;产生了金…
阅读更多...
【Java 中锁的种类】

【Java 中锁的种类】

文章目录 一、公平锁和非公平锁二、可重入锁&#xff08;递归锁&#xff09;三、自旋锁四、独占锁(写锁)/共享锁(读锁)/互斥锁 提示&#xff1a;以下是本篇文章正文内容&#xff0c;下面案例可供参考 一、公平锁和非公平锁 遵守先来后到的是公平锁&#xff0c;不遵守的是非公…
阅读更多...
Mysql主从同步原理

Mysql主从同步原理

文章目录 前言同步原理复制的核心流程写在最后 前言 随着社会的进步大家对服务端应用程序的性能指标有着越来越高的要求&#xff0c;比如响应时间、吞吐率、QPS、TPS等等。基本上大多数系统都会要求响应时间不超过3s&#xff0c;当然对吞吐量和并发量也会根据具体的业务场景进…
阅读更多...
C#编程艺术：Fizzler库助您高效爬取www.twitter.com音频

C#编程艺术：Fizzler库助您高效爬取www.twitter.com音频

数据是当今数字时代的核心资源&#xff0c;但是从互联网上抓取数据并不容易。本文将教您如何利用C#编程艺术和Fizzler库高效爬取Twitter上的音频数据&#xff0c;让您轻松获取所需信息。 Twitter简介 Twitter是全球最大的社交媒体平台之一&#xff0c;包含丰富的音频资源。用…
阅读更多...
Android原生实现分段选择

Android原生实现分段选择

六年前写的一个控件&#xff0c;一直没有时间总结&#xff0c;趁年底不怎么忙&#xff0c;整理一下之前写过的组件。供大家一起参考学习。废话不多说&#xff0c;先上图。 一、效果图 实现思路使用的是radioGroup加radiobutton组合方式。原理就是通过修改RadioButton 的backgr…
阅读更多...
初始JVM

初始JVM

目录 一、什么是JVM 二、JVM与字节码 三、Java程序运行机制 四、JVM 的主要组成部分及其作用 一、什么是JVM JVM 本质上是一个运行在计算机上的程序&#xff0c;他的职责是运行Java字节码文件 二、JVM与字节码 三、Java程序运行机制 首先利用IDE集成开发工具编写Java源代码…
阅读更多...
Docker 部署RAP2

Docker 部署RAP2

1、Github介绍 https://github.com/thx/rap2-delos 2、安装Docker环境 yum install -y yum-utils device-mapper-persistent-data lvm2 yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo yum install -y docker-ce systemctl enable…
阅读更多...
环形链表、环形链表 II、有效的括号​​​​​​​（leetcode）

环形链表、环形链表 II、有效的括号​​​​​​​（leetcode）

目录 一、环形链表 方法&#xff08;快慢指针&#xff09;&#xff1a; 二、环形链表 II 三、有效的括号 一、环形链表 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链…
阅读更多...
C# 图标标注小工具-查看重复文件

C# 图标标注小工具-查看重复文件

目录 效果 项目 代码 下载 效果 项目 代码 using System; using System.Collections.Generic; using System.Data; using System.IO; using System.Linq; using System.Security.Cryptography; using System.Windows.Forms;namespace ImageDuplicate {public partial clas…
阅读更多...
SparkSQL 执行底层原理解析

SparkSQL 执行底层原理解析

从Spark SQL 底层架构可以看到&#xff0c;我们写的SQL语句&#xff0c;经过一个优化器&#xff08;Catalyst&#xff09;处理&#xff0c;转化为可执行的RDD&#xff0c;提交给集群执行。 SQL到RDD中间经过了一个Catalyst&#xff0c;它便是Spark SQL的核心&#xff0c;是针对…
阅读更多...
基于医疗AI、自然语言处理技术的智能导诊系统源码，java语言开发，自主版权，可扩展至H5、小程序、app等多端

基于医疗AI、自然语言处理技术的智能导诊系统源码，java语言开发，自主版权，可扩展至H5、小程序、app等多端

智能导诊系统源码&#xff0c;自主研发&#xff0c;演示应用案例 一、系统概述&#xff1a; 人体智能导诊系统&#xff1a;是基于医疗AI、自然语言处理技术&#xff0c;推出的在线导医分诊智能工具&#xff0c;在医疗中使用的引导患者自助就诊挂号。 在就诊的过程中有许多患者…
阅读更多...
QString的处理及中文乱码问题

QString的处理及中文乱码问题

QString 是 Qt 框架中用于表示字符串的一个类。它提供了丰富的功能来处理 Unicode 字符串&#xff0c;使得国际化和本地化的应用程序开发更加简单。QString 与标准 C 的 std::string 类似&#xff0c;但提供了更多与 Unicode 和国际化相关的功能。 常用功能 判空 代码演示 is…
阅读更多...
计算机网络复习1

计算机网络复习1

概论 文章目录 概论计算机网络的组成功能分类性能指标&#xff08;搞清楚每个时延的具体定义&#xff09;分层结构协议、接口和服务服务的分类ISO/OSITCP/IP两者的不同 计算机网络的组成 组成部分&#xff1a;硬件&#xff0c;软件和协议&#xff08;协议&#xff1a;传输数据…
阅读更多...
HPCC：高精度拥塞控制

HPCC：高精度拥塞控制

HPCC&#xff1a;高精度拥塞控制 文章目录 HPCC&#xff1a;高精度拥塞控制摘要1 引言1.1 背景1.2 现有CC的局限性1.3 HPCC的提出 2 研究动机2.1 大型RDMA部署2.2 RDMA目标2.3 当前RDMA CC中的权衡DCQCNTIMELY 2.4 下一代高速CC 3 技术方案3.1 INT3.2 HPCC设计3.3 HPPC的参数 4…
阅读更多...
【力扣题解】P404-左叶子之和-Java题解

【力扣题解】P404-左叶子之和-Java题解

&#x1f468;‍&#x1f4bb;博客主页&#xff1a;花无缺 欢迎 点赞&#x1f44d; 收藏⭐ 留言&#x1f4dd; 加关注✅! 本文由 花无缺 原创 收录于专栏 【力扣题解】 文章目录 【力扣题解】P404-左叶子之和-Java题解&#x1f30f;题目描述&#x1f4a1;题解&#x1f30f;总结…
阅读更多...
计算机毕业设计-----ssm流浪猫狗救助管理系统

计算机毕业设计-----ssm流浪猫狗救助管理系统

项目介绍 流浪猫狗救助管理系统。该项目分为前后台&#xff1b; 前台主要功能包括&#xff1a;会员的注册登陆,流浪猫狗知识&#xff0c;领养中心&#xff0c;团队活动&#xff0c;流浪宠物详情&#xff0c;申请领养等&#xff1b; 后台主要功能包括&#xff1a;管理员的用户…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023