wolfhece 2.1.109__py3-none-any.whl → 2.1.111__py3-none-any.whl

wolfhece/PyDraw.py

@@ -116,6 +116,12 @@ except ImportError as e:
     print(e)
     raise ImportError("Error importing pyshields, pyviews, PyConfig, GraphProfile, pybridges, tools_mpl, wolf_tiles, lagrangian.particle_system_ui, opengl.py3d, pyGui1D. Please check your installation.")
 
+try:
+    from .apps.curvedigitizer import Digitizer
+except ImportError as e:
+    print(e)
+    raise ImportError("Error importing apps.curvedigitizer. Please check your installation.")
+
 ID_SELECTCS = 1000
 ID_SORTALONG = 1001
 ID_LOCMINMAX = 1002
@@ -1363,6 +1369,7 @@ class WolfMapViewer(wx.Frame):
         self.menu_contour_from_arrays = self.tools_menu.Append(wx.ID_ANY, _("Create contour from checked arrays..."), _("Create contour"))
         self.menu_calculator = self.tools_menu.Append(wx.ID_ANY, _("Calculator..."), _("Calculator"))
         self.menu_views = self.tools_menu.Append(wx.ID_ANY, _("Memory views..."), _("Memory views"))
+        self.menu_digitizer = self.tools_menu.Append(wx.ID_ANY, _("Image digitizer..."), _("Image Digitizer"))
         self.calculator = None
         self.memory_views = None
         self._memory_views_gui = None
@@ -1708,6 +1715,8 @@ class WolfMapViewer(wx.Frame):
 
             self._menuinteractptri = self.trianglesmenu.Append(wx.ID_ANY, _("Interpolate on active triangulation..."), _("InterpolateTri"))
             self._menucomparetri = self.trianglesmenu.Append(wx.ID_ANY, _("Compare triangles to array..."), _("Comparison"))
+            self._menumovetri = self.trianglesmenu.Append(wx.ID_ANY, _("Move triangles..."), _("Move triangles"))
+            self._menurotatetri = self.trianglesmenu.Append(wx.ID_ANY, _("Rotate triangles..."), _("Rotate triangles"))
 
 
     def create_cloud_menu(self):
@@ -3143,6 +3152,20 @@ class WolfMapViewer(wx.Frame):
 
             self.active_array.compare_tri(self.active_tri)
 
