/*
* sets the colormap to Rainbow
*/
private void setColorModelRainbow() {
// Copy in the default colors
for (int i = 0; i < tableSize; i++) {
cm_red[i] = puke_red[i];
cm_green[i] = puke_green[i];
cm_blue[i] = puke_blue[i];
}
// Set rainbow for attribute colors
float maxHue = 0.8f;
float hue = 0;
float delta = maxHue / attrSize;
int rainbowColor;
for (int i = startColor; i <= endColor; ++i, hue += delta) {
rainbowColor = Color.HSBtoRGB(hue, 1.0f, 1.0f);
cm_red[i] = (byte) ((rainbowColor >> 16) & 0xff);
cm_green[i] = (byte) ((rainbowColor >> 8) & 0xff);
cm_blue[i] = (byte) ((rainbowColor >> 0) & 0xff);
}
colorModel = new IndexColorModel(8, tableSize, cm_red, cm_green, cm_blue);
}
/**
* Esta funcion se usa para inicializar los colores del tema segun los argumentos que se le pasen.
*/
static NimRODTheme iniCustomColors(
NimRODTheme nt,
String selection,
String background,
String p1,
String p2,
String p3,
String s1,
String s2,
String s3,
String w,
String b,
String opMenu,
String opFrame) {
if (selection != null) {
nt.setPrimary(Color.decode(selection));
}
if (background != null) {
nt.setSecondary(Color.decode(background));
}
if (p1 != null) {
nt.setPrimary1(Color.decode(p1));
}
if (p2 != null) {
nt.setPrimary2(Color.decode(p2));
}
if (p3 != null) {
nt.setPrimary3(Color.decode(p3));
}
if (s1 != null) {
nt.setSecondary1(Color.decode(s1));
}
if (s2 != null) {
nt.setSecondary2(Color.decode(s2));
}
if (s3 != null) {
nt.setSecondary3(Color.decode(s3));
}
if (w != null) {
nt.setWhite(Color.decode(w));
}
if (b != null) {
nt.setBlack(Color.decode(b));
}
if (opMenu != null) {
nt.setMenuOpacity(Integer.parseInt(opMenu));
}
if (opFrame != null) {
nt.setFrameOpacity(Integer.parseInt(opFrame));
}
return nt;
}
/**
* Turn a (possibly) translucent or indexed image into a display-compatible bitmask image using
* the given alpha threshold and render-to-background colour, or display-compatible translucent
* image. The alpha values in the image are set to either 0 (below threshold) or 255 (above
* threshold). The render-to-background colour bg_col is used to determine how the pixels
* overlapping transparent pixels should be rendered. The fast algorithm just sets the colour
* behind the transparent pixels in the image (for bitmask source images); the slow algorithm
* actually renders the image to a background of bg_col (for translucent sources).
*
* @param thresh alpha threshold between 0 and 255
* @param fast use fast algorithm (only set bg_col behind transp. pixels)
* @param bitmask true=use bitmask, false=use translucent
*/
public JGImage toDisplayCompatible(int thresh, JGColor bg_col, boolean fast, boolean bitmask) {
Color bgcol = new Color(bg_col.r, bg_col.g, bg_col.b);
int bgcol_rgb = (bgcol.getRed() << 16) | (bgcol.getGreen() << 8) | bgcol.getBlue();
JGPoint size = getSize();
int[] buffer = getPixels();
// render image to bg depending on bgcol
BufferedImage img_bg;
if (bitmask) {
img_bg = createCompatibleImage(size.x, size.y, Transparency.BITMASK);
} else {
img_bg = createCompatibleImage(size.x, size.y, Transparency.TRANSLUCENT);
}
int[] bg_buf;
if (!fast) {
Graphics g = img_bg.getGraphics();
g.setColor(bgcol);
// the docs say I could use bgcol in the drawImage as an
// equivalent to the following two lines, but this
// doesn't handle translucency properly and is _slower_
g.fillRect(0, 0, size.x, size.y);
g.drawImage(img, 0, 0, null);
bg_buf = new JREImage(img_bg).getPixels();
} else {
bg_buf = buffer;
}
// g.dispose();
// ColorModel rgb_bitmask = ColorModel.getRGBdefault();
// rgb_bitmask = new PackedColorModel(
// rgb_bitmask.getColorSpace(),25,0xff0000,0x00ff00,0x0000ff,
// 0x1000000, false, Transparency.BITMASK, DataBuffer.TYPE_INT);
// ColorSpace space, int bits, int rmask, int gmask, int bmask, int amask, boolean
// isAlphaPremultiplied, int trans, int transferType)
int[] thrsbuf = new int[size.x * size.y];
for (int y = 0; y < size.y; y++) {
for (int x = 0; x < size.x; x++) {
if (((buffer[y * size.x + x] >> 24) & 0xff) >= thresh) {
thrsbuf[y * size.x + x] = bg_buf[y * size.x + x] | (0xff << 24);
} else {
// explicitly set the colour of the transparent pixel.
// This makes a difference when scaling!
// thrsbuf[y*size.x+x]=bg_buf[y*size.x+x]&~(0xff<<24);
thrsbuf[y * size.x + x] = bgcol_rgb;
}
}
}
return new JREImage(
output_comp.createImage(
new MemoryImageSource(
size.x,
size.y,
// rgb_bitmask,
img_bg.getColorModel(), // display compatible bitmask
bitmask ? thrsbuf : bg_buf,
0,
size.x)));
}
/**
* Sets the selected color of this panel.
*
* <p>If this panel is in RED, GREEN, or BLUE mode, then this method converts these values to RGB
* coordinates and calls <code>setRGB</code>.
*
* <p>This method may regenerate the graphic if necessary.
*
* @param h the hue value of the selected color.
* @param s the saturation value of the selected color.
* @param b the brightness value of the selected color.
*/
public void setHSB(float h, float s, float b) {
if (Float.isInfinite(h) || Float.isNaN(h))
throw new IllegalArgumentException("The hue value (" + h + ") is not a valid number.");
// hue is cyclic, so it can be any value:
while (h < 0) h++;
while (h > 1) h--;
if (s < 0 || s > 1)
throw new IllegalArgumentException("The saturation value (" + s + ") must be between [0,1]");
if (b < 0 || b > 1)
throw new IllegalArgumentException("The brightness value (" + b + ") must be between [0,1]");
if (hue != h || sat != s || bri != b) {
if (mode == ColorPicker.HUE || mode == ColorPicker.BRI || mode == ColorPicker.SAT) {
float lastHue = hue;
float lastBri = bri;
float lastSat = sat;
hue = h;
sat = s;
bri = b;
if (mode == ColorPicker.HUE) {
if (lastHue != hue) {
regenerateImage();
}
} else if (mode == ColorPicker.SAT) {
if (lastSat != sat) {
regenerateImage();
}
} else if (mode == ColorPicker.BRI) {
if (lastBri != bri) {
regenerateImage();
}
}
} else {
Color c = new Color(Color.HSBtoRGB(h, s, b));
setRGB(c.getRed(), c.getGreen(), c.getBlue());
return;
}
Color c = new Color(Color.HSBtoRGB(hue, sat, bri));
red = c.getRed();
green = c.getGreen();
blue = c.getBlue();
regeneratePoint();
repaint();
fireChangeListeners();
}
}
public void overlay() {
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
// System.out.println(nonMax.getRGB(x,y));
if (nonMax.getRGB(x, y) != -1) {
int rgb = img.getRGB(x, y);
Color color = new Color(rgb);
Color res = new Color(255, color.getGreen(), color.getBlue());
img.setRGB(x, y, res.getRGB());
}
}
}
ImageIcon icon1 = new ImageIcon(img);
lbl1.setIcon(icon1);
}
/**
* Draw character in minimap
*
* @param g Graphics
* @param Dx X Displacement
* @param Dy Y Displacement
*/
public void MapDraw(Graphics g, int Dx, int Dy, double Scale, Color col) {
// Color
g.setColor(col.darker().darker().darker());
g.drawOval((int) (X * Scale + Dx), (int) (Y * Scale + Dy), 7, 7);
g.setColor(col);
g.fillOval((int) (X * Scale + Dx), (int) (Y * Scale + Dy), 7, 7);
}
/**
* Makes the Mandelbrot image.
*
* @param width the width
* @parah height the height
* @return the image
*/
public BufferedImage makeMandelbrot(int width, int height) {
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
WritableRaster raster = image.getRaster();
ColorModel model = image.getColorModel();
Color fractalColor = Color.red;
int argb = fractalColor.getRGB();
Object colorData = model.getDataElements(argb, null);
for (int i = 0; i < width; i++)
for (int j = 0; j < height; j++) {
double a = XMIN + i * (XMAX - XMIN) / width;
double b = YMIN + j * (YMAX - YMIN) / height;
if (!escapesToInfinity(a, b)) raster.setDataElements(i, j, colorData);
}
return image;
}
/**
* 指定した属性でJDGradientPaintを構築します.
*
* @param p1 ユーザー空間で最初に指定されたPoint<br>
* p2 ユーザー空間で2番目に指定されたPoint<br>
* ; c1 ポイントp1のカラー<br>
* c2 ポイントp2のカラー<br>
* cp p1からp2間の制御点 cols 制御点のカラー gTyp 塗りのタイプ
*/
public JDGradientPaint(
Point2D p1, Point2D p2, Color c1, Color c2, float[] cp, Color[] cols, int gType) {
this.p1 = p1;
this.p2 = p2;
this.c1 = c1;
this.c2 = c2;
this.controlPoints = cp;
this.colors = cols;
this.gType = gType;
dx = (float) (p2.getX() - p1.getX());
dy = (float) (p2.getY() - p1.getY());
distance = (float) Math.sqrt(dx * dx + dy * dy);
startC = new float[4];
endC = new float[4];
startC = c1.getComponents(startC);
endC = c2.getComponents(endC);
}
protected void setDrawingColor(int ox, int oy, boolean setBackground) {
// IJ.log("setDrawingColor: "+setBackground+this);
int type = imp.getType();
int[] v = imp.getPixel(ox, oy);
switch (type) {
case ImagePlus.GRAY8:
{
if (setBackground) setBackgroundColor(getColor(v[0]));
else setForegroundColor(getColor(v[0]));
break;
}
case ImagePlus.GRAY16:
case ImagePlus.GRAY32:
{
double min = imp.getProcessor().getMin();
double max = imp.getProcessor().getMax();
double value = (type == ImagePlus.GRAY32) ? Float.intBitsToFloat(v[0]) : v[0];
int index = (int) (255.0 * ((value - min) / (max - min)));
if (index < 0) index = 0;
if (index > 255) index = 255;
if (setBackground) setBackgroundColor(getColor(index));
else setForegroundColor(getColor(index));
break;
}
case ImagePlus.COLOR_RGB:
case ImagePlus.COLOR_256:
{
Color c = new Color(v[0], v[1], v[2]);
if (setBackground) setBackgroundColor(c);
else setForegroundColor(c);
break;
}
}
Color c;
if (setBackground) c = Toolbar.getBackgroundColor();
else {
c = Toolbar.getForegroundColor();
imp.setColor(c);
}
IJ.showStatus("(" + c.getRed() + ", " + c.getGreen() + ", " + c.getBlue() + ")");
}
public static IndexColorModel createModelFromColor(Color color) {
byte[] rLut = new byte[256];
byte[] gLut = new byte[256];
byte[] bLut = new byte[256];
int red = color.getRed();
int green = color.getGreen();
int blue = color.getBlue();
double rIncr = ((double) red) / 255d;
double gIncr = ((double) green) / 255d;
double bIncr = ((double) blue) / 255d;
for (int i = 0; i < 256; ++i) {
rLut[i] = (byte) (i * rIncr);
gLut[i] = (byte) (i * gIncr);
bLut[i] = (byte) (i * bIncr);
}
return new IndexColorModel(8, 256, rLut, gLut, bLut);
}
public static void main(String[] args) {
int x = 500, y = 80;
DrawingKit dk = new DrawingKit("Daffodils", 800, 800);
BufferedImage pict = dk.loadPicture("daffodils.jpg");
// get pixel value at location (500, 80)
int encodedPixelColor = pict.getRGB(x, y);
Color pixelColor = new Color(encodedPixelColor);
System.out.println(pixelColor);
int red = pixelColor.getRed();
int green = pixelColor.getGreen();
int blue = pixelColor.getBlue();
// change the color of the pixel to be pure red
red = 255;
green = 0;
blue = 0;
// update the pixel color in picture
Color newPixelColor = new Color(red, green, blue);
int newRgbvalue = newPixelColor.getRGB();
pict.setRGB(x, y, newRgbvalue);
// display the approximate location of the pixel
dk.drawPicture(pict, 0, 0);
BasicStroke s = new BasicStroke(3);
dk.setStroke(s);
Ellipse2D.Float e = new Ellipse2D.Float(x - 3, y - 3, 8, 8);
dk.draw(e);
dk.drawString("(600, 150)", x - 3, y - 5);
}
/** Returns index of palette color closest to c */
protected int findClosest(Color c) {
if (colorTab == null) return -1;
int r = c.getRed();
int g = c.getGreen();
int b = c.getBlue();
int minpos = 0;
int dmin = 256 * 256 * 256;
int len = colorTab.length;
for (int i = 0; i < len; ) {
int dr = r - (colorTab[i++] & 0xff);
int dg = g - (colorTab[i++] & 0xff);
int db = b - (colorTab[i] & 0xff);
int d = dr * dr + dg * dg + db * db;
int index = i / 3;
if (usedEntry[index] && (d < dmin)) {
dmin = d;
minpos = index;
}
i++;
}
return minpos;
}
public void drawTileNumC(int tileNum, int x, int y, Color c, Graphics g) {
BufferedImage coloredTile = tiles[tileNum];
for (int i = 0; i < this.tW; i++) {
for (int j = 0; j < this.tH; j++) {
Color originalColor = new Color(coloredTile.getRGB(i, j), true);
Color nc = new Color(c.getRed(), c.getGreen(), c.getBlue(), originalColor.getAlpha());
coloredTile.setRGB(i, j, nc.getRGB());
}
}
g.drawImage(tiles[tileNum], x, y, null);
}
public void actionMouseClicked(InputEventInfo event) {
if (event.getAction() == InputEventInfo.ACTION_PRESSED) {
super.onMouseDown();
} else if (event.getAction() == InputEventInfo.ACTION_RELEASED && isPressed) {
// Networking.send(CalicoPacket.getPacket(NetworkCommand.CANVAS_REDO, cuid));
Calico.logger.debug("Pressed Color button " + color.toString());
CalicoDataStore.PenColor = color;
CalicoDataStore.LastDrawingColor = color;
if (CalicoDataStore.Mode != CInputMode.ARROW) CalicoDataStore.set_Mode(CInputMode.EXPERT);
CCanvasController.redrawMenuBars();
isPressed = false;
}
}
public static java.awt.Image ApplyAlphaMask(java.awt.Image original, java.awt.Image alphamask) {
int width = original.getWidth(null), height = original.getHeight(null);
if (width <= 0) width = 1;
if (height <= 0) height = 1;
BufferedImage resultImg = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
BufferedImage image = toBufferedImage(original);
BufferedImage mask = toBufferedImage(alphamask);
for (int y = 0; y < image.getHeight(null); y++) {
for (int x = 0; x < image.getWidth(null); x++) {
try {
Color c = new Color(image.getRGB(x, y));
Color maskC = new Color(mask.getRGB(x, y));
Color maskedColor = new Color(c.getRed(), c.getGreen(), c.getBlue(), maskC.getRed());
resultImg.setRGB(x, y, maskedColor.getRGB());
} catch (Exception e) {
}
}
}
return toImage(resultImg);
}
/**
* Esta funcion se usa para pintar la barra de seleccion de los menus. Esta aqui para no repetirla
* en todas partes...
*/
static void pintaBarraMenu(Graphics g, JMenuItem menuItem, Color bgColor) {
ButtonModel model = menuItem.getModel();
Color oldColor = g.getColor();
int menuWidth = menuItem.getWidth();
int menuHeight = menuItem.getHeight();
if (menuItem.isOpaque()) {
g.setColor(menuItem.getBackground());
g.fillRect(0, 0, menuWidth, menuHeight);
}
if ((menuItem instanceof JMenu && !(((JMenu) menuItem).isTopLevelMenu()) && model.isSelected())
|| model.isArmed()) {
RoundRectangle2D.Float boton = new RoundRectangle2D.Float();
boton.x = 1;
boton.y = 0;
boton.width = menuWidth - 3;
boton.height = menuHeight - 1;
boton.arcwidth = 8;
boton.archeight = 8;
GradientPaint grad = new GradientPaint(1, 1, getBrilloMenu(), 0, menuHeight, getSombraMenu());
Graphics2D g2D = (Graphics2D) g;
g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g.setColor(bgColor);
g2D.fill(boton);
g.setColor(bgColor.darker());
g2D.draw(boton);
g2D.setPaint(grad);
g2D.fill(boton);
g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_DEFAULT);
}
g.setColor(oldColor);
}
/**
* Sets the selected color of this panel.
*
* <p>If this panel is in HUE, SAT, or BRI mode, then this method converts these values to HSB
* coordinates and calls <code>setHSB</code>.
*
* <p>This method may regenerate the graphic if necessary.
*
* @param r the red value of the selected color.
* @param g the green value of the selected color.
* @param b the blue value of the selected color.
*/
public void setRGB(int r, int g, int b) {
if (r < 0 || r > 255)
throw new IllegalArgumentException("The red value (" + r + ") must be between [0,255].");
if (g < 0 || g > 255)
throw new IllegalArgumentException("The green value (" + g + ") must be between [0,255].");
if (b < 0 || b > 255)
throw new IllegalArgumentException("The blue value (" + b + ") must be between [0,255].");
if (red != r || green != g || blue != b) {
if (mode == ColorPicker.RED || mode == ColorPicker.GREEN || mode == ColorPicker.BLUE) {
int lastR = red;
int lastG = green;
int lastB = blue;
red = r;
green = g;
blue = b;
if (mode == ColorPicker.RED) {
if (lastR != r) {
regenerateImage();
}
} else if (mode == ColorPicker.GREEN) {
if (lastG != g) {
regenerateImage();
}
} else if (mode == ColorPicker.BLUE) {
if (lastB != b) {
regenerateImage();
}
}
} else {
float[] hsb = new float[3];
Color.RGBtoHSB(r, g, b, hsb);
setHSB(hsb[0], hsb[1], hsb[2]);
return;
}
regeneratePoint();
repaint();
fireChangeListeners();
}
}
static void fillRect(
final Graphics g,
final Component c,
final Color color,
final int x,
final int y,
final int w,
final int h) {
if (!(g instanceof Graphics2D)) {
return;
}
final Graphics2D cg = (Graphics2D) g.create();
try {
if (color instanceof UIResource && isWindowTextured(c) && color.equals(SystemColor.window)) {
cg.setComposite(AlphaComposite.Src);
cg.setColor(resetAlpha(color));
} else {
cg.setColor(color);
}
cg.fillRect(x, y, w, h);
} finally {
cg.dispose();
}
}
void initGraphics(Graphics g, Color textColor, Color defaultColor) {
if (smallFont == null) {
smallFont = new Font("SansSerif", Font.PLAIN, 9);
largeFont = new Font("SansSerif", Font.PLAIN, 12);
}
if (textColor != null) {
labelColor = textColor;
if (overlay != null && overlay.getDrawBackgrounds())
bgColor =
new Color(
255 - labelColor.getRed(), 255 - labelColor.getGreen(), 255 - labelColor.getBlue());
else bgColor = null;
} else {
int red = defaultColor.getRed();
int green = defaultColor.getGreen();
int blue = defaultColor.getBlue();
if ((red + green + blue) / 3 < 128) labelColor = Color.white;
else labelColor = Color.black;
bgColor = defaultColor;
}
this.defaultColor = defaultColor;
g.setColor(defaultColor);
}
public int getColorComp(Color c) {
float[] compArray = new float[4];
c.getColorComponents(compArray);
return (int) (compArray[mode.ordinal()] * 255);
}
private BufferedImage figureOutDrawImage(Sprite[] imgs) {
Sprite img;
if (dead) {
return imgs[5].getBuffer();
}
if (Math.abs((int) (vel.y * 100)) > 0 && !piped) {
img = imgs[1];
} else if (!(movingRight || movingLeft) && vel.x == 0) img = imgs[0];
else {
if (movingRight && vel.x < 0 || movingLeft && vel.x > 0) img = imgs[4];
else {
if (rightFoot) img = imgs[3];
else img = imgs[2];
}
}
if (star && (starTime < 8000 / 15 || System.currentTimeMillis() % 60 > 30)) {
int width = img.getBuffer().getWidth(), height = img.getBuffer().getHeight();
Sprite limg = new Sprite(img.getBuffer());
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
Color pixel = limg.getPixel(x, y);
if (pixel.getAlpha() != 0) {
limg.setPixel(
x,
y,
new Color(
255 - pixel.getRed(),
255 - pixel.getGreen(),
255 - pixel.getBlue(),
pixel.getAlpha()));
}
}
}
img = limg;
} else if (metal) {
int width = img.getBuffer().getWidth(), height = img.getBuffer().getHeight();
Sprite limg = new Sprite(img.getBuffer());
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
Color pixel = limg.getPixel(x, y);
if (pixel.getAlpha() != 0) {
int gray = (pixel.getRed() + pixel.getBlue() + pixel.getGreen()) / 3;
limg.setPixel(x, y, new Color(gray, gray, gray, pixel.getAlpha()));
}
}
}
img = limg;
}
if (facingRight) {
return img.flipX();
} else {
return img.getBuffer();
}
}
public BufferedImage getBufferedImage(int type, Color c) {
BufferedImage image = null;
float[] colComp = new float[3];
c.getRGBColorComponents(colComp);
double red = (double) colComp[0];
double green = (double) colComp[1];
double blue = (double) colComp[2];
// System.out.println("blue, green, red = "+ blue +", " + green + ", " + red);
double x = 0.0;
double x2;
switch (type) {
case ScalarImage.TYPE_BYTE_RANDOM:
{
int numCol = 256;
byte[] bBuf = new byte[numCol * 3];
blue *= 255 * 4.;
green *= 255 * 4.;
red *= 255 * 4.;
double delta = 1.0 / (double) (numCol + 1);
int j = 0;
for (int i = 0; i < numCol; i++) {
if (i % 5 == 0) x = 0.7 * Math.random() + 0.3 * x;
x2 = x * x;
bBuf[j++] = (byte) clamp((510 - red) * x2 + (red - 255) * x);
bBuf[j++] = (byte) clamp((510 - green) * x2 + (green - 255) * x);
bBuf[j++] = (byte) clamp((510 - blue) * x2 + (blue - 255) * x);
// x += delta;
}
IndexColorModel cm = new IndexColorModel(8, numCol, bBuf, 0, false);
// image = new
// BufferedImage(width,height,BufferedImage.TYPE_BYTE_INDEXED,cm);
byte[] idxBuffer = new byte[size];
for (int i = 0; i < size; i++) {
idxBuffer[i] = (byte) (clamp(f[i] * 255.));
}
DataBufferByte dataBuffer = new DataBufferByte(idxBuffer, size);
int idxOffset[] = {0};
int idxBits[] = {8};
try {
ComponentSampleModel idxSampleModel =
new ComponentSampleModel(DataBuffer.TYPE_BYTE, width, height, 1, width, idxOffset);
WritableRaster rasterIdx =
java.awt.image.Raster.createWritableRaster(
idxSampleModel, dataBuffer, new Point(0, 0));
image = new BufferedImage(cm, rasterIdx, false, null);
} catch (Exception e) {
System.out.println("Exception caught while acquiring image:");
System.out.println(e.getMessage());
}
}
break;
case BufferedImage.TYPE_BYTE_INDEXED:
{
int numCol = 256;
byte[] bBuf = new byte[numCol * 3];
blue *= 255 * 4.;
green *= 255 * 4.;
red *= 255 * 4.;
double delta = 1.0 / (double) (numCol + 1);
int j = 0;
for (int i = 0; i < numCol; i++) {
x2 = x * x;
bBuf[j++] = (byte) clamp((510 - red) * x2 + (red - 255) * x);
bBuf[j++] = (byte) clamp((510 - green) * x2 + (green - 255) * x);
bBuf[j++] = (byte) clamp((510 - blue) * x2 + (blue - 255) * x);
x += delta;
}
IndexColorModel cm = new IndexColorModel(8, numCol, bBuf, 0, false);
// image = new
// BufferedImage(width,height,BufferedImage.TYPE_BYTE_INDEXED,cm);
byte[] idxBuffer = new byte[size];
for (int i = 0; i < size; i++) {
idxBuffer[i] = (byte) (clamp(f[i] * 255.));
}
DataBufferByte dataBuffer = new DataBufferByte(idxBuffer, size);
int idxOffset[] = {0};
int idxBits[] = {8};
try {
ComponentSampleModel idxSampleModel =
new ComponentSampleModel(DataBuffer.TYPE_BYTE, width, height, 1, width, idxOffset);
WritableRaster rasterIdx =
java.awt.image.Raster.createWritableRaster(
idxSampleModel, dataBuffer, new Point(0, 0));
image = new BufferedImage(cm, rasterIdx, false, null);
} catch (Exception e) {
System.out.println("Exception caught while acquiring image:");
System.out.println(e.getMessage());
}
}
break;
case BufferedImage.TYPE_BYTE_GRAY:
break;
case BufferedImage.TYPE_3BYTE_BGR:
default:
byte[] byteBuffer = new byte[size * 3];
blue *= 255 * 4.;
green *= 255 * 4.;
red *= 255 * 4.;
int j = 0;
for (int i = 0; i < size; i++) {
x = f[i];
x2 = x * x;
/*
byteBuffer[j++] = (byte)clamp( ( 2 * 255 - 4 * red ) * x * x + ( 4 * red - 255 ) * x);
byteBuffer[j++] = (byte)clamp( ( 2 * 255 - 4 * green ) * x * x + ( 4 * green - 255 ) * x);
byteBuffer[j++] = (byte)clamp( ( 2 * 255 - 4 * blue ) * x * x + ( 4 * blue - 255 ) * x);
*/
byteBuffer[j++] = (byte) clamp((510 - red) * x2 + (red - 255) * x);
byteBuffer[j++] = (byte) clamp((510 - green) * x2 + (green - 255) * x);
byteBuffer[j++] = (byte) clamp((510 - blue) * x2 + (blue - 255) * x);
}
DataBufferByte dataBuffer = new DataBufferByte(byteBuffer, size * 3);
int componentOffset[] = {0, 1, 2};
int componentBits[] = {8, 8, 8};
try {
WritableRaster raster =
java.awt.image.Raster.createWritableRaster(
new PixelInterleavedSampleModel(
DataBuffer.TYPE_BYTE, width, height, 3, width * 3, componentOffset),
dataBuffer,
new Point(0, 0));
image =
new BufferedImage(
new ComponentColorModel(
ColorSpace.getInstance(ColorSpace.CS_LINEAR_RGB),
componentBits,
false,
false,
ColorModel.OPAQUE,
DataBuffer.TYPE_BYTE),
raster,
false,
null);
} catch (Exception e) {
System.out.println("Exception caught while acquiring image:");
System.out.println(e.getMessage());
}
break;
}
return image;
}
ImageProcessor setup(ImagePlus imp) {
ImageProcessor ip;
int type = imp.getType();
if (type != ImagePlus.COLOR_RGB) return null;
ip = imp.getProcessor();
int id = imp.getID();
int slice = imp.getCurrentSlice();
if ((id != previousImageID) | (slice != previousSlice) | (flag)) {
flag = false; // if true, flags a change from HSB to RGB or viceversa
numSlices = imp.getStackSize();
stack = imp.getStack();
width = stack.getWidth();
height = stack.getHeight();
numPixels = width * height;
hSource = new byte[numPixels];
sSource = new byte[numPixels];
bSource = new byte[numPixels];
// restore = (int[])ip.getPixelsCopy(); //This runs into trouble sometimes, so do it the
// long way:
int[] temp = (int[]) ip.getPixels();
restore = new int[numPixels];
for (int i = 0; i < numPixels; i++) restore[i] = temp[i];
fillMask = new int[numPixels];
// Get hsb or rgb from image.
ColorProcessor cp = (ColorProcessor) ip;
IJ.showStatus("Gathering data");
if (isRGB) cp.getRGB(hSource, sSource, bSource);
else cp.getHSB(hSource, sSource, bSource);
IJ.showStatus("done");
// Create a spectrum ColorModel for the Hue histogram plot.
Color c;
byte[] reds = new byte[256];
byte[] greens = new byte[256];
byte[] blues = new byte[256];
for (int i = 0; i < 256; i++) {
c = Color.getHSBColor(i / 255f, 1f, 1f);
reds[i] = (byte) c.getRed();
greens[i] = (byte) c.getGreen();
blues[i] = (byte) c.getBlue();
}
ColorModel cm = new IndexColorModel(8, 256, reds, greens, blues);
// Make an image with just the hue from the RGB image and the spectrum LUT.
// This is just for a hue histogram for the plot. Do not show it.
// ByteProcessor bpHue = new ByteProcessor(width,height,h,cm);
ByteProcessor bpHue = new ByteProcessor(width, height, hSource, cm);
ImagePlus impHue = new ImagePlus("Hue", bpHue);
// impHue.show();
ByteProcessor bpSat = new ByteProcessor(width, height, sSource, cm);
ImagePlus impSat = new ImagePlus("Sat", bpSat);
// impSat.show();
ByteProcessor bpBri = new ByteProcessor(width, height, bSource, cm);
ImagePlus impBri = new ImagePlus("Bri", bpBri);
// impBri.show();
plot.setHistogram(impHue, 0);
splot.setHistogram(impSat, 1);
bplot.setHistogram(impBri, 2);
updateLabels();
updatePlot();
updateScrollBars();
imp.updateAndDraw();
}
previousImageID = id;
previousSlice = slice;
return ip;
}
static ColorUIResource getColorTercio(Color a, Color b) {
return new ColorUIResource(
propInt(a.getRed(), b.getRed(), 3),
propInt(a.getGreen(), b.getGreen(), 3),
propInt(a.getBlue(), b.getBlue(), 3));
}
static Color getColorMedio(Color a, Color b) {
return new Color(
propInt(a.getRed(), b.getRed(), 2),
propInt(a.getGreen(), b.getGreen(), 2),
propInt(a.getBlue(), b.getBlue(), 2));
}
static Color getColorAlfa(Color col, int alfa) {
return new Color(col.getRed(), col.getGreen(), col.getBlue(), alfa);
}
public int getTransparency() {
int a1 = c1.getAlpha();
int a2 = c2.getAlpha();
return (((a1 & a2) == 0xff) ? OPAQUE : TRANSLUCENT);
}
public String toString() {
return objColour.toString();
}
public GroundTexture(int size, Ground grnd) {
System.out.println("Calculating Ground Texture...");
img = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB);
double r, g, b;
Random rnd = new Random();
System.out.print("Initializing...");
for (int x = 0; x < size; x++) {
for (int y = 0; y < size; y++) {
double slope = 0;
for (int nx = x - 1; nx < x + 1; nx++)
for (int ny = y - 1; ny < y + 1; ny++)
if ((nx >= 0) && (nx < size))
if ((ny >= 0) && (ny < size)) slope += Math.abs(grnd.topo[nx][ny] - grnd.topo[x][y]);
if (slope < 1) slope = 1;
g = 5d + 80d / (grnd.topo[x][y] / 2000d + 1d) + rnd.nextDouble() * 30d / (slope);
r =
g
* (1.17
+ (-.3 + (rnd.nextDouble() * .3))
/ (grnd.topo[x][y] / 200d + 1d)
/ (slope / 5 + 1));
b =
r
* (.7
+ (-.3 + (rnd.nextDouble() * .2))
/ (grnd.topo[x][y] / 200d + 1d)
/ (slope / 5 + 1));
img.setRGB(x, y, colorRGB((int) r, (int) g, (int) b));
}
}
/**/
// save("bodentextur2","png");
System.out.print(" \rRandom Growth");
for (int i = 0; i < size * size * 8; i++) {
if (i % (size * size / 2) == 0) System.out.print(".");
int x = 3 + rnd.nextInt(size - 6);
int y = 3 + rnd.nextInt(size - 6);
int nx = x - 1 + rnd.nextInt(3);
int ny = y - 1 + rnd.nextInt(3);
while ((nx < 0) || (nx >= size) || (ny < 0) || (ny >= size)) {
nx = x - 1 + rnd.nextInt(3);
ny = y - 1 + rnd.nextInt(3);
}
Color dis = getColorAt(x, y);
Color col = getColorAt(nx, ny);
if (grnd.topo[nx][ny] >= 4.5)
if (col.getGreen() / col.getRed() > dis.getGreen() / dis.getRed())
if (Math.abs(grnd.topo[x][y] - grnd.topo[nx][ny]) < .65) {
int c = colorRGB(col.getRed(), col.getGreen(), col.getBlue());
// img.setRGB(x,y, colorRGB(col.getRed(), col.getGreen(), col.getBlue()));
// img.setRGB(x-1+rnd.nextInt(3),y-1+rnd.nextInt(3), colorRGB(col.getRed(),
// col.getGreen(), col.getBlue()));
for (nx = x - 1 - rnd.nextInt(3); nx < 1 + x + rnd.nextInt(3); nx++)
for (ny = y - 1 - rnd.nextInt(3); ny < y + 1 + rnd.nextInt(3); ny++) {
img.setRGB(nx, ny, c);
grnd.topo[nx][ny] += 1.8;
}
}
}
System.out.print(" \rAntialiasing...");
/* for (int x = 0; x < size; x++){
for (int y = 0; y < size; y++){
double sumr = 0;
double sumg = 0;
double sumb = 0;
double div = 0;
for (int nx=x-1;nx<x+1;nx++)
for (int ny=y-1;ny<y+1;ny++)
if ((nx>=0) && (nx < size)) if ((ny>=0) && (ny < size)) {
Color col = getColorAt(nx,ny);
sumr+=col.getRed();
sumg+=col.getGreen();
sumb+=col.getBlue();
div++;
}
r=sumr/div;
g=sumg/div;
b=sumb/div;
img.setRGB(x,y, colorRGB((int)r, (int)g, (int)b) );
}
}*/
System.out.print(" \r");
// save("bodentextur3","png");
save("bodentextur", "png");
}
/** Regenerates the image. */
private synchronized void regenerateImage() {
int size =
Math.min(
MAX_SIZE,
Math.min(
getWidth() - imagePadding.left - imagePadding.right,
getHeight() - imagePadding.top - imagePadding.bottom));
if (mode == ColorPicker.BRI || mode == ColorPicker.SAT) {
float bri2 = this.bri;
float sat2 = this.sat;
float radius = ((float) size) / 2f;
float hue2;
float k = 1.2f; // the number of pixels to antialias
for (int y = 0; y < size; y++) {
float y2 = (y - size / 2f);
for (int x = 0; x < size; x++) {
float x2 = (x - size / 2f);
double theta = Math.atan2(y2, x2) - 3 * Math.PI / 2.0;
if (theta < 0) theta += 2 * Math.PI;
double r = Math.sqrt(x2 * x2 + y2 * y2);
if (r <= radius) {
if (mode == ColorPicker.BRI) {
hue2 = (float) (theta / (2 * Math.PI));
sat2 = (float) (r / radius);
} else { // SAT
hue2 = (float) (theta / (2 * Math.PI));
bri2 = (float) (r / radius);
}
row[x] = Color.HSBtoRGB(hue2, sat2, bri2);
if (r > radius - k) {
int alpha = (int) (255 - 255 * (r - radius + k) / k);
if (alpha < 0) alpha = 0;
if (alpha > 255) alpha = 255;
row[x] = row[x] & 0xffffff + (alpha << 24);
}
} else {
row[x] = 0x00000000;
}
}
image.getRaster().setDataElements(0, y, size, 1, row);
}
} else if (mode == ColorPicker.HUE) {
float hue2 = this.hue;
for (int y = 0; y < size; y++) {
float y2 = ((float) y) / ((float) size);
for (int x = 0; x < size; x++) {
float x2 = ((float) x) / ((float) size);
row[x] = Color.HSBtoRGB(hue2, x2, y2);
}
image.getRaster().setDataElements(0, y, image.getWidth(), 1, row);
}
} else { // mode is RED, GREEN, or BLUE
int red2 = red;
int green2 = green;
int blue2 = blue;
for (int y = 0; y < size; y++) {
float y2 = ((float) y) / ((float) size);
for (int x = 0; x < size; x++) {
float x2 = ((float) x) / ((float) size);
if (mode == ColorPicker.RED) {
green2 = (int) (x2 * 255 + .49);
blue2 = (int) (y2 * 255 + .49);
} else if (mode == ColorPicker.GREEN) {
red2 = (int) (x2 * 255 + .49);
blue2 = (int) (y2 * 255 + .49);
} else {
red2 = (int) (x2 * 255 + .49);
green2 = (int) (y2 * 255 + .49);
}
row[x] = 0xFF000000 + (red2 << 16) + (green2 << 8) + blue2;
}
image.getRaster().setDataElements(0, y, size, 1, row);
}
}
repaint();
}
