Aspose.Medical DICOM Anonymizer para .NET Knowledge Base
Cómo anonimizar un folleto de estudios de DICOM

Cómo anonimizar un folleto de estudios de DICOM

Este tutorial demuestra cómo combinar anónimos varios archivos DICOM de una carpeta utilizando C#. Al trabajar con cientos o miles de ficheros de imagen médica, el procesamiento de combinación es esencial para la eficiencia y la coherencia.

Beneficios de la anonimización de Batch

  • Eficiencia:- Procesar los estudios o archivos enteros en una sola operación.

  • Consistencia:- Aplique las mismas reglas de anonimato a todos los archivos.

  • Automación:- Integración en flujos de trabajo automatizados y tuberías.

Requisitos: Preparación del medio ambiente

  • Instalar Visual Studio o cualquier compatible .NET IDE.
  • Crea un nuevo proyecto de aplicación .NET 8 consola.
  • Instalar Aspose.Medical desde el NuGet Package Manager.
  • Prepare la carpeta de entrada con los archivos DICOM y crea una carpa de salida.

Guía paso a paso para anonimizar los archivos de DICOM

Paso 1: Instalar Aspose.Medical

Añade la biblioteca de Aspose.Medical a su proyecto utilizando NuGet.

Install-Package Aspose.Medical

Paso 2: Incluir los espacios de nombre necesarios

Añade las referencias a los espacios de nombre requeridos en su código.

using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Anonymization;

Paso 3: Configurar los pasos de directorios

Define sus caminos de directorio de entrada y salida.

string inputDirectory = @"C:\DicomStudies\Input";
string outputDirectory = @"C:\DicomStudies\Anonymized";

// Ensure output directory exists
Directory.CreateDirectory(outputDirectory);

Paso 4: Enumera los archivos DICOM

Obtenga todos los archivos DICOM del directorio de entrada, incluidas las subdirectorías.

string[] dicomFiles = Directory.GetFiles(
    inputDirectory, 
    "*.dcm", 
    SearchOption.AllDirectories
);

Console.WriteLine($"Found {dicomFiles.Length} DICOM files to process.");

Paso 5: Crea el anónimo

Crea un caso de Anonymizador con su perfil deseado.

Anonymizer anonymizer = new();
// Or with a custom profile:
// ConfidentialityProfile profile = ConfidentialityProfile.CreateDefault(
//     ConfidentialityProfileOptions.BasicProfile
// );
// Anonymizer anonymizer = new(profile);

Paso 6: Procesar cada archivo

Pasar por cada archivo, anonimizarlo y salvarlo en el directorio de salida.

int successCount = 0;
int failCount = 0;

foreach (string filePath in dicomFiles)
{
    try
    {
        // Load DICOM file
        DicomFile dcm = DicomFile.Open(filePath);
        
        // Anonymize
        DicomFile anonymizedDcm = anonymizer.Anonymize(dcm);
        
        // Preserve relative directory structure
        string relativePath = Path.GetRelativePath(inputDirectory, filePath);
        string outputPath = Path.Combine(outputDirectory, relativePath);
        
        // Ensure subdirectory exists
        Directory.CreateDirectory(Path.GetDirectoryName(outputPath)!);
        
        // Save anonymized file
        anonymizedDcm.Save(outputPath);
        
        successCount++;
        Console.WriteLine($"✓ Processed: {relativePath}");
    }
    catch (Exception ex)
    {
        failCount++;
        Console.WriteLine($"✗ Failed: {filePath} - {ex.Message}");
    }
}

Console.WriteLine($"\nCompleted: {successCount} succeeded, {failCount} failed.");

Exemplos de código completo para la anonimización de Batch

Aquí hay un ejemplo completo de demostración de la anonimización del grupo con el informe de progreso:

using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Anonymization;

string inputDirectory = @"C:\DicomStudies\Input";
string outputDirectory = @"C:\DicomStudies\Anonymized";

// Ensure output directory exists
Directory.CreateDirectory(outputDirectory);

// Get all DICOM files
string[] dicomFiles = Directory.GetFiles(inputDirectory, "*.dcm", SearchOption.AllDirectories);
Console.WriteLine($"Found {dicomFiles.Length} DICOM files to process.\n");

// Create anonymizer
Anonymizer anonymizer = new();

int successCount = 0;
int failCount = 0;
int total = dicomFiles.Length;

foreach (string filePath in dicomFiles)
{
    try
    {
        DicomFile dcm = DicomFile.Open(filePath);
        DicomFile anonymizedDcm = anonymizer.Anonymize(dcm);
        
        string relativePath = Path.GetRelativePath(inputDirectory, filePath);
        string outputPath = Path.Combine(outputDirectory, relativePath);
        Directory.CreateDirectory(Path.GetDirectoryName(outputPath)!);
        
        anonymizedDcm.Save(outputPath);
        successCount++;
        
        // Progress reporting
        double progress = (double)(successCount + failCount) / total * 100;
        Console.WriteLine($"[{progress:F1}%] ✓ {relativePath}");
    }
    catch (Exception ex)
    {
        failCount++;
        Console.WriteLine($"✗ Failed: {Path.GetFileName(filePath)} - {ex.Message}");
    }
}

Console.WriteLine($"\n========================================");
Console.WriteLine($"Batch Anonymization Complete");
Console.WriteLine($"Succeeded: {successCount}");
Console.WriteLine($"Failed: {failCount}");
Console.WriteLine($"========================================");

