rl2_export_ndvi_ascii_grid_from_dbms (sqlite3 * handle, int max_threads,
					      const char *dst_path,
					      rl2CoveragePtr coverage,
					      double res, double minx,
					      double miny, double maxx,
					      double maxy, unsigned int width,
					      unsigned int height, int red_band,

					      int nir_band, int is_centered,
					      int decimal_digits);


    RL2_DECLARE int
	rl2_export_section_ndvi_ascii_grid_from_dbms (sqlite3 * handle,
						      int max_threads,
						      const char *dst_path,
						      rl2CoveragePtr coverage,
						      sqlite3_int64 section_id,
						      double res, double minx,
						      double miny, double maxx,
						      double maxy,
						      unsigned int width,
						      unsigned int height,
						      int red_band,

						      int nir_band,
						      int is_centered,
						      int decimal_digits);


    RL2_DECLARE int
	rl2_export_jpeg_from_dbms (sqlite3 * handle, int max_threads,
				   const char *dst_path,
				   rl2CoveragePtr coverage, double x_res,
				   double y_res, double minx, double miny,
				   double maxx, double maxy, unsigned int width,
................................................................................
 \note ownership of the rgba buffer will be definitely acquired by the 
 internal PDF writer.
 */
    RL2_DECLARE int
	rl2_rgba_to_pdf (const void *priv_data, unsigned int width,
			 unsigned int height, unsigned char *rgba,
			 unsigned char **pdf, int *pdf_size);
			 
			 
    RL2_DECLARE int
	rl2_rgba_to_pdfazzo (const void *priv_data, unsigned int width,
			 unsigned int height, unsigned char *rgba,
			 unsigned char **pdf, int *pdf_size);

/**
 Exports an all-Gray PDF document

 \param priv_data pointer to the opaque internal connection object 
 returned by a previous call to rl2_alloc_private() 
 \param width the PDF image width.
................................................................................
						     const char *db_prefix,
						     const char *cvg_name,
						     const unsigned char *blob,
						     int blob_sz,
						     int reaspect,
						     const char *style_name,
						     const unsigned char
						     *xml_style,
						     int *has_labels);

    RL2_DECLARE int rl2_map_image_paint_from_vector_ex (sqlite3 * sqlite,
							const void *data,
							rl2CanvasPtr canvas,
							const char *db_prefix,
							const char *cvg_name,
							const unsigned char
................................................................................
							const unsigned char
							*xml_style,
							int with_nodes,
							int with_edges_or_links,
							int with_faces,
							int
							with_edge_or_link_seeds,
							int with_face_seeds,
							int *has_labels);












    RL2_DECLARE unsigned char *rl2_map_image_from_wms (sqlite3 * sqlite,
						       const char *db_prefix,
						       const char *cvg_name,
						       const unsigned char
						       *blob, int blob_sz,
						       int width, int height,
................................................................................
						       const char *style,
						       const char *format,
						       int transparent,
						       const char *bg_color,
						       int *image_size);

    RL2_DECLARE int rl2_image_blob_from_map_config (sqlite3 * sqlite,
							   const void *data,
							   const char *mapconf,
							   const unsigned char
							   *blob, int blob_sz,
							   int width,
							   int height,
							   const char *format,
							   int quality,
							   int reaspect,
							   unsigned char **img,
							   int *img_size);

    RL2_DECLARE rl2FeatureTypeStylePtr rl2_feature_type_style_from_xml (const
									char
									*name,
									const
									unsigned
									char
................................................................................
					  double no_data_value,
					  double densify_dist,
					  double z_simplify_dist, int update_m);

    RL2_DECLARE int rl2_serialize_map_config (rl2MapConfigPtr map_config_obj,
					      unsigned char **blob,
					      int *blob_sz);
	
#ifdef _WIN32				      
	RL2_DECLARE FILE * rl2_win_fopen(const char *path, const char *mode);
#endif

#ifdef __cplusplus
}
#endif

#endif				/* _RASTERLITE2_H */

	rl2_export_ndvi_ascii_grid_from_dbms (sqlite3 * handle, int max_threads,
					      const char *dst_path,
					      rl2CoveragePtr coverage,
					      double res, double minx,
					      double miny, double maxx,
					      double maxy, unsigned int width,
					      unsigned int height, int red_band,
					      int green_band, int nir_band,
					      int is_centered,
					      int decimal_digits,
					      int ndwi_mode);

    RL2_DECLARE int
	rl2_export_section_ndvi_ascii_grid_from_dbms (sqlite3 * handle,
						      int max_threads,
						      const char *dst_path,
						      rl2CoveragePtr coverage,
						      sqlite3_int64 section_id,
						      double res, double minx,
						      double miny, double maxx,
						      double maxy,
						      unsigned int width,
						      unsigned int height,
						      int red_band,
						      int green_band,
						      int nir_band,
						      int is_centered,
						      int decimal_digits,
						      int ndwi_mode);

    RL2_DECLARE int
	rl2_export_jpeg_from_dbms (sqlite3 * handle, int max_threads,
				   const char *dst_path,
				   rl2CoveragePtr coverage, double x_res,
				   double y_res, double minx, double miny,
				   double maxx, double maxy, unsigned int width,
................................................................................
 \note ownership of the rgba buffer will be definitely acquired by the 
 internal PDF writer.
 */
    RL2_DECLARE int
	rl2_rgba_to_pdf (const void *priv_data, unsigned int width,
			 unsigned int height, unsigned char *rgba,
			 unsigned char **pdf, int *pdf_size);


    RL2_DECLARE int
	rl2_rgba_to_pdfazzo (const void *priv_data, unsigned int width,
			     unsigned int height, unsigned char *rgba,
			     unsigned char **pdf, int *pdf_size);

/**
 Exports an all-Gray PDF document

 \param priv_data pointer to the opaque internal connection object 
 returned by a previous call to rl2_alloc_private() 
 \param width the PDF image width.
................................................................................
						     const char *db_prefix,
						     const char *cvg_name,
						     const unsigned char *blob,
						     int blob_sz,
						     int reaspect,
						     const char *style_name,
						     const unsigned char
						     *xml_style);


    RL2_DECLARE int rl2_map_image_paint_from_vector_ex (sqlite3 * sqlite,
							const void *data,
							rl2CanvasPtr canvas,
							const char *db_prefix,
							const char *cvg_name,
							const unsigned char
................................................................................
							const unsigned char
							*xml_style,
							int with_nodes,
							int with_edges_or_links,
							int with_faces,
							int
							with_edge_or_link_seeds,
							int with_face_seeds);


    RL2_DECLARE int rl2_map_image_paint_labels (sqlite3 * sqlite,
						const void *data,
						rl2CanvasPtr canvas,
						const char *db_prefix,
						const char *cvg_name,
						const unsigned char *blob,
						int blob_sz,
						int reaspect,
						const char *style_name,
						const unsigned char *xml_style);

    RL2_DECLARE unsigned char *rl2_map_image_from_wms (sqlite3 * sqlite,
						       const char *db_prefix,
						       const char *cvg_name,
						       const unsigned char
						       *blob, int blob_sz,
						       int width, int height,
................................................................................
						       const char *style,
						       const char *format,
						       int transparent,
						       const char *bg_color,
						       int *image_size);

    RL2_DECLARE int rl2_image_blob_from_map_config (sqlite3 * sqlite,
						    const void *data,
						    const char *mapconf,
						    const unsigned char
						    *blob, int blob_sz,
						    int width,
						    int height,
						    const char *format,
						    int quality,
						    int reaspect,
						    unsigned char **img,
						    int *img_size);

    RL2_DECLARE rl2FeatureTypeStylePtr rl2_feature_type_style_from_xml (const
									char
									*name,
									const
									unsigned
									char
................................................................................
					  double no_data_value,
					  double densify_dist,
					  double z_simplify_dist, int update_m);

    RL2_DECLARE int rl2_serialize_map_config (rl2MapConfigPtr map_config_obj,
					      unsigned char **blob,
					      int *blob_sz);

#ifdef _WIN32
    RL2_DECLARE FILE *rl2_win_fopen (const char *path, const char *mode);
#endif

#ifdef __cplusplus
}
#endif

#endif				/* _RASTERLITE2_H */

	*rl2_graph_get_context_alpha_array (rl2GraphicsContextPtr context,
					    int *half_transparent);

/**
 Allocates and initializes a new Canvas object (generic Vector Layer)

 \param ref_ctx pointer to Graphics Context
 \param ref_ctx_labels pointer to Labels Graphics Context
 
 \return the pointer to newly created Canvas Object: NULL on failure.
 
 \sa rl2_destroy_canvas, rl2_create_topology_canvas, rl2_create_network_canvas, 
 rl2_create_raster_canves, rl2_create_wms_canvas, rl2_get_canvas_type,
 rl2_get_canvas_ctx, rl2_is_canvas_ready, rl2_is_canvas_error
 
 \note you are responsible to destroy (before or after) any allocated 
 Canvas object.
 */
    RL2_DECLARE rl2CanvasPtr rl2_create_vector_canvas (rl2GraphicsContextPtr
						       ref_ctx,
						       rl2GraphicsContextPtr
						       ref_ctx_labels);

/**
 Allocates and initializes a new Canvas object (Topology Layer)

 \param ref_ctx pointer to base Graphics Context
 \param ref_ctx_labels pointer to Labels Graphics Context
 \param ref_ctx_nodes pointer to Nodes Graphics Context (may be NULL)
 \param ref_ctx_edges pointer to Edges Graphics Context (may be NULL)
 \param ref_ctx_faces pointer to Faces Graphics Context (may be NULL)
 \param ref_ctx_edge_seeds pointer to Edge Seeds Graphics Context (may be NULL)
 \param ref_ctx_face_seeds pointer to Face Seeds Graphics Context (may be NULL)
 
 \return the pointer to newly created Canvas Object: NULL on failure.
................................................................................
 
 \note you are responsible to destroy (before or after) any allocated 
 Canvas object.
 */
    RL2_DECLARE rl2CanvasPtr rl2_create_topology_canvas (rl2GraphicsContextPtr
							 ref_ctx,
							 rl2GraphicsContextPtr
							 ref_ctx_labels,
							 rl2GraphicsContextPtr
							 ref_ctx_nodes,
							 rl2GraphicsContextPtr
							 ref_ctx_edges,
							 rl2GraphicsContextPtr
							 ref_ctx_faces,
							 rl2GraphicsContextPtr
							 ref_ctx_edge_seeds,
................................................................................
							 rl2GraphicsContextPtr
							 ref_ctx_face_seeds);

/**
 Allocates and initializes a new Canvas object (Topology Layer)

 \param ref_ctx pointer to base Graphics Context
 \param ref_ctx_labels pointer to Labels Graphics Context
 \param ref_ctx_nodes pointer to Nodes Graphics Context (may be NULL)
 \param ref_ctx_links pointer to Links Graphics Context (may be NULL)
 \param ref_ctx_link_seeds pointer to Link Seeds Graphics Context (may be NULL)
 
 \return the pointer to newly created Canvas Object: NULL on failure.
 
 \sa rl2_destroy_canvas, rl2_create_vector_canvas, rl2_create_topology_canvas, 
................................................................................
 rl2_get_canvas_ctx, rl2_is_canvas_ready, rl2_is_canvas_error
 
 \note you are responsible to destroy (before or after) any allocated 
 Canvas object.
 */
    RL2_DECLARE rl2CanvasPtr rl2_create_network_canvas (rl2GraphicsContextPtr
							ref_ctx,
							rl2GraphicsContextPtr
							ref_ctx_labels,
							rl2GraphicsContextPtr
							ref_ctx_nodes,
							rl2GraphicsContextPtr
							ref_ctx_links,
							rl2GraphicsContextPtr
							ref_ctx_link_seeds);

	*rl2_graph_get_context_alpha_array (rl2GraphicsContextPtr context,
					    int *half_transparent);

/**
 Allocates and initializes a new Canvas object (generic Vector Layer)

 \param ref_ctx pointer to Graphics Context

 
 \return the pointer to newly created Canvas Object: NULL on failure.
 
 \sa rl2_destroy_canvas, rl2_create_topology_canvas, rl2_create_network_canvas, 
 rl2_create_raster_canves, rl2_create_wms_canvas, rl2_get_canvas_type,
 rl2_get_canvas_ctx, rl2_is_canvas_ready, rl2_is_canvas_error
 
 \note you are responsible to destroy (before or after) any allocated 
 Canvas object.
 */
    RL2_DECLARE rl2CanvasPtr rl2_create_vector_canvas (rl2GraphicsContextPtr
						       ref_ctx);



/**
 Allocates and initializes a new Canvas object (Topology Layer)

 \param ref_ctx pointer to base Graphics Context

 \param ref_ctx_nodes pointer to Nodes Graphics Context (may be NULL)
 \param ref_ctx_edges pointer to Edges Graphics Context (may be NULL)
 \param ref_ctx_faces pointer to Faces Graphics Context (may be NULL)
 \param ref_ctx_edge_seeds pointer to Edge Seeds Graphics Context (may be NULL)
 \param ref_ctx_face_seeds pointer to Face Seeds Graphics Context (may be NULL)
 
 \return the pointer to newly created Canvas Object: NULL on failure.
................................................................................
 
 \note you are responsible to destroy (before or after) any allocated 
 Canvas object.
 */
    RL2_DECLARE rl2CanvasPtr rl2_create_topology_canvas (rl2GraphicsContextPtr
							 ref_ctx,
							 rl2GraphicsContextPtr


							 ref_ctx_nodes,
							 rl2GraphicsContextPtr
							 ref_ctx_edges,
							 rl2GraphicsContextPtr
							 ref_ctx_faces,
							 rl2GraphicsContextPtr
							 ref_ctx_edge_seeds,
................................................................................
							 rl2GraphicsContextPtr
							 ref_ctx_face_seeds);

/**
 Allocates and initializes a new Canvas object (Topology Layer)

 \param ref_ctx pointer to base Graphics Context

 \param ref_ctx_nodes pointer to Nodes Graphics Context (may be NULL)
 \param ref_ctx_links pointer to Links Graphics Context (may be NULL)
 \param ref_ctx_link_seeds pointer to Link Seeds Graphics Context (may be NULL)
 
 \return the pointer to newly created Canvas Object: NULL on failure.
 
 \sa rl2_destroy_canvas, rl2_create_vector_canvas, rl2_create_topology_canvas, 
................................................................................
 rl2_get_canvas_ctx, rl2_is_canvas_ready, rl2_is_canvas_error
 
 \note you are responsible to destroy (before or after) any allocated 
 Canvas object.
 */
    RL2_DECLARE rl2CanvasPtr rl2_create_network_canvas (rl2GraphicsContextPtr
							ref_ctx,


							rl2GraphicsContextPtr
							ref_ctx_nodes,
							rl2GraphicsContextPtr
							ref_ctx_links,
							rl2GraphicsContextPtr
							ref_ctx_link_seeds);

    } rl2TransformParams;
    typedef rl2TransformParams *rl2TransformParamsPtr;

    typedef struct rl2_priv_canvas
    {
	int type;
	void *ref_ctx;
	void *ref_ctx_labels;
	void *ref_ctx_nodes;
	void *ref_ctx_edges;
	void *ref_ctx_links;
	void *ref_ctx_faces;
	void *ref_ctx_edge_seeds;
	void *ref_ctx_link_seeds;
	void *ref_ctx_face_seeds;
	int ctx_ready;
	int ctx_labels_ready;
	int ctx_nodes_ready;
	int ctx_edges_ready;
	int ctx_links_ready;
	int ctx_faces_ready;
	int ctx_edge_seeds_ready;
	int ctx_link_seeds_ready;
	int ctx_face_seeds_ready;
................................................................................
	const char *prefix;
	double min_value;
	double max_value;
	char *style_name;
	char *xml_style;
	unsigned char syntetic_band;
	void *ctx;
	void *ctx_labels;
	void *ctx_nodes;
	void *ctx_edges;
	void *ctx_faces;
	void *ctx_edge_seeds;
	void *ctx_face_seeds;
	void *ctx_links;
	void *ctx_link_seeds;
	rl2CanvasPtr canvas;
	int valid;

	struct rl2_priv_map_layer *next;
    } rl2PrivMapLayer;
    typedef rl2PrivMapLayer *rl2PrivMapLayerPtr;

    typedef struct rl2_priv_map_config_aux
    {
	int valid;
................................................................................
	unsigned char *image;
	int image_size;
	rl2MapConfigPtr map_config;
	rl2PrivMapAttachedDbPtr first_db;
	rl2PrivMapAttachedDbPtr last_db;
	rl2PrivMapLayerPtr first_lyr;
	rl2PrivMapLayerPtr last_lyr;




    } rl2PrivMapConfigAux;
    typedef rl2PrivMapConfigAux *rl2PrivMapConfigAuxPtr;












    typedef struct rl2_wms_tile
    {
	int base_x;
	int base_y;
	int width;
	int height;
	double min_x;
................................................................................
				 int bytes);

    RL2_PRIVATE rl2PrivVariantValuePtr rl2_create_variant_null (const char
								*name);

    RL2_PRIVATE void rl2_destroy_variant_value (rl2PrivVariantValuePtr value);

    RL2_PRIVATE void rl2_draw_vector_feature (void *ctx, void *ctx_labels,
					      sqlite3 * handle,
					      const void *priv_data,
					      rl2VectorSymbolizerPtr symbolizer,
					      int height, double minx,
					      double miny, double maxx,
					      double maxy, double x_res,
					      double y_res, rl2GeometryPtr geom,
					      rl2VariantArrayPtr variant,
					      int *has_labels);

    RL2_PRIVATE rl2GeometryPtr
	rl2_geometry_from_blob (const unsigned char *blob, int blob_sz);

    RL2_PRIVATE int rl2_geometry_to_blob (rl2GeometryPtr geom,
					  unsigned char **blob, int *blob_sz);

    } rl2TransformParams;
    typedef rl2TransformParams *rl2TransformParamsPtr;

    typedef struct rl2_priv_canvas
    {
	int type;
	void *ref_ctx;

	void *ref_ctx_nodes;
	void *ref_ctx_edges;
	void *ref_ctx_links;
	void *ref_ctx_faces;
	void *ref_ctx_edge_seeds;
	void *ref_ctx_link_seeds;
	void *ref_ctx_face_seeds;
	int ctx_ready;

	int ctx_nodes_ready;
	int ctx_edges_ready;
	int ctx_links_ready;
	int ctx_faces_ready;
	int ctx_edge_seeds_ready;
	int ctx_link_seeds_ready;
	int ctx_face_seeds_ready;
................................................................................
	const char *prefix;
	double min_value;
	double max_value;
	char *style_name;
	char *xml_style;
	unsigned char syntetic_band;
	void *ctx;

	void *ctx_nodes;
	void *ctx_edges;
	void *ctx_faces;
	void *ctx_edge_seeds;
	void *ctx_face_seeds;
	void *ctx_links;
	void *ctx_link_seeds;
	rl2CanvasPtr canvas;
	int valid;
	int has_labels;
	struct rl2_priv_map_layer *next;
    } rl2PrivMapLayer;
    typedef rl2PrivMapLayer *rl2PrivMapLayerPtr;

    typedef struct rl2_priv_map_config_aux
    {
	int valid;
................................................................................
	unsigned char *image;
	int image_size;
	rl2MapConfigPtr map_config;
	rl2PrivMapAttachedDbPtr first_db;
	rl2PrivMapAttachedDbPtr last_db;
	rl2PrivMapLayerPtr first_lyr;
	rl2PrivMapLayerPtr last_lyr;
	int has_labels;
	int update_labels;
	void *ctx_labels;
	rl2CanvasPtr canvas_labels;
    } rl2PrivMapConfigAux;
    typedef rl2PrivMapConfigAux *rl2PrivMapConfigAuxPtr;

    typedef struct rl2_aux_map_painter
    {
	void *opaque_thread_id;
	char layer_type;
	sqlite3 * sqlite;
	const void *data;
	rl2PrivMapLayerPtr aux_lyr;
	rl2PrivMapConfigAuxPtr aux;
    } rl2AuxMapPainter;
    typedef rl2AuxMapPainter *rl2AuxMapPainterPtr;

    typedef struct rl2_wms_tile
    {
	int base_x;
	int base_y;
	int width;
	int height;
	double min_x;
................................................................................
				 int bytes);

    RL2_PRIVATE rl2PrivVariantValuePtr rl2_create_variant_null (const char
								*name);

    RL2_PRIVATE void rl2_destroy_variant_value (rl2PrivVariantValuePtr value);

    RL2_PRIVATE void rl2_draw_vector_feature (void *ctx, 

					      sqlite3 * handle, const void *priv_data,
					      rl2VectorSymbolizerPtr symbolizer,
					      int height, double minx,
					      double miny, double maxx,
					      double maxy, double x_res,
					      double y_res, rl2GeometryPtr geom,
					      rl2VariantArrayPtr variant,
					      int mode_labels);

    RL2_PRIVATE rl2GeometryPtr
	rl2_geometry_from_blob (const unsigned char *blob, int blob_sz);

    RL2_PRIVATE int rl2_geometry_to_blob (rl2GeometryPtr geom,
					  unsigned char **blob, int *blob_sz);

	  item_in = item_in->next;
      }

    return out;
}

RL2_PRIVATE void
rl2_draw_vector_feature (void *p_ctx, void *p_ctx_labels, sqlite3 * handle,
			 const void *priv_data,
			 rl2VectorSymbolizerPtr symbolizer, int height,
			 double minx, double miny, double maxx, double maxy,
			 double x_res, double y_res, rl2GeometryPtr geom,
			 rl2VariantArrayPtr variant, int *has_labels)
{
/* drawing a vector feature on the current canvas */
    rl2PrivVectorSymbolizerItemPtr item;
    rl2GraphicsContextPtr ctx = (rl2GraphicsContextPtr) p_ctx;
    rl2GraphicsContextPtr ctx_labels = (rl2GraphicsContextPtr) p_ctx_labels;
    rl2PrivVectorSymbolizerPtr sym = (rl2PrivVectorSymbolizerPtr) symbolizer;
    rl2PrivVectorSymbolizerPtr default_symbolizer = NULL;
    rl2PrivVectorSymbolizerPtr dyn_symbolizer = NULL;

    *has_labels = 0;
    if (ctx == NULL || geom == NULL)
	return;

    if (sym != NULL)
      {
	  /* creating a dynamic symbolizer */
	  dyn_symbolizer =
................................................................................
	      default_symbolizer->first = item;
	  if (default_symbolizer->last != NULL)
	      default_symbolizer->last->next = item;
	  default_symbolizer->last = item;
	  sym = default_symbolizer;
      }



/* we'll render all geometries first */
    if (geom->first_polygon != NULL)
	draw_polygons (ctx, handle, sym, height, minx, miny, maxx, maxy,
		       x_res, y_res, geom);
    if (geom->first_linestring != NULL)
	draw_lines (ctx, handle, sym, height, minx, miny, maxx, maxy, x_res,
		    y_res, geom);
    if (geom->first_point != NULL)
	draw_points (ctx, handle, sym, height, minx, miny, maxx, maxy, x_res,
		     y_res, geom);

    if (sym != NULL && ctx_labels != NULL)
      {
	  /* then we'll render any eventual TextSymbolizer */


	  item = sym->first;
	  while (item != NULL)
	    {
		if (item->symbolizer_type == RL2_TEXT_SYMBOLIZER
		    && item->symbolizer != NULL)
		  {
		      rl2PrivTextSymbolizerPtr text =
			  (rl2PrivTextSymbolizerPtr) (item->symbolizer);
		      if (text->label != NULL)
			{
			    draw_labels (ctx_labels, handle,
					 priv_data, text, height,
					 minx, miny, maxx, maxy,
					 x_res, y_res, geom);
			    *has_labels = 1;
			}
		  }
		item = item->next;
	    }
      }


    if (default_symbolizer != NULL)
	rl2_destroy_vector_symbolizer (default_symbolizer);
    if (dyn_symbolizer != NULL)
	rl2_destroy_vector_symbolizer (dyn_symbolizer);
}

	  item_in = item_in->next;
      }

    return out;
}

RL2_PRIVATE void
rl2_draw_vector_feature (void *p_ctx, sqlite3 * handle, const void *priv_data,

			 rl2VectorSymbolizerPtr symbolizer, int height,
			 double minx, double miny, double maxx, double maxy,
			 double x_res, double y_res, rl2GeometryPtr geom,
			 rl2VariantArrayPtr variant, int mode_labels)
{
/* drawing a vector feature on the current canvas */
    rl2PrivVectorSymbolizerItemPtr item;
    rl2GraphicsContextPtr ctx = (rl2GraphicsContextPtr) p_ctx;

    rl2PrivVectorSymbolizerPtr sym = (rl2PrivVectorSymbolizerPtr) symbolizer;
    rl2PrivVectorSymbolizerPtr default_symbolizer = NULL;
    rl2PrivVectorSymbolizerPtr dyn_symbolizer = NULL;


    if (ctx == NULL || geom == NULL)
	return;

    if (sym != NULL)
      {
	  /* creating a dynamic symbolizer */
	  dyn_symbolizer =
................................................................................
	      default_symbolizer->first = item;
	  if (default_symbolizer->last != NULL)
	      default_symbolizer->last->next = item;
	  default_symbolizer->last = item;
	  sym = default_symbolizer;
      }

if (!mode_labels)
{
	/* we'll render all geometries */
    if (geom->first_polygon != NULL)
	draw_polygons (ctx, handle, sym, height, minx, miny, maxx, maxy,
		       x_res, y_res, geom);
    if (geom->first_linestring != NULL)
	draw_lines (ctx, handle, sym, height, minx, miny, maxx, maxy, x_res,
		    y_res, geom);
    if (geom->first_point != NULL)
	draw_points (ctx, handle, sym, height, minx, miny, maxx, maxy, x_res,
		     y_res, geom);
}
else
{
	  /* we'll render any eventual TextSymbolizer */
    if (sym != NULL)
      {
	  item = sym->first;
	  while (item != NULL)
	    {
		if (item->symbolizer_type == RL2_TEXT_SYMBOLIZER
		    && item->symbolizer != NULL)
		  {
		      rl2PrivTextSymbolizerPtr text =
			  (rl2PrivTextSymbolizerPtr) (item->symbolizer);
		      if (text->label != NULL)
			{
			    draw_labels (ctx, handle,
					 priv_data, text, height,
					 minx, miny, maxx, maxy,
					 x_res, y_res, geom);

			}
		  }
		item = item->next;
	    }
      }
  }

    if (default_symbolizer != NULL)
	rl2_destroy_vector_symbolizer (default_symbolizer);
    if (dyn_symbolizer != NULL)
	rl2_destroy_vector_symbolizer (dyn_symbolizer);
}

RL2_DECLARE int
rl2_get_raw_raster_data_transparent (sqlite3 * handle, int max_threads,
				     rl2CoveragePtr cvg, unsigned int width,
				     unsigned int height, double minx,
				     double miny, double maxx, double maxy,
				     double x_res, double y_res,
				     unsigned char **buffer, int *buf_size,
				     unsigned char **mask, int *mask_size, unsigned char syntetic_band,

				     rl2PalettePtr * palette,
				     unsigned char *out_pixel,
				     rl2PixelPtr no_data,
				     rl2RasterSymbolizerPtr style,
				     rl2RasterStatisticsPtr stats)
{
/*
................................................................................
		goto error;
	    }
      }
    sqlite3_finalize (stmt);
    stmt = NULL;

    if (name == NULL || xml == NULL)
      {
	  if (name != NULL)
	      free (name);
	  if (xml != NULL)
	      free (xml);
	  goto error;
      }
    stl = rl2_feature_type_style_from_xml (name, xml);
    if (stl == NULL)
	goto error;


    return stl;

  error:




    if (stmt != NULL)
	sqlite3_finalize (stmt);
    if (stl != NULL)
	rl2_destroy_feature_type_style (stl);
    return NULL;
}

RL2_DECLARE int
rl2_get_raw_raster_data_transparent (sqlite3 * handle, int max_threads,
				     rl2CoveragePtr cvg, unsigned int width,
				     unsigned int height, double minx,
				     double miny, double maxx, double maxy,
				     double x_res, double y_res,
				     unsigned char **buffer, int *buf_size,
				     unsigned char **mask, int *mask_size,
				     unsigned char syntetic_band,
				     rl2PalettePtr * palette,
				     unsigned char *out_pixel,
				     rl2PixelPtr no_data,
				     rl2RasterSymbolizerPtr style,
				     rl2RasterStatisticsPtr stats)
{
/*
................................................................................
		goto error;
	    }
      }
    sqlite3_finalize (stmt);
    stmt = NULL;

    if (name == NULL || xml == NULL)





	goto error;

    stl = rl2_feature_type_style_from_xml (name, xml);
    if (stl == NULL)
	goto error;
    free (name);
    free (xml);
    return stl;

  error:
    if (name != NULL)
	free (name);
    if (xml != NULL)
	free (xml);
    if (stmt != NULL)
	sqlite3_finalize (stmt);
    if (stl != NULL)
	rl2_destroy_feature_type_style (stl);
    return NULL;
}

static float
compute_ndvi (void *pixels, unsigned char sample_type,
	      unsigned char num_bands, unsigned short width,
	      unsigned char red_band, unsigned char nir_band,
	      unsigned short row, unsigned short col,
	      rl2PrivPixelPtr in_no_data, float out_no_data)
{
/* computing a Normalized Difference Vegetaion Index -NDVI */
    float red;
    float nir;
    unsigned char *p8;
    unsigned short *p16;
    if (sample_type == RL2_SAMPLE_UINT16)
      {
	  /* UINT16 samples */
................................................................................
	  if (is_ndvi_nodata_u8 (in_no_data, p8))
	      return out_no_data;
	  red = *(p8 + red_band);
	  nir = *(p8 + nir_band);
      }
    return (nir - red) / (nir + red);
}




































