@kitware/vtk.js 31.1.0 → 31.2.0

package/Rendering/Core/Mapper/CoincidentTopologyHelper.d.ts

@@ -0,0 +1,194 @@
+export interface ICoincidentTopology {
+  factor: number;
+  offset: number;
+}
+
+export enum Resolve {
+  Off,
+  PolygonOffset,
+}
+
+export interface StaticCoincidentTopologyMethods {
+  /**
+   *
+   * @param {ICoincidentTopology} params
+   */
+  setResolveCoincidentTopologyPolygonOffsetParameters(
+    params: ICoincidentTopology
+  ): boolean;
+
+  /**
+   *
+   * @param {ICoincidentTopology} params
+   */
+  setResolveCoincidentTopologyLineOffsetParameters(
+    params: ICoincidentTopology
+  ): boolean;
+
+  /**
+   *
+   * @param {ICoincidentTopology} params
+   */
+  setResolveCoincidentTopologyPointOffsetParameters(
+    params: ICoincidentTopology
+  ): boolean;
+
+  /**
+   *
+   * @param {Number} factor
+   * @param {Number} offset
+   */
+  setResolveCoincidentTopologyPolygonOffsetParameters(
+    factor: number,
+    offset: number
+  ): boolean;
+
+  /**
+   *
+   * @param {Number} factor
+   * @param {Number} offset
+   */
+  setResolveCoincidentTopologyLineOffsetParameters(
+    factor: number,
+    offset: number
+  ): boolean;
+
+  /**
+   *
+   * @param {Number} factor
+   * @param {Number} offset
+   */
+  setResolveCoincidentTopologyPointOffsetParameters(
+    factor: number,
+    offset: number
+  ): boolean;
+
+  /**
+   *
+   */
+  getResolveCoincidentTopologyLineOffsetParameters(): ICoincidentTopology;
+
+  /**
+   *
+   */
+  getResolveCoincidentTopologyPointOffsetParameters(): ICoincidentTopology;
+
+  /**
+   *
+   */
+  getResolveCoincidentTopologyPolygonOffsetParameters(): ICoincidentTopology;
+
+  /**
+   *
+   */
+  getResolveCoincidentTopologyPolygonOffsetFaces(): ICoincidentTopology;
+
+  /**
+   *
+   * @param {Number} value
+   */
+  setResolveCoincidentTopologyPolygonOffsetFaces(value: number): boolean;
+
+  /**
+   *
+   * @param mode
+   */
+  setResolveCoincidentTopology(mode?: Resolve): boolean;
+
+  /**
+   *
+   */
+  getResolveCoincidentTopology(): Resolve;
+
+  /**
+   *
+   */
+  setResolveCoincidentTopologyToDefault(): boolean;
+
+  /**
+   *
+   */
+  setResolveCoincidentTopologyToOff(): boolean;
+
+  /**
+   *
+   */
+  setResolveCoincidentTopologyToPolygonOffset(): boolean;
+
+  /**
+   *
+   */
+  getResolveCoincidentTopologyAsString(): string;
+}
+
+export default interface CoincidentTopologyHelper
+  extends StaticCoincidentTopologyMethods {
+  /**
+   *
+   * @param {ICoincidentTopology} params
+   */
+  setRelativeCoincidentTopologyLineOffsetParameters(
+    params: ICoincidentTopology
+  ): boolean;
+
+  /**
+   *
+   * @param {ICoincidentTopology} params
+   */
+  setRelativeCoincidentTopologyPointOffsetParameters(
+    params: ICoincidentTopology
+  ): boolean;
+
+  /**
+   *
+   * @param {ICoincidentTopology} params
+   */
+  setRelativeCoincidentTopologyPolygonOffsetParameters(
+    params: ICoincidentTopology
+  ): boolean;
+
+  /**
+   *
+   * @param {Number} factor
+   * @param {Number} offset
+   */
+  setRelativeCoincidentTopologyLineOffsetParameters(
+    factor: number,
+    offset: number
+  ): boolean;
+
+  /**
+   *
+   * @param {Number} factor
+   * @param {Number} offset
+   */
+  setRelativeCoincidentTopologyPointOffsetParameters(
+    factor: number,
+    offset: number
+  ): boolean;
+
+  /**
+   *
+   * @param {Number} factor
+   * @param {Number} offset
+   */
+  setRelativeCoincidentTopologyPolygonOffsetParameters(
+    factor: number,
+    offset: number
+  ): boolean;
+
+  /**
+   *
+   */
+  getCoincidentTopologyPolygonOffsetParameters(): ICoincidentTopology;
+
+  /**
+   *
+   */
+  getCoincidentTopologyLineOffsetParameters(): ICoincidentTopology;
+
+  /**
+   *
+   */
+  getCoincidentTopologyPointOffsetParameters(): ICoincidentTopology;
+}

