@cornerstonejs/tools 2.0.0-beta.8 → 2.0.0

package/src/utilities/math/polyline/getSignedArea.ts

@@ -1,51 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-
-/**
- * Returns the area with signal of a 2D polyline
- * https://www.youtube.com/watch?v=GpsKrAipXm8&t=1900s
- *
- * This functions has a runtime very close to `getArea` and it is recommended to
- * be called only if you need the area signal (eg: calculate polygon normal or
- * winding direction). If you do not need the area signal you should always call
- * `getArea`.
- *
- * @param polyline - Polyline points (2D)
- * @returns Area of the polyline (with signal)
- */
-export default function getSignedArea(polyline: Types.Point2[]): number {
-  if (polyline.length < 3) {
-    return 0;
-  }
-
-  // Reference point can be any point on the same plane
-  const refPoint = polyline[0];
-  let area = 0;
-
-  // Takes three points (reference point and two other points from each line
-  // segment) and calculate the area with cross product. The magnitude of the
-  // vector returned by a cross product is equal to the area of the parallelogram
-  // that the vectors span which is two times the area of the triangle.
-  //
-  // Not calling vec3 mathods makes the function run much faster since polylines
-  // may have thousands of points when using freehand ROI tool and that would
-  // increase considerably the number of function calls.
-  for (let i = 0, len = polyline.length; i < len; i++) {
-    const p1 = polyline[i];
-    // Using ternary instead of % (mod) operator to make it faster
-    const p2Index = i === len - 1 ? 0 : i + 1;
-    const p2 = polyline[p2Index];
-    const aX = p1[0] - refPoint[0];
-    const aY = p1[1] - refPoint[1];
-    const bX = p2[0] - refPoint[0];
-    const bY = p2[1] - refPoint[1];
-
-    // Cross product between vectors "a" and "b" which returns (0, 0, crossProd)
-    // for 2D vectors.
-    area += aX * bY - aY * bX;
-  }
-
-  // Divide by two because cross product returns two times the area for each triangle
-  area *= 0.5;
-
-  return area;
-}

package/src/utilities/math/polyline/getSubPixelSpacingAndXYDirections.ts

