Provided by: libafterimage-dev_2.2.12-15build1_amd64 
NAME
asscale - demonstrates image loading and scaling libAfterImage/tutorials/ASScale
NAMEASScale
SYNOPSIS
Simple program based on libAfterImage to scale an image.
DESCRIPTION
We will load image and scale it up to new size, specified as command line arguments We
then display the result in simple window. After that we would want to wait, until user
closes our window.
In this tutorial we will only explain new steps, not described in previous tutorial. New
steps described in this tutorial are : ASScale.1. Parsing geometry spec. ASScale.2.
Scaling ASImage.
SEE ALSO
Tutorial 1: ASView - explanation of basic steps needed to use
libAfterImage and some other simple things.
SOURCE
#include "../afterbase.h" #include "../afterimage.h" #include "common.h"
void usage() {
printf( "Usage: asscale [-h]|[image [WIDTH[xHEIGHT]]]\n");
printf( "Where: image - is image filename.\n");
printf( " WIDTH - width to scale image to.( Naturally :)\n");
printf( " HEIGHT- height to scale image to.\n"); }
int main(int argc, char* argv[]) {
char *image_file = "rose512.jpg" ;
int dummy, geom_flags = 0;
unsigned int to_width, to_height ;
ASImage *im ;
int clip_x = 0, clip_y = 0, clip_width = 0, clip_height = 0 ;
int slice_x_start = 0, slice_x_end = 0, slice_y_start = 0, slice_y_end = 0 ;
Bool slice_scale = False ;
Display *dpy = NULL;
/* see ASView.1 : */
set_application_name( argv[0] );
if( argc > 1 )
{
int i = 2;
if( strncmp( argv[1], "-h", 2 ) == 0 )
{
usage();
return 0;
}
image_file = argv[1] ;
if( argc > 2 ) /* see ASScale.1 : */
geom_flags = XParseGeometry( argv[2], &dummy, &dummy,
&to_width, &to_height );
while( ++i < argc )
{
if( strncmp( argv[i], "-sx1", 4 ) == 0 && i+1 < argc )
slice_x_start = atoi(argv[++i]) ;
else if( strncmp( argv[i], "-sx2", 4 ) == 0 && i+1 < argc )
slice_x_end = atoi(argv[++i]) ;
else if( strncmp( argv[i], "-sy1", 4 ) == 0 && i+1 < argc )
slice_y_start = atoi(argv[++i]) ;
else if( strncmp( argv[i], "-sy2", 4 ) == 0 && i+1 < argc )
slice_y_end = atoi(argv[++i]) ;
else if( strncmp( argv[i], "-cx", 4 ) == 0 && i+1 < argc )
clip_x = atoi(argv[++i]) ;
else if( strncmp( argv[i], "-cy", 4 ) == 0 && i+1 < argc )
clip_y = atoi(argv[++i]) ;
else if( strncmp( argv[i], "-cwidth", 7 ) == 0 && i+1 < argc )
clip_width = atoi(argv[++i]) ;
else if( strncmp( argv[i], "-cheight", 8 ) == 0 && i+1 < argc )
clip_height = atoi(argv[++i]) ;
else if( strncmp( argv[i], "-ss", 3 ) == 0 )
slice_scale = True ;
}
}else
{
show_warning( "no image file or scale geometry - defaults used:"
" \"%s\" ",
image_file );
usage();
}
/* see ASView.2 : */
im = file2ASImage( image_file, 0xFFFFFFFF, SCREEN_GAMMA, 0, getenv("IMAGE_PATH"),
NULL );
if( im != NULL )
{
ASVisual *asv ;
ASImage *scaled_im ;
/* Making sure tiling geometry is sane : */
if( !get_flags(geom_flags, WidthValue ) )
to_width = im->width*2 ;
if( !get_flags(geom_flags, HeightValue ) )
to_height = im->height*2;
printf( "%s: scaling image \"%s\" to %dx%d by factor of %fx%f\n",
get_application_name(), image_file, to_width, to_height,
(double)to_width/(double)(im->width),
(double)to_height/(double)(im->height) );
#ifndef X_DISPLAY_MISSING
{
Window w ;
int screen, depth ;
dpy = XOpenDisplay(NULL);
_XA_WM_DELETE_WINDOW = XInternAtom( dpy,
"WM_DELETE_WINDOW",
False);
screen = DefaultScreen(dpy);
depth = DefaultDepth( dpy, screen );
/* see ASView.3 : */
asv = create_asvisual( dpy, screen, depth, NULL );
/* see ASView.4 : */
w = create_top_level_window( asv, DefaultRootWindow(dpy),
32, 32,
to_width, to_height, 1, 0, NULL,
"ASScale", image_file );
if( w != None )
{
Pixmap p ;
XMapRaised (dpy, w);
/* see ASScale.2 : */
if( slice_x_start == 0 && slice_x_end == 0 &&
slice_y_start == 0 && slice_y_end == 0 )
{
scaled_im = scale_asimage2( asv, im,
clip_x, clip_y, clip_width,
clip_height,
to_width, to_height,
ASA_XImage, 0,
ASIMAGE_QUALITY_DEFAULT );
}else
{
scaled_im = slice_asimage2( asv, im, slice_x_start, slice_x_end,
slice_y_start, slice_y_end,
to_width, to_height, slice_scale,
ASA_XImage, 0,
ASIMAGE_QUALITY_DEFAULT );
}
destroy_asimage( &im );
/* see ASView.5 : */
p = asimage2pixmap(asv, DefaultRootWindow(dpy), scaled_im,
NULL, True );
/* print_storage(NULL); */
destroy_asimage( &scaled_im );
/* see common.c: set_window_background_and_free() : */
p = set_window_background_and_free( w, p );
}
/* see common.c: wait_closedown() : */
wait_closedown(w);
dpy = NULL;
} #else
asv = create_asvisual( NULL, 0, 0, NULL );
scaled_im = scale_asimage(asv, im, to_width, to_height,
ASA_ASImage, 0,
ASIMAGE_QUALITY_DEFAULT );
/* writing result into the file */
ASImage2file( scaled_im, NULL, "asscale.jpg", ASIT_Jpeg, NULL );
destroy_asimage( &scaled_im );
destroy_asimage( &im ); #endif
}
return 0 ; }
libAfterImage/tutorials/ASScale.1 [2.1]
SYNOPSIS
Step 1. Parsing the geometry.
DESCRIPTION
Geometry can be specified in WIDTHxHEIGHT+X+Y format. Accordingly we use standard X
function to parse it: XParseGeometry. Returned flags tell us what values has been
specified. Since we only need size - we check if it is specified and if not - simply
default it to twice as big as original image. Accordingly we use dummy variable to pass to
XParseGeometry.
EXAMPLE
geom_flags = XParseGeometry( argv[3], &dummy, &dummy,
&to_width, &to_height );
libAfterImage/tutorials/ASScale.2 [2.2]
SYNOPSIS
Step 2. Actual scaling the image.
DESCRIPTION
scale_asimage() scales image both up and down, and is very easy to use - just pass it new
size. In this example we use default quality. Default is equivalent to GOOD which should
be sufficient in most cases. Compression is set to 0 since we do not intend to store image
for long time. Even better - we don't need to store it at all - all we need is XImage, so
we can transfer it to the server easily. That is why to_xim argument is set to
ASA_XImage. As the result obtained ASImage will not have any data in its buffers, but it
will have ximage member set to point to valid XImage. Subsequently we enjoy that
convenience, by setting use_cached to True in call to asimage2pixmap. That ought to save
us a lot of processing.
Scaling algorithm is rather sophisticated and is implementing 4 point interpolation. Which
basically means that we try to approximate each missing point as an extension of the trend
of 4 neighboring points - two on each side. Closest neighbor's have more weight then
outside ones. 2D scaling is performed by scaling each scanline first, and then
interpolating missing scanlines. Scaling down is somewhat skimpier, as it amounts to
simple averaging of the multiple pixels. All calculations are done in integer math on per
channel basis, and with precision 24.8 bits per channel per pixel.
EXAMPLE
scaled_im = scale_asimage( asv, im, to_width, to_height,
ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT );
destroy_asimage( &im );
NOTES
Scaling image up to very large height is much slower then to same width due to algorithm
specifics. Yet even on inferior hardware it yields decent speeds. When we successfully
scaled image - we no longer need the original - getting rid of it so it does not clog
memory.
SEE ALSO
scale_asimage().