manim-web 0.2.0

package/dist/mobjects/graphing/Vector.d.ts

@@ -0,0 +1,121 @@
+import { Vector3Tuple } from '../../core/Mobject';
+import { Arrow } from '../geometry';
+/**
+ * Options for creating a VectorFieldVector
+ */
+export interface VectorFieldVectorOptions {
+    /** The direction of the vector as [x, y, z] */
+    direction: Vector3Tuple;
+    /** The starting point of the vector. Default: [0, 0, 0] */
+    startPoint?: Vector3Tuple;
+    /** Stroke color. Default: '#58c4dd' (Manim blue) */
+    color?: string;
+    /** Stroke width in pixels. Default: 2 */
+    strokeWidth?: number;
+    /** Length of the arrow tip. Default: 0.2 */
+    tipLength?: number;
+    /** Maximum length for vector fields. Default: Infinity (no cap) */
+    maxLength?: number;
+}
+/**
+ * VectorFieldVector - A mathematical vector represented as an arrow
+ *
+ * Convenience class for working with vectors in mathematical contexts.
+ * Extends Arrow with additional methods for vector operations.
+ *
+ * @example
+ * ```typescript
+ * // Create a vector pointing in the direction [1, 1, 0]
+ * const v = new VectorFieldVector({
+ *   direction: [1, 1, 0]
+ * });
+ *
+ * // Create a vector at a specific position
+ * const w = new VectorFieldVector({
+ *   direction: [2, 0, 0],
+ *   startPoint: [1, 1, 0]
+ * });
+ *
+ * // Create a capped vector for vector fields
+ * const fieldVector = new VectorFieldVector({
+ *   direction: [10, 10, 0],
+ *   maxLength: 1.5  // Will be scaled down to length 1.5
+ * });
+ * ```
+ */
+export declare class VectorFieldVector extends Arrow {
+    private _direction;
+    private _startPoint;
+    private _maxLength;
+    constructor(options: VectorFieldVectorOptions);
+    /**
+     * Get the direction vector
+     */
+    getDirection(): Vector3Tuple;
+    /**
+     * Set the direction vector
+     * @param direction - New direction as [x, y, z]
+     */
+    setDirection(direction: Vector3Tuple): this;
+    /**
+     * Get the magnitude (length) of the vector
+     */
+    getMagnitude(): number;
+    /**
+     * Get the visual length of the vector (may be capped by maxLength)
+     */
+    getVisualLength(): number;
+    /**
+     * Set the length of the vector (scales the direction)
+     * @param length - New length for the vector
+     */
+    setMagnitude(length: number): this;
+    /**
+     * Get the unit vector (normalized direction)
+     */
+    getUnitVector(): Vector3Tuple;
+    /**
+     * Get the start point
+     */
+    getStartPoint(): Vector3Tuple;
+    /**
+     * Set the start point (keeps the same direction)
+     */
+    setStartPoint(point: Vector3Tuple): this;
+    /**
+     * Get the maximum length constraint
+     */
+    getMaxLength(): number;
+    /**
+     * Set the maximum length constraint
+     */
+    setMaxLength(maxLength: number): this;
+    /**
+     * Get the angle of the vector in the XY plane (in radians)
+     */
+    getAngleXY(): number;
+    /**
+     * Scale the direction vector by a factor
+     * Note: This method is named scaleDirection to avoid conflict with
+     * the inherited scaleVector property from Mobject.
+     */
+    scaleDirection(factor: number): this;
+    /**
+     * Add another vector to this one
+     */
+    addVector(other: VectorFieldVector | Vector3Tuple): this;
+    /**
+     * Compute the dot product with another vector
+     */
+    dot(other: VectorFieldVector | Vector3Tuple): number;
+    /**
+     * Compute the cross product with another vector
+     */
+    cross(other: VectorFieldVector | Vector3Tuple): Vector3Tuple;
+    /**
+     * Create a copy of this VectorFieldVector
+     */
+    protected _createCopy(): Arrow;
+}
+export default VectorFieldVector;
+//# sourceMappingURL=Vector.d.ts.map

