ImageUtils (SAFS API DOCUMENT)

java.lang.Object
- org.safs.image.ImageUtils

```
public class ImageUtils
extends java.lang.Object
```
Utility functions for processing or manipulating Images stored in the File system or captured from the Screen.

Author:

Carl Nagle Sept 09, 2008

See Also:

Robot, BufferedImage

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ImageUtils.AlterImageStyle` The style to alter the image. SHADE Get the image darker TINT Get the image lighter NONE Keep the image unchanged
`(package private) static class`	`ImageUtils.ModifiedRectInfo`
`static class`	`ImageUtils.SubArea` Represent an SubArea by 2 coordiantes (TopLeft, BottomRight). The x/y of coordinate can be number or a percentage-number, number means absolute coordinate, percentage-number means relative width/height. This SubArea is used to get a sub Rectangle from a Rectangle.

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) static java.lang.String[]`	`_imagerec`
`(package private) static java.lang.String[]`	`_imagerec_alone`
`(package private) static long`	`closestMatchCount`
`(package private) static long`	`closestMatchesOf`
`(package private) static float`	`closestPercentage`
`(package private) static int`	`closestX`
`(package private) static int`	`closestY`
`static boolean`	`debug` for messaging and GenericEngine.saveTestRecordScreenToTestDirectory
`static int`	`default_percent_bits_tolerance` 1-100, acquired from non-recognition string settings like an INI file.
`static boolean`	`default_useBitsTolerance` true or false, acquired from non-recognition string settings like an INI file.
`static int`	`DIVIDE_PIECES` When USE_MULTIPLE_THREADS is true, DIVIDE_PIECES will be used.
`static java.lang.String`	`EXT_GIF`
`static java.lang.String`	`EXT_JPEG`
`static java.lang.String`	`EXT_JPG`
`static java.lang.String`	`EXT_PNG`
`static java.lang.String`	`EXT_TIF`
`static java.lang.String`	`EXT_TIFF`
`static int`	`IMAGE_SIZE_PIXEL_THREADSHOLD` '100*100' if the image size is bigger than this threadshold, we will use multiple threads to compare
`static int`	`INT_BOTTOMCENTER`
`static int`	`INT_BOTTOMLEFT`
`static int`	`INT_BOTTOMRIGHT`
`static int`	`INT_CENTER`
`static int`	`INT_LEFTCENTER`
`static int`	`INT_RIGHTCENTER`
`static int`	`INT_TOPCENTER`
`static int`	`INT_TOPLEFT`
`static int`	`INT_TOPRIGHT`
`(package private) static JAIImagingListener`	`jailistener`
`static int`	`MAX_PERCENT_BITS_TOLERANCE` 100
`static java.lang.String`	`MOD_BC`
`static java.lang.String`	`MOD_BITTOLERANCE`
`static java.lang.String`	`MOD_BL`
`static java.lang.String`	`MOD_BOTTOMCENTER`
`static java.lang.String`	`MOD_BOTTOMLEFT`
`static java.lang.String`	`MOD_BOTTOMRIGHT`
`static java.lang.String`	`MOD_BR`
`static java.lang.String`	`MOD_BT`
`static java.lang.String`	`MOD_C`
`static java.lang.String`	`MOD_CENTER`
`static java.lang.String`	`MOD_COMMA`
`static java.lang.String`	`MOD_EQ`
`static java.lang.String`	`MOD_HOTSPOT`
`static java.lang.String`	`MOD_HS`
`static java.lang.String`	`MOD_IMAGE`
`static java.lang.String`	`MOD_IMAGE_RECT` "ImageRect=", "SearchRect", "ImageRectangle=", or "SearchRectangle" support a new image mode to define a top Window only.
`static java.lang.String`	`MOD_IMAGE_RECTANGLE`
`static java.lang.String`	`MOD_IMAGEB`
`static java.lang.String`	`MOD_IMAGEBOTTOM`
`static java.lang.String`	`MOD_IMAGEH`
`static java.lang.String`	`MOD_IMAGEHEIGHT`
`static java.lang.String`	`MOD_IMAGER`
`static java.lang.String`	`MOD_IMAGERIGHT`
`static java.lang.String`	`MOD_IMAGETEXT` "ImageText=", a new image mode to define a non top Window only.
`static java.lang.String`	`MOD_IMAGEW`
`static java.lang.String`	`MOD_IMAGEWIDTH`
`static java.lang.String`	`MOD_IND`
`static java.lang.String`	`MOD_INDEX`
`static java.lang.String`	`MOD_INS`
`static java.lang.String`	`MOD_INSETS`
`static java.lang.String`	`MOD_LC`
`static java.lang.String`	`MOD_LEFTCENTER`
`static java.lang.String`	`MOD_OUTS`
`static java.lang.String`	`MOD_OUTSETS`
`static java.lang.String`	`MOD_PERCENT`
`static java.lang.String`	`MOD_POINTRELATIVE`
`static java.lang.String`	`MOD_PR`
`static java.lang.String`	`MOD_RC`
`static java.lang.String`	`MOD_RIGHTCENTER`
`static java.lang.String`	`MOD_SEARCH_RECT`
`static java.lang.String`	`MOD_SEARCH_RECTANGLE`
`static java.lang.String`	`MOD_SEARCHMASK`
`static java.lang.String`	`MOD_SEARCHRECT`
`static java.lang.String`	`MOD_SEMICOLON`
`static java.lang.String`	`MOD_SEP`
`static java.lang.String`	`MOD_SM`
`static java.lang.String`	`MOD_SPACE`
`static java.lang.String`	`MOD_SR`
`static java.lang.String`	`MOD_TC`
`static java.lang.String`	`MOD_TL`
`static java.lang.String`	`MOD_TOPCENTER`
`static java.lang.String`	`MOD_TOPLEFT`
`static java.lang.String`	`MOD_TOPRIGHT`
`static java.lang.String`	`MOD_TR`
`(package private) static int`	`percentBitsTolerance` current tolerance for percent of image pixels that must match
`(package private) static int`	`screenBands`
`(package private) static java.awt.image.DataBuffer`	`screenBuffer`
`(package private) static java.awt.image.ColorModel`	`screenColor`
`(package private) static int`	`screenHeight`
`(package private) static java.awt.image.BufferedImage`	`screenImage`
`(package private) static int`	`screenImageType`
`(package private) static java.awt.image.SampleModel`	`screenModel`
`(package private) static java.awt.image.Raster`	`screenRaster`
`(package private) static java.awt.Rectangle`	`screenRect`
`(package private) static java.awt.Dimension`	`screenSize`
`(package private) static int`	`screenWidth`
`(package private) static java.awt.Toolkit`	`toolkit`
`static boolean`	`USE_FUZZY_MATCHING` true if we can add fuzzy pixel matching to the normal match algorithm
`static boolean`	`USE_MULTIPLE_THREADS` Set true if image searches using BitTolerance should attempt to use parallel threading.
`static boolean`	`USE_PER_IMAGE_MODIFIERS` Allow enhanced use of SearchRect=, Index=, and BitTolerance= on all Window definition components like Image=, ImageR= and ImageH= instead of just for the Image= portion.
`(package private) static boolean`	`useBitsTolerance` true if percentBitsTolerance should be used when evaluating image matches

Constructor Summary

Constructors
Constructor and Description

ImageUtils()

