Example #1
0
    def __init__(self, element):
        OSM_Node.__init__(self, element)
        reporting = Reporting()

        self.element = element
        self.wojewodztwo = None
        self.powiat = None
        self.gmina = None
        self.simc_id = None
        self.terc_id = None
        self.simc_place = None
        tags = self.tags

        if "place" in tags:
            self.type = tags["place"]
        else:
            self.type = None

        self.normalized_type = place_aliases.get(self.type, self.type)

        if "is_in" in tags:
            is_in_parts = [s.strip() for s in tags["is_in"].split(",")]
            self.is_in = ", ".join(is_in_parts)
        else:
            is_in_parts = []
            self.is_in = None

        if "is_in:province" in tags:
            woj = tags["is_in:province"]
            self.wojewodztwo = Wojewodztwo.try_by_name(woj, True)
            OSM_Place.woj_matched += 1
        elif is_in_parts:
            for part in is_in_parts:
                woj = Wojewodztwo.try_by_name(part, False)
                if woj:
                    self.wojewodztwo = woj
                    OSM_Place.woj_matched += 1
                    break

        if self.wojewodztwo:
            reporting.output_msg("woj_set", u"%s (%s) jest w %s" % (self.name, 
                        self.id, self.wojewodztwo.full_name()), self)

        if "is_in:county" in tags:
            pow = tags["is_in:county"]
            self.powiat = Powiat.try_by_name(pow, True, self.wojewodztwo)
            OSM_Place.pow_matched += 1
        elif is_in_parts:
            for part in is_in_parts:
                pow = Powiat.try_by_name(part, False, self.wojewodztwo)
                if pow:
                    self.powiat = pow
                    OSM_Place.pow_matched += 1
                    break

        if self.powiat:
            reporting.output_msg("pow_set", u"%s jest w %s" % (self.name,
                            self.powiat.full_name()), self)
            if self.wojewodztwo:
                if self.powiat.wojewodztwo != self.wojewodztwo:
                    reporting.output_msg("errors", u"%s: Powiat nie pasuje do województwa"
                                                        % (self,))
            else:
                self.wojewodztwo = self.powiat.wojewodztwo

        if "is_in:municipality" in tags:
            gmi = tags["is_in:municipality"]
            self.gmina = Gmina.try_by_name(gmi, True,
                                powiat = self.powiat, place_name = self.name)
            OSM_Place.gmi_matched += 1
        elif is_in_parts:
            for part in is_in_parts:
                gmi = Gmina.try_by_name(part, False, 
                                powiat = self.powiat, place_name = self.name)
                if gmi:
                    self.gmi = gmi 
                    OSM_Place.gmi_matched += 1
                    break

        if self.gmina:
            reporting.output_msg("gmi_set", u"%s jest w %s" % (self.name,
                            self.gmina.full_name()), self)
            if self.powiat:
                if self.gmina.powiat != self.powiat:
                    reporting.output_msg("errors", u"%s: Gmina nie pasuje do powiatu"
                                                        % (self,))
                    self.gmina = None
            else:
                self.powiat = self.gmina.powiat

        if "teryt:simc" in tags:
            try:
                self.simc_id = tags["teryt:simc"]
            except ValueError:
                reporting.output_msg("errors", 
                        u"Nieprawidłowa wartość teryt:simc: %r" % (
                                                    tags["teryt:simc"],))
        
        if self.simc_id:
            try:
                self.simc_place = SIMC_Place.by_id(self.simc_id)
            except KeyError:
                reporting.output_msg("errors", 
                        u"wartość teryt:simc nie istnieje w bazie SIMC")
            if self.simc_id in self._by_simc_id:
                reporting.output_msg("errors", 
                    u"Powtórzony kod SIMC w danych OSM: %r (%r and %r)" % (
                    self.simc_id, self, self._by_simc_id[self.simc_id]), self)
            else:
                self._by_simc_id[self.simc_id] = self
       
        if self.simc_place:
            gmina = self.simc_place.gmina 
            if (self.gmina and gmina != self.gmina
                    or self.powiat and gmina.powiat != self.powiat
                    or self.wojewodztwo 
                            and gmina.wojewodztwo != self.wojewodztwo):
                reporting.output_msg("errors", 
                        u"%s: teryt:simc nie zgadza się z położeniem wynikającym z innych tagów"
                        u" (%r != %r | %r != %r | %r != %r)" 
                        % (self, self.gmina, gmina, self.powiat, gmina.powiat,
                            self.wojewodztwo, gmina.wojewodztwo))
            else:    
                self.gmina = self.simc_place.gmina
                self.powiat = self.simc_place.powiat
                self.wojewodztwo = self.simc_place.wojewodztwo
            reporting.output_msg("preassigned", 
                    u"%r ma już przypisany rekord SIMC: %r" 
                                % (self, self.simc_place), self)
        

        if "teryt:terc" in tags:
            try:
                self.terc_id = tags["teryt:terc"]
            except:
                reporting.output_msg("errors", u"Błędny kod teryt:terc: %r"
                                                    % (tags["teryt:terc"],))

        if self.terc_id:
            self.terc_id = tags["teryt:terc"]
            if self.simc_place and self.terc_id != self.simc_place.terc_id:
                reporting.output_msg("errors", u"teryt:terc nie zgadza się z teryt:simc")
            else:
                try:
                    gmina = Gmina.by_code(self.terc_id)
                    if (self.gmina and gmina != self.gmina
                            or self.powiat and gmina.powiat != self.powiat
                            or self.wojewodztwo 
                                and gmina.wojewodztwo != self.wojewodztwo):
                        reporting.output_msg("errors", 
                                u"%s: teryt:terc nie zgadza się"
                                u" z położeniem wynikającym z innych tagów"
                                u" (%r != %r | %r != %r | %r != %r)" 
                                % (self, self.gmina, gmina, self.powiat, gmina.powiat,
                                    self.wojewodztwo, gmina.wojewodztwo))
                    if gmina and not self.gmina:
                        self.gmina = gmina
                        self.powiat = gmina.powiat
                        self.wojewodztwo = gmina.wojewodztwo
                except KeyError:
                    pass
        self._by_id[self.id] = self
        if self.name:
            add_to_list_dict(self._by_name, self.name.lower(), self)
        add_to_list_dict(self._by_type, self.type, self)
