Aspose.Medical DICOM Anonymizer .NET žinių bazei
Kaip apibūdinti DICOM studijų failo anonimiškumą

Kaip apibūdinti DICOM studijų failo anonimiškumą

Šis mokymas rodo, kaip anonimizuoti kelis DICOM failus iš aplankos naudojant C#. Kai dirbate su šimtais ar tūkstančiais medicininio vaizdo failų, pakuotės apdorojimas yra būtinas efektyvumui ir nuoseklumu.

„Batch Anonymization“ privalumai

  • Efektyvumas:- Visų tyrimų ar archyvų tvarkymas vienoje operacijoje.

  • Konsistencija:- Taikykite tuos pačius anonimiškumo taisykles visiems failams.

  • Automatija:- Integruokite į automatinius darbo srautus ir vamzdžius.

Žymos archyvas: paruošti aplinką

  • Įdiegti „Visual Studio“ arba bet kokį suderinamą .NET IDE.
  • Sukurkite naują .NET 8 konsolės programos projektą.
  • Įdiegti Aspose.Medical iš NuGet paketų valdytojo.
  • Paruoškite įvesties aplanką su DICOM failais ir sukurkite išeinamojo aplanko.

Žingsnis po žingsnio “Batch” anoniminių DICOM failų vadovas

1 žingsnis: įdiegti Aspose.Medical

Pridėti Aspose.Medicinos biblioteką į savo projektą naudojant NuGet.

Install-Package Aspose.Medical

2 žingsnis: įtraukti reikiamus pavadinimų erdves

Įveskite nuorodas į reikalingą vardų erdvę savo kodo.

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

3 žingsnis: sukurkite katalogų maršrutus

Nustatykite savo įvesties ir išleidimo direktorijos maršrutus.

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

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

4 žingsnis: DICOM failų sąrašas

Gaukite visus DICOM failus iš įvesties direktorijos, įskaitant subdirektorijas.

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

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

5 žingsnis: sukurkite anoniminį

Sukurkite „Anonymizer“ pavyzdį su pageidaujamu profilu.

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

6 žingsnis: tvarkyti kiekvieną failą

Eikite per kiekvieną failą, anonimizuokite jį ir išsaugokite į išleidimo katalogą.

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

Išsamus kodo pavyzdys „Batch Anonymization“

Čia pateikiamas išsami pavyzdys, kuriame demonstruojamas batch anonimiškumas su pažangos ataskaita:

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

Paralelinė apdorojimas geresnei našumui

Dideliems duomenų rinkiniams naudokite lygiagrečią apdorojimą, kad galėtumėte naudotis keliomis CPU branduoliais:

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

Išplėstinė versija su logingu

Gamybos aplinkoje, įgyvendinti tinkamą 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}");

Geriausios Batch apdorojimo praktikos

  • Run on Copy of Data: Visada apdoroja originalių duomenų kopiją, o ne pačius originalus.
  • Įrašas Visos operacijos: Išsamūs įrašai, kurių failai buvo apdorojami ir kokios nors klaidos įvyko.
  • Pirmieji bandymai: Prieš apdorojant visą duomenų rinkinį, paleiskite mažą pavyzdį.
  • Monitor disko erdvė: užtikrinama pakankamai diskų vietos išleidimo failams.
  • Bendravimo pertraukos: apsvarstykite patikrinimo taško / atskaitos funkcijos įgyvendinimą labai dideliems batams.

Troubleshooting

Atminties problemos su dideliais duomenų rinkmenimis

Labai dideli failai ar duomenų rinkiniai tvarko failus vieną kartą be nuorodų:

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
}

Leidimo klaidos

Įsitikinkite, kad jūsų paraiška perskaitė prieigą prie įvedimo direktorijos ir parašė prieigos prie išleidimo direktoriaus.

Conclusion

Šis mokymas parodė, kaip padengti anoniminius DICOM failus C# naudojant Aspose.Medical. Nesvarbu, ar apdoroti šimtus ar tūkstančius failų, padėties metodas užtikrina nuoseklų anonimiškumą visoje jūsų duomenų rinkinyje, tuo pačiu užtikrinant pažangos sekimą ir klaidų tvarkymą gamybos patikimumui.

 Lietuvių