navit/maptool/osm.c

/**
 * ZANavi, Zoff Android Navigation system.
 * Copyright (C) 2011-2013 Zoff <zoff@zoff.cc>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

/**
 * Navit, a modular navigation system.
 * Copyright (C) 2005-2011 Navit Team
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

#include "maptool.h"
#include "linguistics.h"

#ifdef MAPTOOL_USE_SQL
// sqlite 3
//#include "sqlite3.h"
// sqlite 3
#else
#ifndef SQL_DUMMY_
#define SQL_DUMMY_ 1
int sqlite3_reset(void* v)
{
        return 0;
}
int sqlite3_step(void* v)
{
        return 0;
}
int sqlite3_exec(void* v1, void* v2, void* v3, void* v4, void* v5)
{
        return 0;
}
int sqlite3_bind_int64(void* v, int i, long l)
{
        return 0;
}
int sqlite3_bind_int(void* v, int i, int i2)
{
        return 0;
}
int sqlite3_bind_double(void* v, int i, double d)
{
        return 0;
}
long sqlite3_column_int64(void* v, int i)
{
        return 0;
}
double sqlite3_column_double(void* v, int i)
{
        return 0;
}
int sqlite3_column_int(void* v, int i)
{
        return 0;
}
int sqlite3_bind_text(void* v, int i, char* c, int i2, int i3)
{
        return 0;
}
#endif

#endif

#ifdef MAPTOOL_USE_STRINDEX_COMPRESSION

// compression
#define MINIZ_NO_ZLIB_COMPATIBLE_NAMES

#define MINIZ_NO_STDIO
#define MINIZ_NO_ARCHIVE_APIS
#define MINIZ_NO_TIME
#define MINIZ_NO_ZLIB_APIS
#define MINIZ_NO_MALLOC

#define MINIZ_HEADER_FILE_ONLY
#include "miniz.c"
// compression

#endif

#include <sys/stat.h>
#include <unistd.h>
#include <time.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include "debug.h"
#include "linguistics.h"
#include "country.h"
#include "file.h"

/* triangulate */
/*
 #ifdef SINGLE
 #define REAL float
 #else // not SINGLE
 #define REAL double
 #endif // not SINGLE
 #include "poly_to_tri002/triangle.h"
 */

#include <signal.h>

#ifdef MAPTOOL_TRIANGULATE

#include "p2t/poly2tri.h"
#include "refine/refine.h"
#define MAX_HOLES_PER_POLY 50

#endif

/* triangulate */

#define _FILE_OFFSET_BITS  64
#define _LARGEFILE_SOURCE
#define _LARGEFILE64_SOURCE


#include "osm_countrytable.h"


// function def --
static long long osm_process_street_by_manual_country_borders(GList *bl_manual, struct coord *c);
static int osm_check_all_inner_polys_of_country_id(int country_id, struct coord *c);
// function def --


extern int doway2poi;

static int in_way, in_node, in_relation;
static osmid nodeid, wayid;
osmid current_id;

static GHashTable *attr_hash, *country_table_hash;

void add_boundary_to_db(long long current_id, int admin_level, struct item_bin *item_bin_3, struct relation_member *memb);
void add_waynode_to_db(osmid ref, int c_count);

static char *attr_present;
static int attr_present_count;

static struct item_bin item;

int maxspeed_attr_value;

char debug_attr_buffer[BUFFER_SIZE];

int flags[4];

int flags_attr_value;

struct attr_bin osmid_attr;
osmid osmid_attr_value;

char is_in_buffer[BUFFER_SIZE];

char attr_strings_buffer[BUFFER_SIZE * 16];
int attr_strings_buffer_len;
int alt_name_found = 0;
int real_alt_name_found = 0;

struct coord coord_buffer[65536];
struct coord coord_buffer_3[65536];

struct attr_mapping
{
        enum item_type type;
        int attr_present_idx_count;
        int attr_present_idx[0];
};

static void nodes_ref_item_bin(struct item_bin *ib, int local_thread_num, osmid this_way_id);

static struct attr_mapping **attr_mapping_node;
static int attr_mapping_node_count;
static struct attr_mapping **attr_mapping_way;
static int attr_mapping_way_count;
static struct attr_mapping **attr_mapping_way2poi;
static int attr_mapping_way2poi_count;

static char *attr_present;
static int attr_present_count;

static long long seekpos1;

enum attr_strings
{
        attr_string_phone, attr_string_fax, attr_string_email, attr_string_url, attr_string_street_name, attr_string_street_name_systematic, attr_string_house_number, attr_string_label, attr_string_label_alt, attr_string_label_real_alt, attr_string_postal,
    attr_string_population, attr_string_county_name, attr_string_colour_, attr_string_capacity,
        attr_string_street_name_systematic_nat,
        attr_string_street_name_systematic_int,
        attr_string_ref,
        attr_string_exit_to,
        attr_string_street_destination,
        attr_string_street_lanes,
        // ----------
        attr_string_street_lanes_forward,
        attr_string_street_turn_lanes,
        attr_string_street_destination_lanes,
        // ----- last ----
        attr_string_last,
};

char *attr_strings[attr_string_last];

char *osm_types[] = { "unknown", "node", "way", "relation" };

double save_node_lat;
double save_node_lon;

// #define REF_X 1073741834 --> maptool.h // lat
// #define REF_Y 240000000  --> maptool.h // lon
#define IS_REF(c) (check_decode_nodeid(c)) // --> new method
// #define IS_REF(c) ((c).x >= (1 << 30)) // --> old method again

// #define SET_REF(c,ref) (encode_nodeid(c, ref))
// #define REF(c) (decode_nodeid(c))

void encode_nodeid(struct coord *c, osmid ref)
{
        //fprintf(stderr, "ref=%lld bb=%lld 1=%lld\n", ref, (1 << 31), ((1 << 31) >> 31));
        //fprintf(stderr, "11=%lld 22=%lld\n", (ref >> 31), (1 << 30));
        //fprintf(stderr, "encode_nodeid:ref=%lld\n", ref);

        if (ref > 0xffffffff)
        {
                c->x = (1 << 30) | (ref >> 32 );
                c->y = ref & (0xffffffff);
        }
        else
        {
                c->x = 1 << 30;
                c->y = ref;
        }

#if 0
// lat = y
int x = transform_from_geo_lat(-90);
fprintf(stderr, "y=%d %x\n", x, x);
x = transform_from_geo_lat(0);
fprintf(stderr, "y=%d %x\n", x, x);
x = transform_from_geo_lat(90);
fprintf(stderr, "y=%d %x\n", x, x);

// lon = x
int y = transform_from_geo_lon(-180);
fprintf(stderr, "x=%d %x\n", y, y);
y = transform_from_geo_lon(0);
fprintf(stderr, "x=%d %x\n", y, y);
y = transform_from_geo_lon(180);
fprintf(stderr, "x=%d %x\n", y, y);
#endif

        //fprintf(stderr, "encode_nodeid:cx=%x cy=%x 30th bit=%x ref=%x\n", c->x, c->y, (1 << 30), (ref >> 32) );
}

int check_decode_nodeid(struct coord c)
{
        // fprintf(stderr, "check_decode_nodeid:is ref=%d\n", ((c.x & (1 << 30)) == (1 << 30)) );
        // fprintf(stderr, "check_decode_nodeid:c.x=%d c.y=%d\n", c.x, c.y);

        // if ((c.x == REF_X) && (c.y == REF_Y))
        if (c.x == REF_X)
        {
                // this number is not a real coordiante, its just a dummy to know we need to lookup
                return 1;
        }
        else
        {
                // this is is real GPS coordinate
                // fprintf(stderr, "check_decode_nodeid:c.x=%d c.y=%d\n", c.x, c.y);
                return 0;
        }

        //return ((c.x & (1 << 30)) == (1 << 30));
}

osmid decode_nodeid(struct coord c)
{
        osmid ret;

        //fprintf(stderr, "decode_nodeid:x=%x y=%x val=%x\n", c.x, c.y, ((long long)(c.x ^ 0x40000000)*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2));
        if ( (c.x & (1 << 30)) == (1 << 30) )
        {
                ret = c.y;
                //fprintf(stderr, "decode_nodeid:1=%x\n", ret);
                ret = ret | ((long long)(c.x ^ 0x40000000)*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2);
        }
        else
        {
                ret = (osmid)c.y;
        }
        //fprintf(stderr, "decode_nodeid:ret=%lld\n", ret);

        return ret;
}


// first char - item type
//   =w - ways
//   =? - used both for nodes and ways
//   otherwise - nodes


// for coastline-only map
static char *attrmap_cl = { "n  *=*                     point_unkn\n"
        "w      *=*                     street_unkn\n"
        "w      natural=coastline       water_line\n" };

// for border-only map
static char *attrmap_bo = { "n  *=*                     point_unkn\n"
        "w      *=*                     street_unkn\n"
        "w      boundary=administrative,admin_level=2   border_country\n"
        "w      boundary=territorial,admin_level=2      border_country\n"
        "w      boundary=maritime,admin_level=2         border_country\n"
        "w      administrative=boundary,admin_level=2   border_country\n"
        "w      boundary=administrative,maritime=yes,admin_level=2      border_country\n"
        "w      boundary=administrative,maritime=yes,admin_level=4      border_country\n"
        "w      boundary=administrative,border_type=state,admin_level=4 border_country\n" };

// ==========================
// for USA
// ==========================
// admin_level = 4
// border_type = state
// boundary = administrative
// ==========================


