wolfhece 2.2.32__py3-none-any.whl → 2.2.34__py3-none-any.whl

wolfhece/PyVertexvectors.py

@@ -705,10 +705,17 @@ class vectorproperties:
         self.attachedimage = None
         self.imagevisible = False
         self.textureimage:genericImagetexture = None
+        self.image_scale = 1.0
+        self.image_relative_posx = 0.0
+        self.image_relative_posy = 0.0
+        self.image_attached_pointx = -99999.
+        self.image_attached_pointy = -99999.
 
         self.plot_indices = False
 
-    def get_extra(self) -> list[float,float,int,float,str,bool]:
+        self._cached_offset = None
+
+    def get_extra(self) -> list[float,float,int,float,str,bool, float, float, float, float, float]:
         """ Return extra properties """
         return [self.legendlength,
                 self.legendheight,
@@ -716,9 +723,15 @@ class vectorproperties:
                 self.legendorientation,
                 str(self.attachedimage),
                 self.imagevisible,
-                self.plot_indices]
-
-    def set_extra(self, linesextra:list[float,float,int,float,str,bool] = None):
+                self.plot_indices,
+                self.image_scale,
+                self.image_relative_posx,
+                self.image_relative_posy,
+                self.image_attached_pointx,
+                self.image_attached_pointy
+                ]
+
+    def set_extra(self, linesextra:list[float,float,int,float,str,bool, float, float, float, float, float] = None):
         """ Set extra properties """
 
         if linesextra is None:
@@ -728,7 +741,7 @@ class vectorproperties:
 
         self.legendlength = float(linesextra[0])
         self.legendheight = float(linesextra[1])
-        self.legendpriority = float(linesextra[2])
+        self.legendpriority = int(linesextra[2])
         self.legendorientation = float(linesextra[3])
 
         if len(linesextra)>4:
@@ -738,6 +751,13 @@ class vectorproperties:
         if len(linesextra)>6:
             self.plot_indices = linesextra[6].lower() == 'true'
 
+        if len(linesextra)>7:
+            self.image_scale = float(linesextra[7])
+            self.image_relative_posx = float(linesextra[8])
+            self.image_relative_posy = float(linesextra[9])
+            self.image_attached_pointx = float(linesextra[10])
+            self.image_attached_pointy = float(linesextra[11])
+
     def load_extra(self, lines:list[str]) -> int:
         """ Load extra properties from lines """
 
@@ -802,6 +822,18 @@ class vectorproperties:
 
                     (xmin,xmax),(ymin,ymax) = self.parent.get_bounds_xx_yy()
 
+                    if self.textureimage is not None:
+                        if self.textureimage.imageFile == self.attachedimage:
+                            self.textureimage.drawing_scale = self.image_scale
+                            self.textureimage.offset = (self.image_relative_posx, self.image_relative_posy)
+                            self.textureimage.xmin = xmin
+                            self.textureimage.xmax = xmax
+                            self.textureimage.ymin = ymin
+                            self.textureimage.ymax = ymax
+                            return
+                        else:
+                            self.textureimage.unload()
+
                     self.textureimage = genericImagetexture(which = 'attachedfile',
                                                             label=self.parent.myname,
                                                             mapviewer= self.parent.get_mapviewer(),
@@ -809,8 +841,9 @@ class vectorproperties:
                                                             xmin=xmin,
                                                             xmax=xmax,
                                                             ymin=ymin,
-                                                            ymax=ymax)
-                    # self.textureimage.load(str(self.textureimage))
+                                                            ymax=ymax,
+                                                            drawing_scale= self.image_scale,
+                                                            offset = (self.image_relative_posx, self.image_relative_posy))
                 else:
                     logging.warning('Image not found : {}'.format(self.attachedimage))
         else:
@@ -865,6 +898,11 @@ class vectorproperties:
 
         self.attachedimage = Path(props[('Image','Attached image')])
         self.imagevisible = props[('Image','To show')]
+        self.image_scale = props[('Image','Scale')]
+        self.image_relative_posx = props[('Image','Relative position X')]
+        self.image_relative_posy = props[('Image','Relative position Y')]
+        self.image_attached_pointx = props[('Image','Attached point X')]
+        self.image_attached_pointy = props[('Image','Attached point Y')]
 
         posx = props[('Move','Start X')]
         posy = props[('Move','Start Y')]
