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

wolfhece/pybridges.py

@@ -48,10 +48,18 @@ class stored_values_coords(Enum):
     X = (0, 'CoordX')
     Y = (1, 'CoordY')
 
-class zones_in_file(Enum):
+class zones_in_file_fr_vec(Enum):
     PARTS = '3 zones'
     RIVER = 'entier'
-    SECTION = 'section'
+
+class zones_in_file(Enum):
+    PARTS = _('bridge_position')
+    RIVER = _('river')
+    DECK = _('deck')
+    ROOF = _('roof')
+    PIER = _('pier')
+    CROSS_SECTIONS = _('crosssections')
+    EXTRACTION = _('extraction')
 
 class operators(Enum):
     MEDIAN = 'median'
@@ -66,6 +74,16 @@ class parts_values(Enum):
     UPSTREAM    = _('upstream')
     DOWNSTREAM  = _('downstream')
 
+class rivers_values(Enum):
+    RIVERBED     = _('riverbed')
+    LEFTBANK    = _('leftbank')
+    RIGHTBANK  = _('rightbank')
+
+class cs_values(Enum):
+    UPSTREAM   = _('upstream')
+    MIDDLE     = _('middle')
+    DOWNSTREAM = _('downstream')
+
 class Bridge(Zones):
     """
     Bridge class
@@ -105,108 +123,230 @@ class Bridge(Zones):
 
     """
 
+    @classmethod
+    def new_bridge(cls, name:str):
+        """
+        Create a new bridge with name
+        """
+        new_bridge = cls()
+        new_bridge.myname = name
+
+        position = zone(name = zones_in_file.PARTS.value, parent= new_bridge)
+        new_bridge.add_zone(position)
+
+        new_bridge.centralpart = vector(name = parts_values.CENTRAL.value)
+        position.add_vector(new_bridge.centralpart, forceparent=True)
+
+        new_bridge.upstream = vector(name = parts_values.UPSTREAM.value)
+        position.add_vector(new_bridge.upstream, forceparent=True)
+
+        new_bridge.downstream = vector(name = parts_values.DOWNSTREAM.value)
+        position.add_vector(new_bridge.downstream, forceparent=True)
+
+        river = zone(name = zones_in_file.RIVER.value, parent= new_bridge)
+        new_bridge.add_zone(river)
+
+        new_bridge.leftbank = vector(name = rivers_values.LEFTBANK.value)
+        new_bridge.riverbed = vector(name = rivers_values.RIVERBED.value)
+        new_bridge.rightbank = vector(name = rivers_values.RIGHTBANK.value)
+
+        river.add_vector(new_bridge.leftbank, forceparent=True)
+        river.add_vector(new_bridge.riverbed, forceparent=True)
+        river.add_vector(new_bridge.rightbank, forceparent=True)
+
+        new_bridge.add_zone(zone(name = zones_in_file.DECK.value, parent= new_bridge))
+        new_bridge.add_zone(zone(name = zones_in_file.ROOF.value, parent= new_bridge))
+        new_bridge.add_zone(zone(name = zones_in_file.PIER.value, parent= new_bridge))
+        new_bridge.add_zone(zone(name = zones_in_file.CROSS_SECTIONS.value, parent= new_bridge))
+        new_bridge.add_zone(zone(name = zones_in_file.EXTRACTION.value, parent= new_bridge))
+
+        return new_bridge
+
     def __init__(self, myfile='', ds:float=5., ox: float = 0, oy: float = 0, tx: float = 0, ty: float = 0, parent=None, is2D=True, wx_exists:bool = False):
         super().__init__(myfile, ox, oy, tx, ty, parent, is2D, wx_exists)
         self.init_ui()
 
-        self.myname = splitext(basename(myfile))[0]
+        self.centralpart = None
+        self.upstream = None
+        self.downstream = None
 