// for normal map
static char *attrmap_normal = { "n      *=*                     point_unkn\n"
////    "n      Annehmlichkeit=Hochsitz poi_hunting_stand\n"
        "n      addr:housenumber=*      house_number\n"
        "n      aeroway=aerodrome       poi_airport\n"
        "n      aeroway=airport         poi_airport\n"
        "n      aeroway=helipad         poi_heliport\n"
        "n      aeroway=terminal        poi_airport\n"
        "n      amenity=atm             poi_atm\n"
        "n      amenity=bank            poi_bank\n"
        "n      amenity=bar             poi_bar\n"
        //"n    amenity=bench           poi_bench\n"
        "n      amenity=biergarten      poi_biergarten\n"
        "n      amenity=bus_station     poi_bus_station\n"
        "n      amenity=cafe            poi_cafe\n"
        "n      amenity=car_wash        poi_car_wash\n"
        "n      amenity=cinema          poi_cinema\n"
        "n      amenity=college         poi_school_college\n"
        "n      amenity=courthouse      poi_justice\n"
        //"n    amenity=drinking_water  poi_potable_water\n"
        "n      amenity=fast_food       poi_fastfood\n"
        "n      amenity=fire_station    poi_firebrigade\n"
        //"n    amenity=fountain        poi_fountain\n"
        "n      amenity=fuel            poi_fuel\n"
        "n      amenity=grave_yard      poi_cemetery\n"
        "n      amenity=hospital        poi_hospital\n"
        //"n    amenity=hunting_stand   poi_hunting_stand\n"
        "n      amenity=kindergarten    poi_kindergarten\n"
        "n      amenity=library         poi_library\n"
        "n      amenity=nightclub       poi_nightclub\n"
        //"n    amenity=park_bench      poi_bench\n"
        "n      amenity=parking         poi_car_parking\n"
        "n      amenity=bicycle_parking         poi_bicycle_parking\n"
        "n      amenity=bicycle_rental          poi_bicycle_rental\n"
        "n      amenity=pharmacy        poi_pharmacy\n"
        "n      amenity=place_of_worship,religion=christian     poi_church\n"
        "n      amenity=place_of_worship                        poi_worship\n"
        "n      amenity=police          poi_police\n"
        //"n    amenity=post_box        poi_post_box\n"
        "n      amenity=post_office     poi_post_office\n"
        "n      amenity=prison          poi_prison\n"
        //"n    amenity=pub             poi_pub\n"
        "n      amenity=public_building poi_public_office\n"
        //"n    amenity=recycling       poi_recycling\n"
        "n      amenity=restaurant,cuisine=fine_dining          poi_dining\n"
        "n      amenity=restaurant                              poi_restaurant\n"
        "n      amenity=school          poi_school\n"
        //"n    amenity=shelter         poi_shelter\n"
        "n      amenity=taxi            poi_taxi\n"
        //"n    amenity=tec_common      tec_common\n"
        //"n    amenity=telephone       poi_telephone\n"
        "n      amenity=theatre         poi_theater\n"
        "n      amenity=toilets         poi_restroom\n"
        "n      amenity=townhall        poi_townhall\n"
        "n      amenity=university      poi_school_university\n"
        //"n    amenity=vending_machine poi_vending_machine\n"
        "n      barrier=bollard         barrier_bollard\n"
        "n      barrier=cycle_barrier   barrier_cycle\n"
        "n      barrier=lift_gate       barrier_lift_gate\n"
        "n      car=car_rental          poi_car_rent\n"
        "n      highway=bus_station     poi_bus_station\n"
        "n      highway=bus_stop        poi_bus_stop\n"
        "n      highway=mini_roundabout mini_roundabout\n"
        "n      highway=motorway_junction       highway_exit\n"
        "n      highway=stop            traffic_sign_stop\n"
        "n      highway=toll_booth      poi_toll_booth\n"
        "n      highway=crossing,crossing=traffic_signals       traffic_crossing_signal\n"
        "n      highway=crossing,crossing=uncontrolled  traffic_crossing_uncontrolled\n"
        "n      highway=crossing        traffic_crossing_uncontrolled\n"
        "n      highway=traffic_signals traffic_signals\n"
        "n      highway=turning_circle  turning_circle\n"
        //"n    historic=boundary_stone poi_boundary_stone\n"
        "n      historic=castle         poi_castle\n"
        "n      historic=memorial       poi_memorial\n"
        "n      historic=monument       poi_monument\n"
        "n      historic=ruins          poi_ruins\n"
        ////    "n      historic=*              poi_ruins\n"
        "n      landuse=cemetery        poi_cemetery\n"
        //"n    leisure=fishing         poi_fish\n"
        "n      leisure=golf_course     poi_golf\n"
        "n      leisure=marina          poi_marine\n"
        //"n    leisure=playground      poi_playground\n"
        //"n    leisure=slipway         poi_boat_ramp\n"
        "n      leisure=sports_centre   poi_sport\n"
        "n      leisure=stadium         poi_stadium\n"
        //"n    man_made=tower          poi_tower\n"
        "n      military=airfield       poi_military\n"
        "n      military=barracks       poi_military\n"
        "n      military=bunker         poi_military\n"
        "n      military=danger_area    poi_danger_area\n"
        "n      military=range          poi_military\n"
        "n      natural=bay             poi_bay\n"
        "n      natural=peak,ele=*              poi_peak\n" // show only major peaks with elevation
        //"n    natural=tree            poi_tree\n"
        "n      place=city              town_label_2e5\n"
        "n      place=town              town_label_2e4\n"
        "n      place=village           town_label_2e3\n"
        "n      place=hamlet            town_label_2e2\n"
        "n      place=locality          town_label_2e0\n"
        "n      place=suburb            district_label\n"
        "n      place=quarter           district_label_1e2\n"
        "n      place=neighbourhood             district_label_1e1\n"
        //"n    power=tower             power_tower\n"
        //"n    power=sub_station       power_substation\n"
        "n      railway=halt            poi_rail_halt\n"
        "n      railway=level_crossing  poi_level_crossing\n"
        "n      railway=station         poi_rail_station\n"
        "n      railway=tram_stop       poi_rail_tram_stop\n"
        "n      shop=baker              poi_shop_baker\n"
        "n      shop=bakery             poi_shop_baker\n"
        "n      shop=beverages          poi_shop_beverages\n"
        "n      shop=bicycle            poi_shop_bicycle\n"
        "n      shop=butcher            poi_shop_butcher\n"
        "n      shop=car                poi_car_dealer_parts\n"
        "n      shop=car_repair         poi_repair_service\n"
        //"n    shop=clothes            poi_shop_apparel\n"
        //"n    shop=convenience        poi_shop_grocery\n"
        //"n    shop=drogist            poi_shop_drugstore\n"
        //"n    shop=florist            poi_shop_florist\n"
        //"n    shop=fruit              poi_shop_fruit\n"
        //"n    shop=furniture          poi_shop_furniture\n"
        //"n    shop=garden_centre      poi_shop_handg\n"
        //"n    shop=hardware           poi_shop_handg\n"
        "n      shop=hairdresser        poi_hairdresser\n"
        //"n    shop=kiosk              poi_shop_kiosk\n"
        //"n    shop=optician           poi_shop_optician\n"
        //"n    shop=parfum             poi_shop_parfum\n"
        //"n    shop=photo              poi_shop_photo\n"
        "n      shop=shoes              poi_shop_shoes\n"
        "n      shop=supermarket        poi_shopping\n"
        //"n    sport=10pin             poi_bowling\n"
        //"n    sport=baseball          poi_baseball\n"
        //"n    sport=basketball        poi_basketball\n"
        //"n    sport=climbing          poi_climbing\n"
        "n      sport=golf              poi_golf\n"
        //"n    sport=motor_sports      poi_motor_sport\n"
        //"n    sport=skiing            poi_skiing\n"
        "n      sport=soccer            poi_soccer\n"
        "n      sport=stadium           poi_stadium\n"
        "n      sport=swimming          poi_swimming\n"
        "n      sport=tennis            poi_tennis\n"
        "n      tourism=attraction      poi_attraction\n"
        "n      tourism=camp_site       poi_camp_rv\n"
        "n      tourism=caravan_site    poi_camp_rv\n"
        "n      tourism=guest_house     poi_guesthouse\n"
        "n      tourism=hostel          poi_hostel\n"
        "n      tourism=hotel           poi_hotel\n"
        "n      tourism=information     poi_information\n"
        "n      tourism=motel           poi_motel\n"
        "n      tourism=museum          poi_museum_history\n"
        //"n    tourism=picnic_site     poi_picnic\n"
        "n      tourism=theme_park      poi_resort\n"
        "n      tourism=viewpoint       poi_viewpoint\n"
        "n      tourism=zoo             poi_zoo\n"
        "n      traffic_sign=city_limit traffic_sign_city_limit\n"
        "n      highway=speed_camera    tec_common\n"
        "w      *=*                     street_unkn\n"
        "w      addr:interpolation=even house_number_interpolation_even\n"
        "w      addr:interpolation=odd  house_number_interpolation_odd\n"
        "w      addr:interpolation=all  house_number_interpolation_all\n"
        "w      addr:interpolation=alphabetic   house_number_interpolation_alphabetic\n"
        //"w    aerialway=cable_car     lift_cable_car\n"
        //"w    aerialway=chair_lift    lift_chair\n"
        //"w    aerialway=drag_lift     lift_drag\n"
        "w      aeroway=aerodrome       poly_airport\n"
        "w      aeroway=apron           poly_apron\n"
        "w      aeroway=runway          aeroway_runway\n"
        "w      aeroway=taxiway         aeroway_taxiway\n"
        "w      aeroway=terminal        poly_terminal\n"
        "w      amenity=college         poly_college\n"
        //"w    amenity=grave_yard      poly_cemetery\n"
        "w      amenity=parking         poly_car_parking\n"
        "w      amenity=place_of_worship        poly_building\n"
        "w      amenity=university      poly_university\n"
        // "w   boundary=administrative,admin_level=2   border_country\n" --> in border map
        //"w    boundary=civil          border_civil\n"
        "w      boundary=national_park  border_national_park\n"
        "w      boundary=political      border_political\n"
        "w      building=*              poly_building\n"
        "w      contour_ext=elevation_major     height_line_1\n"
        "w      contour_ext=elevation_medium    height_line_2\n"
        "w      contour_ext=elevation_minor     height_line_3\n"
        "w      highway=bridleway       bridleway\n"
        "w      highway=bus_guideway    bus_guideway\n"
        "w      highway=construction    street_construction\n"
        "w      highway=cyclepath       cycleway\n"
        "w      highway=cycleway        cycleway\n"
        "w      highway=footway         footway\n"
        "w      highway=footway,piste:type=nordic       footway_and_piste_nordic\n"
        "w      highway=living_street   living_street\n"
        "w      highway=minor           street_1_land\n"
        "w      highway=parking_lane    street_parking_lane\n"
        "w      highway=path                            path\n"
        "w      highway=path,bicycle=designated         cycleway\n"
        "w      highway=path,bicycle=official           cycleway\n"
        "w      highway=path,foot=designated            footway\n"
        "w      highway=path,foot=official              footway\n"
        "w      highway=path,horse=designated           bridleway\n"
        "w      highway=path,horse=official             bridleway\n"
        //"w    highway=path,sac_scale=alpine_hiking                    hiking_alpine\n"
        //"w    highway=path,sac_scale=demanding_alpine_hiking          hiking_alpine_demanding\n"
        //"w    highway=path,sac_scale=demanding_mountain_hiking        hiking_mountain_demanding\n"
        //"w    highway=path,sac_scale=difficult_alpine_hiking          hiking_alpine_difficult\n"
        //"w    highway=path,sac_scale=hiking                           hiking\n"
        //"w    highway=path,sac_scale=mountain_hiking                  hiking_mountain\n"
        "w      highway=pedestrian                      street_pedestrian\n"
        "w      highway=pedestrian,area=1               poly_pedestrian\n"
        "w      highway=plaza                           poly_plaza\n"
        "w      highway=motorway                        highway_land\n"
        "w      highway=motorway,rural=0                highway_city\n"
        "w      highway=motorway_link                   ramp_highway_land\n"
        "w      highway=trunk                           street_n_lanes\n"
        "w      highway=trunk,name=*,rural=1            street_4_land\n"
        "w      highway=trunk,name=*                    street_n_lanes\n"
        "w      highway=trunk,rural=0                   street_n_lanes\n"
        "w      highway=trunk_link                      ramp_street_4_city\n"
        "w      highway=primary                         street_4_land\n"
        "w      highway=primary,name=*,rural=1          street_4_land\n"
        "w      highway=primary,name=*                  street_4_city\n"
        "w      highway=primary,rural=0                 street_4_city\n"
        "w      highway=primary_link                    ramp_street_4_city\n"
        "w      highway=secondary                       street_3_land\n"
        "w      highway=secondary,name=*,rural=1        street_3_land\n"
        "w      highway=secondary,name=*                street_3_city\n"
        "w      highway=secondary,rural=0               street_3_city\n"
        "w      highway=secondary,area=1                poly_street_3\n"
        "w      highway=secondary_link                  ramp_street_3_city\n"
        "w      highway=tertiary                        street_2_land\n"
        "w      highway=tertiary,name=*,rural=1         street_2_land\n"
        "w      highway=tertiary,name=*                 street_2_city\n"
        "w      highway=tertiary,rural=0                street_2_city\n"
        "w      highway=tertiary,area=1                 poly_street_2\n"
        "w      highway=tertiary_link                   ramp_street_2_city\n"
        "w      highway=residential                     street_1_city\n"
        "w      highway=residential,area=1              poly_street_1\n"
        "w      highway=unclassified                    street_1_city\n"
        "w      highway=unclassified,area=1             poly_street_1\n"
        "w      highway=road                            street_1_city\n"
        "w      highway=service                         street_service\n"
        "w      highway=service,area=1                  poly_service\n"
        "w      highway=service,service=parking_aisle   street_parking_lane\n"
        "w      highway=track                           track_gravelled\n"
        "w      highway=track,surface=grass             track_grass\n"
        "w      highway=track,surface=gravel            track_gravelled\n"
        "w      highway=track,surface=ground            track_ground\n"
        "w      highway=track,surface=paved             track_paved\n"
        "w      highway=track,surface=unpaved           track_unpaved\n"
        "w      highway=track,tracktype=grade1          track_paved\n"
        "w      highway=track,tracktype=grade2          track_gravelled\n"
        "w      highway=track,tracktype=grade3          track_unpaved\n"
        "w      highway=track,tracktype=grade4          track_ground\n"
        "w      highway=track,tracktype=grade5          track_grass\n"
        "w      highway=track,surface=paved,tracktype=grade1            track_paved\n"
        "w      highway=track,surface=gravel,tracktype=grade2           track_gravelled\n"
        "w      highway=track,surface=unpaved,tracktype=grade3          track_unpaved\n"
        "w      highway=track,surface=ground,tracktype=grade4           track_ground\n"
        "w      highway=track,surface=grass,tracktype=grade5            track_grass\n"
        "w      highway=unsurfaced                      track_gravelled\n"
        "w      highway=steps                           steps\n"
        "w      historic=archaeological_site    poly_archaeological_site\n"
        "w      historic=battlefield    poly_battlefield\n"
        "w      historic=ruins          poly_ruins\n"
        "w      historic=town gate      poly_building\n"
        //"w    landuse=allotments      poly_allotments\n"
        //"w    landuse=basin           poly_basin\n"
        //"w    landuse=brownfield      poly_brownfield\n"
        "w      landuse=cemetery        poly_cemetery\n"
        //"w    landuse=commercial      poly_commercial\n"
        //"w    landuse=construction    poly_construction\n"
        //"w    landuse=farm            poly_farm\n"
        //"w    landuse=farmland        poly_farm\n"
        //"w    landuse=farmyard        poly_town\n"
        "w      landuse=forest          poly_wood\n"
        "w      landuse=greenfield      poly_greenfield\n"
        //"w    landuse=industrial      poly_industry\n"
        //"w    landuse=landfill        poly_landfill\n"
        "w      landuse=military        poly_military\n"
        "w      landuse=plaza           poly_plaza\n"
        //"w    landuse=quarry          poly_quarry\n"
        "w      landuse=railway         poly_railway\n"
        //"w    landuse=recreation_ground               poly_recreation_ground\n"
        "w      landuse=reservoir       poly_reservoir\n"
        //"w    landuse=residential     poly_town\n"
        //"w    landuse=residential,area=1      poly_town\n"
        //"w    landuse=retail          poly_retail\n"
        //"w    landuse=village_green   poly_village_green\n"
        //"w    landuse=vineyard        poly_farm\n"
        //"w    leisure=common          poly_common\n"
        //"w    leisure=fishing         poly_fishing\n"
        //"w    leisure=garden          poly_garden\n"
        //"w    leisure=golf_course     poly_golf_course\n"
        //"w    leisure=marina          poly_marina\n"
        //"w    leisure=nature_reserve  poly_nature_reserve\n"
        "w      leisure=park            poly_park\n"
        //"w    leisure=pitch           poly_sports_pitch\n"
        "w      leisure=playground      poly_playground\n"
        //"w    leisure=sports_centre   poly_sport\n"
        "w      leisure=stadium         poly_sports_stadium\n"
        //"w    leisure=track           poly_sports_track\n"
        "w      leisure=water_park      poly_water_park\n"
        "w      military=airfield       poly_airfield\n"
        "w      military=barracks       poly_barracks\n"
        "w      military=danger_area    poly_danger_area\n"
        "w      military=naval_base     poly_naval_base\n"
        "w      military=range          poly_range\n"
        "w      natural=beach           poly_beach\n"
        // "w   natural=coastline       water_line\n" --> in coastline map
        "w      natural=fell            poly_fell\n"
        "w      natural=glacier         poly_glacier\n"
        "w      natural=heath           poly_heath\n"
        "w      natural=land            poly_land\n"
        "w      natural=marsh           poly_marsh\n"
        "w      natural=mud             poly_mud\n"
        "w      natural=scree           poly_scree\n"
        "w      natural=scrub           poly_scrub\n"
        "w      natural=water           poly_water\n"
        "w      natural=wood            poly_wood\n"
        //"w    piste:type=downhill,piste:difficulty=advanced           piste_downhill_advanced\n"
        //"w    piste:type=downhill,piste:difficulty=easy               piste_downhill_easy\n"
        //"w    piste:type=downhill,piste:difficulty=expert             piste_downhill_expert\n"
        //"w    piste:type=downhill,piste:difficulty=freeride           piste_downhill_freeride\n"
        //"w    piste:type=downhill,piste:difficulty=intermediate       piste_downhill_intermediate\n"
        //"w    piste:type=downhill,piste:difficulty=novice             piste_downhill_novice\n"
        //"w    piste:type=nordic       piste_nordic\n"
        "w      place=suburb            poly_place1\n"
        "w      place=hamlet            poly_place2\n"
        "w      place=village           poly_place3\n"
        "w      place=municipality      poly_place4\n"
        "w      place=town              poly_place5\n"
        "w      place=city              poly_place6\n"
        //"w    power=line              powerline\n"
        //"w    railway=abandoned       rail_abandoned\n"
        //"w    railway=disused         rail_disused\n"
        "w      railway=light_rail      rail_light\n"
        "w      railway=monorail        rail_mono\n"
        "w      railway=narrow_gauge    rail_narrow_gauge\n"
        //"w    railway=preserved       rail_preserved\n"
        "w      railway=rail            rail\n"
        "w      railway=subway          rail_subway\n"
        "w      railway=tram            rail_tram\n"
        "w      route=ferry             ferry\n"
        //"w    route=ski               piste_nordic\n"
        //"w    sport=*                 poly_sport\n"
        "w      tourism=artwork         poly_artwork\n"
        "w      tourism=attraction      poly_attraction\n"
        "w      tourism=camp_site       poly_camp_site\n"
        "w      tourism=caravan_site    poly_caravan_site\n"
        "w      tourism=picnic_site     poly_picnic_site\n"
        "w      tourism=theme_park      poly_theme_park\n"
        "w      tourism=zoo             poly_zoo\n"
        "w      waterway=canal          water_canal\n"
        "w      waterway=drain          water_drain\n"
        "w      waterway=river          water_river\n"
        "w      waterway=riverbank      poly_water\n"
        "w      waterway=stream         water_stream\n"
        "w      barrier=ditch   ditch\n"
        "w      barrier=hedge   hedge\n"
        "w      barrier=fence   fence\n"
        "w      barrier=wall    wall\n"
        "w      barrier=retaining_wall  retaining_wall\n"
        "w      barrier=city_wall       city_wall\n" };

static void build_attrmap_line(char *line)
{
        char *t = NULL, *kvl = NULL, *i = NULL, *p, *kv;
        struct attr_mapping *attr_mapping = g_malloc0(sizeof(struct attr_mapping));
        int idx, attr_mapping_count = 0;
        t = line;
        p = strchr(t, '\t');
        if (p)
        {
                while (*p == '\t')
                        *p++ = '\0';
                kvl = p;
                p = strchr(kvl, '\t');
        }
        if (p)
        {
                while (*p == '\t')
                        *p++ = '\0';
                i = p;
        }
        if (t[0] == 'w')
        {
                if (!i)
                        i = "street_unkn";
        }
        else
        {
                if (!i)
                        i = "point_unkn";
        }

        attr_mapping->type = item_from_name(i);

        if (!attr_mapping->type)
        {
                printf("no id found for '%s'\n", i);
        }

        while ((kv = strtok(kvl, ",")))
        {
                kvl = NULL;
                if (!(idx = (int) (long) g_hash_table_lookup(attr_hash, kv)))
                {
                        idx = attr_present_count++;
                        g_hash_table_insert(attr_hash, kv, (gpointer) (long) idx);
                }
                attr_mapping = g_realloc(attr_mapping, sizeof(struct attr_mapping) + (attr_mapping_count + 1) * sizeof(int));
                attr_mapping->attr_present_idx[attr_mapping_count++] = idx;
                attr_mapping->attr_present_idx_count = attr_mapping_count;
        }
        if (t[0] == 'w')
        {
                attr_mapping_way = g_realloc(attr_mapping_way, sizeof(*attr_mapping_way) * (attr_mapping_way_count + 1));
                attr_mapping_way[attr_mapping_way_count++] = attr_mapping;
        }
        if (t[0] == '?' && doway2poi)
        {
                attr_mapping_way2poi = g_realloc(attr_mapping_way2poi, sizeof(*attr_mapping_way2poi) * (attr_mapping_way2poi_count + 1));
                attr_mapping_way2poi[attr_mapping_way2poi_count++] = attr_mapping;
        }
        if (t[0] != 'w')
        {
                attr_mapping_node = g_realloc(attr_mapping_node, sizeof(*attr_mapping_node) * (attr_mapping_node_count + 1));
                attr_mapping_node[attr_mapping_node_count++] = attr_mapping;
        }

}

static void build_attrmap(FILE* rule_file)
{
        attr_hash = g_hash_table_new(g_str_hash, g_str_equal);
        attr_present_count = 1;

        // build attribute map from rule file if given
        if (rule_file)
        {
                char buffer[200], *p;
                while (fgets(buffer, 200, rule_file))
                {
                        p = strchr(buffer, '\n');
                        if (p)
                                *p = 0;
                        build_attrmap_line(g_strdup(buffer));
                }
                fclose(rule_file);
        }
        // use hardcoded default attributes
        else
        {
                char *p, *map;
                if (border_only_map == 1)
                {
                        map = g_strdup(attrmap_bo);
                }
                else if (coastline_only_map == 1)
                {
                        map = g_strdup(attrmap_cl);
                }
                else
                {
                        map = g_strdup(attrmap_normal);
                }

                while (map)
                {
                        p = strchr(map, '\n');
                        if (p)
                                *p++ = '\0';

                        if (strlen(map))
                                build_attrmap_line(map);

                        map = p;
                }
        }

        attr_present = g_malloc0(sizeof(*attr_present) * attr_present_count);
}

