Merge pull request #463 from geotiffjs/feature/write-typedarrays

Author: constantinius

src/geotiffwriter.js

@@ -4,8 +4,9 @@
   You can view that here:
   https://github.com/photopea/UTIF.js/blob/master/LICENSE
 */
-import { fieldTagNames, fieldTagTypes, fieldTypeNames, geoKeyNames } from './globals.js';
-import { assign, endsWith, forEach, invert, times } from './utils.js';
+import { fieldTags, fieldTagNames, fieldTagTypes, fieldTypeNames, geoKeyNames } from './globals.js';
+import { assign, endsWith, forEach, invert, times, typeMap,
+  isTypedUintArray, isTypedIntArray, isTypedFloatArray } from './utils.js';
 
 const tagName2Code = invert(fieldTagNames);
 const geoKeyName2Code = invert(geoKeyNames);
@@ -251,17 +252,50 @@ const encodeImage = (values, width, height, metadata) => {
   }
 
   const prfx = new Uint8Array(encodeIfds([ifd]));
+  const samplesPerPixel = ifd[fieldTags.SamplesPerPixel];
 
-  const img = new Uint8Array(values);
+  const dataType = values.constructor.name;
+  const TypedArray = typeMap[dataType];
 
-  const samplesPerPixel = ifd[277];
+  // default for Float64
+  let elementSize = 8;
+  if (TypedArray) {
+    elementSize = TypedArray.BYTES_PER_ELEMENT;
+  }
+
+  const data = new Uint8Array(numBytesInIfd + (values.length * elementSize * samplesPerPixel));
 
-  const data = new Uint8Array(numBytesInIfd + (width * height * samplesPerPixel));
   times(prfx.length, (i) => {
     data[i] = prfx[i];
   });