@@ -1008,6 +1046,11 @@ if :\n \
 
         self.myprops.addparam('Image','Attached image','',Type_Param.File, '', whichdict='Default')
         self.myprops.addparam('Image','To show',False,Type_Param.Logical,'',whichdict='Default')
+        self.myprops.addparam('Image','Scale',1.0,Type_Param.Float,'',whichdict='Default')
+        self.myprops.addparam('Image','Relative position X',0.0,Type_Param.Float,'',whichdict='Default')
+        self.myprops.addparam('Image','Relative position Y',0.0,Type_Param.Float,'',whichdict='Default')
+        self.myprops.addparam('Image','Attached point X',-99999.,Type_Param.Float,'',whichdict='Default')
+        self.myprops.addparam('Image','Attached point Y',-99999.,Type_Param.Float,'',whichdict='Default')
 
     def destroyprop(self):
         """
@@ -1113,6 +1156,11 @@ if :\n \
 
             self.myprops[('Image','Attached image')] = str(self.attachedimage)
             self.myprops[('Image','To show')] = self.imagevisible
+            self.myprops[('Image','Scale')] = self.image_scale
+            self.myprops[('Image','Relative position X')] = self.image_relative_posx
+            self.myprops[('Image','Relative position Y')] = self.image_relative_posy
+            self.myprops[('Image','Attached point X')] = self.image_attached_pointx
+            self.myprops[('Image','Attached point Y')] = self.image_attached_pointy
 
             if self.parent._rotation_center is not None:
                 self.myprops[('Rotation','center X')] = self.parent._rotation_center[0]
@@ -1144,6 +1192,31 @@ if :\n \
             self.myprops[('Move','Delta Y')] = 0.
 
             self.myprops.Populate()
+
+    def update_image_texture(self):
+        """ Update the image texture if it exists """
+        if self.textureimage is not None:
+            (xmin, xmax), (ymin, ymax) = self.parent.get_bounds_xx_yy()
+            self.textureimage.xmin = xmin
+            self.textureimage.xmax = xmax
+            self.textureimage.ymin = ymin
+            self.textureimage.ymax = ymax
+            self.textureimage.drawing_scale = self.image_scale
+            self.textureimage.offset = (self.image_relative_posx, self.image_relative_posy)
+
+    def _offset_image_texture(self, delta_x:float, delta_y:float):
+        """ Offset the image texture by a delta in x and y direction """
+
+        if self._cached_offset is None:
+            self._cached_offset = (self.image_relative_posx, self.image_relative_posy)
+
+        self.image_relative_posx = self._cached_offset[0] + delta_x
+        self.image_relative_posy = self._cached_offset[1] + delta_y
+
+    def _reset_cached_offset(self):
+        """ Reset the cached offset for the image texture """
+        self._cached_offset = None
+
 class vector:
     """
     Objet de gestion d'informations vectorielles
@@ -1419,11 +1492,13 @@ class vector:
         """ Set the cache for the vertices """
 
         self._cache_vertices = self.asnparray3d()
+        self._cache_bounds = np.array([[self.xmin, self.xmax], [self.ymin, self.ymax]])
 
     def clear_cache(self):
         """ Clear the cache for the vertices """
 
         self._cache_vertices = None
