1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
package ij.process;
import java.awt.*;
import java.awt.image.*;
import ij.*;
import ij.gui.*;
import ij.measure.*;
/** This class converts an ImagePlus object to a different type. */
public class ImageConverter {
private ImagePlus imp;
private int type;
//private static boolean doScaling = Prefs.getBoolean(Prefs.SCALE_CONVERSIONS,true);
private static boolean doScaling = true;
/** Constructs an ImageConverter based on an ImagePlus object. */
public ImageConverter(ImagePlus imp) {
this.imp = imp;
type = imp.getType();
}
/** Converts this ImagePlus to 8-bit grayscale. */
public synchronized void convertToGray8() {
if (imp.getStackSize()>1)
throw new IllegalArgumentException("Unsupported conversion");
ImageProcessor ip = imp.getProcessor();
if (type==ImagePlus.GRAY16 || type==ImagePlus.GRAY32) {
imp.setProcessor(null, ip.convertToByte(doScaling));
imp.setCalibration(imp.getCalibration()); //update calibration
} else if (type==ImagePlus.COLOR_RGB)
imp.setProcessor(null, ip.convertToByte(doScaling));
else if (ip.isPseudoColorLut()) {
boolean invertedLut = ip.isInvertedLut();
ip.setColorModel(LookUpTable.createGrayscaleColorModel(invertedLut));
imp.updateAndDraw();
} else {
ip = new ColorProcessor(imp.getImage());
imp.setProcessor(null, ip.convertToByte(doScaling));
}
ImageProcessor ip2 = imp.getProcessor();
if (Prefs.useInvertingLut && ip2 instanceof ByteProcessor && !ip2.isInvertedLut()&& !ip2.isColorLut()) {
ip2.invertLut();
ip2.invert();
}
}
/** Converts this ImagePlus to 16-bit grayscale. */
public void convertToGray16() {
if (type==ImagePlus.GRAY16)
return;
if (!(type==ImagePlus.GRAY8||type==ImagePlus.GRAY32||type==ImagePlus.COLOR_RGB))
throw new IllegalArgumentException("Unsupported conversion");
ImageProcessor ip = imp.getProcessor();
imp.trimProcessor();
imp.setProcessor(null, ip.convertToShort(doScaling));
imp.setCalibration(imp.getCalibration()); //update calibration
}
/** Converts this ImagePlus to 32-bit grayscale. */
public void convertToGray32() {
if (type==ImagePlus.GRAY32)
return;
if (!(type==ImagePlus.GRAY8||type==ImagePlus.GRAY16||type==ImagePlus.COLOR_RGB))
throw new IllegalArgumentException("Unsupported conversion");
ImageProcessor ip = imp.getProcessor();
imp.trimProcessor();
Calibration cal = imp.getCalibration();
imp.setProcessor(null, ip.convertToFloat());
imp.setCalibration(cal); //update calibration
}
/** Converts this ImagePlus to RGB. */
public void convertToRGB() {
ImageProcessor ip = imp.getProcessor();
imp.setProcessor(null, ip.convertToRGB());
imp.setCalibration(imp.getCalibration()); //update calibration
}
/** Converts an RGB image to an RGB (red, green and blue) stack. */
public void convertToRGBStack() {
if (type!=ImagePlus.COLOR_RGB)
throw new IllegalArgumentException("Image must be RGB");
//convert to RGB Stack
ColorProcessor cp;
if (imp.getType()==ImagePlus.COLOR_RGB)
cp = (ColorProcessor)imp.getProcessor();
else
cp = new ColorProcessor(imp.getImage());
int width = imp.getWidth();
int height = imp.getHeight();
byte[] R = new byte[width*height];
byte[] G = new byte[width*height];
byte[] B = new byte[width*height];
cp.getRGB(R, G, B);
imp.trimProcessor();
// Create stack and select Red channel
ColorModel cm = LookUpTable.createGrayscaleColorModel(false);
ImageStack stack = new ImageStack(width, height, cm);
stack.addSlice("Red", R);
stack.addSlice("Green", G);
stack.addSlice("Blue", B);
imp.setStack(null, stack);
imp.setDimensions(3, 1, 1);
if (imp.isComposite())
((CompositeImage)imp).setMode(CompositeImage.GRAYSCALE);
}
/** Converts an RGB image to a HSB (hue, saturation and brightness) stack. */
public void convertToHSB() {
if (type!=ImagePlus.COLOR_RGB)
throw new IllegalArgumentException("Image must be RGB");
//convert to hue, saturation and brightness
//IJ.showProgress(0.1);
ColorProcessor cp;
if (imp.getType()==ImagePlus.COLOR_RGB)
cp = (ColorProcessor)imp.getProcessor();
else
cp = new ColorProcessor(imp.getImage());
ImageStack stack = cp.getHSBStack();
imp.trimProcessor();
imp.setStack(null, stack);
imp.setDimensions(3, 1, 1);
//IJ.showProgress(1.0);
}
/** Converts a 2 or 3 slice 8-bit stack to RGB. */
public void convertRGBStackToRGB() {
int stackSize = imp.getStackSize();
if (stackSize<2 || stackSize>3 || type!=ImagePlus.GRAY8)
throw new IllegalArgumentException("2 or 3 slice 8-bit stack required");
int width = imp.getWidth();
int height = imp.getHeight();
ImageStack stack = imp.getStack();
byte[] R = (byte[])stack.getPixels(1);
byte[] G = (byte[])stack.getPixels(2);
byte[] B;
if (stackSize>2)
B = (byte[])stack.getPixels(3);
else
B = new byte[width*height];
imp.trimProcessor();
ColorProcessor cp = new ColorProcessor(width, height);
cp.setRGB(R, G, B);
if (imp.isInvertedLut())
cp.invert();
imp.setImage(cp.createImage());
imp.killStack();
}
/** Converts a 3-slice (hue, saturation, brightness) 8-bit stack to RGB. */
public void convertHSBToRGB() {
if (imp.getStackSize()!=3)
throw new IllegalArgumentException("3-slice 8-bit stack required");
ImageStack stack = imp.getStack();
byte[] H = (byte[])stack.getPixels(1);
byte[] S = (byte[])stack.getPixels(2);
byte[] B = (byte[])stack.getPixels(3);
int width = imp.getWidth();
int height = imp.getHeight();
imp.trimProcessor();
ColorProcessor cp = new ColorProcessor(width, height);
cp.setHSB(H, S, B);
imp.setImage(cp.createImage());
imp.killStack();
}
/** Converts an RGB image to 8-bits indexed color. 'nColors' must
be greater than 1 and less than or equal to 256. */
public void convertRGBtoIndexedColor(int nColors) {
if (type!=ImagePlus.COLOR_RGB)
throw new IllegalArgumentException("Image must be RGB");
if (nColors<2) nColors = 2;
if (nColors>256) nColors = 256;
// get RGB pixels
IJ.showProgress(0.1);
IJ.showStatus("Grabbing pixels");
int width = imp.getWidth();
int height = imp.getHeight();
ImageProcessor ip = imp.getProcessor();
ip.snapshot();
int[] pixels = (int[])ip.getPixels();
imp.trimProcessor();
// convert to 8-bits
long start = System.currentTimeMillis();
MedianCut mc = new MedianCut(pixels, width, height);
ImageProcessor ip2 = mc.convertToByte(nColors);
imp.setProcessor(null, ip2);
}
/** Set true to scale to 0-255 when converting short to byte or float
to byte and to 0-65535 when converting float to short. */
public static void setDoScaling(boolean scaleConversions) {
doScaling = scaleConversions;
IJ.register(ImageConverter.class);
}
/** Returns true if scaling is enabled. */
public static boolean getDoScaling() {
return doScaling;
}
}
|
