Aspose.Medical DICOM Anonymizer untuk .NET Knowledge Base
Bagaimana untuk menganonimkan folder studi DICOM

Bagaimana untuk menganonimkan folder studi DICOM

Tutorial ini menunjukkan bagaimana untuk membungkus anonim beberapa file DICOM dari folder menggunakan C#. Ketika bekerja dengan ratusan atau ribuan file gambar medis, pemrosesan batch penting untuk efisiensi dan konsistensi.

Manfaat Anonimitas Batch

  • Efisiensi:- Proses seluruh studi atau arkib dalam satu operasi.

  • Konsistensi:- Gunakan aturan anonimitas yang sama untuk semua file.

  • Automatik:- Mengintegrasikan ke dalam aliran kerja otomatis dan pipa.

Persyaratan: Persiapan Lingkungan

  • Menginstal Visual Studio atau IDE .NET yang kompatibel.
  • Mencipta aplikasi .NET 8 baru.
  • Instal Aspose.Medical dari NuGet Package Manager.
  • Siapkan folder input dengan file DICOM dan buat folder output.

Langkah-langkah Panduan untuk Batch Anonymous DICOM File

Langkah 1: Instalasi Aspose.Medical

Tambahkan perpustakaan Aspose.Medical ke proyek Anda menggunakan NuGet.

Install-Package Aspose.Medical

Langkah 2: Menyertakan ruang nama yang diperlukan

Tambahkan referensi ke ruang nama yang diperlukan dalam kode Anda.

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

Langkah 3: Mengatur jalur direktori

Tentukan jalur catatan input dan output Anda.

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

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

Langkah 4: Daftar file DICOM

Dapatkan semua file DICOM dari direktori input, termasuk subdirektori.

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

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

Langkah 5: Membuat Anonim

Buat contoh anonim dengan profil yang Anda inginkan.

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

Langkah 6: Memproses setiap file

Berjalan melalui setiap file, anonimkannya, dan menyimpannya ke direktori output.

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

Contoh kode lengkap untuk anonimitas batch

Berikut adalah contoh lengkap yang menunjukkan anonimitas batch dengan laporan kemajuan:

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

Pemprosesan paralel untuk kinerja yang lebih baik

Untuk set data besar, gunakan pemrosesan paralel untuk memanfaatkan beberapa inti 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 yang lebih baik dengan logging

Untuk lingkungan produksi, melaksanakan logging yang tepat:

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

Praktik terbaik untuk Batch Processing

  • Run on Copy of Data: Selalu memproses salinan data asli Anda, bukan yang asli itu sendiri.
  • Log Semua Operasi: Simpan log terperinci dari file yang diproses dan kesalahan yang terjadi.
  • Test First: Berjalan pada sampel kecil sebelum memproses seluruh set data.
  • Monitor Disk Space: Memastikan ruang cakera yang cukup untuk file output.
  • Handle Interruptions: Pertimbangkan untuk melaksanakan fungsi checkpoint/resume untuk batch yang sangat besar.

Troubleshooting

Masalah memori dengan data besar

Untuk file yang sangat besar atau set data, memproses file satu demi satu tanpa mempertahankan referensi:

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
}

Kesalahan Permisi

Pastikan aplikasi Anda telah membaca akses ke direktori input dan menulis akses kepada Direktori output.

Kesimpulan

Tutorial ini telah menunjukkan bagaimana untuk membungkus anonim file DICOM dalam C# menggunakan Aspose.Medical. Apakah memproses ratusan atau ribuan file, pendekatan batch memastikan anonymisasi konsisten di seluruh set data Anda sambil memberikan pengesanan kemajuan dan pengendalian kesalahan untuk kebolehpercayaan produksi.

 Indonesia