static void build_countrytable(void)
{
        int i;
        char *names, *str, *tok;
        country_table_hash = g_hash_table_new(g_str_hash, g_str_equal);
        for (i = 0; i < sizeof(country_table) / sizeof(struct country_table); i++)
        {
                names = g_strdup(country_table[i].names);
                str = names;
                while ((tok = strtok(str, ",")))
                {
                        str = NULL;
                        g_hash_table_insert(country_table_hash, tok, (gpointer) & country_table[i]);
                }
        }
}

int string_endswith2(const char* ending, const char* instring)
{
        int l1;
        int l2;

        if (!ending)
        {
                return 0;
        }

        if (!instring)
        {
                return 0;
        }

    l1 = strlen(ending);
    l2 = strlen(instring);

        if (l1 < 1)
        {
                return 0;
        }

    if (l1 > l2)
        {
                return 0;
        }

    int ret = strcmp(ending, instring + (l2 - l1));
        //dbg(0, "ending=%s in=%s ret=%d\n", ending, instring + (l2 - l1), (ret == 0));
        return (ret == 0);
}


void osm_warning(char *type, long long id, int cont, char *fmt, ...)
{
        char str[4096];
        va_list ap;
        va_start(ap, fmt);
        vsnprintf(str, sizeof(str), fmt, ap);
        va_end(ap);
if (verbose_mode) fprintf(stderr,"%shttp://www.openstreetmap.org/browse/%s/"LONGLONG_FMT" %s",cont ? "":"OSM Warning:",type,id,str);
}

void osm_info(char *type, long long id, int cont, char *fmt, ...)
{
        char str[4096];
        va_list ap;
        va_start(ap, fmt);
        vsnprintf(str, sizeof(str), fmt, ap);
        va_end(ap);
if (verbose_mode) fprintf(stderr,"%shttp://www.openstreetmap.org/browse/%s/"LONGLONG_FMT" %s",cont ? "":"OSM Info:",type,id,str);
}

static void attr_strings_clear(void)
{
        alt_name_found = 0;
        real_alt_name_found = 0;
        attr_strings_buffer_len = 0;
        memset(attr_strings, 0, sizeof(attr_strings));
}

static void attr_strings_save(enum attr_strings id, char *str)
{
        attr_strings[id] = attr_strings_buffer + attr_strings_buffer_len;
        strcpy(attr_strings[id], str);
        attr_strings_buffer_len += strlen(str) + 1;
}

long long item_bin_get_nodeid(struct item_bin *ib)
{
        long long *ret = item_bin_get_attr(ib, attr_osm_nodeid, NULL);
        if (ret)
        {
                return *ret;
        }
        return 0;
}

long long item_bin_get_wayid(struct item_bin *ib)
{
        long long *ret = item_bin_get_attr(ib, attr_osm_wayid, NULL);
        if (ret)
        {
                return *ret;
        }
        return 0;
}

long long item_bin_get_relationid(struct item_bin *ib)
{
        long long *ret = item_bin_get_attr(ib, attr_osm_relationid, NULL);
        if (ret)
        {
                return *ret;
        }
        return 0;
}

long long item_bin_get_id(struct item_bin *ib)
{
        long long ret;
        if (ib->type < 0x80000000)
        {
                return item_bin_get_nodeid(ib);
        }
        ret = item_bin_get_wayid(ib);
        if (!ret)
        {
                ret = item_bin_get_relationid(ib);
        }
        return ret;
}

static int node_is_tagged;
static void relation_add_tag(char *k, char *v);
osmid get_waynode_num_have_seekpos(osmid way_id, int coord_num, int local_thread_num, off_t seek_pos);


static int access_value(char *v)
{
        if (!strcmp(v, "1"))
                return 1;
        if (!strcmp(v, "yes"))
                return 1;
        if (!strcmp(v, "designated"))
                return 1;
        if (!strcmp(v, "official"))
                return 1;
        if (!strcmp(v, "permissive"))
                return 1;
        if (!strcmp(v, "0"))
                return 2;
        if (!strcmp(v, "no"))
                return 2;
        if (!strcmp(v, "agricultural"))
                return 2;
        if (!strcmp(v, "forestry"))
                return 2;
        if (!strcmp(v, "private"))
                return 2;
        if (!strcmp(v, "delivery"))
                return 2;
        if (!strcmp(v, "destination"))
                return 2;
        return 3;
}

void osm_add_tag(char *k, char *v)
{
        int idx, level = 2;
        char buffer[BUFFER_SIZE * 2 + 2];

        if (in_relation)
        {
                relation_add_tag(k, v);
                return;
        }

        if (!strcmp(k, "ele"))
                level = 9;

        if (!strcmp(k, "time"))
                level = 9;

        if (!strcmp(k, "created_by"))
                level = 9;

        if (!strncmp(k, "tiger:", 6) || !strcmp(k, "AND_nodes"))
                level = 9;

        if (!strcmp(k, "converted_by") || !strcmp(k, "source"))
                level = 8;

        if (!strncmp(k, "osmarender:", 11) || !strncmp(k, "svg:", 4))
                level = 8;

        if (!strcmp(k, "layer"))
                level = 7;

        if (!strcasecmp(v, "true") || !strcasecmp(v, "yes"))
                v = "1";

        if (!strcasecmp(v, "false") || !strcasecmp(v, "no"))
                v = "0";


        if (!strcmp(k, "oneway"))
        {
                if (!strcmp(v, "1"))
                {
                        flags[0] |= NAVIT_AF_ONEWAY | NAVIT_AF_ROUNDABOUT_VALID;
                }

                if (!strcmp(v, "-1"))
                {
                        flags[0] |= NAVIT_AF_ONEWAYREV | NAVIT_AF_ROUNDABOUT_VALID;
                }

                if (!in_way)
                {
                        level = 6;
                }
                else
                {
                        level = 5;
                }
        }

        if (!strcmp(k, "cycleway"))
        {
                if (!strcmp(v, "opposite"))
                {
                        flags[0] |= NAVIT_AF_ONEWAY_BICYCLE_NO;
                }
                if (!strcmp(v, "opposite_lane"))
                {
                        flags[0] |= NAVIT_AF_ONEWAY_BICYCLE_NO;
                }

                if (!in_way)
                {
                        level = 6;
                }
                else
                {
                        level = 5;
                }
        }


        if (!strcmp(k, "bicycle:oneway"))
        {
                if (!strcmp(v, "0"))
                {
                        flags[0] |= NAVIT_AF_ONEWAY_BICYCLE_NO;
                }
                if (!strcmp(v, "1"))
                {
                        flags[0] |= NAVIT_AF_ONEWAY_BICYCLE_YES;
                }

                if (!in_way)
                {
                        level = 6;
                }
                else
                {
                        level = 5;
                }
        }

        if (!strcmp(k, "oneway:bicycle"))
        {
                if (!strcmp(v, "0"))
                {
                        flags[0] |= NAVIT_AF_ONEWAY_BICYCLE_NO;
                }
                if (!strcmp(v, "1"))
                {
                        flags[0] |= NAVIT_AF_ONEWAY_BICYCLE_YES;
                }

                if (!in_way)
                {
                        level = 6;
                }
                else
                {
                        level = 5;
                }
        }


/*
blue: cycleway=lane + oneway=yes
blue: cycleway=lane + oneway=yes + bicycle=yes

xxxx: cycleway=opposite_lane + cycleway:left=lane + oneway=yes
xxxx: bicycle=yes + cycleway:right=lane + oneway=yes
xxxx: cycleway:left=track + cycleway:right=lane + oneway=yes + oneway:bicycle=no
xxxx: cycleway:left=share_busway + cycleway:right=lane + oneway=yes + oneway:bicycle=no

dots: cycleway=track + oneway=yes
dots: cycleway=track

xxxx: cycleway:left=track + oneway=yes
xxxx: cycleway:right=track + oneway=yes

xxxx: cycleway:right=track
xxxx: cycleway:right=track + cycleway:right:oneway=no
*/

        if (!strcmp(k, "cycleway"))
        {
                if (!strcmp(v, "track"))
                {
                        flags[0] |= NAVIT_AF_BICYCLE_TRACK;
                }

                if (!in_way)
                {
                        level = 6;
                }
                else
                {
                        level = 5;
                }
        }


/*
        cycleway=lane
        cycleway:right=lane
        cycleway:left=lane

        cycleway=opposite_lane
        cycleway:left=opposite_lane
        cycleway:right=opposite_lane
*/

        if (!strcmp(k, "cycleway"))
        {
                if (!strcmp(v, "lane"))
                {
                        flags[0] |= NAVIT_AF_BICYCLE_LANE;
                }
                else if (!strcmp(v, "opposite_lane"))
                {
                        flags[0] |= NAVIT_AF_BICYCLE_LANE;
                }

                if (!in_way)
                {
                        level = 6;
                }
                else
                {
                        level = 5;
                }
        }


        if (!strcmp(k, "cycleway:left"))
        {
                if (!strcmp(v, "lane"))
                {
                        flags[0] |= NAVIT_AF_BICYCLE_LANE;
                }
                else if (!strcmp(v, "opposite_lane"))
                {
                        flags[0] |= NAVIT_AF_BICYCLE_LANE;
                }

                if (!in_way)
                {
                        level = 6;
                }
                else
                {
                        level = 5;
                }
        }

        if (!strcmp(k, "cycleway:right"))
        {
                if (!strcmp(v, "lane"))
                {
                        flags[0] |= NAVIT_AF_BICYCLE_LANE;
                }
                else if (!strcmp(v, "opposite_lane"))
                {
                        flags[0] |= NAVIT_AF_BICYCLE_LANE;
                }

                if (!in_way)
                {
                        level = 6;
                }
                else
                {
                        level = 5;
                }
        }


        if (!strcmp(k, "junction"))
        {
                if (!strcmp(v, "roundabout"))
                        flags[0] |= NAVIT_AF_ONEWAY | NAVIT_AF_ROUNDABOUT | NAVIT_AF_ROUNDABOUT_VALID;
        }

        if (!strcmp(k, "maxspeed"))
        {
                if (strstr(v, "mph"))
                {
                        maxspeed_attr_value = (int) floor(atof(v) * 1.609344);
                }
                else
                {
                        maxspeed_attr_value = atoi(v);
                }

                if (maxspeed_attr_value)

                        flags[0] |= NAVIT_AF_SPEED_LIMIT;
                level = 5;
        }
        if (!strcmp(k, "toll"))
        {
                if (!strcmp(v, "1"))
                {
                        flags[0] |= NAVIT_AF_TOLL;
                }
        }
        if (!strcmp(k, "access"))
        {
                flags[access_value(v)] |= NAVIT_AF_DANGEROUS_GOODS | NAVIT_AF_EMERGENCY_VEHICLES | NAVIT_AF_TRANSPORT_TRUCK | NAVIT_AF_DELIVERY_TRUCK | NAVIT_AF_PUBLIC_BUS | NAVIT_AF_TAXI | NAVIT_AF_HIGH_OCCUPANCY_CAR | NAVIT_AF_CAR | NAVIT_AF_MOTORCYCLE | NAVIT_AF_MOPED | NAVIT_AF_HORSE | NAVIT_AF_BIKE | NAVIT_AF_PEDESTRIAN;
                level = 5;
        }
        if (!strcmp(k, "vehicle"))
        {
                flags[access_value(v)] |= NAVIT_AF_DANGEROUS_GOODS | NAVIT_AF_EMERGENCY_VEHICLES | NAVIT_AF_TRANSPORT_TRUCK | NAVIT_AF_DELIVERY_TRUCK | NAVIT_AF_PUBLIC_BUS | NAVIT_AF_TAXI | NAVIT_AF_HIGH_OCCUPANCY_CAR | NAVIT_AF_CAR | NAVIT_AF_MOTORCYCLE | NAVIT_AF_MOPED | NAVIT_AF_BIKE;
                level = 5;
        }
        if (!strcmp(k, "motorvehicle"))
        {
                flags[access_value(v)] |= NAVIT_AF_DANGEROUS_GOODS | NAVIT_AF_EMERGENCY_VEHICLES | NAVIT_AF_TRANSPORT_TRUCK | NAVIT_AF_DELIVERY_TRUCK | NAVIT_AF_PUBLIC_BUS | NAVIT_AF_TAXI | NAVIT_AF_HIGH_OCCUPANCY_CAR | NAVIT_AF_CAR | NAVIT_AF_MOTORCYCLE | NAVIT_AF_MOPED;
                level = 5;
        }
        if (!strcmp(k, "bicycle"))
        {
                flags[access_value(v)] |= NAVIT_AF_BIKE;
                level = 5;
        }
        if (!strcmp(k, "foot"))
        {
                flags[access_value(v)] |= NAVIT_AF_PEDESTRIAN;
                level = 5;
        }
        if (!strcmp(k, "horse"))
        {
                flags[access_value(v)] |= NAVIT_AF_HORSE;
                level = 5;
        }
        if (!strcmp(k, "moped"))
        {
                flags[access_value(v)] |= NAVIT_AF_MOPED;
                level = 5;
        }
        if (!strcmp(k, "motorcycle"))
        {
                flags[access_value(v)] |= NAVIT_AF_MOTORCYCLE;
                level = 5;
        }
        if (!strcmp(k, "motorcar"))
        {
                flags[access_value(v)] |= NAVIT_AF_CAR;
                level = 5;
        }
        if (!strcmp(k, "hov"))
        {
                flags[access_value(v)] |= NAVIT_AF_HIGH_OCCUPANCY_CAR;
                level = 5;
        }
        if (!strcmp(k, "bus"))
        {
                flags[access_value(v)] |= NAVIT_AF_PUBLIC_BUS;
                level = 5;
        }
        if (!strcmp(k, "taxi"))
        {
                flags[access_value(v)] |= NAVIT_AF_TAXI;
                level = 5;
        }
        if (!strcmp(k, "goods"))
        {
                flags[access_value(v)] |= NAVIT_AF_DELIVERY_TRUCK;
                level = 5;
        }
        if (!strcmp(k, "hgv"))
        {
                flags[access_value(v)] |= NAVIT_AF_TRANSPORT_TRUCK;
                level = 5;
        }
        if (!strcmp(k, "emergency"))
        {
                flags[access_value(v)] |= NAVIT_AF_EMERGENCY_VEHICLES;
                level = 5;
        }
        if (!strcmp(k, "hazmat"))
        {
                flags[access_value(v)] |= NAVIT_AF_DANGEROUS_GOODS;
                level = 5;
        }
        if (!strcmp(k, "tunnel") && !strcmp(v, "1"))
        {
                flags[0] |= NAVIT_AF_UNDERGROUND;
        }
        if (!strcmp(k, "bridge") && !strcmp(v, "1"))
        {
                flags[0] |= NAVIT_AF_BRIDGE;
        }

        if (!strcmp(k, "note"))
        {
                level = 5;
        }

        if (!strcmp(k, "name"))
        {
                attr_strings_save(attr_string_label, v);
                level = 5;
        }

        if (!strcmp(k, "capacity"))
        {
                attr_strings_save(attr_string_capacity, v);
                level = 5;
        }

        if (!strcmp(k, "alt_name"))
        {
                // alternative name for some places (is sometimes what people call it in the local area)
                attr_strings_save(attr_string_label_real_alt, v);
                real_alt_name_found = 1;
                level = 5;
        }

        if ((!strcmp(k, "int_name")) && (alt_name_found == 0))
        {
                // only use "int_name" if we dont have "name:en"
                attr_strings_save(attr_string_label_alt, v);
                alt_name_found = 1; // lowest priority
                level = 5;
        }
        if (!strcmp(k, "name:en"))
        {
                attr_strings_save(attr_string_label_alt, v);
                alt_name_found = 2; // highest priority
                level = 5;
        }
        if (!strcmp(k, "addr:email"))
        {
                attr_strings_save(attr_string_email, v);
                level = 5;
        }
        if (!strcmp(k, "addr:housenumber"))
        {
                attr_strings_save(attr_string_house_number, v);
                level = 5;
        }
        if (!strcmp(k, "addr:street"))
        {
                attr_strings_save(attr_string_street_name, v);
                level = 5;
        }
        if (!strcmp(k, "colour"))
        {
                attr_strings_save(attr_string_colour_, v);
                level = 5;
        }
        if (!strcmp(k, "phone"))
        {
                attr_strings_save(attr_string_phone, v);
                level = 5;
        }
        if (!strcmp(k, "fax"))
        {
                attr_strings_save(attr_string_fax, v);
                level = 5;
        }
        if (!strcmp(k, "postal_code"))
        {
                attr_strings_save(attr_string_postal, v);
                level = 5;
        }
        if (!strcmp(k, "openGeoDB:postal_codes") && !attr_strings[attr_string_postal])
        {
                attr_strings_save(attr_string_postal, v);
                level = 5;
        }
        if (!strcmp(k, "population"))
        {
                attr_strings_save(attr_string_population, v);
                level = 5;
        }
        if (!strcmp(k, "openGeoDB:population") && !attr_strings[attr_string_population])
        {
                attr_strings_save(attr_string_population, v);
                level = 5;
        }
        if (!strcmp(k, "ref"))
        {
                if (in_way)
                {
                        attr_strings_save(attr_string_street_name_systematic, v);
                }
                else
                {
                        attr_strings_save(attr_string_ref, v);
                }
                level = 5;
        }
        if (! strcmp(k,"nat_ref"))
        {
                if (in_way)
                {
                        attr_strings_save(attr_string_street_name_systematic_nat, v);
                        //fprintf(stderr, "XYZ123!?:nat_ref=%s\n", v);
                }
                level=5;
        }
        if (! strcmp(k,"int_ref"))
        {
                if (in_way)
                {
                        attr_strings_save(attr_string_street_name_systematic_int, v);
                        //fprintf(stderr, "XYZ123!?:int_ref=%s\n", v);
                }
                level=5;
        }
        if (! strcmp(k,"destination:lanes"))
        {
                if (in_way)
                {
                        attr_strings_save(attr_string_street_destination_lanes, v);
                        //fprintf(stderr, "XYZ123!?:destination:lanes=%s\n", v);
                }
                level=5;
        }
        if (! strcmp(k,"destination"))
        {
                if (in_way)
                {
                        attr_strings_save(attr_string_street_destination, v);
                        //fprintf(stderr, "XYZ123!?:destination=%s\n", v);
                }
                level=5;
        }
        if (! strcmp(k,"exit_to"))
        {
                attr_strings_save(attr_string_exit_to, v);
                //fprintf(stderr, "XYZ123!?:exit_to=%s\n", v);
                level=5;
        }
        if (!strcmp(k, "openGeoDB:is_in"))
        {
                if (!is_in_buffer[0])
                {
                        strcpy(is_in_buffer, v);
                }
                level = 5;
        }
        if (!strcmp(k, "is_in"))
        {
                if (!is_in_buffer[0])
                {
                        strcpy(is_in_buffer, v);
                }
                level = 5;
        }
        if (!strcmp(k, "is_in:country"))
        {
                /**
                 * Sometimes there is no is_in tag, only is_in:country.
                 * I put this here so it can be overwritten by the previous if clause if there IS an is_in tag.
                 */
                strcpy(is_in_buffer, v);
                level = 5;
        }
        if (!strcmp(k, "place_county"))
        {
                /** 
                 * Ireland uses the place_county OSM tag to describe what county a town is in.
                 * This would be equivalent to is_in: Town; Locality; Country
                 * A real world example would be Node: Moycullen (52234625)
                 * The tag is processed as Moycullen; Galway; Ireland
                 * where Galway is the county
                 */
                strcpy(is_in_buffer, "Ireland");
                attr_strings_save(attr_string_county_name, v);
                level = 5;
        }
        if (!strcmp(k, "gnis:ST_alpha"))
        {
                /*      assume a gnis tag means it is part of the USA:
                 http://en.wikipedia.org/wiki/Geographic_Names_Information_System
                 many US towns do not have is_in tags
                 */
                strcpy(is_in_buffer, "USA");
                level = 5;
        }

        if (!strcmp(k, "turn:lanes"))
        {
                if (in_way)
                {
                        attr_strings_save(attr_string_street_turn_lanes, v);
                        //fprintf(stderr, "XYZ123!?:turn:lanes=%s\n", v);
                }
                level = 5;
        }


        if (!strcmp(k, "lanes:forward"))
        {
                if (in_way)
                {
                        attr_strings_save(attr_string_street_lanes_forward, v);
                        //fprintf(stderr, "XYZ123!?:lanes:forward=%s\n", v);
                }
                level = 5;
        }

        if (!strcmp(k, "lanes"))
        {
                if (in_way)
                {
                        attr_strings_save(attr_string_street_lanes, v);
                        //fprintf(stderr, "XYZ123!?:lanes=%s\n", v);
                }
                level = 5;
        }


        if (attr_debug_level >= level)
        {
                int bytes_left = sizeof(debug_attr_buffer) - strlen(debug_attr_buffer) - 1;
                if (bytes_left > 0)
                {
                        snprintf(debug_attr_buffer + strlen(debug_attr_buffer), bytes_left, " %s=%s", k, v);
                        debug_attr_buffer[sizeof(debug_attr_buffer) - 1] = '\0';
                        node_is_tagged = 1;
                }
        }

        if (level < 6)
        {
                node_is_tagged = 1;
        }

        strcpy(buffer, "*=*");
        if ((idx = (int) (long) g_hash_table_lookup(attr_hash, buffer)))
        {
                attr_present[idx] = 1;
        }

        sprintf(buffer, "%s=*", k);
        if ((idx = (int) (long) g_hash_table_lookup(attr_hash, buffer)))
        {
                attr_present[idx] = 2;
        }

        sprintf(buffer, "*=%s", v);
        if ((idx = (int) (long) g_hash_table_lookup(attr_hash, buffer)))
        {
                attr_present[idx] = 2;
        }

        sprintf(buffer, "%s=%s", k, v);
        if ((idx = (int) (long) g_hash_table_lookup(attr_hash, buffer)))
        {
                attr_present[idx] = 4;
        }
}

