### Create Installer (Windows)

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/reference/building

Creates an installer package for QuPath using the Gradle wrapper on Windows.

```bash
gradlew clean jpackage -P package=installer
```

--------------------------------

### Create Installer (Windows)

Source: https://qupath.readthedocs.io/en/0.4/docs/reference/building

Builds an installer package for QuPath on Windows using the Gradle wrapper. Requires WiX Toolset to be installed.

```bash
gradlew clean jpackage -P package=installer

```

--------------------------------

### QuPath Tour for Interface Guidance

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/starting/help

The QuPath tour, accessible via the Help menu, guides users through the interface by highlighting elements and explaining their functions. This is useful for understanding the application's layout and features when uncertain.

```QuPath
Help → QuPath Tour
```

--------------------------------

### Set-up for WSInfer

Source: https://qupath.readthedocs.io/en/0.4/docs/deep/index

Step-by-step instructions for installing and configuring the WSInfer tool. This typically involves installing dependencies and potentially downloading model files.

```bash
# Example setup commands for WSInfer (hypothetical)
# pip install tensorflow numpy Pillow
# git clone https://github.com/example/wsinfer.git
# cd wsinfer
# python setup.py install
# Download pre-trained models if necessary
```

--------------------------------

### Running QuPath Executables on Windows

Source: https://qupath.readthedocs.io/en/0.6/docs/intro/installation

This section explains the difference between QuPath.exe and QuPath (console).exe on Windows. The console version provides log messages useful for debugging.

```batch
QuPath.exe
QuPath (console).exe
```

--------------------------------

### Create Installer (macOS/Linux)

Source: https://qupath.readthedocs.io/en/0.4/docs/reference/building

Builds an installer package for QuPath on macOS and Linux using the Gradle wrapper.

```bash
./gradlew clean jpackage -P package=installer

```

--------------------------------

### Create Installer (macOS/Linux)

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/reference/building

Creates an installer package for QuPath using the Gradle wrapper on macOS or Linux.

```bash
./gradlew clean jpackage -P package=installer
```

--------------------------------

### Create QuPath Installer (Windows)

Source: https://qupath.readthedocs.io/en/0.6/docs/reference/building

Creates an installer package for QuPath using Gradle on Windows. Requires the WIX Toolset to be installed.

```shell
gradlew clean jpackage -P package=installer

```

--------------------------------

### Make Launcher Executable on Linux

Source: https://qupath.readthedocs.io/en/0.4/docs/intro/installation

On Linux, you may need to manually make the QuPath launcher executable using the chmod command. This ensures that the application can be run from the command line.

```Shell
chmod u+x /path/to/QuPath/bin/QuPath
```

--------------------------------

### Getting Started with QuPath + DJL

Source: https://qupath.readthedocs.io/en/0.4/docs/deep/index

This section provides guidance on how to begin using the Deep Java Library (DJL) with QuPath for deep learning tasks. It likely covers setup and basic integration steps.

```Java
/*
 * Example placeholder for DJL integration setup in QuPath.
 * Actual code would involve loading DJL models and engines.
 */
// import ai.djl.Model;
// import ai.djl.inference.Predictor;
// import ai.djl.repository.zoo.ZooModel;

// public class DjlIntegration {
//     public static void loadModel(String modelPath) {
//         // Code to load a DJL model
//     }
// }
```

--------------------------------

### Make QuPath Executable on Linux

Source: https://qupath.readthedocs.io/en/0.6/docs/intro/installation

This command is used to grant execute permissions to the QuPath launcher on Linux systems, which may be necessary if the downloaded file is not already executable.

```Shell
chmod u+x /path/to/QuPath/bin/QuPath
```

--------------------------------

### IntelliJ Setup for QuPath Groovy Scripting

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/scripting/scripting_setups

This setup guide explains how to configure IntelliJ IDEA for QuPath scripting. It involves downloading the QuPath gradle scripting project to leverage autocomplete and dependency management for QuPath classes.

