Aspose.Medical DICOM Anonymizer voor .NET Knowledge Base
Hoe om een folder van DICOM-studies anoniem te maken

Hoe om een folder van DICOM-studies anoniem te maken

Deze tutorial toont hoe u meerdere DICOM-bestanden van een map met behulp van C# anoniem te verzamelen.Wanneer u werkt met honderden of duizenden medische beelden, is verwerking van de verpakking essentieel voor efficiëntie en consistentie.

De voordelen van Batch Anonymisatie

  • Efficiëntie:- Het verwerken van alle studies of archieven in één operatie.

  • De consistentie:- Gebruik dezelfde anoniemregels voor alle bestanden.

  • Automatisering:- Integreren in geautomatiseerde werkstromen en pijpleidingen.

Voorwaarden: het voorbereiden van het milieu

  • Installeer Visual Studio of een compatibele .NET IDE.
  • Maak een nieuw .NET 8 console-applicatieproject.
  • Installeer Aspose.Medical vanaf de NuGet Package Manager.
  • Bereid de input map voor met DICOM-bestanden en creëer een output map.

Step-by-Step Guide to Batch Anonymize DICOM-bestanden

Stap 1: Installeer Aspose.Medical

Voeg de Aspose.Medische bibliotheek toe aan uw project met behulp van NuGet.

Install-Package Aspose.Medical

Stap 2: Inkluderen van noodzakelijke naamruimten

Voeg verwijzingen toe aan de vereiste naamruimten in uw code.

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

Stap 3: Set up Directory Paths

Definieer uw input en output directory paden.

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

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

Stap 4: Verwijder de DICOM-bestanden

Krijg alle DICOM-bestanden uit de invoerdirectorie, inclusief subdictories.

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

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

Stap 5: Creëren van de Anonymizer

Maak een Anonymizer-instantie met uw gewenste profiel.

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

Stap 6: Verwerken van elk bestand

Ga door elke bestand, geanonimiseerd en opgeslagen in de output directory.

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

Volledige code voorbeeld voor Batch Anonymisatie

Hier is een volledige voorbeeld van het demonstreren van de anonimiteit van batch met voortgangsrapportage:

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

Parallele verwerking voor betere prestaties

Voor grote datasets, gebruik parallelle verwerking om meerdere CPU-cores te leveren:

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

Verbeterde versie met logging

Voor productieomgevingen, implementeren van de juiste 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}");

Beste praktijken voor batchverwerking

  • Run on Copy of Data: Altijd een kopie van uw oorspronkelijke gegevens verwerkt, niet de originelen zelf.
  • Log Alle Operaties: Houd gedetailleerde logs van welke bestanden zijn verwerkt en eventuele fouten ontstonden.
  • Test First: rijden op een klein voorbeeld voordat u het hele dataset verwerkt.
  • Monitor Disk Space: Zorg ervoor dat er voldoende schijfruimte is voor outputbestanden.
  • ** Handle Interruptions**: Overweeg de implementatie van checkpoint/resume functionaliteit voor zeer grote partijen.

Troubleshooting

Memorieproblemen met grote datasets

Voor zeer grote bestanden of datasets, verwerken van bestand één op een keer zonder referenties te houden:

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
}

Autorisatiefouten

Zorg ervoor dat uw applicatie toegang heeft gelezen tot de ingangsdirectie en toegang schrijft tot het uitgangsdictie.

Conclusie

Deze tutorial heeft aangetoond hoe om DICOM-bestanden anoniem te verzamelen in C# met behulp van Aspose.Medical. Of het nu honderden of duizenden bestanden verwerkt, zorgt de aanpak voor consistente anonimiteit over uw gehele dataset terwijl het vooruitgang tracking en foutenbehandeling biedt voor productie betrouwbaarheid.

 Nederlands