+    def move_triangles(self):
+        """ Move the active triangles """
+        if self.active_tri is None:
+            logging.warning(_('No active triangles -- Please activate triangles first'))
+            return
+        self.start_action('move triangles', 'Move the current triangulation -- Please select 2 points to define the translation vector')
+
+    def rotate_triangles(self):
+        """ Rotate the active triangles """
+        if self.active_tri is None:
+            logging.warning(_('No active triangles -- Please activate triangles first'))
+            return
+        self.start_action('rotate triangles', 'Rotate the current triangulation -- Please select 1 point for the center')
+
     def copy_canvasogl(self, mpl:bool= True, ds:float= 0., figsizes= [10.,10.], palette:wolfpalette = None):
         """
         Generate image based on UI context and copy to the Clipboard
@@ -6270,6 +6293,14 @@ class WolfMapViewer(wx.Frame):
             autoscale = False
             self.compare_tri2array()
 
+        elif itemlabel ==  _("Move triangles..."):
+            autoscale = False
+            self.move_triangles()
+
+        elif itemlabel == _("Rotate triangles..."):
+            autoscale = False
+            self.rotate_triangles()
+
         elif itemlabel ==  _("Create contour from checked arrays..."):
             autoscale = False
 
@@ -6285,6 +6316,11 @@ class WolfMapViewer(wx.Frame):
             else:
                 self.calculator.Show()
 
+        elif itemlabel == _('Image digitizer...'):
+            autoscale = False
+
+            new_digitizer = Digitizer()
+
         elif itemlabel == _("Memory views..."):
             autoscale = False
 
@@ -7029,49 +7065,59 @@ class WolfMapViewer(wx.Frame):
 
         if loadfromfile :
             newpal.readfile()
-        else:
-            with wx.lib.busy.BusyInfo(_('Compute unique colormap from all arrays')):
-                wait = wx.BusyCursor()
-
-                curarray:WolfArray
-                curres2d:Wolfresults_2D
 
-                for curarray in self.myarrays:
-                    if curarray.plotted:
-                        workingarray.append(curarray.get_working_array())
-                        nbnotnull+=curarray.nbnotnull
-
-                for curres2d in self.myres2D:
-                    if curres2d.plotted:
-                        workingarray.append(curres2d.get_working_array())
-                        nbnotnull+=curres2d.nbnotnull
-
-                workingarray = np.concatenate(workingarray)
+            if not newpal.is_valid():
+                logging.warning(_('Palette not valid !'))
+                return
+        else:
+            nb  = len(self.myarrays) + len(self.myres2D)
+            pgbar = wx.ProgressDialog(_('Compute unique colormap'), _('Compute unique colormap from all arrays'), maximum=nb, parent=self, style=wx.PD_APP_MODAL|wx.PD_AUTO_HIDE)
 
-                newpal.default16()
-                newpal.isopop(workingarray, nbnotnull)
-            del wait
+            curarray:WolfArray
+            curres2d:Wolfresults_2D
 
-        with wx.lib.busy.BusyInfo(_('Apply unique colormap to all arrays')):
-            wait = wx.BusyCursor()
             for curarray in self.myarrays:
                 if curarray.plotted:
-                    curarray.mypal.automatic = False
-                    curarray.myops.palauto.SetValue(0)
-                    curarray.mypal.values = newpal.values.copy()
-                    curarray.mypal.colors = newpal.colors.copy()
-                    curarray.mypal.fill_segmentdata()
-                    curarray.reset_plot()
+                    workingarray.append(curarray.get_working_array())
+                    nbnotnull+=curarray.nbnotnull
+                pgbar.Update(pgbar.GetValue() + 1, _('Compute unique colormap from array : ') + curarray.idx)
 
             for curres2d in self.myres2D:
                 if curres2d.plotted:
-                    curres2d.mypal.automatic = False
-                    curres2d.mypal.nb     = newpal.nb
-                    curres2d.mypal.values = newpal.values.copy()
-                    curres2d.mypal.colors = newpal.colors.copy()
-                    curres2d.mypal.fill_segmentdata()
-                    curres2d.reset_plot()
-            del wait
+                    workingarray.append(curres2d.get_working_array())
+                    nbnotnull+=curres2d.nbnotnull
+                pgbar.Update(pgbar.GetValue() + 1, _('Compute unique colormap from 2D result : ') + curres2d.idx)
+
+            pgbar.Destroy()
+
+            workingarray = np.concatenate(workingarray)
+
+            newpal.default16()
+            newpal.isopop(workingarray, nbnotnull)
+
+        nb = len(self.myarrays) + len(self.myres2D)
+        pgbar = wx.ProgressDialog(_('Applying colormap'), _('Applying colormap to all arrays'), maximum=nb, parent=self, style=wx.PD_APP_MODAL|wx.PD_AUTO_HIDE)
+        for curarray in self.myarrays:
+            if curarray.plotted:
+                curarray.mypal.automatic = False
+                curarray.myops.palauto.SetValue(0)
+                curarray.mypal.values = newpal.values.copy()
+                curarray.mypal.colors = newpal.colors.copy()
+                curarray.mypal.fill_segmentdata()
+                curarray.reset_plot()
+            pgbar.Update(pgbar.GetValue() + 1, _('Applying colormap to array : ') + curarray.idx)
+
+        for curres2d in self.myres2D:
+            if curres2d.plotted:
+                curres2d.mypal.automatic = False
+                curres2d.mypal.nb     = newpal.nb
+                curres2d.mypal.values = newpal.values.copy()
+                curres2d.mypal.colors = newpal.colors.copy()
+                curres2d.mypal.fill_segmentdata()
+                curres2d.reset_plot()
+            pgbar.Update(pgbar.GetValue() + 1, _('Applying colormap to 2D result : ') + curres2d.idx)
+
+        pgbar.Destroy()
 
     def loadnap_and_apply(self):
 
@@ -9042,6 +9088,54 @@ class WolfMapViewer(wx.Frame):
 
             self.rightdown = (x, y)
 
+        elif self.action == 'move triangles':
+
+            if self.active_tri is None:
+                logging.warning(_('No triangles selected -- Please select a triangulation first !'))
+                return
+
+            if self.active_tri._start_move is None:
+                self.active_tri._start_move = (x, y)
+                return
+
+            delta_x = x - self.active_tri._start_move[0]
+            delta_y = y - self.active_tri._start_move[1]
+
+            if shiftdown:
+                delta_y = 0.
+
+            if alt:
+                delta_x = 0.
+
+            self.active_tri.move(delta_x, delta_y)
+            self.active_tri.reset_plot()
+            self.active_tri._start_move = None
+            self.active_tri.clear_cache()
+            self.end_action(_('End move triangulation'))
+
+        elif self.action == 'rotate triangles':
+
+            if self.active_tri is None:
+                logging.warning(_('No vector selected -- Please select a triangulation first !'))
+                return
+
+            if self.active_tri._rotation_center is None:
+                self.active_tri._rotation_center = (x,y)
+                return
+
+            if shiftdown:
+                if ctrl:
+                    self.active_tri._rotation_step = None
+                else:
+                    # Set the rotation step
+                    self.active_tri._rotation_step = np.degrees(np.arctan2(y - self.active_tri._rotation_center[1], x - self.active_tri._rotation_center[0]))
+
+            self.active_tri.rotate_xy(x, y)
+            self.active_tri._rotation_center = None
+            self.active_tri.clear_cache()
+            self.active_tri.reset_plot()
+            self.end_action(_('End rotate triangulation'))
+
         elif 'pick landmap' in self.action:
             # Pick a landmap if loaded
 
@@ -9691,7 +9785,7 @@ class WolfMapViewer(wx.Frame):
 
                     i, j, curbloc = locarray.get_blockij_from_xy(x, y)
 
-                    if i != '-':
+                    if i != '-' and i != -1:
                         curpar = 'Indices (i;j;bloc) (1-based)'
 
                         self.mytooltip.add_param(groupname = curgroup,
@@ -9813,8 +9907,10 @@ class WolfMapViewer(wx.Frame):
         if self.linked:
             for curFrame in self.linkedList:
                 if not curFrame is self:
+                    title = curFrame.GetTitle() if curFrame.GetTitle() != 'Wolf - main data manager' else 'Main'
+
                     for locarray in curFrame.myarrays:
-                        curgroup = locarray.idx
+                        curgroup = title + ' -' + locarray.idx
                         if locarray.plotted:
 
                             try:
@@ -9825,7 +9921,7 @@ class WolfMapViewer(wx.Frame):
                                         i, j, curbloc = locarray.get_blockij_from_xy(x, y)
                                         curpar = 'Indices (i;j;bloc) (1-based)'
 
-                                        self.mytooltip.add_param(groupname = locarray.idx,
+                                        self.mytooltip.add_param(groupname = curgroup,
                                                                     name = curpar,
                                                                     value =  '(' + str(i+1) + ';' + str(j+1) + ';' + str(curbloc) + ')',
                                                                     type = Type_Param.String,
@@ -9835,7 +9931,7 @@ class WolfMapViewer(wx.Frame):
                                         i, j = locarray.get_ij_from_xy(x, y)
                                         curpar = 'Indices (i;j) (1-based)'
 
-                                        self.mytooltip.add_param(groupname = locarray.idx,
+                                        self.mytooltip.add_param(groupname = curgroup,
                                                                     name = curpar,
                                                                     value =  '(' + str(i+1) + ';' + str(j+1) + ')',
                                                                     type = Type_Param.String,
@@ -9844,7 +9940,7 @@ class WolfMapViewer(wx.Frame):
                                     curpar = 'Value'
 
                                     if val is np.nan:
-                                        self.mytooltip.add_param(groupname = locarray.idx,
+                                        self.mytooltip.add_param(groupname = curgroup,
                                                                 name = 'Value',
                                                                 value =  "Nan",
                                                                 type = Type_Param.String,
@@ -9852,32 +9948,91 @@ class WolfMapViewer(wx.Frame):
 
                                     elif np.ma.is_masked(val):
 
-                                        self.mytooltip.add_param(groupname = locarray.idx,
+                                        self.mytooltip.add_param(groupname = curgroup,
                                                                 name = 'Value',
                                                                 value =  "Masked",
                                                                 type = Type_Param.String,
                                                                 comment = '')
 
                                     elif isinstance(val, str):
-                                        self.mytooltip.add_param(groupname = locarray.idx,
+                                        self.mytooltip.add_param(groupname = curgroup,
                                                                 name = curpar,
                                                                 value =  val,
                                                                 type = Type_Param.String,
                                                                 comment = '')
                                     elif isinstance(val, int):
-                                        self.mytooltip.add_param(groupname = locarray.idx,
+                                        self.mytooltip.add_param(groupname = curgroup,
                                                                 name = curpar,
                                                                 value =  int(val),
                                                                 type = Type_Param.Integer,
                                                                 comment = '')
                                     else:
-                                        self.mytooltip.add_param(groupname = locarray.idx,
+                                        self.mytooltip.add_param(groupname = curgroup,
                                                                 name = curpar,
                                                                 value =  float(val),
                                                                 type = Type_Param.Float,
                                                                 comment = '')
                             except:
-                                logging.warning(_('Error in linked frame -- Please check !'))
+                                logging.warning(_('Error in linked frame Arrays -- Please check !'))
+
+                    for locarray in curFrame.myres2D:
+                        locarray:Wolfresults_2D
+                        curgroup = title + ' - ' + locarray.idx
+                        if locarray.checked:
+                            try:
+                                vals,labs = locarray.get_values_labels(x,y)
+
+                                i, j, curbloc = locarray.get_blockij_from_xy(x, y)
+
+                                if i != '-' and i != -1:
+                                    curpar = 'Indices (i;j;bloc) (1-based)'
+
+                                    self.mytooltip.add_param(groupname = curgroup,
+                                                            name = curpar,
+                                                            value =  '(' + str(i) + ';' + str(j) + ';' + str(curbloc) + ')',
+                                                            type = Type_Param.String,
+                                                            comment = '')
+
+                                    for val,curpar in zip(vals,labs):
+
+                                        if val is np.nan:
+                                            self.mytooltip.add_param(groupname = curgroup,
+                                                                    name = 'Value',
+                                                                    value =  "Nan",
+                                                                    type = Type_Param.String,
+                                                                    comment = '')
+
+                                        elif np.ma.is_masked(val):
+
+                                            self.mytooltip.add_param(groupname = curgroup,
+                                                                    name = 'Value',
+                                                                    value =  "Masked",
+                                                                    type = Type_Param.String,
+                                                                    comment = '')
+
+                                        elif isinstance(val, str):
+                                            self.mytooltip.add_param(groupname = curgroup,
+                                                                    name = curpar,
+                                                                    value =  val,
+                                                                    type = Type_Param.String,
+                                                                    comment = '')
+
+                                        elif isinstance(val, int):
+                                            self.mytooltip.add_param(groupname = curgroup,
+                                                                    name = curpar,
+                                                                    value =  int(val),
+                                                                    type = Type_Param.Integer,
+                                                                    comment = '')
+
+                                        else:
+                                            self.mytooltip.add_param(groupname = curgroup,
+                                                                    name = curpar,
+                                                                    value =  float(val),
+                                                                    type = Type_Param.Float,
+                                                                    comment = '')
+
+                            except:
+                                logging.warning(_('Error in linked frame Results2D -- Please check !'))
 
         for loc_ps in self.mypartsystems:
             if loc_ps.checked:
@@ -9989,11 +10144,34 @@ class WolfMapViewer(wx.Frame):
 
                         self.active_vector.move(delta_x, delta_y)
 
+            if self.action == 'move triangles':
+                if self.active_tri is not None:
+                    if self.active_tri._start_move is not None:
+
+                        delta_x = x - self.active_tri._start_move[0]
+                        delta_y = y - self.active_tri._start_move[1]
+
+                        if shiftdown:
+                            delta_y = 0.
+
+                        if altdown:
+                            delta_x = 0.
+
+                        self.active_tri.move(delta_x, delta_y)
+
+                        self.active_tri.reset_plot()
+
             if self.action == 'rotate vector':
                 if self.active_vector is not None:
                     if self.active_vector._rotation_center is not None:
                         self.active_vector.rotate_xy(x, y)
 
+            if self.action == 'rotate triangles':
+                if self.active_tri is not None:
+                    if self.active_tri._rotation_center is not None:
+                        self.active_tri.rotate_xy(x, y)
+                        self.active_tri.reset_plot()
+
             if self.action == 'move zone':
                 if self.active_zone is not None:
                     if self.active_zone._start_move is not None:

wolfhece/PyPalette.py

@@ -671,6 +671,21 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
 
         self.fill_segmentdata()
 
+    def is_valid(self):
+        """Vérification de la validité de la palette"""
+
+        if self.nb < 2:
+            return False
+
+        if self.values[0] >= self.values[-1]:
+            return False
+
+        for i in range(1, self.nb):
+            if self.values[i] <= self.values[i-1]:
+                return False
+
+        return True
+
     def savefile(self, *args):
         """Lecture de la palette sur base d'un fichier WOLF .pal"""
         if len(args) > 0:

