pax_global_header 0000666 0000000 0000000 00000000064 14370413656 0014523 g ustar 00root root 0000000 0000000 52 comment=8f79d51e6fbd1031e4f0ed31cd60c3c3333850e2
napari-0.5.0a1/ 0000775 0000000 0000000 00000000000 14370413656 0013221 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/.devcontainer/ 0000775 0000000 0000000 00000000000 14370413656 0015760 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/.devcontainer/Dockerfile 0000664 0000000 0000000 00000000706 14370413656 0017755 0 ustar 00root root 0000000 0000000 # See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.233.0/containers/python-3-miniconda/.devcontainer/base.Dockerfile
FROM mcr.microsoft.com/vscode/devcontainers/miniconda:0-3
RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
&& apt-get -y install --no-install-recommends \
libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-randr0 \
libxcb-render-util0 libxcb-xinerama0 libxkbcommon-x11-0 napari-0.5.0a1/.devcontainer/add-notice.sh 0000664 0000000 0000000 00000001544 14370413656 0020327 0 ustar 00root root 0000000 0000000 # Display a notice when not running in GitHub Codespaces
cat << 'EOF' > /usr/local/etc/vscode-dev-containers/conda-notice.txt
When using "conda" from outside of GitHub Codespaces, note the Anaconda repository
contains restrictions on commercial use that may impact certain organizations. See
https://aka.ms/vscode-remote/conda/miniconda
EOF
notice_script="$(cat << 'EOF'
if [ -t 1 ] && [ "${IGNORE_NOTICE}" != "true" ] && [ "${TERM_PROGRAM}" = "vscode" ] && [ "${CODESPACES}" != "true" ] && [ ! -f "$HOME/.config/vscode-dev-containers/conda-notice-already-displayed" ]; then
cat "/usr/local/etc/vscode-dev-containers/conda-notice.txt"
mkdir -p "$HOME/.config/vscode-dev-containers"
((sleep 10s; touch "$HOME/.config/vscode-dev-containers/conda-notice-already-displayed") &)
fi
EOF
)"
echo "${notice_script}" | tee -a /etc/bash.bashrc >> /etc/zsh/zshrc
napari-0.5.0a1/.devcontainer/devcontainer.json 0000664 0000000 0000000 00000002762 14370413656 0021343 0 ustar 00root root 0000000 0000000 // For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
// https://github.com/microsoft/vscode-dev-containers/tree/v0.233.0/containers/python-3-miniconda
{
"name": "Miniconda (Python 3)",
"build": {
"context": "..",
"dockerfile": "Dockerfile",
"args": {
"NODE_VERSION": "none"
}
},
// Set *default* container specific settings.json values on container create.
"settings": {
"python.defaultInterpreterPath": "/opt/conda/bin/python",
"python.linting.enabled": true,
"python.linting.mypyEnabled": true,
"python.linting.flake8Enabled": true,
"python.formatting.blackPath": "/opt/conda/bin/black",
"python.linting.flake8Path": "/opt/conda/bin/flake8",
"python.linting.mypyPath": "/opt/conda/bin/mypy",
},
// Add the IDs of extensions you want installed when the container is created.
"extensions": [
"ms-python.python",
"ms-python.vscode-pylance"
],
// Use 'forwardPorts' to make a list of ports inside the container available locally.
"forwardPorts": [5900, 5901, 6080],
// Use 'postCreateCommand' to run commands after the container is created.
"postCreateCommand": "pip install -U pip && pip install -e .[pyqt, dev] && pre-commit install",
// Comment out to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
"remoteUser": "vscode",
"features": {
"git": "os-provided",
"github-cli": "latest",
"desktop-lite": {
"password": "napari",
"webPort": "6080",
"vncPort": "5901"
}
}
}
napari-0.5.0a1/.env_sample 0000664 0000000 0000000 00000003044 14370413656 0015354 0 ustar 00root root 0000000 0000000 # TO USE THIS FILE RENAME IT TO '.env'
# NOTE! Using this file requires `pip install python-dotenv`
# ──────────────────────────────────────────────────────────────
# Event Debugging, controls events.debugging.EventDebugSettings:
NAPARI_DEBUG_EVENTS=0
# these are strict json, use double quotes
# if INCLUDE_X is used, EXCLUDE_X is ignored.
EVENT_DEBUG_INCLUDE_EMITTERS = [] # e.g. ["Points", "Selection"]
EVENT_DEBUG_EXCLUDE_EMITTERS = ["TransformChain", "Context"]
EVENT_DEBUG_INCLUDE_EVENTS = [] # e.g. ["set_data", "changed"]
EVENT_DEBUG_EXCLUDE_EVENTS = ["status", "position"]
EVENT_DEBUG_STACK_DEPTH = 20
# ──────────────────────────────────────────────────────────────
# _PYTEST_RAISE=1 will prevent pytest from handling exceptions.
# Use with a debugger that's set to break on "unhandled exceptions".
# https://github.com/pytest-dev/pytest/issues/7409
_PYTEST_RAISE=0
# set to 1 to simulate Continuous integration tests
CI=0
# set to 1 to allow tests that pop up a viewer or widget
NAPARI_POPUP_TESTS=0
# ──────────────────────────────────────────────────────────────
# You can also use any of the (nested) fields from NapariSettings
# for example:
# NAPARI_APPEARANCE_THEME='light'
napari-0.5.0a1/.gitattributes 0000664 0000000 0000000 00000000045 14370413656 0016113 0 ustar 00root root 0000000 0000000 napari_gui/_version.py export-subst
napari-0.5.0a1/.github/ 0000775 0000000 0000000 00000000000 14370413656 0014561 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/.github/CODEOWNERS 0000664 0000000 0000000 00000000000 14370413656 0016142 0 ustar 00root root 0000000 0000000 napari-0.5.0a1/.github/FUNDING.yml 0000664 0000000 0000000 00000000076 14370413656 0016401 0 ustar 00root root 0000000 0000000 github: numfocus
custom: http://numfocus.org/donate-to-napari
napari-0.5.0a1/.github/ISSUE_TEMPLATE/ 0000775 0000000 0000000 00000000000 14370413656 0016744 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/.github/ISSUE_TEMPLATE/bug_report.md 0000664 0000000 0000000 00000001243 14370413656 0021436 0 ustar 00root root 0000000 0000000 ---
name: "\U0001F41B Bug Report"
about: Submit a bug report to help us improve napari
title: ''
labels: bug
assignees: ''
---
## 🐛 Bug
## To Reproduce
Steps to reproduce the behavior:
1.
2.
3.
## Expected behavior
## Environment
- Please copy and paste the information at napari info option in help menubar here:
- Any other relevant information:
## Additional context
napari-0.5.0a1/.github/ISSUE_TEMPLATE/config.yml 0000664 0000000 0000000 00000000673 14370413656 0020742 0 ustar 00root root 0000000 0000000 # Ref: https://help.github.com/en/github/building-a-strong-community/configuring-issue-templates-for-your-repository#configuring-the-template-chooser
blank_issues_enabled: true # default
contact_links:
- name: 🤷💻 napari forum
url: https://forum.image.sc/tag/napari
about: |
Please ask general "how do I ... ?" questions over at image.sc
- name: '💬 napari @ zulip'
url: https://napari.zulipchat.com/
about: Chat with devs
napari-0.5.0a1/.github/ISSUE_TEMPLATE/design_related.md 0000664 0000000 0000000 00000003230 14370413656 0022235 0 ustar 00root root 0000000 0000000 ---
name: "\U00002728 Design Related"
about: Capture needs specific to design and user experience research
title: ''
labels: design
assignees: liaprins-czi
---
### Overview of design need
- Is there an existing GitHub issue this design work pertains to? If so, provide a link to it
- Also link to any specific comments or threads where the problem to be solved by design is mentioned
- In a sentence or two, describe the problem to be solved for users
### What level of design is needed? (Choose all that apply)
_This section may be updated by the designer / UX researcher working on this issue_
- [ ] **User experience research:** high-level recommendation/exploration of user needs, design heuristics, and / or best practices to inform a design experience
(Use this option when you feel there’s a challenge to be solved, but you’re curious about what the experience should be — may involve research studies to understand challenges/opportunities for design)
- [ ] **Information flow / conceptual:** organizing and structuring of information flow and content, including layout on screen or across multiple steps
- [ ] **Visual:** creating mockups, icons, etc
(If choosing this level alone, it means that the content to be mocked up and its organization is already known and specified)
### Is design a blocker?
- [ ] **Yes:** engineering cannot proceed without a design first
- [ ] **No:** engineering can create a first version, and design can come in later to iterate and refine
If selecting **Yes**, how much design input is needed to unblock engineering? For example, is a full, final visual design needed, or just a recommendation of which conceptual direction to go?
napari-0.5.0a1/.github/ISSUE_TEMPLATE/documentation.md 0000664 0000000 0000000 00000000377 14370413656 0022146 0 ustar 00root root 0000000 0000000 ---
name: "\U0001F4DA Documentation"
about: Report an issue with napari documentation
title: ''
labels: documentation
assignees: ''
---
## 📚 Documentation
napari-0.5.0a1/.github/ISSUE_TEMPLATE/feature_request.md 0000664 0000000 0000000 00000001365 14370413656 0022476 0 ustar 00root root 0000000 0000000 ---
name: "\U0001F680 Feature Request"
about: Submit a proposal/request for a new napari feature
title: ''
labels: feature
assignees: ''
---
## 🚀 Feature
## Motivation
## Pitch
## Alternatives
## Additional context
napari-0.5.0a1/.github/ISSUE_TEMPLATE/task.md 0000664 0000000 0000000 00000000303 14370413656 0020224 0 ustar 00root root 0000000 0000000 ---
name: "\U0001F9F0 Task"
about: Submit a proposal/request for a new napari feature
title: ''
labels: task
assignees: ''
---
## 🧰 Task
napari-0.5.0a1/.github/PULL_REQUEST_TEMPLATE.md 0000664 0000000 0000000 00000003351 14370413656 0020364 0 ustar 00root root 0000000 0000000 # Description
## Type of change
- [ ] Bug-fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
- [ ] This change requires a documentation update
# References
# How has this been tested?
- [ ] example: the test suite for my feature covers cases x, y, and z
- [ ] example: all tests pass with my change
- [ ] example: I check if my changes works with both PySide and PyQt backends
as there are small differences between the two Qt bindings.
## Final checklist:
- [ ] My PR is the minimum possible work for the desired functionality
- [ ] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [ ] I have added tests that prove my fix is effective or that my feature works
- [ ] If I included new strings, I have used `trans.` to make them localizable.
For more information see our [translations guide](https://napari.org/developers/translations.html).
napari-0.5.0a1/.github/TEST_FAIL_TEMPLATE.md 0000664 0000000 0000000 00000000625 14370413656 0017753 0 ustar 00root root 0000000 0000000 ---
title: "{{ env.TITLE }}"
labels: [bug]
---
The {{ workflow }} workflow failed on {{ date | date("YYYY-MM-DD HH:mm") }} UTC
The most recent failing test was on {{ env.PLATFORM }} py{{ env.PYTHON }} {{ env.BACKEND }}
with commit: {{ sha }}
Full run: https://github.com/napari/napari/actions/runs/{{ env.RUN_ID }}
(This post will be updated if another test fails, as long as this issue remains open.)
napari-0.5.0a1/.github/dependabot.yml 0000664 0000000 0000000 00000000624 14370413656 0017413 0 ustar 00root root 0000000 0000000 # https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
version: 2
updates:
- package-ecosystem: "github-actions"
directory: "/"
schedule:
interval: "monthly"
commit-message:
prefix: "ci(dependabot):"
- package-ecosystem: "pip"
directory: "/resources"
schedule:
interval: "weekly"
target-branch: "develop"
napari-0.5.0a1/.github/labeler.yml 0000664 0000000 0000000 00000000632 14370413656 0016713 0 ustar 00root root 0000000 0000000 # See: .github/workflows/labeler.yml and https://github.com/marketplace/actions/labeler
design:
- 'napari/_qt/qt_resources/**/*'
preferences:
- 'napari/_qt/**/*/preferences_dialog.py'
- 'napari/settings/**/*.py'
qt:
- 'napari/_qt/**/*.py'
- 'napari/_qt/**/*.py'
- 'napari/qt/**/*.py'
- 'napari/qt/**/*.py'
task:
- '.github/**/*'
tests:
- '**/*/_tests/**/*.py'
vispy:
- 'napari/_vispy'
napari-0.5.0a1/.github/missing_translations.md 0000664 0000000 0000000 00000001126 14370413656 0021355 0 ustar 00root root 0000000 0000000 ---
title: "[Automatic issue] Missing `_.trans()`."
labels: "good first issue"
---
It looks like one of our test cron detected missing translations.
You can see the latest output [here](https://github.com/napari/napari/actions/workflows/test_translations.yml).
There are likely new strings to either ignore, or to internationalise.
You can also Update the cron script to update this issue with better information as well.
Note that this issue will be automatically updated if kept open, or a new one will be created when necessary, if no open
issue is found and new `_.trans` call are missing.
napari-0.5.0a1/.github/workflows/ 0000775 0000000 0000000 00000000000 14370413656 0016616 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/.github/workflows/auto_author_assign.yml 0000664 0000000 0000000 00000000446 14370413656 0023243 0 ustar 00root root 0000000 0000000 # https://github.com/marketplace/actions/auto-author-assign
name: 'Auto Author Assign'
on:
pull_request_target:
types: [opened, reopened]
permissions:
pull-requests: write
jobs:
assign-author:
runs-on: ubuntu-latest
steps:
- uses: toshimaru/auto-author-assign@v1.6.1
napari-0.5.0a1/.github/workflows/benchmarks.yml 0000664 0000000 0000000 00000015636 14370413656 0021471 0 ustar 00root root 0000000 0000000 # This CI configuration for relative benchmarks is based on the research done
# for scikit-image's implementation available here:
# https://github.com/scikit-image/scikit-image/blob/9bdd010a8/.github/workflows/benchmarks.yml#L1
# Blog post with the rationale: https://labs.quansight.org/blog/2021/08/github-actions-benchmarks/
name: Benchmarks
on:
pull_request:
types: [labeled]
schedule:
- cron: "6 6 * * 0" # every sunday
workflow_dispatch:
inputs:
base_ref:
description: "Baseline commit or git reference"
required: true
contender_ref:
description: "Contender commit or git reference"
required: true
# This is the main configuration section that needs to be fine tuned to napari's needs
# All the *_THREADS options is just to make the benchmarks more robust by not using parallelism
env:
OPENBLAS_NUM_THREADS: "1"
MKL_NUM_THREADS: "1"
OMP_NUM_THREADS: "1"
ASV_OPTIONS: "--split --show-stderr --factor 1.5 --attribute timeout=300"
# --split -> split final reports in tables
# --show-stderr -> print tracebacks if errors occur
# --factor 1.5 -> report anomaly if tested timings are beyond 1.5x base timings
# --attribute timeout=300 -> override timeout attribute (default=60s) to allow slow tests to run
# see https://asv.readthedocs.io/en/stable/commands.html#asv-continuous for more details!
jobs:
benchmark:
if: ${{ github.event.label.name == 'run-benchmarks' && github.event_name == 'pull_request' || github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }}
name: ${{ matrix.benchmark-name }}
runs-on: ${{ matrix.runs-on }}
strategy:
fail-fast: false
matrix:
include:
- benchmark-name: Qt
asv-command: continuous
selection-regex: "^benchmark_qt_.*"
runs-on: macos-latest
# Qt tests run on macOS to avoid using Xvfb business
# xvfb makes everything run, but some tests segfault :shrug:
# Fortunately, macOS graphics stack does not need xvfb!
- benchmark-name: non-Qt
asv-command: continuous
selection-regex: "^benchmark_(?!qt_).*"
runs-on: ubuntu-latest
steps:
# We need the full repo to avoid this issue
# https://github.com/actions/checkout/issues/23
- uses: actions/checkout@v3
with:
fetch-depth: 0
- uses: actions/setup-python@v4
name: Install Python
with:
python-version: "3.9"
cache-dependency-path: setup.cfg
- uses: tlambert03/setup-qt-libs@v1
- name: Setup asv
run: python -m pip install asv virtualenv
- uses: octokit/request-action@v2.x
id: latest_release
with:
route: GET /repos/{owner}/{repo}/releases/latest
owner: napari
repo: napari
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- name: Run ${{ matrix.benchmark-name }} benchmarks
id: run_benchmark
env:
# asv will checkout commits, which might contain LFS artifacts; ignore those errors since
# they are probably just documentation PNGs not needed here anyway
GIT_LFS_SKIP_SMUDGE: 1
run: |
set -euxo pipefail
# ID this runner
asv machine --yes
if [[ $GITHUB_EVENT_NAME == pull_request ]]; then
EVENT_NAME="PR #${{ github.event.pull_request.number }}"
BASE_REF=${{ github.event.pull_request.base.sha }}
CONTENDER_REF=${GITHUB_SHA}
echo "Baseline: ${BASE_REF} (${{ github.event.pull_request.base.label }})"
echo "Contender: ${CONTENDER_REF} (${{ github.event.pull_request.head.label }})"
elif [[ $GITHUB_EVENT_NAME == schedule ]]; then
EVENT_NAME="cronjob"
BASE_REF="${{ fromJSON(steps.latest_release.outputs.data).target_commitish }}"
CONTENDER_REF="${GITHUB_SHA}"
echo "Baseline: ${BASE_REF} (${{ fromJSON(steps.latest_release.outputs.data).tag_name }})"
echo "Contender: ${CONTENDER_REF} (current main)"
elif [[ $GITHUB_EVENT_NAME == workflow_dispatch ]]; then
EVENT_NAME="manual trigger"
BASE_REF="${{ github.event.inputs.base_ref }}"
CONTENDER_REF="${{ github.event.inputs.contender_ref }}"
echo "Baseline: ${BASE_REF} (workflow input)"
echo "Contender: ${CONTENDER_REF} (workflow input)"
fi
echo "EVENT_NAME=$EVENT_NAME" >> $GITHUB_ENV
echo "BASE_REF=$BASE_REF" >> $GITHUB_ENV
echo "CONTENDER_REF=$CONTENDER_REF" >> $GITHUB_ENV
# Run benchmarks for current commit against base
asv continuous $ASV_OPTIONS -b '${{ matrix.selection-regex }}' ${BASE_REF} ${CONTENDER_REF} \
| sed -E "/Traceback | failed$|PERFORMANCE DECREASED/ s/^/::error:: /" \
| tee asv_continuous.log
# Report and export results for subsequent steps
if grep "Traceback \|failed\|PERFORMANCE DECREASED" asv_continuous.log > /dev/null ; then
exit 1
fi
- name: Report Failures as Issue
if: ${{ (github.event_name == 'schedule' || github.event_name == 'workflow_dispatch') && failure() }}
uses: JasonEtco/create-an-issue@v2
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
PLATFORM: ${{ matrix.runs-on }}
PYTHON: "3.9"
BACKEND: ${{ matrix.benchmark-name }}
RUN_ID: ${{ github.run_id }}
TITLE: "[test-bot] Benchmark tests failing"
with:
filename: .github/TEST_FAIL_TEMPLATE.md
update_existing: true
- name: Add more info to artifact
if: always()
run: |
# Copy the full `asv continuous` log
cp asv_continuous.log .asv/results/asv_continuous_${{ matrix.benchmark-name }}.log
# ensure that even if this isn't a PR, the benchmark_report workflow can run without error
touch .asv/results/message_${{ matrix.benchmark-name }}.txt
# Add the message that might be posted as a comment on the PR
# We delegate the actual comment to `benchmarks_report.yml` due to
# potential token permissions issues
if [[ $GITHUB_EVENT_NAME == pull_request ]]; then
echo "${{ github.event.pull_request.number }}" > .asv/results/pr_number
echo \
"The ${{ matrix.benchmark-name }} benchmark run requested by $EVENT_NAME ($CONTENDER_REF vs $BASE_REF) has" \
"finished with status '${{ steps.run_benchmark.outcome }}'. See the" \
"[CI logs and artifacts](||BENCHMARK_CI_LOGS_URL||) for further details." \
> .asv/results/message_${{ matrix.benchmark-name }}.txt
fi
- uses: actions/upload-artifact@v3
if: always()
with:
name: asv-benchmark-results-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}
path: .asv/results
napari-0.5.0a1/.github/workflows/benchmarks_report.yml 0000664 0000000 0000000 00000005331 14370413656 0023053 0 ustar 00root root 0000000 0000000 # Report benchmark results to the PR
# We need a dual workflow to make sure the token has the needed permissions to post comments
# See https://stackoverflow.com/a/71683208 for more details
# When this workflow is triggered, it pulls the latest version of this file on
# the default branch. Changes to this file won't be reflected until after the
# PR is merged.
# https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#workflow_run
name: "Benchmarks - Report"
on:
workflow_run:
workflows: [Benchmarks]
types:
- completed
jobs:
download:
runs-on: ubuntu-latest
steps:
- name: "Download artifact"
uses: actions/github-script@v6
with:
script: |
let allArtifacts = await github.rest.actions.listWorkflowRunArtifacts({
owner: context.repo.owner,
repo: context.repo.repo,
run_id: context.payload.workflow_run.id,
});
let artifactName = `asv-benchmark-results-${context.payload.workflow_run.id}-${context.payload.workflow_run.run_number}-${context.payload.workflow_run.run_attempt}`
let matchArtifact = allArtifacts.data.artifacts.filter((artifact) => {
return artifact.name == artifactName
})[0];
let download = await github.rest.actions.downloadArtifact({
owner: context.repo.owner,
repo: context.repo.repo,
artifact_id: matchArtifact.id,
archive_format: 'zip',
});
let fs = require('fs');
fs.writeFileSync(`${process.env.GITHUB_WORKSPACE}/asv_results.zip`, Buffer.from(download.data));
- name: Unzip and prepare data
run: |
unzip asv_results.zip
# combine the Qt and non-Qt messages
cat message_Qt.txt message_non-Qt.txt > message.txt
- name: Replace URLs
run: |
sed -i 's@||BENCHMARK_CI_LOGS_URL||@${{ github.event.workflow_run.html_url }}@g' message.txt
- name: Collect PR number if available
run: |
if [[ -f pr_number ]]; then
echo "PR_NUMBER=$(cat pr_number)" >> $GITHUB_ENV
fi
- name: "Comment on PR"
if: env.PR_NUMBER != ''
uses: actions/github-script@v6
with:
github-token: ${{ secrets.GITHUB_TOKEN }}
script: |
let fs = require('fs');
let issue_number = Number(process.env.PR_NUMBER);
let body = fs.readFileSync('message.txt', 'utf8');
await github.rest.issues.createComment({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: issue_number,
body: body,
});
napari-0.5.0a1/.github/workflows/build_docs.yml 0000664 0000000 0000000 00000003224 14370413656 0021451 0 ustar 00root root 0000000 0000000 name: Build PR Docs
on:
pull_request:
branches:
- main
push:
branches:
- docs
tags:
- 'v*'
workflow_dispatch:
jobs:
build-and-upload:
name: Build & Upload Artifact
runs-on: ubuntu-latest
steps:
- name: Clone docs repo
uses: actions/checkout@v3
with:
path: docs # place in a named directory
repository: napari/docs
- name: Clone main repo
uses: actions/checkout@v3
with:
path: napari-repo
- name: Copy examples to docs folder
run: |
cp -R napari-repo/examples docs
- uses: actions/setup-python@v4
with:
python-version: 3.9
cache-dependency-path: setup.cfg
- uses: tlambert03/setup-qt-libs@v1
- name: Install Dependencies
run: |
python -m pip install --upgrade pip
python -m pip install "napari-repo/[all]"
- name: Testing
run: |
python -c 'import napari; print(napari.__version__)'
python -c 'import napari.layers; print(napari.layers.__doc__)'
- name: Build Docs
uses: aganders3/headless-gui@v1
env:
GOOGLE_CALENDAR_ID: ${{ secrets.GOOGLE_CALENDAR_ID }}
GOOGLE_CALENDAR_API_KEY: ${{ secrets.GOOGLE_CALENDAR_API_KEY }}
with:
# the napari-docs repo is cloned into a docs/ folder, hence the
# invocation below. Locally, you should simply run make docs
run: make -C docs docs GALLERY_PATH=../examples/
- name: Upload artifact
uses: actions/upload-artifact@v3
with:
name: docs
path: docs/docs/_build
napari-0.5.0a1/.github/workflows/deploy_docs.yml 0000664 0000000 0000000 00000001105 14370413656 0021642 0 ustar 00root root 0000000 0000000 name: Build Docs
on:
push:
branches:
- main
workflow_dispatch:
concurrency:
group: docs-${{ github.ref }}
cancel-in-progress: true
jobs:
build-napari-docs:
name: Build docs on napari/docs
runs-on: ubuntu-latest
steps:
- name: Trigger workflow and wait
uses: convictional/trigger-workflow-and-wait@v1.6.5
with:
owner: napari
repo: docs
github_token: ${{ secrets.ACTIONS_DEPLOY_DOCS }}
workflow_file_name: deploy_docs.yml
trigger_workflow: true
wait_workflow: true
napari-0.5.0a1/.github/workflows/docker-singularity-publish.yml 0000664 0000000 0000000 00000010224 14370413656 0024623 0 ustar 00root root 0000000 0000000 name: Docker and Singularity build
# This workflow uses actions that are not certified by GitHub.
# They are provided by a third-party and are governed by
# separate terms of service, privacy policy, and support
# documentation.
on:
workflow_dispatch:
# schedule:
# - cron: '31 0 * * *'
push:
branches: [ main ]
# Publish semver tags as releases.
tags: [ 'v*.*.*' ]
env:
# Use docker.io for Docker Hub if empty
REGISTRY: ghcr.io
jobs:
build1:
runs-on: ubuntu-latest
permissions:
contents: read
packages: write
strategy:
fail-fast: false
matrix:
include:
- recipe: Docker
target: napari
image-name: napari/napari
- recipe: Docker
target: napari-xpra
image-name: napari/napari-xpra
steps:
- name: Checkout repository
uses: actions/checkout@v3
# Login against a Docker registry except on PR
# https://github.com/docker/login-action
- name: Log into registry ${{ env.REGISTRY }}
if: github.event_name != 'pull_request'
uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a
with:
registry: ${{ env.REGISTRY }}
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
# Extract metadata (tags, labels) for Docker
# https://github.com/docker/metadata-action
# https://github.com/docker/build-push-action/blob/master/docs/advanced/tags-labels.md
- name: Extract Docker metadata
id: meta
uses: docker/metadata-action@v4
with:
# list of Docker images to use as base name for tags
images: ${{ env.REGISTRY }}/${{ matrix.image-name }}
# images: |
# name/app
# ghcr.io/username/app
# generate Docker tags based on the following events/attributes
tags: |
type=schedule
type=ref,event=branch
type=ref,event=pr
type=semver,pattern={{version}}
type=semver,pattern={{major}}.{{minor}}
type=semver,pattern={{major}}
type=sha
latest
# oras://ghcr.io is tagged latest too, and seems to override the docker://ghcr.io tag -> race condition?
# Build and push Docker image with Buildx (don't push on PR)
# https://github.com/docker/build-push-action
- name: Build and push Docker image
uses: docker/build-push-action@v4
with:
context: .
push: ${{ github.event_name != 'pull_request' }}
tags: ${{ steps.meta.outputs.tags }}
labels: ${{ steps.meta.outputs.labels }}
file: "dockerfile"
target: ${{ matrix.target }}
# ----
build2:
needs: build1
runs-on: ubuntu-latest
container:
image: quay.io/singularity/docker2singularity:v3.10.0
options: --privileged
permissions:
contents: read
packages: write
strategy:
fail-fast: false
matrix:
recipe: ["Singularity"]
steps:
- name: Checkout repository
uses: actions/checkout@v3
- name: Continue if Singularity Recipe Exists
run: |
if [[ -f "${{ matrix.recipe }}" ]]; then
echo "keepgoing=true" >> $GITHUB_ENV
fi
- name: Build Container
if: ${{ env.keepgoing == 'true' }}
env:
recipe: ${{ matrix.recipe }}
run: |
ls
if [ -f "${{ matrix.recipe }}" ]; then
singularity build container.sif ${{ matrix.recipe }}
tag=latest
fi
# Build the container and name by tag
echo "Tag is $tag."
echo "tag=$tag" >> $GITHUB_ENV
- name: Login and Deploy Container
if: (github.event_name != 'pull_request')
env:
keepgoing: ${{ env.keepgoing }}
run: |
if [[ "${keepgoing}" == "true" ]]; then
echo ${{ secrets.GITHUB_TOKEN }} | singularity remote login -u ${{ secrets.GHCR_USERNAME }} --password-stdin oras://ghcr.io
singularity push container.sif oras://ghcr.io/${GITHUB_REPOSITORY}:${tag}
fi
napari-0.5.0a1/.github/workflows/labeler.yml 0000664 0000000 0000000 00000000376 14370413656 0020755 0 ustar 00root root 0000000 0000000 # https://github.com/marketplace/actions/labeler
name: "Pull Request Labeler"
on:
- pull_request_target
jobs:
triage:
runs-on: ubuntu-latest
steps:
- uses: actions/labeler@main
with:
repo-token: "${{ secrets.GITHUB_TOKEN }}"
napari-0.5.0a1/.github/workflows/make_bundle.yml 0000664 0000000 0000000 00000007731 14370413656 0021617 0 ustar 00root root 0000000 0000000 on:
push:
# Sequence of patterns matched against refs/tags
tags:
- "v*" # Push events to matching v*, i.e. v1.0, v20.15.10
branches:
- main
pull_request:
branches:
- main
paths-ignore:
- 'docs/**'
schedule:
- cron: "0 0 * * *"
# Allows you to run this workflow manually from the Actions tab
workflow_dispatch:
concurrency:
group: create-bundle-${{ github.ref }}
cancel-in-progress: true
name: Create Bundle
jobs:
bundle:
name: Bundle ${{ matrix.platform }}
runs-on: ${{ matrix.platform }}
if: github.repository == 'napari/napari'
env:
GITHUB_TOKEN: ${{ github.token }}
DISPLAY: ":99.0"
strategy:
fail-fast: false
matrix:
include:
- platform: ubuntu-18.04
python-version: "3.9"
- platform: macos-latest
python-version: "3.9"
- platform: windows-latest
python-version: "3.8"
steps:
- name: Checkout code
uses: actions/checkout@v3
with:
fetch-depth: 0
- name: Install Python
uses: actions/setup-python@v4
with:
python-version: ${{ matrix.python-version }}
cache-dependency-path: setup.cfg
- name: Install Dependencies
run: |
python -m pip install --upgrade pip
python -m pip install -e '.[bundle_build]'
- name: get tag / arch-suffix
shell: bash
run: |
VER=`python bundle.py --version`
echo "version=${VER}" >> $GITHUB_ENV
echo "Version: $VER"
ARCH_SUFFIX=`python bundle.py --arch`
echo "arch-suffix=${ARCH_SUFFIX}" >> $GITHUB_ENV
echo "Machine: ${ARCH_SUFFIX}"
- name: Make Bundle (Linux)
if: runner.os == 'Linux'
run: |
sudo apt-get update
sudo apt-get install -y libdbus-1-3 libxkbcommon-x11-0 libxcb-icccm4 \
libxcb-image0 libxcb-keysyms1 libxcb-randr0 libxcb-render-util0 \
libxcb-xinerama0 libxcb-xfixes0 libxcb-shape0 libqt5gui5
xvfb-run --auto-servernum python bundle.py
- name: Make Bundle (Windows & MacOS)
if: runner.os != 'Linux'
run: python bundle.py
- name: Upload Artifact
uses: actions/upload-artifact@v3
with:
name: napari-${{ env.version }}-${{ runner.os }}-${{ env.arch-suffix }}.zip
path: napari-${{ env.version }}-${{ runner.os }}-${{ env.arch-suffix }}.zip
- name: Get Release
if: startsWith(github.ref, 'refs/tags/v')
id: get_release
uses: bruceadams/get-release@v1.3.2
- name: Upload Release Asset
if: startsWith(github.ref, 'refs/tags/v')
uses: actions/upload-release-asset@v1
with:
upload_url: ${{ steps.get_release.outputs.upload_url }}
asset_path: napari-${{ env.version }}-${{ runner.os }}-${{ env.arch-suffix }}.zip
asset_name: napari-${{ env.version }}-${{ runner.os }}-${{ env.arch-suffix }}.zip
asset_content_type: application/zip
- name: Upload Nightly Build Asset
if: ${{ github.event_name == 'schedule' }}
uses: WebFreak001/deploy-nightly@v2.0.0
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
# nightly build release from https://api.github.com/repos/napari/napari/releases
upload_url: https://uploads.github.com/repos/napari/napari/releases/34273071/assets{?name,label}
release_id: 34273071
asset_path: napari-${{ env.version }}-${{ runner.os }}-${{ env.arch-suffix }}.zip
asset_name: napari-${{ runner.os }}-${{ env.arch-suffix }}.zip
asset_content_type: application/zip
max_releases: 1
- name: Update latest tag
uses: EndBug/latest-tag@latest
if: ${{ github.event_name == 'schedule' }}
with:
description: latest code released from nightly build
tag-name: latest
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
napari-0.5.0a1/.github/workflows/make_bundle_conda.yml 0000664 0000000 0000000 00000000651 14370413656 0022755 0 ustar 00root root 0000000 0000000 name: Conda
on:
push:
# Sequence of patterns matched against refs/tags
tags:
- "v*" # Push events to matching v*, i.e. v1.0, v20.15.10
schedule:
- cron: "0 0 * * *"
# workflow_dispatch: # go to napari/packaging to trigger manual runs
jobs:
packaging:
uses: napari/packaging/.github/workflows/make_bundle_conda.yml@main
secrets: inherit
with:
event_name: ${{ github.event_name }}
napari-0.5.0a1/.github/workflows/make_release.yml 0000664 0000000 0000000 00000005135 14370413656 0021762 0 ustar 00root root 0000000 0000000 on:
push:
# Sequence of patterns matched against refs/tags
tags:
- 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
name: Create Release
jobs:
build:
name: Create Release
runs-on: ubuntu-latest
if: github.repository == 'napari/napari'
steps:
- name: Checkout code
uses: actions/checkout@v3
- name: Install Python
uses: actions/setup-python@v4
with:
python-version: 3.9
cache-dependency-path: setup.cfg
- name: Install Dependencies
run: |
python -m pip install --upgrade pip
python -m pip install -e .[build] # need full install so we can build type stubs
- name: Build Distribution
run: make dist
- name: Find Release Notes
id: release_notes
run: |
TAG="${GITHUB_REF/refs\/tags\/v/}" # clean tag
if [[ "$TAG" != *"rc"* ]]; then
VER="${TAG/rc*/}" # remove pre-release identifier
RELEASE_NOTES="$(cat docs/release/release_${VER//./_}.md)"
# https://github.community/t5/GitHub-Actions/set-output-Truncates-Multiline-Strings/m-p/38372/highlight/true#M3322
RELEASE_NOTES="${RELEASE_NOTES//'%'/'%25'}"
RELEASE_NOTES="${RELEASE_NOTES//$'\n'/'%0A'}"
RELEASE_NOTES="${RELEASE_NOTES//$'\r'/'%0D'}"
else
RELEASE_NOTES="pre-release $TAG"
fi
echo "tag=${TAG}" >> $GITHUB_ENV
# https://help.github.com/en/actions/reference/workflow-commands-for-github-actions
echo "::set-output name=contents::$RELEASE_NOTES"
- name: Create Release
id: create_release
uses: actions/create-release@latest
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
with:
tag_name: ${{ github.ref }}
release_name: ${{ env.tag }}
body: ${{ steps.release_notes.outputs.contents }}
draft: false
prerelease: ${{ contains(github.ref, 'rc') }}
- name: Upload Release Asset
uses: actions/upload-release-asset@v1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }}
asset_path: ./dist/napari-${{ env.tag }}.tar.gz
asset_name: napari-${{ env.tag }}.tar.gz
asset_content_type: application/gzip
- name: Publish PyPI Package
uses: pypa/gh-action-pypi-publish@master
with:
user: __token__
password: ${{ secrets.pypi_password }}
napari-0.5.0a1/.github/workflows/test_comprehensive.yml 0000664 0000000 0000000 00000012434 14370413656 0023253 0 ustar 00root root 0000000 0000000 # The Comprehensive test suite, which will be run anytime anything is merged into main.
# See test_pull_request.yml for the tests that will be run
name: Comprehensive Test
on:
push:
branches:
- main
- "v*x"
tags:
- "v*" # Push events to matching v*, i.e. v1.0, v20.15.10
# Allows you to run this workflow manually from the Actions tab
workflow_dispatch:
concurrency:
group: comprehensive-test
jobs:
manifest:
name: Check Manifest
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Set up Python 3.8
uses: actions/setup-python@v4
with:
python-version: 3.8
- name: Install dependencies
run: |
pip install --upgrade pip
pip install check-manifest
- name: Check Manifest
run: check-manifest
test:
name: ${{ matrix.platform }} py${{ matrix.python }} ${{ matrix.toxenv }} ${{ matrix.MIN_REQ && 'min_req' }}
runs-on: ${{ matrix.platform }}
strategy:
fail-fast: false
matrix:
platform: [ubuntu-latest, windows-latest]
python: ["3.8", "3.9", "3.10"]
backend: [pyqt5, pyside2]
include:
- python: 3.9
platform: macos-latest
backend: pyqt5
# test with minimum specified requirements
- python: 3.8
platform: ubuntu-18.04
backend: pyqt5
MIN_REQ: 1
# test with --async_only
- python: 3.8
platform: ubuntu-18.04
toxenv: async-py38-linux-pyqt5
# test without any Qt backends
- python: 3.8
platform: ubuntu-18.04
toxenv: headless-py38-linux
steps:
- name: Cancel Previous Runs
uses: styfle/cancel-workflow-action@0.11.0
with:
access_token: ${{ github.token }}
- uses: actions/checkout@v3
- name: Set up Python ${{ matrix.python }}
uses: actions/setup-python@v4
with:
python-version: ${{ matrix.python }}
cache: "pip"
cache-dependency-path: setup.cfg
- uses: tlambert03/setup-qt-libs@v1
# strategy borrowed from vispy for installing opengl libs on windows
- name: Install Windows OpenGL
if: runner.os == 'Windows'
run: |
git clone --depth 1 https://github.com/pyvista/gl-ci-helpers.git
powershell gl-ci-helpers/appveyor/install_opengl.ps1
if (Test-Path -Path "C:\Windows\system32\opengl32.dll" -PathType Leaf) {Exit 0} else {Exit 1}
- name: Install dependencies
run: |
pip install --upgrade pip
pip install setuptools tox tox-gh-actions
python tools/minreq.py # no-op if MIN_REQ is not set
env:
MIN_REQ: ${{ matrix.MIN_REQ }}
# here we pass off control of environment creation and running of tests to tox
# tox-gh-actions, installed above, helps to convert environment variables into
# tox "factors" ... limiting the scope of what gets tested on each platform
# The one exception is if the "toxenv" environment variable has been set,
# in which case we are declaring one specific tox environment to run.
# see tox.ini for more
- name: Test with tox
uses: aganders3/headless-gui@v1
with:
run: python -m tox
env:
PLATFORM: ${{ matrix.platform }}
BACKEND: ${{ matrix.backend }}
TOXENV: ${{ matrix.toxenv }}
NUMPY_EXPERIMENTAL_ARRAY_FUNCTION: ${{ matrix.MIN_REQ || 1 }}
PYVISTA_OFF_SCREEN: True
MIN_REQ: ${{ matrix.MIN_REQ }}
- name: Coverage
uses: codecov/codecov-action@v3
- name: Report Failures
if: ${{ failure() }}
uses: JasonEtco/create-an-issue@v2
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
PLATFORM: ${{ matrix.platform }}
PYTHON: ${{ matrix.python }}
BACKEND: ${{ matrix.toxenv }}
RUN_ID: ${{ github.run_id }}
TITLE: "[test-bot] Comprehensive tests failing"
with:
filename: .github/TEST_FAIL_TEMPLATE.md
update_existing: true
test_pip_install:
name: ubuntu-latest 3.9 pip install
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
with:
path: napari-from-github
- name: Set up Python 3.9
uses: actions/setup-python@v4
with:
python-version: 3.9
cache: "pip"
cache-dependency-path: napari-from-github/setup.cfg
- uses: tlambert03/setup-qt-libs@v1
- name: Install this commit
run: |
pip install --upgrade pip
pip install ./napari-from-github[all,testing]
- name: Test
uses: aganders3/headless-gui@v1
with:
run: python -m pytest --pyargs napari --color=yes
test_examples:
name: test examples
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-python@v4
with:
python-version: 3.9
- uses: tlambert03/setup-qt-libs@v1
- name: Install this commit
run: |
pip install --upgrade pip
pip install setuptools tox tox-gh-actions
- name: Test
uses: aganders3/headless-gui@v1
with:
run: tox -e py39-linux-pyside2-examples
napari-0.5.0a1/.github/workflows/test_prereleases.yml 0000664 0000000 0000000 00000004405 14370413656 0022715 0 ustar 00root root 0000000 0000000 # An "early warning" cron job that will install dependencies
# with `pip install --pre` periodically to test for breakage
# (and open an issue if a test fails)
name: --pre Test
on:
schedule:
- cron: '0 */12 * * *' # every 12 hours
# Allows you to run this workflow manually from the Actions tab
workflow_dispatch:
jobs:
test:
name: ${{ matrix.platform }} py${{ matrix.python }} ${{ matrix.backend }} --pre
runs-on: ${{ matrix.platform }}
if: github.repository == 'napari/napari'
strategy:
fail-fast: false
matrix:
platform: [windows-latest, macos-latest, ubuntu-latest]
python: [3.9]
backend: [pyqt5, pyside2]
steps:
- uses: actions/checkout@v3
- name: Set up Python ${{ matrix.python }}
uses: actions/setup-python@v4
with:
python-version: ${{ matrix.python }}
cache-dependency-path: setup.cfg
- uses: tlambert03/setup-qt-libs@v1
- name: Install Windows OpenGL
if: runner.os == 'Windows'
run: |
git clone --depth 1 https://github.com/pyvista/gl-ci-helpers.git
powershell gl-ci-helpers/appveyor/install_opengl.ps1
if (Test-Path -Path "C:\Windows\system32\opengl32.dll" -PathType Leaf) {Exit 0} else {Exit 1}
- name: Install dependencies
run: |
pip install --upgrade pip
pip install setuptools tox tox-gh-actions
- name: Test with tox
# run tests using pip install --pre
uses: aganders3/headless-gui@v1
with:
run: python -m tox -v --pre
env:
PLATFORM: ${{ matrix.platform }}
BACKEND: ${{ matrix.backend }}
PYVISTA_OFF_SCREEN: True # required for opengl on windows
# If something goes wrong, we can open an issue in the repo
- name: Report Failures
if: ${{ failure() }}
uses: JasonEtco/create-an-issue@v2
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
PLATFORM: ${{ matrix.platform }}
PYTHON: ${{ matrix.python }}
BACKEND: ${{ matrix.backend }}
RUN_ID: ${{ github.run_id }}
TITLE: '[test-bot] pip install --pre is failing'
with:
filename: .github/TEST_FAIL_TEMPLATE.md
update_existing: true
napari-0.5.0a1/.github/workflows/test_pull_requests.yml 0000664 0000000 0000000 00000014677 14370413656 0023326 0 ustar 00root root 0000000 0000000 # Our minimal suite of tests that run on each pull request
name: PR Test
on:
pull_request:
branches:
- main
- "v*x"
concurrency:
group: test-${{ github.ref }}
cancel-in-progress: true
jobs:
manifest:
# make sure all necessary files will be bundled in the release
name: Check Manifest
timeout-minutes: 15
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-python@v4
with:
python-version: "3.x"
cache-dependency-path: setup.cfg
cache: 'pip'
- name: Install Dependencies
run: pip install --upgrade pip
- name: Install Napari dev
run: pip install -e .[build]
- name: Check Manifest
run: |
make typestubs
make check-manifest
localization_syntax:
# make sure all necessary files will be bundled in the release
name: Check l18n syntax
runs-on: ubuntu-latest
timeout-minutes: 2
steps:
- uses: actions/checkout@v3
- uses: actions/setup-python@v4
with:
python-version: "3.x"
- name: Check localization formatting
run: |
pip install --upgrade pip semgrep
# f"..." and f'...' are the same for semgrep
semgrep --error --lang python --pattern 'trans._(f"...")' napari
semgrep --error --lang python --pattern 'trans._($X.format(...))' napari
test:
name: ${{ matrix.platform }} ${{ matrix.python }} ${{ matrix.toxenv || matrix.backend }} ${{ matrix.MIN_REQ && 'min_req' }}
runs-on: ${{ matrix.platform }}
timeout-minutes: 40
strategy:
fail-fast: false
matrix:
platform: [ubuntu-latest]
python: ["3.8", "3.9", "3.10"]
backend: [pyqt5, pyside2]
include:
# Windows py38
- python: 3.8
platform: windows-latest
backend: pyqt5
- python: 3.8
platform: windows-latest
backend: pyside2
- python: 3.9
platform: macos-latest
backend: pyqt5
# minimum specified requirements
- python: 3.8
platform: ubuntu-18.04
backend: pyqt5
MIN_REQ: 1
# test with --async_only
- python: 3.8
platform: ubuntu-18.04
toxenv: async-pyqt5-py38-linux
# test without any Qt backends
- python: 3.8
platform: ubuntu-18.04
toxenv: headless-py38-linux
- python: 3.9
platform: ubuntu-latest
backend: pyqt6
- python: 3.9
platform: ubuntu-latest
backend: pyside6
- python: '3.10'
platform: ubuntu-latest
backend: pyside6
steps:
- name: Cancel Previous Runs
uses: styfle/cancel-workflow-action@0.11.0
with:
access_token: ${{ github.token }}
- uses: actions/checkout@v3
- name: Set up Python ${{ matrix.python }}
uses: actions/setup-python@v4
with:
python-version: ${{ matrix.python }}
cache: "pip"
cache-dependency-path: setup.cfg
- uses: tlambert03/setup-qt-libs@v1
# strategy borrowed from vispy for installing opengl libs on windows
- name: Install Windows OpenGL
if: runner.os == 'Windows'
run: |
git clone --depth 1 https://github.com/pyvista/gl-ci-helpers.git
powershell gl-ci-helpers/appveyor/install_opengl.ps1
if (Test-Path -Path "C:\Windows\system32\opengl32.dll" -PathType Leaf) {Exit 0} else {Exit 1}
# tox and tox-gh-actions will take care of the "actual" installation
# of python dependendencies into a virtualenv. see tox.ini for more
- name: Install dependencies
run: |
pip install --upgrade pip
pip install setuptools tox tox-gh-actions
python tools/minreq.py
env:
# tools/minreq.py sets all deps to their minumim stated versions
# it is a no-op if MIN_REQ is not set
MIN_REQ: ${{ matrix.MIN_REQ }}
# here we pass off control of environment creation and running of tests to tox
# tox-gh-actions, installed above, helps to convert environment variables into
# tox "factors" ... limiting the scope of what gets tested on each platform
# for instance, on ubuntu-latest with python 3.8, it would be equivalent to this command:
# `tox -e py38-linux-pyqt,py38-linux-pyside`
# see tox.ini for more
- name: Test with tox
# the longest is macos-latest 3.9 pyqt5 at ~30 minutes.
timeout-minutes: 35
uses: aganders3/headless-gui@v1
with:
run: python -m tox
env:
PLATFORM: ${{ matrix.platform }}
BACKEND: ${{ matrix.backend }}
TOXENV: ${{ matrix.toxenv }}
NUMPY_EXPERIMENTAL_ARRAY_FUNCTION: ${{ matrix.MIN_REQ || 1 }}
PYVISTA_OFF_SCREEN: True
MIN_REQ: ${{ matrix.MIN_REQ }}
- uses: actions/upload-artifact@v3
with:
name: upload pytest timing reports as json
path: |
./report-*.json
- name: Coverage
uses: codecov/codecov-action@v3
test_pip_install:
name: ubuntu-latest 3.9 pip install
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
with:
path: napari-from-github
- name: Set up Python 3.9
uses: actions/setup-python@v4
with:
python-version: 3.9
cache: "pip"
cache-dependency-path: napari-from-github/setup.cfg
- uses: tlambert03/setup-qt-libs@v1
- name: Install this commit
run: |
pip install --upgrade pip
pip install ./napari-from-github[all,testing]
- name: Test
uses: aganders3/headless-gui@v1
with:
run: |
python -m pytest --pyargs napari --color=yes
python -m pytest --pyargs napari_builtins --color=yes
test_examples:
name: test examples
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-python@v4
with:
python-version: 3.9
cache-dependency-path: setup.cfg
- uses: tlambert03/setup-qt-libs@v1
- name: Install this commit
run: |
pip install --upgrade pip
pip install setuptools tox tox-gh-actions
- name: Test
uses: aganders3/headless-gui@v1
with:
run: tox -e py39-linux-pyside2-examples
napari-0.5.0a1/.github/workflows/test_translations.yml 0000664 0000000 0000000 00000001570 14370413656 0023124 0 ustar 00root root 0000000 0000000 name: Test translations
on:
schedule:
# * is a special character in YAML so you have to quote this string
- cron: '0 1 * * *'
workflow_dispatch:
jobs:
translations:
name: Check missing translations
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Set up Python 3.8
uses: actions/setup-python@v4
with:
python-version: 3.9
cache-dependency-path: setup.cfg
- name: Install napari
run: |
pip install -e .[all]
pip install -e .[testing]
- name: Run check
run: |
python -m pytest -Wignore tools/ --tb=short
- uses: JasonEtco/create-an-issue@v2
if: ${{ failure() }}
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
filename: .github/missing_translations.md
update_existing: true
napari-0.5.0a1/.github/workflows/test_typing.yml 0000664 0000000 0000000 00000001017 14370413656 0021711 0 ustar 00root root 0000000 0000000 name: Test typing
on:
pull_request:
branches:
- main
jobs:
typing:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-python@v4
with:
python-version: 3.9
cache-dependency-path: setup.cfg
- name: Install napari
run: |
pip install -r resources/requirements_mypy.txt
SETUPTOOLS_ENABLE_FEATURES="legacy-editable" pip install -e .[all]
- name: Run mypy on typed modules
run: make typecheck
napari-0.5.0a1/.github/workflows/test_vendored.yml 0000664 0000000 0000000 00000001777 14370413656 0022222 0 ustar 00root root 0000000 0000000 name: Test vendored
on:
schedule:
# * is a special character in YAML so you have to quote this string
- cron: '0 2 * * *'
jobs:
vendor:
name: Vendored
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Set up Python 3.9
uses: actions/setup-python@v4
with:
python-version: 3.9
- name: Run check
id: check_v
run: python tools/check_vendored_modules.py --ci
- name: Create PR updating vendored modules
uses: peter-evans/create-pull-request@v4
with:
commit-message: Update vendored modules.
branch: update-vendored-examples
delete-branch: true
title: "[Automatic] Update ${{ steps.check_v.outputs.vendored }} vendored module"
body: |
This PR is automatically created and updated by napari GitHub
action cron to keep vendored modules up to date.
It look like ${{ steps.check_v.outputs.vendored }} has a new version.
napari-0.5.0a1/.gitignore 0000664 0000000 0000000 00000004412 14370413656 0015212 0 ustar 00root root 0000000 0000000 # Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
.dmypy.json
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
pip-wheel-metadata/
# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
.pytest_cache/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
db.sqlite3
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/source/api/
docs/source/release/
docs/source/releases.rst
docs/build/
docs/_tags
# PyBuilder
target/
# Jupyter Notebook
.ipynb_checkpoints
# pyenv
.python-version
# celery beat schedule file
celerybeat-schedule
# SageMath parsed files
*.sage.py
# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
# Pycharm files
.idea
# Liclipse
.project
.pydevproject
.settings/
# OS stuff
.DS_store
# Benchmarking results
.asv/
# VSCode
.vscode/
# emacs
*~
\#*\#
auto-save-list
tramp
.\#*
*_flymake.*
.projectile
.dir-locals.el
# these will get autogenerated
_qt_resources*.py
res.qrc
# ignore all generated themed svgs
napari/resources/themes
# briefcase
macOS/
linux/
windows/
napari/_version.py
docs/api/napari*
docs/_build
# built in setup.py
napari/view_layers.pyi
napari/components/viewer_model.pyi
# Autogenerated documentation
docs/images/_autogenerated/
docs/guides/preferences.md
docs/guides/_layer_events.md
docs/guides/_viewer_events.md
docs/guides/_layerlist_events.md
# come from npe2 docs
docs/plugins/_npe2_*.md
napari/settings/napari.schema.json
docs/jupyter_execute/
docs/.jupyter_cache/
docs/gallery/
# pytest reports in json format https://github.com/napari/napari/pull/4518
report*.json
napari/resources/icons/_themes/
# perfmon
tools/perfmon/*/traces-*.json
github_cache.sqlite
napari-0.5.0a1/.pre-commit-config.yaml 0000664 0000000 0000000 00000001436 14370413656 0017506 0 ustar 00root root 0000000 0000000 repos:
- repo: https://github.com/MarcoGorelli/absolufy-imports
rev: v0.3.1
hooks:
- id: absolufy-imports
exclude: _vendor|vendored|examples
- repo: https://github.com/hadialqattan/pycln
rev: v2.1.3
hooks:
- id: pycln
- repo: https://github.com/psf/black
rev: 22.12.0
hooks:
- id: black
pass_filenames: true
exclude: _vendor|vendored|examples
- repo: https://github.com/charliermarsh/ruff-pre-commit
rev: v0.0.237
hooks:
- id: ruff
exclude: _vendor|vendored
- repo: https://github.com/seddonym/import-linter
rev: v1.7.0
hooks:
- id: import-linter
stages: [manual]
- repo: https://github.com/python-jsonschema/check-jsonschema
rev: 0.21.0
hooks:
- id: check-github-workflows
napari-0.5.0a1/CITATION.cff 0000664 0000000 0000000 00000006527 14370413656 0015125 0 ustar 00root root 0000000 0000000 # YAML 1.2
# Metadata for citation of this software according to the CFF format (https://citation-file-format.github.io/)
cff-version: 1.0.3
message: If you use this software, please cite it using these metadata.
title: 'napari: a multi-dimensional image viewer for Python'
doi: 10.5281/zenodo.3555620
authors:
- given-names: Nicholas
family-names: Sofroniew
affiliation: Chan Zuckerberg Initiative
orcid: "https://orcid.org/0000-0002-3426-0914"
- given-names: Talley
family-names: Lambert
affiliation: Harvard Medical School
orcid: "https://orcid.org/0000-0002-2409-0181"
- given-names: Kira
family-names: Evans
affiliation: Chan Zuckerberg Initiative
- given-names: Juan
family-names: Nunez-Iglesias
affiliation: Biomedicine Discovery Institute, Monash University
- given-names: Grzegorz
family-names: Bokota
affiliation: University of Warsaw, Faculty of Mathematics, Informatics, and Mechanics
orcid: https://orcid.org/0000-0002-5470-1676
- given-names: Philip
family-names: Winston
affiliation: Tobeva Software
- given-names: Gonzalo
family-names: Peña-Castellanos
affiliation: Quansight, Inc. / SIHSA Ltda
- given-names: Kevin
family-names: Yamauchi
affiliation: Iber Lab - ETH Zürich
- given-names: Matthias
family-names: Bussonnier
orcid: "http://orcid.org/0000-0002-7636-8632"
affiliation: Quansight Labs
- given-names: Draga
family-names: Doncila Pop
- given-names: Ahmet
family-names: Can Solak
affiliation: Chan Zuckerberg Biohub
- given-names: Ziyang
family-names: Liu
affiliation: Chan Zuckerberg Initiative Foundation
- given-names: Pam
family-names: Wadhwa
affiliation: Quansight Labs
- given-names: Alister
family-names: Burt
affiliation: MRC-LMB
- given-names: Genevieve
family-names: Buckley
affiliation: Monash University
orcid: https://orcid.org/0000-0003-2763-492X
- given-names: Andrew
family-names: Sweet
affiliation: Chan Zuckerberg Initiative
- given-names: Lukasz
family-names: Migas
affiliation: Delft University of Technology
- given-names: Volker
family-names: Hilsenstein
affiliation: EMBL Heidelberg, Germany
orcid: https://orcid.org/0000-0002-2255-2960
- given-names: Lorenzo
family-names: Gaifas
affiliation: Gutsche Lab - University of Grenoble
orcid: https://orcid.org/0000-0003-4875-9422
- given-names: Jordão
family-names: Bragantini
affiliation: Chan Zuckerberg Biohub
- given-names: Jaime
family-names: Rodríguez-Guerra
affiliation: Quansight Labs
- given-names: Hector
family-names: Muñoz
affiliation: University of California, Los Angeles
orcid: https://orcid.org/0000-0001-7851-2549
- given-names: Jeremy
family-names: Freeman
affiliation: Chan Zuckerberg Initiative
- given-names: Peter
family-names: Boone
- given-names: Alan
family-names: Lowe
name-particle: R
affiliation: UCL & The Alan Turing Institute
- given-names: Christoph
family-names: Gohlke
affiliation: University of California, Irvine
- given-names: Loic
family-names: Royer
affiliation: Chan Zuckerberg Biohub
- given-names: Andrea
family-names: Pierré
affiliation: Brown University
orcid: "https://orcid.org/0000-0003-4501-5428"
- given-names: Hagai
family-names: Har-Gil
affiliation: Tel Aviv University, Israel
- given-names: Abigail
family-names: McGovern
affiliation: Monash University
repository-code: https://github.com/napari/napari
license: BSD-3-Clause
napari-0.5.0a1/EULA.md 0000664 0000000 0000000 00000200214 14370413656 0014270 0 ustar 00root root 0000000 0000000 ## Notice of Third Party Software Licenses
napari may be [installed][napari_installers] through a variety of methods. Particularly, the
bundled installers may include third party software packages or tools licensed under different
terms. These licenses may be accessed from within the resulting napari installation or
https://napari.org.
[napari_installers]: https://napari.org/stable/#installation
Intel® OpenMP
```
Intel Simplified Software License (Version August 2021)
Use and Redistribution. You may use and redistribute the software (the
"Software"), without modification, provided the following conditions are met:
* Redistributions must reproduce the above copyright notice and the following
terms of use in the Software and in the documentation and/or other materials
provided with the distribution.
* Neither the name of Intel nor the names of its suppliers may be used to
endorse or promote products derived from this Software without specific
prior written permission.
* No reverse engineering, decompilation, or disassembly of this Software is
permitted.
No other licenses. Except as provided in the preceding section, Intel grants no
licenses or other rights by implication, estoppel or otherwise to, patent,
copyright, trademark, trade name, service mark or other intellectual property
licenses or rights of Intel.
Third party software. The Software may contain Third Party Software. "Third
Party Software" is open source software, third party software, or other Intel
software that may be identified in the Software itself or in the files (if any)
listed in the "third-party-software.txt" or similarly named text file included
with the Software. Third Party Software, even if included with the distribution
of the Software, may be governed by separate license terms, including without
limitation, open source software license terms, third party software license
terms, and other Intel software license terms. Those separate license terms
solely govern your use of the Third Party Software, and nothing in this license
limits any rights under, or grants rights that supersede, the terms of the
applicable license terms.
DISCLAIMER. THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT ARE
DISCLAIMED. THIS SOFTWARE IS NOT INTENDED FOR USE IN SYSTEMS OR APPLICATIONS
WHERE FAILURE OF THE SOFTWARE MAY CAUSE PERSONAL INJURY OR DEATH AND YOU AGREE
THAT YOU ARE FULLY RESPONSIBLE FOR ANY CLAIMS, COSTS, DAMAGES, EXPENSES, AND
ATTORNEYS' FEES ARISING OUT OF ANY SUCH USE, EVEN IF ANY CLAIM ALLEGES THAT
INTEL WAS NEGLIGENT REGARDING THE DESIGN OR MANUFACTURE OF THE SOFTWARE.
LIMITATION OF LIABILITY. IN NO EVENT WILL INTEL BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
No support. Intel may make changes to the Software, at any time without notice,
and is not obligated to support, update or provide training for the Software.
Termination. Your right to use the Software is terminated in the event of your
breach of this license.
Feedback. Should you provide Intel with comments, modifications, corrections,
enhancements or other input ("Feedback") related to the Software, Intel will be
free to use, disclose, reproduce, license or otherwise distribute or exploit the
Feedback in its sole discretion without any obligations or restrictions of any
kind, including without limitation, intellectual property rights or licensing
obligations.
Compliance with laws. You agree to comply with all relevant laws and regulations
governing your use, transfer, import or export (or prohibition thereof) of the
Software.
Governing law. All disputes will be governed by the laws of the United States of
America and the State of Delaware without reference to conflict of law
principles and subject to the exclusive jurisdiction of the state or federal
courts sitting in the State of Delaware, and each party agrees that it submits
to the personal jurisdiction and venue of those courts and waives any
objections. The United Nations Convention on Contracts for the International
Sale of Goods (1980) is specifically excluded and will not apply to the
Software.
```
Intel® Math Kernel Library
```
Intel End User License Agreement for Developer Tools (Version October 2021)
IMPORTANT NOTICE - PLEASE READ AND AGREE BEFORE DOWNLOADING, INSTALLING, COPYING
OR USING
This Agreement is between you, or the company or other legal entity that you
represent and warrant you have the legal authority to bind, (each, "You" or
"Your") and Intel Corporation and its subsidiaries (collectively, "Intel")
regarding Your use of the Materials. By downloading, installing, copying or
using the Materials, You agree to be bound by the terms of this Agreement. If
You do not agree to the terms of this Agreement, or do not have legal authority
or required age to agree to them, do not download, install, copy or use the
Materials.
1. LICENSE DEFINITIONS.
A. "Cloud Provider" means a third party service provider offering a cloud-based
platform, infrastructure, application or storage services, such as Microsoft
Azure or Amazon Web Services, which You may only utilize to host the
Materials subject to the restrictions set forth in Section 2.3 B.
B. "Derivative Work" means a derivative work, as defined in 17 U.S.C. 101, of
the Source Code.
C. "Executable Code" means computer programming code in binary form suitable
for machine execution by a processor without the intervening steps of
interpretation or compilation.
D. "Materials" mean the software, documentation, the software product serial
number, and other collateral, including any updates, made available to You
by Intel under this Agreement. Materials include Redistributables,
Executable Code, Source Code, Sample Source Code, and Pre-Release Materials,
but do not include Third Party Software.
E. "Pre-Release Materials" mean the Materials, or portions of the Materials,
that are identified (in the product release notes, on Intel's download
website for the Materials or elsewhere) or labeled as pre-release,
prototype, alpha or beta code and, as such, are deemed to be pre-release
code (i) which may not be fully functional or tested and may contain bugs or
errors; (ii) which Intel may substantially modify in its development of a
production version; or (iii) for which Intel makes no assurances that it
will ever develop or make a production version generally available.
Pre-Release Materials are subject to the terms of Section 3.2.
F. "Reciprocal Open Source Software" means any software that is subject to a
license which requires that (i) it must be distributed in source code form;
(ii) it must be licensed under the same open source license terms; and (iii)
its derivative works must be licensed under the same open source license
terms. Examples of this type of license are the GNU General Public License
or the Mozilla Public License.
G. "Redistributables" mean the files (if any) listed in the "redist.txt,"
"redist-rt.txt" or similarly-named text files that may be included in the
Materials. Redistributables include Sample Source Code.
H. "Sample Source Code" means those portions of the Materials that are Source
Code and are identified as sample code. Sample Source Code may not have been
tested or validated by Intel and is provided purely as a programming example.
I. "Source Code" means the software portion of the Materials provided in human
readable format.
J. "Third Party Software" mean the files (if any) listed in the
"third-party-software.txt" or other similarly-named text file that may be
included in the Materials for the applicable software. Third Party Software
is subject to the terms of Section 2.2.
K. "Your Product" means one or more applications, products or projects
developed by or for You using the Materials.
2. LICENSE GRANTS.
2.1 License to the Materials. Subject to the terms and conditions of this
Agreement, Intel grants You a non-exclusive, worldwide, non-assignable,
non-sublicensable, limited right and license under its copyrights, to:
A. reproduce internally a reasonable number of copies of the Materials for Your
personal or business use;
B. use the Materials solely for Your personal or business use to develop Your
Product, in accordance with the documentation included as part of the
Materials;
C. modify or create Derivative Works only of the Redistributables, or any
portions, that are provided to You in Source Code;
D. distribute (directly and through Your distributors, resellers, and other
channel partners, if applicable), the Redistributables, including any
modifications to or Derivative Works of the Redistributables or any portions
made pursuant to Section 2.1.C subject to the following conditions:
(1) Any distribution of the Redistributables must only be as part of Your
Product which must add significant primary functionality different than
that of the Redistributables themselves;
(2) You must only distribute the Redistributables originally provided to You
by Intel only in Executable Code subject to a license agreement that
prohibits reverse engineering, decompiling or disassembling the
Redistributables;
(3) This distribution right includes a limited right to sublicense only the
Intel copyrights in the Redistributables and only to the extent necessary
to perform, display, and distribute the Redistributables (including Your
modifications and Derivative Works of the Redistributables provided in
Source Code) solely as incorporated in Your Product; and
(4) You: (i) will be solely responsible to Your customers for any update,
support obligation or other obligation or liability which may arise from
the distribution of Your Product, (ii) will not make any statement that
Your Product is "certified" or that its performance is guaranteed by Intel
or its suppliers, (iii) will not use Intel's or its suppliers' names or
trademarks to market Your Product, (iv) will comply with any additional
restrictions which are included in the text files with the
Redistributables and in Section 3 below, (v) will indemnify, hold
harmless, and defend Intel and its suppliers from and against any claims
or lawsuits, costs, damages, and expenses, including attorney's fees, that
arise or result from (a) Your modifications or Derivative Works of the
Materials or (b) Your distribution of Your Product.
2.2 Third Party Software. Third Party Software, even if included with the
distribution of the Materials, may be governed by separate license terms,
including without limitation, third party license terms, open source
software notices and terms, and/or other Intel software license terms. These
separate license terms solely govern Your use of the Third Party Software.
2.3 Third Party Use.
A. If You are an entity, Your contractors may use the Materials under the
license specified in Section 2, provided: (i) their use of the Materials is
solely on behalf of and in support of Your business, (ii) they agree to the
terms and conditions of this Agreement, and (iii) You are solely responsible
for their use, misuse or disclosure of the Materials.
B. You may utilize a Cloud Provider to host the Materials for You, provided:
(i) the Cloud Provider may only host the Materials for Your exclusive use
and may not use the Materials for any other purpose whatsoever, including the
restriction set forth in Section 3.1(xi); (ii) the Cloud Provider's use of
the Materials must be solely on behalf of and in support of Your Product, and
(iii) You will indemnify, hold harmless, and defend Intel and its suppliers
from and against any claims or lawsuits, costs, damages, and expenses,
including attorney's fees, that arise or result from Your Cloud Provider's
use, misuse or disclosure of the Materials.
3. LICENSE CONDITIONS.
3.1 Restrictions. Except as expressly provided in this Agreement, You may NOT:
(i) use, reproduce, disclose, distribute, or publicly display the
Materials; (ii) share, publish, rent or lease the Materials to any third
party; (iii) assign this Agreement or transfer the Materials; (iv) modify,
adapt, or translate the Materials in whole or in part; (v) reverse engineer,
decompile, or disassemble the Materials, or otherwise attempt to derive the
source code for the software; (vi) work around any technical limitations in
the Materials; (vii) distribute, sublicense or transfer any Source Code,
modifications or Derivative Works of any Source Code to any third party;
(viii) remove, minimize, block or modify any notices of Intel or its
suppliers in the Materials; (ix) include the Redistributables in malicious,
deceptive, or unlawful programs or products or use the Materials in any way
that is against the law; (x) modify, create a Derivative Work, link, or
distribute the Materials so that any part of it becomes Reciprocal Open
Source Software; (xi) use the Materials directly or indirectly for SaaS
services or service bureau purposes (i.e., a service that allows use of or
access to the Materials by a third party as part of that service, such as
the salesforce.com service business model).
3.2 Pre-Release Materials. If You receive Pre-Release Materials, You may
reproduce a reasonable number of copies and use the Pre-Release Materials
for evaluation and testing purposes only. You may not (i) modify or
incorporate the Pre-Release Materials into Your Product; (ii) continue to
use the Pre-Release Materials once a commercial version is released; or
(iii) disclose to any third party any benchmarks, performance results, or
other information relating to the Pre-Release Materials. Intel may waive
these restrictions in writing at its sole discretion; however, if You decide
to use the Pre-Release Materials in Your Product (even with Intel's waiver),
You acknowledge and agree that You are fully responsible for any and all
issues that result from such use.
3.3 Safety-Critical, and Life-Saving Applications; Indemnity. The Materials may
provide information relevant to safety-critical applications
("Safety-Critical Applications") to allow compliance with functional safety
standards or requirements. You acknowledge and agree that safety is Your
responsibility. To the extent You use the Materials to create, or as part
of, products used in Safety-Critical Applications, it is Your responsibility
to design, manage, and ensure that there are system-level safeguards to
anticipate, monitor, and control system failures, and You agree that You are
solely responsible for all applicable regulatory standards and
safety-related requirements concerning Your use of the Materials in Safety
Critical Applications.
Should You use the Materials for Safety-Critical Applications or in any type
of a system or application in which the failure of the Materials could
create a situation where personal injury or death may occur (e.g., medical
systems, life-sustaining or life-saving systems) ("Life-Saving
Applications"), You agree to indemnify, defend, and hold Intel and its
representatives harmless against any claims or lawsuits, costs, damages, and
expenses, including reasonable attorney fees, arising in any way out of Your
use of the Materials in Safety-Critical Applications or Life-Saving
Applications and claims of product liability, personal injury or death
associated with those applications; even if such claims allege that Intel
was negligent or strictly liable regarding the design or manufacture of the
Materials or its failure to warn regarding the Materials.
3.4 Media Format Codecs and Digital Rights Management. You acknowledge and agree
that Your use of the Materials or distribution of the Redistributables with
Your Product as permitted by this Agreement may require You to procure
license(s) from third parties that may hold intellectual property rights
applicable to any media decoding, encoding or transcoding technology (e.g.,
the use of an audio or video codec) and/or digital rights management
capabilities of the Materials, if any. Should any such additional licenses
be required, You are solely responsible for obtaining any such licenses and
agree to obtain any such licenses at Your own expense.
4. DATA COLLECTION AND PRIVACY.
4.1 Data Collection. The Materials may generate and collect anonymous data
and/or provisioning data about the Materials and/or the development
environment and transmit the data to Intel as a one-time event during
installation. Optional data may also be collected by the Materials, however,
You will be provided notice of the request to collect optional data and no
optional data will be collected without Your consent. All data collection by
Intel is performed pursuant to relevant privacy laws, including notice and
consent requirements.
4.2 Intel's Privacy Notice. Intel is committed to respecting Your privacy. To
learn more about Intel's privacy practices, please visit
http://www.intel.com/privacy.
5. OWNERSHIP. Title to the Materials and all copies remain with Intel or its
suppliers. The Materials are protected by intellectual property rights,
including without limitation, United States copyright laws and international
treaty provisions. You will not remove any copyright or other proprietary
notices from the Materials. Except as expressly provided herein, no license
or right is granted to You directly or by implication, inducement, estoppel
or otherwise; specifically, Intel does not grant any express or implied right
to You under Intel patents, copyrights, trademarks, or trade secrets.
6. NO WARRANTY AND NO SUPPORT.
6.1 No Warranty. Disclaimer. Intel disclaims all warranties of any kind and the
terms and remedies provided in this Agreement are instead of any other
warranty or condition, express, implied or statutory, including those
regarding merchantability, fitness for any particular purpose,
non-infringement or any warranty arising out of any course of dealing, usage
of trade, proposal, specification or sample. Intel does not assume (and does
not authorize any person to assume on its behalf) any liability.
6.2 No Support; Priority Support. Intel may make changes to the Materials, or to
items referenced therein, at any time without notice, but is not obligated
to support, update or provide training for the Materials under the terms of
this Agreement. Intel offers free community and paid priority support
options. More information on these support options can be found at:
https://software.intel.com/content/www/us/en/develop/support/priority-support.html.
7. LIMITATION OF LIABILITY.
7.1 Intel will not be liable for any of the following losses or damages (whether
such losses or damages were foreseen, foreseeable, known or otherwise): (i)
loss of revenue; (ii) loss of actual or anticipated profits; (iii) loss of
the use of money; (iv) loss of anticipated savings; (v) loss of business;
(vi) loss of opportunity; (vii) loss of goodwill; (viii) loss of use of the
Materials; (ix) loss of reputation; (x) loss of, damage to, or corruption of
data; or (xi) any indirect, incidental, special or consequential loss of
damage however caused (including loss or damage of the type specified in
this Section 7).
7.2 Intel's total cumulative liability to You, including for direct damages for
claims relating to this Agreement, and whether for breach of contract,
negligence, or for any other reason, will not exceed $100.
7.3 You acknowledge that the limitations of liability provided in this Section 7
are an essential part of this Agreement. You agree that the limitations of
liability provided in this Agreement with respect to Intel will be conveyed
to and made binding upon any customer of Yours that acquires the
Redistributables.
8. USER SUBMISSIONS. Should you provide Intel with comments, modifications,
corrections, enhancements or other input ("Feedback") related to the
Materials, Intel will be free to use, disclose, reproduce, license or
otherwise distribute or exploit the Feedback in its sole discretion without
any obligations or restrictions of any kind, including without limitation,
intellectual property rights or licensing obligations. If You wish to provide
Intel with information that You intend to be treated as confidential
information, Intel requires that such confidential information be provided
pursuant to a non-disclosure agreement ("NDA"); please contact Your Intel
representative to ensure the proper NDA is in place.
9. NON-DISCLOSURE. Information provided by Intel to You may include information
marked as confidential. You must treat such information as confidential under
the terms of the applicable NDA between Intel and You. If You have not
entered into an NDA with Intel, You must not disclose, distribute or make use
of any information marked as confidential, except as expressly authorized in
writing by Intel. Intel retains all rights in and to its confidential
information specifications, designs, engineering details, discoveries,
inventions, patents, copyrights, trademarks, trade secrets, and other
proprietary rights relating to the Materials. Any breach by You of the
confidentiality obligations provided for in this Section 9 will cause
irreparable injury to Intel for which money damages may be inadequate to
compensate Intel for losses arising from such a breach. Intel may obtain
equitable relief, including injunctive relief, if You breach or threaten to
breach Your confidentiality obligations.
10. TERM AND TERMINATION. This Agreement becomes effective on the date You
accept this Agreement and will continue until terminated as provided for in
this Agreement. The term for any Pre-Release Materials terminates upon
release of a commercial version. This Agreement will terminate if You are in
breach of any of its terms and conditions. Upon termination, You will
promptly destroy the Materials and all copies. In the event of termination of
this Agreement, Your license to any Redistributables distributed by You in
accordance with the terms and conditions of this Agreement, prior to the
effective date of such termination, will survive any such termination of this
Agreement. Sections 1, 2.1.D(4)(v), 2.2, 2.3.A(iii), 2.3.B(iii), 3.3, 5, 6,
7, 8, 9, 10 (with respect to these survival provisions in the last sentence),
and 12 will survive expiration or termination of this Agreement.
11. U.S. GOVERNMENT RESTRICTED RIGHTS. The technical data and computer software
covered by this license is a "Commercial Item," as such term is defined by
the FAR 2.101 (48 C.F.R. 2.101) and is "commercial computer software" and
"commercial computer software documentation" as specified under FAR 12.212
(48 C.F.R. 12.212) or DFARS 227.7202 (48 C.F.R. 227.7202), as applicable.
This commercial computer software and related documentation is provided to
end users for use by and on behalf of the U.S. Government with only those
rights as are granted to all other end users pursuant to the terms and
conditions of this Agreement.
12. GENERAL PROVISIONS.
12.1 ENTIRE AGREEMENT. This Agreement contains the complete and exclusive
agreement and understanding between the parties concerning the subject
matter of this Agreement, and supersedes all prior and contemporaneous
proposals, agreements, understanding, negotiations, representations,
warranties, conditions, and communications, oral or written, between the
parties relating to the same subject matter. Each party acknowledges and
agrees that in entering into this Agreement it has not relied on, and will
not be entitled to rely on, any oral or written representations,
warranties, conditions, understanding, or communications between the
parties that are not expressly set forth in this Agreement. The express
provisions of this Agreement control over any course of performance, course
of dealing, or usage of the trade inconsistent with any of the provisions
of this Agreement. The provisions of this Agreement will prevail
notwithstanding any different, conflicting, or additional provisions that
may appear on any purchase order, acknowledgement, invoice, or other
writing issued by either party in connection with this Agreement. No
modification or amendment to this Agreement will be effective unless in
writing and signed by authorized representatives of each party, and must
specifically identify this Agreement by its title and version (e.g., "Intel
End User License Agreement for Developer Tools (Version October 2021)");
except that Intel may make changes to this Agreement as it distributes new
versions of the Materials. When changes are made, Intel will make a new
version of the Agreement available on its website. If You received a copy
of this Agreement translated into another language, the English language
version of this Agreement will prevail in the event of any conflict between
versions.
12.2 EXPORT. You acknowledge that the Materials and all related technical
information are subject to export controls and you agree to comply with all
laws and regulations of the United States and other applicable governments
governing export, re-export, import, transfer, distribution, and use of the
Materials. In particular, but without limitation, the Materials may not be
exported or re-exported (i) into any U.S. embargoed countries or (ii) to
any person or entity listed on a denial order published by the U.S.
government or any other applicable governments. By using the Materials, You
represent and warrant that You are not located in any such country or on
any such list. You also agree that You will not use the Materials for, or
sell or transfer them to a third party who is known or suspected to be
involved in, any purposes prohibited by the U.S. government or other
applicable governments, including, without limitation, the development,
design, manufacture, or production of nuclear, missile, chemical or
biological weapons.
12.3 GOVERNING LAW, JURISDICTION, AND VENUE. All disputes arising out of or
related to this Agreement, whether based on contract, tort, or any other
legal or equitable theory, will in all respects be governed by, and
construed and interpreted under, the laws of the United States of America
and the State of Delaware, without reference to conflict of laws
principles. The parties agree that the United Nations Convention on
Contracts for the International Sale of Goods (1980) is specifically
excluded from and will not apply to this Agreement. All disputes arising
out of or related to this Agreement, whether based on contract, tort, or
any other legal or equitable theory, will be subject to the exclusive
jurisdiction of the courts of the State of Delaware or of the Federal
courts sitting in that State. Each party submits to the personal
jurisdiction of those courts and waives all objections to that jurisdiction
and venue for those disputes.
12.4 SEVERABILITY. The parties intend that if a court holds that any provision
or part of this Agreement is invalid or unenforceable under applicable law,
the court will modify the provision to the minimum extent necessary to make
it valid and enforceable, or if it cannot be made valid and enforceable,
the parties intend that the court will sever and delete the provision or
part from this Agreement. Any change to or deletion of a provision or part
of this Agreement under this Section will not affect the validity or
enforceability of the remainder of this Agreement, which will continue in
full force and effect.
```
UCRT (Redistributable files for Windows SDK)
```
MICROSOFT SOFTWARE LICENSE TERMS
MICROSOFT WINDOWS SOFTWARE DEVELOPMENT KIT (SDK) FOR WINDOWS 10
_______________________________________________________________________________________________________
These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. Please read them. They apply
to the software named above, which includes the media on which you received it, if any. The terms also apply to any Microsoft
• APIs (i.e., APIs included with the installation of the SDK or APIs accessed by installing extension packages or service to use with the SDK),
• updates,
• supplements,
• internet-based services, and
• support services
for this software, unless other terms accompany those items. If so, those terms apply.
By using the software, you accept these terms. If you do not accept them, do not use the software.
As described below, using some features also operates as your consent to the transmission of certain standard computer information for Internet-based
services.
________________________________________________________________________________________________
If you comply with these license terms, you have the rights below.
1. INSTALLATION AND USE RIGHTS.
a. You may install and use any number of copies of the software on your devices to design, develop and test your programs that run on a Microsoft
operating system. Further, you may install, use and/or deploy via a network management system or as part of a desktop image, any number of copies of the
software on computer devices within your internal corporate network to design, develop and test your programs that run on a Microsoft operating system. Each
copy must be complete, including all copyright and trademark notices. You must require end users to agree to terms that protect the software as much as these
license terms.
b. Utilities. The software contains certain components that are identified in the Utilities List located at
http://go.microsoft.com/fwlink/?LinkId=524839. Depending on the specific edition of the software, the number of Utility files you receive with the software
may not be equal to the number of Utilities listed in the Utilities List. Except as otherwise provided on the Utilities List for specific files, you may
copy and install the Utilities you receive with the software on to other third party machines. These Utilities may only be used to debug and deploy your
programs and databases you have developed with the software. You must delete all the Utilities installed onto a third party machine within the earlier of (i)
when you have finished debugging or deploying your programs; or (ii) thirty (30) days after installation of the Utilities onto that machine. We may add
additional files to this list from time to time.
c. Build Services and Enterprise Build Servers. You may install and use any number of copies of the software onto your build machines or servers,
solely for the purpose of:
i. Compiling, building, verifying and archiving your programs;
ii. Creating and configuring build systems internal to your organization to support your internal build environment; or
iii. Enabling a service for third parties to design, develop and test programs or services that run on a Microsoft operating system.
d. Included Microsoft Programs. The software contains other Microsoft programs. The license terms with those programs apply to your use of them.
e. Third Party Notices. The software may include third party code that Microsoft, not the third party, licenses to you under this agreement. Notices,
if any, for the third party code are included for your information only. Notices, if any, for this third party code are included with the software and may be
located at http://aka.ms/thirdpartynotices.
f.
2. ADDITIONAL LICENSING REQUIREMENTS AND/OR USE RIGHTS.
a. Distributable Code. The software contains code that you are permitted to distribute in programs you develop if you comply with the terms below.
i. Right to Use and Distribute. The code and test files listed below are “Distributable Code”.
• REDIST.TXT Files. You may copy and distribute the object code form of code listed in REDIST.TXT files plus the files listed on the
REDIST.TXT list located at http://go.microsoft.com/fwlink/?LinkId=524842. Depending on the specific edition of the software, the number of REDIST files you
receive with the software may not be equal to the number of REDIST files listed in the REDIST.TXT List. We may add additional files to the list from time to
time.
• Third Party Distribution. You may permit distributors of your programs to copy and distribute the Distributable Code as part of those
programs.
ii. Distribution Requirements. For any Distributable Code you distribute, you must
• Add significant primary functionality to it in your programs;
• For any Distributable Code having a filename extension of .lib, distribute only the results of running such Distributable Code through a
linker with your program;
• Distribute Distributable Code included in a setup program only as part of that setup program without modification;
• Require distributors and external end users to agree to terms that protect it at least as much as this agreement;
• For Distributable Code from the Windows Performance Toolkit portions of the software, distribute the unmodified software package as a whole
with your programs, with the exception of the KernelTraceControl.dll and the WindowsPerformanceRecorderControl.dll which can be distributed with your
programs;
• Display your valid copyright notice on your programs; and
• Indemnify, defend, and hold harmless Microsoft from any claims, including attorneys’ fees, related to the distribution or use of your
programs.
iii. Distribution Restrictions. You may not
• Alter any copyright, trademark or patent notice in the Distributable Code;
• Use Microsoft’s trademarks in your programs’ names or in a way that suggests your programs come from or are endorsed by Microsoft;
• Distribute partial copies of the Windows Performance Toolkit portion of the software package with the exception of the
KernelTraceControl.dll and the WindowsPerformanceRecorderControl.dll which can be distributed with your programs;
• Distribute Distributable Code to run on a platform other than the Microsoft operating system platform;
• Include Distributable Code in malicious, deceptive or unlawful programs; or
• Modified or distribute the source code of any Distributable Code so that any part of it becomes subject to an Excluded License. And Excluded
License is on that requir3es, as a condition of use, modification or distribution, that
▪ The code be disclosed or distributed in source code form; or
▪ Others have the right to modify it.
b. Additional Rights and Restrictions for Features made Available with the Software.
i. Windows App Requirements. If you intend to make your program available in the Windows Store, the program must comply with the Certification
Requirements as defined and described in the App Developer Agreement, currently available at:
https://msdn.microsoft.com/en-us/library/windows/apps/hh694058.aspx.
ii. Bing Maps. The software may include features that retrieve content such as maps, images and other data through the Bing Maps (or successor
branded) application programming interface (the “Bing Maps API”) to create reports displaying data on top of maps, aerial and hybrid imagery. If these
features are included, you may use these features to create and view dynamic or static documents only in conjunction with and through methods and means of
access integrated in the software. You may not otherwise copy, store, archive, or create a database of the entity information including business names,
addresses and geocodes available through the Bing Maps API. You may not use the Bing Maps API to provide sensor based guidance/routing, nor use any Road
Traffic Data or Bird’s Eye Imager (or associated metadata) even if available through the Bing Maps API for any purpose. Your use of the Bing Maps API and
associated content is also subject to the additional terms and conditions at http://go.microsoft.com/fwlink/?LinkId=21969.
iii. Additional Mapping APIs. The software may include application programming interfaces that provide maps and other related mapping features and
services that are not provided by Bing (the “Additional Mapping APIs”). These Additional Mapping APIs are subject to additional terms and conditions and may
require payment of fees to Microsoft and/or third party providers based on the use or volume of use of such Additional Mapping APIs. These terms and
conditions will be provided when you obtain any necessary license keys to use such Additional Mapping APIs or when you review or receive documentation related
to the use of such Additional Mapping APIs.
iv. Push Notifications. The Microsoft Push Notification Service may not be used to send notifications that are mission critical or otherwise could
affect matters of life or death, including without limitation critical notifications related to a medical device or condition. MICROSOFT EXPRESSLY DISCLAIMS
ANY WARRANTIES THAT THE USE OF THE MICROSOFT PUSH NOTIFICATION SERVICE OR DELIVERY OF MICROSOFT PUSH NOTIFICATION SERVICE NOTIFICATIONS WILL BE UNINTERRUPTED,
ERROR FREE, OR OTHERWISE GUARANTEED TO OCCUR ON A REAL-TIME BASIS.
v. Speech namespace API. Using speech recognition functionality via the Speech namespace APIs in a program requires the support of a speech
recognition service. The service may require network connectivity at the time of recognition (e.g., when using a predefined grammar). In addition, the service
may also collect speech-related data in order to provide and improve the service. The speech-related data may include, for example, information related to
grammar size and string phrases in a grammar.
vi. Also, in order for a user to use speech recognition on the phone they must first accept certain terms of use. The terms of use notify the
user that data related to their use of the speech recognition service will be collected and used to provide and improve the service. If a user does not accept
the terms of use and speech recognition is attempted by the application, the operation will not work and an error will be returned to the application.
vii. PlayReady Support. The software may include the Windows Emulator, which contains Microsoft’s PlayReady content access technology. Content
owners use Microsoft PlayReady content access technology to protect their intellectual property, including copyrighted content. This software uses PlayReady
technology to access PlayReady-protected content and/or WMDRM-protected content. Microsoft may decide to revoke the software’s ability to consume
PlayReady-protected content for reasons including but not limited to (i) if a breach or potential breach of PlayReady technology occurs, (ii) proactive
robustness enhancement, and (iii) if Content owners require the revocation because the software fails to properly enforce restrictions on content usage.
Revocation should not affect unprotected content or content protected by other content access technologies. Content owners may require you to upgrade
PlayReady to access their content. If you decline an upgrade, you will not be able to access content that requires the upgrade and may not be able to install
other operating system updates or upgrades.
viii. Package Managers. The software may include package managers, like NuGet, that give you the option to download other Microsoft and third
party software packages to use with your application. Those packages are under their own licenses, and not this agreement. Microsoft does not distribute,
license or provide any warranties for any of the third party packages.
ix. Font Components. While the software is running, you may use its fonts to display and print content. You may only embed fonts in content as
permitted by the embedding restrictions in the fonts; and temporarily download them to a printer or other output device to help print content.
x. Notice about the H.264/AVD Visual Standard, and the VC-1 Video Standard. This software may include H.264/MPEG-4 AVC and/or VD-1 decoding
technology. MPEG LA, L.L.C. requires this notice:
c. THIS PRODUCT IS LICENSED UNDER THE AVC AND THE VC-1 PATENT PORTFOLIO LICENSES FOR THE PERSONAL AND NON-COMMERCIAL USE OF A CONSUMER TO (i) ENCODE
VIDEO IN COMPLIANCE WITH THE ABOVE STANDARDS (“VIDEO STANDARDS”) AND/OR (ii) DECODE AVC, AND VC-1 VIDEO THAT WAS ENCODED BY A CONSUMER ENGAGED IN A PERSONAL
AND NON-COMMERCIAL ACTIVITY AND/OR WAS OBTAINED FROM A VIDEO PROVIDER LICENSED TO PROVIDE SUCH VIDEO. NONE OF THE LICENSES EXTEND TO ANY OTHER PRODUCT
REGARDLESS OF WHETHER SUCH PRODUCT IS INCLUDED WITH THIS SOFTWARE IN A SINGLE ARTICLE. NO LICENSE IS GRANTED OR SHALL BE IMPLIED FOR ANY OTHER USE. ADDITIONAL
INFORMATION MAY BE OBTAINED FROM MPEG LA, L.L.C. SEE WWW.MPEGLA.COM.
d. For clarification purposes, this notice does not limit or inhibit the use of the software for normal business uses that are personal to that
business which do not include (i) redistribution of the software to third parties, or (ii) creation of content with the VIDEO STANDARDS compliant technologies
for distribution to third parties.
e. INTERNET-BASED SERVICES. Microsoft provides Internet-based services with the software. It may change or cancel them at any time.
f. Consent for Internet-Based Services. The software features described below and in the privacy statement at
http://go.microsoft.com/fwlink/?LinkId=521839 connect to Microsoft or service provider computer systems over the Internet. In some cases, you will not receive
a separate notice when they connect. In some cases, you may switch off these features or not use them as described in the applicable product documentation. By
using these features, you consent to the transmission of this information. Microsoft does not use the information to identify or contact you.
i. Computer Information. The following features use Internet protocols, which send to the appropriate systems computer information, such as your
Internet protocol address, the type of operating system, browser, and name and version of the software you are using, and the language code of the device
where you installed the software. Microsoft uses this information to make the Internet-based services available to you.
• Software Use and Performance. This software collects info about your hardware and how you use the software and automatically sends error
reports to Microsoft. These reports include information about problems that occur in the software. Reports might unintentionally contain personal
information. For example, a report that contains a snapshot of computer memory might include your name. Part of a document you were working on could be
included as well, but this information in reports or any info collected about hardware or your software use will not be used to identify or contact you.
• Digital Certificates. The software uses digital certificates. These digital certificates confirm the identity of Internet users sending
X.509 standard encryption information. They also can be used to digitally sign files and macros to verify the integrity and origin of the file contents. The
software retrieves certificates and updates certificate revocation lists using the Internet, when available.
• Windows Application Certification Kit. To ensure you have the latest certification tests, when launched this software periodically checks a
Windows Application Certification Kit file on download.microsft.com to see if an update is available. If an update is found, you are prompted and provided a
link to a web site where you can download the update. You may use the Windows Application Certification Kit solely to test your programs before you submit
them for a potential Microsoft Windows Certification and for inclusion on the Microsoft Windows Store. The results you receive are for informational purposes
only. Microsoft has no obligation to either (i) provide you with a Windows Certification for your programs and/or ii) include your program in the Microsoft
Windows Store.
• Microsoft Digital Rights Management for Silverlight.
• If you use Silverlight to access content that has been protected with Microsoft Digital Rights Management (DRM), in order to let you play
the content, the software may automatically
• request media usage rights from a rights server on the Internet and
• download and install available DRM Updates.
• For more information about this feature, including instructions for turning the Automatic Updates off, go to
http://go.microsoft.com/fwlink/?LinkId=147032.
1. Web Content Features. Features in the software can retrieve related content from Microsoft and provide it to you. To provide the content,
these features send to Microsoft the type of operating system, name and version of the software you are using, type of browser and language code of the device
where you installed the software. Examples of these features are clip art, templates, online training, online assistance, help and Appshelp. You may choose
not to use these web content features.
ii. Use of Information. We may use nformation collected about software use and performance to provide and improve Microsoft software and services
as further described in Microsoft’s Privacy Statement available at: https://go.microsoft.com/fwlink/?LinkID=521839. We may also share it with others, such as
hardware and software vendors. They may use the information to improve how their products run with Microsoft software.
iii. Misuse of Internet-based Services. You may not use these services in any way that could harm them or impair anyone else’s use of them. You
may not use the services to try to gain unauthorized access to any service, data, account or network by any means.
3. YOUR COMPLIANCE WITH PRIVACY AND DATA PROTECTION LAWS.
a. Personal Information Definition. "Personal Information" means any information relating to an identified or identifiable natural person; an
identifiable natural person is one who can be identified, directly or indirectly, in particular by reference to an identifier such as a name, an
identification number, location data, an online identifier or to one or more factors specific to the physical, physiological, genetic, mental, economic,
cultural or social identity of that natural person.
b. Collecting Personal Information using Packaged and Add-on APIs. If you use any API to collect personal information from the software, you must
comply with all laws and regulations applicable to your use of the data accessed through APIs including without limitation laws related to privacy, biometric
data, data protection, and confidentiality of communications. Your use of the software is conditioned upon implementing and maintaining appropriate
protections and measures for your applications and services, and that includes your responsibility to the data obtained through the use of APIs. For the data
you obtained through any APIs, you must:
i. obtain all necessary consents before collecting and using data and only use the data for the limited purposes to which the user consented,
including any consent to changes in use;
ii. In the event you’re storing data, ensure that data is kept up to date and implement corrections, restrictions to data, or the deletion of data
as updated through packaged or add-on APIs or upon user request if required by applicable law;
iii. implement proper retention and deletion policies, including deleting all data when as directed by your users or as required by applicable
law; and
iv. maintain and comply with a written statement available to your customers that describes your privacy practices regarding data and information
you collect, use and that you share with any third parties.
c. Location Framework. The software may contain a location framework component or APIs that enable support of location services in programs.
Programs that receive device location must comply with the requirements related to the Location Service APIs as described in the Microsoft Store Policies
(https://docs.microsoft.com/en-us/legal/windows/agreements/store-policies). If you choose to collect device location data outside of the control of Windows
system settings, you must obtain legally sufficient consent for your data practices, and such practices must comply with all other applicable laws and
regulations.
d. Security. If your application or service collects, stores or transmits personal information, it must do so securely, by using modern cryptography
methods.
4. BACKUP COPY. You may make one backup copy of the software. You may use it only to reinstall the software.
5. DOCUMENTATION. Any person that has valid access to your computer or internal network may copy and use the documentation for your internal, reference
purposes.
6. SCOPE OF LICENSE. The software is licensed, not sold. This agreement only gives you some rights to use the software. Microsoft reserves all other
rights. Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement. In doing
so, you must comply with any technical limitations in the software that only allow you to use it in certain ways. You may not
• Except for the Microsoft .NET Framework, you must obtain Microsoft's prior written approval to disclose to a third party the results of any benchmark
test of the software.
• work around any technical limitations in the software;
• reverse engineer, decompile or disassemble the software, except and only to the extent that applicable law expressly permits, despite this limitation;
• make more copies of the software than specified in this agreement or allowed by applicable law, despite this limitation;
• publish the software for others to copy;
• rent, lease or lend the software;
• transfer the software or this agreement to any third party; or
• use the software for commercial software hosting services.
7. EXPORT RESTRICTIONS. The software is subject to United States export laws and regulations. You must comply with all domestic and international export
laws and regulations that apply to the software. These laws include restrictions on destinations, end users and end use. For additional information, see
www.microsoft.com/exporting.
8. SUPPORT SERVICES. Because this software is “as is,” we may not provide support services for it.
9. ENTIRE AGREEMENT. This agreement, and the terms for supplements, updates, Internet-based services and support services that you use, are the entire
agreement for the software and support services.
10. INDEPENDENT PARTIES. Microsoft and you are independent contractors. Nothing in this agreement shall be construed as creating an employer-employee
relationship, processor-subprocessor relationship, a partnership, or a joint venture between the parties.
11. APPLICABLE LAW AND PLACE TO RESOLVE DISPUTES. If you acquired the software in the United States or Canada, the laws of the state or province where you
live (or, if a business, where your principal place of business is located) govern the interpretation of this agreement, claims for its breach, and all other
claims (including consumer protection, unfair competition, and tort claims), regardless of conflict of laws principles. If you acquired the software in any
other country, its laws apply. If U.S. federal jurisdiction exists, you and Microsoft consent to exclusive jurisdiction and venue in the federal court in King
County, Washington for all disputes heard in court. If not, you and Microsoft consent to exclusive jurisdiction and venue in the Superior Court of King
County, Washington for all disputes heard in court.
12. LEGAL EFFECT. This agreement describes certain legal rights. You may have other rights under the laws of your country. You may also have rights with
respect to the party from whom you acquired the software. This agreement does not change your rights under the laws of your country if the laws of your
country do not permit it to do so.
13. DISCLAIMER OF WARRANTY. The software is licensed “as-is.” You bear the risk of using it. Microsoft gives no express warranties, guarantees or
conditions. You may have additional consumer rights or statutory guarantees under your local laws which this agreement cannot change. To the extent permitted
under your local laws, Microsoft excludes the implied warranties of merchantability, fitness for a particular purpose and non-infringement.
FOR AUSTRALIA – You have statutory guarantees under the Australian Consumer Law and nothing in these terms is intended to affect those rights.
14. LIMITATION ON AND EXCLUSION OF REMEDIES AND DAMAGES. You can recover from Microsoft and its suppliers only direct damages up to U.S. $5.00. You cannot
recover any other damages, including consequential, lost profits, special, indirect or incidental damages.
This limitation applies to
• anything related to the software, services, content (including code) on third party Internet sites, or third party programs; and
• claims for breach of contract, breach of warranty, guarantee or condition, strict liability, negligence, or other tort to the extent permitted by
applicable law.
It also applies even if Microsoft knew or should have known about the possibility of the damages. The above limitation or exclusion may not apply to you
because your country may not allow the exclusion or limitation of incidental, consequential or other damages.
Please note: As this software is distributed in Quebec, Canada, some of the clauses in this agreement are provided below in French.
Remarque : Ce logiciel étant distribué au Québec, Canada, certaines des clauses dans ce contrat sont fournies ci-dessous en français.
EXONÉRATION DE GARANTIE. Le logiciel visé par une licence est offert « tel quel ». Toute utilisation de ce logiciel est à votre seule risque et péril.
Microsoft n’accorde aucune autre garantie expresse. Vous pouvez bénéficier de droits additionnels en vertu du droit local sur la protection des consommateurs,
que ce contrat ne peut modifier. La ou elles sont permises par le droit locale, les garanties implicites de qualité marchande, d’adéquation à un usage
particulier et d’absence de contrefaçon sont exclues.
LIMITATION DES DOMMAGES-INTÉRÊTS ET EXCLUSION DE RESPONSABILITÉ POUR LES DOMMAGES. Vous pouvez obtenir de Microsoft et de ses fournisseurs une indemnisation
en cas de dommages directs uniquement à hauteur de 5,00 $ US. Vous ne pouvez prétendre à aucune indemnisation pour les autres dommages, y compris les dommages
spéciaux, indirects ou accessoires et pertes de bénéfices.
Crete limitation concern:
• tout ce qui est relié au logiciel, aux services ou au contenu (y compris le code) figurant sur des sites Internet tiers ou dans des programmes tiers ;
et
• les réclamations au titre de violation de contrat ou de garantie, ou au titre de responsabilité stricte, de négligence ou d’une autre faute dans la
limite autorisée par la loi en vigueur.
Elle s’applique également, même si Microsoft connaissait ou devrait connaître l’éventualité d’un tel dommage. Si votre pays n’autorise pas l’exclusion ou la
limitation de responsabilité pour les dommages indirects, accessoires ou de quelque nature que ce soit, il se peut que la limitation ou l’exclusion ci-dessus
ne s’appliquera pas à votre égard.
EFFET JURIDIQUE. Le présent contrat décrit certains droits juridiques. Vous pourriez avoir d’autres droits prévus par les lois de votre pays. Le présent
contrat ne modifie pas les droits que vous confèrent les lois de votre pays si celles-ci ne le permettent pas.
***************
EULAID:WIN10SDK.RTM.AUG_2018_en-US
*************************************************************************
```
Microsoft Visual C++ 2019 Runtime
```
MICROSOFT SOFTWARE LICENSE TERMS
MICROSOFT VISUAL C++ 2019 RUNTIME
These license terms are an agreement between Microsoft Corporation (or
based on where you live, one of its affiliates) and you. They apply to
the software named above. The terms also apply to any Microsoft services
or updates for the software, except to the extent those have different
terms.
IF YOU COMPLY WITH THESE LICENSE TERMS, YOU HAVE THE RIGHTS BELOW.
- INSTALLATION AND USE RIGHTS.
- You may install and use any number of copies of the software.
- TERMS FOR SPECIFIC COMPONENTS.
- MICROSOFT PLATFORMS. The software may include components from
Microsoft Windows; Microsoft Windows Server; Microsoft SQL
Server; Microsoft Exchange; Microsoft Office; and Microsoft
SharePoint. These components are governed by separate agreements
and their own product support policies, as described in the
Microsoft “Licenses” folder accompanying the software, except
that, if license terms for those components are also included in
the associated installation directory, those license terms
control.
- THIRD PARTY COMPONENTS. The software may include third party
components with separate legal notices or governed by other
agreements, as may be described in the ThirdPartyNotices file(s)
accompanying the software.
- SCOPE OF LICENSE. The software is licensed, not sold. This agreement
only gives you some rights to use the software. Microsoft reserves
all other rights. Unless applicable law gives you more rights
despite this limitation, you may use the software only as expressly
permitted in this agreement. In doing so, you must comply with any
technical limitations in the software that only allow you to use it
in certain ways. You may not
- work around any technical limitations in the software;
- reverse engineer, decompile or disassemble the software, or
otherwise attempt to derive the source code for the software
except, and only to the extent required by third party licensing
terms governing the use of certain open source components that
may be included in the software;
- remove, minimize, block or modify any notices of Microsoft or
its suppliers in the software;
- use the software in any way that is against the law; or
- share, publish, rent or lease the software, or provide the
software as a stand-alone offering for others to use, or
transfer the software or this agreement to any third party.
- EXPORT RESTRICTIONS. You must comply with all domestic and
international export laws and regulations that apply to the
software, which include restrictions on destinations, end users, and
end use. For further information on export restrictions, visit
www.microsoft.com/exporting.
- SUPPORT SERVICES. Because this software is “as is,” we may not
provide support services for it.
- ENTIRE AGREEMENT. This agreement, and the terms for supplements,
updates, Internet-based services and support services that you use,
are the entire agreement for the software and support services.
- APPLICABLE LAW. If you acquired the software in the United States,
Washington law applies to interpretation of and claims for breach of
this agreement, and the laws of the state where you live apply to
all other claims. If you acquired the software in any other country,
its laws apply.
- CONSUMER RIGHTS; REGIONAL VARIATIONS. This agreement describes
certain legal rights. You may have other rights, including consumer
rights, under the laws of your state or country. Separate and apart
from your relationship with Microsoft, you may also have rights with
respect to the party from which you acquired the software. This
agreement does not change those other rights if the laws of your
state or country do not permit it to do so. For example, if you
acquired the software in one of the below regions, or mandatory
country law applies, then the following provisions apply to you:
- AUSTRALIA. You have statutory guarantees under the Australian
Consumer Law and nothing in this agreement is intended to affect
those rights.
- CANADA. If you acquired this software in Canada, you may stop
receiving updates by turning off the automatic update feature,
disconnecting your device from the Internet (if and when you
re-connect to the Internet, however, the software will resume
checking for and installing updates), or uninstalling the
software. The product documentation, if any, may also specify
how to turn off updates for your specific device or software.
- GERMANY AND AUSTRIA.
(i) WARRANTY. The properly licensed software will perform
substantially as described in any Microsoft materials that
accompany the software. However, Microsoft gives no contractual
guarantee in relation to the licensed software.
(ii) LIMITATION OF LIABILITY. In case of intentional conduct,
gross negligence, claims based on the Product Liability Act, as
well as, in case of death or personal or physical injury,
Microsoft is liable according to the statutory law.
- Subject to the foregoing clause (ii), Microsoft will only be
liable for slight negligence if Microsoft is in breach of such
material contractual obligations, the fulfillment of which
facilitate the due performance of this agreement, the breach of
which would endanger the purpose of this agreement and the
compliance with which a party may constantly trust in (so-called
"cardinal obligations"). In other cases of slight negligence,
Microsoft will not be liable for slight negligence.
- DISCLAIMER OF WARRANTY. THE SOFTWARE IS LICENSED “AS-IS.” YOU BEAR
THE RISK OF USING IT. MICROSOFT GIVES NO EXPRESS WARRANTIES,
GUARANTEES OR CONDITIONS. TO THE EXTENT PERMITTED UNDER YOUR LOCAL
LAWS, MICROSOFT EXCLUDES THE IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- LIMITATION ON AND EXCLUSION OF DAMAGES. YOU CAN RECOVER FROM
MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00.
YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, LOST
PROFITS, SPECIAL, INDIRECT OR INCIDENTAL DAMAGES.
This limitation applies to (a) anything related to the software,
services, content (including code) on third party Internet sites, or
third party applications; and (b) claims for breach of contract,
breach of warranty, guarantee or condition, strict liability,
negligence, or other tort to the extent permitted by applicable law.
It also applies even if Microsoft knew or should have known about
the possibility of the damages. The above limitation or exclusion
may not apply to you because your country may not allow the
exclusion or limitation of incidental, consequential or other
damages.
```
napari-0.5.0a1/LICENSE 0000664 0000000 0000000 00000002742 14370413656 0014233 0 ustar 00root root 0000000 0000000 BSD 3-Clause License
Copyright (c) 2018, Napari
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
napari-0.5.0a1/MANIFEST.in 0000664 0000000 0000000 00000001217 14370413656 0014760 0 ustar 00root root 0000000 0000000 include LICENSE
include *.cff
graft napari/_vendor
recursive-include napari *.pyi
recursive-include napari _tests/*.py
recursive-include napari_builtins _tests/*.py
recursive-include napari *.pyi
recursive-include napari *.png *.svg *.qss *.gif *.ico *.icns
recursive-include napari *.yaml
# explicit excludes to keep check-manifest happy and remind us that
# these things are not being included unless we ask
recursive-exclude tools *
recursive-exclude napari *.pyc
exclude napari/benchmarks/*
recursive-exclude resources *
recursive-exclude binder *
recursive-exclude examples *
exclude bundle.py
exclude dockerfile
exclude EULA.md
exclude Singularity
napari-0.5.0a1/Makefile 0000664 0000000 0000000 00000002236 14370413656 0014664 0 ustar 00root root 0000000 0000000 .PHONY: typestubs pre watch dist settings-schema
typestubs:
python -m napari.utils.stubgen
# note: much faster to run mypy as daemon,
# dmypy run -- ...
# https://mypy.readthedocs.io/en/stable/mypy_daemon.html
typecheck:
mypy napari/settings napari/types.py napari/plugins
check-manifest:
pip install -U check-manifest
check-manifest
dist: typestubs check-manifest
pip install -U build
python -m build
settings-schema:
python -m napari.settings._napari_settings
pre:
pre-commit run -a
# If the first argument is "watch"...
ifeq (watch,$(firstword $(MAKECMDGOALS)))
# use the rest as arguments for "watch"
WATCH_ARGS := $(wordlist 2,$(words $(MAKECMDGOALS)),$(MAKECMDGOALS))
# ...and turn them into do-nothing targets
$(eval $(WATCH_ARGS):;@:)
endif
# examples:
# make watch ~/Desktop/Untitled.png
# make watch -- -w animation # -- is required for passing flags to napari
watch:
@echo "running: napari $(WATCH_ARGS)"
@echo "Save any file to restart napari\nCtrl-C to stop..\n" && \
watchmedo auto-restart -R \
--ignore-patterns="*.pyc*" -D \
--signal SIGKILL \
napari -- $(WATCH_ARGS) || \
echo "please run 'pip install watchdog[watchmedo]'"
napari-0.5.0a1/README.md 0000664 0000000 0000000 00000016752 14370413656 0014513 0 ustar 00root root 0000000 0000000 # napari
### multi-dimensional image viewer for python
[](https://mybinder.org/v2/gh/napari/napari/main?urlpath=%2Fdesktop)
[](https://forum.image.sc/tag/napari)
[](https://github.com/napari/napari/raw/main/LICENSE)
[](https://cirrus-ci.com/napari/napari)
[](https://codecov.io/gh/napari/napari)
[](https://python.org)
[](https://pypi.org/project/napari)
[](https://pypistats.org/packages/napari)
[](https://en.wikipedia.org/wiki/Software_release_life_cycle#Alpha)
[](https://github.com/python/black)
[](https://zenodo.org/badge/latestdoi/144513571)
**napari** is a fast, interactive, multi-dimensional image viewer for Python. It's designed for browsing, annotating, and analyzing large multi-dimensional images. It's built on top of Qt (for the GUI), vispy (for performant GPU-based rendering), and the scientific Python stack (numpy, scipy).
We're developing **napari** in the open! But the project is in an **alpha** stage, and there will still likely be **breaking changes** with each release. You can follow progress on [this repository](https://github.com/napari/napari), test out new versions as we release them, and contribute ideas and code.
We're working on [tutorials](https://napari.org/tutorials/), but you can also quickly get started by looking below.
## installation
It is recommended to install napari into a virtual environment, like this:
```sh
conda create -y -n napari-env -c conda-forge python=3.9
conda activate napari-env
python -m pip install "napari[all]"
```
If you prefer conda over pip, you can replace the last line with: `conda install -c conda-forge napari`
See here for the full [installation guide](https://napari.org/tutorials/fundamentals/installation.html), including how to [install napari as a bundled app](https://napari.org/tutorials/fundamentals/installation.html#install-as-a-bundled-app).
## simple example
(The examples below require the `scikit-image` package to run. We just use data samples from this package for demonstration purposes. If you change the examples to use your own dataset, you may not need to install this package.)
From inside an IPython shell, you can open up an interactive viewer by calling
```python
from skimage import data
import napari
viewer = napari.view_image(data.cells3d(), channel_axis=1, ndisplay=3)
```
To use napari from inside a script, use `napari.run()`:
```python
from skimage import data
import napari
viewer = napari.view_image(data.cells3d(), channel_axis=1, ndisplay=3)
napari.run() # start the "event loop" and show the viewer
```
## features
Check out the scripts in our [`examples` folder](examples) to see some of the functionality we're developing!
**napari** supports six main different layer types, `Image`, `Labels`, `Points`, `Vectors`, `Shapes`, and `Surface`, each corresponding to a different data type, visualization, and interactivity. You can add multiple layers of different types into the viewer and then start working with them, adjusting their properties.
All our layer types support n-dimensional data and the viewer provides the ability to quickly browse and visualize either 2D or 3D slices of the data.
**napari** also supports bidirectional communication between the viewer and the Python kernel, which is especially useful when launching from jupyter notebooks or when using our built-in console. Using the console allows you to interactively load and save data from the viewer and control all the features of the viewer programmatically.
You can extend **napari** using custom shortcuts, key bindings, and mouse functions.
## tutorials
For more details on how to use `napari` checkout our [tutorials](https://napari.org/tutorials/). These are still a work in progress, but we'll be updating them regularly.
## mission, values, and roadmap
For more information about our plans for `napari` you can read our [mission and values statement](https://napari.org/community/mission_and_values.html), which includes more details on our vision for supporting a plugin ecosystem around napari.
You can see details of [the project roadmap here](https://napari.org/roadmaps/index.html).
## contributing
Contributions are encouraged! Please read our [contributing guide](https://napari.org/developers/contributing.html) to get started. Given that we're in an early stage, you may want to reach out on our [Github Issues](https://github.com/napari/napari/issues) before jumping in.
## code of conduct
`napari` has a [Code of Conduct](https://napari.org/community/code_of_conduct.html) that should be honored by everyone who participates in the `napari` community.
## governance
You can learn more about how the `napari` project is organized and managed from our [governance model](https://napari.org/community/governance.html), which includes information about, and ways to contact the [@napari/steering-council and @napari/core-devs](https://napari.org/community/team.html#current-core-developers).
## citing napari
If you find `napari` useful please cite [this repository](https://github.com/napari/napari) using its DOI as follows:
> napari contributors (2019). napari: a multi-dimensional image viewer for python. [doi:10.5281/zenodo.3555620](https://zenodo.org/record/3555620)
Note this DOI will resolve to all versions of napari. To cite a specific version please find the
DOI of that version on our [zenodo page](https://zenodo.org/record/3555620). The DOI of the latest version is in the badge at the top of this page.
## help
We're a community partner on the [image.sc forum](https://forum.image.sc/tags/napari) and all help and support requests should be posted on the forum with the tag `napari`. We look forward to interacting with you there.
Bug reports should be made on our [github issues](https://github.com/napari/napari/issues/new?template=bug_report.md) using
the bug report template. If you think something isn't working, don't hesitate to reach out - it is probably us and not you!
## institutional and funding partners
napari-0.5.0a1/Singularity 0000664 0000000 0000000 00000000137 14370413656 0015457 0 ustar 00root root 0000000 0000000 BootStrap: docker
From: ghcr.io/napari/napari:main
%post
date +"%Y-%m-%d-%H%M" > /last_update
napari-0.5.0a1/asv.conf.json 0000664 0000000 0000000 00000003644 14370413656 0015640 0 ustar 00root root 0000000 0000000 {
// The version of the config file format. Do not change, unless
// you know what you are doing.
"version": 1,
// The name of the project being benchmarked
"project": "napari",
// The project's homepage
"project_url": "http://napari.org/",
// The URL or local path of the source code repository for the
// project being benchmarked
"repo": ".",
// Install using default qt install
"build_command": ["python -V"], // skip build stage
"install_command": ["in-dir={env_dir} python -m pip install {build_dir}[all,testing]"],
"uninstall_command": ["in-dir={env_dir} python -m pip uninstall -y {project}"],
// List of branches to benchmark
"branches": ["main"],
// The tool to use to create environments.
"environment_type": "virtualenv",
// timeout in seconds for installing any dependencies in environment
"install_timeout": 600,
// the base URL to show a commit for the project.
"show_commit_url": "http://github.com/napari/napari/commit/",
// The Pythons you'd like to test against.
"pythons": ["3.9"],
// The directory (relative to the current directory) to cache the Python
// environments in.
"env_dir": ".asv/env",
// The directory (relative to the current directory) that raw benchmark
// results are stored in.
"results_dir": ".asv/results",
// The directory (relative to the current directory) that the html tree
// should be written to.
"html_dir": ".asv/html",
// The directory (relative to the current directory) where the benchamrks
// are stored
"benchmark_dir": "napari/benchmarks",
// The number of characters to retain in the commit hashes.
"hash_length": 8,
// `asv` will cache results of the recent builds in each
// environment, making them faster to install next time. This is
// the number of builds to keep, per environment.
"build_cache_size": 2,
}
napari-0.5.0a1/binder/ 0000775 0000000 0000000 00000000000 14370413656 0014464 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/binder/Desktop/ 0000775 0000000 0000000 00000000000 14370413656 0016075 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/binder/Desktop/napari.desktop 0000775 0000000 0000000 00000000221 14370413656 0020740 0 ustar 00root root 0000000 0000000 [Desktop Entry]
Version=1.0
Type=Application
Name=napari 0.4.x
Exec=napari
Icon=/home/jovyan/napari/resources/icon.ico
Path=/home/jovyan/Desktop
napari-0.5.0a1/binder/apt.txt 0000664 0000000 0000000 00000000227 14370413656 0016012 0 ustar 00root root 0000000 0000000 dbus-x11
xfce4
xfce4-panel
xfce4-session
xfce4-settings
xorg
xubuntu-icon-theme
libxss1
libpci3
libasound2
fonts-ubuntu
qutebrowser
htop
nano
libgles2
napari-0.5.0a1/binder/environment.yml 0000664 0000000 0000000 00000001673 14370413656 0017562 0 ustar 00root root 0000000 0000000 channels:
- conda-forge # Used by jupyter-desktop-server
dependencies:
# See: https://github.com/conda-forge/napari-feedstock/blob/master/recipe/meta.yaml
- python >=3.8
# dependencies matched to pip
- appdirs >=1.4.4
- cachey >=0.2.1
- certifi >=2020.6.20
- dask >=2.1.0
- imageio >=2.5.0
- importlib-metadata >=1.5.0 # not needed for py>37 but keeping for noarch
- jsonschema >=3.2.0
- magicgui >=0.2.6
- napari-console >=0.0.4
- napari-plugin-engine >=0.1.9
- napari-svg >=0.1.4
- numpy >=1.18.5
- numpydoc >=0.9.2
- pillow
- pint >=0.17
- psutil >=5.0
- pyopengl >=3.1.0
- pyyaml >=5.1
- pydantic >=1.8.1
- qtpy >=1.7.0
- scipy >=1.2.0
- superqt >=0.2.2
- tifffile >=2020.2.16
- typing_extensions
- toolz >=0.10.0
- tqdm >=4.56.0
- vispy >=0.6.4
- wrapt >=1.11.1
# additional dependencies for convenience in conda-forge
- fsspec
- pyqt
- scikit-image
- zarr
# Required for desktop view on mybinder.org
- websockify
- pip:
- jupyter-desktop-server
napari-0.5.0a1/binder/postBuild 0000775 0000000 0000000 00000000541 14370413656 0016357 0 ustar 00root root 0000000 0000000 #!/bin/bash
set -euo pipefail
cp -r binder/Desktop ${HOME}/Desktop
# Apply our Xfce settings
mkdir -p ${HOME}/.config/xfce4/xfconf/xfce-perchannel-xml
cp binder/xsettings.xml ${HOME}/.config/xfce4/xfconf/xfce-perchannel-xml/
cp binder/xfce4-panel.xml ${HOME}/.config/xfce4/xfconf/xfce-perchannel-xml/
# Install napari
pip install ${HOME}/ --no-deps
napari-0.5.0a1/binder/xfce4-panel.xml 0000664 0000000 0000000 00000002724 14370413656 0017321 0 ustar 00root root 0000000 0000000
napari-0.5.0a1/binder/xsettings.xml 0000664 0000000 0000000 00000003322 14370413656 0017236 0 ustar 00root root 0000000 0000000
napari-0.5.0a1/bundle.py 0000664 0000000 0000000 00000022324 14370413656 0015047 0 ustar 00root root 0000000 0000000 import configparser
import os
import platform
import re
import shutil
import subprocess
import sys
import time
from contextlib import contextmanager
from pathlib import Path
import tomlkit
APP = 'napari'
# EXTRA_REQS will be added to the bundle, in addition to those specified in
# setup.cfg. To add additional packages to the bundle, or to override any of
# the packages listed here or in `setup.cfg, use the `--add` command line
# argument with a series of "pip install" style strings when running this file.
# For example, the following will ADD ome-zarr, and CHANGE the version of
# PySide2:
# python bundle.py --add 'PySide2==5.15.0' 'ome-zarr'
# This is now defined in setup.cfg "options.extras_require.bundle_run"
# EXTRA_REQS = []
WINDOWS = os.name == 'nt'
MACOS = sys.platform == 'darwin'
LINUX = sys.platform.startswith("linux")
HERE = os.path.abspath(os.path.dirname(__file__))
PYPROJECT_TOML = os.path.join(HERE, 'pyproject.toml')
SETUP_CFG = os.path.join(HERE, 'setup.cfg')
ARCH = (platform.machine() or "generic").lower().replace("amd64", "x86_64")
if WINDOWS:
BUILD_DIR = os.path.join(HERE, 'windows')
APP_DIR = os.path.join(BUILD_DIR, APP, 'src')
EXT, OS = 'msi', 'Windows'
elif LINUX:
BUILD_DIR = os.path.join(HERE, 'linux')
APP_DIR = os.path.join(BUILD_DIR, APP, f'{APP}.AppDir')
EXT, OS = 'AppImage', 'Linux'
elif MACOS:
BUILD_DIR = os.path.join(HERE, 'macOS')
APP_DIR = os.path.join(BUILD_DIR, APP, f'{APP}.app')
EXT, OS = 'dmg', 'macOS'
with open(os.path.join(HERE, "napari", "_version.py")) as f:
match = re.search(r'version\s?=\s?\'([^\']+)', f.read())
if match:
VERSION = match.groups()[0].split('+')[0]
@contextmanager
def patched_toml():
parser = configparser.ConfigParser()
parser.read(SETUP_CFG)
requirements = parser.get("options", "install_requires").splitlines()
requirements = [r.split('#')[0].strip() for r in requirements if r]
with open(PYPROJECT_TOML) as f:
original_toml = f.read()
toml = tomlkit.parse(original_toml)
# Initialize EXTRA_REQS from setup.cfg 'options.extras_require.bundle_run'
bundle_run = parser.get("options.extras_require", "bundle_run")
EXTRA_REQS = [
requirement.split('#')[0].strip()
for requirement in bundle_run.splitlines()
if requirement
]
# parse command line arguments
if '--add' in sys.argv:
for item in sys.argv[sys.argv.index('--add') + 1 :]:
if item.startswith('-'):
break
EXTRA_REQS.append(item)
for item in EXTRA_REQS:
_base = re.split('<|>|=', item, maxsplit=1)[0]
for r in requirements:
if r.startswith(_base):
requirements.remove(r)
break
if _base.lower().startswith('pyqt5'):
try:
i = next(x for x in requirements if x.startswith('PySide'))
requirements.remove(i)
except StopIteration:
pass
requirements += EXTRA_REQS
toml['tool']['briefcase']['app'][APP]['requires'] = requirements
toml['tool']['briefcase']['version'] = VERSION
print("patching pyproject.toml to version: ", VERSION)
print(
"patching pyproject.toml requirements to:",
*toml['tool']['briefcase']['app'][APP]['requires'],
sep="\n ",
)
if MACOS:
# Workaround https://github.com/napari/napari/issues/2965
# Pin revisions to releases _before_ they switched to static libs
revision = {
(3, 6): '11',
(3, 7): '5',
(3, 8): '4',
(3, 9): '1',
}[sys.version_info[:2]]
app_table = toml['tool']['briefcase']['app'][APP]
app_table.add('macOS', tomlkit.table())
app_table['macOS']['support_revision'] = revision
print(
"patching pyproject.toml to pin support package to revision:",
revision,
)
with open(PYPROJECT_TOML, 'w') as f:
f.write(tomlkit.dumps(toml))
try:
yield
finally:
with open(PYPROJECT_TOML, 'w') as f:
f.write(original_toml)
@contextmanager
def patched_dmgbuild():
if not MACOS:
yield
else:
from dmgbuild import core
with open(core.__file__) as f:
src = f.read()
with open(core.__file__, 'w') as f:
f.write(
src.replace(
"shutil.rmtree(os.path.join(mount_point, '.Trashes'), True)",
"shutil.rmtree(os.path.join(mount_point, '.Trashes'), True);time.sleep(30)",
)
)
print("patched dmgbuild.core")
try:
yield
finally:
# undo
with open(core.__file__, 'w') as f:
f.write(src)
def add_site_packages_to_path():
# on mac, make sure the site-packages folder exists even before the user
# has pip installed, so it is in sys.path on the first run
# (otherwise, newly installed plugins will not be detected until restart)
if MACOS:
pkgs_dir = os.path.join(
APP_DIR,
'Contents',
'Resources',
'Support',
'lib',
f'python{sys.version_info.major}.{sys.version_info.minor}',
'site-packages',
)
os.makedirs(pkgs_dir)
print("created site-packages at", pkgs_dir)
# on windows, briefcase uses a _pth file to determine the sys.path at
# runtime. https://docs.python.org/3/using/windows.html#finding-modules
# We update that file with the eventual location of pip site-packages
elif WINDOWS:
py = "".join(map(str, sys.version_info[:2]))
python_dir = os.path.join(BUILD_DIR, APP, 'src', 'python')
pth = os.path.join(python_dir, f'python{py}._pth')
with open(pth, "a") as f:
# Append 'hello' at the end of file
f.write(".\\\\Lib\\\\site-packages\n")
print("added bundled site-packages to", pth)
pkgs_dir = os.path.join(python_dir, 'Lib', 'site-packages')
os.makedirs(pkgs_dir)
print("created site-packages at", pkgs_dir)
with open(os.path.join(pkgs_dir, 'readme.txt'), 'w') as f:
f.write("this is where plugin packages will go")
def patch_wxs():
# must run after briefcase create
fname = os.path.join(BUILD_DIR, APP, f'{APP}.wxs')
if os.path.exists(fname):
with open(fname) as f:
source = f.read()
with open(fname, 'w') as f:
f.write(source.replace('pythonw.exe', 'python.exe'))
print("patched pythonw.exe -> python.exe")
def patch_python_lib_location():
# must run after briefcase create
support = os.path.join(
BUILD_DIR, APP, APP + ".app", "Contents", "Resources", "Support"
)
python_resources = os.path.join(support, "Python", "Resources")
if os.path.exists(python_resources):
return
os.makedirs(python_resources, exist_ok=True)
for subdir in ("bin", "lib"):
orig = os.path.join(support, subdir)
dest = os.path.join(python_resources, subdir)
os.symlink("../../" + subdir, dest)
print("symlinking", orig, "to", dest)
def add_sentinel_file():
if MACOS:
(Path(APP_DIR) / "Contents" / "MacOS" / ".napari_is_bundled").touch()
elif LINUX:
(Path(APP_DIR) / "usr" / "bin" / ".napari_is_bundled").touch()
elif WINDOWS:
(Path(APP_DIR) / "python" / ".napari_is_bundled").touch()
else:
print("!!! Sentinel files not yet implemented in", sys.platform)
def patch_environment_variables():
os.environ["ARCH"] = ARCH
def make_zip():
import glob
import zipfile
artifact = glob.glob(os.path.join(BUILD_DIR, f"*.{EXT}"))[0]
dest = f'napari-{VERSION}-{OS}-{ARCH}.zip'
with zipfile.ZipFile(dest, 'w', zipfile.ZIP_DEFLATED) as zf:
zf.write(artifact, arcname=os.path.basename(artifact))
print("created zipfile: ", dest)
return dest
def clean():
shutil.rmtree(BUILD_DIR, ignore_errors=True)
def bundle():
clean()
if LINUX:
patch_environment_variables()
# smoke test, and build resources
subprocess.check_call([sys.executable, '-m', APP, '--info'])
# the briefcase calls need to happen while the pyproject toml is patched
with patched_toml(), patched_dmgbuild():
# create
cmd = ['briefcase', 'create', '-v'] + (
['--no-docker'] if LINUX else []
)
subprocess.check_call(cmd)
time.sleep(0.5)
add_site_packages_to_path()
add_sentinel_file()
if WINDOWS:
patch_wxs()
elif MACOS:
patch_python_lib_location()
# build
cmd = ['briefcase', 'build', '-v'] + (['--no-docker'] if LINUX else [])
subprocess.check_call(cmd)
# package
cmd = ['briefcase', 'package', '-v']
cmd += ['--no-sign'] if MACOS else (['--no-docker'] if LINUX else [])
subprocess.check_call(cmd)
# compress
dest = make_zip()
clean()
return dest
if __name__ == "__main__":
if '--clean' in sys.argv:
clean()
sys.exit()
if '--version' in sys.argv:
print(VERSION)
sys.exit()
if '--arch' in sys.argv:
print(ARCH)
sys.exit()
print('created', bundle())
napari-0.5.0a1/codecov.yml 0000664 0000000 0000000 00000001620 14370413656 0015365 0 ustar 00root root 0000000 0000000 ignore:
- napari/_version.py
- napari/resources
- napari/benchmarks
coverage:
status:
project:
default: false
library:
target: auto
paths: ['!.*/_tests/.*']
threshold: 1%
qt:
target: auto
paths: ['napari/_qt/.*', '!.*/_tests/.*']
threshold: 1%
layers:
target: auto
paths: [ 'napari/layers/.*', '!.*/_tests/.*' ]
threshold: 1%
utils:
target: auto
paths: [ 'napari/utils/.*', '!.*/_tests/.*' ]
threshold: 2%
tests:
target: auto
paths: ['.*/_tests/.*']
threshold: 1% # coverage can drop by up to 1% while still posting success
patch:
default:
threshold: 1%
target: 0%
codecov:
notify:
after_n_builds: 11
comment:
require_changes: true # if true: only post the PR comment if coverage changes
after_n_builds: 11 napari-0.5.0a1/dockerfile 0000664 0000000 0000000 00000004444 14370413656 0015261 0 ustar 00root root 0000000 0000000 FROM --platform=linux/amd64 ubuntu:22.04 AS napari
# if you change the Ubuntu version, remember to update
# the APT definitions for Xpra below so it reflects the
# new codename (e.g. 20.04 was focal, 22.04 had jammy)
# below env var required to install libglib2.0-0 non-interactively
ENV TZ=America/Los_Angeles
ARG DEBIAN_FRONTEND=noninteractive
# install python resources + graphical libraries used by qt and vispy
RUN apt-get update && \
apt-get install -qqy \
build-essential \
python3.9 \
python3-pip \
git \
mesa-utils \
libgl1-mesa-glx \
libglib2.0-0 \
libfontconfig1 \
libxrender1 \
libdbus-1-3 \
libxkbcommon-x11-0 \
libxi6 \
libxcb-icccm4 \
libxcb-image0 \
libxcb-keysyms1 \
libxcb-randr0 \
libxcb-render-util0 \
libxcb-xinerama0 \
libxcb-xinput0 \
libxcb-xfixes0 \
libxcb-shape0 \
&& apt-get clean
# install napari release version
RUN pip3 install napari[all]
# copy examples
COPY examples /tmp/examples
ENTRYPOINT ["python3", "-m", "napari"]
#########################################################
# Extend napari with a preconfigured Xpra server target #
#########################################################
FROM napari AS napari-xpra
# Install Xpra and dependencies
RUN apt-get install -y wget gnupg2 apt-transport-https && \
wget -O - https://xpra.org/gpg.asc | apt-key add - && \
echo "deb https://xpra.org/ jammy main" > /etc/apt/sources.list.d/xpra.list
RUN apt-get update && \
apt-get install -yqq \
xpra \
xvfb \
xterm \
sshfs && \
apt-get clean && \
rm -rf /var/lib/apt/lists/*
ENV DISPLAY=:100
ENV XPRA_PORT=9876
ENV XPRA_START="python3 -m napari"
ENV XPRA_EXIT_WITH_CLIENT="yes"
ENV XPRA_XVFB_SCREEN="1920x1080x24+32"
EXPOSE 9876
CMD echo "Launching napari on Xpra. Connect via http://localhost:$XPRA_PORT"; \
xpra start \
--bind-tcp=0.0.0.0:$XPRA_PORT \
--html=on \
--start="$XPRA_START" \
--exit-with-client="$XPRA_EXIT_WITH_CLIENT" \
--daemon=no \
--xvfb="/usr/bin/Xvfb +extension Composite -screen 0 $XPRA_XVFB_SCREEN -nolisten tcp -noreset" \
--pulseaudio=no \
--notifications=no \
--bell=no \
$DISPLAY
ENTRYPOINT []
napari-0.5.0a1/examples/ 0000775 0000000 0000000 00000000000 14370413656 0015037 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/examples/3D_paths.py 0000664 0000000 0000000 00000001725 14370413656 0017063 0 ustar 00root root 0000000 0000000 """
3D Paths
========
Display two vectors layers ontop of a 4-D image layer. One of the vectors
layers is 3D and "sliced" with a different set of vectors appearing on
different 3D slices. Another is 2D and "broadcast" with the same vectors
appearing on each slice.
.. tags:: visualization-advanced, layers
"""
import numpy as np
from skimage import data
import napari
blobs = data.binary_blobs(
length=128, blob_size_fraction=0.05, n_dim=3, volume_fraction=0.05
)
viewer = napari.Viewer(ndisplay=3)
viewer.add_image(blobs.astype(float))
# sample vector coord-like data
path = np.array([np.array([[0, 0, 0], [0, 10, 10], [0, 5, 15], [20, 5, 15],
[56, 70, 21], [127, 127, 127]]),
np.array([[0, 0, 0], [0, 10, 10], [0, 5, 15], [0, 5, 15],
[0, 70, 21], [0, 127, 127]])])
print('Path', path.shape)
layer = viewer.add_shapes(
path, shape_type='path', edge_width=4, edge_color=['red', 'blue']
)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/3Dimage_plane_rendering.py 0000664 0000000 0000000 00000002653 14370413656 0022104 0 ustar 00root root 0000000 0000000 """
3D image plane rendering
========================
Display one 3D image layer and display it as a plane
with a simple widget for modifying plane parameters.
.. tags:: visualization-advanced, gui, layers
"""
import numpy as np
from skimage import data
import napari
from napari.utils.translations import trans
viewer = napari.Viewer(ndisplay=3)
# add a 3D image
blobs = data.binary_blobs(
length=64, volume_fraction=0.1, n_dim=3
).astype(np.float32)
image_layer = viewer.add_image(
blobs, rendering='mip', name='volume', blending='additive', opacity=0.25
)
# add the same 3D image and render as plane
# plane should be in 'additive' blending mode or depth looks all wrong
plane_parameters = {
'position': (32, 32, 32),
'normal': (0, 1, 0),
'thickness': 10,
}
plane_layer = viewer.add_image(
blobs,
rendering='average',
name='plane',
depiction='plane',
blending='additive',
opacity=0.5,
plane=plane_parameters
)
viewer.axes.visible = True
viewer.camera.angles = (45, 45, 45)
viewer.camera.zoom = 5
viewer.text_overlay.text = trans._(
"""
shift + click and drag to move the plane
press 'x', 'y' or 'z' to orient the plane along that axis around the cursor
press 'o' to orient the plane normal along the camera view direction
press and hold 'o' then click and drag to make the plane normal follow the camera
"""
)
viewer.text_overlay.visible = True
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/3d_kymograph_.py 0000664 0000000 0000000 00000012060 14370413656 0020136 0 ustar 00root root 0000000 0000000 """
3D Kymographs
=============
This example demonstrates that the volume rendering capabilities of napari
can also be used to render 2d timelapse acquisitions as kymographs.
.. tags:: experimental
"""
from itertools import product
import numpy as np
from tqdm import tqdm
import napari
try:
from omero.gateway import BlitzGateway
except ModuleNotFoundError:
print("Could not import BlitzGateway which is")
print("required to download the sample datasets.")
print("Please install omero-py:")
print("https://pypi.org/project/omero-py/")
exit(-1)
def IDR_fetch_image(image_id: int, progressbar: bool = True) -> np.ndarray:
"""
Download the image with id image_id from the IDR
Will fetch all image planes corresponding to separate
timepoints/channels/z-slices and return a numpy
array with dimension order (t,z,y,x,c)
Displaying download progress can be disabled by passing
False to progressbar.
"""
conn = BlitzGateway(
host="ws://idr.openmicroscopy.org/omero-ws",
username="public",
passwd="public",
secure=True,
)
conn.connect()
conn.c.enableKeepAlive(60)
idr_img = conn.getObject("Image", image_id)
idr_pixels = idr_img.getPrimaryPixels()
_ = idr_img
nt, nz, ny, nx, nc = (
_.getSizeT(),
_.getSizeZ(),
_.getSizeY(),
_.getSizeX(),
_.getSizeC(),
)
plane_indices = list(product(range(nz), range(nc), range(nt)))
idr_plane_iterator = idr_pixels.getPlanes(plane_indices)
if progressbar:
idr_plane_iterator = tqdm(idr_plane_iterator, total=len(plane_indices))
_tmp = np.asarray(list(idr_plane_iterator))
_tmp = _tmp.reshape((nz, nc, nt, ny, nx))
# the following line reorders the axes (no summing, despite the name)
return np.einsum("jmikl", _tmp)
description = """
3D-Kymographs in Napari
=======================
About
=====
This example demonstrates that the volume rendering capabilities of napari
can also be used to render 2d timelapse acquisitions as kymographs.
Kymographs, also called space-time images, are a powerful tool to visualize
the dynamics of processes.
The most common way to visualize kymographs is to pick a single line through
a 2D image and visualize the time domain along a second axes.
Napari is not limited to 2D visualization an by harnessing its volume
volume rendering capabilities, we can create a 3D kymograph,
a powerful visualization that provides an overview of the complete
spatial and temporal data from a single view.
Using napari's grid mode we can juxtapose multiple such 3D kymographs to
highlight the differences in cell dynamics under different siRNA treatments.
The selected samples are from the Mitocheck screen and demonstrate siRNA
knockdowns of several genes.
The date is timelapse fluorescence microscopy of HeLa cells, with GFP-
tagged histone revealing the chromosomes.
In the juxtaposed kymographs the reduced branching for the mitotitic
phenotypes caused by INCENP, AURKB and KIF11 knockdown compared to
TMPRSS11A knockdown is immediately obvious.
Data Source
===========
The samples to demonstrate this is downloaded from IDR:
https://idr.openmicroscopy.org/webclient/?show=screen-1302
Reference
=========
The data comes from the Mitocheck screen:
Phenotypic profiling of the human genome by time-lapse microscopy reveals cell
division genes.
Neumann B, Walter T, Hériché JK, Bulkescher J, Erfle H, Conrad C, Rogers P,
Poser I, Held M, Liebel U, Cetin C, Sieckmann F, Pau G, Kabbe R, Wünsche A,
Satagopam V, Schmitz MH, Chapuis C, Gerlich DW, Schneider R, Eils R, Huber W,
Peters JM, Hyman AA, Durbin R, Pepperkok R, Ellenberg J.
Nature. 2010 Apr 1;464(7289):721-7.
doi: 10.1038/nature08869.
Acknowledgements
================
Beate Neumann (EMBL) for helpful advice on mitotic phenotypes.
"""
print(description)
samples = (
{"IDRid": 2864587, "description": "AURKB knockdown", "vol": None},
{"IDRid": 2862565, "description": "KIF11 knockdown", "vol": None},
{"IDRid": 2867896, "description": "INCENP knockdown", "vol": None},
{"IDRid": 1486532, "description": "TMPRSS11A knockdown", "vol": None},
)
print("-------------------------------------------------------")
print("Sample datasets will require ~490 MB download from IDR.")
answer = input("Press Enter to proceed, 'n' to cancel: ")
if answer.lower().startswith('n'):
print("User cancelled download. Exiting.")
exit(0)
print("-------------------------------------------------------")
for s in samples:
print(f"Downloading sample {s['IDRid']}.")
print(f"Description: {s['description']}")
s["vol"] = np.squeeze(IDR_fetch_image(s["IDRid"]))
v = napari.Viewer(ndisplay=3)
scale = (5, 1, 1) # "stretch" time domain
for s in samples:
v.add_image(
s["vol"], name=s['description'], scale=scale, blending="opaque"
)
v.grid.enabled = True # show the volumes in grid mode
v.axes.visible = True # magenta error shows time direction
# set an oblique view angle onto the kymograph grid
v.camera.center = (440, 880, 1490)
v.camera.angles = (-20, 23, -50)
v.camera.zoom = 0.17
napari.run()
napari-0.5.0a1/examples/README.rst 0000664 0000000 0000000 00000000001 14370413656 0016515 0 ustar 00root root 0000000 0000000
napari-0.5.0a1/examples/action_manager.py 0000664 0000000 0000000 00000007147 14370413656 0020371 0 ustar 00root root 0000000 0000000 """
Action manager
==============
.. tags:: gui, experimental
"""
from random import shuffle
import numpy as np
from skimage import data
import napari
from napari._qt.widgets.qt_viewer_buttons import QtViewerPushButton
from napari.components import ViewerModel
from napari.utils.action_manager import action_manager
def rotate45(viewer: napari.Viewer):
"""
Rotate layer 0 of the viewer by 45º
Parameters
----------
viewer : napari.Viewer
active (unique) instance of the napari viewer
Notes
-----
The `viewer` parameter needs to be named `viewer`, the action manager will
infer that we need an instance of viewer.
"""
angle = np.pi / 4
from numpy import cos, sin
r = np.array([[cos(angle), -sin(angle)], [sin(angle), cos(angle)]])
layer = viewer.layers[0]
layer.rotate = layer.rotate @ r
# create the viewer with an image
viewer = napari.view_image(data.astronaut(), rgb=True)
layer_buttons = viewer.window.qt_viewer.layerButtons
# Button do not need to do anything, just need to be pretty; all the action
# binding and (un) binding will be done with the action manager, idem for
# setting the tooltip.
rot_button = QtViewerPushButton('warning')
layer_buttons.layout().insertWidget(3, rot_button)
def register_action():
# Here we pass ViewerModel as the KeymapProvider as we want it to handle the shortcuts.
# we could also pass none and bind the shortcuts at the window level – though we
# are trying to not change the KeymapProvider API too much for now.
# we give an action name to the action for configuration purposes as we need
# it to be storable in json.
# By convention (may be enforce later), we do give an action name which is iprefixed
# by the name of the package it is defined in, here napari,
action_manager.register_action(
name='napari:rotate45',
command=rotate45,
description='Rotate layer 0 by 45deg',
keymapprovider=ViewerModel,
)
def bind_shortcut():
# note that the tooltip of the corresponding button will be updated to
# remove the shortcut.
action_manager.unbind_shortcut('napari:reset_view') # Control-R
action_manager.bind_shortcut('napari:rotate45', 'Control-R')
def bind_button():
action_manager.bind_button('napari:rotate45', rot_button)
# we can all bind_shortcut or register_action or bind_button in any order;
# this let us configure shortcuts even if plugins are loaded / unloaded.
callbacks = [register_action, bind_shortcut, bind_button]
shuffle(callbacks)
for c in callbacks:
print('calling', c)
c()
# We can set the action manager in debug mode, to help us figure out which
# button is triggering which action. This will update the tooltips of the buttons
# to include the name of the action in between square brackets.
action_manager._debug(True)
# Let's also modify some existing shortcuts, by unbinding a few existing actions,
# and rebinding them with new shortcuts; below we change the add and select mode
# to be the = (same as + key on US Keyboards but without modifiers) and - keys.
# unbinding returns the old key if it exists; but we don't use it.
# in practice you likely don't need to modify the shortcuts this way as it will
# be implemented in settings, though you could imagine a plugin that would
# allow toggling between many keymaps.
settings = {
'napari:activate_points_add_mode' : '=',
'napari:activate_points_select_mode': '-',
}
for action, key in settings.items():
_old_shortcut = action_manager.unbind_shortcut(action)
action_manager.bind_shortcut(action, key)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add-points-3d.py 0000664 0000000 0000000 00000001225 14370413656 0017757 0 ustar 00root root 0000000 0000000 """
Add points 3D
=============
Display a labels layer above of an image layer using the add_labels and
add_image APIs, then add points in 3D
.. tags:: visualization-nD
"""
from scipy import ndimage as ndi
from skimage import data
import napari
blobs = data.binary_blobs(
length=128, volume_fraction=0.1, n_dim=3
)[::2].astype(float)
labeled = ndi.label(blobs)[0]
viewer = napari.Viewer(ndisplay=3)
viewer.add_image(blobs, name='blobs', scale=(2, 1, 1))
viewer.add_labels(labeled, name='blob ID', scale=(2, 1, 1))
pts = viewer.add_points()
viewer.camera.angles = (0, -65, 85)
pts.mode = 'add'
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_3D_image.py 0000664 0000000 0000000 00000000614 14370413656 0017632 0 ustar 00root root 0000000 0000000 """
Add 3D image
============
Display a 3D image layer using the :meth:`add_image` API.
.. tags:: visualization-nD, layers
"""
from skimage import data
import napari
blobs = data.binary_blobs(length=64, volume_fraction=0.1, n_dim=3).astype(
float
)
viewer = napari.Viewer(ndisplay=3)
# add the volume
viewer.add_image(blobs, scale=[3, 1, 1])
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_grayscale_image.py 0000664 0000000 0000000 00000000712 14370413656 0021335 0 ustar 00root root 0000000 0000000 """
Add grayscale image
===================
Display one grayscale image using the add_image API.
.. tags:: visualization-basic
"""
import numpy as np
from skimage import data
import napari
# simulating a grayscale image here for testing contrast limits adjustments
image = data.astronaut().mean(-1) * 100 + 100
image += np.random.rand(*image.shape) * 3000
viewer = napari.view_image(image.astype(np.uint16))
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_image.py 0000664 0000000 0000000 00000000440 14370413656 0017301 0 ustar 00root root 0000000 0000000 """
Add image
=========
Display one image using the :func:`view_image` API.
.. tags:: visualization-basic
"""
from skimage import data
import napari
# create the viewer with an image
viewer = napari.view_image(data.astronaut(), rgb=True)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_image_transformed.py 0000664 0000000 0000000 00000000556 14370413656 0021715 0 ustar 00root root 0000000 0000000 """
Add image transformed
=====================
Display one image and transform it using the :func:`view_image` API.
.. tags:: visualization-basic
"""
from skimage import data
import napari
# create the viewer with an image and transform (rotate) it
viewer = napari.view_image(data.astronaut(), rgb=True, rotate=45)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_labels.py 0000664 0000000 0000000 00000001607 14370413656 0017467 0 ustar 00root root 0000000 0000000 """
Add labels
==========
Display a labels layer above of an image layer using the ``add_labels`` and
``add_image`` APIs
.. tags:: layers, visualization-basic
"""
from skimage import data
from skimage.filters import threshold_otsu
from skimage.measure import label
from skimage.morphology import closing, remove_small_objects, square
from skimage.segmentation import clear_border
import napari
image = data.coins()[50:-50, 50:-50]
# apply threshold
thresh = threshold_otsu(image)
bw = closing(image > thresh, square(4))
# remove artifacts connected to image border
cleared = remove_small_objects(clear_border(bw), 20)
# label image regions
label_image = label(cleared)
# initialise viewer with coins image
viewer = napari.view_image(image, name='coins', rgb=False)
# add the labels
label_layer = viewer.add_labels(label_image, name='segmentation')
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_labels_with_features.py 0000664 0000000 0000000 00000002755 14370413656 0022425 0 ustar 00root root 0000000 0000000 """
Add labels with features
========================
Display a labels layer with various features
.. tags:: layers, analysis
"""
import numpy as np
from skimage import data
from skimage.filters import threshold_otsu
from skimage.measure import label
from skimage.morphology import closing, remove_small_objects, square
from skimage.segmentation import clear_border
import napari
image = data.coins()[50:-50, 50:-50]
# apply threshold
thresh = threshold_otsu(image)
bw = closing(image > thresh, square(4))
# remove artifacts connected to image border
cleared = remove_small_objects(clear_border(bw), 20)
# label image regions
label_image = label(cleared)
# initialise viewer with coins image
viewer = napari.view_image(image, name='coins', rgb=False)
# get the size of each coin (first element is background area)
label_areas = np.bincount(label_image.ravel())[1:]
# split coins into small or large
size_range = max(label_areas) - min(label_areas)
small_threshold = min(label_areas) + (size_range / 2)
coin_sizes = np.where(label_areas > small_threshold, 'large', 'small')
label_features = {
'row': ['none']
+ ['top'] * 4
+ ['bottom'] * 4, # background is row: none
'size': ['none'] + list(coin_sizes), # background is size: none
}
color = {1: 'white', 2: 'blue', 3: 'green', 4: 'red', 5: 'yellow'}
# add the labels
label_layer = viewer.add_labels(
label_image,
name='segmentation',
features=label_features,
color=color,
)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_multiscale_image.py 0000664 0000000 0000000 00000001122 14370413656 0021521 0 ustar 00root root 0000000 0000000 """
Add multiscale image
====================
Displays a multiscale image
.. tags:: visualization-advanced
"""
import numpy as np
from skimage import data
from skimage.transform import pyramid_gaussian
import napari
# create multiscale from astronaut image
base = np.tile(data.astronaut(), (8, 8, 1))
multiscale = list(
pyramid_gaussian(base, downscale=2, max_layer=4, multichannel=True)
)
print('multiscale level shapes: ', [p.shape[:2] for p in multiscale])
# add image multiscale
viewer = napari.view_image(multiscale, multiscale=True)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_points.py 0000664 0000000 0000000 00000002242 14370413656 0017535 0 ustar 00root root 0000000 0000000 """
Add points
==========
Display a points layer on top of an image layer using the ``add_points`` and
``add_image`` APIs
.. tags:: visualization-basic
"""
import numpy as np
from skimage import data
from skimage.color import rgb2gray
import napari
# add the image
viewer = napari.view_image(rgb2gray(data.astronaut()))
# add the points
points = np.array([[100, 100], [200, 200], [333, 111]])
size = np.array([10, 20, 20])
viewer.add_points(points, size=size)
# unselect the image layer
viewer.layers.selection.discard(viewer.layers[0])
# adjust some of the points layer attributes
layer = viewer.layers[1]
# change the layer name
layer.name = 'points'
# change the layer visibility
layer.visible = False
layer.visible = True
# select the layer
viewer.layers.selection.add(layer)
# deselect the layer
viewer.layers.selection.remove(layer)
# or: viewer.layers.selection.discard(layer)
# change the layer opacity
layer.opacity = 0.9
# change the layer point symbol using an alias
layer.symbol = '+'
# change the layer point out_of_slice_display status
layer.out_of_slice_display = True
# change the layer mode
layer.mode = 'add'
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_points_on_nD_shapes.py 0000664 0000000 0000000 00000003442 14370413656 0022220 0 ustar 00root root 0000000 0000000 """
Add points on nD shapes
=======================
Add points on nD shapes in 3D using a mouse callback
.. tags:: visualization-nD
"""
import numpy as np
import napari
# Create rectangles in 4D
data = [
[
[0, 50, 75, 75],
[0, 50, 125, 75],
[0, 100, 125, 125],
[0, 100, 75, 125]
],
[
[0, 10, 75, 75],
[0, 10, 125, 75],
[0, 40, 125, 125],
[0, 40, 75, 125]
],
[
[1, 100, 75, 75],
[1, 100, 125, 75],
[1, 50, 125, 125],
[1, 50, 75, 125]
]
]
shapes_data = np.array(data)
# add an empty 4d points layer
viewer = napari.view_points(ndim=4, size=3)
points_layer = viewer.layers[0]
# add the shapes layer to the viewer
features = {'index': [0, 1, 2]}
for shape_type, mult in {('ellipse', 1), ('rectangle', -1)}:
shapes_layer = viewer.add_shapes(
shapes_data * mult,
face_color=['magenta', 'green', 'blue'],
edge_color='white',
blending='additive',
features=features,
text='index',
shape_type=shape_type,
)
@shapes_layer.mouse_drag_callbacks.append
def on_click(layer, event):
shape_index, intersection_point = layer.get_index_and_intersection(
event.position, event.view_direction, event.dims_displayed
)
if (shape_index is not None) and (intersection_point is not None):
points_layer.add(intersection_point)
for d in data:
viewer.add_points(np.array(d))
# set the viewer to 3D rendering mode with the first two rectangles in view
viewer.dims.ndisplay = 3
viewer.dims.set_point(axis=0, value=0)
viewer.camera.angles = (70, 30, 150)
viewer.camera.zoom = 2.5
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_points_with_features.py 0000664 0000000 0000000 00000003665 14370413656 0022500 0 ustar 00root root 0000000 0000000 """
Add points with features
========================
Display a points layer on top of an image layer using the ``add_points`` and
``add_image`` APIs
.. tags:: visualization-basic
"""
import numpy as np
from skimage import data
from skimage.color import rgb2gray
import napari
# add the image
viewer = napari.view_image(rgb2gray(data.astronaut()))
# add the points
points = np.array([[100, 100], [200, 200], [333, 111]])
# create features for each point
features = {
'confidence': np.array([1, 0.5, 0]),
'good_point': np.array([True, False, False])
}
# define the color cycle for the face_color annotation
face_color_cycle = ['blue', 'green']
# create a points layer where the face_color is set by the good_point feature
# and the edge_color is set via a color map (grayscale) on the confidence
# feature.
points_layer = viewer.add_points(
points,
features=features,
size=20,
edge_width=7,
edge_width_is_relative=False,
edge_color='confidence',
edge_colormap='gray',
face_color='good_point',
face_color_cycle=face_color_cycle
)
# set the edge_color mode to colormap
points_layer.edge_color_mode = 'colormap'
# bind a function to toggle the good_point annotation of the selected points
@viewer.bind_key('t')
def toggle_point_annotation(viewer):
selected_points = list(points_layer.selected_data)
if len(selected_points) > 0:
good_point = points_layer.features['good_point']
good_point[selected_points] = ~good_point[selected_points]
points_layer.features['good_point'] = good_point
# we need to manually refresh since we did not use the Points.features
# setter to avoid changing the color map if all points get toggled to
# the same class, we set update_colors=False (only re-colors the point
# using the previously-determined color mapping).
points_layer.refresh_colors(update_color_mapping=False)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_points_with_multicolor_text.py 0000664 0000000 0000000 00000002546 14370413656 0024114 0 ustar 00root root 0000000 0000000 """
Add points with multicolor text
===============================
Display a points layer on top of an image layer with text using
multiple face colors mapped from features for the points and text.
.. tags:: visualization-basic
"""
import numpy as np
import napari
# add the image with three points
viewer = napari.view_image(np.zeros((400, 400)))
points = np.array([[100, 100], [200, 300], [333, 111]])
# create features for each point
features = {
'confidence': np.array([1, 0.5, 0]),
'good_point': np.array([True, False, False]),
}
# define the color cycle for the points face and text colors
color_cycle = ['blue', 'green']
text = {
'string': 'Confidence is {confidence:.2f}',
'size': 20,
'color': {'feature': 'good_point', 'colormap': color_cycle},
'translation': np.array([-30, 0]),
}
# create a points layer where the face_color is set by the good_point feature
# and the edge_color is set via a color map (grayscale) on the confidence
# feature
points_layer = viewer.add_points(
points,
features=features,
text=text,
size=20,
edge_width=7,
edge_width_is_relative=False,
edge_color='confidence',
edge_colormap='gray',
face_color='good_point',
face_color_cycle=color_cycle,
)
# set the edge_color mode to colormap
points_layer.edge_color_mode = 'colormap'
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_points_with_text.py 0000664 0000000 0000000 00000002406 14370413656 0021636 0 ustar 00root root 0000000 0000000 """
Add points with text
====================
Display a points layer on top of an image layer using the ``add_points`` and
``add_image`` APIs
.. tags:: visualization-basic
"""
import numpy as np
import napari
# add the image
viewer = napari.view_image(np.zeros((400, 400)))
# add the points
points = np.array([[100, 100], [200, 300], [333, 111]])
# create features for each point
features = {
'confidence': np.array([1, 0.5, 0]),
'good_point': np.array([True, False, False]),
}
# define the color cycle for the face_color annotation
face_color_cycle = ['blue', 'green']
text = {
'string': 'Confidence is {confidence:.2f}',
'size': 20,
'color': 'green',
'translation': np.array([-30, 0]),
}
# create a points layer where the face_color is set by the good_point feature
# and the edge_color is set via a color map (grayscale) on the confidence
# feature.
points_layer = viewer.add_points(
points,
features=features,
text=text,
size=20,
edge_width=7,
edge_width_is_relative=False,
edge_color='confidence',
edge_colormap='gray',
face_color='good_point',
face_color_cycle=face_color_cycle,
)
# set the edge_color mode to colormap
points_layer.edge_color_mode = 'colormap'
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_shapes.py 0000664 0000000 0000000 00000004254 14370413656 0017511 0 ustar 00root root 0000000 0000000 """
Add shapes
==========
Display one shapes layer ontop of one image layer using the ``add_shapes`` and
``add_image`` APIs. When the window is closed it will print the coordinates of
your shapes.
.. tags:: visualization-basic
"""
import numpy as np
from skimage import data
import napari
# add the image
viewer = napari.view_image(data.camera(), name='photographer')
# create a list of polygons
polygons = [
np.array([[11, 13], [111, 113], [22, 246]]),
np.array(
[
[505, 60],
[402, 71],
[383, 42],
[251, 95],
[212, 59],
[131, 137],
[126, 187],
[191, 204],
[171, 248],
[211, 260],
[273, 243],
[264, 225],
[430, 173],
[512, 160],
]
),
np.array(
[
[310, 382],
[229, 381],
[209, 401],
[221, 411],
[258, 411],
[300, 412],
[306, 435],
[268, 434],
[265, 454],
[298, 461],
[307, 461],
[307, 507],
[349, 510],
[352, 369],
[330, 366],
[330, 366],
]
),
]
# add polygons
layer = viewer.add_shapes(
polygons,
shape_type='polygon',
edge_width=1,
edge_color='coral',
face_color='royalblue',
name='shapes',
)
# shapes of each type can also be added via their respective add_ method
# e.g. for the polygons above:
# layer = viewer.add_shapes(name='shapes') # create empty layer
# layer.add_polygons(
# polygons,
# edge_width=1,
# edge_color='coral',
# face_color='royalblue',
# )
# change some attributes of the layer
layer.selected_data = set(range(layer.nshapes))
layer.current_edge_width = 5
layer.selected_data = set()
# add an ellipse to the layer
ellipse = np.array([[59, 222], [110, 289], [170, 243], [119, 176]])
layer.add(
ellipse,
shape_type='ellipse',
edge_width=5,
edge_color='coral',
face_color='purple',
)
# To save layers to svg:
# viewer.layers.save('viewer.svg', plugin='svg')
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_shapes_with_features.py 0000664 0000000 0000000 00000003671 14370413656 0022444 0 ustar 00root root 0000000 0000000 """
Add shapes with features
========================
Display one shapes layer ontop of one image layer using the ``add_shapes`` and
``add_image`` APIs. When the window is closed it will print the coordinates of
your shapes.
.. tags:: visualization-basic
"""
import numpy as np
from skimage import data
import napari
# add the image
viewer = napari.view_image(data.camera(), name='photographer')
# create a list of polygons
polygons = [
np.array([[11, 13], [111, 113], [22, 246]]),
np.array(
[
[505, 60],
[402, 71],
[383, 42],
[251, 95],
[212, 59],
[131, 137],
[126, 187],
[191, 204],
[171, 248],
[211, 260],
[273, 243],
[264, 225],
[430, 173],
[512, 160],
]
),
np.array(
[
[310, 382],
[229, 381],
[209, 401],
[221, 411],
[258, 411],
[300, 412],
[306, 435],
[268, 434],
[265, 454],
[298, 461],
[307, 461],
[307, 507],
[349, 510],
[352, 369],
[330, 366],
[330, 366],
]
),
]
# create features
features = {
'likelihood': [0.2, 0.5, 1],
'class': ['sky', 'person', 'building'],
}
face_color_cycle = ['blue', 'magenta', 'green']
# add polygons
layer = viewer.add_shapes(
polygons,
features=features,
shape_type='polygon',
edge_width=1,
edge_color='likelihood',
edge_colormap='gray',
face_color='class',
face_color_cycle=face_color_cycle,
name='shapes',
)
# change some attributes of the layer
layer.selected_data = set(range(layer.nshapes))
layer.current_edge_width = 5
layer.selected_data = set()
# To save layers to svg:
# viewer.layers.save('viewer.svg', plugin='svg')
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_shapes_with_text.py 0000664 0000000 0000000 00000002554 14370413656 0021611 0 ustar 00root root 0000000 0000000 """
Add shapes with text
====================
Display one shapes layer ontop of one image layer using the ``add_shapes`` and
``add_image`` APIs. When the window is closed it will print the coordinates of
your shapes.
.. tags:: visualization-basic
"""
import numpy as np
from skimage import data
import napari
# add the image
viewer = napari.view_image(data.camera(), name='photographer')
# create a list of polygons
polygons = [
np.array([[225, 146], [283, 146], [283, 211], [225, 211]]),
np.array([[67, 182], [167, 182], [167, 268], [67, 268]]),
np.array([[111, 336], [220, 336], [220, 240], [111, 240]]),
]
# create features
features = {
'likelihood': [21.23423, 51.2315, 100],
'class': ['hand', 'face', 'camera'],
}
edge_color_cycle = ['blue', 'magenta', 'green']
text = {
'string': '{class}: {likelihood:0.1f}%',
'anchor': 'upper_left',
'translation': [-5, 0],
'size': 8,
'color': 'green',
}
# add polygons
shapes_layer = viewer.add_shapes(
polygons,
features=features,
shape_type='polygon',
edge_width=3,
edge_color='class',
edge_color_cycle=edge_color_cycle,
face_color='transparent',
text=text,
name='shapes',
)
# change some attributes of the layer
shapes_layer.opacity = 1
# To save layers to svg:
# viewer.layers.save('viewer.svg', plugin='svg')
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_surface_2D.py 0000664 0000000 0000000 00000000570 14370413656 0020200 0 ustar 00root root 0000000 0000000 """
Add surface 2D
==============
Display a 2D surface
.. tags:: visualization-basic
"""
import numpy as np
import napari
data = np.array([[0, 0], [0, 20], [10, 0], [10, 10]])
faces = np.array([[0, 1, 2], [1, 2, 3]])
values = np.linspace(0, 1, len(data))
# add the surface
viewer = napari.view_surface((data, faces, values))
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_vectors.py 0000664 0000000 0000000 00000002005 14370413656 0017703 0 ustar 00root root 0000000 0000000 """
Add vectors
===========
This example generates an image of vectors
Vector data is an array of shape (N, 4)
Each vector position is defined by an (x, y, x-proj, y-proj) element where
* x and y are the center points
* x-proj and y-proj are the vector projections at each center
.. tags:: visualization-basic
"""
import numpy as np
from skimage import data
import napari
# create the viewer and window
viewer = napari.Viewer()
layer = viewer.add_image(data.camera(), name='photographer')
# sample vector coord-like data
n = 200
pos = np.zeros((n, 2, 2), dtype=np.float32)
phi_space = np.linspace(0, 4 * np.pi, n)
radius_space = np.linspace(0, 100, n)
# assign x-y position
pos[:, 0, 0] = radius_space * np.cos(phi_space) + 300
pos[:, 0, 1] = radius_space * np.sin(phi_space) + 256
# assign x-y projection
pos[:, 1, 0] = 2 * radius_space * np.cos(phi_space)
pos[:, 1, 1] = 2 * radius_space * np.sin(phi_space)
# add the vectors
layer = viewer.add_vectors(pos, edge_width=3)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_vectors_color_by_angle.py 0000664 0000000 0000000 00000002523 14370413656 0022746 0 ustar 00root root 0000000 0000000 """
Add vectors color by angle
==========================
This example generates a set of vectors in a spiral pattern.
The color of the vectors is mapped to their 'angle' feature.
.. tags:: visualization-advanced
"""
import numpy as np
from skimage import data
import napari
# create the viewer and window
viewer = napari.Viewer()
layer = viewer.add_image(data.camera(), name='photographer')
# sample vector coord-like data
n = 300
pos = np.zeros((n, 2, 2), dtype=np.float32)
phi_space = np.linspace(0, 4 * np.pi, n)
radius_space = np.linspace(0, 100, n)
# assign x-y position
pos[:, 0, 0] = radius_space * np.cos(phi_space) + 300
pos[:, 0, 1] = radius_space * np.sin(phi_space) + 256
# assign x-y projection
pos[:, 1, 0] = 2 * radius_space * np.cos(phi_space)
pos[:, 1, 1] = 2 * radius_space * np.sin(phi_space)
# make the angle feature, range 0-2pi
angle = np.mod(phi_space, 2 * np.pi)
# create a feature that is true for all angles > pi
pos_angle = angle > np.pi
# create the features dictionary.
features = {
'angle': angle,
'pos_angle': pos_angle,
}
# add the vectors
layer = viewer.add_vectors(
pos,
edge_width=3,
features=features,
edge_color='angle',
edge_colormap='husl',
name='vectors'
)
# set the edge color mode to colormap
layer.edge_color_mode = 'colormap'
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/add_vectors_image.py 0000664 0000000 0000000 00000002112 14370413656 0021044 0 ustar 00root root 0000000 0000000 """
Add vectors image
=================
This example generates an image of vectors
Vector data is an array of shape (N, M, 2)
Each vector position is defined by an (x-proj, y-proj) element where
* x-proj and y-proj are the vector projections at each center
* each vector is centered on a pixel of the NxM grid
.. tags:: visualization-basic
"""
import numpy as np
import napari
# create the viewer and window
viewer = napari.Viewer()
n = 20
m = 40
image = 0.2 * np.random.random((n, m)) + 0.5
layer = viewer.add_image(image, contrast_limits=[0, 1], name='background')
# sample vector image-like data
# n x m grid of slanted lines
# random data on the open interval (-1, 1)
pos = np.zeros(shape=(n, m, 2), dtype=np.float32)
rand1 = 2 * (np.random.random_sample(n * m) - 0.5)
rand2 = 2 * (np.random.random_sample(n * m) - 0.5)
# assign projections for each vector
pos[:, :, 0] = rand1.reshape((n, m))
pos[:, :, 1] = rand2.reshape((n, m))
# add the vectors
vect = viewer.add_vectors(pos, edge_width=0.2, length=2.5)
print(image.shape, pos.shape)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/affine_transforms.py 0000664 0000000 0000000 00000003356 14370413656 0021126 0 ustar 00root root 0000000 0000000 """
Affine transforms
=================
Display an image and its corners before and after an affine transform
.. tags:: visualization-advanced
"""
import numpy as np
import scipy.ndimage as ndi
import napari
# Create a random image
image = np.random.random((5, 5))
# Define an affine transform
affine = np.array([[1, -1, 4], [2, 3, 2], [0, 0, 1]])
# Define the corners of the image, including in homogeneous space
corners = np.array([[0, 0], [4, 0], [0, 4], [4, 4]])
corners_h = np.concatenate([corners, np.ones((4, 1))], axis=1)
viewer = napari.Viewer()
# Add the original image and its corners
viewer.add_image(image, name='background', colormap='red', opacity=.5)
viewer.add_points(corners_h[:, :-1], size=0.5, opacity=.5, face_color=[0.8, 0, 0, 0.8], name='bg corners')
# Add another copy of the image, now with a transform, and add its transformed corners
viewer.add_image(image, colormap='blue', opacity=.5, name='moving', affine=affine)
viewer.add_points((corners_h @ affine.T)[:, :-1], size=0.5, opacity=.5, face_color=[0, 0, 0.8, 0.8], name='mv corners')
# Note how the transformed corner points remain at the corners of the transformed image
# Now add the a regridded version of the image transformed with scipy.ndimage.affine_transform
# Note that we have to use the inverse of the affine as scipy does ‘pull’ (or ‘backward’) resampling,
# transforming the output space to the input to locate data, but napari does ‘push’ (or ‘forward’) direction,
# transforming input to output.
scipy_affine = ndi.affine_transform(image, np.linalg.inv(affine), output_shape=(10, 25), order=5)
viewer.add_image(scipy_affine, colormap='green', opacity=.5, name='scipy')
# Reset the view
viewer.reset_view()
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/annotate-2d.py 0000664 0000000 0000000 00000000755 14370413656 0017534 0 ustar 00root root 0000000 0000000 """
Annotate 2D
===========
Display one points layer ontop of one image layer using the ``add_points`` and
``add_image`` APIs
.. tags:: analysis
"""
import numpy as np
from skimage import data
import napari
print("click to add points; close the window when finished.")
viewer = napari.view_image(data.astronaut(), rgb=True)
points = viewer.add_points(np.zeros((0, 2)))
points.mode = 'add'
if __name__ == '__main__':
napari.run()
print("you clicked on:")
print(points.data)
napari-0.5.0a1/examples/annotate_segmentation_with_text.py 0000664 0000000 0000000 00000006355 14370413656 0024107 0 ustar 00root root 0000000 0000000 """
Annotate segmentation with text
===============================
Perform a segmentation and annotate the results with
bounding boxes and text
.. tags:: analysis
"""
import numpy as np
from skimage import data
from skimage.filters import threshold_otsu
from skimage.measure import label, regionprops_table
from skimage.morphology import closing, remove_small_objects, square
from skimage.segmentation import clear_border
import napari
def segment(image):
"""Segment an image using an intensity threshold determined via
Otsu's method.
Parameters
----------
image : np.ndarray
The image to be segmented
Returns
-------
label_image : np.ndarray
The resulting image where each detected object labeled with a unique integer.
"""
# apply threshold
thresh = threshold_otsu(image)
bw = closing(image > thresh, square(4))
# remove artifacts connected to image border
cleared = remove_small_objects(clear_border(bw), 20)
# label image regions
label_image = label(cleared)
return label_image
def make_bbox(bbox_extents):
"""Get the coordinates of the corners of a
bounding box from the extents
Parameters
----------
bbox_extents : list (4xN)
List of the extents of the bounding boxes for each of the N regions.
Should be ordered: [min_row, min_column, max_row, max_column]
Returns
-------
bbox_rect : np.ndarray
The corners of the bounding box. Can be input directly into a
napari Shapes layer.
"""
minr = bbox_extents[0]
minc = bbox_extents[1]
maxr = bbox_extents[2]
maxc = bbox_extents[3]
bbox_rect = np.array(
[[minr, minc], [maxr, minc], [maxr, maxc], [minr, maxc]]
)
bbox_rect = np.moveaxis(bbox_rect, 2, 0)
return bbox_rect
def circularity(perimeter, area):
"""Calculate the circularity of the region
Parameters
----------
perimeter : float
the perimeter of the region
area : float
the area of the region
Returns
-------
circularity : float
The circularity of the region as defined by 4*pi*area / perimeter^2
"""
circularity = 4 * np.pi * area / (perimeter ** 2)
return circularity
# load the image and segment it
image = data.coins()[50:-50, 50:-50]
label_image = segment(image)
# create the features dictionary
features = regionprops_table(
label_image, properties=('label', 'bbox', 'perimeter', 'area')
)
features['circularity'] = circularity(
features['perimeter'], features['area']
)
# create the bounding box rectangles
bbox_rects = make_bbox([features[f'bbox-{i}'] for i in range(4)])
# specify the display parameters for the text
text_parameters = {
'string': 'label: {label}\ncirc: {circularity:.2f}',
'size': 12,
'color': 'green',
'anchor': 'upper_left',
'translation': [-3, 0],
}
# initialise viewer with coins image
viewer = napari.view_image(image, name='coins', rgb=False)
# add the labels
label_layer = viewer.add_labels(label_image, name='segmentation')
shapes_layer = viewer.add_shapes(
bbox_rects,
face_color='transparent',
edge_color='green',
features=features,
text=text_parameters,
name='bounding box',
)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/bbox_annotator.py 0000664 0000000 0000000 00000007251 14370413656 0020435 0 ustar 00root root 0000000 0000000 """
bbox annotator
==============
.. tags:: gui
"""
import numpy as np
import pandas as pd
from magicgui.widgets import ComboBox, Container
from skimage import data
import napari
# set up the categorical annotation values and text display properties
box_annotations = ['person', 'sky', 'camera']
text_feature = 'box_label'
features = pd.DataFrame({
text_feature: pd.Series([], dtype=pd.CategoricalDtype(box_annotations))
})
text_color = 'green'
text_size = 20
# create the GUI for selecting the values
def create_label_menu(shapes_layer, label_feature, labels):
"""Create a label menu widget that can be added to the napari viewer dock
Parameters
----------
shapes_layer : napari.layers.Shapes
a napari shapes layer
label_feature : str
the name of the shapes feature to use the displayed text
labels : List[str]
list of the possible text labels values.
Returns
-------
label_widget : magicgui.widgets.Container
the container widget with the label combobox
"""
# Create the label selection menu
label_menu = ComboBox(label='text label', choices=labels)
label_widget = Container(widgets=[label_menu])
def update_label_menu():
"""This is a callback function that updates the label menu when
the default features of the Shapes layer change
"""
new_label = str(shapes_layer.feature_defaults[label_feature][0])
if new_label != label_menu.value:
label_menu.value = new_label
shapes_layer.events.feature_defaults.connect(update_label_menu)
def set_selected_features_to_default():
"""This is a callback that updates the feature values of the currently
selected shapes. This is a side-effect of the deprecated current_properties
setter, but does not occur when modifying feature_defaults."""
indices = list(shapes_layer.selected_data)
default_value = shapes_layer.feature_defaults[label_feature][0]
shapes_layer.features[label_feature][indices] = default_value
shapes_layer.events.features()
shapes_layer.events.feature_defaults.connect(set_selected_features_to_default)
shapes_layer.events.features.connect(shapes_layer.refresh_text)
def label_changed(value: str):
"""This is a callback that update the default features on the Shapes layer
when the label menu selection changes
"""
shapes_layer.feature_defaults[label_feature] = value
shapes_layer.events.feature_defaults()
label_menu.changed.connect(label_changed)
return label_widget
# create a stack with the camera image shifted in each slice
n_slices = 5
base_image = data.camera()
image = np.zeros((n_slices, base_image.shape[0], base_image.shape[1]), dtype=base_image.dtype)
for slice_idx in range(n_slices):
shift = 1 + 10 * slice_idx
image[slice_idx, ...] = np.pad(base_image, ((0, 0), (shift, 0)), mode='constant')[:, :-shift]
# create a viewer with a fake t+2D image
viewer = napari.view_image(image)
# create an empty shapes layer initialized with
# text set to display the box label
text_kwargs = {
'string': text_feature,
'size': text_size,
'color': text_color
}
shapes = viewer.add_shapes(
face_color='black',
features=features,
text=text_kwargs,
ndim=3
)
# create the label section gui
label_widget = create_label_menu(
shapes_layer=shapes,
label_feature=text_feature,
labels=box_annotations
)
# add the label selection gui to the viewer as a dock widget
viewer.window.add_dock_widget(label_widget, area='right', name='label_widget')
# set the shapes layer mode to adding rectangles
shapes.mode = 'add_rectangle'
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/clipboard_.py 0000664 0000000 0000000 00000002326 14370413656 0017512 0 ustar 00root root 0000000 0000000 """
Clipboard
=========
Copy screenshot of the canvas or the whole viewer to clipboard.
.. tags:: gui
"""
from qtpy.QtWidgets import QPushButton, QVBoxLayout, QWidget
from skimage import data
import napari
# create the viewer with an image
viewer = napari.view_image(data.moon())
class Grabber(QWidget):
def __init__(self) -> None:
super().__init__()
self.copy_canvas_btn = QPushButton("Copy Canvas to Clipboard", self)
self.copy_canvas_btn.setToolTip("Copy screenshot of the canvas to clipboard.")
self.copy_viewer_btn = QPushButton("Copy Viewer to Clipboard", self)
self.copy_viewer_btn.setToolTip("Copy screenshot of the entire viewer to clipboard.")
layout = QVBoxLayout(self)
layout.addWidget(self.copy_canvas_btn)
layout.addWidget(self.copy_viewer_btn)
def create_grabber_widget():
"""Create widget"""
widget = Grabber()
# connect buttons
widget.copy_canvas_btn.clicked.connect(lambda: viewer.window.qt_viewer.clipboard())
widget.copy_viewer_btn.clicked.connect(lambda: viewer.window.clipboard())
return widget
widget = create_grabber_widget()
viewer.window.add_dock_widget(widget)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/clipping_planes_interactive_.py 0000664 0000000 0000000 00000015264 14370413656 0023324 0 ustar 00root root 0000000 0000000 """
Clipping planes interactive
===========================
Display a 3D image (plus labels) with a clipping plane and interactive controls
for moving the plane
.. tags:: experimental
"""
import numpy as np
from scipy import ndimage
from skimage import data
from vispy.geometry import create_sphere
import napari
viewer = napari.Viewer(ndisplay=3)
# VOLUME and LABELS
blobs = data.binary_blobs(
length=64, volume_fraction=0.1, n_dim=3
).astype(float)
labeled = ndimage.label(blobs)[0]
plane_parameters = {
'position': (32, 32, 32),
'normal': (1, 1, 1),
'enabled': True
}
volume_layer = viewer.add_image(
blobs, rendering='mip', name='volume',
experimental_clipping_planes=[plane_parameters],
)
labels_layer = viewer.add_labels(
labeled, name='labels', blending='translucent',
experimental_clipping_planes=[plane_parameters],
)
# POINTS
points_layer = viewer.add_points(
np.random.rand(20, 3) * 64, size=5,
experimental_clipping_planes=[plane_parameters],
)
# SPHERE
mesh = create_sphere(method='ico')
sphere_vert = mesh.get_vertices() * 20
sphere_vert += 32
surface_layer = viewer.add_surface(
(sphere_vert, mesh.get_faces()),
experimental_clipping_planes=[plane_parameters],
)
# SHAPES
shapes_data = np.random.rand(3, 4, 3) * 64
shapes_layer = viewer.add_shapes(
shapes_data,
face_color=['magenta', 'green', 'blue'],
experimental_clipping_planes=[plane_parameters],
)
# VECTORS
vectors = np.zeros((20, 2, 3))
vectors[:, 0] = 32
vectors[:, 1] = (np.random.rand(20, 3) - 0.5) * 32
vectors_layer = viewer.add_vectors(
vectors,
experimental_clipping_planes=[plane_parameters],
)
def point_in_bounding_box(point, bounding_box):
if np.all(point > bounding_box[0]) and np.all(point < bounding_box[1]):
return True
return False
@viewer.mouse_drag_callbacks.append
def shift_plane_along_normal(viewer, event):
"""Shift a plane along its normal vector on mouse drag.
This callback will shift a plane along its normal vector when the plane is
clicked and dragged. The general strategy is to
1) find both the plane normal vector and the mouse drag vector in canvas
coordinates
2) calculate how far to move the plane in canvas coordinates, this is done
by projecting the mouse drag vector onto the (normalised) plane normal
vector
3) transform this drag distance (canvas coordinates) into data coordinates
4) update the plane position
It will also add a point to the points layer for a 'click-not-drag' event.
"""
# get layers from viewer
volume_layer = viewer.layers['volume']
# Calculate intersection of click with data bounding box
near_point, far_point = volume_layer.get_ray_intersections(
event.position,
event.view_direction,
event.dims_displayed,
)
# Calculate intersection of click with plane through data
intersection = volume_layer.experimental_clipping_planes[0].intersect_with_line(
line_position=near_point, line_direction=event.view_direction
)
# Check if click was on plane by checking if intersection occurs within
# data bounding box. If so, exit early.
if not point_in_bounding_box(intersection, volume_layer.extent.data):
return
# Get plane parameters in vispy coordinates (zyx -> xyz)
plane_normal_data_vispy = np.array(volume_layer.experimental_clipping_planes[0].normal)[[2, 1, 0]]
plane_position_data_vispy = np.array(volume_layer.experimental_clipping_planes[0].position)[[2, 1, 0]]
# Get transform which maps from data (vispy) to canvas
# note that we're using a private attribute here, which may not be present in future napari versions
visual2canvas = viewer.window._qt_viewer.layer_to_visual[volume_layer].node.get_transform(
map_from="visual", map_to="canvas"
)
# Find start and end positions of plane normal in canvas coordinates
plane_normal_start_canvas = visual2canvas.map(plane_position_data_vispy)
plane_normal_end_canvas = visual2canvas.map(plane_position_data_vispy + plane_normal_data_vispy)
# Calculate plane normal vector in canvas coordinates
plane_normal_canv = (plane_normal_end_canvas - plane_normal_start_canvas)[[0, 1]]
plane_normal_canv_normalised = (
plane_normal_canv / np.linalg.norm(plane_normal_canv)
)
# Disable interactivity during plane drag
volume_layer.interactive = False
labels_layer.interactive = False
labels_layer.interactive = False
points_layer.interactive = False
surface_layer.interactive = False
shapes_layer.interactive = False
vectors_layer.interactive = False
# Store original plane position and start position in canvas coordinates
original_plane_position = volume_layer.experimental_clipping_planes[0].position
start_position_canv = event.pos
yield
while event.type == "mouse_move":
# Get end position in canvas coordinates
end_position_canv = event.pos
# Calculate drag vector in canvas coordinates
drag_vector_canv = end_position_canv - start_position_canv
# Project the drag vector onto the plane normal vector
# (in canvas coorinates)
drag_projection_on_plane_normal = np.dot(
drag_vector_canv, plane_normal_canv_normalised
)
# Update position of plane according to drag vector
# only update if plane position is within data bounding box
drag_distance_data = drag_projection_on_plane_normal / np.linalg.norm(plane_normal_canv)
updated_position = original_plane_position + drag_distance_data * np.array(
volume_layer.experimental_clipping_planes[0].normal)
if point_in_bounding_box(updated_position, volume_layer.extent.data):
volume_layer.experimental_clipping_planes[0].position = updated_position
labels_layer.experimental_clipping_planes[0].position = updated_position
points_layer.experimental_clipping_planes[0].position = updated_position
surface_layer.experimental_clipping_planes[0].position = updated_position
shapes_layer.experimental_clipping_planes[0].position = updated_position
vectors_layer.experimental_clipping_planes[0].position = updated_position
yield
# Re-enable
volume_layer.interactive = True
labels_layer.interactive = True
points_layer.interactive = True
surface_layer.interactive = True
shapes_layer.interactive = True
vectors_layer.interactive = True
viewer.axes.visible = True
viewer.camera.angles = (45, 45, 45)
viewer.camera.zoom = 5
viewer.text_overlay.update(dict(
text='Drag the clipping plane surface to move it along its normal.',
font_size=20,
visible=True,
))
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/concentric-spheres.py 0000664 0000000 0000000 00000000675 14370413656 0021217 0 ustar 00root root 0000000 0000000 """
Concentric spheres
==================
Display concentric spheres in 3D.
.. tags:: visualization-nD
"""
import numpy as np
from skimage import morphology
import napari
b0 = morphology.ball(5)
b1 = morphology.ball(10)
b0p = np.pad(b0, 5)
viewer = napari.Viewer(ndisplay=3)
# viewer.add_labels(b0)
viewer.add_labels(b0p)
viewer.add_labels(b1 * 2)
viewer.add_points([[10, 10, 10]], size=1)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/cursor_position.py 0000664 0000000 0000000 00000001201 14370413656 0020644 0 ustar 00root root 0000000 0000000 """
Cursor position
===============
Add small data to examine cursor positions
.. tags:: interactivity
"""
import numpy as np
import napari
viewer = napari.Viewer()
image = np.array([[1, 0, 0, 1],
[0, 0, 1, 1],
[1, 0, 3, 0],
[0, 2, 0, 0]], dtype=int)
viewer.add_labels(image)
points = np.array([[0, 0], [2, 0], [1, 3]])
viewer.add_points(points, size=0.25)
rect = np.array([[0, 0], [3, 1]])
viewer.add_shapes(rect, shape_type='rectangle', edge_width=0.1)
vect = np.array([[[3, 2], [-1, 1]]])
viewer.add_vectors(vect, edge_width=0.1)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/cursor_ray.py 0000664 0000000 0000000 00000003324 14370413656 0017603 0 ustar 00root root 0000000 0000000 """
Cursor ray
==========
Depict a ray through a layer in 3D to demonstrate interactive 3D functionality
.. tags:: interactivity
"""
import numpy as np
import napari
sidelength_data = 64
n_points = 10
# data to depict an empty volume, its bounding box and points along a ray
# through the volume
volume = np.zeros(shape=(sidelength_data, sidelength_data, sidelength_data))
bounding_box = np.array(
[
[0, 0, 0],
[1, 0, 0],
[0, 1, 0],
[1, 1, 0],
[0, 0, 1],
[1, 0, 1],
[0, 1, 1],
[1, 1, 1],
]
) * sidelength_data
points = np.zeros(shape=(n_points, 3))
# point sizes
point_sizes = np.linspace(0.5, 2, n_points, endpoint=True)
# point colors
green = [0, 1, 0, 1]
magenta = [1, 0, 1, 1]
point_colors = np.linspace(green, magenta, n_points, endpoint=True)
# create viewer and add layers for each piece of data
viewer = napari.Viewer(ndisplay=3)
bounding_box_layer = viewer.add_points(
bounding_box, face_color='cornflowerblue', name='bounding box'
)
ray_layer = viewer.add_points(
points, face_color=point_colors, size=point_sizes, name='cursor ray'
)
volume_layer = viewer.add_image(volume, blending='additive')
# callback function, called on mouse click when volume layer is active
@volume_layer.mouse_drag_callbacks.append
def on_click(layer, event):
near_point, far_point = layer.get_ray_intersections(
event.position,
event.view_direction,
event.dims_displayed
)
if (near_point is not None) and (far_point is not None):
ray_points = np.linspace(near_point, far_point, n_points, endpoint=True)
if ray_points.shape[1] != 0:
ray_layer.data = ray_points
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/custom_key_bindings.py 0000664 0000000 0000000 00000002043 14370413656 0021447 0 ustar 00root root 0000000 0000000 """
Custom key bindings
===================
Display one 4-D image layer using the ``add_image`` API
.. tags:: gui
"""
from skimage import data
import napari
blobs = data.binary_blobs(
length=128, blob_size_fraction=0.05, n_dim=2, volume_fraction=0.25
).astype(float)
viewer = napari.view_image(blobs, name='blobs')
@viewer.bind_key('a')
def accept_image(viewer):
msg = 'this is a good image'
viewer.status = msg
print(msg)
next(viewer)
@viewer.bind_key('r')
def reject_image(viewer):
msg = 'this is a bad image'
viewer.status = msg
print(msg)
next(viewer)
def next(viewer):
blobs = data.binary_blobs(
length=128, blob_size_fraction=0.05, n_dim=2, volume_fraction=0.25
).astype(float)
viewer.layers[0].data = blobs
@napari.Viewer.bind_key('w')
def hello(viewer):
# on press
viewer.status = 'hello world!'
yield
# on release
viewer.status = 'goodbye world :('
# change viewer title
viewer.title = 'quality control images'
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/custom_mouse_functions.py 0000664 0000000 0000000 00000004275 14370413656 0022233 0 ustar 00root root 0000000 0000000 """
Custom mouse functions
======================
Display one 4-D image layer using the ``add_image`` API
.. tags:: gui
"""
import numpy as np
from scipy import ndimage as ndi
from skimage import data
from skimage.morphology import binary_dilation, binary_erosion
import napari
np.random.seed(1)
viewer = napari.Viewer()
blobs = data.binary_blobs(length=128, volume_fraction=0.1, n_dim=2)
labeled = ndi.label(blobs)[0]
labels_layer = viewer.add_labels(labeled, name='blob ID')
@viewer.mouse_drag_callbacks.append
def get_event(viewer, event):
print(event)
@viewer.mouse_drag_callbacks.append
def get_ndisplay(viewer, event):
if 'Alt' in event.modifiers:
print('viewer display ', viewer.dims.ndisplay)
@labels_layer.mouse_drag_callbacks.append
def get_connected_component_shape(layer, event):
data_coordinates = layer.world_to_data(event.position)
cords = np.round(data_coordinates).astype(int)
val = layer.get_value(data_coordinates)
if val is None:
return
if val != 0:
data = layer.data
binary = data == val
if 'Shift' in event.modifiers:
binary_new = binary_erosion(binary)
data[binary] = 0
else:
binary_new = binary_dilation(binary)
data[binary_new] = val
size = np.sum(binary_new)
layer.data = data
msg = (
f'clicked at {cords} on blob {val} which is now {size} pixels'
)
else:
msg = f'clicked at {cords} on background which is ignored'
print(msg)
# Handle click or drag events separately
@labels_layer.mouse_drag_callbacks.append
def click_drag(layer, event):
print('mouse down')
dragged = False
yield
# on move
while event.type == 'mouse_move':
print(event.position)
dragged = True
yield
# on release
if dragged:
print('drag end')
else:
print('clicked!')
# Handle click or drag events separately
@labels_layer.mouse_double_click_callbacks.append
def on_second_click_of_double_click(layer, event):
print('Second click of double_click', event.position)
print('note that a click event was also triggered', event.type)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/dask_nD_image.py 0000664 0000000 0000000 00000001233 14370413656 0020115 0 ustar 00root root 0000000 0000000 """
Dask nD image
=============
Display a dask array
.. tags:: visualization-nD
"""
try:
from dask import array as da
except ModuleNotFoundError:
raise ModuleNotFoundError(
"""This example uses a dask array but dask is not
installed. To install try 'pip install dask'."""
) from None
import numpy as np
from skimage import data
import napari
blobs = da.stack(
[
data.binary_blobs(
length=128, blob_size_fraction=0.05, n_dim=3, volume_fraction=f
)
for f in np.linspace(0.05, 0.5, 10)
],
axis=0,
)
viewer = napari.view_image(blobs.astype(float))
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/dev/ 0000775 0000000 0000000 00000000000 14370413656 0015615 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/examples/dev/demo_shape_creation.py 0000664 0000000 0000000 00000005424 14370413656 0022164 0 ustar 00root root 0000000 0000000 import argparse
from timeit import default_timer
import numpy as np
import napari
def create_sample_coords(n_polys=3000, n_vertices=32):
"""random circular polygons with given number of vertices"""
center = np.random.randint(0, 1000, (n_polys, 2))
radius = (
1000
/ np.sqrt(n_polys)
* np.random.uniform(0.9, 1.1, (n_polys, n_vertices))
)
phi = np.linspace(0, 2 * np.pi, n_vertices, endpoint=False)
rays = np.stack([np.sin(phi), np.cos(phi)], 1)
radius = radius.reshape((-1, n_vertices, 1))
rays = rays.reshape((1, -1, 2))
center = center.reshape((-1, 1, 2))
coords = center + radius * rays
return coords
def time_me(label, func):
# print(f'{name} start')
t = default_timer()
res = func()
t = default_timer() - t
print(f"{label}: {t:.4f} s")
return res
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="")
parser.add_argument(
"-n",
"--n_polys",
type=int,
default=5000,
help='number of polygons to show',
)
parser.add_argument(
"-t",
"--type",
type=str,
default="path",
choices=['path', 'path_concat', 'polygon', 'rectangle', 'ellipse'],
)
parser.add_argument(
"-c",
"--concat",
action="store_true",
help='concatenate all coordinates to a single mesh',
)
parser.add_argument(
"-v", "--view", action="store_true", help='show napari viewer'
)
parser.add_argument(
"--properties", action="store_true", help='add dummy shape properties'
)
args = parser.parse_args()
coords = create_sample_coords(args.n_polys)
if args.type == 'rectangle':
coords = coords[:, [4, 20]]
elif args.type == 'ellipse':
coords = coords[:, [0, 8, 16,22]]
elif args.type == 'path_concat':
args.type = 'path'
coords = coords.reshape((1, -1, 2))
print(f'number of polygons: {len(coords)}')
print(f'layer type: {args.type}')
print(f'properties: {args.properties}')
properties = {
'class': (['A', 'B', 'C', 'D'] * (len(coords) // 4 + 1))[
: len(coords)
],
}
color_cycle = ['blue', 'magenta', 'green']
kwargs = dict(
shape_type=args.type,
properties=properties if args.properties else None,
face_color='class' if args.properties else [1,1,1,1],
face_color_cycle=color_cycle,
edge_color='class' if args.properties else [1,1,1,1],
edge_color_cycle=color_cycle,
)
layer = time_me(
"time to create layer",
lambda: napari.layers.Shapes(coords, **kwargs),
)
if args.view:
# add the image
viewer = napari.Viewer()
viewer.add_layer(layer)
napari.run()
napari-0.5.0a1/examples/dev/grin.svg 0000664 0000000 0000000 00000001541 14370413656 0017276 0 ustar 00root root 0000000 0000000 napari-0.5.0a1/examples/dev/gui_notifications.py 0000664 0000000 0000000 00000001122 14370413656 0021700 0 ustar 00root root 0000000 0000000 import warnings
import napari
from napari._qt.widgets.qt_viewer_buttons import QtViewerPushButton
def raise_():
x = 1
y = 'a string'
import something_that_does_not_exist
return something_that_does_not_exist.fun(x, y)
def warn_():
warnings.warn("warning!")
viewer = napari.Viewer()
layer_buttons = viewer.window._qt_viewer.layerButtons
err_btn = QtViewerPushButton('warning', 'new Error', raise_)
warn_btn = QtViewerPushButton('warning', 'new Warn', warn_)
layer_buttons.layout().insertWidget(3, warn_btn)
layer_buttons.layout().insertWidget(3, err_btn)
napari.run()
napari-0.5.0a1/examples/dev/gui_notifications_threaded.py 0000664 0000000 0000000 00000001336 14370413656 0023547 0 ustar 00root root 0000000 0000000 import time
import warnings
import napari
from napari._qt.widgets.qt_viewer_buttons import QtViewerPushButton
from napari.qt import thread_worker
@thread_worker(start_thread=True)
def make_warning(*_):
time.sleep(0.05)
warnings.warn('Warning in another thread')
@thread_worker(start_thread=True)
def make_error(*_):
time.sleep(0.05)
raise ValueError("Error in another thread")
viewer = napari.Viewer()
layer_buttons = viewer.window.qt_viewer.layerButtons
err_btn = QtViewerPushButton(None, 'warning', 'new Error', make_error)
warn_btn = QtViewerPushButton(None, 'warning', 'new Warn', make_warning)
layer_buttons.layout().insertWidget(3, warn_btn)
layer_buttons.layout().insertWidget(3, err_btn)
napari.run()
napari-0.5.0a1/examples/dev/leaking_check.py 0000664 0000000 0000000 00000002753 14370413656 0020745 0 ustar 00root root 0000000 0000000 import gc
import os
import weakref
import numpy as np
import objgraph
import psutil
import qtpy
import napari
process = psutil.Process(os.getpid())
viewer = napari.Viewer()
print("mem", process.memory_info().rss)
for _ in range(0):
print(viewer.add_image(np.random.random((60, 1000, 1000))).name)
for _ in range(2):
print(viewer.add_labels((np.random.random((2, 1000, 1000)) * 10).astype(np.uint8)).name)
print("mem", process.memory_info().rss)
# napari.run()
print("controls", viewer.window.qt_viewer.controls.widgets)
li = weakref.ref(viewer.layers[0])
data_li = weakref.ref(li()._data)
controls = weakref.ref(viewer.window.qt_viewer.controls.widgets[li()])
objgraph.show_backrefs(li(), filename="base.png")
del viewer.layers[0]
qtpy.QtGui.QGuiApplication.processEvents()
gc.collect()
gc.collect()
print(li())
objgraph.show_backrefs(li(), max_depth=10, filename="test.png", refcounts=True)
objgraph.show_backrefs(controls(), max_depth=10, filename="controls.png", refcounts=True)
objgraph.show_backrefs(data_li(), max_depth=10, filename="test_data.png")
print("controls", viewer.window.qt_viewer.controls.widgets)
print("controls", gc.get_referrers(controls()))
print("controls", controls().parent())
#print("controls", controls().parent().indexOf(controls()))
print(gc.get_referrers(li()))
print(gc.get_referrers(li())[1])
print(gc.get_referrers(gc.get_referrers(gc.get_referrers(li())[0])))
res = gc.get_referrers(gc.get_referrers(gc.get_referrers(li())[0])[0])
print(res)
#print(type(res[0]))
napari-0.5.0a1/examples/dev/plot_2d_edge_meshes.py 0000664 0000000 0000000 00000002204 14370413656 0022060 0 ustar 00root root 0000000 0000000 import matplotlib.pyplot as plt
from matplotlib.patches import Polygon
from napari.layers.shapes._shapes_utils import (
generate_2D_edge_meshes,
)
fig, axes = plt.subplots(2, 3)
# fig.set_figwidth(15)
# fig.set_figheight(10)
colors = iter(['red', 'green', 'blue', 'yellow'])
itaxes = iter(axes.flatten())
sup = axes.flatten()[4]
for closed in [False, True]:
for beveled in [False, True]:
ax = next(itaxes)
c = next(colors)
centers, offsets, triangles = generate_2D_edge_meshes(
[[0, 3], [1, 0], [2, 3], [5, 0], [2.5, 5]],
closed=closed,
limit=3,
bevel=beveled,
)
points = centers + 0.3 * offsets
for t in triangles:
trp = points[t]
ax.add_patch(Polygon(trp, ec='#000000', fc=c, alpha=0.2))
sup.add_patch(Polygon(trp, ec='#000000', fc=c, alpha=0.1))
ax.scatter(*(points).T)
ax.scatter(*(centers).T)
ax.set_aspect('equal')
ax.set_title(f' {closed=}, {beveled=}')
ax.set_xlim(-1, 6)
ax.set_ylim(-1, 6)
sup.set_xlim(-1, 6)
sup.set_ylim(-1, 6)
plt.show()
napari-0.5.0a1/examples/dev/q_list_view.py 0000664 0000000 0000000 00000002621 14370413656 0020515 0 ustar 00root root 0000000 0000000 """Example of using low-level `QtListView` with SelectableEventedList
:class:`napari.utils.events.SelectableEventedList` is a mutable sequence that
emits events when modified. It also has a selection model (tracking which
items are selected).
:class:`napari._qt.containers.QtListView` adapts the `EventedList` to the
QAbstractItemModel/QAbstractItemView interface used by the QtFramework. This
allows you to create an interactive GUI view onto a python model that stays
up to date, and can modify the python object... while maintining the python
object as the single "source of truth".
"""
import napari
from napari._qt.containers import QtListView
from napari.qt import get_app
from napari.utils.events import SelectableEventedList
get_app()
class MyObject:
"""generic object."""
def __init__(self, name) -> None:
self.name = name
def __str__(self):
return self.name
# create our evented list
root = SelectableEventedList([MyObject(x) for x in 'abcdefg'])
# create Qt view onto the list
view = QtListView(root)
# show the view
view.show()
# spy on events
root.events.reordered.connect(lambda e: print("reordered to: ", e.value))
root.selection.events.changed.connect(
lambda e: print(
f"selection changed. added: {e.added}, removed: {e.removed}"
)
)
root.selection.events._current.connect(
lambda e: print(f"current item changed to: {e.value}")
)
napari.run()
napari-0.5.0a1/examples/dev/q_node_tree.py 0000664 0000000 0000000 00000003736 14370413656 0020464 0 ustar 00root root 0000000 0000000 """Example of using low-level QtNodeTreeView with Node and Group
:class:`napari.utils.tree.Node` is a class that may be used as a mixin that
allows an object to be a member of a "tree".
:class:`napari.utils.tree.Group` is a (nestable) mutable sequence of Nodes, and
is also itself a Node (this is the "composite" pattern):
https://refactoring.guru/design-patterns/composite/python/example
These two classes may be used to create tree-like data structures that behave
like pure python lists of lists.
This examples shows that :class:`napari._qt.containers.QtNodeTreeView`
is capable of providing a basic GUI for any tree structure based on
`napari.utils.tree.Group`.
"""
import napari
from napari._qt.containers import QtNodeTreeView
from napari.qt import get_app
from napari.utils.tree import Group, Node
get_app()
# create a group of nodes.
root = Group(
[
Node(name='6'),
Group(
[
Node(name='1'),
Group([Node(name='2'), Node(name='3')], name="g2"),
Node(name='4'),
Node(name='5'),
Node(name='tip'),
],
name="g1",
),
Node(name='7'),
Node(name='8'),
Node(name='9'),
],
name="root",
)
# create Qt view onto the Group
view = QtNodeTreeView(root)
# show the view
view.show()
# pretty __str__ makes nested tree structure more interpretable
print(root)
# root
# ├──6
# ├──g1
# │ ├──1
# │ ├──g2
# │ │ ├──2
# │ │ └──3
# │ ├──4
# │ ├──5
# │ └──tip
# ├──7
# ├──8
# └──9
# spy on events
root.events.reordered.connect(lambda e: print("reordered to: ", e.value))
root.selection.events.changed.connect(
lambda e: print(
f"selection changed. added: {e.added}, removed: {e.removed}"
)
)
root.selection.events._current.connect(
lambda e: print(f"current item changed to: {e.value}")
)
napari.run()
napari-0.5.0a1/examples/dev/slicing/ 0000775 0000000 0000000 00000000000 14370413656 0017245 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/examples/dev/slicing/README.md 0000664 0000000 0000000 00000003137 14370413656 0020530 0 ustar 00root root 0000000 0000000 # Slicing examples
The examples in this directory are for developers to test various aspects
of layer slicing. These are primarily designed to aid in the async effort ([NAP 4](../../../docs/naps/4-async-slicing.md)).
## Examples
Examples using [pooch](https://pypi.org/project/pooch/) will cache data locally, with an [OS-dependant path](https://www.fatiando.org/pooch/latest/api/generated/pooch.os_cache.html?highlight=cache#pooch.os_cache).
### Examples of desirable behavior
These are a set of examples which are easy and non-frustrating to interact in napari
without async support. We want to ensure that these examples continue to be performant.
* ebi_empiar_3D_with_labels.py [EMPIAR-10982](https://www.ebi.ac.uk/empiar/EMPIAR-10982/)
* Real-world image & labels data (downloaded locally)
* points_example_smlm.py
* Real-world points data (downloaded locally)
Additional examples from the main napari examples:
* add_multiscale_image.py
* Access to in-memory multi-scale data
### Examples of undesirable behavior
These are a set of examples which currently cause undesirable behavior in napari, typically
resulting in non-responsive user interface due to synchronous slicing on large or remote data.
* random_shapes.py
* A large number of shapes to stress slicing on a shapes layer
* random_points.py
* A large number of random points to stress slicing on a points layer
* janelia_s3_n5_multiscale.py
* Multi-scale remote image data in zarr format
## Performance monitoring
The [perfmon](../../../tools/perfmon/README.md) tooling can be used to monitor the data
access performance on these examples. napari-0.5.0a1/examples/dev/slicing/ebi_empiar_3D_with_labels.py 0000664 0000000 0000000 00000002331 14370413656 0024615 0 ustar 00root root 0000000 0000000 import pooch
from tifffile import imread
import napari
"""
This data comes from the MitoNet Benchmarks.
Six benchmark volumes of instance segmentation of mitochondria from diverse volume EM datasets
Narayan K , Conrad RW
DOI: https://dx.doi.org/10.6019/EMPIAR-10982
Data is stored at EMPIAR and can be explored here: https://www.ebi.ac.uk/empiar/EMPIAR-10982/
With respect to the napari async slicing work, this dataset is small enough that it performs well in synchronous mode.
"""
salivary_gland_em_path = pooch.retrieve(
url='https://ftp.ebi.ac.uk/empiar/world_availability/10982/data/mito_benchmarks/salivary_gland/salivary_gland_em.tif',
known_hash='222f50dd8fd801a84f118ce71bc735f5c54f1a3ca4d98315b27721ae499bff94',
progressbar=True
)
salivary_gland_mito_path = pooch.retrieve(
url='https://ftp.ebi.ac.uk/empiar/world_availability/10982/data/mito_benchmarks/salivary_gland/salivary_gland_mito.tif',
known_hash='95247d952a1dd0f7b37da1be95980b598b590e4777065c7cd877ab67cb63c5eb',
progressbar=True
)
salivary_gland_em = imread(salivary_gland_em_path)
salivary_gland_mito = imread(salivary_gland_mito_path)
viewer = napari.view_image(salivary_gland_em)
viewer.add_labels(salivary_gland_mito)
napari.run()
napari-0.5.0a1/examples/dev/slicing/janelia_s3_n5_multiscale.py 0000664 0000000 0000000 00000001754 14370413656 0024462 0 ustar 00root root 0000000 0000000 import dask.array as da
import zarr
import napari
"""
The sample data here is Interphase HeLa Cell [https://openorganelle.janelia.org/datasets/jrc_hela-3],
from HHMI's OpenOrganelle [https://openorganelle.janelia.org].
The data are hosted by Open Data on AWS on S3.
This tests access to multi-scale remote data.
"""
# access the root of the n5 container
group = zarr.open(zarr.N5FSStore('s3://janelia-cosem-datasets/jrc_hela-2/jrc_hela-2.n5', anon=True))
# s0 (highest resolution) through s5 (lowest resolution) are available
data = []
for i in range(0, 5):
zarr_array = group[f'em/fibsem-uint16/s{i}']
data.append(da.from_zarr(zarr_array, chunks=zarr_array.chunks))
# This order presents a better visualization, but seems to break simple async (issue #5106)
# viewer = napari.view_image(data, order=(1, 0, 2), contrast_limits=(18000, 40000), multiscale=True)
viewer = napari.view_image(data, contrast_limits=(18000, 40000), multiscale=True)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/dev/slicing/points_example_smlm.py 0000664 0000000 0000000 00000001664 14370413656 0023705 0 ustar 00root root 0000000 0000000 import csv
import numpy as np
import pooch
import napari
"""
This data comes from the Neurocyto Lab's description of the ThunderSTORM format.
This file format is used to represent single molecule localizations.
With respect to the napari async slicing work, this dataset is small enough that it performs well in synchronous mode.
If someone is interested, then you can use the uncertainty_xy attribute from the STORM data to change the point size.
More information is available here: http://www.neurocytolab.org/tscolumns/
"""
storm_path = pooch.retrieve(
url='http://www.neurocytolab.org/wp-content/uploads/2018/06/ThunderSTORM_TS3D.csv',
known_hash='665a28b2fad69dbfd902e4945df04667f876d33a91167614c280065212041a29',
progressbar=True
)
with open(storm_path) as csvfile:
data = list(csv.reader(csvfile))
data = np.array(data[1:]).astype(float)
data = data[:, 1:4]
viewer = napari.view_points(data, size=50)
napari.run()
napari-0.5.0a1/examples/dev/slicing/profile_points.py 0000664 0000000 0000000 00000001215 14370413656 0022652 0 ustar 00root root 0000000 0000000 import cProfile
import io
import pstats
from pstats import SortKey
import numpy as np
from napari.layers import Points
"""
This script was useful for testing how the performance of
Points._set_view_slice changed with different implementations during async
development.
"""
np.random.seed(0)
n = 65536
data = np.random.random((n, 2))
s = io.StringIO()
reps = 100
# Profiling
with cProfile.Profile() as pr:
for _ in range(reps):
layer = Points(data)
layer._set_view_slice()
sortby = SortKey.CUMULATIVE
ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
ps.print_stats(0.05)
print(s.getvalue())
# pr.dump_stats("result.pstat")
napari-0.5.0a1/examples/dev/slicing/random_points.py 0000664 0000000 0000000 00000000662 14370413656 0022477 0 ustar 00root root 0000000 0000000 import argparse
import numpy as np
import napari
"""
Stress the points layer by generating a large number of points.
"""
parser = argparse.ArgumentParser()
parser.add_argument(
"n", type=int, nargs='?', default=10_000_000, help="(default: %(default)s)"
)
args = parser.parse_args()
np.random.seed(0)
n = args.n
data = 1000 * np.random.rand(n, 3)
viewer = napari.view_points(data)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/dev/slicing/random_shapes.py 0000664 0000000 0000000 00000004030 14370413656 0022437 0 ustar 00root root 0000000 0000000 import os
import numpy as np
import napari
"""
This example generates many random shapes.
There currently is a bug in triangulation that requires this additional step of sanitizing the shape data: https://github.com/orgs/napari/projects/18/views/2
"""
# logging.getLogger().setLevel(0)
def generate_shapes(filename):
# image_data = np.squeeze(cells3d()[:, 1, :, :])
# delayed_image_data = DelayedArray(image_data, delay_s=1)
# From https://github.com/napari/napari/blob/main/examples/nD_shapes.py
# create one random polygon per "plane"
shapes_per_slice = 1000
all_shapes = None
np.random.seed(0)
for _ in range(shapes_per_slice):
planes = np.tile(np.arange(128).reshape((128, 1, 1)), (1, 5, 1))
corners = np.random.uniform(0, 128, size=(128, 5, 2))
shapes = np.concatenate((planes, corners), axis=2)
if all_shapes is not None:
all_shapes = np.concatenate((all_shapes, shapes), axis=0)
else:
all_shapes = shapes
print('all_shapes', all_shapes.shape)
from vispy.geometry.polygon import PolygonData
good_shapes = []
for shape in all_shapes:
# Use try/except to filter all bad shapes
try:
vertices, triangles = PolygonData(
vertices=shape[:, 1:]
).triangulate()
except AssertionError:
pass
else:
good_shapes.append(shape)
print(len(good_shapes))
np.savez(filename, shapes=good_shapes)
test_filename = '/tmp/napari_example_shapes.npz'
# Create the example shapes if they do not exist
if not os.path.exists(test_filename):
print(
'Shapes file does not exist yet. Generating shapes. This may take a couple of minutes...'
)
generate_shapes(test_filename)
# Load the shapes
with np.load(test_filename) as data:
shapes = data['shapes']
# Test shapes in viewer
viewer = napari.Viewer()
viewer.show()
shapes_layer = viewer.add_shapes(
np.array(shapes),
shape_type='polygon',
name='sliced',
)
napari.run()
napari-0.5.0a1/examples/dynamic-projections-dask.py 0000664 0000000 0000000 00000004060 14370413656 0022312 0 ustar 00root root 0000000 0000000 """
Dynamic projections dask
========================
Using dask array operations, one can dynamically take arbitrary slices
and computations of a source dask array and display the results in napari.
When the computation takes one or more parameters, one can tie a UI to
them using magicgui.
.. tags:: visualization-advanced
"""
import dask.array as da
import numpy as np
from dask.array.lib.stride_tricks import sliding_window_view
from skimage import data
import napari
##############################################################################
# Part 1: using code to view a specific value.
blobs = data.binary_blobs(length=64, n_dim=3)
blobs_dask = da.from_array(blobs, chunks=(1, 64, 64))
# original shape [60, 1, 1, 5, 64, 64],
# use squeeze to remove singleton axes
blobs_dask_windows = np.squeeze(
sliding_window_view(blobs_dask, window_shape=(5, 64, 64)),
axis=(1, 2),
)
blobs_sum = np.sum(blobs_dask_windows, axis=1)
viewer = napari.view_image(blobs_sum)
if __name__ == '__main__':
napari.run()
##############################################################################
# Part 2: using magicgui to vary the slice thickness.
from magicgui import magicgui # noqa: E402
def sliding_window_mean(
arr: napari.types.ImageData, size: int = 1
) -> napari.types.LayerDataTuple:
window_shape = (size,) + (arr.shape[1:])
arr_windows = sliding_window_view(arr, window_shape=window_shape)
# as before, use squeeze to remove singleton axes
arr_windows_1d = np.squeeze(
arr_windows, axis=tuple(range(1, arr.ndim))
)
arr_summed = np.sum(arr_windows_1d, axis=1) / size
return (
arr_summed,
{
'translate': (size // 2,) + (0,) * (arr.ndim - 1),
'name': 'mean-window',
'colormap': 'magenta',
'blending': 'additive',
},
'image',
)
viewer = napari.view_image(blobs_dask, colormap='green')
viewer.window.add_dock_widget(magicgui(sliding_window_mean, auto_call=True))
viewer.dims.current_step = (32, 0, 0)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/embed_ipython_.py 0000664 0000000 0000000 00000001537 14370413656 0020404 0 ustar 00root root 0000000 0000000 """
Embed IPython
=============
Start napari and land directly in an embedded ipython console with qt event loop.
A similar effect can be achieved more simply with `viewer.update_console(locals())`,
such as shown in https://github.com/napari/napari/blob/main/examples/update_console.py.
However, differently from `update_console`, this will start an independent
ipython console which can outlive the viewer.
.. tags:: gui
"""
from IPython.terminal.embed import InteractiveShellEmbed
import napari
# any code
text = 'some text'
# initalize viewer
viewer = napari.Viewer()
# embed ipython and run the magic command to use the qt event loop
sh = InteractiveShellEmbed()
sh.enable_gui('qt') # equivalent to using the '%gui qt' magic
sh() # open the embedded shell
# From there, you can access the script's scope, such as the variables `text` and `viewer`
napari-0.5.0a1/examples/get_current_viewer.py 0000664 0000000 0000000 00000000623 14370413656 0021314 0 ustar 00root root 0000000 0000000 """
Get current viewer
==================
Get a reference to the current napari viewer.
Whilst this example is contrived, it can be useful to get a reference to the
viewer when the viewer is out of scope.
.. tags:: gui
"""
import napari
# create viewer
viewer = napari.Viewer()
# lose reference to viewer
viewer = 'oops no viewer here'
# get that reference again
viewer = napari.current_viewer()
napari-0.5.0a1/examples/image-points-3d.py 0000664 0000000 0000000 00000000773 14370413656 0020320 0 ustar 00root root 0000000 0000000 """
Image points 3D
===============
Display points overlaid on a 3D image
.. tags:: visualization-nD
"""
from skimage import data, feature, filters
import napari
cells = data.cells3d()
nuclei = cells[:, 1]
smooth = filters.gaussian(nuclei, sigma=10)
pts = feature.peak_local_max(smooth)
viewer = napari.view_image(
cells, channel_axis=1, name=['membranes', 'nuclei'], ndisplay=3
)
viewer.add_points(pts)
viewer.camera.angles = (10, -20, 130)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/image_depth.py 0000664 0000000 0000000 00000000767 14370413656 0017671 0 ustar 00root root 0000000 0000000 """
Image depth
===========
.. tags:: visualization-basic
"""
import numpy as np
import napari
im_data = np.zeros((50, 50, 50))
im_data[30:40, 25:35, 25:35] = 1
viewer = napari.view_image(im_data, colormap='magenta', rendering='iso')
viewer.add_image(im_data, colormap='green', rendering='iso', translate=(30, 0, 0))
points_data = [
[50, 30, 30],
[25, 30, 30],
[75, 30, 30]
]
viewer.add_points(points_data, size=4)
viewer.dims.ndisplay = 3
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/inherit_viewer_style.py 0000664 0000000 0000000 00000004237 14370413656 0021662 0 ustar 00root root 0000000 0000000 """
Method to get napari style in magicgui based windows
====================================================
Example how to embed magicgui widget in dialog to inherit style
from main napari window.
.. tags:: gui, interactivity
"""
from magicgui import magicgui
from qtpy.QtWidgets import (
QDialog,
QGridLayout,
QLabel,
QPushButton,
QSpinBox,
QVBoxLayout,
QWidget,
)
import napari
from napari.qt import get_stylesheet
from napari.settings import get_settings
# The magicgui widget shown by selecting the 'Show widget' button of MyWidget
@magicgui
def sample_add(a: int, b: int) -> int:
return a + b
def change_style():
sample_add.native.setStyleSheet(get_stylesheet(get_settings().appearance.theme))
get_settings().appearance.events.theme.connect(change_style)
change_style()
class MyDialog(QDialog):
def __init__(self, parent=None) -> None:
super().__init__(parent)
self.first_input = QSpinBox()
self.second_input = QSpinBox()
self.btn = QPushButton('Add')
layout = QGridLayout()
layout.addWidget(QLabel("first input"), 0, 0)
layout.addWidget(self.first_input, 0, 1)
layout.addWidget(QLabel("second input"), 1, 0)
layout.addWidget(self.second_input, 1, 1)
layout.addWidget(self.btn, 2, 0, 1, 2)
self.setLayout(layout)
self.btn.clicked.connect(self.run)
def run(self):
print('run', self.first_input.value() + self.second_input.value())
self.close()
class MyWidget(QWidget):
def __init__(self) -> None:
super().__init__()
self.btn1 = QPushButton('Show dialog')
self.btn1.clicked.connect(self.show_dialog)
self.btn2 = QPushButton('Show widget')
self.btn2.clicked.connect(self.show_widget)
self.layout = QVBoxLayout()
self.layout.addWidget(self.btn1)
self.layout.addWidget(self.btn2)
self.setLayout(self.layout)
def show_dialog(self):
dialog = MyDialog(self)
dialog.exec_()
def show_widget(self):
sample_add.show()
viewer = napari.Viewer()
widget = MyWidget()
viewer.window.add_dock_widget(widget, area='right')
napari.run()
napari-0.5.0a1/examples/interaction_box_image.py 0000664 0000000 0000000 00000000704 14370413656 0021743 0 ustar 00root root 0000000 0000000 """
Interaction box image
=====================
This example demonstrates activating 'transform' mode on the image layer.
This allows the user to manipulate the image via the interaction box
(blue box and points around the image).
.. tags:: experimental
"""
from skimage import data
import napari
viewer = napari.view_image(data.astronaut(), rgb=True)
viewer.layers.selection.active.mode = 'transform'
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/interactive_move_rectangle_3d.py 0000664 0000000 0000000 00000003404 14370413656 0023367 0 ustar 00root root 0000000 0000000 """
Interactive move rectangle
==========================
Shift a rectangle along its normal vector in 3D
.. tags:: experimental
"""
import numpy as np
import napari
rectangle = np.array(
[
[50, 75, 75],
[50, 125, 75],
[100, 125, 125],
[100, 75, 125]
],
dtype=float
)
shapes_data = np.array(rectangle)
normal_vector = np.cross(
rectangle[0] - rectangle[1], rectangle[2] - rectangle[1]
)
normal_vector /= np.linalg.norm(normal_vector)
viewer = napari.Viewer(ndisplay=3)
shapes_layer = viewer.add_shapes(
data=shapes_data,
face_color='blue'
)
viewer.camera.angles = (-170, -20, -170)
viewer.camera.zoom = 1.5
viewer.text_overlay.visible = True
viewer.text_overlay.text = """'click and drag the rectangle to create copies along its normal vector
"""
@shapes_layer.mouse_drag_callbacks.append
def move_rectangle_along_normal(layer, event):
shape_index, _ = layer.get_value(
position=event.position,
view_direction=event.view_direction,
dims_displayed=event.dims_displayed
)
if shape_index is None:
return
layer.interactive = False
start_position = np.copy(event.position)
yield
while event.type == 'mouse_move':
projected_distance = layer.projected_distance_from_mouse_drag(
start_position=start_position,
end_position=event.position,
view_direction=event.view_direction,
vector=normal_vector,
dims_displayed=event.dims_displayed,
)
shift_data_coordinates = projected_distance * normal_vector
new_rectangle = layer.data[shape_index] + shift_data_coordinates
layer.add(new_rectangle)
yield
layer.interactive = True
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/interactive_scripting.py 0000664 0000000 0000000 00000001237 14370413656 0022013 0 ustar 00root root 0000000 0000000 """
Interactive scripting
=====================
.. tags:: interactivity
"""
import time
import numpy as np
import napari
from napari.qt import thread_worker
# create the viewer with an image
data = np.random.random((512, 512))
viewer = napari.Viewer()
layer = viewer.add_image(data)
def update_layer(data):
layer.data = data
@thread_worker(connect={'yielded': update_layer})
def create_data(*, update_period, num_updates):
# number of times to update
for _k in range(num_updates):
yield np.random.random((512, 512))
time.sleep(update_period)
create_data(update_period=0.05, num_updates=50)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/labels-2d.py 0000664 0000000 0000000 00000001446 14370413656 0017163 0 ustar 00root root 0000000 0000000 """
Labels 2D
=========
Display a labels layer above of an image layer using the ``add_labels`` and
``add_image`` APIs
.. tags:: visualization-basic
"""
from skimage import data
from skimage.color import rgb2gray
from skimage.segmentation import slic
import napari
astro = data.astronaut()
# initialise viewer with astro image
viewer = napari.view_image(rgb2gray(astro), name='astronaut', rgb=False)
# add the labels
# we add 1 because SLIC returns labels from 0, which we consider background
labels = slic(astro, multichannel=True, compactness=20) + 1
label_layer = viewer.add_labels(labels, name='segmentation')
# Set the labels layer mode to picker with a string
label_layer.mode = 'PICK'
print(f'The color of label 5 is {label_layer.get_color(5)}')
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/labels3d.py 0000664 0000000 0000000 00000001730 14370413656 0017103 0 ustar 00root root 0000000 0000000 """
Labels 3D
=========
View 3D labels.
.. tags:: visualization-nD
"""
import numpy as np
from scipy import ndimage as ndi
from skimage import data, filters, morphology
import napari
cells3d = data.cells3d()
viewer = napari.view_image(
cells3d, channel_axis=1, name=['membranes', 'nuclei']
)
membrane, nuclei = cells3d.transpose((1, 0, 2, 3)) / np.max(cells3d)
edges = filters.scharr(nuclei)
denoised = ndi.median_filter(nuclei, size=3)
thresholded = denoised > filters.threshold_li(denoised)
cleaned = morphology.remove_small_objects(
morphology.remove_small_holes(thresholded, 20**3),
20**3,
)
segmented = ndi.label(cleaned)[0]
# maxima = ndi.label(morphology.local_maxima(filters.gaussian(nuclei, sigma=10)))[0]
# markers_big = morphology.dilation(maxima, morphology.ball(5))
# segmented = segmentation.watershed(
# edges,
# markers_big,
# mask=cleaned,
# )
labels_layer = viewer.add_labels(segmented)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/layers.py 0000664 0000000 0000000 00000001370 14370413656 0016711 0 ustar 00root root 0000000 0000000 """
Layers
======
Display multiple image layers using the ``add_image`` API and then reorder them
using the layers swap method and remove one
.. tags:: visualization-basic
"""
import numpy as np
from skimage import data
from skimage.color import rgb2gray
import napari
# create the viewer with several image layers
viewer = napari.view_image(rgb2gray(data.astronaut()), name='astronaut')
viewer.add_image(data.camera(), name='photographer')
viewer.add_image(data.coins(), name='coins')
viewer.add_image(data.moon(), name='moon')
viewer.add_image(np.random.random((512, 512)), name='random')
viewer.add_image(data.binary_blobs(length=512, volume_fraction=0.2, n_dim=2), name='blobs')
viewer.grid.enabled = True
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/linked_layers.py 0000664 0000000 0000000 00000001613 14370413656 0020237 0 ustar 00root root 0000000 0000000 """
Linked layers
=============
Demonstrates the `link_layers` function.
This function takes a list of layers and an optional list of attributes, and
links them such that when one of the linked attributes changes on any of the
linked layers, all of the other layers follow.
.. tags:: experimental
"""
import numpy as np
import napari
from napari.experimental import link_layers
viewer = napari.view_image(np.random.rand(3, 64, 64), channel_axis=0)
# link contrast_limits and gamma between all layers in viewer
# NOTE: you may also omit the second argument to link ALL valid, common
# attributes for the set of layers provided
link_layers(viewer.layers, ('contrast_limits', 'gamma'))
# unlinking may be done with napari.experimental.unlink_layers
# this may also be done in a context manager:
# with napari.experimental.layers_linked([layers]):
# ...
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/live_tiffs_.py 0000664 0000000 0000000 00000010337 14370413656 0017706 0 ustar 00root root 0000000 0000000 """
Live tiffs
==========
Loads and Displays tiffs as they get generated in the specific directory.
Trying to simulate the live display of data as it gets acquired by microscope.
This script should be run together with live_tiffs_generator.py
.. tags:: experimental
"""
import os
import sys
import time
import dask.array as da
from dask import delayed
from skimage.io.collection import alphanumeric_key
from tifffile import imread
import napari
from napari.qt import thread_worker
viewer = napari.Viewer(ndisplay=3)
# pass a directory to monitor or it will monitor current directory.
path = sys.argv[1] if len(sys.argv) > 1 else '.'
path = os.path.abspath(path)
end_of_experiment = 'final.log'
def append(delayed_image):
"""Appends the image to viewer.
Parameters
----------
delayed_image : dask.delayed function object
"""
if delayed_image is None:
return
if viewer.layers:
# layer is present, append to its data
layer = viewer.layers[0]
image_shape = layer.data.shape[1:]
image_dtype = layer.data.dtype
image = da.from_delayed(
delayed_image, shape=image_shape, dtype=image_dtype,
).reshape((1,) + image_shape)
layer.data = da.concatenate((layer.data, image), axis=0)
else:
# first run, no layer added yet
image = delayed_image.compute()
image = da.from_delayed(
delayed_image, shape=image.shape, dtype=image.dtype,
).reshape((1,) + image.shape)
layer = viewer.add_image(image, rendering='attenuated_mip')
# we want to show the last file added in the viewer to do so we want to
# put the slider at the very end. But, sometimes when user is scrolling
# through the previous slide then it is annoying to jump to last
# stack as it gets added. To avoid that jump we 1st check where
# the scroll is and if its not at the last slide then don't move the slider.
if viewer.dims.point[0] >= layer.data.shape[0] - 2:
viewer.dims.set_point(0, layer.data.shape[0] - 1)
@thread_worker(connect={'yielded': append})
def watch_path(path):
"""Watches the path for new files and yields it once file is ready.
Notes
-----
Currently, there is no proper way to know if the file has written
entirely. So the workaround is we assume that files are generating
serially (in most microscopes it common), and files are name in
alphanumeric sequence We start loading the total number of minus the
last file (`total__files - last`). In other words, once we see the new
file in the directory, it means the file before it has completed so load
that file. For this example, we also assume that the microscope is
generating a `final.log` file at the end of the acquisition, this file
is an indicator to stop monitoring the directory.
Parameters
----------
path : str
directory to monitor and load tiffs as they start appearing.
"""
current_files = set()
processed_files = set()
end_of_acquisition = False
while not end_of_acquisition:
files_to_process = set()
# Get the all files in the directory at this time
current_files = set(os.listdir(path))
# Check if the end of acquisition has reached
# if yes then remove it from the files_to_process set
# and send it to display
if end_of_experiment in current_files:
files_to_process = current_files - processed_files
files_to_process.remove(end_of_experiment)
end_of_acquisition = True
elif len(current_files):
# get the last file from the current files based on the file names
last_file = sorted(current_files, key=alphanumeric_key)[-1]
current_files.remove(last_file)
files_to_process = current_files - processed_files
# yield every file to process as a dask.delayed function object.
for p in sorted(files_to_process, key=alphanumeric_key):
yield delayed(imread)(os.path.join(path, p))
else:
yield
# add the files which we have yield to the processed list.
processed_files.update(files_to_process)
time.sleep(0.1)
worker = watch_path(path)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/live_tiffs_generator_.py 0000664 0000000 0000000 00000002776 14370413656 0021764 0 ustar 00root root 0000000 0000000 """
Live tiffs generator
====================
Simulation of microscope acquisition. This code generates time series tiffs in
an output directory (must be supplied by the user).
.. tags:: experimental
"""
import argparse
import os
import sys
import time
import numpy as np
import tifffile
from skimage import data
parser = argparse.ArgumentParser()
parser.add_argument('outdir', help='output directory for tiffs')
parser.add_argument(
'--sleep-time',
help='how long to sleep between volumes, in seconds',
type=float,
default=1.0,
)
parser.add_argument(
'-n', help='total number of volumes', type=int, default=100
)
def main(argv=sys.argv[1:]):
args = parser.parse_args(argv)
outdir = args.outdir
sleep_time = args.sleep_time
n = args.n
fractions = np.linspace(0.05, 0.5, n)
os.makedirs(outdir, exist_ok=True)
for i, f in enumerate(fractions):
# We are using skimage binary_blobs which generate's synthetic binary
# image with several rounded blob-like objects and write them into files.
curr_vol = 255 * data.binary_blobs(
length=128, blob_size_fraction=0.05, n_dim=3, volume_fraction=f
).astype(np.uint8)
tifffile.imwrite(
os.path.join(outdir, f'{i}.tiff'), curr_vol, compress=6
)
time.sleep(sleep_time)
# create a final.log file as an indicator for end of acquisition
final_file = open(os.path.join(outdir, 'final.log'), 'w')
final_file.close()
if __name__ == '__main__':
main()
napari-0.5.0a1/examples/magic_image_arithmetic.py 0000664 0000000 0000000 00000003247 14370413656 0022052 0 ustar 00root root 0000000 0000000 """
magicgui Image Arithmetic
=========================
Basic example of using magicgui to create an Image Arithmetic GUI in napari.
.. tags:: gui
"""
import enum
import numpy as np
import napari
# Enums are a convenient way to get a dropdown menu
class Operation(enum.Enum):
"""A set of valid arithmetic operations for image_arithmetic."""
add = np.add
subtract = np.subtract
multiply = np.multiply
divide = np.divide
# Define our image_arithmetic function.
# Note that we can use forward references for the napari type annotations.
# You can read more about them here:
# https://peps.python.org/pep-0484/#forward-references
# In this example, because we have already imported napari anyway, it doesn't
# really matter. But this syntax would let you specify that a parameter is a
# napari object type without actually importing or depending on napari.
# Note: here we use `napari.types.ImageData` as our parameter annotations,
# which means our function will be passed layer.data instead of
# the full layer instance
def image_arithmetic(
layerA: 'napari.types.ImageData',
operation: Operation,
layerB: 'napari.types.ImageData',
) -> 'napari.types.ImageData':
"""Adds, subtracts, multiplies, or divides two same-shaped image layers."""
if layerA is not None and layerB is not None:
return operation.value(layerA, layerB)
# create a new viewer with a couple image layers
viewer = napari.Viewer()
viewer.add_image(np.random.rand(20, 20), name="Layer 1")
viewer.add_image(np.random.rand(20, 20), name="Layer 2")
# Add our magic function to napari
viewer.window.add_function_widget(image_arithmetic)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/magic_parameter_sweep.py 0000664 0000000 0000000 00000003472 14370413656 0021742 0 ustar 00root root 0000000 0000000 """
magicgui parameter sweep
========================
Example showing how to accomplish a napari parameter sweep with magicgui.
It demonstrates:
1. overriding the default widget type with a custom class
2. the `auto_call` option, which calls the function whenever a parameter changes
.. tags:: gui
"""
import skimage.data
import skimage.filters
from typing_extensions import Annotated
import napari
# Define our gaussian_blur function.
# Note that we can use forward references for the napari type annotations.
# You can read more about them here:
# https://peps.python.org/pep-0484/#forward-references
# In this example, because we have already imported napari anyway, it doesn't
# really matter. But this syntax would let you specify that a parameter is a
# napari object type without actually importing or depending on napari.
# We also use the `Annotated` type to pass an additional dictionary that can be used
# to aid widget generation. The keys of the dictionary are keyword arguments to
# the corresponding magicgui widget type. For more informaiton see
# https://napari.org/magicgui/api/widgets.html.
def gaussian_blur(
layer: 'napari.layers.Image',
sigma: Annotated[float, {"widget_type": "FloatSlider", "max": 6}] = 1.0,
mode: Annotated[str, {"choices": ["reflect", "constant", "nearest", "mirror", "wrap"]}]="nearest",
) -> 'napari.types.ImageData':
"""Apply a gaussian blur to ``layer``."""
if layer:
return skimage.filters.gaussian(layer.data, sigma=sigma, mode=mode)
# create a viewer and add some images
viewer = napari.Viewer()
viewer.add_image(skimage.data.astronaut().mean(-1), name="astronaut")
viewer.add_image(skimage.data.grass().astype("float"), name="grass")
# Add our magic function to napari
viewer.window.add_function_widget(gaussian_blur)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/magic_viewer.py 0000664 0000000 0000000 00000001106 14370413656 0020050 0 ustar 00root root 0000000 0000000 """
magicgui viewer
===============
Example showing how to access the current viewer from a function widget.
.. tags:: gui
"""
import napari
# annotating a paramater as `napari.Viewer` will automatically provide
# the viewer that the function is embedded in, when the function is added to
# the viewer with add_function_widget.
def my_function(viewer: napari.Viewer):
print(viewer, f"with {len(viewer.layers)} layers")
viewer = napari.Viewer()
# Add our magic function to napari
viewer.window.add_function_widget(my_function)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/mgui_dask_delayed_.py 0000664 0000000 0000000 00000001435 14370413656 0021205 0 ustar 00root root 0000000 0000000 """
magicgui dask delayed
=====================
An example of calling a threaded function from a magicgui dock_widget.
Note: this example requires python >= 3.9
.. tags:: gui
"""
import time
from concurrent.futures import Future
import dask.array as da
from magicgui import magicgui
import napari
from napari.types import ImageData
def _slow_function(nz):
time.sleep(2)
return da.random.random((nz, 512, 512))
if __name__ == '__main__':
from dask.distributed import Client
client = Client()
@magicgui(client={'bind': client})
def widget(client, nz: int = 1000) -> Future[ImageData]:
return client.submit(_slow_function, nz)
viewer = napari.Viewer()
viewer.window.add_dock_widget(widget, area="right")
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/mgui_with_threadpoolexec_.py 0000664 0000000 0000000 00000003303 14370413656 0022631 0 ustar 00root root 0000000 0000000 """
magicgui with threadpoolexec
============================
An example of calling a threaded function from a magicgui ``dock_widget``.
using ``ThreadPoolExecutor``
Note: this example requires python >= 3.9
.. tags:: gui
"""
import sys
from concurrent.futures import Future, ThreadPoolExecutor
from magicgui import magic_factory
from skimage import data
from skimage.feature import blob_log
import napari
from napari.types import ImageData, LayerDataTuple
if sys.version_info < (3, 9):
print('This example requires python >= 3.9')
sys.exit(0)
pool = ThreadPoolExecutor()
@magic_factory(
min_sigma={"min": 0.5, "max": 15, "step": 0.5},
max_sigma={"min": 1, "max": 200, "step": 0.5},
num_sigma={"min": 1, "max": 20},
threshold={"min": 0, "max": 1000, "step": 0.1},
)
def make_widget(
image: ImageData,
min_sigma: float = 5,
max_sigma: float = 30,
num_sigma: int = 10,
threshold: float = 0.3,
) -> Future[LayerDataTuple]:
# long running function
def _make_blob():
# skimage.feature may take a while depending on the parameters
blobs = blob_log(
image,
min_sigma=min_sigma,
max_sigma=max_sigma,
num_sigma=num_sigma,
threshold=threshold,
)
data = blobs[:, : image.ndim]
kwargs = dict(
size=blobs[:, -1],
edge_color="red",
edge_width=2,
face_color="transparent",
)
return (data, kwargs, 'points')
return pool.submit(_make_blob)
viewer = napari.Viewer()
viewer.window.add_dock_widget(make_widget(), area="right")
viewer.add_image(data.hubble_deep_field().mean(-1))
napari.run()
pool.shutdown(wait=True)
napari-0.5.0a1/examples/mgui_with_threadworker_.py 0000664 0000000 0000000 00000003432 14370413656 0022327 0 ustar 00root root 0000000 0000000 """
magicgui with threadworker
==========================
An example of calling a threaded function from a magicgui ``dock_widget``.
Note: this example requires python >= 3.9
.. tags:: gui
"""
from magicgui import magic_factory, widgets
from skimage import data
from skimage.feature import blob_log
from typing_extensions import Annotated
import napari
from napari.qt.threading import FunctionWorker, thread_worker
from napari.types import ImageData, LayerDataTuple
@magic_factory(pbar={'visible': False, 'max': 0, 'label': 'working...'})
def make_widget(
pbar: widgets.ProgressBar,
image: ImageData,
min_sigma: Annotated[float, {"min": 0.5, "max": 15, "step": 0.5}] = 5,
max_sigma: Annotated[float, {"min": 1, "max": 200, "step": 0.5}] = 30,
num_sigma: Annotated[int, {"min": 1, "max": 20}] = 10,
threshold: Annotated[float, {"min": 0, "max": 1000, "step": 0.1}] = 6,
) -> FunctionWorker[LayerDataTuple]:
# @thread_worker creates a worker that runs a function in another thread
# we connect the "returned" signal to the ProgressBar.hide method
@thread_worker(connect={'returned': pbar.hide})
def detect_blobs() -> LayerDataTuple:
# this is the potentially long-running function
blobs = blob_log(image, min_sigma, max_sigma, num_sigma, threshold)
points = blobs[:, : image.ndim]
meta = dict(
size=blobs[:, -1],
edge_color="red",
edge_width=2,
face_color="transparent",
)
# return a "LayerDataTuple"
return (points, meta, 'points')
# show progress bar and return worker
pbar.show()
return detect_blobs()
viewer = napari.Viewer()
viewer.window.add_dock_widget(make_widget(), area="right")
viewer.add_image(data.hubble_deep_field().mean(-1))
napari.run()
napari-0.5.0a1/examples/minimum_blending.py 0000664 0000000 0000000 00000002535 14370413656 0020733 0 ustar 00root root 0000000 0000000 """
Minimum blending
================
Demonstrates how to use the `minimum` blending mode with inverted colormaps.
`minimum` blending uses the minimum value of each R, G, B channel for each pixel.
`minimum` blending can be used to yield multichannel color images on a white
background, when the channels have inverted colormaps assigned.
An inverted colormap is one where white [1, 1, 1] is used to represent the lowest
values, as opposed to the more conventional black [0, 0, 0]. For example, try the
colormaps prefixed with *I*, such as *I Forest* or *I Bordeaux*, from
ChrisLUTs: https://github.com/cleterrier/ChrisLUTs .
.. tags:: visualization-basic
"""
from skimage import data
import napari
# create a viewer
viewer = napari.Viewer()
# Add the cells3d example image, using the two inverted colormaps
# and minimum blending mode. Note that the bottom-most layer
# must be translucent or opaque to prevent blending with the canvas.
viewer.add_image(data.cells3d(),
name=["membrane", "nuclei"],
channel_axis=1,
contrast_limits = [[1110, 23855], [1600, 50000]],
colormap = ["I Purple", "I Orange"],
blending= ["translucent_no_depth", "minimum"]
)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/mixed-dimensions-labels.py 0000664 0000000 0000000 00000002003 14370413656 0022120 0 ustar 00root root 0000000 0000000 """
Mixed dimensions labels
=======================
Overlay a 3D segmentation on a 4D time series.
Sometimes, our data have mixed dimensionality. napari "right-aligns" the
dimensions of your data, following NumPy broadcasting conventions [1]_. In this
example, we show how we can see a 3D segmentation overlaid on a 4D dataset. As
we slice through the dataset, the segmentation stays unchanged, but is visible
on every slice.
.. [1] https://numpy.org/doc/stable/user/basics.broadcasting.html
.. tags:: visualization-nD
"""
import numpy as np
from scipy import ndimage as ndi
from skimage.data import binary_blobs
import napari
blobs3d = binary_blobs(length=64, volume_fraction=0.1, n_dim=3).astype(float)
blobs3dt = np.stack([np.roll(blobs3d, 3 * i, axis=2) for i in range(10)])
labels = ndi.label(blobs3dt[5])[0]
viewer = napari.Viewer(ndisplay=3)
image_layer = viewer.add_image(blobs3dt)
labels_layer = viewer.add_labels(labels)
viewer.dims.current_step = (5, 0, 0, 0)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/mouse_drag_callback.py 0000664 0000000 0000000 00000002416 14370413656 0021355 0 ustar 00root root 0000000 0000000 """
Mouse drag callback
===================
Example updating the status bar with line profile info while dragging
lines around in a shapes layer.
.. tags:: gui
"""
import numpy as np
from skimage import data, measure
import napari
def profile_lines(image, shape_layer):
profile_data = [
measure.profile_line(image, line[0], line[1], mode='reflect').mean()
for line in shape_layer.data
]
print(f"profile means: [{', '.join(f'{d:.2f}' for d in profile_data)}]")
np.random.seed(1)
viewer = napari.Viewer()
blobs = data.binary_blobs(length=512, volume_fraction=0.1, n_dim=2)
viewer.add_image(blobs, name='blobs')
line1 = np.array([[11, 13], [111, 113]])
line2 = np.array([[200, 200], [400, 300]])
lines = [line1, line2]
shapes_layer = viewer.add_shapes(
lines,
shape_type='line',
edge_width=5,
edge_color='coral',
face_color='royalblue',
)
shapes_layer.mode = 'select'
@shapes_layer.mouse_drag_callbacks.append
def profile_lines_drag(layer, event):
profile_lines(blobs, layer)
yield
while event.type == 'mouse_move':
profile_lines(blobs, layer)
# the yield statement allows the mouse UI to keep working while
# this loop is executed repeatedly
yield
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/mpl_plot_.py 0000664 0000000 0000000 00000002024 14370413656 0017374 0 ustar 00root root 0000000 0000000 """
Matplotlib plot
===============
.. tags:: gui
"""
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.backends.backend_qt5agg import FigureCanvas
import napari
# create image
x = np.linspace(0, 5, 256)
y = np.linspace(0, 5, 256)[:, np.newaxis]
img = np.sin(x) ** 10 + np.cos(10 + y * x) * np.cos(x)
# add it to the viewer
viewer = napari.view_image(img, colormap='viridis')
layer = viewer.layers[-1]
# create mpl figure with subplots
mpl_fig = plt.figure()
ax = mpl_fig.add_subplot(111)
(line,) = ax.plot(layer.data[123]) # linescan through the middle of the image
# add the figure to the viewer as a FigureCanvas widget
viewer.window.add_dock_widget(FigureCanvas(mpl_fig))
# connect a callback that updates the line plot when
# the user clicks on the image
@layer.mouse_drag_callbacks.append
def profile_lines_drag(layer, event):
try:
line.set_ydata(layer.data[int(event.position[0])])
line.figure.canvas.draw()
except IndexError:
pass
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/multiple_viewer_widget.py 0000664 0000000 0000000 00000035400 14370413656 0022172 0 ustar 00root root 0000000 0000000 """
Multiple viewer widget
======================
This is an example on how to have more than one viewer in the same napari window.
Additional viewers state will be synchronized with the main viewer.
Switching to 3D display will only impact the main viewer.
This example also contain option to enable cross that will be moved to the
current dims point (`viewer.dims.point`).
.. tags:: gui
"""
from copy import deepcopy
import numpy as np
from packaging.version import parse as parse_version
from qtpy.QtCore import Qt
from qtpy.QtWidgets import (
QCheckBox,
QDoubleSpinBox,
QPushButton,
QSplitter,
QTabWidget,
QVBoxLayout,
QWidget,
)
from superqt.utils import qthrottled
import napari
from napari.components.layerlist import Extent
from napari.components.viewer_model import ViewerModel
from napari.layers import Image, Labels, Layer, Vectors
from napari.qt import QtViewer
from napari.utils.action_manager import action_manager
from napari.utils.events.event import WarningEmitter
from napari.utils.notifications import show_info
NAPARI_GE_4_16 = parse_version(napari.__version__) > parse_version("0.4.16")
def copy_layer_le_4_16(layer: Layer, name: str = ""):
res_layer = deepcopy(layer)
# this deepcopy is not optimal for labels and images layers
if isinstance(layer, (Image, Labels)):
res_layer.data = layer.data
res_layer.metadata["viewer_name"] = name
res_layer.events.disconnect()
res_layer.events.source = res_layer
for emitter in res_layer.events.emitters.values():
emitter.disconnect()
emitter.source = res_layer
return res_layer
def copy_layer(layer: Layer, name: str = ""):
if NAPARI_GE_4_16:
return copy_layer_le_4_16(layer, name)
res_layer = Layer.create(*layer.as_layer_data_tuple())
res_layer.metadata["viewer_name"] = name
return res_layer
def get_property_names(layer: Layer):
klass = layer.__class__
res = []
for event_name, event_emitter in layer.events.emitters.items():
if isinstance(event_emitter, WarningEmitter):
continue
if event_name in ("thumbnail", "name"):
continue
if (
isinstance(getattr(klass, event_name, None), property)
and getattr(klass, event_name).fset is not None
):
res.append(event_name)
return res
def center_cross_on_mouse(
viewer_model: napari.components.viewer_model.ViewerModel,
):
"""move the cross to the mouse position"""
if not getattr(viewer_model, "mouse_over_canvas", True):
# There is no way for napari 0.4.15 to check if mouse is over sending canvas.
show_info(
"Mouse is not over the canvas. You may need to click on the canvas."
)
return
viewer_model.dims.current_step = tuple(
np.round(
[
max(min_, min(p, max_)) / step
for p, (min_, max_, step) in zip(
viewer_model.cursor.position, viewer_model.dims.range
)
]
).astype(int)
)
action_manager.register_action(
name='napari:move_point',
command=center_cross_on_mouse,
description='Move dims point to mouse position',
keymapprovider=ViewerModel,
)
action_manager.bind_shortcut('napari:move_point', 'C')
class own_partial:
"""
Workaround for deepcopy not copying partial functions
(Qt widgets are not serializable)
"""
def __init__(self, func, *args, **kwargs) -> None:
self.func = func
self.args = args
self.kwargs = kwargs
def __call__(self, *args, **kwargs):
return self.func(*(self.args + args), **{**self.kwargs, **kwargs})
def __deepcopy__(self, memodict=None):
if memodict is None:
memodict = {}
return own_partial(
self.func,
*deepcopy(self.args, memodict),
**deepcopy(self.kwargs, memodict),
)
class QtViewerWrap(QtViewer):
def __init__(self, main_viewer, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
self.main_viewer = main_viewer
def _qt_open(
self,
filenames: list,
stack: bool,
plugin: str = None,
layer_type: str = None,
**kwargs,
):
"""for drag and drop open files"""
self.main_viewer.window._qt_viewer._qt_open(
filenames, stack, plugin, layer_type, **kwargs
)
class CrossWidget(QCheckBox):
"""
Widget to control the cross layer. because of the performance reason
the cross update is throttled
"""
def __init__(self, viewer: napari.Viewer) -> None:
super().__init__("Add cross layer")
self.viewer = viewer
self.setChecked(False)
self.stateChanged.connect(self._update_cross_visibility)
self.layer = None
self.viewer.dims.events.order.connect(self.update_cross)
self.viewer.dims.events.ndim.connect(self._update_ndim)
self.viewer.dims.events.current_step.connect(self.update_cross)
self._extent = None
self._update_extent()
self.viewer.dims.events.connect(self._update_extent)
@qthrottled(leading=False)
def _update_extent(self):
"""
Calculate the extent of the data.
Ignores the the cross layer itself in calculating the extent.
"""
if NAPARI_GE_4_16:
layers = [
layer
for layer in self.viewer.layers
if layer is not self.layer
]
self._extent = self.viewer.layers.get_extent(layers)
else:
extent_list = [
layer.extent
for layer in self.viewer.layers
if layer is not self.layer
]
self._extent = Extent(
data=None,
world=self.viewer.layers._get_extent_world(extent_list),
step=self.viewer.layers._get_step_size(extent_list),
)
self.update_cross()
def _update_ndim(self, event):
if self.layer in self.viewer.layers:
self.viewer.layers.remove(self.layer)
self.layer = Vectors(name=".cross", ndim=event.value)
self.layer.edge_width = 1.5
self.update_cross()
def _update_cross_visibility(self, state):
if state:
self.viewer.layers.append(self.layer)
else:
self.viewer.layers.remove(self.layer)
self.update_cross()
def update_cross(self):
if self.layer not in self.viewer.layers:
return
point = self.viewer.dims.current_step
vec = []
for i, (lower, upper) in enumerate(self._extent.world.T):
if (upper - lower) / self._extent.step[i] == 1:
continue
point1 = list(point)
point1[i] = (lower + self._extent.step[i] / 2) / self._extent.step[
i
]
point2 = [0 for _ in point]
point2[i] = (upper - lower) / self._extent.step[i]
vec.append((point1, point2))
if np.any(self.layer.scale != self._extent.step):
self.layer.scale = self._extent.step
self.layer.data = vec
class ExampleWidget(QWidget):
"""
Dummy widget showcasing how to place additional widgets to the right
of the additional viewers.
"""
def __init__(self) -> None:
super().__init__()
self.btn = QPushButton("Perform action")
self.spin = QDoubleSpinBox()
layout = QVBoxLayout()
layout.addWidget(self.spin)
layout.addWidget(self.btn)
layout.addStretch(1)
self.setLayout(layout)
class MultipleViewerWidget(QSplitter):
"""The main widget of the example."""
def __init__(self, viewer: napari.Viewer) -> None:
super().__init__()
self.viewer = viewer
self.viewer_model1 = ViewerModel(title="model1")
self.viewer_model2 = ViewerModel(title="model2")
self._block = False
self.qt_viewer1 = QtViewerWrap(viewer, self.viewer_model1)
self.qt_viewer2 = QtViewerWrap(viewer, self.viewer_model2)
self.tab_widget = QTabWidget()
w1 = ExampleWidget()
w2 = ExampleWidget()
self.tab_widget.addTab(w1, "Sample 1")
self.tab_widget.addTab(w2, "Sample 2")
viewer_splitter = QSplitter()
viewer_splitter.setOrientation(Qt.Vertical)
viewer_splitter.addWidget(self.qt_viewer1)
viewer_splitter.addWidget(self.qt_viewer2)
viewer_splitter.setContentsMargins(0, 0, 0, 0)
self.addWidget(viewer_splitter)
self.addWidget(self.tab_widget)
self.viewer.layers.events.inserted.connect(self._layer_added)
self.viewer.layers.events.removed.connect(self._layer_removed)
self.viewer.layers.events.moved.connect(self._layer_moved)
self.viewer.layers.selection.events.active.connect(
self._layer_selection_changed
)
self.viewer.dims.events.current_step.connect(self._point_update)
self.viewer_model1.dims.events.current_step.connect(self._point_update)
self.viewer_model2.dims.events.current_step.connect(self._point_update)
self.viewer.dims.events.order.connect(self._order_update)
self.viewer.events.reset_view.connect(self._reset_view)
self.viewer_model1.events.status.connect(self._status_update)
self.viewer_model2.events.status.connect(self._status_update)
def _status_update(self, event):
self.viewer.status = event.value
def _reset_view(self):
self.viewer_model1.reset_view()
self.viewer_model2.reset_view()
def _layer_selection_changed(self, event):
"""
update of current active layer
"""
if self._block:
return
if event.value is None:
self.viewer_model1.layers.selection.active = None
self.viewer_model2.layers.selection.active = None
return
self.viewer_model1.layers.selection.active = self.viewer_model1.layers[
event.value.name
]
self.viewer_model2.layers.selection.active = self.viewer_model2.layers[
event.value.name
]
def _point_update(self, event):
for model in [self.viewer, self.viewer_model1, self.viewer_model2]:
if model.dims is event.source:
continue
model.dims.current_step = event.value
def _order_update(self):
order = list(self.viewer.dims.order)
if len(order) <= 2:
self.viewer_model1.dims.order = order
self.viewer_model2.dims.order = order
return
order[-3:] = order[-2], order[-3], order[-1]
self.viewer_model1.dims.order = order
order = list(self.viewer.dims.order)
order[-3:] = order[-1], order[-2], order[-3]
self.viewer_model2.dims.order = order
def _layer_added(self, event):
"""add layer to additional viewers and connect all required events"""
self.viewer_model1.layers.insert(
event.index, copy_layer(event.value, "model1")
)
self.viewer_model2.layers.insert(
event.index, copy_layer(event.value, "model2")
)
for name in get_property_names(event.value):
getattr(event.value.events, name).connect(
own_partial(self._property_sync, name)
)
if isinstance(event.value, Labels):
event.value.events.set_data.connect(self._set_data_refresh)
self.viewer_model1.layers[
event.value.name
].events.set_data.connect(self._set_data_refresh)
self.viewer_model2.layers[
event.value.name
].events.set_data.connect(self._set_data_refresh)
if event.value.name != ".cross":
self.viewer_model1.layers[event.value.name].events.data.connect(
self._sync_data
)
self.viewer_model2.layers[event.value.name].events.data.connect(
self._sync_data
)
event.value.events.name.connect(self._sync_name)
self._order_update()
def _sync_name(self, event):
"""sync name of layers"""
index = self.viewer.layers.index(event.source)
self.viewer_model1.layers[index].name = event.source.name
self.viewer_model2.layers[index].name = event.source.name
def _sync_data(self, event):
"""sync data modification from additional viewers"""
if self._block:
return
for model in [self.viewer, self.viewer_model1, self.viewer_model2]:
layer = model.layers[event.source.name]
if layer is event.source:
continue
try:
self._block = True
layer.data = event.source.data
finally:
self._block = False
def _set_data_refresh(self, event):
"""
synchronize data refresh between layers
"""
if self._block:
return
for model in [self.viewer, self.viewer_model1, self.viewer_model2]:
layer = model.layers[event.source.name]
if layer is event.source:
continue
try:
self._block = True
layer.refresh()
finally:
self._block = False
def _layer_removed(self, event):
"""remove layer in all viewers"""
self.viewer_model1.layers.pop(event.index)
self.viewer_model2.layers.pop(event.index)
def _layer_moved(self, event):
"""update order of layers"""
dest_index = (
event.new_index
if event.new_index < event.index
else event.new_index + 1
)
self.viewer_model1.layers.move(event.index, dest_index)
self.viewer_model2.layers.move(event.index, dest_index)
def _property_sync(self, name, event):
"""Sync layers properties (except the name)"""
if event.source not in self.viewer.layers:
return
try:
self._block = True
setattr(
self.viewer_model1.layers[event.source.name],
name,
getattr(event.source, name),
)
setattr(
self.viewer_model2.layers[event.source.name],
name,
getattr(event.source, name),
)
finally:
self._block = False
if __name__ == "__main__":
from qtpy import QtCore, QtWidgets
QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_ShareOpenGLContexts)
# above two lines are needed to allow to undock the widget with
# additional viewers
view = napari.Viewer()
dock_widget = MultipleViewerWidget(view)
cross = CrossWidget(view)
view.window.add_dock_widget(dock_widget, name="Sample")
view.window.add_dock_widget(cross, name="Cross", area="left")
napari.run()
napari-0.5.0a1/examples/multiple_viewers.py 0000664 0000000 0000000 00000000747 14370413656 0021020 0 ustar 00root root 0000000 0000000 """
Multiple viewers
================
Create multiple viewers from the same script
.. tags:: gui
"""
from skimage import data
import napari
# add the image
photographer = data.camera()
viewer_a = napari.view_image(photographer, name='photographer')
# add the image in a new viewer window
astronaut = data.astronaut()
# Also view_path, view_shapes, view_points, view_labels etc.
viewer_b = napari.view_image(astronaut, name='astronaut')
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/multithreading_simple_.py 0000664 0000000 0000000 00000002604 14370413656 0022143 0 ustar 00root root 0000000 0000000 """
Multithreading simple
=====================
.. tags:: interactivity
"""
import time
from qtpy.QtWidgets import QApplication, QHBoxLayout, QLabel, QWidget
from napari.qt import thread_worker
@thread_worker
def long_running_function():
"""Just a long running function, most like viewer.update."""
time.sleep(2) # long function
return 'finished!'
def create_widget():
widget = QWidget()
layout = QHBoxLayout()
widget.setLayout(layout)
widget.status = QLabel('ready...')
layout.addWidget(widget.status)
widget.show()
return widget
if __name__ == "__main__":
app = QApplication([])
wdg = create_widget()
# call decorated function
# By default, @thread_worker-decorated functions do not immediately start
worker = long_running_function()
# Signals are best connected *before* starting the worker.
worker.started.connect(lambda: wdg.status.setText("worker is running..."))
worker.returned.connect(lambda x: wdg.status.setText(f"returned {x}"))
# # Connections may also be passed directly to the decorated function.
# # The above syntax is equivalent to:
# worker = long_running_function(
# _connect={
# 'started': lambda: wdg.status.setText("worker is running..."),
# 'returned': lambda x: wdg.status.setText(f"returned {x!r}"),
# }
# )
worker.start()
app.exec_()
napari-0.5.0a1/examples/multithreading_two_way_.py 0000664 0000000 0000000 00000007251 14370413656 0022346 0 ustar 00root root 0000000 0000000 """
Multithreading two-way
======================
.. tags:: interactivity
"""
import time
import numpy as np
from qtpy.QtWidgets import (
QGridLayout,
QLabel,
QProgressBar,
QPushButton,
QWidget,
)
import napari
from napari.qt.threading import thread_worker
@thread_worker
def two_way_communication_with_args(start, end):
"""Both sends and receives values to & from the main thread.
Accepts arguments, puts them on the worker object.
Receives values from main thread with ``incoming = yield``
Optionally returns a value at the end
"""
# do computationally intensive work here
i = start
while i < end:
i += 1
time.sleep(0.1)
# incoming receives values from the main thread
# while yielding sends values back to the main thread
incoming = yield i
i = incoming if incoming is not None else i
# do optional teardown here
return "done"
class Controller(QWidget):
def __init__(self) -> None:
super().__init__()
layout = QGridLayout()
self.setLayout(layout)
self.status = QLabel('Click "Start"', self)
self.play_btn = QPushButton("Start", self)
self.abort_btn = QPushButton("Abort!", self)
self.reset_btn = QPushButton("Reset", self)
self.progress_bar = QProgressBar()
layout.addWidget(self.play_btn, 0, 0)
layout.addWidget(self.reset_btn, 0, 1)
layout.addWidget(self.abort_btn, 0, 2)
layout.addWidget(self.status, 0, 3)
layout.setColumnStretch(3, 1)
layout.addWidget(self.progress_bar, 1, 0, 1, 4)
def create_connected_widget():
"""Builds a widget that can control a function in another thread."""
w = Controller()
steps = 40
# the decorated function now returns a GeneratorWorker object, and the
# Qthread in which it's running.
# (optionally pass start=False to prevent immediate running)
worker = two_way_communication_with_args(0, steps)
w.play_btn.clicked.connect(worker.start)
# it provides signals like {started, yielded, returned, errored, finished}
worker.returned.connect(lambda x: w.status.setText(f"worker returned {x}"))
worker.errored.connect(lambda x: w.status.setText(f"worker errored {x}"))
worker.started.connect(lambda: w.status.setText("worker started..."))
worker.aborted.connect(lambda: w.status.setText("worker aborted"))
# send values into the function (like generator.send) using worker.send
# abort thread with worker.abort()
w.abort_btn.clicked.connect(lambda: worker.quit())
def on_reset_button_pressed():
# we want to avoid sending into a unstarted worker
if worker.is_running:
worker.send(0)
def on_yield(x):
# Receive events and update widget progress
w.progress_bar.setValue(100 * x // steps)
w.status.setText(f"worker yielded {x}")
def on_start():
def handle_pause():
worker.toggle_pause()
w.play_btn.setText("Pause" if worker.is_paused else "Continue")
w.play_btn.clicked.disconnect(worker.start)
w.play_btn.setText("Pause")
w.play_btn.clicked.connect(handle_pause)
def on_finish():
w.play_btn.setDisabled(True)
w.reset_btn.setDisabled(True)
w.abort_btn.setDisabled(True)
w.play_btn.setText("Done")
w.reset_btn.clicked.connect(on_reset_button_pressed)
worker.yielded.connect(on_yield)
worker.started.connect(on_start)
worker.finished.connect(on_finish)
return w
if __name__ == "__main__":
viewer = napari.view_image(np.random.rand(512, 512))
w = create_connected_widget()
viewer.window.add_dock_widget(w)
napari.run()
napari-0.5.0a1/examples/nD_image.py 0000664 0000000 0000000 00000000731 14370413656 0017115 0 ustar 00root root 0000000 0000000 """
nD image
========
Display one 4-D image layer using the :func:`view_image` API.
.. tags:: visualization-nD
"""
import numpy as np
from skimage import data
import napari
blobs = np.stack(
[
data.binary_blobs(
length=128, blob_size_fraction=0.05, n_dim=3, volume_fraction=f
)
for f in np.linspace(0.05, 0.5, 10)
],
axis=0,
)
viewer = napari.view_image(blobs.astype(float))
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/nD_labels.py 0000664 0000000 0000000 00000001007 14370413656 0017272 0 ustar 00root root 0000000 0000000 """
nD labels
=========
Display a labels layer above of an image layer using the ``add_labels`` and
``add_image`` APIs
.. tags:: visualization-nD
"""
from scipy import ndimage as ndi
from skimage import data
import napari
blobs = data.binary_blobs(length=128, volume_fraction=0.1, n_dim=3)
viewer = napari.view_image(blobs[::2].astype(float), name='blobs', scale=(2, 1, 1))
labeled = ndi.label(blobs)[0]
viewer.add_labels(labeled[::2], name='blob ID', scale=(2, 1, 1))
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/nD_multiscale_image.py 0000664 0000000 0000000 00000001236 14370413656 0021340 0 ustar 00root root 0000000 0000000 """
nD multiscale image
===================
Displays an nD multiscale image
.. tags:: visualization-advanced
"""
import numpy as np
from skimage.transform import pyramid_gaussian
import napari
# create multiscale from random data
base = np.random.random((1536, 1536))
base = np.array([base * (8 - i) / 8 for i in range(8)])
print('base shape', base.shape)
multiscale = list(
pyramid_gaussian(base, downscale=2, max_layer=2, multichannel=False)
)
print('multiscale level shapes: ', [p.shape for p in multiscale])
# add image multiscale
viewer = napari.view_image(multiscale, contrast_limits=[0, 1], multiscale=True)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/nD_multiscale_image_non_uniform.py 0000664 0000000 0000000 00000001336 14370413656 0023752 0 ustar 00root root 0000000 0000000 """
nD multiscale image non-uniform
===============================
Displays an nD multiscale image
.. tags:: visualization-advanced
"""
import numpy as np
from skimage import data
from skimage.transform import pyramid_gaussian
import napari
# create multiscale from astronaut image
astronaut = data.astronaut()
base = np.tile(astronaut, (3, 3, 1))
multiscale = list(
pyramid_gaussian(base, downscale=2, max_layer=3, multichannel=True)
)
multiscale = [
np.array([p * (abs(3 - i) + 1) / 4 for i in range(6)]) for p in multiscale
]
print('multiscale level shapes: ', [p.shape for p in multiscale])
# add image multiscale
viewer = napari.view_image(multiscale, multiscale=True)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/nD_points.py 0000664 0000000 0000000 00000001572 14370413656 0017353 0 ustar 00root root 0000000 0000000 """
nD points
=========
Display one points layer on top of one 4-D image layer using the
add_points and add_image APIs, where the markes are visible as nD objects
across the dimensions, specified by their size
.. tags:: visualization-nD
"""
import numpy as np
from skimage import data
import napari
blobs = np.stack(
[
data.binary_blobs(
length=128, blob_size_fraction=0.05, n_dim=3, volume_fraction=f
)
for f in np.linspace(0.05, 0.5, 10)
],
axis=0,
)
viewer = napari.view_image(blobs.astype(float))
# add the points
points = np.array(
[
[0, 0, 100, 100],
[0, 0, 50, 120],
[1, 0, 100, 40],
[2, 10, 110, 100],
[9, 8, 80, 100],
], dtype=float
)
viewer.add_points(
points, size=[0, 6, 10, 10], face_color='blue', out_of_slice_display=True
)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/nD_points_with_features.py 0000664 0000000 0000000 00000002650 14370413656 0022302 0 ustar 00root root 0000000 0000000 """
nD points with features
=======================
Display one points layer ontop of one 4-D image layer using the
add_points and add_image APIs, where the markes are visible as nD objects
across the dimensions, specified by their size
.. tags:: visualization-nD
"""
import numpy as np
from skimage import data
import napari
blobs = data.binary_blobs(
length=100, blob_size_fraction=0.05, n_dim=3, volume_fraction=0.05
)
viewer = napari.view_image(blobs.astype(float))
# create the points
points = []
for z in range(blobs.shape[0]):
points += [[z, 25, 25], [z, 25, 75], [z, 75, 25], [z, 75, 75]]
# create the features for setting the face and edge color.
face_feature = np.array(
[True, True, True, True, False, False, False, False]
* int(blobs.shape[0] / 2)
)
edge_feature = np.array(['A', 'B', 'C', 'D', 'E'] * int(len(points) / 5))
features = {
'face_feature': face_feature,
'edge_feature': edge_feature,
}
points_layer = viewer.add_points(
points,
features=features,
size=3,
edge_width=5,
edge_width_is_relative=False,
edge_color='edge_feature',
face_color='face_feature',
out_of_slice_display=False,
)
# change the face color cycle
points_layer.face_color_cycle = ['white', 'black']
# change the edge_color cycle.
# there are 4 colors for 5 categories, so 'c' will be recycled
points_layer.edge_color_cycle = ['c', 'm', 'y', 'k']
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/nD_shapes.py 0000664 0000000 0000000 00000003017 14370413656 0017316 0 ustar 00root root 0000000 0000000 """
nD shapes
=========
Display one 4-D image layer using the ``add_image`` API
.. tags:: visualization-nD
"""
import numpy as np
from skimage import data
import napari
blobs = data.binary_blobs(
length=128, blob_size_fraction=0.05, n_dim=3, volume_fraction=0.1
).astype(float)
viewer = napari.view_image(blobs.astype(float))
# create one random polygon per "plane"
planes = np.tile(np.arange(128).reshape((128, 1, 1)), (1, 5, 1))
np.random.seed(0)
corners = np.random.uniform(0, 128, size=(128, 5, 2))
shapes = np.concatenate((planes, corners), axis=2)
base_cols = ['red', 'green', 'blue', 'white', 'yellow', 'magenta', 'cyan']
colors = np.random.choice(base_cols, size=128)
layer = viewer.add_shapes(
np.array(shapes),
shape_type='polygon',
face_color=colors,
name='sliced',
)
masks = layer.to_masks(mask_shape=(128, 128, 128))
labels = layer.to_labels(labels_shape=(128, 128, 128))
shape_array = np.array(layer.data)
print(
f'sliced: nshapes {layer.nshapes}, mask shape {masks.shape}, '
f'labels_shape {labels.shape}, array_shape, {shape_array.shape}'
)
corners = np.random.uniform(0, 128, size=(2, 2))
layer = viewer.add_shapes(corners, shape_type='rectangle', name='broadcasted')
masks = layer.to_masks(mask_shape=(128, 128))
labels = layer.to_labels(labels_shape=(128, 128))
shape_array = np.array(layer.data)
print(
f'broadcast: nshapes {layer.nshapes}, mask shape {masks.shape}, '
f'labels_shape {labels.shape}, array_shape, {shape_array.shape}'
)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/nD_shapes_with_text.py 0000664 0000000 0000000 00000001227 14370413656 0021416 0 ustar 00root root 0000000 0000000 """
nD shapes with text
===================
.. tags:: visualization-nD
"""
from skimage import data
import napari
blobs = data.binary_blobs(
length=100, blob_size_fraction=0.05, n_dim=3, volume_fraction=0.03
).astype(float)
viewer = napari.view_image(blobs.astype(float), ndisplay=3)
n = 50
shape = [[[n, 40, 40], [n, 40, 60], [n + 20, 60, 60], [n + 20, 60, 40]]]
features = {'z_index': [n]}
text = {'string': 'z_index', 'color': 'green', 'anchor': 'upper_left'}
shapes_layer = viewer.add_shapes(
shape,
edge_color=[0, 1, 0, 1],
face_color='transparent',
features=features,
text=text,
)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/nD_surface.py 0000664 0000000 0000000 00000000677 14370413656 0017474 0 ustar 00root root 0000000 0000000 """
nD surface
==========
Display a 3D surface
.. tags:: visualization-nD
"""
import numpy as np
import napari
# create the viewer and window
viewer = napari.Viewer(ndisplay=3)
data = np.array([[0, 0, 0], [0, 20, 10], [10, 0, -10], [10, 10, -10]])
faces = np.array([[0, 1, 2], [1, 2, 3]])
values = np.linspace(0, 1, len(data))
# add the surface
layer = viewer.add_surface((data, faces, values))
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/nD_vectors.py 0000664 0000000 0000000 00000002617 14370413656 0017525 0 ustar 00root root 0000000 0000000 """
nD vectors
==========
Display two vectors layers ontop of a 4-D image layer. One of the vectors
layers is 3D and "sliced" with a different set of vectors appearing on
different 3D slices. Another is 2D and "broadcast" with the same vectors
apprearing on each slice.
.. tags:: visualization-nD
"""
import numpy as np
from skimage import data
import napari
blobs = np.stack(
[
data.binary_blobs(
length=128, blob_size_fraction=0.05, n_dim=3, volume_fraction=f
)
for f in np.linspace(0.05, 0.5, 10)
],
axis=0,
)
viewer = napari.view_image(blobs.astype(float))
# sample vector coord-like data
n = 200
pos = np.zeros((n, 2, 2), dtype=np.float32)
phi_space = np.linspace(0, 4 * np.pi, n)
radius_space = np.linspace(0, 20, n)
# assign x-y position
pos[:, 0, 0] = radius_space * np.cos(phi_space) + 64
pos[:, 0, 1] = radius_space * np.sin(phi_space) + 64
# assign x-y projection
pos[:, 1, 0] = 2 * radius_space * np.cos(phi_space)
pos[:, 1, 1] = 2 * radius_space * np.sin(phi_space)
planes = np.round(np.linspace(0, 128, n)).astype(int)
planes = np.concatenate(
(planes.reshape((n, 1, 1)), np.zeros((n, 1, 1))), axis=1
)
vectors = np.concatenate((planes, pos), axis=2)
# add the sliced vectors
layer = viewer.add_vectors(
vectors, edge_width=0.4, name='sliced vectors', edge_color='blue'
)
viewer.dims.ndisplay = 3
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/nD_vectors_image.py 0000664 0000000 0000000 00000001515 14370413656 0020663 0 ustar 00root root 0000000 0000000 """
nD vectors image
================
This example generates an image of vectors
Vector data is an array of shape (M, N, P, 3)
Each vector position is defined by an (x-proj, y-proj, z-proj) element
which are vector projections centered on a pixel of the MxNxP grid
.. tags:: visualization-nD
"""
import numpy as np
import napari
# create the viewer and window
viewer = napari.Viewer()
m = 10
n = 20
p = 40
image = 0.2 * np.random.random((m, n, p)) + 0.5
layer = viewer.add_image(image, contrast_limits=[0, 1], name='background')
# sample vector image-like data
# n x m grid of slanted lines
# random data on the open interval (-1, 1)
pos = np.random.uniform(-1, 1, size=(m, n, p, 3))
print(image.shape, pos.shape)
# add the vectors
vect = viewer.add_vectors(pos, edge_width=0.2, length=2.5)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/new_theme.py 0000664 0000000 0000000 00000001643 14370413656 0017370 0 ustar 00root root 0000000 0000000 """
New theme
=========
Displays an image and sets the theme to new custom theme.
.. tags:: experimental
"""
from skimage import data
import napari
from napari.utils.theme import available_themes, get_theme, register_theme
# create the viewer with an image
viewer = napari.view_image(data.astronaut(), rgb=True, name='astronaut')
# List themes
print('Originally themes', available_themes())
blue_theme = get_theme('dark', False)
blue_theme.id = "blue"
blue_theme.icon = (
'rgb(0, 255, 255)' # you can provide colors as rgb(XXX, YYY, ZZZ)
)
blue_theme.background = 28, 31, 48 # or as tuples
blue_theme.foreground = [45, 52, 71] # or as list
blue_theme.primary = '#50586c' # or as hexes
blue_theme.current = 'orange' # or as color name
register_theme('blue', blue_theme, "custom")
# List themes
print('New themes', available_themes())
# Set theme
viewer.theme = 'blue'
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/notebook.ipynb 0000664 0000000 0000000 00000002267 14370413656 0017731 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Display an image using Napari"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Initial setup"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from skimage import data\n",
"import napari"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Display an image"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"viewer = napari.view_image(data.moon())"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.3"
}
},
"nbformat": 4,
"nbformat_minor": 2
} napari-0.5.0a1/examples/paint-nd.py 0000664 0000000 0000000 00000001321 14370413656 0017120 0 ustar 00root root 0000000 0000000 """
Paint nD
========
Display a 4D labels layer and paint only in 3D.
This is useful e.g. when proofreading segmentations within a time series.
.. tags:: analysis
"""
import numpy as np
from skimage import data
import napari
blobs = np.stack(
[
data.binary_blobs(
length=128, blob_size_fraction=0.05, n_dim=3, volume_fraction=f
)
for f in np.linspace(0.05, 0.5, 10)
],
axis=0,
)
viewer = napari.view_image(blobs.astype(float), rendering='attenuated_mip')
labels = viewer.add_labels(np.zeros_like(blobs, dtype=np.int32))
labels.n_edit_dimensions = 3
labels.brush_size = 15
labels.mode = 'paint'
labels.n_dimensional = True
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/pass_colormaps.py 0000664 0000000 0000000 00000001136 14370413656 0020437 0 ustar 00root root 0000000 0000000 """
Pass colormaps
==============
Add named or unnamed vispy colormaps to existing layers.
.. tags:: visualization-basic
"""
import numpy as np
from skimage import data
import napari
histo = data.astronaut() / 255
rch, gch, bch = np.transpose(histo, (2, 0, 1))
v = napari.Viewer()
rlayer = v.add_image(
rch, name='red channel', colormap='red', blending='additive'
)
glayer = v.add_image(
gch, name='green channel', colormap='green', blending='additive'
)
blayer = v.add_image(
bch, name='blue channel', colormap='blue', blending='additive'
)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/point_cloud.py 0000664 0000000 0000000 00000001003 14370413656 0017722 0 ustar 00root root 0000000 0000000 """
Point cloud
===========
Display 3D points with combinations of different renderings.
.. tags:: visualization-basic
"""
import numpy as np
import napari
n_points = 100
points = np.random.normal(10, 100, (n_points, 3))
symbols = np.random.choice(['o', 's', '*'], n_points)
sizes = np.random.rand(n_points) * 10 + 10
colors = np.random.rand(n_points, 3)
viewer = napari.Viewer(ndisplay=3)
viewer.add_points(points, symbol=symbols, size=sizes, face_color=colors)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/points-over-time.py 0000664 0000000 0000000 00000002164 14370413656 0020635 0 ustar 00root root 0000000 0000000 """
Points over time
================
.. tags:: visualization-advanced
"""
import dask.array as da
import numpy as np
import napari
image4d = da.random.random(
(4000, 32, 256, 256),
chunks=(1, 32, 256, 256),
)
pts_coordinates = np.random.random((50000, 3)) * image4d.shape[1:]
pts_values = da.random.random((50000, 4000), chunks=(50000, 1))
viewer = napari.Viewer(ndisplay=3)
image_layer = viewer.add_image(
image4d, opacity=0.5
)
pts_layer = viewer.add_points(
pts_coordinates,
features={'value': np.asarray(pts_values[:, 0])},
face_color='value',
size=2,
)
def set_pts_features(pts_layer, values_table, step):
# step is a 4D coordinate with the current slider position for each dim
column = step[0] # grab the leading ("time") coordinate
pts_layer.features['value'] = np.asarray(values_table[:, column])
pts_layer.face_color = 'value' # force features refresh
viewer.dims.events.current_step.connect(
lambda event: set_pts_features(pts_layer, pts_values, event.value)
)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/progress_bar_minimal_.py 0000664 0000000 0000000 00000006530 14370413656 0021752 0 ustar 00root root 0000000 0000000 """
Progress bar minimal
====================
This file provides minimal working examples of progress bars in
the napari viewer.
.. tags:: gui
"""
from random import choice
from time import sleep
import numpy as np
from qtpy.QtWidgets import QPushButton, QVBoxLayout, QWidget
import napari
from napari.utils import progress
def process(im_slice):
# do something with your image slice
sleep(0.4)
def iterable():
"""using progress as a wrapper for iterables
"""
my_stacked_volume = np.random.random((5, 4, 500, 500))
# we can wrap any iterable object in `progress` and see a progress
# bar in the viewer
for im_slice in progress(my_stacked_volume):
process(im_slice)
def iterable_w_context():
"""using progress with a context manager
"""
my_stacked_volume = np.random.random((5, 4, 500, 500))
# progress provides a context manager we can use for automatic
# teardown of our widget once iteration is complete. Wherever
# possible, we should *always* use progress within a context
with progress(my_stacked_volume) as pbr:
for i, im_slice in enumerate(pbr):
# using a context manager also allows us to manipulate
# the progress object e.g. by setting a description
pbr.set_description(f"Slice {i}")
# we can group progress bars together in the viewer
# by passing a parent progress bar to new progress
# objects' nest_under attribute
for channel in progress(im_slice, nest_under=pbr):
process(channel)
def indeterminate():
"""By passing a total of 0, we can have an indeterminate progress bar
"""
# note progress(total=0) is equivalent to progress()
with progress(total=0) as pbr:
x = 0
while x != 42:
pbr.set_description(f"Processing {x}")
x = choice(range(100))
sleep(0.05)
def arbitrary_steps():
"""We can manually control updating the value of the progress bar.
"""
with progress(total=4) as pbr:
sleep(3)
pbr.set_description("Step 1 Complete")
# manually updating the progress bar by 1
pbr.update(1)
sleep(1)
pbr.set_description("Step 2 Complete")
pbr.update(1)
sleep(2)
pbr.set_description("Processing Complete!")
# we can manually update by any number of steps
pbr.update(2)
# sleeping so we can see full completion
sleep(1)
viewer = napari.Viewer()
button_layout = QVBoxLayout()
iterable_btn = QPushButton("Iterable")
iterable_btn.clicked.connect(iterable)
button_layout.addWidget(iterable_btn)
iterable_context_btn = QPushButton("Iterable With Context")
iterable_context_btn.clicked.connect(iterable_w_context)
button_layout.addWidget(iterable_context_btn)
indeterminate_btn = QPushButton("Indeterminate")
indeterminate_btn.clicked.connect(indeterminate)
button_layout.addWidget(indeterminate_btn)
steps_btn = QPushButton("Arbitrary Steps")
steps_btn.clicked.connect(arbitrary_steps)
button_layout.addWidget(steps_btn)
pbar_widget = QWidget()
pbar_widget.setLayout(button_layout)
pbar_widget.setObjectName("Progress Examples")
viewer.window.add_dock_widget(pbar_widget)
# showing the activity dock so we can see the progress bars
viewer.window._status_bar._toggle_activity_dock(True)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/progress_bar_segmentation_.py 0000664 0000000 0000000 00000012032 14370413656 0023013 0 ustar 00root root 0000000 0000000 """
Progress bar segmentation
=========================
Use napari's tqdm wrapper to display the progress of long-running operations
in the viewer.
.. tags:: gui
"""
import numpy as np
from qtpy.QtWidgets import QPushButton, QVBoxLayout, QWidget
from skimage.filters import (
threshold_isodata,
threshold_li,
threshold_otsu,
threshold_triangle,
threshold_yen,
)
from skimage.measure import label
import napari
from napari.utils import progress
# we will try each of these thresholds on our image
all_thresholds = [
threshold_isodata,
threshold_li,
threshold_otsu,
threshold_triangle,
threshold_yen,
]
viewer = napari.Viewer()
# load cells data and take just nuclei
membrane, cell_nuclei = viewer.open_sample('napari', 'cells3d')
cell_nuclei = cell_nuclei.data
def try_thresholds():
"""Tries each threshold, and adds result to viewer."""
if 'Binarised' in viewer.layers:
del viewer.layers['Binarised']
thresholded_nuclei = []
# we wrap our iterable with `progress`
# this will automatically add a progress bar to our activity dock
for threshold_func in progress(all_thresholds):
current_threshold = threshold_func(cell_nuclei)
binarised_im = cell_nuclei > current_threshold
thresholded_nuclei.append(binarised_im)
# uncomment if processing is too fast
# from time import sleep
# sleep(0.5)
# working with a wrapped iterable, the progress bar will be closed
# as soon as the iteration is complete
binarised_nuclei = np.stack(thresholded_nuclei)
viewer.add_labels(
binarised_nuclei,
color={1: 'lightgreen'},
opacity=0.7,
name="Binarised",
blending='translucent',
)
# In the previous example, we were able to see the progress bar, but were not
# able to control it. By using `progress` within a context manager, we can
# manipulate the `progress` object and still get the benefit of automatic
# clean up
def segment_binarised_ims():
"""Segments each of the binarised ims.
Uses `progress` within a context manager allowing us to manipulate
the progress bar within the loop
"""
if 'Binarised' not in viewer.layers:
raise TypeError("Cannot segment before thresholding")
if 'Segmented' in viewer.layers:
del viewer.layers['Segmented']
binarised_data = viewer.layers['Binarised'].data
segmented_nuclei = []
# using the `with` keyword we can use `progress` inside a context manager
# `progress` inherits from tqdm and therefore provides the same API
# e.g. we can provide the miniters argument if we want to see the
# progress bar update with each iteration
with progress(binarised_data, miniters=0) as pbar:
for i, binarised_cells in enumerate(pbar):
# this allows us to manipulate the pbar object within the loop
# e.g. setting the description.
pbar.set_description(all_thresholds[i].__name__.split("_")[1])
labelled_im = label(binarised_cells)
segmented_nuclei.append(labelled_im)
# uncomment if processing is too fast
# from time import sleep
# sleep(0.5)
# progress bar is still automatically closed
segmented_nuclei = np.stack(segmented_nuclei)
viewer.add_labels(
segmented_nuclei,
name="Segmented",
blending='translucent',
)
viewer.layers['Binarised'].visible = False
# we can also manually control `progress` objects using their
# `update` method (inherited from tqdm)
def process_ims():
"""
First performs thresholding, then segmentation on our image.
Manually updates a `progress` object.
"""
if 'Binarised' in viewer.layers:
del viewer.layers['Binarised']
if 'Segmented' in viewer.layers:
del viewer.layers['Segmented']
# we instantiate a manually controlled `progress` object
# by just passing a total with no iterable
with progress(total=2) as pbar:
pbar.set_description("Thresholding")
try_thresholds()
# once one processing step is complete, we increment
# the value of our progress bar
pbar.update(1)
pbar.set_description("Segmenting")
segment_binarised_ims()
pbar.update(1)
# uncomment this line to see the 100% progress bar
# from time import sleep
# sleep(0.5)
button_layout = QVBoxLayout()
process_btn = QPushButton("Full Process")
process_btn.clicked.connect(process_ims)
button_layout.addWidget(process_btn)
thresh_btn = QPushButton("1.Threshold")
thresh_btn.clicked.connect(try_thresholds)
button_layout.addWidget(thresh_btn)
segment_btn = QPushButton("2.Segment")
segment_btn.clicked.connect(segment_binarised_ims)
button_layout.addWidget(segment_btn)
action_widget = QWidget()
action_widget.setLayout(button_layout)
action_widget.setObjectName("Segmentation")
viewer.window.add_dock_widget(action_widget)
# showing the activity dock so we can see the progress bars
viewer.window._status_bar._toggle_activity_dock(True)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/progress_bar_threading_.py 0000664 0000000 0000000 00000005267 14370413656 0022277 0 ustar 00root root 0000000 0000000 """
Progress bar threading
======================
This file provides a minimal working example using a progress bar alongside
``@thread_worker`` to report progress.
.. tags:: interactivity
"""
from time import sleep
from qtpy.QtWidgets import QPushButton, QVBoxLayout, QWidget
import napari
from napari.qt import thread_worker
viewer = napari.Viewer()
def handle_yields(yielded_val):
print(f"Just yielded: {yielded_val}")
# generator thread workers can provide progress updates on each yield
@thread_worker(
# passing a progress dictionary with the total number of expected yields
# will place a progress bar in the activity dock and increment its value
# with each yield. We can optionally pass a description for the bar
# using the 'desc' key.
progress={'total': 5, 'desc': 'thread-progress'},
# this does not preclude us from connecting other functions to any of the
# worker signals (including `yielded`)
connect={'yielded': handle_yields},
)
def my_long_running_thread(*_):
for i in range(5):
sleep(0.1)
yield i
@thread_worker(
# If we are unsure of the number of expected yields,
# we can still pass an estimate to total,
# and the progress bar will become indeterminate
# once this number is exceeded.
progress={'total': 5},
# we can also get a simple indeterminate progress bar
# by passing progress=True
connect={'yielded': handle_yields},
)
def my_indeterminate_thread(*_):
for i in range(10):
sleep(0.1)
yield i
def return_func(return_val):
print(f"Returned: {return_val}")
# finally, a FunctionWorker can still provide an indeterminate
# progress bar, but will not take a total>0
@thread_worker(
progress={'total': 0, 'desc': 'FunctionWorker'},
# can use progress=True if not passing description
connect={'returned': return_func},
)
def my_function(*_):
sum = 0
for i in range(10):
sum += i
sleep(0.1)
return sum
button_layout = QVBoxLayout()
start_btn = QPushButton("Start")
start_btn.clicked.connect(my_long_running_thread)
button_layout.addWidget(start_btn)
start_btn2 = QPushButton("Start Indeterminate")
start_btn2.clicked.connect(my_indeterminate_thread)
button_layout.addWidget(start_btn2)
start_btn3 = QPushButton("Start FunctionWorker")
start_btn3.clicked.connect(my_function)
button_layout.addWidget(start_btn3)
pbar_widget = QWidget()
pbar_widget.setLayout(button_layout)
pbar_widget.setObjectName("Threading Examples")
viewer.window.add_dock_widget(pbar_widget, allowed_areas=["right"])
# showing the activity dock so we can see the progress bars
viewer.window._status_bar._toggle_activity_dock(True)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/reader_plugin.py 0000664 0000000 0000000 00000001620 14370413656 0020230 0 ustar 00root root 0000000 0000000 """
Reader plugin
=============
Barebones reader plugin example, using ``imageio.imread```
.. tags:: historical
"""
from imageio import formats, imread
from napari_plugin_engine import napari_hook_implementation
readable_extensions = tuple({x for f in formats for x in f.extensions})
@napari_hook_implementation
def napari_get_reader(path):
"""A basic implementation of the napari_get_reader hook specification."""
# if we know we cannot read the file, we immediately return None.
if not path.endswith(readable_extensions):
return None
# otherwise we return the *function* that can read ``path``.
return reader_function
def reader_function(path):
"""Take a path and returns a list of LayerData tuples."""
data = imread(path)
# Readers are expected to return data as a list of tuples, where each tuple
# is (data, [meta_dict, [layer_type]])
return [(data,)]
napari-0.5.0a1/examples/scale_bar.py 0000664 0000000 0000000 00000000634 14370413656 0017327 0 ustar 00root root 0000000 0000000 """
Scale bar
=========
Display a 3D volume and the scale bar
.. tags:: experimental
"""
from skimage import data
import napari
cells = data.cells3d()
viewer = napari.Viewer(ndisplay=3)
viewer.add_image(
cells,
name=('membrane', 'nuclei'),
channel_axis=1,
scale=(0.29, 0.26, 0.26),
)
viewer.scale_bar.visible = True
viewer.scale_bar.unit = "um"
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/set_colormaps.py 0000664 0000000 0000000 00000001602 14370413656 0020262 0 ustar 00root root 0000000 0000000 """
Set colormaps
=============
Add named or unnamed vispy colormaps to existing layers.
.. tags:: visualization-basic
"""
import numpy as np
import vispy.color
from skimage import data
import napari
histo = data.astronaut() / 255
rch, gch, bch = np.transpose(histo, (2, 0, 1))
red = vispy.color.Colormap([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]])
green = vispy.color.Colormap([[0.0, 0.0, 0.0], [0.0, 1.0, 0.0]])
blue = vispy.color.Colormap([[0.0, 0.0, 0.0], [0.0, 0.0, 1.0]])
v = napari.Viewer()
rlayer = v.add_image(rch, name='red channel')
rlayer.blending = 'additive'
rlayer.colormap = 'red', red
glayer = v.add_image(gch, name='green channel')
glayer.blending = 'additive'
glayer.colormap = green # this will appear as [unnamed colormap]
blayer = v.add_image(bch, name='blue channel')
blayer.blending = 'additive'
blayer.colormap = {'blue': blue}
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/set_theme.py 0000664 0000000 0000000 00000000522 14370413656 0017365 0 ustar 00root root 0000000 0000000 """
Set theme
=========
Displays an image and sets the theme to 'light'.
.. tags:: gui
"""
from skimage import data
import napari
# create the viewer with an image
viewer = napari.view_image(data.astronaut(), rgb=True, name='astronaut')
# set the theme to 'light'
viewer.theme = 'light'
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/shapes_to_labels.py 0000664 0000000 0000000 00000004361 14370413656 0020724 0 ustar 00root root 0000000 0000000 """
Shapes to labels
================
Display one shapes layer ontop of one image layer using the ``add_shapes`` and
``add_image`` APIs. When the window is closed it will print the coordinates of
your shapes.
.. tags:: historical
"""
import numpy as np
from skimage import data
from vispy.color import Colormap
import napari
# create the viewer and window
viewer = napari.Viewer()
# add the image
img_layer = viewer.add_image(data.camera(), name='photographer')
# create a list of polygons
polygons = [
np.array([[11, 13], [111, 113], [22, 246]]),
np.array(
[
[505, 60],
[402, 71],
[383, 42],
[251, 95],
[212, 59],
[131, 137],
[126, 187],
[191, 204],
[171, 248],
[211, 260],
[273, 243],
[264, 225],
[430, 173],
[512, 160],
]
),
np.array(
[
[310, 382],
[229, 381],
[209, 401],
[221, 411],
[258, 411],
[300, 412],
[306, 435],
[268, 434],
[265, 454],
[298, 461],
[307, 461],
[307, 507],
[349, 510],
[352, 369],
[330, 366],
[330, 366],
]
),
]
# add polygons
layer = viewer.add_shapes(
polygons,
shape_type='polygon',
edge_width=1,
edge_color='coral',
face_color='royalblue',
name='shapes',
)
# change some attributes of the layer
layer.selected_data = set(range(layer.nshapes))
layer.current_edge_width = 5
layer.opacity = 0.75
layer.selected_data = set()
# add an ellipse to the layer
ellipse = np.array([[59, 222], [110, 289], [170, 243], [119, 176]])
layer.add(
ellipse,
shape_type='ellipse',
edge_width=5,
edge_color='coral',
face_color='purple',
)
masks = layer.to_masks([512, 512])
masks_layer = viewer.add_image(masks.astype(float), name='masks')
masks_layer.opacity = 0.7
masks_layer.colormap = Colormap([[0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 1.0]])
labels = layer.to_labels([512, 512])
labels_layer = viewer.add_labels(labels, name='labels')
labels_layer.visible = False
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/show_points_based_on_feature.py 0000664 0000000 0000000 00000001705 14370413656 0023335 0 ustar 00root root 0000000 0000000 """
Show points based on feature
============================
.. tags:: visualization-advanced
"""
#!/usr/bin/env python3
import numpy as np
from magicgui import magicgui
import napari
# create points with a randomized "confidence" feature
points = np.random.rand(100, 3) * 100
colors = np.random.rand(100, 3)
confidence = np.random.rand(100)
viewer = napari.Viewer(ndisplay=3)
points = viewer.add_points(
points, face_color=colors, features={'confidence': confidence}
)
# create a simple widget with magicgui which provides a slider that controls the visilibility
# of individual points based on their "confidence" value
@magicgui(
auto_call=True,
threshold={'widget_type': 'FloatSlider', 'min': 0, 'max': 1}
)
def confidence_slider(layer: napari.layers.Points, threshold=0.5):
layer.shown = layer.features['confidence'] > threshold
viewer.window.add_dock_widget(confidence_slider)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/spheres_.py 0000664 0000000 0000000 00000000751 14370413656 0017224 0 ustar 00root root 0000000 0000000 """
Spheres
=======
Display two spheres with Surface layers
.. tags:: visualization-advanced
"""
from vispy.geometry import create_sphere
import napari
mesh = create_sphere(method='ico')
faces = mesh.get_faces()
vert = mesh.get_vertices() * 100
sphere1 = (vert + 30, faces)
sphere2 = (vert - 30, faces)
viewer = napari.Viewer(ndisplay=3)
surface1 = viewer.add_surface(sphere1)
surface2 = viewer.add_surface(sphere2)
viewer.reset_view()
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/spherical_points.py 0000664 0000000 0000000 00000001076 14370413656 0020763 0 ustar 00root root 0000000 0000000 """
Spherical points
================
.. tags:: experimental
"""
import numpy as np
import napari
np.random.seed()
pts = np.random.rand(100, 3) * 100
colors = np.random.rand(100, 3)
sizes = np.random.rand(100) * 20 + 10
viewer = napari.Viewer(ndisplay=3)
pts_layer = viewer.add_points(
pts,
face_color=colors,
size=sizes,
shading='spherical',
edge_width=0,
)
# antialiasing is currently a bit broken, this is especially bad in 3D so
# we turn it off here
pts_layer.antialiasing = 0
viewer.reset_view()
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/surface_normals_wireframe.py 0000664 0000000 0000000 00000001216 14370413656 0022635 0 ustar 00root root 0000000 0000000 """
Surface normals wireframe
=========================
Display a 3D mesh with normals and wireframe
.. tags:: experimental
"""
from vispy.io import load_data_file, read_mesh
import napari
vert, faces, _, _ = read_mesh(load_data_file('orig/triceratops.obj.gz'))
# put the mesh right side up, scale it up (napari#3477) and fix faces handedness
vert *= -100
faces = faces[:, ::-1]
viewer = napari.Viewer(ndisplay=3)
surface = viewer.add_surface(data=(vert, faces))
# enable normals and wireframe
surface.normals.face.visible = True
surface.normals.vertex.visible = True
surface.wireframe.visible = True
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/surface_timeseries_.py 0000664 0000000 0000000 00000002506 14370413656 0021434 0 ustar 00root root 0000000 0000000 """
Surface timeseries
==================
Display a surface timeseries using data from nilearn
.. tags:: experimental
"""
try:
from nilearn import datasets, surface
except ModuleNotFoundError:
raise ModuleNotFoundError(
"You must have nilearn installed to run this example."
) from None
import napari
# Fetch datasets - this will download dataset if datasets are not found
nki_dataset = datasets.fetch_surf_nki_enhanced(n_subjects=1)
fsaverage = datasets.fetch_surf_fsaverage()
# Load surface data and resting state time series from nilearn
brain_vertices, brain_faces = surface.load_surf_data(fsaverage['pial_left'])
brain_vertex_depth = surface.load_surf_data(fsaverage['sulc_left'])
timeseries = surface.load_surf_data(nki_dataset['func_left'][0])
# nilearn provides data as n_vertices x n_timepoints, but napari requires the
# vertices axis to be placed last to match NumPy broadcasting rules
timeseries = timeseries.transpose((1, 0))
# create an empty viewer
viewer = napari.Viewer(ndisplay=3)
# add the mri
viewer.add_surface((brain_vertices, brain_faces, brain_vertex_depth), name='base')
viewer.add_surface((brain_vertices, brain_faces, timeseries),
colormap='turbo', opacity=0.9,
contrast_limits=[-1.5, 3.5], name='timeseries')
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/swap_dims.py 0000664 0000000 0000000 00000001432 14370413656 0017377 0 ustar 00root root 0000000 0000000 """
Swap dims
=========
Display a 4-D image and points layer and swap the displayed dimensions
.. tags:: visualization-nD
"""
import numpy as np
from skimage import data
import napari
blobs = np.stack(
[
data.binary_blobs(
length=128, blob_size_fraction=0.05, n_dim=3, volume_fraction=f
)
for f in np.linspace(0.05, 0.5, 10)
],
axis=0,
)
viewer = napari.view_image(blobs.astype(float))
# add the points
points = np.array(
[
[0, 0, 0, 100],
[0, 0, 50, 120],
[1, 0, 100, 40],
[2, 10, 110, 100],
[9, 8, 80, 100],
]
)
viewer.add_points(
points, size=[0, 6, 10, 10], face_color='blue', out_of_slice_display=True
)
viewer.dims.order = (0, 2, 1, 3)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/tiled-rendering-2d_.py 0000664 0000000 0000000 00000002611 14370413656 0021127 0 ustar 00root root 0000000 0000000 """
Tiled rendering 2D
==================
This example shows how to display tiled, chunked data in napari using the
experimental octree support.
If given a large 2D image with octree support enabled, napari will only load
and display the tiles in the center of the current canvas view. (Note: napari
uses its own internal tile size that may or may not be aligned with the
underlying tiled data, but this should have only minor performance
consequences.)
If octree support is *not* enabled, napari will try to load the entire image,
which may not fit in memory and may bring your computer to a halt. Oops! So, we
make sure that we enable octree support by setting the NAPARI_OCTREE
environment variable to 1 if it is not set by the user.
.. tags:: experimental
"""
import os
# important: if this is not set, the entire ~4GB array will be created!
os.environ.setdefault('NAPARI_OCTREE', '1')
import dask.array as da # noqa: E402
import napari # noqa: E402
ndim = 2
data = da.random.randint(
0, 256, (65536,) * ndim,
chunks=(256,) * ndim,
dtype='uint8'
)
viewer = napari.Viewer()
viewer.add_image(data, contrast_limits=[0, 255])
# To turn off grid lines
#viewer.layers[0].display.show_grid = False
# set small zoom so we don't try to load the whole image at once
viewer.camera.zoom = 0.75
# run the example — try to pan around!
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/to_screenshot.py 0000664 0000000 0000000 00000006021 14370413656 0020267 0 ustar 00root root 0000000 0000000 """
To screenshot
=============
Display one shapes layer ontop of one image layer using the ``add_shapes`` and
``add_image`` APIs. When the window is closed it will print the coordinates of
your shapes.
.. tags:: visualization-advanced
"""
import numpy as np
from skimage import data
from vispy.color import Colormap
import napari
# create the viewer and window
viewer = napari.Viewer()
# add the image
img_layer = viewer.add_image(data.camera(), name='photographer')
img_layer.colormap = 'gray'
# create a list of polygons
polygons = [
np.array([[11, 13], [111, 113], [22, 246]]),
np.array(
[
[505, 60],
[402, 71],
[383, 42],
[251, 95],
[212, 59],
[131, 137],
[126, 187],
[191, 204],
[171, 248],
[211, 260],
[273, 243],
[264, 225],
[430, 173],
[512, 160],
]
),
np.array(
[
[310, 382],
[229, 381],
[209, 401],
[221, 411],
[258, 411],
[300, 412],
[306, 435],
[268, 434],
[265, 454],
[298, 461],
[307, 461],
[307, 507],
[349, 510],
[352, 369],
[330, 366],
[330, 366],
]
),
]
# add polygons
layer = viewer.add_shapes(
polygons,
shape_type='polygon',
edge_width=1,
edge_color='coral',
face_color='royalblue',
name='shapes',
)
# change some attributes of the layer
layer.selected_data = set(range(layer.nshapes))
layer.current_edge_width = 5
layer.opacity = 0.75
layer.selected_data = set()
# add an ellipse to the layer
ellipse = np.array([[59, 222], [110, 289], [170, 243], [119, 176]])
layer.add(
ellipse,
shape_type='ellipse',
edge_width=5,
edge_color='coral',
face_color='purple',
)
masks = layer.to_masks([512, 512])
masks_layer = viewer.add_image(masks.astype(float), name='masks')
masks_layer.opacity = 0.7
masks_layer.colormap = Colormap([[0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 1.0]])
labels = layer.to_labels([512, 512])
labels_layer = viewer.add_labels(labels, name='labels')
points = np.array([[100, 100], [200, 200], [333, 111]])
size = np.array([10, 20, 20])
viewer.add_points(points, size=size)
# sample vector coord-like data
n = 100
pos = np.zeros((n, 2, 2), dtype=np.float32)
phi_space = np.linspace(0, 4 * np.pi, n)
radius_space = np.linspace(0, 100, n)
# assign x-y position
pos[:, 0, 0] = radius_space * np.cos(phi_space) + 350
pos[:, 0, 1] = radius_space * np.sin(phi_space) + 256
# assign x-y projection
pos[:, 1, 0] = 2 * radius_space * np.cos(phi_space)
pos[:, 1, 1] = 2 * radius_space * np.sin(phi_space)
# add the vectors
layer = viewer.add_vectors(pos, edge_width=2)
# take screenshot
screenshot = viewer.screenshot()
viewer.add_image(screenshot, rgb=True, name='screenshot')
# from skimage.io import imsave
# imsave('screenshot.png', screenshot)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/tracks_2d.py 0000664 0000000 0000000 00000002542 14370413656 0017270 0 ustar 00root root 0000000 0000000 """
Tracks 2D
=========
.. tags:: visualization-basic
"""
import numpy as np
import napari
def _circle(r, theta):
x = r * np.cos(theta)
y = r * np.sin(theta)
return x, y
def tracks_2d(num_tracks=10):
""" create 2d+t track data """
tracks = []
for track_id in range(num_tracks):
# space to store the track data and features
track = np.zeros((100, 6), dtype=np.float32)
# time
timestamps = np.arange(track.shape[0])
radius = 20 + 30 * np.random.random()
theta = timestamps * 0.1 + np.random.random() * np.pi
x, y = _circle(radius, theta)
track[:, 0] = track_id
track[:, 1] = timestamps
track[:, 2] = 50.0 + y
track[:, 3] = 50.0 + x
track[:, 4] = theta
track[:, 5] = radius
tracks.append(track)
tracks = np.concatenate(tracks, axis=0)
data = tracks[:, :4] # just the coordinate data
features = {
'time': tracks[:, 1],
'theta': tracks[:, 4],
'radius': tracks[:, 5],
}
graph = {}
return data, features, graph
tracks, features, graph = tracks_2d(num_tracks=10)
vertices = tracks[:, 1:]
viewer = napari.Viewer()
viewer.add_points(vertices, size=1, name='points', opacity=0.3)
viewer.add_tracks(tracks, features=features, name='tracks')
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/tracks_3d.py 0000664 0000000 0000000 00000003546 14370413656 0017276 0 ustar 00root root 0000000 0000000 """
Tracks 3D
=========
.. tags:: visualization-advanced
"""
import numpy as np
import napari
def lissajous(t):
a = np.random.random(size=(3,)) * 80.0 - 40.0
b = np.random.random(size=(3,)) * 0.05
c = np.random.random(size=(3,)) * 0.1
return (a[i] * np.cos(b[i] * t + c[i]) for i in range(3))
def tracks_3d(num_tracks=10):
""" create 3d+t track data """
tracks = []
for track_id in range(num_tracks):
# space to store the track data and features
track = np.zeros((200, 10), dtype=np.float32)
# time
timestamps = np.arange(track.shape[0])
x, y, z = lissajous(timestamps)
track[:, 0] = track_id
track[:, 1] = timestamps
track[:, 2] = 50.0 + z
track[:, 3] = 50.0 + y
track[:, 4] = 50.0 + x
# calculate the speed as a feature
gz = np.gradient(track[:, 2])
gy = np.gradient(track[:, 3])
gx = np.gradient(track[:, 4])
speed = np.sqrt(gx ** 2 + gy ** 2 + gz ** 2)
distance = np.sqrt(x ** 2 + y ** 2 + z ** 2)
track[:, 5] = gz
track[:, 6] = gy
track[:, 7] = gx
track[:, 8] = speed
track[:, 9] = distance
tracks.append(track)
tracks = np.concatenate(tracks, axis=0)
data = tracks[:, :5] # just the coordinate data
features = {
'time': tracks[:, 1],
'gradient_z': tracks[:, 5],
'gradient_y': tracks[:, 6],
'gradient_x': tracks[:, 7],
'speed': tracks[:, 8],
'distance': tracks[:, 9],
}
graph = {}
return data, features, graph
tracks, features, graph = tracks_3d(num_tracks=100)
vertices = tracks[:, 1:]
viewer = napari.Viewer(ndisplay=3)
viewer.add_points(vertices, size=1, name='points', opacity=0.3)
viewer.add_tracks(tracks, features=features, name='tracks')
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/tracks_3d_with_graph.py 0000664 0000000 0000000 00000002447 14370413656 0021511 0 ustar 00root root 0000000 0000000 """
Tracks 3D with graph
====================
.. tags:: visualization-advanced
"""
import numpy as np
import napari
def _circle(r, theta):
x = r * np.cos(theta)
y = r * np.sin(theta)
return x, y
def tracks_3d_merge_split():
"""Create tracks with splitting and merging."""
timestamps = np.arange(300)
def _trajectory(t, r, track_id):
theta = t * 0.1
x, y = _circle(r, theta)
z = np.zeros(x.shape)
tid = np.ones(x.shape) * track_id
return np.stack([tid, t, z, y, x], axis=1)
trackA = _trajectory(timestamps[:100], 30.0, 0)
trackB = _trajectory(timestamps[100:200], 10.0, 1)
trackC = _trajectory(timestamps[100:200], 50.0, 2)
trackD = _trajectory(timestamps[200:], 30.0, 3)
data = [trackA, trackB, trackC, trackD]
tracks = np.concatenate(data, axis=0)
tracks[:, 2:] += 50.0 # centre the track at (50, 50, 50)
graph = {1: 0, 2: [0], 3: [1, 2]}
features = {'time': tracks[:, 1]}
return tracks, features, graph
tracks, features, graph = tracks_3d_merge_split()
vertices = tracks[:, 1:]
viewer = napari.Viewer(ndisplay=3)
viewer.add_points(vertices, size=1, name='points', opacity=0.3)
viewer.add_tracks(tracks, features=features, graph=graph, name='tracks')
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/update_console.py 0000664 0000000 0000000 00000003151 14370413656 0020415 0 ustar 00root root 0000000 0000000 """
Update console
==============
Display one shapes layer ontop of one image layer using the add_shapes and
add_image APIs. When the window is closed it will print the coordinates of
your shapes.
.. tags:: historical
"""
import numpy as np
from skimage import data
import napari
# create the viewer and window
viewer = napari.Viewer()
# add the image
photographer = data.camera()
image_layer = napari.view_image(photographer, name='photographer')
# create a list of polygons
polygons = [
np.array([[11, 13], [111, 113], [22, 246]]),
np.array(
[
[505, 60],
[402, 71],
[383, 42],
[251, 95],
[212, 59],
[131, 137],
[126, 187],
[191, 204],
[171, 248],
[211, 260],
[273, 243],
[264, 225],
[430, 173],
[512, 160],
]
),
np.array(
[
[310, 382],
[229, 381],
[209, 401],
[221, 411],
[258, 411],
[300, 412],
[306, 435],
[268, 434],
[265, 454],
[298, 461],
[307, 461],
[307, 507],
[349, 510],
[352, 369],
[330, 366],
[330, 366],
]
),
]
# add polygons
shapes_layer = viewer.add_shapes(
polygons,
shape_type='polygon',
edge_width=5,
edge_color='coral',
face_color='royalblue',
name='shapes',
)
# Send local variables to the console
viewer.update_console(locals())
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/viewer_fps_label.py 0000664 0000000 0000000 00000000740 14370413656 0020722 0 ustar 00root root 0000000 0000000 """
Viewer FPS label
================
Display a 3D volume and the fps label.
.. tags:: experimental
"""
import numpy as np
import napari
def update_fps(fps):
"""Update fps."""
viewer.text_overlay.text = f"{fps:1.1f} FPS"
viewer = napari.Viewer()
viewer.add_image(np.random.random((5, 5, 5)), colormap='red', opacity=0.8)
viewer.text_overlay.visible = True
viewer.window.qt_viewer.canvas.measure_fps(callback=update_fps)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/viewer_loop_reproducible_screenshots.md 0000664 0000000 0000000 00000006177 14370413656 0025105 0 ustar 00root root 0000000 0000000 ---
jupytext:
formats: ipynb,md:myst
text_representation:
extension: .md
format_name: myst
format_version: 0.13
jupytext_version: 1.13.8
kernelspec:
display_name: Python 3 (ipykernel)
language: python
name: python3
---
```{tags} gui
```
# Creating reproducible screenshots with a viewer loop
This example captures images in three dimensions for multiple samples.
This can be e.g. useful when one has dozens of ct scans and wants to visualize them for a quick overview with napari but does not want to load them one by one.
Reproducibility is achieved by defining exact frame width and frame height.
+++
The first cell takes care of the imports and data initializing, in this case a blob, a ball and an octahedron.
```{code-cell} ipython3
from napari.settings import get_settings
import time
import napari
from napari._qt.qthreading import thread_worker
from skimage import data
from skimage.morphology import ball, octahedron
import matplotlib.pyplot as plt
def make_screenshot(viewer):
img = viewer.screenshot(canvas_only=True, flash=False)
plt.imshow(img)
plt.axis("off")
plt.show()
myblob = data.binary_blobs(
length=200, volume_fraction=0.1, blob_size_fraction=0.3, n_dim=3, seed=42
)
myoctahedron = octahedron(100)
myball = ball(100)
# store the variables in a dict with the image name as key.
data_dict = {
"blob": myblob,
"ball": myball,
"octahedron": myoctahedron,
}
```
Now, the napari viewer settings can be adjusted programmatically, such as 3D rendering methods, axes visible, color maps, zoom level, and camera orientation.
Every plot will have these exact settings, while only one napari viewer instance is needed.
After setting these parameters, one should not make changes with the mouse in the napari viewer anymore, as this would rule out the reproducibility.
```{code-cell} ipython3
viewer = napari.Viewer()
viewer.window.resize(900, 600)
viewer.theme = "light"
viewer.dims.ndisplay = 3
viewer.axes.visible = True
viewer.axes.colored = False
viewer.axes.labels = False
viewer.text_overlay.visible = True
viewer.text_overlay.text = "Hello World!"
# Not yet implemented, but can be added as soon as this feature exisits (syntax might change):
# viewer.controls.visible = False
viewer.add_labels(myball, name="result" , opacity=1)
viewer.camera.angles = (19, -33, -121)
viewer.camera.zoom = 1.3
```
Next, the loop run is defined.
The `loop_run` function reads new `image_data` and the corresponding `image_name` and yields them to napari.
The `update_layer` function gives instructions how to process the yielded data in the napari viewer.
```{code-cell} ipython3
@thread_worker
def loop_run():
for image_name in data_dict:
time.sleep(0.5)
image_data = data_dict[image_name]
yield (image_data, image_name)
def update_layer(image_text_tuple):
image, text = image_text_tuple
viewer.layers["result"].data = image
viewer.text_overlay.text = text
make_screenshot(viewer)
```
And finally, the loop is executed:
```{code-cell} ipython3
worker = loop_run()
worker.yielded.connect(update_layer)
worker.start()
```
```{code-cell} ipython3
```
napari-0.5.0a1/examples/without_gui_qt.py 0000664 0000000 0000000 00000002333 14370413656 0020465 0 ustar 00root root 0000000 0000000 """
napari without gui_qt
=====================
Alternative to using napari.gui_qt() context manager.
This is here for historical purposes, to the transition away from
the "gui_qt()" context manager.
.. tags:: historical
"""
from collections import Counter
from skimage import data
import napari
viewer = napari.view_image(data.astronaut(), rgb=True)
# You can do anything you would normally do with the viewer object
# like take a
screenshot = viewer.screenshot()
print('Maximum value', screenshot.max())
# To see the napari viewer and interact with the graphical user interface,
# use `napari.run()`. (it's similar to `plt.show` in matplotlib)
# If you only wanted the screenshot then you could skip this entirely.
# *run* will *block execution of your script* until the window is closed.
if __name__ == '__main__':
napari.run()
# When the window is closed, your script continues and you can still inspect
# the viewer object. For example, add click the buttons to add various layer
# types when the window is open and see the result below:
print("Your viewer has the following layers:")
for name, n in Counter(type(x).__name__ for x in viewer.layers).most_common():
print(f" {name:<7}: {n}")
napari-0.5.0a1/examples/xarray_nD_image_.py 0000664 0000000 0000000 00000001112 14370413656 0020634 0 ustar 00root root 0000000 0000000 """
Xarray example
==============
Displays an xarray
.. tags:: visualization-nD
"""
try:
import xarray as xr
except ModuleNotFoundError:
raise ModuleNotFoundError(
"""This example uses a xarray but xarray is not
installed. To install try 'pip install xarray'."""
) from None
import numpy as np
import napari
data = np.random.random((20, 40, 50))
xdata = xr.DataArray(data, dims=['z', 'y', 'x'])
# create an empty viewer
viewer = napari.Viewer()
# add the xarray
layer = viewer.add_image(xdata, name='xarray')
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/examples/zarr_nD_image_.py 0000664 0000000 0000000 00000001224 14370413656 0020310 0 ustar 00root root 0000000 0000000 """
Zarr array
==========
Display a zarr array
.. tags:: visualization-nD
"""
try:
import zarr
except ModuleNotFoundError:
raise ModuleNotFoundError(
"""This example uses a zarr array but zarr is not
installed. To install try 'pip install zarr'."""
) from None
import napari
data = zarr.zeros((102_0, 200, 210), chunks=(100, 200, 210))
data[53_0:53_1, 100:110, 110:120] = 1
print(data.shape)
# For big data, we should specify the contrast_limits range, or napari will try
# to find the min and max of the full image.
viewer = napari.view_image(data, contrast_limits=[0, 1], rgb=False)
if __name__ == '__main__':
napari.run()
napari-0.5.0a1/napari/ 0000775 0000000 0000000 00000000000 14370413656 0014473 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/__init__.py 0000664 0000000 0000000 00000003044 14370413656 0016605 0 ustar 00root root 0000000 0000000 import os
from napari._lazy import install_lazy
try:
from napari._version import version as __version__
except ImportError:
__version__ = "not-installed"
# Allows us to use pydata/sparse arrays as layer data
os.environ.setdefault('SPARSE_AUTO_DENSIFY', '1')
del os
# Add everything that needs to be accessible from the napari namespace here.
_proto_all_ = [
'__version__',
'components',
'experimental',
'layers',
'qt',
'types',
'viewer',
'utils',
]
_submod_attrs = {
'_event_loop': ['gui_qt', 'run'],
'plugins.io': ['save_layers'],
'utils': ['sys_info'],
'utils.notifications': ['notification_manager'],
'view_layers': [
'view_image',
'view_labels',
'view_path',
'view_points',
'view_shapes',
'view_surface',
'view_tracks',
'view_vectors',
'imshow',
],
'viewer': ['Viewer', 'current_viewer'],
}
# All imports in __init__ are hidden inside of `__getattr__` to prevent
# importing the full chain of packages required when calling `import napari`.
#
# This has the biggest implications for running `napari` on the command line
# (or running `python -m napari`) since `napari.__init__` gets imported
# on the way to `napari.__main__`. Importing everything here has the
# potential to take a second or more, so we definitely don't want to import it
# just to access the CLI (which may not actually need any of the imports)
__getattr__, __dir__, __all__ = install_lazy(
__name__, _proto_all_, _submod_attrs
)
del install_lazy
napari-0.5.0a1/napari/__init__.pyi 0000664 0000000 0000000 00000001416 14370413656 0016757 0 ustar 00root root 0000000 0000000 import napari._qt.qt_event_loop
import napari.plugins.io
import napari.utils.notifications
import napari.view_layers
import napari.viewer
__version__: str
notification_manager: napari.utils.notifications.NotificationManager
Viewer = napari.viewer.Viewer
current_viewer = napari.viewer.current_viewer
gui_qt = napari._qt.qt_event_loop.gui_qt
run = napari._qt.qt_event_loop.run
save_layers = napari.plugins.io.save_layers
view_image = napari.view_layers.view_image
view_labels = napari.view_layers.view_labels
view_path = napari.view_layers.view_path
view_points = napari.view_layers.view_points
view_shapes = napari.view_layers.view_shapes
view_surface = napari.view_layers.view_surface
view_tracks = napari.view_layers.view_tracks
view_vectors = napari.view_layers.view_vectors
napari-0.5.0a1/napari/__main__.py 0000664 0000000 0000000 00000047375 14370413656 0016605 0 ustar 00root root 0000000 0000000 """
napari command line viewer.
"""
import argparse
import contextlib
import logging
import os
import runpy
import sys
import warnings
from ast import literal_eval
from itertools import chain, repeat
from pathlib import Path
from textwrap import wrap
from typing import Any, Dict, List
from napari.utils.translations import trans
class InfoAction(argparse.Action):
def __call__(self, *args, **kwargs):
# prevent unrelated INFO logs when doing "napari --info"
from npe2 import cli
from napari.utils import sys_info
logging.basicConfig(level=logging.WARNING)
print(sys_info())
print("Plugins:")
cli.list(fields="", sort="0", format="compact")
sys.exit()
class PluginInfoAction(argparse.Action):
def __call__(self, *args, **kwargs):
# prevent unrelated INFO logs when doing "napari --info"
logging.basicConfig(level=logging.WARNING)
from npe2 import cli
cli.list(
fields="name,version,npe2,contributions",
sort="name",
format="table",
)
sys.exit()
class CitationAction(argparse.Action):
def __call__(self, *args, **kwargs):
# prevent unrelated INFO logs when doing "napari --citation"
from napari.utils import citation_text
logging.basicConfig(level=logging.WARNING)
print(citation_text)
sys.exit()
def validate_unknown_args(unknown: List[str]) -> Dict[str, Any]:
"""Convert a list of strings into a dict of valid kwargs for add_* methods.
Will exit program if any of the arguments are unrecognized, or are
malformed. Converts string to python type using literal_eval.
Parameters
----------
unknown : List[str]
a list of strings gathered as "unknown" arguments in argparse.
Returns
-------
kwargs : Dict[str, Any]
{key: val} dict suitable for the viewer.add_* methods where ``val``
is a ``literal_eval`` result, or string.
"""
from napari.components.viewer_model import valid_add_kwargs
out: Dict[str, Any] = {}
valid = set.union(*valid_add_kwargs().values())
for i, arg in enumerate(unknown):
if not arg.startswith("--"):
continue
if "=" in arg:
key, value = arg.split("=", maxsplit=1)
else:
key = arg
key = key.lstrip('-').replace("-", "_")
if key not in valid:
sys.exit(f"error: unrecognized arguments: {arg}")
if "=" not in arg:
try:
value = unknown[i + 1]
if value.startswith("--"):
raise IndexError()
except IndexError:
sys.exit(f"error: argument {arg} expected one argument")
with contextlib.suppress(Exception):
value = literal_eval(value)
out[key] = value
return out
def parse_sys_argv():
"""Parse command line arguments."""
from napari import __version__, layers
from napari.components.viewer_model import valid_add_kwargs
kwarg_options = []
for layer_type, keys in valid_add_kwargs().items():
kwarg_options.append(f" {layer_type.title()}:")
keys = {k.replace('_', '-') for k in keys}
lines = wrap(", ".join(sorted(keys)), break_on_hyphens=False)
kwarg_options.extend([f" {line}" for line in lines])
parser = argparse.ArgumentParser(
usage=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="optional layer-type-specific arguments (precede with '--'):\n"
+ "\n".join(kwarg_options),
)
parser.add_argument('paths', nargs='*', help='path(s) to view.')
parser.add_argument(
'-v',
'--verbose',
action='count',
default=0,
help="increase output verbosity",
)
parser.add_argument(
'-w',
'--with',
dest='with_',
nargs='+',
action='append',
default=[],
metavar=('PLUGIN_NAME', 'WIDGET_NAME'),
help=(
"open napari with dock widget from specified plugin name."
"(If plugin provides multiple dock widgets, widget name must also "
"be provided). Use __all__ to open all dock widgets of a "
"specified plugin. Multiple widgets are opened in tabs."
),
)
parser.add_argument(
'--version',
action='version',
version=f'napari version {__version__}',
)
parser.add_argument(
'--info',
action=InfoAction,
nargs=0,
help='show system information and exit',
)
parser.add_argument(
'--plugin-info',
action=PluginInfoAction,
nargs=0,
help='show information about plugins and exit',
)
parser.add_argument(
'--citation',
action=CitationAction,
nargs=0,
help='show citation information and exit',
)
# Allow multiple --stack options to be provided.
# Each stack option will result in its own stack
parser.add_argument(
'--stack',
action='append',
nargs='*',
default=[],
help='concatenate multiple input files into a single stack. Can be provided multiple times for multiple stacks.',
)
parser.add_argument(
'--plugin',
help='specify plugin name when opening a file',
)
parser.add_argument(
'--layer-type',
metavar="TYPE",
choices=set(layers.NAMES),
help=(
'force file to be interpreted as a specific layer type. '
f'one of {set(layers.NAMES)}'
),
)
parser.add_argument(
'--reset',
action='store_true',
help='reset settings to default values.',
)
parser.add_argument(
'--settings-path',
type=Path,
help='use specific path to store and load settings.',
)
args, unknown = parser.parse_known_args()
# this is a hack to allow using "=" as a key=value separator while also
# allowing nargs='*' on the "paths" argument...
for idx, item in enumerate(reversed(args.paths)):
if item.startswith("--"):
unknown.append(args.paths.pop(len(args.paths) - idx - 1))
kwargs = validate_unknown_args(unknown) if unknown else {}
return args, kwargs
def _run():
from napari import Viewer, run
from napari.settings import get_settings
"""Main program."""
args, kwargs = parse_sys_argv()
# parse -v flags and set the appropriate logging level
levels = [logging.WARNING, logging.INFO, logging.DEBUG]
level = levels[min(2, args.verbose)] # prevent index error
logging.basicConfig(
level=level,
format="%(asctime)s %(levelname)s %(message)s",
datefmt='%H:%M:%S',
)
if args.reset:
if args.settings_path:
settings = get_settings(path=args.settings_path)
else:
settings = get_settings()
settings.reset()
settings.save()
sys.exit("Resetting settings to default values.\n")
if args.plugin:
# make sure plugin is only used when files are specified
if not args.paths:
sys.exit(
"error: The '--plugin' argument is only valid "
"when providing a file name"
)
# I *think* that Qt is looking in sys.argv for a flag `--plugins`,
# which emits "WARNING: No such plugin for spec 'builtins'"
# so remove --plugin from sys.argv to prevent that warningz
sys.argv.remove('--plugin')
if any(p.endswith('.py') for p in args.paths):
# we're running a script
if len(args.paths) > 1:
sys.exit(
'When providing a python script, only a '
'single positional argument may be provided'
)
# run the file
mod = runpy.run_path(args.paths[0])
from napari_plugin_engine.markers import HookImplementationMarker
# if this file had any hook implementations, register and run as plugin
if any(isinstance(i, HookImplementationMarker) for i in mod.values()):
_run_plugin_module(mod, os.path.basename(args.paths[0]))
else:
if args.with_:
from napari.plugins import (
_initialize_plugins,
_npe2,
plugin_manager,
)
# if a plugin widget has been requested, this will fail immediately
# if the requested plugin/widget is not available.
_initialize_plugins()
plugin_manager.discover_widgets()
plugin_manager_plugins = []
npe2_plugins = []
for plugin in args.with_:
pname, *wnames = plugin
for _name, (_pname, _wnames) in _npe2.widget_iterator():
if _name == 'dock' and pname == _pname:
npe2_plugins.append(plugin)
if '__all__' in wnames:
wnames = _wnames
break
for _name, (_pname, _wnames) in plugin_manager.iter_widgets():
if _name == 'dock' and pname == _pname:
plugin_manager_plugins.append(plugin)
if '__all__' in wnames:
# Plugin_manager iter_widgets return wnames as dict keys
wnames = list(_wnames.keys())
print(
trans._(
'Non-npe2 plugin {pname} detected. Disable tabify for this plugin.',
deferred=True,
pname=pname,
)
)
break
if wnames:
for wname in wnames:
_npe2.get_widget_contribution(
pname, wname
) or plugin_manager.get_widget(pname, wname)
else:
_npe2.get_widget_contribution(
pname
) or plugin_manager.get_widget(pname)
from napari._qt.widgets.qt_splash_screen import NapariSplashScreen
splash = NapariSplashScreen()
splash.close() # will close once event loop starts
# viewer _must_ be kept around.
# it will be referenced by the global window only
# once napari has finished starting
# but in the meantime if the garbage collector runs;
# it will collect it and hang napari at start time.
# in a way that is machine, os, time (and likely weather dependant).
viewer = Viewer()
# For backwards compatibility
# If the --stack option is provided without additional arguments
# just set stack to True similar to the previous store_true action
if args.stack and len(args.stack) == 1 and len(args.stack[0]) == 0:
warnings.warn(
trans._(
"The usage of the --stack option as a boolean is deprecated. Please use '--stack file1 file2 .. fileN' instead. It is now also possible to specify multiple stacks of files to stack '--stack file1 file2 --stack file3 file4 file5 --stack ..'. This warning will become an error in version 0.5.0.",
),
DeprecationWarning,
stacklevel=3,
)
args.stack = True
viewer._window._qt_viewer._qt_open(
args.paths,
stack=args.stack,
plugin=args.plugin,
layer_type=args.layer_type,
**kwargs,
)
if args.with_:
# Non-npe2 plugins disappear on tabify or if tabified npe2 plugins are loaded after them.
# Therefore, read npe2 plugins first and do not tabify for non-npe2 plugins.
for plugin, tabify in chain(
zip(npe2_plugins, repeat(True)),
zip(plugin_manager_plugins, repeat(False)),
):
pname, *wnames = plugin
if '__all__' in wnames:
for name, (_pname, _wnames) in chain(
_npe2.widget_iterator(), plugin_manager.iter_widgets()
):
if name == 'dock' and pname == _pname:
if isinstance(_wnames, dict):
# Plugin_manager iter_widgets return wnames as dict keys
wnames = list(_wnames.keys())
else:
wnames = _wnames
break
if wnames:
first_dock_widget = viewer.window.add_plugin_dock_widget(
pname, wnames[0], tabify=tabify
)[0]
for wname in wnames[1:]:
viewer.window.add_plugin_dock_widget(
pname, wname, tabify=tabify
)
first_dock_widget.show()
first_dock_widget.raise_()
else:
viewer.window.add_plugin_dock_widget(pname, tabify=tabify)
# only necessary in bundled app, but see #3596
from napari.utils.misc import (
install_certifi_opener,
running_as_bundled_app,
)
if running_as_bundled_app():
install_certifi_opener()
run(gui_exceptions=True)
def _run_plugin_module(mod, plugin_name):
"""Register `mod` as a plugin, find/create viewer, and run napari."""
from napari import Viewer, run
from napari.plugins import plugin_manager
plugin_manager.register(mod, name=plugin_name)
# now, check if a viewer was created, and if not, create one.
for obj in mod.values():
if isinstance(obj, Viewer):
_v = obj
break
else:
_v = Viewer()
try:
_v.window._qt_window.parent()
except RuntimeError:
# this script had a napari.run() in it, and the viewer has already been
# used and cleaned up... if we eventually have "reusable viewers", we
# can continue here
return
# finally, if the file declared a dock widget, add it to the viewer.
dws = plugin_manager.hooks.napari_experimental_provide_dock_widget
if any(i.plugin_name == plugin_name for i in dws.get_hookimpls()):
_v.window.add_plugin_dock_widget(plugin_name)
run()
def _maybe_rerun_with_macos_fixes():
"""
Apply some fixes needed in macOS, which might involve
running this script again using a different sys.executable.
1) Quick fix for Big Sur Python 3.9 and Qt 5.
No relaunch needed.
2) Using `pythonw` instead of `python`.
This can be used to ensure we're using a framework
build of Python on macOS, which fixes frozen menubar issues
in some macOS versions.
3) Make sure the menu bar uses 'napari' as the display name.
This requires relaunching the app from a symlink to the
desired python executable, conveniently named 'napari'.
"""
from napari._qt import API_NAME
# This import mus be here to raise exception about PySide6 problem
if sys.platform != "darwin":
return
if "_NAPARI_RERUN_WITH_FIXES" in os.environ:
# This function already ran, do not recurse!
# We also restore sys.executable to its initial value,
# if we used a symlink
if exe := os.environ.pop("_NAPARI_SYMLINKED_EXECUTABLE", ""):
sys.executable = exe
return
import platform
import subprocess
from tempfile import mkdtemp
# In principle, we will relaunch to the same python we were using
executable = sys.executable
cwd = Path.cwd()
_MACOS_AT_LEAST_CATALINA = int(platform.release().split('.')[0]) >= 19
_MACOS_AT_LEAST_BIG_SUR = int(platform.release().split('.')[0]) >= 20
_RUNNING_CONDA = "CONDA_PREFIX" in os.environ
_RUNNING_PYTHONW = "PYTHONEXECUTABLE" in os.environ
# 1) quick fix for Big Sur py3.9 and qt 5
# https://github.com/napari/napari/pull/1894
if _MACOS_AT_LEAST_BIG_SUR and '6' not in API_NAME:
os.environ['QT_MAC_WANTS_LAYER'] = '1'
# Create the env copy now because the following changes
# should not persist in the current process in case
# we do not run the subprocess!
env = os.environ.copy()
# 2) Ensure we're always using a "framework build" on the latest
# macOS to ensure menubar works without needing to refocus napari.
# We try this for macOS later than the Catalina release
# See https://github.com/napari/napari/pull/1554 and
# https://github.com/napari/napari/issues/380#issuecomment-659656775
# and https://github.com/ContinuumIO/anaconda-issues/issues/199
if (
_MACOS_AT_LEAST_CATALINA
and not _MACOS_AT_LEAST_BIG_SUR
and _RUNNING_CONDA
and not _RUNNING_PYTHONW
):
pythonw_path = Path(sys.exec_prefix) / 'bin' / 'pythonw'
if pythonw_path.exists():
# Use this one instead of sys.executable to relaunch
# the subprocess
executable = pythonw_path
else:
msg = (
'pythonw executable not found.\n'
'To unfreeze the menubar on macOS, '
'click away from napari to another app, '
'then reactivate napari. To avoid this problem, '
'please install python.app in conda using:\n'
'conda install -c conda-forge python.app'
)
warnings.warn(msg)
# 3) Make sure the app name in the menu bar is 'napari', not 'python'
tempdir = None
_NEEDS_SYMLINK = (
# When napari is launched from the conda bundle shortcut
# it already has the right 'napari' name in the app title
# and __CFBundleIdentifier is set to 'com.napari._()'
"napari" not in os.environ.get("__CFBundleIdentifier", "")
# with a sys.executable named napari,
# macOS should have picked the right name already
or os.path.basename(executable) != "napari"
)
if _NEEDS_SYMLINK:
tempdir = mkdtemp(prefix="symlink-to-fix-macos-menu-name-")
# By using a symlink with basename napari
# we make macOS take 'napari' as the program name
napari_link = os.path.join(tempdir, "napari")
os.symlink(executable, napari_link)
# Pass original executable to the subprocess so it can restore it later
env["_NAPARI_SYMLINKED_EXECUTABLE"] = executable
executable = napari_link
# if at this point 'executable' is different from 'sys.executable', we
# need to launch the subprocess to apply the fixes
if sys.executable != executable:
env["_NAPARI_RERUN_WITH_FIXES"] = "1"
if Path(sys.argv[0]).name == "napari":
# launched through entry point, we do that again to avoid
# issues with working directory getting into sys.path (#5007)
cmd = [executable, sys.argv[0]]
else: # we assume it must have been launched via '-m' syntax
cmd = [executable, "-m", "napari"]
# Append original command line arguments.
if len(sys.argv) > 1:
cmd.extend(sys.argv[1:])
try:
result = subprocess.run(cmd, env=env, cwd=cwd)
sys.exit(result.returncode)
finally:
if tempdir is not None:
import shutil
shutil.rmtree(tempdir)
def main():
# There a number of macOS issues we can fix with env vars
# and/or relaunching a subprocess
_maybe_rerun_with_macos_fixes()
# Prevent https://github.com/napari/napari/issues/3415
# This one fix is needed _after_ a potential relaunch,
# that's why it's here and not in _maybe_rerun_with_macos_fixes()
if sys.platform == "darwin":
import multiprocessing
multiprocessing.set_start_method('fork')
_run()
if __name__ == '__main__':
sys.exit(main())
napari-0.5.0a1/napari/_app_model/ 0000775 0000000 0000000 00000000000 14370413656 0016572 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_app_model/__init__.py 0000664 0000000 0000000 00000000102 14370413656 0020674 0 ustar 00root root 0000000 0000000 from napari._app_model._app import get_app
__all__ = ["get_app"]
napari-0.5.0a1/napari/_app_model/_app.py 0000664 0000000 0000000 00000004635 14370413656 0020073 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from functools import lru_cache
from itertools import chain
from typing import Dict
from app_model import Application
from napari._app_model._submenus import SUBMENUS
from napari._app_model.actions._help_actions import HELP_ACTIONS
from napari._app_model.actions._layer_actions import LAYER_ACTIONS
from napari._app_model.actions._view_actions import VIEW_ACTIONS
from napari._app_model.injection._processors import PROCESSORS
from napari._app_model.injection._providers import PROVIDERS
APP_NAME = 'napari'
class NapariApplication(Application):
def __init__(self, app_name=APP_NAME) -> None:
# raise_synchronous_exceptions means that commands triggered via
# ``execute_command`` will immediately raise exceptions. Normally,
# `execute_command` returns a Future object (which by definition does not
# raise exceptions until requested). While we could use that future to raise
# exceptions with `.result()`, for now, raising immediately should
# prevent any unexpected silent errors. We can turn it off later if we
# adopt asynchronous command execution.
super().__init__(app_name, raise_synchronous_exceptions=True)
self.injection_store.namespace = _napari_names # type: ignore [assignment]
self.injection_store.register(
providers=PROVIDERS, processors=PROCESSORS
)
for action in chain(HELP_ACTIONS, LAYER_ACTIONS, VIEW_ACTIONS):
self.register_action(action)
self.menus.append_menu_items(SUBMENUS)
@classmethod
def get_app(cls) -> NapariApplication:
return Application.get_app(APP_NAME) or cls()
@lru_cache(maxsize=1)
def _napari_names() -> Dict[str, object]:
"""Napari names to inject into local namespace when evaluating type hints."""
import napari
from napari import components, layers, viewer
def _public_types(module):
return {
name: val
for name, val in vars(module).items()
if not name.startswith('_')
and isinstance(val, type)
and getattr(val, '__module__', '_').startswith('napari')
}
return {
'napari': napari,
**_public_types(components),
**_public_types(layers),
**_public_types(viewer),
}
def get_app() -> NapariApplication:
"""Get the Napari Application singleton."""
return NapariApplication.get_app()
napari-0.5.0a1/napari/_app_model/_submenus.py 0000664 0000000 0000000 00000002062 14370413656 0021144 0 ustar 00root root 0000000 0000000 from app_model.types import SubmenuItem
from napari._app_model.constants import MenuGroup, MenuId
from napari._app_model.context import LayerListContextKeys as LLCK
from napari.utils.translations import trans
SUBMENUS = [
(
MenuId.LAYERLIST_CONTEXT,
SubmenuItem(
submenu=MenuId.LAYERS_CONVERT_DTYPE,
title=trans._('Convert data type'),
group=MenuGroup.LAYERLIST_CONTEXT.CONVERSION,
order=None,
enablement=LLCK.all_selected_layers_labels,
),
),
(
MenuId.LAYERLIST_CONTEXT,
SubmenuItem(
submenu=MenuId.LAYERS_PROJECT,
title=trans._('Projections'),
group=MenuGroup.LAYERLIST_CONTEXT.SPLIT_MERGE,
order=None,
enablement=LLCK.active_layer_is_image_3d,
),
),
(
MenuId.MENUBAR_VIEW,
SubmenuItem(submenu=MenuId.VIEW_AXES, title=trans._('Axes')),
),
(
MenuId.MENUBAR_VIEW,
SubmenuItem(submenu=MenuId.VIEW_SCALEBAR, title=trans._('Scale Bar')),
),
]
napari-0.5.0a1/napari/_app_model/_tests/ 0000775 0000000 0000000 00000000000 14370413656 0020073 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_app_model/_tests/test_app.py 0000664 0000000 0000000 00000001364 14370413656 0022270 0 ustar 00root root 0000000 0000000 from napari._app_model import get_app
from napari.layers import Points
def test_app():
"""just make sure our app model is registering menus and commands"""
app = get_app()
assert app.name == 'test_app'
assert list(app.menus)
assert list(app.commands)
# assert list(app.keybindings) # don't have any yet
def test_app_injection():
"""Simple test to make sure napari namespaces are working in app injection."""
app = get_app()
def use_points(points: 'Points'):
return points
p = Points()
def provide_points() -> 'Points':
return p
with app.injection_store.register(providers=[(provide_points,)]):
injected = app.injection_store.inject(use_points)
assert injected() is p
napari-0.5.0a1/napari/_app_model/_tests/test_constants.py 0000664 0000000 0000000 00000000642 14370413656 0023522 0 ustar 00root root 0000000 0000000 from napari._app_model.constants import CommandId, MenuId
def test_command_titles():
"""make sure all command start with napari: and have a title"""
for command in CommandId:
assert command.value.startswith('napari:')
assert command.title is not None
def test_menus():
"""make sure all menus start with napari/"""
for menu in MenuId:
assert menu.value.startswith('napari/')
napari-0.5.0a1/napari/_app_model/_tests/test_help_menu_urls.py 0000664 0000000 0000000 00000000556 14370413656 0024533 0 ustar 00root root 0000000 0000000 """For testing the URLs in the Help menu"""
import pytest
import requests
from napari._app_model.actions._help_actions import HELP_URLS
@pytest.mark.parametrize('url', HELP_URLS.keys())
def test_help_urls(url):
if url == 'release_notes':
pytest.skip("No release notes for dev version")
r = requests.head(HELP_URLS[url])
r.raise_for_status()
napari-0.5.0a1/napari/_app_model/_tests/test_misc_callbacks.py 0000664 0000000 0000000 00000000727 14370413656 0024444 0 ustar 00root root 0000000 0000000 """For testing one off action callbacks"""
from napari._app_model.actions._view_actions import _tooltip_visibility_toggle
from napari.settings import get_settings
def test_tooltip_visibility_toggle():
settings = get_settings().appearance
assert settings.layer_tooltip_visibility is False
_tooltip_visibility_toggle()
assert settings.layer_tooltip_visibility is True
_tooltip_visibility_toggle()
assert settings.layer_tooltip_visibility is False
napari-0.5.0a1/napari/_app_model/_tests/test_viewer_toggler.py 0000664 0000000 0000000 00000001421 14370413656 0024526 0 ustar 00root root 0000000 0000000 from napari import Viewer
from napari._app_model._app import get_app
from napari._app_model.actions._toggle_action import ViewerToggleAction
from napari.components import ViewerModel
def test_viewer_toggler():
viewer = ViewerModel()
action = ViewerToggleAction(
id='some.command.id',
title='Toggle Axis Visibility',
viewer_attribute='axes',
sub_attribute='visible',
)
app = get_app()
app.register_action(action)
with app.injection_store.register(providers={Viewer: lambda: viewer}):
assert viewer.axes.visible is False
app.commands.execute_command('some.command.id')
assert viewer.axes.visible is True
app.commands.execute_command('some.command.id')
assert viewer.axes.visible is False
napari-0.5.0a1/napari/_app_model/actions/ 0000775 0000000 0000000 00000000000 14370413656 0020232 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_app_model/actions/__init__.py 0000664 0000000 0000000 00000000000 14370413656 0022331 0 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_app_model/actions/_help_actions.py 0000664 0000000 0000000 00000005561 14370413656 0023422 0 ustar 00root root 0000000 0000000 """Actions related to the 'Help' menu that do not require Qt.
View actions that do require Qt should go in
`napari/_qt/_qapp_model/qactions/_help.py`.
"""
import webbrowser
from typing import List
from app_model.types import Action
from packaging.version import parse
from napari import __version__
from napari._app_model.constants import CommandId, MenuGroup, MenuId
v = parse(__version__)
VERSION = "dev" if v.is_devrelease else str(v)
HELP_URLS = {
"getting_started": f'https://napari.org/{VERSION}/tutorials/start_index.html',
"tutorials": f'https://napari.org/{VERSION}/tutorials/index.html',
"layers_guide": f'https://napari.org/{VERSION}/howtos/layers/index.html',
"examples_gallery": f'https://napari.org/{VERSION}/gallery.html',
"release_notes": f'https://napari.org/{VERSION}/release/release_{VERSION.replace(".", "_")}.html',
"github_issue": 'https://github.com/napari/napari/issues',
"homepage": 'https://napari.org',
}
HELP_ACTIONS: List[Action] = [
Action(
id=CommandId.NAPARI_GETTING_STARTED,
title=CommandId.NAPARI_GETTING_STARTED.title,
callback=lambda: webbrowser.open(HELP_URLS['getting_started']),
menus=[{'id': MenuId.MENUBAR_HELP}],
),
Action(
id=CommandId.NAPARI_TUTORIALS,
title=CommandId.NAPARI_TUTORIALS.title,
callback=lambda: webbrowser.open(HELP_URLS['tutorials']),
menus=[{'id': MenuId.MENUBAR_HELP}],
),
Action(
id=CommandId.NAPARI_LAYERS_GUIDE,
title=CommandId.NAPARI_LAYERS_GUIDE.title,
callback=lambda: webbrowser.open(HELP_URLS['layers_guide']),
menus=[{'id': MenuId.MENUBAR_HELP}],
),
Action(
id=CommandId.NAPARI_EXAMPLES,
title=CommandId.NAPARI_EXAMPLES.title,
callback=lambda: webbrowser.open(HELP_URLS['examples_gallery']),
menus=[{'id': MenuId.MENUBAR_HELP}],
),
Action(
id=CommandId.NAPARI_RELEASE_NOTES,
title=CommandId.NAPARI_RELEASE_NOTES.title,
callback=lambda: webbrowser.open(
HELP_URLS['release_notes'],
),
menus=[
{
'id': MenuId.MENUBAR_HELP,
'when': VERSION != "dev",
'group': MenuGroup.NAVIGATION,
}
],
),
Action(
id=CommandId.NAPARI_GITHUB_ISSUE,
title=CommandId.NAPARI_GITHUB_ISSUE.title,
callback=lambda: webbrowser.open(
HELP_URLS['github_issue'],
),
menus=[
{
'id': MenuId.MENUBAR_HELP,
'when': VERSION == "dev",
'group': MenuGroup.NAVIGATION,
}
],
),
Action(
id=CommandId.NAPARI_HOMEPAGE,
title=CommandId.NAPARI_HOMEPAGE.title,
callback=lambda: webbrowser.open(HELP_URLS['homepage']),
menus=[{'id': MenuId.MENUBAR_HELP, 'group': MenuGroup.NAVIGATION}],
),
]
napari-0.5.0a1/napari/_app_model/actions/_layer_actions.py 0000664 0000000 0000000 00000012734 14370413656 0023606 0 ustar 00root root 0000000 0000000 """This module defines actions (functions) that operate on layers.
Among other potential uses, these will populate the menu when you right-click
on a layer in the LayerList.
The Actions in LAYER_ACTIONS are registered with the application when it is
created in `_app_model._app`. Modifying this list at runtime will have no
effect. Use `app.register_action` to register new actions at runtime.
"""
from __future__ import annotations
from functools import partial
from typing import TYPE_CHECKING, List
from app_model.types import Action
from napari._app_model.constants import CommandId, MenuGroup, MenuId
from napari._app_model.context import LayerListContextKeys as LLCK
from napari.layers import _layer_actions
if TYPE_CHECKING:
from app_model.types import MenuRuleDict
# The following dicts define groups to which menu items in the layer list context menu can belong
# see https://app-model.readthedocs.io/en/latest/types/#app_model.types.MenuRule for details
LAYERCTX_SPLITMERGE: MenuRuleDict = {
'id': MenuId.LAYERLIST_CONTEXT,
'group': MenuGroup.LAYERLIST_CONTEXT.SPLIT_MERGE,
}
LAYERCTX_CONVERSION: MenuRuleDict = {
'id': MenuId.LAYERLIST_CONTEXT,
'group': MenuGroup.LAYERLIST_CONTEXT.CONVERSION,
}
LAYERCTX_LINK: MenuRuleDict = {
'id': MenuId.LAYERLIST_CONTEXT,
'group': MenuGroup.LAYERLIST_CONTEXT.LINK,
}
# Statically defined Layer actions.
# modifying this list at runtime has no effect.
LAYER_ACTIONS: List[Action] = [
Action(
id=CommandId.LAYER_DUPLICATE,
title=CommandId.LAYER_DUPLICATE.title,
callback=_layer_actions._duplicate_layer,
menus=[LAYERCTX_SPLITMERGE],
),
Action(
id=CommandId.LAYER_SPLIT_STACK,
title=CommandId.LAYER_SPLIT_STACK.title,
callback=_layer_actions._split_stack,
menus=[{**LAYERCTX_SPLITMERGE, 'when': ~LLCK.active_layer_is_rgb}],
enablement=LLCK.active_layer_is_image_3d,
),
Action(
id=CommandId.LAYER_SPLIT_RGB,
title=CommandId.LAYER_SPLIT_RGB.title,
callback=_layer_actions._split_rgb,
menus=[{**LAYERCTX_SPLITMERGE, 'when': LLCK.active_layer_is_rgb}],
enablement=LLCK.active_layer_is_rgb,
),
Action(
id=CommandId.LAYER_CONVERT_TO_LABELS,
title=CommandId.LAYER_CONVERT_TO_LABELS.title,
callback=_layer_actions._convert_to_labels,
enablement=(
(
(LLCK.num_selected_image_layers >= 1)
| (LLCK.num_selected_shapes_layers >= 1)
)
& LLCK.all_selected_layers_same_type
),
menus=[LAYERCTX_CONVERSION],
),
Action(
id=CommandId.LAYER_CONVERT_TO_IMAGE,
title=CommandId.LAYER_CONVERT_TO_IMAGE.title,
callback=_layer_actions._convert_to_image,
enablement=(
(LLCK.num_selected_labels_layers >= 1)
& LLCK.all_selected_layers_same_type
),
menus=[LAYERCTX_CONVERSION],
),
Action(
id=CommandId.LAYER_MERGE_STACK,
title=CommandId.LAYER_MERGE_STACK.title,
callback=_layer_actions._merge_stack,
enablement=(
(LLCK.num_selected_layers > 1)
& (LLCK.num_selected_image_layers == LLCK.num_selected_layers)
& LLCK.all_selected_layers_same_shape
),
menus=[LAYERCTX_SPLITMERGE],
),
Action(
id=CommandId.LAYER_TOGGLE_VISIBILITY,
title=CommandId.LAYER_TOGGLE_VISIBILITY.title,
callback=_layer_actions._toggle_visibility,
menus=[
{
'id': MenuId.LAYERLIST_CONTEXT,
'group': MenuGroup.NAVIGATION,
}
],
),
Action(
id=CommandId.LAYER_LINK_SELECTED,
title=CommandId.LAYER_LINK_SELECTED.title,
callback=_layer_actions._link_selected_layers,
enablement=(
(LLCK.num_selected_layers > 1) & ~LLCK.num_selected_layers_linked
),
menus=[{**LAYERCTX_LINK, 'when': ~LLCK.num_selected_layers_linked}],
),
Action(
id=CommandId.LAYER_UNLINK_SELECTED,
title=CommandId.LAYER_UNLINK_SELECTED.title,
callback=_layer_actions._unlink_selected_layers,
enablement=LLCK.num_selected_layers_linked,
menus=[{**LAYERCTX_LINK, 'when': LLCK.num_selected_layers_linked}],
),
Action(
id=CommandId.LAYER_SELECT_LINKED,
title=CommandId.LAYER_SELECT_LINKED.title,
callback=_layer_actions._select_linked_layers,
enablement=LLCK.num_unselected_linked_layers,
menus=[LAYERCTX_LINK],
),
]
for _dtype in (
'int8',
'int16',
'int32',
'int64',
'uint8',
'uint16',
'uint32',
'uint64',
):
cmd: CommandId = getattr(CommandId, f'LAYER_CONVERT_TO_{_dtype.upper()}')
LAYER_ACTIONS.append(
Action(
id=cmd,
title=cmd.title,
callback=partial(_layer_actions._convert_dtype, mode=_dtype),
enablement=(
LLCK.all_selected_layers_labels
& (LLCK.active_layer_dtype != _dtype)
),
menus=[{'id': MenuId.LAYERS_CONVERT_DTYPE}],
)
)
for mode in ('max', 'min', 'std', 'sum', 'mean', 'median'):
cmd: CommandId = getattr(CommandId, f'LAYER_PROJECT_{mode.upper()}')
LAYER_ACTIONS.append(
Action(
id=cmd,
title=cmd.title,
callback=partial(_layer_actions._project, mode=mode),
enablement=LLCK.active_layer_is_image_3d,
menus=[{'id': MenuId.LAYERS_PROJECT}],
)
)
napari-0.5.0a1/napari/_app_model/actions/_toggle_action.py 0000664 0000000 0000000 00000003300 14370413656 0023555 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
from app_model.types import Action, ToggleRule
if TYPE_CHECKING:
from napari.viewer import Viewer
class ViewerToggleAction(Action):
"""Action subclass that toggles a boolean viewer (sub)attribute on trigger.
Parameters
----------
id : str
The command id of the action.
title : str
The title of the action. Prefer capital case.
viewer_attribute : str
The attribute of the viewer to toggle. (e.g. 'axes')
sub_attribute : str
The attribute of the viewer attribute to toggle. (e.g. 'visible')
**kwargs
Additional keyword arguments to pass to the Action constructor.
Examples
--------
>>> action = ViewerToggleAction(
... id='some.command.id',
... title='Toggle Axis Visibility',
... viewer_attribute='axes',
... sub_attribute='visible',
... )
"""
def __init__(
self,
*,
id: str,
title: str,
viewer_attribute: str,
sub_attribute: str,
**kwargs,
) -> None:
def get_current(viewer: Viewer):
"""return the current value of the viewer attribute"""
attr = getattr(viewer, viewer_attribute)
return getattr(attr, sub_attribute)
def toggle(viewer: Viewer):
"""toggle the viewer attribute"""
attr = getattr(viewer, viewer_attribute)
setattr(attr, sub_attribute, not getattr(attr, sub_attribute))
super().__init__(
id=id,
title=title,
toggled=ToggleRule(get_current=get_current),
callback=toggle,
**kwargs,
)
napari-0.5.0a1/napari/_app_model/actions/_view_actions.py 0000664 0000000 0000000 00000004214 14370413656 0023436 0 ustar 00root root 0000000 0000000 """Actions related to the 'View' menu that do not require Qt.
View actions that do require Qt should go in
`napari/_qt/_qapp_model/qactions/_view.py`.
"""
from typing import List
from app_model.types import Action, ToggleRule
from napari._app_model.actions._toggle_action import ViewerToggleAction
from napari._app_model.constants import CommandId, MenuId
from napari.settings import get_settings
VIEW_ACTIONS: List[Action] = []
for cmd, viewer_attr, sub_attr in (
(CommandId.TOGGLE_VIEWER_AXES, 'axes', 'visible'),
(CommandId.TOGGLE_VIEWER_AXES_COLORED, 'axes', 'colored'),
(CommandId.TOGGLE_VIEWER_AXES_LABELS, 'axes', 'labels'),
(CommandId.TOGGLE_VIEWER_AXES_DASHED, 'axes', 'dashed'),
(CommandId.TOGGLE_VIEWER_AXES_ARROWS, 'axes', 'arrows'),
(CommandId.TOGGLE_VIEWER_SCALE_BAR, 'scale_bar', 'visible'),
(CommandId.TOGGLE_VIEWER_SCALE_BAR_COLORED, 'scale_bar', 'colored'),
(CommandId.TOGGLE_VIEWER_SCALE_BAR_TICKS, 'scale_bar', 'ticks'),
):
menu = MenuId.VIEW_AXES if viewer_attr == 'axes' else MenuId.VIEW_SCALEBAR
VIEW_ACTIONS.append(
ViewerToggleAction(
id=cmd,
title=cmd.title,
viewer_attribute=viewer_attr,
sub_attribute=sub_attr,
menus=[{'id': menu}],
)
)
def _tooltip_visibility_toggle():
settings = get_settings().appearance
settings.layer_tooltip_visibility = not settings.layer_tooltip_visibility
# this can be generalised for all boolean settings, similar to `ViewerToggleAction`
def _get_current_tooltip_visibility():
return get_settings().appearance.layer_tooltip_visibility
VIEW_ACTIONS.extend(
[
# TODO: this could be made into a toggle setting Action subclass
# using a similar pattern to the above ViewerToggleAction classes
Action(
id=CommandId.TOGGLE_LAYER_TOOLTIPS,
title=CommandId.TOGGLE_LAYER_TOOLTIPS.title,
menus=[
{'id': MenuId.MENUBAR_VIEW, 'group': '1_render', 'order': 10}
],
callback=_tooltip_visibility_toggle,
toggled=ToggleRule(get_current=_get_current_tooltip_visibility),
),
]
)
napari-0.5.0a1/napari/_app_model/constants/ 0000775 0000000 0000000 00000000000 14370413656 0020606 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_app_model/constants/__init__.py 0000664 0000000 0000000 00000000255 14370413656 0022721 0 ustar 00root root 0000000 0000000 from napari._app_model.constants._commands import CommandId
from napari._app_model.constants._menus import MenuGroup, MenuId
__all__ = ['CommandId', 'MenuGroup', 'MenuId']
napari-0.5.0a1/napari/_app_model/constants/_commands.py 0000664 0000000 0000000 00000016246 14370413656 0023131 0 ustar 00root root 0000000 0000000 """All commands that are available in the napari GUI are defined here.
Internally, prefer using the CommandId enum instead of the string literal.
When adding a new command, add a new title/description in the _COMMAND_INFO dict
below. The title will be used in the GUI, and the may be used in auto generated
documentation.
CommandId values should be namespaced, e.g. 'napari:layer:something' for a command
that operates on layers.
"""
from enum import Enum
from typing import NamedTuple, Optional
from napari.utils.translations import trans
# fmt: off
class CommandId(str, Enum):
"""Id representing a napari command."""
# View menubar
TOGGLE_FULLSCREEN = 'napari:window:view:toggle_fullscreen'
TOGGLE_MENUBAR = 'napari:window:view:toggle_menubar'
TOGGLE_PLAY = 'napari:window:view:toggle_play'
TOGGLE_OCTREE_CHUNK_OUTLINES = 'napari:window:view:toggle_octree_chunk_outlines'
TOGGLE_LAYER_TOOLTIPS = 'napari:window:view:toggle_layer_tooltips'
TOGGLE_ACTIVITY_DOCK = 'napari:window:view:toggle_activity_dock'
TOGGLE_VIEWER_AXES = 'napari:window:view:toggle_viewer_axes'
TOGGLE_VIEWER_AXES_COLORED = 'napari:window:view:toggle_viewer_axes_colored'
TOGGLE_VIEWER_AXES_LABELS = 'napari:window:view:toggle_viewer_axes_labels'
TOGGLE_VIEWER_AXES_DASHED = 'napari:window:view:toggle_viewer_axesdashed'
TOGGLE_VIEWER_AXES_ARROWS = 'napari:window:view:toggle_viewer_axes_arrows'
TOGGLE_VIEWER_SCALE_BAR = 'napari:window:view:toggle_viewer_scale_bar'
TOGGLE_VIEWER_SCALE_BAR_COLORED = 'napari:window:view:toggle_viewer_scale_bar_colored'
TOGGLE_VIEWER_SCALE_BAR_TICKS = 'napari:window:view:toggle_viewer_scale_bar_ticks'
# Help menubar
NAPARI_GETTING_STARTED = 'napari:window:help:getting_started'
NAPARI_TUTORIALS = 'napari:window:help:tutorials'
NAPARI_LAYERS_GUIDE = 'napari:window:help:layers_guide'
NAPARI_EXAMPLES = 'napari:window:help:examples'
NAPARI_RELEASE_NOTES = 'napari:window:help:release_notes'
NAPARI_HOMEPAGE = 'napari:window:help:homepage'
NAPARI_INFO = 'napari:window:help:info'
NAPARI_GITHUB_ISSUE = 'napari:window:help:github_issue'
TOGGLE_BUG_REPORT_OPT_IN = 'napari:window:help:bug_report_opt_in'
# Layer menubar
LAYER_DUPLICATE = 'napari:layer:duplicate'
LAYER_SPLIT_STACK = 'napari:layer:split_stack'
LAYER_SPLIT_RGB = 'napari:layer:split_rgb'
LAYER_MERGE_STACK = 'napari:layer:merge_stack'
LAYER_TOGGLE_VISIBILITY = 'napari:layer:toggle_visibility'
LAYER_LINK_SELECTED = 'napari:layer:link_selected_layers'
LAYER_UNLINK_SELECTED = 'napari:layer:unlink_selected_layers'
LAYER_SELECT_LINKED = 'napari:layer:select_linked_layers'
LAYER_CONVERT_TO_LABELS = 'napari:layer:convert_to_labels'
LAYER_CONVERT_TO_IMAGE = 'napari:layer:convert_to_image'
LAYER_CONVERT_TO_INT8 = 'napari:layer:convert_to_int8'
LAYER_CONVERT_TO_INT16 = 'napari:layer:convert_to_int16'
LAYER_CONVERT_TO_INT32 = 'napari:layer:convert_to_int32'
LAYER_CONVERT_TO_INT64 = 'napari:layer:convert_to_int64'
LAYER_CONVERT_TO_UINT8 = 'napari:layer:convert_to_uint8'
LAYER_CONVERT_TO_UINT16 = 'napari:layer:convert_to_uint16'
LAYER_CONVERT_TO_UINT32 = 'napari:layer:convert_to_uint32'
LAYER_CONVERT_TO_UINT64 = 'napari:layer:convert_to_uint64'
LAYER_PROJECT_MAX = 'napari:layer:project_max'
LAYER_PROJECT_MIN = 'napari:layer:project_min'
LAYER_PROJECT_STD = 'napari:layer:project_std'
LAYER_PROJECT_SUM = 'napari:layer:project_sum'
LAYER_PROJECT_MEAN = 'napari:layer:project_mean'
LAYER_PROJECT_MEDIAN = 'napari:layer:project_median'
@property
def title(self) -> str:
return _COMMAND_INFO[self].title
@property
def description(self) -> Optional[str]:
return _COMMAND_INFO[self].description
class _i(NamedTuple):
"""simple utility tuple for defining items in _COMMAND_INFO."""
title: str
description: Optional[str] = None
_COMMAND_INFO = {
# View menubar
CommandId.TOGGLE_FULLSCREEN: _i(trans._('Toggle Full Screen'),),
CommandId.TOGGLE_MENUBAR: _i(trans._('Toggle Menubar Visibility'),),
CommandId.TOGGLE_PLAY: _i(trans._('Toggle Play'),),
CommandId.TOGGLE_OCTREE_CHUNK_OUTLINES: _i(trans._('Toggle Chunk Outlines'),),
CommandId.TOGGLE_LAYER_TOOLTIPS: _i(trans._('Toggle Layer Tooltips'),),
CommandId.TOGGLE_ACTIVITY_DOCK: _i(trans._('Toggle Activity Dock'),),
CommandId.TOGGLE_VIEWER_AXES: _i(trans._('Axes Visible')),
CommandId.TOGGLE_VIEWER_AXES_COLORED: _i(trans._('Axes Colored')),
CommandId.TOGGLE_VIEWER_AXES_LABELS: _i(trans._('Axes Labels')),
CommandId.TOGGLE_VIEWER_AXES_DASHED: _i(trans._('Axes Dashed')),
CommandId.TOGGLE_VIEWER_AXES_ARROWS: _i(trans._('Axes Arrows')),
CommandId.TOGGLE_VIEWER_SCALE_BAR: _i(trans._('Scale Bar Visible')),
CommandId.TOGGLE_VIEWER_SCALE_BAR_COLORED: _i(trans._('Scale Bar Colored')),
CommandId.TOGGLE_VIEWER_SCALE_BAR_TICKS: _i(trans._('Scale Bar Ticks')),
# Help menubar
CommandId.NAPARI_GETTING_STARTED: _i(trans._('Getting started'), ),
CommandId.NAPARI_TUTORIALS: _i(trans._('Tutorials'), ),
CommandId.NAPARI_LAYERS_GUIDE: _i(trans._('Using Layers Guides'), ),
CommandId.NAPARI_EXAMPLES: _i(trans._('Examples Gallery'), ),
CommandId.NAPARI_RELEASE_NOTES: _i(trans._('Release Notes'), ),
CommandId.NAPARI_HOMEPAGE: _i(trans._('napari homepage'), ),
CommandId.NAPARI_INFO: _i(trans._('napari Info'), ),
CommandId.NAPARI_GITHUB_ISSUE: _i(trans._('Report an issue on GitHub'), ),
CommandId.TOGGLE_BUG_REPORT_OPT_IN: _i(trans._('Bug Reporting Opt In/Out...'), ),
# Layer menubar
CommandId.LAYER_DUPLICATE: _i(trans._('Duplicate Layer'),),
CommandId.LAYER_SPLIT_STACK: _i(trans._('Split Stack'),),
CommandId.LAYER_SPLIT_RGB: _i(trans._('Split RGB'),),
CommandId.LAYER_MERGE_STACK: _i(trans._('Merge to Stack'),),
CommandId.LAYER_TOGGLE_VISIBILITY: _i(trans._('Toggle visibility'),),
CommandId.LAYER_LINK_SELECTED: _i(trans._('Link Layers'),),
CommandId.LAYER_UNLINK_SELECTED: _i(trans._('Unlink Layers'),),
CommandId.LAYER_SELECT_LINKED: _i(trans._('Select Linked Layers'),),
CommandId.LAYER_CONVERT_TO_LABELS: _i(trans._('Convert to Labels'),),
CommandId.LAYER_CONVERT_TO_IMAGE: _i(trans._('Convert to Image'),),
CommandId.LAYER_CONVERT_TO_INT8: _i(trans._('Convert to int8'),),
CommandId.LAYER_CONVERT_TO_INT16: _i(trans._('Convert to int16'),),
CommandId.LAYER_CONVERT_TO_INT32: _i(trans._('Convert to int32'),),
CommandId.LAYER_CONVERT_TO_INT64: _i(trans._('Convert to int64'),),
CommandId.LAYER_CONVERT_TO_UINT8: _i(trans._('Convert to uint8'),),
CommandId.LAYER_CONVERT_TO_UINT16: _i(trans._('Convert to uint16'),),
CommandId.LAYER_CONVERT_TO_UINT32: _i(trans._('Convert to uint32'),),
CommandId.LAYER_CONVERT_TO_UINT64: _i(trans._('Convert to uint64'),),
CommandId.LAYER_PROJECT_MAX: _i(trans._('Max projection'),),
CommandId.LAYER_PROJECT_MIN: _i(trans._('Min projection'),),
CommandId.LAYER_PROJECT_STD: _i(trans._('Std projection'),),
CommandId.LAYER_PROJECT_SUM: _i(trans._('Sum projection'),),
CommandId.LAYER_PROJECT_MEAN: _i(trans._('Mean projection'),),
CommandId.LAYER_PROJECT_MEDIAN: _i(trans._('Median projection'),),
}
# fmt: on
napari-0.5.0a1/napari/_app_model/constants/_menus.py 0000664 0000000 0000000 00000003325 14370413656 0022451 0 ustar 00root root 0000000 0000000 """All Menus that are available anywhere in the napari GUI are defined here.
These might be menubar menus, context menus, or other menus. They could
even be "toolbars", such as the set of mode buttons on the layer list.
A "menu" needn't just be a literal QMenu (though it usually is): it is better
thought of as a set of related commands.
Internally, prefer using the `MenuId` enum instead of the string literal.
SOME of these (but definitely not all) will be exposed as "contributable"
menus for plugins to contribute commands and submenu items to.
"""
from enum import Enum
class MenuId(str, Enum):
"""Id representing a menu somewhere in napari."""
MENUBAR_VIEW = 'napari/view'
VIEW_AXES = 'napari/view/axes'
VIEW_SCALEBAR = 'napari/view/scalebar'
MENUBAR_HELP = 'napari/help'
LAYERLIST_CONTEXT = 'napari/layers/context'
LAYERS_CONVERT_DTYPE = 'napari/layers/convert_dtype'
LAYERS_PROJECT = 'napari/layers/project'
def __str__(self) -> str:
return self.value
# XXX: the structure/usage pattern of this class may change in the future
class MenuGroup:
NAVIGATION = 'navigation' # always the first group in any menu
RENDER = '1_render'
class LAYERLIST_CONTEXT:
CONVERSION = '1_conversion'
SPLIT_MERGE = '5_split_merge'
LINK = '9_link'
# TODO: add these to docs, with a lookup for what each menu is/does.
_CONTRIBUTABLES = {MenuId.LAYERLIST_CONTEXT.value}
"""Set of all menu ids that can be contributed to by plugins."""
def is_menu_contributable(menu_id: str) -> bool:
"""Return True if the given menu_id is a menu that plugins can contribute to."""
return (
menu_id in _CONTRIBUTABLES if menu_id.startswith("napari/") else True
)
napari-0.5.0a1/napari/_app_model/context/ 0000775 0000000 0000000 00000000000 14370413656 0020256 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_app_model/context/__init__.py 0000664 0000000 0000000 00000000426 14370413656 0022371 0 ustar 00root root 0000000 0000000 from napari._app_model.context._context import (
Context,
create_context,
get_context,
)
from napari._app_model.context._layerlist_context import LayerListContextKeys
__all__ = [
'Context',
'create_context',
'get_context',
'LayerListContextKeys',
]
napari-0.5.0a1/napari/_app_model/context/_context.py 0000664 0000000 0000000 00000005011 14370413656 0022450 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING, Any, Final, Optional
from app_model.expressions import Context, get_context
from app_model.expressions import create_context as _create_context
from napari.utils.translations import trans
if TYPE_CHECKING:
from napari.utils.events import Event
__all__ = ["create_context", "get_context", "Context", "SettingsAwareContext"]
class SettingsAwareContext(Context):
"""A special context that allows access of settings using `settings.`
This takes no parents, and will always be a root context.
"""
_PREFIX: Final[str] = 'settings.'
def __init__(self) -> None:
super().__init__()
from napari.settings import get_settings
self._settings = get_settings()
self._settings.events.changed.connect(self._update_key)
def _update_key(self, event: Event):
self.changed.emit({f'{self._PREFIX}{event.key}'})
def __del__(self):
self._settings.events.changed.disconnect(self._update_key)
def __missing__(self, key: str) -> Any:
if key.startswith(self._PREFIX):
splits = [k for k in key.split(".")[1:] if k]
val: Any = self._settings
if splits:
while splits:
val = getattr(val, splits.pop(0))
if hasattr(val, 'dict'):
val = val.dict()
return val
return super().__missing__(key)
def new_child(self, m: Optional[dict] = None) -> Context: # type: ignore
"""New ChainMap with a new map followed by all previous maps.
If no map is provided, an empty dict is used.
"""
# important to use self, not *self.maps
return Context(m or {}, self) # type: ignore
def __setitem__(self, k: str, v: Any) -> None:
if k.startswith(self._PREFIX):
raise ValueError(
trans._(
"Cannot set key starting with {prefix!r}",
deferred=True,
prefix=self._PREFIX,
)
)
return super().__setitem__(k, v)
def __bool__(self):
# settings mappings are always populated, so we can always return True
return True
def create_context(
obj: object,
max_depth: int = 20,
start: int = 2,
root: Optional[Context] = None,
) -> Optional[Context]:
return _create_context(
obj=obj,
max_depth=max_depth,
start=start,
root=root,
root_class=SettingsAwareContext,
)
napari-0.5.0a1/napari/_app_model/context/_context_keys.py 0000664 0000000 0000000 00000001141 14370413656 0023503 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING, Generic, TypeVar
from app_model.expressions import ContextNamespace as _ContextNamespace
if TYPE_CHECKING:
from napari.utils.events import Event
A = TypeVar("A")
class ContextNamespace(_ContextNamespace, Generic[A]):
"""A collection of related keys in a context
meant to be subclassed, with class attributes that are `ContextKeys`.
"""
def update(self, event: 'Event') -> None:
"""Trigger an update of all "getter" functions in this namespace."""
for k, get in self._getters.items():
setattr(self, k, get(event.source))
napari-0.5.0a1/napari/_app_model/context/_layerlist_context.py 0000664 0000000 0000000 00000015313 14370413656 0024546 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import contextlib
from typing import TYPE_CHECKING, Optional, Tuple
from app_model.expressions import ContextKey
from napari._app_model.context._context_keys import ContextNamespace
from napari.utils._dtype import normalize_dtype
from napari.utils.translations import trans
if TYPE_CHECKING:
from numpy.typing import DTypeLike
from napari.layers import Layer
from napari.utils.events import Selection
LayerSel = Selection[Layer]
def _len(s: LayerSel) -> int:
return len(s)
def _all_linked(s: LayerSel) -> bool:
from napari.layers.utils._link_layers import layer_is_linked
return bool(s and all(layer_is_linked(x) for x in s))
def _n_unselected_links(s: LayerSel) -> int:
from napari.layers.utils._link_layers import get_linked_layers
return len(get_linked_layers(*s) - s)
def _is_rgb(s: LayerSel) -> bool:
return getattr(s.active, "rgb", False)
def _only_img(s: LayerSel) -> bool:
return bool(s and all(x._type_string == "image" for x in s))
def _n_selected_imgs(s: LayerSel) -> int:
return sum(x._type_string == "image" for x in s)
def _only_labels(s: LayerSel) -> bool:
return bool(s and all(x._type_string == "labels" for x in s))
def _n_selected_labels(s: LayerSel) -> int:
return sum(x._type_string == "labels" for x in s)
def _only_points(s: LayerSel) -> bool:
return bool(s and all(x._type_string == "points" for x in s))
def _n_selected_points(s: LayerSel) -> int:
return sum(x._type_string == "points" for x in s)
def _only_shapes(s: LayerSel) -> bool:
return bool(s and all(x._type_string == "shapes" for x in s))
def _n_selected_shapes(s: LayerSel) -> int:
return sum(x._type_string == "shapes" for x in s)
def _only_surface(s: LayerSel) -> bool:
return bool(s and all(x._type_string == "surface" for x in s))
def _n_selected_surfaces(s: LayerSel) -> int:
return sum(x._type_string == "surface" for x in s)
def _only_vectors(s: LayerSel) -> bool:
return bool(s and all(x._type_string == "vectors" for x in s))
def _n_selected_vectors(s: LayerSel) -> int:
return sum(x._type_string == "vectors" for x in s)
def _only_tracks(s: LayerSel) -> bool:
return bool(s and all(x._type_string == "tracks" for x in s))
def _n_selected_tracks(s: LayerSel) -> int:
return sum(x._type_string == "tracks" for x in s)
def _active_type(s: LayerSel) -> Optional[str]:
return s.active._type_string if s.active else None
def _active_ndim(s: LayerSel) -> Optional[int]:
return getattr(s.active.data, "ndim", None) if s.active else None
def _active_shape(s: LayerSel) -> Optional[Tuple[int, ...]]:
return getattr(s.active.data, "shape", None) if s.active else None
def _same_shape(s: LayerSel) -> bool:
return len({getattr(x.data, "shape", ()) for x in s}) == 1
def _active_dtype(s: LayerSel) -> DTypeLike:
dtype = None
if s.active:
with contextlib.suppress(AttributeError):
dtype = normalize_dtype(s.active.data.dtype).__name__
return dtype
def _same_type(s: LayerSel) -> bool:
return len({x._type_string for x in s}) == 1
def _active_is_image_3d(s: LayerSel) -> bool:
return (
_active_type(s) == "image"
and _active_ndim(s) is not None
and (_active_ndim(s) > 3 or (_active_ndim(s) > 2 and not _is_rgb(s)))
)
class LayerListContextKeys(ContextNamespace['LayerSel']):
"""These are the available context keys relating to a LayerList.
along with default value, a description, and a function to retrieve the
current value from layers.selection
"""
num_selected_layers = ContextKey(
0,
trans._("Number of currently selected layers."),
_len,
)
num_selected_layers_linked = ContextKey(
False,
trans._("True when all selected layers are linked."),
_all_linked,
)
num_unselected_linked_layers = ContextKey(
0,
trans._("Number of unselected layers linked to selected layer(s)."),
_n_unselected_links,
)
active_layer_is_rgb = ContextKey(
False,
trans._("True when the active layer is RGB."),
_is_rgb,
)
active_layer_type = ContextKey['LayerSel', Optional[str]](
None,
trans._(
"Lowercase name of active layer type, or None of none active."
),
_active_type,
)
# TODO: try to reduce these `num_selected_x_layers` to a single set of strings
# or something... however, this would require that our context expressions
# support Sets, tuples, lists, etc... which they currently do not.
num_selected_image_layers = ContextKey(
0,
trans._("Number of selected image layers."),
_n_selected_imgs,
)
num_selected_labels_layers = ContextKey(
0,
trans._("Number of selected labels layers."),
_n_selected_labels,
)
num_selected_points_layers = ContextKey(
0,
trans._("Number of selected points layers."),
_n_selected_points,
)
num_selected_shapes_layers = ContextKey(
0,
trans._("Number of selected shapes layers."),
_n_selected_shapes,
)
num_selected_surface_layers = ContextKey(
0,
trans._("Number of selected surface layers."),
_n_selected_surfaces,
)
num_selected_vectors_layers = ContextKey(
0,
trans._("Number of selected vectors layers."),
_n_selected_vectors,
)
num_selected_tracks_layers = ContextKey(
0,
trans._("Number of selected tracks layers."),
_n_selected_tracks,
)
active_layer_ndim = ContextKey['LayerSel', Optional[int]](
None,
trans._(
"Number of dimensions in the active layer, or `None` if nothing is active."
),
_active_ndim,
)
active_layer_shape = ContextKey['LayerSel', Optional[Tuple[int, ...]]](
(),
trans._("Shape of the active layer, or `None` if nothing is active."),
_active_shape,
)
active_layer_is_image_3d = ContextKey(
False,
trans._("True when the active layer is a 3D image."),
_active_is_image_3d,
)
active_layer_dtype = ContextKey(
None,
trans._("Dtype of the active layer, or `None` if nothing is active."),
_active_dtype,
)
all_selected_layers_same_shape = ContextKey(
False,
trans._("True when all selected layers have the same shape."),
_same_shape,
)
all_selected_layers_same_type = ContextKey(
False,
trans._("True when all selected layers are of the same type."),
_same_type,
)
all_selected_layers_labels = ContextKey(
False,
trans._("True when all selected layers are labels."),
_only_labels,
)
napari-0.5.0a1/napari/_app_model/injection/ 0000775 0000000 0000000 00000000000 14370413656 0020554 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_app_model/injection/__init__.py 0000664 0000000 0000000 00000000000 14370413656 0022653 0 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_app_model/injection/_processors.py 0000664 0000000 0000000 00000013135 14370413656 0023472 0 ustar 00root root 0000000 0000000 import sys
from concurrent.futures import Future
from contextlib import nullcontext, suppress
from functools import partial
from typing import Any, Callable, Dict, List, Optional, Set, Union
from napari import layers, types, viewer
from napari._app_model.injection._providers import _provide_viewer
from napari.layers._source import layer_source
def _add_layer_data_tuples_to_viewer(
data: Union[types.LayerDataTuple, List[types.LayerDataTuple]],
return_type=None,
viewer=None,
source: Optional[dict] = None,
):
from napari.utils.misc import ensure_list_of_layer_data_tuple
if viewer is None:
viewer = _provide_viewer()
if viewer and data is not None:
data = data if isinstance(data, list) else [data]
for datum in ensure_list_of_layer_data_tuple(data):
# then try to update a viewer layer with the same name.
if len(datum) > 1 and (name := datum[1].get("name")):
with suppress(KeyError):
layer = viewer.layers[name]
layer.data = datum[0]
for k, v in datum[1].items():
setattr(layer, k, v)
continue
with layer_source(**source) if source else nullcontext():
# otherwise create a new layer from the layer data
viewer._add_layer_from_data(*datum)
def _add_layer_data_to_viewer(
data: Any,
return_type: Any,
viewer: Optional[viewer.Viewer] = None,
layer_name: Optional[str] = None,
source: Optional[dict] = None,
):
"""Show a result in the viewer.
Parameters
----------
data : Any
The result of the function call. For this function, this should be
*just* the data part of the corresponding layer type.
return_type : Any
The return annotation that was used in the decorated function.
viewer : Optional[Viewer]
An optional viewer to use. Otherwise use current viewer.
layer_name : Optional[str]
An optional layer name to use. If a layer with this name exists, it will
be updated.
source : Optional[dict]
An optional layer source to use.
Examples
--------
This allows the user to do this, and add the result as a viewer Image.
>>> def make_layer() -> napari.types.ImageData:
... return np.random.rand(256, 256)
"""
if data is not None and (viewer := viewer or _provide_viewer()):
if layer_name:
with suppress(KeyError):
viewer.layers[layer_name].data = data
return
layer_type = return_type.__name__.replace("Data", "").lower()
with layer_source(**source) if source else nullcontext():
getattr(viewer, f'add_{layer_type}')(data=data, name=layer_name)
def _add_layer_to_viewer(
layer: layers.Layer,
viewer: Optional[viewer.Viewer] = None,
source: Optional[dict] = None,
):
if layer is not None and (viewer := viewer or _provide_viewer()):
layer._source = layer.source.copy(update=source or {})
viewer.add_layer(layer)
# here to prevent garbace collection of the future object while processing.
_FUTURES: Set[Future] = set()
def _add_future_data(
future: Future,
return_type: Any,
_from_tuple=True,
viewer: Optional[viewer.Viewer] = None,
source: dict = None,
):
"""Process a Future object.
This function will be called to process function that has a
return annotation of one of the `napari.types.Data` ... and
will add the data in `result` to the current viewer as the corresponding
layer type.
Parameters
----------
future : Future
An instance of `concurrent.futures.Future` (or any third-party) object
with the same interface, that provides `add_done_callback` and `result`
methods. When the future is `done()`, the `result()` will be added
to the viewer.
return_type : type
The return annotation that was used in the decorated function.
_from_tuple : bool, optional
(only for internal use). True if the future returns `LayerDataTuple`,
False if it returns one of the `LayerData` types.
"""
# when the future is done, add layer data to viewer, dispatching
# to the appropriate method based on the Future data type.
adder = (
_add_layer_data_tuples_to_viewer
if _from_tuple
else _add_layer_data_to_viewer
)
def _on_future_ready(f: Future):
adder(
f.result(),
return_type=return_type,
viewer=viewer,
source=source,
)
_FUTURES.discard(future)
# We need the callback to happen in the main thread...
# This still works (no-op) in a headless environment, but
# we could be even more granular with it, with a function
# that checks if we're actually in a QApp before wrapping.
# with suppress(ImportError):
# from superqt.utils import ensure_main_thread
# _on_future_ready = ensure_main_thread(_on_future_ready)
future.add_done_callback(_on_future_ready)
_FUTURES.add(future)
# Add future and LayerData processors for each layer type.
PROCESSORS: Dict[object, Callable] = {
types.LayerDataTuple: _add_layer_data_tuples_to_viewer,
List[types.LayerDataTuple]: _add_layer_data_tuples_to_viewer,
layers.Layer: _add_layer_to_viewer,
}
for t in types._LayerData.__args__: # type: ignore [attr-defined]
PROCESSORS[t] = partial(_add_layer_data_to_viewer, return_type=t)
if sys.version_info >= (3, 9):
PROCESSORS[Future[t]] = partial(
_add_future_data, return_type=t, _from_tuple=False
)
napari-0.5.0a1/napari/_app_model/injection/_providers.py 0000664 0000000 0000000 00000001147 14370413656 0023305 0 ustar 00root root 0000000 0000000 from typing import Optional
from napari import components, layers, viewer
def _provide_viewer() -> Optional[viewer.Viewer]:
return viewer.current_viewer()
def _provide_active_layer() -> Optional[layers.Layer]:
return v.layers.selection.active if (v := _provide_viewer()) else None
def _provide_active_layer_list() -> Optional[components.LayerList]:
return v.layers if (v := _provide_viewer()) else None
# syntax could be simplified after
# https://github.com/tlambert03/in-n-out/issues/31
PROVIDERS = [
(_provide_viewer,),
(_provide_active_layer,),
(_provide_active_layer_list,),
]
napari-0.5.0a1/napari/_event_loop.py 0000664 0000000 0000000 00000000404 14370413656 0017354 0 ustar 00root root 0000000 0000000 try:
from napari._qt.qt_event_loop import gui_qt, run
# qtpy raises a RuntimeError if no Qt bindings can be found
except (ImportError, RuntimeError) as e:
exc = e
def gui_qt(**kwargs):
raise exc
def run(**kwargs):
raise exc
napari-0.5.0a1/napari/_lazy.py 0000664 0000000 0000000 00000004334 14370413656 0016167 0 ustar 00root root 0000000 0000000 from importlib import import_module
def install_lazy(module_name, submodules=None, submod_attrs=None):
"""Install lazily loaded submodules, and functions or other attributes.
Parameters
----------
module_name : str
Typically use __name__.
submodules : set
List of submodules to install.
submod_attrs : dict
Dictionary of submodule -> list of attributes / functions.
These attributes are imported as they are used.
Returns
-------
__getattr__, __dir__, __all__
"""
if submod_attrs is None:
submod_attrs = {}
if submodules is None:
submodules = set()
else:
submodules = set(submodules)
attr_to_modules = {
attr: mod for mod, attrs in submod_attrs.items() for attr in attrs
}
__all__ = list(submodules | attr_to_modules.keys())
def __getattr__(name):
# this unused import is here to fix a very strange bug.
# there is some mysterious magical goodness in scipy stats that needs
# to be imported early.
# see: https://github.com/napari/napari/issues/925
# see: https://github.com/napari/napari/issues/1347
from scipy import stats # noqa: F401
if name in submodules:
return import_module(f'{module_name}.{name}')
elif name in attr_to_modules:
try:
submod = import_module(
f'{module_name}.{attr_to_modules[name]}'
)
except AttributeError as er:
# if we want any useful error message to show
# (besides just "cannot import name...") then we need raise anything
# BUT an attribute error here, because the __getattr__ protocol will
# swallow that error.
raise ImportError(
f'Failed to import {attr_to_modules[name]} from {module_name}. '
'See cause above'
) from er
# this is where we allow an attribute error to be raised.
return getattr(submod, name)
else:
raise AttributeError(f'No {module_name} attribute {name}')
def __dir__():
return __all__
return __getattr__, __dir__, __all__
napari-0.5.0a1/napari/_qt/ 0000775 0000000 0000000 00000000000 14370413656 0015256 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/__init__.py 0000664 0000000 0000000 00000005402 14370413656 0017370 0 ustar 00root root 0000000 0000000 import os
import sys
from pathlib import Path
from warnings import warn
from napari.utils.translations import trans
try:
from qtpy import API_NAME, QT_VERSION, QtCore
except Exception as e:
if 'No Qt bindings could be found' in str(e):
raise ImportError(
trans._(
"No Qt bindings could be found.\n\nnapari requires either PyQt5 or PySide2 to be installed in the environment.\nTo install the default backend (currently PyQt5), run \"pip install napari[all]\" \nYou may also use \"pip install napari[pyside2]\"for Pyside2, or \"pip install napari[pyqt5]\" for PyQt5",
deferred=True,
)
) from e
raise
if API_NAME == 'PySide2':
# Set plugin path appropriately if using PySide2. This is a bug fix
# for when both PyQt5 and Pyside2 are installed
import PySide2
os.environ['QT_PLUGIN_PATH'] = str(
Path(PySide2.__file__).parent / 'Qt' / 'plugins'
)
if API_NAME == 'PySide6' and sys.version_info[:2] < (3, 10):
from packaging import version
if version.parse(QT_VERSION) > version.parse("6.3.1"):
raise RuntimeError(
trans._(
"Napari is not expected to work with PySide6 >= 6.3.2 on Python < 3.10",
deferred=True,
)
)
# When QT is not the specific version, we raise a warning:
if tuple(int(x) for x in QtCore.__version__.split('.')[:3]) < (5, 12, 3):
import importlib.metadata
try:
dist_info_version = importlib.metadata.version(API_NAME)
if dist_info_version != QtCore.__version__:
warn_message = trans._(
"\n\nIMPORTANT:\nYou are using QT version {version}, but version {dversion} was also found in your environment.\nThis usually happens when you 'conda install' something that also depends on PyQt\n*after* you have pip installed napari (such as jupyter notebook).\nYou will likely run into problems and should create a fresh environment.\nIf you want to install conda packages into the same environment as napari,\nplease add conda-forge to your channels: https://conda-forge.org\n",
deferred=True,
version=QtCore.__version__,
dversion=dist_info_version,
)
except ModuleNotFoundError:
warn_message = trans._(
"\n\nnapari was tested with QT library `>=5.12.3`.\nThe version installed is {version}. Please report any issues with\nthis specific QT version at https://github.com/Napari/napari/issues.",
deferred=True,
version=QtCore.__version__,
)
warn(message=warn_message)
from napari._qt.qt_event_loop import get_app, gui_qt, quit_app, run
from napari._qt.qt_main_window import Window
__all__ = ["get_app", "gui_qt", "quit_app", "run", "Window"]
napari-0.5.0a1/napari/_qt/_qapp_model/ 0000775 0000000 0000000 00000000000 14370413656 0017536 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/_qapp_model/__init__.py 0000664 0000000 0000000 00000000242 14370413656 0021645 0 ustar 00root root 0000000 0000000 """Helper functions to create Qt objects from app-model objects."""
from napari._qt._qapp_model._menus import build_qmodel_menu
__all__ = ['build_qmodel_menu']
napari-0.5.0a1/napari/_qt/_qapp_model/_menus.py 0000664 0000000 0000000 00000001460 14370413656 0021377 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING, Optional
from app_model.backends.qt import QModelMenu
if TYPE_CHECKING:
from qtpy.QtWidgets import QWidget
def build_qmodel_menu(
menu_id: str,
title: Optional[str] = None,
parent: Optional['QWidget'] = None,
) -> QModelMenu:
"""Build a QModelMenu from the napari app model
Parameters
----------
menu_id : str
ID of a menu registered with napari._app_model.get_app().menus
title : Optional[str]
Title of the menu
parent : Optional[QWidget]
Parent of the menu
Returns
-------
QModelMenu
QMenu subclass populated with all items in `menu_id` menu.
"""
from napari._app_model import get_app
return QModelMenu(
menu_id=menu_id, app=get_app(), title=title, parent=parent
)
napari-0.5.0a1/napari/_qt/_qapp_model/_tests/ 0000775 0000000 0000000 00000000000 14370413656 0021037 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/_qapp_model/_tests/test_qapp_model_menus.py 0000664 0000000 0000000 00000001555 14370413656 0026006 0 ustar 00root root 0000000 0000000 from unittest.mock import MagicMock
import pytest
from napari import viewer
from napari._app_model import constants, get_app
from napari._qt._qapp_model import build_qmodel_menu
from napari._qt._qapp_model.qactions import init_qactions
from napari._qt.qt_main_window import Window
@pytest.mark.parametrize('menu_id', list(constants.MenuId))
def test_build_qmodel_menu(qtbot, menu_id):
"""Test that we can build qmenus for all registered menu IDs"""
app = get_app()
mock = MagicMock()
with app.injection_store.register(
providers={viewer.Viewer: lambda: mock, Window: lambda: mock}
):
init_qactions.cache_clear()
init_qactions()
menu = build_qmodel_menu(menu_id)
qtbot.addWidget(menu)
# `>=` because separator bars count as actions
assert len(menu.actions()) >= len(app.menus.get_menu(menu_id))
napari-0.5.0a1/napari/_qt/_qapp_model/qactions/ 0000775 0000000 0000000 00000000000 14370413656 0021357 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/_qapp_model/qactions/__init__.py 0000664 0000000 0000000 00000003643 14370413656 0023476 0 ustar 00root root 0000000 0000000 from functools import lru_cache
from itertools import chain
from typing import Optional
# Submodules should be able to import from most modules, so to
# avoid circular imports, don't import submodules at the top level here,
# import them inside the init_qactions function.
@lru_cache # only call once
def init_qactions() -> None:
"""Initialize all Qt-based Actions with app-model
This function will be called in _QtMainWindow.__init__(). It should only
be called once (hence the lru_cache decorator).
It is responsible for:
- injecting Qt-specific names into the application injection_store namespace
(this is what allows functions to be declared with annotations like
`def foo(window: Window)` or `def foo(qt_viewer: QtViewer)`)
- registering provider functions for the names added to the namespace
- registering Qt-dependent actions with app-model (i.e. Q_*_ACTIONS actions).
"""
from napari._app_model import get_app
from napari._qt._qapp_model.qactions._help import Q_HELP_ACTIONS
from napari._qt._qapp_model.qactions._view import Q_VIEW_ACTIONS
from napari._qt.qt_main_window import Window, _QtMainWindow
from napari._qt.qt_viewer import QtViewer
# update the namespace with the Qt-specific types/providers/processors
app = get_app()
store = app.injection_store
store.namespace = {
**store.namespace,
'Window': Window,
'QtViewer': QtViewer,
}
# Qt-specific providers/processors
@store.register_provider
def _provide_window() -> Optional[Window]:
if _qmainwin := _QtMainWindow.current():
return _qmainwin._window
@store.register_provider
def _provide_qt_viewer() -> Optional[QtViewer]:
if _qmainwin := _QtMainWindow.current():
return _qmainwin._qt_viewer
# register actions
for action in chain(Q_VIEW_ACTIONS, Q_HELP_ACTIONS):
app.register_action(action)
napari-0.5.0a1/napari/_qt/_qapp_model/qactions/_help.py 0000664 0000000 0000000 00000002444 14370413656 0023024 0 ustar 00root root 0000000 0000000 """Actions related to the 'Help' menu that require Qt.
'Help' actions that do not require Qt should go in a new '_help_actions.py'
file within `napari/_app_model/actions/`.
"""
from typing import List
from app_model.types import Action, KeyBindingRule, KeyCode, KeyMod
from napari._app_model.constants import CommandId, MenuGroup, MenuId
from napari._qt.dialogs.qt_about import QtAbout
from napari._qt.qt_main_window import Window
from napari.utils.translations import trans
try:
from napari_error_reporter import ask_opt_in
except ModuleNotFoundError:
ask_opt_in = None
def _show_about(window: Window):
QtAbout.showAbout(window._qt_window)
Q_HELP_ACTIONS: List[Action] = [
Action(
id=CommandId.NAPARI_INFO,
title=CommandId.NAPARI_INFO.title,
callback=_show_about,
menus=[{"id": MenuId.MENUBAR_HELP, 'group': MenuGroup.RENDER}],
status_tip=trans._('About napari'),
keybindings=[KeyBindingRule(primary=KeyMod.CtrlCmd | KeyCode.Slash)],
)
]
if ask_opt_in is not None:
Q_HELP_ACTIONS.append(
Action(
id=CommandId.TOGGLE_BUG_REPORT_OPT_IN,
title=CommandId.TOGGLE_BUG_REPORT_OPT_IN.title,
callback=lambda: ask_opt_in(force=True),
menus=[{"id": MenuId.MENUBAR_HELP}],
)
)
napari-0.5.0a1/napari/_qt/_qapp_model/qactions/_view.py 0000664 0000000 0000000 00000006132 14370413656 0023044 0 ustar 00root root 0000000 0000000 """Actions related to the 'View' menu that require Qt.
'View' actions that do not require Qt should go in
`napari/_app_model/actions/_view_actions.py`.
"""
import sys
from typing import List
from app_model.types import (
Action,
KeyCode,
KeyMod,
StandardKeyBinding,
ToggleRule,
)
from napari._app_model.constants import CommandId, MenuGroup, MenuId
from napari._qt.qt_main_window import Window
from napari._qt.qt_viewer import QtViewer
from napari.settings import get_settings
from napari.utils.translations import trans
def _toggle_activity_dock(window: Window):
window._status_bar._toggle_activity_dock()
def _get_current_activity_dock(window: Window):
return window._qt_window._activity_dialog.isVisible()
Q_VIEW_ACTIONS: List[Action] = [
Action(
id=CommandId.TOGGLE_FULLSCREEN,
title=CommandId.TOGGLE_FULLSCREEN.title,
menus=[
{
'id': MenuId.MENUBAR_VIEW,
'group': MenuGroup.NAVIGATION,
'order': 1,
}
],
callback=Window._toggle_fullscreen,
keybindings=[StandardKeyBinding.FullScreen],
),
Action(
id=CommandId.TOGGLE_MENUBAR,
title=CommandId.TOGGLE_MENUBAR.title,
menus=[
{
'id': MenuId.MENUBAR_VIEW,
'group': MenuGroup.NAVIGATION,
'order': 2,
'when': sys.platform != 'darwin',
}
],
callback=Window._toggle_menubar_visible,
keybindings=[
{
'win': KeyMod.CtrlCmd | KeyCode.KeyM,
'linux': KeyMod.CtrlCmd | KeyCode.KeyM,
}
],
# TODO: add is_mac global context keys (rather than boolean here)
enablement=sys.platform != 'darwin',
status_tip=trans._('Show/Hide Menubar'),
),
Action(
id=CommandId.TOGGLE_PLAY,
title=CommandId.TOGGLE_PLAY.title,
menus=[
{
'id': MenuId.MENUBAR_VIEW,
'group': MenuGroup.NAVIGATION,
'order': 3,
}
],
callback=Window._toggle_play,
keybindings=[{'primary': KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyP}],
),
Action(
id=CommandId.TOGGLE_OCTREE_CHUNK_OUTLINES,
title=CommandId.TOGGLE_OCTREE_CHUNK_OUTLINES.title,
menus=[
{
'id': MenuId.MENUBAR_VIEW,
'group': MenuGroup.RENDER,
'order': 1,
'when': get_settings().experimental.octree,
}
],
callback=QtViewer._toggle_chunk_outlines,
enablement=get_settings().experimental.octree,
# this used to have a keybinding of Ctrl+Alt+O, but that conflicts with
# Open files as stack
),
Action(
id=CommandId.TOGGLE_ACTIVITY_DOCK,
title=CommandId.TOGGLE_ACTIVITY_DOCK.title,
menus=[
{'id': MenuId.MENUBAR_VIEW, 'group': MenuGroup.RENDER, 'order': 11}
],
callback=_toggle_activity_dock,
toggled=ToggleRule(get_current=_get_current_activity_dock),
),
]
napari-0.5.0a1/napari/_qt/_tests/ 0000775 0000000 0000000 00000000000 14370413656 0016557 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/_tests/__init__.py 0000664 0000000 0000000 00000000000 14370413656 0020656 0 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/_tests/test_app.py 0000664 0000000 0000000 00000004332 14370413656 0020752 0 ustar 00root root 0000000 0000000 import os
from collections import defaultdict
from unittest.mock import Mock
import pytest
from qtpy.QtWidgets import QAction, QShortcut
from napari import Viewer
from napari._qt.qt_event_loop import _ipython_has_eventloop, run, set_app_id
@pytest.mark.skipif(os.name != "Windows", reason="Windows specific")
def test_windows_grouping_overwrite(qapp):
import ctypes
def get_app_id():
mem = ctypes.POINTER(ctypes.c_wchar)()
ctypes.windll.shell32.GetCurrentProcessExplicitAppUserModelID(
ctypes.byref(mem)
)
res = ctypes.wstring_at(mem)
ctypes.windll.Ole32.CoTaskMemFree(mem)
return res
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID("test_text")
assert get_app_id() == "test_text"
set_app_id("custom_string")
assert get_app_id() == "custom_string"
set_app_id("")
assert get_app_id() == ""
def test_run_outside_ipython(qapp, monkeypatch):
"""Test that we don't incorrectly give ipython the event loop."""
assert not _ipython_has_eventloop()
v1 = Viewer(show=False)
assert not _ipython_has_eventloop()
v2 = Viewer(show=False)
assert not _ipython_has_eventloop()
with monkeypatch.context() as m:
mock_exec = Mock()
m.setattr(qapp, 'exec_', mock_exec)
run()
mock_exec.assert_called_once()
v1.close()
v2.close()
def test_shortcut_collision(make_napari_viewer):
viewer = make_napari_viewer()
defined_shortcuts = defaultdict(list)
problematic_shortcuts = []
shortcuts = viewer.window._qt_window.findChildren(QShortcut)
for shortcut in shortcuts:
key = shortcut.key().toString()
if key == "Ctrl+M":
# menubar toggle support
# https://github.com/napari/napari/pull/3204
continue
if key and key in defined_shortcuts:
problematic_shortcuts.append(key)
defined_shortcuts[key].append(key)
actions = viewer.window._qt_window.findChildren(QAction)
for action in actions:
key = action.shortcut().toString()
if key and key in defined_shortcuts:
problematic_shortcuts.append(key)
defined_shortcuts[key].append(key)
assert not problematic_shortcuts
napari-0.5.0a1/napari/_qt/_tests/test_plugin_widgets.py 0000664 0000000 0000000 00000015220 14370413656 0023214 0 ustar 00root root 0000000 0000000 from itertools import dropwhile
from unittest.mock import Mock, patch
import pytest
from napari_plugin_engine import napari_hook_implementation
from qtpy.QtWidgets import QWidget
import napari
from napari import Viewer
from napari._qt.menus import PluginsMenu
from napari._qt.qt_main_window import _instantiate_dock_widget
from napari.utils._proxies import PublicOnlyProxy
class Widg1(QWidget):
pass
class Widg2(QWidget):
def __init__(self, napari_viewer) -> None:
self.viewer = napari_viewer
super().__init__()
class Widg3(QWidget):
def __init__(self, v: Viewer) -> None:
self.viewer = v
super().__init__()
def fail(self):
"""private attr not allowed"""
self.viewer.window._qt_window
def magicfunc(viewer: 'napari.Viewer'):
return viewer
dwidget_args = {
'single_class': Widg1,
'class_tuple': (Widg1, {'area': 'right'}),
'tuple_list': [(Widg1, {'area': 'right'}), (Widg2, {})],
'tuple_list2': [(Widg1, {'area': 'right'}), Widg2],
'bad_class': 1,
'bad_tuple1': (Widg1, 1),
'bad_double_tuple': ((Widg1, {}), (Widg2, {})),
}
# napari_plugin_manager from _testsupport.py
# monkeypatch, request, recwarn fixtures are from pytest
@pytest.mark.parametrize('arg', dwidget_args.values(), ids=dwidget_args.keys())
def test_dock_widget_registration(
arg, napari_plugin_manager, request, recwarn
):
"""Test that dock widgets get validated and registerd correctly."""
class Plugin:
@napari_hook_implementation
def napari_experimental_provide_dock_widget():
return arg
napari_plugin_manager.register(Plugin, name='Plugin')
napari_plugin_manager.discover_widgets()
widgets = napari_plugin_manager._dock_widgets
if '[bad_' in request.node.name:
assert len(recwarn) == 1
assert not widgets
else:
assert len(recwarn) == 0
assert widgets['Plugin']['Widg1'][0] == Widg1
if 'tuple_list' in request.node.name:
assert widgets['Plugin']['Widg2'][0] == Widg2
@pytest.fixture
def test_plugin_widgets(monkeypatch, napari_plugin_manager):
"""A smattering of example registered dock widgets and function widgets."""
tnpm = napari_plugin_manager
dock_widgets = {
"TestP1": {"Widg1": (Widg1, {}), "Widg2": (Widg2, {})},
"TestP2": {"Widg3": (Widg3, {})},
}
monkeypatch.setattr(tnpm, "_dock_widgets", dock_widgets)
function_widgets = {'TestP3': {'magic': magicfunc}}
monkeypatch.setattr(tnpm, "_function_widgets", function_widgets)
yield
def test_plugin_widgets_menus(test_plugin_widgets, qtbot):
"""Test the plugin widgets get added to the window menu correctly."""
# only take the plugin actions
window = Mock()
qtwin = QWidget()
qtbot.addWidget(qtwin)
with patch.object(window, '_qt_window', qtwin):
actions = PluginsMenu(window=window).actions()
actions = list(dropwhile(lambda a: a.text() != '', actions))
texts = [a.text() for a in actions][1:]
for t in ['TestP1', 'Widg3 (TestP2)', 'magic (TestP3)']:
assert t in texts
# Expect a submenu ("Test plugin1") with particular entries.
tp1 = next(m for m in actions if m.text() == 'TestP1')
assert tp1.parent()
assert [a.text() for a in tp1.parent().actions()] == ['Widg1', 'Widg2']
def test_making_plugin_dock_widgets(test_plugin_widgets, make_napari_viewer):
"""Test that we can create dock widgets, and they get the viewer."""
viewer = make_napari_viewer()
# only take the plugin actions
actions = viewer.window.plugins_menu.actions()
actions = list(dropwhile(lambda a: a.text() != '', actions))
# trigger the 'TestP2: Widg3' action
tp2 = next(m for m in actions if m.text().endswith('(TestP2)'))
tp2.trigger()
# make sure that a dock widget was created
assert 'Widg3 (TestP2)' in viewer.window._dock_widgets
dw = viewer.window._dock_widgets['Widg3 (TestP2)']
assert isinstance(dw.widget(), Widg3)
# This widget uses the parameter annotation method to receive a viewer
assert isinstance(dw.widget().viewer, napari.Viewer)
# Add twice is ok, only does a show
tp2.trigger()
# trigger the 'TestP1 > Widg2' action (it's in a submenu)
tp2 = next(m for m in actions if m.text().endswith('TestP1'))
action = tp2.parent().actions()[1]
assert action.text() == 'Widg2'
action.trigger()
# make sure that a dock widget was created
assert 'Widg2 (TestP1)' in viewer.window._dock_widgets
dw = viewer.window._dock_widgets['Widg2 (TestP1)']
assert isinstance(dw.widget(), Widg2)
# This widget uses parameter *name* "napari_viewer" to get a viewer
assert isinstance(dw.widget().viewer, napari.Viewer)
# Add twice is ok, only does a show
action.trigger()
# Check that widget is still there when closed.
widg = dw.widget()
dw.title.hide_button.click()
assert widg
# Check that widget is destroyed when closed.
dw.destroyOnClose()
assert action not in viewer.window.plugins_menu.actions()
assert not widg.parent()
def test_making_function_dock_widgets(test_plugin_widgets, make_napari_viewer):
"""Test that we can create magicgui widgets, and they get the viewer."""
import magicgui
viewer = make_napari_viewer()
# only take the plugin actions
actions = viewer.window.plugins_menu.actions()
actions = dropwhile(lambda a: a.text() != '', actions)
# trigger the 'TestP3: magic' action
tp3 = next(m for m in actions if m.text().endswith('(TestP3)'))
tp3.trigger()
# make sure that a dock widget was created
assert 'magic (TestP3)' in viewer.window._dock_widgets
dw = viewer.window._dock_widgets['magic (TestP3)']
# make sure that it contains a magicgui widget
magic_widget = dw.widget()._magic_widget
FGui = getattr(magicgui.widgets, 'FunctionGui', None)
if FGui is None:
# pre magicgui 0.2.6
FGui = magicgui.FunctionGui
assert isinstance(magic_widget, FGui)
# This magicgui widget uses the parameter annotation to receive a viewer
assert isinstance(magic_widget.viewer.value, napari.Viewer)
# The function just returns the viewer... make sure we can call it
assert isinstance(magic_widget(), napari.Viewer)
# Add twice is ok, only does a show
tp3.trigger()
def test_inject_viewer_proxy(make_napari_viewer):
"""Test that the injected viewer is a public-only proxy"""
viewer = make_napari_viewer()
wdg = _instantiate_dock_widget(Widg3, viewer)
assert isinstance(wdg.viewer, PublicOnlyProxy)
# simulate access from outside napari
with patch('napari.utils.misc.ROOT_DIR', new='/some/other/package'):
with pytest.warns(FutureWarning):
wdg.fail()
napari-0.5.0a1/napari/_qt/_tests/test_proxy_fixture.py 0000664 0000000 0000000 00000001213 14370413656 0023114 0 ustar 00root root 0000000 0000000 import pytest
from napari.utils import misc
def test_proxy_fixture_warning(make_napari_viewer_proxy, monkeypatch):
viewer = make_napari_viewer_proxy()
monkeypatch.setattr(misc, 'ROOT_DIR', '/some/other/package')
with pytest.warns(FutureWarning, match='Private attribute access'):
viewer.window._qt_window
def test_proxy_fixture_thread_error(
make_napari_viewer_proxy, single_threaded_executor
):
viewer = make_napari_viewer_proxy()
future = single_threaded_executor.submit(
viewer.__setattr__, 'status', 'hi'
)
with pytest.raises(RuntimeError, match='Setting attributes'):
future.result()
napari-0.5.0a1/napari/_qt/_tests/test_prune_qt_connections.py 0000664 0000000 0000000 00000001554 14370413656 0024434 0 ustar 00root root 0000000 0000000 from unittest.mock import Mock
from qtpy.QtWidgets import QSpinBox
from napari.utils.events import EmitterGroup
def test_prune_dead_qt(qtbot):
qtcalls = 0
class W(QSpinBox):
def _set(self, event):
self.setValue(event.value)
nonlocal qtcalls
qtcalls += 1
wdg = W()
mock = Mock()
group = EmitterGroup(None, False, boom=None)
group.boom.connect(mock)
group.boom.connect(wdg._set)
assert len(group.boom.callbacks) == 2
group.boom(value=1)
assert qtcalls == 1
mock.assert_called_once()
mock.reset_mock()
with qtbot.waitSignal(wdg.destroyed):
wdg.close()
wdg.deleteLater()
group.boom(value=1)
mock.assert_called_once()
assert len(group.boom.callbacks) == 1 # we've lost the qt connection
assert qtcalls == 1 # qwidget didn't get called again
napari-0.5.0a1/napari/_qt/_tests/test_qt_notifications.py 0000664 0000000 0000000 00000020554 14370413656 0023553 0 ustar 00root root 0000000 0000000 import threading
import warnings
from concurrent.futures import Future
from dataclasses import dataclass
from unittest.mock import MagicMock
import dask.array as da
import pytest
from qtpy.QtCore import Qt, QThread
from qtpy.QtWidgets import QPushButton, QWidget
from napari._qt.dialogs.qt_notification import (
NapariQtNotification,
TracebackDialog,
)
from napari._tests.utils import DEFAULT_TIMEOUT_SECS, skip_on_win_ci
from napari.utils.notifications import (
ErrorNotification,
Notification,
NotificationSeverity,
notification_manager,
)
def _threading_warn():
thr = threading.Thread(target=_warn)
thr.start()
thr.join(timeout=DEFAULT_TIMEOUT_SECS)
def _warn():
warnings.warn('warning!')
def _threading_raise():
thr = threading.Thread(target=_raise)
thr.start()
thr.join(timeout=DEFAULT_TIMEOUT_SECS)
def _raise():
raise ValueError("error!")
@pytest.fixture
def clean_current(monkeypatch, qtbot):
from napari._qt.qt_main_window import _QtMainWindow
base_show = NapariQtNotification.show
widget = QWidget()
qtbot.addWidget(widget)
mock_window = MagicMock()
widget.resized = MagicMock()
mock_window._qt_viewer._welcome_widget = widget
def mock_current_main_window(*_, **__):
"""
This return mock main window object to ensure that
notification dialog has parent added to qtbot
"""
return mock_window
def store_widget(self, *args, **kwargs):
base_show(self, *args, **kwargs)
monkeypatch.setattr(NapariQtNotification, "show", store_widget)
monkeypatch.setattr(_QtMainWindow, "current", mock_current_main_window)
@dataclass
class ShowStatus:
show_notification_count: int = 0
show_traceback_count: int = 0
@pytest.fixture(autouse=True)
def raise_on_show(monkeypatch, qtbot):
def raise_prepare(text):
def _raise_on_call(self, *args, **kwargs):
raise RuntimeError(text)
return _raise_on_call
monkeypatch.setattr(
NapariQtNotification, 'show', raise_prepare("notification show")
)
monkeypatch.setattr(
TracebackDialog, 'show', raise_prepare("traceback show")
)
monkeypatch.setattr(
NapariQtNotification,
'close_with_fade',
raise_prepare("close_with_fade"),
)
@pytest.fixture
def count_show(monkeypatch, qtbot):
stat = ShowStatus()
def mock_show_notif(_):
stat.show_notification_count += 1
def mock_show_traceback(_):
stat.show_traceback_count += 1
monkeypatch.setattr(NapariQtNotification, "show", mock_show_notif)
monkeypatch.setattr(TracebackDialog, "show", mock_show_traceback)
return stat
@pytest.fixture(autouse=True)
def ensure_qtbot(monkeypatch, qtbot):
old_notif_init = NapariQtNotification.__init__
old_traceback_init = TracebackDialog.__init__
def mock_notif_init(self, *args, **kwargs):
old_notif_init(self, *args, **kwargs)
qtbot.add_widget(self)
def mock_traceback_init(self, *args, **kwargs):
old_traceback_init(self, *args, **kwargs)
qtbot.add_widget(self)
monkeypatch.setattr(NapariQtNotification, "__init__", mock_notif_init)
monkeypatch.setattr(TracebackDialog, "__init__", mock_traceback_init)
def test_clean_current_path_exist(make_napari_viewer):
"""If this test fail then you need to fix also clean_current fixture"""
assert isinstance(
make_napari_viewer().window._qt_viewer._welcome_widget, QWidget
)
@pytest.mark.parametrize(
"raise_func,warn_func",
[(_raise, _warn), (_threading_raise, _threading_warn)],
)
def test_notification_manager_via_gui(
count_show, qtbot, raise_func, warn_func, clean_current, monkeypatch
):
"""
Test that the notification_manager intercepts `sys.excepthook`` and
`threading.excepthook`.
"""
errButton = QPushButton()
warnButton = QPushButton()
errButton.clicked.connect(raise_func)
warnButton.clicked.connect(warn_func)
qtbot.addWidget(errButton)
qtbot.addWidget(warnButton)
monkeypatch.setattr(
NapariQtNotification, "show_notification", lambda x: None
)
with notification_manager:
for btt, expected_message in [
(errButton, 'error!'),
(warnButton, 'warning!'),
]:
notification_manager.records = []
qtbot.mouseClick(btt, Qt.MouseButton.LeftButton)
assert len(notification_manager.records) == 1
assert notification_manager.records[0].message == expected_message
notification_manager.records = []
def test_show_notification_from_thread(
count_show, monkeypatch, qtbot, clean_current
):
from napari.settings import get_settings
settings = get_settings()
monkeypatch.setattr(
settings.application,
'gui_notification_level',
NotificationSeverity.INFO,
)
class CustomThread(QThread):
def run(self):
notif = Notification(
'hi',
NotificationSeverity.INFO,
actions=[('click', lambda x: None)],
)
res = NapariQtNotification.show_notification(notif)
assert isinstance(res, Future)
assert res.result(timeout=DEFAULT_TIMEOUT_SECS) is None
assert count_show.show_notification_count == 1
thread = CustomThread()
with qtbot.waitSignal(thread.finished):
thread.start()
@pytest.mark.parametrize('severity', NotificationSeverity.__members__)
def test_notification_display(
count_show, severity, monkeypatch, clean_current
):
"""Test that NapariQtNotification can present a Notification event.
NOTE: in napari.utils._tests.test_notification_manager, we already test
that the notification manager successfully overrides sys.excepthook,
and warnings.showwarning... and that it emits an event which is an instance
of napari.utils.notifications.Notification.
in `get_app()`, we connect `notification_manager.notification_ready` to
`NapariQtNotification.show_notification`, so all we have to test here is
that show_notification is capable of receiving various event types.
(we don't need to test that )
"""
from napari.settings import get_settings
settings = get_settings()
monkeypatch.delenv('NAPARI_CATCH_ERRORS', raising=False)
monkeypatch.setattr(
settings.application,
'gui_notification_level',
NotificationSeverity.INFO,
)
notif = Notification('hi', severity, actions=[('click', lambda x: None)])
NapariQtNotification.show_notification(notif)
if NotificationSeverity(severity) >= NotificationSeverity.INFO:
assert count_show.show_notification_count == 1
else:
assert count_show.show_notification_count == 0
dialog = NapariQtNotification.from_notification(notif)
assert not dialog.property('expanded')
dialog.toggle_expansion()
assert dialog.property('expanded')
dialog.toggle_expansion()
assert not dialog.property('expanded')
def test_notification_error(count_show, monkeypatch):
from napari.settings import get_settings
settings = get_settings()
monkeypatch.delenv('NAPARI_CATCH_ERRORS', raising=False)
monkeypatch.setattr(
NapariQtNotification, "close_with_fade", lambda x, y: None
)
monkeypatch.setattr(
settings.application,
'gui_notification_level',
NotificationSeverity.INFO,
)
try:
raise ValueError('error!')
except ValueError as e:
notif = ErrorNotification(e)
dialog = NapariQtNotification.from_notification(notif)
bttn = dialog.row2_widget.findChild(QPushButton)
assert bttn.text() == 'View Traceback'
assert count_show.show_traceback_count == 0
bttn.click()
assert count_show.show_traceback_count == 1
@skip_on_win_ci
@pytest.mark.sync_only
def test_notifications_error_with_threading(
make_napari_viewer, clean_current, monkeypatch
):
"""Test notifications of `threading` threads, using a dask example."""
random_image = da.random.random((10, 10))
monkeypatch.setattr(
NapariQtNotification, "show_notification", lambda x: None
)
with notification_manager:
viewer = make_napari_viewer(strict_qt=False)
viewer.add_image(random_image)
result = da.divide(random_image, da.zeros((10, 10)))
viewer.add_image(result)
assert len(notification_manager.records) >= 1
notification_manager.records = []
napari-0.5.0a1/napari/_qt/_tests/test_qt_provide_theme.py 0000664 0000000 0000000 00000005377 14370413656 0023542 0 ustar 00root root 0000000 0000000 import warnings
from unittest.mock import patch
import pytest
from napari_plugin_engine import napari_hook_implementation
from napari import Viewer
from napari._qt import Window
from napari._tests.utils import skip_on_win_ci
from napari.settings import get_settings
from napari.utils.theme import Theme, get_theme
@skip_on_win_ci
@patch.object(Window, "_remove_theme")
@patch.object(Window, "_add_theme")
def test_provide_theme_hook_registered_correctly(
mock_add_theme,
mock_remove_theme,
make_napari_viewer,
napari_plugin_manager,
):
# make a viewer with a plugin & theme registered
viewer = make_napari_viewer_with_plugin_theme(
make_napari_viewer,
napari_plugin_manager,
theme_type='dark',
name='dark-test-2',
)
# set the viewer theme to the plugin theme
viewer.theme = "dark-test-2"
# triggered when theme was added
mock_add_theme.assert_called()
mock_remove_theme.assert_not_called()
# now, lets unregister the theme
# We didn't set the setting, so ensure that no warning
with warnings.catch_warnings():
warnings.simplefilter("error")
napari_plugin_manager.unregister("TestPlugin")
mock_remove_theme.assert_called()
@patch.object(Window, "_remove_theme")
@patch.object(Window, "_add_theme")
def test_plugin_provide_theme_hook_set_settings_correctly(
mock_add_theme,
mock_remove_theme,
make_napari_viewer,
napari_plugin_manager,
):
# make a viewer with a plugin & theme registered
make_napari_viewer_with_plugin_theme(
make_napari_viewer,
napari_plugin_manager,
theme_type='dark',
name='dark-test-2',
)
# set the plugin theme as a setting
get_settings().appearance.theme = "dark-test-2"
# triggered when theme was added
mock_add_theme.assert_called()
mock_remove_theme.assert_not_called()
# now, lets unregister the theme
# We *did* set the setting, so there should be a warning
with pytest.warns(UserWarning, match="The current theme "):
napari_plugin_manager.unregister("TestPlugin")
mock_remove_theme.assert_called()
def make_napari_viewer_with_plugin_theme(
make_napari_viewer, napari_plugin_manager, *, theme_type: str, name: str
) -> Viewer:
theme = get_theme(theme_type, True)
theme["name"] = name
class TestPlugin:
@napari_hook_implementation
def napari_experimental_provide_theme():
return {name: theme}
# create instance of viewer to make sure
# registration and unregistration methods are called
viewer = make_napari_viewer()
# register theme
napari_plugin_manager.register(TestPlugin)
reg = napari_plugin_manager._theme_data["TestPlugin"]
assert isinstance(reg[name], Theme)
return viewer
napari-0.5.0a1/napari/_qt/_tests/test_qt_public_imports.py 0000664 0000000 0000000 00000000112 14370413656 0023721 0 ustar 00root root 0000000 0000000 from napari.qt import * # noqa
from napari.qt.threading import * # noqa
napari-0.5.0a1/napari/_qt/_tests/test_qt_utils.py 0000664 0000000 0000000 00000007172 14370413656 0022043 0 ustar 00root root 0000000 0000000 import pytest
from qtpy.QtCore import QObject, Signal
from qtpy.QtWidgets import QMainWindow
from napari._qt.utils import (
QBYTE_FLAG,
add_flash_animation,
is_qbyte,
qbytearray_to_str,
qt_might_be_rich_text,
qt_signals_blocked,
str_to_qbytearray,
)
from napari.utils._proxies import PublicOnlyProxy
class Emitter(QObject):
test_signal = Signal()
def go(self):
self.test_signal.emit()
def test_signal_blocker(qtbot):
"""make sure context manager signal blocker works"""
import pytestqt.exceptions
obj = Emitter()
# make sure signal works
with qtbot.waitSignal(obj.test_signal):
obj.go()
# make sure blocker works
with qt_signals_blocked(obj):
with pytest.raises(pytestqt.exceptions.TimeoutError):
with qtbot.waitSignal(obj.test_signal, timeout=500):
obj.go()
def test_is_qbyte_valid():
is_qbyte(QBYTE_FLAG)
is_qbyte(
"!QBYTE_AAAA/wAAAAD9AAAAAgAAAAAAAAECAAACePwCAAAAAvsAAAAcAGwAYQB5AGUAcgAgAGMAbwBuAHQAcgBvAGwAcwEAAAAAAAABFwAAARcAAAEX+wAAABQAbABhAHkAZQByACAAbABpAHMAdAEAAAEXAAABYQAAALcA////AAAAAwAAAAAAAAAA/AEAAAAB+wAAAA4AYwBvAG4AcwBvAGwAZQAAAAAA/////wAAADIA////AAADPAAAAngAAAAEAAAABAAAAAgAAAAI/AAAAAA="
)
def test_str_to_qbytearray_valid():
with pytest.raises(ValueError):
str_to_qbytearray("")
with pytest.raises(ValueError):
str_to_qbytearray("FOOBAR")
with pytest.raises(ValueError):
str_to_qbytearray(
"_AAAA/wAAAAD9AAAAAgAAAAAAAAECAAACePwCAAAAAvsAAAAcAGwAYQB5AGUAcgAgAGMAbwBuAHQAcgBvAGwAcwEAAAAAAAABFwAAARcAAAEX+wAAABQAbABhAHkAZQByACAAbABpAHMAdAEAAAEXAAABYQAAALcA////AAAAAwAAAAAAAAAA/AEAAAAB+wAAAA4AYwBvAG4AcwBvAGwAZQAAAAAA/////wAAADIA////AAADPAAAAngAAAAEAAAABAAAAAgAAAAI/AAAAAA="
)
def test_str_to_qbytearray_invalid():
with pytest.raises(ValueError):
str_to_qbytearray("")
with pytest.raises(ValueError):
str_to_qbytearray(
"_AAAA/wAAAAD9AAAAAgAAAAAAAAECAAACePwCAAAAAvsAAAAcAGwAYQB5AGUAcgAgAGMAbwBuAHQAcgBvAGwAcwEAAAAAAAABFwAAARcAAAEX+wAAABQAbABhAHkAZQByACAAbABpAHMAdAEAAAEXAAABYQAAALcA////AAAAAwAAAAAAAAAA/AEAAAAB+wAAAA4AYwBvAG4AcwBvAGwAZQAAAAAA/////wAAADIA////AAADPAAAAngAAAAEAAAABAAAAAgAAAAI/AAAAAA="
)
def test_qbytearray_to_str(qtbot):
widget = QMainWindow()
qtbot.addWidget(widget)
qbyte = widget.saveState()
qbyte_string = qbytearray_to_str(qbyte)
assert is_qbyte(qbyte_string)
def test_qbytearray_to_str_and_back(qtbot):
widget = QMainWindow()
qtbot.addWidget(widget)
qbyte = widget.saveState()
assert str_to_qbytearray(qbytearray_to_str(qbyte)) == qbyte
def test_add_flash_animation(qtbot):
widget = QMainWindow()
qtbot.addWidget(widget)
assert widget.graphicsEffect() is None
add_flash_animation(widget)
assert widget.graphicsEffect() is not None
assert hasattr(widget, "_flash_animation")
qtbot.wait(350)
assert widget.graphicsEffect() is None
assert not hasattr(widget, "_flash_animation")
def test_qt_might_be_rich_text(qtbot):
widget = QMainWindow()
qtbot.addWidget(widget)
assert qt_might_be_rich_text("rich text")
assert not qt_might_be_rich_text("plain text")
def test_thread_proxy_guard(monkeypatch, qapp, single_threaded_executor):
class X:
a = 1
monkeypatch.setenv('NAPARI_ENSURE_PLUGIN_MAIN_THREAD', 'True')
x = X()
x_proxy = PublicOnlyProxy(x)
f = single_threaded_executor.submit(x.__setattr__, 'a', 2)
f.result()
assert x.a == 2
f = single_threaded_executor.submit(x_proxy.__setattr__, 'a', 3)
with pytest.raises(RuntimeError):
f.result()
assert x.a == 2
napari-0.5.0a1/napari/_qt/_tests/test_qt_viewer.py 0000664 0000000 0000000 00000053433 14370413656 0022205 0 ustar 00root root 0000000 0000000 import gc
import os
import weakref
from dataclasses import dataclass
from typing import List
from unittest import mock
import numpy as np
import pytest
from imageio import imread
from qtpy.QtGui import QGuiApplication
from qtpy.QtWidgets import QMessageBox
from napari._qt.qt_viewer import QtViewer
from napari._tests.utils import (
add_layer_by_type,
check_viewer_functioning,
layer_test_data,
skip_local_popups,
skip_on_win_ci,
)
from napari._vispy.utils.gl import fix_data_dtype
from napari.components.viewer_model import ViewerModel
from napari.layers import Points
from napari.settings import get_settings
from napari.utils.interactions import mouse_press_callbacks
from napari.utils.theme import available_themes
BUILTINS_DISP = 'napari'
BUILTINS_NAME = 'builtins'
def test_qt_viewer(make_napari_viewer):
"""Test instantiating viewer."""
viewer = make_napari_viewer()
view = viewer.window._qt_viewer
assert viewer.title == 'napari'
assert view.viewer == viewer
assert len(viewer.layers) == 0
assert view.layers.model().rowCount() == 0
assert viewer.dims.ndim == 2
assert view.dims.nsliders == viewer.dims.ndim
assert np.sum(view.dims._displayed_sliders) == 0
def test_qt_viewer_with_console(make_napari_viewer):
"""Test instantiating console from viewer."""
viewer = make_napari_viewer()
view = viewer.window._qt_viewer
# Check console is created when requested
assert view.console is not None
assert view.dockConsole.widget() is view.console
def test_qt_viewer_toggle_console(make_napari_viewer):
"""Test instantiating console from viewer."""
viewer = make_napari_viewer()
view = viewer.window._qt_viewer
# Check console has been created when it is supposed to be shown
view.toggle_console_visibility(None)
assert view._console is not None
assert view.dockConsole.widget() is view.console
@skip_local_popups
def test_qt_viewer_console_focus(qtbot, make_napari_viewer):
"""Test console has focus when instantiating from viewer."""
viewer = make_napari_viewer(show=True)
view = viewer.window._qt_viewer
assert not view.console.hasFocus(), "console has focus before being shown"
view.toggle_console_visibility(None)
def console_has_focus():
assert (
view.console.hasFocus()
), "console does not have focus when shown"
qtbot.waitUntil(console_has_focus)
@pytest.mark.parametrize('layer_class, data, ndim', layer_test_data)
def test_add_layer(make_napari_viewer, layer_class, data, ndim):
viewer = make_napari_viewer(ndisplay=int(np.clip(ndim, 2, 3)))
view = viewer.window._qt_viewer
add_layer_by_type(viewer, layer_class, data)
check_viewer_functioning(viewer, view, data, ndim)
def test_new_labels(make_napari_viewer):
"""Test adding new labels layer."""
# Add labels to empty viewer
viewer = make_napari_viewer()
view = viewer.window._qt_viewer
viewer._new_labels()
assert np.max(viewer.layers[0].data) == 0
assert len(viewer.layers) == 1
assert view.layers.model().rowCount() == len(viewer.layers)
assert viewer.dims.ndim == 2
assert view.dims.nsliders == viewer.dims.ndim
assert np.sum(view.dims._displayed_sliders) == 0
# Add labels with image already present
viewer = make_napari_viewer()
view = viewer.window._qt_viewer
np.random.seed(0)
data = np.random.random((10, 15))
viewer.add_image(data)
viewer._new_labels()
assert np.max(viewer.layers[1].data) == 0
assert len(viewer.layers) == 2
assert view.layers.model().rowCount() == len(viewer.layers)
assert viewer.dims.ndim == 2
assert view.dims.nsliders == viewer.dims.ndim
assert np.sum(view.dims._displayed_sliders) == 0
def test_new_points(make_napari_viewer):
"""Test adding new points layer."""
# Add labels to empty viewer
viewer = make_napari_viewer()
view = viewer.window._qt_viewer
viewer.add_points()
assert len(viewer.layers[0].data) == 0
assert len(viewer.layers) == 1
assert view.layers.model().rowCount() == len(viewer.layers)
assert viewer.dims.ndim == 2
assert view.dims.nsliders == viewer.dims.ndim
assert np.sum(view.dims._displayed_sliders) == 0
# Add points with image already present
viewer = make_napari_viewer()
view = viewer.window._qt_viewer
np.random.seed(0)
data = np.random.random((10, 15))
viewer.add_image(data)
viewer.add_points()
assert len(viewer.layers[1].data) == 0
assert len(viewer.layers) == 2
assert view.layers.model().rowCount() == len(viewer.layers)
assert viewer.dims.ndim == 2
assert view.dims.nsliders == viewer.dims.ndim
assert np.sum(view.dims._displayed_sliders) == 0
def test_new_shapes_empty_viewer(make_napari_viewer):
"""Test adding new shapes layer."""
# Add labels to empty viewer
viewer = make_napari_viewer()
view = viewer.window._qt_viewer
viewer.add_shapes()
assert len(viewer.layers[0].data) == 0
assert len(viewer.layers) == 1
assert view.layers.model().rowCount() == len(viewer.layers)
assert viewer.dims.ndim == 2
assert view.dims.nsliders == viewer.dims.ndim
assert np.sum(view.dims._displayed_sliders) == 0
# Add points with image already present
viewer = make_napari_viewer()
view = viewer.window._qt_viewer
np.random.seed(0)
data = np.random.random((10, 15))
viewer.add_image(data)
viewer.add_shapes()
assert len(viewer.layers[1].data) == 0
assert len(viewer.layers) == 2
assert view.layers.model().rowCount() == len(viewer.layers)
assert viewer.dims.ndim == 2
assert view.dims.nsliders == viewer.dims.ndim
assert np.sum(view.dims._displayed_sliders) == 0
def test_z_order_adding_removing_images(make_napari_viewer):
"""Test z order is correct after adding/ removing images."""
data = np.ones((10, 10))
viewer = make_napari_viewer()
vis = viewer.window._qt_viewer.layer_to_visual
viewer.add_image(data, colormap='red', name='red')
viewer.add_image(data, colormap='green', name='green')
viewer.add_image(data, colormap='blue', name='blue')
order = [vis[x].order for x in viewer.layers]
np.testing.assert_almost_equal(order, list(range(len(viewer.layers))))
# Remove and re-add image
viewer.layers.remove('red')
order = [vis[x].order for x in viewer.layers]
np.testing.assert_almost_equal(order, list(range(len(viewer.layers))))
viewer.add_image(data, colormap='red', name='red')
order = [vis[x].order for x in viewer.layers]
np.testing.assert_almost_equal(order, list(range(len(viewer.layers))))
# Remove two other images
viewer.layers.remove('green')
viewer.layers.remove('blue')
order = [vis[x].order for x in viewer.layers]
np.testing.assert_almost_equal(order, list(range(len(viewer.layers))))
# Add two other layers back
viewer.add_image(data, colormap='green', name='green')
viewer.add_image(data, colormap='blue', name='blue')
order = [vis[x].order for x in viewer.layers]
np.testing.assert_almost_equal(order, list(range(len(viewer.layers))))
@skip_on_win_ci
def test_screenshot(make_napari_viewer):
"Test taking a screenshot"
viewer = make_napari_viewer()
np.random.seed(0)
# Add image
data = np.random.random((10, 15))
viewer.add_image(data)
# Add labels
data = np.random.randint(20, size=(10, 15))
viewer.add_labels(data)
# Add points
data = 20 * np.random.random((10, 2))
viewer.add_points(data)
# Add vectors
data = 20 * np.random.random((10, 2, 2))
viewer.add_vectors(data)
# Add shapes
data = 20 * np.random.random((10, 4, 2))
viewer.add_shapes(data)
# Take screenshot
with pytest.warns(FutureWarning):
screenshot = viewer.window.qt_viewer.screenshot(flash=False)
screenshot = viewer.window.screenshot(flash=False, canvas_only=True)
assert screenshot.ndim == 3
@pytest.mark.skip("new approach")
def test_screenshot_dialog(make_napari_viewer, tmpdir):
"""Test save screenshot functionality."""
viewer = make_napari_viewer()
np.random.seed(0)
# Add image
data = np.random.random((10, 15))
viewer.add_image(data)
# Add labels
data = np.random.randint(20, size=(10, 15))
viewer.add_labels(data)
# Add points
data = 20 * np.random.random((10, 2))
viewer.add_points(data)
# Add vectors
data = 20 * np.random.random((10, 2, 2))
viewer.add_vectors(data)
# Add shapes
data = 20 * np.random.random((10, 4, 2))
viewer.add_shapes(data)
# Save screenshot
input_filepath = os.path.join(tmpdir, 'test-save-screenshot')
mock_return = (input_filepath, '')
with mock.patch('napari._qt._qt_viewer.QFileDialog') as mocker, mock.patch(
'napari._qt._qt_viewer.QMessageBox'
) as mocker2:
mocker.getSaveFileName.return_value = mock_return
mocker2.warning.return_value = QMessageBox.Yes
viewer.window._qt_viewer._screenshot_dialog()
# Assert behaviour is correct
expected_filepath = input_filepath + '.png' # add default file extension
assert os.path.exists(expected_filepath)
output_data = imread(expected_filepath)
expected_data = viewer.window._qt_viewer.screenshot(flash=False)
assert np.allclose(output_data, expected_data)
@pytest.mark.parametrize(
"dtype",
[
'int8',
'uint8',
'int16',
'uint16',
'int32',
'float16',
'float32',
'float64',
],
)
def test_qt_viewer_data_integrity(make_napari_viewer, dtype):
"""Test that the viewer doesn't change the underlying array."""
image = np.random.rand(10, 32, 32)
image *= 200 if dtype.endswith('8') else 2**14
image = image.astype(dtype)
imean = image.mean()
viewer = make_napari_viewer()
layer = viewer.add_image(image.copy())
data = layer.data
datamean = np.mean(data)
assert datamean == imean
# toggle dimensions
viewer.dims.ndisplay = 3
datamean = np.mean(data)
assert datamean == imean
# back to 2D
viewer.dims.ndisplay = 2
datamean = np.mean(data)
assert datamean == imean
# also check that vispy gets (almost) the same data
datamean = np.mean(fix_data_dtype(data))
assert np.allclose(datamean, imean, rtol=5e-04)
def test_points_layer_display_correct_slice_on_scale(make_napari_viewer):
viewer = make_napari_viewer()
data = np.zeros((60, 60, 60))
viewer.add_image(data, scale=[0.29, 0.26, 0.26])
pts = viewer.add_points(name='test', size=1, ndim=3)
pts.add((8.7, 0, 0))
viewer.dims.set_point(0, 30 * 0.29) # middle plane
request = pts._make_slice_request(viewer.dims)
response = request()
np.testing.assert_equal(response.indices, [0])
@skip_on_win_ci
def test_qt_viewer_clipboard_with_flash(make_napari_viewer, qtbot):
viewer = make_napari_viewer()
# make sure clipboard is empty
QGuiApplication.clipboard().clear()
clipboard_image = QGuiApplication.clipboard().image()
assert clipboard_image.isNull()
# capture screenshot
with pytest.warns(FutureWarning):
viewer.window.qt_viewer.clipboard(flash=True)
viewer.window.clipboard(flash=False, canvas_only=True)
clipboard_image = QGuiApplication.clipboard().image()
assert not clipboard_image.isNull()
# ensure the flash effect is applied
assert (
viewer.window._qt_viewer._welcome_widget.graphicsEffect() is not None
)
assert hasattr(
viewer.window._qt_viewer._welcome_widget, "_flash_animation"
)
qtbot.wait(500) # wait for the animation to finish
assert viewer.window._qt_viewer._welcome_widget.graphicsEffect() is None
assert not hasattr(
viewer.window._qt_viewer._welcome_widget, "_flash_animation"
)
# clear clipboard and grab image from application view
QGuiApplication.clipboard().clear()
clipboard_image = QGuiApplication.clipboard().image()
assert clipboard_image.isNull()
# capture screenshot of the entire window
viewer.window.clipboard(flash=True)
clipboard_image = QGuiApplication.clipboard().image()
assert not clipboard_image.isNull()
# ensure the flash effect is applied
assert viewer.window._qt_window.graphicsEffect() is not None
assert hasattr(viewer.window._qt_window, "_flash_animation")
qtbot.wait(500) # wait for the animation to finish
assert viewer.window._qt_window.graphicsEffect() is None
assert not hasattr(viewer.window._qt_window, "_flash_animation")
@skip_on_win_ci
def test_qt_viewer_clipboard_without_flash(make_napari_viewer):
viewer = make_napari_viewer()
# make sure clipboard is empty
QGuiApplication.clipboard().clear()
clipboard_image = QGuiApplication.clipboard().image()
assert clipboard_image.isNull()
# capture screenshot
with pytest.warns(FutureWarning):
viewer.window.qt_viewer.clipboard(flash=False)
viewer.window.clipboard(flash=False, canvas_only=True)
clipboard_image = QGuiApplication.clipboard().image()
assert not clipboard_image.isNull()
# ensure the flash effect is not applied
assert viewer.window._qt_viewer._welcome_widget.graphicsEffect() is None
assert not hasattr(
viewer.window._qt_viewer._welcome_widget, "_flash_animation"
)
# clear clipboard and grab image from application view
QGuiApplication.clipboard().clear()
clipboard_image = QGuiApplication.clipboard().image()
assert clipboard_image.isNull()
# capture screenshot of the entire window
viewer.window.clipboard(flash=False)
clipboard_image = QGuiApplication.clipboard().image()
assert not clipboard_image.isNull()
# ensure the flash effect is not applied
assert viewer.window._qt_window.graphicsEffect() is None
assert not hasattr(viewer.window._qt_window, "_flash_animation")
def test_active_keybindings(make_napari_viewer):
"""Test instantiating viewer."""
viewer = make_napari_viewer()
view = viewer.window._qt_viewer
# Check only keybinding is Viewer
assert len(view._key_map_handler.keymap_providers) == 1
assert view._key_map_handler.keymap_providers[0] == viewer
# Add a layer and check it is keybindings are active
data = np.random.random((10, 15))
layer_image = viewer.add_image(data)
assert viewer.layers.selection.active == layer_image
assert len(view._key_map_handler.keymap_providers) == 2
assert view._key_map_handler.keymap_providers[0] == layer_image
# Add a layer and check it is keybindings become active
layer_image_2 = viewer.add_image(data)
assert viewer.layers.selection.active == layer_image_2
assert len(view._key_map_handler.keymap_providers) == 2
assert view._key_map_handler.keymap_providers[0] == layer_image_2
# Change active layer and check it is keybindings become active
viewer.layers.selection.active = layer_image
assert viewer.layers.selection.active == layer_image
assert len(view._key_map_handler.keymap_providers) == 2
assert view._key_map_handler.keymap_providers[0] == layer_image
@dataclass
class MouseEvent:
# mock mouse event class
pos: List[int]
def test_process_mouse_event(make_napari_viewer):
"""Test that the correct properties are added to the
MouseEvent by _process_mouse_events.
"""
# make a mock mouse event
new_pos = [25, 25]
mouse_event = MouseEvent(
pos=new_pos,
)
data = np.zeros((5, 20, 20, 20), dtype=int)
data[1, 0:10, 0:10, 0:10] = 1
viewer = make_napari_viewer()
view = viewer.window._qt_viewer
labels = viewer.add_labels(data, scale=(1, 2, 1, 1), translate=(5, 5, 5))
@labels.mouse_drag_callbacks.append
def on_click(layer, event):
np.testing.assert_almost_equal(event.view_direction, [0, 1, 0, 0])
np.testing.assert_array_equal(event.dims_displayed, [1, 2, 3])
assert event.dims_point[0] == data.shape[0] // 2
expected_position = view._map_canvas2world(new_pos)
np.testing.assert_almost_equal(expected_position, list(event.position))
viewer.dims.ndisplay = 3
view._process_mouse_event(mouse_press_callbacks, mouse_event)
@skip_local_popups
def test_memory_leaking(qtbot, make_napari_viewer):
data = np.zeros((5, 20, 20, 20), dtype=int)
data[1, 0:10, 0:10, 0:10] = 1
viewer = make_napari_viewer()
image = weakref.ref(viewer.add_image(data))
labels = weakref.ref(viewer.add_labels(data))
del viewer.layers[0]
del viewer.layers[0]
qtbot.wait(100)
gc.collect()
gc.collect()
assert image() is None
assert labels() is None
@skip_on_win_ci
@skip_local_popups
def test_leaks_image(qtbot, make_napari_viewer):
viewer = make_napari_viewer(show=True)
lr = weakref.ref(viewer.add_image(np.random.rand(10, 10)))
dr = weakref.ref(lr().data)
viewer.layers.clear()
qtbot.wait(100)
gc.collect()
gc.collect()
assert not lr()
assert not dr()
@skip_on_win_ci
@skip_local_popups
def test_leaks_labels(qtbot, make_napari_viewer):
viewer = make_napari_viewer(show=True)
lr = weakref.ref(
viewer.add_labels((np.random.rand(10, 10) * 10).astype(np.uint8))
)
dr = weakref.ref(lr().data)
viewer.layers.clear()
qtbot.wait(100)
gc.collect()
gc.collect()
assert not lr()
assert not dr()
@pytest.mark.parametrize("theme", available_themes())
def test_canvas_color(make_napari_viewer, theme):
"""Test instantiating viewer with different themes.
See: https://github.com/napari/napari/issues/3278
"""
# This test is to make sure the application starts with
# with different themes
get_settings().appearance.theme = theme
viewer = make_napari_viewer()
assert viewer.theme == theme
def test_remove_points(make_napari_viewer):
viewer = make_napari_viewer()
viewer.add_points([(1, 2), (2, 3)])
del viewer.layers[0]
viewer.add_points([(1, 2), (2, 3)])
def test_remove_image(make_napari_viewer):
viewer = make_napari_viewer()
viewer.add_image(np.random.rand(10, 10))
del viewer.layers[0]
viewer.add_image(np.random.rand(10, 10))
def test_remove_labels(make_napari_viewer):
viewer = make_napari_viewer()
viewer.add_labels((np.random.rand(10, 10) * 10).astype(np.uint8))
del viewer.layers[0]
viewer.add_labels((np.random.rand(10, 10) * 10).astype(np.uint8))
@pytest.mark.parametrize('multiscale', [False, True])
def test_mixed_2d_and_3d_layers(make_napari_viewer, multiscale):
"""Test bug in setting corner_pixels from qt_viewer.on_draw"""
viewer = make_napari_viewer()
img = np.ones((512, 256))
# canvas size must be large enough that img fits in the canvas
canvas_size = tuple(3 * s for s in img.shape)
expected_corner_pixels = np.asarray([[0, 0], [img.shape[0], img.shape[1]]])
vol = np.stack([img] * 8, axis=0)
if multiscale:
img = [img[::s, ::s] for s in (1, 2, 4)]
viewer.add_image(img)
img_multi_layer = viewer.layers[0]
viewer.add_image(vol)
viewer.dims.order = (0, 1, 2)
viewer.window._qt_viewer.canvas.size = canvas_size
viewer.window._qt_viewer.on_draw(None)
assert np.all(img_multi_layer.corner_pixels == expected_corner_pixels)
viewer.dims.order = (2, 0, 1)
viewer.window._qt_viewer.on_draw(None)
assert np.all(img_multi_layer.corner_pixels == expected_corner_pixels)
viewer.dims.order = (1, 2, 0)
viewer.window._qt_viewer.on_draw(None)
assert np.all(img_multi_layer.corner_pixels == expected_corner_pixels)
def test_remove_add_image_3D(make_napari_viewer):
"""
Test that adding, removing and readding an image layer in 3D does not cause issues
due to the vispy node change. See https://github.com/napari/napari/pull/3670
"""
viewer = make_napari_viewer(ndisplay=3)
img = np.ones((10, 10, 10))
layer = viewer.add_image(img)
viewer.layers.remove(layer)
viewer.layers.append(layer)
@skip_on_win_ci
@skip_local_popups
def test_qt_viewer_multscale_image_out_of_view(make_napari_viewer):
"""Test out-of-view multiscale image viewing fix.
Just verifies that no RuntimeError is raised in this scenario.
see: https://github.com/napari/napari/issues/3863.
"""
# show=True required to test fix for OpenGL error
viewer = make_napari_viewer(ndisplay=2, show=True)
viewer.add_shapes(
data=[
np.array(
[[1500, 4500], [4500, 4500], [4500, 1500], [1500, 1500]],
dtype=float,
)
],
shape_type=['polygon'],
)
viewer.add_image([np.eye(1024), np.eye(512), np.eye(256)])
def test_surface_mixed_dim(make_napari_viewer):
"""Test that adding a layer that changes the world ndim
when ndisplay=3 before the mouse cursor has been updated
doesn't raise an error.
See PR: https://github.com/napari/napari/pull/3881
"""
viewer = make_napari_viewer(ndisplay=3)
verts = np.array([[0, 0, 0], [0, 20, 10], [10, 0, -10], [10, 10, -10]])
faces = np.array([[0, 1, 2], [1, 2, 3]])
values = np.linspace(0, 1, len(verts))
data = (verts, faces, values)
viewer.add_surface(data)
timeseries_values = np.vstack([values, values])
timeseries_data = (verts, faces, timeseries_values)
viewer.add_surface(timeseries_data)
def test_insert_layer_ordering(make_napari_viewer):
"""make sure layer ordering is correct in vispy when inserting layers"""
viewer = make_napari_viewer()
pl1 = Points()
pl2 = Points()
viewer.layers.append(pl1)
viewer.layers.insert(0, pl2)
pl1_vispy = viewer.window._qt_viewer.layer_to_visual[pl1].node
pl2_vispy = viewer.window._qt_viewer.layer_to_visual[pl2].node
assert pl1_vispy.order == 1
assert pl2_vispy.order == 0
def test_create_non_empty_viewer_model(qtbot):
viewer_model = ViewerModel()
viewer_model.add_points([(1, 2), (2, 3)])
viewer = QtViewer(viewer=viewer_model)
viewer.close()
viewer.deleteLater()
# try to del local reference for gc.
del viewer_model
del viewer
qtbot.wait(50)
gc.collect()
napari-0.5.0a1/napari/_qt/_tests/test_qt_window.py 0000664 0000000 0000000 00000006117 14370413656 0022210 0 ustar 00root root 0000000 0000000 import platform
from unittest.mock import patch
import pytest
from napari._qt.qt_main_window import Window, _QtMainWindow
from napari.utils.theme import (
_themes,
get_theme,
register_theme,
unregister_theme,
)
def test_current_viewer(make_napari_viewer):
"""Test that we can retrieve the "current" viewer window easily.
... where "current" means it was the last viewer the user interacted with.
"""
assert _QtMainWindow.current() is None
# when we create a new viewer it becomes accessible at Viewer.current()
v1 = make_napari_viewer(title='v1')
assert _QtMainWindow._instances == [v1.window._qt_window]
assert _QtMainWindow.current() == v1.window._qt_window
v2 = make_napari_viewer(title='v2')
assert _QtMainWindow._instances == [
v1.window._qt_window,
v2.window._qt_window,
]
assert _QtMainWindow.current() == v2.window._qt_window
# Viewer.current() will always give the most recently activated viewer.
v1.window.activate()
assert _QtMainWindow.current() == v1.window._qt_window
v2.window.activate()
assert _QtMainWindow.current() == v2.window._qt_window
# The list remembers the z-order of previous viewers ...
v2.close()
assert _QtMainWindow.current() == v1.window._qt_window
assert _QtMainWindow._instances == [v1.window._qt_window]
# and when none are left, Viewer.current() becomes None again
v1.close()
assert _QtMainWindow._instances == []
assert _QtMainWindow.current() is None
def test_set_geometry(make_napari_viewer):
viewer = make_napari_viewer()
values = (70, 70, 1000, 700)
viewer.window.set_geometry(*values)
assert viewer.window.geometry() == values
@patch.object(Window, "_update_theme_no_event")
@patch.object(Window, "_remove_theme")
@patch.object(Window, "_add_theme")
def test_update_theme(
mock_add_theme,
mock_remove_theme,
mock_update_theme_no_event,
make_napari_viewer,
):
viewer = make_napari_viewer()
blue = get_theme("dark", False)
blue.id = "blue"
register_theme("blue", blue, "test")
# triggered when theme was added
mock_add_theme.assert_called()
mock_remove_theme.assert_not_called()
unregister_theme("blue")
# triggered when theme was removed
mock_remove_theme.assert_called()
mock_update_theme_no_event.assert_not_called()
viewer.theme = "light"
theme = _themes["light"]
theme.icon = "#FF0000"
mock_update_theme_no_event.assert_called()
def test_lazy_console(make_napari_viewer):
v = make_napari_viewer()
assert v.window._qt_viewer._console is None
v.update_console({"test": "test"})
assert v.window._qt_viewer._console is None
@pytest.mark.skipif(
platform.system() == "Darwin", reason="Cannot control menu bar on MacOS"
)
def test_menubar_shortcut(make_napari_viewer):
v = make_napari_viewer()
v.show()
assert v.window.main_menu.isVisible()
assert not v.window._main_menu_shortcut.isEnabled()
v.window._toggle_menubar_visible()
assert not v.window.main_menu.isVisible()
assert v.window._main_menu_shortcut.isEnabled()
napari-0.5.0a1/napari/_qt/_tests/test_sigint_interupt.py 0000664 0000000 0000000 00000001513 14370413656 0023417 0 ustar 00root root 0000000 0000000 import os
import pytest
from qtpy.QtCore import QTimer
from napari._qt.utils import _maybe_allow_interrupt
@pytest.fixture
def platform_simulate_ctrl_c():
import signal
from functools import partial
if hasattr(signal, "CTRL_C_EVENT"):
win32api = pytest.importorskip('win32api')
return partial(win32api.GenerateConsoleCtrlEvent, 0, 0)
else:
# we're not on windows
return partial(os.kill, os.getpid(), signal.SIGINT)
@pytest.mark.skipif(os.name != "Windows", reason="Windows specific")
def test_sigint(qapp, platform_simulate_ctrl_c, make_napari_viewer):
def fire_signal():
platform_simulate_ctrl_c()
make_napari_viewer()
QTimer.singleShot(100, fire_signal)
with pytest.raises(KeyboardInterrupt):
with _maybe_allow_interrupt(qapp):
qapp.exec_()
napari-0.5.0a1/napari/_qt/_tests/test_threading_progress.py 0000664 0000000 0000000 00000006615 14370413656 0024071 0 ustar 00root root 0000000 0000000 import pytest
from napari._qt import qthreading
from napari._qt.widgets.qt_progress_bar import QtLabeledProgressBar
pytest.importorskip(
'qtpy', reason='Cannot test threading progress without qtpy.'
)
def test_worker_with_progress(qtbot):
test_val = [0]
def func():
yield 1
yield 1
def test_yield(v):
test_val[0] += 1
thread_func = qthreading.thread_worker(
func,
connect={'yielded': test_yield},
progress={'total': 2},
start_thread=False,
)
worker = thread_func()
with qtbot.waitSignal(worker.yielded):
worker.start()
assert worker.pbar.n == test_val[0]
def test_function_worker_nonzero_total_warns():
def not_a_generator():
return
with pytest.warns(RuntimeWarning):
thread_func = qthreading.thread_worker(
not_a_generator,
progress={'total': 2},
start_thread=False,
)
thread_func()
def test_worker_may_exceed_total(qtbot):
test_val = [0]
def func():
yield 1
yield 1
def test_yield(v):
test_val[0] += 1
if test_val[0] < 2:
assert worker.pbar.n == test_val[0]
else:
assert worker.pbar.total == 0
thread_func = qthreading.thread_worker(
func,
progress={'total': 1},
start_thread=False,
)
worker = thread_func()
worker.yielded.connect(test_yield)
with qtbot.waitSignal(worker.yielded) and qtbot.waitSignal(
worker.finished
):
worker.start()
assert test_val[0] == 2
def test_generator_worker_with_description():
def func():
yield 1
thread_func = qthreading.thread_worker(
func,
progress={'total': 1, 'desc': 'custom'},
start_thread=False,
)
worker = thread_func()
assert worker.pbar.desc == 'custom'
def test_function_worker_with_description():
def func():
for _ in range(10):
pass
thread_func = qthreading.thread_worker(
func,
progress={'total': 0, 'desc': 'custom'},
start_thread=False,
)
worker = thread_func()
assert worker.pbar.desc == 'custom'
def test_generator_worker_with_no_total():
def func():
yield 1
thread_func = qthreading.thread_worker(
func,
progress=True,
start_thread=False,
)
worker = thread_func()
assert worker.pbar.total == 0
def test_function_worker_with_no_total():
def func():
for _ in range(10):
pass
thread_func = qthreading.thread_worker(
func,
progress=True,
start_thread=False,
)
worker = thread_func()
assert worker.pbar.total == 0
def test_function_worker_0_total():
def func():
for _ in range(10):
pass
thread_func = qthreading.thread_worker(
func,
progress={'total': 0},
start_thread=False,
)
worker = thread_func()
assert worker.pbar.total == 0
def test_unstarted_worker_no_widget(make_napari_viewer):
viewer = make_napari_viewer()
def func():
for _ in range(5):
yield
thread_func = qthreading.thread_worker(
func,
progress={'total': 5},
start_thread=False,
)
thread_func()
assert not bool(
viewer.window._qt_viewer.window()._activity_dialog.findChildren(
QtLabeledProgressBar
)
)
napari-0.5.0a1/napari/_qt/code_syntax_highlight.py 0000664 0000000 0000000 00000005323 14370413656 0022202 0 ustar 00root root 0000000 0000000 from pygments import highlight
from pygments.formatter import Formatter
from pygments.lexers import get_lexer_by_name
from qtpy import QtGui
# inspired by https://github.com/Vector35/snippets/blob/master/QCodeEditor.py (MIT license) and
# https://pygments.org/docs/formatterdevelopment/#html-3-2-formatter
def get_text_char_format(style):
"""
Return a QTextCharFormat with the given attributes.
https://pygments.org/docs/formatterdevelopment/#html-3-2-formatter
"""
text_char_format = QtGui.QTextCharFormat()
try:
text_char_format.setFontFamilies(["monospace"])
except AttributeError:
text_char_format.setFontFamily(
"monospace"
) # backward compatibility for pyqt5 5.12.3
if style.get('color'):
text_char_format.setForeground(QtGui.QColor(f"#{style['color']}"))
if style.get('bgcolor'):
text_char_format.setBackground(QtGui.QColor(style['bgcolor']))
if style.get('bold'):
text_char_format.setFontWeight(QtGui.QFont.Bold)
if style.get('italic'):
text_char_format.setFontItalic(True)
if style.get("underline"):
text_char_format.setFontUnderline(True)
# TODO find if it is possible to support border style.
return text_char_format
class QFormatter(Formatter):
def __init__(self, **kwargs) -> None:
super().__init__(**kwargs)
self.data = []
self._style = {
name: get_text_char_format(style) for name, style in self.style
}
def format(self, tokensource, outfile):
"""
`outfile` is argument from parent class, but
in Qt we do not produce string output, but QTextCharFormat, so it needs to be
collected using `self.data`.
"""
self.data = []
for token, value in tokensource:
self.data.extend(
[
self._style[token],
]
* len(value)
)
class Pylighter(QtGui.QSyntaxHighlighter):
def __init__(self, parent, lang, theme) -> None:
super().__init__(parent)
self.formatter = QFormatter(style=theme)
self.lexer = get_lexer_by_name(lang)
def highlightBlock(self, text):
cb = self.currentBlock()
p = cb.position()
text = self.document().toPlainText() + '\n'
highlight(text, self.lexer, self.formatter)
# dirty, dirty hack
# The core problem is that pygemnts by default use string streams,
# that will not handle QTextCharFormat, so wee need use `data` property to work around this.
for i in range(len(text)):
try:
self.setFormat(i, 1, self.formatter.data[p + i])
except IndexError:
pass
napari-0.5.0a1/napari/_qt/containers/ 0000775 0000000 0000000 00000000000 14370413656 0017423 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/containers/__init__.py 0000664 0000000 0000000 00000001152 14370413656 0021533 0 ustar 00root root 0000000 0000000 from napari._qt.containers._factory import create_model, create_view
from napari._qt.containers.qt_layer_list import QtLayerList
from napari._qt.containers.qt_layer_model import QtLayerListModel
from napari._qt.containers.qt_list_model import QtListModel
from napari._qt.containers.qt_list_view import QtListView
from napari._qt.containers.qt_tree_model import QtNodeTreeModel
from napari._qt.containers.qt_tree_view import QtNodeTreeView
__all__ = [
'create_model',
'create_view',
'QtLayerList',
'QtLayerListModel',
'QtListModel',
'QtListView',
'QtNodeTreeModel',
'QtNodeTreeView',
]
napari-0.5.0a1/napari/_qt/containers/_base_item_model.py 0000664 0000000 0000000 00000025726 14370413656 0023260 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from collections.abc import MutableSequence
from typing import TYPE_CHECKING, Any, Generic, Tuple, TypeVar, Union
from qtpy.QtCore import QAbstractItemModel, QModelIndex, Qt
from napari.utils.events import disconnect_events
from napari.utils.events.containers import SelectableEventedList
from napari.utils.translations import trans
if TYPE_CHECKING:
from qtpy.QtWidgets import QWidget
ItemType = TypeVar("ItemType")
ItemRole = Qt.UserRole
SortRole = Qt.UserRole + 1
_BASE_FLAGS = (
Qt.ItemFlag.ItemIsSelectable
| Qt.ItemFlag.ItemIsEditable
| Qt.ItemFlag.ItemIsUserCheckable
| Qt.ItemFlag.ItemIsDragEnabled
| Qt.ItemFlag.ItemIsEnabled
)
class _BaseEventedItemModel(QAbstractItemModel, Generic[ItemType]):
"""A QAbstractItemModel desigend to work with `SelectableEventedList`.
:class:`~napari.utils.events.SelectableEventedList` is our pure python
model of a mutable sequence that supports the concept of "currently
selected/active items". It emits events when the list is altered (e.g.,
by appending, inserting, removing items), or when the selection model is
altered.
This class is an adapter between that interface and Qt's
`QAbstractItemModel` interface. It allows python users to interact with
the list in the "usual" python ways, updating any Qt Views that may
be connected, and also updates the python list object if any GUI events
occur in the view.
For a "plain" (flat) list, use the
:class:`napari._qt.containers.QtListModel` subclass.
For a nested list-of-lists using the Group/Node classes, use the
:class:`napari._qt.containers.QtNodeTreeModel` subclass.
For convenience, the :func:`napari._qt.containers.create_model` factory
function will return the appropriate `_BaseEventedItemModel` instance given
a python `EventedList` object.
.. note::
In most cases, if you want a "GUI widget" to go along with an
``EventedList`` object, it will not be necessary to instantiate the
``EventedItemModel`` directly. Instead, use one of the
:class:`napari._qt.containers.QtListView` or
:class:`napari._qt.containers.QtNodeTreeView` views, or the
:func:`napari._qt.containers.create_view` factory function.
Key concepts and references:
- Qt `Model/View Programming
`_
- Qt `Model Subclassing Reference
`_
- `Model Index `_
- `Simple Tree Model Example
`_
"""
_root: SelectableEventedList[ItemType]
# ########## Reimplemented Public Qt Functions ##################
def __init__(
self, root: SelectableEventedList[ItemType], parent: QWidget = None
) -> None:
super().__init__(parent=parent)
self.setRoot(root)
def parent(self, index):
"""Return the parent of the model item with the given ``index``.
(The parent in a basic list is always the root, Tree models will need
to reimplement)
"""
return QModelIndex()
def data(self, index: QModelIndex, role: Qt.ItemDataRole) -> Any:
"""Returns data stored under `role` for the item at `index`.
A given `QModelIndex` can store multiple types of data, each
with its own "ItemDataRole". ItemType-specific subclasses will likely
want to customize this method (and likely `setData` as well) for
different data roles.
see: https://doc.qt.io/qt-5/qt.html#ItemDataRole-enum
"""
if role == Qt.DisplayRole:
return str(self.getItem(index))
if role == ItemRole:
return self.getItem(index)
if role == SortRole:
return index.row()
return None
def flags(self, index: QModelIndex) -> Qt.ItemFlags:
"""Returns the item flags for the given `index`.
This describes the properties of a given item in the model. We set
them to be editable, checkable, dragable, droppable, etc...
If index is not a list, we additionally set `Qt.ItemNeverHasChildren`
(for optimization). Editable models must return a value containing
`Qt.ItemIsEditable`.
See Qt.ItemFlags https://doc.qt.io/qt-5/qt.html#ItemFlag-enum
"""
if not index.isValid() or index.model() is not self:
# we allow drops outside the items
return Qt.ItemFlag.ItemIsDropEnabled
if isinstance(self.getItem(index), MutableSequence):
return _BASE_FLAGS | Qt.ItemFlag.ItemIsDropEnabled
return _BASE_FLAGS | Qt.ItemFlag.ItemNeverHasChildren
def columnCount(self, parent: QModelIndex) -> int:
"""Return the number of columns for the children of the given `parent`.
In a list view, and most tree views, the number of columns is always 1.
"""
return 1
def rowCount(self, parent: QModelIndex = None) -> int:
"""Returns the number of rows under the given parent.
When the parent is valid it means that rowCount is returning the number
of children of parent.
"""
if parent is None:
parent = QModelIndex()
try:
return len(self.getItem(parent))
except TypeError:
return 0
def index(
self, row: int, column: int = 0, parent: QModelIndex = None
) -> QModelIndex:
"""Return a QModelIndex for item at `row`, `column` and `parent`."""
# NOTE: the use of `self.createIndex(row, col, object)`` will create a
# model index that stores a pointer to the object, which can be
# retrieved later with index.internalPointer(). That's convenient and
# performant, and very important tree structures, but it causes a bug
# if integers (or perhaps values that get garbage collected?) are in
# the list, because `createIndex` is an overloaded function and
# `self.createIndex(row, col, )` will assume that the third
# argument *is* the id of the object (not the object itself). This
# will then cause a segfault if `index.internalPointer()` is used
# later.
# so we need to either:
# 1. refuse store integers in this model
# 2. never store the object (and incur the penalty of
# self.getItem(idx) each time you want to get the value of an idx)
# 3. Have special treatment when we encounter integers in the model
# 4. Wrap every object in *another* object (which is basically what
# Qt does with QAbstractItem)... ugh.
#
# Unfortunately, all of those come at a cost... as this is a very
# frequently called function :/
if parent is None:
parent = QModelIndex()
return (
self.createIndex(row, column, self.getItem(parent)[row])
if self.hasIndex(row, column, parent)
else QModelIndex() # instead of index error, Qt wants null index
)
def supportedDropActions(self) -> Qt.DropActions:
"""Returns the drop actions supported by this model.
The default implementation returns `Qt.CopyAction`. We re-implement to
support only `Qt.MoveAction`. See also dropMimeData(), which must
handle each supported drop action type.
"""
return Qt.MoveAction
# ###### Non-Qt methods added for SelectableEventedList Model ############
def setRoot(self, root: SelectableEventedList[ItemType]):
"""Call during __init__, to set the python model and connections"""
if not isinstance(root, SelectableEventedList):
raise TypeError(
trans._(
"root must be an instance of {class_name}",
deferred=True,
class_name=SelectableEventedList,
)
)
current_root = getattr(self, "_root", None)
if root is current_root:
return
if current_root is not None:
# we're changing roots... disconnect previous root
disconnect_events(self._root.events, self)
self._root = root
self._root.events.removing.connect(self._on_begin_removing)
self._root.events.removed.connect(self._on_end_remove)
self._root.events.inserting.connect(self._on_begin_inserting)
self._root.events.inserted.connect(self._on_end_insert)
self._root.events.moving.connect(self._on_begin_moving)
self._root.events.moved.connect(self._on_end_move)
self._root.events.connect(self._process_event)
def _split_nested_index(
self, nested_index: Union[int, Tuple[int, ...]]
) -> Tuple[QModelIndex, int]:
"""Return (parent_index, row) for a given index."""
if isinstance(nested_index, int):
return QModelIndex(), nested_index
# Tuple indexes are used in NestableEventedList, so we support them
# here so that subclasses needn't reimplmenet our _on_begin_* methods
par = QModelIndex()
*_p, idx = nested_index
for i in _p:
par = self.index(i, 0, par)
return par, idx
def _on_begin_inserting(self, event):
"""Begins a row insertion operation.
See Qt documentation:
https://doc.qt.io/qt-5/qabstractitemmodel.html#beginInsertRows
"""
par, idx = self._split_nested_index(event.index)
self.beginInsertRows(par, idx, idx)
def _on_end_insert(self):
"""Must be called after insert operation to update model."""
self.endInsertRows()
def _on_begin_removing(self, event):
"""Begins a row removal operation.
See Qt documentation:
https://doc.qt.io/qt-5/qabstractitemmodel.html#beginRemoveRows
"""
par, idx = self._split_nested_index(event.index)
self.beginRemoveRows(par, idx, idx)
def _on_end_remove(self):
"""Must be called after remove operation to update model."""
self.endRemoveRows()
def _on_begin_moving(self, event):
"""Begins a row move operation.
See Qt documentation:
https://doc.qt.io/qt-5/qabstractitemmodel.html#beginMoveRows
"""
src_par, src_idx = self._split_nested_index(event.index)
dest_par, dest_idx = self._split_nested_index(event.new_index)
self.beginMoveRows(src_par, src_idx, src_idx, dest_par, dest_idx)
def _on_end_move(self):
"""Must be called after move operation to update model."""
self.endMoveRows()
def getItem(self, index: QModelIndex) -> ItemType:
"""Return python object for a given `QModelIndex`.
An invalid `QModelIndex` will return the root object.
"""
return self._root[index.row()] if index.isValid() else self._root
def _process_event(self, event):
# for subclasses to handle ItemType-specific data
pass
napari-0.5.0a1/napari/_qt/containers/_base_item_view.py 0000664 0000000 0000000 00000012403 14370413656 0023116 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from itertools import chain, repeat
from typing import TYPE_CHECKING, Generic, TypeVar
from qtpy.QtCore import QItemSelection, QModelIndex, Qt
from qtpy.QtWidgets import QAbstractItemView
from napari._qt.containers._base_item_model import ItemRole
from napari._qt.containers._factory import create_model
ItemType = TypeVar("ItemType")
if TYPE_CHECKING:
from qtpy.QtCore import QAbstractItemModel
from qtpy.QtGui import QKeyEvent
from napari._qt.containers._base_item_model import _BaseEventedItemModel
from napari.utils.events import Event
from napari.utils.events.containers import SelectableEventedList
class _BaseEventedItemView(Generic[ItemType]):
"""A QAbstractItemView mixin desigend to work with `SelectableEventedList`.
:class:`~napari.utils.events.SelectableEventedList` is our pure python
model of a mutable sequence that supports the concept of "currently
selected/active items". It emits events when the list is altered (e.g.,
by appending, inserting, removing items), or when the selection model is
altered.
This class is an adapter between that interface and Qt's
`QAbstractItemView` interface (see `Qt Model/View Programming
`_). It allows python
users to interact with the list in the "usual" python ways, while updating
any Qt Views that may be connected, and also updates the python list object
if any GUI events occur in the view.
For a "plain" (flat) list, use the
:class:`napari._qt.containers.QtListView` subclass.
For a nested list-of-lists using the Group/Node classes, use the
:class:`napari._qt.containers.QtNodeTreeView` subclass.
For convenience, the :func:`napari._qt.containers.create_view` factory
function will return the appropriate `_BaseEventedItemView` instance given
a python `EventedList` object.
"""
# ########## Reimplemented Public Qt Functions ##################
def model(self) -> _BaseEventedItemModel[ItemType]: # for type hints
return super().model()
def keyPressEvent(self, e: QKeyEvent) -> None:
"""Delete items with delete key."""
if e.key() in (Qt.Key.Key_Backspace, Qt.Key.Key_Delete):
self._root.remove_selected()
return
return super().keyPressEvent(e)
def currentChanged(
self: QAbstractItemView, current: QModelIndex, previous: QModelIndex
):
"""The Qt current item has changed. Update the python model."""
self._root.selection._current = current.data(ItemRole)
return super().currentChanged(current, previous)
def selectionChanged(
self: QAbstractItemView,
selected: QItemSelection,
deselected: QItemSelection,
):
"""The Qt Selection has changed. Update the python model."""
sel = {i.data(ItemRole) for i in selected.indexes()}
desel = {i.data(ItemRole) for i in deselected.indexes()}
if not self._root.selection.events.changed._emitting:
self._root.selection.update(sel)
self._root.selection.difference_update(desel)
return super().selectionChanged(selected, deselected)
# ###### Non-Qt methods added for SelectableEventedList Model ############
def setRoot(self, root: SelectableEventedList[ItemType]):
"""Call during __init__, to set the python model."""
self._root = root
self.setModel(create_model(root, self))
# connect selection events
root.selection.events.changed.connect(self._on_py_selection_change)
root.selection.events._current.connect(self._on_py_current_change)
self._sync_selection_models()
def _on_py_current_change(self, event: Event):
"""The python model current item has changed. Update the Qt view."""
sm = self.selectionModel()
if not event.value:
sm.clearCurrentIndex()
else:
idx = index_of(self.model(), event.value)
sm.setCurrentIndex(idx, sm.SelectionFlag.Current)
def _on_py_selection_change(self, event: Event):
"""The python model selection has changed. Update the Qt view."""
sm = self.selectionModel()
for is_selected, idx in chain(
zip(repeat(sm.SelectionFlag.Select), event.added),
zip(repeat(sm.SelectionFlag.Deselect), event.removed),
):
model_idx = index_of(self.model(), idx)
if model_idx.isValid():
sm.select(model_idx, is_selected)
def _sync_selection_models(self):
"""Clear and re-sync the Qt selection view from the python selection."""
sel_model = self.selectionModel()
selection = QItemSelection()
for i in self._root.selection:
idx = index_of(self.model(), i)
selection.select(idx, idx)
sel_model.select(selection, sel_model.SelectionFlag.ClearAndSelect)
def index_of(model: QAbstractItemModel, obj: ItemType) -> QModelIndex:
"""Find the `QModelIndex` for a given object in the model."""
fl = Qt.MatchFlag.MatchExactly | Qt.MatchFlag.MatchRecursive
hits = model.match(
model.index(0, 0, QModelIndex()),
Qt.ItemDataRole.UserRole,
obj,
hits=1,
flags=fl,
)
return hits[0] if hits else QModelIndex()
napari-0.5.0a1/napari/_qt/containers/_factory.py 0000664 0000000 0000000 00000004377 14370413656 0021616 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING, Union
from napari.components.layerlist import LayerList
from napari.utils.events import SelectableEventedList
from napari.utils.translations import trans
from napari.utils.tree import Group
if TYPE_CHECKING:
from qtpy.QtWidgets import QWidget
def create_view(
obj: Union[SelectableEventedList, Group], parent: QWidget = None
):
"""Create a `QtListView`, or `QtNodeTreeView` for `obj`.
Parameters
----------
obj : SelectableEventedList or Group
The python object for which to creat a QtView.
parent : QWidget, optional
Optional parent widget, by default None
Returns
-------
Union[QtListView, QtNodeTreeView]
A view instance appropriate for `obj`.
"""
from napari._qt.containers import QtLayerList, QtListView, QtNodeTreeView
if isinstance(obj, LayerList):
return QtLayerList(obj, parent=parent)
if isinstance(obj, Group):
return QtNodeTreeView(obj, parent=parent)
if isinstance(obj, SelectableEventedList):
return QtListView(obj, parent=parent)
raise TypeError(
trans._(
"Cannot create Qt view for obj: {obj}",
deferred=True,
obj=obj,
)
)
def create_model(
obj: Union[SelectableEventedList, Group], parent: QWidget = None
):
"""Create a `QtListModel`, or `QtNodeTreeModel` for `obj`.
Parameters
----------
obj : SelectableEventedList or Group
The python object for which to creat a QtView.
parent : QWidget, optional
Optional parent widget, by default None
Returns
-------
Union[QtListModel, QtNodeTreeModel]
A model instance appropriate for `obj`.
"""
from napari._qt.containers import (
QtLayerListModel,
QtListModel,
QtNodeTreeModel,
)
if isinstance(obj, LayerList):
return QtLayerListModel(obj, parent=parent)
if isinstance(obj, Group):
return QtNodeTreeModel(obj, parent=parent)
if isinstance(obj, SelectableEventedList):
return QtListModel(obj, parent=parent)
raise TypeError(
trans._(
"Cannot create Qt model for obj: {obj}",
deferred=True,
obj=obj,
)
)
napari-0.5.0a1/napari/_qt/containers/_layer_delegate.py 0000664 0000000 0000000 00000021222 14370413656 0023101 0 ustar 00root root 0000000 0000000 """
General rendering flow:
1. The List/Tree view needs to display or edit an index in the model...
2. It gets the ``itemDelegate``
a. A custom delegate can be set with ``setItemDelegate``
b. ``QStyledItemDelegate`` is the default delegate for all Qt item views,
and is installed upon them when they are created.
3. ``itemDelegate.paint`` is called on the index being displayed
4. Each index in the model has various data elements (i.e. name, image, etc..),
each of which has a "data role". A model should return the appropriate data
for each role by reimplementing ``QAbstractItemModel.data``.
a. `QStyledItemDelegate` implements display and editing for the most common
datatypes expected by users, including booleans, integers, and strings.
b. If the delegate does not support painting of the data types you need or
you want to customize the drawing of items, you need to subclass
``QStyledItemDelegate``, and reimplement ``paint()`` and possibly
``sizeHint()``.
c. When reimplementing ``paint()``, one typically handles the datatypes
they would like to draw and uses the superclass implementation for other
types.
5. The default implementation of ``QStyledItemDelegate.paint`` paints the item
using the view's ``QStyle`` (which is, by default, an OS specific style...
but see ``QCommonStyle`` for a generic implementation)
a. It is also possible to override the view's style, using either a
subclass of ``QCommonStyle``, for a platform-independent look and feel, or
``QProxyStyle``, which let's you override only certain stylistic elements
on any platform, falling back to the system default otherwise.
b. ``QStyle`` paints various elements using methods like ``drawPrimitive``
and ``drawControl``. These can be overridden for very fine control.
6. It is hard to use stylesheets with custom ``QStyles``... but it's possible
to style sub-controls in ``QAbstractItemView`` (such as ``QTreeView``):
https://doc.qt.io/qt-5/stylesheet-reference.html#list-of-sub-controls
"""
from __future__ import annotations
from typing import TYPE_CHECKING
from qtpy.QtCore import QPoint, QSize, Qt
from qtpy.QtGui import QMouseEvent, QPixmap
from qtpy.QtWidgets import QStyledItemDelegate
from napari._app_model.constants import MenuId
from napari._app_model.context import get_context
from napari._qt._qapp_model import build_qmodel_menu
from napari._qt.containers._base_item_model import ItemRole
from napari._qt.containers.qt_layer_model import ThumbnailRole
from napari._qt.qt_resources import QColoredSVGIcon
if TYPE_CHECKING:
from qtpy import QtCore
from qtpy.QtGui import QPainter
from qtpy.QtWidgets import QStyleOptionViewItem, QWidget
from napari.components.layerlist import LayerList
class LayerDelegate(QStyledItemDelegate):
"""A QItemDelegate specialized for painting Layer objects.
In Qt's `Model/View architecture
`_. A *delegate* is an
object that controls the visual rendering (and editing widgets) of an item
in a view. For more, see:
https://doc.qt.io/qt-5/model-view-programming.html#delegate-classes
This class provides the logic required to paint a Layer item in the
:class:`napari._qt.containers.QtLayerList`. The `QStyledItemDelegate`
super-class provides most of the logic (including display/editing of the
layer name, a visibility checkbox, and an icon for the layer type). This
subclass provides additional logic for drawing the layer thumbnail, picking
the appropriate icon for the layer, and some additional style/UX issues.
"""
def paint(
self,
painter: QPainter,
option: QStyleOptionViewItem,
index: QtCore.QModelIndex,
):
"""Paint the item in the model at `index`."""
# update the icon based on layer type
self.get_layer_icon(option, index)
# paint the standard itemView (includes name, icon, and vis. checkbox)
super().paint(painter, option, index)
# paint the thumbnail
self._paint_thumbnail(painter, option, index)
def get_layer_icon(
self, option: QStyleOptionViewItem, index: QtCore.QModelIndex
):
"""Add the appropriate QIcon to the item based on the layer type."""
layer = index.data(ItemRole)
if layer is None:
return
if hasattr(layer, 'is_group') and layer.is_group(): # for layer trees
expanded = option.widget.isExpanded(index)
icon_name = 'folder-open' if expanded else 'folder'
else:
icon_name = f'new_{layer._type_string}'
try:
icon = QColoredSVGIcon.from_resources(icon_name)
except ValueError:
return
# guessing theme rather than passing it through.
bg = option.palette.color(option.palette.ColorRole.Window).red()
option.icon = icon.colored(theme='dark' if bg < 128 else 'light')
option.decorationSize = QSize(18, 18)
option.decorationPosition = (
option.Position.Right
) # put icon on the right
option.features |= option.ViewItemFeature.HasDecoration
def _paint_thumbnail(self, painter, option, index):
"""paint the layer thumbnail."""
# paint the thumbnail
# MAGICNUMBER: numbers from the margin applied in the stylesheet to
# QtLayerTreeView::item
thumb_rect = option.rect.translated(-2, 2)
h = index.data(Qt.ItemDataRole.SizeHintRole).height() - 4
thumb_rect.setWidth(h)
thumb_rect.setHeight(h)
image = index.data(ThumbnailRole)
painter.drawPixmap(thumb_rect, QPixmap.fromImage(image))
def createEditor(
self,
parent: QWidget,
option: QStyleOptionViewItem,
index: QtCore.QModelIndex,
) -> QWidget:
"""User has double clicked on layer name."""
# necessary for geometry, otherwise editor takes up full width.
self.get_layer_icon(option, index)
editor = super().createEditor(parent, option, index)
# make sure editor has same alignment as the display name
editor.setAlignment(
Qt.Alignment(index.data(Qt.ItemDataRole.TextAlignmentRole))
)
return editor
def editorEvent(
self,
event: QtCore.QEvent,
model: QtCore.QAbstractItemModel,
option: QStyleOptionViewItem,
index: QtCore.QModelIndex,
) -> bool:
"""Called when an event has occured in the editor.
This can be used to customize how the delegate handles mouse/key events
"""
if (
event.type() == QMouseEvent.MouseButtonRelease
and event.button() == Qt.MouseButton.RightButton
):
pnt = (
event.globalPosition().toPoint()
if hasattr(event, "globalPosition")
else event.globalPos()
)
self.show_context_menu(index, model, pnt, option.widget)
# if the user clicks quickly on the visibility checkbox, we *don't*
# want it to be interpreted as a double-click. We want the visibilty
# to simply be toggled.
if event.type() == QMouseEvent.MouseButtonDblClick:
self.initStyleOption(option, index)
style = option.widget.style()
check_rect = style.subElementRect(
style.SubElement.SE_ItemViewItemCheckIndicator,
option,
option.widget,
)
if check_rect.contains(event.pos()):
cur_state = index.data(Qt.ItemDataRole.CheckStateRole)
if model.flags(index) & Qt.ItemFlag.ItemIsUserTristate:
state = Qt.CheckState((cur_state + 1) % 3)
else:
state = (
Qt.CheckState.Unchecked
if cur_state
else Qt.CheckState.Checked
)
return model.setData(
index, state, Qt.ItemDataRole.CheckStateRole
)
# refer all other events to the QStyledItemDelegate
return super().editorEvent(event, model, option, index)
def show_context_menu(self, index, model, pos: QPoint, parent):
"""Show the layerlist context menu.
To add a new item to the menu, update the _LAYER_ACTIONS dict.
"""
if not hasattr(self, '_context_menu'):
self._context_menu = build_qmodel_menu(
MenuId.LAYERLIST_CONTEXT, parent=parent
)
layer_list: LayerList = model.sourceModel()._root
self._context_menu.update_from_context(get_context(layer_list))
self._context_menu.exec_(pos)
napari-0.5.0a1/napari/_qt/containers/_tests/ 0000775 0000000 0000000 00000000000 14370413656 0020724 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/containers/_tests/test_factory.py 0000664 0000000 0000000 00000001303 14370413656 0024001 0 ustar 00root root 0000000 0000000 import pytest
from napari._qt.containers import (
QtListModel,
QtListView,
QtNodeTreeModel,
QtNodeTreeView,
create_view,
)
from napari.utils.events.containers import SelectableEventedList
from napari.utils.tree import Group, Node
class T(Node):
def __init__(self, x) -> None:
self.x = x
@pytest.mark.parametrize(
'cls, exView, exModel',
[
(SelectableEventedList, QtListView, QtListModel),
(Group, QtNodeTreeView, QtNodeTreeModel),
],
)
def test_factory(qtbot, cls, exView, exModel):
a = cls([T(1), T(2)])
view = create_view(a)
qtbot.addWidget(view)
assert isinstance(view, exView)
assert isinstance(view.model(), exModel)
napari-0.5.0a1/napari/_qt/containers/_tests/test_qt_layer_list.py 0000664 0000000 0000000 00000003203 14370413656 0025206 0 ustar 00root root 0000000 0000000 from typing import Tuple
import numpy as np
from qtpy.QtCore import QModelIndex, Qt
from napari._qt.containers import QtLayerList
from napari.components import LayerList
from napari.layers import Image
def test_set_layer_invisible_makes_item_unchecked(qtbot):
view, image = make_qt_layer_list_with_layer(qtbot)
assert image.visible
assert check_state_at_layer_index(view, 0) == Qt.CheckState.Checked
image.visible = False
assert check_state_at_layer_index(view, 0) == Qt.CheckState.Unchecked
def test_set_item_unchecked_makes_layer_invisible(qtbot):
view, image = make_qt_layer_list_with_layer(qtbot)
assert check_state_at_layer_index(view, 0) == Qt.CheckState.Checked
assert image.visible
view.model().setData(
layer_to_model_index(view, 0),
Qt.CheckState.Unchecked,
Qt.ItemDataRole.CheckStateRole,
)
assert not image.visible
def make_qt_layer_list_with_layer(qtbot) -> Tuple[QtLayerList, Image]:
image = Image(np.zeros((4, 3)))
layers = LayerList([image])
view = QtLayerList(layers)
qtbot.addWidget(view)
return view, image
def layer_to_model_index(view: QtLayerList, layer_index: int) -> QModelIndex:
return view.model().index(layer_index, 0, view.rootIndex())
def check_state_at_layer_index(
view: QtLayerList, layer_index: int
) -> Qt.CheckState:
model_index = layer_to_model_index(view, layer_index)
value = view.model().data(model_index, Qt.ItemDataRole.CheckStateRole)
# The data method returns integer value of the enum in some cases, so
# ensure it has the enum type for more explicit assertions.
return Qt.CheckState(value)
napari-0.5.0a1/napari/_qt/containers/_tests/test_qt_list.py 0000664 0000000 0000000 00000007101 14370413656 0024013 0 ustar 00root root 0000000 0000000 from unittest.mock import Mock
import pytest
from qtpy.QtCore import QEvent, QModelIndex, Qt
from qtpy.QtGui import QKeyEvent
from napari._qt.containers import QtListModel, QtListView
from napari.utils.events._tests.test_evented_list import BASIC_INDICES
from napari.utils.events.containers import SelectableEventedList
class T:
def __init__(self, name) -> None:
self.name = name
def __str__(self):
return str(self.name)
def __hash__(self):
return id(self)
def __eq__(self, o: object) -> bool:
return self.name == o
def test_list_model():
root: SelectableEventedList[str] = SelectableEventedList('abcdef')
model = QtListModel(root)
assert all(
model.data(model.index(i), Qt.UserRole) == letter
for i, letter in enumerate('abcdef')
)
assert all(
model.data(model.index(i), Qt.DisplayRole) == letter
for i, letter in enumerate('abcdef')
)
# unknown data role
assert not any(model.data(model.index(i), Qt.FontRole) for i in range(5))
assert model.flags(QModelIndex()) & Qt.ItemIsDropEnabled
assert not (model.flags(model.index(1)) & Qt.ItemIsDropEnabled)
with pytest.raises(TypeError):
model.setRoot('asdf')
# smoke test that we can change the root model.
model.setRoot(SelectableEventedList('zysv'))
def test_list_view(qtbot):
root: SelectableEventedList[T] = SelectableEventedList(map(T, range(5)))
root.selection.clear()
assert not root.selection
view = QtListView(root)
qmodel = view.model()
qsel = view.selectionModel()
qtbot.addWidget(view)
# update selection in python
_selection = {root[0], root[2]}
root.selection.update(_selection)
assert root[2] in root.selection
# check selection in Qt
idx = {qmodel.getItem(i) for i in qsel.selectedIndexes()}
assert idx == _selection
# clear selection in Qt
qsel.clearSelection()
# check selection in python
assert not root.selection
# update current in python
root.selection._current = root[3]
# check current in Qt
assert root.selection._current == root[3]
assert qmodel.getItem(qsel.currentIndex()) == root[3]
# clear current in Qt
qsel.setCurrentIndex(QModelIndex(), qsel.SelectionFlag.Current)
# check current in python
assert root.selection._current is None
def test_list_view_keypress(qtbot):
root: SelectableEventedList[T] = SelectableEventedList(map(T, range(5)))
view = QtListView(root)
qtbot.addWidget(view)
first = root[0]
root.selection = {first}
assert first in root.selection
# delete removes the item from the python model too
view.keyPressEvent(
QKeyEvent(QEvent.KeyPress, Qt.Key_Delete, Qt.NoModifier)
)
assert first not in root
@pytest.mark.parametrize('sources, dest, expectation', BASIC_INDICES)
def test_move_multiple(sources, dest, expectation):
"""Test that models stay in sync with complicated moves.
This uses mimeData to simulate drag/drop operations.
"""
root = SelectableEventedList(map(T, range(8)))
root.events = Mock(wraps=root.events)
assert root != expectation
qt_tree = QtListModel(root)
dest_mi = qt_tree.index(dest)
qt_tree.dropMimeData(
qt_tree.mimeData([qt_tree.index(i) for i in sources]),
Qt.MoveAction,
dest_mi.row(),
dest_mi.column(),
dest_mi.parent(),
)
assert root == qt_tree._root == expectation
root.events.moving.assert_called()
root.events.moved.assert_called()
root.events.reordered.assert_called_with(value=[T(i) for i in expectation])
napari-0.5.0a1/napari/_qt/containers/_tests/test_qt_tree.py 0000664 0000000 0000000 00000012164 14370413656 0024004 0 ustar 00root root 0000000 0000000 import pytest
from qtpy.QtCore import QModelIndex, Qt
from napari._qt.containers import QtNodeTreeModel, QtNodeTreeView
from napari._qt.containers._base_item_view import index_of
from napari.utils.events._tests.test_evented_list import NESTED_POS_INDICES
from napari.utils.tree import Group, Node
@pytest.fixture
def tree_model(qapp):
root = Group(
[
Node(name="1"),
Group(
[
Node(name="2"),
Group([Node(name="3"), Node(name="4")], name="g2"),
Node(name="5"),
Node(name="6"),
Node(name="7"),
],
name="g1",
),
Node(name="8"),
Node(name="9"),
],
name="root",
)
return QtNodeTreeModel(root)
def _recursive_make_group(lst, level=0):
"""Make a Tree of Group/Node objects from a nested list."""
out = []
for item in lst:
if isinstance(item, list):
out.append(_recursive_make_group(item, level=level + 1))
else:
out.append(Node(name=str(item)))
return Group(out, name=f'g{level}')
def _assert_models_synced(model: Group, qt_model: QtNodeTreeModel):
for item in model.traverse():
model_idx = qt_model.nestedIndex(item.index_from_root())
node = qt_model.getItem(model_idx)
assert item.name == node.name
def test_move_single_tree_item(tree_model):
"""Test moving a single item."""
root = tree_model._root
assert isinstance(root, Group)
_assert_models_synced(root, tree_model)
root.move(0, 2)
_assert_models_synced(root, tree_model)
root.move(3, 1)
_assert_models_synced(root, tree_model)
@pytest.mark.parametrize('sources, dest, expectation', NESTED_POS_INDICES)
def test_nested_move_multiple(qapp, sources, dest, expectation):
"""Test that models stay in sync with complicated moves.
This uses mimeData to simulate drag/drop operations.
"""
root = _recursive_make_group([0, 1, [20, [210, 211], 22], 3, 4])
qt_tree = QtNodeTreeModel(root)
model_indexes = [qt_tree.nestedIndex(i) for i in sources]
mime_data = qt_tree.mimeData(model_indexes)
dest_mi = qt_tree.nestedIndex(dest)
qt_tree.dropMimeData(
mime_data,
Qt.MoveAction,
dest_mi.row(),
dest_mi.column(),
dest_mi.parent(),
)
expected = _recursive_make_group(expectation)
_assert_models_synced(expected, qt_tree)
def test_qt_tree_model_deletion(qapp):
"""Test that we can delete items from a QTreeModel"""
root = _recursive_make_group([0, 1, [20, [210, 211], 22], 3, 4])
qt_tree = QtNodeTreeModel(root)
_assert_models_synced(root, qt_tree)
del root[2, 1]
e = _recursive_make_group([0, 1, [20, 22], 3, 4])
_assert_models_synced(e, qt_tree)
def test_qt_tree_model_insertion(qapp):
"""Test that we can append and insert items to a QTreeModel."""
root = _recursive_make_group([0, 1, [20, [210, 211], 22], 3, 4])
qt_tree = QtNodeTreeModel(root)
_assert_models_synced(root, qt_tree)
root[2, 1].append(Node(name='212'))
e = _recursive_make_group([0, 1, [20, [210, 211, 212], 22], 3, 4])
_assert_models_synced(e, qt_tree)
root.insert(-2, Node(name='9'))
e = _recursive_make_group([0, 1, [20, [210, 211, 212], 22], 9, 3, 4])
_assert_models_synced(e, qt_tree)
def test_find_nodes(qapp):
root = _recursive_make_group([0, 1, [20, [210, 211], 22], 3, 4])
qt_tree = QtNodeTreeModel(root)
_assert_models_synced(root, qt_tree)
node = Node(name='212')
root[2, 1].append(node)
assert index_of(qt_tree, node).row() == 2
assert not index_of(qt_tree, Node(name='new node')).isValid()
def test_node_tree_view(qtbot):
root = _recursive_make_group([0, 1, [20, [210, 211], 22], 3, 4])
root.selection.clear()
assert not root.selection
view = QtNodeTreeView(root)
qmodel = view.model()
qsel = view.selectionModel()
qtbot.addWidget(view)
# update selection in python
root.selection.update([root[0], root[2, 0]])
assert root[2, 0] in root.selection
# check selection in Qt
idx = {qmodel.getItem(i).index_from_root() for i in qsel.selectedIndexes()}
assert idx == {(0,), (2, 0)}
# clear selection in Qt
qsel.clearSelection()
# check selection in python
assert not root.selection
# update current in python
root.selection._current = root[2, 1, 0]
# check current in Qt
assert root.selection._current == root[2, 1, 0]
assert qmodel.getItem(qsel.currentIndex()).index_from_root() == (2, 1, 0)
# clear current in Qt
qsel.setCurrentIndex(QModelIndex(), qsel.SelectionFlag.Current)
# check current in python
assert root.selection._current is None
def test_flags(tree_model):
"""Some sanity checks on retrieving flags for nested items"""
assert not tree_model.hasIndex(5, 0, tree_model.index(1))
last = tree_model._root.pop()
tree_model._root[1].append(last)
assert tree_model.hasIndex(5, 0, tree_model.index(1))
idx = tree_model.index(5, 0, tree_model.index(1))
assert bool(tree_model.flags(idx) & Qt.ItemFlag.ItemIsEnabled)
napari-0.5.0a1/napari/_qt/containers/qt_layer_list.py 0000664 0000000 0000000 00000004235 14370413656 0022654 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
from qtpy.QtCore import QSortFilterProxyModel, Qt
from napari._qt.containers._base_item_model import (
SortRole,
_BaseEventedItemModel,
)
from napari._qt.containers._layer_delegate import LayerDelegate
from napari._qt.containers.qt_list_view import QtListView
from napari.layers import Layer
from napari.utils.translations import trans
if TYPE_CHECKING:
from qtpy.QtGui import QKeyEvent
from qtpy.QtWidgets import QWidget
from napari.components.layerlist import LayerList
class ReverseProxyModel(QSortFilterProxyModel):
"""Proxy Model that reverses the view order of a _BaseEventedItemModel."""
def __init__(self, model: _BaseEventedItemModel) -> None:
super().__init__()
self.setSourceModel(model)
self.setSortRole(SortRole)
self.sort(0, Qt.SortOrder.DescendingOrder)
def dropMimeData(self, data, action, destRow, col, parent):
"""Handle destination row for dropping with reversed indices."""
row = 0 if destRow == -1 else self.sourceModel().rowCount() - destRow
return self.sourceModel().dropMimeData(data, action, row, col, parent)
class QtLayerList(QtListView[Layer]):
"""QItemView subclass specialized for the LayerList.
This is as mostly for targetting with QSS, applying the delegate and
reversing the view with ReverseProxyModel.
"""
def __init__(self, root: LayerList, parent: QWidget = None) -> None:
super().__init__(root, parent)
self.setItemDelegate(LayerDelegate())
self.setToolTip(trans._('Layer list'))
font = self.font()
font.setPointSize(12)
self.setFont(font)
# This reverses the order of the items in the view,
# so items at the end of the list are at the top.
self.setModel(ReverseProxyModel(self.model()))
def keyPressEvent(self, e: QKeyEvent) -> None:
"""Override Qt event to pass events to the viewer."""
if e.key() != Qt.Key.Key_Space:
super().keyPressEvent(e)
if e.key() not in (Qt.Key.Key_Backspace, Qt.Key.Key_Delete):
e.ignore() # pass key events up to viewer
napari-0.5.0a1/napari/_qt/containers/qt_layer_model.py 0000664 0000000 0000000 00000006351 14370413656 0023002 0 ustar 00root root 0000000 0000000 import typing
from qtpy.QtCore import QModelIndex, QSize, Qt
from qtpy.QtGui import QImage
from napari._qt.containers.qt_list_model import QtListModel
from napari.layers import Layer
ThumbnailRole = Qt.UserRole + 2
class QtLayerListModel(QtListModel[Layer]):
def data(self, index: QModelIndex, role: Qt.ItemDataRole):
"""Return data stored under ``role`` for the item at ``index``."""
if not index.isValid():
return None
layer = self.getItem(index)
if role == Qt.ItemDataRole.DisplayRole: # used for item text
return layer.name
if role == Qt.ItemDataRole.TextAlignmentRole: # alignment of the text
return Qt.AlignCenter
if role == Qt.ItemDataRole.EditRole:
# used to populate line edit when editing
return layer.name
if role == Qt.ItemDataRole.ToolTipRole: # for tooltip
return layer.get_source_str()
if (
role == Qt.ItemDataRole.CheckStateRole
): # the "checked" state of this item
return (
Qt.CheckState.Checked
if layer.visible
else Qt.CheckState.Unchecked
)
if role == Qt.ItemDataRole.SizeHintRole: # determines size of item
return QSize(200, 34)
if role == ThumbnailRole: # return the thumbnail
thumbnail = layer.thumbnail
return QImage(
thumbnail,
thumbnail.shape[1],
thumbnail.shape[0],
QImage.Format_RGBA8888,
)
# normally you'd put the icon in DecorationRole, but we do that in the
# # LayerDelegate which is aware of the theme.
# if role == Qt.ItemDataRole.DecorationRole: # icon to show
# pass
return super().data(index, role)
def setData(
self,
index: QModelIndex,
value: typing.Any,
role: int = Qt.ItemDataRole.EditRole,
) -> bool:
if role == Qt.ItemDataRole.CheckStateRole:
# The item model stores a Qt.CheckState enum value that can be
# partially checked, but we only use the unchecked and checked
# to correspond to the layer's visibility.
# https://doc.qt.io/qt-5/qt.html#CheckState-enum
self.getItem(index).visible = value == Qt.CheckState.Checked
elif role == Qt.ItemDataRole.EditRole:
self.getItem(index).name = value
role = Qt.ItemDataRole.DisplayRole
else:
return super().setData(index, value, role=role)
self.dataChanged.emit(index, index, [role])
return True
def _process_event(self, event):
# The model needs to emit `dataChanged` whenever data has changed
# for a given index, so that views can update themselves.
# Here we convert native events to the dataChanged signal.
if not hasattr(event, 'index'):
return
role = {
'thumbnail': ThumbnailRole,
'visible': Qt.ItemDataRole.CheckStateRole,
'name': Qt.ItemDataRole.DisplayRole,
}.get(event.type)
roles = [role] if role is not None else []
row = self.index(event.index)
self.dataChanged.emit(row, row, roles)
napari-0.5.0a1/napari/_qt/containers/qt_list_model.py 0000664 0000000 0000000 00000006366 14370413656 0022647 0 ustar 00root root 0000000 0000000 import logging
import pickle
from typing import List, Optional, Sequence, TypeVar
from qtpy.QtCore import QMimeData, QModelIndex, Qt
from napari._qt.containers._base_item_model import _BaseEventedItemModel
logger = logging.getLogger(__name__)
ListIndexMIMEType = "application/x-list-index"
ItemType = TypeVar("ItemType")
class QtListModel(_BaseEventedItemModel[ItemType]):
"""A QItemModel for a :class:`~napari.utils.events.SelectableEventedList`.
Designed to work with :class:`~napari._qt.containers.QtListView`.
See docstring of :class:`_BaseEventedItemModel` and
:class:`~napari._qt.containers.QtListView` for additional background.
"""
def mimeTypes(self) -> List[str]:
"""Returns the list of allowed MIME types.
When implementing drag and drop support in a custom model, if you will
return data in formats other than the default internal MIME type,
reimplement this function to return your list of MIME types.
"""
return [ListIndexMIMEType, "text/plain"]
def mimeData(self, indices: List[QModelIndex]) -> Optional['QMimeData']:
"""Return an object containing serialized data from `indices`.
If the list of indexes is empty, or there are no supported MIME types,
None is returned rather than a serialized empty list.
"""
if not indices:
return None
items, indices = zip(*[(self.getItem(i), i.row()) for i in indices])
return ItemMimeData(items, indices)
def dropMimeData(
self,
data: QMimeData,
action: Qt.DropAction,
destRow: int,
col: int,
parent: QModelIndex,
) -> bool:
"""Handles `data` from a drag and drop operation ending with `action`.
The specified row, column and parent indicate the location of an item
in the model where the operation ended. It is the responsibility of the
model to complete the action at the correct location.
Returns
-------
bool ``True`` if the `data` and `action` were handled by the model;
otherwise returns ``False``.
"""
if not data or action != Qt.DropAction.MoveAction:
return False
if not data.hasFormat(self.mimeTypes()[0]):
return False
if isinstance(data, ItemMimeData):
moving_indices = data.indices
logger.debug(
"dropMimeData: indices %s ➡ %s",
moving_indices,
destRow,
)
if len(moving_indices) == 1:
return self._root.move(moving_indices[0], destRow)
else:
return bool(self._root.move_multiple(moving_indices, destRow))
return False
class ItemMimeData(QMimeData):
"""An object to store list indices data during a drag operation."""
def __init__(
self, items: Sequence[ItemType], indices: Sequence[int]
) -> None:
super().__init__()
self.items = items
self.indices = tuple(sorted(indices))
if items:
self.setData(ListIndexMIMEType, pickle.dumps(self.indices))
self.setText(" ".join(str(item) for item in items))
def formats(self) -> List[str]:
return [ListIndexMIMEType, "text/plain"]
napari-0.5.0a1/napari/_qt/containers/qt_list_view.py 0000664 0000000 0000000 00000003076 14370413656 0022514 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING, TypeVar
from qtpy.QtWidgets import QListView
from napari._qt.containers._base_item_view import _BaseEventedItemView
from napari._qt.containers.qt_list_model import QtListModel
if TYPE_CHECKING:
from qtpy.QtWidgets import QWidget
from napari.utils.events.containers import SelectableEventedList
ItemType = TypeVar("ItemType")
class QtListView(_BaseEventedItemView[ItemType], QListView):
"""A QListView for a :class:`~napari.utils.events.SelectableEventedList`.
Designed to work with :class:`~napari._qt.containers.QtListModel`.
This class is an adapter between
:class:`~napari.utils.events.SelectableEventedList` and Qt's
`QAbstractItemView` interface (see `Qt Model/View Programming
`_). It allows python
users to interact with the list in the "usual" python ways, updating any Qt
Views that may be connected, and also updates the python list object if any
GUI events occur in the view.
See docstring of :class:`_BaseEventedItemView` for additional background.
"""
_root: SelectableEventedList[ItemType]
def __init__(
self, root: SelectableEventedList[ItemType], parent: QWidget = None
) -> None:
super().__init__(parent)
self.setDragDropMode(QListView.InternalMove)
self.setDragDropOverwriteMode(False)
self.setSelectionMode(QListView.ExtendedSelection)
self.setRoot(root)
def model(self) -> QtListModel[ItemType]:
return super().model()
napari-0.5.0a1/napari/_qt/containers/qt_tree_model.py 0000664 0000000 0000000 00000020556 14370413656 0022630 0 ustar 00root root 0000000 0000000 import logging
import pickle
from typing import List, Optional, Tuple, TypeVar
from qtpy.QtCore import QMimeData, QModelIndex, Qt
from napari._qt.containers._base_item_model import _BaseEventedItemModel
from napari.utils.translations import trans
from napari.utils.tree import Group, Node
logger = logging.getLogger(__name__)
NodeType = TypeVar("NodeType", bound=Node)
NodeMIMEType = "application/x-tree-node"
class QtNodeTreeModel(_BaseEventedItemModel[NodeType]):
"""A QItemModel for a tree of ``Node`` and ``Group`` objects.
Designed to work with :class:`napari.utils.tree.Group` and
:class:`~napari._qt.containers.QtNodeTreeView`.
See docstring of :class:`_BaseEventedItemModel` and
:class:`~napari._qt.containers.QtNodeTreeView` for additional background.
"""
_root: Group[NodeType]
# ########## Reimplemented Public Qt Functions ##################
def data(self, index: QModelIndex, role: Qt.ItemDataRole):
"""Return data stored under ``role`` for the item at ``index``.
A given class:`QModelIndex` can store multiple types of data, each with
its own "ItemDataRole".
"""
item = self.getItem(index)
if role == Qt.ItemDataRole.DisplayRole:
return item._node_name()
if role == Qt.ItemDataRole.UserRole:
return self.getItem(index)
return None
def index(
self, row: int, column: int = 0, parent: QModelIndex = None
) -> QModelIndex:
"""Return a QModelIndex for item at `row`, `column` and `parent`."""
# NOTE: self.createIndex(row, col, object) will create a model index
# that *stores* a pointer to the object, which can be retrieved later
# with index.internalPointer(). That's convenient and performant, but
# it comes with a bug if integers are in the list, because
# `createIndex` is overloaded and `self.createIndex(row, col, )`
# will assume that the third argument *is* the id of the object (not
# the object itself). This will then cause a segfault if
# `index.internalPointer()` is used later.
# XXX: discuss
# so we need to either:
# 1. refuse store integers in this model
# 2. never store the object (and incur the penalty of
# self.getItem(idx) each time you want to get the value of an idx)
# 3. Have special treatment when we encounter integers in the model
if parent is None:
parent = QModelIndex()
return (
self.createIndex(row, column, self.getItem(parent)[row])
if self.hasIndex(row, column, parent)
else QModelIndex() # instead of index error, Qt wants null index
)
def getItem(self, index: QModelIndex) -> NodeType:
"""Return python object for a given `QModelIndex`.
An invalid `QModelIndex` will return the root object.
"""
if index.isValid():
item = index.internalPointer()
if item is not None:
return item
return self._root
def parent(self, index: QModelIndex) -> QModelIndex:
"""Return the parent of the model item with the given ``index``.
If the item has no parent, an invalid QModelIndex is returned.
"""
if not index.isValid():
return QModelIndex() # null index
parentItem = self.getItem(index).parent
if parentItem is None or parentItem == self._root:
return QModelIndex()
# A common convention used in models that expose tree data structures
# is that only items in the first column have children. So here,the
# column of the returned is 0.
row = parentItem.index_in_parent() or 0
return self.createIndex(row, 0, parentItem)
def mimeTypes(self) -> List[str]:
"""Returns the list of allowed MIME types.
By default, the built-in models and views use an internal MIME type:
application/x-qabstractitemmodeldatalist.
When implementing drag and drop support in a custom model, if you will
return data in formats other than the default internal MIME type,
reimplement this function to return your list of MIME types.
If you reimplement this function in your custom model, you must also
reimplement the member functions that call it: mimeData() and
dropMimeData().
Returns
-------
list of str
MIME types allowed for drag & drop support
"""
return [NodeMIMEType, "text/plain"]
def mimeData(self, indices: List[QModelIndex]) -> Optional['NodeMimeData']:
"""Return an object containing serialized data from `indices`.
The format used to describe the encoded data is obtained from the
mimeTypes() function. The implementation uses the default MIME type
returned by the default implementation of mimeTypes(). If you
reimplement mimeTypes() in your custom model to return more MIME types,
reimplement this function to make use of them.
"""
# If the list of indexes is empty, or there are no supported MIME types
# nullptr is returned rather than a serialized empty list.
if not indices:
return 0
return NodeMimeData([self.getItem(i) for i in indices])
def dropMimeData(
self,
data: QMimeData,
action: Qt.DropAction,
destRow: int,
col: int,
parent: QModelIndex,
) -> bool:
"""Handles `data` from a drag and drop operation ending with `action`.
The specified row, column and parent indicate the location of an item
in the model where the operation ended. It is the responsibility of the
model to complete the action at the correct location.
Returns
-------
bool ``True`` if the `data` and `action` were handled by the model;
otherwise returns ``False``.
"""
if not data or action != Qt.DropAction.MoveAction:
return False
if not data.hasFormat(self.mimeTypes()[0]):
return False
if isinstance(data, NodeMimeData):
dest_idx = self.getItem(parent).index_from_root()
dest_idx = dest_idx + (destRow,)
moving_indices = data.node_indices()
logger.debug(
f"dropMimeData: indices {moving_indices} ➡ {dest_idx}"
)
if len(moving_indices) == 1:
self._root.move(moving_indices[0], dest_idx)
else:
self._root.move_multiple(moving_indices, dest_idx)
return True
return False
# ###### Non-Qt methods added for Group Model ############
def setRoot(self, root: Group[NodeType]):
if not isinstance(root, Group):
raise TypeError(
trans._(
"root node must be an instance of {Group}",
deferred=True,
Group=Group,
)
)
super().setRoot(root)
def nestedIndex(self, nested_index: Tuple[int, ...]) -> QModelIndex:
"""Return a QModelIndex for a given ``nested_index``."""
parent = QModelIndex()
if isinstance(nested_index, tuple):
if not nested_index:
return parent
*parents, child = nested_index
for i in parents:
parent = self.index(i, 0, parent)
elif isinstance(nested_index, int):
child = nested_index
else:
raise TypeError(
trans._(
"nested_index must be an int or tuple of int.",
deferred=True,
)
)
return self.index(child, 0, parent)
class NodeMimeData(QMimeData):
"""An object to store Node data during a drag operation."""
def __init__(self, nodes: Optional[List[NodeType]] = None) -> None:
super().__init__()
self.nodes: List[NodeType] = nodes or []
if nodes:
self.setData(NodeMIMEType, pickle.dumps(self.node_indices()))
self.setText(" ".join(node._node_name() for node in nodes))
def formats(self) -> List[str]:
return [NodeMIMEType, "text/plain"]
def node_indices(self) -> List[Tuple[int, ...]]:
return [node.index_from_root() for node in self.nodes]
def node_names(self) -> List[str]:
return [node._node_name() for node in self.nodes]
napari-0.5.0a1/napari/_qt/containers/qt_tree_view.py 0000664 0000000 0000000 00000004502 14370413656 0022473 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from collections.abc import MutableSequence
from typing import TYPE_CHECKING, TypeVar
from qtpy.QtWidgets import QTreeView
from napari._qt.containers._base_item_view import _BaseEventedItemView
from napari._qt.containers.qt_tree_model import QtNodeTreeModel
from napari.utils.tree import Group, Node
if TYPE_CHECKING:
from qtpy.QtCore import QModelIndex
from qtpy.QtWidgets import QWidget
NodeType = TypeVar("NodeType", bound=Node)
class QtNodeTreeView(_BaseEventedItemView[NodeType], QTreeView):
"""A QListView for a :class:`~napari.utils.tree.Group`.
Designed to work with :class:`~napari._qt.containers.QtNodeTreeModel`.
This class is an adapter between :class:`~napari.utils.tree.Group` and Qt's
`QAbstractItemView` interface (see `Qt Model/View Programming
`_). It allows python
users to interact with a list of lists in the "usual" python ways, updating
any Qt Views that may be connected, and also updates the python list object
if any GUI events occur in the view.
See docstring of :class:`_BaseEventedItemView` for additional background.
"""
_root: Group[Node]
def __init__(self, root: Group[Node], parent: QWidget = None) -> None:
super().__init__(parent)
self.setHeaderHidden(True)
self.setDragDropMode(QTreeView.InternalMove)
self.setDragDropOverwriteMode(False)
self.setSelectionMode(QTreeView.ExtendedSelection)
self.setRoot(root)
def setRoot(self, root: Group[Node]):
super().setRoot(root)
# make tree look like a list if it contains no lists.
self.model().rowsRemoved.connect(self._redecorate_root)
self.model().rowsInserted.connect(self._redecorate_root)
self._redecorate_root()
def _redecorate_root(self, parent: QModelIndex = None, *_):
"""Add a branch/arrow column only if there are Groups in the root.
This makes the tree fall back to looking like a simple list if there
are no lists in the root level.
"""
if not parent or not parent.isValid():
hasgroup = any(isinstance(i, MutableSequence) for i in self._root)
self.setRootIsDecorated(hasgroup)
def model(self) -> QtNodeTreeModel[NodeType]:
return super().model()
napari-0.5.0a1/napari/_qt/dialogs/ 0000775 0000000 0000000 00000000000 14370413656 0016700 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/dialogs/__init__.py 0000664 0000000 0000000 00000000060 14370413656 0021005 0 ustar 00root root 0000000 0000000 """Custom dialogs that inherit from QDialog."""
napari-0.5.0a1/napari/_qt/dialogs/_tests/ 0000775 0000000 0000000 00000000000 14370413656 0020201 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/dialogs/_tests/__init__.py 0000664 0000000 0000000 00000000000 14370413656 0022300 0 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/dialogs/_tests/test_about.py 0000664 0000000 0000000 00000000273 14370413656 0022726 0 ustar 00root root 0000000 0000000 from napari._qt.dialogs.qt_about import QtAbout
from napari._tests.utils import skip_local_popups
@skip_local_popups
def test_about(qtbot):
wdg = QtAbout()
qtbot.addWidget(wdg)
napari-0.5.0a1/napari/_qt/dialogs/_tests/test_activity_dialog.py 0000664 0000000 0000000 00000010053 14370413656 0024764 0 ustar 00root root 0000000 0000000 import os
import sys
from contextlib import contextmanager
import pytest
from napari._qt.widgets.qt_progress_bar import (
QtLabeledProgressBar,
QtProgressBarGroup,
)
from napari.utils import progress
SHOW = bool(sys.platform == 'linux' or os.getenv("CI"))
def qt_viewer_has_pbar(qt_viewer):
"""Returns True if the viewer has an active progress bar, else False"""
return bool(
qt_viewer.window._qt_viewer.window()._activity_dialog.findChildren(
QtLabeledProgressBar
)
)
@contextmanager
def assert_pbar_added_to(viewer):
"""Context manager checks that progress bar is added on construction"""
assert not qt_viewer_has_pbar(viewer)
yield
assert qt_viewer_has_pbar(viewer)
def activity_button_shows_indicator(activity_dialog):
"""Returns True if the progress indicator is visible, else False"""
return activity_dialog._toggleButton._inProgressIndicator.isVisible()
def get_qt_labeled_progress_bar(prog, viewer):
"""Given viewer and progress, finds associated QtLabeledProgressBar"""
activity_dialog = viewer.window._qt_viewer.window()._activity_dialog
pbar = activity_dialog.get_pbar_from_prog(prog)
return pbar
def get_progress_groups(qt_viewer):
"""Given viewer, find all QtProgressBarGroups in activity dialog"""
return qt_viewer.window()._activity_dialog.findChildren(QtProgressBarGroup)
def test_activity_dialog_holds_progress(make_napari_viewer):
"""Progress gets added to dialog & once finished it gets removed"""
viewer = make_napari_viewer(show=SHOW)
with assert_pbar_added_to(viewer):
r = range(100)
prog = progress(r)
pbar = get_qt_labeled_progress_bar(prog, viewer)
assert pbar is not None
assert pbar.progress is prog
assert pbar.qt_progress_bar.maximum() == prog.total
prog.close()
assert not pbar.isVisible()
def test_progress_with_context(make_napari_viewer):
"""Test adding/removing of progress bar with context manager"""
viewer = make_napari_viewer(show=SHOW)
with assert_pbar_added_to(viewer):
with progress(range(100)) as prog:
pbar = get_qt_labeled_progress_bar(prog, viewer)
assert pbar.qt_progress_bar.maximum() == prog.total == 100
def test_closing_viewer_no_error(make_napari_viewer):
"""Closing viewer with active progress doesn't cause RuntimeError"""
viewer = make_napari_viewer(show=SHOW)
assert not qt_viewer_has_pbar(viewer)
with progress(range(100)):
assert qt_viewer_has_pbar(viewer)
viewer.close()
def test_progress_nested(make_napari_viewer):
"""Test nested progress bars are added with QtProgressBarGroup"""
viewer = make_napari_viewer(show=SHOW)
assert not qt_viewer_has_pbar(viewer)
with progress(range(10)) as pbr:
assert qt_viewer_has_pbar(viewer)
pbr2 = progress(range(2), nest_under=pbr)
prog_groups = get_progress_groups(viewer.window._qt_viewer)
assert len(prog_groups) == 1
# two progress bars + separator
assert prog_groups[0].layout().count() == 3
pbr2.close()
assert not prog_groups[0].isVisible()
@pytest.mark.skipif(
not SHOW,
reason='viewer needs to be shown to test indicator',
)
def test_progress_indicator(make_napari_viewer):
viewer = make_napari_viewer(show=SHOW)
activity_dialog = viewer.window._qt_viewer.window()._activity_dialog
# it's not clear why, but using the context manager here
# causes test to fail, so we make the assertions explicitly
assert not qt_viewer_has_pbar(viewer)
with progress(range(10)):
assert qt_viewer_has_pbar(viewer)
assert activity_button_shows_indicator(activity_dialog)
@pytest.mark.skipif(
bool(sys.platform == 'linux'),
reason='need to debug sefaults with set_description',
)
def test_progress_set_description(make_napari_viewer):
viewer = make_napari_viewer(show=SHOW)
prog = progress(total=5)
prog.set_description("Test")
pbar = get_qt_labeled_progress_bar(prog, viewer)
assert pbar.description_label.text() == "Test: "
prog.close()
napari-0.5.0a1/napari/_qt/dialogs/_tests/test_confirm_close_dialog.py 0000664 0000000 0000000 00000003273 14370413656 0025760 0 ustar 00root root 0000000 0000000 from qtpy.QtWidgets import QDialog
from napari._qt.dialogs.confirm_close_dialog import ConfirmCloseDialog
from napari.settings import get_settings
def test_create_application_close(qtbot):
dialog = ConfirmCloseDialog(None, close_app=True)
qtbot.addWidget(dialog)
assert dialog.windowTitle() == 'Close Application?'
assert get_settings().application.confirm_close_window
assert dialog.close_btn.shortcut().toString() == 'Ctrl+Q'
dialog.close_btn.click()
assert dialog.result() == QDialog.DialogCode.Accepted
assert get_settings().application.confirm_close_window
def test_remove_confirmation(qtbot):
dialog = ConfirmCloseDialog(None, close_app=True)
dialog.do_not_ask.setChecked(True)
assert get_settings().application.confirm_close_window
dialog.close_btn.click()
assert dialog.result() == QDialog.DialogCode.Accepted
assert not get_settings().application.confirm_close_window
def test_remove_confirmation_reject(qtbot):
dialog = ConfirmCloseDialog(None, close_app=True)
dialog.do_not_ask.setChecked(True)
assert get_settings().application.confirm_close_window
dialog.cancel_btn.click()
assert dialog.result() == QDialog.DialogCode.Rejected
assert get_settings().application.confirm_close_window
def test_create_window_close(qtbot):
dialog = ConfirmCloseDialog(None, close_app=False)
qtbot.addWidget(dialog)
assert dialog.windowTitle() == 'Close Window?'
assert get_settings().application.confirm_close_window
assert dialog.close_btn.shortcut().toString() == 'Ctrl+W'
dialog.close_btn.click()
assert dialog.result() == QDialog.DialogCode.Accepted
assert get_settings().application.confirm_close_window
napari-0.5.0a1/napari/_qt/dialogs/_tests/test_installer_process.py 0000664 0000000 0000000 00000015172 14370413656 0025353 0 ustar 00root root 0000000 0000000 import re
import sys
import time
from pathlib import Path
from types import MethodType
from typing import TYPE_CHECKING
import pytest
from qtpy.QtCore import QProcessEnvironment
from napari._qt.dialogs.qt_package_installer import (
AbstractInstallerTool,
CondaInstallerTool,
InstallerQueue,
InstallerTools,
PipInstallerTool,
)
if TYPE_CHECKING:
from virtualenv.run import Session
@pytest.fixture
def tmp_virtualenv(tmp_path) -> 'Session':
virtualenv = pytest.importorskip('virtualenv')
cmd = [str(tmp_path), '--no-setuptools', '--no-wheel', '--activators', '']
return virtualenv.cli_run(cmd)
@pytest.fixture
def tmp_conda_env(tmp_path):
import subprocess
try:
subprocess.check_output(
[
CondaInstallerTool.executable(),
'create',
'-yq',
'-p',
str(tmp_path),
'--override-channels',
'-c',
'conda-forge',
f'python={sys.version_info.major}.{sys.version_info.minor}',
],
stderr=subprocess.STDOUT,
text=True,
timeout=300,
)
except subprocess.CalledProcessError as exc:
print(exc.output)
raise
return tmp_path
def test_pip_installer_tasks(qtbot, tmp_virtualenv: 'Session', monkeypatch):
installer = InstallerQueue()
monkeypatch.setattr(
PipInstallerTool, "executable", lambda *a: tmp_virtualenv.creator.exe
)
with qtbot.waitSignal(installer.allFinished, timeout=20000):
installer.install(
tool=InstallerTools.PIP,
pkgs=['pip-install-test'],
)
installer.install(
tool=InstallerTools.PIP,
pkgs=['typing-extensions'],
)
job_id = installer.install(
tool=InstallerTools.PIP,
pkgs=['requests'],
)
assert isinstance(job_id, int)
installer.cancel(job_id)
assert not installer.hasJobs()
pkgs = 0
for pth in tmp_virtualenv.creator.libs:
if (pth / 'pip_install_test').exists():
pkgs += 1
if (pth / 'typing_extensions.py').exists():
pkgs += 1
if (pth / 'requests').exists():
raise AssertionError('requests got installed')
assert pkgs >= 2, 'package was not installed'
with qtbot.waitSignal(installer.allFinished, timeout=10000):
job_id = installer.uninstall(
tool=InstallerTools.PIP,
pkgs=['pip-install-test'],
)
for pth in tmp_virtualenv.creator.libs:
assert not (
pth / 'pip_install_test'
).exists(), 'pip_install_test still installed'
assert not installer.hasJobs()
def _assert_exit_code_not_zero(
self, exit_code=None, exit_status=None, error=None
):
errors = []
if exit_code == 0:
errors.append("- 'exit_code' should have been non-zero!")
if error is not None:
errors.append("- 'error' should have been None!")
if errors:
raise AssertionError("\n".join(errors))
return self._on_process_done_original(exit_code, exit_status, error)
class _NonExistingTool(AbstractInstallerTool):
def executable(self):
return f"this-tool-does-not-exist-{hash(time.time())}"
def arguments(self):
return ()
def environment(self, env=None):
return QProcessEnvironment.systemEnvironment()
def _assert_error_used(self, exit_code=None, exit_status=None, error=None):
errors = []
if error is None:
errors.append("- 'error' should have been populated!")
if exit_code is not None:
errors.append("- 'exit_code' should not have been populated!")
if errors:
raise AssertionError("\n".join(errors))
return self._on_process_done_original(exit_code, exit_status, error)
def test_installer_failures(qtbot, tmp_virtualenv: 'Session', monkeypatch):
installer = InstallerQueue()
monkeypatch.setattr(
PipInstallerTool, "executable", lambda *a: tmp_virtualenv.creator.exe
)
# CHECK 1) Errors should trigger finished and allFinished too
with qtbot.waitSignal(installer.allFinished, timeout=10000):
installer.install(
tool=InstallerTools.PIP,
pkgs=[f'this-package-does-not-exist-{hash(time.time())}'],
)
# Keep a reference before we monkey patch stuff
installer._on_process_done_original = installer._on_process_done
# CHECK 2) Non-existing packages should return non-zero
monkeypatch.setattr(
installer,
"_on_process_done",
MethodType(_assert_exit_code_not_zero, installer),
)
with qtbot.waitSignal(installer.allFinished, timeout=10000):
installer.install(
tool=InstallerTools.PIP,
pkgs=[f'this-package-does-not-exist-{hash(time.time())}'],
)
# CHECK 3) Non-existing tools should fail to start
monkeypatch.setattr(
installer,
"_on_process_done",
MethodType(_assert_error_used, installer),
)
monkeypatch.setattr(installer, "_get_tool", lambda *a: _NonExistingTool)
with qtbot.waitSignal(installer.allFinished, timeout=10000):
installer.install(
tool=_NonExistingTool,
pkgs=[f'this-package-does-not-exist-{hash(time.time())}'],
)
@pytest.mark.skipif(
not CondaInstallerTool.available(), reason="Conda is not available."
)
def test_conda_installer(qtbot, tmp_conda_env: Path):
installer = InstallerQueue()
with qtbot.waitSignal(installer.allFinished, timeout=600_000):
installer.install(
tool=InstallerTools.CONDA,
pkgs=['typing-extensions'],
prefix=tmp_conda_env,
)
conda_meta = tmp_conda_env / "conda-meta"
glob_pat = "typing-extensions-*.json"
assert not installer.hasJobs()
assert list(conda_meta.glob(glob_pat))
with qtbot.waitSignal(installer.allFinished, timeout=600_000):
installer.uninstall(
tool=InstallerTools.CONDA,
pkgs=['typing-extensions'],
prefix=tmp_conda_env,
)
assert not installer.hasJobs()
assert not list(conda_meta.glob(glob_pat))
def test_constraints_are_in_sync():
conda_constraints = sorted(CondaInstallerTool.constraints())
pip_constraints = sorted(PipInstallerTool.constraints())
assert len(conda_constraints) == len(pip_constraints)
name_re = re.compile(r"([a-z0-9_\-]+).*")
for conda_constraint, pip_constraint in zip(
conda_constraints, pip_constraints
):
conda_name = name_re.match(conda_constraint).group(1)
pip_name = name_re.match(pip_constraint).group(1)
assert conda_name == pip_name
napari-0.5.0a1/napari/_qt/dialogs/_tests/test_preferences_dialog.py 0000664 0000000 0000000 00000003632 14370413656 0025436 0 ustar 00root root 0000000 0000000 import pytest
from pydantic import BaseModel
from qtpy.QtCore import Qt
from napari._qt.dialogs.preferences_dialog import (
PreferencesDialog,
QMessageBox,
)
from napari.settings import NapariSettings, get_settings
@pytest.fixture
def pref(qtbot):
dlg = PreferencesDialog()
qtbot.addWidget(dlg)
settings = get_settings()
assert settings.appearance.theme == 'dark'
dlg._settings.appearance.theme = 'light'
assert get_settings().appearance.theme == 'light'
yield dlg
def test_prefdialog_populated(pref):
subfields = filter(
lambda f: isinstance(f.type_, type) and issubclass(f.type_, BaseModel),
NapariSettings.__fields__.values(),
)
assert pref._stack.count() == len(list(subfields))
def test_preferences_dialog_accept(qtbot, pref):
with qtbot.waitSignal(pref.finished):
pref.accept()
assert get_settings().appearance.theme == 'light'
def test_preferences_dialog_ok(qtbot, pref):
with qtbot.waitSignal(pref.finished):
pref._button_ok.click()
assert get_settings().appearance.theme == 'light'
def test_preferences_dialog_close(qtbot, pref):
with qtbot.waitSignal(pref.finished):
pref.close()
assert get_settings().appearance.theme == 'light'
def test_preferences_dialog_escape(qtbot, pref):
with qtbot.waitSignal(pref.finished):
qtbot.keyPress(pref, Qt.Key_Escape)
assert get_settings().appearance.theme == 'light'
def test_preferences_dialog_cancel(qtbot, pref):
with qtbot.waitSignal(pref.finished):
pref._button_cancel.click()
assert get_settings().appearance.theme == 'dark'
def test_preferences_dialog_restore(qtbot, pref, monkeypatch):
assert get_settings().appearance.theme == 'light'
monkeypatch.setattr(
QMessageBox, 'question', lambda *a: QMessageBox.RestoreDefaults
)
pref._restore_default_dialog()
assert get_settings().appearance.theme == 'dark'
napari-0.5.0a1/napari/_qt/dialogs/_tests/test_qt_modal.py 0000664 0000000 0000000 00000003721 14370413656 0023415 0 ustar 00root root 0000000 0000000 from unittest.mock import MagicMock
import pytest
from qtpy.QtCore import Qt
from qtpy.QtWidgets import QMainWindow, QWidget
from napari._qt.dialogs.qt_modal import QtPopup
class TestQtPopup:
def test_show_above(self, qtbot):
popup = QtPopup(None)
qtbot.addWidget(popup)
popup.show_above_mouse()
popup.close()
def test_show_right(self, qtbot):
popup = QtPopup(None)
qtbot.addWidget(popup)
popup.show_right_of_mouse()
popup.close()
def test_move_to_error_no_parent(self, qtbot):
popup = QtPopup(None)
qtbot.add_widget(popup)
with pytest.raises(ValueError):
popup.move_to()
@pytest.mark.parametrize("pos", ["top", "bottom", "left", "right"])
def test_move_to(self, pos, qtbot):
window = QMainWindow()
qtbot.addWidget(window)
widget = QWidget()
window.setCentralWidget(widget)
popup = QtPopup(widget)
popup.move_to(pos)
def test_move_to_error_wrong_params(self, qtbot):
window = QMainWindow()
qtbot.addWidget(window)
widget = QWidget()
window.setCentralWidget(widget)
popup = QtPopup(widget)
with pytest.raises(ValueError):
popup.move_to("dummy_text")
with pytest.raises(ValueError):
popup.move_to({})
@pytest.mark.parametrize("pos", [[10, 10, 10, 10], (15, 10, 10, 10)])
def test_move_to_cords(self, pos, qtbot):
window = QMainWindow()
qtbot.addWidget(window)
widget = QWidget()
window.setCentralWidget(widget)
popup = QtPopup(widget)
popup.move_to(pos)
def test_click(self, qtbot, monkeypatch):
popup = QtPopup(None)
monkeypatch.setattr(popup, "close", MagicMock())
qtbot.addWidget(popup)
qtbot.keyClick(popup, Qt.Key_8)
popup.close.assert_not_called()
qtbot.keyClick(popup, Qt.Key_Return)
popup.close.assert_called_once()
napari-0.5.0a1/napari/_qt/dialogs/_tests/test_qt_plugin_dialog.py 0000664 0000000 0000000 00000011731 14370413656 0025136 0 ustar 00root root 0000000 0000000 from typing import Generator, Optional, Tuple
import pytest
from npe2 import PackageMetadata
from napari._qt.dialogs import qt_plugin_dialog
def _iter_napari_hub_or_pypi_plugin_info(
conda_forge: bool = True,
) -> Generator[Tuple[Optional[PackageMetadata], bool], None, None]:
"""Mock the hub and pypi methods to collect available plugins.
This will mock `napari.plugins.hub.iter_hub_plugin_info` for napari-hub,
and `napari.plugins.pypi.iter_napari_plugin_info` for pypi.
It will return two fake plugins that will populate the available plugins
list (the bottom one). The first plugin will not be available on
conda-forge so will be greyed out ("test-name-0"). The second plugin will
be available on conda-forge so will be enabled ("test-name-1").
"""
# This mock `base_data`` will be the same for both fake plugins.
base_data = {
"metadata_version": "1.0",
"version": "0.1.0",
"summary": "some test package",
"home_page": "http://napari.org",
"author": "test author",
"license": "UNKNOWN",
}
for i in range(2):
yield PackageMetadata(name=f"test-name-{i}", **base_data), bool(i)
@pytest.fixture
def plugin_dialog(qtbot, monkeypatch):
"""Fixture that provides a plugin dialog for a normal napari install."""
for method_name in ["iter_hub_plugin_info", "iter_napari_plugin_info"]:
monkeypatch.setattr(
qt_plugin_dialog,
method_name,
_iter_napari_hub_or_pypi_plugin_info,
)
# This is patching `napari.utils.misc.running_as_constructor_app` function
# to mock a normal napari install.
monkeypatch.setattr(
qt_plugin_dialog,
"running_as_constructor_app",
lambda: False,
)
widget = qt_plugin_dialog.QtPluginDialog()
widget.show()
qtbot.wait(300)
qtbot.add_widget(widget)
return widget
@pytest.fixture
def plugin_dialog_constructor(qtbot, monkeypatch):
"""
Fixture that provides a plugin dialog for a constructor based install.
"""
for method_name in ["iter_hub_plugin_info", "iter_napari_plugin_info"]:
monkeypatch.setattr(
qt_plugin_dialog,
method_name,
_iter_napari_hub_or_pypi_plugin_info,
)
# This is patching `napari.utils.misc.running_as_constructor_app` function
# to mock a constructor based install.
monkeypatch.setattr(
qt_plugin_dialog,
"running_as_constructor_app",
lambda: True,
)
widget = qt_plugin_dialog.QtPluginDialog()
widget.show()
qtbot.wait(300)
qtbot.add_widget(widget)
return widget
def test_filter_not_available_plugins(plugin_dialog_constructor):
"""
Check that the plugins listed under available plugins are
enabled and disabled accordingly.
The first plugin ("test-name-0") is not available on conda-forge and
should be disabled, and show a tooltip warning.
The second plugin ("test-name-1") is available on conda-forge and
should be enabled without the tooltip warning.
"""
item = plugin_dialog_constructor.available_list.item(0)
widget = plugin_dialog_constructor.available_list.itemWidget(item)
if widget:
assert not widget.action_button.isEnabled()
assert widget.warning_tooltip.isVisible()
item = plugin_dialog_constructor.available_list.item(1)
widget = plugin_dialog_constructor.available_list.itemWidget(item)
assert widget.action_button.isEnabled()
assert not widget.warning_tooltip.isVisible()
def test_filter_available_plugins(plugin_dialog):
"""
Test the dialog is correctly filtering plugins in the available plugins
list (the bottom one).
"""
plugin_dialog.filter("")
assert plugin_dialog.available_list.count() == 2
assert plugin_dialog.available_list._count_visible() == 2
plugin_dialog.filter("no-match@123")
assert plugin_dialog.available_list._count_visible() == 0
plugin_dialog.filter("")
plugin_dialog.filter("test-name-0")
assert plugin_dialog.available_list._count_visible() == 1
def test_filter_installed_plugins(plugin_dialog):
"""
Test the dialog is correctly filtering plugins in the installed plugins
list (the top one).
"""
plugin_dialog.filter("")
assert plugin_dialog.installed_list._count_visible() >= 0
plugin_dialog.filter("no-match@123")
assert plugin_dialog.installed_list._count_visible() == 0
def test_visible_widgets(plugin_dialog):
"""
Test that the direct entry button and textbox are visible for
normal napari installs.
"""
assert plugin_dialog.direct_entry_edit.isVisible()
assert plugin_dialog.direct_entry_btn.isVisible()
def test_constructor_visible_widgets(plugin_dialog_constructor):
"""
Test that the direct entry button and textbox are hidden for
constructor based napari installs.
"""
assert not plugin_dialog_constructor.direct_entry_edit.isVisible()
assert not plugin_dialog_constructor.direct_entry_btn.isVisible()
napari-0.5.0a1/napari/_qt/dialogs/_tests/test_qt_plugin_report.py 0000664 0000000 0000000 00000004115 14370413656 0025210 0 ustar 00root root 0000000 0000000 import webbrowser
import pytest
from napari_plugin_engine import PluginError
from qtpy.QtCore import Qt
from qtpy.QtGui import QGuiApplication
from napari._qt.dialogs import qt_plugin_report
# qtbot fixture comes from pytest-qt
# test_plugin_manager fixture is provided by napari_plugin_engine._testsupport
# monkeypatch fixture is from pytest
def test_error_reporter(qtbot, monkeypatch):
"""test that QtPluginErrReporter shows any instantiated PluginErrors."""
monkeypatch.setattr(
qt_plugin_report,
'standard_metadata',
lambda x: {'url': 'https://github.com/example/example'},
)
error_message = 'my special error'
try:
# we need to raise to make sure a __traceback__ is attached to the error.
raise PluginError(
error_message, plugin_name='test_plugin', plugin="mock"
)
except PluginError:
pass
report_widget = qt_plugin_report.QtPluginErrReporter()
qtbot.addWidget(report_widget)
# the null option plus the one we created
assert report_widget.plugin_combo.count() >= 2
# the message should appear somewhere in the text area
report_widget.set_plugin('test_plugin')
assert error_message in report_widget.text_area.toPlainText()
# mock_webbrowser_open
def mock_webbrowser_open(url, new=0):
assert new == 2
assert "Errors for plugin 'test_plugin'" in url
assert "Traceback from napari" in url
monkeypatch.setattr(webbrowser, 'open', mock_webbrowser_open)
qtbot.mouseClick(report_widget.github_button, Qt.LeftButton)
# make sure we can copy traceback to clipboard
report_widget.copyToClipboard()
clipboard_text = QGuiApplication.clipboard().text()
assert "Errors for plugin 'test_plugin'" in clipboard_text
# plugins without errors raise an error
with pytest.raises(ValueError):
report_widget.set_plugin('non_existent')
report_widget.set_plugin(None)
assert not report_widget.text_area.toPlainText()
def test_dialog_create(qtbot):
dialog = qt_plugin_report.QtPluginErrReporter()
qtbot.addWidget(dialog)
napari-0.5.0a1/napari/_qt/dialogs/_tests/test_reader_dialog.py 0000664 0000000 0000000 00000011363 14370413656 0024377 0 ustar 00root root 0000000 0000000 import os
import numpy as np
import pytest
from npe2 import DynamicPlugin
from qtpy.QtWidgets import QLabel, QRadioButton
from napari._qt.dialogs.qt_reader_dialog import (
QtReaderDialog,
open_with_dialog_choices,
prepare_remaining_readers,
)
from napari.errors.reader_errors import ReaderPluginError
from napari.settings import get_settings
@pytest.fixture
def reader_dialog(qtbot):
def _reader_dialog(**kwargs):
widget = QtReaderDialog(**kwargs)
widget.show()
qtbot.addWidget(widget)
return widget
return _reader_dialog
def test_reader_dialog_buttons(reader_dialog):
widg = reader_dialog(
readers={'display name': 'plugin-name', 'display 2': 'plugin2'}
)
assert len(widg.findChildren(QRadioButton)) == 2
def test_reader_defaults(reader_dialog, tmpdir):
file_pth = tmpdir.join('my_file.tif')
widg = reader_dialog(pth=file_pth, readers={'p1': 'p1', 'p2': 'p2'})
assert widg.findChild(QLabel).text().startswith('Choose reader')
assert widg._get_plugin_choice() == 'p1'
assert widg.persist_checkbox.isChecked()
def test_reader_with_error_message(reader_dialog):
widg = reader_dialog(error_message='Test Error')
assert widg.findChild(QLabel).text().startswith('Test Error')
def test_reader_dir_with_extension(tmpdir, reader_dialog):
dir = tmpdir.mkdir('my_dir.zarr')
widg = reader_dialog(pth=dir, readers={'p1': 'p1', 'p2': 'p2'})
assert hasattr(widg, 'persist_checkbox')
assert (
widg.persist_checkbox.text()
== "Remember this choice for files with a .zarr extension"
)
def test_reader_dir(tmpdir, reader_dialog):
dir = tmpdir.mkdir('my_dir')
widg = reader_dialog(pth=dir, readers={'p1': 'p1', 'p2': 'p2'})
assert (
widg._persist_text
== f'Remember this choice for folders labeled as {dir}{os.sep}.'
)
def test_get_plugin_choice(tmpdir, reader_dialog):
file_pth = tmpdir.join('my_file.tif')
widg = reader_dialog(pth=file_pth, readers={'p1': 'p1', 'p2': 'p2'})
reader_btns = widg.reader_btn_group.buttons()
reader_btns[1].toggle()
assert widg._get_plugin_choice() == 'p2'
reader_btns[0].toggle()
assert widg._get_plugin_choice() == 'p1'
def test_get_persist_choice(tmpdir, reader_dialog):
file_pth = tmpdir.join('my_file.tif')
widg = reader_dialog(pth=file_pth, readers={'p1': 'p1', 'p2': 'p2'})
assert widg._get_persist_choice()
widg.persist_checkbox.toggle()
assert not widg._get_persist_choice()
def test_prepare_dialog_options_no_readers():
with pytest.raises(ReaderPluginError) as e:
prepare_remaining_readers(
['my-file.fake'], 'fake-reader', RuntimeError('Reading failed')
)
assert 'Tried to read my-file.fake with plugin fake-reader' in str(e.value)
def test_prepare_dialog_options_multiple_plugins(builtins):
pth = 'my-file.tif'
readers = prepare_remaining_readers(
[pth],
None,
RuntimeError(f'Multiple plugins found capable of reading {pth}'),
)
assert builtins.name in readers
def test_prepare_dialog_options_removes_plugin(tmp_plugin: DynamicPlugin):
tmp2 = tmp_plugin.spawn(register=True)
@tmp_plugin.contribute.reader(filename_patterns=['*.fake'])
def _(path):
...
@tmp2.contribute.reader(filename_patterns=['*.fake'])
def _(path):
...
readers = prepare_remaining_readers(
['my-file.fake'],
tmp_plugin.name,
RuntimeError('Reader failed'),
)
assert tmp2.name in readers
assert tmp_plugin.name not in readers
def test_open_with_dialog_choices_persist(
builtins, make_napari_viewer, tmp_path
):
pth = tmp_path / 'my-file.npy'
np.save(pth, np.random.random((10, 10)))
viewer = make_napari_viewer()
open_with_dialog_choices(
display_name=builtins.display_name,
persist=True,
extension='.npy',
readers={builtins.name: builtins.display_name},
paths=[str(pth)],
stack=False,
qt_viewer=viewer.window._qt_viewer,
)
assert len(viewer.layers) == 1
# make sure extension was saved with *
assert get_settings().plugins.extension2reader['*.npy'] == builtins.name
def test_open_with_dialog_choices_raises(make_napari_viewer):
viewer = make_napari_viewer()
get_settings().plugins.extension2reader = {}
with pytest.raises(ValueError):
open_with_dialog_choices(
display_name='Fake Plugin',
persist=True,
extension='.fake',
readers={'fake-plugin': 'Fake Plugin'},
paths=['my-file.fake'],
stack=False,
qt_viewer=viewer.window._qt_viewer,
)
# settings weren't saved because reading failed
assert not get_settings().plugins.extension2reader
napari-0.5.0a1/napari/_qt/dialogs/confirm_close_dialog.py 0000664 0000000 0000000 00000005063 14370413656 0023417 0 ustar 00root root 0000000 0000000 from qtpy.QtGui import QKeySequence
from qtpy.QtWidgets import (
QCheckBox,
QDialog,
QHBoxLayout,
QLabel,
QPushButton,
QVBoxLayout,
QWidget,
)
from napari.settings import get_settings
from napari.utils.translations import trans
class ConfirmCloseDialog(QDialog):
def __init__(self, parent, close_app=False) -> None:
super().__init__(parent)
cancel_btn = QPushButton(trans._("Cancel"))
close_btn = QPushButton(trans._("Close"))
close_btn.setObjectName("warning_icon_btn")
icon_label = QWidget()
self.do_not_ask = QCheckBox(trans._("Do not ask in future"))
if close_app:
self.setWindowTitle(trans._('Close Application?'))
text = trans._(
"Do you want to close the application? ('{shortcut}' to confirm). This will close all Qt Windows in this process",
shortcut=QKeySequence('Ctrl+Q').toString(
QKeySequence.NativeText
),
)
close_btn.setObjectName("error_icon_btn")
close_btn.setShortcut(QKeySequence('Ctrl+Q'))
icon_label.setObjectName("error_icon_element")
else:
self.setWindowTitle(trans._('Close Window?'))
text = trans._(
"Confirm to close window (or press '{shortcut}')",
shortcut=QKeySequence('Ctrl+W').toString(
QKeySequence.NativeText
),
)
close_btn.setObjectName("warning_icon_btn")
close_btn.setShortcut(QKeySequence('Ctrl+W'))
icon_label.setObjectName("warning_icon_element")
cancel_btn.clicked.connect(self.reject)
close_btn.clicked.connect(self.accept)
layout = QVBoxLayout()
layout2 = QHBoxLayout()
layout2.addWidget(icon_label)
layout3 = QVBoxLayout()
layout3.addWidget(QLabel(text))
layout3.addWidget(self.do_not_ask)
layout2.addLayout(layout3)
layout4 = QHBoxLayout()
layout4.addStretch(1)
layout4.addWidget(cancel_btn)
layout4.addWidget(close_btn)
layout.addLayout(layout2)
layout.addLayout(layout4)
self.setLayout(layout)
# for test purposes because of problem with shortcut testing:
# https://github.com/pytest-dev/pytest-qt/issues/254
self.close_btn = close_btn
self.cancel_btn = cancel_btn
def accept(self):
if self.do_not_ask.isChecked():
get_settings().application.confirm_close_window = False
super().accept()
napari-0.5.0a1/napari/_qt/dialogs/preferences_dialog.py 0000664 0000000 0000000 00000020232 14370413656 0023071 0 ustar 00root root 0000000 0000000 import json
from enum import EnumMeta
from typing import TYPE_CHECKING, Tuple, cast
from pydantic.main import BaseModel
from qtpy.QtCore import QSize, Qt, Signal
from qtpy.QtWidgets import (
QDialog,
QHBoxLayout,
QListWidget,
QMessageBox,
QPushButton,
QStackedWidget,
QVBoxLayout,
)
from napari.utils.translations import trans
if TYPE_CHECKING:
from pydantic.fields import ModelField
from qtpy.QtGui import QCloseEvent, QKeyEvent
class PreferencesDialog(QDialog):
"""Preferences Dialog for Napari user settings."""
ui_schema = {
"call_order": {"ui:widget": "plugins"},
"highlight_thickness": {"ui:widget": "highlight"},
"shortcuts": {"ui:widget": "shortcuts"},
"extension2reader": {"ui:widget": "extension2reader"},
}
resized = Signal(QSize)
def __init__(self, parent=None) -> None:
from napari.settings import get_settings
super().__init__(parent)
self.setWindowTitle(trans._("Preferences"))
self._settings = get_settings()
self._stack = QStackedWidget(self)
self._list = QListWidget(self)
self._list.setObjectName("Preferences")
self._list.currentRowChanged.connect(self._stack.setCurrentIndex)
# Set up buttons
self._button_cancel = QPushButton(trans._("Cancel"))
self._button_cancel.clicked.connect(self.reject)
self._button_ok = QPushButton(trans._("OK"))
self._button_ok.clicked.connect(self.accept)
self._button_ok.setDefault(True)
self._button_restore = QPushButton(trans._("Restore defaults"))
self._button_restore.clicked.connect(self._restore_default_dialog)
# Layout
left_layout = QVBoxLayout()
left_layout.addWidget(self._list)
left_layout.addStretch()
left_layout.addWidget(self._button_restore)
left_layout.addWidget(self._button_cancel)
left_layout.addWidget(self._button_ok)
self.setLayout(QHBoxLayout())
self.layout().addLayout(left_layout, 1)
self.layout().addWidget(self._stack, 3)
# Build dialog from settings
self._rebuild_dialog()
def keyPressEvent(self, e: 'QKeyEvent'):
if e.key() == Qt.Key.Key_Escape:
# escape key should just close the window
# which implies "accept"
e.accept()
self.accept()
return
super().keyPressEvent(e)
def resizeEvent(self, event):
"""Override to emit signal."""
self.resized.emit(event.size())
super().resizeEvent(event)
def _rebuild_dialog(self):
"""Removes settings not to be exposed to user and creates dialog pages."""
# FIXME: this dialog should not need to know about the plugin manager
from napari.plugins import plugin_manager
self._starting_pm_order = plugin_manager.call_order()
self._starting_values = self._settings.dict(exclude={'schema_version'})
self._list.clear()
while self._stack.count():
self._stack.removeWidget(self._stack.currentWidget())
for field in self._settings.__fields__.values():
if isinstance(field.type_, type) and issubclass(
field.type_, BaseModel
):
self._add_page(field)
self._list.setCurrentRow(0)
def _add_page(self, field: 'ModelField'):
"""Builds the preferences widget using the json schema builder.
Parameters
----------
field : ModelField
subfield for which to create a page.
"""
from napari._vendor.qt_json_builder.qt_jsonschema_form import (
WidgetBuilder,
)
schema, values = self._get_page_dict(field)
name = field.field_info.title or field.name
form = WidgetBuilder().create_form(schema, self.ui_schema)
# set state values for widget
form.widget.state = values
# make settings follow state of the form widget
form.widget.on_changed.connect(
lambda d: getattr(self._settings, name.lower()).update(d)
)
# need to disable async if octree is enabled.
# TODO: this shouldn't live here... if there is a coupling/dependency
# between these settings, it should be declared in the settings schema
if (
name.lower() == 'experimental'
and values['octree']
and self._settings.env_settings()
.get('experimental', {})
.get('async_')
not in (None, '0')
):
form_layout = form.widget.layout()
for i in range(form_layout.count()):
wdg = form_layout.itemAt(i, form_layout.FieldRole).widget()
if wdg._name == 'async_':
wdg.opacity.setOpacity(0.3)
wdg.setDisabled(True)
break
self._list.addItem(field.field_info.title or field.name)
self._stack.addWidget(form)
def _get_page_dict(self, field: 'ModelField') -> Tuple[dict, dict]:
"""Provides the schema, set of values for each setting, and the
properties for each setting."""
ftype = cast('BaseModel', field.type_)
# TODO make custom shortcuts dialog to properly capture new
# functionality once we switch to app-model's keybinding system
# then we can remove the below code used for autogeneration
if field.name == 'shortcuts':
# hardcode workaround because pydantic's schema generation
# does not allow you to specify custom JSON serialization
schema = {
"title": "ShortcutsSettings",
"type": "object",
"properties": {
"shortcuts": {
"title": "shortcuts",
"description": "Set keyboard shortcuts for actions.",
"type": "object",
}
},
}
else:
schema = json.loads(ftype.schema_json())
# find enums:
for name, subfield in ftype.__fields__.items():
if isinstance(subfield.type_, EnumMeta):
enums = [s.value for s in subfield.type_] # type: ignore
schema["properties"][name]["enum"] = enums
schema["properties"][name]["type"] = "string"
# Need to remove certain properties that will not be displayed on the GUI
setting = getattr(self._settings, field.name)
with setting.enums_as_values():
values = setting.dict()
napari_config = getattr(setting, "NapariConfig", None)
if hasattr(napari_config, 'preferences_exclude'):
for val in napari_config.preferences_exclude:
schema['properties'].pop(val, None)
values.pop(val, None)
return schema, values
def _restore_default_dialog(self):
"""Launches dialog to confirm restore settings choice."""
response = QMessageBox.question(
self,
trans._("Restore Settings"),
trans._("Are you sure you want to restore default settings?"),
QMessageBox.RestoreDefaults | QMessageBox.Cancel,
QMessageBox.RestoreDefaults,
)
if response == QMessageBox.RestoreDefaults:
self._settings.reset()
self._rebuild_dialog() # TODO: do we need this?
def _restart_required_dialog(self):
"""Displays the dialog informing user a restart is required."""
QMessageBox.information(
self,
trans._("Restart required"),
trans._(
"A restart is required for some new settings to have an effect."
),
)
def closeEvent(self, event: 'QCloseEvent') -> None:
event.accept()
self.accept()
def reject(self):
"""Restores the settings in place when dialog was launched."""
self._settings.update(self._starting_values)
# FIXME: this dialog should not need to know about the plugin manager
if self._starting_pm_order:
from napari.plugins import plugin_manager
plugin_manager.set_call_order(self._starting_pm_order)
super().reject()
napari-0.5.0a1/napari/_qt/dialogs/qt_about.py 0000664 0000000 0000000 00000010731 14370413656 0021072 0 ustar 00root root 0000000 0000000 from qtpy import QtGui
from qtpy.QtCore import Qt
from qtpy.QtWidgets import (
QDialog,
QHBoxLayout,
QLabel,
QPushButton,
QTextEdit,
QVBoxLayout,
)
from napari.utils import citation_text, sys_info
from napari.utils.translations import trans
class QtAbout(QDialog):
"""Qt dialog window for displaying 'About napari' information.
Parameters
----------
parent : QWidget, optional
Parent of the dialog, to correctly inherit and apply theme.
Default is None.
Attributes
----------
citationCopyButton : napari._qt.qt_about.QtCopyToClipboardButton
Button to copy citation information to the clipboard.
citationTextBox : qtpy.QtWidgets.QTextEdit
Text box containing napari citation information.
citation_layout : qtpy.QtWidgets.QHBoxLayout
Layout widget for napari citation information.
infoCopyButton : napari._qt.qt_about.QtCopyToClipboardButton
Button to copy napari version information to the clipboard.
info_layout : qtpy.QtWidgets.QHBoxLayout
Layout widget for napari version information.
infoTextBox : qtpy.QtWidgets.QTextEdit
Text box containing napari version information.
layout : qtpy.QtWidgets.QVBoxLayout
Layout widget for the entire 'About napari' dialog.
"""
def __init__(self, parent=None) -> None:
super().__init__(parent)
self.layout = QVBoxLayout()
# Description
title_label = QLabel(
trans._(
"napari: a multi-dimensional image viewer for python"
)
)
title_label.setTextInteractionFlags(
Qt.TextInteractionFlag.TextSelectableByMouse
)
self.layout.addWidget(title_label)
# Add information
self.infoTextBox = QTextEdit()
self.infoTextBox.setTextInteractionFlags(
Qt.TextInteractionFlag.TextSelectableByMouse
)
self.infoTextBox.setLineWrapMode(QTextEdit.NoWrap)
# Add text copy button
self.infoCopyButton = QtCopyToClipboardButton(self.infoTextBox)
self.info_layout = QHBoxLayout()
self.info_layout.addWidget(self.infoTextBox, 1)
self.info_layout.addWidget(
self.infoCopyButton, 0, Qt.AlignmentFlag.AlignTop
)
self.info_layout.setAlignment(Qt.AlignmentFlag.AlignTop)
self.layout.addLayout(self.info_layout)
self.infoTextBox.setText(sys_info(as_html=True))
self.infoTextBox.setMinimumSize(
int(self.infoTextBox.document().size().width() + 19),
int(min(self.infoTextBox.document().size().height() + 10, 500)),
)
self.layout.addWidget(QLabel(trans._('citation information:')))
self.citationTextBox = QTextEdit(citation_text)
self.citationTextBox.setFixedHeight(64)
self.citationCopyButton = QtCopyToClipboardButton(self.citationTextBox)
self.citation_layout = QHBoxLayout()
self.citation_layout.addWidget(self.citationTextBox, 1)
self.citation_layout.addWidget(
self.citationCopyButton, 0, Qt.AlignmentFlag.AlignTop
)
self.layout.addLayout(self.citation_layout)
self.setLayout(self.layout)
@staticmethod
def showAbout(parent=None):
"""Display the 'About napari' dialog box.
Parameters
----------
parent : QWidget, optional
Parent of the dialog, to correctly inherit and apply theme.
Default is None.
"""
d = QtAbout(parent)
d.setObjectName('QtAbout')
d.setWindowTitle(trans._('About'))
d.setWindowModality(Qt.WindowModality.ApplicationModal)
d.exec_()
class QtCopyToClipboardButton(QPushButton):
"""Button to copy text box information to the clipboard.
Parameters
----------
text_edit : qtpy.QtWidgets.QTextEdit
The text box contents linked to copy to clipboard button.
Attributes
----------
text_edit : qtpy.QtWidgets.QTextEdit
The text box contents linked to copy to clipboard button.
"""
def __init__(self, text_edit) -> None:
super().__init__()
self.setObjectName("QtCopyToClipboardButton")
self.text_edit = text_edit
self.setToolTip(trans._("Copy to clipboard"))
self.clicked.connect(self.copyToClipboard)
def copyToClipboard(self):
"""Copy text to the clipboard."""
cb = QtGui.QGuiApplication.clipboard()
cb.setText(str(self.text_edit.toPlainText()))
napari-0.5.0a1/napari/_qt/dialogs/qt_activity_dialog.py 0000664 0000000 0000000 00000024671 14370413656 0023143 0 ustar 00root root 0000000 0000000 from pathlib import Path
from qtpy.QtCore import QPoint, QSize, Qt
from qtpy.QtGui import QMovie
from qtpy.QtWidgets import (
QApplication,
QDialog,
QFrame,
QGraphicsOpacityEffect,
QHBoxLayout,
QLabel,
QScrollArea,
QSizePolicy,
QToolButton,
QVBoxLayout,
QWidget,
)
import napari.resources
from napari._qt.widgets.qt_progress_bar import (
QtLabeledProgressBar,
QtProgressBarGroup,
)
from napari.utils.progress import progress
from napari.utils.translations import trans
class ActivityToggleItem(QWidget):
"""Toggle button for Activity Dialog.
A progress indicator is displayed when there are active progress
bars.
"""
def __init__(self, parent=None) -> None:
super().__init__(parent=parent)
self.setLayout(QHBoxLayout())
self._activityBtn = QToolButton()
self._activityBtn.setObjectName("QtActivityButton")
self._activityBtn.setToolButtonStyle(
Qt.ToolButtonStyle.ToolButtonTextBesideIcon
)
self._activityBtn.setArrowType(Qt.ArrowType.UpArrow)
self._activityBtn.setIconSize(QSize(11, 11))
self._activityBtn.setText(trans._('activity'))
self._activityBtn.setCheckable(True)
self._inProgressIndicator = QLabel(trans._("in progress..."), self)
sp = self._inProgressIndicator.sizePolicy()
sp.setRetainSizeWhenHidden(True)
self._inProgressIndicator.setSizePolicy(sp)
load_gif = str(Path(napari.resources.__file__).parent / "loading.gif")
mov = QMovie(load_gif)
mov.setScaledSize(QSize(18, 18))
self._inProgressIndicator.setMovie(mov)
self._inProgressIndicator.hide()
self.layout().addWidget(self._inProgressIndicator)
self.layout().addWidget(self._activityBtn)
self.layout().setContentsMargins(0, 0, 0, 0)
class QtActivityDialog(QDialog):
"""Activity Dialog for Napari progress bars."""
MIN_WIDTH = 250
MIN_HEIGHT = 185
def __init__(self, parent=None, toggle_button=None) -> None:
super().__init__(parent)
self._toggleButton = toggle_button
self.setObjectName('Activity')
self.setMinimumWidth(self.MIN_WIDTH)
self.setMinimumHeight(self.MIN_HEIGHT)
self.setMaximumHeight(self.MIN_HEIGHT)
self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
self.setWindowFlags(
Qt.WindowType.SubWindow | Qt.WindowType.WindowStaysOnTopHint
)
self.setModal(False)
opacityEffect = QGraphicsOpacityEffect(self)
opacityEffect.setOpacity(0.8)
self.setGraphicsEffect(opacityEffect)
self._baseWidget = QWidget()
self._activityLayout = QVBoxLayout()
self._activityLayout.addStretch()
self._baseWidget.setLayout(self._activityLayout)
self._baseWidget.layout().setContentsMargins(0, 0, 0, 0)
self._scrollArea = QScrollArea()
self._scrollArea.setWidgetResizable(True)
self._scrollArea.setWidget(self._baseWidget)
self._titleBar = QLabel()
title = QLabel('activity', self)
title.setObjectName('QtCustomTitleLabel')
title.setSizePolicy(
QSizePolicy(QSizePolicy.Policy.Maximum, QSizePolicy.Policy.Maximum)
)
line = QFrame(self)
line.setObjectName("QtCustomTitleBarLine")
titleLayout = QHBoxLayout()
titleLayout.setSpacing(4)
titleLayout.setContentsMargins(8, 1, 8, 0)
line.setFixedHeight(1)
titleLayout.addWidget(line)
titleLayout.addWidget(title)
self._titleBar.setLayout(titleLayout)
self._baseLayout = QVBoxLayout()
self._baseLayout.addWidget(self._titleBar)
self._baseLayout.addWidget(self._scrollArea)
self.setLayout(self._baseLayout)
self.resize(520, self.MIN_HEIGHT)
self.move_to_bottom_right()
# TODO: what do we do with any existing progress objects in action?
# connect callback to handle new progress objects being added/removed
progress._all_instances.events.changed.connect(
self.handle_progress_change
)
def handle_progress_change(self, event):
"""Handle addition and/or removal of new progress objects
Parameters
----------
event : Event
EventedSet `changed` event with `added` and `removed` objects
"""
for prog in event.removed:
self.close_progress_bar(prog)
for prog in event.added:
self.make_new_pbar(prog)
def make_new_pbar(self, prog):
"""Make new `QtLabeledProgressBar` for this `progress` object and add to viewer.
Parameters
----------
prog : progress
progress object to associated with new progress bar
"""
prog.gui = True
prog.leave = False
# make and add progress bar
pbar = QtLabeledProgressBar(prog=prog)
self.add_progress_bar(pbar, nest_under=prog.nest_under)
# connect progress object events to updating progress bar
prog.events.value.connect(pbar._set_value)
prog.events.description.connect(pbar._set_description)
prog.events.overflow.connect(pbar._make_indeterminate)
prog.events.eta.connect(pbar._set_eta)
prog.events.total.connect(pbar._set_total)
# connect pbar close method if we're closed
self.destroyed.connect(prog.close)
# set its range etc. based on progress object
if prog.total is not None:
pbar.setRange(prog.n, prog.total)
pbar.setValue(prog.n)
else:
pbar.setRange(0, 0)
prog.total = 0
pbar.setDescription(prog.desc)
def add_progress_bar(self, pbar, nest_under=None):
"""Add progress bar to activity_dialog,in QtProgressBarGroup if needed.
Check if pbar needs nesting and create QtProgressBarGroup, removing
existing separators and creating new ones. Show and start
inProgressIndicator to highlight the existence of a progress bar
in the dock even when the dock is hidden.
Parameters
----------
pbar : QtLabeledProgressBar
progress bar to add to activity dialog
nest_under : Optional[progress]
parent `progress` whose QtLabeledProgressBar we need to nest under
"""
if nest_under is None:
self._activityLayout.addWidget(pbar)
else:
# TODO: can parent be non gui pbar?
parent_pbar = self.get_pbar_from_prog(nest_under)
current_pbars = [parent_pbar, pbar]
remove_separators(current_pbars)
parent_widg = parent_pbar.parent()
# if we are already in a group, add pbar to existing group
if isinstance(parent_widg, QtProgressBarGroup):
nested_layout = parent_widg.layout()
# create QtProgressBarGroup for this pbar
else:
new_group = QtProgressBarGroup(parent_pbar)
new_group.destroyed.connect(self.maybe_hide_progress_indicator)
nested_layout = new_group.layout()
self._activityLayout.addWidget(new_group)
# progress bar needs to go before separator
new_pbar_index = nested_layout.count() - 1
nested_layout.insertWidget(new_pbar_index, pbar)
# show progress indicator and start gif
self._toggleButton._inProgressIndicator.movie().start()
self._toggleButton._inProgressIndicator.show()
pbar.destroyed.connect(self.maybe_hide_progress_indicator)
QApplication.processEvents()
def get_pbar_from_prog(self, prog):
"""Given prog `progress` object, find associated `QtLabeledProgressBar`
Parameters
----------
prog : progress
progress object with associated progress bar
Returns
-------
QtLabeledProgressBar
QtLabeledProgressBar widget associated with this progress object
"""
if pbars := self._baseWidget.findChildren(QtLabeledProgressBar):
for potential_parent in pbars:
if potential_parent.progress is prog:
return potential_parent
def close_progress_bar(self, prog):
"""Close `QtLabeledProgressBar` and parent `QtProgressBarGroup` if needed
Parameters
----------
prog : progress
progress object whose QtLabeledProgressBar to close
"""
current_pbar = self.get_pbar_from_prog(prog)
if not current_pbar:
return
parent_widget = current_pbar.parent()
current_pbar.close()
current_pbar.deleteLater()
if isinstance(parent_widget, QtProgressBarGroup):
pbar_children = [
child
for child in parent_widget.children()
if isinstance(child, QtLabeledProgressBar)
]
# only close group if it has no visible progress bars
if not any(child.isVisible() for child in pbar_children):
parent_widget.close()
def move_to_bottom_right(self, offset=(8, 8)):
"""Position widget at the bottom right edge of the parent."""
if not self.parent():
return
sz = self.parent().size() - self.size() - QSize(*offset)
self.move(QPoint(sz.width(), sz.height()))
def maybe_hide_progress_indicator(self):
"""Hide progress indicator when all progress bars have finished."""
pbars = self._baseWidget.findChildren(QtLabeledProgressBar)
pbar_groups = self._baseWidget.findChildren(QtProgressBarGroup)
progress_visible = any(pbar.isVisible() for pbar in pbars)
progress_group_visible = any(
pbar_group.isVisible() for pbar_group in pbar_groups
)
if not progress_visible and not progress_group_visible:
self._toggleButton._inProgressIndicator.movie().stop()
self._toggleButton._inProgressIndicator.hide()
def remove_separators(current_pbars):
"""Remove any existing line separators from current_pbars
as they will get a separator from the group
Parameters
----------
current_pbars : List[QtLabeledProgressBar]
parent and new progress bar to remove separators from
"""
for current_pbar in current_pbars:
if line_widg := current_pbar.findChild(QFrame, "QtCustomTitleBarLine"):
current_pbar.layout().removeWidget(line_widg)
line_widg.hide()
line_widg.deleteLater()
napari-0.5.0a1/napari/_qt/dialogs/qt_modal.py 0000664 0000000 0000000 00000013310 14370413656 0021050 0 ustar 00root root 0000000 0000000 from qtpy.QtCore import QPoint, QRect, Qt
from qtpy.QtGui import QCursor, QGuiApplication
from qtpy.QtWidgets import QDialog, QFrame, QVBoxLayout
from napari.utils.translations import trans
class QtPopup(QDialog):
"""A generic popup window.
The seemingly extra frame here is to allow rounded corners on a truly
transparent background. New items should be added to QtPopup.frame
+----------------------------------
| Dialog
| +-------------------------------
| | QVBoxLayout
| | +----------------------------
| | | QFrame
| | | +-------------------------
| | | |
| | | | (add a new layout here)
Parameters
----------
parent : qtpy.QtWidgets:QWidget
Parent widget of the popup dialog box.
Attributes
----------
frame : qtpy.QtWidgets.QFrame
Frame of the popup dialog box.
"""
def __init__(self, parent) -> None:
super().__init__(parent)
self.setObjectName("QtModalPopup")
self.setModal(False) # if False, then clicking anywhere else closes it
self.setWindowFlags(Qt.Popup | Qt.FramelessWindowHint)
self.setLayout(QVBoxLayout())
self.frame = QFrame()
self.frame.setObjectName("QtPopupFrame")
self.layout().addWidget(self.frame)
self.layout().setContentsMargins(0, 0, 0, 0)
def show_above_mouse(self, *args):
"""Show popup dialog above the mouse cursor position."""
pos = QCursor().pos() # mouse position
szhint = self.sizeHint()
pos -= QPoint(szhint.width() // 2, szhint.height() + 14)
self.move(pos)
self.show()
def show_right_of_mouse(self, *args):
pos = QCursor().pos() # mouse position
szhint = self.sizeHint()
pos -= QPoint(-14, szhint.height() // 4)
self.move(pos)
self.show()
def move_to(self, position='top', *, win_ratio=0.9, min_length=0):
"""Move popup to a position relative to the QMainWindow.
Parameters
----------
position : {str, tuple}, optional
position in the QMainWindow to show the pop, by default 'top'
if str: must be one of {'top', 'bottom', 'left', 'right' }
if tuple: must be length 4 with (left, top, width, height)
win_ratio : float, optional
Fraction of the width (for position = top/bottom) or height (for
position = left/right) of the QMainWindow that the popup will
occupy. Only valid when isinstance(position, str).
by default 0.9
min_length : int, optional
Minimum size of the long dimension (width for top/bottom or
height fort left/right).
Raises
------
ValueError
if position is a string and not one of
{'top', 'bottom', 'left', 'right' }
"""
if isinstance(position, str):
window = self.parent().window() if self.parent() else None
if not window:
raise ValueError(
trans._(
"Specifying position as a string is only possible if the popup has a parent",
deferred=True,
)
)
left = window.pos().x()
top = window.pos().y()
if position in ('top', 'bottom'):
width = int(window.width() * win_ratio)
width = max(width, min_length)
left += (window.width() - width) // 2
height = self.sizeHint().height()
top += (
24
if position == 'top'
else (window.height() - height - 12)
)
elif position in ('left', 'right'):
height = int(window.height() * win_ratio)
height = max(height, min_length)
# 22 is for the title bar
top += 22 + (window.height() - height) // 2
width = self.sizeHint().width()
left += (
12 if position == 'left' else (window.width() - width - 12)
)
else:
raise ValueError(
trans._(
'position must be one of ["top", "left", "bottom", "right"]',
deferred=True,
)
)
elif isinstance(position, (tuple, list)):
assert len(position) == 4, '`position` argument must have length 4'
left, top, width, height = position
else:
raise ValueError(
trans._(
"Wrong type of position {position}",
deferred=True,
position=position,
)
)
# necessary for transparent round corners
self.resize(self.sizeHint())
# make sure the popup is completely on the screen
# In Qt ≥5.10 we can use screenAt to know which monitor the mouse is on
screen_geometry: QRect = QGuiApplication.screenAt(
QCursor.pos()
).geometry()
left = max(
min(screen_geometry.right() - width, left), screen_geometry.left()
)
top = max(
min(screen_geometry.bottom() - height, top), screen_geometry.top()
)
self.setGeometry(left, top, width, height)
def keyPressEvent(self, event):
"""Close window on return, else pass event through to super class.
Parameters
----------
event : qtpy.QtCore.QEvent
Event from the Qt context.
"""
if event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter):
self.close()
return
super().keyPressEvent(event)
napari-0.5.0a1/napari/_qt/dialogs/qt_notification.py 0000664 0000000 0000000 00000036641 14370413656 0022456 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import Callable, Optional, Sequence, Tuple, Union
from qtpy.QtCore import (
QEasingCurve,
QPoint,
QPropertyAnimation,
QRect,
QSize,
Qt,
QTimer,
)
from qtpy.QtWidgets import (
QApplication,
QDialog,
QGraphicsOpacityEffect,
QHBoxLayout,
QLabel,
QPushButton,
QSizePolicy,
QTextEdit,
QVBoxLayout,
QWidget,
)
from superqt import QElidingLabel, ensure_main_thread
from napari._qt.code_syntax_highlight import Pylighter
from napari._qt.qt_resources import QColoredSVGIcon
from napari.settings import get_settings
from napari.utils.notifications import Notification, NotificationSeverity
from napari.utils.theme import get_theme
from napari.utils.translations import trans
ActionSequence = Sequence[Tuple[str, Callable[['NapariQtNotification'], None]]]
class NapariQtNotification(QDialog):
"""Notification dialog frame, appears at the bottom right of the canvas.
By default, only the first line of the notification is shown, and the text
is elided. Double-clicking on the text (or clicking the chevron icon) will
expand to show the full notification. The dialog will autmatically
disappear in ``DISMISS_AFTER`` milliseconds, unless hovered or clicked.
Parameters
----------
message : str
The message that will appear in the notification
severity : str or NotificationSeverity, optional
Severity level {'error', 'warning', 'info', 'none'}. Will determine
the icon associated with the message.
by default NotificationSeverity.WARNING.
source : str, optional
A source string for the notifcation (intended to show the module and
or package responsible for the notification), by default None
actions : list of tuple, optional
A sequence of 2-tuples, where each tuple is a string and a callable.
Each tuple will be used to create button in the dialog, where the text
on the button is determine by the first item in the tuple, and a
callback function to call when the button is pressed is the second item
in the tuple. by default ()
"""
MAX_OPACITY = 0.9
FADE_IN_RATE = 220
FADE_OUT_RATE = 120
DISMISS_AFTER = 4000
MIN_WIDTH = 400
MIN_EXPANSION = 18
message: QElidingLabel
source_label: QLabel
severity_icon: QLabel
def __init__(
self,
message: str,
severity: Union[str, NotificationSeverity] = 'WARNING',
source: Optional[str] = None,
actions: ActionSequence = (),
parent=None,
) -> None:
super().__init__(parent=parent)
if parent and hasattr(parent, 'resized'):
parent.resized.connect(self.move_to_bottom_right)
self.setupUi()
self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
self.setup_buttons(actions)
self.setMouseTracking(True)
self._update_icon(str(severity))
self.message.setText(message)
if source:
self.source_label.setText(
trans._('Source: {source}', source=source)
)
self.close_button.clicked.connect(self.close)
self.expand_button.clicked.connect(self.toggle_expansion)
self.timer = QTimer()
self.opacity = QGraphicsOpacityEffect()
self.setGraphicsEffect(self.opacity)
self.opacity_anim = QPropertyAnimation(self.opacity, b"opacity", self)
self.geom_anim = QPropertyAnimation(self, b"geometry", self)
self.move_to_bottom_right()
def _update_icon(self, severity: str):
"""Update the icon to match the severity level."""
from napari.settings import get_settings
from napari.utils.theme import get_theme
settings = get_settings()
theme = settings.appearance.theme
default_color = get_theme(theme, False).icon
# FIXME: Should these be defined at the theme level?
# Currently there is a warning one
colors = {
'error': "#D85E38",
'warning': "#E3B617",
'info': default_color,
'debug': default_color,
'none': default_color,
}
color = colors.get(severity, default_color)
icon = QColoredSVGIcon.from_resources(severity)
self.severity_icon.setPixmap(icon.colored(color=color).pixmap(15, 15))
def move_to_bottom_right(self, offset=(8, 8)):
"""Position widget at the bottom right edge of the parent."""
if not self.parent():
return
sz = self.parent().size() - self.size() - QSize(*offset)
self.move(QPoint(sz.width(), sz.height()))
def slide_in(self):
"""Run animation that fades in the dialog with a slight slide up."""
geom = self.geometry()
self.geom_anim.setDuration(self.FADE_IN_RATE)
self.geom_anim.setStartValue(geom.translated(0, 20))
self.geom_anim.setEndValue(geom)
self.geom_anim.setEasingCurve(QEasingCurve.OutQuad)
# fade in
self.opacity_anim.setDuration(self.FADE_IN_RATE)
self.opacity_anim.setStartValue(0)
self.opacity_anim.setEndValue(self.MAX_OPACITY)
self.geom_anim.start()
self.opacity_anim.start()
def show(self):
"""Show the message with a fade and slight slide in from the bottom."""
super().show()
self.slide_in()
if self.DISMISS_AFTER > 0:
self.timer.setInterval(self.DISMISS_AFTER)
self.timer.setSingleShot(True)
self.timer.timeout.connect(self.close_with_fade)
self.timer.start()
def mouseMoveEvent(self, event):
"""On hover, stop the self-destruct timer"""
self.timer.stop()
def mouseDoubleClickEvent(self, event):
"""Expand the notification on double click."""
self.toggle_expansion()
def close(self):
self.timer.stop()
self.opacity_anim.stop()
self.geom_anim.stop()
super().close()
def close_with_fade(self):
"""Fade out then close."""
self.timer.stop()
self.opacity_anim.stop()
self.geom_anim.stop()
self.opacity_anim.setDuration(self.FADE_OUT_RATE)
self.opacity_anim.setStartValue(self.MAX_OPACITY)
self.opacity_anim.setEndValue(0)
self.opacity_anim.start()
self.opacity_anim.finished.connect(self.close)
def deleteLater(self) -> None:
"""stop all animations and timers before deleting"""
self.opacity_anim.stop()
self.geom_anim.stop()
self.timer.stop()
super().deleteLater()
def toggle_expansion(self):
"""Toggle the expanded state of the notification frame."""
self.contract() if self.property('expanded') else self.expand()
self.timer.stop()
def expand(self):
"""Expanded the notification so that the full message is visible."""
curr = self.geometry()
self.geom_anim.setDuration(100)
self.geom_anim.setStartValue(curr)
new_height = self.sizeHint().height()
if new_height < curr.height():
# new height would shift notification down, ensure some expansion
new_height = curr.height() + self.MIN_EXPANSION
delta = new_height - curr.height()
self.geom_anim.setEndValue(
QRect(curr.x(), curr.y() - delta, curr.width(), new_height)
)
self.geom_anim.setEasingCurve(QEasingCurve.OutQuad)
self.geom_anim.start()
self.setProperty('expanded', True)
self.style().unpolish(self.expand_button)
self.style().polish(self.expand_button)
def contract(self):
"""Contract notification to a single elided line of the message."""
geom = self.geometry()
self.geom_anim.setDuration(100)
self.geom_anim.setStartValue(geom)
dlt = geom.height() - self.minimumHeight()
self.geom_anim.setEndValue(
QRect(geom.x(), geom.y() + dlt, geom.width(), geom.height() - dlt)
)
self.geom_anim.setEasingCurve(QEasingCurve.OutQuad)
self.geom_anim.start()
self.setProperty('expanded', False)
self.style().unpolish(self.expand_button)
self.style().polish(self.expand_button)
def setupUi(self):
"""Set up the UI during initialization."""
self.setWindowFlags(Qt.WindowType.SubWindow)
self.setMinimumWidth(self.MIN_WIDTH)
self.setMaximumWidth(self.MIN_WIDTH)
self.setMinimumHeight(40)
self.setSizeGripEnabled(False)
self.setModal(False)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setContentsMargins(2, 2, 2, 2)
self.verticalLayout.setSpacing(0)
self.row1_widget = QWidget(self)
self.row1 = QHBoxLayout(self.row1_widget)
self.row1.setContentsMargins(12, 12, 12, 8)
self.row1.setSpacing(4)
self.severity_icon = QLabel(self.row1_widget)
self.severity_icon.setObjectName("severity_icon")
self.severity_icon.setMinimumWidth(30)
self.severity_icon.setMaximumWidth(30)
self.row1.addWidget(
self.severity_icon, alignment=Qt.AlignmentFlag.AlignTop
)
self.message = QElidingLabel()
self.message.setWordWrap(True)
self.message.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.message.setMinimumWidth(self.MIN_WIDTH - 200)
self.message.setSizePolicy(
QSizePolicy.Expanding, QSizePolicy.Expanding
)
self.row1.addWidget(self.message, alignment=Qt.AlignmentFlag.AlignTop)
self.expand_button = QPushButton(self.row1_widget)
self.expand_button.setObjectName("expand_button")
self.expand_button.setCursor(Qt.PointingHandCursor)
self.expand_button.setMaximumWidth(20)
self.expand_button.setFlat(True)
self.row1.addWidget(
self.expand_button, alignment=Qt.AlignmentFlag.AlignTop
)
self.close_button = QPushButton(self.row1_widget)
self.close_button.setObjectName("close_button")
self.close_button.setCursor(Qt.PointingHandCursor)
self.close_button.setMaximumWidth(20)
self.close_button.setFlat(True)
self.row1.addWidget(
self.close_button, alignment=Qt.AlignmentFlag.AlignTop
)
self.verticalLayout.addWidget(self.row1_widget, 1)
self.row2_widget = QWidget(self)
self.row2_widget.hide()
self.row2 = QHBoxLayout(self.row2_widget)
self.source_label = QLabel(self.row2_widget)
self.source_label.setObjectName("source_label")
self.row2.addWidget(
self.source_label, alignment=Qt.AlignmentFlag.AlignBottom
)
self.row2.addStretch()
self.row2.setContentsMargins(12, 2, 16, 12)
self.row2_widget.setMaximumHeight(34)
self.row2_widget.setStyleSheet(
'QPushButton{'
'padding: 4px 12px 4px 12px; '
'font-size: 11px;'
'min-height: 18px; border-radius: 0;}'
)
self.verticalLayout.addWidget(self.row2_widget, 0)
self.setProperty('expanded', False)
self.resize(self.MIN_WIDTH, 40)
def setup_buttons(self, actions: ActionSequence = ()):
"""Add buttons to the dialog.
Parameters
----------
actions : tuple, optional
A sequence of 2-tuples, where each tuple is a string and a
callable. Each tuple will be used to create button in the dialog,
where the text on the button is determine by the first item in the
tuple, and a callback function to call when the button is pressed
is the second item in the tuple. by default ()
"""
if isinstance(actions, dict):
actions = list(actions.items())
for text, callback in actions:
btn = QPushButton(text)
def call_back_with_self(callback_, self):
"""
We need a higher order function this to capture the reference to self.
"""
def _inner():
return callback_(self)
return _inner
btn.clicked.connect(call_back_with_self(callback, self))
btn.clicked.connect(self.close_with_fade)
self.row2.addWidget(btn)
if actions:
self.row2_widget.show()
self.setMinimumHeight(
self.row2_widget.maximumHeight() + self.minimumHeight()
)
def sizeHint(self):
"""Return the size required to show the entire message."""
return QSize(
super().sizeHint().width(),
self.row2_widget.height() + self.message.sizeHint().height(),
)
@classmethod
def from_notification(
cls, notification: Notification, parent: QWidget = None
) -> NapariQtNotification:
from napari.utils.notifications import ErrorNotification
if isinstance(notification, ErrorNotification):
def show_tb(notification_dialog):
tbdialog = TracebackDialog(
notification, notification_dialog.parent()
)
tbdialog.show()
actions = tuple(notification.actions) + (
(trans._('View Traceback'), show_tb),
)
else:
actions = notification.actions
return cls(
message=notification.message,
severity=notification.severity,
source=notification.source,
actions=actions,
parent=parent,
)
@classmethod
@ensure_main_thread
def show_notification(cls, notification: Notification):
from napari._qt.qt_main_window import _QtMainWindow
from napari.settings import get_settings
settings = get_settings()
# after https://github.com/napari/napari/issues/2370,
# the os.getenv can be removed (and NAPARI_CATCH_ERRORS retired)
if (
notification.severity
>= settings.application.gui_notification_level
and _QtMainWindow.current()
):
canvas = _QtMainWindow.current()._qt_viewer._welcome_widget
cls.from_notification(notification, canvas).show()
def _debug_tb(tb):
import pdb
from napari._qt.utils import event_hook_removed
QApplication.processEvents()
QApplication.processEvents()
with event_hook_removed():
print("Entering debugger. Type 'q' to return to napari.\n")
pdb.post_mortem(tb)
print("\nDebugging finished. Napari active again.")
class TracebackDialog(QDialog):
def __init__(self, exception, parent=None) -> None:
super().__init__(parent=parent)
self.exception = exception
self.setModal(True)
self.setLayout(QVBoxLayout())
self.resize(650, 270)
text = QTextEdit()
theme = get_theme(get_settings().appearance.theme, as_dict=False)
_highlight = Pylighter( # noqa: F841
text.document(), "python", theme.syntax_style
)
text.setText(exception.as_text())
text.setReadOnly(True)
self.btn = QPushButton(trans._('Enter Debugger'))
self.btn.clicked.connect(self._enter_debug_mode)
self.layout().addWidget(text)
self.layout().addWidget(self.btn, 0, Qt.AlignmentFlag.AlignRight)
def _enter_debug_mode(self):
self.btn.setText(
trans._(
'Now Debugging. Please quit debugger in console to continue'
)
)
_debug_tb(self.exception.__traceback__)
self.btn.setText(trans._('Enter Debugger'))
napari-0.5.0a1/napari/_qt/dialogs/qt_package_installer.py 0000664 0000000 0000000 00000040654 14370413656 0023437 0 ustar 00root root 0000000 0000000 """
A tool-agnostic installation logic for the plugin manager.
The main object is `InstallerQueue`, a `QProcess` subclass
with the notion of a job queue. The queued jobs are represented
by a `deque` of `*InstallerTool` dataclasses that contain the
executable path, arguments and environment modifications.
Available actions for each tool are `install`, `uninstall`
and `cancel`.
"""
import atexit
import contextlib
import os
import sys
from collections import deque
from dataclasses import dataclass
from enum import auto
from functools import lru_cache
from logging import getLogger
from pathlib import Path
from subprocess import call
from tempfile import gettempdir, mkstemp
from typing import Deque, Optional, Sequence, Tuple
from npe2 import PluginManager
from qtpy.QtCore import QObject, QProcess, QProcessEnvironment, Signal
from qtpy.QtWidgets import QTextEdit
from napari._version import version as _napari_version
from napari._version import version_tuple as _napari_version_tuple
from napari.plugins import plugin_manager
from napari.plugins.pypi import _user_agent
from napari.utils._appdirs import user_plugin_dir, user_site_packages
from napari.utils.misc import StringEnum, running_as_bundled_app
from napari.utils.translations import trans
JobId = int
log = getLogger(__name__)
class InstallerActions(StringEnum):
"Available actions for the plugin manager"
INSTALL = auto()
UNINSTALL = auto()
CANCEL = auto()
class InstallerTools(StringEnum):
"Available tools for InstallerQueue jobs"
CONDA = auto()
PIP = auto()
@dataclass(frozen=True)
class AbstractInstallerTool:
action: InstallerActions
pkgs: Tuple[str, ...]
origins: Tuple[str, ...] = ()
prefix: Optional[str] = None
@property
def ident(self):
return hash((self.action, *self.pkgs, *self.origins, self.prefix))
# abstract method
@classmethod
def executable(cls):
"Path to the executable that will run the task"
raise NotImplementedError()
# abstract method
def arguments(self):
"Arguments supplied to the executable"
raise NotImplementedError()
# abstract method
def environment(
self, env: QProcessEnvironment = None
) -> QProcessEnvironment:
"Changes needed in the environment variables."
raise NotImplementedError()
@staticmethod
def constraints() -> Sequence[str]:
"""
Version constraints to limit unwanted changes in installation.
"""
return [f"napari=={_napari_version}"]
@classmethod
def available(cls) -> bool:
"""
Check if the tool is available by performing a little test
"""
raise NotImplementedError()
class PipInstallerTool(AbstractInstallerTool):
@classmethod
def executable(cls):
return str(_get_python_exe())
@classmethod
def available(cls):
return call([cls.executable(), "-m", "pip", "--version"]) == 0
def arguments(self) -> Tuple[str, ...]:
args = ['-m', 'pip']
if self.action == InstallerActions.INSTALL:
args += ['install', '--upgrade', '-c', self._constraints_file()]
for origin in self.origins:
args += ['--extra-index-url', origin]
elif self.action == InstallerActions.UNINSTALL:
args += ['uninstall', '-y']
else:
raise ValueError(f"Action '{self.action}' not supported!")
if 10 <= log.getEffectiveLevel() < 30: # DEBUG level
args.append('-vvv')
if self.prefix is not None:
args.extend(['--prefix', str(self.prefix)])
elif running_as_bundled_app(
check_conda=False
) and sys.platform.startswith('linux'):
args += [
'--no-warn-script-location',
'--prefix',
user_plugin_dir(),
]
return (*args, *self.pkgs)
def environment(
self, env: QProcessEnvironment = None
) -> QProcessEnvironment:
if env is None:
env = QProcessEnvironment.systemEnvironment()
combined_paths = os.pathsep.join(
[
user_site_packages(),
env.systemEnvironment().value("PYTHONPATH"),
]
)
env.insert("PYTHONPATH", combined_paths)
env.insert("PIP_USER_AGENT_USER_DATA", _user_agent())
return env
@classmethod
@lru_cache(maxsize=0)
def _constraints_file(cls) -> str:
_, path = mkstemp("-napari-constraints.txt", text=True)
with open(path, "w") as f:
f.write("\n".join(cls.constraints()))
atexit.register(os.unlink, path)
return path
class CondaInstallerTool(AbstractInstallerTool):
@classmethod
def executable(cls):
bat = ".bat" if os.name == "nt" else ""
for path in (
Path(os.environ.get('MAMBA_EXE', '')),
Path(os.environ.get('CONDA_EXE', '')),
# $CONDA is usually only available on GitHub Actions
Path(os.environ.get('CONDA', '')) / 'condabin' / f'conda{bat}',
):
if path.is_file():
return str(path)
return f'conda{bat}' # cross our fingers 'conda' is in PATH
@classmethod
def available(cls):
executable = cls.executable()
try:
return call([executable, "--version"]) == 0
except FileNotFoundError: # pragma: no cover
return False
def arguments(self) -> Tuple[str, ...]:
prefix = self.prefix or self._default_prefix()
args = [self.action.value, '-y', '--prefix', prefix]
args.append('--override-channels')
for channel in (*self.origins, *self._default_channels()):
args.extend(["-c", channel])
return (*args, *self.pkgs)
def environment(
self, env: QProcessEnvironment = None
) -> QProcessEnvironment:
if env is None:
env = QProcessEnvironment.systemEnvironment()
self._add_constraints_to_env(env)
if 10 <= log.getEffectiveLevel() < 30: # DEBUG level
env.insert('CONDA_VERBOSITY', '3')
if os.name == "nt":
if not env.contains("TEMP"):
temp = gettempdir()
env.insert("TMP", temp)
env.insert("TEMP", temp)
if not env.contains("USERPROFILE"):
env.insert("HOME", os.path.expanduser("~"))
env.insert("USERPROFILE", os.path.expanduser("~"))
return env
@staticmethod
def constraints() -> Sequence[str]:
# FIXME
# dev or rc versions might not be available in public channels
# but only installed locally - if we try to pin those, mamba
# will fail to pin it because there's no record of that version
# in the remote index, only locally; to work around this bug
# we will have to pin to e.g. 0.4.* instead of 0.4.17.* for now
version_lower = _napari_version.lower()
is_dev = "rc" in version_lower or "dev" in version_lower
pin_level = 2 if is_dev else 3
version = ".".join([str(x) for x in _napari_version_tuple[:pin_level]])
return [f"napari={version}"]
def _add_constraints_to_env(
self, env: QProcessEnvironment
) -> QProcessEnvironment:
PINNED = 'CONDA_PINNED_PACKAGES'
constraints = self.constraints()
if env.contains(PINNED):
constraints.append(env.value(PINNED))
env.insert(PINNED, "&".join(constraints))
return env
def _default_channels(self):
return ('conda-forge',)
def _default_prefix(self):
if (Path(sys.prefix) / "conda-meta").is_dir():
return sys.prefix
raise ValueError("Prefix has not been specified!")
class InstallerQueue(QProcess):
"""Queue for installation and uninstallation tasks in the plugin manager."""
# emitted when all jobs are finished
# not to be confused with finished, which is emitted when each job is finished
allFinished = Signal()
def __init__(self, parent: Optional[QObject] = None) -> None:
super().__init__(parent)
self._queue: Deque[AbstractInstallerTool] = deque()
self._output_widget = None
self.setProcessChannelMode(QProcess.MergedChannels)
self.readyReadStandardOutput.connect(self._on_stdout_ready)
self.readyReadStandardError.connect(self._on_stderr_ready)
self.finished.connect(self._on_process_finished)
self.errorOccurred.connect(self._on_error_occurred)
# -------------------------- Public API ------------------------------
def install(
self,
tool: InstallerTools,
pkgs: Sequence[str],
*,
prefix: Optional[str] = None,
origins: Sequence[str] = (),
**kwargs,
) -> JobId:
"""Install packages in `pkgs` into `prefix` using `tool` with additional
`origins` as source for `pkgs`.
Parameters
----------
tool : InstallerTools
Which type of installation tool to use.
pkgs : Sequence[str]
List of packages to install.
prefix : Optional[str], optional
Optional prefix to install packages into.
origins : Optional[Sequence[str]], optional
Additional sources for packages to be downloaded from.
Returns
-------
JobId : int
ID that can be used to cancel the process.
"""
item = self._build_queue_item(
tool=tool,
action=InstallerActions.INSTALL,
pkgs=pkgs,
prefix=prefix,
origins=origins,
**kwargs,
)
return self._queue_item(item)
def uninstall(
self,
tool: InstallerTools,
pkgs: Sequence[str],
*,
prefix: Optional[str] = None,
**kwargs,
) -> JobId:
"""Uninstall packages in `pkgs` from `prefix` using `tool`.
Parameters
----------
tool : InstallerTools
Which type of installation tool to use.
pkgs : Sequence[str]
List of packages to uninstall.
prefix : Optional[str], optional
Optional prefix from which to uninstall packages.
Returns
-------
JobId : int
ID that can be used to cancel the process.
"""
item = self._build_queue_item(
tool=tool,
action=InstallerActions.UNINSTALL,
pkgs=pkgs,
prefix=prefix,
**kwargs,
)
return self._queue_item(item)
def cancel(self, job_id: Optional[JobId] = None):
"""Cancel `job_id` if it is running.
Parameters
----------
job_id : Optional[JobId], optional
Job ID to cancel. If not provided, cancel all jobs.
"""
if job_id is None:
# cancel all jobs
self._queue.clear()
self._end_process()
return
for i, item in enumerate(self._queue):
if item.ident == job_id:
if i == 0: # first in queue, currently running
self._end_process()
else: # still pending, just remove from queue
self._queue.remove(item)
return
msg = f"No job with id {job_id}. Current queue:\n - "
msg += "\n - ".join(
[
f"{item.ident} -> {item.executable()} {item.arguments()}"
for item in self._queue
]
)
raise ValueError(msg)
def waitForFinished(self, msecs: int = 10000) -> bool:
"""Block and wait for all jobs to finish.
Parameters
----------
msecs : int, optional
Time to wait, by default 10000
"""
while self.hasJobs():
super().waitForFinished(msecs)
return True
def hasJobs(self) -> bool:
"""True if there are jobs remaining in the queue."""
return bool(self._queue)
def set_output_widget(self, output_widget: QTextEdit):
if output_widget:
self._output_widget = output_widget
# -------------------------- Private methods ------------------------------
def _log(self, msg: str):
log.debug(msg)
if self._output_widget:
self._output_widget.append(msg)
def _get_tool(self, tool: InstallerTools):
if tool == InstallerTools.PIP:
return PipInstallerTool
if tool == InstallerTools.CONDA:
return CondaInstallerTool
raise ValueError(f"InstallerTool {tool} not recognized!")
def _build_queue_item(
self,
tool: InstallerTools,
action: InstallerActions,
pkgs: Sequence[str],
prefix: Optional[str] = None,
origins: Sequence[str] = (),
**kwargs,
) -> AbstractInstallerTool:
return self._get_tool(tool)(
pkgs=pkgs, action=action, origins=origins, prefix=prefix, **kwargs
)
def _queue_item(self, item: AbstractInstallerTool) -> JobId:
self._queue.append(item)
self._process_queue()
return item.ident
def _process_queue(self):
if not self._queue:
self.allFinished.emit()
return
tool = self._queue[0]
self.setProgram(str(tool.executable()))
self.setProcessEnvironment(tool.environment())
self.setArguments([str(arg) for arg in tool.arguments()])
# this might throw a warning because the same process
# was already running but it's ok
self._log(
trans._(
"Starting '{program}' with args {args}",
program=self.program(),
args=self.arguments(),
)
)
self.start()
def _end_process(self):
if os.name == 'nt':
# TODO: this might be too agressive and won't allow rollbacks!
# investigate whether we can also do .terminate()
self.kill()
else:
self.terminate()
if self._output_widget:
self._output_widget.append(
trans._("\nTask was cancelled by the user.")
)
def _on_process_finished(
self, exit_code: int, exit_status: QProcess.ExitStatus
):
try:
current = self._queue[0]
except IndexError:
current = None
if (
current
and current.action == InstallerActions.UNINSTALL
and exit_status == QProcess.ExitStatus.NormalExit
and exit_code == 0
):
pm2 = PluginManager.instance()
npe1_plugins = set(plugin_manager.iter_available())
for pkg in current.pkgs:
if pkg in pm2:
pm2.unregister(pkg)
elif pkg in npe1_plugins:
plugin_manager.unregister(pkg)
else:
log.warning(
'Cannot unregister %s, not a known napari plugin.', pkg
)
self._on_process_done(exit_code=exit_code, exit_status=exit_status)
def _on_error_occurred(self, error: QProcess.ProcessError):
self._on_process_done(error=error)
def _on_process_done(
self,
exit_code: Optional[int] = None,
exit_status: Optional[QProcess.ExitStatus] = None,
error: Optional[QProcess.ProcessError] = None,
):
with contextlib.suppress(IndexError):
self._queue.popleft()
if error:
msg = trans._(
"Task finished with errors! Error: {error}.", error=error
)
else:
msg = trans._(
"Task finished with exit code {exit_code} with status {exit_status}.",
exit_code=exit_code,
exit_status=exit_status,
)
self._log(msg)
self._process_queue()
def _on_stdout_ready(self):
text = self.readAllStandardOutput().data().decode()
if text:
self._log(text)
def _on_stderr_ready(self):
text = self.readAllStandardError().data().decode()
if text:
self._log(text)
def _get_python_exe():
# Note: is_bundled_app() returns False even if using a Briefcase bundle...
# Workaround: see if sys.executable is set to something something napari on Mac
if sys.executable.endswith("napari") and sys.platform == 'darwin':
# sys.prefix should be /Contents/Resources/Support/Python/Resources
if (python := Path(sys.prefix) / "bin" / "python3").is_file():
return str(python)
return sys.executable
napari-0.5.0a1/napari/_qt/dialogs/qt_plugin_dialog.py 0000664 0000000 0000000 00000072302 14370413656 0022577 0 ustar 00root root 0000000 0000000 import os
from enum import Enum, auto
from functools import partial
from importlib.metadata import PackageNotFoundError, metadata
from pathlib import Path
from typing import Optional, Sequence, Tuple
from npe2 import PackageMetadata, PluginManager
from qtpy.QtCore import QEvent, QPoint, QSize, Qt, Slot
from qtpy.QtGui import QFont, QMovie
from qtpy.QtWidgets import (
QCheckBox,
QDialog,
QFrame,
QHBoxLayout,
QLabel,
QLineEdit,
QListWidget,
QListWidgetItem,
QPushButton,
QSizePolicy,
QSplitter,
QTextEdit,
QVBoxLayout,
QWidget,
)
from superqt import QElidingLabel
import napari.resources
from napari._qt.dialogs.qt_package_installer import (
InstallerActions,
InstallerQueue,
InstallerTools,
)
from napari._qt.qt_resources import QColoredSVGIcon
from napari._qt.qthreading import create_worker
from napari._qt.widgets.qt_message_popup import WarnPopup
from napari._qt.widgets.qt_tooltip import QtToolTipLabel
from napari.plugins import plugin_manager
from napari.plugins.hub import iter_hub_plugin_info
from napari.plugins.pypi import iter_napari_plugin_info
from napari.plugins.utils import normalized_name
from napari.settings import get_settings
from napari.utils.misc import (
parse_version,
running_as_bundled_app,
running_as_constructor_app,
)
from napari.utils.translations import trans
class PluginListItem(QFrame):
def __init__(
self,
package_name: str,
version: str = '',
url: str = '',
summary: str = '',
author: str = '',
license: str = "UNKNOWN",
*,
plugin_name: str = None,
parent: QWidget = None,
enabled: bool = True,
installed: bool = False,
npe_version=1,
) -> None:
super().__init__(parent)
self.setup_ui(enabled)
self.plugin_name.setText(package_name)
self.package_name.setText(version)
self.summary.setText(summary)
self.package_author.setText(author)
self.cancel_btn.setVisible(False)
self.help_button.setText(trans._("Website"))
self.help_button.setObjectName("help_button")
self._handle_npe2_plugin(npe_version)
if installed:
self.enabled_checkbox.show()
self.action_button.setText(trans._("uninstall"))
self.action_button.setObjectName("remove_button")
else:
self.enabled_checkbox.hide()
self.action_button.setText(trans._("install"))
self.action_button.setObjectName("install_button")
def _handle_npe2_plugin(self, npe_version):
if npe_version in (None, 1):
return
opacity = 0.4 if npe_version == 'shim' else 1
lbl = trans._('npe1 (adapted)') if npe_version == 'shim' else 'npe2'
npe2_icon = QLabel(self)
icon = QColoredSVGIcon.from_resources('logo_silhouette')
npe2_icon.setPixmap(
icon.colored(color='#33F0FF', opacity=opacity).pixmap(20, 20)
)
self.row1.insertWidget(2, QLabel(lbl))
self.row1.insertWidget(2, npe2_icon)
def _get_dialog(self) -> QDialog:
p = self.parent()
while not isinstance(p, QDialog) and p.parent():
p = p.parent()
return p
def set_busy(self, text: str, update: bool = False):
self.item_status.setText(text)
self.cancel_btn.setVisible(True)
if not update:
self.action_button.setVisible(False)
else:
self.update_btn.setVisible(False)
def setup_ui(self, enabled=True):
self.v_lay = QVBoxLayout(self)
self.v_lay.setContentsMargins(-1, 6, -1, 6)
self.v_lay.setSpacing(0)
self.row1 = QHBoxLayout()
self.row1.setSpacing(6)
self.enabled_checkbox = QCheckBox(self)
self.enabled_checkbox.setChecked(enabled)
self.enabled_checkbox.stateChanged.connect(self._on_enabled_checkbox)
self.enabled_checkbox.setToolTip(trans._("enable/disable"))
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.enabled_checkbox.sizePolicy().hasHeightForWidth()
)
self.enabled_checkbox.setSizePolicy(sizePolicy)
self.enabled_checkbox.setMinimumSize(QSize(20, 0))
self.enabled_checkbox.setText("")
self.row1.addWidget(self.enabled_checkbox)
self.plugin_name = QLabel(self)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.plugin_name.sizePolicy().hasHeightForWidth()
)
self.plugin_name.setSizePolicy(sizePolicy)
font15 = QFont()
font15.setPointSize(15)
self.plugin_name.setFont(font15)
self.row1.addWidget(self.plugin_name)
icon = QColoredSVGIcon.from_resources("warning")
self.warning_tooltip = QtToolTipLabel(self)
# TODO: This color should come from the theme but the theme needs
# to provide the right color. Default warning should be orange, not
# red. Code example:
# theme_name = get_settings().appearance.theme
# napari.utils.theme.get_theme(theme_name, as_dict=False).warning.as_hex()
self.warning_tooltip.setPixmap(
icon.colored(color="#E3B617").pixmap(15, 15)
)
self.warning_tooltip.setVisible(False)
self.row1.addWidget(self.warning_tooltip)
self.item_status = QLabel(self)
self.item_status.setObjectName("small_italic_text")
self.item_status.setSizePolicy(sizePolicy)
self.row1.addWidget(self.item_status)
self.row1.addStretch()
self.package_name = QLabel(self)
self.package_name.setAlignment(
Qt.AlignmentFlag.AlignRight
| Qt.AlignmentFlag.AlignTrailing
| Qt.AlignmentFlag.AlignVCenter
)
self.row1.addWidget(self.package_name)
self.cancel_btn = QPushButton("cancel", self)
self.cancel_btn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.cancel_btn.setObjectName("remove_button")
self.row1.addWidget(self.cancel_btn)
self.update_btn = QPushButton(self)
self.update_btn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.update_btn.setObjectName("install_button")
self.row1.addWidget(self.update_btn)
self.update_btn.setVisible(False)
self.help_button = QPushButton(self)
self.action_button = QPushButton(self)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.action_button.sizePolicy().hasHeightForWidth()
)
self.help_button.setSizePolicy(sizePolicy)
self.action_button.setSizePolicy(sizePolicy)
self.row1.addWidget(self.help_button)
self.row1.addWidget(self.action_button)
self.v_lay.addLayout(self.row1)
self.row2 = QHBoxLayout()
self.error_indicator = QPushButton()
self.error_indicator.setObjectName("warning_icon")
self.error_indicator.setCursor(Qt.CursorShape.PointingHandCursor)
self.error_indicator.hide()
self.row2.addWidget(self.error_indicator)
self.row2.setContentsMargins(-1, 4, 0, -1)
self.summary = QElidingLabel(parent=self)
sizePolicy = QSizePolicy(
QSizePolicy.MinimumExpanding, QSizePolicy.Preferred
)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.summary.sizePolicy().hasHeightForWidth()
)
self.summary.setSizePolicy(sizePolicy)
self.summary.setObjectName("small_text")
self.row2.addWidget(self.summary)
self.package_author = QLabel(self)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.package_author.sizePolicy().hasHeightForWidth()
)
self.package_author.setSizePolicy(sizePolicy)
self.package_author.setObjectName("small_text")
self.row2.addWidget(self.package_author)
self.v_lay.addLayout(self.row2)
def _on_enabled_checkbox(self, state: int):
"""Called with `state` when checkbox is clicked."""
enabled = bool(state)
plugin_name = self.plugin_name.text()
pm2 = PluginManager.instance()
if plugin_name in pm2:
pm2.enable(plugin_name) if state else pm2.disable(plugin_name)
return
for npe1_name, _, distname in plugin_manager.iter_available():
if distname and (normalized_name(distname) == plugin_name):
plugin_manager.set_blocked(npe1_name, not enabled)
def show_warning(self, message: str = ""):
"""Show warning icon and tooltip."""
self.warning_tooltip.setVisible(bool(message))
self.warning_tooltip.setToolTip(message)
class QPluginList(QListWidget):
def __init__(self, parent: QWidget, installer: InstallerQueue) -> None:
super().__init__(parent)
self.installer = installer
self.setSortingEnabled(True)
self._remove_list = []
def _count_visible(self) -> int:
"""Return the number of visible items.
Visible items are the result of the normal `count` method minus
any hidden items.
"""
hidden = 0
count = self.count()
for i in range(count):
item = self.item(i)
hidden += item.isHidden()
return count - hidden
@Slot(PackageMetadata)
def addItem(
self,
project_info: PackageMetadata,
installed=False,
plugin_name=None,
enabled=True,
npe_version=None,
):
pkg_name = project_info.name
# don't add duplicates
if (
self.findItems(pkg_name, Qt.MatchFlag.MatchFixedString)
and not plugin_name
):
return
# including summary here for sake of filtering below.
searchable_text = f"{pkg_name} {project_info.summary}"
item = QListWidgetItem(searchable_text, self)
item.version = project_info.version
super().addItem(item)
widg = PluginListItem(
package_name=pkg_name,
version=project_info.version,
url=project_info.home_page,
summary=project_info.summary,
author=project_info.author,
license=project_info.license,
parent=self,
plugin_name=plugin_name,
enabled=enabled,
installed=installed,
npe_version=npe_version,
)
item.widget = widg
item.npe_version = npe_version
action_name = 'uninstall' if installed else 'install'
item.setSizeHint(widg.sizeHint())
self.setItemWidget(item, widg)
if project_info.home_page:
import webbrowser
widg.help_button.clicked.connect(
partial(webbrowser.open, project_info.home_page)
)
else:
widg.help_button.setVisible(False)
widg.action_button.clicked.connect(
partial(self.handle_action, item, pkg_name, action_name)
)
widg.update_btn.clicked.connect(
partial(
self.handle_action,
item,
pkg_name,
InstallerActions.INSTALL,
update=True,
)
)
widg.cancel_btn.clicked.connect(
partial(
self.handle_action, item, pkg_name, InstallerActions.CANCEL
)
)
item.setSizeHint(widg.sizeHint())
self.setItemWidget(item, widg)
def handle_action(
self,
item: QListWidgetItem,
pkg_name: str,
action_name: InstallerActions,
update: bool = False,
):
# TODO: 'tool' should be configurable per item, depending on dropdown
tool = (
InstallerTools.CONDA
if running_as_constructor_app()
else InstallerTools.PIP
)
widget = item.widget
item.setText(f"0-{item.text()}")
self._remove_list.append((pkg_name, item))
self._warn_dialog = None
# TODO: NPE version unknown before installing
if item.npe_version != 1 and action_name == InstallerActions.UNINSTALL:
# show warning pop up dialog
message = trans._(
'When installing/uninstalling npe2 plugins, you must '
'restart napari for UI changes to take effect.'
)
self._warn_dialog = WarnPopup(text=message)
delta_x = 75
global_point = widget.action_button.mapToGlobal(
widget.action_button.rect().topLeft()
)
global_point = QPoint(global_point.x() - delta_x, global_point.y())
self._warn_dialog.move(global_point)
if action_name == InstallerActions.INSTALL:
if update:
if hasattr(item, 'latest_version'):
pkg_name += f"=={item.latest_version}"
widget.set_busy(trans._("updating..."), update)
widget.action_button.setDisabled(True)
else:
widget.set_busy(trans._("installing..."), update)
job_id = self.installer.install(
tool=tool,
pkgs=[pkg_name],
# origins="TODO",
)
widget.setProperty("current_job_id", job_id)
if self._warn_dialog:
self._warn_dialog.exec_()
self.scrollToTop()
elif action_name == InstallerActions.UNINSTALL:
widget.set_busy(trans._("uninstalling..."), update)
widget.update_btn.setDisabled(True)
job_id = self.installer.uninstall(
tool=tool,
pkgs=[pkg_name],
# origins="TODO",
)
widget.setProperty("current_job_id", job_id)
if self._warn_dialog:
self._warn_dialog.exec_()
self.scrollToTop()
elif action_name == InstallerActions.CANCEL:
widget.set_busy(trans._("cancelling..."), update)
try:
job_id = widget.property("current_job_id")
self.installer.cancel(job_id)
finally:
widget.setProperty("current_job_id", None)
@Slot(PackageMetadata, bool)
def tag_outdated(self, project_info: PackageMetadata, is_available: bool):
if not is_available:
return
for item in self.findItems(
project_info.name, Qt.MatchFlag.MatchStartsWith
):
current = item.version
latest = project_info.version
if parse_version(current) >= parse_version(latest):
continue
if hasattr(item, 'outdated'):
# already tagged it
continue
item.outdated = True
item.latest_version = latest
widg = self.itemWidget(item)
widg.update_btn.setVisible(True)
widg.update_btn.setText(
trans._("update (v{latest})", latest=latest)
)
def tag_unavailable(self, project_info: PackageMetadata):
"""
Tag list items as unavailable for install with conda-forge.
This will disable the item and the install button and add a warning
icon with a hover tooltip.
"""
for item in self.findItems(
project_info.name, Qt.MatchFlag.MatchStartsWith
):
widget = self.itemWidget(item)
widget.show_warning(
trans._(
"Plugin not yet available for installation within the bundle application"
)
)
widget.setObjectName("unavailable")
widget.style().unpolish(widget)
widget.style().polish(widget)
widget.action_button.setEnabled(False)
widget.warning_tooltip.setVisible(True)
def filter(self, text: str):
"""Filter items to those containing `text`."""
if text:
# PySide has some issues, so we compare using id
# See: https://bugreports.qt.io/browse/PYSIDE-74
shown = [
id(it)
for it in self.findItems(text, Qt.MatchFlag.MatchContains)
]
for i in range(self.count()):
item = self.item(i)
item.setHidden(id(item) not in shown)
else:
for i in range(self.count()):
item = self.item(i)
item.setHidden(False)
class RefreshState(Enum):
REFRESHING = auto()
OUTDATED = auto()
DONE = auto()
class QtPluginDialog(QDialog):
def __init__(self, parent=None) -> None:
super().__init__(parent)
self.refresh_state = RefreshState.DONE
self.already_installed = set()
self.installer = InstallerQueue()
self.setWindowTitle(trans._('Plugin Manager'))
self.setup_ui()
self.installer.set_output_widget(self.stdout_text)
self.installer.started.connect(self._on_installer_start)
self.installer.finished.connect(self._on_installer_done)
self.refresh()
def _on_installer_start(self):
self.cancel_all_btn.setVisible(True)
self.working_indicator.show()
self.process_success_indicator.hide()
self.process_error_indicator.hide()
self.close_btn.setDisabled(True)
def _on_installer_done(self, exit_code):
self.working_indicator.hide()
if exit_code:
self.process_error_indicator.show()
else:
self.process_success_indicator.show()
self.cancel_all_btn.setVisible(False)
self.close_btn.setDisabled(False)
self.refresh()
def closeEvent(self, event):
if self.close_btn.isEnabled():
super().closeEvent(event)
event.ignore()
def refresh(self):
if self.refresh_state != RefreshState.DONE:
self.refresh_state = RefreshState.OUTDATED
return
self.refresh_state = RefreshState.REFRESHING
self.installed_list.clear()
self.available_list.clear()
# fetch installed
from npe2 import PluginManager
from napari.plugins import plugin_manager
self.already_installed = set()
def _add_to_installed(distname, enabled, npe_version=1):
norm_name = normalized_name(distname or '')
if distname:
try:
meta = metadata(distname)
except PackageNotFoundError:
self.refresh_state = RefreshState.OUTDATED
return # a race condition has occurred and the package is uninstalled by another thread
if len(meta) == 0:
# will not add builtins.
return
self.already_installed.add(norm_name)
else:
meta = {}
self.installed_list.addItem(
PackageMetadata(
metadata_version="1.0",
name=norm_name,
version=meta.get('version', ''),
summary=meta.get('summary', ''),
home_page=meta.get('url', ''),
author=meta.get('author', ''),
license=meta.get('license', ''),
),
installed=True,
enabled=enabled,
npe_version=npe_version,
)
pm2 = PluginManager.instance()
discovered = pm2.discover()
for manifest in pm2.iter_manifests():
distname = normalized_name(manifest.name or '')
if distname in self.already_installed or distname == 'napari':
continue
enabled = not pm2.is_disabled(manifest.name)
# if it's an Npe1 adaptor, call it v1
npev = 'shim' if manifest.npe1_shim else 2
_add_to_installed(distname, enabled, npe_version=npev)
plugin_manager.discover() # since they might not be loaded yet
for plugin_name, _, distname in plugin_manager.iter_available():
# not showing these in the plugin dialog
if plugin_name in ('napari_plugin_engine',):
continue
if normalized_name(distname or '') in self.already_installed:
continue
_add_to_installed(
distname, not plugin_manager.is_blocked(plugin_name)
)
self.installed_label.setText(
trans._(
"Installed Plugins ({amount})",
amount=len(self.already_installed),
)
)
# fetch available plugins
settings = get_settings()
use_hub = (
running_as_bundled_app()
or running_as_constructor_app()
or settings.plugins.plugin_api.name == "napari_hub"
)
if use_hub:
conda_forge = running_as_constructor_app()
self.worker = create_worker(
iter_hub_plugin_info, conda_forge=conda_forge
)
else:
self.worker = create_worker(iter_napari_plugin_info)
self.worker.yielded.connect(self._handle_yield)
self.worker.finished.connect(self.working_indicator.hide)
self.worker.finished.connect(self._update_count_in_label)
self.worker.finished.connect(self._end_refresh)
self.worker.start()
if discovered:
message = trans._(
'When installing/uninstalling npe2 plugins, '
'you must restart napari for UI changes to take effect.'
)
self._warn_dialog = WarnPopup(text=message)
global_point = self.process_error_indicator.mapToGlobal(
self.process_error_indicator.rect().topLeft()
)
global_point = QPoint(global_point.x(), global_point.y() - 75)
self._warn_dialog.move(global_point)
self._warn_dialog.exec_()
def setup_ui(self):
self.resize(1080, 640)
vlay_1 = QVBoxLayout(self)
self.h_splitter = QSplitter(self)
vlay_1.addWidget(self.h_splitter)
self.h_splitter.setOrientation(Qt.Orientation.Horizontal)
self.v_splitter = QSplitter(self.h_splitter)
self.v_splitter.setOrientation(Qt.Orientation.Vertical)
self.v_splitter.setMinimumWidth(500)
installed = QWidget(self.v_splitter)
lay = QVBoxLayout(installed)
lay.setContentsMargins(0, 2, 0, 2)
self.installed_label = QLabel(trans._("Installed Plugins"))
self.packages_filter = QLineEdit()
self.packages_filter.setPlaceholderText(trans._("filter..."))
self.packages_filter.setMaximumWidth(350)
self.packages_filter.setClearButtonEnabled(True)
mid_layout = QVBoxLayout()
mid_layout.addWidget(self.packages_filter)
mid_layout.addWidget(self.installed_label)
lay.addLayout(mid_layout)
self.installed_list = QPluginList(installed, self.installer)
self.packages_filter.textChanged.connect(self.installed_list.filter)
lay.addWidget(self.installed_list)
uninstalled = QWidget(self.v_splitter)
lay = QVBoxLayout(uninstalled)
lay.setContentsMargins(0, 2, 0, 2)
self.avail_label = QLabel(trans._("Available Plugins"))
mid_layout = QHBoxLayout()
mid_layout.addWidget(self.avail_label)
mid_layout.addStretch()
lay.addLayout(mid_layout)
self.available_list = QPluginList(uninstalled, self.installer)
self.packages_filter.textChanged.connect(self.available_list.filter)
lay.addWidget(self.available_list)
self.stdout_text = QTextEdit(self.v_splitter)
self.stdout_text.setReadOnly(True)
self.stdout_text.setObjectName("plugin_manager_process_status")
self.stdout_text.hide()
buttonBox = QHBoxLayout()
self.working_indicator = QLabel(trans._("loading ..."), self)
sp = self.working_indicator.sizePolicy()
sp.setRetainSizeWhenHidden(True)
self.working_indicator.setSizePolicy(sp)
self.process_error_indicator = QLabel(self)
self.process_error_indicator.setObjectName("error_label")
self.process_error_indicator.hide()
self.process_success_indicator = QLabel(self)
self.process_success_indicator.setObjectName("success_label")
self.process_success_indicator.hide()
load_gif = str(Path(napari.resources.__file__).parent / "loading.gif")
mov = QMovie(load_gif)
mov.setScaledSize(QSize(18, 18))
self.working_indicator.setMovie(mov)
mov.start()
visibility_direct_entry = not running_as_constructor_app()
self.direct_entry_edit = QLineEdit(self)
self.direct_entry_edit.installEventFilter(self)
self.direct_entry_edit.setPlaceholderText(
trans._('install by name/url, or drop file...')
)
self.direct_entry_edit.setVisible(visibility_direct_entry)
self.direct_entry_btn = QPushButton(trans._("Install"), self)
self.direct_entry_btn.setVisible(visibility_direct_entry)
self.direct_entry_btn.clicked.connect(self._install_packages)
self.show_status_btn = QPushButton(trans._("Show Status"), self)
self.show_status_btn.setFixedWidth(100)
self.cancel_all_btn = QPushButton(trans._("cancel all actions"), self)
self.cancel_all_btn.setObjectName("remove_button")
self.cancel_all_btn.setVisible(False)
self.cancel_all_btn.clicked.connect(self.installer.cancel)
self.close_btn = QPushButton(trans._("Close"), self)
self.close_btn.clicked.connect(self.accept)
self.close_btn.setObjectName("close_button")
buttonBox.addWidget(self.show_status_btn)
buttonBox.addWidget(self.working_indicator)
buttonBox.addWidget(self.direct_entry_edit)
buttonBox.addWidget(self.direct_entry_btn)
if not visibility_direct_entry:
buttonBox.addStretch()
buttonBox.addWidget(self.process_success_indicator)
buttonBox.addWidget(self.process_error_indicator)
buttonBox.addSpacing(20)
buttonBox.addWidget(self.cancel_all_btn)
buttonBox.addSpacing(20)
buttonBox.addWidget(self.close_btn)
buttonBox.setContentsMargins(0, 0, 4, 0)
vlay_1.addLayout(buttonBox)
self.show_status_btn.setCheckable(True)
self.show_status_btn.setChecked(False)
self.show_status_btn.toggled.connect(self._toggle_status)
self.v_splitter.setStretchFactor(1, 2)
self.h_splitter.setStretchFactor(0, 2)
self.packages_filter.setFocus()
def _update_count_in_label(self):
count = self.available_list.count()
self.avail_label.setText(
trans._("Available Plugins ({count})", count=count)
)
def _end_refresh(self):
refresh_state = self.refresh_state
self.refresh_state = RefreshState.DONE
if refresh_state == RefreshState.OUTDATED:
self.refresh()
def eventFilter(self, watched, event):
if event.type() == QEvent.DragEnter:
# we need to accept this event explicitly to be able
# to receive QDropEvents!
event.accept()
if event.type() == QEvent.Drop:
md = event.mimeData()
if md.hasUrls():
files = [url.toLocalFile() for url in md.urls()]
self.direct_entry_edit.setText(files[0])
return True
return super().eventFilter(watched, event)
def _toggle_status(self, show):
if show:
self.show_status_btn.setText(trans._("Hide Status"))
self.stdout_text.show()
else:
self.show_status_btn.setText(trans._("Show Status"))
self.stdout_text.hide()
def _install_packages(self, packages: Sequence[str] = ()):
if not packages:
_packages = self.direct_entry_edit.text()
packages = (
[_packages] if os.path.exists(_packages) else _packages.split()
)
self.direct_entry_edit.clear()
if packages:
self.installer.install(packages)
def _handle_yield(self, data: Tuple[PackageMetadata, bool]):
project_info, is_available = data
if project_info.name in self.already_installed:
self.installed_list.tag_outdated(project_info, is_available)
else:
self.available_list.addItem(project_info)
if not is_available:
self.available_list.tag_unavailable(project_info)
self.filter()
def filter(self, text: Optional[str] = None) -> None:
"""Filter by text or set current text as filter."""
if text is None:
text = self.packages_filter.text()
else:
self.packages_filter.setText(text)
self.installed_list.filter(text)
self.available_list.filter(text)
if __name__ == "__main__":
from qtpy.QtWidgets import QApplication
app = QApplication([])
w = QtPluginDialog()
w.show()
app.exec_()
napari-0.5.0a1/napari/_qt/dialogs/qt_plugin_report.py 0000664 0000000 0000000 00000017436 14370413656 0022662 0 ustar 00root root 0000000 0000000 """Provides a QtPluginErrReporter that allows the user report plugin errors.
"""
from typing import Optional
from napari_plugin_engine import standard_metadata
from qtpy.QtCore import Qt
from qtpy.QtGui import QGuiApplication
from qtpy.QtWidgets import (
QComboBox,
QDialog,
QHBoxLayout,
QLabel,
QPushButton,
QTextEdit,
QVBoxLayout,
QWidget,
)
from napari._qt.code_syntax_highlight import Pylighter
from napari.plugins.exceptions import format_exceptions
from napari.settings import get_settings
from napari.utils.theme import get_theme
from napari.utils.translations import trans
class QtPluginErrReporter(QDialog):
"""Dialog that allows users to review and report PluginError tracebacks.
Parameters
----------
parent : QWidget, optional
Optional parent widget for this widget.
initial_plugin : str, optional
If provided, errors from ``initial_plugin`` will be shown when the
dialog is created, by default None
Attributes
----------
text_area : qtpy.QtWidgets.QTextEdit
The text area where traceback information will be shown.
plugin_combo : qtpy.QtWidgets.QComboBox
The dropdown menu used to select the current plugin
github_button : qtpy.QtWidgets.QPushButton
A button that, when pressed, will open an issue at the current plugin's
github issue tracker, prepopulated with a formatted traceback. Button
is only visible if a github URL is detected in the package metadata for
the current plugin.
clipboard_button : qtpy.QtWidgets.QPushButton
A button that, when pressed, copies the current traceback information
to the clipboard. (HTML tags are removed in the copied text.)
plugin_meta : qtpy.QtWidgets.QLabel
A label that will show available plugin metadata (such as home page).
"""
NULL_OPTION = trans._('select plugin... ')
def __init__(
self,
*,
parent: Optional[QWidget] = None,
initial_plugin: Optional[str] = None,
) -> None:
super().__init__(parent)
from napari.plugins import plugin_manager
self.plugin_manager = plugin_manager
self.setWindowTitle(trans._('Recorded Plugin Exceptions'))
self.setWindowModality(Qt.WindowModality.NonModal)
self.layout = QVBoxLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(10, 10, 10, 10)
self.setLayout(self.layout)
self.text_area = QTextEdit()
theme = get_theme(get_settings().appearance.theme, as_dict=False)
self._highlight = Pylighter(
self.text_area.document(), "python", theme.syntax_style
)
self.text_area.setTextInteractionFlags(
Qt.TextInteractionFlag.TextSelectableByMouse
)
self.text_area.setMinimumWidth(360)
# Create plugin dropdown menu
self.plugin_combo = QComboBox()
self.plugin_combo.addItem(self.NULL_OPTION)
bad_plugins = [e.plugin_name for e in self.plugin_manager.get_errors()]
self.plugin_combo.addItems(list(sorted(set(bad_plugins))))
self.plugin_combo.currentTextChanged.connect(self.set_plugin)
self.plugin_combo.setCurrentText(self.NULL_OPTION)
# create github button (gets connected in self.set_plugin)
self.github_button = QPushButton(trans._('Open issue on GitHub'), self)
self.github_button.setToolTip(
trans._(
"Open a web browser to submit this error log\nto the developer's GitHub issue tracker",
)
)
self.github_button.hide()
# create copy to clipboard button
self.clipboard_button = QPushButton()
self.clipboard_button.hide()
self.clipboard_button.setObjectName("QtCopyToClipboardButton")
self.clipboard_button.setToolTip(
trans._("Copy error log to clipboard")
)
self.clipboard_button.clicked.connect(self.copyToClipboard)
# plugin_meta contains a URL to the home page, (and/or other details)
self.plugin_meta = QLabel('', parent=self)
self.plugin_meta.setObjectName("pluginInfo")
self.plugin_meta.setTextFormat(Qt.TextFormat.RichText)
self.plugin_meta.setTextInteractionFlags(
Qt.TextInteractionFlag.TextBrowserInteraction
)
self.plugin_meta.setOpenExternalLinks(True)
self.plugin_meta.setAlignment(Qt.AlignmentFlag.AlignRight)
# make layout
row_1_layout = QHBoxLayout()
row_1_layout.setContentsMargins(11, 5, 10, 0)
row_1_layout.addStretch(1)
row_1_layout.addWidget(self.plugin_meta)
row_2_layout = QHBoxLayout()
row_2_layout.setContentsMargins(11, 5, 10, 0)
row_2_layout.addWidget(self.plugin_combo)
row_2_layout.addStretch(1)
row_2_layout.addWidget(self.github_button)
row_2_layout.addWidget(self.clipboard_button)
row_2_layout.setSpacing(5)
self.layout.addLayout(row_1_layout)
self.layout.addLayout(row_2_layout)
self.layout.addWidget(self.text_area, 1)
self.setMinimumWidth(750)
self.setMinimumHeight(600)
if initial_plugin:
self.set_plugin(initial_plugin)
def set_plugin(self, plugin: str) -> None:
"""Set the current plugin shown in the dropdown and text area.
Parameters
----------
plugin : str
name of a plugin that has created an error this session.
"""
self.github_button.hide()
self.clipboard_button.hide()
try:
self.github_button.clicked.disconnect()
# when disconnecting a non-existent signal
# PySide2 raises runtimeError, PyQt5 raises TypeError
except (RuntimeError, TypeError):
pass
if not plugin or (plugin == self.NULL_OPTION):
self.plugin_meta.setText('')
self.text_area.setText('')
return
if not self.plugin_manager.get_errors(plugin):
raise ValueError(
trans._(
"No errors reported for plugin '{plugin}'", plugin=plugin
)
)
self.plugin_combo.setCurrentText(plugin)
err_string = format_exceptions(plugin, as_html=False, color="NoColor")
self.text_area.setText(err_string)
self.clipboard_button.show()
# set metadata and outbound links/buttons
err0 = self.plugin_manager.get_errors(plugin)[0]
meta = standard_metadata(err0.plugin) if err0.plugin else {}
meta_text = ''
if not meta:
self.plugin_meta.setText(meta_text)
return
url = meta.get('url')
if url:
meta_text += (
'plugin home page: '
f'{url}'
)
if 'github.com' in url:
def onclick():
import webbrowser
err = format_exceptions(plugin, as_html=False)
err = (
"\n\n\n\n"
"\nTraceback from napari"
f"\n\n```\n{err}\n```\n"
)
url = f'{meta.get("url")}/issues/new?&body={err}'
webbrowser.open(url, new=2)
self.github_button.clicked.connect(onclick)
self.github_button.show()
self.plugin_meta.setText(meta_text)
def copyToClipboard(self) -> None:
"""Copy current plugin traceback info to clipboard as plain text."""
plugin = self.plugin_combo.currentText()
err_string = format_exceptions(plugin, as_html=False)
cb = QGuiApplication.clipboard()
cb.setText(err_string)
napari-0.5.0a1/napari/_qt/dialogs/qt_reader_dialog.py 0000664 0000000 0000000 00000023522 14370413656 0022543 0 ustar 00root root 0000000 0000000 import os
from typing import Dict, List, Optional, Tuple, Union
from qtpy.QtWidgets import (
QButtonGroup,
QCheckBox,
QDialog,
QDialogButtonBox,
QLabel,
QRadioButton,
QVBoxLayout,
QWidget,
)
from napari.errors import ReaderPluginError
from napari.plugins.utils import get_potential_readers
from napari.settings import get_settings
from napari.utils.translations import trans
class QtReaderDialog(QDialog):
"""Dialog for user to select a reader plugin for a given file extension or folder"""
def __init__(
self,
pth: str = '',
parent: QWidget = None,
readers: Dict[str, str] = None,
error_message: str = '',
persist_checked: bool = True,
) -> None:
if readers is None:
readers = {}
super().__init__(parent)
self.setObjectName('Choose reader')
self.setWindowTitle(trans._('Choose reader'))
self._current_file = pth
self._extension = os.path.splitext(pth)[1]
self._persist_text = trans._(
'Remember this choice for files with a {extension} extension',
extension=self._extension,
)
if os.path.isdir(pth):
self._extension = os.path.realpath(pth)
if not self._extension.endswith(
'.zarr'
) and not self._extension.endswith(os.sep):
self._extension = self._extension + os.sep
self._persist_text = trans._(
'Remember this choice for folders labeled as {extension}.',
extension=self._extension,
)
self._reader_buttons = []
self.setup_ui(error_message, readers, persist_checked)
def setup_ui(self, error_message, readers, persist_checked):
"""Build UI using given error_messsage and readers dict"""
# add instruction label
layout = QVBoxLayout()
if error_message:
error_message += "\n"
label = QLabel(
f"{error_message}Choose reader for {self._current_file}:"
)
layout.addWidget(label)
# add radio button for each reader plugin
self.reader_btn_group = QButtonGroup(self)
self.add_reader_buttons(layout, readers)
if self.reader_btn_group.buttons():
self.reader_btn_group.buttons()[0].toggle()
# OK & cancel buttons for the dialog
btns = QDialogButtonBox.Ok | QDialogButtonBox.Cancel
self.btn_box = QDialogButtonBox(btns)
self.btn_box.accepted.connect(self.accept)
self.btn_box.rejected.connect(self.reject)
# checkbox to remember the choice
if os.path.isdir(self._current_file):
existing_pref = get_settings().plugins.extension2reader.get(
self._extension
)
isdir = True
else:
existing_pref = get_settings().plugins.extension2reader.get(
'*' + self._extension
)
isdir = False
if existing_pref:
if isdir:
self._persist_text = trans._(
'Override existing preference for folders labeled as {extension}: {pref}',
extension=self._extension,
pref=existing_pref,
)
else:
self._persist_text = trans._(
'Override existing preference for files with a {extension} extension: {pref}',
extension=self._extension,
pref=existing_pref,
)
self.persist_checkbox = QCheckBox(self._persist_text)
self.persist_checkbox.toggle()
self.persist_checkbox.setChecked(persist_checked)
layout.addWidget(self.persist_checkbox)
layout.addWidget(self.btn_box)
self.setLayout(layout)
def add_reader_buttons(self, layout, readers):
"""Add radio button to layout for each reader in readers"""
for display_name in sorted(readers.values()):
button = QRadioButton(f"{display_name}")
self.reader_btn_group.addButton(button)
layout.addWidget(button)
def _get_plugin_choice(self):
"""Get user's plugin choice based on the checked button"""
checked_btn = self.reader_btn_group.checkedButton()
if checked_btn:
return checked_btn.text()
def _get_persist_choice(self):
"""Get persistence checkbox choice"""
return (
hasattr(self, 'persist_checkbox')
and self.persist_checkbox.isChecked()
)
def get_user_choices(self) -> Tuple[str, bool]:
"""Execute dialog and get user choices"""
display_name = ''
persist_choice = False
dialog_result = self.exec_()
# user pressed cancel
if dialog_result:
# grab the selected radio button text
display_name = self._get_plugin_choice()
# grab the persistence checkbox choice
persist_choice = self._get_persist_choice()
return display_name, persist_choice
def handle_gui_reading(
paths: List[str],
qt_viewer,
stack: Union[bool, List[List[str]]],
plugin_name: Optional[str] = None,
error: Optional[ReaderPluginError] = None,
plugin_override: bool = False,
**kwargs,
):
"""Present reader dialog to choose reader and open paths based on result.
This function is called whenever ViewerModel._open_or_get_error returns
an error from a GUI interaction e.g. dragging & dropping a file or using
the File -> Open dialogs. It prepares remaining readers and error message
for display, opens the reader dialog and based on user entry opens
paths using the chosen plugin. Any errors raised in the process of reading
with the chosen plugin are reraised.
Parameters
----------
paths : list[str]
list of paths to open, as strings
qt_viewer : QtViewer
QtViewer to associate dialog with
stack : bool or list[list[str]]
True if list of paths should be stacked, otherwise False.
Can also be a list containing lists of files to stack
plugin_name : str | None
name of plugin already tried, if any
error : ReaderPluginError | None
previous error raised in the process of opening
plugin_override : bool
True when user is forcing a plugin choice, otherwise False.
Dictates whether checkbox to remember choice is unchecked by default
"""
_path = paths[0]
readers = prepare_remaining_readers(paths, plugin_name, error)
error_message = str(error) if error else ''
readerDialog = QtReaderDialog(
parent=qt_viewer,
pth=_path,
error_message=error_message,
readers=readers,
persist_checked=not plugin_override,
)
display_name, persist = readerDialog.get_user_choices()
if display_name:
open_with_dialog_choices(
display_name,
persist,
readerDialog._extension,
readers,
paths,
stack,
qt_viewer,
**kwargs,
)
def prepare_remaining_readers(
paths: List[str],
plugin_name: Optional[str] = None,
error: Optional[ReaderPluginError] = None,
):
"""Remove tried plugin from readers and raise error if no readers remain.
Parameters
----------
paths : List[str]
paths to open
plugin_name : str | None
name of plugin previously tried, if any
error : ReaderPluginError | None
previous error raised in the process of opening
Returns
-------
readers: Dict[str, str]
remaining readers to present to user
Raises
------
ReaderPluginError
raises previous error if no readers are left to try
"""
readers = get_potential_readers(paths[0])
# remove plugin we already tried e.g. prefered plugin
if plugin_name in readers:
del readers[plugin_name]
# if there's no other readers left, raise the exception
if not readers and error:
raise ReaderPluginError(
trans._(
"Tried to read {path_message} with plugin {plugin}, because it was associated with that file extension/because it is the only plugin capable of reading that path, but it gave an error. Try associating a different plugin or installing a different plugin for this kind of file.",
path_message=f"[{paths[0]}, ...]"
if len(paths) > 1
else paths[0],
plugin=plugin_name,
),
plugin_name,
paths,
) from error
return readers
def open_with_dialog_choices(
display_name: str,
persist: bool,
extension: str,
readers: Dict[str, str],
paths: List[str],
stack: bool,
qt_viewer,
**kwargs,
):
"""Open paths with chosen plugin from reader dialog, persisting if chosen.
Parameters
----------
display_name : str
display name of plugin to use
persist : bool
True if user chose to persist plugin association, otherwise False
extension : str
file extension for association of preferences
readers : Dict[str, str]
plugin-name: display-name dictionary of remaining readers
paths : List[str]
paths to open
stack : bool
True if files should be opened as a stack, otherwise False
qt_viewer : QtViewer
viewer to add layers to
"""
# TODO: disambiguate with reader title
plugin_name = [
p_name for p_name, d_name in readers.items() if d_name == display_name
][0]
# may throw error, but we let it this time
qt_viewer.viewer.open(paths, stack=stack, plugin=plugin_name, **kwargs)
if persist:
if not extension.endswith(os.sep):
extension = '*' + extension
get_settings().plugins.extension2reader = {
**get_settings().plugins.extension2reader,
extension: plugin_name,
}
napari-0.5.0a1/napari/_qt/dialogs/screenshot_dialog.py 0000664 0000000 0000000 00000004203 14370413656 0022745 0 ustar 00root root 0000000 0000000 import os
from pathlib import Path
from typing import Any, Callable
from qtpy.QtWidgets import QFileDialog, QMessageBox
from napari.utils.misc import in_ipython
from napari.utils.translations import trans
HOME_DIRECTORY = str(Path.home())
class ScreenshotDialog(QFileDialog):
"""
Dialog to chose save location of screenshot.
Parameters
----------
save_function : Callable[[str], Any],
Function to be called on success of selecting save location
parent : QWidget, optional
Optional parent widget for this widget..
directory : str, optional
Starting directory to be set to File Dialog
"""
def __init__(
self,
save_function: Callable[[str], Any],
parent=None,
directory=HOME_DIRECTORY,
history=None,
) -> None:
super().__init__(parent, trans._("Save screenshot"))
self.setAcceptMode(QFileDialog.AcceptSave)
self.setFileMode(QFileDialog.AnyFile)
self.setNameFilter(
trans._("Image files (*.png *.bmp *.gif *.tif *.tiff)")
)
self.setDirectory(directory)
self.setHistory(history)
if in_ipython():
self.setOptions(QFileDialog.DontUseNativeDialog)
self.save_function = save_function
def accept(self):
save_path = self.selectedFiles()[0]
if os.path.splitext(save_path)[1] == "":
save_path = save_path + ".png"
if os.path.exists(save_path):
res = QMessageBox().warning(
self,
trans._("Confirm overwrite"),
trans._(
"{save_path} already exists. Do you want to replace it?",
save_path=save_path,
),
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No,
)
if res != QMessageBox.Yes:
# standard accept return 1, reject 0. This inform that dialog should be reopened
super().accept()
self.exec_()
self.save_function(save_path)
return super().accept()
napari-0.5.0a1/napari/_qt/experimental/ 0000775 0000000 0000000 00000000000 14370413656 0017753 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/experimental/__init__.py 0000664 0000000 0000000 00000000000 14370413656 0022052 0 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/experimental/qt_chunk_receiver.py 0000664 0000000 0000000 00000010240 14370413656 0024022 0 ustar 00root root 0000000 0000000 """QtChunkReceiver and QtGuiEvent classes.
"""
from qtpy.QtCore import QObject, Signal
from napari.components.experimental.chunk import chunk_loader
from napari.utils.events import EmitterGroup, Event, EventEmitter
class QtGuiEvent(QObject):
"""Fires an event in the GUI thread.
Listens to an event in any thread. When that event fires, it uses a Qt
Signal/Slot to fire a gui_event in the GUI thread. If the original
event is already in the GUI thread that's fine, the gui_event will
be immediately fired the GUI thread.
Parameters
----------
parent : QObject
Parent Qt object.
emitter : EventEmitter
The event we are listening to.
Attributes
----------
emitter : EventEmitter
The event we are listening to.
events : EmitterGroup
The only event we report is events.gui_event.
Notes
-----
Qt's signal/slot mechanism is the only way we know of to "call" from a
worker thread to the GUI thread. When Qt signals from a worker thread
it posts a message to the GUI thread. When the GUI thread is next
processing messages it will receive that message and call into the Slot
to deliver the message/event.
If the original event was already in the GUI thread that's fine,
the resulting event will just be triggered right away.
"""
signal = Signal(Event)
def __init__(self, parent: QObject, emitter: EventEmitter) -> None:
super().__init__(parent)
emitter.connect(self._on_event)
self.emitter = emitter
self.events = EmitterGroup(source=self, gui_event=None)
self.signal.connect(self._slot)
def _on_event(self, event) -> None:
"""Event was fired, we could be in any thread."""
self.signal.emit(event)
def _slot(self, event) -> None:
"""Slot is always called in the GUI thread."""
self.events.gui_event(original_event=event)
def close(self):
"""Viewer is closing."""
self.gui_event.disconnect()
self.emitter.disconnect()
class QtChunkReceiver:
"""Passes loaded chunks to their layer.
Parameters
----------
parent : QObject
Parent Qt object.
Attributes
----------
gui_event : QtGuiEvent
We use this to call _on_chunk_loaded_gui() in the GUI thread.
Notes
-----
ChunkLoader._done "may" be called in a worker thread. The
concurrent.futures documentation only guarantees that the future's done
handler will be called in a thread in the correct process, it does not
say which thread.
We need to call Layer.on_chunk_loaded() to deliver the loaded chunk to the
Layer. We do not want to make this call from a worker thread, because our
model code is not thread safe. We don't want the GUI thread and the worker
thread changing things at the same time, both triggering events, potentially
calling into vispy or other things that also aren't thread safe.
We could add locks, but it's simpler and better if we just call
Layer.on_chunk_loaded() from the GUI thread. This class QtChunkReceiver
listens to the ChunkLoader's chunk_loaded event. It then uses QtUiEvent
to call its own _on_chunk_loaded_gui() in the GUI thread. From that
method it can safely call Layer.on_chunk_loaded.
If ChunkLoader's chunk_loaded event is already in the GUI thread for
some reason, this class will still work fine, it will just run
100% in the GUI thread.
"""
def __init__(self, parent: QObject) -> None:
listen_event = chunk_loader.events.chunk_loaded
self.gui_event = QtGuiEvent(parent, listen_event)
self.gui_event.events.gui_event.connect(self._on_chunk_loaded_gui)
@staticmethod
def _on_chunk_loaded_gui(event) -> None:
"""A chunk was loaded. This method is called in the GUI thread.
Parameters
----------
event : Event
The event object from the original event.
"""
layer = event.original_event.layer
request = event.original_event.request
layer.on_chunk_loaded(request) # Pass the chunk to its layer.
def close(self):
"""Viewer is closing."""
self.gui_event.close()
napari-0.5.0a1/napari/_qt/experimental/qt_poll.py 0000664 0000000 0000000 00000010607 14370413656 0022003 0 ustar 00root root 0000000 0000000 """QtPoll class.
Poll visuals or other objects so they can do things even when the
mouse/camera are not moving. Usually for just a short period of time.
"""
import time
from typing import Optional
from qtpy.QtCore import QEvent, QObject, QTimer
from napari.utils.events import EmitterGroup
# When running a timer we use this interval.
POLL_INTERVAL_MS = 16 # About 60HZ, needs to be an int for QTimer setInterval
# If called more often than this we ignore it. Our _on_camera() method can
# be called multiple times in on frame. It can get called because the
# "center" changed and then the "zoom" changed even if it was really from
# the same camera movement.
IGNORE_INTERVAL_MS = 10
class QtPoll(QObject):
"""Polls anything once per frame via an event.
QtPoll was first created for VispyTiledImageLayer. It polls the visual
when the camera moves. However, we also want visuals to keep loading
chunks even when the camera stops. We want the visual to finish up
anything that was in progress. Before it goes fully idle.
QtPoll will poll those visuals using a timer. If the visual says the
event was "handled" it means the visual has more work to do. If that
happens, QtPoll will continue to poll and draw the visual it until the
visual is done with the in-progress work.
An analogy is a snow globe. The user moving the camera shakes up the
snow globe. We need to keep polling/drawing things until all the snow
settles down. Then everything will stay completely still until the
camera is moved again, shaking up the globe once more.
Parameters
----------
parent : QObject
Parent Qt object.
camera : Camera
The viewer's main camera.
"""
def __init__(self, parent: QObject) -> None:
super().__init__(parent)
self.events = EmitterGroup(source=self, poll=None)
self.timer = QTimer()
self.timer.setInterval(POLL_INTERVAL_MS)
self.timer.timeout.connect(self._on_timer)
self._interval = IntervalTimer()
def on_camera(self) -> None:
"""Called when camera view changes."""
# When the mouse button is down and the camera is being zoomed
# or panned, timer events are starved out. So we call poll
# explicitly here. It will start the timer if needed so that
# polling can continue even after the camera stops moving.
self._poll()
def wake_up(self) -> None:
"""Wake up QtPoll so it starts polling."""
# Start the timer so that we start polling. We used to poll once
# right away here, but it led to crashes. Because we polled during
# a paintGL event?
if not self.timer.isActive():
self.timer.start()
def _on_timer(self) -> None:
"""Called when the timer is running.
The timer is running which means someone we are polling still has
work to do.
"""
self._poll()
def _poll(self) -> None:
"""Called on camera move or with the timer."""
# Between timers and camera and wake_up() we might be called multiple
# times in quick succession. Use an IntervalTimer to ignore these
# near-duplicate calls.
if self._interval.elapsed_ms < IGNORE_INTERVAL_MS:
return
# Poll all listeners.
event = self.events.poll()
# Listeners will "handle" the event if they need more polling. If
# no one needs polling, then we can stop the timer.
if not event.handled:
self.timer.stop()
return
# Someone handled the event, so they want to be polled even if
# the mouse doesn't move. So start the timer if needed.
if not self.timer.isActive():
self.timer.start()
def closeEvent(self, _event: QEvent) -> None:
"""Cleanup and close.
Parameters
----------
_event : QEvent
The close event.
"""
self.timer.stop()
self.deleteLater()
class IntervalTimer:
"""Time the interval between subsequent calls to our elapsed property."""
def __init__(self) -> None:
self._last: Optional[float] = None
@property
def elapsed_ms(self) -> float:
"""The elapsed time since the last call to this property."""
now = time.time()
elapsed_seconds = 0 if self._last is None else now - self._last
self._last = now
return elapsed_seconds * 1000
napari-0.5.0a1/napari/_qt/layer_controls/ 0000775 0000000 0000000 00000000000 14370413656 0020315 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/layer_controls/__init__.py 0000664 0000000 0000000 00000000214 14370413656 0022423 0 ustar 00root root 0000000 0000000 from napari._qt.layer_controls.qt_layer_controls_container import (
QtLayerControlsContainer,
)
__all__ = ["QtLayerControlsContainer"]
napari-0.5.0a1/napari/_qt/layer_controls/_tests/ 0000775 0000000 0000000 00000000000 14370413656 0021616 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/layer_controls/_tests/__init__.py 0000664 0000000 0000000 00000000000 14370413656 0023715 0 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/layer_controls/_tests/test_qt_image_base_layer_.py 0000664 0000000 0000000 00000013601 14370413656 0027343 0 ustar 00root root 0000000 0000000 import os
from unittest.mock import patch
import numpy as np
import pytest
from qtpy.QtCore import Qt
from qtpy.QtWidgets import QPushButton
from napari._qt.layer_controls.qt_image_controls_base import (
QContrastLimitsPopup,
QRangeSliderPopup,
QtBaseImageControls,
QtLayerControls,
range_to_decimals,
)
from napari.layers import Image, Surface
_IMAGE = np.arange(100).astype(np.uint16).reshape((10, 10))
_SURF = (
np.random.random((10, 2)),
np.random.randint(10, size=(6, 3)),
np.arange(100).astype(float),
)
@pytest.mark.parametrize('layer', [Image(_IMAGE), Surface(_SURF)])
def test_base_controls_creation(qtbot, layer):
"""Check basic creation of QtBaseImageControls works"""
qtctrl = QtBaseImageControls(layer)
qtbot.addWidget(qtctrl)
original_clims = tuple(layer.contrast_limits)
slider_clims = qtctrl.contrastLimitsSlider.value()
assert slider_clims[0] == 0
assert slider_clims[1] == 99
assert tuple(slider_clims) == original_clims
@patch.object(QRangeSliderPopup, 'show')
@pytest.mark.parametrize('layer', [Image(_IMAGE), Surface(_SURF)])
def test_clim_right_click_shows_popup(mock_show, qtbot, layer):
"""Right clicking on the contrast limits slider should show a popup."""
qtctrl = QtBaseImageControls(layer)
qtbot.addWidget(qtctrl)
qtbot.mousePress(qtctrl.contrastLimitsSlider, Qt.RightButton)
assert hasattr(qtctrl, 'clim_popup')
# this mock doesn't seem to be working on cirrus windows
# but it works on local windows tests...
if not (os.name == 'nt' and os.getenv("CI")):
mock_show.assert_called_once()
@pytest.mark.parametrize('layer', [Image(_IMAGE), Surface(_SURF)])
def test_changing_model_updates_view(qtbot, layer):
"""Changing the model attribute should update the view"""
qtctrl = QtBaseImageControls(layer)
qtbot.addWidget(qtctrl)
new_clims = (20, 40)
layer.contrast_limits = new_clims
assert tuple(qtctrl.contrastLimitsSlider.value()) == new_clims
@patch.object(QRangeSliderPopup, 'show')
@pytest.mark.parametrize(
'layer', [Image(_IMAGE), Image(_IMAGE.astype(np.int32)), Surface(_SURF)]
)
def test_range_popup_clim_buttons(mock_show, qtbot, qapp, layer):
"""The buttons in the clim_popup should adjust the contrast limits value"""
qtctrl = QtBaseImageControls(layer)
qtbot.addWidget(qtctrl)
original_clims = tuple(layer.contrast_limits)
layer.contrast_limits = (20, 40)
qtbot.mousePress(qtctrl.contrastLimitsSlider, Qt.RightButton)
# pressing the reset button returns the clims to the default values
reset_button = qtctrl.clim_popup.findChild(
QPushButton, "reset_clims_button"
)
reset_button.click()
qapp.processEvents()
assert tuple(qtctrl.contrastLimitsSlider.value()) == original_clims
rangebtn = qtctrl.clim_popup.findChild(
QPushButton, "full_clim_range_button"
)
# data in this test is uint16 or int32 for Image, and float for Surface.
# Surface will not have a "full range button"
if np.issubdtype(layer.dtype, np.integer):
info = np.iinfo(layer.dtype)
rangebtn.click()
qapp.processEvents()
assert tuple(layer.contrast_limits_range) == (info.min, info.max)
min_ = qtctrl.contrastLimitsSlider.minimum()
max_ = qtctrl.contrastLimitsSlider.maximum()
assert (min_, max_) == (info.min, info.max)
else:
assert rangebtn is None
@pytest.mark.parametrize('mag', list(range(-16, 16, 4)))
def test_clim_slider_step_size_and_precision(qtbot, mag):
"""Make sure the slider has a reasonable step size and precision.
...across a broad range of orders of magnitude.
"""
layer = Image(np.random.rand(20, 20) * 10**mag)
popup = QContrastLimitsPopup(layer)
qtbot.addWidget(popup)
# scale precision with the log of the data range order of magnitude
# eg. 0 - 1 (0 order of mag) -> 3 decimal places
# 0 - 10 (1 order of mag) -> 2 decimals
# 0 - 100 (2 orders of mag) -> 1 decimal
# ≥ 3 orders of mag -> no decimals
# no more than 64 decimals
decimals = range_to_decimals(layer.contrast_limits, layer.dtype)
assert popup.slider.decimals() == decimals
# the slider step size should also be inversely proportional to the data
# range, with 1000 steps across the data range
assert popup.slider.singleStep() == 10**-decimals
def test_qt_image_controls_change_contrast(qtbot):
layer = Image(np.random.rand(8, 8))
qtctrl = QtBaseImageControls(layer)
qtbot.addWidget(qtctrl)
qtctrl.contrastLimitsSlider.setValue((0.1, 0.8))
assert tuple(layer.contrast_limits) == (0.1, 0.8)
def test_tensorstore_clim_popup():
"""Regression to test, makes sure it works with tensorstore dtype"""
ts = pytest.importorskip('tensorstore')
layer = Image(ts.array(np.random.rand(20, 20)))
QContrastLimitsPopup(layer)
def test_blending_opacity_slider(qtbot):
"""Tests whether opacity slider is disabled for minimum and opaque blending."""
layer = Image(np.random.rand(8, 8))
qtctrl = QtLayerControls(layer)
qtbot.addWidget(qtctrl)
assert layer.blending == 'translucent'
# check that the opacity slider is present by default
assert qtctrl.opacitySlider.isEnabled()
# set minimum blending, the opacity slider should be disabled
layer.blending = 'minimum'
assert not qtctrl.opacitySlider.isEnabled()
# set the blending to 'additive' confirm the slider is enabled
layer.blending = 'additive'
assert layer.blending == 'additive'
assert qtctrl.opacitySlider.isEnabled()
# set opaque blending, the opacity slider should be disabled
layer.blending = 'opaque'
assert layer.blending == 'opaque'
assert not qtctrl.opacitySlider.isEnabled()
# set the blending back to 'translucent' confirm the slider is enabled
layer.blending = 'translucent'
assert layer.blending == 'translucent'
assert qtctrl.opacitySlider.isEnabled()
napari-0.5.0a1/napari/_qt/layer_controls/_tests/test_qt_image_layer.py 0000664 0000000 0000000 00000011023 14370413656 0026206 0 ustar 00root root 0000000 0000000 import numpy as np
from napari._qt.layer_controls.qt_image_controls import QtImageControls
from napari.layers import Image
def test_interpolation_combobox(qtbot):
"""Changing the model attribute should update the view"""
layer = Image(np.random.rand(8, 8))
qtctrl = QtImageControls(layer)
qtbot.addWidget(qtctrl)
combo = qtctrl.interpComboBox
opts = {combo.itemText(i) for i in range(combo.count())}
assert opts == {'cubic', 'linear', 'kaiser', 'nearest', 'spline36'}
# programmatically adding approved interpolation works
layer.interpolation2d = 'lanczos'
assert combo.findText('lanczos') == 5
def test_rendering_combobox(qtbot):
"""Changing the model attribute should update the view"""
layer = Image(np.random.rand(8, 8))
qtctrl = QtImageControls(layer)
qtbot.addWidget(qtctrl)
combo = qtctrl.renderComboBox
opts = {combo.itemText(i) for i in range(combo.count())}
rendering_options = {
'translucent',
'additive',
'iso',
'mip',
'minip',
'attenuated_mip',
'average',
}
assert opts == rendering_options
# programmatically updating rendering mode updates the combobox
layer.rendering = 'iso'
assert combo.findText('iso') == combo.currentIndex()
def test_depiction_combobox_changes(qtbot):
"""Changing the model attribute should update the view."""
layer = Image(np.random.rand(10, 15, 20))
qtctrl = QtImageControls(layer)
qtctrl.ndisplay = 3
qtbot.addWidget(qtctrl)
combo_box = qtctrl.depictionComboBox
opts = {combo_box.itemText(i) for i in range(combo_box.count())}
depiction_options = {
'volume',
'plane',
}
assert opts == depiction_options
layer.depiction = 'plane'
assert combo_box.findText('plane') == combo_box.currentIndex()
layer.depiction = 'volume'
assert combo_box.findText('volume') == combo_box.currentIndex()
def test_plane_controls_show_hide_on_depiction_change(qtbot):
"""Changing depiction mode should show/hide plane controls in 3D."""
layer = Image(np.random.rand(10, 15, 20))
qtctrl = QtImageControls(layer)
qtbot.addWidget(qtctrl)
qtctrl.ndisplay = 3
layer.depiction = 'volume'
assert qtctrl.planeThicknessSlider.isHidden()
assert qtctrl.planeThicknessLabel.isHidden()
assert qtctrl.planeNormalButtons.isHidden()
assert qtctrl.planeNormalLabel.isHidden()
layer.depiction = 'plane'
assert not qtctrl.planeThicknessSlider.isHidden()
assert not qtctrl.planeThicknessLabel.isHidden()
assert not qtctrl.planeNormalButtons.isHidden()
assert not qtctrl.planeNormalLabel.isHidden()
def test_plane_controls_show_hide_on_ndisplay_change(qtbot):
"""Changing ndisplay should show/hide plane controls if depicting a plane."""
layer = Image(np.random.rand(10, 15, 20))
layer.depiction = 'plane'
qtctrl = QtImageControls(layer)
qtbot.addWidget(qtctrl)
assert qtctrl.ndisplay == 2
assert qtctrl.planeThicknessSlider.isHidden()
assert qtctrl.planeThicknessLabel.isHidden()
assert qtctrl.planeNormalButtons.isHidden()
assert qtctrl.planeNormalLabel.isHidden()
qtctrl.ndisplay = 3
assert not qtctrl.planeThicknessSlider.isHidden()
assert not qtctrl.planeThicknessLabel.isHidden()
assert not qtctrl.planeNormalButtons.isHidden()
assert not qtctrl.planeNormalLabel.isHidden()
def test_plane_slider_value_change(qtbot):
"""Changing the model should update the view."""
layer = Image(np.random.rand(10, 15, 20))
qtctrl = QtImageControls(layer)
qtbot.addWidget(qtctrl)
layer.plane.thickness *= 2
assert qtctrl.planeThicknessSlider.value() == layer.plane.thickness
def test_auto_contrast_buttons(qtbot):
layer = Image(np.arange(8**3).reshape(8, 8, 8), contrast_limits=(0, 1))
qtctrl = QtImageControls(layer)
qtbot.addWidget(qtctrl)
assert layer.contrast_limits == [0, 1]
qtctrl.autoScaleBar._once_btn.click()
assert layer.contrast_limits == [0, 63]
# change slice
layer._slice_dims((1, 8, 8))
# hasn't changed yet
assert layer.contrast_limits == [0, 63]
# with auto_btn, it should always change
qtctrl.autoScaleBar._auto_btn.click()
assert layer.contrast_limits == [64, 127]
layer._slice_dims((2, 8, 8))
assert layer.contrast_limits == [128, 191]
layer._slice_dims((3, 8, 8))
assert layer.contrast_limits == [192, 255]
# once button turns off continuous
qtctrl.autoScaleBar._once_btn.click()
layer._slice_dims((4, 8, 8))
assert layer.contrast_limits == [192, 255]
napari-0.5.0a1/napari/_qt/layer_controls/_tests/test_qt_labels_layer.py 0000664 0000000 0000000 00000004222 14370413656 0026371 0 ustar 00root root 0000000 0000000 import numpy as np
from napari._qt.layer_controls.qt_labels_controls import QtLabelsControls
from napari.layers import Labels
from napari.utils.colormaps import colormap_utils
np.random.seed(0)
_LABELS = np.random.randint(5, size=(10, 15))
_COLOR = {1: 'white', 2: 'blue', 3: 'green', 4: 'red', 5: 'yellow'}
def test_changing_layer_color_mode_updates_combo_box(qtbot):
"""Updating layer color mode changes the combo box selection"""
layer = Labels(_LABELS, color=_COLOR)
qtctrl = QtLabelsControls(layer)
qtbot.addWidget(qtctrl)
original_color_mode = layer.color_mode
assert original_color_mode == qtctrl.colorModeComboBox.currentText()
layer.color_mode = 'auto'
assert layer.color_mode == qtctrl.colorModeComboBox.currentText()
def test_rendering_combobox(qtbot):
"""Changing the model attribute should update the view"""
layer = Labels(_LABELS)
qtctrl = QtLabelsControls(layer)
qtbot.addWidget(qtctrl)
combo = qtctrl.renderComboBox
opts = {combo.itemText(i) for i in range(combo.count())}
rendering_options = {'translucent', 'iso_categorical'}
assert opts == rendering_options
# programmatically updating rendering mode updates the combobox
new_mode = 'iso_categorical'
layer.rendering = new_mode
assert combo.findText(new_mode) == combo.currentIndex()
def test_changing_colormap_updates_colorbox(qtbot):
"""Test that changing the colormap on a layer will update color swatch in the combo box"""
layer = Labels(_LABELS, color=_COLOR)
qtctrl = QtLabelsControls(layer)
qtbot.addWidget(qtctrl)
color_box = qtctrl.colorBox
layer.selected_label = 1
# For a paint event, which does not occur in a headless qtbot
color_box.paintEvent(None)
np.testing.assert_equal(
color_box.color,
np.round(np.asarray(layer._selected_color) * 255 * layer.opacity),
)
layer.colormap = colormap_utils.label_colormap(num_colors=5)
# For a paint event, which does not occur in a headless qtbot
color_box.paintEvent(None)
np.testing.assert_equal(
color_box.color,
np.round(np.asarray(layer._selected_color) * 255 * layer.opacity),
)
napari-0.5.0a1/napari/_qt/layer_controls/_tests/test_qt_layer_controls.py 0000664 0000000 0000000 00000011041 14370413656 0026767 0 ustar 00root root 0000000 0000000 from collections import namedtuple
import numpy as np
import pytest
from qtpy.QtWidgets import QAbstractButton
from napari._qt.layer_controls.qt_layer_controls_container import (
create_qt_layer_controls,
layer_to_controls,
)
from napari._qt.layer_controls.qt_shapes_controls import QtShapesControls
from napari.layers import Labels, Points, Shapes
LayerTypeWithData = namedtuple('LayerTypeWithData', ['type', 'data'])
_POINTS = LayerTypeWithData(type=Points, data=np.random.random((5, 2)))
_SHAPES = LayerTypeWithData(type=Shapes, data=np.random.random((10, 4, 2)))
_LINES_DATA = np.random.random((6, 2, 2))
def test_create_shape(qtbot):
shapes = _SHAPES.type(_SHAPES.data)
ctrl = create_qt_layer_controls(shapes)
qtbot.addWidget(ctrl)
assert isinstance(ctrl, QtShapesControls)
def test_unknown_raises(qtbot):
class Test:
"""Unmatched class"""
with pytest.raises(TypeError):
create_qt_layer_controls(Test())
def test_inheritance(qtbot):
class QtLinesControls(QtShapesControls):
"""Yes I'm the same"""
class Lines(Shapes):
"""Here too"""
lines = Lines(_LINES_DATA)
layer_to_controls[Lines] = QtLinesControls
ctrl = create_qt_layer_controls(lines)
qtbot.addWidget(ctrl)
assert isinstance(ctrl, QtLinesControls)
@pytest.mark.parametrize('layer_type_with_data', [_POINTS, _SHAPES])
def test_text_set_visible_updates_checkbox(qtbot, layer_type_with_data):
text = {
'string': {'constant': 'test'},
'visible': True,
}
layer = layer_type_with_data.type(layer_type_with_data.data, text=text)
ctrl = create_qt_layer_controls(layer)
qtbot.addWidget(ctrl)
assert ctrl.textDispCheckBox.isChecked()
layer.text.visible = False
assert not ctrl.textDispCheckBox.isChecked()
@pytest.mark.parametrize('layer_type_with_data', [_POINTS, _SHAPES])
def test_set_text_then_set_visible_updates_checkbox(
qtbot, layer_type_with_data
):
layer = layer_type_with_data.type(layer_type_with_data.data)
ctrl = create_qt_layer_controls(layer)
qtbot.addWidget(ctrl)
layer.text = {
'string': {'constant': 'another_test'},
'visible': False,
}
assert not ctrl.textDispCheckBox.isChecked()
layer.text.visible = True
assert ctrl.textDispCheckBox.isChecked()
# The following tests handle changes to the layer's visible and
# editable state for layer control types that have controls to edit
# the layer. For more context see:
# https://github.com/napari/napari/issues/1346
@pytest.fixture(
params=(
(Labels, np.zeros((3, 4), dtype=int)),
(Points, np.empty((0, 2))),
(Shapes, np.empty((0, 2, 4))),
)
)
def editable_layer(request):
LayerType, data = request.param
return LayerType(data)
def test_make_visible_when_editable_enables_edit_buttons(
qtbot, editable_layer
):
editable_layer.editable = True
editable_layer.visible = False
controls = make_layer_controls(qtbot, editable_layer)
assert_no_edit_buttons_enabled(controls)
editable_layer.visible = True
assert_all_edit_buttons_enabled(controls)
def test_make_not_visible_when_editable_disables_edit_buttons(
qtbot, editable_layer
):
editable_layer.editable = True
editable_layer.visible = True
controls = make_layer_controls(qtbot, editable_layer)
assert_all_edit_buttons_enabled(controls)
editable_layer.visible = False
assert_no_edit_buttons_enabled(controls)
def test_make_editable_when_visible_enables_edit_buttons(
qtbot, editable_layer
):
editable_layer.editable = False
editable_layer.visible = True
controls = make_layer_controls(qtbot, editable_layer)
assert_no_edit_buttons_enabled(controls)
editable_layer.editable = True
assert_all_edit_buttons_enabled(controls)
def test_make_not_editable_when_visible_disables_edit_buttons(
qtbot, editable_layer
):
editable_layer.editable = True
editable_layer.visible = True
controls = make_layer_controls(qtbot, editable_layer)
assert_all_edit_buttons_enabled(controls)
editable_layer.editable = False
assert_no_edit_buttons_enabled(controls)
def make_layer_controls(qtbot, layer):
QtLayerControlsType = layer_to_controls[type(layer)]
controls = QtLayerControlsType(layer)
qtbot.addWidget(controls)
return controls
def assert_all_edit_buttons_enabled(controls) -> None:
assert all(map(QAbstractButton.isEnabled, controls._EDIT_BUTTONS))
def assert_no_edit_buttons_enabled(controls) -> None:
assert not any(map(QAbstractButton.isEnabled, controls._EDIT_BUTTONS))
napari-0.5.0a1/napari/_qt/layer_controls/_tests/test_qt_points_layer.py 0000664 0000000 0000000 00000006274 14370413656 0026454 0 ustar 00root root 0000000 0000000 import numpy as np
import pytest
from napari._qt.layer_controls.qt_points_controls import QtPointsControls
from napari.layers import Points
def test_out_of_slice_display_checkbox(qtbot):
"""Changing the model attribute should update the view"""
layer = Points(np.random.rand(10, 2))
qtctrl = QtPointsControls(layer)
qtbot.addWidget(qtctrl)
combo = qtctrl.outOfSliceCheckBox
assert layer.out_of_slice_display is False
combo.setChecked(True)
assert layer.out_of_slice_display is True
def test_current_size_display_in_range(qtbot):
"""Changing the model attribute should update the view"""
layer = Points(np.random.rand(10, 2))
qtctrl = QtPointsControls(layer)
qtbot.addWidget(qtctrl)
slider = qtctrl.sizeSlider
slider.setValue(10)
# Initial values
assert slider.maximum() == 100
assert slider.minimum() == 1
assert slider.value() == 10
assert layer.current_size == 10
# Size event needs to be triggered manually, because no points are selected.
layer.current_size = 5
layer.events.size()
assert slider.maximum() == 100
assert slider.minimum() == 1
assert slider.value() == 5
assert layer.current_size == 5
# Size event needs to be triggered manually, because no points are selected.
layer.current_size = 100
layer.events.size()
assert slider.maximum() == 100
assert slider.minimum() == 1
assert slider.value() == 100
assert layer.current_size == 100
# Size event needs to be triggered manually, because no points are selected.
layer.current_size = 200
layer.events.size()
assert slider.maximum() == 201
assert slider.minimum() == 1
assert slider.value() == 200
assert layer.current_size == 200
# Size event needs to be triggered manually, because no points are selected.
with pytest.warns(RuntimeWarning):
layer.current_size = -1000
layer.events.size()
assert slider.maximum() == 201
assert slider.minimum() == 1
assert slider.value() == 200
assert layer.current_size == 200
layer.current_size = [20, 20]
layer.events.size()
assert slider.maximum() == 201
assert slider.minimum() == 1
assert slider.value() == 200
assert layer.current_size == [20, 20]
with pytest.warns(RuntimeWarning):
layer.current_size = [20, -20]
layer.events.size()
assert slider.maximum() == 201
assert slider.minimum() == 1
assert slider.value() == 200
assert layer.current_size == [20, 20]
def test_current_size_slider_properly_initialized(qtbot):
"""Changing the model attribute should update the view"""
layer = Points(np.random.rand(10, 2), size=np.linspace(-2, 200, 10))
qtctrl = QtPointsControls(layer)
qtbot.addWidget(qtctrl)
slider = qtctrl.sizeSlider
assert slider.maximum() == 201
assert slider.minimum() == 1
assert slider.value() == 10
assert layer.current_size == 10
layer = Points(np.random.rand(10, 2), size=np.linspace(-2, 50, 10))
qtctrl = QtPointsControls(layer)
qtbot.addWidget(qtctrl)
slider = qtctrl.sizeSlider
assert slider.maximum() == 100
assert slider.minimum() == 1
assert slider.value() == 10
assert layer.current_size == 10
napari-0.5.0a1/napari/_qt/layer_controls/_tests/test_qt_shapes_layer.py 0000664 0000000 0000000 00000002502 14370413656 0026411 0 ustar 00root root 0000000 0000000 import numpy as np
from napari._qt.layer_controls.qt_shapes_controls import QtShapesControls
from napari.layers import Shapes
from napari.utils.colormaps.standardize_color import transform_color
_SHAPES = np.random.random((10, 4, 2))
def test_shape_controls_face_color(qtbot):
"""Check updating of face color updates QtShapesControls."""
layer = Shapes(_SHAPES)
qtctrl = QtShapesControls(layer)
qtbot.addWidget(qtctrl)
target_color = transform_color(layer.current_face_color)[0]
np.testing.assert_almost_equal(qtctrl.faceColorEdit.color, target_color)
# Update current face color
layer.current_face_color = 'red'
target_color = transform_color(layer.current_face_color)[0]
np.testing.assert_almost_equal(qtctrl.faceColorEdit.color, target_color)
def test_shape_controls_edge_color(qtbot):
"""Check updating of edge color updates QtShapesControls."""
layer = Shapes(_SHAPES)
qtctrl = QtShapesControls(layer)
qtbot.addWidget(qtctrl)
target_color = transform_color(layer.current_edge_color)[0]
np.testing.assert_almost_equal(qtctrl.edgeColorEdit.color, target_color)
# Update current edge color
layer.current_edge_color = 'red'
target_color = transform_color(layer.current_edge_color)[0]
np.testing.assert_almost_equal(qtctrl.edgeColorEdit.color, target_color)
napari-0.5.0a1/napari/_qt/layer_controls/_tests/test_qt_tracks_layer.py 0000664 0000000 0000000 00000002650 14370413656 0026421 0 ustar 00root root 0000000 0000000 import numpy as np
import pytest
from qtpy.QtCore import Qt
from napari._qt.layer_controls.qt_tracks_controls import QtTracksControls
from napari.layers import Tracks
_TRACKS = np.zeros((2, 4))
_PROPERTIES = {'speed': [50, 30], 'time': [0, 1]}
def test_tracks_controls_color_by(qtbot):
"""Check updating of the color_by combobox."""
inital_color_by = 'time'
with pytest.warns(UserWarning) as wrn:
layer = Tracks(
_TRACKS, properties=_PROPERTIES, color_by=inital_color_by
)
assert "Previous color_by key 'time' not present" in str(wrn[0].message)
qtctrl = QtTracksControls(layer)
qtbot.addWidget(qtctrl)
# verify the color_by argument is initialized correctly
assert layer.color_by == inital_color_by
assert qtctrl.color_by_combobox.currentText() == inital_color_by
# update color_by from the layer model
layer_update_color_by = 'speed'
layer.color_by = layer_update_color_by
assert layer.color_by == layer_update_color_by
assert qtctrl.color_by_combobox.currentText() == layer_update_color_by
# update color_by from the qt controls
qt_update_color_by = 'track_id'
speed_index = qtctrl.color_by_combobox.findText(
qt_update_color_by, Qt.MatchFixedString
)
qtctrl.color_by_combobox.setCurrentIndex(speed_index)
assert layer.color_by == qt_update_color_by
assert qtctrl.color_by_combobox.currentText() == qt_update_color_by
napari-0.5.0a1/napari/_qt/layer_controls/qt_colormap_combobox.py 0000664 0000000 0000000 00000004511 14370413656 0025100 0 ustar 00root root 0000000 0000000 from qtpy.QtCore import QModelIndex, QRect
from qtpy.QtGui import QImage, QPainter
from qtpy.QtWidgets import (
QComboBox,
QListView,
QStyledItemDelegate,
QStyleOptionViewItem,
)
from napari.utils.colormaps import (
display_name_to_name,
ensure_colormap,
make_colorbar,
)
COLORMAP_WIDTH = 50
TEXT_WIDTH = 130
ENTRY_HEIGHT = 20
PADDING = 1
class ColorStyledDelegate(QStyledItemDelegate):
"""Class for paint :py:class:`~.ColorComboBox` elements when list trigger
Parameters
----------
base_height : int
Height of single list element.
color_dict: dict
Dict mapping name to colors.
"""
def __init__(self, base_height: int, **kwargs) -> None:
super().__init__(**kwargs)
self.base_height = base_height
def paint(
self,
painter: QPainter,
style: QStyleOptionViewItem,
model: QModelIndex,
):
style2 = QStyleOptionViewItem(style)
cbar_rect = QRect(
style.rect.x(),
style.rect.y() + PADDING,
style.rect.width() - TEXT_WIDTH,
style.rect.height() - 2 * PADDING,
)
text_rect = QRect(
style.rect.width() - TEXT_WIDTH,
style.rect.y() + PADDING,
style.rect.width(),
style.rect.height() - 2 * PADDING,
)
style2.rect = text_rect
super().paint(painter, style2, model)
name = display_name_to_name(model.data())
cbar = make_colorbar(ensure_colormap(name), (18, 100))
image = QImage(
cbar,
cbar.shape[1],
cbar.shape[0],
QImage.Format_RGBA8888,
)
painter.drawImage(cbar_rect, image)
def sizeHint(self, style: QStyleOptionViewItem, model: QModelIndex):
res = super().sizeHint(style, model)
res.setHeight(self.base_height)
res.setWidth(max(500, res.width()))
return res
class QtColormapComboBox(QComboBox):
"""Combobox showing colormaps
Parameters
----------
parent : QWidget
Parent widget of comboxbox.
"""
def __init__(self, parent) -> None:
super().__init__(parent)
view = QListView()
view.setMinimumWidth(COLORMAP_WIDTH + TEXT_WIDTH)
view.setItemDelegate(ColorStyledDelegate(ENTRY_HEIGHT))
self.setView(view)
napari-0.5.0a1/napari/_qt/layer_controls/qt_image_controls.py 0000664 0000000 0000000 00000037262 14370413656 0024412 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING
from qtpy.QtCore import Qt
from qtpy.QtWidgets import (
QComboBox,
QHBoxLayout,
QLabel,
QPushButton,
QSlider,
QWidget,
)
from superqt import QLabeledDoubleSlider
from napari._qt.layer_controls.qt_image_controls_base import (
QtBaseImageControls,
)
from napari._qt.utils import qt_signals_blocked
from napari._qt.widgets._slider_compat import QDoubleSlider
from napari.layers.image._image_constants import (
ImageRendering,
Interpolation,
VolumeDepiction,
)
from napari.utils.action_manager import action_manager
from napari.utils.translations import trans
if TYPE_CHECKING:
import napari.layers
class QtImageControls(QtBaseImageControls):
"""Qt view and controls for the napari Image layer.
Parameters
----------
layer : napari.layers.Image
An instance of a napari Image layer.
Attributes
----------
attenuationSlider : qtpy.QtWidgets.QSlider
Slider controlling attenuation rate for `attenuated_mip` mode.
attenuationLabel : qtpy.QtWidgets.QLabel
Label for the attenuation slider widget.
interpComboBox : qtpy.QtWidgets.QComboBox
Dropdown menu to select the interpolation mode for image display.
interpLabel : qtpy.QtWidgets.QLabel
Label for the interpolation dropdown menu.
isoThresholdSlider : qtpy.QtWidgets.QSlider
Slider controlling the isosurface threshold value for rendering.
isoThresholdLabel : qtpy.QtWidgets.QLabel
Label for the isosurface threshold slider widget.
layer : napari.layers.Image
An instance of a napari Image layer.
renderComboBox : qtpy.QtWidgets.QComboBox
Dropdown menu to select the rendering mode for image display.
renderLabel : qtpy.QtWidgets.QLabel
Label for the rendering mode dropdown menu.
"""
layer: 'napari.layers.Image'
def __init__(self, layer) -> None:
super().__init__(layer)
self.layer.events.interpolation2d.connect(
self._on_interpolation_change
)
self.layer.events.interpolation3d.connect(
self._on_interpolation_change
)
self.layer.events.rendering.connect(self._on_rendering_change)
self.layer.events.iso_threshold.connect(self._on_iso_threshold_change)
self.layer.events.attenuation.connect(self._on_attenuation_change)
self.layer.events.depiction.connect(self._on_depiction_change)
self.layer.plane.events.thickness.connect(
self._on_plane_thickness_change
)
self.interpComboBox = QComboBox(self)
self.interpComboBox.currentTextChanged.connect(
self.changeInterpolation
)
self.interpLabel = QLabel(trans._('interpolation:'))
renderComboBox = QComboBox(self)
rendering_options = [i.value for i in ImageRendering]
renderComboBox.addItems(rendering_options)
index = renderComboBox.findText(
self.layer.rendering, Qt.MatchFlag.MatchFixedString
)
renderComboBox.setCurrentIndex(index)
renderComboBox.currentTextChanged.connect(self.changeRendering)
self.renderComboBox = renderComboBox
self.renderLabel = QLabel(trans._('rendering:'))
self.depictionComboBox = QComboBox(self)
depiction_options = [d.value for d in VolumeDepiction]
self.depictionComboBox.addItems(depiction_options)
index = self.depictionComboBox.findText(
self.layer.depiction, Qt.MatchFlag.MatchFixedString
)
self.depictionComboBox.setCurrentIndex(index)
self.depictionComboBox.currentTextChanged.connect(self.changeDepiction)
self.depictionLabel = QLabel(trans._('depiction:'))
# plane controls
self.planeNormalButtons = PlaneNormalButtons(self)
self.planeNormalLabel = QLabel(trans._('plane normal:'))
action_manager.bind_button(
'napari:orient_plane_normal_along_z',
self.planeNormalButtons.zButton,
)
action_manager.bind_button(
'napari:orient_plane_normal_along_y',
self.planeNormalButtons.yButton,
)
action_manager.bind_button(
'napari:orient_plane_normal_along_x',
self.planeNormalButtons.xButton,
)
action_manager.bind_button(
'napari:orient_plane_normal_along_view_direction',
self.planeNormalButtons.obliqueButton,
)
self.planeThicknessSlider = QLabeledDoubleSlider(
Qt.Orientation.Horizontal, self
)
self.planeThicknessLabel = QLabel(trans._('plane thickness:'))
self.planeThicknessSlider.setFocusPolicy(Qt.NoFocus)
self.planeThicknessSlider.setMinimum(1)
self.planeThicknessSlider.setMaximum(50)
self.planeThicknessSlider.setValue(self.layer.plane.thickness)
self.planeThicknessSlider.valueChanged.connect(
self.changePlaneThickness
)
sld = QDoubleSlider(Qt.Orientation.Horizontal, parent=self)
sld.setFocusPolicy(Qt.FocusPolicy.NoFocus)
cmin, cmax = self.layer.contrast_limits_range
sld.setMinimum(cmin)
sld.setMaximum(cmax)
sld.setValue(self.layer.iso_threshold)
sld.valueChanged.connect(self.changeIsoThreshold)
self.isoThresholdSlider = sld
self.isoThresholdLabel = QLabel(trans._('iso threshold:'))
sld = QSlider(Qt.Orientation.Horizontal, parent=self)
sld.setFocusPolicy(Qt.FocusPolicy.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.setValue(int(self.layer.attenuation * 200))
sld.valueChanged.connect(self.changeAttenuation)
self.attenuationSlider = sld
self.attenuationLabel = QLabel(trans._('attenuation:'))
self._on_ndisplay_changed()
colormap_layout = QHBoxLayout()
if hasattr(self.layer, 'rgb') and self.layer.rgb:
colormap_layout.addWidget(QLabel("RGB"))
self.colormapComboBox.setVisible(False)
self.colorbarLabel.setVisible(False)
else:
colormap_layout.addWidget(self.colorbarLabel)
colormap_layout.addWidget(self.colormapComboBox)
colormap_layout.addStretch(1)
self.layout().addRow(self.opacityLabel, self.opacitySlider)
self.layout().addRow(
trans._('contrast limits:'), self.contrastLimitsSlider
)
self.layout().addRow(trans._('auto-contrast:'), self.autoScaleBar)
self.layout().addRow(trans._('gamma:'), self.gammaSlider)
self.layout().addRow(trans._('colormap:'), colormap_layout)
self.layout().addRow(trans._('blending:'), self.blendComboBox)
self.layout().addRow(self.interpLabel, self.interpComboBox)
self.layout().addRow(self.depictionLabel, self.depictionComboBox)
self.layout().addRow(self.renderLabel, self.renderComboBox)
self.layout().addRow(self.isoThresholdLabel, self.isoThresholdSlider)
self.layout().addRow(self.attenuationLabel, self.attenuationSlider)
self.layout().addRow(self.planeNormalLabel, self.planeNormalButtons)
self.layout().addRow(
self.planeThicknessLabel, self.planeThicknessSlider
)
def changeInterpolation(self, text):
"""Change interpolation mode for image display.
Parameters
----------
text : str
Interpolation mode used by vispy. Must be one of our supported
modes:
'bessel', 'bicubic', 'linear', 'blackman', 'catrom', 'gaussian',
'hamming', 'hanning', 'hermite', 'kaiser', 'lanczos', 'mitchell',
'nearest', 'spline16', 'spline36'
"""
if self.ndisplay == 2:
self.layer.interpolation2d = text
else:
self.layer.interpolation3d = text
def changeRendering(self, text):
"""Change rendering mode for image display.
Parameters
----------
text : str
Rendering mode used by vispy.
Selects a preset rendering mode in vispy that determines how
volume is displayed:
* translucent: voxel colors are blended along the view ray until
the result is opaque.
* mip: maximum intensity projection. Cast a ray and display the
maximum value that was encountered.
* additive: voxel colors are added along the view ray until
the result is saturated.
* iso: isosurface. Cast a ray until a certain threshold is
encountered. At that location, lighning calculations are
performed to give the visual appearance of a surface.
* attenuated_mip: attenuated maximum intensity projection. Cast a
ray and attenuate values based on integral of encountered values,
display the maximum value that was encountered after attenuation.
This will make nearer objects appear more prominent.
"""
self.layer.rendering = text
self._update_rendering_parameter_visibility()
def changeDepiction(self, text):
self.layer.depiction = text
self._update_plane_parameter_visibility()
def changePlaneThickness(self, value: float):
self.layer.plane.thickness = value
def changeIsoThreshold(self, value):
"""Change isosurface threshold on the layer model.
Parameters
----------
value : float
Threshold for isosurface.
"""
with self.layer.events.blocker(self._on_iso_threshold_change):
self.layer.iso_threshold = value
def _on_contrast_limits_change(self):
with self.layer.events.blocker(self._on_iso_threshold_change):
cmin, cmax = self.layer.contrast_limits_range
self.isoThresholdSlider.setMinimum(cmin)
self.isoThresholdSlider.setMaximum(cmax)
return super()._on_contrast_limits_change()
def _on_iso_threshold_change(self):
"""Receive layer model isosurface change event and update the slider."""
with self.layer.events.iso_threshold.blocker():
self.isoThresholdSlider.setValue(self.layer.iso_threshold)
def changeAttenuation(self, value):
"""Change attenuation rate for attenuated maximum intensity projection.
Parameters
----------
value : Float
Attenuation rate for attenuated maximum intensity projection.
"""
with self.layer.events.blocker(self._on_attenuation_change):
self.layer.attenuation = value / 200
def _on_attenuation_change(self):
"""Receive layer model attenuation change event and update the slider."""
with self.layer.events.attenuation.blocker():
self.attenuationSlider.setValue(int(self.layer.attenuation * 200))
def _on_interpolation_change(self, event):
"""Receive layer interpolation change event and update dropdown menu.
Parameters
----------
event : napari.utils.event.Event
The napari event that triggered this method.
"""
interp_string = event.value.value
with self.layer.events.interpolation.blocker(), self.layer.events.interpolation2d.blocker(), self.layer.events.interpolation3d.blocker():
if self.interpComboBox.findText(interp_string) == -1:
self.interpComboBox.addItem(interp_string)
self.interpComboBox.setCurrentText(interp_string)
def _on_rendering_change(self):
"""Receive layer model rendering change event and update dropdown menu."""
with self.layer.events.rendering.blocker():
index = self.renderComboBox.findText(
self.layer.rendering, Qt.MatchFlag.MatchFixedString
)
self.renderComboBox.setCurrentIndex(index)
self._update_rendering_parameter_visibility()
def _on_depiction_change(self):
"""Receive layer model depiction change event and update combobox."""
with self.layer.events.depiction.blocker():
index = self.depictionComboBox.findText(
self.layer.depiction, Qt.MatchFlag.MatchFixedString
)
self.depictionComboBox.setCurrentIndex(index)
self._update_plane_parameter_visibility()
def _on_plane_thickness_change(self):
with self.layer.plane.events.blocker():
self.planeThicknessSlider.setValue(self.layer.plane.thickness)
def _update_rendering_parameter_visibility(self):
"""Hide isosurface rendering parameters if they aren't needed."""
rendering = ImageRendering(self.layer.rendering)
iso_threshold_visible = rendering == ImageRendering.ISO
self.isoThresholdLabel.setVisible(iso_threshold_visible)
self.isoThresholdSlider.setVisible(iso_threshold_visible)
attenuation_visible = rendering == ImageRendering.ATTENUATED_MIP
self.attenuationSlider.setVisible(attenuation_visible)
self.attenuationLabel.setVisible(attenuation_visible)
def _update_plane_parameter_visibility(self):
"""Hide plane rendering controls if they aren't needed."""
depiction = VolumeDepiction(self.layer.depiction)
visible = depiction == VolumeDepiction.PLANE and self.ndisplay == 3
self.planeNormalButtons.setVisible(visible)
self.planeNormalLabel.setVisible(visible)
self.planeThicknessSlider.setVisible(visible)
self.planeThicknessLabel.setVisible(visible)
def _update_interpolation_combo(self):
interp_names = [i.value for i in Interpolation.view_subset()]
interp = (
self.layer.interpolation2d
if self.ndisplay == 2
else self.layer.interpolation3d
)
with qt_signals_blocked(self.interpComboBox):
self.interpComboBox.clear()
self.interpComboBox.addItems(interp_names)
self.interpComboBox.setCurrentText(interp)
def _on_ndisplay_changed(self):
"""Update widget visibility based on 2D and 3D visualization modes."""
self._update_interpolation_combo()
self._update_plane_parameter_visibility()
if self.ndisplay == 2:
self.isoThresholdSlider.hide()
self.isoThresholdLabel.hide()
self.attenuationSlider.hide()
self.attenuationLabel.hide()
self.renderComboBox.hide()
self.renderLabel.hide()
self.depictionComboBox.hide()
self.depictionLabel.hide()
else:
self.renderComboBox.show()
self.renderLabel.show()
self._update_rendering_parameter_visibility()
self.depictionComboBox.show()
self.depictionLabel.show()
class PlaneNormalButtons(QWidget):
"""Qt buttons for controlling plane orientation.
Attributes
----------
xButton : qtpy.QtWidgets.QPushButton
Button which orients a plane normal along the x axis.
yButton : qtpy.QtWidgets.QPushButton
Button which orients a plane normal along the y axis.
zButton : qtpy.QtWidgets.QPushButton
Button which orients a plane normal along the z axis.
obliqueButton : qtpy.QtWidgets.QPushButton
Button which orients a plane normal along the camera view direction.
"""
def __init__(self, parent=None) -> None:
super().__init__(parent=parent)
self.setLayout(QHBoxLayout())
self.layout().setSpacing(2)
self.layout().setContentsMargins(0, 0, 0, 0)
self.xButton = QPushButton('x')
self.yButton = QPushButton('y')
self.zButton = QPushButton('z')
self.obliqueButton = QPushButton(trans._('oblique'))
self.layout().addWidget(self.xButton)
self.layout().addWidget(self.yButton)
self.layout().addWidget(self.zButton)
self.layout().addWidget(self.obliqueButton)
napari-0.5.0a1/napari/_qt/layer_controls/qt_image_controls_base.py 0000664 0000000 0000000 00000026205 14370413656 0025377 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
import numpy as np
from qtpy.QtCore import Qt
from qtpy.QtGui import QImage, QPixmap
from qtpy.QtWidgets import QHBoxLayout, QLabel, QPushButton, QWidget
from superqt import QDoubleRangeSlider
from napari._qt.layer_controls.qt_colormap_combobox import QtColormapComboBox
from napari._qt.layer_controls.qt_layer_controls_base import QtLayerControls
from napari._qt.utils import qt_signals_blocked
from napari._qt.widgets._slider_compat import QDoubleSlider
from napari._qt.widgets.qt_range_slider_popup import QRangeSliderPopup
from napari.utils._dtype import normalize_dtype
from napari.utils.colormaps import AVAILABLE_COLORMAPS
from napari.utils.events.event_utils import connect_no_arg, connect_setattr
from napari.utils.translations import trans
if TYPE_CHECKING:
from napari.layers import Image
class _QDoubleRangeSlider(QDoubleRangeSlider):
def mousePressEvent(self, event):
"""Update the slider, or, on right-click, pop-up an expanded slider.
The expanded slider provides finer control, directly editable values,
and the ability to change the available range of the sliders.
Parameters
----------
event : napari.utils.event.Event
The napari event that triggered this method.
"""
if event.button() == Qt.MouseButton.RightButton:
self.parent().show_clim_popupup()
else:
super().mousePressEvent(event)
class QtBaseImageControls(QtLayerControls):
"""Superclass for classes requiring colormaps, contrast & gamma sliders.
This class is never directly instantiated anywhere.
It is subclassed by QtImageControls and QtSurfaceControls.
Parameters
----------
layer : napari.layers.Layer
An instance of a napari layer.
Attributes
----------
clim_popup : napari._qt.qt_range_slider_popup.QRangeSliderPopup
Popup widget launching the contrast range slider.
colorbarLabel : qtpy.QtWidgets.QLabel
Label text of colorbar widget.
colormapComboBox : qtpy.QtWidgets.QComboBox
Dropdown widget for selecting the layer colormap.
contrastLimitsSlider : superqt.QRangeSlider
Contrast range slider widget.
gammaSlider : qtpy.QtWidgets.QSlider
Gamma adjustment slider widget.
layer : napari.layers.Layer
An instance of a napari layer.
"""
def __init__(self, layer: Image) -> None:
super().__init__(layer)
self.layer.events.colormap.connect(self._on_colormap_change)
self.layer.events.gamma.connect(self._on_gamma_change)
self.layer.events.contrast_limits.connect(
self._on_contrast_limits_change
)
self.layer.events.contrast_limits_range.connect(
self._on_contrast_limits_range_change
)
comboBox = QtColormapComboBox(self)
comboBox.setObjectName("colormapComboBox")
comboBox._allitems = set(self.layer.colormaps)
for name, cm in AVAILABLE_COLORMAPS.items():
if name in self.layer.colormaps:
comboBox.addItem(cm._display_name, name)
comboBox.currentTextChanged.connect(self.changeColor)
self.colormapComboBox = comboBox
# Create contrast_limits slider
self.contrastLimitsSlider = _QDoubleRangeSlider(
Qt.Orientation.Horizontal, self
)
decimals = range_to_decimals(
self.layer.contrast_limits_range, self.layer.dtype
)
self.contrastLimitsSlider.setRange(*self.layer.contrast_limits_range)
self.contrastLimitsSlider.setSingleStep(10**-decimals)
self.contrastLimitsSlider.setValue(self.layer.contrast_limits)
self.contrastLimitsSlider.setToolTip(
trans._('Right click for detailed slider popup.')
)
self.clim_popup = None
connect_setattr(
self.contrastLimitsSlider.valueChanged,
self.layer,
"contrast_limits",
)
connect_setattr(
self.contrastLimitsSlider.rangeChanged,
self.layer,
'contrast_limits_range',
)
self.autoScaleBar = AutoScaleButtons(layer, self)
# gamma slider
sld = QDoubleSlider(Qt.Orientation.Horizontal, parent=self)
sld.setMinimum(0.2)
sld.setMaximum(2)
sld.setSingleStep(0.02)
sld.setValue(self.layer.gamma)
connect_setattr(sld.valueChanged, self.layer, 'gamma')
self.gammaSlider = sld
self.colorbarLabel = QLabel(parent=self)
self.colorbarLabel.setObjectName('colorbar')
self.colorbarLabel.setToolTip(trans._('Colorbar'))
self._on_colormap_change()
def changeColor(self, text):
"""Change colormap on the layer model.
Parameters
----------
text : str
Colormap name.
"""
self.layer.colormap = self.colormapComboBox.currentData()
def _on_contrast_limits_change(self):
"""Receive layer model contrast limits change event and update slider."""
with qt_signals_blocked(self.contrastLimitsSlider):
self.contrastLimitsSlider.setValue(self.layer.contrast_limits)
if self.clim_popup:
with qt_signals_blocked(self.clim_popup.slider):
self.clim_popup.slider.setValue(self.layer.contrast_limits)
def _on_contrast_limits_range_change(self):
"""Receive layer model contrast limits change event and update slider."""
with qt_signals_blocked(self.contrastLimitsSlider):
decimals = range_to_decimals(
self.layer.contrast_limits_range, self.layer.dtype
)
self.contrastLimitsSlider.setRange(
*self.layer.contrast_limits_range
)
self.contrastLimitsSlider.setSingleStep(10**-decimals)
if self.clim_popup:
with qt_signals_blocked(self.clim_popup.slider):
self.clim_popup.slider.setRange(
*self.layer.contrast_limits_range
)
def _on_colormap_change(self):
"""Receive layer model colormap change event and update dropdown menu."""
name = self.layer.colormap.name
if name not in self.colormapComboBox._allitems:
if cm := AVAILABLE_COLORMAPS.get(name):
self.colormapComboBox._allitems.add(name)
self.colormapComboBox.addItem(cm._display_name, name)
if name != self.colormapComboBox.currentData():
index = self.colormapComboBox.findData(name)
self.colormapComboBox.setCurrentIndex(index)
# Note that QImage expects the image width followed by height
cbar = self.layer.colormap.colorbar
image = QImage(
cbar,
cbar.shape[1],
cbar.shape[0],
QImage.Format_RGBA8888,
)
self.colorbarLabel.setPixmap(QPixmap.fromImage(image))
def _on_gamma_change(self):
"""Receive the layer model gamma change event and update the slider."""
with qt_signals_blocked(self.gammaSlider):
self.gammaSlider.setValue(self.layer.gamma)
def closeEvent(self, event):
self.deleteLater()
self.layer.events.disconnect(self)
super().closeEvent(event)
def show_clim_popupup(self):
self.clim_popup = QContrastLimitsPopup(self.layer, self)
self.clim_popup.setParent(self)
self.clim_popup.move_to('top', min_length=650)
self.clim_popup.show()
class AutoScaleButtons(QWidget):
def __init__(self, layer: Image, parent=None) -> None:
super().__init__(parent=parent)
self.setLayout(QHBoxLayout())
self.layout().setSpacing(2)
self.layout().setContentsMargins(0, 0, 0, 0)
once_btn = QPushButton(trans._('once'))
once_btn.setFocusPolicy(Qt.FocusPolicy.NoFocus)
auto_btn = QPushButton(trans._('continuous'))
auto_btn.setCheckable(True)
auto_btn.setFocusPolicy(Qt.FocusPolicy.NoFocus)
once_btn.clicked.connect(lambda: auto_btn.setChecked(False))
connect_no_arg(once_btn.clicked, layer, "reset_contrast_limits")
connect_setattr(auto_btn.toggled, layer, "_keep_auto_contrast")
connect_no_arg(auto_btn.clicked, layer, "reset_contrast_limits")
self.layout().addWidget(once_btn)
self.layout().addWidget(auto_btn)
# just for testing
self._once_btn = once_btn
self._auto_btn = auto_btn
class QContrastLimitsPopup(QRangeSliderPopup):
def __init__(self, layer: Image, parent=None) -> None:
super().__init__(parent)
decimals = range_to_decimals(layer.contrast_limits_range, layer.dtype)
self.slider.setRange(*layer.contrast_limits_range)
self.slider.setDecimals(decimals)
self.slider.setSingleStep(10**-decimals)
self.slider.setValue(layer.contrast_limits)
connect_setattr(self.slider.valueChanged, layer, "contrast_limits")
connect_setattr(
self.slider.rangeChanged, layer, "contrast_limits_range"
)
def reset():
layer.reset_contrast_limits()
layer.contrast_limits_range = layer.contrast_limits
reset_btn = QPushButton("reset")
reset_btn.setObjectName("reset_clims_button")
reset_btn.setToolTip(trans._("autoscale contrast to data range"))
reset_btn.setFixedWidth(45)
reset_btn.clicked.connect(reset)
self._layout.addWidget(
reset_btn, alignment=Qt.AlignmentFlag.AlignBottom
)
# the "full range" button doesn't do anything if it's not an
# unsigned integer type (it's unclear what range should be set)
# so we don't show create it at all.
if np.issubdtype(normalize_dtype(layer.dtype), np.integer):
range_btn = QPushButton("full range")
range_btn.setObjectName("full_clim_range_button")
range_btn.setToolTip(
trans._("set contrast range to full bit-depth")
)
range_btn.setFixedWidth(75)
range_btn.clicked.connect(layer.reset_contrast_limits_range)
self._layout.addWidget(
range_btn, alignment=Qt.AlignmentFlag.AlignBottom
)
def range_to_decimals(range_, dtype):
"""Convert a range to decimals of precision.
Parameters
----------
range_ : tuple
Slider range, min and then max values.
dtype : np.dtype
Data type of the layer. Integers layers are given integer.
step sizes.
Returns
-------
int
Decimals of precision.
"""
if hasattr(dtype, 'numpy_dtype'):
# retrieve the corresponding numpy.dtype from a tensorstore.dtype
dtype = dtype.numpy_dtype
if np.issubdtype(dtype, np.integer):
return 0
else:
# scale precision with the log of the data range order of magnitude
# eg. 0 - 1 (0 order of mag) -> 3 decimal places
# 0 - 10 (1 order of mag) -> 2 decimals
# 0 - 100 (2 orders of mag) -> 1 decimal
# ≥ 3 orders of mag -> no decimals
# no more than 64 decimals
d_range = np.subtract(*range_[::-1])
return min(64, max(int(3 - np.log10(d_range)), 0))
napari-0.5.0a1/napari/_qt/layer_controls/qt_labels_controls.py 0000664 0000000 0000000 00000047155 14370413656 0024574 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING
import numpy as np
from qtpy.QtCore import Qt
from qtpy.QtGui import QColor, QPainter
from qtpy.QtWidgets import (
QButtonGroup,
QCheckBox,
QComboBox,
QHBoxLayout,
QLabel,
QSpinBox,
QWidget,
)
from superqt import QLargeIntSpinBox
from napari._qt.layer_controls.qt_layer_controls_base import QtLayerControls
from napari._qt.utils import set_widgets_enabled_with_opacity
from napari._qt.widgets._slider_compat import QSlider
from napari._qt.widgets.qt_mode_buttons import (
QtModePushButton,
QtModeRadioButton,
)
from napari.layers.labels._labels_constants import (
LABEL_COLOR_MODE_TRANSLATIONS,
LabelsRendering,
Mode,
)
from napari.layers.labels._labels_utils import get_dtype
from napari.utils._dtype import get_dtype_limits
from napari.utils.action_manager import action_manager
from napari.utils.events import disconnect_events
from napari.utils.translations import trans
if TYPE_CHECKING:
import napari.layers
INT32_MAX = 2**31 - 1
class QtLabelsControls(QtLayerControls):
"""Qt view and controls for the napari Labels layer.
Parameters
----------
layer : napari.layers.Labels
An instance of a napari Labels layer.
Attributes
----------
button_group : qtpy.QtWidgets.QButtonGroup
Button group of labels layer modes: PAN_ZOOM, PICKER, PAINT, ERASE, or
FILL.
colormapUpdate : qtpy.QtWidgets.QPushButton
Button to update colormap of label layer.
contigCheckBox : qtpy.QtWidgets.QCheckBox
Checkbox to control if label layer is contiguous.
fill_button : qtpy.QtWidgets.QtModeRadioButton
Button to select FILL mode on Labels layer.
layer : napari.layers.Labels
An instance of a napari Labels layer.
ndimSpinBox : qtpy.QtWidgets.QSpinBox
Spinbox to control the number of editable dimensions of label layer.
paint_button : qtpy.QtWidgets.QtModeRadioButton
Button to select PAINT mode on Labels layer.
panzoom_button : qtpy.QtWidgets.QtModeRadioButton
Button to select PAN_ZOOM mode on Labels layer.
pick_button : qtpy.QtWidgets.QtModeRadioButton
Button to select PICKER mode on Labels layer.
erase_button : qtpy.QtWidgets.QtModeRadioButton
Button to select ERASE mode on Labels layer.
selectionSpinBox : superqt.QLargeIntSpinBox
Widget to select a specific label by its index.
N.B. cannot represent labels > 2**53.
Raises
------
ValueError
Raise error if label mode is not PAN_ZOOM, PICKER, PAINT, ERASE, or
FILL.
"""
layer: 'napari.layers.Labels'
def __init__(self, layer) -> None:
super().__init__(layer)
self.layer.events.mode.connect(self._on_mode_change)
self.layer.events.rendering.connect(self._on_rendering_change)
self.layer.events.selected_label.connect(
self._on_selected_label_change
)
self.layer.events.brush_size.connect(self._on_brush_size_change)
self.layer.events.contiguous.connect(self._on_contiguous_change)
self.layer.events.n_edit_dimensions.connect(
self._on_n_edit_dimensions_change
)
self.layer.events.contour.connect(self._on_contour_change)
self.layer.events.editable.connect(self._on_editable_or_visible_change)
self.layer.events.visible.connect(self._on_editable_or_visible_change)
self.layer.events.preserve_labels.connect(
self._on_preserve_labels_change
)
self.layer.events.color_mode.connect(self._on_color_mode_change)
# selection spinbox
self.selectionSpinBox = QLargeIntSpinBox()
dtype_lims = get_dtype_limits(get_dtype(layer))
self.selectionSpinBox.setRange(*dtype_lims)
self.selectionSpinBox.setKeyboardTracking(False)
self.selectionSpinBox.valueChanged.connect(self.changeSelection)
self.selectionSpinBox.setAlignment(Qt.AlignmentFlag.AlignCenter)
self._on_selected_label_change()
sld = QSlider(Qt.Orientation.Horizontal)
sld.setFocusPolicy(Qt.FocusPolicy.NoFocus)
sld.setMinimum(1)
sld.setMaximum(40)
sld.setSingleStep(1)
sld.valueChanged.connect(self.changeSize)
self.brushSizeSlider = sld
self._on_brush_size_change()
contig_cb = QCheckBox()
contig_cb.setToolTip(trans._('contiguous editing'))
contig_cb.stateChanged.connect(self.change_contig)
self.contigCheckBox = contig_cb
self._on_contiguous_change()
ndim_sb = QSpinBox()
self.ndimSpinBox = ndim_sb
ndim_sb.setToolTip(trans._('number of dimensions for label editing'))
ndim_sb.valueChanged.connect(self.change_n_edit_dim)
ndim_sb.setMinimum(2)
ndim_sb.setMaximum(self.layer.ndim)
ndim_sb.setSingleStep(1)
ndim_sb.setAlignment(Qt.AlignmentFlag.AlignCenter)
self._on_n_edit_dimensions_change()
self.contourSpinBox = QLargeIntSpinBox()
self.contourSpinBox.setRange(*dtype_lims)
self.contourSpinBox.setToolTip(trans._('display contours of labels'))
self.contourSpinBox.valueChanged.connect(self.change_contour)
self.contourSpinBox.setKeyboardTracking(False)
self.contourSpinBox.setAlignment(Qt.AlignmentFlag.AlignCenter)
self._on_contour_change()
preserve_labels_cb = QCheckBox()
preserve_labels_cb.setToolTip(
trans._('preserve existing labels while painting')
)
preserve_labels_cb.stateChanged.connect(self.change_preserve_labels)
self.preserveLabelsCheckBox = preserve_labels_cb
self._on_preserve_labels_change()
selectedColorCheckbox = QCheckBox()
selectedColorCheckbox.setToolTip(
trans._("Display only selected label")
)
selectedColorCheckbox.stateChanged.connect(self.toggle_selected_mode)
self.selectedColorCheckbox = selectedColorCheckbox
# shuffle colormap button
self.colormapUpdate = QtModePushButton(
layer,
'shuffle',
slot=self.changeColor,
tooltip=trans._('shuffle colors'),
)
self.panzoom_button = QtModeRadioButton(
layer,
'zoom',
Mode.PAN_ZOOM,
checked=True,
)
action_manager.bind_button(
'napari:activate_label_pan_zoom_mode', self.panzoom_button
)
self.pick_button = QtModeRadioButton(layer, 'picker', Mode.PICK)
action_manager.bind_button(
'napari:activate_label_picker_mode', self.pick_button
)
self.paint_button = QtModeRadioButton(layer, 'paint', Mode.PAINT)
action_manager.bind_button(
'napari:activate_paint_mode', self.paint_button
)
self.fill_button = QtModeRadioButton(
layer,
'fill',
Mode.FILL,
)
action_manager.bind_button(
'napari:activate_fill_mode',
self.fill_button,
)
self.erase_button = QtModeRadioButton(
layer,
'erase',
Mode.ERASE,
)
action_manager.bind_button(
'napari:activate_label_erase_mode',
self.erase_button,
)
# don't bind with action manager as this would remove "Toggle with {shortcut}"
self._EDIT_BUTTONS = (
self.paint_button,
self.pick_button,
self.fill_button,
self.erase_button,
)
self.button_group = QButtonGroup(self)
self.button_group.addButton(self.panzoom_button)
self.button_group.addButton(self.paint_button)
self.button_group.addButton(self.pick_button)
self.button_group.addButton(self.fill_button)
self.button_group.addButton(self.erase_button)
self._on_editable_or_visible_change()
button_row = QHBoxLayout()
button_row.addStretch(1)
button_row.addWidget(self.colormapUpdate)
button_row.addWidget(self.erase_button)
button_row.addWidget(self.paint_button)
button_row.addWidget(self.fill_button)
button_row.addWidget(self.pick_button)
button_row.addWidget(self.panzoom_button)
button_row.setSpacing(4)
button_row.setContentsMargins(0, 0, 0, 5)
renderComboBox = QComboBox(self)
rendering_options = [i.value for i in LabelsRendering]
renderComboBox.addItems(rendering_options)
index = renderComboBox.findText(
self.layer.rendering, Qt.MatchFlag.MatchFixedString
)
renderComboBox.setCurrentIndex(index)
renderComboBox.currentTextChanged.connect(self.changeRendering)
self.renderComboBox = renderComboBox
self.renderLabel = QLabel(trans._('rendering:'))
self._on_ndisplay_changed()
color_mode_comboBox = QComboBox(self)
for index, (data, text) in enumerate(
LABEL_COLOR_MODE_TRANSLATIONS.items()
):
data = data.value
color_mode_comboBox.addItem(text, data)
if self.layer.color_mode == data:
color_mode_comboBox.setCurrentIndex(index)
color_mode_comboBox.activated.connect(self.change_color_mode)
self.colorModeComboBox = color_mode_comboBox
self._on_color_mode_change()
color_layout = QHBoxLayout()
self.colorBox = QtColorBox(layer)
color_layout.addWidget(self.colorBox)
color_layout.addWidget(self.selectionSpinBox)
self.layout().addRow(button_row)
self.layout().addRow(trans._('label:'), color_layout)
self.layout().addRow(self.opacityLabel, self.opacitySlider)
self.layout().addRow(trans._('brush size:'), self.brushSizeSlider)
self.layout().addRow(trans._('blending:'), self.blendComboBox)
self.layout().addRow(self.renderLabel, self.renderComboBox)
self.layout().addRow(trans._('color mode:'), self.colorModeComboBox)
self.layout().addRow(trans._('contour:'), self.contourSpinBox)
self.layout().addRow(trans._('n edit dim:'), self.ndimSpinBox)
self.layout().addRow(trans._('contiguous:'), self.contigCheckBox)
self.layout().addRow(
trans._('preserve\nlabels:'), self.preserveLabelsCheckBox
)
self.layout().addRow(
trans._('show\nselected:'), self.selectedColorCheckbox
)
def _on_mode_change(self, event):
"""Receive layer model mode change event and update checkbox ticks.
Parameters
----------
event : napari.utils.event.Event
The napari event that triggered this method.
Raises
------
ValueError
Raise error if event.mode is not PAN_ZOOM, PICK, PAINT, ERASE, or
FILL
"""
mode = event.mode
if mode == Mode.PAN_ZOOM:
self.panzoom_button.setChecked(True)
elif mode == Mode.PICK:
self.pick_button.setChecked(True)
elif mode == Mode.PAINT:
self.paint_button.setChecked(True)
elif mode == Mode.FILL:
self.fill_button.setChecked(True)
elif mode == Mode.ERASE:
self.erase_button.setChecked(True)
elif mode != Mode.TRANSFORM:
raise ValueError(trans._("Mode not recognized"))
def changeRendering(self, text):
"""Change rendering mode for image display.
Parameters
----------
text : str
Rendering mode used by vispy.
Selects a preset rendering mode in vispy that determines how
volume is displayed:
* translucent: voxel colors are blended along the view ray until
the result is opaque.
* iso_categorical: isosurface for categorical data (e.g., labels).
Cast a ray until a value greater than zero is encountered. At that
location, lighning calculations are performed to give the visual
appearance of a surface.
"""
self.layer.rendering = text
def changeColor(self):
"""Change colormap of the label layer."""
self.layer.new_colormap()
def changeSelection(self, value):
"""Change currently selected label.
Parameters
----------
value : int
Index of label to select.
"""
self.layer.selected_label = value
self.selectionSpinBox.clearFocus()
self.setFocus()
def toggle_selected_mode(self, state):
self.layer.show_selected_label = state == Qt.CheckState.Checked
def changeSize(self, value):
"""Change paint brush size.
Parameters
----------
value : float
Size of the paint brush.
"""
self.layer.brush_size = value
def change_contig(self, state):
"""Toggle contiguous state of label layer.
Parameters
----------
state : QCheckBox
Checkbox indicating if labels are contiguous.
"""
self.layer.contiguous = state == Qt.CheckState.Checked
def change_n_edit_dim(self, value):
"""Change the number of editable dimensions of label layer.
Parameters
----------
value : int
The number of editable dimensions to set.
"""
self.layer.n_edit_dimensions = value
self.ndimSpinBox.clearFocus()
self.setFocus()
def change_contour(self, value):
"""Change contour thickness.
Parameters
----------
value : int
Thickness of contour.
"""
self.layer.contour = value
self.contourSpinBox.clearFocus()
self.setFocus()
def change_preserve_labels(self, state):
"""Toggle preserve_labels state of label layer.
Parameters
----------
state : QCheckBox
Checkbox indicating if overwriting label is enabled.
"""
self.layer.preserve_labels = state == Qt.CheckState.Checked
def change_color_mode(self):
"""Change color mode of label layer"""
self.layer.color_mode = self.colorModeComboBox.currentData()
def _on_contour_change(self):
"""Receive layer model contour value change event and update spinbox."""
with self.layer.events.contour.blocker():
value = self.layer.contour
self.contourSpinBox.setValue(value)
def _on_selected_label_change(self):
"""Receive layer model label selection change event and update spinbox."""
with self.layer.events.selected_label.blocker():
value = self.layer.selected_label
self.selectionSpinBox.setValue(value)
def _on_brush_size_change(self):
"""Receive layer model brush size change event and update the slider."""
with self.layer.events.brush_size.blocker():
value = self.layer.brush_size
value = np.maximum(1, int(value))
if value > self.brushSizeSlider.maximum():
self.brushSizeSlider.setMaximum(int(value))
self.brushSizeSlider.setValue(value)
def _on_n_edit_dimensions_change(self):
"""Receive layer model n-dim mode change event and update the checkbox."""
with self.layer.events.n_edit_dimensions.blocker():
value = self.layer.n_edit_dimensions
self.ndimSpinBox.setValue(int(value))
def _on_contiguous_change(self):
"""Receive layer model contiguous change event and update the checkbox."""
with self.layer.events.contiguous.blocker():
self.contigCheckBox.setChecked(self.layer.contiguous)
def _on_preserve_labels_change(self):
"""Receive layer model preserve_labels event and update the checkbox."""
with self.layer.events.preserve_labels.blocker():
self.preserveLabelsCheckBox.setChecked(self.layer.preserve_labels)
def _on_color_mode_change(self):
"""Receive layer model color."""
with self.layer.events.color_mode.blocker():
self.colorModeComboBox.setCurrentIndex(
self.colorModeComboBox.findData(self.layer.color_mode)
)
def _on_editable_or_visible_change(self):
"""Receive layer model editable/visible change event & enable/disable buttons."""
set_widgets_enabled_with_opacity(
self,
self._EDIT_BUTTONS,
self.layer.editable and self.layer.visible,
)
def _on_rendering_change(self):
"""Receive layer model rendering change event and update dropdown menu."""
with self.layer.events.rendering.blocker():
index = self.renderComboBox.findText(
self.layer.rendering, Qt.MatchFlag.MatchFixedString
)
self.renderComboBox.setCurrentIndex(index)
def _on_ndisplay_changed(self):
render_visible = self.ndisplay == 3
self.renderComboBox.setVisible(render_visible)
self.renderLabel.setVisible(render_visible)
self._on_editable_or_visible_change()
def deleteLater(self):
disconnect_events(self.layer.events, self.colorBox)
super().deleteLater()
class QtColorBox(QWidget):
"""A widget that shows a square with the current label color.
Parameters
----------
layer : napari.layers.Layer
An instance of a napari layer.
"""
def __init__(self, layer) -> None:
super().__init__()
self.layer = layer
self.layer.events.selected_label.connect(
self._on_selected_label_change
)
self.layer.events.opacity.connect(self._on_opacity_change)
self.layer.events.colormap.connect(self._on_colormap_change)
self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
self._height = 24
self.setFixedWidth(self._height)
self.setFixedHeight(self._height)
self.setToolTip(trans._('Selected label color'))
self.color = None
def _on_selected_label_change(self):
"""Receive layer model label selection change event & update colorbox."""
self.update()
def _on_opacity_change(self):
"""Receive layer model label selection change event & update colorbox."""
self.update()
def _on_colormap_change(self):
"""Receive label colormap change event & update colorbox."""
self.update()
def paintEvent(self, event):
"""Paint the colorbox. If no color, display a checkerboard pattern.
Parameters
----------
event : qtpy.QtCore.QEvent
Event from the Qt context.
"""
painter = QPainter(self)
if self.layer._selected_color is None:
self.color = None
for i in range(self._height // 4):
for j in range(self._height // 4):
if (i % 2 == 0 and j % 2 == 0) or (
i % 2 == 1 and j % 2 == 1
):
painter.setPen(QColor(230, 230, 230))
painter.setBrush(QColor(230, 230, 230))
else:
painter.setPen(QColor(25, 25, 25))
painter.setBrush(QColor(25, 25, 25))
painter.drawRect(i * 4, j * 4, 5, 5)
else:
color = np.multiply(self.layer._selected_color, self.layer.opacity)
color = np.round(255 * color).astype(int)
painter.setPen(QColor(*list(color)))
painter.setBrush(QColor(*list(color)))
painter.drawRect(0, 0, self._height, self._height)
self.color = tuple(color)
def deleteLater(self):
disconnect_events(self.layer.events, self)
super().deleteLater()
def closeEvent(self, event):
"""Disconnect events when widget is closing."""
disconnect_events(self.layer.events, self)
super().closeEvent(event)
napari-0.5.0a1/napari/_qt/layer_controls/qt_layer_controls_base.py 0000664 0000000 0000000 00000013234 14370413656 0025427 0 ustar 00root root 0000000 0000000 from qtpy.QtCore import Qt
from qtpy.QtWidgets import QComboBox, QFormLayout, QFrame, QLabel
from napari._qt.widgets._slider_compat import QDoubleSlider
from napari.layers.base._base_constants import BLENDING_TRANSLATIONS, Blending
from napari.layers.base.base import Layer
from napari.utils.events import disconnect_events
from napari.utils.translations import trans
# opaque and minimum blending do not support changing alpha (opacity)
NO_OPACITY_BLENDING_MODES = {str(Blending.MINIMUM), str(Blending.OPAQUE)}
class LayerFormLayout(QFormLayout):
"""Reusable form layout for subwidgets in each QtLayerControls class"""
def __init__(self, QWidget=None) -> None:
super().__init__(QWidget)
self.setContentsMargins(0, 0, 0, 0)
self.setSpacing(4)
self.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
class QtLayerControls(QFrame):
"""Superclass for all the other LayerControl classes.
This class is never directly instantiated anywhere.
Parameters
----------
layer : napari.layers.Layer
An instance of a napari layer.
Attributes
----------
blendComboBox : qtpy.QtWidgets.QComboBox
Dropdown widget to select blending mode of layer.
layer : napari.layers.Layer
An instance of a napari layer.
opacitySlider : qtpy.QtWidgets.QSlider
Slider controlling opacity of the layer.
opacityLabel : qtpy.QtWidgets.QLabel
Label for the opacity slider widget.
"""
def __init__(self, layer: Layer) -> None:
super().__init__()
self._ndisplay: int = 2
self.layer = layer
self.layer.events.blending.connect(self._on_blending_change)
self.layer.events.opacity.connect(self._on_opacity_change)
self.setObjectName('layer')
self.setMouseTracking(True)
self.setLayout(LayerFormLayout(self))
sld = QDoubleSlider(Qt.Orientation.Horizontal, parent=self)
sld.setFocusPolicy(Qt.FocusPolicy.NoFocus)
sld.setMinimum(0)
sld.setMaximum(1)
sld.setSingleStep(0.01)
sld.valueChanged.connect(self.changeOpacity)
self.opacitySlider = sld
self.opacityLabel = QLabel(trans._('opacity:'))
self._on_opacity_change()
blend_comboBox = QComboBox(self)
for index, (data, text) in enumerate(BLENDING_TRANSLATIONS.items()):
data = data.value
blend_comboBox.addItem(text, data)
if data == self.layer.blending:
blend_comboBox.setCurrentIndex(index)
blend_comboBox.currentTextChanged.connect(self.changeBlending)
self.blendComboBox = blend_comboBox
# opaque and minimum blending do not support changing alpha
self.opacitySlider.setEnabled(
self.layer.blending not in NO_OPACITY_BLENDING_MODES
)
self.opacityLabel.setEnabled(
self.layer.blending not in NO_OPACITY_BLENDING_MODES
)
def changeOpacity(self, value):
"""Change opacity value on the layer model.
Parameters
----------
value : float
Opacity value for shapes.
Input range 0 - 100 (transparent to fully opaque).
"""
with self.layer.events.blocker(self._on_opacity_change):
self.layer.opacity = value
def changeBlending(self, text):
"""Change blending mode on the layer model.
Parameters
----------
text : str
Name of blending mode, eg: 'translucent', 'additive', 'opaque'.
"""
self.layer.blending = self.blendComboBox.currentData()
# opaque and minimum blending do not support changing alpha
self.opacitySlider.setEnabled(
self.layer.blending not in NO_OPACITY_BLENDING_MODES
)
self.opacityLabel.setEnabled(
self.layer.blending not in NO_OPACITY_BLENDING_MODES
)
blending_tooltip = ''
if self.layer.blending == str(Blending.MINIMUM):
blending_tooltip = trans._(
'`minimum` blending mode works best with inverted colormaps with a white background.',
)
self.blendComboBox.setToolTip(blending_tooltip)
self.layer.help = blending_tooltip
def _on_opacity_change(self):
"""Receive layer model opacity change event and update opacity slider."""
with self.layer.events.opacity.blocker():
self.opacitySlider.setValue(self.layer.opacity)
def _on_blending_change(self):
"""Receive layer model blending mode change event and update slider."""
with self.layer.events.blending.blocker():
self.blendComboBox.setCurrentIndex(
self.blendComboBox.findData(self.layer.blending)
)
@property
def ndisplay(self) -> int:
"""The number of dimensions displayed in the canvas."""
return self._ndisplay
@ndisplay.setter
def ndisplay(self, ndisplay: int) -> None:
self._ndisplay = ndisplay
self._on_ndisplay_changed()
def _on_ndisplay_changed(self) -> None:
"""Respond to a change to the number of dimensions displayed in the viewer.
This is needed because some layer controls may have options that are specific
to 2D or 3D visualization only.
"""
pass
def deleteLater(self):
disconnect_events(self.layer.events, self)
super().deleteLater()
def close(self):
"""Disconnect events when widget is closing."""
disconnect_events(self.layer.events, self)
for child in self.children():
close_method = getattr(child, 'close', None)
if close_method is not None:
close_method()
return super().close()
napari-0.5.0a1/napari/_qt/layer_controls/qt_layer_controls_container.py 0000664 0000000 0000000 00000012371 14370413656 0026500 0 ustar 00root root 0000000 0000000 from qtpy.QtWidgets import QFrame, QStackedWidget
from napari._qt.layer_controls.qt_image_controls import QtImageControls
from napari._qt.layer_controls.qt_labels_controls import QtLabelsControls
from napari._qt.layer_controls.qt_points_controls import QtPointsControls
from napari._qt.layer_controls.qt_shapes_controls import QtShapesControls
from napari._qt.layer_controls.qt_surface_controls import QtSurfaceControls
from napari._qt.layer_controls.qt_tracks_controls import QtTracksControls
from napari._qt.layer_controls.qt_vectors_controls import QtVectorsControls
from napari.layers import (
Image,
Labels,
Points,
Shapes,
Surface,
Tracks,
Vectors,
)
from napari.utils import config
from napari.utils.translations import trans
layer_to_controls = {
Labels: QtLabelsControls,
Image: QtImageControls,
Points: QtPointsControls,
Shapes: QtShapesControls,
Surface: QtSurfaceControls,
Vectors: QtVectorsControls,
Tracks: QtTracksControls,
}
if config.async_loading:
from napari.layers.image.experimental.octree_image import _OctreeImageBase
# The user visible layer controls for OctreeImage layers are identical
# to the regular image layer controls, for now.
layer_to_controls[_OctreeImageBase] = QtImageControls
def create_qt_layer_controls(layer):
"""
Create a qt controls widget for a layer based on its layer type.
In case of a subclass, the type higher in the layer's method resolution
order will be used.
Parameters
----------
layer : napari.layers.Layer
Layer that needs its controls widget created.
Returns
-------
controls : napari.layers.base.QtLayerControls
Qt controls widget
"""
candidates = []
for layer_type in layer_to_controls:
if isinstance(layer, layer_type):
candidates.append(layer_type)
if not candidates:
raise TypeError(
trans._(
'Could not find QtControls for layer of type {type_}',
deferred=True,
type_=type(layer),
)
)
layer_cls = layer.__class__
# Sort the list of candidates by 'lineage'
candidates.sort(key=lambda layer_type: layer_cls.mro().index(layer_type))
controls = layer_to_controls[candidates[0]]
return controls(layer)
class QtLayerControlsContainer(QStackedWidget):
"""Container widget for QtLayerControl widgets.
Parameters
----------
viewer : napari.components.ViewerModel
Napari viewer containing the rendered scene, layers, and controls.
Attributes
----------
empty_widget : qtpy.QtWidgets.QFrame
Empty placeholder frame for when no layer is selected.
viewer : napari.components.ViewerModel
Napari viewer containing the rendered scene, layers, and controls.
widgets : dict
Dictionary of key value pairs matching layer with its widget controls.
widgets[layer] = controls
"""
def __init__(self, viewer) -> None:
super().__init__()
self.setProperty("emphasized", True)
self.viewer = viewer
self.setMouseTracking(True)
self.empty_widget = QFrame()
self.empty_widget.setObjectName("empty_controls_widget")
self.widgets = {}
self.addWidget(self.empty_widget)
self.setCurrentWidget(self.empty_widget)
self.viewer.layers.events.inserted.connect(self._add)
self.viewer.layers.events.removed.connect(self._remove)
viewer.layers.selection.events.active.connect(self._display)
viewer.dims.events.ndisplay.connect(self._on_ndisplay_changed)
def _on_ndisplay_changed(self, event):
"""Responds to a change in the dimensionality displayed in the canvas.
Parameters
----------
event : Event
Event with the new dimensionality value at `event.value`.
"""
for widget in self.widgets.values():
if widget is not self.empty_widget:
widget.ndisplay = event.value
def _display(self, event):
"""Change the displayed controls to be those of the target layer.
Parameters
----------
event : Event
Event with the target layer at `event.value`.
"""
layer = event.value
if layer is None:
self.setCurrentWidget(self.empty_widget)
else:
controls = self.widgets[layer]
self.setCurrentWidget(controls)
def _add(self, event):
"""Add the controls target layer to the list of control widgets.
Parameters
----------
event : Event
Event with the target layer at `event.value`.
"""
layer = event.value
controls = create_qt_layer_controls(layer)
controls.ndisplay = 3
self.addWidget(controls)
self.widgets[layer] = controls
def _remove(self, event):
"""Remove the controls target layer from the list of control widgets.
Parameters
----------
event : Event
Event with the target layer at `event.value`.
"""
layer = event.value
controls = self.widgets[layer]
self.removeWidget(controls)
controls.hide()
controls.deleteLater()
controls = None
del self.widgets[layer]
napari-0.5.0a1/napari/_qt/layer_controls/qt_points_controls.py 0000664 0000000 0000000 00000031526 14370413656 0024641 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING
import numpy as np
from qtpy.QtCore import Qt, Slot
from qtpy.QtWidgets import QButtonGroup, QCheckBox, QComboBox, QHBoxLayout
from napari._qt.layer_controls.qt_layer_controls_base import QtLayerControls
from napari._qt.utils import (
qt_signals_blocked,
set_widgets_enabled_with_opacity,
)
from napari._qt.widgets._slider_compat import QSlider
from napari._qt.widgets.qt_color_swatch import QColorSwatchEdit
from napari._qt.widgets.qt_mode_buttons import (
QtModePushButton,
QtModeRadioButton,
)
from napari.layers.points._points_constants import (
SYMBOL_TRANSLATION,
SYMBOL_TRANSLATION_INVERTED,
Mode,
)
from napari.utils.action_manager import action_manager
from napari.utils.events import disconnect_events
from napari.utils.translations import trans
if TYPE_CHECKING:
import napari.layers
class QtPointsControls(QtLayerControls):
"""Qt view and controls for the napari Points layer.
Parameters
----------
layer : napari.layers.Points
An instance of a napari Points layer.
Attributes
----------
addition_button : qtpy.QtWidgets.QtModeRadioButton
Button to add points to layer.
button_group : qtpy.QtWidgets.QButtonGroup
Button group of points layer modes (ADD, PAN_ZOOM, SELECT).
delete_button : qtpy.QtWidgets.QtModePushButton
Button to delete points from layer.
edgeColorEdit : QColorSwatchEdit
Widget to select display color for shape edges.
faceColorEdit : QColorSwatchEdit
Widget to select display color for shape faces.
layer : napari.layers.Points
An instance of a napari Points layer.
outOfSliceCheckBox : qtpy.QtWidgets.QCheckBox
Checkbox to indicate whether to render out of slice.
panzoom_button : qtpy.QtWidgets.QtModeRadioButton
Button for pan/zoom mode.
select_button : qtpy.QtWidgets.QtModeRadioButton
Button to select points from layer.
sizeSlider : qtpy.QtWidgets.QSlider
Slider controlling size of points.
symbolComboBox : qtpy.QtWidgets.QComboBox
Drop down list of symbol options for points markers.
Raises
------
ValueError
Raise error if points mode is not recognized.
Points mode must be one of: ADD, PAN_ZOOM, or SELECT.
"""
layer: 'napari.layers.Points'
def __init__(self, layer) -> None:
super().__init__(layer)
self.layer.events.mode.connect(self._on_mode_change)
self.layer.events.out_of_slice_display.connect(
self._on_out_of_slice_display_change
)
self.layer.events.symbol.connect(self._on_symbol_change)
self.layer.events.size.connect(self._on_size_change)
self.layer.events.current_edge_color.connect(
self._on_current_edge_color_change
)
self.layer._edge.events.current_color.connect(
self._on_current_edge_color_change
)
self.layer.events.current_face_color.connect(
self._on_current_face_color_change
)
self.layer._face.events.current_color.connect(
self._on_current_face_color_change
)
self.layer.events.editable.connect(self._on_editable_or_visible_change)
self.layer.events.visible.connect(self._on_editable_or_visible_change)
self.layer.text.events.visible.connect(self._on_text_visibility_change)
sld = QSlider(Qt.Orientation.Horizontal)
sld.setToolTip(
trans._(
"Change the size of currently selected points and any added afterwards."
)
)
sld.setFocusPolicy(Qt.FocusPolicy.NoFocus)
sld.setMinimum(1)
if self.layer.size.size:
max_value = max(100, int(np.max(self.layer.size)) + 1)
else:
max_value = 100
sld.setMaximum(max_value)
sld.setSingleStep(1)
value = self.layer.current_size
sld.setValue(int(value))
sld.valueChanged.connect(self.changeSize)
self.sizeSlider = sld
self.faceColorEdit = QColorSwatchEdit(
initial_color=self.layer.current_face_color,
tooltip=trans._('click to set current face color'),
)
self.edgeColorEdit = QColorSwatchEdit(
initial_color=self.layer.current_edge_color,
tooltip=trans._('click to set current edge color'),
)
self.faceColorEdit.color_changed.connect(self.changeFaceColor)
self.edgeColorEdit.color_changed.connect(self.changeEdgeColor)
sym_cb = QComboBox()
sym_cb.setToolTip(
trans._(
"Change the symbol of currently selected points and any added afterwards."
)
)
current_index = 0
for index, (symbol_string, text) in enumerate(
SYMBOL_TRANSLATION.items()
):
symbol_string = symbol_string.value
sym_cb.addItem(text, symbol_string)
if symbol_string == self.layer.current_symbol:
current_index = index
sym_cb.setCurrentIndex(current_index)
sym_cb.currentTextChanged.connect(self.changeSymbol)
self.symbolComboBox = sym_cb
self.outOfSliceCheckBox = QCheckBox()
self.outOfSliceCheckBox.setToolTip(trans._('Out of slice display'))
self.outOfSliceCheckBox.setChecked(self.layer.out_of_slice_display)
self.outOfSliceCheckBox.stateChanged.connect(self.change_out_of_slice)
self.select_button = QtModeRadioButton(
layer,
'select_points',
Mode.SELECT,
)
action_manager.bind_button(
'napari:activate_points_select_mode', self.select_button
)
self.addition_button = QtModeRadioButton(layer, 'add_points', Mode.ADD)
action_manager.bind_button(
'napari:activate_points_add_mode', self.addition_button
)
self.panzoom_button = QtModeRadioButton(
layer,
'pan_zoom',
Mode.PAN_ZOOM,
checked=True,
)
action_manager.bind_button(
'napari:activate_points_pan_zoom_mode', self.panzoom_button
)
self.delete_button = QtModePushButton(
layer,
'delete_shape',
)
action_manager.bind_button(
'napari:delete_selected_points', self.delete_button
)
self.textDispCheckBox = QCheckBox()
self.textDispCheckBox.setToolTip(trans._('toggle text visibility'))
self.textDispCheckBox.setChecked(self.layer.text.visible)
self.textDispCheckBox.stateChanged.connect(self.change_text_visibility)
self._EDIT_BUTTONS = (
self.select_button,
self.addition_button,
self.delete_button,
)
self.button_group = QButtonGroup(self)
self.button_group.addButton(self.select_button)
self.button_group.addButton(self.addition_button)
self.button_group.addButton(self.panzoom_button)
self._on_editable_or_visible_change()
button_row = QHBoxLayout()
button_row.addStretch(1)
button_row.addWidget(self.delete_button)
button_row.addWidget(self.addition_button)
button_row.addWidget(self.select_button)
button_row.addWidget(self.panzoom_button)
button_row.setContentsMargins(0, 0, 0, 5)
button_row.setSpacing(4)
self.layout().addRow(button_row)
self.layout().addRow(self.opacityLabel, self.opacitySlider)
self.layout().addRow(trans._('point size:'), self.sizeSlider)
self.layout().addRow(trans._('blending:'), self.blendComboBox)
self.layout().addRow(trans._('symbol:'), self.symbolComboBox)
self.layout().addRow(trans._('face color:'), self.faceColorEdit)
self.layout().addRow(trans._('edge color:'), self.edgeColorEdit)
self.layout().addRow(trans._('display text:'), self.textDispCheckBox)
self.layout().addRow(trans._('out of slice:'), self.outOfSliceCheckBox)
def _on_mode_change(self, event):
"""Update ticks in checkbox widgets when points layer mode is changed.
Available modes for points layer are:
* ADD
* SELECT
* PAN_ZOOM
Parameters
----------
event : napari.utils.event.Event
The napari event that triggered this method.
Raises
------
ValueError
Raise error if event.mode is not ADD, PAN_ZOOM, or SELECT.
"""
mode = event.mode
if mode == Mode.ADD:
self.addition_button.setChecked(True)
elif mode == Mode.SELECT:
self.select_button.setChecked(True)
elif mode == Mode.PAN_ZOOM:
self.panzoom_button.setChecked(True)
elif mode != Mode.TRANSFORM:
raise ValueError(trans._("Mode not recognized {mode}", mode=mode))
def changeSymbol(self, text):
"""Change marker symbol of the points on the layer model.
Parameters
----------
text : int
Index of current marker symbol of points, eg: '+', '.', etc.
"""
self.layer.current_symbol = SYMBOL_TRANSLATION_INVERTED[text]
def changeSize(self, value):
"""Change size of points on the layer model.
Parameters
----------
value : float
Size of points.
"""
self.layer.current_size = value
def change_out_of_slice(self, state):
"""Toggleout of slice display of points layer.
Parameters
----------
state : QCheckBox
Checkbox indicating whether to render out of slice.
"""
# needs cast to bool for Qt6
self.layer.out_of_slice_display = bool(state)
def change_text_visibility(self, state):
"""Toggle the visibility of the text.
Parameters
----------
state : QCheckBox
Checkbox indicating if text is visible.
"""
# needs cast to bool for Qt6
self.layer.text.visible = bool(state)
def _on_text_visibility_change(self):
"""Receive layer model text visibiltiy change change event and update checkbox."""
with self.layer.text.events.visible.blocker():
self.textDispCheckBox.setChecked(self.layer.text.visible)
def _on_out_of_slice_display_change(self):
"""Receive layer model out_of_slice_display change event and update checkbox."""
with self.layer.events.out_of_slice_display.blocker():
self.outOfSliceCheckBox.setChecked(self.layer.out_of_slice_display)
def _on_symbol_change(self):
"""Receive marker symbol change event and update the dropdown menu."""
with self.layer.events.symbol.blocker():
self.symbolComboBox.setCurrentIndex(
self.symbolComboBox.findData(self.layer.current_symbol.value)
)
def _on_size_change(self):
"""Receive layer model size change event and update point size slider."""
with self.layer.events.size.blocker():
value = self.layer.current_size
min_val = min(value) if isinstance(value, list) else value
max_val = max(value) if isinstance(value, list) else value
if min_val < self.sizeSlider.minimum():
self.sizeSlider.setMinimum(max(1, int(min_val - 1)))
if max_val > self.sizeSlider.maximum():
self.sizeSlider.setMaximum(int(max_val + 1))
try:
self.sizeSlider.setValue(int(value))
except TypeError:
pass
@Slot(np.ndarray)
def changeFaceColor(self, color: np.ndarray):
"""Update face color of layer model from color picker user input."""
with self.layer.events.current_face_color.blocker():
self.layer.current_face_color = color
@Slot(np.ndarray)
def changeEdgeColor(self, color: np.ndarray):
"""Update edge color of layer model from color picker user input."""
with self.layer.events.current_edge_color.blocker():
self.layer.current_edge_color = color
def _on_current_face_color_change(self):
"""Receive layer.current_face_color() change event and update view."""
with qt_signals_blocked(self.faceColorEdit):
self.faceColorEdit.setColor(self.layer.current_face_color)
def _on_current_edge_color_change(self):
"""Receive layer.current_edge_color() change event and update view."""
with qt_signals_blocked(self.edgeColorEdit):
self.edgeColorEdit.setColor(self.layer.current_edge_color)
def _on_editable_or_visible_change(self):
"""Receive layer model editable/visible change event & enable/disable buttons."""
set_widgets_enabled_with_opacity(
self,
self._EDIT_BUTTONS,
self.layer.editable and self.layer.visible,
)
def close(self):
"""Disconnect events when widget is closing."""
disconnect_events(self.layer.text.events, self)
super().close()
napari-0.5.0a1/napari/_qt/layer_controls/qt_shapes_controls.py 0000664 0000000 0000000 00000037256 14370413656 0024616 0 ustar 00root root 0000000 0000000 from collections.abc import Iterable
from typing import TYPE_CHECKING
import numpy as np
from qtpy.QtCore import Qt
from qtpy.QtWidgets import QButtonGroup, QCheckBox, QGridLayout
from napari._qt.layer_controls.qt_layer_controls_base import QtLayerControls
from napari._qt.utils import (
qt_signals_blocked,
set_widgets_enabled_with_opacity,
)
from napari._qt.widgets._slider_compat import QSlider
from napari._qt.widgets.qt_color_swatch import QColorSwatchEdit
from napari._qt.widgets.qt_mode_buttons import (
QtModePushButton,
QtModeRadioButton,
)
from napari.layers.shapes._shapes_constants import Mode
from napari.utils.action_manager import action_manager
from napari.utils.events import disconnect_events
from napari.utils.interactions import Shortcut
from napari.utils.translations import trans
if TYPE_CHECKING:
import napari.layers
class QtShapesControls(QtLayerControls):
"""Qt view and controls for the napari Shapes layer.
Parameters
----------
layer : napari.layers.Shapes
An instance of a napari Shapes layer.
Attributes
----------
button_group : qtpy.QtWidgets.QButtonGroup
Button group for shapes layer modes
(SELECT, DIRECT, PAN_ZOOM, ADD_RECTANGLE, ADD_ELLIPSE, ADD_LINE,
ADD_PATH, ADD_POLYGON, VERTEX_INSERT, VERTEX_REMOVE).
delete_button : qtpy.QtWidgets.QtModePushButton
Button to delete selected shapes
direct_button : qtpy.QtWidgets.QtModeRadioButton
Button to select individual vertices in shapes.
edgeColorEdit : QColorSwatchEdit
Widget allowing user to set edge color of points.
ellipse_button : qtpy.QtWidgets.QtModeRadioButton
Button to add ellipses to shapes layer.
faceColorEdit : QColorSwatchEdit
Widget allowing user to set face color of points.
layer : napari.layers.Shapes
An instance of a napari Shapes layer.
line_button : qtpy.QtWidgets.QtModeRadioButton
Button to add lines to shapes layer.
move_back_button : qtpy.QtWidgets.QtModePushButton
Button to move selected shape(s) to the back.
move_front_button : qtpy.QtWidgets.QtModePushButton
Button to move shape(s) to the front.
panzoom_button : qtpy.QtWidgets.QtModeRadioButton
Button to pan/zoom shapes layer.
path_button : qtpy.QtWidgets.QtModeRadioButton
Button to add paths to shapes layer.
polygon_button : qtpy.QtWidgets.QtModeRadioButton
Button to add polygons to shapes layer.
rectangle_button : qtpy.QtWidgets.QtModeRadioButton
Button to add rectangles to shapes layer.
select_button : qtpy.QtWidgets.QtModeRadioButton
Button to select shapes.
vertex_insert_button : qtpy.QtWidgets.QtModeRadioButton
Button to insert vertex into shape.
vertex_remove_button : qtpy.QtWidgets.QtModeRadioButton
Button to remove vertex from shapes.
widthSlider : qtpy.QtWidgets.QSlider
Slider controlling line edge width of shapes.
Raises
------
ValueError
Raise error if shapes mode is not recognized.
"""
layer: 'napari.layers.Shapes'
def __init__(self, layer) -> None:
super().__init__(layer)
self.layer.events.mode.connect(self._on_mode_change)
self.layer.events.edge_width.connect(self._on_edge_width_change)
self.layer.events.current_edge_color.connect(
self._on_current_edge_color_change
)
self.layer.events.current_face_color.connect(
self._on_current_face_color_change
)
self.layer.events.editable.connect(self._on_editable_or_visible_change)
self.layer.events.visible.connect(self._on_editable_or_visible_change)
self.layer.text.events.visible.connect(self._on_text_visibility_change)
sld = QSlider(Qt.Orientation.Horizontal)
sld.setFocusPolicy(Qt.FocusPolicy.NoFocus)
sld.setMinimum(0)
sld.setMaximum(40)
sld.setSingleStep(1)
value = self.layer.current_edge_width
if isinstance(value, Iterable):
if isinstance(value, list):
value = np.asarray(value)
value = value.mean()
sld.setValue(int(value))
sld.valueChanged.connect(self.changeWidth)
self.widthSlider = sld
def _radio_button(
parent,
btn_name,
mode,
action_name,
extra_tooltip_text='',
**kwargs,
):
"""
Convenience local function to create a RadioButton and bind it to
an action at the same time.
Parameters
----------
parent : Any
Parent of the generated QtModeRadioButton
btn_name : str
name fo the button
mode : Enum
Value Associated to current button
action_name : str
Action triggered when button pressed
extra_tooltip_text : str
Text you want added after the automatic tooltip set by the
action manager
**kwargs:
Passed to QtModeRadioButton
Returns
-------
button: QtModeRadioButton
button bound (or that will be bound to) to action `action_name`
Notes
-----
When shortcuts are modifed/added/removed via the action manager, the
tooltip will be updated to reflect the new shortcut.
"""
action_name = f'napari:{action_name}'
btn = QtModeRadioButton(parent, btn_name, mode, **kwargs)
action_manager.bind_button(
action_name,
btn,
extra_tooltip_text='',
)
return btn
self.select_button = _radio_button(
layer, 'select', Mode.SELECT, "activate_select_mode"
)
self.direct_button = _radio_button(
layer, 'direct', Mode.DIRECT, "activate_direct_mode"
)
self.panzoom_button = _radio_button(
layer,
'zoom',
Mode.PAN_ZOOM,
"activate_shape_pan_zoom_mode",
extra_tooltip_text=trans._('(or hold Space)'),
checked=True,
)
self.rectangle_button = _radio_button(
layer,
'rectangle',
Mode.ADD_RECTANGLE,
"activate_add_rectangle_mode",
)
self.ellipse_button = _radio_button(
layer,
'ellipse',
Mode.ADD_ELLIPSE,
"activate_add_ellipse_mode",
)
self.line_button = _radio_button(
layer, 'line', Mode.ADD_LINE, "activate_add_line_mode"
)
self.path_button = _radio_button(
layer, 'path', Mode.ADD_PATH, "activate_add_path_mode"
)
self.polygon_button = _radio_button(
layer,
'polygon',
Mode.ADD_POLYGON,
"activate_add_polygon_mode",
)
self.vertex_insert_button = _radio_button(
layer,
'vertex_insert',
Mode.VERTEX_INSERT,
"activate_vertex_insert_mode",
)
self.vertex_remove_button = _radio_button(
layer,
'vertex_remove',
Mode.VERTEX_REMOVE,
"activate_vertex_remove_mode",
)
self.move_front_button = QtModePushButton(
layer,
'move_front',
slot=self.layer.move_to_front,
tooltip=trans._('Move to front'),
)
action_manager.bind_button(
'napari:move_shapes_selection_to_front', self.move_front_button
)
self.move_back_button = QtModePushButton(
layer,
'move_back',
slot=self.layer.move_to_back,
tooltip=trans._('Move to back'),
)
action_manager.bind_button(
'napari:move_shapes_selection_to_back', self.move_back_button
)
self.delete_button = QtModePushButton(
layer,
'delete_shape',
slot=self.layer.remove_selected,
tooltip=trans._(
"Delete selected shapes ({shortcut})",
shortcut=Shortcut('Backspace').platform,
),
)
self._EDIT_BUTTONS = (
self.select_button,
self.direct_button,
self.rectangle_button,
self.ellipse_button,
self.line_button,
self.path_button,
self.polygon_button,
self.vertex_remove_button,
self.vertex_insert_button,
self.delete_button,
self.move_back_button,
self.move_front_button,
)
self.button_group = QButtonGroup(self)
self.button_group.addButton(self.select_button)
self.button_group.addButton(self.direct_button)
self.button_group.addButton(self.panzoom_button)
self.button_group.addButton(self.rectangle_button)
self.button_group.addButton(self.ellipse_button)
self.button_group.addButton(self.line_button)
self.button_group.addButton(self.path_button)
self.button_group.addButton(self.polygon_button)
self.button_group.addButton(self.vertex_insert_button)
self.button_group.addButton(self.vertex_remove_button)
self._on_editable_or_visible_change()
button_grid = QGridLayout()
button_grid.addWidget(self.vertex_remove_button, 0, 2)
button_grid.addWidget(self.vertex_insert_button, 0, 3)
button_grid.addWidget(self.delete_button, 0, 4)
button_grid.addWidget(self.direct_button, 0, 5)
button_grid.addWidget(self.select_button, 0, 6)
button_grid.addWidget(self.panzoom_button, 0, 7)
button_grid.addWidget(self.move_back_button, 1, 1)
button_grid.addWidget(self.move_front_button, 1, 2)
button_grid.addWidget(self.ellipse_button, 1, 3)
button_grid.addWidget(self.rectangle_button, 1, 4)
button_grid.addWidget(self.polygon_button, 1, 5)
button_grid.addWidget(self.line_button, 1, 6)
button_grid.addWidget(self.path_button, 1, 7)
button_grid.setContentsMargins(5, 0, 0, 5)
button_grid.setColumnStretch(0, 1)
button_grid.setSpacing(4)
self.faceColorEdit = QColorSwatchEdit(
initial_color=self.layer.current_face_color,
tooltip=trans._('click to set current face color'),
)
self._on_current_face_color_change()
self.edgeColorEdit = QColorSwatchEdit(
initial_color=self.layer.current_edge_color,
tooltip=trans._('click to set current edge color'),
)
self._on_current_edge_color_change()
self.faceColorEdit.color_changed.connect(self.changeFaceColor)
self.edgeColorEdit.color_changed.connect(self.changeEdgeColor)
text_disp_cb = QCheckBox()
text_disp_cb.setToolTip(trans._('toggle text visibility'))
text_disp_cb.setChecked(self.layer.text.visible)
text_disp_cb.stateChanged.connect(self.change_text_visibility)
self.textDispCheckBox = text_disp_cb
self.layout().addRow(button_grid)
self.layout().addRow(self.opacityLabel, self.opacitySlider)
self.layout().addRow(trans._('edge width:'), self.widthSlider)
self.layout().addRow(trans._('blending:'), self.blendComboBox)
self.layout().addRow(trans._('face color:'), self.faceColorEdit)
self.layout().addRow(trans._('edge color:'), self.edgeColorEdit)
self.layout().addRow(trans._('display text:'), self.textDispCheckBox)
def _on_mode_change(self, event):
"""Update ticks in checkbox widgets when shapes layer mode changed.
Available modes for shapes layer are:
* SELECT
* DIRECT
* PAN_ZOOM
* ADD_RECTANGLE
* ADD_ELLIPSE
* ADD_LINE
* ADD_PATH
* ADD_POLYGON
* VERTEX_INSERT
* VERTEX_REMOVE
Parameters
----------
event : napari.utils.event.Event
The napari event that triggered this method.
Raises
------
ValueError
Raise error if event.mode is not ADD, PAN_ZOOM, or SELECT.
"""
mode_buttons = {
Mode.SELECT: self.select_button,
Mode.DIRECT: self.direct_button,
Mode.PAN_ZOOM: self.panzoom_button,
Mode.ADD_RECTANGLE: self.rectangle_button,
Mode.ADD_ELLIPSE: self.ellipse_button,
Mode.ADD_LINE: self.line_button,
Mode.ADD_PATH: self.path_button,
Mode.ADD_POLYGON: self.polygon_button,
Mode.VERTEX_INSERT: self.vertex_insert_button,
Mode.VERTEX_REMOVE: self.vertex_remove_button,
}
if event.mode in mode_buttons:
mode_buttons[event.mode].setChecked(True)
elif event.mode != Mode.TRANSFORM:
raise ValueError(
trans._("Mode '{mode}'not recognized", mode=event.mode)
)
def changeFaceColor(self, color: np.ndarray):
"""Change face color of shapes.
Parameters
----------
color : np.ndarray
Face color for shapes, color name or hex string.
Eg: 'white', 'red', 'blue', '#00ff00', etc.
"""
with self.layer.events.current_face_color.blocker():
self.layer.current_face_color = color
def changeEdgeColor(self, color: np.ndarray):
"""Change edge color of shapes.
Parameters
----------
color : np.ndarray
Edge color for shapes, color name or hex string.
Eg: 'white', 'red', 'blue', '#00ff00', etc.
"""
with self.layer.events.current_edge_color.blocker():
self.layer.current_edge_color = color
def changeWidth(self, value):
"""Change edge line width of shapes on the layer model.
Parameters
----------
value : float
Line width of shapes.
"""
self.layer.current_edge_width = float(value)
def change_text_visibility(self, state):
"""Toggle the visibility of the text.
Parameters
----------
state : QCheckBox
Checkbox indicating if text is visible.
"""
self.layer.text.visible = state == Qt.CheckState.Checked
def _on_text_visibility_change(self):
"""Receive layer model text visibiltiy change change event and update checkbox."""
with self.layer.text.events.visible.blocker():
self.textDispCheckBox.setChecked(self.layer.text.visible)
def _on_edge_width_change(self):
"""Receive layer model edge line width change event and update slider."""
with self.layer.events.edge_width.blocker():
value = self.layer.current_edge_width
value = np.clip(int(value), 0, 40)
self.widthSlider.setValue(value)
def _on_current_edge_color_change(self):
"""Receive layer model edge color change event and update color swatch."""
with qt_signals_blocked(self.edgeColorEdit):
self.edgeColorEdit.setColor(self.layer.current_edge_color)
def _on_current_face_color_change(self):
"""Receive layer model face color change event and update color swatch."""
with qt_signals_blocked(self.faceColorEdit):
self.faceColorEdit.setColor(self.layer.current_face_color)
def _on_editable_or_visible_change(self):
"""Receive layer model editable/visible change event & enable/disable buttons."""
set_widgets_enabled_with_opacity(
self,
self._EDIT_BUTTONS,
self.layer.editable and self.layer.visible,
)
def close(self):
"""Disconnect events when widget is closing."""
disconnect_events(self.layer.text.events, self)
super().close()
napari-0.5.0a1/napari/_qt/layer_controls/qt_surface_controls.py 0000664 0000000 0000000 00000004267 14370413656 0024757 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING
from qtpy.QtWidgets import QComboBox, QHBoxLayout
from napari._qt.layer_controls.qt_image_controls_base import (
QtBaseImageControls,
)
from napari.layers.surface._surface_constants import SHADING_TRANSLATION
from napari.utils.translations import trans
if TYPE_CHECKING:
import napari.layers
class QtSurfaceControls(QtBaseImageControls):
"""Qt view and controls for the napari Surface layer.
Parameters
----------
layer : napari.layers.Surface
An instance of a napari Surface layer.
Attributes
----------
layer : napari.layers.Surface
An instance of a napari Surface layer.
"""
layer: 'napari.layers.Surface'
def __init__(self, layer) -> None:
super().__init__(layer)
colormap_layout = QHBoxLayout()
colormap_layout.addWidget(self.colorbarLabel)
colormap_layout.addWidget(self.colormapComboBox)
colormap_layout.addStretch(1)
shading_comboBox = QComboBox(self)
for display_name, shading in SHADING_TRANSLATION.items():
shading_comboBox.addItem(display_name, shading)
index = shading_comboBox.findData(
SHADING_TRANSLATION[self.layer.shading]
)
shading_comboBox.setCurrentIndex(index)
shading_comboBox.currentTextChanged.connect(self.changeShading)
self.shadingComboBox = shading_comboBox
self.layout().addRow(self.opacityLabel, self.opacitySlider)
self.layout().addRow(
trans._('contrast limits:'), self.contrastLimitsSlider
)
self.layout().addRow(trans._('auto-contrast:'), self.autoScaleBar)
self.layout().addRow(trans._('gamma:'), self.gammaSlider)
self.layout().addRow(trans._('colormap:'), colormap_layout)
self.layout().addRow(trans._('blending:'), self.blendComboBox)
self.layout().addRow(trans._('shading:'), self.shadingComboBox)
def changeShading(self, text):
"""Change shading value on the surface layer.
Parameters
----------
text : str
Name of shading mode, eg: 'flat', 'smooth', 'none'.
"""
self.layer.shading = self.shadingComboBox.currentData()
napari-0.5.0a1/napari/_qt/layer_controls/qt_tracks_controls.py 0000664 0000000 0000000 00000016757 14370413656 0024625 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING
from qtpy.QtCore import Qt
from qtpy.QtWidgets import QCheckBox, QComboBox, QSlider
from napari._qt.layer_controls.qt_layer_controls_base import QtLayerControls
from napari._qt.utils import qt_signals_blocked
from napari.utils.colormaps import AVAILABLE_COLORMAPS
from napari.utils.translations import trans
if TYPE_CHECKING:
import napari.layers
class QtTracksControls(QtLayerControls):
"""Qt view and controls for the Tracks layer.
Parameters
----------
layer : napari.layers.Tracks
An instance of a Tracks layer.
Attributes
----------
layer : layers.Tracks
An instance of a Tracks layer.
"""
layer: 'napari.layers.Tracks'
def __init__(self, layer) -> None:
super().__init__(layer)
# NOTE(arl): there are no events fired for changing checkboxes
self.layer.events.tail_width.connect(self._on_tail_width_change)
self.layer.events.tail_length.connect(self._on_tail_length_change)
self.layer.events.head_length.connect(self._on_head_length_change)
self.layer.events.properties.connect(self._on_properties_change)
self.layer.events.colormap.connect(self._on_colormap_change)
self.layer.events.color_by.connect(self._on_color_by_change)
# combo box for track coloring, we can get these from the properties
# keys
self.color_by_combobox = QComboBox()
self.color_by_combobox.addItems(self.layer.properties_to_color_by)
self.colormap_combobox = QComboBox()
for name, colormap in AVAILABLE_COLORMAPS.items():
display_name = colormap._display_name
self.colormap_combobox.addItem(display_name, name)
# slider for track head length
self.head_length_slider = QSlider(Qt.Orientation.Horizontal)
self.head_length_slider.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.head_length_slider.setMinimum(0)
self.head_length_slider.setMaximum(self.layer._max_length)
self.head_length_slider.setSingleStep(1)
# slider for track tail length
self.tail_length_slider = QSlider(Qt.Orientation.Horizontal)
self.tail_length_slider.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.tail_length_slider.setMinimum(1)
self.tail_length_slider.setMaximum(self.layer._max_length)
self.tail_length_slider.setSingleStep(1)
# slider for track edge width
self.tail_width_slider = QSlider(Qt.Orientation.Horizontal)
self.tail_width_slider.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.tail_width_slider.setMinimum(1)
self.tail_width_slider.setMaximum(int(2 * self.layer._max_width))
self.tail_width_slider.setSingleStep(1)
# checkboxes for display
self.id_checkbox = QCheckBox()
self.tail_checkbox = QCheckBox()
self.tail_checkbox.setChecked(True)
self.graph_checkbox = QCheckBox()
self.graph_checkbox.setChecked(True)
self.tail_width_slider.valueChanged.connect(self.change_tail_width)
self.tail_length_slider.valueChanged.connect(self.change_tail_length)
self.head_length_slider.valueChanged.connect(self.change_head_length)
self.tail_checkbox.stateChanged.connect(self.change_display_tail)
self.id_checkbox.stateChanged.connect(self.change_display_id)
self.graph_checkbox.stateChanged.connect(self.change_display_graph)
self.color_by_combobox.currentTextChanged.connect(self.change_color_by)
self.colormap_combobox.currentTextChanged.connect(self.change_colormap)
self.layout().addRow(trans._('color by:'), self.color_by_combobox)
self.layout().addRow(trans._('colormap:'), self.colormap_combobox)
self.layout().addRow(trans._('blending:'), self.blendComboBox)
self.layout().addRow(self.opacityLabel, self.opacitySlider)
self.layout().addRow(trans._('tail width:'), self.tail_width_slider)
self.layout().addRow(trans._('tail length:'), self.tail_length_slider)
self.layout().addRow(trans._('head length:'), self.head_length_slider)
self.layout().addRow(trans._('tail:'), self.tail_checkbox)
self.layout().addRow(trans._('show ID:'), self.id_checkbox)
self.layout().addRow(trans._('graph:'), self.graph_checkbox)
self._on_tail_length_change()
self._on_tail_width_change()
self._on_colormap_change()
self._on_color_by_change()
def _on_tail_width_change(self):
"""Receive layer model track line width change event and update slider."""
with self.layer.events.tail_width.blocker():
value = int(2 * self.layer.tail_width)
self.tail_width_slider.setValue(value)
def _on_tail_length_change(self):
"""Receive layer model track line width change event and update slider."""
with self.layer.events.tail_length.blocker():
value = self.layer.tail_length
self.tail_length_slider.setValue(value)
def _on_head_length_change(self):
"""Receive layer model track line width change event and update slider."""
with self.layer.events.head_length.blocker():
value = self.layer.head_length
self.head_length_slider.setValue(value)
def _on_properties_change(self):
"""Change the properties that can be used to color the tracks."""
with self.layer.events.properties.blocker():
with qt_signals_blocked(self.color_by_combobox):
self.color_by_combobox.clear()
self.color_by_combobox.addItems(self.layer.properties_to_color_by)
def _on_colormap_change(self):
"""Receive layer model colormap change event and update combobox."""
with self.layer.events.colormap.blocker():
self.colormap_combobox.setCurrentIndex(
self.colormap_combobox.findData(self.layer.colormap)
)
def _on_color_by_change(self):
"""Receive layer model color_by change event and update combobox."""
with self.layer.events.color_by.blocker():
color_by = self.layer.color_by
idx = self.color_by_combobox.findText(
color_by, Qt.MatchFlag.MatchFixedString
)
self.color_by_combobox.setCurrentIndex(idx)
def change_tail_width(self, value):
"""Change track line width of shapes on the layer model.
Parameters
----------
value : float
Line width of track tails.
"""
self.layer.tail_width = float(value) / 2.0
def change_tail_length(self, value):
"""Change edge line backward length of shapes on the layer model.
Parameters
----------
value : int
Line length of track tails.
"""
self.layer.tail_length = value
def change_head_length(self, value):
"""Change edge line forward length of shapes on the layer model.
Parameters
----------
value : int
Line length of track tails.
"""
self.layer.head_length = value
def change_display_tail(self, state):
self.layer.display_tail = self.tail_checkbox.isChecked()
def change_display_id(self, state):
self.layer.display_id = self.id_checkbox.isChecked()
def change_display_graph(self, state):
self.layer.display_graph = self.graph_checkbox.isChecked()
def change_color_by(self, value: str):
self.layer.color_by = value
def change_colormap(self, colormap: str):
self.layer.colormap = self.colormap_combobox.currentData()
napari-0.5.0a1/napari/_qt/layer_controls/qt_vectors_controls.py 0000664 0000000 0000000 00000025434 14370413656 0025013 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING
import numpy as np
from qtpy.QtCore import Qt
from qtpy.QtWidgets import QCheckBox, QComboBox, QDoubleSpinBox, QLabel
from napari._qt.layer_controls.qt_layer_controls_base import QtLayerControls
from napari._qt.utils import qt_signals_blocked
from napari._qt.widgets.qt_color_swatch import QColorSwatchEdit
from napari.layers.utils._color_manager_constants import ColorMode
from napari.utils.translations import trans
if TYPE_CHECKING:
import napari.layers
class QtVectorsControls(QtLayerControls):
"""Qt view and controls for the napari Vectors layer.
Parameters
----------
layer : napari.layers.Vectors
An instance of a napari Vectors layer.
Attributes
----------
edge_color_label : qtpy.QtWidgets.QLabel
Label for edgeColorSwatch
edgeColorEdit : QColorSwatchEdit
Widget to select display color for vectors.
color_mode_comboBox : qtpy.QtWidgets.QComboBox
Dropdown widget to select edge_color_mode for the vectors.
color_prop_box : qtpy.QtWidgets.QComboBox
Dropdown widget to select _edge_color_property for the vectors.
edge_prop_label : qtpy.QtWidgets.QLabel
Label for color_prop_box
layer : napari.layers.Vectors
An instance of a napari Vectors layer.
outOfSliceCheckBox : qtpy.QtWidgets.QCheckBox
Checkbox to indicate whether to render out of slice.
lengthSpinBox : qtpy.QtWidgets.QDoubleSpinBox
Spin box widget controlling line length of vectors.
Multiplicative factor on projections for length of all vectors.
widthSpinBox : qtpy.QtWidgets.QDoubleSpinBox
Spin box widget controlling edge line width of vectors.
"""
layer: 'napari.layers.Vectors'
def __init__(self, layer) -> None:
super().__init__(layer)
# dropdown to select the property for mapping edge_color
color_properties = self._get_property_values()
self.color_prop_box = QComboBox(self)
self.color_prop_box.currentTextChanged.connect(
self.change_edge_color_property
)
self.color_prop_box.addItems(color_properties)
self.edge_prop_label = QLabel(trans._('edge property:'))
# vector direct color mode adjustment and widget
self.edgeColorEdit = QColorSwatchEdit(
initial_color=self.layer.edge_color,
tooltip=trans._(
'click to set current edge color',
),
)
self.edgeColorEdit.color_changed.connect(self.change_edge_color_direct)
self.edge_color_label = QLabel(trans._('edge color:'))
self._on_edge_color_change()
# dropdown to select the edge color mode
self.color_mode_comboBox = QComboBox(self)
color_modes = [e.value for e in ColorMode]
self.color_mode_comboBox.addItems(color_modes)
self.color_mode_comboBox.currentTextChanged.connect(
self.change_edge_color_mode
)
self._on_edge_color_mode_change()
# line width in pixels
self.widthSpinBox = QDoubleSpinBox()
self.widthSpinBox.setKeyboardTracking(False)
self.widthSpinBox.setSingleStep(0.1)
self.widthSpinBox.setMinimum(0.1)
self.widthSpinBox.setMaximum(np.inf)
self.widthSpinBox.setValue(self.layer.edge_width)
self.widthSpinBox.valueChanged.connect(self.change_width)
# line length
self.lengthSpinBox = QDoubleSpinBox()
self.lengthSpinBox.setKeyboardTracking(False)
self.lengthSpinBox.setSingleStep(0.1)
self.lengthSpinBox.setValue(self.layer.length)
self.lengthSpinBox.setMinimum(0.1)
self.lengthSpinBox.setMaximum(np.inf)
self.lengthSpinBox.valueChanged.connect(self.change_length)
out_of_slice_cb = QCheckBox()
out_of_slice_cb.setToolTip(trans._('Out of slice display'))
out_of_slice_cb.setChecked(self.layer.out_of_slice_display)
out_of_slice_cb.stateChanged.connect(self.change_out_of_slice)
self.outOfSliceCheckBox = out_of_slice_cb
self.layout().addRow(self.opacityLabel, self.opacitySlider)
self.layout().addRow(trans._('width:'), self.widthSpinBox)
self.layout().addRow(trans._('length:'), self.lengthSpinBox)
self.layout().addRow(trans._('blending:'), self.blendComboBox)
self.layout().addRow(
trans._('edge color mode:'), self.color_mode_comboBox
)
self.layout().addRow(self.edge_color_label, self.edgeColorEdit)
self.layout().addRow(self.edge_prop_label, self.color_prop_box)
self.layout().addRow(trans._('out of slice:'), self.outOfSliceCheckBox)
self.layer.events.edge_width.connect(self._on_edge_width_change)
self.layer.events.length.connect(self._on_length_change)
self.layer.events.out_of_slice_display.connect(
self._on_out_of_slice_display_change
)
self.layer.events.edge_color_mode.connect(
self._on_edge_color_mode_change
)
self.layer.events.edge_color.connect(self._on_edge_color_change)
def change_edge_color_property(self, property: str):
"""Change edge_color_property of vectors on the layer model.
This property is the property the edge color is mapped to.
Parameters
----------
property : str
property to map the edge color to
"""
mode = self.layer.edge_color_mode
try:
self.layer.edge_color = property
self.layer.edge_color_mode = mode
except TypeError:
# if the selected property is the wrong type for the current color mode
# the color mode will be changed to the appropriate type, so we must update
self._on_edge_color_mode_change()
raise
def change_edge_color_mode(self, mode: str):
"""Change edge color mode of vectors on the layer model.
Parameters
----------
mode : str
Edge color for vectors. Must be: 'direct', 'cycle', or 'colormap'
"""
old_mode = self.layer.edge_color_mode
with self.layer.events.edge_color_mode.blocker():
try:
self.layer.edge_color_mode = mode
self._update_edge_color_gui(mode)
except ValueError:
# if the color mode was invalid, revert to the old mode
self.layer.edge_color_mode = old_mode
raise
def change_edge_color_direct(self, color: np.ndarray):
"""Change edge color of vectors on the layer model.
Parameters
----------
color : np.ndarray
Edge color for vectors, in an RGBA array
"""
self.layer.edge_color = color
def change_width(self, value):
"""Change edge line width of vectors on the layer model.
Parameters
----------
value : float
Line width of vectors.
"""
self.layer.edge_width = value
self.widthSpinBox.clearFocus()
self.setFocus()
def change_length(self, value):
"""Change length of vectors on the layer model.
Multiplicative factor on projections for length of all vectors.
Parameters
----------
value : float
Length of vectors.
"""
self.layer.length = value
self.lengthSpinBox.clearFocus()
self.setFocus()
def change_out_of_slice(self, state):
"""Toggle out of slice display of vectors layer.
Parameters
----------
state : QCheckBox
Checkbox to indicate whether to render out of slice.
"""
self.layer.out_of_slice_display = state == Qt.CheckState.Checked
def _update_edge_color_gui(self, mode: str):
"""Update the GUI element associated with edge_color.
This is typically used when edge_color_mode changes
Parameters
----------
mode : str
The new edge_color mode the GUI needs to be updated for.
Should be: 'direct', 'cycle', 'colormap'
"""
if mode in {'cycle', 'colormap'}:
self.edgeColorEdit.setHidden(True)
self.edge_color_label.setHidden(True)
self.color_prop_box.setHidden(False)
self.edge_prop_label.setHidden(False)
elif mode == 'direct':
self.edgeColorEdit.setHidden(False)
self.edge_color_label.setHidden(False)
self.color_prop_box.setHidden(True)
self.edge_prop_label.setHidden(True)
def _get_property_values(self):
"""Get the current property values from the Vectors layer
Returns
-------
property_values : np.ndarray
array of all of the union of the property names (keys)
in Vectors.properties and Vectors.property_choices
"""
property_choices = [*self.layer.property_choices]
properties = [*self.layer.properties]
property_values = np.union1d(property_choices, properties)
return property_values
def _on_length_change(self):
"""Change length of vectors."""
with self.layer.events.length.blocker():
self.lengthSpinBox.setValue(self.layer.length)
def _on_out_of_slice_display_change(self, event):
"""Receive layer model out_of_slice_display change event and update checkbox."""
with self.layer.events.out_of_slice_display.blocker():
self.outOfSliceCheckBox.setChecked(self.layer.out_of_slice_display)
def _on_edge_width_change(self):
"""Receive layer model width change event and update width spinbox."""
with self.layer.events.edge_width.blocker():
self.widthSpinBox.setValue(self.layer.edge_width)
def _on_edge_color_mode_change(self):
"""Receive layer model edge color mode change event & update dropdown."""
with qt_signals_blocked(self.color_mode_comboBox):
mode = self.layer._edge.color_mode
index = self.color_mode_comboBox.findText(
mode, Qt.MatchFixedString
)
self.color_mode_comboBox.setCurrentIndex(index)
self._update_edge_color_gui(mode)
def _on_edge_color_change(self):
"""Receive layer model edge color change event & update dropdown."""
if (
self.layer._edge.color_mode == ColorMode.DIRECT
and len(self.layer.data) > 0
):
with qt_signals_blocked(self.edgeColorEdit):
self.edgeColorEdit.setColor(self.layer.edge_color[0])
elif self.layer._edge.color_mode in (
ColorMode.CYCLE,
ColorMode.COLORMAP,
):
with qt_signals_blocked(self.color_prop_box):
prop = self.layer._edge.color_properties.name
index = self.color_prop_box.findText(prop, Qt.MatchFixedString)
self.color_prop_box.setCurrentIndex(index)
napari-0.5.0a1/napari/_qt/menus/ 0000775 0000000 0000000 00000000000 14370413656 0016405 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/menus/__init__.py 0000664 0000000 0000000 00000000441 14370413656 0020515 0 ustar 00root root 0000000 0000000 from napari._qt.menus.debug_menu import DebugMenu
from napari._qt.menus.file_menu import FileMenu
from napari._qt.menus.plugins_menu import PluginsMenu
from napari._qt.menus.window_menu import WindowMenu
__all__ = [
'DebugMenu',
'FileMenu',
'PluginsMenu',
'WindowMenu',
]
napari-0.5.0a1/napari/_qt/menus/_tests/ 0000775 0000000 0000000 00000000000 14370413656 0017706 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/menus/_tests/__init__.py 0000664 0000000 0000000 00000000000 14370413656 0022005 0 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/menus/_tests/test_file_menu.py 0000664 0000000 0000000 00000010771 14370413656 0023270 0 ustar 00root root 0000000 0000000 from unittest import mock
import pytest
import qtpy
from npe2 import DynamicPlugin
from npe2.manifest.contributions import SampleDataURI
from qtpy.QtWidgets import QMenu
from napari.utils.action_manager import action_manager
def test_sample_data_triggers_reader_dialog(
make_napari_viewer, tmp_plugin: DynamicPlugin
):
"""Sample data pops reader dialog if multiple compatible readers"""
# make two tmp readers that take tif files
tmp2 = tmp_plugin.spawn(register=True)
@tmp_plugin.contribute.reader(filename_patterns=['*.tif'])
def _(path):
...
@tmp2.contribute.reader(filename_patterns=['*.tif'])
def _(path):
...
# make a sample data reader for tif file
my_sample = SampleDataURI(
key='tmp-sample',
display_name='Temp Sample',
uri='some-path/some-file.tif',
)
tmp_plugin.manifest.contributions.sample_data = [my_sample]
viewer = make_napari_viewer()
sample_action = viewer.window.file_menu.open_sample_menu.actions()[0]
with mock.patch(
'napari._qt.menus.file_menu.handle_gui_reading'
) as mock_read:
sample_action.trigger()
# assert that handle gui reading was called
mock_read.assert_called_once()
def test_plugin_display_name_use_for_multiple_samples(
make_napari_viewer, builtins
):
"""For plugin with more than two sample datasets, should use plugin_display for building the menu"""
viewer = make_napari_viewer()
# builtins provides more than one sample, so the submenu should use the `display_name` from manifest
plugin_action_menu = viewer.window.file_menu.open_sample_menu.actions()[
0
].menu()
assert plugin_action_menu.title() == 'napari builtins'
# Now ensure that the actions are still correct
# trigger the action, opening the first sample: `Astronaut`
assert len(viewer.layers) == 0
plugin_action_menu.actions()[0].trigger()
assert len(viewer.layers) == 1
assert viewer.layers[0].name == 'astronaut'
def test_show_shortcuts_actions(make_napari_viewer):
viewer = make_napari_viewer()
assert viewer.window.file_menu._pref_dialog is None
action_manager.trigger("napari:show_shortcuts")
assert viewer.window.file_menu._pref_dialog is not None
assert (
viewer.window.file_menu._pref_dialog._list.currentItem().text()
== "Shortcuts"
)
viewer.window.file_menu._pref_dialog.close()
def get_open_with_plugin_action(viewer, action_text):
def _get_menu(act):
# this function may be removed when PyQt6 will release next version
# (after 6.3.1 - if we do not want to support this test on older PyQt6)
# https://www.riverbankcomputing.com/pipermail/pyqt/2022-July/044817.html
# because both PyQt6 and PySide6 will have working manu method of action
return (
QMenu.menuInAction(act)
if getattr(qtpy, 'PYQT6', False)
else act.menu()
)
actions = viewer.window.file_menu.actions()
for action1 in actions:
if action1.text() == 'Open with Plugin':
for action2 in _get_menu(action1).actions():
if action2.text() == action_text:
return action2, action1
raise ValueError(
f'Could not find action "{action_text}"'
) # pragma: no cover
@pytest.mark.parametrize(
"menu_str,dialog_method,dialog_return,filename_call,stack",
[
(
'Open File(s)...',
'getOpenFileNames',
(['my-file.tif'], ''),
['my-file.tif'],
False,
),
(
'Open Files as Stack...',
'getOpenFileNames',
(['my-file.tif'], ''),
['my-file.tif'],
True,
),
(
'Open Folder...',
'getExistingDirectory',
'my-dir/',
['my-dir/'],
False,
),
],
)
def test_open_with_plugin(
make_napari_viewer,
menu_str,
dialog_method,
dialog_return,
filename_call,
stack,
):
viewer = make_napari_viewer()
action, _a = get_open_with_plugin_action(viewer, menu_str)
with mock.patch(
'napari._qt.qt_viewer.QFileDialog'
) as mock_file, mock.patch(
'napari._qt.qt_viewer.QtViewer._qt_open'
) as mock_read:
mock_file_instance = mock_file.return_value
getattr(mock_file_instance, dialog_method).return_value = dialog_return
action.trigger()
mock_read.assert_called_once_with(
filename_call, stack=stack, choose_plugin=True
)
napari-0.5.0a1/napari/_qt/menus/_tests/test_plugins_menu.py 0000664 0000000 0000000 00000002201 14370413656 0024017 0 ustar 00root root 0000000 0000000 from npe2 import DynamicPlugin
from qtpy.QtWidgets import QWidget
class DummyWidget(QWidget):
pass
def test_plugin_display_name_use_for_multiple_widgets(
make_napari_viewer, tmp_plugin: DynamicPlugin
):
"""For plugin with more than two widgets, should use plugin_display for building the menu"""
@tmp_plugin.contribute.widget(display_name='Widget 1')
def widget1():
return DummyWidget()
@tmp_plugin.contribute.widget(display_name='Widget 2')
def widget2():
return DummyWidget()
assert tmp_plugin.display_name == 'Temp Plugin'
viewer = make_napari_viewer()
# the submenu should use the `display_name` from manifest
plugin_action_menu = viewer.window.plugins_menu.actions()[3].menu()
assert plugin_action_menu.title() == tmp_plugin.display_name
# Now ensure that the actions are still correct
# trigger the action, opening the first widget: `Widget 1`
assert len(viewer.window._dock_widgets) == 0
plugin_action_menu.actions()[0].trigger()
assert len(viewer.window._dock_widgets) == 1
assert list(viewer.window._dock_widgets.data)[0] == 'Widget 1 (tmp_plugin)'
napari-0.5.0a1/napari/_qt/menus/_tests/test_util.py 0000664 0000000 0000000 00000002276 14370413656 0022303 0 ustar 00root root 0000000 0000000 from unittest.mock import MagicMock
from qtpy.QtWidgets import QMenu
from napari._qt.menus._util import populate_menu
def test_populate_menu_create(qtbot):
"""Test the populate_menu function."""
mock = MagicMock()
menu = QMenu()
populate_menu(menu, [{"text": "test", "slot": mock}])
assert len(menu.actions()) == 1
assert menu.actions()[0].text() == "test"
assert menu.actions()[0].isCheckable() is False
with qtbot.waitSignal(menu.actions()[0].triggered):
menu.actions()[0].trigger()
mock.assert_called_once()
def test_populate_menu_create_checkable(qtbot):
"""Test the populate_menu function with checkable actions."""
mock = MagicMock()
menu = QMenu()
populate_menu(menu, [{"text": "test", "slot": mock, "checkable": True}])
assert len(menu.actions()) == 1
assert menu.actions()[0].text() == "test"
assert menu.actions()[0].isCheckable() is True
with qtbot.waitSignal(menu.actions()[0].triggered):
menu.actions()[0].trigger()
mock.assert_called_once_with(True)
mock.reset_mock()
with qtbot.waitSignal(menu.actions()[0].triggered):
menu.actions()[0].trigger()
mock.assert_called_once_with(False)
napari-0.5.0a1/napari/_qt/menus/_util.py 0000664 0000000 0000000 00000010525 14370413656 0020076 0 ustar 00root root 0000000 0000000 import contextlib
from typing import TYPE_CHECKING, Callable, List, Union
from qtpy.QtWidgets import QAction, QMenu
if TYPE_CHECKING:
from typing_extensions import TypedDict
from napari.utils.events import EventEmitter
try:
from qtpy.QtCore import SignalInstance
except ImportError:
from qtpy.QtCore import pyqtBoundSignal as SignalInstance
class ActionDict(TypedDict):
text: str
# these are optional
slot: Callable
shortcut: str
statusTip: str
menuRole: QAction.MenuRole
checkable: bool
checked: bool
check_on: Union[EventEmitter, SignalInstance]
class MenuDict(TypedDict):
menu: str
# these are optional
items: List[ActionDict]
# note: TypedDict still doesn't have the concept of "optional keys"
# so we add in generic `dict` for type checking.
# see PEP655: https://peps.python.org/pep-0655/
MenuItem = Union[MenuDict, ActionDict, dict]
def populate_menu(menu: QMenu, actions: List['MenuItem']):
"""Populate a QMenu from a declarative list of QAction dicts.
Parameters
----------
menu : QMenu
the menu to populate
actions : list of dict
A list of dicts with one or more of the following keys
**Required: One of "text" or "menu" MUST be present in the dict**
text: str
the name of the QAction to add
menu: str
if present, creates a submenu instead. "menu" keys may also
provide an "items" key to populate the menu.
**Optional:**
slot: callable
a callback to call when the action is triggered
shortcut: str
a keyboard shortcut to trigger the actoin
statusTip: str
used for setStatusTip
menuRole: QAction.MenuRole
used for setMenuRole
checkable: bool
used for setCheckable
checked: bool
used for setChecked (only if `checkable` is provided and True)
check_on: EventEmitter
If provided, and `checkable` is True, this EventEmitter will be
connected to action.setChecked:
`dct['check_on'].connect(lambda e: action.setChecked(e.value))`
"""
for ax in actions:
if not ax:
menu.addSeparator()
continue
if not ax.get("when", True):
continue
if 'menu' in ax:
sub = ax['menu']
if isinstance(sub, QMenu):
menu.addMenu(sub)
sub.setParent(menu)
else:
sub = menu.addMenu(sub)
populate_menu(sub, ax.get("items", []))
continue
action: QAction = menu.addAction(ax['text'])
if 'slot' in ax:
if ax.get("checkable"):
action.toggled.connect(ax['slot'])
else:
action.triggered.connect(ax['slot'])
action.setShortcut(ax.get('shortcut', ''))
action.setStatusTip(ax.get('statusTip', ''))
if 'menuRole' in ax:
action.setMenuRole(ax['menuRole'])
if ax.get("checkable"):
action.setCheckable(True)
action.setChecked(ax.get("checked", False))
if 'check_on' in ax:
emitter = ax['check_on']
@emitter.connect
def _setchecked(e, action=action):
action.setChecked(e.value if hasattr(e, 'value') else e)
action.setData(ax)
class NapariMenu(QMenu):
"""
Base napari menu class that provides action handling and clean up on
close.
"""
_INSTANCES: List['NapariMenu'] = []
def __init__(self, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
self._INSTANCES.append(self)
def _destroy(self):
"""Clean up action data to avoid widget leaks."""
for ax in self.actions():
ax.setData(None)
with contextlib.suppress(AttributeError):
ax._destroy()
if self in self._INSTANCES:
self._INSTANCES.remove(self)
def update(self, event=None):
"""Update action enabled/disabled state based on action data."""
for ax in self.actions():
if data := ax.data():
enabled_func = data.get('enabled', lambda event: True)
ax.setEnabled(bool(enabled_func(event)))
napari-0.5.0a1/napari/_qt/menus/debug_menu.py 0000664 0000000 0000000 00000006747 14370413656 0021107 0 ustar 00root root 0000000 0000000 """Debug menu.
The debug menu is for developer-focused functionality that we want to be
easy-to-use and discoverable, but which is not for the average user.
"""
from typing import TYPE_CHECKING
from qtpy.QtCore import QTimer
from qtpy.QtWidgets import QFileDialog
from napari._qt.menus._util import NapariMenu, populate_menu
from napari.utils import perf
from napari.utils.history import get_save_history, update_save_history
from napari.utils.translations import trans
if TYPE_CHECKING:
from napari._qt.qt_main_window import Window
class DebugMenu(NapariMenu):
def __init__(self, window: 'Window') -> None:
self._win = window
super().__init__(trans._('&Debug'), window._qt_window)
self._perf_menu = NapariMenu(trans._("Performance Trace"), self)
ACTIONS = [
{
'menu': self._perf_menu,
'items': [
{
'text': trans._('Start Recording...'),
'slot': self._start_trace_dialog,
'shortcut': 'Alt+T',
'statusTip': trans._('Start recording a trace file'),
},
{
'text': trans._('Stop Recording...'),
'slot': self._stop_trace,
'shortcut': 'Shift+Alt+T',
'statusTip': trans._('Stop recording a trace file'),
},
],
}
]
populate_menu(self, ACTIONS)
self._set_recording(False)
if perf.perf_config:
path = perf.perf_config.trace_file_on_start
if path is not None:
# Config option "trace_file_on_start" means immediately
# start tracing to that file. This is very useful if you
# want to create a trace every time you start napari,
# without having to start it from the debug menu.
self._start_trace(path)
def _start_trace_dialog(self):
"""Open Save As dialog to start recording a trace file."""
viewer = self._win._qt_viewer
dlg = QFileDialog()
hist = get_save_history()
dlg.setHistory(hist)
filename, _ = dlg.getSaveFileName(
parent=viewer,
caption=trans._('Record performance trace file'),
directory=hist[0],
filter=trans._("Trace Files (*.json)"),
)
if filename:
if not filename.endswith(".json"):
filename += ".json"
# Schedule this to avoid bogus "MetaCall" event for the entire
# time the file dialog was up.
QTimer.singleShot(0, lambda: self._start_trace(filename))
update_save_history(filename)
def _start_trace(self, path: str):
perf.timers.start_trace_file(path)
self._set_recording(True)
def _stop_trace(self):
"""Stop recording a trace file."""
perf.timers.stop_trace_file()
self._set_recording(False)
def _set_recording(self, recording: bool):
"""Toggle which are enabled/disabled.
Parameters
----------
recording : bool
Are we currently recording a trace file.
"""
for action in self._perf_menu.actions():
if trans._('Start Recording') in action.text():
action.setEnabled(not recording)
elif trans._('Stop Recording') in action.text():
action.setEnabled(recording)
napari-0.5.0a1/napari/_qt/menus/file_menu.py 0000664 0000000 0000000 00000023152 14370413656 0020725 0 ustar 00root root 0000000 0000000 from itertools import chain
from typing import TYPE_CHECKING
from qtpy.QtCore import QSize
from qtpy.QtWidgets import QAction, QMenu
from napari._qt.dialogs.preferences_dialog import PreferencesDialog
from napari._qt.dialogs.qt_reader_dialog import handle_gui_reading
from napari._qt.dialogs.screenshot_dialog import ScreenshotDialog
from napari._qt.menus._util import NapariMenu, populate_menu
from napari.components._viewer_key_bindings import register_viewer_action
from napari.errors.reader_errors import MultipleReaderError
from napari.settings import get_settings
from napari.utils.history import get_save_history, update_save_history
from napari.utils.misc import running_as_bundled_app
from napari.utils.translations import trans
if TYPE_CHECKING:
from napari import Viewer
from napari._qt.qt_main_window import Window
class FileMenu(NapariMenu):
def __init__(self, window: 'Window') -> None:
self._win = window
super().__init__(trans._('&File'), window._qt_window)
self.open_sample_menu = NapariMenu(trans._('Open Sample'), self)
ACTIONS = [
{
'text': trans._('Open File(s)...'),
'slot': window._qt_viewer._open_files_dialog,
'shortcut': 'Ctrl+O',
},
{
'text': trans._('Open Files as Stack...'),
'slot': window._qt_viewer._open_files_dialog_as_stack_dialog,
'shortcut': 'Ctrl+Alt+O',
},
{
'text': trans._('Open Folder...'),
'slot': window._qt_viewer._open_folder_dialog,
'shortcut': 'Ctrl+Shift+O',
},
{
'menu': trans._('Open with Plugin'),
'items': [
{
'text': 'Open File(s)...',
'slot': self._open_files_w_plugin,
},
{
'text': 'Open Files as Stack...',
'slot': self._open_files_as_stack_w_plugin,
},
{
'text': 'Open Folder...',
'slot': self._open_folder_w_plugin,
},
],
},
{'menu': self.open_sample_menu},
{},
{
'text': trans._('Preferences'),
'slot': self._open_preferences,
'shortcut': 'Ctrl+Shift+P',
'statusTip': trans._('Open preferences dialog'),
'menuRole': QAction.PreferencesRole,
},
{},
{
'text': trans._('Save Selected Layer(s)...'),
'slot': lambda: window._qt_viewer._save_layers_dialog(
selected=True
),
'shortcut': 'Ctrl+S',
'enabled': self._layer_count,
},
{
'text': trans._('Save All Layers...'),
'slot': lambda: window._qt_viewer._save_layers_dialog(
selected=False
),
'shortcut': 'Ctrl+Shift+S',
'enabled': self._layer_count,
},
{
'text': trans._('Save Screenshot...'),
'slot': window._qt_viewer._screenshot_dialog,
'shortcut': 'Alt+S',
'statusTip': trans._(
'Save screenshot of current display, default .png'
),
},
{
'text': trans._('Save Screenshot with Viewer...'),
'slot': self._screenshot_dialog,
'shortcut': 'Alt+Shift+S',
'statusTip': trans._(
'Save screenshot of current display with the viewer, default .png'
),
},
{
'text': trans._('Copy Screenshot to Clipboard'),
'slot': window._qt_viewer.clipboard,
'shortcut': 'Alt+C',
'statusTip': trans._(
'Copy screenshot of current display to the clipboard'
),
},
{
'text': trans._('Copy Screenshot with Viewer to Clipboard'),
'slot': window.clipboard,
'shortcut': 'Alt+Shift+C',
'statusTip': trans._(
'Copy screenshot of current display with the viewer to the clipboard'
),
},
{},
{
'text': trans._('Close Window'),
'slot': self._close_window,
'shortcut': 'Ctrl+W',
},
{
'when': running_as_bundled_app(),
'text': trans._('Restart'),
'slot': window._qt_window.restart,
},
# OS X will rename this to Quit and put it in the app menu.
# This quits the entire QApplication and closes all windows.
{
'text': trans._('Exit'),
'slot': self._close_app,
'shortcut': 'Ctrl+Q',
'menuRole': QAction.QuitRole,
},
]
populate_menu(self, ACTIONS)
self._pref_dialog = None
from napari.plugins import plugin_manager
plugin_manager.discover_sample_data()
plugin_manager.events.disabled.connect(self._rebuild_samples_menu)
plugin_manager.events.registered.connect(self._rebuild_samples_menu)
plugin_manager.events.unregistered.connect(self._rebuild_samples_menu)
self._rebuild_samples_menu()
self.update()
def _close_app(self):
self._win._qt_window.close(quit_app=True, confirm_need=True)
def _close_window(self):
self._win._qt_window.close(quit_app=False, confirm_need=True)
def _layer_count(self, event=None):
return len(self._win._qt_viewer.viewer.layers)
def _screenshot_dialog(self):
"""Save screenshot of current display with viewer, default .png"""
hist = get_save_history()
dial = ScreenshotDialog(
self._win.screenshot, self._win._qt_viewer, hist[0], hist
)
if dial.exec_():
update_save_history(dial.selectedFiles()[0])
def _open_preferences(self):
"""Edit preferences from the menubar."""
if self._pref_dialog is None:
win = PreferencesDialog(parent=self._win._qt_window)
self._pref_dialog = win
app_pref = get_settings().application
if app_pref.preferences_size:
win.resize(*app_pref.preferences_size)
@win.resized.connect
def _save_size(sz: QSize):
app_pref.preferences_size = (sz.width(), sz.height())
win.finished.connect(self._clean_pref_dialog)
win.show()
else:
self._pref_dialog.raise_()
def _clean_pref_dialog(self):
self._pref_dialog = None
def _rebuild_samples_menu(self):
from napari.plugins import _npe2, menu_item_template, plugin_manager
self.open_sample_menu.clear()
for plugin_name, samples in chain(
_npe2.sample_iterator(), plugin_manager._sample_data.items()
):
multiprovider = len(samples) > 1
if multiprovider:
# use display_name for the menu item if npe2
from npe2 import plugin_manager as pm
try:
plugin_display_name = pm.get_manifest(
plugin_name
).display_name
except KeyError:
plugin_display_name = plugin_name
menu = self.open_sample_menu.addMenu(
QMenu(title=plugin_display_name, parent=self)
).menu()
else:
menu = self.open_sample_menu
for samp_name, samp_dict in samples.items():
display_name = samp_dict['display_name'].replace("&", "&&")
if multiprovider:
action = QAction(display_name, parent=self)
else:
full_name = menu_item_template.format(
plugin_name, display_name
)
action = QAction(full_name, parent=self)
def _add_sample(*_, plg=plugin_name, smp=samp_name):
try:
self._win._qt_viewer.viewer.open_sample(plg, smp)
except MultipleReaderError as e:
handle_gui_reading(
e.paths,
self._win._qt_viewer,
plugin_name=plg,
stack=False,
)
menu.addAction(action)
action.triggered.connect(_add_sample)
def _open_files_w_plugin(self):
"""Helper method for forcing plugin choice"""
self._win._qt_viewer._open_files_dialog(choose_plugin=True)
def _open_files_as_stack_w_plugin(self):
"""Helper method for forcing plugin choice"""
self._win._qt_viewer._open_files_dialog_as_stack_dialog(
choose_plugin=True
)
def _open_folder_w_plugin(self):
"""Helper method for forcing plugin choice"""
self._win._qt_viewer._open_folder_dialog(choose_plugin=True)
@register_viewer_action(trans._("Show all key bindings"))
def show_shortcuts(viewer: 'Viewer'):
viewer.window.file_menu._open_preferences()
pref_list = viewer.window.file_menu._pref_dialog._list
for i in range(pref_list.count()):
if pref_list.item(i).text() == "Shortcuts":
pref_list.setCurrentRow(i)
napari-0.5.0a1/napari/_qt/menus/plugins_menu.py 0000664 0000000 0000000 00000011007 14370413656 0021463 0 ustar 00root root 0000000 0000000 from itertools import chain
from typing import TYPE_CHECKING, Sequence
from qtpy.QtWidgets import QAction
from napari._qt.dialogs.qt_plugin_dialog import QtPluginDialog
from napari._qt.dialogs.qt_plugin_report import QtPluginErrReporter
from napari._qt.menus._util import NapariMenu
from napari.plugins import _npe2
from napari.utils.translations import trans
if TYPE_CHECKING:
from napari._qt.qt_main_window import Window
class PluginsMenu(NapariMenu):
def __init__(self, window: 'Window') -> None:
self._win = window
super().__init__(trans._('&Plugins'), window._qt_window)
from napari.plugins import plugin_manager
_npe2.index_npe1_adapters()
plugin_manager.discover_widgets()
plugin_manager.events.disabled.connect(
self._remove_unregistered_widget
)
plugin_manager.events.registered.connect(self._add_registered_widget)
plugin_manager.events.unregistered.connect(
self._remove_unregistered_widget
)
self._build()
def _build(self, event=None):
self.clear()
action = self.addAction(trans._("Install/Uninstall Plugins..."))
action.triggered.connect(self._show_plugin_install_dialog)
action = self.addAction(trans._("Plugin Errors..."))
action.setStatusTip(
trans._(
'Review stack traces for plugin exceptions and notify developers'
)
)
action.triggered.connect(self._show_plugin_err_reporter)
self.addSeparator()
# Add a menu item (QAction) for each available plugin widget
self._add_registered_widget(call_all=True)
def _remove_unregistered_widget(self, event):
for action in self.actions():
if event.value in action.text():
self.removeAction(action)
self._win._remove_dock_widget(event=event)
def _add_registered_widget(self, event=None, call_all=False):
from napari.plugins import plugin_manager
# eg ('dock', ('my_plugin', {'My widget': MyWidget}))
for hook_type, (plugin_name, widgets) in chain(
_npe2.widget_iterator(), plugin_manager.iter_widgets()
):
if call_all or event.value == plugin_name:
self._add_plugin_actions(hook_type, plugin_name, widgets)
def _add_plugin_actions(
self, hook_type: str, plugin_name: str, widgets: Sequence[str]
):
from napari.plugins import menu_item_template
multiprovider = len(widgets) > 1
if multiprovider:
# use display_name if npe2 plugin
from npe2 import plugin_manager as pm
try:
plugin_display_name = pm.get_manifest(plugin_name).display_name
except KeyError:
plugin_display_name = plugin_name
menu = NapariMenu(plugin_display_name, self)
self.addMenu(menu)
else:
menu = self
for wdg_name in widgets:
key = (plugin_name, wdg_name)
if multiprovider:
action = QAction(wdg_name.replace("&", "&&"), parent=self)
else:
full_name = menu_item_template.format(*key)
action = QAction(full_name.replace("&", "&&"), parent=self)
def _add_toggle_widget(*, key=key, hook_type=hook_type):
full_name = menu_item_template.format(*key)
if full_name in self._win._dock_widgets.keys():
dock_widget = self._win._dock_widgets[full_name]
if dock_widget.isVisible():
dock_widget.hide()
else:
dock_widget.show()
return
if hook_type == 'dock':
self._win.add_plugin_dock_widget(*key)
else:
self._win._add_plugin_function_widget(*key)
action.setCheckable(True)
# check that this wasn't added to the menu already
actions = [a.text() for a in menu.actions()]
if action.text() not in actions:
menu.addAction(action)
action.triggered.connect(_add_toggle_widget)
def _show_plugin_install_dialog(self):
"""Show dialog that allows users to sort the call order of plugins."""
QtPluginDialog(self._win._qt_window).exec_()
def _show_plugin_err_reporter(self):
"""Show dialog that allows users to review and report plugin errors."""
QtPluginErrReporter(parent=self._win._qt_window).exec_()
napari-0.5.0a1/napari/_qt/menus/window_menu.py 0000664 0000000 0000000 00000000633 14370413656 0021314 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING
from napari._qt.menus._util import NapariMenu, populate_menu
from napari.utils.translations import trans
if TYPE_CHECKING:
from napari._qt.qt_main_window import Window
class WindowMenu(NapariMenu):
def __init__(self, window: 'Window') -> None:
super().__init__(trans._('&Window'), window._qt_window)
ACTIONS = []
populate_menu(self, ACTIONS)
napari-0.5.0a1/napari/_qt/perf/ 0000775 0000000 0000000 00000000000 14370413656 0016212 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/perf/__init__.py 0000664 0000000 0000000 00000000000 14370413656 0020311 0 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/perf/_tests/ 0000775 0000000 0000000 00000000000 14370413656 0017513 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/perf/_tests/__init__.py 0000664 0000000 0000000 00000000000 14370413656 0021612 0 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/perf/_tests/test_perf.py 0000664 0000000 0000000 00000005132 14370413656 0022061 0 ustar 00root root 0000000 0000000 import dataclasses
import json
import os
import subprocess
import sys
from pathlib import Path
from unittest.mock import MagicMock
from napari._qt.perf import qt_performance
from napari._tests.utils import skip_local_popups, skip_on_win_ci
# NOTE:
# for some reason, running this test fails in a subprocess with a segfault
# if you don't show the viewer...
PERFMON_SCRIPT = """
import napari
from qtpy.QtCore import QTimer
v = napari.view_points()
QTimer.singleShot(100, napari._qt.qt_event_loop.quit_app)
napari.run()
"""
CONFIG = {
"trace_qt_events": True,
"trace_file_on_start": '',
"trace_callables": ["chunk_loader"],
"callable_lists": {
"chunk_loader": [
"napari.components.experimental.chunk._loader.ChunkLoader.load_request",
"napari.components.experimental.chunk._loader.ChunkLoader._on_done",
]
},
}
@skip_on_win_ci
@skip_local_popups
def test_trace_on_start(tmp_path: Path):
"""Make sure napari can write a perfmon trace file."""
trace_path = tmp_path / "trace.json"
config_path = tmp_path / "perfmon.json"
CONFIG['trace_file_on_start'] = str(trace_path)
config_path.write_text(json.dumps(CONFIG))
env = os.environ.copy()
env.update({'NAPARI_PERFMON': str(config_path), 'NAPARI_CONFIG': ''})
subprocess.run([sys.executable, '-c', PERFMON_SCRIPT], env=env, check=True)
# Make sure file exists and is not empty.
assert trace_path.exists(), "Trace file not written"
assert trace_path.stat().st_size > 0, "Trace file is empty"
# Assert every event contains every important field.
with open(trace_path) as infile:
data = json.load(infile)
assert len(data) > 0
for event in data:
for field in ['pid', 'tid', 'name', 'ph', 'ts', 'args']:
assert field in event
def test_qt_performance(qtbot, monkeypatch):
widget = qt_performance.QtPerformance()
widget.timer.stop()
qtbot.addWidget(widget)
mock = MagicMock()
data = [
("test1", MockTimer(1, 1)),
("test2", MockTimer(20, 120)),
("test1", MockTimer(70, 90)),
("test2", MockTimer(50, 220)),
]
mock.timers.items = MagicMock(return_value=data)
monkeypatch.setattr(qt_performance.perf, 'timers', mock)
assert widget.log.toPlainText() == ""
widget.update()
assert widget.log.toPlainText() == ' 120ms test2\n 220ms test2\n'
widget._change_thresh("150")
assert widget.log.toPlainText() == ""
widget.update()
assert widget.log.toPlainText() == ' 220ms test2\n'
@dataclasses.dataclass
class MockTimer:
average: float
max: float
napari-0.5.0a1/napari/_qt/perf/qt_event_tracing.py 0000664 0000000 0000000 00000006547 14370413656 0022134 0 ustar 00root root 0000000 0000000 """A special QApplication for perfmon that traces events.
This file defines QApplicationWithTracing which we use when perfmon is
enabled to time Qt Events.
When using perfmon there is a debug menu "Start Tracing" command as well as a
dockable QtPerformance widget.
"""
from qtpy.QtCore import QEvent
from qtpy.QtWidgets import QApplication, QWidget
from napari.utils import perf
from napari.utils.translations import trans
class QApplicationWithTracing(QApplication):
"""Extend QApplication to trace Qt Events.
This QApplication wraps a perf_timer around the normal notify().
Notes
-----
Qt Event handling is nested. A call to notify() can trigger other calls to
notify() prior to the first one finishing, even several levels deep.
The hierarchy of timers is displayed correctly in the chrome://tracing GUI.
Seeing the structure of the event handling hierarchy can be very informative
even apart from the actual timing numbers, which is why we call it "tracing"
instead of just "timing".
"""
def notify(self, receiver, event):
"""Trace events while we handle them."""
timer_name = _get_event_label(receiver, event)
# Time the event while we handle it.
with perf.perf_timer(timer_name, "qt_event"):
return QApplication.notify(self, receiver, event)
class EventTypes:
"""Convert event type to a string name.
Create event type to string mapping once on startup. We want human-readable
event names for our timers. PySide2 does this for you but PyQt5 does not:
# PySide2
str(QEvent.KeyPress) -> 'PySide2.QtCore.QEvent.Type.KeyPress'
# PyQt5
str(QEvent.KeyPress) -> '6'
We use this class for PyQt5 and PySide2 to be consistent.
"""
def __init__(self) -> None:
"""Create mapping for all known event types."""
self.string_name = {}
for name in vars(QEvent):
attribute = getattr(QEvent, name)
if type(attribute) == QEvent.Type:
self.string_name[attribute] = name
def as_string(self, event: QEvent.Type) -> str:
"""Return the string name for this event.
event : QEvent.Type
Return string for this event type.
"""
try:
return self.string_name[event]
except KeyError:
return trans._("UnknownEvent:{event}", event=event)
EVENT_TYPES = EventTypes()
def _get_event_label(receiver: QWidget, event: QEvent) -> str:
"""Return a label for this event.
Parameters
----------
receiver : QWidget
The receiver of the event.
event : QEvent
The event name.
Returns
-------
str
Label to display for the event.
Notes
-----
If no object we return .
If there's an object we return :.
Combining the two names with a colon is our own made-up format. The name
will show up in chrome://tracing and our QtPerformance widget.
"""
event_str = EVENT_TYPES.as_string(event.type())
try:
# There may or may not be a receiver object name.
object_name = receiver.objectName()
except AttributeError:
# Ignore "missing objectName attribute" during shutdown.
object_name = None
if object_name:
return f"{event_str}:{object_name}"
# There was no object (pretty common).
return event_str
napari-0.5.0a1/napari/_qt/perf/qt_performance.py 0000664 0000000 0000000 00000013527 14370413656 0021601 0 ustar 00root root 0000000 0000000 """QtPerformance widget to show performance information.
"""
import time
from qtpy.QtCore import Qt, QTimer
from qtpy.QtGui import QTextCursor
from qtpy.QtWidgets import (
QComboBox,
QHBoxLayout,
QLabel,
QProgressBar,
QSizePolicy,
QSpacerItem,
QTextEdit,
QVBoxLayout,
QWidget,
)
from napari.utils import perf
from napari.utils.translations import trans
class TextLog(QTextEdit):
"""Text window we can write "log" messages to.
TODO: need to limit length, erase oldest messages?
"""
def append(self, name: str, time_ms: float) -> None:
"""Add one line of text for this timer.
Parameters
----------
name : str
Timer name.
time_ms : float
Duration of the timer in milliseconds.
"""
self.moveCursor(QTextCursor.MoveOperation.End)
self.setTextColor(Qt.GlobalColor.red)
self.insertPlainText(
trans._("{time_ms:5.0f}ms {name}\n", time_ms=time_ms, name=name)
)
class QtPerformance(QWidget):
"""Dockable widget to show performance info.
Notes
-----
1) The progress bar doesn't show "progress", we use it as a bar graph to
show the average duration of recent "UpdateRequest" events. This
is actually not the total draw time, but it's generally the biggest
part of each frame.
2) We log any event whose duration is longer than the threshold.
3) We show uptime so you can tell if this window is being updated at all.
Attributes
----------
start_time : float
Time is seconds when widget was created.
bar : QProgressBar
The progress bar we use as your draw time indicator.
thresh_ms : float
Log events whose duration is longer then this.
timer_label : QLabel
We write the current "uptime" into this label.
timer : QTimer
To update our window every UPDATE_MS.
"""
# We log events slower than some threshold (in milliseconds).
THRESH_DEFAULT = 100
THRESH_OPTIONS = [
"1",
"5",
"10",
"15",
"20",
"30",
"40",
"50",
"100",
"200",
]
# Update at 250ms / 4Hz for now. The more we update more alive our
# display will look, but the more we will slow things down.
UPDATE_MS = 250
def __init__(self) -> None:
"""Create our windgets."""
super().__init__()
layout = QVBoxLayout()
# We log slow events to this window.
self.log = TextLog()
# For our "uptime" timer.
self.start_time = time.time()
# Label for our progress bar.
bar_label = QLabel(trans._("Draw Time:"))
layout.addWidget(bar_label)
# Progress bar is not used for "progress", it's just a bar graph to show
# the "draw time", the duration of the "UpdateRequest" event.
bar = QProgressBar()
bar.setRange(0, 100)
bar.setValue(50)
bar.setFormat("%vms")
layout.addWidget(bar)
self.bar = bar
# We let the user set the "slow event" threshold.
self.thresh_ms = self.THRESH_DEFAULT
self.thresh_combo = QComboBox()
self.thresh_combo.addItems(self.THRESH_OPTIONS)
self.thresh_combo.currentTextChanged.connect(self._change_thresh)
self.thresh_combo.setCurrentText(str(self.thresh_ms))
combo_layout = QHBoxLayout()
combo_layout.addWidget(QLabel(trans._("Show Events Slower Than:")))
combo_layout.addWidget(self.thresh_combo)
combo_layout.addWidget(QLabel(trans._("milliseconds")))
combo_layout.addItem(
QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
)
layout.addLayout(combo_layout)
layout.addWidget(self.log)
# Uptime label. To indicate if the widget is getting updated.
label = QLabel('')
layout.addWidget(label)
self.timer_label = label
self.setLayout(layout)
# Update us with a timer.
self.timer = QTimer(self)
self.timer.timeout.connect(self.update)
self.timer.setInterval(self.UPDATE_MS)
self.timer.start()
def _change_thresh(self, text):
"""Threshold combo box change."""
self.thresh_ms = float(text)
self.log.clear() # start fresh with this new threshold
def _get_timer_info(self):
"""Get the information from the timers that we want to display."""
average = None
long_events = []
# We don't update any GUI/widgets while iterating over the timers.
# Updating widgets can create immediate Qt Events which would modify the
# timers out from under us!
for name, timer in perf.timers.timers.items():
# The Qt Event "UpdateRequest" is the main "draw" event, so
# that's what we use for our progress bar.
if name == "UpdateRequest":
average = timer.average
# Log any "long" events to the text window.
if timer.max >= self.thresh_ms:
long_events.append((name, timer.max))
return average, long_events
def update(self):
"""Update our label and progress bar and log any new slow events."""
# Update our timer label.
elapsed = time.time() - self.start_time
self.timer_label.setText(
trans._("Uptime: {elapsed:.2f}", elapsed=elapsed)
)
average, long_events = self._get_timer_info()
# Now safe to update the GUI: progress bar first.
if average is not None:
self.bar.setValue(int(average))
# And log any new slow events.
for name, time_ms in long_events:
self.log.append(name, time_ms)
# Clear all the timers since we've displayed them. They will immediately
# start accumulating numbers for the next update.
perf.timers.clear()
napari-0.5.0a1/napari/_qt/qt_event_filters.py 0000664 0000000 0000000 00000001407 14370413656 0021207 0 ustar 00root root 0000000 0000000 """Qt event filters providing custom handling of events."""
import html
from qtpy.QtCore import QEvent, QObject
from qtpy.QtWidgets import QWidget
from napari._qt.utils import qt_might_be_rich_text
class QtToolTipEventFilter(QObject):
"""
An event filter that converts all plain-text widget tooltips to rich-text
tooltips.
"""
def eventFilter(self, qobject: QObject, event: QEvent) -> bool:
if event.type() == QEvent.ToolTipChange and isinstance(
qobject, QWidget
):
tooltip = qobject.toolTip()
if tooltip and not qt_might_be_rich_text(tooltip):
qobject.setToolTip(f'{html.escape(tooltip)}')
return True
return super().eventFilter(qobject, event)
napari-0.5.0a1/napari/_qt/qt_event_loop.py 0000664 0000000 0000000 00000034545 14370413656 0020521 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
import sys
from contextlib import contextmanager
from typing import TYPE_CHECKING
from warnings import warn
from qtpy import PYQT5
from qtpy.QtCore import QDir, Qt
from qtpy.QtGui import QIcon
from qtpy.QtWidgets import QApplication
from napari import Viewer, __version__
from napari._qt.dialogs.qt_notification import NapariQtNotification
from napari._qt.qt_event_filters import QtToolTipEventFilter
from napari._qt.qthreading import (
register_threadworker_processors,
wait_for_workers_to_quit,
)
from napari._qt.utils import _maybe_allow_interrupt
from napari.resources._icons import _theme_path
from napari.settings import get_settings
from napari.utils import config, perf
from napari.utils.notifications import (
notification_manager,
show_console_notification,
)
from napari.utils.perf import perf_config
from napari.utils.theme import _themes
from napari.utils.translations import trans
if TYPE_CHECKING:
from IPython import InteractiveShell
NAPARI_ICON_PATH = os.path.join(
os.path.dirname(__file__), '..', 'resources', 'logo.png'
)
NAPARI_APP_ID = f'napari.napari.viewer.{__version__}'
def set_app_id(app_id):
if os.name == "nt" and app_id and not getattr(sys, 'frozen', False):
import ctypes
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(app_id)
_defaults = {
'app_name': 'napari',
'app_version': __version__,
'icon': NAPARI_ICON_PATH,
'org_name': 'napari',
'org_domain': 'napari.org',
'app_id': NAPARI_APP_ID,
}
# store reference to QApplication to prevent garbage collection
_app_ref = None
_IPYTHON_WAS_HERE_FIRST = "IPython" in sys.modules
def get_app(
*,
app_name: str = None,
app_version: str = None,
icon: str = None,
org_name: str = None,
org_domain: str = None,
app_id: str = None,
ipy_interactive: bool = None,
) -> QApplication:
"""Get or create the Qt QApplication.
There is only one global QApplication instance, which can be retrieved by
calling get_app again, (or by using QApplication.instance())
Parameters
----------
app_name : str, optional
Set app name (if creating for the first time), by default 'napari'
app_version : str, optional
Set app version (if creating for the first time), by default __version__
icon : str, optional
Set app icon (if creating for the first time), by default
NAPARI_ICON_PATH
org_name : str, optional
Set organization name (if creating for the first time), by default
'napari'
org_domain : str, optional
Set organization domain (if creating for the first time), by default
'napari.org'
app_id : str, optional
Set organization domain (if creating for the first time). Will be
passed to set_app_id (which may also be called independently), by
default NAPARI_APP_ID
ipy_interactive : bool, optional
Use the IPython Qt event loop ('%gui qt' magic) if running in an
interactive IPython terminal.
Returns
-------
QApplication
[description]
Notes
-----
Substitutes QApplicationWithTracing when the NAPARI_PERFMON env variable
is set.
"""
# napari defaults are all-or nothing. If any of the keywords are used
# then they are all used.
set_values = {k for k, v in locals().items() if v}
kwargs = locals() if set_values else _defaults
global _app_ref
app = QApplication.instance()
if app:
set_values.discard("ipy_interactive")
if set_values:
warn(
trans._(
"QApplication already existed, these arguments to to 'get_app' were ignored: {args}",
deferred=True,
args=set_values,
)
)
if perf_config and perf_config.trace_qt_events:
warn(
trans._(
"Using NAPARI_PERFMON with an already-running QtApp (--gui qt?) is not supported.",
deferred=True,
)
)
else:
# automatically determine monitor DPI.
# Note: this MUST be set before the QApplication is instantiated
if PYQT5:
QApplication.setAttribute(
Qt.ApplicationAttribute.AA_EnableHighDpiScaling
)
QApplication.setAttribute(
Qt.ApplicationAttribute.AA_UseHighDpiPixmaps
)
argv = sys.argv.copy()
if sys.platform == "darwin" and not argv[0].endswith("napari"):
# Make sure the app name in the Application menu is `napari`
# which is taken from the basename of sys.argv[0]; we use
# a copy so the original value is still available at sys.argv
argv[0] = "napari"
if perf_config and perf_config.trace_qt_events:
from napari._qt.perf.qt_event_tracing import (
QApplicationWithTracing,
)
app = QApplicationWithTracing(argv)
else:
app = QApplication(argv)
# if this is the first time the Qt app is being instantiated, we set
# the name and metadata
app.setApplicationName(kwargs.get('app_name'))
app.setApplicationVersion(kwargs.get('app_version'))
app.setOrganizationName(kwargs.get('org_name'))
app.setOrganizationDomain(kwargs.get('org_domain'))
set_app_id(kwargs.get('app_id'))
# Intercept tooltip events in order to convert all text to rich text
# to allow for text wrapping of tooltips
app.installEventFilter(QtToolTipEventFilter())
if app.windowIcon().isNull():
app.setWindowIcon(QIcon(kwargs.get('icon')))
if ipy_interactive is None:
ipy_interactive = get_settings().application.ipy_interactive
if _IPYTHON_WAS_HERE_FIRST:
_try_enable_ipython_gui('qt' if ipy_interactive else None)
if not _ipython_has_eventloop():
notification_manager.notification_ready.connect(
NapariQtNotification.show_notification
)
notification_manager.notification_ready.connect(
show_console_notification
)
if perf_config and not perf_config.patched:
# Will patch based on config file.
perf_config.patch_callables()
if not _app_ref: # running get_app for the first time
# see docstring of `wait_for_workers_to_quit` for caveats on killing
# workers at shutdown.
app.aboutToQuit.connect(wait_for_workers_to_quit)
# Setup search paths for currently installed themes.
for name in _themes:
QDir.addSearchPath(f'theme_{name}', str(_theme_path(name)))
# When a new theme is added, at it to the search path.
@_themes.events.changed.connect
@_themes.events.added.connect
def _(event):
name = event.key
QDir.addSearchPath(f'theme_{name}', str(_theme_path(name)))
register_threadworker_processors()
_app_ref = app # prevent garbage collection
# Add the dispatcher attribute to the application to be able to dispatch
# notifications coming from threads
return app
def quit_app():
"""Close all windows and quit the QApplication if napari started it."""
for v in list(Viewer._instances):
v.close()
QApplication.closeAllWindows()
# if we started the application then the app will be named 'napari'.
if (
QApplication.applicationName() == 'napari'
and not _ipython_has_eventloop()
):
QApplication.quit()
# otherwise, something else created the QApp before us (such as
# %gui qt IPython magic). If we quit the app in this case, then
# *later* attempts to instantiate a napari viewer won't work until
# the event loop is restarted with app.exec_(). So rather than
# quit just close all the windows (and clear our app icon).
else:
QApplication.setWindowIcon(QIcon())
if perf.USE_PERFMON:
# Write trace file before exit, if we were writing one.
# Is there a better place to make sure this is done on exit?
perf.timers.stop_trace_file()
if config.monitor:
# Stop the monitor service if we were using it
from napari.components.experimental.monitor import monitor
monitor.stop()
if config.async_loading:
# Shutdown the chunkloader
from napari.components.experimental.chunk import chunk_loader
chunk_loader.shutdown()
@contextmanager
def gui_qt(*, startup_logo=False, gui_exceptions=False, force=False):
"""Start a Qt event loop in which to run the application.
NOTE: This context manager is deprecated!. Prefer using :func:`napari.run`.
Parameters
----------
startup_logo : bool, optional
Show a splash screen with the napari logo during startup.
gui_exceptions : bool, optional
Whether to show uncaught exceptions in the GUI, by default they will be
shown in the console that launched the event loop.
force : bool, optional
Force the application event_loop to start, even if there are no top
level widgets to show.
Notes
-----
This context manager is not needed if running napari within an interactive
IPython session. In this case, use the ``%gui qt`` magic command, or start
IPython with the Qt GUI event loop enabled by default by using
``ipython --gui=qt``.
"""
warn(
trans._(
"\nThe 'gui_qt()' context manager is deprecated.\nIf you are running napari from a script, please use 'napari.run()' as follows:\n\n import napari\n\n viewer = napari.Viewer() # no prior setup needed\n # other code using the viewer...\n napari.run()\n\nIn IPython or Jupyter, 'napari.run()' is not necessary. napari will automatically\nstart an interactive event loop for you: \n\n import napari\n viewer = napari.Viewer() # that's it!\n",
deferred=True,
),
FutureWarning,
)
app = get_app()
splash = None
if startup_logo and app.applicationName() == 'napari':
from napari._qt.widgets.qt_splash_screen import NapariSplashScreen
splash = NapariSplashScreen()
splash.close()
try:
yield app
except Exception: # noqa: BLE001
notification_manager.receive_error(*sys.exc_info())
run(force=force, gui_exceptions=gui_exceptions, _func_name='gui_qt')
def _ipython_has_eventloop() -> bool:
"""Return True if IPython %gui qt is active.
Using this is better than checking ``QApp.thread().loopLevel() > 0``,
because IPython starts and stops the event loop continuously to accept code
at the prompt. So it will likely "appear" like there is no event loop
running, but we still don't need to start one.
"""
ipy_module = sys.modules.get("IPython")
if not ipy_module:
return False
shell: InteractiveShell = ipy_module.get_ipython() # type: ignore
if not shell:
return False
return shell.active_eventloop == 'qt'
def _pycharm_has_eventloop(app: QApplication) -> bool:
"""Return true if running in PyCharm and eventloop is active.
Explicit checking is necessary because PyCharm runs a custom interactive
shell which overrides `InteractiveShell.enable_gui()`, breaking some
superclass behaviour.
"""
in_pycharm = 'PYCHARM_HOSTED' in os.environ
in_event_loop = getattr(app, '_in_event_loop', False)
return in_pycharm and in_event_loop
def _try_enable_ipython_gui(gui='qt'):
"""Start %gui qt the eventloop."""
ipy_module = sys.modules.get("IPython")
if not ipy_module:
return
shell: InteractiveShell = ipy_module.get_ipython() # type: ignore
if not shell:
return
if shell.active_eventloop != gui:
shell.enable_gui(gui)
def run(
*, force=False, gui_exceptions=False, max_loop_level=1, _func_name='run'
):
"""Start the Qt Event Loop
Parameters
----------
force : bool, optional
Force the application event_loop to start, even if there are no top
level widgets to show.
gui_exceptions : bool, optional
Whether to show uncaught exceptions in the GUI. By default they will be
shown in the console that launched the event loop.
max_loop_level : int, optional
The maximum allowable "loop level" for the execution thread. Every
time `QApplication.exec_()` is called, Qt enters the event loop,
increments app.thread().loopLevel(), and waits until exit() is called.
This function will prevent calling `exec_()` if the application already
has at least ``max_loop_level`` event loops running. By default, 1.
_func_name : str, optional
name of calling function, by default 'run'. This is only here to
provide functions like `gui_qt` a way to inject their name into the
warning message.
Raises
------
RuntimeError
(To avoid confusion) if no widgets would be shown upon starting the
event loop.
"""
if _ipython_has_eventloop():
# If %gui qt is active, we don't need to block again.
return
app = QApplication.instance()
if _pycharm_has_eventloop(app):
# explicit check for PyCharm pydev console
return
if not app:
raise RuntimeError(
trans._(
'No Qt app has been created. One can be created by calling `get_app()` or `qtpy.QtWidgets.QApplication([])`',
deferred=True,
)
)
if not app.topLevelWidgets() and not force:
warn(
trans._(
"Refusing to run a QApplication with no topLevelWidgets. To run the app anyway, use `{_func_name}(force=True)`",
deferred=True,
_func_name=_func_name,
)
)
return
if app.thread().loopLevel() >= max_loop_level:
loops = app.thread().loopLevel()
warn(
trans._n(
"A QApplication is already running with 1 event loop. To enter *another* event loop, use `{_func_name}(max_loop_level={max_loop_level})`",
"A QApplication is already running with {n} event loops. To enter *another* event loop, use `{_func_name}(max_loop_level={max_loop_level})`",
n=loops,
deferred=True,
_func_name=_func_name,
max_loop_level=loops + 1,
)
)
return
with notification_manager, _maybe_allow_interrupt(app):
app.exec_()
napari-0.5.0a1/napari/_qt/qt_main_window.py 0000664 0000000 0000000 00000152162 14370413656 0020656 0 ustar 00root root 0000000 0000000 """
Custom Qt widgets that serve as native objects that the public-facing elements
wrap.
"""
import contextlib
import inspect
import os
import sys
import time
import warnings
from typing import (
TYPE_CHECKING,
Any,
ClassVar,
Dict,
List,
Optional,
Sequence,
Tuple,
Union,
cast,
)
from weakref import WeakValueDictionary
from qtpy.QtCore import (
QEvent,
QEventLoop,
QPoint,
QProcess,
QRect,
QSize,
Qt,
Slot,
)
from qtpy.QtGui import QIcon
from qtpy.QtWidgets import (
QApplication,
QDialog,
QDockWidget,
QHBoxLayout,
QMainWindow,
QMenu,
QShortcut,
QToolTip,
QWidget,
)
from superqt.utils import QSignalThrottler
from napari._app_model.constants import MenuId
from napari._qt import menus
from napari._qt._qapp_model import build_qmodel_menu
from napari._qt._qapp_model.qactions import init_qactions
from napari._qt.dialogs.confirm_close_dialog import ConfirmCloseDialog
from napari._qt.dialogs.qt_activity_dialog import QtActivityDialog
from napari._qt.dialogs.qt_notification import NapariQtNotification
from napari._qt.qt_event_loop import NAPARI_ICON_PATH, get_app, quit_app
from napari._qt.qt_resources import get_stylesheet
from napari._qt.qt_viewer import QtViewer
from napari._qt.utils import QImg2array, qbytearray_to_str, str_to_qbytearray
from napari._qt.widgets.qt_viewer_dock_widget import (
_SHORTCUT_DEPRECATION_STRING,
QtViewerDockWidget,
)
from napari._qt.widgets.qt_viewer_status_bar import ViewerStatusBar
from napari.plugins import menu_item_template as plugin_menu_item_template
from napari.plugins import plugin_manager
from napari.settings import get_settings
from napari.utils import perf
from napari.utils._proxies import PublicOnlyProxy
from napari.utils.io import imsave
from napari.utils.misc import (
in_ipython,
in_jupyter,
in_python_repl,
running_as_bundled_app,
)
from napari.utils.notifications import Notification
from napari.utils.theme import _themes, get_system_theme
from napari.utils.translations import trans
_sentinel = object()
if TYPE_CHECKING:
from magicgui.widgets import Widget
from qtpy.QtGui import QImage
from napari.viewer import Viewer
class _QtMainWindow(QMainWindow):
# This was added so that someone can patch
# `napari._qt.qt_main_window._QtMainWindow._window_icon`
# to their desired window icon
_window_icon = NAPARI_ICON_PATH
# To track window instances and facilitate getting the "active" viewer...
# We use this instead of QApplication.activeWindow for compatibility with
# IPython usage. When you activate IPython, it will appear that there are
# *no* active windows, so we want to track the most recently active windows
_instances: ClassVar[List['_QtMainWindow']] = []
# `window` is passed through on construction so it's available to a window
# provider for dependency injection
# See https://github.com/napari/napari/pull/4826
def __init__(
self, viewer: 'Viewer', window: 'Window', parent=None
) -> None:
super().__init__(parent)
self._ev = None
self._window = window
self._qt_viewer = QtViewer(viewer, show_welcome_screen=True)
self._quit_app = False
self.setWindowIcon(QIcon(self._window_icon))
self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
self.setUnifiedTitleAndToolBarOnMac(True)
center = QWidget(self)
center.setLayout(QHBoxLayout())
center.layout().addWidget(self._qt_viewer)
center.layout().setContentsMargins(4, 0, 4, 0)
self.setCentralWidget(center)
self.setWindowTitle(self._qt_viewer.viewer.title)
self._maximized_flag = False
self._fullscreen_flag = False
self._normal_geometry = QRect()
self._window_size = None
self._window_pos = None
self._old_size = None
self._positions = []
self._is_close_dialog = {False: True, True: True}
# this ia sa workaround for #5335 issue. The dict is used to not
# collide shortcuts for close and close all windows
act_dlg = QtActivityDialog(self._qt_viewer._welcome_widget)
self._qt_viewer._welcome_widget.resized.connect(
act_dlg.move_to_bottom_right
)
act_dlg.hide()
self._activity_dialog = act_dlg
self.setStatusBar(ViewerStatusBar(self))
settings = get_settings()
# TODO:
# settings.plugins.defaults.call_order = plugin_manager.call_order()
# set the values in plugins to match the ones saved in settings
if settings.plugins.call_order is not None:
plugin_manager.set_call_order(settings.plugins.call_order)
_QtMainWindow._instances.append(self)
# since we initialize canvas before window,
# we need to manually connect them again.
handle = self.windowHandle()
if handle is not None:
handle.screenChanged.connect(
self._qt_viewer.canvas._backend.screen_changed
)
# this is the line that initializes any Qt-based app-model Actions that
# were defined somewhere in the `_qt` module and imported in init_qactions
init_qactions()
self.status_throttler = QSignalThrottler(parent=self)
self.status_throttler.setTimeout(50)
self._throttle_cursor_to_status_connection(viewer)
def _throttle_cursor_to_status_connection(self, viewer: 'Viewer'):
# In the GUI we expect lots of changes to the cursor position, so
# replace the direct connection with a throttled one.
with contextlib.suppress(IndexError):
viewer.cursor.events.position.disconnect(
viewer._update_status_bar_from_cursor
)
viewer.cursor.events.position.connect(self.status_throttler.throttle)
self.status_throttler.triggered.connect(
viewer._update_status_bar_from_cursor
)
def statusBar(self) -> 'ViewerStatusBar':
return super().statusBar()
@classmethod
def current(cls) -> Optional['_QtMainWindow']:
return cls._instances[-1] if cls._instances else None
@classmethod
def current_viewer(cls):
window = cls.current()
return window._qt_viewer.viewer if window else None
def event(self, e: QEvent) -> bool:
if (
e.type() == QEvent.Type.ToolTip
and self._qt_viewer.viewer.tooltip.visible
):
# globalPos is for Qt5 e.globalPosition().toPoint() is for QT6
# https://doc-snapshots.qt.io/qt6-dev/qmouseevent-obsolete.html#globalPos
pnt = (
e.globalPosition().toPoint()
if hasattr(e, "globalPosition")
else e.globalPos()
)
QToolTip.showText(pnt, self._qt_viewer.viewer.tooltip.text, self)
if e.type() == QEvent.Type.Close:
# when we close the MainWindow, remove it from the instances list
with contextlib.suppress(ValueError):
_QtMainWindow._instances.remove(self)
if e.type() in {QEvent.Type.WindowActivate, QEvent.Type.ZOrderChange}:
# upon activation or raise_, put window at the end of _instances
with contextlib.suppress(ValueError):
inst = _QtMainWindow._instances
inst.append(inst.pop(inst.index(self)))
return super().event(e)
def isFullScreen(self):
# Needed to prevent errors when going to fullscreen mode on Windows
# Use a flag attribute to determine if the window is in full screen mode
# See https://bugreports.qt.io/browse/QTBUG-41309
# Based on https://github.com/spyder-ide/spyder/pull/7720
return self._fullscreen_flag
def showNormal(self):
# Needed to prevent errors when going to fullscreen mode on Windows. Here we:
# * Set fullscreen flag
# * Remove `Qt.FramelessWindowHint` and `Qt.WindowStaysOnTopHint` window flags if needed
# * Set geometry to previously stored normal geometry or default empty QRect
# Always call super `showNormal` to set Qt window state
# See https://bugreports.qt.io/browse/QTBUG-41309
# Based on https://github.com/spyder-ide/spyder/pull/7720
self._fullscreen_flag = False
if os.name == 'nt':
self.setWindowFlags(
self.windowFlags()
^ (Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)
)
self.setGeometry(self._normal_geometry)
super().showNormal()
def showFullScreen(self):
# Needed to prevent errors when going to fullscreen mode on Windows. Here we:
# * Set fullscreen flag
# * Add `Qt.FramelessWindowHint` and `Qt.WindowStaysOnTopHint` window flags if needed
# * Call super `showNormal` to update the normal screen geometry to apply it later if needed
# * Save window normal geometry if needed
# * Get screen geometry
# * Set geometry window to use total screen geometry +1 in every direction if needed
# If the workaround is not needed just call super `showFullScreen`
# See https://bugreports.qt.io/browse/QTBUG-41309
# Based on https://github.com/spyder-ide/spyder/pull/7720
self._fullscreen_flag = True
if os.name == 'nt':
self.setWindowFlags(
self.windowFlags()
| Qt.FramelessWindowHint
| Qt.WindowStaysOnTopHint
)
super().showNormal()
self._normal_geometry = self.normalGeometry()
screen_rect = self.windowHandle().screen().geometry()
self.setGeometry(
screen_rect.left() - 1,
screen_rect.top() - 1,
screen_rect.width() + 2,
screen_rect.height() + 2,
)
else:
super().showFullScreen()
def _load_window_settings(self):
"""
Load window layout settings from configuration.
"""
settings = get_settings()
window_position = settings.application.window_position
# It's necessary to verify if the window/position value is valid with
# the current screen.
if not window_position:
window_position = (self.x(), self.y())
else:
width, height = window_position
screen_geo = QApplication.primaryScreen().geometry()
if screen_geo.width() < width or screen_geo.height() < height:
window_position = (self.x(), self.y())
return (
settings.application.window_state,
settings.application.window_size,
window_position,
settings.application.window_maximized,
settings.application.window_fullscreen,
)
def _get_window_settings(self):
"""Return current window settings.
Symmetric to the 'set_window_settings' setter.
"""
window_fullscreen = self.isFullScreen()
if window_fullscreen:
window_maximized = self._maximized_flag
else:
window_maximized = self.isMaximized()
window_state = qbytearray_to_str(self.saveState())
return (
window_state,
self._window_size or (self.width(), self.height()),
self._window_pos or (self.x(), self.y()),
window_maximized,
window_fullscreen,
)
def _set_window_settings(
self,
window_state,
window_size,
window_position,
window_maximized,
window_fullscreen,
):
"""
Set window settings.
Symmetric to the 'get_window_settings' accessor.
"""
self.setUpdatesEnabled(False)
self.setWindowState(Qt.WindowState.WindowNoState)
if window_position:
window_position = QPoint(*window_position)
self.move(window_position)
if window_size:
window_size = QSize(*window_size)
self.resize(window_size)
if window_state:
self.restoreState(str_to_qbytearray(window_state))
# Toggling the console visibility is disabled when it is not
# available, so ensure that it is hidden.
if in_ipython() or in_jupyter() or in_python_repl():
self._qt_viewer.dockConsole.setVisible(False)
if window_fullscreen:
self._maximized_flag = window_maximized
self.showFullScreen()
elif window_maximized:
self.setWindowState(Qt.WindowState.WindowMaximized)
self.setUpdatesEnabled(True)
def _save_current_window_settings(self):
"""Save the current geometry of the main window."""
(
window_state,
window_size,
window_position,
window_maximized,
window_fullscreen,
) = self._get_window_settings()
settings = get_settings()
if settings.application.save_window_geometry:
settings.application.window_maximized = window_maximized
settings.application.window_fullscreen = window_fullscreen
settings.application.window_position = window_position
settings.application.window_size = window_size
settings.application.window_statusbar = (
not self.statusBar().isHidden()
)
if settings.application.save_window_state:
settings.application.window_state = window_state
def close(self, quit_app=False, confirm_need=False):
"""Override to handle closing app or just the window."""
if hasattr(self.status_throttler, "_timer"):
self.status_throttler._timer.stop()
if not quit_app and not self._qt_viewer.viewer.layers:
return super().close()
confirm_need_local = confirm_need and self._is_close_dialog[quit_app]
self._is_close_dialog[quit_app] = False
# here we save information that we could request confirmation on close
# So fi function `close` is called again, we don't ask again but just close
if (
not confirm_need_local
or not get_settings().application.confirm_close_window
or ConfirmCloseDialog(self, quit_app).exec_() == QDialog.Accepted
):
self._quit_app = quit_app
self._is_close_dialog[quit_app] = True
# here we inform that confirmation dialog is not open
self._qt_viewer.dims.stop()
return super().close()
self._is_close_dialog[quit_app] = True
# here we inform that confirmation dialog is not open
def close_window(self):
"""Close active dialog or active window."""
parent = QApplication.focusWidget()
while parent is not None:
if isinstance(parent, QMainWindow):
self.close()
break
if isinstance(parent, QDialog):
parent.close()
break
try:
parent = parent.parent()
except AttributeError:
parent = getattr(parent, "_parent", None)
def show(self, block=False):
super().show()
self._qt_viewer.setFocus()
if block:
self._ev = QEventLoop()
self._ev.exec()
def changeEvent(self, event):
"""Handle window state changes."""
if event.type() == QEvent.Type.WindowStateChange:
# TODO: handle maximization issue. When double clicking on the
# title bar on Mac the resizeEvent is called an varying amount
# of times which makes it hard to track the original size before
# maximization.
condition = (
self.isMaximized() if os.name == "nt" else self.isFullScreen()
)
if condition and self._old_size is not None:
if self._positions and len(self._positions) > 1:
self._window_pos = self._positions[-2]
self._window_size = (
self._old_size.width(),
self._old_size.height(),
)
else:
self._old_size = None
self._window_pos = None
self._window_size = None
self._positions = []
super().changeEvent(event)
def resizeEvent(self, event):
"""Override to handle original size before maximizing."""
# the first resize event will have nonsense positions that we dont
# want to store (and potentially restore)
if event.oldSize().isValid():
self._old_size = event.oldSize()
self._positions.append((self.x(), self.y()))
if self._positions and len(self._positions) >= 2:
self._window_pos = self._positions[-2]
self._positions = self._positions[-2:]
super().resizeEvent(event)
def closeEvent(self, event):
"""This method will be called when the main window is closing.
Regardless of whether cmd Q, cmd W, or the close button is used...
"""
if (
event.spontaneous()
and get_settings().application.confirm_close_window
and self._qt_viewer.viewer.layers
and ConfirmCloseDialog(self, False).exec_() != QDialog.Accepted
):
event.ignore()
return
if self._ev and self._ev.isRunning():
self._ev.quit()
# Close any floating dockwidgets
for dock in self.findChildren(QtViewerDockWidget):
if isinstance(dock, QWidget) and dock.isFloating():
dock.setFloating(False)
self._save_current_window_settings()
# On some versions of Darwin, exiting while fullscreen seems to tickle
# some bug deep in NSWindow. This forces the fullscreen keybinding
# test to complete its draw cycle, then pop back out of fullscreen.
if self.isFullScreen():
self.showNormal()
for _ in range(5):
time.sleep(0.1)
QApplication.processEvents()
self._qt_viewer.dims.stop()
if self._quit_app:
quit_app()
event.accept()
def restart(self):
"""Restart the napari application in a detached process."""
process = QProcess()
process.setProgram(sys.executable)
if not running_as_bundled_app():
process.setArguments(sys.argv)
process.startDetached()
self.close(quit_app=True)
@staticmethod
@Slot(Notification)
def show_notification(notification: Notification):
"""Show notification coming from a thread."""
NapariQtNotification.show_notification(notification)
class Window:
"""Application window that contains the menu bar and viewer.
Parameters
----------
viewer : napari.components.ViewerModel
Contained viewer widget.
Attributes
----------
file_menu : qtpy.QtWidgets.QMenu
File menu.
help_menu : qtpy.QtWidgets.QMenu
Help menu.
main_menu : qtpy.QtWidgets.QMainWindow.menuBar
Main menubar.
view_menu : qtpy.QtWidgets.QMenu
View menu.
window_menu : qtpy.QtWidgets.QMenu
Window menu.
"""
def __init__(self, viewer: 'Viewer', *, show: bool = True) -> None:
# create QApplication if it doesn't already exist
get_app()
# Dictionary holding dock widgets
self._dock_widgets: Dict[
str, QtViewerDockWidget
] = WeakValueDictionary()
self._unnamed_dockwidget_count = 1
# Connect the Viewer and create the Main Window
self._qt_window = _QtMainWindow(viewer, self)
# connect theme events before collecting plugin-provided themes
# to ensure icons from the plugins are generated correctly.
_themes.events.added.connect(self._add_theme)
_themes.events.removed.connect(self._remove_theme)
# discover any themes provided by plugins
plugin_manager.discover_themes()
self._setup_existing_themes()
self._add_menus()
self._update_theme()
get_settings().appearance.events.theme.connect(self._update_theme)
self._add_viewer_dock_widget(
self._qt_viewer.dockConsole, tabify=False, menu=self.window_menu
)
self._add_viewer_dock_widget(
self._qt_viewer.dockLayerControls,
tabify=False,
menu=self.window_menu,
)
self._add_viewer_dock_widget(
self._qt_viewer.dockLayerList, tabify=False, menu=self.window_menu
)
if perf.USE_PERFMON:
self._add_viewer_dock_widget(
self._qt_viewer.dockPerformance, menu=self.window_menu
)
viewer.events.help.connect(self._help_changed)
viewer.events.title.connect(self._title_changed)
viewer.events.theme.connect(self._update_theme)
viewer.layers.events.connect(self.file_menu.update)
viewer.events.status.connect(self._status_changed)
if show:
self.show()
# Ensure the controls dock uses the minimum height
self._qt_window.resizeDocks(
[
self._qt_viewer.dockLayerControls,
self._qt_viewer.dockLayerList,
],
[self._qt_viewer.dockLayerControls.minimumHeight(), 10000],
Qt.Orientation.Vertical,
)
def _setup_existing_themes(self, connect: bool = True):
"""This function is only executed once at the startup of napari
to connect events to themes that have not been connected yet.
Parameters
----------
connect : bool
Determines whether the `connect` or `disconnect` method should be used.
"""
for theme in _themes.values():
if connect:
self._connect_theme(theme)
else:
self._disconnect_theme(theme)
def _connect_theme(self, theme):
# connect events to update theme. Here, we don't want to pass the event
# since it won't have the right `value` attribute.
theme.events.background.connect(self._update_theme_no_event)
theme.events.foreground.connect(self._update_theme_no_event)
theme.events.primary.connect(self._update_theme_no_event)
theme.events.secondary.connect(self._update_theme_no_event)
theme.events.highlight.connect(self._update_theme_no_event)
theme.events.text.connect(self._update_theme_no_event)
theme.events.warning.connect(self._update_theme_no_event)
theme.events.current.connect(self._update_theme_no_event)
theme.events.icon.connect(self._update_theme_no_event)
theme.events.canvas.connect(
lambda _: self._qt_viewer.canvas._set_theme_change(
get_settings().appearance.theme
)
)
# connect console-specific attributes only if QtConsole
# is present. The `console` is called which might slow
# things down a little.
if self._qt_viewer._console:
theme.events.console.connect(self._qt_viewer.console._update_theme)
theme.events.syntax_style.connect(
self._qt_viewer.console._update_theme
)
def _disconnect_theme(self, theme):
theme.events.background.disconnect(self._update_theme_no_event)
theme.events.foreground.disconnect(self._update_theme_no_event)
theme.events.primary.disconnect(self._update_theme_no_event)
theme.events.secondary.disconnect(self._update_theme_no_event)
theme.events.highlight.disconnect(self._update_theme_no_event)
theme.events.text.disconnect(self._update_theme_no_event)
theme.events.warning.disconnect(self._update_theme_no_event)
theme.events.current.disconnect(self._update_theme_no_event)
theme.events.icon.disconnect(self._update_theme_no_event)
theme.events.canvas.disconnect(
lambda _: self._qt_viewer.canvas._set_theme_change(
get_settings().appearance.theme
)
)
# disconnect console-specific attributes only if QtConsole
# is present and they were previously connected
if self._qt_viewer._console:
theme.events.console.disconnect(
self._qt_viewer.console._update_theme
)
theme.events.syntax_style.disconnect(
self._qt_viewer.console._update_theme
)
def _add_theme(self, event):
"""Add new theme and connect events."""
theme = event.value
self._connect_theme(theme)
def _remove_theme(self, event):
"""Remove theme and disconnect events."""
theme = event.value
self._disconnect_theme(theme)
@property
def qt_viewer(self):
warnings.warn(
trans._(
'Public access to Window.qt_viewer is deprecated and will be removed in\nv0.5.0. It is considered an "implementation detail" of the napari\napplication, not part of the napari viewer model. If your use case\nrequires access to qt_viewer, please open an issue to discuss.',
deferred=True,
),
category=FutureWarning,
stacklevel=2,
)
return self._qt_window._qt_viewer
@property
def _qt_viewer(self):
# this is starting to be "vestigial"... this property could be removed
return self._qt_window._qt_viewer
@property
def _status_bar(self):
# TODO: remove from window
return self._qt_window.statusBar()
def _add_menus(self):
"""Add menubar to napari app."""
# TODO: move this to _QMainWindow... but then all of the Menu()
# items will not have easy access to the methods on this Window obj.
self.main_menu = self._qt_window.menuBar()
# Menubar shortcuts are only active when the menubar is visible.
# Therefore, we set a global shortcut not associated with the menubar
# to toggle visibility, *but*, in order to not shadow the menubar
# shortcut, we disable it, and only enable it when the menubar is
# hidden. See this stackoverflow link for details:
# https://stackoverflow.com/questions/50537642/how-to-keep-the-shortcuts-of-a-hidden-widget-in-pyqt5
self._main_menu_shortcut = QShortcut('Ctrl+M', self._qt_window)
self._main_menu_shortcut.setEnabled(False)
self._main_menu_shortcut.activated.connect(
self._toggle_menubar_visible
)
self.file_menu = menus.FileMenu(self)
self.main_menu.addMenu(self.file_menu)
self.view_menu = build_qmodel_menu(
MenuId.MENUBAR_VIEW, title=trans._('&View'), parent=self._qt_window
)
self.main_menu.addMenu(self.view_menu)
self.plugins_menu = menus.PluginsMenu(self)
self.main_menu.addMenu(self.plugins_menu)
self.window_menu = menus.WindowMenu(self)
self.main_menu.addMenu(self.window_menu)
self.help_menu = build_qmodel_menu(
MenuId.MENUBAR_HELP, title=trans._('&Help'), parent=self._qt_window
)
self.main_menu.addMenu(self.help_menu)
if perf.USE_PERFMON:
self._debug_menu = menus.DebugMenu(self)
self.main_menu.addMenu(self._debug_menu)
def _toggle_menubar_visible(self):
"""Toggle visibility of app menubar.
This function also disables or enables a global keyboard shortcut to
show the menubar, since menubar shortcuts are only available while the
menubar is visible.
"""
self.main_menu.setVisible(not self.main_menu.isVisible())
self._main_menu_shortcut.setEnabled(not self.main_menu.isVisible())
def _toggle_fullscreen(self):
"""Toggle fullscreen mode."""
if self._qt_window.isFullScreen():
self._qt_window.showNormal()
else:
self._qt_window.showFullScreen()
def _toggle_play(self):
"""Toggle play."""
if self._qt_viewer.dims.is_playing:
self._qt_viewer.dims.stop()
else:
axis = self._qt_viewer.viewer.dims.last_used or 0
self._qt_viewer.dims.play(axis)
def add_plugin_dock_widget(
self,
plugin_name: str,
widget_name: str = None,
tabify: bool = False,
) -> Tuple[QtViewerDockWidget, Any]:
"""Add plugin dock widget if not already added.
Parameters
----------
plugin_name : str
Name of a plugin providing a widget
widget_name : str, optional
Name of a widget provided by `plugin_name`. If `None`, and the
specified plugin provides only a single widget, that widget will be
returned, otherwise a ValueError will be raised, by default None
Returns
-------
tuple
A 2-tuple containing (the DockWidget instance, the plugin widget
instance).
"""
from napari.plugins import _npe2
Widget = None
dock_kwargs = {}
if result := _npe2.get_widget_contribution(plugin_name, widget_name):
Widget, widget_name = result
if Widget is None:
Widget, dock_kwargs = plugin_manager.get_widget(
plugin_name, widget_name
)
if not widget_name:
# if widget_name wasn't provided, `get_widget` will have
# ensured that there is a single widget available.
widget_name = list(plugin_manager._dock_widgets[plugin_name])[0]
full_name = plugin_menu_item_template.format(plugin_name, widget_name)
if full_name in self._dock_widgets:
dock_widget = self._dock_widgets[full_name]
wdg = dock_widget.widget()
if hasattr(wdg, '_magic_widget'):
wdg = wdg._magic_widget
return dock_widget, wdg
wdg = _instantiate_dock_widget(
Widget, cast('Viewer', self._qt_viewer.viewer)
)
# Add dock widget
dock_kwargs.pop('name', None)
dock_widget = self.add_dock_widget(
wdg, name=full_name, tabify=tabify, **dock_kwargs
)
return dock_widget, wdg
def _add_plugin_function_widget(self, plugin_name: str, widget_name: str):
"""Add plugin function widget if not already added.
Parameters
----------
plugin_name : str
Name of a plugin providing a widget
widget_name : str, optional
Name of a widget provided by `plugin_name`. If `None`, and the
specified plugin provides only a single widget, that widget will be
returned, otherwise a ValueError will be raised, by default None
"""
full_name = plugin_menu_item_template.format(plugin_name, widget_name)
if full_name in self._dock_widgets:
return
func = plugin_manager._function_widgets[plugin_name][widget_name]
# Add function widget
return self.add_function_widget(
func, name=full_name, area=None, allowed_areas=None
)
def add_dock_widget(
self,
widget: Union[QWidget, 'Widget'],
*,
name: str = '',
area: str = 'right',
allowed_areas: Optional[Sequence[str]] = None,
shortcut=_sentinel,
add_vertical_stretch=True,
tabify: bool = False,
menu: Optional[QMenu] = None,
):
"""Convenience method to add a QDockWidget to the main window.
If name is not provided a generic name will be addded to avoid
`saveState` warnings on close.
Parameters
----------
widget : QWidget
`widget` will be added as QDockWidget's main widget.
name : str, optional
Name of dock widget to appear in window menu.
area : str
Side of the main window to which the new dock widget will be added.
Must be in {'left', 'right', 'top', 'bottom'}
allowed_areas : list[str], optional
Areas, relative to main window, that the widget is allowed dock.
Each item in list must be in {'left', 'right', 'top', 'bottom'}
By default, all areas are allowed.
shortcut : str, optional
Keyboard shortcut to appear in dropdown menu.
add_vertical_stretch : bool, optional
Whether to add stretch to the bottom of vertical widgets (pushing
widgets up towards the top of the allotted area, instead of letting
them distribute across the vertical space). By default, True.
.. deprecated:: 0.4.8
The shortcut parameter is deprecated since version 0.4.8, please use
the action and shortcut manager APIs. The new action manager and
shortcut API allow user configuration and localisation.
tabify : bool
Flag to tabify dockwidget or not.
menu : QMenu, optional
Menu bar to add toggle action to. If `None` nothing added to menu.
Returns
-------
dock_widget : QtViewerDockWidget
`dock_widget` that can pass viewer events.
"""
if not name:
with contextlib.suppress(AttributeError):
name = widget.objectName()
name = name or trans._(
"Dock widget {number}",
number=self._unnamed_dockwidget_count,
)
self._unnamed_dockwidget_count += 1
if shortcut is not _sentinel:
warnings.warn(
_SHORTCUT_DEPRECATION_STRING.format(shortcut=shortcut),
FutureWarning,
stacklevel=2,
)
dock_widget = QtViewerDockWidget(
self._qt_viewer,
widget,
name=name,
area=area,
allowed_areas=allowed_areas,
shortcut=shortcut,
add_vertical_stretch=add_vertical_stretch,
)
else:
dock_widget = QtViewerDockWidget(
self._qt_viewer,
widget,
name=name,
area=area,
allowed_areas=allowed_areas,
add_vertical_stretch=add_vertical_stretch,
)
self._add_viewer_dock_widget(dock_widget, tabify=tabify, menu=menu)
if hasattr(widget, 'reset_choices'):
# Keep the dropdown menus in the widget in sync with the layer model
# if widget has a `reset_choices`, which is true for all magicgui
# `CategoricalWidget`s
layers_events = self._qt_viewer.viewer.layers.events
layers_events.inserted.connect(widget.reset_choices)
layers_events.removed.connect(widget.reset_choices)
layers_events.reordered.connect(widget.reset_choices)
# Add dock widget to dictionary
self._dock_widgets[dock_widget.name] = dock_widget
return dock_widget
def _add_viewer_dock_widget(
self,
dock_widget: QtViewerDockWidget,
tabify: bool = False,
menu: Optional[QMenu] = None,
):
"""Add a QtViewerDockWidget to the main window
If other widgets already present in area then will tabify.
Parameters
----------
dock_widget : QtViewerDockWidget
`dock_widget` will be added to the main window.
tabify : bool
Flag to tabify dockwidget or not.
menu : QMenu, optional
Menu bar to add toggle action to. If `None` nothing added to menu.
"""
# Find if any othe dock widgets are currently in area
current_dws_in_area = [
dw
for dw in self._qt_window.findChildren(QDockWidget)
if self._qt_window.dockWidgetArea(dw) == dock_widget.qt_area
]
self._qt_window.addDockWidget(dock_widget.qt_area, dock_widget)
# If another dock widget present in area then tabify
if current_dws_in_area:
if tabify:
self._qt_window.tabifyDockWidget(
current_dws_in_area[-1], dock_widget
)
dock_widget.show()
dock_widget.raise_()
elif dock_widget.area in ('right', 'left'):
_wdg = current_dws_in_area + [dock_widget]
# add sizes to push lower widgets up
sizes = list(range(1, len(_wdg) * 4, 4))
self._qt_window.resizeDocks(
_wdg, sizes, Qt.Orientation.Vertical
)
if menu:
action = dock_widget.toggleViewAction()
action.setStatusTip(dock_widget.name)
action.setText(dock_widget.name)
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore", FutureWarning)
# deprecating with 0.4.8, but let's try to keep compatibility.
shortcut = dock_widget.shortcut
if shortcut is not None:
action.setShortcut(shortcut)
menu.addAction(action)
# see #3663, to fix #3624 more generally
dock_widget.setFloating(False)
def _remove_dock_widget(self, event=None):
names = list(self._dock_widgets.keys())
for widget_name in names:
if event.value in widget_name:
# remove this widget
widget = self._dock_widgets[widget_name]
self.remove_dock_widget(widget)
def remove_dock_widget(self, widget: QWidget, menu=None):
"""Removes specified dock widget.
If a QDockWidget is not provided, the existing QDockWidgets will be
searched for one whose inner widget (``.widget()``) is the provided
``widget``.
Parameters
----------
widget : QWidget | str
If widget == 'all', all docked widgets will be removed.
"""
if widget == 'all':
for dw in list(self._dock_widgets.values()):
self.remove_dock_widget(dw)
return
if not isinstance(widget, QDockWidget):
dw: QDockWidget
for dw in self._qt_window.findChildren(QDockWidget):
if dw.widget() is widget:
_dw: QDockWidget = dw
break
else:
raise LookupError(
trans._(
"Could not find a dock widget containing: {widget}",
deferred=True,
widget=widget,
)
)
else:
_dw = widget
if _dw.widget():
_dw.widget().setParent(None)
self._qt_window.removeDockWidget(_dw)
if menu is not None:
menu.removeAction(_dw.toggleViewAction())
# Remove dock widget from dictionary
self._dock_widgets.pop(_dw.name, None)
# Deleting the dock widget means any references to it will no longer
# work but it's not really useful anyway, since the inner widget has
# been removed. and anyway: people should be using add_dock_widget
# rather than directly using _add_viewer_dock_widget
_dw.deleteLater()
def add_function_widget(
self,
function,
*,
magic_kwargs=None,
name: str = '',
area=None,
allowed_areas=None,
shortcut=_sentinel,
):
"""Turn a function into a dock widget via magicgui.
Parameters
----------
function : callable
Function that you want to add.
magic_kwargs : dict, optional
Keyword arguments to :func:`magicgui.magicgui` that
can be used to specify widget.
name : str, optional
Name of dock widget to appear in window menu.
area : str, optional
Side of the main window to which the new dock widget will be added.
Must be in {'left', 'right', 'top', 'bottom'}. If not provided the
default will be determined by the widget.layout, with 'vertical'
layouts appearing on the right, otherwise on the bottom.
allowed_areas : list[str], optional
Areas, relative to main window, that the widget is allowed dock.
Each item in list must be in {'left', 'right', 'top', 'bottom'}
By default, only provided areas is allowed.
shortcut : str, optional
Keyboard shortcut to appear in dropdown menu.
Returns
-------
dock_widget : QtViewerDockWidget
`dock_widget` that can pass viewer events.
"""
from magicgui import magicgui
if magic_kwargs is None:
magic_kwargs = {
'auto_call': False,
'call_button': "run",
'layout': 'vertical',
}
widget = magicgui(function, **magic_kwargs or {})
if area is None:
area = 'right' if str(widget.layout) == 'vertical' else 'bottom'
if allowed_areas is None:
allowed_areas = [area]
if shortcut is not _sentinel:
return self.add_dock_widget(
widget,
name=name or function.__name__.replace('_', ' '),
area=area,
allowed_areas=allowed_areas,
shortcut=shortcut,
)
else:
return self.add_dock_widget(
widget,
name=name or function.__name__.replace('_', ' '),
area=area,
allowed_areas=allowed_areas,
)
def resize(self, width, height):
"""Resize the window.
Parameters
----------
width : int
Width in logical pixels.
height : int
Height in logical pixels.
"""
self._qt_window.resize(width, height)
def set_geometry(self, left, top, width, height):
"""Set the geometry of the widget
Parameters
----------
left : int
X coordinate of the upper left border.
top : int
Y coordinate of the upper left border.
width : int
Width of the rectangle shape of the window.
height : int
Height of the rectangle shape of the window.
"""
self._qt_window.setGeometry(left, top, width, height)
def geometry(self) -> Tuple[int, int, int, int]:
"""Get the geometry of the widget
Returns
-------
left : int
X coordinate of the upper left border.
top : int
Y coordinate of the upper left border.
width : int
Width of the rectangle shape of the window.
height : int
Height of the rectangle shape of the window.
"""
rect = self._qt_window.geometry()
return rect.left(), rect.top(), rect.width(), rect.height()
def show(self, *, block=False):
"""Resize, show, and bring forward the window.
Raises
------
RuntimeError
If the viewer.window has already been closed and deleted.
"""
settings = get_settings()
try:
self._qt_window.show(block=block)
except (AttributeError, RuntimeError) as e:
raise RuntimeError(
trans._(
"This viewer has already been closed and deleted. Please create a new one.",
deferred=True,
)
) from e
if settings.application.first_time:
settings.application.first_time = False
try:
self._qt_window.resize(self._qt_window.layout().sizeHint())
except (AttributeError, RuntimeError) as e:
raise RuntimeError(
trans._(
"This viewer has already been closed and deleted. Please create a new one.",
deferred=True,
)
) from e
else:
try:
if settings.application.save_window_geometry:
self._qt_window._set_window_settings(
*self._qt_window._load_window_settings()
)
except Exception as err: # noqa: BLE001
import warnings
warnings.warn(
trans._(
"The window geometry settings could not be loaded due to the following error: {err}",
deferred=True,
err=err,
),
category=RuntimeWarning,
stacklevel=2,
)
# Resize axis labels now that window is shown
self._qt_viewer.dims._resize_axis_labels()
# We want to bring the viewer to the front when
# A) it is our own event loop OR we are running in jupyter
# B) it is not the first time a QMainWindow is being created
# `app_name` will be "napari" iff the application was instantiated in
# get_app(). isActiveWindow() will be True if it is the second time a
# _qt_window has been created.
# See #721, #732, #735, #795, #1594
app_name = QApplication.instance().applicationName()
if (
app_name == 'napari' or in_jupyter()
) and self._qt_window.isActiveWindow():
self.activate()
def activate(self):
"""Make the viewer the currently active window."""
self._qt_window.raise_() # for macOS
self._qt_window.activateWindow() # for Windows
def _update_theme_no_event(self):
self._update_theme()
def _update_theme(self, event=None):
"""Update widget color theme."""
settings = get_settings()
with contextlib.suppress(AttributeError, RuntimeError):
value = event.value if event else settings.appearance.theme
self._qt_viewer.viewer.theme = value
if value == "system":
# system isn't a theme, so get the name and set style sheet
actual_theme_name = get_system_theme()
self._qt_window.setStyleSheet(
get_stylesheet(actual_theme_name)
)
else:
self._qt_window.setStyleSheet(get_stylesheet(value))
def _status_changed(self, event):
"""Update status bar.
Parameters
----------
event : napari.utils.event.Event
The napari event that triggered this method.
"""
if isinstance(event.value, str):
self._status_bar.setStatusText(event.value)
else:
status_info = event.value
self._status_bar.setStatusText(
layer_base=status_info['layer_base'],
source_type=status_info['source_type'],
plugin=status_info['plugin'],
coordinates=status_info['coordinates'],
)
def _title_changed(self, event):
"""Update window title.
Parameters
----------
event : napari.utils.event.Event
The napari event that triggered this method.
"""
self._qt_window.setWindowTitle(event.value)
def _help_changed(self, event):
"""Update help message on status bar.
Parameters
----------
event : napari.utils.event.Event
The napari event that triggered this method.
"""
self._status_bar.setHelpText(event.value)
def _restart(self):
"""Restart the napari application."""
self._qt_window.restart()
def _screenshot(
self, size=None, scale=None, flash=True, canvas_only=False
) -> 'QImage':
"""Capture screenshot of the currently displayed viewer.
Parameters
----------
flash : bool
Flag to indicate whether flash animation should be shown after
the screenshot was captured.
size : tuple (int, int)
Size (resolution) of the screenshot. By default, the currently displayed size.
Only used if `canvas_only` is True.
scale : float
Scale factor used to increase resolution of canvas for the screenshot. By default, the currently displayed resolution.
Only used if `canvas_only` is True.
canvas_only : bool
If True, screenshot shows only the image display canvas, and
if False include the napari viewer frame in the screenshot,
By default, True.
Returns
-------
img : QImage
"""
from napari._qt.utils import add_flash_animation
if canvas_only:
canvas = self._qt_viewer.canvas
prev_size = canvas.size
if size is not None:
if len(size) != 2:
raise ValueError(
trans._(
'screenshot size must be 2 values, got {len_size}',
len_size=len(size),
)
)
# Scale the requested size to account for HiDPI
size = tuple(
int(dim / self._qt_window.devicePixelRatio())
for dim in size
)
canvas.size = size[::-1] # invert x ad y for vispy
if scale is not None:
# multiply canvas dimensions by the scale factor to get new size
canvas.size = tuple(int(dim * scale) for dim in canvas.size)
try:
img = self._qt_viewer.canvas.native.grabFramebuffer()
if flash:
add_flash_animation(self._qt_viewer._welcome_widget)
finally:
# make sure we always go back to the right canvas size
if size is not None or scale is not None:
canvas.size = prev_size
else:
img = self._qt_window.grab().toImage()
if flash:
add_flash_animation(self._qt_window)
return img
def screenshot(
self, path=None, size=None, scale=None, flash=True, canvas_only=False
):
"""Take currently displayed viewer and convert to an image array.
Parameters
----------
path : str
Filename for saving screenshot image.
size : tuple (int, int)
Size (resolution) of the screenshot. By default, the currently displayed size.
Only used if `canvas_only` is True.
scale : float
Scale factor used to increase resolution of canvas for the screenshot. By default, the currently displayed resolution.
Only used if `canvas_only` is True.
flash : bool
Flag to indicate whether flash animation should be shown after
the screenshot was captured.
canvas_only : bool
If True, screenshot shows only the image display canvas, and
if False include the napari viewer frame in the screenshot,
By default, True.
Returns
-------
image : array
Numpy array of type ubyte and shape (h, w, 4). Index [0, 0] is the
upper-left corner of the rendered region.
"""
img = QImg2array(self._screenshot(size, scale, flash, canvas_only))
if path is not None:
imsave(path, img) # scikit-image imsave method
return img
def clipboard(self, flash=True, canvas_only=False):
"""Copy screenshot of current viewer to the clipboard.
Parameters
----------
flash : bool
Flag to indicate whether flash animation should be shown after
the screenshot was captured.
canvas_only : bool
If True, screenshot shows only the image display canvas, and
if False include the napari viewer frame in the screenshot,
By default, True.
"""
img = self._screenshot(flash=flash, canvas_only=canvas_only)
QApplication.clipboard().setImage(img)
def _teardown(self):
"""Carry out various teardown tasks such as event disconnection."""
self._setup_existing_themes(False)
_themes.events.added.disconnect(self._add_theme)
_themes.events.removed.disconnect(self._remove_theme)
self._qt_viewer.viewer.layers.events.disconnect(self.file_menu.update)
for menu in self.file_menu._INSTANCES:
with contextlib.suppress(RuntimeError):
menu._destroy()
def close(self):
"""Close the viewer window and cleanup sub-widgets."""
# Someone is closing us twice? Only try to delete self._qt_window
# if we still have one.
if hasattr(self, '_qt_window'):
self._teardown()
self._qt_viewer.close()
self._qt_window.close()
del self._qt_window
def _instantiate_dock_widget(wdg_cls, viewer: 'Viewer'):
# if the signature is looking a for a napari viewer, pass it.
from napari.viewer import Viewer
kwargs = {}
try:
sig = inspect.signature(wdg_cls.__init__)
except ValueError:
pass
else:
for param in sig.parameters.values():
if param.name == 'napari_viewer':
kwargs['napari_viewer'] = PublicOnlyProxy(viewer)
break
if param.annotation in ('napari.viewer.Viewer', Viewer):
kwargs[param.name] = PublicOnlyProxy(viewer)
break
# cannot look for param.kind == param.VAR_KEYWORD because
# QWidget allows **kwargs but errs on unknown keyword arguments
# instantiate the widget
return wdg_cls(**kwargs)
napari-0.5.0a1/napari/_qt/qt_resources/ 0000775 0000000 0000000 00000000000 14370413656 0017774 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/qt_resources/__init__.py 0000664 0000000 0000000 00000003745 14370413656 0022116 0 ustar 00root root 0000000 0000000 from pathlib import Path
from typing import List, Optional
from napari._qt.qt_resources._svg import QColoredSVGIcon
from napari.settings import get_settings
__all__ = ['get_stylesheet', 'QColoredSVGIcon']
STYLE_PATH = (Path(__file__).parent / 'styles').resolve()
STYLES = {x.stem: str(x) for x in STYLE_PATH.iterdir() if x.suffix == '.qss'}
def get_stylesheet(
theme_id: str = None, extra: Optional[List[str]] = None
) -> str:
"""Combine all qss files into single, possibly pre-themed, style string.
Parameters
----------
theme : str, optional
Theme to apply to the stylesheet. If no theme is provided, the returned
stylesheet will still have ``{{ template_variables }}`` that need to be
replaced using the :func:`napari.utils.theme.template` function prior
to using the stylesheet.
extra : list of str, optional
Additional paths to QSS files to include in stylesheet, by default None
Returns
-------
css : str
The combined stylesheet.
"""
stylesheet = ''
for key in sorted(STYLES.keys()):
file = STYLES[key]
with open(file) as f:
stylesheet += f.read()
if extra:
for file in extra:
with open(file) as f:
stylesheet += f.read()
if theme_id:
from napari.utils.theme import get_theme, template
return template(stylesheet, **get_theme(theme_id, as_dict=True))
return stylesheet
def get_current_stylesheet(extra: Optional[List[str]] = None) -> str:
"""
Return the current stylesheet base on settings. This is wrapper around
:py:func:`get_stylesheet` that takes the current theme base on settings.
Parameters
----------
extra : list of str, optional
Additional paths to QSS files to include in stylesheet, by default None
Returns
-------
css : str
The combined stylesheet.
"""
settings = get_settings()
return get_stylesheet(settings.appearance.theme, extra)
napari-0.5.0a1/napari/_qt/qt_resources/_svg.py 0000664 0000000 0000000 00000011461 14370413656 0021307 0 ustar 00root root 0000000 0000000 """
A Class for generating QIcons from SVGs with arbitrary colors at runtime.
"""
from typing import Optional, Union
from qtpy.QtCore import QByteArray, QPoint, QRect, QRectF, Qt
from qtpy.QtGui import QIcon, QIconEngine, QImage, QPainter, QPixmap
from qtpy.QtSvg import QSvgRenderer
class QColoredSVGIcon(QIcon):
"""A QIcon class that specializes in colorizing SVG files.
Parameters
----------
path_or_xml : str
Raw SVG XML or a path to an existing svg file. (Will raise error on
``__init__`` if a non-existent file is provided.)
color : str, optional
A valid CSS color string, used to colorize the SVG. by default None.
opacity : float, optional
Fill opacity for the icon (0-1). By default 1 (opaque).
Examples
--------
>>> from napari._qt.qt_resources import QColoredSVGIcon
>>> from qtpy.QtWidgets import QLabel
# Create icon with specific color
>>> label = QLabel()
>>> icon = QColoredSVGIcon.from_resources('new_points')
>>> label.setPixmap(icon.colored('#0934e2', opacity=0.7).pixmap(300, 300))
>>> label.show()
# Create colored icon using theme
>>> label = QLabel()
>>> icon = QColoredSVGIcon.from_resources('new_points')
>>> label.setPixmap(icon.colored(theme='light').pixmap(300, 300))
>>> label.show()
"""
def __init__(
self,
path_or_xml: str,
color: Optional[str] = None,
opacity: float = 1.0,
) -> None:
from napari.resources import get_colorized_svg
self._svg = path_or_xml
colorized = get_colorized_svg(path_or_xml, color, opacity)
super().__init__(SVGBufferIconEngine(colorized))
def colored(
self,
color: Optional[str] = None,
opacity: float = 1.0,
theme: Optional[str] = None,
theme_key: str = 'icon',
) -> 'QColoredSVGIcon':
"""Return a new colorized QIcon instance.
Parameters
----------
color : str, optional
A valid CSS color string, used to colorize the SVG. If provided,
will take precedence over ``theme``, by default None.
opacity : float, optional
Fill opacity for the icon (0-1). By default 1 (opaque).
theme : str, optional
Name of the theme to from which to get `theme_key` color.
``color`` argument takes precedence.
theme_key : str, optional
If using a theme, key in the theme dict to use, by default 'icon'
Returns
-------
QColoredSVGIcon
A pre-colored QColoredSVGIcon (which may still be recolored)
"""
if not color and theme:
from napari.utils.theme import get_theme
color = getattr(get_theme(theme, False), theme_key).as_hex()
return QColoredSVGIcon(self._svg, color, opacity)
@staticmethod
def from_resources(
icon_name: str,
) -> 'QColoredSVGIcon':
"""Get an icon from napari SVG resources.
Parameters
----------
icon_name : str
The name of the icon svg to load (just the stem). Must be in the
napari icons folder.
Returns
-------
QColoredSVGIcon
A colorizeable QIcon
"""
from napari.resources import get_icon_path
path = get_icon_path(icon_name)
return QColoredSVGIcon(path)
class SVGBufferIconEngine(QIconEngine):
"""A custom QIconEngine that can render an SVG buffer.
An icon engine provides the rendering functions for a ``QIcon``.
Each icon has a corresponding icon engine that is responsible for drawing
the icon with a requested size, mode and state. While the built-in
QIconEngine is capable of rendering SVG files, it's not able to receive the
raw XML string from memory.
This ``QIconEngine`` takes in SVG data as a raw xml string or bytes.
see: https://doc.qt.io/qt-5/qiconengine.html
"""
def __init__(self, xml: Union[str, bytes]) -> None:
if isinstance(xml, str):
xml = xml.encode('utf-8')
self.data = QByteArray(xml)
super().__init__()
def paint(self, painter: QPainter, rect, mode, state):
"""Paint the icon int ``rect`` using ``painter``."""
renderer = QSvgRenderer(self.data)
renderer.render(painter, QRectF(rect))
def clone(self):
"""Required to subclass abstract QIconEngine."""
return SVGBufferIconEngine(self.data)
def pixmap(self, size, mode, state):
"""Return the icon as a pixmap with requested size, mode, and state."""
img = QImage(size, QImage.Format_ARGB32)
img.fill(Qt.transparent)
pixmap = QPixmap.fromImage(img, Qt.NoFormatConversion)
painter = QPainter(pixmap)
self.paint(painter, QRect(QPoint(0, 0), size), mode, state)
return pixmap
napari-0.5.0a1/napari/_qt/qt_resources/_tests/ 0000775 0000000 0000000 00000000000 14370413656 0021275 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/qt_resources/_tests/test_icons.py 0000664 0000000 0000000 00000000570 14370413656 0024023 0 ustar 00root root 0000000 0000000 import shutil
from napari.resources._icons import ICON_PATH, ICONS
from napari.utils.misc import dir_hash, paths_hash
def test_icon_hash_equality():
if (_themes := ICON_PATH / '_themes').exists():
shutil.rmtree(_themes)
dir_hash_result = dir_hash(ICON_PATH)
paths_hash_result = paths_hash(ICONS.values())
assert dir_hash_result == paths_hash_result
napari-0.5.0a1/napari/_qt/qt_resources/_tests/test_svg.py 0000664 0000000 0000000 00000001256 14370413656 0023511 0 ustar 00root root 0000000 0000000 from qtpy.QtGui import QIcon
from napari._qt.qt_resources import QColoredSVGIcon
def test_colored_svg(qtbot):
"""Test that we can create a colored icon with certain color."""
icon = QColoredSVGIcon.from_resources('new_points')
assert isinstance(icon, QIcon)
assert isinstance(icon.colored('#0934e2', opacity=0.4), QColoredSVGIcon)
assert icon.pixmap(250, 250)
def test_colored_svg_from_theme(qtbot):
"""Test that we can create a colored icon using a theme name."""
icon = QColoredSVGIcon.from_resources('new_points')
assert isinstance(icon, QIcon)
assert isinstance(icon.colored(theme='light'), QColoredSVGIcon)
assert icon.pixmap(250, 250)
napari-0.5.0a1/napari/_qt/qt_resources/styles/ 0000775 0000000 0000000 00000000000 14370413656 0021317 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/qt_resources/styles/00_base.qss 0000664 0000000 0000000 00000032506 14370413656 0023266 0 ustar 00root root 0000000 0000000 /*
Styles in this file should only refer to built-in QtWidgets
It will be imported first, and styles declared in other files
may override these styles, but should only do so on
custom subclasses, object names, or properties.
might be possible to convert px to em by 1px = 0.0625em
*/
/* ----------------- QWidget ------------------ */
/*
mappings between property and QPalette.ColorRole:
these colors can be looked up dynamically in widgets using, e.g
``widget.palette().color(QPalette.Window)``
background -> QPalette.Window/QPalette.Background
background-color -> QPalette.Window/QPalette.Background
color -> QPalette.WindowText/QPalette.Foreground
selection-color -> QPalette.HighlightedText
selection-background-color -> QPalette.Highlight
alternate-background-color -> QPalette.AlternateBase
*/
QWidget {
background-color: {{ background }};
border: 0px;
padding: 1px;
margin: 0px;
color: {{ text }};
selection-background-color: {{ secondary }};
selection-color: {{ text }};
}
QWidget[emphasized="true"] {
background-color: {{ foreground }};
}
QWidget[emphasized="true"] > QFrame {
background-color: {{ foreground }};
}
/* ------------ QAbstractScrollArea ------------- */
/* QAbstractScrollArea is the superclass */
QTextEdit {
background-color: {{ console }};
background-clip: padding;
color: {{ text }};
selection-background-color: {{ foreground }};
padding: 4px 2px 4px 4px;
}
/* the area behind the scrollbar */
QTextEdit > QWidget {
background-color: {{ console }};
}
/* ----------------- QPushButton ------------------ */
QPushButton {
background-color: {{ foreground }};
border-radius: 2px;
padding: 4px;
border: 0px;
}
QPushButton:hover {
background-color: {{ primary }};
}
QPushButton:pressed {
background-color: {{ highlight }};
}
QPushButton:checked {
background-color: {{ highlight }};
}
QPushButton:disabled {
background-color: {{ opacity(foreground, 75) }};
border: 1px solid;
border-color: {{ foreground }};
color: {{ opacity(text, 90) }};
}
QWidget[emphasized="true"] QPushButton {
background-color: {{ primary }};
}
QWidget[emphasized="true"] QPushButton:disabled {
background-color: {{ darken(foreground, 20) }};
}
QWidget[emphasized="true"] QPushButton:hover {
background-color: {{ highlight }};
}
QWidget[emphasized="true"] QPushButton:pressed {
background-color: {{ secondary }};
}
QWidget[emphasized="true"] QPushButton:checked {
background-color: {{ current }};
}
/* ----------------- QComboBox ------------------ */
QComboBox {
border-radius: 2px;
background-color: {{ foreground }};
padding: 3px 10px 3px 8px; /* top right bottom left */
}
QComboBox:disabled {
background-color: {{ opacity(foreground, 75) }};
border: 1px solid;
border-color: {{ foreground }};
color: {{ opacity(text, 90) }};
}
QWidget[emphasized="true"] QComboBox {
background-color: {{ primary }};
}
QComboBox::drop-down {
width: 26px;
border-top-right-radius: 2px;
border-bottom-right-radius: 2px;
}
QComboBox::down-arrow {
image: url("theme_{{ id }}:/drop_down_50.svg");
width: 14px;
height: 14px;
}
QComboBox::down-arrow:on {
/* when the dropdown is open */
}
QComboBox:on {
border-radius: 0px;
}
QListView {
/* controls the color of the open dropdown menu */
background-color: {{ foreground }};
color: {{ text }};
border-radius: 2px;
}
QListView:item:selected {
background-color: {{ highlight }};
}
QWidget[emphasized="true"] QComboBox {
background-color: {{ primary }};
}
/* ----------------- QLineEdit ------------------ */
QLineEdit {
background-color: {{ darken(background, 15) }};
color: {{ text }};
min-height: 20px;
padding: 2px;
border-radius: 2px;
}
QWidget[emphasized="true"] QLineEdit {
background-color: {{ background }};
}
/* ----------------- QAbstractSpinBox ------------------ */
QAbstractSpinBox {
background-color: {{ foreground }};
border: none;
padding: 1px 10px;
min-width: 70px;
min-height: 18px;
border-radius: 2px;
}
QLabeledSlider > QAbstractSpinBox {
min-width: 10px;
padding: 0px;
}
QWidget[emphasized="true"] QAbstractSpinBox {
background-color: {{ primary }};
}
QAbstractSpinBox::up-button,
QAbstractSpinBox::down-button {
subcontrol-origin: margin;
width: 20px;
height: 20px;
}
QAbstractSpinBox::up-button:hover,
QAbstractSpinBox::down-button:hover {
background-color: {{ primary }};
}
QWidget[emphasized="true"] QAbstractSpinBox::up-button:hover,
QWidget[emphasized="true"] QAbstractSpinBox::down-button:hover {
background-color: {{ highlight }};
}
QAbstractSpinBox::up-button:pressed,
QAbstractSpinBox::down-button:pressed {
background-color: {{ highlight }};
}
QWidget[emphasized="true"] QAbstractSpinBox::up-button:pressed,
QWidget[emphasized="true"] QAbstractSpinBox::down-button:pressed {
background-color: {{ lighten(highlight, 15) }};
}
QAbstractSpinBox::up-button {
subcontrol-position: center right;
right: 0px;
border-top-right-radius: 2px;
border-bottom-right-radius: 2px;
}
QAbstractSpinBox::down-button {
subcontrol-position: center left;
left: 0px;
border-top-left-radius: 2px;
border-bottom-left-radius: 2px;
}
QAbstractSpinBox::up-arrow,
QAbstractSpinBox::down-arrow {
width: 10px;
height: 10px;
}
QAbstractSpinBox::up-arrow {
image: url("theme_{{ id }}:/plus_50.svg");
}
QAbstractSpinBox::down-arrow {
image: url("theme_{{ id }}:/minus_50.svg");
}
QLabeledRangeSlider > QAbstractSpinBox {
min-width: 5px;
}
/* ----------------- QCheckBox ------------------ */
QCheckBox {
spacing: 5px;
color: {{ text }};
background-color: none;
}
QCheckBox::indicator {
width: 16px;
height: 16px;
background-color: {{ foreground }};
border: 0px;
padding: 1px;
border-radius: 2px
}
QCheckBox::indicator:hover {
background-color: {{ lighten(foreground, 5) }};
}
QCheckBox::indicator:unchecked {
image: none;
}
QCheckBox::indicator:checked {
image: url("theme_{{ id }}:/check.svg");
}
QCheckBox::indicator:indeterminate {
image: url("theme_{{ id }}:/minus.svg");
padding: 2px;
width: 14px;
height: 14px;
}
QWidget[emphasized="true"] QCheckBox::indicator {
background-color: {{ primary }};
border-color: {{ primary }};
}
QWidget[emphasized="true"] QCheckBox::indicator:hover {
background-color: {{ lighten(primary, 5) }};
}
QWidget[emphasized="true"] QCheckBox::indicator:unchecked:hover {
background-color: {{ lighten(primary, 5) }};
border-color: {{ lighten(primary, 5) }};
}
/* ----------------- QRadioButton ------------------ */
QRadioButton {
background: none;
}
QRadioButton::indicator{
height: 16px;
width: 16px;
border-radius: 8px;
}
QRadioButton::indicator::unchecked {
background: {{ foreground }};
}
QRadioButton::indicator:unchecked:hover {
background: {{ lighten(foreground, 5) }};
}
QRadioButton::indicator::checked {
background: {{ highlight }};
}
QRadioButton::indicator::checked {
image: url("theme_{{ id }}:/circle.svg");
height: 6px;
width: 6px;
padding: 5px;
}
QWidget[emphasized="true"] > QRadioButton {
background: {{ foreground }};
}
QWidget[emphasized="true"] > QRadioButton::indicator::unchecked {
background-color: {{ primary }};
}
QWidget[emphasized="true"] > QRadioButton:disabled {
background-color: {{ foreground }};
}
QWidget[emphasized="true"] > QRadioButton::indicator:checked {
background-color: {{ secondary }};
}
QWidget[emphasized="true"] > QRadioButton::indicator:unchecked:hover {
background: {{ lighten(primary, 5) }};
}
/* ----------------- QSlider ------------------ */
QSlider {
background-color: none;
}
QSlider::groove:horizontal {
border: 0px;
background-color: {{ foreground }};
height: 6px;
border-radius: 2px;
}
QSlider::handle:horizontal {
background-color: {{ highlight }};
border: 0px;
width: 16px;
margin-top: -5px;
margin-bottom: -5px;
border-radius: 8px;
}
QSlider::handle:hover {
background-color: {{ secondary }};
}
QSlider::sub-page:horizontal {
background: {{ primary }};
border-radius: 2px;
}
QWidget[emphasized="true"] QSlider::groove:horizontal {
background: {{ primary }};
}
QWidget[emphasized="true"] QSlider::handle:horizontal {
background: {{ secondary }};
}
QWidget[emphasized="true"] QSlider::sub-page:horizontal {
background: {{ highlight }};
}
QWidget[emphasized="true"] QSlider::handle:hover {
background-color: {{ lighten(secondary, 5) }};
}
QRangeSlider {
qproperty-barColor: {{ primary }};
}
QWidget[emphasized="true"] QRangeSlider {
qproperty-barColor: {{ highlight }};
}
/* ----------------- QScrollBar ------------------ */
QScrollBar {
border: none;
border-radius: 2px;
background: {{ foreground }};
}
QWidget[emphasized="true"] QScrollBar {
background: {{ primary }};
}
QScrollBar:horizontal {
min-height: 13px;
max-height: 13px;
margin: 0px 16px;
}
QScrollBar:vertical {
max-width: 13px;
margin: 16px 0px;
}
QScrollBar::handle {
background: {{ highlight }};
border-radius: 2px;
}
QWidget[emphasized="true"] QScrollBar::handle {
background: {{ secondary }};
}
QScrollBar::handle:horizontal {
min-width: 26px;
}
QScrollBar::handle:vertical {
min-height: 26px;
}
QScrollBar::add-line, QScrollBar::sub-line {
border: none;
border-radius: 2px;
background: {{ foreground }};
subcontrol-origin: margin;
}
QWidget[emphasized="true"] QScrollBar::add-line,
QWidget[emphasized="true"] QScrollBar::sub-line {
background: {{ primary }};
}
QScrollBar::add-line:horizontal {
width: 13px;
subcontrol-position: right;
}
QScrollBar::sub-line:horizontal {
width: 13px;
subcontrol-position: left;
}
QScrollBar::add-line:vertical {
height: 13px;
subcontrol-position: bottom;
}
QScrollBar::sub-line:vertical {
height: 13px;
subcontrol-position: top;
}
QScrollBar::add-line:horizontal:pressed,
QScrollBar::sub-line:horizontal:pressed {
background: {{ highlight }};
}
QWidget[emphasized="true"] QScrollBar::add-line:horizontal:pressed,
QWidget[emphasized="true"] QScrollBar::sub-line:horizontal:pressed {
background: {{ secondary }};
}
QScrollBar:left-arrow:horizontal {
image: url("theme_{{ id }}:/left_arrow.svg");
}
QScrollBar::right-arrow:horizontal {
image: url("theme_{{ id }}:/right_arrow.svg");
}
QScrollBar:up-arrow:vertical {
image: url("theme_{{ id }}:/up_arrow.svg");
}
QScrollBar::down-arrow:vertical {
image: url("theme_{{ id }}:/down_arrow.svg");
}
QScrollBar::left-arrow,
QScrollBar::right-arrow,
QScrollBar::up-arrow,
QScrollBar::down-arrow {
min-height: 13px;
min-width: 13px;
max-height: 13px;
max-width: 13px;
padding: 1px 2px;
margin: 0;
border: 0;
border-radius: 2px;
background: {{ foreground }};
}
QScrollBar::left-arrow:hover,
QScrollBar::right-arrow:hover,
QScrollBar::up-arrow:hover,
QScrollBar::down-arrow:hover {
background-color: {{ primary }};
}
QScrollBar::left-arrow:pressed,
QScrollBar::right-arrow:pressed,
QScrollBar::up-arrow:pressed,
QScrollBar::down-arrow:pressed {
background-color: {{ highlight }};
}
QScrollBar::add-page,
QScrollBar::sub-page {
background: none;
}
/* ----------------- QProgressBar ------------------ */
QProgressBar {
border: 1px solid {{ foreground }};
border-radius: 2px;
text-align: center;
padding: 0px;
}
QProgressBar::horizontal {
height: 18px;
}
QProgressBar::vertical {
width: 18px;
}
QProgressBar::chunk {
width: 1px;
background-color: vgradient({{ highlight }} - {{ foreground }});
}
/* ----------------- QToolTip ------------------ */
QToolTip {
border: 1px solid {{ foreground }};
border-radius: 2px;
padding: 2px;
background-color: {{ background }};
color: {{ text }};
}
/* ----------------- QGroupBox ------------------ */
QGroupBox {
background-color: {{ background }};
border: 1px solid {{ foreground }};
border-radius: 5px;
margin-top: 1ex; /* leave space at the top for the title */
}
QGroupBox::title {
subcontrol-origin: margin;
subcontrol-position: top left;
left: 10px;
padding: 0 3px;
background-color: {{ background }};
}
/* ----------------- QTabWidget ------------------ */
/* The tab widget frame */
QTabWidget::pane {
border: 1px solid {{ darken(foreground, 10) }};
border-radius: 2px;
}
QWidget[emphasized="true"] QTabWidget::pane {
border: 1px solid {{ darken(primary, 10) }};
}
QTabBar::tab {
background-color: {{ foreground }};
border: 1px solid {{ background }};
border-bottom: 0px;
border-top-left-radius: 4px;
border-top-right-radius: 4px;
padding: 3px 6px;
background: vgradient({{ lighten(foreground, 15) }} - {{ foreground }});
}
QWidget[emphasized="true"] QTabBar::tab {
background-color: {{ primary }};
border: 1px solid {{ foreground }};
background: vgradient({{ lighten(primary, 15) }} - {{ primary }});
}
QTabBar::tab:selected {
background: vgradient({{ lighten(highlight, 15) }} - {{ highlight }});
}
QWidget[emphasized="true"] QTabBar::tab:selected {
background: vgradient({{ lighten(secondary, 15) }} - {{ secondary }});
}
/* ----------------- QLabel ------------------ */
QLabel {
background-color: none;
}
/* ----------------- QMenuBar ------------------ */
QMenuBar::item:selected {
background-color: {{ secondary }};
}
QLCDNumber {
background: none;
}
/* ----------------- QStatusBar ------------------ */
QStatusBar::item{
border: None;
}
/* ----------------- QHeaderView ----------------- */
QHeaderView::section {
background-color: {{ background }};
padding: 2px;
}
napari-0.5.0a1/napari/_qt/qt_resources/styles/01_buttons.qss 0000664 0000000 0000000 00000011651 14370413656 0024051 0 ustar 00root root 0000000 0000000
/* ----------------- Buttons -------------------- */
QtDeleteButton {
image: url("theme_{{ id }}:/delete.svg");
min-width : 28px;
max-width : 28px;
min-height : 28px;
max-height : 28px;
padding: 0px;
}
QtViewerPushButton{
min-width : 28px;
max-width : 28px;
min-height : 28px;
max-height : 28px;
padding: 0px;
}
QtViewerPushButton[mode="new_points"] {
image: url("theme_{{ id }}:/new_points.svg");
}
QtViewerPushButton[mode="new_shapes"] {
image: url("theme_{{ id }}:/new_shapes.svg");
}
QtViewerPushButton[mode="warning"] {
image: url("theme_{{ id }}:/warning.svg");
}
QtViewerPushButton[mode="new_labels"] {
image: url("theme_{{ id }}:/new_labels.svg");
}
QtViewerPushButton[mode="console"] {
image: url("theme_{{ id }}:/console.svg");
}
QtViewerPushButton[mode="roll"] {
image: url("theme_{{ id }}:/roll.svg");
}
QtViewerPushButton[mode="transpose"] {
image: url("theme_{{ id }}:/transpose.svg");
}
QtViewerPushButton[mode="home"] {
image: url("theme_{{ id }}:/home.svg");
}
QtViewerPushButton[mode="ndisplay_button"]:checked {
image: url("theme_{{ id }}:/3D.svg");
}
QtViewerPushButton[mode="ndisplay_button"] {
image: url("theme_{{ id }}:/2D.svg");
}
QtViewerPushButton[mode="grid_view_button"]:checked {
image: url("theme_{{ id }}:/square.svg");
}
QtViewerPushButton[mode="grid_view_button"] {
image: url("theme_{{ id }}:/grid.svg");
}
QtModeRadioButton {
min-height : 28px;
padding: 0px;
}
QtModeRadioButton::indicator:unchecked {
border-radius: 3px;
width: 28px;
height: 28px;
padding: 0;
background-color: {{ primary }};
}
QtModeRadioButton::indicator:checked {
border-radius: 3px;
height: 28px;
width: 28px;
padding: 0;
background-color: {{ current }};
}
QtModeRadioButton::indicator:disabled {
background-color: {{ darken(foreground, 20) }}
}
QtModeRadioButton::indicator:unchecked:hover {
background-color: {{ highlight }};
}
QtModeRadioButton[mode="zoom"]::indicator {
image: url("theme_{{ id }}:/zoom.svg");
}
QtModeRadioButton[mode="select"]::indicator {
image: url("theme_{{ id }}:/select.svg");
}
QtModeRadioButton[mode="direct"]::indicator {
image: url("theme_{{ id }}:/direct.svg");
}
QtModeRadioButton[mode="rectangle"]::indicator {
image: url("theme_{{ id }}:/rectangle.svg");
}
QtModeRadioButton[mode="ellipse"]::indicator {
image: url("theme_{{ id }}:/ellipse.svg");
color: red;
}
QtModeRadioButton[mode="line"]::indicator {
image: url("theme_{{ id }}:/line.svg");
}
QtModeRadioButton[mode="path"]::indicator {
image: url("theme_{{ id }}:/path.svg");
}
QtModeRadioButton[mode="polygon"]::indicator {
image: url("theme_{{ id }}:/polygon.svg");
}
QtModeRadioButton[mode="vertex_insert"]::indicator {
image: url("theme_{{ id }}:/vertex_insert.svg");
}
QtModeRadioButton[mode="vertex_remove"]::indicator {
image: url("theme_{{ id }}:/vertex_remove.svg");
}
QtModeRadioButton[mode="paint"]::indicator {
image: url("theme_{{ id }}:/paint.svg");
}
QtModeRadioButton[mode="fill"]::indicator {
image: url("theme_{{ id }}:/fill.svg");
}
QtModeRadioButton[mode="picker"]::indicator {
image: url("theme_{{ id }}:/picker.svg");
}
QtModeRadioButton[mode="erase"]::indicator {
image: url("theme_{{ id }}:/erase.svg");
}
QtModeRadioButton[mode="pan_zoom"]::indicator {
image: url("theme_{{ id }}:/zoom.svg");
}
QtModeRadioButton[mode="select_points"]::indicator {
image: url("theme_{{ id }}:/select.svg");
}
QtModeRadioButton[mode="add_points"]::indicator {
image: url("theme_{{ id }}:/add.svg");
}
QtModePushButton[mode="shuffle"] {
image: url("theme_{{ id }}:/shuffle.svg");
}
QtModePushButton[mode="move_back"] {
image: url("theme_{{ id }}:/move_back.svg");
}
QtModePushButton[mode="move_front"] {
image: url("theme_{{ id }}:/move_front.svg");
}
QtModePushButton[mode="delete_shape"] {
image: url("theme_{{ id }}:/delete_shape.svg");
}
QWidget[emphasized="true"] QtModePushButton[mode="delete_shape"]:pressed {
background-color: {{ error }};
}
QtCopyToClipboardButton {
background-color: {{ background }};
margin: 0px;
padding: 1px 1px 3px 2px;
border: 0px;
min-width: 18px;
max-width: 18px;
min-height: 18px;
max-height: 18px;
border-radius: 3px;
}
#QtCopyToClipboardButton {
image: url("theme_{{ id }}:/copy_to_clipboard.svg");
}
QtPlayButton {
border-radius: 2px;
height: 11px;
width: 11px;
margin: 0px 2px;
padding: 2px;
border: 0px;
}
QtPlayButton[reverse=True] {
image: url("theme_{{ id }}:/left_arrow.svg");
}
QtPlayButton[reverse=False] {
background: {{ foreground }};
image: url("theme_{{ id }}:/right_arrow.svg");
}
QtPlayButton[reverse=True]:hover, QtPlayButton[reverse=False]:hover {
background: {{ primary }};
}
QtPlayButton[playing=True]:hover {
background-color: {{ lighten(error, 10) }};
}
QtPlayButton[playing=True] {
image: url("theme_{{ id }}:/square.svg");
background-color: {{ error }};
height: 12px;
width: 12px;
padding: 2px;
}
napari-0.5.0a1/napari/_qt/qt_resources/styles/02_custom.qss 0000664 0000000 0000000 00000037202 14370413656 0023666 0 ustar 00root root 0000000 0000000 QLabel#h1 {
font-size: 28px;
}
QLabel#h2 {
font-size: 22px;
color: {{ secondary }};
}
QLabel#h3 {
font-size: 18px;
color: {{ secondary }};
}
QtViewer {
padding-top: 0px;
}
QtLayerButtons, QtViewerButtons, QtLayerList {
min-width: 242px;
}
/* ------------- QMainWindow --------- */
/* QDockWidgets will use the MainWindow styles
as long as they are docked (though they use the
style of QDockWidget when undocked) */
QStatusBar {
background: {{ background }};
color: {{ text }};
}
/* ------------- Window separator --------- */
QMainWindow::separator {
width: 4px;
height: 4px;
border: none;
background-color: {{ background }};
}
QMainWindow::separator:hover {
background: {{ foreground }};
}
QMainWindow::separator:horizontal {
image: url("theme_{{ id }}:/horizontal_separator.svg");
}
QMainWindow::separator:vertical {
image: url("theme_{{ id }}:/vertical_separator.svg");
}
/* ------------- DockWidgets --------- */
#QtCustomTitleBar {
padding-top:3px;
background-color: {{ background }};
}
#QtCustomTitleBar:hover {
background-color: {{ darken(background, 10) }};
}
#QtCustomTitleBarLine {
background-color: {{ foreground }};
}
#QtCustomTitleBar > QPushButton {
background-color: none;
max-width: 12px;
max-height: 12px;
}
#QtCustomTitleBar > QPushButton:hover {
background-color: {{ foreground }};
}
#QtCustomTitleBar > QLabel {
color: {{ primary }};
font-size: 11pt;
}
#QTitleBarCloseButton{
width: 12px;
height: 12px;
padding: 0;
image: url("theme_{{ id }}:/delete_shape.svg");
}
#QTitleBarFloatButton{
image: url("theme_{{ id }}:/pop_out.svg");
width: 10px;
height: 8px;
padding: 2 1 2 1;
}
#QTitleBarHideButton{
image: url("theme_{{ id }}:/visibility_off.svg");
width: 10px;
height: 8px;
padding: 2 1 2 1;
}
/* ----------------- Console ------------------ */
QtConsole {
min-height: 100px;
}
QtConsole > QTextEdit {
background-color: {{ console }};
background-clip: padding;
color: {{ text }};
selection-background-color: {{ highlight }};
margin: 10px;
}
.inverted {
background-color: {{ background }};
color: {{ foreground }};
}
.error { color: #b72121; }
.in-prompt-number { font-weight: bold; }
.out-prompt-number { font-weight: bold; }
.in-prompt { color: #6ab825; }
.out-prompt { color: #b72121; }
/* controls the area around the canvas */
QSplitter {
spacing: 0px;
padding: 0px;
margin: 0px;
}
QtDivider {
spacing: 0px;
padding: 0px;
border: 0px;
margin: 0px 3px 0px 3px;
min-width: 214px;
min-height: 1px;
max-height: 1px;
}
QtDivider[selected=true] {
background-color: {{ text }};
}
QtDivider[selected=false] {
background-color: {{ background }};
}
/* --------------- QtLayerWidget -------------------- */
QtLayerWidget {
padding: 0px;
background-color: {{ foreground }};
border-radius: 2px;
min-height: 32px;
max-height: 32px;
min-width: 228px;
}
QtLayerWidget[selected="true"] {
background-color: {{ current }};
}
QtLayerWidget > QLabel {
background-color: transparent;
padding: 0px;
qproperty-alignment: AlignCenter;
}
/* The name of the layer*/
QtLayerWidget > QLineEdit {
background-color: transparent;
border: none;
border-radius: 2px;
padding: 2px;
font-size: 14px;
qproperty-alignment: right;
}
QtLayerWidget > QLineEdit:disabled {
background-color: transparent;
border-color: transparent;
border-radius: 3px;
}
QtLayerWidget > QLineEdit:focus {
background-color: {{ darken(current, 20) }};
selection-background-color: {{ lighten(current, 20) }};
}
QtLayerWidget QCheckBox::indicator {
background-color: transparent;
}
QtLayerWidget QCheckBox::indicator:hover {
background-color: transparent;
}
QtLayerWidget > QCheckBox#visibility {
spacing: 0px;
margin: 0px 0px 0px 4px;
}
QtLayerWidget > QCheckBox#visibility::indicator{
width: 18px;
height: 18px;
}
QtLayerWidget > QCheckBox#visibility::indicator:unchecked {
image: url("theme_{{ id }}:/visibility_off_50.svg");
}
QtLayerWidget > QCheckBox#visibility::indicator:checked {
image: url("theme_{{ id }}:/visibility.svg");
}
QLabel[layer_type_label="true"] {
max-width: 20px;
min-width: 20px;
min-height: 20px;
max-height: 20px;
margin-right: 4px;
}
QLabel#Shapes {
image: url("theme_{{ id }}:/new_shapes.svg");
}
QLabel#Points {
image: url("theme_{{ id }}:/new_points.svg");
}
QLabel#Labels {
image: url("theme_{{ id }}:/new_labels.svg");
}
QLabel#Image {
image: url("theme_{{ id }}:/new_image.svg");
}
QLabel#Multiscale {
image: url("theme_{{ id }}:/new_image.svg");
}
QLabel#Surface {
image: url("theme_{{ id }}:/new_surface.svg");
}
QLabel#Vectors {
image: url("theme_{{ id }}:/new_vectors.svg");
}
QLabel#logo_silhouette {
image: url("theme_{{ id }}:/logo_silhouette.svg");
}
/* ------------------------------------------------------ */
QFrame#empty_controls_widget {
min-height: 225px;
min-width: 240px;
}
QtLayerControlsContainer {
border-radius: 2px;
padding: 0px;
margin: 10px;
margin-left: 10px;
margin-right: 8px;
margin-bottom: 4px;
}
QtLayerControlsContainer > QFrame {
padding: 5px;
padding-right: 8px;
border-radius: 2px;
}
/* the box that shows the current Label color */
QtColorBox {
padding: 0px;
border: 0px;
margin: -1px 0 0 -1px;
border-radius: 2px;
min-height: 20px;
max-height: 20px;
min-width: 20px;
max-width: 20px;
}
/* ----------------- QtLayerControls -------------------- */
QtLayerControls > QLabel, QtLayerControls, QtPlaneControls > QLabeledSlider > QAbstractSpinBox {
font-size: 11pt;
color: {{ text }};
}
QLabeledRangeSlider > QAbstractSpinBox {
font-size: 12pt;
color: {{ secondary }};
}
QWidget[emphasized="true"] QDoubleSlider::sub-page:horizontal:disabled {
background: {{ primary }};
}
QWidget[emphasized="true"] QDoubleSlider::handle:disabled {
background: {{ primary }};
}
QWidget[emphasized="true"] SliderLabel:disabled {
color: {{ opacity(text, 50) }};
}
QWidget[emphasized="true"] QLabel:disabled {
color: {{ opacity(text, 50) }};
}
AutoScaleButtons QPushButton {
font-size: 9pt;
padding: 4;
}
PlaneNormalButtons QPushButton {
font-size: 9pt;
padding: 4;
}
/* ------------- DimsSliders --------- */
QtDimSliderWidget > QScrollBar::handle[last_used=false]:horizontal {
background: {{ highlight }};
}
QtDimSliderWidget > QScrollBar::handle[last_used=true]:horizontal {
background: {{ secondary }};
}
QtDimSliderWidget > QScrollBar:left-arrow:horizontal {
image: url("theme_{{ id }}:/step_left.svg");
}
QtDimSliderWidget > QScrollBar::right-arrow:horizontal {
image: url("theme_{{ id }}:/step_right.svg");
}
QtDimSliderWidget > QLineEdit {
background-color: {{ background }};
}
#QtModalPopup {
/* required for rounded corners to not have background color */
background: transparent;
}
#QtPopupFrame {
border: 1px solid {{ secondary }};
border-radius: 5px;
}
#QtPopupFrame > QLabel {
color: {{ darken(text, 35) }};
font-size: 12px;
}
#playDirectionCheckBox::indicator {
image: url("theme_{{ id }}:/long_right_arrow.svg");
width: 22px;
height: 22px;
padding: 0 6px;
border: 0px;
}
#fpsSpinBox {
min-width: 60px;
}
#playDirectionCheckBox::indicator:checked {
image: url("theme_{{ id }}:/long_left_arrow.svg");
}
#playDirectionCheckBox::indicator:pressed {
background-color: {{ highlight }};
}
#colorSwatch {
border-radius: 1px;
min-height: 22px;
max-height: 22px;
min-width: 22px;
max-width: 22px;
}
#QtColorPopup{
background-color: transparent;
}
#CustomColorDialog QPushButton {
padding: 4px 10px;
}
#CustomColorDialog QLabel {
background-color: {{ background }};
color: {{ secondary }};
}
/* editable slice label and axis name */
QtDimSliderWidget > QLineEdit {
padding: 0 0 1px 2px;
max-height: 14px;
min-height: 12px;
min-width: 16px;
color: {{ text }};
}
#slice_label {
font-size: 11pt;
color: {{ secondary }};
background: transparent;
}
#slice_label_sep{
background-color: {{ background }};
border: 1px solid {{ primary }};
}
/* ------------ Special Dialogs ------------ */
QtAboutKeybindings {
min-width: 600px;
min-height: 605px;
}
QtAbout > QTextEdit{
margin: 0px;
border: 0px;
padding: 2px;
}
/* ------------ Shortcut Editor ------------ */
ShortcutEditor QHeaderView::section {
padding: 2px;
border: None;
}
/* ------------ Plugin Sorter ------------ */
ImplementationListItem {
background-color: {{ background }};
border-radius: 2px;
}
QtHookImplementationListWidget::item {
background: transparent;
}
QtHookImplementationListWidget {
background-color: {{ console }};
}
/* for the error reporter */
#pluginInfo {
color: text;
}
QtPluginErrReporter > QTextEdit {
background-color: {{ console }};
background-clip: padding;
color: {{ text }};
selection-background-color: {{ highlight }};
margin: 10px;
}
/* ------------ Notifications ------------ */
NapariQtNotification > QWidget {
background: none;
}
NapariQtNotification::hover{
background: {{ lighten(background, 5) }};
}
NapariQtNotification #expand_button {
background: none;
padding: 0px;
margin: 0px;
max-width: 20px;
}
NapariQtNotification[expanded="false"] #expand_button {
image: url("theme_{{ id }}:/chevron_up.svg");
}
NapariQtNotification[expanded="true"] #expand_button {
image: url("theme_{{ id }}:/chevron_down.svg");
}
NapariQtNotification #close_button {
background: none;
image: url("theme_{{ id }}:/delete_shape.svg");
padding: 0px;
margin: 0px;
max-width: 20px;
}
NapariQtNotification #source_label {
color: {{ primary }};
font-size: 11px;
}
NapariQtNotification #severity_icon {
padding: 0;
margin: 0 0 -3px 0;
min-width: 20px;
min-height: 18px;
font-size: 15px;
color: {{ icon }};
}
/* ------------ Activity Dock ------------ */
#QtCustomTitleLabel {
color: {{ primary }};
font-size: 11pt;
}
#QtActivityButton:hover {
background-color: {{ lighten(background, 10) }};
}
/* ------------ Plugin Dialog ------------ */
QPluginList {
background: {{ console }};
}
PluginListItem {
background: {{ darken(foreground, 20) }};
padding: 0;
margin: 2px 4px;
border-radius: 3px;
}
PluginListItem#unavailable {
background: {{ lighten(foreground, 20) }};
padding: 0;
margin: 2px 4px;
border-radius: 3px;
}
PluginListItem QCheckBox::indicator:disabled {
background-color: {{ opacity(foreground, 127) }};
image: url("theme_{{ id }}:/check_50.svg");
}
QPushButton#install_button {
background-color: {{ current }}
}
QPushButton#install_button:hover {
background-color: {{ lighten(current, 10) }}
}
QPushButton#install_button:pressed {
background-color: {{ darken(current, 10) }}
}
QPushButton#install_button:disabled {
background-color: {{ lighten(current, 20) }}
}
QPushButton#remove_button {
background-color: {{ error }}
}
QPushButton#remove_button:hover {
background-color: {{ lighten(error, 10) }}
}
QPushButton#remove_button:pressed {
background-color: {{ darken(error, 10) }}
}
QPushButton#busy_button:pressed {
background-color: {{ darken(secondary, 10) }}
}
QPushButton#busy_button {
background-color: {{ secondary }}
}
QPushButton#busy_button:hover {
background-color: {{ lighten(secondary, 10) }}
}
QPushButton#busy_button:pressed {
background-color: {{ darken(secondary, 10) }}
}
QPushButton#close_button:disabled {
background-color: {{ lighten(secondary, 10) }}
}
#small_text {
color: {{ opacity(text, 150) }};
font-size: 10px;
}
#small_italic_text {
color: {{ opacity(text, 150) }};
font-size: 12px;
font-style: italic;
}
#plugin_manager_process_status{
background: {{ background }};
color: {{ opacity(text, 200) }};
}
#info_icon {
image: url("theme_{{ id }}:/info.svg");
min-width: 18px;
min-height: 18px;
margin: 2px;
}
#warning_icon {
image: url("theme_{{ id }}:/warning.svg");
max-width: 14px;
max-height: 14px;
min-width: 14px;
min-height: 14px;
margin: 0px;
margin-left: 1px;
padding: 2px;
background: darken(foreground, 20);
}
#warning_icon:hover{
background: {{ foreground }};
}
#warning_icon:pressed{
background: {{ primary }};
}
#error_label {
image: url("theme_{{ id }}:/warning.svg");
max-width: 18px;
max-height: 18px;
min-width: 18px;
min-height: 18px;
margin: 0px;
margin-left: 1px;
padding: 2px;
}
#success_label {
image: url("theme_{{ id }}:/check.svg");
max-width: 18px;
max-height: 18px;
min-width: 18px;
min-height: 18px;
margin: 0px;
margin-left: 1px;
padding: 2px;
}
#help_label {
image: url("theme_{{ id }}:/help.svg");
max-width: 18px;
max-height: 18px;
min-width: 18px;
min-height: 18px;
margin: 0px;
margin-left: 1px;
padding: 2px;
}
QtPluginDialog QSplitter{
padding-right: 2;
}
QtPluginSorter {
padding: 20px;
}
QtFontSizePreview {
border: 1px solid {{ foreground }};
border-radius: 5px;
}
QListWidget#Preferences {
background: {{ background }};
}
QtWelcomeWidget, QtWelcomeWidget[drag=false] {
background: {{ canvas }};
}
QtWelcomeWidget[drag=true] {
background: {{ highlight }};
}
QtWelcomeLabel {
color: {{ foreground }};
font-size: 20px;
}
QtShortcutLabel {
color: {{ foreground }};
font-size: 16px;
}
/* ------------- Narrow scrollbar for qtlayer list --------- */
QtListView {
background: {{ background }};
}
QtListView QScrollBar:vertical {
max-width: 8px;
}
QtListView QScrollBar::add-line:vertical,
QtListView QScrollBar::sub-line:vertical {
height: 10px;
width: 8px;
margin-top: 2px;
margin-bottom: 2px;
}
QtListView QScrollBar:up-arrow,
QtListView QScrollBar:down-arrow {
min-height: 6px;
min-width: 6px;
max-height: 6px;
max-width: 6px;
}
QtListView::item {
padding: 4px;
margin: 2px 2px 2px 2px;
background-color: {{ foreground }};
border: 1px solid {{ foreground }};
}
QtListView::item:hover {
background-color: {{ lighten(foreground, 3) }};
}
/* in the QSS context "active" means the window is active */
/* (as opposed to focused on another application) */
QtListView::item:selected:active{
background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 {{ current }}, stop: 1 {{ darken(current, 15) }});
}
QtListView::item:selected:!active {
background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 {{ darken(current, 10) }}, stop: 1 {{ darken(current, 25) }});
}
QtListView QLineEdit {
background-color: {{ darken(current, 20) }};
selection-background-color: {{ lighten(current, 20) }};
font-size: 12px;
}
QtLayerList::item {
margin: 2px 2px 2px 28px;
border-top-right-radius: 2px;
border-bottom-right-radius: 2px;
border: 0;
}
/* the first one is the "partially checked" state */
QtLayerList::indicator {
width: 16px;
height: 16px;
position: absolute;
left: 0px;
image: url("theme_{{ id }}:/visibility_off.svg");
}
QtLayerList::indicator:unchecked {
image: url("theme_{{ id }}:/visibility_off_50.svg");
}
QtLayerList::indicator:checked {
image: url("theme_{{ id }}:/visibility.svg");
}
#error_icon_btn {
qproperty-icon: url("theme_{{ id }}:/error.svg");
}
#warning_icon_btn {
qproperty-icon: url("theme_{{ id }}:/warning.svg");
}
#warning_icon_element {
image: url("theme_{{ id }}:/warning.svg");
min-height: 36px;
min-width: 36px;
}
#error_icon_element {
image: url("theme_{{ id }}:/error.svg");
min-height: 36px;
min-width: 36px;
}
/* --------------- Menus (application and context menus) ---------------- */
QMenu::separator, QModelMenu::separator {
height: 1 px;
background: {{ opacity(text, 90) }};
margin-left: 17 px;
margin-right: 6 px;
margin-top: 5 px;
margin-bottom: 3 px;
}
QMenu:disabled, QModelMenu:disabled {
background-color: {{ background }};
selection-background-color: transparent;
border: 1px solid;
border-color: {{ foreground }};
color: {{ opacity(text, 90) }};
}
QMenu, QModelMenu {
padding: 6 px;
}
napari-0.5.0a1/napari/_qt/qt_viewer.py 0000664 0000000 0000000 00000127465 14370413656 0017654 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import logging
import traceback
import typing
import warnings
from pathlib import Path
from typing import TYPE_CHECKING, List, Optional, Sequence, Tuple, Union
from weakref import WeakSet
import numpy as np
from qtpy.QtCore import QCoreApplication, QObject, Qt
from qtpy.QtGui import QCursor, QGuiApplication
from qtpy.QtWidgets import QFileDialog, QSplitter, QVBoxLayout, QWidget
from napari._qt.containers import QtLayerList
from napari._qt.dialogs.qt_reader_dialog import handle_gui_reading
from napari._qt.dialogs.screenshot_dialog import ScreenshotDialog
from napari._qt.perf.qt_performance import QtPerformance
from napari._qt.utils import (
QImg2array,
circle_pixmap,
crosshair_pixmap,
square_pixmap,
)
from napari._qt.widgets.qt_dims import QtDims
from napari._qt.widgets.qt_viewer_buttons import (
QtLayerButtons,
QtViewerButtons,
)
from napari._qt.widgets.qt_viewer_dock_widget import QtViewerDockWidget
from napari._qt.widgets.qt_welcome import QtWidgetOverlay
from napari.components.camera import Camera
from napari.components.layerlist import LayerList
from napari.components.overlays import CanvasOverlay, Overlay, SceneOverlay
from napari.errors import MultipleReaderError, ReaderPluginError
from napari.layers.base.base import Layer
from napari.plugins import _npe2
from napari.settings import get_settings
from napari.utils import config, perf
from napari.utils._proxies import ReadOnlyWrapper
from napari.utils.action_manager import action_manager
from napari.utils.colormaps.standardize_color import transform_color
from napari.utils.history import (
get_open_history,
get_save_history,
update_open_history,
update_save_history,
)
from napari.utils.interactions import (
mouse_double_click_callbacks,
mouse_move_callbacks,
mouse_press_callbacks,
mouse_release_callbacks,
mouse_wheel_callbacks,
)
from napari.utils.io import imsave
from napari.utils.key_bindings import KeymapHandler
from napari.utils.misc import in_ipython, in_jupyter
from napari.utils.theme import get_theme
from napari.utils.translations import trans
from napari_builtins.io import imsave_extensions
from napari._vispy import ( # isort:skip
VispyCamera,
VispyCanvas,
create_vispy_layer,
create_vispy_overlay,
)
if TYPE_CHECKING:
from npe2.manifest.contributions import WriterContribution
from napari._qt.layer_controls import QtLayerControlsContainer
from napari.components import ViewerModel
def _npe2_decode_selected_filter(
ext_str: str, selected_filter: str, writers: Sequence[WriterContribution]
) -> Optional[WriterContribution]:
"""Determine the writer that should be invoked to save data.
When npe2 can be imported, resolves a selected file extension
string into a specific writer. Otherwise, returns None.
"""
# When npe2 is not present, `writers` is expected to be an empty list,
# `[]`. This function will return None.
for entry, writer in zip(
ext_str.split(";;"),
writers,
):
if entry.startswith(selected_filter):
return writer
return None
def _extension_string_for_layers(
layers: Sequence[Layer],
) -> Tuple[str, List[WriterContribution]]:
"""Return an extension string and the list of corresponding writers.
The extension string is a ";;" delimeted string of entries. Each entry
has a brief description of the file type and a list of extensions.
The writers, when provided, are the npe2.manifest.io.WriterContribution
objects. There is one writer per entry in the extension string. If npe2
is not importable, the list of writers will be empty.
"""
# try to use npe2
ext_str, writers = _npe2.file_extensions_string_for_layers(layers)
if ext_str:
return ext_str, writers
# fallback to old behavior
if len(layers) == 1:
selected_layer = layers[0]
# single selected layer.
if selected_layer._type_string == 'image':
ext = imsave_extensions()
ext_list = [f"*{val}" for val in ext]
ext_str = ';;'.join(ext_list)
ext_str = trans._(
"All Files (*);; Image file types:;;{ext_str}",
ext_str=ext_str,
)
elif selected_layer._type_string == 'points':
ext_str = trans._("All Files (*);; *.csv;;")
else:
# layer other than image or points
ext_str = trans._("All Files (*);;")
else:
# multiple layers.
ext_str = trans._("All Files (*);;")
return ext_str, []
class QtViewer(QSplitter):
"""Qt view for the napari Viewer model.
Parameters
----------
viewer : napari.components.ViewerModel
Napari viewer containing the rendered scene, layers, and controls.
show_welcome_screen : bool, optional
Flag to show a welcome message when no layers are present in the
canvas. Default is `False`.
Attributes
----------
canvas : vispy.scene.SceneCanvas
Canvas for rendering the current view.
console : QtConsole
IPython console terminal integrated into the napari GUI.
controls : QtLayerControlsContainer
Qt view for GUI controls.
dims : napari.qt_dims.QtDims
Dimension sliders; Qt View for Dims model.
dockConsole : QtViewerDockWidget
QWidget wrapped in a QDockWidget with forwarded viewer events.
dockLayerControls : QtViewerDockWidget
QWidget wrapped in a QDockWidget with forwarded viewer events.
dockLayerList : QtViewerDockWidget
QWidget wrapped in a QDockWidget with forwarded viewer events.
layerButtons : QtLayerButtons
Button controls for napari layers.
layers : QtLayerList
Qt view for LayerList controls.
layer_to_visual : dict
Dictionary mapping napari layers with their corresponding vispy_layers.
view : vispy scene widget
View displayed by vispy canvas. Adds a vispy ViewBox as a child widget.
viewer : napari.components.ViewerModel
Napari viewer containing the rendered scene, layers, and controls.
viewerButtons : QtViewerButtons
Button controls for the napari viewer.
"""
_instances = WeakSet()
def __init__(
self, viewer: ViewerModel, show_welcome_screen: bool = False
) -> None:
super().__init__()
self._instances.add(self)
self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
self._show_welcome_screen = show_welcome_screen
QCoreApplication.setAttribute(
Qt.AA_UseStyleSheetPropagationInWidgetStyles, True
)
self.viewer = viewer
self.dims = QtDims(self.viewer.dims)
self._controls = None
self._layers = None
self._layersButtons = None
self._viewerButtons = None
self._key_map_handler = KeymapHandler()
self._key_map_handler.keymap_providers = [self.viewer]
self._console = None
self._dockLayerList = None
self._dockLayerControls = None
self._dockConsole = None
self._dockPerformance = None
# This dictionary holds the corresponding vispy visual for each layer
self.layer_to_visual = {}
self.overlay_to_visual = {}
self._create_canvas()
# Stacked widget to provide a welcome page
self._welcome_widget = QtWidgetOverlay(self, self.canvas.native)
self._welcome_widget.set_welcome_visible(show_welcome_screen)
self._welcome_widget.sig_dropped.connect(self.dropEvent)
self._welcome_widget.leave.connect(self._leave_canvas)
self._welcome_widget.enter.connect(self._enter_canvas)
main_widget = QWidget()
main_layout = QVBoxLayout()
main_layout.setContentsMargins(0, 2, 0, 2)
main_layout.addWidget(self._welcome_widget)
main_layout.addWidget(self.dims)
main_layout.setSpacing(0)
main_widget.setLayout(main_layout)
self.setOrientation(Qt.Orientation.Vertical)
self.addWidget(main_widget)
self._cursors = {
'cross': Qt.CursorShape.CrossCursor,
'forbidden': Qt.CursorShape.ForbiddenCursor,
'pointing': Qt.CursorShape.PointingHandCursor,
'standard': Qt.CursorShape.ArrowCursor,
}
self._on_active_change()
self.viewer.layers.events.inserted.connect(self._update_welcome_screen)
self.viewer.layers.events.removed.connect(self._update_welcome_screen)
self.viewer.layers.selection.events.active.connect(
self._on_active_change
)
self.viewer.camera.events.interactive.connect(self._on_interactive)
self.viewer.cursor.events.style.connect(self._on_cursor)
self.viewer.cursor.events.size.connect(self._on_cursor)
self.viewer.layers.events.reordered.connect(self._reorder_layers)
self.viewer.layers.events.inserted.connect(self._on_add_layer_change)
self.viewer.layers.events.removed.connect(self._remove_layer)
self.setAcceptDrops(True)
self.view = self.canvas.central_widget.add_view(border_width=0)
self.camera = VispyCamera(
self.view, self.viewer.camera, self.viewer.dims
)
self.canvas.events.draw.connect(self.camera.on_draw)
# Create the experimental QtPool for octree and/or monitor.
self._qt_poll = _create_qt_poll(self, self.viewer.camera)
# Create the experimental RemoteManager for the monitor.
self._remote_manager = _create_remote_manager(
self.viewer.layers, self._qt_poll
)
# moved from the old layerlist... still feels misplaced.
# can you help me move this elsewhere?
if config.async_loading:
from napari._qt.experimental.qt_chunk_receiver import (
QtChunkReceiver,
)
# The QtChunkReceiver object allows the ChunkLoader to pass newly
# loaded chunks to the layers that requested them.
self.chunk_receiver = QtChunkReceiver(self.layers)
else:
self.chunk_receiver = None
# bind shortcuts stored in settings last.
self._bind_shortcuts()
for layer in self.viewer.layers:
self._add_layer(layer)
for overlay in self.viewer._overlays.values():
self._add_overlay(overlay)
@property
def controls(self) -> QtLayerControlsContainer:
if self._controls is None:
# Avoid circular import.
from napari._qt.layer_controls import QtLayerControlsContainer
self._controls = QtLayerControlsContainer(self.viewer)
return self._controls
@property
def layers(self) -> QtLayerList:
if self._layers is None:
self._layers = QtLayerList(self.viewer.layers)
return self._layers
@property
def layerButtons(self) -> QtLayerButtons:
if self._layersButtons is None:
self._layersButtons = QtLayerButtons(self.viewer)
return self._layersButtons
@property
def viewerButtons(self) -> QtViewerButtons:
if self._viewerButtons is None:
self._viewerButtons = QtViewerButtons(self.viewer)
return self._viewerButtons
@property
def dockLayerList(self) -> QtViewerDockWidget:
if self._dockLayerList is None:
layerList = QWidget()
layerList.setObjectName('layerList')
layerListLayout = QVBoxLayout()
layerListLayout.addWidget(self.layerButtons)
layerListLayout.addWidget(self.layers)
layerListLayout.addWidget(self.viewerButtons)
layerListLayout.setContentsMargins(8, 4, 8, 6)
layerList.setLayout(layerListLayout)
self._dockLayerList = QtViewerDockWidget(
self,
layerList,
name=trans._('layer list'),
area='left',
allowed_areas=['left', 'right'],
object_name='layer list',
close_btn=False,
)
return self._dockLayerList
@property
def dockLayerControls(self) -> QtViewerDockWidget:
if self._dockLayerControls is None:
self._dockLayerControls = QtViewerDockWidget(
self,
self.controls,
name=trans._('layer controls'),
area='left',
allowed_areas=['left', 'right'],
object_name='layer controls',
close_btn=False,
)
return self._dockLayerControls
@property
def dockConsole(self) -> QtViewerDockWidget:
if self._dockConsole is None:
self._dockConsole = QtViewerDockWidget(
self,
QWidget(),
name=trans._('console'),
area='bottom',
allowed_areas=['top', 'bottom'],
object_name='console',
close_btn=False,
)
self._dockConsole.setVisible(False)
self._dockConsole.visibilityChanged.connect(self._ensure_connect)
return self._dockConsole
@property
def dockPerformance(self) -> QtViewerDockWidget:
if self._dockPerformance is None:
self._dockPerformance = self._create_performance_dock_widget()
return self._dockPerformance
def _leave_canvas(self):
"""disable status on canvas leave"""
self.viewer.status = ""
self.viewer.mouse_over_canvas = False
def _enter_canvas(self):
"""enable status on canvas enter"""
self.viewer.status = "Ready"
self.viewer.mouse_over_canvas = True
def _ensure_connect(self):
# lazy load console
id(self.console)
def _bind_shortcuts(self):
"""Bind shortcuts stored in SETTINGS to actions."""
for action, shortcuts in get_settings().shortcuts.shortcuts.items():
action_manager.unbind_shortcut(action)
for shortcut in shortcuts:
action_manager.bind_shortcut(action, shortcut)
def _create_canvas(self) -> None:
"""Create the canvas and hook up events."""
self.canvas = VispyCanvas(
keys=None,
vsync=True,
parent=self,
size=self.viewer._canvas_size[::-1],
)
self.canvas.events.draw.connect(self.dims.enable_play)
self.canvas.events.mouse_double_click.connect(
self.on_mouse_double_click
)
self.canvas.events.mouse_move.connect(self.on_mouse_move)
self.canvas.events.mouse_press.connect(self.on_mouse_press)
self.canvas.events.mouse_release.connect(self.on_mouse_release)
self.canvas.events.key_press.connect(
self._key_map_handler.on_key_press
)
self.canvas.events.key_release.connect(
self._key_map_handler.on_key_release
)
self.canvas.events.mouse_wheel.connect(self.on_mouse_wheel)
self.canvas.events.draw.connect(self.on_draw)
self.canvas.events.resize.connect(self.on_resize)
self.canvas.bgcolor = transform_color(
get_theme(self.viewer.theme, False).canvas.as_hex()
)[0]
theme = self.viewer.events.theme
on_theme_change = self.canvas._on_theme_change
theme.connect(on_theme_change)
self.canvas.destroyed.connect(self._diconnect_theme)
def _diconnect_theme(self):
self.viewer.events.theme.disconnect(self.canvas._on_theme_change)
def _add_overlay(self, overlay: Overlay) -> None:
vispy_overlay = create_vispy_overlay(overlay, viewer=self.viewer)
if isinstance(overlay, CanvasOverlay):
vispy_overlay.node.parent = self.view
elif isinstance(overlay, SceneOverlay):
vispy_overlay.node.parent = self.view.scene
self.overlay_to_visual[overlay] = vispy_overlay
def _create_performance_dock_widget(self):
"""Create the dock widget that shows performance metrics."""
if perf.USE_PERFMON:
return QtViewerDockWidget(
self,
QtPerformance(),
name=trans._('performance'),
area='bottom',
)
return None
@property
def console(self):
"""QtConsole: iPython console terminal integrated into the napari GUI."""
if self._console is None:
try:
from napari_console import QtConsole
import napari
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
self.console = QtConsole(self.viewer)
self.console.push(
{'napari': napari, 'action_manager': action_manager}
)
except ModuleNotFoundError:
warnings.warn(
trans._(
'napari-console not found. It can be installed with'
' "pip install napari_console"'
)
)
self._console = None
except ImportError:
traceback.print_exc()
warnings.warn(
trans._(
'error importing napari-console. See console for full error.'
)
)
self._console = None
return self._console
@console.setter
def console(self, console):
self._console = console
if console is not None:
self.dockConsole.setWidget(console)
console.setParent(self.dockConsole)
def _on_active_change(self):
"""When active layer changes change keymap handler."""
self._key_map_handler.keymap_providers = (
[self.viewer]
if self.viewer.layers.selection.active is None
else [self.viewer.layers.selection.active, self.viewer]
)
def _on_add_layer_change(self, event):
"""When a layer is added, set its parent and order.
Parameters
----------
event : napari.utils.event.Event
The napari event that triggered this method.
"""
layer = event.value
self._add_layer(layer)
def _add_layer(self, layer):
"""When a layer is added, set its parent and order.
Parameters
----------
layer : napari.layers.Layer
Layer to be added.
"""
vispy_layer = create_vispy_layer(layer)
# QtPoll is experimental.
if self._qt_poll is not None:
# QtPoll will call VipyBaseImage._on_poll() when the camera
# moves or the timer goes off.
self._qt_poll.events.poll.connect(vispy_layer._on_poll)
# In the other direction, some visuals need to tell QtPoll to
# start polling. When they receive new data they need to be
# polled to load it, even if the camera is not moving.
if vispy_layer.events is not None:
vispy_layer.events.loaded.connect(self._qt_poll.wake_up)
vispy_layer.node.parent = self.view.scene
self.layer_to_visual[layer] = vispy_layer
self._reorder_layers()
def _remove_layer(self, event):
"""When a layer is removed, remove its parent.
Parameters
----------
event : napari.utils.event.Event
The napari event that triggered this method.
"""
layer = event.value
vispy_layer = self.layer_to_visual[layer]
vispy_layer.close()
del vispy_layer
del self.layer_to_visual[layer]
self._reorder_layers()
def _reorder_layers(self):
"""When the list is reordered, propagate changes to draw order."""
for i, layer in enumerate(self.viewer.layers):
vispy_layer = self.layer_to_visual[layer]
vispy_layer.order = i
self.canvas._draw_order.clear()
self.canvas.update()
def _save_layers_dialog(self, selected=False):
"""Save layers (all or selected) to disk, using ``LayerList.save()``.
Parameters
----------
selected : bool
If True, only layers that are selected in the viewer will be saved.
By default, all layers are saved.
"""
msg = ''
if not len(self.viewer.layers):
msg = trans._("There are no layers in the viewer to save")
elif selected and not len(self.viewer.layers.selection):
msg = trans._(
'Please select one or more layers to save,'
'\nor use "Save all layers..."'
)
if msg:
raise OSError(trans._("Nothing to save"))
# prepare list of extensions for drop down menu.
ext_str, writers = _extension_string_for_layers(
list(self.viewer.layers.selection)
if selected
else self.viewer.layers
)
msg = trans._("selected") if selected else trans._("all")
dlg = QFileDialog()
hist = get_save_history()
dlg.setHistory(hist)
filename, selected_filter = dlg.getSaveFileName(
parent=self,
caption=trans._('Save {msg} layers', msg=msg),
directory=hist[0], # home dir by default,
filter=ext_str,
options=(
QFileDialog.DontUseNativeDialog
if in_ipython()
else QFileDialog.Options()
),
)
logging.debug(
trans._(
'QFileDialog - filename: {filename} '
'selected_filter: {selected_filter}',
filename=filename or None,
selected_filter=selected_filter or None,
)
)
if filename:
writer = _npe2_decode_selected_filter(
ext_str, selected_filter, writers
)
with warnings.catch_warnings(record=True) as wa:
saved = self.viewer.layers.save(
filename, selected=selected, _writer=writer
)
logging.debug('Saved %s', saved)
error_messages = "\n".join(str(x.message.args[0]) for x in wa)
if not saved:
raise OSError(
trans._(
"File {filename} save failed.\n{error_messages}",
deferred=True,
filename=filename,
error_messages=error_messages,
)
)
else:
update_save_history(saved[0])
def _update_welcome_screen(self):
"""Update welcome screen display based on layer count."""
if self._show_welcome_screen:
self._welcome_widget.set_welcome_visible(not self.viewer.layers)
def _screenshot(self, flash=True):
"""Capture a screenshot of the Vispy canvas.
Parameters
----------
flash : bool
Flag to indicate whether flash animation should be shown after
the screenshot was captured.
"""
# CAN REMOVE THIS AFTER DEPRECATION IS DONE, see self.screenshot.
img = self.canvas.native.grabFramebuffer()
if flash:
from napari._qt.utils import add_flash_animation
# Here we are actually applying the effect to the `_welcome_widget`
# and not # the `native` widget because it does not work on the
# `native` widget. It's probably because the widget is in a stack
# with the `QtWelcomeWidget`.
add_flash_animation(self._welcome_widget)
return img
def screenshot(self, path=None, flash=True):
"""Take currently displayed screen and convert to an image array.
Parameters
----------
path : str
Filename for saving screenshot image.
flash : bool
Flag to indicate whether flash animation should be shown after
the screenshot was captured.
Returns
-------
image : array
Numpy array of type ubyte and shape (h, w, 4). Index [0, 0] is the
upper-left corner of the rendered region.
"""
img = QImg2array(self._screenshot(flash))
if path is not None:
imsave(path, img) # scikit-image imsave method
return img
def clipboard(self, flash=True):
"""Take a screenshot of the currently displayed screen and copy the
image to the clipboard.
Parameters
----------
flash : bool
Flag to indicate whether flash animation should be shown after
the screenshot was captured.
"""
cb = QGuiApplication.clipboard()
cb.setImage(self._screenshot(flash))
def _screenshot_dialog(self):
"""Save screenshot of current display, default .png"""
hist = get_save_history()
dial = ScreenshotDialog(self.screenshot, self, hist[0], hist)
if dial.exec_():
update_save_history(dial.selectedFiles()[0])
def _open_file_dialog_uni(self, caption: str) -> typing.List[str]:
"""
Open dialog to get list of files from user
"""
dlg = QFileDialog()
hist = get_open_history()
dlg.setHistory(hist)
open_kwargs = {
"parent": self,
"caption": caption,
}
if "pyside" in QFileDialog.__module__.lower():
# PySide6
open_kwargs["dir"] = hist[0]
else:
open_kwargs["directory"] = hist[0]
if in_ipython():
open_kwargs["options"] = QFileDialog.DontUseNativeDialog
return dlg.getOpenFileNames(**open_kwargs)[0]
def _open_files_dialog(self, choose_plugin=False):
"""Add files from the menubar."""
filenames = self._open_file_dialog_uni(trans._('Select file(s)...'))
if (filenames != []) and (filenames is not None):
for filename in filenames:
self._qt_open(
[filename], stack=False, choose_plugin=choose_plugin
)
update_open_history(filenames[0])
def _open_files_dialog_as_stack_dialog(self, choose_plugin=False):
"""Add files as a stack, from the menubar."""
filenames = self._open_file_dialog_uni(trans._('Select files...'))
if (filenames != []) and (filenames is not None):
self._qt_open(filenames, stack=True, choose_plugin=choose_plugin)
update_open_history(filenames[0])
def _open_folder_dialog(self, choose_plugin=False):
"""Add a folder of files from the menubar."""
dlg = QFileDialog()
hist = get_open_history()
dlg.setHistory(hist)
folder = dlg.getExistingDirectory(
self,
trans._('Select folder...'),
hist[0], # home dir by default
(
QFileDialog.DontUseNativeDialog
if in_ipython()
else QFileDialog.Options()
),
)
if folder not in {'', None}:
self._qt_open([folder], stack=False, choose_plugin=choose_plugin)
update_open_history(folder)
def _qt_open(
self,
filenames: List[str],
stack: Union[bool, List[List[str]]],
choose_plugin: bool = False,
plugin: str = None,
layer_type: str = None,
**kwargs,
):
"""Open files, potentially popping reader dialog for plugin selection.
Call ViewerModel.open and catch errors that could
be fixed by user making a plugin choice.
Parameters
----------
filenames : List[str]
paths to open
choose_plugin : bool
True if user wants to explicitly choose the plugin else False
stack : bool or list[list[str]]
whether to stack files or not. Can also be a list containing
files to stack.
plugin : str
plugin to use for reading
layer_type : str
layer type for opened layers
"""
if choose_plugin:
handle_gui_reading(
filenames, self, stack, plugin_override=choose_plugin, **kwargs
)
return
try:
self.viewer.open(
filenames,
stack=stack,
plugin=plugin,
layer_type=layer_type,
**kwargs,
)
except ReaderPluginError as e:
handle_gui_reading(
filenames,
self,
stack,
e.reader_plugin,
e,
layer_type=layer_type,
**kwargs,
)
except MultipleReaderError:
handle_gui_reading(filenames, self, stack, **kwargs)
def _toggle_chunk_outlines(self):
"""Toggle whether we are drawing outlines around the chunks."""
from napari.layers.image.experimental.octree_image import (
_OctreeImageBase,
)
for layer in self.viewer.layers:
if isinstance(layer, _OctreeImageBase):
layer.display.show_grid = not layer.display.show_grid
def _on_interactive(self):
"""Link interactive attributes of view and viewer."""
self.view.interactive = self.viewer.camera.interactive
def _on_cursor(self):
"""Set the appearance of the mouse cursor."""
cursor = self.viewer.cursor.style
if cursor in {'square', 'circle'}:
# Scale size by zoom if needed
size = self.viewer.cursor.size
if self.viewer.cursor.scaled:
size *= self.viewer.camera.zoom
size = int(size)
# make sure the square fits within the current canvas
if size < 8 or size > (min(*self.canvas.size) - 4):
q_cursor = self._cursors['cross']
elif cursor == 'circle':
q_cursor = QCursor(circle_pixmap(size))
else:
q_cursor = QCursor(square_pixmap(size))
elif cursor == 'crosshair':
q_cursor = QCursor(crosshair_pixmap())
else:
q_cursor = self._cursors[cursor]
self.canvas.native.setCursor(q_cursor)
def toggle_console_visibility(self, event=None):
"""Toggle console visible and not visible.
Imports the console the first time it is requested.
"""
if in_ipython() or in_jupyter():
return
# force instantiation of console if not already instantiated
_ = self.console
viz = not self.dockConsole.isVisible()
# modulate visibility at the dock widget level as console is dockable
self.dockConsole.setVisible(viz)
if self.dockConsole.isFloating():
self.dockConsole.setFloating(True)
if viz:
self.dockConsole.raise_()
self.dockConsole.setFocus()
self.viewerButtons.consoleButton.setProperty(
'expanded', self.dockConsole.isVisible()
)
self.viewerButtons.consoleButton.style().unpolish(
self.viewerButtons.consoleButton
)
self.viewerButtons.consoleButton.style().polish(
self.viewerButtons.consoleButton
)
def _map_canvas2world(self, position):
"""Map position from canvas pixels into world coordinates.
Parameters
----------
position : 2-tuple
Position in canvas (x, y).
Returns
-------
coords : tuple
Position in world coordinates, matches the total dimensionality
of the viewer.
"""
nd = self.viewer.dims.ndisplay
transform = self.view.scene.transform
mapped_position = transform.imap(list(position))[:nd]
position_world_slice = mapped_position[::-1]
# handle position for 3D views of 2D data
nd_point = len(self.viewer.dims.point)
if nd_point < nd:
position_world_slice = position_world_slice[-nd_point:]
position_world = list(self.viewer.dims.point)
for i, d in enumerate(self.viewer.dims.displayed):
position_world[d] = position_world_slice[i]
return tuple(position_world)
@property
def _canvas_corners_in_world(self):
"""Location of the corners of canvas in world coordinates.
Returns
-------
corners : 2-tuple
Coordinates of top left and bottom right canvas pixel in the world.
"""
# Find corners of canvas in world coordinates
top_left = self._map_canvas2world([0, 0])
bottom_right = self._map_canvas2world(self.canvas.size)
return np.array([top_left, bottom_right])
def on_resize(self, event):
"""Called whenever canvas is resized.
event : vispy.util.event.Event
The vispy event that triggered this method.
"""
self.viewer._canvas_size = tuple(self.canvas.size[::-1])
def _process_mouse_event(self, mouse_callbacks, event):
"""Add properties to the mouse event before passing the event to the
napari events system. Called whenever the mouse moves or is clicked.
As such, care should be taken to reduce the overhead in this function.
In future work, we should consider limiting the frequency at which
it is called.
This method adds following:
position: the position of the click in world coordinates.
view_direction: a unit vector giving the direction of the camera in
world coordinates.
up_direction: a unit vector giving the direction of the camera that is
up in world coordinates.
dims_displayed: a list of the dimensions currently being displayed
in the viewer. This comes from viewer.dims.displayed.
dims_point: the indices for the data in view in world coordinates.
This comes from viewer.dims.point
Parameters
----------
mouse_callbacks : function
Mouse callbacks function.
event : vispy.event.Event
The vispy event that triggered this method.
"""
if event.pos is None:
return
# Add the view ray to the event
event.view_direction = self.viewer.camera.calculate_nd_view_direction(
self.viewer.dims.ndim, self.viewer.dims.displayed
)
event.up_direction = self.viewer.camera.calculate_nd_up_direction(
self.viewer.dims.ndim, self.viewer.dims.displayed
)
# Update the cursor position
self.viewer.cursor._view_direction = event.view_direction
self.viewer.cursor.position = self._map_canvas2world(list(event.pos))
# Add the cursor position to the event
event.position = self.viewer.cursor.position
# Add the displayed dimensions to the event
event.dims_displayed = list(self.viewer.dims.displayed)
# Add the current dims indices
event.dims_point = list(self.viewer.dims.point)
# Put a read only wrapper on the event
event = ReadOnlyWrapper(event)
mouse_callbacks(self.viewer, event)
layer = self.viewer.layers.selection.active
if layer is not None:
mouse_callbacks(layer, event)
def on_mouse_wheel(self, event):
"""Called whenever mouse wheel activated in canvas.
Parameters
----------
event : vispy.event.Event
The vispy event that triggered this method.
"""
self._process_mouse_event(mouse_wheel_callbacks, event)
def on_mouse_double_click(self, event):
"""Called whenever a mouse double-click happen on the canvas
Parameters
----------
event : vispy.event.Event
The vispy event that triggered this method. The `event.type` will always be `mouse_double_click`
Notes
-----
Note that this triggers in addition to the usual mouse press and mouse release.
Therefore a double click from the user will likely triggers the following event in sequence:
- mouse_press
- mouse_release
- mouse_double_click
- mouse_release
"""
self._process_mouse_event(mouse_double_click_callbacks, event)
def on_mouse_press(self, event):
"""Called whenever mouse pressed in canvas.
Parameters
----------
event : vispy.event.Event
The vispy event that triggered this method.
"""
self._process_mouse_event(mouse_press_callbacks, event)
def on_mouse_move(self, event):
"""Called whenever mouse moves over canvas.
Parameters
----------
event : vispy.event.Event
The vispy event that triggered this method.
"""
self._process_mouse_event(mouse_move_callbacks, event)
def on_mouse_release(self, event):
"""Called whenever mouse released in canvas.
Parameters
----------
event : vispy.event.Event
The vispy event that triggered this method.
"""
self._process_mouse_event(mouse_release_callbacks, event)
def on_draw(self, event):
"""Called whenever the canvas is drawn.
This is triggered from vispy whenever new data is sent to the canvas or
the camera is moved and is connected in the `QtViewer`.
"""
# The canvas corners in full world coordinates (i.e. across all layers).
canvas_corners_world = self._canvas_corners_in_world
for layer in self.viewer.layers:
# The following condition should mostly be False. One case when it can
# be True is when a callback connected to self.viewer.dims.events.ndisplay
# is executed before layer._slice_input has been updated by another callback
# (e.g. when changing self.viewer.dims.ndisplay from 3 to 2).
displayed_sorted = sorted(layer._slice_input.displayed)
nd = len(displayed_sorted)
if nd > self.viewer.dims.ndisplay:
displayed_axes = displayed_sorted
else:
displayed_axes = self.viewer.dims.displayed[-nd:]
layer._update_draw(
scale_factor=1 / self.viewer.camera.zoom,
corner_pixels_displayed=canvas_corners_world[
:, displayed_axes
],
shape_threshold=self.canvas.size,
)
def set_welcome_visible(self, visible):
"""Show welcome screen widget."""
self._show_welcome_screen = visible
self._welcome_widget.set_welcome_visible(visible)
def keyPressEvent(self, event):
"""Called whenever a key is pressed.
Parameters
----------
event : qtpy.QtCore.QEvent
Event from the Qt context.
"""
self.canvas._backend._keyEvent(self.canvas.events.key_press, event)
event.accept()
def keyReleaseEvent(self, event):
"""Called whenever a key is released.
Parameters
----------
event : qtpy.QtCore.QEvent
Event from the Qt context.
"""
self.canvas._backend._keyEvent(self.canvas.events.key_release, event)
event.accept()
def dragEnterEvent(self, event):
"""Ignore event if not dragging & dropping a file or URL to open.
Using event.ignore() here allows the event to pass through the
parent widget to its child widget, otherwise the parent widget
would catch the event and not pass it on to the child widget.
Parameters
----------
event : qtpy.QtCore.QDragEvent
Event from the Qt context.
"""
if event.mimeData().hasUrls():
self._set_drag_status()
event.accept()
else:
event.ignore()
def _set_drag_status(self):
"""Set dedicated status message when dragging files into viewer"""
self.viewer.status = trans._(
'Hold key to open plugin selection. Hold to open files as stack.'
)
def dropEvent(self, event):
"""Add local files and web URLS with drag and drop.
For each file, attempt to open with existing associated reader
(if available). If no reader is associated or opening fails,
and more than one reader is available, open dialog and ask
user to choose among available readers. User can choose to persist
this choice.
Parameters
----------
event : qtpy.QtCore.QDropEvent
Event from the Qt context.
"""
shift_down = (
QGuiApplication.keyboardModifiers()
& Qt.KeyboardModifier.ShiftModifier
)
alt_down = (
QGuiApplication.keyboardModifiers()
& Qt.KeyboardModifier.AltModifier
)
filenames = []
for url in event.mimeData().urls():
if url.isLocalFile():
# directories get a trailing "/", Path conversion removes it
filenames.append(str(Path(url.toLocalFile())))
else:
filenames.append(url.toString())
self._qt_open(
filenames,
stack=bool(shift_down),
choose_plugin=bool(alt_down),
)
def closeEvent(self, event):
"""Cleanup and close.
Parameters
----------
event : qtpy.QtCore.QCloseEvent
Event from the Qt context.
"""
self.layers.close()
# if the viewer.QtDims object is playing an axis, we need to terminate
# the AnimationThread before close, otherwise it will cause a segFault
# or Abort trap. (calling stop() when no animation is occurring is also
# not a problem)
self.dims.stop()
self.canvas.native.deleteLater()
if self._console is not None:
self.console.close()
self.dockConsole.deleteLater()
event.accept()
if TYPE_CHECKING:
from napari._qt.experimental.qt_poll import QtPoll
from napari.components.experimental.remote import RemoteManager
def _create_qt_poll(parent: QObject, camera: Camera) -> Optional[QtPoll]:
"""Create and return a QtPoll instance, if needed.
Create a QtPoll instance for octree or monitor.
Octree needs QtPoll so VispyTiledImageLayer can finish in-progress
loads even if the camera is not moving. Once loading is finish it will
tell QtPoll it no longer needs to be polled.
Monitor needs QtPoll to poll for incoming messages. This might be
temporary until we can process incoming messages with a dedicated
thread.
Parameters
----------
parent : QObject
Parent Qt object.
camera : Camera
Camera that the QtPoll object will listen to.
Returns
-------
Optional[QtPoll]
The new QtPoll instance, if we need one.
"""
if not config.async_octree and not config.monitor:
return None
from napari._qt.experimental.qt_poll import QtPoll
qt_poll = QtPoll(parent)
camera.events.connect(qt_poll.on_camera)
return qt_poll
def _create_remote_manager(
layers: LayerList, qt_poll
) -> Optional[RemoteManager]:
"""Create and return a RemoteManager instance, if we need one.
Parameters
----------
layers : LayersList
The viewer's layers.
qt_poll : QtPoll
The viewer's QtPoll instance.
"""
if not config.monitor:
return None # Not using the monitor at all
from napari.components.experimental.monitor import monitor
from napari.components.experimental.remote import RemoteManager
# Start the monitor so we can access its events. The monitor has no
# dependencies to napari except to utils.Event.
started = monitor.start()
if not started:
return None # Probably not >= Python 3.9, so no manager is needed.
# Create the remote manager and have monitor call its process_command()
# method to execute commands from clients.
manager = RemoteManager(layers)
# RemoteManager will process incoming command from the monitor.
monitor.run_command_event.connect(manager.process_command)
# QtPoll should pool the RemoteManager and the Monitor.
qt_poll.events.poll.connect(manager.on_poll)
qt_poll.events.poll.connect(monitor.on_poll)
return manager
napari-0.5.0a1/napari/_qt/qthreading.py 0000664 0000000 0000000 00000031437 14370413656 0017766 0 ustar 00root root 0000000 0000000 import inspect
import warnings
from functools import partial, wraps
from types import FunctionType, GeneratorType
from typing import (
Callable,
Dict,
List,
Optional,
Sequence,
Type,
TypeVar,
Union,
)
from superqt.utils import _qthreading
from typing_extensions import ParamSpec
from napari.utils.progress import progress
from napari.utils.translations import trans
wait_for_workers_to_quit = _qthreading.WorkerBase.await_workers
class _NotifyingMixin:
def __init__(self: _qthreading.WorkerBase, *args, **kwargs) -> None: # type: ignore
super().__init__(*args, **kwargs) # type: ignore
self.errored.connect(self._relay_error)
self.warned.connect(self._relay_warning)
def _relay_error(self, exc: Exception):
from napari.utils.notifications import notification_manager
notification_manager.receive_error(type(exc), exc, exc.__traceback__)
def _relay_warning(self, show_warn_args: tuple):
from napari.utils.notifications import notification_manager
notification_manager.receive_warning(*show_warn_args)
_Y = TypeVar("_Y")
_S = TypeVar("_S")
_R = TypeVar("_R")
_P = ParamSpec("_P")
class FunctionWorker(_qthreading.FunctionWorker[_R], _NotifyingMixin):
...
class GeneratorWorker(
_qthreading.GeneratorWorker[_Y, _S, _R], _NotifyingMixin
):
...
# these are re-implemented from superqt just to provide progress
def create_worker(
func: Union[FunctionType, GeneratorType],
*args,
_start_thread: Optional[bool] = None,
_connect: Optional[Dict[str, Union[Callable, Sequence[Callable]]]] = None,
_progress: Optional[Union[bool, Dict[str, Union[int, bool, str]]]] = None,
_worker_class: Union[
Type[GeneratorWorker], Type[FunctionWorker], None
] = None,
_ignore_errors: bool = False,
**kwargs,
) -> Union[FunctionWorker, GeneratorWorker]:
"""Convenience function to start a function in another thread.
By default, uses :class:`Worker`, but a custom ``WorkerBase`` subclass may
be provided. If so, it must be a subclass of :class:`Worker`, which
defines a standard set of signals and a run method.
Parameters
----------
func : Callable
The function to call in another thread.
_start_thread : bool, optional
Whether to immediaetly start the thread. If False, the returned worker
must be manually started with ``worker.start()``. by default it will be
``False`` if the ``_connect`` argument is ``None``, otherwise ``True``.
_connect : Dict[str, Union[Callable, Sequence]], optional
A mapping of ``"signal_name"`` -> ``callable`` or list of ``callable``:
callback functions to connect to the various signals offered by the
worker class. by default None
_progress : Union[bool, Dict[str, Union[int, bool, str]]], optional
Can be True, to provide indeterminate progress bar, or dictionary.
If dict, requires mapping of 'total' to number of expected yields.
If total is not provided, progress bar will be indeterminate. Will connect
progress bar update to yields and display this progress in the viewer.
Can also take a mapping of 'desc' to the progress bar description.
Progress bar will become indeterminate when number of yields exceeds 'total'.
By default None.
_worker_class : Type[WorkerBase], optional
The :class`WorkerBase` to instantiate, by default
:class:`FunctionWorker` will be used if ``func`` is a regular function,
and :class:`GeneratorWorker` will be used if it is a generator.
_ignore_errors : bool, optional
If ``False`` (the default), errors raised in the other thread will be
reraised in the main thread (makes debugging significantly easier).
*args
will be passed to ``func``
**kwargs
will be passed to ``func``
Returns
-------
worker : WorkerBase
An instantiated worker. If ``_start_thread`` was ``False``, the worker
will have a `.start()` method that can be used to start the thread.
Raises
------
TypeError
If a worker_class is provided that is not a subclass of WorkerBase.
TypeError
If _connect is provided and is not a dict of ``{str: callable}``
TypeError
If _progress is provided and function is not a generator
Examples
--------
.. code-block:: python
def long_function(duration):
import time
time.sleep(duration)
worker = create_worker(long_function, 10)
"""
# provide our own classes with the notification mixins
if not _worker_class:
if inspect.isgeneratorfunction(func):
_worker_class = GeneratorWorker
else:
_worker_class = FunctionWorker
worker = _qthreading.create_worker(
func,
*args,
_start_thread=False,
_connect=_connect,
_worker_class=_worker_class,
_ignore_errors=_ignore_errors,
**kwargs,
)
# either True or a non-empty dictionary
if _progress:
if isinstance(_progress, bool):
_progress = {}
desc = _progress.get('desc', None)
total = int(_progress.get('total', 0))
if isinstance(worker, FunctionWorker) and total != 0:
warnings.warn(
trans._(
"_progress total != 0 but worker is FunctionWorker and will not yield. Returning indeterminate progress bar...",
deferred=True,
),
RuntimeWarning,
)
total = 0
with progress._all_instances.events.changed.blocker():
pbar = progress(total=total, desc=desc)
worker.started.connect(
partial(
lambda prog: progress._all_instances.events.changed(
added={prog}, removed={}
),
pbar,
)
)
worker.finished.connect(pbar.close)
if total != 0 and isinstance(worker, GeneratorWorker):
worker.yielded.connect(pbar.increment_with_overflow)
worker.pbar = pbar
if _start_thread is None:
_start_thread = _connect is not None
if _start_thread:
worker.start()
return worker
def thread_worker(
function: Optional[Callable] = None,
start_thread: Optional[bool] = None,
connect: Optional[Dict[str, Union[Callable, Sequence[Callable]]]] = None,
progress: Optional[Union[bool, Dict[str, Union[int, bool, str]]]] = None,
worker_class: Union[
Type[FunctionWorker], Type[GeneratorWorker], None
] = None,
ignore_errors: bool = False,
):
"""Decorator that runs a function in a separate thread when called.
When called, the decorated function returns a :class:`WorkerBase`. See
:func:`create_worker` for additional keyword arguments that can be used
when calling the function.
The returned worker will have these signals:
- *started*: emitted when the work is started
- *finished*: emitted when the work is finished
- *returned*: emitted with return value
- *errored*: emitted with error object on Exception
It will also have a ``worker.start()`` method that can be used to start
execution of the function in another thread. (useful if you need to connect
callbacks to signals prior to execution)
If the decorated function is a generator, the returned worker will also
provide these signals:
- *yielded*: emitted with yielded values
- *paused*: emitted when a running job has successfully paused
- *resumed*: emitted when a paused job has successfully resumed
- *aborted*: emitted when a running job is successfully aborted
And these methods:
- *quit*: ask the thread to quit
- *toggle_paused*: toggle the running state of the thread.
- *send*: send a value into the generator. (This requires that your
decorator function uses the ``value = yield`` syntax)
Parameters
----------
function : callable
Function to call in another thread. For communication between threads
may be a generator function.
start_thread : bool, optional
Whether to immediaetly start the thread. If False, the returned worker
must be manually started with ``worker.start()``. by default it will be
``False`` if the ``_connect`` argument is ``None``, otherwise ``True``.
connect : Dict[str, Union[Callable, Sequence]], optional
A mapping of ``"signal_name"`` -> ``callable`` or list of ``callable``:
callback functions to connect to the various signals offered by the
worker class. by default None
progress : Union[bool, Dict[str, Union[int, bool, str]]], optional
Can be True, to provide indeterminate progress bar, or dictionary.
If dict, requires mapping of 'total' to number of expected yields.
If total is not provided, progress bar will be indeterminate. Will connect
progress bar update to yields and display this progress in the viewer.
Can also take a mapping of 'desc' to the progress bar description.
Progress bar will become indeterminate when number of yields exceeds 'total'.
By default None. Must be used in conjunction with a generator function.
worker_class : Type[WorkerBase], optional
The :class`WorkerBase` to instantiate, by default
:class:`FunctionWorker` will be used if ``func`` is a regular function,
and :class:`GeneratorWorker` will be used if it is a generator.
ignore_errors : bool, optional
If ``False`` (the default), errors raised in the other thread will be
reraised in the main thread (makes debugging significantly easier).
Returns
-------
callable
function that creates a worker, puts it in a new thread and returns
the worker instance.
Examples
--------
.. code-block:: python
@thread_worker
def long_function(start, end):
# do work, periodically yielding
i = start
while i <= end:
time.sleep(0.1)
yield i
# do teardown
return 'anything'
# call the function to start running in another thread.
worker = long_function()
# connect signals here if desired... or they may be added using the
# `connect` argument in the `@thread_worker` decorator... in which
# case the worker will start immediately when long_function() is called
worker.start()
"""
def _inner(func):
@wraps(func)
def worker_function(*args, **kwargs):
# decorator kwargs can be overridden at call time by using the
# underscore-prefixed version of the kwarg.
kwargs['_start_thread'] = kwargs.get('_start_thread', start_thread)
kwargs['_connect'] = kwargs.get('_connect', connect)
kwargs['_progress'] = kwargs.get('_progress', progress)
kwargs['_worker_class'] = kwargs.get('_worker_class', worker_class)
kwargs['_ignore_errors'] = kwargs.get(
'_ignore_errors', ignore_errors
)
return create_worker(
func,
*args,
**kwargs,
)
return worker_function
return _inner if function is None else _inner(function)
_new_worker_qthread = _qthreading.new_worker_qthread
def _add_worker_data(worker: FunctionWorker, return_type, source=None):
from napari._app_model.injection import _processors
cb = _processors._add_layer_data_to_viewer
worker.signals.returned.connect(
partial(cb, return_type=return_type, source=source)
)
def _add_worker_data_from_tuple(
worker: FunctionWorker, return_type, source=None
):
from napari._app_model.injection import _processors
cb = _processors._add_layer_data_tuples_to_viewer
worker.signals.returned.connect(
partial(cb, return_type=return_type, source=source)
)
def register_threadworker_processors():
from functools import partial
import magicgui
from napari import layers, types
from napari._app_model import get_app
from napari.types import LayerDataTuple
from napari.utils import _magicgui as _mgui
app = get_app()
for _type in (LayerDataTuple, List[LayerDataTuple]):
t = FunctionWorker[_type]
magicgui.register_type(t, return_callback=_mgui.add_worker_data)
app.injection_store.register(
processors={t: _add_worker_data_from_tuple}
)
for layer_name in layers.NAMES:
_type = getattr(types, f'{layer_name.title()}Data')
t = FunctionWorker[_type]
magicgui.register_type(
t,
return_callback=partial(_mgui.add_worker_data, _from_tuple=False),
)
app.injection_store.register(processors={t: _add_worker_data})
napari-0.5.0a1/napari/_qt/utils.py 0000664 0000000 0000000 00000035120 14370413656 0016771 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import re
import signal
import socket
import weakref
from contextlib import contextmanager
from functools import lru_cache, partial
from typing import Iterable, Sequence, Union
import numpy as np
import qtpy
from qtpy.QtCore import (
QByteArray,
QCoreApplication,
QPoint,
QPropertyAnimation,
QSize,
QSocketNotifier,
Qt,
QThread,
)
from qtpy.QtGui import QColor, QCursor, QDrag, QImage, QPainter, QPen, QPixmap
from qtpy.QtWidgets import (
QGraphicsColorizeEffect,
QGraphicsOpacityEffect,
QHBoxLayout,
QListWidget,
QVBoxLayout,
QWidget,
)
from napari.utils.colormaps.standardize_color import transform_color
from napari.utils.events.custom_types import Array
from napari.utils.misc import is_sequence
from napari.utils.translations import trans
QBYTE_FLAG = "!QBYTE_"
RICH_TEXT_PATTERN = re.compile("<[^\n]+>")
def is_qbyte(string: str) -> bool:
"""Check if a string is a QByteArray string.
Parameters
----------
string : bool
State string.
"""
return isinstance(string, str) and string.startswith(QBYTE_FLAG)
def qbytearray_to_str(qbyte: QByteArray) -> str:
"""Convert a window state to a string.
Used for restoring the state of the main window.
Parameters
----------
qbyte : QByteArray
State array.
"""
return QBYTE_FLAG + qbyte.toBase64().data().decode()
def str_to_qbytearray(string: str) -> QByteArray:
"""Convert a string to a QbyteArray.
Used for restoring the state of the main window.
Parameters
----------
string : str
State string.
"""
if len(string) < len(QBYTE_FLAG) or not is_qbyte(string):
raise ValueError(
trans._(
"Invalid QByte string. QByte strings start with '{QBYTE_FLAG}'",
QBYTE_FLAG=QBYTE_FLAG,
)
)
return QByteArray.fromBase64(string[len(QBYTE_FLAG) :].encode())
def QImg2array(img) -> np.ndarray:
"""Convert QImage to an array.
Parameters
----------
img : qtpy.QtGui.QImage
QImage to be converted.
Returns
-------
arr : array
Numpy array of type ubyte and shape (h, w, 4). Index [0, 0] is the
upper-left corner of the rendered region.
"""
# Fix when image is provided in wrong format (ex. test on Azure pipelines)
if img.format() != QImage.Format_ARGB32:
img = img.convertToFormat(QImage.Format_ARGB32)
b = img.constBits()
h, w, c = img.height(), img.width(), 4
# As vispy doesn't use qtpy we need to reconcile the differences
# between the `QImage` API for `PySide2` and `PyQt5` on how to convert
# a QImage to a numpy array.
if qtpy.API_NAME.startswith('PySide'):
arr = np.array(b).reshape(h, w, c)
else:
b.setsize(h * w * c)
arr = np.frombuffer(b, np.uint8).reshape(h, w, c)
# Format of QImage is ARGB32_Premultiplied, but color channels are
# reversed.
arr = arr[:, :, [2, 1, 0, 3]]
return arr
@contextmanager
def qt_signals_blocked(obj):
"""Context manager to temporarily block signals from `obj`"""
previous = obj.blockSignals(True)
try:
yield
finally:
obj.blockSignals(previous)
@contextmanager
def event_hook_removed():
"""Context manager to temporarily remove the PyQt5 input hook"""
from qtpy import QtCore
if hasattr(QtCore, 'pyqtRemoveInputHook'):
QtCore.pyqtRemoveInputHook()
try:
yield
finally:
if hasattr(QtCore, 'pyqtRestoreInputHook'):
QtCore.pyqtRestoreInputHook()
def set_widgets_enabled_with_opacity(
parent: QWidget, widgets: Iterable[QWidget], enabled: bool
):
"""Set enabled state on some widgets. If not enabled, decrease opacity."""
for widget in widgets:
widget.setEnabled(enabled)
op = QGraphicsOpacityEffect(parent)
op.setOpacity(1 if enabled else 0.5)
widget.setGraphicsEffect(op)
@lru_cache(maxsize=64)
def square_pixmap(size):
"""Create a white/black hollow square pixmap. For use as labels cursor."""
size = max(int(size), 1)
pixmap = QPixmap(QSize(size, size))
pixmap.fill(Qt.GlobalColor.transparent)
painter = QPainter(pixmap)
painter.setPen(Qt.GlobalColor.white)
painter.drawRect(0, 0, size - 1, size - 1)
painter.setPen(Qt.GlobalColor.black)
painter.drawRect(1, 1, size - 3, size - 3)
painter.end()
return pixmap
@lru_cache(maxsize=64)
def crosshair_pixmap():
"""Create a cross cursor with white/black hollow square pixmap in the middle.
For use as points cursor."""
size = 25
pixmap = QPixmap(QSize(size, size))
pixmap.fill(Qt.GlobalColor.transparent)
painter = QPainter(pixmap)
# Base measures
width = 1
center = 3 # Must be odd!
rect_size = center + 2 * width
square = rect_size + width * 4
pen = QPen(Qt.GlobalColor.white, 1)
pen.setJoinStyle(Qt.PenJoinStyle.MiterJoin)
painter.setPen(pen)
# # Horizontal rectangle
painter.drawRect(0, (size - rect_size) // 2, size - 1, rect_size - 1)
# Vertical rectangle
painter.drawRect((size - rect_size) // 2, 0, rect_size - 1, size - 1)
# Square
painter.drawRect(
(size - square) // 2, (size - square) // 2, square - 1, square - 1
)
pen = QPen(Qt.GlobalColor.black, 2)
pen.setJoinStyle(Qt.PenJoinStyle.MiterJoin)
painter.setPen(pen)
# # Square
painter.drawRect(
(size - square) // 2 + 2,
(size - square) // 2 + 2,
square - 4,
square - 4,
)
pen = QPen(Qt.GlobalColor.black, 3)
pen.setJoinStyle(Qt.PenJoinStyle.MiterJoin)
painter.setPen(pen)
# # # Horizontal lines
mid_vpoint = QPoint(2, size // 2)
painter.drawLine(
mid_vpoint, QPoint(((size - center) // 2) - center + 1, size // 2)
)
mid_vpoint = QPoint(size - 3, size // 2)
painter.drawLine(
mid_vpoint, QPoint(((size - center) // 2) + center + 1, size // 2)
)
# # # Vertical lines
mid_hpoint = QPoint(size // 2, 2)
painter.drawLine(
QPoint(size // 2, ((size - center) // 2) - center + 1), mid_hpoint
)
mid_hpoint = QPoint(size // 2, size - 3)
painter.drawLine(
QPoint(size // 2, ((size - center) // 2) + center + 1), mid_hpoint
)
painter.end()
return pixmap
@lru_cache(maxsize=64)
def circle_pixmap(size: int):
"""Create a white/black hollow circle pixmap. For use as labels cursor."""
size = max(size, 1)
pixmap = QPixmap(QSize(size, size))
pixmap.fill(Qt.GlobalColor.transparent)
painter = QPainter(pixmap)
painter.setPen(Qt.GlobalColor.white)
painter.drawEllipse(0, 0, size - 1, size - 1)
painter.setPen(Qt.GlobalColor.black)
painter.drawEllipse(1, 1, size - 3, size - 3)
painter.end()
return pixmap
def drag_with_pixmap(list_widget: QListWidget) -> QDrag:
"""Create a QDrag object with a pixmap of the currently select list item.
This method is useful when you have a QListWidget that displays custom
widgets for each QListWidgetItem instance in the list (usually by calling
``QListWidget.setItemWidget(item, widget)``). When used in a
``QListWidget.startDrag`` method, this function creates a QDrag object that
shows an image of the item being dragged (rather than an empty rectangle).
Parameters
----------
list_widget : QListWidget
The QListWidget for which to create a QDrag object.
Returns
-------
QDrag
A QDrag instance with a pixmap of the currently selected item.
Examples
--------
>>> class QListWidget:
... def startDrag(self, supportedActions):
... drag = drag_with_pixmap(self)
... drag.exec_(supportedActions, Qt.MoveAction)
"""
drag = QDrag(list_widget)
drag.setMimeData(list_widget.mimeData(list_widget.selectedItems()))
size = list_widget.viewport().visibleRegion().boundingRect().size()
pixmap = QPixmap(size)
pixmap.fill(Qt.GlobalColor.transparent)
painter = QPainter(pixmap)
for index in list_widget.selectedIndexes():
rect = list_widget.visualRect(index)
painter.drawPixmap(rect, list_widget.viewport().grab(rect))
painter.end()
drag.setPixmap(pixmap)
drag.setHotSpot(list_widget.viewport().mapFromGlobal(QCursor.pos()))
return drag
def combine_widgets(
widgets: Union[QWidget, Sequence[QWidget]], vertical: bool = False
) -> QWidget:
"""Combine a list of widgets into a single QWidget with Layout.
Parameters
----------
widgets : QWidget or sequence of QWidget
A widget or a list of widgets to combine.
vertical : bool, optional
Whether the layout should be QVBoxLayout or not, by default
QHBoxLayout is used
Returns
-------
QWidget
If ``widgets`` is a sequence, returns combined QWidget with `.layout`
property, otherwise returns the original widget.
Raises
------
TypeError
If ``widgets`` is neither a ``QWidget`` or a sequence of ``QWidgets``.
"""
if isinstance(getattr(widgets, 'native', None), QWidget):
# compatibility with magicgui v0.2.0 which no longer uses QWidgets
# directly. Like vispy, the backend widget is at widget.native
return widgets.native # type: ignore
elif isinstance(widgets, QWidget):
return widgets
elif is_sequence(widgets):
# the same as above, compatibility with magicgui v0.2.0
widgets = [
i.native if isinstance(getattr(i, 'native', None), QWidget) else i
for i in widgets
]
if all(isinstance(i, QWidget) for i in widgets):
container = QWidget()
container.setLayout(QVBoxLayout() if vertical else QHBoxLayout())
for widget in widgets:
container.layout().addWidget(widget)
return container
raise TypeError(
trans._('"widget" must be a QWidget or a sequence of QWidgets')
)
def add_flash_animation(
widget: QWidget, duration: int = 300, color: Array = (0.5, 0.5, 0.5, 0.5)
):
"""Add flash animation to widget to highlight certain action (e.g. taking a screenshot).
Parameters
----------
widget : QWidget
Any Qt widget.
duration : int
Duration of the flash animation.
color : Array
Color of the flash animation. By default, we use light gray.
"""
color = transform_color(color)[0]
color = (255 * color).astype("int")
effect = QGraphicsColorizeEffect(widget)
widget.setGraphicsEffect(effect)
widget._flash_animation = QPropertyAnimation(effect, b"color")
widget._flash_animation.setStartValue(QColor(0, 0, 0, 0))
widget._flash_animation.setEndValue(QColor(0, 0, 0, 0))
widget._flash_animation.setLoopCount(1)
# let's make sure to remove the animation from the widget because
# if we don't, the widget will actually be black and white.
widget._flash_animation.finished.connect(
partial(remove_flash_animation, weakref.ref(widget))
)
widget._flash_animation.start()
# now set an actual time for the flashing and an intermediate color
widget._flash_animation.setDuration(duration)
widget._flash_animation.setKeyValueAt(0.1, QColor(*color))
def remove_flash_animation(widget_ref: weakref.ref[QWidget]):
"""Remove flash animation from widget.
Parameters
----------
widget_ref : QWidget
Any Qt widget.
"""
if widget_ref() is None:
return
widget = widget_ref()
try:
widget.setGraphicsEffect(None)
del widget._flash_animation
except RuntimeError:
# RuntimeError: wrapped C/C++ object of type QtWidgetOverlay deleted
pass
@contextmanager
def _maybe_allow_interrupt(qapp):
"""
This manager allows to terminate a plot by sending a SIGINT. It is
necessary because the running Qt backend prevents Python interpreter to
run and process signals (i.e., to raise KeyboardInterrupt exception). To
solve this one needs to somehow wake up the interpreter and make it close
the plot window. We do this by using the signal.set_wakeup_fd() function
which organizes a write of the signal number into a socketpair connected
to the QSocketNotifier (since it is part of the Qt backend, it can react
to that write event). Afterwards, the Qt handler empties the socketpair
by a recv() command to re-arm it (we need this if a signal different from
SIGINT was caught by set_wakeup_fd() and we shall continue waiting). If
the SIGINT was caught indeed, after exiting the on_signal() function the
interpreter reacts to the SIGINT according to the handle() function which
had been set up by a signal.signal() call: it causes the qt_object to
exit by calling its quit() method. Finally, we call the old SIGINT
handler with the same arguments that were given to our custom handle()
handler.
We do this only if the old handler for SIGINT was not None, which means
that a non-python handler was installed, i.e. in Julia, and not SIG_IGN
which means we should ignore the interrupts.
code from https://github.com/matplotlib/matplotlib/pull/13306
"""
old_sigint_handler = signal.getsignal(signal.SIGINT)
handler_args = None
if old_sigint_handler in (None, signal.SIG_IGN, signal.SIG_DFL):
yield
return
wsock, rsock = socket.socketpair()
wsock.setblocking(False)
old_wakeup_fd = signal.set_wakeup_fd(wsock.fileno())
sn = QSocketNotifier(rsock.fileno(), QSocketNotifier.Type.Read)
# Clear the socket to re-arm the notifier.
sn.activated.connect(lambda *args: rsock.recv(1))
def handle(*args):
nonlocal handler_args
handler_args = args
qapp.exit()
signal.signal(signal.SIGINT, handle)
try:
yield
finally:
wsock.close()
rsock.close()
sn.setEnabled(False)
signal.set_wakeup_fd(old_wakeup_fd)
signal.signal(signal.SIGINT, old_sigint_handler)
if handler_args is not None:
old_sigint_handler(*handler_args)
def qt_might_be_rich_text(text) -> bool:
"""
Check if a text might be rich text in a cross-binding compatible way.
"""
if qtpy.PYSIDE2:
from qtpy.QtGui import Qt as Qt_
else:
from qtpy.QtCore import Qt as Qt_
try:
return Qt_.mightBeRichText(text)
except AttributeError:
return bool(RICH_TEXT_PATTERN.search(text))
def in_qt_main_thread():
"""
Check if we are in the thread in which QApplication object was created.
Returns
-------
thread_flag : bool
True if we are in the main thread, False otherwise.
"""
return QCoreApplication.instance().thread() == QThread.currentThread()
napari-0.5.0a1/napari/_qt/widgets/ 0000775 0000000 0000000 00000000000 14370413656 0016724 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/widgets/__init__.py 0000664 0000000 0000000 00000000060 14370413656 0021031 0 ustar 00root root 0000000 0000000 """Custom widgets that inherit from QWidget."""
napari-0.5.0a1/napari/_qt/widgets/_slider_compat.py 0000664 0000000 0000000 00000000630 14370413656 0022261 0 ustar 00root root 0000000 0000000 from qtpy import QT_VERSION
from qtpy.QtWidgets import QSlider # noqa
from superqt import QDoubleSlider
# here until we can debug why labeled sliders render differently on 5.12
if tuple(int(x) for x in QT_VERSION.split(".")) >= (5, 14):
from superqt import QLabeledDoubleSlider as QDoubleSlider # noqa
from superqt import QLabeledSlider as QSlider # noqa
__all__ = ["QSlider", "QDoubleSlider"]
napari-0.5.0a1/napari/_qt/widgets/_tests/ 0000775 0000000 0000000 00000000000 14370413656 0020225 5 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/widgets/_tests/__init__.py 0000664 0000000 0000000 00000000000 14370413656 0022324 0 ustar 00root root 0000000 0000000 napari-0.5.0a1/napari/_qt/widgets/_tests/test_qt_buttons.py 0000664 0000000 0000000 00000002460 14370413656 0024042 0 ustar 00root root 0000000 0000000 from napari._qt.widgets.qt_mode_buttons import (
QtModePushButton,
QtModeRadioButton,
)
from napari.layers import Points
from napari.layers.points._points_constants import Mode
def test_radio_button(qtbot):
"""Make sure the QtModeRadioButton works to change layer modes"""
layer = Points()
assert layer.mode != Mode.ADD
btn = QtModeRadioButton(layer, 'test_button', Mode.ADD, tooltip='tooltip')
assert btn.property('mode') == 'test_button'
assert btn.toolTip() == 'tooltip'
btn.click()
qtbot.waitUntil(lambda: layer.mode == Mode.ADD, timeout=500)
def test_push_button(qtbot):
"""Make sure the QtModePushButton works with callbacks"""
layer = Points()
layer.test_prop = False
def set_test_prop():
layer.test_prop = True
btn = QtModePushButton(
layer, 'test_button', slot=set_test_prop, tooltip='tooltip'
)
assert btn.property('mode') == 'test_button'
assert btn.toolTip() == 'tooltip'
btn.click()
qtbot.waitUntil(lambda: layer.test_prop, timeout=500)
def test_layers_button_works(make_napari_viewer):
v = make_napari_viewer()
layer = v.add_layer(Points())
assert layer.mode != "add"
controls = v.window._qt_viewer.controls.widgets[layer]
controls.addition_button.click()
assert layer.mode == "add"
napari-0.5.0a1/napari/_qt/widgets/_tests/test_qt_color_swatch.py 0000664 0000000 0000000 00000002123 14370413656 0025027 0 ustar 00root root 0000000 0000000 import numpy
import pytest
from napari._qt.widgets.qt_color_swatch import (
TRANSPARENT,
QColorSwatch,
QColorSwatchEdit,
)
@pytest.mark.parametrize('color', [None, [1, 1, 1, 1]])
@pytest.mark.parametrize('tooltip', [None, 'This is a test'])
def test_succesfull_create_qcolorswatchedit(qtbot, color, tooltip):
widget = QColorSwatchEdit(initial_color=color, tooltip=tooltip)
qtbot.add_widget(widget)
test_color = color or TRANSPARENT
test_tooltip = tooltip or 'click to set color'
assert widget.color_swatch.toolTip() == test_tooltip
numpy.testing.assert_array_equal(widget.color, test_color)
@pytest.mark.parametrize('color', [None, [1, 1, 1, 1]])
@pytest.mark.parametrize('tooltip', [None, 'This is a test'])
def test_succesfull_create_qcolorswatch(qtbot, color, tooltip):
widget = QColorSwatch(initial_color=color, tooltip=tooltip)
qtbot.add_widget(widget)
test_color = color or TRANSPARENT
test_tooltip = tooltip or 'click to set color'
assert widget.toolTip() == test_tooltip
numpy.testing.assert_array_equal(widget.color, test_color)
napari-0.5.0a1/napari/_qt/widgets/_tests/test_qt_dims.py 0000664 0000000 0000000 00000025250 14370413656 0023302 0 ustar 00root root 0000000 0000000 import os
from sys import platform
from unittest.mock import patch
import numpy as np
import pytest
from qtpy.QtCore import Qt
from napari._qt.widgets.qt_dims import QtDims
from napari.components import Dims
def test_creating_view(qtbot):
"""
Test creating dims view.
"""
ndim = 4
dims = Dims(ndim=ndim)
view = QtDims(dims)
qtbot.addWidget(view)
# Check that the dims model has been appended to the dims view
assert view.dims == dims
# Check the number of displayed sliders is two less than the number of
# dimensions
assert view.nsliders == view.dims.ndim
assert np.sum(view._displayed_sliders) == view.dims.ndim - 2
assert np.all(
[
s.isVisibleTo(view) == d
for s, d in zip(view.slider_widgets, view._displayed_sliders)
]
)
def test_changing_ndim(qtbot):
"""
Test changing the number of dimensions
"""
ndim = 4
view = QtDims(Dims(ndim=ndim))
qtbot.addWidget(view)
# Check that adding dimensions adds sliders
view.dims.ndim = 5
assert view.nsliders == view.dims.ndim
assert np.sum(view._displayed_sliders) == view.dims.ndim - 2
assert np.all(
[
s.isVisibleTo(view) == d
for s, d in zip(view.slider_widgets, view._displayed_sliders)
]
)
# Check that removing dimensions removes sliders
view.dims.ndim = 2
assert view.nsliders == view.dims.ndim
assert np.sum(view._displayed_sliders) == view.dims.ndim - 2
assert np.all(
[
s.isVisibleTo(view) == d
for s, d in zip(view.slider_widgets, view._displayed_sliders)
]
)
def test_changing_focus(qtbot):
"""Test changing focus updates the dims.last_used prop."""
# Initialize to 0th axis
ndim = 2
view = QtDims(Dims(ndim=ndim))
qtbot.addWidget(view)
assert view.dims.last_used == 0
view.dims._focus_down()
view.dims._focus_up()
assert view.dims.last_used == 0
view.dims.ndim = 5
view.dims.last_used = 2
assert view.dims.last_used == 2
view.dims._focus_down()
assert view.dims.last_used == 1
view.dims._focus_up()
assert view.dims.last_used == 2
view.dims._focus_up()
assert view.dims.last_used == 0
view.dims._focus_down()
assert view.dims.last_used == 2
def test_changing_display(qtbot):
"""
Test changing the displayed property of an axis
"""
ndim = 4
view = QtDims(Dims(ndim=ndim))
qtbot.addWidget(view)
assert view.nsliders == view.dims.ndim
assert np.sum(view._displayed_sliders) == view.dims.ndim - 2
assert np.all(
[
s.isVisibleTo(view) == d
for s, d in zip(view.slider_widgets, view._displayed_sliders)
]
)
# Check changing displayed removes a slider
view.dims.ndisplay = 3
assert view.nsliders == view.dims.ndim
assert np.sum(view._displayed_sliders) == view.dims.ndim - 3
assert np.all(
[
s.isVisibleTo(view) == d
for s, d in zip(view.slider_widgets, view._displayed_sliders)
]
)
def test_slider_values(qtbot):
"""
Test the values of a slider stays matched to the values of the dims point.
"""
ndim = 4
view = QtDims(Dims(ndim=ndim))
qtbot.addWidget(view)
# Check that values of the dimension slider matches the values of the
# dims point at initialization
first_slider = view.slider_widgets[0].slider
assert first_slider.value() == view.dims.point[0]
# Check that values of the dimension slider matches the values of the
# dims point after the point has been moved within the dims
view.dims.set_point(0, 2)
assert first_slider.value() == view.dims.point[0]
# Check that values of the dimension slider matches the values of the
# dims point after the point has been moved within the slider
first_slider.setValue(1)
assert first_slider.value() == view.dims.point[0]
def test_slider_range(qtbot):
"""
Tests range of the slider is matched to the range of the dims
"""
ndim = 4
view = QtDims(Dims(ndim=ndim))
qtbot.addWidget(view)
# Check the maximum allowed value of the slider is one less
# than the allowed nsteps of the dims at initialization
first_slider = view.slider_widgets[0].slider
assert first_slider.minimum() == 0
assert first_slider.maximum() == view.dims.nsteps[0] - 1
assert first_slider.singleStep() == 1
# Check the maximum allowed value of the slider stays one less
# than the allowed nsteps of the dims after updates
view.dims.set_range(0, (1, 5, 2))
assert first_slider.minimum() == 0
assert first_slider.maximum() == view.dims.nsteps[0] - 1
assert first_slider.singleStep() == 1
def test_singleton_dims(qtbot):
"""
Test singleton dims causes no slider.
"""
ndim = 4
dims = Dims(ndim=ndim)
dims.set_range(0, (0, 1, 1))
view = QtDims(dims)
qtbot.addWidget(view)
# Check that the dims model has been appended to the dims view
assert view.dims == dims
# Check the number of displayed sliders is only one
assert view.nsliders == 4
assert np.sum(view._displayed_sliders) == 1
assert np.all(
[
s.isVisibleTo(view) == d
for s, d in zip(view.slider_widgets, view._displayed_sliders)
]
)
# Change ndisplay to three
view.dims.ndisplay = 3
# Check no sliders now shown
assert np.sum(view._displayed_sliders) == 0
# Change ndisplay back to two
view.dims.ndisplay = 2
# Check only slider now shown
assert np.sum(view._displayed_sliders) == 1
def test_order_when_changing_ndim(qtbot):
"""
Test order of the sliders when changing the number of dimensions.
"""
ndim = 4
view = QtDims(Dims(ndim=ndim))
qtbot.addWidget(view)
# Check that values of the dimension slider matches the values of the
# dims point after the point has been moved within the dims
view.dims.set_point(0, 2)
view.dims.set_point(1, 1)
for i in range(view.dims.ndim - 2):
slider = view.slider_widgets[i].slider
assert slider.value() == view.dims.point[i]
# Check the matching dimensions and sliders are preserved when
# dimensions are added
view.dims.ndim = 5
for i in range(view.dims.ndim - 2):
slider = view.slider_widgets[i].slider
assert slider.value() == view.dims.point[i]
# Check the matching dimensions and sliders are preserved when dims
# dimensions are removed
view.dims.ndim = 4
for i in range(view.dims.ndim - 2):
slider = view.slider_widgets[i].slider
assert slider.value() == view.dims.point[i]
# Check the matching dimensions and sliders are preserved when dims
# dimensions are removed
view.dims.ndim = 3
for i in range(view.dims.ndim - 2):
slider = view.slider_widgets[i].slider
assert slider.value() == view.dims.point[i]
def test_update_dims_labels(qtbot):
"""
Test that the slider_widget axis labels are updated with the dims model
and vice versa.
"""
ndim = 4
view = QtDims(Dims(ndim=ndim))
qtbot.addWidget(view)
view.dims.axis_labels = list('TZYX')
assert [w.axis_label.text() for w in view.slider_widgets] == list('TZYX')
first_label = view.slider_widgets[0].axis_label
assert first_label.text() == view.dims.axis_labels[0]
first_label.setText('napari')
# first_label.editingFinished.emit()
assert first_label.text() == view.dims.axis_labels[0]
def test_slider_press_updates_last_used(qtbot):
"""pressing on the slider should update the dims.last_used property"""
ndim = 5
view = QtDims(Dims(ndim=ndim))
qtbot.addWidget(view)
for i, widg in enumerate(view.slider_widgets):
widg.slider.sliderPressed.emit()
assert view.dims.last_used == i
@pytest.mark.skipif(
os.environ.get('CI') and platform == 'win32',
reason='not working in windows VM',
)
def test_play_button(qtbot):
"""test that the play button and its popup dialog work"""
ndim = 3
view = QtDims(Dims(ndim=ndim))
qtbot.addWidget(view)
slider = view.slider_widgets[0]
button = slider.play_button
# Need looping playback so that it does not stop before we can assert that.
assert slider.loop_mode == 'loop'
assert not view.is_playing
qtbot.mouseClick(button, Qt.LeftButton)
qtbot.waitUntil(lambda: view.is_playing)
qtbot.mouseClick(button, Qt.LeftButton)
qtbot.waitUntil(lambda: not view.is_playing)
qtbot.waitUntil(lambda: view._animation_worker is None)
with patch.object(button.popup, 'show_above_mouse') as mock_popup:
qtbot.mouseClick(button, Qt.RightButton)
mock_popup.assert_called_once()
def test_slice_labels(qtbot):
ndim = 4
dims = Dims(ndim=ndim)
dims.set_range(0, (0, 20, 1))
view = QtDims(dims)
qtbot.addWidget(view)
# make sure the totslice_label is showing the correct number
assert int(view.slider_widgets[0].totslice_label.text()) == 19
# make sure setting the dims.point updates the slice label
label_edit = view.slider_widgets[0].curslice_label
dims.set_point(0, 15)
assert int(label_edit.text()) == 15
# make sure setting the current slice label updates the model
label_edit.setText(str(8))
label_edit.editingFinished.emit()
assert dims.point[0] == 8
def test_not_playing_after_ndim_changes(qtbot):
"""See https://github.com/napari/napari/issues/3998"""
dims = Dims(ndim=3, ndisplay=2, range=((0, 10, 1), (0, 20, 1), (0, 30, 1)))
view = QtDims(dims)
qtbot.addWidget(view)
# Loop to prevent finishing before the assertions in this test.
view.play(loop_mode='loop')
qtbot.waitUntil(lambda: view.is_playing)
dims.ndim = 2
qtbot.waitUntil(lambda: not view.is_playing)
qtbot.waitUntil(lambda: view._animation_worker is None)
def test_not_playing_after_ndisplay_changes(qtbot):
"""See https://github.com/napari/napari/issues/3998"""
dims = Dims(ndim=3, ndisplay=2, range=((0, 10, 1), (0, 20, 1), (0, 30, 1)))
view = QtDims(dims)
qtbot.addWidget(view)
# Loop to prevent finishing before the assertions in this test.
view.play(loop_mode='loop')
qtbot.waitUntil(lambda: view.is_playing)
dims.ndisplay = 3
qtbot.waitUntil(lambda: not view.is_playing)
qtbot.waitUntil(lambda: view._animation_worker is None)
def test_set_axis_labels_after_ndim_changes(qtbot):
"""See https://github.com/napari/napari/issues/3753"""
dims = Dims(ndim=3, ndisplay=2)
view = QtDims(dims)
qtbot.addWidget(view)
dims.ndim = 2
dims.axis_labels = ['y', 'x']
assert len(view.slider_widgets) == 2
assert view.slider_widgets[0].axis_label.text() == 'y'
assert view.slider_widgets[1].axis_label.text() == 'x'
napari-0.5.0a1/napari/_qt/widgets/_tests/test_qt_dims_sorter.py 0000664 0000000 0000000 00000001401 14370413656 0024670 0 ustar 00root root 0000000 0000000 from napari._qt.widgets.qt_dims_sorter import QtDimsSorter
from napari.components.viewer_model import ViewerModel
def test_dims_sorter(qtbot):
viewer = ViewerModel()
dim_sorter = QtDimsSorter(viewer)
qtbot.addWidget(dim_sorter)
assert tuple(dim_sorter.axes_list) == (0, 1)
viewer.dims.axis_labels = ('y', 'x')
assert tuple(dim_sorter.axes_list) == ('y', 'x')
dim_sorter.axes_list.move(1, 0)
assert tuple(dim_sorter.axes_list) == ('x', 'y')
assert tuple(viewer.dims.order) == (1, 0)
def test_dims_sorter_with_reordered_init(qtbot):
viewer = ViewerModel()
viewer.dims.order = (1, 0)
dim_sorter = QtDimsSorter(viewer)
qtbot.addWidget(dim_sorter)
assert tuple(dim_sorter.axes_list) == tuple(viewer.dims.order)
napari-0.5.0a1/napari/_qt/widgets/_tests/test_qt_dock_widget.py 0000664 0000000 0000000 00000011505 14370413656 0024627 0 ustar 00root root 0000000 0000000 import pytest
from qtpy.QtWidgets import (
QDockWidget,
QHBoxLayout,
QPushButton,
QTextEdit,
QVBoxLayout,
QWidget,
)
def test_add_dock_widget(make_napari_viewer):
"""Test basic add_dock_widget functionality"""
viewer = make_napari_viewer()
widg = QPushButton('button')
dwidg = viewer.window.add_dock_widget(widg, name='test', area='bottom')
assert not dwidg.is_vertical
assert viewer.window._qt_window.findChild(QDockWidget, 'test')
assert dwidg.widget() == widg
dwidg._on_visibility_changed(True) # smoke test
widg2 = QPushButton('button')
dwidg2 = viewer.window.add_dock_widget(widg2, name='test2', area='right')
assert dwidg2.is_vertical
assert viewer.window._qt_window.findChild(QDockWidget, 'test2')
assert dwidg2.widget() == widg2
dwidg2._on_visibility_changed(True) # smoke test
with pytest.raises(ValueError):
# 'under' is not a valid area
viewer.window.add_dock_widget(widg2, name='test2', area='under')
with pytest.raises(ValueError):
# 'under' is not a valid area
viewer.window.add_dock_widget(
widg2, name='test2', allowed_areas=['under']
)
with pytest.raises(TypeError):
# allowed_areas must be a list
viewer.window.add_dock_widget(
widg2, name='test2', allowed_areas='under'
)
def test_add_dock_widget_from_list(make_napari_viewer):
"""Test that we can add a list of widgets and they will be combined"""
viewer = make_napari_viewer()
widg = QPushButton('button')
widg2 = QPushButton('button')
dwidg = viewer.window.add_dock_widget(
[widg, widg2], name='test', area='right'
)
assert viewer.window._qt_window.findChild(QDockWidget, 'test')
assert isinstance(dwidg.widget().layout(), QVBoxLayout)
dwidg = viewer.window.add_dock_widget(
[widg, widg2], name='test2', area='bottom'
)
assert viewer.window._qt_window.findChild(QDockWidget, 'test2')
assert isinstance(dwidg.widget().layout(), QHBoxLayout)
def test_add_dock_widget_raises(make_napari_viewer):
"""Test that the widget passed must be a DockWidget."""
viewer = make_napari_viewer()
widg = object()
with pytest.raises(TypeError):
viewer.window.add_dock_widget(widg, name='test')
def test_remove_dock_widget_orphans_widget(make_napari_viewer):
viewer = make_napari_viewer()
widg = QPushButton('button')
assert not widg.parent()
dw = viewer.window.add_dock_widget(
widg, name='test', menu=viewer.window.window_menu
)
assert widg.parent() is dw
assert dw.toggleViewAction() in viewer.window.window_menu.actions()
viewer.window.remove_dock_widget(dw, menu=viewer.window.window_menu)
assert dw.toggleViewAction() not in viewer.window.window_menu.actions()
del dw
# if dw didn't release widg, we'd get an exception when next accessing widg
assert not widg.parent()
def test_remove_dock_widget_by_widget_reference(make_napari_viewer):
viewer = make_napari_viewer()
widg = QPushButton('button')
dw = viewer.window.add_dock_widget(widg, name='test')
assert widg.parent() is dw
assert dw in viewer.window._qt_window.findChildren(QDockWidget)
viewer.window.remove_dock_widget(widg)
with pytest.raises(LookupError):
# it's gone this time:
viewer.window.remove_dock_widget(widg)
assert not widg.parent()
def test_adding_modified_widget(make_napari_viewer):
viewer = make_napari_viewer()
widg = QWidget()
# not uncommon to see people shadow the builtin layout()
# which breaks our ability to add vertical stretch... but shouldn't crash
widg.layout = None
dw = viewer.window.add_dock_widget(widg, name='test', area='right')
assert dw.widget() is widg
def test_adding_stretch(make_napari_viewer):
"""Make sure that vertical stretch only gets added when appropriate."""
viewer = make_napari_viewer()
# adding a widget to the left/right will usually addStretch to the layout
widg = QWidget()
widg.setLayout(QVBoxLayout())
widg.layout().addWidget(QPushButton())
assert widg.layout().count() == 1
dw = viewer.window.add_dock_widget(widg, area='right')
assert widg.layout().count() == 2
dw.close()
# ... unless the widget has a widget with a large vertical sizePolicy
widg = QWidget()
widg.setLayout(QVBoxLayout())
widg.layout().addWidget(QTextEdit())
assert widg.layout().count() == 1
dw = viewer.window.add_dock_widget(widg, area='right')
assert widg.layout().count() == 1
dw.close()
# ... widgets on the bottom do not get stretch
widg = QWidget()
widg.setLayout(QHBoxLayout())
widg.layout().addWidget(QPushButton())
assert widg.layout().count() == 1
dw = viewer.window.add_dock_widget(widg, area='bottom')
assert widg.layout().count() == 1
dw.close()
napari-0.5.0a1/napari/_qt/widgets/_tests/test_qt_extension2reader.py 0000664 0000000 0000000 00000015713 14370413656 0025632 0 ustar 00root root 0000000 0000000 import pytest
from npe2 import DynamicPlugin
from qtpy.QtCore import Qt
from qtpy.QtWidgets import QLabel, QPushButton
from napari._qt.widgets.qt_extension2reader import Extension2ReaderTable
from napari.settings import get_settings
@pytest.fixture
def extension2reader_widget(qtbot):
def _extension2reader_widget(**kwargs):
widget = Extension2ReaderTable(**kwargs)
widget.show()
qtbot.addWidget(widget)
return widget
return _extension2reader_widget
@pytest.fixture
def tif_reader(tmp_plugin: DynamicPlugin):
tmp2 = tmp_plugin.spawn(name='tif_reader', register=True)
@tmp2.contribute.reader(filename_patterns=['*.tif'])
def _(path):
...
return tmp2
@pytest.fixture
def npy_reader(tmp_plugin: DynamicPlugin):
tmp2 = tmp_plugin.spawn(name='npy_reader', register=True)
@tmp2.contribute.reader(filename_patterns=['*.npy'])
def _(path):
...
return tmp2
def test_extension2reader_defaults(
extension2reader_widget,
):
get_settings().plugins.extension2reader = {}
widget = extension2reader_widget()
assert widget._table.rowCount() == 1
assert (
widget._table.itemAt(0, 0).text() == 'No filename preferences found.'
)
def test_extension2reader_with_settings(
extension2reader_widget,
):
get_settings().plugins.extension2reader = {'.test': 'test-plugin'}
widget = extension2reader_widget()
assert widget._table.rowCount() == 1
assert widget._table.item(0, 0).text() == '.test'
assert (
widget._table.cellWidget(0, 1).findChild(QLabel).text()
== 'test-plugin'
)
def test_extension2reader_removal(extension2reader_widget, qtbot):
get_settings().plugins.extension2reader = {
'.test': 'test-plugin',
'.abc': 'abc-plugin',
}
widget = extension2reader_widget()
assert widget._table.rowCount() == 2
btn_to_click = widget._table.cellWidget(0, 1).findChild(QPushButton)
qtbot.mouseClick(btn_to_click, Qt.LeftButton)
assert get_settings().plugins.extension2reader == {'.abc': 'abc-plugin'}
assert widget._table.rowCount() == 1
assert widget._table.item(0, 0).text() == '.abc'
# remove remaining extension
btn_to_click = widget._table.cellWidget(0, 1).findChild(QPushButton)
qtbot.mouseClick(btn_to_click, Qt.LeftButton)
assert not get_settings().plugins.extension2reader
assert widget._table.rowCount() == 1
assert "No filename preferences found" in widget._table.item(0, 0).text()
def test_all_readers_in_dropdown(
extension2reader_widget, tmp_plugin, tif_reader
):
@tmp_plugin.contribute.reader(filename_patterns=['*'])
def _(path):
...
npe2_readers = {
tmp_plugin.name: tmp_plugin.display_name,
tif_reader.name: tif_reader.display_name,
}
widget = extension2reader_widget(npe2_readers=npe2_readers)
all_dropdown_items = {
widget._new_reader_dropdown.itemText(i)
for i in range(widget._new_reader_dropdown.count())
}
assert all(i in all_dropdown_items for i in npe2_readers.values())
def test_directory_readers_not_in_dropdown(
extension2reader_widget, tmp_plugin
):
@tmp_plugin.contribute.reader(
filename_patterns=[], accepts_directories=True
)
def f(path):
...
widget = extension2reader_widget(
npe2_readers={tmp_plugin.name: tmp_plugin.display_name},
npe1_readers={},
)
all_dropdown_items = [
widget._new_reader_dropdown.itemText(i)
for i in range(widget._new_reader_dropdown.count())
]
assert tmp_plugin.display_name not in all_dropdown_items
def test_filtering_readers(
extension2reader_widget, builtins, tif_reader, npy_reader
):
widget = extension2reader_widget(
npe1_readers={builtins.display_name: builtins.display_name}
)
assert widget._new_reader_dropdown.count() == 3
widget._filter_compatible_readers('*.npy')
assert widget._new_reader_dropdown.count() == 2
all_dropdown_items = [
widget._new_reader_dropdown.itemText(i)
for i in range(widget._new_reader_dropdown.count())
]
assert (
sorted([npy_reader.display_name, builtins.display_name])
== all_dropdown_items
)
def test_filtering_readers_complex_pattern(
extension2reader_widget, npy_reader, tif_reader
):
@tif_reader.contribute.reader(
filename_patterns=['my-specific-folder/*.tif']
)
def f(path):
...
widget = extension2reader_widget(npe1_readers={})
assert widget._new_reader_dropdown.count() == 2
widget._filter_compatible_readers('my-specific-folder/my-file.tif')
assert widget._new_reader_dropdown.count() == 1
all_dropdown_items = [
widget._new_reader_dropdown.itemText(i)
for i in range(widget._new_reader_dropdown.count())
]
assert sorted([tif_reader.name]) == all_dropdown_items
def test_adding_new_preference(
extension2reader_widget, tif_reader, npy_reader
):
widget = extension2reader_widget(npe1_readers={})
widget._fn_pattern_edit.setText('*.tif')
# will be filtered and tif-reader will be only item
widget._new_reader_dropdown.setCurrentIndex(0)
get_settings().plugins.extension2reader = {}
widget._save_new_preference(True)
settings = get_settings().plugins.extension2reader
assert '*.tif' in settings
assert settings['*.tif'] == tif_reader.name
assert (
widget._table.item(widget._table.rowCount() - 1, 0).text() == '*.tif'
)
plugin_label = widget._table.cellWidget(
widget._table.rowCount() - 1, 1
).findChild(QLabel)
assert plugin_label.text() == tif_reader.display_name
def test_adding_new_preference_no_asterisk(
extension2reader_widget, tif_reader, npy_reader
):
widget = extension2reader_widget(npe1_readers={})
widget._fn_pattern_edit.setText('.tif')
# will be filtered and tif-reader will be only item
widget._new_reader_dropdown.setCurrentIndex(0)
get_settings().plugins.extension2reader = {}
widget._save_new_preference(True)
settings = get_settings().plugins.extension2reader
assert '*.tif' in settings
assert settings['*.tif'] == tif_reader.name
def test_editing_preference(extension2reader_widget, tif_reader):
tiff2 = tif_reader.spawn(register=True)
@tiff2.contribute.reader(filename_patterns=["*.tif"])
def ff(path):
...
get_settings().plugins.extension2reader = {'*.tif': tif_reader.name}
widget = extension2reader_widget()
widget._fn_pattern_edit.setText('*.tif')
# set to tiff2
widget._new_reader_dropdown.setCurrentText(tiff2.display_name)
original_row_count = widget._table.rowCount()
widget._save_new_preference(True)
settings = get_settings().plugins.extension2reader
assert '*.tif' in settings
assert settings['*.tif'] == tiff2.name
assert widget._table.rowCount() == original_row_count
plugin_label = widget._table.cellWidget(
original_row_count - 1, 1
).findChild(QLabel)
assert plugin_label.text() == tiff2.name
napari-0.5.0a1/napari/_qt/widgets/_tests/test_qt_highlight_preview.py 0000664 0000000 0000000 00000013631 14370413656 0026056 0 ustar 00root root 0000000 0000000 import pytest
from napari._qt.widgets.qt_highlight_preview import (
QtHighlightSizePreviewWidget,
QtStar,
QtTriangle,
)
@pytest.fixture
def star_widget(qtbot):
def _star_widget(**kwargs):
widget = QtStar(**kwargs)
widget.show()
qtbot.addWidget(widget)
return widget
return _star_widget
@pytest.fixture
def triangle_widget(qtbot):
def _triangle_widget(**kwargs):
widget = QtTriangle(**kwargs)
widget.show()
qtbot.addWidget(widget)
return widget
return _triangle_widget
@pytest.fixture
def highlight_size_preview_widget(qtbot):
def _highlight_size_preview_widget(**kwargs):
widget = QtHighlightSizePreviewWidget(**kwargs)
widget.show()
qtbot.addWidget(widget)
return widget
return _highlight_size_preview_widget
# QtStar
# ----------------------------------------------------------------------------
def test_qt_star_defaults(star_widget):
star_widget()
def test_qt_star_value(star_widget):
widget = star_widget(value=5)
assert widget.value() <= 5
widget = star_widget()
widget.setValue(5)
assert widget.value() == 5
# QtTriangle
# ----------------------------------------------------------------------------
def test_qt_triangle_defaults(triangle_widget):
triangle_widget()
def test_qt_triangle_value(triangle_widget):
widget = triangle_widget(value=5)
assert widget.value() <= 5
widget = triangle_widget()
widget.setValue(5)
assert widget.value() == 5
def test_qt_triangle_minimum(triangle_widget):
minimum = 1
widget = triangle_widget(min_value=minimum)
assert widget.minimum() == minimum
assert widget.value() >= minimum
widget = triangle_widget()
widget.setMinimum(2)
assert widget.minimum() == 2
assert widget.value() == 2
def test_qt_triangle_maximum(triangle_widget):
maximum = 10
widget = triangle_widget(max_value=maximum)
assert widget.maximum() == maximum
assert widget.value() <= maximum
widget = triangle_widget()
widget.setMaximum(20)
assert widget.maximum() == 20
def test_qt_triangle_signal(qtbot, triangle_widget):
widget = triangle_widget()
with qtbot.waitSignal(widget.valueChanged, timeout=500):
widget.setValue(7)
with qtbot.waitSignal(widget.valueChanged, timeout=500):
widget.setValue(-5)
# QtHighlightSizePreviewWidget
# ----------------------------------------------------------------------------
def test_qt_highlight_size_preview_widget_defaults(
highlight_size_preview_widget,
):
highlight_size_preview_widget()
def test_qt_highlight_size_preview_widget_description(
highlight_size_preview_widget,
):
description = "Some text"
widget = highlight_size_preview_widget(description=description)
assert widget.description() == description
widget = highlight_size_preview_widget()
widget.setDescription(description)
assert widget.description() == description
def test_qt_highlight_size_preview_widget_unit(highlight_size_preview_widget):
unit = "CM"
widget = highlight_size_preview_widget(unit=unit)
assert widget.unit() == unit
widget = highlight_size_preview_widget()
widget.setUnit(unit)
assert widget.unit() == unit
def test_qt_highlight_size_preview_widget_minimum(
highlight_size_preview_widget,
):
minimum = 5
widget = highlight_size_preview_widget(min_value=minimum)
assert widget.minimum() == minimum
assert widget.value() >= minimum
widget = highlight_size_preview_widget()
widget.setMinimum(3)
assert widget.minimum() == 3
assert widget.value() == 3
assert widget._slider.minimum() == 3
assert widget._slider_min_label.text() == "3"
assert widget._triangle.minimum() == 3
assert widget._lineedit.text() == "3"
def test_qt_highlight_size_preview_widget_minimum_invalid(
highlight_size_preview_widget,
):
widget = highlight_size_preview_widget()
with pytest.raises(ValueError):
widget.setMinimum(60)
def test_qt_highlight_size_preview_widget_maximum(
highlight_size_preview_widget,
):
maximum = 10
widget = highlight_size_preview_widget(max_value=maximum)
assert widget.maximum() == maximum
assert widget.value() <= maximum
widget = highlight_size_preview_widget()
widget.setMaximum(20)
assert widget.maximum() == 20
assert widget._slider.maximum() == 20
assert widget._triangle.maximum() == 20
assert widget._slider_max_label.text() == "20"
widget.setMaximum(5)
assert widget.maximum() == 5
# assert widget.value() == 5
# assert widget._slider.maximum() == 5
# assert widget._triangle.maximum() == 20
# assert widget._lineedit.text() == "5"
# assert widget._slider_max_label.text() == "5"
def test_qt_highlight_size_preview_widget_maximum_invalid(
highlight_size_preview_widget,
):
widget = highlight_size_preview_widget()
with pytest.raises(ValueError):
widget.setMaximum(-5)
def test_qt_highlight_size_preview_widget_value(highlight_size_preview_widget):
widget = highlight_size_preview_widget(value=5)
assert widget.value() <= 5
widget = highlight_size_preview_widget()
widget.setValue(5)
assert widget.value() == 5
def test_qt_highlight_size_preview_widget_value_invalid(
qtbot, highlight_size_preview_widget
):
widget = highlight_size_preview_widget()
widget.setMaximum(50)
widget.setValue(51)
assert widget.value() == 50
assert widget._lineedit.text() == "50"
widget.setMinimum(5)
widget.setValue(1)
assert widget.value() == 5
assert widget._lineedit.text() == "5"
def test_qt_highlight_size_preview_widget_signal(
qtbot, highlight_size_preview_widget
):
widget = highlight_size_preview_widget()
with qtbot.waitSignal(widget.valueChanged, timeout=500):
widget.setValue(7)
with qtbot.waitSignal(widget.valueChanged, timeout=500):
widget.setValue(-5)
napari-0.5.0a1/napari/_qt/widgets/_tests/test_qt_play.py 0000664 0000000 0000000 00000011401 14370413656 0023304 0 ustar 00root root 0000000 0000000 from contextlib import contextmanager
from weakref import ref
import numpy as np
import pytest
from napari._qt.widgets.qt_dims import QtDims
from napari._qt.widgets.qt_dims_slider import AnimationWorker
from napari.components import Dims
from napari.settings._constants import LoopMode
@contextmanager
def make_worker(
qtbot, nframes=8, fps=20, frame_range=None, loop_mode=LoopMode.LOOP
):
# sets up an AnimationWorker ready for testing, and breaks down when done
dims = Dims(ndim=4)
qtdims = QtDims(dims)
qtbot.addWidget(qtdims)
nz = 8
step = 1
dims.set_range(0, (0, nz, step))
slider_widget = qtdims.slider_widgets[0]
slider_widget.loop_mode = loop_mode
slider_widget.fps = fps
slider_widget.frame_range = frame_range
worker = AnimationWorker(slider_widget)
worker._count = 0
worker.nz = nz
def bump(*args):
if worker._count < nframes:
worker._count += 1
else:
worker._stop()
def count_reached():
assert worker._count >= nframes
def go():
worker.work()
qtbot.waitUntil(count_reached, timeout=6000)
worker._stop()
return worker.current
worker.frame_requested.connect(bump)
worker.go = go
yield worker
# Each tuple represents different arguments we will pass to make_thread
# frames, fps, mode, frame_range, expected_result(nframes, nz)
CONDITIONS = [
# regular nframes < nz
(5, 10, LoopMode.LOOP, None, lambda x, y: x),
# loops around to the beginning
(10, 10, LoopMode.LOOP, None, lambda x, y: x % y),
# loops correctly with frame_range specified
(10, 10, LoopMode.LOOP, (2, 6), lambda x, y: x % y),
# loops correctly going backwards
(10, -10, LoopMode.LOOP, None, lambda x, y: y - (x % y)),
# loops back and forth
(10, 10, LoopMode.BACK_AND_FORTH, None, lambda x, y: x - y + 2),
# loops back and forth, with negative fps
(10, -10, LoopMode.BACK_AND_FORTH, None, lambda x, y: y - (x % y) - 2),
]
@pytest.mark.parametrize("nframes,fps,mode,rng,result", CONDITIONS)
def test_animation_thread_variants(qtbot, nframes, fps, mode, rng, result):
"""This is mostly testing that AnimationWorker.advance works as expected"""
with make_worker(
qtbot, fps=fps, nframes=nframes, frame_range=rng, loop_mode=mode
) as worker:
current = worker.go()
if rng:
nrange = rng[1] - rng[0] + 1
expected = rng[0] + result(nframes, nrange)
else:
expected = result(nframes, worker.nz)
# assert current == expected
# relaxing for CI OSX tests
assert expected - 1 <= current <= expected + 1
def test_animation_thread_once(qtbot):
"""Single shot animation should stop when it reaches the last frame"""
nframes = 13
with make_worker(
qtbot, nframes=nframes, loop_mode=LoopMode.ONCE
) as worker:
with qtbot.waitSignal(worker.finished, timeout=8000):
worker.work()
assert worker.current == worker.nz
@pytest.fixture()
def ref_view(make_napari_viewer):
"""basic viewer with data that we will use a few times
It is problematic to yield the qt_viewer directly as it will stick
around in the generator frames and causes issues if we want to make sure
there is only a single instance of QtViewer instantiated at all times during
the test suite. Thus we yield a weak reference that we resolve immediately
in the test suite.
"""
viewer = make_napari_viewer()
np.random.seed(0)
data = np.random.random((10, 10, 15))
viewer.add_image(data)
yield ref(viewer.window._qt_viewer)
viewer.close()
def test_play_raises_index_errors(qtbot, ref_view):
view = ref_view()
# play axis is out of range
with pytest.raises(IndexError):
view.dims.play(4, 20)
# data doesn't have 20 frames
with pytest.raises(IndexError):
view.dims.play(0, 20, frame_range=[2, 20])
def test_play_raises_value_errors(qtbot, ref_view):
view = ref_view()
# frame_range[1] not > frame_range[0]
with pytest.raises(ValueError):
view.dims.play(0, 20, frame_range=[2, 2])
# that's not a valid loop_mode
with pytest.raises(ValueError):
view.dims.play(0, 20, loop_mode=5)
def test_playing_hidden_slider_does_nothing(ref_view):
"""Make sure playing a dimension without a slider does nothing"""
view = ref_view()
def increment(e):
view.dims._frame = e.value # this is provided by the step event
# if we don't "enable play" again, view.dims won't request a new frame
view.dims._play_ready = True
view.dims.dims.events.current_step.connect(increment)
with pytest.warns(UserWarning):
view.dims.play(2, 20)
view.dims.dims.events.current_step.disconnect(increment)
assert not view.dims.is_playing
napari-0.5.0a1/napari/_qt/widgets/_tests/test_qt_progress_bar.py 0000664 0000000 0000000 00000002770 14370413656 0025040 0 ustar 00root root 0000000 0000000 from argparse import Namespace
from napari._qt.widgets.qt_progress_bar import (
QtLabeledProgressBar,
QtProgressBarGroup,
)
def test_create_qt_labeled_progress_bar(qtbot):
progress = QtLabeledProgressBar()
qtbot.addWidget(progress)
def test_qt_labeled_progress_bar_base(qtbot):
progress = QtLabeledProgressBar()
qtbot.addWidget(progress)
progress.setRange(0, 10)
assert progress.qt_progress_bar.value() == -1
progress.setValue(5)
assert progress.qt_progress_bar.value() == 5
progress.setDescription("text")
assert progress.description_label.text() == "text: "
def test_qt_labeled_progress_bar_event_handle(qtbot):
progress = QtLabeledProgressBar()
qtbot.addWidget(progress)
assert progress.qt_progress_bar.maximum() != 10
progress._set_total(Namespace(value=10))
assert progress.qt_progress_bar.maximum() == 10
assert progress._get_value() == -1
progress._set_value(Namespace(value=5))
assert progress._get_value() == 5
assert progress.description_label.text() == ""
progress._set_description(Namespace(value="text"))
assert progress.description_label.text() == "text: "
assert progress.eta_label.text() == ""
progress._set_eta(Namespace(value="test"))
assert progress.eta_label.text() == "test"
progress._make_indeterminate(None)
assert progress.qt_progress_bar.maximum() == 0
def test_create_qt_progress_bar_group(qtbot):
group = QtProgressBarGroup(QtLabeledProgressBar())
qtbot.addWidget(group)
napari-0.5.0a1/napari/_qt/widgets/_tests/test_qt_range_slider_popup.py 0000664 0000000 0000000 00000001513 14370413656 0026223 0 ustar 00root root 0000000 0000000 import pytest
from napari._qt.widgets.qt_range_slider_popup import QRangeSliderPopup
initial = (100, 400)
range_ = (0, 500)
@pytest.fixture
def popup(qtbot):
popup = QRangeSliderPopup()
popup.slider.setRange(*range_)
popup.slider.setValue(initial)
qtbot.addWidget(popup)
return popup
def test_range_slider_popup_labels(popup):
"""make sure labels are correct"""
assert popup.slider._handle_labels[0].value() == initial[0]
assert popup.slider._handle_labels[1].value() == initial[1]
assert (popup.slider.minimum(), popup.slider.maximum()) == range_
def test_range_slider_changes_labels(popup):
"""make sure setting the slider updates the labels"""
popup.slider.setValue((10, 20))
assert popup.slider._handle_labels[0].value() == 10
assert popup.slider._handle_labels[1].value() == 20
napari-0.5.0a1/napari/_qt/widgets/_tests/test_qt_scrollbar.py 0000664 0000000 0000000 00000000561 14370413656 0024327 0 ustar 00root root 0000000 0000000 from qtpy.QtCore import QPoint, Qt
from napari._qt.widgets.qt_scrollbar import ModifiedScrollBar
def test_modified_scrollbar_click(qtbot):
w = ModifiedScrollBar(Qt.Horizontal)
w.resize(100, 10)
assert w.value() == 0
qtbot.mousePress(w, Qt.LeftButton, pos=QPoint(50, 5))
# the normal QScrollBar would have moved to "10"
assert w.value() >= 40
napari-0.5.0a1/napari/_qt/widgets/_tests/test_qt_size_preview.py 0000664 0000000 0000000 00000011301 14370413656 0025051 0 ustar 00root root 0000000 0000000 import pytest
from napari._qt.widgets.qt_size_preview import (
QtFontSizePreview,
QtSizeSliderPreviewWidget,
)
@pytest.fixture
def preview_widget(qtbot):
def _preview_widget(**kwargs):
widget = QtFontSizePreview(**kwargs)
widget.show()
qtbot.addWidget(widget)
return widget
return _preview_widget
@pytest.fixture
def font_size_preview_widget(qtbot):
def _font_size_preview_widget(**kwargs):
widget = QtSizeSliderPreviewWidget(**kwargs)
widget.show()
qtbot.addWidget(widget)
return widget
return _font_size_preview_widget
# QtFontSizePreview
# ----------------------------------------------------------------------------
def test_qt_font_size_preview_defaults(preview_widget):
preview_widget()
def test_qt_font_size_preview_text(preview_widget):
text = "Some text"
widget = preview_widget(text=text)
assert widget.text() == text
widget = preview_widget()
widget.setText(text)
assert widget.text() == text
# QtSizeSliderPreviewWidget
# ----------------------------------------------------------------------------
def test_qt_size_slider_preview_widget_defaults(font_size_preview_widget):
font_size_preview_widget()
def test_qt_size_slider_preview_widget_description(font_size_preview_widget):
description = "Some text"
widget = font_size_preview_widget(description=description)
assert widget.description() == description
widget = font_size_preview_widget()
widget.setDescription(description)
assert widget.description() == description
def test_qt_size_slider_preview_widget_unit(font_size_preview_widget):
unit = "EM"
widget = font_size_preview_widget(unit=unit)
assert widget.unit() == unit
widget = font_size_preview_widget()
widget.setUnit(unit)
assert widget.unit() == unit
def test_qt_size_slider_preview_widget_preview(font_size_preview_widget):
preview = "Some preview"
widget = font_size_preview_widget(preview_text=preview)
assert widget.previewText() == preview
widget = font_size_preview_widget()
widget.setPreviewText(preview)
assert widget.previewText() == preview
def test_qt_size_slider_preview_widget_minimum(font_size_preview_widget):
minimum = 10
widget = font_size_preview_widget(min_value=minimum)
assert widget.minimum() == minimum
assert widget.value() >= minimum
widget = font_size_preview_widget()
widget.setMinimum(5)
assert widget.minimum() == 5
assert widget._slider.minimum() == 5
assert widget._slider_min_label.text() == "5"
widget.setMinimum(20)
assert widget.minimum() == 20
assert widget.value() == 20
assert widget._slider.minimum() == 20
assert widget._slider_min_label.text() == "20"
assert widget._lineedit.text() == "20"
def test_qt_size_slider_preview_widget_minimum_invalid(
font_size_preview_widget,
):
widget = font_size_preview_widget()
with pytest.raises(ValueError):
widget.setMinimum(60)
def test_qt_size_slider_preview_widget_maximum(font_size_preview_widget):
maximum = 10
widget = font_size_preview_widget(max_value=maximum)
assert widget.maximum() == maximum
assert widget.value() <= maximum
widget = font_size_preview_widget()
widget.setMaximum(20)
assert widget.maximum() == 20
assert widget._slider.maximum() == 20
assert widget._slider_max_label.text() == "20"
widget.setMaximum(5)
assert widget.maximum() == 5
assert widget.value() == 5
assert widget._slider.maximum() == 5
assert widget._lineedit.text() == "5"
assert widget._slider_max_label.text() == "5"
def test_qt_size_slider_preview_widget_maximum_invalid(
font_size_preview_widget,
):
widget = font_size_preview_widget()
with pytest.raises(ValueError):
widget.setMaximum(-5)
def test_qt_size_slider_preview_widget_value(font_size_preview_widget):
widget = font_size_preview_widget(value=5)
assert widget.value() <= 5
widget = font_size_preview_widget()
widget.setValue(5)
assert widget.value() == 5
def test_qt_size_slider_preview_widget_value_invalid(
qtbot, font_size_preview_widget
):
widget = font_size_preview_widget()
widget.setMaximum(50)
widget.setValue(51)
assert widget.value() == 50
assert widget._lineedit.text() == "50"
widget.setMinimum(5)
widget.setValue(1)
assert widget.value() == 5
assert widget._lineedit.text() == "5"
def test_qt_size_slider_preview_signal(qtbot, font_size_preview_widget):
widget = font_size_preview_widget()
with qtbot.waitSignal(widget.valueChanged, timeout=500):
widget.setValue(7)
with qtbot.waitSignal(widget.valueChanged, timeout=500):
widget.setValue(-5)
napari-0.5.0a1/napari/_qt/widgets/_tests/test_shortcut_editor_widget.py 0000664 0000000 0000000 00000003066 14370413656 0026427 0 ustar 00root root 0000000 0000000 from unittest.mock import patch
import pytest
from napari._qt.widgets.qt_keyboard_settings import ShortcutEditor, WarnPopup
from napari.utils.action_manager import action_manager
@pytest.fixture
def shortcut_editor_widget(qtbot):
def _shortcut_editor_widget(**kwargs):
widget = ShortcutEditor(**kwargs)
widget.show()
qtbot.addWidget(widget)
return widget
return _shortcut_editor_widget
def test_shortcut_editor_defaults(
shortcut_editor_widget,
):
shortcut_editor_widget()
def test_layer_actions(shortcut_editor_widget):
widget = shortcut_editor_widget()
assert widget.layer_combo_box.currentText() == widget.VIEWER_KEYBINDINGS
actions1 = widget._get_layer_actions()
assert actions1 == widget.key_bindings_strs[widget.VIEWER_KEYBINDINGS]
widget.layer_combo_box.setCurrentText("Labels layer")
actions2 = widget._get_layer_actions()
assert actions2 == {**widget.key_bindings_strs["Labels layer"], **actions1}
def test_mark_conflicts(shortcut_editor_widget, qtbot):
widget = shortcut_editor_widget()
widget._table.item(0, widget._shortcut_col).setText("U")
act = widget._table.item(0, widget._action_col).text()
assert action_manager._shortcuts[act][0] == "U"
with patch.object(WarnPopup, "exec_") as mock:
assert not widget._mark_conflicts(action_manager._shortcuts[act][0], 1)
assert mock.called
assert widget._mark_conflicts("Y", 1)
# "Y" is arbitrary chosen and on conflict with existing shortcut should be changed
qtbot.add_widget(widget._warn_dialog)
napari-0.5.0a1/napari/_qt/widgets/_tests/test_theme_sample.py 0000664 0000000 0000000 00000000377 14370413656 0024310 0 ustar 00root root 0000000 0000000 from napari._qt.widgets.qt_theme_sample import SampleWidget
def test_theme_sample(qtbot):
"""Just a smoke test to make sure that the theme sample can be created."""
w = SampleWidget()
qtbot.addWidget(w)
w.show()
assert w.isVisible()
napari-0.5.0a1/napari/_qt/widgets/qt_color_swatch.py 0000664 0000000 0000000 00000023612 14370413656 0022475 0 ustar 00root root 0000000 0000000 import re
from typing import Optional, Union
import numpy as np
from qtpy.QtCore import QEvent, Qt, Signal, Slot
from qtpy.QtGui import QColor, QKeyEvent, QMouseEvent
from qtpy.QtWidgets import (
QColorDialog,
QCompleter,
QFrame,
QHBoxLayout,
QLineEdit,
QVBoxLayout,
QWidget,
)
from vispy.color import get_color_dict
from napari._qt.dialogs.qt_modal import QtPopup
from napari.utils.colormaps.colormap_utils import ColorType
from napari.utils.colormaps.standardize_color import (
hex_to_name,
rgb_to_hex,
transform_color,
)
from napari.utils.translations import trans
# matches any 3- or 4-tuple of int or float, with or without parens
# captures the numbers into groups.
# this is used to allow users to enter colors as e.g.: "(1, 0.7, 0)"
rgba_regex = re.compile(
r"\(?([\d.]+),\s*([\d.]+),\s*([\d.]+),?\s*([\d.]+)?\)?"
)
TRANSPARENT = np.array([0, 0, 0, 0], np.float32)
AnyColorType = Union[ColorType, QColor]
class QColorSwatchEdit(QWidget):
"""A widget that combines a QColorSwatch with a QColorLineEdit.
emits a color_changed event with a 1x4 numpy array when the current color
changes. Note, the "model" for the current color is the ``_color``
attribute on the QColorSwatch.
Parameters
----------
parent : QWidget, optional
parent widget, by default None
initial_color : AnyColorType, optional
Starting color, by default None
tooltip : str, optional
Tooltip when hovering on the swatch,
by default 'click to set color'
Attributes
----------
line_edit : QColorLineEdit
An instance of QColorLineEdit, which takes hex, rgb, or autocompletes
common color names. On invalid input, this field will return to the
previous color value.
color_swatch : QColorSwatch
The square that shows the current color, and can be clicked to show a
color dialog.
color : np.ndarray
The current color (just an alias for the colorSwatch.color)
Signals
-------
color_changed : np.ndarray
Emits the new color when the current color changes.
"""
color_changed = Signal(np.ndarray)
def __init__(
self,
parent: Optional[QWidget] = None,
*,
initial_color: Optional[AnyColorType] = None,
tooltip: Optional[str] = None,
) -> None:
super().__init__(parent=parent)
self.setObjectName('QColorSwatchEdit')
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(6)
self.setLayout(layout)
self.line_edit = QColorLineEdit(self)
self.line_edit.editingFinished.connect(self._on_line_edit_edited)
self.color_swatch = QColorSwatch(self, tooltip=tooltip)
self.color_swatch.color_changed.connect(self._on_swatch_changed)
self.setColor = self.color_swatch.setColor
if initial_color is not None:
self.setColor(initial_color)
layout.addWidget(self.color_swatch)
layout.addWidget(self.line_edit)
@property
def color(self):
"""Return the current color."""
return self.color_swatch.color
def _on_line_edit_edited(self):
"""When the user hits enter or loses focus on the LineEdit widget."""
text = self.line_edit.text()
rgb_match = rgba_regex.match(text)
if rgb_match:
text = [float(x) for x in rgb_match.groups() if x]
self.color_swatch.setColor(text)
@Slot(np.ndarray)
def _on_swatch_changed(self, color: np.ndarray):
"""Receive QColorSwatch change event, update the lineEdit, re-emit."""
self.line_edit.setText(color)
self.color_changed.emit(color)
class QColorSwatch(QFrame):
"""A QFrame that displays a color and can be clicked to show a QColorPopup.
Parameters
----------
parent : QWidget, optional
parent widget, by default None
tooltip : Optional[str], optional
Tooltip when hovering on swatch,
by default 'click to set color'
initial_color : ColorType, optional
initial color, by default will be transparent
Attributes
----------
color : np.ndarray
The current color
Signals
-------
color_changed : np.ndarray
Emits the new color when the current color changes.
"""
color_changed = Signal(np.ndarray)
def __init__(
self,
parent: Optional[QWidget] = None,
tooltip: Optional[str] = None,
initial_color: Optional[ColorType] = None,
) -> None:
super().__init__(parent)
self.setObjectName('colorSwatch')
self.setToolTip(tooltip or trans._('click to set color'))
self.setCursor(Qt.CursorShape.PointingHandCursor)
self.color_changed.connect(self._update_swatch_style)
self._color: np.ndarray = TRANSPARENT
if initial_color is not None:
self.setColor(initial_color)
@property
def color(self):
"""Return the current color"""
return self._color
@Slot(np.ndarray)
def _update_swatch_style(self, color: np.ndarray) -> None:
"""Convert the current color to rgba() string and update appearance."""
rgba = f'rgba({",".join(map(lambda x: str(int(x*255)), self._color))})'
self.setStyleSheet('#colorSwatch {background-color: ' + rgba + ';}')
def mouseReleaseEvent(self, event: QMouseEvent):
"""Show QColorPopup picker when the user clicks on the swatch."""
if event.button() == Qt.MouseButton.LeftButton:
initial = QColor(*(255 * self._color).astype('int'))
popup = QColorPopup(self, initial)
popup.colorSelected.connect(self.setColor)
popup.show_right_of_mouse()
def setColor(self, color: AnyColorType) -> None:
"""Set the color of the swatch.
Parameters
----------
color : ColorType
Can be any ColorType recognized by our
utils.colormaps.standardize_color.transform_color function.
"""
if isinstance(color, QColor):
_color = (np.array(color.getRgb()) / 255).astype(np.float32)
else:
try:
_color = transform_color(color)[0]
except ValueError:
return self.color_changed.emit(self._color)
emit = np.any(self._color != _color)
self._color = _color
if emit or np.all(_color == TRANSPARENT):
self.color_changed.emit(_color)
class QColorLineEdit(QLineEdit):
"""A LineEdit that takes hex, rgb, or autocompletes common color names.
Parameters
----------
parent : QWidget, optional
The parent widget, by default None
"""
def __init__(self, parent=None) -> None:
super().__init__(parent)
self._compl = QCompleter(list(get_color_dict()) + ['transparent'])
self._compl.setCompletionMode(QCompleter.InlineCompletion)
self.setCompleter(self._compl)
self.setTextMargins(2, 2, 2, 2)
def setText(self, color: ColorType):
"""Set the text of the lineEdit using any ColorType.
Colors will be converted to standard SVG spec names if possible,
or shown as #RGBA hex if not.
Parameters
----------
color : ColorType
Can be any ColorType recognized by our
utils.colormaps.standardize_color.transform_color function.
"""
_rgb = transform_color(color)[0]
_hex = rgb_to_hex(_rgb)[0]
super().setText(hex_to_name.get(_hex, _hex))
class CustomColorDialog(QColorDialog):
def __init__(self, parent=None) -> None:
super().__init__(parent=parent)
self.setObjectName('CustomColorDialog')
def keyPressEvent(self, event: QEvent):
event.ignore()
class QColorPopup(QtPopup):
"""A QColorDialog inside of our QtPopup.
Allows all of the show methods of QtPopup (like show relative to mouse).
Passes through signals from the ColorDialogm, and handles some keypress
events.
Parameters
----------
parent : QWidget, optional
The parent widget. by default None
initial_color : AnyColorType, optional
The initial color set in the color dialog, by default None
Attributes
----------
color_dialog : CustomColorDialog
The main color dialog in the popup
"""
currentColorChanged = Signal(QColor)
colorSelected = Signal(QColor)
def __init__(
self, parent: QWidget = None, initial_color: AnyColorType = None
) -> None:
super().__init__(parent)
self.setObjectName('QtColorPopup')
self.color_dialog = CustomColorDialog(self)
# native dialog doesn't get added to the QtPopup frame
# so more would need to be done to use it
self.color_dialog.setOptions(
QColorDialog.DontUseNativeDialog | QColorDialog.ShowAlphaChannel
)
layout = QVBoxLayout()
self.frame.setLayout(layout)
layout.addWidget(self.color_dialog)
self.color_dialog.currentColorChanged.connect(
self.currentColorChanged.emit
)
self.color_dialog.colorSelected.connect(self._on_color_selected)
self.color_dialog.rejected.connect(self._on_rejected)
self.color_dialog.setCurrentColor(QColor(initial_color))
def _on_color_selected(self, color: QColor):
"""When a color has beeen selected and the OK button clicked."""
self.colorSelected.emit(color)
self.close()
def _on_rejected(self):
self.close()
def keyPressEvent(self, event: QKeyEvent):
"""Accept current color on enter, cancel on escape.
Parameters
----------
event : QKeyEvent
The keypress event that triggered this method.
"""
if event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter):
return self.color_dialog.accept()
if event.key() == Qt.Key.Key_Escape:
return self.color_dialog.reject()
self.color_dialog.keyPressEvent(event)
napari-0.5.0a1/napari/_qt/widgets/qt_dict_table.py 0000664 0000000 0000000 00000012131 14370413656 0022072 0 ustar 00root root 0000000 0000000 import re
from typing import List, Optional
from qtpy.QtCore import QSize, Slot
from qtpy.QtGui import QFont
from qtpy.QtWidgets import QTableWidget, QTableWidgetItem
from napari.utils.translations import trans
email_pattern = re.compile(r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$")
url_pattern = re.compile(
r"https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}"
r"\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)"
)
class QtDictTable(QTableWidget):
"""A QTableWidget subclass that makes a table from a list of dicts.
This will also make any cells that contain emails address or URLs
clickable to open the link in a browser/email client.
Parameters
----------
parent : QWidget, optional
The parent widget, by default None
source : list of dict, optional
A list of dicts where each dict in the list is a row, and each key in
the dict is a header, by default None. (call set_data later to add
data)
headers : list of str, optional
If provided, will be used in order as the headers of the table. All
items in ``headers`` must be present in at least one of the dicts.
by default headers will be the set of all keys in all dicts in
``source``
min_section_width : int, optional
If provided, sets a minimum width on the columns, by default None
max_section_width : int, optional
Sets a maximum width on the columns, by default 480
Raises
------
ValueError
if ``source`` is not a list of dicts.
"""
def __init__(
self,
parent=None,
source: List[dict] = None,
*,
headers: List[str] = None,
min_section_width: Optional[int] = None,
max_section_width: int = 480,
) -> None:
super().__init__(parent=parent)
if min_section_width:
self.horizontalHeader().setMinimumSectionSize(min_section_width)
self.horizontalHeader().setMaximumSectionSize(max_section_width)
self.horizontalHeader().setStretchLastSection(True)
if source:
self.set_data(source, headers)
self.cellClicked.connect(self._go_to_links)
self.setMouseTracking(True)
def set_data(self, data: List[dict], headers: Optional[List[str]] = None):
"""Set the data in the table, given a list of dicts.
Parameters
----------
data : List[dict]
A list of dicts where each dict in the list is a row, and each key
in the dict is a header, by default None. (call set_data later to
add data)
headers : list of str, optional
If provided, will be used in order as the headers of the table. All
items in ``headers`` must be present in at least one of the dicts.
by default headers will be the set of all keys in all dicts in
``source``
"""
if not isinstance(data, list) or any(
not isinstance(i, dict) for i in data
):
raise ValueError(
trans._(
"'data' argument must be a list of dicts", deferred=True
)
)
nrows = len(data)
_headers = sorted(set().union(*data))
if headers:
for h in headers:
if h not in _headers:
raise ValueError(
trans._(
"Argument 'headers' got item '{header}', which was not found in any of the items in 'data'",
deferred=True,
header=h,
)
)
_headers = headers
self.setRowCount(nrows)
self.setColumnCount(len(_headers))
for row, elem in enumerate(data):
for key, value in elem.items():
value = value or ''
try:
col = _headers.index(key)
except ValueError:
continue
item = QTableWidgetItem(value)
# underline links
if email_pattern.match(value) or url_pattern.match(value):
font = QFont()
font.setUnderline(True)
item.setFont(font)
self.setItem(row, col, item)
self.setHorizontalHeaderLabels(_headers)
self.resize_to_fit()
@Slot(int, int)
def _go_to_links(self, row, col):
"""if a cell is clicked and it contains an email or url, go to link."""
import webbrowser
item = self.item(row, col)
text = item.text().strip()
if email_pattern.match(text):
webbrowser.open(f'mailto:{text}', new=1)
return
if url_pattern.match(text):
webbrowser.open(text, new=1)
def resize_to_fit(self):
self.resizeColumnsToContents()
self.resize(self.sizeHint())
def sizeHint(self):
"""Return (width, height) of the table"""
width = sum(map(self.columnWidth, range(self.columnCount()))) + 25
height = self.rowHeight(0) * (self.rowCount() + 1)
return QSize(width, height)
napari-0.5.0a1/napari/_qt/widgets/qt_dims.py 0000664 0000000 0000000 00000032053 14370413656 0020741 0 ustar 00root root 0000000 0000000 import warnings
from typing import Optional, Tuple
import numpy as np
from qtpy.QtCore import Slot
from qtpy.QtGui import QFont, QFontMetrics
from qtpy.QtWidgets import QLineEdit, QSizePolicy, QVBoxLayout, QWidget
from napari._qt.widgets.qt_dims_slider import QtDimSliderWidget
from napari.components.dims import Dims
from napari.settings._constants import LoopMode
from napari.utils.translations import trans
class QtDims(QWidget):
"""Qt view for the napari Dims model.
Parameters
----------
dims : napari.components.dims.Dims
Dims object to be passed to Qt object.
parent : QWidget, optional
QWidget that will be the parent of this widget.
Attributes
----------
dims : napari.components.dims.Dims
Dimensions object modeling slicing and displaying.
slider_widgets : list[QtDimSliderWidget]
List of slider widgets.
"""
def __init__(self, dims: Dims, parent=None) -> None:
super().__init__(parent=parent)
self.SLIDERHEIGHT = 22
# We keep a reference to the view:
self.dims = dims
# list of sliders
self.slider_widgets = []
# True / False if slider is or is not displayed
self._displayed_sliders = []
self._play_ready = True # False if currently awaiting a draw event
self._animation_thread = None
self._animation_worker = None
# Initialises the layout:
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(3)
self.setLayout(layout)
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
# Update the number of sliders now that the dims have been added
self._update_nsliders()
self.dims.events.ndim.connect(self._update_nsliders)
self.dims.events.current_step.connect(self._update_slider)
self.dims.events.range.connect(self._update_range)
self.dims.events.ndisplay.connect(self._update_display)
self.dims.events.order.connect(self._update_display)
self.dims.events.last_used.connect(self._on_last_used_changed)
@property
def nsliders(self):
"""Returns the number of sliders.
Returns
-------
nsliders: int
Number of sliders.
"""
return len(self.slider_widgets)
def _on_last_used_changed(self):
"""Sets the style of the last used slider."""
for i, widget in enumerate(self.slider_widgets):
sld = widget.slider
sld.setProperty('last_used', i == self.dims.last_used)
sld.style().unpolish(sld)
sld.style().polish(sld)
def _update_slider(self):
"""Updates position for a given slider."""
for widget in self.slider_widgets:
widget._update_slider()
def _update_range(self):
"""Updates range for a given slider."""
for widget in self.slider_widgets:
widget._update_range()
nsliders = np.sum(self._displayed_sliders)
self.setMinimumHeight(nsliders * self.SLIDERHEIGHT)
self._resize_slice_labels()
def _update_display(self):
"""Updates display for all sliders."""
self.stop()
widgets = reversed(list(enumerate(self.slider_widgets)))
nsteps = self.dims.nsteps
for (axis, widget) in widgets:
if axis in self.dims.displayed or nsteps[axis] <= 1:
# Displayed dimensions correspond to non displayed sliders
self._displayed_sliders[axis] = False
self.dims.last_used = 0
widget.hide()
else:
# Non displayed dimensions correspond to displayed sliders
self._displayed_sliders[axis] = True
self.dims.last_used = axis
widget.show()
nsliders = np.sum(self._displayed_sliders)
self.setMinimumHeight(nsliders * self.SLIDERHEIGHT)
self._resize_slice_labels()
def _update_nsliders(self):
"""Updates the number of sliders based on the number of dimensions."""
self.stop()
self._trim_sliders(0)
self._create_sliders(self.dims.ndim)
self._update_display()
for i in range(self.dims.ndim):
self._update_range()
if self._displayed_sliders[i]:
self._update_slider()
def _resize_axis_labels(self):
"""When any of the labels get updated, this method updates all label
widths to the width of the longest label. This keeps the sliders
left-aligned and allows the full label to be visible at all times,
with minimal space, without setting stretch on the layout.
"""
fm = QFontMetrics(QFont("", 0))
labels = self.findChildren(QLineEdit, 'axis_label')
newwidth = max(fm.boundingRect(lab.text()).width() for lab in labels)
if any(self._displayed_sliders):
# set maximum width to no more than 20% of slider width
maxwidth = self.slider_widgets[0].width() * 0.2
newwidth = min([newwidth, maxwidth])
for labl in labels:
labl.setFixedWidth(int(newwidth) + 10)
def _resize_slice_labels(self):
"""When the size of any dimension changes, we want to resize all of the
slice labels to width of the longest label, to keep all the sliders
right aligned. The width is determined by the number of digits in the
largest dimensions, plus a little padding.
"""
width = 0
for ax, maxi in enumerate(self.dims.nsteps):
if self._displayed_sliders[ax]:
length = len(str(maxi - 1))
if length > width:
width = length
# gui width of a string of length `width`
fm = QFontMetrics(QFont("", 0))
width = fm.boundingRect("8" * width).width()
for labl in self.findChildren(QWidget, 'slice_label'):
labl.setFixedWidth(width + 6)
def _create_sliders(self, number_of_sliders: int):
"""Creates sliders to match new number of dimensions.
Parameters
----------
number_of_sliders : int
New number of sliders.
"""
# add extra sliders so that number_of_sliders are present
# add to the beginning of the list
for slider_num in range(self.nsliders, number_of_sliders):
dim_axis = number_of_sliders - slider_num - 1
slider_widget = QtDimSliderWidget(self, dim_axis)
slider_widget.axis_label_changed.connect(self._resize_axis_labels)
slider_widget.play_button.play_requested.connect(self.play)
self.layout().addWidget(slider_widget)
self.slider_widgets.insert(0, slider_widget)
self._displayed_sliders.insert(0, True)
nsliders = np.sum(self._displayed_sliders)
self.setMinimumHeight(nsliders * self.SLIDERHEIGHT)
self._resize_axis_labels()
def _trim_sliders(self, number_of_sliders):
"""Trims number of dimensions to a lower number.
Parameters
----------
number_of_sliders : int
New number of sliders.
"""
# remove extra sliders so that only number_of_sliders are left
# remove from the beginning of the list
for _slider_num in range(number_of_sliders, self.nsliders):
self._remove_slider_widget(0)
def _remove_slider_widget(self, index):
"""Remove slider_widget at index, including all sub-widgets.
Parameters
----------
index : int
Index of slider to remove
"""
# remove particular slider
slider_widget = self.slider_widgets.pop(index)
self._displayed_sliders.pop(index)
self.layout().removeWidget(slider_widget)
# As we delete this widget later, callbacks with a weak reference
# to it may successfully grab the instance, but may be incompatible
# with other update state like dims.
self.dims.events.axis_labels.disconnect(slider_widget._pull_label)
slider_widget.deleteLater()
nsliders = np.sum(self._displayed_sliders)
self.setMinimumHeight(int(nsliders * self.SLIDERHEIGHT))
self.dims.last_used = 0
def play(
self,
axis: int = 0,
fps: Optional[float] = None,
loop_mode: Optional[str] = None,
frame_range: Optional[Tuple[int, int]] = None,
):
"""Animate (play) axis.
Parameters
----------
axis : int
Index of axis to play
fps : float
Frames per second for playback. Negative values will play in
reverse. fps == 0 will stop the animation. The view is not
guaranteed to keep up with the requested fps, and may drop frames
at higher fps.
loop_mode : str
Mode for animation playback. Must be one of the following options:
"once": Animation will stop once movie reaches the
max frame (if fps > 0) or the first frame (if fps < 0).
"loop": Movie will return to the first frame
after reaching the last frame, looping until stopped.
"back_and_forth": Movie will loop back and forth until
stopped
frame_range : tuple | list
If specified, will constrain animation to loop [first, last] frames
Raises
------
IndexError
If ``axis`` requested is out of the range of the dims
IndexError
If ``frame_range`` is provided and out of the range of the dims
ValueError
If ``frame_range`` is provided and range[0] >= range[1]
"""
# doing manual check here to avoid issue in StringEnum
# see https://github.com/napari/napari/issues/754
if loop_mode is not None:
_modes = LoopMode.keys()
if loop_mode not in _modes:
raise ValueError(
trans._(
'loop_mode must be one of {_modes}. Got: {loop_mode}',
_modes=_modes,
loop_mode=loop_mode,
)
)
loop_mode = LoopMode(loop_mode)
if axis >= self.dims.ndim:
raise IndexError(trans._('axis argument out of range'))
if self.is_playing:
if self._animation_worker.axis == axis:
self.slider_widgets[axis]._update_play_settings(
fps, loop_mode, frame_range
)
return
else:
self.stop()
# we want to avoid playing a dimension that does not have a slider
# (like X or Y, or a third dimension in volume view.)
if self._displayed_sliders[axis]:
work = self.slider_widgets[axis]._play(fps, loop_mode, frame_range)
if work:
self._animation_worker, self._animation_thread = work
else:
self._animation_worker, self._animation_thread = None, None
else:
warnings.warn(
trans._(
'Refusing to play a hidden axis',
deferred=True,
)
)
@Slot()
def stop(self):
"""Stop axis animation"""
if self._animation_worker is not None:
# Thread will be stop by the worker
self._animation_worker._stop()
@Slot()
def cleaned_worker(self):
self._animation_thread = None
self._animation_worker = None
self.enable_play()
@property
def is_playing(self):
"""Return True if any axis is currently animated."""
try:
return (
self._animation_thread and self._animation_thread.isRunning()
)
except RuntimeError as e: # pragma: no cover
if (
"wrapped C/C++ object of type" not in e.args[0]
and "Internal C++ object" not in e.args[0]
):
# checking if threat is partially deleted. Otherwise
# reraise exception. For more details see:
# https://github.com/napari/napari/pull/5499
raise
return False
def _set_frame(self, axis, frame):
"""Safely tries to set `axis` to the requested `point`.
This function is debounced: if the previous frame has not yet drawn to
the canvas, it will simply do nothing. If the timer plays faster than
the canvas can draw, this will drop the intermediate frames, keeping
the effective frame rate constant even if the canvas cannot keep up.
"""
if self._play_ready:
# disable additional point advance requests until this one draws
self._play_ready = False
self.dims.set_current_step(axis, frame)
def enable_play(self, *args):
# this is mostly here to connect to the main SceneCanvas.events.draw
# event in the qt_viewer
self._play_ready = True
def closeEvent(self, event):
[w.deleteLater() for w in self.slider_widgets]
self.deleteLater()
event.accept()
napari-0.5.0a1/napari/_qt/widgets/qt_dims_slider.py 0000664 0000000 0000000 00000067676 14370413656 0022326 0 ustar 00root root 0000000 0000000 from typing import Optional, Tuple
from weakref import ref
import numpy as np
from qtpy.QtCore import QObject, Qt, QThread, QTimer, Signal, Slot
from qtpy.QtGui import QIntValidator
from qtpy.QtWidgets import (
QApplication,
QCheckBox,
QComboBox,
QDoubleSpinBox,
QFormLayout,
QFrame,
QHBoxLayout,
QLabel,
QLineEdit,
QPushButton,
QWidget,
)
from superqt import ensure_object_thread
from napari._qt.dialogs.qt_modal import QtPopup
from napari._qt.qthreading import _new_worker_qthread
from napari._qt.widgets.qt_scrollbar import ModifiedScrollBar
from napari.settings import get_settings
from napari.settings._constants import LoopMode
from napari.utils.events.event_utils import connect_setattr_value
from napari.utils.translations import trans
class QtDimSliderWidget(QWidget):
"""Compound widget to hold the label, slider and play button for an axis.
These will usually be instantiated in the QtDims._create_sliders method.
This widget *must* be instantiated with a parent QtDims.
"""
axis_label_changed = Signal(int, str) # axis, label
fps_changed = Signal(float)
mode_changed = Signal(str)
range_changed = Signal(tuple)
play_started = Signal()
play_stopped = Signal()
def __init__(self, parent: QWidget, axis: int) -> None:
super().__init__(parent=parent)
self.axis = axis
self.qt_dims = parent
self.dims = parent.dims
self.axis_label = None
self.slider = None
self.play_button = None
self.curslice_label = QLineEdit(self)
self.curslice_label.setToolTip(
trans._('Current slice for axis {axis}', axis=axis)
)
# if we set the QIntValidator to actually reflect the range of the data
# then an invalid (i.e. too large) index doesn't actually trigger the
# editingFinished event (the user is expected to change the value)...
# which is confusing to the user, so instead we use an IntValidator
# that makes sure the user can only enter integers, but we do our own
# value validation in self.change_slice
self.curslice_label.setValidator(QIntValidator(0, 999999))
self.curslice_label.editingFinished.connect(self._set_slice_from_label)
self.totslice_label = QLabel(self)
self.totslice_label.setToolTip(
trans._('Total slices for axis {axis}', axis=axis)
)
self.curslice_label.setObjectName('slice_label')
self.totslice_label.setObjectName('slice_label')
sep = QFrame(self)
sep.setFixedSize(1, 14)
sep.setObjectName('slice_label_sep')
settings = get_settings()
self._fps = settings.application.playback_fps
connect_setattr_value(
settings.application.events.playback_fps, self, "fps"
)
self._minframe = None
self._maxframe = None
self._loop_mode = settings.application.playback_mode
connect_setattr_value(
settings.application.events.playback_mode, self, "loop_mode"
)
layout = QHBoxLayout()
self._create_axis_label_widget()
self._create_range_slider_widget()
self._create_play_button_widget()
layout.addWidget(self.axis_label)
layout.addWidget(self.play_button)
layout.addWidget(self.slider, stretch=1)
layout.addWidget(self.curslice_label)
layout.addWidget(sep)
layout.addWidget(self.totslice_label)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(2)
layout.setAlignment(Qt.AlignmentFlag.AlignVCenter)
self.setLayout(layout)
self.dims.events.axis_labels.connect(self._pull_label)
def _set_slice_from_label(self):
"""Update the dims point based on the curslice_label."""
# On teardown some tests fail on OSX with an `IndexError`
try:
max_allowed = self.dims.nsteps[self.axis] - 1
except IndexError:
return
val = int(self.curslice_label.text())
if val > max_allowed:
val = max_allowed
self.curslice_label.setText(str(val))
self.curslice_label.clearFocus()
self.qt_dims.setFocus()
self.dims.set_current_step(self.axis, val)
def _create_axis_label_widget(self):
"""Create the axis label widget which accompanies its slider."""
label = QLineEdit(self)
label.setObjectName('axis_label') # needed for _update_label
label.setText(self.dims.axis_labels[self.axis])
label.home(False)
label.setToolTip(trans._('Edit to change axis label'))
label.setAcceptDrops(False)
label.setEnabled(True)
label.setAlignment(Qt.AlignmentFlag.AlignRight)
label.setContentsMargins(0, 0, 2, 0)
label.textChanged.connect(self._update_label)
label.editingFinished.connect(self._clear_label_focus)
self.axis_label = label
def _value_changed(self, value):
"""Slider changed to this new value.
We split this out as a separate function for perfmon.
"""
self.dims.set_current_step(self.axis, value)
def _create_range_slider_widget(self):
"""Creates a range slider widget for a given axis."""
# Set the maximum values of the range slider to be one step less than
# the range of the layer as otherwise the slider can move beyond the
# shape of the layer as the endpoint is included
slider = ModifiedScrollBar(Qt.Orientation.Horizontal)
slider.setFocusPolicy(Qt.FocusPolicy.NoFocus)
slider.setMinimum(0)
slider.setMaximum(self.dims.nsteps[self.axis] - 1)
slider.setSingleStep(1)
slider.setPageStep(1)
slider.setValue(self.dims.current_step[self.axis])
# Listener to be used for sending events back to model:
slider.valueChanged.connect(self._value_changed)
def slider_focused_listener():
self.dims.last_used = self.axis
# linking focus listener to the last used:
slider.sliderPressed.connect(slider_focused_listener)
self.slider = slider
def _create_play_button_widget(self):
"""Creates the actual play button, which has the modal popup."""
self.play_button = QtPlayButton(
self.qt_dims, self.axis, fps=self._fps, mode=self._loop_mode
)
self.play_button.setToolTip(
trans._('Right click on button for playback setting options.')
)
self.play_button.mode_combo.currentTextChanged.connect(
lambda x: self.__class__.loop_mode.fset(
self, LoopMode(x.replace(' ', '_'))
)
)
def fps_listener(*args):
fps = self.play_button.fpsspin.value()
fps *= -1 if self.play_button.reverse_check.isChecked() else 1
self.__class__.fps.fset(self, fps)
self.play_button.fpsspin.editingFinished.connect(fps_listener)
self.play_button.reverse_check.stateChanged.connect(fps_listener)
self.play_stopped.connect(self.play_button._handle_stop)
self.play_started.connect(self.play_button._handle_start)
def _pull_label(self):
"""Updates the label LineEdit from the dims model."""
label = self.dims.axis_labels[self.axis]
self.axis_label.setText(label)
self.axis_label_changed.emit(self.axis, label)
def _update_label(self):
"""Update dimension slider label."""
with self.dims.events.axis_labels.blocker():
self.dims.set_axis_label(self.axis, self.axis_label.text())
self.axis_label_changed.emit(self.axis, self.axis_label.text())
def _clear_label_focus(self):
"""Clear focus from dimension slider label."""
self.axis_label.clearFocus()
self.qt_dims.setFocus()
def _update_range(self):
"""Updates range for slider."""
displayed_sliders = self.qt_dims._displayed_sliders
nsteps = self.dims.nsteps[self.axis] - 1
if nsteps == 0:
displayed_sliders[self.axis] = False
self.qt_dims.last_used = 0
self.hide()
else:
if (
not displayed_sliders[self.axis]
and self.axis not in self.dims.displayed
):
displayed_sliders[self.axis] = True
self.last_used = self.axis
self.show()
self.slider.setMinimum(0)
self.slider.setMaximum(nsteps)
self.slider.setSingleStep(1)
self.slider.setPageStep(1)
self.slider.setValue(self.dims.current_step[self.axis])
self.totslice_label.setText(str(nsteps))
self.totslice_label.setAlignment(Qt.AlignmentFlag.AlignLeft)
self._update_slice_labels()
def _update_slider(self):
"""Update dimension slider."""
self.slider.setValue(self.dims.current_step[self.axis])
self._update_slice_labels()
def _update_slice_labels(self):
"""Update slice labels to match current dimension slider position."""
self.curslice_label.setText(str(self.dims.current_step[self.axis]))
self.curslice_label.setAlignment(Qt.AlignmentFlag.AlignRight)
@property
def fps(self):
"""Frames per second for animation."""
return self._fps
@fps.setter
def fps(self, value):
"""Frames per second for animation.
Parameters
----------
value : float
Frames per second for animation.
"""
self._fps = value
self.play_button.fpsspin.setValue(abs(value))
self.play_button.reverse_check.setChecked(value < 0)
self.fps_changed.emit(value)
@property
def loop_mode(self):
"""Loop mode for animation.
Loop mode enumeration napari._qt._constants.LoopMode
Available options for the loop mode string enumeration are:
- LoopMode.ONCE
Animation will stop once movie reaches the max frame
(if fps > 0) or the first frame (if fps < 0).
- LoopMode.LOOP
Movie will return to the first frame after reaching
the last frame, looping continuously until stopped.
- LoopMode.BACK_AND_FORTH
Movie will loop continuously until stopped,
reversing direction when the maximum or minimum frame
has been reached.
"""
return self._loop_mode
@loop_mode.setter
def loop_mode(self, value):
"""Loop mode for animation.
Parameters
----------
value : napari._qt._constants.LoopMode
Loop mode for animation.
Available options for the loop mode string enumeration are:
- LoopMode.ONCE
Animation will stop once movie reaches the max frame
(if fps > 0) or the first frame (if fps < 0).
- LoopMode.LOOP
Movie will return to the first frame after reaching
the last frame, looping continuously until stopped.
- LoopMode.BACK_AND_FORTH
Movie will loop continuously until stopped,
reversing direction when the maximum or minimum frame
has been reached.
"""
value = LoopMode(value)
self._loop_mode = value
self.play_button.mode_combo.setCurrentText(
str(value).replace('_', ' ')
)
self.mode_changed.emit(str(value))
@property
def frame_range(self):
"""Frame range for animation, as (minimum_frame, maximum_frame)."""
frame_range = (self._minframe, self._maxframe)
frame_range = frame_range if any(frame_range) else None
return frame_range
@frame_range.setter
def frame_range(self, value):
"""Frame range for animation, as (minimum_frame, maximum_frame).
Parameters
----------
value : tuple(int, int)
Frame range as tuple/list with range (minimum_frame, maximum_frame)
"""
if not isinstance(value, (tuple, list, type(None))):
raise TypeError(
trans._('frame_range value must be a list or tuple')
)
if value and len(value) != 2:
raise ValueError(trans._('frame_range must have a length of 2'))
if value is None:
value = (None, None)
self._minframe, self._maxframe = value
self.range_changed.emit(tuple(value))
def _update_play_settings(self, fps, loop_mode, frame_range):
"""Update settings for animation.
Parameters
----------
fps : float
Frames per second to play the animation.
loop_mode : napari._qt._constants.LoopMode
Loop mode for animation.
Available options for the loop mode string enumeration are:
- LoopMode.ONCE
Animation will stop once movie reaches the max frame
(if fps > 0) or the first frame (if fps < 0).
- LoopMode.LOOP
Movie will return to the first frame after reaching
the last frame, looping continuously until stopped.
- LoopMode.BACK_AND_FORTH
Movie will loop continuously until stopped,
reversing direction when the maximum or minimum frame
has been reached.
frame_range : tuple(int, int)
Frame range as tuple/list with range (minimum_frame, maximum_frame)
"""
if fps is not None:
self.fps = fps
if loop_mode is not None:
self.loop_mode = loop_mode
if frame_range is not None:
self.frame_range = frame_range
def _play(
self,
fps: Optional[float] = None,
loop_mode: Optional[str] = None,
frame_range: Optional[Tuple[int, int]] = None,
):
"""Animate (play) axis. Same API as QtDims.play()
Putting the AnimationWorker logic here makes it easier to call
QtDims.play(axis), or hit the keybinding, and have each axis remember
it's own settings (fps, mode, etc...).
Parameters
----------
fps : float
Frames per second for animation.
loop_mode : napari._qt._constants.LoopMode
Loop mode for animation.
Available options for the loop mode string enumeration are:
- LoopMode.ONCE
Animation will stop once movie reaches the max frame
(if fps > 0) or the first frame (if fps < 0).
- LoopMode.LOOP
Movie will return to the first frame after reaching
the last frame, looping continuously until stopped.
- LoopMode.BACK_AND_FORTH
Movie will loop continuously until stopped,
reversing direction when the maximum or minimum frame
has been reached.
frame_range : tuple(int, int)
Frame range as tuple/list with range (minimum_frame, maximum_frame)
"""
# having this here makes sure that using the QtDims.play() API
# keeps the play preferences synchronized with the play_button.popup
self._update_play_settings(fps, loop_mode, frame_range)
# setting fps to 0 just stops the animation
if fps == 0:
return
worker, thread = _new_worker_qthread(
AnimationWorker,
self,
_start_thread=True,
_connect={'frame_requested': self.qt_dims._set_frame},
)
thread.finished.connect(self.qt_dims.cleaned_worker)
thread.finished.connect(self.play_stopped)
self.play_started.emit()
return worker, thread
class QtCustomDoubleSpinBox(QDoubleSpinBox):
"""Custom Spinbox that emits an additional editingFinished signal whenever
the valueChanged event is emitted AND the left mouse button is down.
The original use case here was the FPS spinbox in the play button, where
hooking to the actual valueChanged event is undesirable, because if the
user clears the LineEdit to type, for example, "0.5", then play back
will temporarily pause when "0" is typed (if the animation is currently
running). However, the editingFinished event ignores mouse click events on
the spin buttons. This subclass class triggers an event both during
editingFinished and when the user clicks on the spin buttons.
"""
def __init__(self, *args, **kwargs) -> None:
super().__init__(*args, *kwargs)
self.valueChanged.connect(self.custom_change_event)
def custom_change_event(self, value):
"""Emits editingFinished if valueChanged AND left mouse button is down.
(i.e. when the user clicks on the spin buttons)
Paramters
---------
value : float
The value of this custom double spin box.
"""
if QApplication.mouseButtons() & Qt.MouseButton.LeftButton:
self.editingFinished.emit()
def textFromValue(self, value):
"""This removes the decimal places if the float is an integer.
Parameters
----------
value : float
The value of this custom double spin box.
"""
if value.is_integer():
value = int(value)
return str(value)
def keyPressEvent(self, event):
"""Handle key press event for the dimension slider spinbox.
Parameters
----------
event : qtpy.QtCore.QKeyEvent
Event from the Qt context.
"""
# this is here to intercept Return/Enter keys when editing the FPS
# SpinBox. We WANT the return key to close the popup normally,
# but if the user is editing the FPS spinbox, we simply want to
# register the change and lose focus on the lineEdit, in case they
# want to make an additional change (without reopening the popup)
if event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter):
self.editingFinished.emit()
self.clearFocus()
return
super().keyPressEvent(event)
class QtPlayButton(QPushButton):
"""Play button, included in the DimSliderWidget, to control playback
the button also owns the QtModalPopup that controls the playback settings.
"""
play_requested = Signal(int) # axis, fps
def __init__(
self, qt_dims, axis, reverse=False, fps=10, mode=LoopMode.LOOP
) -> None:
super().__init__()
self.qt_dims_ref = ref(qt_dims)
self.axis = axis
self.reverse = reverse
self.fps = fps
self.mode = mode
self.setProperty('reverse', str(reverse)) # for styling
self.setProperty('playing', 'False') # for styling
# build popup modal form
self.popup = QtPopup(self)
form_layout = QFormLayout()
self.popup.frame.setLayout(form_layout)
fpsspin = QtCustomDoubleSpinBox(self.popup)
fpsspin.setObjectName("fpsSpinBox")
fpsspin.setAlignment(Qt.AlignmentFlag.AlignCenter)
fpsspin.setValue(self.fps)
if hasattr(fpsspin, 'setStepType'):
# this was introduced in Qt 5.12. Totally optional, just nice.
fpsspin.setStepType(QDoubleSpinBox.AdaptiveDecimalStepType)
fpsspin.setMaximum(500)
fpsspin.setMinimum(0)
form_layout.insertRow(
0,
QLabel(trans._('frames per second:'), parent=self.popup),
fpsspin,
)
self.fpsspin = fpsspin
revcheck = QCheckBox(self.popup)
revcheck.setObjectName("playDirectionCheckBox")
form_layout.insertRow(
1, QLabel(trans._('play direction:'), parent=self.popup), revcheck
)
self.reverse_check = revcheck
mode_combo = QComboBox(self.popup)
mode_combo.addItems([str(i).replace('_', ' ') for i in LoopMode])
form_layout.insertRow(
2, QLabel(trans._('play mode:'), parent=self.popup), mode_combo
)
mode_combo.setCurrentText(str(self.mode).replace('_', ' '))
self.mode_combo = mode_combo
def mouseReleaseEvent(self, event):
"""Show popup for right-click, toggle animation for right click.
Parameters
----------
event : qtpy.QtCore.QMouseEvent
Event from the qt context.
"""
# using this instead of self.customContextMenuRequested.connect and
# clicked.connect because the latter was not sending the
# rightMouseButton release event.
if event.button() == Qt.MouseButton.RightButton:
self.popup.show_above_mouse()
elif event.button() == Qt.MouseButton.LeftButton:
self._on_click()
def _on_click(self):
"""Toggle play/stop animation control."""
qt_dims = self.qt_dims_ref()
if not qt_dims: # pragma: no cover
return
if self.property('playing') == "True":
return qt_dims.stop()
self.play_requested.emit(self.axis)
def _handle_start(self):
"""On animation start, set playing property to True & update style."""
self.setProperty('playing', 'True')
self.style().unpolish(self)
self.style().polish(self)
def _handle_stop(self):
"""On animation stop, set playing property to False & update style."""
self.setProperty('playing', 'False')
self.style().unpolish(self)
self.style().polish(self)
class AnimationWorker(QObject):
"""A thread to keep the animation timer independent of the main event loop.
This prevents mouseovers and other events from causing animation lag. See
QtDims.play() for public-facing docstring.
"""
frame_requested = Signal(int, int) # axis, point
finished = Signal()
started = Signal()
def __init__(self, slider) -> None:
# FIXME there are attributes defined outsid of __init__.
super().__init__()
self._interval = 1
self.slider = slider
self.dims = slider.dims
self.axis = slider.axis
self.loop_mode = slider.loop_mode
self.timer = QTimer()
slider.fps_changed.connect(self.set_fps)
slider.mode_changed.connect(self.set_loop_mode)
slider.range_changed.connect(self.set_frame_range)
self.set_fps(self.slider.fps)
self.set_frame_range(slider.frame_range)
# after dims.set_current_step is called, it will emit a dims.events.current_step()
# we use this to update this threads current frame (in case it
# was some other event that updated the axis)
self.dims.events.current_step.connect(self._on_axis_changed)
self.current = max(self.dims.current_step[self.axis], self.min_point)
self.current = min(self.current, self.max_point)
self.timer.setSingleShot(True)
self.timer.timeout.connect(self.advance)
@property
def interval(self):
return self._interval
@interval.setter
def interval(self, value):
self._interval = value
self.timer.setInterval(int(self._interval))
@Slot()
def work(self):
"""Play the animation."""
# if loop_mode is once and we are already on the last frame,
# return to the first frame... (so the user can keep hitting once)
if self.loop_mode == LoopMode.ONCE:
if self.step > 0 and self.current >= self.max_point - 1:
self.frame_requested.emit(self.axis, self.min_point)
elif self.step < 0 and self.current <= self.min_point + 1:
self.frame_requested.emit(self.axis, self.max_point)
self.timer.start()
else:
# immediately advance one frame
self.advance()
self.started.emit()
@ensure_object_thread
def _stop(self):
"""Stop the animation."""
if self.timer.isActive():
self.timer.stop()
self.finish()
@Slot(float)
def set_fps(self, fps):
"""Set the frames per second value for the animation.
Parameters
----------
fps : float
Frames per second for the animation.
"""
if fps == 0:
return self.finish()
self.step = 1 if fps > 0 else -1 # negative fps plays in reverse
self.interval = 1000 / abs(fps)
@Slot(tuple)
def set_frame_range(self, frame_range):
"""Frame range for animation, as (minimum_frame, maximum_frame).
Parameters
----------
frame_range : tuple(int, int)
Frame range as tuple/list with range (minimum_frame, maximum_frame)
"""
self.dimsrange = (0, self.dims.nsteps[self.axis], 1)
if frame_range is not None:
if frame_range[0] >= frame_range[1]:
raise ValueError(
trans._("frame_range[0] must be <= frame_range[1]")
)
if frame_range[0] < self.dimsrange[0]:
raise IndexError(trans._("frame_range[0] out of range"))
if frame_range[1] * self.dimsrange[2] >= self.dimsrange[1]:
raise IndexError(trans._("frame_range[1] out of range"))
self.frame_range = frame_range
if self.frame_range is not None:
self.min_point, self.max_point = self.frame_range
else:
self.min_point = 0
self.max_point = int(
np.floor(self.dimsrange[1] - self.dimsrange[2])
)
self.max_point += 1 # range is inclusive
@Slot(str)
def set_loop_mode(self, mode):
"""Set the loop mode for the animation.
Parameters
----------
mode : str
Loop mode for animation.
Available options for the loop mode string enumeration are:
- LoopMode.ONCE
Animation will stop once movie reaches the max frame
(if fps > 0) or the first frame (if fps < 0).
- LoopMode.LOOP
Movie will return to the first frame after reaching
the last frame, looping continuously until stopped.
- LoopMode.BACK_AND_FORTH
Movie will loop continuously until stopped,
reversing direction when the maximum or minimum frame
has been reached.
"""
self.loop_mode = LoopMode(mode)
@Slot()
def advance(self):
"""Advance the current frame in the animation.
Takes dims scale into account and restricts the animation to the
requested frame_range, if entered.
"""
self.current += self.step * self.dimsrange[2]
if self.current < self.min_point:
if (
self.loop_mode == LoopMode.BACK_AND_FORTH
): # 'loop_back_and_forth'
self.step *= -1
self.current = self.min_point + self.step * self.dimsrange[2]
elif self.loop_mode == LoopMode.LOOP: # 'loop'
self.current = self.max_point + self.current - self.min_point
else: # loop_mode == 'once'
return self.finish()
elif self.current >= self.max_point:
if (
self.loop_mode == LoopMode.BACK_AND_FORTH
): # 'loop_back_and_forth'
self.step *= -1
self.current = (
self.max_point + 2 * self.step * self.dimsrange[2]
)
elif self.loop_mode == LoopMode.LOOP: # 'loop'
self.current = self.min_point + self.current - self.max_point
else: # loop_mode == 'once'
return self.finish()
with self.dims.events.current_step.blocker(self._on_axis_changed):
self.frame_requested.emit(self.axis, self.current)
self.timer.start()
def finish(self):
"""Emit the finished event signal."""
self.finished.emit()
def _on_axis_changed(self):
"""Update the current frame if the axis has changed."""
# slot for external events to update the current frame
self.current = self.dims.current_step[self.axis]
def moveToThread(self, thread: QThread):
"""Move the animation to a given thread.
Parameters
----------
thread : QThread
The thread to move the animation to.
"""
super().moveToThread(thread)
self.timer.moveToThread(thread)
napari-0.5.0a1/napari/_qt/widgets/qt_dims_sorter.py 0000664 0000000 0000000 00000006076 14370413656 0022345 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING, Tuple, Union
import numpy as np
from qtpy.QtWidgets import QGridLayout, QLabel, QWidget
from napari._qt.containers import QtListView
from napari._qt.widgets.qt_tooltip import QtToolTipLabel
from napari.components import Dims
from napari.utils.events import SelectableEventedList
from napari.utils.translations import trans
if TYPE_CHECKING:
from napari.viewer import Viewer
class AxisModel:
"""View of an axis within a dims model keeping track of axis names."""
def __init__(self, dims: Dims, axis: int) -> None:
self.dims = dims
self.axis = axis
def __hash__(self) -> int:
return id(self)
def __str__(self) -> str:
return repr(self)
def __repr__(self) -> str:
return self.dims.axis_labels[self.axis]
def __eq__(self, other: Union[int, str]) -> bool:
if isinstance(other, int):
return self.axis == other
else:
return repr(self) == other
def set_dims_order(dims: Dims, order: Tuple[int, ...]):
if type(order[0]) == AxisModel:
order = [a.axis for a in order]
dims.order = order
def _array_in_range(arr: np.ndarray, low: int, high: int) -> bool:
return (arr >= low) & (arr < high)
def move_indices(axes_list: SelectableEventedList, order: Tuple[int, ...]):
with axes_list.events.blocker_all():
if tuple(axes_list) == tuple(order):
return
axes = [a.axis for a in axes_list]
ax_to_existing_position = {a: ix for ix, a in enumerate(axes)}
move_list = np.asarray(
[(ax_to_existing_position[order[i]], i) for i in range(len(order))]
)
for src, dst in move_list:
axes_list.move(src, dst)
move_list[_array_in_range(move_list[:, 0], dst, src)] += 1
# remove the elements from the back if order has changed length
while len(axes_list) > len(order):
axes_list.pop()
class QtDimsSorter(QWidget):
"""
Modified from:
https://github.com/jni/zarpaint/blob/main/zarpaint/_dims_chooser.py
"""
def __init__(self, viewer: 'Viewer', parent=None) -> None:
super().__init__(parent=parent)
dims = viewer.dims
root = SelectableEventedList(
[AxisModel(dims, dims.order[i]) for i in range(dims.ndim)]
)
root.events.reordered.connect(
lambda event: set_dims_order(dims, event.value)
)
dims.events.order.connect(
lambda event: move_indices(root, event.value)
)
view = QtListView(root)
view.setSizeAdjustPolicy(QtListView.AdjustToContents)
self.axes_list = root
layout = QGridLayout()
self.setLayout(layout)
widget_tooltip = QtToolTipLabel(self)
widget_tooltip.setObjectName('help_label')
widget_tooltip.setToolTip(trans._('Drag dimensions to reorder.'))
widget_title = QLabel(trans._('Dims. Ordering'), self)
self.layout().addWidget(widget_title, 0, 0)
self.layout().addWidget(widget_tooltip, 0, 1)
self.layout().addWidget(view, 1, 0)
napari-0.5.0a1/napari/_qt/widgets/qt_extension2reader.py 0000664 0000000 0000000 00000024766 14370413656 0023302 0 ustar 00root root 0000000 0000000 import os
from qtpy.QtCore import Qt, Signal
from qtpy.QtWidgets import (
QComboBox,
QGridLayout,
QHBoxLayout,
QLabel,
QLineEdit,
QPushButton,
QSizePolicy,
QTableWidget,
QTableWidgetItem,
QVBoxLayout,
QWidget,
)
from napari.plugins.utils import (
get_all_readers,
get_filename_patterns_for_reader,
get_potential_readers,
)
from napari.settings import get_settings
from napari.utils.translations import trans
class Extension2ReaderTable(QWidget):
"""Table showing extension to reader mappings with removal button.
Widget presented in preferences-plugin dialog."""
valueChanged = Signal(int)
def __init__(
self, parent=None, npe2_readers=None, npe1_readers=None
) -> None:
super().__init__(parent=parent)
npe2, npe1 = get_all_readers()
if npe2_readers is None:
npe2_readers = npe2
if npe1_readers is None:
npe1_readers = npe1
self._npe2_readers = npe2_readers
self._npe1_readers = npe1_readers
self._table = QTableWidget()
self._table.setShowGrid(False)
self._set_up_table()
self._edit_row = self._make_new_preference_row()
self._populate_table()
instructions = QLabel(
trans._(
'Enter a filename pattern to associate with a reader e.g. "*.tif" for all TIFF files. Available readers will be filtered to those compatible with your pattern. Hover over a reader to see what patterns it accepts. \n\nYou can save a preference for a specific folder by listing the folder name with a "/" at the end (for example, "/test_images/"). \n\nFor documentation on valid filename patterns, see https://docs.python.org/3/library/fnmatch.html'
)
)
instructions.setWordWrap(True)
instructions.setOpenExternalLinks(True)
layout = QVBoxLayout()
instructions.setSizePolicy(
QSizePolicy.MinimumExpanding, QSizePolicy.Expanding
)
layout.addWidget(instructions)
layout.addWidget(self._edit_row)
layout.addWidget(self._table)
self.setLayout(layout)
def _set_up_table(self):
"""Add table columns and headers, define styling"""
self._fn_pattern_col = 0
self._reader_col = 1
header_strs = [trans._('Filename Pattern'), trans._('Reader Plugin')]
self._table.setColumnCount(2)
self._table.setColumnWidth(self._fn_pattern_col, 200)
self._table.setColumnWidth(self._reader_col, 200)
self._table.verticalHeader().setVisible(False)
self._table.setMinimumHeight(120)
self._table.horizontalHeader().setStyleSheet(
'border-bottom: 2px solid white;'
)
self._table.setHorizontalHeaderLabels(header_strs)
self._table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
def _populate_table(self):
"""Add row for each extension to reader mapping in settings"""
fnpattern2reader = get_settings().plugins.extension2reader
if len(fnpattern2reader) > 0:
for fn_pattern, plugin_name in fnpattern2reader.items():
self._add_new_row(fn_pattern, plugin_name)
else:
# Display that there are no filename patterns with reader associations
self._display_no_preferences_found()
def _make_new_preference_row(self):
"""Make row for user to add a new filename pattern assignment"""
edit_row_widget = QWidget()
edit_row_widget.setLayout(QGridLayout())
edit_row_widget.layout().setContentsMargins(0, 0, 0, 0)
self._fn_pattern_edit = QLineEdit()
self._fn_pattern_edit.setPlaceholderText(
trans._("Start typing filename pattern...")
)
self._fn_pattern_edit.textChanged.connect(
self._filter_compatible_readers
)
add_reader_widg = QWidget()
add_reader_widg.setLayout(QHBoxLayout())
add_reader_widg.layout().setContentsMargins(0, 0, 0, 0)
self._new_reader_dropdown = QComboBox()
for i, (plugin_name, display_name) in enumerate(
sorted(dict(self._npe2_readers, **self._npe1_readers).items())
):
self._add_reader_choice(i, plugin_name, display_name)
add_btn = QPushButton(trans._('Add'))
add_btn.setToolTip(trans._('Save reader preference for pattern'))
add_btn.clicked.connect(self._save_new_preference)
add_reader_widg.layout().addWidget(self._new_reader_dropdown)
add_reader_widg.layout().addWidget(add_btn)
edit_row_widget.layout().addWidget(
self._fn_pattern_edit,
0,
0,
)
edit_row_widget.layout().addWidget(add_reader_widg, 0, 1)
return edit_row_widget
def _display_no_preferences_found(self):
self._table.setRowCount(1)
item = QTableWidgetItem(trans._('No filename preferences found.'))
item.setFlags(Qt.ItemFlag.NoItemFlags)
self._table.setItem(self._fn_pattern_col, 0, item)
def _add_reader_choice(self, i, plugin_name, display_name):
"""Add dropdown item for plugin_name with reader pattern tooltip"""
reader_patterns = get_filename_patterns_for_reader(plugin_name)
# TODO: no reader_patterns means directory reader,
# we don't support preference association yet
if not reader_patterns:
return
self._new_reader_dropdown.addItem(display_name, plugin_name)
if '*' in reader_patterns:
tooltip_text = trans._('Accepts all')
else:
reader_patterns_formatted = ', '.join(
sorted(list(reader_patterns))
)
tooltip_text = trans._(
'Accepts: {reader_patterns_formatted}',
reader_patterns_formatted=reader_patterns_formatted,
)
self._new_reader_dropdown.setItemData(
i, tooltip_text, role=Qt.ItemDataRole.ToolTipRole
)
def _filter_compatible_readers(self, new_pattern):
"""Filter reader dropwdown items to those that accept `new_extension`"""
self._new_reader_dropdown.clear()
readers = self._npe2_readers.copy()
to_delete = []
compatible_readers = get_potential_readers(new_pattern)
for plugin_name in readers:
if plugin_name not in compatible_readers:
to_delete.append(plugin_name)
for reader in to_delete:
del readers[reader]
readers.update(self._npe1_readers)
if not readers:
self._new_reader_dropdown.addItem(trans._("None available"))
else:
for i, (plugin_name, display_name) in enumerate(
sorted(readers.items())
):
self._add_reader_choice(i, plugin_name, display_name)
def _save_new_preference(self, event):
"""Save current preference to settings and show in table"""
fn_pattern = self._fn_pattern_edit.text()
reader = self._new_reader_dropdown.currentData()
if not fn_pattern or not reader:
return
# if user types pattern that starts with a . it's probably a file extension so prepend the *
if fn_pattern.startswith('.'):
fn_pattern = f'*{fn_pattern}'
if fn_pattern in get_settings().plugins.extension2reader:
self._edit_existing_preference(fn_pattern, reader)
else:
self._add_new_row(fn_pattern, reader)
get_settings().plugins.extension2reader = {
**get_settings().plugins.extension2reader,
fn_pattern: reader,
}
def _edit_existing_preference(self, fn_pattern, reader):
"""Edit existing extension preference"""
current_reader_label = self.findChild(QLabel, fn_pattern)
if reader in self._npe2_readers:
reader = self._npe2_readers[reader]
current_reader_label.setText(reader)
def _add_new_row(self, fn_pattern, reader):
"""Add new reader preference to table"""
last_row = self._table.rowCount()
if (
last_row == 1
and 'No filename preferences found'
in self._table.item(0, 0).text()
):
self._table.removeRow(0)
last_row = 0
self._table.insertRow(last_row)
item = QTableWidgetItem(fn_pattern)
if fn_pattern.endswith(os.sep):
item.setTextAlignment(Qt.AlignmentFlag.AlignLeft)
item.setFlags(Qt.ItemFlag.NoItemFlags)
self._table.setItem(last_row, self._fn_pattern_col, item)
plugin_widg = QWidget()
# need object name to easily find row
plugin_widg.setObjectName(f'{fn_pattern}')
plugin_widg.setLayout(QHBoxLayout())
plugin_widg.layout().setContentsMargins(0, 0, 0, 0)
if reader in self._npe2_readers:
reader = self._npe2_readers[reader]
plugin_label = QLabel(reader, objectName=fn_pattern)
# need object name to easily work out which button was clicked
remove_btn = QPushButton('X', objectName=fn_pattern)
remove_btn.setFixedWidth(30)
remove_btn.setStyleSheet('margin: 4px;')
remove_btn.setToolTip(
trans._('Remove this filename pattern to reader association')
)
remove_btn.clicked.connect(self.remove_existing_preference)
plugin_widg.layout().addWidget(plugin_label)
plugin_widg.layout().addWidget(remove_btn)
self._table.setCellWidget(last_row, self._reader_col, plugin_widg)
def remove_existing_preference(self, event):
"""Delete extension to reader mapping setting and remove table row"""
pattern_to_remove = self.sender().objectName()
current_settings = get_settings().plugins.extension2reader
# need explicit assignment to new object here for persistence
get_settings().plugins.extension2reader = {
k: v for k, v in current_settings.items() if k != pattern_to_remove
}
for i in range(self._table.rowCount()):
row_widg_name = self._table.cellWidget(
i, self._reader_col
).objectName()
if row_widg_name == pattern_to_remove:
self._table.removeRow(i)
break
if self._table.rowCount() == 0:
self._display_no_preferences_found()
def value(self):
"""Return extension:reader mapping from settings.
Returns
-------
Dict[str, str]
mapping of extension to reader plugin display name
"""
return get_settings().plugins.extension2reader
napari-0.5.0a1/napari/_qt/widgets/qt_highlight_preview.py 0000664 0000000 0000000 00000036111 14370413656 0023514 0 ustar 00root root 0000000 0000000 import numpy as np
from qtpy.QtCore import QSize, Qt, Signal
from qtpy.QtGui import QColor, QIntValidator, QPainter, QPainterPath, QPen
from qtpy.QtWidgets import (
QFrame,
QHBoxLayout,
QLabel,
QLineEdit,
QSlider,
QVBoxLayout,
QWidget,
)
from napari.utils.translations import translator
trans = translator.load()
class QtStar(QFrame):
"""Creates a star for the preview pane in the highlight widget.
Parameters
----------
value : int
The line width of the star.
"""
def __init__(
self,
parent: QWidget = None,
value: int = None,
) -> None:
super().__init__(parent)
self._value = value
def sizeHint(self):
"""Override Qt sizeHint."""
return QSize(100, 100)
def minimumSizeHint(self):
"""Override Qt minimumSizeHint."""
return QSize(100, 100)
def paintEvent(self, e):
"""Paint star on frame."""
qp = QPainter()
qp.begin(self)
self.drawStar(qp)
qp.end()
def value(self):
"""Return value of star widget.
Returns
-------
int
The value of the star widget.
"""
return self._value
def setValue(self, value: int):
"""Set line width value of star widget.
Parameters
----------
value : int
line width value for star
"""
self._value = value
self.update()
def drawStar(self, qp):
"""Draw a star in the preview pane.
Parameters
----------
qp : QPainter object
"""
width = self.rect().width()
height = self.rect().height()
col = QColor(135, 206, 235)
pen = QPen(col, self._value)
pen.setJoinStyle(Qt.PenJoinStyle.MiterJoin)
qp.setPen(pen)
path = QPainterPath()
# draw pentagram
star_center_x = width / 2
star_center_y = height / 2
# make sure the star equal no matter the size of the qframe
radius_outer = width * 0.35 if width < height else height * 0.35
# start at the top point of the star and move counter clockwise to draw the path.
# every other point is the shorter radius (1/(1+golden_ratio)) of the larger radius
golden_ratio = (1 + np.sqrt(5)) / 2
radius_inner = radius_outer / (1 + golden_ratio)
theta_start = np.pi / 2
theta_inc = (2 * np.pi) / 10
for n in range(11):
theta = theta_start + (n * theta_inc)
theta = np.mod(theta, 2 * np.pi)
if np.mod(n, 2) == 0:
# use radius_outer
x = radius_outer * np.cos(theta)
y = radius_outer * np.sin(theta)
else:
# use radius_inner
x = radius_inner * np.cos(theta)
y = radius_inner * np.sin(theta)
x_adj = star_center_x - x
y_adj = star_center_y - y + 3
if n == 0:
path.moveTo(x_adj, y_adj)
else:
path.lineTo(x_adj, y_adj)
qp.drawPath(path)
class QtTriangle(QFrame):
"""Draw the triangle in highlight widget.
Parameters
----------
value : int
Current value of the highlight size.
min_value : int
Minimum value possible for highlight size.
max_value : int
Maximum value possible for highlight size.
"""
valueChanged = Signal(int)
def __init__(
self,
parent: QWidget = None,
value: int = 1,
min_value: int = 1,
max_value: int = 10,
) -> None:
super().__init__(parent)
self._max_value = max_value
self._min_value = min_value
self._value = value
def mousePressEvent(self, event):
"""When mouse is clicked, adjust to new values."""
# set value based on position of event
perc = event.pos().x() / self.rect().width()
value = ((self._max_value - self._min_value) * perc) + self._min_value
self.setValue(value)
def paintEvent(self, e):
"""Paint triangle on frame."""
qp = QPainter()
qp.begin(self)
self.drawTriangle(qp)
perc = (self._value - self._min_value) / (
self._max_value - self._min_value
)
self.drawLine(qp, self.rect().width() * perc)
qp.end()
def sizeHint(self):
"""Override Qt sizeHint."""
return QSize(75, 30)
def minimumSizeHint(self):
"""Override Qt minimumSizeHint."""
return QSize(75, 30)
def drawTriangle(self, qp):
"""Draw triangle.
Parameters
----------
qp : QPainter object
"""
width = self.rect().width()
col = QColor(135, 206, 235)
qp.setPen(QPen(col, 1))
qp.setBrush(col)
path = QPainterPath()
height = 10
path.moveTo(0, height)
path.lineTo(width, height)
path.lineTo(width, 0)
path.closeSubpath()
qp.drawPath(path)
def value(self):
"""Return value of triangle widget.
Returns
-------
int
Current value of triangle widget.
"""
return self._value
def setValue(self, value):
"""Set value for triangle widget.
Parameters
----------
value : int
Value to use for line in triangle widget.
"""
self._value = value
self.update()
def minimum(self):
"""Return minimum value.
Returns
-------
int
Mininum value of triangle widget.
"""
return self._min_value
def maximum(self):
"""Return maximum value.
Returns
-------
int
Maximum value of triangle widget.
"""
return self._max_value
def setMinimum(self, value: int):
"""Set minimum value
Parameters
----------
value : int
Minimum value of triangle.
"""
self._min_value = value
self._value = max(self._value, value)
def setMaximum(self, value: int):
"""Set maximum value.
Parameters
----------
value : int
Maximum value of triangle.
"""
self._max_value = value
self._value = min(self._value, value)
def drawLine(self, qp, value: int):
"""Draw line on triangle indicating value.
Parameters
----------
qp : QPainter object
value : int
Value of highlight thickness.
"""
col = QColor('white')
qp.setPen(QPen(col, 2))
qp.setBrush(col)
path = QPainterPath()
path.moveTo(value, 15)
path.lineTo(value, 0)
path.closeSubpath()
qp.drawPath(path)
self.valueChanged.emit(self._value)
class QtHighlightSizePreviewWidget(QWidget):
"""Creates custom widget to set highlight size.
Parameters
----------
description : str
Text to explain and display on widget.
value : int
Value of highlight size.
min_value : int
Minimum possible value of highlight size.
max_value : int
Maximum possible value of highlight size.
unit : str
Unit of highlight size.
"""
valueChanged = Signal(int)
def __init__(
self,
parent: QWidget = None,
description: str = "",
value: int = 1,
min_value: int = 1,
max_value: int = 10,
unit: str = "px",
) -> None:
super().__init__(parent)
self.setGeometry(300, 300, 125, 110)
self._value = value or self.fontMetrics().height()
self._min_value = min_value
self._max_value = max_value
# Widget
self._lineedit = QLineEdit()
self._description = QLabel(self)
self._unit = QLabel(self)
self._slider = QSlider(Qt.Orientation.Horizontal)
self._triangle = QtTriangle(self)
self._slider_min_label = QLabel(self)
self._slider_max_label = QLabel(self)
self._preview = QtStar(self)
self._preview_label = QLabel(self)
self._validator = QIntValidator(min_value, max_value, self)
# Widgets setup
self._description.setText(description)
self._description.setWordWrap(True)
self._unit.setText(unit)
self._unit.setAlignment(Qt.AlignmentFlag.AlignBottom)
self._lineedit.setValidator(self._validator)
self._lineedit.setAlignment(Qt.AlignmentFlag.AlignRight)
self._lineedit.setAlignment(Qt.AlignmentFlag.AlignBottom)
self._slider_min_label.setText(str(min_value))
self._slider_min_label.setAlignment(Qt.AlignmentFlag.AlignBottom)
self._slider_max_label.setText(str(max_value))
self._slider_max_label.setAlignment(Qt.AlignmentFlag.AlignBottom)
self._slider.setMinimum(min_value)
self._slider.setMaximum(max_value)
self._preview.setValue(value)
self._triangle.setValue(value)
self._triangle.setMinimum(min_value)
self._triangle.setMaximum(max_value)
self._preview_label.setText(trans._("Preview"))
self._preview_label.setAlignment(Qt.AlignmentFlag.AlignHCenter)
self._preview_label.setAlignment(Qt.AlignmentFlag.AlignBottom)
self._preview.setStyleSheet('border: 1px solid white;')
# Signals
self._slider.valueChanged.connect(self._update_value)
self._lineedit.textChanged.connect(self._update_value)
self._triangle.valueChanged.connect(self._update_value)
# Layout
triangle_layout = QHBoxLayout()
triangle_layout.addWidget(self._triangle)
triangle_layout.setContentsMargins(6, 35, 6, 0)
triangle_slider_layout = QVBoxLayout()
triangle_slider_layout.addLayout(triangle_layout)
triangle_slider_layout.setContentsMargins(0, 0, 0, 0)
triangle_slider_layout.addWidget(self._slider)
triangle_slider_layout.setAlignment(Qt.AlignmentFlag.AlignVCenter)
# Bottom row layout
lineedit_layout = QHBoxLayout()
lineedit_layout.addWidget(self._lineedit)
lineedit_layout.setAlignment(Qt.AlignmentFlag.AlignBottom)
bottom_left_layout = QHBoxLayout()
bottom_left_layout.addLayout(lineedit_layout)
bottom_left_layout.addWidget(self._unit)
bottom_left_layout.addWidget(self._slider_min_label)
bottom_left_layout.addLayout(triangle_slider_layout)
bottom_left_layout.addWidget(self._slider_max_label)
bottom_left_layout.setAlignment(Qt.AlignmentFlag.AlignBottom)
left_layout = QVBoxLayout()
left_layout.addWidget(self._description)
left_layout.addLayout(bottom_left_layout)
left_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
preview_label_layout = QHBoxLayout()
preview_label_layout.addWidget(self._preview_label)
preview_label_layout.setAlignment(Qt.AlignmentFlag.AlignHCenter)
preview_layout = QVBoxLayout()
preview_layout.addWidget(self._preview)
preview_layout.addLayout(preview_label_layout)
preview_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
layout = QHBoxLayout()
layout.addLayout(left_layout)
layout.addLayout(preview_layout)
self.setLayout(layout)
self._refresh()
def _update_value(self, value):
"""Update highlight value.
Parameters
----------
value : int
Highlight value.
"""
if value == "":
return
value = int(value)
value = max(min(value, self._max_value), self._min_value)
if value == self._value:
return
self._value = value
self.valueChanged.emit(self._value)
self._refresh()
def _refresh(self):
"""Set every widget value to the new set value."""
self.blockSignals(True)
self._lineedit.setText(str(self._value))
self._slider.setValue(self._value)
self._triangle.setValue(self._value)
self._preview.setValue(self._value)
self.blockSignals(False)
def value(self):
"""Return current value.
Returns
-------
int
Current value of highlight widget.
"""
return self._value
def setValue(self, value):
"""Set new value and update widget.
Parameters
----------
value : int
Highlight value.
"""
self._update_value(value)
self._refresh()
def description(self):
"""Return the description text.
Returns
-------
str
Current text in description.
"""
return self._description.text()
def setDescription(self, text):
"""Set the description text.
Parameters
----------
text : str
Text to use in description box.
"""
self._description.setText(text)
def unit(self):
"""Return highlight value unit text.
Returns
-------
str
Current text in unit text.
"""
return self._unit.text()
def setUnit(self, text):
"""Set highlight value unit.
Parameters
----------
text : str
Text used to describe units.
"""
self._unit.setText(text)
def setMinimum(self, value):
"""Set minimum highlight value for star, triangle, text and slider.
Parameters
----------
value : int
Minimum highlight value.
"""
value = int(value)
if value >= self._max_value:
raise ValueError(
trans._(
"Minimum value must be smaller than {max_value}",
deferred=True,
max_value=self._max_value,
)
)
self._min_value = value
self._slider_min_label.setText(str(value))
self._slider.setMinimum(value)
self._triangle.setMinimum(value)
self._value = max(self._value, self._min_value)
self._refresh()
def minimum(self):
"""Return minimum highlight value.
Returns
-------
int
Minimum value of highlight widget.
"""
return self._min_value
def setMaximum(self, value):
"""Set maximum highlight value.
Parameters
----------
value : int
Maximum highlight value.
"""
value = int(value)
if value <= self._min_value:
raise ValueError(
trans._(
"Maximum value must be larger than {min_value}",
deferred=True,
min_value=self._min_value,
)
)
self._max_value = value
self._slider_max_label.setText(str(value))
self._slider.setMaximum(value)
self._triangle.setMaximum(value)
self._value = min(self._value, self._max_value)
self._refresh()
def maximum(self):
"""Return maximum highlight value.
Returns
-------
int
Maximum value of highlight widget.
"""
return self._max_value
napari-0.5.0a1/napari/_qt/widgets/qt_keyboard_settings.py 0000664 0000000 0000000 00000054467 14370413656 0023542 0 ustar 00root root 0000000 0000000 import contextlib
import re
from collections import OrderedDict
from qtpy.QtCore import QEvent, QPoint, Qt, Signal
from qtpy.QtGui import QKeySequence
from qtpy.QtWidgets import (
QAbstractItemView,
QComboBox,
QHBoxLayout,
QItemDelegate,
QKeySequenceEdit,
QLabel,
QLineEdit,
QMessageBox,
QPushButton,
QTableWidget,
QTableWidgetItem,
QVBoxLayout,
QWidget,
)
from vispy.util import keys
from napari._qt.widgets.qt_message_popup import WarnPopup
from napari.layers import Image, Labels, Points, Shapes, Surface, Vectors
from napari.settings import get_settings
from napari.utils.action_manager import action_manager
from napari.utils.interactions import Shortcut
from napari.utils.translations import trans
# Dict used to format strings returned from converted key press events.
# For example, the ShortcutTranslator returns 'Ctrl' instead of 'Control'.
# In order to be consistent with the code base, the values in KEY_SUBS will
# be subsituted.
KEY_SUBS = {'Ctrl': 'Control'}
class ShortcutEditor(QWidget):
"""Widget to edit keybindings for napari."""
valueChanged = Signal(dict)
VIEWER_KEYBINDINGS = trans._('Viewer key bindings')
def __init__(
self,
parent: QWidget = None,
description: str = "",
value: dict = None,
) -> None:
super().__init__(parent=parent)
# Flag to not run _set_keybinding method after setting special symbols.
# When changing line edit to special symbols, the _set_keybinding
# method will be called again (and breaks) and is not needed.
self._skip = False
layers = [
Image,
Labels,
Points,
Shapes,
Surface,
Vectors,
]
self.key_bindings_strs = OrderedDict()
# widgets
self.layer_combo_box = QComboBox(self)
self._label = QLabel(self)
self._table = QTableWidget(self)
self._table.setSelectionBehavior(QAbstractItemView.SelectItems)
self._table.setSelectionMode(QAbstractItemView.SingleSelection)
self._table.setShowGrid(False)
self._restore_button = QPushButton(trans._("Restore All Keybindings"))
# Set up dictionary for layers and associated actions.
all_actions = action_manager._actions.copy()
self.key_bindings_strs[self.VIEWER_KEYBINDINGS] = {}
for layer in layers:
if len(layer.class_keymap) == 0:
actions = {}
else:
actions = action_manager._get_provider_actions(layer)
for name in actions.keys():
all_actions.pop(name)
self.key_bindings_strs[f"{layer.__name__} layer"] = actions
# Left over actions can go here.
self.key_bindings_strs[self.VIEWER_KEYBINDINGS] = all_actions
# Widget set up
self.layer_combo_box.addItems(list(self.key_bindings_strs))
self.layer_combo_box.currentTextChanged.connect(self._set_table)
self.layer_combo_box.setCurrentText(self.VIEWER_KEYBINDINGS)
self._set_table()
self._label.setText(trans._("Group"))
self._restore_button.clicked.connect(self.restore_defaults)
# layout
hlayout1 = QHBoxLayout()
hlayout1.addWidget(self._label)
hlayout1.addWidget(self.layer_combo_box)
hlayout1.setContentsMargins(0, 0, 0, 0)
hlayout1.setSpacing(20)
hlayout1.addStretch(0)
hlayout2 = QHBoxLayout()
hlayout2.addLayout(hlayout1)
hlayout2.addWidget(self._restore_button)
layout = QVBoxLayout()
layout.addLayout(hlayout2)
layout.addWidget(self._table)
layout.addWidget(
QLabel(
trans._(
"To edit, double-click the keybinding. To unbind a shortcut, use Backspace or Delete. To set Backspace or Delete, first unbind."
)
)
)
self.setLayout(layout)
def restore_defaults(self):
"""Launches dialog to confirm restore choice."""
response = QMessageBox.question(
self,
trans._("Restore Shortcuts"),
trans._("Are you sure you want to restore default shortcuts?"),
QMessageBox.RestoreDefaults | QMessageBox.Cancel,
QMessageBox.RestoreDefaults,
)
if response == QMessageBox.RestoreDefaults:
self._reset_shortcuts()
def _reset_shortcuts(self):
"""Reset shortcuts to default settings."""
get_settings().shortcuts.reset()
for (
action,
shortcuts,
) in get_settings().shortcuts.shortcuts.items():
action_manager.unbind_shortcut(action)
for shortcut in shortcuts:
action_manager.bind_shortcut(action, shortcut)
self._set_table(layer_str=self.layer_combo_box.currentText())
def _set_table(self, layer_str: str = ''):
"""Builds and populates keybindings table.
Parameters
----------
layer_str : str
If layer_str is not empty, then show the specified layers'
keybinding shortcut table.
"""
# Keep track of what is in each column.
self._action_name_col = 0
self._icon_col = 1
self._shortcut_col = 2
self._shortcut_col2 = 3
self._action_col = 4
# Set header strings for table.
header_strs = ['', '', '', '', '']
header_strs[self._action_name_col] = trans._('Action')
header_strs[self._shortcut_col] = trans._('Keybinding')
header_strs[self._shortcut_col2] = trans._('Alternative Keybinding')
# If no layer_str, then set the page to the viewer keybindings page.
if not layer_str:
layer_str = self.VIEWER_KEYBINDINGS
# If rebuilding the table, then need to disconnect the connection made
# previously as well as clear the table contents.
with contextlib.suppress(TypeError, RuntimeError):
self._table.cellChanged.disconnect(self._set_keybinding)
self._table.clearContents()
# Table styling set up.
self._table.horizontalHeader().setStretchLastSection(True)
self._table.horizontalHeader().setStyleSheet(
'border-bottom: 2px solid white;'
)
# Get all actions for the layer.
actions = self.key_bindings_strs[layer_str]
if len(actions) > 0:
# Set up table based on number of actions and needed columns.
self._table.setRowCount(len(actions))
self._table.setColumnCount(5)
# Set up delegate in order to capture keybindings.
self._table.setItemDelegateForColumn(
self._shortcut_col, ShortcutDelegate(self._table)
)
self._table.setItemDelegateForColumn(
self._shortcut_col2, ShortcutDelegate(self._table)
)
self._table.setHorizontalHeaderLabels(header_strs)
self._table.verticalHeader().setVisible(False)
# Hide the column with action names. These are kept here for reference when needed.
self._table.setColumnHidden(self._action_col, True)
# Column set up.
self._table.setColumnWidth(self._action_name_col, 250)
self._table.setColumnWidth(self._shortcut_col, 200)
self._table.setColumnWidth(self._shortcut_col2, 200)
self._table.setColumnWidth(self._icon_col, 50)
# Go through all the actions in the layer and add them to the table.
for row, (action_name, action) in enumerate(actions.items()):
shortcuts = action_manager._shortcuts.get(action_name, [])
# Set action description. Make sure its not selectable/editable.
item = QTableWidgetItem(action.description)
item.setFlags(Qt.ItemFlag.NoItemFlags)
self._table.setItem(row, self._action_name_col, item)
# Create empty item in order to make sure this column is not
# selectable/editable.
item = QTableWidgetItem("")
item.setFlags(Qt.ItemFlag.NoItemFlags)
self._table.setItem(row, self._icon_col, item)
# Set the shortcuts in table.
item_shortcut = QTableWidgetItem(
Shortcut(list(shortcuts)[0]).platform if shortcuts else ""
)
self._table.setItem(row, self._shortcut_col, item_shortcut)
item_shortcut2 = QTableWidgetItem(
Shortcut(list(shortcuts)[1]).platform
if len(shortcuts) > 1
else ""
)
self._table.setItem(row, self._shortcut_col2, item_shortcut2)
# action_name is stored in the table to use later, but is not shown on dialog.
item_action = QTableWidgetItem(action_name)
self._table.setItem(row, self._action_col, item_action)
# If a cell is changed, run .set_keybinding.
self._table.cellChanged.connect(self._set_keybinding)
else:
# Display that there are no actions for this layer.
self._table.setRowCount(1)
self._table.setColumnCount(4)
self._table.setHorizontalHeaderLabels(header_strs)
self._table.verticalHeader().setVisible(False)
self._table.setColumnHidden(self._action_col, True)
item = QTableWidgetItem(trans._('No key bindings'))
item.setFlags(Qt.ItemFlag.NoItemFlags)
self._table.setItem(0, 0, item)
def _get_layer_actions(self):
current_layer_text = self.layer_combo_box.currentText()
layer_actions = self.key_bindings_strs[current_layer_text]
actions_all = layer_actions.copy()
if current_layer_text is not self.VIEWER_KEYBINDINGS:
viewer_actions = self.key_bindings_strs[self.VIEWER_KEYBINDINGS]
actions_all.update(viewer_actions)
return actions_all
def _restore_shortcuts(self, row):
action_name = self._table.item(row, self._action_col).text()
shortcuts = action_manager._shortcuts.get(action_name, [])
with lock_keybind_update(self):
self._table.item(row, self._shortcut_col).setText(
Shortcut(list(shortcuts)[0]).platform if shortcuts else ""
)
self._table.item(row, self._shortcut_col2).setText(
Shortcut(list(shortcuts)[1]).platform
if len(shortcuts) > 1
else ""
)
def _mark_conflicts(self, new_shortcut, row) -> bool:
# Go through all layer actions to determine if the new shortcut is already here.
current_action = self._table.item(row, self._action_col).text()
actions_all = self._get_layer_actions()
current_item = self._table.currentItem()
for row1, (action_name, action) in enumerate(actions_all.items()):
shortcuts = action_manager._shortcuts.get(action_name, [])
if new_shortcut not in shortcuts:
continue
# Shortcut is here (either same action or not), don't replace in settings.
if action_name != current_action:
# the shortcut is saved to a different action
# show warning symbols
self._show_warning_icons([row, row1])
# show warning message
message = trans._(
"The keybinding {new_shortcut} is already assigned to {action_description}; change or clear that shortcut before assigning {new_shortcut} to this one.",
new_shortcut=new_shortcut,
action_description=action.description,
)
self._show_warning(new_shortcut, action, row, message)
self._restore_shortcuts(row)
self._cleanup_warning_icons([row, row1])
return False
else:
# This shortcut was here. Reformat and reset text.
format_shortcut = Shortcut(new_shortcut).platform
with lock_keybind_update(self):
current_item.setText(format_shortcut)
return True
def _show_bind_shortcut_error(
self, current_action, current_shortcuts, row, new_shortcut
):
action_manager._shortcuts[current_action] = []
# need to rebind the old shortcut
action_manager.unbind_shortcut(current_action)
for short in current_shortcuts:
action_manager.bind_shortcut(current_action, short)
# Show warning message to let user know this shortcut is invalid.
self._show_warning_icons([row])
message = trans._(
"{new_shortcut} is not a valid keybinding.",
new_shortcut=new_shortcut,
)
self._show_warning(new_shortcut, current_action, row, message)
self._cleanup_warning_icons([row])
self._restore_shortcuts(row)
def _set_keybinding(self, row, col):
"""Checks the new keybinding to determine if it can be set.
Parameters
----------
row : int
Row in keybindings table that is being edited.
col : int
Column being edited (shortcut column).
"""
if self._skip:
return
self._table.setCurrentItem(self._table.item(row, col))
if col in {self._shortcut_col, self._shortcut_col2}:
# Get all layer actions and viewer actions in order to determine
# the new shortcut is not already set to an action.
current_layer_text = self.layer_combo_box.currentText()
layer_actions = self.key_bindings_strs[current_layer_text]
actions_all = layer_actions.copy()
if current_layer_text is not self.VIEWER_KEYBINDINGS:
viewer_actions = self.key_bindings_strs[
self.VIEWER_KEYBINDINGS
]
actions_all.update(viewer_actions)
# get the current item from shortcuts column
current_item = self._table.currentItem()
new_shortcut = current_item.text()
if new_shortcut:
new_shortcut = new_shortcut[0].upper() + new_shortcut[1:]
# get the current action name
current_action = self._table.item(row, self._action_col).text()
# get the original shortcutS
current_shortcuts = list(
action_manager._shortcuts.get(current_action, [])
)
# Flag to indicate whether to set the new shortcut.
replace = self._mark_conflicts(new_shortcut, row)
if replace is True:
# This shortcut is not taken.
# Unbind current action from shortcuts in action manager.
action_manager.unbind_shortcut(current_action)
shortcuts_list = list(current_shortcuts)
ind = col - self._shortcut_col
if new_shortcut != "":
if ind < len(shortcuts_list):
shortcuts_list[ind] = new_shortcut
else:
shortcuts_list.append(new_shortcut)
elif ind < len(shortcuts_list):
shortcuts_list.pop(col - self._shortcut_col)
new_value_dict = {}
# Bind the new shortcut.
try:
for short in shortcuts_list:
action_manager.bind_shortcut(current_action, short)
except TypeError:
self._show_bind_shortcut_error(
current_action,
current_shortcuts,
row,
new_shortcut,
)
return
# The new shortcut is valid and can be displayed in widget.
# Keep track of what changed.
new_value_dict = {current_action: shortcuts_list}
self._restore_shortcuts(row)
# Emit signal when new value set for shortcut.
self.valueChanged.emit(new_value_dict)
def _show_warning_icons(self, rows):
"""Creates and displays the warning icons.
Parameters
----------
rows : list[int]
List of row numbers that should have the icon.
"""
for row in rows:
self.warning_indicator = QLabel(self)
self.warning_indicator.setObjectName("error_label")
self._table.setCellWidget(
row, self._icon_col, self.warning_indicator
)
def _cleanup_warning_icons(self, rows):
"""Remove the warning icons from the shortcut table.
Parameters
----------
rows : list[int]
List of row numbers to remove warning icon from.
"""
for row in rows:
self._table.setCellWidget(row, self._icon_col, QLabel(""))
def _show_warning(self, new_shortcut='', action=None, row=0, message=''):
"""Creates and displays warning message when shortcut is already assigned.
Parameters
----------
new_shortcut : str
The new shortcut attempting to be set.
action : Action
Action that is already assigned with the shortcut.
row : int
Row in table where the shortcut is attempting to be set.
message : str
Message to be displayed in warning pop up.
"""
# Determine placement of warning message.
delta_y = 105
delta_x = 10
global_point = self.mapToGlobal(
QPoint(
self._table.columnViewportPosition(self._shortcut_col)
+ delta_x,
self._table.rowViewportPosition(row) + delta_y,
)
)
# Create warning pop up and move it to desired position.
self._warn_dialog = WarnPopup(
text=message,
)
self._warn_dialog.move(global_point)
# Styling adjustments.
self._warn_dialog.resize(250, self._warn_dialog.sizeHint().height())
self._warn_dialog._message.resize(
200, self._warn_dialog._message.sizeHint().height()
)
self._warn_dialog.exec_()
def value(self):
"""Return the actions and shortcuts currently assigned in action manager.
Returns
-------
value: dict
Dictionary of action names and shortcuts assigned to them.
"""
value = {}
for action_name in action_manager._actions.keys():
shortcuts = action_manager._shortcuts.get(action_name, [])
value[action_name] = list(shortcuts)
return value
class ShortcutDelegate(QItemDelegate):
"""Delegate that handles when user types in new shortcut."""
def createEditor(self, widget, style_option, model_index):
self._editor = EditorWidget(widget)
return self._editor
def setEditorData(self, widget, model_index):
text = model_index.model().data(model_index, Qt.ItemDataRole.EditRole)
widget.setText(str(text) if text else "")
def updateEditorGeometry(self, widget, style_option, model_index):
widget.setGeometry(style_option.rect)
def setModelData(self, widget, abstract_item_model, model_index):
text = widget.text()
abstract_item_model.setData(
model_index, text, Qt.ItemDataRole.EditRole
)
class EditorWidget(QLineEdit):
"""Editor widget set in the delegate column in shortcut table."""
def __init__(self, parent=None) -> None:
super().__init__(parent)
def event(self, event):
"""Qt method override."""
if event.type() == QEvent.Type.ShortcutOverride:
self.keyPressEvent(event)
return True
elif event.type() in [QEvent.Type.KeyPress, QEvent.Type.Shortcut]:
return True
else:
return super().event(event)
def keyPressEvent(self, event):
"""Qt method override."""
event_key = event.key()
if not event_key or event_key == Qt.Key.Key_unknown:
return
if (
event_key in {Qt.Key.Key_Delete, Qt.Key.Key_Backspace}
and self.text() != ''
):
# Allow user to delete shortcut.
self.setText('')
return
key_map = {
Qt.Key.Key_Control: keys.CONTROL.name,
Qt.Key.Key_Shift: keys.SHIFT.name,
Qt.Key.Key_Alt: keys.ALT.name,
Qt.Key.Key_Meta: keys.META.name,
Qt.Key.Key_Delete: keys.DELETE.name,
}
if event_key in key_map:
self.setText(key_map[event_key])
return
if event_key in {
Qt.Key.Key_Return,
Qt.Key.Key_Tab,
Qt.Key.Key_CapsLock,
Qt.Key.Key_Enter,
}:
# Do not allow user to set these keys as shortcut.
return
# Translate key value to key string.
translator = ShortcutTranslator()
event_keyseq = translator.keyevent_to_keyseq(event)
event_keystr = event_keyseq.toString(QKeySequence.PortableText)
# Split the shortcut if it contains a symbol.
parsed = re.split('[-(?=.+)]', event_keystr)
keys_li = []
# Format how the shortcut is written (ex. 'Ctrl+B' is changed to 'Control-B')
for val in parsed:
if val in KEY_SUBS.keys():
keys_li.append(KEY_SUBS[val])
else:
keys_li.append(val)
keys_li = '-'.join(keys_li)
self.setText(keys_li)
class ShortcutTranslator(QKeySequenceEdit):
"""
Convert QKeyEvent into QKeySequence.
"""
def __init__(self) -> None:
super().__init__()
self.hide()
def keyevent_to_keyseq(self, event):
"""Return a QKeySequence representation of the provided QKeyEvent."""
self.keyPressEvent(event)
event.accept()
return self.keySequence()
def keyReleaseEvent(self, event):
"""Qt Override"""
return False
def timerEvent(self, event):
"""Qt Override"""
return False
def event(self, event):
"""Qt Override"""
return False
@contextlib.contextmanager
def lock_keybind_update(widget: ShortcutEditor):
prev = widget._skip
widget._skip = True
try:
yield
finally:
widget._skip = prev
napari-0.5.0a1/napari/_qt/widgets/qt_message_popup.py 0000664 0000000 0000000 00000002153 14370413656 0022652 0 ustar 00root root 0000000 0000000 from qtpy.QtCore import Qt
from qtpy.QtWidgets import QDialog, QLabel, QPushButton, QVBoxLayout
from napari._qt.qt_resources import get_stylesheet
from napari.settings import get_settings
class WarnPopup(QDialog):
"""Dialog to inform user that shortcut is already assigned."""
def __init__(
self,
parent=None,
text: str = "",
) -> None:
super().__init__(parent)
self.setWindowFlags(Qt.WindowType.FramelessWindowHint)
# Widgets
self._message = QLabel()
self._xbutton = QPushButton('x', self)
self._xbutton.setFixedSize(20, 20)
# Widget set up
self._message.setText(text)
self._message.setWordWrap(True)
self._xbutton.clicked.connect(self._close)
self._xbutton.setStyleSheet("background-color: rgba(0, 0, 0, 0);")
# Layout
main_layout = QVBoxLayout()
main_layout.addWidget(self._message)
self.setLayout(main_layout)
self.setStyleSheet(get_stylesheet(get_settings().appearance.theme))
self._xbutton.raise_()
def _close(self):
self.close()
napari-0.5.0a1/napari/_qt/widgets/qt_mode_buttons.py 0000664 0000000 0000000 00000005416 14370413656 0022512 0 ustar 00root root 0000000 0000000 import weakref
from qtpy.QtWidgets import QPushButton, QRadioButton
class QtModeRadioButton(QRadioButton):
"""Creates a radio button that can enable a specific layer mode.
Parameters
----------
layer : napari.layers.Layer
The layer instance that this button controls.
button_name : str
Name for the button. This is mostly used to identify the button
in stylesheets (e.g. to add a custom icon)
mode : Enum
The mode to enable when this button is clicked.
tooltip : str, optional
A tooltip to display when hovering the mouse on this button,
by default it will be set to `button_name`.
checked : bool, optional
Whether the button is activate, by default False.
One button in a QButtonGroup should be initially checked.
Attributes
----------
layer : napari.layers.Layer
The layer instance that this button controls.
"""
def __init__(
self, layer, button_name, mode, *, tooltip=None, checked=False
) -> None:
super().__init__()
self.layer_ref = weakref.ref(layer)
self.setToolTip(tooltip or button_name)
self.setChecked(checked)
self.setProperty('mode', button_name)
self.setFixedWidth(28)
self.mode = mode
if mode is not None:
self.toggled.connect(self._set_mode)
def _set_mode(self, bool):
"""Toggle the mode associated with the layer.
Parameters
----------
bool : bool
Whether this mode is currently selected or not.
"""
layer = self.layer_ref()
if layer is None:
return
with layer.events.mode.blocker(self._set_mode):
if bool:
layer.mode = self.mode
class QtModePushButton(QPushButton):
"""Creates a radio button that can trigger a specific action.
Parameters
----------
layer : napari.layers.Layer
The layer instance that this button controls.
button_name : str
Name for the button. This is mostly used to identify the button
in stylesheets (e.g. to add a custom icon)
slot : callable, optional
The function to call when this button is clicked.
tooltip : str, optional
A tooltip to display when hovering the mouse on this button.
Attributes
----------
layer : napari.layers.Layer
The layer instance that this button controls.
"""
def __init__(self, layer, button_name, *, slot=None, tooltip=None) -> None:
super().__init__()
self.layer = layer
self.setProperty('mode', button_name)
self.setToolTip(tooltip or button_name)
self.setFixedWidth(28)
self.setFixedHeight(28)
if slot is not None:
self.clicked.connect(slot)
napari-0.5.0a1/napari/_qt/widgets/qt_plugin_sorter.py 0000664 0000000 0000000 00000035105 14370413656 0022702 0 ustar 00root root 0000000 0000000 """Provides a QtPluginSorter that allows the user to change plugin call order.
"""
from __future__ import annotations
import re
from typing import TYPE_CHECKING, List, Optional, Union
from napari_plugin_engine import HookCaller, HookImplementation
from qtpy.QtCore import QEvent, Qt, Signal, Slot
from qtpy.QtWidgets import (
QAbstractItemView,
QCheckBox,
QComboBox,
QFrame,
QGraphicsOpacityEffect,
QHBoxLayout,
QLabel,
QListView,
QListWidget,
QListWidgetItem,
QSizePolicy,
QVBoxLayout,
QWidget,
)
from superqt import QElidingLabel
from napari._qt.utils import drag_with_pixmap
from napari._qt.widgets.qt_tooltip import QtToolTipLabel
from napari.plugins import plugin_manager as napari_plugin_manager
from napari.settings import get_settings
from napari.utils.translations import trans
if TYPE_CHECKING:
from napari_plugin_engine import PluginManager
def rst2html(text):
def ref(match):
_text = match.groups()[0].split()[0]
if _text.startswith("~"):
_text = _text.split(".")[-1]
return f'``{_text}``'
def link(match):
_text, _link = match.groups()[0].split('<')
return f'")}">{_text.strip()}'
text = re.sub(r'\*\*([^*]+)\*\*', '\\1', text)
text = re.sub(r'\*([^*]+)\*', '\\1', text)
text = re.sub(r':[a-z]+:`([^`]+)`', ref, text, re.DOTALL)
text = re.sub(r'`([^`]+)`_', link, text, re.DOTALL)
text = re.sub(r'``([^`]+)``', '\\1', text)
return text.replace("\n", " ")
class ImplementationListItem(QFrame):
"""A Widget to render each hook implementation item in a ListWidget.
Parameters
----------
item : QListWidgetItem
An item instance from a QListWidget. This will most likely come from
:meth:`QtHookImplementationListWidget.add_hook_implementation_to_list`.
parent : QWidget, optional
The parent widget, by default None
Attributes
----------
plugin_name_label : QLabel
The name of the plugin providing the hook implementation.
enabled_checkbox : QCheckBox
Checkbox to set the ``enabled`` status of the corresponding hook
implementation.
opacity : QGraphicsOpacityEffect
The opacity of the whole widget. When self.enabled_checkbox is
unchecked, the opacity of the item is decreased.
"""
on_changed = Signal() # when user changes whether plugin is enabled.
def __init__(self, item: QListWidgetItem, parent: QWidget = None) -> None:
super().__init__(parent)
self.item = item
self.opacity = QGraphicsOpacityEffect(self)
self.setGraphicsEffect(self.opacity)
layout = QHBoxLayout()
self.setLayout(layout)
self.position_label = QLabel()
self.update_position_label()
self.setToolTip(trans._("Click and drag to change call order"))
self.plugin_name_label = QElidingLabel()
self.plugin_name_label.setObjectName('small_text')
self.plugin_name_label.setText(item.hook_implementation.plugin_name)
plugin_name_size_policy = QSizePolicy(
QSizePolicy.MinimumExpanding, QSizePolicy.Preferred
)
plugin_name_size_policy.setHorizontalStretch(2)
self.plugin_name_label.setSizePolicy(plugin_name_size_policy)
self.function_name_label = QLabel(
item.hook_implementation.function.__name__
)
self.enabled_checkbox = QCheckBox(self)
self.enabled_checkbox.setToolTip(
trans._("Uncheck to disable this plugin")
)
self.enabled_checkbox.stateChanged.connect(self._set_enabled)
self.enabled_checkbox.setChecked(
getattr(item.hook_implementation, 'enabled', True)
)
layout.addWidget(self.position_label)
layout.addWidget(self.enabled_checkbox)
layout.addWidget(self.function_name_label)
layout.addWidget(self.plugin_name_label)
layout.setStretch(2, 1)
layout.setContentsMargins(0, 0, 0, 0)
def _set_enabled(self, state: Union[bool, int]):
"""Set the enabled state of this hook implementation to ``state``."""
self.item.hook_implementation.enabled = bool(state)
self.opacity.setOpacity(1 if state else 0.5)
self.on_changed.emit()
def update_position_label(self, order=None):
"""Update the label showing the position of this item in the list.
Parameters
----------
order : list, optional
A HookOrderType list ... unused by this function, but here for ease
of signal connection, by default None.
"""
position = self.item.listWidget().indexFromItem(self.item).row() + 1
self.position_label.setText(str(position))
class QtHookImplementationListWidget(QListWidget):
"""A ListWidget to display & sort the call order of a hook implementation.
This class will usually be instantiated by a
:class:`~napari._qt.qt_plugin_sorter.QtPluginSorter`. Each item in the list
will be rendered as a :class:`ImplementationListItem`.
Parameters
----------
parent : QWidget, optional
Optional parent widget, by default None
hook_caller : HookCaller, optional
The ``HookCaller`` for which to show implementations. by default None
(i.e. no hooks shown)
Attributes
----------
hook_caller : HookCaller or None
The current ``HookCaller`` instance being shown in the list.
"""
order_changed = Signal(list) # emitted when the user changes the order.
on_changed = Signal() # when user changes whether plugin is enabled.
def __init__(
self,
parent: Optional[QWidget] = None,
hook_caller: Optional[HookCaller] = None,
) -> None:
super().__init__(parent)
self.setDefaultDropAction(Qt.DropAction.MoveAction)
self.setDragEnabled(True)
self.setDragDropMode(QListView.InternalMove)
self.setSelectionMode(QAbstractItemView.SingleSelection)
self.setAcceptDrops(True)
self.setSpacing(1)
self.setMinimumHeight(1)
self.setMaximumHeight(80)
self.order_changed.connect(self.permute_hook)
self.hook_caller: Optional[HookCaller] = None
self.set_hook_caller(hook_caller)
def set_hook_caller(self, hook_caller: Optional[HookCaller]):
"""Set the list widget to show hook implementations for ``hook_caller``.
Parameters
----------
hook_caller : HookCaller, optional
A ``HookCaller`` for which to show implementations. by default None
(i.e. no hooks shown)
"""
self.clear()
self.hook_caller = hook_caller
if not hook_caller:
return
# _nonwrappers returns hook implementations in REVERSE call order
# so we reverse them here to show them in the list in the order in
# which they get called.
for hook_implementation in reversed(hook_caller._nonwrappers):
self.append_hook_implementation(hook_implementation)
def append_hook_implementation(
self, hook_implementation: HookImplementation
):
"""Add a list item for ``hook_implementation`` with a custom widget.
Parameters
----------
hook_implementation : HookImplementation
The hook implementation object to add to the list.
"""
item = QListWidgetItem(self)
item.hook_implementation = hook_implementation
self.addItem(item)
widg = ImplementationListItem(item, parent=self)
widg.on_changed.connect(self.on_changed.emit)
item.setSizeHint(widg.sizeHint())
self.order_changed.connect(widg.update_position_label)
self.setItemWidget(item, widg)
def dropEvent(self, event: QEvent):
"""Triggered when the user moves & drops one of the items in the list.
Parameters
----------
event : QEvent
The event that triggered the dropEvent.
"""
super().dropEvent(event)
order = [self.item(r).hook_implementation for r in range(self.count())]
self.order_changed.emit(order)
def startDrag(self, supported_actions):
drag = drag_with_pixmap(self)
drag.exec_(supported_actions, Qt.DropAction.MoveAction)
@Slot(list)
def permute_hook(self, order: List[HookImplementation]):
"""Rearrage the call order of the hooks for the current hook impl.
Parameters
----------
order : list
A list of str, hook_implementation, or module_or_class, with the
desired CALL ORDER of the hook implementations.
"""
if not self.hook_caller:
return
self.hook_caller.bring_to_front(order)
class QtPluginSorter(QWidget):
"""Dialog that allows a user to change the call order of plugin hooks.
A main QComboBox lets the user pick which hook specification they would
like to reorder. Then a :class:`QtHookImplementationListWidget` shows the
current call order for all implementations of the current hook
specification. The user may then reorder them, or disable them by checking
the checkbox next to each hook implementation name.
Parameters
----------
plugin_manager : PluginManager, optional
An instance of a PluginManager. by default, the main
``napari.plugins.plugin_manager`` instance
parent : QWidget, optional
Optional parent widget, by default None
initial_hook : str, optional
If provided the QComboBox at the top of the dialog will be set to
this hook, by default None
firstresult_only : bool, optional
If True, only hook specifications that declare the "firstresult"
option will be included. (these are hooks for which only the first
non None result is returned). by default True (because it makes
less sense to sort hooks where we just collect all results anyway)
https://pluggy.readthedocs.io/en/latest/#first-result-only
Attributes
----------
hook_combo_box : QComboBox
A dropdown menu to select the current hook.
hook_list : QtHookImplementationListWidget
The list widget that displays (and allows sorting of) all of the hook
implementations for the currently selected hook.
"""
NULL_OPTION = trans._('select hook... ')
def __init__(
self,
plugin_manager: PluginManager = napari_plugin_manager,
*,
parent: Optional[QWidget] = None,
initial_hook: Optional[str] = None,
firstresult_only: bool = True,
) -> None:
super().__init__(parent)
self.plugin_manager = plugin_manager
self.hook_combo_box = QComboBox()
self.hook_combo_box.addItem(self.NULL_OPTION, None)
# populate comboBox with all of the hooks known by the plugin manager
for name, hook_caller in plugin_manager.hooks.items():
# only show hooks with specifications
if not hook_caller.spec:
continue
# if the firstresult_only option is set
# we only want to include hook_specifications that declare the
# "firstresult" option as True.
if firstresult_only and not hook_caller.spec.opts.get(
'firstresult', False
):
continue
self.hook_combo_box.addItem(
name.replace("napari_", ""), hook_caller
)
self.plugin_manager.events.disabled.connect(self._on_disabled)
self.plugin_manager.events.registered.connect(self.refresh)
self.hook_combo_box.setToolTip(
trans._("select the hook specification to reorder")
)
self.hook_combo_box.currentIndexChanged.connect(self._on_hook_change)
self.hook_list = QtHookImplementationListWidget(parent=self)
self.hook_list.order_changed.connect(self._change_settings_plugins)
self.hook_list.on_changed.connect(self._change_settings_plugins)
instructions = QLabel(
trans._(
'Select a hook to rearrange, then drag and drop plugins into the desired call order.\n\nDisable plugins for a specific hook by unchecking their checkbox.'
)
)
instructions.setWordWrap(True)
self.docstring = QLabel(self)
self.info = QtToolTipLabel(self)
self.info.setObjectName("info_icon")
doc_lay = QHBoxLayout()
doc_lay.addWidget(self.docstring)
doc_lay.setStretch(0, 1)
doc_lay.addWidget(self.info)
self.docstring.setWordWrap(True)
self.docstring.setObjectName('small_text')
self.info.hide()
self.docstring.hide()
layout = QVBoxLayout(self)
layout.addWidget(instructions)
layout.addWidget(self.hook_combo_box)
layout.addLayout(doc_lay)
layout.addWidget(self.hook_list)
if initial_hook is not None:
self.set_hookname(initial_hook)
def _change_settings_plugins(self):
"""Update settings if plugin call order changes."""
settings = get_settings()
settings.plugins.call_order = self.plugin_manager.call_order()
def set_hookname(self, hook: str):
"""Change the hook specification shown in the list widget.
Parameters
----------
hook : str
Name of the new hook specification to show.
"""
self.hook_combo_box.setCurrentText(hook.replace("napari_", ''))
def _on_hook_change(self, index):
hook_caller = self.hook_combo_box.currentData()
self.hook_list.set_hook_caller(hook_caller)
if hook_caller:
doc = hook_caller.spec.function.__doc__
html = rst2html(doc.split("Parameters")[0].strip())
summary, fulldoc = html.split(' ', 1)
while fulldoc.startswith(' '):
fulldoc = fulldoc[4:]
self.docstring.setText(summary.strip())
self.docstring.show()
self.info.show()
self.info.setToolTip(fulldoc.strip())
else:
self.docstring.hide()
self.info.hide()
self.docstring.setToolTip('')
def refresh(self):
self._on_hook_change(self.hook_combo_box.currentIndex())
def _on_disabled(self, event):
for i in range(self.hook_list.count()):
item = self.hook_list.item(i)
if item and item.hook_implementation.plugin_name == event.value:
self.hook_list.takeItem(i)
def value(self):
"""Returns the call order from the plugin manager.
Returns
-------
call_order : CallOrderDict
"""
return napari_plugin_manager.call_order()
napari-0.5.0a1/napari/_qt/widgets/qt_progress_bar.py 0000664 0000000 0000000 00000005173 14370413656 0022500 0 ustar 00root root 0000000 0000000 from typing import Optional
from qtpy import QtCore
from qtpy.QtWidgets import (
QApplication,
QFrame,
QHBoxLayout,
QLabel,
QProgressBar,
QVBoxLayout,
QWidget,
)
from napari.utils.progress import progress
class QtLabeledProgressBar(QWidget):
"""QProgressBar with QLabels for description and ETA."""
def __init__(
self, parent: Optional[QWidget] = None, prog: progress = None
) -> None:
super().__init__(parent)
self.setAttribute(QtCore.Qt.WidgetAttribute.WA_DeleteOnClose)
self.progress = prog
self.qt_progress_bar = QProgressBar()
self.description_label = QLabel()
self.eta_label = QLabel()
base_layout = QVBoxLayout()
pbar_layout = QHBoxLayout()
pbar_layout.addWidget(self.description_label)
pbar_layout.addWidget(self.qt_progress_bar)
pbar_layout.addWidget(self.eta_label)
base_layout.addLayout(pbar_layout)
line = QFrame(self)
line.setObjectName("QtCustomTitleBarLine")
line.setFixedHeight(1)
base_layout.addWidget(line)
self.setLayout(base_layout)
def setRange(self, min, max):
self.qt_progress_bar.setRange(min, max)
def setValue(self, value):
self.qt_progress_bar.setValue(value)
QApplication.processEvents()
def setDescription(self, value):
if not value.endswith(': '):
value = f'{value}: '
self.description_label.setText(value)
QApplication.processEvents()
def _set_value(self, event):
self.setValue(event.value)
def _get_value(self):
return self.qt_progress_bar.value()
def _set_description(self, event):
self.setDescription(event.value)
def _make_indeterminate(self, event):
self.setRange(0, 0)
def _set_eta(self, event):
self.eta_label.setText(event.value)
def _set_total(self, event):
self.setRange(0, event.value)
class QtProgressBarGroup(QWidget):
"""One or more QtLabeledProgressBars with a QFrame line separator at the bottom"""
def __init__(
self,
qt_progress_bar: QtLabeledProgressBar,
parent: Optional[QWidget] = None,
) -> None:
super().__init__(parent)
self.setAttribute(QtCore.Qt.WidgetAttribute.WA_DeleteOnClose)
pbr_group_layout = QVBoxLayout()
pbr_group_layout.addWidget(qt_progress_bar)
pbr_group_layout.setContentsMargins(0, 0, 0, 0)
line = QFrame(self)
line.setObjectName("QtCustomTitleBarLine")
line.setFixedHeight(1)
pbr_group_layout.addWidget(line)
self.setLayout(pbr_group_layout)
napari-0.5.0a1/napari/_qt/widgets/qt_range_slider_popup.py 0000664 0000000 0000000 00000003240 14370413656 0023662 0 ustar 00root root 0000000 0000000 from qtpy.QtCore import Qt
from qtpy.QtWidgets import QApplication, QHBoxLayout
from superqt import QLabeledDoubleRangeSlider
from napari._qt.dialogs.qt_modal import QtPopup
class QRangeSliderPopup(QtPopup):
"""A popup window that contains a labeled range slider and buttons.
Parameters
----------
parent : QWidget, optional
Will like be an instance of QtLayerControls. Note, providing
parent can be useful to inherit stylesheets.
Attributes
----------
slider : QLabeledRangeSlider
Slider widget.
"""
def __init__(self, parent=None) -> None:
super().__init__(parent)
# create slider
self.slider = QLabeledDoubleRangeSlider(
Qt.Orientation.Horizontal, parent
)
self.slider.label_shift_x = 2
self.slider.label_shift_y = 2
self.slider.setFocus()
# add widgets to layout
self._layout = QHBoxLayout()
self._layout.setContentsMargins(10, 0, 10, 16)
self.frame.setLayout(self._layout)
self._layout.addWidget(self.slider)
QApplication.processEvents()
self.slider._reposition_labels()
def keyPressEvent(self, event):
"""On key press lose focus of the lineEdits.
Parameters
----------
event : qtpy.QtCore.QKeyEvent
Event from the Qt context.
"""
# we override the parent keyPressEvent so that hitting enter does not
# hide the window... but we do want to lose focus on the lineEdits
if event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter):
self.slider.setFocus()
return
super().keyPressEvent(event)
napari-0.5.0a1/napari/_qt/widgets/qt_scrollbar.py 0000664 0000000 0000000 00000005541 14370413656 0021772 0 ustar 00root root 0000000 0000000 from qtpy.QtCore import Qt
from qtpy.QtWidgets import QScrollBar, QStyle, QStyleOptionSlider
CC = QStyle.ComplexControl
SC = QStyle.SubControl
# https://stackoverflow.com/questions/29710327/how-to-override-qscrollbar-onclick-default-behaviour
class ModifiedScrollBar(QScrollBar):
"""Modified QScrollBar that moves fully to the clicked position.
When the user clicks on the scroll bar background area (aka, the "page
control"), the default behavior of the QScrollBar is to move one "page"
towards the click (rather than all the way to the clicked position).
See: https://doc.qt.io/qt-5/qscrollbar.html
This scroll bar modifies the mousePressEvent to move the slider position
fully to the clicked position.
"""
def _move_to_mouse_position(self, event):
opt = QStyleOptionSlider()
self.initStyleOption(opt)
# pos is for Qt5 e.position().toPoint() is for QT6
# https://doc-snapshots.qt.io/qt6-dev/qmouseevent-obsolete.html#pos
point = (
event.position().toPoint()
if hasattr(event, "position")
else event.pos()
)
control = self.style().hitTestComplexControl(
CC.CC_ScrollBar, opt, point, self
)
if control not in {SC.SC_ScrollBarAddPage, SC.SC_ScrollBarSubPage}:
return
# scroll here
gr = self.style().subControlRect(
CC.CC_ScrollBar, opt, SC.SC_ScrollBarGroove, self
)
sr = self.style().subControlRect(
CC.CC_ScrollBar, opt, SC.SC_ScrollBarSlider, self
)
if self.orientation() == Qt.Orientation.Horizontal:
pos = point.x()
slider_length = sr.width()
slider_min = gr.x()
slider_max = gr.right() - slider_length + 1
if self.layoutDirection() == Qt.LayoutDirection.RightToLeft:
opt.upsideDown = not opt.upsideDown
else:
pos = point.y()
slider_length = sr.height()
slider_min = gr.y()
slider_max = gr.bottom() - slider_length + 1
self.setValue(
QStyle.sliderValueFromPosition(
self.minimum(),
self.maximum(),
pos - slider_min - slider_length // 2,
slider_max - slider_min,
opt.upsideDown,
)
)
def mouseMoveEvent(self, event):
if event.buttons() & Qt.MouseButton.LeftButton:
# dragging with the mouse button down should move the slider
self._move_to_mouse_position(event)
return super().mouseMoveEvent(event)
def mousePressEvent(self, event):
if event.button() == Qt.MouseButton.LeftButton:
# clicking the mouse button should move slider to the clicked point
self._move_to_mouse_position(event)
return super().mousePressEvent(event)
napari-0.5.0a1/napari/_qt/widgets/qt_size_preview.py 0000664 0000000 0000000 00000023417 14370413656 0022524 0 ustar 00root root 0000000 0000000 import typing
from qtpy.QtCore import QSize, Qt, Signal
from qtpy.QtGui import QFont, QIntValidator
from qtpy.QtWidgets import (
QFrame,
QHBoxLayout,
QLabel,
QLineEdit,
QPlainTextEdit,
QSlider,
QVBoxLayout,
QWidget,
)
from napari.utils.translations import trans
class QtFontSizePreview(QFrame):
"""
Widget that displays a preview text.
Parameters
----------
parent : QWidget, optional
Parent widget.
text : str, optional
Preview text to display. Default is None.
"""
def __init__(self, parent: QWidget = None, text: str = None) -> None:
super().__init__(parent)
self._text = text or ""
# Widget
self._preview = QPlainTextEdit(self)
# Widget setup
self._preview.setReadOnly(True)
self._preview.setPlainText(self._text)
# Layout
layout = QHBoxLayout()
layout.addWidget(self._preview)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
def sizeHint(self):
"""Override Qt method."""
return QSize(100, 80)
def text(self) -> str:
"""Return the current preview text.
Returns
-------
str
The current preview text.
"""
return self._text
def setText(self, text: str):
"""Set the current preview text.
Parameters
----------
text : str
The current preview text.
"""
self._text = text
self._preview.setPlainText(text)
class QtSizeSliderPreviewWidget(QWidget):
"""
Widget displaying a description, textedit and slider to adjust font size
with preview.
Parameters
----------
parent : qtpy.QtWidgets.QWidget, optional
Default is None.
description : str, optional
Default is "".
preview_text : str, optional
Default is "".
value : int, optional
Default is None.
min_value : int, optional
Default is 1.
max_value : int, optional
Default is 50.
unit : str, optional
Default is "px".
"""
valueChanged = Signal(int)
def __init__(
self,
parent: QWidget = None,
description: str = None,
preview_text: str = None,
value: int = None,
min_value: int = 1,
max_value: int = 50,
unit: str = "px",
) -> None:
super().__init__(parent)
description = description or ""
preview_text = preview_text or ""
self._value = value if value else self.fontMetrics().height()
self._min_value = min_value
self._max_value = max_value
# Widget
self._lineedit = QLineEdit()
self._description_label = QLabel(self)
self._unit_label = QLabel(self)
self._slider = QSlider(Qt.Orientation.Horizontal, self)
self._slider_min_label = QLabel(self)
self._slider_max_label = QLabel(self)
self._preview = QtFontSizePreview(self)
self._preview_label = QLabel(self)
self._validator = None
# Widgets setup
self._description_label.setText(description)
self._description_label.setWordWrap(True)
self._unit_label.setText(unit)
self._lineedit.setAlignment(Qt.AlignmentFlag.AlignRight)
self._slider_min_label.setText(str(min_value))
self._slider_max_label.setText(str(max_value))
self._slider.setMinimum(min_value)
self._slider.setMaximum(max_value)
self._preview.setText(preview_text)
self._preview_label.setText(trans._("preview"))
self._preview_label.setAlignment(Qt.AlignmentFlag.AlignHCenter)
self.setFocusProxy(self._lineedit)
# Layout
left_bottom_layout = QHBoxLayout()
left_bottom_layout.addWidget(self._lineedit)
left_bottom_layout.addWidget(self._unit_label)
left_bottom_layout.addWidget(self._slider_min_label)
left_bottom_layout.addWidget(self._slider)
left_bottom_layout.addWidget(self._slider_max_label)
left_layout = QVBoxLayout()
left_layout.addWidget(self._description_label)
left_layout.addLayout(left_bottom_layout)
right_layout = QVBoxLayout()
right_layout.addWidget(self._preview)
right_layout.addWidget(self._preview_label)
layout = QHBoxLayout()
layout.addLayout(left_layout, 2)
layout.addLayout(right_layout, 1)
self.setLayout(layout)
# Signals
self._slider.valueChanged.connect(self._update_value)
self._lineedit.textChanged.connect(self._update_value)
self._update_line_width()
self._update_validator()
self._update_value(self._value)
def _update_validator(self):
self._validator = QIntValidator(self._min_value, self._max_value, self)
self._lineedit.setValidator(self._validator)
def _update_line_width(self):
"""Update width ofg line text edit."""
txt = "m" * (1 + len(str(self._max_value)))
fm = self._lineedit.fontMetrics()
if hasattr(fm, 'horizontalAdvance'):
# Qt >= 5.11
size = fm.horizontalAdvance(txt)
else:
size = fm.width(txt)
self._lineedit.setMaximumWidth(size)
self._lineedit.setMinimumWidth(size)
def _update_value(self, value: typing.Union[int, str]):
"""Update internal value and emit if changed."""
if value == "":
value = int(self._value)
value = int(value)
if value > self._max_value:
value = self._max_value
elif value < self._min_value:
value = self._min_value
if value != self._value:
self.valueChanged.emit(value)
self._value = value
self._refresh(self._value)
def _refresh(self, value: int = None):
"""Refresh the value on all subwidgets."""
value = value or self._value
self.blockSignals(True)
self._lineedit.setText(str(value))
self._slider.setValue(value)
font = QFont()
font.setPixelSize(value)
self._preview.setFont(font)
font = QFont()
font.setPixelSize(self.fontMetrics().height() - 4)
self._preview_label.setFont(font)
self.blockSignals(False)
def description(self) -> str:
"""Return the current widget description.
Returns
-------
str
The description text.
"""
return self._description_label.text()
def setDescription(self, text: str):
"""Set the current widget description.
Parameters
----------
text : str
The description text.
"""
self._description_label.setText(text)
def previewText(self) -> str:
"""Return the current preview text.
Returns
-------
str
The current preview text.
"""
return self._preview.text()
def setPreviewText(self, text: str):
"""Set the current preview text.
Parameters
----------
text : str
The current preview text.
"""
self._preview.setText(text)
def unit(self) -> str:
"""Return the current unit text.
Returns
-------
str
The current unit text.
"""
return self._unit_label.text()
def setUnit(self, text: str):
"""Set the current unit text.
Parameters
----------
text : str
The current preview text.
"""
self._unit_label.setText(text)
def minimum(self) -> int:
"""Return the current minimum value for the slider and value in textbox.
Returns
-------
int
The minimum value for the slider.
"""
return self._min_value
def setMinimum(self, value: int):
"""Set the current minimum value for the slider and value in textbox.
Parameters
----------
value : int
The minimum value for the slider.
"""
if value >= self._max_value:
raise ValueError(
trans._(
"Minimum value must be smaller than {max_value}",
max_value=self._max_value,
)
)
self._min_value = value
self._value = max(self._value, self._min_value)
self._slider_min_label.setText(str(value))
self._slider.setMinimum(value)
self._update_validator()
self._refresh()
def maximum(self) -> int:
"""Return the maximum value for the slider and value in textbox.
Returns
-------
int
The maximum value for the slider.
"""
return self._max_value
def setMaximum(self, value: int):
"""Set the maximum value for the slider and value in textbox.
Parameters
----------
value : int
The maximum value for the slider.
"""
if value <= self._min_value:
raise ValueError(
trans._(
"Maximum value must be larger than {min_value}",
min_value=self._min_value,
)
)
self._max_value = value
self._value = min(self._value, self._max_value)
self._slider_max_label.setText(str(value))
self._slider.setMaximum(value)
self._update_validator()
self._update_line_width()
self._refresh()
def value(self) -> int:
"""Return the current widget value.
Returns
-------
int
The current value.
"""
return self._value
def setValue(self, value: int):
"""Set the current widget value.
Parameters
----------
value : int
The current value.
"""
self._update_value(value)
napari-0.5.0a1/napari/_qt/widgets/qt_spinbox.py 0000664 0000000 0000000 00000001442 14370413656 0021465 0 ustar 00root root 0000000 0000000 from qtpy.QtGui import QValidator
from qtpy.QtWidgets import QSpinBox
class QtSpinBox(QSpinBox):
"""Extends QSpinBox validate and stepBy methods in order
to skip values in spin box."""
prohibit = None
def setProhibitValue(self, value: int):
"""Set value that should not be used in QSpinBox.
Parameters
----------
value : int
Value to be excluded from QSpinBox.
"""
self.prohibit = value
def validate(self, value: str, pos: int):
if value == str(self.prohibit):
return QValidator.Invalid, value, pos
return super().validate(value, pos)
def stepBy(self, steps: int) -> None:
if self.value() + steps == self.prohibit:
steps *= 2
return super().stepBy(steps)
napari-0.5.0a1/napari/_qt/widgets/qt_splash_screen.py 0000664 0000000 0000000 00000001003 14370413656 0022625 0 ustar 00root root 0000000 0000000 from qtpy.QtCore import Qt
from qtpy.QtGui import QPixmap
from qtpy.QtWidgets import QSplashScreen
from napari._qt.qt_event_loop import NAPARI_ICON_PATH, get_app
class NapariSplashScreen(QSplashScreen):
def __init__(self, width=360) -> None:
get_app()
pm = QPixmap(NAPARI_ICON_PATH).scaled(
width,
width,
Qt.AspectRatioMode.KeepAspectRatio,
Qt.TransformationMode.SmoothTransformation,
)
super().__init__(pm)
self.show()
napari-0.5.0a1/napari/_qt/widgets/qt_theme_sample.py 0000664 0000000 0000000 00000012242 14370413656 0022446 0 ustar 00root root 0000000 0000000 """SampleWidget that contains many types of QWidgets.
This file and SampleWidget is useful for testing out themes from the command
line or for generating screenshots of a sample widget to demonstrate a theme.
Examples
--------
To use from the command line:
$ python -m napari._qt.theme_sample
To generate a screenshot within python:
>>> from napari._qt.widgets.qt_theme_sample import SampleWidget
>>> widg = SampleWidget(theme='dark')
>>> screenshot = widg.screenshot()
"""
from qtpy.QtCore import Qt
from qtpy.QtWidgets import (
QCheckBox,
QComboBox,
QDoubleSpinBox,
QFontComboBox,
QFormLayout,
QGroupBox,
QHBoxLayout,
QLabel,
QLineEdit,
QProgressBar,
QPushButton,
QRadioButton,
QScrollBar,
QSlider,
QSpinBox,
QTabWidget,
QTextEdit,
QTimeEdit,
QVBoxLayout,
QWidget,
)
from superqt import QRangeSlider
from napari._qt.qt_resources import get_stylesheet
from napari._qt.utils import QImg2array
from napari.utils.io import imsave
blurb = """
Heading
Lorem ipsum dolor sit amet, consectetur adipiscing elit,
sed do eiusmod tempor incididunt ut labore et dolore magna
aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat.
Duis aute irure dolor in reprehenderit in voluptate velit
esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui
officia deserunt mollit anim id est laborum.