def create(self, request):
        # print(request.data)

        layer = Polygon.objects.get(
            polygon_id=request.data['layer_id'])

        polygon = Polygon(
            polygon_id=request.data['centroid'],
            centroid=fromstr("POINT(%s %s)" % tuple(request.data['centroid'].split(','))),
            shape=request.data['shape'],
            address=request.data['address'],
            layer=layer,
            level=Polygon.building,
            zoom=17,
            is_verified=True)
        polygon.save()

        org_type = OrganizationType.objects.get(
            type_id=request.data['org_type'])

        organization = Organization(
            name=request.data['org_name'],
            org_type=org_type)
        organization.save()

        polygon.organizations.add(organization)
def add_org(request):
    print(request.POST)

    layer = Polygon.objects.get(
        polygon_id=request.POST['layer_id'])

    polygon = Polygon(
        polygon_id=request.POST['centroid'],
        centroid=request.POST['centroid'],
        address=request.POST['address'],
        layer=layer,
        level=Polygon.building,
        zoom=17,
        is_verified=True)
    polygon.save()

    org_type = OrganizationType.objects.get(
        type_id=request.POST['org_type'])

    organization = Organization(
        name=request.POST['org_name'],
        org_type=org_type)
    organization.save()

    polygon.organizations.add(organization)

    return HttpResponse(status=201)
Beispiel #3
0
def add_org(request):
    print(request.POST)

    layer = Polygon.objects.get(polygon_id=request.POST['layer_id'])

    polygon = Polygon(
        polygon_id=request.POST['centroid'],
        centroid=fromstr("POINT(%s %s)" %
                         tuple(request.POST['centroid'].split(','))),
        shape=request.POST['shape'],
        address=request.POST['address'],
        layer=layer,
        level=Polygon.building,
        zoom=17,
        is_verified=True)
    polygon.save()

    org_type = OrganizationType.objects.get(type_id=request.POST['org_type'])

    organization = Organization(name=request.POST['org_name'],
                                org_type=org_type)
    organization.save()

    polygon.organizations.add(organization)

    return HttpResponse(status=201)
    def geojson_to_db(geo_json, return_instance=False):

        if geo_json['ctracker_config']['AL'] == 4:
            try:
                default_claim_type = ClaimType.objects.get(name='---')
            except ClaimType.DoesNotExist:
                default_claim_type = ClaimType(name='---')
                default_claim_type.save()

        # Create polygons
        for feature in geo_json['features']:
            try:
                polygon = Polygon.objects.get(
                    polygon_id=feature['properties']['ID'])

            except Polygon.DoesNotExist:
                polygon = Polygon(
                    polygon_id=feature['properties']['ID'],
                    shape=json.dumps(feature['geometry']),
                    centroid=feature['properties']['CENTROID'],
                    address=feature['properties']['ADDRESS'],
                    level=geo_json['ctracker_config']['AL'],
                    zoom=geo_json['ctracker_config']['ZOOM'])

                if feature['properties']['PARENT']:
                    parent = Polygon.objects.get(
                        polygon_id=feature['properties']['PARENT'])
                    polygon.layer = parent

                polygon.save()

            if geo_json['ctracker_config']['AL'] == 4:
                org_names = feature['properties']['ORG_NAMES'].split('|')
                org_types = feature['properties']['ORG_TYPES'].split('|')
                for index, org_name in enumerate(org_names):
                    try:
                        org_obj = Organization.objects.get(
                            name=org_name)
                    except Organization.DoesNotExist:

                        try:
                            org_type = OrganizationType.objects.get(
                                type_id=org_types[index])
                        except OrganizationType.DoesNotExist:
                            org_type = OrganizationType(type_id=org_types[index],
                                                        name=geo_json['ctracker_config']["ORG_TYPES"][org_types[index]])
                            org_type.save()
                            default_claim_type.org_type.add(org_type)

                        org_obj = Organization(
                            name=org_name,
                            org_type=org_type
                        )
                        org_obj.save()
                    except Organization.MultipleObjectsReturned:
                        pass

                    # Link them
                    polygon.organizations.add(org_obj)
