316 lines
9.2 KiB
TypeScript
316 lines
9.2 KiB
TypeScript
/**
|
|
* Shared types, constants, and utilities for ASCII rendering.
|
|
* Used by both WebGL renderer and UI components.
|
|
*/
|
|
|
|
// ============= Types =============
|
|
|
|
export interface AsciiOptions {
|
|
width?: number;
|
|
height?: number;
|
|
contrast?: number;
|
|
exposure?: number;
|
|
invert?: boolean;
|
|
saturation?: number;
|
|
gamma?: number;
|
|
charSet?: CharSetKey | string;
|
|
color?: boolean;
|
|
dither?: number;
|
|
edgeMode?: EdgeMode;
|
|
autoStretch?: boolean;
|
|
overlayStrength?: number;
|
|
aspectMode?: AspectMode;
|
|
denoise?: boolean;
|
|
fontAspectRatio?: number;
|
|
onProgress?: (progress: number) => void;
|
|
sharpen?: number;
|
|
edgeThreshold?: number;
|
|
shadows?: number;
|
|
highlights?: number;
|
|
scanlines?: number;
|
|
vignette?: number;
|
|
monoColor?: string;
|
|
backgroundColor?: string;
|
|
}
|
|
|
|
export interface AsciiResult {
|
|
output: string;
|
|
isHtml: boolean;
|
|
width: number;
|
|
height: number;
|
|
}
|
|
|
|
export type EdgeMode = 'none' | 'simple' | 'sobel' | 'canny';
|
|
export type CharSetKey = 'standard' | 'extended' | 'blocks' | 'minimal' | 'matrix' | 'dots' | 'shapes';
|
|
export type AspectMode = 'fit' | 'fill' | 'stretch';
|
|
|
|
export interface ImageMetadata {
|
|
color_dominant?: [number, number, number];
|
|
color_palette?: [number, number, number][];
|
|
has_fine_detail?: boolean;
|
|
}
|
|
|
|
export interface AsciiSettings {
|
|
exposure: number;
|
|
contrast: number;
|
|
saturation: number;
|
|
gamma: number;
|
|
invert: boolean;
|
|
color: boolean;
|
|
dither: number;
|
|
denoise: boolean;
|
|
edgeMode: number;
|
|
overlayStrength: number;
|
|
resolution: number;
|
|
charSet: CharSetKey;
|
|
sharpen: number;
|
|
edgeThreshold: number;
|
|
shadows: number;
|
|
highlights: number;
|
|
scanlines: number;
|
|
vignette: number;
|
|
monoColor: string;
|
|
backgroundColor: string;
|
|
}
|
|
|
|
// ============= Constants =============
|
|
|
|
export const CHAR_SETS: Record<CharSetKey, string> = {
|
|
standard: '@W%$NQ08GBR&ODHKUgSMw#Xbdp5q9C26APahk3EFVesm{}o4JZcjnuy[f1xi*7zYt(l/I\\v)T?]r><+"L;|!~:,-_.\' ',
|
|
extended: '░▒▓█▀▄▌▐│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌ ',
|
|
blocks: '█▓▒░ ',
|
|
minimal: '#+-. ',
|
|
matrix: 'ﾊﾐﾋｰｳｼﾅﾓﾆｻﾜﾂｵﾘｱﾎﾃﾏｹﾒｴｶｷﾑﾕﾗｾﾈｽﾀﾇﾍ1234567890:.=*+-<>',
|
|
dots: '⣿⣷⣯⣟⡿⢿⣻⣽⣾⣶⣦⣤⣄⣀⡀ ',
|
|
shapes: '@%#*+=-:. '
|
|
};
|
|
|
|
export const ASPECT_MODES: Record<string, AspectMode> = {
|
|
fit: 'fit',
|
|
fill: 'fill',
|
|
stretch: 'stretch'
|
|
};
|
|
|
|
export const EDGE_MODES: Record<string, EdgeMode> = {
|
|
none: 'none',
|
|
simple: 'simple',
|
|
sobel: 'sobel',
|
|
canny: 'canny'
|
|
};
|
|
|
|
// Short keys for UI
|
|
export const CHARSET_SHORT_MAP: Record<string, CharSetKey> = {
|
|
STD: 'standard',
|
|
EXT: 'extended',
|
|
BLK: 'blocks',
|
|
MIN: 'minimal',
|
|
DOT: 'dots',
|
|
SHP: 'shapes'
|
|
};
|
|
|
|
export const CHARSET_REVERSE_MAP: Record<CharSetKey, string> = Object.fromEntries(
|
|
Object.entries(CHARSET_SHORT_MAP).map(([k, v]) => [v, k])
|
|
) as Record<CharSetKey, string>;
|
|
|
|
// ============= Auto-Tune =============
|
|
|
|
export function autoTuneImage(img: HTMLImageElement, meta: ImageMetadata | null = null): Partial<AsciiOptions> {
|
|
if (typeof document === 'undefined') return {};
|
|
|
|
const canvas = document.createElement('canvas');
|
|
const ctx = canvas.getContext('2d');
|
|
if (!ctx) return {};
|
|
|
|
const size = 100;
|
|
canvas.width = size;
|
|
canvas.height = size;
|
|
ctx.drawImage(img, 0, 0, size, size);
|
|
|
|
const imageData = ctx.getImageData(0, 0, size, size);
|
|
const pixels = imageData.data;
|
|
|
|
const histogram = new Array(256).fill(0);
|
|
let totalLum = 0;
|
|
|
|
for (let i = 0; i < pixels.length; i += 4) {
|
|
const lum = Math.round(0.2126 * pixels[i] + 0.7152 * pixels[i + 1] + 0.0722 * pixels[i + 2]);
|
|
histogram[lum]++;
|
|
totalLum += lum;
|
|
}
|
|
|
|
const pixelCount = pixels.length / 4;
|
|
const avgLum = totalLum / pixelCount;
|
|
|
|
let p5: number | null = null, p95 = 255, count = 0;
|
|
for (let i = 0; i < 256; i++) {
|
|
count += histogram[i];
|
|
if (p5 === null && count > pixelCount * 0.05) p5 = i;
|
|
if (count > pixelCount * 0.95) { p95 = i; break; }
|
|
}
|
|
p5 = p5 ?? 0;
|
|
|
|
const midPoint = (p5 + p95) / 2;
|
|
let exposure = 128 / Math.max(midPoint, 10);
|
|
exposure = Math.max(0.4, Math.min(2.8, exposure));
|
|
|
|
const activeRange = p95 - p5;
|
|
let contrast = 1.1;
|
|
if (activeRange < 50) contrast = 2.5;
|
|
else if (activeRange < 100) contrast = 1.8;
|
|
else if (activeRange < 150) contrast = 1.4;
|
|
|
|
let invert = false;
|
|
let saturation = 1.2;
|
|
let useEdgeDetection = true;
|
|
|
|
if (meta) {
|
|
const { color_dominant, color_palette } = meta;
|
|
|
|
if (color_dominant) {
|
|
const [r, g, b] = color_dominant;
|
|
const domLum = 0.2126 * r + 0.7152 * g + 0.0722 * b;
|
|
if (domLum > 140) {
|
|
invert = true;
|
|
useEdgeDetection = false;
|
|
}
|
|
}
|
|
|
|
if (color_palette && Array.isArray(color_palette) && color_palette.length > 0) {
|
|
let totalSat = 0;
|
|
for (const [r, g, b] of color_palette) {
|
|
const max = Math.max(r, g, b);
|
|
const delta = max - Math.min(r, g, b);
|
|
const s = max === 0 ? 0 : delta / max;
|
|
totalSat += s;
|
|
}
|
|
const avgSat = totalSat / color_palette.length;
|
|
|
|
if (avgSat > 0.4) saturation = 1.6;
|
|
else if (avgSat < 0.1) saturation = 0.0;
|
|
else saturation = 1.2;
|
|
}
|
|
}
|
|
|
|
if (useEdgeDetection) {
|
|
let edgeLumSum = 0;
|
|
let edgeCount = 0;
|
|
for (let y = 0; y < size; y++) {
|
|
for (let x = 0; x < size; x++) {
|
|
if (x < 5 || x >= size - 5 || y < 5 || y >= size - 5) {
|
|
const i = (y * size + x) * 4;
|
|
edgeLumSum += 0.2126 * pixels[i] + 0.7152 * pixels[i + 1] + 0.0722 * pixels[i + 2];
|
|
edgeCount++;
|
|
}
|
|
}
|
|
}
|
|
const bgLum = edgeLumSum / edgeCount;
|
|
if (bgLum > 160) {
|
|
invert = true;
|
|
}
|
|
}
|
|
|
|
const gamma = avgLum < 80 ? 0.75 : avgLum > 200 ? 1.15 : 1.0;
|
|
|
|
let recommendedCharSet: CharSetKey = 'standard';
|
|
let denoise = false;
|
|
let dither = 0;
|
|
let edgeMode: EdgeMode = 'none';
|
|
let overlayStrength = 0.3;
|
|
|
|
const histogramPeaks = countHistogramPeaks(histogram, pixelCount);
|
|
const isHighContrast = activeRange > 180;
|
|
const isLowContrast = activeRange < 80;
|
|
const noiseLevel = estimateNoiseLevel(pixels, size);
|
|
|
|
const noiseThreshold = isLowContrast ? 12 : isHighContrast ? 30 : 20;
|
|
|
|
const midToneCount = histogram.slice(64, 192).reduce((a, b) => a + b, 0);
|
|
const hasGradients = midToneCount > pixelCount * 0.6 && histogramPeaks < 5;
|
|
|
|
if (isHighContrast || (meta?.has_fine_detail)) {
|
|
recommendedCharSet = 'extended';
|
|
overlayStrength = 0.2;
|
|
if (noiseLevel < noiseThreshold * 0.5) {
|
|
edgeMode = 'canny'; // Use Canny for high quality clean images
|
|
}
|
|
} else {
|
|
recommendedCharSet = 'standard';
|
|
}
|
|
|
|
if (isLowContrast || noiseLevel > noiseThreshold) {
|
|
denoise = true;
|
|
overlayStrength = isLowContrast ? 0.5 : 0.3;
|
|
// Avoid complex edge detection on noisy images
|
|
edgeMode = 'none';
|
|
}
|
|
|
|
if (hasGradients && !denoise) {
|
|
dither = 0.5; // Default dither strength
|
|
}
|
|
|
|
if (noiseLevel > noiseThreshold * 1.5) {
|
|
dither = 0;
|
|
denoise = true;
|
|
}
|
|
|
|
return {
|
|
exposure: parseFloat(exposure.toFixed(2)),
|
|
contrast,
|
|
invert,
|
|
gamma,
|
|
saturation: parseFloat(saturation.toFixed(1)),
|
|
charSet: recommendedCharSet,
|
|
denoise,
|
|
dither,
|
|
edgeMode,
|
|
overlayStrength
|
|
};
|
|
}
|
|
|
|
function countHistogramPeaks(histogram: number[], pixelCount: number): number {
|
|
const threshold = pixelCount * 0.02;
|
|
let peaks = 0;
|
|
let inPeak = false;
|
|
|
|
for (let i = 1; i < 255; i++) {
|
|
const isPeak = histogram[i] > histogram[i - 1] && histogram[i] > histogram[i + 1];
|
|
const isSignificant = histogram[i] > threshold;
|
|
|
|
if (isPeak && isSignificant && !inPeak) {
|
|
peaks++;
|
|
inPeak = true;
|
|
} else if (histogram[i] < threshold / 2) {
|
|
inPeak = false;
|
|
}
|
|
}
|
|
|
|
return peaks;
|
|
}
|
|
|
|
function estimateNoiseLevel(pixels: Uint8ClampedArray, size: number): number {
|
|
let totalVariance = 0;
|
|
const samples = 100;
|
|
|
|
for (let s = 0; s < samples; s++) {
|
|
const x = Math.floor(Math.random() * (size - 2)) + 1;
|
|
const y = Math.floor(Math.random() * (size - 2)) + 1;
|
|
const i = (y * size + x) * 4;
|
|
|
|
const center = 0.2126 * pixels[i] + 0.7152 * pixels[i + 1] + 0.0722 * pixels[i + 2];
|
|
const neighbors = [
|
|
(y - 1) * size + x,
|
|
(y + 1) * size + x,
|
|
y * size + (x - 1),
|
|
y * size + (x + 1)
|
|
].map(idx => {
|
|
const offset = idx * 4;
|
|
return 0.2126 * pixels[offset] + 0.7152 * pixels[offset + 1] + 0.0722 * pixels[offset + 2];
|
|
});
|
|
|
|
const avgNeighbor = neighbors.reduce((a, b) => a + b, 0) / 4;
|
|
totalVariance += Math.abs(center - avgNeighbor);
|
|
}
|
|
|
|
return totalVariance / samples;
|
|
}
|