diff --git a/_sources/getting_started.md b/_sources/getting_started.md index 8a1e78d..1f24cfd 100644 --- a/_sources/getting_started.md +++ b/_sources/getting_started.md @@ -1,56 +1,263 @@ -# Getting started +## Getting started -## Loading data +blik is a plugin for the scientific visualisation software napari, bringing extra functionality for cryo-electron tomography (cryo-ET) data visualisation, manipulation and analysis. In this tutorial, you will learn the basics of napari and how to use the various tools provided by blik. When available, links to more extensive external documentation are provided throughout this tutorial. -From the command line: -```bash -napari -w blik -- /path/to.star /path/to/mrc/files/* +## napari basics + +[napari](https://napari.org/) is a multi-dimensional image viewer, focused on scientific image analysis. It provides both a graphical and programmatic interface to offer intuitive interaction and powerful customisation capabilities. napari is easily installed and can be extended with a growing number of plugins dedicated to specific image analysis tasks. You can find the full napari documentation and a usage guide at the [napari tutorial page](https://napari.org/stable/usage.html). + +A variety of image formats can be loaded into napari and additional format support can be achieved by plugins (such as blik for cryo-ET related formats). Images can be [opened from the command line](https://napari.org/stable/tutorials/fundamentals/getting_started.html), by dragging them into the napari window, or by selecting them from the *File > Open File(s)* (Ctrl+o) menu. The image will be [loaded as a new `Layer`](https://napari.org/stable/guides/layers.html#layers-glance), the basic object that can be visualised in the napari viewer (similarly to layers in image-editing software like Photoshop ad GIMP). There are several layer types (e.g. Image, Surface, etc.), which all come with their specific `layer controls`, displayed at the top left of the viewer when a layer is selected ({numref}`layercontrols`). + +```{figure} https://github.com/brisvag/blik/assets/23482191/5d7916ca-5963-4f95-bae9-f251863b1586 +--- +name: layercontrols +--- +Layer controls panel for the `Image` layer, providing several basic controls such as contrast limits, colormapping and interpolation. ``` -The `-w blik` is important for proper initialization of all the layers. Keep the main widget open to ensure nothing goes wrong! +Using this window, we may adjust basic properties like image contrast and colormap, surface colors, and others. If multiple layers are present, the `layer list` just below the `layer controls` can be used to reorder layers and select a specific layer to control. Layers can also be shown and hidden from this panel by clicking on the eye icon ({numref}`layerlist`). + +```{figure} https://github.com/brisvag/blik/assets/23482191/df3e6496-d21d-4a11-a25a-54dd1ec6a82e +--- +name: layerlist +--- +Layer list widget containing a single `Image` layer. On the left, the eye icon used to toggle layer visibility. +``` + +In addition to the graphical controls, napari provides a built-in IPython console. To open the console, click the `>_` symbol in the button row at the bottom left of the viewer ({numref}`buttons`). The console can be used for on-the-fly programmatic interaction with the data via the napari python API. + +The button row below the layer list also allows to toggle between 2D and 3D, as well other viewer controls. + +```{figure} https://github.com/brisvag/blik/assets/23482191/20efdb89-92e4-4895-a9e4-c01854f02e1b +--- +name: buttons +--- +Bottom button row. In order: toggle ipython console, toggle 2D/3D, transpose dimensions, rotate visualisation, grid mode, reset view. +``` + +Napari is designed to handle n-dimensional data. When loading data with more than two dimensions, the `dimension slider` will open beneath the canvas. This slider can be used to scroll through the dimensions currently not displayed. The number of sliders depends on the dimensionality of the data: one slider for each dimension beyond the ones displayed. The play button on the left side of each slider allows to automatically scroll through that dimension. + +More in-depth information on how to navigate the napari user interface (UI) can be found [on the viewer documentation](https://napari.org/stable/tutorials/fundamentals/viewer.html). + +## blik basics + +[blik](https://github.com/brisvag/blik) is a napari plugin for reading, writing, and interacting with cryo-ET and subtomogram averaging (STA) data ([Gaifas et al. -- *bioRxiv* 2023](https://doi.org/10.1101/2023.12.05.570263)). This tutorial provides some basics for visualisation and annotation of cryo-ET data using blik; the full documentation can be found at [https://brisvag.github.io/blik/](https://brisvag.github.io/blik/). + +## Installation + +There are multiple ways in which blik can be installed. If napari is already installed, you can install blik through the napari plugin manager (in napari UI go to *Plugins > Install/Uninstall Plugins...* and then search for blik), [directly through pip](https://pypi.org/project/pip/). Alternatively, you can install blik and napari together using: + + pip install "blik[all]" + +This will also install additional plugins which are needed or segmentation interpolation and properties inspection. + +The nightly build is updated more frequently with new features and uses the latest, unreleased napari (with some instability to be expected). To install the latest nightly build, follow the [instructions on the readme](https://brisvag.github.io/blik/#nightly-build). + +## Opening and visualising data +blik takes care of the data loading once installed; to open files, you can use the standard napari methods described above. -## Widgets -### Main Widget +For images, blik supports many standard file formats such as `.mrc` (including `.mrcs`, `.st` and `.map`) but also formats like [Dynamo](https://www.dynamo-em.org//w/index.php?title=Main_Page) `.em`, among others. This allows visualisation not only of tomograms, but also raw movies, tilt series and even things like output power spectra from [ctffind4](https://grigoriefflab.umassmed.edu/ctffind4). -In the `napari` GUI, you'll find the main blik widget. Select which experiment ID to visualize with the dropdown menu, and the relevant layers will be selected and made visible. +For particle data, blik takes [Relion](https://relion.readthedocs.io/en/release-5.0/) `.star`, Dynamo `.tbl` and a variety of other input formats format. -Here you can also create a new segmentation (a simple napari labels layer) and automatically add it to the current experiment. This ensures that saving it will have all the correct metadata. +blik also comes with a file reader implemented as a napari UI widget (*Plugins > blik > file reader*), which offers more granular control over the loading process. -You can add any existing layer to the currently selected experiment ID by using the `add layer` widget. +Once opened, the data will initially be loaded into a hidden layer: experiments can be selected and rendered visible through the main widget, or layers can be manually marked as visible from the layer list. +### Saving or writing data to a file -### File Reader -If you need finer control over loading data, you can use the `file reader` widget. You can also start it from the command line with: +To save any napari layer using a plugin, we simply need to select the layer of interest and hit *Ctrl + s* or go to *File > Save selected Layer(s)*. Depending on the layer type, napari will provide various output formats, among which those implemented by blik (such as `.mrc` for images, or `.star` for particles). +### Visualising tomograms + +Let's see what we can do with our data after loading it into blik. For this example, we are using a tomogram of *E. coli* minicells showcasing a sizeable chemosensory array underneath their membrane ({numref}`fulltomo`, [Burt et al. -- *Nature Communications* 2020](https://doi.org/10.1038/s41467-020-14350-9)). + +```{figure} https://github.com/brisvag/blik/assets/23482191/ff5bc916-ed40-436e-a8d2-263a40066be8 +--- +name: fulltomo +--- +Z-slice through a (noisy) tomogram of *E. coli* minicells. ``` -napari -w blik 'file reader' + +At first glance, the low contrast of this tomogram makes it hard to segment or pick particles. To improve interpretability of the data, blik provides a `gaussian filter`, which can be applied to 2D images and slices with adjustable kernel size and sigma ({numref}`fulltomo_contrast`). The filter can be applied through its widget, accessible from the main menu. + +If using the nightly build, to further improve contrast, we can increase the thickness over which the currently viewed slice is averaged using the slider on the main widget. + +If we switch to the 3D view, the data will initially be depicted as a 2D slicing plane through the 3D volume. We can also adjust the thickness of this slice using the slider in the `layer controls`. We can also hold the shift key while dragging the plane up and down to slice through the tomogram volume. + +```{figure} https://github.com/brisvag/blik/assets/23482191/b8a8d88f-ce51-472d-8136-e640ea9fccb7 +--- +name: fulltomo_contrast +--- +z_slice through the same tomogram in 3D view with enhanced contrast thanks to averaging over a thick slice. ``` -This widget allows additional arguments compared to the basic `napari` command line interface. +We can change the alignment of the slicing plane through the volume to x or y by clicking on the corresponding direction under `plane normal` in the layer controls. Using multiple layers with slices oriented along different axes, we can visualise slicing through the tomogram in multiple directions simultaneously ({numref}`csa_sta_slices`). +```{figure} https://github.com/brisvag/blik/assets/23482191/0741796b-feaa-4553-ad25-21b5c2d741b0 +--- +name: csa_sta_slices --- +Three 3D slices along different axes through a map from subtomogram averaging of the chemosensory array. +``` -`name_regex` is a regex pattern used to extract tomogram names from file names (or things like the `rlnMicrographName` filed in `.star` files). By default, `blik` recognizes files containing `TS_\d+`, and will fall back to `\d+`. For example, the following files will be assigned `TS_001`: +To view the full volume in 3D, change the depiction from `plane` to `volume` in the layer controls. A variety of rendering options are available, including isosurfaces ({numref}`csa_sta_iso`) and maximum intensity projections (under `rendering` in the `layer controls`). These options are not exclusive to blik but are built-in functions of the [napari `Image` layer](https://napari.org/stable/howtos/layers/image.html). +```{figure} https://github.com/brisvag/blik/assets/23482191/e5dea3c7-2149-425f-9ff7-4b6a9fb6c5af +--- +name: csa_sta_iso +--- +Visualisation as an isosurface of a map from subtomogram averaging of the chemosensory array. ``` -CoolSample2_TS_001_something.mrc -Particles_TS_001.star + +blik also comes with a widget for quickly visualizing the power spectra of images, slices and volumes (*Plugins > blik > power spectrum*, {numref}`powerspectrum`). The power spectrum widget comes with a tick box which lets us input the dimensionality of the data, to distinguish between 3D volumes and stacks of 2D images. + +```{figure} https://github.com/brisvag/blik/assets/23482191/bf6ceb51-f6bf-4b26-aa84-df1341ba61ce +--- +name: powerspectrum +--- +Z-slice slice through the 3D power spectrum of the tomogram. The central slices from each tilt projection are clearly visible, highlighting the missing wedge characteristic of cryo-ET data. ``` -These, instead, will be assigned just `02`: +### Visualising particles +Each particle dataset will be loaded into two separate layers by blik: particle locations are loaded as a `points layer`, while orientations will be loaded as a `vectors layer` and by default will be displayed as coloured arrows ({numref}`particles_tbl`). + +```{figure} https://github.com/brisvag/blik/assets/23482191/0b76edef-9823-40e2-b581-b5b7a8b09013 +--- +name: particles_tbl +--- +Positions and orientations of particles picked using vector picking in Dynamo from a surface model. Data loaded from a `.tbl` file. ``` -image_02.em -particles_02.tbl + +Particles can be manually selected by clicking `Select points` from the top of the layer controls panel and then drawing a box around the desired particle. Particles may also be manually created by selecting the `add` tool from the layer controls. The `remove` tool will remove currently selected particles. The appearance of the selected particles may also be changed by using the layer controls. Selecting the orientations layer from the layer list will also let us similarly change the appearance of the orientation arrows. + +## Using blik to segment and pick + +### Tomogram segmentation + +One of the most common next steps after the generation of a tomogram is the segmentation of the features visible in the data. blik comes with its own implemented segmentation function. It can be found under the main widget under `new`. Choose the data which you want to use for segmentation under `experiment` and then create a new segmentation. This will open a labels layers. Here you can adjust parameters for visualization of the segmentation like colour and opacity. By clicking on + and - under `label` you can change between different labels which will all be saved in the same layer + +At the top of the layer controls panel, different tools for manual annotation are provided, including the brush for drawing on an image, an eraser and a fill function. Features can be annotated in 2 or 3 dimension, which can be changed using the `n edit dim` function. 3D annotation is currently only available for extending already existing annotations, but full 3D segmentation will be implemented in the future. To interpolate the created labels, we can use the `napari-label-interpolater` plugin. Below you can see a rough segmentation of the cytoplasm of the two cells in our tomogram ({numref}`segmentation`). The segmentation was created by annotating multiple 2D slices and then interpolating the result. + +```{figure} https://github.com/brisvag/blik/assets/23482191/6ecce685-a221-470e-8bfc-c581ded3b141 +--- +name: segmentation +--- +Rough segmentation of the cytoplasm of the cells in the tomogram. Important parts of the UI are highlighted with arrows. +``` + +To be able to save them with blik, interpolated labels must first be added to the experiment to be properly equipped with metadata such as pixel size. We can do so using `add to exp` using the main blik widget widget. + +### Manual picking + +Using the main blik widget, we can also create new empty particles for manual picking. This will open two new layers, one for particle positions and one for particle orientations. We can now use the `layer controls` of the napari `Points` layer to add, delete and select particles. By using `add` and clicking on a position in 2D view, we can pick a location, where a new particle will be created. For now, interactive determination of the particle orientation while picking is not possible, so the initial orientation will correspond to all-zero Euler angles. + +### Surface picking + +blik also provides tools to pick particles on a surface. In order to define a surface , we can use the `surface picking` option in the main widget. This will create a new `Shapes` layer with many controls; blik's surface generation expects paths created using the `Add path` tool (last button on the top left); using other shapes is currently unsupported. + +Using the path tool, we annotate our desired feature in a few 2D slices by left clicking to add points to the `surface lines` layer. The points don't need to be particularly dense: interpolation and smoothing will be applied when generating the surface. By double clicking, each path can be finalised. Repeating this over a few z-slices (about 4 or 5 is usually sufficient for typical surfaces) will define the rough shape of the surface we will generate. If we want to edit one of our points we can select the path on the corresponding z-slice by clicking `select vertices` in the layer controls, and then drag the point to a new position. + +Now that we roughly defined the shape of the surface we want to use for picking, we can continue with the surface generation. Open the `surface widget`. By giving our surface lines layer as input to `surface shapes`, we can construct a surface which follows the lines we defined. The `spacing A` parameter is used to define the spacing (in Angstroms) of individual samples on the surface ({numref}`surface`). + +```{figure} https://github.com/brisvag/blik/assets/23482191/aed9a161-438f-4101-9fcd-e33eb8aa6505 +--- +name: surface +--- +Surface created from user-defined paths along the inner membrane of the *E. coli* minicells. +``` + +Once we are happy with the shape of the generated surface, we can move on to generating the particles ({numref}`surface_particles`). This is done by using the `surface particle` section. The `spacing A` slider controls the distance between the final particles just as the one above. The orientation of the particles will initialize with the Z axis of the particle orthogonal to the picked surface. + +Note that the surface creation algorithm of blik can lead to deformed surfaces beyond the edges of the annotation, which may result in unexpected particle orientations; to avoid these artifacts, we can tick `mask` to only create particles strictly within the region of the surface where we defined our paths. + +```{figure} https://github.com/brisvag/blik/assets/23482191/efdcdbee-a604-4a75-b7fc-dd58cb17df96 +--- +name: surface_particles +--- +Particles uniformly distributed on the generated surface. +``` + +### Filament picking + +Another geometrical picking model implemented in blik is the `filament picker`. The procedure is similar to that for surfaces. To start defining a new filament, we need to create a new `filament picking` in the main widget. This will open a new `Points` layer called `filament picks`. + +We can now pick coordinates using the `Add points` tool under layer controls. Points can be picked across multiple z-slices (picking in 3D mode is not implemented yet). When we are satisfied with the points, we need to open the `filament widget` to generate the filament from the points which will create a new layer called `filament` ({numref}`filament`). + +After the filament itself is created, we need to define the parameters for generating particles along the filament, which are `rise A`, `twist deg` and `radius A`. Information about cyclic symmetry and a twist offset can also be added. The rise parameter will determine the separation distance between the generated particles. Clicking Generate will add new layers which encode particle positions and orientations. + +```{figure} https://github.com/brisvag/blik/assets/23482191/84d9f7a0-5135-4b0c-9cb0-0a87353c8830 +--- +name: filament +--- +Particle positions and orientations generated along a helical filament defined by manually picked locations (in white). +``` + +### Resampling features + +We can also resample a surface using `resample surface` taking a user defined thickness for the resampled volume ({numref}`surface_resample`). This feature comes in handy when we would like to create a spatially consistent volume of a complex 3D object for quantitative analysis. The same as for the surface generation, filaments can also be resampled using the `resample filament` function. + +```{figure} https://github.com/brisvag/blik/assets/23482191/d4706948-1f6e-4ab9-a516-c4131c6f054a +--- +name: surface_resample +--- +Resampling of a surface created with the surface picking procedure. The surface was annotated along the outer membrane of an *E. coli* minicell (top), resampled with a thickness of 650 A and then averaged across z (bottom). ``` +## Inspecting particle metadata + +If blik was installed with the `[all]` option, it will automatically come with the `napari-properties-plotter` and `napari-properties-viewer` plugins. These can be used for inspecting additional features of particle data directly in the napari UI. + +The properties-viewer can be used to open a table of all `features` of a layer in blik. The features are specific properties of objects in a layer, such as which class each particle belongs to if classification results were present in a loaded `.star` file. + +The properties can also be plotted using the properties plotter. Any two features of a layer can be plotted against each other in different styles; choosing just one feature will plot a histogram. + +Within the properties-plotter we can choose a selection of data points from the plot by clicking `Select Area`. The specified data can then be interacted with through the layer controls. Below you can see particles loaded from a `.star` file which have been picked using the surface picking protocol. They were equipped with a synthetic feature called "conf", the values of which follow a normal distribution, which has been plotted against the particle index using the properties-plotter. Data points with "conf" higher or equal 1 have been selected from the plotter and were coloured red using the layer controls. + +```{figure} https://github.com/brisvag/blik/assets/23482191/e95d8472-ac3d-4006-9ed2-3030333c5788 +--- +name: plotter --- +Using the properties plotter to select and interact with particles with the desired feature values. +``` + +## Creating custom widgets + +napari integrates with a tool called [`magicgui`](https://pyapp-kit.github.io/magicgui/) to make it easy to create simple custom widgets to interact with the viewer and the data by writing simple python code. A thorough explanation can be found in the [napari documentation for magicgui](https://napari.org/stable/guides/magicgui.html). Here's a (complete!) example showcasing how to create a slider to control the threshold of a simple segmentation algorithm, which allows to quickly and interactively find the best value for the parameter. -`names` can be used to whitelist specific tomogram names to load. If passed, anything *not* in the list won't be loaded. +```py +import napari +from magicgui import magicgui -### Filters +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 -Simple imaging filters (such as gaussian) to help with visualization. In the future, these will be available as much faster gpu-based interpolations. +@magicgui( + auto_call=True, # call the function automatically on any change + threshold=dict(widget_type='FloatSlider', min=0, max=300), # use a slider widget +) +def segment( + image: napari.layers.Image, # automatically detect image layers as inputs + threshold: float = 50, +) -> napari.types.LayerDataTuple: # tell napari to add the output to the layerlist + # see scikit-image docs for details on these functions + thresholded = closing(image.data > threshold, square(4)) + cleared = remove_small_objects(clear_border(thresholded), 100) + label_image = label(cleared) + return label_image, {'name': 'result'} +## load sample data and open it in napari +image = data.coins()[50:-50, 50:-50] +viewer = napari.view_image(image, name='coins', rgb=False) + +## add the widget to the viewer window +viewer.window.add_dock_widget(segment) + +napari.run() +``` diff --git a/genindex.html b/genindex.html index 92dde0e..3673994 100644 --- a/genindex.html +++ b/genindex.html @@ -1 +1 @@ - Index — Blik Skip to content
\ No newline at end of file + Index — Blik Skip to content
\ No newline at end of file diff --git a/getting_started.html b/getting_started.html index d808d94..d2c1d58 100644 --- a/getting_started.html +++ b/getting_started.html @@ -1,7 +1,34 @@ - Getting started — Blik Skip to content

