NAME

asimage - internal structures and methods used for image manipulation in libAfterImage libAfterImage/asimage.h

NAMEasimage

defines main structures and function for image manipulation.

DESCRIPTION

libAfterImage provides powerful functionality to load, store and transform images. It allows for smaller memory utilization by utilizing run-length encoding of the image data. There could be different levels of compression selected, allowing to choose best speed/memory ratio.

AUTHOR

Sasha Vasko <sasha at aftercode dot net>
libAfterImage/ASAltImFormats

NAMEASAltImFormats

identifies what output format should be used for storing the transformation result. Also identifies what data is currently stored in alt member of ASImage structure.

SOURCE

typedef enum {
ASA_ASImage = 0,
ASA_XImage,
ASA_MaskXImage,
/* temporary XImages to be allocated from static pool of memory :*/
ASA_ScratchXImage,
ASA_ScratchMaskXImage,

ASA_ScratchXImageAndAlpha,

ASA_ARGB32,
ASA_Vector, /* This cannot be used for transformation's result
* format */
ASA_Formats }ASAltImFormats;

libAfterImage/ASImage

NAMEASImage

is the main structure to hold image data.

DESCRIPTION

Images are stored internally split into ARGB channels, each split into scanline. Actuall data is stored using ASStorage container. Inside ASImage data structure we only store IDs pointing to data in ASStorage ASStorage implements reference counting, data compression, automatic memory defragmentation and other nice things.

SOURCE

struct ASImageAlternative; struct ASImageManager;

/* magic number identifying ASFont data structure */ #define MAGIC_ASIMAGE 0xA3A314AE

typedef struct ASImage {

unsigned long magic ;

unsigned int width, height; /* size of the image in pixels */

/* arrays of storage ids of stored scanlines of particular channel: */
ASStorageID *alpha,
*red,
*green,
*blue;

ASStorageID *channels[IC_NUM_CHANNELS];
/* merely a shortcut so we can
* somewhat simplify code in loops */

ARGB32 back_color ; /* background color of the image, so
* we could discard everything that
* matches it, and then restore it
* back. */

struct ASImageAlternative
{ /* alternative forms of ASImage storage : */
XImage *ximage ; /* pointer to XImage created as the
* result of transformations whenever
* we request it to output into
* XImage ( see to_xim parameter ) */
XImage *mask_ximage ; /* XImage of depth 1 that could be
* used to store mask of the image */
ARGB32 *argb32 ; /* array of widthxheight ARGB32
* values */
double *vector ; /* scientific data that should be used
* in conjunction with
* ASScientificPalette to produce
* actuall ARGB data */
}alt;

struct ASImageManager *imageman; /* if not null - then image could be
* referenced by some other code */
int ref_count ;/* this will tell us what us how many
* times */

char *name ; /* readonly copy of image name
* this name is a hash value used to
* store image in the image-man's hash,
* and gets freed automagically on image
* removal from hash */

#define ASIM_DATA_NOT_USEFUL (0x01<<0) #define ASIM_VECTOR_TOP2BOTTOM (0x01<<1) #define ASIM_XIMAGE_8BIT_MASK (0x01<<2) #define ASIM_NO_COMPRESSION (0x01<<3) /* Do not use compression to
* save some computation time
*/ #define ASIM_ALPHA_IS_BITMAP (0x01<<4) #define ASIM_RGB_IS_BITMAP (0x01<<5) #define ASIM_XIMAGE_NOT_USEFUL (0x01<<6) #define ASIM_NAME_IS_FILENAME (0x01<<7)

ASFlagType flags ; /* combination of the above flags */

} ASImage;

libAfterImage/ASImageManager

NAMEASImageManager

structure to be used to maintain list of loaded images for given set of search paths and gamma. Images are named and reference counted.

SOURCE

typedef struct ASImageManager {
ASHashTable *image_hash ;
/* misc stuff that may come handy : */
char *search_path[MAX_SEARCH_PATHS+1];
double gamma ; }ASImageManager;

libAfterImage/LIMITS

NAMEMAX_IMPORT_IMAGE_SIZE

effectively limits size of the allowed images to be loaded from files. That is needed to be able to filter out corrupt files. MAX_BEVEL_OUTLINE Limit on bevel outline to be drawn around the image. MAX_SEARCH_PATHS Number of search paths to be used while loading images from files.

#define MAX_IMPORT_IMAGE_SIZE 8000 #define MAX_BEVEL_OUTLINE 100 #define MAX_SEARCH_PATHS 8 /* prudently limiting ourselfs */

libAfterImage/ASVectorPalette

NAMEASVectorPalette

contains palette allowing us to map double values in vector image data into actuall ARGB values.

SOURCE

typedef struct ASVectorPalette {
unsigned int npoints ;
double *points ;
CARD16 *channels[IC_NUM_CHANNELS] ; /* ARGB data for key points. */
ARGB32 default_color; }ASVectorPalette;

libAfterImage/asimage/ASImageLayer

NAMEASImageLayer

specifies parameters of the image superimposition.

DESCRIPTION

libAfterImage allows for simultaneous superimposition (overlaying) of arbitrary number of images. To facilitate this ASImageLayer structure has been created in order to specify parameters of each image participating in overlaying operation. Images need not to be exact same size. For each image its position on destination is specified via dst_x and dst_y data members. Each image maybe tiled and clipped to fit into rectangle specified by clip_x, clip_y, clip_width, clip_height ( in image coordinates - not destination ). If image is missing, then area specified by dst_x, dst_y, clip_width, clip_height will be filled with solid_color. Entire image will be tinted using tint parameter prior to overlaying. Bevel specified by bevel member will be drawn over image prior to overlaying. Specific overlay method has to be specified. merge_scanlines method is pointer to a function, that accepts 2 ASScanlines as arguments and performs overlaying of first one with the second one. There are 15 different merge_scanline methods implemented in libAfterImage, including alpha-blending, tinting, averaging, HSV and HSL colorspace operations, etc.