wolfhece/PyVertexvectors.py

@@ -59,6 +59,12 @@ class Triangulation(Element_To_Draw):
         self.nb_tri = len(tri)
         self.nb_pts = len(pts)
 
+        self._start_move = None
+        self._move_step = None  # step for a move
+        self._rotation_center = None
+        self._rotation_step = None
+        self._cache = None
+
         if fn !='':
             self.filename=fn
             self.read(fn)
@@ -370,6 +376,7 @@ class Triangulation(Element_To_Draw):
                 glPolygonMode(GL_FRONT_AND_BACK,GL_LINE)
 
                 glEndList()
+                glCallList(self.id_list)
             except:
                 logging.warning('Problem with OpenGL plot - Triangulation.plot')
         else:
@@ -420,6 +427,67 @@ class Triangulation(Element_To_Draw):
         self.nb_pts = len(self.pts)
         self.nb_tri = len(self.tri)
         self.valid_format()
+
+    def set_cache(self):
+        """ Set the cache for the vertices """
+
+        self._cache = self.pts.copy()
+
+    def clear_cache(self):
+        """ Clear the cache for the vertices """
+
+        self._cache = None
+
+    def move(self, delta_x:float, delta_y:float, use_cache:bool = True):
+        """ Move the vertices by a delta_x and delta_y
+
+        :param delta_x: delta x [m]
+        :param delta_y: delta y [m]
+        """
+
+        if use_cache and self._cache is None:
+            self.set_cache()
+
+        if use_cache:
+            self.pts[:,0] = self._cache[:,0] + delta_x
+            self.pts[:,1] = self._cache[:,1] + delta_y
+        else:
+            self.pts[:,0] += delta_x
+            self.pts[:,1] += delta_y
+
+    def rotate(self, angle:float, center:tuple, use_cache:bool = True):
+        """ Rotate the vertices around a center
+
+        :param angle: angle in degrees -- positive for clockwise rotation
+        :param center: center of rotation
+        """
+        angle = np.radians(angle)
+        c,s = np.cos(angle), np.sin(angle)
+        R = np.array([[c,-s],[s,c]])
+
+        if use_cache and self._cache is None:
+            self.set_cache()
+
+        if use_cache:
+            locxy = self._cache[:,:2] - np.array(center)
+            self.pts[:,:2] = np.dot(R,locxy.T).T + np.array(center)
+        else:
+            locxy = self.pts[:,:2] - np.array(center)
+            self.pts[:,:2] = np.dot(R,locxy.T).T + np.array(center)
+
+    def rotate_xy(self, x:float, y:float, use_cache:bool = True):
+        """ Rotate the vector around the rotation center and a xy point """
+
+        if self._rotation_center is None:
+            logging.error('No rotation center defined -- set it before rotating by this routine')
+            return self
+
+        angle = np.degrees(np.arctan2(-(y-self._rotation_center[1]), x-self._rotation_center[0]))
+
+        if self._rotation_step is not None:
+            angle = np.round(angle/self._rotation_step)*self._rotation_step
+
+        return self.rotate(-angle, center=self._rotation_center, use_cache=use_cache)
 class vectorproperties:
     """ Vector properties """
     used:bool