+        self._cache_bounds = None
 
     def move(self, deltax:float, deltay:float, use_cache:bool = True, inplace:bool = True):
         """
@@ -1445,10 +1520,26 @@ class vector:
 
             if use_cache:
                 self.xy = self._cache_vertices[:,:2] + np.array([deltax, deltay])
+                self.xmin = self._cache_bounds[0,0] + deltax
+                self.xmax = self._cache_bounds[0,1] + deltax
+                self.ymin = self._cache_bounds[1,0] + deltay
+                self.ymax = self._cache_bounds[1,1] + deltay
             else:
                 for curvert in self.myvertices:
                     curvert.x += deltax
                     curvert.y += deltay
+                # update the bounds
+                self.xmin += deltax
+                self.xmax += deltax
+                self.ymin += deltay
+                self.ymax += deltay
+
+            # update the texture image position if it exists
+            if self.myprop.textureimage is not None:
+                self.myprop.textureimage.xmin = self.xmin
+                self.myprop.textureimage.xmax = self.xmax
+                self.myprop.textureimage.ymin = self.ymin
+                self.myprop.textureimage.ymax = self.ymax
 
             return self
         else:
@@ -1482,6 +1573,14 @@ class vector:
                 for curvert in self.myvertices:
                     curvert.rotate(angle, center)
 
+            self.find_minmax()
+
+            if self.myprop.textureimage is not None:
+                self.myprop.textureimage.xmin = self.xmin
+                self.myprop.textureimage.xmax = self.xmax
+                self.myprop.textureimage.ymin = self.ymin
+                self.myprop.textureimage.ymax = self.ymax
+
             return self
         else:
             new_vector = self.deepcopy_vector(self.myname + '_rotated')
@@ -2071,6 +2170,13 @@ class vector:
 
         return self.myvertices[indexmp]
 
+    def update_image_texture(self):
+        """
+        Met à jour la texture de l'image si elle existe
+        """
+
+        self.myprop.update_image_texture()
+
     def find_minmax(self, only_firstlast:bool=False):
         """
         Recherche l'extension spatiale du vecteur
@@ -2090,6 +2196,8 @@ 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)
+
+            self.update_image_texture()
         else:
             self.xmin=-99999.
             self.ymin=-99999.
@@ -3589,6 +3697,32 @@ class vector:
         """ Alias for surface """
         return self.surface
 
+    def interpolate_coordinates(self):
+        """
+        Interpole les valeurs Z des vertices sur base des seules valeurs connues,
+        càd autre que infinity ou -99999 ou 99999.
+        """
+
+        sz = self.get_sz()
+        s = sz[0]
+        z = sz[1]
+
+        # Remove -99999 and empty values
+        valid_indices = np.where((z != -99999.) & (z != 99999.) & (z != '') & (np.isfinite(z)))[0]
+        if len(valid_indices) == 0:
+            logging.warning(_('No valid z values to interpolate'))
+            return
+
+        f = interp1d(s[valid_indices], z[valid_indices])
+
+        for k in range(self.nbvertices):
+            if k not in valid_indices:
+                z = f(s[k])
+                self.myvertices[k].z = z
+
+        self.update_lengths()
+        self._reset_listogl()
+
 class zone:
     """
     Objet de gestion d'informations vectorielles
@@ -4109,14 +4243,14 @@ class zone:
                     self.has_legend |= curvect.myprop.legendvisible
                     self.has_image  |= curvect.myprop.imagevisible
 
-        if self.has_legend:
-            for curvect in self.myvectors:
-                curvect.plot_legend(sx, sy, xmin, ymin, xmax, ymax, size)
-
         if self.has_image:
             for curvect in self.myvectors:
                 curvect.plot_image(sx, sy, xmin, ymin, xmax, ymax, size)
 
+        if self.has_legend:
+            for curvect in self.myvectors:
+                curvect.plot_legend(sx, sy, xmin, ymin, xmax, ymax, size)
+
     def plot_matplotlib(self, ax:plt.Axes):
         """
         Plot the zone using matplotlib
@@ -6699,6 +6833,14 @@ class Zones(wx.Frame, Element_To_Draw):
 
         return minvec
 