static int
export_ndvi_ascii_grid_common (int by_section, sqlite3 * handle,
			       int max_threads, const char *dst_path,
			       rl2CoveragePtr cvg, sqlite3_int64 section_id,
			       double res, double minx, double miny,
			       double maxx, double maxy, unsigned int width,
			       unsigned int height, int red_band,
			       int nir_band, int is_centered,
			       int decimal_digits)
{
/* exporting an NDVI ASCII Grid common implementation */
    rl2PalettePtr palette = NULL;
    rl2PixelPtr in_no_data;
    rl2AsciiGridDestinationPtr ascii = NULL;
    unsigned char level;
    unsigned char scale;
................................................................................
	RL2_OK)
	goto error;
    in_no_data = rl2_get_coverage_no_data (cvg);

    if (pixel_type != RL2_PIXEL_MULTIBAND)
	goto error;

    if (red_band < 0 || red_band >= num_bands)
	goto error;



    if (nir_band < 0 || nir_band >= num_bands)
	goto error;









    if (red_band == nir_band)
	goto error;


    if (by_section)
      {
	  /* single Section */
	  if (rl2_get_section_raw_raster_data
	      (handle, max_threads, cvg, section_id, width, height, minx,
	       miny, maxx, maxy, res, res, &pixels, &pixels_size, &palette,
................................................................................
    out_pixels_size = width * height * sizeof (float);
    out_pixels = malloc (out_pixels_size);
    if (out_pixels == NULL)
	goto error;
    po = (float *) out_pixels;
    for (row = 0; row < height; row++)
      {












	  /* computing NDVI */
	  for (col = 0; col < width; col++)
	      *po++ =
		  compute_ndvi (pixels, sample_type, num_bands, width,
				red_band, nir_band, row, col,
				(rl2PrivPixelPtr) in_no_data, out_no_data);


      }
    free (pixels);
    pixels = NULL;

    ascii =
	rl2_create_ascii_grid_destination (dst_path, width, height,
					   xx_res, minx, miny, is_centered,
................................................................................
RL2_DECLARE int
rl2_export_ndvi_ascii_grid_from_dbms (sqlite3 * handle, int max_threads,
				      const char *dst_path,
				      rl2CoveragePtr cvg, double res,
				      double minx, double miny, double maxx,
				      double maxy, unsigned int width,
				      unsigned int height, int red_band,
				      int nir_band, int is_centered,
				      int decimal_digits)

{
/* exporting an ASCII Grid from the DBMS into the file-system */
    return export_ndvi_ascii_grid_common (0, handle, max_threads, dst_path,
					  cvg, 0, res, minx, miny, maxx, maxy,
					  width, height, red_band, nir_band,
					  is_centered, decimal_digits);

}

RL2_DECLARE int
rl2_export_section_ndvi_ascii_grid_from_dbms (sqlite3 * handle,
					      int max_threads,
					      const char *dst_path,
					      rl2CoveragePtr cvg,
					      sqlite3_int64 section_id,
					      double res, double minx,
					      double miny, double maxx,
					      double maxy, unsigned int width,
					      unsigned int height,
					      int red_band, int nir_band,
					      int is_centered,
					      int decimal_digits)
{
/* exporting an ASCII Grid - Section */
    return export_ndvi_ascii_grid_common (1, handle, max_threads, dst_path,
					  cvg, section_id, res, minx, miny,
					  maxx, maxy, width, height, red_band,
					  nir_band, is_centered,
					  decimal_digits);
}

static int
export_jpeg_common (int by_section, sqlite3 * handle, int max_threads,
		    const char *dst_path, rl2CoveragePtr cvg,
		    sqlite3_int64 section_id, double x_res, double y_res,
		    double minx, double miny, double maxx, double maxy,

static float
compute_ndvi (void *pixels, unsigned char sample_type,
	      unsigned char num_bands, unsigned short width,
	      unsigned char red_band, unsigned char nir_band,
	      unsigned short row, unsigned short col,
	      rl2PrivPixelPtr in_no_data, float out_no_data)
{
/* computing a Normalized Difference Vegetation Index -NDVI */
    float red;
    float nir;
    unsigned char *p8;
    unsigned short *p16;
    if (sample_type == RL2_SAMPLE_UINT16)
      {
	  /* UINT16 samples */
................................................................................
	  if (is_ndvi_nodata_u8 (in_no_data, p8))
	      return out_no_data;
	  red = *(p8 + red_band);
	  nir = *(p8 + nir_band);
      }
    return (nir - red) / (nir + red);
}

static float
compute_ndwi (void *pixels, unsigned char sample_type,
	      unsigned char num_bands, unsigned short width,
	      unsigned char green_band, unsigned char nir_band,
	      unsigned short row, unsigned short col,
	      rl2PrivPixelPtr in_no_data, float out_no_data)
{
/* computing a Normalized Difference Water Index -NDWI */
    float green;
    float nir;
    unsigned char *p8;
    unsigned short *p16;
    if (sample_type == RL2_SAMPLE_UINT16)
      {
	  /* UINT16 samples */
	  p16 = (unsigned short *) pixels;
	  p16 += (row * width * num_bands) + (col * num_bands);
	  if (is_ndvi_nodata_u16 (in_no_data, p16))
	      return out_no_data;
	  green = *(p16 + green_band);
	  nir = *(p16 + nir_band);
      }
    else
      {
	  /* assuming UINT8 samples */
	  p8 = (unsigned char *) pixels;
	  p8 += (row * width * num_bands) + (col * num_bands);
	  if (is_ndvi_nodata_u8 (in_no_data, p8))
	      return out_no_data;
	  green = *(p8 + green_band);
	  nir = *(p8 + nir_band);
      }
    return (green - nir) / (green + nir);
}

static int
export_ndvi_ascii_grid_common (int by_section, sqlite3 * handle,
			       int max_threads, const char *dst_path,
			       rl2CoveragePtr cvg, sqlite3_int64 section_id,
			       double res, double minx, double miny,
			       double maxx, double maxy, unsigned int width,
			       unsigned int height, int red_band,
			       int green_band, int nir_band, int is_centered,
			       int decimal_digits, int ndwi_mode)
{
/* exporting an NDVI ASCII Grid common implementation */
    rl2PalettePtr palette = NULL;
    rl2PixelPtr in_no_data;
    rl2AsciiGridDestinationPtr ascii = NULL;
    unsigned char level;
    unsigned char scale;
................................................................................
	RL2_OK)
	goto error;
    in_no_data = rl2_get_coverage_no_data (cvg);

    if (pixel_type != RL2_PIXEL_MULTIBAND)
	goto error;

    if (ndwi_mode)

      {
	  if (green_band < 0 || green_band >= num_bands)
	      goto error;
	  if (nir_band < 0 || nir_band >= num_bands)
	      goto error;
	  if (green_band == nir_band)
	      goto error;
      }
    else
      {
	  if (red_band < 0 || red_band >= num_bands)
	      goto error;
	  if (nir_band < 0 || nir_band >= num_bands)
	      goto error;
	  if (red_band == nir_band)
	      goto error;
      }

    if (by_section)
      {
	  /* single Section */
	  if (rl2_get_section_raw_raster_data
	      (handle, max_threads, cvg, section_id, width, height, minx,
	       miny, maxx, maxy, res, res, &pixels, &pixels_size, &palette,
................................................................................
    out_pixels_size = width * height * sizeof (float);
    out_pixels = malloc (out_pixels_size);
    if (out_pixels == NULL)
	goto error;
    po = (float *) out_pixels;
    for (row = 0; row < height; row++)
      {
	  if (ndwi_mode)
	    {
		/* computing NDWI */
		for (col = 0; col < width; col++)
		    *po++ =
			compute_ndwi (pixels, sample_type, num_bands, width,
				      green_band, nir_band, row, col,
				      (rl2PrivPixelPtr) in_no_data,
				      out_no_data);
	    }
	  else
	    {
		/* computing NDVI */
		for (col = 0; col < width; col++)
		    *po++ =
			compute_ndvi (pixels, sample_type, num_bands, width,
				      red_band, nir_band, row, col,
				      (rl2PrivPixelPtr) in_no_data,
				      out_no_data);
	    }
      }
    free (pixels);
    pixels = NULL;

    ascii =
	rl2_create_ascii_grid_destination (dst_path, width, height,
					   xx_res, minx, miny, is_centered,
................................................................................
RL2_DECLARE int
rl2_export_ndvi_ascii_grid_from_dbms (sqlite3 * handle, int max_threads,
				      const char *dst_path,
				      rl2CoveragePtr cvg, double res,
				      double minx, double miny, double maxx,
				      double maxy, unsigned int width,
				      unsigned int height, int red_band,
				      int green_band, int nir_band,
				      int is_centered, int decimal_digits,
				      int ndwi_mode)
{
/* exporting an ASCII Grid from the DBMS into the file-system */
    return export_ndvi_ascii_grid_common (0, handle, max_threads, dst_path,
					  cvg, 0, res, minx, miny, maxx, maxy,
					  width, height, red_band, green_band,
					  nir_band, is_centered, decimal_digits,
					  ndwi_mode);
}

RL2_DECLARE int
rl2_export_section_ndvi_ascii_grid_from_dbms (sqlite3 * handle,
					      int max_threads,
					      const char *dst_path,
					      rl2CoveragePtr cvg,
					      sqlite3_int64 section_id,
					      double res, double minx,
					      double miny, double maxx,
					      double maxy, unsigned int width,
					      unsigned int height,
					      int red_band, int green_band,
					      int nir_band, int is_centered,
					      int decimal_digits, int ndwi_mode)
{
/* exporting an ASCII Grid - Section */
    return export_ndvi_ascii_grid_common (1, handle, max_threads, dst_path,
					  cvg, section_id, res, minx, miny,
					  maxx, maxy, width, height, red_band,
					  green_band, nir_band, is_centered,
					  decimal_digits, ndwi_mode);
}

static int
export_jpeg_common (int by_section, sqlite3 * handle, int max_threads,
		    const char *dst_path, rl2CoveragePtr cvg,
		    sqlite3_int64 section_id, double x_res, double y_res,
		    double minx, double miny, double maxx, double maxy,

						      {
							  unsigned char red;
							  unsigned char green;
							  unsigned char blue;
							  const char *value =
							      (const char
							       *)
							      (grandchild2->content);

							  if (parse_hex_color
							      (value, &red,
							       &green, &blue))
							      do_add_graphic_fill_color
								  (graphic, red,
								   green, blue);
						      }
................................................................................
		      xmlNode *text = attr->children;
		      if (text != NULL)
			{
			    int len;
			    const char *name;
			    if (text->type == XML_TEXT_NODE)
				name = (const char *) (text->content);
			    if (lyr->topology_internal_style->
				style_internal_name != NULL)

				free (lyr->topology_internal_style->
				      style_internal_name);
			    lyr->topology_internal_style->style_internal_name =
				NULL;
			    if (name != NULL)
			      {
				  len = strlen (name);

				  lyr->topology_internal_style->
				      style_internal_name = malloc (len + 1);
				  strcpy (lyr->topology_internal_style->
					  style_internal_name, name);

			      }
			}
		  }
		if (strcmp (name, "ShowFaces") == 0)
		  {
		      xmlNode *text = attr->children;
		      lyr->topology_internal_style->show_faces = 0;
................................................................................
		      if (text != NULL)
			{
			    if (text->type == XML_TEXT_NODE)
			      {
				  if (strcmp
				      ((const char *) (text->content),
				       "true") == 0)
				      lyr->topology_internal_style->
					  show_edge_seeds = 1;

			      }
			}
		  }
		if (strcmp (name, "ShowFaceSeeds") == 0)
		  {
		      xmlNode *text = attr->children;
		      lyr->topology_internal_style->show_face_seeds = 0;
................................................................................
		      if (text != NULL)
			{
			    if (text->type == XML_TEXT_NODE)
			      {
				  if (strcmp
				      ((const char *) (text->content),
				       "true") == 0)
				      lyr->topology_internal_style->
					  show_face_seeds = 1;

			      }
			}
		  }
	    }
	  attr = attr->next;
      }
}
................................................................................
		      xmlNode *text = attr->children;
		      if (text != NULL)
			{
			    int len;
			    const char *name;
			    if (text->type == XML_TEXT_NODE)
				name = (const char *) (text->content);
			    if (lyr->network_internal_style->
				style_internal_name != NULL)

				free (lyr->network_internal_style->
				      style_internal_name);
			    lyr->network_internal_style->style_internal_name =
				NULL;
			    if (name != NULL)
			      {
				  len = strlen (name);

				  lyr->network_internal_style->
				      style_internal_name = malloc (len + 1);
				  strcpy (lyr->network_internal_style->
					  style_internal_name, name);

			      }
			}
		  }
		if (strcmp (name, "ShowLinks") == 0)
		  {
		      xmlNode *text = attr->children;
		      lyr->network_internal_style->show_links = 0;
................................................................................
		      if (text != NULL)
			{
			    if (text->type == XML_TEXT_NODE)
			      {
				  if (strcmp
				      ((const char *) (text->content),
				       "true") == 0)
				      lyr->network_internal_style->
					  show_link_seeds = 1;

			      }
			}
		  }
	    }
	  attr = attr->next;
      }
}
................................................................................
			      {
				  value = (const char *) (text->content);
				  if (value == NULL)
				    {
					if (lyr->wms_style->background_color !=
					    NULL)
					  {
					      free (lyr->wms_style->
						    background_color);
					      lyr->wms_style->background_color =
						  NULL;
					  }
				    }
				  else
				    {
					if (lyr->wms_style->background_color !=
					    NULL)
					    free (lyr->wms_style->
						  background_color);
					len = strlen (value);
					lyr->wms_style->background_color =
					    malloc (len + 1);
					strcpy (lyr->wms_style->
						background_color, value);

				    }
			      }
			    text = text->next;
			}
		  }
		if (strcmp (name, "HttpProxy") == 0)
		    parse_http_proxy (node, lyr->wms_style);
................................................................................
			{
			    if (text->type == XML_TEXT_NODE)
			      {
				  value = (const char *) (text->content);
				  if (value != NULL)
				    {
					if (strcmp (value, "true") == 0)
					    map_config->map_background_transparent
						= 1;
				    }
			      }
			}
		  }
		attr = attr->next;
	    }
      }
................................................................................
    aux->ctx = NULL;
    aux->image = NULL;
    aux->image_size = 0;
    aux->first_db = NULL;
    aux->last_db = NULL;
    aux->first_lyr = NULL;
    aux->last_lyr = NULL;




    if (strcmp (format, "image/png") == 0)
      {
	  format_id = RL2_OUTPUT_FORMAT_PNG;
	  ok_format = 1;
      }
    if (strcmp (format, "image/jpeg") == 0)
      {
................................................................................
	  aux_lyr->layer = lyr;
	  aux_lyr->min_value = 0.0;
	  aux_lyr->max_value = 0.0;
	  aux_lyr->style_name = NULL;
	  aux_lyr->xml_style = NULL;
	  aux_lyr->syntetic_band = RL2_SYNTETIC_NONE;
	  aux_lyr->ctx = NULL;
	  aux_lyr->ctx_labels = NULL;
	  aux_lyr->ctx_nodes = NULL;
	  aux_lyr->ctx_edges = NULL;
	  aux_lyr->ctx_faces = NULL;
	  aux_lyr->ctx_edge_seeds = NULL;
	  aux_lyr->ctx_face_seeds = NULL;
	  aux_lyr->ctx_links = NULL;
	  aux_lyr->ctx_link_seeds = NULL;
	  aux_lyr->canvas = NULL;
	  aux_lyr->valid = lyr->visible;

	  aux_lyr->next = NULL;

	  if (aux->first_lyr == NULL)
	      aux->first_lyr = aux_lyr;
	  if (aux->last_lyr != NULL)
	      aux->last_lyr->next = aux_lyr;
	  aux->last_lyr = aux_lyr;
................................................................................
		if (do_check_prefix (aux, aux_lyr->layer->prefix, &alias))
		    do_check_layer_vector (sqlite, alias, aux_lyr);
		if (aux_lyr->valid)
		  {
		      /* creating a Canvas */
		      aux_lyr->ctx =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_labels =
			  rl2_graph_create_context (data, width, height);
		      if (aux_lyr->ctx != NULL && aux_lyr->ctx_labels != NULL)
			{
			    rl2_prime_background (aux_lyr->ctx, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_labels, 0, 0, 0, 0);	/* transparent background */
			    aux_lyr->canvas =
				rl2_create_vector_canvas (aux_lyr->ctx,
							  aux_lyr->ctx_labels);
			}
		      if (aux_lyr->canvas == NULL)
			  aux_lyr->valid = 0;
		      if (aux_lyr->canvas == NULL)
			  goto error;
		  }
		break;
................................................................................
		if (do_check_prefix (aux, aux_lyr->layer->prefix, &alias))
		    do_check_layer_vector_view (sqlite, alias, aux_lyr);
		if (aux_lyr->valid)
		  {
		      /* creating a Canvas */
		      aux_lyr->ctx =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_labels =
			  rl2_graph_create_context (data, width, height);
		      if (aux_lyr->ctx != NULL && aux_lyr->ctx_labels != NULL)
			{
			    rl2_prime_background (aux_lyr->ctx, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_labels, 0, 0, 0, 0);	/* transparent background */
			    aux_lyr->canvas =
				rl2_create_vector_canvas (aux_lyr->ctx,
							  aux_lyr->ctx_labels);
			}
		      if (aux_lyr->canvas == NULL)
			  aux_lyr->valid = 0;
		      if (aux_lyr->canvas == NULL)
			  goto error;
		  }
		break;
................................................................................
		if (do_check_prefix (aux, aux_lyr->layer->prefix, &alias))
		    do_check_layer_vector_virtual (sqlite, alias, aux_lyr);
		if (aux_lyr->valid)
		  {
		      /* creating a Canvas */
		      aux_lyr->ctx =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_labels =
			  rl2_graph_create_context (data, width, height);
		      if (aux_lyr->ctx != NULL && aux_lyr->ctx_labels != NULL)
			{
			    rl2_prime_background (aux_lyr->ctx, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_labels, 0, 0, 0, 0);	/* transparent background */
			    aux_lyr->canvas =
				rl2_create_vector_canvas (aux_lyr->ctx,
							  aux_lyr->ctx_labels);
			}
		      if (aux_lyr->canvas == NULL)
			  aux_lyr->valid = 0;
		      if (aux_lyr->canvas == NULL)
			  goto error;
		  }
		break;
................................................................................
		if (do_check_prefix (aux, aux_lyr->layer->prefix, &alias))
		    do_check_layer_topology (sqlite, alias, aux_lyr);
		if (aux_lyr->valid)
		  {
		      /* creating all Topology Canvas */
		      aux_lyr->ctx =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_labels =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_nodes =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_edges =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_faces =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_edge_seeds =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_face_seeds =
			  rl2_graph_create_context (data, width, height);
		      if (aux_lyr->ctx != NULL && aux_lyr->ctx_labels != NULL
			  && aux_lyr->ctx_nodes != NULL
			  && aux_lyr->ctx_edges != NULL
			  && aux_lyr->ctx_faces != NULL
			  && aux_lyr->ctx_edge_seeds != NULL
			  && aux_lyr->ctx_face_seeds != NULL)
			{
			    rl2_prime_background (aux_lyr->ctx, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_labels, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_nodes, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_edges, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_faces, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_edge_seeds, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_face_seeds, 0, 0, 0, 0);	/* transparent background */
			    aux_lyr->canvas =
				rl2_create_topology_canvas (aux_lyr->ctx,
							    aux_lyr->ctx_labels,
							    aux_lyr->ctx_nodes,
							    aux_lyr->ctx_edges,
							    aux_lyr->ctx_faces,

							    aux_lyr->ctx_edge_seeds,

							    aux_lyr->ctx_face_seeds);
			}
		      if (aux_lyr->canvas == NULL)
			  aux_lyr->valid = 0;
		      if (aux_lyr->canvas == NULL)
			  goto error;
		  }
		break;
................................................................................
		if (do_check_prefix (aux, aux_lyr->layer->prefix, &alias))
		    do_check_layer_network (sqlite, alias, aux_lyr);
		if (aux_lyr->valid)
		  {
		      /* creating all Network Canvas */
		      aux_lyr->ctx =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_labels =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_nodes =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_links =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_link_seeds =
			  rl2_graph_create_context (data, width, height);
		      if (aux_lyr->ctx != NULL && aux_lyr->ctx_labels != NULL
			  && aux_lyr->ctx_nodes != NULL
			  && aux_lyr->ctx_links != NULL
			  && aux_lyr->ctx_link_seeds != NULL)
			{
			    rl2_prime_background (aux_lyr->ctx, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_labels, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_nodes, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_links, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_link_seeds, 0, 0, 0, 0);	/* transparent background */
			    aux_lyr->canvas =
				rl2_create_network_canvas (aux_lyr->ctx,
							   aux_lyr->ctx_labels,
							   aux_lyr->ctx_nodes,
							   aux_lyr->ctx_links,
							   aux_lyr->ctx_link_seeds);
			}
		      if (aux_lyr->canvas == NULL)
			  aux_lyr->valid = 0;
		      if (aux_lyr->canvas == NULL)
			  goto error;
		  }
		break;
................................................................................
	      free (lyr->style_name);
	  if (lyr->xml_style != NULL)
	      sqlite3_free (lyr->xml_style);
	  if (lyr->canvas != NULL)
	      rl2_destroy_canvas (lyr->canvas);
	  if (lyr->ctx != NULL)
	      rl2_graph_destroy_context (lyr->ctx);
	  if (lyr->ctx_labels != NULL)
	      rl2_graph_destroy_context (lyr->ctx_labels);
	  if (lyr->ctx_nodes != NULL)
	      rl2_graph_destroy_context (lyr->ctx_nodes);
	  if (lyr->ctx_edges != NULL)
	      rl2_graph_destroy_context (lyr->ctx_edges);
	  if (lyr->ctx_faces != NULL)
	      rl2_graph_destroy_context (lyr->ctx_faces);
	  if (lyr->ctx_edge_seeds != NULL)
................................................................................
	  if (lyr->ctx_link_seeds != NULL)
	      rl2_graph_destroy_context (lyr->ctx_link_seeds);
	  free (lyr);
	  lyr = lyr_n;
      }

    if (aux->ctx != NULL)
	rl2_graph_destroy_context (aux->ctx);




    free (aux);
}

						      {
							  unsigned char red;
							  unsigned char green;
							  unsigned char blue;
							  const char *value =
							      (const char
							       *)
							      (grandchild2->
							       content);
							  if (parse_hex_color
							      (value, &red,
							       &green, &blue))
							      do_add_graphic_fill_color
								  (graphic, red,
								   green, blue);
						      }
................................................................................
		      xmlNode *text = attr->children;
		      if (text != NULL)
			{
			    int len;
			    const char *name;
			    if (text->type == XML_TEXT_NODE)
				name = (const char *) (text->content);
			    if (lyr->
				topology_internal_style->style_internal_name !=
				NULL)
				free (lyr->
				      topology_internal_style->style_internal_name);
			    lyr->topology_internal_style->style_internal_name =
				NULL;
			    if (name != NULL)
			      {
				  len = strlen (name);
				  lyr->
				      topology_internal_style->style_internal_name
				      = malloc (len + 1);
				  strcpy (lyr->
					  topology_internal_style->style_internal_name,
					  name);
			      }
			}
		  }
		if (strcmp (name, "ShowFaces") == 0)
		  {
		      xmlNode *text = attr->children;
		      lyr->topology_internal_style->show_faces = 0;
................................................................................
		      if (text != NULL)
			{
			    if (text->type == XML_TEXT_NODE)
			      {
				  if (strcmp
				      ((const char *) (text->content),
				       "true") == 0)
				      lyr->
					  topology_internal_style->show_edge_seeds
					  = 1;
			      }
			}
		  }
		if (strcmp (name, "ShowFaceSeeds") == 0)
		  {
		      xmlNode *text = attr->children;
		      lyr->topology_internal_style->show_face_seeds = 0;
................................................................................
		      if (text != NULL)
			{
			    if (text->type == XML_TEXT_NODE)
			      {
				  if (strcmp
				      ((const char *) (text->content),
				       "true") == 0)
				      lyr->
					  topology_internal_style->show_face_seeds
					  = 1;
			      }
			}
		  }
	    }
	  attr = attr->next;
      }
}
................................................................................
		      xmlNode *text = attr->children;
		      if (text != NULL)
			{
			    int len;
			    const char *name;
			    if (text->type == XML_TEXT_NODE)
				name = (const char *) (text->content);
			    if (lyr->
				network_internal_style->style_internal_name !=
				NULL)
				free (lyr->
				      network_internal_style->style_internal_name);
			    lyr->network_internal_style->style_internal_name =
				NULL;
			    if (name != NULL)
			      {
				  len = strlen (name);
				  lyr->
				      network_internal_style->style_internal_name
				      = malloc (len + 1);
				  strcpy (lyr->
					  network_internal_style->style_internal_name,
					  name);
			      }
			}
		  }
		if (strcmp (name, "ShowLinks") == 0)
		  {
		      xmlNode *text = attr->children;
		      lyr->network_internal_style->show_links = 0;
................................................................................
		      if (text != NULL)
			{
			    if (text->type == XML_TEXT_NODE)
			      {
				  if (strcmp
				      ((const char *) (text->content),
				       "true") == 0)
				      lyr->
					  network_internal_style->show_link_seeds
					  = 1;
			      }
			}
		  }
	    }
	  attr = attr->next;
      }
}
................................................................................
			      {
				  value = (const char *) (text->content);
				  if (value == NULL)
				    {
					if (lyr->wms_style->background_color !=
					    NULL)
					  {
					      free (lyr->
						    wms_style->background_color);
					      lyr->wms_style->background_color =
						  NULL;
					  }
				    }
				  else
				    {
					if (lyr->wms_style->background_color !=
					    NULL)
					    free (lyr->
						  wms_style->background_color);
					len = strlen (value);
					lyr->wms_style->background_color =
					    malloc (len + 1);
					strcpy (lyr->
						wms_style->background_color,
						value);
				    }
			      }
			    text = text->next;
			}
		  }
		if (strcmp (name, "HttpProxy") == 0)
		    parse_http_proxy (node, lyr->wms_style);
................................................................................
			{
			    if (text->type == XML_TEXT_NODE)
			      {
				  value = (const char *) (text->content);
				  if (value != NULL)
				    {
					if (strcmp (value, "true") == 0)
					    map_config->
						map_background_transparent = 1;
				    }
			      }
			}
		  }
		attr = attr->next;
	    }
      }
................................................................................
    aux->ctx = NULL;
    aux->image = NULL;
    aux->image_size = 0;
    aux->first_db = NULL;
    aux->last_db = NULL;
    aux->first_lyr = NULL;
    aux->last_lyr = NULL;
    aux->has_labels = 0;
    aux->update_labels = 0;
    aux->ctx_labels = NULL;
    aux->canvas_labels = NULL;
    if (strcmp (format, "image/png") == 0)
      {
	  format_id = RL2_OUTPUT_FORMAT_PNG;
	  ok_format = 1;
      }
    if (strcmp (format, "image/jpeg") == 0)
      {
................................................................................
	  aux_lyr->layer = lyr;
	  aux_lyr->min_value = 0.0;
	  aux_lyr->max_value = 0.0;
	  aux_lyr->style_name = NULL;
	  aux_lyr->xml_style = NULL;
	  aux_lyr->syntetic_band = RL2_SYNTETIC_NONE;
	  aux_lyr->ctx = NULL;

	  aux_lyr->ctx_nodes = NULL;
	  aux_lyr->ctx_edges = NULL;
	  aux_lyr->ctx_faces = NULL;
	  aux_lyr->ctx_edge_seeds = NULL;
	  aux_lyr->ctx_face_seeds = NULL;
	  aux_lyr->ctx_links = NULL;
	  aux_lyr->ctx_link_seeds = NULL;
	  aux_lyr->canvas = NULL;
	  aux_lyr->valid = lyr->visible;
	  aux_lyr->has_labels = 0;
	  aux_lyr->next = NULL;

	  if (aux->first_lyr == NULL)
	      aux->first_lyr = aux_lyr;
	  if (aux->last_lyr != NULL)
	      aux->last_lyr->next = aux_lyr;
	  aux->last_lyr = aux_lyr;
................................................................................
		if (do_check_prefix (aux, aux_lyr->layer->prefix, &alias))
		    do_check_layer_vector (sqlite, alias, aux_lyr);
		if (aux_lyr->valid)
		  {
		      /* creating a Canvas */
		      aux_lyr->ctx =
			  rl2_graph_create_context (data, width, height);


		      if (aux_lyr->ctx != NULL)
			{
			    rl2_prime_background (aux_lyr->ctx, 0, 0, 0, 0);	/* transparent background */

			    aux_lyr->canvas =
				rl2_create_vector_canvas (aux_lyr->ctx);

			}
		      if (aux_lyr->canvas == NULL)
			  aux_lyr->valid = 0;
		      if (aux_lyr->canvas == NULL)
			  goto error;
		  }
		break;
................................................................................
		if (do_check_prefix (aux, aux_lyr->layer->prefix, &alias))
		    do_check_layer_vector_view (sqlite, alias, aux_lyr);
		if (aux_lyr->valid)
		  {
		      /* creating a Canvas */
		      aux_lyr->ctx =
			  rl2_graph_create_context (data, width, height);


		      if (aux_lyr->ctx != NULL)
			{
			    rl2_prime_background (aux_lyr->ctx, 0, 0, 0, 0);	/* transparent background */

			    aux_lyr->canvas =
				rl2_create_vector_canvas (aux_lyr->ctx);

			}
		      if (aux_lyr->canvas == NULL)
			  aux_lyr->valid = 0;
		      if (aux_lyr->canvas == NULL)
			  goto error;
		  }
		break;
................................................................................
		if (do_check_prefix (aux, aux_lyr->layer->prefix, &alias))
		    do_check_layer_vector_virtual (sqlite, alias, aux_lyr);
		if (aux_lyr->valid)
		  {
		      /* creating a Canvas */
		      aux_lyr->ctx =
			  rl2_graph_create_context (data, width, height);


		      if (aux_lyr->ctx != NULL)
			{
			    rl2_prime_background (aux_lyr->ctx, 0, 0, 0, 0);	/* transparent background */

			    aux_lyr->canvas =
				rl2_create_vector_canvas (aux_lyr->ctx);

			}
		      if (aux_lyr->canvas == NULL)
			  aux_lyr->valid = 0;
		      if (aux_lyr->canvas == NULL)
			  goto error;
		  }
		break;
................................................................................
		if (do_check_prefix (aux, aux_lyr->layer->prefix, &alias))
		    do_check_layer_topology (sqlite, alias, aux_lyr);
		if (aux_lyr->valid)
		  {
		      /* creating all Topology Canvas */
		      aux_lyr->ctx =
			  rl2_graph_create_context (data, width, height);


		      aux_lyr->ctx_nodes =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_edges =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_faces =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_edge_seeds =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_face_seeds =
			  rl2_graph_create_context (data, width, height);
		      if (aux_lyr->ctx != NULL && aux_lyr->ctx_nodes != NULL

			  && aux_lyr->ctx_edges != NULL
			  && aux_lyr->ctx_faces != NULL
			  && aux_lyr->ctx_edge_seeds != NULL
			  && aux_lyr->ctx_face_seeds != NULL)
			{
			    rl2_prime_background (aux_lyr->ctx, 0, 0, 0, 0);	/* transparent background */

			    rl2_prime_background (aux_lyr->ctx_nodes, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_edges, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_faces, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_edge_seeds, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_face_seeds, 0, 0, 0, 0);	/* transparent background */
			    aux_lyr->canvas =
				rl2_create_topology_canvas (aux_lyr->ctx,

							    aux_lyr->ctx_nodes,
							    aux_lyr->ctx_edges,
							    aux_lyr->ctx_faces,
							    aux_lyr->
							    ctx_edge_seeds,
							    aux_lyr->
							    ctx_face_seeds);
			}
		      if (aux_lyr->canvas == NULL)
			  aux_lyr->valid = 0;
		      if (aux_lyr->canvas == NULL)
			  goto error;
		  }
		break;
................................................................................
		if (do_check_prefix (aux, aux_lyr->layer->prefix, &alias))
		    do_check_layer_network (sqlite, alias, aux_lyr);
		if (aux_lyr->valid)
		  {
		      /* creating all Network Canvas */
		      aux_lyr->ctx =
			  rl2_graph_create_context (data, width, height);


		      aux_lyr->ctx_nodes =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_links =
			  rl2_graph_create_context (data, width, height);
		      aux_lyr->ctx_link_seeds =
			  rl2_graph_create_context (data, width, height);
		      if (aux_lyr->ctx != NULL && aux_lyr->ctx_nodes != NULL

			  && aux_lyr->ctx_links != NULL
			  && aux_lyr->ctx_link_seeds != NULL)
			{
			    rl2_prime_background (aux_lyr->ctx, 0, 0, 0, 0);	/* transparent background */

			    rl2_prime_background (aux_lyr->ctx_nodes, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_links, 0, 0, 0, 0);	/* transparent background */
			    rl2_prime_background (aux_lyr->ctx_link_seeds, 0, 0, 0, 0);	/* transparent background */
			    aux_lyr->canvas =
				rl2_create_network_canvas (aux_lyr->ctx,
							   aux_lyr->ctx_nodes,
							   aux_lyr->ctx_links,
							   aux_lyr->
							   ctx_link_seeds);
			}
		      if (aux_lyr->canvas == NULL)
			  aux_lyr->valid = 0;
		      if (aux_lyr->canvas == NULL)
			  goto error;
		  }
		break;
................................................................................
	      free (lyr->style_name);
	  if (lyr->xml_style != NULL)
	      sqlite3_free (lyr->xml_style);
	  if (lyr->canvas != NULL)
	      rl2_destroy_canvas (lyr->canvas);
	  if (lyr->ctx != NULL)
	      rl2_graph_destroy_context (lyr->ctx);


	  if (lyr->ctx_nodes != NULL)
	      rl2_graph_destroy_context (lyr->ctx_nodes);
	  if (lyr->ctx_edges != NULL)
	      rl2_graph_destroy_context (lyr->ctx_edges);
	  if (lyr->ctx_faces != NULL)
	      rl2_graph_destroy_context (lyr->ctx_faces);
	  if (lyr->ctx_edge_seeds != NULL)
................................................................................
	  if (lyr->ctx_link_seeds != NULL)
	      rl2_graph_destroy_context (lyr->ctx_link_seeds);
	  free (lyr);
	  lyr = lyr_n;
      }

    if (aux->ctx != NULL)
		rl2_graph_destroy_context (aux->ctx);
    if (aux->canvas_labels != NULL)
		rl2_destroy_canvas (aux->canvas_labels);
    if (aux->ctx_labels != NULL)
		rl2_graph_destroy_context (aux->ctx_labels);
    free (aux);
}

	  ret = sqlite3_step (stmt);
	  if (ret == SQLITE_DONE)
	      break;
	  if (ret == SQLITE_ROW)
	    {
		if (sqlite3_column_type (stmt, 0) == SQLITE_BLOB)
		  {
		      int hasLabels;
		      unsigned char *blob =
			  (unsigned char *) sqlite3_column_blob (stmt, 0);
		      int blob_sz = sqlite3_column_bytes (stmt, 0);
		      if (aux_lyr->layer->type == RL2_MAP_LAYER_TOPOLOGY)
			  ret =
			      rl2_map_image_paint_from_vector_ex (sqlite, data,
								  (rl2CanvasPtr)
								  aux_lyr->canvas,

								  aux_lyr->prefix,

								  aux_lyr->layer->

								  name, blob,
								  blob_sz, 0,
								  aux_lyr->

								  style_name,
								  (unsigned char


								   *) aux_lyr->

								  xml_style,



								  aux_lyr->layer->topology_style->show_nodes,



								  aux_lyr->layer->topology_style->show_edges,



								  aux_lyr->layer->topology_style->show_faces,
								  aux_lyr->layer->topology_style->show_edge_seeds,


								  aux_lyr->layer->topology_style->show_face_seeds,
								  &hasLabels);

		      else if (aux_lyr->layer->type == RL2_MAP_LAYER_NETWORK)
			  ret =
			      rl2_map_image_paint_from_vector_ex (sqlite, data,
								  (rl2CanvasPtr)
								  aux_lyr->canvas,

								  aux_lyr->prefix,

								  aux_lyr->layer->

								  name, blob,
								  blob_sz, 0,
								  aux_lyr->

								  style_name,
								  (unsigned char


								   *) aux_lyr->

								  xml_style,



								  aux_lyr->layer->network_style->show_nodes,



								  aux_lyr->layer->network_style->show_links,
								  0,
								  aux_lyr->layer->network_style->show_link_seeds,
								  0,
								  &hasLabels);
		      else
			  ret = rl2_map_image_paint_from_vector (sqlite, data,
								 (rl2CanvasPtr)
								 aux_lyr->canvas,

								 aux_lyr->prefix,

								 aux_lyr->layer->

								 name, blob,
								 blob_sz, 0,
								 aux_lyr->

								 style_name,
								 (unsigned char
								  *) aux_lyr->

								 xml_style,
								 &hasLabels);
		      if (ret == RL2_OK)
			  ret = rl2_graph_merge (aux->ctx, aux_lyr->ctx);
		      //if (hasLabels)
		      //  layer->SetLabels(true);
		      //if (quickStyle != NULL)
		      //free (quickStyle);
		      //layer->Validate(canvas);
		      //rl2_destroy_canvas(canvas);




















































		  }
	    }
      }
    sqlite3_finalize (stmt);
}

