package ij.plugin.filter;
import ij.*;
import ij.gui.*;
import ij.process.*;
import ij.macro.*;
import java.awt.*;
/** This plugin implements ImageJ's Process/Math submenu. */
public class ImageMath implements ExtendedPlugInFilter, DialogListener {
public static final String MACRO_KEY = "math.macro";
private int flags = DOES_ALL|SUPPORTS_MASKING|KEEP_PREVIEW;
private String arg;
private ImagePlus imp;
private boolean canceled;
private double lower=-1.0, upper=-1.0;
private static double addValue = 25;
private static double mulValue = 1.25;
private static double minValue = 0;
private static double maxValue = 255;
private static final String defaultAndValue = "11110000";
private static String andValue = defaultAndValue;
private static final double defaultGammaValue = 0.5;
private static double gammaValue = defaultGammaValue;
private static String macro = Prefs.get(MACRO_KEY, "v=v+50*sin(d/10)");
private String macro2;
private PlugInFilterRunner pfr;
private GenericDialog gd;
public int setup(String arg, ImagePlus imp) {
this.arg = arg;
this.imp = imp;
IJ.register(ImageMath.class);
if (!arg.equals("macro") || Interpreter.getInstance()==null)
flags |= PARALLELIZE_STACKS;
return flags;
}
public void run(ImageProcessor ip) {
if (canceled)
return;
if (arg.equals("add")) {
ip.add(addValue);
} else if (arg.equals("sub")) {
ip.subtract(addValue);
} else if (arg.equals("mul")) {
ip.multiply(mulValue);
} else if (arg.equals("div")) {
if (mulValue==0.0&&imp.getBitDepth()!=32)
return;
else
ip.multiply(1.0/mulValue);
} else if (arg.equals("and")) {
try {
ip.and(Integer.parseInt(andValue,2));
} catch (NumberFormatException e) {
andValue = defaultAndValue;
IJ.error("Binary number required");
}
} else if (arg.equals("or")) {
try {
ip.or(Integer.parseInt(andValue,2));
} catch (NumberFormatException e) {
andValue = defaultAndValue;
IJ.error("Binary number required");
}
} else if (arg.equals("xor")) {
try {
ip.xor(Integer.parseInt(andValue,2));
} catch (NumberFormatException e) {
andValue = defaultAndValue;
IJ.error("Binary number required");
}
} else if (arg.equals("min")) {
ip.min(minValue);
if (!(ip instanceof ByteProcessor))
ip.resetMinAndMax();
} else if (arg.equals("max")) {
ip.max(maxValue);
if (!(ip instanceof ByteProcessor))
ip.resetMinAndMax();
} else if (arg.equals("gamma")) {
if (gammaValue<0.05 || gammaValue>5.0) {
if (!previewing() && !canceled) {
canceled = true;
IJ.error("Gamma must be between 0.05 and 5.0");
}
gammaValue = defaultGammaValue;
} else
ip.gamma(gammaValue);
} else if (arg.equals("set")) {
ip.set(addValue);
} else if (arg.equals("log")) {
ip.log();
} else if (arg.equals("exp")) {
ip.exp();
} else if (arg.equals("sqr")) {
ip.sqr();
} else if (arg.equals("sqrt")) {
ip.sqrt();
} else if (arg.equals("reciprocal")) {
if (!isFloat(ip))
return;
float[] pixels = (float[])ip.getPixels();
for (int i=0; i0 || (int)defaultValue!=defaultValue)
digits = Math.max(places, 1);
gd = new GenericDialog(title);
gd.addNumericField(prompt, defaultValue, digits, 8, null);
gd.addPreviewCheckbox(pfr);
gd.addDialogListener(this);
gd.showDialog();
}
void getBinaryValue (String title, String prompt, String defaultValue) {
gd = new GenericDialog(title);
gd.addStringField(prompt, defaultValue);
gd.addPreviewCheckbox(pfr);
gd.addDialogListener(this);
gd.showDialog();
}
void getGammaValue (double defaultValue) {
gd = new GenericDialog("Gamma");
gd.addSlider("Value:", 0.0, 5.0, defaultValue, 0.02);
gd.addPreviewCheckbox(pfr);
gd.addDialogListener(this);
gd.showDialog();
}
/** Set non-thresholded pixels in a float image to NaN. */
void setBackgroundToNaN(ImageProcessor ip) {
if (lower==-1.0 && upper==-1.0) {
lower = ip.getMinThreshold();
upper = ip.getMaxThreshold();
if (lower==ImageProcessor.NO_THRESHOLD || !(ip instanceof FloatProcessor)) {
String title = imp!=null?"\n\""+imp.getTitle()+"\"":"";
IJ.error("NaN Backround", "Thresholded 32-bit float image required:"+title);
canceled = true;
return;
}
}
float[] pixels = (float[])ip.getPixels();
int width = ip.getWidth();
int height = ip.getHeight();
double v;
for (int y=0; yupper)
pixels[y*width+x] = Float.NaN;
}
}
ip.resetMinAndMax();
return;
}
// first default: v = v+(sin(x/(w/25))+sin(y/(h/25)))*40
// a=round(a/10); if (a%2==0) v=0;
// cone: v=d
// translate: v=getPixel(x+10,y+10)
// flip vertically: v=getPixel(x,h-y-1)
// spiral: v=(sin(d/10+a*PI/180)+1)*128
// spiral on image: v=v+50*sin(a*PI/180+d/5)
// spiral rotation: a+=PI+d*PI/360; v=getPixel(d*cos(a)+w/2,d*sin(a)+h/2);
// v=sin(log(d)*8 + a) * sin(a*8)
// v=(a * 40.74 + d) % 32
// v=floor((a * 40.75 + 1) % 2)
// v=sin(x) * sin(y)
// v=cos(0.2*x) + sin(0.2*y)
private void applyMacro(ImageProcessor ip) {
if (macro2==null) return;
macro = macro2;
ip.setSliceNumber(pfr.getSliceNumber());
boolean showProgress = pfr.getSliceNumber()==1 && !Interpreter.isBatchMode();
applyMacro(ip, macro, showProgress);
if (pfr.getSliceNumber()==1)
ip.resetMinAndMax();
}
public static void applyMacro(ImageProcessor ip, String macro, boolean showProgress) {
if (!macro.contains("="))
macro = "v="+macro;
ImagePlus temp = WindowManager.getTempCurrentImage();
WindowManager.setTempCurrentImage(new ImagePlus("",ip));
int PCStart = 23;
Program pgm = (new Tokenizer()).tokenize(macro);
boolean hasX = pgm.hasWord("x");
boolean hasA = pgm.hasWord("a");
boolean hasD = pgm.hasWord("d");
boolean hasGetPixel = pgm.hasWord("getPixel");
int w = ip.getWidth();
int h = ip.getHeight();
int w2 = w/2;
int h2 = h/2;
String code =
"var v,x,y,z,w,h,d,a;\n"+
"function dummy() {}\n"+
macro+";\n"; // code starts at program counter location 'PCStart'
Interpreter interp = new Interpreter();
interp.run(code, null);
if (interp.wasError()) {
WindowManager.setTempCurrentImage(temp);
return;
}
Prefs.set(MACRO_KEY, macro);
interp.setVariable("w", w);
interp.setVariable("h", h);
interp.setVariable("z", ip.getSliceNumber()-1);
int bitDepth = ip.getBitDepth();
Rectangle r = ip.getRoi();
int inc = r.height/50;
if (inc<1) inc = 1;
double v;
int index, v2;
if (bitDepth==8) {
byte[] pixels1 = (byte[])ip.getPixels();
byte[] pixels2 = pixels1;
if (hasGetPixel)
pixels2 = new byte[w*h];
for (int y=r.y; y<(r.y+r.height); y++) {
if (showProgress && y%inc==0)
IJ.showProgress(y-r.y, r.height);
interp.setVariable("y", y);
for (int x=r.x; x<(r.x+r.width); x++) {
index = y*w+x;
v = pixels1[index]&255;
interp.setVariable("v", v);
if (hasX) interp.setVariable("x", x);
if (hasA) interp.setVariable("a", getA((h-y-1)-h2, x-w2));
if (hasD) interp.setVariable("d", getD(x-w2,y-h2));
interp.run(PCStart);
v2 = (int)interp.getVariable("v");
if (v2<0) v2 = 0;
if (v2>255) v2 = 255;
pixels2[index] = (byte)v2;
}
}
if (hasGetPixel) System.arraycopy(pixels2, 0, pixels1, 0, w*h);
} else if (bitDepth==24) {
int rgb, red, green, blue;
int[] pixels1 = (int[])ip.getPixels();
int[] pixels2 = pixels1;
if (hasGetPixel)
pixels2 = new int[w*h];
for (int y=r.y; y<(r.y+r.height); y++) {
if (showProgress && y%inc==0)
IJ.showProgress(y-r.y, r.height);
interp.setVariable("y", y);
for (int x=r.x; x<(r.x+r.width); x++) {
if (hasX) interp.setVariable("x", x);
if (hasA) interp.setVariable("a", getA((h-y-1)-h2, x-w2));
if (hasD) interp.setVariable("d", getD(x-w2,y-h2));
index = y*w+x;
rgb = pixels1[index];
if (hasGetPixel) {
interp.setVariable("v", rgb);
interp.run(PCStart);
rgb = (int)interp.getVariable("v");
} else {
red = (rgb&0xff0000)>>16;
green = (rgb&0xff00)>>8;
blue = rgb&0xff;
interp.setVariable("v", red);
interp.run(PCStart);
red = (int)interp.getVariable("v");
if (red<0) red=0; if (red>255) red=255;
interp.setVariable("v", green);
interp.run(PCStart);
green= (int)interp.getVariable("v");
if (green<0) green=0; if (green>255) green=255;
interp.setVariable("v", blue);
interp.run(PCStart);
blue = (int)interp.getVariable("v");
if (blue<0) blue=0; if (blue>255) blue=255;
rgb = 0xff000000 | ((red&0xff)<<16) | ((green&0xff)<<8) | blue&0xff;
}
pixels2[index] = rgb;
}
}
if (hasGetPixel) System.arraycopy(pixels2, 0, pixels1, 0, w*h);
} else if (ip.isSigned16Bit()) {
for (int y=r.y; y<(r.y+r.height); y++) {
if (showProgress && y%inc==0)
IJ.showProgress(y-r.y, r.height);
interp.setVariable("y", y);
for (int x=r.x; x<(r.x+r.width); x++) {
v = ip.getPixelValue(x, y);
interp.setVariable("v", v);
if (hasX) interp.setVariable("x", x);
if (hasA) interp.setVariable("a", getA((h-y-1)-h2, x-w2));
if (hasD) interp.setVariable("d", getD(x-w2,y-h2));
interp.run(PCStart);
ip.putPixelValue(x, y, interp.getVariable("v"));
}
}
} else if (bitDepth==16) {
short[] pixels1 = (short[])ip.getPixels();
short[] pixels2 = pixels1;
if (hasGetPixel)
pixels2 = new short[w*h];
for (int y=r.y; y<(r.y+r.height); y++) {
if (showProgress && y%inc==0)
IJ.showProgress(y-r.y, r.height);
interp.setVariable("y", y);
for (int x=r.x; x<(r.x+r.width); x++) {
index = y*w+x;
v = pixels1[index]&65535;
interp.setVariable("v", v);
if (hasX) interp.setVariable("x", x);
if (hasA) interp.setVariable("a", getA((h-y-1)-h2, x-w2));
if (hasD) interp.setVariable("d", getD(x-w2,y-h2));
interp.run(PCStart);
v2 = (int)interp.getVariable("v");
if (v2<0) v2 = 0;
if (v2>65535) v2 = 65535;
pixels2[index] = (short)v2;
}
}
if (hasGetPixel) System.arraycopy(pixels2, 0, pixels1, 0, w*h);
} else { //32-bit
float[] pixels1 = (float[])ip.getPixels();
float[] pixels2 = pixels1;
if (hasGetPixel)
pixels2 = new float[w*h];
for (int y=r.y; y<(r.y+r.height); y++) {
if (showProgress && y%inc==0)
IJ.showProgress(y-r.y, r.height);
interp.setVariable("y", y);
for (int x=r.x; x<(r.x+r.width); x++) {
index = y*w+x;
v = pixels1[index];
interp.setVariable("v", v);
if (hasX) interp.setVariable("x", x);
if (hasA) interp.setVariable("a", getA((h-y-1)-h2, x-w2));
if (hasD) interp.setVariable("d", getD(x-w2,y-h2));
interp.run(PCStart);
pixels2[index] = (float)interp.getVariable("v");
}
}
if (hasGetPixel) System.arraycopy(pixels2, 0, pixels1, 0, w*h);
}
if (showProgress)
IJ.showProgress(1.0);
WindowManager.setTempCurrentImage(temp);
}
private static final double getD(int dx, int dy) {
return Math.sqrt(dx*dx + dy*dy);
}
private static final double getA(int y, int x) {
double angle = Math.atan2(y, x);
if (angle<0) angle += 2*Math.PI;
return angle;
}
void getMacro(String macro) {
String options = Macro.getOptions();
if (options!=null && options.startsWith("v="))
Macro.setOptions("code="+options);
gd = new GenericDialog("Expression Evaluator");
gd.addStringField("Code:", macro, 42);
gd.setInsets(0,40,0);
gd.addMessage("v=pixel value, x,y&z=pixel coordinates, w=image width,\nh=image height, a=angle, d=distance from center\n");
gd.setInsets(5,40,0);
gd.addPreviewCheckbox(pfr);
gd.addDialogListener(this);
gd.addHelp(IJ.URL+"/docs/menus/process.html#math-macro");
gd.showDialog();
}
public int showDialog(ImagePlus imp, String command, PlugInFilterRunner pfr) {
this.pfr = pfr;
if (arg.equals("macro"))
getMacro(macro);
else if (arg.equals("add"))
getValue("Add", "Value: ", addValue, 0);
else if (arg.equals("sub"))
getValue("Subtract", "Value: ", addValue, 0);
else if (arg.equals("mul"))
getValue("Multiply", "Value: ", mulValue, 2);
else if (arg.equals("div"))
getValue("Divide", "Value: ", mulValue, 2);
else if (arg.equals("and"))
getBinaryValue("AND", "Value (binary): ", andValue);
else if (arg.equals("or"))
getBinaryValue("OR", "Value (binary): ", andValue);
else if (arg.equals("xor"))
getBinaryValue("XOR", "Value (binary): ", andValue);
else if (arg.equals("min"))
getValue("Min", "Value: ", minValue, 0);
else if (arg.equals("max"))
getValue("Max", "Value: ", maxValue, 0);
else if (arg.equals("gamma"))
getGammaValue(gammaValue);
else if (arg.equals("set")) {
boolean rgb = imp.getBitDepth()==24;
String prompt = rgb?"Value (0-255): ":"Value: ";
getValue("Set", prompt, addValue, 0);
}
if (gd!=null && gd.wasCanceled())
return DONE;
else
return IJ.setupDialog(imp, flags);
}
public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
if (arg.equals("macro")) {
String str = gd.getNextString();
if (previewing() && macro2!=null && !str.equals(macro2))
gd.getPreviewCheckbox().setState(false);
macro2 = str;
} else if (arg.equals("add")||arg.equals("sub")||arg.equals("set"))
addValue = gd.getNextNumber();
else if (arg.equals("mul")||arg.equals("div"))
mulValue = gd.getNextNumber();
else if (arg.equals("and")||arg.equals("or")||arg.equals("xor"))
andValue = gd.getNextString();
else if (arg.equals("min"))
minValue = gd.getNextNumber();
else if (arg.equals("max"))
maxValue = gd.getNextNumber();
else if (arg.equals("gamma")) {
gammaValue = gd.getNextNumber();
if (gammaValue<0.05 || gammaValue>5.0) {
if (previewing()) {
IJ.showStatus("Gamma must be between 0.05 and 5.0");
gammaValue = defaultGammaValue;
return false;
}
}
}
canceled = gd.invalidNumber();
if (gd.wasOKed() && canceled) {
IJ.error("Value is invalid.");
return false;
}
return true;
}
public void setNPasses(int nPasses) {
}
}
Ads help maintain this website.