@@ -1,99 +0,0 @@
-import { StackViewport } from '@cornerstonejs/core';
-import type { Types } from '@cornerstonejs/core';
-import { vec3 } from 'gl-matrix';
-
-const EPSILON = 1e-3;
-
-/**
- * Gets the desired spacing for points in the polyline for the
- * `PlanarFreehandROITool` in the x and y canvas directions, as well as
- * returning these canvas directions in world space.
- *
- * @param viewport - The Cornerstone3D `StackViewport` or `VolumeViewport`.
- * @param subPixelResolution - The number to divide the image pixel spacing by
- * to get the sub pixel spacing. E.g. `10` will return spacings 10x smaller than
- * the native image spacing.
- * @returns The spacings of the X and Y directions, and the 3D directions of the
- * x and y directions.
- */
-const getSubPixelSpacingAndXYDirections = (
-  viewport: Types.IStackViewport | Types.IVolumeViewport,
-  subPixelResolution: number
-): { spacing: Types.Point2; xDir: Types.Point3; yDir: Types.Point3 } => {
-  let spacing;
-  let xDir;
-  let yDir;
-
-  if (viewport instanceof StackViewport) {
-    // Check XY directions
-    const imageData = viewport.getImageData();
-
-    xDir = imageData.direction.slice(0, 3);
-    yDir = imageData.direction.slice(3, 6);
-
-    spacing = imageData.spacing;
-  } else {
-    // Check volume directions
-    const imageData = viewport.getImageData();
-    const { direction, spacing: volumeSpacing } = imageData;
-    const { viewPlaneNormal, viewUp } = viewport.getCamera();
-
-    // Calculate size of spacing vector in normal direction
-    const iVector = direction.slice(0, 3) as Types.Point3;
-    const jVector = direction.slice(3, 6) as Types.Point3;
-    const kVector = direction.slice(6, 9) as Types.Point3;
-
-    const viewRight = vec3.create(); // Get the X direction of the viewport
-
-    vec3.cross(viewRight, <vec3>viewUp, <vec3>viewPlaneNormal);
-
-    const absViewRightDotI = Math.abs(vec3.dot(viewRight, iVector));
-    const absViewRightDotJ = Math.abs(vec3.dot(viewRight, jVector));
-    const absViewRightDotK = Math.abs(vec3.dot(viewRight, kVector));
-
-    // Get X spacing
-    let xSpacing;
-    if (Math.abs(1 - absViewRightDotI) < EPSILON) {
-      xSpacing = volumeSpacing[0];
-      xDir = iVector;
-    } else if (Math.abs(1 - absViewRightDotJ) < EPSILON) {
-      xSpacing = volumeSpacing[1];
-      xDir = jVector;
-    } else if (Math.abs(1 - absViewRightDotK) < EPSILON) {
-      xSpacing = volumeSpacing[2];
-      xDir = kVector;
-    } else {
-      throw new Error('No support yet for oblique plane planar contours');
-    }
-
-    const absViewUpDotI = Math.abs(vec3.dot(viewUp, iVector));
-    const absViewUpDotJ = Math.abs(vec3.dot(viewUp, jVector));
-    const absViewUpDotK = Math.abs(vec3.dot(viewUp, kVector));
-
-    // Get Y spacing
-    let ySpacing;
-    if (Math.abs(1 - absViewUpDotI) < EPSILON) {
-      ySpacing = volumeSpacing[0];
-      yDir = iVector;
-    } else if (Math.abs(1 - absViewUpDotJ) < EPSILON) {
-      ySpacing = volumeSpacing[1];
-      yDir = jVector;
-    } else if (Math.abs(1 - absViewUpDotK) < EPSILON) {
-      ySpacing = volumeSpacing[2];
-      yDir = kVector;
-    } else {
-      throw new Error('No support yet for oblique plane planar contours');
-    }
-
-    spacing = [xSpacing, ySpacing];
-  }
-
-  const subPixelSpacing: Types.Point2 = [
-    spacing[0] / subPixelResolution,
-    spacing[1] / subPixelResolution,
-  ];
-
-  return { spacing: subPixelSpacing, xDir, yDir };
-};
-
-export default getSubPixelSpacingAndXYDirections;

package/src/utilities/math/polyline/getWindingDirection.ts

@@ -1,14 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import getSignedArea from './getSignedArea';
-
-/**
- * Calculate the winding direction (CW or CCW) of a polyline
- * @param polyline - Polyline (2D)
- * @returns 1 for CW or -1 for CCW polylines
- */
-export default function getWindingDirection(polyline: Types.Point2[]): number {
-  const signedArea = getSignedArea(polyline);
-
-  // Return 1 or -1 which is also possible to convert into ContourOrientation
-  return signedArea >= 0 ? 1 : -1;
-}

package/src/utilities/math/polyline/index.ts

@@ -1,48 +0,0 @@
-import isClosed from './isClosed';
-import containsPoint from './containsPoint';
-import containsPoints from './containsPoints';
-import getAABB from './getAABB';
-import getArea from './getArea';
-import getSignedArea from './getSignedArea';
-import getWindingDirection from './getWindingDirection';
-import getNormal3 from './getNormal3';
-import getNormal2 from './getNormal2';
-import { mergePolylines, subtractPolylines } from './combinePolyline';
-import intersectPolyline from './intersectPolyline';
-import decimate from './decimate';
-import getFirstLineSegmentIntersectionIndexes from './getFirstLineSegmentIntersectionIndexes';
-import getLineSegmentIntersectionsIndexes from './getLineSegmentIntersectionsIndexes';
-import getLineSegmentIntersectionsCoordinates from './getLineSegmentIntersectionsCoordinates';
-import getClosestLineSegmentIntersection from './getClosestLineSegmentIntersection';
-import getSubPixelSpacingAndXYDirections from './getSubPixelSpacingAndXYDirections';
-import pointsAreWithinCloseContourProximity from './pointsAreWithinCloseContourProximity';
-import addCanvasPointsToArray from './addCanvasPointsToArray';
-import pointCanProjectOnLine from './pointCanProjectOnLine';
-import { isPointInsidePolyline3D } from './isPointInsidePolyline3D';
-import { projectTo2D } from './projectTo2D';
-
-export {
-  isClosed,
-  containsPoint,
-  containsPoints,
-  getAABB,
-  getArea,
-  getSignedArea,
-  getWindingDirection,
-  getNormal3,
-  getNormal2,
-  intersectPolyline,
-  decimate,
-  getFirstLineSegmentIntersectionIndexes,
-  getLineSegmentIntersectionsIndexes,
-  getLineSegmentIntersectionsCoordinates,
-  getClosestLineSegmentIntersection,
-  getSubPixelSpacingAndXYDirections,
-  pointsAreWithinCloseContourProximity,
-  addCanvasPointsToArray,
-  pointCanProjectOnLine,
-  mergePolylines,
-  subtractPolylines,
-  isPointInsidePolyline3D,
-  projectTo2D,
-};