static void
................................................................................
							   aux_lyr->canvas,
							   aux_lyr->prefix,
							   aux_lyr->layer->name,
							   blob, blob_sz,
							   aux_lyr->style_name,
							   (unsigned char *)
							   aux_lyr->xml_style,
							   aux_lyr->
							   syntetic_band);
		      if (ret == RL2_OK)
			  ret = rl2_graph_merge (aux->ctx, aux_lyr->ctx);
		  }
	    }
      }
    sqlite3_finalize (stmt);
}
................................................................................
	  if (aux->ctx != NULL && ctx_in != NULL)
	      rl2_graph_merge (aux->ctx, ctx_in);
	  if (ctx_in)
	      rl2_graph_destroy_context (ctx_in);
	  free (rgba);
      }
}






























RL2_PRIVATE int
rl2_paint_map_config_aux (sqlite3 * sqlite, const void *data,
			  rl2PrivMapConfigAuxPtr aux)
{
/* rendering a full MapConfiguration */
    rl2PrivMapLayerPtr aux_lyr;
................................................................................
    int half_transparent;
    unsigned char *image = NULL;
    int image_size;

    if (aux == NULL)
	return RL2_ERROR;



    aux_lyr = aux->first_lyr;
    while (aux_lyr != NULL)
      {






















	  if (aux_lyr->valid)
	    {
		switch (aux_lyr->layer->type)
		  {
		  case RL2_MAP_LAYER_WMS:
		      do_paint_layer_wms (data, aux_lyr, aux);
		      break;
		  case RL2_MAP_LAYER_RASTER:
		      do_paint_layer_raster (sqlite, data, aux_lyr, aux);
		      break;
		  case RL2_MAP_LAYER_VECTOR:
		  case RL2_MAP_LAYER_VECTOR_VIEW:
		  case RL2_MAP_LAYER_VECTOR_VIRTUAL:
		  case RL2_MAP_LAYER_TOPOLOGY:
		  case RL2_MAP_LAYER_NETWORK:
		      do_paint_layer_vector (sqlite, data, aux_lyr, aux);


		      break;
		  default:
		      break;
		  };
	    }
	  aux_lyr = aux_lyr->next;
      }







































/* preparing the full rendered Map Image */
    rgb = rl2_graph_get_context_rgb_array (aux->ctx);
    alpha = rl2_graph_get_context_alpha_array (aux->ctx, &half_transparent);
    if (rgb == NULL || alpha == NULL)
	goto error;

	  ret = sqlite3_step (stmt);
	  if (ret == SQLITE_DONE)
	      break;
	  if (ret == SQLITE_ROW)
	    {
		if (sqlite3_column_type (stmt, 0) == SQLITE_BLOB)
		  {

		      unsigned char *blob =
			  (unsigned char *) sqlite3_column_blob (stmt, 0);
		      int blob_sz = sqlite3_column_bytes (stmt, 0);
		      if (aux_lyr->layer->type == RL2_MAP_LAYER_TOPOLOGY)
			  ret =
			      rl2_map_image_paint_from_vector_ex (sqlite, data,
								  (rl2CanvasPtr)
								  aux_lyr->
								  canvas,
								  aux_lyr->
								  prefix,
								  aux_lyr->
								  layer->name,
								  blob, blob_sz,


								  0,
								  aux_lyr->style_name,
								  (unsigned char
								   *)
								  aux_lyr->xml_style,
								  aux_lyr->
								  layer->
								  topology_style->
								  show_nodes,
								  aux_lyr->
								  layer->
								  topology_style->
								  show_edges,
								  aux_lyr->
								  layer->
								  topology_style->
								  show_faces,
								  aux_lyr->
								  layer->
								  topology_style->
								  show_edge_seeds,
								  aux_lyr->
								  layer->
								  topology_style->

								  show_face_seeds);
		      else if (aux_lyr->layer->type == RL2_MAP_LAYER_NETWORK)
			  ret =
			      rl2_map_image_paint_from_vector_ex (sqlite, data,
								  (rl2CanvasPtr)
								  aux_lyr->
								  canvas,
								  aux_lyr->
								  prefix,
								  aux_lyr->
								  layer->name,
								  blob, blob_sz,


								  0,
								  aux_lyr->style_name,
								  (unsigned char
								   *)
								  aux_lyr->xml_style,
								  aux_lyr->
								  layer->
								  network_style->
								  show_nodes,
								  aux_lyr->
								  layer->
								  network_style->
								  show_links, 0,
								  aux_lyr->
								  layer->
								  network_style->

								  show_link_seeds,
								  0);

		      else
			  ret = rl2_map_image_paint_from_vector (sqlite, data,
								 (rl2CanvasPtr)
								 aux_lyr->
								 canvas,
								 aux_lyr->
								 prefix,
								 aux_lyr->
								 layer->name,
								 blob, blob_sz,


								 0,
								 aux_lyr->style_name,
								 (unsigned char

								  *)
								 aux_lyr->xml_style);

		      if (ret == RL2_OK)
			  ret = rl2_graph_merge (aux->ctx, aux_lyr->ctx);






		  }
	    }
      }
    sqlite3_finalize (stmt);
}

static void
do_paint_layer_labels (sqlite3 * sqlite, const void *data,
		       rl2PrivMapLayerPtr aux_lyr, rl2PrivMapConfigAuxPtr aux)
{
/* rendering a MapConfiguration Layer Labels */
    sqlite3_stmt *stmt = NULL;
    const char *sql;
    int ret;

    if (aux_lyr == NULL)
	return;
    if (aux_lyr->layer == NULL)
	return;

/* building the Map's Bounding Box */
    sql = "SELECT BuildMbr(?, ?, ?, ?, ?)";
    ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
    if (ret != SQLITE_OK)
	return;
    sqlite3_reset (stmt);
    sqlite3_clear_bindings (stmt);
    sqlite3_bind_double (stmt, 1, aux->min_x);
    sqlite3_bind_double (stmt, 2, aux->min_y);
    sqlite3_bind_double (stmt, 3, aux->max_x);
    sqlite3_bind_double (stmt, 4, aux->max_y);
    sqlite3_bind_int (stmt, 5, aux->srid);
    while (1)
      {
	  ret = sqlite3_step (stmt);
	  if (ret == SQLITE_DONE)
	      break;
	  if (ret == SQLITE_ROW)
	    {
		if (sqlite3_column_type (stmt, 0) == SQLITE_BLOB)
		  {
		      unsigned char *blob =
			  (unsigned char *) sqlite3_column_blob (stmt, 0);
		      int blob_sz = sqlite3_column_bytes (stmt, 0);
		      ret = rl2_map_image_paint_labels (sqlite, data,
							aux->canvas_labels,
							aux_lyr->prefix,
							aux_lyr->layer->name,
							blob, blob_sz, 0,
							aux_lyr->style_name,
							(unsigned char *)
							aux_lyr->xml_style);
		  }
	    }
      }
    sqlite3_finalize (stmt);
}

static void
................................................................................
							   aux_lyr->canvas,
							   aux_lyr->prefix,
							   aux_lyr->layer->name,
							   blob, blob_sz,
							   aux_lyr->style_name,
							   (unsigned char *)
							   aux_lyr->xml_style,

							   aux_lyr->syntetic_band);
		      if (ret == RL2_OK)
			  ret = rl2_graph_merge (aux->ctx, aux_lyr->ctx);
		  }
	    }
      }
    sqlite3_finalize (stmt);
}
................................................................................
	  if (aux->ctx != NULL && ctx_in != NULL)
	      rl2_graph_merge (aux->ctx, ctx_in);
	  if (ctx_in)
	      rl2_graph_destroy_context (ctx_in);
	  free (rgba);
      }
}

static void
check_map_labels (sqlite3 * sqlite, rl2PrivMapLayerPtr lyr)
{
/* testing for Layers with Map Labels */
    rl2MapLayerPtr layer = lyr->layer;
    rl2MapVectorLayerStylePtr style = layer->vector_style;
    lyr->has_labels = 0;
    if (style != NULL)
      {
	  /* quick style */
	  if (style->text_sym != NULL)
	      lyr->has_labels = 1;
      }
    else if (layer->vector_style_internal_name != NULL)
      {
	  /* internal style name */
	  rl2FeatureTypeStylePtr lyr_stl =
	      rl2_create_feature_type_style_from_dbms (sqlite, layer->prefix,
						       layer->name,
						       layer->
						       vector_style_internal_name);
	  if (lyr_stl != NULL)
	    {
		lyr->has_labels = rl2_style_has_labels (lyr_stl);
		rl2_destroy_feature_type_style (lyr_stl);
	    }
      }
}

RL2_PRIVATE int
rl2_paint_map_config_aux (sqlite3 * sqlite, const void *data,
			  rl2PrivMapConfigAuxPtr aux)
{
/* rendering a full MapConfiguration */
    rl2PrivMapLayerPtr aux_lyr;
................................................................................
    int half_transparent;
    unsigned char *image = NULL;
    int image_size;

    if (aux == NULL)
	return RL2_ERROR;

    aux->has_labels = 0;
    aux->update_labels = 0;
    aux_lyr = aux->first_lyr;
    while (aux_lyr != NULL)
      {
	  /* testing for Map Labels */
	  switch (aux_lyr->layer->type)
	    {
	    case RL2_MAP_LAYER_VECTOR:
	    case RL2_MAP_LAYER_VECTOR_VIEW:
	    case RL2_MAP_LAYER_VECTOR_VIRTUAL:
	    case RL2_MAP_LAYER_TOPOLOGY:
	    case RL2_MAP_LAYER_NETWORK:
		check_map_labels (sqlite, aux_lyr);
		if (aux_lyr->has_labels)
		    aux->has_labels = 1;
		break;
	    default:
		break;
	    };
	  aux_lyr = aux_lyr->next;
      }

	  aux_lyr = aux->first_lyr;
	  while (aux_lyr != NULL)
	    {
		/* painting Layers */
		if (aux_lyr->valid)
		  {
		      switch (aux_lyr->layer->type)
			{
			case RL2_MAP_LAYER_WMS:
			    do_paint_layer_wms (data, aux_lyr, aux);
			    break;
			case RL2_MAP_LAYER_RASTER:
			    do_paint_layer_raster (sqlite, data, aux_lyr, aux);
			    break;
			case RL2_MAP_LAYER_VECTOR:
			case RL2_MAP_LAYER_VECTOR_VIEW:
			case RL2_MAP_LAYER_VECTOR_VIRTUAL:
			case RL2_MAP_LAYER_TOPOLOGY:
			case RL2_MAP_LAYER_NETWORK:
			    do_paint_layer_vector (sqlite, data, aux_lyr, aux);
			    if (aux_lyr->has_labels)
				aux->update_labels = 1;
			    break;
			default:
			    break;
			};
		  }
		aux_lyr = aux_lyr->next;
	    }

    if (aux->has_labels && aux->update_labels)
      {
	  /* creating a Canvas for Map Labels */
	  aux->ctx_labels =
	      rl2_graph_create_context (data, aux->width, aux->height);
	  if (aux->ctx_labels != NULL)
	    {
		rl2_prime_background (aux->ctx_labels, 0, 0, 0, 0);	/* transparent background */
		aux->canvas_labels = rl2_create_raster_canvas (aux->ctx_labels);
	    }
	  if (aux->canvas_labels != NULL)
	    {
		aux_lyr = aux->first_lyr;
		while (aux_lyr != NULL)
		  {
		      /* painting Layers with Map Labels */
		      if (aux_lyr->valid && aux_lyr->has_labels)
			{
			    switch (aux_lyr->layer->type)
			      {
			      case RL2_MAP_LAYER_VECTOR:
			      case RL2_MAP_LAYER_VECTOR_VIEW:
			      case RL2_MAP_LAYER_VECTOR_VIRTUAL:
			      case RL2_MAP_LAYER_TOPOLOGY:
			      case RL2_MAP_LAYER_NETWORK:
				  do_paint_layer_labels (sqlite, data, aux_lyr,
							 aux);
				  break;
			      default:
				  break;
			      };
			}
		      aux_lyr = aux_lyr->next;
		  }
		rl2_graph_merge (aux->ctx, aux->ctx_labels);
	    }
      }

/* preparing the full rendered Map Image */
    rgb = rl2_graph_get_context_rgb_array (aux->ctx);
    alpha = rl2_graph_get_context_alpha_array (aux->ctx, &half_transparent);
    if (rgb == NULL || alpha == NULL)
	goto error;

/* all children threads have now finished: resuming the main thread */
    for (i = 0; i < count; i++)
      {
	  params = params_array + i;
	  params->at_data = NULL;
	  params->in = NULL;
	  params->out = NULL;


	  params->opaque_thread_id = NULL;
      }
}

static void
do_mono_thread_transform (rl2TransformParamsPtr params)
{
................................................................................
    *buffer = mem->buffer;
    mem->buffer = NULL;
    *size = mem->write_offset;
    return RL2_OK;
}

RL2_DECLARE rl2CanvasPtr
rl2_create_vector_canvas (rl2GraphicsContextPtr ref_ctx,
			  rl2GraphicsContextPtr ref_ctx_labels)
{
/* allocating and initializing a Canvas object (generic Vector) */
    rl2PrivCanvasPtr canvas = NULL;
    if (ref_ctx == NULL)
	return NULL;

    canvas = malloc (sizeof (rl2PrivCanvas));
    if (canvas == NULL)
	return NULL;
    canvas->type = RL2_VECTOR_CANVAS;
    canvas->ref_ctx = ref_ctx;
    canvas->ref_ctx_labels = ref_ctx_labels;
    canvas->ref_ctx_nodes = NULL;
    canvas->ref_ctx_edges = NULL;
    canvas->ref_ctx_links = NULL;
    canvas->ref_ctx_faces = NULL;
    canvas->ref_ctx_edge_seeds = NULL;
    canvas->ref_ctx_link_seeds = NULL;
    canvas->ref_ctx_face_seeds = NULL;
    canvas->ctx_ready = RL2_FALSE;
    canvas->ctx_labels_ready = RL2_FALSE;
    canvas->ctx_nodes_ready = RL2_FALSE;
    canvas->ctx_edges_ready = RL2_FALSE;
    canvas->ctx_links_ready = RL2_FALSE;
    canvas->ctx_faces_ready = RL2_FALSE;
    canvas->ctx_edge_seeds_ready = RL2_FALSE;
    canvas->ctx_link_seeds_ready = RL2_FALSE;
    canvas->ctx_face_seeds_ready = RL2_FALSE;
    return (rl2CanvasPtr) canvas;
}

RL2_DECLARE rl2CanvasPtr
rl2_create_topology_canvas (rl2GraphicsContextPtr ref_ctx,
			    rl2GraphicsContextPtr ref_ctx_labels,
			    rl2GraphicsContextPtr ref_ctx_nodes,
			    rl2GraphicsContextPtr ref_ctx_edges,
			    rl2GraphicsContextPtr ref_ctx_faces,
			    rl2GraphicsContextPtr ref_ctx_edge_seeds,
			    rl2GraphicsContextPtr ref_ctx_face_seeds)
{
/* allocating and initializing a Canvas object (Topology) */
................................................................................
	return NULL;

    canvas = malloc (sizeof (rl2PrivCanvas));
    if (canvas == NULL)
	return NULL;
    canvas->type = RL2_TOPOLOGY_CANVAS;
    canvas->ref_ctx = ref_ctx;
    canvas->ref_ctx_labels = ref_ctx_labels;
    canvas->ref_ctx_nodes = ref_ctx_nodes;
    canvas->ref_ctx_edges = ref_ctx_edges;
    canvas->ref_ctx_links = NULL;
    canvas->ref_ctx_faces = ref_ctx_faces;
    canvas->ref_ctx_edge_seeds = ref_ctx_edge_seeds;
    canvas->ref_ctx_link_seeds = NULL;
    canvas->ref_ctx_face_seeds = ref_ctx_face_seeds;
    canvas->ctx_ready = RL2_FALSE;
    canvas->ctx_labels_ready = RL2_FALSE;
    canvas->ctx_nodes_ready = RL2_FALSE;
    canvas->ctx_edges_ready = RL2_FALSE;
    canvas->ctx_links_ready = RL2_FALSE;
    canvas->ctx_faces_ready = RL2_FALSE;
    canvas->ctx_edge_seeds_ready = RL2_FALSE;
    canvas->ctx_link_seeds_ready = RL2_FALSE;
    canvas->ctx_face_seeds_ready = RL2_FALSE;
    return (rl2CanvasPtr) canvas;
}

RL2_DECLARE rl2CanvasPtr
rl2_create_network_canvas (rl2GraphicsContextPtr ref_ctx,
			   rl2GraphicsContextPtr ref_ctx_labels,
			   rl2GraphicsContextPtr ref_ctx_nodes,
			   rl2GraphicsContextPtr ref_ctx_links,
			   rl2GraphicsContextPtr ref_ctx_link_seeds)
{
/* allocating and initializing a Canvas object (Network) */
    rl2PrivCanvasPtr canvas = NULL;
    if (ref_ctx == NULL)
................................................................................
	return NULL;

    canvas = malloc (sizeof (rl2PrivCanvas));
    if (canvas == NULL)
	return NULL;
    canvas->type = RL2_NETWORK_CANVAS;
    canvas->ref_ctx = ref_ctx;
    canvas->ref_ctx_labels = ref_ctx_labels;
    canvas->ref_ctx_nodes = ref_ctx_nodes;
    canvas->ref_ctx_edges = NULL;
    canvas->ref_ctx_links = ref_ctx_links;
    canvas->ref_ctx_faces = NULL;
    canvas->ref_ctx_edge_seeds = NULL;
    canvas->ref_ctx_link_seeds = ref_ctx_link_seeds;
    canvas->ref_ctx_face_seeds = NULL;
    canvas->ctx_ready = RL2_FALSE;
    canvas->ctx_labels_ready = RL2_FALSE;
    canvas->ctx_nodes_ready = RL2_FALSE;
    canvas->ctx_edges_ready = RL2_FALSE;
    canvas->ctx_links_ready = RL2_FALSE;
    canvas->ctx_faces_ready = RL2_FALSE;
    canvas->ctx_edge_seeds_ready = RL2_FALSE;
    canvas->ctx_link_seeds_ready = RL2_FALSE;
    canvas->ctx_face_seeds_ready = RL2_FALSE;
................................................................................
	return NULL;

    canvas = malloc (sizeof (rl2PrivCanvas));
    if (canvas == NULL)
	return NULL;
    canvas->type = RL2_RASTER_CANVAS;
    canvas->ref_ctx = ref_ctx;
    canvas->ref_ctx_labels = NULL;
    canvas->ref_ctx_nodes = NULL;
    canvas->ref_ctx_edges = NULL;
    canvas->ref_ctx_links = NULL;
    canvas->ref_ctx_faces = NULL;
    canvas->ref_ctx_edge_seeds = NULL;
    canvas->ref_ctx_link_seeds = NULL;
    canvas->ref_ctx_face_seeds = NULL;
    canvas->ctx_ready = RL2_FALSE;
    canvas->ctx_labels_ready = RL2_FALSE;
    canvas->ctx_nodes_ready = RL2_FALSE;
    canvas->ctx_edges_ready = RL2_FALSE;
    canvas->ctx_links_ready = RL2_FALSE;
    canvas->ctx_faces_ready = RL2_FALSE;
    canvas->ctx_edge_seeds_ready = RL2_FALSE;
    canvas->ctx_link_seeds_ready = RL2_FALSE;
    canvas->ctx_face_seeds_ready = RL2_FALSE;
................................................................................
	return NULL;

    canvas = malloc (sizeof (rl2PrivCanvas));
    if (canvas == NULL)
	return NULL;
    canvas->type = RL2_WMS_CANVAS;
    canvas->ref_ctx = ref_ctx;
    canvas->ref_ctx_labels = NULL;
    canvas->ref_ctx_nodes = NULL;
    canvas->ref_ctx_edges = NULL;
    canvas->ref_ctx_links = NULL;
    canvas->ref_ctx_faces = NULL;
    canvas->ref_ctx_edge_seeds = NULL;
    canvas->ref_ctx_link_seeds = NULL;
    canvas->ref_ctx_face_seeds = NULL;
    canvas->ctx_ready = RL2_FALSE;
    canvas->ctx_labels_ready = RL2_FALSE;
    canvas->ctx_nodes_ready = RL2_FALSE;
    canvas->ctx_edges_ready = RL2_FALSE;
    canvas->ctx_links_ready = RL2_FALSE;
    canvas->ctx_faces_ready = RL2_FALSE;
    canvas->ctx_edge_seeds_ready = RL2_FALSE;
    canvas->ctx_link_seeds_ready = RL2_FALSE;
    canvas->ctx_face_seeds_ready = RL2_FALSE;
................................................................................
    switch (canvas->type)
      {
      case RL2_VECTOR_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
		return canvas->ctx_ready;
	    case RL2_CANVAS_LABELS_CTX:
		return canvas->ctx_labels_ready;
	    };
	  break;
      case RL2_RASTER_CANVAS:
      case RL2_WMS_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
................................................................................
	    };
	  break;
      case RL2_TOPOLOGY_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
		return canvas->ctx_ready;
	    case RL2_CANVAS_LABELS_CTX:
		return canvas->ctx_labels_ready;
	    case RL2_CANVAS_NODES_CTX:
		return canvas->ctx_nodes_ready;
	    case RL2_CANVAS_EDGES_CTX:
		return canvas->ctx_edges_ready;
	    case RL2_CANVAS_FACES_CTX:
		return canvas->ctx_faces_ready;
	    case RL2_CANVAS_EDGE_SEEDS_CTX:
................................................................................
	    };
	  break;
      case RL2_NETWORK_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
		return canvas->ctx_ready;
	    case RL2_CANVAS_LABELS_CTX:
		return canvas->ctx_labels_ready;
	    case RL2_CANVAS_NODES_CTX:
		return canvas->ctx_nodes_ready;
	    case RL2_CANVAS_LINKS_CTX:
		return canvas->ctx_links_ready;
	    case RL2_CANVAS_LINK_SEEDS_CTX:
		return canvas->ctx_link_seeds_ready;
	    };
................................................................................
      };
    return RL2_FALSE;
}

RL2_DECLARE rl2GraphicsContextPtr
rl2_get_canvas_ctx (rl2CanvasPtr ptr, int which)
{
/* return a pointer to soma Graphics Context from a Canvas */
    rl2PrivCanvasPtr canvas = (rl2PrivCanvasPtr) ptr;
    if (canvas == NULL)
	return NULL;
    switch (canvas->type)
      {
      case RL2_VECTOR_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
		return canvas->ref_ctx;
	    case RL2_CANVAS_LABELS_CTX:
		return canvas->ref_ctx_labels;
	    };
	  break;
      case RL2_RASTER_CANVAS:
      case RL2_WMS_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
................................................................................
	    };
	  break;
      case RL2_TOPOLOGY_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
		return canvas->ref_ctx;
	    case RL2_CANVAS_LABELS_CTX:
		return canvas->ref_ctx_labels;
	    case RL2_CANVAS_NODES_CTX:
		return canvas->ref_ctx_nodes;
	    case RL2_CANVAS_EDGES_CTX:
		return canvas->ref_ctx_edges;
	    case RL2_CANVAS_FACES_CTX:
		return canvas->ref_ctx_faces;
	    case RL2_CANVAS_EDGE_SEEDS_CTX:
................................................................................
	    };
	  break;
      case RL2_NETWORK_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
		return canvas->ref_ctx;
	    case RL2_CANVAS_LABELS_CTX:
		return canvas->ref_ctx_labels;
	    case RL2_CANVAS_NODES_CTX:
		return canvas->ref_ctx_nodes;
	    case RL2_CANVAS_LINKS_CTX:
		return canvas->ref_ctx_links;
	    case RL2_CANVAS_LINK_SEEDS_CTX:
		return canvas->ref_ctx_link_seeds;
	    };

/* all children threads have now finished: resuming the main thread */
    for (i = 0; i < count; i++)
      {
	  params = params_array + i;
	  params->at_data = NULL;
	  params->in = NULL;
	  params->out = NULL;
	  if (params->opaque_thread_id != NULL)
	      free (params->opaque_thread_id);
	  params->opaque_thread_id = NULL;
      }
}

static void
do_mono_thread_transform (rl2TransformParamsPtr params)
{
................................................................................
    *buffer = mem->buffer;
    mem->buffer = NULL;
    *size = mem->write_offset;
    return RL2_OK;
}

RL2_DECLARE rl2CanvasPtr
rl2_create_vector_canvas (rl2GraphicsContextPtr ref_ctx)

{
/* allocating and initializing a Canvas object (generic Vector) */
    rl2PrivCanvasPtr canvas = NULL;
    if (ref_ctx == NULL)
	return NULL;

    canvas = malloc (sizeof (rl2PrivCanvas));
    if (canvas == NULL)
	return NULL;
    canvas->type = RL2_VECTOR_CANVAS;
    canvas->ref_ctx = ref_ctx;

    canvas->ref_ctx_nodes = NULL;
    canvas->ref_ctx_edges = NULL;
    canvas->ref_ctx_links = NULL;
    canvas->ref_ctx_faces = NULL;
    canvas->ref_ctx_edge_seeds = NULL;
    canvas->ref_ctx_link_seeds = NULL;
    canvas->ref_ctx_face_seeds = NULL;
    canvas->ctx_ready = RL2_FALSE;

    canvas->ctx_nodes_ready = RL2_FALSE;
    canvas->ctx_edges_ready = RL2_FALSE;
    canvas->ctx_links_ready = RL2_FALSE;
    canvas->ctx_faces_ready = RL2_FALSE;
    canvas->ctx_edge_seeds_ready = RL2_FALSE;
    canvas->ctx_link_seeds_ready = RL2_FALSE;
    canvas->ctx_face_seeds_ready = RL2_FALSE;
    return (rl2CanvasPtr) canvas;
}

