aceti 0.0.1__tar.gz

aceti-0.0.1/.gitignore

@@ -0,0 +1,2 @@
+dist/
+__pycache__/

aceti-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2025 Alejandro Casado Pérez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aceti-0.0.1/MANIFEST.in

@@ -0,0 +1 @@
+graft maps

aceti-0.0.1/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: aceti
+Version: 0.0.1
+Summary: A simple package to store and create maps for an experiment
+Project-URL: Homepage, https://github.com/aceti-pub/common_maps
+Project-URL: Issues, https://github.com/aceti-pub/common_maps/issues
+Author-email: Alejandro Casado <acasado4@us.es>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: numpy
+Description-Content-Type: text/markdown
+
+aceti_maps
+===========
+
+* Python library to make an efficient use of data
+* License: MIT
+* Compatible With: python 3.0+
+
+Develop API Usage
+-----------------
+
+available maps
+- Alamillo
+- Alamillo11x15
+- Alamillo30x49
+
+<pre>
+<code>
+>>>from aceti_maps import import_map
+>>>base_matrix, lat_lon_map  = import_map("alamillo11x15")
+
+</code>
+</pre>

aceti-0.0.1/README.md

@@ -0,0 +1,29 @@
+La forma de hacer upload de este paquete se realiza mediante Hatchling siguiendo el [tutorial de python](https://packaging.python.org/en/latest/tutorials/packaging-projects/)
+
+esta librería recibe el nombre de aceti_maps
+
+asegurarse de tener pip actualizado a la última versión
+```bash
+$ python3 -m pip install --upgrade pip
+```
+construir el repositorio
+```bash
+$ python3 -m build
+```
+
+subirlo al repositorio deseado
+```bash
+$ python3 -m twine upload --repository testpypi dist/*
+$ python3 -m twine upload dist/*
+```
+el token lo tiene acasado4@us.es
+
+
+
+instalar mediante
+```bash
+$ python3 -m pip install --index-url https://test.pypi.org/simple/ --no-deps aceti_maps
+$ pip install aceti_maps
+```
+
+la guía de uso está disponible en [README_LEG](./README_LEG.md)

aceti-0.0.1/README_LEG.md

@@ -0,0 +1,22 @@
+aceti_maps
+===========
+
+* Python library to make an efficient use of data
+* License: MIT
+* Compatible With: python 3.0+
+
+Develop API Usage
+-----------------
+
+available maps
+- Alamillo
+- Alamillo11x15
+- Alamillo30x49
+
+<pre>
+<code>
+>>>from aceti_maps import import_map
+>>>base_matrix, lat_lon_map  = import_map("alamillo11x15")
+
+</code>
+</pre>

aceti-0.0.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+[project]
+name = "aceti"
+version = "0.0.1"
+authors = [
+  { name="Alejandro Casado", email="acasado4@us.es" },
+]
+description = "A simple package to store and create maps for an experiment"
+readme = "README_LEG.md"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Education",
+    "Programming Language :: Python :: 2",
+    "Programming Language :: Python :: 3",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+dependencies = [
+  "numpy",
+]
+
+[project.urls]
+Homepage = "https://github.com/aceti-pub/common_maps"
+Issues = "https://github.com/aceti-pub/common_maps/issues"

aceti-0.0.1/src/aceti/__init__.py

@@ -0,0 +1,2 @@
+# from .maps_utils import png_to_csv, csv_to_png, csv_to_npy, invert_map, get_output_name, csv_shrink, csv_downsize
+from .map_importer import import_map

aceti-0.0.1/src/aceti/map_importer.py

@@ -0,0 +1,29 @@
+import numpy as np
+import os
+import sys
+if sys.version_info < (3, 9):
+    # importlib.resources either doesn't exist or lacks the files() function, so use the PyPI version:
+    import importlib_resources
+else:
+    # importlib.resources has files(), so use that:
+    import importlib.resources as importlib_resources
+
+def import_map(map_name: str):
+    """
+    Import a map from a file and return the base matrix and lat/lon map.
+    Args:
+        map_name (str): The name of the map to import.
+    Returns:
+        tuple: A tuple containing the base matrix and lat/lon map.
+    """
+    map_name = map_name.lower()
+    pkg = importlib_resources.files("aceti_maps")
+    if os.path.exists(pkg.joinpath("maps", f"{map_name}mask.npy")):
+        print(f"Loading map {map_name} from repo directory")
+
+    base_matrix = np.load(pkg.joinpath("maps", f"{map_name}mask.npy"))
+
+    # Load the lat/lon map
+    lat_lon_map = np.load(pkg.joinpath("maps", f"{map_name}latlon.npy"))
+
+    return base_matrix, lat_lon_map

aceti-0.0.1/src/aceti/old/create grid.py

@@ -0,0 +1,573 @@
+
+# modified from the scripts created by Hayden Eskriett [http://eskriett.com] and jbndlr
+# Find the associated blog post at: http://blog.eskriett.com/2013/07/19/downloading-google-maps/
+# but it has been done in a better way using the data in https://developers.google.com/maps/documentation/javascript/coordinates
+# and https://stackoverflow.com/questions/40342355/how-can-i-generate-a-regular-geographic-grid-using-python
+
+
+
+
+
+###################################IMPORTANT##################################
+#Google maps works with [Latitude Longitude] variables however
+#Dronekit and other programs (such as gridder) work with [Longitude Latitude] variables
+##############################################################################
+
+import urllib.request
+from PIL import Image
+import os
+import math
+import pyproj
+import matplotlib.pyplot as plt
+import numpy as np
+# from KMLMissionGeneration import KMLMissionGenerator
+class CustomError(Exception):
+     pass
+
+class GoogleMapDownloader:
+    """
+        A class which generates high resolution google maps image given
+        Northwest and Southeast points in [Lat Lon] and zoom level
+        You can change the quality of the image by changing the zoom and layer values
+        
+        19 is a valid zoom value knowing the size of our drone
+        
+        for the maps you have available
+        ROADMAP = "v"
+        TERRAIN = "p"
+        ALTERED_ROADMAP = "r"
+        SATELLITE = "s"
+        TERRAIN_ONLY = "t"
+        HYBRID = "y"
+        
+        
+    """
+
+    def __init__(self, Northwest, Southeast, zoom=19, layer="s"):
+        """
+            GoogleMapDownloader Constructor
+            Args:
+                lat:    The latitude of the location required
+                lng:    The longitude of the location required
+                zoom:   The zoom level of the location required, ranges from 0 - 23
+        """
+        self.Northwest = Northwest
+        self.Southeast = Southeast
+        self._zoom = zoom
+        self._layer = layer
+        
+        if Northwest[0]<=Southeast[0] or Northwest[1]>=Southeast[1]:
+            raise CustomError("You must use Northwest(top-left) and Southeast(bottom-right) coordinates")
+        self.get_nw_coordinates()
+        self.get_se_coordinates()
+        
+        if (abs(self.nw_tile[0]-self.se_tile[0]) == 0) or (abs(self.nw_tile[1]-self.se_tile[1]) == 0):
+            raise CustomError("Insuficient zoom, points are too close, i am lazy to program this, increase zoom")
+        
+        
+
+    def get_nw_coordinates(self):
+        """
+            Generates an X,Y tile and pixel coordinate based on the latitude, longitude
+            and zoom level
+            Returns:    An X,Y pixel coordinate
+        """
+
+        tile_size = 256 #each tile has 256 pixels
+
+        # Use a left shift to get the power of 2, zoom 0 is a world map, zoom 1 is wold map divided in 4 tiles, zoom 2 is world map divided in 16 tiles
+        # i.e. a zoom level of 2 will have 2^2 = 4 tiles as coordinate sistem divides axis in 4 (x+y+,x-y+,x-y-,x+y-)
+        numTiles = 1 << self._zoom
+
+        # Find the x_pixel given the longitude
+        x_pixel = (tile_size / 2 + self.Northwest[1] * tile_size / 360.0) * numTiles 
+
+        # Convert the latitude to radians and take the sine
+        sin_y = math.sin(self.Northwest[0] * (math.pi / 180.0))
+
+        # Calulate the y_pixel
+        y_pixel = ((tile_size / 2) + 0.5 * math.log((1 + sin_y) / (1 - sin_y)) * -(
+        tile_size / (2 * math.pi))) * numTiles 
+        
+        self.nw_pixel=[x_pixel, y_pixel]
+        self.nw_tile=[int(x_pixel // tile_size), int(y_pixel // tile_size)]
+    
+    def get_se_coordinates(self):
+        """
+            Generates an X,Y tile and pixel coordinate based on the latitude, longitude
+            and zoom level
+            Returns:    An X,Y pixel coordinate
+        """
+
+        tile_size = 256 #each tile has 256 pixels
+
+        # Use a left shift to get the power of 2, zoom 0 is a world map, zoom 1 is wold map divided in 4 tiles, zoom 2 is world map divided in 16 tiles
+        # i.e. a zoom level of 2 will have 2^2 = 4 tiles as coordinate sistem divides axis in 4 (x+y+,x-y+,x-y-,x+y-)
+        numTiles = 1 << self._zoom
+
+        # Find the x_pixel given the longitude
+        x_pixel = (tile_size / 2 + self.Southeast[1] * tile_size / 360.0) * numTiles 
+
+        # Convert the latitude to radians and take the sine
+        sin_y = math.sin(self.Southeast[0] * (math.pi / 180.0))
+
+        # Calulate the y_pixel
+        y_pixel = ((tile_size / 2) + 0.5 * math.log((1 + sin_y) / (1 - sin_y)) * -(
+        tile_size / (2 * math.pi))) * numTiles 
+        
+        self.se_pixel=[x_pixel, y_pixel]
+        self.se_tile=[math.ceil(x_pixel // tile_size)+1, math.ceil(y_pixel // tile_size)+1]
+            
+    def generateImage(self, ):
+        """
+            Generates an image by stitching a number of google map tiles together.
+
+            Args:
+                start_x:        The top-left x-tile coordinate
+                start_y:        The top-left y-tile coordinate
+                tile_width:     The number of tiles wide the image should be -
+                                defaults to 5
+                tile_height:    The number of tiles high the image should be -
+                                defaults to 5
+            Returns:
+                A high-resolution Goole Map image.
+        """
+        tile_width = abs(self.nw_tile[0]-self.se_tile[0])
+        tile_height = abs(self.nw_tile[1]-self.se_tile[1])
+        
+        
+            
+        # Determine the size of the image, for simplicity, we will print the whole image and later crop it
+        width, height = 256 * tile_width, 256 * tile_height
+
+        # Create a new image of the size required
+        map_img = Image.new('RGB', (width, height))
+        
+        
+        # calculate northwest pixel of the tile
+        start_x=self.nw_tile[0]
+        start_y=self.nw_tile[1]
+
+        # print the map
+        for x in range(0, tile_width):
+            for y in range(0, tile_height):
+                
+                url = f'https://mt0.google.com/vt?lyrs={self._layer}&x=' + str(start_x + x) + '&y=' + str(start_y + y) + '&z=' + str(
+                    self._zoom)
+
+                current_tile = str(x) + '-' + str(y)
+                urllib.request.urlretrieve(url, current_tile)
+
+                im = Image.open(current_tile)
+                map_img.paste(im, (x * 256, y * 256))
+
+                os.remove(current_tile)
+        
+        
+        # cut corners
+        left=abs(self.nw_tile[0] * 256 - self.nw_pixel[0])
+        top=abs(self.nw_tile[1] * 256 - self.nw_pixel[1])
+        right=left + abs(self.se_pixel[0] - self.nw_pixel[0])
+        bottom=top + abs(self.nw_pixel[1] - self.se_pixel[1])
+        
+        
+        map_img = map_img.crop((left, top, right, bottom))
+        return map_img
+
+class gridder:
+    
+    def __init__(self, NW_corner, SE_corner, grid_size, zoom =19):
+        """
+            Args:
+                NW_corner:
+                SE_corner:   
+                grid_size:   
+        """
+        
+        
+        
+        # Set up transformers, EPSG:3857 is metric, same as EPSG:900913
+        self.to_proxy_transformer = pyproj.Transformer.from_crs('epsg:4326', 'epsg:3857')
+        self.to_original_transformer = pyproj.Transformer.from_crs('epsg:3857', 'epsg:4326')
+        
+        # Project corners to target projection
+        self.NW_corner=[NW_corner[1],NW_corner[0]]
+        self.SE_corner=[SE_corner[1],SE_corner[0]]
+        
+        #this transformation works in [Longitude Latitude]
+        self.transformed_nw = self.to_proxy_transformer.transform(self.NW_corner[1], self.NW_corner[0]) # Transform NW point to 3857
+        self.transformed_se = self.to_proxy_transformer.transform(self.SE_corner[1], self.SE_corner[0]) # .. same for SE
+        
+        self.pole=["E","N"]
+        self.grid_size=grid_size
+        self.zoom = zoom
+        print(f"map size is {int(abs(self.transformed_nw[1]-self.transformed_se[1]))}x{int(abs(self.transformed_nw[0]-self.transformed_se[0]))}m")
+        self.create_grid()
+        print(f"grid size is {self.width}x{self.heigth} cells")
+        self.calculate_pixels_per_grid()
+        
+        
+        
+        
+        
+    def save_to_file(self, name):
+        with open(name, 'w') as of:
+            for j in range(self.heigth):
+                for i in range(self.width):
+                    of.write('{:f},{:f};'.format(self.gridpoints[j][i][0], self.gridpoints[j][i][1]))
+                of.write('\n')
+            
+            
+    def create_grid(self):
+        # Iterate over 2D area
+        self.gridpoints = []
+        countx=0
+        county=0
+        x = self.transformed_nw[0]
+        if self.transformed_nw[0] >self.transformed_se[0]:
+            self.pole[0]="N"
+        else:
+            self.pole[0]="S"
+        while abs(x) > abs(self.transformed_se[0]):
+            county+=1
+            countx=0
+            column=[]
+            y = self.transformed_nw[1]
+            if self.transformed_nw[1] <self.transformed_se[1]:
+                self.pole[1]="E"
+            else:
+                self.pole[1]="W"
+            while abs(y) > abs(self.transformed_se[1]):
+                p = self.to_original_transformer.transform(x, y)
+                column.append([p[0],p[1]])
+                if self.pole[1]=="E":
+                    y += self.grid_size
+                else:
+                    y -= self.grid_size
+                countx+=1
+            column.pop() #cut corners
+            self.gridpoints.append(column)
+            if self.pole[0]=="N":
+                x -=self.grid_size
+            else:
+                x +=self.grid_size
+        self.gridpoints.pop() #cut corners
+        self.width=len(self.gridpoints[0])
+        self.heigth=len(self.gridpoints)
+            
+        
+    def to_pixel(self, GPS_point, zoom=19):
+        """
+            Generates an X,Y pixel coordinate based on the latitude, longitude
+            and zoom level
+            Returns:    An X,Y pixel coordinate
+        """
+        #check if we are inside the map
+        if self.pole[1]=="W":
+            if ((self.SE_corner[1])>(GPS_point[1])>(self.NW_corner[1])):
+                raise CustomError(f"point {GPS_point} 1W is outside the map {[self.NW_corner,self.SE_corner]}")
+        else:
+            if ((self.SE_corner[1])<(GPS_point[1])<(self.NW_corner[1])):
+                raise CustomError(f"point {GPS_point} 1E is outside the map {[self.NW_corner,self.SE_corner]}")
+        if self.pole[0]=="N":
+            if ((self.SE_corner[0])>(GPS_point[0])>(self.NW_corner[0])):
+                raise CustomError(f"point {GPS_point} 0N is outside the map {[self.NW_corner,self.SE_corner]}")
+        else:
+            if ((self.SE_corner[0])<(GPS_point[0])<(self.NW_corner[0])):
+                raise CustomError(f"point {GPS_point} 0S is outside the map {[self.NW_corner,self.SE_corner]}")
+
+
+
+        tile_size = 256 #each tile has 256 pixels
+
+        # Use a left shift to get the power of 2, zoom 0 is a world map, zoom 1 is wold map divided in 4 tiles, zoom 2 is world map divided in 16 tiles
+        # i.e. a zoom level of 2 will have 2^2 = 4 tiles as coordinate sistem divides axis in 4 (x+y+,x-y+,x-y-,x+y-)
+        numTiles = 1 << self.zoom
+
+        # Find the x_pixel given the longitude
+        x_pixel = (tile_size / 2 + GPS_point[1] * tile_size / 360.0) * numTiles 
+
+        # Convert the latitude to radians and take the sine
+        sin_y = math.sin(GPS_point[0] * (math.pi / 180.0))
+
+        # Calulate the y_pixel
+        y_pixel = ((tile_size / 2) + 0.5 * math.log((1 + sin_y) / (1 - sin_y)) * -(
+        tile_size / (2 * math.pi))) * numTiles 
+        
+        return [x_pixel-self.corner_pixel[0], y_pixel-self.corner_pixel[1]]
+    
+    def calculate_pixels_per_grid(self):
+        
+        self.calculate_corner_pixel()
+        p=self.to_pixel(self.gridpoints[self.heigth-1][self.width-1])
+        x=p[0]
+        y=p[1]
+        self.pixel_width=x/(self.width-1)
+        self.pixel_heigth=y/(self.heigth-1)
+        print(f"pixel size is {x}x{y} with corner {self.corner_pixel}")
+            
+    def calculate_corner_pixel(self):
+        """
+            Generates an X,Y pixel coordinate based on the latitude, longitude
+            and zoom level
+            Returns:    An X,Y pixel coordinate
+        """
+
+        tile_size = 256 #each tile has 256 pixels
+
+        # Use a left shift to get the power of 2, zoom 0 is a world map, zoom 1 is wold map divided in 4 tiles, zoom 2 is world map divided in 16 tiles
+        # i.e. a zoom level of 2 will have 2^2 = 4 tiles as coordinate sistem divides axis in 4 (x+y+,x-y+,x-y-,x+y-)
+        numTiles = 1 << self.zoom
+
+        # Find the x_pixel given the longitude
+        x_pixel = (tile_size / 2 + self.NW_corner[0] * tile_size / 360.0) * numTiles 
+
+        # Convert the latitude to radians and take the sine
+        sin_y = math.sin(self.NW_corner[1] * (math.pi / 180.0))
+
+        # Calulate the y_pixel
+        y_pixel = ((tile_size / 2) + 0.5 * math.log((1 + sin_y) / (1 - sin_y)) * -(
+        tile_size / (2 * math.pi))) * numTiles 
+        
+        self.corner_pixel=[x_pixel, y_pixel]
+        
+    def show_grid(self, img):
+            
+        #show grid
+        x=[]
+        y=[]
+        plt.figure()
+        plt.imshow(img, cmap=plt.get_cmap('binary'))
+        
+        #horizontal lines
+        for j in range(self.heigth):
+            for i in range(self.width):
+                p=self.to_pixel(self.gridpoints[j][i])
+                x.append(p[0])
+                y.append(p[1])
+            plt.plot(x,y,'b-', linewidth=0.2)
+            x=[]
+            y=[]
+        #vertical lines
+        
+        for i in range(self.width):
+            for j in range(self.heigth):
+                p=self.to_pixel(self.gridpoints[j][i])
+                x.append(p[0])
+                y.append(p[1])
+            plt.plot(x,y,'b-', linewidth=0.2)
+            x=[]
+            y=[]
+        plt.savefig('grid.png', dpi=400)
+        
+        img=Image.open('grid.png')
+        img.show()
+        
+        
+    def show_point(self, img, point):
+        
+        #print a point in the map
+        pixel=self.to_pixel(point)
+        
+        plt.figure()
+        plt.imshow(img, cmap=plt.get_cmap('binary'))
+        plt.plot(pixel[0],pixel[1],'ro', markersize=5)
+        plt.show()
+        
+    def save_empty_mask(self, file):
+        with open(file, 'w') as of:
+            for j in range(self.heigth-1):
+                for i in range(self.width-1):
+                    of.write('0;')
+                of.write('\n')
+                
+    def save_mask(self, file):
+        with open(file, 'w') as of:
+            for j in range(self.heigth-1):
+                for i in range(self.width-2):
+                    of.write('{:d};'.format(self.mask[j][i]))
+                of.write('{:d}\n'.format(self.mask[j][i]))
+        
+    def create_mask(self, img):
+        grayImage=img.convert(mode="L")
+        array = np.array(grayImage)
+        self.mask=[]
+        for j in range(self.heigth-1):
+            column=[]
+            for i in range(self.width-1):
+                p1=self.to_pixel(self.gridpoints[j][i])
+                p2=self.to_pixel(self.gridpoints[j+1][i])
+                p3=self.to_pixel(self.gridpoints[j][i+1])
+                p4=self.to_pixel(self.gridpoints[j+1][i+1])
+                p1=array[int(p1[1])][int(p1[0])]
+                p2=array[int(p2[1])][int(p2[0])]
+                p3=array[int(p3[1])][int(p3[0])]
+                p4=array[int(p4[1])][int(p4[0])]
+                white=0
+                if p1:
+                    white+=1
+                if p2:
+                    white+=1
+                if p3:
+                    white+=1
+                if p4:
+                    white+=1
+                if white>2:
+                    column.append(0)
+                else:
+                    column.append(1)
+            self.mask.append(column)
+    def show_mask(self, img):
+        #show grid
+        
+        plt.figure()
+        plt.imshow(img, cmap=plt.get_cmap('binary'))
+        
+        for j in range(self.heigth-1):
+            for i in range(self.width-1):
+                if not self.mask[j][i]:
+                    x=[]
+                    y=[]
+                    p1=self.to_pixel(self.gridpoints[j][i])
+                    p2=self.to_pixel(self.gridpoints[j+1][i])
+                    p3=self.to_pixel(self.gridpoints[j][i+1])
+                    p4=self.to_pixel(self.gridpoints[j+1][i+1])
+                    x.append(p1[0])
+                    y.append(p1[1])
+                    x.append(p2[0])
+                    y.append(p2[1])
+                    x.append(p4[0])
+                    y.append(p4[1])
+                    x.append(p3[0])
+                    y.append(p3[1])
+                    x.append(p1[0])
+                    y.append(p1[1])
+                    plt.plot(x,y,'b-', linewidth=0.2)
+                    
+        
+        plt.savefig('mask.png', dpi=400)
+        
+        img=Image.open('mask.png')
+        img.show()
+        
+    # def show_mission(self, img):
+    #     plt.figure()
+    #     plt.imshow(img, cmap=plt.get_cmap('binary'))
+    #     point=0
+    #     KML=KMLMissionGenerator("MisionesLoyola_dron_3.kml")
+    #     mission=KML.get_mission_list()[0]
+        
+    #     for j in range(self.heigth-1):
+    #         for i in range(self.width-1):
+    #             if not self.mask[j][i]:
+    #                 x=[]
+    #                 y=[]
+    #                 p1=self.to_pixel(self.gridpoints[j][i])
+    #                 p2=self.to_pixel(self.gridpoints[j+1][i])
+    #                 p3=self.to_pixel(self.gridpoints[j][i+1])
+    #                 p4=self.to_pixel(self.gridpoints[j+1][i+1])
+    #                 x.append(p1[0])
+    #                 y.append(p1[1])
+    #                 x.append(p2[0])
+    #                 y.append(p2[1])
+    #                 x.append(p4[0])
+    #                 y.append(p4[1])
+    #                 x.append(p3[0])
+    #                 y.append(p3[1])
+    #                 x.append(p1[0])
+    #                 y.append(p1[1])
+    #                 plt.plot(x,y,'b-', linewidth=0.2)
+    #     for i in mission:
+    #         point=[i[1], i[0]]
+    #         pixel=self.to_pixel(point)
+    #         plt.plot(pixel[0],pixel[1],'ro', markersize=0.5)
+        
+        
+    #     plt.savefig('mission.png', dpi=400)
+        
+    #     img=Image.open('mission.png')
+    #     img.show()
+                    
+                    
+def main():
+    # Create a new instance of GoogleMap Downloader
+    """
+    Loyola
+    NW_corner=[37.30877610927852, -5.940516378146266] #northwest point of the map [latitude longitude]
+    SE_corner=[37.30661986681041, -5.939422309058239] #southeast point of the map [latitude longitude]
+    
+
+    NW_corner=[36.123388953996404, -5.443591065870082] #northwest point of the map [latitude longitude]
+    SE_corner=[36.11595558243919, -5.430975637057081] #southeast point of the map [latitude longitude]
+    #alamillo
+
+    NW_corner=[36.227154628215054, -6.188738765767977] #northwest point of the map [latitude longitude]
+    SE_corner=[35.67592758704647, -5.13798693812742] #southeast point of the map [latitude longitude]
+    #Estrecho
+    """
+    # NW_corner=[30.719200,-86.115300] #northwest point of the map [latitude longitude]
+    # SE_corner=[30.7148,-86.110014] #southeast point of the map [latitude longitude]
+    # #Lake DeFuniak
+    
+    NW_corner=[37.420088017565696, -6.001345595400041] #northwest point of the map [latitude longitude]
+    SE_corner=[37.41837443521307, -5.997484063063451] #southeast point of the map [latitude longitude]
+    #alamillo
+
+    #SE_corner=[37.29989089621092, -5.9274044593699236]
+    grid_size= 2.5     #size of the grid in meters
+    zoom=19
+    
+    #create class of the map downloader 
+    gmd = GoogleMapDownloader(NW_corner ,SE_corner, zoom =zoom) #zoom 19, aproximadamente tiles de 50m^2, más zoom no se aprecian obstaculos nuevos
+    
+    try:
+        # Get the high resolution image
+        img = gmd.generateImage()
+    except IOError:
+        print("Could not generate the image - try adjusting the zoom level and checking your coordinates")
+    else:
+        # Save the image to disk
+        img.rotate(17)
+        img.save("high_resolution_image2.png")
+        print("The map has successfully been created")
+        
+    
+    #Show the image
+    plt.figure()
+    plt.imshow(img, cmap=plt.get_cmap('binary'))
+    plt.show()
+    
+    #create grid
+    print(f"generating map for {NW_corner}, {SE_corner}")
+    grid= gridder(NW_corner,SE_corner,grid_size, zoom =zoom)
+
+
+
+    #show the grid on the image
+    aux=0
+    while aux!="y" and aux!="n":
+        aux=input("is there already an existing mask (y/n)").lower()
+    if aux=='n':
+        grid.show_grid(img)
+        grid.save_to_file("grid.csv")
+        grid.save_empty_mask("empty_mask.csv")
+        return
+    
+    while not os.path.exists(str("./"+aux)) or aux[-1]!="g":
+        aux=input("insert mask name: ").lower()
+    imgn=Image.open(aux)
+    grid.show_grid(imgn)
+    name=aux[0:-4]
+    grid.create_mask(imgn)
+    grid.save_mask(str(name+".csv"))
+    grid.show_mask(img)
+
+
+    #show a point
+    #grid.show_point(img, [37.307659405593995, -5.940044140455814])
+    
+    #grid.show_mission(img)
+        
+
+
+if __name__ == '__main__':  main()

aceti-0.0.1/src/aceti/old/gen_lat_lon_map.py

@@ -0,0 +1,38 @@
+import sys
+sys.path.append('.')
+
+from Environment.generate_map import img2pixels
+
+import numpy as np
+
+# Esquina inferior izquierda
+lat = np.float64(37.41856004857407)
+lon = np.float64(-6.001322282719345)
+
+# Esquina superior derecha
+lat2 = np.float64(37.41953493274117)
+lon2 = np.float64(-5.9987915127912)
+
+path = 'Environment/maps/alamillo.png'
+
+pixels = img2pixels(path, threshold=128, height=40)
+
+pixels = 1 - pixels
+
+# Sabiendo que lat,lon hace referencia a la esquina inferior izquierda y lat2,lon2 a la esquina superior derecha,
+# calculamos, para cada pixel, su latitud y longitud
+latitudes = np.linspace(lat2, lat, pixels.shape[0], dtype=np.float64)
+longitudes = np.linspace(lon, lon2, pixels.shape[1], dtype=np.float64)
+
+# Creamos un array de MxNx2 dimensiones con las latitudes y longitudes
+lat_lon_map = np.zeros((pixels.shape[0], pixels.shape[1], 2), dtype=np.float64)
+
+for i in range(pixels.shape[0]):
+    for j in range(pixels.shape[1]):
+        lat_lon_map[i,j] = [latitudes[i], longitudes[j]]
+        
+np.save('Environment/maps/lat_lon_alamillo_big.npy', lat_lon_map)
+np.save('Environment/maps/alamillo_big.npy', pixels)
+
+
+

aceti-0.0.1/src/aceti/old/generate_map.py

@@ -0,0 +1,40 @@
+# Programa para pasar de una imagen a una matriz de pixeles 0,1 con un umbral y un alto en pixeles
+import sys
+from PIL import Image
+import numpy as np
+import matplotlib.pyplot as plt	
+import argparse
+
+
+
+def img2pixels(img_path, threshold=128, height=100):
+
+	img = Image.open(img_path)
+	img = img.convert('L')  # Convert to grayscale
+	img = img.resize((int(img.width * height / img.height), height), Image.LANCZOS)
+	img = np.array(img)
+
+	# Threshold
+	img = (img > threshold).astype(int)
+
+	return img
+
+
+
+if __name__ == "__main__":
+
+	argparser = argparse.ArgumentParser(description='Convert image to pixel matrix')
+	argparser.add_argument('--path', type=str, help='Path to image')
+	argparser.add_argument('--threshold', type=int, default=128, help='Threshold for binarization')
+	argparser.add_argument('--height', type=int, default=100, help='Height of the output image')
+	argparser.add_argument('--output', type=str, help='Output file')
+
+	args = argparser.parse_args()
+
+	# Example
+	pixels = img2pixels(args.path, threshold=args.threshold, height=args.height)
+
+
+	# To numpy and save to file 
+
+	np.save(args.output + '.npy', pixels)

aceti-0.0.1/src/aceti/old/legendarium.py

@@ -0,0 +1,180 @@
+import sys
+sys.path.append('.')
+
+import pandas as pd
+import numpy as np
+import os
+from typing import Union
+import lzma
+import pickle
+import yaml
+from collections import defaultdict
+
+class Legendarium:
+
+    def __init__(self, experiment_name : str, experiment_description : str, path : str):
+
+        self._exp_name = experiment_name
+        self._exp_desc = experiment_description
+        self._path = path
+
+        # Check if directory exists
+        if path is not None:
+            if not os.path.exists(self._path):
+                os.makedirs(self._path)
+            else:
+                # Check if the there is a file with the same experiment name
+                if os.path.exists(os.path.join(self._path, f"{self._exp_name}.metrics.xz")):
+                    raise Exception("Experiment already exists!")
+        
+
+        self.metrics_meta = {}
+        self.metrics = []
+        self.parameters = {}
+        self.n_metrics = 0
+        self.data_names = []
+
+    def create_parameter(self, parameter_name : str, parameter_value):        
+        """ 
+        Create a parameter for the experiment
+        """
+        self.parameters.update({parameter_name : parameter_value})
+
+    def create_metric(self, metric_name : str, data_type : type, description : str, unit : str):
+
+        self.metrics_meta.update({metric_name : {"type" : data_type, "description" : description, "unit" : unit, "order": self.n_metrics}})
+        self.n_metrics += 1
+
+    def write(self, run : int, step : int, **kwargs):
+        """ 
+        Write data to the metric
+        """
+
+        # Check if metric exists
+        for metric_name, new_data in kwargs.items():
+
+            if metric_name not in self.metrics_meta:
+                raise Exception(f"Metric {metric_name} not found!")
+            
+            # Check if the data type is correct
+            if not isinstance(run, int):
+                raise Exception("Run should be an integer!")
+            
+            if not isinstance(step, int):
+                raise Exception("Step should be an integer!")
+            
+            # Check if the data type is correct
+            if not issubclass(type(kwargs[metric_name]), self.metrics_meta[metric_name]["type"]):
+                raise Exception(f"Data type mismatch for metric {metric_name}!")
+            
+        # Check if all the metrics are present
+        if len(kwargs) != self.n_metrics:
+            raise Exception("Not all metrics are present in the data!")
+        
+        new_data = [run, step] + [None] * self.n_metrics
+    
+        
+        for key, value in kwargs.items():
+            
+            # Comprobamos si la clave es una metrica registrada
+            if key not in self.metrics_meta:
+                raise Exception(f"Metric {key} not found!")
+            
+            # Comprobamos si el tipo de dato es correcto
+            if not isinstance(value, self.metrics_meta[key]["type"]):
+                raise Exception(f"Data type mismatch for metric {key}!")
+            
+            # Obtenemos la posición en la lista
+            pos = self.metrics_meta[key]["order"]
+            new_data[pos + 2] = value
+
+        # Añadimos la información de los parámetros
+        for key, value in self.parameters.items():
+            new_data.append(value)
+        
+        self.metrics.append(new_data)
+
+
+    def save(self):
+        """
+        Save the experiment
+        """
+
+        data_names = ["run", "step"] + list(self.metrics_meta.keys()) + list(self.parameters.keys())
+
+
+        # Save the metrics
+        with lzma.open(os.path.join(self._path, f"{self._exp_name}.metrics.xz"), "wb") as f:
+            pickle.dump(self.metrics, f)
+
+        # Save the metrics meta
+        with open(os.path.join(self._path, f"{self._exp_name}.meta.yaml"), "w") as f:
+            yaml.dump(data_names, f)
+
+
+def load_experiment_pd(experiment_name : str, path : str):
+    # Load the metrics as a pandas dataframe
+
+    # Load the metrics
+    with lzma.open(os.path.join(path, f"{experiment_name}.metrics.xz"), "rb") as f:
+        metrics = pickle.load(f)
+
+    # Load the metrics meta
+    with open(os.path.join(path, f"{experiment_name}.meta.yaml"), "r") as f:
+        data_names = yaml.load(f, Loader=yaml.FullLoader)
+
+    # Create the dataframe
+    df = pd.DataFrame(metrics, columns = data_names)
+
+    return df
+
+def load_experiments(path : str):
+    # Load all the experiments in a directory and return a pandas dataframe
+
+    pds = []
+
+    for file in os.listdir(path):
+        if file.endswith(".metrics.xz"):
+            experiment_name = file.split(".")[0]
+            try:
+                df = load_experiment_pd(experiment_name, path)
+                pds.append(df)
+            except Exception as e:
+                print(f"Error loading experiment {experiment_name}: {e}")
+
+
+    return pd.concat(pds)
+
+
+if __name__ == "__main__":
+
+
+    # Create an instance of the class
+    exp = Legendarium(f"test", "Test experiment", "experiments")
+
+    # Create a parameter
+    exp.create_parameter("algorithm", "Greedy")
+    exp.create_parameter("max_distance", 100.0)
+
+    # Create a metric
+    exp.create_metric("reward", float, "Reward function", "points")
+    exp.create_metric("map", np.ndarray, "Mean map", "%")
+
+    for run in range(3):
+
+        # Write data
+        for i in range(100):
+            exp.write(run = run, step = i, reward = np.random.rand(), map = np.random.rand(100,100))
+
+    # Save the data
+    exp.save()
+
+    # Load the data
+    df = load_experiments("experiments")
+    print(df.head())
+
+    import seaborn as sns
+    import matplotlib.pyplot as plt
+
+    sns.lineplot(data = df, x = "step", y = "reward", hue = "run")
+    plt.show()

aceti-0.0.1/src/aceti/old/maps_utils.py

@@ -0,0 +1,128 @@
+import cv2
+import numpy as np
+
+def png_to_csv(name, delim=' '):
+    ''' Convert a binary image to a CSV file. '''
+    # Load the image
+    image = cv2.imread(f'Environment/maps/{name}.png', 0)
+
+    # Binarize the image
+    _, binary_image = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)
+
+    # Convert the binary image to 0s and 1s
+    binary_image = np.where(binary_image > 0, 1, 0)
+
+    # Save the binary image as a CSV file
+    np.savetxt(f'Environment/maps/{name}.csv', binary_image, delimiter=delim, fmt='%d')
+
+def csv_to_png(name, delim=' '):
+    ''' Convert a CSV file to a binary image. '''
+    # Load the CSV file
+    binary_image = np.loadtxt(f'Environment/maps/{name}.csv', delimiter=delim)
+
+    # Convert the binary image to 0s and 255s
+    binary_image = np.where(binary_image > 0, 255, 0)
+
+    # Save the binary image as a PNG file
+    cv2.imwrite(f'Environment/maps/{name}.png', binary_image)
+
+def csv_to_npy(name, delim=' '):
+    ''' Convert a CSV file to a NumPy file. '''
+    if 'mask' in name or 'plantilla' in name or 'nodes' in name:
+        # Load the CSV file
+        binary_image = np.loadtxt(f'Environment/maps/{name}.csv', delimiter=delim)
+
+        # Save the binary image as a NumPy file
+        np.save(f'Environment/maps/{name}.npy', binary_image)
+    elif 'latlon' in name or 'grid' in name:
+        # There is a two component array in each cell #
+
+        # Load the CSV file
+        binary_image = np.loadtxt(f'Environment/maps/{name}.csv', delimiter=delim, dtype=str)
+        lat_lon_map = np.zeros((binary_image.shape[0], binary_image.shape[1], 2), dtype=np.float64)
+
+        # Convert the strings to tuples
+        for i in range(binary_image.shape[0]):
+            for j in range(binary_image.shape[1]):
+                lat = binary_image[i, j].split(',')[0]
+                lon = binary_image[i, j].split(',')[1]
+                lat_lon_map[i, j] = [float(lat), float(lon)]
+        
+        # Save the binary image as a NumPy file
+        np.save(f'Environment/maps/{name}.npy', lat_lon_map)
+
+def csv_downsize(name, delim=' ', factor=2, output_name=None):
+    ''' Downsize a CSV file. '''
+    # Load the CSV file
+    binary_image = np.loadtxt(f'Environment/maps/{name}.csv', delimiter=delim, dtype=str)
+
+    # Downsize the binary image
+    binary_image = binary_image[::factor, ::factor]
+
+    output_name1 = output_name.split('_')[0]
+    output_name2 = output_name.split('_')[1]
+
+    # Save the binary image as a CSV file
+    np.savetxt(f'Environment/maps/{output_name1}{binary_image.shape[0]}x{binary_image.shape[1]}{output_name2}.csv', binary_image, delimiter=delim, fmt='%s')
+
+def csv_shrink(name, delim=' ', init_column=0, final_column=None, init_row=0, final_row=None, output_name=None):
+    ''' Shrink a CSV file. '''
+    # Load the CSV file
+    binary_image = np.loadtxt(f'Environment/maps/{name}.csv', delimiter=delim, dtype=str)
+
+    # Set the final column and row if they are None
+    if final_column is None:
+        final_column = binary_image.shape[1]
+    if final_row is None:
+        final_row = binary_image.shape[0]
+
+    # Shrink the binary image
+    binary_image = binary_image[init_row:final_row, init_column:final_column]
+
+    output_name1 = output_name.split('_')[0]
+    output_name2 = output_name.split('_')[1]
+
+    # Save the binary image as a CSV file
+    np.savetxt(f'Environment/maps/{output_name1}{binary_image.shape[0]}x{binary_image.shape[1]}{output_name2}.csv', binary_image, delimiter=delim, fmt='%s')
+
+def get_output_name(name):
+    ''' Get the output name if the format is correct. '''
+    output_name = name
+    first_number_pos = None
+    last_number_pos = None
+    for i, c in enumerate(name):
+        if c.isdigit():
+            if first_number_pos is None:
+                first_number_pos = i
+            last_number_pos = i
+    if first_number_pos is not None and last_number_pos is not None:
+        output_name = name[:first_number_pos] + '_' + name[last_number_pos+1:]
+    else:
+        output_name = 'output_map'
+    return output_name
+
+def invert_map(name, delim=' '):
+    ''' Invert a map. '''
+    # Load the CSV file
+    binary_image = np.loadtxt(f'Environment/maps/{name}.csv', delimiter=delim)
+
+    # Invert the binary image
+    binary_image = np.where(binary_image == 1, 0, 1)
+
+    # Save the binary image as a CSV file
+    np.savetxt(f'Environment/maps/{name}.csv', binary_image, delimiter=delim, fmt='%d')
+
+if __name__ == '__main__':
+
+    # name = 'rawfiles/Alamillo95x216grid'
+    # delim = ';'
+    
+    name = 'rawfiles/Alamillo95x216plantilla'
+    delim = ' '
+    
+    # invert_map(name, delim)
+    # png_to_csv(name, delim) 
+    # csv_to_png(name, delim)
+    # csv_to_npy(name, delim)
+    # csv_downsize(name, delim, factor=3, output_name=get_output_name(name))
+    # csv_shrink(name, delim, init_column=0, final_column=145, init_row=0, final_row=90, output_name=get_output_name(name))

aceti-0.0.1/src/aceti/old/path_planner_checker.py

@@ -0,0 +1,65 @@
+import numpy as np
+from scipy.ndimage import binary_dilation
+import matplotlib.pyplot as plt
+
+# NODOS
+nodos_mask = np.load('Environment/maps/AlamilloAccess11x15mask.npy')
+nodos_lat_lon = np.load('Environment/maps/AlamilloAccess11x15latlon.npy')
+
+# "REALES"
+real_mask = np.genfromtxt('Environment/maps/rawfiles/Alamillo95x216plantilla.csv', dtype=int, delimiter=' ')
+raw_grid_csv = np.genfromtxt('Environment/maps/rawfiles/Alamillo95x216grid.csv', delimiter=';', dtype=str)
+real_lat_long = np.zeros((*real_mask.shape, 2))
+# Transform the map to a float for long and lat
+for i in range(real_mask.shape[0]):
+	for j in range(real_mask.shape[1]):
+		real_lat_long[i, j, 0] = float(raw_grid_csv[i, j].split(',')[0])
+		real_lat_long[i, j, 1] = float(raw_grid_csv[i, j].split(',')[1])
+
+latitudes = real_lat_long[:,:, 0]
+longitudes = real_lat_long[:,:, 1]
+
+navigables_latitudes = latitudes[real_mask == 1]
+navigables_longitudes = longitudes[real_mask == 1]
+
+# Comprobar si los puntos de navegación en el mapa real están en el mapa de nodos
+# Para cada punto navegable (1) en base_matrix, obtener su latitud y longitud. Y comprobar si todos son alcanzables.
+cont_unreach = 0
+cont_reach = 0
+non_reachable_points = []
+reachable_points = []
+for i in range(nodos_mask.shape[0]):
+	for j in range(nodos_mask.shape[1]):
+		if nodos_mask[i, j] == 1:
+			# Comprobar si está como navegable en el mapa de navegación
+			if nodos_lat_lon[i, j, 0] in navigables_latitudes and nodos_lat_lon[i, j, 1] in navigables_longitudes:
+				# Obtener los índices de la latitud y longitud en el mapa de navegación
+				lat_indexs = np.where(navigables_latitudes == nodos_lat_lon[i, j, 0])[0]
+				lon_indexs = np.where(navigables_longitudes == nodos_lat_lon[i, j, 1])[0]
+
+				# Comprobar si hay algún índice en común
+				if len(set(lat_indexs).intersection(set(lon_indexs))) == 0:
+					print(f'No alcanzable (no común): {nodos_lat_lon[i, j, 0]}, {nodos_lat_lon[i, j, 1]}')
+					cont_unreach += 1
+					non_reachable_points.append((i, j))
+				else:
+					cont_reach += 1
+					reachable_points.append((i, j))
+			else:
+				print(f'No alcanzable: {nodos_lat_lon[i, j, 0]}, {nodos_lat_lon[i, j, 1]}')
+				cont_unreach += 1
+				non_reachable_points.append((i, j))
+
+
+if cont_unreach == 0:
+	print(f'Todos los puntos son alcanzables: {cont_reach}')
+else:
+	print(f'{cont_unreach} puntos no son alcanzables de un total de {np.sum(nodos_mask)}')
+
+# Pintar los puntos no alcanzables
+plt.imshow(nodos_mask)
+for point in non_reachable_points:
+	plt.scatter(point[1], point[0], c='r', s=10)
+for point in reachable_points:
+	plt.scatter(point[1], point[0], c='g', s=10)
+plt.show()

aceti-0.0.1/tests/test.py

@@ -0,0 +1,3 @@
+from aceti_maps import import_map
+
+base_matrix, lat_lon_map  = import_map("alamillo11x15")