diff --git a/requirements.txt b/requirements.txt
index b02edbd..cc31bfc 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,7 +1,7 @@
 napari-plugin-engine>=0.1.9
 napari>=0.4.3
 numpy
-scikit-image
+scikit-image>=0.19.2
 magicgui>=0.2.5,!=0.2.7
-napari
 toolz
+zarr
\ No newline at end of file
diff --git a/setup.cfg b/setup.cfg
index fb10c31..5f3d71c 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -30,7 +30,7 @@ install_requires =
     napari>=0.4.17
     npe2>=0.1.2
     numpy
-    scikit-image
+    scikit-image>=0.19.2
     magicgui>=0.3.7
     toolz
 python_requires = >=3.9
diff --git a/src/affinder/_test_data.py b/src/affinder/_test_data.py
new file mode 100644
index 0000000..26b40b5
--- /dev/null
+++ b/src/affinder/_test_data.py
@@ -0,0 +1,72 @@
+import numpy as np
+from scipy import ndimage as ndi
+from skimage import data, feature, filters, util, segmentation, morphology, transform
+import toolz as tz
+
+median_filter = tz.curry(ndi.median_filter)
+remove_holes = tz.curry(morphology.remove_small_holes)
+remove_objects = tz.curry(morphology.remove_small_objects)
+
+
+@tz.curry
+def threshold_with(image, method=filters.threshold_li):
+    return image > method(image)
+
+
+to_origin = np.array([0, -127.5, -127.5])
+c = np.cos(np.radians(60))
+s = np.sin(np.radians(60))
+rot60 = np.array([
+        [1, 0, 0],
+        [0, c, -s],
+        [0, s, c],
+        ])
+from_origin = -to_origin
+trans = np.array([0, 5, 10])
+
+nuclei = data.cells3d()[:, 1, ...]
+nuclei_rotated = ndi.rotate(nuclei, 60, axes=(1, 2), reshape=False)
+nuclei_rotated_translated = ndi.shift(nuclei_rotated, trans)
+nuclei_points = feature.peak_local_max(filters.gaussian(nuclei, 15))
+
+nuclei_points_rotated_translated = ((nuclei_points+to_origin) @ rot60.T
+                                    + from_origin + trans)
+
+nuclei_binary = tz.pipe(
+        nuclei,
+        median_filter(size=3),
+        threshold_with(method=filters.threshold_li),
+        remove_holes(area_threshold=20**3),
+        remove_objects(min_size=20**3),
+        )
+nuclei_labels = segmentation.watershed(
+        filters.farid(nuclei),
+        markers=util.label_points(nuclei_points, nuclei.shape),
+        mask=nuclei_binary,
+        )
+nuclei_labels_rotated = ndi.rotate(
+        nuclei_labels, 60, axes=(1, 2), reshape=False, order=0
+        )
+nuclei_labels_rotated_translated = ndi.shift(nuclei_labels, trans, order=0)
+
+nuclei2d = nuclei[30]
+nuclei2d_points = nuclei_points[:, 1:]  # remove z = project onto yx
+nuclei2d_rotated = nuclei_rotated[30]
+nuclei2d_rotated_translated = nuclei_rotated_translated[30]
+nuclei2d_labels = nuclei_labels[30]
+nuclei2d_labels_rotated_translated = nuclei_labels_rotated_translated[30]
+nuclei2d_points_rotated_translated = nuclei_points_rotated_translated[:, 1:]
+
+if __name__ == '__main__':
+    import napari
+    viewer = napari.Viewer(ndisplay=3)
+    viewer.add_image(nuclei, blending='additive')
+    viewer.add_points(nuclei_points)
+    viewer.add_labels(nuclei_labels, blending='translucent_no_depth')
+    viewer.add_image(nuclei_rotated_translated, blending='additive')
+    viewer.add_points(nuclei_points_rotated_translated, face_color='red')
+    viewer.add_labels(nuclei_labels_rotated, blending='translucent_no_depth')
+
+    viewer.grid.enabled = True
+    viewer.grid.stride = 3
+    napari.run()
diff --git a/src/affinder/_tests/labels0.zarr/.zarray b/src/affinder/_tests/labels0.zarr/.zarray
deleted file mode 100644
index 31d4d6a..0000000
--- a/src/affinder/_tests/labels0.zarr/.zarray
+++ /dev/null
@@ -1,22 +0,0 @@
-{
-    "chunks": [
-        512,
-        512
-    ],
-    "compressor": {
-        "blocksize": 0,
-        "clevel": 5,
-        "cname": "lz4",
-        "id": "blosc",
-        "shuffle": 1
-    },
-    "dtype": "<i2",
-    "fill_value": 0,
-    "filters": null,
-    "order": "C",
-    "shape": [
-        512,
-        512
-    ],
-    "zarr_format": 2
-}
\ No newline at end of file
diff --git a/src/affinder/_tests/labels0.zarr/0.0 b/src/affinder/_tests/labels0.zarr/0.0
deleted file mode 100644
index 7756b6f..0000000
Binary files a/src/affinder/_tests/labels0.zarr/0.0 and /dev/null differ
diff --git a/src/affinder/_tests/labels1.zarr/.zarray b/src/affinder/_tests/labels1.zarr/.zarray
deleted file mode 100644
index 31d4d6a..0000000
--- a/src/affinder/_tests/labels1.zarr/.zarray
+++ /dev/null
@@ -1,22 +0,0 @@
-{
-    "chunks": [
-        512,
-        512
-    ],
-    "compressor": {
-        "blocksize": 0,
-        "clevel": 5,
-        "cname": "lz4",
-        "id": "blosc",
-        "shuffle": 1
-    },
-    "dtype": "<i2",
-    "fill_value": 0,
-    "filters": null,
-    "order": "C",
-    "shape": [
-        512,
-        512
-    ],
-    "zarr_format": 2
-}
\ No newline at end of file
diff --git a/src/affinder/_tests/labels1.zarr/0.0 b/src/affinder/_tests/labels1.zarr/0.0
deleted file mode 100644
index b015a44..0000000
Binary files a/src/affinder/_tests/labels1.zarr/0.0 and /dev/null differ
diff --git a/src/affinder/_tests/test_affinder.py b/src/affinder/_tests/test_affinder.py
index b9246e3..a7441d1 100644
--- a/src/affinder/_tests/test_affinder.py
+++ b/src/affinder/_tests/test_affinder.py
@@ -6,24 +6,11 @@
 import zarr
 import napari
 import pytest