package/src/utilities/math/polyline/intersectPolyline.ts

@@ -1,34 +0,0 @@
-import { Types } from '@cornerstonejs/core';
-import getFirstLineSegmentIntersectionIndexes from './getFirstLineSegmentIntersectionIndexes';
-
-/**
- * Check if two polylines intersect comparing line segment by line segment.
- * @param sourcePolyline - Source polyline
- * @param targetPolyline - Target polyline
- * @returns True if the polylines intersect or false otherwise
- */
-export default function intersectPolyline(
-  sourcePolyline: Types.Point2[],
-  targetPolyline: Types.Point2[]
-): boolean {
-  // Naive way to detect intersection between polylines in O(n^2).
-  // TODO: Implement Bentley Ottmann sweep line algorithm or maybe some
-  // algorithm that uses r-tree may make it run faster
-  for (let i = 0, sourceLen = sourcePolyline.length; i < sourceLen; i++) {
-    const sourceP1 = sourcePolyline[i];
-    const sourceP2Index = i === sourceLen - 1 ? 0 : i + 1;
-    const sourceP2 = sourcePolyline[sourceP2Index];
-
-    const intersectionPointIndexes = getFirstLineSegmentIntersectionIndexes(
-      targetPolyline,
-      sourceP1,
-      sourceP2
-    );
-
-    if (intersectionPointIndexes?.length === 2) {
-      return true;
-    }
-  }
-
-  return false;
-}

package/src/utilities/math/polyline/isClosed.ts

@@ -1,26 +0,0 @@
-import { glMatrix } from 'gl-matrix';
-import type { Types } from '@cornerstonejs/core';
-import * as math from '..';
-
-/**
- * A polyline is considered closed if the start and end points are at the same position
- *
- * @param polyline - Polyline points (2D)
- * @returns True if the polyline is already closed or false otherwise
- */
-export default function isClosed(polyline: Types.Point2[]): boolean {
-  if (polyline.length < 3) {
-    return false;
-  }
-
-  const numPolylinePoints = polyline.length;
-
-  const firstPoint = polyline[0];
-  const lastPoint = polyline[numPolylinePoints - 1];
-  const distFirstToLastPoints = math.point.distanceToPointSquared(
-    firstPoint,
-    lastPoint
-  );
-
-  return glMatrix.equals(0, distFirstToLastPoints);
-}

package/src/utilities/math/polyline/isPointInsidePolyline3D.ts

@@ -1,50 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import containsPoint from './containsPoint';
-import { projectTo2D } from './projectTo2D';
-
-/**
- * Determines whether a 3D point is inside a polyline in 3D space.
- *
- * The algorithm works by reducing the polyline and point to 2D space, and then
- * using the 2D algorithm to determine whether the point is inside the polyline.
- *
- * @param point - The 3D point to test.
- * @param polyline - The polyline represented as an array of 3D points.
- * @param options.holesPolyline - An array of polylines representing each hole, so it
- * is an array of arrays of 3D points.
- * @returns A boolean indicating whether the point is inside the polyline.
- * @throws An error if a shared dimension index cannot be found for the polyline points.
- */
-export function isPointInsidePolyline3D(
-  point: Types.Point3,
-  polyline: Types.Point3[],
-  options: { holes?: Types.Point3[][] } = {}
-) {
-  const { sharedDimensionIndex, projectedPolyline } = projectTo2D(polyline);
-
-  const { holes } = options;
-  const projectedHoles = [] as Types.Point2[][];
-
-  if (holes) {
-    for (let i = 0; i < holes.length; i++) {
-      const hole = holes[i];
-      const hole2D = [] as Types.Point2[];
-
-      for (let j = 0; j < hole.length; j++) {
-        hole2D.push([
-          hole[j][(sharedDimensionIndex + 1) % 3],
-          hole[j][(sharedDimensionIndex + 2) % 3],
-        ]);
-      }
-
-      projectedHoles.push(hole2D);
-    }
-  }
-
-  const point2D = [
-    point[(sharedDimensionIndex + 1) % 3],
-    point[(sharedDimensionIndex + 2) % 3],
-  ] as Types.Point2;
-
-  return containsPoint(projectedPolyline, point2D, { holes: projectedHoles });
-}

