import org.scijava.plugin.PluginInfo; //导入依赖的package包/类
public static void main(String... args) {
final Context context = new Context();

// Remove the Display and Results post-processors to prevent output
// windows from being displayed
final PluginService pluginService = context.service(PluginService.class);
final PluginInfo<SciJavaPlugin> display = pluginService.getPlugin(DisplayPostprocessor.class);
final PluginInfo<SciJavaPlugin> results = pluginService.getPlugin(ResultsPostprocessor.class);
pluginService.removePlugin(display);
pluginService.removePlugin(results);

JupyterService jupyter = context.service(JupyterService.class);
jupyter.runKernel(args);

context.dispose();
   }
 

import org.scijava.plugin.PluginInfo; //导入依赖的package包/类
/** Build the menu listing {@code SlideSetPlugin}s */
private JMenu buildSlideSetPluginsMenu() {
     JMenu m = new JMenu("Slide Set Commands");
     List<CommandInfo> plugins = sspl.getPluginInfo();
     for(PluginInfo<Command> plugin : plugins) {
          String[] path = plugin.getMenuPath().getMenuString().split(MenuPath.PATH_SEPARATOR);
          if(path == null || path[0] == null || path[0].equals("")) {
               path = new String[1];
               path[0] = plugin.getTitle();
          }
          if(path.length > 3
                  && path[0].trim().equalsIgnoreCase("Plugins")
                  && path[1].trim().equalsIgnoreCase("Slide Set")
                  && path[2].trim().equalsIgnoreCase("Commands")) {
              String[] pathShrunk
                      = Arrays.copyOfRange(path, 3, path.length);
              path = pathShrunk;
          }
          String command = "sspl/" + plugin.getClassName();
          UIUtil.parseRecursiveMenuAdd(path, command, m, this);
     }
     return m;
}
 

import org.scijava.plugin.PluginInfo; //导入依赖的package包/类
/** Build the menu listing other ImageJ commands */
private JMenu buildOtherCommandsMenu() {
     JMenu m = new JMenu("Other ImageJ Commands");
     m.add(new JMenu("Edit "));
     m.add(new JMenu("Image "));
     m.add(new JMenu("Process "));
     m.add(new JMenu("Analyze "));
     m.add(new JMenu("Plugins "));
     /*MenuService ijms = ij.getService(MenuService.class); // Possible alternative way to do this?
     SwingJMenuCreator ijmc = new SwingJMenuCreator();
     ShadowMenu ijMenu = ijms.getMenu();
     ijmc.createMenus(ijMenu, m);*/
     PluginService ps = ij.get(PluginService.class);
     List<PluginInfo<Command>> plugins = ps.getPluginsOfType(Command.class);
     for(PluginInfo<Command> plugin : plugins) {
          String[] path = plugin.getMenuPath().getMenuString().split(MenuPath.PATH_SEPARATOR);
          String command = "ijps/" + plugin.getClassName();
          if(path != null && !path[0].equals("") && path.length > 1
               && !path[0].equals("File ")
               && !path[0].equals("Window ")
               && !path[0].equals("Help ")
               && plugin.getAnnotation() != null
               && plugin.getAnnotation().visible())
               UIUtil.parseRecursiveMenuAdd(path, command, m, this);
     }
     return m;
}
 

import org.scijava.plugin.PluginInfo; //导入依赖的package包/类
/** Tests that all ops can be successfully instantiated. */
@Test
public void testInstantiation() {
	int errors = 0;
	for (final PluginInfo<Op> info : ops.getPlugins()) {
		try {
			info.createInstance();
		}
		catch (InstantiableException e) {
			errors++;
			System.err.println("Could not instantiate " + info.getClassName());
		}
	}
	assertEquals(0, errors);
}
 

import org.scijava.plugin.PluginInfo; //导入依赖的package包/类
/**
 * Tests that each op implements the marker interface that it uses as its
 * plugin type.
 */
@Test
public void testOpInterface() throws InstantiableException {
	for (final PluginInfo<Op> info : ops.getPlugins()) {
		final Class<Op> type = info.getPluginType();
		final Class<? extends Op> c = info.loadClass();
		final String msg =
			type.getName() + " is not assignable from " + c.getName();
		assertTrue(msg, type.isAssignableFrom(c));
	}
}
 

