docs: public KltTrackFault track(KltFeature feature) {
  
  		// precompute bounds and other values
  		setAllowedBounds(feature);
  
  		// sanity check to make sure it is actually inside the image
  		if ( isFullyOutside(feature.x, feature.y))
  			return KltTrackFault.OUT_OF_BOUNDS;
  
  		if (currDesc.data.length < lengthFeature) {
  			currDesc.reshape(widthFeature,widthFeature);
  		}
  
  		// save the original location so that a drifting fault can be detected
  		float origX = feature.x, origY = feature.y;
  
  		// If the feature is complete then the fast code can be used when entirely inside
  		boolean complete = isDescriptionComplete(feature);
  
  		float det = 0;
  
  		// make sure its inside this image
  		if ( complete ) {
  			// see if the determinant is too small
  			Gxx = feature.Gxx;
  			Gyy = feature.Gyy;
  			Gxy = feature.Gxy;
  			det = Gxx * Gyy - Gxy * Gxy;
  			if (det < config.minDeterminant*lengthFeature) {
  				return KltTrackFault.FAILED;
  			}
  		}
  
  		for (int iter = 0; iter < config.maxIterations; iter++) {
  			float dx,dy;
  			if( complete && isFullyInside(feature.x, feature.y) ) {
  				computeE(feature, feature.x, feature.y);
  			} else {
  				// once it goes outside it must remain outside.  If it starts outside
  				int length = computeGandE_border(feature, feature.x, feature.y);
  
  				det = Gxx * Gyy - Gxy * Gxy;
  				if (det <= config.minDeterminant*length) {
  					return KltTrackFault.FAILED;
  				}
  			}
  
  			// solve for D
  			dx = (Gyy * Ex - Gxy * Ey) / det;
  			dy = (Gxx * Ey - Gxy * Ex) / det;
  
  			feature.x += dx;
  			feature.y += dy;
  
  			// see if it moved outside of the image
  			if ( isFullyOutside(feature.x, feature.y))
  				return KltTrackFault.OUT_OF_BOUNDS;
  
  			// see if it has moved more than possible if it is really tracking a target
  			// this happens in regions with little texture
  			if (Math.abs(feature.x - origX) > widthFeature
  					|| Math.abs(feature.y - origY) > widthFeature)
  				return KltTrackFault.DRIFTED;
  
  			// see if it has converged to a solution
  			if (Math.abs(dx) < config.minPositionDelta && Math.abs(dy) < config.minPositionDelta) {
  				break;
  			}
  		}
  
  		if ( (error=computeError(feature)) > config.maxPerPixelError)
  			return KltTrackFault.LARGE_ERROR;
  
  		return KltTrackFault.SUCCESS;
  	}