2. 程式人生 > >Java種子填充演算法 四向和八向

Java種子填充演算法 四向和八向

阿新 • • 發佈：2018-11-26

種子填充演算法多用於計算機對圖形的處理。例如ps中填充區域一樣。當我們要填充某一塊區域，首先我們要讓電腦識別出你要填充的每個畫素點，種子演算法通過給定種子的座標獲取該畫素的顏色值，通過對比顏色資訊來判斷周圍的畫素是否是我們要選擇的。

接下來我們用一個字元陣列來代表我們的圖片，*號的點則是我們要選中的畫素，選擇後我們則將他改成#。

第一種：四向填充         

我們沒給定一個種子，我們則只獲取左、上、右、下四個點。通過遞迴或迴圈處理所有的點。但是用遞迴會存在遞迴的深度問題，當我們的圖片足夠大時，Java虛擬機器就會報出棧溢位的錯誤！

所以我們選取迴圈+佇列的方式。我們都知道佇列有個特性：先進先出！當我們根據種子點獲取周圍四個點加入佇列，下一次迴圈則從佇列頭部去除一個點作為下一次的種子，並刪除他，依次這樣迴圈直到佇列大小為零則停止。

Demo1.COL、Demo1.ROW為定義字元陣列的行列

/**
	 * 四向
	 * @param seed
	 */
	public void DemoFill4(Point se) {
		Point seed = se;
		do {
			//左
			if(0<=(seed.x-1)&&(seed.x-1)<Demo1.ROW&&0<=(seed.y)&&(seed.y)<Demo1.COL&&!point[seed.x-1][seed.y].equals(c)) {
				point[seed.x-1][seed.y] = c;
				queue.offer(new Point(seed.x-1,seed.y));
				
			}
			//上
			if(0<=(seed.x)&&(seed.x)<Demo1.ROW&&0<=(seed.y-1)&&(seed.y-1)<Demo1.COL&&!point[seed.x][seed.y-1].equals(c)) {
				point[seed.x][seed.y-1] = c;
				queue.offer(new Point(seed.x,seed.y-1));
				
			}
			//右
			if(0<=(seed.x+1)&&(seed.x+1)<Demo1.ROW&&0<=(seed.y)&&(seed.y)<Demo1.COL&&!point[seed.x+1][seed.y].equals(c)) {
				point[seed.x+1][seed.y] = c;
				queue.offer(new Point(seed.x+1,seed.y));
				
			}
			//下
			if(0<=(seed.x)&&(seed.x)<Demo1.ROW&&0<=(seed.y+1)&&(seed.y+1)<Demo1.COL&&!point[seed.x][seed.y+1].equals(c)) {
				point[seed.x][seed.y+1] = c;
				queue.offer(new Point(seed.x,seed.y+1));
				
			}

			if(queue.size()>0) {
				point[seed.x][seed.y] = c;
				Point s = (Point) queue.poll();
				point[s.x][s.y] = c;
				seed = s;
				
				
			}else {
				return;
			}

		}while(true);

	}

為了提高演算法的效能，則可以在加入周圍點的同時也改變周圍點。

 

第二種：八向填充       八向填充和四向不同的地方就是他選取了八個方向的點主要是解決邊角問題。

