Java Roi.POINT属性代码示例

private static String[] getImageList()
{
	TurboList<String> newImageList = new TurboList<String>();

	for (int id : Utils.getIDList())
	{
		ImagePlus imp = WindowManager.getImage(id);
		if (imp == null)
			continue;
		if (imp.getNDimensions() != 3)
			continue;
		if (imp.getBitDepth() == 24)
			continue;
		Roi roi = imp.getRoi();
		if (roi == null || roi.getType() != Roi.POINT)
			continue;
		newImageList.add(imp.getTitle());
	}

	return newImageList.toArray(new String[0]);
}
 

private boolean findFitRegion()
{
	// Get the centre
	Roi roi = imp.getRoi();
	if (roi != null && roi.getType() == Roi.POINT)
	{
		FloatPolygon p = roi.getFloatPolygon();
		int n = p.npoints;
		if (n != 1)
		{
			IJ.error(TITLE, "Require a single point ROI");
			return false;
		}
		cx = (int) p.xpoints[0];
		cy = (int) p.ypoints[0];
		return true;
	}
	IJ.error(TITLE, "Require a single point ROI");
	return false;
}
 

public int setup(String arg, ImagePlus imp)
{
	SMLMUsageTracker.recordPlugin(this.getClass(), arg);

	if (imp == null)
	{
		IJ.noImage();
		return DONE;
	}

	Roi roi = imp.getRoi();
	if (roi == null || roi.getType() != Roi.POINT)
	{
		IJ.error("Point ROI required");
		return DONE;
	}

	this.imp = imp;

	return showDialog();
}
 

/**
 * @return Extract all the ROI points
 */
private BasePoint[] getSpots()
{
	float z = imp.getStackSize() / 2;
	Roi roi = imp.getRoi();
	if (roi != null && roi.getType() == Roi.POINT)
	{
		FloatPolygon p = roi.getFloatPolygon();
		int n = p.npoints;

		float offset = 0.5f;

		// Check if already float coordinates
		if (!SimpleArrayUtils.isInteger(p.xpoints) || !SimpleArrayUtils.isInteger(p.ypoints))
			offset = 0;

		BasePoint[] roiPoints = new BasePoint[n];
		for (int i = 0; i < n; i++)
		{
			roiPoints[i] = new BasePoint(p.xpoints[i] + offset, p.ypoints[i] + offset, z);
		}
		return roiPoints;
	}
	return new BasePoint[0];
}
 

/** Creates a point selection. */
public static void makePoint(int x, int y) {
	ImagePlus img = getImage();
	Roi roi = img.getRoi();
	if (shiftKeyDown() && roi!=null && roi.getType()==Roi.POINT) {
		Polygon p = roi.getPolygon();
		p.addPoint(x, y);
		img.setRoi(new PointRoi(p.xpoints, p.ypoints, p.npoints));
	} else
		img.setRoi(new PointRoi(x, y));
}
 

private boolean getImage()
{
	// Select an image
	GenericDialog gd = new GenericDialog(TITLE);
	String[] list = getImageList();
	if (list.length == 0)
	{
		IJ.error("No suitable images");
		return false;
	}
	gd.addChoice("Image", list, pluginSettings.getImage());
	gd.showDialog();
	if (gd.wasCanceled())
		return false;
	String image = gd.getNextChoice();
	pluginSettings.setImage(image);
	imp = WindowManager.getImage(image);
	if (imp == null)
	{
		IJ.error(TITLE, "Failed to find image: " + image);
		return false;
	}
	Roi roi = imp.getRoi();
	if (roi == null || roi.getType() != Roi.POINT)
	{
		IJ.error("Point ROI required");
		return false;
	}
	return true;
}
 

private void killPointRoi(ImagePlus imp)
{
	if (imp != null)
	{
		if (imp.getRoi() != null && imp.getRoi().getType() == Roi.POINT)
		{
			imp.killRoi();
		}
	}
}
 

