transform.h(1)

libAfterImage/transform.h
 Defines transformations that could be performed on ASImage.
 Transformations can be performed with different degree of quality.
 Internal engine uses 24.8 bits per channel per pixel. As the result
 there are no precision loss, while performing complex calculations.
 Error diffusion algorithms could be used to transform it back into 8
 bit without quality loss.
 Any Transformation could be performed with the result written directly
 into XImage, so that it could be displayed faster.
 Complex interpolation algorithms are used to perform scaling
 operations, thus yielding very good quality. All the transformations
 are performed in integer math, with the result of greater speeds.
 Optional MMX inline assembly has been incorporated into some
 procedures, and allows to achieve considerably better performance on
 compatible CPUs.
  Transformations :
          scale_asimage(), tile_asimage(), merge_layers(), make_gradient(),
          flip_asimage(), mirror_asimage(), pad_asimage(),
          blur_asimage_gauss(), fill_asimage(), adjust_asimage_hsv()
  Other libAfterImage modules :
          ascmap.h asfont.h asimage.h asvisual.h blender.h export.h
          import.h transform.h ximage.h
  Sasha Vasko <sasha at aftercode dot net>

libAfterImage/transform/scale_asimage()
 ASImage *scale_asimage( struct ASVisual *asv,
                         ASImage *src,
                         unsigned int to_width,
                         unsigned int to_height,
                         ASAltImFormats out_format,
                         unsigned int compression_out, int quality );
 asv        - pointer to valid ASVisual structure
 src        - source ASImage
 to_width   - desired width of the resulting image
 to_height  - desired height of the resulting image
 out_format     - optionally describes alternative ASImage format that
                should be produced as the result - XImage, ARGB32, etc.
 compression_out- compression level of resulting image in range 0-100.
 quality    - output quality
 returns newly created and encoded ASImage on success, NULL of failure.
 Scales source ASImage into new image of requested dimensions. If size
 has to be reduced - then several neighboring pixels will be averaged
 into single pixel. If size has to be increased then new pixels will
 be interpolated based on values of four neighboring pixels.
 ASScale

libAfterImage/transform/tile_asimage()
 ASImage *tile_asimage ( struct ASVisual *asv,
                         ASImage *src,
                         int offset_x,
                         int offset_y,
                         unsigned int to_width,
                         unsigned int to_height,
                         ARGB32 tint,
                         ASAltImFormats out_format,
                         unsigned int compression_out, int quality );
 asv          - pointer to valid ASVisual structure
 src          - source ASImage
 offset_x     - left clip margin
 offset_y     - right clip margin
 to_width     - desired width of the resulting image
 to_height    - desired height of the resulting image
 tint         - ARGB32 value describing tinting color.
 out_format     - optionally describes alternative ASImage format that
                should be produced as the result - XImage, ARGB32, etc.
 compression_out- compression level of resulting image in range 0-100.
 quality      - output quality
 returns newly created and encoded ASImage on success, NULL of failure.
 Source ASImage will be tiled into newly created image of specified
 size. offset_x and offset_y define origin on source image from which
 tiling will start. If offset_x or offset_y is outside of the image
 boundaries, then it will be reduced by whole number of image sizes to
 fit inside the image. At the time of tiling image will be tinted
 unless tint == 0.
 ASTile

libAfterImage/transform/merge_layers()
 ASImage *merge_layers  ( struct ASVisual *asv,
                          ASImageLayer *layers, int count,
                          unsigned int dst_width,
                          unsigned int dst_height,
                          ASAltImFormats out_format,
                          unsigned int compression_out, int quality);
 asv          - pointer to valid ASVisual structure
 layers       - array of ASImageLayer structures that will be rendered
                one on top of another. First element corresponds to
                the bottommost layer.
 dst_width    - desired width of the resulting image
 dst_height   - desired height of the resulting image
 out_format     - optionally describes alternative ASImage format that
                should be produced as the result - XImage, ARGB32, etc.
 compression_out - compression level of resulting image in range 0-100.
 quality      - output quality
 returns newly created and encoded ASImage on success, NULL of failure.
 merge_layers() will create new ASImage of requested size. It will then
 go through all the layers, and fill image with composition.
 Bottommost layer will be used unchanged and above layers will be
 superimposed on it, using algorithm specified in ASImageLayer
 structure of the overlaying layer. Layers may have smaller size
 then destination image, and maybe placed in arbitrary locations. Each
 layer will be padded to fit width of the destination image with all 0
 effectively making it transparent.