RL2_DECLARE rl2CanvasPtr
rl2_create_topology_canvas (rl2GraphicsContextPtr ref_ctx,

			    rl2GraphicsContextPtr ref_ctx_nodes,
			    rl2GraphicsContextPtr ref_ctx_edges,
			    rl2GraphicsContextPtr ref_ctx_faces,
			    rl2GraphicsContextPtr ref_ctx_edge_seeds,
			    rl2GraphicsContextPtr ref_ctx_face_seeds)
{
/* allocating and initializing a Canvas object (Topology) */
................................................................................
	return NULL;

    canvas = malloc (sizeof (rl2PrivCanvas));
    if (canvas == NULL)
	return NULL;
    canvas->type = RL2_TOPOLOGY_CANVAS;
    canvas->ref_ctx = ref_ctx;

    canvas->ref_ctx_nodes = ref_ctx_nodes;
    canvas->ref_ctx_edges = ref_ctx_edges;
    canvas->ref_ctx_links = NULL;
    canvas->ref_ctx_faces = ref_ctx_faces;
    canvas->ref_ctx_edge_seeds = ref_ctx_edge_seeds;
    canvas->ref_ctx_link_seeds = NULL;
    canvas->ref_ctx_face_seeds = ref_ctx_face_seeds;
    canvas->ctx_ready = RL2_FALSE;

    canvas->ctx_nodes_ready = RL2_FALSE;
    canvas->ctx_edges_ready = RL2_FALSE;
    canvas->ctx_links_ready = RL2_FALSE;
    canvas->ctx_faces_ready = RL2_FALSE;
    canvas->ctx_edge_seeds_ready = RL2_FALSE;
    canvas->ctx_link_seeds_ready = RL2_FALSE;
    canvas->ctx_face_seeds_ready = RL2_FALSE;
    return (rl2CanvasPtr) canvas;
}

RL2_DECLARE rl2CanvasPtr
rl2_create_network_canvas (rl2GraphicsContextPtr ref_ctx,

			   rl2GraphicsContextPtr ref_ctx_nodes,
			   rl2GraphicsContextPtr ref_ctx_links,
			   rl2GraphicsContextPtr ref_ctx_link_seeds)
{
/* allocating and initializing a Canvas object (Network) */
    rl2PrivCanvasPtr canvas = NULL;
    if (ref_ctx == NULL)
................................................................................
	return NULL;

    canvas = malloc (sizeof (rl2PrivCanvas));
    if (canvas == NULL)
	return NULL;
    canvas->type = RL2_NETWORK_CANVAS;
    canvas->ref_ctx = ref_ctx;

    canvas->ref_ctx_nodes = ref_ctx_nodes;
    canvas->ref_ctx_edges = NULL;
    canvas->ref_ctx_links = ref_ctx_links;
    canvas->ref_ctx_faces = NULL;
    canvas->ref_ctx_edge_seeds = NULL;
    canvas->ref_ctx_link_seeds = ref_ctx_link_seeds;
    canvas->ref_ctx_face_seeds = NULL;
    canvas->ctx_ready = RL2_FALSE;

    canvas->ctx_nodes_ready = RL2_FALSE;
    canvas->ctx_edges_ready = RL2_FALSE;
    canvas->ctx_links_ready = RL2_FALSE;
    canvas->ctx_faces_ready = RL2_FALSE;
    canvas->ctx_edge_seeds_ready = RL2_FALSE;
    canvas->ctx_link_seeds_ready = RL2_FALSE;
    canvas->ctx_face_seeds_ready = RL2_FALSE;
................................................................................
	return NULL;

    canvas = malloc (sizeof (rl2PrivCanvas));
    if (canvas == NULL)
	return NULL;
    canvas->type = RL2_RASTER_CANVAS;
    canvas->ref_ctx = ref_ctx;

    canvas->ref_ctx_nodes = NULL;
    canvas->ref_ctx_edges = NULL;
    canvas->ref_ctx_links = NULL;
    canvas->ref_ctx_faces = NULL;
    canvas->ref_ctx_edge_seeds = NULL;
    canvas->ref_ctx_link_seeds = NULL;
    canvas->ref_ctx_face_seeds = NULL;
    canvas->ctx_ready = RL2_FALSE;

    canvas->ctx_nodes_ready = RL2_FALSE;
    canvas->ctx_edges_ready = RL2_FALSE;
    canvas->ctx_links_ready = RL2_FALSE;
    canvas->ctx_faces_ready = RL2_FALSE;
    canvas->ctx_edge_seeds_ready = RL2_FALSE;
    canvas->ctx_link_seeds_ready = RL2_FALSE;
    canvas->ctx_face_seeds_ready = RL2_FALSE;
................................................................................
	return NULL;

    canvas = malloc (sizeof (rl2PrivCanvas));
    if (canvas == NULL)
	return NULL;
    canvas->type = RL2_WMS_CANVAS;
    canvas->ref_ctx = ref_ctx;

    canvas->ref_ctx_nodes = NULL;
    canvas->ref_ctx_edges = NULL;
    canvas->ref_ctx_links = NULL;
    canvas->ref_ctx_faces = NULL;
    canvas->ref_ctx_edge_seeds = NULL;
    canvas->ref_ctx_link_seeds = NULL;
    canvas->ref_ctx_face_seeds = NULL;
    canvas->ctx_ready = RL2_FALSE;

    canvas->ctx_nodes_ready = RL2_FALSE;
    canvas->ctx_edges_ready = RL2_FALSE;
    canvas->ctx_links_ready = RL2_FALSE;
    canvas->ctx_faces_ready = RL2_FALSE;
    canvas->ctx_edge_seeds_ready = RL2_FALSE;
    canvas->ctx_link_seeds_ready = RL2_FALSE;
    canvas->ctx_face_seeds_ready = RL2_FALSE;
................................................................................
    switch (canvas->type)
      {
      case RL2_VECTOR_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
		return canvas->ctx_ready;


	    };
	  break;
      case RL2_RASTER_CANVAS:
      case RL2_WMS_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
................................................................................
	    };
	  break;
      case RL2_TOPOLOGY_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
		return canvas->ctx_ready;


	    case RL2_CANVAS_NODES_CTX:
		return canvas->ctx_nodes_ready;
	    case RL2_CANVAS_EDGES_CTX:
		return canvas->ctx_edges_ready;
	    case RL2_CANVAS_FACES_CTX:
		return canvas->ctx_faces_ready;
	    case RL2_CANVAS_EDGE_SEEDS_CTX:
................................................................................
	    };
	  break;
      case RL2_NETWORK_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
		return canvas->ctx_ready;


	    case RL2_CANVAS_NODES_CTX:
		return canvas->ctx_nodes_ready;
	    case RL2_CANVAS_LINKS_CTX:
		return canvas->ctx_links_ready;
	    case RL2_CANVAS_LINK_SEEDS_CTX:
		return canvas->ctx_link_seeds_ready;
	    };
................................................................................
      };
    return RL2_FALSE;
}

RL2_DECLARE rl2GraphicsContextPtr
rl2_get_canvas_ctx (rl2CanvasPtr ptr, int which)
{
/* return a pointer to some Graphics Context from a Canvas */
    rl2PrivCanvasPtr canvas = (rl2PrivCanvasPtr) ptr;
    if (canvas == NULL)
	return NULL;
    switch (canvas->type)
      {
      case RL2_VECTOR_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
		return canvas->ref_ctx;


	    };
	  break;
      case RL2_RASTER_CANVAS:
      case RL2_WMS_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
................................................................................
	    };
	  break;
      case RL2_TOPOLOGY_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
		return canvas->ref_ctx;


	    case RL2_CANVAS_NODES_CTX:
		return canvas->ref_ctx_nodes;
	    case RL2_CANVAS_EDGES_CTX:
		return canvas->ref_ctx_edges;
	    case RL2_CANVAS_FACES_CTX:
		return canvas->ref_ctx_faces;
	    case RL2_CANVAS_EDGE_SEEDS_CTX:
................................................................................
	    };
	  break;
      case RL2_NETWORK_CANVAS:
	  switch (which)
	    {
	    case RL2_CANVAS_BASE_CTX:
		return canvas->ref_ctx;


	    case RL2_CANVAS_NODES_CTX:
		return canvas->ref_ctx_nodes;
	    case RL2_CANVAS_LINKS_CTX:
		return canvas->ref_ctx_links;
	    case RL2_CANVAS_LINK_SEEDS_CTX:
		return canvas->ref_ctx_link_seeds;
	    };

      }
#endif

/* all children threads have now finished: resuming the main thread */
    for (i = 0; i < max_threads; i++)
      {
	  /* cleaning up a request slot */

	  if (shadower->opaque_thread_id != NULL)
	      free (shadower->opaque_thread_id);
	  shadower->opaque_thread_id = NULL;
      }
}

RL2_PRIVATE int

      }
#endif

/* all children threads have now finished: resuming the main thread */
    for (i = 0; i < max_threads; i++)
      {
	  /* cleaning up a request slot */
	  shadower = aux + i;
	  if (shadower->opaque_thread_id != NULL)
	      free (shadower->opaque_thread_id);
	  shadower->opaque_thread_id = NULL;
      }
}

RL2_PRIVATE int

	priv_data->max_threads = max_threads;
    else
	max_threads = 1;
    sqlite3_result_int (context, max_threads);
}

static void
fnct_GetMaxWmsRetries (sqlite3_context * context, int argc, sqlite3_value ** argv)

{
/* SQL function:
/ RL2_GetMaxWmsRetries()
/
/ return the currently set Max number of WMS Retries
*/
    int max_wms_retries = 5;
................................................................................
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (priv_data != NULL)
	max_wms_retries = priv_data->max_wms_retries;
    sqlite3_result_int (context, max_wms_retries);
}

static void
fnct_SetMaxWmsRetries (sqlite3_context * context, int argc, sqlite3_value ** argv)

{
/* SQL function:
/ RL2_SetMaxWmsRetries(INTEGER max)
/
/ return the currently set Max number of WMS Retries (after this call)
/ -1 on invalid arguments
*/
................................................................................
	priv_data->wms_pause = wms_pause;
    else
	wms_pause = 1;
    sqlite3_result_int (context, wms_pause);
}

static void
fnct_GetPdfMarginUOM (sqlite3_context * context, int argc, sqlite3_value ** argv)

{
/* SQL function:
/ RL2_GetPdfMarginUOM()
/
/ return the current Unity Of Measure for PDF empty margins
*/
    const char *uom = "in";
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (priv_data != NULL)
	{
		switch(priv_data->pdf_margin_uom)
		{
			case RL2_PDF_MARGIN_MILLIMS:
				uom = "mm";
				break;
			case RL2_PDF_MARGIN_INCHES:
			default:
				uom = "in";
				break;
		};
	}
    sqlite3_result_text (context, uom, strlen(uom), SQLITE_STATIC);
}

static void
fnct_SetPdfMarginUOM (sqlite3_context * context, int argc, sqlite3_value ** argv)

{
/* SQL function:
/ RL2_SetPdfMarginUOM(text UOM)
/
/ return the current Unity Of Measure for PDF empty margins (after this call)
/ NULL on invalid arguments
*/
    const char *uom = "in";
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	uom = (const char *)sqlite3_value_text (argv[0]);
    else
      {
	  sqlite3_result_null (context);
	  return;
      }

    if (priv_data != NULL)
    {
		if (strcasecmp(uom, "mm") == 0)
		{
			priv_data->pdf_margin_uom = RL2_PDF_MARGIN_MILLIMS;
			uom = "mm";
		}
		else
		{
			priv_data->pdf_margin_uom = RL2_PDF_MARGIN_INCHES;
			uom = "in";
		}
	}
    else
	uom = "in";
    sqlite3_result_text (context, uom, strlen(uom), SQLITE_STATIC);
}

static void
fnct_GetPdfMarginHorz (sqlite3_context * context, int argc, sqlite3_value ** argv)

{
/* SQL function:
/ RL2_GetPdfMarginHorz()
/
/ return the currently set Horizontal PDF empty margin
*/
    double margin = 0.5;
................................................................................
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (priv_data != NULL)
	margin = priv_data->pdf_margin_horz;
    sqlite3_result_double (context, margin);
}

static void
fnct_SetPdfMarginHorz (sqlite3_context * context, int argc, sqlite3_value ** argv)

{
/* SQL function:
/ RL2_SetPdfMarginHorz(double MARGIN)
/
/ return the currently set Horizontal PDF empty margin (after this call)
/ -1 on invalid arguments
*/
................................................................................
	priv_data->pdf_margin_horz = margin;
    else
	margin = 0.5;
    sqlite3_result_double (context, margin);
}

static void
fnct_GetPdfMarginVert (sqlite3_context * context, int argc, sqlite3_value ** argv)

{
/* SQL function:
/ RL2_GetPdfMarginVert()
/
/ return the currently set Horizontal PDF empty margin
*/
    double margin = 0.5;
................................................................................
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (priv_data != NULL)
	margin = priv_data->pdf_margin_vert;
    sqlite3_result_double (context, margin);
}

static void
fnct_SetPdfMarginVert (sqlite3_context * context, int argc, sqlite3_value ** argv)

{
/* SQL function:
/ RL2_SetPdfMarginVert(double MARGIN)
/
/ return the currently set Vertical PDF empty margin (after this call)
/ -1 on invalid arguments
*/
................................................................................
	priv_data->pdf_margin_vert = margin;
    else
	margin = 0.5;
    sqlite3_result_double (context, margin);
}

static void
fnct_GetPdfPaperFormat (sqlite3_context * context, int argc, sqlite3_value ** argv)

{
/* SQL function:
/ RL2_GetPdfPaperFormat()
/
/ return the current PDF Paper Format
*/
    const char *format = "A4";
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (priv_data != NULL)
	{
		switch(priv_data->pdf_paper_format)
		{
			case RL2_PDF_PAPER_FORMAT_A0:
				format = "A0";
				break;
			case RL2_PDF_PAPER_FORMAT_A1:
				format = "A1";
				break;
			case RL2_PDF_PAPER_FORMAT_A2:
				format = "A2";
				break;
			case RL2_PDF_PAPER_FORMAT_A3:
				format = "A3";
				break;
			case RL2_PDF_PAPER_FORMAT_A5:
				format = "A5";
				break;
			case RL2_PDF_PAPER_FORMAT_A4:
			default:
				format = "A4";
				break;
		};
	}
    sqlite3_result_text (context, format, strlen(format), SQLITE_STATIC);
}

static void
fnct_SetPdfPaperFormat (sqlite3_context * context, int argc, sqlite3_value ** argv)

{
/* SQL function:
/ RL2_SetPdfPaperFormat(text FORMAT)
/
/ return the current PDF Page Format (after this call)
/ NULL on invalid arguments
*/
    const char *format = "A4";
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	format = (const char *)sqlite3_value_text (argv[0]);
    else
      {
	  sqlite3_result_null (context);
	  return;
      }

    if (priv_data != NULL)
    {
		if (strcasecmp(format, "A0") == 0)
		{
			priv_data->pdf_paper_format = RL2_PDF_PAPER_FORMAT_A0;
			format = "A0";
		}
		else if (strcasecmp(format, "A1") == 0)
		{
			priv_data->pdf_paper_format = RL2_PDF_PAPER_FORMAT_A1;
			format = "A1";
		}
		else if (strcasecmp(format, "A2") == 0)
		{
			priv_data->pdf_paper_format = RL2_PDF_PAPER_FORMAT_A2;
			format = "A2";
		}
		else if (strcasecmp(format, "A3") == 0)
		{
			priv_data->pdf_paper_format = RL2_PDF_PAPER_FORMAT_A3;
			format = "A3";
		}
		else if (strcasecmp(format, "A5") == 0)
		{
			priv_data->pdf_paper_format = RL2_PDF_PAPER_FORMAT_A5;
			format = "A5";
		}
		else
		{
			priv_data->pdf_paper_format = RL2_PDF_PAPER_FORMAT_A4;
			format = "A4";
		}
	}
    else
	format = "A4";
    sqlite3_result_text (context, format, strlen(format), SQLITE_STATIC);
}

static void
fnct_GetPdfDPI (sqlite3_context * context, int argc, sqlite3_value ** argv)
{
/* SQL function:
/ RL2_GetPdfDPI()
................................................................................
/
/ return the current PDF DPI setting
*/
    int dpi = 300;
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (priv_data != NULL)
	{
		switch(priv_data->pdf_dpi)
		{
			case RL2_PDF_DPI_72:
				dpi = 72;
				break;
			case RL2_PDF_DPI_150:
				dpi = 150;
				break;
			case RL2_PDF_DPI_600:
				dpi = 600;
				break;
			case RL2_PDF_DPI_300:
			default:
				dpi = 300;
				break;
		};
	}
    sqlite3_result_int (context, dpi);
}

static void
fnct_SetPdfDPI (sqlite3_context * context, int argc, sqlite3_value ** argv)
{
/* SQL function:
................................................................................
    else
      {
	  sqlite3_result_null (context);
	  return;
      }

    if (priv_data != NULL)
    {
		if (dpi == 72)
			priv_data->pdf_dpi = RL2_PDF_DPI_72;
		else if (dpi == 150)
			priv_data->pdf_dpi = RL2_PDF_DPI_150;
		else if (dpi == 600)
			priv_data->pdf_dpi = RL2_PDF_DPI_600;
		else
		{
			priv_data->pdf_dpi = RL2_PDF_DPI_300;
			dpi = 300;
		}
	}
    else
	dpi = 300;
    sqlite3_result_int (context, dpi);
}

static void
fnct_GetPdfOrientation (sqlite3_context * context, int argc, sqlite3_value ** argv)

{
/* SQL function:
/ RL2_GetPdfOrientation()
/
/ return the current PDF Orientation setting
*/
    const char *orientation = "Portrait";
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (priv_data != NULL)
	{
		switch(priv_data->pdf_orientation)
		{
			case RL2_PDF_LANDSCAPE:
				orientation = "Landscape";
				break;
			case RL2_PDF_PORTRAIT:
			default:
				orientation = "Portrait";
				break;
		};
	}
    sqlite3_result_text (context, orientation, strlen(orientation), SQLITE_STATIC);

}

static void
fnct_SetPdfOrientation (sqlite3_context * context, int argc, sqlite3_value ** argv)

{
/* SQL function:
/ RL2_SetPdfOrientation(text ORIENTATION)
/
/ return the current PDF Orientation setting (after this call)
/ NULL on invalid arguments
*/
    const char *orientation = "Portrait";
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	orientation = (const char *)sqlite3_value_text (argv[0]);
    else
      {
	  sqlite3_result_null (context);
	  return;
      }

    if (priv_data != NULL)
    {
		if (strcasecmp(orientation, "Landscape") == 0)
		{
			priv_data->pdf_orientation = RL2_PDF_LANDSCAPE;
			orientation = "Landscape";
		}
		else
		{
			priv_data->pdf_orientation = RL2_PDF_PORTRAIT;
			orientation = "Portrait";
		}
	}
    else
	orientation = "Portrait";
    sqlite3_result_text (context, orientation, strlen(orientation), SQLITE_STATIC);

}

static void
fnct_IsAntiLabelCollisionEnabled (sqlite3_context * context, int argc,
				  sqlite3_value ** argv)
{
/* SQL function:
................................................................................
    if (priv_data != NULL)
	priv_data->labeling.no_colliding_labels = 0;
    sqlite3_result_int (context, 0);
}

static void
fnct_IsLabelWrapTextEnabled (sqlite3_context * context, int argc,
				  sqlite3_value ** argv)
{
/* SQL function:
/ RL2_IsLabelWrapTextEnabled()
/
/ return if LabelWrapText is enabled or not
*/
    int anti = 0;
................................................................................
    if (anti != 0)
	anti = 1;
    sqlite3_result_int (context, anti);
}

static void
fnct_EnableLabelWrapText (sqlite3_context * context, int argc,
			       sqlite3_value ** argv)
{
/* SQL function:
/ RL2_EnableLabelWrapText(void)
/
/ return if LabelWrapText has been enabled or not
*/
    int anti = 0;
................................................................................
	  anti = priv_data->labeling.label_wrap_text;
      }
    sqlite3_result_int (context, anti);
}

static void
fnct_DisableLabelWrapText (sqlite3_context * context, int argc,
				sqlite3_value ** argv)
{
/* SQL function:
/ RL2_DisableLabelWrapText(void)
/
/ return zero
*/
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
................................................................................
    if (priv_data != NULL)
	priv_data->labeling.label_wrap_text = 0;
    sqlite3_result_int (context, 0);
}

static void
fnct_IsLabelAutorotateEnabled (sqlite3_context * context, int argc,
				  sqlite3_value ** argv)
{
/* SQL function:
/ RL2_IsLabelAutorotateEnabled()
/
/ return if LabelAutorotate is enabled or not
*/
    int anti = 0;
................................................................................
    if (anti != 0)
	anti = 1;
    sqlite3_result_int (context, anti);
}

static void
fnct_EnableLabelAutorotate (sqlite3_context * context, int argc,
			       sqlite3_value ** argv)
{
/* SQL function:
/ RL2_EnableLabelAutorotate(void)
/
/ return if LabelAutorotate has been enabled or not
*/
    int anti = 0;
................................................................................
	  anti = priv_data->labeling.label_autorotate;
      }
    sqlite3_result_int (context, anti);
}

static void
fnct_DisableLabelAutorotate (sqlite3_context * context, int argc,
				sqlite3_value ** argv)
{
/* SQL function:
/ RL2_DisableLabelAutorotate(void)
/
/ return zero
*/
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
................................................................................
}

static void
fnct_GetBandHistogramFromImage (sqlite3_context * context, int argc,
				sqlite3_value ** argv)
{
/* SQL function:
/ GetBandHistogramFromImage(BLOBencoded statistics, TEXT mime_type, int band_index)
/
/ will return a PNG image representing the Histogram for the given Band
/ or NULL (INVALID ARGS)
/
*/
    const unsigned char *blob;
    int blob_sz;
................................................................................
/ Coverage of the MULTIBAND type and explicitly declaring
/ a default band mapping
/ returns 1 on success
/ 0 on failure, -1 on invalid arguments
*/
    const char *coverage_name;
    int on_off;

    sqlite3 *sqlite = sqlite3_context_db_handle (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (sqlite3_value_type (argv[0]) != SQLITE_TEXT)
      {
	  sqlite3_result_int (context, -1);
	  return;
      }
................................................................................
    if (sqlite3_value_type (argv[1]) != SQLITE_INTEGER)
      {
	  sqlite3_result_int (context, -1);
	  return;
      }
    coverage_name = (const char *) sqlite3_value_text (argv[0]);
    on_off = sqlite3_value_int (argv[1]);
    if (rl2_enable_dbms_coverage_auto_ndvi (sqlite, coverage_name, on_off) ==
	RL2_OK)
	sqlite3_result_int (context, 1);
    else
	sqlite3_result_int (context, 0);
}

static void
fnct_IsRasterCoverageAutoNdviEnabled (sqlite3_context * context, int argc,
................................................................................
    int n;
    double x = 0.0;
    double y = 0.0;
    double tilew;
    double tileh;
    unsigned int tile_width;
    unsigned int tile_height;
    WmsRetryListPtr retry_list = NULL; 
    char *table;
    char *xtable;
    char *sql;
    sqlite3_stmt *stmt_data = NULL;
    sqlite3_stmt *stmt_tils = NULL;
    sqlite3_stmt *stmt_sect = NULL;
    sqlite3_stmt *stmt_policies = NULL;
................................................................................
/
/ will return 1 (TRUE, success) or 0 (FALSE, failure)
/ or -1 (INVALID ARGS)
/
*/
    common_write_ascii_grid (1, context, argc, argv);
}
















































static void
common_write_ndvi_ascii_grid (int by_section, sqlite3_context * context,
			      int argc, sqlite3_value ** argv)
{
/* common export NDVI ASCII Grid implementation */
    int err = 0;
    const char *db_prefix = NULL;
    const char *cvg_name;
    const char *path;
    sqlite3_int64 section_id = 0;
    int width;
    int height;
    int red_band;

    int nir_band;
    const unsigned char *blob;
    int blob_sz;
    double resolution;
    rl2CoveragePtr coverage = NULL;
    sqlite3 *sqlite;
    const void *data;
................................................................................
	      err = 1;
	  if (sqlite3_value_type (argv[3]) != SQLITE_TEXT)
	      err = 1;
	  if (sqlite3_value_type (argv[4]) != SQLITE_INTEGER)
	      err = 1;
	  if (sqlite3_value_type (argv[5]) != SQLITE_INTEGER)
	      err = 1;
	  if (sqlite3_value_type (argv[6]) != SQLITE_INTEGER)
	      err = 1;
	  if (sqlite3_value_type (argv[7]) != SQLITE_INTEGER)

	      err = 1;
	  if (sqlite3_value_type (argv[8]) != SQLITE_BLOB)
	      err = 1;
	  if (sqlite3_value_type (argv[9]) != SQLITE_INTEGER
	      && sqlite3_value_type (argv[9]) != SQLITE_FLOAT)
	      err = 1;
	  if (argc > 10 && sqlite3_value_type (argv[10]) != SQLITE_INTEGER)
	      err = 1;
	  if (argc > 11 && sqlite3_value_type (argv[11]) != SQLITE_INTEGER)
	      err = 1;
      }
    else
      {
	  /* whole Coverage */
	  if (sqlite3_value_type (argv[0]) == SQLITE_TEXT
	      || sqlite3_value_type (argv[0]) == SQLITE_NULL)
................................................................................
	      err = 1;
	  if (sqlite3_value_type (argv[2]) != SQLITE_TEXT)
	      err = 1;
	  if (sqlite3_value_type (argv[3]) != SQLITE_INTEGER)
	      err = 1;
	  if (sqlite3_value_type (argv[4]) != SQLITE_INTEGER)
	      err = 1;
	  if (sqlite3_value_type (argv[5]) != SQLITE_INTEGER)
	      err = 1;
	  if (sqlite3_value_type (argv[6]) != SQLITE_INTEGER)

	      err = 1;
	  if (sqlite3_value_type (argv[7]) != SQLITE_BLOB)
	      err = 1;
	  if (sqlite3_value_type (argv[8]) != SQLITE_INTEGER
	      && sqlite3_value_type (argv[8]) != SQLITE_FLOAT)
	      err = 1;
	  if (argc > 9 && sqlite3_value_type (argv[9]) != SQLITE_INTEGER)
	      err = 1;
	  if (argc > 10 && sqlite3_value_type (argv[10]) != SQLITE_INTEGER)
	      err = 1;
      }
    if (err)
      {
	  sqlite3_result_int (context, -1);
	  return;
      }
................................................................................
	  if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	      db_prefix = (const char *) sqlite3_value_text (argv[0]);
	  cvg_name = (const char *) sqlite3_value_text (argv[1]);
	  section_id = sqlite3_value_int64 (argv[2]);
	  path = (const char *) sqlite3_value_text (argv[3]);
	  width = sqlite3_value_int (argv[4]);
	  height = sqlite3_value_int (argv[5]);
	  red_band = sqlite3_value_int (argv[6]);
	  nir_band = sqlite3_value_int (argv[7]);
	  blob = sqlite3_value_blob (argv[8]);
	  blob_sz = sqlite3_value_bytes (argv[8]);
	  if (sqlite3_value_type (argv[9]) == SQLITE_INTEGER)
	    {
		int ival = sqlite3_value_int (argv[9]);
		resolution = ival;
	    }
	  else
	      resolution = sqlite3_value_double (argv[9]);
	  if (argc > 10)
	      is_centered = sqlite3_value_int (argv[10]);
	  if (argc > 11)
	      decimal_digits = sqlite3_value_int (argv[11]);
      }
    else
      {
	  /* whole Coverage */
	  if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	      db_prefix = (const char *) sqlite3_value_text (argv[0]);
	  cvg_name = (const char *) sqlite3_value_text (argv[1]);
	  path = (const char *) sqlite3_value_text (argv[2]);
	  width = sqlite3_value_int (argv[3]);
	  height = sqlite3_value_int (argv[4]);
	  red_band = sqlite3_value_int (argv[5]);
	  nir_band = sqlite3_value_int (argv[6]);
	  blob = sqlite3_value_blob (argv[7]);
	  blob_sz = sqlite3_value_bytes (argv[7]);
	  if (sqlite3_value_type (argv[8]) == SQLITE_INTEGER)
	    {
		int ival = sqlite3_value_int (argv[8]);
		resolution = ival;
	    }
	  else
	      resolution = sqlite3_value_double (argv[8]);
	  if (argc > 9)
	      is_centered = sqlite3_value_int (argv[9]);
	  if (argc > 10)
	      decimal_digits = sqlite3_value_int (argv[10]);
      }

    if (decimal_digits < 1)
	decimal_digits = 0;
    if (decimal_digits > 18)
	decimal_digits = 18;

................................................................................
/* attempting to load the Coverage definitions from the DBMS */
    coverage = rl2_create_coverage_from_dbms (sqlite, db_prefix, cvg_name);
    if (coverage == NULL)
      {
	  sqlite3_result_int (context, -1);
	  return;
      }








    if (by_section)
      {
	  /* single Section */
	  ret =
	      rl2_export_section_ndvi_ascii_grid_from_dbms (sqlite,
							    max_threads, path,
							    coverage,
							    section_id,
							    resolution, minx,
							    miny, maxx, maxy,
							    width, height,
							    red_band,

							    nir_band,
							    is_centered,
							    decimal_digits);

      }
    else
      {
	  /* whole Coverage */
	  ret =
	      rl2_export_ndvi_ascii_grid_from_dbms (sqlite, max_threads, path,
						    coverage, resolution,
						    minx, miny, maxx, maxy,
						    width, height, red_band,
						    nir_band, is_centered,
						    decimal_digits);

      }
    if (ret != RL2_OK)
      {
	  errcode = 0;
	  goto error;
      }
    rl2_destroy_coverage (coverage);
................................................................................

static void
fnct_WriteNdviAsciiGrid (sqlite3_context * context, int argc,
			 sqlite3_value ** argv)
{
/* SQL function:
/ WriteNdviAsciiGrid(text db_prefix, text coverage, text ascii_path, 
/                    int width, int height, int red_band, int nir_band, 
/                    BLOB geom, double resolution)
/ WriteNdviAsciiGrid(text db_prefix, text coverage, text ascii_path, 
/                    int width, int height, int red_band, int nir_band, 
/                    BLOB geom, double resolution, int is_centered)
/ WriteNdviAsciiGrid(text db_prefix, text coverage, text ascii_path, 
/                    int width, int height, int red_band, int nir_band, 
/                    BLOB geom, double resolution, int is_centered, 
/                    int decimal_digits)
/
/ will return 1 (TRUE, success) or 0 (FALSE, failure)
/ or -1 (INVALID ARGS)
/
*/
    common_write_ndvi_ascii_grid (0, context, argc, argv);
}

static void
fnct_WriteSectionNdviAsciiGrid (sqlite3_context * context, int argc,
				sqlite3_value ** argv)
{
/* SQL function:
/ WriteSectionNdviAsciiGrid(text db_prefix, text coverage, int section_id,
/                           text ascii_path, int width, int height, 
/                           int red_band, int nir_band, BLOB geom, 

/                           double resolution)

/ WriteSectionNdviAsciiGrid(text db_prefix, text coverage, int section_id,
/                           text ascii_path, int width, int height,

/                           int red_band, int nir_band, BLOB geom, 




































/                           double resolution, int is_centered)
/ WriteSectionNdviAsciiGrid(text db_prefix, text coverage, int section_id,
/                           text ascii_path, int width, int height,


/                           int red_band, int nir_band, BLOB geom, 
/                           double resolution, int is_centered,
/                           int decimal_digits)
/
/ will return 1 (TRUE, success) or 0 (FALSE, failure)
/ or -1 (INVALID ARGS)
/
*/
    common_write_ndvi_ascii_grid (1, context, argc, argv);
}