import org.scijava.plugin.PluginInfo; //导入依赖的package包/类
private SCIFIO makeSCIFIO() {
	final SCIFIO scifio = new SCIFIO();

	final Context ctx = scifio.getContext();

	final PluginInfo<Filter> enabledInfo =
		new PluginInfo<>(EnabledFilter.class, Filter.class);
	final PluginInfo<Filter> disabledInfo =
		new PluginInfo<>(DisabledFilter.class, Filter.class);

	ctx.getPluginIndex().add(enabledInfo);
	ctx.getPluginIndex().add(disabledInfo);

	return scifio;
}
 

import org.scijava.plugin.PluginInfo; //导入依赖的package包/类
@Test
public void testFilterOrder() throws FormatException, IOException {
	readerFilter = scifio.initializer().initializeReader(id);

	// enable all plugins
	for (final PluginInfo<Filter> pi : scifio.getContext().getPluginIndex()
		.getPlugins(Filter.class))
	{
		((ReaderFilter) readerFilter).enable(pi.getPluginClass());
	}

	double lastPriority = Double.MAX_VALUE;

	// Skip the actual ReaderFilter class
	if (Filter.class.isAssignableFrom(readerFilter.getClass())) readerFilter =
		(Reader) ((Filter) readerFilter).getParent();

	while (Filter.class.isAssignableFrom(readerFilter.getClass())) {
		final double priority = ((Filter) readerFilter).getPriority();

		// Verify all plugins are in proper order
		assertTrue(priority <= lastPriority);
		lastPriority = priority;

		readerFilter = (Reader) ((Filter) readerFilter).getParent();
	}

}
 

import org.scijava.plugin.PluginInfo; //导入依赖的package包/类
@Test
public void checkScancoISQFormat() {
    final Stream<PluginInfo<?>> infoStream = IMAGE_J.plugin().getPlugins().stream();

    assertTrue(infoStream.anyMatch(i -> i.getClassName().equals("io.scif.formats.ScancoISQFormat")));
}
 

import org.scijava.plugin.PluginInfo; //导入依赖的package包/类
@Test
public void checkKontronFormat() {
    final Stream<PluginInfo<?>> infoStream = IMAGE_J.plugin().getPlugins().stream();

    assertTrue(infoStream.anyMatch(i -> i.getClassName().equals("io.scif.formats.KontronFormat")));
}
 

import org.scijava.plugin.PluginInfo; //导入依赖的package包/类
@Override
public IRandomAccess getHandle(final String id, final boolean writable,
	final boolean allowArchiveHandles) throws IOException
{
	log.trace("getHandle(id = " + id + ", writable = " + writable + ")");
	IRandomAccess handle = getMappedFile(id);
	if (handle == null) {
		log.trace("no handle was mapped for this ID");
		final String mapId = getMappedId(id);

		final List<PluginInfo<IStreamAccess>> streamInfos =
			getContext().getPluginIndex().getPlugins(IStreamAccess.class);

		if (allowArchiveHandles) {
			for (final PluginInfo<IStreamAccess> info : streamInfos) {
				handle = pluginService.createInstance(info);
				if (((IStreamAccess) handle).isConstructable(id)) {
					((IStreamAccess) handle).setFile(id);
					break;
				}
				handle = null;
			}
		}

		try {
			if (handle == null) handle =
				new NIOFileHandle(nioService, mapId, writable ? "rw" : "r");
		}
		catch (final IOException e) {
			// File doesn't exist on disk, so we'll create a virtual handle
			// that
			// can be used even when a physical file doesn't exist.
			// TODO this solution is not ideal; but we are currently limited
			// by the
			// over-use of RAIS and the mapping of handles by
			// LocationService.
			// This infrastructure is going to be redone before a 1.0.0
			// release,
			// but VirtualHandle is an intermediate fix.
			return new VirtualHandle(mapId);
		}
	}
	log.trace("Location.getHandle: " + id + " -> " + handle);
	return handle;
}
 

import org.scijava.plugin.PluginInfo; //导入依赖的package包/类
private PluginInfo<Command> pluginInfo(
	final Class<? extends Command> pluginClass)
{
	final Plugin ann = pluginClass.getAnnotation(Plugin.class);
	return new PluginInfo<Command>(pluginClass, Command.class, ann);
}