JHelpImage

java.lang.Object
- jhelp.util.gui.JHelpImage

All Implemented Interfaces:

ConstantsGUI
```
public class JHelpImage
extends java.lang.Object
implements ConstantsGUI
```
Represents an image.
You can draw on image only this image if it is on draw mode, see startDrawMode(), endDrawMode() and isDrawMode().
You can also create JHelpSprite, that are small image that can be easy animated.
The image is refresh at screen , only if exit of draw mode endDrawMode() or call update()

Author:

JHelp

Field Summary

Fields
Modifier and Type	Field and Description
`private java.util.ArrayList<java.awt.Component>`	`componentsListeners` List of registered components to alert if image update
`private boolean`	`drawMode` Actaul draw mode
`private int`	`height` Image height
`private java.awt.Image`	`image` Image for draw in a swing component
`private java.awt.image.MemoryImageSource`	`memoryImageSource` Image source
`private java.lang.String`	`name` Image name
`private static int[]`	`PALETTE` Palette to use
`static int`	`PALETTE_SIZE` Pallete size
`private int[]`	`pixels` Image pixels
`private java.util.concurrent.locks.ReentrantLock`	`reentrantLock` For synchronize
`private java.util.ArrayList<JHelpSprite>`	`sprites` List of sprite
`private boolean[]`	`visibilities` Last sprite visibility information collected on `startDrawMode()` to resitute sprite in good state when `endDrawMode()` is call
`private int`	`width` Image width

Fields inherited from interface jhelp.util.gui.ConstantsGUI
AFFINE_TRANSFORM, FLATNESS, FONT_RENDER_CONTEXT

Constructor Summary