-        # recherche de la zone du fichier contenant les 3 parties de l'ouvrage
-        curzone = self.get_zone(zones_in_file.PARTS.value)
-        if curzone is None:
-            curzone = self.get_zone(0)
-            curzone.myname = zones_in_file.PARTS.value # on force le nom de la zone pour éviter de refaire le test ailleurs
-        if curzone is None:
-            raise Warning(_('Bad file : {}'.format(myfile)))
+        self.riverbed = None
+        self.leftbank = None
+        self.rightbank = None
 
-        # attribution des vecteurs pour les différentes parties de l'ouvrage
+        self.polygons_zone = None
 
-        self.centralpart       = curzone.get_vector('tablier') # 4 vertices from Upstream Left to Dowstream Left passing by Upstream Right and Downstream Right
-        if self.centralpart is None:
-            self.centralpart       = curzone.get_vector('seuil') # 4 vertices from Upstream Left to Dowstream Left passing by Upstream Right and Downstream Right
+        if myfile != '':
+            self.myname = splitext(basename(myfile))[0]
+            extension = splitext(basename(myfile))[1]
 
-        self.upstream   = curzone.get_vector('amont')   # 4 vertices from Upstream Left Deck  to Upstream Right Deck passing by Upstream Left Bank and Upstream Right Bank
-        self.downstream = curzone.get_vector('aval')    # 4 vertices from Downstream Left Deck Left to Downstream Right Deck passing by Downstream Left Bank and Downstream Right Bank
 
-        xydeck = self.centralpart.asnparray()
+            if extension == '.vec':
 
-        # point central de l'ouvrage
-        self.centerx = np.mean(xydeck[:,0]) # X coordinate of the deck
-        self.centery = np.mean(xydeck[:,1]) # X coordinate of the deck
-        self.curvi = 0                      # s curvilinear coordinate of the deck along a support polyline
+                # recherche de la zone du fichier contenant les 3 parties de l'ouvrage
+                curzone = self.get_zone(zones_in_file_fr_vec.PARTS.value)
+                if curzone is None:
+                    curzone = self.get_zone(0)
+                    curzone.myname = zones_in_file_fr_vec.PARTS.value # on force le nom de la zone pour éviter de refaire le test ailleurs
+                if curzone is None:
+                    raise Warning(_('Bad file : {}'.format(myfile)))
 