```bash
git clone https://github.com/qupath/qupath-gradle-scripting-project.git
```

--------------------------------

### Create QuPath Installer (macOS/Linux)

Source: https://qupath.readthedocs.io/en/0.6/docs/reference/building

Creates an installer package for QuPath using Gradle on macOS or Linux. No additional toolset is explicitly mentioned as required.

```shell
./gradlew clean jpackage -P package=installer

```

--------------------------------

### VSCode Setup for QuPath Groovy Scripting with Autocomplete

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/scripting/scripting_setups

This guide details setting up VSCode for QuPath scripting, focusing on enabling autocomplete and other advanced editor features. It requires installing a Groovy language server and configuring the classpath to include QuPath JARs and extensions.

```json
{
  "groovy.classpath": [
    "/path/to/QuPath/lib/app/",
    "/path/to/QuPath/extensions/"
  ]
}
```

--------------------------------

### Install Extension via Extension Manager in QuPath

Source: https://qupath.readthedocs.io/en/0.6/docs/intro/extensions

This explains how to install an extension using QuPath's extension manager. It involves clicking a '+' button, selecting a version and optional dependencies, and then clicking 'Install'.

```text
Click on the + green button next to the extension name. This will show the installation window.
There, you can select the extension version and whether to install optional dependencies.
When you click on Install, the extension files will be downloaded and added to your QuPath user directory.
```

--------------------------------

### Set QuPath Java Memory Parameters

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/reference/config

Demonstrates setting Java memory parameters for QuPath, including maximum and starting memory allocation.

```java
-XX:MaxRAMPercentage=50
```

```java
-Xmx16G
```

```java
-Xms16G
```

--------------------------------

### Install Extension Manually in QuPath

Source: https://qupath.readthedocs.io/en/0.6/docs/intro/extensions

This describes the manual installation of QuPath extensions, typically by downloading a .jar file from a GitHub repository's 'Releases' section and either dragging it onto QuPath's main window or copying it to the user directory.

```text
It usually consists of downloading a file that ends with `.jar` from the `Releases` section of the GitHub repository. If you drag this onto QuPath’s main window, QuPath should copy it to your QuPath user directory. You can also manually copy the jar to your QuPath user directory.
```

--------------------------------

### Run QuPath Executables on Windows

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/intro/installation

Instructions for launching QuPath on Windows after extracting the ZIP package. It highlights the difference between `QuPath.exe` and `QuPath (console).exe`, with the latter providing log messages.

```batch
QuPath.exe
QuPath (console).exe
```

--------------------------------

### Install QuPath Extension via Drag and Drop

Source: https://qupath.readthedocs.io/en/0.4/docs/intro/extensions

This describes the common method for installing QuPath extensions. Extensions are provided as .jar files. Users drag these files onto the QuPath application window, which then copies them to the user directory. A restart of QuPath may be necessary for the extension to be fully functional.

```text
Drag the .jar file onto QuPath's main window.
QuPath should copy it to your user directory.
Restart QuPath if necessary.
```

--------------------------------

### Requirements for WSInfer

Source: https://qupath.readthedocs.io/en/0.4/docs/deep/index

Lists the necessary software and hardware prerequisites for setting up and running the WSInfer tool with QuPath. This ensures a smooth installation and execution process.

```bash
# Example requirements list (conceptual)
# - Python 3.7+
# - TensorFlow 2.x
# - NumPy
# - Pillow
# - QuPath installed
# - Sufficient RAM and GPU memory for whole slide processing
```

--------------------------------

### Make QuPath Executable on Linux

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/intro/installation

This command is used to grant execute permissions to the QuPath launcher on Linux systems. It is necessary if the downloaded file does not have the correct permissions to run.

```shell
chmod u+x /path/to/QuPath/bin/QuPath
```

--------------------------------

### Configure Build with gradle.properties

Source: https://qupath.readthedocs.io/en/0.4/docs/reference/building