+    def find_vector_containing_point(self, x:float, y:float) -> vector:
+        """ Trouve le prmier vecteur contenant le point (x,y) """
+        xy = Point(x, y)
+        for curzone in self.myzones:
+            for curvect in curzone.myvectors:
+                if curvect.polygon.contains(xy):
+                    return curvect
+
     def reset_listogl(self):
         """
         Reset des listes OpenGL pour toutes les zones

wolfhece/Results2DGPU.py

@@ -274,9 +274,18 @@ class wolfres2DGPU(Wolfresults_2D):
                  idx: str = '',
                  plotted: bool = True,
                  mapviewer=None,
-                 store = None):
+                 store = None,
+                 load_from_cache:bool = True) -> None:
 
         fname = Path(fname)
+
+        # Test if fname is an url
+        if str(fname).startswith('http:') or str(fname).startswith('https:'):
+            from .pydownloader import download_gpu_simulation, DATADIR
+            ret = download_gpu_simulation(fname, DATADIR / fname.name, load_from_cache = load_from_cache)
+            assert isinstance(ret, ResultsStore), _("Download failed or did not return a ResultsStore instance")
+            fname = DATADIR / fname.name
+
         self._nap = None
 
         if not fname.name.lower() == 'simul_gpu_results':

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 2
-        self.patch = 32
+        self.patch = 34
 
     def __str__(self):
 

wolfhece/pydownloader.py

@@ -36,6 +36,11 @@ class DownloadFiles(Enum):
     VECFILES = ('vec', 'vec.extra')
     VECZFILES = ('vecz', 'vecz.extra')
     PROJECTFILES = ('proj',)
+    NUMPYFILES = ('npy',)
+    NPZFILES = ('npz',)
+    JSONFILES = ('json',)
+    TXTFILES = ('txt',)
+    CSVFILES = ('csv',)
 
 class DonwloadDirectories(Enum):
     """ Enum to define the directories for downloads. """
@@ -43,6 +48,7 @@ class DonwloadDirectories(Enum):
 
 
 GITLAB_EXAMPLE = 'https://gitlab.uliege.be/HECE/wolf_examples/-/raw/main'
+GITLAB_EXAMPLE_GPU = 'https://gitlab.uliege.be/HECE/wolfgpu_examples/-/raw/main'
 DATADIR = Path(__file__).parent / 'data' / 'downloads'
 
 def clean_url(url: str) -> str:
@@ -63,6 +69,10 @@ def clean_url(url: str) -> str:
     cleaned_url = re.sub(r'(?<!:)//+', '/', cleaned_url)
     # Convert Backslashes to forward slashes
     cleaned_url = cleaned_url.replace('\\', '/')
+
+    cleaned_url = cleaned_url.replace(':/', '://')
+    cleaned_url = cleaned_url.replace(':///', '://')
+
     # Ensure the URL starts with http:// or https://
     if not cleaned_url.startswith(('http://', 'https://', 'ftp://')):
         raise ValueError(f"Invalid URL: {url}. Must start with http://, https://, or ftp://")
@@ -171,6 +181,77 @@ def toys_dataset(dir:str, file:str, load_from_cache:bool = True):
     destination = DATADIR / dir / file
     return download_file(url, destination, load_from_cache=load_from_cache)
 
+def download_gpu_simulation(url:str, destination:str | Path, load_from_cache:bool = True):
+    """ Download a GPU simulation file from the WOLFHECE dataset.
+
+    :param url: The URL of the GPU simulation file to download.
+    :param destination: The path where the file will be saved.
+    :param load_from_cache: If True, will not download the file if it already exists.
+    :type url: str
+    :type destination: str | Path
+    :type load_from_cache: bool
+    """
+
+    url = str(url).strip()
+    url = clean_url(url)
+    destination = Path(destination)
+
+    files = ['NAP.npy', 'bathymetry.npy', 'bridge_roof.npy', 'bridge_deck.npy', 'h.npy', 'manning.npy', 'qx.npy', 'qy.npy', 'parameters.json']
+    dir_res = 'simul_gpu_results'
+    res_files = ['metadata.json', 'nap.npz', 'nb_results.txt', 'sim_times.csv']
+
+    try:
+        for file in files:
+            try:
+                download_file(f"{url}/{file}", destination / file, load_from_cache=load_from_cache)
+            except Exception as e:
+                logging.error(f"Error downloading file {file} from {url}: {e}")
+
+        url = url + '/' + dir_res
+        destination = destination / dir_res
+        for file in res_files:
+            try:
+                download_file(f"{url}/{file}", destination / file, load_from_cache=load_from_cache)
+            except Exception as e:
+                logging.error(f"Error downloading result file {file} from {url}: {e}")
+
+        with open(destination / 'nb_results.txt', 'r') as f:
+            nb_results = int(f.read().strip())
+
+        for i in range(1,nb_results+1):
+            # h_0000001.npz
+            # qx_0000001.npz
+            # qy_0000001.npz
+            for file in ['h', 'qx', 'qy']:
+                try:
+                    download_file(f"{url}/{file}_{i:07d}.npz", destination / f'{file}_{i:07d}.npz', load_from_cache=load_from_cache)
+                except Exception as e:
+                    logging.error(f"Error downloading result file {file}_{i:07d}.npz from {url}: {e}")
+
+        from wolfgpu.results_store import ResultsStore
+        rs = ResultsStore(destination)
+
+    except Exception as e:
+        logging.error(f"Error downloading GPU dataset {dir}: {e}")
+        rs = None
+
+    return rs
+
+def toys_gpu_dataset(dir:str, dirweb:str = None, load_from_cache:bool = True):
+    """ Download toy simulatoin files from the WOLFHECE dataset for GPU.
+
+    :param dir: The directory where the file will be saved.
+    :param dirweb: The directory of the files to download.
+    :type dir: str
+    :type dirweb: str
+    :return: The path to the downloaded file.
+    """
+
+    if dirweb is None:
+        dirweb = dir
+
+    return download_gpu_simulation(f"{GITLAB_EXAMPLE_GPU}/{dirweb}", DATADIR / dir, load_from_cache=load_from_cache)
+
 if __name__ == "__main__":
     # Example usage
     print(download_file(r'https:\\gitlab.uliege.be\HECE\wolf_examples\-\raw\main\Extract_part_array\extraction.vec'))
@@ -180,3 +261,4 @@ if __name__ == "__main__":
     print(download_file('https://gitlab.uliege.be/HECE/wolf_examples/-/raw/main/Array_Theux_Pepinster/mnt.tif'))
     print(download_file('https://gitlab.uliege.be/HECE/wolf_examples/-/raw/main/PICC/PICC_Vesdre.shp'))
     print(toys_dataset('Extract_part_array', 'extraction.vec'))
+    rs = toys_gpu_dataset('channel_w_archbridge_fully_man004')

wolfhece/textpillow.py

@@ -194,7 +194,7 @@ class Text_Infos():
         elif self.priority == Font_Priority.HEIGHT:
             self.fontsize = int(self.fontsize/scaley)
 
-        self.fontsize=min(self.fontsize,200)
+        self.fontsize=max(min(self.fontsize,200),2)
 
         self.findsize(text)
 

wolfhece/wolf_texture.py

@@ -48,12 +48,32 @@ class genericImagetexture(Element_To_Draw):
                  which: str,
                  label: str,
                  mapviewer,
-                 xmin, xmax, ymin, ymax,
-                 imageFile="",
-                 imageObj=None,
+                 xmin:float, xmax:float, ymin:float, ymax:float,
+                 imageFile:str = "",
+                 imageObj = None,
                  transparent_color = None,
                  tolerance:int = 3,
-                 replace_color = None) -> None:
+                 replace_color = None,
+                 drawing_scale:float = 1.0,
+                 offset:list[float, float] = [0.,0.]) -> None:
+
+        """ Initialize the image texture
+
+        :param which: Type of image (e.g., 'satellite', 'map', etc.)
+        :param label: Label for the texture
+        :param mapviewer: The map viewer object to which this texture belongs
+        :param xmin: Minimum X coordinate for the texture
+        :param xmax: Maximum X coordinate for the texture
+        :param ymin: Minimum Y coordinate for the texture
+        :param ymax: Maximum Y coordinate for the texture
+        :param imageFile: Optional file path to load the image from
+        :param imageObj: Optional PIL Image object to use instead of loading from file
+        :param transparent_color: Color to treat as transparent in the image
+        :param tolerance: Tolerance for color matching when replacing transparent color
+        :param replace_color: Color to replace the transparent color with
+        :param drawing_scale: Scale factor for the image
+        :param offset: Offset to apply to the texture position
+        """
 
         super().__init__(label, True, mapviewer, False)
 
@@ -61,6 +81,7 @@ class genericImagetexture(Element_To_Draw):
             self.mapviewer.canvas.SetCurrent(mapviewer.context)
         except:
             logging.error(_('Opengl setcurrent -- Do you have a active canvas ?'))
+            return
 
         self.time = None
         self.xmin = xmin
@@ -82,6 +103,9 @@ class genericImagetexture(Element_To_Draw):
         self.imageFile = imageFile
         self.myImage = imageObj
 
+        self.drawing_scale = drawing_scale
+        self.offset = offset
+
         if imageFile != "":
             if exists(imageFile):
                 try:
@@ -142,6 +166,11 @@ class genericImagetexture(Element_To_Draw):
             del self.myImage
 
     def load(self, imageFile=""):
+        """ Load the image texture into OpenGL
+
+        :param imageFile: Optional file path to load the image from
+        """
+
         if self.width == -99999 or self.height == -99999:
             return
 
@@ -167,6 +196,7 @@ class genericImagetexture(Element_To_Draw):
                 'Opengl setcurrent -- maybe a conflict with an existing opengl32.dll file - please rename the opengl32.dll in the libs directory and retry')
 
     def update_minmax(self):
+        """ Update the spatial extent of the texture based on its size """
 
         if self.myImage is None:
             return
@@ -181,7 +211,7 @@ class genericImagetexture(Element_To_Draw):
 
             self.ymax = self.ymin + dx *scale
 
-    def reload(self,xmin=-99999,xmax=-99999,ymin=-99999,ymax=-99999):
+    def reload(self, xmin=-99999, xmax=-99999, ymin=-99999, ymax=-99999):
 
         if xmin !=-99999:
             self.xmin = xmin
@@ -210,7 +240,28 @@ class genericImagetexture(Element_To_Draw):
         # Nothing to do, set during initialization phase
         pass
 
+    def uv(self, x: float, y: float) -> tuple[float, float]:
+        """ Convert coordinates to texture coordinates taking into account the texture's spatial extent,
+        the scaleing factor, and the offset.
+
+        :param x: X coordinate in pixels
+        :param y: Y coordinate in pixels
+        :return: Tuple of (u, v) texture coordinates
+        """
+        if self.width == -99999 or self.height == -99999:
+            return 0.0, 0.0
+
+        u = (x - self.offset[0] - self.xmin) / ((self.xmax - self.xmin) * self.drawing_scale)
+        v = 1.0 - (y - self.offset[1] - self.ymin) / ((self.ymax - self.ymin) * self.drawing_scale)
+
+        # Ensure u and v are within the range [0, 1]
+        u = max(0.0, min(1.0, u))
+        v = max(0.0, min(1.0, v))
+
+        return u, v
+
     def paint(self):
+        """ Paint the image texture on the OpenGL canvas """
 
         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
 
@@ -222,14 +273,31 @@ class genericImagetexture(Element_To_Draw):
         glBindTexture(GL_TEXTURE_2D, self.idtexture[0])
 
         glBegin(GL_QUADS)
-        glTexCoord2f(0.0, 0.0)
-        glVertex2f(self.xmin, self.ymax)
-        glTexCoord2f(1.0, 0.0)
-        glVertex2f(self.xmax, self.ymax)
-        glTexCoord2f(1.0, 1.0)
-        glVertex2f(self.xmax, self.ymin)
-        glTexCoord2f(0.0, 1.0)
-        glVertex2f(self.xmin, self.ymin)
+
+        # Draw a quad with texture coordinates
+        xy = [[self.xmin, self.ymax],
+              [self.xmax, self.ymax],
+              [self.xmax, self.ymin],
+              [self.xmin, self.ymin]]
+        uv = [self.uv(x,y) for x,y in xy]
+
+        glTexCoord2f(uv[0][0], uv[0][1])
+        glVertex2f(xy[0][0], xy[0][1])
+        glTexCoord2f(uv[1][0], uv[1][1])
+        glVertex2f(xy[1][0], xy[1][1])
+        glTexCoord2f(uv[2][0], uv[2][1])
+        glVertex2f(xy[2][0], xy[2][1])
+        glTexCoord2f(uv[3][0], uv[3][1])
+        glVertex2f(xy[3][0], xy[3][1])
+
+        # glTexCoord2f(0.0, 0.0)
+        # glVertex2f(self.xmin, self.ymax)
+        # glTexCoord2f(1.0, 0.0)
+        # glVertex2f(self.xmax, self.ymax)
+        # glTexCoord2f(1.0, 1.0)
+        # glVertex2f(self.xmax, self.ymin)
+        # glTexCoord2f(0.0, 1.0)
+        # glVertex2f(self.xmin, self.ymin)
         glEnd()
         glDisable(GL_TEXTURE_2D)
         glDisable(GL_BLEND)