map.h

Go to the documentation of this file.

 
#ifndef NAVIT_MAP_H
#define NAVIT_MAP_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdio.h>  // for FILE
 
#include "attr_type_def.h"  // for attr_type
#include "coord.h"          // for coord, coord_rect
#include "debug.h"          // for dbg_assert
#include "item.h"           // for item_range
#include "item_type_def.h"  // for item_type
#include "point.h"          // for point_rect
#include "projection.h"     // for projection
 
struct attr;
 
#define WORLD_BOUNDINGBOX_MIN_X -20000000
#define WORLD_BOUNDINGBOX_MAX_X 20000000
#define WORLD_BOUNDINGBOX_MIN_Y -20000000
#define WORLD_BOUNDINGBOX_MAX_Y 20000000
 
struct map_selection {
    struct map_selection *next; 
    union {
        struct coord_rect c_rect; 
        struct point_rect p_rect; 
    } u;
    int order;               
    struct item_range range; 
};
 
struct attr_iter;
struct callback;
struct map;
struct map_priv;
struct map_rect;
struct map_search;
 
struct map_methods {
    enum projection pro; 
    char *charset; 
    void (*map_destroy)(struct map_priv *priv); 
    struct map_rect_priv *(*map_rect_new)(
        struct map_priv *map, struct map_selection *sel); 
    void (*map_rect_destroy)(struct map_rect_priv *mr);   
    struct item *(*map_rect_get_item)(
        struct map_rect_priv *mr); 
    struct item *(*map_rect_get_item_byid)(
        struct map_rect_priv *mr, int id_hi,
        int id_lo); 
    struct map_search_priv *(*map_search_new)(
        struct map_priv *map, struct item *item, struct attr *search,
        int partial); 
    void (*map_search_destroy)(struct map_search_priv *ms); 
    struct item *(*map_search_get_item)(struct map_search_priv *ms); 
    struct item *(*map_rect_create_item)(struct map_rect_priv *mr,
                                         enum item_type type); 
    int (*map_get_attr)(struct map_priv *priv, enum attr_type type,
                        struct attr *attr);                        
    int (*map_set_attr)(struct map_priv *priv, struct attr *attr); 
};
 
static inline int map_selection_contains_point(struct map_selection *sel, struct coord *c) {
    struct map_selection *curr = sel;
    while (curr) {
        struct coord_rect *r = &curr->u.c_rect;
        if (c->x >= r->lu.x && c->x <= r->rl.x && c->y <= r->lu.y && c->y >= r->rl.y)
            return 1;
        curr = curr->next;
    }
    return sel ? 0 : 1;
}
 
static inline int map_selection_contains_polyline(struct map_selection *sel, struct coord *c, int count) {
    int i, x_mi, x_ma, y_mi, y_ma;
    struct map_selection *curr;
 
    if (!sel)
        return 1;
    for (i = 0; i < count - 1; i++) {
        x_mi = c[i].x;
        if (c[i + 1].x < x_mi)
            x_mi = c[i + 1].x;
        x_ma = c[i].x;
        if (c[i + 1].x > x_ma)
            x_ma = c[i + 1].x;
        y_mi = c[i].y;
        if (c[i + 1].y < y_mi)
            y_mi = c[i + 1].y;
        y_ma = c[i].y;
        if (c[i + 1].y > y_ma)
            y_ma = c[i + 1].y;
        curr = sel;
        while (curr) {
            struct coord_rect *sr = &curr->u.c_rect;
            if (x_mi <= sr->rl.x && x_ma >= sr->lu.x && y_ma >= sr->rl.y && y_mi <= sr->lu.y)
                return 1;
            curr = curr->next;
        }
    }
    return 0;
}
 
static inline int map_selection_contains_rect(struct map_selection *sel, struct coord_rect *r) {
    struct map_selection *curr;
 
    dbg_assert(r->lu.x <= r->rl.x);
    dbg_assert(r->lu.y >= r->rl.y);
 
    if (!sel)
        return 1;
    curr = sel;
    while (curr) {
        struct coord_rect *sr = &curr->u.c_rect;
        dbg_assert(sr->lu.x <= sr->rl.x);
        dbg_assert(sr->lu.y >= sr->rl.y);
        if (r->lu.x <= sr->rl.x && r->rl.x >= sr->lu.x && r->lu.y >= sr->rl.y && r->rl.y <= sr->lu.y)
            return 1;
        curr = curr->next;
    }
    return 0;
}
 
static inline int map_selection_contains_polygon(struct map_selection *sel, struct coord *c, int count) {
    struct coord_rect r;
    int i;
 
    if (!sel)
        return 1;
    if (!count)
        return 0;
    r.lu = c[0];
    r.rl = c[0];
    for (i = 1; i < count; i++) {
        if (c[i].x < r.lu.x)
            r.lu.x = c[i].x;
        if (c[i].x > r.rl.x)
            r.rl.x = c[i].x;
        if (c[i].y < r.rl.y)
            r.rl.y = c[i].y;
        if (c[i].y > r.lu.y)
            r.lu.y = c[i].y;
    }
    return map_selection_contains_rect(sel, &r);
}
struct map *map_new(struct attr *parent, struct attr **attrs);
struct map *map_ref(struct map *m);
void map_unref(struct map *m);
int map_get_attr(struct map *this_, enum attr_type type, struct attr *attr, struct attr_iter *iter);
int map_set_attr(struct map *this_, struct attr *attr);
void map_add_callback(struct map *this_, struct callback *cb);
void map_remove_callback(struct map *this_, struct callback *cb);
int map_requires_conversion(struct map *this_);
char *map_convert_string_tmp(struct map *this_, char *str);
char *map_convert_string(struct map *this_, char *str);
char *map_convert_dup(char *str);
void map_convert_free(char *str);
enum projection map_projection(struct map *this_);
void map_set_projection(struct map *this_, enum projection pro);
void map_destroy(struct map *m);
struct map_rect *map_rect_new(struct map *m, struct map_selection *sel);
struct item *map_rect_get_item(struct map_rect *mr);
struct item *map_rect_get_item_byid(struct map_rect *mr, int id_hi, int id_lo);
struct item *map_rect_create_item(struct map_rect *mr, enum item_type type_);
void map_rect_destroy(struct map_rect *mr);
struct map_search *map_search_new(struct map *m, struct item *item, struct attr *search_attr, int partial);
struct item *map_search_get_item(struct map_search *this_);
void map_search_destroy(struct map_search *this_);
struct map_selection *map_selection_rect_new(struct pcoord *center, int distance, int order);
struct map_selection *map_selection_dup_pro(struct map_selection *sel, enum projection from, enum projection to);
struct map_selection *map_selection_dup(struct map_selection *sel);
void map_selection_destroy(struct map_selection *sel);
int map_selection_contains_item_rect(struct map_selection *sel, struct item *item);
int map_selection_contains_item_range(struct map_selection *sel, int follow, struct item_range *range, int count);
int map_selection_contains_item(struct map_selection *sel, int follow, enum item_type type);
int map_priv_is(struct map *map, struct map_priv *priv);
void map_dump_filedesc(struct map *map, FILE *out);
void map_dump_file(struct map *map, const char *file);
void map_dump(struct map *map);
void map_destroy_do(struct map *m);
struct maps *maps_new(struct attr *parent, struct attr **attrs);
/* end of prototypes */
 
#ifdef __cplusplus
}
#endif
#endif