콘텐츠 지문 기술

// aHash 구현
import sharp from 'sharp';

async function averageHash(imagePath: string): Promise {
    // 1. 이미지를 8x8 회색조로 축소
    const buffer = await sharp(imagePath)
        .resize(8, 8, { fit: 'fill' })
        .grayscale()
        .raw()
        .toBuffer();

    // 2. 픽셀 평균 계산
    const pixels = Array.from(buffer);
    const average = pixels.reduce((a, b) => a + b, 0) / pixels.length;

    // 3. 각 픽셀을 평균과 비교하여 비트 생성
    let hash = '';
    for (const pixel of pixels) {
        hash += pixel >= average ? '1' : '0';
    }

    // 4. 이진수를 16진수로 변환
    const hexHash = BigInt('0b' + hash).toString(16).padStart(16, '0');

    return hexHash;
}

// 사용 예제
const hash1 = await averageHash('original.jpg');
const hash2 = await averageHash('compressed.jpg');

console.log('원본 해시:', hash1);
console.log('압축 해시:', hash2);

// dHash 구현
async function differenceHash(imagePath: string): Promise {
    // 1. 이미지를 9x8 회색조로 축소 (수평 그래디언트용 추가 열)
    const buffer = await sharp(imagePath)
        .resize(9, 8, { fit: 'fill' })
        .grayscale()
        .raw()
        .toBuffer();

    const pixels = Array.from(buffer);

    // 2. 수평 그래디언트 계산
    let hash = '';
    for (let row = 0; row < 8; row++) {
        for (let col = 0; col < 8; col++) {
            const idx = row * 9 + col;
            const left = pixels[idx];
            const right = pixels[idx + 1];
            // 왼쪽 픽셀이 오른쪽보다 작으면 1, 아니면 0
            hash += left < right ? '1' : '0';
        }
    }

    // 3. 16진수로 변환
    const hexHash = BigInt('0b' + hash).toString(16).padStart(16, '0');

    return hexHash;
}

// 사용 예제
const dhash = await differenceHash('photo.jpg');
console.log('dHash:', dhash);

// pHash 구현 (DCT 기반)
import sharp from 'sharp';

async function perceptualHash(imagePath: string): Promise {
    // 1. 이미지를 32x32 회색조로 축소
    const buffer = await sharp(imagePath)
        .resize(32, 32, { fit: 'fill' })
        .grayscale()
        .raw()
        .toBuffer();

    // 2. 픽셀을 2D 배열로 변환
    const pixels: number[][] = [];
    for (let i = 0; i < 32; i++) {
        pixels[i] = Array.from(buffer.slice(i * 32, (i + 1) * 32));
    }

    // 3. 2D DCT 적용
    const dctMatrix = dct2d(pixels);

    // 4. 좌상단 8x8 저주파수 성분 추출
    const lowFreq: number[] = [];
    for (let i = 0; i < 8; i++) {
        for (let j = 0; j < 8; j++) {
            lowFreq.push(dctMatrix[i][j]);
        }
    }

    // 5. 중앙값 계산
    const sorted = [...lowFreq].sort((a, b) => a - b);
    const median = sorted[Math.floor(sorted.length / 2)];

    // 6. 각 계수를 중앙값과 비교
    let hash = '';
    for (const coef of lowFreq) {
        hash += coef > median ? '1' : '0';
    }

    // 7. 16진수로 변환
    const hexHash = BigInt('0b' + hash).toString(16).padStart(16, '0');

    return hexHash;
}

// DCT 헬퍼 함수
function dct2d(matrix: number[][]): number[][] {
    const N = matrix.length;
    const result: number[][] = Array(N).fill(0).map(() => Array(N).fill(0));

    for (let u = 0; u < N; u++) {
        for (let v = 0; v < N; v++) {
            let sum = 0;
            for (let i = 0; i < N; i++) {
                for (let j = 0; j < N; j++) {
                    sum += matrix[i][j] *
                           Math.cos(((2*i+1) * u * Math.PI) / (2*N)) *
                           Math.cos(((2*j+1) * v * Math.PI) / (2*N));
                }
            }
            const cu = u === 0 ? 1/Math.sqrt(2) : 1;
            const cv = v === 0 ? 1/Math.sqrt(2) : 1;
            result[u][v] = (2/N) * cu * cv * sum;
        }
    }
    return result;
}

// 해밍 거리 계산
function hammingDistance(hash1: string, hash2: string): number {
    if (hash1.length !== hash2.length) {
        throw new Error('해시 길이가 동일해야 합니다');
    }

    // 16진수를 BigInt로 변환
    const num1 = BigInt('0x' + hash1);
    const num2 = BigInt('0x' + hash2);

    // XOR 연산
    let xor = num1 ^ num2;

    // 1 비트 개수 세기 (Brian Kernighan 알고리즘)
    let distance = 0;
    while (xor > 0n) {
        distance++;
        xor &= xor - 1n;  // 가장 오른쪽 1 비트 제거
    }

    return distance;
}