Constructors
Constructor and Description
`ImageUtils()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`protected static java.awt.Rectangle`	`adjustImageBRect(java.awt.image.BufferedImage pic, java.awt.Rectangle searchRec)`
`static java.awt.image.BufferedImage`	`blurImage(java.awt.image.BufferedImage image)`
`static java.awt.Point`	`calcHotspotPoint(java.awt.Point relativehs, java.awt.Rectangle area, int pointrelative)`
`static double`	`calculateAbsoluteCoordinate(double xOrY, double wOrH, java.lang.String offset)` Caculate an absolute coordinate according to (x, width)/(y, height) and offset.
`static java.awt.image.BufferedImage`	`captureScreenArea(java.awt.Rectangle screenRect)` Retrieve a BufferedImage of an area of the screen.
`static boolean`	`compareImage(java.awt.image.BufferedImage sourceImage, java.awt.image.BufferedImage targetImage, int percentBitsTolerance)` Compare the sourceImage and targetImage.
`static boolean`	`compareImage(java.awt.image.BufferedImage sourceImage, java.awt.image.BufferedImage targetImage, java.awt.Rectangle sourceRect, java.awt.Rectangle targetRect, int percentBitsTolerance)` Compare the sourceImage and targetImage, or compare a certain area of them.
`static java.awt.Rectangle[]`	`convertAreas(java.awt.Rectangle basedRect, java.lang.String areas, java.util.List<java.lang.String> warnings)` Convert a set of area into an array of Rectangle
`static java.awt.image.BufferedImage`	`convertImage(java.awt.image.BufferedImage image, int type)` Convert the BufferedImage to another type of BufferedImage. Some types cannot convert to, for example BufferedImage.TYPE_CUSTOM
`static java.util.List<java.awt.image.BufferedImage>`	`convertPDF(java.io.File pdfFile, int resolution)`
`static java.awt.image.BufferedImage`	`convertToRGBImage(java.awt.image.BufferedImage image)` If the image contains alpha value, then remove it and create a new RGB Image.
`static java.awt.image.BufferedImage`	`copy(java.awt.image.BufferedImage image)` Make a deep copy of original BufferedImage. Do NOT copy the Raster. But paint the original image on a new BufferedImage of the same size and type, so the Raster has the same size as image (will not contain more data with an offset).
`static java.awt.image.BufferedImage`	`copyRaster(java.awt.image.BufferedImage bi)` Make a deep copy of original BufferedImage, copy the Raster. This method is not very reliable, sometimes it fail.
`static java.awt.image.BufferedImage`	`createDiffImage(java.awt.image.BufferedImage buffimg, java.awt.image.BufferedImage benchimg)` With the assumption that the two provided images are NOT matching, we will create a Diff image composite from the two images.
`static java.awt.image.BufferedImage`	`createDiffImage(java.awt.image.BufferedImage buffimg, java.awt.image.BufferedImage benchimg, ImageUtils.AlterImageStyle style, double factor)` With the assumption that the two provided images are NOT matching, we will create a Diff image composite from the two images.
`static javax.swing.ImageIcon`	`createImageIcon(java.lang.String path)` Returns an ImageIcon, or null if the path is invalid.
`static java.awt.image.BufferedImage`	`edgeImage(java.awt.image.BufferedImage image)`
`static int`	`extractBitsTolerance(java.lang.String[] recognition)` Extract the BitTolerance=N; or BT=N; modifier of an Image-Based Testing recognition string.
`static int`	`extractBitsTolerance(java.lang.String imagetype, java.lang.String[] recognition)` Extract the BitTolerance=N; or BT=N; modifier of an Image-Based Testing recognition string.
`static java.awt.Point`	`extractHotspot(java.lang.String[] recognition)` Attempt to extract the Hotspot=; portion of an Image-Based Testing recognition string.
`static int`	`extractImageIndex(java.lang.String[] recognition)` Extract the Index=N; modifier of an Image-Based Testing recognition string.
`static int`	`extractImageIndex(java.lang.String imagetype, java.lang.String[] recognition)` Extract the Index=N; modifier of an Image-Based Testing recognition string.
`static java.lang.String`	`extractImagePath(java.lang.String imagex, java.lang.String[] recognition)` Attempt to extract the Image=path; portion of an Image-Based Testing recognition string. This can also be an ImageRect or SearchRect "path".
`static int`	`extractPointRelative(java.lang.String[] recognition)` Extract the PointRelative= info of the recognition string.
`static java.awt.Rectangle`	`extractSearchRect(java.lang.String winimagetype, java.lang.String[] recognition)` Attempt to extract the SearchRect=; portion of an Image-Based Testing recognition string.
`static java.awt.Rectangle`	`extractSearchRect(java.lang.String winimagetype, java.lang.String[] recognition, java.awt.Rectangle relative)` Attempt to extract the SearchRect=; portion of an Image-Based Testing recognition string.
`static java.awt.image.BufferedImage`	`filterImage(java.awt.image.BufferedImage image, java.awt.image.BufferedImageOp op)` Purpose: Use provided BufferedImageOp to convert image
`static java.awt.image.BufferedImage`	`filterImage(java.awt.image.BufferedImage image, java.lang.String filteredAreas, java.util.List<java.lang.String> warnings)` Cover an image by black color on a set of area.
`static java.awt.Rectangle`	`findBufferedImageOnScreen(java.awt.image.BufferedImage image)` Call the main findBufferedImageOnScreen with null searchRect and nthindex of 1.
`static java.awt.Rectangle`	`findBufferedImageOnScreen(java.awt.image.BufferedImage image, java.awt.Rectangle searchRect)` Call the main findBufferedImageOnScreen with searchRect and nthindex of 1.
`static java.awt.Rectangle`	`findBufferedImageOnScreen(java.awt.image.BufferedImage image, java.awt.Rectangle searchRect, int nth)` Attempts to locate the provided image within the latest screenshot and return its location and size, if found.
`(package private) static java.awt.Rectangle`	`findCompImageInRectangle(TestRecordHelper trd, java.lang.String imagepath, int imageindex, java.lang.String[] modifiers, java.awt.Rectangle rect)` Called by findComponentRectangle.
`static java.awt.Rectangle`	`findComponentRectangle(TestRecordHelper trd)` Calls findComponentRectangle with a timeout of 0.
`static java.awt.Rectangle`	`findComponentRectangle(TestRecordHelper trd, long timeout)` Locate the final Window:Component Rectangle specified by the test record.
`static java.awt.Rectangle`	`findImageLocation(TestRecordHelper trd, boolean imageBR, java.lang.String imagepath, java.awt.Rectangle searchRec, int nthindex)` Routine to find an image on the screen.
`(package private) static java.awt.Rectangle`	`findImageTextInRectangle(java.lang.String imagetext, int imageindex, STAFHelper staf, java.lang.String[] modifiers, java.awt.Rectangle rect)` Called by findComponentRectangle.
`protected static java.awt.Rectangle`	`findImageWithXYBTThread(int startx, int starty, int searchWidth, int searchHeight, int maxPixelErrors, java.awt.image.BufferedImage image, java.awt.image.DataBuffer imageBuffer, java.awt.image.SampleModel imageModel)` Generally called from findBufferedImageOnScreen and not normally called directly.
`protected static java.awt.Rectangle`	`findImageWithXYBTThreadPool(int startx, int starty, int searchWidth, int searchHeight, int maxPixelErrors, java.awt.image.DataBuffer imageBuffer, java.awt.image.SampleModel imageModel, int nth)` Generally called from findBufferedImageOnScreen and not normally called directly.
`static java.awt.Rectangle`	`getClippedSubAreaRectangle(java.awt.Rectangle compRect, java.awt.Rectangle subRect)` Helper function for getSubAreaRectangle().
`static java.awt.image.BufferedImage`	`getCopiedImage(java.awt.image.BufferedImage srcImage, int destWidth, int destHeight, java.awt.Color initialColor)` Purpose Create a new BufferedImage object, its size is destWidth*destHeight If the size is samller than the source image, copy that part from source image to this new image; While if the size is bigger, copy the whole source image to this new image, and the part beyond will be filled by initialColor This method is used when drag to resize an image in ImageManager2
`static java.awt.image.BufferedImage`	`getCopiedImage(java.awt.image.BufferedImage srcImage, int srcOffsetX, int srcOffsetY, int destOffsetX, int destOffsetY, int destWidth, int destHeight, java.awt.Color initialColor)` Purpose Copy the source image to a new image, whose width and height are given by destWidth and destHeight; The area of new image outside of the source image will be filled with the color provided by parameter.
`static javax.swing.filechooser.FileFilter`	`getImageFileFilter()`
`static int`	`getScreenHeight()`
`static java.awt.image.BufferedImage`	`getScreenImage()` Return the latest BufferedImage captured for the screen.
`static java.awt.Rectangle`	`getScreenSize()` Return the rectangle of the whole screen.
`static int`	`getScreenWidth()`
`static java.awt.image.BufferedImage`	`getStoredImage(java.lang.String fullpath)` Attempts to create\load a BufferedImage from an image stored in the File system.
`static java.awt.Dimension`	`getStoredImageDimension(java.lang.String fullpath)` Attempts to determine the width and height of the stored image.
`static java.awt.Rectangle`	`getSubAreaRectangle(java.awt.Rectangle compRect, java.lang.String subarea)` Given the compRect Rectangle and the subarea string, return a new, valid Rectangle that represents the SubArea.
`static java.awt.image.BufferedImage`	`getVoidBufferImage(int width, int height, int defaultType, int altType)` Purpose Create a new BufferedImage Object with a certain type.
`static boolean`	`hasAlpha(java.awt.Image image)`
`static boolean`	`isImageBasedRecognition(java.lang.String recognition)` Attempt to determine if recognition string is for image-based testing
`static boolean`	`isImageFormatSupported(java.lang.String fileName)`
`(package private) static boolean`	`isImageType(java.lang.String imagetype, java.lang.String modifier)` See if the recognition string modifier maps to the imagetype passed in.
`static boolean`	`isScreenXYFuzzyMatch(java.awt.image.DataBuffer sBuffer, java.awt.image.SampleModel smodel, int screencenterX, int screencenterY, java.awt.image.DataBuffer tBuffer, java.awt.image.SampleModel tmodel, int targetX, int targetY)` This is a time expensive match seeking to match 1 pixel with any one of 8 adjacent pixels.
`static void`	`main(java.lang.String[] args)`
`static ImageUtils.ModifiedRectInfo`	`modifyLocWidthHeight(TestRecordHelper trd, java.awt.Rectangle winloc, java.lang.String[] modifiers)` Attempt to expand the winloc Rectangle based on locating IMAGEW and IMAGEH images specified in the recognition string.
`static java.awt.image.BufferedImage`	`negativeImage(java.awt.image.BufferedImage image)`
`static java.lang.String`	`normalizeFileNameSuffix(java.lang.String filename)` Check the suffix of filename, if it is not supported then append '.bmp' as suffix.
`static java.lang.String`	`normalizeSubAreas(java.lang.String areas)` Normalize a subareas string. Replace all ";" by ",".
`static void`	`outputImageData(java.awt.image.BufferedImage image)` Needs Enhancement API subject to change.
`static java.awt.image.BufferedImage`	`paintOnImage(java.awt.image.BufferedImage image, int offsetX, int offsetY, int width, int height, java.awt.Color initialColor, boolean paintOnNewImage)` Purpose Modify the source image by painting a simple color on an area, this area is defined by offsetX,offsetY,width,height This method is used when cut an area from an image in ImageManager2
`static java.awt.image.BufferedImage`	`paintOnImage(java.awt.image.BufferedImage srcImage, int srcOffsetX, int srcOffsetY, int width, int height, int destOffsetX, int destOffsetY, java.awt.image.BufferedImage destImage, java.awt.Color initialColor, boolean paintOnNewImage)` Purpose Get an area from the source image, this area is defined by srcOffsetX,srcOffsetY,width,height; Then copy this area to the destImage, the point to start to paint is (destOffsetX,destOffsetY) If the area is too big, beyond the source image, then the souce image will be enlarged, the extra part will be painted with initColor. This method is used when copy an image to the panel in ImageManager2
`(package private) static int`	`processBitsToleranceModifier(java.lang.String value)` Called internally from extractBitTolerance.
`(package private) static java.awt.Rectangle`	`processSearchRectModifier(java.lang.String modifier, java.awt.Rectangle rectangle, boolean isRelative)` Called internally by extractSearchRect
`static void`	`recaptureScreen()` Recaptures certain properties and the graphical contents of the screen.
`static void`	`resetBitsTolerance()` Resets the class to use the default_percent_bits_tolerance and the default_useBitsTolerance.
`static void`	`resetMatchData()` Clear\Reset all internally stored search match data like: closestX, closestY, closestMatchCount, closestMatchesOf, closestPercentage
`static void`	`resetScreenData()` Clear\Reset all internally stored screen data like: screenWidth, screenHeight, screenBands, screenImage, screenModel, screenBuffer, and screenColor.
`static java.io.File`	`retrieveAbsoluteFileOrDirectory(TestRecordHelper trd, java.lang.String path)` path must not be null or 0-length
`static java.awt.image.BufferedImage`	`rotateImage(java.awt.image.BufferedImage bufferedimage, int angle)` Rotate the Image with 90, 180 or 270 degree.
`static void`	`saveImageToFile(java.awt.image.BufferedImage image, java.io.File file)` Store our BufferedImage into a File.
`static void`	`saveImageToFile(java.awt.image.BufferedImage image, java.io.File file, float quality)` Store our BufferedImage into a File; If the format is JPG, the third parameter indicate the compression quality.
`static java.awt.image.BufferedImage`	`sharpenImage(java.awt.image.BufferedImage image)`
`static java.lang.String[]`	`splitRecognition(java.lang.String recognition)` Split the image recognition info at each MOD_SEP to form the String[] recognition needed by most routines.
`static void`	`takeScreenshot(java.lang.String screenShotFile)` Take screen shot and save it to a file.
`static java.awt.image.BufferedImage`	`toBufferedImage(java.awt.Image image)` Convert an Image to BufferedImage.

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

- Field Detail
  - debug
```
public static boolean debug
```
    for messaging and GenericEngine.saveTestRecordScreenToTestDirectory
  - MOD_EQ
```
public static final java.lang.String MOD_EQ
```
    See Also:
    
    Constant Field Values
  - MOD_COMMA
```
public static final java.lang.String MOD_COMMA
```
    See Also:
    
    Constant Field Values
  - MOD_SEMICOLON
```
public static final java.lang.String MOD_SEMICOLON
```
    See Also:
    
    Constant Field Values
  - MOD_SPACE
```
public static final java.lang.String MOD_SPACE
```
    See Also:
    
    Constant Field Values
  - MOD_PERCENT
```
public static final java.lang.String MOD_PERCENT
```
    See Also:
    
    Constant Field Values
  - MOD_SEP
```
public static final java.lang.String MOD_SEP
```
    See Also:
    
    Constant Field Values
  - MOD_IMAGE
```
public static final java.lang.String MOD_IMAGE
```
    See Also:
    
    Constant Field Values
  - MOD_IMAGER
```
public static final java.lang.String MOD_IMAGER
```
    See Also:
    
    Constant Field Values
  - MOD_IMAGERIGHT
```
public static final java.lang.String MOD_IMAGERIGHT
```
    See Also:
    
    Constant Field Values
  - MOD_IMAGEW
```
public static final java.lang.String MOD_IMAGEW
```
    See Also:
    
    Constant Field Values
  - MOD_IMAGEWIDTH
```
public static final java.lang.String MOD_IMAGEWIDTH
```
    See Also:
    
    Constant Field Values
  - MOD_IMAGEB
```
public static final java.lang.String MOD_IMAGEB
```
    See Also:
    
    Constant Field Values
  - MOD_IMAGEBOTTOM
```
public static final java.lang.String MOD_IMAGEBOTTOM
```
    See Also:
    
    Constant Field Values
  - MOD_IMAGEH
```
public static final java.lang.String MOD_IMAGEH
```
    See Also:
    
    Constant Field Values
  - MOD_IMAGEHEIGHT
```
public static final java.lang.String MOD_IMAGEHEIGHT
```
    See Also:
    
    Constant Field Values
  - MOD_INDEX
```
public static final java.lang.String MOD_INDEX
```
    See Also:
    
    Constant Field Values
  - MOD_IND
```
public static final java.lang.String MOD_IND
```
    See Also:
    
    Constant Field Values
  - MOD_HOTSPOT
```
public static final java.lang.String MOD_HOTSPOT
```
    See Also:
    
    Constant Field Values
  - MOD_HS
```
public static final java.lang.String MOD_HS
```
    See Also:
    
    Constant Field Values
  - MOD_SEARCHRECT
```
public static final java.lang.String MOD_SEARCHRECT
```
    See Also:
    
    Constant Field Values
  - MOD_SR
```
public static final java.lang.String MOD_SR
```
    See Also:
    
    Constant Field Values
  - MOD_SEARCHMASK
```
public static final java.lang.String MOD_SEARCHMASK
```
    See Also:
    
    Constant Field Values
  - MOD_SM
```
public static final java.lang.String MOD_SM
```
    See Also:
    
    Constant Field Values
  - MOD_POINTRELATIVE
```
public static final java.lang.String MOD_POINTRELATIVE
```
    See Also:
    
    Constant Field Values
  - MOD_PR
```
public static final java.lang.String MOD_PR
```
    See Also:
    
    Constant Field Values
  - MOD_INSETS
```
public static final java.lang.String MOD_INSETS
```
    See Also:
    
    Constant Field Values
  - MOD_INS
```
public static final java.lang.String MOD_INS
```
    See Also:
    
    Constant Field Values
  - MOD_OUTSETS
```
public static final java.lang.String MOD_OUTSETS
```
    See Also:
    
    Constant Field Values
  - MOD_OUTS
```
public static final java.lang.String MOD_OUTS
```
    See Also:
    
    Constant Field Values
  - MOD_BITTOLERANCE
```
public static final java.lang.String MOD_BITTOLERANCE
```
    See Also:
    
    Constant Field Values
  - MOD_BT
```
public static final java.lang.String MOD_BT
```
    See Also:
    
    Constant Field Values
  - MOD_TOPLEFT
```
public static final java.lang.String MOD_TOPLEFT
```
    See Also:
    
    Constant Field Values
  - MOD_TL
```
public static final java.lang.String MOD_TL
```
    See Also:
    
    Constant Field Values
  - INT_TOPLEFT
```
public static final int INT_TOPLEFT
```
    See Also:
    
    Constant Field Values
  - MOD_TOPCENTER
```
public static final java.lang.String MOD_TOPCENTER
```
    See Also:
    
    Constant Field Values
  - MOD_TC
```
public static final java.lang.String MOD_TC
```
    See Also:
    
    Constant Field Values
  - INT_TOPCENTER
```
public static final int INT_TOPCENTER
```
    See Also:
    
    Constant Field Values
  - MOD_TOPRIGHT
```
public static final java.lang.String MOD_TOPRIGHT
```
    See Also:
    
    Constant Field Values
  - MOD_TR
```
public static final java.lang.String MOD_TR
```
    See Also:
    
    Constant Field Values
  - INT_TOPRIGHT
```
public static final int INT_TOPRIGHT
```
    See Also:
    
    Constant Field Values
  - MOD_LEFTCENTER
```
public static final java.lang.String MOD_LEFTCENTER
```
    See Also:
    
    Constant Field Values
  - MOD_LC
```
public static final java.lang.String MOD_LC
```
    See Also:
    
    Constant Field Values
  - INT_LEFTCENTER
```
public static final int INT_LEFTCENTER
```
    See Also:
    
    Constant Field Values
  - MOD_CENTER
```
public static final java.lang.String MOD_CENTER
```
    See Also:
    
    Constant Field Values
  - MOD_C
```
public static final java.lang.String MOD_C
```
    See Also:
    
    Constant Field Values
  - INT_CENTER
```
public static final int INT_CENTER
```
    See Also:
    
    Constant Field Values
  - MOD_RIGHTCENTER
```
public static final java.lang.String MOD_RIGHTCENTER
```
    See Also:
    
    Constant Field Values
  - MOD_RC
```
public static final java.lang.String MOD_RC
```
    See Also:
    
    Constant Field Values
  - INT_RIGHTCENTER
```
public static final int INT_RIGHTCENTER
```
    See Also:
    
    Constant Field Values
  - MOD_BOTTOMLEFT
```
public static final java.lang.String MOD_BOTTOMLEFT
```
    See Also:
    
    Constant Field Values
  - MOD_BL
```
public static final java.lang.String MOD_BL
```
    See Also:
    
    Constant Field Values
  - INT_BOTTOMLEFT
```
public static final int INT_BOTTOMLEFT
```
    See Also:
    
    Constant Field Values
  - MOD_BOTTOMCENTER
```
public static final java.lang.String MOD_BOTTOMCENTER
```
    See Also:
    
    Constant Field Values
  - MOD_BC
```
public static final java.lang.String MOD_BC
```
    See Also:
    
    Constant Field Values
  - INT_BOTTOMCENTER
```
public static final int INT_BOTTOMCENTER
```
    See Also:
    
    Constant Field Values
  - MOD_BOTTOMRIGHT
```
public static final java.lang.String MOD_BOTTOMRIGHT
```
    See Also:
    
    Constant Field Values
  - MOD_BR
```
public static final java.lang.String MOD_BR
```
    See Also:
    
    Constant Field Values
  - INT_BOTTOMRIGHT
```
public static final int INT_BOTTOMRIGHT
```
    See Also:
    
    Constant Field Values
  - EXT_JPEG
```
public static final java.lang.String EXT_JPEG
```
    See Also:
    
    Constant Field Values
  - EXT_JPG
```
public static final java.lang.String EXT_JPG
```
    See Also:
    
    Constant Field Values
  - EXT_GIF
```
public static final java.lang.String EXT_GIF
```
    See Also:
    
    Constant Field Values
  - EXT_TIFF
```
public static final java.lang.String EXT_TIFF
```
    See Also:
    
    Constant Field Values
  - EXT_TIF
```
public static final java.lang.String EXT_TIF
```
    See Also:
    
    Constant Field Values
  - EXT_PNG
```
public static final java.lang.String EXT_PNG
```
    See Also:
    
    Constant Field Values
  - MOD_IMAGETEXT
```
public static final java.lang.String MOD_IMAGETEXT
```
    "ImageText=", a new image mode to define a non top Window only. In a traditional IBT-defined top window like "Image=", TessOCR may location the text area in the top window. Instead of searching a component image in a top-window image, SAFS may use tess OCR to locate the text area in the top-window if the text can be recognize by the OCR. Thus we no longer need to prepare the snapshots of the text in different screen resolution for SAFS to use like it used to be. Examples: Recognition Strings topWin="Image=" Comp="ImageText=" IBT script: T,topWin,Comp,Click
    
    See Also:
    
    Constant Field Values
  - MOD_IMAGE_RECT
```
public static final java.lang.String MOD_IMAGE_RECT
```
    "ImageRect=", "SearchRect", "ImageRectangle=", or "SearchRectangle" support a new image mode to define a top Window only.
    A traditional IBT-defined top window is like "Image=", then IBT will try to find the location of this top window on the screen. The location is represented by a Rectangle(x,y,width,height). In IBT we call this location as Anchor, from where we will continue to find component location.
    Now we can profit from a special Engine (ex. RJ) to get the top window object, this object can give us it's location on the screen, then we can create a new RS like "ImageRect=x,y,width,height" and send it back to IBT (@see org.safs.tools.engines.TIDComponent), IBT can deduce the Anchor from this RS directly.
    It will be a great complement for a special Engine in case that the engine can't find some components. Take RFT as example,
```
   Examples:
   Recognition Strings:
   topWin="Type=JavaWindow;Caption={Swing*}"
   Comp="IBT_Recognization_String"

   IBT script:
   T,topWin,Comp,Click

   Explain:
   1. RS topWin="Type=JavaWindow;Caption={Swing*}" is treated in a special Engine, the top window object
        is got.
   2. From the top window object, we generate a new RS "ImageRect=x,y,w,h" for top window. And we send the test
        record to IBT.
   3. IBT will parse RS "ImageRect=x,y,w,h" and get the Anchor, and it will find the component location
        within that Anchor, and perform the action Click on that location.
   
