updates

Author: sudhanshu112233shukla

python/grass/jupyter/baseseriesmap.py

@@ -28,6 +28,7 @@
 from .utils import get_number_of_cores, save_gif
 
 
+
 class BaseSeriesMap:
     """
     Base class for SeriesMap and TimeSeriesMap
@@ -56,10 +57,10 @@ def __init__(self, width=None, height=None, env=None):
         self._width = width
         self._height = height
         self._slider_description = ""
+        self._legend = None  # Shared legend settings for all timesteps/frames
         self._labels = []
         self._indices = []
         self.base_file = None
-
         # Create a temporary directory for our PNG images
         # Resource managed by weakref.finalize.
         self._tmpdir = (
@@ -98,12 +99,29 @@ def wrapper(**kwargs):
                 self._base_calls.append((grass_module, kwargs))
 
         return wrapper
+    
+    def d_legend(self, **kwargs):
+        """Display legend for all timesteps/frames."""
+        self._legend = kwargs
+        self._layers_rendered = False  # Force re-render  
+    
 
     def _render_baselayers(self, img):
         """Add collected baselayers to Map instance"""
         for grass_module, kwargs in self._base_layer_calls:
             img.run(grass_module, **kwargs)
 
+    def _apply_overlays(self, img):
+        """Apply overlay commands (d.vect, d.barscale) to map instance"""
+        for grass_module, kwargs in self._base_calls:
+            img.run(grass_module, **kwargs)        
+
+    def _apply_legend(self, img):
+        """Apply legend to a map instance"""
+        if self._legend:
+            img.d_legend(**self._legend) 
+     
+                  
     def _render(self, tasks):
         """
         Renders the base image for the dataset.
@@ -145,7 +163,7 @@ def _render(self, tasks):
         for i, filename in results:
             self._base_filename_dict[i] = filename
 
-        self._layers_rendered = True
+        self._layers_rendered = True     
 
     def show(self, slider_width=None):
         """Create interactive timeline slider.

python/grass/jupyter/seriesmap.py

@@ -22,7 +22,6 @@
 from .region import RegionManagerForSeries
 from .baseseriesmap import BaseSeriesMap
 
-
 class SeriesMap(BaseSeriesMap):
     """Creates visualizations from a series of rasters or vectors in Jupyter
     Notebooks.
@@ -79,25 +78,16 @@ def add_rasters(self, rasters, **kwargs):
         for raster in rasters:
             if not map_exists(name=raster, element="raster"):
                 raise NameError(_("Could not find a raster named {}").format(raster))
-        # Update region to rasters if not use_region or saved_region
-        self._region_manager.set_region_from_rasters(rasters)
-        if self._baseseries_added:
-            assert self.baseseries == len(rasters), _(
-                "Number of vectors in series must match number of vectors"
-            )
-            for i in range(self.baseseries):
-                kwargs["map"] = rasters[i]
-                self._base_calls[i].append(("d.rast", kwargs.copy()))
-        else:
-            self.baseseries = len(rasters)
-            for raster in rasters:
-                kwargs["map"] = raster
-                self._base_calls.append([("d.rast", kwargs.copy())])
-            self._baseseries_added = True
-        if not self._labels:
-            self._labels = rasters
+        # Update region
+        self._region_manager.set_region_from_rasters(rasters) 
+        # Add overlays via BaseSeriesMap
+        for raster in rasters:
+            self.d_rast(map=raster, **kwargs)
+        
+        # Set labels and indices
+        self._labels = rasters
+        self._indices = list(range(len(rasters)))
         self._layers_rendered = False
