1752 lines
68 KiB
JavaScript
1752 lines
68 KiB
JavaScript
// ===== GLOBAL STATE =====
|
||
let currentImage = null;
|
||
let currentRectangles = [];
|
||
let currentCoordinateString = '';
|
||
let currentFileName = '';
|
||
let canvas = null;
|
||
let ctx = null;
|
||
|
||
let batchFiles = [];
|
||
let batchResults = [];
|
||
let isProcessingBatch = false;
|
||
let currentBatchDetailIndex = -1; // New State for tracking detail view
|
||
let detailCanvas = null;
|
||
let detailCtx = null;
|
||
let detailImage = null;
|
||
|
||
// ===== DETAIL CANVAS INTERACTION STATE (must be at top level, not TDZ) =====
|
||
let isDetailDragging = false;
|
||
let detailDragTargetIndex = -1;
|
||
let detailDragHandle = null;
|
||
let detailDragStartPoint = null;
|
||
let detailDragStartRect = null;
|
||
let isDetailDrawing = false;
|
||
let detailDrawStartPoint = null;
|
||
|
||
// ===== INITIALIZATION =====
|
||
// ===== FORMAT SETTINGS MANAGEMENT =====
|
||
const FormatManager = {
|
||
settings: {
|
||
coordFormat: '{tl_x}:{tl_y},{br_x}:{br_y}',
|
||
rotFormat: '{rot_x}:{rot_y}',
|
||
separator: ';'
|
||
},
|
||
|
||
// Load settings
|
||
load: function () {
|
||
const saved = localStorage.getItem('formatSettings_facial_v2');
|
||
console.log('🔧 FormatManager.load() - localStorage value:', saved);
|
||
if (saved) {
|
||
try {
|
||
const parsed = JSON.parse(saved);
|
||
if (parsed.coordFormat) this.settings.coordFormat = parsed.coordFormat;
|
||
if (parsed.rotFormat) this.settings.rotFormat = parsed.rotFormat;
|
||
if (parsed.separator) this.settings.separator = parsed.separator;
|
||
console.log('✅ Loaded custom settings:', this.settings);
|
||
} catch (e) { console.error('Error loading settings', e); }
|
||
} else {
|
||
console.log('ℹ️ No saved settings found (v2), using defaults:', this.settings);
|
||
}
|
||
this.applyToUI();
|
||
},
|
||
|
||
// Save settings
|
||
save: function () {
|
||
this.settings.coordFormat = document.getElementById('coordFormat').value || '{tl_x}:{tl_y},{br_x}:{br_y}';
|
||
this.settings.rotFormat = document.getElementById('rotFormat').value || '{rot_x}:{rot_y}';
|
||
this.settings.separator = document.getElementById('sepFrame').value || ';';
|
||
|
||
localStorage.setItem('formatSettings_facial_v2', JSON.stringify(this.settings));
|
||
this.updatePreview();
|
||
},
|
||
|
||
// Apply values to UI inputs
|
||
applyToUI: function () {
|
||
const coordInput = document.getElementById('coordFormat');
|
||
const rotInput = document.getElementById('rotFormat');
|
||
const sepInput = document.getElementById('sepFrame');
|
||
|
||
if(coordInput) coordInput.value = this.settings.coordFormat;
|
||
if(rotInput) rotInput.value = this.settings.rotFormat;
|
||
if(sepInput) sepInput.value = this.settings.separator;
|
||
|
||
// Add listeners for live preview
|
||
[coordInput, rotInput, sepInput].forEach(el => {
|
||
if(el) el.addEventListener('input', () => this.updatePreview(true));
|
||
});
|
||
|
||
this.updatePreview();
|
||
},
|
||
|
||
// Generate Formats Object { coord, rot }
|
||
generateFormats: function (rectangles) {
|
||
if (!rectangles || rectangles.length === 0) return { coord: '', rot: '' };
|
||
|
||
const coordStrings = [];
|
||
const rotStrings = [];
|
||
|
||
// UI inputs might be live (during preview) or settings (during final gen)
|
||
// actually let's always use `this.settings` for consistency,
|
||
// but `updatePreview` will temporarily override or pass custom.
|
||
// For now, simpler: always read from settings which are updated on Save.
|
||
// But for live preview, we want to read from inputs.
|
||
// Let's rely on `this.settings` being current.
|
||
|
||
const cFmt = this.settings.coordFormat;
|
||
const rFmt = this.settings.rotFormat;
|
||
|
||
rectangles.forEach(rect => {
|
||
const corners = rect.corners || {
|
||
top_left: {x: rect.x, y: rect.y},
|
||
top_right: {x: rect.x + rect.width, y: rect.y},
|
||
bottom_right: {x: rect.x + rect.width, y: rect.y + rect.height},
|
||
bottom_left: {x: rect.x, y: rect.y + rect.height}
|
||
};
|
||
const rot = rect.rotation_point || {x: 0, y: 0};
|
||
|
||
// Helper to replace
|
||
const replacer = (fmt) => {
|
||
return fmt
|
||
.replace(/{tl_x}/g, corners.top_left.x)
|
||
.replace(/{tl_y}/g, corners.top_left.y)
|
||
.replace(/{tr_x}/g, corners.top_right.x)
|
||
.replace(/{tr_y}/g, corners.top_right.y)
|
||
.replace(/{br_x}/g, corners.bottom_right.x)
|
||
.replace(/{br_y}/g, corners.bottom_right.y)
|
||
.replace(/{bl_x}/g, corners.bottom_left.x)
|
||
.replace(/{bl_y}/g, corners.bottom_left.y)
|
||
.replace(/{rot_x}/g, rot.x)
|
||
.replace(/{rot_y}/g, rot.y)
|
||
.replace(/{width}/g, rect.width)
|
||
.replace(/{height}/g, rect.height)
|
||
.replace(/{angle}/g, rect.angle !== undefined ? rect.angle : 0);
|
||
};
|
||
|
||
coordStrings.push(replacer(cFmt));
|
||
rotStrings.push(replacer(rFmt));
|
||
});
|
||
|
||
const sep = this.settings.separator;
|
||
return {
|
||
coord: coordStrings.join(sep),
|
||
rot: rotStrings.join(sep)
|
||
};
|
||
},
|
||
|
||
// Generates format based on CURRENT INPUTS (for live preview)
|
||
generatePreviewFormats: function(rectangles) {
|
||
const cFmt = document.getElementById('coordFormat').value || '';
|
||
const rFmt = document.getElementById('rotFormat').value || '';
|
||
const sep = document.getElementById('sepFrame').value || ';';
|
||
|
||
const coordStrings = [];
|
||
const rotStrings = [];
|
||
|
||
rectangles.forEach(rect => {
|
||
const corners = rect.corners || {
|
||
top_left: {x: rect.x, y: rect.y},
|
||
top_right: {x: rect.x + rect.width, y: rect.y},
|
||
bottom_right: {x: rect.x + rect.width, y: rect.y + rect.height},
|
||
bottom_left: {x: rect.x, y: rect.y + rect.height}
|
||
};
|
||
const rot = rect.rotation_point || {x: 0, y: 0};
|
||
|
||
const replacer = (fmt) => {
|
||
return fmt
|
||
.replace(/{tl_x}/g, corners.top_left.x)
|
||
.replace(/{tl_y}/g, corners.top_left.y)
|
||
.replace(/{tr_x}/g, corners.top_right.x)
|
||
.replace(/{tr_y}/g, corners.top_right.y)
|
||
.replace(/{br_x}/g, corners.bottom_right.x)
|
||
.replace(/{br_y}/g, corners.bottom_right.y)
|
||
.replace(/{bl_x}/g, corners.bottom_left.x)
|
||
.replace(/{bl_y}/g, corners.bottom_left.y)
|
||
.replace(/{rot_x}/g, rot.x)
|
||
.replace(/{rot_y}/g, rot.y)
|
||
.replace(/{width}/g, rect.width)
|
||
.replace(/{height}/g, rect.height)
|
||
.replace(/{angle}/g, rect.angle !== undefined ? rect.angle : 0);
|
||
};
|
||
|
||
coordStrings.push(replacer(cFmt));
|
||
rotStrings.push(replacer(rFmt));
|
||
});
|
||
|
||
return {
|
||
coord: coordStrings.join(sep),
|
||
rot: rotStrings.join(sep)
|
||
};
|
||
},
|
||
|
||
updatePreview: function (isLive = false) {
|
||
const mockRects = [{
|
||
x: 100, y: 100, width: 200, height: 200,
|
||
corners: {
|
||
top_left: { x: 100, y: 100 },
|
||
top_right: { x: 300, y: 100 },
|
||
bottom_right: { x: 300, y: 300 },
|
||
bottom_left: { x: 100, y: 300 }
|
||
},
|
||
rotation_point: { x: 200, y: 300 }
|
||
}];
|
||
|
||
let result;
|
||
if(isLive) {
|
||
result = this.generatePreviewFormats(mockRects);
|
||
} else {
|
||
result = this.generateFormats(mockRects);
|
||
}
|
||
|
||
const previewEl = document.getElementById('formatPreview');
|
||
if(previewEl) {
|
||
previewEl.innerHTML = `<div style="margin-bottom:5px;"><strong>C:</strong> ${result.coord}</div><div><strong>R:</strong> ${result.rot}</div>`;
|
||
}
|
||
}
|
||
};
|
||
document.addEventListener('DOMContentLoaded', function () {
|
||
// Initialize canvas
|
||
canvas = document.getElementById('imageCanvas');
|
||
ctx = canvas.getContext('2d');
|
||
|
||
// Initialize Detail Canvas
|
||
detailCanvas = document.getElementById('detailCanvas');
|
||
detailCtx = detailCanvas.getContext('2d');
|
||
|
||
// Setup event listeners
|
||
setupEventListeners();
|
||
|
||
// Setup detail canvas interactions (must be after detailCanvas is assigned)
|
||
setupDetailInteractions();
|
||
|
||
// Load format settings from localStorage
|
||
FormatManager.load();
|
||
|
||
// Load initial results
|
||
loadResults();
|
||
|
||
// Check server health
|
||
checkServerHealth();
|
||
});
|
||
|
||
// ===== EVENT LISTENERS SETUP =====
|
||
function setupEventListeners() {
|
||
// File input
|
||
const fileInput = document.getElementById('fileInput');
|
||
if (fileInput) {
|
||
fileInput.addEventListener('change', handleFileSelect);
|
||
}
|
||
|
||
// Folder input
|
||
const folderInput = document.getElementById('folderInput');
|
||
if (folderInput) {
|
||
folderInput.addEventListener('change', handleFolderSelect);
|
||
}
|
||
|
||
// Drag and drop
|
||
const uploadArea = document.getElementById('uploadArea');
|
||
if (uploadArea) {
|
||
uploadArea.addEventListener('dragover', handleDragOver);
|
||
uploadArea.addEventListener('dragleave', handleDragLeave);
|
||
uploadArea.addEventListener('drop', handleDrop);
|
||
}
|
||
}
|
||
|
||
// ===== DRAG AND DROP HANDLERS =====
|
||
function handleDragOver(e) {
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
e.currentTarget.classList.add('drag-over');
|
||
}
|
||
|
||
function handleDragLeave(e) {
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
e.currentTarget.classList.remove('drag-over');
|
||
}
|
||
|
||
function handleDrop(e) {
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
e.currentTarget.classList.remove('drag-over');
|
||
|
||
const files = e.dataTransfer.files;
|
||
if (files.length > 0) {
|
||
const file = files[0];
|
||
if (file.type.startsWith('image/')) {
|
||
loadImageFile(file);
|
||
} else {
|
||
showMessage('Please drop an image file', 'error');
|
||
}
|
||
}
|
||
}
|
||
|
||
// ===== FILE HANDLING =====
|
||
function handleFileSelect(e) {
|
||
const file = e.target.files[0];
|
||
if (file) {
|
||
loadImageFile(file);
|
||
}
|
||
}
|
||
|
||
function handleFolderSelect(e) {
|
||
const files = Array.from(e.target.files);
|
||
batchFiles = files.filter(file => file.type.startsWith('image/'));
|
||
|
||
if (batchFiles.length > 0) {
|
||
const folderName = batchFiles[0].webkitRelativePath.split('/')[0];
|
||
document.getElementById('batchStatus').innerHTML = `
|
||
<i class="fas fa-folder" style="color: #667eea;"></i>
|
||
<strong>Selected Folder:</strong> ${folderName}<br>
|
||
<strong>Images Found:</strong> ${batchFiles.length} files
|
||
`;
|
||
document.getElementById('progressContainer').style.display = 'block';
|
||
document.getElementById('batchResults').style.display = 'block';
|
||
document.getElementById('batchResultsList').innerHTML = '';
|
||
|
||
showMessage(`Found ${batchFiles.length} images in folder`, 'info');
|
||
} else {
|
||
showMessage('No image files found in selected folder', 'error');
|
||
}
|
||
}
|
||
|
||
function loadImageFile(file) {
|
||
const reader = new FileReader();
|
||
reader.onload = function (e) {
|
||
const img = new Image();
|
||
img.onload = function () {
|
||
displayImage(img);
|
||
currentFileName = file.name;
|
||
};
|
||
img.onerror = function () {
|
||
showMessage('Failed to load image', 'error');
|
||
};
|
||
img.src = e.target.result;
|
||
};
|
||
reader.readAsDataURL(file);
|
||
}
|
||
|
||
function displayImage(img) {
|
||
currentImage = img;
|
||
canvas.width = img.width;
|
||
canvas.height = img.height;
|
||
ctx.clearRect(0, 0, canvas.width, canvas.height);
|
||
ctx.drawImage(img, 0, 0);
|
||
|
||
document.getElementById('emptyState').style.display = 'none';
|
||
canvas.style.display = 'block';
|
||
|
||
currentRectangles = [];
|
||
updateCoordinatesList();
|
||
showMessage('Image loaded successfully', 'info');
|
||
}
|
||
|
||
// ===== IMAGE ANALYSIS =====
|
||
// ===== INTERACTION STATE =====
|
||
let isDragging = false;
|
||
let dragTargetIndex = -1;
|
||
let dragHandle = null; // 'tl','tr','bl','br','rot','body','img'
|
||
let dragStartPoint = null;
|
||
let dragStartRect = null;
|
||
let isDrawing = false;
|
||
let drawStartPoint = null;
|
||
|
||
// ===== IMAGE ANALYSIS =====
|
||
function analyzeImage() {
|
||
if (!currentImage) {
|
||
showMessage('Please select an image first', 'error');
|
||
return;
|
||
}
|
||
|
||
showLoading(true);
|
||
const analyzeBtn = document.getElementById('analyzeBtn');
|
||
analyzeBtn.disabled = true;
|
||
|
||
canvas.toBlob(function (blob) {
|
||
if (!blob) {
|
||
showMessage('Failed to process image', 'error');
|
||
showLoading(false);
|
||
analyzeBtn.disabled = false;
|
||
return;
|
||
}
|
||
|
||
const formData = new FormData();
|
||
formData.append('file', blob, currentFileName || 'image.png');
|
||
const minF = document.getElementById('minFaces');
|
||
const maxF = document.getElementById('maxFaces');
|
||
const confT = document.getElementById('confThreshold');
|
||
if (minF) formData.append('min_faces', minF.value || 0);
|
||
if (maxF) formData.append('max_faces', maxF.value || 0);
|
||
if (confT) formData.append('conf_threshold', confT.value || 0.15);
|
||
|
||
fetch('/upload', {
|
||
method: 'POST',
|
||
body: formData
|
||
})
|
||
.then(response => {
|
||
if (!response.ok) {
|
||
throw new Error(`HTTP error! status: ${response.status}`);
|
||
}
|
||
return response.json();
|
||
})
|
||
.then(data => {
|
||
if (data.success) {
|
||
currentRectangles = data.rectangles || [];
|
||
currentCoordinateString = data.coordinate_string || '';
|
||
|
||
if (currentRectangles.length > 0) {
|
||
currentRectangles.forEach((rect, idx) => {
|
||
if (!rect.id) rect.id = idx + 1;
|
||
if (!rect.shape_type) rect.shape_type = 'Face';
|
||
if (!rect.color) rect.color = { hex: '#00FF00' };
|
||
});
|
||
// Switch to client-side rendering for interactivity
|
||
redrawCanvas();
|
||
|
||
updateCoordinatesList();
|
||
document.getElementById('saveBtn').disabled = false;
|
||
showMessage(`Found ${currentRectangles.length} face(s)`, 'success');
|
||
} else {
|
||
showMessage('No faces detected', 'error');
|
||
redrawCanvas();
|
||
updateCoordinatesList();
|
||
}
|
||
} else {
|
||
showMessage(data.error || 'Analysis failed', 'error');
|
||
}
|
||
})
|
||
.catch(error => {
|
||
console.error('Error:', error);
|
||
showMessage('Error: ' + error.message, 'error');
|
||
})
|
||
.finally(() => {
|
||
showLoading(false);
|
||
analyzeBtn.disabled = false;
|
||
});
|
||
}, 'image/png');
|
||
}
|
||
|
||
function redrawCanvas() {
|
||
if (!currentImage) return;
|
||
|
||
ctx.clearRect(0, 0, canvas.width, canvas.height);
|
||
ctx.drawImage(currentImage, 0, 0);
|
||
|
||
// Calculate visual scale for handles
|
||
const rect = canvas.getBoundingClientRect();
|
||
const scale = canvas.width / rect.width;
|
||
const hSize = 12 * scale; // 12px visual size
|
||
const lineWidth = Math.max(2 * scale, 2);
|
||
|
||
currentRectangles.forEach((rect, i) => {
|
||
// Draw Box
|
||
ctx.beginPath();
|
||
ctx.rect(rect.x, rect.y, rect.width, rect.height);
|
||
ctx.lineWidth = lineWidth;
|
||
ctx.strokeStyle = '#00FF00';
|
||
ctx.stroke();
|
||
|
||
// Draw Handles (Corners)
|
||
ctx.fillStyle = '#00FF00';
|
||
// TL
|
||
ctx.fillRect(rect.x - hSize/2, rect.y - hSize/2, hSize, hSize);
|
||
// TR
|
||
ctx.fillRect(rect.x + rect.width - hSize/2, rect.y - hSize/2, hSize, hSize);
|
||
// BR
|
||
ctx.fillRect(rect.x + rect.width - hSize/2, rect.y + rect.height - hSize/2, hSize, hSize);
|
||
// BL
|
||
ctx.fillRect(rect.x - hSize/2, rect.y + rect.height - hSize/2, hSize, hSize);
|
||
|
||
// Rotation Point
|
||
if (rect.rotation_point) {
|
||
ctx.beginPath();
|
||
ctx.arc(rect.rotation_point.x, rect.rotation_point.y, hSize/2, 0, 2 * Math.PI);
|
||
ctx.fillStyle = '#FF0000';
|
||
ctx.fill();
|
||
// Highlight rotation point handle
|
||
ctx.strokeStyle = '#FFFFFF';
|
||
ctx.lineWidth = 1 * scale;
|
||
ctx.stroke();
|
||
}
|
||
});
|
||
|
||
// Draw temporary box if drawing
|
||
if (isDrawing && drawStartPoint && dragStartPoint) {
|
||
const w = dragStartPoint.x - drawStartPoint.x;
|
||
const h = dragStartPoint.y - drawStartPoint.y;
|
||
ctx.beginPath();
|
||
ctx.rect(drawStartPoint.x, drawStartPoint.y, w, h);
|
||
ctx.lineWidth = lineWidth;
|
||
ctx.strokeStyle = '#FFFF00';
|
||
ctx.setLineDash([5 * scale, 5 * scale]);
|
||
ctx.stroke();
|
||
ctx.setLineDash([]);
|
||
}
|
||
}
|
||
|
||
// ===== CANVAS INTERACTION =====
|
||
function toggleCreateMode() {
|
||
isDrawing = !isDrawing;
|
||
const btn = document.getElementById('addBoxBtn');
|
||
if (isDrawing) {
|
||
btn.classList.add('active');
|
||
canvas.style.cursor = 'crosshair';
|
||
showMessage('Draw a box on the image', 'info');
|
||
} else {
|
||
btn.classList.remove('active');
|
||
canvas.style.cursor = 'default';
|
||
showMessage('Edit mode', 'info');
|
||
}
|
||
}
|
||
|
||
function getMousePos(canvas, evt) {
|
||
const rect = canvas.getBoundingClientRect();
|
||
const scaleX = canvas.width / rect.width;
|
||
const scaleY = canvas.height / rect.height;
|
||
return {
|
||
x: (evt.clientX - rect.left) * scaleX,
|
||
y: (evt.clientY - rect.top) * scaleY
|
||
};
|
||
}
|
||
|
||
canvas.addEventListener('mousedown', function (e) {
|
||
if (!currentImage) return;
|
||
const pos = getMousePos(canvas, e);
|
||
const rectBounds = canvas.getBoundingClientRect();
|
||
const scale = canvas.width / rectBounds.width;
|
||
const hSize = 14 * scale; // Slightly larger hit area
|
||
|
||
// Check if hitting existing handles or body
|
||
// Reverse order to check top-most first
|
||
let hitFound = false;
|
||
for (let i = currentRectangles.length - 1; i >= 0; i--) {
|
||
const rect = currentRectangles[i];
|
||
|
||
// Check Rotation Point
|
||
if (rect.rotation_point) {
|
||
const dx = pos.x - rect.rotation_point.x;
|
||
const dy = pos.y - rect.rotation_point.y;
|
||
// Radius check including scale
|
||
if (dx*dx + dy*dy <= (hSize/2 * 1.5)**2) {
|
||
isDragging = true;
|
||
dragTargetIndex = i;
|
||
dragHandle = 'rot';
|
||
hitFound = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Check Corners
|
||
// TL
|
||
if (Math.abs(pos.x - (rect.x)) < hSize && Math.abs(pos.y - (rect.y)) < hSize) {
|
||
isDragging = true; dragTargetIndex = i; dragHandle = 'tl'; hitFound = true; break;
|
||
}
|
||
// TR
|
||
if (Math.abs(pos.x - (rect.x + rect.width)) < hSize && Math.abs(pos.y - (rect.y)) < hSize) {
|
||
isDragging = true; dragTargetIndex = i; dragHandle = 'tr'; hitFound = true; break;
|
||
}
|
||
// BR
|
||
if (Math.abs(pos.x - (rect.x + rect.width)) < hSize && Math.abs(pos.y - (rect.y + rect.height)) < hSize) {
|
||
isDragging = true; dragTargetIndex = i; dragHandle = 'br'; hitFound = true; break;
|
||
}
|
||
// BL
|
||
if (Math.abs(pos.x - (rect.x)) < hSize && Math.abs(pos.y - (rect.y + rect.height)) < hSize) {
|
||
isDragging = true; dragTargetIndex = i; dragHandle = 'bl'; hitFound = true; break;
|
||
}
|
||
|
||
// Check Body (Move)
|
||
if (pos.x >= rect.x && pos.x <= rect.x + rect.width && pos.y >= rect.y && pos.y <= rect.y + rect.height) {
|
||
isDragging = true;
|
||
dragTargetIndex = i;
|
||
dragHandle = 'body';
|
||
dragStartPoint = pos; // For delta calculation
|
||
dragStartRect = { ...rect, rotation_point: { ...rect.rotation_point } };
|
||
hitFound = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!hitFound && isDrawing) {
|
||
// Start Drawing
|
||
isDragging = true;
|
||
dragHandle = 'draw';
|
||
drawStartPoint = pos;
|
||
dragStartPoint = pos; // Current end point
|
||
}
|
||
});
|
||
|
||
canvas.addEventListener('mousemove', function (e) {
|
||
if (!currentImage) return;
|
||
const pos = getMousePos(canvas, e);
|
||
const rectBounds = canvas.getBoundingClientRect();
|
||
const scale = canvas.width / rectBounds.width;
|
||
const hSize = 14 * scale;
|
||
|
||
// Update Cursor and Hover State if not dragging
|
||
if (!isDragging) {
|
||
let cursor = isDrawing ? 'crosshair' : 'default';
|
||
for (let i = currentRectangles.length - 1; i >= 0; i--) {
|
||
const rect = currentRectangles[i];
|
||
// TL/BR
|
||
if ((Math.abs(pos.x - rect.x) < hSize && Math.abs(pos.y - rect.y) < hSize) ||
|
||
(Math.abs(pos.x - (rect.x + rect.width)) < hSize && Math.abs(pos.y - (rect.y + rect.height)) < hSize)) {
|
||
cursor = 'nwse-resize';
|
||
}
|
||
// TR/BL
|
||
else if ((Math.abs(pos.x - (rect.x + rect.width)) < hSize && Math.abs(pos.y - rect.y) < hSize) ||
|
||
(Math.abs(pos.x - rect.x) < hSize && Math.abs(pos.y - (rect.y + rect.height)) < hSize)) {
|
||
cursor = 'nesw-resize';
|
||
}
|
||
// Rot
|
||
else if (rect.rotation_point) {
|
||
const dx = pos.x - rect.rotation_point.x;
|
||
const dy = pos.y - rect.rotation_point.y;
|
||
if (dx*dx + dy*dy <= (hSize/2 * 1.5)**2) cursor = 'move';
|
||
}
|
||
// Body
|
||
else if (cursor === 'default' && pos.x >= rect.x && pos.x <= rect.x + rect.width && pos.y >= rect.y && pos.y <= rect.y + rect.height) {
|
||
cursor = 'move';
|
||
}
|
||
}
|
||
canvas.style.cursor = cursor;
|
||
return;
|
||
}
|
||
|
||
// Handle Dragging
|
||
if (dragHandle === 'draw') {
|
||
dragStartPoint = pos; // Update end point
|
||
redrawCanvas();
|
||
return;
|
||
}
|
||
|
||
const rect = currentRectangles[dragTargetIndex];
|
||
if (!rect) return;
|
||
|
||
if (dragHandle === 'rot') {
|
||
rect.rotation_point.x = Math.round(pos.x);
|
||
rect.rotation_point.y = Math.round(pos.y);
|
||
} else if (dragHandle === 'body') {
|
||
const dx = pos.x - dragStartPoint.x;
|
||
const dy = pos.y - dragStartPoint.y;
|
||
rect.x = Math.round(dragStartRect.x + dx);
|
||
rect.y = Math.round(dragStartRect.y + dy);
|
||
rect.rotation_point.x = Math.round(dragStartRect.rotation_point.x + dx);
|
||
rect.rotation_point.y = Math.round(dragStartRect.rotation_point.y + dy);
|
||
// Correct corners/bbox? rect.x/y is x1, y1.
|
||
// We shouldn't exceed canvas bounds?
|
||
} else {
|
||
// Resizing
|
||
// Preserve rotation point relative position? Or fixed? User didn't specify.
|
||
// Usually fixed is safer unless scaled. I'll leave it fixed for now, simplest.
|
||
|
||
if (dragHandle === 'tl') {
|
||
const maxX = rect.x + rect.width - 10;
|
||
const maxY = rect.y + rect.height - 10;
|
||
const newX = Math.min(pos.x, maxX);
|
||
const newY = Math.min(pos.y, maxY);
|
||
rect.width += (rect.x - newX);
|
||
rect.height += (rect.y - newY);
|
||
rect.x = newX;
|
||
rect.y = newY;
|
||
} else if (dragHandle === 'tr') {
|
||
const minX = rect.x + 10;
|
||
const maxY = rect.y + rect.height - 10;
|
||
const newW = Math.max(pos.x - rect.x, 10);
|
||
const newY = Math.min(pos.y, maxY);
|
||
rect.height += (rect.y - newY);
|
||
rect.y = newY;
|
||
rect.width = newW;
|
||
} else if (dragHandle === 'bl') {
|
||
const maxX = rect.x + rect.width - 10;
|
||
const newX = Math.min(pos.x, maxX);
|
||
const newH = Math.max(pos.y - rect.y, 10);
|
||
rect.width += (rect.x - newX);
|
||
rect.x = newX;
|
||
rect.height = newH;
|
||
} else if (dragHandle === 'br') {
|
||
rect.width = Math.max(pos.x - rect.x, 10);
|
||
rect.height = Math.max(pos.y - rect.y, 10);
|
||
}
|
||
|
||
rect.x = Math.round(rect.x);
|
||
rect.y = Math.round(rect.y);
|
||
rect.width = Math.round(rect.width);
|
||
rect.height = Math.round(rect.height);
|
||
|
||
// Update corners struct if it exists (for backend compat)?
|
||
// Backend returns corners logic, but formatted string is what matters.
|
||
// `FormatManager` uses `rect.corners` or calculates from x,y,w,h?
|
||
// Wait, `FormatManager` uses `rect.corners.top_left` etc.
|
||
// I MUST update `rect.corners` too!
|
||
rect.corners = {
|
||
top_left: { x: rect.x, y: rect.y },
|
||
top_right: { x: rect.x + rect.width, y: rect.y },
|
||
bottom_right: { x: rect.x + rect.width, y: rect.y + rect.height },
|
||
bottom_left: { x: rect.x, y: rect.y + rect.height }
|
||
};
|
||
}
|
||
|
||
redrawCanvas();
|
||
});
|
||
|
||
canvas.addEventListener('mouseup', function (e) {
|
||
if (!isDragging) return;
|
||
|
||
if (dragHandle === 'draw' && drawStartPoint && dragStartPoint) {
|
||
// Finalize new box
|
||
const x = Math.min(drawStartPoint.x, dragStartPoint.x);
|
||
const y = Math.min(drawStartPoint.y, dragStartPoint.y);
|
||
const w = Math.abs(drawStartPoint.x - dragStartPoint.x);
|
||
const h = Math.abs(drawStartPoint.y - dragStartPoint.y);
|
||
|
||
if (w > 10 && h > 10) {
|
||
const newRect = {
|
||
id: currentRectangles.length + 1,
|
||
shape_type: 'Face',
|
||
box_2d: [x, y, x + w, y + h], // Format matching backend
|
||
x: Math.round(x),
|
||
y: Math.round(y),
|
||
width: Math.round(w),
|
||
height: Math.round(h),
|
||
rotation_point: { x: Math.round(x + w/2), y: Math.round(y + h/2) },
|
||
corners: {
|
||
top_left: { x: Math.round(x), y: Math.round(y) },
|
||
top_right: { x: Math.round(x + w), y: Math.round(y) },
|
||
bottom_right: { x: Math.round(x + w), y: Math.round(y + h) },
|
||
bottom_left: { x: Math.round(x), y: Math.round(y + h) }
|
||
},
|
||
color: { hex: '#00FF00' }
|
||
};
|
||
currentRectangles.push(newRect);
|
||
showMessage('New box added', 'success');
|
||
|
||
// Turn off create mode
|
||
toggleCreateMode();
|
||
}
|
||
}
|
||
|
||
// For Edits (resize/move), we already updated `rect` in real-time.
|
||
// Just sync UI list.
|
||
updateCoordinatesList();
|
||
|
||
isDragging = false;
|
||
dragHandle = null;
|
||
dragTargetIndex = -1;
|
||
drawStartPoint = null;
|
||
dragStartPoint = null;
|
||
redrawCanvas();
|
||
});
|
||
|
||
// ===== COORDINATES DISPLAY =====
|
||
function updateCoordinatesList() {
|
||
const listElement = document.getElementById('coordinatesList');
|
||
|
||
if (!currentRectangles || currentRectangles.length === 0) {
|
||
listElement.innerHTML = `
|
||
<div class="empty-state">
|
||
<i class="fas fa-times-circle"></i>
|
||
<p>No faces detected</p>
|
||
</div>
|
||
`;
|
||
return;
|
||
}
|
||
|
||
let html = '';
|
||
currentRectangles.forEach((rect, index) => {
|
||
if (!rect.id) rect.id = index + 1;
|
||
if (!rect.shape_type) rect.shape_type = 'Face';
|
||
if (!rect.color) rect.color = { hex: '#00FF00' };
|
||
|
||
// Generate coordinate string using FormatManager for consistency
|
||
const formats = FormatManager.generateFormats([rect]);
|
||
// Use labels and newlines for clear separation
|
||
let displayStr = `<div class="coord-field"><span class="field-label">C:</span> ${formats.coord}</div>`;
|
||
if (formats.rot) {
|
||
displayStr += `<div class="coord-field"><span class="field-label">R:</span> ${formats.rot}</div>`;
|
||
}
|
||
|
||
html += `
|
||
<div class="coord-item">
|
||
<div style="display:flex; justify-content:space-between; align-items:flex-start;">
|
||
<div>
|
||
<span class="color-dot" style="background-color: ${rect.color.hex};"></span>
|
||
<strong>${rect.shape_type} ${rect.id}</strong>
|
||
</div>
|
||
<button onclick="removeFace(${index})" title="Delete Face" style="background:none; border:none; color:#ff4444; cursor:pointer;">
|
||
<i class="fas fa-trash"></i>
|
||
</button>
|
||
</div>
|
||
<div style="margin-bottom: 4px;">
|
||
<span style="font-size: 11px; color: #6c757d;">${rect.width}×${rect.height}px</span>
|
||
</div>
|
||
<div class="coord-string" style="display:flex; flex-direction:column; gap:2px;">${displayStr}</div>
|
||
</div>
|
||
`;
|
||
});
|
||
|
||
listElement.innerHTML = html;
|
||
}
|
||
|
||
function removeFace(index) {
|
||
if (!confirm('Delete this face? It will not be saved.')) return;
|
||
|
||
currentRectangles.splice(index, 1);
|
||
updateCoordinatesList();
|
||
showMessage('Face removed from list. It will not be saved.', 'info');
|
||
|
||
// Optional: Redraw canvas to remove the baked-in box if possible
|
||
if (currentImage) {
|
||
// Clear and draw original
|
||
ctx.clearRect(0, 0, canvas.width, canvas.height);
|
||
ctx.drawImage(currentImage, 0, 0);
|
||
|
||
// Draw remaining boxes using JS
|
||
currentRectangles.forEach(rect => {
|
||
// Box
|
||
ctx.beginPath();
|
||
ctx.rect(rect.x, rect.y, rect.width, rect.height);
|
||
ctx.lineWidth = 2;
|
||
ctx.strokeStyle = '#00FF00';
|
||
ctx.stroke();
|
||
|
||
// Rotation Point
|
||
if (rect.rotation_point) {
|
||
ctx.beginPath();
|
||
ctx.arc(rect.rotation_point.x, rect.rotation_point.y, 4, 0, 2 * Math.PI);
|
||
ctx.fillStyle = '#FF0000';
|
||
ctx.fill();
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
// ===== SAVE OPERATIONS =====
|
||
// ===== SAVE OPERATIONS =====
|
||
function saveCoordinates() {
|
||
try {
|
||
// Generate flexible string
|
||
const formats = FormatManager.generateFormats(currentRectangles);
|
||
|
||
console.log('💾 Saving coordinates:', formats);
|
||
|
||
if (!formats.coord && !formats.rot) {
|
||
showMessage('No coordinates to save', 'error');
|
||
return;
|
||
}
|
||
|
||
showLoading(true);
|
||
|
||
fetch('/save_coordinates', {
|
||
method: 'POST',
|
||
headers: {
|
||
'Content-Type': 'application/json',
|
||
},
|
||
body: JSON.stringify({
|
||
image_name: currentFileName,
|
||
coordinate_string: formats.coord,
|
||
rotation_string: formats.rot,
|
||
rectangles: currentRectangles
|
||
})
|
||
})
|
||
.then(response => {
|
||
if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
|
||
return response.json();
|
||
})
|
||
.then(data => {
|
||
if (data.success) {
|
||
showMessage('Coordinates saved successfully!', 'success');
|
||
loadResults();
|
||
} else {
|
||
showMessage(data.error || 'Failed to save', 'error');
|
||
}
|
||
})
|
||
.catch(error => {
|
||
console.error('Error in save fetch:', error);
|
||
showMessage('Error: ' + error.message, 'error');
|
||
})
|
||
.finally(() => {
|
||
console.log('Save operation finished, hiding loader');
|
||
showLoading(false);
|
||
});
|
||
} catch (e) {
|
||
console.error('Synchronous error in saveCoordinates:', e);
|
||
showLoading(false);
|
||
showMessage('Error preparing save data', 'error');
|
||
}
|
||
}
|
||
|
||
// ===== BATCH PROCESSING =====
|
||
function startBatchProcessing() {
|
||
if (batchFiles.length === 0) {
|
||
showMessage('Please select a folder first', 'error');
|
||
return;
|
||
}
|
||
|
||
if (isProcessingBatch) {
|
||
showMessage('Batch processing already in progress', 'error');
|
||
return;
|
||
}
|
||
|
||
isProcessingBatch = true;
|
||
batchResults = [];
|
||
document.getElementById('batchStartBtn').disabled = true;
|
||
document.getElementById('saveAllBtn').disabled = true;
|
||
document.getElementById('batchResultsList').innerHTML = '';
|
||
|
||
const totalFiles = batchFiles.length;
|
||
let processedFiles = 0;
|
||
let successfulFiles = 0;
|
||
|
||
updateProgress(totalFiles, 0, 0);
|
||
|
||
function processNextFile(index) {
|
||
if (index >= totalFiles) {
|
||
isProcessingBatch = false;
|
||
document.getElementById('batchStartBtn').disabled = false;
|
||
if (batchResults.length > 0) {
|
||
document.getElementById('saveAllBtn').disabled = false;
|
||
}
|
||
|
||
showMessage(`Batch complete: ${successfulFiles}/${totalFiles} successful`, 'success');
|
||
return;
|
||
}
|
||
|
||
const file = batchFiles[index];
|
||
const formData = new FormData();
|
||
formData.append('file', file);
|
||
const minF = document.getElementById('minFaces');
|
||
const maxF = document.getElementById('maxFaces');
|
||
const confT = document.getElementById('confThreshold');
|
||
if (minF) formData.append('min_faces', minF.value || 0);
|
||
if (maxF) formData.append('max_faces', maxF.value || 0);
|
||
if (confT) formData.append('conf_threshold', confT.value || 0.15);
|
||
|
||
fetch('/upload', {
|
||
method: 'POST',
|
||
body: formData
|
||
})
|
||
.then(response => response.json())
|
||
.then(data => {
|
||
processedFiles++;
|
||
|
||
const resultItem = document.createElement('div');
|
||
resultItem.className = 'batch-item';
|
||
|
||
if (data.success && data.rectangles) {
|
||
successfulFiles++;
|
||
|
||
// Show device info once at the start of batch
|
||
if (processedFiles === 1) {
|
||
const deviceMsg = data.device === 'cuda' ? 'GPU (CUDA)' : 'CPU';
|
||
showMessage(`Batch started using ${deviceMsg}`, 'success');
|
||
}
|
||
|
||
// Generate formatted coordinate string using FormatManager
|
||
const formats = FormatManager.generateFormats(data.rectangles);
|
||
const displayStr = formats.rot ? `${formats.coord}<br>${formats.rot}` : formats.coord;
|
||
|
||
batchResults.push({
|
||
filename: file.name,
|
||
warning: data.warning || null,
|
||
coordinates: formats.coord,
|
||
rotations: formats.rot,
|
||
rectangles: data.rectangles,
|
||
image_url: data.image_url,
|
||
original_url: data.original_url
|
||
});
|
||
|
||
// Determine badge overlay on image
|
||
const noFaceMark = data.rectangles.length === 0
|
||
? `<div style="position:absolute;top:10px;left:10px;background:red;color:white;border-radius:50%;width:24px;height:24px;display:flex;align-items:center;justify-content:center;font-weight:bold;box-shadow:0 2px 4px rgba(0,0,0,0.2);" title="No faces detected"><i class="fas fa-exclamation"></i></div>`
|
||
: data.warning
|
||
? `<div style="position:absolute;top:10px;left:10px;background:#f5a623;color:white;border-radius:50%;width:24px;height:24px;display:flex;align-items:center;justify-content:center;font-weight:bold;box-shadow:0 2px 4px rgba(0,0,0,0.2);" title="${data.warning}"><i class="fas fa-exclamation-triangle"></i></div>`
|
||
: '';
|
||
|
||
const headerIcon = data.warning ? 'fa-exclamation-triangle' : (data.rectangles.length === 0 ? 'fa-exclamation-circle' : 'fa-check-circle');
|
||
const headerColor = data.warning ? '#f5a623' : (data.rectangles.length === 0 ? 'red' : 'var(--success-color)');
|
||
const warningDetail = data.warning ? `<span style="color:#f5a623;font-size:11px;">⚠ ${data.warning}</span><br>` : '';
|
||
|
||
resultItem.classList.add(data.warning ? 'warning' : 'success');
|
||
resultItem.innerHTML = `
|
||
<div class="batch-image-container" style="position:relative;">
|
||
<img src="${data.image_url || data.original_url}" class="batch-image" alt="${file.name}">
|
||
${noFaceMark}
|
||
<button class="batch-info-btn" onclick="openBatchDetail(${batchResults.length - 1})" title="View / Edit Faces">
|
||
<i class="fas fa-info"></i>
|
||
</button>
|
||
</div>
|
||
<div class="batch-item-header">
|
||
<i class="fas ${headerIcon}" style="color: ${headerColor};"></i>
|
||
${file.name}
|
||
</div>
|
||
<div class="batch-item-details" id="batch-details-${batchResults.length - 1}">
|
||
${warningDetail}
|
||
${data.rectangles.length} face(s)<br>
|
||
${displayStr}
|
||
</div>
|
||
`;
|
||
} else {
|
||
resultItem.classList.add('error');
|
||
resultItem.innerHTML = `
|
||
<div class="batch-image-container" style="background: #fff5f5; display: flex; flex-direction: column;">
|
||
<i class="fas fa-exclamation-circle" style="font-size: 32px; color: var(--danger-color); margin-bottom: 10px;"></i>
|
||
<span style="font-size: 12px; color: var(--danger-color);">Analysis Failed</span>
|
||
</div>
|
||
<div class="batch-item-header">
|
||
<i class="fas fa-times-circle" style="color: var(--danger-color);"></i>
|
||
${file.name}
|
||
</div>
|
||
<div class="batch-item-details" style="color: var(--danger-color);">
|
||
${data.error || 'No faces detected'}
|
||
</div>
|
||
`;
|
||
}
|
||
|
||
document.getElementById('batchResultsList').appendChild(resultItem);
|
||
|
||
// Auto-scroll container to the end (newest item)
|
||
const listContainer = document.getElementById('batchResultsList');
|
||
listContainer.scrollTo({
|
||
left: listContainer.scrollWidth,
|
||
behavior: 'smooth'
|
||
});
|
||
|
||
updateProgress(totalFiles, processedFiles, successfulFiles);
|
||
|
||
setTimeout(() => processNextFile(index + 1), 100);
|
||
})
|
||
.catch(error => {
|
||
console.error('Error processing file:', error);
|
||
processedFiles++;
|
||
|
||
const resultItem = document.createElement('div');
|
||
resultItem.className = 'batch-item error';
|
||
resultItem.innerHTML = `
|
||
<div class="batch-image-container" style="background: #fff5f5; display: flex; flex-direction: column;">
|
||
<i class="fas fa-exclamation-triangle" style="font-size: 32px; color: var(--danger-color); margin-bottom: 10px;"></i>
|
||
<span style="font-size: 12px; color: var(--danger-color);">Error</span>
|
||
</div>
|
||
<div class="batch-item-header">
|
||
<i class="fas fa-times-circle" style="color: var(--danger-color);"></i>
|
||
${file.name}
|
||
</div>
|
||
<div class="batch-item-details" style="color: var(--danger-color);">
|
||
${error.message}
|
||
</div>
|
||
`;
|
||
document.getElementById('batchResultsList').appendChild(resultItem);
|
||
|
||
updateProgress(totalFiles, processedFiles, successfulFiles);
|
||
setTimeout(() => processNextFile(index + 1), 100);
|
||
});
|
||
}
|
||
|
||
processNextFile(0);
|
||
}
|
||
|
||
function updateProgress(total, processed, successful) {
|
||
const percent = Math.round((processed / total) * 100);
|
||
|
||
document.getElementById('progressFill').style.width = percent + '%';
|
||
document.getElementById('progressPercent').textContent = percent + '%';
|
||
document.getElementById('progressText').textContent = `Processing: ${processed}/${total}`;
|
||
document.getElementById('batchStats').innerHTML = `
|
||
<i class="fas fa-file-image"></i> Files: ${total} |
|
||
<i class="fas fa-check-circle" style="color: #4facfe;"></i> Successful: ${successful} |
|
||
<i class="fas fa-times-circle" style="color: #f5576c;"></i> Failed: ${processed - successful}
|
||
`;
|
||
}
|
||
|
||
function saveAllCoordinates() {
|
||
try {
|
||
if (batchResults.length === 0) {
|
||
showMessage('No batch results to save', 'error');
|
||
return;
|
||
}
|
||
|
||
showLoading(true);
|
||
|
||
const formattedResults = batchResults.map(item => {
|
||
// Fix: Use generateFormats instead of removed generateString
|
||
const formats = FormatManager.generateFormats(item.rectangles);
|
||
return {
|
||
filename: item.filename,
|
||
coordinate_string: formats.coord,
|
||
rotation_string: formats.rot,
|
||
rectangles: currentRectangles,
|
||
rectangles: item.rectangles
|
||
};
|
||
});
|
||
|
||
console.log('💾 Saving batch coordinates:', formattedResults);
|
||
|
||
fetch('/save_all_coordinates', {
|
||
method: 'POST',
|
||
headers: {
|
||
'Content-Type': 'application/json',
|
||
},
|
||
body: JSON.stringify({
|
||
results: formattedResults
|
||
})
|
||
})
|
||
.then(response => {
|
||
if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
|
||
return response.json();
|
||
})
|
||
.then(data => {
|
||
if (data.success) {
|
||
showMessage(`Saved ${batchResults.length} images to coordinates file`, 'success');
|
||
loadResults();
|
||
} else {
|
||
showMessage(data.error || 'Failed to save', 'error');
|
||
}
|
||
})
|
||
.catch(error => {
|
||
console.error('Error:', error);
|
||
showMessage('Error: ' + error.message, 'error');
|
||
})
|
||
.finally(() => {
|
||
showLoading(false);
|
||
});
|
||
} catch (e) {
|
||
console.error('Synchronous error in saveAllCoordinates:', e);
|
||
showLoading(false);
|
||
showMessage('Error preparing batch data: ' + e.message, 'error');
|
||
}
|
||
}
|
||
|
||
function clearBatch() {
|
||
if (!confirm('Clear batch results?')) return;
|
||
|
||
batchFiles = [];
|
||
batchResults = [];
|
||
document.getElementById('batchStatus').innerHTML = 'No folder selected';
|
||
document.getElementById('batchResults').style.display = 'none';
|
||
document.getElementById('batchResultsList').innerHTML = '';
|
||
document.getElementById('progressContainer').style.display = 'none';
|
||
document.getElementById('saveAllBtn').disabled = true;
|
||
document.getElementById('folderInput').value = '';
|
||
showMessage('Batch results cleared', 'info');
|
||
}
|
||
|
||
// ===== RESULTS MANAGEMENT =====
|
||
function loadResults() {
|
||
fetch('/get_coordinates')
|
||
.then(response => {
|
||
if (!response.ok) throw new Error('Failed to fetch coordinates');
|
||
return response.json();
|
||
})
|
||
.then(data => {
|
||
const resultsContent = document.getElementById('resultsContent');
|
||
|
||
if (data.content && data.content.trim()) {
|
||
resultsContent.textContent = data.content;
|
||
|
||
// Update recent entries - New Format Parsing
|
||
// Separator: 50 dashes
|
||
const entries = data.content.split(/-{5,}/).filter(e => e.trim().length > 0);
|
||
const recent = entries.slice(-10).reverse();
|
||
let recentHtml = '';
|
||
|
||
recent.forEach(entryText => {
|
||
const lines = entryText.split('\n').map(l => l.trim()).filter(l => l.length > 0);
|
||
let imgName = 'Unknown';
|
||
let coord = '';
|
||
let rot = '';
|
||
|
||
lines.forEach(line => {
|
||
if (line.startsWith('Image:')) imgName = line.replace('Image:', '').trim();
|
||
if (line.startsWith('coordinate:')) coord = line.replace('coordinate:', '').trim();
|
||
if (line.startsWith('rotationpoint:')) rot = line.replace('rotationpoint:', '').trim();
|
||
});
|
||
|
||
if (imgName !== 'Unknown') {
|
||
recentHtml += `
|
||
<div style="background: white; padding: 15px; border-radius: 12px; margin-bottom: 12px; border-left: 4px solid #667eea; box-shadow: 0 2px 8px rgba(0,0,0,0.08);">
|
||
<div style="font-weight: bold; color: #667eea; margin-bottom: 5px;">${imgName}</div>
|
||
<div style="font-size: 11px; color: #6c757d; font-family: Monaco, monospace; margin-bottom: 2px;"><strong>C:</strong> ${coord.substring(0, 50)}${coord.length > 50 ? '...' : ''}</div>
|
||
<div style="font-size: 11px; color: #6c757d; font-family: Monaco, monospace;"><strong>R:</strong> ${rot.substring(0, 50)}${rot.length > 50 ? '...' : ''}</div>
|
||
</div>
|
||
`;
|
||
}
|
||
});
|
||
|
||
document.getElementById('recentEntries').innerHTML = recentHtml || '<p style="color: #adb5bd;">No recent entries</p>';
|
||
} else {
|
||
resultsContent.textContent = 'No coordinates saved yet';
|
||
document.getElementById('recentEntries').innerHTML = '<p style="color: #adb5bd;">No recent entries</p>';
|
||
}
|
||
})
|
||
.catch(error => {
|
||
console.error('Error loading results:', error);
|
||
const resultsContent = document.getElementById('resultsContent');
|
||
if (resultsContent) resultsContent.textContent = 'Error loading results';
|
||
});
|
||
}
|
||
|
||
function clearResults() {
|
||
if (!confirm('Clear all saved coordinates? This cannot be undone.')) return;
|
||
|
||
fetch('/clear_coordinates', {
|
||
method: 'POST'
|
||
})
|
||
.then(response => response.json())
|
||
.then(data => {
|
||
if (data.success) {
|
||
showMessage('All coordinates cleared', 'success');
|
||
loadResults();
|
||
} else {
|
||
showMessage(data.error || 'Failed to clear', 'error');
|
||
}
|
||
})
|
||
.catch(error => {
|
||
console.error('Error:', error);
|
||
showMessage('Error: ' + error.message, 'error');
|
||
});
|
||
}
|
||
|
||
function downloadResults(format = 'text') {
|
||
const TOOL_BASE = window.location.pathname.replace(/\/+$/, '');
|
||
let url;
|
||
let filename;
|
||
|
||
// Check if we have data first
|
||
// Since we download from backend file, we can just trigger it.
|
||
// But helpful to check if resultsContent is empty to avoid 404 or empty file if possible,
|
||
// though backend handles it.
|
||
|
||
if (format === 'json') {
|
||
url = TOOL_BASE + '/download/json';
|
||
filename = `results_${new Date().toISOString().slice(0, 10)}.json`;
|
||
} else {
|
||
url = TOOL_BASE + '/download/text';
|
||
filename = `coordinates_${new Date().toISOString().slice(0, 10)}.txt`;
|
||
}
|
||
|
||
const a = document.createElement('a');
|
||
a.href = url;
|
||
a.download = filename;
|
||
document.body.appendChild(a);
|
||
a.click();
|
||
document.body.removeChild(a);
|
||
|
||
showMessage(`Downloading ${format.toUpperCase()} results...`, 'success');
|
||
}
|
||
|
||
// ===== TAB NAVIGATION =====
|
||
// ===== TAB NAVIGATION =====
|
||
function switchTab(tabName) {
|
||
document.querySelectorAll('.tab-content').forEach(tab => {
|
||
tab.classList.remove('active');
|
||
});
|
||
|
||
document.querySelectorAll('.tab').forEach(tab => {
|
||
tab.classList.remove('active');
|
||
});
|
||
|
||
document.getElementById(tabName + '-tab').classList.add('active');
|
||
document.getElementById(tabName + '-content').classList.add('active');
|
||
|
||
if (tabName === 'results') {
|
||
loadResults();
|
||
}
|
||
}
|
||
|
||
// ===== UI INTERACTION =====
|
||
function toggleFormatInfo() {
|
||
const info = document.querySelector('.format-info');
|
||
info.classList.toggle('collapsed');
|
||
}
|
||
|
||
// ===== UTILITY FUNCTIONS =====
|
||
function clearImage() {
|
||
if (!confirm('Clear current image?')) return;
|
||
|
||
currentImage = null;
|
||
currentRectangles = [];
|
||
currentCoordinateString = '';
|
||
currentFileName = '';
|
||
|
||
ctx.clearRect(0, 0, canvas.width, canvas.height);
|
||
canvas.style.display = 'none';
|
||
document.getElementById('emptyState').style.display = 'block';
|
||
updateCoordinatesList();
|
||
document.getElementById('saveBtn').disabled = true;
|
||
document.getElementById('fileInput').value = '';
|
||
// Format info collapse state is preserved in UI
|
||
showMessage('Image cleared', 'info');
|
||
}
|
||
|
||
function showLoading(show) {
|
||
document.getElementById('loading').style.display = show ? 'flex' : 'none';
|
||
}
|
||
|
||
function showMessage(text, type = 'info') {
|
||
const message = document.getElementById('message');
|
||
message.textContent = text;
|
||
message.className = `message ${type}`;
|
||
|
||
setTimeout(() => {
|
||
message.classList.add('show');
|
||
}, 10);
|
||
|
||
setTimeout(() => {
|
||
message.classList.remove('show');
|
||
}, 5000);
|
||
}
|
||
|
||
// ===== BATCH SCROLLING =====
|
||
function scrollBatch(direction) {
|
||
const list = document.getElementById('batchResultsList');
|
||
const scrollAmount = 340; // Approx card width (320) + gap (20)
|
||
|
||
if (direction === 'left') {
|
||
list.scrollBy({ left: -scrollAmount, behavior: 'smooth' });
|
||
} else {
|
||
list.scrollBy({ left: scrollAmount, behavior: 'smooth' });
|
||
}
|
||
}
|
||
|
||
|
||
// Global modal functions
|
||
function toggleFormatModal(show) {
|
||
const modal = document.getElementById('formatModal');
|
||
if (show) {
|
||
modal.classList.add('show');
|
||
FormatManager.load(); // Refresh/Init
|
||
} else {
|
||
modal.classList.remove('show');
|
||
}
|
||
}
|
||
|
||
function saveFormatSettings() {
|
||
FormatManager.save();
|
||
toggleFormatModal(false);
|
||
showMessage('Format settings saved', 'success');
|
||
}
|
||
|
||
// Add listeners for real-time preview
|
||
document.addEventListener('DOMContentLoaded', function () {
|
||
// Inputs (separators)
|
||
['sepCoord', 'sepPoint', 'sepFrame'].forEach(id => {
|
||
const el = document.getElementById(id);
|
||
if (el) {
|
||
el.addEventListener('input', () => FormatManager.updatePreview());
|
||
}
|
||
});
|
||
});
|
||
|
||
function checkServerHealth() {
|
||
fetch('/health')
|
||
.then(response => response.json())
|
||
.then(data => {
|
||
if (data.status === 'healthy') {
|
||
console.log('Server is healthy');
|
||
}
|
||
})
|
||
.catch(error => {
|
||
console.error('Server health check failed:', error);
|
||
showMessage('Warning: Server connection issues', 'error');
|
||
});
|
||
}
|
||
|
||
// ===== BATCH DETAIL VIEW FUNCTIONS =====
|
||
|
||
function openBatchDetail(index) {
|
||
if (index < 0 || index >= batchResults.length) return;
|
||
|
||
currentBatchDetailIndex = index;
|
||
const result = batchResults[index];
|
||
|
||
// Load image for canvas
|
||
detailImage = new Image();
|
||
detailImage.onload = function() {
|
||
document.getElementById('batchDetailModal').classList.add('show');
|
||
renderDetailView();
|
||
};
|
||
detailImage.onerror = function() {
|
||
console.error("Failed to load image for detail view:", detailImage.src);
|
||
showMessage("Failed to load image for details.", "error");
|
||
};
|
||
// Use original URL if available (to avoid ghost boxes), otherwise fallback to processed
|
||
detailImage.src = result.original_url || result.image_url;
|
||
}
|
||
|
||
function closeBatchDetail() {
|
||
document.getElementById('batchDetailModal').classList.remove('show');
|
||
currentBatchDetailIndex = -1;
|
||
detailImage = null;
|
||
}
|
||
|
||
function renderDetailView() {
|
||
if (currentBatchDetailIndex === -1 || !detailImage) return;
|
||
|
||
const result = batchResults[currentBatchDetailIndex];
|
||
const rectangles = result.rectangles;
|
||
|
||
// 1. Render Canvas
|
||
detailCanvas.width = detailImage.width;
|
||
detailCanvas.height = detailImage.height;
|
||
detailCtx.clearRect(0, 0, detailCanvas.width, detailCanvas.height);
|
||
detailCtx.drawImage(detailImage, 0, 0);
|
||
|
||
// Calculate visual scale for handles
|
||
const rectBounds = detailCanvas.getBoundingClientRect();
|
||
const scale = detailCanvas.width / rectBounds.width;
|
||
const hSize = 12 * scale; // 12px visual size
|
||
const lineWidth = Math.max(2 * scale, 2);
|
||
|
||
// Draw rectangles
|
||
rectangles.forEach((rect, i) => {
|
||
// Draw Box
|
||
detailCtx.beginPath();
|
||
detailCtx.rect(rect.x, rect.y, rect.width, rect.height);
|
||
detailCtx.lineWidth = lineWidth;
|
||
detailCtx.strokeStyle = '#00FF00'; // Green
|
||
detailCtx.stroke();
|
||
|
||
// Draw Handles (Corners)
|
||
detailCtx.fillStyle = '#00FF00';
|
||
// TL
|
||
detailCtx.fillRect(rect.x - hSize/2, rect.y - hSize/2, hSize, hSize);
|
||
// TR
|
||
detailCtx.fillRect(rect.x + rect.width - hSize/2, rect.y - hSize/2, hSize, hSize);
|
||
// BR
|
||
detailCtx.fillRect(rect.x + rect.width - hSize/2, rect.y + rect.height - hSize/2, hSize, hSize);
|
||
// BL
|
||
detailCtx.fillRect(rect.x - hSize/2, rect.y + rect.height - hSize/2, hSize, hSize);
|
||
|
||
// Draw Rotation Point
|
||
if (rect.rotation_point) {
|
||
detailCtx.beginPath();
|
||
detailCtx.arc(rect.rotation_point.x, rect.rotation_point.y, hSize/2, 0, 2 * Math.PI);
|
||
detailCtx.fillStyle = '#FF0000';
|
||
detailCtx.fill();
|
||
detailCtx.strokeStyle = '#FFFFFF';
|
||
detailCtx.lineWidth = 1 * scale;
|
||
detailCtx.stroke();
|
||
}
|
||
|
||
// Draw Label
|
||
detailCtx.font = `bold ${Math.max(16 * scale, 16)}px Arial`;
|
||
detailCtx.fillStyle = '#00FF00';
|
||
detailCtx.fillText(`Face ${i + 1}`, rect.x, rect.y - 5);
|
||
});
|
||
|
||
// Draw temporary box if drawing
|
||
if (isDetailDrawing && detailDrawStartPoint && detailDragStartPoint && detailDragHandle === 'draw') {
|
||
const w = detailDragStartPoint.x - detailDrawStartPoint.x;
|
||
const h = detailDragStartPoint.y - detailDrawStartPoint.y;
|
||
detailCtx.beginPath();
|
||
detailCtx.rect(detailDrawStartPoint.x, detailDrawStartPoint.y, w, h);
|
||
detailCtx.lineWidth = lineWidth;
|
||
detailCtx.strokeStyle = '#FFFF00';
|
||
detailCtx.setLineDash([5 * scale, 5 * scale]);
|
||
detailCtx.stroke();
|
||
detailCtx.setLineDash([]);
|
||
}
|
||
|
||
// 2. Render List
|
||
const listContainer = document.getElementById('detailList');
|
||
listContainer.innerHTML = '';
|
||
|
||
if (rectangles.length === 0) {
|
||
listContainer.innerHTML = '<p class="text-muted text-center" style="margin-top: 20px;">No faces detected (or all removed)</p>';
|
||
return;
|
||
}
|
||
|
||
rectangles.forEach((rect, i) => {
|
||
const item = document.createElement('div');
|
||
item.className = 'detail-item';
|
||
|
||
const color = '#44CC44'; // Green
|
||
|
||
item.innerHTML = `
|
||
<div style="width: 20px; height: 20px; background: ${color}; border-radius: 4px; margin-right: 10px; display: flex; align-items: center; justify-content: center; color: white; font-weight: bold; font-size: 12px;">
|
||
${i + 1}
|
||
</div>
|
||
<div>
|
||
<div style="font-weight: 600; font-size: 14px;">Face #${i + 1}</div>
|
||
<div style="font-size: 11px; color: #6c757d;">
|
||
Box: ${rect.width}x${rect.height} • (${rect.x}, ${rect.y}) • Angle: ${rect.angle !== undefined ? rect.angle : 0}°<br>
|
||
Rot: ${rect.rotation_point ? `(${rect.rotation_point.x}, ${rect.rotation_point.y})` : 'Drag red dot to set'}
|
||
</div>
|
||
</div>
|
||
<button class="detail-remove-btn" onclick="removeFaceFromBatch(${currentBatchDetailIndex}, ${i})" title="Remove Face">
|
||
<i class="fas fa-times"></i>
|
||
</button>
|
||
`;
|
||
listContainer.appendChild(item);
|
||
});
|
||
}
|
||
|
||
function removeFaceFromBatch(batchIndex, frameIndex) {
|
||
if (batchIndex !== currentBatchDetailIndex) return;
|
||
if (!confirm('Remove this face? It will not be saved.')) return;
|
||
|
||
const result = batchResults[batchIndex];
|
||
|
||
// Remove from array
|
||
result.rectangles.splice(frameIndex, 1);
|
||
|
||
// Regenerate coordinate string using FormatManager
|
||
const formats = FormatManager.generateFormats(result.rectangles);
|
||
result.coordinates = formats.coord;
|
||
result.rotations = formats.rot;
|
||
|
||
// Update Batch Item UI in the background list
|
||
const batchDetailsEl = document.getElementById(`batch-details-${batchIndex}`);
|
||
if (batchDetailsEl) {
|
||
const displayStr = formats.rot ? `${formats.coord}<br>${formats.rot}` : formats.coord;
|
||
batchDetailsEl.innerHTML = `
|
||
${result.rectangles.length} face(s)<br>
|
||
${displayStr}
|
||
`;
|
||
}
|
||
|
||
// Re-render Detail View
|
||
renderDetailView();
|
||
|
||
showMessage('Face removed', 'success');
|
||
}// ===== DETAIL VIEW INTERACTION =====
|
||
// (State variables moved to top of file to avoid Temporal Dead Zone)
|
||
|
||
function toggleDetailCreateMode() {
|
||
isDetailDrawing = !isDetailDrawing;
|
||
const btn = document.getElementById('detailAddBoxBtn');
|
||
if (isDetailDrawing) {
|
||
btn.classList.add('active');
|
||
if (detailCanvas) detailCanvas.style.cursor = 'crosshair';
|
||
showMessage('Draw a box on the image', 'info');
|
||
} else {
|
||
btn.classList.remove('active');
|
||
if (detailCanvas) detailCanvas.style.cursor = 'default';
|
||
showMessage('Edit mode', 'info');
|
||
}
|
||
}
|
||
|
||
// Add listeners to detailCanvas when main.js loads (it's in DOM)
|
||
// Ensure detailCanvas is available. It is init in DOMContentLoaded.
|
||
// So we hook into DOMContentLoaded or just run this if defer.
|
||
// We'll add a helper and call it.
|
||
|
||
function setupDetailInteractions() {
|
||
if (!detailCanvas) return;
|
||
|
||
function getDetailMousePos(evt) {
|
||
const rect = detailCanvas.getBoundingClientRect();
|
||
const scaleX = detailCanvas.width / rect.width;
|
||
const scaleY = detailCanvas.height / rect.height;
|
||
return {
|
||
x: (evt.clientX - rect.left) * scaleX,
|
||
y: (evt.clientY - rect.top) * scaleY
|
||
};
|
||
}
|
||
|
||
detailCanvas.addEventListener('mousedown', function(e) {
|
||
if (currentBatchDetailIndex === -1) return;
|
||
const pos = getDetailMousePos(e);
|
||
const rectBounds = detailCanvas.getBoundingClientRect();
|
||
const scale = detailCanvas.width / rectBounds.width;
|
||
const hSize = 14 * scale;
|
||
|
||
const rectangles = batchResults[currentBatchDetailIndex].rectangles;
|
||
|
||
let hitFound = false;
|
||
// Reverse check
|
||
for (let i = rectangles.length - 1; i >= 0; i--) {
|
||
const rect = rectangles[i];
|
||
|
||
// Rot
|
||
if (rect.rotation_point) {
|
||
const dx = pos.x - rect.rotation_point.x;
|
||
const dy = pos.y - rect.rotation_point.y;
|
||
if (dx*dx + dy*dy <= (hSize/2 * 1.5)**2) {
|
||
isDetailDragging = true; detailDragTargetIndex = i; detailDragHandle = 'rot'; hitFound = true; break;
|
||
}
|
||
}
|
||
// Corners
|
||
if (Math.abs(pos.x - rect.x) < hSize && Math.abs(pos.y - rect.y) < hSize) { isDetailDragging=true; detailDragTargetIndex=i; detailDragHandle='tl'; hitFound=true; break; }
|
||
if (Math.abs(pos.x - (rect.x+rect.width)) < hSize && Math.abs(pos.y - rect.y) < hSize) { isDetailDragging=true; detailDragTargetIndex=i; detailDragHandle='tr'; hitFound=true; break; }
|
||
if (Math.abs(pos.x - (rect.x+rect.width)) < hSize && Math.abs(pos.y - (rect.y+rect.height)) < hSize) { isDetailDragging=true; detailDragTargetIndex=i; detailDragHandle='br'; hitFound=true; break; }
|
||
if (Math.abs(pos.x - rect.x) < hSize && Math.abs(pos.y - (rect.y+rect.height)) < hSize) { isDetailDragging=true; detailDragTargetIndex=i; detailDragHandle='bl'; hitFound=true; break; }
|
||
|
||
// Body
|
||
if (pos.x >= rect.x && pos.x <= rect.x + rect.width && pos.y >= rect.y && pos.y <= rect.y + rect.height) {
|
||
isDetailDragging = true;
|
||
detailDragTargetIndex = i;
|
||
detailDragHandle = 'body';
|
||
detailDragStartPoint = pos;
|
||
detailDragStartRect = { ...rect, rotation_point: { ...rect.rotation_point } };
|
||
hitFound = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!hitFound && isDetailDrawing) {
|
||
isDetailDragging = true;
|
||
detailDragHandle = 'draw';
|
||
detailDrawStartPoint = pos;
|
||
detailDragStartPoint = pos; // current end point
|
||
}
|
||
});
|
||
|
||
detailCanvas.addEventListener('mousemove', function(e) {
|
||
if (currentBatchDetailIndex === -1) return;
|
||
const pos = getDetailMousePos(e);
|
||
const rectBounds = detailCanvas.getBoundingClientRect();
|
||
const scale = detailCanvas.width / rectBounds.width;
|
||
const hSize = 14 * scale;
|
||
const rectangles = batchResults[currentBatchDetailIndex].rectangles;
|
||
|
||
if (!isDetailDragging) {
|
||
let cursor = isDetailDrawing ? 'crosshair' : 'default';
|
||
for (let i = rectangles.length - 1; i >= 0; i--) {
|
||
const rect = rectangles[i];
|
||
if ((Math.abs(pos.x-rect.x)<hSize && Math.abs(pos.y-rect.y)<hSize) ||
|
||
(Math.abs(pos.x-(rect.x+rect.width))<hSize && Math.abs(pos.y-(rect.y+rect.height))<hSize)) cursor = 'nwse-resize';
|
||
else if ((Math.abs(pos.x-(rect.x+rect.width))<hSize && Math.abs(pos.y-rect.y)<hSize) ||
|
||
(Math.abs(pos.x-rect.x)<hSize && Math.abs(pos.y-(rect.y+rect.height))<hSize)) cursor = 'nesw-resize';
|
||
else if (rect.rotation_point && (pos.x-rect.rotation_point.x)**2 + (pos.y-rect.rotation_point.y)**2 <= (hSize/2*1.5)**2) cursor='move';
|
||
else if (cursor === 'default' && pos.x>=rect.x && pos.x<=rect.x+rect.width && pos.y>=rect.y && pos.y<=rect.y+rect.height) cursor='move';
|
||
}
|
||
detailCanvas.style.cursor = cursor;
|
||
return;
|
||
}
|
||
|
||
if (detailDragHandle === 'draw') {
|
||
detailDragStartPoint = pos;
|
||
renderDetailView();
|
||
return;
|
||
}
|
||
|
||
// Dragging logic
|
||
const rect = rectangles[detailDragTargetIndex];
|
||
if (!rect) return;
|
||
|
||
if (detailDragHandle === 'rot') {
|
||
rect.rotation_point.x = Math.round(pos.x);
|
||
rect.rotation_point.y = Math.round(pos.y);
|
||
} else if (detailDragHandle === 'body') {
|
||
const dx = pos.x - detailDragStartPoint.x;
|
||
const dy = pos.y - detailDragStartPoint.y;
|
||
rect.x = Math.round(detailDragStartRect.x + dx);
|
||
rect.y = Math.round(detailDragStartRect.y + dy);
|
||
rect.rotation_point.x = Math.round(detailDragStartRect.rotation_point.x + dx);
|
||
rect.rotation_point.y = Math.round(detailDragStartRect.rotation_point.y + dy);
|
||
} else {
|
||
// Resize (tl, tr, bl, br) - Simplified
|
||
if (detailDragHandle === 'tl') {
|
||
const maxX = rect.x + rect.width - 10; const maxY = rect.y + rect.height - 10;
|
||
const newX = Math.min(pos.x, maxX); const newY = Math.min(pos.y, maxY);
|
||
rect.width += (rect.x - newX); rect.height += (rect.y - newY);
|
||
rect.x = newX; rect.y = newY;
|
||
} else if (detailDragHandle === 'tr') {
|
||
const maxY = rect.y + rect.height - 10;
|
||
const newW = Math.max(pos.x - rect.x, 10); const newY = Math.min(pos.y, maxY);
|
||
rect.height += (rect.y - newY); rect.y = newY; rect.width = newW;
|
||
} else if (detailDragHandle === 'bl') {
|
||
const maxX = rect.x + rect.width - 10;
|
||
const newX = Math.min(pos.x, maxX); const newH = Math.max(pos.y - rect.y, 10);
|
||
rect.width += (rect.x - newX); rect.x = newX; rect.height = newH;
|
||
} else if (detailDragHandle === 'br') {
|
||
rect.width = Math.max(pos.x - rect.x, 10); rect.height = Math.max(pos.y - rect.y, 10);
|
||
}
|
||
|
||
// Round all rect coordinates to integer to avoid floats in formatting
|
||
rect.x = Math.round(rect.x);
|
||
rect.y = Math.round(rect.y);
|
||
rect.width = Math.round(rect.width);
|
||
rect.height = Math.round(rect.height);
|
||
|
||
// Update corners
|
||
rect.corners = {
|
||
top_left: { x: rect.x, y: rect.y },
|
||
top_right: { x: rect.x + rect.width, y: rect.y },
|
||
bottom_right: { x: rect.x + rect.width, y: rect.y + rect.height },
|
||
bottom_left: { x: rect.x, y: rect.y + rect.height }
|
||
};
|
||
}
|
||
renderDetailView();
|
||
});
|
||
|
||
detailCanvas.addEventListener('mouseup', function() {
|
||
if (!isDetailDragging) return;
|
||
|
||
if (detailDragHandle === 'draw' && detailDrawStartPoint && detailDragStartPoint) {
|
||
const x = Math.min(detailDrawStartPoint.x, detailDragStartPoint.x);
|
||
const y = Math.min(detailDrawStartPoint.y, detailDragStartPoint.y);
|
||
const w = Math.abs(detailDrawStartPoint.x - detailDragStartPoint.x);
|
||
const h = Math.abs(detailDrawStartPoint.y - detailDragStartPoint.y);
|
||
|
||
if (w > 10 && h > 10) {
|
||
const newRect = {
|
||
x: Math.round(x),
|
||
y: Math.round(y),
|
||
width: Math.round(w),
|
||
height: Math.round(h),
|
||
rotation_point: { x: Math.round(x + w/2), y: Math.round(y + h) },
|
||
corners: {
|
||
top_left: { x: Math.round(x), y: Math.round(y) },
|
||
top_right: { x: Math.round(x + w), y: Math.round(y) },
|
||
bottom_right: { x: Math.round(x + w), y: Math.round(y + h) },
|
||
bottom_left: { x: Math.round(x), y: Math.round(y + h) }
|
||
}
|
||
};
|
||
const result = batchResults[currentBatchDetailIndex];
|
||
result.rectangles.push(newRect);
|
||
|
||
const formats = FormatManager.generateFormats(result.rectangles);
|
||
result.coordinates = formats.coord;
|
||
result.rotations = formats.rot;
|
||
|
||
const batchDetailsEl = document.getElementById(`batch-details-${currentBatchDetailIndex}`);
|
||
if (batchDetailsEl) {
|
||
const displayStr = formats.rot ? `${formats.coord}<br>${formats.rot}` : formats.coord;
|
||
batchDetailsEl.innerHTML = `
|
||
${result.rectangles.length} face(s)<br>
|
||
${displayStr}
|
||
`;
|
||
}
|
||
|
||
// Update batch UI marker if needed
|
||
const itemEl = batchDetailsEl.parentElement;
|
||
if (itemEl && result.rectangles.length > 0) {
|
||
const iconEl = itemEl.querySelector('.batch-item-header i');
|
||
if (iconEl) {
|
||
iconEl.className = 'fas fa-check-circle';
|
||
iconEl.style.color = 'var(--success-color)';
|
||
}
|
||
const markEl = itemEl.querySelector('.batch-image-container div[title="No faces detected"]');
|
||
if (markEl) markEl.remove();
|
||
}
|
||
|
||
showMessage('New box added', 'success');
|
||
toggleDetailCreateMode();
|
||
}
|
||
} else {
|
||
// Updating existing coordinates for saving later
|
||
const result = batchResults[currentBatchDetailIndex];
|
||
const formats = FormatManager.generateFormats(result.rectangles);
|
||
result.coordinates = formats.coord;
|
||
result.rotations = formats.rot;
|
||
const batchDetailsEl = document.getElementById(`batch-details-${currentBatchDetailIndex}`);
|
||
if (batchDetailsEl) {
|
||
const displayStr = formats.rot ? `${formats.coord}<br>${formats.rot}` : formats.coord;
|
||
batchDetailsEl.innerHTML = `
|
||
${result.rectangles.length} face(s)<br>
|
||
${displayStr}
|
||
`;
|
||
}
|
||
}
|
||
|
||
isDetailDragging = false;
|
||
detailDragTargetIndex = -1;
|
||
detailDragHandle = null;
|
||
detailDrawStartPoint = null;
|
||
detailDragStartPoint = null;
|
||
renderDetailView();
|
||
});
|
||
}
|
||
|
||
// Detail interactions are now set up inside DOMContentLoaded (above)
|