```
    If this feature is used with feature "ImageText=", that will be great. We don't need to store ANY one image.
    We can also support this just by allowing an IBT Window Recognition string in the appmap to contain ImageRect or SearchRect recognition information without specifying any real images.
    See Also:
    
    Constant Field Values
  - MOD_IMAGE_RECTANGLE
```
public static final java.lang.String MOD_IMAGE_RECTANGLE
```
    See Also:
    
    Constant Field Values
  - MOD_SEARCH_RECT
```
public static final java.lang.String MOD_SEARCH_RECT
```
    See Also:
    
    Constant Field Values
  - MOD_SEARCH_RECTANGLE
```
public static final java.lang.String MOD_SEARCH_RECTANGLE
```
    See Also:
    
    Constant Field Values
  - toolkit
```
static java.awt.Toolkit toolkit
```
  - screenSize
```
static java.awt.Dimension screenSize
```
  - screenRect
```
static java.awt.Rectangle screenRect
```
  - screenImage
```
static java.awt.image.BufferedImage screenImage
```
  - screenImageType
```
static int screenImageType
```
  - screenRaster
```
static java.awt.image.Raster screenRaster
```
  - screenModel
```
static java.awt.image.SampleModel screenModel
```
  - screenBuffer
```
static java.awt.image.DataBuffer screenBuffer
```
  - screenColor
```
static java.awt.image.ColorModel screenColor
```
  - screenWidth
```
static int screenWidth
```
  - screenHeight
```
static int screenHeight
```
  - screenBands
```
static int screenBands
```
  - closestX
```
static int closestX
```
  - closestY
```
static int closestY
```
  - closestMatchCount
```
static long closestMatchCount
```
  - closestMatchesOf
```
static long closestMatchesOf
```
  - closestPercentage
```
static float closestPercentage
```
  - MAX_PERCENT_BITS_TOLERANCE
```
public static final int MAX_PERCENT_BITS_TOLERANCE
```
    100
    
    See Also:
    
    Constant Field Values
  - default_percent_bits_tolerance
```
public static int default_percent_bits_tolerance
```
    1-100, acquired from non-recognition string settings like an INI file. Defaults to 100.
  - percentBitsTolerance
```
static int percentBitsTolerance
```
    current tolerance for percent of image pixels that must match
  - default_useBitsTolerance
```
public static boolean default_useBitsTolerance
```
    true or false, acquired from non-recognition string settings like an INI file. Defaults to false.
  - USE_PER_IMAGE_MODIFIERS
```
public static boolean USE_PER_IMAGE_MODIFIERS
```
    Allow enhanced use of SearchRect=, Index=, and BitTolerance= on all Window definition components like Image=, ImageR= and ImageH= instead of just for the Image= portion.
    true or false, acquired from non-recognition string settings like an INI file. Defaults to false.
  - useBitsTolerance
```
static boolean useBitsTolerance
```
    true if percentBitsTolerance should be used when evaluating image matches
  - USE_FUZZY_MATCHING
```
public static boolean USE_FUZZY_MATCHING
```
    true if we can add fuzzy pixel matching to the normal match algorithm
  - jailistener
```
static JAIImagingListener jailistener
```
  - USE_MULTIPLE_THREADS
```
public static boolean USE_MULTIPLE_THREADS
```
    Set true if image searches using BitTolerance should attempt to use parallel threading. The current implementation of multi-threading is poor, and may actually be slower than NOT using multi-threading. Current default is 'false'.
    
    See Also:
    
    SmallPieceComparator, ScreenXYBTComparator
  - DIVIDE_PIECES
```
public static int DIVIDE_PIECES
```
    When USE_MULTIPLE_THREADS is true, DIVIDE_PIECES will be used. This field decide the number of blocks that a search rectangle or an image to be divided, this is also the number of threads to be created to search an image. The number of threads will be DIVIDE_PIECES*DIVIDE_PIECES. The default DIVIDE_PIECES is 4, so number of blocks (or number of threads will be 4*4, that is 16)
    
    See Also:
    
    SmallPieceComparator
  - IMAGE_SIZE_PIXEL_THREADSHOLD
```
public static final int IMAGE_SIZE_PIXEL_THREADSHOLD
```
    '100*100' if the image size is bigger than this threadshold, we will use multiple threads to compare
    
    See Also:
    
    Constant Field Values
  - _imagerec_alone
```
static final java.lang.String[] _imagerec_alone
```
  - _imagerec
```
static final java.lang.String[] _imagerec
```
- Constructor Detail
  - ImageUtils
```
public ImageUtils()
```
- Method Detail
  - resetScreenData
```
public static void resetScreenData()
```
    Clear\Reset all internally stored screen data like: screenWidth, screenHeight, screenBands, screenImage, screenModel, screenBuffer, and screenColor.
  - resetMatchData
```
public static void resetMatchData()
```
    Clear\Reset all internally stored search match data like: closestX, closestY, closestMatchCount, closestMatchesOf, closestPercentage
  - getScreenWidth
```
public static int getScreenWidth()
```
    Returns:
    
    last known screenWidth or -1 if unretrievable
  - getScreenHeight
```
public static int getScreenHeight()
```
    Returns:
    
    last known screenHeight or -1 if unretrievable
  - createImageIcon
```
public static javax.swing.ImageIcon createImageIcon(java.lang.String path)
```
    Returns an ImageIcon, or null if the path is invalid.
    
    Parameters:
    
    path - String path suitable for getResource() to create\locate a valid java.net.URL.
    
    Returns:
    
    See Also:
    
    Class.getResource(String), URL
  - getClippedSubAreaRectangle
```
public static java.awt.Rectangle getClippedSubAreaRectangle(java.awt.Rectangle compRect,
                                                            java.awt.Rectangle subRect)
