Example #1
0
def test_icm_square():

    com = ConstantObservationModel()
    icm = IteratedConditionalModes()

    initial_segmentation = square.copy()

    mu, sigma = com.seg_stats(square_1, initial_segmentation,
                              nclasses)
    sigmasq = sigma ** 2
    npt.assert_(mu[0] >= 0.0)
    npt.assert_(mu[1] >= 0.0)
    npt.assert_(mu[2] >= 0.0)
    npt.assert_(mu[3] >= 0.0)
    npt.assert_(sigmasq[0] >= 0.0)
    npt.assert_(sigmasq[1] >= 0.0)
    npt.assert_(sigmasq[2] >= 0.0)
    npt.assert_(sigmasq[3] >= 0.0)

    negll = com.negloglikelihood(square_1, mu, sigmasq, nclasses)

    final_segmentation_1 = np.empty_like(square_1)
    final_segmentation_2 = np.empty_like(square_1)

    beta = 0.0

    for i in range(max_iter):

        print('\n')
        print('>> Iteration: ' + str(i))
        print('\n')

        final_segmentation_1, energy_1 = icm.icm_ising(negll, beta,
                                                       initial_segmentation)
        initial_segmentation = final_segmentation_1.copy()

    beta = 2
    initial_segmentation = square.copy()

    for j in range(max_iter):

        print('\n')
        print('>> Iteration: ' + str(j))
        print('\n')

        final_segmentation_2, energy_2 = icm.icm_ising(negll, beta,
                                                       initial_segmentation)
        initial_segmentation = final_segmentation_2.copy()

    difference_map = np.abs(final_segmentation_1 - final_segmentation_2)
    npt.assert_(np.abs(np.sum(difference_map)) != 0)
Example #2
0
def test_greyscale_iter():

    max_iter = 15
    beta = np.float64(0.1)

    com = ConstantObservationModel()
    icm = IteratedConditionalModes()

    mu, sigma = com.initialize_param_uniform(image, nclasses)
    sigmasq = sigma ** 2
    neglogl = com.negloglikelihood(image, mu, sigmasq, nclasses)
    initial_segmentation = icm.initialize_maximum_likelihood(neglogl)
    npt.assert_(initial_segmentation.max() == nclasses - 1)
    npt.assert_(initial_segmentation.min() == 0)

    mu, sigma = com.seg_stats(image, initial_segmentation, nclasses)
    sigmasq = sigma ** 2
    npt.assert_(mu[0] >= 0.0)
    npt.assert_(mu[1] >= 0.0)
    npt.assert_(mu[2] >= 0.0)
    npt.assert_(mu[3] >= 0.0)
    npt.assert_(sigmasq[0] >= 0.0)
    npt.assert_(sigmasq[1] >= 0.0)
    npt.assert_(sigmasq[2] >= 0.0)
    npt.assert_(sigmasq[3] >= 0.0)

    if background_noise:
        zero = np.zeros_like(image) + 0.001
        zero_noise = add_noise(zero, 10000, 1, noise_type='gaussian')
        image_gauss = np.where(image == 0, zero_noise, image)
    else:
        image_gauss = image

    final_segmentation = np.empty_like(image)
    seg_init = initial_segmentation.copy()
    energies = []

    for i in range(max_iter):

        PLN = icm.prob_neighborhood(initial_segmentation, beta,
                                    nclasses)
        npt.assert_(np.all((PLN >= 0) & (PLN <= 1.0)))

        if beta == 0.0:

            npt.assert_almost_equal(PLN[50, 50, 1, 0], 0.25, True)
            npt.assert_almost_equal(PLN[50, 50, 1, 1], 0.25, True)
            npt.assert_almost_equal(PLN[50, 50, 1, 2], 0.25, True)
            npt.assert_almost_equal(PLN[50, 50, 1, 3], 0.25, True)
            npt.assert_almost_equal(PLN[147, 129, 1, 0], 0.25, True)
            npt.assert_almost_equal(PLN[147, 129, 1, 1], 0.25, True)
            npt.assert_almost_equal(PLN[147, 129, 1, 2], 0.25, True)
            npt.assert_almost_equal(PLN[147, 129, 1, 3], 0.25, True)
            npt.assert_almost_equal(PLN[61, 152, 1, 0], 0.25, True)
            npt.assert_almost_equal(PLN[61, 152, 1, 1], 0.25, True)
            npt.assert_almost_equal(PLN[61, 152, 1, 2], 0.25, True)
            npt.assert_almost_equal(PLN[61, 152, 1, 3], 0.25, True)
            npt.assert_almost_equal(PLN[100, 100, 1, 0], 0.25, True)
            npt.assert_almost_equal(PLN[100, 100, 1, 1], 0.25, True)
            npt.assert_almost_equal(PLN[100, 100, 1, 2], 0.25, True)
            npt.assert_almost_equal(PLN[100, 100, 1, 3], 0.25, True)

        PLY = com.prob_image(image_gauss, nclasses, mu, sigmasq, PLN)
        npt.assert_(np.all((PLY >= 0) & (PLY <= 1.0)))
        npt.assert_(PLY[50, 50, 1, 0] > PLY[50, 50, 1, 1])
        npt.assert_(PLY[50, 50, 1, 0] > PLY[50, 50, 1, 2])
        npt.assert_(PLY[50, 50, 1, 0] > PLY[50, 50, 1, 3])
        npt.assert_(PLY[100, 100, 1, 3] > PLY[100, 100, 1, 0])
        npt.assert_(PLY[100, 100, 1, 3] > PLY[100, 100, 1, 1])
        npt.assert_(PLY[100, 100, 1, 3] > PLY[100, 100, 1, 2])

        mu_upd, sigmasq_upd = com.update_param(image_gauss, PLY, mu, nclasses)        
        npt.assert_(mu_upd[0] >= 0.0)
        npt.assert_(mu_upd[1] >= 0.0)
        npt.assert_(mu_upd[2] >= 0.0)
        npt.assert_(mu_upd[3] >= 0.0)    
        npt.assert_(sigmasq_upd[0] >= 0.0)
        npt.assert_(sigmasq_upd[1] >= 0.0)
        npt.assert_(sigmasq_upd[2] >= 0.0)
        npt.assert_(sigmasq_upd[3] >= 0.0)

        negll = com.negloglikelihood(image_gauss,
                                     mu_upd, sigmasq_upd, nclasses)
        npt.assert_(negll[50, 50, 1, 0] < negll[50, 50, 1, 1])
        npt.assert_(negll[50, 50, 1, 0] < negll[50, 50, 1, 2])
        npt.assert_(negll[50, 50, 1, 0] < negll[50, 50, 1, 3])
        npt.assert_(negll[100, 100, 1, 3] < negll[100, 100, 1, 0])
        npt.assert_(negll[100, 100, 1, 3] < negll[100, 100, 1, 1])
        npt.assert_(negll[100, 100, 1, 3] < negll[100, 100, 1, 2])

        final_segmentation, energy = icm.icm_ising(negll, beta,
                                                   initial_segmentation)
        print(energy[energy > -np.inf].sum())
        energies.append(energy[energy > -np.inf].sum())

        initial_segmentation = final_segmentation.copy()
        mu = mu_upd.copy()
        sigmasq = sigmasq_upd.copy()

    npt.assert_(energies[-1] < energies[0])

    difference_map = np.abs(seg_init - final_segmentation)
    npt.assert_(np.abs(np.sum(difference_map)) != 0)