package/src/utilities/math/polyline/planarFreehandROIInternalTypes.ts

@@ -1,38 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
-
-// Note: These types are internal to the drawing/editing processes of the tool.
-
-type PlanarFreehandROIDrawData = {
-  polylineIndex: number;
-  canvasPoints: Types.Point2[];
-  contourHoleProcessingEnabled: boolean;
-};
-
-type PlanarFreehandROIEditData = {
-  prevCanvasPoints: Types.Point2[];
-  editCanvasPoints: Types.Point2[];
-  fusedCanvasPoints: Types.Point2[];
-  startCrossingIndex?: Types.Point2;
-  // The current index of the last node added to the (invisible) edit line being
-  // used to calculate the edit preview.
-  editIndex: number;
-  // The index on the prevCanvasPoints that the edit line should snap to in the
-  // edit preview.
-  snapIndex?: number;
-};
-
-type PlanarFreehandROICommonData = {
-  annotation: PlanarFreehandROIAnnotation;
-  viewportIdsToRender: string[];
-  spacing: Types.Point2;
-  xDir: Types.Point3;
-  yDir: Types.Point3;
-  movingTextBox?: boolean;
-};
-
-export {
-  PlanarFreehandROIDrawData,
-  PlanarFreehandROIEditData,
-  PlanarFreehandROICommonData,
-};

package/src/utilities/math/polyline/pointCanProjectOnLine.ts

@@ -1,57 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import { vec2 } from 'gl-matrix';
-
-/**
- * Returns `true` if the point `p` can project onto point (`p1`, `p2`), and if
- * this projected point is less than `proximity` units away.
- */
-const pointCanProjectOnLine = (
-  p: Types.Point2,
-  p1: Types.Point2,
-  p2: Types.Point2,
-  proximity: number
-): boolean => {
-  // Perfom checks in order of computational complexity.
-  const p1p = [p[0] - p1[0], p[1] - p1[1]];
-  const p1p2 = [p2[0] - p1[0], p2[1] - p1[1]];
-
-  const dot = p1p[0] * p1p2[0] + p1p[1] * p1p2[1];
-
-  // Dot product needs to be positive to be a candidate for projection onto line segment.
-  if (dot < 0) {
-    return false;
-  }
-
-  const p1p2Mag = Math.sqrt(p1p2[0] * p1p2[0] + p1p2[1] * p1p2[1]);
-
-  if (p1p2Mag === 0) {
-    return false;
-  }
-
-  const projectionVectorMag = dot / p1p2Mag;
-  const p1p2UnitVector = [p1p2[0] / p1p2Mag, p1p2[1] / p1p2Mag];
-  const projectionVector = [
-    p1p2UnitVector[0] * projectionVectorMag,
-    p1p2UnitVector[1] * projectionVectorMag,
-  ];
-  const projectionPoint = <Types.Point2>[
-    p1[0] + projectionVector[0],
-    p1[1] + projectionVector[1],
-  ];
-
-  const distance = vec2.distance(p, projectionPoint);
-
-  if (distance > proximity) {
-    // point is too far away.
-    return false;
-  }
-
-  // Check projects onto line segment.
-  if (vec2.distance(p1, projectionPoint) > vec2.distance(p1, p2)) {
-    return false;
-  }
-
-  return true;
-};
-
-export default pointCanProjectOnLine;

