Aspose.Medical DICOM Anonymizer per a la base de coneixements .NET
Com anomenar un full d'estudis de DICOM

Com anomenar un full d'estudis de DICOM

Aquest tutorial demostra com batxar anònims múltiples arxius DICOM d’una carpeta utilitzant C#. Quan es treballa amb centenars o milers de fotografies mèdiques, el processament de batxets és essencial per a l’eficiència i la consistència.

Beneficis de l’anonimat de Batch

  • Eficiència:- Processar tots els estudis o arxius en una sola operació.

  • Consistència:- Aplica les mateixes regles d’anonimatització a tots els arxius.

  • Automatitzaci:- Integració en fluxos de treball automatitzats i pipelines.

Previsió: Preparar el medi ambient

  • Instal·lació de Visual Studio o qualsevol compatible .NET IDE.
  • Crear un nou projecte d’aplicació .NET 8 consola.
  • Instal·la Aspose.Medical des del NuGet Package Manager.
  • Prepara la pasta d’entrada amb els arxius DICOM i crea una pasta de sortida.

Guia de pas a pas per Batch Anònimitzar arxius DICOM

Pas 1: Instal·lació Aspose.Medical

Afegeix la biblioteca d’Aspose.Medical al teu projecte utilitzant NuGet.

Install-Package Aspose.Medical

Pas 2: Incloure els espais de nom necessaris

Afegeix referències als espais de nom requerits en el teu codi.

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

Pas 3: Establir els camins de directori

Defineix els teus camins de directori d’entrada i sortida.

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

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

Pas 4: Enumera els arxius DICOM

Obtenir tots els arxius DICOM de la direcció d’entrada, incloses les subdireccions.

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

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

Pas 5: Creació de l’anonimat

Crea un exemple d’anonimat amb el teu perfil desitjat.

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

Pas 6: Processar cada fitxer

Passar a través de cada fitxer, anonimitzar-lo i salvar a la direcció de sortides.

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.");

Exemple de codi complet per a l’anonimat Batch

Aquí teniu un exemple complet de la demostració de l’anonimat del batx amb el reportatge del progrés:

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($"========================================");

Tractament paral·lel per a millors prestacions

Per a grans set de dades, utilitzeu el processament paral·lel per tal d’aprofitar diversos cossos de 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ó millorada amb logging

Per als entorns de producció, implementar el logging adequat:

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}");

Les millors pràctiques per al processament de batxillerat

  • Run on Copi de Dades: Sempre tractem una còpia de les teves dades originals, no les mateixes.
  • Log Totes les operacions: Mantenir registres detallats dels arxius dels quals s’han processat i qualsevol error es troba.
  • Test First: Feu una petita mostra abans de processar tot el conjunt de dades.
  • Monitor Disc Space: Assegurar espai suficient en el disc per a fitxers de sortida.
  • Interrupcions de comerç: Considera la implementació de la funcionalitat del punt de control/resum per a batxes molt grans.

Troubleshooting

Problemes de memòria amb grans dades

Per a fitxers molt grans o grups de dades, processar els arxius un a l’altre sense mantenir referències:

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
}

Errors de permís

Assegureu-vos que la vostra aplicació ha llegit l’accés a la direcció d’entrada i escriure accés al directori de sortida.

Conclusió

Aquest tutorial ha demostrat com batxar anònims de fitxers DICOM en C# utilitzant Aspose.Medical. Si es processen centenars o milers d’arxius, l’enfocament batch assegura una anonimització coherent a través de tot el conjunt de dades, mentre que proporciona el rastreig del progrés i el tractament dels errors per a la fiabilitat de la producció.

 Català