libAfterImage/transform/make_gradient()
 ASImage *make_gradient ( struct ASVisual *asv,
                          struct ASGradient *grad,
                          unsigned int width,
                          unsigned int height,
                          ASFlagType filter,
                          ASAltImFormats out_format,
                          unsigned int compression_out, int quality);
 asv          - pointer to valid ASVisual structure
 grad         - ASGradient structure defining how gradient should be
                drawn
 width        - desired width of the resulting image
 height       - desired height of the resulting image
 filter       - only channels corresponding to set bits will be
                rendered.
 out_format     - optionally describes alternative ASImage format that
                should be produced as the result - XImage, ARGB32, etc.
 compression_out- compression level of resulting image in range 0-100.
 quality      - output quality
 returns newly created and encoded ASImage on success, NULL of failure.
 make_gradient() will create new image of requested size and it will
 fill it with gradient, described in structure pointed to by grad.
 Different dithering techniques will be applied to produce nicer
 looking gradients.

libAfterImage/transform/flip_asimage()
 ASImage *flip_asimage ( struct ASVisual *asv,
                         ASImage *src,
                         int offset_x, int offset_y,
                         unsigned int to_width,
                         unsigned int to_height,
                         int flip, ASAltImFormats out_format,
                         unsigned int compression_out, int quality );
 asv          - pointer to valid ASVisual structure
 src          - source ASImage
 offset_x     - left clip margin
 offset_y     - right clip margin
 to_width     - desired width of the resulting image
 to_height    - desired height of the resulting image
 flip         - flip flags determining degree of rotation.
 out_format     - optionally describes alternative ASImage format that
                should be produced as the result - XImage, ARGB32, etc.
 compression_out - compression level of resulting image in range 0-100.
 quality      - output quality
 returns newly created and encoded ASImage on success, NULL of failure.
 flip_asimage() will create new image of requested size, it will then
 tile source image based on offset_x, offset_y, and destination size,
 and it will rotate it then based on flip value. Three rotation angles
 supported 90, 180 and 270 degrees.

libAfterImage/transform/mirror_asimage()
 ASImage *mirror_asimage ( struct ASVisual *asv,
                           ASImage *src,
                           int offset_x, int offset_y,
                           unsigned int to_width,
                           unsigned int to_height,
                           Bool vertical, ASAltImFormats out_format,
                           unsigned int compression_out, int quality );
 asv          - pointer to valid ASVisual structure
 src          - source ASImage
 offset_x     - left clip margin
 offset_y     - right clip margin
 to_width     - desired width of the resulting image
 to_height    - desired height of the resulting image
 vertical     - mirror in vertical direction.
 out_format     - optionally describes alternative ASImage format that
                should be produced as the result - XImage, ARGB32, etc.
 compression_out - compression level of resulting image in range 0-100.
 quality      - output quality
 returns newly created and encoded ASImage on success, NULL of failure.
 mirror_asimage() will create new image of requested size, it will then
 tile source image based on offset_x, offset_y, and destination size,
 and it will mirror it in vertical or horizontal direction.

libAfterImage/transform/pad_asimage()
 ASImage *pad_asimage( ASVisual *asv, ASImage *src,
                      int dst_x, int dst_y,
                      unsigned int to_width,
                      unsigned int to_height,
                      ARGB32 color,
                      ASAltImFormats out_format,
                      unsigned int compression_out, int quality );
 asv          - pointer to valid ASVisual structure
 src          - source ASImage
 dst_x, dst_y - placement of the source image relative to the origin of
                destination image
 to_width     - width of the destination image
 to_height    - height of the destination image
 color        - ARGB32 color value to pad with.
 out_format     - optionally describes alternative ASImage format that
                should be produced as the result - XImage, ARGB32, etc.
 compression_out - compression level of resulting image in range 0-100.
 quality      - output quality
 returns newly created and encoded ASImage on success, NULL of failure.
 enlarges ASImage, padding it with specified color on each side in
 accordance with requested geometry.

