make x_ and y_kwargs private to avoid changing them in the echogramviewer

Author: peter-urban

python/themachinethatgoesping/pingprocessing/watercolumn/echograms/echogrambuilder.py

@@ -209,6 +209,12 @@ def get_ping_param(self, name, use_x_coordinates=False):
 
         return x_coordinates, return_param
 
+    def get_x_kwargs(self):
+        return deepcopy(self.__x_kwargs)
+
+    def get_y_kwargs(self):
+        return deepcopy(self.__y_kwargs)
+
     @classmethod
     def from_pings(
         cls,
@@ -284,7 +290,9 @@ def from_pings(
                     # sel_bottom = pss.apply_selection(ping.bottom)
                     # bd = np.nanmin(p.bottom.get_xyz(sel_bottom).z) + p.get_geolocation().z
                     # this is incorrect
-                    br = np.nanquantile(ping.bottom.get_xyz(sel).z, 0.05)
+
+                    # br = np.nanquantile(ping.bottom.get_xyz(sel).z, 0.05)
+                    br = ping.bottom.get_bottom_z(sel)
                     # mr = np.nanquantile(ping.watercolumn.get_bottom_range_samples(), 0.05) * range_res * angle_factor
                     mr = ping.watercolumn.get_minslant_sample_nr() * range_res * angle_factor
                     bottom_d_times.append(times[nr])
@@ -371,8 +379,8 @@ def reinit(self):
         if self.initialized:
             return
 
-        self.y_axis_function(**self.y_kwargs)
-        self.x_axis_function(**self.x_kwargs)
+        self.y_axis_function(**self.__y_kwargs)
+        self.x_axis_function(**self.__x_kwargs)
 
     def set_y_coordinates(self, name, y_coordinates, y_resolution, vec_min_y, vec_max_y):
         assert (
@@ -552,23 +560,23 @@ def get_filtered_by_y_extent(self, vec_x_val, vec_min_y, vec_max_y):
     def copy_xy_axis(self, other):
         match self.x_axis_name:
             case "Date time":
-                other.set_x_axis_date_time(**self.x_kwargs)
+                other.set_x_axis_date_time(**self.__x_kwargs)
             case "Ping time":
-                other.set_x_axis_ping_time(**self.x_kwargs)
+                other.set_x_axis_ping_time(**self.__x_kwargs)
             case "Ping number":
-                other.set_x_axis_ping_nr(**self.x_kwargs)
+                other.set_x_axis_ping_nr(**self.__x_kwargs)
             case _:
                 raise RuntimeError(f"ERROR: unknown x axis name '{self.x_axis_name}'")
 
         match self.y_axis_name:
             case "Depth (m)":
-                other.set_y_axis_depth(**self.y_kwargs)
+                other.set_y_axis_depth(**self.__y_kwargs)
             case "Range (m)":
-                other.set_y_axis_range(**self.y_kwargs)
+                other.set_y_axis_range(**self.__y_kwargs)
             case "Sample number":
-                other.set_y_axis_sample_nr(**self.y_kwargs)
+                other.set_y_axis_sample_nr(**self.__y_kwargs)
             case "Y indice":
-                other.set_y_axis_y_indice(**self.y_kwargs)
+                other.set_y_axis_y_indice(**self.__y_kwargs)
             case _:
                 raise RuntimeError(f"ERROR: unknown y axis name '{self.y_axis_name}'")
 
@@ -602,9 +610,9 @@ def set_y_axis_y_indice(
 
         y_kwargs = {"min_sample_nr": min_sample_nr, "max_sample_nr": max_sample_nr, "max_steps": max_steps}
         self.y_axis_function = self.set_y_axis_y_indice
-        if self.y_axis_name == "Y indice" and self.y_kwargs == y_kwargs:
+        if self.y_axis_name == "Y indice" and self.__y_kwargs == y_kwargs:
             return
-        self.y_kwargs = y_kwargs
+        self.__y_kwargs = y_kwargs
 
         y_coordinates, y_res = self.sample_y_coordinates(
             vec_min_y=vec_min_y,
@@ -628,9 +636,9 @@ def set_y_axis_depth(
 
         y_kwargs = {"min_depth": min_depth, "max_depth": max_depth, "max_steps": max_steps}
         self.y_axis_function = self.set_y_axis_depth
-        if self.y_axis_name == "Depth (m)" and self.y_kwargs == y_kwargs:
+        if self.y_axis_name == "Depth (m)" and self.__y_kwargs == y_kwargs:
             return
-        self.y_kwargs = y_kwargs
+        self.__y_kwargs = y_kwargs
 
         y_coordinates, y_res = self.sample_y_coordinates(
             vec_min_y=self.min_depths,
@@ -654,9 +662,9 @@ def set_y_axis_range(
 
         y_kwargs = {"min_range": min_range, "max_range": max_range, "max_steps": max_steps}
         self.y_axis_function = self.set_y_axis_range
-        if self.y_axis_name == "Range (m)" and self.y_kwargs == y_kwargs:
+        if self.y_axis_name == "Range (m)" and self.__y_kwargs == y_kwargs:
             return
-        self.y_kwargs = y_kwargs
+        self.__y_kwargs = y_kwargs
 
         y_coordinates, y_res = self.sample_y_coordinates(
             vec_min_y=self.min_ranges,
@@ -682,9 +690,9 @@ def set_y_axis_sample_nr(
 
         y_kwargs = {"min_sample_nr": min_sample_nr, "max_sample_nr": max_sample_nr, "max_steps": max_steps}
         self.y_axis_function = self.set_y_axis_sample_nr
-        if self.y_axis_name == "Sample number" and self.y_kwargs == y_kwargs:
+        if self.y_axis_name == "Sample number" and self.__y_kwargs == y_kwargs:
             return
-        self.y_kwargs = y_kwargs
+        self.__y_kwargs = y_kwargs
 
         y_coordinates, y_res = self.sample_y_coordinates(
             vec_min_y=self.min_sample_nrs,
@@ -712,10 +720,10 @@ def set_x_axis_ping_nr(
         }
 
         self.x_axis_function = self.set_x_axis_ping_nr
-        if self.x_axis_name == "Ping number" and self.x_kwargs == x_kwargs:
+        if self.x_axis_name == "Ping number" and self.__x_kwargs == x_kwargs:
             return
 
-        self.x_kwargs = x_kwargs
+        self.__x_kwargs = x_kwargs
 
         if not np.isfinite(max_ping_nr):
             max_ping_nr = np.max(self.ping_numbers)
@@ -758,10 +766,10 @@ def set_x_axis_ping_time(
         }
 
         self.x_axis_function = self.set_x_axis_ping_time
-        if self.x_axis_name == "Ping time" and self.x_kwargs == x_kwargs:
+        if self.x_axis_name == "Ping time" and self.__x_kwargs == x_kwargs:
             return
 
-        self.x_kwargs = x_kwargs
+        self.__x_kwargs = x_kwargs
 
         if not np.isfinite(min_timestamp):
             min_timestamp = np.min(self.ping_times)
@@ -823,7 +831,7 @@ def set_x_axis_date_time(
         }
 
         self.x_axis_function = self.set_x_axis_date_time
-        if self.x_axis_name == "Date time" and self.x_kwargs == x_kwargs:
+        if self.x_axis_name == "Date time" and self.__x_kwargs == x_kwargs:
             return
 
         if isinstance(min_ping_time, dt.datetime):
@@ -849,7 +857,8 @@ def set_x_axis_date_time(
         self.x_extent[0] = dt.datetime.fromtimestamp(self.x_extent[0], self.time_zone)
         self.x_extent[1] = dt.datetime.fromtimestamp(self.x_extent[1], self.time_zone)
         self.x_axis_name = "Date time"
-        self.x_kwargs = x_kwargs
+        self.x_axis_function = self.set_x_axis_date_time
+        self.__x_kwargs = x_kwargs
 
     def get_y_indices(self, wci_nr):
         n_samples = self.beam_sample_selections[wci_nr].get_number_of_samples_ensemble()
@@ -885,7 +894,7 @@ def build_image(self, progress=None):
                 y1, y2 = self.get_y_indices(wci_index)
                 image[image_index, y1] = wci[y2]
 
-        extent = self.x_extent
+        extent = deepcopy(self.x_extent)
         extent.extend(self.y_extent)
 
         return image, extent
@@ -919,7 +928,7 @@ def build_image_and_layer_image(self, progress=None):
                     if y1_layer is not None:
                         layer_image[image_index, y1_layer] = wci[y2_layer]
 
-        extent = self.x_extent
+        extent = deepcopy(self.x_extent)
         extent.extend(self.y_extent)
 
         return image, layer_image, extent
@@ -955,7 +964,7 @@ def build_image_and_layer_images(self, progress=None):
                     if y1_layer is not None:
                         layer_images[key][image_index, y1_layer] = wci[y2_layer]
 
-        extent = self.x_extent
+        extent = deepcopy(self.x_extent)
         extent.extend(self.y_extent)
 
         return image, layer_images, extent

python/themachinethatgoesping/pingprocessing/widgets/echogramviewer.py

@@ -240,12 +240,12 @@ def show_background_zoom(self, event = 0):
 
                 xmin,xmax = self.axes[i].get_xlim()
                 ymin,ymax = sorted(self.axes[i].get_ylim())
-                x_kwargs = echogram.x_kwargs
-                y_kwargs = echogram.y_kwargs
+                x_kwargs = echogram.get_x_kwargs()
+                y_kwargs = echogram.get_y_kwargs()
 
                 match self.x_axis_name:
                     case 'Date time':
-                        tmin,tmax = mdates.num2date(xmin).timestamp(),mdates.num2date(xmax).timestamp()
+                        tmin,tmax = mdates.num2date([xmin, xmax])
                         x_kwargs['min_ping_time'] = tmin
                         x_kwargs['max_ping_time'] = tmax
                         echogram.set_x_axis_date_time(**x_kwargs)
@@ -286,6 +286,7 @@ def show_background_zoom(self, event = 0):
                     self.high_res_extents.append(ex)
                 else:
                     im,im_layer,ex = echogram.build_image_and_layer_image(progress=self.progress)
+
                     self.high_res_images.append(im)
                     self.high_res_extents.append(ex)
                     self.layer_images.append(im_layer)
@@ -390,74 +391,76 @@ def callback_view(self):
         pass
 
     def click_echogram(self, event):
-        if self.pingviewer is None:
-            return
-        #global e
-        #e = event
         with self.output:
-            #print(event)
-            if event.button == 1:
-                match self.x_axis_name:
-                    case 'Date time':
-                        t = mdates.num2date(event.xdata).timestamp()
-                        for pn,ping in enumerate(self.pingviewer.imagebuilder.pings):
-                            if isinstance(ping,dict):
-                                ping = next(iter(ping.values()))
-
-                            if ping.get_timestamp() > t:
-                                if pn > 0:
-                                    pn -= 1
-                                break
-                    case 'Ping number':
-                        pn = event.xdata
-                    case 'Ping time':
-                        t = event.xdata
-                        for pn,ping in enumerate(self.pingviewer.imagebuilder.pings):
-                            if isinstance(ping,dict):
-                                ping = next(iter(ping.values()))
-
-                            if ping.get_timestamp() > t:
-                                if pn > 0:
-                                    pn -= 1
-                                break
-                    case _:
-                        raise RuntimeError(f"ERROR: unknown x axis name '{self.x_axis_name}'")
-                    
-                if pn < 0: 
-                    pn = 0
-                if pn >= len(self.pingviewer.imagebuilder.pings):
-                    pn = len(self.pingviewer.imagebuilder.pings)-1
+            if self.pingviewer is None:
+                return
+            #global e
+            #e = event
+            with self.output:
+                #print(event)
+                if event.button == 2:
+                    match self.x_axis_name:
+                        case 'Date time':
+                            t = mdates.num2date(event.xdata).timestamp()
+                            for pn,ping in enumerate(self.pingviewer.imagebuilder.pings):
+                                if isinstance(ping,dict):
+                                    ping = next(iter(ping.values()))
+
+                                if ping.get_timestamp() > t:
+                                    if pn > 0:
+                                        pn -= 1
+                                    break
+                        case 'Ping number':
+                            pn = event.xdata
+                        case 'Ping time':
+                            t = event.xdata
+                            for pn,ping in enumerate(self.pingviewer.imagebuilder.pings):
+                                if isinstance(ping,dict):
+                                    ping = next(iter(ping.values()))
+
+                                if ping.get_timestamp() > t:
+                                    if pn > 0:
+                                        pn -= 1
+                                    break
+                        case _:
+                            raise RuntimeError(f"ERROR: unknown x axis name '{self.x_axis_name}'")
 
-                self.pingviewer.w_index.value = pn
-        
-        self.update_ping_line()
+                    if pn < 0: 
+                        pn = 0
+                    if pn >= len(self.pingviewer.imagebuilder.pings):
+                        pn = len(self.pingviewer.imagebuilder.pings)-1
+                            
+                    self.pingviewer.w_index.value = pn
+            
+            self.update_ping_line()
 
     def update_ping_line(self, event = 0):
-        if self.pingviewer is not None:
-            with self.output:            
-                match self.x_axis_name:
-                    case 'Ping number':
-                        x = self.pingviewer.w_index.value
-                    case 'Date time':
-                        ping = self.pingviewer.imagebuilder.pings[self.pingviewer.w_index.value]
-                        if isinstance(ping,dict):
-                            ping = next(iter(ping.values()))                    
-                        x = ping.get_datetime()
-                    case 'Ping time':
-                        ping = self.pingviewer.imagebuilder.pings[self.pingviewer.w_index.value]
-                        if isinstance(ping,dict):
-                            ping = next(iter(ping.values()))                        
-                        x = ping.get_timestamp()
-                    case _:
-                        raise RuntimeError(f"ERROR: unknown x axis name '{self.x_axis_name}'")
-                            
-                for i,ax in enumerate(self.axes):
-                    try:
-                        if self.pingline[i] is not None:
-                            self.pingline[i].remove()
-                    except:
-                        pass
-                    self.pingline[i] = ax.axvline(x,c='black',linestyle='dashed')
+        with self.output:
+            if self.pingviewer is not None:
+                with self.output:            
+                    match self.x_axis_name:
+                        case 'Ping number':
+                            x = self.pingviewer.w_index.value
+                        case 'Date time':
+                            ping = self.pingviewer.imagebuilder.pings[self.pingviewer.w_index.value]
+                            if isinstance(ping,dict):
+                                ping = next(iter(ping.values()))                    
+                            x = ping.get_datetime()
+                        case 'Ping time':
+                            ping = self.pingviewer.imagebuilder.pings[self.pingviewer.w_index.value]
+                            if isinstance(ping,dict):
+                                ping = next(iter(ping.values()))                        
+                            x = ping.get_timestamp()
+                        case _:
+                            raise RuntimeError(f"ERROR: unknown x axis name '{self.x_axis_name}'")
+                                
+                    for i,ax in enumerate(self.axes):
+                        try:
+                            if self.pingline[i] is not None:
+                                self.pingline[i].remove()
+                        except:
+                            pass
+                        self.pingline[i] = ax.axvline(x,c='black',linestyle='dashed')
 
     def disconnect_pingviewer(self):
         with self.output: