Exemple #1
0
    def test_constraint_global_noisy(self):
        hard_radius = 1.
        constraints = dimer_global(1, self.im.ndim)
        self.im.clear()
        self.im.draw_clusters(10, 2, hard_radius, 2*self.separation,
                              2*self.diameter)

        f0 = self.im.f(noise=self.pos_err)
        f0['signal'] = 180
        f0['size'] = 6.

        result = refine_leastsq(f0, self.im.noisy_image(0.2*self.signal),
                                self.diameter, self.separation,
                                constraints=constraints,
                                param_mode=dict(signal='global',
                                                size='global'),
                                options=dict(maxiter=1000))

        dists = []
        for _, f_cl in result.groupby('cluster'):
            pos = result[['y', 'x']].values
            dists.append(np.sqrt(np.sum(((pos[0] - pos[1])/np.array(self.im.size))**2)))

        assert_allclose(dists, 2*hard_radius, atol=0.1)

        assert_coordinates_close(result[self.im.pos_columns].values,
                                 self.im.coords, 0.1)
        assert_allclose(result['signal'].values, 200, atol=2)
        assert_allclose(result['size'].values, 5.25, atol=1)
Exemple #2
0
    def test_constraint_global_noisy(self):
        hard_radius = 1.
        constraints = dimer_global(1, self.im.ndim)
        self.im.clear()
        self.im.draw_clusters(10, 2, hard_radius, 2 * self.separation,
                              2 * self.diameter)

        f0 = self.im.f(noise=self.pos_err)
        f0['signal'] = 180
        f0['size'] = 6.

        result = refine_leastsq(f0,
                                self.im.noisy_image(0.2 * self.signal),
                                self.diameter,
                                self.separation,
                                constraints=constraints,
                                param_mode=dict(signal='global',
                                                size='global'),
                                options=dict(maxiter=1000))

        dists = []
        for _, f_cl in result.groupby('cluster'):
            pos = result[['y', 'x']].values
            dists.append(
                np.sqrt(np.sum(
                    ((pos[0] - pos[1]) / np.array(self.im.size))**2)))

        assert_allclose(dists, 2 * hard_radius, atol=0.1)

        assert_coordinates_close(result[self.im.pos_columns].values,
                                 self.im.coords, 0.1)
        assert_allclose(result['signal'].values, 200, atol=2)
        assert_allclose(result['size'].values, 5.25, atol=1)
Exemple #3
0
    def test_constraint_global_dimer(self):
        hard_radius = 1.
        constraints = dimer_global(1, self.im.ndim)
        self.im.clear()
        self.im.draw_clusters(10, 2, hard_radius, 2 * self.separation,
                              2 * self.diameter)

        f0 = self.im.f(noise=self.pos_err)
        result = refine_leastsq(f0,
                                self.im(),
                                self.diameter,
                                self.separation,
                                constraints=constraints,
                                options=dict(maxiter=1000))

        dists = []
        for _, f_cl in result.groupby('cluster'):
            pos = result[['y', 'x']].values
            dists.append(
                np.sqrt(np.sum(
                    ((pos[0] - pos[1]) / np.array(self.im.size))**2)))

        assert_allclose(dists, 2 * hard_radius, atol=0.01)

        assert_coordinates_close(result[self.im.pos_columns].values,
                                 self.im.coords, 0.1)
Exemple #4
0
    def refine_cluster(self, cluster_size, hard_radius, pos_diff=None,
                       signal_dev=None, size_dev=None, noise=None,
                       param_mode=None, angle=None, **kwargs):
        """
        Parameters
        ----------
        noise : integer
            noise level
        pos_diff :
            pixels deviation of p0 from true feature location
        signal_dev :
            deviation of feature signal with respect to p0
        size_dev :
            deviation of feature size with respect to p0
        """
        if param_mode is None:
            param_mode = self.param_mode
        else:
            param_mode = dict(self.param_mode, **param_mode)
        if pos_diff is None:
            pos_diff = self.pos_diff
        if signal_dev is None:
            signal_dev = self.signal_dev
        if size_dev is None:
            size_dev = self.size_dev
        if noise is None:
            noise = self.noise
        # generate image with array of features and deviating signal and size
        image, expected, clusters = self.get_image_clusters(cluster_size,
                                                            hard_radius,
                                                            noise, signal_dev,
                                                            size_dev, angle)
        expected_pos, expected_signal, expected_size = expected
        expected_center, expected_angle = clusters
        p0_pos = self.gen_p0_coords(expected_pos, pos_diff)
        f0 = self.to_dataframe(p0_pos, self.signal, self.size, cluster_size)
        # Set an estimate for the background value. Helps convergence,
        # especially for 3D tests with high noise (tested here: S/N = 3)
        f0['background'] = noise / 2

        actual = refine_leastsq(f0, image, self.diameter, separation=None,
                                param_mode=dict(self.param_mode, **param_mode),
                                param_val=self.param_val,
                                pos_columns=self.pos_columns,
                                t_column='frame',
                                fit_function=self.fit_func,
                                bounds=self.bounds, **kwargs)

        assert not np.any(np.isnan(actual['cost']))
        assert np.all(actual['cluster_size'] <= cluster_size)

        actual = self.from_dataframe(actual)
        actual_pos, actual_signal, actual_size, pos_err = actual
        deviations = self.get_deviations(actual_pos, expected_pos, cluster_size,
                                         expected_center, expected_angle)
        return self.compute_deviations_cluster(actual, expected, deviations)
