A PowerShell-based tool for automating DICOM study pre-fetching. It monitors an input directory for new DICOM files, and when a new file appears, it automatically queries a PACS for other studies belonging to the same patient, and then issues a move request to have those studies sent to a pre-configured destination.
- QR Tool
- Automatic Prefetching: Monitors a directory for incoming DICOM files and triggers a prefetching workflow.
- Patient-Centric Query: Identifies the patient from the incoming file and queries a PACS for related studies.
- Configurable Query Parameters: Allows specifying a timeframe for the study search (e.g., last 60 months) and can be configured to query for a fixed modality or the same modality as the trigger file.
- Flexible Destination: The destination Application Entity (AE) for the C-MOVE operation is configurable.
- Robust Workflow Management: Uses a multi-stage process with dedicated directories for tracking the state of each task (queued, processed, rejected, no-results).
- Efficient Processing: Avoids re-processing of already handled studies by keeping a history of processed files.
- Pixel Data Stripping: Optionally strips pixel data from large DICOM files to save space, as only the header information is needed for the query.
- Worklist Integration: Connects to DICOM Modality Worklist servers to automatically discover and process scheduled procedures.
- Privacy Controls: Configurable patient name masking for HIPAA compliance and privacy protection.
- Retry Mechanisms: Robust error handling with configurable retry logic for network operations.
- Comprehensive Logging: Detailed logging with configurable levels and file rotation.
Before running QR Tool, ensure you have the following installed:
- Operating System: Windows 10/11 or Windows Server 2016/2019/2022
- PowerShell: Version 5.1 or later
- .NET Framework: Version 4.7.2 or later
- Visual Studio: 2017 or later (for building the C# cmdlets)
- PACS Connectivity: Network access to your DICOM PACS server
- DICOM Ports: Ensure required DICOM ports (typically 104 or custom) are accessible
- Application Entity (AE): Your tool's AE must be configured on the PACS server
- fo-dicom: Version 4.0.8 (automatically managed via NuGet)
- System.Management.Automation: For PowerShell cmdlet functionality
git clone https://github.com/mostlydev/qr-tool.git
cd qr-tool- Download the latest release from Releases
- Extract to your desired directory
- Follow the build instructions below
The tool operates in a three-stage pipeline:
-
Stage 1: File Ingestion (
stage-1.ps1)- Monitors the
incoming-stored-itemsdirectory for new.dcmfiles. - For each new file, it extracts
PatientName,PatientBirthDate, andStudyDate. - A unique hash is generated from these tags to identify the study.
- If the study has not been processed before, the file is moved to the
queued-stored-itemsdirectory. If it's a large file, the pixel data may be stripped. - If the study has already been processed, the incoming file is rejected (either by deleting it or moving it to the
rejected-stored-itemsdirectory).
- Monitors the
-
Stage 2: Study Discovery (
stage-2.ps1)- Processes files in the
queued-stored-itemsdirectory. - For each file, it performs a C-FIND query against the configured PACS (
qrServerAE) to find other studies for the same patient. - The search can be limited by the
studyFindMonthsBackparameter and can be configured to look for a specific modality usingfindAndMoveFixedModality. - If studies are found, it creates a
.move-requestticket for each study in thequeued-study-movesdirectory. The ticket is named with theStudyInstanceUID. - The original file from the queue is then moved to the
processed-stored-itemsdirectory. - If no studies are found, the file is moved to the
no-results-stored-itemsdirectory.
- Processes files in the
-
Stage 3: Study Retrieval (
stage-3.ps1)- Processes the
.move-requesttickets in thequeued-study-movesdirectory. - For each ticket, it issues a C-MOVE request to the PACS to send the corresponding study to the configured destination AE (
qrDestinationAE). - Upon successful completion of the C-MOVE, the ticket is moved to the
processed-study-movesdirectory.
- Processes the
qr-tool/
├── cache/ # Working directory for the tool, contains subdirectories for each stage.
│ ├── incoming-stored-items/ # Drop new DICOM files here to trigger the workflow.
│ ├── queued-stored-items/ # Stage 1 output, Stage 2 input.
│ ├── processed-stored-items/ # Files that have been processed by Stage 2.
│ ├── rejected-stored-items/ # Files that were rejected in Stage 1.
│ ├── no-results-stored-items/ # Files for which no studies were found in Stage 2.
│ ├── queued-study-moves/ # Stage 2 output, Stage 3 input.
│ └── processed-study-moves/ # Move requests that have been processed by Stage 3.
├── config.template.ps1 # Configuration template (copy to config.ps1)
├── FoDicomCmdlets/ # C# project for custom DICOM PowerShell cmdlets.
│ └── FoDicomCmdlets.cs # Implements Move-StudyByStudyInstanceUIDSync and Get-StudiesByPatientNameAndBirthDate.
├── lib/ # PowerShell modules for each stage and utility functions.
│ ├── dicom-funs.ps1 # DICOM-related helper functions.
│ ├── logging.ps1 # Logging functions and utilities.
│ ├── retry.ps1 # Retry mechanism for failed operations.
│ ├── stage-1.ps1 # Logic for the File Ingestion stage.
│ ├── stage-2.ps1 # Logic for the Study Discovery stage.
│ ├── stage-3.ps1 # Logic for the Study Retrieval stage.
│ ├── utility-funs.ps1 # Common utility functions.
│ └── worklist-query.ps1 # Worklist query functionality.
├── qr-tool.ps1 # Main script to run the tool.
└── README.md # This file.
All configuration is done by copying config.template.ps1 to config.ps1 and editing the settings.
DICOM Configuration:
$global:myAE: The Application Entity Title (AET) of this tool (default: "QR-TOOL")$global:qrServerAE: The AET of the PACS to query (default: "HOROS")$global:qrServerHost: The hostname or IP address of the PACS (default: "localhost")$global:qrServerPort: The port number of the PACS (default: 2763)$global:qrDestinationAE: The AET of the destination where the studies should be sent (default: "FLUXTEST1AB")
Query Parameters:
$global:studyFindMonthsBack: The number of months back to search for studies (default: 60)$global:findAndMoveFixedModality: If set to a modality (e.g., "CT"), the tool will query for studies of that modality. If$null, it will query for studies with the same modality as the trigger file
Operational Settings:
$global:sleepSeconds: The number of seconds to wait between processing cycles. If set to 0, the script will run once and exit (default: 0)$global:mtimeThreshholdSeconds: A file in the incoming directory is considered "fresh" and will be skipped if its last modified time is less than this many seconds ago (default: 3)$global:largeFileThreshholdBytes: Files larger than this size (in bytes) will have their pixel data stripped in Stage 1 (default: 50000)$global:rejectByDeleting: If$true, rejected files will be deleted. If$false, they will be moved to therejected-stored-itemsdirectory (default: $true)$global:maskPatientNames: If$true, patient names in log output will be masked for privacy (default: $true)
Worklist Configuration:
$global:WorklistEndpointAETitle: AE title of the worklist SCP server (default: "FLUX_WORKLIST")$global:WorklistEndpointHost: Hostname/IP of the worklist server (default: "worklist.example.com")$global:WorklistEndpointPort: Port number of the worklist server (default: 1070)$global:WorklistQueryIntervalSeconds: Query interval in seconds (default: 300)$global:EnableImagePrefetch: Enable automatic image prefetching (default: $true)$global:WorklistModalityFilter: Filter by modality (null = all modalities)$global:WorklistScheduledDateFilter: Filter by scheduled date (YYYYMMDD format)
Retry and Logging Configuration:
$global:RetryDefaultMaxRetries: Default retry attempts (default: 3)$global:RetryDicomMoveMaxRetries: C-MOVE retry attempts (default: 5)$global:logLevel: Logging level - DEBUG, INFO, WARN, ERROR, FATAL (default: "INFO")$global:logToFile: Enable file logging (default: $true)$global:logToConsole: Enable console logging (default: $true)
Directory Configuration:
$global:cacheDirBasePath: The base path for the working directories. Defaults to thecachesubdirectory of the project$global:incomingStoredItemsDirPath: The path to the directory where new DICOM files are placed
-
Configure the tool:
# Copy the template and edit with your PACS settings copy config.template.ps1 config.ps1 notepad config.ps1 -
Run the tool:
# Windows PowerShell powershell -ExecutionPolicy Bypass -File qr-tool.ps1 # Or from remote (SSH) ssh windev "cd C:\dev\qr-tool && powershell -ExecutionPolicy Bypass -File qr-tool.ps1"
-
Drop DICOM files:
# Place .dcm files in the incoming directory cache/incoming-stored-items/
The main script supports the following parameters:
# Standard execution - Run three-stage processing pipeline once
.\qr-tool.ps1
# Start worklist query service - Continuously query worklist server for new items
.\qr-tool.ps1 -StartWorklistQuery
# Get help about the script
Get-Help .\qr-tool.ps1Parameter Details:
- No parameters: Runs the standard three-stage processing pipeline once and exits
-StartWorklistQuery: Starts the worklist query service that continuously monitors a DICOM Modality Worklist server for new scheduled procedures and automatically creates corresponding DICOM files in the incoming directory
qr-tool/
├── cache/ # Working directories (auto-created)
│ ├── incoming-stored-items/ # Drop DICOM files here
│ ├── queued-stored-items/ # Files awaiting processing
│ ├── processed-stored-items/ # Successfully processed files
│ ├── rejected-stored-items/ # Duplicate/rejected files
│ ├── no-results-stored-items/ # Files with no matching studies
│ ├── queued-study-moves/ # Pending study move requests
│ ├── processed-study-moves/ # Completed study moves
│ ├── worklist-cache/ # Worklist query cache files
│ └── logs/ # Application logs
Important: Prior to running qr-tool.ps1, build the FoDicomCmdlets solution in Release mode as the script will need to make use of both the DLL it will build and the DLL of the copy of fo-dicom that the solution will install in its packages folder.
-
Open the Solution:
# Open in Visual Studio start FoDicomCmdlets/FoDicomCmdlets.sln -
Restore NuGet Packages:
- Right-click on the solution in Visual Studio
- Select "Restore NuGet Packages"
- This will download fo-dicom v4.0.8 and dependencies
-
Build the Solution:
# Build in Release mode (recommended) MSBuild FoDicomCmdlets/FoDicomCmdlets.sln /p:Configuration=ReleaseOr use Visual Studio:
- Set configuration to "Release"
- Build → Build Solution (Ctrl+Shift+B)
-
Verify Build Output:
FoDicomCmdlets/bin/Release/ ├── FoDicomCmdlets.dll # Your custom cmdlets ├── Dicom.Core.dll # fo-dicom library └── Other dependencies... -
Configure the Application: Before running the script, be sure to copy config.template.ps1 to config.ps1 and make any required changes.
copy config.template.ps1 config.ps1 # Edit config.ps1 with your specific PACS settings
# Standard execution - Run three-stage processing pipeline
.\qr-tool.ps1
# Start worklist query service
.\qr-tool.ps1 -StartWorklistQuery# From Linux/macOS to Windows machine - Standard processing
ssh windev "cd C:\dev\qr-tool && powershell -ExecutionPolicy Bypass -File qr-tool.ps1"
# Start worklist query service remotely
ssh windev "cd C:\dev\qr-tool && powershell -ExecutionPolicy Bypass -File qr-tool.ps1 -StartWorklistQuery"To run as a Windows service:
# Install standard processing service (requires admin privileges)
New-Service -Name "QRTool" -BinaryPathName "powershell.exe -ExecutionPolicy Bypass -File C:\path\to\qr-tool.ps1" -DisplayName "DICOM QR Tool" -Description "Automated DICOM study prefetching service"
# Install worklist query service (requires admin privileges)
New-Service -Name "QRToolWorklist" -BinaryPathName "powershell.exe -ExecutionPolicy Bypass -File C:\path\to\qr-tool.ps1 -StartWorklistQuery" -DisplayName "DICOM QR Tool Worklist" -Description "DICOM worklist query service"
# Start the services
Start-Service -Name "QRTool"
Start-Service -Name "QRToolWorklist"The QR Tool has been successfully tested with the complete workflow:
# Clear worklist cache to treat existing items as new
rm cache/worklist-cache/*.json
# Run worklist query service
powershell -ExecutionPolicy Bypass -File qr-tool.ps1 -StartWorklistQueryResults:
- ✅ Successfully connected to
worklist.fluxinc.ca:1070 - ✅ Retrieved 10 worklist items from the server
- ✅ Generated 10 new DICOM files in
incoming-stored-items/:worklist-AV35674-00000-20250630081346.dcm(VIVALDI^ANTONIO)worklist-BLV734623-00007-20250630081346.dcm(BEETHOVEN^LUDWIG^VAN)worklist-HF-00004-20250630081346.dcm(HAYDN^FRANZ^JOSEPH)worklist-MWA484763-00001-20250630081346.dcm(MOZART^WOLFGANG^AMADEUS)- Plus 6 additional files for the same patients
# Run standard processing pipeline
powershell -ExecutionPolicy Bypass -File qr-tool.ps1Results:
- ✅ Stage 1 (File Ingestion): Successfully processed 10 incoming files
- ✅ Deduplication: Correctly identified and rejected duplicate files based on patient name + DOB hash
- ✅ Stage 2 (Study Discovery): Processed queued files and attempted PACS queries
- ✅ Error Handling: Gracefully handled expected PACS connection failures with retry mechanism
- ✅ Logging: Comprehensive logging to
cache/logs/qr-tool-YYYYMMDD.log
- Worklist Integration - Connects to external worklist server and creates DICOM files
- File Processing Pipeline - Three-stage processing (ingestion → discovery → retrieval)
- Patient Deduplication - Prevents duplicate processing using PatientName+DOB+StudyDate hash
- Error Handling & Retry - Robust error handling with configurable retry mechanisms
- Privacy Controls - Patient name masking functionality (configurable)
- Configuration Management - Template-based configuration system
To test the QR Tool manually:
-
Setup Configuration:
copy config.template.ps1 config.ps1 # Edit config.ps1 with your PACS settings -
Test Worklist Service:
# Start worklist query service (runs continuously) .\qr-tool.ps1 -StartWorklistQuery
-
Test File Processing:
# Place test DICOM files in cache/incoming-stored-items/ # Then run the processing pipeline .\qr-tool.ps1
-
Monitor Results:
# Check processing stages dir cache\queued-stored-items\ # Stage 1 output dir cache\processed-stored-items\ # Stage 2 output dir cache\queued-study-moves\ # Stage 2 → Stage 3 dir cache\processed-study-moves\ # Stage 3 output # Check logs type cache\logs\qr-tool-YYYYMMDD.log
The tool provides two custom PowerShell cmdlets:
Performs a synchronous DICOM C-MOVE operation.
Move-StudyByStudyInstanceUIDSync -StudyInstanceUID "1.2.3.4.5" -DestinationAE "WORKSTATION" -ServerHost "192.168.1.100" -ServerPort 104 -MyAE "QR_TOOL" -ServerAE "PACS_SERVER"Parameters:
StudyInstanceUID(Required): The study to moveDestinationAE(Required): Target AE for the studyServerHost(Required): PACS server hostname/IPServerPort(Required): PACS server portMyAE(Required): This tool's AE titleServerAE(Required): PACS server AE title
Queries PACS for studies matching patient criteria.
Get-StudiesByPatientNameAndBirthDate -PatientName "DOE^JOHN" -PatientBirthDate "19800101" -ServerHost "192.168.1.100" -ServerPort 104 -MyAE "QR_TOOL" -ServerAE "PACS_SERVER"Key functions available in the lib/ modules:
Get-DicomPatientInfo: Extract patient data from DICOM filesTest-DicomFile: Validate DICOM file integrityNew-StudyHash: Generate unique study identifiersInvoke-StageOne: Execute file ingestion logicInvoke-StageTwo: Execute study discovery logicInvoke-StageThree: Execute study retrieval logic
We welcome contributions to the QR Tool project! Please follow these guidelines:
- Fork the repository
- Create a feature branch:
git checkout -b feature/your-feature-name - Follow the existing code style and conventions
- Test your changes thoroughly
- Submit a pull request with a clear description
- Use consistent PowerShell formatting
- Include inline comments for complex logic
- Follow existing naming conventions
- Ensure all C# code compiles without warnings
Please use the GitHub issue tracker to report bugs or request features:
- Check existing issues first
- Provide detailed reproduction steps
- Include system information (OS, PowerShell version, etc.)
- Attach relevant log files if available
Issue: NuGet package restore fails
Solution: Ensure you have internet connectivity and try:
- Clean solution in Visual Studio
- Delete packages/, bin/ and obj/ folders and rebuild
- Check NuGet sources in Visual Studio settings
Issue: fo-dicom compatibility errors
Solution: Verify .NET Framework version compatibility:
- Ensure .NET Framework 4.7.2 or later is installed
- Check project target framework in .csproj file
Issue: "Access Denied" when running PowerShell script
# Solution: Set execution policy:
powershell -ExecutionPolicy Bypass -File qr-tool.ps1Issue: DICOM connection timeouts
Solution: Check network configuration:
- Verify PACS server is accessible
- Confirm AE titles are configured correctly
- Test connectivity with DICOM tools like dcmtk
Issue: Files not being processed
Solution: Check directory permissions and file states:
- Ensure write permissions on cache directories
- Verify files meet the mtime threshold requirements
- Check logs for processing errors
Enable verbose logging for troubleshooting by setting the log level in your configuration:
# Edit config.ps1 to enable debug logging
$global:logLevel = "DEBUG"
# Then run normally
.\qr-tool.ps1
# or
.\qr-tool.ps1 -StartWorklistQueryQ: Can this tool work with non-Windows PACS servers? A: Yes, the tool communicates using standard DICOM protocols and can work with any DICOM-compliant PACS, regardless of the server's operating system.
Q: How do I configure multiple destination AEs? A: Currently, the tool supports a single destination AE per configuration. You can run multiple instances with different configurations for multiple destinations.
Q: What happens if the PACS server is temporarily unavailable? A: The tool will log connection errors and continue processing. Implement the retry mechanism (Task #13) for automatic retry functionality.
Q: Can I modify the query criteria beyond patient name and birth date?
A: Yes, you can modify the Get-StudiesByPatientNameAndBirthDate cmdlet to include additional DICOM tags in the query.
Q: Is there a way to preview what studies will be moved before they're actually transferred? A: Currently, the tool processes automatically. You can modify Stage 3 to add a confirmation step or implement a dry-run mode.
- Initial release with three-stage processing pipeline
- Support for fo-dicom 4.0.8
- Configurable PACS connectivity
- Pixel data stripping for large files
- Basic error handling and logging
- Enhanced error handling and retry mechanisms
- Performance monitoring and metrics
- Study deduplication
- Unit test coverage
- Web-based monitoring interface
Copyright (c) 2025 [Your Organization Name]. All rights reserved.
This software is proprietary and confidential. No part of this software may be reproduced, distributed, or transmitted in any form or by any means, including photocopying, recording, or other electronic or mechanical methods, without the prior written permission of the copyright holder.
This project uses the following third-party libraries:
- License: Microsoft Public License (MS-PL)
- Version: 4.0.8
- Homepage: https://github.com/fo-dicom/fo-dicom
- License Text: https://github.com/fo-dicom/fo-dicom/blob/development/License.txt
The fo-dicom library is licensed under the Microsoft Public License (MS-PL), which permits use, modification, and distribution under certain conditions. The full license text is available at the link above.
- License: MIT License (part of PowerShell)
- Copyright: Microsoft Corporation
- Homepage: https://github.com/PowerShell/PowerShell
- fo-dicom Team - For providing the excellent DICOM library that powers our C# cmdlets
- Microsoft PowerShell Team - For the robust automation framework
- DICOM Standards Committee - For maintaining the DICOM standard that enables medical imaging interoperability
- Contributors - Thanks to all who have contributed to this project
For technical support or questions, please:
- Check the FAQ section
- Review Troubleshooting guide
- Search existing GitHub Issues
- Create a new issue with detailed information
Built with ❤️ for the medical imaging community
🎯 Taskmaster Export - 2025-07-03 17:48:30 UTC 📋 Export: without subtasks • Status filter: none 🔗 Powered by Task Master
╭─────────────────────────────────────────────────────────╮╭─────────────────────────────────────────────────────────╮
│ ││ │
│ Project Dashboard ││ Dependency Status & Next Task │
│ Tasks Progress: ░░░░░░░░░░░░░░░░░░░░ 0% ││ Dependency Metrics: │
│ 0% ││ • Tasks with no dependencies: 1 │
│ Done: 0 In Progress: 0 Pending: 10 Blocked: 0 ││ • Tasks ready to work on: 1 │
│ Deferred: 0 Cancelled: 0 ││ • Tasks blocked by dependencies: 9 │
│ ││ • Most depended-on task: #1 (5 dependents) │
│ Subtasks Progress: ░░░░░░░░░░░░░░░░░░░░ ││ • Avg dependencies per task: 1.1 │
│ 0% 0% ││ │
│ Completed: 0/0 In Progress: 0 Pending: 0 ││ Next Task to Work On: │
│ Blocked: 0 Deferred: 0 Cancelled: 0 ││ ID: 1 - Implement Comprehensive Unit Testing ... │
│ ││ Priority: high Dependencies: None │
│ Priority Breakdown: ││ Complexity: ● 7 │
│ • High priority: 5 │╰─────────────────────────────────────────────────────────╯
│ • Medium priority: 5 │
│ • Low priority: 0 │
│ │
╰─────────────────────────────────────────────────────────╯
┌───────────┬──────────────────────────────────────┬─────────────────┬──────────────┬───────────────────────┬───────────┐
│ ID │ Title │ Status │ Priority │ Dependencies │ Complexi… │
├───────────┼──────────────────────────────────────┼─────────────────┼──────────────┼───────────────────────┼───────────┤
│ 1 │ Implement Comprehensive Unit Testing │ ○ pending │ high │ None │ ● 7 │
├───────────┼──────────────────────────────────────┼─────────────────┼──────────────┼───────────────────────┼───────────┤
│ 2 │ Implement Startup Configuration Vali │ ○ pending │ high │ 1 │ ● 4 │
├───────────┼──────────────────────────────────────┼─────────────────┼──────────────┼───────────────────────┼───────────┤
│ 3 │ Implement Performance Monitoring Mod │ ○ pending │ high │ 1 │ ● 5 │
├───────────┼──────────────────────────────────────┼─────────────────┼──────────────┼───────────────────────┼───────────┤
│ 4 │ Enhance Study Deduplication with Exp │ ○ pending │ high │ 1 │ ● 6 │
├───────────┼──────────────────────────────────────┼─────────────────┼──────────────┼───────────────────────┼───────────┤
│ 5 │ Improve Error Recovery with Exponent │ ○ pending │ high │ 1 │ ● 7 │
├───────────┼──────────────────────────────────────┼─────────────────┼──────────────┼───────────────────────┼───────────┤
│ 6 │ Implement Structured Logging │ ○ pending │ medium │ 1 │ ● 6 │
├───────────┼──────────────────────────────────────┼─────────────────┼──────────────┼───────────────────────┼───────────┤
│ 7 │ Optimize Code and Memory Management │ ○ pending │ medium │ 3 │ ● 8 │
├───────────┼──────────────────────────────────────┼─────────────────┼──────────────┼───────────────────────┼───────────┤
│ 8 │ Develop Backend API for Monitoring D │ ○ pending │ medium │ 3, 6 │ ● 6 │
├───────────┼──────────────────────────────────────┼─────────────────┼──────────────┼───────────────────────┼───────────┤
│ 9 │ Build Web-Based Monitoring Dashboard │ ○ pending │ medium │ 8 │ ● 5 │
├───────────┼──────────────────────────────────────┼─────────────────┼──────────────┼───────────────────────┼───────────┤
│ 10 │ Implement Container Support with Doc │ ○ pending │ medium │ 2, 9 │ ● 8 │
└───────────┴──────────────────────────────────────┴─────────────────┴──────────────┴───────────────────────┴───────────┘
╭────────────────────────────────────────────── ⚡ RECOMMENDED NEXT TASK ⚡ ──────────────────────────────────────────────╮ │ │ │ 🔥 Next Task to Work On: #1 - Implement Comprehensive Unit Testing Framework │ │ │ │ Priority: high Status: ○ pending │ │ Dependencies: None │ │ │ │ Description: Establish a comprehensive unit testing framework for the PowerShell Core Engine and the FoDicomCmdlets C# library. This is a foundational step to ensure code quality, enable safe refactoring, and prevent regressions as new features are added. │ │ │ │ Start working: task-master set-status --id=1 --status=in-progress │ │ View details: task-master show 1 │ │ │ ╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭──────────────────────────────────────────────────────────────────────────────────────╮ │ │ │ Suggested Next Steps: │ │ │ │ 1. Run task-master next to see what to work on next │ │ 2. Run task-master expand --id= to break down a task into subtasks │ │ 3. Run task-master set-status --id= --status=done to mark a task as complete │ │ │ ╰──────────────────────────────────────────────────────────────────────────────────────╯
📋 End of Taskmaster Export - Tasks are synced from your project using the
sync-readmecommand.
Prior to runninig qr-tool.ps1, build the FoDicomCmdlets solution in Release mode as the script will need to make use of both the DLL it will build and the DLL of the copy of fo-dicom that the solution will install in itjs packages folder.
Before running the script, be sure to copy config.template.ps1 to config.ps1 to and make any required changes.