adding support for ortho-ortho-diagonal conflicts (5d6289e3) · Commits · Elphel / imagej-elphel

src/main/java/Conflict.java

0 → 100644

+194 −0

Original line number	Diff line number	Diff line
		/**
		**
		** Conflict - Represent a "conflit" between connected supertiles
		**
		** Copyright (C) 2017 Elphel, Inc.
		**
		-----------------------------------------------------------------------------
		**
		** Conflict.java is free software: you can redistribute it and/or modify
		** it under the terms of the GNU General Public License as published by
		** the Free Software Foundation, either version 3 of the License, or
		** (at your option) any later version.
		**
		** This program is distributed in the hope that it will be useful,
		** but WITHOUT ANY WARRANTY; without even the implied warranty of
		** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		** GNU General Public License for more details.
		**
		** You should have received a copy of the GNU General Public License
		** along with this program. If not, see <http://www.gnu.org/licenses/>.
		-----------------------------------------------------------------------------
		**
		*/

		public class Conflict{
		int start_layer;
		int end_layer;
		boolean [] start_dirs = new boolean[24];
		// 0 ... 7 - ortho-diagonal-ortho
		// 0 ... 3 from start_layer to end_layer: 0 - start_layer->N->SE->W->end_layer, 1 - start_layer->E->SW->N->end_layer, ...
		// 4 ... 7 from end_layer to start_layer: 4 - end_layer->N->SE->W->start_layer, 7 - end_layer->E->SW->N->start_layer, ...
		// 8 ... 15 - ortho-ortho-diagonal (turn right)
		// 8 ... 11 : 8 - start_layer->N->E->SW->end_layer, 9 - start_layer->E->S->NW->end_layer, ...
		// 12 ... 15 : 12 - end_layer->N->E->SW->start_layer, 13 - end_layer->E->S->NW->start_layer, ...
		// 16 ... 23 - ortho-ortho-diagonal (turn left)
		// 16 ... 19 : 16 - start_layer->N->W->SE->end_layer, 17 - start_layer->E->N->SW->end_layer, ...
		// 20 ... 23 : 20 - end_layer->N->W->SE->start_layer, 21 - end_layer->E->N->SW->start_layer, ...

		Conflict(int start_layer, int end_layer, int start_dir) // for ortho-diag-ortho
		{
		if (end_layer > start_layer) {
		this.start_layer = start_layer;
		this.end_layer = end_layer;
		this.start_dirs[start_dir] = true;
		} else {
		this.start_layer = end_layer;
		this.end_layer = start_layer;
		this.start_dirs[start_dir + 4] = true;

		}
		}

		Conflict(int start_layer, int end_layer, int start_dir, boolean right) // for ortho-ortho-diag
		{
		if (end_layer > start_layer) {
		this.start_layer = start_layer;
		this.end_layer = end_layer;
		this.start_dirs[(right? 8 : 12) + start_dir] = true;
		} else {
		this.start_layer = end_layer;
		this.end_layer = start_layer;
		this.start_dirs[(right? 16 : 20) + start_dir] = true;
		}
		}

		Conflict(int [] arr)
		{
		this.start_layer = arr[0];
		this.end_layer = arr[1];
		for (int i = 0; i < start_dirs.length; i++){
		start_dirs[i] = (arr[2] & (1 << i)) != 0;
		}
		}
		Conflict(int bits)
		{
		this.start_layer = -1;
		this.end_layer = -1;
		for (int i = 0; i < start_dirs.length; i++){
		start_dirs[i] = (bits & (1 << i)) != 0;
		}
		}



		boolean combine (Conflict other_conflict)
		{
		if ((other_conflict.start_layer == this.start_layer) && (other_conflict.end_layer == this.end_layer)) {
		for (int i = 0; i < start_dirs.length; i++) start_dirs[i] \|= other_conflict.start_dirs[i];
		return true;
		}
		return false;
		}

		int getStartLayer(){
		return start_layer;
		}

		int getEndLayer(){
		return end_layer;
		}

		int getDirBits(){
		int dirs_bits = 0;
		for (int i = 0; i < start_dirs.length; i++){
		if (start_dirs[i]) dirs_bits \|= (1 << i);
		}
		return dirs_bits;
		}

		int getDirBitsOrthoDiagOrtho(){
		int dirs_bits = 0;
		for (int i = 0; i < 8; i++){
		if (start_dirs[i]) dirs_bits \|= (1 << i);
		}
		return dirs_bits;
		}

		int getDirBitsOrthoOrthoDiag(boolean right){
		int dirs_bits = 0;
		if (right) {
		for (int i = 0; i < 8; i++){
		if (start_dirs[i]) dirs_bits \|= (1 << (i + 8));
		}
		} else {
		for (int i = 0; i < 8; i++){
		if (start_dirs[i]) dirs_bits \|= (1 << (i + 16));
		}

		}
		return dirs_bits;
		}

		int [] toArray()
		{
		int dirs_bits = 0;
		for (int i = 0; i < start_dirs.length; i++){
		if (start_dirs[i]) dirs_bits \|= (1 << i);
		}
		int [] rslt = {start_layer, end_layer, dirs_bits};
		return rslt;
		}

		int getNumConflicts(){
		int numbits = 0;
		for (int i = 0; i < start_dirs.length; i++){
		if (start_dirs[i]) numbits++;
		}
		return numbits;
		}

		int getNumOrthoDiagOrthoConflicts(){
		int numbits = 0;
		for (int i = 0; i < 8; i++){
		if (start_dirs[i]) numbits++;
		}
		return numbits;
		}

		int getNumOrthoOrthoDiagConflicts(){
		int numbits = 0;
		for (int i = 8; i < 24; i++){
		if (start_dirs[i]) numbits++;
		}
		return numbits;
		}

		int getIncompatibleOrthoDiagOrthoConflicts(){
		int num_incompat = 0;
		for (int i = 0; i < 8; i++){
		if (start_dirs[i]) {
		int [] incomp_bits= {
		i ^ 4,
		(i & 4) \| ((i + 1) & 3),
		(i & 4) \| ((i - 1) & 3)};
		for (int j = 1; j < 3; j++){ // skip dual triangles
		int i1 = incomp_bits[j];
		if (start_dirs[i1]){
		num_incompat ++;
		}
		}
		}
		}
		return num_incompat / 2;
		}

		public int getDualTriOrthoDiagOrthoConflicts()
		{
		int num_dual = 0;
		for (int i = 0; i < 4; i++) if (start_dirs[i] && start_dirs[i + 4]) num_dual++;
		return num_dual;
		}


		}