libAfterImage/transform/blur_asimage_gauss()
 ASImage* blur_asimage_gauss( ASVisual* asv, ASImage* src,
                              double horz, double vert,
                              ASAltImFormats out_format,
                              unsigned int compression_out, int quality );
 asv          - pointer to valid ASVisual structure
 src          - source ASImage
 horz         - horizontal radius of the blurr
 vert         - vertical radius of the blurr
 out_format     - optionally describes alternative ASImage format that
                should be produced as the result - XImage, ARGB32, etc.
 compression_out - compression level of resulting image in range 0-100.
 quality      - output quality
 returns newly created and encoded ASImage on success, NULL of failure.
 Performs Gaussian blurr of the image ( usefull fro drop shadows and
 the likes ).

libAfterImage/transform/fill_asimage()
 Bool fill_asimage( ASVisual *asv, ASImage *im,
                    int x, int y, int width, int height,
                    ARGB32 color );
 asv           - pointer to valid ASVisual structure
 im            - ASImage to fill with the color
 x, y          - left-top corner of the rectangle to fill.
 width, height - size of the rectangle to fill.
 color         - ARGB32 color value to fill rectangle with.
 True on success, False on failure.
 Fills rectangle within the existing ASImage with specified color.

libAfterImage/transform/adjust_asimage_hsv()
 ASImage *adjust_asimage_hsv( ASVisual *asv, ASImage *src,
                              int offset_x, int offset_y,
                              unsigned int to_width,
                              unsigned int to_height,
                              unsigned int affected_hue,
                              unsigned int affected_radius,
                              int hue_offset, int saturation_offset,
                              int value_offset,
                              ASAltImFormats out_format,
                              unsigned int compression_out, int quality);
 asv           - pointer to valid ASVisual structure
 src           - ASImage to adjust colors of.
 offset_x,
 offset_y      - position on infinite surface tiled with original image,
                 of the left-top corner of the area to be used for new
                 image.
 to_width,
 to_height     - size of the area of the original image to be used
                 for new image.
 affected_hue  - hue in degrees in range 0-360. This allows to limit
                 impact of color adjustment to affect only limited
                 range of hues.
 affected_radius Sets the diapason of the range of affected hues.
 hue_offset    - value by which to change hues in affected range.
 saturation_offset -
                 value by which to change saturation of the pixels in
                 affected hue range.
 value_offset  - value by which to change Value(brightness) of pixels
                 in affected hue range.
 out_format     - optionally describes alternative ASImage format that
                should be produced as the result - XImage, ARGB32, etc.
 compression_out- compression level of resulting image in range 0-100.
 quality      - output quality
 returns newly created and encoded ASImage on success, NULL of failure.
 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.

libAfterImage/transform/colorize_asimage_vector()
 Bool colorize_asimage_vector( ASVisual *asv, ASImage *im,
                                 ASVectorPalette *palette,
                               ASAltImFormats out_format,
                               int quality );
 asv           - pointer to valid ASVisual structure
 im            - ASImage to update.
 palette       - palette to be used in conversion of double precision
                 values into colors.
 out_format      - optionally describes alternative ASImage format that
                 should be produced as the result - XImage, ARGB32, etc.
 quality       - output quality
 True on success, False on failure.
 This function will try to convert double precision indexed image data
 into actuall color image using palette. Original data should be attached
 to ASImage using vector member. Operation is relatively fast and allows
 representation of scientific data as color image with dynamically
 changing palette.

libAfterImage/transform/create_asimage_from_vector()
 ASImage *create_asimage_from_vector( ASVisual *asv, double *vector,
                                      unsigned int width,
                                      unsigned int height,
                                      ASVectorPalette *palette,
                                      ASAltImFormats out_format,
                                      unsigned int compression,
                                      int quality );
 asv           - pointer to valid ASVisual structure
 vector        - data to be attached to new ASImage and used to generate
                 RGB image
 width, height - size of the new image.
 palette       - palette to be used in conversion of double precision
                 values into colors.
 out_format      - optionally describes alternative ASImage format that
                 should be produced as the result - XImage, ARGB32, etc.
 compression_out- compression level of resulting image in range 0-100.
 quality       - output quality
 New ASImage  on success, NULL on failure.
 This function is merely a convinience function allowing to create new
 ASImage, set its vector data and colorize it using palette - all in
 one step.
 colorize_asimage_vector(), create_asimage(), set_asimage_vector()