Constructors
Constructor and Description
`JHelpImage(int width, int height)` Create a new instance of JHelpImage empty
`JHelpImage(int width, int height, int color)` Create a new instance of JHelpImage full of one color
`JHelpImage(int width, int height, int[] pixels)` Create a new instance of JHelpImage

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addition(JHelpImage image)` Add an other image This image and the given one MUST have same dimension Note : if this image or given one not in draw mode, all visible sprites (of the image) are consider like a part of the image
`void`	`applyPalette(int precision)` Fill with the pallete different area MUST be in draw mode
`void`	`brighter(int factor)` Put the image brighter MUST be in draw mode
`void`	`brightness(double factor)` Change image brightness MUST be in draw mode
`void`	`categorizeByColor(int precision)` Colorize all near color with same color MUST be in draw mode
`void`	`categorizeByY(int colorLow, int colorMiddle, int colorHigh, double precision)` Colorize with 3 colors, one used for "dark" colors, one for "gray" colors and last for "white" colors MUST be in draw mode
`(package private) void`	`changeSpriteVisibiliy(int index, boolean visible, boolean forced)` Change a sprite visibility
`void`	`clear(int color)` Fill the entire image with same color MUST be in draw mode
`int`	`colorizeWithPalette(int precision)` Colorize with automatic palette MUST be in draw mode
`private static int`	`computeBlue(double y, double u, double v)` Compute blue part of color from YUV B = Y + 1.7790 * (U - 128)
`private static int`	`computeGreen(double y, double u, double v)` Compute green part of color from YUV G = Y - 0.3455 * (U - 128) - (0.7169 * (V - 128))
`private static int`	`computeRed(double y, double u, double v)` Compute red part of color from YUV R = Y + 1.4075 * (V - 128)
`private static double`	`computeU(int red, int green, int blue)` Compute U of a color U = R * -.168736 + G * -.331264 + B * .500000 + 128
`private static double`	`computeV(int red, int green, int blue)` Compute V of a color V = R * .500000 + G * -.418688 + B * -.081312 + 128
`private static double`	`computeY(int red, int green, int blue)` Compute Y of a color Y = R * .299000 + G * .587000 + B * .114000
`void`	`contrast(double factor)` Change image contrast by using the middle of the minmum and maximum MUST be in draw mode
`void`	`contrastAvreage(double factor)` Change image contrast by using the average of all values MUST be in draw mode
`void`	`copy(JHelpImage image)` Copy the image is this one This image and the given one MUST have same dimension Note : if this image or given one not in draw mode, all visible sprites (of the image) are consider like a part of the image
`Pair<JHelpSprite,JHelpAnimatedImage>`	`createAnimatedSprite(int x, int y, int width, int height, JHelpAnimatedImage.AnimationMode animationMode)` Create a couple of sprite and associated animated image MUSN'T be in draw mode
`static JHelpImage`	`createBumpedImage(JHelpImage source, JHelpImage bump)` Create a bump image with 0.75 contrast, 12 dark, 1 shift X and 1 shift Y Note : If one of image is not in draw mode, all visible sprite (of this image) will be consider as a part of the image
`static JHelpImage`	`createBumpedImage(JHelpImage source, JHelpImage bump, double contrast, int dark, int shiftX, int shiftY)` Create a bump image Note : If one of image is not in draw mode, all visible sprite (of this image) will be consider as a part of the image
`static JHelpImage`	`createBumpedImage2(JHelpImage source, JHelpImage bump)` Create a bump image with 0.75 contrast, 12 dark, -1 shift X and -1 shift Y Note : If one of image is not in draw mode, all visible sprite (of this image) will be consider as a part of the image
`JHelpImage`	`createCopy()` Create an image copy Note : if this image is not in draw mode, al visible sprites will be consider like a part of this image
`static JHelpImage`	`createImage(java.awt.image.BufferedImage bufferedImage)` Create an image from a buffered image
`JHelpSprite`	`createSprite(int x, int y, int width, int height)` Create a sprite MUSN'T be in draw mode
`JHelpSprite`	`createSprite(int x, int y, JHelpImage source)` Create sprite with initial image inside MUSN'T be in draw mode
`static JHelpImage`	`createThumbImage(java.awt.image.BufferedImage bufferedImage, int width, int height)` Create an image resized to specify size from a buffered image
`void`	`darker(int factor)` Make image darker MUST be in draw mode
`void`	`divide(JHelpImage image)` Divide an other image This image and the given one MUST have same dimension Note : if this image or given one not in draw mode, all visible sprites (of the image) are consider like a part of the image
`static boolean`	`doesImagesLookSamePerBorder(JHelpImage image1, JHelpImage image2, int precision, int percentDifferenceAccepted)` Compare 2 images and compute if they "look" the same in compare the image border.
`static boolean`	`doesImagesLookSamePerLuminosity(JHelpImage image1, JHelpImage image2, int precision, int percentDifferenceAccepted)` Compare 2 images and compute if they "look" the same in compare the image luminosity The precision is to determine the accepted distance in luminosity part, and percent to know the percent of accepted pixels doesn't match to precision.
`static boolean`	`doesImagesLookSamePerPixel(JHelpImage image1, JHelpImage image2, int colorPartPrecision, int percentDifferenceAccepted)` Compare 2 images and compute if they "look" the same in compare the image pixels.
`void`	`drawEllipse(int x, int y, int width, int height, int color)` Draw an ellipse MUST be in draw mode
`void`	`drawEllipse(int x, int y, int width, int height, int color, boolean doAlphaMix)` Draw an ellipse MUST be in draw mode
`void`	`drawHorizontalLine(int x1, int x2, int y, int color)` Draw an horizontal line MUST be in draw mode
`void`	`drawHorizontalLine(int x1, int x2, int y, int color, boolean doAlphaMix)` Draw horizontal line MUST be in draw mode
`void`	`drawImage(int x, int y, JHelpImage image)` Draw an image MUST be in draw mode
`void`	`drawImage(int x, int y, JHelpImage image, boolean doAlphaMix)` Draw an image MUST be in draw mode
`void`	`drawImage(int x, int y, JHelpImage image, int alpha)` Draw an image over this image with specific alpha MUST be in draw mode
`void`	`drawImage(int x, int y, JHelpImage image, int xImage, int yImage, int width, int height)` Draw a part off image MUST be in draw mode
`void`	`drawImage(int x, int y, JHelpImage image, int xImage, int yImage, int width, int height, boolean doAlphaMix)` Draw a part off image MUST be in draw mode
`void`	`drawImage(int x, int y, JHelpImage image, int xImage, int yImage, int width, int height, int alpha)` Draw a part of image with a specific alpha MUST be in draw mode
`(package private) void`	`drawImageInternal(int x, int y, JHelpImage image, int xImage, int yImage, int width, int height, boolean doAlphaMix)` Draw a part of an image on this image MUST be in draw mode
`(package private) void`	`drawImageInternal(int x, int y, JHelpImage image, int xImage, int yImage, int width, int height, int alpha)` Draw a part of image on using a specific alpha value MUST be in draw mode
`(package private) void`	`drawImageOver(int x, int y, JHelpImage image, int xImage, int yImage, int width, int height)` Draw apart of image over this image 'just override) MUST be in draw mode
`void`	`drawLine(int x1, int y1, int x2, int y2, int color)` Draw a line MUST be in draw mode
`void`	`drawLine(int x1, int y1, int x2, int y2, int color, boolean doAlphaMix)` Draw a line MUST be in draw mode
`void`	`drawPolygon(int[] xs, int[] ys, int color)` Draw a polygon MUST be in draw mode
`void`	`drawPolygon(int[] xs, int[] ys, int color, boolean doAlphaMix)` Draw a polygon MUST be in draw mode
`void`	`drawPolygon(int[] xs, int offsetX, int[] ys, int offsetY, int length, int color)` Draw a polygon MUST be in draw mode
`void`	`drawPolygon(int[] xs, int offsetX, int[] ys, int offsetY, int length, int color, boolean doAlphaMix)` Draw a polygon MUST be in draw mode
`void`	`drawRectangle(int x, int y, int width, int height, int color)` Draw an empty rectangle MUST be in draw mode
`void`	`drawRectangle(int x, int y, int width, int height, int color, boolean doAlphaMix)` Draw an empty rectangle MUST be in draw mode
`void`	`drawRoundRectangle(int x, int y, int width, int height, int arcWidth, int arcHeight, int color)` Draw round corner rectangle MUST be in draw mode
`void`	`drawRoundRectangle(int x, int y, int width, int height, int arcWidth, int arcHeight, int color, boolean doAlphaMix)` Draw round corner rectangle MUST be in draw mode
`void`	`drawShape(java.awt.Shape shape, int color)` Draw an empty shape MUST be in draw mode
`void`	`drawShape(java.awt.Shape shape, int color, boolean doAlphaMix)` Draw an empty shape MUST be in draw mode
`private void`	`drawShapeCenter(java.awt.Shape shape, int color, boolean doAlphaMix)` Draw a shape on center it MUST be in draw mode
`void`	`drawString(int x, int y, java.lang.String string, JHelpFont font, int color)` Draw a string MUST be in draw mode
`void`	`drawString(int x, int y, java.lang.String string, JHelpFont font, int color, boolean doAlphaMix)` Draw a string MUST be in draw mode
`void`	`drawStringCenter(int x, int y, java.lang.String string, JHelpFont font, int color)` Draw a string center on given point MUST be in draw mode
`void`	`drawStringCenter(int x, int y, java.lang.String string, JHelpFont font, int color, boolean doAlphaMix)` Draw a string center on given point MUST be in draw mode
`void`	`drawVerticalLine(int x, int y1, int y2, int color)` Draw a vertical line MUST be in draw mode
`void`	`drawVerticalLine(int x, int y1, int y2, int color, boolean doAlphaMix)` Draw a vertical line MUST be in draw mode
`void`	`endDrawMode()` Stop the draw mode and refresh the image
`static JHelpImage`	`extractBorder(JHelpImage source)` Extract the border of the objects inside the image.
`static JHelpImage`	`extractBorder(JHelpImage source, int width)` Extract the border of the objects inside the image.
`static JHelpImage`	`extractBorder(JHelpImage source, int width, int step)` Extract the border of the objects inside the image.
`static JHelpImage`	`extractBorder2(JHelpImage source)` Extract the border of the objects inside the image.
`JHelpImage`	`extractSubImage(int x, int y, int width, int height)` Extract a sub image from the image Note : If one of image is not in draw mode, all visible sprite (of this image) will be consider as a part of the image
`void`	`fillEllipse(int x, int y, int width, int height, int color)` Fill an ellipse MUST be in draw mode
`void`	`fillEllipse(int x, int y, int width, int height, int color, boolean doAlphaMix)` Fill an ellipse MUST be in draw mode
`void`	`fillEllipse(int x, int y, int width, int height, JHelpImage texture)` Fill ellipse with a texture Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture MUST be in draw mode
`void`	`fillEllipse(int x, int y, int width, int height, JHelpImage texture, boolean doAlphaMix)` Fill ellipse with a texture Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture MUST be in draw mode
`void`	`fillEllipse(int x, int y, int width, int height, JHelpPaint paint)` Fill an ellipse MUST be in draw mode
`void`	`fillEllipse(int x, int y, int width, int height, JHelpPaint paint, boolean doAlphaMix)` Fill an ellipse MUST be in draw mode
`void`	`fillPolygon(int[] xs, int[] ys, int color)` Fill a polygon MUST be in draw mode
`void`	`fillPolygon(int[] xs, int[] ys, int color, boolean doAlphaMix)` Fill a polygon MUST be in draw mode
`void`	`fillPolygon(int[] xs, int[] ys, JHelpImage texture)` Fill a polygon Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture MUST be in draw mode
`void`	`fillPolygon(int[] xs, int[] ys, JHelpImage texture, boolean doAlphaMix)` Fill a polygon Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture MUST be in draw mode
`void`	`fillPolygon(int[] xs, int[] ys, JHelpPaint paint)` Fill a polygon MUST be in draw mode
`void`	`fillPolygon(int[] xs, int[] ys, JHelpPaint paint, boolean doAlphaMix)` Fill a polygon MUST be in draw mode
`void`	`fillPolygon(int[] xs, int offsetX, int[] ys, int offsetY, int length, int color)` Fill a polygon
`void`	`fillPolygon(int[] xs, int offsetX, int[] ys, int offsetY, int length, int color, boolean doAlphaMix)` Fill a polygon MUST be in draw mode
`void`	`fillPolygon(int[] xs, int offsetX, int[] ys, int offsetY, int length, JHelpImage texture)` Fill a polygon Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture MUST be in draw mode
`void`	`fillPolygon(int[] xs, int offsetX, int[] ys, int offsetY, int length, JHelpImage texture, boolean doAlphaMix)` Fill a polygon Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture MUST be in draw mode
`void`	`fillPolygon(int[] xs, int offsetX, int[] ys, int offsetY, int length, JHelpPaint paint)` Fill a polygon MUST be in draw mode
`void`	`fillPolygon(int[] xs, int offsetX, int[] ys, int offsetY, int length, JHelpPaint paint, boolean doAlphaMix)` Fill a polygon MUST be in draw mode
`void`	`fillRectangle(int x, int y, int width, int height, int color)` Fill a rectangle MUST be in draw mode
`void`	`fillRectangle(int x, int y, int width, int height, int color, boolean doAlphaMix)` Fill a rectangle MUST be in draw mode
`void`	`fillRectangle(int x, int y, int width, int height, JHelpImage texture)` Fill a rectangle Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture MUST be in draw mode
`void`	`fillRectangle(int x, int y, int width, int height, JHelpImage texture, boolean doAlphaMix)` Fill a rectangle Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture MUST be in draw mode
`void`	`fillRectangle(int x, int y, int width, int height, JHelpPaint paint)` Fill a rectangle MUST be in draw mode
`void`	`fillRectangle(int x, int y, int width, int height, JHelpPaint paint, boolean doAlphaMix)` Fill a rectangle MUST be in draw mode
`void`	`fillRectangleScale(int x, int y, int width, int height, JHelpImage texture)` Fill a rectangle with an image.
`void`	`fillRectangleScale(int x, int y, int width, int height, JHelpImage texture, boolean doAlphaMix)` Fill a rectangle with an image.
`void`	`fillRectangleScaleBetter(int x, int y, int width, int height, JHelpImage texture)` Fill a rectangle with an image.
`void`	`fillRectangleScaleBetter(int x, int y, int width, int height, JHelpImage texture, boolean doAlphaMix)` Fill a rectangle with an image.
`void`	`fillRoundRectangle(int x, int y, int width, int height, int arcWidth, int arcHeight, int color)` Fill a round rectangle MUST be in draw mode
`void`	`fillRoundRectangle(int x, int y, int width, int height, int arcWidth, int arcHeight, int color, boolean doAlphaMix)` Fill a round rectangle MUST be in draw mode
`void`	`fillRoundRectangle(int x, int y, int width, int height, int arcWidth, int arcHeight, JHelpImage texture)` Fill a round rectangle Note : if the texture is not in draw mode, all of it's visible sprite will be consider like a part of he texture MUST be in draw mode
`void`	`fillRoundRectangle(int x, int y, int width, int height, int arcWidth, int arcHeight, JHelpImage texture, boolean doAlphaMix)` Fill a round rectangle Note : if the texture is not in draw mode, all of it's visible sprite will be consider like a part of he texture MUST be in draw mode
`void`	`fillRoundRectangle(int x, int y, int width, int height, int arcWidth, int arcHeight, JHelpPaint paint)` Fill a round rectangle MUST be in draw mode
`void`	`fillRoundRectangle(int x, int y, int width, int height, int arcWidth, int arcHeight, JHelpPaint paint, boolean doAlphaMix)` Fill a round rectangle MUST be in draw mode
`void`	`fillShape(java.awt.Shape shape, int color)` Fill a shape MUST be in draw mode
`void`	`fillShape(java.awt.Shape shape, int color, boolean doAlphaMix)` Fill a shape MUST be in draw mode
`void`	`fillShape(java.awt.Shape shape, JHelpImage texture)` Fill a shape Note : if the texture is not in draw mode, all of it's visible sprite will be consider like a part of he texture MUST be in draw mode
`void`	`fillShape(java.awt.Shape shape, JHelpImage texture, boolean doAlphaMix)` Fill a shape Note : if the texture is not in draw mode, all of it's visible sprite will be consider like a part of he texture MUST be in draw mode
`void`	`fillShape(java.awt.Shape shape, JHelpPaint paint)` Fill a shape MUST be in draw mode
`void`	`fillShape(java.awt.Shape shape, JHelpPaint paint, boolean doAlphaMix)` Fill a shape MUST be in draw mode
`void`	`fillString(int x, int y, java.lang.String string, JHelpFont font, int color)` Fill a string MUST be in draw mode
`void`	`fillString(int x, int y, java.lang.String string, JHelpFont font, int color, boolean doAlphaMix)` Fill a string MUST be in draw mode
`void`	`fillString(int x, int y, java.lang.String string, JHelpFont font, JHelpImage texture, int color)` Fill a string Note : if the texture is not in draw mode, all of it's visible sprite will be consider like a part of he texture MUST be in draw mode
`void`	`fillString(int x, int y, java.lang.String string, JHelpFont font, JHelpImage texture, int color, boolean doAlphaMix)` Fill a string Note : if the texture is not in draw mode, all of it's visible sprite will be consider like a part of he texture MUST be in draw mode
`void`	`fillString(int x, int y, java.lang.String string, JHelpFont font, JHelpPaint paint, int color)` Fill a string MUST be on draw mode
`void`	`fillString(int x, int y, java.lang.String string, JHelpFont font, JHelpPaint paint, int color, boolean doAlphaMix)` Fill a string MUST be on draw mode
`void`	`filterBlue()` Filter image on blue channel MUST be on draw mode
`void`	`filterGreen()` Filter image on green channel MUST be on draw mode
`void`	`filterOn(int color, int colorOK, int colorKO)` Filter image on a specific color MUST be on draw mode
`void`	`filterOn(int color, int precision, int colorOK, int colorKO)` filter image on a specific color MUST be on draw mode
`void`	`filterPalette(int index, int colorOK, int colorKO)` Filter on using a palette color MUST be on draw mode
`void`	`filterRed()` Filter image on red channel MUST be on draw mode
`void`	`filterU()` Filter image on U part MUST be on draw mode
`void`	`filterV()` Filter image on V part MUST be on draw mode
`void`	`filterY()` Filter image on Y part MUST be on draw mode
`protected void`	`finalize()` Call by garbage collector to free some memory Parent documentation:
`void`	`flipBoth()` Flip the image horizontally and vertically in same time.
`void`	`flipHorizontal()` Flip the image horizontally MUST be on draw mode
`void`	`flipVertical()` Flip the image vertically MUST be on draw mode
`int`	`getHeight()` Image height
`java.awt.Image`	`getImage()` Image for draw in graphics environment
`java.lang.String`	`getName()` Image name
`int`	`getWidth()` Image width
`void`	`gray()` Convert image in gray version MUST be on draw mode
`void`	`grayInvert()` Convert image in gray invert version MUST be on draw mode
`void`	`invertColors()` Invert image colors MUST be on draw mode
`void`	`invertUV()` Invert U and V parts MUST be on draw mode
`boolean`	`isDrawMode()` Indicates if we are in draw mode
`private static java.awt.image.BufferedImage`	`loadBufferedImage(java.io.File image)` Load a buffered image
`static JHelpImage`	`loadImage(java.io.File image)` Load an image from file
`static JHelpImage`	`loadImage(java.io.InputStream inputStream)` Load an image from a stream
`static JHelpImage`	`loadImageThumb(java.io.File image, int width, int height)` Load an image and resize it to have specific dimension
`static JHelpImage`	`loadImageThumb(java.io.InputStream inputStream, int width, int height)` Load an image and resize it to have specific dimension
`void`	`maximum(JHelpImage image)` Take the maximum between this image and given one Note : if the given image is not in draw mode, all of it's visible sprite will be consider like a part of the given image Given image MUST have same dimension of this MUST be in draw mode
`void`	`middle(JHelpImage image)` Take the middle between this image and given one Note : if the given image is not in draw mode, all of it's visible sprite will be consider like a part of the given image Given image MUST have same dimension of this MUST be in draw mode
`void`	`minimum(JHelpImage image)` Take the minimum between this image and given one Note : if the given image is not in draw mode, all of it's visible sprite will be consider like a part of the given image Given image MUST have same dimension of this MUST be in draw mode
`void`	`multiply(JHelpImage image)` Multiply the image with an other one Note : if the given image is not in draw mode, all of it's visible sprite will be consider like a part of the given image Given image MUST have same dimension of this MUST be in draw mode
`void`	`paintMask(int x, int y, JHelpMask mask, int foreground, int background, boolean doAlphaMix)` Paint a mask MUST be in draw mode
`void`	`paintMask(int x, int y, JHelpMask mask, int foreground, JHelpImage background, int backgroundX, int backgroundY, boolean doAlphaMix)` Paint a mask with unify foreground color and part of image in background Note : if the background is not in draw mode, all of it's visible sprite will be consider like a part of the background MUST be in draw mode
`void`	`paintMask(int x, int y, JHelpMask mask, int foreground, JHelpPaint background, boolean doAlphaMix)` Paint a mask with unify color as foreground and paint as background MUST be in draw mode
`void`	`paintMask(int x, int y, JHelpMask mask, JHelpImage foreground, int foregroundX, int foregroundY, int background, boolean doAlphaMix)` Paint a mask with part of image as foreground and unify color as background Note : if the foreground is not in draw mode, all of it's visible sprite will be consider like a part of the foreground MUST be in draw mode
`void`	`paintMask(int x, int y, JHelpMask mask, JHelpImage foreground, int foregroundX, int foregroundY, JHelpImage background, int backgroundX, int backgroundY, boolean doAlphaMix)` Paint a mask with 2 images, one for "foreground" pixels, one for "background" ones Note : if the foreground or background is not in draw mode, all of it's visible sprite will be consider like a part of the foreground or background MUST be in draw mode
`void`	`paintMask(int x, int y, JHelpMask mask, JHelpImage foreground, int foregroundX, int foregroundY, JHelpPaint background, boolean doAlphaMix)` Paint a mask with image in foreground and paint in background Note : if the foreground is not in draw mode, all of it's visible sprite will be consider like a part of the foreground MUST be in draw mode
`void`	`paintMask(int x, int y, JHelpMask mask, JHelpPaint foreground, int background, boolean doAlphaMix)` Paint mask with paint in foreground and color in background MUST be in draw mode
`void`	`paintMask(int x, int y, JHelpMask mask, JHelpPaint foreground, JHelpImage background, int backgroundX, int backgroundY, boolean doAlphaMix)` Paint a mask with paint in foreground and image in background Note : if the background is not in draw mode, all of it's visible sprite will be consider like a part of the background MUST be in draw mode
`void`	`paintMask(int x, int y, JHelpMask mask, JHelpPaint foreground, JHelpPaint background, boolean doAlphaMix)` Paint mask with paint in foreground and background MUST be in draw mode
`int`	`pickColor(int x, int y)` Pick a color inside the image Note : if the image is not in draw mode, all visible sprite are consider as a part of image, so may obtain a sprite pixel
`(package private) void`	`refresh()` Refresh the image
`void`	`register(java.awt.Component component)` Register a component to update on image change
`void`	`removeSprite(JHelpSprite sprite)` Remove a sprite from linked sprites.
`void`	`replaceColor(int colorToReplace, int newColor, int near)` Replace all pixels near a color by an other color MUST be in draw mode
`JHelpImage`	`rotate180()` Compute the image rotated from 180 degree If the image is not in draw mode, visible sprites are consider like a part of image
`JHelpImage`	`rotate270()` Compute the image rotated from 270 degree If the image is not in draw mode, visible sprites are consider like a part of image
`JHelpImage`	`rotate90()` Compute the image rotated from 90 degree If the image is not in draw mode, visible sprites are consider like a part of image
`JHelpImage`	`rotatedPart180(int x, int y, int width, int height)` Extract a sub image and then rotate it from 180 degree If the image is not in draw mode, visible sprites are consider like a part of image
`JHelpImage`	`rotatedPart270(int x, int y, int width, int height)` Extract a sub image and then rotate it from 270 degree If the image is not in draw mode, visible sprites are consider like a part of image
`JHelpImage`	`rotatedPart90(int x, int y, int width, int height)` Extract a sub image and then rotate it from 90 degree If the image is not in draw mode, visible sprites are consider like a part of image
`static void`	`saveImage(java.io.OutputStream outputStream, JHelpImage image)` Save an image to a stream Note : If the image is not in draw mode, all visible sprite will be consider as a part of the image
`void`	`setName(java.lang.String name)` Change image name
`void`	`shift(int x, int y)` Shift (translate) the image MUST be in draw mode
`void`	`startDrawMode()` Start the draw mode
`void`	`subtract(JHelpImage image)` Subtract the image by an other one Note : if the given image is not in draw mode, all of it's visible sprite will be consider like a part of the given image Given image MUST have same dimension of this MUST be in draw mode
`void`	`transfertSpritesTo(JHelpImage image)` Give all sprites of this image to an other image
`void`	`unregister(java.awt.Component component)` Unregister a component
`void`	`update()` Update the image, to see last changes

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

- Field Detail
  - PALETTE
```
private static final int[] PALETTE
```
    Palette to use
  - PALETTE_SIZE
```
public static final int PALETTE_SIZE
```
    Pallete size
  - componentsListeners
```
private java.util.ArrayList<java.awt.Component> componentsListeners
```
    List of registered components to alert if image update
  - drawMode
```
private boolean drawMode
```
    Actaul draw mode
  - height
```
private final int height
```
    Image height
  - image
```
private java.awt.Image image
```
    Image for draw in a swing component
  - memoryImageSource
```
private java.awt.image.MemoryImageSource memoryImageSource
```
    Image source
  - name
```
private java.lang.String name
```
    Image name
  - pixels
```
private int[] pixels
```
    Image pixels
  - reentrantLock
```
private final java.util.concurrent.locks.ReentrantLock reentrantLock
```
    For synchronize
  - sprites
```
private java.util.ArrayList<JHelpSprite> sprites
```
    List of sprite
  - visibilities
```
private boolean[] visibilities
```
    Last sprite visibility information collected on startDrawMode() to resitute sprite in good state when endDrawMode() is call
  - width
```
private final int width
```
    Image width
- Constructor Detail
  - JHelpImage
```
public JHelpImage(int width,
          int height)