int coord_count;

static void extend_buffer(struct buffer *b)
{
        b->malloced += b->malloced_step;
        b->base = realloc(b->base, (size_t) b->malloced);

        if (b->base == NULL)
        {
                fprintf(stderr, "realloc of "LONGLONG_FMT" bytes failed\n", (size_t) b->malloced);
                exit(1);
        }

        if (verbose_mode) fprintf(stderr, "extend_buffer: "LONGLONG_FMT" bytes\n", (size_t) b->malloced);
}

osmid nodeid_last;
GHashTable *way_hash, *waytag_hash;
cfuhash_table_t *way_hash_cfu = NULL;

typedef struct dummy_cfuhash_entry
{
        long long key;
        int data;
        struct dummy_cfuhash_entry *next;
} dummy_cfuhash_entry;

static void node_buffer_to_hash(int local_thread_num)
{
        if (verbose_mode)
        {
                fprintf(stderr, "node_buffer_to_hash t:%d nb->size:%lu\n", local_thread_num, node_buffer[local_thread_num].size);
                fprintf(stderr, "node_buffer_to_hash t:%d nb->base:%lu\n", local_thread_num, node_buffer[local_thread_num].base);
                fprintf(stderr, "node_buffer_to_hash t:%d nh:%p\n", local_thread_num, node_hash[local_thread_num]);
        }

        int i = 0;
        int count2 = node_buffer[local_thread_num].size / sizeof(struct node_item);
        struct node_item *ni = (struct node_item *) node_buffer[local_thread_num].base;

#if 0
        fprintf(stderr, "[THREAD] #%d fill hash node: count=%d size=%d\n", local_thread_num, count2, sizeof(dummy_cfuhash_entry));
#endif

        struct dummy_dummy_entry
        {
                long long key;
                int value_ptr;
        };

        fprintf_(stderr, "[THREAD] #%d fill hash node: count=%d size=%d\n", local_thread_num, count2, sizeof(struct dummy_dummy_entry));

        for (i = 0; i < count2; i++)
        {
                /*
                 if (i % 5000)
                 {
                 }
                 */

                // fprintf_(stderr, "thread #%d fill #%d/%d\n", local_thread_num, i, count2);

                // g_hash_table_insert(node_hash[local_thread_num], (gpointer) (long) (ni[i].id), (gpointer) (long) i);
                //cfuhash_put(node_hash_cfu[local_thread_num], &(long long)ni[i].id, xxx);

#if 0
                //fprintf(stderr, "node id:%lld i:%d\n", (long long)ni[i].id, i);
                cfuhash_put_data(node_hash_cfu[local_thread_num], (long long)ni[i].id, sizeof(long long), i, sizeof(int), NULL);
#endif

                // fprintf(stderr, "node id:%lld mem:%p\n", (long long)ni->id, ni);
                quick_hash_add_entry(node_hash_cfu[local_thread_num], (long long)ni[i].id, i);
                // ni++;
        }

        // fprintf_(stderr, "thread #%d node_buffer_to_hash ready\n", local_thread_num);

        if (verbose_mode)
        {
                fprintf(stderr, "node_buffer_to_hash ready\n");
        }
}

static void waytag_buffer_to_hash(void)
{
        int i, count = waytag_buffer.size / sizeof(struct way_tag);
        struct way_tag *wt = (struct way_tag *) waytag_buffer.base;
        for (i = 0; i < count; i++)
        {
                // fprintf(stderr, "waytag_hash insert:%lu %lu\n", (long) (wt[i].way_id), (long) i);
                g_hash_table_insert(waytag_hash, (gpointer) (long) (wt[i].way_id), (gpointer) (long) i);
        }
}

static struct node_item *ni;

void init_node_hash(int threads, int clear)
{
        int i;
        for (i = 0; i < threads; i++)
        {
                //if (clear)
                //{
                //*node_hash[i] = NULL;
                //}
                //else
                //{
                //*node_hash[i] = g_hash_table_new(NULL, NULL);
                //}
#if 0
                node_hash_cfu[i] = cfuhash_new_with_initial_size(CFUHASH_BUCKETS_NODES);
                cfuhash_set_flag(node_hash_cfu[i], CFUHASH_FROZEN);
#endif
                node_hash_cfu[i] = quick_hash_init(CFUHASH_BUCKETS_NODES);
        }
}

void fill_hash_node(int local_thread_num)
{
        //fprintf(stderr, "001t:%d base:%lu\n", local_thread_num, node_buffer[local_thread_num]);

        if (verbose_mode)
        {
                fprintf(stderr, "fill_hash_node - START\n");
        }
        //if (node_hash[local_thread_num])
        if (node_hash_cfu[local_thread_num])
        {
#if 0
                //g_hash_table_destroy(node_hash[local_thread_num]);
                //node_hash[local_thread_num] = NULL;
                cfuhash_clear(node_hash_cfu[local_thread_num]);
                cfuhash_destroy(node_hash_cfu[local_thread_num]);
                node_hash_cfu[local_thread_num] = NULL;
#endif
                quick_hash_destroy(node_hash_cfu[local_thread_num]);
                node_hash_cfu[local_thread_num] = NULL;
        }

#if 0
        // node_hash[local_thread_num] = g_hash_table_new(NULL, NULL);
        node_hash_cfu[local_thread_num] = cfuhash_new_with_initial_size(CFUHASH_BUCKETS_NODES);
        cfuhash_set_flag(node_hash_cfu[local_thread_num], CFUHASH_FROZEN);
#endif
        node_hash_cfu[local_thread_num] = quick_hash_init(CFUHASH_BUCKETS_NODES);
        

        //fprintf(stderr, "002t:%d base:%lu\n", local_thread_num, node_buffer[local_thread_num]);
        node_buffer_to_hash(local_thread_num);

        quick_hash_print_stats(node_hash_cfu[local_thread_num]);

        //fprintf(stderr, "003t:%d base:%lu\n", local_thread_num, node_buffer[local_thread_num]);
        if (verbose_mode)
        {
                fprintf(stderr, "fill_hash_node - END\n");
        }
}

void flush_nodes(int final, int local_thread_num)
{
        save_buffer("coords.tmp", &node_buffer[local_thread_num], slices * slice_size);
        //fprintf(stderr, "004t:%d base:%lu\n", local_thread_num, node_buffer[local_thread_num]);

        if (verbose_mode)
        {
                fprintf(stderr, "flush_nodes %d\n", final);
        }

        if (!final)
        {
                //fprintf(stderr, "005t:%d base:%lu\n", local_thread_num, node_buffer[local_thread_num]);
                node_buffer[local_thread_num].size = 0;
                //fprintf(stderr, "006t:%d base:%lu\n", local_thread_num, node_buffer[local_thread_num]);

                //if (node_hash[local_thread_num])
                if (node_hash_cfu[local_thread_num])
                {
                        if (verbose_mode) fprintf(stderr,"node_hash size="LONGLONG_FMT"\n", g_hash_table_size (node_hash[local_thread_num]));
#if 0
                        //g_hash_table_destroy(node_hash[local_thread_num]);
                        //node_hash[local_thread_num] = NULL;
                        cfuhash_clear(node_hash_cfu[local_thread_num]);
                        cfuhash_destroy(node_hash_cfu[local_thread_num]);
                        node_hash_cfu[local_thread_num] = NULL;
#endif
                        quick_hash_destroy(node_hash_cfu[local_thread_num]);
                        node_hash_cfu[local_thread_num] = NULL;
                }
        }

        if (verbose_mode) fprintf(stderr,"node: node_buffer size="LONGLONG_FMT"\n", node_buffer[local_thread_num].size);
        if (verbose_mode) fprintf(stderr,"node: node_buffer malloced="LONGLONG_FMT"\n", node_buffer[local_thread_num].malloced);
        //fprintf(stderr, "007t:%d base:%lu\n", local_thread_num, node_buffer[local_thread_num]);

        slices++;
}


inline double transform_to_geo_lat(int y)
{
        /* ZZ GEO TRANS ZZ */
        return TO_GEO_LAT_(y);
}

inline double transform_to_geo_lon(int x)
{
        /* ZZ GEO TRANS ZZ */
        return TO_GEO_LON_(x);
}

inline int transform_from_geo_lat(double lat)
{
        /* ZZ GEO TRANS ZZ */
        return FROM_GEO_LAT_(lat);
}

inline int transform_from_geo_lon(double lon)
{
        /* ZZ GEO TRANS ZZ */
        return FROM_GEO_LON_(lon);
}

