import { vtkObject } from '../../../interfaces';

import { Bounds, Vector3 } from '../../../types';

import vtkPoints from '../../Core/Points';

/**

*

*/

export interface IIncrementalOctreeNodeInitialValues {

pointIdSet?: number[];

minBounds?: Bounds;

maxBounds?: Bounds;

minDataBounds?: Bounds;

maxDataBounds?: Bounds;

parent?: vtkIncrementalOctreeNode;

children?: vtkIncrementalOctreeNode[];

}

export interface vtkIncrementalOctreeNode extends vtkObject {

/**

* Create a list object for storing point indices.

*/

createPointIdSet(): void;

/**

* Set the spatial bounding box of the node. This function sets a default

* data bounding box.

*

* @param {Number} x1

* @param {Number} x2

* @param {Number} y1

* @param {Number} y2

* @param {Number} z1

* @param {Number} z2

*/

setBounds(

x1: number,

x2: number,

y1: number,

y2: number,

z1: number,

z2: number

): void;

/**

* Get the spatial bounding box of the node. The values are returned via

* an array in order of: x_min, x_max, y_min, y_max, z_min, z_max.

*

* @param {Bounds} bounds

*/

getBounds(bounds: Bounds): void;

/**

* @param {Vector3} point

*/

getChildIndex(point: Vector3): number;

/**

* @param {Vector3} point

*/

containsPoint(point: Vector3): boolean;

/**

* @param {Vector3} point

*/

containsPointByData(point: Vector3): boolean;

/**

* Given a point inserted to either this node (a leaf node) or a descendant

* leaf (of this node --- when this node is a non-leaf node), update the

* counter and the data bounding box for this node only. The data bounding box

* is considered only if updateData is non-zero. The returned value indicates

* whether (1) or not (0) the data bounding box is actually updated. Note that

* argument nHits must be 1 unless this node is updated with a number (nHits)

* of exactly duplicate points as a whole via a single call to this function.

*

* @param {Vector3} point

* @param {Number} nHits

* @param {Boolean} updateData

*/

updateCounterAndDataBounds(

point: Vector3,

nHits: number,

updateData: boolean

): boolean;

/**

* Given a point inserted to either this node (a leaf node) or a descendant

* leaf (of this node --- when this node is a non-leaf node), update the

* counter and the data bounding box recursively bottom-up until a specified

* node. The data bounding box is considered only if updateData is non-zero.

* The returned value indicates whether (true) or not (false) the data bounding box

* is actually updated. Note that argument nHits must be 1 unless this node

* is updated with a number (nHits) of exactly duplicate points as a whole

* via a single call to this function.

*

* @param {Vector3} point

* @param {Number} nHits

* @param {Boolean} updateData

* @param {vtkIncrementalOctreeNode} endNode

*/

updateCounterAndDataBoundsRecursively(

point: Vector3,

nHits: number,

updateData: boolean,

endNode: vtkIncrementalOctreeNode

): boolean;

/**

* Given a point, determine whether (true) or not (false) it is an exact duplicate

* of all the points, if any, maintained in this node. In other words, to

* check if this given point and all existing points, if any, of this node

* are exactly duplicate with one another.

*

* @param {Vector3} point

*/

containsDuplicatePointsOnly(point: Vector3): boolean;

/**

* Determine whether or not this node is a leaf.

*/

isLeaf(): boolean;

/**

* Get the child at the given index i.

* i must be an int between 0 and 7.

*

* @param {Number} i

*/

getChild(i: number): vtkIncrementalOctreeNode;

/**

* Given a number (>= threshold) of all exactly duplicate points (accessible

* via points and pntIds, but with exactly the same 3D coordinate) maintained

* in this leaf node and a point (absolutely not a duplicate any more, with

* pntIdx storing the index in points)) to be inserted to this node, separate

* all the duplicate points from this new point by means of usually recursive

* node sub-division such that the former points are inserted to a descendant

* leaf while the new point is inserted to a sibling of this descendant leaf.

* Argument ptMode specifies whether the point is not inserted at all but only

* the point index is provided upon 0, the point is inserted via vtkPoints::

* InsertPoint() upon 1, or this point is instead inserted through vtkPoints::

* InsertNextPoint() upon 2.

*

* @param {vtkPoints} points

* @param {Number[]} pntIds

* @param {Vector3} newPnt

* @param {Number} pntIdx

* @param {Number} maxPts

* @param {Number} ptMode

*/

separateExactlyDuplicatePointsFromNewInsertion(

points: vtkPoints,

pntIds: number[],

newPnt: Vector3,

pntIdx: number,

maxPts: number,

ptMode: number

): void;

/**

* Divide this LEAF node into eight child nodes as the number of points

* maintained by this leaf node has reached the threshold maxPts while

* another point newPnt is just going to be inserted to it. The available

* point-indices pntIds are distributed to the child nodes based on the

* point coordinates (available through points). Note that this function

* can incur recursive node-division to determine the specific leaf node

* for accepting the new point (with pntIdx storing the index in points)

* because the existing maxPts points may fall within only one of the eight

* child nodes to make a radically imbalanced layout within the node (to

* be divided). Argument ptMode specifies whether the point is not inserted

* at all but instead only the point index is provided upon 0, the point is

* inserted via vtkPoints.InsertPoint() upon 1, or the point is inserted by

* vtkPoints.InsertNextPoint() upon 2. The returned value of this function

* indicates whether pntIds needs to be destroyed (1) or just unregistered

* from this node as it has been attached to another node (0).

* numberOfNodes in the tree is updated with new created nodes

*

* @param {vtkPoints} points

* @param {Number[]} pntIds

* @param {Vector3} newPnt

* @param {Number} pntIdx

* @param {Number} maxPts

* @param {Number} ptMode

* @param {Number} numberOfNodes

*/

createChildNodes(

points: vtkPoints,

pntIds: number[],

newPnt: Vector3,

pntIdx: number,

maxPts: number,

ptMode: number,

numberOfNodes: number

): { success: boolean; numberOfNodes: number; pointIdx: number };

/**

* This function is called after a successful point-insertion check and

* only applies to a leaf node. Prior to a call to this function, the

* octree should have been retrieved top-down to find the specific leaf

* node in which this new point (newPt) will be inserted. The actual index

* of the new point (to be inserted to points) is stored in pntId. Argument

* ptMode specifies whether the point is not inserted at all but instead only

* the point index is provided upon 0, the point is inserted via vtkPoints.

* insertPoint() upon 1, or it is inserted via vtkPoints.insertNextPoint()

* upon 2. For case 0, pntId needs to be specified. For cases 1 and 2, the

* actual point index is returned via pntId. Note that this function always

* returns 1 to indicate the success of point insertion.

* numberOfNodes is the number of nodes present in the tree at this time.

* it is used to assign an ID to each node which can be used to associate

* application specific information with each node. It is updated if new nodes

* are added to the tree.

*

* @param {Number} points

* @param {Number} newPnt

* @param {Number} maxPts

* @param {Number} pntId

* @param {Number} ptMode

* @param {Number} numberOfNodes

*/

insertPoint(

points: number,

newPnt: number,

maxPts: number,

pntId: number,

ptMode: number,

numberOfNodes: number

): { numberOfNodes: number; pointIdx: number };

/**

* Compute the minimum squared distance from a point to this node, with all

* six boundaries considered. The data bounding box is checked if checkData

* is non-zero. The closest on-boundary point is returned via closest.

*

* @param {Vector3} point

* @param {Vector3} closest

* @param {Boolean} innerOnly

* @param {vtkIncrementalOctreeNode} rootNode

* @param {Boolean} checkData

* @returns {Number}

*/

getDistance2ToBoundary(

point: Vector3,

closest: Vector3,

innerOnly: boolean,

rootNode: vtkIncrementalOctreeNode,

checkData: boolean

): number;

/**

* Given a point inside this node, get the minimum squared distance to all

* inner boundaries. An inner boundary is a node's face that is shared by

* another non-root node.

*

* @param {Vector3} point

* @param {vtkIncrementalOctreeNode} rootNode

*/

getDistance2ToInnerBoundary(

point: Vector3,

rootNode: vtkIncrementalOctreeNode

): number;

}

// ----------------------------------------------------------------------------

// Static API

// ----------------------------------------------------------------------------

/**

* Method use to decorate a given object (publicAPI+model) with vtkIncrementalOctreeNode characteristics.

*

* @param publicAPI object on which methods will be bounds (public)

* @param model object on which data structure will be bounds (protected)

* @param {object} [initialValues] (default: {})

*/

export function extend(

publicAPI: object,

model: object,

initialValues?: object

): void;

// ----------------------------------------------------------------------------

/**

* Method use to create a new instance of vtkIncrementalOctreeNode

* @param {IIncrementalOctreeNodeInitialValues} [initialValues] for pre-setting some of its content

*/

export function newInstance(

initialValues?: IIncrementalOctreeNodeInitialValues

): vtkIncrementalOctreeNode;

/**

* vtkIncrementalOctreeNode

*/

export declare const vtkIncrementalOctreeNode: {

newInstance: typeof newInstance;

extend: typeof extend;

};

export default vtkIncrementalOctreeNode;