```
    Helper function for getSubAreaRectangle(). Given a compRect Rectangle and a subRect Rectangle that lies outside of the Component Rectangle, return a new, clipped subRect Rectangle that has been forced to fit in the bounds of the compRect Rectangle. If the subRect Rectangle falls completely outside of the compRect Rectangle, then an invalid Rectangle is created (width and/or height = 0). In that case, the new clipped Rectangle is invalid and null is returned (its image cannot be captured).
    
    Parameters:
    
    Rectangle - compRect; the portion of the window that holds the component.
    
    Rectangle - subRect; the the portion of compRect in question.
    
    Returns:
    
    Rectangle clippedRect; a new clipped portion of subRect that has been forced to fit in the bounds of compRect, or null if the subRect does not overlap the compRect in any way.
  - getSubAreaRectangle
```
public static java.awt.Rectangle getSubAreaRectangle(java.awt.Rectangle compRect,
                                                     java.lang.String subarea)
```
    Given the compRect Rectangle and the subarea string, return a new, valid Rectangle that represents the SubArea. This function may call getClippedSubAreaRectangle() to clip the new Rectangle if its dimensions paritally fall outside of the compRect Rectangle. If the defined subarea or the new clipped Rectangle are completely outside the bounds of compRect then a null is returned.
    
    Parameters:
    
    Rectangle - compRect; the source Rectangle to get the subarea from.
    
    String - subarea; the portion of compRect in question. subarea coors can be semi-colon delimited (x;2;3;4) or comma-delimited (1,2,3,4). subarea must be in the format of a top-left and bottom-right pair, and can be either absolute coordinates or percentages ("x1,y1,x2,y2" or "x1%,y1%,x2%,y2%"). Coordinates are relative to compRect, i.e. (0,0) and (0%,0%) are the minimum, and (compRect.width, compRect.height) and (100%,100%) are the maximum. Values exceeding the minimun/ maximum are forced to the nearest limiting value. Absolute and percent values can be mixed, so "0,0,50%,50%" is valid.
    
    Returns:
    
    Rectangle subRect; a new portion of the component to be captured, or null if the new subRect is invalid.
  - calculateAbsoluteCoordinate
```
public static double calculateAbsoluteCoordinate(double xOrY,
                                                 double wOrH,
                                                 java.lang.String offset)
                                          throws java.lang.Exception
```
    Caculate an absolute coordinate according to (x, width)/(y, height) and offset.
    
    Parameters:
    
    xOrY - double, the x/y of a rectangle.
    
    wOrH - double, the width/height of a rectangle.
    
    offset - String, the offset
    
    Returns:
    
    double, an absolute coordinate of an rectangle
    
    Throws:
    
    java.lang.Exception
  - recaptureScreen
```
public static void recaptureScreen()
                            throws java.awt.AWTException
```
    Recaptures certain properties and the graphical contents of the screen. Uses the java.awt.Robot to capture the full contents of the screen. Makes available internally, or through the public API:
    - screenSize
    - screenRect
    - screenImage (BufferedImage)
    - screenRaster
    - screenModel (SampleModel)
    - screenBuffer (DataBuffer)
    - screenColor (ColorModel)
    - screenBands (ARGB layers, per se)
    - screenWidth
    - screenHeight
    Throws:
    
    java.awt.AWTException - if instantiation of the java.awt.Robot throws it.
    
    See Also:
    
    getScreenImage(), screenHeight, screenWidth
  - captureScreenArea
```
public static java.awt.image.BufferedImage captureScreenArea(java.awt.Rectangle screenRect)
                                                      throws java.awt.AWTException
```
    Retrieve a BufferedImage of an area of the screen.
    
    Parameters:
    
    screenRect -
    
    Returns:
    
    BufferedImage
    
    Throws:
    
    java.awt.AWTException - if java.awt.Robot AWTException occurs
  - getScreenSize
```
public static java.awt.Rectangle getScreenSize()
```
    Return the rectangle of the whole screen.
    
    Returns:
    
    Rectangle, the rectangle of the screen
  - getScreenImage
```
public static java.awt.image.BufferedImage getScreenImage()
                                                   throws java.awt.AWTException