Example gradle.properties file to customize QuPath builds, including parallel execution, Java home, OpenSlide path, and DJL engines.

```properties
org.gradle.parallel=true
org.gradle.java.home=/Library/Java/JavaVirtualMachines/temurin-17.jdk/Contents/Home
 openslide=/opt/homebrew/Cellar/openslide-java/0.12.2/lib/openslide-java/openslide.jar
djl.engines=pytorch,mxnet,onnxruntime
djl.zoos=all

```

--------------------------------

### Gradle Properties for Build Optimization

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/reference/building

Example `gradle.properties` file to configure build settings like parallel execution, Java home, and Deep Java Library engines.

```properties
org.gradle.parallel=true
org.gradle.java.home=/Library/Java/JavaVirtualMachines/temurin-|javaVersion|.jdk/Contents/Home
djl.engines=pytorch,mxnet,onnxruntime
djl.zoos=all
```

--------------------------------

### Configure QuPath System Properties

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/reference/config

Illustrates setting general and QuPath-specific system properties to control application version, native library paths, and preference management.

```java
-Djpackage.app-version=0.3.0
```

```java
-Djava.library.path=$APPDIR
```

```java
-Djava.util.concurrent.ForkJoinPool.common.parallelism=4
```

```java
-Dqupath.prefs.name="qupath.eclipse/0.3"
```

--------------------------------

### View System Info

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/reference/commands

Shows detailed technical information about the current QuPath installation.

```QuPath Menu
Help --> System info
```

--------------------------------

### Getting the StarDist Extension

Source: https://qupath.readthedocs.io/en/0.4/docs/deep/index

This section explains how to obtain and install the StarDist extension for QuPath, which is used for advanced cell detection. It may involve downloading a plugin or following installation instructions.

```bash
# Example command to download a StarDist extension (hypothetical)
# wget https://example.com/qupath-stardist-extension.zip
# unzip qupath-stardist-extension.zip -d /path/to/qupath/extensions
```

--------------------------------

### Access QuPath Preferences

Source: https://qupath.readthedocs.io/en/0.6/docs/starting/first_steps

Provides instructions on how to access and modify QuPath's settings, including options for the welcome message and viewer customization.

```QuPath
Edit -> Preferences -> general -> Show welcome message when QuPath starts.
Edit -> Preferences -> Viewer (for scalebar customization).
```

--------------------------------

### macOS Security Warning Bypass

Source: https://qupath.readthedocs.io/en/0.6/docs/intro/installation

This snippet outlines the process to bypass macOS security warnings for unsigned applications. It involves navigating to System Settings > Security & Privacy to allow the application to open.

```text
The workaround is hidden under System Settings ‣ Security & Privacy.
There, you should find the name of the QuPath file you tried to open, with a button to Open Anyway. Clicking that, macOS will make one more attempt to stop you:
If you choose Open Anyway again, QuPath’s installer should start.
```

--------------------------------

### Open Image File in QuPath

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/starting/first_steps

Demonstrates the recommended method for opening image files in QuPath by dragging and dropping them onto the main window. This is presented as a more efficient alternative to using the File > Open menu.

```User Interface Interaction
Drag the file you want to open onto QuPath's main window.
```

--------------------------------

### Windows Security Warning Bypass

Source: https://qupath.readthedocs.io/en/0.6/docs/intro/installation

This snippet describes how to bypass Windows security warnings when running an unsigned application like QuPath. It involves clicking 'More info' and then 'Run anyway' or unblocking the file in its properties.

```text
When Windows tries to protect you from software it does not know, you’ll probably see a scary-looking warning whenever the QuPath installer is first run:
If you would like to get past this screen, press ‘More info’ and the option to ‘Run anyway’ appears.
Sometimes, you won’t see any ‘More info’ button. In such situations, you can try to right click on the file, click on ‘Properties’, and tick the ‘Unblock’ checkbox:
```

--------------------------------

### Build QuPath (Windows)

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/reference/building

Clones the QuPath repository and builds the application using Gradle wrapper on Windows.