/**
	 * 八向
	 * @param seed
	 */
	public void DemoFill8(Point se) {
		Point seed = se;
		do {
			//左
			if(0<=(seed.x-1)&&(seed.x-1)<Demo1.ROW&&0<=(seed.y)&&(seed.y)<Demo1.COL&&!point[seed.x-1][seed.y].equals(c)) {
				point[seed.x-1][seed.y] = c;
				queue.offer(new Point(seed.x-1,seed.y));
				
			}
			//左上
			if(0<=(seed.x-1)&&(seed.x-1)<Demo1.ROW&&0<=(seed.y-1)&&(seed.y-1)<Demo1.COL&&!point[seed.x-1][seed.y-1].equals(c)) {
				point[seed.x-1][seed.y-1] = c;
				queue.offer(new Point(seed.x-1,seed.y-1));
				
			}
			//上
			if(0<=(seed.x)&&(seed.x)<Demo1.ROW&&0<=(seed.y-1)&&(seed.y-1)<Demo1.COL&&!point[seed.x][seed.y-1].equals(c)) {
				point[seed.x][seed.y-1] = c;
				queue.offer(new Point(seed.x,seed.y-1));
				
			}
			//右上
			if(0<=(seed.x+1)&&(seed.x+1)<Demo1.ROW&&0<=(seed.y-1)&&(seed.y-1)<Demo1.COL&&!point[seed.x+1][seed.y-1].equals(c)) {
				point[seed.x+1][seed.y-1] = c;
				queue.offer(new Point(seed.x+1,seed.y-1));
				
			}
			//右
			if(0<=(seed.x+1)&&(seed.x+1)<Demo1.ROW&&0<=(seed.y)&&(seed.y)<Demo1.COL&&!point[seed.x+1][seed.y].equals(c)) {
				point[seed.x+1][seed.y] = c;
				queue.offer(new Point(seed.x+1,seed.y));
				
			}
			//右下
			if(0<=(seed.x+1)&&(seed.x+1)<Demo1.ROW&&0<=(seed.y+1)&&(seed.y+1)<Demo1.COL&&!point[seed.x+1][seed.y+1].equals(c)) {
				point[seed.x+1][seed.y+1] = c;
				queue.offer(new Point(seed.x+1,seed.y+1));
				
			}
			//下
			if(0<=(seed.x)&&(seed.x)<Demo1.ROW&&0<=(seed.y+1)&&(seed.y+1)<Demo1.COL&&!point[seed.x][seed.y+1].equals(c)) {
				point[seed.x][seed.y+1] = c;
				queue.offer(new Point(seed.x,seed.y+1));
				
			}
			//左下
			if(0<=(seed.x-1)&&(seed.x-1)<Demo1.ROW&&0<=(seed.y+1)&&(seed.y+1)<Demo1.COL&&!point[seed.x-1][seed.y+1].equals(c)) {
				point[seed.x-1][seed.y+1] = c;
				queue.offer(new Point(seed.x-1,seed.y+1));
				
			}

			if(queue.size()>0) {
				point[seed.x][seed.y] = c;
				Point s = (Point) queue.poll();
				point[s.x][s.y] = c;
				seed = s;

			}else {
				return;
			}
		}while(true);

	}

 

 

完整樣例如下：

 

Point.java

package com.lb.test;
/**
 * 物件點
 * @author lanbing
 * @date 2018年9月17日
 *
 */
public class Point {
	public int x;
	public int y;
	
	public Point(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}
	
}

Fill.java

package com.lb.test;

import java.util.LinkedList;
import java.util.Queue;
/**
 * 四向，八向
 * @author lanbing
 * @date 2018年9月17日
 *
 */
public class Fill {
	public String[][] point;
	public String c;
	Queue<Point> queue = new LinkedList<Point>();

	public Fill(String[][] point, String c) {
		super();
		this.point = point;
		this.c = c;

	}

	/**
	 * 四向
	 * @param seed
	 */
	public void DemoFill4(Point se) {
		Point seed = se;
		do {
			//左
			if(0<=(seed.x-1)&&(seed.x-1)<Demo1.ROW&&0<=(seed.y)&&(seed.y)<Demo1.COL&&!point[seed.x-1][seed.y].equals(c)) {
				point[seed.x-1][seed.y] = c;
				queue.offer(new Point(seed.x-1,seed.y));
				
			}
			//上
			if(0<=(seed.x)&&(seed.x)<Demo1.ROW&&0<=(seed.y-1)&&(seed.y-1)<Demo1.COL&&!point[seed.x][seed.y-1].equals(c)) {
				point[seed.x][seed.y-1] = c;
				queue.offer(new Point(seed.x,seed.y-1));
				
			}
			//右
			if(0<=(seed.x+1)&&(seed.x+1)<Demo1.ROW&&0<=(seed.y)&&(seed.y)<Demo1.COL&&!point[seed.x+1][seed.y].equals(c)) {
				point[seed.x+1][seed.y] = c;
				queue.offer(new Point(seed.x+1,seed.y));
				
			}
			//下
			if(0<=(seed.x)&&(seed.x)<Demo1.ROW&&0<=(seed.y+1)&&(seed.y+1)<Demo1.COL&&!point[seed.x][seed.y+1].equals(c)) {
				point[seed.x][seed.y+1] = c;
				queue.offer(new Point(seed.x,seed.y+1));
				
			}

			if(queue.size()>0) {
				point[seed.x][seed.y] = c;
				Point s = (Point) queue.poll();
				point[s.x][s.y] = c;
				seed = s;
				
				
			}else {
				return;
			}

		}while(true);

	}