@@ -1743,7 +1811,8 @@ class vector:
 
         :param only_firstlast: si True, on ne recherche que les coordonnées du premier et du dernier vertex
         """
-        if len(self.myvertices)>0:
+
+        if self.nbvertices > 0:
 
             if only_firstlast:
                 self.xmin=min(self.myvertices[0].x, self.myvertices[-1].x)
@@ -1755,6 +1824,11 @@ class vector:
                 self.ymin=min(vert.y for vert in self.myvertices)
                 self.xmax=max(vert.x for vert in self.myvertices)
                 self.ymax=max(vert.y for vert in self.myvertices)
+        else:
+            self.xmin=-99999.
+            self.ymin=-99999.
+            self.xmax=-99999.
+            self.ymax=-99999.
 
     @property
     def has_interior(self):
@@ -2952,10 +3026,10 @@ class zone:
         self.active_vector=None # current active vector
         self.parent=parent      # parent object - type(Zones)
 
-        self.xmin = 0.
-        self.ymin = 0.
-        self.xmax = 0.
-        self.ymax = 0.
+        self.xmin = -99999.
+        self.ymin = -99999.
+        self.xmax = -99999.
+        self.ymax = -99999.
 
         self.has_legend = False # indicate if at least one vector in the zone has a legend
         self.has_image  = False # indicate if at least one vector in the zone has an image
@@ -3282,22 +3356,21 @@ class zone:
             self.xmax=-99999.
             self.ymax=-99999.
         else:
-            minsx=np.asarray([vect.xmin for vect in self.myvectors])
-            minsy=np.asarray([vect.ymin for vect in self.myvectors])
-            maxsx=np.asarray([vect.xmax for vect in self.myvectors])
-            maxsy=np.asarray([vect.ymax for vect in self.myvectors])
-
-            # if len(minsx)>1: # FIXME what if more than one vector is empty.
-            if max(max(minsx),max(minsy), max(maxsx), max(maxsy)) != -99999.:
-                self.xmin=np.min(minsx[np.where(minsx!=-99999.)])
-                self.xmax=np.max(maxsx[np.where(maxsx!=-99999.)])
-                self.ymin=np.min(minsy[np.where(minsy!=-99999.)])
-                self.ymax=np.max(maxsy[np.where(maxsy!=-99999.)])
+            minsx=np.asarray([vect.xmin for vect in self.myvectors if vect.xmin!=-99999.])
+            minsy=np.asarray([vect.ymin for vect in self.myvectors if vect.ymin!=-99999.])
+            maxsx=np.asarray([vect.xmax for vect in self.myvectors if vect.xmax!=-99999.])
+            maxsy=np.asarray([vect.ymax for vect in self.myvectors if vect.ymax!=-99999.])
+
+            if minsx.size == 0:
+                self.xmin=-99999.
+                self.ymin=-99999.
+                self.xmax=-99999.
+                self.ymax=-99999.
             else:
-                self.xmin=minsx[0]
-                self.xmax=maxsx[0]
-                self.ymin=minsy[0]
-                self.ymax=maxsy[0]
+                self.xmin = minsx.min()
+                self.xmax = maxsx.max()
+                self.ymin = minsy.min()
+                self.ymax = maxsy.max()
 
     def prep_listogl(self):
         """