-        """
-        Si certaines parties ne sont pas attribuées, il peut s'agir d'une mauvaise appellation.
-        Dans ce cas, on attribue sur base de la position dans la zone
-        """
-        assert curzone.nbvectors==3, _('Bad number of parts')
-
-        if self.centralpart is None:
-            self.centralpart = curzone.get_vector(0)
-        if self.upstream is None:
-            self.upstream = curzone.get_vector(1)
-        if self.downstream is None:
-            self.downstream = curzone.get_vector(2)
-
-        if self.centralpart is None:
-            raise Warning(_('Bad file : {}'.format(myfile)))
-        if self.upstream is None:
-            raise Warning(_('Bad file : {}'.format(myfile)))
-        if self.downstream is None:
-            raise Warning(_('Bad file : {}'.format(myfile)))
-
-        curzone = self.get_zone(zones_in_file.RIVER.value)
-        if curzone is None:
-            curzone = self.get_zone(1)
-            curzone.myname = zones_in_file.RIVER.value # on force le nom de la zone pour éviter de refaire le test ailleurs
-        if curzone is None:
-            raise Warning(_('Bad file : {}'.format(myfile)))
-
-        self.riverbed = curzone.get_vector('parallèle')    # vertices from upstream to downstream
-        if self.riverbed is None:
-            self.riverbed = curzone.get_vector(1)
-        if self.riverbed is None:
-            raise Warning(_('Bad file : {}'.format(myfile)))
-
-        self.riverbed.reverse()
-
-        self.leftbank = curzone.get_vector(2)    # vertices from upstream to downstream
-        if self.leftbank is None:
-            raise Warning(_('Bad file : {}'.format(myfile)))
-
-        self.leftbank.reverse()
-
-        self.rightbank = curzone.get_vector(0)    # vertices from upstream to downstream
-        if self.rightbank is None:
-            raise Warning(_('Bad file : {}'.format(myfile)))
-
-        self.rightbank.reverse()
-
-        curzone.myvectors = [self.leftbank, self.riverbed, self.rightbank] #inverse order to be up -> down
-
-        #création des polygones de rivière
-        curzone.create_polygon_from_parallel(ds)
-        self.polygons_zone:zone
-        self.polygons_zone = self.get_zone(-1)
-        self.polygons_curvi = {}
-        for curvert in self.polygons_zone.myvectors:
-            self.polygons_curvi[curvert.myname] = curvert.myvertices[0].z
+                # attribution des vecteurs pour les différentes parties de l'ouvrage
+
+                self.centralpart       = curzone.get_vector('tablier') # 4 vertices from Upstream Left to Dowstream Left passing by Upstream Right and Downstream Right
+                if self.centralpart is None:
+                    self.centralpart       = curzone.get_vector('seuil') # 4 vertices from Upstream Left to Dowstream Left passing by Upstream Right and Downstream Right
+
+                self.upstream   = curzone.get_vector('amont')   # 4 vertices from Upstream Left Deck  to Upstream Right Deck passing by Upstream Left Bank and Upstream Right Bank
+                self.downstream = curzone.get_vector('aval')    # 4 vertices from Downstream Left Deck Left to Downstream Right Deck passing by Downstream Left Bank and Downstream Right Bank
+
+                xydeck = self.centralpart.asnparray()
+
+                # point central de l'ouvrage
+                self.centerx = np.mean(xydeck[:,0]) # X coordinate of the deck
+                self.centery = np.mean(xydeck[:,1]) # X coordinate of the deck
+                self.curvi = 0                      # s curvilinear coordinate of the deck along a support polyline
+
+                """
+                Si certaines parties ne sont pas attribuées, il peut s'agir d'une mauvaise appellation.
+                Dans ce cas, on attribue sur base de la position dans la zone
+                """
+                assert curzone.nbvectors==3, _('Bad number of parts')
+
+                if self.centralpart is None:
+                    self.centralpart = curzone.get_vector(0)
+                if self.upstream is None:
+                    self.upstream = curzone.get_vector(1)
+                if self.downstream is None:
+                    self.downstream = curzone.get_vector(2)
+
+                if self.centralpart is None:
+                    raise Warning(_('Bad file : {}'.format(myfile)))
+                if self.upstream is None:
+                    raise Warning(_('Bad file : {}'.format(myfile)))
+                if self.downstream is None:
+                    raise Warning(_('Bad file : {}'.format(myfile)))
+
+                curzone = self.get_zone(zones_in_file_fr_vec.RIVER.value)
+                if curzone is None:
+                    curzone = self.get_zone(1)
+                    curzone.myname = zones_in_file_fr_vec.RIVER.value # on force le nom de la zone pour éviter de refaire le test ailleurs
+                if curzone is None:
+                    raise Warning(_('Bad file : {}'.format(myfile)))
 