Procesamiento paralelo para un mejor rendimiento

Para los grandes conjuntos de datos, utilice el procesamiento paralelo para aprovechar varios núcleos CPU:

using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Anonymization;
using System.Collections.Concurrent;

string inputDirectory = @"C:\DicomStudies\Input";
string outputDirectory = @"C:\DicomStudies\Anonymized";

Directory.CreateDirectory(outputDirectory);

string[] dicomFiles = Directory.GetFiles(inputDirectory, "*.dcm", SearchOption.AllDirectories);
Console.WriteLine($"Found {dicomFiles.Length} DICOM files to process.\n");

// Thread-safe counters
int successCount = 0;
int failCount = 0;
ConcurrentBag<string> failedFiles = new();

// Process in parallel
Parallel.ForEach(dicomFiles, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, filePath =>
{
    try
    {
        // Each thread gets its own anonymizer instance
        Anonymizer anonymizer = new();
        
        DicomFile dcm = DicomFile.Open(filePath);
        DicomFile anonymizedDcm = anonymizer.Anonymize(dcm);
        
        string relativePath = Path.GetRelativePath(inputDirectory, filePath);
        string outputPath = Path.Combine(outputDirectory, relativePath);
        
        lock (outputDirectory) // Ensure directory creation is thread-safe
        {
            Directory.CreateDirectory(Path.GetDirectoryName(outputPath)!);
        }
        
        anonymizedDcm.Save(outputPath);
        Interlocked.Increment(ref successCount);
    }
    catch (Exception ex)
    {
        Interlocked.Increment(ref failCount);
        failedFiles.Add($"{filePath}: {ex.Message}");
    }
});

Console.WriteLine($"\nBatch Anonymization Complete");
Console.WriteLine($"Succeeded: {successCount}");
Console.WriteLine($"Failed: {failCount}");

if (failedFiles.Any())
{
    Console.WriteLine($"\nFailed files:");
    foreach (string failure in failedFiles)
    {
        Console.WriteLine($"  - {failure}");
    }
}

Versión mejorada con logging

Para los entornos de producción, implementar el logging adecuado:

using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Anonymization;

string inputDirectory = @"C:\DicomStudies\Input";
string outputDirectory = @"C:\DicomStudies\Anonymized";
string logFile = Path.Combine(outputDirectory, "anonymization_log.txt");

Directory.CreateDirectory(outputDirectory);

string[] dicomFiles = Directory.GetFiles(inputDirectory, "*.dcm", SearchOption.AllDirectories);

Anonymizer anonymizer = new();
List<string> logEntries = new();

logEntries.Add($"Anonymization started: {DateTime.Now}");
logEntries.Add($"Input directory: {inputDirectory}");
logEntries.Add($"Output directory: {outputDirectory}");
logEntries.Add($"Total files to process: {dicomFiles.Length}");
logEntries.Add("---");

int successCount = 0;
int failCount = 0;

foreach (string filePath in dicomFiles)
{
    string relativePath = Path.GetRelativePath(inputDirectory, filePath);
    
    try
    {
        DicomFile dcm = DicomFile.Open(filePath);
        DicomFile anonymizedDcm = anonymizer.Anonymize(dcm);
        
        string outputPath = Path.Combine(outputDirectory, relativePath);
        Directory.CreateDirectory(Path.GetDirectoryName(outputPath)!);
        anonymizedDcm.Save(outputPath);
        
        successCount++;
        logEntries.Add($"SUCCESS: {relativePath}");
    }
    catch (Exception ex)
    {
        failCount++;
        logEntries.Add($"FAILED: {relativePath} - {ex.Message}");
    }
}

logEntries.Add("---");
logEntries.Add($"Anonymization completed: {DateTime.Now}");
logEntries.Add($"Succeeded: {successCount}");
logEntries.Add($"Failed: {failCount}");

// Write log file
File.WriteAllLines(logFile, logEntries);

Console.WriteLine($"Processing complete. Log saved to: {logFile}");

Las mejores prácticas para el procesamiento de batch

  • Run on Copy of Data: siempre procesamos una copia de sus datos originales, no los mismos.
  • Log Todas las operaciones: Mantiene registros detallados de los archivos que se han procesado y cualquier error encontrado.
  • Test First: Ejecutar una muestra pequeña antes de procesar todo el conjunto de datos.
  • Monitor Disk Space: Asegurar espacio de disco suficiente para los archivos de salida.
  • Handle Interruptions: Considere la implementación de la funcionalidad de punto de verificación/resumen para batallas muy grandes.

Troubleshooting

Problemas de memoria con grandes conjuntos de datos

Para los archivos muy grandes o conjuntos de datos, procesar los ficheros una a la otra sin mantener las referencias:

foreach (string filePath in dicomFiles)
{
    using (DicomFile dcm = DicomFile.Open(filePath))
    {
        DicomFile anonymizedDcm = anonymizer.Anonymize(dcm);
        anonymizedDcm.Save(outputPath);
    }
    // Files are disposed after each iteration
}

Errores de permiso

Asegúrese de que su aplicación ha leído el acceso al directorio de entradas y escriba el derecho a la entrada.

Conclusión

Este tutorial ha demostrado cómo anonimizar los archivos DICOM en C# utilizando Aspose.Medical. Ya sea procesando cientos o miles de ficheros, el enfoque de batch garantiza una anónima coherente a través de todo su conjunto de datos mientras proporciona el seguimiento del progreso y el manejo de errores para la fiabilidad de la producción.

 Español