bitmaps.c

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
//     
//    __                                ______
//   / /_______________  ____  ___     / ____/
//  / __/ ___/ ___/ __ \/ __ \/ _ \   /___ )  
// / /_(__  ) /__/ /_/ / /_/ /  __/  ____/ /  
// \__/____/\___/\____/ .___/\___/  /_____/   
//                   /_/                      
//     
/// \file bitmaps.c 
/// Definitions of bitmap functions.
/// \example bitmaps01.c
/// \example bitmaps02.c
/// \example bitmaps03.c
/// \example bitmaps04.c
/// \example bitmaps05.c
////////////////////////////////////////////////////////////////////////////////


#include "../include/tscope5/bitmaps.h"
#include "../include/tscope5/display.h"
#include "../include/tscope5/graphics.h"
#include "../include/tscope5/bitmaps_internal.h"
#include "../include/tscope5/system_internal.h"
#include "../include/tscope5/graphics_internal.h"
#include "../include/tscope5/display_internal.h"

#include <math.h>


////////////////////////////////////////////////////////////////////////////////
/// @name Loading bitmaps
/// Bitmaps can either be read from a file, or empty bitmaps can be generated.
//@{
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
/// Create a bitmap.
///
/// \param w Width of the bitmap.
/// \param h Height of the bitmap.
///
/// \return A pointer to the newly created bitmap.
///
/// The default background color of the newly created bitmap 
/// is the same as the display.
////////////////////////////////////////////////////////////////////////////////
TS5_BITMAP *ts5_alloc_bitmap(double w, double h)
{
    ts5_check_bitmaps("ts5_alloc_bitmap");
    ts5_log(TS5_LOGLEVEL_2, "ts5_alloc_bitmap(%f,%f)\n", w, h);

    if (_ts5_status.graphics.coordinate_scale 
            == TS5_RELATIVE_COORDINATES) {
        w *= _ts5_status.graphics.target_width;
        h *= _ts5_status.graphics.target_height;
    }

    w *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    h *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    
    TS5_BITMAP *map;
    map = al_create_bitmap(w, h);

    if (map == NULL) {
        ts5_fatal("ts5_alloc_bitmap: could not make bitmap\n");
    }

    TS5_BITMAP *oldval = ts5_set_drawing_target(map);
    ts5_clear_display();
    ts5_set_drawing_target(oldval);

    return map;
}


////////////////////////////////////////////////////////////////////////////////
/// Open a bitmap from a file.
///
/// \param file Path to the bitmap file.
///
/// \return A pointer to the newly created bitmap.
///
/// Available bitmap types are: bmp, pcx, tga, jpeg and png.
////////////////////////////////////////////////////////////////////////////////
TS5_BITMAP *ts5_read_bitmap(const char *file)
{
    ts5_check_bitmaps("ts5_read_bitmap");
    ts5_log(TS5_LOGLEVEL_2, "ts5_read_bitmap(%s)\n", file);

    TS5_BITMAP *map1, *map2;
    map1 = al_load_bitmap(file);

    if (map1 == NULL) {
        ts5_fatal("ts5_read_bitmap: could not read bitmap\n");
    }

    al_convert_bitmap(map1);
    
    double w1 = al_get_bitmap_width(map1);
    double h1 = al_get_bitmap_height(map1);
    
    double w2 = w1 * _ts5_status.display[_ts5_status.active_display].sampling_factor;
    double h2 = h1 * _ts5_status.display[_ts5_status.active_display].sampling_factor;
    
    map2 = al_create_bitmap(w2, h2);

    TS5_BITMAP *oldmap = ts5_set_drawing_target(map2);
        
    al_draw_scaled_bitmap(map1, 0.0, 0.0, w1, h1, 
                            0.0, 0.0, w2, h2, 0);

    ts5_set_drawing_target(oldmap);
    al_destroy_bitmap(map1);

    return map2;
}


