src/stats/Centroids.js

  1.  
  2.  
  3. import Stat from "./Stat.js"
  4. import PixelsByCell from "./PixelsByCell.js"
  5.  
  6. /**	This Stat computes the centroid of a cell. When the cell resides on a torus, the
  7. 	centroid may be well outside the cell, and other stats may be preferable (e.g.
  8. 	{@link CentroidsWithTorusCorrection}).
  9. 	
  10. 	@example
  11. 	* let CPM = require( "path/to/build" )
  12. 	*
  13. 	* // Make a CPM, seed two cells, run a little, and get their centroids
  14. 	* let C = new CPM.CPM( [100,100], { 
  15. 	* 	T:20,
  16. 	*	torus:[false,false],
  17. 	* 	J:[[0,20],[20,10]],
  18. 	* 	V:[0,200],
  19. 	* 	LAMBDA_V:[0,2]
  20. 	* } )
  21. 	* let gm = new CPM.GridManipulator( C )
  22. 	* gm.seedCell(1)
  23. 	* gm.seedCell(1)
  24. 	* for( let t = 0; t < 100; t++ ){ C.timeStep() }
  25. 	*
  26. 	* C.getStat( CPM.Centroids ) 
  27. */
  28. class Centroids extends Stat {
  29.  
  30. 	/** The set model method of class CentroidsWithTorusCorrection.
  31. 	@param {GridBasedModel} M - the model to compute centroids on. */
  32. 	set model( M ){
  33. 	
  34. 		/** The model to compute centroids on. 
  35. 		@type {GridBasedModel}*/
  36. 		this.M = M
  37. 		
  38. 		/* Check if the grid has a torus; if so, warn that this method may not be
  39. 		appropriate. */
  40. 		let torus = false
  41. 		for( let d = 0; d < this.M.ndim; d++ ){
  42. 			if( this.M.grid.torus[d] ){
  43. 				torus = true
  44. 				break
  45. 			}
  46. 		}
  47. 		
  48. 		if(torus){
  49. 			// eslint-disable-next-line no-console
  50. 			console.warn( "Your model grid has a torus, and the 'Centroids' stat is not compatible with torus! Consider using 'CentroidsWithTorusCorrection' instead." )
  51. 		}
  52. 		
  53. 		// Half the grid dimensions; if pixels with the same cellid are further apart,
  54. 		// we assume they are on the border of the grid and that we need to correct
  55. 		// their positions to compute the centroid.
  56. 		/** @ignore */
  57. 		this.halfsize = new Array( this.M.ndim).fill(0)
  58. 		for( let i = 0 ; i < this.M.ndim ; i ++ ){
  59. 			this.halfsize[i] = this.M.extents[i]/2
  60. 		}
  61. 	}
  62. 	/** @ignore */
  63. 	constructor( conf ){
  64. 		super(conf)
  65. 	}
  66. 	/** This method computes the centroid of a specific cell. 
  67. 		@param {CellId} cellid the unique cell id of the cell to get centroid of.
  68. 		@param {CellArrayObject} cellpixels object produced by {@link PixelsByCell}, 
  69. 		with keys for each cellid
  70. 		and as corresponding value the pixel coordinates of their pixels.
  71. 		@returns {ArrayCoordinate} coordinate of the centroid.
  72. 	*/
  73. 	computeCentroidOfCell( cellid, cellpixels  ){
  74. 	
  75. 		//let cellpixels = this.M.getStat( PixelsByCell ) 
  76. 	
  77. 		const pixels = cellpixels[ cellid ]
  78. 		
  79. 		// cvec will contain the x, y, (z) coordinate of the centroid.
  80. 		// Loop over the dimensions to compute each element separately.
  81. 		let cvec = new Array(this.M.ndim).fill(0)
  82. 		for( let dim = 0 ; dim < this.M.ndim ; dim ++ ){
  83. 			
  84. 			let mi = 0.
  85. 			// Loop over the pixels;
  86. 			// compute mean position per dimension with online algorithm
  87. 			for( let j = 0 ; j < pixels.length ; j ++ ){
  88. 				// Check distance of current pixel to the accumulated mean in this dim.
  89. 				// Check if this distance is greater than half the grid size in this
  90. 				// dimension; if so, this indicates that the cell has moved to the
  91. 				// other end of the grid because of the torus. Note that this only
  92. 				// holds AFTER the first pixel (so for j > 0), when we actually have
  93. 				// an idea of where the cell is.
  94. 				let dx = pixels[j][dim] - mi
  95. 				// Update the mean with the appropriate weight. 
  96. 				mi += dx/(j+1)
  97. 			}			
  98. 			// Set the mean position in the cvec vector.
  99. 			cvec[dim] = mi
  100. 		}
  101. 		return cvec
  102. 		
  103. 	}
  104. 		
  105. 	/** Compute centroids for all cells on the grid. 
  106. 	@return {CellObject} with an {@link ArrayCoordinate} of the centroid for each cell
  107. 	 on the grid (see {@link computeCentroidOfCell}). */
  108. 	compute(){
  109. 		// Get object with arrays of pixels for each cell on the grid, and get
  110. 		// the array for the current cell.
  111. 		let cellpixels = this.M.getStat( PixelsByCell ) 
  112. 		
  113. 		// Create an object for the centroids. Add the centroid array for each cell.
  114. 		let centroids = {}
  115. 		for( let cid of this.M.cellIDs() ){
  116. 			centroids[cid] = this.computeCentroidOfCell( cid, cellpixels )
  117. 		}
  118. 		return centroids
  119. 	}
  120. }
  121.  
  122. export default Centroids