def projection_closed_curves_test_data(self):
        cells, _, _ = data_utils.load_cells()
        curves = [cell[:-10] for cell in cells[:5]]
        ambient_manifold = Euclidean(dim=2)
        smoke_data = []
        for curve in curves:
            smoke_data += [
                dict(ambient_manifold=ambient_manifold, curve=curve)
            ]

        return self.generate_tests(smoke_data)
    def test_cartesian_to_polar_and_inverse(self):
        """Test that going back to cartesian works."""
        cells, _, _ = data_utils.load_cells()
        curve = cells[0]

        metric = self.elastic_metric
        norms, args = metric.cartesian_to_polar(curve)

        result = metric.polar_to_cartesian(norms, args)
        expected = curve
        self.assertAllClose(result, expected, rtol=10000 * gs.rtol)
    def test_elastic_dist(self):
        """Test shape and positivity."""
        cells, _, _ = data_utils.load_cells()
        curve_1, curve_2 = cells[0][:10], cells[1][:10]
        metric = self.elastic_metric
        dist = metric.dist(curve_1, curve_2)

        result = dist.shape
        expected = ()
        self.assertAllClose(result, expected)

        result = dist > 0
        self.assertTrue(result)
    def test_f_transform_and_inverse(self):
        """Test that the inverse is right."""
        cells, _, _ = data_utils.load_cells()
        curve = cells[0]
        metric = self.elastic_metric
        f = metric.f_transform(curve)
        f_inverse = metric.f_transform_inverse(f, curve[0])

        result = f.shape
        expected = (curve.shape[0] - 1, 2)
        self.assertAllClose(result, expected)

        result = f_inverse
        expected = curve
        self.assertAllClose(result, expected)
    def test_projection_closed_curves(self):
        """Test that projecting the projection returns the projection

        and that the projection is a closed curve."""
        planar_closed_curves = self.space_closed_curves_in_euclidean_2d

        cells, _, _ = data_utils.load_cells()
        curves = [cell[:-10] for cell in cells[:5]]

        for curve in curves:
            proj = planar_closed_curves.project(curve)
            expected = proj
            result = planar_closed_curves.project(proj)
            self.assertAllClose(result, expected)

            result = proj[-1, :]
            expected = proj[0, :]
            self.assertAllClose(result, expected, rtol=10 * gs.rtol)
    def test_cells(self):
        """Test that cells belong to space of planar curves."""
        cells, cell_lines, treatments = data_utils.load_cells()
        expected = 650
        result = len(cells)
        self.assertAllClose(result, expected)
        result = len(cell_lines)
        self.assertAllClose(result, expected)
        result = len(treatments)
        self.assertAllClose(result, expected)

        planar_curves_space = DiscreteCurves(R2)

        result = planar_curves_space.belongs(cells)
        self.assertTrue(gs.all(result))

        result = [line in ["dlm8", "dunn"] for line in cell_lines]
        self.assertTrue(gs.all(result))

        result = [
            treatment in ["control", "cytd", "jasp"]
            for treatment in treatments
        ]
        self.assertTrue(gs.all(result))
 def cartesian_to_polar_and_inverse_test_data(self):
     cells, _, _ = data_utils.load_cells()
     curve = cells[0]
     smoke_data = [dict(a=1.0, b=1.0, curve=curve)]
     return self.generate_tests(smoke_data)
 def elastic_dist_test_data(self):
     cells, _, _ = data_utils.load_cells()
     curve_1, curve_2 = cells[0][:10], cells[1][:10]
     smoke_data = [dict(a=1.0, b=0.5, curve_1=curve_1, curve_2=curve_2)]
     return self.generate_tests(smoke_data)
 def f_transform_and_inverse_test_data(self):
     cells, _, _ = data_utils.load_cells()
     curve = cells[0]
     smoke_data = [dict(a=1.0, b=0.5, curve=curve)]
     return self.generate_tests(smoke_data)