@@ -4852,6 +4925,9 @@ class Zones(wx.Frame, Element_To_Draw):
 
         self.xmin=ox
         self.ymin=oy
+
+        self._first_find_minmax:bool = True
+
         self.tx=tx
         self.ty=ty
         self.myzones=[]
@@ -5502,32 +5578,29 @@ class Zones(wx.Frame, Element_To_Draw):
         :param update : si True, force la MAJ des minmax dans chaque zone; si False, compile les minmax déjà présents
         :param only_firstlast : si True, ne prend en compte que le premier et le dernier vertex de chaque vecteur
         """
-        if update:
+
+        if update or self._first_find_minmax:
             for zone in self.myzones:
-                zone.find_minmax(update, only_firstlast)
+                zone.find_minmax(update or self._first_find_minmax, only_firstlast)
+            self._first_find_minmax = False
 
-        if len(self.myzones)>0:
+        if self.nbzones > 0:
 
-            minsx=np.asarray([zone.xmin for zone in self.myzones])
-            minsy=np.asarray([zone.ymin for zone in self.myzones])
-            maxsx=np.asarray([zone.xmax for zone in self.myzones])
-            maxsy=np.asarray([zone.ymax for zone in self.myzones])
+            minsx = np.asarray([zone.xmin for zone in self.myzones if zone.xmin!=-99999.])
+            minsy = np.asarray([zone.ymin for zone in self.myzones if zone.ymin!=-99999.])
+            maxsx = np.asarray([zone.xmax for zone in self.myzones if zone.xmax!=-99999.])
+            maxsy = np.asarray([zone.ymax for zone in self.myzones if zone.ymax!=-99999.])
 
-            if len(minsx)>1:
-                self.xmin=np.min(minsx[np.where(minsx!=-99999.)])
-                self.xmax=np.max(maxsx[np.where(maxsx!=-99999.)])
-                self.ymin=np.min(minsy[np.where(minsy!=-99999.)])
-                self.ymax=np.max(maxsy[np.where(maxsy!=-99999.)])
+            if minsx.size == 0:
+                self.xmin = 0.
+                self.ymin = 0.
+                self.xmax = 1.
+                self.ymax = 1.
             else:
-                self.xmin=minsx[0]
-                self.xmax=maxsx[0]
-                self.ymin=minsy[0]
-                self.ymax=maxsy[0]
-        else:
-            self.xmin=0.
-            self.ymin=0.
-            self.xmax=1.
-            self.ymax=1.
+                self.xmin = minsx.min()
+                self.xmax = maxsx.max()
+                self.ymin = minsy.min()
+                self.ymax = maxsy.max()
 
     def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
         """