/* Pulls all items from list which match this prefix
* note: they are removed from the original list an returned in a new one
*/
struct keyval *getMatches(struct keyval *head, const char *name)
{
struct keyval *out = NULL;
struct keyval *p;
if (!head)
return NULL;
out = malloc(sizeof(struct keyval));
if (!out)
return NULL;
initList(out);
p = head->next;
while(p != head) {
struct keyval *next = p->next;
if (!strncmp(p->key, name, strlen(name))) {
p->next->prev = p->prev;
p->prev->next = p->next;
pushItem(out, p);
}
p = next;
}
if (listHasData(out))
return out;
free(out);
return NULL;
}
size_t WKT(int polygon)
{
while (listHasData(&segs))
{
struct keyval *p;
unsigned int id, to, from;
double x0, y0, x1, y1;
p = popItem(&segs);
id = strtoul(p->value, NULL, 10);
freeItem(p);
from = segments[id].from;
to = segments[id].to;
x0 = nodes[from].lon;
y0 = nodes[from].lat;
x1 = nodes[to].lon;
y1 = nodes[to].lat;
add_segment(x0,y0,x1,y1);
}
return build_geometry(polygon);
}
void EndElement(xmlTextReaderPtr reader, const xmlChar *name)
{
unsigned int id;
DEBUG("%s: %s\n", __FUNCTION__, name);
if (xmlStrEqual(name, BAD_CAST "node")) {
int i;
char *values = NULL, *names = NULL;
char *osm_id = getItem(&keys, "id");
if (!osm_id) {
fprintf(stderr, "%s: Node ID not in keys\n", __FUNCTION__);
resetList(&keys);
resetList(&tags);
return;
}
id = strtoul(osm_id, NULL, 10);
//assert(nodes[id].lat && nodes[id].lon);
for (i=0; i < sizeof(exportTags) / sizeof(exportTags[0]); i++) {
char *v;
if ((v = getItem(&tags, exportTags[i].name))) {
if (values) {
char *oldval = values, *oldnam = names;
asprintf(&names, "%s,\"%s\"", oldnam, exportTags[i].name);
asprintf(&values, "%s,$$%s$$", oldval, v);
free(oldnam);
free(oldval);
} else {
asprintf(&names, "\"%s\"", exportTags[i].name);
asprintf(&values, "$$%s$$", v);
}
}
}
if (values) {
count_node++;
printf("insert into %s (osm_id,%s,way) values "
"(%s,%s,GeomFromText('POINT(%.15g %.15g)',4326));\n",
table_name_point,names,osm_id,values,nodes[id].lon, nodes[id].lat);
}
resetList(&keys);
resetList(&tags);
free(values);
free(names);
} else if (xmlStrEqual(name, BAD_CAST "segment")) {
resetList(&tags);
} else if (xmlStrEqual(name, BAD_CAST "tag")) {
/* Separate tag list so tag stack unused */
} else if (xmlStrEqual(name, BAD_CAST "way")) {
int i, polygon = 0;
char *values = NULL, *names = NULL;
char *osm_id = getItem(&keys, "id");
if (!osm_id) {
fprintf(stderr, "%s: WAY ID not in keys\n", __FUNCTION__);
resetList(&keys);
resetList(&tags);
resetList(&segs);
return;
}
if (!listHasData(&segs)) {
DEBUG("%s: WAY(%s) has no segments\n", __FUNCTION__, osm_id);
resetList(&keys);
resetList(&tags);
resetList(&segs);
return;
}
id = strtoul(osm_id, NULL, 10);
for (i=0; i < sizeof(exportTags) / sizeof(exportTags[0]); i++) {
char *v;
if ((v = getItem(&tags, exportTags[i].name))) {
if (values) {
char *oldval = values, *oldnam = names;
asprintf(&names, "%s,\"%s\"", oldnam, exportTags[i].name);
asprintf(&values, "%s,$$%s$$", oldval, v);
free(oldnam);
free(oldval);
} else {
asprintf(&names, "\"%s\"", exportTags[i].name);
asprintf(&values, "$$%s$$", v);
}
polygon |= exportTags[i].polygon;
}
}
if (values) {
size_t wkt_size = WKT(polygon);
if (wkt_size)
{
unsigned i;
for (i=0;i<wkt_size;i++)
{
const char * wkt = get_wkt(i);
if (strlen(wkt)) {
if (polygon) {
printf("insert into %s (osm_id,%s,way) values (%s,%s,GeomFromText('%s',4326));\n", table_name_polygon,names,osm_id,values,wkt);
}
else {
printf("insert into %s (osm_id,%s,way) values (%s,%s,GeomFromText('%s',4326));\n", table_name_line,names,osm_id,values,wkt);
}
count_way++;
}
}
clear_wkts();
}
}
resetList(&keys);
resetList(&tags);
resetList(&segs);
free(values);
free(names);
} else if (xmlStrEqual(name, BAD_CAST "seg")) {
/* ignore */
} else if (xmlStrEqual(name, BAD_CAST "osm")) {
/* ignore */
} else {
fprintf(stderr, "%s: Unknown element name: %s\n", __FUNCTION__, name);
}
}
static int split_tags(struct keyval *tags, unsigned int flags, struct keyval *names, struct keyval *places, struct keyval *extratags,
int* admin_level, struct keyval ** housenumber, struct keyval ** street, char ** isin, struct keyval ** postcode, struct keyval ** countrycode)
{
int placehouse = 0;
int placebuilding = 0;
int placeadmin = 0;
struct keyval *landuse;
struct keyval *place;
struct keyval *item;
struct keyval *conscriptionnumber;
struct keyval *streetnumber;
*admin_level = ADMINLEVEL_NONE;
*housenumber = 0;
*street = 0;
*isin = 0;
int isinsize = 0;
*postcode = 0;
*countrycode = 0;
landuse = 0;
place = 0;
conscriptionnumber = 0;
streetnumber = 0;
/* Initialise the result lists */
initList(names);
initList(places);
initList(extratags);
/* Loop over the tags */
while ((item = popItem(tags)) != NULL)
{
/* If this is a name tag, add it to the name list */
if (strcmp(item->key, "ref") == 0 ||
strcmp(item->key, "int_ref") == 0 ||
strcmp(item->key, "nat_ref") == 0 ||
strcmp(item->key, "reg_ref") == 0 ||
strcmp(item->key, "loc_ref") == 0 ||
strcmp(item->key, "old_ref") == 0 ||
strcmp(item->key, "ncn_ref") == 0 ||
strcmp(item->key, "rcn_ref") == 0 ||
strcmp(item->key, "lcn_ref") == 0 ||
strcmp(item->key, "iata") == 0 ||
strcmp(item->key, "icao") == 0 ||
strcmp(item->key, "pcode:1") == 0 ||
strcmp(item->key, "pcode:2") == 0 ||
strcmp(item->key, "pcode:3") == 0 ||
strcmp(item->key, "un:pcode:1") == 0 ||
strcmp(item->key, "un:pcode:2") == 0 ||
strcmp(item->key, "un:pcode:3") == 0 ||
strcmp(item->key, "name") == 0 ||
(strncmp(item->key, "name:", 5) == 0) ||
strcmp(item->key, "int_name") == 0 ||
(strncmp(item->key, "int_name:", 9) == 0) ||
strcmp(item->key, "nat_name") == 0 ||
(strncmp(item->key, "nat_name:", 9) == 0) ||
strcmp(item->key, "reg_name") == 0 ||
(strncmp(item->key, "reg_name:", 9) == 0) ||
strcmp(item->key, "loc_name") == 0 ||
(strncmp(item->key, "loc_name:", 9) == 0) ||
strcmp(item->key, "old_name") == 0 ||
(strncmp(item->key, "old_name:", 9) == 0) ||
strcmp(item->key, "alt_name") == 0 ||
(strncmp(item->key, "alt_name:", 9) == 0) ||
strcmp(item->key, "official_name") == 0 ||
(strncmp(item->key, "official_name:", 14) == 0) ||
strcmp(item->key, "commonname") == 0 ||
(strncmp(item->key, "commonname:", 11) == 0) ||
strcmp(item->key, "common_name") == 0 ||
(strncmp(item->key, "common_name:", 12) == 0) ||
strcmp(item->key, "place_name") == 0 ||
(strncmp(item->key, "place_name:", 11) == 0) ||
strcmp(item->key, "short_name") == 0 ||
(strncmp(item->key, "short_name:", 11) == 0) ||
strcmp(item->key, "operator") == 0) /* operator is a bit of an oddity */
{
if (strcmp(item->key, "name:prefix") == 0)
{
pushItem(extratags, item);
}
else
{
pushItem(names, item);
}
}
else if (strcmp(item->key, "aerialway") == 0 ||
strcmp(item->key, "aeroway") == 0 ||
strcmp(item->key, "amenity") == 0 ||
strcmp(item->key, "boundary") == 0 ||
strcmp(item->key, "bridge") == 0 ||
strcmp(item->key, "craft") == 0 ||
strcmp(item->key, "emergency") == 0 ||
strcmp(item->key, "highway") == 0 ||
strcmp(item->key, "historic") == 0 ||
strcmp(item->key, "leisure") == 0 ||
strcmp(item->key, "military") == 0 ||
strcmp(item->key, "natural") == 0 ||
strcmp(item->key, "office") == 0 ||
strcmp(item->key, "railway") == 0 ||
strcmp(item->key, "shop") == 0 ||
strcmp(item->key, "tourism") == 0 ||
strcmp(item->key, "tunnel") == 0 ||
strcmp(item->key, "waterway") == 0 )
{
if (strcmp(item->value, "no"))
{
pushItem(places, item);
if (strcmp(item->key, "boundary") == 0 && strcmp(item->value, "administrative") == 0)
{
placeadmin = 1;
}
}
else
{
freeItem(item);
}
}
else if (strcmp(item->key, "place") == 0)
{
place = item;
}
else if (strcmp(item->key, "addr:housename") == 0)
{
pushItem(names, item);
placehouse = 1;
}
else if (strcmp(item->key, "landuse") == 0)
{
if (strcmp(item->value, "cemetery") == 0)
pushItem(places, item);
else
landuse = item;
}
else if (strcmp(item->key, "postal_code") == 0 ||
strcmp(item->key, "post_code") == 0 ||
strcmp(item->key, "postcode") == 0 ||
strcmp(item->key, "addr:postcode") == 0 ||
strcmp(item->key, "tiger:zip_left") == 0 ||
strcmp(item->key, "tiger:zip_right") == 0)
{
if (*postcode)
freeItem(item);
else
*postcode = item;
}
else if (strcmp(item->key, "addr:street") == 0)
{
*street = item;
}
else if ((strcmp(item->key, "country_code_iso3166_1_alpha_2") == 0 ||
strcmp(item->key, "country_code_iso3166_1") == 0 ||
strcmp(item->key, "country_code_iso3166") == 0 ||
strcmp(item->key, "country_code") == 0 ||
strcmp(item->key, "iso3166-1:alpha2") == 0 ||
strcmp(item->key, "iso3166-1") == 0 ||
strcmp(item->key, "ISO3166-1") == 0 ||
strcmp(item->key, "iso3166") == 0 ||
strcmp(item->key, "is_in:country_code") == 0 ||
strcmp(item->key, "addr:country") == 0 ||
strcmp(item->key, "addr:country_code") == 0)
&& strlen(item->value) == 2)
{
*countrycode = item;
}
else if (strcmp(item->key, "addr:housenumber") == 0)
{
/* house number can be far more complex than just a single house number - leave for postgresql to deal with */
if (*housenumber)
freeItem(item);
else {
*housenumber = item;
placehouse = 1;
}
}
else if (strcmp(item->key, "addr:conscriptionnumber") == 0)
{
if (conscriptionnumber)
freeItem(item);
else {
conscriptionnumber = item;
placehouse = 1;
}
}
else if (strcmp(item->key, "addr:streetnumber") == 0)
{
if (streetnumber)
freeItem(item);
else {
streetnumber = item;
placehouse = 1;
}
}
else if (strcmp(item->key, "addr:interpolation") == 0)
{
/* house number can be far more complex than just a single house number - leave for postgresql to deal with */
if (*housenumber) {
freeItem(item);
} else {
*housenumber = item;
addItem(places, "place", "houses", 1);
}
}
else if (strcmp(item->key, "is_in") == 0 ||
(strncmp(item->key, "is_in:", 5) == 0) ||
strcmp(item->key, "addr:country")== 0 ||
strcmp(item->key, "addr:county")== 0 ||
strcmp(item->key, "tiger:county")== 0 ||
strcmp(item->key, "addr:city") == 0 ||
strcmp(item->key, "addr:state_code") == 0 ||
strcmp(item->key, "addr:state") == 0)
{
*isin = realloc(*isin, isinsize + 2 + strlen(item->value));
*(*isin+isinsize) = ',';
strcpy(*isin+1+isinsize, item->value);
isinsize += 1 + strlen(item->value);
freeItem(item);
}
else if (strcmp(item->key, "admin_level") == 0)
{
*admin_level = atoi(item->value);
freeItem(item);
}
else if (strcmp(item->key, "tracktype") == 0 ||
strcmp(item->key, "traffic_calming") == 0 ||
strcmp(item->key, "service") == 0 ||
strcmp(item->key, "cuisine") == 0 ||
strcmp(item->key, "capital") == 0 ||
strcmp(item->key, "dispensing") == 0 ||
strcmp(item->key, "religion") == 0 ||
strcmp(item->key, "denomination") == 0 ||
strcmp(item->key, "sport") == 0 ||
strcmp(item->key, "internet_access") == 0 ||
strcmp(item->key, "lanes") == 0 ||
strcmp(item->key, "surface") == 0 ||
strcmp(item->key, "smoothness") == 0 ||
strcmp(item->key, "width") == 0 ||
strcmp(item->key, "est_width") == 0 ||
strcmp(item->key, "incline") == 0 ||
strcmp(item->key, "opening_hours") == 0 ||
strcmp(item->key, "food_hours") == 0 ||
strcmp(item->key, "collection_times") == 0 ||
strcmp(item->key, "service_times") == 0 ||
strcmp(item->key, "smoking_hours") == 0 ||
strcmp(item->key, "disused") == 0 ||
strcmp(item->key, "wheelchair") == 0 ||
strcmp(item->key, "sac_scale") == 0 ||
strcmp(item->key, "trail_visibility") == 0 ||
strcmp(item->key, "mtb:scale") == 0 ||
strcmp(item->key, "mtb:description") == 0 ||
strcmp(item->key, "wood") == 0 ||
strcmp(item->key, "drive_thru") == 0 ||
strcmp(item->key, "drive_in") == 0 ||
strcmp(item->key, "access") == 0 ||
strcmp(item->key, "vehicle") == 0 ||
strcmp(item->key, "bicyle") == 0 ||
strcmp(item->key, "foot") == 0 ||
strcmp(item->key, "goods") == 0 ||
strcmp(item->key, "hgv") == 0 ||
strcmp(item->key, "motor_vehicle") == 0 ||
strcmp(item->key, "motor_car") == 0 ||
(strncmp(item->key, "access:", 7) == 0) ||
(strncmp(item->key, "contact:", 8) == 0) ||
(strncmp(item->key, "drink:", 6) == 0) ||
strcmp(item->key, "oneway") == 0 ||
strcmp(item->key, "date_on") == 0 ||
strcmp(item->key, "date_off") == 0 ||
strcmp(item->key, "day_on") == 0 ||
strcmp(item->key, "day_off") == 0 ||
strcmp(item->key, "hour_on") == 0 ||
strcmp(item->key, "hour_off") == 0 ||
strcmp(item->key, "maxweight") == 0 ||
strcmp(item->key, "maxheight") == 0 ||
strcmp(item->key, "maxspeed") == 0 ||
strcmp(item->key, "disused") == 0 ||
strcmp(item->key, "toll") == 0 ||
strcmp(item->key, "charge") == 0 ||
strcmp(item->key, "population") == 0 ||
strcmp(item->key, "description") == 0 ||
strcmp(item->key, "image") == 0 ||
strcmp(item->key, "attribution") == 0 ||
strcmp(item->key, "fax") == 0 ||
strcmp(item->key, "email") == 0 ||
strcmp(item->key, "url") == 0 ||
strcmp(item->key, "website") == 0 ||
strcmp(item->key, "phone") == 0 ||
strcmp(item->key, "tel") == 0 ||
strcmp(item->key, "real_ale") == 0 ||
strcmp(item->key, "smoking") == 0 ||
strcmp(item->key, "food") == 0 ||
strcmp(item->key, "camera") == 0 ||
strcmp(item->key, "brewery") == 0 ||
strcmp(item->key, "locality") == 0 ||
strcmp(item->key, "wikipedia") == 0 ||
(strncmp(item->key, "wikipedia:", 10) == 0)
)
{
pushItem(extratags, item);
}
else if (strcmp(item->key, "building") == 0)
{
placebuilding = 1;
freeItem(item);
}
else if (strcmp(item->key, "mountain_pass") == 0)
{
pushItem(places, item);
}
else
{
freeItem(item);
}
}
/* Handle Czech/Slovak addresses:
- if we have just a conscription number or a street number,
just use the one we have as a house number
- if we have both of them, concatenate them so users may search
by any of them
*/
if (conscriptionnumber || streetnumber)
{
if (*housenumber)
{
freeItem(*housenumber);
}
if (!conscriptionnumber)
{
addItem(tags, "addr:housenumber", streetnumber->value, 0);
freeItem(streetnumber);
*housenumber = popItem(tags);
}
if (!streetnumber)
{
addItem(tags, "addr:housenumber", conscriptionnumber->value, 10);
freeItem(conscriptionnumber);
*housenumber = popItem(tags);
}
if (conscriptionnumber && streetnumber)
{
char * completenumber = strdup(conscriptionnumber->value);
size_t completenumberlength = strlen(completenumber);
completenumber = realloc(completenumber, completenumberlength + 2 + strlen(streetnumber->value));
*(completenumber + completenumberlength) = '/';
strcpy(completenumber + completenumberlength + 1, streetnumber->value);
freeItem(conscriptionnumber);
freeItem(streetnumber);
addItem(tags, "addr:housenumber", completenumber, 0);
*housenumber = popItem(tags);
free(completenumber);
}
}
if (place)
{
if (placeadmin)
{
pushItem(extratags, place);
}
else
{
pushItem(places, place);
}
}
if (placehouse && !listHasData(places))
{
addItem(places, "place", "house", 1);
}
/* Fallback place types - only used if we didn't create something more specific already */
if (placebuilding && !listHasData(places) && (listHasData(names) || *housenumber || *postcode))
{
addItem(places, "building", "yes", 1);
}
if (landuse)
{
if (!listHasData(places))
{
pushItem(places, landuse);
}
else
{
freeItem(item);
}
}
if (*postcode && !listHasData(places))
{
addItem(places, "place", "postcode", 1);
}
/* Try to convert everything to an area */
return 1;
}
static unsigned int tagtransform_c_filter_rel_member_tags(
struct keyval *rel_tags, int member_count,
struct keyval *member_tags, const char **member_role,
int * member_superseeded, int * make_boundary, int * make_polygon, int * roads) {
char *type;
struct keyval tags, *p, *q, *qq, poly_tags;
int i, j;
int first_outerway, contains_tag;
/* Get the type, if there's no type we don't care */
type = getItem(rel_tags, "type");
if (!type)
return 1;
initList(&tags);
initList(&poly_tags);
/* Clone tags from relation */
p = rel_tags->next;
while (p != rel_tags) {
/* For routes, we convert name to route_name */
if ((strcmp(type, "route") == 0) && (strcmp(p->key, "name") == 0))
addItem(&tags, "route_name", p->value, 1);
else if (strcmp(p->key, "type")) /* drop type= */
addItem(&tags, p->key, p->value, 1);
p = p->next;
}
if (strcmp(type, "route") == 0) {
const char *state = getItem(rel_tags, "state");
const char *netw = getItem(rel_tags, "network");
int networknr = -1;
if (state == NULL ) {
state = "";
}
if (netw != NULL ) {
if (strcmp(netw, "lcn") == 0) {
networknr = 10;
if (strcmp(state, "alternate") == 0) {
addItem(&tags, "lcn", "alternate", 1);
} else if (strcmp(state, "connection") == 0) {
addItem(&tags, "lcn", "connection", 1);
} else {
addItem(&tags, "lcn", "yes", 1);
}
} else if (strcmp(netw, "rcn") == 0) {
networknr = 11;
if (strcmp(state, "alternate") == 0) {
addItem(&tags, "rcn", "alternate", 1);
} else if (strcmp(state, "connection") == 0) {
addItem(&tags, "rcn", "connection", 1);
} else {
addItem(&tags, "rcn", "yes", 1);
}
} else if (strcmp(netw, "ncn") == 0) {
networknr = 12;
if (strcmp(state, "alternate") == 0) {
addItem(&tags, "ncn", "alternate", 1);
} else if (strcmp(state, "connection") == 0) {
addItem(&tags, "ncn", "connection", 1);
} else {
addItem(&tags, "ncn", "yes", 1);
}
} else if (strcmp(netw, "lwn") == 0) {
networknr = 20;
if (strcmp(state, "alternate") == 0) {
addItem(&tags, "lwn", "alternate", 1);
} else if (strcmp(state, "connection") == 0) {
addItem(&tags, "lwn", "connection", 1);
} else {
addItem(&tags, "lwn", "yes", 1);
}
} else if (strcmp(netw, "rwn") == 0) {
networknr = 21;
if (strcmp(state, "alternate") == 0) {
addItem(&tags, "rwn", "alternate", 1);
} else if (strcmp(state, "connection") == 0) {
addItem(&tags, "rwn", "connection", 1);
} else {
addItem(&tags, "rwn", "yes", 1);
}
} else if (strcmp(netw, "nwn") == 0) {
networknr = 22;
if (strcmp(state, "alternate") == 0) {
addItem(&tags, "nwn", "alternate", 1);
} else if (strcmp(state, "connection") == 0) {
addItem(&tags, "nwn", "connection", 1);
} else {
addItem(&tags, "nwn", "yes", 1);
}
}
}
if (getItem(rel_tags, "preferred_color") != NULL ) {
const char *a = getItem(rel_tags, "preferred_color");
if (strcmp(a, "0") == 0 || strcmp(a, "1") == 0
|| strcmp(a, "2") == 0 || strcmp(a, "3") == 0
|| strcmp(a, "4") == 0) {
addItem(&tags, "route_pref_color", a, 1);
} else {
addItem(&tags, "route_pref_color", "0", 1);
}
} else {
addItem(&tags, "route_pref_color", "0", 1);
}
if (getItem(rel_tags, "ref") != NULL ) {
if (networknr == 10) {
addItem(&tags, "lcn_ref", getItem(rel_tags, "ref"), 1);
} else if (networknr == 11) {
addItem(&tags, "rcn_ref", getItem(rel_tags, "ref"), 1);
} else if (networknr == 12) {
addItem(&tags, "ncn_ref", getItem(rel_tags, "ref"), 1);
} else if (networknr == 20) {
addItem(&tags, "lwn_ref", getItem(rel_tags, "ref"), 1);
} else if (networknr == 21) {
addItem(&tags, "rwn_ref", getItem(rel_tags, "ref"), 1);
} else if (networknr == 22) {
addItem(&tags, "nwn_ref", getItem(rel_tags, "ref"), 1);
}
}
} else if (strcmp(type, "boundary") == 0) {
/* Boundaries will get converted into multiple geometries:
- Linear features will end up in the line and roads tables (useful for admin boundaries)
- Polygon features also go into the polygon table (useful for national_forests)
The edges of the polygon also get treated as linear fetaures allowing these to be rendered seperately. */
*make_boundary = 1;
} else if (strcmp(type, "multipolygon") == 0
&& getItem(&tags, "boundary")) {
/* Treat type=multipolygon exactly like type=boundary if it has a boundary tag. */
*make_boundary = 1;
} else if (strcmp(type, "multipolygon") == 0) {
*make_polygon = 1;
/* Collect a list of polygon-like tags, these are used later to
identify if an inner rings looks like it should be rendered separately */
p = tags.next;
while (p != &tags) {
if (!strcmp(p->key, "area")) {
addItem(&poly_tags, p->key, p->value, 1);
} else {
for (i = 0; i < exportListCount[OSMTYPE_WAY]; i++) {
if (strcmp(exportList[OSMTYPE_WAY][i].name, p->key) == 0) {
if (exportList[OSMTYPE_WAY][i].flags & FLAG_POLYGON) {
addItem(&poly_tags, p->key, p->value, 1);
}
break;
}
}
}
p = p->next;
}
/* Copy the tags from the outer way(s) if the relation is untagged (with
* respect to tags that influence its polygon nature. Tags like name or fixme should be fine*/
if (!listHasData(&poly_tags)) {
first_outerway = 1;
for (i = 0; i < member_count; i++) {
if (member_role[i] && !strcmp(member_role[i], "inner"))
continue;
/* insert all tags of the first outerway to the potential list of copied tags. */
if (first_outerway) {
p = member_tags[i].next;
while (p != &(member_tags[i])) {
addItem(&poly_tags, p->key, p->value, 1);
p = p->next;
}
} else {
/* Check if all of the tags in the list of potential tags are present on this way,
otherwise remove from the list of potential tags. Tags need to be present on
all outer ways to be copied over to the relation */
q = poly_tags.next;
while (q != &poly_tags) {
p = getTag(&(member_tags[i]), q->key);
if ((p != NULL) && (strcmp(q->value, p->value) == 0)) {
q = q->next;
} else {
/* This tag is not present on all member outer ways, so don't copy it over to relation */
qq = q->next;
removeTag(q);
q = qq;
}
}
}
first_outerway = 0;
}
/* Copy the list identified outer way tags over to the relation */
q = poly_tags.next;
while (q != &poly_tags) {
addItem(&tags, q->key, q->value, 1);
q = q->next;
}
/* We need to re-check and only keep polygon tags in the list of polytags */
q = poly_tags.next;
while (q != &poly_tags) {
contains_tag = 0;
for (j = 0; j < exportListCount[OSMTYPE_WAY]; j++) {
if (strcmp(exportList[OSMTYPE_WAY][j].name, q->key) == 0) {
if (exportList[OSMTYPE_WAY][j].flags & FLAG_POLYGON) {
contains_tag = 1;
break;
}
}
}
if (contains_tag == 0) {
qq = q->next;
removeTag(q);
q = qq;
} else {
q = q->next;
}
}
}
resetList(&poly_tags);
} else {
/* Unknown type, just exit */
resetList(&tags);
resetList(&poly_tags);
return 1;
}
if (!listHasData(&tags)) {
resetList(&tags);
resetList(&poly_tags);
return 1;
}
/* If we are creating a multipolygon then we
mark each member so that we can skip them during iterate_ways
but only if the polygon-tags look the same as the outer ring */
if (make_polygon) {
for (i = 0; i < member_count; i++) {
int match = 1;
struct keyval *p = member_tags[i].next;
while (p != &(member_tags[i])) {
const char *v = getItem(&tags, p->key);
if (!v || strcmp(v, p->value)) {
/* z_order and osm_ are automatically generated tags, so ignore them */
if ((strcmp(p->key, "z_order") != 0) && (strcmp(p->key, "osm_user") != 0) &&
(strcmp(p->key, "osm_version") != 0) && (strcmp(p->key, "osm_uid") != 0) &&
(strcmp(p->key, "osm_changeset")) && (strcmp(p->key, "osm_timestamp") != 0)) {
match = 0;
break;
}
}
p = p->next;
}
if (match) {
member_superseeded[i] = 1;
} else {
member_superseeded[i] = 0;
}
}
}
resetList(rel_tags);
cloneList(rel_tags, &tags);
resetList(&tags);
add_z_order(rel_tags, roads);
return 0;
}
static unsigned int tagtransform_c_filter_rel_member_tags(
struct keyval *rel_tags, int member_count,
struct keyval *member_tags, const char **member_role,
int * member_superseeded, int * make_boundary, int * make_polygon, int * roads) {
char *type;
struct keyval tags, *p, poly_tags;
int i;
/* Get the type, if there's no type we don't care */
type = getItem(rel_tags, "type");
if (!type)
return 1;
initList(&tags);
initList(&poly_tags);
/* Clone tags from relation */
p = rel_tags->next;
while (p != rel_tags) {
/* For routes, we convert name to route_name */
if ((strcmp(type, "route") == 0) && (strcmp(p->key, "name") == 0))
addItem(&tags, "route_name", p->value, 1);
else if (strcmp(p->key, "type")) /* drop type= */
addItem(&tags, p->key, p->value, 1);
p = p->next;
}
if (strcmp(type, "route") == 0) {
const char *state = getItem(rel_tags, "state");
const char *netw = getItem(rel_tags, "network");
int networknr = -1;
if (state == NULL ) {
state = "";
}
if (netw != NULL ) {
if (strcmp(netw, "lcn") == 0) {
networknr = 10;
if (strcmp(state, "alternate") == 0) {
addItem(&tags, "lcn", "alternate", 1);
} else if (strcmp(state, "connection") == 0) {
addItem(&tags, "lcn", "connection", 1);
} else {
addItem(&tags, "lcn", "yes", 1);
}
} else if (strcmp(netw, "rcn") == 0) {
networknr = 11;
if (strcmp(state, "alternate") == 0) {
addItem(&tags, "rcn", "alternate", 1);
} else if (strcmp(state, "connection") == 0) {
addItem(&tags, "rcn", "connection", 1);
} else {
addItem(&tags, "rcn", "yes", 1);
}
} else if (strcmp(netw, "ncn") == 0) {
networknr = 12;
if (strcmp(state, "alternate") == 0) {
addItem(&tags, "ncn", "alternate", 1);
} else if (strcmp(state, "connection") == 0) {
addItem(&tags, "ncn", "connection", 1);
} else {
addItem(&tags, "ncn", "yes", 1);
}
} else if (strcmp(netw, "lwn") == 0) {
networknr = 20;
if (strcmp(state, "alternate") == 0) {
addItem(&tags, "lwn", "alternate", 1);
} else if (strcmp(state, "connection") == 0) {
addItem(&tags, "lwn", "connection", 1);
} else {
addItem(&tags, "lwn", "yes", 1);
}
} else if (strcmp(netw, "rwn") == 0) {
networknr = 21;
if (strcmp(state, "alternate") == 0) {
addItem(&tags, "rwn", "alternate", 1);
} else if (strcmp(state, "connection") == 0) {
addItem(&tags, "rwn", "connection", 1);
} else {
addItem(&tags, "rwn", "yes", 1);
}
} else if (strcmp(netw, "nwn") == 0) {
networknr = 22;
if (strcmp(state, "alternate") == 0) {
addItem(&tags, "nwn", "alternate", 1);
} else if (strcmp(state, "connection") == 0) {
addItem(&tags, "nwn", "connection", 1);
} else {
addItem(&tags, "nwn", "yes", 1);
}
}
}
if (getItem(rel_tags, "preferred_color") != NULL ) {
const char *a = getItem(rel_tags, "preferred_color");
if (strcmp(a, "0") == 0 || strcmp(a, "1") == 0
|| strcmp(a, "2") == 0 || strcmp(a, "3") == 0
|| strcmp(a, "4") == 0) {
addItem(&tags, "route_pref_color", a, 1);
} else {
addItem(&tags, "route_pref_color", "0", 1);
}
} else {
addItem(&tags, "route_pref_color", "0", 1);
}
if (getItem(rel_tags, "ref") != NULL ) {
if (networknr == 10) {
addItem(&tags, "lcn_ref", getItem(rel_tags, "ref"), 1);
} else if (networknr == 11) {
addItem(&tags, "rcn_ref", getItem(rel_tags, "ref"), 1);
} else if (networknr == 12) {
addItem(&tags, "ncn_ref", getItem(rel_tags, "ref"), 1);
} else if (networknr == 20) {
addItem(&tags, "lwn_ref", getItem(rel_tags, "ref"), 1);
} else if (networknr == 21) {
addItem(&tags, "rwn_ref", getItem(rel_tags, "ref"), 1);
} else if (networknr == 22) {
addItem(&tags, "nwn_ref", getItem(rel_tags, "ref"), 1);
}
}
} else if (strcmp(type, "boundary") == 0) {
/* Boundaries will get converted into multiple geometries:
- Linear features will end up in the line and roads tables (useful for admin boundaries)
- Polygon features also go into the polygon table (useful for national_forests)
The edges of the polygon also get treated as linear fetaures allowing these to be rendered seperately. */
*make_boundary = 1;
} else if (strcmp(type, "multipolygon") == 0
&& getItem(&tags, "boundary")) {
/* Treat type=multipolygon exactly like type=boundary if it has a boundary tag. */
*make_boundary = 1;
} else if (strcmp(type, "multipolygon") == 0) {
*make_polygon = 1;
/* Copy the tags from the outer way(s) if the relation is untagged */
/* or if there is just a name tag, people seem to like naming relations */
if (!listHasData(&tags)
|| ((countList(&tags) == 1) && getItem(&tags, "name"))) {
for (i = 0; i < member_count; i++) {
if (member_role[i] && !strcmp(member_role[i], "inner"))
continue;
p = member_tags[i].next;
while (p != &(member_tags[i])) {
addItem(&tags, p->key, p->value, 1);
p = p->next;
}
}
}
/* Collect a list of polygon-like tags, these are used later to
identify if an inner rings looks like it should be rendered separately */
p = tags.next;
while (p != &tags) {
if (!strcmp(p->key, "area")) {
addItem(&poly_tags, p->key, p->value, 1);
} else {
for (i = 0; i < exportListCount[OSMTYPE_WAY]; i++) {
if (strcmp(exportList[OSMTYPE_WAY][i].name, p->key) == 0) {
if (exportList[OSMTYPE_WAY][i].flags & FLAG_POLYGON) {
addItem(&poly_tags, p->key, p->value, 1);
}
break;
}
}
}
p = p->next;
}
} else {
/* Unknown type, just exit */
resetList(&tags);
resetList(&poly_tags);
return 1;
}
/* If we are creating a multipolygon then we
mark each member so that we can skip them during iterate_ways
but only if the polygon-tags look the same as the outer ring */
if (make_polygon) {
for (i = 0; i < member_count; i++) {
int match = 0;
struct keyval *p = poly_tags.next;
while (p != &poly_tags) {
const char *v = getItem(&(member_tags[i]), p->key);
if (!v || strcmp(v, p->value)) {
match = 0;
break;
}
match = 1;
p = p->next;
}
if (match) {
member_superseeded[i] = 1;
} else {
member_superseeded[i] = 0;
}
}
}
resetList(rel_tags);
cloneList(rel_tags, &tags);
resetList(&tags);
add_z_order(rel_tags, roads);
return 0;
}