static void
fnct_GetDrapingLastError (sqlite3_context * context, int argc,
			  sqlite3_value ** argv)
{
/* SQL function:
................................................................................
	sqlite3_result_null (context);
    else
	sqlite3_result_blob (context, image, image_size, free);
}

static void
fnct_GetImageFromMapConfiguration (sqlite3_context * context, int argc,
			    sqlite3_value ** argv)
{
/* SQL function:
/ GetImageFromMapConfiguration(text mapConf, BLOB geom, int width,
/                              int height)
/ GetImageFromMapConfiguration(text mapConf, BLOB geom, int width,
/                              int height, text format)
/ GetImageFromMapConfiguration(text mapConf, BLOB geom, int width, 
................................................................................
    if (argc > 6)
	reaspect = sqlite3_value_int (argv[6]);

    sqlite = sqlite3_context_db_handle (context);
    data = sqlite3_user_data (context);

    if (rl2_image_blob_from_map_config
	(sqlite, data, mapconf, blob, blob_sz, width, height, format, quality, reaspect, &image,
	 &image_size) != RL2_OK)
	sqlite3_result_null (context);
    else
	sqlite3_result_blob (context, image, image_size, free);
}

static void
fnct_GetTileImage (sqlite3_context * context, int argc, sqlite3_value ** argv)
................................................................................
static void
register_rl2_sql_functions (void *p_db, const void *p_data)
{
    sqlite3 *db = p_db;
    struct rl2_private_data *priv_data = (struct rl2_private_data *) p_data;
    const char *security_level;
    if (priv_data != NULL)
	  priv_data->labeling.sqlite = db;
    sqlite3_create_function (db, "rl2_version", 0,
			     SQLITE_UTF8 | SQLITE_DETERMINISTIC, 0,
			     fnct_rl2_version, 0, 0);
    sqlite3_create_function (db, "rl2_cairo_version", 0,
			     SQLITE_UTF8 | SQLITE_DETERMINISTIC, 0,
			     fnct_rl2_cairo_version, 0, 0);
    sqlite3_create_function (db, "rl2_curl_version", 0,
................................................................................
			     SQLITE_UTF8 | SQLITE_DETERMINISTIC, priv_data,
			     fnct_GetMapImageFromWMS, 0, 0);
    sqlite3_create_function (db, "GetMapImageFromWMS", 10,
			     SQLITE_UTF8 | SQLITE_DETERMINISTIC, priv_data,
			     fnct_GetMapImageFromWMS, 0, 0);
    sqlite3_create_function (db, "RL2_GetMapImageFromWMS", 10,
			     SQLITE_UTF8 | SQLITE_DETERMINISTIC, priv_data,
			     fnct_GetMapImageFromWMS, 0, 0);			     
    sqlite3_create_function (db, "GetImageFromMapConfiguration", 4,
			     SQLITE_UTF8 | SQLITE_DETERMINISTIC, priv_data,
			     fnct_GetImageFromMapConfiguration, 0, 0);
    sqlite3_create_function (db, "RL2_GetImageFromMapConfiguration", 4,
			     SQLITE_UTF8 | SQLITE_DETERMINISTIC, priv_data,
			     fnct_GetImageFromMapConfiguration, 0, 0);
    sqlite3_create_function (db, "GetImageFromMapConfiguration", 5,
................................................................................
				   fnct_WriteSectionAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteSectionAsciiGrid", 10,
				   SQLITE_UTF8, 0, fnct_WriteSectionAsciiGrid,
				   0, 0);
	  sqlite3_create_function (db, "RL2_WriteSectionAsciiGrid", 10,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionAsciiGrid, 0, 0);










	  sqlite3_create_function (db, "WriteNdviAsciiGrid", 9, SQLITE_UTF8,
				   priv_data, fnct_WriteNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteNdviAsciiGrid", 9,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteNdviAsciiGrid", 10, SQLITE_UTF8,

				   priv_data, fnct_WriteNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteNdviAsciiGrid", 10,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteNdviAsciiGrid", 11, SQLITE_UTF8,

				   priv_data, fnct_WriteNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteNdviAsciiGrid", 11,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteSectionNdviAsciiGrid", 10,



				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteSectionNdviAsciiGrid", 10,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionNdviAsciiGrid, 0, 0);















	  sqlite3_create_function (db, "WriteSectionNdviAsciiGrid", 11,
				   SQLITE_UTF8, 0,
				   fnct_WriteSectionNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteSectionNdviAsciiGrid", 11,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteSectionNdviAsciiGrid", 12,
				   SQLITE_UTF8, 0,
				   fnct_WriteSectionNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteSectionNdviAsciiGrid", 12,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionNdviAsciiGrid, 0, 0);



	  sqlite3_create_function (db, "RL2_WriteSectionNdviAsciiGrid", 12,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionNdviAsciiGrid, 0, 0);
      }
}

#ifndef LOADABLE_EXTENSION

static void
rl2_splash_screen (int verbose)
................................................................................
    register_rl2_sql_functions (db, priv_data);
    *pzErrMsg = NULL;
    return 0;
}

#if !(defined _WIN32) || defined(__MINGW32__)
/* MSVC is unable to understand this declaration */
__attribute__ ((visibility ("default")))
#endif
     RL2_DECLARE int
	 sqlite3_modrasterlite_init (sqlite3 * db, char **pzErrMsg,
				     const sqlite3_api_routines * pApi)
{
/* SQLite invokes this routine once when it dynamically loads the extension. */
    return init_rl2_extension (db, pzErrMsg, pApi);
}

#endif

	priv_data->max_threads = max_threads;
    else
	max_threads = 1;
    sqlite3_result_int (context, max_threads);
}

static void
fnct_GetMaxWmsRetries (sqlite3_context * context, int argc,
		       sqlite3_value ** argv)
{
/* SQL function:
/ RL2_GetMaxWmsRetries()
/
/ return the currently set Max number of WMS Retries
*/
    int max_wms_retries = 5;
................................................................................
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (priv_data != NULL)
	max_wms_retries = priv_data->max_wms_retries;
    sqlite3_result_int (context, max_wms_retries);
}

static void
fnct_SetMaxWmsRetries (sqlite3_context * context, int argc,
		       sqlite3_value ** argv)
{
/* SQL function:
/ RL2_SetMaxWmsRetries(INTEGER max)
/
/ return the currently set Max number of WMS Retries (after this call)
/ -1 on invalid arguments
*/
................................................................................
	priv_data->wms_pause = wms_pause;
    else
	wms_pause = 1;
    sqlite3_result_int (context, wms_pause);
}

static void
fnct_GetPdfMarginUOM (sqlite3_context * context, int argc,
		      sqlite3_value ** argv)
{
/* SQL function:
/ RL2_GetPdfMarginUOM()
/
/ return the current Unity Of Measure for PDF empty margins
*/
    const char *uom = "in";
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (priv_data != NULL)
      {
	  switch (priv_data->pdf_margin_uom)
	    {
	    case RL2_PDF_MARGIN_MILLIMS:
		uom = "mm";
		break;
	    case RL2_PDF_MARGIN_INCHES:
	    default:
		uom = "in";
		break;
	    };
      }
    sqlite3_result_text (context, uom, strlen (uom), SQLITE_STATIC);
}

static void
fnct_SetPdfMarginUOM (sqlite3_context * context, int argc,
		      sqlite3_value ** argv)
{
/* SQL function:
/ RL2_SetPdfMarginUOM(text UOM)
/
/ return the current Unity Of Measure for PDF empty margins (after this call)
/ NULL on invalid arguments
*/
    const char *uom = "in";
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	uom = (const char *) sqlite3_value_text (argv[0]);
    else
      {
	  sqlite3_result_null (context);
	  return;
      }

    if (priv_data != NULL)
      {
	  if (strcasecmp (uom, "mm") == 0)
	    {
		priv_data->pdf_margin_uom = RL2_PDF_MARGIN_MILLIMS;
		uom = "mm";
	    }
	  else
	    {
		priv_data->pdf_margin_uom = RL2_PDF_MARGIN_INCHES;
		uom = "in";
	    }
      }
    else
	uom = "in";
    sqlite3_result_text (context, uom, strlen (uom), SQLITE_STATIC);
}

static void
fnct_GetPdfMarginHorz (sqlite3_context * context, int argc,
		       sqlite3_value ** argv)
{
/* SQL function:
/ RL2_GetPdfMarginHorz()
/
/ return the currently set Horizontal PDF empty margin
*/
    double margin = 0.5;
................................................................................
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (priv_data != NULL)
	margin = priv_data->pdf_margin_horz;
    sqlite3_result_double (context, margin);
}

static void
fnct_SetPdfMarginHorz (sqlite3_context * context, int argc,
		       sqlite3_value ** argv)
{
/* SQL function:
/ RL2_SetPdfMarginHorz(double MARGIN)
/
/ return the currently set Horizontal PDF empty margin (after this call)
/ -1 on invalid arguments
*/
................................................................................
	priv_data->pdf_margin_horz = margin;
    else
	margin = 0.5;
    sqlite3_result_double (context, margin);
}

static void
fnct_GetPdfMarginVert (sqlite3_context * context, int argc,
		       sqlite3_value ** argv)
{
/* SQL function:
/ RL2_GetPdfMarginVert()
/
/ return the currently set Horizontal PDF empty margin
*/
    double margin = 0.5;
................................................................................
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (priv_data != NULL)
	margin = priv_data->pdf_margin_vert;
    sqlite3_result_double (context, margin);
}

static void
fnct_SetPdfMarginVert (sqlite3_context * context, int argc,
		       sqlite3_value ** argv)
{
/* SQL function:
/ RL2_SetPdfMarginVert(double MARGIN)
/
/ return the currently set Vertical PDF empty margin (after this call)
/ -1 on invalid arguments
*/
................................................................................
	priv_data->pdf_margin_vert = margin;
    else
	margin = 0.5;
    sqlite3_result_double (context, margin);
}

static void
fnct_GetPdfPaperFormat (sqlite3_context * context, int argc,
			sqlite3_value ** argv)
{
/* SQL function:
/ RL2_GetPdfPaperFormat()
/
/ return the current PDF Paper Format
*/
    const char *format = "A4";
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (priv_data != NULL)
      {
	  switch (priv_data->pdf_paper_format)
	    {
	    case RL2_PDF_PAPER_FORMAT_A0:
		format = "A0";
		break;
	    case RL2_PDF_PAPER_FORMAT_A1:
		format = "A1";
		break;
	    case RL2_PDF_PAPER_FORMAT_A2:
		format = "A2";
		break;
	    case RL2_PDF_PAPER_FORMAT_A3:
		format = "A3";
		break;
	    case RL2_PDF_PAPER_FORMAT_A5:
		format = "A5";
		break;
	    case RL2_PDF_PAPER_FORMAT_A4:
	    default:
		format = "A4";
		break;
	    };
      }
    sqlite3_result_text (context, format, strlen (format), SQLITE_STATIC);
}

static void
fnct_SetPdfPaperFormat (sqlite3_context * context, int argc,
			sqlite3_value ** argv)
{
/* SQL function:
/ RL2_SetPdfPaperFormat(text FORMAT)
/
/ return the current PDF Page Format (after this call)
/ NULL on invalid arguments
*/
    const char *format = "A4";
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	format = (const char *) sqlite3_value_text (argv[0]);
    else
      {
	  sqlite3_result_null (context);
	  return;
      }

    if (priv_data != NULL)
      {
	  if (strcasecmp (format, "A0") == 0)
	    {
		priv_data->pdf_paper_format = RL2_PDF_PAPER_FORMAT_A0;
		format = "A0";
	    }
	  else if (strcasecmp (format, "A1") == 0)
	    {
		priv_data->pdf_paper_format = RL2_PDF_PAPER_FORMAT_A1;
		format = "A1";
	    }
	  else if (strcasecmp (format, "A2") == 0)
	    {
		priv_data->pdf_paper_format = RL2_PDF_PAPER_FORMAT_A2;
		format = "A2";
	    }
	  else if (strcasecmp (format, "A3") == 0)
	    {
		priv_data->pdf_paper_format = RL2_PDF_PAPER_FORMAT_A3;
		format = "A3";
	    }
	  else if (strcasecmp (format, "A5") == 0)
	    {
		priv_data->pdf_paper_format = RL2_PDF_PAPER_FORMAT_A5;
		format = "A5";
	    }
	  else
	    {
		priv_data->pdf_paper_format = RL2_PDF_PAPER_FORMAT_A4;
		format = "A4";
	    }
      }
    else
	format = "A4";
    sqlite3_result_text (context, format, strlen (format), SQLITE_STATIC);
}

static void
fnct_GetPdfDPI (sqlite3_context * context, int argc, sqlite3_value ** argv)
{
/* SQL function:
/ RL2_GetPdfDPI()
................................................................................
/
/ return the current PDF DPI setting
*/
    int dpi = 300;
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (priv_data != NULL)
      {
	  switch (priv_data->pdf_dpi)
	    {
	    case RL2_PDF_DPI_72:
		dpi = 72;
		break;
	    case RL2_PDF_DPI_150:
		dpi = 150;
		break;
	    case RL2_PDF_DPI_600:
		dpi = 600;
		break;
	    case RL2_PDF_DPI_300:
	    default:
		dpi = 300;
		break;
	    };
      }
    sqlite3_result_int (context, dpi);
}

static void
fnct_SetPdfDPI (sqlite3_context * context, int argc, sqlite3_value ** argv)
{
/* SQL function:
................................................................................
    else
      {
	  sqlite3_result_null (context);
	  return;
      }

    if (priv_data != NULL)
      {
	  if (dpi == 72)
	      priv_data->pdf_dpi = RL2_PDF_DPI_72;
	  else if (dpi == 150)
	      priv_data->pdf_dpi = RL2_PDF_DPI_150;
	  else if (dpi == 600)
	      priv_data->pdf_dpi = RL2_PDF_DPI_600;
	  else
	    {
		priv_data->pdf_dpi = RL2_PDF_DPI_300;
		dpi = 300;
	    }
      }
    else
	dpi = 300;
    sqlite3_result_int (context, dpi);
}

static void
fnct_GetPdfOrientation (sqlite3_context * context, int argc,
			sqlite3_value ** argv)
{
/* SQL function:
/ RL2_GetPdfOrientation()
/
/ return the current PDF Orientation setting
*/
    const char *orientation = "Portrait";
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (priv_data != NULL)
      {
	  switch (priv_data->pdf_orientation)
	    {
	    case RL2_PDF_LANDSCAPE:
		orientation = "Landscape";
		break;
	    case RL2_PDF_PORTRAIT:
	    default:
		orientation = "Portrait";
		break;
	    };
      }
    sqlite3_result_text (context, orientation, strlen (orientation),
			 SQLITE_STATIC);
}

static void
fnct_SetPdfOrientation (sqlite3_context * context, int argc,
			sqlite3_value ** argv)
{
/* SQL function:
/ RL2_SetPdfOrientation(text ORIENTATION)
/
/ return the current PDF Orientation setting (after this call)
/ NULL on invalid arguments
*/
    const char *orientation = "Portrait";
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	orientation = (const char *) sqlite3_value_text (argv[0]);
    else
      {
	  sqlite3_result_null (context);
	  return;
      }

    if (priv_data != NULL)
      {
	  if (strcasecmp (orientation, "Landscape") == 0)
	    {
		priv_data->pdf_orientation = RL2_PDF_LANDSCAPE;
		orientation = "Landscape";
	    }
	  else
	    {
		priv_data->pdf_orientation = RL2_PDF_PORTRAIT;
		orientation = "Portrait";
	    }
      }
    else
	orientation = "Portrait";
    sqlite3_result_text (context, orientation, strlen (orientation),
			 SQLITE_STATIC);
}

static void
fnct_IsAntiLabelCollisionEnabled (sqlite3_context * context, int argc,
				  sqlite3_value ** argv)
{
/* SQL function:
................................................................................
    if (priv_data != NULL)
	priv_data->labeling.no_colliding_labels = 0;
    sqlite3_result_int (context, 0);
}

static void
fnct_IsLabelWrapTextEnabled (sqlite3_context * context, int argc,
			     sqlite3_value ** argv)
{
/* SQL function:
/ RL2_IsLabelWrapTextEnabled()
/
/ return if LabelWrapText is enabled or not
*/
    int anti = 0;
................................................................................
    if (anti != 0)
	anti = 1;
    sqlite3_result_int (context, anti);
}

static void
fnct_EnableLabelWrapText (sqlite3_context * context, int argc,
			  sqlite3_value ** argv)
{
/* SQL function:
/ RL2_EnableLabelWrapText(void)
/
/ return if LabelWrapText has been enabled or not
*/
    int anti = 0;
................................................................................
	  anti = priv_data->labeling.label_wrap_text;
      }
    sqlite3_result_int (context, anti);
}

static void
fnct_DisableLabelWrapText (sqlite3_context * context, int argc,
			   sqlite3_value ** argv)
{
/* SQL function:
/ RL2_DisableLabelWrapText(void)
/
/ return zero
*/
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
................................................................................
    if (priv_data != NULL)
	priv_data->labeling.label_wrap_text = 0;
    sqlite3_result_int (context, 0);
}

static void
fnct_IsLabelAutorotateEnabled (sqlite3_context * context, int argc,
			       sqlite3_value ** argv)
{
/* SQL function:
/ RL2_IsLabelAutorotateEnabled()
/
/ return if LabelAutorotate is enabled or not
*/
    int anti = 0;
................................................................................
    if (anti != 0)
	anti = 1;
    sqlite3_result_int (context, anti);
}

static void
fnct_EnableLabelAutorotate (sqlite3_context * context, int argc,
			    sqlite3_value ** argv)
{
/* SQL function:
/ RL2_EnableLabelAutorotate(void)
/
/ return if LabelAutorotate has been enabled or not
*/
    int anti = 0;
................................................................................
	  anti = priv_data->labeling.label_autorotate;
      }
    sqlite3_result_int (context, anti);
}

static void
fnct_DisableLabelAutorotate (sqlite3_context * context, int argc,
			     sqlite3_value ** argv)
{
/* SQL function:
/ RL2_DisableLabelAutorotate(void)
/
/ return zero
*/
    struct rl2_private_data *priv_data = sqlite3_user_data (context);
................................................................................
}

static void
fnct_GetBandHistogramFromImage (sqlite3_context * context, int argc,
				sqlite3_value ** argv)
{
/* SQL function:
/ GetBandHistogramFromImage(BLOBencoded image, TEXT mime_type, int band_index)
/
/ will return a PNG image representing the Histogram for the given Band
/ or NULL (INVALID ARGS)
/
*/
    const unsigned char *blob;
    int blob_sz;
................................................................................
/ Coverage of the MULTIBAND type and explicitly declaring
/ a default band mapping
/ returns 1 on success
/ 0 on failure, -1 on invalid arguments
*/
    const char *coverage_name;
    int on_off;
    int ret;
    sqlite3 *sqlite = sqlite3_context_db_handle (context);
    RL2_UNUSED ();		/* LCOV_EXCL_LINE */
    if (sqlite3_value_type (argv[0]) != SQLITE_TEXT)
      {
	  sqlite3_result_int (context, -1);
	  return;
      }
................................................................................
    if (sqlite3_value_type (argv[1]) != SQLITE_INTEGER)
      {
	  sqlite3_result_int (context, -1);
	  return;
      }
    coverage_name = (const char *) sqlite3_value_text (argv[0]);
    on_off = sqlite3_value_int (argv[1]);
    ret = rl2_enable_dbms_coverage_auto_ndvi (sqlite, coverage_name, on_off);
    if (ret == RL2_OK)
	sqlite3_result_int (context, 1);
    else
	sqlite3_result_int (context, 0);
}

static void
fnct_IsRasterCoverageAutoNdviEnabled (sqlite3_context * context, int argc,
................................................................................
    int n;
    double x = 0.0;
    double y = 0.0;
    double tilew;
    double tileh;
    unsigned int tile_width;
    unsigned int tile_height;
    WmsRetryListPtr retry_list = NULL;
    char *table;
    char *xtable;
    char *sql;
    sqlite3_stmt *stmt_data = NULL;
    sqlite3_stmt *stmt_tils = NULL;
    sqlite3_stmt *stmt_sect = NULL;
    sqlite3_stmt *stmt_policies = NULL;
................................................................................
/
/ will return 1 (TRUE, success) or 0 (FALSE, failure)
/ or -1 (INVALID ARGS)
/
*/
    common_write_ascii_grid (1, context, argc, argv);
}

static int
do_retrieve_ndvi_band_selection (sqlite3 * sqlite, const char *db_prefix,
				 const char *cvg_name, int *red_band,
				 int *green_band, int *nir_band)
{
/* attempting to retrieve the NDVI/NDWI Default Band selection */
    int ret;
    char **results;
    int rows;
    int columns;
    int i;
    char *sql;
    char *xdb_prefix;
    int cnt = 0;

    if (db_prefix == NULL)
	db_prefix = "main";
    xdb_prefix = rl2_double_quoted_sql (db_prefix);
    sql =
	sqlite3_mprintf
	("SELECT red_band_index, green_band_index, nir_band_index FROM \"%s\".raster_coverages "
	 "WHERE coverage_name = Lower(%Q) AND red_band_index IS NOT NULL "
	 "AND green_band_index IS NOT NULL AND nir_band_index IS NOT NULL "
	 "AND enable_auto_ndvi = 1", xdb_prefix, cvg_name);
    free (xdb_prefix);
    ret = sqlite3_get_table (sqlite, sql, &results, &rows, &columns, NULL);
    sqlite3_free (sql);
    if (ret != SQLITE_OK)
	goto error;
    for (i = 1; i <= rows; i++)
      {
	  const char *red = results[(i * columns) + 0];
	  const char *green = results[(i * columns) + 1];
	  const char *nir = results[(i * columns) + 2];
	  *red_band = atoi (red);
	  *green_band = atoi (green);
	  *nir_band = atoi (nir);
	  cnt++;
      }
    sqlite3_free_table (results);
    if (cnt == 1)
	return 1;

  error:
    return 0;
}

static void
common_write_ndvi_ascii_grid (int by_section, sqlite3_context * context,
			      int argc, sqlite3_value ** argv, int ndwi_mode)
{
/* common export NDVI/NDWI ASCII Grid implementation */
    int err = 0;
    const char *db_prefix = NULL;
    const char *cvg_name;
    const char *path;
    sqlite3_int64 section_id = 0;
    int width;
    int height;
    int red_band = -1;
    int green_band = -1;
    int nir_band;
    const unsigned char *blob;
    int blob_sz;
    double resolution;
    rl2CoveragePtr coverage = NULL;
    sqlite3 *sqlite;
    const void *data;
................................................................................
	      err = 1;
	  if (sqlite3_value_type (argv[3]) != SQLITE_TEXT)
	      err = 1;
	  if (sqlite3_value_type (argv[4]) != SQLITE_INTEGER)
	      err = 1;
	  if (sqlite3_value_type (argv[5]) != SQLITE_INTEGER)
	      err = 1;
	  if (sqlite3_value_type (argv[6]) != SQLITE_BLOB)
	      err = 1;
	  if (sqlite3_value_type (argv[7]) != SQLITE_INTEGER
	      && sqlite3_value_type (argv[7]) != SQLITE_FLOAT)
	      err = 1;
	  if (argc > 8 && sqlite3_value_type (argv[8]) != SQLITE_INTEGER)
	      err = 1;
	  if (argc > 9 && sqlite3_value_type (argv[9]) != SQLITE_INTEGER)





	      err = 1;
      }
    else
      {
	  /* whole Coverage */
	  if (sqlite3_value_type (argv[0]) == SQLITE_TEXT
	      || sqlite3_value_type (argv[0]) == SQLITE_NULL)
................................................................................
	      err = 1;
	  if (sqlite3_value_type (argv[2]) != SQLITE_TEXT)
	      err = 1;
	  if (sqlite3_value_type (argv[3]) != SQLITE_INTEGER)
	      err = 1;
	  if (sqlite3_value_type (argv[4]) != SQLITE_INTEGER)
	      err = 1;
	  if (sqlite3_value_type (argv[5]) != SQLITE_BLOB)
	      err = 1;
	  if (sqlite3_value_type (argv[6]) != SQLITE_INTEGER
	      && sqlite3_value_type (argv[6]) != SQLITE_FLOAT)
	      err = 1;
	  if (argc > 7 && sqlite3_value_type (argv[7]) != SQLITE_INTEGER)
	      err = 1;
	  if (argc > 8 && sqlite3_value_type (argv[8]) != SQLITE_INTEGER)





	      err = 1;
      }
    if (err)
      {
	  sqlite3_result_int (context, -1);
	  return;
      }
................................................................................
	  if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	      db_prefix = (const char *) sqlite3_value_text (argv[0]);
	  cvg_name = (const char *) sqlite3_value_text (argv[1]);
	  section_id = sqlite3_value_int64 (argv[2]);
	  path = (const char *) sqlite3_value_text (argv[3]);
	  width = sqlite3_value_int (argv[4]);
	  height = sqlite3_value_int (argv[5]);


	  blob = sqlite3_value_blob (argv[6]);
	  blob_sz = sqlite3_value_bytes (argv[6]);
	  if (sqlite3_value_type (argv[7]) == SQLITE_INTEGER)
	    {
		int ival = sqlite3_value_int (argv[7]);
		resolution = ival;
	    }
	  else
	      resolution = sqlite3_value_double (argv[7]);
	  if (argc > 8)
	      is_centered = sqlite3_value_int (argv[8]);
	  if (argc > 9)
	      decimal_digits = sqlite3_value_int (argv[9]);
      }
    else
      {
	  /* whole Coverage */
	  if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	      db_prefix = (const char *) sqlite3_value_text (argv[0]);
	  cvg_name = (const char *) sqlite3_value_text (argv[1]);
	  path = (const char *) sqlite3_value_text (argv[2]);
	  width = sqlite3_value_int (argv[3]);
	  height = sqlite3_value_int (argv[4]);


	  blob = sqlite3_value_blob (argv[5]);
	  blob_sz = sqlite3_value_bytes (argv[5]);
	  if (sqlite3_value_type (argv[6]) == SQLITE_INTEGER)
	    {
		int ival = sqlite3_value_int (argv[6]);
		resolution = ival;
	    }
	  else
	      resolution = sqlite3_value_double (argv[6]);
	  if (argc > 7)
	      is_centered = sqlite3_value_int (argv[7]);
	  if (argc > 8)
	      decimal_digits = sqlite3_value_int (argv[8]);
      }

    if (decimal_digits < 1)
	decimal_digits = 0;
    if (decimal_digits > 18)
	decimal_digits = 18;

................................................................................
/* attempting to load the Coverage definitions from the DBMS */
    coverage = rl2_create_coverage_from_dbms (sqlite, db_prefix, cvg_name);
    if (coverage == NULL)
      {
	  sqlite3_result_int (context, -1);
	  return;
      }
/* attempting to retrieve the Default Band NDVI selection */
    if (!do_retrieve_ndvi_band_selection
	(sqlite, db_prefix, cvg_name, &red_band, &green_band, &nir_band))
      {
	  sqlite3_result_int (context, -1);
	  return;
      }

    if (by_section)
      {
	  /* single Section */
	  ret =
	      rl2_export_section_ndvi_ascii_grid_from_dbms (sqlite,
							    max_threads, path,
							    coverage,
							    section_id,
							    resolution, minx,
							    miny, maxx, maxy,
							    width, height,
							    red_band,
							    green_band,
							    nir_band,
							    is_centered,
							    decimal_digits,
							    ndwi_mode);
      }
    else
      {
	  /* whole Coverage */
	  ret =
	      rl2_export_ndvi_ascii_grid_from_dbms (sqlite, max_threads, path,
						    coverage, resolution,
						    minx, miny, maxx, maxy,
						    width, height, red_band,
						    green_band, nir_band,
						    is_centered, decimal_digits,
						    ndwi_mode);
      }
    if (ret != RL2_OK)
      {
	  errcode = 0;
	  goto error;
      }
    rl2_destroy_coverage (coverage);
................................................................................

static void
fnct_WriteNdviAsciiGrid (sqlite3_context * context, int argc,
			 sqlite3_value ** argv)
{
/* SQL function:
/ WriteNdviAsciiGrid(text db_prefix, text coverage, text ascii_path, 
/                    int width, int height, BLOB geom, double resolution)

/ WriteNdviAsciiGrid(text db_prefix, text coverage, text ascii_path, 
/                    int width, int height, BLOB geom, double resolution,
/                    int is_centered)
/ WriteNdviAsciiGrid(text db_prefix, text coverage, text ascii_path, 
/                    int width, int height, BLOB geom, double resolution, 

/                    int is_centered, int decimal_digits)
/
/ will return 1 (TRUE, success) or 0 (FALSE, failure)
/ or -1 (INVALID ARGS)
/
*/
    common_write_ndvi_ascii_grid (0, context, argc, argv, 0);
}

static void
fnct_WriteSectionNdviAsciiGrid (sqlite3_context * context, int argc,
				sqlite3_value ** argv)
{
/* SQL function:
/ WriteSectionNdviAsciiGrid(text db_prefix, text coverage, int section_id,
/                           text ascii_path, int width, int height, 
/                           BLOB geom, double resolution)
/ WriteSectionNdviAsciiGrid(text db_prefix, text coverage, int section_id,
/                           text ascii_path, int width, int height,
/                           BLOB geom, double resolution, int is_centered)
/ WriteSectionNdviAsciiGrid(text db_prefix, text coverage, int section_id,
/                           text ascii_path, int width, int height,
/                           BLOB geom, double resolution, int is_centered,
/                           int decimal_digits)
/
/ will return 1 (TRUE, success) or 0 (FALSE, failure)
/ or -1 (INVALID ARGS)
/
*/
    common_write_ndvi_ascii_grid (1, context, argc, argv, 0);
}

static void
fnct_WriteNdwiAsciiGrid (sqlite3_context * context, int argc,
			 sqlite3_value ** argv)
{
/* SQL function:
/ WriteNdwiAsciiGrid(text db_prefix, text coverage, text ascii_path, 
/                    int width, int height, BLOB geom, double resolution)
/ WriteNdwiAsciiGrid(text db_prefix, text coverage, text ascii_path, 
/                    int width, int height, BLOB geom, double resolution,
/                    int is_centered)
/ WriteNdwiAsciiGrid(text db_prefix, text coverage, text ascii_path, 
/                    int width, int height, BLOB geom, double resolution,
/                    int is_centered, int decimal_digits)
/
/ will return 1 (TRUE, success) or 0 (FALSE, failure)
/ or -1 (INVALID ARGS)
/
*/
    common_write_ndvi_ascii_grid (0, context, argc, argv, 1);
}

static void
fnct_WriteSectionNdwiAsciiGrid (sqlite3_context * context, int argc,
				sqlite3_value ** argv)
{
/* SQL function:
/ WriteSectionNdwiAsciiGrid(text db_prefix, text coverage, int section_id,
/                           text ascii_path, int width, int height, 
/                           BLOB geom, double resolution)
/ WriteSectionNdwiAsciiGrid(text db_prefix, text coverage, int section_id,
/                           text ascii_path, int width, int height,
/                           BLOB geom, double resolution, int is_centered)
/ WriteSectionNdwiAsciiGrid(text db_prefix, text coverage, int section_id,
/                           text ascii_path, int width, int height,
/                           BLOB geom, double resolution, int is_centered,
/                           int decimal_digits)
/
/ will return 1 (TRUE, success) or 0 (FALSE, failure)
/ or -1 (INVALID ARGS)
/
*/
    common_write_ndvi_ascii_grid (1, context, argc, argv, 1);
}