package/dist/mobjects/graphing/Vector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Vector.d.ts","sourceRoot":"","sources":["../../../src/mobjects/graphing/Vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,+CAA+C;IAC/C,SAAS,EAAE,YAAY,CAAC;IACxB,2DAA2D;IAC3D,UAAU,CAAC,EAAE,YAAY,CAAC;IAC1B,oDAAoD;IACpD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,OAAO,CAAC,UAAU,CAAe;IACjC,OAAO,CAAC,WAAW,CAAe;IAClC,OAAO,CAAC,UAAU,CAAS;gBAEf,OAAO,EAAE,wBAAwB;IAiD7C;;OAEG;IACH,YAAY,IAAI,YAAY;IAI5B;;;OAGG;IACH,YAAY,CAAC,SAAS,EAAE,YAAY,GAAG,IAAI;IAkC3C;;OAEG;IACH,YAAY,IAAI,MAAM;IAQtB;;OAEG;IACH,eAAe,IAAI,MAAM;IAIzB;;;OAGG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAgBlC;;OAEG;IACH,aAAa,IAAI,YAAY;IAU7B;;OAEG;IACH,aAAa,IAAI,YAAY;IAI7B;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAMxC;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAMrC;;OAEG;IACH,UAAU,IAAI,MAAM;IAIpB;;;;OAIG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IASpC;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,GAAG,IAAI;IAUxD;;OAEG;IACH,GAAG,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,GAAG,MAAM;IASpD;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,GAAG,YAAY;IAS5D;;OAEG;cACgB,WAAW,IAAI,KAAK;CAUxC;AAED,eAAe,iBAAiB,CAAC"}

package/dist/mobjects/graphing/VectorField.d.ts

