commit 2fb880b64942aa6554254d3ab3e7b61d90e139a8 · patrick.sirref.org/ocaml-geotessera

+3 -3

example/main.ml

···

       3
       3
        
       let belfast =

     

       4
       4
        
         Gt.Bbox.v ~min_lat:54.48 ~min_lon:(-6.11) ~max_lat:54.66 ~max_lon:(-5.78)

     

       5
       5
        
       

     

       6
       6
       -
       let pp_result fmt (crs, (point : Gt.point), emb) =

     

       7
       7
       -
         Fmt.pf fmt "Embedding at (%.2f, %.2f) with CRS:%i: %a" point.lat point.lon crs

     

       8
       8
       -
           Nx.pp_shape (Nx.shape emb)

     

       6
       6
       +
       let pp_result fmt ((crs, transform), (point : Gt.point), emb) =

     

       7
       7
       +
         Fmt.pf fmt "Embedding at (%.2f, %.2f) with CRS:%i: %a\ntransform: [%a]"

     

       8
       8
       +
           point.lat point.lon crs Nx.pp_shape (Nx.shape emb) Nx.pp transform

     

       9
       9
        
       

     

       10
       10
        
       let () =

     

       11
       11
        
         Mirage_crypto_rng_unix.use_default ();

+17 -5

src/geotessera.ml

···

       186
       186
        
             ([], [], []) paths

     

       187
       187
        
           |> fun (ps, s, t) -> List.combine ps (List.combine s t)

     

       188
       188
        
       

     

       189
       189
       -
         let crs_of_landmask lm =

     

       189
       189
       +
         let transformation_matrix e =

     

       190
       190
       +
           let scale = Tiff.Ifd.pixel_scale e in

     

       191
       191
       +
           let tiepoint = Tiff.Ifd.tiepoint e in

     

       192
       192
       +
           let arr = Nx.zeros Nx.float64 [| 6 |] in

     

       193
       193
       +
           (* X *)

     

       194
       194
       +
           Nx.set_item [ 0 ] tiepoint.(3) arr;

     

       195
       195
       +
           (* sX *) Nx.set_item [ 1 ] scale.(0) arr;

     

       196
       196
       +
           Nx.set_item [ 3 ] tiepoint.(4) arr;

     

       197
       197
       +
           Nx.set_item [ 5 ] (-.scale.(1)) arr;

     

       198
       198
       +
           arr

     

       199
       199
       +
       

     

       200
       200
       +
         let crs_and_transform_of_landmask lm =

     

       190
       201
        
           Eio.Path.with_open_in lm @@ fun r ->

     

       191
       202
        
           let ro = Eio.File.pread_exact r in

     

       192
       203
        
           let tiff = Tiff.from_file Tiff.Float32 ro in

     

       193
       193
       -
           let geos = Tiff.ifd tiff |> Tiff.Ifd.geo_key_directory in

     

       194
       194
       -
           Tiff.Ifd.GeoKeys.projected_crs geos

     

       204
       204
       +
           let ifd = Tiff.ifd tiff in

     

       205
       205
       +
           let geos = Tiff.Ifd.geo_key_directory ifd in

     

       206
       206
       +
           (Tiff.Ifd.GeoKeys.projected_crs geos, transformation_matrix ifd)

     

       195
       207
        
       

     

       196
       208
        
         let download_landmasks t v =

     

       197
       209
        
           Eio.Switch.run @@ fun sw ->

     
···

       223
       235
        
                     (* Eio.traceln "%a\n%a" Digestif.SHA256.pp disk_hash *)

     

       224
       236
        
                     (*   Digestif.SHA256.pp hash; *)

     

       225
       237
        
                     (* assert (Digestif.SHA256.equal disk_hash hash); *)

     

       226
       226
       -
                     let crs = crs_of_landmask path in

     

       238
       238
       +
                     let crs = crs_and_transform_of_landmask path in

     

       227
       239
        
                     (crs, path)

     

       228
       240
        
                 | `Delete_and_download | `Download ->

     

       229
       241
        
                     let () =

     
···

       238
       250
        
                       Client.with_body ~default:() t.client display ~uri

     

       239
       251
        
                       @@ fun body -> Flow.copy body w

     

       240
       252
        
                     in

     

       241
       241
       -
                     let crs = crs_of_landmask path in

     

       253
       253
       +
                     let crs = crs_and_transform_of_landmask path in

     

       242
       254
        
                     (crs, path)

     

       243
       255
        
                 | `Check_hash _ -> Fmt.failwith "%s exists but is not a file!" name)

     

       244
       256
        
               v

+9 -3

src/geotessera.mli

···

       34
       34
        
         _ env ->

     

       35
       35
        
         year:int ->

     

       36
       36
        
         Bbox.t ->

     

       37
       37
       -
         (int * point * Eio.Fs.dir_ty Eio.Path.t * (embedding * scales)) list

     

       37
       37
       +
         ((int * (float, Bigarray.float64_elt) Nx.t)

     

       38
       38
       +
         * point

     

       39
       39
       +
         * Eio.Fs.dir_ty Eio.Path.t

     

       40
       40
       +
         * (embedding * scales))

     

       41
       41
       +
         list

     

       38
       42
        
       (** [fetch env ~year bbox] returns a list of

     

       39
       39
       -
           [(crs, centre, landmask_path, scaled_embeddings)] for the tiles available in

     

       40
       40
       -
           [bbox] for [year]. *)

     

       43
       43
       +
           [((crs, transform), centre, landmask_path, scaled_embeddings)] for the tiles

     

       44
       44
       +
           available in [bbox] for [year].

     

       45
       45
       +
       

     

       46
       46
       +
           Note that the [transformation] is returned in GDAL format. *)

     

       41
       47
        
       

     

       42
       48
        
       val scale : embedding * scales -> (float, Bigarray.float32_elt) Nx.t

     

       43
       49
        
       (** Scale up the embeddings *)