private void drawSelection(Graphics2D g2d) {
if (srcx != destx || srcy != desty) {
int x1 = (srcx < destx) ? srcx : destx;
int y1 = (srcy < desty) ? srcy : desty;
int x2 = (srcx > destx) ? srcx : destx;
int y2 = (srcy > desty) ? srcy : desty;
rectSelection.x = x1;
rectSelection.y = y1;
rectSelection.width = (x2 - x1) + 1;
rectSelection.height = (y2 - y1) + 1;
if (rectSelection.width > 0 && rectSelection.height > 0) {
g2d.drawImage(scr_img.getSubimage(x1, y1, x2 - x1 + 1, y2 - y1 + 1), null, x1, y1);
}
g2d.setColor(selFrameColor);
g2d.setStroke(bs);
g2d.draw(rectSelection);
int cx = (x1 + x2) / 2;
int cy = (y1 + y2) / 2;
g2d.setColor(selCrossColor);
g2d.setStroke(_StrokeCross);
g2d.drawLine(cx, y1, cx, y2);
g2d.drawLine(x1, cy, x2, cy);
if (Screen.getNumberScreens() > 1) {
drawScreenFrame(g2d, srcScreenId);
}
}
}
/** Enlarge the canvas if the user enlarges the window. */
void resizeCanvas(int width, int height) {
ImageWindow win = imp.getWindow();
// IJ.log("resizeCanvas: "+srcRect+" "+imageWidth+" "+imageHeight+" "+width+" "+height+"
// "+dstWidth+" "+dstHeight+" "+win.maxBounds);
if (!maxBoundsReset
&& (width > dstWidth || height > dstHeight)
&& win != null
&& win.maxBounds != null
&& width != win.maxBounds.width - 10) {
if (resetMaxBoundsCount != 0)
resetMaxBounds(); // Works around problem that prevented window from being larger than
// maximized size
resetMaxBoundsCount++;
}
if (IJ.altKeyDown()) {
fitToWindow();
return;
}
if (srcRect.width < imageWidth || srcRect.height < imageHeight) {
if (width > imageWidth * magnification) width = (int) (imageWidth * magnification);
if (height > imageHeight * magnification) height = (int) (imageHeight * magnification);
setDrawingSize(width, height);
srcRect.width = (int) (dstWidth / magnification);
srcRect.height = (int) (dstHeight / magnification);
if ((srcRect.x + srcRect.width) > imageWidth) srcRect.x = imageWidth - srcRect.width;
if ((srcRect.y + srcRect.height) > imageHeight) srcRect.y = imageHeight - srcRect.height;
repaint();
}
// IJ.log("resizeCanvas2: "+srcRect+" "+dstWidth+" "+dstHeight+" "+width+" "+height);
}
public void zoomIn() {
Dimension asz = this.getSize();
int maxzf = 3;
int coef = 1;
int r;
cmdline =
"/bin/sh get.sh "
+ j2kfilename
+ " "
+ iw
+ " "
+ ih
+ " "
+ rect.x
+ " "
+ rect.y
+ " "
+ rect.width
+ " "
+ rect.height;
Exec.execPrint(cmdline);
rect.x = rect.y = rect.width = rect.height = 0;
img = pgm.open("out.pgm");
iw = img.getWidth(this);
ih = img.getHeight(this);
bi = new BufferedImage(iw, ih, BufferedImage.TYPE_INT_RGB);
big = bi.createGraphics();
selected = 0;
fullRefresh = true;
repaint();
}
protected Dimension canEnlarge(int newWidth, int newHeight) {
// if ((flags&Event.CTRL_MASK)!=0 || IJ.controlKeyDown()) return null;
ImageWindow win = imp.getWindow();
if (win == null) return null;
Rectangle r1 = win.getBounds();
Insets insets = win.getInsets();
Point loc = getLocation();
if (loc.x > insets.left + 5 || loc.y > insets.top + 5) {
r1.width = newWidth + insets.left + insets.right + 10;
r1.height = newHeight + insets.top + insets.bottom + 10;
if (win instanceof StackWindow) r1.height += 20;
} else {
r1.width = r1.width - dstWidth + newWidth + 10;
r1.height = r1.height - dstHeight + newHeight + 10;
}
Rectangle max = win.getMaxWindow(r1.x, r1.y);
boolean fitsHorizontally = r1.x + r1.width < max.x + max.width;
boolean fitsVertically = r1.y + r1.height < max.y + max.height;
if (fitsHorizontally && fitsVertically) return new Dimension(newWidth, newHeight);
else if (fitsVertically && newHeight < dstWidth) return new Dimension(dstWidth, newHeight);
else if (fitsHorizontally && newWidth < dstHeight) return new Dimension(newWidth, dstHeight);
else return null;
}
private void drawScreenFrame(Graphics2D g2d, int scrId) {
g2d.setColor(screenFrameColor);
g2d.setStroke(strokeScreenFrame);
if (screenFrame == null) {
screenFrame = Screen.getBounds(scrId);
Rectangle ubound = scrOCP.getBounds();
screenFrame.x -= ubound.x;
screenFrame.y -= ubound.y;
int sw = (int) (strokeScreenFrame.getLineWidth() / 2);
screenFrame.x += sw;
screenFrame.y += sw;
screenFrame.width -= sw * 2;
screenFrame.height -= sw * 2;
}
g2d.draw(screenFrame);
}
/**
* Gets the template location at which the best match occurs in a rectangle and along a line. May
* return null.
*
* @param target the image to search
* @param searchRect the rectangle to search within the target image
* @param x0 the x-component of a point on the line
* @param y0 the y-component of a point on the line
* @param slope the slope of the line
* @param spread the spread of the line (line width = 1+2*spread)
* @return the optimized template location of the best match, if any
*/
public TPoint getMatchLocation(
BufferedImage target, Rectangle searchRect, double x0, double y0, double theta, int spread) {
wTarget = target.getWidth();
hTarget = target.getHeight();
// determine insets needed to accommodate template
int left = wTemplate / 2, right = left;
if (wTemplate % 2 > 0) right++;
int top = hTemplate / 2, bottom = top;
if (hTemplate % 2 > 0) bottom++;
// trim search rectangle if necessary
searchRect.x = Math.max(left, Math.min(wTarget - right, searchRect.x));
searchRect.y = Math.max(top, Math.min(hTarget - bottom, searchRect.y));
searchRect.width = Math.min(wTarget - searchRect.x - right, searchRect.width);
searchRect.height = Math.min(hTarget - searchRect.y - bottom, searchRect.height);
if (searchRect.width <= 0 || searchRect.height <= 0) {
peakHeight = Double.NaN;
peakWidth = Double.NaN;
return null;
}
// set up test pixels to search (rectangle plus template)
int xMin = Math.max(0, searchRect.x - left);
int xMax = Math.min(wTarget, searchRect.x + searchRect.width + right);
int yMin = Math.max(0, searchRect.y - top);
int yMax = Math.min(hTarget, searchRect.y + searchRect.height + bottom);
wTest = xMax - xMin;
hTest = yMax - yMin;
if (target.getType() != BufferedImage.TYPE_INT_RGB) {
BufferedImage image = new BufferedImage(wTarget, hTarget, BufferedImage.TYPE_INT_RGB);
image.createGraphics().drawImage(target, 0, 0, null);
target = image;
}
targetPixels = new int[wTest * hTest];
target.getRaster().getDataElements(xMin, yMin, wTest, hTest, targetPixels);
// get the points to search along the line
ArrayList<Point2D> searchPts = getSearchPoints(searchRect, x0, y0, theta);
if (searchPts == null) {
peakHeight = Double.NaN;
peakWidth = Double.NaN;
return null;
}
// collect differences in a map as they are measured
HashMap<Point2D, Double> diffs = new HashMap<Point2D, Double>();
// find the point with the minimum difference from template
double matchDiff = largeNumber; // larger than typical differences
int xMatch = 0, yMatch = 0;
double avgDiff = 0;
Point2D matchPt = null;
for (Point2D pt : searchPts) {
int x = (int) pt.getX();
int y = (int) pt.getY();
double diff = getDifferenceAtTestPoint(x, y);
diffs.put(pt, diff);
avgDiff += diff;
if (diff < matchDiff) {
matchDiff = diff;
xMatch = x;
yMatch = y;
matchPt = pt;
}
}
avgDiff /= searchPts.size();
peakHeight = avgDiff / matchDiff - 1;
peakWidth = Double.NaN;
double dl = 0;
int matchIndex = searchPts.indexOf(matchPt);
// if match is not exact, fit a Gaussian and find peak
if (!Double.isInfinite(peakHeight) && matchIndex > 0 && matchIndex < searchPts.size() - 1) {
// fill data arrays
Point2D pt = searchPts.get(matchIndex - 1);
double diff = diffs.get(pt);
xValues[0] = -pt.distance(matchPt);
yValues[0] = avgDiff / diff - 1;
xValues[1] = 0;
yValues[1] = peakHeight;
pt = searchPts.get(matchIndex + 1);
diff = diffs.get(pt);
xValues[2] = pt.distance(matchPt);
yValues[2] = avgDiff / diff - 1;
// determine approximate offset (dl) and width (w) values
double pull = -xValues[0] / (yValues[1] - yValues[0]);
double push = xValues[2] / (yValues[1] - yValues[2]);
if (Double.isNaN(pull)) pull = LARGE_NUMBER;
if (Double.isNaN(push)) push = LARGE_NUMBER;
dl = 0.3 * (xValues[2] - xValues[0]) * (push - pull) / (push + pull);
double ratio = dl > 0 ? peakHeight / yValues[0] : peakHeight / yValues[2];
double w = dl > 0 ? dl - xValues[0] : dl - xValues[2];
w = w * w / Math.log(ratio);
// set parameters and fit to x data
dataset.clear();
dataset.append(xValues, yValues);
double rmsDev = 1;
for (int k = 0; k < 3; k++) {
double c = k == 0 ? w : k == 1 ? w / 3 : w * 3;
f.setParameterValue(0, peakHeight);
f.setParameterValue(1, dl);
f.setParameterValue(2, c);
rmsDev = fitter.fit(f);
if (rmsDev < 0.01) { // fitter succeeded (3-point fit should be exact)
dl = f.getParameterValue(1);
peakWidth = f.getParameterValue(2);
break;
}
}
}
double dx = dl * Math.cos(theta);
double dy = dl * Math.sin(theta);
double xImage = xMatch + searchRect.x - left - trimLeft + dx;
double yImage = yMatch + searchRect.y - top - trimTop + dy;
return new TPoint(xImage, yImage);
}
/**
* Gets the template location at which the best match occurs in a rectangle. May return null.
*
* @param target the image to search
* @param searchRect the rectangle to search within the target image
* @return the optimized template location at which the best match, if any, is found
*/
public TPoint getMatchLocation(BufferedImage target, Rectangle searchRect) {
wTarget = target.getWidth();
hTarget = target.getHeight();
// determine insets needed to accommodate template
int left = wTemplate / 2, right = left;
if (wTemplate % 2 > 0) right++;
int top = hTemplate / 2, bottom = top;
if (hTemplate % 2 > 0) bottom++;
// trim search rectangle if necessary
searchRect.x = Math.max(left, Math.min(wTarget - right, searchRect.x));
searchRect.y = Math.max(top, Math.min(hTarget - bottom, searchRect.y));
searchRect.width = Math.min(wTarget - searchRect.x - right, searchRect.width);
searchRect.height = Math.min(hTarget - searchRect.y - bottom, searchRect.height);
if (searchRect.width <= 0 || searchRect.height <= 0) {
peakHeight = Double.NaN;
peakWidth = Double.NaN;
return null;
}
// set up test pixels to search (rectangle plus template)
int xMin = Math.max(0, searchRect.x - left);
int xMax = Math.min(wTarget, searchRect.x + searchRect.width + right);
int yMin = Math.max(0, searchRect.y - top);
int yMax = Math.min(hTarget, searchRect.y + searchRect.height + bottom);
wTest = xMax - xMin;
hTest = yMax - yMin;
if (target.getType() != BufferedImage.TYPE_INT_RGB) {
BufferedImage image = new BufferedImage(wTarget, hTarget, BufferedImage.TYPE_INT_RGB);
image.createGraphics().drawImage(target, 0, 0, null);
target = image;
}
targetPixels = new int[wTest * hTest];
target.getRaster().getDataElements(xMin, yMin, wTest, hTest, targetPixels);
// find the rectangle point with the minimum difference
double matchDiff = largeNumber; // larger than typical differences
int xMatch = 0, yMatch = 0;
double avgDiff = 0;
for (int x = 0; x <= searchRect.width; x++) {
for (int y = 0; y <= searchRect.height; y++) {
double diff = getDifferenceAtTestPoint(x, y);
avgDiff += diff;
if (diff < matchDiff) {
matchDiff = diff;
xMatch = x;
yMatch = y;
}
}
}
avgDiff /= (searchRect.width * searchRect.height);
peakHeight = avgDiff / matchDiff - 1;
peakWidth = Double.NaN;
double dx = 0, dy = 0;
// if match is not exact, fit a Gaussian and find peak
if (!Double.isInfinite(peakHeight)) {
// fill data arrays
xValues[1] = yValues[1] = peakHeight;
for (int i = -1; i < 2; i++) {
if (i == 0) continue;
double diff = getDifferenceAtTestPoint(xMatch + i, yMatch);
xValues[i + 1] = avgDiff / diff - 1;
diff = getDifferenceAtTestPoint(xMatch, yMatch + i);
yValues[i + 1] = avgDiff / diff - 1;
}
// estimate peakHeight = peak of gaussian
// estimate offset dx of gaussian
double pull = 1 / (xValues[1] - xValues[0]);
double push = 1 / (xValues[1] - xValues[2]);
if (Double.isNaN(pull)) pull = LARGE_NUMBER;
if (Double.isNaN(push)) push = LARGE_NUMBER;
dx = 0.6 * (push - pull) / (push + pull);
// estimate width wx of gaussian
double ratio = dx > 0 ? peakHeight / xValues[0] : peakHeight / xValues[2];
double wx = dx > 0 ? dx + 1 : dx - 1;
wx = wx * wx / Math.log(ratio);
// estimate offset dy of gaussian
pull = 1 / (yValues[1] - yValues[0]);
push = 1 / (yValues[1] - yValues[2]);
if (Double.isNaN(pull)) pull = LARGE_NUMBER;
if (Double.isNaN(push)) push = LARGE_NUMBER;
dy = 0.6 * (push - pull) / (push + pull);
// estimate width wy of gaussian
ratio = dy > 0 ? peakHeight / yValues[0] : peakHeight / yValues[2];
double wy = dy > 0 ? dy + 1 : dy - 1;
wy = wy * wy / Math.log(ratio);
// set x parameters and fit to x data
dataset.clear();
dataset.append(pixelOffsets, xValues);
double rmsDev = 1;
for (int k = 0; k < 3; k++) {
double c = k == 0 ? wx : k == 1 ? wx / 3 : wx * 3;
f.setParameterValue(0, peakHeight);
f.setParameterValue(1, dx);
f.setParameterValue(2, c);
rmsDev = fitter.fit(f);
if (rmsDev < 0.01) { // fitter succeeded (3-point fit should be exact)
dx = f.getParameterValue(1);
peakWidth = f.getParameterValue(2);
break;
}
}
if (!Double.isNaN(peakWidth)) {
// set y parameters and fit to y data
dataset.clear();
dataset.append(pixelOffsets, yValues);
for (int k = 0; k < 3; k++) {
double c = k == 0 ? wy : k == 1 ? wy / 3 : wy * 3;
f.setParameterValue(0, peakHeight);
f.setParameterValue(1, dx);
f.setParameterValue(2, c);
rmsDev = fitter.fit(f);
if (rmsDev < 0.01) { // fitter succeeded (3-point fit should be exact)
dy = f.getParameterValue(1);
peakWidth = (peakWidth + f.getParameterValue(2)) / 2;
break;
}
}
if (rmsDev > 0.01) peakWidth = Double.NaN;
}
}
double xImage = xMatch + searchRect.x - left - trimLeft + dx;
double yImage = yMatch + searchRect.y - top - trimTop + dy;
return new TPoint(xImage, yImage);
}
@Override
protected void paintText(
Graphics g,
int tabPlacement,
Font font,
FontMetrics metrics,
int tabIndex,
String title,
Rectangle textRect,
boolean isSelected) {
g.setFont(font);
int titleWidth = SwingUtilities.computeStringWidth(metrics, title);
int preferredWidth = 0;
if (isOneActionButtonEnabled()) {
preferredWidth = calculateTabWidth(tabPlacement, tabIndex, metrics) - WIDTHDELTA - 15;
if (isCloseEnabled()) preferredWidth -= BUTTONSIZE;
if (isMaxEnabled()) preferredWidth -= BUTTONSIZE;
} else {
preferredWidth = titleWidth;
}
while (titleWidth > preferredWidth) {
if (title.endsWith("...")) title = title.substring(0, title.indexOf("...") - 1).concat("...");
else title = title.substring(0, title.length() - 4).concat("...");
titleWidth = SwingUtilities.computeStringWidth(metrics, title);
}
textRect.width = titleWidth;
View v = getTextViewForTab(tabIndex);
if (v != null) {
// html
v.paint(g, textRect);
} else {
// plain text
int mnemIndex = tabPane.getDisplayedMnemonicIndexAt(tabIndex);
if (tabPane.isEnabled() && tabPane.isEnabledAt(tabIndex)) {
if (isSelected) g.setColor(TAB_SELECTED_FOREGROUND_COLOR);
else {
if (this.isTabHighlighted(tabIndex)) {
g.setColor(TAB_HIGHLIGHT_FOREGROUND_COLOR);
} else g.setColor(tabPane.getForegroundAt(tabIndex));
}
BasicGraphicsUtils.drawString(
g, title, mnemIndex, textRect.x, textRect.y + metrics.getAscent());
} else { // tab disabled
g.setColor(tabPane.getBackgroundAt(tabIndex).brighter());
BasicGraphicsUtils.drawStringUnderlineCharAt(
g, title, mnemIndex, textRect.x, textRect.y + metrics.getAscent());
g.setColor(tabPane.getBackgroundAt(tabIndex).darker());
BasicGraphicsUtils.drawStringUnderlineCharAt(
g, title, mnemIndex, textRect.x - 1, textRect.y + metrics.getAscent() - 1);
}
}
}
public void setRGeom(int x1, int y1, int x2, int y2) {
rect.x = Math.min(x1, x2) - offset.x;
rect.y = Math.min(y1, y2) - offset.y;
rect.width = Math.abs(x2 - x1);
rect.height = Math.abs(y2 - y1);
}