static void
fnct_GetDrapingLastError (sqlite3_context * context, int argc,
			  sqlite3_value ** argv)
{
/* SQL function:
................................................................................
	sqlite3_result_null (context);
    else
	sqlite3_result_blob (context, image, image_size, free);
}

static void
fnct_GetImageFromMapConfiguration (sqlite3_context * context, int argc,
				   sqlite3_value ** argv)
{
/* SQL function:
/ GetImageFromMapConfiguration(text mapConf, BLOB geom, int width,
/                              int height)
/ GetImageFromMapConfiguration(text mapConf, BLOB geom, int width,
/                              int height, text format)
/ GetImageFromMapConfiguration(text mapConf, BLOB geom, int width, 
................................................................................
    if (argc > 6)
	reaspect = sqlite3_value_int (argv[6]);

    sqlite = sqlite3_context_db_handle (context);
    data = sqlite3_user_data (context);

    if (rl2_image_blob_from_map_config
	(sqlite, data, mapconf, blob, blob_sz, width, height, format, quality,
	 reaspect, &image, &image_size) != RL2_OK)
	sqlite3_result_null (context);
    else
	sqlite3_result_blob (context, image, image_size, free);
}

static void
fnct_GetTileImage (sqlite3_context * context, int argc, sqlite3_value ** argv)
................................................................................
static void
register_rl2_sql_functions (void *p_db, const void *p_data)
{
    sqlite3 *db = p_db;
    struct rl2_private_data *priv_data = (struct rl2_private_data *) p_data;
    const char *security_level;
    if (priv_data != NULL)
	priv_data->labeling.sqlite = db;
    sqlite3_create_function (db, "rl2_version", 0,
			     SQLITE_UTF8 | SQLITE_DETERMINISTIC, 0,
			     fnct_rl2_version, 0, 0);
    sqlite3_create_function (db, "rl2_cairo_version", 0,
			     SQLITE_UTF8 | SQLITE_DETERMINISTIC, 0,
			     fnct_rl2_cairo_version, 0, 0);
    sqlite3_create_function (db, "rl2_curl_version", 0,
................................................................................
			     SQLITE_UTF8 | SQLITE_DETERMINISTIC, priv_data,
			     fnct_GetMapImageFromWMS, 0, 0);
    sqlite3_create_function (db, "GetMapImageFromWMS", 10,
			     SQLITE_UTF8 | SQLITE_DETERMINISTIC, priv_data,
			     fnct_GetMapImageFromWMS, 0, 0);
    sqlite3_create_function (db, "RL2_GetMapImageFromWMS", 10,
			     SQLITE_UTF8 | SQLITE_DETERMINISTIC, priv_data,
			     fnct_GetMapImageFromWMS, 0, 0);
    sqlite3_create_function (db, "GetImageFromMapConfiguration", 4,
			     SQLITE_UTF8 | SQLITE_DETERMINISTIC, priv_data,
			     fnct_GetImageFromMapConfiguration, 0, 0);
    sqlite3_create_function (db, "RL2_GetImageFromMapConfiguration", 4,
			     SQLITE_UTF8 | SQLITE_DETERMINISTIC, priv_data,
			     fnct_GetImageFromMapConfiguration, 0, 0);
    sqlite3_create_function (db, "GetImageFromMapConfiguration", 5,
................................................................................
				   fnct_WriteSectionAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteSectionAsciiGrid", 10,
				   SQLITE_UTF8, 0, fnct_WriteSectionAsciiGrid,
				   0, 0);
	  sqlite3_create_function (db, "RL2_WriteSectionAsciiGrid", 10,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteNdviAsciiGrid", 7, SQLITE_UTF8,
				   priv_data, fnct_WriteNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteNdviAsciiGrid", 7,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteNdviAsciiGrid", 8, SQLITE_UTF8,
				   priv_data, fnct_WriteNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteNdviAsciiGrid", 8,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteNdviAsciiGrid", 9, SQLITE_UTF8,
				   priv_data, fnct_WriteNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteNdviAsciiGrid", 9,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteSectionNdviAsciiGrid", 8,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteSectionNdviAsciiGrid", 8,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteSectionNdviAsciiGrid", 9,
				   SQLITE_UTF8, 0,
				   fnct_WriteSectionNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteSectionNdviAsciiGrid", 9,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteSectionNdviAsciiGrid", 10,
				   SQLITE_UTF8, 0,
				   fnct_WriteSectionNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteSectionNdviAsciiGrid", 10,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteSectionNdviAsciiGrid", 10,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionNdviAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteNdwiAsciiGrid", 7, SQLITE_UTF8,
				   priv_data, fnct_WriteNdwiAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteNdwiAsciiGrid", 7,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteNdwiAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteNdwiAsciiGrid", 8, SQLITE_UTF8,
				   priv_data, fnct_WriteNdwiAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteNdwiAsciiGrid", 8,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteNdwiAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteNdwiAsciiGrid", 9, SQLITE_UTF8,
				   priv_data, fnct_WriteNdwiAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteNdwiAsciiGrid", 9,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteNdwiAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteSectionNdwiAsciiGrid", 8,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionNdwiAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteSectionNdwiAsciiGrid", 8,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionNdwiAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteSectionNdwiAsciiGrid", 9,
				   SQLITE_UTF8, 0,
				   fnct_WriteSectionNdwiAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteSectionNdwiAsciiGrid", 9,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionNdwiAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "WriteSectionNdwiAsciiGrid", 10,
				   SQLITE_UTF8, 0,
				   fnct_WriteSectionNdwiAsciiGrid, 0, 0);
	  sqlite3_create_function (db, "RL2_WriteSectionNdwiAsciiGrid", 10,
				   SQLITE_UTF8, priv_data,
				   fnct_WriteSectionNdwiAsciiGrid, 0, 0);
      }
}

#ifndef LOADABLE_EXTENSION

static void
rl2_splash_screen (int verbose)
................................................................................
    register_rl2_sql_functions (db, priv_data);
    *pzErrMsg = NULL;
    return 0;
}

#if !(defined _WIN32) || defined(__MINGW32__)
/* MSVC is unable to understand this declaration */
__attribute__((visibility ("default")))
#endif
     RL2_DECLARE int
	 sqlite3_modrasterlite_init (sqlite3 * db, char **pzErrMsg,
				     const sqlite3_api_routines * pApi)
{
/* SQLite invokes this routine once when it dynamically loads the extension. */
    return init_rl2_extension (db, pzErrMsg, pApi);
}

#endif

    const char *style_name;
    const unsigned char *xml_style;
    int with_nodes;
    int with_edges_or_links;
    int with_faces;
    int with_edge_or_link_seeds;
    int with_face_seeds;
    int has_labels;
    struct aux_raster_image *output;
};

#define RL2_UNUSED() if (argc || argv) argc = argc;

RL2_PRIVATE int
get_coverage_sample_bands (sqlite3 * sqlite, const char *db_prefix,
................................................................................
    int j;
    int ret;
    int reproject_on_the_fly;
    int has_extra_columns;
    rl2VariantArrayPtr variant = NULL;
    rl2GraphicsContextPtr ctx = NULL;
    rl2GraphicsContextPtr ctx_labels = NULL;
    int has_labels = 0;
    unsigned char *rgb = NULL;
    unsigned char *alpha = NULL;
    int half_transparent;
    int is_topogeo = 0;
    int is_toponet = 0;
    int which = RL2_CANVAS_UNKNOWN_CTX;

................................................................................
		  }
	    }
	  else
	    {
		/* using the Canvas Base Graphics Context */
		ctx = rl2_get_canvas_ctx (canvas, RL2_CANVAS_BASE_CTX);
	    }
	  has_labels = rl2_style_has_labels (lyr_stl);
	  if (has_labels)
	    {
		ctx_labels = rl2_get_canvas_ctx (canvas, RL2_CANVAS_LABELS_CTX);
		if (ctx_labels == NULL)
		    goto error;
	    }
	  if (ctx == NULL)
	      goto error;

	  /* composing the SQL query */
	  toponame = sqlite3_mprintf ("%s", lyr->f_table_name);
	  len = strlen (lyr->f_table_name);
	  if (len > 5)
................................................................................
					break;
				    };
			      }
			}
		      if (geom != NULL)
			{
			    /* drawing a styled Feature */
			    int has_labels;
			    int scale_forbidden = 0;
			    symbolizer = NULL;
			    if (lyr_stl != NULL)
				symbolizer =
				    rl2_get_symbolizer_from_feature_type_style
				    (lyr_stl, scale, variant, &scale_forbidden);
			    if (!scale_forbidden)
				rl2_draw_vector_feature (ctx, ctx_labels,
							 sqlite, priv_data,
							 symbolizer, height,
							 minx, miny, maxx, maxy,
							 x_res, y_res, geom,
							 variant, &has_labels);
			    if (has_labels)
				aux->has_labels = 1;
			    rl2_destroy_geometry (geom);
			}
		  }
	    }
	  sqlite3_finalize (stmt);
	  stmt = NULL;

................................................................................
    rl2_destroy_multi_layer (multi);
    multi = NULL;
    if (lyr_stl != NULL)
	rl2_destroy_feature_type_style (lyr_stl);
    if (variant != NULL)
	rl2_destroy_variant_array (variant);
    if (stmt != NULL)
	sqlite3_finalize (stmt);


    aux->output->img = NULL;
    aux->output->img_size = 0;

    return RL2_ERROR;
}

static int
do_check_topogeo (sqlite3 * sqlite, const char *db_prefix, const char *coverage)
{
/* checking for a TopoGeo Coverage */
................................................................................
    aux.style_name = style_name;
    aux.xml_style = NULL;
    aux.with_nodes = 1;
    aux.with_edges_or_links = 1;
    aux.with_faces = 0;
    aux.with_edge_or_link_seeds = 1;
    aux.with_face_seeds = 1;
    aux.has_labels = 0;
    aux.output = malloc (sizeof (struct aux_raster_image));
    aux.output->bg_red = 255;
    aux.output->bg_green = 255;
    aux.output->bg_blue = 255;
    aux.output->transparent = transparent;
    aux.output->format = format;
    aux.output->quality = quality;
................................................................................
	  ctx_faces = rl2_graph_create_context (data, width, height);
	  if (ctx_faces == NULL)
	      goto error;
	  ctx_face_seeds = rl2_graph_create_context (data, width, height);
	  if (ctx_face_seeds == NULL)
	      goto error;
	  aux.canvas =
	      rl2_create_topology_canvas (ctx, ctx_labels, ctx_nodes, ctx_edges,
					  ctx_faces, ctx_edge_seeds,
					  ctx_face_seeds);
      }
    else if (is_toponet)
      {
	  /* Network canvas */
	  ctx_nodes = rl2_graph_create_context (data, width, height);
................................................................................
	  ctx_links = rl2_graph_create_context (data, width, height);
	  if (ctx_links == NULL)
	      goto error;
	  ctx_link_seeds = rl2_graph_create_context (data, width, height);
	  if (ctx_link_seeds == NULL)
	      goto error;
	  aux.canvas =
	      rl2_create_network_canvas (ctx, ctx_labels, ctx_nodes, ctx_links,
					 ctx_link_seeds);
      }
    else
      {
	  /* generic Vector canvas */
	  aux.canvas = rl2_create_vector_canvas (ctx, ctx_labels);
      }
    if (aux.canvas == NULL)
	goto error;
    if (!transparent)
      {
	  /* parsing the background color */
	  bg_alpha = 255;
................................................................................
    aux.style_name = "external_style";
    aux.xml_style = xml_style;
    aux.with_nodes = 1;
    aux.with_edges_or_links = 1;
    aux.with_faces = 0;
    aux.with_edge_or_link_seeds = 1;
    aux.with_face_seeds = 1;
    aux.has_labels = 0;
    aux.output = malloc (sizeof (struct aux_raster_image));
    aux.output->bg_red = 255;
    aux.output->bg_green = 255;
    aux.output->bg_blue = 255;
    aux.output->transparent = transparent;
    aux.output->format = format;
    aux.output->quality = quality;
................................................................................
	  ctx_faces = rl2_graph_create_context (data, width, height);
	  if (ctx_faces == NULL)
	      goto error;
	  ctx_face_seeds = rl2_graph_create_context (data, width, height);
	  if (ctx_face_seeds == NULL)
	      goto error;
	  aux.canvas =
	      rl2_create_topology_canvas (ctx, ctx_labels, ctx_nodes, ctx_edges,
					  ctx_faces, ctx_edge_seeds,
					  ctx_face_seeds);
      }
    else if (is_toponet)
      {
	  /* Network canvas */
	  ctx_nodes = rl2_graph_create_context (data, width, height);
................................................................................
	  ctx_links = rl2_graph_create_context (data, width, height);
	  if (ctx_links == NULL)
	      goto error;
	  ctx_link_seeds = rl2_graph_create_context (data, width, height);
	  if (ctx_link_seeds == NULL)
	      goto error;
	  aux.canvas =
	      rl2_create_network_canvas (ctx, ctx_labels, ctx_nodes, ctx_links,
					 ctx_link_seeds);
      }
    else
      {
	  /* generic Vector canvas */
	  aux.canvas = rl2_create_vector_canvas (ctx, ctx_labels);
      }
    if (aux.canvas == NULL)
	goto error;
    if (!transparent)
      {
	  /* parsing the background color */
	  bg_alpha = 255;
................................................................................

RL2_DECLARE int
rl2_map_image_paint_from_vector (sqlite3 * sqlite, const void *data,
				 rl2CanvasPtr canvas, const char *db_prefix,
				 const char *cvg_name,
				 const unsigned char *blob, int blob_sz,
				 int reaspect, const char *style_name,
				 const unsigned char *xml_style,
				 int *has_labels)
{
/* rendering a Map Image from a Vector Coverage - Graphics Context */
    struct aux_vector_render aux;
    rl2GraphicsContextPtr ctx;
    int width;
    int height;
    int ret;
................................................................................
    aux.xml_style = xml_style;
    aux.output = NULL;
    aux.with_nodes = 1;
    aux.with_edges_or_links = 1;
    aux.with_faces = 0;
    aux.with_edge_or_link_seeds = 1;
    aux.with_face_seeds = 1;
    aux.has_labels = 0;
    ret = do_paint_map_from_vector (&aux);
    if (aux.has_labels)
	*has_labels = 1;
    else
	*has_labels = 0;
    return ret;
}

RL2_DECLARE int
rl2_map_image_paint_from_vector_ex (sqlite3 * sqlite, const void *data,
				    rl2CanvasPtr canvas, const char *db_prefix,
				    const char *cvg_name,
				    const unsigned char *blob, int blob_sz,
				    int reaspect, const char *style_name,
				    const unsigned char *xml_style,
				    int with_nodes, int with_edges_or_links,
				    int with_faces, int with_edge_or_link_seeds,
				    int with_face_seeds, int *has_labels)
{
/* rendering a Map Image from a Vector Coverage - Graphics Context - extended */
    struct aux_vector_render aux;
    rl2GraphicsContextPtr ctx;
    int width;
    int height;
    int ret;
................................................................................
    aux.xml_style = xml_style;
    aux.output = NULL;
    aux.with_nodes = with_nodes;
    aux.with_edges_or_links = with_edges_or_links;
    aux.with_faces = with_faces;
    aux.with_edge_or_link_seeds = with_edge_or_link_seeds;
    aux.with_face_seeds = with_face_seeds;
    aux.has_labels = 0;
    ret = do_paint_map_from_vector (&aux);
    if (aux.has_labels)
	*has_labels = 1;








































    else




















	*has_labels = 0;

    return ret;
}

static int
sniff_valid_xml (const char *str)
{
/* sniffing if a generic text string seems to be valid XML */

    const char *style_name;
    const unsigned char *xml_style;
    int with_nodes;
    int with_edges_or_links;
    int with_faces;
    int with_edge_or_link_seeds;
    int with_face_seeds;
    int mode_labels;
    struct aux_raster_image *output;
};

#define RL2_UNUSED() if (argc || argv) argc = argc;

RL2_PRIVATE int
get_coverage_sample_bands (sqlite3 * sqlite, const char *db_prefix,
................................................................................
    int j;
    int ret;
    int reproject_on_the_fly;
    int has_extra_columns;
    rl2VariantArrayPtr variant = NULL;
    rl2GraphicsContextPtr ctx = NULL;
    rl2GraphicsContextPtr ctx_labels = NULL;

    unsigned char *rgb = NULL;
    unsigned char *alpha = NULL;
    int half_transparent;
    int is_topogeo = 0;
    int is_toponet = 0;
    int which = RL2_CANVAS_UNKNOWN_CTX;

................................................................................
		  }
	    }
	  else
	    {
		/* using the Canvas Base Graphics Context */
		ctx = rl2_get_canvas_ctx (canvas, RL2_CANVAS_BASE_CTX);
	    }







	  if (ctx == NULL)
	      goto error;

	  /* composing the SQL query */
	  toponame = sqlite3_mprintf ("%s", lyr->f_table_name);
	  len = strlen (lyr->f_table_name);
	  if (len > 5)
................................................................................
					break;
				    };
			      }
			}
		      if (geom != NULL)
			{
			    /* drawing a styled Feature */

			    int scale_forbidden = 0;
			    symbolizer = NULL;
			    if (lyr_stl != NULL)
				symbolizer =
				    rl2_get_symbolizer_from_feature_type_style
				    (lyr_stl, scale, variant, &scale_forbidden);
			    if (!scale_forbidden)
			    {
				rl2_draw_vector_feature (ctx, sqlite, priv_data,
							 symbolizer, height,
							 minx, miny, maxx, maxy,
							 x_res, y_res, geom,
							 variant, aux->mode_labels);
						 }

			    rl2_destroy_geometry (geom);
			}
		  }
	    }
	  sqlite3_finalize (stmt);
	  stmt = NULL;

................................................................................
    rl2_destroy_multi_layer (multi);
    multi = NULL;
    if (lyr_stl != NULL)
	rl2_destroy_feature_type_style (lyr_stl);
    if (variant != NULL)
	rl2_destroy_variant_array (variant);
    if (stmt != NULL)
		sqlite3_finalize (stmt);
	if (aux->output != NULL)
	{
		aux->output->img = NULL;
		aux->output->img_size = 0;
	}
    return RL2_ERROR;
}

static int
do_check_topogeo (sqlite3 * sqlite, const char *db_prefix, const char *coverage)
{
/* checking for a TopoGeo Coverage */
................................................................................
    aux.style_name = style_name;
    aux.xml_style = NULL;
    aux.with_nodes = 1;
    aux.with_edges_or_links = 1;
    aux.with_faces = 0;
    aux.with_edge_or_link_seeds = 1;
    aux.with_face_seeds = 1;
    aux.mode_labels = 0;
    aux.output = malloc (sizeof (struct aux_raster_image));
    aux.output->bg_red = 255;
    aux.output->bg_green = 255;
    aux.output->bg_blue = 255;
    aux.output->transparent = transparent;
    aux.output->format = format;
    aux.output->quality = quality;
................................................................................
	  ctx_faces = rl2_graph_create_context (data, width, height);
	  if (ctx_faces == NULL)
	      goto error;
	  ctx_face_seeds = rl2_graph_create_context (data, width, height);
	  if (ctx_face_seeds == NULL)
	      goto error;
	  aux.canvas =
	      rl2_create_topology_canvas (ctx, ctx_nodes, ctx_edges,
					  ctx_faces, ctx_edge_seeds,
					  ctx_face_seeds);
      }
    else if (is_toponet)
      {
	  /* Network canvas */
	  ctx_nodes = rl2_graph_create_context (data, width, height);
................................................................................
	  ctx_links = rl2_graph_create_context (data, width, height);
	  if (ctx_links == NULL)
	      goto error;
	  ctx_link_seeds = rl2_graph_create_context (data, width, height);
	  if (ctx_link_seeds == NULL)
	      goto error;
	  aux.canvas =
	      rl2_create_network_canvas (ctx, ctx_nodes, ctx_links,
					 ctx_link_seeds);
      }
    else
      {
	  /* generic Vector canvas */
	  aux.canvas = rl2_create_vector_canvas (ctx);
      }
    if (aux.canvas == NULL)
	goto error;
    if (!transparent)
      {
	  /* parsing the background color */
	  bg_alpha = 255;
................................................................................
    aux.style_name = "external_style";
    aux.xml_style = xml_style;
    aux.with_nodes = 1;
    aux.with_edges_or_links = 1;
    aux.with_faces = 0;
    aux.with_edge_or_link_seeds = 1;
    aux.with_face_seeds = 1;
    aux.mode_labels = 0;
    aux.output = malloc (sizeof (struct aux_raster_image));
    aux.output->bg_red = 255;
    aux.output->bg_green = 255;
    aux.output->bg_blue = 255;
    aux.output->transparent = transparent;
    aux.output->format = format;
    aux.output->quality = quality;
................................................................................
	  ctx_faces = rl2_graph_create_context (data, width, height);
	  if (ctx_faces == NULL)
	      goto error;
	  ctx_face_seeds = rl2_graph_create_context (data, width, height);
	  if (ctx_face_seeds == NULL)
	      goto error;
	  aux.canvas =
	      rl2_create_topology_canvas (ctx, ctx_nodes, ctx_edges,
					  ctx_faces, ctx_edge_seeds,
					  ctx_face_seeds);
      }
    else if (is_toponet)
      {
	  /* Network canvas */
	  ctx_nodes = rl2_graph_create_context (data, width, height);
................................................................................
	  ctx_links = rl2_graph_create_context (data, width, height);
	  if (ctx_links == NULL)
	      goto error;
	  ctx_link_seeds = rl2_graph_create_context (data, width, height);
	  if (ctx_link_seeds == NULL)
	      goto error;
	  aux.canvas =
	      rl2_create_network_canvas (ctx, ctx_nodes, ctx_links,
					 ctx_link_seeds);
      }
    else
      {
	  /* generic Vector canvas */
	  aux.canvas = rl2_create_vector_canvas (ctx);
      }
    if (aux.canvas == NULL)
	goto error;
    if (!transparent)
      {
	  /* parsing the background color */
	  bg_alpha = 255;
................................................................................

RL2_DECLARE int
rl2_map_image_paint_from_vector (sqlite3 * sqlite, const void *data,
				 rl2CanvasPtr canvas, const char *db_prefix,
				 const char *cvg_name,
				 const unsigned char *blob, int blob_sz,
				 int reaspect, const char *style_name,
				 const unsigned char *xml_style)

{
/* rendering a Map Image from a Vector Coverage - Graphics Context */
    struct aux_vector_render aux;
    rl2GraphicsContextPtr ctx;
    int width;
    int height;
    int ret;
................................................................................
    aux.xml_style = xml_style;
    aux.output = NULL;
    aux.with_nodes = 1;
    aux.with_edges_or_links = 1;
    aux.with_faces = 0;
    aux.with_edge_or_link_seeds = 1;
    aux.with_face_seeds = 1;
    aux.mode_labels = 0;
    ret = do_paint_map_from_vector (&aux);




    return ret;
}

RL2_DECLARE int
rl2_map_image_paint_from_vector_ex (sqlite3 * sqlite, const void *data,
				    rl2CanvasPtr canvas, const char *db_prefix,
				    const char *cvg_name,
				    const unsigned char *blob, int blob_sz,
				    int reaspect, const char *style_name,
				    const unsigned char *xml_style,
				    int with_nodes, int with_edges_or_links,
				    int with_faces, int with_edge_or_link_seeds,
				    int with_face_seeds)
{
/* rendering a Map Image from a Vector Coverage - Graphics Context - extended */
    struct aux_vector_render aux;
    rl2GraphicsContextPtr ctx;
    int width;
    int height;
    int ret;
................................................................................
    aux.xml_style = xml_style;
    aux.output = NULL;
    aux.with_nodes = with_nodes;
    aux.with_edges_or_links = with_edges_or_links;
    aux.with_faces = with_faces;
    aux.with_edge_or_link_seeds = with_edge_or_link_seeds;
    aux.with_face_seeds = with_face_seeds;
    aux.mode_labels = 0;
    ret = do_paint_map_from_vector (&aux);
    return ret;

}

RL2_DECLARE int
rl2_map_image_paint_labels (sqlite3 * sqlite, const void *data,
				 rl2CanvasPtr canvas, const char *db_prefix,
				 const char *cvg_name,
				 const unsigned char *blob, int blob_sz,
				 int reaspect, const char *style_name,
				 const unsigned char *xml_style)
{
/* rendering Labels from a Vector Coverage - Graphics Context */
    struct aux_vector_render aux;
    rl2GraphicsContextPtr ctx;
    int width;
    int height;
    int ret;

    if (canvas == NULL)
	return RL2_ERROR;
    ctx = rl2_get_canvas_ctx (canvas, RL2_CANVAS_BASE_CTX);
    if (ctx == NULL)
	return RL2_ERROR;
    if (rl2_graph_context_get_dimensions (ctx, &width, &height) != RL2_OK)
	return RL2_ERROR;

    if (reaspect == 0)
      {
	  /* testing for consistent aspect ratios */
	  double aspect_org =
	      do_compute_bbox_aspect_ratio (sqlite, blob, blob_sz);
	  double aspect_dst = (double) width / (double) height;
	  double confidence = aspect_org / 100.0;
	  aspect_org = do_compute_bbox_aspect_ratio (sqlite, blob, blob_sz);
	  if (aspect_org < 0.0)
	      return RL2_ERROR;
	  aspect_dst = (double) width / (double) height;
	  confidence = aspect_org / 100.0;
	  if (aspect_dst >= (aspect_org - confidence)
	      && aspect_dst <= (aspect_org + confidence))
	      ;
	  else
	      return RL2_ERROR;
      }

    aux.sqlite = sqlite;
    aux.data = data;
    aux.canvas = canvas;
    aux.db_prefix = db_prefix;
    aux.cvg_name = cvg_name;
    aux.blob = blob;
    aux.blob_sz = blob_sz;
    aux.width = width;
    aux.height = height;
    aux.style_name = style_name;
    aux.xml_style = xml_style;
    aux.output = NULL;
    aux.with_nodes = 1;
    aux.with_edges_or_links = 1;
    aux.with_faces = 0;
    aux.with_edge_or_link_seeds = 1;
    aux.with_face_seeds = 1;
    aux.mode_labels = 1;
    ret = do_paint_map_from_vector (&aux);
    return ret;
}

static int
sniff_valid_xml (const char *str)
{
/* sniffing if a generic text string seems to be valid XML */

	writesectionascii18.testcase \
	writesectionascii19.testcase \
	writesectionascii20.testcase \
	writendviascii1.testcase \
	writendviascii2.testcase \
	writendviascii3.testcase \
	writendviascii4.testcase \
	writendviascii5.testcase \
	writendviascii6.testcase \
	writendviascii7.testcase \
	writendviascii8.testcase \
	writendviascii9.testcase \
	writendviascii10.testcase \
	writendviascii11.testcase \
	writendviascii12.testcase \
	writendviascii13.testcase \
................................................................................
	writendviascii17.testcase \
	writendviascii18.testcase \
	writendviascii19.testcase \
	writesectionndviascii1.testcase \
	writesectionndviascii2.testcase \
	writesectionndviascii3.testcase \
	writesectionndviascii4.testcase \
	writesectionndviascii5.testcase \
	writesectionndviascii6.testcase \
	writesectionndviascii7.testcase \
	writesectionndviascii8.testcase \
	writesectionndviascii9.testcase \
	writesectionndviascii10.testcase \
	writesectionndviascii11.testcase \
	writesectionndviascii12.testcase \
	writesectionndviascii13.testcase \
................................................................................
	writesectionndviascii15.testcase \
	writesectionndviascii16.testcase \
	writesectionndviascii17.testcase \
	writesectionndviascii18.testcase \
	writesectionndviascii19.testcase \
	writesectionndviascii20.testcase \
	writesectionndviascii21.testcase \




































	writebandtiff1.testcase \
	writebandtiff2.testcase \
	writebandtiff3.testcase \
	writebandtiff4.testcase \
	writebandtiff5.testcase \
	writebandtiff6.testcase \
	writebandtiff7.testcase \

	writesectionascii18.testcase \
	writesectionascii19.testcase \
	writesectionascii20.testcase \
	writendviascii1.testcase \
	writendviascii2.testcase \
	writendviascii3.testcase \
	writendviascii4.testcase \


	writendviascii7.testcase \
	writendviascii8.testcase \
	writendviascii9.testcase \
	writendviascii10.testcase \
	writendviascii11.testcase \
	writendviascii12.testcase \
	writendviascii13.testcase \
................................................................................
	writendviascii17.testcase \
	writendviascii18.testcase \
	writendviascii19.testcase \
	writesectionndviascii1.testcase \
	writesectionndviascii2.testcase \
	writesectionndviascii3.testcase \
	writesectionndviascii4.testcase \


	writesectionndviascii7.testcase \
	writesectionndviascii8.testcase \
	writesectionndviascii9.testcase \
	writesectionndviascii10.testcase \
	writesectionndviascii11.testcase \
	writesectionndviascii12.testcase \
	writesectionndviascii13.testcase \
................................................................................
	writesectionndviascii15.testcase \
	writesectionndviascii16.testcase \
	writesectionndviascii17.testcase \
	writesectionndviascii18.testcase \
	writesectionndviascii19.testcase \
	writesectionndviascii20.testcase \
	writesectionndviascii21.testcase \
	writendwiascii1.testcase \
	writendwiascii2.testcase \
	writendwiascii3.testcase \
	writendwiascii4.testcase \
	writendwiascii7.testcase \
	writendwiascii8.testcase \
	writendwiascii9.testcase \
	writendwiascii10.testcase \
	writendwiascii11.testcase \
	writendwiascii12.testcase \
	writendwiascii13.testcase \
	writendwiascii14.testcase \
	writendwiascii15.testcase \
	writendwiascii16.testcase \
	writendwiascii17.testcase \
	writendwiascii18.testcase \
	writendwiascii19.testcase \
	writesectionndwiascii1.testcase \
	writesectionndwiascii2.testcase \
	writesectionndwiascii3.testcase \
	writesectionndwiascii4.testcase \
	writesectionndwiascii7.testcase \
	writesectionndwiascii8.testcase \
	writesectionndwiascii9.testcase \
	writesectionndwiascii10.testcase \
	writesectionndwiascii11.testcase \
	writesectionndwiascii12.testcase \
	writesectionndwiascii13.testcase \
	writesectionndwiascii14.testcase \
	writesectionndwiascii15.testcase \
	writesectionndwiascii16.testcase \
	writesectionndwiascii17.testcase \
	writesectionndwiascii18.testcase \
	writesectionndwiascii19.testcase \
	writesectionndwiascii20.testcase \
	writesectionndwiascii21.testcase \
	writebandtiff1.testcase \
	writebandtiff2.testcase \
	writebandtiff3.testcase \
	writebandtiff4.testcase \
	writebandtiff5.testcase \
	writebandtiff6.testcase \
	writebandtiff7.testcase \

	writesectionascii18.testcase \
	writesectionascii19.testcase \
	writesectionascii20.testcase \
	writendviascii1.testcase \
	writendviascii2.testcase \
	writendviascii3.testcase \
	writendviascii4.testcase \
	writendviascii5.testcase \
	writendviascii6.testcase \
	writendviascii7.testcase \
	writendviascii8.testcase \
	writendviascii9.testcase \
	writendviascii10.testcase \
	writendviascii11.testcase \
	writendviascii12.testcase \
	writendviascii13.testcase \
................................................................................
	writendviascii17.testcase \
	writendviascii18.testcase \
	writendviascii19.testcase \
	writesectionndviascii1.testcase \
	writesectionndviascii2.testcase \
	writesectionndviascii3.testcase \
	writesectionndviascii4.testcase \
	writesectionndviascii5.testcase \
	writesectionndviascii6.testcase \
	writesectionndviascii7.testcase \
	writesectionndviascii8.testcase \
	writesectionndviascii9.testcase \
	writesectionndviascii10.testcase \
	writesectionndviascii11.testcase \
	writesectionndviascii12.testcase \
	writesectionndviascii13.testcase \
................................................................................
	writesectionndviascii15.testcase \
	writesectionndviascii16.testcase \
	writesectionndviascii17.testcase \
	writesectionndviascii18.testcase \
	writesectionndviascii19.testcase \
	writesectionndviascii20.testcase \
	writesectionndviascii21.testcase \




































	writebandtiff1.testcase \
	writebandtiff2.testcase \
	writebandtiff3.testcase \
	writebandtiff4.testcase \
	writebandtiff5.testcase \
	writebandtiff6.testcase \
	writebandtiff7.testcase \

	writesectionascii18.testcase \
	writesectionascii19.testcase \
	writesectionascii20.testcase \
	writendviascii1.testcase \
	writendviascii2.testcase \
	writendviascii3.testcase \
	writendviascii4.testcase \


	writendviascii7.testcase \
	writendviascii8.testcase \
	writendviascii9.testcase \
	writendviascii10.testcase \
	writendviascii11.testcase \
	writendviascii12.testcase \
	writendviascii13.testcase \
................................................................................
	writendviascii17.testcase \
	writendviascii18.testcase \
	writendviascii19.testcase \
	writesectionndviascii1.testcase \
	writesectionndviascii2.testcase \
	writesectionndviascii3.testcase \
	writesectionndviascii4.testcase \


	writesectionndviascii7.testcase \
	writesectionndviascii8.testcase \
	writesectionndviascii9.testcase \
	writesectionndviascii10.testcase \
	writesectionndviascii11.testcase \
	writesectionndviascii12.testcase \
	writesectionndviascii13.testcase \
................................................................................
	writesectionndviascii15.testcase \
	writesectionndviascii16.testcase \
	writesectionndviascii17.testcase \
	writesectionndviascii18.testcase \
	writesectionndviascii19.testcase \
	writesectionndviascii20.testcase \
	writesectionndviascii21.testcase \
	writendwiascii1.testcase \
	writendwiascii2.testcase \
	writendwiascii3.testcase \
	writendwiascii4.testcase \
	writendwiascii7.testcase \
	writendwiascii8.testcase \
	writendwiascii9.testcase \
	writendwiascii10.testcase \
	writendwiascii11.testcase \
	writendwiascii12.testcase \
	writendwiascii13.testcase \
	writendwiascii14.testcase \
	writendwiascii15.testcase \
	writendwiascii16.testcase \
	writendwiascii17.testcase \
	writendwiascii18.testcase \
	writendwiascii19.testcase \
	writesectionndwiascii1.testcase \
	writesectionndwiascii2.testcase \
	writesectionndwiascii3.testcase \
	writesectionndwiascii4.testcase \
	writesectionndwiascii7.testcase \
	writesectionndwiascii8.testcase \
	writesectionndwiascii9.testcase \
	writesectionndwiascii10.testcase \
	writesectionndwiascii11.testcase \
	writesectionndwiascii12.testcase \
	writesectionndwiascii13.testcase \
	writesectionndwiascii14.testcase \
	writesectionndwiascii15.testcase \
	writesectionndwiascii16.testcase \
	writesectionndwiascii17.testcase \
	writesectionndwiascii18.testcase \
	writesectionndwiascii19.testcase \
	writesectionndwiascii20.testcase \
	writesectionndwiascii21.testcase \
	writebandtiff1.testcase \
	writebandtiff2.testcase \
	writebandtiff3.testcase \
	writebandtiff4.testcase \
	writebandtiff5.testcase \
	writebandtiff6.testcase \
	writebandtiff7.testcase \

RL2_WriteNdviAsciiGrid - NULL Coverage
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid('main', NULL, './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid('main', NULL, './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 1)
-1

RL2_WriteNdviAsciiGrid - NULL Coverage
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid('main', NULL, './test.asc', 1024, 1024, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid('main', NULL, './test.asc', 1024, 1024, MakePoint(1, 1), 1)
-1

RL2_WriteNdviAsciiGrid - NULL is-centered
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 0.5, NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 0.5, NULL)
-1

RL2_WriteNdviAsciiGrid - NULL is-centered
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, NULL)
-1

RL2_WriteNdviAsciiGrid - NULL decimal-digits
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 0.5, 1, NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 0.5, 1, NULL)
-1