// 사용 예제
const hash1 = 'a4b3c2d1e5f6a7b8';
const hash2 = 'a4b3c2d1e5f6a7b9';  // 마지막 비트만 다름
const distance = hammingDistance(hash1, hash2);

console.log('해밍 거리:', distance);
console.log('유사도:', (1 - distance / 64) * 100 + '%');

// FFmpeg를 사용한 비디오 지문 생성
import { spawn } from 'child_process';
import { writeFileSync, unlinkSync } from 'fs';

async function videoFingerprint(videoPath: string): Promise {
    const hashes: string[] = [];

    // 1. FFmpeg로 1초당 1프레임 추출
    const ffmpeg = spawn('ffmpeg', [
        '-i', videoPath,
        '-vf', 'fps=1',  // 1초당 1프레임
        '-f', 'image2pipe',
        '-vcodec', 'png',
        '-'
    ]);

    let frameBuffer = Buffer.alloc(0);
    let frameCount = 0;

    // 2. 각 프레임 처리
    for await (const chunk of ffmpeg.stdout) {
        frameBuffer = Buffer.concat([frameBuffer, chunk]);

        // PNG 경계 찾기 (IEND 청크)
        const iendIndex = frameBuffer.indexOf(Buffer.from('IEND', 'ascii'));
        if (iendIndex !== -1) {
            // 완전한 프레임 추출
            const frame = frameBuffer.slice(0, iendIndex + 8);
            frameBuffer = frameBuffer.slice(iendIndex + 8);

            // 프레임 임시 저장 및 해시 생성
            const tempPath = `/tmp/frame-${frameCount}.png`;
            writeFileSync(tempPath, frame);

            const hash = await perceptualHash(tempPath);
            hashes.push(hash);

            // 임시 파일 삭제
            unlinkSync(tempPath);

            frameCount++;
        }
    }

    console.log(`✅ ${frameCount}개 프레임 처리 완료`);
    return hashes;
}

// 사용 예제
const fingerprint = await videoFingerprint('video.mp4');
console.log('비디오 지문:', fingerprint);

// 시간적 지문 생성
function temporalFingerprint(frameHashes: string[]): string {
    // 연속 프레임 간의 해밍 거리 계산
    const temporalSignature: number[] = [];

    for (let i = 1; i < frameHashes.length; i++) {
        const distance = hammingDistance(frameHashes[i - 1], frameHashes[i]);
        temporalSignature.push(distance);
    }

    // 시간적 변화 패턴을 해시로 변환
    const avgChange = temporalSignature.reduce((a, b) => a + b, 0) / temporalSignature.length;

    let temporalHash = '';
    for (const change of temporalSignature) {
        temporalHash += change > avgChange ? '1' : '0';
    }

    return temporalHash;
}

// 사용 예제
const frameHashes = await videoFingerprint('movie.mp4');
const temporal = temporalFingerprint(frameHashes);
console.log('시간적 지문:', temporal);

// 오디오 지문 생성 (간소화된 버전)
import { spawn } from 'child_process';

async function audioFingerprint(audioPath: string): Promise {
    // 1. FFmpeg로 오디오를 PCM으로 디코딩
    const ffmpeg = spawn('ffmpeg', [
        '-i', audioPath,
        '-f', 's16le',  // 16비트 PCM
        '-ac', '1',     // 모노
        '-ar', '11025', // 11kHz 샘플링
        '-'
    ]);

    const chunks: Buffer[] = [];
    for await (const chunk of ffmpeg.stdout) {
        chunks.push(chunk);
    }

    // 2. PCM 데이터 버퍼 결합
    const pcmData = Buffer.concat(chunks);
    const samples = new Int16Array(pcmData.buffer);

    // 3. 단시간 푸리에 변환 (STFT)
    const windowSize = 1024;
    const hopSize = 512;
    const spectrogram: number[][] = [];

    for (let i = 0; i < samples.length - windowSize; i += hopSize) {
        const window = Array.from(samples.slice(i, i + windowSize));
        const magnitudes = fft(window);  // FFT 수행
        spectrogram.push(magnitudes);
    }

    // 4. 스펙트로그램에서 피크 추출
    const peaks = extractPeaks(spectrogram);

    // 5. 피크를 해시로 변환
    const hash = peaksToHash(peaks);

    return hash;
}