```
    Create a new instance of JHelpImage empty
    
    Parameters:
    width - Width
    height - Height
  - JHelpImage
```
public JHelpImage(int width,
          int height,
          int color)
```
    Create a new instance of JHelpImage full of one color
    
    Parameters:
    width - Width
    height - Height
    color - Background color to use
  - JHelpImage
```
public JHelpImage(int width,
          int height,
          int[] pixels)
```
    Create a new instance of JHelpImage
    
    Parameters:
    width - Width
    height - Height
    pixels - Image pixels
- Method Detail
  - computeBlue
```
private static int computeBlue(double y,
              double u,
              double v)
```
    Compute blue part of color from YUV
    B = Y + 1.7790 * (U - 128)
    
    Parameters:
    y - Y
    u - U
    v - V
    
    Returns:
    Blue part
  - computeGreen
```
private static int computeGreen(double y,
               double u,
               double v)
```
    Compute green part of color from YUV
    G = Y - 0.3455 * (U - 128) - (0.7169 * (V - 128))
    
    Parameters:
    y - Y
    u - U
    v - V
    
    Returns:
    Green part
  - computeRed
```
private static int computeRed(double y,
             double u,
             double v)
```
    Compute red part of color from YUV
    R = Y + 1.4075 * (V - 128)
    
    Parameters:
    y - Y
    u - U
    v - V
    
    Returns:
    Red part
  - computeU
```
private static double computeU(int red,
              int green,
              int blue)
```
    Compute U of a color
    U = R * -.168736 + G * -.331264 + B * .500000 + 128
    
    Parameters:
    red - Red part
    green - Green part
    blue - Blue part
    
    Returns:
    U
  - computeV
```
private static double computeV(int red,
              int green,
              int blue)
```
    Compute V of a color
    V = R * .500000 + G * -.418688 + B * -.081312 + 128
    
    Parameters:
    red - Red part
    green - Green part
    blue - Blue part
    
    Returns:
    V
  - computeY
```
private static double computeY(int red,
              int green,
              int blue)
```
    Compute Y of a color
    Y = R * .299000 + G * .587000 + B * .114000
    
    Parameters:
    red - Red part
    green - Green part
    blue - Blue part
    
    Returns:
    Y
  - loadBufferedImage
```
private static java.awt.image.BufferedImage loadBufferedImage(java.io.File image)
                                                       throws java.io.IOException
