monai-weekly 1.5.dev2505__py3-none-any.whl → 1.5.dev2507__py3-none-any.whl

tests/transforms/test_add_extreme_points_channeld.py

@@ -0,0 +1,77 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import AddExtremePointsChanneld
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+IMG_CHANNEL = 3
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    for q in TEST_NDARRAYS:
+        TESTS.append(
+            [
+                {
+                    "img": p(np.zeros((IMG_CHANNEL, 4, 3))),
+                    "label": q(np.array([[[0, 1, 0], [0, 0, 1], [0, 1, 0], [1, 0, 0]]])),
+                },
+                p(
+                    np.array(
+                        [
+                            [0.38318458, 0.98615628, 0.85551184],
+                            [0.35422316, 0.94430935, 1.0],
+                            [0.46000731, 0.57319659, 0.46000722],
+                            [0.64577687, 0.38318464, 0.0],
+                        ]
+                    )
+                ),
+            ]
+        )
+
+        TESTS.append(
+            [
+                {
+                    "img": p(np.zeros((IMG_CHANNEL, 4, 3))),
+                    "label": q(np.array([[[0, 1, 0], [1, 1, 1], [0, 1, 0], [0, 1, 0]]])),
+                },
+                p(
+                    np.array(
+                        [
+                            [0.44628328, 0.80495411, 0.44628328],
+                            [0.6779086, 1.0, 0.67790854],
+                            [0.33002687, 0.62079221, 0.33002687],
+                            [0.0, 0.31848389, 0.0],
+                        ]
+                    )
+                ),
+            ]
+        )
+
+
+class TestAddExtremePointsChanneld(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_correct_results(self, input_data, expected):
+        add_extreme_points_channel = AddExtremePointsChanneld(
+            keys="img", label_key="label", sigma=1.0, rescale_min=0.0, rescale_max=1.0
+        )
+        result = add_extreme_points_channel(input_data)
+        assert_allclose(result["img"][IMG_CHANNEL], expected, rtol=1e-4, atol=1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_adjust_contrast.py

@@ -0,0 +1,70 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import AdjustContrast
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+TESTS = []
+for invert_image in (True, False):
+    for retain_stats in (True, False):
+        TEST_CASE_1 = [1.0, invert_image, retain_stats]
+        TEST_CASE_2 = [0.5, invert_image, retain_stats]
+        TEST_CASE_3 = [4.5, invert_image, retain_stats]
+
+        TESTS.extend([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+
+
+class TestAdjustContrast(NumpyImageTestCase2D):
+    @parameterized.expand(TESTS)
+    def test_correct_results(self, gamma, invert_image, retain_stats):
+        adjuster = AdjustContrast(gamma=gamma, invert_image=invert_image, retain_stats=retain_stats)
+        for p in TEST_NDARRAYS:
+            im = p(self.imt)
+            result = adjuster(im)
+            self.assertTrue(type(im), type(result))
+            if False:  # gamma == 1.0:
+                expected = self.imt
+            else:
+                if invert_image:
+                    self.imt = -self.imt
+
+                if retain_stats:
+                    mn = self.imt.mean()
+                    sd = self.imt.std()
+
+                epsilon = 1e-7
+                img_min = self.imt.min()
+                img_range = self.imt.max() - img_min
+
+                expected = np.power(((self.imt - img_min) / float(img_range + epsilon)), gamma) * img_range + img_min
+
+                if retain_stats:
+                    # zero mean and normalize
+                    expected = expected - expected.mean()
+                    expected = expected / (expected.std() + 1e-8)
+                    # restore old mean and standard deviation
+                    expected = sd * expected + mn
+
+                if invert_image:
+                    expected = -expected
+
+            assert_allclose(result, expected, atol=1e-05, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_adjust_contrastd.py

@@ -0,0 +1,64 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms import AdjustContrastd
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+TESTS = []
+for invert_image in (True, False):
+    for retain_stats in (True, False):
+        TEST_CASE_1 = [1.0, invert_image, retain_stats]
+        TEST_CASE_2 = [0.5, invert_image, retain_stats]
+        TEST_CASE_3 = [4.5, invert_image, retain_stats]
+
+        TESTS.extend([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+
+
+class TestAdjustContrastd(NumpyImageTestCase2D):
+    @parameterized.expand(TESTS)
+    def test_correct_results(self, gamma, invert_image, retain_stats):
+        adjuster = AdjustContrastd("img", gamma=gamma, invert_image=invert_image, retain_stats=retain_stats)
+        for p in TEST_NDARRAYS:
+            result = adjuster({"img": p(self.imt)})
+            if invert_image:
+                self.imt = -self.imt
+
+            if retain_stats:
+                mn = self.imt.mean()
+                sd = self.imt.std()
+
+            epsilon = 1e-7
+            img_min = self.imt.min()
+            img_range = self.imt.max() - img_min
+
+            expected = np.power(((self.imt - img_min) / float(img_range + epsilon)), gamma) * img_range + img_min
+
+            if retain_stats:
+                # zero mean and normalize
+                expected = expected - expected.mean()
+                expected = expected / (expected.std() + 1e-8)
+                # restore old mean and standard deviation
+                expected = sd * expected + mn
+
+            if invert_image:
+                expected = -expected
+            assert_allclose(result["img"], expected, atol=1e-05, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_affine.py

@@ -0,0 +1,245 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+from copy import deepcopy
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.data import MetaTensor, set_track_meta
+from monai.transforms import Affine, Resize
+from monai.transforms.lazy.functional import apply_pending
+from monai.utils import optional_import
+from tests.lazy_transforms_utils import test_resampler_lazy
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose, test_local_inversion
+
+TESTS = []
+for p in TEST_NDARRAYS_ALL:
+    for device in [None, "cpu", "cuda"] if torch.cuda.is_available() else [None, "cpu"]:
+        TESTS.append(
+            [
+                dict(padding_mode="zeros", device=device),
+                {"img": p(np.arange(9).reshape((1, 3, 3))), "spatial_size": (-1, 0)},
+                p(np.arange(9).reshape(1, 3, 3)),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(padding_mode="zeros", device=device, image_only=True),
+                {"img": p(np.arange(9).reshape((1, 3, 3))), "spatial_size": (-1, 0)},
+                p(np.arange(9).reshape(1, 3, 3)),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(padding_mode="zeros", device=device),
+                {"img": p(np.arange(4).reshape((1, 2, 2)))},
+                p(np.arange(4).reshape(1, 2, 2)),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(padding_mode="zeros", device=device),
+                {"img": p(np.arange(4).reshape((1, 2, 2))), "spatial_size": (4, 4)},
+                p(np.array([[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 2.0, 3.0, 0.0], [0.0, 0.0, 0.0, 0.0]]])),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(rotate_params=[np.pi / 2], padding_mode="zeros", device=device),
+                {"img": p(np.arange(4).reshape((1, 2, 2))), "spatial_size": (4, 4)},
+                p(np.array([[[0.0, 0.0, 0.0, 0.0], [0.0, 2.0, 0.0, 0.0], [0.0, 3.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]]])),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(rotate_params=[np.pi / 2], padding_mode="zeros", device=device, align_corners=False),
+                {"img": p(np.arange(4).reshape((1, 2, 2))), "spatial_size": (4, 4)},
+                p(np.array([[[0.0, 0.0, 0.0, 0.0], [0.0, 2.0, 0.0, 0.0], [0.0, 3.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]]])),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(
+                    affine=p(torch.tensor([[0.0, -1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]])),
+                    padding_mode="zeros",
+                    device=device,
+                ),
+                {"img": p(np.arange(4).reshape((1, 2, 2))), "spatial_size": (4, 4)},
+                p(np.array([[[0.0, 0.0, 0.0, 0.0], [0.0, 2.0, 0.0, 0.0], [0.0, 3.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]]])),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(padding_mode="zeros", device=device),
+                {"img": p(np.arange(27).reshape((1, 3, 3, 3))), "spatial_size": (-1, 0, 0)},
+                p(np.arange(27).reshape(1, 3, 3, 3)),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(padding_mode="zeros", device=device),
+                {"img": p(np.arange(8).reshape((1, 2, 2, 2))), "spatial_size": (4, 4, 4)},
+                p(
+                    np.array(
+                        [
+                            [
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 1.0, 0.0],
+                                    [0.0, 2.0, 3.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 4.0, 5.0, 0.0],
+                                    [0.0, 6.0, 7.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                            ]
+                        ]
+                    )
+                ),
+            ]
+        )
+        TESTS.append(
+            [
+                dict(rotate_params=[np.pi / 2], padding_mode="zeros", device=device),
+                {"img": p(np.arange(8).reshape((1, 2, 2, 2))), "spatial_size": (4, 4, 4)},
+                p(
+                    np.array(
+                        [
+                            [
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 2.0, 0.0, 0.0],
+                                    [0.0, 3.0, 1.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 6.0, 4.0, 0.0],
+                                    [0.0, 7.0, 5.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                                [
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                    [0.0, 0.0, 0.0, 0.0],
+                                ],
+                            ]
+                        ]
+                    )
+                ),
+            ]
+        )
+
+
+class TestAffine(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_affine(self, input_param, input_data, expected_val):
+        input_copy = deepcopy(input_data["img"])
+        g = Affine(**input_param)
+        result = g(**input_data)
+        output_idx = None
+        if isinstance(result, tuple):
+            output_idx = 0
+            result = result[output_idx]
+
+        test_local_inversion(g, result, input_copy)
+        assert_allclose(result, expected_val, rtol=1e-4, atol=1e-4, type_test=False)
+
+        set_track_meta(False)
+        result = g(**input_data)
+        if isinstance(result, tuple):
+            result = result[0]
+        self.assertNotIsInstance(result, MetaTensor)
+        self.assertIsInstance(result, torch.Tensor)
+        set_track_meta(True)
+
+        # test lazy
+        lazy_input_param = input_param.copy()
+        for align_corners in [True, False]:
+            lazy_input_param["align_corners"] = align_corners
+            resampler = Affine(**lazy_input_param)
+            non_lazy_result = resampler(**input_data)
+            test_resampler_lazy(resampler, non_lazy_result, lazy_input_param, input_data, output_idx=output_idx)
+
+
+@unittest.skipUnless(optional_import("scipy")[1], "Requires scipy library.")
+class TestAffineConsistency(unittest.TestCase):
+    @parameterized.expand([[7], [8], [9]])
+    def test_affine_resize(self, s):
+        """s"""
+        im = np.arange(4).reshape(1, 2, 2).astype(float)
+        mat = np.array([[1 / s, 0, 0], [0, 1 / s, 0], [0, 0, 1]])
+        sp_size = 2 * s
+
+        def method_0(im, ac):
+            xform = Affine(align_corners=ac, affine=mat, image_only=True, spatial_size=sp_size)
+            xform.lazy = True
+            out = xform(im)
+            overrides = {"padding_mode": "border", "align_corners": ac}
+            out = apply_pending(out, overrides=overrides)[0]
+            return out
+
+        def method_1(im, ac):
+            xform = Affine(align_corners=ac, affine=mat, image_only=True, spatial_size=sp_size)
+            xform.lazy = True
+            out = xform(im)
+            overrides = {"mode": 1, "padding_mode": "nearest", "align_corners": ac}
+            out = apply_pending(out, overrides=overrides)[0]
+            return out
+
+        def method_2(im, ac):
+            xform = Affine(align_corners=ac, affine=mat, padding_mode="border", image_only=True, spatial_size=sp_size)
+            out = xform(im)
+            return out
+
+        def method_3(im, ac):
+            xform = Affine(
+                align_corners=ac, affine=mat, mode=1, padding_mode="nearest", image_only=True, spatial_size=sp_size
+            )
+            out = xform(im)
+            return out
+
+        for call in (method_0, method_1, method_2, method_3):
+            for ac in (False, True):
+                out = call(im, ac)
+                ref = Resize(align_corners=ac, spatial_size=(sp_size, sp_size), mode="bilinear")(im)
+                assert_allclose(out, ref, rtol=1e-4, atol=1e-4, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/test_affine_grid.py

@@ -0,0 +1,152 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.data import MetaTensor, set_track_meta
+from monai.transforms import AffineGrid
+from tests.test_utils import TEST_NDARRAYS_ALL, assert_allclose, is_tf32_env
+
+TESTS = []
+for p in TEST_NDARRAYS_ALL:
+    for device in [None, "cpu", "cuda"] if torch.cuda.is_available() else [None, "cpu"]:
+        TESTS.append(
+            [
+                {"device": device},
+                {"spatial_size": (2, 2)},
+                np.array([[[-0.5, -0.5], [0.5, 0.5]], [[-0.5, 0.5], [-0.5, 0.5]], [[1.0, 1.0], [1.0, 1.0]]]),
+            ]
+        )
+
+        TESTS.append([{"device": device}, {"grid": p(np.ones((3, 3, 3)))}, p(np.ones((3, 3, 3)))])
+        TESTS.append([{"device": device}, {"grid": p(torch.ones((3, 3, 3)))}, p(np.ones((3, 3, 3)))])
+        TESTS.append(
+            [
+                {"rotate_params": (1.0, 1.0), "scale_params": (-20, 10), "device": device},
+                {"grid": p(torch.ones((3, 3, 3)))},
+                p(
+                    torch.tensor(
+                        [
+                            [
+                                [-19.2208, -19.2208, -19.2208],
+                                [-19.2208, -19.2208, -19.2208],
+                                [-19.2208, -19.2208, -19.2208],
+                            ],
+                            [
+                                [-11.4264, -11.4264, -11.4264],
+                                [-11.4264, -11.4264, -11.4264],
+                                [-11.4264, -11.4264, -11.4264],
+                            ],
+                            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                        ]
+                    )
+                ),
+            ]
+        )
+        TESTS.append(
+            [
+                {
+                    "affine": p(
+                        torch.tensor(
+                            [[-10.8060, -8.4147, 0.0000], [-16.8294, 5.4030, 0.0000], [0.0000, 0.0000, 1.0000]]
+                        )
+                    )
+                },
+                {"grid": p(torch.ones((3, 3, 3)))},
+                p(
+                    torch.tensor(
+                        [
+                            [
+                                [-19.2208, -19.2208, -19.2208],
+                                [-19.2208, -19.2208, -19.2208],
+                                [-19.2208, -19.2208, -19.2208],
+                            ],
+                            [
+                                [-11.4264, -11.4264, -11.4264],
+                                [-11.4264, -11.4264, -11.4264],
+                                [-11.4264, -11.4264, -11.4264],
+                            ],
+                            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                        ]
+                    )
+                ),
+            ]
+        )
+        TESTS.append(
+            [
+                {"rotate_params": (1.0, 1.0, 1.0), "scale_params": (-20, 10), "device": device},
+                {"grid": p(torch.ones((4, 3, 3, 3)))},
+                p(
+                    torch.tensor(
+                        [
+                            [
+                                [[-9.5435, -9.5435, -9.5435], [-9.5435, -9.5435, -9.5435], [-9.5435, -9.5435, -9.5435]],
+                                [[-9.5435, -9.5435, -9.5435], [-9.5435, -9.5435, -9.5435], [-9.5435, -9.5435, -9.5435]],
+                                [[-9.5435, -9.5435, -9.5435], [-9.5435, -9.5435, -9.5435], [-9.5435, -9.5435, -9.5435]],
+                            ],
+                            [
+                                [
+                                    [-20.2381, -20.2381, -20.2381],
+                                    [-20.2381, -20.2381, -20.2381],
+                                    [-20.2381, -20.2381, -20.2381],
+                                ],
+                                [
+                                    [-20.2381, -20.2381, -20.2381],
+                                    [-20.2381, -20.2381, -20.2381],
+                                    [-20.2381, -20.2381, -20.2381],
+                                ],
+                                [
+                                    [-20.2381, -20.2381, -20.2381],
+                                    [-20.2381, -20.2381, -20.2381],
+                                    [-20.2381, -20.2381, -20.2381],
+                                ],
+                            ],
+                            [
+                                [[-0.5844, -0.5844, -0.5844], [-0.5844, -0.5844, -0.5844], [-0.5844, -0.5844, -0.5844]],
+                                [[-0.5844, -0.5844, -0.5844], [-0.5844, -0.5844, -0.5844], [-0.5844, -0.5844, -0.5844]],
+                                [[-0.5844, -0.5844, -0.5844], [-0.5844, -0.5844, -0.5844], [-0.5844, -0.5844, -0.5844]],
+                            ],
+                            [
+                                [[1.0000, 1.0000, 1.0000], [1.0000, 1.0000, 1.0000], [1.0000, 1.0000, 1.0000]],
+                                [[1.0000, 1.0000, 1.0000], [1.0000, 1.0000, 1.0000], [1.0000, 1.0000, 1.0000]],
+                                [[1.0000, 1.0000, 1.0000], [1.0000, 1.0000, 1.0000], [1.0000, 1.0000, 1.0000]],
+                            ],
+                        ]
+                    )
+                ),
+            ]
+        )
+
+_rtol = 5e-2 if is_tf32_env() else 1e-4
+
+
+class TestAffineGrid(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_affine_grid(self, input_param, input_data, expected_val):
+        g = AffineGrid(**input_param)
+        set_track_meta(False)
+        result, _ = g(**input_data)
+        self.assertNotIsInstance(result, MetaTensor)
+        self.assertIsInstance(result, torch.Tensor)
+        set_track_meta(True)
+        if "device" in input_data:
+            self.assertEqual(result.device, input_data[device])
+        assert_allclose(result, expected_val, type_test=False, rtol=_rtol)
+
+
+if __name__ == "__main__":
+    unittest.main()