void osm_add_node(osmid id, double lat, double lon)
{
        in_node = 1;
        if (node_buffer[0].size + sizeof(struct node_item) > node_buffer[0].malloced)
        {
                extend_buffer(&node_buffer[0]);
        }
        attr_strings_clear();
        node_is_tagged = 0;
        nodeid = id;
        item.type = type_point_unkn;
        debug_attr_buffer[0] = '\0';
        is_in_buffer[0] = '\0';
        debug_attr_buffer[0] = '\0';
        osmid_attr.type = attr_osm_nodeid;
        osmid_attr.len = 3;
        osmid_attr_value = id;
        if (node_buffer[0].size + sizeof(struct node_item) > slice_size)
        {
                flush_nodes(0, 0);
        }
        ni = (struct node_item *) (node_buffer[0].base + node_buffer[0].size);
        ni->id = id;
        ni->ref_node = 0;
        ni->ref_way = 0;
        ni->ref_ref = 0;
        ni->dummy = 0;

        // fprintf(stderr, "NNDD:000:%f %f\n", lat, lon);

        /* ZZ GEO TRANS ZZ */
        ni->c.x = FROM_GEO_LON_(lon);
        ni->c.y = FROM_GEO_LAT_(lat);
        /* ZZ GEO TRANS ZZ */

        // fprintf(stderr, "NNDD:002:%d %d\n", ni->c.x, ni->c.y);


        // save values -----
        save_node_lat = lat;
        save_node_lon = lon;
        // save values -----


#ifdef MAPTOOL_USE_SQL

        if (sql_counter2 == 0)
        {
                sqlite3_exec(sql_handle002a, "BEGIN", 0, 0, 0);
                sqlite3_exec(sql_handle003a, "BEGIN", 0, 0, 0);
                sqlite3_exec(sql_handle002b, "BEGIN", 0, 0, 0);
                sqlite3_exec(sql_handle003b, "BEGIN", 0, 0, 0);
        }
        sql_counter2++;

#ifdef MAPTOOL_SPLIT_NODE_DB
        if (nodeid % 2)
        {
                if ((nodeid & MAPTOOL_SPLIT_NODE_BIT) > 0)
                {
                        sqlite3_bind_int64(stmt_node__2a, 1, nodeid);
                        sqlite3_bind_double(stmt_node__2a, 2, lat);
                        sqlite3_bind_double(stmt_node__2a, 3, lon);
                        sqlite3_step(stmt_node__2a);
                        sqlite3_reset(stmt_node__2a);
                }
                else
                {
                        sqlite3_bind_int64(stmt_node__2b, 1, nodeid);
                        sqlite3_bind_double(stmt_node__2b, 2, lat);
                        sqlite3_bind_double(stmt_node__2b, 3, lon);
                        sqlite3_step(stmt_node__2b);
                        sqlite3_reset(stmt_node__2b);
                }
        }
        else
        {
                if ((nodeid & MAPTOOL_SPLIT_NODE_BIT) > 0)
                {
#endif
                        sqlite3_bind_int64(stmt_nodea, 1, nodeid);
                        sqlite3_bind_double(stmt_nodea, 2, lat);
                        sqlite3_bind_double(stmt_nodea, 3, lon);
                        sqlite3_step(stmt_nodea);
                        sqlite3_reset(stmt_nodea);
#ifdef MAPTOOL_SPLIT_NODE_DB
                }
                else
                {
                        sqlite3_bind_int64(stmt_nodeb, 1, nodeid);
                        sqlite3_bind_double(stmt_nodeb, 2, lat);
                        sqlite3_bind_double(stmt_nodeb, 3, lon);
                        sqlite3_step(stmt_nodeb);
                        sqlite3_reset(stmt_nodeb);
                }
        }
#endif

        if (sql_counter2 > MAX_ROWS_WO_COMMIT)
        {
                sql_counter2 = 0;
                sqlite3_exec(sql_handle002a, "COMMIT", 0, 0, 0);
                sqlite3_exec(sql_handle003a, "COMMIT", 0, 0, 0);
                sqlite3_exec(sql_handle002b, "COMMIT", 0, 0, 0);
                sqlite3_exec(sql_handle003b, "COMMIT", 0, 0, 0);
                //fprintf(stderr, "SQL: COMMIT\n");
        }

#endif

        //fprintf(stderr,"node: %d %d\n", ni->c.x, ni->c.y);
        //fprintf(stderr,"node: %f %f\n", lat, lon);


        node_buffer[0].size += sizeof(struct node_item);
        //fprintf(stderr,"node: inc node_buffer by %d\n", sizeof(struct node_item));
        //fprintf(stderr,"node: node_buffer size="LONGLONG_FMT"\n", node_buffer.size);

#if 0
        //if (!node_hash[0])
        if (!node_hash_cfu[0])
        {
                if (ni->id > nodeid_last)
                {
                        nodeid_last = ni->id;
                }
                else
                {
                        //fprintf(stderr,"INFO: Nodes out of sequence (new %d vs old %d), adding hash\n", ni->id, nodeid_last);
                        //node_hash[0] = g_hash_table_new(NULL, NULL);

                        node_hash_cfu[0] = cfuhash_new_with_initial_size(CFUHASH_BUCKETS_OTHER);
                        cfuhash_set_flag(node_hash_cfu[0], CFUHASH_FROZEN);

                        node_buffer_to_hash(0);
                }
        }
        //else if (!g_hash_table_lookup(node_hash[0], (gpointer) (long) (ni->id)))
        // else if (!cfuhash_exists(node_hash_cfu[0], (long long) ni->id ))

        else if (!cfuhash_exists_data(node_hash_cfu[0], (long long) ni->id, sizeof(long long)))
        {
                //g_hash_table_insert(node_hash[0], (gpointer) (long) (ni->id), (gpointer) (long) (ni - (struct node_item *) node_buffer[0].base));
                //cfuhash_put(node_hash_cfu[0], (gpointer)ni->id, (gpointer)(long) (ni - (struct node_item *) node_buffer[0].base) );
                cfuhash_put_data(node_hash_cfu[0], (long long)ni->id, sizeof(long long), (long) (ni - (struct node_item *) node_buffer[0].base), 1, NULL);

        }
        else
        {
                node_buffer[0].size -= sizeof(struct node_item);
                if (verbose_mode)
                fprintf(stderr, "node: Decr. node_buffer by %d\n", sizeof(struct node_item));
                if (verbose_mode) fprintf(stderr,"node: node_buffer size="LONGLONG_FMT"\n", node_buffer[0].size);
                nodeid = 0;
        }
#endif

}

void clear_node_item_buffer(void)
{
        int j, count = node_buffer[0].size / sizeof(struct node_item);
        struct node_item *ni = (struct node_item *) (node_buffer[0].base);
        for (j = 0; j < count; j++)
        {
                ni[j].ref_way = 0;
        }
}

static struct node_item *
node_item_get_fast(osmid id, int local_thread_num)
{
#if 1
        int i;
        //void *p_tmp;
        //int rr;
        //size_t data_size2 = sizeof(int);
        struct node_item *ni = (struct node_item *) (node_buffer[local_thread_num].base);
#endif

        //if (node_hash[local_thread_num])
        if (node_hash_cfu[local_thread_num])
        {
#if 0
                //p_tmp = (gpointer)(g_hash_table_lookup(node_hash[local_thread_num], (gpointer) (long) id));
                rr = cfuhash_get_data(node_hash_cfu[local_thread_num], (long long) id, sizeof(long long), &p_tmp, &data_size2);
                if (rr == 1)
                {
                        //fprintf(stderr, "got key=%lld value=%d\n", (long long) id, p_tmp);
                        i = p_tmp;
                        return ni + i;
                }
#endif

                //struct node_item *ni = quick_hash_lookup(node_hash_cfu[local_thread_num], id);
                //fprintf(stderr, "got key=%lld value=%p\n", (long long)id, ni);
                //if (ni)
                //{
                //      fprintf(stderr, "x=%d y=%d\n", ni->c.x, ni->c.y);
                //}
                i = quick_hash_lookup(node_hash_cfu[local_thread_num], id);
                if (i != -1)
                {
                        return ni + i; // move pointer "i" number of items forward
                }

                //if (p_tmp != NULL)
                //{
                //      // only if node is found in hash!
                //      i = (int) (long) (p_tmp);
                //      return ni + i;
                //}
        }
        return NULL;
}

static int load_node(FILE *coords, int p, struct node_item *ret)
{
        fseek(coords, p * sizeof(struct node_item), SEEK_SET);
        if (fread(ret, sizeof(*ret), 1, coords) != 1)
        {
                fprintf(stderr, "read failed\n");
                return 0;
        }
        return 1;
}

static osmid first_node_of_current_way;

void osm_add_way(osmid id)
{
        static osmid wayid_last;

        in_way = 1;
        wayid = id;
        coord_count = 0;
        attr_strings_clear();
        item.type = type_street_unkn;
        debug_attr_buffer[0] = '\0';
        maxspeed_attr_value = 0;
        flags_attr_value = 0;
        memset(flags, 0, sizeof(flags));
        debug_attr_buffer[0] = '\0';
        osmid_attr_value = id;

        if (wayid < wayid_last && !way_hash_cfu)
        {
                if (verbose_mode)
                {
                        fprintf(stderr, "INFO: Ways out of sequence (new %d vs old %d), adding hash\n", wayid, wayid_last);
                }
                // way_hash = g_hash_table_new(NULL, NULL);
                way_hash_cfu = cfuhash_new_with_initial_size(CFUHASH_BUCKETS_WAYS);
                cfuhash_set_flag(way_hash_cfu, CFUHASH_FROZEN);

        }
        wayid_last = wayid;
}

char relation_type[BUFFER_SIZE];
char iso_code[BUFFER_SIZE];
int admin_level;
int boundary;

void osm_add_relation(osmid id)
{
        current_id = id;
        in_relation = 1;
        debug_attr_buffer[0] = '\0';
        relation_type[0] = '\0';
        iso_code[0] = '\0';
        admin_level = -1;
        boundary = 0;

        // zero out buffer -----------------------
        // bzero(item_bin_2, MAX_ITEMBIN_BYTES_);
        // zero out buffer -----------------------

        item_bin_init(item_bin_2, type_none);
        item_bin_add_attr_longlong(item_bin_2, attr_osm_relationid, current_id);
}

static int country_id_from_iso2(char *iso)
{
        int ret = 0;
        if (iso)
        {
                // make uppercase
                int i99;
                for (i99 = 0; iso[i99]; i99++)
                {
                        iso[i99] = toupper(iso[i99]);
                }
                struct country_search *search;
                struct attr country_iso2, country_id;
                struct item *item;
                country_iso2.type = attr_country_iso2;
                country_iso2.u.str = iso;
                search = country_search_new(&country_iso2, 0);
                if ((item = country_search_get_item(search)) && item_attr_get(item, attr_country_id, &country_id))
                {
                        ret = country_id.u.num;
                        if (debug_itembin(3))
                        {
                                fprintf(stderr, "country id(1)=%d\n", ret);
                        }
                }
                else
                {
                        if (debug_itembin(3))
                        {
                                fprintf(stderr, "country id(2)=%d\n", ret);
                        }
                }
                country_search_destroy(search);
        }
        return ret;
}

struct country_table *country_from_countryid(int id)
{
        int i;
        for (i = 0; i < sizeof(country_table) / sizeof(struct country_table); i++)
        {
                //if (debug_itembin(3))
                //{
                //      fprintf(stderr,"== country_from_countryid: %d ==\n", country_table[i].countryid);
                //}

                if (country_table[i].countryid == id)
                {
                        return &country_table[i];
                }
        }

        //if (debug_itembin(3))
        //{
        //      fprintf(stderr,"== country_from_countryid: return NULL ==\n");
        //}

        return NULL;
}

struct country_table *
country_from_iso2(char *iso)
{
        return country_from_countryid(country_id_from_iso2(iso));
}

static int get_relation_member(char *str, struct relation_member *memb)
{
        int len;
        sscanf(str,"%d:"LONGLONG_FMT":%n",&memb->type,&memb->id,&len);
        memb->role = str + len;
        return 1;
}

#if 0
void report(io, markers, reporttriangles, reportneighbors, reportsegments, reportedges, reportnorms)
struct triangulateio *io;int markers;int reporttriangles;int reportneighbors;int reportsegments;int reportedges;int reportnorms;
{
        int i, j;

        for (i = 0; i < io->numberofpoints; i++)
        {
                fprintf(stderr, "Point %4d:", i);
                for (j = 0; j < 2; j++)
                {
                        fprintf(stderr, "  %.6g", io->pointlist[i * 2 + j]);
                }
                if (io->numberofpointattributes > 0)
                {
                        fprintf(stderr, "   attributes");
                }
                for (j = 0; j < io->numberofpointattributes; j++)
                {
                        fprintf(stderr, "  %.6g", io->pointattributelist[i * io->numberofpointattributes + j]);
                }
                if (markers)
                {
                        fprintf(stderr, "   marker %d\n", io->pointmarkerlist[i]);
                }
                else
                {
                        fprintf(stderr, "\n");
                }
        }
        fprintf(stderr, "\n");

        if (reporttriangles || reportneighbors)
        {
                for (i = 0; i < io->numberoftriangles; i++)
                {
                        if (reporttriangles)
                        {
                                fprintf(stderr, "Triangle %4d points:", i);
                                for (j = 0; j < io->numberofcorners; j++)
                                {
                                        fprintf(stderr, "  %4d", io->trianglelist[i * io->numberofcorners + j]);
                                }
                                if (io->numberoftriangleattributes > 0)
                                {
                                        fprintf(stderr, "   attributes");
                                }
                                for (j = 0; j < io->numberoftriangleattributes; j++)
                                {
                                        fprintf(stderr, "  %.6g", io->triangleattributelist[i * io->numberoftriangleattributes + j]);
                                }
                                fprintf(stderr, "\n");
                        }
                        if (reportneighbors)
                        {
                                fprintf(stderr, "Triangle %4d neighbors:", i);
                                for (j = 0; j < 3; j++)
                                {
                                        fprintf(stderr, "  %4d", io->neighborlist[i * 3 + j]);
                                }
                                fprintf(stderr, "\n");
                        }
                }
                fprintf(stderr, "\n");
        }

        if (reportsegments)
        {
                for (i = 0; i < io->numberofsegments; i++)
                {
                        fprintf(stderr, "Segment %4d points:", i);
                        for (j = 0; j < 2; j++)
                        {
                                fprintf(stderr, "  %4d", io->segmentlist[i * 2 + j]);
                        }
                        if (markers)
                        {
                                fprintf(stderr, "   marker %d\n", io->segmentmarkerlist[i]);
                        }
                        else
                        {
                                fprintf(stderr, "\n");
                        }
                }
                fprintf(stderr, "\n");
        }

        if (reportedges)
        {
                for (i = 0; i < io->numberofedges; i++)
                {
                        fprintf(stderr, "Edge %4d points:", i);
                        for (j = 0; j < 2; j++)
                        {
                                fprintf(stderr, "  %4d", io->edgelist[i * 2 + j]);
                        }
                        if (reportnorms && (io->edgelist[i * 2 + 1] == -1))
                        {
                                for (j = 0; j < 2; j++)
                                {
                                        fprintf(stderr, "  %.6g", io->normlist[i * 2 + j]);
                                }
                        }
                        if (markers)
                        {
                                fprintf(stderr, "   marker %d\n", io->edgemarkerlist[i]);
                        }
                        else
                        {
                                fprintf(stderr, "\n");
                        }
                }
                fprintf(stderr, "\n");
        }
}

#endif

void get_lat_lon_for_node(long long nd, struct node_lat_lon *node);

void get_lat_lon_way_first_node(long long way_id, struct node_lat_lon *node)
{
        int rc2;
        sqlite3_stmt *st;
        long long nd = 0;


        node->valid = 0;

#ifdef MAPTOOL_SPLIT_WAYNODE_DB
        if ((way_id & MAPTOOL_SPLIT_WAYNODE_BIT) > 0)
        {
                if ((way_id & MAPTOOL_SPLIT_WAYNODE_BIT2) > 0)
                {
#endif
                        st = stmt_sel001;
#ifdef MAPTOOL_SPLIT_WAYNODE_DB
                }
                else
                {
                        st = stmt_sel001b;
                }
        }
        else
        {
                if ((way_id & MAPTOOL_SPLIT_WAYNODE_BIT2) > 0)
                {
                        st = stmt_sel001__2;
                }
                else
                {
                        st = stmt_sel001__2b;
                }
        }
#endif
        sqlite3_bind_int64(st, 1, way_id);

        // execute the statement
        rc2 = sqlite3_step(st);
        switch (rc2)
        {
                case SQLITE_DONE:
                break;
                case SQLITE_ROW:
                nd = sqlite3_column_int64(st, 0);
                break;
                default:
                fprintf(stderr, "Error: %d\n", rc2);
                break;
        }
        sqlite3_reset(st);
        // sqlite3_finalize(st);

        if (nd != 0)
        {
                get_lat_lon_for_node(nd, node);
        }
}