```
    Load a buffered image
    
    Parameters:
    image - Image file
    
    Returns:
    Buffered image loaded
    
    Throws:
    
    java.io.IOException - On reading file issue
  - createBumpedImage
```
public static JHelpImage createBumpedImage(JHelpImage source,
                           JHelpImage bump)
```
    Create a bump image with 0.75 contrast, 12 dark, 1 shift X and 1 shift Y
    Note : If one of image is not in draw mode, all visible sprite (of this image) will be consider as a part of the image
    
    Parameters:
    source - Image source
    bump - Image used for bump
    
    Returns:
    Bumped image
  - createBumpedImage
```
public static JHelpImage createBumpedImage(JHelpImage source,
                           JHelpImage bump,
                           double contrast,
                           int dark,
                           int shiftX,
                           int shiftY)
```
    Create a bump image
    Note : If one of image is not in draw mode, all visible sprite (of this image) will be consider as a part of the image
    
    Parameters:
    source - Image source
    bump - Image used for bump
    contrast - Contrast to use in [0, 1].
    dark - Dark to use. in [0, 255].
    shiftX - Shift X [-3, 3].
    shiftY - Shift Y [-3, 3].
    
    Returns:
    Bumped image
  - createBumpedImage2
```
public static JHelpImage createBumpedImage2(JHelpImage source,
                            JHelpImage bump)
```
    Create a bump image with 0.75 contrast, 12 dark, -1 shift X and -1 shift Y
    Note : If one of image is not in draw mode, all visible sprite (of this image) will be consider as a part of the image
    
    Parameters:
    source - Image source
    bump - Image used for bump
    
    Returns:
    Bumped image
  - createImage
```
public static JHelpImage createImage(java.awt.image.BufferedImage bufferedImage)
```
    Create an image from a buffered image
    
    Parameters:
    bufferedImage - Buffered image source
    
    Returns:
    Created image
  - createThumbImage
```
public static JHelpImage createThumbImage(java.awt.image.BufferedImage bufferedImage,
                          int width,
                          int height)
```
    Create an image resized to specify size from a buffered image
    
    Parameters:
    bufferedImage - Buffered image source
    width - Result image width
    height - Result image height
    
    Returns:
    Created image
  - doesImagesLookSamePerBorder
```
public static boolean doesImagesLookSamePerBorder(JHelpImage image1,
                                  JHelpImage image2,
                                  int precision,
                                  int percentDifferenceAccepted)
```
    Compare 2 images and compute if they "look" the same in compare the image border. That is to say if we obtain border of objects inside the image
    The precision is to determine the accepted distance in border limit, and percent to know the percent of accepted pixels doesn't match to precision.
    Note : if images have'nt same dimension, the smallest is firstly scale to fit to the biggest
    Note : if one image is not in draw mode, the visible sprites of this image will be consider like a part of the image
    
    Parameters:
    image1 - First image
    image2 - Second image
    precision - Difference accepted in border limit
    percentDifferenceAccepted - Percent of accepted different pixels (Pixels doesn't match to the precision)
    
    Returns:
    true if images "look" the same
  - doesImagesLookSamePerLuminosity
```
public static boolean doesImagesLookSamePerLuminosity(JHelpImage image1,
                                      JHelpImage image2,
                                      int precision,
                                      int percentDifferenceAccepted)
```
    Compare 2 images and compute if they "look" the same in compare the image luminosity
    The precision is to determine the accepted distance in luminosity part, and percent to know the percent of accepted pixels doesn't match to precision.
    Note : if images have'nt same dimension, the smallest is firstly scale to fit to the biggest
    Note : if one image is not in draw mode, the visible sprites of this image will be consider like a part of the image
    
    Parameters:
    image1 - First image
    image2 - Second image
    precision - Difference accepted in luminosity
    percentDifferenceAccepted - Percent of accepted different pixels (Pixels doesn't match to the precision)
    
    Returns:
    true if images "look" the same
  - doesImagesLookSamePerPixel
```
public static boolean doesImagesLookSamePerPixel(JHelpImage image1,
                                 JHelpImage image2,
                                 int colorPartPrecision,
                                 int percentDifferenceAccepted)
```
    Compare 2 images and compute if they "look" the same in compare the image pixels.
    The precision is to determine the accepted distance in alpha, red, green and blue part, and percent to know the percent of accepted pixels doesn't match to precision.
    Note : if images have'nt same dimension, the smallest is firstly scale to fit to the biggest
    Note : if one image is not in draw mode, the visible sprites of this image will be consider like a part of the image
    
    Parameters:
    image1 - First image
    image2 - Second image
    colorPartPrecision - Difference accepted in pixel parts
    percentDifferenceAccepted - Percent of accepted different pixels (Pixels doesn't match to the precision)
    
    Returns:
    true if images "look" the same
  - extractBorder
```
public static JHelpImage extractBorder(JHelpImage source)
```
    Extract the border of the objects inside the image. Width 1, step 1
    Note : If the image is not in draw mode, all visible sprite will be consider as a part of the image
    
    Parameters:
    source - Image source
    
    Returns:
    Image border
  - extractBorder
```
public static JHelpImage extractBorder(JHelpImage source,
                       int width)
```
    Extract the border of the objects inside the image. Step 1
    Note : If the image is not in draw mode, all visible sprite will be consider as a part of the image
    
    Parameters:
    source - Image source
    width - Line width
    
    Returns:
    Image border
  - extractBorder
```
public static JHelpImage extractBorder(JHelpImage source,
                       int width,
                       int step)
```
    Extract the border of the objects inside the image.
    Note : If the image is not in draw mode, all visible sprite will be consider as a part of the image
    
    Parameters:
    source - Image source
    width - Line width
    step - Step to jump between width : [1, width]
    
    Returns:
    Image border
  - extractBorder2
```
public static JHelpImage extractBorder2(JHelpImage source)
```
    Extract the border of the objects inside the image. Width 2, step 1
    Note : If the image is not in draw mode, all visible sprite will be consider as a part of the image
    
    Parameters:
    source - Image source
    
    Returns:
    Image border
  - loadImage
```
public static JHelpImage loadImage(java.io.File image)
                            throws java.io.IOException
```
    Load an image from file
    
    Parameters:
    image - Image file
    
    Returns:
    Loaded image
    
    Throws:
    
    java.io.IOException - On file reading issue
  - loadImage
```
public static JHelpImage loadImage(java.io.InputStream inputStream)
                            throws java.io.IOException
```
    Load an image from a stream
    
    Parameters:
    inputStream - Stream to read
    
    Returns:
    Read image
    
    Throws:
    
    java.io.IOException - On reading issue
  - loadImageThumb
```
public static JHelpImage loadImageThumb(java.io.File image,
                        int width,
                        int height)
                                 throws java.io.IOException
```
    Load an image and resize it to have specific dimension
    
    Parameters:
    image - Image file
    width - Final width
    height - Final height
    
    Returns:
    Loaded image resized to corresponds to specified dimension
    
    Throws:
    
    java.io.IOException - On reading file issue
  - loadImageThumb
```
public static JHelpImage loadImageThumb(java.io.InputStream inputStream,
                        int width,
                        int height)
                                 throws java.io.IOException
```
    Load an image and resize it to have specific dimension
    
    Parameters:
    inputStream - Stream where lies the image
    width - Final width
    height - Final height
    
    Returns:
    Loaded image resized to corresponds to specified dimension
    
    Throws:
    
    java.io.IOException - On reading stream issue
  - saveImage
```
public static void saveImage(java.io.OutputStream outputStream,
             JHelpImage image)
                      throws java.io.IOException
```
    Save an image to a stream
    Note : If the image is not in draw mode, all visible sprite will be consider as a part of the image
    
    Parameters:
    outputStream - Stream where write
    image - Image to save
    
    Throws:
    
    java.io.IOException - On writing issue
  - drawShapeCenter
```
private void drawShapeCenter(java.awt.Shape shape,
                   int color,
                   boolean doAlphaMix)
```
    Draw a shape on center it
    MUST be in draw mode
    
    Parameters:
    shape - Shape to draw
    color - Color to use
    doAlphaMix - Indicates if alpha mix is on
  - changeSpriteVisibiliy
```
void changeSpriteVisibiliy(int index,
                         boolean visible,
                         boolean forced)
```
    Change a sprite visibility
    
    Parameters:
    index - Sprite index
    visible - New visibility state
    forced - Indicated that the changes is forced
  - drawImageInternal
```
void drawImageInternal(int x,
                     int y,
                     JHelpImage image,
                     int xImage,
                     int yImage,
                     int width,
                     int height,
                     boolean doAlphaMix)
```
    Draw a part of an image on this image
    MUST be in draw mode
    
    Parameters:
    x - X on this image
    y - Y on this image
    image - Image to draw
    xImage - X on given image
    yImage - Y on given image
    width - Part width
    height - Part height
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - drawImageInternal
```
void drawImageInternal(int x,
                     int y,
                     JHelpImage image,
                     int xImage,
                     int yImage,
                     int width,
                     int height,
                     int alpha)
```
    Draw a part of image on using a specific alpha value
    MUST be in draw mode
    
    Parameters:
    x - X to draw image
    y - Y to draw image
    image - Image to draw
    xImage - Start X of image part
    yImage - Start Y of image part
    width - Width of image part
    height - Height of image part
    alpha - Alpha to use
  - drawImageOver
```
void drawImageOver(int x,
                 int y,
                 JHelpImage image,
                 int xImage,
                 int yImage,
                 int width,
                 int height)
```
    Draw apart of image over this image 'just override)
    MUST be in draw mode
    
    Parameters:
    x - X on this image
    y - Y on this image
    image - Image to draw
    xImage - X on image
    yImage - Y on image
    width - Part width
    height - Part height
  - refresh
```
void refresh()
```
    Refresh the image
  - finalize
```
protected void finalize()
                 throws java.lang.Throwable