RL2_WriteNdviAsciiGrid - NULL decimal-digits
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, NULL)
-1

RL2_WriteNdviAsciiGrid - not existing coverage (1)
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 0.5, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 0.5, 1, 2)
-1

RL2_WriteNdviAsciiGrid - not existing coverage (1)
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, 2)
-1

RL2_WriteNdviAsciiGrid - not existing coverage (2)
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdviAsciiGrid - not existing coverage (2)
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdviAsciiGrid - invalid width (too small)
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 4, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 4, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdviAsciiGrid - invalid width (too small)
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 4, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 4, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdviAsciiGrid - invalid width (too big)
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1000004, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1000004, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdviAsciiGrid - invalid width (too big)
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1000004, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1000004, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdviAsciiGrid - invalid height (too small)
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdviAsciiGrid - invalid height (too small)
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdviAsciiGrid - invalid height (too big)
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1000000, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1000000, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdviAsciiGrid - invalid height (too big)
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdviAsciiGrid - invalid decimal precision (too small)
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1000000, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, -1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1000000, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, -1)
-1

RL2_WriteNdviAsciiGrid - invalid decimal precision (too small)
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, -1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, -1)
-1

RL2_WriteNdviAsciiGrid - Int DbPrefix
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(1, 'alpha', './test.asc', 1024, 1000000, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 4);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(1, 'alpha', './test.asc', 1024, 1000000, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 4)
-1

RL2_WriteNdviAsciiGrid - Int DbPrefix
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(1, 'alpha', './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 4);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(1, 'alpha', './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 4)
-1

RL2_WriteNdviAsciiGrid - NULL Path
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid('MAIN', 'alpha', NULL, 1024, 1024, 0, 3, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid('MAIN', 'alpha', NULL, 1024, 1024, 0, 3, MakePoint(1, 1), 1)
-1

RL2_WriteNdviAsciiGrid - NULL Path
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid('MAIN', 'alpha', NULL, 1024, 1024, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid('MAIN', 'alpha', NULL, 1024, 1024, MakePoint(1, 1), 1)
-1

RL2_WriteNdviAsciiGrid - NULL Width
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', NULL, 1024, 0, 3, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', NULL, 1024, 0, 3, MakePoint(1, 1), 1)
-1

RL2_WriteNdviAsciiGrid - NULL Width
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', NULL, 1024, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', NULL, 1024, MakePoint(1, 1), 1)
-1

RL2_WriteNdviAsciiGrid - NULL Height
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, NULL, 0, 3, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, NULL, 0, 3, MakePoint(1, 1), 1)
-1

RL2_WriteNdviAsciiGrid - NULL Height
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, NULL, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, NULL, MakePoint(1, 1), 1)
-1

RL2_WriteNdviAsciiGrid - NULL red band
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, NULL, 3, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, NULL, 3, MakePoint(1, 1), 1)
-1

RL2_WriteNdviAsciiGrid - NULL NIR band
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, NULL, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, NULL, MakePoint(1, 1), 1)
-1

RL2_WriteNdviAsciiGrid - NULL Geometry
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, 3, NULL, 0.5);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, 3, NULL, 0.5)
-1

RL2_WriteNdviAsciiGrid - NULL Geometry
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, NULL, 0.5);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, NULL, 0.5)
-1

RL2_WriteNdviAsciiGrid - Invalid BLOB Geometry
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, 3, zeroblob(100), 0.5);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, 3, zeroblob(100), 0.5)
-1

RL2_WriteNdviAsciiGrid - Invalid BLOB Geometry
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, zeroblob(100), 0.5);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, zeroblob(100), 0.5)
-1

RL2_WriteNdviAsciiGrid - NULL resolution
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), NULL)
-1

RL2_WriteNdviAsciiGrid - NULL resolution
:memory: #use in-memory database
SELECT RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdviAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), NULL)
-1

RL2_WriteNdwiAsciiGrid - NULL Coverage
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid('main', NULL, './test.asc', 1024, 1024, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid('main', NULL, './test.asc', 1024, 1024, MakePoint(1, 1), 1)
-1

RL2_WriteNdwiAsciiGrid - NULL is-centered
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, NULL)
-1

RL2_WriteNdwiAsciiGrid - NULL decimal-digits
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, NULL)
-1

RL2_WriteNdwiAsciiGrid - not existing coverage (1)
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, 2)
-1

RL2_WriteNdwiAsciiGrid - not existing coverage (2)
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdwiAsciiGrid - invalid width (too small)
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 4, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 4, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdwiAsciiGrid - invalid width (too big)
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1000004, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1000004, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdwiAsciiGrid - invalid height (too small)
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdwiAsciiGrid - invalid height (too big)
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteNdwiAsciiGrid - invalid decimal precision (too small)
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, -1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, -1)
-1

RL2_WriteNdwiAsciiGrid - Int DbPrefix
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(1, 'alpha', './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 4);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(1, 'alpha', './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 4)
-1

RL2_WriteNdwiAsciiGrid - NULL Path
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid('MAIN', 'alpha', NULL, 1024, 1024, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid('MAIN', 'alpha', NULL, 1024, 1024, MakePoint(1, 1), 1)
-1

RL2_WriteNdwiAsciiGrid - NULL Width
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', NULL, 1024, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', NULL, 1024, MakePoint(1, 1), 1)
-1

RL2_WriteNdwiAsciiGrid - NULL Height
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, NULL, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, NULL, MakePoint(1, 1), 1)
-1

RL2_WriteNdwiAsciiGrid - NULL Geometry
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, NULL, 0.5);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, NULL, 0.5)
-1

RL2_WriteNdwiAsciiGrid - Invalid BLOB Geometry
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, zeroblob(100), 0.5);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, zeroblob(100), 0.5)
-1

RL2_WriteNdwiAsciiGrid - NULL resolution
:memory: #use in-memory database
SELECT RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteNdwiAsciiGrid(NULL, 'alpha', './test.asc', 1024, 1024, MakePoint(1, 1), NULL)
-1

RL2_WriteNdviSectionAsciiGrid - NULL Coverage
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid('main', NULL, 1, './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid('main', NULL, 1, './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 1)
-1

RL2_WriteNdviSectionAsciiGrid - NULL Coverage
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid('main', NULL, 1, './test.asc', 1024, 1024, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid('main', NULL, 1, './test.asc', 1024, 1024, MakePoint(1, 1), 1)
-1

RL2_WriteSectionNdviAsciiGrid - NULL is-centered
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 0.5, NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 0.5, NULL)
-1

RL2_WriteSectionNdviAsciiGrid - NULL is-centered
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, NULL)
-1

RL2_WriteSectionNdviAsciiGrid - NULL decimal-digits
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 0.5, 1, NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 0.5, 1, NULL)
-1

RL2_WriteSectionNdviAsciiGrid - NULL decimal-digits
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, NULL)
-1

RL2_WriteSectionNdviAsciiGrid - not existing coverage (1)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 0.5, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), 0.5, 1, 2)
-1

RL2_WriteSectionNdviAsciiGrid - not existing coverage (1)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, 2)
-1

RL2_WriteSectionNdviAsciiGrid - not existing coverage (2)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdviAsciiGrid - not existing coverage (2)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdviAsciiGrid - invalid width (too small)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 4, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 4, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdviAsciiGrid - invalid width (too small)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 4, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 4, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdviAsciiGrid - invalid width (too big)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1000004, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1000004, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdviAsciiGrid - invalid width (too big)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1000004, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1000004, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdviAsciiGrid - invalid height (too small)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdviAsciiGrid - invalid height (too small)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdviAsciiGrid - invalid height (too big)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdviAsciiGrid - invalid height (too big)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdviAsciiGrid - invalid decimal precision (too small)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, -1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, -1)
-1

RL2_WriteSectionNdviAsciiGrid - invalid decimal precision (too small)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, -1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, -1)
-1

RL2_WriteSectionNdviAsciiGrid - invalid decimal precision (too big)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 50);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 50)
-1

RL2_WriteSectionNdviAsciiGrid - invalid decimal precision (too big)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 50);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 50)
-1

RL2_WriteSectionNdviAsciiGrid - NULL Path
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid('MAIN', 'alpha', 1, NULL, 1024, 1024, 0, 3, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid('MAIN', 'alpha', 1, NULL, 1024, 1024, 0, 3, MakePoint(1, 1), 1)
-1

RL2_WriteSectionNdviAsciiGrid - NULL Path
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid('MAIN', 'alpha', 1, NULL, 1024, 1024, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid('MAIN', 'alpha', 1, NULL, 1024, 1024, MakePoint(1, 1), 1)
-1

RL2_WriteSectionNdviAsciiGrid - NULL Section
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', NULL, './test.asc', 1024, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 50);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', NULL, './test.asc', 1024, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 50)
-1

RL2_WriteSectionNdviAsciiGrid - NULL Section
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', NULL, './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 50);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', NULL, './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 50)
-1

RL2_WriteSectionNdviAsciiGrid - Int DbPrefix
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(1, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 50);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(1, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, BuildMbr(1, 1, 10, 10), 1, 1, 50)
-1

RL2_WriteSectionNdviAsciiGrid - Int DbPrefix
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(1, 'alpha', 1, './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 50);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(1, 'alpha', 1, './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 50)
-1

RL2_WriteSectionNdviAsciiGrid - NULL Width
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', NULL, 1024, 0, 3, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', NULL, 1024, 0, 3, MakePoint(1, 1), 1)
-1

RL2_WriteSectionNdviAsciiGrid - NULL Width
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', NULL, 1024, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', NULL, 1024, MakePoint(1, 1), 1)
-1

RL2_WriteSectionNdviAsciiGrid - NULL Height
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, NULL, 0, 3, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, NULL, 0, 3, MakePoint(1, 1), 1)
-1

RL2_WriteSectionNdviAsciiGrid - NULL Height
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, NULL, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, NULL, MakePoint(1, 1), 1)
-1

RL2_WriteSectionNdviAsciiGrid - NULL red band
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, NULL, 3, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, NULL, 3, MakePoint(1, 1), 1)
-1

RL2_WriteSectionNdviAsciiGrid - NULL NIR band
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, NULL, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, NULL, MakePoint(1, 1), 1)
-1

RL2_WriteSectionNdviAsciiGrid - NULL Geometry
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, NULL, 0.5);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, NULL, 0.5)
-1

RL2_WriteSectionNdviAsciiGrid - NULL Geometry
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, NULL, 0.5);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, NULL, 0.5)
-1

RL2_WriteSectionNdviAsciiGrid - Invalid BLOB Geometry
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, zeroblob(100), 0.5);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, zeroblob(100), 0.5)
-1

RL2_WriteSectionNdviAsciiGrid - Invalid BLOB Geometry
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, zeroblob(100), 0.5);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, zeroblob(100), 0.5)
-1

RL2_WriteSectionNdviAsciiGrid - NULL resolution
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, 0, 3, MakePoint(1, 1), NULL)
-1

RL2_WriteSectionNdviAsciiGrid - NULL resolution
:memory: #use in-memory database
SELECT RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdviAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), NULL)
-1

RL2_WriteNdwiSectionAsciiGrid - NULL Coverage
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid('main', NULL, 1, './test.asc', 1024, 1024, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid('main', NULL, 1, './test.asc', 1024, 1024, MakePoint(1, 1), 1)
-1

RL2_WriteSectionNdwiAsciiGrid - NULL is-centered
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, NULL)
-1

RL2_WriteSectionNdwiAsciiGrid - NULL decimal-digits
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, NULL)
-1

RL2_WriteSectionNdwiAsciiGrid - not existing coverage (1)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), 0.5, 1, 2)
-1

RL2_WriteSectionNdwiAsciiGrid - not existing coverage (2)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdwiAsciiGrid - invalid width (too small)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 4, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 4, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdwiAsciiGrid - invalid width (too big)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1000004, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1000004, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdwiAsciiGrid - invalid height (too small)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdwiAsciiGrid - invalid height (too big)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 2);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 2)
-1

RL2_WriteSectionNdwiAsciiGrid - invalid decimal precision (too small)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, -1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, -1)
-1

RL2_WriteSectionNdwiAsciiGrid - invalid decimal precision (too big)
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 50);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1000000, BuildMbr(1, 1, 10, 10), 1, 1, 50)
-1

RL2_WriteSectionNdwiAsciiGrid - NULL Path
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid('MAIN', 'alpha', 1, NULL, 1024, 1024, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid('MAIN', 'alpha', 1, NULL, 1024, 1024, MakePoint(1, 1), 1)
-1

RL2_WriteSectionNdwiAsciiGrid - NULL Section
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', NULL, './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 50);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', NULL, './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 50)
-1

RL2_WriteSectionNdwiAsciiGrid - Int DbPrefix
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(1, 'alpha', 1, './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 50);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(1, 'alpha', 1, './test.asc', 1024, 1024, BuildMbr(1, 1, 10, 10), 1, 1, 50)
-1

RL2_WriteSectionNdwiAsciiGrid - NULL Width
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', NULL, 1024, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', NULL, 1024, MakePoint(1, 1), 1)
-1

RL2_WriteSectionNdwiAsciiGrid - NULL Height
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, NULL, MakePoint(1, 1), 1);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, NULL, MakePoint(1, 1), 1)
-1

RL2_WriteSectionNdwiAsciiGrid - NULL Geometry
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, NULL, 0.5);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, NULL, 0.5)
-1

RL2_WriteSectionNdwiAsciiGrid - Invalid BLOB Geometry
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, zeroblob(100), 0.5);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, zeroblob(100), 0.5)
-1

RL2_WriteSectionNdwiAsciiGrid - NULL resolution
:memory: #use in-memory database
SELECT RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), NULL);
1 # rows (not including the header row)
1 # columns
RL2_WriteSectionNdwiAsciiGrid(NULL, 'alpha', 1, './test.asc', 1024, 1024, MakePoint(1, 1), NULL)
-1

		  }
		if (lyr->raster_style->contrast_enhancement->gamma_value !=
		    1.57)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected ContrastEnhancement GammaValue %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->raster_style->
			       contrast_enhancement->gamma_value);
		      ret = -19;
		      goto stop;
		  }
	    }
	  if (strcmp (lyr->prefix, "main") == 0
	      && strcmp (lyr->name, "raster_8") == 0)
	    {
................................................................................
		if (lyr->raster_style->channel_selection->rgb == 0
		    || lyr->raster_style->channel_selection->green_channel != 1)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected ChannelSelection RGB=%d Green=%d !!\n",
			       lyr->prefix, lyr->name,
			       lyr->raster_style->channel_selection->rgb,
			       lyr->raster_style->
			       channel_selection->green_channel);
		      ret = -23;
		      goto stop;
		  }
	    }
	  if (strcmp (lyr->prefix, "main") == 0
	      && strcmp (lyr->name, "raster_9") == 0)
	    {
................................................................................
		if (lyr->raster_style->channel_selection->rgb != 0
		    || lyr->raster_style->channel_selection->gray_channel != 4)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected ChannelSelection RGB=%d Green=%d !!\n",
			       lyr->prefix, lyr->name,
			       lyr->raster_style->channel_selection->rgb,
			       lyr->raster_style->
			       channel_selection->gray_channel);
		      ret = -27;
		      goto stop;
		  }
	    }
	  if (strcmp (lyr->prefix, "main") == 0
	      && strcmp (lyr->name, "wms_layer_2") == 0)
	    {
................................................................................
		if (strcmp
		    (lyr->topology_internal_style->style_internal_name,
		     "topology_style_1") != 0)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected Internal Style Name \"%s\" !!\n",
			       lyr->prefix, lyr->name,
			       lyr->
			       topology_internal_style->style_internal_name);
		      ret = -57;
		      goto stop;
		  }
		if (lyr->topology_internal_style->show_faces == 0
		    || lyr->topology_internal_style->show_edges == 0
		    || lyr->topology_internal_style->show_nodes == 0
		    || lyr->topology_internal_style->show_edge_seeds == 0
................................................................................
		if (strcmp
		    (lyr->network_internal_style->style_internal_name,
		     "network_style_1") != 0)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected Internal Style Name \"%s\" !!\n",
			       lyr->prefix, lyr->name,
			       lyr->
			       network_internal_style->style_internal_name);
		      ret = -62;
		      goto stop;
		  }
		if (lyr->network_internal_style->show_links == 0 ||
		    lyr->network_internal_style->show_nodes == 0
		    || lyr->network_internal_style->show_link_seeds == 0)
		  {
................................................................................
		    lyr->vector_style->point_sym->mark->stroke->green != 0x03 ||
		    lyr->vector_style->point_sym->mark->stroke->blue != 0xfa)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PointSymbolizerMarkStroke #%02x%02x%02x !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->point_sym->mark->stroke->red,
			       lyr->vector_style->point_sym->mark->
			       stroke->green,
			       lyr->vector_style->point_sym->mark->
			       stroke->blue);
		      ret = -71;
		      goto stop;
		  }
		if (lyr->vector_style->point_sym->opacity != 0.75)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PointSymbolizerOpacity %1.2f !!\n",
................................................................................
		      goto stop;
		  }
		if (lyr->vector_style->first_line_sym->stroke->opacity != 0.66)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected LineSymbolizerStrokeOpacity %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->first_line_sym->
			       stroke->opacity);
		      ret = -82;
		      goto stop;
		  }
		if (lyr->vector_style->first_line_sym->stroke->width != 8.52)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected LineSymbolizerStrokeWidth %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->first_line_sym->
			       stroke->width);
		      ret = -83;
		      goto stop;
		  }
		if (lyr->vector_style->first_line_sym->stroke->dot_style != 4)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected LineSymbolizerStrokeDotStyle %d !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->first_line_sym->
			       stroke->dot_style);
		      ret = -84;
		      goto stop;
		  }
	    }
	  if (strcmp (lyr->prefix, "main") == 0
	      && strcmp (lyr->name, "topology_2") == 0)
	    {
................................................................................
		if (strcmp
		    (lyr->vector_style->polygon_sym->fill->graphic->resource,
		     "http://www.utopia.gov/stdbrush_crossdiag.png") != 0)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PolygonSymbolizerFillGraphicResource \"%s\" !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->polygon_sym->fill->graphic->
			       resource);
		      ret = -94;
		      goto stop;
		  }
		if (strcmp
		    (lyr->vector_style->polygon_sym->fill->graphic->format,
		     "image/png") != 0)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PolygonSymbolizerFillGraphicFormat \"%s\" !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->polygon_sym->fill->graphic->
			       format);
		      ret = -95;
		      goto stop;
		  }
		if (lyr->vector_style->polygon_sym->fill->graphic->color ==
		    NULL)
		  {
		      fprintf (stderr,
................................................................................
			       "Layer <%s><%s> unexpected NULL PolygonSymbolizerFillGraphicRemapColor !!\n",
			       lyr->prefix, lyr->name);
		      ret = -96;
		      goto stop;
		  }
		if (lyr->vector_style->polygon_sym->fill->graphic->color->red !=
		    0xfb
		    || lyr->vector_style->polygon_sym->fill->graphic->color->
		    green != 0xe3
		    || lyr->vector_style->polygon_sym->fill->graphic->color->
		    blue != 0x46)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PolygonSymbolizerFillGraphicRemapColor #%02x%02x%02x !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->polygon_sym->fill->graphic->
			       color->red,
			       lyr->vector_style->polygon_sym->fill->graphic->
			       color->green,
			       lyr->vector_style->polygon_sym->fill->graphic->
			       color->blue);
		      ret = -97;
		      goto stop;
		  }
		if (lyr->vector_style->polygon_sym->stroke == NULL)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected NULL PolygonSymbolizerStroke !!\n",
................................................................................
		      goto stop;
		  }
		if (lyr->vector_style->polygon_sym->stroke->dot_style != 2)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PolygonSymbolizerStrokeDotStyle %d !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->polygon_sym->
			       stroke->dot_style);
		      ret = -102;
		      goto stop;
		  }
		if (lyr->vector_style->polygon_sym->displacement_x != 5.3)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PolygonSymbolizerDisplacementX %1.2f !!\n",
................................................................................
		  }
		if (lyr->vector_style->polygon_sym->perpendicular_offset !=
		    10.25)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PolygonSymbolizerPerpendicularOffset %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->polygon_sym->
			       perpendicular_offset);
		      ret = -104;
		      goto stop;
		  }
	    }
	  if (strcmp (lyr->prefix, "main") == 0
	      && strcmp (lyr->name, "vector_6") == 0)
	    {
................................................................................
		  }
		if (lyr->vector_style->text_sym->placement->point->rotation !=
		    45.2)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerPointPlacementRotation %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->
			       point->rotation);
		      ret = -117;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->point->anchor_x !=
		    0.3)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerPointPlacementAnchorX %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->
			       point->anchor_x);
		      ret = -118;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->point->anchor_y !=
		    2.5)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerPointPlacementAnchorY %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->
			       point->anchor_y);
		      ret = -119;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->
		    point->displacement_x != 10.1)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerPointPlacementDisplacementX %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->
			       point->displacement_x);
		      ret = -120;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->
		    point->displacement_y != 0.32)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerPointPlacementDisplacementY %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->
			       point->displacement_y);
		      ret = -121;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->halo == NULL)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected NULL TextSymbolizerHalo !!\n",
................................................................................
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->halo->fill->opacity != 0.33)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerHaloFillOpacity %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->halo->
			       fill->opacity);
		      ret = -126;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->fill == NULL)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected NULL TextSymbolizerFill !!\n",
................................................................................
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected NULL TextSymbolizerLinePlacement !!\n",
			       lyr->prefix, lyr->name);
		      ret = -133;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->line->
		    perpendicular_offset != 1.32)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerLinePlacementPerpendicularOffset %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->line->
			       perpendicular_offset);
		      ret = -134;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->line->repeated != 1)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerLinePlacementIsRepeated %d !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->line->
			       repeated);
		      ret = -135;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->line->initial_gap !=
		    5.25)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerLinePlacementInitialGap %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->line->
			       initial_gap);
		      ret = -136;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->line->gap != 10.5)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerLinePlacementGap %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->line->
			       gap);
		      ret = -137;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->line->aligned != 1)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerLinePlacementIsAligned %d !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->line->
			       aligned);
		      ret = -138;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->line->generalize !=
		    1)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerLinePlacementGeneralizeLine %d !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->line->
			       generalize);
		      ret = -139;
		      goto stop;
		  }
	    }
	  lyr = lyr->next;
      }

................................................................................
  error:
    if (xml != NULL)
	free (xml);
    if (in != NULL)
	fclose (in);
    return NULL;
}



















































































































































































































int
main (int argc, char *argv[])
{
    int result = 0;
    int ret;
    sqlite3 *db_handle;
................................................................................
    if (argc > 1 || argv[0] == NULL)
	argc = 1;		/* silencing stupid compiler warnings */

/* opening and initializing the "memory" test DB */
    ret = sqlite3_open_v2 (":memory:", &db_handle, SQLITE_OPEN_READONLY, NULL);
    if (ret != SQLITE_OK)
      {
	  fprintf (stderr, "sqlite3_open_v2() error: %s\n",
		   sqlite3_errmsg (db_handle));
	  return -1;
      }
    spatialite_init_ex (db_handle, cache, 0);
    rl2_init (db_handle, priv_data, 0);

/* loading the XML document */
................................................................................
/* closing the DB */
    sqlite3_close (db_handle);
    spatialite_cleanup_ex (cache);
    rl2_cleanup_private (priv_data);
    spatialite_shutdown ();
    if (xml != NULL)
	free (xml);



    return result;
}

		  }
		if (lyr->raster_style->contrast_enhancement->gamma_value !=
		    1.57)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected ContrastEnhancement GammaValue %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->raster_style->contrast_enhancement->
			       gamma_value);
		      ret = -19;
		      goto stop;
		  }
	    }
	  if (strcmp (lyr->prefix, "main") == 0
	      && strcmp (lyr->name, "raster_8") == 0)
	    {
................................................................................
		if (lyr->raster_style->channel_selection->rgb == 0
		    || lyr->raster_style->channel_selection->green_channel != 1)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected ChannelSelection RGB=%d Green=%d !!\n",
			       lyr->prefix, lyr->name,
			       lyr->raster_style->channel_selection->rgb,
			       lyr->raster_style->channel_selection->
			       green_channel);
		      ret = -23;
		      goto stop;
		  }
	    }
	  if (strcmp (lyr->prefix, "main") == 0
	      && strcmp (lyr->name, "raster_9") == 0)
	    {
................................................................................
		if (lyr->raster_style->channel_selection->rgb != 0
		    || lyr->raster_style->channel_selection->gray_channel != 4)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected ChannelSelection RGB=%d Green=%d !!\n",
			       lyr->prefix, lyr->name,
			       lyr->raster_style->channel_selection->rgb,
			       lyr->raster_style->channel_selection->
			       gray_channel);
		      ret = -27;
		      goto stop;
		  }
	    }
	  if (strcmp (lyr->prefix, "main") == 0
	      && strcmp (lyr->name, "wms_layer_2") == 0)
	    {
................................................................................
		if (strcmp
		    (lyr->topology_internal_style->style_internal_name,
		     "topology_style_1") != 0)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected Internal Style Name \"%s\" !!\n",
			       lyr->prefix, lyr->name,
			       lyr->topology_internal_style->
			       style_internal_name);
		      ret = -57;
		      goto stop;
		  }
		if (lyr->topology_internal_style->show_faces == 0
		    || lyr->topology_internal_style->show_edges == 0
		    || lyr->topology_internal_style->show_nodes == 0
		    || lyr->topology_internal_style->show_edge_seeds == 0
................................................................................
		if (strcmp
		    (lyr->network_internal_style->style_internal_name,
		     "network_style_1") != 0)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected Internal Style Name \"%s\" !!\n",
			       lyr->prefix, lyr->name,
			       lyr->network_internal_style->
			       style_internal_name);
		      ret = -62;
		      goto stop;
		  }
		if (lyr->network_internal_style->show_links == 0 ||
		    lyr->network_internal_style->show_nodes == 0
		    || lyr->network_internal_style->show_link_seeds == 0)
		  {
................................................................................
		    lyr->vector_style->point_sym->mark->stroke->green != 0x03 ||
		    lyr->vector_style->point_sym->mark->stroke->blue != 0xfa)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PointSymbolizerMarkStroke #%02x%02x%02x !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->point_sym->mark->stroke->red,
			       lyr->vector_style->point_sym->mark->stroke->
			       green,
			       lyr->vector_style->point_sym->mark->stroke->
			       blue);
		      ret = -71;
		      goto stop;
		  }
		if (lyr->vector_style->point_sym->opacity != 0.75)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PointSymbolizerOpacity %1.2f !!\n",