////////////////////////////////////////////////////////////////////////////////
/// Write a bitmap.
///
/// \param file Path to the bitmap file.
/// \param map Pointer to the bitmap that will be written.
///
/// The extension specifies the file type. 
/// Available bitmap types are: bmp, pcx, tga, jpeg and png.
///
/// Useful for saving screenshots of the experiment.
///
/// Useful for creating complex stimuli beforehand.
////////////////////////////////////////////////////////////////////////////////
void ts5_write_bitmap(const char *file, TS5_BITMAP *map)
{
    ts5_check_bitmaps("ts5_write_bitmap");
    ts5_log(TS5_LOGLEVEL_2, "ts5_write_bitmap(%s,%p)\n", file, map);

    double w, w2, h, h2;
    ts5_get_bitmap_size(map, &w, &h);

    w2 = w;
    h2 = h;
    
    w *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    h *= _ts5_status.display[_ts5_status.active_display].sampling_factor;

    TS5_BITMAP *map2 = al_create_bitmap(w2, h2);

    TS5_BITMAP *oldmap = ts5_set_drawing_target(map2);
        
    al_draw_scaled_bitmap(map, 0.0, 0.0, w, h, 
                            0.0, 0.0, w2, h2, 0);

    ts5_set_drawing_target(oldmap);

    if (!al_save_bitmap(file, map2)) {
        ts5_fatal("ts5_write_bitmap: could not write bitmap\n");
    }
    al_destroy_bitmap(map2);
}


////////////////////////////////////////////////////////////////////////////////
/// Free the memory used by a bitmap.
///
/// \param map pointer to the bitmap that will be freed.
///
/// This function should be called at the end of the program for
/// each bitmap allocated or read by the user.
////////////////////////////////////////////////////////////////////////////////
void ts5_free_bitmap(TS5_BITMAP *map)
{
    ts5_check_bitmaps("ts5_free_bitmap");
    ts5_log(TS5_LOGLEVEL_2, "ts5_free_bitmap(%p)\n", map);

    al_destroy_bitmap(map);
    map = NULL;
}