-        for vec in self.polygons_zone.myvectors:
-            vec.myprop.used=False # cache les polygones pour ne pas surcharger l'affichage éventuel
+                self.riverbed = curzone.get_vector('parallèle')    # vertices from upstream to downstream
+                if self.riverbed is None:
+                    self.riverbed = curzone.get_vector(1)
+                if self.riverbed is None:
+                    raise Warning(_('Bad file : {}'.format(myfile)))
+
+                self.riverbed.reverse()
+
+                self.leftbank = curzone.get_vector(2)    # vertices from upstream to downstream
+                if self.leftbank is None:
+                    raise Warning(_('Bad file : {}'.format(myfile)))
+
+                self.leftbank.reverse()
+
+                self.rightbank = curzone.get_vector(0)    # vertices from upstream to downstream
+                if self.rightbank is None:
+                    raise Warning(_('Bad file : {}'.format(myfile)))
+
+                self.rightbank.reverse()
+
+            elif extension == '.vecz':
+
+                zone_names = [curzone.myname for curzone in self.myzones]
+
+                # test if all zones are present
+                for curkey in zones_in_file:
+                    if curkey.value not in zone_names:
+                        logging.warning(_('Zone {} not found in file {}'.format(curkey.value, myfile)))
+
+
+                if zones_in_file.PARTS.value in zone_names:
+                    # recherche de la zone du fichier contenant les 3 parties de l'ouvrage
+                    curzone = self.get_zone(zones_in_file.PARTS.value)
+
+                    vec_names = [curvec.myname for curvec in curzone.myvectors]
+                    for curkey in parts_values:
+                        if curkey.value not in vec_names:
+                            logging.error(_('Vector {} not found in zone {}'.format(curkey.value, zones_in_file.PARTS.value)))
+
+                    # attribution des vecteurs pour les différentes parties de l'ouvrage
+                    self.centralpart    = curzone.get_vector(parts_values.CENTRAL.value) # 4 vertices from Upstream Left to Dowstream Left passing by Upstream Right and Downstream Right
+                    self.upstream       = curzone.get_vector(parts_values.UPSTREAM.value)   # 4 vertices from Upstream Left Deck  to Upstream Right Deck passing by Upstream Left Bank and Upstream Right Bank
+                    self.downstream     = curzone.get_vector(parts_values.DOWNSTREAM.value)    # 4 vertices from Downstream Left Deck Left to Downstream Right Deck passing by Downstream Left Bank and Downstream Right Bank
+
+                xydeck = self.centralpart.asnparray()
+
+                # point central de l'ouvrage
+                self.centerx = np.mean(xydeck[:,0]) # X coordinate of the deck
+                self.centery = np.mean(xydeck[:,1]) # X coordinate of the deck
+                self.curvi = 0                      # s curvilinear coordinate of the deck along a support polyline
+
+                if self.centralpart is None:
+                    raise Warning(_('Bad file : {}'.format(myfile)))
+                if self.upstream is None:
+                    raise Warning(_('Bad file : {}'.format(myfile)))
+                if self.downstream is None:
+                    raise Warning(_('Bad file : {}'.format(myfile)))
+
+                if zones_in_file.RIVER.value in zone_names:
+                    curzone = self.get_zone(zones_in_file.RIVER.value)
+
+                    self.riverbed = curzone.get_vector(rivers_values.RIVERBED.value)    # vertices from upstream to downstream
+                    self.leftbank = curzone.get_vector(rivers_values.LEFTBANK.value)    # vertices from upstream to downstream
+                    self.rightbank = curzone.get_vector(rivers_values.RIGHTBANK.value)    # vertices from upstream to downstream
+
+                if self.riverbed is None:
+                    raise Warning(_('Bad file : {}'.format(myfile)))
+                if self.leftbank is None:
+                    raise Warning(_('Bad file : {}'.format(myfile)))
+                if self.rightbank is None:
+                    raise Warning(_('Bad file : {}'.format(myfile)))
+
+        self.create_polygon_river(ds)
+        self.force_plot()
+
+        self.colorize()
+
+    def force_plot(self):
 
         vecs = [self.centralpart, self.upstream, self.downstream, self.riverbed, self.leftbank, self.rightbank]
         vec: vector
         for vec in vecs:
-            vec.myprop.used=True
+            if vec is not None:
+                vec.myprop.used=True
 