package/src/utilities/math/polyline/pointsAreWithinCloseContourProximity.ts

@@ -1,15 +0,0 @@
-import { vec2 } from 'gl-matrix';
-import type { Types } from '@cornerstonejs/core';
-
-/**
- * Returns true if points `p1` and `p2` are within `closeContourProximity`.
- */
-const pointsAreWithinCloseContourProximity = (
-  p1: Types.Point2,
-  p2: Types.Point2,
-  closeContourProximity: number
-): boolean => {
-  return vec2.dist(p1, p2) < closeContourProximity;
-};
-
-export default pointsAreWithinCloseContourProximity;

package/src/utilities/math/polyline/projectTo2D.ts

@@ -1,52 +0,0 @@
-import { utilities } from '@cornerstonejs/core';
-import type { Types } from '@cornerstonejs/core';
-
-const epsilon = 1e-6;
-
-/**
- * Projects a polyline from 3D to 2D by reducing one dimension.
- *
- * @param polyline - The polyline to be projected.
- * @returns An object containing the shared dimension index and the projected polyline in 2D.
- * @throws Error if a shared dimension index cannot be found for the polyline.
- */
-export function projectTo2D(polyline: Types.Point3[]) {
-  // We need to reduce one dimension to 2D, so basically
-  // we need to find the dimension index that is shared by all points
-  // Use the first three points, two is enough but three is more robust
-  let sharedDimensionIndex;
-
-  const testPoints = utilities.getRandomSampleFromArray(polyline, 50);
-
-  for (let i = 0; i < 3; i++) {
-    if (
-      testPoints.every(
-        (point, index, array) => Math.abs(point[i] - array[0][i]) < epsilon
-      )
-    ) {
-      sharedDimensionIndex = i;
-      break;
-    }
-  }
-
-  if (sharedDimensionIndex === undefined) {
-    throw new Error(
-      'Cannot find a shared dimension index for polyline, probably oblique plane'
-    );
-  }
-
-  // convert polyline list and point to 2D
-  const points2D = [] as Types.Point2[];
-
-  const firstDim = (sharedDimensionIndex + 1) % 3;
-  const secondDim = (sharedDimensionIndex + 2) % 3;
-
-  for (let i = 0; i < polyline.length; i++) {
-    points2D.push([polyline[i][firstDim], polyline[i][secondDim]]);
-  }
-
-  return {
-    sharedDimensionIndex,
-    projectedPolyline: points2D,
-  };
-}

package/src/utilities/math/rectangle/distanceToPoint.ts

@@ -1,82 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import * as lineSegment from '../line';
-
-type rectLineSegments = {
-  top: Types.Point2[];
-  right: Types.Point2[];
-  bottom: Types.Point2[];
-  left: Types.Point2[];
-};
-
-/**
- * Given a rectangle left, top, width and height, return an object containing the
- * line segments that make up the rectangle's four sides
- * @param left - The x-coordinate of the left edge of the rectangle.
- * @param top - The y-coordinate of the top edge of the rectangle.
- * @param width - The width of the rectangle.
- * @param height - The height of the rectangle.
- * @returns An object with four keys, each of which contains an array of two
- * points.
- */
-function rectToLineSegments(
-  left: number,
-  top: number,
-  width: number,
-  height: number
-): rectLineSegments {
-  const topLineStart: Types.Point2 = [left, top];
-  const topLineEnd: Types.Point2 = [left + width, top];
-
-  const rightLineStart: Types.Point2 = [left + width, top];
-  const rightLineEnd: Types.Point2 = [left + width, top + height];
-
-  const bottomLineStart: Types.Point2 = [left + width, top + height];
-  const bottomLineEnd: Types.Point2 = [left, top + height];
-
-  const leftLineStart: Types.Point2 = [left, top + height];
-  const leftLineEnd: Types.Point2 = [left, top];
-
-  const lineSegments = {
-    top: [topLineStart, topLineEnd],
-    right: [rightLineStart, rightLineEnd],
-    bottom: [bottomLineStart, bottomLineEnd],
-    left: [leftLineStart, leftLineEnd],
-  };
-
-  return lineSegments;
-}
-
-/**
- * Calculates distance of the point to the rectangle. It calculates the minimum
- * distance between the point and each line segment of the rectangle.
- *
- * @param rect - coordinates of the rectangle [left, top, width, height]
- * @param point - [x,y] coordinates of a point
- * @returns
- */
-export default function distanceToPoint(
-  rect: number[],
-  point: Types.Point2
-): number {
-  if (rect.length !== 4 || point.length !== 2) {
-    throw Error(
-      'rectangle:[left, top, width, height] or point: [x,y] not defined correctly'
-    );
-  }
-
-  const [left, top, width, height] = rect;
-
-  let minDistance = 655535;
-  const lineSegments = rectToLineSegments(left, top, width, height);
-
-  Object.keys(lineSegments).forEach((segment) => {
-    const [lineStart, lineEnd] = lineSegments[segment];
-    const distance = lineSegment.distanceToPoint(lineStart, lineEnd, point);
-
-    if (distance < minDistance) {
-      minDistance = distance;
-    }
-  });
-
-  return minDistance;
-}