```bash
git clone https://github.com/qupath/qupath
cd qupath
gradlew clean jpackage
```

--------------------------------

### Run QuPath (Windows)

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/reference/building

Runs the QuPath application directly using the Gradle wrapper on Windows.

```bash
gradlew run
```

--------------------------------

### Get Pixel Size in Microns using QuPath

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/scripting/overview

Shows how to retrieve pixel dimensions (width, height, and average size) in microns from the ImageServer's pixel calibration. It also includes examples of checking for NaN values, which indicate unavailable size information.

```groovy
def server = getCurrentServer()
def cal = server.getPixelCalibration()
print cal.getPixelWidthMicrons()
print cal.getPixelHeightMicrons()
print cal.getAveragedPixelSizeMicrons()
```

```groovy
double myNaN = Double.NaN

// Two Java/Groovy-friendly ways to check values are 'usable'
print Double.isNaN(myNaN)
print Double.isFinite(myNaN)

// A bad way to check for NaN - confusing because Java & Groovy handle == differently
print (myNaN == Double.NaN) // Don't do this!
```

--------------------------------

### Navigate and Zoom in QuPath

Source: https://qupath.readthedocs.io/en/0.6/docs/starting/first_steps

Explains how to control the magnification and view different parts of an image in QuPath. It covers using the mouse scroll wheel and direct input for zooming.

```QuPath
Use mouse scroll wheel to zoom in/out.
Right-click on image -> Display -> 100% (or other zoom options).
Double-click magnification value on toolbar -> Enter specific value.
```

--------------------------------

### Create QuPath Project

Source: https://qupath.readthedocs.io/en/0.4/docs/reference/commands

Initiates the creation of a new project in QuPath. While menu navigation is possible, dragging an empty folder onto the QuPath window is a more convenient method.

```QuPath Commands
File ‣ Project… ‣ Create project
```

--------------------------------

### File: Open Project

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/reference/commands

Opens an existing QuPath project. Similar to creating a project, dragging a project folder onto QuPath is a more convenient method.

```QuPath Commands
File --> Project... --> Open project
```

--------------------------------

### Install TensorFlow with CUDA Support using Pip

Source: https://qupath.readthedocs.io/en/0.6/docs/deep/gpu

Installs TensorFlow version 2.16.1 with CUDA support using pip within the activated conda environment.

```bash
pip install tensorflow[and-cuda]==2.16.1
```

--------------------------------

### QuPath: Create Measurement Tables

Source: https://qupath.readthedocs.io/en/0.6/docs/starting/first_steps

Users can generate tables containing measurements for annotations or detections. These tables are interactive, allowing object selection and sorting. Measurements can also be visualized as histograms and exported as CSV files.

```User Interface
Click the **Table** button in the toolbar
```

--------------------------------

### Install PyTorch with CUDA Support

Source: https://qupath.readthedocs.io/en/0.6/docs/deep/gpu

Installs PyTorch version 2.5.1 along with torchvision, torchaudio, and CUDA 12.4 support using the PyTorch and NVIDIA channels.

```bash
mamba install pytorch==2.5.1 torchvision torchaudio pytorch-cuda=12.4 -c pytorch -c nvidia
```

--------------------------------

### Install TensorFlow with CUDA Support (Pip)

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/deep/gpu

Installs TensorFlow version 2.16.1 with CUDA support using pip. This command assumes the Conda environment is already activated.

```sh
pip install tensorflow[and-cuda]==2.16.1
```

--------------------------------

### Open Image in QuPath

Source: https://qupath.readthedocs.io/en/0.6/docs/starting/first_steps

Demonstrates the primary methods for opening an image file within the QuPath application. It highlights the convenience of drag-and-drop functionality over the traditional File > Open menu.

```QuPath
File -> Open...
Drag and drop file onto QuPath's main window
```

--------------------------------

### Install OpenSlide for Apple Silicon (macOS)

Source: https://qupath.readthedocs.io/en/0.4/docs/intro/formats

