leaflet-city-mapper 0.0.9 → 0.1.1

package/src/textures/addImageState.js

@@ -1,8 +1,13 @@
 import { imageStates } from '../weakmaps/imageStates.js';
-
-
-export function addImageState(image, state) {
-  let states = imageStates.get(image);
-  if (!states) imageStates.set(image, states = /* alloc */ new Set());
-  states.add(state);
-}
+
+/**
+ * Associate a native layer state with an image.
+ *
+ * @param {HTMLImageElement} image Image to track.
+ * @param {Object} state Native layer state.
+ */
+export function addImageState(image, state) {
+  let states = imageStates.get(image);
+  if (!states) imageStates.set(image, states = /* alloc */ new Set());
+  states.add(state);
+}

package/src/textures/attachRasterImage.js

@@ -1,8 +1,7 @@
 import { pendingRasterLoads } from '../globals/pendingRasterLoads.js';
-
-
 import { fireRasterLoad } from '../core/fireRasterLoad.js';
 
+/** Initialize this raster layer's image and queue its load event if already loaded. */
 export function addRasterImage() {
   if (!this._image) this._initImage();
   if (this._image.complete && this._image.naturalWidth) {

package/src/textures/bindMeshTextures.js

@@ -1,50 +1,57 @@
-import { meshBindGroup } from '../globals/meshBindGroup.js';
-import { drawEntries } from '../globals/drawEntries.js';
-import { drawMeshEntry } from '../globals/drawMeshEntry.js';
-import { drawFrameEntry } from '../globals/drawFrameEntry.js';
-import { drawTerrainEntry } from '../globals/drawTerrainEntry.js';
-import { drawTextureEntries } from '../globals/drawTextureEntries.js';
-import { drawSamplerEntries } from '../globals/drawSamplerEntries.js';
-
-export function bindMeshTextures(renderer, mesh, textures) {
-  const { program } = mesh;
-  const entries = drawEntries;
-  entries.length = 0;
-  drawMeshEntry.resource.buffer = renderer.uniformBuffer;
-  drawFrameEntry.resource.buffer = renderer.uniformBuffer;
-  entries.push(drawMeshEntry, drawFrameEntry);
-  if (program.terrain) {
-    drawTerrainEntry.resource = program.terrain.texture.createView();
-    entries.push(drawTerrainEntry);
-  }
-  mesh.boundBuffer = renderer.uniformBuffer;
-  const boundTextures = mesh.boundTextures ||= /* alloc */ [];
-  boundTextures.length = textures.length;
-  let i, binding, texture;
-  for (i = 0; i < textures.length; i++) {
-    binding = program.bindings[i], texture = textures[i];
-    drawTextureEntries[i].binding = binding.texture;
-    drawTextureEntries[i].resource = texture.texture.createView();
-    drawSamplerEntries[i].binding = binding.sampler;
-    drawSamplerEntries[i].resource = texture.sampler;
-    entries.push(drawTextureEntries[i], drawSamplerEntries[i]);
-    boundTextures[i] ||= /* alloc */ [];
-    boundTextures[i][0] = texture.texture;
-    boundTextures[i][1] = texture.sampler;
-  }
-  mesh.bindGroup = renderer.device.createBindGroup((
-    meshBindGroup.layout = program.bindGroupLayout,
-    meshBindGroup.entries = entries,
-    meshBindGroup
-  ));
-  meshBindGroup.layout = null;
-  meshBindGroup.entries = null;
-  drawMeshEntry.resource.buffer = null;
-  drawFrameEntry.resource.buffer = null;
-  drawTerrainEntry.resource = null;
-  for (i = 0; i < textures.length; i++) {
-    drawTextureEntries[i].resource = null;
-    drawSamplerEntries[i].resource = null;
-  }
-  entries.length = 0;
-}
+import { meshBindGroup } from '../globals/meshBindGroup.js';
+import { drawEntries } from '../globals/drawEntries.js';
+import { drawMeshEntry } from '../globals/drawMeshEntry.js';
+import { drawFrameEntry } from '../globals/drawFrameEntry.js';
+import { drawTerrainEntry } from '../globals/drawTerrainEntry.js';
+import { drawTextureEntries } from '../globals/drawTextureEntries.js';
+import { drawSamplerEntries } from '../globals/drawSamplerEntries.js';
+
+/**
+ * Create the mesh bind group for frame uniforms, terrain and material textures.
+ *
+ * @param {Object} renderer Renderer providing the device and uniform buffer.
+ * @param {Object} mesh Mesh whose bind group is updated.
+ * @param {Array<Object>} textures Texture and sampler pairs in program binding order.
+ */
+export function bindMeshTextures(renderer, mesh, textures) {
+  const { program } = mesh;
+  const entries = drawEntries;
+  entries.length = 0;
+  drawMeshEntry.resource.buffer = renderer.uniformBuffer;
+  drawFrameEntry.resource.buffer = renderer.uniformBuffer;
+  entries.push(drawMeshEntry, drawFrameEntry);
+  if (program.terrain) {
+    drawTerrainEntry.resource = program.terrain.texture.createView();
+    entries.push(drawTerrainEntry);
+  }
+  mesh.boundBuffer = renderer.uniformBuffer;
+  const boundTextures = mesh.boundTextures ||= /* alloc */ [];
+  boundTextures.length = textures.length;
+  let i, binding, texture;
+  for (i = 0; i < textures.length; i++) {
+    binding = program.bindings[i], texture = textures[i];
+    drawTextureEntries[i].binding = binding.texture;
+    drawTextureEntries[i].resource = texture.texture.createView();
+    drawSamplerEntries[i].binding = binding.sampler;
+    drawSamplerEntries[i].resource = texture.sampler;
+    entries.push(drawTextureEntries[i], drawSamplerEntries[i]);
+    boundTextures[i] ||= /* alloc */ [];
+    boundTextures[i][0] = texture.texture;
+    boundTextures[i][1] = texture.sampler;
+  }
+  mesh.bindGroup = renderer.device.createBindGroup((
+    meshBindGroup.layout = program.bindGroupLayout,
+    meshBindGroup.entries = entries,
+    meshBindGroup
+  ));
+  meshBindGroup.layout = null;
+  meshBindGroup.entries = null;
+  drawMeshEntry.resource.buffer = null;
+  drawFrameEntry.resource.buffer = null;
+  drawTerrainEntry.resource = null;
+  for (i = 0; i < textures.length; i++) {
+    drawTextureEntries[i].resource = null;
+    drawSamplerEntries[i].resource = null;
+  }
+  entries.length = 0;
+}

package/src/textures/collectRoofTiles.js

@@ -1,16 +1,23 @@
 import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
 
-
-export function collectRoofTiles(rasters, tiles) {
-  let zoom = -Infinity, layer, tile;
-  for (layer of rasters) {
-    for (tile of rasterTilesByLayer.get(layer).values()) {
-      if (tile.done && !tile.request.signal.aborted && tile.image) {
-        tile._roofEntry ||= /* alloc */ { tile, layer };
-        tiles.push(tile._roofEntry);
-        zoom = Math.max(zoom, tile.coords.z);
-      }
-    }
-  }
-  return zoom;
-}
+/**
+ * Collect completed, unaborted raster tiles with images for the roof atlas.
+ *
+ * @param {Array<L.Layer>} rasters Raster layers to inspect.
+ * @param {Array<Object>} tiles Destination for tile and layer entries.
+ *
+ * @returns {number} Highest collected tile zoom, or negative infinity if none.
+ */
+export function collectRoofTiles(rasters, tiles) {
+  let zoom = -Infinity, layer, tile;
+  for (layer of rasters) {
+    for (tile of rasterTilesByLayer.get(layer).values()) {
+      if (tile.done && !tile.request.signal.aborted && tile.image) {
+        tile._roofEntry ||= /* alloc */ { tile, layer };
+        tiles.push(tile._roofEntry);
+        zoom = Math.max(zoom, tile.coords.z);
+      }
+    }
+  }
+  return zoom;
+}

package/src/textures/compareRoofTiles.js

@@ -1,3 +1,11 @@
+/**
+ * Order roof tiles by layer z-index and then tile zoom.
+ *
+ * @param {Object} a First tile and layer entry.
+ * @param {Object} b Second tile and layer entry.
+ *
+ * @returns {number} Sort comparison.
+ */
 export function compareRoofTiles(a, b) {
   return (a.layer.options.zIndex || 0) - (b.layer.options.zIndex || 0) ||
     a.tile.coords.z - b.tile.coords.z;

package/src/textures/composeRoofAtlas.js

@@ -1,6 +1,5 @@
 import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
 import { roofRasterByLayer } from '../weakmaps/roofRasterByLayer.js';
-
 import { roofBuffer } from '../globals/roofBuffer.js';
 import { roofPass } from '../globals/roofPass.js';
 import { uploadRoofTile } from './uploadRoofTile.js';
@@ -8,10 +7,19 @@ import { roofBindGroup } from '../globals/roofBindGroup.js';
 import { roofCommands } from '../globals/roofCommands.js';
 import { roofOpacities } from '../globals/roofOpacities.js';
 import { TILE_SIZE } from '../globals/TILE_SIZE.js';
-
-
 import { compareRoofTiles } from './compareRoofTiles.js';
 
+/**
+ * Composite raster tiles into the roof atlas on the GPU, in layer and zoom order.
+ *
+ * @param {L.Layer} layer Rendering layer owning the atlas.
+ * @param {Array<Object>} tiles Tile and layer entries to composite and sort.
+ * @param {number} zoom Atlas coordinate zoom.
+ * @param {L.Point} min Atlas origin in projected pixels.
+ * @param {L.Point} size Atlas extent in projected pixels.
+ * @param {number} width Texture width in pixels.
+ * @param {number} height Texture height in pixels.
+ */
 export function composeRoofAtlas(layer, tiles, zoom, min, size, width, height) {
   const renderer = rendererByLayer.get(layer), device = renderer.device, map = layer._map;
   const opacityLength = Math.max(1, tiles.length) * 64;

package/src/textures/destroyTexture.js

@@ -1,10 +1,12 @@
 import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
-
-
-
-
 import { destroyAfterSubmission } from './destroyTextureAfterSubmission.js';
 
+/**
+ * Schedule destruction of a GPU resource after the renderer's submitted work finishes.
+ *
+ * @param {L.Layer} layer Rendering layer used to report queue errors.
+ * @param {GPUTexture|GPUBuffer} texture Resource to destroy.
+ */
 export function destroyTexture(layer, texture) {
   destroyAfterSubmission(layer, texture, rendererByLayer.get(layer).device.queue.onSubmittedWorkDone());
 }

package/src/textures/destroyTextureAfterSubmission.js

@@ -1,3 +1,12 @@
+/**
+ * Destroy a GPU resource after submitted work settles, reporting a rejected submission.
+ *
+ * @param {L.Layer} layer Layer receiving error events.
+ * @param {GPUTexture|GPUBuffer} texture Resource to destroy.
+ * @param {Promise<void>} submitted Completion of previously submitted work.
+ *
+ * @returns {Promise<void>} Completion of resource destruction.
+ */
 export async function destroyAfterSubmission(layer, texture, submitted) {
   try {
     await submitted;

package/src/textures/ensureRoofBlit.js

@@ -2,6 +2,11 @@ import { roofShader } from '../globals/roofShader.js';
 import { roofPipeline } from '../globals/roofPipeline.js';
 import { roofBlitSampler } from '../globals/roofBlitSampler.js';
 
+/**
+ * Create the roof-atlas blit pipeline and sampler if they do not yet exist.
+ *
+ * @param {Object} renderer Renderer owning the GPU device and blit state.
+ */
 export function ensureRoofBlit(renderer) {
   const device = renderer.device;
   if (!renderer.roofBlit) {

package/src/textures/loadModelImage.js

@@ -1,19 +1,29 @@
 import { geometryImageOptions } from '../globals/geometryImageOptions.js';
-
-
-export async function loadImage(description, directory, image) {
-  let blob;
-  if (image.bufferView !== undefined) {
-    const view = description.bufferViews[image.bufferView];
-    const buffer = description.buffers[view.buffer].binary;
-    blob = /* alloc */ new Blob(
-      /* alloc */ [buffer.slice(view.byteOffset || 0, (view.byteOffset || 0) + view.byteLength)],
-      /* alloc */ { type: image.mimeType });
-  } else {
-    const response = await fetch(/* alloc */ new URL(image.uri, directory).href);
-    if (!response.ok) throw /* alloc */ new Error(`Unable to load model texture: HTTP ${response.status}`);
-    blob = await response.blob();
-  }
-  // Preserve straight alpha and raw samples; GPU sRGB formats do color decoding.
-  return createImageBitmap(blob, geometryImageOptions);
-}
+
+/**
+ * Load a glTF image from a buffer view or URI as an unpremultiplied image bitmap.
+ *
+ * @param {Object} description Decoded glTF document with loaded buffers.
+ * @param {string} directory Base URL for external image URIs.
+ * @param {Object} image glTF image specification.
+ *
+ * @returns {Promise<ImageBitmap>} Decoded image.
+ *
+ * @throws {Error} If an external image response is not successful.
+ */
+export async function loadImage(description, directory, image) {
+  let blob;
+  if (image.bufferView !== undefined) {
+    const view = description.bufferViews[image.bufferView];
+    const buffer = description.buffers[view.buffer].binary;
+    blob = /* alloc */ new Blob(
+      /* alloc */ [buffer.slice(view.byteOffset || 0, (view.byteOffset || 0) + view.byteLength)],
+      /* alloc */ { type: image.mimeType });
+  } else {
+    const response = await fetch(/* alloc */ new URL(image.uri, directory).href);
+    if (!response.ok) throw /* alloc */ new Error(`Unable to load model texture: HTTP ${response.status}`);
+    blob = await response.blob();
+  }
+  // Preserve straight alpha and raw samples; GPU sRGB formats do color decoding.
+  return createImageBitmap(blob, geometryImageOptions);
+}

package/src/textures/modelTextureFor.js

@@ -1,39 +1,47 @@
 import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { textureSampler } from './modelTextureSampler.js';
 
-
-
-import { textureSampler } from './modelTextureSampler.js';
-
-export function textureFor(context, reference, color = false) {
-  const { backend: layer, description, images, textures } = context;
-  if (!reference) return null;
-  if ((reference.texCoord || 0) !== 0 || reference.extensions) {
-    throw /* alloc */ new Error('Model textures currently require untransformed TEXCOORD_0 UVs');
-  }
-  const device = rendererByLayer.get(layer).device;
-  // A glTF image may serve both color and data maps: those cannot share a GPU format.
-  const key = `${reference.index}:${color}`;
-  if (!textures.has(key)) {
-    const texture = description.textures[reference.index];
-    const sampler = description.samplers?.[texture.sampler];
-    const image = images[texture.source];
-    const format = color ? 'rgba8unorm-srgb' : 'rgba8unorm';
-    const samplerOptions = textureSampler(sampler);
-    textures.set(key, /* alloc */ {
-      device,
-      texture: device.createTexture(/* alloc */ {
-        size: /* alloc */ [image.width, image.height],
-        format,
-        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-      }),
-      sampler: device.createSampler(samplerOptions),
-      samplerOptions,
-      format,
-      srgb: color,
-      image,
-      flipY: false,
-      uploaded: null,
-    });
-  }
-  return textures.get(key);
-}
+/**
+ * Get or create a model texture, using separate cache entries for color and data formats.
+ *
+ * @param {Object} context Model context containing images, texture descriptions and cache.
+ * @param {Object} reference glTF texture reference, if present.
+ * @param {boolean} [color] Whether to use an sRGB color format.
+ *
+ * @returns {Object|null} Cached texture state, or null without a reference.
+ *
+ * @throws {Error} If the texture uses transformed UVs or a set other than TEXCOORD_0.
+ */
+export function textureFor(context, reference, color = false) {
+  const { backend: layer, description, images, textures } = context;
+  if (!reference) return null;
+  if ((reference.texCoord || 0) !== 0 || reference.extensions) {
+    throw /* alloc */ new Error('Model textures currently require untransformed TEXCOORD_0 UVs');
+  }
+  const device = rendererByLayer.get(layer).device;
+  // A glTF image may serve both color and data maps: those cannot share a GPU format.
+  const key = `${reference.index}:${color}`;
+  if (!textures.has(key)) {
+    const texture = description.textures[reference.index];
+    const sampler = description.samplers?.[texture.sampler];
+    const image = images[texture.source];
+    const format = color ? 'rgba8unorm-srgb' : 'rgba8unorm';
+    const samplerOptions = textureSampler(sampler);
+    textures.set(key, /* alloc */ {
+      device,
+      texture: device.createTexture(/* alloc */ {
+        size: /* alloc */ [image.width, image.height],
+        format,
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+      }),
+      sampler: device.createSampler(samplerOptions),
+      samplerOptions,
+      format,
+      srgb: color,
+      image,
+      flipY: false,
+      uploaded: null,
+    });
+  }
+  return textures.get(key);
+}

package/src/textures/modelTextureSampler.js

@@ -1,5 +1,10 @@
-/** Translate glTF sampler constants into WebGPU sampler options. */
-
+/**
+ * Translate glTF sampler constants into WebGPU sampler options.
+ *
+ * @param {Object} sampler glTF sampler, if present.
+ *
+ * @returns {Object} WebGPU addressing and filtering options.
+ */
 export function textureSampler(sampler) {
   return /* alloc */ {
     addressModeU: sampler?.wrapS === 33071 ? 'clamp-to-edge' : sampler?.wrapS === 33648 ? 'mirror-repeat' : 'repeat',

package/src/textures/nativeImageError.js

@@ -1,6 +1,10 @@
 import { imageStates } from '../weakmaps/imageStates.js';
 
-
+/**
+ * Report a native image load failure to every associated source layer.
+ *
+ * @param {Event} event Image error event.
+ */
 export function nativeImageError(event) {
   const states = imageStates.get(event.currentTarget);
   if (!states) return;

package/src/textures/nativeImageRefresh.js

@@ -1,8 +1,11 @@
 import { imageStates } from '../weakmaps/imageStates.js';
-
-
 import { refreshNativeLayer } from '../native/refreshNativeLayer.js';
 
+/**
+ * Refresh all native layer states associated with an image event.
+ *
+ * @param {Event} event Image event.
+ */
 export function nativeImageRefresh(event) {
   const states = imageStates.get(event.currentTarget);
   if (!states) return;

package/src/textures/nativeTextureFor.js

@@ -1,13 +1,21 @@
 import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
-
 import { coreSampler } from '../globals/coreSampler.js';
-
 import { disposeMesh } from '../rendering/disposeMesh.js';
 import { destroyTexture } from './destroyTexture.js';
 import { uploadCanvasTexture } from './uploadCanvasTexture.js';
 import { uploadNativeImage } from './uploadNativeImage.js';
 
-
+/**
+ * Get or create a native raster texture, returning it once its image is uploaded.
+ *
+ * @param {Object} state Native layer state with texture and mesh caches.
+ * @param {string} key Tile or image cache key.
+ * @param {HTMLImageElement|HTMLCanvasElement} image Raster source.
+ *
+ * @returns {Object|undefined} Uploaded texture state, if ready.
+ *
+ * @throws {Error} If the source is neither an image nor a canvas.
+ */
 export function textureFor(state, key, image) {
   if (!(image instanceof HTMLImageElement) && !(image instanceof HTMLCanvasElement)) {
     throw /* alloc */ new Error('WebGPU native raster layers require image or canvas tiles');

package/src/textures/prepareMeshTextures.js

@@ -1,23 +1,31 @@
-import { uploadMeshTexture } from './uploadMeshTexture.js';
-import { bindMeshTextures } from './bindMeshTextures.js';
-
-export function prepareMeshTextures(renderer, mesh) {
-  const { program } = mesh;
-  const { device } = renderer;
-  const textures = mesh._textures ||= /* alloc */ [];
-  textures.length = 0;
-  let binding, texture, i;
-  for (binding of program.bindings) {
-    texture = program.uniforms[binding.name]?.value;
-    if (!texture) throw /* alloc */ new Error(`Missing Layer3D texture: ${binding.name}`);
-    uploadMeshTexture(device, texture);
-    textures.push(texture);
-  }
-  let bindingsChanged = !mesh.bindGroup || mesh.boundBuffer !== renderer.uniformBuffer ||
-    textures.length !== mesh.boundTextures.length;
-  for (i = 0; !bindingsChanged && i < textures.length; i++) {
-    if (textures[i].texture !== mesh.boundTextures[i][0] ||
-      textures[i].sampler !== mesh.boundTextures[i][1]) bindingsChanged = true;
-  }
-  if (bindingsChanged) bindMeshTextures(renderer, mesh, textures);
-}
+import { uploadMeshTexture } from './uploadMeshTexture.js';
+import { bindMeshTextures } from './bindMeshTextures.js';
+
+/**
+ * Upload a mesh's program textures and rebuild its bind group when bindings change.
+ *
+ * @param {Object} renderer Renderer providing the GPU device and uniform buffer.
+ * @param {Object} mesh Mesh whose textures and bindings are prepared.
+ *
+ * @throws {Error} If a required program texture is missing.
+ */
+export function prepareMeshTextures(renderer, mesh) {
+  const { program } = mesh;
+  const { device } = renderer;
+  const textures = mesh._textures ||= /* alloc */ [];
+  textures.length = 0;
+  let binding, texture, i;
+  for (binding of program.bindings) {
+    texture = program.uniforms[binding.name]?.value;
+    if (!texture) throw /* alloc */ new Error(`Missing Layer3D texture: ${binding.name}`);
+    uploadMeshTexture(device, texture);
+    textures.push(texture);
+  }
+  let bindingsChanged = !mesh.bindGroup || mesh.boundBuffer !== renderer.uniformBuffer ||
+    textures.length !== mesh.boundTextures.length;
+  for (i = 0; !bindingsChanged && i < textures.length; i++) {
+    if (textures[i].texture !== mesh.boundTextures[i][0] ||
+      textures[i].sampler !== mesh.boundTextures[i][1]) bindingsChanged = true;
+  }
+  if (bindingsChanged) bindMeshTextures(renderer, mesh, textures);
+}

package/src/textures/rebuildRoofAtlas.js

@@ -1,20 +1,25 @@
 import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
 import { roofRasterByLayer } from '../weakmaps/roofRasterByLayer.js';
 import { sceneOriginByLayer } from '../weakmaps/sceneOriginByLayer.js';
-
 import { radians } from '../globals/radians.js';
 import { earthCirc } from '../globals/earthCirc.js';
 import { roofTiles } from '../globals/roofTiles.js';
 import { TILE_SIZE } from '../globals/TILE_SIZE.js';
 import { roofMin } from '../globals/roofMin.js';
 import { roofSize } from '../globals/roofSize.js';
-
-
 import { ensureRoofBlit } from './ensureRoofBlit.js';
 import { composeRoofAtlas } from './composeRoofAtlas.js';
 import { collectRoofTiles } from './collectRoofTiles.js';
 import { resizeRoofTexture } from './resizeRoofTexture.js';
 
+/**
+ * Rebuild the roof atlas from available raster tiles and update its scene-to-atlas matrix.
+ *
+ * @param {L.Layer} layer Rendering layer owning the atlas.
+ * @param {Array<L.Layer>} rasters Raster layers to composite.
+ * @param {string} signature Raster state signature.
+ * @param {number} now Current frame time in milliseconds.
+ */
 export function rebuildRoofAtlas(layer, rasters, signature, now) {
   const map = layer._map, renderer = rendererByLayer.get(layer);
   const tiles = roofTiles;

package/src/textures/removeImageState.js

@@ -1,9 +1,14 @@
 import { imageStates } from '../weakmaps/imageStates.js';
 
-
-export function removeImageState(image, state) {
-  const states = imageStates.get(image);
-  if (!states) return;
-  states.delete(state);
-  if (!states.size) imageStates.delete(image);
+/**
+ * Remove a native layer state from an image's tracked associations.
+ *
+ * @param {HTMLImageElement} image Image to update.
+ * @param {Object} state Native layer state to remove.
+ */
+export function removeImageState(image, state) {
+  const states = imageStates.get(image);
+  if (!states) return;
+  states.delete(state);
+  if (!states.size) imageStates.delete(image);
 }