src/main/java/Conflicts.java

0 → 100644

+394 −0

Original line number	Diff line number	Diff line
		/**
		**
		** Conflicts - Represent "conflicts" (instances of Conflict) between connected supertiles
		**
		** Copyright (C) 2017 Elphel, Inc.
		**
		-----------------------------------------------------------------------------
		**
		** Conflicts.java is free software: you can redistribute it and/or modify
		** it under the terms of the GNU General Public License as published by
		** the Free Software Foundation, either version 3 of the License, or
		** (at your option) any later version.
		**
		** This program is distributed in the hope that it will be useful,
		** but WITHOUT ANY WARRANTY; without even the implied warranty of
		** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		** GNU General Public License for more details.
		**
		** You should have received a copy of the GNU General Public License
		** along with this program. If not, see <http://www.gnu.org/licenses/>.
		-----------------------------------------------------------------------------
		**
		*/

		import java.util.ArrayList;
		import java.util.HashMap;
		import java.util.concurrent.atomic.AtomicInteger;

		public class Conflicts {
		private int [] num_ortho_diag_ortho = new int [8];
		private int [] num_ortho_ortho_diag = new int [16];
		private int [] num_all_conflicts = new int [24];
		private int num_ortho_incompat = 0;
		private int num_ortho_dual = 0;
		private int num_conflicts;
		private SuperTiles st = null;

		public Conflicts(
		SuperTiles st){
		this.st = st;
		}

		public Conflicts(
		int [][][] conflicts,
		SuperTiles st,
		int debugLevel)
		{
		this.st = st;
		addConflicts( conflicts, debugLevel);
		}
		public Conflicts(
		int [][][] conflicts,
		SuperTiles st)
		{
		this.st = st;
		addConflicts( conflicts, -1);
		}

		public Conflicts(
		Conflict [][] conflicts,
		SuperTiles st,
		int debugLevel)
		{
		this.st = st;
		addConflicts( conflicts, debugLevel);
		}
		public Conflicts(
		Conflict [][] conflicts,
		SuperTiles st)
		{
		this.st = st;
		addConflicts( conflicts, -1);
		}
		public void addConflicts(Conflicts conflicts){
		addsubConflicts(conflicts, false);
		}
		public void subConflicts(Conflicts conflicts){
		addsubConflicts(conflicts, true);
		}

		public void addsubConflicts(Conflicts conflicts, boolean sub)
		{
		int s = sub? -1: 1;
		for (int i = 0; i < num_ortho_diag_ortho.length; i++) num_ortho_diag_ortho[i] += s * conflicts.num_ortho_diag_ortho[i];
		for (int i = 0; i < num_ortho_ortho_diag.length; i++) num_ortho_ortho_diag[i] += s * conflicts.num_ortho_ortho_diag[i];
		for (int i = 0; i < num_all_conflicts.length; i++) num_all_conflicts[i] += s * conflicts.num_all_conflicts[i];
		num_ortho_incompat += s * conflicts.num_ortho_incompat;
		num_ortho_dual += s * conflicts.num_ortho_dual;
		num_conflicts += s * conflicts.num_conflicts;

		}

		public int addConflicts(
		int [][][] conflicts,
		int debugLevel)
		{
		for (int nsTile = 0; nsTile < conflicts.length; nsTile++) if (conflicts[nsTile] != null){
		for (int nc = 0; nc < conflicts[nsTile].length; nc++){
		Conflict conf = new Conflict(conflicts[nsTile][nc]);
		if (conf.getNumOrthoDiagOrthoConflicts() > 0) num_ortho_diag_ortho[conf.getNumOrthoDiagOrthoConflicts() - 1]++;
		if (conf.getNumOrthoOrthoDiagConflicts() > 0) num_ortho_ortho_diag[conf.getNumOrthoOrthoDiagConflicts() - 1]++;
		if (conf.getNumConflicts() > 0) num_all_conflicts[conf.getNumConflicts() - 1]++;
		num_ortho_incompat += conf.getIncompatibleOrthoDiagOrthoConflicts();
		num_ortho_dual += conf.getDualTriOrthoDiagOrthoConflicts();
		num_conflicts += conf.getNumConflicts();
		if (debugLevel > 0){
		printConflict("addConflicts() nsTile = "+nsTile, conf);
		}
		}
		}
		return num_conflicts;
		}

		public int addConflicts(
		Conflict [][] conflicts,
		int debugLevel)
		{
		for (int nsTile = 0; nsTile < conflicts.length; nsTile++) if (conflicts[nsTile] != null){
		for (int nc = 0; nc < conflicts[nsTile].length; nc++){
		Conflict conf = conflicts[nsTile][nc];
		if (conf.getNumOrthoDiagOrthoConflicts() > 0) num_ortho_diag_ortho[conf.getNumOrthoDiagOrthoConflicts() - 1]++;
		if (conf.getNumOrthoOrthoDiagConflicts() > 0) num_ortho_ortho_diag[conf.getNumOrthoOrthoDiagConflicts() - 1]++;
		if (conf.getNumConflicts() > 0) num_all_conflicts[conf.getNumConflicts() - 1]++;
		num_ortho_incompat += conf.getIncompatibleOrthoDiagOrthoConflicts();
		num_ortho_dual += conf.getDualTriOrthoDiagOrthoConflicts();
		num_conflicts += conf.getNumConflicts();
		if (debugLevel > 0){
		printConflict("addConflicts() nsTile = "+nsTile, conf);
		}
		}
		}
		return num_conflicts;
		}

		public int [] getNumOrthoDiagOrtho(){
		return num_ortho_diag_ortho;
		}
		public int [] getNumOrthoOrthoDiag(){
		return num_ortho_ortho_diag;
		}
		public int [] getNumAllConflicts(){
		return num_all_conflicts;
		}
		public int getNumOrthoIncompat(){
		return num_ortho_incompat;
		}
		public int getNumOrthoDual(){
		return num_ortho_dual;
		}
		public int getNumConflicts(){
		return num_conflicts;
		}

		public void printConflict(String prefix, Conflict conf)
		{
		System.out.println(prefix+
		" nl1 = "+ conf.getStartLayer()+
		" nl2 = "+ conf.getEndLayer()+
		" all = "+ conf.getNumConflicts() + " ("+String.format("%06x", conf.getDirBits())+")" +
		" odo = "+ conf.getNumOrthoDiagOrthoConflicts() +
		" ood = "+ conf.getNumOrthoOrthoDiagConflicts() +
		" number of odo incompatible triangles = "+ conf.getIncompatibleOrthoDiagOrthoConflicts() +
		" number of odo dual triangles = "+conf.getDualTriOrthoDiagOrthoConflicts());
		}

		public int numBetterWorse(
		boolean better,
		boolean use_all,
		boolean use_odo,
		boolean use_ood)
		{
		int num = 0;
		if (use_all) {
		for (int i = 0; i < num_all_conflicts.length; i++){
		if (better?(num_all_conflicts[i] < 0):(num_all_conflicts[i] > 0)) num++;
		}
		}
		if (use_odo) {
		for (int i = 0; i < num_ortho_diag_ortho.length; i++){
		if (better?(num_ortho_diag_ortho[i] < 0):(num_ortho_diag_ortho[i] > 0)) num++;
		}
		if (better? (num_ortho_incompat < 0) : (num_ortho_incompat > 0)) num++;
		if (better? (num_ortho_dual < 0) : (num_ortho_dual > 0)) num++;

		}
		return num;
		}


		public void printConflictSummary(
		String prefix,
		boolean use_all,
		boolean use_odo,
		boolean use_ood)
		{
		System.out.print(prefix);
		if (use_all) {
		for (int i = 0; i < num_all_conflicts.length; i++){
		if (num_all_conflicts[i] != 0) System.out.print(" all_"+(i + 1)+": "+num_all_conflicts[i]);
		}
		}

		if (use_odo) {
		for (int i = 0; i < num_ortho_diag_ortho.length; i++){
		if (num_ortho_diag_ortho[i] != 0) System.out.print(" odo_"+(i + 1)+": "+num_ortho_diag_ortho[i]);
		}
		if (num_ortho_incompat != 0) {
		System.out.print(" number of incompatible odo triangles = " + num_ortho_incompat);
		}
		if (num_ortho_dual != 0) {
		System.out.print(" number of dual odo triangles = " + num_ortho_dual);
		}
		}
		if (use_ood) {
		for (int i = 0; i < num_ortho_ortho_diag.length; i++){
		if (num_ortho_ortho_diag[i] != 0) System.out.print(" ood_"+(i + 1)+": "+num_ortho_ortho_diag[i]);
		}
		}
		System.out.println();
		}
		// TilePlanes.PlaneData [][] planes = null;

		/**
		* Find "triangular" conflicts after running selectNeighborPlanesMutual.
		* Such conflicts happen is when starting N (or other ortho direction) from some node,
		* then turning 135 degrees right, and then 135 right again it will get to the different
		* layer than started (and all 3 connections exist.
		* @param debugLevel
		* @return 3-d array, first index - tile number, 2-nd - tile conflict number. Each conflict
		* is stored as {start layer, end layer, bitmask of start directions} (+1 - N, +2 - E, +4 - S, +8 - W)
		*/


		public int [][][] detectTriangularConflicts(
		final int debugLevel)
		{
		final int tilesX = st.getTileProcessor().getTilesX();
		final int tilesY = st.getTileProcessor().getTilesY();
		final int superTileSize = st.getTileProcessor().getSuperTileSize();
		final int stilesX = (tilesX + superTileSize -1)/superTileSize;
		final int stilesY = (tilesY + superTileSize -1)/superTileSize;
		final int nStiles = stilesX * stilesY;
		final int [][][] conflicts = new int [st.getPlanes().length][][];
		final TileSurface.TileNeibs tnSurface = st.getTileSurface().new TileNeibs(stilesX, stilesY);
		final Thread[] threads = ImageDtt.newThreadArray(st.getTileProcessor().threadsMax);
		final AtomicInteger ai = new AtomicInteger(0);
		for (int ithread = 0; ithread < threads.length; ithread++) {
		threads[ithread] = new Thread() {
		public void run() {
		for (int nsTile0 = ai.getAndIncrement(); nsTile0 < nStiles; nsTile0 = ai.getAndIncrement()) {
		if ( st.getPlanes()[nsTile0] != null) {
		conflicts[nsTile0] = detectTriangularTileConflicts(
		nsTile0,
		null, // HashMap<Integer,Integer> replacement_tiles, //
		null, // int [][][] replacement_neibs,
		tnSurface);
		}
		}
		}
		};
		}
		ImageDtt.startAndJoin(threads);
		if (debugLevel > -1){
		addConflicts(
		conflicts,
		debugLevel);
		printConflictSummary("Detected conflicts:",true,false,false);
		printConflictSummary("Detected ortho-diagonal-ortho conflicts:",false, true, false);
		printConflictSummary("Detected ortho-ortho-diagonal conflicts:",false, false, true);
		}
		return conflicts;
		}


		public int [][] detectTriangularTileConflicts(
		int nsTile0,
		HashMap<Integer,Integer> replacement_tiles, //
		int [][][] replacement_neibs,
		TileSurface.TileNeibs tnSurface)
		{
		TilePlanes.PlaneData [][] planes = st.getPlanes();
		ArrayList<Conflict> conflicts_list= new ArrayList<Conflict>();
		if ( planes[nsTile0] != null) {
		Integer repl_indx = (replacement_tiles != null) ? replacement_tiles.get(new Integer(nsTile0)): null;
		for (int np0 = 0; np0 < planes[nsTile0].length; np0++){
		if (planes[nsTile0][np0] != null) {
		int [] neibs0 = ((repl_indx == null) \|\| (replacement_neibs[repl_indx][np0] == null)) ?
		planes[nsTile0][np0].getNeibBest() :
		replacement_neibs[repl_indx][np0];
		for (int dir = 0; dir < 8; dir +=2){
		int np1;
		np1= neibs0[dir]; // planes[nsTile0][np0].getNeibBest(dir);
		if (np1 >=0) {
		int nsTile1 = tnSurface.getNeibIndex(nsTile0, dir);
		if (nsTile1 >= 0){
		Integer repl_indx1 = (replacement_tiles != null) ? replacement_tiles.get(new Integer(nsTile1)): null;
		int [] neibs1 = (((repl_indx1 == null) \|\| (replacement_neibs[repl_indx1][np1] == null) )?
		planes[nsTile1][np1].getNeibBest() :
		replacement_neibs[repl_indx1][np1]);
		int dir1 = (dir + 3) % 8;
		int np2 = neibs1[dir1]; // planes[nsTile1][np1].getNeibBest(dir1);
		if (np2 >= 0){
		int nsTile2 = tnSurface.getNeibIndex(nsTile1, dir1);
		if (nsTile2 >= 0){
		Integer repl_indx2 = (replacement_tiles != null) ? replacement_tiles.get(new Integer(nsTile2)): null;
		int [] neibs2 = (((repl_indx2 == null) \|\| (replacement_neibs[repl_indx2][np2] == null)) ?
		planes[nsTile2][np2].getNeibBest() :
		replacement_neibs[repl_indx2][np2]);
		int dir2 = (dir1 + 3) % 8;
		int np3 = neibs2[dir2]; // planes[nsTile2][np2].getNeibBest(dir2);
		if ((np3 >= 0) && (np3 != np0)){
		Conflict conflict = new Conflict(np0, np3, dir/2);
		label_apply:
		{
		for (Conflict conf_old:conflicts_list){
		if (conf_old.combine(conflict)){
		break label_apply;
		}
		}
		conflicts_list.add(conflict);
		}
		}
		}
		}
		// ortho-ortho-diagonal, right hand from np0
		dir1 = (dir + 2) % 8;
		np2 = neibs1[dir1]; // planes[nsTile1][np1].getNeibBest(dir1);
		if (np2 >= 0){
		int nsTile2 = tnSurface.getNeibIndex(nsTile1, dir1);
		if (nsTile2 >= 0){
		Integer repl_indx2 = (replacement_tiles != null) ? replacement_tiles.get(new Integer(nsTile2)): null;
		int [] neibs2 = (((repl_indx2 == null) \|\| (replacement_neibs[repl_indx2][np2] == null)) ?
		planes[nsTile2][np2].getNeibBest() :
		replacement_neibs[repl_indx2][np2]);
		int dir2 = (dir1 + 3) % 8;
		int np3 = neibs2[dir2]; // planes[nsTile2][np2].getNeibBest(dir2);
		if ((np3 >= 0) && (np3 != np0)){
		Conflict conflict = new Conflict(np0, np3, dir/2, true); // ood, right
		label_apply:
		{
		for (Conflict conf_old:conflicts_list){
		if (conf_old.combine(conflict)){
		break label_apply;
		}
		}
		conflicts_list.add(conflict);
		}
		}
		}
		}
		// ortho-ortho-diagonal, left hand from np0
		dir1 = (dir + 6) % 8;
		np2 = neibs1[dir1]; // planes[nsTile1][np1].getNeibBest(dir1);
		if (np2 >= 0){
		int nsTile2 = tnSurface.getNeibIndex(nsTile1, dir1);
		if (nsTile2 >= 0){
		Integer repl_indx2 = (replacement_tiles != null) ? replacement_tiles.get(new Integer(nsTile2)): null;
		int [] neibs2 = (((repl_indx2 == null) \|\| (replacement_neibs[repl_indx2][np2] == null)) ?
		planes[nsTile2][np2].getNeibBest() :
		replacement_neibs[repl_indx2][np2]);
		int dir2 = (dir1 + 5) % 8;
		int np3 = neibs2[dir2]; // planes[nsTile2][np2].getNeibBest(dir2);
		if ((np3 >= 0) && (np3 != np0)){
		Conflict conflict = new Conflict(np0, np3, dir/2, true); // ood, right
		label_apply:
		{
		for (Conflict conf_old:conflicts_list){
		if (conf_old.combine(conflict)){
		break label_apply;
		}
		}
		conflicts_list.add(conflict);
		}
		}
		}
		}
		}
		}
		}
		}
		}
		}
		if(conflicts_list.isEmpty()){
		return null;
		}
		int [][] conflicts = new int [conflicts_list.size()][];
		int indx=0;
		for (Conflict conflict:conflicts_list){
		conflicts[indx++] = conflict.toArray();
		}
		return conflicts;
		}

		}

Admin message