HomeHomeHomeHomeHome
 
Home
News
Downloads
Documentation
Looks and Themes
Icons, Clipart, etc.
Mailing List and Contacts
aterm terminal emulator
 
title_image
 Preface  Introduction  API Topic index  API Glossary  F.A.Q.  Copyright

ASImage Transformationstransformations 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/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()
    


AfterStep Documentation   -   October 2005     ( 80% complete )

lowbarimage