@@ -0,0 +1,321 @@
+import { Group } from '../../core/Group';
+/**
+ * Type for vector field function that maps (x, y) to [vx, vy]
+ */
+export type VectorFunction = (x: number, y: number) => [number, number];
+/**
+ * Type for color function that maps magnitude (or x, y, vx, vy) to a color string
+ */
+export type ColorFunction = (magnitude: number, x: number, y: number, vx: number, vy: number) => string;
+/**
+ * Base options for all vector field types
+ */
+export interface VectorFieldBaseOptions {
+    /** The vector function mapping (x, y) to [vx, vy] */
+    func: VectorFunction;
+    /** X range as [min, max, step]. Default: [-5, 5, 0.5] */
+    xRange?: [number, number, number];
+    /** Y range as [min, max, step]. Default: [-3, 3, 0.5] */
+    yRange?: [number, number, number];
+    /** Length scaling factor for vectors. Default: 1 */
+    lengthScale?: number;
+    /** Color function or static color. Default: magnitude-based gradient */
+    color?: string | ColorFunction;
+    /** Minimum magnitude threshold (vectors smaller are not drawn). Default: 0 */
+    minMagnitude?: number;
+    /** Maximum magnitude threshold (vectors are capped). Default: Infinity */
+    maxMagnitude?: number;
+    /** Stroke width. Default: DEFAULT_STROKE_WIDTH / 2 */
+    strokeWidth?: number;
+    /** Opacity. Default: 1 */
+    opacity?: number;
+}
+/**
+ * Options for ArrowVectorField
+ */
+export interface ArrowVectorFieldOptions extends VectorFieldBaseOptions {
+    /** Length of arrow tips. Default: 0.15 */
+    tipLength?: number;
+    /** Maximum visual length for each arrow. Default: 0.8 (step size) */
+    maxArrowLength?: number;
+    /** Whether to normalize all arrows to the same length. Default: false */
+    normalizeArrows?: boolean;
+}
+/**
+ * Options for StreamLines
+ */
+export interface StreamLinesOptions extends VectorFieldBaseOptions {
+    /** Number of streamlines to draw. Default: 15 */
+    numLines?: number;
+    /** Starting points for streamlines. If not provided, generated automatically. */
+    startPoints?: [number, number][];
+    /** Maximum length of each streamline. Default: 10 */
+    maxLineLength?: number;
+    /** Integration step size. Default: 0.1 */
+    stepSize?: number;
+    /** Minimum step count before stopping. Default: 3 */
+    minSteps?: number;
+    /** Line width variation based on magnitude. Default: false */
+    variableWidth?: boolean;
+    /** Whether to draw arrows along streamlines. Default: false */
+    showArrows?: boolean;
+    /** Spacing between arrows on streamlines. Default: 1 */
+    arrowSpacing?: number;
+}
+/**
+ * VectorField - Base class for vector field visualizations
+ *
+ * Provides common functionality for vector fields including:
+ * - Grid generation for sample points
+ * - Vector function evaluation
+ * - Color computation based on magnitude
+ * - Magnitude scaling
+ *
+ * @example
+ * ```typescript
+ * // Create a radial vector field
+ * const field = new VectorField({
+ *   func: (x, y) => [x, y],
+ *   xRange: [-3, 3, 0.5],
+ *   yRange: [-2, 2, 0.5]
+ * });
+ * ```
+ */
+export declare class VectorField extends Group {
+    protected _func: VectorFunction;
+    protected _xRange: [number, number, number];
+    protected _yRange: [number, number, number];
+    protected _lengthScale: number;
+    protected _colorFunc: ColorFunction;
+    protected _minMagnitude: number;
+    protected _maxMagnitude: number;
+    protected _strokeWidth: number;
+    protected _opacity: number;
+    constructor(options: VectorFieldBaseOptions);
+    /**
+     * Generate grid sample points
+     * @returns Array of [x, y] coordinates
+     */
+    protected _generateGridPoints(): [number, number][];
+    /**
+     * Evaluate the vector function at a point
+     * @param x - X coordinate
+     * @param y - Y coordinate
+     * @returns Vector [vx, vy] with magnitude constraints applied
+     */
+    protected _evaluateVector(x: number, y: number): [number, number];
+    /**
+     * Get the color for a vector at a point
+     * @param x - X coordinate
+     * @param y - Y coordinate
+     * @param vx - Vector X component
+     * @param vy - Vector Y component
+     * @returns CSS color string
+     */
+    protected _getColor(x: number, y: number, vx: number, vy: number): string;
+    /**
+     * Calculate the magnitude of a vector
+     */
+    protected _magnitude(vx: number, vy: number): number;
+    /**
+     * Get the vector function
+     */
+    getFunction(): VectorFunction;
+    /**
+     * Set a new vector function and regenerate the field
+     * @param func - New vector function
+     */
+    setFunction(func: VectorFunction): this;
+    /**
+     * Get the X range
+     */
+    getXRange(): [number, number, number];
+    /**
+     * Get the Y range
+     */
+    getYRange(): [number, number, number];
+    /**
+     * Set the length scale factor
+     */
+    setLengthScale(scale: number): this;
+    /**
+     * Get the length scale factor
+     */
+    getLengthScale(): number;
+    /**
+     * Regenerate the vector field (to be overridden by subclasses)
+     */
+    protected _regenerate(): void;
+    /**
+     * Update the vector field for animation purposes
+     * Allows smooth updates to the vector function
+     * @param func - New vector function
+     * @param alpha - Interpolation factor (0-1)
+     */
+    interpolateFunction(func: VectorFunction, alpha: number): this;
+    /**
+     * Create a copy of this VectorField
+     */
+    protected _createCopy(): VectorField;
+}
+/**
+ * ArrowVectorField - Vector field visualization using arrows
+ *
+ * Displays a grid of arrows representing the vector field, where:
+ * - Arrow position indicates the sample point
+ * - Arrow direction indicates the vector direction
+ * - Arrow length indicates the vector magnitude (unless normalized)
+ * - Arrow color can indicate magnitude or use a custom function
+ *
+ * @example
+ * ```typescript
+ * // Create a rotation field
+ * const rotationField = new ArrowVectorField({
+ *   func: (x, y) => [-y, x],
+ *   xRange: [-3, 3, 0.5],
+ *   yRange: [-3, 3, 0.5],
+ *   color: '#00ff00'
+ * });
+ *
+ * // Create a field with magnitude-based coloring
+ * const gradientField = new ArrowVectorField({
+ *   func: (x, y) => [Math.sin(y), Math.cos(x)],
+ *   color: (mag) => mag > 0.5 ? '#ff0000' : '#0000ff'
+ * });
+ * ```
+ */
+export declare class ArrowVectorField extends VectorField {
+    protected _tipLength: number;
+    protected _maxArrowLength: number;
+    protected _normalizeArrows: boolean;
+    constructor(options: ArrowVectorFieldOptions);
+    /**
+     * Generate arrows at each grid point
+     */
+    private _generateArrows;
+    /**
+     * Regenerate the vector field
+     */
+    protected _regenerate(): void;
+    /**
+     * Set whether arrows should be normalized
+     */
+    setNormalizeArrows(normalize: boolean): this;
+    /**
+     * Get whether arrows are normalized
+     */
+    getNormalizeArrows(): boolean;
+    /**
+     * Set the maximum arrow length
+     */
+    setMaxArrowLength(length: number): this;
+    /**
+     * Get the maximum arrow length
+     */
+    getMaxArrowLength(): number;
+    /**
+     * Create a copy of this ArrowVectorField
+     */
+    protected _createCopy(): ArrowVectorField;
+}
+/**
+ * StreamLines - Streamline visualization for vector fields
+ *
+ * Draws curves that follow the flow of the vector field.
+ * At every point on a streamline, the tangent is parallel to the vector field.
+ *
+ * @example
+ * ```typescript
+ * // Create streamlines for a sink field
+ * const streamlines = new StreamLines({
+ *   func: (x, y) => [-x, -y],
+ *   numLines: 20,
+ *   maxLineLength: 8
+ * });
+ *
+ * // Create streamlines with custom start points
+ * const customLines = new StreamLines({
+ *   func: (x, y) => [y, -x],
+ *   startPoints: [[1, 0], [2, 0], [3, 0], [-1, 0], [-2, 0], [-3, 0]]
+ * });
+ *
+ * // Create streamlines with arrows
+ * const arrowLines = new StreamLines({
+ *   func: (x, y) => [Math.sin(x), Math.cos(y)],
+ *   showArrows: true,
+ *   arrowSpacing: 1.5
+ * });
+ * ```
+ */
+export declare class StreamLines extends VectorField {
+    protected _numLines: number;
+    protected _startPoints: [number, number][] | null;
+    protected _maxLineLength: number;
+    protected _stepSize: number;
+    protected _minSteps: number;
+    protected _variableWidth: boolean;
+    protected _showArrows: boolean;
+    protected _arrowSpacing: number;
+    constructor(options: StreamLinesOptions);
+    /**
+     * Generate starting points for streamlines if not provided
+     */
+    private _getStartPoints;
+    /**
+     * Integrate a streamline from a starting point using RK4
+     * @param startX - Starting X coordinate
+     * @param startY - Starting Y coordinate
+     * @returns Array of points along the streamline
+     */
+    private _integrateStreamline;
+    /**
+     * Generate all streamlines
+     */
+    private _generateStreamlines;
+    /**
+     * Add arrows along a streamline
+     */
+    private _addArrowsToLine;
+    /**
+     * Regenerate the vector field
+     */
+    protected _regenerate(): void;
+    /**
+     * Set custom starting points
+     */
+    setStartPoints(points: [number, number][]): this;
+    /**
+     * Get the starting points
+     */
+    getStartPoints(): [number, number][];
+    /**
+     * Set the number of streamlines (only used when startPoints is null)
+     */
+    setNumLines(num: number): this;
+    /**
+     * Get the number of streamlines
+     */
+    getNumLines(): number;
+    /**
+     * Set whether to show arrows along streamlines
+     */
+    setShowArrows(show: boolean): this;
+    /**
+     * Get whether arrows are shown
+     */
+    getShowArrows(): boolean;
+    /**
+     * Set the maximum line length
+     */
+    setMaxLineLength(length: number): this;
+    /**
+     * Get the maximum line length
+     */
+    getMaxLineLength(): number;
+    /**
+     * Create a copy of this StreamLines
+     */
+    protected _createCopy(): StreamLines;
+}
+export default VectorField;
+//# sourceMappingURL=VectorField.d.ts.map