-  forEach(img, (value, i) => {
-    data[numBytesInIfd + i] = value;
+
+  forEach(values, (value, i) => {
+    if (!TypedArray) {
+      data[numBytesInIfd + i] = value;
+      return;
+    }
+
+    const buffer = new ArrayBuffer(elementSize);
+    const view = new DataView(buffer);
+
+    if (dataType === 'Float64Array') {
+      view.setFloat64(0, value, false);
+    } else if (dataType === 'Float32Array') {
+      view.setFloat32(0, value, false);
+    } else if (dataType === 'Uint32Array') {
+      view.setUint32(0, value, false);
+    } else if (dataType === 'Uint16Array') {
+      view.setUint16(0, value, false);
+    } else if (dataType === 'Uint8Array') {
+      view.setUint8(0, value);
+    }
+
+    const typedArray = new Uint8Array(view.buffer);
+    const idx = numBytesInIfd + (i * elementSize);
+
+    for (let j = 0; j < elementSize; j++) {
+      data[idx + j] = typedArray[j];
+    }
   });
 
   return data.buffer;
@@ -328,7 +362,11 @@ export function writeGeotiff(data, metadata) {
   // consult https://www.loc.gov/preservation/digital/formats/content/tiff_tags.shtml
 
   if (!metadata.BitsPerSample) {
-    metadata.BitsPerSample = times(numBands, () => 8);
+    let bitsPerSample = 8;
+    if (ArrayBuffer.isView(flattenedValues)) {
+      bitsPerSample = 8 * flattenedValues.BYTES_PER_ELEMENT;
+    }
+    metadata.BitsPerSample = times(numBands, () => bitsPerSample);
   }
 
   metadataDefaults.forEach((tag) => {
@@ -352,7 +390,15 @@ export function writeGeotiff(data, metadata) {
 
   if (!metadata.StripByteCounts) {
     // we are only writing one strip
-    metadata.StripByteCounts = [numBands * height * width];
+
+    // default for Float64
+    let elementSize = 8;
+
+    if (ArrayBuffer.isView(flattenedValues)) {
+      elementSize = flattenedValues.BYTES_PER_ELEMENT;
+    }
+
+    metadata.StripByteCounts = [numBands * elementSize * height * width];
   }
 
   if (!metadata.ModelPixelScale) {
@@ -361,7 +407,17 @@ export function writeGeotiff(data, metadata) {
   }
 
   if (!metadata.SampleFormat) {
-    metadata.SampleFormat = times(numBands, () => 1);
+    let sampleFormat = 1;
+    if (isTypedFloatArray(flattenedValues)) {
+      sampleFormat = 3;
+    }
+    if (isTypedIntArray(flattenedValues)) {
+      sampleFormat = 2;
+    }
+    if (isTypedUintArray(flattenedValues)) {
+      sampleFormat = 1;
+    }
+    metadata.SampleFormat = times(numBands, () => sampleFormat);
   }
 
   // if didn't pass in projection information, assume the popular 4326 "geographic projection"

src/globals.js

@@ -161,10 +161,18 @@ export const fieldTagTypes = {
   514: 'LONG',
   1024: 'SHORT',
   1025: 'SHORT',
+  1026: 'ASCII',
   2048: 'SHORT',
   2049: 'ASCII',
+  2052: 'SHORT',
+  2054: 'SHORT',
+  2060: 'SHORT',
   3072: 'SHORT',
   3073: 'ASCII',
+  3076: 'SHORT',
+  4096: 'SHORT',
+  4097: 'ASCII',
+  4099: 'SHORT',
   33432: 'ASCII',
   33550: 'DOUBLE',
   33922: 'DOUBLE',

src/utils.js

@@ -156,3 +156,41 @@ export class CustomAggregateError extends Error {
 }
 
 export const AggregateError = CustomAggregateError;
+
+export function isTypedFloatArray(input) {
+  if (ArrayBuffer.isView(input)) {
+    const ctr = input.constructor;
+    if (ctr === Float32Array || ctr === Float64Array) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function isTypedIntArray(input) {
+  if (ArrayBuffer.isView(input)) {
+    const ctr = input.constructor;
+    if (ctr === Int8Array || ctr === Int16Array || ctr === Int32Array) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function isTypedUintArray(input) {
+  if (ArrayBuffer.isView(input)) {
+    const ctr = input.constructor;
+    if (ctr === Uint8Array || ctr === Uint16Array || ctr === Uint32Array || ctr === Uint8ClampedArray) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export const typeMap = {
+  Float64Array,
+  Float32Array,
+  Uint32Array,
+  Uint16Array,
+  Uint8Array,
+};

test/geotiff.spec.js

@@ -78,6 +78,20 @@ function normalize(input) {
   return JSON.stringify(toArrayRecursively(input));
 }
 
+function generateTestDataArray(min, max, length, onlyWholeNumbers) {
+  const data = [];
+
+  for (let i = 0; i < length; i++) {
+    let randomValue = (Math.random() * (max - min + 1)) + min;
+    if (onlyWholeNumbers) {
+      randomValue = Math.floor(randomValue);
+    }
+    data.push(randomValue);
+  }
+
+  return data;
+}
+
 function getMockMetaData(height, width) {
   return {
     ImageWidth: width, // only necessary if values aren't multi-dimensional
@@ -103,6 +117,42 @@ function getMockMetaData(height, width) {
   };
 }
 
+describe('writeTypedArrays', () => {
+  const dataLength = 512 * 512 * 4;
+
+  const variousDataTypeExamples = [
+    generateTestDataArray(0, 255, dataLength, true),
+    new Uint8Array(generateTestDataArray(0, 255, dataLength, true)),
+    new Uint16Array(generateTestDataArray(0, 65535, dataLength, true)),
+    new Uint32Array(generateTestDataArray(0, 4294967295, dataLength, true)),
+    new Float32Array(generateTestDataArray(-3.4e+38, 3.4e+38, dataLength, false)),
+    new Float64Array(generateTestDataArray(Number.MIN_VALUE, Number.MAX_VALUE, dataLength, false)),
+  ];
+
+  const height = Math.sqrt(dataLength);
+  const width = Math.sqrt(dataLength);
+
+  for (let s = 0; s < variousDataTypeExamples.length; ++s) {
+    const originalValues = variousDataTypeExamples[s];
+    const dataType = originalValues.constructor.name;
+
+    it(`should write ${dataType}`, async () => {
+      const metadata = {
+        height,
+        width,
+      };
+
+      const newGeoTiffAsBinaryData = await writeArrayBuffer(originalValues, metadata);
+      const newGeoTiff = await fromArrayBuffer(newGeoTiffAsBinaryData);
+      const image = await newGeoTiff.getImage();
+      const newValues = await image.readRasters();
+      const valueArray = toArrayRecursively(newValues)[0];
+      const originalValueArray = Array.from(originalValues);
+      expect(valueArray).to.be.deep.equal(originalValueArray);
+    });
+  }
+});
+
 describe('GeoTIFF - external overviews', () => {
   it('Can load', async () => {
     const tiff = await fromUrls(
@@ -1112,7 +1162,10 @@ describe('writeTests', () => {
       [0, 0, 0],
       [255, 255, 255],
     ];
-    const originalValues = [originalRed, originalGreen, originalBlue];
+    const interleaved = originalRed.flatMap((row, rowIdx) => row.flatMap((value, colIdx) => [
+      value, originalGreen[rowIdx][colIdx], originalBlue[rowIdx][colIdx],
+    ]));
+    const originalValues = new Uint8Array(interleaved);
     const metadata = {
       height: 3,
       width: 3,