Files
frontend/apps/sn/app/(with-base-layout)/oper/dredging/lib/exif.ts
T
2026-08-07 15:28:33 +09:00

335 lines
10 KiB
TypeScript

import type { ExifStatus, GeoPoint, PhotoMetadata } from "./types";
type ByteOrder = "LE" | "BE";
type IfdEntry = {
type: number;
count: number;
valueOffset: number;
entryOffset: number;
};
const JPEG_START = 0xffd8;
const APP1_MARKER = 0xe1;
const EXIF_IFD_POINTER = 0x8769;
const GPS_IFD_POINTER = 0x8825;
const DATE_TIME = 0x0132;
const DATE_TIME_ORIGINAL = 0x9003;
const DATE_TIME_DIGITIZED = 0x9004;
const typeByteLength = (type: number) => {
if (type === 1 || type === 2 || type === 7) return 1;
if (type === 3) return 2;
if (type === 4 || type === 9) return 4;
if (type === 5 || type === 10) return 8;
return 0;
};
/**
* JPEG EXIF TIFF 블록을 읽는 범위 제한 reader이다.
* 손상된 offset이 파일 범위를 벗어나면 예외를 발생시켜 수동 입력 흐름으로 전환한다.
*/
class TiffReader {
private readonly view: DataView;
private readonly tiffStart: number;
private readonly order: ByteOrder;
constructor(buffer: ArrayBuffer, tiffStart: number) {
this.view = new DataView(buffer);
this.tiffStart = tiffStart;
this.ensureRange(tiffStart, 8);
const byteOrder = this.view.getUint16(tiffStart, false);
if (byteOrder === 0x4949) {
this.order = "LE";
} else if (byteOrder === 0x4d4d) {
this.order = "BE";
} else {
throw new Error("지원하지 않는 TIFF 바이트 순서입니다.");
}
if (this.uint16(2) !== 0x002a) {
throw new Error("유효한 TIFF 헤더가 아닙니다.");
}
}
private get littleEndian() {
return this.order === "LE";
}
private absolute(relativeOffset: number) {
return this.tiffStart + relativeOffset;
}
private ensureRange(absoluteOffset: number, byteLength: number) {
if (
absoluteOffset < 0 ||
byteLength < 0 ||
absoluteOffset + byteLength > this.view.byteLength
) {
throw new Error("EXIF offset이 파일 범위를 벗어났습니다.");
}
}
uint16(relativeOffset: number) {
const absoluteOffset = this.absolute(relativeOffset);
this.ensureRange(absoluteOffset, 2);
return this.view.getUint16(absoluteOffset, this.littleEndian);
}
uint32(relativeOffset: number) {
const absoluteOffset = this.absolute(relativeOffset);
this.ensureRange(absoluteOffset, 4);
return this.view.getUint32(absoluteOffset, this.littleEndian);
}
private readIfd(relativeOffset: number) {
const entryCount = this.uint16(relativeOffset);
const entries = new Map<number, IfdEntry>();
for (let index = 0; index < entryCount; index += 1) {
const entryOffset = relativeOffset + 2 + index * 12;
const tag = this.uint16(entryOffset);
const type = this.uint16(entryOffset + 2);
const count = this.uint32(entryOffset + 4);
const valueOffset = this.uint32(entryOffset + 8);
entries.set(tag, { type, count, valueOffset, entryOffset });
}
return entries;
}
private dataRelativeOffset(entry: IfdEntry) {
const byteLength = typeByteLength(entry.type) * entry.count;
if (byteLength <= 4) return entry.entryOffset + 8;
return entry.valueOffset;
}
private ascii(entry: IfdEntry) {
const relativeOffset = this.dataRelativeOffset(entry);
const absoluteOffset = this.absolute(relativeOffset);
const byteLength = typeByteLength(entry.type) * entry.count;
this.ensureRange(absoluteOffset, byteLength);
const bytes = new Uint8Array(this.view.buffer, absoluteOffset, byteLength);
return new TextDecoder("ascii").decode(bytes).replace(/\0+$/g, "").trim();
}
private rational(relativeOffset: number) {
const numerator = this.uint32(relativeOffset);
const denominator = this.uint32(relativeOffset + 4);
if (denominator === 0) return null;
return numerator / denominator;
}
private rationals(entry: IfdEntry) {
const relativeOffset = this.dataRelativeOffset(entry);
const values: number[] = [];
for (let index = 0; index < entry.count; index += 1) {
const value = this.rational(relativeOffset + index * 8);
if (value === null) return null;
values.push(value);
}
return values;
}
private pointer(entry: IfdEntry | undefined) {
if (!entry || entry.type !== 4 || entry.count !== 1) return null;
return entry.valueOffset;
}
private parseDate(value: string | null) {
if (!value) return null;
const match = value.match(
/^(\d{4}):(\d{2}):(\d{2})[ T](\d{2}):(\d{2}):(\d{2})/,
);
if (!match) return null;
const [, year, month, day, hour, minute, second] = match;
if (!year || !month || !day || !hour || !minute || !second) return null;
const monthNumber = Number(month);
const dayNumber = Number(day);
const hourNumber = Number(hour);
const minuteNumber = Number(minute);
const secondNumber = Number(second);
if (
monthNumber < 1 ||
monthNumber > 12 ||
dayNumber < 1 ||
dayNumber > 31 ||
hourNumber > 23 ||
minuteNumber > 59 ||
secondNumber > 59
) {
return null;
}
return {
capturedAt: `${year}-${month}-${day}T${hour}:${minute}:${second}`,
dredgingDate: `${year}-${month}-${day}`,
};
}
private parseGps(entries: Map<number, IfdEntry>): GeoPoint | null {
const latitudeRefEntry = entries.get(0x0001);
const latitudeEntry = entries.get(0x0002);
const longitudeRefEntry = entries.get(0x0003);
const longitudeEntry = entries.get(0x0004);
if (
!latitudeRefEntry ||
!latitudeEntry ||
!longitudeRefEntry ||
!longitudeEntry
) {
return null;
}
const latitudeRef = this.ascii(latitudeRefEntry).toUpperCase();
const longitudeRef = this.ascii(longitudeRefEntry).toUpperCase();
const latitudeDms = this.rationals(latitudeEntry);
const longitudeDms = this.rationals(longitudeEntry);
if (
!latitudeDms ||
latitudeDms.length < 3 ||
!longitudeDms ||
longitudeDms.length < 3
) {
return null;
}
const toDecimal = (values: number[]) =>
(values[0] ?? 0) + (values[1] ?? 0) / 60 + (values[2] ?? 0) / 3600;
let latitude = toDecimal(latitudeDms);
let longitude = toDecimal(longitudeDms);
if (latitudeRef === "S") latitude *= -1;
if (longitudeRef === "W") longitude *= -1;
if (
!Number.isFinite(latitude) ||
!Number.isFinite(longitude) ||
latitude < -90 ||
latitude > 90 ||
longitude < -180 ||
longitude > 180
) {
return null;
}
return { latitude, longitude };
}
parse() {
const ifd0Offset = this.uint32(4);
const ifd0 = this.readIfd(ifd0Offset);
const exifIfdOffset = this.pointer(ifd0.get(EXIF_IFD_POINTER));
const exifIfd = exifIfdOffset === null ? null : this.readIfd(exifIfdOffset);
const gpsIfdOffset = this.pointer(ifd0.get(GPS_IFD_POINTER));
const gpsIfd = gpsIfdOffset === null ? null : this.readIfd(gpsIfdOffset);
const dateValue =
(exifIfd?.get(DATE_TIME_ORIGINAL)
? this.ascii(exifIfd.get(DATE_TIME_ORIGINAL)!)
: null) ??
(exifIfd?.get(DATE_TIME_DIGITIZED)
? this.ascii(exifIfd.get(DATE_TIME_DIGITIZED)!)
: null) ??
(ifd0.get(DATE_TIME) ? this.ascii(ifd0.get(DATE_TIME)!) : null);
return {
date: this.parseDate(dateValue),
location: gpsIfd ? this.parseGps(gpsIfd) : null,
};
}
}
const toMetadata = (
capturedAt: string | null,
dredgingDate: string | null,
location: GeoPoint | null,
unsupported = false,
): PhotoMetadata => {
let status: ExifStatus;
let message: string;
if (unsupported) {
status = "UNSUPPORTED";
message = "JPEG EXIF가 없어 준설일자와 위치를 직접 입력해야 합니다.";
} else if (dredgingDate && location) {
status = "COMPLETE";
message = "촬영일자와 GPS를 확인했습니다.";
} else if (!dredgingDate && !location) {
status = "MISSING_BOTH";
message = "촬영일자와 GPS가 없어 수동 입력이 필요합니다.";
} else if (!dredgingDate) {
status = "MISSING_DATE";
message = "촬영일자가 없어 준설일자를 직접 입력해야 합니다.";
} else {
status = "MISSING_GPS";
message = "GPS가 없어 지도에서 준설위치를 등록해야 합니다.";
}
return { capturedAt, dredgingDate, location, status, message };
};
/**
* 브라우저에서 즉시 보여 줄 JPEG EXIF 미리보기를 만든다.
* 서버는 저장 시 원본 첨부파일을 기준으로 동일 정보를 다시 검증해야 한다.
*/
export const readPhotoMetadata = async (file: File): Promise<PhotoMetadata> => {
if (file.type !== "image/jpeg" && !/\.jpe?g$/i.test(file.name)) {
return toMetadata(null, null, null, true);
}
try {
const buffer = await file.arrayBuffer();
const view = new DataView(buffer);
if (view.byteLength < 4 || view.getUint16(0, false) !== JPEG_START) {
return toMetadata(null, null, null, true);
}
let offset = 2;
while (offset + 4 <= view.byteLength) {
if (view.getUint8(offset) !== 0xff) break;
const marker = view.getUint8(offset + 1);
if (marker === 0xda || marker === 0xd9) break;
const segmentLength = view.getUint16(offset + 2, false);
if (segmentLength < 2 || offset + 2 + segmentLength > view.byteLength) {
break;
}
if (marker === APP1_MARKER) {
const exifStart = offset + 4;
const exifSignature =
exifStart + 6 <= view.byteLength
? String.fromCharCode(
view.getUint8(exifStart),
view.getUint8(exifStart + 1),
view.getUint8(exifStart + 2),
view.getUint8(exifStart + 3),
)
: "";
if (exifSignature === "Exif") {
const parsed = new TiffReader(buffer, exifStart + 6).parse();
return toMetadata(
parsed.date?.capturedAt ?? null,
parsed.date?.dredgingDate ?? null,
parsed.location,
);
}
}
offset += 2 + segmentLength;
}
} catch (error) {
console.warn("준설 사진 EXIF 분석 실패", error);
}
return toMetadata(null, null, null, false);
};