Updated to version 2.13.2

Author: Axel Hörteborn

i18n/GeoDataFarm_sv.qm

@@ -134,10 +134,20 @@ def get_task_data(self: Self) -> dict:
                         continue
             except Exception as e:
                 print(f'error: {e}')
-                return
+                task_names[task_nr] = []
+                continue
+            # Remove rows where both latitude and longitude are 0
+            data_set = data_set[~((data_set['latitude'] == 0) & (data_set['longitude'] == 0))]
+            if len(data_set) == 0:
+                task_names[task_nr] = []
+                continue
             fields = []
+            if len(data_set) < 100:
+                divider = len(data_set)
+            else:
+                divider = 10
             sql = "with start_sel as ("
-            for index, row in data_set.iloc[::int(len(data_set)/10)].iterrows():
+            for index, row in data_set.iloc[::int(len(data_set)/divider)].iterrows():
                 sql +=f"""select field_name from fields where st_intersects(polygon, st_geomfromtext('Point({row["longitude"]} {row["latitude"]})', 4326))
 UNION """
             sql = sql[:-6] + ") select field_name from start_sel group by field_name"
@@ -217,7 +227,11 @@ def populate2(self: Self, res: str="", values: str="") -> None:
         """The end of populate the second table when all data is decoded 
         from the qtask"""
         task_names = self.get_task_data()
-        self.IXB.TWISODataSelect.setRowCount(len(self.tasks_to_include))
+        valids = 0
+        for row in task_names.values():
+            if len(row) > 0:
+                valids += 1
+        self.IXB.TWISODataSelect.setRowCount(valids)
         self.IXB.TWISODataSelect.setColumnCount(4)
         self.IXB.TWISODataSelect.setHorizontalHeaderLabels([self.tr('To include'), self.tr('Date'), self.tr('Field'),
                                                             self.tr('Crops')])
@@ -235,7 +249,7 @@ def populate2(self: Self, res: str="", values: str="") -> None:
             item1 = QtWidgets.QTableWidgetItem('Include')
             item1.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled)
             item1.setCheckState(QtCore.Qt.Checked)
-            self.checkboxes2.append([i, j, item1])
+            self.checkboxes2.append([j, j, item1])
             item2 = QtWidgets.QTableWidgetItem(row[0][1])
             item2.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable)
             field_column = RadioComboBox()
@@ -245,10 +259,10 @@ def populate2(self: Self, res: str="", values: str="") -> None:
             field_column.setCurrentIndex(1)
             crops = QtWidgets.QComboBox()
             self.populate.reload_crops(crops)
-            self.IXB.TWISODataSelect.setItem(i, 0, item1)
-            self.IXB.TWISODataSelect.setItem(i, 1, item2)
-            self.IXB.TWISODataSelect.setCellWidget(i, 2, field_column)
-            self.IXB.TWISODataSelect.setCellWidget(i, 3, crops)
+            self.IXB.TWISODataSelect.setItem(j, 0, item1)
+            self.IXB.TWISODataSelect.setItem(j, 1, item2)
+            self.IXB.TWISODataSelect.setCellWidget(j, 2, field_column)
+            self.IXB.TWISODataSelect.setCellWidget(j, 3, crops)
             self.checkboxes3.append(field_column)
             self.checkboxes4.append(crops)
             self.tasks.append(self.rename_duplicate_columns(self.py_agri.tasks[i]))