Beispiel #5
0
    def geojson_to_db(geo_json):
        layer_info = geo_json['ctracker_config']
        print('Processing %s geojson...' % layer_info['layer_name'])
        try:
            layer = Layer.objects.get(name=layer_info['layer_name'])
        except Layer.DoesNotExist:
            layer = Layer(
                layer_type=getattr(Layer, layer_info['layer_type']),
                name=layer_info['layer_name'],
                is_default=bool(layer_info['set_default']))
            layer.save()

        for feature in geo_json['features']:
            # Create polygon
            try:
                polygon = Polygon.objects.get(
                    polygon_id=feature['properties']['ID'])
            except Polygon.DoesNotExist:
                # Hack to avoid organizations without names
                if not feature['properties']['NAME']:
                    continue

                polygon = Polygon(polygon_id=feature['properties']['ID'],
                                  coordinates=json.dumps(feature['geometry']),
                                  layer=layer)
                polygon.save()

            # Create organization
            # Temporary, fix unknown organization type
            org_type = OrganizationType.objects.get(org_type="0")

            try:
                org_obj = Organization.objects.get(
                    name=feature['properties']['NAME'])
            except Organization.DoesNotExist:
                org_obj = Organization(
                    name=feature['properties']['NAME'],
                    org_type=org_type
                )
                org_obj.save()
            except Organization.MultipleObjectsReturned:
                pass

            # Link them
            polygon.organizations.add(org_obj)

        # Temporary, to add additional organizations
        # to north terminal
        org_type = OrganizationType.objects.get(org_type="0")
        north_terminal = Polygon.objects.get(polygon_id='1296')
        if north_terminal.organizations.all().count() < 3:
            for new_org in ['Довідкова', 'Каси']:
                new_org_obj = Organization(
                    name=new_org,
                    org_type=org_type
                )
                new_org_obj.save()
                north_terminal.organizations.add(new_org_obj)
Beispiel #6
0
    def create(self, request):
        print('yo')

        parent_polygon_id = request.data.get('parent_polygon_id', None)
        polygon_id = request.data.get('polygon_id', None)
        level = request.data.get('level', None)
        centroid = request.data['centroid']
        centroid_pnt = geos.fromstr("POINT(%s %s)" % tuple(centroid.split(',')))

        layer = None
        if parent_polygon_id:
            layer = Polygon.objects.get(polygon_id=parent_polygon_id)
        else:
            districts = Polygon.objects.filter(shape__contains=centroid_pnt,
                                               level=Polygon.district)
            if districts:
                layer = districts[0]

        if not polygon_id:
            polygon_id = centroid

        if not level:
            level = Polygon.building

        polygon = Polygon(
            polygon_id=polygon_id,
            centroid=centroid_pnt,
            shape=request.data.get('shape', None),
            address=request.data['address'],
            layer=layer,
            level=level,
            is_verified=False)
        polygon.save()

        org_type = OrganizationType.objects.get(
            type_id=request.data['org_type'])

        organization = Organization(
            name=request.data['name'],
            org_type=org_type,
            is_verified=False)
        organization.save()

        polygon.organizations.add(organization)

        serializer = self.get_serializer(organization)
        return Response(serializer.data, status=status.HTTP_201_CREATED)
Beispiel #7
0
    def create(self, request):
        print('yo')

        parent_polygon_id = request.data.get('parent_polygon_id', None)
        polygon_id = request.data.get('polygon_id', None)
        level = request.data.get('level', None)
        centroid = request.data['centroid']
        centroid_pnt = geos.fromstr("POINT(%s %s)" %
                                    tuple(centroid.split(',')))

        layer = None
        if parent_polygon_id:
            layer = Polygon.objects.get(polygon_id=parent_polygon_id)
        else:
            districts = Polygon.objects.filter(shape__contains=centroid_pnt,
                                               level=Polygon.district)
            if districts:
                layer = districts[0]

        if not polygon_id:
            polygon_id = centroid

        if not level:
            level = Polygon.building

        polygon = Polygon(polygon_id=polygon_id,
                          centroid=centroid_pnt,
                          shape=request.data.get('shape', None),
                          address=request.data['address'],
                          layer=layer,
                          level=level,
                          is_verified=False)
        polygon.save()

        org_type = OrganizationType.objects.get(
            type_id=request.data['org_type'])

        organization = Organization(name=request.data['name'],
                                    org_type=org_type,
                                    is_verified=False)
        organization.save()

        polygon.organizations.add(organization)

        serializer = self.get_serializer(organization)
        return Response(serializer.data, status=status.HTTP_201_CREATED)
