Ejemplo n.º 1
0
    def run(self, workspace):
        image = workspace.image_set.get_image(self.image_name.value,
                                              must_be_grayscale=True)
        orig_pixels = image.pixel_data
        if image.has_mask:
            mask = image.mask
        else:
            mask = np.ones(orig_pixels.shape, bool)
        if self.method == M_SOBEL:
            if self.direction == E_ALL:
                output_pixels = sobel(orig_pixels, mask)
            elif self.direction == E_HORIZONTAL:
                output_pixels = hsobel(orig_pixels, mask)
            elif self.direction == E_VERTICAL:
                output_pixels = vsobel(orig_pixels, mask)
            else:
                raise NotImplementedError("Unimplemented direction for Sobel: %s", self.direction.value)
        elif self.method == M_LOG:
            sigma = self.get_sigma()
            size = int(sigma * 4) + 1
            output_pixels = laplacian_of_gaussian(orig_pixels, mask, size, sigma)
        elif self.method == M_PREWITT:
            if self.direction == E_ALL:
                output_pixels = prewitt(orig_pixels)
            elif self.direction == E_HORIZONTAL:
                output_pixels = hprewitt(orig_pixels, mask)
            elif self.direction == E_VERTICAL:
                output_pixels = vprewitt(orig_pixels, mask)
            else:
                raise NotImplementedError("Unimplemented direction for Prewitt: %s", self.direction.value)
        elif self.method == M_CANNY:
            high_threshold = self.manual_threshold.value
            low_threshold = self.low_threshold.value
            if (self.wants_automatic_low_threshold.value or
                    self.wants_automatic_threshold.value):
                sobel_image = sobel(orig_pixels, mask)
                low, high = otsu3(sobel_image[mask])
                if self.wants_automatic_low_threshold.value:
                    low_threshold = low * self.threshold_adjustment_factor.value
                if self.wants_automatic_threshold.value:
                    high_threshold = high * self.threshold_adjustment_factor.value
            output_pixels = canny(orig_pixels, mask, self.get_sigma(),
                                  low_threshold,
                                  high_threshold)
        elif self.method == M_ROBERTS:
            output_pixels = roberts(orig_pixels, mask)
        elif self.method == M_KIRSCH:
            output_pixels = kirsch(orig_pixels)
        else:
            raise NotImplementedError("Unimplemented edge detection method: %s" %
                                      self.method.value)

        output_image = cpi.Image(output_pixels, parent_image=image)
        workspace.image_set.add(self.output_image_name.value, output_image)

        if self.show_window:
            workspace.display_data.orig_pixels = orig_pixels
            workspace.display_data.output_pixels = output_pixels
Ejemplo n.º 2
0
 def test_07_01_kirsch(self):
     r = np.random.RandomState([ord(_) for _ in "test_07_01_kirsch"])
     i, j = np.mgrid[-20:20, -20:20]
     image = (np.sqrt(i * i + j * j) <= 10).astype(float) * .5
     image = image + r.uniform(size=image.shape) * .1
     workspace, module = self.make_workspace(image)
     module.method.value = F.M_KIRSCH
     module.run(workspace)
     output = workspace.image_set.get_image(OUTPUT_IMAGE_NAME)
     result = kirsch(image)
     np.testing.assert_almost_equal(output.pixel_data, result, decimal=4)
 def test_07_01_kirsch(self):
     r = np.random.RandomState([ord(_) for _ in "test_07_01_kirsch"])
     i, j = np.mgrid[-20:20, -20:20]
     image = (np.sqrt(i * i + j * j) <= 10).astype(float) * .5
     image = image + r.uniform(size=image.shape) * .1
     workspace, module = self.make_workspace(image)
     module.method.value = F.M_KIRSCH
     module.run(workspace)
     output = workspace.image_set.get_image(OUTPUT_IMAGE_NAME)
     result = kirsch(image)
     np.testing.assert_almost_equal(output.pixel_data, result, decimal=4)