NOTES

ASImageLayer s could be organized into chains using next pointers. Since there could be a need to rearrange layers and maybe bypass some layers - we need to provide for flexibility, while at the same time allowing for simplicity of arrays. As the result next pointers could be used to link together continuous arrays of layer, like so : array1: [layer1(next==NULL)][layer2(next!=NULL)]
____________________________|
V array2: [layer3(next==NULL)][layer4(next==NULL)][layer5(next!=NULL)]
________________________________________________|
V array3: [layer6(next==NULL)][layer7(next==layer7)]
^______|

While iterating through such a list we check for two conditions - exceeding count of layers and layer pointing to self. When any of that is met - we stopping iteration.

SOURCE

typedef struct ASImageLayer {
ASImage *im;
ARGB32 solid_color ; /* If im == NULL, then fill
* the area with this color. */

int dst_x, dst_y; /* placement in overall
* composition */

/* clip area could be partially outside of the image -
* image gets tiled in it */
int clip_x, clip_y;
unsigned int clip_width, clip_height;

ARGB32 tint ; /* if 0 - no tint */
struct ASImageBevel *bevel ; /* border to wrap layer with
* (for buttons, etc.)*/

/* if image is clipped then we need to specify offsets of bevel as
* related to clipped rectangle. Normally it should be :
* 0, 0, im->width, im->height. And if width/height left 0 - it will
* default to this values. Note that clipped image MUST be entirely
* inside the bevel rectangle. !!!*/
int bevel_x, bevel_y;
unsigned int bevel_width, bevel_height;

int merge_mode ; /* reserved for future use */
merge_scanlines_func merge_scanlines ; /* overlay method */
struct ASImageLayer *next; /* optional pointer to next
* layer. If it points to
* itself - then end of the
* chain.*/
void *data; /* hook to hung data on */ }ASImageLayer;

libAfterImage/asimage/GRADIENT_TYPE_flags

FUNCTION

Combination of this flags defines the way gradient is rendered.

NAMEGRADIENT_TYPE_DIAG

when set it will cause gradient's direction to be rotated by 45 degrees GRADIENT_TYPE_ORIENTATION will cause gradient direction to be rotated by 90 degrees. When combined with GRADIENT_TYPE_DIAG - rotates gradient direction by 135 degrees.

SOURCE

#define GRADIENT_TYPE_DIAG (0x01<<0) #define GRADIENT_TYPE_ORIENTATION (0x01<<1) #define GRADIENT_TYPE_MASK (GRADIENT_TYPE_ORIENTATION| \
GRADIENT_TYPE_DIAG)

libAfterImage/asimage/GRADIENT_TYPE

FUNCTION

This are named combinations of above flags to define type of gradient.

NAMEGRADIENT_Left2Right

normal left-to-right gradient. GRADIENT_TopLeft2BottomRight diagonal top-left to bottom-right. GRADIENT_Top2Bottom vertical top to bottom gradient. GRADIENT_BottomLeft2TopRight diagonal bottom-left to top-right.

SOURCE

#define GRADIENT_Left2Right 0 #define GRADIENT_TopLeft2BottomRight GRADIENT_TYPE_DIAG #define GRADIENT_Top2Bottom GRADIENT_TYPE_ORIENTATION #define GRADIENT_BottomLeft2TopRight (GRADIENT_TYPE_DIAG| \
GRADIENT_TYPE_ORIENTATION)

libAfterImage/ASGradient

NAMEASGradient

describes how gradient is to be drawn.

DESCRIPTION

libAfterImage includes functionality to draw multipoint gradients in 4 different directions left->right, top->bottom and diagonal lefttop->rightbottom and bottomleft->topright. Each gradient described by type, number of colors (or anchor points), ARGB values for each color and offsets of each point from the beginning of gradient in fractions of entire length. There should be at least 2 anchor points. very first point should have offset of 0. and last point should have offset of 1. Gradients are drawn in ARGB colorspace, so it is possible to have semitransparent gradients.

SOURCE

typedef struct ASGradient {
int type; /* see GRADIENT_TYPE above */

int npoints; /* number of anchor points */
ARGB32 *color; /* ARGB color values for each anchor point*/
double *offset; /* offset of each point from the beginning in
* fractions of entire length */ }ASGradient;

libAfterImage/asimage/flip

FUNCTION

This are flags that define rotation angle.

NAMEFLIP_VERTICAL

defines rotation of 90 degrees counterclockwise. FLIP_UPSIDEDOWN defines rotation of 180 degrees counterclockwise. combined they define rotation of 270 degrees counterclockwise.

SOURCE

#define FLIP_VERTICAL (0x01<<0) #define FLIP_UPSIDEDOWN (0x01<<1) #define FLIP_MASK (FLIP_UPSIDEDOWN|FLIP_VERTICAL)

libAfterImage/asimage/flip_gradient()

NAMEflip_gradient()

- rotates gradient in 90 degree increments.

SEE ALSO

SEE ALSO

SEE ALSO

SEE ALSO

RETURN VALUE

RETURN VALUE

RETURN VALUE

RETURN VALUE

RETURN VALUE

RETURN VALUE

RETURN VALUE