Haven't been committing and want to keep track of where I'm at with this

• [x] separate models for manipulator/translator and associated visual data
• [x] add tests construction of models
• [x] produce correct visual data from individual models
• [x] produce correct visual data from manipulator itself
• [x] hook up to Kevin's vispy visual
• [x] highlighting logic

Also todo but maybe in separate PRs:

• [ ] hook up existing manipulators
• [ ] add docs

Hi all,

I would love to ship napari-threedee together with of devbio-napari. This should just work, the only thing is: It would be cool if it was available via conda-forge.

See also:

• [ ] https://github.com/haesleinhuepf/devbio-napari/issues/29

This PR makes our plane point annotator compatible with nD data

The only restriction at the minute is that the points and image layers must have the same dimensionality

this is a branch which adds visualisation of

• the centroid of the clicked triangle
• the click point
• the view direction (as another point, further along the view direction)

This should allow us to debug the 'furthest away rotator is sometimes selected on click' bug

I'm struggling to figure out what exactly is wrong with what we're doing - switching to the maximum distance is clearly wrong and the signed distances appear to be calculated correctly... will keep investigating

This PR adds a simple reader/writer contribution pairing which will read/write .n3d files, zarr arrays matching annotation specifications

should add a test but it's the end of the day and getting zarr to work was annoying, will do tomorrow before merge

slight annoyance: you can't open directories from the standard open file menu in the napari gui, you have to specifically open a folder -> because zarr arrays are folders this is also true for .n3d files

Hey @kevinyamauchi - I think this is good to go, let me know what you think of the outline for the spec in the docs and if you think anything is missing

Once this is in I will implement a single io plugin entry point in a separate plugin rather than implementing one for every annotator

progress on sphere annotator and todo:

• [x] ability to generate sphere data from points with radius in features
• [x] ability to configure radii interactively
• [x] ability to configure position interactively

This WIP PR is another absolute monster: forgive me 🙏🏼

This PR takes the improved manipulator and related component models from #63 and hooks everything up to our BaseManipulator class in a way which I think makes it nice and easy to implement desired behaviour in specific Manipulator implementations.

I have so far only reimplemented the RenderPlaneManipulator, widget autogeneration is working as before

https://user-images.githubusercontent.com/7307488/197223256-978fdd9c-6c09-48e6-ad75-1ca411495a1a.mp4

the implementation for this is...

class RenderPlaneManipulator(BaseManipulator):
    """A manipulator for moving and orienting an image layer rendering plane."""

    def __init__(self, viewer, layer=None):
        super().__init__(viewer, layer, rotator_axes='yz', translator_axes='z')

    def set_layers(self, layers: napari.layers.Image):
        super().set_layers(layers)

    def _initialize_transform(self):
        self.origin = np.array(self.layer.plane.position)
        plane_normal = self.layer.plane.normal
        self.rotation_matrix = rotation_matrix_from_vectors_3d([1, 0, 0], plane_normal)

    def _while_dragging_translator(self):
        self.layer.plane.position = self.origin

    def _while_dragging_rotator(self):
        self.layer.plane.normal = self.z_vector

something else worth highlighting is how simple this new separation made the mouse callback on the BaseManipulator class

    def _mouse_callback(self, layer, event):
        """Update the manipulated object via subclass implementations of drag/rotate behaviour."""
        yield
        if self._viewer.dims.ndisplay != 3 or self._backend.is_dragging is False:
            return  # early exit if manipulator is not being manipulated
        self._pre_drag()
        while event.type == 'mouse_move':
            selected_object_type = self._backend.manipulator_model.selected_object_type
            if selected_object_type == 'translator':
                self._while_dragging_translator()
            elif selected_object_type == 'rotator':
                self._while_dragging_rotator()
            yield
        self._post_drag()

edit: things left to do

• [ ] check and add tests for various instantiation possibilities of manipulator implementations (with layer, no layer)
• [ ] hook up other manipulators

This WIP PR refactors the manipulator drag:

• improves the visual for the manipulator
• factors out an separate model for translator
• factors out a separate model for rotator
• introduces a RotatorDragManager to encapsulate the rotator drag logic
• introduces a TranslatorDragManager to encapsulate the translator drag logic
• fixes bugs in the rotator drag calculation
• adds tests
• restricts axes to [[1, 0, 0], [0, 1, 0], [0, 0, 1]]

In this issue, we discuss the initial workflows we aim to add:

Draw points on a plane in 3D

Have a controllable plane displayed in the volume. The user clicks to add points that get put on the point the cursor ray intersects the plane.

Draw a line and rotate a rendering plane around the line

Define a line by drawing two points on a plane. Add a render a plane that the line lies on and allow the user to rotate the plane around that line.

Define a spline with points and translate a rendering plane along the spline

Add points in 3D. Then fit a spline to those points. Add a rendering plane that is on the spline with its normal along the tangent of the spline. Allow the user to slice along the spline using a slider.

This PR updates the landing page of the docs:

• add video
• add installation instructions
• add getting started section and stubs for the getting started pages

The manipulator used to stay a constant size relative to the scene

I broke that with #63 and #65

Would be great if we could get that feature back and not need to modify the model

relevant code from old manipulator: https://github.com/napari-threedee/napari-threedee/blob/8f05af903a5722ba529fececc4f365c1fe922bed/src/napari_threedee/manipulators/base_manipulator.py#L127

https://github.com/napari-threedee/napari-threedee/blob/8f05af903a5722ba529fececc4f365c1fe922bed/src/napari_threedee/manipulators/base_manipulator.py#L732-L747

Our annotators produce layers with a specific structure - we need to be able to serialize and deserialize that structure

steps

• specifications for layers produced by different annotators
• serialize/deserialise

related: we also need to make sure all annotators can be instantiated with existing layers which match the spec