The visibility map can be saved at any moment by calling the function:

This function will return a pointer to a newly allocated LqrVMap object, or NULL in case of failure. See also the section "The visibility map objects".

By default, the computed visibility maps are wasted. Instead of saving them individually, it is possible to automatically dump them at the end of the carving process, attaching them to their associated LqrCarver. In order to activate this feature, the following function has to be called:

This will have the effect of dumping the visibility map each time lqr_carver_resize is invoked, and storing it internally. When resizing along both directions, two maps will be dumped, one for each direction.

In order to revert the effect of lqr_carver_set_dump_vmaps, thus stopping the automatic dumping, use the function

Alternatively, the internal storage mechanism can be called over the current visibility map at any given moment by calling this function:

The dumped maps are stored inside LqrVMap objects, and these are attached to their corresponing LqrCarver object through a linked list, whose type is LqrVMapList

To access the maps attached to a carver one has first to obtain the pointer to the list, with the function:

Then, one can iterate through the attached maps by using these two functions:

Here is a sample code usage:

LqrVMap *vmap;
LqrVMapList *list;

list = lqr_vmap_list_start (carver);
while (list) {
    vmap = lqr_vmap_list_current (list);
    /* ... do something on vmap ... */
    list = lqr_vmap_list_next (list);
}
                        

The maps will always be accessed in the order in which they were dumped.

Alternatively, one can apply a function to all the elements of the list, through this function:

To use this second method, you'll need to define a function first, as in this sample code:

LqrRetVal my_func (LqrVMap vmap, gpointer data)
{
    /* ... do something on vmap ... */
    return LQR_OK;
}

LqrVMapList *list;

list = lqr_vmap_list_start (carver);
lqr_vmap_list_foreach (list, my_func, NULL);
                        

In the above example, no data is actually passed on to the function.

The LqrVMap objects contain an int buffer with the actual map data (plain array, ordered by row), plus all the information needed to be able to recover it from scratch.

The information can be extracted with these functions:

gint* lqr_vmap_get_data (LqrVMap* vmap);
gint lqr_vmap_get_width (LqrVMap* vmap);
gint lqr_vmap_get_height (LqrVMap* vmap);
gint lqr_vmap_get_orientation (LqrVMap* vmap);
gint lqr_vmap_get_depth (LqrVMap* vmap);
                    

The first one returns a pointer to the data buffer.

The orientation of the map is 0 if the map is to be used for horizontal rescaling, 1 otherwise.

The depth of the map is the maximum amount of rescaling possible with that map, either shrinking or enlarging.

gint *buffer;
gint width;
gint vis;

buffer = lqr_vmap_get_data (vmap);
width = lqr_vmap_get_width (vmap);
vis =  buffer[y * width + x];
                        

Having an LqrVMap object, one can load it in an LqrCarver simply by calling this function:

The carver must not to be initialised, neither before nor after invoking this function.

The library does not include methods to load/save visibility maps to/from files. However, a way to do so is shown in the demo program `liquidrescale' in the `examples' directory.