```
    Call by garbage collector to free some memory
    
    Parent documentation:
    
    Overrides:
    
    finalize in class java.lang.Object
    
    Throws:
    
    java.lang.Throwable - On issue
    See Also:
    Object.finalize()
  - addition
```
public void addition(JHelpImage image)
```
    Add an other image
    This image and the given one MUST have same dimension
    Note : if this image or given one not in draw mode, all visible sprites (of the image) are consider like a part of the image
    
    Parameters:
    image - Image to add
  - applyPalette
```
public void applyPalette(int precision)
```
    Fill with the pallete different area
    MUST be in draw mode
    
    Parameters:
    precision - Precision to use for distinguish 2 area
  - brighter
```
public void brighter(int factor)
```
    Put the image brighter
    MUST be in draw mode
    
    Parameters:
    factor - Factor of bright
  - brightness
```
public void brightness(double factor)
```
    Change image brightness
    MUST be in draw mode
    
    Parameters:
    factor - Brightness factor
  - categorizeByColor
```
public void categorizeByColor(int precision)
```
    Colorize all near color with same color
    MUST be in draw mode
    
    Parameters:
    precision - Precision to use
  - categorizeByY
```
public void categorizeByY(int colorLow,
                 int colorMiddle,
                 int colorHigh,
                 double precision)
```
    Colorize with 3 colors, one used for "dark" colors, one for "gray" colors and last for "white" colors
    MUST be in draw mode
    
    Parameters:
    colorLow - Color for dark
    colorMiddle - Color for gray
    colorHigh - Color for whte
    precision - Precision for decide witch are gray
  - clear
```
public void clear(int color)
```
    Fill the entire image with same color
    MUST be in draw mode
    
    Parameters:
    color - Color to use
  - colorizeWithPalette
```
public int colorizeWithPalette(int precision)
```
    Colorize with automatic palette
    MUST be in draw mode
    
    Parameters:
    precision - Precision to use
    
    Returns:
    Number of different color
  - contrast
```
public void contrast(double factor)
```
    Change image contrast by using the middle of the minmum and maximum
    MUST be in draw mode
    
    Parameters:
    factor - Factor to apply to the contrast
  - contrastAvreage
```
public void contrastAvreage(double factor)
```
    Change image contrast by using the average of all values
    MUST be in draw mode
    
    Parameters:
    factor - Factor to apply to the contrast
  - copy
```
public void copy(JHelpImage image)
```
    Copy the image is this one
    This image and the given one MUST have same dimension
    Note : if this image or given one not in draw mode, all visible sprites (of the image) are consider like a part of the image
    
    Parameters:
    image - Image to copy
  - createAnimatedSprite
```
public Pair<JHelpSprite,JHelpAnimatedImage> createAnimatedSprite(int x,
                                                        int y,
                                                        int width,
                                                        int height,
                                                        JHelpAnimatedImage.AnimationMode animationMode)
```
    Create a couple of sprite and associated animated image
    MUSN'T be in draw mode
    
    Parameters:
    x - X position
    y - Y position
    width - Sprite width
    height - Sprite height
    animationMode - Animation mode to use
    
    Returns:
    Created couple
  - createCopy
```
public JHelpImage createCopy()
```
    Create an image copy
    Note : if this image is not in draw mode, al visible sprites will be consider like a part of this image
    
    Returns:
    The copy
  - createSprite
```
public JHelpSprite createSprite(int x,
                       int y,
                       int width,
                       int height)
```
    Create a sprite
    MUSN'T be in draw mode
    
    Parameters:
    x - Start X of sprite
    y - Start Y of sprite
    width - Sprite width
    height - Sprite height
    
    Returns:
    Created sprite
  - createSprite
```
public JHelpSprite createSprite(int x,
                       int y,
                       JHelpImage source)
```
    Create sprite with initial image inside
    MUSN'T be in draw mode
    
    Parameters:
    x - X
    y - Y
    source - Initial image
    
    Returns:
    Created sprite
  - darker
```
public void darker(int factor)
```
    Make image darker
    MUST be in draw mode
    
    Parameters:
    factor - Darker factor in [0, 255]
  - divide
```
public void divide(JHelpImage image)
```
    Divide an other image
    This image and the given one MUST have same dimension
    Note : if this image or given one not in draw mode, all visible sprites (of the image) are consider like a part of the image
    
    Parameters:
    image - Image to divide with
  - drawEllipse
```
public void drawEllipse(int x,
               int y,
               int width,
               int height,
               int color)
```
    Draw an ellipse
    MUST be in draw mode
    
    Parameters:
    x - X of upper left corner
    y - Y of upper left corner
    width - Width
    height - Height
    color - Color to use
  - drawEllipse
```
public void drawEllipse(int x,
               int y,
               int width,
               int height,
               int color,
               boolean doAlphaMix)
```
    Draw an ellipse
    MUST be in draw mode
    
    Parameters:
    x - X of upper left corner
    y - Y of upper left corner
    width - Width
    height - Height
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - drawHorizontalLine
```
public void drawHorizontalLine(int x1,
                      int x2,
                      int y,
                      int color)
```
    Draw an horizontal line
    MUST be in draw mode
    
    Parameters:
    x1 - Start X
    x2 - End X
    y - Y
    color - Color to use
  - drawHorizontalLine
```
public void drawHorizontalLine(int x1,
                      int x2,
                      int y,
                      int color,
                      boolean doAlphaMix)
```
    Draw horizontal line
    MUST be in draw mode
    
    Parameters:
    x1 - X start
    x2 - End X
    y - Y
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - drawImage
```
public void drawImage(int x,
             int y,
             JHelpImage image)
```
    Draw an image
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    image - image to draw
  - drawImage
```
public void drawImage(int x,
             int y,
             JHelpImage image,
             boolean doAlphaMix)
```
    Draw an image
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    image - Image to draw
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - drawImage
```
public void drawImage(int x,
             int y,
             JHelpImage image,
             int alpha)
```
    Draw an image over this image with specific alpha
    MUST be in draw mode
    
    Parameters:
    x - X position
    y - Y position
    image - Image to draw
    alpha - Alpha to use
  - drawImage
```
public void drawImage(int x,
             int y,
             JHelpImage image,
             int xImage,
             int yImage,
             int width,
             int height)
```
    Draw a part off image
    MUST be in draw mode
    
    Parameters:
    x - X on this
    y - Y on this
    image - Image to draw
    xImage - X on image
    yImage - Y on image
    width - Part width
    height - Part height
  - drawImage
```
public void drawImage(int x,
             int y,
             JHelpImage image,
             int xImage,
             int yImage,
             int width,
             int height,
             boolean doAlphaMix)
```
    Draw a part off image
    MUST be in draw mode
    
    Parameters:
    x - X on this
    y - Y on this
    image - Image to draw
    xImage - X on image
    yImage - Y on image
    width - Part width
    height - Part height
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - drawImage
```
public void drawImage(int x,
             int y,
             JHelpImage image,
             int xImage,
             int yImage,
             int width,
             int height,
             int alpha)
```
    Draw a part of image with a specific alpha
    MUST be in draw mode
    
    Parameters:
    x - X position
    y - Y position
    image - Image to draw
    xImage - X of image part
    yImage - Y of image part
    width - Image part width
    height - Image part height
    alpha - Alpha to use
  - drawLine
```
public void drawLine(int x1,
            int y1,
            int x2,
            int y2,
            int color)
```
    Draw a line
    MUST be in draw mode
    
    Parameters:
    x1 - X of first point
    y1 - Y first point
    x2 - X second point
    y2 - Y second point
    color - Color to use
  - drawLine
```
public void drawLine(int x1,
            int y1,
            int x2,
            int y2,
            int color,
            boolean doAlphaMix)
```
    Draw a line
    MUST be in draw mode
    
    Parameters:
    x1 - X of first point
    y1 - Y first point
    x2 - X second point
    y2 - Y second point
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - drawPolygon
```
public void drawPolygon(int[] xs,
               int offsetX,
               int[] ys,
               int offsetY,
               int length,
               int color)
```
    Draw a polygon
    MUST be in draw mode
    
    Parameters:
    xs - Polygon X list
    offsetX - Where start read the X list
    ys - Polygon Y list
    offsetY - Where start read the Y list
    length - Number of point
    color - Color to use
  - drawPolygon
```
public void drawPolygon(int[] xs,
               int offsetX,
               int[] ys,
               int offsetY,
               int length,
               int color,
               boolean doAlphaMix)
```
    Draw a polygon
    MUST be in draw mode
    
    Parameters:
    xs - Polygon X list
    offsetX - Where start read the X list
    ys - Polygon Y list
    offsetY - Where start read the Y list
    length - Number of point
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - drawPolygon
```
public void drawPolygon(int[] xs,
               int[] ys,
               int color)
```
    Draw a polygon
    MUST be in draw mode
    
    Parameters:
    xs - X list
    ys - Y list
    color - Color to use
  - drawPolygon
```
public void drawPolygon(int[] xs,
               int[] ys,
               int color,
               boolean doAlphaMix)
```
    Draw a polygon
    MUST be in draw mode
    
    Parameters:
    xs - X list
    ys - Y list
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - drawRectangle
```
public void drawRectangle(int x,
                 int y,
                 int width,
                 int height,
                 int color)
```
    Draw an empty rectangle
    MUST be in draw mode
    
    Parameters:
    x - X of top-left
    y - Y of top-left
    width - Rectangle width
    height - Rectangle height
    color - Color to use
  - drawRectangle
```
public void drawRectangle(int x,
                 int y,
                 int width,
                 int height,
                 int color,
                 boolean doAlphaMix)
```
    Draw an empty rectangle
    MUST be in draw mode
    
    Parameters:
    x - X of top-left
    y - Y of top-left
    width - Rectangle width
    height - Rectangle height
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - drawRoundRectangle
```
public void drawRoundRectangle(int x,
                      int y,
                      int width,
                      int height,
                      int arcWidth,
                      int arcHeight,
                      int color)
```
    Draw round corner rectangle
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    arcWidth - Arc width
    arcHeight - Arc height
    color - Color to use
  - drawRoundRectangle
```
public void drawRoundRectangle(int x,
                      int y,
                      int width,
                      int height,
                      int arcWidth,
                      int arcHeight,
                      int color,
                      boolean doAlphaMix)
```
    Draw round corner rectangle
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    arcWidth - Arc width
    arcHeight - Arc height
    color - Color to use
    doAlphaMix - Indicates if do alpha mixing or just overwrite
  - drawShape
```
public void drawShape(java.awt.Shape shape,
             int color)
```
    Draw an empty shape
    MUST be in draw mode
    
    Parameters:
    shape - Shape to draw
    color - Color to use
  - drawShape
```
public void drawShape(java.awt.Shape shape,
             int color,
             boolean doAlphaMix)