def level_appender(polygon, claims_dict, max_claims_dict):
    if polygon["properties"]["ID"] in claims_dict:
        polygon["properties"]["polygon_claims"] = claims_dict[polygon["properties"]["ID"]]
    else:
        polygon["properties"]["polygon_claims"] = 0

    if 'parent_id' in polygon["properties"] and polygon["properties"]['parent_id'] in max_claims_dict:
        max_claims = max_claims_dict[polygon["properties"]['parent_id']]
    else:
        max_claims = 0

    polygon["properties"]['color'] = Polygon.color_spot(polygon["properties"]["polygon_claims"], max_claims)\
        if polygon["properties"]["polygon_claims"] else 'grey'
Beispiel #9
0
    def create(self, request):
        layer = Polygon.objects.get(polygon_id=request.data['layer_id'])

        polygon = Polygon(
            polygon_id=request.data['centroid'],
            centroid=geos.fromstr("POINT(%s %s)" %
                                  tuple(request.data['centroid'].split(','))),
            shape=request.data['shape'],
            address=request.data['address'],
            layer=layer,
            level=Polygon.building,
            zoom=17,
            is_verified=True)
        polygon.save()

        org_type = OrganizationType.objects.get(
            type_id=request.data['org_type'])

        organization = Organization(name=request.data['org_name'],
                                    org_type=org_type)
        organization.save()

        polygon.organizations.add(organization)
Beispiel #10
0
def level_appender(polygon, claims_dict, max_claims_dict):
    if polygon["properties"]["ID"] in claims_dict:
        polygon["properties"]["polygon_claims"] = claims_dict[
            polygon["properties"]["ID"]]
    else:
        polygon["properties"]["polygon_claims"] = 0

    if 'parent_id' in polygon["properties"] and polygon["properties"][
            'parent_id'] in max_claims_dict:
        max_claims = max_claims_dict[polygon["properties"]['parent_id']]
    else:
        max_claims = 0

    polygon["properties"]['color'] = Polygon.color_spot(polygon["properties"]["polygon_claims"], max_claims)\
        if polygon["properties"]["polygon_claims"] else 'grey'
Beispiel #11
0
    def geojson_to_db(geo_json, return_instance=False):
        centroidPattern = re.compile("(-?\d+(?:\.\d+)?)\D+(-?\d+(?:\.\d+)?)")

        if geo_json['ctracker_config']['AL'] == 4:
            try:
                default_claim_type = ClaimType.objects.get(name='---')
            except ClaimType.DoesNotExist:
                default_claim_type = ClaimType(name='---')
                default_claim_type.save()

                with open(os.path.join(settings.INIT_GEOJSON_FOLDER,
                          'habar.jpg'), 'rb') as x_logo:
                    xabar_file = File(x_logo)

                    xabar = ClaimType(name='Xabar', icon=xabar_file)
                    xabar.save()

        # Create polygons
        for feature in geo_json['features']:
            try:
                polygon = Polygon.objects.get(
                    polygon_id=feature['properties']['ID'])

            except Polygon.DoesNotExist:
                polygon = Polygon(
                    polygon_id=feature['properties']['ID'],
                    shape=json.dumps(feature['geometry']),
                    # centroid=GEOSGeometry('POINT(%s %s)') % (
                    #     feature['properties']['CENTROID'].split(',')),
                    centroid=fromstr("POINT(%s %s)" % centroidPattern.search(
                        feature['properties']['CENTROID']).groups(),
                        srid=4326),
                    address=feature['properties']['ADDRESS'],
                    level=geo_json['ctracker_config']['AL'],
                    zoom=geo_json['ctracker_config']['ZOOM'])

                if feature['properties']['PARENT']:
                    parent = Polygon.objects.get(
                        polygon_id=feature['properties']['PARENT'])
                    polygon.layer = parent

                polygon.save()

            if geo_json['ctracker_config']['AL'] == 4:
                org_names = feature['properties']['ORG_NAMES'].split('|')
                org_types = feature['properties']['ORG_TYPES'].split('|')
                for index, org_name in enumerate(org_names):
                    try:
                        org_obj = Organization.objects.get(
                            name=org_name)
                    except Organization.DoesNotExist:

                        try:
                            org_type = OrganizationType.objects.get(
                                type_id=org_types[index])
                        except OrganizationType.DoesNotExist:
                            org_type = OrganizationType(
                                type_id=org_types[index],
                                name=geo_json['ctracker_config']["ORG_TYPES"][org_types[index]])
                            org_type.save()
                            org_type.claimtype_set.add(
                                default_claim_type, xabar)

                        org_obj = Organization(
                            name=org_name,
                            org_type=org_type
                        )
                        org_obj.save()
                    except Organization.MultipleObjectsReturned:
                        pass

                    # Link them
                    polygon.organizations.add(org_obj)
