@dataforsyningen/saul 3.4.0 → 3.5.0

package/index.js

@@ -14,6 +14,7 @@ export {
   getSTAC,
   getDHM,
   getTerrainGeoTIFF,
+  getDenmarkGeoTiff,
   get,
   post
 } from './modules/api.js'
@@ -24,5 +25,6 @@ export {
 } from './modules/saul-projection.js'
 
 export {
-  getElevation
+  getElevation,
+  visualizeGeotiff
 } from './modules/saul-elevation.js'

package/modules/api.js

@@ -1,5 +1,5 @@
 /**
- * SAUL API utilities 
+ * SAUL API utilities
  */
 
 import { fromArrayBuffer } from 'geotiff'
@@ -202,6 +202,11 @@ async function consumeGeoTIFF(raw_data) {
   return image
 }
 
+function calcSizeRatio(sizeX, bbox) {
+  const ratio = ( bbox[0] - bbox[2] ) / ( bbox[1] - bbox[3] )
+  return Math.round(sizeX * ratio)
+}
+
 
 /** Fetches a GeoTIFF with elevation data matching the bounding box of a STAC API item (image)
  * @param {object} stac_item - STAC API item from a featureCollection request
@@ -209,11 +214,12 @@ async function consumeGeoTIFF(raw_data) {
  * @param {number} [resolution] - Resolution (1 - 0.01). Higher number means more pixels and better precision.
  * @returns {object} GeoTiff data
  */
-function getTerrainGeoTIFF(stac_item, auth, resolution = 0.05) {
+function getTerrainGeoTIFF(stac_item, auth, resolution = 0.05, sizeX = 300) {
   
   const bbox = stac_item.bbox
-  const width = Math.round( stac_item.properties['proj:shape'][0] * resolution )
-  const height = Math.round( stac_item.properties['proj:shape'][1] * resolution )
+  const sizeY = calcSizeRatio(sizeX, stac_item.bbox)
+  const width = stac_item.properties ? Math.round( stac_item.properties['proj:shape'][0] * resolution ) : sizeX
+  const height = stac_item.properties ? Math.round( stac_item.properties['proj:shape'][1] * resolution ) : sizeY
 
   // GET request for DHM WCS data
   let url = auth.API_DHM_WCS_BASEURL
@@ -232,6 +238,25 @@ function getTerrainGeoTIFF(stac_item, auth, resolution = 0.05) {
   })
 }
 
