Upload 8 files

download.py

@@ -0,0 +1,153 @@
+import json
+from shapely.geometry import shape
+import os
+import collections
+from tqdm import tqdm
+import pandas as pd  
+from multiprocessing import cpu_count 
+from multiprocessing.pool import ThreadPool
+import requests
+import networkx as nx
+import rasterio as rio
+from extract import extract
+from tiling import get_tiles
+
+from huggingface_hub import HfApi
+from datetime import datetime
+from tiling import get_tiles
+
+def download_image(args): 
+    url, fn = args['image_href'], args['image']
+
+    if os.path.exists(fn) is False:
+        try: 
+            r = requests.get(url) 
+            with open(fn, 'wb') as f:
+                f.write(r.content) 
+        except Exception as e: 
+            print('Exception in download_url():', e)
+            return url
+
+    with rio.open(fn, "r") as ds:
+        print(args['date'], args['id'], ds.crs.to_proj4())
+    
+    return url
+
+
+if __name__ == '__main__':
+    api = HfApi()
+
+    image_dir = './dataset/image'
+
+    if os.path.exists('data.json') == False:
+        extract('data.json')
+    
+    with open('data.json') as f:
+        data = json.load(f)
+
+
+    ids = [f['id'] for f in data['features']]
+    duplicated = [item for item, count in collections.Counter(ids).items() if count > 1]
+    for duplicated_instance in duplicated:
+        items = []
+        for f in data['features']:
+            if f['id'] == duplicated_instance:
+                items.append(json.dumps(f))
+        assert len(collections.Counter(items).keys()) == 1, 'Unexpected duplicated item' # Tutti gli elementi che hanno lo stesso id sono completamente identici
+
+    # Prendo tutte le feature che sono univoce a livello di contenuto
+    data['features'] =[json.loads(f) for f in list(set([json.dumps(f) for f in data['features']]))]
+    #data['features'] = data['features'][:2]
+
+    records = []
+    for idx in tqdm(range(len(data['features']))):
+        feature = data['features'][idx]
+
+        gec = feature['assets'].get('GEC')
+        if gec is None:
+            continue
+
+
+        metadata = feature['assets']['metadata']['content']
+        assert len(metadata['collects']) == 1, 'Unexpected situation'
+        assert len(metadata['derivedProducts']['GEC']) == 1, 'Unexpected situation'
+
+        parsed_date = datetime.fromisoformat(metadata['collects'][0]['startAtUTC'])
+        if parsed_date.year < 2024:
+            continue
+            
+
+        records.append({
+            'id': feature['id'],
+            'date': metadata['collects'][0]['startAtUTC'],
+            'bbox': feature['bbox'],
+            'geometry': feature['geometry'],
+            'satellite': metadata['umbraSatelliteName'],
+            'track': metadata['collects'][0]['satelliteTrack'],
+            'direction': metadata['collects'][0]['observationDirection'],
+            'mode': metadata['imagingMode'],
+            'band': metadata['collects'][0]['radarBand'],
+            'polarization': metadata['collects'][0]['polarizations'],
+            'azimuth_res': metadata['derivedProducts']['GEC'][0]['groundResolution']['azimuthMeters'],
+            'range_res': metadata['derivedProducts']['GEC'][0]['groundResolution']['rangeMeters'],
+            'rows': metadata['derivedProducts']['GEC'][0]['numRows'],
+            'cols': metadata['derivedProducts']['GEC'][0]['numColumns'],
+            'size': metadata['derivedProducts']['GEC'][0]['numRows']*metadata['derivedProducts']['GEC'][0]['numColumns'],
+            'image_href': gec['href'],
+            'image': os.path.join(image_dir, '{name}.tiff'.format(name=feature['id']))
+        })
+
+
+
+    cpus = cpu_count() 
+    results = ThreadPool(cpus - 1).imap_unordered(download_image, records) 
+    for result in results: 
+        print('url:', result)
+
+    for record in records:
+        try:
+            with rio.open(record['image']) as src:
+                image_crs = src.crs.to_proj4()
+                record['crs'] = src.crs.to_proj4()
+        except:
+            record['crs'] = 'None'
+            print('Error reading the image')
+    
+    df = pd.DataFrame.from_records(records)
+    df.to_excel('out.xlsx')
+
+
+
+    selected_records = []
+    for record in records:
+        if record['crs'] == '+proj=longlat +datum=WGS84 +no_defs=True':
+            out_dir = 'dataset/tile/{id}'.format(id = record['id'])
+            if os.path.exists(out_dir) is False:
+                os.mkdir(out_dir)
+            selected_records.append({'input_path': record['image'], 'out_dir': out_dir, 'patch_size': 2048})
+    cpus = cpu_count() 
+    results = ThreadPool(cpus - 1).imap_unordered(get_tiles, selected_records) 
+    for result in results: 
+        print('url:', result)
+
+
+
+    api.upload_file(
+        path_or_fileobj='out.xlsx',
+        path_in_repo='out.xlsx',
+        repo_id='fedric95/umbra',
+        repo_type='dataset',
+    )
+
+    api.upload_file(
+        path_or_fileobj='data.json',
+        path_in_repo='data.json',
+        repo_id='fedric95/umbra',
+        repo_type='dataset',
+    )
+
+    api.upload_large_folder(
+        repo_id='fedric95/umbra',
+        repo_type='dataset',
+        folder_path='./dataset/',
+    )

