From 4798e764adf21e259e6738eaaf18c0fa7ae18bac Mon Sep 17 00:00:00 2001 From: Étienne Loks Date: Thu, 1 Sep 2022 19:15:02 +0200 Subject: Geo: display related items on sheet --- ishtar_common/models_common.py | 101 ++--- ishtar_common/static/js/ishtar-map.js | 169 +++++-- .../templates/ishtar/blocks/sheet_map.html | 98 ++--- ishtar_common/tests.py | 483 --------------------- ishtar_common/utils.py | 4 + 5 files changed, 211 insertions(+), 644 deletions(-) (limited to 'ishtar_common') diff --git a/ishtar_common/models_common.py b/ishtar_common/models_common.py index 83897768c..5d3cdbec2 100644 --- a/ishtar_common/models_common.py +++ b/ishtar_common/models_common.py @@ -48,6 +48,7 @@ from ishtar_common.utils import ( pgettext_lazy, get_image_path, human_date, + reverse_list_coordinates ) from simple_history.models import HistoricalRecords as BaseHistoricalRecords from simple_history.signals import ( @@ -2358,34 +2359,53 @@ class GeoVectorData(Imported, OwnPerms): profile = get_current_profile() return profile.srs - def get_geo_items(self, get_polygons, rounded=5): - label = self.label if hasattr(self, "label") else self.short_label - dct = {"type": "Feature", "geometry": {}, "properties": {"label": label}} - if get_polygons: + def get_geo_items(self, rounded=5): + dct = {"type": "Feature", "geometry": {}, "properties": {"label": str(self)}} + if self.multi_polygon: list_coords = [] - if self.multi_polygon: - for polygon in self.multi_polygon: - list_coords.append([]) - for linear_ring in range(len(polygon)): - list_coords[-1].append([]) - for coords in polygon[linear_ring].coords: - point_2d = Point( - coords[0], coords[1], srid=self.multi_polygon.srid - ) - list_coords[-1][linear_ring].append( - self.convert_coordinates(point_2d, rounded) - ) + for polygon in self.multi_polygon: + list_coords.append([]) + for linear_ring in range(len(polygon)): + list_coords[-1].append([]) + for coords in polygon[linear_ring].coords: + point_2d = Point( + coords[0], coords[1], srid=self.multi_polygon.srid + ) + list_coords[-1][linear_ring].append( + self.convert_coordinates(point_2d, rounded) + ) dct["geometry"]["type"] = "MultiPolygon" dct["geometry"]["coordinates"] = list_coords + elif self.multi_points: + list_coords = [] + for coords in self.multi_points: + point_2d = Point( + coords.x, coords.y, srid=self.multi_points.srid + ) + list_coords.append( + self.convert_coordinates(point_2d, rounded) + ) + dct["geometry"]["type"] = "MultiPoint" + dct["geometry"]["coordinates"] = list_coords + elif self.multi_line: + list_coords = [] + for idx, line in enumerate(self.multi_line): + if not idx: + list_coords.append([]) + for coords in line: + point_2d = Point( + coords.x, coords.y, srid=self.multi_points.srid + ) + list_coords[-1].append( + self.convert_coordinates(point_2d, rounded) + ) + dct["geometry"]["type"] = "MultiLine" + dct["geometry"]["coordinates"] = list_coords else: dct["geometry"]["type"] = "Point" - coords = self.display_coordinates() + coords = self.display_coordinates(srid=4326) if coords: dct["geometry"]["coordinates"] = coords - elif self.multi_polygon: - dct["geometry"]["coordinates"] = self.convert_coordinates( - self.multi_polygon.centroid, rounded - ) else: return {} return dct @@ -3537,41 +3557,10 @@ class GeoItem(GeographicItem): if self.multi_polygon_source == "P" and self.multi_polygon: return self.multi_polygon, self.multi_polygon_source_item - def get_geo_items(self, get_polygons, rounded=True): - try: - label = self.label - except: - label = self.short_label - dict = {"type": "Feature", "geometry": {}, "properties": {"label": label}} - if get_polygons: - list_coords = [] - if self.multi_polygon: - for polygon in self.multi_polygon: - list_coords.append([]) - for linear_ring in range(len(polygon)): - list_coords[-1].append([]) - for coords in polygon[linear_ring].coords: - point_2d = Point( - coords[0], coords[1], srid=self.multi_polygon.srid - ) - list_coords[-1][linear_ring].append( - self.convert_coordinates(point_2d, rounded) - ) - dict["geometry"]["type"] = "MultiPolygon" - dict["geometry"]["coordinates"] = list_coords - else: - dict["geometry"]["type"] = "Point" - if self.point_2d: - try: - x, y = self.display_coordinates - dict["geometry"]["coordinates"] = [x, y] - except ValueError: - dict["geometry"]["coordinates"] = [] - else: - dict["geometry"]["coordinates"] = self.convert_coordinates( - self.multi_polygon.centroid, rounded - ) - return dict + def get_geo_items(self, rounded=5): + if not self.main_geodata: + return {} + return self.main_geodata.get_geo_items(rounded) def convert_coordinates(self, point_2d, rounded): profile = get_current_profile() diff --git a/ishtar_common/static/js/ishtar-map.js b/ishtar_common/static/js/ishtar-map.js index 95f8ad3e3..a0709c059 100644 --- a/ishtar_common/static/js/ishtar-map.js +++ b/ishtar_common/static/js/ishtar-map.js @@ -32,7 +32,7 @@ var fetching_msg = "Fetching data..."; var base_maps_msg = "Base maps"; var _map_submit_search = function(query_vars, name, source, extra){ - if (!extra) extra = "default"; + if (!extra) extra = "default"; var modal_base_text = $('.modal-progress .modal-header').html(); $('.modal-progress .modal-header').html(fetching_msg); $('.modal-progress').modal('show'); @@ -175,7 +175,7 @@ var TrackPositionControl = (function (Control) { /* base layers */ var source_osm = function(options){ - options["source"] = new ol.source.OSM(); + options["source"] = new ol.source.OSM(); return new ol.layer.Tile(options); }; @@ -207,19 +207,19 @@ var ign_resolutions = [ var ign_key = "essentiels"; var source_ign = function(options){ - options["source"] = new ol.source.WMTS({ - url: "https://wxs.ign.fr/" + ign_key + "/geoportail/wmts", - layer: "ORTHOIMAGERY.ORTHOPHOTOS", - matrixSet: "PM", - format: "image/jpeg", - style: "normal", - tileGrid : new ol.tilegrid.WMTS({ - origin: [-20037508,20037508], // topLeftCorner - resolutions: ign_resolutions, // résolutions - matrixIds: ["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19"] // ids des TileMatrix - }) - }); - return new ol.layer.Tile(options); + options["source"] = new ol.source.WMTS({ + url: "https://wxs.ign.fr/" + ign_key + "/geoportail/wmts", + layer: "ORTHOIMAGERY.ORTHOPHOTOS", + matrixSet: "PM", + format: "image/jpeg", + style: "normal", + tileGrid : new ol.tilegrid.WMTS({ + origin: [-20037508,20037508], // topLeftCorner + resolutions: ign_resolutions, // résolutions + matrixIds: ["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19"] // ids des TileMatrix + }) + }); + return new ol.layer.Tile(options); } var default_map_layers = { @@ -230,14 +230,14 @@ var default_map_layers = { var get_layers = function(layers){ if (!layers){ layers = [ - { - 'type': 'ign', - 'options': {'title': "IGN aérien (France)", 'visible': false, "type": 'base'} - }, - { - 'type': 'osm', - 'options': {'title': "OpenStreetMap", 'visible': true, "type": 'base'} - } + { + 'type': 'ign', + 'options': {'title': "IGN aérien (France)", 'visible': false, "type": 'base'} + }, + { + 'type': 'osm', + 'options': {'title': "OpenStreetMap", 'visible': true, "type": 'base'} + } ]; } var ol_layers = []; @@ -627,12 +627,12 @@ var initialize_base_map = function(map_id, layers){ center = wkt_format.readGeometry(map_default_center).getCoordinates(); map_layers[map_id] = [ - new ol.layer.Group({ - title: base_maps_msg, - visible: true, - layers: get_layers(layers) - }) - ]; + new ol.layer.Group({ + title: base_maps_msg, + visible: true, + layers: get_layers(layers) + }) + ]; map_view[map_id] = new ol.View({ projection: view_projection, @@ -661,14 +661,14 @@ var initialize_base_map = function(map_id, layers){ view: map_view[map_id] }); var layer_switcher = new ol.control.LayerSwitcher({ - tipLabel: 'Légende', - groupSelectStyle: 'children' - }); - map[map_id].addControl(layer_switcher); + tipLabel: 'Légende', + groupSelectStyle: 'children' + }); + map[map_id].addControl(layer_switcher); } var redraw_map = function(map_id, layers){ - if (!map || !map[map_id]) return; + if (!map || !map[map_id]) return; map[map_id].setTarget(null); map[map_id] = null; initialize_base_map(map_id, layers); @@ -705,7 +705,6 @@ var display_map = function(map_id, points, lines_and_polys, layers){ var display_points = function(map_id, points, first_init){ if (!points) return; point_features[map_id] = geojson_format.readFeatures(points); - console.log(708); if (!cluster_source[map_id]){ enable_clustering(map_id); } else { @@ -736,7 +735,6 @@ var display_lines_and_polys = function(map_id, lines_and_polys, first_init){ style: get_vector_style }); - console.log(738); map[map_id].addLayer(vector_layer[map_id]); if (first_init && lines_and_polys.features && lines_and_polys.features.length){ map_view[map_id].fit(vector_source[map_id].getExtent()); @@ -896,3 +894,102 @@ var base_features_type = function (id) { } else { return 'Point and MultiPolygon' } } + +var _geo_points = new Array(); +var _geo_other = new Array(); + +var _point_list_crs = new Array(); +var _other_list_crs = new Array(); +var _point_list_finds = new Array(); +var _other_list_finds = new Array(); + +const _refresh_map_crs = function(idx) { + if (idx in _geo_points && idx in _point_list_crs){ + for (const feat of _point_list_crs[idx]){ + _geo_points[idx]["features"].push(feat); + } + } + if (idx in _geo_other && idx in _other_list_crs){ + for (const feat of _other_list_crs[idx]){ + _geo_other[idx]["features"].push(feat); + } + } +} +const _refresh_map_finds = function(idx) { + if (idx in _geo_points && idx in _point_list_finds){ + for (const feat of _point_list_finds[idx]){ + _geo_points[idx]["features"].push(feat); + } + } + if (idx in _geo_other && idx in _other_list_finds){ + for (const feat of _other_list_finds[idx]){ + _geo_other[idx]["features"].push(feat); + } + } +} + +const refresh_map_finds_crs = function(url, attrs, idx, crs_check, find_check) { + if (idx in _point_list_finds){ + if (crs_check) _refresh_map_crs(idx); + if (find_check) _refresh_map_finds(idx); + return; + } + _point_list_crs[idx] = new Array(); + _other_list_crs[idx] = new Array(); + _point_list_finds[idx] = new Array(); + _other_list_finds[idx] = new Array(); + $.get(url, attrs).done( + function(data) { + data = JSON.parse(data); + if (data) { + if (data["context-records"] && data["context-records"]["features"]) { + for (let feat of data["context-records"]["features"]){ + if (feat["geometry"]["type"] === 'Point' || + feat["geometry"]["type"] === 'MultiPoint'){ + _point_list_crs[idx].push(feat); + } else { + _other_list_crs[idx].push(feat); + } + } + if (crs_check) _refresh_map_crs(idx); + } + if (data["finds"] && data["finds"]["features"]) { + for (let feat of data["finds"]["features"]){ + if (feat["geometry"]["type"] === 'Point' || + feat["geometry"]["type"] === 'MultiPoint'){ + _point_list_finds[idx].push(feat); + } else { + _other_list_finds[idx].push(feat); + } + } + if (finds_check) _refresh_map_finds(idx); + } + } + } + ); +} + + +const refresh_map = function(idx, geodata_list, url, attrs) { + _geo_points[idx] = {"type": "FeatureCollection", "features": []}; + _geo_other[idx] = {"type": "FeatureCollection", "features": []}; + for (const key in geodata_list){ + if ($("#map-ol-" + key).prop('checked')){ + let geo_type = geodata_list[key][0]; + let geojson = geodata_list[key][1]; + if (geo_type === 'POINT'){ + Array.prototype.push.apply( + _geo_points[idx]["features"], geojson["features"]); + } else { + Array.prototype.push.apply( + _geo_other[idx]["features"], geojson["features"]); + } + } + } + if (url && attrs){ + let find_check = $("#map-ol-" + idx + "-finds").prop('checked'); + let crs_check = $("#map-ol-" + idx + "-crs").prop('checked'); + refresh_map_finds_crs(url, attrs, idx, crs_check, find_check); + } +} + diff --git a/ishtar_common/templates/ishtar/blocks/sheet_map.html b/ishtar_common/templates/ishtar/blocks/sheet_map.html index 16e014b49..11780ae8a 100644 --- a/ishtar_common/templates/ishtar/blocks/sheet_map.html +++ b/ishtar_common/templates/ishtar/blocks/sheet_map.html @@ -10,6 +10,7 @@ {% endwith %} {% endif %} diff --git a/ishtar_common/tests.py b/ishtar_common/tests.py index dfae6c164..25d4d8e85 100644 --- a/ishtar_common/tests.py +++ b/ishtar_common/tests.py @@ -2839,489 +2839,6 @@ class IshtarBasicTest(TestCase): self.assertEqual(town.cached_label, "Sin City - 99 (2050)") -class GeomaticTest(TestCase): - fixtures = FIND_FIXTURES - - def setUp(self): - profile = models.get_current_profile() - profile.mapping = True - profile.save() - - def test_post_save_point(self): - class FakeGeomaticObject(object): - _meta = models.GeoItem._meta - - def __init__( - self, x, y, z, spatial_reference_system, point=None, point_2d=None - ): - self.x = x - self.y = y - self.z = z - self.spatial_reference_system = spatial_reference_system - self.point_source = "P" - self.point_source_item = "" - self.point = point - self.point_2d = point_2d - self.pk = 42 - - def save(self, *args, **kwargs): - pass - - srs, __ = models.SpatialReferenceSystem.objects.get_or_create( - srid=4326, defaults={"label": "WGS84", "txt_idx": "wgs84"} - ) - obj = FakeGeomaticObject(x=2, y=3, z=4, spatial_reference_system=srs) - self.assertIsNone(obj.point_2d) - post_save_geo(FakeGeomaticObject, instance=obj) - self.assertIsNotNone(obj.point_2d) - self.assertIsNotNone(obj.point) - - @staticmethod - def create_cr_with_bfs(ope, geom_ope, geom_cr, list_geom_bf, label_cr): - Operation = apps.get_model("archaeological_operations", "Operation") - ContextRecord = apps.get_model( - "archaeological_context_records", "ContextRecord" - ) - Find = apps.get_model("archaeological_finds", "Find") - BaseFind = apps.get_model("archaeological_finds", "BaseFind") - - wgs84 = models_common.SpatialReferenceSystem.objects.get(srid=4326) - poly_ope = ( - "MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2))," - "((6 3,9 2,9 4,6 3)))" - ) - point_ope = GEOSGeometry("POINT({} {} {})".format(3.8, 3, 1), srid=4326) - point_2d_ope = GEOSGeometry("POINT({} {})".format(3.8, 3), srid=4326) - xy_ope = 3.8, 3 - poly_cr = ( - "MULTIPOLYGON(((2 1,5 1,5 5,1 5,2 1),(2 2,2 3,3 3,3 2,2 2))," - "((6 3,9 2,9 4,6 3)))" - ) - point_cr = GEOSGeometry("POINT({} {} {})".format(3.9, 3, 1), srid=4326) - point_2d_cr = GEOSGeometry("POINT({} {})".format(3.9, 3), srid=4326) - xy_cr = 3.9, 3 - poly_bf = ( - "MULTIPOLYGON(((2 1,4 1,4 4,1 4,2 1),(2 2,2 3,3 3,3 2,2 2))," - "((6 3,9 2,9 4,6 3)))" - ) - point_bf = GEOSGeometry("POINT({} {} {})".format(3.9, 2.9, 1), srid=4326) - point_2d_bf = GEOSGeometry("POINT({} {})".format(3.9, 2.9), srid=4326) - xy_bf = 3.9, 2.9 - - pks = {} - - ope.multi_polygon = "SRID=4326;" + poly_ope - ope.multi_polygon_source = "P" - ope.multi_polygon_source_item = str(ope._meta.verbose_name) - ope.spatial_reference_system = wgs84 - if geom_ope == "Point": - ope.point = point_ope - ope.point_source = "P" - ope.point_source_item = str(ope._meta.verbose_name) - ope.x, ope.y = xy_ope - ope.point_2d = point_2d_ope - ope.save() # needs 2 saves because point_2d is none for multi_polygon - ope = Operation.objects.get(pk=ope.pk) - ope.save() - ope = Operation.objects.get(pk=ope.pk) - - default = { - "label": label_cr, - "operation": ope, - } - cr = ContextRecord.objects.create(**default) - cr = ContextRecord.objects.get(pk=cr.pk) - cr.multi_polygon = "SRID=4326;" + poly_cr - cr.multi_polygon_source = "P" - cr.multi_polygon_source_item = str(cr._meta.verbose_name) - cr.spatial_reference_system = wgs84 - if geom_cr == "Point": - cr.point = point_cr - cr.point_source = "P" - cr.point_source_item = str(cr._meta.verbose_name) - cr.x, cr.y = xy_cr - cr.point_2d = point_2d_cr - cr.save() - cr = ContextRecord.objects.get(pk=cr.pk) - pks[label_cr] = cr.pk - - bfs = [] - for bf_geom in list_geom_bf: - default = { - "label": "Find " + bf_geom + " from " + label_cr, - "context_record": cr, - } - bf = BaseFind.objects.create(**default) - bf.multi_polygon = "SRID=4326;" + poly_bf - bf.multi_polygon_source = "P" - bf.multi_polygon_source_item = str(bf._meta.verbose_name) - bf.spatial_reference_system = wgs84 - if bf_geom == "Point": - bf.point = point_bf - bf.point_source = "P" - bf.point_source_item = str(bf._meta.verbose_name) - bf.x, bf.y = xy_bf - bf.point_2d = point_2d_bf - bf.save() - bf = BaseFind.objects.get(pk=bf.pk) - bfs.append(bf) - pks[default["label"]] = bf.pk - - find = Find.objects.create() - find.base_finds.add(bf) - find.save() - return pks - - @staticmethod - def setUpDefaultGeoItems(user): - from archaeological_operations.tests import create_operation - - ope1 = create_operation(user) - ope2 = create_operation(user) - pks = {"Pt": ope1.pk, "Poly": ope2.pk} - - pks.update( - GeomaticTest.create_cr_with_bfs( - ope1, "Point", "Point", ["Polygon", "Point"], "CR Pt Pt" - ) - ) - pks.update( - GeomaticTest.create_cr_with_bfs( - ope1, "Point", "Polygon", ["Polygon", "Point"], "CR Pt Poly" - ) - ) - pks.update( - GeomaticTest.create_cr_with_bfs( - ope2, "Polygon", "Point", ["Polygon", "Point"], "CR Poly Pt" - ) - ) - pks.update( - GeomaticTest.create_cr_with_bfs( - ope2, "Polygon", "Polygon", ["Polygon", "Point"], "CR Poly Poly" - ) - ) - - geom_ope = [ - [ - [ - [[1, 1], [5, 1], [5, 5], [1, 5], [1, 1]], - [[2, 2], [2, 3], [3, 3], [3, 2], [2, 2]], - ], - [[[6, 3], [9, 2], [9, 4], [6, 3]]], - ], - [3.86111, 3.02778], - [3.8, 3], - ] - geom_cr = [ - [ - [ - [[2, 1], [5, 1], [5, 5], [1, 5], [2, 1]], - [[2, 2], [2, 3], [3, 3], [3, 2], [2, 2]], - ], - [[[6, 3], [9, 2], [9, 4], [6, 3]]], - ], - [4.17708, 3.11458], - [3.9, 3], - ] - geom_bf = [ - [ - [ - [[2, 1], [4, 1], [4, 4], [1, 4], [2, 1]], - [[2, 2], [2, 3], [3, 3], [3, 2], [2, 2]], - ], - [[[6, 3], [9, 2], [9, 4], [6, 3]]], - ], - [4.42105, 2.73684], - [3.9, 2.9], - ] - return [geom_ope, geom_cr, geom_bf], pks - - @staticmethod - def pt_coords_from_label(label, geoms): - if label[:2] == "Pt": - return geoms[0][2], True - if label[:4] == "Poly": - return geoms[0][1], False - if label[:2] == "CR": - if label[-2:] == "Pt": - return geoms[1][2], True - if label[3:5] == "Pt": - return geoms[0][2], True - return geoms[1][1], False - if label[5:10] == "Point": - return geoms[2][2], True - # label has shape Find Polygon from CR xxx xxx - if label[-2:] == "Pt": - return geoms[1][2], True - if label[21:23] == "Pt": - return geoms[0][2], True - return geoms[2][1], False - - def assertPt(self, item, geom): - self.assertEqual(item.multi_polygon.coords, geom[0].coords) - self.assertEqual(item.point_2d.coords, geom[2].coords) - - def assertPoly(self, item, geom, real_point=None): - self.assertEqual(item.multi_polygon.coords, geom[0].coords) - if real_point: - self.assertEqual((round(item.x, 5), round(item.y, 5)), real_point.coords) - else: - self.assertEqual((round(item.x, 5), round(item.y, 5)), geom[1].coords) - - def test_setUpDefaultGeoItems(self): - # TODO: remove and clean - Operation = apps.get_model("archaeological_operations", "Operation") - - """ - username, password, user = create_superuser() - base_geoms, pks = self.setUpDefaultGeoItems(user) - geoms = [] - for geom in base_geoms: - poly = GEOSGeometry( - json.dumps({"type": "MultiPolygon", "coordinates": geom[0]}) - ) - centr = GEOSGeometry(json.dumps({"type": "Point", "coordinates": geom[1]})) - pt = GEOSGeometry(json.dumps({"type": "Point", "coordinates": geom[2]})) - geoms.append([poly, centr, pt]) - ope_pt = Operation.objects.get(pk=pks["Pt"]) - self.assertPt(ope_pt, geoms[0]) - ope_poly = Operation.objects.get(pk=pks["Poly"]) - self.assertPoly(ope_poly, geoms[0]) - - cr_poly_poly = ope_poly.context_record.get(pk=pks["CR Poly Poly"]) - self.assertPoly(cr_poly_poly, geoms[1]) - cr_poly_pt = ope_poly.context_record.get(pk=pks["CR Poly Pt"]) - self.assertPt(cr_poly_pt, geoms[1]) - cr_pt_poly = ope_pt.context_record.get(pk=pks["CR Pt Poly"]) - self.assertPoly(cr_pt_poly, geoms[1], geoms[0][2]) - cr_pt_pt = ope_pt.context_record.get(pk=pks["CR Pt Pt"]) - self.assertPt(cr_pt_pt, geoms[1]) - - self.assertPt( - cr_pt_pt.base_finds.get(pk=pks["Find Point from CR Pt Pt"]), geoms[2] - ) - self.assertPoly( - cr_pt_pt.base_finds.get(pk=pks["Find Polygon from CR Pt Pt"]), - geoms[2], - geoms[1][2], - ) - self.assertPt( - cr_poly_pt.base_finds.get(pk=pks["Find Point from CR Poly Pt"]), geoms[2] - ) - self.assertPoly( - cr_poly_pt.base_finds.get(pk=pks["Find Polygon from CR Poly Pt"]), - geoms[2], - geoms[1][2], - ) - self.assertPt( - cr_pt_poly.base_finds.get(pk=pks["Find Point from CR Pt Poly"]), geoms[2] - ) - self.assertPoly( - cr_pt_poly.base_finds.get(pk=pks["Find Polygon from CR Pt Poly"]), - geoms[2], - geoms[0][2], - ) - self.assertPt( - cr_poly_poly.base_finds.get(pk=pks["Find Point from CR Poly Poly"]), - geoms[2], - ) - self.assertPoly( - cr_poly_poly.base_finds.get(pk=pks["Find Polygon from CR Poly Poly"]), - geoms[2], - ) - """ - - @staticmethod - def geojson_geo_items(geoms, pks, test_get_geo_items=False): - Operation = apps.get_model("archaeological_operations", "Operation") - ContextRecord = apps.get_model( - "archaeological_context_records", "ContextRecord" - ) - BaseFind = apps.get_model("archaeological_finds", "BaseFind") - - cache_dics_t, cache_dics_f = {}, {} - res = {} - - def finds_first(x): - if x[:2] == "CR": - return 0 - if x[:4] == "Find": - return -1 - else: - return 1 - - labels = list(pks.keys()) - labels.sort(key=finds_first) - for label in labels: - pk = pks[label] - pt_coords, precise = GeomaticTest.pt_coords_from_label(label, geoms) - if label[:4] == "Find": - dic_t = { - "type": "Feature", - "geometry": {"type": "MultiPolygon", "coordinates": geoms[2][0]}, - "properties": {"label": label}, - } - dic_f = { - "type": "Feature", - "geometry": { - "type": "Point", - "coordinates": pt_coords, - }, - "properties": {"label": label}, - } - cache_dics_t[label] = dic_t - cache_dics_f[label] = dic_f - if test_get_geo_items: - res_t = BaseFind.objects.get(pk=pk).get_geo_items(get_polygons=True) - res_f = BaseFind.objects.get(pk=pk).get_geo_items( - get_polygons=False - ) - get_pk = "?pk=" - else: - get_polys = dic_t - get_pts = dic_f - - elif label[:2] == "CR": - cache_key = lambda x: "Find " + x + " from " + label - dic_t = { - "type": "Feature", - "geometry": {"type": "MultiPolygon", "coordinates": geoms[1][0]}, - "properties": { - "label": label, - "base-finds": { - "type": "FeatureCollection", - "features": [ - cache_dics_t[cache_key("Polygon")], - cache_dics_t[cache_key("Point")], - ], - }, - }, - } - dic_f = { - "type": "Feature", - "geometry": { - "type": "Point", - "coordinates": pt_coords, - }, - "properties": { - "label": label, - "base-finds": { - "type": "FeatureCollection", - "features": [ - cache_dics_f[cache_key("Polygon")], - cache_dics_f[cache_key("Point")], - ], - }, - }, - } - cache_dics_t[label] = dic_t - cache_dics_f[label] = dic_f - if test_get_geo_items: - res_t = ContextRecord.objects.get(pk=pk).get_geo_items( - get_polygons=True - ) - res_f = ContextRecord.objects.get(pk=pk).get_geo_items( - get_polygons=False - ) - get_pk = "?context_record_pk=" - else: - get_polys = copy.deepcopy(dic_t) - get_polys["properties"]["base-finds"] = [ - cache_key("Polygon"), - cache_key("Point"), - ] - get_pts = copy.deepcopy(dic_f) - get_pts["properties"]["base-finds"] = [ - cache_key("Polygon"), - cache_key("Point"), - ] - else: - real_label = "OA3" - cache_key_prefix = "CR " + label + " " - if label == "Pt": - real_label = "OA2" - dic_t = { - "type": "Feature", - "geometry": {"type": "MultiPolygon", "coordinates": geoms[0][0]}, - "properties": { - "label": real_label, - "context-records": { - "type": "FeatureCollection", - "features": [ - cache_dics_t[cache_key_prefix + "Poly"], - cache_dics_t[cache_key_prefix + "Pt"], - ], - }, - }, - } - dic_f = { - "type": "Feature", - "geometry": { - "type": "Point", - "coordinates": pt_coords, - }, - "properties": { - "label": real_label, - "context-records": { - "type": "FeatureCollection", - "features": [ - cache_dics_f[cache_key_prefix + "Poly"], - cache_dics_f[cache_key_prefix + "Pt"], - ], - }, - }, - } - if test_get_geo_items: - res_t = Operation.objects.get(pk=pk).get_geo_items( - get_polygons=True - ) - res_f = Operation.objects.get(pk=pk).get_geo_items( - get_polygons=False - ) - get_pk = "?operation_pk=" - else: - get_polys = copy.deepcopy(dic_t) - bf_labels = [] - for cr in dic_t["properties"]["context-records"]["features"]: - for bf in cr["properties"]["base-finds"]["features"]: - bf_labels.append(bf["properties"]["label"]) - get_polys["properties"] = { - "context-records": [ - cache_key_prefix + "Poly", - cache_key_prefix + "Pt", - ], - "base-finds": bf_labels, - } - get_pts = copy.deepcopy(dic_f) - bf_labels = [] - for cr in dic_f["properties"]["context-records"]["features"]: - for bf in cr["properties"]["base-finds"]["features"]: - bf_labels.append(bf["properties"]["label"]) - get_pts["properties"] = { - "context-records": [ - cache_key_prefix + "Poly", - cache_key_prefix + "Pt", - ], - "base-finds": bf_labels, - } - - if test_get_geo_items: - res[label] = { - "get_polys": dic_t, - "get_pts": dic_f, - "res_polys": res_t, - "res_pts": res_f, - "get_pk": get_pk, - } - else: - res[label] = { - "get_polys": get_polys, - "get_pts": get_pts, - "precise": precise, - } - return res - - class NewItems(TestCase): fixtures = COMMON_FIXTURES diff --git a/ishtar_common/utils.py b/ishtar_common/utils.py index 2a41ab0aa..a99a40d02 100644 --- a/ishtar_common/utils.py +++ b/ishtar_common/utils.py @@ -2363,3 +2363,7 @@ RE_COORDS = r"(" + RE_NUMBER + r") (" + RE_NUMBER + r")" def reverse_coordinates(wkt): return re.sub(RE_COORDS, r"\2 \1", wkt) + + +def reverse_list_coordinates(lst): + return list(reversed(lst)) \ No newline at end of file -- cgit v1.2.3