Example #2
0
def match_names(pass_no, places_to_match, grid = None):
    reporting = Reporting()
    places_count = len(places_to_match)
    if grid:
        reporting.progress_start(
                u"Dopasowywanie nazw %i miejsc, przebieg %i, z siatką %s"
                        % (places_count, pass_no, grid), places_count)
    else:
        reporting.progress_start(
                u"Dopasowywanie nazw %i miejsc, przebieg %i"
                        % (places_count, pass_no), places_count)
    osm_matched = set()
    simc_matched = set()
    places = [ (str(p), p) for p in places_to_match ]
    for name, osm_place in places:
        reporting.progress()
        if osm_place.name is None:
            reporting.output_msg("errors", u"%r: brak nazwy" % (osm_place,), osm_place)
            continue

        # Find matching entry in SIMC
        try:
            matching_simc_places = SIMC_Place.by_name(osm_place.name)
        except KeyError:
            reporting.output_msg("not_found", u"%s: nie znaleziono w TERYT" 
                                                    % (osm_place,), osm_place)
            places_to_match.remove(osm_place)
            continue
        simc_places = [place for place in matching_simc_places 
                                if place.type == osm_place.normalized_type
                                    and place.osm_place is None]
        if not simc_places:
            types_found = [ place.type for place in matching_simc_places ]
            reporting.output_msg("bad_type", u"%s: nie znalezionow w TERYT"
                        u" obiektu właściwego typu (%r, znaleziono: %r)" % (
                            osm_place, osm_place.type, types_found), osm_place)
            continue

        cell = None
        if grid:
            try:
                cell = grid.get_cell(osm_place)
            except KeyError:
                pass
        if cell:
            simc_places = [ p for p in simc_places if p.powiat in cell.powiaty ]
            if len(simc_places) > 1:
                simc_places = [ p for p in simc_places if p.gmina in cell.gminy ]
            if not simc_places:
                reporting.output_msg("not_found",
                        u"%s: nie znaleziono w TERYT miejsca"
                        u" pasującego do komórki %s" % (osm_place, cell),
                        osm_place)
                continue

        if len(simc_places) > 1:
            if grid:
                reporting.output_msg("ambigous%i" % (pass_no,), 
                        u"%s z OSM pasuje do wielu obiektów"
                        u" SIMC w komórce %s: %s" % (osm_place, cell,
                            u", ".join([str(p) for p in simc_places])), 
                                                                osm_place)
            else:
                reporting.output_msg("ambigous%i" % (pass_no,), 
                        u"%s z OSM pasuje do wielu obiektów w SIMC: %s" % (osm_place,
                            u", ".join([str(p) for p in simc_places])), osm_place)
            continue
        simc_place = simc_places[0]

        # now check if reverse assignment is not ambigous
        matching_osm_places = OSM_Place.by_name(simc_place.name)
        confl_osm_places = []
        for place in matching_osm_places:
            if place is osm_place:
                continue
            if cell:
                try:
                    g_cell = grid.get_cell(place) 
                except KeyError:
                    g_cell = None
                if g_cell is not cell:
                    continue
            if place.gmina and place.gmina != simc_place.gmina:
                continue
            if place.powiat and place.powiat != simc_place.powiat:
                continue
            if place.wojewodztwo and place.wojewodztwo != simc_place.wojewodztwo:
                continue
            confl_osm_places.append(place)

        if confl_osm_places:
            reporting.output_msg("ambigous%i" % (pass_no,), 
                        u"%s z SIMC pasuje do wielu obiektów w OMS: %s" % (simc_place,
                            ", ".join([str(p) for p in confl_osm_places])), osm_place)
            continue
        
        if simc_place.osm_place:
            reporting.output_msg("ambigous%i" % (pass_no,), 
                    u"%s z SIMC ma już przypisany obiekt OSM: %s" % (
                        simc_place, simc_place.osm_place), osm_place)

        # good match
        osm_place.assign_simc(simc_place)
        simc_place.assign_osm(osm_place)

        reporting.output_msg("match", u"%s w OSM to %s w SIMC" % (osm_place, simc_place), osm_place) 
        osm_matched.add(osm_place)
        simc_matched.add(simc_place)
        places_to_match.remove(osm_place)

    reporting.progress_stop()
    reporting.output_msg("stats", 
            u"Przebieg %i: znaleziono w SIMC %i z %i miejscowości OSM" % (
                                    pass_no, len(osm_matched), places_count))
    return osm_matched, simc_matched