-from scipy import ndimage as ndi
 from pathlib import Path
+from copy import copy
+from scipy import ndimage as ndi
 
-layer0_pts = np.array([[140.38371886,
-                        322.5390704], [181.91866481, 319.65803368],
-                       [176.15659138, 259.1562627],
-                       [140.14363246, 254.59462124]])
-layer1_pts = np.array([[70.94741072,
-                        117.37477536], [95.80911919, 152.00358359],
-                       [143.16475439, 118.55866623],
-                       [131.32584559, 83.33791256]])
-
-# get reference and moving layer types
-im0 = data.camera()
-im1 = transform.rotate(im0[100:, 32:496], 60)
-this_dir = Path(__file__).parent.absolute()
-labels0 = zarr.open(this_dir / 'labels0.zarr', mode='r')
-labels1 = zarr.open(this_dir / 'labels1.zarr', mode='r')
+from affinder import _test_data as dat
 
 
 def make_vector_border(layer_pts):
@@ -35,54 +22,165 @@ def make_vector_border(layer_pts):
     return vectors
 
 
-vectors0 = make_vector_border(layer0_pts)
-vectors1 = make_vector_border(layer1_pts)
+def generate_all_layer_types(image, pts, labels):
+    layers = [
+            napari.layers.Image(image),
+            #napari.layers.Shapes(pts, shape_type='polygon'),
+            napari.layers.Points(pts),
+            napari.layers.Labels(labels),
+            napari.layers.Vectors(make_vector_border(pts)),
+            ]
+
+    return layers
+
+
+layers2d = generate_all_layer_types(
+        dat.nuclei2d, dat.nuclei2d_points, dat.nuclei2d_labels
+        )
+layers2d_transformed = generate_all_layer_types(
+        dat.nuclei2d_rotated_translated,
+        dat.nuclei2d_points_rotated_translated,
+        dat.nuclei2d_labels_rotated_translated,
+        )
+layers3d = generate_all_layer_types(
+        dat.nuclei, dat.nuclei_points, dat.nuclei_labels
+        )
+layers3d_transformed = generate_all_layer_types(
+        dat.nuclei_rotated_translated,
+        dat.nuclei_points_rotated_translated,
+        dat.nuclei_labels_rotated_translated,
+        )
+
+
+# 2D as reference, 2D as moving
+@pytest.mark.parametrize(
+        "reference,moving,model_class",
+        product(layers2d, layers2d_transformed, AffineTransformChoices)
+        )
+def test_2d_2d(make_napari_viewer, tmp_path, reference, moving, model_class):
+    """Test a 2D reference layer with a 2D moving layer."""
+
+    viewer = make_napari_viewer()
+
+    l0 = viewer.add_layer(reference)
+    l0.name = "layer0"
+
+    l1 = viewer.add_layer(moving)
+    l1.name = 'layer1'
+
+    affinder_widget = start_affinder()
+    affinder_widget(
+            viewer=viewer,
+            reference=l0,
+            moving=l1,
+            model=model_class,
+            output=tmp_path / 'my_affine.txt'
+            )
+
+    viewer.layers['layer0_pts'].data = dat.nuclei2d_points
+    viewer.layers['layer1_pts'].data = dat.nuclei2d_points_rotated_translated
+
+    actual_affine = np.asarray(l1.affine)
 