```
    Draw an empty shape
    MUST be in draw mode
    
    Parameters:
    shape - Shape to draw
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - drawString
```
public void drawString(int x,
              int y,
              java.lang.String string,
              JHelpFont font,
              int color)
```
    Draw a string
    MUST be in draw mode
    
    Parameters:
    x - X of top-left
    y - Y of top-left
    string - String to draw
    font - Font to use
    color - Color to use
  - drawString
```
public void drawString(int x,
              int y,
              java.lang.String string,
              JHelpFont font,
              int color,
              boolean doAlphaMix)
```
    Draw a string
    MUST be in draw mode
    
    Parameters:
    x - X of top-left
    y - Y of top-left
    string - String to draw
    font - Font to use
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - drawStringCenter
```
public void drawStringCenter(int x,
                    int y,
                    java.lang.String string,
                    JHelpFont font,
                    int color)
```
    Draw a string center on given point
    MUST be in draw mode
    
    Parameters:
    x - String center X
    y - String center Y
    string - String to draw
    font - Font to use
    color - Color to use
  - drawStringCenter
```
public void drawStringCenter(int x,
                    int y,
                    java.lang.String string,
                    JHelpFont font,
                    int color,
                    boolean doAlphaMix)
```
    Draw a string center on given point
    MUST be in draw mode
    
    Parameters:
    x - String center X
    y - String center Y
    string - String to draw
    font - Font to use
    color - Color to use
    doAlphaMix - Indicates if use alpha mix
  - drawVerticalLine
```
public void drawVerticalLine(int x,
                    int y1,
                    int y2,
                    int color)
```
    Draw a vertical line
    MUST be in draw mode
    
    Parameters:
    x - X
    y1 - Start Y
    y2 - End Y
    color - Color to use
  - drawVerticalLine
```
public void drawVerticalLine(int x,
                    int y1,
                    int y2,
                    int color,
                    boolean doAlphaMix)
```
    Draw a vertical line
    MUST be in draw mode
    
    Parameters:
    x - X
    y1 - Start Y
    y2 - End Y
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - endDrawMode
```
public void endDrawMode()
```
    Stop the draw mode and refresh the image
  - extractSubImage
```
public JHelpImage extractSubImage(int x,
                         int y,
                         int width,
                         int height)
```
    Extract a sub image from the image
    Note : If one of image is not in draw mode, all visible sprite (of this image) will be consider as a part of the image
    
    Parameters:
    x - X of upper left corner of the area to extract
    y - Y of upper left corner of the area to extract
    width - Area to extract width
    height - Area to extract height
    
    Returns:
    Extracted image
  - fillEllipse
```
public void fillEllipse(int x,
               int y,
               int width,
               int height,
               int color)
```
    Fill an ellipse
    MUST be in draw mode
    
    Parameters:
    x - X of bounds top-left
    y - Y of bounds top-left
    width - Ellipse width
    height - Ellipse height
    color - Color to use
  - fillEllipse
```
public void fillEllipse(int x,
               int y,
               int width,
               int height,
               int color,
               boolean doAlphaMix)
```
    Fill an ellipse
    MUST be in draw mode
    
    Parameters:
    x - X of bounds top-left
    y - Y of bounds top-left
    width - Ellipse width
    height - Ellipse height
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillEllipse
```
public void fillEllipse(int x,
               int y,
               int width,
               int height,
               JHelpImage texture)
```
    Fill ellipse with a texture
    Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    x - X of bounds top-left
    y - Y of bounds top-left
    width - Ellipse width
    height - Ellipse height
    texture - Texture to use
  - fillEllipse
```
public void fillEllipse(int x,
               int y,
               int width,
               int height,
               JHelpImage texture,
               boolean doAlphaMix)
```
    Fill ellipse with a texture
    Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    x - X of bounds top-left
    y - Y of bounds top-left
    width - Ellipse width
    height - Ellipse height
    texture - Texture to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillEllipse
```
public void fillEllipse(int x,
               int y,
               int width,
               int height,
               JHelpPaint paint)
```
    Fill an ellipse
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    paint - Paint to use
  - fillEllipse
```
public void fillEllipse(int x,
               int y,
               int width,
               int height,
               JHelpPaint paint,
               boolean doAlphaMix)
```
    Fill an ellipse
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    paint - Paint to use
    doAlphaMix - Indicates if do alpha mixing or just overwrite
  - fillPolygon
```
public void fillPolygon(int[] xs,
               int offsetX,
               int[] ys,
               int offsetY,
               int length,
               int color)
```
    Fill a polygon
    
    Parameters:
    xs - X list
    offsetX - X list start offset
    ys - Y list
    offsetY - Y list start offset
    length - Number of points
    color - Color to use
  - fillPolygon
```
public void fillPolygon(int[] xs,
               int offsetX,
               int[] ys,
               int offsetY,
               int length,
               int color,
               boolean doAlphaMix)
```
    Fill a polygon
    MUST be in draw mode
    
    Parameters:
    xs - X list
    offsetX - X list start offset
    ys - Y list
    offsetY - Y list start offset
    length - Number of points
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillPolygon
```
public void fillPolygon(int[] xs,
               int offsetX,
               int[] ys,
               int offsetY,
               int length,
               JHelpImage texture)
```
    Fill a polygon
    Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    xs - X list
    offsetX - X list start offset
    ys - Y list
    offsetY - Y list offset
    length - Number of points
    texture - Texture to use
  - fillPolygon
```
public void fillPolygon(int[] xs,
               int offsetX,
               int[] ys,
               int offsetY,
               int length,
               JHelpImage texture,
               boolean doAlphaMix)
```
    Fill a polygon
    Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    xs - X list
    offsetX - X list start offset
    ys - Y list
    offsetY - Y list offset
    length - Number of points
    texture - Texture to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillPolygon
```
public void fillPolygon(int[] xs,
               int offsetX,
               int[] ys,
               int offsetY,
               int length,
               JHelpPaint paint)
```
    Fill a polygon
    MUST be in draw mode
    
    Parameters:
    xs - X coordinates
    offsetX - Start read offset of xs
    ys - Y coordinates
    offsetY - Start read offset of ys
    length - Number of point
    paint - Paint to use
  - fillPolygon
```
public void fillPolygon(int[] xs,
               int offsetX,
               int[] ys,
               int offsetY,
               int length,
               JHelpPaint paint,
               boolean doAlphaMix)
```
    Fill a polygon
    MUST be in draw mode
    
    Parameters:
    xs - X coordinates
    offsetX - Start read offset of xs
    ys - Y coordinates
    offsetY - Start read offset of ys
    length - Number of point
    paint - Paint to use
    doAlphaMix - Indicates if do alpha mixing or just overwrite
  - fillPolygon
```
public void fillPolygon(int[] xs,
               int[] ys,
               int color)
```
    Fill a polygon
    MUST be in draw mode
    
    Parameters:
    xs - X list
    ys - Y list
    color - Color to use
  - fillPolygon
```
public void fillPolygon(int[] xs,
               int[] ys,
               int color,
               boolean doAlphaMix)
```
    Fill a polygon
    MUST be in draw mode
    
    Parameters:
    xs - X list
    ys - Y list
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillPolygon
```
public void fillPolygon(int[] xs,
               int[] ys,
               JHelpImage texture)
```
    Fill a polygon
    Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    xs - X list
    ys - Y list
    texture - Texture to use
  - fillPolygon
```
public void fillPolygon(int[] xs,
               int[] ys,
               JHelpImage texture,
               boolean doAlphaMix)
```
    Fill a polygon
    Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    xs - X list
    ys - Y list
    texture - Texture to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillPolygon
```
public void fillPolygon(int[] xs,
               int[] ys,
               JHelpPaint paint)
```
    Fill a polygon
    MUST be in draw mode
    
    Parameters:
    xs - X coordinates
    ys - Y coordinates
    paint - Paint to use
  - fillPolygon
```
public void fillPolygon(int[] xs,
               int[] ys,
               JHelpPaint paint,
               boolean doAlphaMix)
```
    Fill a polygon
    MUST be in draw mode
    
    Parameters:
    xs - X coordinates
    ys - Y coordinates
    paint - Paint to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillRectangle
```
public void fillRectangle(int x,
                 int y,
                 int width,
                 int height,
                 int color)
```
    Fill a rectangle
    MUST be in draw mode
    
    Parameters:
    x - X top-left
    y - U top-left
    width - Rectangle width
    height - Rectangle height
    color - Color to use
  - fillRectangle
```
public void fillRectangle(int x,
                 int y,
                 int width,
                 int height,
                 int color,
                 boolean doAlphaMix)
```
    Fill a rectangle
    MUST be in draw mode
    
    Parameters:
    x - X top-left
    y - U top-left
    width - Rectangle width
    height - Rectangle height
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillRectangle
```
public void fillRectangle(int x,
                 int y,
                 int width,
                 int height,
                 JHelpImage texture)
```
    Fill a rectangle
    Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    x - X top-left
    y - Y top-left
    width - Rectangle width
    height - Rectangle height
    texture - Texture to use
  - fillRectangle
```
public void fillRectangle(int x,
                 int y,
                 int width,
                 int height,
                 JHelpImage texture,
                 boolean doAlphaMix)
```
    Fill a rectangle
    Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    x - X top-left
    y - Y top-left
    width - Rectangle width
    height - Rectangle height
    texture - Texture to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillRectangle
```
public void fillRectangle(int x,
                 int y,
                 int width,
                 int height,
                 JHelpPaint paint)
```
    Fill a rectangle
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    paint - Paint to use
  - fillRectangle
```
public void fillRectangle(int x,
                 int y,
                 int width,
                 int height,
                 JHelpPaint paint,
                 boolean doAlphaMix)
```
    Fill a rectangle
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    paint - Paint to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillRectangleScale
```
public void fillRectangleScale(int x,
                      int y,
                      int width,
                      int height,
                      JHelpImage texture)
```
    Fill a rectangle with an image.
    The image is scaled to fit rectangle size
    Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    texture - Image to draw
  - fillRectangleScale
```
public void fillRectangleScale(int x,
                      int y,
                      int width,
                      int height,
                      JHelpImage texture,
                      boolean doAlphaMix)
```
    Fill a rectangle with an image.
    The image is scaled to fit rectangle size
    Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    texture - Image to draw
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillRectangleScaleBetter
```
public void fillRectangleScaleBetter(int x,
                            int y,
                            int width,
                            int height,
                            JHelpImage texture)
