volview 4.0.0 → 4.0.1

package/src/io/io.ts

@@ -1,157 +0,0 @@
-import { extensionToImageIO } from 'itk-wasm';
-import { extractFilesFromZip } from './zip';
-import { FileEntry } from './types';
-
-export const ARCHIVE_FILE_TYPES = new Set(['zip', 'application/zip']);
-
-export const ITK_IMAGE_EXTENSIONS = Array.from(
-  new Set(Array.from(extensionToImageIO.keys()).map((ext) => ext.toLowerCase()))
-);
-
-// remove duplicates
-export const FILE_TYPES = Array.from(
-  new Set(['vti', 'vtp', 'stl', 'dcm', 'zip', 'json', ...ITK_IMAGE_EXTENSIONS])
-);
-
-/**
- * file magic database
- * Used to handle certain cases where files have no extension
- */
-const FILE_MAGIC_DB = [
-  {
-    type: 'dcm',
-    skip: 128,
-    header: Array.from('DICM').map((c) => c.charCodeAt(0)),
-  },
-];
-
-// How much data to read when extracting file magic.
-// This should be generous enough for most files.
-const HEAD_CHUNK = 512;
-
-function prefixEquals(target: Uint8Array, prefix: number[] | Uint8Array) {
-  if (prefix.length > target.length) {
-    return false;
-  }
-  for (let i = 0; i < prefix.length; i += 1) {
-    if (prefix[i] !== target[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-async function getFileTypeFromMagic(file: File): Promise<string | null> {
-  return new Promise((resolve) => {
-    const head = file.slice(0, HEAD_CHUNK);
-    const reader = new FileReader();
-    reader.onload = () => {
-      const chunk = new Uint8Array(reader.result! as ArrayBuffer);
-      for (let i = 0; i < FILE_MAGIC_DB.length; i += 1) {
-        const { type, header, skip = 0 } = FILE_MAGIC_DB[i];
-        if (prefixEquals(chunk.slice(skip), header)) {
-          resolve(type);
-          return;
-        }
-      }
-      resolve(null);
-    };
-    reader.readAsArrayBuffer(head);
-  });
-}
-
-/**
- * Retypes a given File.
- *
- * Handy for when a file object has no type given.
- * Type is inferred from extension or magic.
- *
- * If type is not supported, file.type will be "".
- * @param file
- */
-export async function retypeFile(file: File): Promise<File> {
-  let type: string | null;
-
-  type =
-    FILE_TYPES.find((ext) => file.name.toLowerCase().endsWith(`.${ext}`)) ??
-    null;
-
-  if (!type) {
-    type = await getFileTypeFromMagic(file);
-  }
-
-  if (!type) {
-    type = '';
-  }
-
-  const retypedFile = new File([file], file.name, { type: type.toLowerCase() });
-  return retypedFile;
-}
-
-export async function extractArchivesRecursively(
-  files: File[]
-): Promise<FileEntry[]> {
-  const results = await Promise.all(
-    files.map(async (file) => {
-      if (ARCHIVE_FILE_TYPES.has(file.type)) {
-        return extractFilesFromZip(file);
-      }
-
-      return [{ file, path: '' }];
-    })
-  );
-
-  const archivedEntries = await Promise.all(
-    results.flat().map(async (entry) => {
-      return { file: await retypeFile(entry.file), path: entry.path };
-    })
-  );
-
-  const archives = archivedEntries
-    .filter(({ file }) => ARCHIVE_FILE_TYPES.has(file.type))
-    .map(({ file }) => file);
-
-  if (archives.length > 0) {
-    const moreEntries = await extractArchivesRecursively(archives);
-    return [...archivedEntries, ...moreEntries];
-  }
-
-  return archivedEntries;
-}
-
-export type ReadAsType = 'ArrayBuffer' | 'Text';
-
-async function readFileAs<T extends ArrayBuffer | string>(
-  file: File,
-  type: ReadAsType
-): Promise<T> {
-  return new Promise((resolve) => {
-    const fio = new globalThis.FileReader();
-    fio.onload = () => resolve(fio.result as T);
-    if (type === 'ArrayBuffer') {
-      fio.readAsArrayBuffer(file);
-    } else if (type === 'Text') {
-      fio.readAsText(file);
-    } else {
-      throw new TypeError(`readAs${type} is not a function`);
-    }
-  });
-}
-
-/**
- * Reads a file and returns an ArrayBuffer
- * @async
- * @param {File} file
- */
-export async function readFileAsArrayBuffer(file: File) {
-  return readFileAs<ArrayBuffer>(file, 'ArrayBuffer');
-}
-
-/**
- * Reads a file and returns UTF-8 text
- * @async
- * @param {File} file
- */
-export async function readFileAsUTF8Text(file: File) {
-  return readFileAs<string>(file, 'Text');
-}

package/src/io/itk/itkConfig.js

@@ -1,8 +0,0 @@
-const itkConfig = {
-  pipelineWorkerUrl: '/itk/web-workers/min-bundles/pipeline.worker.js',
-  imageIOUrl: '/itk/image-io',
-  meshIOUrl: '/itk/mesh-io',
-  pipelinesUrl: '/itk/pipelines',
-};
-
-export default itkConfig;

package/src/io/itk-dicom/dicom.cpp

@@ -1,327 +0,0 @@
-#include <cerrno>
-#include <cstdio>
-#include <dirent.h>
-#include <fstream>
-#include <iostream>
-#include <stdexcept>
-#include <string>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#ifdef WEB_BUILD
-// Building with the itk.js docker container has a more recent gcc version
-#include <filesystem>
-namespace fs = std::filesystem;
-#else
-// Building locally with gcc 7.5.0 means I need -lstdc++fs and
-// experimental/filesystem
-#include <experimental/filesystem>
-namespace fs = std::experimental::filesystem;
-#endif
-
-#ifdef WEB_BUILD
-#include <emscripten.h>
-#endif
-
-#include <fstream>
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-#include "itkCastImageFilter.h"
-#include "itkGDCMImageIO.h"
-#include "itkGDCMSeriesFileNames.h"
-#include "itkImage.h"
-#include "itkImageFileReader.h"
-#include "itkImageIOBase.h"
-#include "itkImageSeriesReader.h"
-#include "itkRescaleIntensityImageFilter.h"
-#include "itkVectorImage.h"
-
-#include "itkOutputImage.h"
-#include "itkOutputTextStream.h"
-#include "itkPipeline.h"
-
-#include "gdcmImageHelper.h"
-#include "gdcmReader.h"
-
-using json = nlohmann::json;
-using ImageType = itk::Image<float, 3>;
-using ReaderType = itk::ImageFileReader<ImageType>;
-using SeriesReaderType = itk::ImageSeriesReader<ImageType>;
-using FileNamesContainer = std::vector<std::string>;
-using DicomIO = itk::GDCMImageIO;
-// volumeID -> filenames[]
-using VolumeMapType = std::unordered_map<std::string, std::vector<std::string>>;
-// VolumeID[]
-using VolumeIDList = std::vector<std::string>;
-
-static const double EPSILON = 10e-5;
-
-#ifdef WEB_BUILD
-extern "C" const char *EMSCRIPTEN_KEEPALIVE unpack_error_what(intptr_t ptr) {
-  auto error = reinterpret_cast<std::runtime_error *>(ptr);
-  return error->what();
-}
-#endif
-
-void replaceChars(std::string &str, char search, char replaceChar) {
-  int pos;
-  std::string replace(1, replaceChar);
-  while ((pos = str.find(search)) != std::string::npos) {
-    str.replace(pos, 1, replace);
-  }
-}
-
-// doesn't actually do any length checks, or overflow checks, or anything
-// really.
-template <int N>
-double dotProduct(const std::vector<double> &vec1,
-                  const std::vector<double> &vec2) {
-  double result = 0;
-  for (int i = 0; i < N; i++) {
-    result += vec1.at(i) * vec2.at(i);
-  }
-  return result;
-}
-
-std::vector<double> ReadImageOrientationValue(const std::string &filename) {
-  gdcm::Reader reader;
-  reader.SetFileName(filename.c_str());
-  if (!reader.Read()) {
-    throw std::runtime_error("gdcm: failed to read file");
-  }
-  const gdcm::File &file = reader.GetFile();
-  // This helper method asserts that the vector has length 6.
-  return gdcm::ImageHelper::GetDirectionCosinesValue(file);
-}
-
-bool areCosinesAlmostEqual(std::vector<double> cosines1,
-                           std::vector<double> cosines2,
-                           double epsilon = EPSILON) {
-  for (int i = 0; i <= 1; i++) {
-    std::vector<double> vec1{cosines1.at(i), cosines1.at(i + 1),
-                             cosines1.at(i + 2)};
-    std::vector<double> vec2{cosines2.at(i), cosines2.at(i + 1),
-                             cosines2.at(i + 2)};
-    double dot = dotProduct<3>(vec1, vec2);
-    if (dot < (1 - EPSILON)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-VolumeMapType SeparateOnImageOrientation(const VolumeMapType &volumeMap) {
-  VolumeMapType newVolumeMap;
-  // Vector< Pair< cosines, volumeID >>
-  std::vector<std::pair<std::vector<double>, std::string>> cosinesToID;
-
-  // append unique ID part to the volume ID, based on cosines
-  // The format replaces non-alphanumeric chars to be semi-consistent with DICOM
-  // UID spec,
-  //   and to make debugging easier when looking at the full volume IDs.
-  // Format: COSINE || "S" || COSINE || "S" || ...
-  //   COSINE: A decimal number -DD.DDDD gets reformatted into NDDSDDDD
-  auto encodeCosinesAsIDPart = [](const std::vector<double> &cosines) {
-    std::string concatenated;
-    for (auto it = cosines.begin(); it != cosines.end(); ++it) {
-      concatenated += std::to_string(*it);
-      if (it != cosines.end() - 1) {
-        concatenated += 'S';
-      }
-    }
-
-    replaceChars(concatenated, '-', 'N');
-    replaceChars(concatenated, '.', 'D');
-
-    return concatenated;
-  };
-
-  for (const auto &[volumeID, names] : volumeMap) {
-    for (const auto &filename : names) {
-      std::vector<double> curCosines = ReadImageOrientationValue(filename);
-
-      bool inserted = false;
-      for (const auto &entry : cosinesToID) {
-        if (areCosinesAlmostEqual(curCosines, entry.first)) {
-          newVolumeMap[entry.second].push_back(filename);
-          inserted = true;
-          break;
-        }
-      }
-
-      if (!inserted) {
-        const auto encodedIDPart = encodeCosinesAsIDPart(curCosines);
-        auto newID = volumeID + '.' + encodedIDPart;
-        newVolumeMap[newID].push_back(filename);
-        cosinesToID.push_back(std::make_pair(curCosines, newID));
-      }
-    }
-  }
-
-  return newVolumeMap;
-}
-
-/**
- * categorizeFiles extracts out the volumes contained within a set of DICOM
- * files.
- *
- * Return a mapping of volume ID to the files containing the volume.
- */
-int categorizeFiles(itk::wasm::Pipeline &pipeline) {
-
-  // inputs
-  FileNamesContainer files;
-  pipeline.add_option("-f,--files", files, "File names to categorize")
-      ->required()
-      ->check(CLI::ExistingFile)
-      ->expected(1, -1);
-
-  // outputs
-  itk::wasm::OutputTextStream volumeMapJSONStream;
-  pipeline
-      .add_option("volumeMap", volumeMapJSONStream,
-                  "JSON object encoding volumeID => filenames.")
-      ->required();
-
-  ITK_WASM_PARSE(pipeline);
-
-  std::string path = "./";
-
-  // parse out series
-  typedef itk::GDCMSeriesFileNames SeriesFileNames;
-  SeriesFileNames::Pointer seriesFileNames = SeriesFileNames::New();
-  // files are all default dumped to cwd
-  seriesFileNames->SetDirectory(path);
-  seriesFileNames->SetUseSeriesDetails(true);
-  seriesFileNames->SetGlobalWarningDisplay(false);
-  seriesFileNames->AddSeriesRestriction("0008|0021");
-  seriesFileNames->SetRecursive(false);
-  // Does this affect series organization?
-  seriesFileNames->SetLoadPrivateTags(false);
-
-  // Obtain the initial separation of imported files into distinct volumes.
-  auto &gdcmSeriesUIDs = seriesFileNames->GetSeriesUIDs();
-
-  // The initial series UIDs are used as the basis for our volume IDs.
-  VolumeMapType volumeMap;
-  for (auto seriesUID : gdcmSeriesUIDs) {
-    volumeMap[seriesUID] = seriesFileNames->GetFileNames(seriesUID.c_str());
-  }
-
-  // further restrict on orientation
-  volumeMap = SeparateOnImageOrientation(volumeMap);
-
-  // strip off tmp prefix
-  for (auto &entry : volumeMap) {
-    auto &fileNames = entry.second;
-    for (auto &f : fileNames) {
-      f = f.substr(path.size());
-    }
-  }
-
-  // Generate the JSON and add to output stream
-  auto volumeMapJSON = json(volumeMap);
-  volumeMapJSONStream.Get() << volumeMapJSON;
-
-  // Clean up files
-  for (auto &file : files) {
-    remove(file.c_str());
-  }
-
-  return EXIT_SUCCESS;
-}
-
-/**
- * Reads an image slice and returns the optionally thumbnailed image.
- */
-int getSliceImage(itk::wasm::Pipeline &pipeline) {
-
-  // inputs
-  std::string fileName;
-  pipeline.add_option("-f,--file", fileName, "File name generate image for")
-      ->required()
-      ->check(CLI::ExistingFile)
-      ->expected(1);
-
-  bool asThumbnail = false;
-  pipeline.add_option("-t,--thumbnail", asThumbnail,
-                      "Generate thumbnail image");
-
-  ITK_WASM_PRE_PARSE(pipeline);
-
-  // Setup reader
-  typename DicomIO::Pointer dicomIO = DicomIO::New();
-  dicomIO->LoadPrivateTagsOff();
-  typename ReaderType::Pointer reader = ReaderType::New();
-  reader->SetFileName(fileName);
-
-  if (asThumbnail) {
-    using InputImageType = ImageType;
-    using OutputPixelType = uint8_t;
-    using OutputImageType = itk::Image<OutputPixelType, 3>;
-    using RescaleFilter =
-        itk::RescaleIntensityImageFilter<InputImageType, InputImageType>;
-    using CastImageFilter =
-        itk::CastImageFilter<InputImageType, OutputImageType>;
-
-    // outputs
-    using WasmOutputImageType = itk::wasm::OutputImage<OutputImageType>;
-    WasmOutputImageType outputImage;
-    pipeline.add_option("OutputImage", outputImage, "The slice")->required();
-
-    ITK_WASM_PARSE(pipeline);
-
-    auto rescaleFilter = RescaleFilter::New();
-    rescaleFilter->SetInput(reader->GetOutput());
-    rescaleFilter->SetOutputMinimum(0);
-    rescaleFilter->SetOutputMaximum(itk::NumericTraits<OutputPixelType>::max());
-
-    auto castFilter = CastImageFilter::New();
-    castFilter->SetInput(rescaleFilter->GetOutput());
-    castFilter->Update();
-
-    // Set the output image
-    outputImage.Set(castFilter->GetOutput());
-  } else {
-    // outputs
-    using WasmOutputImageType = itk::wasm::OutputImage<ImageType>;
-    WasmOutputImageType outputImage;
-    pipeline.add_option("OutputImage", outputImage, "The slice")->required();
-
-    ITK_WASM_PARSE(pipeline);
-
-    reader->Update();
-    outputImage.Set(reader->GetOutput());
-  }
-
-  // Clean up the file
-  remove(fileName.c_str());
-
-  return EXIT_SUCCESS;
-}
-
-int main(int argc, char *argv[]) {
-  std::string action;
-  itk::wasm::Pipeline pipeline("VolView pipeline to access DICOM data", argc,
-                               argv);
-  pipeline.add_option("-a,--action", action, "The action to run")
-      ->check(CLI::IsMember({"categorize", "getSliceImage"}));
-
-  // Pre parse so we can get the action
-  ITK_WASM_PRE_PARSE(pipeline)
-
-  if (action == "categorize") {
-
-    ITK_WASM_CATCH_EXCEPTION(pipeline, categorizeFiles(pipeline));
-
-  } else if (action == "getSliceImage") {
-
-    ITK_WASM_CATCH_EXCEPTION(pipeline, getSliceImage(pipeline));
-  }
-
-  return EXIT_SUCCESS;
-}