+/**
+ * Fetches a geoTIFF with elevation data covering all of Denmark
+ * @param {Object} options
+ * @param {Object} options.src - URL to download a pre-generated GeoTiff.
+ * @param {Object} options.auth - API autentication data. See ../config.js.example for reference.
+ * @param {Number} options.size - Width of the geoTiff image to return
+ * @returns GeoTIFF raster with elevation data
+ */
+function getDenmarkGeoTiff(options) {
+  if (options.src) {
+    return fetch(options.src)
+    .then(response => response.arrayBuffer())
+    .then(arrayBuffer => consumeGeoTIFF(arrayBuffer))
+  } else {
+    const auth = options.auth
+    const size = options.size ? options.size : 1000
+    return getTerrainGeoTIFF({bbox: [430000,6040000,900000,6413000]}, auth, null, size)
+  }
+}
 
 export {
   get,
@@ -239,5 +264,7 @@ export {
   getSTAC,
   postSTAC,
   getDHM,
-  getTerrainGeoTIFF
+  getTerrainGeoTIFF,
+  getDenmarkGeoTiff,
+  consumeGeoTIFF
 }

package/modules/saul-core.js

@@ -202,8 +202,8 @@ async function compareZ(options) {
   const delta = Math.abs(world_xyz[2] - options.z)
   
   // Check delta vs. limit. If the difference is too big, try building coordinates with the new z
-  // Make sure the recursive loop ends at some point (iteration = 50) even if no precise z is found
-  if (options.iteration < 50 && delta > options.limit) {
+  // Make sure the recursive loop ends after 20 iterations even if no precise z is found
+  if (options.iteration < 20 && delta > options.limit) {
     options.iteration++
     options.z = world_xyz[2]
     return compareZ(options)

package/modules/saul-elevation.js

@@ -1,52 +1,106 @@
-import { getTerrainGeoTIFF } from './api.js'
+/**  
+ * Maps a coordinate from the one coordinate system to another based on GeoTiff image dimensions.
+ * @param {Array} coord - EPSG:25832 X,Y coordinate pair
+ * @param {Array} bbox - Bounding box within input coordinate systtem. Consists of 2 EPSG:25832 coordinate pairs. Example: [x1,y1,x2,y2]
+ * @param {Array} imageDimensions - Width and height of a GeoTiff image. This will set the bounding box of the output coordinate system. Note: This coordinate system will have 0,0 set in the top right position of the image.
+ */
+function convertCoordinate(coord, bbox1, imageDimensions) {
+  
+  // Extract the coordinates from the bounding boxes
+  const [x1_min, y1_min, x1_max, y1_max] = bbox1
 
+  // Extract the coordinate to convert
+  const [x1, y1] = coord
 
-/** Constrain coordinates to be within a bounding box */
-function constrainToBbox(bbox, x, y) {
-  let new_x = x
-  let new_y = y
-  if (x < bbox[0]) {
-    new_x = bbox[0] + 1
-  } else if (bbox[2] < x) {
-    new_x = bbox[2] - 1
-  }
-  if (y < bbox[1]) {
-    new_y = bbox[1] + 1
-  } else if (bbox[3] < y) {
-    new_y = bbox[3] - 1
-  }
-  return [new_x, new_y]
+  // Calculate the width and height of both bounding boxes
+  const width1 = x1_max - x1_min
+  const height1 = y1_max - y1_min
+  const width2 = imageDimensions[0]
+  const height2 = imageDimensions[1]
+
+  // Calculate the relative position in the first coordinate system
+  const x_relative = (x1 - x1_min) / width1
+  const y_relative = (y1 - y1_min) / height1
+
+  // Calculate the new position in the second coordinate system
+  const x2 = Math.abs(x_relative * width2)
+  const y2 = height2 - Math.abs(y_relative * height2)
+
+  return [x2, y2]
 }
 
-/** Calculates nearest elevation for given coordinate using geoTIFF terrain data
- * Heavily inspired by https://towardsdatascience.com/geotiff-coordinate-querying-with-javascript-5e6caaaf88cf
+/** 
+ * Calculates nearest elevation for given coordinate using geoTIFF terrain data
  * @param {number} x - EPSG:25832 X coordinate
  * @param {number} y - EPSG:25832 Y coordinate
- * @param {object} geoTiff - GeoTiff data output from getTerrainGeoTIFF() method
+ * @param {object} geoTiff - GeoTiff data output from getTerrainGeoTIFF() or getDenmarkGeoTiff() method
  * @returns {number} Elevation in meters 
  */
 async function getElevation(x, y, geoTiff) {
-  
+
   const bbox = geoTiff.getBoundingBox()
   const height = geoTiff.getHeight()
   const width = geoTiff.getWidth()
-  const bboxWidth = bbox[2] - bbox[0]
-  const bboxHeight = bbox[3] - bbox[1]
 
-  const xy = constrainToBbox(bbox, x, y)
-
-  const widthPct = ( xy[0] - bbox[0] ) / bboxWidth
-  const heightPct = ( xy[1] - bbox[1] ) / bboxHeight
-  const xPx = Math.floor( width * widthPct )
-  const yPx = Math.floor( height * ( 1 - heightPct ) )
+  // Convert lat/lon to geotiff x/y
+  const [xPx, yPx] = convertCoordinate([x,y], bbox, [width, height])
+ 
+  // Fetch window of raster values around x/y
+  const window = [
+    Math.floor(xPx), 
+    Math.floor(yPx),
+    Math.ceil(xPx),
+    Math.ceil(yPx)
+  ]
+  
+  // Fetch elevation value from geoTiff rasters
+  const elevation_data = await geoTiff.readRasters({
+    window: window,
+    fillValue: 0
+  })
+  
+  return elevation_data[0][0]
+}
 
-  const window = [ xPx, yPx, xPx + 1, yPx + 1 ]
-  const elevation_data = await geoTiff.readRasters( {window} )
+/** Creates an ASCII visualization of a terrain GeoTiff. Useful for display in a terminal.
+ * NOTE: You may want to use a downsmapled GeoTiff to fit within your terminal window. A GeoTiff pixel is represented by 3 characters each.
+ * @param {object} gTiff - GeoTiff output from getTerrainGeoTIFF() or getDenmarkGeoTiff() method
+ */
+async function visualizeGeotiff(gTiff) {
+  console.log('--- GTIFF visualization ---')
+  const float32Arr = await gTiff.readRasters()
+  const tiffWidth = gTiff.getWidth()
+  const rasters = float32Arr[0]
+  let lines = []
+  let line = ''
+  for (let i = 0; i < rasters.length; i++) {
+    if (i % tiffWidth === 0) {
+      lines.push(line)
+      line = ''
+    }
+    line += zeroPadNumber(rasters[i])
+  }
+  for (const l of lines) {
+    console.log(l)
+  }
+}
 
-  return Math.round( elevation_data[0][0] * 10) / 10
+/** Converts numbers to strings in a 3-letter format. Ex. `002`, `0-3` (for negative numbers), or `123` */
+function zeroPadNumber(input) {
+  if (input === 0) {
+      return "..."
+  } else if (input < 0) {
+      return `0${input.toFixed(0)}`
+  } else if (input < 10) {
+      return `00${Math.floor(input)}`
+  } else if (input < 100) {
+      return `0${Math.floor(input)}`
+  } else {
+      return `${Math.floor(input)}`
+  }
 }
 
 export {
-  getTerrainGeoTIFF,
-  getElevation
+  getElevation,
+  visualizeGeotiff
 }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@dataforsyningen/saul",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "description": "This is a collection of stand-alone methods for photogrammetry calculations and API interactions for 'Danske Skråfotos'.",
   "main": "index.js",
   "type": "module",
   "scripts": {
-    "test": "echo 'TESTS WILL ONLY RUN UNDER NODE v18' && node ./test/saul-projection.test.js && node ./test/saul-core.test.js && node ./test/saul-combined.test.js && node ./test/saul-elevation.test.js",
+    "test": "echo 'Tests require Node.js >= 18.0.0' && node ./test/saul-projection.test.js && node ./test/saul-core.test.js && node ./test/saul-combined.test.js && node ./test/saul-elevation.test.js",
     "docs": "jsdoc ./modules/*.js --destination docs"
   },
   "repository": {

package/test/geotiff-experiments.js

@@ -0,0 +1,250 @@
+import auth from '../config.js'
+import { getElevation, visualizeGeotiff } from '../modules/saul-elevation.js'
+import { getImageXY, getWorldXYZ } from '../modules/saul-core.js'
+import { getDenmarkGeoTiff, consumeGeoTIFF } from '../modules/api.js'
+
+const geoTiffResolution = 1000
+
+const worldxy = [533344, 6172951] // World XY Point in all images near Vejle
+const image1xy = [8566,4105] // Point/Image XY in `image1`
+const image1 = '2023_83_29_2_0019_00001130' // Vejle N
+const image2 = '2023_83_29_4_0017_00001752' // Vejle E
+const image3 = '2023_83_29_3_0019_00001149' // Veje S
+const image4 = '2023_83_29_5_0022_00002826' // Vejle W
+const image0 = '2023_83_29_1_0019_00001139' // Vejle Nadir
+
+const point1 = [724400, 6175773] // Rådhuspladsen
+const point2 = [595686, 6170394] // In the sea
+const point3 = [542656, 6217825] // Near Himmelbjerg
+const point4 = [480770, 6087529] // Marshes in the west
+const point5 = [533394, 6173015] // Steep street in Vejle
+const point6 = [533381, 6173108] // Vejle 2
+const point7 = [533339, 6172860] // Vejle 3
+
+const pointn = [596610, 6402161] // Skagen
+const points = [692008, 6049902] // Gedser
+const pointø = [892999, 6147725] // Christians Ø
+const pointv = [441977, 6157385] // Blåvands hug
+
+function fetchKote(worldXY) {
+  return fetch(`https://services.datafordeler.dk/DHMTerraen/DHMKoter/1.0.0/GEOREST/HentKoter?geop=POINT(${worldXY[0]} ${worldXY[1]})&elevationmodel=dtm&username=${auth.API_DHM_TOKENA}&password=${auth.API_DHM_TOKENB}`)
+  .then((response) => {
+    return response.json()
+  })
+  .then((kote) => {
+    return kote.HentKoterRespons.data[0].kote
+  })
+}
+
+function fetchImageData(imageId) {
+  return fetch(`https://api.dataforsyningen.dk/rest/skraafoto_api/v1.0/search?limit=1&crs=http://www.opengis.net/def/crs/EPSG/0/25832&ids=${imageId}&token=e88d7be6754140025ebeb63d57e991ae`)
+  .then((response) => response.json())
+  .then((data) => {
+    return data.features[0]
+  })
+}
+
+/*
+ * Example request to get terrain data for all of DK
+ * https://services.datafordeler.dk/DHMNedboer/dhm_wcs/1.0.0/WCS?SERVICE=WCS&COVERAGE=dhm_terraen&RESPONSE_CRS=epsg:25832&CRS=epsg:25832&FORMAT=GTiff&REQUEST=GetCoverage&VERSION=1.0.0&username=QKJBQATHVS&password=ytxCA8UGM5n0Z*zi&height=1000&width=1000&bbox=430000,6040000,900000,6413000
+ */
+
+console.log('-------------------------------------------------------')
+console.log('-- Experiments with pan-Danish GeoTiff terrain model --')
+console.log('-------------------------------------------------------')
+
+/* 
+It should
+- fetch geotiff from all of DK
+- fetch image data from several images covering the same area
+- should simulate a click in one image (img1 at [8566,4105])
+- should calculate worldxyz 1 from that click
+- should calculate imagexy in another image
+- should calculate worldxyz 2 from that imagexy
+- should compare worldxyz 1 and worldxyz 2
+- should compare worldxyz 1 z and worldxyz 2 z and kote
+*/
+
+// Get GTiff from API
+// const DKGeoTiff = await getDenmarkGeoTiff({auth: auth, size: geoTiffResolution})
+
+// Get big GTiff
+const DKGeoTiff = await getDenmarkGeoTiff({src: 'http://localhost:7701/dk-terrain.tiff'})
+
+// Get tiny GTiff
+//const DKGeoTiff = await getDenmarkGeoTiff({src: 'http://localhost:7701/tiny-dk-terrain.tiff'})
+
+const imgData0 = await fetchImageData(image0)
+const imgData1 = await fetchImageData(image1)
+const imgData2 = await fetchImageData(image2)
+const imgData3 = await fetchImageData(image3)
+const imgData4 = await fetchImageData(image4)
+
+// Simulate click in image north at [8566,4105]
+const calcdWorldXYZ1 = await getWorldXYZ({
+  xy: image1xy, 
+  image: imgData1, 
+  terrain: DKGeoTiff
+})
+const calcdImageXY2 = getImageXY(imgData2, ...calcdWorldXYZ1)
+const calcdWorldXYZ2 = await getWorldXYZ({
+  xy: calcdImageXY2, 
+  image: imgData2, 
+  terrain: DKGeoTiff
+})
+const calcdImageXY3 = getImageXY(imgData3, ...calcdWorldXYZ2)
+const calcdWorldXYZ3 = await getWorldXYZ({
+  xy: calcdImageXY3, 
+  image: imgData3, 
+  terrain: DKGeoTiff
+})
+const calcdImageXY4 = getImageXY(imgData4, ...calcdWorldXYZ3)
+const calcdWorldXYZ4 = await getWorldXYZ({
+  xy: calcdImageXY4, 
+  image: imgData4, 
+  terrain: DKGeoTiff
+})
+const calcdImageXY0 = getImageXY(imgData0, ...calcdWorldXYZ4)
+const calcdWorldXYZ0 = await getWorldXYZ({
+  xy: calcdImageXY0, 
+  image: imgData0, 
+  terrain: DKGeoTiff
+})
+const calcdImageXY10 = getImageXY(imgData1, ...calcdWorldXYZ0)
+const calcdWorldXYZ10 = await getWorldXYZ({
+  xy: calcdImageXY10, 
+  image: imgData1, 
+  terrain: DKGeoTiff
+})
+
+function getRandomPoint() {
+  const bbox = [430000,6040000,900000,6413000]
+  const width = bbox[2] - bbox[0]
+  const height = bbox[3] - bbox[1]
+  const randomX = bbox[0] + (Math.random() * width)
+  const randomY = bbox[1] + (Math.random() * height)
+  return [randomX, randomY]
+}
+
+const randomPoint1 = getRandomPoint()
+const randomPoint2 = getRandomPoint()
+const randomPoint3 = getRandomPoint()
+const randomPoint4 = getRandomPoint()
+const randomPoint5 = getRandomPoint()
+const randomPoint6 = getRandomPoint()
+const randomPoint7 = getRandomPoint()
+const randomPoint8 = getRandomPoint()
+const randomPoint9 = getRandomPoint()
+const randomPoint10 = getRandomPoint()
+
+console.log('From origin, use world coordinate to calculate image coordinate.')
+console.log('Then uses that image coordinate to calculate world coordinate and feed it into the next image calculations.')
+console.table({
+  origins: {worldxyz: worldxy, imagexy: image1xy},
+  image1: {worldxyz: calcdWorldXYZ1, imagexy: image1xy},
+  image2: {worldxyz: calcdWorldXYZ2, imagexy: calcdImageXY2},
+  image3: {worldxyz: calcdWorldXYZ3, imagexy: calcdImageXY3},
+  image4: {worldxyz: calcdWorldXYZ4, imagexy: calcdImageXY4},
+  image0: {worldxyz: calcdWorldXYZ0, imagexy: calcdImageXY0},
+  back_to_image1: {worldxyz: calcdWorldXYZ10, imagexy: calcdImageXY10}
+})
+
+console.log('Using image px coordinate to calculate a world coordinate and back again.')
+console.table({
+  imageXY: {
+    original: [8566,4105],
+    'round-trip': getImageXY(imgData1, ...calcdWorldXYZ0)
+  }
+})
+
+console.log('Samle elevations fetched from kote API or calculated from GeoTiff:')
+console.table({
+  'Rådhuspladsen': {
+    kote: await fetchKote(point1),
+    gtiff: await getElevation(...point1, DKGeoTiff)
+  },
+  'In the sea': {
+    kote: await fetchKote(point2),
+    gtiff: await getElevation(...point2, DKGeoTiff)
+  },
+  'Near Himmelbjerg': {
+    kote: await fetchKote(point3),
+    gtiff: await getElevation(...point3, DKGeoTiff)
+  },
+  'Marshes in the west': {
+    kote: await fetchKote(point4),
+    gtiff: await getElevation(...point4, DKGeoTiff)
+  },
+  'Vejle 1': {
+    kote: await fetchKote(point5),
+    gtiff: await getElevation(...point5, DKGeoTiff)
+  },
+  'Vejle 2': {
+    kote: await fetchKote(point6),
+    gtiff: await getElevation(...point6, DKGeoTiff)
+  },
+  'Vejle 3': {
+    kote: await fetchKote(point7),
+    gtiff: await getElevation(...point7, DKGeoTiff)
+  },
+  'Skagen': {
+    kote: await fetchKote(pointn),
+    gtiff: await getElevation(...pointn, DKGeoTiff)
+  },
+  'Gedser': {
+    kote: await fetchKote(points),
+    gtiff: await getElevation(...points, DKGeoTiff)
+  },
+  'Blåvand': {
+    kote: await fetchKote(pointv),
+    gtiff: await getElevation(...pointv, DKGeoTiff)
+  },
+  'Chr. Ø': {
+    kote: await fetchKote(pointø),
+    gtiff: await getElevation(...pointø, DKGeoTiff)
+  },
+  'Random 1': {
+    kote: await fetchKote(randomPoint1),
+    gtiff: await getElevation(...randomPoint1, DKGeoTiff)
+  },
+  'Random 2': {
+    kote: await fetchKote(randomPoint2),
+    gtiff: await getElevation(...randomPoint2, DKGeoTiff)
+  },
+  'Random 3': {
+    kote: await fetchKote(randomPoint3),
+    gtiff: await getElevation(...randomPoint3, DKGeoTiff)
+  },
+  'Random 4': {
+    kote: await fetchKote(randomPoint4),
+    gtiff: await getElevation(...randomPoint4, DKGeoTiff)
+  },
+  'Random 5': {
+    kote: await fetchKote(randomPoint5),
+    gtiff: await getElevation(...randomPoint5, DKGeoTiff)
+  },
+  'Random 6': {
+    kote: await fetchKote(randomPoint6),
+    gtiff: await getElevation(...randomPoint6, DKGeoTiff)
+  },
+  'Random 7': {
+    kote: await fetchKote(randomPoint7),
+    gtiff: await getElevation(...randomPoint7, DKGeoTiff)
+  },
+  'Random 8': {
+    kote: await fetchKote(randomPoint8),
+    gtiff: await getElevation(...randomPoint8, DKGeoTiff)
+  },
+  'Random 9': {
+    kote: await fetchKote(randomPoint9),
+    gtiff: await getElevation(...randomPoint9, DKGeoTiff)
+  },
+  'Random 10': {
+    kote: await fetchKote(randomPoint10),
+    gtiff: await getElevation(...randomPoint10, DKGeoTiff)
+  }
+})
+
+console.log('got DKGeotiff', (DKGeoTiff.source.arrayBuffer.byteLength / 1024), 'Kb', pointø)
+
+//visualizeGeotiff(DKGeoTiff)

package/test/saul-combined.test.js

@@ -3,6 +3,9 @@
 import auth from '../config.js'
 import { getSTAC, getTerrainGeoTIFF,getZ, getWorldXYZ, getImageXY } from '../index.js'
 
+console.log('---------------')
+console.log('Combined tests ')
+console.log('---------------')
 
 // Vars
 const resolution = 0.005 // Higher number means more points and better precision
@@ -86,9 +89,11 @@ function is_equalIsh(num1, num2, deviation = max_deviation) {
     return true
   }
 }
+
 function generateSTACurl(stac_item_id) {
   return `/search?limit=1&crs=http://www.opengis.net/def/crs/EPSG/0/25832&ids=${ stac_item_id }`
 }
+
 async function enrichData(item) {
   let new_item = Object.assign({}, item)
   // add STAC item

package/test/saul-core.test.js

@@ -7,6 +7,10 @@ import auth from '../config.js'
 import assert from 'assert'
 import {getSTAC, world2image, image2world, getZ, iterate} from '../index.js'
 
+console.log('---------------')
+console.log('  Core tests   ')
+console.log('---------------')
+
 /*
 const item = await getSTAC('/collections/skraafotos2019/items/2019_83_37_2_0046_00001113', auth)
 const world_x = 580341
@@ -64,7 +68,7 @@ try {
   let xy = world2image(item, world_x, world_y, world_elevation)
 
   assert(is_equalIsh(xy[0], image_x, 1), `world2image fail: The x coordinate values ${xy[0]} ${image_x} are not equal`)
-  assert(is_equalIsh(xy[1], image_y), "world2image fail: The y coordinate values are not equal")
+  assert(is_equalIsh(xy[1], image_y, 1), `world2image fail: The y coordinate values ${xy[1]} ${image_y} are not equal`)
   
   console.log("Test world2image OK")
 

package/test/saul-elevation.test.js

@@ -5,6 +5,10 @@ import auth from '../config.js'
 import assert from 'assert'
 import { getElevation, get, getTerrainGeoTIFF, getZ, getWorldXYZ, world2image } from '../index.js'
 
+console.log('---------------')
+console.log('Elevation tests')
+console.log('---------------')
+
 // Vars
 const stac_item = '2021_83_29_2_0019_00003995'
 const fidelity = 0.03 // Higher number means more points and better precision
@@ -65,7 +69,7 @@ function compareElevations(x,y,geotiff) {
   .then(elevation => {
     getZ(x, y, auth)
     .then(getz_e => {
-      assert(is_equalIsh(getz_e, elevation, 0.5), `Elevations ${elevation} / ${getz_e} at ${x} ${y} do not match`)
+      assert(is_equalIsh(getz_e, elevation, 2.7), `Elevations ${elevation} / ${getz_e} at ${x} ${y} are way apart`)
       console.log(`Elevation at ${ x } ${ y } with delta ${Math.abs(elevation - getz_e).toFixed(2)} OK`)
     })
   })

package/test/saul-projection.test.js

@@ -4,6 +4,10 @@ import assert from 'assert'
 import proj4 from 'proj4'
 import {epsg25832proj, createTranslator} from '../index.js'
 
+console.log('----------------')
+console.log('Projection tests')
+console.log('----------------')
+
 // Test epsg25832proj
 try {