extract.py

@@ -0,0 +1,24 @@
+"""
+Get the collaction of all the metadata of the umbra open data collection
+"""
+
+import requests
+import urllib.parse
+import json
+import pystac
+
+def extract(out_path):
+
+    base_url = 'https://s3.us-west-2.amazonaws.com/umbra-open-data-catalog/stac/'
+    home = 'catalog.json'
+    url = urllib.parse.urljoin(base_url, home)
+
+    collection = {'type': 'FeatureCollection', 'features': []}
+    catalog = pystac.Catalog.from_file(url)
+    for idx, item in enumerate(catalog.get_all_items()):
+        item = item.to_dict()
+        item['assets']['metadata']['content'] = requests.get(item['assets']['metadata']['href']).json()
+        collection['features'].append(item)
+
+    with open(out_path, 'w') as f:
+        json.dump(collection, f)

harmonize.py

@@ -0,0 +1,56 @@
+
+from rasterio.enums import Resampling
+from huggingface_hub import hf_hub_download
+import pandas as pd
+import rasterio
+import matplotlib.pyplot as plt
+
+df = pd.read_excel('out.xlsx')
+
+records = []
+for index, row in df.iterrows():
+    if row['crs'] == '+proj=longlat +datum=WGS84 +no_defs=True':
+        records.append(row)
+
+for record in records:
+
+    hf_hub_download(
+        'fedric95/umbra', 
+        './image/{id}.tiff'.format(id=record['id']),
+        local_dir = 'dataset/',
+        repo_type = 'dataset'
+    )
+    hf_hub_download(
+        'fedric95/umbra', 
+        './label/{id}.tiff'.format(id=record['id']),
+        local_dir = 'dataset/',
+        repo_type = 'dataset'
+    )
+
+    image = './dataset/image/{id}.tiff'.format(id=record['id'])
+    label = './dataset/label/{id}.tiff'.format(id=record['id'])
+
+    with rasterio.open(image) as image_src:
+        with rasterio.open(label) as label_src:
+            
+            # resample data to target shape
+            data = label_src.read(
+                out_shape=(
+                    label_src.count,
+                    image_src.height,
+                    image_src.width
+                ),
+                resampling=Resampling.bilinear
+            )
+
+            # scale image transform
+            transform = label_src.transform * label_src.transform.scale(
+                (label_src.width / data.shape[-1]),
+                (label_src.height / data.shape[-2])
+            )
+
+            import pdb
+            pdb.set_trace()
+
+        plt.imshow(data[0, :, :])
+        plt.savefig('label.png')

label.py

