def run(self, workspace): '''Run the imageJ command''' image_set = workspace.image_set d = self.get_dictionary(workspace.image_set_list) if self.wants_to_set_current_image: input_image_name = self.current_input_image_name.value img = image_set.get_image(input_image_name, must_be_grayscale=True) else: img = None display_service = ij2.get_display_service(get_context()) # # Run a command or macro on the first image of the set # if d.get(D_FIRST_IMAGE_SET) == image_set.image_number: self.do_imagej(workspace, D_FIRST_IMAGE_SET) # # Install the input image as the current image # if img is not None: dataset = ij2.create_dataset(get_context(), img.pixel_data * IMAGEJ_SCALE, input_image_name) display = display_service.createDisplay(input_image_name, dataset) display_service.setActiveDisplay(display) self.do_imagej(workspace) # # Get the output image # if self.wants_to_get_current_image: output_image_name = self.current_output_image_name.value for attempt in range(4): display = display_service.getActiveImageDisplay() if display.o is not None: break # # Possible synchronization problem with ImageJ 1.0 # Possible error involving user changing window focus # import time time.sleep(.25) else: raise ValueError("Failed to retrieve active display") self.save_display_as_image(workspace, display, output_image_name) # # Execute the post-group macro or command # if d.get(D_LAST_IMAGE_SET) == image_set.image_number: self.do_imagej(workspace, D_LAST_IMAGE_SET) # # Save the current ImageJ image after executing the post-group # command or macro # if (self.post_group_choice != CM_NOTHING and self.wants_post_group_image): output_image_name = self.post_group_output_image.value output_image_name = self.current_output_image_name.value display = display_service.getActiveImageDisplay() self.save_display_as_image(workspace, display, output_image_name)
def test_09_03_set_active_display(self): svc = ij2.get_display_service(self.context) r = np.random.RandomState() r.seed(92) image = r.randint(0, 256, (11,13)) ds = ij2.create_dataset(self.context, image, "Foo") display = svc.createDisplay("Foo", ds) svc.setActiveDisplay(display)
def test_11_03_get_no_display_overlays(self): display_svc = ij2.get_display_service(self.context) overlay_svc = ij2.get_overlay_service(self.context) i, j = np.mgrid[0:15, 0:1900:100] image = i+j ds = ij2.create_dataset(self.context, image, "Foo") display = display_svc.createDisplay("Foo", ds) self.assertEqual(len(overlay_svc.getDisplayOverlays(display.o)), 0)
def test_09_07_is_unique_name(self): svc = ij2.get_display_service(self.context) r = np.random.RandomState() r.seed(92) image = r.randint(0, 256, (11,13)) ds = ij2.create_dataset(self.context, image, "Foo") svc.createDisplay("Foo", ds) self.assertTrue(svc.isUniqueName("Bar")) self.assertFalse(svc.isUniqueName("Foo"))
def test_09_05_get_active_image_display(self): svc = ij2.get_display_service(self.context) r = np.random.RandomState() r.seed(92) image = r.randint(0, 256, (11,13)) ds = ij2.create_dataset(self.context, image, "Foo") svc.createDisplay("Foo", ds) ds = ij2.create_dataset(self.context, image, "Bar") display = svc.createDisplay("Bar", ds) svc.setActiveDisplay(display) self.assertEqual(svc.getActiveImageDisplay().getName(), "Bar")
def run(self, workspace): '''Run the imageJ command''' image_set = workspace.image_set d = self.get_dictionary(workspace.image_set_list) if self.wants_to_set_current_image: input_image_name = self.current_input_image_name.value img = image_set.get_image(input_image_name, must_be_grayscale = True) else: img = None display_service = ij2.get_display_service(get_context()) # # Run a command or macro on the first image of the set # if d.get(D_FIRST_IMAGE_SET) == image_set.image_number: self.do_imagej(workspace, D_FIRST_IMAGE_SET) # # Install the input image as the current image # if img is not None: dataset = ij2.create_dataset(get_context(), img.pixel_data * IMAGEJ_SCALE, input_image_name) display = display_service.createDisplay( input_image_name, dataset) display_service.setActiveDisplay(display) self.do_imagej(workspace) # # Get the output image # if self.wants_to_get_current_image: output_image_name = self.current_output_image_name.value display = display_service.getActiveImageDisplay() self.save_display_as_image(workspace, display, output_image_name) # # Execute the post-group macro or command # if d.get(D_LAST_IMAGE_SET) == image_set.image_number: self.do_imagej(workspace, D_LAST_IMAGE_SET) # # Save the current ImageJ image after executing the post-group # command or macro # if (self.post_group_choice != CM_NOTHING and self.wants_post_group_image): output_image_name = self.post_group_output_image.value output_image_name = self.current_output_image_name.value display = display_service.getActiveImageDisplay() self.save_display_as_image(workspace, display, output_image_name)
def test_09_06_get_display_by_name(self): svc = ij2.get_display_service(self.context) r = np.random.RandomState() r.seed(92) image = r.randint(0, 256, (11,13)) ds = ij2.create_dataset(self.context, image, "Foo") svc.createDisplay("Foo", ds) image = r.randint(0, 256, (14,12)) ds2 = ij2.create_dataset(self.context, image, "Bar") display = svc.createDisplay("Bar", ds) svc.setActiveDisplay(display) display = svc.getDisplay("Foo") view = display.getActiveView() ds3 = ij2.wrap_interval(view.getData()) self.assertSequenceEqual(ds3.dimensions(), [13, 11])
def test_11_06_select_overlay(self): display_svc = ij2.get_display_service(self.context) overlay_svc = ij2.get_overlay_service(self.context) i, j = np.mgrid[0:15, 0:1900:100] image = i+j ds = ij2.create_dataset(self.context, image, "Foo") display = display_svc.createDisplay("Foo", ds) d2 = display_svc.createDisplay("Bar", ij2.create_dataset(self.context, image, "Bar")) mask = np.zeros(i.shape, bool) islice = slice(2,-3) jslice = slice(3,-4) mask[islice, jslice] = True overlay = ij2.create_overlay(self.context, mask) overlay_svc.addOverlays(display, J.make_list([overlay])) ij2.select_overlay(display.o, overlay)
def test_09_08_check_stride(self): # Rotate the image by 90 degrees to make sure the pixel copy # was properly strided # svc = ij2.get_display_service(self.context) i, j = np.mgrid[0:5, 0:70:10] image = i + j ds = ij2.create_dataset(self.context, image, "Foo") display = svc.createDisplay("Foo", ds) outputs = dict(display=None) self.run_command("imagej.core.commands.rotate.Rotate90DegreesLeft", dict(display=display), outputs) display_out = ij2.wrap_display(outputs["display"]) dataset = ij2.wrap_dataset(display_out.getActiveView().getData()) image_out = dataset.get_pixel_data() self.assertSequenceEqual(image_out.shape, list(reversed(image.shape))) np.testing.assert_array_equal(np.rot90(image), image_out)
def test_09_08_check_stride(self): # Rotate the image by 90 degrees to make sure the pixel copy # was properly strided # svc = ij2.get_display_service(self.context) i, j = np.mgrid[0:5, 0:70:10] image = i+j ds = ij2.create_dataset(self.context, image, "Foo") display = svc.createDisplay("Foo", ds) outputs = dict(display=None) self.run_command("imagej.core.commands.rotate.Rotate90DegreesLeft", dict(display=display), outputs) display_out = ij2.wrap_display(outputs["display"]) dataset = ij2.wrap_dataset(display_out.getActiveView().getData()) image_out = dataset.get_pixel_data() self.assertSequenceEqual(image_out.shape, list(reversed(image.shape))) np.testing.assert_array_equal(np.rot90(image), image_out)
def test_09_09_check_overlay(self): svc = ij2.get_display_service(self.context) r = np.random.RandomState() i, j = np.mgrid[0:11, 0:1300:100] image = i+j ds = ij2.create_dataset(self.context, image, "Foo") display = svc.createDisplay("Foo", ds) mask = np.zeros(image.shape, bool) mask[2:-1, 3:-4] = 1 overlay = ij2.create_overlay(self.context, mask) ij2.get_overlay_service(self.context).addOverlays( display.o, J.make_list([overlay])) ij2.select_overlay(display.o, overlay) self.run_command("imagej.core.commands.imglib.CropImage", dict(display=display), {}) dataset = ij2.wrap_dataset(display.getActiveView().getData()) image_out = dataset.get_pixel_data() self.assertSequenceEqual(image_out.shape, [7, 5]) np.testing.assert_array_equal(image[2:-2, 3:-5], image_out)
def test_11_07_get_selection_bounds(self): display_svc = ij2.get_display_service(self.context) overlay_svc = ij2.get_overlay_service(self.context) i, j = np.mgrid[0:15, 0:1900:100] image = i+j ds = ij2.create_dataset(self.context, image, "Foo") display = display_svc.createDisplay("Foo", ds) mask = np.zeros(i.shape, bool) islice = slice(2,-3) jslice = slice(3,-4) mask[islice, jslice] = True overlay = ij2.create_overlay(self.context, mask) overlay_svc.addOverlays(display, J.make_list([overlay])) ij2.select_overlay(display.o, overlay) rect = overlay_svc.getSelectionBounds(display) self.assertEqual(J.get_field(rect, "x", "D"), 3) self.assertEqual(J.get_field(rect, "y", "D"), 2) self.assertEqual(J.get_field(rect, "width", "D"), 11) self.assertEqual(J.get_field(rect, "height", "D"), 9)
def test_06_01_get_mask_data(self): # Get the overlay data from a display # display_svc = ij2.get_display_service(self.context) overlay_svc = ij2.get_overlay_service(self.context) image = np.zeros((30, 30)) ds = ij2.create_dataset(self.context, image, "Foo") display = display_svc.createDisplay("Foo", ds) d2 = display_svc.createDisplay("Bar", ij2.create_dataset(self.context, image, "Bar")) overlay = J.run_script( """var o = new Packages.imagej.data.overlay.RectangleOverlay(context.getContext()); o.setOrigin(5, 0); o.setOrigin(3, 1); o.setExtent(6, 0); o.setExtent(7, 1); o;""", dict(context=self.context)) overlay_svc.addOverlays(display, J.make_list([overlay])) ij2.select_overlay(display.o, overlay) mask = ij2.create_mask(display) i, j = np.mgrid[0:mask.shape[0], 0:mask.shape[1]] np.testing.assert_equal(mask, (j >= 5) & (j < 11) & (i >= 3) & (i < 10))
def test_09_02_create_display(self): svc = ij2.get_display_service(self.context) r = np.random.RandomState() r.seed(92) image = r.randint(0, 256, (11,13)) ds = ij2.create_dataset(self.context, image, "Foo") display = svc.createDisplay("Foo", ds) self.assertEqual(display.size(), 1) self.assertFalse(display.isEmpty()) self.assertFalse(display.contains(None)) views = display.toArray() self.assertEqual(len(views), 1) self.assertTrue(display.canDisplay(ds.o)) display.update() self.assertEqual(display.getName(), "Foo") display.setName("Bar") self.assertEqual(display.getName(), "Bar") display.getActiveView() display.getActiveAxis() display.getCanvas() display.setActiveAxis(ij2.Axes().X)
def inject_image(self, pixels, name=None): '''inject an image into ImageJ for processing''' dataset = IJ2.create_dataset(pixels, name) display_service = IJ2.get_display_service(self.context) display = display_service.createDisplay(dataset) display_service.setActiveDisplay(display.o)
def tearDown(self): # Close all displays after each test svc = ij2.get_display_service(self.context) for display in svc.getDisplays(): display.close()
def run(self, workspace): '''Run the imageJ command''' image_set = workspace.image_set d = self.get_dictionary(workspace.image_set_list) if self.wants_to_set_current_image: input_image_name = self.current_input_image_name.value img = image_set.get_image(input_image_name, must_be_grayscale=True) if self.show_window: workspace.display_data.image_sent_to_ij = img.pixel_data else: img = None display_service = ij2.get_display_service(get_context()) # # Run a command or macro on the first image of the set # if d.get(D_FIRST_IMAGE_SET) == image_set.image_number: self.do_imagej(workspace, D_FIRST_IMAGE_SET) ij1_mode = self.command_or_macro == CM_MACRO # # Install the input image as the current image # if img is not None: ijpixels = img.pixel_data * IMAGEJ_SCALE if ij1_mode: ij_processor = ijiproc.make_image_processor( ijpixels.astype('float32')) image_plus = ijip.make_imageplus_from_processor( input_image_name, ij_processor) ijwm.set_current_image(image_plus) else: dataset = ij2.create_dataset(get_context(), ijpixels, input_image_name) display = display_service.createDisplay( input_image_name, dataset) display_service.setActiveDisplay(display) self.do_imagej(workspace) # # Get the output image # if self.wants_to_get_current_image: output_image_name = self.current_output_image_name.value if ij1_mode: image_plus = ijwm.get_current_image() ij_processor = image_plus.getProcessor() pixels = ijiproc.get_image(ij_processor).\ astype('float32') / IMAGEJ_SCALE image = cpi.Image(pixels) workspace.image_set.add(output_image_name, image) else: for attempt in range(4): display = display_service.getActiveImageDisplay() if display.o is not None: break # # Possible synchronization problem with ImageJ 1.0 # Possible error involving user changing window focus # import time time.sleep(.25) else: raise ValueError("Failed to retrieve active display") pixels = self.save_display_as_image(workspace, display, output_image_name) if self.show_window: workspace.display_data.image_acquired_from_ij = pixels # # Execute the post-group macro or command # if d.get(D_LAST_IMAGE_SET) == image_set.image_number: self.do_imagej(workspace, D_LAST_IMAGE_SET) # # Save the current ImageJ image after executing the post-group # command or macro # if (self.post_group_choice != CM_NOTHING and self.wants_post_group_image): output_image_name = self.post_group_output_image.value if ij1_mode: image_plus = ijwm.get_current_image() ij_processor = image_plus.getProcessor() pixels = ijiproc.get_image(ij_processor).\ astype('float32') / IMAGEJ_SCALE image = cpi.Image(pixels, mask=mask) workspace.image_set.add(output_image_name, image) else: display = display_service.getActiveImageDisplay() self.save_display_as_image(workspace, display, output_image_name)
def get_current_image(self): '''returns the WindowManager's current image as a numpy float array''' display_service = IJ2.get_display_service(self.context) current_display = display_service.getActiveImageDisplay() dataset = display_service.getActiveDataset(current_display) return dataset.get_pixel_data()
def execute_advanced_command(self, workspace, command, d): '''Execute an advanced command command - name of the command d - dictionary to be used to find settings ''' context = get_context() self.get_command_settings(command, d) wants_display = self.show_window if wants_display: workspace.display_data.input_images = input_images = [] workspace.display_data.output_images = output_images = [] key = command.get_unicode_value() node = command.get_selected_leaf() module_info = node[2] input_dictionary = J.get_map_wrapper( J.make_instance('java/util/HashMap', "()V")) display_dictionary = {} display_service = ij2.get_display_service(context) for setting, module_item in d[key]: if isinstance(setting, cps.ImageNameProvider): continue field_name = module_item.getName() field_type = module_item.getType() raw_type = J.call(module_item.o, "getType", "()Ljava/lang/Class;") if field_type in (ij2.FT_BOOL, ij2.FT_INTEGER, ij2.FT_FLOAT, ij2.FT_STRING): input_dictionary.put(field_name, J.box(setting.value, raw_type)) elif field_type == ij2.FT_COLOR: assert isinstance(setting, cps.Color) red, green, blue = setting.to_rgb() jobject = J.make_instance("imagej/util/ColorRGB", "(III)V", red, green, blue) input_dictionary.put(field_name, jobject) elif field_type == ij2.FT_IMAGE: image_name = setting.value image = workspace.image_set.get_image(image_name) pixel_data = image.pixel_data * IMAGEJ_SCALE dataset = ij2.create_dataset(context, pixel_data, image_name) display = display_service.createDisplay(image_name, dataset) display_dictionary[module_item.getName()] = display if image.has_mask: #overlay_name = "X" + uuid.uuid4().get_hex() #image_dictionary[overlay_name] = image.mask overlay = ij2.create_overlay(context, image.mask) overlay_service = ij2.get_overlay_service(context) overlay_service.addOverlays(display.o, J.make_list([overlay])) ij2.select_overlay(display.o, overlay) input_dictionary.put(field_name, display.o) if wants_display: input_images.append((image_name, image.pixel_data)) elif field_type == ij2.FT_TABLE: table_name = setting.value table = workspace.object_set.get_type_instance( IJ_TABLE_TYPE, table_name) input_dictionary.put(field_name, table) elif field_type == ij2.FT_FILE: jfile = J.make_instance("java/io/File", "(Ljava/lang/String;)V", setting.value) input_dictionary.put(field_name, jfile) command_service = ij2.get_command_service(get_context()) future = command_service.run(module_info.o, input_dictionary.o) module = future.get() for setting, module_item in d[key]: if isinstance(setting, cps.ImageNameProvider): name = module_item.getName() output_name = setting.value if display_dictionary.has_key(name): display = display_dictionary[name] else: display = IJ2.wrap_display(module.getOutput(name)) pixel_data = self.save_display_as_image( workspace, display, output_name) if wants_display: output_images.append((output_name, pixel_data)) # Close any displays that we created. for display in display_dictionary.values(): display.close()
def execute_advanced_command(self, workspace, command, d): '''Execute an advanced command command - name of the command d - dictionary to be used to find settings ''' wants_display = workspace.frame is not None if wants_display: workspace.display_data.input_images = input_images = [] workspace.display_data.output_images = output_images = [] key = command.get_unicode_value() if bioformats.USE_IJ2: node = command.get_selected_leaf() module_info = node[2] module = IJ2.wrap_module(module_info.createModule()) context = self.get_context() display_service = IJ2.get_display_service(context) display_dictionary = {} for setting, module_item in d[key]: field_type = module_item.getType() if isinstance(setting, cps.ImageNameProvider): continue if field_type == IJ2.FT_BOOL: value = J.make_instance("java/lang/Boolean", "(Z)V", setting.value) elif field_type == IJ2.FT_INTEGER: value = J.make_instance("java/lang/Integer", "(I)V", setting.value) elif field_type == IJ2.FT_FLOAT: value = J.make_instance("java/lang/Double", "(D)V", setting.value) elif field_type == IJ2.FT_STRING: value = setting.value elif field_type == IJ2.FT_COLOR: value = IJ2.make_color_rgb_from_html(setting.value) elif field_type == IJ2.FT_IMAGE: image_name = setting.value image = workspace.image_set.get_image(image_name) dataset = IJ2.create_dataset(image.pixel_data, setting.value) display = display_service.createDisplay(dataset) if image.has_mask: overlay = IJ2.create_overlay(image.mask) display.displayOverlay(overlay) value = display display_dictionary[module_item.getName()] = display if wants_display: input_images.append((image_name, image.pixel_data)) module.setInput(module_item.getName(), value) module_service = IJ2.get_module_service(context) module_service.run(module) for setting, module_item in d[key]: if isinstance(setting, cps.ImageNameProvider): name = module_item.getName() output_name = setting.value if display_dictionary.has_key(name): display = display_dictionary[name] else: display = IJ2.wrap_display(module.getOutput(name)) ds = display_service.getActiveDataset(display) pixel_data = ds.get_pixel_data() image = cpi.Image(pixel_data) workspace.image_set.add(output_name, image) if wants_display: output_images.append((output_name, pixel_data)) for display in display_dictionary.values(): panel = IJ2.wrap_display_panel(display.getDisplayPanel()) panel.close() else: from imagej.imageplus import make_imageplus_from_processor from imagej.imageplus import get_imageplus_wrapper from imagej.imageprocessor import make_image_processor from imagej.imageprocessor import get_image command = command.value settings = d[command] classname = self.get_cached_commands()[command] plugin = M.get_plugin(classname) fp_in = P.get_input_fields_and_parameters(plugin) result = [] image_set = workspace.image_set assert isinstance(image_set, cpi.ImageSet) for (field, parameter), setting in zip(fp_in, settings[:len(fp_in)]): field_type = P.get_field_type(field) label = parameter.label() or "" if field_type == P.FT_IMAGE: image_name = setting.value image = workspace.image_set.get_image(image_name, must_be_grayscale = True) pixel_data = (image.pixel_data * 255.0).astype(np.float32) if wants_display: input_images.append((image_name, pixel_data / 255.0)) processor = make_image_processor(pixel_data) image_plus = make_imageplus_from_processor(image_name, processor) field.set(plugin, image_plus) del image_plus del processor elif field_type == P.FT_INTEGER: field.setInt(plugin, setting.value) elif field_type == P.FT_FLOAT: field.setFloat(plugin, setting.value) elif field_type == P.FT_BOOL: field.setBoolean(plugin, setting.value) else: field.set(plugin, setting.value) # # There are two ways to run this: # * Batch - just call plugin.run() # * Interactive - use PlugInFunctions.runInteractively # if self.pause_before_proceeding: J.execute_runnable_in_main_thread(J.run_script( """new java.lang.Runnable() { run:function() { importClass(Packages.imagej.plugin.PlugInFunctions); PlugInFunctions.runInteractively(plugin); }};""", dict(plugin=plugin)), True) else: J.execute_runnable_in_main_thread(plugin, True) setting_idx = len(fp_in) fp_out = P.get_output_fields_and_parameters(plugin) for field, parameter in fp_out: field_type = P.get_field_type(field) if field_type == P.FT_IMAGE: image_name = settings[setting_idx].value setting_idx += 1 image_plus = get_imageplus_wrapper(field.get(plugin)) processor = image_plus.getProcessor() pixel_data = get_image(processor).astype(np.float32) / 255.0 if wants_display: output_images.append((image_name, pixel_data)) image = cpi.Image(pixel_data) image_set.add(image_name, image)
def run(self, workspace): '''Run the imageJ command''' image_set = workspace.image_set d = self.get_dictionary(workspace.image_set_list) if self.wants_to_set_current_image: input_image_name = self.current_input_image_name.value img = image_set.get_image(input_image_name, must_be_grayscale = True) else: img = None display_service = ij2.get_display_service(get_context()) # # Run a command or macro on the first image of the set # if d.get(D_FIRST_IMAGE_SET) == image_set.image_number: self.do_imagej(workspace, D_FIRST_IMAGE_SET) # # Install the input image as the current image # if img is not None: dataset = ij2.create_dataset(get_context(), img.pixel_data * IMAGEJ_SCALE, input_image_name) display = display_service.createDisplay( input_image_name, dataset) display_service.setActiveDisplay(display) self.do_imagej(workspace) # # Get the output image # if self.wants_to_get_current_image: output_image_name = self.current_output_image_name.value for attempt in range(4): display = display_service.getActiveImageDisplay() if display.o is not None: break # # Possible synchronization problem with ImageJ 1.0 # Possible error involving user changing window focus # import time time.sleep(.25) else: raise ValueError("Failed to retrieve active display") self.save_display_as_image(workspace, display, output_image_name) # # Execute the post-group macro or command # if d.get(D_LAST_IMAGE_SET) == image_set.image_number: self.do_imagej(workspace, D_LAST_IMAGE_SET) # # Save the current ImageJ image after executing the post-group # command or macro # if (self.post_group_choice != CM_NOTHING and self.wants_post_group_image): output_image_name = self.post_group_output_image.value output_image_name = self.current_output_image_name.value display = display_service.getActiveImageDisplay() self.save_display_as_image(workspace, display, output_image_name)
def run(self, workspace): """Run the imageJ command""" image_set = workspace.image_set d = self.get_dictionary(workspace.image_set_list) if self.wants_to_set_current_image: input_image_name = self.current_input_image_name.value img = image_set.get_image(input_image_name, must_be_grayscale=True) if self.show_window: workspace.display_data.image_sent_to_ij = img.pixel_data else: img = None display_service = ij2.get_display_service(get_context()) # # Run a command or macro on the first image of the set # if d.get(D_FIRST_IMAGE_SET) == image_set.image_number: self.do_imagej(workspace, D_FIRST_IMAGE_SET) ij1_mode = self.command_or_macro == CM_MACRO # # Install the input image as the current image # if img is not None: ijpixels = img.pixel_data * IMAGEJ_SCALE if ij1_mode: ij_processor = ijiproc.make_image_processor(ijpixels.astype("float32")) image_plus = ijip.make_imageplus_from_processor(input_image_name, ij_processor) ijwm.set_current_image(image_plus) else: dataset = ij2.create_dataset(get_context(), ijpixels, input_image_name) display = display_service.createDisplay(input_image_name, dataset) display_service.setActiveDisplay(display) self.do_imagej(workspace) # # Get the output image # if self.wants_to_get_current_image: output_image_name = self.current_output_image_name.value if ij1_mode: image_plus = ijwm.get_current_image() ij_processor = image_plus.getProcessor() pixels = ijiproc.get_image(ij_processor).astype("float32") / IMAGEJ_SCALE image = cpi.Image(pixels) workspace.image_set.add(output_image_name, image) else: for attempt in range(4): display = display_service.getActiveImageDisplay() if display.o is not None: break # # Possible synchronization problem with ImageJ 1.0 # Possible error involving user changing window focus # import time time.sleep(0.25) else: raise ValueError("Failed to retrieve active display") pixels = self.save_display_as_image(workspace, display, output_image_name) if self.show_window: workspace.display_data.image_acquired_from_ij = pixels # # Execute the post-group macro or command # if d.get(D_LAST_IMAGE_SET) == image_set.image_number: self.do_imagej(workspace, D_LAST_IMAGE_SET) # # Save the current ImageJ image after executing the post-group # command or macro # if self.post_group_choice != CM_NOTHING and self.wants_post_group_image: output_image_name = self.post_group_output_image.value if ij1_mode: image_plus = ijwm.get_current_image() ij_processor = image_plus.getProcessor() pixels = ijiproc.get_image(ij_processor).astype("float32") / IMAGEJ_SCALE image = cpi.Image(pixels, mask=mask) workspace.image_set.add(output_image_name, image) else: display = display_service.getActiveImageDisplay() self.save_display_as_image(workspace, display, output_image_name)
def test_09_01_get_display_service(self): svc = ij2.get_display_service(self.context)
def execute_advanced_command(self, workspace, command, d): '''Execute an advanced command command - name of the command d - dictionary to be used to find settings ''' context = get_context() self.get_command_settings(command, d) wants_display = self.show_window if wants_display: workspace.display_data.input_images = input_images = [] workspace.display_data.output_images = output_images = [] key = command.get_unicode_value() node = command.get_selected_leaf() module_info = node[2] input_dictionary = J.get_map_wrapper( J.make_instance('java/util/HashMap', "()V")) display_dictionary = {} display_service = ij2.get_display_service(context) for setting, module_item in d[key]: if isinstance(setting, cps.ImageNameProvider): continue field_name = module_item.getName() field_type = module_item.getType() raw_type = J.call(module_item.o, "getType", "()Ljava/lang/Class;") if field_type in (ij2.FT_BOOL, ij2.FT_INTEGER, ij2.FT_FLOAT, ij2.FT_STRING): input_dictionary.put(field_name, J.box(setting.value, raw_type)) elif field_type == ij2.FT_COLOR: assert isinstance(setting, cps.Color) red, green, blue = setting.to_rgb() jobject = J.make_instance( "imagej/util/ColorRGB", "(III)V", red, green, blue) input_dictionary.put(field_name, jobject) elif field_type == ij2.FT_IMAGE: image_name = setting.value image = workspace.image_set.get_image(image_name) pixel_data = image.pixel_data * IMAGEJ_SCALE dataset = ij2.create_dataset( context, pixel_data, image_name) display = display_service.createDisplay(image_name, dataset) display_dictionary[module_item.getName()] = display if image.has_mask: #overlay_name = "X" + uuid.uuid4().get_hex() #image_dictionary[overlay_name] = image.mask overlay = ij2.create_overlay(context, image.mask) overlay_service = ij2.get_overlay_service(context) overlay_service.addOverlays( display.o, J.make_list([overlay])) ij2.select_overlay(display.o, overlay) input_dictionary.put(field_name, display.o) if wants_display: input_images.append((image_name, image.pixel_data)) elif field_type == ij2.FT_TABLE: table_name = setting.value table = workspace.object_set.get_type_instance( IJ_TABLE_TYPE, table_name) input_dictionary.put(field_name, table) elif field_type == ij2.FT_FILE: jfile = J.make_instance( "java/io/File", "(Ljava/lang/String;)V", setting.value) input_dictionary.put(field_name, jfile) command_service = ij2.get_command_service(get_context()) future = command_service.run(module_info.o, input_dictionary.o) module = future.get() for setting, module_item in d[key]: if isinstance(setting, cps.ImageNameProvider): name = module_item.getName() output_name = setting.value if display_dictionary.has_key(name): display = display_dictionary[name] else: display = IJ2.wrap_display(module.getOutput(name)) pixel_data = self.save_display_as_image( workspace, display, output_name) if wants_display: output_images.append((output_name, pixel_data)) # Close any displays that we created. for display in display_dictionary.values(): display.close()
def execute_advanced_command(self, workspace, command, d): '''Execute an advanced command command - name of the command d - dictionary to be used to find settings ''' wants_display = workspace.frame is not None if wants_display: workspace.display_data.input_images = input_images = [] workspace.display_data.output_images = output_images = [] key = command.get_unicode_value() if bioformats.USE_IJ2: node = command.get_selected_leaf() module_info = node[2] module = IJ2.wrap_module(module_info.createModule()) context = self.get_context() display_service = IJ2.get_display_service(context) display_dictionary = {} for setting, module_item in d[key]: field_type = module_item.getType() if isinstance(setting, cps.ImageNameProvider): continue if field_type == IJ2.FT_BOOL: value = J.make_instance("java/lang/Boolean", "(Z)V", setting.value) elif field_type == IJ2.FT_INTEGER: value = J.make_instance("java/lang/Integer", "(I)V", setting.value) elif field_type == IJ2.FT_FLOAT: value = J.make_instance("java/lang/Double", "(D)V", setting.value) elif field_type == IJ2.FT_STRING: value = setting.value elif field_type == IJ2.FT_COLOR: value = IJ2.make_color_rgb_from_html(setting.value) elif field_type == IJ2.FT_IMAGE: image_name = setting.value image = workspace.image_set.get_image(image_name) dataset = IJ2.create_dataset(image.pixel_data, setting.value) display = display_service.createDisplay(dataset) if image.has_mask: overlay = IJ2.create_overlay(image.mask) display.displayOverlay(overlay) value = display display_dictionary[module_item.getName()] = display if wants_display: input_images.append((image_name, image.pixel_data)) module.setInput(module_item.getName(), value) module_service = IJ2.get_module_service(context) module_service.run(module) for setting, module_item in d[key]: if isinstance(setting, cps.ImageNameProvider): name = module_item.getName() output_name = setting.value if display_dictionary.has_key(name): display = display_dictionary[name] else: display = IJ2.wrap_display(module.getOutput(name)) ds = display_service.getActiveDataset(display) pixel_data = ds.get_pixel_data() image = cpi.Image(pixel_data) workspace.image_set.add(output_name, image) if wants_display: output_images.append((output_name, pixel_data)) for display in display_dictionary.values(): panel = IJ2.wrap_display_panel(display.getDisplayPanel()) panel.close() else: from imagej.imageplus import make_imageplus_from_processor from imagej.imageplus import get_imageplus_wrapper from imagej.imageprocessor import make_image_processor from imagej.imageprocessor import get_image command = command.value settings = d[command] classname = self.get_cached_commands()[command] plugin = M.get_plugin(classname) fp_in = P.get_input_fields_and_parameters(plugin) result = [] image_set = workspace.image_set assert isinstance(image_set, cpi.ImageSet) for (field, parameter), setting in zip(fp_in, settings[:len(fp_in)]): field_type = P.get_field_type(field) label = parameter.label() or "" if field_type == P.FT_IMAGE: image_name = setting.value image = workspace.image_set.get_image( image_name, must_be_grayscale=True) pixel_data = (image.pixel_data * 255.0).astype(np.float32) if wants_display: input_images.append((image_name, pixel_data / 255.0)) processor = make_image_processor(pixel_data) image_plus = make_imageplus_from_processor( image_name, processor) field.set(plugin, image_plus) del image_plus del processor elif field_type == P.FT_INTEGER: field.setInt(plugin, setting.value) elif field_type == P.FT_FLOAT: field.setFloat(plugin, setting.value) elif field_type == P.FT_BOOL: field.setBoolean(plugin, setting.value) else: field.set(plugin, setting.value) # # There are two ways to run this: # * Batch - just call plugin.run() # * Interactive - use PlugInFunctions.runInteractively # if self.pause_before_proceeding: J.static_call('imagej/plugin/PlugInFunctions', 'runInteractively', '(Ljava/lang/Runnable)V', plugin) else: J.call(plugin, 'run', '()V') setting_idx = len(fp_in) fp_out = P.get_output_fields_and_parameters(plugin) for field, parameter in fp_out: field_type = P.get_field_type(field) if field_type == P.FT_IMAGE: image_name = settings[setting_idx].value setting_idx += 1 image_plus = get_imageplus_wrapper(field.get(plugin)) processor = image_plus.getProcessor() pixel_data = get_image(processor).astype( np.float32) / 255.0 if wants_display: output_images.append((image_name, pixel_data)) image = cpi.Image(pixel_data) image_set.add(image_name, image)