X-Git-Url: http://pileus.org/git/?p=grits;a=blobdiff_plain;f=src%2Fobjects%2Fgis-tile.c;h=9a2a29886a4277ad90b2a503948dbf90a592c72d;hp=b2f96d377eaf6a6476f32359878dff208415c09b;hb=b5fde541db3eec5aa0b2d7f5b7a0725ad524f84c;hpb=5fc5cb01b2d060bdfa5a268c0d4e6b528bd31edc
diff --git a/src/objects/gis-tile.c b/src/objects/gis-tile.c
index b2f96d3..9a2a298 100644
--- a/src/objects/gis-tile.c
+++ b/src/objects/gis-tile.c
@@ -15,6 +15,23 @@
* along with this program. If not, see .
*/
+/**
+ * SECTION:gis-tile
+ * @short_description: Latitude/longitude overlays
+ *
+ * Each #GisTile corresponds to a latitude/longitude box on the surface of the
+ * earth. When drawn, the #GisTile renders an images associated with it to the
+ * surface of the earth. This is primarily used to draw ground overlays.
+ *
+ * Each GisTile can be split into subtiles in order to draw higher resolution
+ * overlays. Pointers to subtitles are stored in the parent tile and a parent
+ * pointer is stored in each child.
+ *
+ * Each #GisTile has a data filed which must be set by the user in order for
+ * the tile to be drawn. When used with GisOpenGL the data must be an integer
+ * representing the OpenGL texture to use when drawing the tile.
+ */
+
#include
#include "gis-util.h"
#include "gis-tile.h"
@@ -24,22 +41,45 @@ gchar *gis_tile_path_table[2][2] = {
{"10.", "11."},
};
+/**
+ * gis_tile_new:
+ * @parent: the parent for the tile, or NULL
+ * @n: the northern border of the tile
+ * @s: the southern border of the tile
+ * @e: the eastern border of the tile
+ * @w: the western border of the tile
+ *
+ * Create a tile associated with a particular latitude/longitude box.
+ *
+ * Returns: the new #GisTile
+ */
GisTile *gis_tile_new(GisTile *parent,
gdouble n, gdouble s, gdouble e, gdouble w)
{
- GisTile *self = g_object_new(GIS_TYPE_TILE, NULL);
- self->parent = parent;
- self->edge.n = n;
- self->edge.s = s;
- self->edge.e = e;
- self->edge.w = w;
- self->atime = time(NULL);
- return self;
+ GisTile *tile = g_object_new(GIS_TYPE_TILE, NULL);
+ tile->parent = parent;
+ tile->edge.n = n;
+ tile->edge.s = s;
+ tile->edge.e = e;
+ tile->edge.w = w;
+ tile->atime = time(NULL);
+ return tile;
}
+/**
+ * gis_tile_get_path:
+ * @child: the tile to generate a path for
+ *
+ * Generate a string representation of a tiles location in a group of nested
+ * tiles. The string returned consists of groups of two digits separated by a
+ * delimiter. Each group of digits the tiles location with respect to it's
+ * parent tile.
+ *
+ * Returns: the path representing the tiles's location
+ */
gchar *gis_tile_get_path(GisTile *child)
{
- /* This could be easily cached if necessasairy */
+ /* This could be easily cached if necessary */
int x, y;
GList *parts = NULL;
for (GisTile *parent = child->parent; parent; child = parent, parent = child->parent)
@@ -47,19 +87,20 @@ gchar *gis_tile_get_path(GisTile *child)
if (parent->children[x][y] == child)
parts = g_list_prepend(parts, gis_tile_path_table[x][y]);
GString *path = g_string_new("");
- for (; parts; parts = parts->next)
- g_string_append(path, parts->data);
+ for (GList *cur = parts; cur; cur = cur->next)
+ g_string_append(path, cur->data);
g_list_free(parts);
return g_string_free(path, FALSE);
}
-gdouble _gis_tile_get_min_dist(GisTile *self,
- gdouble lat, gdouble lon, gdouble elev)
+static gdouble _gis_tile_get_min_dist(
+ gdouble lat, gdouble lon, gdouble elev,
+ gdouble n, gdouble s, gdouble e, gdouble w)
{
- gdouble tlat = lat > self->edge.n ? self->edge.n :
- lat < self->edge.s ? self->edge.s : lat;
- gdouble tlon = lon > self->edge.e ? self->edge.e :
- lon < self->edge.w ? self->edge.w : lon;
+ gdouble tlat = lat > n ? n :
+ lat < s ? s : lat;
+ gdouble tlon = lon > e ? e :
+ lon < w ? w : lon;
gdouble telev = 0; // TODO: elevation at rlat,rlon
//if (lat == tlat && lon == tlon)
// return elev; /* Shortcut? */
@@ -69,56 +110,80 @@ gdouble _gis_tile_get_min_dist(GisTile *self,
return distd(a, b);
}
-gboolean _gis_tile_needs_split(GisTile *self,
- gdouble max_res, gint width, gint height,
- gdouble lat, gdouble lon, gdouble elev)
+static gboolean _gis_tile_precise(
+ gdouble lat, gdouble lon, gdouble elev,
+ gdouble n, gdouble s, gdouble e, gdouble w,
+ gdouble max_res, gint width, gint height)
{
- gdouble lat_point = self->edge.n < 0 ? self->edge.n :
- self->edge.s > 0 ? self->edge.s : 0;
- gdouble min_dist = _gis_tile_get_min_dist(self, lat, lon, elev);
+ gdouble min_dist = _gis_tile_get_min_dist(lat, lon, elev, n, s, e, w);
gdouble view_res = MPPX(min_dist);
- gdouble lon_dist = self->edge.e - self->edge.w;
+
+ gdouble lat_point = n < 0 ? n : s > 0 ? s : 0;
+ gdouble lon_dist = e - w;
gdouble tile_res = ll2m(lon_dist, lat_point)/width;
/* This isn't really right, but it helps with memory since we don't (yet?) test if the tile
* would be drawn */
gdouble scale = elev / min_dist;
view_res /= scale;
+ //view_res /= 1.4; /* make it a little nicer, not sure why this is needed */
//g_message("tile=(%7.2f %7.2f %7.2f %7.2f) "
// "eye=(%9.1f %9.1f %9.1f) "
// "elev=%9.1f / dist=%9.1f = %f",
- // self->edge.n, self->edge.s, self->edge.e, self->edge.w,
+ // tile->edge.n, tile->edge.s, tile->edge.e, tile->edge.w,
// lat, lon, elev,
// elev, min_dist, scale);
- if (tile_res < max_res)
- return FALSE;
- return view_res < tile_res;
+ return tile_res < max_res ||
+ tile_res < view_res;
}
-void gis_tile_update(GisTile *self,
+/**
+ * gis_tile_update:
+ * @root: the root tile to split
+ * @res: a maximum resolution in meters per pixel to split tiles to
+ * @width: width in pixels of the image associated with the tile
+ * @height: height in pixels of the image associated with the tile
+ * @lat: latitude of the eye point
+ * @lon: longitude of the eye point
+ * @elev: elevation of the eye point
+ * @load_func: function used to load the image when a new tile is created
+ * @user_data: user data to past to the load function
+ *
+ * Recursively split a tile into children of appropriate detail. The resolution
+ * of the tile in pixels per meter is compared to the resolution which the tile
+ * is being drawn at on the screen. If the screen resolution is insufficient
+ * the tile is recursively subdivided until a sufficient resolution is
+ * achieved.
+ */
+void gis_tile_update(GisTile *root,
gdouble res, gint width, gint height,
gdouble lat, gdouble lon, gdouble elev,
GisTileLoadFunc load_func, gpointer user_data)
{
- self->atime = time(NULL);
- //g_debug("GisTile: update - %p->atime = %u", self, (guint)self->atime);
- gdouble lat_dist = self->edge.n - self->edge.s;
- gdouble lon_dist = self->edge.e - self->edge.w;
- if (_gis_tile_needs_split(self, res, width, height, lat, lon, elev)) {
- gdouble lat_step = lat_dist / G_N_ELEMENTS(self->children);
- gdouble lon_step = lon_dist / G_N_ELEMENTS(self->children[0]);
- int x, y;
- gis_tile_foreach_index(self, x, y) {
- if (!self->children[x][y]) {
- self->children[x][y] = gis_tile_new(self,
- self->edge.n-(lat_step*(x+0)),
- self->edge.n-(lat_step*(x+1)),
- self->edge.w+(lon_step*(y+1)),
- self->edge.w+(lon_step*(y+0)));
- load_func(self->children[x][y], user_data);
+ root->atime = time(NULL);
+ //g_debug("GisTile: update - %p->atime = %u",
+ // root, (guint)root->atime);
+ const gdouble rows = G_N_ELEMENTS(root->children);
+ const gdouble cols = G_N_ELEMENTS(root->children[0]);
+ const gdouble lat_dist = root->edge.n - root->edge.s;
+ const gdouble lon_dist = root->edge.e - root->edge.w;
+ const gdouble lat_step = lat_dist / rows;
+ const gdouble lon_step = lon_dist / cols;
+ int row, col;
+ gis_tile_foreach_index(root, row, col) {
+ GisTile **child = &root->children[row][col];
+ const gdouble n = root->edge.n-(lat_step*(row+0));
+ const gdouble s = root->edge.n-(lat_step*(row+1));
+ const gdouble e = root->edge.w+(lon_step*(col+1));
+ const gdouble w = root->edge.w+(lon_step*(col+0));
+ if (!_gis_tile_precise(lat,lon,elev, n,s,e,w,
+ res,width/cols,height/rows)) {
+ if (!*child) {
+ *child = gis_tile_new(root, n,s,e,w);
+ load_func(*child, user_data);
}
- gis_tile_update(self->children[x][y],
+ gis_tile_update(*child,
res, width, height,
lat, lon, elev,
load_func, user_data);
@@ -126,16 +191,27 @@ void gis_tile_update(GisTile *self,
}
}
-GisTile *gis_tile_find(GisTile *self, gdouble lat, gdouble lon)
+/**
+ * gis_tile_find:
+ * @root: the root tile to search from
+ * @lat: target latitude
+ * @lon: target longitude
+ *
+ * Locate the subtile with the highest resolution which contains the given
+ * lat/lon point.
+ *
+ * Returns: the child tile
+ */
+GisTile *gis_tile_find(GisTile *root, gdouble lat, gdouble lon)
{
- gint rows = G_N_ELEMENTS(self->children);
- gint cols = G_N_ELEMENTS(self->children[0]);
+ gint rows = G_N_ELEMENTS(root->children);
+ gint cols = G_N_ELEMENTS(root->children[0]);
- gdouble lat_step = (self->edge.n - self->edge.s) / rows;
- gdouble lon_step = (self->edge.e - self->edge.w) / cols;
+ gdouble lat_step = (root->edge.n - root->edge.s) / rows;
+ gdouble lon_step = (root->edge.e - root->edge.w) / cols;
- gdouble lat_offset = self->edge.n - lat;;
- gdouble lon_offset = lon - self->edge.w;
+ gdouble lat_offset = root->edge.n - lat;;
+ gdouble lon_offset = lon - root->edge.w;
gint row = lat_offset / lat_step;
gint col = lon_offset / lon_step;
@@ -149,50 +225,75 @@ GisTile *gis_tile_find(GisTile *self, gdouble lat, gdouble lon)
if (row < 0 || row >= rows || col < 0 || col >= cols)
return NULL;
- else if (self->children[row][col] && self->children[row][col]->data)
- return gis_tile_find(self->children[row][col], lat, lon);
+ else if (root->children[row][col] && root->children[row][col]->data)
+ return gis_tile_find(root->children[row][col], lat, lon);
else
- return self;
+ return root;
}
-GisTile *gis_tile_gc(GisTile *self, time_t atime,
+/**
+ * gis_tile_gc:
+ * @root: the root tile to start garbage collection at
+ * @atime: most recent time at which tiles will be kept
+ * @free_func: function used to free the image when a new tile is collected
+ * @user_data: user data to past to the free function
+ *
+ * Garbage collect old tiles. This removes and deallocate tiles that have not
+ * been used since before @atime.
+ *
+ * Returns: a pointer to the original tile, or NULL if it was garbage collected
+ */
+GisTile *gis_tile_gc(GisTile *root, time_t atime,
GisTileFreeFunc free_func, gpointer user_data)
{
- if (!self)
+ if (!root)
return NULL;
gboolean has_children = FALSE;
int x, y;
- gis_tile_foreach_index(self, x, y) {
- self->children[x][y] = gis_tile_gc(
- self->children[x][y], atime,
+ gis_tile_foreach_index(root, x, y) {
+ root->children[x][y] = gis_tile_gc(
+ root->children[x][y], atime,
free_func, user_data);
- if (self->children[x][y])
+ if (root->children[x][y])
has_children = TRUE;
}
//g_debug("GisTile: gc - %p->atime=%u < atime=%u",
- // self, (guint)self->atime, (guint)atime);
- if (!has_children && self->atime < atime && self->data) {
- free_func(self, user_data);
- g_free(self);
+ // root, (guint)root->atime, (guint)atime);
+ if (!has_children && root->atime < atime && root->data) {
+ free_func(root, user_data);
+ g_object_unref(root);
return NULL;
}
- return self;
+ return root;
}
/* Use GObject for this */
-void gis_tile_free(GisTile *self, GisTileFreeFunc free_func, gpointer user_data)
+/**
+ * gis_tile_free:
+ * @root: the root tile to free
+ * @free_func: function used to free the image when a new tile is collected
+ * @user_data: user data to past to the free function
+ *
+ * Recursively free a tile and all it's children.
+ */
+void gis_tile_free(GisTile *root, GisTileFreeFunc free_func, gpointer user_data)
{
- if (!self)
+ if (!root)
return;
GisTile *child;
- gis_tile_foreach(self, child)
+ gis_tile_foreach(root, child)
gis_tile_free(child, free_func, user_data);
if (free_func)
- free_func(self, user_data);
- g_object_unref(self);
+ free_func(root, user_data);
+ g_object_unref(root);
}
/* GObject code */
G_DEFINE_TYPE(GisTile, gis_tile, GIS_TYPE_OBJECT);
-static void gis_tile_init(GisTile *self) { }
-static void gis_tile_class_init(GisTileClass *klass) { }
+static void gis_tile_init(GisTile *tile)
+{
+}
+
+static void gis_tile_class_init(GisTileClass *klass)
+{
+}