@@ -0,0 +1,154 @@
+"""
+Visualize the location of the acquisition made for the umbra open data collection
+"""
+
+
+import rasterio
+import matplotlib.pyplot as plt
+from sentinelhub import SHConfig, BBox, MimeType, SentinelHubRequest, DataCollection, bbox_to_dimensions, BBoxSplitter, SentinelHubDownloadClient, MosaickingOrder
+from pathlib import Path
+
+
+import numpy as np
+import rasterio
+from rasterio import features
+from rasterio.mask import mask
+from sentinelhub.geometry import Geometry
+# the first one is your raster on the right
+# and the second one your red raster
+from rasterio.crs import CRS
+import pandas as pd
+import shutil
+from multiprocessing import cpu_count 
+from multiprocessing.pool import ThreadPool
+from huggingface_hub import HfApi
+from rasterio.enums import Resampling
+from huggingface_hub import hf_hub_download
+
+
+def download_image(args):
+    time_interval = ['2021/1/1', '2021/12/31']
+
+    geometry = args['geometry']
+    bbox = args['bbox']
+    crs = args['crs']
+    crs = CRS.from_proj4(crs).to_string()
+
+    geometry = Geometry(eval(geometry), crs=crs)
+    bbox = BBox(eval(bbox), crs=crs)
+    size = bbox_to_dimensions(bbox, RESOLUTION)
+
+
+    try:
+        request = SentinelHubRequest(
+            data_folder="test_dir",
+            evalscript=WORLDCOVER,
+            input_data=[
+                SentinelHubRequest.input_data(
+                    data_collection=DataCollection.define_byoc(collection_id="0b940c63-45dd-4e6b-8019-c3660b81b884"),
+                    time_interval=time_interval,
+                    mosaicking_order=MosaickingOrder.MOST_RECENT
+                )
+            ],
+            responses=[SentinelHubRequest.output_response("default", MimeType.TIFF)],
+            geometry=geometry,
+            size=size,
+            config=None,
+        )
+        dl_requests = [request.download_list[0]]
+        _ = SentinelHubDownloadClient(config=None).download(dl_requests)
+        print(crs)
+    except Exception as e:
+        print('Error'+crs)
+        return e
+
+    label_path = Path(request.data_folder) / request.get_filename_list()[0]
+
+
+    hf_hub_download(
+        'fedric95/umbra', 
+        './image/{id}.tiff'.format(id=args['id']),
+        local_dir = 'dataset/',
+        repo_type = 'dataset'
+    )
+    image_path = './dataset/image/{id}.tiff'.format(id=args['id'])
+    label_out = './dataset/label/{id}.tiff'.format(id=args['id'])
+
+    with rasterio.open(image_path) as image_src:
+        with rasterio.open(label_path) as label_src:
+            
+            # resample data to target shape
+            data = label_src.read(
+                out_shape=(
+                    label_src.count,
+                    image_src.height,
+                    image_src.width
+                ),
+                resampling=Resampling.bilinear
+            )
+
+            # scale image transform
+            transform = label_src.transform * label_src.transform.scale(
+                (label_src.width / data.shape[-1]),
+                (label_src.height / data.shape[-2])
+            )
+
+            dst_kwargs = label_src.meta.copy()
+            dst_kwargs.update(
+                 {
+                     "transform": transform,
+                     "width": data.shape[-1],
+                     "height": data.shape[-2],
+                     "nodata": 0,  
+                 }
+            )
+
+            with rasterio.open(label_out, "w", **dst_kwargs) as dst:
+                 for i in range(data.shape[0]):
+                       dst.write(data[i], i+1)
+    return label_out
+
+if __name__ == '__main__':
+
+    WORLDCOVER = """
+    //VERSION=3
+
+    // This custom script visualises WorldCover map 
+
+    function setup() {
+    return {
+        input: ["Map", "dataMask"],
+        output: { 
+        bands: 2, 
+        sampleType: "INT8"
+        }
+    }
+    }
+
+    function evaluatePixel(sample) {
+    return [sample.Map, sample.dataMask];
+    }
+    """
+    RESOLUTION = 10
+
+
+    df = pd.read_excel('out.xlsx')
+
+    records = []
+    for index, row in df.iterrows():
+        if row['crs'] == '+proj=longlat +datum=WGS84 +no_defs=True':
+            records.append(row)
+
+    cpus = cpu_count() 
+    results = ThreadPool(cpus - 1).imap_unordered(download_image, records) 
+    for result in results: 
+        print('url:', result)
+
+    api = HfApi()
+    api.upload_folder(
+        repo_id='fedric95/umbra',
+        repo_type='dataset',
+        folder_path='./dataset/label',
+        path_in_repo='./label'
+    )
+    