////////////////////////////////////////////////////////////////////////////////
//@}
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
/// @name Query bitmap dimensions
/// The dimensions of a bitmap can be queried using the functions below:
//@{
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
/// Get the size of a bitmap in pixels.
///
/// \param map The bitmap that will be queried.
/// \param w Variable that will store the width.
/// \param h Variable that will store the height.
///
/// You can pass NULL for values you are not interested in.
///
/// ts5_alloc_bitmap(), ts5_read_bitmap(), primitives.c, textio.c
////////////////////////////////////////////////////////////////////////////////
void ts5_get_bitmap_size(TS5_BITMAP *map, double *w, double *h)
{
    ts5_check_bitmaps("ts5_get_bitmap_size");
    ts5_log(TS5_LOGLEVEL_5, "ts5_get_bitmap_size(%p,%p,%p)\n", map, w, h);

    if (!map) {
        ts5_fatal("ts5_get_bitmap_size: bitmap pointer is null\n");
    }

    if (w) {
        *w = al_get_bitmap_width(map) / 
                _ts5_status.display[_ts5_status.active_display].sampling_factor;
    }

    if (h) {
        *h = al_get_bitmap_height(map) / 
                _ts5_status.display[_ts5_status.active_display].sampling_factor;
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Get the width of a bitmap in pixels.
///
/// \param map The bitmap that will be queried.
///
/// \return The width of the bitmap.
////////////////////////////////////////////////////////////////////////////////
double ts5_get_bitmap_width(TS5_BITMAP *map)
{
    ts5_check_bitmaps("ts5_get_bitmap_width");
    ts5_log(TS5_LOGLEVEL_5, "ts5_get_bitmap_width(%p)\n", map);

    double w;
    ts5_get_bitmap_size(map, &w, NULL);

    return w;
}


////////////////////////////////////////////////////////////////////////////////
/// Get the height of a bitmap in pixels.
///
/// \param map The bitmap that will be queried.
///
/// \return The height of the bitmap.
////////////////////////////////////////////////////////////////////////////////
double ts5_get_bitmap_height(TS5_BITMAP *map)
{
    ts5_check_bitmaps("ts5_get_bitmap_height");
    ts5_log(TS5_LOGLEVEL_5, "ts5_get_bitmap_width(%d)\n", map);

    double h;
    ts5_get_bitmap_size(map, NULL, &h);

    return h;
}


////////////////////////////////////////////////////////////////////////////////
//@}
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
/// @name Drawing on bitmaps
/// Text/primitives output that is normally drawn on the display can
/// be redirected to a bitmap.
//@{
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
/// Set the active drawing target.
///
/// \param target Pointer to the bitmap that will be used 
/// for drawing operations.
///
/// \return A pointer to the previous active drawing target.
////////////////////////////////////////////////////////////////////////////////
TS5_BITMAP *ts5_set_drawing_target(TS5_BITMAP * target)
{
    ts5_check_display("ts5_set_drawing_target");
    ts5_log(TS5_LOGLEVEL_4, "ts5_set_drawing_target(%p)\n", target);

    if (target == NULL) {
        ts5_fatal("ts5_set_drawing_target: target is a NULL pointer\n");
    }

    TS5_BITMAP *retval = _ts5_data.target;
    _ts5_data.target = target;
    al_set_target_bitmap(_ts5_data.target);

    _ts5_status.graphics.target_width = 
        ts5_get_bitmap_width(_ts5_data.target);
    
    _ts5_status.graphics.target_height = 
        ts5_get_bitmap_height(_ts5_data.target);

    return retval;
}


////////////////////////////////////////////////////////////////////////////////
/// Get the active drawing target.
///
/// \return A pointer to the active drawing target.
////////////////////////////////////////////////////////////////////////////////
TS5_BITMAP *ts5_get_drawing_target()
{
    ts5_check_display("ts5_get_drawing_target");
    ts5_log(TS5_LOGLEVEL_4, "ts5_get_drawing_target()\n");

    return _ts5_data.target;
}


////////////////////////////////////////////////////////////////////////////////
/// Get the total size of the drawing target in pixels.
///
/// \param w Variable that will store the width.
/// \param h Variable that will store the height.
///
/// The drawing target can be either a display or a memory bitmap.
///
/// You can pass NULL for values you are not interested in.
////////////////////////////////////////////////////////////////////////////////
void ts5_get_target_size(double *w, double *h)
{
    ts5_check_graphics("ts5_get_target_size");
    ts5_log(TS5_LOGLEVEL_4, "ts5_get_target_size(%p,%p)\n", w, h);

    if (w) {
        *w = _ts5_status.graphics.target_width;
    }

    if (h) {
        *h = _ts5_status.graphics.target_height;
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Get the total width of the drawing target in pixels.
///
/// \return the width of the drawing target.
///
/// The drawing target can be either a display or a memory bitmap.
////////////////////////////////////////////////////////////////////////////////
double ts5_get_target_width()
{
    ts5_check_graphics("ts5_get_target_width");
    ts5_log(TS5_LOGLEVEL_4, "ts5_get_target_width()\n");

    double w;
    ts5_get_target_size(&w, NULL);

    return w;
}


////////////////////////////////////////////////////////////////////////////////
/// Get the total height of the drawing target in pixels.
///
/// \return the height of the drawing target.
///
/// The drawing target can be either a display or a memory bitmap.
////////////////////////////////////////////////////////////////////////////////
double ts5_get_target_height()
{
    ts5_check_graphics("ts5_get_target_height");
    ts5_log(TS5_LOGLEVEL_4, "ts5_get_target_height()\n");

    double h;
    ts5_get_target_size(NULL, &h);

    return h;

}


////////////////////////////////////////////////////////////////////////////////
//@}
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
/// @name Drawing bitmaps on the display
/// 
/// The destination coordinates of the bitmap drawing functions below are 
/// interpreted dependent on the coordinate system used. 
/// - When using the Cartesian coordinate system, 
///   bitmaps are centered around the destination coordinates. 
/// - When using the Display coordinate system, 
///   the destination coordinates correspond to the 
///   upper left corner of the bitmap.
//@{
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
/// Draw a bitmap.
///
/// \param map The bitmap that will be drawn.
/// \param dx Horizontal position where it will be drawn.
/// \param dy Vertical position where it will be drawn.
////////////////////////////////////////////////////////////////////////////////
void ts5_draw_bitmap(TS5_BITMAP *map, double dx, double dy)
{
    ts5_check_bitmaps2("ts5_draw_bitmap", map);
    ts5_log(TS5_LOGLEVEL_5, "ts5_draw_bitmap(%p,%f,%f)\n", map, dx, dy);

    if (_ts5_status.graphics.coordinate_scale 
            == TS5_RELATIVE_COORDINATES) {
        dx = ts5_relative_to_absolute_coordinate_x(dx);
        dy = ts5_relative_to_absolute_coordinate_y(dy);
    }

    if (_ts5_status.graphics.coordinate_system 
            == TS5_CARTESIAN_COORDINATES) {
                
        dx = ts5_cartesian_to_display_coordinate_x(dx) 
                - ts5_get_bitmap_width(map) / 2.0;
        
        dy = ts5_cartesian_to_display_coordinate_y(dy) 
                - ts5_get_bitmap_height(map) / 2.0;
    }

    dx *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    dy *= _ts5_status.display[_ts5_status.active_display].sampling_factor;

    al_draw_bitmap(map, dx, dy, 0);
}


////////////////////////////////////////////////////////////////////////////////
/// Draw a flipped bitmap.
///
/// \param map The bitmap that will be drawn.
/// \param dx Horizontal position where it will be drawn.
/// \param dy Vertical position where it will be drawn.
/// \param flip Direction of the flip. 
/// Can be TS5_FLIP_HORIZONTAL, TS5_FLIP_VERTICAL or TS5_FLIP_BOTH.
////////////////////////////////////////////////////////////////////////////////
void ts5_draw_flipped_bitmap(TS5_BITMAP *map, double dx, double dy, 
                                const int flip)
{
    ts5_check_bitmaps2("ts5_draw_flipped_bitmap", map);
    ts5_log(TS5_LOGLEVEL_5, "ts5_draw_flipped_bitmap(%p,%f,%f,%d)\n", 
                map, dx, dy, flip);

    if (flip != TS5_FLIP_HORIZONTAL && flip != TS5_FLIP_VERTICAL 
            && flip != TS5_FLIP_BOTH) {
        ts5_fatal("%s: %s %s\n", "ts5_draw_flipped_bitmap", 
                    "flip should be TS5_FLIP_HORIZONTAL,",
                    "TS5_FLIP_VERTICAL or TS5_FLIP_BOTH");
    }

    if (_ts5_status.graphics.coordinate_scale 
            == TS5_RELATIVE_COORDINATES) {
        dx = ts5_relative_to_absolute_coordinate_x(dx);
        dy = ts5_relative_to_absolute_coordinate_y(dy);
    }

    if (_ts5_status.graphics.coordinate_system 
            == TS5_CARTESIAN_COORDINATES) {
                
        dx = ts5_cartesian_to_display_coordinate_x(dx) 
                - ts5_get_bitmap_width(map) / 2.0;
        
        dy = ts5_cartesian_to_display_coordinate_y(dy) 
                - ts5_get_bitmap_height(map) / 2.0;
    }

    dx *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    dy *= _ts5_status.display[_ts5_status.active_display].sampling_factor;

    al_draw_bitmap(map, dx, dy, flip);
}


////////////////////////////////////////////////////////////////////////////////
/// Draw a tinted bitmap.
///
/// \param map The bitmap that will be drawn.
/// \param tint The tint color. 
/// All colors in the bitmap are multiplied with the color specified in tint.
/// \param dx Horizontal position where it will be drawn.
/// \param dy Vertical position where it will be drawn.
////////////////////////////////////////////////////////////////////////////////
void ts5_draw_tinted_bitmap(TS5_BITMAP *map, TS5_COLOR tint, 
                            double dx, double dy)
{
    ts5_check_bitmaps2("ts5_draw_tinted_bitmap", map);
    ts5_log(TS5_LOGLEVEL_5, "ts5_draw_tinted_bitmap(%p,(%f,%f,%f,%f),%f,%f)\n",
                map, tint.r, tint.g, tint.b, tint.a, dx, dy);

    if (_ts5_status.graphics.coordinate_scale 
            == TS5_RELATIVE_COORDINATES) {
        dx = ts5_relative_to_absolute_coordinate_x(dx);
        dy = ts5_relative_to_absolute_coordinate_y(dy);
    }

    if (_ts5_status.graphics.coordinate_system 
            == TS5_CARTESIAN_COORDINATES) {
                
        dx = ts5_cartesian_to_display_coordinate_x(dx) 
                - ts5_get_bitmap_width(map) / 2.0;
        
        dy = ts5_cartesian_to_display_coordinate_y(dy) 
                - ts5_get_bitmap_height(map) / 2.0;
    }

    dx *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    dy *= _ts5_status.display[_ts5_status.active_display].sampling_factor;

    al_draw_tinted_bitmap(map, tint, dx, dy, 0);
}


////////////////////////////////////////////////////////////////////////////////
/// Draw a region of a bitmap.
///
/// \param map The bitmap that will be drawn.
/// \param sx1 Horizontal coordinate of the first corner or the region.
/// \param sy1 Vertical coordinate of the first corner or the region.
/// \param sx2 Horizontal coordinate of the second corner or the region.
/// \param sy2 Vertical coordinate of the second corner or the region.
/// \param dx Horizontal position where it will be drawn.
/// \param dy Vertical position where it will be drawn.
////////////////////////////////////////////////////////////////////////////////
void ts5_draw_bitmap_region(TS5_BITMAP *map, double sx1, double sy1, 
                            double sx2, double sy2, double dx, double dy)
{
    ts5_check_bitmaps2("ts5_draw_bitmap_region", map);
    ts5_log(TS5_LOGLEVEL_5, "ts5_draw_bitmap_region(%p,%f,%f,%f,%f,%f,%f)\n",
                map, sx1, sy1, sx2, sy2, dx, dy);

    if (_ts5_status.graphics.coordinate_scale 
            == TS5_RELATIVE_COORDINATES) {
        dx = ts5_relative_to_absolute_coordinate_x(dx);
        dy = ts5_relative_to_absolute_coordinate_y(dy);
        TS5_BITMAP *oldval = ts5_set_drawing_target (map);
        sx1 = ts5_relative_to_absolute_coordinate_x(sx1);
        sx2 = ts5_relative_to_absolute_coordinate_x(sx2);
        sy1 = ts5_relative_to_absolute_coordinate_y(sy1);
        sy2 = ts5_relative_to_absolute_coordinate_y(sy2);
        ts5_set_drawing_target(oldval);
    }

    double width = fabs(sx2 - sx1);
    double height = fabs(sy2 - sy1);
    double x = sx1 < sx2 ? sx1 : sx2;
    double y = sy1 < sy2 ? sy1 : sy2;

    if (_ts5_status.graphics.coordinate_system 
            == TS5_CARTESIAN_COORDINATES) {
        dx = ts5_cartesian_to_display_coordinate_x(dx - width / 2.0);
        dy = ts5_cartesian_to_display_coordinate_y(height / 2.0 - dy);
        x = x + ts5_get_bitmap_width(map) / 2.0;
        y = y + ts5_get_bitmap_height(map) / 2.0;
    }
    
    x *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    y *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    width *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    height *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    dx *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    dy *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    

    al_draw_bitmap_region(map, x, y, width, height, dx, dy, 0);
}


////////////////////////////////////////////////////////////////////////////////
/// Draw a rotated bitmap.
///
/// \param map The bitmap that will be drawn.
/// \param cx Horizontal coordinate of the center of rotation.
/// \param cy Certical coordinate of the center of rotation.
/// \param angle The angle of rotation in degrees 
/// (positive is counter clockwise, negative is clockwise).
/// \param dx Horizontal position where it will be drawn.
/// \param dy Vertical position where it will be drawn.
///
/// The center of rotation (cx,cy) will be drawn at (dx,dy).
////////////////////////////////////////////////////////////////////////////////
void ts5_draw_rotated_bitmap(TS5_BITMAP *map, double cx, double cy, 
                                double angle, double dx, double dy)
{
    ts5_check_bitmaps2("ts5_draw_rotated_bitmap", map);
    ts5_log(TS5_LOGLEVEL_5, "ts5_draw_rotated_bitmap(%p,%f,%f,%f,%f,%f)\n", 
                map, cx, cy, angle, dx, dy);

    if (_ts5_status.graphics.coordinate_scale 
            == TS5_RELATIVE_COORDINATES) {
        dx = ts5_relative_to_absolute_coordinate_x(dx);
        dy = ts5_relative_to_absolute_coordinate_y(dy);
        TS5_BITMAP *oldval = ts5_set_drawing_target (map);
        cx = ts5_relative_to_absolute_coordinate_x(cx);
        cy = ts5_relative_to_absolute_coordinate_y(cy);
        ts5_set_drawing_target(oldval);
    }

    if (_ts5_status.graphics.coordinate_system
            == TS5_CARTESIAN_COORDINATES) {
        dx = ts5_cartesian_to_display_coordinate_x(dx);
        dy = ts5_cartesian_to_display_coordinate_y(dy);
        cx = ts5_get_bitmap_width(map) / 2.0 + cx;
        cy = ts5_get_bitmap_height(map) / 2.0 - cy;
    }

    angle = - angle * TS5_PI / 180.0;

    cx *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    cy *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    dx *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    dy *= _ts5_status.display[_ts5_status.active_display].sampling_factor;

        al_draw_rotated_bitmap(map, cx, cy, dx, dy, angle, 0);
}


////////////////////////////////////////////////////////////////////////////////
/// Draw a scaled bitmap.
///
/// \param map The bitmap that will be drawn.
/// \param xratio The scaling factor in the horizontal direction.
/// \param yratio The scaling factor in the vertical direction.
/// \param dx Horizontal position where it will be drawn.
/// \param dy Vertical position where it will be drawn.
////////////////////////////////////////////////////////////////////////////////
void ts5_draw_scaled_bitmap(TS5_BITMAP *map, double xratio, double yratio, 
                            double dx, double dy)
{
    ts5_check_bitmaps2("ts5_draw_scaled_bitmap", map);
    ts5_log(TS5_LOGLEVEL_5, "ts5_draw_scaled_bitmap(%p,%f,%f,%f,%f)\n", 
                map, xratio, yratio, dx, dy);

    double w = ts5_get_bitmap_width(map);
    double h = ts5_get_bitmap_height(map);

    if (_ts5_status.graphics.coordinate_scale 
            == TS5_RELATIVE_COORDINATES) {
        dx = ts5_relative_to_absolute_coordinate_x(dx);
        dy = ts5_relative_to_absolute_coordinate_y(dy);
    }

    if (_ts5_status.graphics.coordinate_system 
            == TS5_CARTESIAN_COORDINATES) {
        dx = ts5_cartesian_to_display_coordinate_x(dx) - w * xratio / 2.0;
        dy = ts5_cartesian_to_display_coordinate_y(dy) - h * yratio / 2.0;
    }

    w *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    h *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    dx *= _ts5_status.display[_ts5_status.active_display].sampling_factor;
    dy *= _ts5_status.display[_ts5_status.active_display].sampling_factor;

    al_draw_scaled_bitmap(map, 0.0, 0.0, w, h, dx, dy, 
                            w * xratio, h * yratio, 0);
}