@kitware/vtk.js 24.12.1 → 24.14.0

package/Rendering/Core/Property2D.d.ts

@@ -1,12 +1,13 @@
 import { vtkObject } from './../../interfaces';
 import { RGBColor } from './../../types';
+import { DisplayLocation } from './Property2D/Constants';
 
 interface IProperty2DInitialValues{
 	color?: RGBColor;
 	opacity?: number;
 	pointSize?: number;
 	lineWidth?: number;
-	displayLocation?: string;
+	displayLocation?: DisplayLocation;
 }
 
 export interface vtkProperty2D extends vtkObject {
@@ -25,7 +26,7 @@ export interface vtkProperty2D extends vtkObject {
 	 * Get the display location of the object.
 	 * @default 'Foreground'
 	 */
-	getDisplayLocation(): string;
+	getDisplayLocation(): DisplayLocation;
 
 	/**
 	 * Get the width of a Line. 
@@ -84,7 +85,7 @@ export interface vtkProperty2D extends vtkObject {
 	 * Set the display location of the object.
 	 * @param {String} displayLocation
 	 */
-	setDisplayLocation(displayLocation: string): boolean;
+	setDisplayLocation(displayLocation: DisplayLocation): boolean;
 
 	/**
 	 * Set the width of a Line. The width is expressed in screen units.
@@ -138,7 +139,7 @@ export function newInstance(initialValues?: IProperty2DInitialValues): vtkProper
  * like backface properties can be set and manipulated with this object.
  */
 export declare const vtkProperty2D: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
+	newInstance: typeof newInstance;
+	extend: typeof extend;
 };
 export default vtkProperty2D;

package/Rendering/Core/Renderer.js

@@ -55,11 +55,13 @@ function vtkRenderer(publicAPI, model) {
     // another renderer is setting up.
     var camera = publicAPI.getActiveCameraAndResetIfCreated();
     model.lights.forEach(function (light) {
-      if (light.lightTypeIsSceneLight() || light.lightTypeIsCameraLight()) ; else if (light.lightTypeIsHeadLight()) {
+      if (light.lightTypeIsSceneLight()) ; else if (light.lightTypeIsHeadLight()) {
         // update position and orientation of light to match camera.
         light.setPositionFrom(camera.getPositionByReference());
         light.setFocalPointFrom(camera.getFocalPointByReference());
         light.modified(camera.getMTime());
+      } else if (light.lightTypeIsCameraLight()) {
+        light.setTransformMatrix(camera.getCameraLightTransformMatrix(mat4.create()));
       } else {
         vtkErrorMacro('light has unknown light type', light.get());
       }

package/Rendering/Core/ScalarBarActor.d.ts

@@ -27,22 +27,22 @@ export interface IStyle {
  *
  */
 export interface IScalarBarActorInitialValues extends IActorInitialValues {
-  automated?: boolean,
-  autoLayout?: (publicAPI: object, model: object) => void,
-  axisLabel?: string,
-  barPosition?: Vector2,
-  barSize?: Size,
-  boxPosition?: Vector2,
-  boxSize?: Size,
-  scalarToColors?: null,
-  axisTitlePixelOffset?: number,
-  axisTextStyle?: IStyle,
-  tickLabelPixelOffset?: number,
-  tickTextStyle?: IStyle,
-  generateTicks?: (helper: any) => void,
-  drawBelowRangeSwatch?: boolean,
-  drawAboveRangeSwatch?: boolean,
-  drawNanAnnotation?: boolean,
+	automated?: boolean,
+	autoLayout?: (publicAPI: object, model: object) => void,
+	axisLabel?: string,
+	barPosition?: Vector2,
+	barSize?: Size,
+	boxPosition?: Vector2,
+	boxSize?: Size,
+	scalarToColors?: null,
+	axisTitlePixelOffset?: number,
+	axisTextStyle?: IStyle,
+	tickLabelPixelOffset?: number,
+	tickTextStyle?: IStyle,
+	generateTicks?: (helper: any) => void,
+	drawBelowRangeSwatch?: boolean,
+	drawAboveRangeSwatch?: boolean,
+	drawNanAnnotation?: boolean,
 }
 
 export interface vtkScalarBarActor extends vtkActor {
@@ -88,10 +88,11 @@ export interface vtkScalarBarActor extends vtkActor {
 	 */
 	getAutoLayout(): any;
 
-  /**
-   * 
-   */
-  getGenerateTicks(): any;
+	/**
+	 * 
+	 */
+	getGenerateTicks(): any;
+
 	/**
 	 * 
 	 */
@@ -122,7 +123,6 @@ export interface vtkScalarBarActor extends vtkActor {
 	 */
 	getBoxPositionByReference(): Vector2;
 
-
 	/**
 	 * 
 	 */
@@ -180,23 +180,24 @@ export interface vtkScalarBarActor extends vtkActor {
 	 */
 	setAutoLayout(autoLayout: any): boolean;
 
-  /**
-   * Sets the function used to generate legend ticks. 
-   * 
-   * This function takes a vtkScalarBarActorHelper and returns true on success. 
-   * To have the desired effect, the function must call: `helper.setTicks(ticks: num[])` and `helper.setTickStrings(tickStrings: string[])`.
-   * 
-   * After setting the generateTicks function you must regenerate the vtkScalarBarActor for your changes to take effect. 
-   * One way to do that is:
-   * ```
-   *  const mapper = scalarBarActor.getMapper()
-   *  if (mapper) {
-   *    mapper.getLookupTable().resetAnnotations()
-   *  }
-   * ```
-   * @param {(helper: any) => void} generateTicks 
-   */
-  setGenerateTicks(generateTicks: (helper: any) => void): boolean;
+	/**
+	 * Sets the function used to generate legend ticks. 
+	 * 
+	 * This function takes a vtkScalarBarActorHelper and returns true on success. 
+	 * To have the desired effect, the function must call: `helper.setTicks(ticks: num[])` and `helper.setTickStrings(tickStrings: string[])`.
+	 * 
+	 * After setting the generateTicks function you must regenerate the vtkScalarBarActor for your changes to take effect. 
+	 * One way to do that is:
+	 * ```
+	 *  const mapper = scalarBarActor.getMapper()
+	 *  if (mapper) {
+	 *    mapper.getLookupTable().resetAnnotations()
+	 *  }
+	 * ```
+	 * @param generateTicks 
+	 */
+	setGenerateTicks(generateTicks: (helper: any) => void): boolean;
+
 	/**
 	 * 
 	 * @param {Boolean} automated 
@@ -279,7 +280,7 @@ export interface vtkScalarBarActor extends vtkActor {
 	 * Set whether the NaN annotation should be rendered or not.
 	 * @param {Boolean} drawNanAnnotation
 	 */
-	 setDrawNanAnnotation(drawNanAnnotation: boolean): boolean;
+	setDrawNanAnnotation(drawNanAnnotation: boolean): boolean;
 
 	/**
 	 * Set whether the Below range swatch should be rendered or not
@@ -360,7 +361,7 @@ export function newInstance(initialValues?: IScalarBarActorInitialValues): vtkSc
  * (i.e., in the renderer's viewport) on top of the 3D graphics window.
  */
 export declare const vtkScalarBarActor: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
+	newInstance: typeof newInstance;
+	extend: typeof extend;
 };
 export default vtkScalarBarActor;

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

@@ -0,0 +1,16 @@
+export declare enum InterpolationType {
+	NEAREST = 0,
+	LINEAR = 1,
+	FAST_LINEAR = 2
+}
+
+export declare enum OpacityMode {
+	FRACTIONAL = 0,
+	PROPORTIONAL = 1,
+}
+
+declare const _default: {
+	InterpolationType: typeof InterpolationType;
+	OpacityMode: typeof OpacityMode;
+};
+export default _default;

package/Rendering/OpenGL/CellArrayBufferObject.js

@@ -33,6 +33,8 @@ function vtkOpenGLCellArrayBufferObject(publicAPI, model) {
   publicAPI.setType(ObjectType.ARRAY_BUFFER);
 
   publicAPI.createVBO = function (cellArray, inRep, outRep, options) {
+    var selectionMaps = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
+
     if (!cellArray.getData() || !cellArray.getData().length) {
       model.elementCount = 0;
       return 0;
@@ -263,10 +265,34 @@ function vtkOpenGLCellArrayBufferObject(publicAPI, model) {
     } else if (model.coordShiftAndScaleEnabled === true) {
       // Make sure to reset
       publicAPI.setCoordShiftAndScale(null, null);
+    } // Initialize the structures used to keep track of point ids and cell ids for selectors
+
+
+    if (selectionMaps) {
+      if (!selectionMaps.points && !selectionMaps.cells) {
+        selectionMaps.points = new Int32Array(caboCount);
+        selectionMaps.cells = new Int32Array(caboCount);
+      } else {
+        var newPoints = new Int32Array(caboCount + selectionMaps.points.length);
+        newPoints.set(selectionMaps.points);
+        selectionMaps.points = newPoints;
+        var newCells = new Int32Array(caboCount + selectionMaps.points.length);
+        newCells.set(selectionMaps.cells);
+        selectionMaps.cells = newCells;
+      }
     }
 
+    var pointCount = options.vertexOffset;
+
     addAPoint = function addAPointFunc(i) {
-      // Vertices
+      // Keep track of original point and cell ids, for selection
+      if (selectionMaps) {
+        selectionMaps.points[pointCount] = i;
+        selectionMaps.cells[pointCount] = cellCount;
+      }
+
+      ++pointCount; // Vertices
+
       pointIdx = i * 3;
 
       if (!model.coordShiftAndScaleEnabled) {

package/Rendering/OpenGL/HardwareSelector/Constants.js

@@ -3,7 +3,8 @@ var PassTypes = {
   ACTOR_PASS: 0,
   COMPOSITE_INDEX_PASS: 1,
   ID_LOW24: 2,
-  MAX_KNOWN_PASS: 2
+  ID_HIGH24: 3,
+  MAX_KNOWN_PASS: 3
 };
 var Constants = {
   PassTypes: PassTypes

package/Rendering/OpenGL/HardwareSelector.js

@@ -23,6 +23,15 @@ function getInfoHash(info) {
   return "".concat(info.propID, " ").concat(info.compositeID);
 }
 
+function getAlpha(xx, yy, pb, area) {
+  if (!pb) {
+    return 0;
+  }
+
+  var offset = (yy * (area[2] - area[0] + 1) + xx) * 4;
+  return pb[offset + 3];
+}
+
 function convert(xx, yy, pb, area) {
   if (!pb) {
     return 0;
@@ -41,6 +50,15 @@ function convert(xx, yy, pb, area) {
   return val;
 }
 
+function getID(low24, high8) {
+  /* eslint-disable no-bitwise */
+  var val = high8;
+  val <<= 24;
+  val |= low24;
+  return val;
+  /* eslint-enable no-bitwise */
+}
+
 function getPixelInformationWithData(buffdata, inDisplayPosition, maxDistance, outSelectedPosition) {
   // Base case
   var maxDist = maxDistance < 0 ? 0 : maxDistance;
@@ -80,6 +98,15 @@ function getPixelInformationWithData(buffdata, inDisplayPosition, maxDistance, o
       _info.displayPosition = inDisplayPosition;
     }
 
+    if (buffdata.pixBuffer[PassTypes.ID_LOW24]) {
+      if (getAlpha(displayPosition[0], displayPosition[1], buffdata.pixBuffer[PassTypes.ID_LOW24], buffdata.area) === 0.0) {
+        return _info;
+      }
+    }
+
+    var low24 = convert(displayPosition[0], displayPosition[1], buffdata.pixBuffer[PassTypes.ID_LOW24], buffdata.area);
+    var high24 = convert(displayPosition[0], displayPosition[1], buffdata.pixBuffer[PassTypes.ID_HIGH24], buffdata.area);
+    _info.attributeID = getID(low24, high24);
     return _info;
   } // Iterate over successively growing boxes.
   // They recursively call the base case to handle single pixels.
@@ -167,6 +194,7 @@ function convertSelection(fieldassociation, dataMap, captureZValues, renderer, o
     child.getProperties().propID = value.info.propID;
     child.getProperties().prop = value.info.prop;
     child.getProperties().compositeID = value.info.compositeID;
+    child.getProperties().attributeID = value.info.attributeID;
     child.getProperties().pixelCount = value.pixelCount;
 
     if (captureZValues) {
@@ -233,6 +261,7 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
   model.classHierarchy.push('vtkOpenGLHardwareSelector'); //----------------------------------------------------------------------------
 
   publicAPI.releasePixBuffers = function () {
+    model.rawPixBuffer = [];
     model.pixBuffer = [];
     model.zBuffer = null;
   }; //----------------------------------------------------------------------------
@@ -270,8 +299,24 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
     model._openGLRenderer.setSelector(publicAPI);
 
     model.hitProps = {};
+    model.propPixels = {};
     model.props = [];
     publicAPI.releasePixBuffers();
+
+    if (model.fieldAssociation === FieldAssociations.FIELD_ASSOCIATION_POINTS) {
+      var gl = model._openGLRenderWindow.getContext();
+
+      var originalBlending = gl.isEnabled(gl.BLEND);
+      gl.disable(gl.BLEND);
+
+      model._openGLRenderWindow.traverseAllPasses();
+
+      model._renderer.setPreserveDepthBuffer(true);
+
+      if (originalBlending) {
+        gl.enable(gl.BLEND);
+      }
+    }
   }; //----------------------------------------------------------------------------
 
 
@@ -281,11 +326,26 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
     model._openGLRenderer.setSelector(null);
 
     model.framebuffer.restorePreviousBindingsAndBuffers();
+
+    model._renderer.setPreserveDepthBuffer(false);
+  };
+
+  publicAPI.preCapturePass = function () {
+    var gl = model._openGLRenderWindow.getContext(); // Disable blending
+
+
+    model.originalBlending = gl.isEnabled(gl.BLEND);
+    gl.disable(gl.BLEND);
   };
 
-  publicAPI.preCapturePass = function () {};
+  publicAPI.postCapturePass = function () {
+    var gl = model._openGLRenderWindow.getContext(); // Restore blending if it was enabled prior to the capture
+
 
-  publicAPI.postCapturePass = function () {}; //----------------------------------------------------------------------------
+    if (model.originalBlending) {
+      gl.enable(gl.BLEND);
+    }
+  }; //----------------------------------------------------------------------------
 
 
   publicAPI.select = function () {
@@ -385,13 +445,13 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
 
     model.originalBackground = model._renderer.getBackgroundByReference();
 
-    model._renderer.setBackground(0.0, 0.0, 0.0);
+    model._renderer.setBackground(0.0, 0.0, 0.0, 0.0);
 
     var rpasses = model._openGLRenderWindow.getRenderPasses();
 
     publicAPI.beginSelection();
 
-    for (model.currentPass = PassTypes.MIN_KNOWN_PASS; model.currentPass <= PassTypes.COMPOSITE_INDEX_PASS; model.currentPass++) {
+    for (model.currentPass = PassTypes.MIN_KNOWN_PASS; model.currentPass <= PassTypes.MAX_KNOWN_PASS; model.currentPass++) {
       if (publicAPI.passRequired(model.currentPass)) {
         publicAPI.preCapturePass(model.currentPass);
 
@@ -405,6 +465,7 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
 
         publicAPI.postCapturePass(model.currentPass);
         publicAPI.savePixelBuffer(model.currentPass);
+        publicAPI.processPixelBuffers();
       }
     }
 
@@ -418,10 +479,28 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
     // model._openGLRenderWindow.traverseAllPasses();
 
     return true;
+  };
+
+  publicAPI.processPixelBuffers = function () {
+    model.props.forEach(function (prop, index) {
+      if (publicAPI.isPropHit(index)) {
+        prop.processSelectorPixelBuffers(publicAPI, model.propPixels[index]);
+      }
+    });
   }; //----------------------------------------------------------------------------
 
 
   publicAPI.passRequired = function (pass) {
+    if (pass === PassTypes.ID_HIGH24) {
+      if (model.fieldAssociation === FieldAssociations.FIELD_ASSOCIATION_POINTS) {
+        return model.maximumPointId > 0x00ffffff;
+      }
+
+      if (model.fieldAssociation === FieldAssociations.FIELD_ASSOCIATION_CELLS) {
+        return model.maximumCellId > 0x00ffffff;
+      }
+    }
+
     return true;
   }; //----------------------------------------------------------------------------
 
@@ -429,6 +508,12 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
   publicAPI.savePixelBuffer = function (passNo) {
     model.pixBuffer[passNo] = model._openGLRenderWindow.getPixelData(model.area[0], model.area[1], model.area[2], model.area[3]);
 
+    if (!model.rawPixBuffer[passNo]) {
+      var size = (model.area[2] - model.area[0] + 1) * (model.area[3] - model.area[1] + 1) * 4;
+      model.rawPixBuffer[passNo] = new Uint8Array(size);
+      model.rawPixBuffer[passNo].set(model.pixBuffer[passNo]);
+    }
+
     if (passNo === PassTypes.ACTOR_PASS) {
       if (model.captureZValues) {
         var rpasses = model._openGLRenderWindow.getRenderPasses();
@@ -442,12 +527,14 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
         }
       }
 
-      publicAPI.buildPropHitList(model.pixBuffer[passNo]);
+      publicAPI.buildPropHitList(model.rawPixBuffer[passNo]);
     }
   }; //----------------------------------------------------------------------------
 
 
   publicAPI.buildPropHitList = function (pixelbuffer) {
+    var offset = 0;
+
     for (var yy = 0; yy <= model.area[3] - model.area[1]; yy++) {
       for (var xx = 0; xx <= model.area[2] - model.area[0]; xx++) {
         var val = convert(xx, yy, pixelbuffer, model.area);
@@ -457,8 +544,13 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
 
           if (!(val in model.hitProps)) {
             model.hitProps[val] = true;
+            model.propPixels[val] = [];
           }
+
+          model.propPixels[val].push(offset * 4);
         }
+
+        ++offset;
       }
     }
   }; //----------------------------------------------------------------------------
@@ -552,8 +644,18 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
         var offset = (displayPosition[1] * (model.area[2] - model.area[0] + 1) + displayPosition[0]) * 4;
         _info2.zValue = (256 * model.zBuffer[offset] + model.zBuffer[offset + 1]) / 65535.0;
         _info2.displayPosition = inDisplayPosition;
+      } // Skip attribute ids if alpha is zero (missed)
+
+
+      if (model.pixBuffer[PassTypes.ID_LOW24]) {
+        if (getAlpha(displayPosition[0], displayPosition[1], model.pixBuffer[PassTypes.ID_LOW24], model.area) === 0.0) {
+          return _info2;
+        }
       }
 
+      var low24 = convert(displayPosition[0], displayPosition[1], model.pixBuffer[PassTypes.ID_LOW24], model.area);
+      var high24 = convert(displayPosition[0], displayPosition[1], model.pixBuffer[PassTypes.ID_HIGH24], model.area);
+      _info2.attributeID = getID(low24, high24);
       return _info2;
     } // Iterate over successively growing boxes.
     // They recursively call the base case to handle single pixels.
@@ -659,6 +761,14 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
     }
 
     return convertSelection(model.fieldAssociation, dataMap, model.captureZValues, model._renderer, model._openGLRenderWindow);
+  };
+
+  publicAPI.getRawPixelBuffer = function (passNo) {
+    return model.rawPixBuffer[passNo];
+  };
+
+  publicAPI.getPixelBuffer = function (passNo) {
+    return model.pixBuffer[passNo];
   }; //----------------------------------------------------------------------------
 
 
@@ -694,6 +804,8 @@ var DEFAULT_VALUES = {
   currentPass: -1,
   propColorValue: null,
   props: null,
+  maximumPointId: 0,
+  maximumCellId: 0,
   idOffset: 1
 }; // ----------------------------------------------------------------------------
 
@@ -710,7 +822,7 @@ function extend(publicAPI, model) {
   }
 
   macro.setGetArray(publicAPI, model, ['area'], 4);
-  macro.setGet(publicAPI, model, ['_renderer', 'currentPass', '_openGLRenderWindow']);
+  macro.setGet(publicAPI, model, ['_renderer', 'currentPass', '_openGLRenderWindow', 'maximumPointId', 'maximumCellId']);
   macro.setGetArray(publicAPI, model, ['propColorValue'], 3);
   macro.moveToProtected(publicAPI, model, ['renderer', 'openGLRenderWindow']);
   macro.event(publicAPI, model, 'event'); // Object methods

package/Rendering/OpenGL/Helper.js

@@ -41,6 +41,12 @@ function vtkOpenGLHelper(publicAPI, model) {
       var mode = publicAPI.getOpenGLMode(rep);
       var wideLines = publicAPI.haveWideLines(ren, actor);
       var gl = model.context;
+      var depthMask = gl.getParameter(gl.DEPTH_WRITEMASK);
+
+      if (model.pointPicking) {
+        gl.depthMask(false);
+      }
+
       var drawingLines = mode === gl.LINES;
 
       if (drawingLines && wideLines) {
@@ -55,6 +61,11 @@ function vtkOpenGLHelper(publicAPI, model) {
       }
 
       var stride = (mode === gl.POINTS ? 1 : 0) || (mode === gl.LINES ? 2 : 3);
+
+      if (model.pointPicking) {
+        gl.depthMask(depthMask);
+      }
+
       return model.CABO.getElementCount() / stride;
     }
 
@@ -62,6 +73,10 @@ function vtkOpenGLHelper(publicAPI, model) {
   };
 
   publicAPI.getOpenGLMode = function (rep) {
+    if (model.pointPicking) {
+      return model.context.POINTS;
+    }
+
     var type = model.primitiveType;
 
     if (rep === Representation.POINTS || type === primTypes.Points) {
@@ -144,22 +159,38 @@ function vtkOpenGLHelper(publicAPI, model) {
       publicAPI.getProgram().setUniformf('lineWidthStepSize', lineWidth / Math.ceil(lineWidth));
       publicAPI.getProgram().setUniformf('halfLineWidth', halfLineWidth);
     }
+
+    if (model.primitiveType === primTypes.Points || actor.getProperty().getRepresentation() === Representation.POINTS) {
+      publicAPI.getProgram().setUniformf('pointSize', actor.getProperty().getPointSize());
+    } else if (model.pointPicking) {
+      publicAPI.getProgram().setUniformf('pointSize', publicAPI.getPointPickingPrimitiveSize());
+    }
   };
 
   publicAPI.replaceShaderPositionVC = function (shaders, ren, actor) {
-    var VSSource = shaders.Vertex; // for lines, make sure we add the width code
+    var VSSource = shaders.Vertex; // Always set point size in case we need picking
+
+    VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Dec', ['//VTK::PositionVC::Dec', 'uniform float pointSize;']).result;
+    VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Impl', ['//VTK::PositionVC::Impl', '  gl_PointSize = pointSize;'], false).result; // for lines, make sure we add the width code
 
     if (publicAPI.getOpenGLMode(actor.getProperty().getRepresentation()) === model.context.LINES && publicAPI.haveWideLines(ren, actor)) {
       VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Dec', ['//VTK::PositionVC::Dec', 'uniform vec2 viewportSize;', 'uniform float lineWidthStepSize;', 'uniform float halfLineWidth;']).result;
       VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Impl', ['//VTK::PositionVC::Impl', ' if (halfLineWidth > 0.0)', '   {', '   float offset = float(gl_InstanceID / 2) * lineWidthStepSize - halfLineWidth;', '   vec4 tmpPos = gl_Position;', '   vec3 tmpPos2 = tmpPos.xyz / tmpPos.w;', '   tmpPos2.x = tmpPos2.x + 2.0 * mod(float(gl_InstanceID), 2.0) * offset / viewportSize[0];', '   tmpPos2.y = tmpPos2.y + 2.0 * mod(float(gl_InstanceID + 1), 2.0) * offset / viewportSize[1];', '   gl_Position = vec4(tmpPos2.xyz * tmpPos.w, tmpPos.w);', '   }']).result;
-    } // for points make sure to add in the point size
+    }
 
+    shaders.Vertex = VSSource;
+  };
 
-    if (actor.getProperty().getRepresentation() === Representation.POINTS || model.primitiveType === primTypes.Points) {
-      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Impl', ['//VTK::PositionVC::Impl', "  gl_PointSize = ".concat(actor.getProperty().getPointSize(), ".0;")], false).result;
+  publicAPI.getPointPickingPrimitiveSize = function () {
+    if (model.primitiveType === primTypes.Points) {
+      return 2;
     }
 
-    shaders.Vertex = VSSource;
+    if (model.primitiveType === primTypes.Lines) {
+      return 4;
+    }
+
+    return 6;
   };
 } // ----------------------------------------------------------------------------
 // Object factory
@@ -173,7 +204,8 @@ var DEFAULT_VALUES = {
   VAO: null,
   attributeUpdateTime: null,
   CABO: null,
-  primitiveType: 0
+  primitiveType: 0,
+  pointPicking: false
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -185,7 +217,7 @@ function extend(publicAPI, model) {
   macro.obj(model.shaderSourceTime);
   model.attributeUpdateTime = {};
   macro.obj(model.attributeUpdateTime);
-  macro.setGet(publicAPI, model, ['program', 'shaderSourceTime', 'VAO', 'attributeUpdateTime', 'CABO', 'primitiveType']);
+  macro.setGet(publicAPI, model, ['program', 'shaderSourceTime', 'VAO', 'attributeUpdateTime', 'CABO', 'primitiveType', 'pointPicking']);
   model.program = vtkShaderProgram.newInstance();
   model.VAO = vtkVertexArrayObject.newInstance();
   model.CABO = vtkCellArrayBufferObject.newInstance(); // Object methods