	/**
	 * 八向
	 * @param seed
	 */
	public void DemoFill8(Point se) {
		Point seed = se;
		do {
			//左
			if(0<=(seed.x-1)&&(seed.x-1)<Demo1.ROW&&0<=(seed.y)&&(seed.y)<Demo1.COL&&!point[seed.x-1][seed.y].equals(c)) {
				point[seed.x-1][seed.y] = c;
				queue.offer(new Point(seed.x-1,seed.y));
				
			}
			//左上
			if(0<=(seed.x-1)&&(seed.x-1)<Demo1.ROW&&0<=(seed.y-1)&&(seed.y-1)<Demo1.COL&&!point[seed.x-1][seed.y-1].equals(c)) {
				point[seed.x-1][seed.y-1] = c;
				queue.offer(new Point(seed.x-1,seed.y-1));
				
			}
			//上
			if(0<=(seed.x)&&(seed.x)<Demo1.ROW&&0<=(seed.y-1)&&(seed.y-1)<Demo1.COL&&!point[seed.x][seed.y-1].equals(c)) {
				point[seed.x][seed.y-1] = c;
				queue.offer(new Point(seed.x,seed.y-1));
				
			}
			//右上
			if(0<=(seed.x+1)&&(seed.x+1)<Demo1.ROW&&0<=(seed.y-1)&&(seed.y-1)<Demo1.COL&&!point[seed.x+1][seed.y-1].equals(c)) {
				point[seed.x+1][seed.y-1] = c;
				queue.offer(new Point(seed.x+1,seed.y-1));
				
			}
			//右
			if(0<=(seed.x+1)&&(seed.x+1)<Demo1.ROW&&0<=(seed.y)&&(seed.y)<Demo1.COL&&!point[seed.x+1][seed.y].equals(c)) {
				point[seed.x+1][seed.y] = c;
				queue.offer(new Point(seed.x+1,seed.y));
				
			}
			//右下
			if(0<=(seed.x+1)&&(seed.x+1)<Demo1.ROW&&0<=(seed.y+1)&&(seed.y+1)<Demo1.COL&&!point[seed.x+1][seed.y+1].equals(c)) {
				point[seed.x+1][seed.y+1] = c;
				queue.offer(new Point(seed.x+1,seed.y+1));
				
			}
			//下
			if(0<=(seed.x)&&(seed.x)<Demo1.ROW&&0<=(seed.y+1)&&(seed.y+1)<Demo1.COL&&!point[seed.x][seed.y+1].equals(c)) {
				point[seed.x][seed.y+1] = c;
				queue.offer(new Point(seed.x,seed.y+1));
				
			}
			//左下
			if(0<=(seed.x-1)&&(seed.x-1)<Demo1.ROW&&0<=(seed.y+1)&&(seed.y+1)<Demo1.COL&&!point[seed.x-1][seed.y+1].equals(c)) {
				point[seed.x-1][seed.y+1] = c;
				queue.offer(new Point(seed.x-1,seed.y+1));
				
			}

			if(queue.size()>0) {
				point[seed.x][seed.y] = c;
				Point s = (Point) queue.poll();
				point[s.x][s.y] = c;
				seed = s;

			}else {
				return;
			}
		}while(true);

	}

}

Demo.java

package com.lb.test;

import java.util.LinkedList;
/**
 * 種子填充演算法
 * @author lanbing
 * @date 2018年9月17日
 *
 */
public class Demo1 {
	//矩陣的行列
	public final static int ROW = 19;
	public final static int COL = 19;

	//生成三列分割點
	public final static int[] COL1 = new int[] {4,8,12};

	//生成三行分割點
	public final static int[] ROW1 = new int[] {4,8,12};

	//填充的字元
	public final static String FILLCHAR = "#";

	//生成的隨機點
	public final static int SUM = 50;


	public static void main(String[] args) {

		String[][] point = new String[ROW][COL];

		//初始化矩陣
		for(int i=0;i<ROW;i++) {
			for(int j=0;j<COL;j++) {
				if(i==0){
					point[i][j] = FILLCHAR;
				}else if(i==ROW-1){
					point[i][j] = FILLCHAR;
				}else if(j==0){
					point[i][j] = FILLCHAR;
				}else if(j==COL-1){
					point[i][j] = FILLCHAR;
				}else {
					point[i][j] = "*";
				}
			}
		}

		//顯示矩陣
		ShowPoint(point);
		System.out.println();

//		//新增縱向分隔
//		AddColPoint(point);
//
//		ShowPoint(point);
//		System.out.println();
//
//		//新增橫向分隔
//		AddRowPoint(point);
//
//		ShowPoint(point);
//		System.out.println();
//
//		
//		point[4][4] = "*";
//
//
//		ShowPoint(point);
//		System.out.println();
//		
//		
//		//生成隨機點
//		GetRandom(50,point);
//		ShowPoint(point);

		
		Point seed = new Point(3, 3);
		Fill f = new Fill(point, FILLCHAR);
		f.DemoFill8(seed);
		
		ShowPoint(f.point);

	}