Exemple #5
0
    def refine(self,
               pos_diff=None,
               signal_dev=None,
               size_dev=None,
               noise=None,
               param_mode=None,
               **kwargs):
        """
        Parameters
        ----------
        noise : integer
            noise level
        pos_diff :
            pixels deviation of p0 from true feature location
        signal_dev :
            deviation of feature signal with respect to p0
        size_dev :
            deviation of feature size with respect to p0
        """
        if param_mode is None:
            param_mode = self.param_mode
        else:
            param_mode = dict(self.param_mode, **param_mode)
        if pos_diff is None:
            pos_diff = self.pos_diff
        if signal_dev is None:
            signal_dev = self.signal_dev
        if size_dev is None:
            size_dev = self.size_dev
        if noise is None:
            noise = self.noise
        # generate image with array of features and deviating signal and size
        image, expected = self.get_image(noise, signal_dev, size_dev)
        expected_pos, expected_signal, expected_size = expected
        p0_pos = self.gen_p0_coords(expected_pos, pos_diff)
        f0 = self.to_dataframe(p0_pos, self.signal, self.size)
        # Set an estimate for the background value. Helps convergence,
        # especially for 3D tests with high noise (tested here: S/N = 3)
        f0['background'] = noise / 2

        actual = refine_leastsq(f0,
                                image,
                                self.diameter,
                                separation=None,
                                param_mode=dict(self.param_mode, **param_mode),
                                param_val=self.param_val,
                                pos_columns=self.pos_columns,
                                t_column='frame',
                                fit_function=self.fit_func,
                                bounds=self.bounds,
                                **kwargs)

        assert not np.any(np.isnan(actual['cost']))

        actual = self.from_dataframe(actual)
        return self.compute_deviations(actual, expected)
Exemple #6
0
    def test_multiple_overlapping(self):
        self.im.clear()
        self.im.draw_features(100, 15, self.diameter)

        f0 = self.im.f(noise=self.pos_err)

        result = refine_leastsq(f0, self.im(), self.diameter, self.separation)

        assert_coordinates_close(result[self.im.pos_columns].values,
                                 self.im.coords, 0.1)
Exemple #7
0
    def test_multiple_overlapping(self):
        self.im.clear()
        self.im.draw_features(100, 15, self.diameter)

        f0 = self.im.f(noise=self.pos_err)

        result = refine_leastsq(f0, self.im(), self.diameter, self.separation)

        assert_coordinates_close(result[self.im.pos_columns].values,
                                 self.im.coords, 0.1)
Exemple #8
0
    def test_var_global(self):
        self.im.clear()
        self.im.draw_features(100, 15, self.diameter)

        f0 = self.im.f(noise=self.pos_err)
        f0['signal'] = 180

        result = refine_leastsq(f0, self.im(), self.diameter, self.separation,
                                param_mode=dict(signal='global'),
                                options=dict(maxiter=10000))

        assert_coordinates_close(result[self.im.pos_columns].values,
                                 self.im.coords, 0.1)
        assert (result['signal'].values[1:] == result['signal'].values[:-1]).all()
        assert_allclose(result['signal'].values, 200, atol=5)
Exemple #9
0
    def test_var_global(self):
        self.im.clear()
        self.im.draw_features(100, 15, self.diameter)

        f0 = self.im.f(noise=self.pos_err)
        f0['signal'] = 180

        result = refine_leastsq(f0, self.im(), self.diameter, self.separation,
                                param_mode=dict(signal='global'),
                                options=dict(maxiter=10000))

        assert_coordinates_close(result[self.im.pos_columns].values,
                                 self.im.coords, 0.1)
        assert (result['signal'].values[1:] == result['signal'].values[:-1]).all()
        assert_allclose(result['signal'].values, 200, atol=5)
Exemple #10
0
    def test_constraint_global_dimer(self):
        hard_radius = 1.
        constraints = dimer_global(1, self.im.ndim)
        self.im.clear()
        self.im.draw_clusters(10, 2, hard_radius, 2*self.separation,
                              2*self.diameter)

        f0 = self.im.f(noise=self.pos_err)
        result = refine_leastsq(f0, self.im(), self.diameter,
                                self.separation, constraints=constraints,
                                options=dict(maxiter=1000))

        dists = []
        for _, f_cl in result.groupby('cluster'):
            pos = result[['y', 'x']].values
            dists.append(np.sqrt(np.sum(((pos[0] - pos[1])/np.array(self.im.size))**2)))

        assert_allclose(dists, 2*hard_radius, atol=0.01)

        assert_coordinates_close(result[self.im.pos_columns].values,
                                 self.im.coords, 0.1)