src/stats/ConnectedComponentsByCellBorder.js

  1.  
  2. import Stat from "./Stat.js"
  3. import BorderPixelsByCell from "./BorderPixelsByCell.js"
  4.  
  5. /** This Stat creates an object with the connected components of each cell's border on the grid. 
  6. 	Keys are the {@link CellId} of all cells on the grid, corresponding values are objects
  7. 	where each element is a connected component. Each element of that array contains 
  8. 	the {@link ArrayCoordinate} for that pixel.
  9. 	
  10. 	@example
  11. 	* let CPM = require( "path/to/build" )
  12. 	*
  13. 	* // Make a CPM, seed a cell, and get the ConnectedComponentsByCellBorder
  14. 	* let C = new CPM.CPM( [100,100], { 
  15. 	* 	T:20,
  16. 	* 	J:[[0,20],[20,10]],
  17. 	* 	V:[0,200],
  18. 	* 	LAMBDA_V:[0,2]
  19. 	* } )
  20. 	* let gm = new CPM.GridManipulator( C )
  21. 	* gm.seedCell(1)
  22. 	* gm.seedCell(1)
  23. 	* for( let t = 0; t < 100; t++ ){ C.timeStep() }
  24. 	* C.getStat( CPM.ConnectedComponentsByCellBorder )
  25. */
  26. class ConnectedComponentsByCellBorder extends Stat {
  27.  
  28. 	/** This method computes the connected components of the border of a specific cell. 
  29. 		@param {CellId} cellid the unique cell id of the cell to get the border's connected components of.
  30. 		@returns {object} object of cell border connected components. These components in turn consist of the pixels 
  31. 	(specified by {@link ArrayCoordinate}) belonging to that cell border.
  32. 	*/
  33. 	connectedComponentsOfCellBorder( cellid ){
  34. 	
  35. 		/* Note that to get connected components, we only need to look at cellborderpixels. */
  36. 		let cbp = this.M.getStat( BorderPixelsByCell )
  37. 		cbpi = cbp[cellid]
  38. 	
  39. 	
  40. 		let visited = {}, k=0, pixels = []
  41. 		let labelComponent = function(seed, k){
  42. 			let q = [seed]
  43. 			visited[q[0]] = 1
  44. 			pixels[k] = []
  45. 			while( q.length > 0 ){
  46. 				let e = q.pop()
  47. 				pixels[k].push( this.M.grid.i2p(e) )
  48. 				let ne = this.M.grid.neighi( e )
  49. 				for( let i = 0 ; i < ne.length ; i ++ ){
  50. 					if( this.M.pixti( ne[i] ) == t &&
  51. 						!(ne[i] in visited) ){
  52. 						q.push(ne[i])
  53. 						visited[ne[i]]=1
  54. 					}
  55. 				}
  56. 			}
  57. 		}
  58. 		for( let i = 0 ; i < cbpi.length ; i ++ ){
  59. 			let pi = this.M.grid.p2i( cbpi[i] )
  60. 			if( !(pi in visited) ){
  61. 				labelComponent( pi, k )
  62. 				k++
  63. 			}
  64. 		}
  65. 		return pixels
  66. 	}
  67.  
  68. 	/** The compute method of ConnectedComponentsByCellBorder creates an object with 
  69. 	connected components of the border of each cell on the grid.
  70. 	@return {CellObject} object with for each cell on the grid
  71. 	an object of components. These components in turn consist of the pixels 
  72. 	(specified by {@link ArrayCoordinate}) belonging to that cell.
  73. 	*/
  74. 	compute(){
  75. 		// initialize the object
  76. 		let components = { }
  77. 		// The this.M.pixels() iterator returns coordinates and cellid for all 
  78. 		// non-background pixels on the grid. See the appropriate Grid class for
  79. 		// its implementation.
  80. 		for( let ci of this.M.cellIDs() ){
  81. 			components[ci] = this.connectedComponentsOfCellBorder( ci )
  82. 		}
  83. 		return components
  84. 	}
  85. }
  86.  
  87. export default ConnectedComponentsByCellBorder