/*******************************************************************************
 * This software is provided as a supplement to the authors' textbooks on digital
 * image processing published by Springer-Verlag in various languages and editions.
 * Permission to use and distribute this software is granted under the BSD 2-Clause
 * "Simplified" License (see http://opensource.org/licenses/BSD-2-Clause).
 * Copyright (c) 2006-2023 Wilhelm Burger, Mark J. Burge. All rights reserved.
 * Visit https://imagingbook.com for additional details.
 ******************************************************************************/
package imagingbook.common.image.matching.lucaskanade;

import ij.process.ImageProcessor;
import imagingbook.common.geometry.basic.Pnt2d;
import imagingbook.common.geometry.basic.Pnt2d.PntInt;
import imagingbook.common.geometry.mappings.linear.AffineMapping2D;
import imagingbook.common.geometry.mappings.linear.LinearMapping2D;
import imagingbook.common.geometry.mappings.linear.ProjectiveMapping2D;
import imagingbook.common.image.access.ImageAccessor;

/**
 * Used to extract warped images for testing class {@link LucasKanadeMatcher}.
 * 
 * @author WB
 * @version 2022/09/16
 */
public class ImageExtractor {
        // TODO: replace by ImageMapper
        
        private int interpolationMethod = ImageProcessor.BILINEAR;
        private final ImageProcessor I;
        
        /**
         * Creates a new instance of {@link ImageExtractor} for the image {@code I}.
         * @param I the target image.
         */
        public ImageExtractor(ImageProcessor I) {
                this.I = I;
        }

        /**
         * Sets the interpolation method to be used for extracting sub-images (defined by ImageJ's {@link ImageProcessor}):
         * {@code ImageProcessor.BILINEAR} (default), {@code NEAREST_NEIGHBOR}, {@code BICUBIC} or {@code NONE}.
         *
         * @param method the interpolation method to use
         */
        public void setInterpolationMethod(int method) {
                this.interpolationMethod = method;
        }

        /**
         * Extracts a sub-image of size {@code width} x {@code height} from the source image {@code I} (referenced by
         * {@code this} {@link ImageExtractor}), using the specified transformation. The image {@code R} is extracted from a
         * quadrilateral patch of the source image, defined by the transformation of the boundary of {@code R} by
         * {@code T(x)}.
         *
         * @param width the width of the extracted image
         * @param height the height of the extracted image
         * @param T a {@link LinearMapping2D} instance
         * @return the extracted image, which is of the same type as the source image.
         */
        public ImageProcessor extractImage(int width, int height, LinearMapping2D T) {
                ImageProcessor R = I.createProcessor(width, height);
                extractImage(R, T);
                return R;
        }
        
//      public ImageProcessor extractImage(int width, int height, Pnt2d[] sourcePnts) {
//              ImageProcessor R = I.createProcessor(width, height);
//              ProjectiveMapping2D T = getMapping(width, height, sourcePnts);
//              extractImage(R, T);
//              return R;
//      }

        /**
         * Fills the image {@code R} from the source image {@code I} (referenced by {@code this} object). The image
         * {@code R} is extracted from a quadrilateral patch of the source image, defined by the transformation of the
         * boundary of {@code R} by {@code T(x)}. Grayscale and color images my not be mixed (i.e., {@code R} must be of the
         * same type as {@code I}).
         *
         * @param R the image to be filled.
         * @param T a {@link LinearMapping2D} object.
         */
        public void extractImage(ImageProcessor R, LinearMapping2D T) {
                int prevInterpolationMethod = I.getInterpolationMethod();
                // save current interpolation method
                I.setInterpolationMethod(interpolationMethod);
                
                ImageAccessor iaI = ImageAccessor.create(I);
                ImageAccessor iaR = ImageAccessor.create(R);
        
                int wT = R.getWidth();
                int hT = R.getHeight();
                for (int u = 0; u < wT; u++) {
                        for (int v = 0; v < hT; v++) {
                                Pnt2d uv = PntInt.from(u, v);
                                Pnt2d xy = T.applyTo(uv);
                                float[] val = iaI.getPix(xy.getX(), xy.getY());
                                iaR.setPix(u, v, val);
                        }
                }
                // restore interpolation method
                I.setInterpolationMethod(prevInterpolationMethod);
        }

        /**
         * Extracts a warped sub-image of the associated target image I, defined by a sequence of 3 or 4 points. In the case
         * of 3 points in sourcePnts, an {@link AffineMapping2D} is used; with 4 points, a {@link ProjectiveMapping2D} is
         * used. The 3 or 4 points map clockwise to the corner points of the target image R, starting with the top-left
         * corner.
         *
         * @param R the target image
         * @param sourcePnts an array of 3 or 4 {@link Pnt2d} objects
         */
        public void extractImage(ImageProcessor R, Pnt2d[] sourcePnts) {
                ProjectiveMapping2D T = getMapping(R.getWidth(), R.getHeight(), sourcePnts);
                extractImage(R, T);
        }
        
        private ProjectiveMapping2D getMapping(int w, int h, Pnt2d[] sourcePnts) {
                Pnt2d[] targetPnts = {
                                PntInt.from(0, 0), PntInt.from(w - 1, 0),
                                PntInt.from(w - 1, h - 1), PntInt.from(0, h - 1)
                        };
                ProjectiveMapping2D T = null;
                switch (sourcePnts.length) {
                case (3) : T = AffineMapping2D.fromPoints(targetPnts, sourcePnts); break;
                case (4) : T = ProjectiveMapping2D.fromPoints(targetPnts, sourcePnts); break;
                default : throw new IllegalArgumentException("wrong number of source points (3 or 4 required)");
                }
                return T;
        }
        
}