feat(writeLocalFileSync): Initial addition

Author: thewtex

doc/content/api/node_io.md

@@ -15,6 +15,18 @@ Read an image or mesh from a file on the local filesystem.
 
 Similar to `readLocalFile`, but returns the image or mesh directly instead of a promise.
 
+## writeLocalFile(useCompression, imageOrMesh, filePath) -> null
+
+Write an image to a file on the local filesystem with Node.js.
+
+*useCompression*: compress the pixel data when possible
+*imageOrMesh*:    [itk/Image](./Image.html) or [itk/Mesh](./Mesh.html) instance to write
+*filePath*:       path to the file on the local filesystem
+
+## writeFileSync(useCompression, image, filePath) -> null
+
+Similar to `writeImageLocalFile`, but synchronous.
+
 ---
 
 ## readImageLocalFile(filePath) -> [itk/Image](./Image.html)

src/writeLocalFileSync.js

@@ -0,0 +1,36 @@
+const path = require('path')
+
+const getFileExtension = require('./getFileExtension.js')
+const extensionToMeshIO = require('./extensionToMeshIO.js')
+
+const writeImageLocalFileSync = require('./writeImageLocalFileSync.js')
+const writeMeshLocalFileSync = require('./writeMeshLocalFileSync.js')
+
+/**
+ * Write an image or mesh to a file on the local filesystem in Node.js.
+ *
+ * @param: useCompression compression the pixel data when possible
+ * @param: imageOrMesh itk.Image or itk.Mesh instance to write
+ * @param: filePath path to the file on the local filesystem.
+ *
+ * @return empty Promise
+ */
+const writeLocalFileSync = (useCompression, imageOrMesh, filePath) => {
+  const absoluteFilePath = path.resolve(filePath)
+  const extension = getFileExtension(absoluteFilePath)
+
+  const isMesh = extensionToMeshIO.hasOwnProperty(extension)
+  if (isMesh) {
+    try {
+      writeMeshLocalFileSync(useCompression, imageOrMesh, filePath)
+      return
+    } catch (err) {
+      // Was a .vtk image file? Continue to write as an image.
+      writeImageLocalFileSync(useCompression, imageOrMesh, filePath)
+    }
+  } else {
+    writeImageLocalFileSync(useCompression, imageOrMesh, filePath)
+  }
+}
+
+module.exports = writeLocalFileSync

test/writeLocalFileSyncTest.js

@@ -0,0 +1,63 @@
+import test from 'ava'
+import path from 'path'
+
+const IntTypes = require(path.resolve(__dirname, '..', 'dist', 'IntTypes.js'))
+const FloatTypes = require(path.resolve(__dirname, '..', 'dist', 'FloatTypes.js'))
+const PixelTypes = require(path.resolve(__dirname, '..', 'dist', 'PixelTypes.js'))
+const readImageLocalFile = require(path.resolve(__dirname, '..', 'dist', 'readImageLocalFile.js'))
+const readMeshLocalFile = require(path.resolve(__dirname, '..', 'dist', 'readMeshLocalFile.js'))
+const writeLocalFileSync = require(path.resolve(__dirname, '..', 'dist', 'writeLocalFileSync.js'))
+
+const testImageInputFilePath = path.resolve(__dirname, '..', 'build', 'ExternalData', 'test', 'Input', 'cthead1.png')
+const testImageOutputFilePath = path.resolve(__dirname, '..', 'build', 'Testing', 'Temporary', 'writeLocalFileSyncTest-cthead1.png')
+const testMeshInputFilePath = path.resolve(__dirname, '..', 'build', 'ExternalData', 'test', 'Input', 'cow.vtk')
+const testMeshOutputFilePath = path.resolve(__dirname, '..', 'build', 'Testing', 'Temporary', 'writeLocalFileSyncTest-cow.vtk')
+
+const verifyImage = (t, image) => {
+  t.is(image.imageType.dimension, 2, 'dimension')
+  t.is(image.imageType.componentType, IntTypes.UInt8, 'componentType')
+  t.is(image.imageType.pixelType, PixelTypes.RGB, 'pixelType')
+  t.is(image.imageType.components, 3, 'components')
+  t.is(image.origin[0], 0.0, 'origin[0]')
+  t.is(image.origin[1], 0.0, 'origin[1]')
+  t.is(image.spacing[0], 1.0, 'spacing[0]')
+  t.is(image.spacing[1], 1.0, 'spacing[1]')
+  t.is(image.direction.getElement(0, 0), 1.0, 'direction (0, 0)')
+  t.is(image.direction.getElement(0, 1), 0.0, 'direction (0, 1)')
+  t.is(image.direction.getElement(1, 0), 0.0, 'direction (1, 0)')
+  t.is(image.direction.getElement(1, 1), 1.0, 'direction (1, 1)')
+  t.is(image.size[0], 256, 'size[0]')
+  t.is(image.size[1], 256, 'size[1]')
+  t.is(image.data.length, 196608, 'data.length')
+}
+
+test('writeLocalFileSync writes an image file path on the local filesystem', t => {
+  return readImageLocalFile(testImageInputFilePath)
+    .then(function (image) {
+      const useCompression = false
+      writeLocalFileSync(useCompression, image, testImageOutputFilePath)
+      return readImageLocalFile(testImageOutputFilePath).then(function (image) {
+        verifyImage(t, image)
+      })
+    })
+})
+
+const verifyMesh = (t, mesh) => {
+  t.is(mesh.meshType.dimension, 3)
+  t.is(mesh.meshType.pointComponentType, FloatTypes.Float32)
+  t.is(mesh.meshType.cellComponentType, IntTypes.UInt32)
+  t.is(mesh.meshType.pointPixelType, 1)
+  t.is(mesh.meshType.cellPixelType, 1)
+  t.is(mesh.numberOfPoints, 2903)
+  t.is(mesh.numberOfCells, 3263)
+}
+
+test('writeLocalFile writes a mesh file path on the local filesystem', (t) => {
+  return readMeshLocalFile(testMeshInputFilePath)
+    .then(function (mesh) {
+      writeLocalFileSync(false, mesh, testMeshOutputFilePath)
+      return readMeshLocalFile(testMeshOutputFilePath).then(function (mesh) {
+        verifyMesh(t, mesh)
+      })
+    })
+})