// 피크 추출 (로컬 최대값)
function extractPeaks(spectrogram: number[][]): Array<[number, number]> {
    const peaks: Array<[number, number]> = [];

    for (let t = 1; t < spectrogram.length - 1; t++) {
        for (let f = 1; f < spectrogram[t].length - 1; f++) {
            const current = spectrogram[t][f];

            // 인접한 모든 값보다 크면 피크
            if (current > spectrogram[t-1][f] &&
                current > spectrogram[t+1][f] &&
                current > spectrogram[t][f-1] &&
                current > spectrogram[t][f+1]) {
                peaks.push([t, f]);
            }
        }
    }

    return peaks;
}

// 피크를 해시로 변환
function peaksToHash(peaks: Array<[number, number]>): string {
    // 각 피크에 대해 인접 피크와의 관계를 해시
    let hashBits = '';

    for (let i = 0; i < peaks.length - 1; i++) {
        const [t1, f1] = peaks[i];
        const [t2, f2] = peaks[i + 1];

        const deltaT = t2 - t1;
        const deltaF = f2 - f1;

        // 시간차와 주파수차를 비트로 인코딩
        hashBits += deltaT > 10 ? '1' : '0';
        hashBits += deltaF > 0 ? '1' : '0';
    }

    // 16진수로 변환
    return BigInt('0b' + hashBits).toString(16);
}

// MinHash 구현
class MinHash {
    private numHashes: number;
    private hashFunctions: Array<(x: string) => number>;
    private signature: number[];

    constructor(numHashes: number = 128) {
        this.numHashes = numHashes;
        this.signature = new Array(numHashes).fill(Infinity);

        // 해시 함수 생성 (서로 다른 시드 사용)
        this.hashFunctions = [];
        for (let i = 0; i < numHashes; i++) {
            const seed = i;
            this.hashFunctions.push((s: string) => {
                let hash = seed;
                for (let j = 0; j < s.length; j++) {
                    hash = ((hash << 5) - hash) + s.charCodeAt(j);
                    hash |= 0; // 32비트 정수로 변환
                }
                return Math.abs(hash);
            });
        }
    }

    // 텍스트에서 MinHash 서명 계산
    update(text: string): void {
        // 텍스트를 3-그램으로 분할
        const ngrams = this.getNgrams(text, 3);

        // 각 n-그램에 대해
        for (const ngram of ngrams) {
            // 모든 해시 함수 적용
            for (let i = 0; i < this.numHashes; i++) {
                const hashValue = this.hashFunctions[i](ngram);
                // 최소값 유지
                if (hashValue < this.signature[i]) {
                    this.signature[i] = hashValue;
                }
            }
        }
    }

    // n-그램 생성
    private getNgrams(text: string, n: number): Set {
        const ngrams = new Set();
        const normalized = text.toLowerCase().replace(/\s+/g, ' ');

        for (let i = 0; i <= normalized.length - n; i++) {
            ngrams.add(normalized.slice(i, i + n));
        }

        return ngrams;
    }

    // 서명 가져오기
    getSignature(): number[] {
        return [...this.signature];
    }

    // 두 MinHash 서명의 유사도 계산
    static similarity(sig1: number[], sig2: number[]): number {
        let matches = 0;
        for (let i = 0; i < sig1.length; i++) {
            if (sig1[i] === sig2[i]) {
                matches++;
            }
        }
        return matches / sig1.length;
    }
}

// 사용 예제
const text1 = "AI 콘텐츠 인증은 디지털 신뢰의 핵심입니다.";
const text2 = "디지털 신뢰를 위해서는 AI 콘텐츠 인증이 필수입니다.";

const mh1 = new MinHash();
mh1.update(text1);

const mh2 = new MinHash();
mh2.update(text2);

const similarity = MinHash.similarity(mh1.getSignature(), mh2.getSignature());
console.log('텍스트 유사도:', (similarity * 100).toFixed(2) + '%');

// BK-트리 구현
class BKTreeNode {
    hash: string;
    children: Map;

    constructor(hash: string) {
        this.hash = hash;
        this.children = new Map();
    }
}

class BKTree {
    private root: BKTreeNode | null = null;

    // 해시 추가
    add(hash: string): void {
        if (!this.root) {
            this.root = new BKTreeNode(hash);
            return;
        }

        let current = this.root;

        while (true) {
            const distance = hammingDistance(current.hash, hash);

            if (distance === 0) {
                // 중복, 추가하지 않음
                return;
            }

            if (!current.children.has(distance)) {
                current.children.set(distance, new BKTreeNode(hash));
                return;
            }

            current = current.children.get(distance)!;
        }
    }

