_computeLocalization(prunedExtremasList, dogPyramidImagesT) {
		/*  if (!this.kernelCaches.computeLocalization) {
		   const dogVariableNames = [];
	 
		   let dogSubCodes = `float getPixel(int octave, int y, int x) {`;
		   for (let i = 1; i < dogPyramidImagesT.length; i++) {  // extrema starts from second octave
		 dogVariableNames.push('image' + i);
		 dogSubCodes += `
		   if (octave == ${i}) {
			 return getImage${i}(y, x);
		   }
		   `;
		   }
		   dogSubCodes += `}`;
	 
		   const kernel = {
		 variableNames: [...dogVariableNames, 'extrema'],
		 outputShape: [prunedExtremasList.length, 3, 3], // 3x3 pixels around the extrema
		 userCode: `
		   ${dogSubCodes}
	 
		   void main() {
			 ivec3 coords = getOutputCoords();
			 int featureIndex = coords[0];
			 float score = getExtrema(featureIndex, 0);
			 if (score == 0.0) {
			   return;
			 }
	 
			 int dy = coords[1]-1;
			 int dx = coords[2]-1;
			 int octave = int(getExtrema(featureIndex, 1));
			 int y = int(getExtrema(featureIndex, 2));
			 int x = int(getExtrema(featureIndex, 3));
			 setOutput(getPixel(octave, y+dy, x+dx));
		   }
		 `
		   }
	 
		   this.kernelCaches.computeLocalization = [kernel];
		 } */

		return tf.tidy(() => {
			//const program = this.kernelCaches.computeLocalization[0];
			//const prunedExtremasT = tf.tensor(prunedExtremasList, [prunedExtremasList.length, prunedExtremasList[0].length], 'int32');

			const pixelsT = tf.engine().runKernel('ComputeLocalization', { prunedExtremasList, dogPyramidImagesT });//this._compileAndRun(program, [...dogPyramidImagesT.slice(1), prunedExtremasT]);
			const pixels = pixelsT.arraySync();

			const result = [];
			for (let i = 0; i < pixels.length; i++) {
				result.push([]);
				for (let j = 0; j < pixels[i].length; j++) {
					result[i].push([]);
				}
			}

			const localizedExtremas = [];
			for (let i = 0; i < prunedExtremasList.length; i++) {
				localizedExtremas[i] = [
					prunedExtremasList[i][0],
					prunedExtremasList[i][1],
					prunedExtremasList[i][2],
					prunedExtremasList[i][3],
				];
			}

			for (let i = 0; i < localizedExtremas.length; i++) {
				if (localizedExtremas[i][0] === 0) {
					continue;
				}
				const pixel = pixels[i];
				const dx = 0.5 * (pixel[1][2] - pixel[1][0]);
				const dy = 0.5 * (pixel[2][1] - pixel[0][1]);
				const dxx = pixel[1][2] + pixel[1][0] - 2 * pixel[1][1];
				const dyy = pixel[2][1] + pixel[0][1] - 2 * pixel[1][1];
				const dxy = 0.25 * (pixel[0][0] + pixel[2][2] - pixel[0][2] - pixel[2][0]);

				const det = dxx * dyy - dxy * dxy;
				const ux = (dyy * -dx + -dxy * -dy) / det;
				const uy = (-dxy * -dx + dxx * -dy) / det;

				const newY = localizedExtremas[i][2] + uy;
				const newX = localizedExtremas[i][3] + ux;

				if (Math.abs(det) < 0.0001) {
					continue;
				}

				localizedExtremas[i][2] = newY;
				localizedExtremas[i][3] = newX;
			}
			return tf.tensor(localizedExtremas, [localizedExtremas.length, localizedExtremas[0].length], 'float32');
		});
	}
@param {number[][]} prunedExtremasList 
@param {tf.Tensor<tf.Rank>[]} dogPyramidImagesT 
@returns