/** @packageDocumentation
 * @module OrbitGT
 */
declare type int32 = number;
import { Bounds } from "../../spatial/geom/Bounds";
import { AList } from "../../system/collection/AList";
import { BlockIndex } from "../model/BlockIndex";
import { PointData } from "../model/PointData";
import { TileIndex } from "../model/TileIndex";
import { AViewRequest } from "./AViewRequest";
import { DataManager } from "./DataManager";
import { Level } from "./Level";
/**
 * Class TileSpatialIndex manages a spatial index of levels, blocks and tiles in pointcloud. The index does not store data, only block and tile indexes.
 *
 * @version 1.0 November 2015
 */
/** @internal */
export declare class ViewTree {
    /** The name of this module */
    private static readonly MODULE;
    /** Debug mode? */
    private static readonly DEBUG;
    /** The data manager */
    private _dataManager;
    /** The levels */
    private _levels;
    /** The data bounds */
    private _dataBounds;
    /** The root blocks */
    private _rootBlocks;
    /**
     * Create a new tree.
     * @param levels the levels.
     * @param dataBounds the data bounds.
     */
    constructor(dataManager: DataManager, levels: Array<Level>, dataBounds: Bounds);
    /**
     * Find all root blocks (dropping of single-point tiles during pyramid creation can lead to missing branches).
     * @return all root blocks.
     */
    private findRootBlocks;
    /**
     * Get the number of levels.
     * @return the number of levels.
     */
    getLevelCount(): int32;
    /**
     * Get a level.
     * @param index the index of the level.
     * @return the level.
     */
    getLevel(index: int32): Level;
    /**
     * Get the data bounds.
     * @return the data bounds.
     */
    getDataBounds(): Bounds;
    /**
     * Set the blocks for a level (after a data load operation).
     * @param level the level.
     * @param blockIndexes the indexes of the blocks in the level.
     */
    setLevelBlocks(level: Level, blockIndexes: Array<BlockIndex>): void;
    /**
     * Set the tiles for a block (after a data load operation).
     * @param blockIndex the index of the block.
     * @param tileIndexes the indexes of the tiles in the block.
     */
    setBlockTiles(blockIndex: BlockIndex, tileIndexes: Array<TileIndex>): void;
    /**
     * Split a tile into lower-level tiles.
     * @param level the level of the tile to split.
     * @param tile the tile to split.
     * @param childLevel the lower level of the tile.
     * @param children the list of children to split into.
     * @param levelsToLoad the list of levels to load.
     * @param blocksToLoad the list of blocks to load.
     * @return true if the list of children is complete.
     */
    private splitTile;
    /**
     * Is all tile data available for rendering?
     * @param viewRequest the view request.
     * @param tiles a list of tiles to check.
     * @param missingTiles the list of tiles whose data is missing.
     */
    private checkDataAvailable;
    /**
     * Is all tile data available for rendering?
     * @param viewRequest the view request.
     * @param tiles a list of tiles to check.
     * @return true if the tile data is available.
     */
    private isDataAvailable;
    /**
     * Add visible tiles to the view.
     * @param viewRequest the view request.
     * @param level the level of the tiles.
     * @param tiles the tiles to check.
     * @param visibleTiles the list of visible tiles to add to.
     */
    private addTilesToView;
    /**
     * Find tile indexes for a 3D view.
     * @param viewRequest the request parameters.
     * @param visibleTiles the list of visible tiles to add to.
     * @param availableTiles the set of available tiles.
     * @param visibleAvailableTiles the list if visible and available tiles to add to.
     */
    renderView3D(viewRequest: AViewRequest, levelsToLoad: AList<Level>, blocksToLoad: AList<BlockIndex>, tilesToLoad: AList<TileIndex>, tilesToRender: AList<PointData>): void;
}
export {};
//# sourceMappingURL=ViewTree.d.ts.map