*/

	 * Creates a copy of all the planes bounded by the currently selected 2d
	 * region of an ImageDisplay.
	 */
<<<<<<< HEAD
	ImageDisplay duplicateSelectedPlanes(ImageDisplay display);
=======
	public ImageDisplay duplicateSelectedPlanes(final ImageDisplay display) {
		final SamplingDefinition copyDef =
			SamplingDefinition.sampleAllPlanes(display);
		final RealRect selection = overlayService.getSelectionBounds(display);
		final long minX = (long) selection.x;
		final long minY = (long) selection.y;
		final long maxX = (long) (selection.x + selection.width);
		final long maxY = (long) (selection.y + selection.height);
		final AxisSubrange xSubrange = new AxisSubrange(minX, maxX);
		final AxisSubrange ySubrange = new AxisSubrange(minY, maxY);
		copyDef.constrain(Axes.X, xSubrange);
		copyDef.constrain(Axes.Y, ySubrange);
		return createSampledImage(copyDef);
	}

	// -- private helpers --

	/**
	 * Creates an output image from a sampling definition. All data initialized to
	 * zero.
	 */
	private ImageDisplay createOutputImage(final SamplingDefinition def) {
		final ImageDisplay origDisp = def.getDisplay();
		// TODO - remove evil cast
		final Dataset origDs = (Dataset) origDisp.getActiveView().getData();
		final long[] dims = def.getOutputDims();
		final String name = origDisp.getName();
		final AxisType[] axes = def.getOutputAxes();
		final double[] cal = def.getOutputCalibration(axes);
		final int bitsPerPixel = origDs.getType().getBitsPerPixel();
		final boolean signed = origDs.isSigned();
		final boolean floating = !origDs.isInteger();
		final Dataset output =
			datasetService.create(dims, name, axes, bitsPerPixel, signed, floating);
		output.setCalibration(cal);
		long numPlanes = calcNumPlanes(dims, axes);
		if (numPlanes > Integer.MAX_VALUE) {
			throw new IllegalArgumentException(
				"output image has more planes than "+Integer.MAX_VALUE);
		}
		output.getImgPlus().initializeColorTables((int)numPlanes);
		if (origDs.isRGBMerged()) {
			final int chanAxis = output.getAxisIndex(Axes.CHANNEL);
			if (chanAxis >= 0) {
				if (output.dimension(chanAxis) == 3) {
					output.setRGBMerged(true);
				}
			}
		}
		// TODO - remove evil cast
		return (ImageDisplay) displayService.createDisplay(name, output);
	}

	/** Copies all associated data from a SamplingDefinition to an output image. */
	private void copyData(final SamplingDefinition def,
		final ImageDisplay outputImage)
	{
		final PositionIterator iter1 = new SparsePositionIterator(def);
		final PositionIterator iter2 = new DensePositionIterator(def);
		// TODO - remove evil casts
		final Dataset input = (Dataset) def.getDisplay().getActiveView().getData();
		final Dataset output = (Dataset) outputImage.getActiveView().getData();
		final long[] inputDims = input.getDims();
		final long[] outputDims = output.getDims();
		final RandomAccess> inputAccessor =
			input.getImgPlus().randomAccess();
		final RandomAccess> outputAccessor =
			output.getImgPlus().randomAccess();
		double min = Double.MAX_VALUE;
		double max = -Double.MAX_VALUE;
		while (iter1.hasNext() && iter2.hasNext()) {

			// determine data positions within datasets
			final long[] inputPos = iter1.next();
			final long[] outputPos = iter2.next();
			inputAccessor.setPosition(inputPos);
			outputAccessor.setPosition(outputPos);

			// copy value
			final double value = inputAccessor.get().getRealDouble();
			min = Math.min(value, min);
			max = Math.max(value, max);
			outputAccessor.get().setReal(value);

			// TODO - notice there is a lot of inefficiency following here.
			// We are setting color tables once per pixel in image and do a lot of
			// calculation to figure out what table. This should be done once per
			// plane.
			
			// keep dataset color tables in sync
			final int inputPlaneNumber = planeNum(inputDims, inputPos);
			final ColorTable colorTable = input.getColorTable(inputPlaneNumber);
			final int outputPlaneNumber = planeNum(outputDims, outputPos);
			output.setColorTable(colorTable, outputPlaneNumber);
		}

		// TODO - enable this code
		// List overlays = overlayService.getOverlays(def.getDisplay());
		// attachOverlays(def.getDisplay(), outputImage, overlays);

		/* TODO
		setOtherMetadata();  // user defined info that has been added to orig data
		// keep composite status in sync
		setCompositeChannelCount(input, output);

		// keep display color tables in sync
		updateDisplayColorTables(def.getDisplay(), outputImage);

		// set the display range from actual data values
		// TODO - could just reuse input image's display ranges for valid channels
		setDisplayRange(outputImage, min, max);
	}

	/** Calculates a plane number from a position within a dimensional space. */
	private int planeNum(final long[] dims, final long[] pos) {
		int plane = 0;
		int inc = 1;
		for (int i = 2; i < dims.length; i++) { // TODO - assumes X & Y are 1st two dims
			plane += pos[i] * inc;
			inc *= dims[i];
		}
		return plane;
	}

	/**
	 * Sets an output Dataset's composite channel count based upon an input
	 * Dataset's composite channel characteristics.
	 */
	private void setCompositeChannelCount(final Dataset input,
		final Dataset output)
	{
		if (input.getCompositeChannelCount() == 1) return;
		final int index = output.getAxisIndex(Axes.CHANNEL);
		final long numChannels = (index < 0) ? 1 : output.dimension(index);
		output.setCompositeChannelCount((int) numChannels);
		// outside viewers need to know composite channel count changed
		output.rebuild();
	}

	/**
	 * Copies the appropriate color tables from the input ImageDisplay to the
	 * output ImageDiosplay.
	 */
	private void updateDisplayColorTables(final ImageDisplay input,
		final ImageDisplay output)
	{
		final int chAxisIn = input.getAxisIndex(Axes.CHANNEL);
		final int chAxisOut = output.getAxisIndex(Axes.CHANNEL);
		if (chAxisIn < 0 || chAxisOut < 0) {
			return;
		}
		if (input.dimension(chAxisIn) != output.dimension(chAxisOut)) {
			return;
		}

		// otherwise if here the two displays have channel axes of the same size

		// TODO - cannot assume 1 color table per channel, right? if so then no
		// idea how to copy color tables. For now will assume 1 per channel
		final DatasetView inView = imgDispService.getActiveDatasetView(input);
		final DatasetView outView = imgDispService.getActiveDatasetView(output);
		final List colorTables = inView.getColorTables();
		for (int c = 0; c < colorTables.size(); c++) {
			final ColorTable table = colorTables.get(c);
			outView.setColorTable(table, c);
		}
	}

	private void attachOverlays(final ImageDisplay inputDisp,
		final ImageDisplay outputDisp, final List overlays)
	{
		final RealRect bounds = overlayService.getSelectionBounds(inputDisp);
		final double[] toOrigin = new double[2];
		toOrigin[0] = -bounds.x;
		toOrigin[1] = -bounds.y;
		final List newOverlays = new ArrayList();
		for (final Overlay overlay : overlays) {
			if (overlayWithinBounds(overlay, bounds)) {
				// add a reference to existing overlay?
				if (toOrigin[0] == 0 && toOrigin[1] == 0) {
					newOverlays.add(overlay);
				}
				else { // different origins means must create new overlays
					final Overlay newOverlay = overlay.duplicate();
					newOverlay.move(toOrigin);
					newOverlays.add(newOverlay);
				}
			}
		}
		overlayService.addOverlays(outputDisp, newOverlays);
	}

	private boolean overlayWithinBounds(final Overlay overlay,
		final RealRect bounds)
	{
		if (overlay.min(0) < bounds.x) return false;
		if (overlay.min(1) < bounds.y) return false;
		if (overlay.max(0) > bounds.x + bounds.width) return false;
		if (overlay.max(1) > bounds.y + bounds.height) return false;
		return true;
	}
>>>>>>> 4669b3785cc2b24740d9cd9172e1a24ae6a6a6e1

}

	 * Creates a copy of all the planes bounded by the currently selected 2d
	 * region of an ImageDisplay.
	 */
	ImageDisplay duplicateSelectedPlanes(ImageDisplay display);

}