-        self._indices = list(range(len(self._labels)))
 
     def add_vectors(self, vectors, **kwargs):
         """
@@ -106,62 +96,45 @@ def add_vectors(self, vectors, **kwargs):
         for vector in vectors:
             if not map_exists(name=vector, element="vector"):
                 raise NameError(_("Could not find a vector named {}").format(vector))
-        # Update region extent to vectors if not use_region or saved_region
+        # Update region
         self._region_manager.set_region_from_vectors(vectors)
-        if self._baseseries_added:
-            assert self.baseseries == len(vectors), _(
-                "Number of rasters in series must match number of vectors"
-            )
-            for i in range(self.baseseries):
-                kwargs["map"] = vectors[i]
-                self._base_calls[i].append(("d.vect", kwargs.copy()))
-        else:
-            self.baseseries = len(vectors)
-            for vector in vectors:
-                kwargs["map"] = vector
-                self._base_calls.append([("d.vect", kwargs.copy())])
-            self._baseseries_added = True
-        if not self._labels:
-            self._labels = vectors
+        # Add overlays via BaseSeriesMap
+        for vector in vectors:
+            self.d_vect(map=vector, **kwargs)
+        
+        # Set labels and indices
+        self._labels = vectors
+        self._indices = list(range(len(vectors)))
         self._layers_rendered = False
-        self._indices = range(len(self._labels))
 
     def add_names(self, names):
-        """Add list of names associated with layers.
-        Default will be names of first series added."""
-        assert self.baseseries == len(names), _(
-            "Number of vectors in series must match number of vectors"
-        )
+        """Add list of names associated with layers."""
+        assert len(self._labels) == len(names), "Names must match layer count"
         self._labels = names
-        self._indices = list(range(len(self._labels)))
 
     def _render_worker(self, i):
-        """Function to render a single layer."""
+        """Render a single layer with overlays/legends"""
         filename = os.path.join(self._tmpdir.name, f"{i}.png")
-        shutil.copyfile(self.base_file, filename)
         img = Map(
             width=self._width,
             height=self._height,
             filename=filename,
             use_region=True,
             env=self._env,
-            read_file=True,
+            read_file=False,
         )
-        for grass_module, kwargs in self._base_calls[i]:
-            img.run(grass_module, **kwargs)
-        return i, filename
+        img.d_erase()
+        
+        # Apply overlays and legend via BaseSeriesMap
+        self._apply_overlays(img)
+        self._apply_legend(img)
+        
+        img.save(filename)
+        return (i, filename)
 
     def render(self):
-        """Renders image for each raster in series.
-
-        Save PNGs to temporary directory. Must be run before creating a visualization
-        (i.e. show or save).
-        """
+        """Renders image for each raster in series."""
         if not self._baseseries_added:
-            msg = (
-                "Cannot render series since none has been added."
-                "Use SeriesMap.add_rasters() or SeriesMap.add_vectors()"
-            )
-            raise RuntimeError(msg)
-        tasks = [(i,) for i in range(self.baseseries)]
-        self._render(tasks)
+            raise RuntimeError("Add series using add_rasters() or add_vectors()")
+        tasks = [(i,) for i in range(len(self._labels))]
+        self._render(tasks)

python/grass/jupyter/timeseriesmap.py

@@ -175,9 +175,6 @@ def add_raster_series(self, baseseries, fill_gaps=False):
         self.baseseries = baseseries
         self._fill_gaps = fill_gaps
         self._baseseries_added = True
-
-        self._base_calls = []
-        self._legend = None
         # create list of layers to render and date/times
         self._layers, self._labels = collect_layers(
             self.baseseries, self._element_type, self._fill_gaps
@@ -202,9 +199,6 @@ def add_vector_series(self, baseseries, fill_gaps=False):
         self.baseseries = baseseries
         self._fill_gaps = fill_gaps
         self._baseseries_added = True
-         # NEW CODE: Reset overlays and legend when adding a new series
-        self._base_calls = []
-        self._legend = None
         # create list of layers to render and date/times
         self._layers, self._labels = collect_layers(
             self.baseseries, self._element_type, self._fill_gaps
@@ -217,108 +211,74 @@ def add_vector_series(self, baseseries, fill_gaps=False):
         self._indices = self._labels
 
     def d_legend(self, **kwargs):
-        """Display legend.
-
-        Wraps d.legend and uses same keyword arguments.
+        """Display legend for all timesteps.
+    
+        Wraps `d.legend` and uses the same keyword arguments.
         """
-        if "raster" in kwargs and not self._baseseries_added:
-            self._base_layer_calls.append(("d.legend", kwargs))
-        if "raster" in kwargs and self._baseseries_added:
-            self._base_calls.append(("d.legend", kwargs))
-        else:
-            self._legend = kwargs
-            # If d_legend has been called, we need to re-render layers
-            self._layers_rendered = False
-
-    def _render_legend(self, img):
-        """Add legend to Map instance"""
-        info = gs.parse_command(
-            "t.info", input=self.baseseries, flags="g", env=self._env
-        )
-        min_min = info["min_min"]
-        max_max = info["max_max"]
-        img.d_legend(
-            raster=self._layers[0],
-            range=f"{min_min}, {max_max}",
-            **self._legend,
-        )
+        self._legend = kwargs
+        self._layers_rendered = False
 