	/**
	 * 展示矩陣
	 * @param point
	 */
	public static void ShowPoint(String[][] point) {
		for(int i=0;i<ROW;i++) {
			for(int j=0;j<COL;j++) {
				System.out.print(point[i][j]);
			}
			System.out.println();
		}
	}

	/**
	 * 隨機生成干擾點
	 * @param n
	 * @return
	 */
	public static void GetRandom(int n,String[][] point){
		LinkedList<Point> p = new LinkedList<Point>();

		do {
			if(p.size()>=n) {
				break;
			}else {
				Point po = new Point((int)Math.floor(Math.random()*ROW),(int)Math.floor(Math.random()*COL));
				if(!p.contains(po)) {
					p.add(po);
				}
			}
		}while(true);

		for(int i=0;i<p.size();i++) {
			point[p.get(i).x][p.get(i).y] = "#";
		}
	}

	/**
	 * 三列分割點
	 * @return
	 */
	public static void AddColPoint(String[][] point) {
		for(int i=0;i<ROW;i++) {
			for(int j=0;j<COL;j++) {
				for(int k=0;k<COL1.length;k++) {
					if(j==COL1[k]) {
						point[i][j] = FILLCHAR;
					}
				}
			}
		}
	}

	/**
	 * 三橫分割點
	 * @return
	 */
	public static void AddRowPoint(String[][] point) {
		for(int i=0;i<ROW;i++) {
			for(int j=0;j<COL;j++) {
				for(int k=0;k<ROW1.length;k++) {
					if(i==ROW1[k]) {
						point[i][j] = FILLCHAR;
					}
				}
			}
		}
	}
}

 

有不對的地方請多多指教！

 

相關推薦

Java種子填充演算法 四向和八向

種子填充演算法多用於計算機對圖形的處理。例如ps中填充區域一樣。當我們要填充某一塊區域，首先我們要讓電腦識別出你要填充的每個畫素點，種子演算法通過給定種子的座標獲取該畫素的顏色值，通過對比顏色資訊來判斷周圍的畫素是否是我們要選擇的。 接下來我們用一個字元陣列來代表我們的圖片，*號的點則是我們要選

種子填充演算法（簡單和掃描線）

簡單的種子填充演算法 掃描線種子填充演算法 種子填充演算法的思路就是通過區域的一點賦予指定的顏色，然後通過填充其周圍的畫素點，從而將填充顏色擴充套件到整個顏色區域的過程。 如何畫圖 我們已經知道有很多工具可以拿來畫圖，比如MFC或者是Open

基於佇列和雜湊的種子填充演算法

繼 https://blog.csdn.net/u013749051/article/details/84553642 之後， 我又對種子填充演算法進行了改進，主要利用了雜湊的思想，以空間換時間，把這個演算法的速度再次優化了。 這次的優化效果非常好，填充大面積區域稍有卡頓。 下面是效果圖

JAVA多執行緒(四) Executor併發框架向RabbitMQ推送訊息

github程式碼地址：https://github.com/showkawa/springBoot_2017/tree/master/spb-demo  假設一個需求使用者點選某個頁面，我們後臺需要向MQ推送信資訊 1，模擬的MQ服務，我這邊使用RabbitMQ (關於MQ 傳送和監聽訊息可以

（8）種子填充演算法

兩種連通區域  四連通區域：從區域內一點出發，可通過上、下、左、右四個方向的移動組合，在不越出區域的前提下，能到達區域內的任意畫素  八連通區域：從區域內每一畫素出發，可通過八個方向，即上、下、左、右、左上、右上、左下、右下移動的組合，在不越出區域的前提下，能到達區域

基於集合的種子填充演算法

通過實踐，我們不難發現，基礎的種子填充演算法根本沒法使用。常常遇到的問題是：Stack Overflow （棧溢位）。 一種可行的解決辦法是通過自己構建資料結構棧來將遞迴演算法改非遞迴演算法，但是實踐的執行結果還是極其緩慢。 現在通過使用集合來優化這個演算法，雖然效率仍然不理想，但還是有一定

【區域填充】中的種子填充演算法

假定：①邊界畫素給定 ②內部一個畫素（種子）給定–適合互動 （1）四連通法（4-connected） 向四個方向檢查，填色，擴散。遍歷區域內所有畫素。 （2）八連通法（8-connected） 向四個方向檢查，填色，擴散。遍歷區域內所有畫素。

