Aspose.Medical DICOM Anonymizer for .NET Knowledge Base
Hvordan Batch Anonymiserer en mappe av DICOM-studier

Hvordan Batch Anonymiserer en mappe av DICOM-studier

Denne veiledningen viser hvordan du kombinerer anonyme flere DICOM-filer fra en mappe ved hjelp av C#. Når du arbeider med hundrevis eller tusenvis av medisinske bildefiler, er kombinasjonsbehandling viktig for effektivitet og konsistens.

Fordelene med Batch Anonymisering

  • Effektivitet:- Prosessere hele studier eller arkiver i en enkelt operasjon.

  • Konsistens i forhold til:- Bruk de samme anonymiseringsreglene på alle filer.

  • Automatisering:- Integrere i automatiserte arbeidsflyter og rørledninger.

Forutsetninger: Å forberede miljøet

  • Installer Visual Studio eller noe kompatibelt .NET IDE.
  • Skap et nytt .NET 8 konsolapplikasjon prosjekt.
  • Installere Aspose.Medical fra NuGet Package Manager.
  • Forbereder input-mappen med DICOM-filer og oppretter en utgangsmapell.

Step-by-step guide til Batch Anonymize DICOM filer

Steg 1: Installere Aspose.Medical

Legg til Aspose.Medical Library til prosjektet ditt ved hjelp av NuGet.

Install-Package Aspose.Medical

Steg 2: Inkludere nødvendige navnområder

Legg til referanser til de nødvendige navnene i koden din.

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

Trinn 3: Sett opp katalogveier

Definer inn- og utgangsdialogen veier.

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

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

Steg 4: Liste opp DICOM-filer

Få alle DICOM-filer fra inngangsdialogen, inkludert underdirektorer.

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

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

Steg 5: Skap anonymiseren

Lag en Anonymiser instans med din ønskede profil.

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

Steg 6: Behandle hver fil

Gå gjennom hver fil, anonymisere den, og lagre den til utgangsdirektivet.

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 kodeksempel for batch anonymisering

Her er et komplett eksempel på demonstrasjon av batch anonymisering med fremgangsrapportering:

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

Parallell behandling for bedre ytelse

For store datasett, bruk parallell behandling for å levere flere CPU-kår:

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

Forbedret versjon med logging

For produksjonsmiljøer, implementere riktig 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 metoder for batchbehandling

  • Run on Copy of Data: Alltid behandle en kopi av dine opprinnelige data, ikke originalene selv.
  • Log All Operations: Lagre detaljerte logger av hvilke filer som ble behandlet og eventuelle feil oppdaget.
  • Test First: Kjør på en liten prøve før du behandler hele datasettet.
  • Monitor Disk Space: Sikre tilstrekkelig diskplass for utgangsfiler.
  • Handle Interruptions: Tenk på å implementere checkpoint/resume-funksjonalitet for svært store partier.

Troubleshooting

Memory problemer med store datasett

For svært store filer eller datasett, behandle filene én gang uten å holde referanser:

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
}

Tillatelsesfeil

Sørg for at applikasjonen har lest tilgang til inngangsdirektivet og skrive tilgangen til utgangsditorien.

Conclusion

Denne tutorialen har vist hvordan å pakke anonymiserte DICOM-filer i C# ved hjelp av Aspose.Medical. Uansett om du behandler hundrevis eller tusenvis av filer, sikrer pakken tilnærming konsekvent anonymisering over hele datasettet, samtidig som det gir fremgangssporing og feilbehandling for produksjon pålitelighet.

 Norsk