-    def _render_overlays(self, img):
-        """Add collected overlays to Map instance"""
-        for grass_module, kwargs in self._base_calls:
-            img.run(grass_module, **kwargs)
-
-    def _render_blank_layer(self, filename):
-        """Write blank image for gaps in time series.
-
-        Adds overlays and legend to base map.
-        """
-        img = Map(
-            width=self._width,
-            height=self._height,
-            filename=filename,
-            use_region=True,
-            env=self._env,
-            read_file=True,
-        )
-        # Add overlays
-        self._render_overlays(img)
-        # Add legend if needed
+    def _apply_legend(self, img):
+        """Override BaseSeriesMap to set dynamic legend range for time series."""
         if self._legend:
-            self._render_legend(img)
-
-    def _render_layer(self, layer, filename):
-        """Render layer to file with overlays and legend"""
-        img = Map(
-            width=self._width,
-            height=self._height,
-            filename=filename,
-            use_region=True,
-            env=self._env,
-            read_file=True,
-        )
-
-
-        img.run("d.erase", flags="f")
+            info = gs.parse_command(
+                "t.info", input=self.baseseries, flags="g", env=self._env
+            )
+            min_min = info["min_min"]
+            max_max = info["max_max"]
+            img.d_legend(
+                raster=self._layers[0],  # Use first layer for range
+                range=f"{min_min}, {max_max}",
+                **self._legend,
+            )    
 
+    def _render_worker(self, date, layer, filename):
+     """Render a timestep with overlays/legends"""
+    img = Map(
+        width=self._width,
+        height=self._height,
+        filename=filename,
+        use_region=True,
+        env=self._env,
+        read_file=False,
+    )
+    img.d_erase()
+
+    # Render base layer only if not "None"
+    if layer != "None":
         if self._element_type == "strds":
             img.d_rast(map=layer)
         elif self._element_type == "stvds":
             img.d_vect(map=layer)
-        # Add overlays
-        self._render_overlays(img)
-        # Add legend if needed
-        if self._legend:
-            self._render_legend(img)
 
-    def _render_worker(self, date, layer, filename):
-        """Function to render a single layer."""
-        shutil.copyfile(self.base_file, filename)
-        if layer == "None":
-            self._render_blank_layer(filename)
-        else:
-            self._render_layer(layer, filename)
-        return date, filename
+    #Apply overlays/legend to ALL layers (including "None")
+        self._apply_overlays(img)  # Fixed indentation
+        self._apply_legend(img)    # Fixed indentation
+
+        img.save(filename)
+        return (date, filename)
 
     def render(self):
-        """Renders image for each time-step in space-time dataset."""
-        if not self._baseseries_added:
-            msg = (
-                "Cannot render space time dataset since none has been added."
-                " Use TimeSeriesMap.add_raster_series() or "
-                "TimeSeriesMap.add_vector_series() to add dataset"
+     """Renders image for each time-step in space-time dataset."""
+    if not self._baseseries_added:
+        msg = (
+            "Cannot render space time dataset since none has been added."
+            " Use TimeSeriesMap.add_raster_series() or "
+            "TimeSeriesMap.add_vector_series() to add dataset"
+        )
+        raise RuntimeError(msg)
+
+    # Prepare tasks with tuples
+    tasks = []
+    for date, layer in self._date_layer_dict.items():
+        if layer == "None":
+            # Generate unique filename for each "None" layer
+            filename = os.path.join(
+                self._tmpdir.name, 
+                f"none_{gs.append_random('', 8)}.png"  # Unique random name
             )
-            raise RuntimeError(msg)
-
-        # Create name for empty layers
-        random_name_none = gs.append_random("none", 8) + ".png"
-
-        # Prepare tasks with tuples
-        tasks = []
-        for date, layer in self._date_layer_dict.items():
-            if layer == "None":
-                filename = os.path.join(self._tmpdir.name, random_name_none)
-            else:
-                filename = os.path.join(self._tmpdir.name, f"{layer}.png")
-            tasks.append((date, layer, filename))
-        self._render(tasks)
+        else:
+            filename = os.path.join(self._tmpdir.name, f"{layer}.png")
+            
+        tasks.append((date, layer, filename))  
+    self._render(tasks)