Class RectRecurse

  • Direct Known Subclasses:
    Border, MaxExposure, ScaledBorder

    public abstract class RectRecurse
    extends ImageFinder
    This class finds the best images to be used for sampling using a recursive rectangle algorithm. It looks for rectangles the boundaries of which can all be sampled from the same input image.
    Settings are used by this class:
    MinEdge
    Only images where we are at least this number of pixels from the edge will be considered. The default is 0.
    MaxRadius
    Only images where the offset of the pixel from the center of the image is less than this radius (calculations in pixels) will be considered. The default is infinity.
    CheckNaNs
    is a flag whose value is ignored. If set, then images are checked to see if the data value corresponding to a pixel position is a NaN when looking for the best image. Images where a NaN is found are ignored. Note that this applies only to the boundaries of the rectangles that are checked. If there are NaNs in isolated regions or pixels these may still be used by this image finder.
    CornersOnly
    is a flag whose value is ignored. If set, then only the corners of rectanges are checked before the rectangle is filled in with values. This was essentially the behavior of the default image finder prior to v2.02 of Skyview.
    • The output image is sampled in a rectangular grid with the samples spaced no more than half the image size of the input images.
    • For each rectangle, the corners of the image are projected into the frame of each currently valid image in turn.
    • If all four pixels project below, above, to the right or to the left of the image bounds, then this image is marked as invalid for future consideration in this rectangle or subrectangles. E.g., suppose that a given corner is simultaneously below and to the left of the image (i.e., the corner projects to pixel coordinates with x and y both less than 0). If the other three corners are also below the image, even if some are to the right of the image or some have X-values that would be within the image, then the image can be eliminated from future consideration. However, if even one of the other pixels is not below the image, then we can not use this criterion to eliminate the image, even if that corner is also outside the image. Similarly if the other three corners all project to the left of the image, then the image can be eliminated.
    • The best pixel is found for each corner. The algorithm for the best pixel is defined by subclasses. If the pixel does not fall within any image it is marked as NO_COVERAGE.
    • A pixel may not correspond to any position on the sky (e.g., a pixel outside the elliptical bounds the Aitoff projection). These pixels are marked as NON-PHYSICAL
    • If the best images are the same for all four corners, then the edges of the rectangle is also checked. If the entire border comes from the same candidate then the rectangle is filled in as coming from that sample.
    • Otherwise the algorithm checks to see if the the values along the horizontal or veritical edges are the same. If so, we split the rectangle in half, so that the corners that match are kept together. If not we do a recusion splitting the rectangle into quarters.
    • Constructor Summary

      Constructors 
      Constructor Description
      RectRecurse()  
    • Method Summary

      All Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and Type Method Description
      protected int cornerMatch​(int[] corners, boolean[] valid, boolean[] newValid)
      Check the corners of a rectangle.
      protected abstract double criterion​(int image, int nx, int ny, double tx, double ty)
      The criterion function should return a larger value for more desirable inputs.
      protected boolean edgeOff​(int match, int p0, int pe, int dp, boolean[] valid)
      Check whether all pixels on an edge of a rectangle all have the same best fit image.
      int[] findImages​(Image[] input, Image output)
      Find the best image for each output pixel.
      protected Image getCandidate​(int i)
      Return a particular candidate.
      protected double[] getImage​(Image img, double[] inp)
      Convert an input unit vector to a position in an image.
      protected int[] getInputLimits​(Image in)  
      protected double minDist​(double x, double y, double a, double b)
      Given a point at x,y in an image of size a,b in the rectangle 0,a 0,b find the minimum distance to the edge.
      void printOut​(int[] arr, int mx)
      Debugging output
      protected double radiusSquared​(double tx, double ty, double nx, double ny, int index, Image input)
      The default for this is to use the radius from the center of the image.
      void setStrict​(boolean flag)
      Set a strict geometry.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Constructor Detail

      • RectRecurse

        public RectRecurse()
    • Method Detail

      • findImages

        public int[] findImages​(Image[] input,
                                Image output)
        Find the best image for each output pixel.
        Specified by:
        findImages in class ImageFinder
        Parameters:
        input - An array of images that may be sampled to get the output image.
        output - The output image. In this routine we are interested in its geometry, not its data.
        Returns:
        An index array which for each pixel in the output image gives the best image to sample. Note that this has dimension int[nx*ny] where nx changes most rapidly. The values of the index array can be:
        • >= 0: The pixel is best indexed with the given image.
        • -1: [internal] The best image for this pixel has not yet been determined.
        • -2: This pixel is not on any of the input images.
        • -3: This pixel does not represent a physical coordinate.
        • -4: [in other methods] this pixel has already been processed.
      • getCandidate

        protected Image getCandidate​(int i)
        Return a particular candidate.
        Parameters:
        i - The index of the requested candidate
        Returns:
        The input image.
      • setStrict

        public void setStrict​(boolean flag)
        Set a strict geometry. This class ignores the strict geometry flag since it does boundary checking.
        Overrides:
        setStrict in class ImageFinder
        Parameters:
        flag - Should strict checking be enabled?
      • edgeOff

        protected boolean edgeOff​(int match,
                                  int p0,
                                  int pe,
                                  int dp,
                                  boolean[] valid)
        Check whether all pixels on an edge of a rectangle all have the same best fit image.
        Parameters:
        match - The value each edge is to be compared against.
        p0 - The first pixel offset to be checked.
        pe - The last pixel offset to be checked.
        dp - The spacing between pixels (either 1 or the number of pixels in a row).
        valid - Should we consider this image?
        valid - If we recurse should be consider this image?
        Returns:
        true if there is a discrepant pixel, or false if all values are the same as std.
      • cornerMatch

        protected int cornerMatch​(int[] corners,
                                  boolean[] valid,
                                  boolean[] newValid)
        Check the corners of a rectangle.
        Parameters:
        corners - The corners of the rectangle. It is assumed that there are four elements in corners, and they are in the order p00, p01, p10, p11
        valid - The images to be checked at the current level of recursion.
        newValid - The images to be checked at the next level of recursion. This routine will look at the corners of the image in relation to the bounds of the valid images to decide which images to search at a future level of recursion.
        Returns:
        A zero of positive value indicates that all corners match that image. Negative values code where variations were shown.
      • minDist

        protected double minDist​(double x,
                                 double y,
                                 double a,
                                 double b)
        Given a point at x,y in an image of size a,b in the rectangle 0,a 0,b find the minimum distance to the edge. We assume that x,y is contained in the rectangle. If x,y is outside the rectangle, then this should return a negative number.
        Parameters:
        x - The x value of the point.
        y - The y value of the point
        a - The width of the image.
        b - the height of the image
        Returns:
        The distance between the point and the nearest edge.
      • getImage

        protected double[] getImage​(Image img,
                                    double[] inp)
        Convert an input unit vector to a position in an image.
        Parameters:
        img - The image we are transforming into the plane of.
        inp - The input unit celestial coordinate unit vector.
        Returns:
        The coordinate plane tuple. This is returned as a pointer to the field t2.
      • getInputLimits

        protected int[] getInputLimits​(Image in)
      • radiusSquared

        protected double radiusSquared​(double tx,
                                       double ty,
                                       double nx,
                                       double ny,
                                       int index,
                                       Image input)
        The default for this is to use the radius from the center of the image. The last two arguments may be used in extending classes. when the center of the image is not the center of the field of view.
        Parameters:
        tx - The x value of the first point.
        ty - The y value of the first point.
        nx - The width of the image.
        ny - the height of the image.
        Returns:
        the distance squared from the center of the image.
      • criterion

        protected abstract double criterion​(int image,
                                            int nx,
                                            int ny,
                                            double tx,
                                            double ty)
        The criterion function should return a larger value for more desirable inputs.
        Parameters:
        image - The index of the image being considered
        nx - The width of the candidate image
        ny - The height of the caandiate image
        tx - The x-value of the requested point.
        ty - The y-value of the requested point.
        Returns:
        A measure of the desirability of using this image to same this point. Larger is better.
      • printOut

        public void printOut​(int[] arr,
                             int mx)
        Debugging output
        Parameters:
        arr - An input array.
        mx - The number of values to put on a line