Example #3
0
def test_square_iter():

    com = ConstantObservationModel()
    icm = IteratedConditionalModes()

    initial_segmentation = square

    mu, sigma = com.seg_stats(square_gauss, initial_segmentation,
                              nclasses)
    sigmasq = sigma ** 2
    npt.assert_(mu[0] >= 0.0)
    npt.assert_(mu[1] >= 0.0)
    npt.assert_(mu[2] >= 0.0)
    npt.assert_(mu[3] >= 0.0)
    npt.assert_(sigmasq[0] >= 0.0)
    npt.assert_(sigmasq[1] >= 0.0)
    npt.assert_(sigmasq[2] >= 0.0)
    npt.assert_(sigmasq[3] >= 0.0)

    final_segmentation = np.empty_like(square_gauss)
    seg_init = initial_segmentation.copy()
    energies = []

    for i in range(max_iter):

        print('\n')
        print('>> Iteration: ' + str(i))
        print('\n')

        PLN = icm.prob_neighborhood(initial_segmentation, beta,
                                    nclasses)
        npt.assert_(np.all((PLN >= 0) & (PLN <= 1.0)))

        if beta == 0.0:

            npt.assert_(PLN[25, 25, 1, 0] == 0.25)
            npt.assert_(PLN[25, 25, 1, 1] == 0.25)
            npt.assert_(PLN[25, 25, 1, 2] == 0.25)
            npt.assert_(PLN[25, 25, 1, 3] == 0.25)
            npt.assert_(PLN[50, 50, 1, 0] == 0.25)
            npt.assert_(PLN[50, 50, 1, 1] == 0.25)
            npt.assert_(PLN[50, 50, 1, 2] == 0.25)
            npt.assert_(PLN[50, 50, 1, 3] == 0.25)
            npt.assert_(PLN[90, 90, 1, 0] == 0.25)
            npt.assert_(PLN[90, 90, 1, 1] == 0.25)
            npt.assert_(PLN[90, 90, 1, 2] == 0.25)
            npt.assert_(PLN[90, 90, 1, 3] == 0.25)
            npt.assert_(PLN[125, 125, 1, 0] == 0.25)
            npt.assert_(PLN[125, 125, 1, 1] == 0.25)
            npt.assert_(PLN[125, 125, 1, 2] == 0.25)
            npt.assert_(PLN[125, 125, 1, 3] == 0.25)

        PLY = com.prob_image(square_gauss, nclasses, mu, sigmasq, PLN)
        npt.assert_(np.all((PLY >= 0) & (PLY <= 1.0)))
        npt.assert_(PLY[25, 25, 1, 0] > PLY[25, 25, 1, 1])
        npt.assert_(PLY[25, 25, 1, 0] > PLY[25, 25, 1, 2])
        npt.assert_(PLY[25, 25, 1, 0] > PLY[25, 25, 1, 3])
        npt.assert_(PLY[125, 125, 1, 3] > PLY[125, 125, 1, 0])
        npt.assert_(PLY[125, 125, 1, 3] > PLY[125, 125, 1, 1])
        npt.assert_(PLY[125, 125, 1, 3] > PLY[125, 125, 1, 2])

        mu_upd, sigmasq_upd = com.update_param(square_gauss, PLY, mu, nclasses)
        npt.assert_(mu_upd[0] >= 0.0)
        npt.assert_(mu_upd[1] >= 0.0)
        npt.assert_(mu_upd[2] >= 0.0)
        npt.assert_(mu_upd[3] >= 0.0)    
        npt.assert_(sigmasq_upd[0] >= 0.0)
        npt.assert_(sigmasq_upd[1] >= 0.0)
        npt.assert_(sigmasq_upd[2] >= 0.0)
        npt.assert_(sigmasq_upd[3] >= 0.0)

        negll = com.negloglikelihood(square_gauss,
                                     mu_upd, sigmasq_upd, nclasses)
        npt.assert_(negll[25, 25, 1, 0] < negll[25, 25, 1, 1])
        npt.assert_(negll[25, 25, 1, 0] < negll[25, 25, 1, 2])
        npt.assert_(negll[25, 25, 1, 0] < negll[25, 25, 1, 3])
        npt.assert_(negll[100, 100, 1, 3] < negll[125, 125, 1, 0])
        npt.assert_(negll[100, 100, 1, 3] < negll[125, 125, 1, 1])
        npt.assert_(negll[100, 100, 1, 3] < negll[125, 125, 1, 2])

        final_segmentation, energy = icm.icm_ising(negll, beta,
                                                   initial_segmentation)

        energies.append(energy[energy > -np.inf].sum())

        initial_segmentation = final_segmentation.copy()
        mu = mu_upd.copy()
        sigmasq = sigmasq_upd.copy()

    difference_map = np.abs(seg_init - final_segmentation)
    npt.assert_(np.abs(np.sum(difference_map)) == 0.0)