void get_lat_lon_for_node(long long nd, struct node_lat_lon *node)
{
        int rc2;

        // now read the coords of this node
        node->valid = 0;

#ifdef MAPTOOL_USE_SQL

#ifdef MAPTOOL_SPLIT_NODE_DB
        if (nd % 2)
        {
                if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                {
                        sqlite3_bind_int64(stmt_sel002__2a, 1, nd);
                }
                else
                {
                        sqlite3_bind_int64(stmt_sel002__2b, 1, nd);
                }
        }
        else
        {
                if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                {
#endif
                        sqlite3_bind_int64(stmt_sel002a, 1, nd);
#ifdef MAPTOOL_SPLIT_NODE_DB
                }
                else
                {
                        sqlite3_bind_int64(stmt_sel002b, 1, nd);
                }
        }
#endif

        rc2 = 0;
        //do
        //{
#ifdef MAPTOOL_SPLIT_NODE_DB
        if (nd % 2)
        {
                if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                {
                        rc2 = sqlite3_step(stmt_sel002__2a);
                }
                else
                {
                        rc2 = sqlite3_step(stmt_sel002__2b);
                }
        }
        else
        {
                if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                {
#endif
                        rc2 = sqlite3_step(stmt_sel002a);
#ifdef MAPTOOL_SPLIT_NODE_DB
                }
                else
                {
                        rc2 = sqlite3_step(stmt_sel002b);
                }
        }
#endif
        //cols2 = sqlite3_column_count(stmt_sel002);
        switch (rc2)
        {
                //case SQLITE_DONE:
                //      break;
                case SQLITE_ROW:

#ifdef MAPTOOL_SPLIT_NODE_DB
                if (nd % 2)
                {
                        if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                        {
                                node->lat = (double) sqlite3_column_double(stmt_sel002__2a, 0);
                                node->lon = (double) sqlite3_column_double(stmt_sel002__2a, 1);
                        }
                        else
                        {
                                node->lat = (double) sqlite3_column_double(stmt_sel002__2b, 0);
                                node->lon = (double) sqlite3_column_double(stmt_sel002__2b, 1);
                        }
                }
                else
                {
                        if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                        {
#endif
                                node->lat = (double) sqlite3_column_double(stmt_sel002a, 0);
                                node->lon = (double) sqlite3_column_double(stmt_sel002a, 1);
#ifdef MAPTOOL_SPLIT_NODE_DB
                        }
                        else
                        {
                                node->lat = (double) sqlite3_column_double(stmt_sel002b, 0);
                                node->lon = (double) sqlite3_column_double(stmt_sel002b, 1);
                        }
                }
#endif
                node->valid = 1;
                break;
                default:
                fprintf(stderr, "get_lat_lon_for_node:SQL Error: %d nodeid:%lld\n", rc2, nd);
                break;
        }
        //}
        //while (rc2 == SQLITE_ROW);
#ifdef MAPTOOL_SPLIT_NODE_DB
        if (nd % 2)
        {
                if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                {
                        sqlite3_reset(stmt_sel002__2a);
                }
                else
                {
                        sqlite3_reset(stmt_sel002__2b);
                }
        }
        else
        {
                if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                {
#endif
                        sqlite3_reset(stmt_sel002a);
#ifdef MAPTOOL_SPLIT_NODE_DB
                }
                else
                {
                        sqlite3_reset(stmt_sel002b);
                }
        }
#endif
#endif

}

void catch_signal(int param)
{
        // fprintf (stderr, "Terminating program...\n");
        fprintf(stderr, "****** got SIGSEGV ******\n");
        THROW(MAPTOOL_00002_EXCEPTION);
        // exit(1);
}

struct way_and_endnodes
{
        unsigned long long way_id;
        unsigned long long first_node_id;
        unsigned long long last_node_id;
        int reverse;
        int role;
        GList *nodes;
};

// if same value        -> 0
// otherwise            -> 1
gint comp_func(gconstpointer item1, gconstpointer item2)
{
        long long a;
        long long b;

        a = *((long long *) item1);
        b = *((long long *) item2);

        //fprintf(stderr," item1=%lld\n", a);
        //fprintf(stderr," item2=%lld\n", b);

        if (a == b)
        {
                return 0;
        }

        return 1;
}

// return 0 if item is not found in GList
int glist_find_already_inside(GList* list, gconstpointer item)
{
        if (g_list_find_custom(list, item, (GCompareFunc) comp_func) == NULL)
        {
                return 0;
        }
        return 1;
}