-ref = [
-        napari.layers.Image(im0),
-        napari.layers.Shapes(layer0_pts),
-        napari.layers.Points(layer0_pts),
-        napari.layers.Labels(labels0),
-        napari.layers.Vectors(vectors0),
-        ]
-mov = [
-        napari.layers.Image(im1),
-        napari.layers.Shapes(layer1_pts),
-        napari.layers.Points(layer1_pts),
-        napari.layers.Labels(labels1),
-        napari.layers.Vectors(vectors1),
-        ]
-# TODO add tracks layer types, after multidim affine support added
+    model = model_class.value(dimensionality=2)
+    model.estimate(
+            viewer.layers['layer1_pts'].data, viewer.layers['layer0_pts'].data
+            )
+    expected_affine = model.params
 
+    np.testing.assert_allclose(
+            actual_affine, expected_affine, rtol=10, atol=1e-10
+            )
+
+
+# 3D as reference, 2D as moving
+@pytest.mark.parametrize(
+        "reference,moving,model_class",
+        product(layers3d, layers2d_transformed, AffineTransformChoices)
+        )
+def test_3d_2d(make_napari_viewer, tmp_path, reference, moving, model_class):
+    """Test a 3D reference layer with a 2D moving layer.
 
-@pytest.mark.parametrize("reference,moving", [p for p in product(ref, mov)])
-def test_layer_types(make_napari_viewer, tmp_path, reference, moving):
+    The estimation dimension is always the minimum of the two, so this test
+    uses 2D points to estimate the transform.
+    """
 
     viewer = make_napari_viewer()
 
     l0 = viewer.add_layer(reference)
-    l0.name = 'layer0'
+    l0.name = "layer0"
+
     l1 = viewer.add_layer(moving)
-    l1.name = 'layer1'
+    l1.name = "layer1"
 