@Override
public void updateImageList()
{
	int noOfImages = WindowManager.getImageCount();
	List<String> imageList = new ArrayList<String>(noOfImages);
	for (int id : gdsc.core.ij.Utils.getIDList())
	{
		ImagePlus imp = WindowManager.getImage(id);

		// Image must be 8-bit/16-bit/32-bit && only contains XYZ dimensions
		if (imp != null && (imp.getType() == ImagePlus.GRAY8 || imp.getType() == ImagePlus.GRAY16 ||
				imp.getType() == ImagePlus.GRAY32) && (imp.getNChannels() == 1 && imp.getNFrames() == 1))
		{
			Roi roi = imp.getRoi();
			if (roi == null || roi.getType() != Roi.POINT)
				continue;

			// Check it is not one the result images
			String imageTitle = imp.getTitle();
			if (!imageTitle.endsWith(FindFoci.TITLE) && !imageTitle.endsWith("clone") &&
					!imageTitle.endsWith(" TP") && !imageTitle.endsWith(" FP") && !imageTitle.endsWith(" FN"))
			{
				imageList.add(imageTitle);
			}
		}
	}

	model.setImageList(imageList);
}
 

/**
 * Extracts the points from the given Point ROI
 * 
 * @param roi
 * @return The list of points (can be zero length)
 */
public static AssignedPoint[] extractRoiPoints(Roi roi)
{
	AssignedPoint[] roiPoints = null;

	if (roi != null && roi.getType() == Roi.POINT)
	{
		Polygon p = ((PolygonRoi) roi).getNonSplineCoordinates();
		int n = p.npoints;
		Rectangle bounds = roi.getBounds();
		// The ROI has either a hyperstack position or a stack position, but not both.
		// Both will be zero if the ROI has no 3D information.
		int z = roi.getZPosition();
		if (z == 0)
			z = roi.getPosition();

		roiPoints = new AssignedPoint[n];
		for (int i = 0; i < n; i++)
		{
			roiPoints[i] = new AssignedPoint(bounds.x + p.xpoints[i], bounds.y + p.ypoints[i], z, i);
		}
	}
	else
	{
		roiPoints = new AssignedPoint[0];
	}

	return roiPoints;
}
 

public void mouseClicked(MouseEvent e)
{
	setShowOverlay(false);

	Roi roi = activeImp.getRoi();
	if (roi != null && roi.getType() == Roi.POINT)
	{
		PointRoi pointRoi = (PointRoi) roi;
		Polygon p = pointRoi.getNonSplineCoordinates();

		if (p.npoints < currentRoiPoints || p.npoints == 1)
		{
			// The ROI has had a point removed or has been restarted at 1 point

			if (p.npoints == 1)
			{
				// Picking has restarted so allow update 
				manager.resetAssigned();
				assignRoiPoints();
			}
			else
			{
				// This is a removal of a point, all other points should already be located at maxima
				reassignRoiPoints();
			}
		}
		else if (p.npoints > currentRoiPoints)
		{
			mapRoiPoint(pointRoi, p.npoints - 1);
		}
	}
}
 

public void mouseReleased(MouseEvent e)
{
	if (dragging)
	{
		dragging = false;
		Roi roi = activeImp.getRoi();
		if (roi != null && roi.getType() == Roi.POINT && roi.getState() == Roi.NORMAL)
		{
			// Find the image x,y coords
			ImageCanvas ic = activeImp.getCanvas();
			int ox = ic.offScreenX(e.getX());
			int oy = ic.offScreenY(e.getY());

			//logMessage("Dropped coords " + ox + "," + oy);

			int index = findRoiPointIndex((PointRoi) roi, ox, oy);

			if (index >= 0)
			{
				if (assignDragged)
				{
					mapRoiPoint((PointRoi) roi, index);
				}
				else
				{
					addRoiPoint((PointRoi) roi, index);
				}
			}
		}
	}
}
 

/**
 * Adds the mapped/unmapped points to the image using an overlay
 */
private void showOverlay()
{
	// Build lists of the mapped and unmapped points
	AssignedPoint[] points = getRoiPoints();

	List<AssignedPoint> mapped = new LinkedList<AssignedPoint>();
	List<AssignedPoint> unmapped = new LinkedList<AssignedPoint>();
	for (AssignedPoint p : points)
	{
		if (p.getAssignedId() < 0)
			unmapped.add(p);
		else
			mapped.add(p);
	}

	// Add the overlay
	activeImp.setOverlay(null);
	MatchPlugin.addOverlay(activeImp, mapped, Color.green);
	MatchPlugin.addOverlay(activeImp, unmapped, Color.yellow);

	// Save the ROI and remove it
	savedRoi = activeImp.getRoi();
	if (savedRoi != null && savedRoi.getType() != Roi.POINT)
	{
		savedRoi = null;
	}
	activeImp.killRoi();
}
 