void osm_end_relation(struct maptool_osm *osm)
{
        //fprintf(stderr, "XXX000\n");

        struct item_bin *item_bin_tri;
        struct coord coord_tri;
        struct node_lat_lon node_coords;
        int i9;
        int j9;
        int tmp9;

        int save_relation = 0;
        int save_relations_other_method = 0;
        int tag_id = 1;
        char *str = NULL;
        int triangulate_not_done = 1;
        int problem = 0;
        struct relation_member memb;
        struct relation_member memb2;
        struct way_and_endnodes *way_nodes1;
        struct way_and_endnodes *way_nodes2;
        int found_new_way = 0;
        gpointer *gptr;
        int rc = 0;
        int rc2 = 0;
        int cols;
        int col;
        int first_node_found = 0;
        long long nd;
        long long first_nd;
        long long search_nd;
        long long *ndptr;

        /*
         long lat_nd;
         long lon_nd;
         */

        double lat_nd;
        double lon_nd;

        int number_of_points_in_poly = 0;
        int number_of_points_current_poly = 0;
        int exception = 0;
        int role_ = 0;

        double factor = 10000000;

        struct node_lat_lon* lat_lon_c;

        // triangulate vars
#if 0
        struct triangulateio in, mid, out, vorout;
#endif

#ifdef MAPTOOL_TRIANGULATE
        GPtrArray *current_points;
        GPtrArray *current_hole;
        P2tCDT *cdt;
        P2trCDT *rcdt;
        P2trRefiner *refiner;
        P2tTrianglePtrArray triangles;
        gint refine_max_steps = 1000;
        double x;
        double y;
        int i;
        int j;
        GHashTable *point_map;
        P2trCDT *rmesh;
#endif
        GList *all_holes;

        int count_of_outer_ways = 0;

        GList *unsorted_outer_ways = NULL;
        GList *unsorted_inner_ways = NULL;
        GList *sorted_outer_ways = NULL;
        GList *temp_nodes_list = NULL;
        all_holes = NULL;

        // -- save relations for riverbanks --
        while ((str = item_bin_get_attr(item_bin_2, attr_osm_tag, str)))
        {

                if (!strcmp(str, "waterway=riverbank"))
                {
                        // fprintf(stderr,"k:v=%s\n", str);
                        save_relation = 1;
                        save_relations_other_method = 0;
                        tag_id = 1;
                }
                else if (!strcmp(str, "natural=water"))
                {
                        save_relation = 1;
                        save_relations_other_method = 0;
                        tag_id = 2;
                }
                /*
                 else if (!strcmp(str, "water=river"))
                 {
                 save_relation = 1;
                 tag_id = 3;
                 }
                 */
                else if (!strcmp(str, "natural=lake"))
                {
                        save_relation = 1;
                        save_relations_other_method = 0;
                        tag_id = 4;
                }
                else if (!strcmp(str, "landuse=forest"))
                {
                        // ------ DISABLED ------
                        // save_relation = 1;
                        // save_relations_other_method = 1;
                        // tag_id = 5;
                        // ------ DISABLED ------
                }
                else if (!strcmp(str, "natural=wood"))
                {
                        // ------ DISABLED ------
                        // save_relation = 1;
                        // save_relations_other_method = 1;
                        // tag_id = 6;
                        // ------ DISABLED ------
                }
                else if (!strcmp(str, "building=yes"))
                {
                        save_relation = 1;
                        save_relations_other_method = 0;
                        tag_id = 9;
                        //fprintf(stderr,"k:v=%s id=%lld\n", str, current_id);
                }

        }

        if (save_relation == 1)
        {

#ifdef MAPTOOL_TRIANGULATE

                if (save_relations_other_method == 0)
                {

                        //fprintf(stderr, "START relation id=%lld tag=%d\n", current_id, tag_id);

                        sqlite3_stmt *st;

                        triangulate_not_done = 1;
                        str = NULL;
                        number_of_points_in_poly = 0;
                        count_of_outer_ways = 0;
                        //fprintf(stderr, "\n\n----------START---------\n");
                        while ((str = item_bin_get_attr(item_bin_2, attr_osm_member, str)))
                        {
                                if (get_relation_member(str, &memb))
                                {
                                        if (!strcmp(memb.role, "outer"))
                                        {
                                                if (memb.type == 2)
                                                {
                                                        count_of_outer_ways++;
                                                }
                                        }
                                }
                        }
                        //fprintf(stderr, "number of outer ways: %d\n", count_of_outer_ways);

                        str = NULL;
                        while ((str = item_bin_get_attr(item_bin_2, attr_osm_member, str)))
                        {
                                if (get_relation_member(str, &memb))
                                {
                                        role_=0;
                                        if (!strcmp(memb.role, "outer"))
                                        {
                                                role_=1;
                                                //fprintf(stderr, "1:role=%s id=%lld\n", memb.role, memb.id);
                                        }
                                        else if (!strcmp(memb.role, "inner"))
                                        {
                                                role_=2;
                                                //fprintf(stderr, "2:role=%s id=%lld\n", memb.role, memb.id);
                                        }

                                        if ((memb.type == 2) && ( (role_ == 1)||(role_ == 2) )) // use "outer" and "inner" ways
                                        {
                                                way_nodes1 = (struct way_and_endnodes *) malloc(sizeof(struct way_and_endnodes));
                                                way_nodes1->nodes = NULL;
                                                // get id for last and first nodes

#ifdef MAPTOOL_SPLIT_WAYNODE_DB
                                                if ((memb.id & MAPTOOL_SPLIT_WAYNODE_BIT) > 0)
                                                {
                                                        if ((memb.id & MAPTOOL_SPLIT_WAYNODE_BIT2) > 0)
                                                        {
#endif
                                                                st = stmt_sel001;
#ifdef MAPTOOL_SPLIT_WAYNODE_DB
                                                        }
                                                        else
                                                        {
                                                                st = stmt_sel001b;
                                                        }
                                                }
                                                else
                                                {
                                                        if ((memb.id & MAPTOOL_SPLIT_WAYNODE_BIT2) > 0)
                                                        {
                                                                st = stmt_sel001__2;
                                                        }
                                                        else
                                                        {
                                                                st = stmt_sel001__2b;
                                                        }
                                                }
#endif
                                                sqlite3_bind_int64(st, 1, memb.id);

                                                first_node_found = 0;
                                                way_nodes1->first_node_id = 0;
                                                nd = 0;
                                                number_of_points_current_poly = 0;
                                                // execute the statement
                                                do
                                                {
                                                        rc = sqlite3_step(st);
                                                        // cols = sqlite3_column_count(st);
                                                        switch (rc)
                                                        {
                                                                case SQLITE_DONE:
                                                                break;
                                                                case SQLITE_ROW:
                                                                nd = sqlite3_column_int64(st, 0);
                                                                number_of_points_current_poly++;
                                                                //fprintf(stderr, "------ %s = %d\n", sqlite3_column_name(st, 0), nd ? nd : "NULL");
                                                                if (first_node_found == 0)
                                                                {
                                                                        way_nodes1->first_node_id = nd;
                                                                        way_nodes1->role = role_;
                                                                        first_node_found = 1;
                                                                        //fprintf(stderr, "------ first node found\n");
                                                                }
                                                                ndptr = malloc(sizeof(long long));
                                                                *ndptr = nd;
                                                                way_nodes1->nodes = g_list_append(way_nodes1->nodes, ndptr);
                                                                break;
                                                                default:
                                                                fprintf(stderr, "Error: %d\n", rc);
                                                                break;
                                                        }
                                                }
                                                while (rc == SQLITE_ROW);

                                                // dont count the last node of each way
                                                number_of_points_current_poly--;

                                                sqlite3_reset(st);

                                                way_nodes1->last_node_id = nd;
                                                way_nodes1->way_id = memb.id;

                                                if (way_nodes1->last_node_id == 0)
                                                {
                                                        if (way_nodes1->nodes)
                                                        {
                                                                way_nodes1->nodes = g_list_first(way_nodes1->nodes);
                                                                while (way_nodes1->nodes)
                                                                {
                                                                        ndptr = way_nodes1->nodes->data;
                                                                        way_nodes1->nodes = g_list_remove(way_nodes1->nodes, ndptr);
                                                                        g_free(ndptr);
                                                                        ndptr = NULL;
                                                                        way_nodes1->nodes = g_list_next(way_nodes1->nodes);
                                                                }
                                                        }
                                                        g_free(way_nodes1);
                                                }
                                                else if (way_nodes1->last_node_id == way_nodes1->first_node_id)
                                                {
                                                        //fprintf(stderr, "ln id=%lld, fn id=%lld\n", way_nodes1->last_node_id, way_nodes1->first_node_id);

                                                        if (way_nodes1->nodes)
                                                        {
                                                                if (role_ == 2)
                                                                {
                                                                        //fprintf(stderr, "role=2\n");
                                                                        unsorted_inner_ways = g_list_append(unsorted_inner_ways, way_nodes1);
                                                                }
                                                                else if (role_ == 1)
                                                                {
                                                                        if (count_of_outer_ways == 1)
                                                                        {
                                                                                // we have only 1 outer way, it must be a closed loop. add it
                                                                                unsorted_outer_ways = g_list_append(unsorted_outer_ways, way_nodes1);
                                                                                number_of_points_in_poly = number_of_points_in_poly + number_of_points_current_poly;
                                                                                //fprintf(stderr, "w,sn,en %lld,%lld,%lld\n", way_nodes1->way_id, way_nodes1->first_node_id, way_nodes1->last_node_id);
                                                                                //fprintf(stderr, "num points=%d\n", number_of_points_current_poly);
                                                                                //fprintf(stderr, "SUM points=%d\n", number_of_points_in_poly);
                                                                        }
                                                                        else
                                                                        {
                                                                                // we have an outer way that is a loop (remove it)
                                                                                //fprintf(stderr, "remove node ... start\n");
                                                                                way_nodes1->nodes = g_list_first(way_nodes1->nodes);
                                                                                while (way_nodes1->nodes)
                                                                                {
                                                                                        //fprintf(stderr, "remove node\n");
                                                                                        ndptr = way_nodes1->nodes->data;
                                                                                        way_nodes1->nodes = g_list_remove(way_nodes1->nodes, ndptr);
                                                                                        g_free(ndptr);
                                                                                        ndptr = NULL;
                                                                                        way_nodes1->nodes = g_list_next(way_nodes1->nodes);
                                                                                }
                                                                                g_free(way_nodes1);
                                                                                //fprintf(stderr, "remove node ... ready\n");
                                                                        }
                                                                }
                                                        }
                                                }
                                                else
                                                {
                                                        if (role_ == 1)
                                                        {
                                                                unsorted_outer_ways = g_list_append(unsorted_outer_ways, way_nodes1);
                                                                number_of_points_in_poly = number_of_points_in_poly + number_of_points_current_poly;
                                                        }
                                                        //fprintf(stderr, "w,sn,en %lld,%lld,%lld\n", way_nodes1->way_id, way_nodes1->first_node_id, way_nodes1->last_node_id);
                                                        //fprintf(stderr, "num points=%d\n", number_of_points_current_poly);
                                                        //fprintf(stderr, "SUM points=%d\n", number_of_points_in_poly);
                                                }
                                        }
                                }
                        }

                        // now sort ways to have a linked polygon
                        if (unsorted_outer_ways)
                        {
                                unsorted_outer_ways = g_list_first(unsorted_outer_ways);
                                way_nodes1 = (struct way_and_endnodes *) malloc(sizeof(struct way_and_endnodes));
                                way_nodes2 = (struct way_and_endnodes *) unsorted_outer_ways->data;
                                way_nodes1->way_id = way_nodes2->way_id;
                                //fprintf(stderr, "(START)way id=%llu\n", way_nodes1->way_id);
                                way_nodes1->last_node_id = way_nodes2->last_node_id;
                                way_nodes1->first_node_id = way_nodes2->first_node_id;
                                // only copy over the pointer to the node list!!
                                way_nodes1->nodes = way_nodes2->nodes;
                                // first node is always in the right order
                                way_nodes1->reverse = 0;

                                gptr = unsorted_outer_ways->data;
                                sorted_outer_ways = g_list_append(sorted_outer_ways, way_nodes1);
                                // save the very first node of the poly
                                first_nd = way_nodes1->first_node_id;
                                // what node we want to find
                                search_nd = way_nodes1->last_node_id;
                                unsorted_outer_ways = g_list_remove(unsorted_outer_ways, gptr);
                                g_free(gptr);
                                gptr = NULL;

                                //fprintf(stderr,"remaining=%d sorted=%d\n", g_list_length(unsorted_outer_ways), g_list_length(sorted_outer_ways));
                        }

                        if (unsorted_outer_ways)
                        {

                                problem = 0;
                                //fprintf(stderr, "start length unsorted_outer_ways=%d\n", g_list_length(unsorted_outer_ways));

                                while ((g_list_length(unsorted_outer_ways) > 0) && (problem == 0))
                                {
                                        //fprintf(stderr, "loop thru remaining ways 1\n");

                                        // loop thru all the remaining ways
                                        found_new_way = 0;
                                        unsorted_outer_ways = g_list_first(unsorted_outer_ways);
                                        while (unsorted_outer_ways)
                                        {
                                                //fprintf(stderr, "loop thru remaining ways 2 search=%lld\n", search_nd);

                                                if (unsorted_outer_ways->data)
                                                {
                                                        way_nodes2 = (struct way_and_endnodes *) unsorted_outer_ways->data;
                                                        if (way_nodes2->first_node_id == search_nd)
                                                        {

                                                                if (way_nodes2->last_node_id == first_nd)
                                                                {
                                                                        if (g_list_length(unsorted_outer_ways) > 1)
                                                                        {
                                                                                // we have closed the poly, but there are still "ways" left
                                                                                // sounds broken
                                                                                problem = 1;
                                                                                break;
                                                                        }
                                                                }

                                                                // what node we want to find
                                                                search_nd = way_nodes2->last_node_id;

                                                                // now move the way from unsorted to sorted list
                                                                way_nodes1 = (struct way_and_endnodes *) malloc(sizeof(struct way_and_endnodes));
                                                                way_nodes1->way_id = way_nodes2->way_id;

                                                                // ok next way found
                                                                //fprintf(stderr, "(F)way id=%llu\n", way_nodes1->way_id);
                                                                //fprintf(stderr, "now search id=%llu\n", search_nd);

                                                                way_nodes1->last_node_id = way_nodes2->last_node_id;
                                                                way_nodes1->first_node_id = way_nodes2->first_node_id;
                                                                // only copy over the pointer to the node list!!
                                                                way_nodes1->nodes = way_nodes2->nodes;
                                                                // first node is always in the right order
                                                                way_nodes1->reverse = 0;
                                                                sorted_outer_ways = g_list_append(sorted_outer_ways, way_nodes1);
                                                                if (unsorted_outer_ways)
                                                                {
                                                                        unsorted_outer_ways = g_list_first(unsorted_outer_ways);
                                                                }
                                                                unsorted_outer_ways = g_list_remove(unsorted_outer_ways, way_nodes2);
                                                                g_free(way_nodes2);
                                                                way_nodes2 = NULL;

                                                                found_new_way = 1;
                                                                //fprintf(stderr, "length unsorted_outer_ways=%d\n", g_list_length(unsorted_outer_ways));
                                                                break;
                                                        }
                                                        else if (way_nodes2->last_node_id == search_nd)
                                                        {
                                                                if (way_nodes2->first_node_id == first_nd)
                                                                {
                                                                        if (g_list_length(unsorted_outer_ways) > 1)
                                                                        {
                                                                                // we have closed the poly, but there are still "ways" left
                                                                                // sounds broken
                                                                                problem = 1;
                                                                                break;
                                                                        }
                                                                }

                                                                // what node we want to find
                                                                search_nd = way_nodes2->first_node_id;

                                                                // now move the way from unsorted to sorted list
                                                                way_nodes1 = (struct way_and_endnodes *) malloc(sizeof(struct way_and_endnodes));
                                                                way_nodes1->way_id = way_nodes2->way_id;

                                                                // ok next way found
                                                                //fprintf(stderr, "(R)way id=%llu\n", way_nodes1->way_id);
                                                                //fprintf(stderr, "now search id=%llu\n", search_nd);

                                                                way_nodes1->first_node_id = way_nodes2->last_node_id;
                                                                way_nodes1->last_node_id = way_nodes2->first_node_id;
                                                                // only copy over the pointer to the node list!!
                                                                way_nodes1->nodes = way_nodes2->nodes;
                                                                way_nodes1->nodes = g_list_reverse(way_nodes1->nodes);
                                                                // first node is always in the right order
                                                                way_nodes1->reverse = 1;
                                                                sorted_outer_ways = g_list_append(sorted_outer_ways, way_nodes1);
                                                                if (unsorted_outer_ways)
                                                                {
                                                                        unsorted_outer_ways = g_list_first(unsorted_outer_ways);
                                                                }
                                                                unsorted_outer_ways = g_list_remove(unsorted_outer_ways, way_nodes2);
                                                                g_free(way_nodes2);
                                                                way_nodes2 = NULL;

                                                                found_new_way = 1;
                                                                //fprintf(stderr, "length unsorted_outer_ways=%d\n", g_list_length(unsorted_outer_ways));
                                                                break;
                                                        }
                                                }
                                                unsorted_outer_ways = g_list_next(unsorted_outer_ways);
                                        }
                                        //fprintf(stderr, "after while loop 2\n");

                                        if (found_new_way == 0)
                                        {
                                                // some problem with this multipolygon
                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                                fprintf_(stderr, "some problem with this multipolygon\n");
                                                triangulate_not_done = 1;
                                                problem = 1;
                                                break;
                                        }
                                }
                                //fprintf(stderr, "after while loop 1\n");

                        }

                        // now at last check if very first node matches the last found node
                        // and less than xxx 1000 points in polygon
                        // if ((search_nd == first_nd) && (number_of_points_in_poly > 2) && (number_of_points_in_poly < 1000))
                        if ((problem == 0) && ((search_nd == first_nd) && (number_of_points_in_poly > 2) && (number_of_points_in_poly < 30000)))
                        {

                                //fprintf(stderr, "in relation id=%lld\n", current_id);

                                point_map = g_hash_table_new(g_direct_hash, g_direct_equal);
                                current_points = g_ptr_array_new();

                                number_of_points_in_poly = 0;

                                sorted_outer_ways = g_list_first(sorted_outer_ways);
                                while (sorted_outer_ways)
                                {
                                        if (sorted_outer_ways->data)
                                        {
                                                way_nodes1 = (struct way_and_endnodes *) sorted_outer_ways->data;
                                                // now read all the nodes of this way
                                                //**alread in GList** //sqlite3_bind_int64(stmt_sel001, 1, way_nodes1->way_id);
                                                way_nodes1->nodes = g_list_first(way_nodes1->nodes);
                                                first_node_found = 0;
                                                while (way_nodes1->nodes)
                                                {
                                                        ndptr = (long long *) way_nodes1->nodes->data;
                                                        nd = *ndptr;

                                                        get_lat_lon_for_node(nd, &node_coords);
                                                        if (node_coords.valid == 1)
                                                        {
                                                                // lat
                                                                lat_nd = node_coords.lat;
                                                                // lon
                                                                lon_nd = node_coords.lon;

                                                                if (first_node_found == 0)
                                                                {
                                                                        first_node_found = 1;
                                                                }
                                                                else
                                                                {
                                                                        y = lat_nd * factor;
                                                                        x = lon_nd * factor;

                                                                        // ------ ok use this node and coords for triangulation ----
                                                                        //fprintf(stderr, "nd,lat,lon %lld,%f,%f\n", nd,lat_nd,lon_nd);
                                                                        //fprintf(stderr, "x,y %f,%f\n", x, y);

                                                                        g_ptr_array_add(current_points, p2t_point_new_dd(x, y));
                                                                }
                                                        }
                                                        way_nodes1->nodes = g_list_next(way_nodes1->nodes);
                                                }
                                        }
                                        //sqlite3_reset(st);

                                        sorted_outer_ways = g_list_next(sorted_outer_ways);
                                }

                                //fprintf(stderr, "after sorting ways\n");


                                exception = 0;

                                TRY
                                {
                                        // catch SIGSEGV !!
                                        signal(SIGSEGV, catch_signal);

                                        // alternate signal stack ------------
                                        //ss.ss_size = SIGSTKSZ;
                                        //ss.ss_sp = stack;
                                        //sa.sa_handler = catch_signal;
                                        //sa.sa_flags = SA_ONSTACK;
                                        //sigfillset(&sa.sa_mask);

                                        //sigaltstack(&ss, 0);
                                        //sigfillset(&sa.sa_mask);
                                        //sigaction(SIGSEGV, &sa, 0);
                                        // alternate signal stack ------------

                                        // catch SIGSEGV !!

                                        //fprintf(stderr, "In Try Statement (p2t_cdt_new)\n");
                                        cdt = p2t_cdt_new(current_points);
                                        //fprintf(stderr, "all OK (p2t_cdt_new)\n");
                                }
                                CATCH( MAPTOOL_00001_EXCEPTION )
                                {
                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                        fprintf_(stderr, "Got Exception 1!\n");
                                        exception = 1;
                                }
                                CATCH( MAPTOOL_00002_EXCEPTION )
                                {
                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                        fprintf_(stderr, "Got segv Exception 1!\n");
                                        exception = 1;
                                }
                                FINALLY
                                {
                                        // set default
                                        signal (SIGSEGV, SIG_DFL);
                                        // set default

                                        //fprintf(stderr, "finally\n");
                                }
                                ETRY;

                                //fprintf(stderr, "after cdt_new\n");

                                GList* save = unsorted_inner_ways;

                                int no_holes = 0;
                                if (exception == 0)
                                {

                                        // first run a check loop
                                        int number_of_nodes_in_this_way;
                                        int cur_node_count_in_way;
                                        unsorted_inner_ways = g_list_first(unsorted_inner_ways);

                                        int number_of_nodes_in_this_way3 = g_list_length(unsorted_inner_ways);
                                        //fprintf(stderr, "uiw 001.0 c=%d\n", number_of_nodes_in_this_way3);
                                        while (unsorted_inner_ways)
                                        {
                                                if ((unsorted_inner_ways->data)&&(no_holes == 0))
                                                {
                                                        way_nodes1 = (struct way_and_endnodes *) unsorted_inner_ways->data;
                                                        number_of_nodes_in_this_way = g_list_length(way_nodes1->nodes);
                                                        // now read all the nodes of this "hole"-way
                                                        GList* save0 = way_nodes1->nodes;
                                                        way_nodes1->nodes = g_list_first(way_nodes1->nodes);
                                                        first_node_found = 0;
                                                        cur_node_count_in_way = 1;
                                                        while (way_nodes1->nodes)
                                                        {
                                                                ndptr = (long long *) way_nodes1->nodes->data;
                                                                // fprintf(stderr, "hole node:%lld\n", (long long)*ndptr);

                                                                if (temp_nodes_list != NULL)
                                                                {
                                                                        //fprintf(stderr, "cur_node_count_in_way %d number_of_nodes_in_this_way %d\n", cur_node_count_in_way, number_of_nodes_in_this_way);
                                                                        // the last node should always be same as first node (for now we only support holes that dont span over multiple ways!)
                                                                        if (cur_node_count_in_way < number_of_nodes_in_this_way)
                                                                        {
                                                                                if (glist_find_already_inside(temp_nodes_list, ndptr) != 0)
                                                                                {
                                                                                        fprintf_(stderr, "relation id=%lld\n", current_id);
                                                                                        fprintf_(stderr, "problem with hole!\n");
                                                                                        no_holes = 1;
                                                                                        break;
                                                                                }
                                                                                else
                                                                                {
                                                                                        //fprintf(stderr, "hole check ok\n");
                                                                                }
                                                                        }
                                                                }

                                                                temp_nodes_list = g_list_append(temp_nodes_list, ndptr);

                                                                way_nodes1->nodes = g_list_next(way_nodes1->nodes);
                                                                cur_node_count_in_way++;
                                                        }
                                                        way_nodes1->nodes = save0;
                                                }
                                                unsorted_inner_ways = g_list_next(unsorted_inner_ways);
                                        }

                                }

                                unsorted_inner_ways = save;

                                //fprintf(stderr, "ex=%d nohole=%d\n", exception, no_holes);

                                
                                if ((exception == 0) && (no_holes == 0))
                                {
                                        //fprintf(stderr, "uiw 000\n");

                                        // now do the real loop
                                        int number_of_added_holes = 0;

                                        unsorted_inner_ways = g_list_first(unsorted_inner_ways);
                                        //int number_of_nodes_in_this_way4 = g_list_length(unsorted_inner_ways);
                                        //fprintf(stderr, "uiw 001.2 c=%d\n", number_of_nodes_in_this_way4);
                                        while (unsorted_inner_ways)
                                        {
                                                //fprintf(stderr, "uiw 001\n");

                                                if (unsorted_inner_ways->data)
                                                {
                                                        //fprintf(stderr, "uiw 002\n");

                                                        current_hole = g_ptr_array_new();

                                                        //fprintf(stderr, "uiw 003\n");

                                                        way_nodes1 = (struct way_and_endnodes *) unsorted_inner_ways->data;
                                                        // now read all the nodes of this "hole"-way
                                                        way_nodes1->nodes = g_list_first(way_nodes1->nodes);
                                                        first_node_found = 0;
                                                        while (way_nodes1->nodes)
                                                        {
                                                                //fprintf(stderr, "uiw 004\n");

                                                                ndptr = (long long *) way_nodes1->nodes->data;
                                                                nd = *ndptr;

                                                                // now read the coords of this node

#ifdef MAPTOOL_SPLIT_NODE_DB
                                                                if (nd % 2)
                                                                {
                                                                        if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                                                                        {
                                                                                sqlite3_bind_int64(stmt_sel002__2a, 1, nd);
                                                                        }
                                                                        else
                                                                        {
                                                                                sqlite3_bind_int64(stmt_sel002__2b, 1, nd);
                                                                        }
                                                                }
                                                                else
                                                                {
                                                                        if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                                                                        {
#endif
                                                                                sqlite3_bind_int64(stmt_sel002a, 1, nd);
#ifdef MAPTOOL_SPLIT_NODE_DB
                                                                        }
                                                                        else
                                                                        {
                                                                                sqlite3_bind_int64(stmt_sel002b, 1, nd);
                                                                        }
                                                                }
#endif
                                                                rc2 = 0;
                                                                do
                                                                {
#ifdef MAPTOOL_SPLIT_NODE_DB
                                                                        if (nd % 2)
                                                                        {
                                                                                if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                                                                                {
                                                                                        rc2 = sqlite3_step(stmt_sel002__2a);
                                                                                }
                                                                                else
                                                                                {
                                                                                        rc2 = sqlite3_step(stmt_sel002__2b);
                                                                                }
                                                                        }
                                                                        else
                                                                        {
                                                                                if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                                                                                {
#endif
                                                                                        rc2 = sqlite3_step(stmt_sel002a);
#ifdef MAPTOOL_SPLIT_NODE_DB
                                                                                }
                                                                                else
                                                                                {
                                                                                        rc2 = sqlite3_step(stmt_sel002b);
                                                                                }
                                                                        }
#endif

                                                                        switch (rc2)
                                                                        {
                                                                                case SQLITE_DONE:
                                                                                break;
                                                                                case SQLITE_ROW:

#ifdef MAPTOOL_SPLIT_NODE_DB
                                                                                if (nd % 2)
                                                                                {
                                                                                        if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                                                                                        {
                                                                                                lat_nd = (double) sqlite3_column_double(stmt_sel002__2a, 0);
                                                                                                lon_nd = (double) sqlite3_column_double(stmt_sel002__2a, 1);
                                                                                        }
                                                                                        else
                                                                                        {
                                                                                                lat_nd = (double) sqlite3_column_double(stmt_sel002__2b, 0);
                                                                                                lon_nd = (double) sqlite3_column_double(stmt_sel002__2b, 1);
                                                                                        }
                                                                                }
                                                                                else
                                                                                {
                                                                                        if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                                                                                        {
#endif
                                                                                                lat_nd = (double) sqlite3_column_double(stmt_sel002a, 0);
                                                                                                lon_nd = (double) sqlite3_column_double(stmt_sel002a, 1);
#ifdef MAPTOOL_SPLIT_NODE_DB
                                                                                        }
                                                                                        else
                                                                                        {
                                                                                                lat_nd = (double) sqlite3_column_double(stmt_sel002b, 0);
                                                                                                lon_nd = (double) sqlite3_column_double(stmt_sel002b, 1);
                                                                                        }
                                                                                }
#endif

                                                                                if (first_node_found == 0)
                                                                                {
                                                                                        first_node_found = 1;
                                                                                }
                                                                                else
                                                                                {
                                                                                        // ------ ok use this node and coords for triangulation ----
                                                                                        //fprintf(stderr, "HOLE:nd,lat,lon %lld,%f,%f\n", nd,lat_nd,lon_nd);

                                                                                        //fprintf(stderr, "np=%d\n", number_of_points_in_poly);
                                                                                        //in.pointlist[number_of_points_in_poly] = (REAL) (lat_nd*10);
                                                                                        //number_of_points_in_poly++;
                                                                                        //fprintf(stderr, "np=%d\n", number_of_points_in_poly);
                                                                                        //in.pointlist[number_of_points_in_poly] = (REAL) (lon_nd*10);
                                                                                        //number_of_points_in_poly++;
#if 1
                                                                                        y = lat_nd * factor;
                                                                                        x = lon_nd * factor;

                                                                                        TRY
                                                                                        {
                                                                                                signal(SIGSEGV, catch_signal);

                                                                                                // hole complete, now add it
                                                                                                //fprintf(stderr, "hole new\n");
                                                                                                g_ptr_array_add(current_hole, p2t_point_new_dd(x, y));
                                                                                                //fprintf(stderr, "hole new done\n");
                                                                                        }
                                                                                        CATCH( MAPTOOL_00001_EXCEPTION )
                                                                                        {
                                                                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                                                                                fprintf_(stderr, "Got Exception A!\n");
                                                                                                exception = 1;
                                                                                        }
                                                                                        CATCH( MAPTOOL_00002_EXCEPTION )
                                                                                        {
                                                                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                                                                                fprintf_(stderr, "Got segv Exception A!\n");
                                                                                                exception = 1;
                                                                                        }
                                                                                        FINALLY
                                                                                        {
                                                                                                // set default
                                                                                                signal (SIGSEGV, SIG_DFL);
                                                                                                // set default

                                                                                                //fprintf(stderr, "finally\n");
                                                                                        }
                                                                                        ETRY;

#endif
                                                                                }
                                                                                break;
                                                                                default:
                                                                                fprintf(stderr, "Error: %d\n", rc2);
                                                                                break;
                                                                        }
                                                                }
                                                                while (rc2 == SQLITE_ROW);

#ifdef MAPTOOL_SPLIT_NODE_DB
                                                                if (nd % 2)
                                                                {
                                                                        if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                                                                        {
                                                                                sqlite3_reset(stmt_sel002__2a);
                                                                        }
                                                                        else
                                                                        {
                                                                                sqlite3_reset(stmt_sel002__2b);
                                                                        }
                                                                }
                                                                else
                                                                {
                                                                        if ((nd & MAPTOOL_SPLIT_NODE_BIT) > 0)
                                                                        {
#endif
                                                                                sqlite3_reset(stmt_sel002a);
#ifdef MAPTOOL_SPLIT_NODE_DB
                                                                        }
                                                                        else
                                                                        {
                                                                                sqlite3_reset(stmt_sel002b);
                                                                        }
                                                                }
#endif

                                                                way_nodes1->nodes = g_list_next(way_nodes1->nodes);
                                                        }

                                                        //fprintf(stderr, "uiw 005\n");

                                                        // remember the pointer, to free the memory later
                                                        all_holes = g_list_append(all_holes, current_hole);

                                                        //fprintf(stderr, "uiw 005.1\n");

                                                        TRY
                                                        {
                                                                signal(SIGSEGV, catch_signal);

                                                                // hole complete, now add it
                                                                //fprintf(stderr, "adding hole\n");
                                                                if (number_of_added_holes < MAX_HOLES_PER_POLY)
                                                                {
                                                                        p2t_cdt_add_hole(cdt, current_hole);
                                                                        number_of_added_holes++;
                                                                }
                                                                //fprintf(stderr, "adding done\n");
                                                        }
                                                        CATCH( MAPTOOL_00001_EXCEPTION )
                                                        {
                                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                                                fprintf_(stderr, "Got Exception 8!\n");
                                                                exception = 1;
                                                        }
                                                        CATCH( MAPTOOL_00002_EXCEPTION )
                                                        {
                                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                                                fprintf_(stderr, "Got segv Exception 8!\n");
                                                                exception = 1;
                                                        }
                                                        FINALLY
                                                        {
                                                                // set default
                                                                signal (SIGSEGV, SIG_DFL);
                                                                // set default

                                                                //fprintf(stderr, "finally\n");
                                                        }
                                                        ETRY;

                                                }

                                                //fprintf(stderr, "uiw 006\n");
                                                unsorted_inner_ways = g_list_next(unsorted_inner_ways);

                                        }
                                        //sqlite3_reset(st);

                                        //fprintf(stderr, "uiw 007\n");
                                }

                                //fprintf(stderr, "after adding holes\n");

#if 1

                                if (exception == 0)
                                {
                                        exception = 0;

                                        TRY
                                        {
                                                // catch SIGSEGV !!
                                                signal(SIGSEGV, catch_signal);
                                                //signal(SIGILL, catch_signal);

                                                // alternate signal stack ------------
                                                //ss.ss_size = SIGSTKSZ;
                                                //ss.ss_sp = stack;
                                                //sa.sa_handler = catch_signal;
                                                //sa.sa_flags = SA_ONSTACK;
                                                //sigfillset(&sa.sa_mask);

                                                //sigaltstack(&ss, 0);
                                                //sigfillset(&sa.sa_mask);
                                                //sigaction(SIGSEGV, &sa, 0);
                                                // alternate signal stack ------------

                                                // catch SIGSEGV !!

                                                //fprintf(stderr, "triangulate start ...\n");
                                                p2t_cdt_triangulate(cdt);
                                                //fprintf(stderr, "triangulate end\n");
                                        }
                                        CATCH( MAPTOOL_00001_EXCEPTION )
                                        {
                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                                fprintf_(stderr, "Got Exception 2! (in triangulate)\n");
                                                exception = 1;
                                        }
                                        CATCH( MAPTOOL_00002_EXCEPTION )
                                        {
                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                                fprintf_(stderr, "Got segv Exception 2! (in triangulate)\n");
                                                exception = 1;
                                        }
                                        FINALLY
                                        {
                                                //fprintf(stderr, "finally 2 (in triangulate)\n");

                                                //sa.sa_handler = SIG_DFL;
                                                // sigfillset(&sa.sa_mask);
                                                //sigaction(SIGSEGV, &sa, 0);

                                                // set default
                                                signal (SIGSEGV, SIG_DFL);
                                                // set default
                                        }
                                        ETRY;

                                        if (exception == 0)
                                        {
                                                rmesh = g_slice_new (P2trCDT);
                                                rmesh->mesh = p2tr_mesh_new ();
                                                // rmesh->outline = p2tr_pslg_new ();

                                                /* First iteration over the CDT - create all the points */
                                                //fprintf(stderr, "trinew 006\n");
                                                triangles = p2t_cdt_get_triangles(cdt);
                                                //fprintf(stderr, "trinew 007\n");
                                                for (i = 0; i < triangles->len; i++)
                                                {
                                                        P2tTriangle *cdt_tri = triangle_index (triangles, i);
                                                        for (j = 0; j < 3; j++)
                                                        {
                                                                P2tPoint *cdt_pt = p2t_triangle_get_point(cdt_tri, j);
                                                                P2trPoint *new_pt = (P2trPoint*) g_hash_table_lookup (point_map, cdt_pt);

                                                                if (new_pt == NULL)
                                                                {
                                                                        //fprintf(stderr, "p1 x=%d, y=%d\n",(int)cdt_pt->x, (int)cdt_pt->y);
                                                                        new_pt = p2tr_mesh_new_point2 (rmesh->mesh, (cdt_pt->x / factor), (cdt_pt->y / factor));
                                                                        g_hash_table_insert (point_map, cdt_pt, new_pt);
                                                                }
                                                        }
                                                }

                                                for (i = 0; i < triangles->len; i++)
                                                {
                                                        P2tTriangle *cdt_tri = triangle_index(triangles, i);
                                                        //fprintf(stderr, "tri# %d\n", i);
                                                        gboolean ii = p2t_triangle_is_interior(cdt_tri);
                                                        //fprintf(stderr, "is int=%d\n", ii);

                                                        P2trPoint *pt1 = (P2trPoint*) g_hash_table_lookup (point_map, p2t_triangle_get_point (cdt_tri, 0));
                                                        P2trPoint *pt2 = (P2trPoint*) g_hash_table_lookup (point_map, p2t_triangle_get_point (cdt_tri, 1));
                                                        P2trPoint *pt3 = (P2trPoint*) g_hash_table_lookup (point_map, p2t_triangle_get_point (cdt_tri, 2));

                                                        //fprintf(stderr, "0 x=%f, y=%f\n",pt1->c.x, pt1->c.y);
                                                        //fprintf(stderr, "1 x=%f, y=%f\n",pt2->c.x, pt2->c.y);
                                                        //fprintf(stderr, "2 x=%f, y=%f\n",pt3->c.x, pt3->c.y);

                                                        // make item and write it to ways file -------------------
                                                        // make item and write it to ways file -------------------
                                                        if (tag_id == 1)
                                                        {
                                                                item_bin_tri = init_item(type_poly_water_from_triang, 0);
                                                                //fprintf(stderr, "T:water\n");
                                                        }
                                                        else if (tag_id == 2)
                                                        {
                                                                item_bin_tri = init_item(type_poly_water_from_triang, 0);
                                                                //fprintf(stderr, "T:water\n");
                                                        }
                                                        else if (tag_id == 4)
                                                        {
                                                                item_bin_tri = init_item(type_poly_water_from_triang, 0);
                                                                //fprintf(stderr, "T:water\n");
                                                        }
                                                        else if (tag_id == 5)
                                                        {
                                                                item_bin_tri = init_item(type_poly_wood_from_triang, 0);
                                                                //fprintf(stderr, "T:forest\n");
                                                        }
                                                        else if (tag_id == 6)
                                                        {
                                                                item_bin_tri = init_item(type_poly_wood_from_triang, 0);
                                                                //fprintf(stderr, "T:forest\n");
                                                        }
                                                        else if (tag_id == 9)
                                                        {
                                                                item_bin_tri = init_item(type_poly_building_from_triang, 0);
                                                                //fprintf(stderr, "T:building\n");
                                                        }
                                                        else
                                                        {
                                                                // default
                                                                item_bin_tri = init_item(type_poly_water_from_triang, 0);
                                                                //fprintf(stderr, "T:water\n");
                                                        }

                                                        // first add coords
                                                        coord_tri.x = transform_from_geo_lon(pt1->c.x);
                                                        coord_tri.y = transform_from_geo_lat(pt1->c.y);
                                                        item_bin_add_coord(item_bin_tri, &coord_tri, 1);
                                                        coord_tri.x = transform_from_geo_lon(pt2->c.x);
                                                        coord_tri.y = transform_from_geo_lat(pt2->c.y);
                                                        item_bin_add_coord(item_bin_tri, &coord_tri, 1);
                                                        coord_tri.x = transform_from_geo_lon(pt3->c.x);
                                                        coord_tri.y = transform_from_geo_lat(pt3->c.y);
                                                        item_bin_add_coord(item_bin_tri, &coord_tri, 1);
                                                        // now add dummy osm wayid
                                                        item_bin_add_attr_longlong(item_bin_tri, attr_osm_wayid, current_id);

                                                        // DEBUG -- DEBUG -- DEBUG --
                                                        // DEBUG -- DEBUG -- DEBUG --
                                                        // dump_itembin(item_bin_tri);
                                                        // DEBUG -- DEBUG -- DEBUG --
                                                        // DEBUG -- DEBUG -- DEBUG --
                                                        item_bin_write(item_bin_tri, osm->ways_with_coords);

                                                        // make item and write it to ways file -------------------
                                                        // make item and write it to ways file -------------------

                                                }

                                                //fprintf(stderr, "trinew 091\n");

                                        }

                                        //fprintf(stderr, "trinew 092.0\n");


                                        TRY
                                        {
                                                signal(SIGSEGV, catch_signal);

                                                /* Now finally unref the points we added into the map */
                                                if (point_map != NULL)
                                                {
                                                        GHashTableIter iter;
                                                        P2trPoint *pt_iter = NULL;
                                                        g_hash_table_iter_init (&iter, point_map);
                                                        while (g_hash_table_iter_next (&iter, NULL, (gpointer*)&pt_iter))
                                                        {
                                                                p2tr_point_unref(pt_iter);
                                                        }
                                                        g_hash_table_destroy(point_map);
                                                }
                                        }
                                        CATCH( MAPTOOL_00001_EXCEPTION )
                                        {
                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                                fprintf_(stderr, "Got Exception 3!\n");
                                                exception = 1;
                                        }
                                        CATCH( MAPTOOL_00002_EXCEPTION )
                                        {
                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                                fprintf_(stderr, "Got segv Exception 3!\n");
                                                exception = 1;
                                        }
                                        FINALLY
                                        {
                                                signal (SIGSEGV, SIG_DFL);
                                        }
                                        ETRY;

                                        //fprintf(stderr, "trinew 092.1\n");


                                        TRY
                                        {
                                                signal(SIGSEGV, catch_signal);
                                                // p2tr_mesh_clear(rmesh->mesh);
                                                // --- maybe need this?? --- p2tr_mesh_unref(rmesh->mesh);
                                        }
                                        CATCH( MAPTOOL_00001_EXCEPTION )
                                        {
                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                                fprintf_(stderr, "Got Exception 4!\n");
                                                exception = 1;
                                        }
                                        CATCH( MAPTOOL_00002_EXCEPTION )
                                        {
                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                                fprintf_(stderr, "Got segv Exception 4!\n");
                                                exception = 1;
                                        }
                                        FINALLY
                                        {
                                                signal (SIGSEGV, SIG_DFL);
                                        }
                                        ETRY;

                                        //fprintf(stderr, "trinew 092.2\n");

                                        TRY
                                        {
                                                signal(SIGSEGV, catch_signal);
                                                p2t_cdt_free(cdt);
                                        }
                                        CATCH( MAPTOOL_00001_EXCEPTION )
                                        {
                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                                fprintf_(stderr, "Got Exception 5!\n");
                                                exception = 1;
                                        }
                                        CATCH( MAPTOOL_00002_EXCEPTION )
                                        {
                                                fprintf_(stderr, "relation id=%lld\n", current_id);
                                                fprintf_(stderr, "Got segv Exception 5!\n");
                                                exception = 1;
                                        }
                                        FINALLY
                                        {
                                                signal (SIGSEGV, SIG_DFL);
                                        }
                                        ETRY;

                                        //fprintf(stderr, "trinew 092.3\n");

                                } // exception == 0 ? -- END

                                // rcdt = p2tr_cdt_new(cdt);
                                /*
                                 if (refine_max_steps > 0)
                                 {
                                 fprintf(stderr, "Refining the mesh!\n");
                                 refiner = p2tr_refiner_new(G_PI / 6, p2tr_refiner_false_too_big, rcdt);
                                 p2tr_refiner_refine(refiner, refine_max_steps, NULL);
                                 p2tr_refiner_free(refiner);

                                 p2tr_cdt_validate_edges(rcdt);
                                 }
                                 */

                                //fprintf(stderr, "free holes\n");

                                if (all_holes)
                                {
                                        all_holes = g_list_first(all_holes);
                                        while (all_holes)
                                        {
                                                current_hole = all_holes->data;
                                                for (i = 0; i < current_hole->len; ++i)
                                                {
                                                        p2t_point_free(g_ptr_array_index(current_hole, i));
                                                }
                                                g_ptr_array_free(current_hole, TRUE);

                                                all_holes = g_list_next(all_holes);
                                        }
                                        g_list_free(all_holes);
                                        all_holes = NULL;
                                }

                                //fprintf(stderr, "free points\n");

                                for (i = 0; i < current_points->len; ++i)
                                {
                                        p2t_point_free(g_ptr_array_index(current_points, i));
                                }
                                g_ptr_array_free(current_points, TRUE);

                                //                      p2tr_cdt_free(rcdt);

#endif

#if 0
                                item_bin_write(item_bin_tri, osm->ways_with_coords);
#endif
                                triangulate_not_done = 0;
                        }

                        // free everything!! ----------------
                        if (unsorted_outer_ways)
                        {
                                unsorted_outer_ways = g_list_first(unsorted_outer_ways);
                                while (unsorted_outer_ways)
                                {
                                        gptr = unsorted_outer_ways->data;
                                        way_nodes1 = unsorted_outer_ways->data;
                                        if (way_nodes1->nodes)
                                        {
                                                way_nodes1->nodes = g_list_first(way_nodes1->nodes);
                                                while (way_nodes1->nodes)
                                                {
                                                        ndptr = way_nodes1->nodes->data;
                                                        way_nodes1->nodes = g_list_remove(way_nodes1->nodes, ndptr);
                                                        g_free(ndptr);
                                                        ndptr = NULL;
                                                        way_nodes1->nodes = g_list_next(way_nodes1->nodes);
                                                }
                                        }
                                        unsorted_outer_ways = g_list_remove(unsorted_outer_ways, gptr);
                                        g_free(gptr);
                                        gptr = NULL;
                                        unsorted_outer_ways = g_list_next(unsorted_outer_ways);
                                }
                        }

                        if (unsorted_inner_ways)
                        {
                                unsorted_inner_ways = g_list_first(unsorted_inner_ways);
                                while (unsorted_inner_ways)
                                {
                                        gptr = unsorted_inner_ways->data;
                                        way_nodes1 = unsorted_inner_ways->data;
                                        if (way_nodes1->nodes)
                                        {
                                                way_nodes1->nodes = g_list_first(way_nodes1->nodes);
                                                while (way_nodes1->nodes)