```
    Fill a rectangle with an image.
    The image is scaled to fit rectangle size.
    The result is nicer than fillRectangleScale(int, int, int, int, JHelpImage) but it is slower and take temporary more memory
    Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    texture - Image to draw
  - fillRectangleScaleBetter
```
public void fillRectangleScaleBetter(int x,
                            int y,
                            int width,
                            int height,
                            JHelpImage texture,
                            boolean doAlphaMix)
```
    Fill a rectangle with an image.
    The image is scaled to fit rectangle size.
    The result is nicer than fillRectangleScale(int, int, int, int, JHelpImage, boolean) but it is slower and take temporary more memory
    Note : if the texture is not in draw moe, all of it's visible sprte will be condider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    texture - Image to draw
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillRoundRectangle
```
public void fillRoundRectangle(int x,
                      int y,
                      int width,
                      int height,
                      int arcWidth,
                      int arcHeight,
                      int color)
```
    Fill a round rectangle
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    arcWidth - Arc width
    arcHeight - Arc height
    color - Color to use
  - fillRoundRectangle
```
public void fillRoundRectangle(int x,
                      int y,
                      int width,
                      int height,
                      int arcWidth,
                      int arcHeight,
                      int color,
                      boolean doAlphaMix)
```
    Fill a round rectangle
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    arcWidth - Arc width
    arcHeight - Arc height
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillRoundRectangle
```
public void fillRoundRectangle(int x,
                      int y,
                      int width,
                      int height,
                      int arcWidth,
                      int arcHeight,
                      JHelpImage texture)
```
    Fill a round rectangle
    Note : if the texture is not in draw mode, all of it's visible sprite will be consider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    arcWidth - Arc width
    arcHeight - Arc height
    texture - Texture to use
  - fillRoundRectangle
```
public void fillRoundRectangle(int x,
                      int y,
                      int width,
                      int height,
                      int arcWidth,
                      int arcHeight,
                      JHelpImage texture,
                      boolean doAlphaMix)
```
    Fill a round rectangle
    Note : if the texture is not in draw mode, all of it's visible sprite will be consider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    arcWidth - Arc width
    arcHeight - Arc height
    texture - Texture to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillRoundRectangle
```
public void fillRoundRectangle(int x,
                      int y,
                      int width,
                      int height,
                      int arcWidth,
                      int arcHeight,
                      JHelpPaint paint)
```
    Fill a round rectangle
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    arcWidth - Arc width
    arcHeight - Arc height
    paint - Paint to use
  - fillRoundRectangle
```
public void fillRoundRectangle(int x,
                      int y,
                      int width,
                      int height,
                      int arcWidth,
                      int arcHeight,
                      JHelpPaint paint,
                      boolean doAlphaMix)
```
    Fill a round rectangle
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    width - Width
    height - Height
    arcWidth - Arc width
    arcHeight - Arc height
    paint - Paint to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillShape
```
public void fillShape(java.awt.Shape shape,
             int color)
```
    Fill a shape
    MUST be in draw mode
    
    Parameters:
    shape - Shape to fill
    color - Color to use
  - fillShape
```
public void fillShape(java.awt.Shape shape,
             int color,
             boolean doAlphaMix)
```
    Fill a shape
    MUST be in draw mode
    
    Parameters:
    shape - Shape to fill
    color - Color to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillShape
```
public void fillShape(java.awt.Shape shape,
             JHelpImage texture)
```
    Fill a shape
    Note : if the texture is not in draw mode, all of it's visible sprite will be consider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    shape - Shape to fill
    texture - Texture to use
  - fillShape
```
public void fillShape(java.awt.Shape shape,
             JHelpImage texture,
             boolean doAlphaMix)
```
    Fill a shape
    Note : if the texture is not in draw mode, all of it's visible sprite will be consider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    shape - Shape to fill
    texture - Texture to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillShape
```
public void fillShape(java.awt.Shape shape,
             JHelpPaint paint)
```
    Fill a shape
    MUST be in draw mode
    
    Parameters:
    shape - Shape to fill
    paint - Paint to use
  - fillShape
```
public void fillShape(java.awt.Shape shape,
             JHelpPaint paint,
             boolean doAlphaMix)
```
    Fill a shape
    MUST be in draw mode
    
    Parameters:
    shape - Shape to fill
    paint - Paint to use
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillString
```
public void fillString(int x,
              int y,
              java.lang.String string,
              JHelpFont font,
              int color)
```
    Fill a string
    MUST be in draw mode
    
    Parameters:
    x - X top-left
    y - Y top-left
    string - String to draw
    font - Font to use
    color - Color for fill
  - fillString
```
public void fillString(int x,
              int y,
              java.lang.String string,
              JHelpFont font,
              int color,
              boolean doAlphaMix)
```
    Fill a string
    MUST be in draw mode
    
    Parameters:
    x - X top-left
    y - Y top-left
    string - String to draw
    font - Font to use
    color - Color for fill
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillString
```
public void fillString(int x,
              int y,
              java.lang.String string,
              JHelpFont font,
              JHelpImage texture,
              int color)
```
    Fill a string
    Note : if the texture is not in draw mode, all of it's visible sprite will be consider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    x - X top-left
    y - Y top-left
    string - String to fill
    font - Font to use
    texture - Texture to use
    color - Color if underline
  - fillString
```
public void fillString(int x,
              int y,
              java.lang.String string,
              JHelpFont font,
              JHelpImage texture,
              int color,
              boolean doAlphaMix)
```
    Fill a string
    Note : if the texture is not in draw mode, all of it's visible sprite will be consider like a part of he texture
    MUST be in draw mode
    
    Parameters:
    x - X top-left
    y - Y top-left
    string - String to fill
    font - Font to use
    texture - Texture to use
    color - Color if underline
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - fillString
```
public void fillString(int x,
              int y,
              java.lang.String string,
              JHelpFont font,
              JHelpPaint paint,
              int color)
```
    Fill a string
    MUST be on draw mode
    
    Parameters:
    x - X
    y - Y
    string - String to fill
    font - Font to use
    paint - Paint to use
    color - Color for underline
  - fillString
```
public void fillString(int x,
              int y,
              java.lang.String string,
              JHelpFont font,
              JHelpPaint paint,
              int color,
              boolean doAlphaMix)
```
    Fill a string
    MUST be on draw mode
    
    Parameters:
    x - X
    y - Y
    string - String to fill
    font - Font to use
    paint - Paint to use
    color - Color for underline
    doAlphaMix - Indicates if we do the mixing true, or we just override false
  - filterBlue
```
public void filterBlue()
```
    Filter image on blue channel
    MUST be on draw mode
  - filterGreen
```
public void filterGreen()
```
    Filter image on green channel
    MUST be on draw mode
  - filterOn
```
public void filterOn(int color,
            int colorOK,
            int colorKO)
```
    Filter image on a specific color
    MUST be on draw mode
    
    Parameters:
    color - Color search
    colorOK - Color to use if corresponds
    colorKO - Colo to use if failed
  - filterOn
```
public void filterOn(int color,
            int precision,
            int colorOK,
            int colorKO)
```
    filter image on a specific color
    MUST be on draw mode
    
    Parameters:
    color - Color search
    precision - Precision to use
    colorOK - Color if corresponds
    colorKO - Color if not corresponds
  - filterPalette
```
public void filterPalette(int index,
                 int colorOK,
                 int colorKO)
```
    Filter on using a palette color
    MUST be on draw mode
    
    Parameters:
    index - Palette color indes
    colorOK - Color if match
    colorKO - Color if not match
  - filterRed
```
public void filterRed()
```
    Filter image on red channel
    MUST be on draw mode
  - filterU
```
public void filterU()
```
    Filter image on U part
    MUST be on draw mode
  - filterV
```
public void filterV()
```
    Filter image on V part
    MUST be on draw mode
  - filterY
```
public void filterY()
```
    Filter image on Y part
    MUST be on draw mode
  - flipBoth
```
public void flipBoth()
```
    Flip the image horizontally and vertically in same time.
    Visually its same result as : But its done faster
    MUST be on draw mode
  - flipHorizontal
```
public void flipHorizontal()
```
    Flip the image horizontally
    MUST be on draw mode
  - flipVertical
```
public void flipVertical()
```
    Flip the image vertically
    MUST be on draw mode
  - getHeight
```
public int getHeight()
```
    Image height
    
    Returns:
    Image height
  - getImage
```
public java.awt.Image getImage()
```
    Image for draw in graphics environment
    
    Returns:
    Image for draw in graphics environment
  - getName
```
public java.lang.String getName()
```
    Image name
    
    Returns:
    Image name
  - getWidth
```
public int getWidth()
```
    Image width
    
    Returns:
    Image width
  - gray
```
public void gray()
```
    Convert image in gray version
    MUST be on draw mode
  - grayInvert
```
public void grayInvert()
```
    Convert image in gray invert version
    MUST be on draw mode
  - invertColors
```
public void invertColors()
```
    Invert image colors
    MUST be on draw mode
  - invertUV
```
public void invertUV()
```
    Invert U and V parts
    MUST be on draw mode
  - isDrawMode
```
public boolean isDrawMode()
```
    Indicates if we are in draw mode
    
    Returns:
    Draw mode status
  - maximum
```
public void maximum(JHelpImage image)
```
    Take the maximum between this image and given one
    Note : if the given image is not in draw mode, all of it's visible sprite will be consider like a part of the given image
    Given image MUST have same dimension of this
    MUST be in draw mode
    
    Parameters:
    image - Image reference
  - middle
```
public void middle(JHelpImage image)
```
    Take the middle between this image and given one
    Note : if the given image is not in draw mode, all of it's visible sprite will be consider like a part of the given image
    Given image MUST have same dimension of this
    MUST be in draw mode
    
    Parameters:
    image - Image reference
  - minimum
```
public void minimum(JHelpImage image)
```
    Take the minimum between this image and given one
    Note : if the given image is not in draw mode, all of it's visible sprite will be consider like a part of the given image
    Given image MUST have same dimension of this
    MUST be in draw mode
    
    Parameters:
    image - Image reference
  - multiply
```
public void multiply(JHelpImage image)
```
    Multiply the image with an other one
    Note : if the given image is not in draw mode, all of it's visible sprite will be consider like a part of the given image
    Given image MUST have same dimension of this
    MUST be in draw mode
    
    Parameters:
    image - Image to multiply
  - paintMask
```
public void paintMask(int x,
             int y,
             JHelpMask mask,
             int foreground,
             int background,
             boolean doAlphaMix)