/**
 * Hides the overlay and restores the ROI
 */
private void hideOverlay()
{
	// Kill the overlay
	activeImp.setOverlay(null);

	Roi roi = activeImp.getRoi();
	if (roi != null)
	{
		// If this is a new point then merge it into the saved Point ROI
		if (roi.getType() == Roi.POINT && savedRoi != null)
		{
			// Merge the current ROI and the saved one
			PointRoi pointRoi = (PointRoi) savedRoi;
			AssignedPoint[] newPoints = PointManager.extractRoiPoints(roi);
			for (AssignedPoint p : newPoints)
			{
				//pointRoi = pointRoi.addPoint(p.getX() - pointRoi.getBounds().x, p.getY() - pointRoi.getBounds().y);
				pointRoi = pointRoi.addPoint(p.getX(), p.getY());
			}
			activeImp.setRoi(pointRoi, true);
		}
	}
	else
	{
		// No new ROI so just restore from the old one 
		activeImp.restoreRoi();
	}

	savedRoi = null;
}
 

private boolean showDialog()
{
	// To improve the flexibility, do not restrict the mask to those suitable for the image. Allow any image for the mask.
	//ArrayList<String> newImageList = FindFoci.buildMaskList(imp);
	//String[] list = newImageList.toArray(new String[0]);
	String[] list = Utils.getImageList(Utils.NO_IMAGE, null);

	GenericDialog gd = new GenericDialog(TITLE);

	gd.addMessage("Extracts the ROI points to file");
	gd.addChoice("Mask", list, mask);
	gd.addStringField("Filename", filename, 30);
	if (imp != null)
		gd.addCheckbox("xyz_only", xyz);

	if (isManagerAvailable())
	{
		gd.addMessage(String.format("%s (%s) present in the ROI manager",
				TextUtils.pleural(nPointRois(), "ROI"), TextUtils.pleural(nPoints(), "point")));
		gd.addCheckbox("Use_manager_ROIs", useManager);
		gd.addCheckbox("Reset_manager", reset);
	}
	else
	{
		Roi roi = imp.getRoi();
		if (roi == null || roi.getType() != Roi.POINT)
		{
			gd.addMessage("Warning: The image does not contain Point ROI.\nAn empty result file will be produced");
		}
	}

	gd.showDialog();

	if (gd.wasCanceled())
		return false;

	mask = gd.getNextChoice();
	filename = gd.getNextString();
	if (imp != null)
		xyz = gd.getNextBoolean();

	if (isManagerAvailable())
	{
		useManager = gd.getNextBoolean();
		reset = gd.getNextBoolean();
	}

	return true;
}
 

public void mouseDragged(MouseEvent e)
{
	setShowOverlay(false);

	Roi roi = activeImp.getRoi();
	if (roi != null && roi.getType() == Roi.POINT && roi.getState() == Roi.MOVING_HANDLE)
	{
		if (!dragging)
		{
			dragging = true;

			// Find the image x,y coords
			ImageCanvas ic = activeImp.getCanvas();
			int ox = ic.offScreenX(e.getX());
			int oy = ic.offScreenY(e.getY());

			//logMessage("Image coords " + ox + "," + oy);

			// Check if an assigned point is being moved
			GridPoint movedPoint = manager.findClosestAssignedPoint(ox, oy);

			double mag = activeImp.getCanvas().getMagnification();

			// Distance for the ROI is dependent on magnification.  
			// Approximate distance for mouse to change from cross to finger in X/Y:
			// 50% = 10px
			// 100% = 5px
			// 200% = 2px 
			// Given that the drag could move away from the current ROI centre a bit more 
			// tolerance could be added if this limit is too strict.
			int distanceLimit = (int) Math.ceil(5 / mag);

			// Check the point is within reasonable distance of the mouse
			if (movedPoint != null && Math.abs(movedPoint.getX() - ox) <= distanceLimit &&
					Math.abs(movedPoint.getY() - oy) <= distanceLimit)
			{
				//logMessage("Dragging point " + movedPoint.getX() + "," + movedPoint.getY());
				movedPoint.setAssigned(false);
				setMappedPoints(mappedPoints - 1);
			}
			else
			{
				setUnmappedPoints(unmappedPoints - 1);
			}
		}
	}
}