866 lines
35 KiB
C#
866 lines
35 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Windows;
|
||
using System.Windows.Controls;
|
||
using System.Windows.Media;
|
||
using System.Windows.Media.Imaging;
|
||
using System.Windows.Shapes;
|
||
using CtrEditor.ObjetosSim;
|
||
using System.Diagnostics;
|
||
|
||
namespace CtrEditor.Services
|
||
{
|
||
/// <summary>
|
||
/// Gestor centralizado de capturas de pantalla del canvas.
|
||
/// Proporciona funcionalidades para capturar:
|
||
/// 1. Objetos específicos por ID
|
||
/// 2. Áreas específicas en coordenadas de metros
|
||
/// 3. Todo el canvas
|
||
///
|
||
/// Utiliza la misma lógica que ObjectManipulationManager para calcular
|
||
/// las dimensiones reales de los objetos en el canvas.
|
||
/// </summary>
|
||
public class ScreenshotManager
|
||
{
|
||
private readonly MainViewModel _mainViewModel;
|
||
private readonly Canvas _canvas;
|
||
private readonly string _defaultScreenshotsDirectory;
|
||
|
||
public ScreenshotManager(MainViewModel mainViewModel, Canvas canvas)
|
||
{
|
||
_mainViewModel = mainViewModel ?? throw new ArgumentNullException(nameof(mainViewModel));
|
||
_canvas = canvas ?? throw new ArgumentNullException(nameof(canvas));
|
||
_defaultScreenshotsDirectory = System.IO.Path.Combine(EstadoPersistente.Instance.directorio, "screenshots");
|
||
}
|
||
|
||
#region Public Methods
|
||
|
||
/// <summary>
|
||
/// Captura screenshot de objetos específicos por sus IDs
|
||
/// </summary>
|
||
/// <param name="objectIds">Array de IDs de objetos a capturar</param>
|
||
/// <param name="paddingMeters">Padding adicional alrededor de los objetos en metros</param>
|
||
/// <param name="filename">Nombre del archivo (opcional)</param>
|
||
/// <param name="includeBackground">Si incluir imagen de fondo</param>
|
||
/// <param name="saveToFile">Si guardar el archivo</param>
|
||
/// <param name="returnBase64">Si retornar la imagen como base64</param>
|
||
/// <returns>Resultado de la captura</returns>
|
||
public ScreenshotResult CaptureObjects(
|
||
string[] objectIds,
|
||
float paddingMeters = 0.5f,
|
||
string filename = null,
|
||
bool includeBackground = false,
|
||
bool saveToFile = true,
|
||
bool returnBase64 = true)
|
||
{
|
||
try
|
||
{
|
||
if (objectIds == null || objectIds.Length == 0)
|
||
throw new ArgumentException("objectIds no puede estar vacío");
|
||
|
||
// Buscar objetos por ID
|
||
var targetObjects = FindObjectsByIds(objectIds);
|
||
if (!targetObjects.Any())
|
||
throw new ArgumentException($"No se encontraron objetos visibles con los IDs: {string.Join(", ", objectIds)}");
|
||
|
||
// SOLUCIÓN 2: Usar bounding box mejorado para objetos con dimensiones 0.0
|
||
var boundingBox = CalculateObjectsBoundingBoxImproved(targetObjects);
|
||
|
||
// Aplicar padding
|
||
var captureArea = new ScreenshotArea
|
||
{
|
||
Left = boundingBox.Left - paddingMeters,
|
||
Top = boundingBox.Top - paddingMeters,
|
||
Width = boundingBox.Width + (paddingMeters * 2),
|
||
Height = boundingBox.Height + (paddingMeters * 2)
|
||
};
|
||
|
||
// Asegurar dimensiones mínimas
|
||
captureArea.Width = Math.Max(captureArea.Width, 0.1f);
|
||
captureArea.Height = Math.Max(captureArea.Height, 0.1f);
|
||
|
||
// Capturar la imagen
|
||
var bitmap = CaptureCanvasArea(captureArea, includeBackground);
|
||
|
||
// Preparar resultado
|
||
var result = new ScreenshotResult
|
||
{
|
||
Success = true,
|
||
Bitmap = bitmap,
|
||
CaptureType = ScreenshotType.Objects,
|
||
CapturedObjects = targetObjects.Select(obj => new CapturedObjectInfo
|
||
{
|
||
Id = obj.Id.Value.ToString(),
|
||
Name = obj.Nombre,
|
||
Type = obj.GetType().Name,
|
||
Left = obj.Left,
|
||
Top = obj.Top,
|
||
Width = obj.Ancho,
|
||
Height = obj.Alto,
|
||
CenterX = obj.Left + obj.Ancho / 2,
|
||
CenterY = obj.Top + obj.Alto / 2
|
||
}).ToList(),
|
||
BoundingBox = new AreaInfo
|
||
{
|
||
Left = boundingBox.Left,
|
||
Top = boundingBox.Top,
|
||
Width = boundingBox.Width,
|
||
Height = boundingBox.Height,
|
||
CenterX = boundingBox.Left + boundingBox.Width / 2,
|
||
CenterY = boundingBox.Top + boundingBox.Height / 2
|
||
},
|
||
CaptureArea = new AreaInfo
|
||
{
|
||
Left = captureArea.Left,
|
||
Top = captureArea.Top,
|
||
Width = captureArea.Width,
|
||
Height = captureArea.Height,
|
||
CenterX = captureArea.Left + captureArea.Width / 2,
|
||
CenterY = captureArea.Top + captureArea.Height / 2
|
||
},
|
||
PaddingMeters = paddingMeters,
|
||
IncludeBackground = includeBackground
|
||
};
|
||
|
||
// Guardar archivo y/o generar base64
|
||
return ProcessScreenshotOutput(result, filename, saveToFile, returnBase64);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ScreenshotResult
|
||
{
|
||
Success = false,
|
||
ErrorMessage = ex.Message,
|
||
ErrorType = ex.GetType().Name
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Captura screenshot de un área específica en coordenadas de metros
|
||
/// </summary>
|
||
/// <param name="left">Coordenada X izquierda en metros</param>
|
||
/// <param name="top">Coordenada Y superior en metros</param>
|
||
/// <param name="width">Ancho en metros</param>
|
||
/// <param name="height">Alto en metros</param>
|
||
/// <param name="filename">Nombre del archivo (opcional)</param>
|
||
/// <param name="includeBackground">Si incluir imagen de fondo</param>
|
||
/// <param name="saveToFile">Si guardar el archivo</param>
|
||
/// <param name="returnBase64">Si retornar la imagen como base64</param>
|
||
/// <returns>Resultado de la captura</returns>
|
||
public ScreenshotResult CaptureArea(
|
||
float left,
|
||
float top,
|
||
float width,
|
||
float height,
|
||
string filename = null,
|
||
bool includeBackground = false,
|
||
bool saveToFile = true,
|
||
bool returnBase64 = true)
|
||
{
|
||
try
|
||
{
|
||
if (width <= 0 || height <= 0)
|
||
throw new ArgumentException("Width y height deben ser mayores que 0");
|
||
|
||
var captureArea = new ScreenshotArea
|
||
{
|
||
Left = left,
|
||
Top = top,
|
||
Width = width,
|
||
Height = height
|
||
};
|
||
|
||
var bitmap = CaptureCanvasArea(captureArea, includeBackground);
|
||
|
||
var result = new ScreenshotResult
|
||
{
|
||
Success = true,
|
||
Bitmap = bitmap,
|
||
CaptureType = ScreenshotType.Area,
|
||
CaptureArea = new AreaInfo
|
||
{
|
||
Left = left,
|
||
Top = top,
|
||
Width = width,
|
||
Height = height,
|
||
CenterX = left + width / 2,
|
||
CenterY = top + height / 2
|
||
},
|
||
IncludeBackground = includeBackground
|
||
};
|
||
|
||
return ProcessScreenshotOutput(result, filename, saveToFile, returnBase64);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ScreenshotResult
|
||
{
|
||
Success = false,
|
||
ErrorMessage = ex.Message,
|
||
ErrorType = ex.GetType().Name
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Captura screenshot de un área centrada en coordenadas específicas
|
||
/// </summary>
|
||
/// <param name="centerX">Coordenada X del centro en metros</param>
|
||
/// <param name="centerY">Coordenada Y del centro en metros</param>
|
||
/// <param name="width">Ancho en metros</param>
|
||
/// <param name="height">Alto en metros</param>
|
||
/// <param name="filename">Nombre del archivo (opcional)</param>
|
||
/// <param name="includeBackground">Si incluir imagen de fondo</param>
|
||
/// <param name="saveToFile">Si guardar el archivo</param>
|
||
/// <param name="returnBase64">Si retornar la imagen como base64</param>
|
||
/// <returns>Resultado de la captura</returns>
|
||
public ScreenshotResult CaptureCenteredArea(
|
||
float centerX,
|
||
float centerY,
|
||
float width,
|
||
float height,
|
||
string filename = null,
|
||
bool includeBackground = false,
|
||
bool saveToFile = true,
|
||
bool returnBase64 = true)
|
||
{
|
||
var left = centerX - width / 2;
|
||
var top = centerY - height / 2;
|
||
|
||
return CaptureArea(left, top, width, height, filename, includeBackground, saveToFile, returnBase64);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Captura screenshot de todo el canvas con auto-zoom inteligente
|
||
/// </summary>
|
||
/// <param name="filename">Nombre del archivo (opcional)</param>
|
||
/// <param name="includeBackground">Si incluir imagen de fondo</param>
|
||
/// <param name="saveToFile">Si guardar el archivo</param>
|
||
/// <param name="returnBase64">Si retornar la imagen como base64</param>
|
||
/// <param name="autoZoom">Si usar auto-zoom a área con objetos (por defecto true)</param>
|
||
/// <returns>Resultado de la captura</returns>
|
||
public ScreenshotResult CaptureFullCanvas(
|
||
string filename = null,
|
||
bool includeBackground = true,
|
||
bool saveToFile = true,
|
||
bool returnBase64 = true,
|
||
bool autoZoom = true)
|
||
{
|
||
try
|
||
{
|
||
// SOLUCIÓN 1: Auto-zoom inteligente
|
||
if (autoZoom)
|
||
{
|
||
var visibleObjects = _mainViewModel.ObjetosSimulables
|
||
.Where(o => o.Show_On_This_Page).ToList();
|
||
|
||
if (visibleObjects.Any())
|
||
{
|
||
try
|
||
{
|
||
var bounds = CalculateObjectsBoundingBoxImproved(visibleObjects);
|
||
var padding = Math.Max(2.0f, Math.Max(bounds.Width, bounds.Height) * 0.2f);
|
||
|
||
Trace.WriteLine($"[ScreenshotManager] Auto-zoom detectado: área {bounds.Width:F1}×{bounds.Height:F1}m, padding {padding:F1}m");
|
||
|
||
return CaptureArea(
|
||
bounds.Left - padding,
|
||
bounds.Top - padding,
|
||
bounds.Width + (padding * 2),
|
||
bounds.Height + (padding * 2),
|
||
filename, includeBackground, saveToFile, returnBase64);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Trace.WriteLine($"[ScreenshotManager] Auto-zoom falló: {ex.Message}, usando canvas completo");
|
||
}
|
||
}
|
||
}
|
||
|
||
// Fallback a canvas completo
|
||
var bitmap = CaptureEntireCanvas(includeBackground);
|
||
|
||
var canvasWidthMeters = PixelToMeter.Instance.calc.PixelsToMeters((float)_canvas.ActualWidth);
|
||
var canvasHeightMeters = PixelToMeter.Instance.calc.PixelsToMeters((float)_canvas.ActualHeight);
|
||
|
||
var result = new ScreenshotResult
|
||
{
|
||
Success = true,
|
||
Bitmap = bitmap,
|
||
CaptureType = ScreenshotType.FullCanvas,
|
||
CaptureArea = new AreaInfo
|
||
{
|
||
Left = 0,
|
||
Top = 0,
|
||
Width = canvasWidthMeters,
|
||
Height = canvasHeightMeters,
|
||
CenterX = canvasWidthMeters / 2,
|
||
CenterY = canvasHeightMeters / 2
|
||
},
|
||
IncludeBackground = includeBackground
|
||
};
|
||
|
||
return ProcessScreenshotOutput(result, filename, saveToFile, returnBase64);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ScreenshotResult
|
||
{
|
||
Success = false,
|
||
ErrorMessage = ex.Message,
|
||
ErrorType = ex.GetType().Name
|
||
};
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Private Helper Methods
|
||
|
||
/// <summary>
|
||
/// Busca objetos por sus IDs
|
||
/// </summary>
|
||
private List<osBase> FindObjectsByIds(string[] objectIds)
|
||
{
|
||
var allObjects = _mainViewModel.ObjetosSimulables.ToList();
|
||
var result = new List<osBase>();
|
||
|
||
foreach (var objectId in objectIds)
|
||
{
|
||
var obj = allObjects.FirstOrDefault(o => o.Id.Value.ToString() == objectId);
|
||
if (obj != null && obj.Show_On_This_Page)
|
||
{
|
||
result.Add(obj);
|
||
Console.WriteLine($"DEBUG: Object {objectId} ADDED - Type: {obj.GetType().Name}, Left: {obj.Left}, Top: {obj.Top}");
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine($"DEBUG: Object {objectId} REJECTED - Found: {obj != null}, Show_On_This_Page: {obj?.Show_On_This_Page}");
|
||
}
|
||
}
|
||
|
||
Console.WriteLine($"DEBUG: Total objects found: {result.Count}");
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Calcula el bounding box de un conjunto de objetos usando coordenadas directas
|
||
/// </summary>
|
||
private ScreenshotArea CalculateObjectsBoundingBox(List<osBase> objects)
|
||
{
|
||
if (!objects.Any())
|
||
throw new ArgumentException("La lista de objetos no puede estar vacía");
|
||
|
||
float left = float.MaxValue;
|
||
float top = float.MaxValue;
|
||
float right = float.MinValue;
|
||
float bottom = float.MinValue;
|
||
|
||
foreach (var obj in objects)
|
||
{
|
||
// Usar coordenadas directas del objeto (ya están en metros)
|
||
float objLeft = obj.Left;
|
||
float objTop = obj.Top;
|
||
float objRight = obj.Left + obj.Ancho;
|
||
float objBottom = obj.Top + obj.Alto;
|
||
|
||
left = Math.Min(left, objLeft);
|
||
top = Math.Min(top, objTop);
|
||
right = Math.Max(right, objRight);
|
||
bottom = Math.Max(bottom, objBottom);
|
||
|
||
Console.WriteLine($"DEBUG: Object {obj.Id.Value} bounds - L:{objLeft} T:{objTop} R:{objRight} B:{objBottom}");
|
||
}
|
||
|
||
if (left == float.MaxValue) // No se encontraron objetos válidos
|
||
throw new InvalidOperationException("No se encontraron objetos válidos para calcular el bounding box");
|
||
|
||
Console.WriteLine($"DEBUG: Final bounding box - L:{left} T:{top} W:{right - left} H:{bottom - top}");
|
||
|
||
return new ScreenshotArea
|
||
{
|
||
Left = left,
|
||
Top = top,
|
||
Width = right - left,
|
||
Height = bottom - top
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// SOLUCIÓN 2: Calcula el bounding box mejorado que maneja objetos con dimensiones 0.0
|
||
/// </summary>
|
||
private ScreenshotArea CalculateObjectsBoundingBoxImproved(List<osBase> objects)
|
||
{
|
||
if (!objects.Any())
|
||
throw new ArgumentException("La lista de objetos no puede estar vacía");
|
||
|
||
float left = float.MaxValue;
|
||
float top = float.MaxValue;
|
||
float right = float.MinValue;
|
||
float bottom = float.MinValue;
|
||
|
||
foreach (var obj in objects)
|
||
{
|
||
// Obtener dimensiones reales del objeto
|
||
float objWidth = obj.Ancho;
|
||
float objHeight = obj.Alto;
|
||
|
||
// SOLUCIÓN 2: Manejar objetos con dimensiones 0.0 (como botellas)
|
||
if (objWidth <= 0.0f || objHeight <= 0.0f)
|
||
{
|
||
// Usar dimensiones por defecto basadas en el tipo de objeto
|
||
if (obj.GetType().Name == "osBotella")
|
||
{
|
||
objWidth = 0.2f; // 20cm por defecto para botellas
|
||
objHeight = 0.2f;
|
||
}
|
||
else
|
||
{
|
||
objWidth = Math.Max(objWidth, 0.1f); // Mínimo 10cm
|
||
objHeight = Math.Max(objHeight, 0.1f);
|
||
}
|
||
}
|
||
|
||
float objLeft = obj.Left - objWidth / 2; // Centrar el objeto
|
||
float objTop = obj.Top - objHeight / 2;
|
||
float objRight = obj.Left + objWidth / 2;
|
||
float objBottom = obj.Top + objHeight / 2;
|
||
|
||
left = Math.Min(left, objLeft);
|
||
top = Math.Min(top, objTop);
|
||
right = Math.Max(right, objRight);
|
||
bottom = Math.Max(bottom, objBottom);
|
||
|
||
Trace.WriteLine($"[ScreenshotManager] Object {obj.Id.Value} ({obj.GetType().Name}) - Original: {obj.Ancho}×{obj.Alto}, Used: {objWidth}×{objHeight}");
|
||
}
|
||
|
||
if (left == float.MaxValue)
|
||
throw new InvalidOperationException("No se encontraron objetos válidos para calcular el bounding box");
|
||
|
||
var finalWidth = right - left;
|
||
var finalHeight = bottom - top;
|
||
|
||
// Asegurar dimensiones mínimas
|
||
if (finalWidth < 0.5f)
|
||
{
|
||
var center = (left + right) / 2;
|
||
left = center - 0.25f;
|
||
right = center + 0.25f;
|
||
finalWidth = 0.5f;
|
||
}
|
||
|
||
if (finalHeight < 0.5f)
|
||
{
|
||
var center = (top + bottom) / 2;
|
||
top = center - 0.25f;
|
||
bottom = center + 0.25f;
|
||
finalHeight = 0.5f;
|
||
}
|
||
|
||
Trace.WriteLine($"[ScreenshotManager] Bounding box mejorado - L:{left:F2} T:{top:F2} W:{finalWidth:F2} H:{finalHeight:F2}");
|
||
|
||
return new ScreenshotArea
|
||
{
|
||
Left = left,
|
||
Top = top,
|
||
Width = finalWidth,
|
||
Height = finalHeight
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// Captura un área específica del canvas
|
||
/// </summary>
|
||
private RenderTargetBitmap CaptureCanvasArea(ScreenshotArea area, bool includeBackground)
|
||
{
|
||
// Asegurar que el canvas esté actualizado
|
||
_canvas.UpdateLayout();
|
||
|
||
// Convertir área de metros a píxeles
|
||
var pixelLeft = PixelToMeter.Instance.calc.MetersToPixels(area.Left);
|
||
var pixelTop = PixelToMeter.Instance.calc.MetersToPixels(area.Top);
|
||
var pixelWidth = PixelToMeter.Instance.calc.MetersToPixels(area.Width);
|
||
var pixelHeight = PixelToMeter.Instance.calc.MetersToPixels(area.Height);
|
||
|
||
var captureRect = new Rect(pixelLeft, pixelTop, pixelWidth, pixelHeight);
|
||
|
||
// Validar que el área esté dentro del canvas
|
||
var canvasRect = new Rect(0, 0, _canvas.ActualWidth, _canvas.ActualHeight);
|
||
if (!canvasRect.IntersectsWith(captureRect))
|
||
throw new ArgumentException("El área especificada está fuera del canvas");
|
||
|
||
// Intersectar con el canvas para evitar áreas fuera de límites
|
||
captureRect.Intersect(canvasRect);
|
||
|
||
return CaptureCanvasRect(captureRect, includeBackground);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Captura todo el canvas
|
||
/// </summary>
|
||
private RenderTargetBitmap CaptureEntireCanvas(bool includeBackground)
|
||
{
|
||
_canvas.UpdateLayout();
|
||
var canvasRect = new Rect(0, 0, _canvas.ActualWidth, _canvas.ActualHeight);
|
||
return CaptureCanvasRect(canvasRect, includeBackground);
|
||
}
|
||
|
||
/// <summary>
|
||
/// SOLUCIÓN 3: Captura un rectángulo específico del canvas usando DrawingVisual (sin VisualBrush)
|
||
/// </summary>
|
||
private RenderTargetBitmap CaptureCanvasRect(Rect captureRect, bool includeBackground)
|
||
{
|
||
if (captureRect.Width <= 0 || captureRect.Height <= 0)
|
||
throw new ArgumentException("Las dimensiones de captura deben ser mayores que 0");
|
||
|
||
// SOLUCIÓN 3: Reducir scaleFactor de 2.0 a 1.0 para evitar problemas de memoria
|
||
var scaleFactor = 1.0; // Reducido para mayor estabilidad
|
||
var renderWidth = Math.Max(1, (int)(captureRect.Width * scaleFactor));
|
||
var renderHeight = Math.Max(1, (int)(captureRect.Height * scaleFactor));
|
||
var dpi = 96 * scaleFactor;
|
||
|
||
Trace.WriteLine($"[ScreenshotManager] Capturando {renderWidth}×{renderHeight} px (scaleFactor: {scaleFactor})");
|
||
|
||
var renderBitmap = new RenderTargetBitmap(
|
||
renderWidth,
|
||
renderHeight,
|
||
dpi,
|
||
dpi,
|
||
PixelFormats.Pbgra32);
|
||
|
||
// SOLUCIÓN 3 CORREGIDA: Enfoque híbrido - Canvas temporal con VisualBrush mejorado
|
||
var tempCanvas = new Canvas()
|
||
{
|
||
Width = captureRect.Width * scaleFactor,
|
||
Height = captureRect.Height * scaleFactor,
|
||
Background = includeBackground ? _canvas.Background : Brushes.White
|
||
};
|
||
|
||
tempCanvas.RenderTransform = new ScaleTransform(scaleFactor, scaleFactor);
|
||
|
||
// Forzar actualización de layout del canvas principal antes de capturar
|
||
_canvas.UpdateLayout();
|
||
_canvas.InvalidateVisual();
|
||
|
||
// Renderizar elementos con VisualBrush mejorado
|
||
int elementCount = 0;
|
||
foreach (UIElement child in _canvas.Children)
|
||
{
|
||
if (ValidateElementForCapture(child, captureRect))
|
||
{
|
||
try
|
||
{
|
||
var left = Canvas.GetLeft(child);
|
||
var top = Canvas.GetTop(child);
|
||
|
||
// SOLUCIÓN 3: Validación mejorada de coordenadas
|
||
if (double.IsNaN(left)) left = 0;
|
||
if (double.IsNaN(top)) top = 0;
|
||
if (double.IsInfinity(left) || double.IsInfinity(top)) continue;
|
||
|
||
var elementRect = new Rect(left, top, child.RenderSize.Width, child.RenderSize.Height);
|
||
|
||
if (captureRect.IntersectsWith(elementRect))
|
||
{
|
||
// Forzar actualización del UserControl
|
||
child.UpdateLayout();
|
||
child.InvalidateVisual();
|
||
|
||
// Usar VisualBrush mejorado con manejo robusto de errores
|
||
try
|
||
{
|
||
var visualBrush = new VisualBrush(child)
|
||
{
|
||
Stretch = Stretch.None,
|
||
AlignmentX = AlignmentX.Left,
|
||
AlignmentY = AlignmentY.Top,
|
||
ViewboxUnits = BrushMappingMode.Absolute,
|
||
Viewbox = new Rect(0, 0, child.RenderSize.Width, child.RenderSize.Height)
|
||
};
|
||
|
||
var rect = new Rectangle()
|
||
{
|
||
Width = child.RenderSize.Width * scaleFactor,
|
||
Height = child.RenderSize.Height * scaleFactor,
|
||
Fill = visualBrush
|
||
};
|
||
|
||
Canvas.SetLeft(rect, (elementRect.X - captureRect.X) * scaleFactor);
|
||
Canvas.SetTop(rect, (elementRect.Y - captureRect.Y) * scaleFactor);
|
||
|
||
tempCanvas.Children.Add(rect);
|
||
elementCount++;
|
||
|
||
Trace.WriteLine($"[ScreenshotManager] Capturado UserControl: {child.GetType().Name} en ({elementRect.X:F1}, {elementRect.Y:F1})");
|
||
}
|
||
catch (Exception brushEx)
|
||
{
|
||
Trace.WriteLine($"[ScreenshotManager] Error con VisualBrush para {child.GetType().Name}: {brushEx.Message}");
|
||
|
||
// Fallback: Rectángulo de placeholder
|
||
var placeholder = new Rectangle()
|
||
{
|
||
Width = child.RenderSize.Width * scaleFactor,
|
||
Height = child.RenderSize.Height * scaleFactor,
|
||
Fill = Brushes.LightGray,
|
||
Stroke = Brushes.Red,
|
||
StrokeThickness = 2
|
||
};
|
||
|
||
Canvas.SetLeft(placeholder, (elementRect.X - captureRect.X) * scaleFactor);
|
||
Canvas.SetTop(placeholder, (elementRect.Y - captureRect.Y) * scaleFactor);
|
||
tempCanvas.Children.Add(placeholder);
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Trace.WriteLine($"[ScreenshotManager] Error procesando elemento {child.GetType().Name}: {ex.Message}");
|
||
}
|
||
}
|
||
}
|
||
|
||
Trace.WriteLine($"[ScreenshotManager] Renderizados {elementCount} elementos UserControl");
|
||
|
||
// Renderizar canvas temporal mejorado
|
||
var scaledSize = new Size(captureRect.Width * scaleFactor, captureRect.Height * scaleFactor);
|
||
tempCanvas.Measure(scaledSize);
|
||
tempCanvas.Arrange(new Rect(0, 0, scaledSize.Width, scaledSize.Height));
|
||
tempCanvas.UpdateLayout();
|
||
|
||
renderBitmap.Render(tempCanvas);
|
||
return renderBitmap;
|
||
}
|
||
|
||
/// <summary>
|
||
/// SOLUCIÓN 3: Valida si un elemento debe ser incluido en la captura
|
||
/// </summary>
|
||
private bool ValidateElementForCapture(UIElement element, Rect captureRect)
|
||
{
|
||
if (element.Visibility != Visibility.Visible)
|
||
return false;
|
||
|
||
if (element.RenderSize.Width <= 0 || element.RenderSize.Height <= 0)
|
||
return false;
|
||
|
||
var left = Canvas.GetLeft(element);
|
||
var top = Canvas.GetTop(element);
|
||
|
||
// Validación mejorada de posiciones
|
||
if (double.IsNaN(left) || double.IsNaN(top) ||
|
||
double.IsInfinity(left) || double.IsInfinity(top))
|
||
return false;
|
||
|
||
var elementRect = new Rect(left, top, element.RenderSize.Width, element.RenderSize.Height);
|
||
return captureRect.IntersectsWith(elementRect);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Procesa la salida del screenshot (guardar archivo y/o generar base64)
|
||
/// </summary>
|
||
private ScreenshotResult ProcessScreenshotOutput(ScreenshotResult result, string filename, bool saveToFile, bool returnBase64)
|
||
{
|
||
try
|
||
{
|
||
// Generar nombre de archivo si no se proporcionó
|
||
if (string.IsNullOrEmpty(filename))
|
||
{
|
||
var typePrefix = result.CaptureType.ToString().ToLower();
|
||
filename = $"{typePrefix}_screenshot_{DateTime.Now:yyyyMMdd_HHmmss}.png";
|
||
}
|
||
|
||
// Asegurar extensión .png
|
||
if (!filename.ToLower().EndsWith(".png"))
|
||
filename += ".png";
|
||
|
||
// Guardar archivo si se solicita
|
||
if (saveToFile)
|
||
{
|
||
Directory.CreateDirectory(_defaultScreenshotsDirectory);
|
||
var fullPath = System.IO.Path.IsPathRooted(filename) ? filename : System.IO.Path.Combine(_defaultScreenshotsDirectory, filename);
|
||
|
||
var encoder = new PngBitmapEncoder();
|
||
encoder.Frames.Add(BitmapFrame.Create(result.Bitmap));
|
||
|
||
using (var fileStream = new FileStream(fullPath, FileMode.Create))
|
||
{
|
||
encoder.Save(fileStream);
|
||
}
|
||
|
||
var fileInfo = new FileInfo(fullPath);
|
||
result.FilePath = fullPath;
|
||
result.FileName = System.IO.Path.GetFileName(fullPath);
|
||
result.Directory = System.IO.Path.GetDirectoryName(fullPath);
|
||
result.FileSizeBytes = fileInfo.Length;
|
||
}
|
||
|
||
// Generar base64 solo si se cumplen las condiciones restrictivas
|
||
if (returnBase64 && ShouldGenerateBase64(result))
|
||
{
|
||
using (var memoryStream = new MemoryStream())
|
||
{
|
||
var encoder = new PngBitmapEncoder();
|
||
encoder.Frames.Add(BitmapFrame.Create(result.Bitmap));
|
||
encoder.Save(memoryStream);
|
||
result.Base64Data = Convert.ToBase64String(memoryStream.ToArray());
|
||
}
|
||
}
|
||
else if (returnBase64)
|
||
{
|
||
// Informar por qué no se generó el base64
|
||
result.Base64SkipReason = GetBase64SkipReason(result);
|
||
}
|
||
|
||
result.Timestamp = DateTime.Now;
|
||
return result;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
result.Success = false;
|
||
result.ErrorMessage = $"Error procesando salida: {ex.Message}";
|
||
result.ErrorType = ex.GetType().Name;
|
||
return result;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Determina si se debe generar base64 basado en las restricciones de tamaño y cantidad de objetos
|
||
/// </summary>
|
||
private bool ShouldGenerateBase64(ScreenshotResult result)
|
||
{
|
||
const int MAX_DIMENSION = 1024;
|
||
|
||
// Solo permitir base64 para objetos únicos
|
||
if (result.CaptureType == ScreenshotType.Objects && (result.CapturedObjects?.Count != 1))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// Verificar dimensiones de la imagen
|
||
if (result.Bitmap != null)
|
||
{
|
||
if (result.Bitmap.PixelWidth > MAX_DIMENSION || result.Bitmap.PixelHeight > MAX_DIMENSION)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// No generar base64 para canvas completo o áreas grandes
|
||
if (result.CaptureType == ScreenshotType.FullCanvas)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Obtiene la razón por la cual no se generó el base64
|
||
/// </summary>
|
||
private string GetBase64SkipReason(ScreenshotResult result)
|
||
{
|
||
const int MAX_DIMENSION = 1024;
|
||
|
||
if (result.CaptureType == ScreenshotType.FullCanvas)
|
||
{
|
||
return "Base64 no generado: Canvas completo excede límites de tokens";
|
||
}
|
||
|
||
if (result.CaptureType == ScreenshotType.Objects && (result.CapturedObjects?.Count != 1))
|
||
{
|
||
return $"Base64 no generado: Solo se permite para objetos únicos (encontrados: {result.CapturedObjects?.Count ?? 0})";
|
||
}
|
||
|
||
if (result.Bitmap != null && (result.Bitmap.PixelWidth > MAX_DIMENSION || result.Bitmap.PixelHeight > MAX_DIMENSION))
|
||
{
|
||
return $"Base64 no generado: Imagen excede {MAX_DIMENSION}x{MAX_DIMENSION} píxeles (actual: {result.Bitmap.PixelWidth}x{result.Bitmap.PixelHeight})";
|
||
}
|
||
|
||
return "Base64 no generado: Condiciones no cumplidas";
|
||
}
|
||
|
||
#endregion
|
||
}
|
||
|
||
#region Data Classes
|
||
|
||
/// <summary>
|
||
/// Resultado de una operación de screenshot
|
||
/// </summary>
|
||
public class ScreenshotResult
|
||
{
|
||
public bool Success { get; set; }
|
||
public string ErrorMessage { get; set; }
|
||
public string ErrorType { get; set; }
|
||
public RenderTargetBitmap Bitmap { get; set; }
|
||
public ScreenshotType CaptureType { get; set; }
|
||
public string FilePath { get; set; }
|
||
public string FileName { get; set; }
|
||
public string Directory { get; set; }
|
||
public long FileSizeBytes { get; set; }
|
||
public string Base64Data { get; set; }
|
||
public string Base64SkipReason { get; set; }
|
||
public DateTime Timestamp { get; set; }
|
||
public bool IncludeBackground { get; set; }
|
||
public List<CapturedObjectInfo> CapturedObjects { get; set; } = new List<CapturedObjectInfo>();
|
||
public AreaInfo BoundingBox { get; set; }
|
||
public AreaInfo CaptureArea { get; set; }
|
||
public float PaddingMeters { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// Información de un objeto capturado
|
||
/// </summary>
|
||
public class CapturedObjectInfo
|
||
{
|
||
public string Id { get; set; }
|
||
public string Name { get; set; }
|
||
public string Type { get; set; }
|
||
public float Left { get; set; }
|
||
public float Top { get; set; }
|
||
public float Width { get; set; }
|
||
public float Height { get; set; }
|
||
public float CenterX { get; set; }
|
||
public float CenterY { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// Información de un área
|
||
/// </summary>
|
||
public class AreaInfo
|
||
{
|
||
public float Left { get; set; }
|
||
public float Top { get; set; }
|
||
public float Width { get; set; }
|
||
public float Height { get; set; }
|
||
public float CenterX { get; set; }
|
||
public float CenterY { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// Área de screenshot en coordenadas de metros
|
||
/// </summary>
|
||
internal class ScreenshotArea
|
||
{
|
||
public float Left { get; set; }
|
||
public float Top { get; set; }
|
||
public float Width { get; set; }
|
||
public float Height { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// Tipos de captura de screenshot
|
||
/// </summary>
|
||
public enum ScreenshotType
|
||
{
|
||
Objects,
|
||
Area,
|
||
FullCanvas
|
||
}
|
||
|
||
#endregion
|
||
}
|