@ohos-ports/cornerstone-core 2.6.1-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Chris Hafey (chafey@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,230 @@
+<div align="center">
+<h1>cornerstone-core</h1>
+
+<p>Cornerstone.js delivers a complete web based medical imaging platform. This repository contains the Cornerstone.js "Core" component which is a lightweight JavaScript library for displaying medical images in modern web browsers that support the HTML5 canvas element.</p>
+
+[**Read The Docs**](https://docs.cornerstonejs.org/) | [Edit the docs](https://github.com/cornerstonejs/cornerstone/tree/master/docs)
+
+</div>
+
+<hr />
+
+<!-- prettier-ignore-start -->
+[![Coverage Status][coverage-image]][coverage-url]
+[![All Contributors](https://img.shields.io/badge/all_contributors-0-orange.svg?style=flat-square)](#contributors)
+
+[![NPM version][npm-version-image]][npm-url]
+[![NPM downloads][npm-downloads-image]][npm-url]
+[![MIT License][license-image]][license-url]
+<!-- prettier-ignore-end -->
+
+Cornerstone Core is not meant to be a complete application itself, but instead a component that can be used as part of larger more complex applications.  See the
+[OHIF Viewer](http://viewer.ohif.org/) for an example of using the various Cornerstone
+libraries to build a simple study viewer.
+
+Cornerstone Core is agnostic to the actual container used to store image pixels as well as the transport mechanism used to get the image data.  In fact, Cornerstone Core itself has no ability to read/parse or load images and instead depends on one or more [ImageLoaders](https://github.com/cornerstonejs/cornerstone/wiki/ImageLoader) to function.
+
+The goal here is to avoid constraining developers to work within a single container and transport (e.g. DICOM) since images are stored in a variety of formats (including proprietary).  By providing flexibility with respect to the container and transport, the highest performance image display may be obtained as no conversion to an alternate container or transport is required.  It is hoped that developers feel empowered to load images from any type of image container using any kind of transport.  See the [CornerstoneWADOImageLoader](https://github.com/cornerstonejs/cornerstoneWADOImageLoader) project for an example
+of a DICOM WADO based Image Loader.
+
+Cornerstone Core is agnostic to the exact interaction paradigm being used.  It does not include any mouse, touch or keyboard bindings to manipulate the various image properties such as scale, translation or ww/wc.  The goal here is to avoid constraining developers using this library to fit into a given ui paradigm.  It is hoped that developers are empowered to create new paradigms possibly using new input mechanisms to interact with medical images (e.g. [Kinect](http://en.wikipedia.org/wiki/Kinect) or [Accelerometer](http://en.wikipedia.org/wiki/Accelerometer)).
+Cornerstone does provide a set of API's allowing manipulation of the image properties via javascript. See the [CornerstoneTools](https://github.com/cornerstonejs/cornerstoneTools) library for an example of common tools built on top of Cornerstone.
+
+Community
+---------
+
+Have questions?  Try posting on our [google groups forum](https://groups.google.com/forum/#!forum/cornerstone-platform).
+
+Live Examples
+---------------
+The best way to see the power of this library is to actually see it in use.
+
+[Click here for a list of examples of using the Cornerstone library.](https://rawgit.com/cornerstonejs/cornerstone/master/example/index.html)
+
+Install
+-------
+
+Get a packaged source file:
+
+* [cornerstone.js](https://unpkg.com/cornerstone-core/dist/cornerstone.js)
+  * `https://unpkg.com/cornerstone-core/dist/cornerstone.js`
+* [cornerstone.min.js](https://unpkg.com/cornerstone-core/dist/cornerstone.min.js)
+  * `https://unpkg.com/cornerstone-core/dist/cornerstone.min.js`
+
+Or install via [NPM](https://www.npmjs.com/):
+
+**Latest stable release:**
+
+> npm install cornerstone-core
+
+**Pre-release, unstable, mostly for contributors:**
+
+> npm install cornerstone-core@next
+
+
+Key Features
+------------
+
+ * HTML5/Javascript based library to easily add interactive medical images to web applications
+ * Serves as a foundation to build more complex medical imaging applications from - enterprise viewer, report viewer, etc.
+ * Supports all HTML5 based browsers including mobile, tablet and desktop
+ * Displays all common medical image formats (e.g. 8 bit grayscale, 16 bit grayscale, RGB color)
+ * High performance image display
+ * Retrieval of images from different systems with different protocols via Image Loader plugin design
+ * API support for changing viewport properties (e.g. ww/wc, zoom, pan, invert)
+
+
+Links
+=====
+
+[Development Process](docs/developmentProcess.md)
+
+[Installation](docs/installation.md)
+
+[Developer Guide](docs/developer-guide.md)
+
+[View the wiki for documentation on the concepts and APIs](https://github.com/cornerstonejs/cornerstone/wiki)
+
+[View Roadmap](docs/roadmap.md)
+
+[View Backlog](docs/backlog.md)
+
+[2014 comp.protocols.dicom thread that started this project](https://groups.google.com/forum/#!topic/comp.protocols.dicom/_2fMh69GdAM)
+
+[CornerstoneTools](https://github.com/cornerstonejs/cornerstoneTools) - A library of common tools that can be used with Cornerstone
+
+[CornerstoneWADOImageLoader](https://github.com/cornerstonejs/cornerstoneWADOImageLoader) - A Cornerstone Image Loader that works with WADO-URI, WADO-RS and DICOM P10 files
+
+[CornerstoneWebImageLoader](https://github.com/cornerstonejs/cornerstoneWebImageLoader) - A Cornerstone Image Loader that works with PNG and JPEG files
+
+[dicomParser](https://github.com/cornerstonejs/dicomParser) - A JavaScript library designed to parse DICOM for web browsers
+
+Code Contributors
+=================
+
+I welcome pull requests, please see FAQ below for guidance on this.
+
+* @simonmd - CSS improvements in the cornerstoneDemo application
+* @doncharkowsky - The angle tool in cornerstoneTools
+* @prasath-rasterimages - Touch event bindings in cornerstoneTools
+* @jpamburn - Performance optimizations for signed data, fixes for image caching
+* @jmhmd - for getPixels() implementation
+* @devishree-raster - for flip and rotate implementation
+
+FAQ
+===
+
+_Why did you decide to license this library using the open source MIT license?_
+
+The main reason this library is released as [open source](http://en.wikipedia.org/wiki/Open_source) is
+that I believe that medical imaging in particular can do a lot more to improve patient outcomes
+but the cost of doing so is prohibitive.  Making this library open source removes the cost barrier and will
+hopefully usher in a new set of medical imaging based applications.
+
+The old adage [a picture is worth a thousand words](http://en.wikipedia.org/wiki/A_picture_is_worth_a_thousand_words)
+is very true in medical imaging.  When a patient is going through a disease process, they often face fear
+and confusion.  Medical terminology amplifies these issues as it is hard to understand and therefore
+disempowering.  Medical imaging allows a mysterious health issue to be visualized and therefore brings a
+level of understanding that just can't be accomplished via textual information found in lab or radiology
+reports.  By helping a patient (and its supporting friends/family) connect with the disease visually through images, it is believed that fear, anxiety and confusion will all be reduced which
+will increase optimism and therefore patient outcomes.
+
+It is my hope that this library be used to build a variety of applications and experiences
+to deliver on this vision.  The MIT license allows this library to be used in any type of application - personal, open source and commercial and is therefore appropriate to support this vision.  If you are reading this, I hope you can join me in this mission as there is still a lot to be done.
+
+_Why doesn't Cornerstone natively support the display of DICOM images?_
+
+While DICOM has support for just about every type of medical image, there are many cases where medical images
+are not stored in DICOM format.  In many cases, a PACS may receive DICOM images but store them in a proprietary
+format on disk.  In this case, it can be faster to access images by having an image loader that works with
+a proprietary PACS interface that would not require conversion from the proprietary format into a standard format
+like DICOM.  Another example of this is is dermatology where images are often taken using standard
+digital cameras and are stored as JPEG not DICOM.
+
+The main reason this library is not based around DICOM is that it wants to reach the widest possible adoption
+and that will be accomplished by supporting as many types of image containers and transports possible.
+Another side effect of this approach is that the code base is smaller and easier to understand since
+it is focused on doing exactly one thing.  That being said, it is is expected that the majority of images
+displayed using this library will have originated as DICOM images.  It is therefore important to make sure
+that there are no limitations with respect to displaying the different types of DICOM images and have robust supporting libraries for DICOM.  Separate libraries to add DICOM specific support already exist, check out the [CornerstoneWADOImageLoader](https://github.com/cornerstonejs/cornerstoneWADOImageLoader) library and the [dicomParser](https://github.com/cornerstonejs/dicomParser) library.
+
+_Why doesn't Cornerstone include basic tools like ww/wc using the mouse?_
+
+There is no standard for user interaction in medical imaging and a wide variety of interaction paradigms exist.
+For example, one medical imaging application may use the left mouse button to adjust ww/wc and another may use the right mouse button.  The main reason this library does not include tools is that it wants to reach the widest possible adoption and that will only be accomplished by making any interaction paradigm possible.  No tools are therefore provided with this library allowing users of the library to choose
+whatever interaction paradigm they like.  It is also hoped that this approach will make it easier for developers to experiment with new user input mechanisms like [Kinect](http://en.wikipedia.org/wiki/Kinect) or [Accelerometer](http://en.wikipedia.org/wiki/Accelerometer).  Another side effect of this
+approach is that the code base is smaller and easier to understand since it is focused on doing exactly one
+thing.  Tools are provided using the separate [CornerstoneTools](https://github.com/cornerstonejs/cornerstoneTools) if desired.
+
+_Why doesn't this library support older browsers like IE8?_
+
+Much of the performance in this library is possible due to utilizing modern web features such as HTML5 canvas,
+high performance javascript engines and WebGL.  These feature are not avaialble in IE8 and there are no suitable
+polyfills available.  Sorry, upgrade your browser.
+
+_Why doesn't this library support stacks of images?_
+
+Images stack functionality such as a CT series or MRI series can actually be quite complex.  Regardless of
+what stack functionality is desired, all stacks ultimately need to be able to display a single image and that is what this library is focused on doing.  Stack functionality is therefore pushed up to a higher layer.  The [CornerstoneTools](https://github.com/cornerstonejs/cornerstoneTools) contains stack functionality and is a good place to look to see how various stack related functionality is implemented.
+
+_How do you envision this library supporting 3D functionality such as MPR, MIP and VR?_
+
+This library would be responsible for displaying the rendered image to the user.  The rendering of the 3D image would be done by some other library - perhaps on the server side.  This library is purely 2D and has no knowledge of 3D image space.  It will probably make sense to have several layers on top of this library to provide 3D functionality.  For example, one layer that has a 3D viewport with properties such as transformation matrix, slice thickness, transfer function/LUT, segmentation masks, etc.  And another 3D tools layer that provides various tools on top of the 3d viewport (rotate, zoom, segment, scroll, etc).
+
+OHIF/Cornerstone is working with the 3DSlicer project to integrate the two.  I also expect to implement
+client side MPR at some point as the browsers seem to be handling large memory much better.
+
+_I would like to contribute code - how do I do this?_
+
+Fork the repository, make your change and submit a pull request.
+
+_Any guidance on submitting changes?_
+
+While I do appreciate code contributions, I will not merge it unless it meets the following criteria:
+
+* Functionality is appropriate for the repository.  Consider posting on the forum if you are not sure
+* Code quality is acceptable.  I don't have coding standards defined, but make sure it passes ESLint and looks like the rest of the code in the repository.
+* Quality of design is acceptable.  This is a bit subjective so you should consider posting on the forum for specific guidance
+
+I will provide feedback on your pull request if it fails to meet any of the above.
+
+Please consider separate pull requests for each feature as big pull requests are very time consuming to understand.
+It is highly probably that I will reject a large pull request due to the time it would take to comprehend.
+
+_Will you add feature XYZ for me?_
+
+If it is in the roadmap, I intend to implement it some day - probably when I actually need it.  If you really need something now and are willing to pay for it, try posting on the cornerstone platform google group
+
+Research notice
+~~~~~~~~~~~~~~~
+
+Please note that this repository is participating in a study into
+sustainability of open source projects. Data will be gathered about this
+repository for approximately the next 12 months, starting from June
+2021.
+
+Data collected will include number of contributors, number of PRs, time
+taken to close/merge these PRs, and issues closed.
+
+For more information, please visit `the informational
+page <https://sustainable-open-science-and-software.github.io/>`__ or
+download the `participant information
+sheet <https://sustainable-open-science-and-software.github.io/assets/PIS_sustainable_software.pdf>`__.
+
+Copyright
+=========
+
+Copyright 2017 Chris Hafey [chafey@gmail.com](mailto:chafey@gmail.com)
+
+[license-image]: http://img.shields.io/badge/license-MIT-blue.svg?style=flat
+[license-url]: LICENSE
+
+[npm-url]: https://npmjs.org/package/cornerstone-core
+[npm-version-image]: http://img.shields.io/npm/v/cornerstone-core.svg?style=flat
+[npm-downloads-image]: http://img.shields.io/npm/dm/cornerstone-core.svg?style=flat
+
+[travis-url]: http://travis-ci.org/cornerstonejs/cornerstone
+[travis-image]: https://travis-ci.org/cornerstonejs/cornerstone.svg?branch=master
+
+[coverage-url]: https://coveralls.io/github/cornerstonejs/cornerstone?branch=master
+[coverage-image]: https://coveralls.io/repos/github/cornerstonejs/cornerstone/badge.svg?branch=master

package/dist/cornerstone-node-bootstrap.js

@@ -0,0 +1,264 @@
+/**
+ * Node.js / HarmonyOS bootstrap shim for cornerstone-core.
+ *
+ * cornerstone-core is a browser-only UMD library: its UMD wrapper evaluates
+ * `window` at load time, and its rendering pipeline needs DOM + canvas.
+ *
+ * This shim bootstraps a jsdom DOM environment (with real canvas 2D support
+ * provided by the `canvas` package, aliased to the HarmonyOS prebuilt
+ * `@ohos-ports/canvas`) so that the UMD bundle can be required from Node.js
+ * on HarmonyOS and canvas-based APIs can operate for real.
+ *
+ * WebGL IS available: since round 2 the optional native dependency
+ * `@ohos-ports/gl` (headless-gl HarmonyOS port, natively compiled via
+ * node-gyp against the OHOS EGL/GLES stack) provides real WebGL 1 contexts
+ * in Node.js. jsdom's HTMLCanvasElement#getContext is hooked so that
+ * 'webgl' / 'experimental-webgl' requests return a real headless-gl context,
+ * and each frame's framebuffer is copied back into the canvas backing
+ * surface so ctx2d.drawImage(webglCanvas) composites real pixels.
+ */
+"use strict";
+
+if (typeof window !== "undefined") {
+  // Already in a browser-like environment; nothing to do.
+  module.exports = window;
+} else {
+  const { JSDOM } = require("jsdom");
+
+  const dom = new JSDOM("<!DOCTYPE html><html><body></body></html>", {
+    pretendToBeVisual: true,
+    url: "http://localhost/",
+  });
+  const win = dom.window;
+
+  // Expose the DOM environment as globals so that the UMD bundle's bare
+  // `window` / `document` / `navigator` references resolve inside Node.js.
+  // Some globals (e.g. navigator in Node >= 21) are getter-only, so use
+  // defineProperty and ignore failures for those already provided by Node.
+  const defineGlobal = (name, value) => {
+    try {
+      Object.defineProperty(globalThis, name, {
+        value,
+        writable: true,
+        configurable: true,
+        enumerable: false,
+      });
+    } catch (e) {
+      // Keep the Node-provided global if it cannot be redefined.
+    }
+  };
+
+  defineGlobal("window", win);
+  defineGlobal("document", win.document);
+  defineGlobal("navigator", win.navigator);
+  defineGlobal("location", win.location);
+  defineGlobal("Image", win.Image);
+  defineGlobal("HTMLElement", win.HTMLElement);
+  defineGlobal("HTMLCanvasElement", win.HTMLCanvasElement);
+  defineGlobal("XMLHttpRequest", win.XMLHttpRequest);
+  // Event classes must come from the jsdom realm: cornerstone creates events
+  // with `new CustomEvent(...)` and dispatches them on jsdom elements, which
+  // reject cross-realm (Node-built) events.
+  defineGlobal("CustomEvent", win.CustomEvent);
+  defineGlobal("Event", win.Event);
+  defineGlobal("getComputedStyle", win.getComputedStyle.bind(win));
+  defineGlobal("requestAnimationFrame", win.requestAnimationFrame.bind(win));
+  defineGlobal("cancelAnimationFrame", win.cancelAnimationFrame.bind(win));
+
+  // --- WebGL support via @ohos-ports/gl (headless-gl HarmonyOS port) ---
+  // headless-gl creates a REAL, natively compiled WebGL 1 context without a
+  // window (EGL/GLES on HarmonyOS). We hook jsdom's HTMLCanvasElement so
+  // canvas.getContext('webgl' / 'experimental-webgl') returns a headless-gl
+  // context sized to the canvas. Because a headless-gl context has no browser
+  // compositing step, the GL framebuffer is copied back into the jsdom
+  // canvas' 2D backing surface after every drawArrays() call, so
+  // ctx2d.drawImage(webglCanvas) composites real pixels (equivalent to
+  // preserveDrawingBuffer behaviour in a browser).
+  try {
+    const createGL = require("@ohos-ports/gl");
+    const idlUtils = require("jsdom/lib/generated/idl/utils");
+
+    const glStates = new WeakMap();
+
+    function syncFramebufferToCanvas(state) {
+      try {
+        const { gl, w, h, impl } = state;
+        if (!gl || !w || !h) {
+          return;
+        }
+        const buf = new Uint8Array(w * h * 4);
+        gl.readPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, buf);
+        // GL framebuffers are bottom-up; flip rows for the 2D surface and
+        // force opaque alpha so drawImage compositing is not transparent.
+        const flipped = new Uint8Array(w * h * 4);
+        const row = w * 4;
+        for (let y = 0; y < h; y++) {
+          flipped.set(buf.subarray((h - 1 - y) * row, (h - y) * row), y * row);
+          for (let x = 3; x < row; x += 4) {
+            flipped[y * row + x] = 255;
+          }
+        }
+        const c2d = impl._getCanvas().getContext("2d");
+        const img = c2d.createImageData(w, h);
+        img.data.set(flipped);
+        c2d.putImageData(img, 0, 0);
+      } catch (e) {
+        // Never break the GL draw loop because of a copy-back failure.
+      }
+    }
+
+    function makeHandler(state) {
+      return {
+        get(target, prop) {
+          if (prop === "canvas") {
+            return state.canvas;
+          }
+          if (prop === "drawingBufferWidth") {
+            return state.w;
+          }
+          if (prop === "drawingBufferHeight") {
+            return state.h;
+          }
+          if (prop === "__cornerstoneGLState") {
+            return state;
+          }
+          // After each real GL draw, copy the framebuffer into the jsdom
+          // canvas backing surface so drawImage() composites real pixels.
+          if (prop === "drawArrays") {
+            return function (mode, first, count) {
+              const r = state.gl.drawArrays(mode, first, count);
+              syncFramebufferToCanvas(state);
+              return r;
+            };
+          }
+          // OHOS ANGLE GLES driver: 'precision mediump float' is broken for
+          // the 65536-scale arithmetic cornerstone's int16/uint16 shaders
+          // rely on (decoded values collapse). Upgrade fragment shaders to
+          // highp, which works on this driver.
+          if (prop === "shaderSource") {
+            return function (shader, src) {
+              if (typeof src === "string") {
+                src = src.replace(
+                  /^precision\s+mediump\s+float\s*;/,
+                  "precision highp float;"
+                );
+              }
+              return state.gl.shaderSource(shader, src);
+            };
+          }
+          const v = state.gl[prop];
+          return typeof v === "function" ? v.bind(state.gl) : v;
+        },
+        has(target, prop) {
+          return prop in state.gl || prop === "canvas";
+        },
+      };
+    }
+
+    function resizeIfNeeded(state) {
+      const canvas = state.canvas;
+      const w = canvas.width;
+      const h = canvas.height;
+      if (!w || !h || (w === state.w && h === state.h)) {
+        return;
+      }
+      state.w = w;
+      state.h = h;
+      let newGl = null;
+      try {
+        newGl = createGL(w, h);
+      } catch (e) {
+        return;
+      }
+      if (!newGl) {
+        return;
+      }
+      state.gl = newGl;
+      // Mimic the browser context-lost/restored cycle so cornerstone purges
+      // its texture/program caches and re-initializes on the new GL context.
+      state.canvas.dispatchEvent(
+        new win.Event("webglcontextlost", { cancelable: true })
+      );
+      state.canvas.dispatchEvent(new win.Event("webglcontextrestored"));
+    }
+
+    function watchResize(state) {
+      const canvas = state.canvas;
+      const proto = Object.getPrototypeOf(canvas);
+      for (const dim of ["width", "height"]) {
+        const d = Object.getOwnPropertyDescriptor(proto, dim);
+        if (!d || typeof d.set !== "function") {
+          continue;
+        }
+        Object.defineProperty(canvas, dim, {
+          get() {
+            return d.get.call(canvas);
+          },
+          set(v) {
+            d.set.call(canvas, v);
+            try {
+              resizeIfNeeded(state);
+            } catch (e) {
+              // ignore resize handling errors
+            }
+          },
+          configurable: true,
+          enumerable: d.enumerable,
+        });
+      }
+    }
+
+    function getOrCreateWebGLContext(canvasWrapper, options) {
+      let state = glStates.get(canvasWrapper);
+      if (state) {
+        return state.wrapper;
+      }
+      const impl = idlUtils.implForWrapper(canvasWrapper);
+      if (!impl || !impl._getCanvas()) {
+        return null;
+      }
+      const w = canvasWrapper.width || 300;
+      const h = canvasWrapper.height || 150;
+      let gl = null;
+      try {
+        gl = createGL(w, h);
+      } catch (e) {
+        return null;
+      }
+      if (!gl) {
+        return null;
+      }
+      state = { gl, w, h, impl, canvas: canvasWrapper };
+      state.wrapper = new Proxy({}, makeHandler(state));
+      glStates.set(canvasWrapper, state);
+      watchResize(state);
+      return state.wrapper;
+    }
+
+    const origGetContext = win.HTMLCanvasElement.prototype.getContext;
+    win.HTMLCanvasElement.prototype.getContext = function (contextId) {
+      const t = String(contextId).toLowerCase();
+      if (t === "webgl" || t === "experimental-webgl") {
+        return getOrCreateWebGLContext(this, arguments[1]);
+      }
+      return origGetContext.apply(this, arguments);
+    };
+
+    // Expose on both the Node global (bare `WebGLRenderingContext`
+    // references) and the jsdom window (cornerstone checks
+    // `window.WebGLRenderingContext` in isWebGLAvailable()).
+    defineGlobal("WebGLRenderingContext", createGL.WebGLRenderingContext);
+    try {
+      win.WebGLRenderingContext = createGL.WebGLRenderingContext;
+    } catch (e2) {
+      // ignore
+    }
+
+    win.__cornerstoneWebGLSource = "@ohos-ports/gl";
+  } catch (e) {
+    // @ohos-ports/gl unavailable or failed to load: WebGL stays unavailable
+    // and canvas2D rendering continues to work.
+  }
+
+  module.exports = win;
+}