算法系列之十二：多邊形區域填充演算法－－遞迴種子填充演算法

         平面區域填充演算法是計算機圖形學領域的一個很重要的演算法，區域填充即給出一個區域的邊界（也可以是沒有邊界，只是給出指定顏色），要求將邊界範圍內的所有象素單元都修改成指定的顏色（也可能是圖案填充）。區域填充中最常用的是多邊形填色，本文中我們就討論幾種多邊形區域

Atitit Seed-Filling種子填充演算法attilax總結

個人說明 提供相關技術諮詢，以及解決方案編制，編制相關標準化規範草案，軟體培訓與技術點體系建設，知識圖譜體系化，提供軟體行業顧問佈道，12年的軟體行業背景，歡迎有志於軟體行業的同仁們互相交流，群名稱：標準化規範工作組草案，群   號：518818717， 聯絡方式: [

算法系列之十二：多邊形區域填充演算法－－掃描線種子填充演算法

1.3掃描線種子填充演算法        1.1和1.2節介紹的兩種種子填充演算法的優點是非常簡單，缺點是使用了遞迴演算法，這不但需要大量棧空間來儲存相鄰的點，而且效率不高。為了減少演算法中的遞迴呼叫，節省棧空間的使用，人們提出了很多改進演算法，其中一種就是掃描線種子填充演算

圖形填充演算法（掃描線種子填充演算法）

好多天沒去上圖形學的課了，今天聽說要交幾個圖形學的演算法實現程式，就花了將近一天的時間終於將程式除錯通過了，可是到了實驗室，才知道老師根本沒時間檢查。哎，白寫了^_^.說笑了，其實不寫怎麼能真正理解演算法的真諦呢。現在將程式貼出來，以備將來有學弟學妹之用。（其實如果只是Cop

種子填充演算法(計算機圖形學)

#include <graphics.h> #include <iostream> using namespace std; <span style="white-space:pre"> </span>//種子填充演算法四

神經網路中的前向和後向演算法

  最近深度學習的研究在學界火的一塌糊塗，大老闆終於也下定決心組織實驗室開展相關研究了，何況實驗室的主流方向是做成像的，不做點這方面的研究感覺說不過去。研究生小朋友們剛進來還得看視覺方面的東西，博三博四的師兄師姐們基本都達到畢業要求了已經無心學習，最後這種為實驗

卷積神經網路CNN的前向和後向傳播（一）

卷積神經網路CNN的前向和後向傳播 卷積運算與相關的區別 卷積運算的正向和反向傳播 原文 Forward And Backpropagation in Convolutional Neural Network地址： https://medium.

卷積神經網路CNN的前向和後向傳播（二）

卷積神經網路CNN的前向和後向傳播（二） padding=1，stride=1的情形 輸入為8x8和卷積核3x3 對輸入的求導 對卷積核的求導 本文在卷積神經網路CNN的前向和後向傳播（一）的基礎上做一些擴充套件

機器學習筆記（十四）——HMM估計問題和前向後向演算法

一、隱馬爾科夫鏈的第一個基本問題     估計問題：給定一個觀察序列O=O1O2…OT和模型u=(A,B,π),如何快速地計算出給定模型u情況下，觀察序列O的概率， 即P(O|u)? 二、求解觀察序列的概率     其實，求解這個問題就是一個解碼問題。

聊聊高併發（四十二）解析java.util.concurrent各個元件（十八） 任務的批量執行和CompletionService

上一篇講了ExecutorService關於任務的非同步執行和狀態控制的部分，這篇說說關於任務批量執行的部分。ExecutorSerivce中關於批量執行的介面如下 <T> List<Future<T>> invokeAll(Collec

Java（第四章和第五章）

簡潔 重復 清晰 快速 結束 編寫 int() input 出現 第四章 一、 switch結構（開關語句）的語法 switch(表達式[dream1] ){ case 常量1[dream2] : //語句塊1

Java基礎學習筆記八 Java基礎語法之接口和多態

java cas 發現 過程 類類型 結果 覆寫 實例 new 接口 接口概念 接口是功能的集合，同樣可看做是一種數據類型，是比抽象類更為抽象的”類”。接口只描述所應該具備的方法，並沒有具體實現，具體的實現由接口的實現類(相當於接口的子類)來完成

Java之集合(四)Vector和Stack

index 說明 原因 play 技術分享 操作 決定 lis java集合 　　轉載請註明源出處：http://www.cnblogs.com/lighten/p/7296023.html 1.前言 　　本章介紹Java集合List中的Vector和其子類Stack。Ve