Aspose.Medical DICOM Anonymizer für .NET Knowledge Base
Wie man eine Folie von DICOM-Studien anonymisiert

Wie man eine Folie von DICOM-Studien anonymisiert

Dieses Tutorial zeigt, wie man mehrere DICOM-Dateien aus einer Folie mit C# anonymisiert.Wenn man mit Hundert oder Tausenden medizinischer Bilddateien arbeitet, ist die Verarbeitung von Batch für Effizienz und Konsistenz unerlässlich.

Vorteile der Batch Anonymisierung

  • Effizienz:- Verarbeiten Sie die gesamten Studien oder Archive in einer einzigen Operation.

  • Konsistenz:- Verwenden Sie die gleichen Anonymisierungsregeln für alle Dateien.

  • Automatisierung:- Integrieren Sie in automatisierte Workflows und Pipelines.

Voraussetzungen: Umwelt vorbereiten

  • Installieren Sie Visual Studio oder eine kompatible .NET IDE.
  • Erstellen Sie ein neues .NET 8-Konsole-Anwendungsprojekt.
  • Installieren Sie Aspose.Medical vom NuGet Package Manager.
  • Bereiten Sie die Eingabefolder mit DICOM-Dateien vor und erstellen Sie eine Ausgangsfolde.

Schritt für Schritt Guide to Batch Anonymize DICOM-Dateien

Schritt 1: Installieren Aspose.Medical

Fügen Sie die Aspose.Medical Bibliothek zu Ihrem Projekt mit NuGet hinzu.

Install-Package Aspose.Medical

Schritt 2: Inkludieren Sie notwendige Namenräume

Fügen Sie Referenzen zu den erforderlichen Namenräumen in Ihrem Code hinzu.

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

Schritt 3: Set Up Directory Paths

Definieren Sie Ihre Eingangs- und Ausgangsdirektorswege.

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

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

Schritt 4: Die Liste der DICOM-Dateien

Erhalten Sie alle DICOM-Dateien aus der Eingabe-Direktorie, einschließlich Unterdirektorien.

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

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

Schritt 5: Erstellen Sie den Anonymizer

Erstellen Sie eine Anonymisierungsinstanz mit Ihrem gewünschten Profil.

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

Schritt 6: Prozesse jedes Datei

Laufen Sie durch jeden Datei, anonymisieren Sie ihn und speichern Sie es in die Ausgangsdirektion.

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

Komplett Code Beispiel für Batch Anonymisierung

Hier ist ein vollständiges Beispiel für die Anonymisierung von Batch mit Fortschrittsberichten:

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

Parallelle Verarbeitung für bessere Leistung

Für große Datensätze verwenden Sie die parallele Verarbeitung, um mehrere CPU-Kore zu nutzen:

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

Verbesserte Version mit Logging

Für Produktionsumgebungen implementieren Sie eine ordnungsgemäße Logging:

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

Best Practices für die Batch-Verarbeitung

  • Run on Copy of Data: Sie verarbeiten immer eine Kopie Ihrer ursprünglichen Daten, nicht die Originale selbst.
  • Log All Operations: Speichern Sie detaillierte Logs, von denen Dateien verarbeitet wurden und Fehler aufgetreten sind.
  • Test First: Durchführen Sie eine kleine Probe vor der Verarbeitung des gesamten Datensatzes.
  • Monitor Disk Space: Gewährleistet genügend Diskplatz für Output-Dateien.
  • Handle Interruptions: Betrachten Sie die Implementierung von Checkpoint/Resume-Funktionalität für sehr große Batches.

Troubleshooting

Speicherprobleme mit großen Datensätzen

Für sehr große Dateien oder Datensätze verarbeiten Sie Dateien einmal in einmal, ohne Referenzen zu behalten:

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
}

Erlaubnisfehler

Stellen Sie sicher, dass Ihre Anwendung Zugriff auf den Eingabe-Dokument gelesen hat und Zugang zu dem Ausgangsdirektor schreibt.

Schlussfolgerungen

Dieses Tutorial hat gezeigt, wie man DICOM-Dateien in C# mit Aspose.Medical anonymisieren kann. Ob Hunderte oder Tausende von Dateien verarbeitet werden, sorgt der Batch-Ansatz für eine konsistente Anonymisierung über den gesamten Datensatz und bietet gleichzeitig Fortschritte-Tracking und Fehlerbehandlung für die Zuverlässigkeit der Produktion.

 Deutsch