Preface Introduction Main index API Topic index API Glossary

# ASImage Transformations

transformations available for ASImages

libAfterImage/transform.h

- NAME

  transform

- SYNOPSIS

      Defines transformations that could be performed on ASImage.

- DESCRIPTION

      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.

- SEE ALSO

       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

- AUTHOR

      Sasha Vasko <sasha at aftercode dot net>

libAfterImage/transform/scale_asimage()

- NAME

  scale_asimage()

  - scales source ASImage into new image of requested dimensions.

- SYNOPSIS

      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 );

- INPUTS

  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

- RETURN VALUE

      returns newly created and encoded ASImage on success, NULL of failure.

- DESCRIPTION

      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.

- EXAMPLE

      ASScale

libAfterImage/transform/tile_asimage()

- NAME

  tile_asimage()

  - tiles/crops ASImage to desired size, while optionaly tinting it at the same time.

- SYNOPSIS

      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 );

- INPUTS

  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

- RETURN VALUE

      returns newly created and encoded ASImage on success, NULL of failure.

- DESCRIPTION

      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.

- EXAMPLE

      ASTile

libAfterImage/transform/merge_layers()

- NAME

  merge_layers()

- SYNOPSIS

      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);

- INPUTS

  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

- RETURN VALUE

      returns newly created and encoded ASImage on success, NULL of failure.

- DESCRIPTION

      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()

- NAME

  make_gradient()

  - renders linear gradient into new ASImage

- SYNOPSIS

      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);

- INPUTS

  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

- RETURN VALUE

      returns newly created and encoded ASImage on success, NULL of failure.

- DESCRIPTION

      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()

- NAME

  flip_asimage()

  - rotates ASImage in 90 degree increments

- SYNOPSIS

      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 );

- INPUTS

  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

- RETURN VALUE

      returns newly created and encoded ASImage on success, NULL of failure.

- DESCRIPTION

      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()

- NAME

  mirror_asimage()

- SYNOPSIS

      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 );

- INPUTS

  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

- RETURN VALUE

      returns newly created and encoded ASImage on success, NULL of failure.

- DESCRIPTION

      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()

- NAME

  pad_asimage()

  enlarges ASImage, padding it with specified color on each side in accordance with requested geometry.

- SYNOPSIS

      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 );

- INPUTS

  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

- RETURN VALUE

      returns newly created and encoded ASImage on success, NULL of failure.

libAfterImage/transform/blur_asimage_gauss()

- NAME

  blur_asimage_gauss()

  Performs Gaussian blurr of the image ( usefull for drop shadows and the likes ).

- SYNOPSIS

      ASImage* blur_asimage_gauss( ASVisual* asv, ASImage* src,
                                   double horz, double vert,
                                   ASAltImFormats out_format,
                                   unsigned int compression_out,
                                      int quality );

- INPUTS

  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

- RETURN VALUE

      returns newly created and encoded ASImage on success, NULL of failure.

libAfterImage/transform/fill_asimage()

- NAME

  fill_asimage()

  - Fills rectangle within the existing ASImage with specified color.

- SYNOPSIS

      Bool fill_asimage( ASVisual *asv, ASImage *im,
                         int x, int y, int width, int height,
                         ARGB32 color );

- INPUTS

  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.

- RETURN VALUE

      True on success, False on failure.

libAfterImage/transform/adjust_asimage_hsv()

- NAME

  adjust_asimage_hsv()

  - adjusts image color properties in HSV colorspace

- SYNOPSIS

      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);

- INPUTS

  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

- RETURN VALUE

      returns newly created and encoded ASImage on success, NULL of failure.

- DESCRIPTION

      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()

- NAME

  colorize_asimage_vector()

  creates ASImage from double precision indexed image data - usefull for scientific visualisation.

- SYNOPSIS

      Bool colorize_asimage_vector( ASVisual *asv, ASImage *im,
                                       ASVectorPalette *palette,
                                    ASAltImFormats out_format,
                                    int quality );

- INPUTS

  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

- RETURN VALUE

      True on success, False on failure.

- DESCRIPTION

      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()

- NAME

  create_asimage_from_vector()

  - convinience function allowing to create new ASImage, set its vector data and colorize it using palette - all in one step.

- SYNOPSIS

      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 );

- INPUTS

  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

- RETURN VALUE

      New ASImage  on success, NULL on failure.

- SEE ALSO

      colorize_asimage_vector(), create_asimage(), set_asimage_vector()

libAfterImage/transform/slice_asimage2()

- NAME

  slice_asimage2()

  - slice ASImage leaving its corners intact, and scaling the middle part.

- SYNOPSIS

      ASImage*
      slice_asimage2( ASVisual *asv, ASImage *src,
                  int slice_x_start, int slice_x_end,
                  int slice_y_start, int slice_y_end,
                  int to_width,
                  int to_height,
                  Bool scaled,
                  ASAltImFormats out_format,
                  unsigned int compression_out, int quality );

- INPUTS

  asv
    - pointer to valid ASVisual structure
  src
    - source ASImage.
  slice_x_start
    - ending of the left corners
  slice_x_end
    - begining of the right corners
  slice_y_start
    - ending of the top corners
  slice_y_end
    - begining of the bottom corners
  to_width
    - width of the generated image;
  to_height
    - height of the generated image;
  scaled
    - if True - middle part of the image will be scaled, otherwise - tiled;
  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.

- RETURN VALUE

      New ASImage  on success, NULL on failure.

- SEE ALSO

      scale_asimage(), tile_asimage()

Preface Introduction Topic index Glossary Back to Top

AfterStep version 2.2.11