Getting started

Loading data

From the command line:

napari -w blik -- /path/to.star /path/to/mrc/files/*
-

The -w blik is important for proper initialization of all the layers. Keep the main widget open to ensure nothing goes wrong!

Widgets

Main Widget

In the napari GUI, you’ll find the main blik widget. Select which experiment ID to visualize with the dropdown menu, and the relevant layers will be selected and made visible.

Here you can also create a new segmentation (a simple napari labels layer) and automatically add it to the current experiment. This ensures that saving it will have all the correct metadata.

You can add any existing layer to the currently selected experiment ID by using the add layer widget.

File Reader

If you need finer control over loading data, you can use the file reader widget. You can also start it from the command line with:

napari -w blik 'file reader'
-

This widget allows additional arguments compared to the basic napari command line interface.


name_regex is a regex pattern used to extract tomogram names from file names (or things like the rlnMicrographName filed in .star files). By default, blik recognizes files containing TS_\d+, and will fall back to \d+. For example, the following files will be assigned TS_001:

CoolSample2_TS_001_something.mrc
-Particles_TS_001.star
-

These, instead, will be assigned just 02:

image_02.em
-particles_02.tbl
-

names can be used to whitelist specific tomogram names to load. If passed, anything not in the list won’t be loaded.

Filters

Simple imaging filters (such as gaussian) to help with visualization. In the future, these will be available as much faster gpu-based interpolations.

\ No newline at end of file + Getting started — Blik Skip to content

Getting started

blik is a plugin for the scientific visualisation software napari, bringing extra functionality for cryo-electron tomography (cryo-ET) data visualisation, manipulation and analysis. In this tutorial, you will learn the basics of napari and how to use the various tools provided by blik. When available, links to more extensive external documentation are provided throughout this tutorial.

napari basics

napari is a multi-dimensional image viewer, focused on scientific image analysis. It provides both a graphical and programmatic interface to offer intuitive interaction and powerful customisation capabilities. napari is easily installed and can be extended with a growing number of plugins dedicated to specific image analysis tasks. You can find the full napari documentation and a usage guide at the napari tutorial page.

A variety of image formats can be loaded into napari and additional format support can be achieved by plugins (such as blik for cryo-ET related formats). Images can be opened from the command line, by dragging them into the napari window, or by selecting them from the File > Open File(s) (Ctrl+o) menu. The image will be loaded as a new Layer, the basic object that can be visualised in the napari viewer (similarly to layers in image-editing software like Photoshop ad GIMP). There are several layer types (e.g. Image, Surface, etc.), which all come with their specific layer controls, displayed at the top left of the viewer when a layer is selected (Fig. 1).

https://github.com/brisvag/blik/assets/23482191/5d7916ca-5963-4f95-bae9-f251863b1586

Fig. 1 Layer controls panel for the Image layer, providing several basic controls such as contrast limits, colormapping and interpolation.

Using this window, we may adjust basic properties like image contrast and colormap, surface colors, and others. If multiple layers are present, the layer list just below the layer controls can be used to reorder layers and select a specific layer to control. Layers can also be shown and hidden from this panel by clicking on the eye icon (Fig. 2).

https://github.com/brisvag/blik/assets/23482191/df3e6496-d21d-4a11-a25a-54dd1ec6a82e

Fig. 2 Layer list widget containing a single Image layer. On the left, the eye icon used to toggle layer visibility.

In addition to the graphical controls, napari provides a built-in IPython console. To open the console, click the >_ symbol in the button row at the bottom left of the viewer (Fig. 3). The console can be used for on-the-fly programmatic interaction with the data via the napari python API.

The button row below the layer list also allows to toggle between 2D and 3D, as well other viewer controls.

https://github.com/brisvag/blik/assets/23482191/20efdb89-92e4-4895-a9e4-c01854f02e1b

Fig. 3 Bottom button row. In order: toggle ipython console, toggle 2D/3D, transpose dimensions, rotate visualisation, grid mode, reset view.

Napari is designed to handle n-dimensional data. When loading data with more than two dimensions, the dimension slider will open beneath the canvas. This slider can be used to scroll through the dimensions currently not displayed. The number of sliders depends on the dimensionality of the data: one slider for each dimension beyond the ones displayed. The play button on the left side of each slider allows to automatically scroll through that dimension.

More in-depth information on how to navigate the napari user interface (UI) can be found on the viewer documentation.

blik basics

blik is a napari plugin for reading, writing, and interacting with cryo-ET and subtomogram averaging (STA) data (Gaifas et al. – bioRxiv 2023). This tutorial provides some basics for visualisation and annotation of cryo-ET data using blik; the full documentation can be found at https://brisvag.github.io/blik/.

Installation

There are multiple ways in which blik can be installed. If napari is already installed, you can install blik through the napari plugin manager (in napari UI go to Plugins > Install/Uninstall Plugins… and then search for blik), directly through pip. Alternatively, you can install blik and napari together using:

pip install "blik[all]"
+

This will also install additional plugins which are needed or segmentation interpolation and properties inspection.

The nightly build is updated more frequently with new features and uses the latest, unreleased napari (with some instability to be expected). To install the latest nightly build, follow the instructions on the readme.

Opening and visualising data

blik takes care of the data loading once installed; to open files, you can use the standard napari methods described above.

For images, blik supports many standard file formats such as .mrc (including .mrcs, .st and .map) but also formats like Dynamo .em, among others. This allows visualisation not only of tomograms, but also raw movies, tilt series and even things like output power spectra from ctffind4.

For particle data, blik takes Relion .star, Dynamo .tbl and a variety of other input formats format.

blik also comes with a file reader implemented as a napari UI widget (Plugins > blik > file reader), which offers more granular control over the loading process.

Once opened, the data will initially be loaded into a hidden layer: experiments can be selected and rendered visible through the main widget, or layers can be manually marked as visible from the layer list.

Saving or writing data to a file

To save any napari layer using a plugin, we simply need to select the layer of interest and hit Ctrl + s or go to File > Save selected Layer(s). Depending on the layer type, napari will provide various output formats, among which those implemented by blik (such as .mrc for images, or .star for particles).

Visualising tomograms

Let’s see what we can do with our data after loading it into blik. For this example, we are using a tomogram of E. coli minicells showcasing a sizeable chemosensory array underneath their membrane (Fig. 4, Burt et al. – Nature Communications 2020).

https://github.com/brisvag/blik/assets/23482191/ff5bc916-ed40-436e-a8d2-263a40066be8

Fig. 4 Z-slice through a (noisy) tomogram of E. coli minicells.

At first glance, the low contrast of this tomogram makes it hard to segment or pick particles. To improve interpretability of the data, blik provides a gaussian filter, which can be applied to 2D images and slices with adjustable kernel size and sigma (Fig. 5). The filter can be applied through its widget, accessible from the main menu.

If using the nightly build, to further improve contrast, we can increase the thickness over which the currently viewed slice is averaged using the slider on the main widget.

If we switch to the 3D view, the data will initially be depicted as a 2D slicing plane through the 3D volume. We can also adjust the thickness of this slice using the slider in the layer controls. We can also hold the shift key while dragging the plane up and down to slice through the tomogram volume.

https://github.com/brisvag/blik/assets/23482191/b8a8d88f-ce51-472d-8136-e640ea9fccb7

Fig. 5 z_slice through the same tomogram in 3D view with enhanced contrast thanks to averaging over a thick slice.

We can change the alignment of the slicing plane through the volume to x or y by clicking on the corresponding direction under plane normal in the layer controls. Using multiple layers with slices oriented along different axes, we can visualise slicing through the tomogram in multiple directions simultaneously (Fig. 6).

https://github.com/brisvag/blik/assets/23482191/0741796b-feaa-4553-ad25-21b5c2d741b0

Fig. 6 Three 3D slices along different axes through a map from subtomogram averaging of the chemosensory array.

To view the full volume in 3D, change the depiction from plane to volume in the layer controls. A variety of rendering options are available, including isosurfaces (Fig. 7) and maximum intensity projections (under rendering in the layer controls). These options are not exclusive to blik but are built-in functions of the napari Image layer.

https://github.com/brisvag/blik/assets/23482191/e5dea3c7-2149-425f-9ff7-4b6a9fb6c5af

Fig. 7 Visualisation as an isosurface of a map from subtomogram averaging of the chemosensory array.

blik also comes with a widget for quickly visualizing the power spectra of images, slices and volumes (Plugins > blik > power spectrum, Fig. 8). The power spectrum widget comes with a tick box which lets us input the dimensionality of the data, to distinguish between 3D volumes and stacks of 2D images.

https://github.com/brisvag/blik/assets/23482191/bf6ceb51-f6bf-4b26-aa84-df1341ba61ce

Fig. 8 Z-slice slice through the 3D power spectrum of the tomogram. The central slices from each tilt projection are clearly visible, highlighting the missing wedge characteristic of cryo-ET data.

Visualising particles

Each particle dataset will be loaded into two separate layers by blik: particle locations are loaded as a points layer, while orientations will be loaded as a vectors layer and by default will be displayed as coloured arrows (Fig. 9).

https://github.com/brisvag/blik/assets/23482191/0b76edef-9823-40e2-b581-b5b7a8b09013

Fig. 9 Positions and orientations of particles picked using vector picking in Dynamo from a surface model. Data loaded from a .tbl file.

Particles can be manually selected by clicking Select points from the top of the layer controls panel and then drawing a box around the desired particle. Particles may also be manually created by selecting the add tool from the layer controls. The remove tool will remove currently selected particles. The appearance of the selected particles may also be changed by using the layer controls. Selecting the orientations layer from the layer list will also let us similarly change the appearance of the orientation arrows.

Using blik to segment and pick

Tomogram segmentation

One of the most common next steps after the generation of a tomogram is the segmentation of the features visible in the data. blik comes with its own implemented segmentation function. It can be found under the main widget under new. Choose the data which you want to use for segmentation under experiment and then create a new segmentation. This will open a labels layers. Here you can adjust parameters for visualization of the segmentation like colour and opacity. By clicking on + and - under label you can change between different labels which will all be saved in the same layer

At the top of the layer controls panel, different tools for manual annotation are provided, including the brush for drawing on an image, an eraser and a fill function. Features can be annotated in 2 or 3 dimension, which can be changed using the n edit dim function. 3D annotation is currently only available for extending already existing annotations, but full 3D segmentation will be implemented in the future. To interpolate the created labels, we can use the napari-label-interpolater plugin. Below you can see a rough segmentation of the cytoplasm of the two cells in our tomogram (Fig. 10). The segmentation was created by annotating multiple 2D slices and then interpolating the result.

https://github.com/brisvag/blik/assets/23482191/6ecce685-a221-470e-8bfc-c581ded3b141

Fig. 10 Rough segmentation of the cytoplasm of the cells in the tomogram. Important parts of the UI are highlighted with arrows.

To be able to save them with blik, interpolated labels must first be added to the experiment to be properly equipped with metadata such as pixel size. We can do so using add to exp using the main blik widget widget.

Manual picking

Using the main blik widget, we can also create new empty particles for manual picking. This will open two new layers, one for particle positions and one for particle orientations. We can now use the layer controls of the napari Points layer to add, delete and select particles. By using add and clicking on a position in 2D view, we can pick a location, where a new particle will be created. For now, interactive determination of the particle orientation while picking is not possible, so the initial orientation will correspond to all-zero Euler angles.

Surface picking

blik also provides tools to pick particles on a surface. In order to define a surface , we can use the surface picking option in the main widget. This will create a new Shapes layer with many controls; blik’s surface generation expects paths created using the Add path tool (last button on the top left); using other shapes is currently unsupported.

Using the path tool, we annotate our desired feature in a few 2D slices by left clicking to add points to the surface lines layer. The points don’t need to be particularly dense: interpolation and smoothing will be applied when generating the surface. By double clicking, each path can be finalised. Repeating this over a few z-slices (about 4 or 5 is usually sufficient for typical surfaces) will define the rough shape of the surface we will generate. If we want to edit one of our points we can select the path on the corresponding z-slice by clicking select vertices in the layer controls, and then drag the point to a new position.

Now that we roughly defined the shape of the surface we want to use for picking, we can continue with the surface generation. Open the surface widget. By giving our surface lines layer as input to surface shapes, we can construct a surface which follows the lines we defined. The spacing A parameter is used to define the spacing (in Angstroms) of individual samples on the surface (Fig. 11).

https://github.com/brisvag/blik/assets/23482191/aed9a161-438f-4101-9fcd-e33eb8aa6505

Fig. 11 Surface created from user-defined paths along the inner membrane of the E. coli minicells.

Once we are happy with the shape of the generated surface, we can move on to generating the particles (Fig. 12). This is done by using the surface particle section. The spacing A slider controls the distance between the final particles just as the one above. The orientation of the particles will initialize with the Z axis of the particle orthogonal to the picked surface.

Note that the surface creation algorithm of blik can lead to deformed surfaces beyond the edges of the annotation, which may result in unexpected particle orientations; to avoid these artifacts, we can tick mask to only create particles strictly within the region of the surface where we defined our paths.

https://github.com/brisvag/blik/assets/23482191/efdcdbee-a604-4a75-b7fc-dd58cb17df96

Fig. 12 Particles uniformly distributed on the generated surface.

Filament picking

Another geometrical picking model implemented in blik is the filament picker. The procedure is similar to that for surfaces. To start defining a new filament, we need to create a new filament picking in the main widget. This will open a new Points layer called filament picks.

We can now pick coordinates using the Add points tool under layer controls. Points can be picked across multiple z-slices (picking in 3D mode is not implemented yet). When we are satisfied with the points, we need to open the filament widget to generate the filament from the points which will create a new layer called filament (Fig. 13).

After the filament itself is created, we need to define the parameters for generating particles along the filament, which are rise A, twist deg and radius A. Information about cyclic symmetry and a twist offset can also be added. The rise parameter will determine the separation distance between the generated particles. Clicking Generate will add new layers which encode particle positions and orientations.

https://github.com/brisvag/blik/assets/23482191/84d9f7a0-5135-4b0c-9cb0-0a87353c8830

Fig. 13 Particle positions and orientations generated along a helical filament defined by manually picked locations (in white).

Resampling features

We can also resample a surface using resample surface taking a user defined thickness for the resampled volume (Fig. 14). This feature comes in handy when we would like to create a spatially consistent volume of a complex 3D object for quantitative analysis. The same as for the surface generation, filaments can also be resampled using the resample filament function.

https://github.com/brisvag/blik/assets/23482191/d4706948-1f6e-4ab9-a516-c4131c6f054a

Fig. 14 Resampling of a surface created with the surface picking procedure. The surface was annotated along the outer membrane of an E. coli minicell (top), resampled with a thickness of 650 A and then averaged across z (bottom).

Inspecting particle metadata

If blik was installed with the [all] option, it will automatically come with the napari-properties-plotter and napari-properties-viewer plugins. These can be used for inspecting additional features of particle data directly in the napari UI.

The properties-viewer can be used to open a table of all features of a layer in blik. The features are specific properties of objects in a layer, such as which class each particle belongs to if classification results were present in a loaded .star file.

The properties can also be plotted using the properties plotter. Any two features of a layer can be plotted against each other in different styles; choosing just one feature will plot a histogram.

Within the properties-plotter we can choose a selection of data points from the plot by clicking Select Area. The specified data can then be interacted with through the layer controls. Below you can see particles loaded from a .star file which have been picked using the surface picking protocol. They were equipped with a synthetic feature called “conf”, the values of which follow a normal distribution, which has been plotted against the particle index using the properties-plotter. Data points with “conf” higher or equal 1 have been selected from the plotter and were coloured red using the layer controls.

https://github.com/brisvag/blik/assets/23482191/e95d8472-ac3d-4006-9ed2-3030333c5788

Fig. 15 Using the properties plotter to select and interact with particles with the desired feature values.

Creating custom widgets

napari integrates with a tool called magicgui to make it easy to create simple custom widgets to interact with the viewer and the data by writing simple python code. A thorough explanation can be found in the napari documentation for magicgui. Here’s a (complete!) example showcasing how to create a slider to control the threshold of a simple segmentation algorithm, which allows to quickly and interactively find the best value for the parameter.

import napari
+from magicgui import magicgui
+
+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
+
+@magicgui(
+    auto_call=True,  # call the function automatically on any change
+    threshold=dict(widget_type='FloatSlider', min=0, max=300),  # use a slider widget
+)
+def segment(
+    image: napari.layers.Image,  # automatically detect image layers as inputs
+    threshold: float = 50,
+) -> napari.types.LayerDataTuple:  # tell napari to add the output to the layerlist
+    # see scikit-image docs for details on these functions
+    thresholded = closing(image.data > threshold, square(4))
+    cleared = remove_small_objects(clear_border(thresholded), 100)
+    label_image = label(cleared)
+
+    return label_image, {'name': 'result'}
+
+## load sample data and open it in napari
+image = data.coins()[50:-50, 50:-50]
+viewer = napari.view_image(image, name='coins', rgb=False)
+
+## add the widget to the viewer window
+viewer.window.add_dock_widget(segment)
+
+napari.run()
+
\ No newline at end of file diff --git a/index.html b/index.html index 76a373b..99f2225 100644 --- a/index.html +++ b/index.html @@ -1,4 +1,4 @@ - blik — Blik Skip to content

logo

blik

License PyPI Python Version CI codecov

blik showcase

blik is a tool for visualising and interacting with cryo-ET and subtomogram averaging data. It leverages the fast, multi-dimensional napari viewer and the scientific python stack.

DISCLAIMER: this package is in development phase. Expect bugs and crashes. Please, report them on the issue tracker and ask if anything is unclear!

Installation

You can either install blik through the napari plugin system, through pip, or get both napari and blik directly with:

pip install "blik[all]"
+                        blik — Blik                                      Skip to content  

logo

blik

License PyPI Python Version CI codecov

blik showcase

blik is a tool for visualising and interacting with cryo-ET and subtomogram averaging data. It leverages the fast, multi-dimensional napari viewer and the scientific python stack.

DISCLAIMER: this package is in development phase. Expect bugs and crashes. Please, report them on the issue tracker and ask if anything is unclear!

Installation

You can either install blik through the napari plugin system, through pip, or get both napari and blik directly with:

pip install "blik[all]"
 

The [all] qualifier also installs pyqt5 as the napari GUI backend, and a few additional napari plugins that you might find useful in your workflow:

Nightly build

If you’d like the most up to date blik possible, you can install directly from the main branch on github. This also uses napari main, so expect some instability!

pip install "git+https://github.com/brisvag/blik.git@main#egg=blik[all]"
 pip install "git+https://github.com/napari/napari.git@main#egg=napari[all]"
 

Basic Usage

From the command line:

napari -w blik -- /path/to.star /path/to/mrc/files/*
diff --git a/objects.inv b/objects.inv
index e991947..e711d48 100644
Binary files a/objects.inv and b/objects.inv differ
diff --git a/search.html b/search.html
index ef8ccaf..7f05808 100644
--- a/search.html
+++ b/search.html
@@ -1 +1 @@
-                        Search — Blik                                        Skip to content  

Search

Please activate JavaScript to enable the search functionality.

\ No newline at end of file + Search — Blik Skip to content
\ No newline at end of file diff --git a/searchindex.js b/searchindex.js index 2b45450..21aa5fa 100644 --- a/searchindex.js +++ b/searchindex.js @@ -1 +1 @@ -Search.setIndex({"docnames": ["getting_started", "index"], "filenames": ["getting_started.md", "index.md"], "titles": ["Getting started", "blik"], "terms": {"from": [0, 1], "command": [0, 1], "line": [0, 1], "napari": [0, 1], "w": [0, 1], "blik": 0, "path": [0, 1], "star": [0, 1], "mrc": [0, 1], "The": [0, 1], "i": [0, 1], "import": [0, 1], "proper": [0, 1], "initi": [0, 1], "all": [0, 1], "layer": [0, 1], "keep": 0, "open": [0, 1], "ensur": [0, 1], "noth": [0, 1], "goe": [0, 1], "wrong": [0, 1], "In": 0, "gui": [0, 1], "you": [0, 1], "ll": 0, "find": [0, 1], "select": [0, 1], "which": [0, 1], "experi": [0, 1], "id": [0, 1], "visual": 0, "dropdown": 0, "menu": 0, "relev": 0, "made": 0, "visibl": 0, "here": 0, "can": [0, 1], "also": [0, 1], "creat": 0, "new": [0, 1], "segment": [0, 1], "simpl": [0, 1], "label": [0, 1], "automat": 0, "add": [0, 1], "current": [0, 1], "thi": [0, 1], "save": 0, "have": 0, "correct": 0, "metadata": [0, 1], "ani": 0, "exist": 0, "us": [0, 1], "If": [0, 1], "need": 0, "finer": 0, "control": 0, "over": [0, 1], "allow": 0, "addit": [0, 1], "argument": 0, "compar": 0, "basic": 0, "interfac": 0, "name_regex": 0, "regex": 0, "pattern": 0, "extract": 0, "tomogram": [0, 1], "name": 0, "thing": 0, "like": [0, 1], "rlnmicrographnam": 0, "By": 0, "default": 0, "recogn": 0, "contain": 0, "ts_": 0, "d": [0, 1], "fall": 0, "back": 0, "For": 0, "exampl": 0, "follow": 0, "assign": 0, "ts_001": 0, "coolsample2_ts_001_someth": 0, "particles_ts_001": 0, "These": 0, "instead": 0, "just": [0, 1], "02": 0, "image_02": 0, "em": 0, "particles_02": 0, "tbl": 0, "whitelist": 0, "specif": 0, "pass": 0, "anyth": [0, 1], "list": 0, "won": 0, "t": 0, "imag": [0, 1], "gaussian": 0, "help": 0, "futur": 0, "avail": [0, 1], "much": 0, "faster": 0, "gpu": 0, "base": 0, "interpol": [0, 1], "tool": 1, "visualis": 1, "interact": 1, "cryo": 1, "et": 1, "subtomogram": 1, "averag": 1, "data": 1, "It": 1, "leverag": 1, "fast": 1, "multi": 1, "dimension": 1, "viewer": 1, "scientif": 1, "python": 1, "stack": 1, "disclaim": 1, "packag": 1, "develop": 1, "phase": 1, "expect": 1, "bug": 1, "crash": 1, "pleas": 1, "report": 1, "them": 1, "issu": 1, "tracker": 1, "ask": 1, "unclear": 1, "either": 1, "through": 1, "plugin": 1, "system": 1, "pip": 1, "get": 1, "both": 1, "directli": 1, "qualifi": 1, "pyqt5": 1, "backend": 1, "few": 1, "might": 1, "your": 1, "workflow": 1, "properti": 1, "plotter": 1, "most": 1, "up": 1, "date": 1, "possibl": 1, "main": 1, "branch": 1, "github": 1, "so": 1, "some": 1, "instabl": 1, "git": 1, "http": 1, "com": 1, "brisvag": 1, "egg": 1, "file": 1, "alwai": 1, "particl": 1, "ar": 1, "expos": 1, "analys": 1, "manipul": 1, "importantli": 1, "other": 1, "ha": 1, "function": 1, "quickli": 1, "switch": 1, "differ": 1, "typic": 1, "everyth": 1, "relat": 1, "an": 1, "individu": 1, "volum": 1, "gener": 1, "manual": 1, "pick": 1, "set": 1, "surfac": 1, "filament": 1, "resampl": 1, "exp": 1, "shorthand": 1, "experiment_id": 1, "current_exp_id": 1, "slice_thick": 1, "chang": 1, "slice": 1, "thick": 1, "dimens": 1, "displai": 1, "There": 1, "process": 1, "previous": 1, "mesh": 1, "distribut": 1, "along": 1, "A": 1, "paper": 1, "preprint": 1, "about": 1, "biorxiv": 1, "doi": 1, "org": 1, "10": 1, "1101": 1, "2023": 1, "12": 1, "05": 1, "570263": 1}, "objects": {}, "objtypes": {}, "objnames": {}, "titleterms": {"get": 0, "start": 0, "load": 0, "data": 0, "widget": [0, 1], "main": 0, "file": 0, "reader": 0, "filter": 0, "blik": 1, "instal": 1, "nightli": 1, "build": 1, "basic": 1, "usag": 1, "refer": 1}, "envversion": {"sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.intersphinx": 1, "sphinx.ext.viewcode": 1, "sphinx": 60}, "alltitles": {"Getting started": [[0, "getting-started"]], "Loading data": [[0, "loading-data"]], "Widgets": [[0, "widgets"], [1, "widgets"]], "Main Widget": [[0, "main-widget"]], "File Reader": [[0, "file-reader"]], "Filters": [[0, "filters"]], "blik": [[1, "blik"]], "Installation": [[1, "installation"]], "Nightly build": [[1, "nightly-build"]], "Basic Usage": [[1, "basic-usage"]], "References": [[1, "references"]]}, "indexentries": {}}) \ No newline at end of file +Search.setIndex({"docnames": ["getting_started", "index"], "filenames": ["getting_started.md", "index.md"], "titles": ["Getting started", "blik"], "terms": {"i": [0, 1], "plugin": [0, 1], "scientif": [0, 1], "softwar": 0, "bring": 0, "extra": 0, "function": [0, 1], "cryo": [0, 1], "electron": 0, "tomographi": 0, "et": [0, 1], "manipul": [0, 1], "analysi": 0, "In": 0, "thi": [0, 1], "tutori": 0, "you": [0, 1], "learn": 0, "how": 0, "variou": 0, "tool": [0, 1], "provid": 0, "when": 0, "avail": [0, 1], "link": 0, "more": 0, "extens": 0, "extern": 0, "document": 0, "ar": [0, 1], "throughout": 0, "multi": [0, 1], "dimension": [0, 1], "imag": [0, 1], "viewer": [0, 1], "focus": 0, "It": [0, 1], "both": [0, 1], "graphic": 0, "programmat": 0, "interfac": 0, "offer": 0, "intuit": 0, "interact": [0, 1], "power": 0, "customis": 0, "capabl": 0, "easili": 0, "can": [0, 1], "extend": 0, "grow": 0, "number": 0, "dedic": 0, "specif": 0, "task": 0, "find": [0, 1], "full": 0, "usag": 0, "guid": 0, "page": 0, "A": [0, 1], "varieti": 0, "format": 0, "load": 0, "addit": [0, 1], "support": 0, "achiev": 0, "relat": [0, 1], "from": [0, 1], "command": [0, 1], "line": [0, 1], "drag": 0, "them": [0, 1], "window": 0, "select": [0, 1], "": 0, "ctrl": 0, "o": 0, "menu": 0, "The": [0, 1], "new": [0, 1], "layer": [0, 1], "object": 0, "similarli": 0, "edit": 0, "like": [0, 1], "photoshop": 0, "ad": 0, "gimp": 0, "There": [0, 1], "sever": 0, "type": 0, "e": 0, "g": 0, "etc": 0, "which": [0, 1], "all": [0, 1], "come": 0, "control": 0, "displai": [0, 1], "top": 0, "left": 0, "fig": 0, "1": 0, "panel": 0, "contrast": 0, "limit": 0, "colormap": 0, "interpol": [0, 1], "we": 0, "mai": 0, "adjust": 0, "properti": [0, 1], "color": 0, "other": [0, 1], "If": [0, 1], "multipl": 0, "present": 0, "list": 0, "just": [0, 1], "below": 0, "reorder": 0, "also": [0, 1], "shown": 0, "hidden": 0, "click": 0, "ey": 0, "icon": 0, "2": 0, "contain": 0, "singl": 0, "On": 0, "toggl": 0, "visibl": 0, "built": 0, "ipython": 0, "consol": 0, "To": 0, "_": 0, "symbol": 0, "button": 0, "row": 0, "bottom": 0, "3": 0, "fly": 0, "via": 0, "python": [0, 1], "api": 0, "allow": 0, "between": 0, "2d": 0, "3d": 0, "well": 0, "order": 0, "transpos": 0, "dimens": [0, 1], "rotat": 0, "grid": 0, "mode": 0, "reset": 0, "view": 0, "design": 0, "handl": 0, "n": 0, "than": 0, "two": 0, "slider": 0, "beneath": 0, "canva": 0, "scroll": 0, "through": [0, 1], "current": [0, 1], "depend": 0, "one": 0, "each": 0, "beyond": 0, "ones": 0, "plai": 0, "side": 0, "automat": 0, "depth": 0, "inform": 0, "navig": 0, "user": 0, "ui": 0, "found": 0, "read": 0, "subtomogram": [0, 1], "averag": [0, 1], "sta": 0, "gaifa": 0, "al": 0, "biorxiv": [0, 1], "2023": [0, 1], "some": [0, 1], "annot": 0, "http": [0, 1], "brisvag": [0, 1], "github": [0, 1], "io": 0, "wai": 0, "alreadi": 0, "manag": 0, "go": 0, "uninstal": 0, "search": 0, "directli": [0, 1], "pip": [0, 1], "altern": 0, "togeth": 0, "need": 0, "nightli": 0, "build": 0, "updat": 0, "frequent": 0, "latest": 0, "unreleas": 0, "instabl": [0, 1], "expect": [0, 1], "follow": 0, "instruct": 0, "readm": 0, "take": 0, "care": 0, "onc": 0, "standard": 0, "method": 0, "describ": 0, "abov": 0, "For": 0, "mani": 0, "mrc": [0, 1], "includ": 0, "st": 0, "map": 0, "dynamo": 0, "em": 0, "among": 0, "onli": 0, "raw": 0, "movi": 0, "tilt": 0, "seri": 0, "even": 0, "thing": 0, "output": 0, "spectra": 0, "ctffind4": 0, "relion": 0, "star": [0, 1], "tbl": 0, "input": 0, "reader": 0, "implement": 0, "granular": 0, "over": [0, 1], "process": [0, 1], "initi": [0, 1], "experi": [0, 1], "render": 0, "main": [0, 1], "mark": 0, "ani": 0, "simpli": 0, "interest": 0, "hit": 0, "those": 0, "let": 0, "see": 0, "what": 0, "do": 0, "our": 0, "after": 0, "exampl": 0, "coli": 0, "minicel": 0, "showcas": 0, "sizeabl": 0, "chemosensori": 0, "arrai": 0, "underneath": 0, "membran": 0, "4": 0, "burt": 0, "natur": 0, "commun": 0, "2020": 0, "z": 0, "slice": [0, 1], "noisi": 0, "At": 0, "first": 0, "glanc": 0, "low": 0, "make": 0, "hard": 0, "improv": 0, "interpret": 0, "gaussian": 0, "filter": 0, "appli": 0, "kernel": 0, "size": 0, "sigma": 0, "5": 0, "its": 0, "access": 0, "further": 0, "increas": 0, "thick": [0, 1], "switch": [0, 1], "depict": 0, "plane": 0, "volum": [0, 1], "hold": 0, "shift": 0, "kei": 0, "while": 0, "up": [0, 1], "down": 0, "z_slice": 0, "same": 0, "enhanc": 0, "thank": 0, "chang": [0, 1], "align": 0, "x": 0, "y": 0, "correspond": 0, "direct": 0, "under": 0, "normal": 0, "orient": 0, "along": [0, 1], "differ": [0, 1], "ax": 0, "simultan": 0, "6": 0, "three": 0, "option": 0, "isosurfac": 0, "7": 0, "maximum": 0, "intens": 0, "project": 0, "These": 0, "exclus": 0, "an": [0, 1], "quickli": [0, 1], "visual": 0, "spectrum": 0, "8": 0, "tick": 0, "box": 0, "u": 0, "distinguish": 0, "stack": [0, 1], "central": 0, "clearli": 0, "highlight": 0, "miss": 0, "wedg": 0, "characterist": 0, "dataset": 0, "separ": 0, "locat": 0, "point": 0, "vector": 0, "default": 0, "colour": 0, "arrow": 0, "9": 0, "posit": 0, "model": 0, "draw": 0, "around": 0, "desir": 0, "add": [0, 1], "remov": 0, "appear": 0, "One": 0, "most": [0, 1], "common": 0, "next": 0, "step": 0, "gener": [0, 1], "own": 0, "choos": 0, "want": 0, "label": [0, 1], "here": 0, "paramet": 0, "opac": 0, "By": 0, "brush": 0, "eras": 0, "fill": 0, "dim": 0, "exist": 0, "futur": 0, "interpolat": 0, "rough": 0, "cytoplasm": 0, "cell": 0, "10": [0, 1], "wa": 0, "result": 0, "import": [0, 1], "part": 0, "abl": 0, "must": 0, "properli": 0, "equip": 0, "pixel": 0, "so": [0, 1], "exp": [0, 1], "empti": 0, "now": 0, "delet": 0, "where": 0, "determin": 0, "possibl": [0, 1], "zero": 0, "euler": 0, "angl": 0, "defin": 0, "shape": 0, "path": [0, 1], "last": 0, "unsupport": 0, "few": [0, 1], "don": 0, "t": 0, "particularli": 0, "dens": 0, "smooth": 0, "doubl": 0, "finalis": 0, "repeat": 0, "about": [0, 1], "usual": 0, "suffici": 0, "typic": [0, 1], "vertic": 0, "roughli": 0, "continu": 0, "give": 0, "construct": 0, "space": 0, "angstrom": 0, "individu": [0, 1], "sampl": 0, "11": 0, "inner": 0, "happi": 0, "move": 0, "12": [0, 1], "done": 0, "section": 0, "distanc": 0, "final": 0, "axi": 0, "orthogon": 0, "note": 0, "creation": 0, "algorithm": 0, "lead": 0, "deform": 0, "edg": 0, "unexpect": 0, "avoid": 0, "artifact": 0, "mask": 0, "strictli": 0, "within": 0, "region": 0, "uniformli": 0, "distribut": [0, 1], "anoth": 0, "geometr": 0, "picker": 0, "procedur": 0, "similar": 0, "call": 0, "coordin": 0, "across": 0, "yet": 0, "satisfi": 0, "13": 0, "itself": 0, "rise": 0, "twist": 0, "deg": 0, "radiu": 0, "cyclic": 0, "symmetri": 0, "offset": 0, "encod": 0, "helic": 0, "white": 0, "14": 0, "handi": 0, "would": 0, "spatial": 0, "consist": 0, "complex": 0, "quantit": 0, "outer": 0, "650": 0, "plotter": [0, 1], "tabl": 0, "class": 0, "belong": 0, "classif": 0, "were": 0, "plot": 0, "against": 0, "style": 0, "histogram": 0, "area": 0, "specifi": 0, "have": 0, "been": 0, "protocol": 0, "thei": 0, "synthet": 0, "conf": 0, "valu": 0, "ha": [0, 1], "index": 0, "higher": 0, "equal": 0, "red": 0, "integr": 0, "magicgui": 0, "easi": 0, "simpl": [0, 1], "code": 0, "thorough": 0, "explan": 0, "complet": 0, "threshold": 0, "best": 0, "skimag": 0, "threshold_otsu": 0, "measur": 0, "morphologi": 0, "close": 0, "remove_small_object": 0, "squar": 0, "clear_bord": 0, "auto_cal": 0, "true": 0, "dict": 0, "widget_typ": 0, "floatslid": 0, "min": 0, "0": 0, "max": 0, "300": 0, "def": 0, "detect": 0, "float": 0, "50": 0, "layerdatatupl": 0, "tell": 0, "layerlist": 0, "scikit": 0, "doc": 0, "detail": 0, "clear": 0, "100": 0, "label_imag": 0, "return": 0, "name": 0, "coin": 0, "view_imag": 0, "rgb": 0, "fals": 0, "add_dock_widget": 0, "run": 0, "visualis": 1, "data": 1, "leverag": 1, "fast": 1, "napari": 1, "disclaim": 1, "packag": 1, "develop": 1, "phase": 1, "bug": 1, "crash": 1, "pleas": 1, "report": 1, "issu": 1, "tracker": 1, "ask": 1, "anyth": 1, "unclear": 1, "either": 1, "system": 1, "get": 1, "qualifi": 1, "pyqt5": 1, "gui": 1, "backend": 1, "might": 1, "us": 1, "your": 1, "workflow": 1, "d": 1, "date": 1, "branch": 1, "git": 1, "com": 1, "egg": 1, "w": 1, "file": 1, "proper": 1, "alwai": 1, "open": 1, "ensur": 1, "noth": 1, "goe": 1, "wrong": 1, "particl": 1, "expos": 1, "analys": 1, "importantli": 1, "id": 1, "everyth": 1, "tomogram": 1, "segment": 1, "manual": 1, "pick": 1, "set": 1, "surfac": 1, "filament": 1, "resampl": 1, "shorthand": 1, "metadata": 1, "experiment_id": 1, "current_exp_id": 1, "slice_thick": 1, "previous": 1, "mesh": 1, "paper": 1, "preprint": 1, "doi": 1, "org": 1, "1101": 1, "05": 1, "570263": 1}, "objects": {}, "objtypes": {}, "objnames": {}, "titleterms": {"get": 0, "start": 0, "napari": 0, "basic": [0, 1], "blik": [0, 1], "instal": [0, 1], "open": 0, "visualis": 0, "data": 0, "save": 0, "write": 0, "file": 0, "tomogram": 0, "particl": 0, "us": 0, "segment": 0, "pick": 0, "manual": 0, "surfac": 0, "filament": 0, "resampl": 0, "featur": 0, "inspect": 0, "metadata": 0, "creat": 0, "custom": 0, "widget": [0, 1], "nightli": 1, "build": 1, "usag": 1, "refer": 1}, "envversion": {"sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.intersphinx": 1, "sphinx.ext.viewcode": 1, "sphinx": 60}, "alltitles": {"Getting started": [[0, "getting-started"]], "napari basics": [[0, "napari-basics"]], "blik basics": [[0, "blik-basics"]], "Installation": [[0, "installation"], [1, "installation"]], "Opening and visualising data": [[0, "opening-and-visualising-data"]], "Saving or writing data to a file": [[0, "saving-or-writing-data-to-a-file"]], "Visualising tomograms": [[0, "visualising-tomograms"]], "Visualising particles": [[0, "visualising-particles"]], "Using blik to segment and pick": [[0, "using-blik-to-segment-and-pick"]], "Tomogram segmentation": [[0, "tomogram-segmentation"]], "Manual picking": [[0, "manual-picking"]], "Surface picking": [[0, "surface-picking"]], "Filament picking": [[0, "filament-picking"]], "Resampling features": [[0, "resampling-features"]], "Inspecting particle metadata": [[0, "inspecting-particle-metadata"]], "Creating custom widgets": [[0, "creating-custom-widgets"]], "blik": [[1, "blik"]], "Nightly build": [[1, "nightly-build"]], "Basic Usage": [[1, "basic-usage"]], "Widgets": [[1, "widgets"]], "References": [[1, "references"]]}, "indexentries": {}}) \ No newline at end of file