Aspose.Medical DICOM Anonymizer pour la base de connaissances .NET
Comment Batch Anonymiser un dossier d'études DICOM

Comment Batch Anonymiser un dossier d'études DICOM

Ce tutoriel démontre comment combiner des fichiers DICOM multiples anonymisés à partir d’un dossier en utilisant C#. Lorsque vous travaillez avec des centaines ou des milliers d’images médicaux, le traitement du batch est essentiel pour l’efficacité et la cohérence.

Les avantages de l’anonymisation de Batch

  • Efficacité:- Traitement de l’ensemble des études ou des archives dans une seule opération.

  • La cohérence:- Appliquez les mêmes règles d’anonymisation à tous les fichiers.

  • Automatisation:- Intégrer dans les flux de travail automatisés et les pipelines.

Étiquette : Préparer l’environnement

  • Configurez Visual Studio ou tout IDE .NET compatible.
  • Créer un nouveau projet d’application pour la console .NET 8.
  • Installez Aspose.Medical à partir du NuGet Package Manager.
  • Préparez le dossier d’entrée avec les fichiers DICOM et créez un dossier de sortie.

Guide Step-by-Step pour Batch Anonymiser les fichiers DICOM

Étape 1 : Installer Aspose.Medical

Ajoutez la bibliothèque Aspose.Medical à votre projet en utilisant NuGet.

Install-Package Aspose.Medical

Étape 2 : Inclure les espaces de nom nécessaires

Ajoutez des références aux espaces de nom requis dans votre code.

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

Étape 3 : Mettre en place les pistes de directeur

Définissez vos itinéraires d’entrée et de sortie.

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

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

Étape 4 : Énumérer les fichiers DICOM

Obtenez tous les fichiers DICOM de la directory d’entrée, y compris les sous-directeurs.

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

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

Étape 5 : Créer l’anonymat

Créez un exemple d’anonymisation avec votre profil souhaité.

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

Étape 6 : Travailler chaque fichier

Passez à travers chaque fichier, l’anonymisez et sauvez dans le catalogue de sortie.

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 code complet pour l’anonymisation de Batch

Voici un exemple complet de la démonstration de l’anonymisation du groupe avec le rapport de 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($"========================================");

Traitement parallèle pour une meilleure performance

Pour les grands ensembles de données, utilisez le traitement parallèle pour exploiter plusieurs cœurs 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}");
    }
}

Version améliorée avec logging

Pour les environnements de production, mettre en œuvre le logage approprié:

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 meilleures pratiques pour le traitement de batch

  • Run sur Copie des données: Traite toujours une copie de vos données originales, pas les données originaux.
  • Log Toutes les opérations: Gardez des journaux détaillés sur lesquels les fichiers ont été traités et les erreurs rencontrées.
  • Test First: Exécuter sur un petit échantillon avant de traiter l’ensemble des données.
  • Monitor Disk Space: Assurez un espace de disque suffisant pour les fichiers de sortie.
  • Handle Interruptions: considérer la mise en œuvre de la fonctionnalité de checkpoint/resume pour les lots très grands.

Troubleshooting

Problèmes de mémoire avec de grandes données

Pour les fichiers très grands ou les ensembles de données, traiter les dossiers un à l’autre sans conserver des références :

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
}

Erreurs de permission

Assurez-vous que votre application a lu l’accès à la directory d’entrée et écrite l’accès au directeur de sortie.

Conclusion

Ce tutoriel a démontré comment s’anonymiser les fichiers DICOM en C# en utilisant Aspose.Medical. Que ce soit pour traiter des centaines ou des milliers de dossiers, l’approche d’emballage assure une anonymisation cohérente à travers votre ensemble de données tout en fournissant le suivi des progrès et le traitement des erreurs pour la fiabilité de la production.

 Français