Instructions for installing or updating the OpenSlide library for QuPath on Apple silicon Macs (M1/M2 processors) and other Mac or Linux systems.

```Shell
brew install qupath/qupath/openslide
```

--------------------------------

### Get Current Image Data via Viewer

Source: https://qupath.readthedocs.io/en/0.4/docs/scripting/overview

This Groovy script demonstrates an alternative way to get the ImageData for the current QuPath viewer by first obtaining the viewer object.

```Groovy
def viewer = getCurrentViewer()
def imageData = viewer.getImageData()
print imageData

```

--------------------------------

### Build QuPath (Windows)

Source: https://qupath.readthedocs.io/en/0.4/docs/reference/building

Clones the QuPath repository and builds the project using Gradle wrapper for Windows. This command also packages the application.

```bash
git clone https://github.com/qupath/qupath
cd qupath
gradlew clean jpackage

```

--------------------------------

### QuPath WSInfer Scripting Example

Source: https://qupath.readthedocs.io/en/0.6/docs/deep/wsinfer

Provides a scripting example for the QuPath WSInfer extension to run inference on a specified model. It demonstrates how to select annotations and then execute a model from the WSInfer zoo, such as 'kaczmarj/pancancer-lymphocytes-inceptionv4.tcga'.

```groovy
selectAnnotations()
qupath.ext.wsinfer.WSInfer.runInference("kaczmarj/pancancer-lymphocytes-inceptionv4.tcga")
```

--------------------------------

### Get Current Image Data via Viewer in QuPath

Source: https://qupath.readthedocs.io/en/0.6/docs/scripting/overview

This script demonstrates an alternative method to get the current image data by first obtaining the current viewer instance and then accessing its image data. This is equivalent to using getCurrentImageData().

```Groovy
def viewer = getCurrentViewer()
def imageData = viewer.getImageData()
print imageData
```

--------------------------------

### Run QuPath (macOS/Linux)

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/reference/building

Runs the QuPath application directly using the Gradle wrapper on macOS or Linux.

```bash
./gradlew run
```

--------------------------------

### Install PyTorch with CUDA Support (Mamba)

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/deep/gpu

Installs a specific version of PyTorch (2.5.1) along with torchvision, torchaudio, and the required CUDA toolkit version (12.4) using Mamba. It specifies the PyTorch and NVIDIA channels for package retrieval.

```sh
mamba install pytorch==2.5.1 torchvision torchaudio pytorch-cuda=12.4 -c pytorch -c nvidia
```

--------------------------------

### Open QuPath Files with Drag and Drop

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/starting/essential_tips

Demonstrates how to open various QuPath-supported files, including projects, images, and scripts, by simply dragging them onto the main QuPath window. This method bypasses traditional file choosers.

```text
Supported files:
- Projects (.qpproj or folder)
- Images
- Scripts
```

--------------------------------

### Install QuPath Deep Java Library Extension

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/deep/bioimage

To utilize the Bioimage Model Zoo within QuPath, users must install the QuPath Deep Java Library extension. This extension is a prerequisite for integrating external deep learning models.

```Java
:::{admonition} Adding Deep Java Library
:class: tip

To use the model zoo in QuPath, you'll need the [QuPath Deep Java Library extension](djl).
:::

```

--------------------------------

### Remove QuPath Extension

Source: https://qupath.readthedocs.io/en/0.4/docs/intro/extensions

Instructions for removing installed QuPath extensions. This involves locating the extension's .jar file in the user directory and deleting it. It's recommended to close QuPath before performing the deletion. The 'Installed extensions' menu can help find the file path.

```text
Close QuPath.
Navigate to the QuPath user directory.
Delete the extension's .jar file.
Use 'Extensions -> Installed extensions' to find the file location.
```

--------------------------------

### File: Create Project

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/reference/commands

Creates a new project in QuPath. While this menu option exists, it's often easier to create a project by dragging an empty folder onto the QuPath application.

