RectRecurse

java.lang.Object
- skyview.process.ImageFinder
- - skyview.process.imagefinder.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.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CONSUMED`
`protected Transformer`	`fromOut` The transformation from the output pixels to the celestial sphere
`static int`	`NO_COVERAGE`
`static int`	`NON_PHYSICAL`
`static int`	`SPLIT_X`
`static int`	`SPLIT_XY`
`static int`	`SPLIT_Y`
`static int`	`UNCHECKED`

Constructor Summary

Constructors
Constructor and Description

RectRecurse()

Constructors
Constructor and Description
`RectRecurse()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and 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 skyview.process.ImageFinder
factory

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - fromOut
```
protected Transformer fromOut
```
    The transformation from the output pixels to the celestial sphere
  - UNCHECKED
```
public static final int UNCHECKED
```
    See Also:
    
    Constant Field Values
  - NO_COVERAGE
```
public static final int NO_COVERAGE
```
    See Also:
    
    Constant Field Values
  - NON_PHYSICAL
```
public static final int NON_PHYSICAL
```
    See Also:
    
    Constant Field Values
  - CONSUMED
```
public static final int CONSUMED
```
    See Also:
    
    Constant Field Values
  - SPLIT_X
```
public static final int SPLIT_X
```
    See Also:
    
    Constant Field Values
  - SPLIT_Y
```
public static final int SPLIT_Y
```
    See Also:
    
    Constant Field Values
  - SPLIT_XY
```
public static final int SPLIT_XY
```
    See Also:
    
    Constant Field Values
- 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

Class RectRecurse

Field Summary

Constructor Summary

Method Summary

Methods inherited from class skyview.process.ImageFinder

Methods inherited from class java.lang.Object

Field Detail

fromOut

UNCHECKED

NO_COVERAGE

NON_PHYSICAL

CONSUMED

SPLIT_X

SPLIT_Y

SPLIT_XY

Constructor Detail

RectRecurse

Method Detail

findImages

getCandidate

setStrict

edgeOff

cornerMatch

minDist

getImage

getInputLimits

radiusSquared

criterion

printOut