Beispiel #12
0
    def geojson_to_db(geo_json, return_instance=False):
        centroidPattern = re.compile("(-?\d+(?:\.\d+)?)\D+(-?\d+(?:\.\d+)?)")

        if geo_json['ctracker_config']['AL'] == 4:
            try:
                default_claim_type = ClaimType.objects.get(name='---')
            except ClaimType.DoesNotExist:
                default_claim_type = ClaimType(name='---')
                default_claim_type.save()

            try:
                xabar = ClaimType.objects.get(name='Xabar')
            except ClaimType.DoesNotExist:
                with open(
                        os.path.join(settings.INIT_GEOJSON_FOLDER,
                                     'habar.jpg'), 'rb') as x_logo:
                    xabar_file = File(x_logo)

                    xabar = ClaimType(name='Xabar', icon=xabar_file)
                    xabar.save()

        # Create polygons
        for feature in geo_json['features']:
            try:
                polygon = Polygon.objects.get(
                    polygon_id=feature['properties']['ID'])

            except Polygon.DoesNotExist:
                polygon = Polygon(
                    polygon_id=feature['properties']['ID'],
                    shape=json.dumps(feature['geometry']),
                    # centroid=GEOSGeometry('POINT(%s %s)') % (
                    #     feature['properties']['CENTROID'].split(',')),
                    centroid=fromstr("POINT(%s %s)" % centroidPattern.search(
                        feature['properties']['CENTROID']).groups(),
                                     srid=4326),
                    address=feature['properties']['ADDRESS'],
                    level=geo_json['ctracker_config']['AL'],
                    zoom=geo_json['ctracker_config']['ZOOM'])

                if feature['properties']['PARENT']:
                    parent = Polygon.objects.get(
                        polygon_id=feature['properties']['PARENT'])
                    polygon.layer = parent

                polygon.save()

            if geo_json['ctracker_config']['AL'] == 4:
                org_names = feature['properties']['ORG_NAMES'].split('|')
                org_types = feature['properties']['ORG_TYPES'].split('|')
                for index, org_name in enumerate(org_names):
                    try:
                        org_obj = Organization.objects.get(name=org_name)
                    except Organization.DoesNotExist:

                        try:
                            org_type = OrganizationType.objects.get(
                                type_id=org_types[index])
                        except OrganizationType.DoesNotExist:
                            org_type = OrganizationType(
                                type_id=org_types[index],
                                name=geo_json['ctracker_config']["ORG_TYPES"][
                                    org_types[index]])
                            org_type.save()
                            org_type.claimtype_set.add(default_claim_type,
                                                       xabar)

                        org_obj = Organization(name=org_name,
                                               org_type=org_type)
                        org_obj.save()
                    except Organization.MultipleObjectsReturned:
                        pass

                    # Link them
                    polygon.organizations.add(org_obj)