```QuPath Commands
File --> Project... --> Create project
```

--------------------------------

### Manage Extensions

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/reference/commands

Manages the list of installed QuPath extensions.

```QuPath Menu
Extensions --> Manage extensions
```

--------------------------------

### QuPath Annotation Selection and Visibility

Source: https://qupath.readthedocs.io/en/0.6/docs/starting/first_steps

This section explains how to select annotations in QuPath, typically by double-clicking them with the Move tool. It also covers customizing selection colors and toggling the visibility of annotation names using a keyboard shortcut.

```QuPath
Double-clicking on an object to select it.
Alt + click to select multiple annotations.
N to toggle visibility of annotation names.
```

--------------------------------

### Create Conda Environment for TensorFlow

Source: https://qupath.readthedocs.io/en/0.6/docs/deep/gpu

Creates a new conda environment named 'qupath-tensorflow' for TensorFlow installations.

```bash
mamba create -n qupath-tensorflow
```

--------------------------------

### QuPath: Zooming and Panning Navigation

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/starting/first_steps

Explains how to zoom in and out of images in QuPath using the mouse scroll wheel or by entering specific magnification values. It also describes panning using the Move tool or the overview image.

```QuPath
:::{figure} images/steps_mag.jpg
:class: shadow-image small-image

The *Magnification box*
:::

Double-clicking on the magnification value in the toolbar (here, the bit that shows 10.0x) opens an input dialog to enter a specific magnification.

As you zoom in and out, the scalebar in the lower left cover will conveniently update so you always know your scale.

:::{tip}
You can customize the scalebar thickness, font size and weight from preferences panel ({menuselection}`Edit --> Preferences --> Viewer`).
:::

To **pan** around a large image within QuPath, first make sure that the **Move** tool {{ icon_move }} is selected in the toolbar.
Then click anywhere on the image, and drag the mouse with the button held down to move.

Alternatively, you can click on the **Overview image** in the top right to automatically jump to a specific region.

:::{figure} images/steps_overview.jpg
:class: shadow-image full-image

The *Image overview (top right) can be used for navigation*
:::

:::{note}
For other methods to navigate large images - including multitouch support for touchpads, touch-sensitive screens and 3D mice - see {doc}`viewing`.
:::
```

--------------------------------

### Reset Detection Classifications in QuPath

Source: https://qupath.readthedocs.io/en/0.4/docs/reference/commands

Resets the classifications of all detected objects, allowing for re-classification or a fresh start.

```QuPath
Classify ‣ Object classification ‣ Reset detection classifications
```

--------------------------------

### Reset Preferences

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/reference/commands

Resets QuPath's preferences to their default values. This can be useful for troubleshooting or starting with a clean configuration.

```N/A
Edit --> Reset preferences
```

--------------------------------

### QuPath Cell Detection Command

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/starting/first_steps

This snippet describes the process of initiating cell detection in QuPath. It involves navigating the menu to access the 'Cell detection' command and understanding the available parameters for customization.

```QuPath
Analyze --> Cell detection --> Cell detection
```

--------------------------------

### Pass arguments to ImageServer using --server

Source: https://qupath.readthedocs.io/en/0.4/docs/advanced/command_line

Shows how to pass arguments to the ImageServer when constructing it with the `--image` option using the `--server` keyword. This example specifies the Bio-Formats server and a specific series.

```bash
--server "[--classname,qupath.lib.images.servers.bioformats.BioFormatsServerBuilder,--series,2]"
```

--------------------------------

### Verify PyTorch Engine in QuPath

Source: https://qupath.readthedocs.io/en/0.6/docs/deep/gpu

Prints the details of the detected PyTorch engine within the QuPath environment, confirming the installation and CUDA capabilities.

```java
println ai.djl.engine.Engine.getEngine("PyTorch")
```

--------------------------------

### Simplified Build Command after gradle.properties

Source: https://qupath.readthedocs.io/en/0.4/docs/reference/building