................................................................................
		      goto stop;
		  }
		if (lyr->vector_style->first_line_sym->stroke->opacity != 0.66)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected LineSymbolizerStrokeOpacity %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->first_line_sym->stroke->
			       opacity);
		      ret = -82;
		      goto stop;
		  }
		if (lyr->vector_style->first_line_sym->stroke->width != 8.52)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected LineSymbolizerStrokeWidth %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->first_line_sym->stroke->
			       width);
		      ret = -83;
		      goto stop;
		  }
		if (lyr->vector_style->first_line_sym->stroke->dot_style != 4)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected LineSymbolizerStrokeDotStyle %d !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->first_line_sym->stroke->
			       dot_style);
		      ret = -84;
		      goto stop;
		  }
	    }
	  if (strcmp (lyr->prefix, "main") == 0
	      && strcmp (lyr->name, "topology_2") == 0)
	    {
................................................................................
		if (strcmp
		    (lyr->vector_style->polygon_sym->fill->graphic->resource,
		     "http://www.utopia.gov/stdbrush_crossdiag.png") != 0)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PolygonSymbolizerFillGraphicResource \"%s\" !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->polygon_sym->fill->
			       graphic->resource);
		      ret = -94;
		      goto stop;
		  }
		if (strcmp
		    (lyr->vector_style->polygon_sym->fill->graphic->format,
		     "image/png") != 0)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PolygonSymbolizerFillGraphicFormat \"%s\" !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->polygon_sym->fill->
			       graphic->format);
		      ret = -95;
		      goto stop;
		  }
		if (lyr->vector_style->polygon_sym->fill->graphic->color ==
		    NULL)
		  {
		      fprintf (stderr,
................................................................................
			       "Layer <%s><%s> unexpected NULL PolygonSymbolizerFillGraphicRemapColor !!\n",
			       lyr->prefix, lyr->name);
		      ret = -96;
		      goto stop;
		  }
		if (lyr->vector_style->polygon_sym->fill->graphic->color->red !=
		    0xfb
		    || lyr->vector_style->polygon_sym->fill->graphic->
		    color->green != 0xe3
		    || lyr->vector_style->polygon_sym->fill->graphic->
		    color->blue != 0x46)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PolygonSymbolizerFillGraphicRemapColor #%02x%02x%02x !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->polygon_sym->fill->
			       graphic->color->red,
			       lyr->vector_style->polygon_sym->fill->
			       graphic->color->green,
			       lyr->vector_style->polygon_sym->fill->
			       graphic->color->blue);
		      ret = -97;
		      goto stop;
		  }
		if (lyr->vector_style->polygon_sym->stroke == NULL)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected NULL PolygonSymbolizerStroke !!\n",
................................................................................
		      goto stop;
		  }
		if (lyr->vector_style->polygon_sym->stroke->dot_style != 2)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PolygonSymbolizerStrokeDotStyle %d !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->polygon_sym->stroke->
			       dot_style);
		      ret = -102;
		      goto stop;
		  }
		if (lyr->vector_style->polygon_sym->displacement_x != 5.3)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PolygonSymbolizerDisplacementX %1.2f !!\n",
................................................................................
		  }
		if (lyr->vector_style->polygon_sym->perpendicular_offset !=
		    10.25)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected PolygonSymbolizerPerpendicularOffset %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->
			       polygon_sym->perpendicular_offset);
		      ret = -104;
		      goto stop;
		  }
	    }
	  if (strcmp (lyr->prefix, "main") == 0
	      && strcmp (lyr->name, "vector_6") == 0)
	    {
................................................................................
		  }
		if (lyr->vector_style->text_sym->placement->point->rotation !=
		    45.2)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerPointPlacementRotation %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->point->
			       rotation);
		      ret = -117;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->point->anchor_x !=
		    0.3)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerPointPlacementAnchorX %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->point->
			       anchor_x);
		      ret = -118;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->point->anchor_y !=
		    2.5)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerPointPlacementAnchorY %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->point->
			       anchor_y);
		      ret = -119;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->point->
		    displacement_x != 10.1)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerPointPlacementDisplacementX %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->point->
			       displacement_x);
		      ret = -120;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->point->
		    displacement_y != 0.32)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerPointPlacementDisplacementY %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->point->
			       displacement_y);
		      ret = -121;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->halo == NULL)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected NULL TextSymbolizerHalo !!\n",
................................................................................
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->halo->fill->opacity != 0.33)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerHaloFillOpacity %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->halo->fill->
			       opacity);
		      ret = -126;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->fill == NULL)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected NULL TextSymbolizerFill !!\n",
................................................................................
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected NULL TextSymbolizerLinePlacement !!\n",
			       lyr->prefix, lyr->name);
		      ret = -133;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->
		    line->perpendicular_offset != 1.32)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerLinePlacementPerpendicularOffset %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->
			       line->perpendicular_offset);
		      ret = -134;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->line->repeated != 1)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerLinePlacementIsRepeated %d !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->
			       line->repeated);
		      ret = -135;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->line->initial_gap !=
		    5.25)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerLinePlacementInitialGap %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->
			       line->initial_gap);
		      ret = -136;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->line->gap != 10.5)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerLinePlacementGap %1.2f !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->
			       line->gap);
		      ret = -137;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->line->aligned != 1)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerLinePlacementIsAligned %d !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->
			       line->aligned);
		      ret = -138;
		      goto stop;
		  }
		if (lyr->vector_style->text_sym->placement->line->generalize !=
		    1)
		  {
		      fprintf (stderr,
			       "Layer <%s><%s> unexpected TextSymbolizerLinePlacementGeneralizeLine %d !!\n",
			       lyr->prefix, lyr->name,
			       lyr->vector_style->text_sym->placement->
			       line->generalize);
		      ret = -139;
		      goto stop;
		  }
	    }
	  lyr = lyr->next;
      }

................................................................................
  error:
    if (xml != NULL)
	free (xml);
    if (in != NULL)
	fclose (in);
    return NULL;
}

static int
test_rendering (sqlite3 * sqlite, const char *name, const char *mbr)
{
/* testing RL2_GetImageFromMapConfiguration() */
    char *sql;
    sqlite3_stmt *stmt;
    int ret;
    int ok = 0;

    sql = sqlite3_mprintf ("SELECT RL2_GetImageFromMapConfiguration(%Q, %s, "
			   "1024, 1024, 'image/jpeg', 85)", name, mbr);
    ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
    sqlite3_free (sql);
    if (ret != SQLITE_OK)
      {
	  fprintf (stderr, "ERROR: invalid SQL !!!\n");
	  return -1;
      }
    while (1)
      {
	  /* scrolling the result set rows */
	  ret = sqlite3_step (stmt);
	  if (ret == SQLITE_DONE)
	      break;		/* end of result set */
	  if (ret == SQLITE_ROW)
	    {
		if (sqlite3_column_type (stmt, 0) == SQLITE_BLOB)
		    ok = 1;
		else
		    fprintf (stderr, "'%s': returned value is not a BLOB !!!\n",
			     name);
	    }
      }
    sqlite3_finalize (stmt);
    if (ok)
	return 0;
    else
      {
	  fprintf (stderr, "ERROR on RL2_GetImageFromMapConfiguration() '%s'\n",
		   name);
	  return -1;
      }
}

static int
do_test_rendering ()
{
    int result = 0;
    int ret;
    sqlite3 *db_handle;
    void *cache = spatialite_alloc_connection ();
    void *priv_data = rl2_alloc_private ();
    const char *db_path = "./map_config.sqlite";

/* opening and initializing the test DB */
    ret = sqlite3_open_v2 (db_path, &db_handle, SQLITE_OPEN_READONLY, NULL);
    if (ret != SQLITE_OK)
      {
	  fprintf (stderr, "sqlite3_open_v2() #2 error: %s\n",
		   sqlite3_errmsg (db_handle));
	  return -1;
      }
    spatialite_init_ex (db_handle, cache, 0);
    rl2_init (db_handle, priv_data, 0);

    ret =
	test_rendering (db_handle, "test",
			"BuildMbr(661080.36416380, 4847546.75435066, 661185.84211366, 4847652.23230052, 32632)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

    ret =
	test_rendering (db_handle, "test_nir",
			"BuildMbr(661080.36416380, 4847546.75435066, 661185.84211366, 4847652.23230052, 32632)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

    ret =
	test_rendering (db_handle, "test_ndvi",
			"BuildMbr(661080.36416380, 4847546.75435066, 661185.84211366, 4847652.23230052, 32632)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

    ret =
	test_rendering (db_handle, "test_ndwi",
			"BuildMbr(661080.36416380, 4847546.75435066, 661185.84211366, 4847652.23230052, 32632)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

    ret =
	test_rendering (db_handle, "test_topo",
			"BuildMbr(661080.36416380, 4847546.75435066, 661185.84211366, 4847652.23230052, 32632)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

    ret =
	test_rendering (db_handle, "test_network",
			"BuildMbr(661080.36416380, 4847546.75435066, 661185.84211366, 4847652.23230052, 32632)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

    ret =
	test_rendering (db_handle, "test_etopo2",
			"BuildMbr(1645836.00863381, 4739566.56487609, 1646963.24970982, 4740693.80595209, 3003)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

    ret =
	test_rendering (db_handle, "test_srtm",
			"BuildMbr(1645836.00863381, 4739566.56487609, 1646963.24970982, 4740693.80595209, 3003)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

    ret =
	test_rendering (db_handle, "test_terrain",
			"BuildMbr(1645836.00863381, 4739566.56487609, 1646963.24970982, 4740693.80595209, 3003)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

    ret =
	test_rendering (db_handle, "test_aspect",
			"BuildMbr(1645836.00863381, 4739566.56487609, 1646963.24970982, 4740693.80595209, 3003)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

    ret =
	test_rendering (db_handle, "test_elevation",
			"BuildMbr(1645836.00863381, 4739566.56487609, 1646963.24970982, 4740693.80595209, 3003)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

    ret =
	test_rendering (db_handle, "test_rainbow",
			"BuildMbr(1645836.00863381, 4739566.56487609, 1646963.24970982, 4740693.80595209, 3003)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

    ret =
	test_rendering (db_handle, "test_wave",
			"BuildMbr(1645836.00863381, 4739566.56487609, 1646963.24970982, 4740693.80595209, 3003)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

    ret =
	test_rendering (db_handle, "test_sepia",
			"BuildMbr(1645836.00863381, 4739566.56487609, 1646963.24970982, 4740693.80595209, 3003)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

    ret =
	test_rendering (db_handle, "test_ramp",
			"BuildMbr(1645836.00863381, 4739566.56487609, 1646963.24970982, 4740693.80595209, 3003)");
    if (ret < 0)
      {
	  result = ret;
	  goto stop;
      }

/* closing the DB */
  stop:
    sqlite3_close (db_handle);
    spatialite_cleanup_ex (cache);
    rl2_cleanup_private (priv_data);
    spatialite_shutdown ();

    return result;
}

int
main (int argc, char *argv[])
{
    int result = 0;
    int ret;
    sqlite3 *db_handle;
................................................................................
    if (argc > 1 || argv[0] == NULL)
	argc = 1;		/* silencing stupid compiler warnings */

/* opening and initializing the "memory" test DB */
    ret = sqlite3_open_v2 (":memory:", &db_handle, SQLITE_OPEN_READONLY, NULL);
    if (ret != SQLITE_OK)
      {
	  fprintf (stderr, "sqlite3_open_v2() #1 error: %s\n",
		   sqlite3_errmsg (db_handle));
	  return -1;
      }
    spatialite_init_ex (db_handle, cache, 0);
    rl2_init (db_handle, priv_data, 0);

/* loading the XML document */
................................................................................
/* closing the DB */
    sqlite3_close (db_handle);
    spatialite_cleanup_ex (cache);
    rl2_cleanup_private (priv_data);
    spatialite_shutdown ();
    if (xml != NULL)
	free (xml);

/* testing RL2_GetImageFromMapConfiguration() */
    result = do_test_rendering ();
    return result;
}

    sqlite3_free (path);
    if (strcmp(suffix, "png") == 0 && strcmp(style, "default") != 0)
		retcode = do_export_styled_map_image (sqlite, coverage, geom, style, suffix);
    return retcode;
}

static int
do_export_ndvi (sqlite3 * sqlite, const char *coverage, gaiaGeomCollPtr geom)
{
/* exporting an NDVI Ascii Grid */
    char *sql;
    const char *path = "./ndvi_ascii_grid.asc";
    sqlite3_stmt *stmt;
    int ret;
    double x_res;
    double y_res;
    double xx_res;
    double yy_res;
    unsigned char *blob;
................................................................................
    if (!get_base_resolution (sqlite, coverage, &x_res, &y_res))
	return 0;
    xx_res = x_res * (double) scale;
    yy_res = y_res * (double) scale;
    if (xx_res != yy_res)
	xx_res = (xx_res + yy_res) / 2.0;









    sql = "SELECT RL2_WriteNdviAsciiGrid('main', ?, ?, ?, ?, ?, ?, ?, ?)";

    ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
    if (ret != SQLITE_OK)
	return 0;
    sqlite3_reset (stmt);
    sqlite3_clear_bindings (stmt);
    sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
    sqlite3_bind_text (stmt, 2, path, strlen (path), SQLITE_STATIC);
    sqlite3_bind_int (stmt, 3, 1024);
    sqlite3_bind_int (stmt, 4, 1024);
    sqlite3_bind_int (stmt, 5, 0);	/* red band */
    sqlite3_bind_int (stmt, 6, 3);	/* NIR band */
    gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
    sqlite3_bind_blob (stmt, 7, blob, blob_size, free);
    sqlite3_bind_double (stmt, 8, xx_res);
    ret = sqlite3_step (stmt);
    if (ret == SQLITE_DONE || ret == SQLITE_ROW)
      {
	  if (sqlite3_column_int (stmt, 0) == 1)
	      retcode = 1;
      }
    sqlite3_finalize (stmt);
    unlink (path);
    if (!retcode)
	fprintf (stderr, "ERROR: unable to export \"%s\"\n", path);
    return retcode;
}

static int
do_export_section_ndvi (sqlite3 * sqlite, const char *coverage,
			gaiaGeomCollPtr geom)
{
/* exporting a Section NDVI Ascii Grid */
    char *sql;
    const char *path = "./ndvi_ascii_grid_section.asc";
    sqlite3_stmt *stmt;
    int ret;
    double x_res;
    double y_res;
    double xx_res;
    double yy_res;
    unsigned char *blob;
................................................................................
    if (!get_base_resolution (sqlite, coverage, &x_res, &y_res))
	return 0;
    xx_res = x_res * (double) scale;
    yy_res = y_res * (double) scale;
    if (xx_res != yy_res)
	xx_res = (xx_res + yy_res) / 2.0;




    sql =






	"SELECT RL2_WriteSectionNdviAsciiGrid('main', ?, ?, ?, ?, ?, ?, ?, ?, ?)";

    ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
    if (ret != SQLITE_OK)
	return 0;
    sqlite3_reset (stmt);
    sqlite3_clear_bindings (stmt);
    sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
    sqlite3_bind_int64 (stmt, 2, 1);
    sqlite3_bind_text (stmt, 3, path, strlen (path), SQLITE_STATIC);
    sqlite3_bind_int (stmt, 4, 1024);
    sqlite3_bind_int (stmt, 5, 1024);
    sqlite3_bind_int (stmt, 6, 0);	/* red band */
    sqlite3_bind_int (stmt, 7, 3);	/* NIR band */
    gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
    sqlite3_bind_blob (stmt, 8, blob, blob_size, free);
    sqlite3_bind_double (stmt, 9, xx_res);
    ret = sqlite3_step (stmt);
    if (ret == SQLITE_DONE || ret == SQLITE_ROW)
      {
	  if (sqlite3_column_int (stmt, 0) == 1)
	      retcode = 1;
      }
    sqlite3_finalize (stmt);
    unlink (path);
    if (!retcode)
	fprintf (stderr, "ERROR: unable to export \"%s\"\n", path);
    return retcode;
}

static gaiaGeomCollPtr
get_center_point (sqlite3 * sqlite, const char *coverage)
{
/* attempting to retrieve the Coverage's Center Point */
................................................................................
	  *retcode += -40;
	  return 0;
      }
    if (!do_export_mono_band_tiff_tfw (sqlite, coverage, geom, 1, 2))
      {
	  *retcode += -41;
	  return 0;
      }
    if (ndvi)
      {
	  /* NDVI Ascii Grid */
	  if (!do_export_ndvi (sqlite, coverage, geom))
	    {
		*retcode += -101;
		return 0;
	    }
      }
    if (!test_map_image)
	goto skip;

/* loading the RasterSymbolizers */
    sql =
	sqlite3_mprintf ("SELECT SE_RegisterRasterStyledLayer(%Q, 1)",
................................................................................

/* testing GetMapImage - NDVI */
    if (!test_default_bands (sqlite, coverage))
      {
	  *retcode += -102;
	  return 0;
      }



























    if (!do_export_map_image (sqlite, coverage, geom, "ndvi", "jpg", 0))
      {
	  *retcode += 104;
	  return 0;
      }

/* testing GetMapImage - IR false color */
................................................................................
		*retcode += -99;
		return 0;
	    }
	  if (!do_export_section_mono_tiff_tfw (sqlite, coverage, geom, 8))
	    {
		*retcode += -100;
		return 0;
	    }
	  if (ndvi)
	    {
		/* Section NDVI Ascii Grid */
		if (!do_export_section_ndvi (sqlite, coverage, geom))
		  {
		      *retcode += -102;
		      return 0;
		  }
	    }
	  gaiaFreeGeomColl (geom);
      }

    if (!do_test_tile_data (sqlite, compression, tile_sz))
      {
	  *retcode += -103;

    sqlite3_free (path);
    if (strcmp(suffix, "png") == 0 && strcmp(style, "default") != 0)
		retcode = do_export_styled_map_image (sqlite, coverage, geom, style, suffix);
    return retcode;
}

static int
do_export_ndvi (sqlite3 * sqlite, const char *coverage, gaiaGeomCollPtr geom, int ndwi_mode)
{
/* exporting an NDVI Ascii Grid */
    const char *sql;
    const char *path;
    sqlite3_stmt *stmt;
    int ret;
    double x_res;
    double y_res;
    double xx_res;
    double yy_res;
    unsigned char *blob;
................................................................................
    if (!get_base_resolution (sqlite, coverage, &x_res, &y_res))
	return 0;
    xx_res = x_res * (double) scale;
    yy_res = y_res * (double) scale;
    if (xx_res != yy_res)
	xx_res = (xx_res + yy_res) / 2.0;

if (ndwi_mode)
{
    path = "./ndwi_ascii_grid.asc";
    sql = "SELECT RL2_WriteNdwiAsciiGrid('main', ?, ?, ?, ?, ?, ?)";
}
else
{
    path = "./ndvi_ascii_grid.asc";
    sql = "SELECT RL2_WriteNdviAsciiGrid('main', ?, ?, ?, ?, ?, ?)";
}
    ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
    if (ret != SQLITE_OK)
	return 0;
    sqlite3_reset (stmt);
    sqlite3_clear_bindings (stmt);
    sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
    sqlite3_bind_text (stmt, 2, path, strlen (path), SQLITE_STATIC);
    sqlite3_bind_int (stmt, 3, 1024);
    sqlite3_bind_int (stmt, 4, 1024);


    gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
    sqlite3_bind_blob (stmt, 5, blob, blob_size, free);
    sqlite3_bind_double (stmt, 6, xx_res);
    ret = sqlite3_step (stmt);
    if (ret == SQLITE_DONE || ret == SQLITE_ROW)
      {
	  if (sqlite3_column_int (stmt, 0) == 1)
	      retcode = 1;
      }
    sqlite3_finalize (stmt);
    unlink (path);
    if (!retcode)
	fprintf (stderr, "cov ERROR: unable to export \"%s\"\n", path);
    return retcode;
}

static int
do_export_section_ndvi (sqlite3 * sqlite, const char *coverage,
			gaiaGeomCollPtr geom, int ndwi_mode)
{
/* exporting a Section NDVI Ascii Grid */
    const char *sql;
    const char *path;
    sqlite3_stmt *stmt;
    int ret;
    double x_res;
    double y_res;
    double xx_res;
    double yy_res;
    unsigned char *blob;
................................................................................
    if (!get_base_resolution (sqlite, coverage, &x_res, &y_res))
	return 0;
    xx_res = x_res * (double) scale;
    yy_res = y_res * (double) scale;
    if (xx_res != yy_res)
	xx_res = (xx_res + yy_res) / 2.0;

if (ndwi_mode)
{
    path = "./ndwi_ascii_grid_section.asc";
    sql =
	"SELECT RL2_WriteSectionNdwiAsciiGrid('main', ?, ?, ?, ?, ?, ?, ?)";
}
else
{
    path = "./ndvi_ascii_grid_section.asc";
    sql =
	"SELECT RL2_WriteSectionNdviAsciiGrid('main', ?, ?, ?, ?, ?, ?, ?)";
}
    ret = sqlite3_prepare_v2 (sqlite, sql, strlen (sql), &stmt, NULL);
    if (ret != SQLITE_OK)
	return 0;
    sqlite3_reset (stmt);
    sqlite3_clear_bindings (stmt);
    sqlite3_bind_text (stmt, 1, coverage, strlen (coverage), SQLITE_STATIC);
    sqlite3_bind_int64 (stmt, 2, 1);
    sqlite3_bind_text (stmt, 3, path, strlen (path), SQLITE_STATIC);
    sqlite3_bind_int (stmt, 4, 1024);
    sqlite3_bind_int (stmt, 5, 1024);


    gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_size);
    sqlite3_bind_blob (stmt, 6, blob, blob_size, free);
    sqlite3_bind_double (stmt, 7, xx_res);
    ret = sqlite3_step (stmt);
    if (ret == SQLITE_DONE || ret == SQLITE_ROW)
      {
	  if (sqlite3_column_int (stmt, 0) == 1)
	      retcode = 1;
      }
    sqlite3_finalize (stmt);
    unlink (path);
    if (!retcode)
	fprintf (stderr, "sect ERROR: unable to export \"%s\"\n", path);
    return retcode;
}

static gaiaGeomCollPtr
get_center_point (sqlite3 * sqlite, const char *coverage)
{
/* attempting to retrieve the Coverage's Center Point */
................................................................................
	  *retcode += -40;
	  return 0;
      }
    if (!do_export_mono_band_tiff_tfw (sqlite, coverage, geom, 1, 2))
      {
	  *retcode += -41;
	  return 0;









      }
    if (!test_map_image)
	goto skip;

/* loading the RasterSymbolizers */
    sql =
	sqlite3_mprintf ("SELECT SE_RegisterRasterStyledLayer(%Q, 1)",
................................................................................

/* testing GetMapImage - NDVI */
    if (!test_default_bands (sqlite, coverage))
      {
	  *retcode += -102;
	  return 0;
      }
    if (ndvi)
      {
	  /* NDVI Ascii Grid */
	  if (!do_export_ndvi (sqlite, coverage, geom, 0))
	    {
		*retcode += -101;
		return 0;
	    }
		/* Section NDVI Ascii Grid */
		if (!do_export_section_ndvi (sqlite, coverage, geom, 0))
		  {
		      *retcode += -102;
		      return 0;
		  }
	  /* NDWI Ascii Grid */
	  if (!do_export_ndvi (sqlite, coverage, geom, 1))
	    {
		*retcode += -101;
		return 0;
	    }
		/* Section NDWI Ascii Grid */
		if (!do_export_section_ndvi (sqlite, coverage, geom, 1))
		  {
		      *retcode += -102;
		      return 0;
		  }
	    }
    if (!do_export_map_image (sqlite, coverage, geom, "ndvi", "jpg", 0))
      {
	  *retcode += 104;
	  return 0;
      }

/* testing GetMapImage - IR false color */
................................................................................
		*retcode += -99;
		return 0;
	    }
	  if (!do_export_section_mono_tiff_tfw (sqlite, coverage, geom, 8))
	    {
		*retcode += -100;
		return 0;









	    }
	  gaiaFreeGeomColl (geom);
      }

    if (!do_test_tile_data (sqlite, compression, tile_sz))
      {
	  *retcode += -103;

    int retcode = 1;
    char *path;
    int i;
    unsigned char *rgb;
    unsigned char *alpha;
    unsigned char *png = NULL;
    int png_size;
    int has_labels;
    FILE *out;
    int half_transparent;
    rl2GraphicsContextPtr ctx = NULL;
    rl2GraphicsContextPtr ctx_labels = NULL;
    rl2GraphicsContextPtr ctx_nodes = NULL;
    rl2GraphicsContextPtr ctx_edges = NULL;
    rl2GraphicsContextPtr ctx_links = NULL;
    rl2GraphicsContextPtr ctx_faces = NULL;
    rl2GraphicsContextPtr ctx_edge_seeds = NULL;
    rl2GraphicsContextPtr ctx_link_seeds = NULL;
    rl2GraphicsContextPtr ctx_face_seeds = NULL;
................................................................................
    rl2CanvasPtr canvas = NULL;

    gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_sz);

    if (toponet)
      {
	  ctx = rl2_graph_create_context (data, 1024, 1024);
	  ctx_labels = rl2_graph_create_context (data, 1024, 1024);
	  ctx_nodes = rl2_graph_create_context (data, 1024, 1024);
	  ctx_links = rl2_graph_create_context (data, 1024, 1024);
	  ctx_link_seeds = rl2_graph_create_context (data, 1024, 1024);
	  canvas =
	      rl2_create_network_canvas (ctx, ctx_labels, ctx_nodes, ctx_links,
					 ctx_link_seeds);
      }
    if (topogeo)
      {
	  ctx = rl2_graph_create_context (data, 1024, 1024);
	  ctx_labels = rl2_graph_create_context (data, 1024, 1024);
	  ctx_nodes = rl2_graph_create_context (data, 1024, 1024);
	  ctx_edges = rl2_graph_create_context (data, 1024, 1024);
	  ctx_faces = rl2_graph_create_context (data, 1024, 1024);
	  ctx_edge_seeds = rl2_graph_create_context (data, 1024, 1024);
	  ctx_face_seeds = rl2_graph_create_context (data, 1024, 1024);
	  canvas =
	      rl2_create_topology_canvas (ctx, ctx_labels, ctx_nodes, ctx_edges,
					  ctx_faces, ctx_edge_seeds,
					  ctx_face_seeds);
      }

    switch (mode)
      {
      case 0:
	  ret =
	      rl2_map_image_paint_from_vector (sqlite, data, canvas, NULL,
					       coverage, blob, blob_sz, 0,
					       style, NULL, &has_labels);
	  break;
      case 1:
	  ret =
	      rl2_map_image_paint_from_vector_ex (sqlite, data, canvas, NULL,
						  coverage, blob, blob_sz, 0,
						  style, NULL, 1, 1, 1, 1, 1, &has_labels);
	  break;
      case 2:
	  ret =
	      rl2_map_image_paint_from_vector_ex (sqlite, data, canvas, NULL,
						  coverage, blob, blob_sz, 0,
						  style, NULL, 0, 1, 0, 1, 0, &has_labels);
	  break;
      case 3:
	  ret =
	      rl2_map_image_paint_from_vector_ex (sqlite, data, canvas, NULL,
						  coverage, blob, blob_sz, 0,
						  style, NULL, 1, 0, 1, 0, 1, &has_labels);
	  break;
      };
    if (ret != RL2_OK)
      {
	  fprintf (stderr, "C API (base) failure !!! (%s - %s)\n", coverage,
		   (style == NULL) ? "NULL" : style);
	  return 0;

    int retcode = 1;
    char *path;
    int i;
    unsigned char *rgb;
    unsigned char *alpha;
    unsigned char *png = NULL;
    int png_size;

    FILE *out;
    int half_transparent;
    rl2GraphicsContextPtr ctx = NULL;

    rl2GraphicsContextPtr ctx_nodes = NULL;
    rl2GraphicsContextPtr ctx_edges = NULL;
    rl2GraphicsContextPtr ctx_links = NULL;
    rl2GraphicsContextPtr ctx_faces = NULL;
    rl2GraphicsContextPtr ctx_edge_seeds = NULL;
    rl2GraphicsContextPtr ctx_link_seeds = NULL;
    rl2GraphicsContextPtr ctx_face_seeds = NULL;
................................................................................
    rl2CanvasPtr canvas = NULL;

    gaiaToSpatiaLiteBlobWkb (geom, &blob, &blob_sz);

    if (toponet)
      {
	  ctx = rl2_graph_create_context (data, 1024, 1024);

	  ctx_nodes = rl2_graph_create_context (data, 1024, 1024);
	  ctx_links = rl2_graph_create_context (data, 1024, 1024);
	  ctx_link_seeds = rl2_graph_create_context (data, 1024, 1024);
	  canvas =
	      rl2_create_network_canvas (ctx, ctx_nodes, ctx_links,
					 ctx_link_seeds);
      }
    if (topogeo)
      {
	  ctx = rl2_graph_create_context (data, 1024, 1024);

	  ctx_nodes = rl2_graph_create_context (data, 1024, 1024);
	  ctx_edges = rl2_graph_create_context (data, 1024, 1024);
	  ctx_faces = rl2_graph_create_context (data, 1024, 1024);
	  ctx_edge_seeds = rl2_graph_create_context (data, 1024, 1024);
	  ctx_face_seeds = rl2_graph_create_context (data, 1024, 1024);
	  canvas =
	      rl2_create_topology_canvas (ctx, ctx_nodes, ctx_edges,
					  ctx_faces, ctx_edge_seeds,
					  ctx_face_seeds);
      }

    switch (mode)
      {
      case 0:
	  ret =
	      rl2_map_image_paint_from_vector (sqlite, data, canvas, NULL,
					       coverage, blob, blob_sz, 0,
					       style, NULL);
	  break;
      case 1:
	  ret =
	      rl2_map_image_paint_from_vector_ex (sqlite, data, canvas, NULL,
						  coverage, blob, blob_sz, 0,
						  style, NULL, 1, 1, 1, 1, 1);
	  break;
      case 2:
	  ret =
	      rl2_map_image_paint_from_vector_ex (sqlite, data, canvas, NULL,
						  coverage, blob, blob_sz, 0,
						  style, NULL, 0, 1, 0, 1, 0);
	  break;
      case 3:
	  ret =
	      rl2_map_image_paint_from_vector_ex (sqlite, data, canvas, NULL,
						  coverage, blob, blob_sz, 0,
						  style, NULL, 1, 0, 1, 0, 1);
	  break;
      };
    if (ret != RL2_OK)
      {
	  fprintf (stderr, "C API (base) failure !!! (%s - %s)\n", coverage,
		   (style == NULL) ? "NULL" : style);
	  return 0;