```
    Return the latest BufferedImage captured for the screen. If no screenImage has been captured then this routine will also initiate that first capture.
    
    Returns:
    
    BufferedImage representing the entire screen.
    
    Throws:
    
    java.awt.AWTException - if instantiating the java.awt.Robot throws it
    
    See Also:
    
    recaptureScreen()
  - getStoredImage
```
public static java.awt.image.BufferedImage getStoredImage(java.lang.String fullpath)
                                                   throws java.io.FileNotFoundException,
                                                          java.io.IOException
```
    Attempts to create\load a BufferedImage from an image stored in the File system. Using JAI API to read image file, it is supposed to support BMP, FPX, GIF, JPEG,PNG,PNM and TIFF. The TIFF operation supports the compression types: 1) no compression 2)PackBits compression 3)Modified Huffman compression (CCITT Group3 1-dimensional facsimile)
    
    Parameters:
    
    fullpath - case-insensitive absolute path to the image on file.
    
    Returns:
    
    BufferedImage representing the stored image.
    
    Throws:
    
    java.io.FileNotFoundException - if the file does not exist or cannot be read.
    
    java.io.IOException - if ImageIO has a problem reading the file or file format.
    
    See Also:
    
    BufferedImage, ImageIO.read(File)
  - getStoredImageDimension
```
public static java.awt.Dimension getStoredImageDimension(java.lang.String fullpath)
                                                  throws java.io.FileNotFoundException,
                                                         java.io.IOException
```
    Attempts to determine the width and height of the stored image.
    
    Parameters:
    
    fullpath - case-insensitive absolute path to the image on file.
    
    Returns:
    
    Dimension width and height of the image or null.
    
    Throws:
    
    java.io.FileNotFoundException - if the file does not exist or cannot be read.
    
    java.io.IOException - if ImageIO has a problem reading the file or file format.
    
    See Also:
    
    BufferedImage, ImageIO.read(File)
  - compareImage
```
public static boolean compareImage(java.awt.image.BufferedImage sourceImage,
                                   java.awt.image.BufferedImage targetImage,
                                   int percentBitsTolerance)
```
    Compare the sourceImage and targetImage.
    
    Parameters:
    
    sourceImage - BufferedImage, the bench image
    
    targetImage - BufferedImage, the test image
    
    percentBitsTolerance - int, the percentage of bits need to be the same. it is between 0 and 100. 100 means only 100% match, 2 images will be considered matched; 0 means even no bits match, 2 images will be considered matched.
    
    Returns:
    
    boolean, if the 2 images match.
    
    See Also:
    
    compareImage(BufferedImage, BufferedImage, Rectangle, Rectangle, int)
  - compareImage
```
public static boolean compareImage(java.awt.image.BufferedImage sourceImage,
                                   java.awt.image.BufferedImage targetImage,
                                   java.awt.Rectangle sourceRect,
                                   java.awt.Rectangle targetRect,
                                   int percentBitsTolerance)
```
    Compare the sourceImage and targetImage, or compare a certain area of them.
    
    Parameters:
    
    sourceImage - BufferedImage, the bench image
    
    targetImage - BufferedImage, the test image
    
    sourceRect - Rectangle, the area on source image to compare; if null, compare whole image
    
    targetRect - Rectangle, the area on target image to compare; if null, compare whole image
    
    percentBitsTolerance - int, the percentage of bits need to be the same. it is between 0 and 100. 100 means only 100% match, 2 images will be considered matched; 0 means even no bits match, 2 images will be considered matched.
    
    Returns:
    
    boolean, if the 2 images (or certain area) match.
    
    See Also:
    
    compareImage(BufferedImage, BufferedImage, int), _compareImageWithThread(BufferedImage, BufferedImage, int, int)
  - findBufferedImageOnScreen
```
public static java.awt.Rectangle findBufferedImageOnScreen(java.awt.image.BufferedImage image,
                                                           java.awt.Rectangle searchRect,
                                                           int nth)
                                                    throws java.lang.IllegalArgumentException,
                                                           java.awt.image.ImagingOpException,
                                                           java.awt.AWTException
```
    Attempts to locate the provided image within the latest screenshot and return its location and size, if found. Use the current Bit Tolerance settings.
    
    Parameters:
    
    image - -- BufferedImage to locate within the latest screenshot.
    
    searchRect - --limit the search area. Should be null to search the whole screen.
    
    nth - -- the nth instance of a match. (1) first, by default. It may be -1, which means user specify "Index=any" and he wants to use multi-thread-search; It may be 0, which means user don't give "Index=N", SAFS will decide to use multi or single thread according to value of USE_MULTIPLE_THREADS. This parameter should be assigned to 0 when calling by other method without knowing the real index, so that the multi-thread-search can be profited when USE_MULTIPLE_THREADS is true.
    
    Returns:
    
    Rectangle where image was found, or null
    
    Throws:
    
    java.lang.IllegalArgumentException - if the searchRect is not valid. (null will not throw this)
    
    java.awt.image.ImagingOpException
    
    java.awt.AWTException
  - findImageWithXYBTThreadPool
```
protected static java.awt.Rectangle findImageWithXYBTThreadPool(int startx,
                                                                int starty,
                                                                int searchWidth,
                                                                int searchHeight,
                                                                int maxPixelErrors,
                                                                java.awt.image.DataBuffer imageBuffer,
                                                                java.awt.image.SampleModel imageModel,
                                                                int nth)
                                                         throws java.lang.IllegalArgumentException,
                                                                java.awt.image.ImagingOpException,
                                                                java.awt.AWTException
```
    Generally called from findBufferedImageOnScreen and not normally called directly. Uses a Thread pool to attempt to take advantage of multi-processor systems. This particular algorithm uses multiple ScreenXYBTComparators--one for each screen pixel anchor point.
    Initial testing seems to suggest that using one thread per pixel anchor on the screen is too fine grained. The overhead of thread maintenance appears to be too great--making the performance poorer than simply using a single-threaded algorithm. For this reason, the use of the algorithm is presently discouraged and is disabled, by default.
    
    Parameters:
    
    startx - - x-coord on screen to start the search
    
    starty - - y-coord on screen to start the search
    
    searchWidth - - width of area from startx to search
    
    searchHeight - - height of area from starty to search
    
    maxPixelErrors - - max number of pixels that can fail comparison
    
    imageBuffer - - DataBuffer of the target image
    
    imageModel - - SampleModel of the target image
    
    nth - - normally 1. Find the nth match of the image on screen.
    
    Returns:
    
    Rectangle location where the image was found or null.
    
    Throws:
    
    java.lang.IllegalArgumentException
    
    java.awt.image.ImagingOpException
    
    java.awt.AWTException
    
    See Also:
    
    #findBufferedImageOnScreen(BufferedImage, Rectangle, int)}, DataBuffer, SampleModel
  - findImageWithXYBTThread
```
protected static java.awt.Rectangle findImageWithXYBTThread(int startx,
                                                            int starty,
                                                            int searchWidth,
                                                            int searchHeight,
                                                            int maxPixelErrors,
                                                            java.awt.image.BufferedImage image,
                                                            java.awt.image.DataBuffer imageBuffer,
                                                            java.awt.image.SampleModel imageModel)
                                                     throws java.lang.IllegalArgumentException,
                                                            java.awt.image.ImagingOpException,
                                                            java.awt.AWTException
```
    Generally called from findBufferedImageOnScreen and not normally called directly. Use multiple-thread algorithm to search an image on screen. The search algorithm is different according to the size of the picture. If the size is big: We will divide the picture to small blocks, for each block, we use SmallPieceComparator to create a thread to compare with according screen location. If all blocks can match, which means the whole picture match. If the size is small: We will divide the search rectangle to small pieces, for each small search rectangle, we use SmallPieceComparator to create a thread to search the whole picture in that rectangle. If one of the thread find a matched picture in its search rectangle, which means the search is ok, we can stop the other threads.
    
    Parameters:
    
    startx - - x-coord on screen to start the search
    
    starty - - y-coord on screen to start the search
    
    searchWidth - - width of area from startx to search
    
    searchHeight - - height of area from starty to search
    
    maxPixelErrors - - max number of pixels that can fail comparison
    
    image - - BufferedImage of the target image
    
    imageBuffer - - DataBuffer of the target image
    
    imageModel - - SampleModel of the target image
    
    Returns:
    
    Rectangle location where the image was found or null.
    
    Throws:
    
    java.lang.IllegalArgumentException
    
    java.awt.image.ImagingOpException
    
    java.awt.AWTException
    
    See Also:
    
    #findBufferedImageOnScreen(BufferedImage, Rectangle, int)}, DataBuffer, SampleModel, SharedLock, SmallPieceComparator
  - isScreenXYFuzzyMatch
```
public static boolean isScreenXYFuzzyMatch(java.awt.image.DataBuffer sBuffer,
                                           java.awt.image.SampleModel smodel,
                                           int screencenterX,
                                           int screencenterY,
                                           java.awt.image.DataBuffer tBuffer,
                                           java.awt.image.SampleModel tmodel,
                                           int targetX,
                                           int targetY)
```
    This is a time expensive match seeking to match 1 pixel with any one of 8 adjacent pixels.
    
    Parameters:
    
    screenshotBuffer -
    
    screenshot -
    
    screencenterX -
    
    screencenterY -
    
    targetBuffer -
    
    target -
    
    targetX -
    
    targetY -
    
    Returns:
  - findBufferedImageOnScreen
```
public static java.awt.Rectangle findBufferedImageOnScreen(java.awt.image.BufferedImage image)
                                                    throws java.lang.IllegalArgumentException,
                                                           java.awt.image.ImagingOpException,
                                                           java.awt.AWTException
```
    Call the main findBufferedImageOnScreen with null searchRect and nthindex of 1.
    
    Parameters:
    
    image -
    
    Returns:
    
    Throws:
    
    java.lang.IllegalArgumentException
    
    java.awt.image.ImagingOpException
    
    java.awt.AWTException
  - findBufferedImageOnScreen
```
public static java.awt.Rectangle findBufferedImageOnScreen(java.awt.image.BufferedImage image,
                                                           java.awt.Rectangle searchRect)
                                                    throws java.lang.IllegalArgumentException,
                                                           java.awt.image.ImagingOpException,
                                                           java.awt.AWTException
```
    Call the main findBufferedImageOnScreen with searchRect and nthindex of 1.
    
    Parameters:
    
    image -
    
    Returns:
    
    Throws:
    
    java.lang.IllegalArgumentException
    
    java.awt.image.ImagingOpException
    
    java.awt.AWTException
  - outputImageData
```
public static void outputImageData(java.awt.image.BufferedImage image)
                            throws java.io.IOException