Executes the QuPath build using the configurations specified in the gradle.properties file.

```bash
./gradlew jpackage

```

--------------------------------

### Activate Conda Environment

Source: https://qupath.readthedocs.io/en/0.6/docs/deep/gpu

This command activates the specified conda environment, making its installed packages and executables available in the current terminal session.

```bash
mamba activate qupath-pytorch
```

--------------------------------

### Open QuPath Files with Drag and Drop

Source: https://qupath.readthedocs.io/en/0.4/docs/starting/essential_tips

QuPath supports opening various files by simply dragging them onto the main window. This includes project files (.qpproj), images, and scripts, streamlining the file opening process.

```plaintext
Drag and drop supported files (Projects, Images, Scripts) onto the QuPath main window.
```

--------------------------------

### Install StarDist Extension for QuPath

Source: https://qupath.readthedocs.io/en/0.6/_sources/docs/deep/stardist

Instructions on how to add the StarDist extension to QuPath for cell detection. This involves obtaining the extension from its GitHub repository.

```bash
git clone https://github.com/qupath/qupath-extension-stardist.git
```

--------------------------------

### Get Image Dimensions

Source: https://qupath.readthedocs.io/en/0.6/docs/scripting/overview

Accesses and prints the width and height of the current image using the ImageServer instance. This is useful for understanding image resolution.

```Groovy
def server = getCurrentServer()
print server.getWidth() + ' x ' + server.getHeight()
```

--------------------------------

### Get Image Dimensions

Source: https://qupath.readthedocs.io/en/0.4/docs/scripting/overview

Accesses and prints the width and height of the current image using the ImageServer instance. This is useful for understanding image resolution.

```Groovy
def server = getCurrentServer()
print server.getWidth() + ' x ' + server.getHeight()
```

--------------------------------

### Build QuPath with CUDA Redistributables (Windows)

Source: https://qupath.readthedocs.io/en/0.4/docs/reference/building

Builds QuPath with automatic download of necessary CUDA files for GPU acceleration on Windows. This is for systems with recent NVIDIA GPUs and drivers.

```bash
gradlew clean jpackage -Pcuda-redist

```

--------------------------------

### Set Pixel Size in QuPath

Source: https://qupath.readthedocs.io/en/0.6/docs/starting/first_steps

Describes how to set the pixel size for accurate measurements in QuPath. It covers automatic fetching from file metadata and manual input, including using annotations.

```QuPath
Image tab in Analysis panel -> 'Pixel width' & 'Pixel height' (auto-fetched).
Double-click 'Pixel width' or 'Pixel height' -> Manually enter values.
Draw annotation -> Double-click 'Pixel width' or 'Pixel height' -> Enter size in micron squared.
Draw line annotation -> Double-click 'Pixel width' or 'Pixel height' -> Enter length in micron.
```

--------------------------------

### Get Image Metadata Object

Source: https://qupath.readthedocs.io/en/0.6/docs/scripting/overview

Retrieves the ImageServerMetadata object from the ImageServer, which contains comprehensive metadata about the image. This allows access to all key metadata properties.

```Groovy
def server = getCurrentServer()
print server.getMetadata()
```

--------------------------------

### Navigate Images in QuPath

Source: https://qupath.readthedocs.io/en/0.4/docs/starting/first_steps

Explains how to zoom in and out of images in QuPath using the mouse scroll wheel or by directly entering a magnification value. It also covers panning using the 'Move' tool or the overview image.

```QuPath
Right-click on the image, and choose one of the zoom options e.g. Display ‣ 100%
Double-click on the little magnification value on the toolbar, and enter a value there.
```

--------------------------------

### Get Image Server Instance

Source: https://qupath.readthedocs.io/en/0.6/docs/scripting/overview

Retrieves the current ImageServer instance to access image properties. This is a fundamental step for most image data operations in QuPath.

```Groovy
def imageData = getCurrentImageData()
def server = imageData.getServer()
print server
```

```Groovy
def server = getCurrentServer()
print server
```