package/dist/mobjects/graphing/VectorField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VectorField.d.ts","sourceRoot":"","sources":["../../../src/mobjects/graphing/VectorField.ts"],"names":[],"mappings":"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"}

package/dist/mobjects/graphing/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Graphing mobjects for manimweb
+ *
+ * This module provides coordinate systems, function graphs, and vectors
+ * for mathematical visualization.
+ */
+export { NumberLine, type NumberLineOptions, UnitInterval, type UnitIntervalOptions } from './NumberLine';
+export { Axes, type AxesOptions } from './Axes';
+export { NumberPlane, type NumberPlaneOptions, type BackgroundLineStyle, } from './NumberPlane';
+export { FunctionGraph, type FunctionGraphOptions } from './FunctionGraph';
+export { ImplicitFunction, type ImplicitFunctionOptions } from './ImplicitFunction';
+export { ParametricFunction, type ParametricFunctionOptions } from './ParametricFunction';
+export { VectorFieldVector, type VectorFieldVectorOptions } from './Vector';
+export { ComplexPlane, type ComplexPlaneOptions, type Complex, } from './ComplexPlane';
+export { PolarPlane, type PolarPlaneOptions, } from './ComplexPlane';
+export { BarChart, type BarChartOptions } from './BarChart';
+export { VectorField, ArrowVectorField, StreamLines, type VectorFunction, type ColorFunction, type VectorFieldBaseOptions, type ArrowVectorFieldOptions, type StreamLinesOptions, } from './VectorField';
+//# sourceMappingURL=index.d.ts.map