Example #4
0
    def classify(self, image, nclasses, beta, tolerance=None, max_iter=None):
        r"""
        This method uses the Maximum a posteriori - Markov Random Field
        approach for segmentation by using the Iterative Conditional Modes and
        Expectation Maximization to estimate the parameters.

        Parameters
        ----------
        image : ndarray,
                3D structural image.
        nclasses : int,
                number of desired classes.
        beta : float,
                smoothing parameter, the higher this number the smoother the
                output will be.
        tolerance: float,
                value that defines the percentage of change tolerated to
                prevent the ICM loop to stop. Default is 1e-05.
        max_iter : float,
                fixed number of desired iterations. Default is 100.
                If the user only specifies this parameter, the tolerance
                value will not be considered. If none of these two
                parameters

        Returns
        -------
        initial_segmentation : ndarray,
                3D segmented image with all tissue types
                specified in nclasses.
        final_segmentation : ndarray,
                3D final refined segmentation containing all
                tissue types.
        PVE : ndarray,
                3D probability map of each tissue type.
        """

        nclasses = nclasses + 1  # One extra class for the background
        energy_sum = [1e-05]

        com = ConstantObservationModel()
        icm = IteratedConditionalModes()

        if image.max() > 1:
            image = np.interp(image, [0, image.max()], [0.0, 1.0])

        mu, sigma = com.initialize_param_uniform(image, nclasses)
        p = np.argsort(mu)
        mu = mu[p]
        sigma = sigma[p]
        sigmasq = sigma**2

        neglogl = com.negloglikelihood(image, mu, sigmasq, nclasses)
        seg_init = icm.initialize_maximum_likelihood(neglogl)

        mu, sigma = com.seg_stats(image, seg_init, nclasses)
        sigmasq = sigma**2

        zero = np.zeros_like(image) + 0.001
        zero_noise = add_noise(zero, 10000, 1, noise_type='gaussian')
        image_gauss = np.where(image == 0, zero_noise, image)

        final_segmentation = np.empty_like(image)
        initial_segmentation = seg_init.copy()

        if max_iter is not None and tolerance is None:

            for i in range(max_iter):

                if self.verbose:
                    print('>> Iteration: ' + str(i))

                PLN = icm.prob_neighborhood(seg_init, beta, nclasses)
                PVE = com.prob_image(image_gauss, nclasses, mu, sigmasq, PLN)

                mu_upd, sigmasq_upd = com.update_param(image_gauss, PVE, mu,
                                                       nclasses)
                ind = np.argsort(mu_upd)
                mu_upd = mu_upd[ind]
                sigmasq_upd = sigmasq_upd[ind]

                negll = com.negloglikelihood(image_gauss, mu_upd, sigmasq_upd,
                                             nclasses)
                final_segmentation, energy = icm.icm_ising(
                    negll, beta, seg_init)

                if self.save_history:
                    self.segmentations.append(final_segmentation)
                    self.pves.append(PVE)
                    self.energies.append(energy)
                    self.energies_sum.append(energy[energy > -np.inf].sum())

                seg_init = final_segmentation.copy()
                mu = mu_upd.copy()
                sigmasq = sigmasq_upd.copy()

        else:
            max_iter = 100

            if tolerance is None:
                tolerance = 1e-05
            for i in range(max_iter):

                if self.verbose:
                    print('>> Iteration: ' + str(i))

                PLN = icm.prob_neighborhood(seg_init, beta, nclasses)
                PVE = com.prob_image(image_gauss, nclasses, mu, sigmasq, PLN)

                mu_upd, sigmasq_upd = com.update_param(image_gauss, PVE, mu,
                                                       nclasses)
                ind = np.argsort(mu_upd)
                mu_upd = mu_upd[ind]
                sigmasq_upd = sigmasq_upd[ind]

                negll = com.negloglikelihood(image_gauss, mu_upd, sigmasq_upd,
                                             nclasses)
                final_segmentation, energy = icm.icm_ising(
                    negll, beta, seg_init)
                energy_sum.append(energy[energy > -np.inf].sum())

                if self.save_history:
                    self.segmentations.append(final_segmentation)
                    self.pves.append(PVE)
                    self.energies.append(energy)
                    self.energies_sum.append(energy[energy > -np.inf].sum())

                if i % 10 == 0 and i != 0:

                    tol = tolerance * (np.amax(energy_sum) -
                                       np.amin(energy_sum))

                    test_dist = np.absolute(
                        np.amax(energy_sum[np.size(energy_sum) - 5:i]) -
                        np.amin(energy_sum[np.size(energy_sum) - 5:i]))

                    if test_dist < tol:

                        break

                seg_init = final_segmentation.copy()
                mu = mu_upd.copy()
                sigmasq = sigmasq_upd.copy()

        PVE = PVE[..., 1:]

        return initial_segmentation, final_segmentation, PVE