Beispiel #13
0
    def to_representation(self, data):
        iterable = data.all() if isinstance(data, models.Manager) else data

        polygons = []
        buildings_parents, buildings_ids, buildings_objects = [], [], []
        district_parents, district_ids, district_objects = [], [], []
        area_parents, area_ids, area_objects = [], [], []
        region_ids, region_objects = [], []

        # start = time.time()
        for item in iterable:
            # start_repr = time.time()
            item_obj = self.child.to_representation(item)

            # print('      to representaion', time.time() - start_repr)
            level = item_obj["properties"]['level']
            if level == 4:
                # start_repr = time.time()
                level_separator(item_obj, buildings_parents, buildings_ids,
                                buildings_objects)
                # print('      level_separator', time.time() - start_repr)
            elif level == 3:
                level_separator(item_obj, district_parents, district_ids,
                                district_objects)
            elif level == 2:
                level_separator(item_obj, area_parents, area_ids, area_objects)
            elif level == 1:
                region_ids.append(item_obj["properties"]['ID'])
                region_objects.append(item_obj)
        # print('    separating by levels', time.time() - start)

        # ------------------------------Process buildings ---------------------
        if buildings_ids:
            org_ids = []
            # start = time.time()
            for polygon in buildings_objects:
                for org in polygon["properties"]["organizations"]:
                    if org['id'] not in org_ids:
                        org_ids.append(org['id'])
            # print('    getting org ids', time.time() - start)

            # start = time.time()
            claims_for_orgs = get_sum_for_layers(org_ids, 4)
            # print('    agregating claims(sql)', time.time() - start)

            # start = time.time()
            buildings_max_claims_dict = get_max_for_layers(
                buildings_parents, 4)
            # print('    agregating max claims(sql)', time.time() - start)

            for polygon in buildings_objects:
                for org in polygon["properties"]["organizations"]:
                    if org['id'] in claims_for_orgs:
                        org['claims'] = claims_for_orgs[org['id']]
                    else:
                        org['claims'] = 0

                polygon["properties"]["polygon_claims"] = sum([
                    x['claims'] for x in polygon["properties"]["organizations"]
                ])

                if 'parent_id' in polygon["properties"] and polygon[
                        "properties"]['parent_id'] in buildings_max_claims_dict:
                    max_claims = buildings_max_claims_dict[
                        polygon["properties"]['parent_id']]
                else:
                    max_claims = 0

                polygon["properties"]['color'] = Polygon.color_spot(polygon["properties"]["polygon_claims"], max_claims)\
                    if polygon["properties"]["polygon_claims"] else 'grey'

            polygons += buildings_objects

        # ---------------------- Process districts -----------------------
        if district_ids:

            claims_for_houses = get_sum_for_layers(district_ids, 3)
            district_max_claims_dict = get_max_for_layers(district_parents, 3)
            for polygon in district_objects:
                level_appender(polygon, claims_for_houses,
                               district_max_claims_dict)

            polygons += district_objects

        # ---------------------- Process cities -----------------------
        if area_ids:

            claims_for_areas = get_sum_for_layers(area_ids, 2)
            area_max_claims_dict = get_max_for_layers(area_parents, 2)
            for polygon in area_objects:
                level_appender(polygon, claims_for_areas, area_max_claims_dict)

            polygons += area_objects

        # ---------------------- Process regions -----------------------
        if region_ids:

            claims_for_regions = get_sum_for_layers(region_ids, 1)
            region_max_claims_dict = get_max_for_layers(['root'], 1)
            for polygon in region_objects:
                level_appender(polygon, claims_for_regions,
                               region_max_claims_dict)

            polygons += region_objects

        return polygons
Beispiel #14
0
    def geojson_to_db(geo_json, return_instance=False):

        # Create layer
        layer_info = geo_json['ctracker_config']
        global_org_type = False
        if 'global_org_type' in layer_info:
            try:
                global_org_type = OrganizationType.objects.get(
                    type_id=layer_info['global_org_type'])
            except OrganizationType.DoesNotExist:
                global_org_type = OrganizationType(
                    type_id=layer_info['global_org_type'],
                    name=layer_info['global_org_type_name'])
                global_org_type.save()

        print('Processing %s geojson...' % layer_info['layer_name'])
        try:
            layer = Layer.objects.get(name=layer_info['layer_name'])
        except Layer.DoesNotExist:

            if layer_info['set_default']:
                try:
                    ex_default = Layer.objects.get(is_default=True)
                    ex_default.is_default = False
                    ex_default.save()
                except Layer.DoesNotExist:
                    pass

            layer = Layer(
                layer_type=getattr(Layer, layer_info['layer_type']),
                name=layer_info['layer_name'],
                is_default=bool(layer_info['set_default']),
                zoom=layer_info['zoom'],
                center=json.dumps(layer_info['center']))
            layer.save()

        # Create polygons
        for feature in geo_json['features']:
            try:
                polygon = Polygon.objects.get(
                    polygon_id=feature['properties']['ID'])
            except Polygon.DoesNotExist:
                # Hack to avoid organizations without names
                if not feature['properties']['NAME']:
                    continue

                polygon = Polygon(
                    polygon_id=feature['properties']['ID'],
                    shape=json.dumps(feature['geometry']),
                    centroid=json.dumps([
                        feature['properties']["CEN_LAT"],
                        feature['properties']["CEN_LONG"]]),
                    address=feature['properties']['ADDRESS'],
                    layer=layer)
                polygon.save()

            # Create organization
            # Temporary, fix unknown organization type
            org_type = global_org_type

            polygon_orgs = feature['properties']['NAME'].split('|')
            for org_name in polygon_orgs:
                try:
                    org_obj = Organization.objects.get(
                        name=org_name)
                except Organization.DoesNotExist:
                    org_obj = Organization(
                        name=org_name,
                        org_type=org_type
                    )
                    org_obj.save()
                except Organization.MultipleObjectsReturned:
                    pass

                # Link them
                polygon.organizations.add(org_obj)

        if return_instance:
            return layer