-    my_widget_factory = start_affinder()
-    my_widget_factory(
+    affinder_widget = start_affinder()
+    affinder_widget(
             viewer=viewer,
             reference=l0,
             moving=l1,
-            model=AffineTransformChoices.affine,
+            model=model_class,
             output=tmp_path / 'my_affine.txt'
             )
 
-    viewer.layers['layer0_pts'].data = layer0_pts
-    viewer.layers['layer1_pts'].data = layer1_pts
+    viewer.layers['layer0_pts'].data = dat.nuclei2d_points
+    viewer.layers['layer1_pts'].data = dat.nuclei2d_points_rotated_translated
 
     actual_affine = np.asarray(l1.affine)
-    expected_affine = np.array([[0.48155037, 0.85804854, 5.43577937],
-                                [-0.88088632, 0.49188026, 328.20642821],
-                                [0., 0., 1.]])
 
-    np.testing.assert_allclose(actual_affine, expected_affine)
+    model = model_class.value(dimensionality=2)
+    model.estimate(
+            viewer.layers['layer1_pts'].data, viewer.layers['layer0_pts'].data
+            )
+    expected_affine = model.params
+
+    np.testing.assert_allclose(
+            actual_affine, expected_affine, rtol=10, atol=1e-10
+            )
+
+
+@pytest.mark.parametrize(
+        "reference,moving,model_class",
+        product(layers3d, layers3d_transformed, AffineTransformChoices)
+        )
+def test_3d_3d(make_napari_viewer, tmp_path, reference, moving, model_class):
+    """Test a 3D reference layer with a 3D moving layer.
+
+    Point clicking in 3D is hard but this should still work, for example if
+    you combine it with a plugin such as napari-threedee to click on points
+    in 3D space.
+    """
+
+    viewer = make_napari_viewer()
+
+    l0 = viewer.add_layer(reference)
+    l0.name = "layer0"
+
+    l1 = viewer.add_layer(moving)
+    l1.name = "layer1"
+
+    affinder_widget = start_affinder()
+    affinder_widget(
+            viewer=viewer,
+            reference=l0,
+            moving=l1,
+            model=model_class,
+            output=tmp_path / 'my_affine.txt'
+            )
+
+    viewer.layers['layer0_pts'].data = dat.nuclei_points
+    viewer.layers['layer1_pts'].data = dat.nuclei_points_rotated_translated
+
+    actual_affine = np.asarray(l1.affine)
+
+    model = model_class.value(dimensionality=3)
+    model.estimate(
+            viewer.layers['layer1_pts'].data, viewer.layers['layer0_pts'].data
+            )
+    expected_affine = model.params
+
+    np.testing.assert_allclose(
+            actual_affine, expected_affine, rtol=10, atol=1e-10
+            )
 
 
 def test_ensure_different_layers(make_napari_viewer):
diff --git a/src/affinder/affinder.py b/src/affinder/affinder.py
index 4da9bb5..8b51026 100644
--- a/src/affinder/affinder.py
+++ b/src/affinder/affinder.py
@@ -3,6 +3,11 @@
 import warnings
 from enum import Enum
 from typing import Optional
+import napari
+from napari.layers import Image, Labels, Shapes, Points, Vectors
+from enum import Enum
+import pathlib
+from copy import deepcopy
 
 import numpy as np
 import toolz as tz
@@ -23,7 +28,10 @@ class AffineTransformChoices(Enum):
 def reset_view(viewer: 'napari.Viewer', layer: 'napari.layers.Layer'):
     if viewer.dims.ndisplay != 2:
         return
-    extent = layer.extent.world[:, viewer.dims.displayed]
+    if len(viewer.dims.displayed) == layer.extent.world.shape[1]:
+        extent = layer.extent.world
+    else:
+        extent = layer.extent.world[:, viewer.dims.displayed]
     size = extent[1] - extent[0]
     center = extent[0] + size/2
     viewer.camera.center = center
@@ -43,7 +51,7 @@ def next_layer_callback(
         moving_image_layer,
         moving_points_layer,
         model_class,
-        output,
+        output
         ):
     pts0, pts1 = reference_points_layer.data, moving_points_layer.data
     n0, n1 = len(pts0), len(pts1)
@@ -63,12 +71,18 @@ def next_layer_callback(
             # we just added enough points:
             # estimate transform, go back to layer0
             if n0 > ndim:
-                mat = calculate_transform(pts0, pts1, model_class=model_class)
-                moving_image_layer.affine = (
-                        reference_image_layer.affine.affine_matrix @ mat.params
+                mat = calculate_transform(
+                        pts0, pts1, ndim, model_class=model_class
                         )
-                moving_points_layer.affine = (
-                        reference_image_layer.affine.affine_matrix @ mat.params
+                ref_mat = reference_image_layer.affine.affine_matrix
+                # must shrink ndims of affine matrix if dims of image layer is bigger than moving layer #####
+                if reference_image_layer.ndim > moving_image_layer.ndim:
+                    ref_mat = convert_affine_to_ndims(
+                            ref_mat, moving_image_layer.ndim
+                            )
+                # must pad affine matrix with identity matrix if dims of moving layer smaller #####
+                moving_image_layer.affine = convert_affine_to_ndims(
+                        (ref_mat @ mat.params), moving_image_layer.ndim
                         )
                 if output is not None:
                     np.savetxt(output, np.asarray(mat.params), delimiter=',')
@@ -91,6 +105,22 @@ def remove_pts_layers(viewer, layers):
         viewer.layers.remove(layer)
 
 
+def convert_affine_to_ndims(affine, target_ndim):
+    """Either embed or slice an affine matrix to match the target ndims."""
+    affine_matrix = np.asarray(affine)
+    diff = np.shape(affine_matrix)[0] - 1 - target_ndim
+    if diff == 0:
+        out = affine_matrix
+    elif diff < 0:
+        # target is larger, so embed
+        out = np.identity(target_ndim + 1)
+        out[-diff:, -diff:] = affine_matrix
+    else:  # diff > 0
+        out = affine_matrix[diff:, diff:]
+
+    return out
+
+
 def _update_unique_choices(widget, choice_name):
     """Update the selected choice in a ComboBox widget to be unique.
 
@@ -129,7 +159,10 @@ def _on_affinder_main_init(widget):
         widget_init=_on_affinder_main_init,
         call_button='Start',
         layout='vertical',
-        output={'mode': 'w', 'label': 'Save transformation as', 'filter': '*.txt'},
+        output={
+                'mode': 'w', 'label': 'Save transformation as', 'filter':
+                        '*.txt'
+                },
         viewer={'visible': False, 'label': ' '},
         delete_pts={
                 'label':
@@ -154,6 +187,7 @@ def start_affinder(
     mode = start_affinder._call_button.text  # can be "Start" or "Finish"
 
     if mode == 'Start':
+
         # focus on the reference layer
         reset_view(viewer, reference)
         # set points layer for each image
@@ -161,20 +195,23 @@ def start_affinder(
         # Use C0 and C1 from matplotlib color cycle
         points_layers_to_add = [(reference, (0.122, 0.467, 0.706, 1.0)),
                                 (moving, (1.0, 0.498, 0.055, 1.0))]
+
         # make points layer if it was not specified
+        estimation_ndim = min(reference.ndim, moving.ndim)
         for i in range(len(points_layers)):
             if points_layers[i] is None:
                 layer, color = points_layers_to_add[i]
                 new_layer = viewer.add_points(
-                        ndim=layer.ndim,
+                        ndim=estimation_ndim, # ndims of all points layers same lowest ndim of reference or moving
                         name=layer.name + '_pts',
-                        affine=layer.affine,
+                        affine=convert_affine_to_ndims(
+                                layer.affine, estimation_ndim
+                                ),
                         face_color=[color],
                         )
                 points_layers[i] = new_layer
         pts_layer0 = points_layers[0]
         pts_layer1 = points_layers[1]
-
         # make a callback for points added
         callback = next_layer_callback(
                 viewer=viewer,
@@ -183,7 +220,7 @@ def start_affinder(
                 moving_image_layer=moving,
                 moving_points_layer=pts_layer1,
                 model_class=model.value,
-                output=output,
+                output=output
                 )
         pts_layer0.events.data.connect(callback)
         pts_layer1.events.data.connect(callback)
@@ -210,7 +247,7 @@ def start_affinder(
         start_affinder._call_button.text = 'Start'
 
 
-def calculate_transform(src, dst, model_class=AffineTransform):
+def calculate_transform(src, dst, ndim, model_class=AffineTransform):
     """Calculate transformation matrix from matched coordinate pairs.
 
     Parameters
@@ -227,6 +264,11 @@ def calculate_transform(src, dst, model_class=AffineTransform):
     transform
         scikit-image Transformation object
     """
-    model = model_class()
-    model.estimate(dst, src)  # we want the inverse
+    # convert points to correct dimension (from right bottom corner)
+    # pos_val = lambda x: x if x > 0 else 0
+
+    # do transform
+    model = model_class(dimensionality=ndim)
+    model.estimate(dst, src)  # we want
+    # the inverse
     return model