class TASImage: public TImage

 helper class

 set default parameters

 Default image ctor.

 create an empty image

 Create an image object and read from specified file.
 For more information see description of function ReadImage()
 which is called by this constructor.

 Creates an image depending on the values of imageData.
 For more information see function SetImage() which is called
 by this constructor.

 Creates an image depending on the values of imageData. The size
 of the image is width X (imageData.fN / width).
 For more information see function SetImage() which is called by
 this constructor.

 Creates an image depending on the values of imageData. The size
 of the image is width X (imageData.fN / width).
 For more information see function SetImage() which is called by
 this constructor.

 Image copy ctor.

 Image assignment operator.

 Image dtor, clean up image and visual.

 Guess file type from the first byte of file

 Read specified image file. The file type is determined by
 the file extension (the type argument is ignored). It will
 attempt to append .gz and then .Z to the filename and find such
 a file. If the filename ends with extension consisting of digits
 only, it will attempt to find the file with this extension stripped
 off. On success this extension will be used to load subimage from
 the file with that number. Subimage is supported for GIF files
 (ICO, BMP, CUR, TIFF, XCF to be supported in futute).
  For example,
    i1 = TImage::Open("anim.gif.0"); // read the first subimage
    i4 = TImage::Open("anim.gif.3"); // read the forth subimage

 It is also possible to put XPM raw string (see also SetImageBuffer) as
 the first input parameter ("filename"), such string  is returned by
 GetImageBuffer method.

 Write image to specified file. If there is no file extension or
 if the file extension is unknown, the type argument will be used
 to determine the file type. The quality and compression is derived from
 the TAttImage values.
 It's posiible to write image into an animated GIF file by specifying file name as
 "myfile.gif+" of "myfile.gif+NN", where NN is delay of displaying
 subimages during animation in 10ms seconds units.
 If NN is ommitted the delay between subimages is zero.
 For repeated animation the last subimage must be specified as "myfile.gif++NN",
 where NN is number of cycles. If NN is ommitted the animation will be infinite.

 The following macro creates animated gif from jpeg images with names
    imageNN.jpg, where 1<= NN <= 10
 {
    TImage *img = 0;
    gSystem->Unlink("anim.gif");  // delete existing file

    for (int i = 1; i <= 10; i++) {
       delete img; // delete previous image

       // Read image data. Image can be in any format, e.g. png, gif, etc.
       img = TImage::Open(Form("image%d.jpg", i));

       if (i < 10) {
          img->WriteImage("anim.gif+");
       } else { // the last image written.  "++" stands for infinit animation.
          img->WriteImage("anim.gif++");
       }
    }
 }

 Return file type depending on specified extension.
 Protected method.

 Map file type to/from AfterImage types.
 Protected method.

 Map quality to/from AfterImage quality.
 Protected method.

 Deletes the old image and creates a new image depending on the values
 of imageData. The size of the image is width X height.
 The color of each pixel depends on the imageData of the corresponding
 pixel. The palette is used to convert an image value into its color.
 If palette is not defined (palette = 0) a default palette is used.
 Any previously defined zooming is reset.

 Deletes the old image and creates a new image depending on the values
 of imageData. The size of the image is width X (imageData.fN / width).
 The color of each pixel depends on the imageData of the corresponding
 pixel. The palette is used to convert an image value into its color.
 If palette is not defined (palette = 0) a default palette is used.
 Any previously defined zooming is reset.

 Deletes the old image and creates a new image depending on the values
 of imageData. The size of the image is width X (imageData.fN / width).
 The color of each pixel depends on the imageData of the corresponding
 pixel. The palette is used to convert an image value into its color.
 If palette is not defined (palette = 0) a default palette is used.
 Any previously defined zooming is reset.

 Create an image from the given pad, afterwards this image can be
 saved in any of the supported image formats.

 Draw image. Support the following drawing options:
 "T[x,y[,tint]]" - tile image (use specified offset and tint),
                   e.g. "T100,100,#556655"
                   with this option the zooming is not possible
                   and disabled
 "N"             - display in new canvas (of original image size)
 "X"             - image is drawn expanded to pad size
 "Z"             - image is vectorized and image palette is drawn

 The default is to display the image in the current gPad.

 Draw asimage on drawable.

 Draw image on the drawable wid (pixmap, window) at x,y position.

 wid        : Drawable (pixmap or window) on which image is drawn.
 x,y        : Window coordinates where image is drawn.
 xsrc, ysrc : X and Y coordinates of an image area to be drawn.
 wsrc, hsrc : Widh and height image area to be drawn.

 Paint image. Support the following drawing options:
 "T[x,y[,tint]]" - tile image (use specified offset and tint),
                   e.g. "T100,100,#556655"
                   with this option the zooming is not possible
                   and disabled
 "N"             - display in new canvas (of original image size)
 "X"             - image is drawn expanded to pad size
 "Z"             - image is vectorized and image palette is drawn

 The default is to display the image in the current gPad.

 Is the mouse in the image?

 Execute mouse events.

 Get image pixel coordinates and the pixel value at the mouse pointer.

 Set a new palette to an image. Only images that were created with the
 SetImage() functions can be modified with this function.
 The previously used palette is destroyed.

 Scales the original image. The size of the image on the screen does not
 change because it is defined by the size of the pad.
 This function can be used to change the size of an image before writing
 it into a file. The colors of the new pixels are interpolated.
 An image created with the SetImage() functions cannot be modified with
 the function SetPalette() any more after a call of this function!

 Yet another method of enlarging images where corners remain unchanged,
 but middle part gets tiled.

 Tiles the original image.

 The area of an image displayed in a pad is defined by this function.
 Note: the size on the screen is defined by the size of the pad.
 The original image is not modified by this function.
 If width or height is larger than the original image they are reduced to
 the width and height of the image.
 If the off values are too large (off + width > image width) than the off
 values are decreased. For example: offX = image width - width
 Note: the parameters are always relative to the original image not to the
 size of an already zoomed image.

 Un-zooms the image to original size.

 UnZoom() - performs undo for Zoom,Crop,Scale actions

 Flip image in place. Flip is either 90, 180, 270, 180 is default.
 This function manipulates the original image and destroys the
 scaled and zoomed image which will be recreated at the next call of
 the Draw function. If the image is zoomed the zoom - coordinates are
 now relative to the new image.
 This function cannot be used for images which were created with the
 SetImage() functions, because the original pixel values would be
 destroyed.

 Mirror image in place. If vert is true mirror in vertical axis,
 horizontal otherwise. Vertical is default.
 This function manipulates the original image and destroys the
 scaled and zoomed image which will be recreated at the next call of
 the Draw function. If the image is zoomed the zoom - coordinates are
 now relative to the new image.
 This function cannot be used for images which were created with the
 SetImage() functions, because the original pixel values would be
 destroyed.

 Return width of original image not of the displayed image.
 (Number of image pixels)

 Return height of original image not of the displayed image.
 (Number of image pixels)

 Return width of the displayed image not of the original image.
 (Number of screen pixels)

 Return height of the displayed image not of the original image.
 (Number of screen pixels)

 Return the zoom parameters. This is useful when the zoom has been done
 interactively using the mouse.

 Static function to initialize the ASVisual.

 Start palette editor.

 Returns image pixmap. The pixmap must deleted by user.

 Returns image mask pixmap (alpha channel). The pixmap must deleted by user.

 create image from pixmap

 returns 2D array of machine dependent pixel values

 Returns a pointer to internal array[width x height] of double values [0, 1]
 This array is directly accessible. That allows to manipulate/change the image

 In case of vectorized image return an associated array of doubles
 otherwise this method creates and returns a 2D array of doubles corresponding to palette.
 If palette is ZERO a color converted to double value [0, 1] according to formula
   Double_t((r << 16) + (g << 8) + b)/0xFFFFFF
 The returned array must be deleted after usage.

 Draw text of size (in pixels for TrueType fonts)
 at position (x, y) with color  specified by hex string.
   font_name - TrueType font's filename or X font spec or alias.
   3D style of text is one of the following:
     0 - plain 2D text, 1 - embossed, 2 - sunken, 3 - shade above,
     4 - shade below, 5 - embossed thick, 6 - sunken thick.
     7 - ouline above, 8 - ouline below, 9 - full ouline.
  fore_file specifies foreground texture of text.

 Merge two images.

 op is string which specifies overlay operation. Supported operations are:
    add            - color addition with saturation
    alphablend     - alpha-blending
    allanon        - color values averaging
    colorize       - hue and saturate bottom image same as top image
    darken         - use lowest color value from both images
    diff           - use absolute value of the color difference between two images
    dissipate      - randomly alpha-blend images
    hue            - hue bottom image same as top image
    lighten        - use highest color value from both images
    overlay        - some wierd image overlaying(see GIMP)
    saturate       - saturate bottom image same as top image
    screen         - another wierd image overlaying(see GIMP)
    sub            - color substraction with saturation
    tint           - tinting image with image
    value          - value bottom image same as top image

 Performs Gaussian blurr of the image (usefull for drop shadows)
    hr         - horizontal radius of the blurr
    vr         - vertical radius of the blurr

 clone image

 Reduces colordepth of an image and fills vector of "scientific data" [0...1]

 Colors are reduced by allocating colorcells to most used colors first,
 and then approximating other colors with those allocated.
 max_colors       - maximum size of the colormap.
 dither           - number of bits to strip off the color data ( 0...7 )
 opaque_threshold - alpha channel threshold at which pixel should be
                    treated as opaque

 This function will tile original image to specified size with offsets
 requested, and then it will go though it and adjust hue, saturation and
 value of those pixels that have specific hue, set by affected_hue
 affected_radius parameters. When affected_radius is greater then 180
 entire image will be adjusted. Note that since grayscale colors have
 no hue - the will not get adjusted. Only saturation and value will be
 adjusted in gray pixels.
 Hue is measured as an angle on a 360 degree circle, The following is
 relationship of hue values to regular color names :
 red      - 0
 yellow   - 60
 green    - 120
 cyan     - 180
 blue     - 240
 magenta  - 300
 red      - 360

 All the hue values in parameters will be adjusted to fall withing 0-360 range.

 Render multipoint gradient inside rectangle of size (width, height)
 at position (x,y) within the existing image.

 angle    Given in degrees.  Default is 0.  This is the
          direction of the gradient.  Currently the only supported
          values are 0, 45, 90, 135, 180, 225, 270, 315.  0 means left
          to right, 90 means top to bottom, etc.

 colors   Whitespace-separated list of colors.  At least two
          colors are required.  Each color in this list will be visited
          in turn, at the intervals given by the offsets attribute.

 offsets  Whitespace-separated list of floating point values
          ranging from 0.0 to 1.0.  The colors from the colors attribute
          are given these offsets, and the final gradient is rendered
          from the combination of the two.  If both colors and offsets
          are given but the number of colors and offsets do not match,
          the minimum of the two will be used, and the other will be
          truncated to match.  If offsets are not given, a smooth
          stepping from 0.0 to 1.0 will be used.

  Bevel is used to create 3D effect while drawing buttons, or any other
 image that needs to be framed. Bevel is drawn using 2 primary colors:
 one for top and left sides - hi color, and another for bottom and
 right sides - low color. Bevel can be drawn over exisiting image or
 as newly created,  as it is shown in code below:

  TImage *img = TImage::Create();
  img->Bevel(0, 0, 400, 300, "#dddddd", "#000000", 3);

 Enlarges image, padding it with specified color on each side in
 accordance with requested geometry.

 Crops an image

 Appends image

 option:
       "+" - appends to the right side
       "/" - appends to the bottom

 BeginPaint initializes internal array[width x height] of ARGB32 pixel values
 That provides quick access to image during paint operations.
 To RLE compress image one needs to call EndPaint method when paintinig is over

 EndPaint does internal RLE compression of image data

 Returns a pointer to internal array[width x height] of ARGB32 values
 This array is directly accessible. That allows to manipulate/change the image

 Returns a pointer to an array[width x height] of RGBA32 values.
 This array is created from internal ARGB32 array,
 must be deleted after usage.

 return a pointer to scanline

 Fills rectangle of size (width, height) at position (x,y)
 within the existing image with specified color.

 Fills rectangle of size (width, height) at position (x,y)
 within the existing image with specified color.

 To create new image with Fill method the following code can be used:

  TImage *img = TImage::Create();
  img->Fill("#FF00FF", 0, 0, 400, 300);

 vertical line

 horizontal line

 draw line

 internal drawing

 draw rectangle

 draw box

 draw dashed horizontal line

 draw dashed vertical line

 draw dashed line with 1 pixel width

 draw dashed line with thick pixel width

 draw dashed line

 draw polyline

 draw point at specified position

 draw poly point

 draw segments

 fill spans with specified color or/and stipple

 fille spans with tile image

  crop spans

 Copy source region to the destination image. Copy is done according
 to specified function:

 enum EGraphicsFunction {
    kGXclear = 0,               // 0
    kGXand,                     // src AND dst
    kGXandReverse,              // src AND NOT dst
    kGXcopy,                    // src (default)
    kGXandInverted,             // NOT src AND dst
    kGXnoop,                    // dst
    kGXxor,                     // src XOR dst
    kGXor,                      // src OR dst
    kGXnor,                     // NOT src AND NOT dst
    kGXequiv,                   // NOT src XOR dst
    kGXinvert,                  // NOT dst
    kGXorReverse,               // src OR NOT dst
    kGXcopyInverted,            // NOT src
    kGXorInverted,              // NOT src OR dst
    kGXnand,                    // NOT src OR NOT dst
    kGXset                      // 1
 };

 Draw a cell array.
 x1,y1        : left down corner
 x2,y2        : right up corner
 nx,ny        : array size
 ic           : array of ARGB32 colors

 Draw a cell array. The drawing is done with the pixel presicion
 if (X2-X1)/NX (or Y) is not a exact pixel number the position of
 the top rigth corner may be wrong.

 returns alphablended value computed from bottom and top pixel values

 return visual

 The code is based on Xserver/mi/mipolycon.c
    "Copyright 1987, 1998  The Open Group"

 Fill a convex polygon with background color or bitmap
 For non convex polygon one must use DrawFillArea method

 Fill a convex polygon with background image.
 For non convex polygon one must use DrawFillArea method

 Crop a convex polygon.

 fill a polygon (any type convex, non-convex)

 fill a polygon (any type convex, non-convex)

 Draw wide line

 Draw glyph bitmap

 Draw text in poosition (x, y), where x,y - in pixels

 Draw text using TrueType fonts.

 Returns in-memory buffer compressed according image type
 Buffer must be deallocated after usage.
 This method can be used for sending images over network.

 create image from  compressed buffer
 Supported formats:

    PNG - by default
    XPM - two options exist:
      1.  xpm as a single string (raw buffer). Such string
          is returned by GetImageBuffer method.

    For example:
       char *buf;
       int sz;
       im1->GetImageBuffer(&buf, &int, TImage::kXpm); /*raw buffer*
       TImage *im2 = TImage::Create();
       im2->SetImageBuffer(&buf, TImage::kXpm);

      2.  xpm as an array of strigs (preparsed)

    For example:
       char *xpm[] = {
          "64 28 58 1",
          "  c #0A030C",
          ". c #1C171B"

    TImage *im = TImage::Create();
    im->SetImageBuffer(xpm, TImage::kXpm);

 creates image thumbnail

 streamer for ROOT I/O

 browse image

 title is used to keep 32x32 xpm image's thumbnail

 set a title for an image

 draws cubic bezier line

 draws straight ellips. If thick < 0 - draw filled ellips

 Draw circle. If thick < 0 - draw filled circle

 Draw ellips. If thick < 0 - draw filled ellips

 Draw ellips. If thick < 0 - draw filled ellips

 flood fill

 Converts RGB image to Gray image and vice versa.

 creates an image(screenshot) from  specified window

 creates an image(screenshot) from a RGBA buffer

 switch on/off image palette. That also invokes calling vectorizasion of image

 Save a primitive as a C++ statement(s) on output stream "out"

 Sets an image printing resolution in Dots Per Inch units.
 name - the name of jpeg file.
 set - dpi resolution.
 Returns kFALSE in case of error.