Распознование образов. Матчасть. Алгоритм Слежения за объектом

public void recursice(int x, int y) {
        
        if(y < 1 || y >= height - 1 || x < 1 || x >= width - 1) return;
                
        if(pixelsData[width * y + x] == AbstractTool._1) pixelsData[width * y + x] = Color.GREEN.getRGB();
        
        if (pixelsData[width * (y - 1) + (x - 1)] == AbstractTool._1) recursice(x - 1, y - 1);
        if (pixelsData[width * (y - 1) + x        ] == AbstractTool._1) recursice(x, y - 1);
        if (pixelsData[width * (y - 1) + (x + 1)] == AbstractTool._1) recursice(x + 1, y - 1);
 
        if (pixelsData[width * y + (x - 1)        ] == AbstractTool._1) recursice(x - 1, y);
        if (pixelsData[width * y + (x + 1)        ] == AbstractTool._1) recursice(x + 1, y);
 
        if (pixelsData[width * (y + 1) + (x - 1)] == AbstractTool._1) recursice(x - 1, y + 1);
        if (pixelsData[width * (y + 1) + x        ] == AbstractTool._1) recursice(x, y + 1);
        if (pixelsData[width * (y + 1) + (x + 1)] == AbstractTool._1) recursice(x + 1, y + 1);
    }

private float gaussian(float x, float sigma) {
 
        return (float) Math.exp(-(x * x) / (2f * sigma * sigma));
    }
     
    // gradient computation 
    private void computeGradients(float kernelRadius, int kernelWidth) {
            // generate the gaussian convolution masks
            float kernel[] = new float[kernelWidth];
            float diffKernel[] = new float[kernelWidth];
            int kwidth;
            for (kwidth = 0; kwidth < kernelWidth; kwidth++) {
                float g1 = gaussian(kwidth, kernelRadius);
                if (g1 <= GAUSSIAN_CUT_OFF && kwidth >= 2) break;
                float g2 = gaussian(kwidth - 0.5f, kernelRadius);
                float g3 = gaussian(kwidth + 0.5f, kernelRadius);
                kernel[kwidth] = (g1 + g2 + g3) / 3f / (2f * (float) Math.PI * kernelRadius * kernelRadius);
                diffKernel[kwidth] = g3 - g2;
            }
 
            int initX = kwidth - 1;
            int maxX = width - (kwidth - 1);
            int initY = width * (kwidth - 1);
            int maxY = width * (height - (kwidth - 1));
 
            // perform convolution in x and y directions
            for (int x = initX; x < maxX; x++) {
                for (int y = initY; y < maxY; y += width) {
                    int index = x + y;
                    float sumX = data[index] * kernel[0];
                    float sumY = sumX;
                    int xOffset = 1;
                    int yOffset = width;
                    for (; xOffset < kwidth;) {
                        sumY += kernel[xOffset] * (data[index - yOffset] + data[index + yOffset]);
                        sumX += kernel[xOffset] * (data[index - xOffset] + data[index + xOffset]);
                        yOffset += width;
                        xOffset++;
                    }
 
                    yConv[index] = sumY;
                    xConv[index] = sumX;
                }
            }
 
            for (int x = initX; x < maxX; x++) {
                for (int y = initY; y < maxY; y += width) {
                    float sum = 0f;
                    int index = x + y;
                    for (int i = 1; i < kwidth; ++i)
                        sum += diffKernel[i] * (yConv[index - i] - yConv[index + i]);
 
                    xGradient[index] = sum;
                }
            }
 
            for (int x = kwidth; x < width - kwidth; x++) {
                for (int y = initY; y < maxY; y += width) {
                    float sum = 0.0f;
                    int index = x + y;
                    int yOffset = width;
                    for (int i = 1; i < kwidth; ++i) {
                        sum += diffKernel[i] * (xConv[index - yOffset] - xConv[index + yOffset]);
                        yOffset += width;
                    }
 
                    yGradient[index] = sum;
                }
 
            }
    }