Beispiel #15
0
    def to_representation(self, data):
        iterable = data.all() if isinstance(data, models.Manager) else data

        polygons = []
        buildings_parents, buildings_ids, buildings_objects = [], [], []
        district_parents, district_ids, district_objects = [], [], []
        area_parents, area_ids, area_objects = [], [], []
        region_ids, region_objects = [], []

        # start = time.time()
        for item in iterable:
            # start_repr = time.time()
            item_obj = self.child.to_representation(item)

            # print('      to representaion', time.time() - start_repr)
            level = item_obj["properties"]['level']
            if level == 4:
                # start_repr = time.time()
                level_separator(item_obj, buildings_parents, buildings_ids, buildings_objects)
                # print('      level_separator', time.time() - start_repr)
            elif level == 3:
                level_separator(item_obj, district_parents, district_ids, district_objects)
            elif level == 2:
                level_separator(item_obj, area_parents, area_ids, area_objects)
            elif level == 1:
                region_ids.append(item_obj["properties"]['ID'])
                region_objects.append(item_obj)
        # print('    separating by levels', time.time() - start)

        # ------------------------------Process buildings ---------------------
        if buildings_ids:
            org_ids = []
            # start = time.time()
            for polygon in buildings_objects:
                for org in polygon["properties"]["organizations"]:
                    if org['id'] not in org_ids:
                        org_ids.append(org['id'])
            # print('    getting org ids', time.time() - start)

            # start = time.time()
            claims_for_orgs = get_sum_for_layers(org_ids, 4)
            # print('    agregating claims(sql)', time.time() - start)

            # start = time.time()
            buildings_max_claims_dict = get_max_for_layers(buildings_parents, 4)
            # print('    agregating max claims(sql)', time.time() - start)

            for polygon in buildings_objects:
                for org in polygon["properties"]["organizations"]:
                    if org['id'] in claims_for_orgs:
                        org['claims'] = claims_for_orgs[org['id']]
                    else:
                        org['claims'] = 0

                polygon["properties"]["polygon_claims"] = sum(
                    [x['claims'] for x in polygon["properties"]["organizations"]])

                if 'parent_id' in polygon["properties"] and polygon["properties"]['parent_id'] in buildings_max_claims_dict:
                    max_claims = buildings_max_claims_dict[polygon["properties"]['parent_id']]
                else:
                    max_claims = 0

                polygon["properties"]['color'] = Polygon.color_spot(polygon["properties"]["polygon_claims"], max_claims)\
                    if polygon["properties"]["polygon_claims"] else 'grey'

            polygons += buildings_objects

        # ---------------------- Process districts -----------------------
        if district_ids:

            claims_for_houses = get_sum_for_layers(district_ids, 3)
            district_max_claims_dict = get_max_for_layers(district_parents, 3)
            for polygon in district_objects:
                level_appender(polygon, claims_for_houses, district_max_claims_dict)

            polygons += district_objects

        # ---------------------- Process cities -----------------------
        if area_ids:

            claims_for_areas = get_sum_for_layers(area_ids, 2)
            area_max_claims_dict = get_max_for_layers(area_parents, 2)
            for polygon in area_objects:
                level_appender(polygon, claims_for_areas, area_max_claims_dict)

            polygons += area_objects

        # ---------------------- Process regions -----------------------
        if region_ids:

            claims_for_regions = get_sum_for_layers(region_ids, 1)
            region_max_claims_dict = get_max_for_layers(['root'], 1)
            for polygon in region_objects:
                level_appender(polygon, claims_for_regions, region_max_claims_dict)

            polygons += region_objects

        return polygons