    // 임계값 이내의 모든 해시 검색
    search(targetHash: string, threshold: number): string[] {
        if (!this.root) {
            return [];
        }

        const results: string[] = [];
        const queue: BKTreeNode[] = [this.root];

        while (queue.length > 0) {
            const node = queue.shift()!;
            const distance = hammingDistance(node.hash, targetHash);

            if (distance <= threshold) {
                results.push(node.hash);
            }

            // 삼각 부등식을 사용한 가지치기
            const minDist = Math.max(0, distance - threshold);
            const maxDist = distance + threshold;

            for (let d = minDist; d <= maxDist; d++) {
                if (node.children.has(d)) {
                    queue.push(node.children.get(d)!);
                }
            }
        }

        return results;
    }
}

// 사용 예제
const tree = new BKTree();

// 지문 데이터베이스 구축
const hashes = [
    'a1b2c3d4e5f6a7b8',
    'a1b2c3d4e5f6a7b9',
    'f1e2d3c4b5a69788',
    // ... 수백만 개의 해시
];

for (const hash of hashes) {
    tree.add(hash);
}

// 유사한 해시 검색
const queryHash = 'a1b2c3d4e5f6a7ba';
const matches = tree.search(queryHash, 3);  // 해밍 거리 3 이내

console.log('일치하는 해시:', matches);

// TensorFlow.js를 사용한 신경망 지문
import * as tf from '@tensorflow/tfjs-node';
import * as mobilenet from '@tensorflow-models/mobilenet';
import sharp from 'sharp';

class NeuralFingerprint {
    private model: mobilenet.MobileNet;

    async initialize() {
        // MobileNet 모델 로드 (사전 훈련된 ImageNet)
        this.model = await mobilenet.load({
            version: 2,
            alpha: 1.0
        });
        console.log('✅ 모델 로드 완료');
    }

    async computeEmbedding(imagePath: string): Promise {
        // 1. 이미지 로드 및 전처리
        const imageBuffer = await sharp(imagePath)
            .resize(224, 224)
            .raw()
            .toBuffer();

        // 2. 텐서로 변환
        const tensor = tf.tensor3d(
            new Uint8Array(imageBuffer),
            [224, 224, 3]
        ).expandDims(0).toFloat().div(255);

        // 3. 내부 활성화 추출 (분류 계층 이전)
        const activation = this.model.infer(tensor, 'conv_preds');

        // 4. 평균 풀링으로 고정 크기 벡터 생성
        const embedding = tf.mean(activation, [1, 2]).squeeze();

        // 5. 배열로 변환
        const embeddingArray = await embedding.array() as number[];

        // 메모리 정리
        tensor.dispose();
        activation.dispose();
        embedding.dispose();

        return embeddingArray;
    }

    // 코사인 유사도 계산
    cosineSimilarity(vec1: number[], vec2: number[]): number {
        let dotProduct = 0;
        let norm1 = 0;
        let norm2 = 0;

        for (let i = 0; i < vec1.length; i++) {
            dotProduct += vec1[i] * vec2[i];
            norm1 += vec1[i] * vec1[i];
            norm2 += vec2[i] * vec2[i];
        }

        return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
    }
}

// 사용 예제
const fingerprinter = new NeuralFingerprint();
await fingerprinter.initialize();

const emb1 = await fingerprinter.computeEmbedding('photo1.jpg');
const emb2 = await fingerprinter.computeEmbedding('photo2.jpg');

const similarity = fingerprinter.cosineSimilarity(emb1, emb2);
console.log('신경망 유사도:', (similarity * 100).toFixed(2) + '%');

// WIA-AI-017 지문 매니페스트
interface FingerprintManifest {
    fingerprintId: string;        // 고유 ID
    version: string;              // 표준 버전

    // 콘텐츠 참조
    contentType: string;          // image, video, audio, text
    contentHash: string;          // SHA-256 해시

    // 지문 데이터
    fingerprints: {
        algorithm: string;        // phash, dhash, simhash 등
        hash: string;             // 실제 지문
        confidence: number;       // 0.0-1.0
    }[];

    // 메타데이터
    computedAt: string;           // ISO 8601 타임스탬프
    computedBy: string;           // 생성 시스템/조직
}

// 예제 사용
const manifest: FingerprintManifest = {
    fingerprintId: 'fp-' + crypto.randomUUID(),
    version: '1.0',
    contentType: 'image',
    contentHash: '9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08',
    fingerprints: [
        {
            algorithm: 'pHash-DCT',
            hash: await perceptualHash('image.jpg'),
            confidence: 0.95
        },
        {
            algorithm: 'dHash',
            hash: await differenceHash('image.jpg'),
            confidence: 0.90
        }
    ],
    computedAt: new Date().toISOString(),
    computedBy: 'WIA 콘텐츠 연구소'
};