```
    Needs Enhancement API subject to change.
    
    Parameters:
    
    image -
    
    Throws:
    
    java.io.IOException
  - splitRecognition
```
public static java.lang.String[] splitRecognition(java.lang.String recognition)
```
    Split the image recognition info at each MOD_SEP to form the String[] recognition needed by most routines.
    
    Parameters:
    
    recognition - String containing all image recognition information.
    
    Returns:
    
    String[] of image recognition modifiers split at the MOD_SEP(;)
    
    Throws:
    
    java.lang.NullPointerException - if String recognition is null.
  - isImageType
```
static boolean isImageType(java.lang.String imagetype,
                           java.lang.String modifier)
```
    See if the recognition string modifier maps to the imagetype passed in. Ex: imagetype MOD_IMAGEW returns true for modifiers MOD_IMAGER, MOD_IMAGERIGHT, MOD_IMAGEW, and MOD_IMAGEWIDTH.
    
    Parameters:
    
    imagetype - MOD_IMAGE, MOD_IMAGEW, MOD_IMAGEH, MOD_IMAGETEXT, MOD_IMAGE_RECT
    
    modifier - actual recognition string modifier
    
    Returns:
    
    true if the modifier maps to the provided imagetype.
  - extractImagePath
```
public static java.lang.String extractImagePath(java.lang.String imagex,
                                                java.lang.String[] recognition)
```
    Attempt to extract the Image=path; portion of an Image-Based Testing recognition string.
    This can also be an ImageRect or SearchRect "path".
    
    Parameters:
    
    imagex - should be either MOD_IMAGE, MOD_IMAGEW, MOD_IMAGEH, MOD_IMAGE_RECT, MODE_SEARCH_RECT
    
    recognition - String [] of recognition modifiers. should not be null;
    
    Returns:
    
    path found or null. path.length() will be > 0 or we will return null.
  - extractImageIndex
```
public static int extractImageIndex(java.lang.String[] recognition)
```
    Extract the Index=N; modifier of an Image-Based Testing recognition string. If user specify Index=Number, we will return the int value of that number; If user specify Index=Any, we will return -1; If we don't specify "Index=N", we will return 0. This is expected to immediately follow the Image= modifier. Or not at all. Adding ImageText= and allow Index=N follow ImageText= modifier.
    
    Parameters:
    
    recognition - String [] of recognition modifiers. should not be null;
    
    Returns:
    
    index found or 0 or -1;
  - extractImageIndex
```
public static int extractImageIndex(java.lang.String imagetype,
                                    java.lang.String[] recognition)
```
    Extract the Index=N; modifier of an Image-Based Testing recognition string. This is the UsePerImageModifiers version. If user specify Index=Number, we will return the int value of that number; If user specify Index=Any, we will return -1; If we don't specify "Index=N", we will return 0. This is expected to immediately follow the imagetype provided.
    
    Parameters:
    
    imagetype - must be MOD_IMAGE, MOD_IMAGEW, MOD_IMAGEH, or MOD_IMAGETEXT
    
    recognition - String [] of recognition modifiers. should not be null;
    
    Returns:
    
    index found or 0 or -1;
  - extractSearchRect
```
public static java.awt.Rectangle extractSearchRect(java.lang.String winimagetype,
                                                   java.lang.String[] recognition)
```
    Attempt to extract the SearchRect=; portion of an Image-Based Testing recognition string. The SearchRect definition is relative to the entire screen. The routine also evaluates whether USE_PER_IMAGE_MODIFIERS is active.
    
    Parameters:
    
    which - type of image is being modified: MOD_IMAGE, MOD_IMAGER, MOD_IMAGEH, MOD_IMAGE_RECT, MOD_IMAGETEXT. can be null to default to ANY instance of SearchRect.
    
    recognition - String [] of recognition modifiers. should not be null;
    
    Returns:
    
    Rectangle found or null. This rectangle is in screen coordinates.
    
    See Also:
    
    USE_PER_IMAGE_MODIFIERS
  - processSearchRectModifier
```
static java.awt.Rectangle processSearchRectModifier(java.lang.String modifier,
                                                    java.awt.Rectangle rectangle,
                                                    boolean isRelative)
```
    Called internally by extractSearchRect
    
    Parameters:
    
    modifier - The value already extracted from ;sr=value;
    
    rectangle - The rectangle to modify
    
    isRelative - true if the modifications are "relative" instead of "absolute".
    
    Returns:
    
    new rectangle or the original rectangle if a problem occurred.
    
    See Also:
    
    extractSearchRect(String, String[], Rectangle)
  - extractSearchRect
```
public static java.awt.Rectangle extractSearchRect(java.lang.String winimagetype,
                                                   java.lang.String[] recognition,
                                                   java.awt.Rectangle relative)
```
    Attempt to extract the SearchRect=; portion of an Image-Based Testing recognition string. The SearchRect values are relative to the specified 'relative' Rectangle. This allows us to find "components" inside "windows" and limit the area inside the "window" for the search. The relative Rectangle is expected to be in screen coordinates.
    
    Parameters:
    
    which - type of image is being modified: MOD_IMAGE, MOD_IMAGER, MOD_IMAGEH, MOD_IMAGE_RECT, MOD_IMAGETEXT if null then MOD_IMAGE is used by default.
    
    recognition - String [] of recognition modifiers. should not be null;
    
    relative - Rectangle. If not null, the SearchRect is considered relative to this Rectangle and not the entire screen.
    
    Returns:
    
    Rectangle found or null. This rectangle is in screen coordinates.
  - extractHotspot
```
public static java.awt.Point extractHotspot(java.lang.String[] recognition)
```
    Attempt to extract the Hotspot=; portion of an Image-Based Testing recognition string. The default hotspot of an image or Rectangle is the center. The Hotspot Point will be relative to the center of the image\rectangle unless PointRelative= is also present in the image recognition (and processed elsewhere).
    
    Parameters:
    
    recognition - String [] of recognition modifiers. should not be null;
    
    Returns:
    
    Point containing relative X and Y values or null if no Hotspot is found.
  - extractPointRelative
```
public static int extractPointRelative(java.lang.String[] recognition)
```
    Extract the PointRelative= info of the recognition string.
    
    Parameters:
    
    recognition - String [] of recognition modifiers. should not be null;
    
    Returns:
    
    INT_TOPLEFT thru INT_BOTTOMRIGHT (1-9) or -1 if not found.
  - resetBitsTolerance
```
public static void resetBitsTolerance()
```
    Resets the class to use the default_percent_bits_tolerance and the default_useBitsTolerance.
    
    See Also:
    
    default_useBitsTolerance, default_percent_bits_tolerance
  - processBitsToleranceModifier
```
static int processBitsToleranceModifier(java.lang.String value)
```
    Called internally from extractBitTolerance.
    
    Parameters:
    
    value - should not be null;
    
    Returns:
  - extractBitsTolerance
```
public static int extractBitsTolerance(java.lang.String[] recognition)
```
    Extract the BitTolerance=N; or BT=N; modifier of an Image-Based Testing recognition string. BitTolerance is optional and may not be present.
    If not present, the routine resets the class to use the default_percent_bits_tolerance and the default_useBitsTolerance. If present and the tolerance is less than 100% then the useBitsTolerance boolean is forced to true, as well. If the tolerance is set to 100% then we expect an exact match and the useBitsTolerance boolean is set to false.
    
    Parameters:
    
    recognition - String [] of recognition modifiers. should not be null;
    
    Returns:
    
    1-100 of extracted bit tolerance or default_percent_bits_tolerance.
  - extractBitsTolerance
```
public static int extractBitsTolerance(java.lang.String imagetype,
                                       java.lang.String[] recognition)
```
    Extract the BitTolerance=N; or BT=N; modifier of an Image-Based Testing recognition string. This is the UsePerImageModifiers version. BitTolerance is optional and may not be present.
    If not present, the routine resets the class to use the default_percent_bits_tolerance and the default_useBitsTolerance. If present and the tolerance is less than 100% then the useBitsTolerance boolean is forced to true, as well. If the tolerance is set to 100% then we expect an exact match and the useBitsTolerance boolean is set to false.
    
    Parameters:
    
    imagetype - should be MOD_IMAGE, MOD_IMAGEW, or MOD_IMAGEH
    
    recognition - String [] of recognition modifiers. should not be null;
    
    Returns:
    
    1-100 of extracted bit tolerance or default_percent_bits_tolerance.
  - calcHotspotPoint
```
public static java.awt.Point calcHotspotPoint(java.awt.Point relativehs,
                                              java.awt.Rectangle area,
                                              int pointrelative)
```
    Parameters:
    
    relative - Point retrieved from extractHotspot. may be null.
    
    area - Rectangle found for image on screen
    
    pointrelative - int value retrieved from extractPointRelative. -1=none or center
    
    Returns:
    
    screen coordinate of hotspot to click or act upon.
  - isImageBasedRecognition
```
public static boolean isImageBasedRecognition(java.lang.String recognition)
```
    Attempt to determine if recognition string is for image-based testing
    
    Parameters:
    
    recognition - -- recognition, usually from App Map
    
    Returns:
    
    true if it contains elements of image-based testing recognition
  - retrieveAbsoluteFileOrDirectory
```
public static java.io.File retrieveAbsoluteFileOrDirectory(TestRecordHelper trd,
                                                           java.lang.String path)
```
    path must not be null or 0-length
    
    Parameters:
    
    TestRecordHelper - containing STAFHelper, AppMapName, WinName, and CompName info returns the absolute path to the file or directory. relative paths seek PROJECTDIR then DATAPOOLDIR to complete the absolute path. Only returns if the File exists. null otherwise.
  - adjustImageBRect
```
protected static java.awt.Rectangle adjustImageBRect(java.awt.image.BufferedImage pic,
                                                     java.awt.Rectangle searchRec)
```
  - findImageLocation
```
public static java.awt.Rectangle findImageLocation(TestRecordHelper trd,
                                                   boolean imageBR,
                                                   java.lang.String imagepath,
                                                   java.awt.Rectangle searchRec,
                                                   int nthindex)
                                            throws java.io.FileNotFoundException,
                                                   java.lang.IllegalArgumentException,
                                                   java.io.IOException,
                                                   java.awt.AWTException,
                                                   java.awt.image.ImagingOpException