@@ -648,7 +662,9 @@ def insert_data(qtask: None, db: DB, data: pd.DataFrame, schema: str, insert_sql
         if suc[2] == 0:
             return False, True, 'No data was found on that field.'
         if schema != 'harvest':
-            create_polygons(db, schema, tbl_name, field)
+            r = create_polygons(db, schema, tbl_name, field)
+        if not suc[0]:
+            return False, True, r[1]
         db.execute_sql(f"DROP TABLE {schema}.temp_table{tsk_nr}")
         if qtask is not None:
             qtask.setProgress(90)

i18n/GeoDataFarm_sv.ts

@@ -635,7 +635,7 @@ def create_table(db: DB, schema: str, heading_row: list[str],
 
 
 def create_polygons(db: DB, schema: str, tbl_name: str, 
-                    field: str) -> None:
+                    field: str) -> list:
     sql = """drop table if exists {schema}.temp_tbl2;
         WITH voronoi_temp2 AS (
         SELECT ST_dump(ST_VoronoiPolygons(ST_Collect(pos))) as vor
@@ -647,9 +647,10 @@ def create_polygons(db: DB, schema: str, tbl_name: str,
         SET polygon = st_multi(ST_Intersection(geom, (select polygon 
             from fields where field_name = '{field}')))
         FROM {schema}.temp_tbl2
-        WHERE st_intersects(pos, geom)""".format(schema=schema, tbl=tbl_name, field=field)
-    db.execute_sql(sql)
+        WHERE st_intersects(pos, geom) AND ST_IsValid(geom)""".format(schema=schema, tbl=tbl_name, field=field)
+    res = db.execute_sql(sql, return_failure=True)
     db.execute_sql("drop table if exists {schema}.temp_tbl2;".format(schema=schema))
+    return res
 
 
 def insert_data_to_database(task: str, db: DB, params: dict) -> list[bool]:
@@ -793,12 +794,14 @@ def insert_data_to_database(task: str, db: DB, params: dict) -> list[bool]:
         if task != 'debug':
             task.setProgress(70)
         if schema != 'harvest':
-            create_polygons(db, schema, tbl_name, field)
+            r = create_polygons(db, schema, tbl_name, field)
+            if not r[0]:
+                return [False, r[1], '', 'Creating polygons failed']
         db.create_indexes(tbl_name, focus_col, schema, primary_key=False)
         if params['move']:
             suc = move_points(db, params['move_x'], params['move_y'], tbl_name, task)
             if not suc[0]:
-                True, no_miss_heading, some_wrong_len, sql
+                return [False, no_miss_heading, some_wrong_len, sql]
             else:
                 task = suc[1]
         if task != 'debug':

i18n/geodatafarm_de.qm

@@ -11,7 +11,7 @@ name=GeoDataFarm
 qgisMinimumVersion=2.99
 qgisMaximumVersion=3.99
 description=For farmers, tracking efforts on the field, planing for next season etc.
-version=2.13.1
+version=2.13.2
 author=Axel Horteborn
 email=geodatafarm@gmail.com
 
@@ -25,6 +25,9 @@ repository=https://github.com/axelande/geodatafarm3
 
 # Uncomment the following line and add your changelog:
 changelog=
+  Version 2.13.2 (2025-08-30)
+  - [bug] Added support for missing unit in the isoXML import.
+  - [bug] More isoXML fixes.
   Version 2.13.1 (2025-08-19)
   - [bug] fixed failed import statement
   Version 2.13.0 (2025-08-13)

i18n/geodatafarm_de.ts

@@ -1,37 +1,59 @@
 from typing import TYPE_CHECKING, Never, Self
+import os
+import xml.etree.ElementTree as ET
+
 import matplotlib
 matplotlib.use('Agg')
 if TYPE_CHECKING:
     import matplotlib.figure
     import pyproj.crs.crs
     import shapely.geometry.polygon
-import os
-import xml.etree.ElementTree as ET
-
 import contextily as ctx
 import geopandas as gpd
 import matplotlib.pyplot as plt
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 import pyproj
 from PyQt5 import QtWidgets, QtCore
 from PyQt5.QtWidgets import QMessageBox, QListWidgetItem, QApplication
+from PyQt5.QtGui import QMovie
 from psycopg2 import IntegrityError, InternalError
 from qgis.core import QgsTask
 from shapely import wkt
 from shapely.ops import transform
-from shapely.geometry import Polygon, Point
+from shapely.geometry import Point, Polygon
 
 from ..support_scripts.pyagriculture.agriculture import PyAgriculture
 from ..widgets.find_iso_fields import FindIsoFieldWidget
 
+
+def get_auto_zoom_level(minx, miny, maxx, maxy, max_zoom=17, min_zoom=10):
+    """Estimate a suitable zoom level for the given bounds in meters (EPSG:3857)."""
+    width = abs(maxx - minx)
+    # These thresholds are tuned for Web Mercator (meters)
+    if width < 100:         # < 100 m
+        return max_zoom
+    elif width < 1000:      # < 1 km
+        return max_zoom - 2
+    elif width < 10000:     # < 10 km
+        return max_zoom - 4
+    elif width < 100000:    # < 100 km
+        return max_zoom - 6
+    else:
+        return min_zoom
+
+
 def remove_invalid_points(gdf):
     """Removes rows with invalid latitude and longitude values from the GeoDataFrame."""
     # Define valid ranges for latitude and longitude
     valid_lat_range = (-90, 90)
     valid_lon_range = (-180, 180)
 
     # Filter out rows with invalid latitude and longitude values
-    valid_gdf = gdf[(gdf['latitude'].between(*valid_lat_range)) & (gdf['longitude'].between(*valid_lon_range))]
+    valid_gdf = gdf[
+        (gdf['latitude'].between(*valid_lat_range)) &
+        (gdf['longitude'].between(*valid_lon_range)) &
+        ~((gdf['latitude'] == 0) & (gdf['longitude'] == 0))
+    ]
 
     return valid_gdf
 
@@ -115,6 +137,8 @@ def _extract_coordinates(self: Self, root: ET.Element) -> list[list[str]|Never]:
     def find_from_tasks(self: Self) -> None:
         """Finds additional data from Pyagriculture tasks"""
         self.py_agri = PyAgriculture(os.path.dirname(self.path))
+        self.show_loading_animation() # <-- Show spinner before starting task
+        #self.parent.tsk_mngr.addTask(self.loading_tsk)
         if self.parent.test_mode is False:
             task = QgsTask.fromFunction('Decode binary data', self.py_agri.gather_data, 
                                         most_importants=[],
@@ -124,42 +148,86 @@ def find_from_tasks(self: Self) -> None:
             self.py_agri.gather_data(qtask='debug', most_importants=[])
             self.populate_field_list2()
 
-    def populate_field_list2(self: Self, res: None=None, 
-                             values: None=None) -> None:
+    def clear_layout(self):
+        """Remove all widgets from a given layout."""
+        layout = self.fifw.WShowField.layout()
+        # Stop and remove the loading animation if present
+        if hasattr(self, "movie"):
+            self.movie.stop()
+        if hasattr(self, "loading_label") and self.loading_label in [layout.itemAt(i).widget() for i in range(layout.count())]:
+            layout.removeWidget(self.loading_label)
+            self.loading_label.deleteLater()
+            del self.loading_label
+        if layout is not None:
+            for i in reversed(range(layout.count())):
+                widget = layout.itemAt(i).widget()
+                if widget is not None:
+                    widget.setParent(None)
+
+    def show_loading_animation(self: Self) -> None:
+        """Show a spinning/loading animation in the canvas area."""
+        layout = self.fifw.WShowField.layout()
+        if layout is None:
+            layout = QtWidgets.QVBoxLayout()
+            self.fifw.WShowField.setLayout(layout)
+        else:
+            self.clear_layout()
+        # Create and add the loading animation
+        print('run')
+        self.loading_label = QtWidgets.QLabel()
+        gif_path = os.path.join(os.path.dirname(__file__),"..", "img", "loading.gif")
+        if not os.path.exists(gif_path):
+            self.loading_label.setText("Loading...")
+        else:
+            self.movie = QMovie(gif_path)
+            self.loading_label.setMovie(self.movie)
+            self.movie.start()
+        layout.addWidget(self.loading_label)
+        
+    def populate_field_list2(self: Self, res: None=None, values: None=None) -> None:
         """Populates the field list based on the pyagri tasks."""
+        self.clear_layout()
         self.fifw.LWFields.clear()
         for i, task in enumerate(self.py_agri.tasks):
             if 'longitude' not in task.columns:
                 try:
-                    # Assuming `gdf` is your GeoDataFrame with geometries
-                    extent = task.total_bounds  # Get [min_x, min_y, max_x, max_y]
-
-                    # Create a bounding box polygon
+                    extent = task.total_bounds
                     convex_hull = Polygon([
-                        (extent[0], extent[1]),  # Bottom-left corner (min_x, min_y)
-                        (extent[0], extent[3]),  # Top-left corner (min_x, max_y)
-                        (extent[2], extent[3]),  # Top-right corner (max_x, max_y)
-                        (extent[2], extent[1]),  # Bottom-right corner (max_x, min_y)
-                        (extent[0], extent[1])   # Close the polygon (back to bottom-left)
+                        (extent[0], extent[1]),
+                        (extent[0], extent[3]),
+                        (extent[2], extent[3]),
+                        (extent[2], extent[1]),
+                        (extent[0], extent[1])
                     ])
                 except:
-                    pass
+                    continue
             else:
                 task['geometry'] = task.apply(lambda row: Point(row['longitude'], row['latitude']), axis=1)
                 gdf = gpd.GeoDataFrame(task, geometry='geometry')
                 gdf.set_crs(epsg=4326, inplace=True)
                 gdf = remove_invalid_points(gdf)
-                convex_hull = gdf.unary_union.convex_hull
-            self.fields[f'Task {i}'] = convex_hull.wkt
-            self.fifw.LWFields.addItem(f'Task {i}')
+                convex_hull = gdf.union_all().convex_hull
+
+            # Only create a new polygon if there are at least 3 points left
+            if len(convex_hull.exterior.coords) < 3:
+                continue  # Not enough points for a valid polygon
+
+            name = task.attrs.get('task_name', f'Task {i}')
+            self.fields[name] = convex_hull.wkt
+            self.fifw.LWFields.addItem(name)
 
     def on_item_clicked(self: Self, item: QListWidgetItem) -> None:
         """Handles the event when an item in the field list is clicked."""
         item_name = item.text()
+        self.show_loading_animation()
         if self.current_polygon != '':
             self.save_updated_polygon()
         if item_name != '':
-            self.load_wkt(self.fields[item_name])
+            self.load_wkt(polygon_wkt=self.fields[item_name])
+            #tsk = QgsTask.fromFunction('Load polygon', self.load_wkt, 
+            #                            polygon_wkt=self.fields[item_name],
+            #                            on_finished=None)
+            #self.parent.tsk_mngr.addTask(tsk)
             self.current_polygon = self.fields[item_name]
 
     def _set_new_crs(self: Self, 
@@ -173,22 +241,28 @@ def _set_new_crs(self: Self,
         return transformed_polygon
 
     def _plot_polygon_on_map(self: Self, polygon: "shapely.geometry.polygon.Polygon") -> "matplotlib.figure.Figure":
-        """Plots the polygon on a map with interactivity for zoom and node editing."""
+        """Plots the polygon or point on a map with interactivity for zoom and node editing."""
         if polygon.is_empty:
             fig, ax = plt.subplots(figsize=(12, 9))
             ax.text(0.5, 0.5, 'No data points were found', horizontalalignment='center', verticalalignment='center', transform=ax.transAxes, fontsize=15)
             ax.set_axis_off()
             return fig
+
+        # Handle Polygon geometry as before
         polygon = self._set_new_crs(polygon)
         minx, miny, maxx, maxy = polygon.bounds
+
+        # Calculate zoom level automatically
+        zoom = get_auto_zoom_level(minx, miny, maxx, maxy, max_zoom=17, min_zoom=10)
+
         fig, ax = plt.subplots(figsize=(12, 9))
         patch_collection = ax.fill(*polygon.exterior.xy, edgecolor='m', facecolor='none')
         if patch_collection:
             self.polygon_patch = patch_collection[0]
 
-        # Add the basemap
+        # Add the basemap with the calculated zoom
         if not self.parent.test_mode:
-            ctx.add_basemap(ax, source=ctx.providers.Esri.WorldImagery, zoom=self.zoom_level)
+            ctx.add_basemap(ax, source=ctx.providers.Esri.WorldImagery, zoom=zoom)
 
         # Set the axis limits with padding
         padding = 0.15
@@ -254,13 +328,15 @@ def on_release(self, event):
         """Handles the event when a dragged point is released."""
         if not hasattr(self, 'dragging_point'):
             return
-        self.dragging_point.set_animated(False)
+        if self.dragging_point is not None:
+            self.dragging_point.set_animated(False)
         self.dragging_point = None
         self.canvas.draw()
 
     def load_wkt(self: Self, polygon_wkt: str) -> None:
         """Loads a polygon from WKT and plots it on the map."""
         polygon = wkt.loads(polygon_wkt)
+        self.clear_layout()
         fig = self._plot_polygon_on_map(polygon)
         self.canvas = FigureCanvas(fig)  # Link the figure to the FigureCanvas
         self.canvas.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
@@ -284,8 +360,7 @@ def save_updated_polygon(self: Self) -> None:
         new_polygon = Polygon(new_coords)
         for key, value in self.fields.items():
             if value == self.current_polygon:
-                new_wkt = self._set_new_crs(new_polygon, source_proj = pyproj.CRS('EPSG:3857'), 
-                                                          target_proj = pyproj.CRS('EPSG:4326'))
+                new_wkt = self._set_new_crs(new_polygon, source_proj=pyproj.CRS('EPSG:3857'), target_proj=pyproj.CRS('EPSG:4326'))
                 self.fields[key] = new_wkt.wkt
                 break
         self.current_polygon = new_wkt.wkt