package/dist/mobjects/graphing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mobjects/graphing/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAG1G,OAAO,EAAE,IAAI,EAAE,KAAK,WAAW,EAAE,MAAM,QAAQ,CAAC;AAGhD,OAAO,EACL,WAAW,EACX,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,GACzB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAG3E,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAGpF,OAAO,EAAE,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAG1F,OAAO,EAAE,iBAAiB,EAAE,KAAK,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAG5E,OAAO,EACL,YAAY,EACZ,KAAK,mBAAmB,EACxB,KAAK,OAAO,GACb,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,UAAU,EACV,KAAK,iBAAiB,GACvB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAG5D,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,WAAW,EACX,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC5B,KAAK,kBAAkB,GACxB,MAAM,eAAe,CAAC"}

package/dist/mobjects/image/index.d.ts

@@ -0,0 +1,223 @@
+import { Mobject, Vector3Tuple } from '../../core/Mobject';
+import * as THREE from 'three';
+/**
+ * Image filter options for visual effects
+ */
+export interface ImageFilterOptions {
+    /** Apply grayscale filter. Default: false */
+    grayscale?: boolean;
+    /** Invert colors. Default: false */
+    invert?: boolean;
+    /** Brightness multiplier (1 = normal). Default: 1 */
+    brightness?: number;
+    /** Contrast multiplier (1 = normal). Default: 1 */
+    contrast?: number;
+}
+/**
+ * Options for creating an ImageMobject
+ */
+export interface ImageMobjectOptions {
+    /** Image source: URL or base64 data URI. Either source or pixelData is required. */
+    source?: string;
+    /** 2D grayscale pixel array (values 0-255). Each inner array is a row. Either source or pixelData is required. */
+    pixelData?: number[][];
+    /** Width of the image in scene units. Default: auto-calculated from aspect ratio */
+    width?: number;
+    /** Height of the image in scene units. Default: auto-calculated from aspect ratio */
+    height?: number;
+    /** If both width and height specified, whether to scale to fit within bounds preserving aspect ratio. Default: true */
+    scaleToFit?: boolean;
+    /** Center position [x, y, z]. Default: [0, 0, 0] */
+    center?: Vector3Tuple;
+    /** Opacity from 0 to 1. Default: 1 */
+    opacity?: number;
+    /** Image filter options */
+    filters?: ImageFilterOptions;
+    /** Whether to render both sides. Default: false */
+    doubleSided?: boolean;
+}
+/**
+ * ImageMobject - Display images as mobjects
+ *
+ * Creates an image plane using THREE.js PlaneGeometry with TextureLoader.
+ * Supports loading from URLs or base64 data, with optional filters like
+ * grayscale and invert.
+ *
+ * @example
+ * ```typescript
+ * // Load from URL
+ * const image = new ImageMobject({
+ *   source: 'https://example.com/image.png',
+ *   width: 4,
+ * });
+ *
+ * // Load from base64
+ * const base64Image = new ImageMobject({
+ *   source: 'data:image/png;base64,iVBORw0KGgoAAAA...',
+ *   height: 3,
+ *   opacity: 0.8,
+ * });
+ *
+ * // With filters
+ * const filtered = new ImageMobject({
+ *   source: 'https://example.com/photo.jpg',
+ *   width: 5,
+ *   filters: {
+ *     grayscale: true,
+ *     brightness: 1.2,
+ *   },
+ * });
+ * ```
+ */
+export declare class ImageMobject extends Mobject {
+    protected _source: string;
+    protected _pixelData: number[][] | undefined;
+    protected _width: number | undefined;
+    protected _height: number | undefined;
+    protected _scaleToFit: boolean;
+    protected _centerPoint: Vector3Tuple;
+    protected _filters: ImageFilterOptions;
+    protected _doubleSided: boolean;
+    protected _texture: THREE.Texture | null;
+    protected _imageLoaded: boolean;
+    protected _naturalWidth: number;
+    protected _naturalHeight: number;
+    private _loadPromise;
+    private _loadResolve;
+    constructor(options: ImageMobjectOptions);
+    /**
+     * Load texture from a 2D grayscale pixel array
+     */
+    private _loadFromPixelData;
+    /**
+     * Load the texture from the source
+     */
+    private _loadTexture;
+    /**
+     * Wait for the image to be loaded
+     * @returns Promise that resolves when the image is loaded
+     */
+    waitForLoad(): Promise<void>;
+    /**
+     * Check if the image has been loaded
+     */
+    isLoaded(): boolean;
+    /**
+     * Calculate the display dimensions based on options and natural size
+     */
+    private _calculateDimensions;
+    /**
+     * Apply image filters using canvas manipulation
+     */
+    private _applyFilters;
+    /**
+     * Create the Three.js plane mesh with image texture
+     */
+    protected _createThreeObject(): THREE.Object3D;
+    /**
+     * Update geometry when dimensions change
+     */
+    protected _updateGeometry(): void;
+    /**
+     * Sync material properties to Three.js object
+     */
+    protected _syncMaterialToThree(): void;
+    /**
+     * Get the image source
+     */
+    getSource(): string;
+    /**
+     * Set a new image source
+     */
+    setSource(source: string): this;
+    /**
+     * Get the display width
+     */
+    getWidth(): number;
+    /**
+     * Set the display width (height will be calculated from aspect ratio)
+     */
+    setWidth(width: number): this;
+    /**
+     * Get the display height
+     */
+    getHeight(): number;
+    /**
+     * Set the display height (width will be calculated from aspect ratio)
+     */
+    setHeight(height: number): this;
+    /**
+     * Set both width and height
+     * @param width Display width
+     * @param height Display height
+     * @param scaleToFit If true, scale to fit preserving aspect ratio
+     */
+    setSize(width: number, height: number, scaleToFit?: boolean): this;
+    /**
+     * Scale the image to fit within a bounding box
+     * @param maxWidth Maximum width
+     * @param maxHeight Maximum height
+     */
+    scaleToFitBox(maxWidth: number, maxHeight: number): this;
+    /**
+     * Get the current filter options
+     */
+    getFilters(): ImageFilterOptions;
+    /**
+     * Set filter options
+     */
+    setFilters(filters: Partial<ImageFilterOptions>): this;
+    /**
+     * Set grayscale filter
+     */
+    setGrayscale(enabled: boolean): this;
+    /**
+     * Set invert filter
+     */
+    setInvert(enabled: boolean): this;
+    /**
+     * Set brightness
+     */
+    setBrightness(value: number): this;
+    /**
+     * Set contrast
+     */
+    setContrast(value: number): this;
+    /**
+     * Get whether double-sided rendering is enabled
+     */
+    isDoubleSided(): boolean;
+    /**
+     * Set double-sided rendering
+     */
+    setDoubleSided(value: boolean): this;
+    /**
+     * Get the natural (original) dimensions of the image
+     */
+    getNaturalSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Get the aspect ratio of the image
+     */
+    getAspectRatio(): number;
+    /**
+     * Override getBoundingBox to use calculated dimensions
+     */
+    protected _getBoundingBox(): {
+        width: number;
+        height: number;
+        depth: number;
+    };
+    /**
+     * Create a copy of this ImageMobject
+     */
+    protected _createCopy(): ImageMobject;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}
+export default ImageMobject;
+//# sourceMappingURL=index.d.ts.map