package/src/utilities/math/rectangle/index.ts

@@ -1,3 +0,0 @@
-import distanceToPoint from './distanceToPoint';
-
-export { distanceToPoint };

package/src/utilities/math/sphere/index.ts

@@ -1,3 +0,0 @@
-import pointInSphere from './pointInSphere';
-
-export { pointInSphere };

package/src/utilities/math/sphere/pointInSphere.ts

@@ -1,36 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import { vec3 } from 'gl-matrix';
-
-type Sphere = {
-  center: Types.Point3 | vec3;
-  radius: number;
-  // Square of the radius
-  radius2?: number;
-};
-
-/**
- * Checks if a point is inside a sphere. Note: this is similar to the
- * `pointInEllipse` function, but since we don't need checks for the
- * ellipse's rotation in different views, we can use a simpler equation
- * which would be faster (no if statements).
- *
- * This is safe to call for point in circle as long as you don't call it with
- * anything off-plane - that is, a circle is a degenerate sphere that is
- * intersected with the primary plane.
- *
- * @param sphere - Sphere object with center and radius and radius squared
- *     as radius2 if you are calling this a huge number of times.
- * @param pointLPS - the point to check in world coordinates
- * @returns boolean
- */
-export default function pointInSphere(sphere: Sphere, pointLPS: vec3): boolean {
-  const { center, radius } = sphere;
-  const radius2 = sphere.radius2 || radius * radius;
-
-  return (
-    (pointLPS[0] - center[0]) * (pointLPS[0] - center[0]) +
-      (pointLPS[1] - center[1]) * (pointLPS[1] - center[1]) +
-      (pointLPS[2] - center[2]) * (pointLPS[2] - center[2]) <=
-    radius2
-  );
-}

package/src/utilities/math/vec2/findClosestPoint.ts

@@ -1,40 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-
-/**
- * Find the closest point to the target point
- *
- * @param sourcePoints - The potential source points.
- * @param targetPoint - The target point, used to find the closest source.
- * @returns The closest point in the array of point sources
- */
-export default function findClosestPoint(
-  sourcePoints: Array<Types.Point2>,
-  targetPoint: Types.Point2
-): Types.Point2 {
-  let minPoint = [0, 0];
-  let minDistance = Number.MAX_SAFE_INTEGER;
-
-  sourcePoints.forEach(function (sourcePoint) {
-    const distance = _distanceBetween(targetPoint, sourcePoint);
-
-    if (distance < minDistance) {
-      minDistance = distance;
-      minPoint = [...sourcePoint];
-    }
-  });
-
-  return minPoint as Types.Point2;
-}
-
-/**
- *
- * @private
- * @param p1
- * @param p2
- */
-function _distanceBetween(p1: Types.Point2, p2: Types.Point2): number {
-  const [x1, y1] = p1;
-  const [x2, y2] = p2;
-
-  return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
-}

package/src/utilities/math/vec2/index.ts

@@ -1,4 +0,0 @@
-import findClosestPoint from './findClosestPoint';
-import liangBarksyClip from './liangBarksyClip';
-
-export { findClosestPoint, liangBarksyClip };