main.py

@@ -0,0 +1,14 @@
+"""
+Visualize the location of the acquisition made for the umbra open data collection
+"""
+
+import json
+import folium
+import pandas as pd
+
+with open('data.json') as f:
+    data = json.load(f)
+
+m = folium.Map(zoom_start=4)
+folium.GeoJson(data).add_to(m)
+m.save("index.html")

push.py

@@ -0,0 +1,16 @@
+import pandas as pd
+from datasets import Dataset, Image
+import numpy as np
+import rasterio
+from rasterio.enums import Resampling
+import os
+#from utils import image_to_patches
+import mosaic.esalulc
+import datetime
+
+
+
+data = pd.read_excel('out.xlsx')
+msg_ds = Dataset.from_pandas(data)
+msg_ds = msg_ds.cast_column("image", Image(decode=False))
+msg_ds.push_to_hub("fedric95/umbra", private=True)

tiling.py

@@ -0,0 +1,46 @@
+import os
+from itertools import product
+import rasterio as rio
+import rasterio.mask as mask
+from rasterio import windows
+import os
+
+
+def split(ds, width, height):
+    nols, nrows = ds.meta['width'], ds.meta['height']
+    offsets = product(range(0, nols, width), range(0, nrows, height))
+    big_window = windows.Window(col_off=0, row_off=0, width=nols, height=nrows)
+    for col_off, row_off in  offsets:
+        window =windows.Window(col_off=col_off, row_off=row_off, width=width, height=height).intersection(big_window)
+        transform = windows.transform(window, ds.transform)
+        yield window, transform
+
+
+
+def get_tiles(args):
+
+    input_path, out_dir, patch_size = args['input_path'], args['out_dir'], args['patch_size']
+    
+    id = os.path.basename(input_path).replace('.tiff', '')
+    output_filename = '{id}_{col}-{row}.tiff'
+    tile_width, tile_height = patch_size, patch_size
+
+    with rio.open(input_path) as inds:
+
+        meta = inds.meta.copy()
+
+        for window, transform in split(inds, tile_width, tile_height):
+            if window.width != patch_size or window.height != patch_size:
+                continue
+
+            print(window)
+            meta['transform'] = transform
+            meta['width'], meta['height'] = window.width, window.height
+
+            outpath = os.path.join(out_dir,output_filename.format(id = id, col=int(window.col_off), row=int(window.row_off)))
+            if os.path.exists(outpath):
+                continue
+            with rio.open(outpath, 'w', **meta) as outds:
+                data = inds.read(window=window)
+                #out_image, out_transform = mask.mask(outds, [geometry], crop=True)
+                outds.write(data)

utils.py

@@ -0,0 +1,23 @@
+import numpy as np
+
+
+def image_to_patches(img, label = None, patch_height, patch_width):
+    H, W = img.shape
+    # Calculate how many patches fit along each dimension
+    num_patches_vert = H // patch_height
+    num_patches_horz = W // patch_width
+    
+    patches = []
+    for i in range(num_patches_vert):
+        for j in range(num_patches_horz):
+            patch_img = img[i * patch_height:(i+1) * patch_height,
+                        j * patch_width:(j+1) * patch_width
+                    ]
+            if label is not None:
+                patch_label = label[i * patch_height:(i+1) * patch_height,
+                            j * patch_width:(j+1) * patch_width
+                        ]
+                patches.append((patch_img, patch_label))
+            else:
+                patches.append(patch_img)
+    return patches