Fix the code. 
	public void actionPerformed(ActionEvent e) {
	 if (e.getSource() == cannyButton) {
			cannyImage();
	}
		
	}
	
	

private void cannyImage() {
if (image != null) {
String inputMask = JOptionPane.showInputDialog(this,"Enter a mask size (odd number >= 3)");
int kernelSize = Integer.parseInt(inputMask);
if (kernelSize % 2 == 0 || kernelSize < 3) {
JOptionPane.showMessageDialog(this,"INlid mask size. Please enter an odd number >= 3.");
return;
}

float[][] mask = new float[kernelSize][kernelSize];
for (int i = 0; i < mask.length; i++) {
for (int j = 0; j < mask[i].length; j++) {
mask[i][j] = 1.0f / (mask.length * mask[i].length);
}
}

// Use a custom input dialog with a slider for the threshold values
JPanel panel = new JPanel(new GridLayout(0, 1));
JSlider lowThresholdSlider = new JSlider(JSlider.HORIZONTAL, 0, 255, 50);
JSlider highThresholdSlider = new JSlider(JSlider.HORIZONTAL, 0, 255, 100);

panel.add(new JLabel("Low Threshold:"));
panel.add(lowThresholdSlider);
panel.add(new JLabel("High Threshold:"));
panel.add(highThresholdSlider);

int result = JOptionPane.showOptionDialog(this, panel,
"Enter Threshold Values",JOptionPane.OK_CANCEL_OPTION,
JOptionPane.PLAIN_MESSAGE, null, null, null);

if (result == JOptionPane.OK_OPTION) {
int lowThreshold = lowThresholdSlider.getValue();
int highThreshold = highThresholdSlider.getValue();
applyCannyEdgeDetector(image, mask, lowThreshold, highThreshold,
kernelSize);
}
}
}

private BufferedImage applyCannyEdgeDetector(BufferedImage image,
float[][] mask, int lowThreshold, int highThreshold, int kernelSize) {

int width = image.getWidth();
int height = image.getHeight();
BufferedImage resultImage = new BufferedImage(width, height,
BufferedImage.TYPE_INT_RGB);

int[] pixels = new int[width * height];
int[] edges = new int[width * height];

image.getRGB(0, 0, width, height, pixels, 0, width);

int[][] sobelX = {{-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1}};
int[][] sobelY = {{-1, -2, -1}, {0, 0, 0}, {1, 2, 1}};

int[] grayPixels = convertToGrayscale(pixels);

int[] gradientX = getConvolution(grayPixels, sobelX, width, height, kernelSize);
int[] gradientY = getConvolution(grayPixels, sobelY, width, height, kernelSize);

for (int i = 0; i < pixels.length; i++) {
int gx = gradientX[i];
int gy = gradientY[i];
edges[i] = (int) Math.sqrt(gx * gx + gy * gy);
}

int[] thresholdEdges = applyHysteresis(edges, lowThreshold, highThreshold, width, height);

for (int i = 0; i < pixels.length; i++) {
if (thresholdEdges[i] != 0) {
resultImage.setRGB(i % width, i / width, Color.BLACK.getRGB());
} else {
resultImage.setRGB(i % width, i / width, 0xFFFFFF);
}
}

return resultImage;
}

private int[] applyHysteresis(int[] edges, int low, int high, int width, int height) {
int[] result = new int[edges.length];
Arrays.fill(result, 0);
for (int i = 0; i < edges.length; i++) {
if (edges[i] >= high && result[i] == 0) {
trace(result, edges, low, high, i, width, height);
}
}
return result;
}

private void trace(int[] result, int[] edges, int low, int high, int i, int width, int height) {
result[i] = 255;
LinkedList<Integer> queue = new LinkedList<>();
queue.offer(i);

while (!queue.isEmpty()) {
int currIndex = queue.poll();
int currX = currIndex % width;
int currY = currIndex / width;

for (int j = -1; j <= 1; j++) {
for (int k = -1; k <= 1; k++) {
int neighborX = currX + k;
int neighborY = currY + j;
int neighborIndex = neighborY * width + neighborX;

if (neighborX >= 0 && neighborX < width &&
neighborY >= 0 && neighborY < height &&
neighborIndex >= 0 && neighborIndex < edges.length &&
result[neighborIndex] == 0 && edges[neighborIndex] >= low &&
edges[neighborIndex] <= high) {
result[neighborIndex] = 255;
queue.offer(neighborIndex);
}
}
}
}
}

private int[] getConvolution(int[] pixels, int[][] filter, int width, int height, int kernelSize) {

int[] result = new int[pixels.length];
int radius = kernelSize / 2;

for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
double sum = 0.0;

for (int ky = -radius; ky <= radius && ky < kernelSize; ky++) {
for (int kx = -radius; kx <= radius && kx < kernelSize; kx++) {
int px = x + kx;
int py = y + ky;

if (px >= 0 && px < width && py >= 0 && py < height) {
int i = py * width + px;
double value = (double) pixels[i];
sum += value * filter[ky + radius][kx + radius];
}
}
}

int i = y * width + x;
result[i] = (int) sum;
}
}

return result;
}

private int[] convertToGrayscale(int[] pixels) {
int[] grayPixels = new int[pixels.length];

for (int i = 0; i < pixels.length; i++) {
int r = (pixels[i] >> 16) & 0xFF;
int g = (pixels[i] >> 8) & 0xFF;
int b = pixels[i] & 0xFF;
int gray = (int) (0.2126 * r + 0.7152 * g + 0.0722 * b);
grayPixels[i] = (gray << 16) + (gray << 8) + gray;
}

return grayPixels;
}