package/Rendering/Core/Mapper/CoincidentTopologyHelper.js

@@ -1,16 +1,15 @@
-import otherStaticMethods from './Static.js';
+import otherStaticMethods, { Resolve } from './Static.js';
+export { Resolve } from './Static.js';
 import { m as macro } from '../../../macros2.js';
 
 /* eslint-disable arrow-body-style */
 function addCoincidentTopologyMethods(publicAPI, model, nameList) {
   nameList.forEach(item => {
     publicAPI[`get${item.method}`] = () => model[item.key];
-    publicAPI[`set${item.method}`] = (factor, offset) => {
-      model[item.key] = {
-        factor,
-        offset
-      };
-    };
+    publicAPI[`set${item.method}`] = macro.objectSetterMap.object(publicAPI, model, {
+      name: item.key,
+      params: ['factor', 'offset']
+    });
   });
 }
 const CATEGORIES = ['Polygon', 'Line', 'Point'];
@@ -98,7 +97,8 @@ var CoincidentTopologyHelper = {
   implementCoincidentTopologyMethods,
   staticOffsetAPI,
   otherStaticMethods,
-  CATEGORIES
+  CATEGORIES,
+  Resolve
 };
 
 export { CATEGORIES, CoincidentTopologyHelper as default };

package/Rendering/Core/Mapper/Static.js

@@ -1,35 +1,41 @@
-let resolveCoincidentTopologyPolygonOffsetFaces = 1;
-let resolveCoincidentTopology = 0;
+const Resolve = {
+  Off: 0,
+  PolygonOffset: 1
+};
+let resolveCoincidentTopologyPolygonOffsetFaces = Resolve.PolygonOffset;
+let resolveCoincidentTopology = Resolve.Off;
 const RESOLVE_COINCIDENT_TOPOLOGY_MODE = ['VTK_RESOLVE_OFF', 'VTK_RESOLVE_POLYGON_OFFSET'];
 function getResolveCoincidentTopologyPolygonOffsetFaces() {
   return resolveCoincidentTopologyPolygonOffsetFaces;
 }
 function setResolveCoincidentTopologyPolygonOffsetFaces(value) {
+  const changed = resolveCoincidentTopologyPolygonOffsetFaces === value;
   resolveCoincidentTopologyPolygonOffsetFaces = value;
+  return changed;
 }
 function getResolveCoincidentTopology() {
   return resolveCoincidentTopology;
 }
 function setResolveCoincidentTopology() {
   let mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  const changed = resolveCoincidentTopology === mode;
   resolveCoincidentTopology = mode;
+  return changed;
 }
 function setResolveCoincidentTopologyToDefault() {
-  setResolveCoincidentTopology(0); // VTK_RESOLVE_OFF
+  return setResolveCoincidentTopology(Resolve.Off);
 }
-
 function setResolveCoincidentTopologyToOff() {
-  setResolveCoincidentTopology(0); // VTK_RESOLVE_OFF
+  return setResolveCoincidentTopology(Resolve.Off);
 }
-
 function setResolveCoincidentTopologyToPolygonOffset() {
-  setResolveCoincidentTopology(1); // VTK_RESOLVE_POLYGON_OFFSET
+  return setResolveCoincidentTopology(Resolve.PolygonOffset);
 }