```
    Routine to find an image on the screen. Limit the search to the searchRec area of the screen. Look for the nth instance of the image in the searchRec. Use the currently set Bit Tolerance. This routine is called by other routines and is not normally called directly.
    
    Parameters:
    
    TestRecordHelper - containing STAFHelper, AppMapName, WinName, and CompName info
    
    imageBR - -- set true ONLY if the search is for a bottom-right image below a top-right image.
    
    imagepath -
    
    searchRec -
    
    nthindex - -- If it is 0, when USE_MULTIPLE_THREADS is true, SAFS will use multi-thread to search image; when USE_MULTIPLE_THREADS is false, SAFS will use single-thread to search image; If it is -1, SAFS will use multi-thread to search image; If it is >0, SAFS will use single-thread to search image;
    
    Returns:
    
    Rectangle where the image was found or null if not found.
    
    Throws:
    
    java.io.FileNotFoundException - if the specified image file cannot be found
    
    java.lang.IllegalArgumentException - if searchRec is not valid
    
    java.io.IOException - if there is a problem opening or reading files
    
    java.awt.image.ImagingOpException - if ImageIO cannot process the image file
    
    java.awt.AWTException - if there is a problem with the java.awt.Robot
  - modifyLocWidthHeight
```
public static ImageUtils.ModifiedRectInfo modifyLocWidthHeight(TestRecordHelper trd,
                                                               java.awt.Rectangle winloc,
                                                               java.lang.String[] modifiers)
                                                        throws java.io.FileNotFoundException
```
    Attempt to expand the winloc Rectangle based on locating IMAGEW and IMAGEH images specified in the recognition string. These images essentially locate the width and height of a larger area using the initial IMAGE as an top-left anchor point.
    For any given image, first tries to find it by exact match, then tries to find it according to any BitTolerance settings specified in the recognition modifiers.
    
    Parameters:
    
    TestRecordHelper - containing STAFHelper, AppMapName, WinName, and CompName info
    
    winloc - -- Rectangle for the found anchor IMAGE
    
    modifiers - -- String[] split from the winrec
    
    Returns:
    
    winloc modified to expand to any width or height images found, if any.
    
    Throws:
    
    java.io.FileNotFoundException
  - findComponentRectangle
```
public static java.awt.Rectangle findComponentRectangle(TestRecordHelper trd)
                                                 throws java.io.IOException,
                                                        java.awt.AWTException,
                                                        SAFSException
```
    Calls findComponentRectangle with a timeout of 0.
    
    Parameters:
    
    trd -
    
    Returns:
    
    Throws:
    
    java.io.IOException
    
    java.awt.AWTException
    
    SAFSException - findComponentRectangle(TestRecordHelper, long)
  - findComponentRectangle
```
public static java.awt.Rectangle findComponentRectangle(TestRecordHelper trd,
                                                        long timeout)
                                                 throws java.io.IOException,
                                                        java.awt.AWTException,
                                                        SAFSException
```
    Locate the final Window:Component Rectangle specified by the test record. Search for Window first. Then find Component within Window. This is the workhorse routine for component functions to call to deduce the Rectangle targeted by the Window:Comp recognition information.
    For any and all images, we try to find an exact match first, then try to use any BitsTolerance that might be supplied in the recognition strings.
    
    Parameters:
    
    TestRecordHelper - containing STAFHelper, AppMapName, WinName, and CompName info
    
    timeout - in seconds to loop the search until found. <=0 means check only once.
    
    Returns:
    
    Rectangle identifying the area on the screen targetted by the Window:Comp app map recognition strings or null.
    
    Throws:
    
    java.io.IOException - if we cannot open or read specified files
    
    java.awt.AWTException - if we cannot use the java.awt.Robot
    
    SAFSException - if we cannot extract valid data from TestRecordHelper or STAF
  - findCompImageInRectangle
```
static java.awt.Rectangle findCompImageInRectangle(TestRecordHelper trd,
                                                   java.lang.String imagepath,
                                                   int imageindex,
                                                   java.lang.String[] modifiers,
                                                   java.awt.Rectangle rect)
                                            throws java.io.IOException,
                                                   java.awt.AWTException,
                                                   SAFSException
```
    Called by findComponentRectangle. Not normally called otherwise.
    
    Parameters:
    
    imagepath -
    
    imageindex -
    
    modifiers - should not be null
    
    rect - screen area to search.
    
    Returns:
    
    found Image Rectangle or null.
    
    Throws:
    
    java.io.IOException
    
    java.awt.AWTException
    
    SAFSException - findComponentRectangle(TestRecordHelper, long)
  - findImageTextInRectangle
```
static java.awt.Rectangle findImageTextInRectangle(java.lang.String imagetext,
                                                   int imageindex,
                                                   STAFHelper staf,
                                                   java.lang.String[] modifiers,
                                                   java.awt.Rectangle rect)
                                            throws java.io.IOException,
                                                   java.awt.AWTException,
                                                   SAFSException
```
    Called by findComponentRectangle. Not normally called otherwise.
    
    Parameters:
    
    imagetext -
    
    imageindex -
    
    staf -
    
    modifiers - should not be null
    
    rect - area on screen to search
    
    Returns:
    
    found ImageText Rectangle or null.
    
    Throws:
    
    java.io.IOException
    
    java.awt.AWTException
    
    SAFSException - findComponentRectangle(TestRecordHelper, long)
  - saveImageToFile
```
public static void saveImageToFile(java.awt.image.BufferedImage image,
                                   java.io.File file)
                            throws java.lang.SecurityException,
                                   java.lang.IllegalArgumentException,
                                   java.io.IOException,
                                   java.lang.NoClassDefFoundError
```
    Store our BufferedImage into a File.
    
    Parameters:
    
    image - - BufferedImage for ImageIO to write to file
    
    file - -- valid full absolute File to write to
    
    Throws:
    
    java.lang.SecurityException - thrown if permission to write to the location is denied
    
    java.lang.IllegalArgumentException - if ImageIO doesn't like our invocation
    
    java.io.IOException - if an error occurs while writing.
    
    java.lang.NoClassDefFoundError - if support for ImageIO is not found (Java Advanced Imaging)
  - copy
```
public static java.awt.image.BufferedImage copy(java.awt.image.BufferedImage image)
```
    Make a deep copy of original BufferedImage.
    Do NOT copy the Raster.
    But paint the original image on a new BufferedImage of the same size and type, so the
    Raster has the same size as image (will not contain more data with an offset).
    
    Parameters:
    
    bi - BufferedImage, the image to copy.
    
    Returns:
    
    BufferedImage, a deep copy of BufferedImage.
  - copyRaster
```
public static java.awt.image.BufferedImage copyRaster(java.awt.image.BufferedImage bi)
```
    Make a deep copy of original BufferedImage, copy the Raster.
    This method is not very reliable, sometimes it fail.
    
    Parameters:
    
    bi - BufferedImage, the image to copy.
    
    Returns:
    
    BufferedImage, a deep copy of BufferedImage.
  - convertImage
```
public static java.awt.image.BufferedImage convertImage(java.awt.image.BufferedImage image,
                                                        int type)
```
    Convert the BufferedImage to another type of BufferedImage.
    Some types cannot convert to, for example BufferedImage.TYPE_CUSTOM
    
    Parameters:
    
    image - BufferedImage, the image to convert.
    
    type - int, the type to convert to.
    
    Returns:
    
    BufferedImage, the converted image
  - convertToRGBImage
```
public static java.awt.image.BufferedImage convertToRGBImage(java.awt.image.BufferedImage image)
```
    If the image contains alpha value, then remove it and create a new RGB Image.
    
    Parameters:
    
    image - BufferedImage, the image to convert
    
    Returns:
    
    BufferedImage, an RGB image without alpha value.
  - hasAlpha
```
public static boolean hasAlpha(java.awt.Image image)
                        throws java.io.IOException
```
    Parameters:
    
    image - Image, the image to detect
    
    Returns:
    
    boolean, true if the image contains 'alpha' value; false otherwise.
    
    Throws:
    
    java.io.IOException
  - isImageFormatSupported
```
public static boolean isImageFormatSupported(java.lang.String fileName)
```
    Parameters:
    
    fileName -
    
    Returns:
    
    true if the fileName is one of the supported image format
  - normalizeFileNameSuffix
```
public static java.lang.String normalizeFileNameSuffix(java.lang.String filename)
                                                throws SAFSException
```
    Check the suffix of filename, if it is not supported then append '.bmp' as suffix.
    
    Parameters:
    
    filename, - String, the filename to check
    
    Returns:
    
    Throws:
    
    SAFSException
  - getImageFileFilter
```
public static javax.swing.filechooser.FileFilter getImageFileFilter()
```
    Returns:
    
    A FileFilter, which accepts files of format supported in isImageFormatSupported(String) or directories.
  - getVoidBufferImage
```
public static java.awt.image.BufferedImage getVoidBufferImage(int width,
                                                              int height,
                                                              int defaultType,
                                                              int altType)
```
    Purpose Create a new BufferedImage Object with a certain type.
    
    Parameters:
    
    width -
    
    height -
    
    defaultType - The type of the new BufferedImage
    
    altType - If the default type can not be used to create a BufferedImage,
    the altType will be used.
    
    Returns:
  - getCopiedImage
```
public static java.awt.image.BufferedImage getCopiedImage(java.awt.image.BufferedImage srcImage,
                                                          int destWidth,
                                                          int destHeight,
                                                          java.awt.Color initialColor)
```
    Purpose Create a new BufferedImage object, its size is destWidth*destHeight
    If the size is samller than the source image, copy that part from source
    image to this new image; While if the size is bigger, copy the whole source
    image to this new image, and the part beyond will be filled by initialColor
    This method is used when drag to resize an image in ImageManager2
    
    Parameters:
    
    srcImage - BufferedImage, The source image to be copied.
    
    destWidth - int, the destination image width
    
    destHeight - int, the destination image height
    
    initialColor - Color, the color to paint on the destination image as initial color
    
    Returns:
  - getCopiedImage
```
public static java.awt.image.BufferedImage getCopiedImage(java.awt.image.BufferedImage srcImage,
                                                          int srcOffsetX,
                                                          int srcOffsetY,
                                                          int destOffsetX,
                                                          int destOffsetY,
                                                          int destWidth,
                                                          int destHeight,
                                                          java.awt.Color initialColor)