```
    Paint a mask
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    mask - Mask to paint
    foreground - Foreground color
    background - Background color
    doAlphaMix - Indicates if do alpha mixing (true) or just overwrite (false)
  - paintMask
```
public void paintMask(int x,
             int y,
             JHelpMask mask,
             int foreground,
             JHelpImage background,
             int backgroundX,
             int backgroundY,
             boolean doAlphaMix)
```
    Paint a mask with unify foreground color and part of image in background
    Note : if the background is not in draw mode, all of it's visible sprite will be consider like a part of the background
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    mask - Mask to paint
    foreground - Foreground color
    background - Background image
    backgroundX - X start in background image
    backgroundY - Y start in background image
    doAlphaMix - Indicates if do alpha mixing (true) or just overwrite (false)
  - paintMask
```
public void paintMask(int x,
             int y,
             JHelpMask mask,
             int foreground,
             JHelpPaint background,
             boolean doAlphaMix)
```
    Paint a mask with unify color as foreground and paint as background
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    mask - Mask to paint
    foreground - Foreground color
    background - Background paint
    doAlphaMix - Indicates if do alpha mixing (true) or just overwrite (false)
  - paintMask
```
public void paintMask(int x,
             int y,
             JHelpMask mask,
             JHelpImage foreground,
             int foregroundX,
             int foregroundY,
             int background,
             boolean doAlphaMix)
```
    Paint a mask with part of image as foreground and unify color as background
    Note : if the foreground is not in draw mode, all of it's visible sprite will be consider like a part of the foreground
    MUST be in draw mode
    
    Parameters:
    x - X
    y - Y
    mask - Mask to paint
    foreground - Foreground image
    foregroundX - X start on foreground image
    foregroundY - Y start on foreground image
    background - Background color
    doAlphaMix - Indicates if do alpha mixing (true) or just overwrite (false)
  - paintMask
```
public void paintMask(int x,
             int y,
             JHelpMask mask,
             JHelpImage foreground,
             int foregroundX,
             int foregroundY,
             JHelpImage background,
             int backgroundX,
             int backgroundY,
             boolean doAlphaMix)
```
    Paint a mask with 2 images, one for "foreground" pixels, one for "background" ones
    Note : if the foreground or background is not in draw mode, all of it's visible sprite will be consider like a part of the foreground or background
    MUST be in draw mode
    
    Parameters:
    x - X position for the mask
    y - Y position for the mask
    mask - Mask to paint
    foreground - Foreground image
    foregroundX - X start position in foreground image
    foregroundY - Y start position in foreground image
    background - Background image
    backgroundX - X start position in background image
    backgroundY - Y start position in background image
    doAlphaMix - Indicates if do alpha mixing (true) or just overwrite (false)
  - paintMask
```
public void paintMask(int x,
             int y,
             JHelpMask mask,
             JHelpImage foreground,
             int foregroundX,
             int foregroundY,
             JHelpPaint background,
             boolean doAlphaMix)
```
    Paint a mask with image in foreground and paint in background
    Note : if the foreground is not in draw mode, all of it's visible sprite will be consider like a part of the foreground
    MUST be in draw mode
    
    Parameters:
    x - X where paint the mask
    y - Y where paint the mask
    mask - Mask to paint
    foreground - Image in foreground
    foregroundX - X start on foreground image
    foregroundY - Y start on foreground image
    background - Background paint
    doAlphaMix - Indicates if do alpha mixing (true) or just overwrite (false)
  - paintMask
```
public void paintMask(int x,
             int y,
             JHelpMask mask,
             JHelpPaint foreground,
             int background,
             boolean doAlphaMix)
```
    Paint mask with paint in foreground and color in background
    MUST be in draw mode
    
    Parameters:
    x - X where paint the mask
    y - Y where paint the mask
    mask - Mask to paint
    foreground - Foreground paint
    background - Background color
    doAlphaMix - Indicates if do alpha mixing (true) or just overwrite (false)
  - paintMask
```
public void paintMask(int x,
             int y,
             JHelpMask mask,
             JHelpPaint foreground,
             JHelpImage background,
             int backgroundX,
             int backgroundY,
             boolean doAlphaMix)
```
    Paint a mask with paint in foreground and image in background
    Note : if the background is not in draw mode, all of it's visible sprite will be consider like a part of the background
    MUST be in draw mode
    
    Parameters:
    x - X position for mask
    y - Y position for mask
    mask - Mask to paint
    foreground - Foreground paint
    background - Background image
    backgroundX - X start in background image
    backgroundY - Y start in background image
    doAlphaMix - Indicates if do alpha mixing (true) or just overwrite (false)
  - paintMask
```
public void paintMask(int x,
             int y,
             JHelpMask mask,
             JHelpPaint foreground,
             JHelpPaint background,
             boolean doAlphaMix)
```
    Paint mask with paint in foreground and background
    MUST be in draw mode
    
    Parameters:
    x - X position for mask
    y - Y position for mask
    mask - Mask to paint
    foreground - Foreground paint
    background - Background paint
    doAlphaMix - Indicates if do alpha mixing (true) or just overwrite (false)
  - pickColor
```
public int pickColor(int x,
            int y)
```
    Pick a color inside the image
    Note : if the image is not in draw mode, all visible sprite are consider as a part of image, so may obtain a sprite pixel
    
    Parameters:
    x - X position
    y - Y position
    
    Returns:
    Picked color
  - register
```
public void register(java.awt.Component component)
```
    Register a component to update on image change
    
    Parameters:
    component - Component to register
  - removeSprite
```
public void removeSprite(JHelpSprite sprite)
```
    Remove a sprite from linked sprites.
    The sprite is no more usable
    MUSN'T be in draw mode
    
    Parameters:
    sprite - Sprite to remove
  - replaceColor
```
public void replaceColor(int colorToReplace,
                int newColor,
                int near)
```
    Replace all pixels near a color by an other color
    MUST be in draw mode
    
    Parameters:
    colorToReplace - Color searched
    newColor - New color
    near - Distance maximum from color searched to consider to color is near
  - rotate180
```
public JHelpImage rotate180()
```
    Compute the image rotated from 180 degree
    If the image is not in draw mode, visible sprites are consider like a part of image
    
    Returns:
    Rotated image
  - rotate270
```
public JHelpImage rotate270()
```
    Compute the image rotated from 270 degree
    If the image is not in draw mode, visible sprites are consider like a part of image
    
    Returns:
    Rotated image
  - rotate90
```
public JHelpImage rotate90()
```
    Compute the image rotated from 90 degree
    If the image is not in draw mode, visible sprites are consider like a part of image
    
    Returns:
    Rotated image
  - rotatedPart180
```
public JHelpImage rotatedPart180(int x,
                        int y,
                        int width,
                        int height)
```
    Extract a sub image and then rotate it from 180 degree
    If the image is not in draw mode, visible sprites are consider like a part of image
    
    Parameters:
    x - Upper left area corner X
    y - Upper left area corner Y
    width - Area to extract width
    height - Area to extract height
    
    Returns:
    Result image
  - rotatedPart270
```
public JHelpImage rotatedPart270(int x,
                        int y,
                        int width,
                        int height)
```
    Extract a sub image and then rotate it from 270 degree
    If the image is not in draw mode, visible sprites are consider like a part of image
    
    Parameters:
    x - Upper left area corner X
    y - Upper left area corner Y
    width - Area to extract width
    height - Area to extract height
    
    Returns:
    Result image
  - rotatedPart90
```
public JHelpImage rotatedPart90(int x,
                       int y,
                       int width,
                       int height)
```
    Extract a sub image and then rotate it from 90 degree
    If the image is not in draw mode, visible sprites are consider like a part of image
    
    Parameters:
    x - Upper left area corner X
    y - Upper left area corner Y
    width - Area to extract width
    height - Area to extract height
    
    Returns:
    Result image
  - setName
```
public void setName(java.lang.String name)
```
    Change image name
    
    Parameters:
    name - New name
  - shift
```
public void shift(int x,
         int y)
```
    Shift (translate) the image
    MUST be in draw mode
    
    Parameters:
    x - X shift
    y - Y shift
  - startDrawMode
```
public void startDrawMode()
```
    Start the draw mode
  - subtract
```
public void subtract(JHelpImage image)
```
    Subtract the image by an other one
    Note : if the given image is not in draw mode, all of it's visible sprite will be consider like a part of the given image
    Given image MUST have same dimension of this
    MUST be in draw mode
    
    Parameters:
    image - Image to subtract
  - transfertSpritesTo
```
public void transfertSpritesTo(JHelpImage image)
```
    Give all sprites of this image to an other image
    
    Parameters:
    image - Image will receive this image sprites
  - unregister
```
public void unregister(java.awt.Component component)
```
    Unregister a component
    
    Parameters:
    component - Component to unregister
  - update
```
public void update()
```
    Update the image, to see last changes

Class JHelpImage

Field Summary

Fields inherited from interface jhelp.util.gui.ConstantsGUI

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PALETTE

PALETTE_SIZE

componentsListeners

drawMode

height

image

memoryImageSource

name

pixels

reentrantLock

sprites

visibilities

width

Constructor Detail

JHelpImage

JHelpImage

JHelpImage

Method Detail

computeBlue

computeGreen

computeRed

computeU

computeV

computeY

loadBufferedImage

createBumpedImage

createBumpedImage

createBumpedImage2

createImage

createThumbImage

doesImagesLookSamePerBorder

doesImagesLookSamePerLuminosity

doesImagesLookSamePerPixel

extractBorder

extractBorder

extractBorder

extractBorder2

loadImage

loadImage

loadImageThumb

loadImageThumb

saveImage

drawShapeCenter

changeSpriteVisibiliy

drawImageInternal

drawImageInternal

drawImageOver

refresh

finalize

addition

applyPalette

brighter

brightness

categorizeByColor

categorizeByY

clear

colorizeWithPalette

contrast

contrastAvreage

copy

createAnimatedSprite

createCopy

createSprite

createSprite

darker

divide

drawEllipse

drawEllipse

drawHorizontalLine

drawHorizontalLine

drawImage

drawImage

drawImage