-
 function getResolveCoincidentTopologyAsString() {
   return RESOLVE_COINCIDENT_TOPOLOGY_MODE[resolveCoincidentTopology];
 }
 var otherStaticMethods = {
+  Resolve,
   getResolveCoincidentTopologyAsString,
   getResolveCoincidentTopologyPolygonOffsetFaces,
   getResolveCoincidentTopology,
@@ -40,4 +46,4 @@ var otherStaticMethods = {
   setResolveCoincidentTopologyToPolygonOffset
 };
 
-export { RESOLVE_COINCIDENT_TOPOLOGY_MODE, otherStaticMethods as default, getResolveCoincidentTopology, getResolveCoincidentTopologyAsString, getResolveCoincidentTopologyPolygonOffsetFaces, setResolveCoincidentTopology, setResolveCoincidentTopologyPolygonOffsetFaces, setResolveCoincidentTopologyToDefault, setResolveCoincidentTopologyToOff, setResolveCoincidentTopologyToPolygonOffset };
+export { RESOLVE_COINCIDENT_TOPOLOGY_MODE, Resolve, otherStaticMethods as default, getResolveCoincidentTopology, getResolveCoincidentTopologyAsString, getResolveCoincidentTopologyPolygonOffsetFaces, setResolveCoincidentTopology, setResolveCoincidentTopologyPolygonOffsetFaces, setResolveCoincidentTopologyToDefault, setResolveCoincidentTopologyToOff, setResolveCoincidentTopologyToPolygonOffset };

package/Rendering/Core/Mapper.d.ts

@@ -4,6 +4,9 @@ import vtkAbstractMapper3D, {
 } from './AbstractMapper3D';
 import { ColorMode, GetArray, ScalarMode } from './Mapper/Constants';
 import vtkDataArray from './../../Common/Core/DataArray';
+import CoincidentTopologyHelper, {
+  StaticCoincidentTopologyMethods,
+} from './Mapper/CoincidentTopologyHelper';
 
 interface IPrimitiveCount {
   points: number;
@@ -17,11 +20,6 @@ interface IAbstractScalars {
   scalars: Nullable<vtkDataArray>;
 }
 
-interface ICoincidentTopology {
-  factor: number;
-  offset: number;
-}
-
 interface IScalarToTextureCoordinate {
   texCoordS: number;
   texCoordT: number;
@@ -43,7 +41,9 @@ export interface IMapperInitialValues extends IAbstractMapper3DInitialValues {
   customShaderAttributes?: any;
 }
 
-export interface vtkMapper extends vtkAbstractMapper3D {
+export interface vtkMapper
+  extends vtkAbstractMapper3D,
+    CoincidentTopologyHelper {
   /**
    *
    */
@@ -140,21 +140,6 @@ export interface vtkMapper extends vtkAbstractMapper3D {
    */
   getBounds(): Bounds;
 
-  /**
-   *
-   */
-  getCoincidentTopologyPolygonOffsetParameters(): ICoincidentTopology;
-
-  /**
-   *
-   */
-  getCoincidentTopologyLineOffsetParameters(): ICoincidentTopology;
-
-  /**
-   *
-   */
-  getCoincidentTopologyPointOffsetParameter(): ICoincidentTopology;
-
   /**
    * Get the array name to color by.
    */
@@ -515,10 +500,6 @@ export interface vtkMapper extends vtkAbstractMapper3D {
   setInterpolateScalarsBeforeMapping(
     interpolateScalarsBeforeMapping: boolean
   ): boolean;
-
-  setResolveCoincidentTopologyToPolygonOffset(): boolean;
-
-  setResolveCoincidentTopologyToOff(): boolean;
 }
 
 /**
@@ -540,80 +521,6 @@ export function extend(
  */
 export function newInstance(initialValues?: IMapperInitialValues): vtkMapper;
 
-/**
- *
- */
-export function getResolveCoincidentTopologyAsString(): string;
-
-/**
- *
- */
-export function getResolveCoincidentTopologyPolygonOffsetFaces(): ICoincidentTopology;
-
-/**
- *
- */
-export function getResolveCoincidentTopology(): ICoincidentTopology;
-
-/**
- *
- * @param {Number} [mode]
- */
-export function setResolveCoincidentTopology(mode?: number): boolean;
-
-/**
- *
- * @param value
- */
-export function setResolveCoincidentTopologyPolygonOffsetFaces(
-  value: any
-): boolean;
-
-/**
- *
- */
-export function setResolveCoincidentTopologyToDefault(): boolean;
-
-/**
- *
- */
-export function setResolveCoincidentTopologyToOff(): boolean;
-
-/**
- *
- */
-export function setResolveCoincidentTopologyToPolygonOffset(): boolean;
-
-/**
- *
- */
-export function getRelativeCoincidentTopologyLineOffsetParameters(): ICoincidentTopology;
-
-/**
- *
- */
-export function getRelativeCoincidentTopologyPointOffsetParameters(): ICoincidentTopology;
-
-/**
- *
- */
-export function getRelativeCoincidentTopologyPolygonOffsetParameters(): ICoincidentTopology;
-
-/**
- *
- */
-export function getResolveCoincidentTopologyLineOffsetParameters(): ICoincidentTopology;
-
-/**
- *
- */
-export function getResolveCoincidentTopologyPointOffsetParameters(): ICoincidentTopology;
-
-/**
- *
- */
-export function getResolveCoincidentTopologyPolygonOffsetParameters(): ICoincidentTopology;
-
 /**
  * vtkMapper is an abstract class to specify interface between data and
  * graphics primitives. Subclasses of vtkMapper map data through a
@@ -650,22 +557,8 @@ export function getResolveCoincidentTopologyPolygonOffsetParameters(): ICoincide
 export declare const vtkMapper: {
   newInstance: typeof newInstance;
   extend: typeof extend;
-  getResolveCoincidentTopologyAsString: typeof getResolveCoincidentTopologyAsString;
-  getResolveCoincidentTopologyPolygonOffsetFaces: typeof getResolveCoincidentTopologyPolygonOffsetFaces;
-  getResolveCoincidentTopology: typeof getResolveCoincidentTopology;
-  setResolveCoincidentTopology: typeof setResolveCoincidentTopology;
-  setResolveCoincidentTopologyPolygonOffsetFaces: typeof setResolveCoincidentTopologyPolygonOffsetFaces;
-  setResolveCoincidentTopologyToDefault: typeof setResolveCoincidentTopologyToDefault;
-  setResolveCoincidentTopologyToOff: typeof setResolveCoincidentTopologyToOff;
-  setResolveCoincidentTopologyToPolygonOffset: typeof setResolveCoincidentTopologyToPolygonOffset;
-  getRelativeCoincidentTopologyLineOffsetParameters: typeof getRelativeCoincidentTopologyLineOffsetParameters;
-  getRelativeCoincidentTopologyPointOffsetParameters: typeof getRelativeCoincidentTopologyPointOffsetParameters;
-  getRelativeCoincidentTopologyPolygonOffsetParameters: typeof getRelativeCoincidentTopologyPolygonOffsetParameters;
-  getResolveCoincidentTopologyLineOffsetParameters: typeof getResolveCoincidentTopologyLineOffsetParameters;
-  getResolveCoincidentTopologyPointOffsetParameters: typeof getResolveCoincidentTopologyPointOffsetParameters;
-  getResolveCoincidentTopologyPolygonOffsetParameters: typeof getResolveCoincidentTopologyPolygonOffsetParameters;
   ColorMode: typeof ColorMode;
   ScalarMode: typeof ScalarMode;
   GetArray: typeof GetArray;
-};
+} & StaticCoincidentTopologyMethods;
 export default vtkMapper;

package/Rendering/Core/VolumeMapper/Constants.d.ts

@@ -5,6 +5,7 @@ export declare enum BlendMode {
   AVERAGE_INTENSITY_BLEND = 3,
   ADDITIVE_INTENSITY_BLEND = 4,
   RADON_TRANSFORM_BLEND = 5,
+  LABELMAP_EDGE_PROJECTION_BLEND = 6,
 }
 
 export declare enum FilterMode {

package/Rendering/Core/VolumeMapper/Constants.js

@@ -4,7 +4,8 @@ const BlendMode = {
   MINIMUM_INTENSITY_BLEND: 2,
   AVERAGE_INTENSITY_BLEND: 3,
   ADDITIVE_INTENSITY_BLEND: 4,
-  RADON_TRANSFORM_BLEND: 5
+  RADON_TRANSFORM_BLEND: 5,
+  LABELMAP_EDGE_PROJECTION_BLEND: 6
 };
 const FilterMode = {
   OFF: 0,

package/Rendering/OpenGL/ImageCPRMapper.js

@@ -14,6 +14,8 @@ import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { v as vtkPolyDataVS } from './glsl/vtkPolyDataVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import { registerOverride } from './ViewNodeFactory.js';
+import '../Core/Mapper/CoincidentTopologyHelper.js';
+import { Resolve } from '../Core/Mapper/Static.js';
 
 const {
   vtkErrorMacro
@@ -68,7 +70,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     }
   };
   publicAPI.getCoincidentParameters = (ren, actor) => {
-    if (model.renderable.getResolveCoincidentTopology()) {
+    if (model.renderable.getResolveCoincidentTopology() === Resolve.PolygonOffset) {
       return model.renderable.getCoincidentTopologyPolygonOffsetParameters();
     }
     return null;

package/Rendering/OpenGL/ImageMapper.js

@@ -14,7 +14,9 @@ import { InterpolationType } from '../Core/ImageProperty/Constants.js';
 import { v as vtkPolyDataVS } from './glsl/vtkPolyDataVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
+import '../Core/Mapper/CoincidentTopologyHelper.js';
 import { registerOverride } from './ViewNodeFactory.js';
+import { Resolve } from '../Core/Mapper/Static.js';
 
 const {
   vtkErrorMacro
@@ -103,7 +105,10 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     }
   };
   publicAPI.getCoincidentParameters = (ren, actor) => {
-    if (model.renderable.getResolveCoincidentTopology()) {
+    if (
+    // backwards compat with code that (errorneously) set this to boolean
+    // eslint-disable-next-line eqeqeq
+    model.renderable.getResolveCoincidentTopology() == Resolve.PolygonOffset) {
       return model.renderable.getCoincidentTopologyPolygonOffsetParameters();
     }
     return null;
@@ -202,7 +207,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         case 1:
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', [...splitStringOnEnter(`
                 #ifdef vtkImageLabelOutlineOn
-                  vec3 centerPosIS = fragCoordToIndexSpace(gl_FragCoord); 
+                  vec3 centerPosIS = fragCoordToIndexSpace(gl_FragCoord);
                   float centerValue = texture2D(texture1, centerPosIS.xy).r;
                   bool pixelOnBorder = false;
                   vec3 tColor = texture2D(colorTexture1, vec2(centerValue * cscale0 + cshift0, 0.5)).rgb;

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -20,6 +20,8 @@ import { InterpolationType } from '../Core/ImageProperty/Constants.js';
 import { Representation } from '../Core/Property/Constants.js';
 import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
 import { registerOverride } from './ViewNodeFactory.js';
+import '../Core/Mapper/CoincidentTopologyHelper.js';
+import { Resolve } from '../Core/Mapper/Static.js';
 
 const {
   vtkErrorMacro
@@ -94,7 +96,10 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     }
   };
   publicAPI.getCoincidentParameters = (ren, actor) => {
-    if (model.renderable.getResolveCoincidentTopology()) {
+    if (
+    // backwards compat with code that (errorneously) set this to boolean
+    // eslint-disable-next-line eqeqeq
+    model.renderable.getResolveCoincidentTopology() == Resolve.PolygonOffset) {
       return model.renderable.getCoincidentTopologyPolygonOffsetParameters();
     }
     return null;

package/Rendering/OpenGL/PolyDataMapper.js

@@ -14,6 +14,8 @@ import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import { registerOverride } from './ViewNodeFactory.js';
 import { PassTypes } from './HardwareSelector/Constants.js';
 import vtkDataSet from '../../Common/DataModel/DataSet.js';
+import '../Core/Mapper/CoincidentTopologyHelper.js';
+import { Resolve } from '../Core/Mapper/Static.js';
 
 const {
   FieldAssociations
@@ -391,7 +393,10 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
       offset: 0.0
     };
     const prop = actor.getProperty();
-    if (model.renderable.getResolveCoincidentTopology() || prop.getEdgeVisibility() && prop.getRepresentation() === Representation.SURFACE) {
+    if (
+    // backwards compat with code that (errorneously) set this to boolean
+    // eslint-disable-next-line eqeqeq
+    model.renderable.getResolveCoincidentTopology() == Resolve.PolygonOffset || prop.getEdgeVisibility() && prop.getRepresentation() === Representation.SURFACE) {
       const primType = model.lastBoundBO.getPrimitiveType();
       if (primType === primTypes.Points || prop.getRepresentation() === Representation.POINTS) {
         cp = model.renderable.getCoincidentTopologyPointOffsetParameter();

package/Rendering/OpenGL/VolumeMapper.js

@@ -175,10 +175,14 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     if (iType === InterpolationType.LINEAR) {
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TrilinearOn', '#define vtkTrilinearOn').result;
     }
-    const vtkImageLabelOutline = actorProps.getUseLabelOutline();
+    const vtkImageLabelOutline = publicAPI.isLabelmapOutlineRequired(actor);
     if (vtkImageLabelOutline === true) {
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::ImageLabelOutlineOn', '#define vtkImageLabelOutlineOn').result;
     }
+    const LabelEdgeProjection = model.renderable.getBlendMode() === BlendMode.LABELMAP_EDGE_PROJECTION_BLEND;
+    if (LabelEdgeProjection) {
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelEdgeProjectionOn', '#define vtkLabelEdgeProjectionOn').result;
+    }
     const numComp = model.scalarTexture.getComponents();
     FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::NumComponents', `#define vtkNumComponents ${numComp}`).result;
     const useIndependentComps = publicAPI.useIndependentComponents(actorProps);
@@ -350,7 +354,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       iComps: actorProps.getIndependentComponents(),
       colorMixPreset: actorProps.getColorMixPreset(),
       interpolationType: actorProps.getInterpolationType(),
-      useLabelOutline: actorProps.getUseLabelOutline(),
+      useLabelOutline: publicAPI.isLabelmapOutlineRequired(actor),
       numComp,
       maxSamples,
       useGradientOpacity: actorProps.getUseGradientOpacity(0),
@@ -512,6 +516,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     vec3.divide(vctoijk, vctoijk, vsize);
     program.setUniform3f('vVCToIJK', vctoijk[0], vctoijk[1], vctoijk[2]);
     program.setUniform3i('volumeDimensions', dims[0], dims[1], dims[2]);
+    program.setUniform3f('volumeSpacings', spc[0], spc[1], spc[2]);
     if (!model._openGLRenderWindow.getWebgl2()) {
       const volInfo = model.scalarTexture.getVolumeInfo();
       program.setUniformf('texWidth', model.scalarTexture.getWidth());
@@ -562,7 +567,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       program.setUniform3f(`vPlaneNormal${i}`, normal[0], normal[1], normal[2]);
       program.setUniformf(`vPlaneDistance${i}`, dist);
     }
-    if (actor.getProperty().getUseLabelOutline()) {
+    if (publicAPI.isLabelmapOutlineRequired(actor)) {
       const image = model.currentInput;
       const worldToIndex = image.getWorldToIndex();
       program.setUniformMatrix('vWCtoIDX', worldToIndex);
@@ -750,7 +755,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         program.setUniformf('goshift0', -goRange[0] * (gomax - gomin) / (goRange[1] - goRange[0]) + gomin);
       }
     }
-    const vtkImageLabelOutline = actor.getProperty().getUseLabelOutline();
+    const vtkImageLabelOutline = publicAPI.isLabelmapOutlineRequired(actor);
     if (vtkImageLabelOutline === true) {
       const labelOutlineOpacity = actor.getProperty().getLabelOutlineOpacity();
       program.setUniformf('outlineOpacity', labelOutlineOpacity);
@@ -1252,6 +1257,11 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       model.labelOutlineThicknessTexture = lTex.oglObject;
     }
   };
+  publicAPI.isLabelmapOutlineRequired = actor => {
+    const prop = actor.getProperty();
+    const renderable = model.renderable;
+    return prop.getUseLabelOutline() || renderable.getBlendMode() === BlendMode.LABELMAP_EDGE_PROJECTION_BLEND;
+  };
 }
 
 // ----------------------------------------------------------------------------