DeconvolutionScript: Wiener

import ij.ImagePlus;
import ij.plugin.filter.Convolver;
import ij.process.FloatProcessor;
import ij.process.ImageProcessor;
import ij.IJ;

// Get the list of open images in ImageJ
String[] imageList = IJ.getOverlayList();
int numImages = imageList.length;

// Check if there are open images
if (numImages == 0) {
    IJ.log("No images are open in ImageJ.");
} else {
    IJ.log("Starting deconvolution using Wiener space regularization algorithm for " + numImages + " image(s).");

    // Deconvolution parameters
    double regularization = 0.1; // Regularization parameter

    // Process each image in the list
    for (int i = 0; i < numImages; i++) {
        String imageTitle = imageList[i];
        IJ.log("Processing image: " + imageTitle);

        try {
            // Load the original image
            ImagePlus originalImage = IJ.getImage();

            // Create a duplicate of the original image to store the deconvolution result
            ImagePlus deconvolvedImage = originalImage.duplicate();
            String deconvolvedTitle = "Deconvolved_" + imageTitle;
            deconvolvedImage.setTitle(deconvolvedTitle);

            // Get the image processors
            ImageProcessor originalIP = originalImage.getProcessor();
            ImageProcessor deconvolvedIP = deconvolvedImage.getProcessor();

            // Calculate the power spectrum of the original image
            FloatProcessor originalPowerSpectrum = calculatePowerSpectrum(originalIP);

            // Calculate the Wiener filter
            FloatProcessor wienerFilter = calculateWienerFilter(originalPowerSpectrum, regularization);

            // Perform the convolution with the Wiener filter
            Convolver convolver = new Convolver();
            convolver.setNormalize(true);
            convolver.convolve(originalIP, wienerFilter);

            // Update the pixels of the deconvolved image
            deconvolvedIP.setPixels(originalIP.getPixels());

            // Show the deconvolved image
            deconvolvedImage.show();
        } catch (Exception e) {
            IJ.log("Error processing the image: " + imageTitle);
            e.printStackTrace();
        }
    }

    IJ.log("Image processing finished.");
}

// Function to calculate the power spectrum of an image
private FloatProcessor calculatePowerSpectrum(ImageProcessor ip) {
    FloatProcessor fp = ip.convertToFloatProcessor();
    fp.multiply(255.0);
    fp.power(2.0);
    fp.transformFFT();
    fp.swapQuadrants();
    fp.log();
    return fp;
}

// Function to calculate the Wiener filter
private FloatProcessor calculateWienerFilter(FloatProcessor powerSpectrum, double regularization) {
    int width = powerSpectrum.getWidth();
    int height = powerSpectrum.getHeight();
    float[] powerPixels = (float[]) powerSpectrum.getPixels();
    float[] wienerPixels = new float[width * height];

    for (int i = 0; i < powerPixels.length; i++) {
        float power = powerPixels[i];
        float wiener = power / (power + (float) regularization);
        wienerPixels[i] = wiener;
    }

    return new FloatProcessor(width, height, wienerPixels);
}