```
    Purpose Copy the source image to a new image, whose width and height are given
    by destWidth and destHeight; The area of new image outside of the source
    image will be filled with the color provided by parameter.
    
    Parameters:
    
    srcImage - BufferedImage, The source image to be copied.
    
    srcOffsetX - int, the x coordination in source image to begin copy
    
    srcOffsetY - int, the y coordination in source image to begin copy
    
    destOffsetX - int, the x coordination in destination image to begin paste
    
    destOffsetY - int, the y coordination in destination image to begin paste
    
    destWidth - int, the destination image width
    
    destHeight - int, the destination image height
    
    initialColor - Color, the color to paint on the destination image as initial color
    
    Returns:
  - paintOnImage
```
public static java.awt.image.BufferedImage paintOnImage(java.awt.image.BufferedImage image,
                                                        int offsetX,
                                                        int offsetY,
                                                        int width,
                                                        int height,
                                                        java.awt.Color initialColor,
                                                        boolean paintOnNewImage)
```
    Purpose Modify the source image by painting a simple color on an area, this
    area is defined by offsetX,offsetY,width,height
    This method is used when cut an area from an image in ImageManager2
    
    Parameters:
    
    image -
    
    offsetX -
    
    offsetY -
    
    width -
    
    height -
    
    initialColor -
    
    paintOnNewImage - false, paint on original image; true, paint on a new buffered image.
  - paintOnImage
```
public static java.awt.image.BufferedImage paintOnImage(java.awt.image.BufferedImage srcImage,
                                                        int srcOffsetX,
                                                        int srcOffsetY,
                                                        int width,
                                                        int height,
                                                        int destOffsetX,
                                                        int destOffsetY,
                                                        java.awt.image.BufferedImage destImage,
                                                        java.awt.Color initialColor,
                                                        boolean paintOnNewImage)
```
    Purpose Get an area from the source image, this area is defined by
    srcOffsetX,srcOffsetY,width,height; Then copy this area to the
    destImage, the point to start to paint is (destOffsetX,destOffsetY)
    If the area is too big, beyond the source image, then the souce image
    will be enlarged, the extra part will be painted with initColor.
    This method is used when copy an image to the panel in ImageManager2
  - blurImage
```
public static java.awt.image.BufferedImage blurImage(java.awt.image.BufferedImage image)
```
  - sharpenImage
```
public static java.awt.image.BufferedImage sharpenImage(java.awt.image.BufferedImage image)
```
  - edgeImage
```
public static java.awt.image.BufferedImage edgeImage(java.awt.image.BufferedImage image)
```
  - negativeImage
```
public static java.awt.image.BufferedImage negativeImage(java.awt.image.BufferedImage image)
```
  - rotateImage
```
public static java.awt.image.BufferedImage rotateImage(java.awt.image.BufferedImage bufferedimage,
                                                       int angle)
```
    Rotate the Image with 90, 180 or 270 degree.
    
    Parameters:
    
    bufferedimage -
    
    angle - int, the angle the image will be rotated, in 360 degree only 90, 180 or 270 degree are supported.
    
    Returns:
  - filterImage
```
public static java.awt.image.BufferedImage filterImage(java.awt.image.BufferedImage image,
                                                       java.awt.image.BufferedImageOp op)
```
    Purpose: Use provided BufferedImageOp to convert image
    
    Parameters:
    
    image -
    
    op -
    
    Returns:
  - filterImage
```
public static java.awt.image.BufferedImage filterImage(java.awt.image.BufferedImage image,
                                                       java.lang.String filteredAreas,
                                                       java.util.List<java.lang.String> warnings)
                                                throws SAFSException
```
    Cover an image by black color on a set of area.
    
    Parameters:
    
    image - BufferedImage, the image to filter.
    
    filteredAreas - String, a set of area delimited by space, such as "0,0,10,10 40;40;5%;5%"
    
    warnings - List, out, a List instance provided to contain the possible warnings during execution.
    
    Returns:
    
    Throws:
    
    SAFSException - passed along from convertAreas(Rectangle, String, List).
  - convertAreas
```
public static java.awt.Rectangle[] convertAreas(java.awt.Rectangle basedRect,
                                                java.lang.String areas,
                                                java.util.List<java.lang.String> warnings)
                                         throws SAFSException
```
    Convert a set of area into an array of Rectangle
    
    Parameters:
    
    basedRect - Rectangle, the based rectangle.
    
    areas - String, a set of area delimited by space, such as "0,0,10,10 40;40;5%;5%"
    
    warnings - List, out, a List instance provided to contain the possible warnings during execution.
    
    Returns:
    
    Throws:
    
    SAFSException - if the basedRect is null or if any of the provided areas are completely outside the bounds of basedRect.
  - normalizeSubAreas
```
public static java.lang.String normalizeSubAreas(java.lang.String areas)
```
    Normalize a subareas string.
    Replace all ";" by ",". Example "40;40;5%;5%" -> "40,40,5%,5%"
    For each area, if there are some space " " in it, remove them. Example "0, 0, 10, 10" -> "0,0,10,10"
    Between areas, if there are multiple space " ", repalce them by one space.
    
    Parameters:
    
    areas - String, a set of area delimited by space, such as "0, 0,10 ,10 40;40;5%; 5%"
    
    Returns:
    
    String, a normalized subareas string
  - saveImageToFile
```
public static void saveImageToFile(java.awt.image.BufferedImage image,
                                   java.io.File file,
                                   float quality)
                            throws SAFSException
```
    Store our BufferedImage into a File; If the format is JPG, the third parameter indicate the compression quality.
    
    Parameters:
    
    image - - BufferedImage for ImageIO to write to file
    
    file - - valid full absolute File to write to
    
    quality - - If the file format is JPG, it indicates the compression quality. It's value should be between 0.0 and 1.0;
    
    Throws:
    
    SAFSException
  - createDiffImage
```
public static java.awt.image.BufferedImage createDiffImage(java.awt.image.BufferedImage buffimg,
                                                           java.awt.image.BufferedImage benchimg,
                                                           ImageUtils.AlterImageStyle style,
                                                           double factor)
                                                    throws java.lang.IllegalArgumentException
```
    With the assumption that the two provided images are NOT matching, we will create a Diff image composite from the two images.
    
    Parameters:
    
    buffimg - BufferedImage,
    
    benchimg - BufferedImage,
    
    style - AlterImageStyle, ImageUtils.AlterImageStyle how to alter the pixel of no difference.
    Normally, the different pixel will be filled with red color, while the same pixel will be written as it is.
    But if the original pixel is red and there is no difference, it will be hard to know if there is a difference at that pixel!
    So user may want to get the original pixel (with no difference) lighter or darker.
    
    factor - double, how much lighter or darker to make the original pixel (with no difference), it is a number between 0 and 1.
    It only takes effect if the parameter 'style' is ImageUtils.AlterImageStyle.TINT or ImageUtils.AlterImageStyle.SHADE.
    For SHADE, the bigger the factor, the darker the shade.
    For TINT, the bigger the factor, the lighter the tint.
    
    Returns:
    
    BufferedImage highlighting the differences between the two images.
    
    Throws:
    
    java.lang.IllegalArgumentException - if either of the images provided is null.
  - createDiffImage
```
public static java.awt.image.BufferedImage createDiffImage(java.awt.image.BufferedImage buffimg,
                                                           java.awt.image.BufferedImage benchimg)
                                                    throws java.lang.IllegalArgumentException
```
    With the assumption that the two provided images are NOT matching, we will create a Diff image composite from the two images.
    
    Parameters:
    
    buffimg - BufferedImage,
    
    benchimg - BufferedImage,
    
    Returns:
    
    BufferedImage highlighting the differences between the two images.
    
    Throws:
    
    java.lang.IllegalArgumentException - if either of the images provided is null.
  - convertPDF
```
public static java.util.List<java.awt.image.BufferedImage> convertPDF(java.io.File pdfFile,
                                                                      int resolution)
                                                               throws SAFSException
```
    Parameters:
    
    pdfFile - File, the PDF file to convert
    
    resolution - int, the resolution used to convert PDF to image.
    
    Returns:
    
    List<BufferedImage>, a list of BufferedImage converted from PDF file
    
    Throws:
    
    SAFSException - if there is any problem during the conversion.
  - toBufferedImage
```
public static java.awt.image.BufferedImage toBufferedImage(java.awt.Image image)
```
    Convert an Image to BufferedImage.
    
    Parameters:
    
    image - Image, the image to convert.
    
    Returns:
    
    BufferedImage the converted BufferedImage.
  - takeScreenshot
```
public static void takeScreenshot(java.lang.String screenShotFile)
```
    Take screen shot and save it to a file.
    
    Parameters:
    
    screenShotFile - String, the full file name to hold the screen shot.
  - main
```
public static void main(java.lang.String[] args)
```

Class ImageUtils

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

debug

MOD_EQ

MOD_COMMA

MOD_SEMICOLON

MOD_SPACE

MOD_PERCENT

MOD_SEP

MOD_IMAGE

MOD_IMAGER

MOD_IMAGERIGHT

MOD_IMAGEW

MOD_IMAGEWIDTH

MOD_IMAGEB

MOD_IMAGEBOTTOM

MOD_IMAGEH

MOD_IMAGEHEIGHT

MOD_INDEX

MOD_IND

MOD_HOTSPOT

MOD_HS

MOD_SEARCHRECT

MOD_SR

MOD_SEARCHMASK

MOD_SM

MOD_POINTRELATIVE

MOD_PR

MOD_INSETS

MOD_INS

MOD_OUTSETS

MOD_OUTS

MOD_BITTOLERANCE

MOD_BT

MOD_TOPLEFT

MOD_TL

INT_TOPLEFT

MOD_TOPCENTER

MOD_TC

INT_TOPCENTER

MOD_TOPRIGHT

MOD_TR

INT_TOPRIGHT

MOD_LEFTCENTER

MOD_LC

INT_LEFTCENTER

MOD_CENTER

MOD_C

INT_CENTER

MOD_RIGHTCENTER

MOD_RC

INT_RIGHTCENTER

MOD_BOTTOMLEFT

MOD_BL

INT_BOTTOMLEFT

MOD_BOTTOMCENTER

MOD_BC

INT_BOTTOMCENTER

MOD_BOTTOMRIGHT

MOD_BR

INT_BOTTOMRIGHT

EXT_JPEG

EXT_JPG

EXT_GIF

EXT_TIFF

EXT_TIF

EXT_PNG

MOD_IMAGETEXT

MOD_IMAGE_RECT

MOD_IMAGE_RECTANGLE

MOD_SEARCH_RECT

MOD_SEARCH_RECTANGLE

toolkit

screenSize

screenRect