-        self.colorize()
+    def create_polygon_river(self, ds:float=5.):
+        """ Create river polygons """
+
+        if self.leftbank is not None and self.riverbed is not None and self.rightbank is not None:
+
+            self.polygons_zone = zone(name= "polygons_river")
+            self.add_zone(self.polygons_zone, forceparent=True)
+            self.polygons_zone.myvectors = [self.leftbank, self.riverbed, self.rightbank] #inverse order to be up -> down
+
+            #création des polygones de rivière
+            self.polygons_zone.create_polygon_from_parallel(ds)
+
+            self.polygons_zone = self.get_zone(-1)
+            self.polygons_curvi = {}
+            for curvert in self.polygons_zone.myvectors:
+                self.polygons_curvi[curvert.myname] = curvert.myvertices[0].z
+
+            for vec in self.polygons_zone.myvectors:
+                vec.myprop.used=False # cache les polygones pour ne pas surcharger l'affichage éventuel
 
     def colorize(self):
         """Colorisation des polygones pour l'interface graphique"""
-        self.centralpart.myprop.color = getIfromRGB((0,255,0))
-        self.upstream.myprop.color = getIfromRGB((255,0,0))
-        self.downstream.myprop.color = getIfromRGB((0,0,255))
+
+        if self.centralpart is not None and self.upstream is not None and self.downstream is not None:
+
+            self.centralpart.myprop.color = getIfromRGB((0,255,0))
+            self.upstream.myprop.color = getIfromRGB((255,0,0))
+            self.downstream.myprop.color = getIfromRGB((0,0,255))
 
     def get_distance(self, x:float, y:float):
         """
@@ -260,7 +400,7 @@ class Bridge(Zones):
         ATTENTION : si linked_arrays est un dictionnaire, alors un niveau supérieur est ajouté sur base des clés de ce dictionnaire, dans ce cas, self.linked est un dict et non une liste
 
         """
-        curzone = self.get_zone(zones_in_file.PARTS.value)
+        curzone = self.get_zone(zones_in_file_fr_vec.PARTS.value)
 
         if isinstance(linked_arrays, dict):
 
@@ -1314,8 +1454,8 @@ class Weir(Bridge):
 
     def colorize(self):
         self.centralpart.myprop.color = getIfromRGB((102,102,255))
-        self.upstream.myprop.color = getIfromRGB((255,0,127))
-        self.downstream.myprop.color = getIfromRGB((102,0,204))
+        self.upstream.myprop.color    = getIfromRGB((255,0,127))
+        self.downstream.myprop.color  = getIfromRGB((102,0,204))
 
 class Weirs(Bridges):
 

wolfhece/scenario/config_manager.py

