import { Color, Scene } from 'three';
import { SegmentColorizer } from './SegmentColorizer';
/**
 * GCode renderer which parses a GCode file and displays it using
 * three.js. Use .element() to retrieve the DOM canvas element.
 */
export declare class GCodeRenderer {
    readonly scene: Scene;
    private readonly renderer;
    private cameraControl?;
    private camera;
    private lineMaterial;
    private readonly parser;
    /**
     * Here you can replace the default scene setup (called after adding the model).
     * You can use renderer.scene to get access to it and do whatever you want with it.
     * The default implementation just adds some lights and then calls renderer.fitCamera().
     */
    setupScene: () => void;
    /**
     * Width of travel-lines. Use 0 to hide them.
     *
     * @type number
     */
    get travelWidth(): number;
    /**
     * Width of travel-lines. Use 0 to hide them.
     *
     * @type number
     */
    set travelWidth(w: number);
    /**
     * Set any colorizer implementation to change the segment color based on the segment
     * metadata. Some default implementations are provided.
     *
     * @type SegmentColorizer
     */
    get colorizer(): SegmentColorizer;
    /**
     * Set any colorizer implementation to change the segment color based on the segment
     * metadata. Some default implementations are provided.
     *
     * @type SegmentColorizer
     */
    set colorizer(colorizer: SegmentColorizer);
    /**
     * The number of radial segments per line.
     * Less (e.g. 3) provides faster rendering with less memory usage.
     * More (e.g. 8) provides a better look.
     *
     * @default 8
     * @type number
     */
    get radialSegments(): number;
    /**
     * The number of radial segments per line.
     * Less (e.g. 3) provides faster rendering with less memory usage.
     * More (e.g. 8) provides a better look.
     *
     * @default 8
     * @type number
     */
    set radialSegments(segments: number);
    /**
     * Internally the rendered object is split into several. This allows to reduce the
     * memory consumption while rendering.
     * You can set the number of points per object.
     * In most cases you can leave this at the default.
     *
     * @default 120000
     * @type number
     */
    get pointsPerObject(): number;
    /**
     * Internally the rendered object is split into several. This allows to reduce the
     * memory consumption while rendering.
     * You can set the number of points per object.
     * In most cases you can leave this at the default.
     *
     * @default 120000
     * @type number
     */
    set pointsPerObject(num: number);
    /**
     * Creates a new GCode renderer for the given gcode.
     * It initializes the canvas to the given size and
     * uses the passed color as background.
     *
     * @param {string} gCode
     * @param {number} width
     * @param {number} height
     * @param {Color} background
     */
    constructor(gCode: string, width: number, height: number, background: Color);
    /**
     * This can be used to retrieve some min / max values which may
     * be needed as param for a colorizer.
     * @returns {{
     *         minTemp: number | undefined,
     *         maxTemp: number,
     *         minSpeed: number | undefined,
     *         maxSpeed: number
     *     }}
     */
    getMinMaxValues(): {
        minTemp: number | undefined;
        maxTemp: number;
        minSpeed: number | undefined;
        maxSpeed: number;
    };
    private newCamera;
    fitCamera(): void;
    /**
     * Reads the GCode and renders it to a mesh.
     */
    render(): Promise<void>;
    private draw;
    /**
     * Slices the rendered model based on the passed start and end point numbers.
     * (0, pointsCount()) renders everything
     *
     * Note: Currently negative values are not allowed.
     *
     * @param {number} start the starting segment
     * @param {number} end the ending segment (excluding)
     */
    slice(start?: number, end?: number): void;
    /**
     * Slices the rendered model based on the passed start and end line numbers.
     * (0, layerCount()) renders everything
     *
     * Note: Currently negative values are not allowed.
     *
     * @param {number} start the starting layer
     * @param {number} end the ending layer (excluding)
     */
    sliceLayer(start?: number, end?: number): void;
    /**
     * Retrieve the dom html canvas element where
     * the GCode viewer draws to.
     * @returns {HTMLCanvasElement}
     */
    element(): HTMLCanvasElement;
    /**
     * disposes everything which is dispose able.
     * Call this always before destroying the instance.""
     */
    dispose(): void;
    /**
     * Get the amount of points in the model.
     *
     * @returns {number}
     */
    pointsCount(): number;
    /**
     * Get the amount of layers in the model.
     * This is an approximation which may be incorrect if the
     * nozzle moves downwards mid print.
     *
     * @returns {number}
     */
    layerCount(): number;
    /**
     * This can be called when a resize of the canvas is needed.
     *
     * @param {number} width
     * @param {number} height
     */
    resize(width: number, height: number): void;
}