@@ -202,7 +202,7 @@ class Config_Manager_2D_GPU:
     Gestionnaire de configurations 2D - code GPU
     """
 
-    def __init__(self, workingdir:str = '', mapviewer:WolfMapViewer = None, python_venv:Path = None) -> None:
+    def __init__(self, workingdir:str = '', mapviewer:WolfMapViewer = None, python_venv:Path = None, create_ui_if_wx:bool = False) -> None:
         """
         Recherche de toutes les modélisation dans un répertoire et ses sous-répertoires
         """
@@ -235,6 +235,7 @@ class Config_Manager_2D_GPU:
 
         self._txtctrl = None
         self._ui  = None
+        self._create_ui_if_wx = create_ui_if_wx
 
         self._epsilon = 0.01
         self._filter_independent = True
@@ -287,7 +288,7 @@ class Config_Manager_2D_GPU:
             # la fenêtre est déjà ouverte
             self._ui.refill_data(self.configs)
         else:
-            if self.wx_exists:
+            if self.wx_exists and self._create_ui_if_wx:
                 self._ui = UI_Manager_2D_GPU(self.configs, parent=self)
 
 
@@ -1165,6 +1166,22 @@ class Config_Manager_2D_GPU:
             logging.error(_("No 'bathymetry.tif' file found in the root directory !"))
 
 
+    def verify_bath_roof_deck(self, bathymetry:WolfArray, bridge_roof:WolfArray):
+        """ Verify bathymetry, roof and deck """
+
+        if bridge_roof is None:
+            return
+
+        # si la matrice de toit de pont est plus basse que la bathymétrie, on met à 99999
+        # la bathymétrie et le toit de pont.
+        # Ainsi, ces maille seront infranchissables.
+        # Cale peut être utile pour discrétiser les piles dans les données du toit, plutôt que de les
+        # laisser inclure dans un fichier bath_ séparé.
+        mask = bridge_roof.array.data < bathymetry.array.data
+        bridge_roof.array.data[mask] = 99999.
+        bathymetry.array.data[mask]  = 99999.
+
+
     def create_simulation(self,
                           dir:Path,
                           idx_hydros:list[int] = [-1],
@@ -1280,6 +1297,8 @@ class Config_Manager_2D_GPU:
         # applying Python scrpitps on ARRAYS
         self._apply_scripts_update_topo_maning_inf_roof(dir, bat, man, infiltration, roof)
 
+        self.verify_bath_roof_deck(bat, roof)
+
         # save arrays on disk
         bat.write_all(str(dir / '__bathymetry_after_scripts.tif'))
         man.write_all(str(dir / '__manning_after_scripts.tif'))
@@ -1398,12 +1417,12 @@ class Config_Manager_2D_GPU:
                 f.write(str(curdir.drive) + '\n')
                 f.write('cd {}\n'.format(str(curdir.parent)))
                 f.write("\n")
-                f.write("WOLFGPU_PARAMS=-quickrun " + str(curdir.name) + "\n")
+                f.write("set WOLFGPU_PARAMS=-quickrun " + str(curdir.name) + "\n")
                 f.write("\n")
                 f.write("where wolfgpu.exe\n")
                 f.write("IF %ERRORLEVEL%==0 (\n")
                 f.write("wolfgpu %WOLFGPU_PARAMS%\n")
-                f.write("goto :end\n")
+                f.write("goto :exit\n")
                 f.write(")\n")
                 f.write("\n")
                 f.write("echo -------------------------------\n")
@@ -1417,7 +1436,7 @@ class Config_Manager_2D_GPU:
                 f.write("echo -------------------------------\n")
                 f.write("pause\n")
                 f.write("python -m wolfgpu.cli %WOLFGPU_PARAMS%\n")
-                f.write(":end\n")
+                f.write(":exit\n")
 
             allsims.append(curdir / 'quickrun.bat')
 
@@ -2588,4 +2607,4 @@ class UI_Manager_2D_GPU():
                         newroot = self._treelist.AppendItem(root, k, data = v)
 
                         for curfile in v:
-                            self._treelist.AppendItem(newroot, curfile.name, data = curfile)
+                            self._treelist.AppendItem(newroot, curfile.name, data = curfile)

wolfhece/wolf_array.py

@@ -3335,9 +3335,16 @@ class SelectionData():
         else:
             destxy = self.myselection
 
-        destij = np.asarray([list(curarray.get_ij_from_xy(x, y)) for x, y in destxy])
+        if len(destxy) == 0:
+            logging.error(_('No selection to unmask'))
+            return
+
+        if destxy == 'all':
+            curarray.array.mask[:, :] = False
+        else:
+            destij = np.asarray([list(curarray.get_ij_from_xy(x, y)) for x, y in destxy])
 
-        curarray.array.mask[destij[:, 0], destij[:, 1]] = False
+            curarray.array.mask[destij[:, 0], destij[:, 1]] = False
 
         if resetplot:
             curarray.reset_plot()
@@ -5629,7 +5636,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             - Float32
             - Float64
 
-        :param outdir: directory - If provided, the file will be savd as "outdir/idx+extent.tif" 
+        :param outdir: directory - If provided, the file will be savd as "outdir/idx+extent.tif"
                                    If not provided, we use the filename attribute
 
         :param extent: suffix to add to the filename before the extension '.tif' (only if outdir is provided)
@@ -5749,7 +5756,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         assert locarray.shape[1] == self.nby, _('Incompatible dimensions')
 
         if crop is not None :
-            logging.error(_('Cropping not yet implemented for numpy files'))
+            # logging.error(_('Cropping not yet implemented for numpy files'))
 
             imin, jmin = self.get_ij_from_xy(crop[0][0], crop[1][0])
             imax, jmax = self.get_ij_from_xy(crop[0][1], crop[1][1])
@@ -5795,6 +5802,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             return
 
+        raster:gdal.Dataset
         if crop is not None :
             if not os.path.exists(fn):
                 logging.error(_('File not found'))
@@ -5812,12 +5820,35 @@ class WolfArray(Element_To_Draw, header_wolf):
                     logging.error(_('Crop must be a list or a numpy array with 4 values - xmin, xmax, ymin, ymax'))
                     return
 
-                raster:gdal.Dataset
-                raster = gdal.Open(fn)
-                geotr = raster.GetGeoTransform()
+                raster_in:gdal.Dataset
+                raster_in = gdal.Open(fn)
+
+                proj = raster_in.GetProjection()
+                # check if proj is epsg:31370
+                if 'Lambert 72' not in proj and "31370" not in proj:
+                    logging.error(_('{} projection is not Lambert 72 - EPSG:31370').format(fn))
+
+                    raster_in2 = gdal.Dataset()
+                    gdal.Warp(raster_in2, raster_in, dstSRS='EPSG:31370')
+
+                    # Close the raster_in
+                    raster_in.FlushCache()
+                    raster_in = None
+
+                    raster_in = raster_in2
+
+                    if raster_in is None:
+                        logging.error(_('Could not reproject the file {fn}'))
+                        return
+
+                geotr = raster_in.GetGeoTransform()
                 self.dx = geotr[1]
                 self.dy = abs(geotr[5])
 
+                ulx = geotr[0]
+                uly = geotr[3]
+                llx = ulx + geotr[1] * raster_in.RasterXSize
+                lly = uly + geotr[5] * raster_in.RasterYSize
 
                 newcrop = CropDialog(None)
 
@@ -5868,20 +5899,29 @@ class WolfArray(Element_To_Draw, header_wolf):
 
                     fn_crop = fileDialog.GetPath()
 
+                if uly > lly:
+                    raster = gdal.Translate(fn_crop, fn, projWin=[xmin, ymax, xmax, ymin])
+                else:
+                    raster = gdal.Translate(fn_crop, fn, projWin=[xmin, ymin, xmax, ymax])
 
-                gdal.Translate(fn_crop, fn, projWin=[xmin, ymax, xmax, ymin])
                 fn  = fn_crop
             else:
                 from tempfile import NamedTemporaryFile
                 tmpfile = NamedTemporaryFile(suffix='.tif')
-                gdal.Translate(str(tmpfile.name), fn, projWin=[xmin, ymax, xmax, ymin])
+
+                if uly > lly:
+                    raster = gdal.Translate(str(tmpfile.name), fn, projWin=[xmin, ymax, xmax, ymin])
+                else:
+                    raster = gdal.Translate(str(tmpfile.name), fn, projWin=[xmin, ymin, xmax, ymax])
+
                 fn = str(tmpfile.name)
+        else:
+            raster = gdal.Open(fn)
 
-        raster:gdal.Dataset
-        raster = gdal.Open(fn)
 
-        # Projection
-        # proj = raster.GetProjection()
+        if raster is None:
+            logging.error(_('Could not open the file {fn}'))
+            return
 
         # Dimensions
         self.nbx = raster.RasterXSize
@@ -7936,41 +7976,51 @@ class WolfArray(Element_To_Draw, header_wolf):
             elif type(self.cropini) is list:
                 pass
             else:
-                newcrop = CropDialog(None)
+                if self.wx_exists:
+                    newcrop = CropDialog(None)
 
-                if self.mapviewer is not None:
-                    bounds = self.mapviewer.get_canvas_bounds()
+                    if self.mapviewer is not None:
+                        bounds = self.mapviewer.get_canvas_bounds()
 
-                    newcrop.dx.Value = str(self.dx)
-                    newcrop.dy.Value = str(self.dy)
+                        newcrop.dx.Value = str(self.dx)
+                        newcrop.dy.Value = str(self.dy)
 
-                    # newcrop.dx.Enable(False)
-                    # newcrop.dy.Enable(False)
+                        # newcrop.dx.Enable(False)
+                        # newcrop.dy.Enable(False)
 
-                    newcrop.ox.Value = str(float((bounds[0] // 50.) * 50.))
-                    newcrop.ex.Value = str(float((bounds[2] // 50.) * 50.))
-                    newcrop.oy.Value = str(float((bounds[1] // 50.) * 50.))
-                    newcrop.ey.Value = str(float((bounds[3] // 50.) * 50.))
+                        newcrop.ox.Value = str(float((bounds[0] // 50.) * 50.))
+                        newcrop.ex.Value = str(float((bounds[2] // 50.) * 50.))
+                        newcrop.oy.Value = str(float((bounds[1] // 50.) * 50.))
+                        newcrop.ey.Value = str(float((bounds[3] // 50.) * 50.))
 
-                badvalues = True
-                while badvalues:
-                    badvalues = False
+                    badvalues = True
+                    while badvalues:
+                        badvalues = False
 
-                    ret = newcrop.ShowModal()
-                    if ret == wx.ID_CANCEL:
-                        newcrop.Destroy()
-                        return
-                    else:
-                        self.cropini = [[float(newcrop.ox.Value), float(newcrop.ex.Value)],
-                                        [float(newcrop.oy.Value), float(newcrop.ey.Value)]]
-                        tmpdx = float(newcrop.dx.Value)
-                        tmpdy = float(newcrop.dy.Value)
+                        ret = newcrop.ShowModal()
+                        if ret == wx.ID_CANCEL:
+                            newcrop.Destroy()
+                            return
+                        else:
+                            self.cropini = [[float(newcrop.ox.Value), float(newcrop.ex.Value)],
+                                            [float(newcrop.oy.Value), float(newcrop.ey.Value)]]
+                            tmpdx = float(newcrop.dx.Value)
+                            tmpdy = float(newcrop.dy.Value)
+
+                        if self.dx != tmpdx or self.dy != tmpdy:
+                            if tmpdx / self.dx != tmpdy / self.dy:
+                                badvalues = True
+
+                    newcrop.Destroy()
+
+                    self.cropini = [[self.cropini[0][0] + self.dx/2., self.cropini[0][1] + self.dx/2.],
+                                    [self.cropini[1][0] + self.dy/2., self.cropini[1][1] + self.dy/2.]]
+                else:
+                    logging.warning(_('No crop defined and no wxPython available'))
+                    logging.info(_('Abort reading data !'))
+                    return
 
-                    if self.dx != tmpdx or self.dy != tmpdy:
-                        if tmpdx / self.dx != tmpdy / self.dy:
-                            badvalues = True
 
-                newcrop.Destroy()
 
             with open(self.filename, 'rb') as f:
                 if self.wolftype == WOLF_ARRAY_FULL_SINGLE or self.wolftype == WOLF_ARRAY_FULL_SINGLE_3D:
@@ -8007,6 +8057,10 @@ class WolfArray(Element_To_Draw, header_wolf):
 
                     self.array = ma.masked_array(locarray, dtype=np.float32)
 
+                else:
+                    logging.warning(_('Unsupported wolftype for cropping'))
+                    return
+
             if self.filename.endswith('.flt'):
                 # fichier .flt --> miroir "horizontal"
                 self.array = np.fliplr(self.array)