public boolean prepareImage(FileSystem fs) throws Exception {
boolean result = false;
if (isImage()) {
if (data == null || !(data instanceof Image)) {
String fn = fileName.toLowerCase();
if (fn.endsWith(".bmp")) {
// Old edu.xtec.jclic.misc.Bmp replaced by image4j
// Bmp bmp=new Bmp(fs.getInputStream(fileName));
// setData(bmp.getImage());
BufferedImage img = BMPDecoder.read(fs.getInputStream(fileName));
setData(Toolkit.getDefaultToolkit().createImage(img.getSource()));
} else if (fn.endsWith(".ico")) {
java.util.List list = ICODecoder.read(fs.getInputStream(fileName));
int maxs = 0;
BufferedImage img = null;
int listSize = list.size();
for (int i = 0; i < listSize; i++) {
BufferedImage imgtmp = (BufferedImage) list.get(i);
int s = imgtmp.getWidth() * imgtmp.getHeight();
if (s >= maxs) {
img = imgtmp;
maxs = s;
}
}
if (img != null) setData(Toolkit.getDefaultToolkit().createImage(img.getSource()));
} else setData(fs.getImageFile(fileName));
}
result = true;
}
return result;
}
/**
* イメージを設定します。
*
* @param image イメージ
*/
public void setImage(BufferedImage image) {
this.image = image;
setSize(image.getWidth(), image.getHeight());
Toolkit tk = Toolkit.getDefaultToolkit();
ChromakeyImageFilter chromakey = new ChromakeyImageFilter(getBackground().getRGB());
img = tk.createImage(new FilteredImageSource(image.getSource(), chromakey));
}
/* (non-Javadoc)
* @see java.awt.image.BufferedImageOp#filter(java.awt.image.BufferedImage, java.awt.image.BufferedImage)
*/
public BufferedImage filter(BufferedImage src, BufferedImage dst) {
if (src == null) {
throw new NullPointerException("src image is null");
}
if (src == dst) {
throw new IllegalArgumentException("src image cannot be the " + "same as the dst image");
}
boolean needToConvert = false;
ColorModel srcCM = src.getColorModel();
ColorModel dstCM;
BufferedImage origDst = dst;
if (srcCM instanceof IndexColorModel) {
IndexColorModel icm = (IndexColorModel) srcCM;
src = icm.convertToIntDiscrete(src.getRaster(), false);
srcCM = src.getColorModel();
}
if (dst == null) {
dst = createCompatibleDestImage(src, null);
dstCM = srcCM;
origDst = dst;
} else {
dstCM = dst.getColorModel();
if (srcCM.getColorSpace().getType() != dstCM.getColorSpace().getType()) {
needToConvert = true;
dst = createCompatibleDestImage(src, null);
dstCM = dst.getColorModel();
} else if (dstCM instanceof IndexColorModel) {
dst = createCompatibleDestImage(src, null);
dstCM = dst.getColorModel();
}
}
java.awt.image.CropImageFilter cropfilter =
new java.awt.image.CropImageFilter(region.x, region.y, region.width, region.height);
Image returnImage =
Toolkit.getDefaultToolkit()
.createImage(new java.awt.image.FilteredImageSource(src.getSource(), cropfilter));
dst = ImageConverter.convertImage(returnImage);
origDst = dst;
if (needToConvert) {
ColorConvertOp ccop = new ColorConvertOp(hints);
ccop.filter(dst, origDst);
} else if (origDst != dst) {
java.awt.Graphics2D g2 = origDst.createGraphics();
try {
g2.drawImage(dst, 0, 0, null);
} finally {
g2.dispose();
}
}
return origDst;
}
/**
* This method makes the color yellow transparent. It allows for images to overlap without fully
* covering eachother
*
* @param im The image to be made transparent
* @return The image with transparency
*/
public Image makeColorTransparent(BufferedImage im) {
ImageFilter filter =
new RGBImageFilter() {
public int markerRGB = Color.YELLOW.getRGB() | 0xFF000000;
public final int filterRGB(int x, int y, int rgb) {
if ((rgb | 0xFF000000) == markerRGB) {
return 0x00FFFFFF & rgb;
} else {
return rgb;
}
}
};
ImageProducer ip = new FilteredImageSource(im.getSource(), filter);
return Toolkit.getDefaultToolkit().createImage(ip);
}
private Image invert(Image src) {
BufferedImage biSrc = toBufferedImage(src);
BufferedImage biDst =
new BufferedImage(biSrc.getWidth(), biSrc.getHeight(), BufferedImage.TYPE_INT_ARGB_PRE);
byte invert[] = new byte[256];
for (int j = 0; j < 256; j++) {
invert[j] = (byte) (255 - j);
}
byte[][] ftable = {invert};
LookupOp lo = new LookupOp(new ByteLookupTable(0, ftable), null);
lo.filter(biSrc, biDst);
return Toolkit.getDefaultToolkit().createImage(biDst.getSource());
}
/**
* Makes a transparent image of the given dimensions.
*
* @param width the image width
* @param height the image height
* @return transparent image
*/
public static BufferedImage makeTransparentImage(final int width, final int height) {
// Create an image with the given dimension
final BufferedImage img = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
// Now filter the image to make all pixels transparent
final ImageFilter filter = new TransparentImageFilter();
final ImageProducer ip = new FilteredImageSource(img.getSource(), filter);
final Image image = Toolkit.getDefaultToolkit().createImage(ip);
// Write the resulting image in the buffered image to return
final BufferedImage bufferedImage = new BufferedImage(width, height, img.getType());
final Graphics graphics = bufferedImage.createGraphics();
graphics.drawImage(image, 0, 0, null);
graphics.dispose();
return bufferedImage;
}
public static BufferedImage colorRangeToTransparency(
final BufferedImage image, final Color c1, final Color c2) {
final int r1 = c1.getRed();
final int g1 = c1.getGreen();
final int b1 = c1.getBlue();
final int r2 = c2.getRed();
final int g2 = c2.getGreen();
final int b2 = c2.getBlue();
final ImageFilter filter =
new RGBImageFilter() {
@Override
public final int filterRGB(final int x, final int y, final int rgb) {
final int r = (rgb & 0xFF0000) >> 16;
final int g = (rgb & 0xFF00) >> 8;
final int b = rgb & 0xFF;
if (r >= r1 && r <= r2 && g >= g1 && g <= g2 && b >= b1 && b <= b2) {
// Set fully transparent but keep color
// calculate a alpha value based on the distance between the
// range borders and the pixel color
final int dist =
(Math.abs(r - (r1 + r2) / 2)
+ Math.abs(g - (g1 + g2) / 2)
+ Math.abs(b - (b1 + b2) / 2))
* 2;
return new Color(r, g, b, Math.min(255, dist)).getRGB();
}
return rgb;
}
};
final ImageProducer ip = new FilteredImageSource(image.getSource(), filter);
final Image img = Toolkit.getDefaultToolkit().createImage(ip);
return IconIO.toBufferedImage(img);
}
// BufferedImage 객체를 ImageIcon 로 변환한다. save 시 사용
private ImageIcon toImageIcon(BufferedImage bufferedImage) { // 추가된 메소드
return new ImageIcon(Toolkit.getDefaultToolkit().createImage(bufferedImage.getSource()));
}
private void initUI() {
solution.add(new Point(0, 0));
solution.add(new Point(0, 1));
solution.add(new Point(0, 2));
solution.add(new Point(1, 0));
solution.add(new Point(1, 1));
solution.add(new Point(1, 2));
solution.add(new Point(2, 0));
solution.add(new Point(2, 1));
solution.add(new Point(2, 2));
solution.add(new Point(3, 0));
solution.add(new Point(3, 1));
solution.add(new Point(3, 2));
buttons = new ArrayList<>();
panel = new JPanel();
panel.setBorder(BorderFactory.createLineBorder(Color.gray));
panel.setLayout(new GridLayout(4, 3, 0, 0));
try {
source = loadImage();
int h = getNewHeight(source.getWidth(), source.getHeight());
resized = resizeImage(source, DESIRED_WIDTH, h, BufferedImage.TYPE_INT_ARGB);
} catch (IOException ex) {
Logger.getLogger(PuzzleSample.class.getName()).log(Level.SEVERE, null, ex);
}
width = resized.getWidth(null);
height = resized.getHeight(null);
add(panel, BorderLayout.CENTER);
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 3; j++) {
image =
createImage(
new FilteredImageSource(
resized.getSource(),
new CropImageFilter(j * width / 3, i * height / 4, (width / 3), height / 4)));
MyButton button = new MyButton(image);
button.putClientProperty("position", new Point(i, j));
if (i == 3 && j == 2) {
lastButton = new MyButton();
lastButton.setBorderPainted(false);
lastButton.setContentAreaFilled(false);
lastButton.setLastButton();
lastButton.putClientProperty("position", new Point(i, j));
} else {
buttons.add(button);
}
}
}
Collections.shuffle(buttons);
buttons.add(lastButton);
for (int i = 0; i < 12; i++) {
MyButton btn = buttons.get(i);
panel.add(btn);
btn.setBorder(BorderFactory.createLineBorder(Color.gray));
btn.addActionListener(new ClickAction());
}
pack();
setTitle("Puzzle");
setResizable(false);
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static Image toImage(BufferedImage bufferedImage) {
return Toolkit.getDefaultToolkit().createImage(bufferedImage.getSource());
}
private void estimateContentTabAreaBorderColor(
PanePainter pane, int index, final Direction direction) {
Dimension preSize = pane.getSize();
reset(pane);
pane.addTab(EMPTY_STRING, SizeIcon.EMPTY, getComponent());
pane.setSelectedIndex(-1);
Dimension paneSize = pane.getMinimumSize();
if (direction.isHorizontal()) pane.setSize(paneSize.width, paneSize.height * 2);
else pane.setSize(paneSize.width * 2, paneSize.height);
pane.doValidation();
Rectangle tabBounds = pane.getBoundsAt(0);
BufferedImage img =
new BufferedImage(pane.getWidth(), pane.getHeight(), BufferedImage.TYPE_INT_ARGB);
int x = 0;
int y = 0;
if (direction == Direction.UP) {
x = tabBounds.x + (tabBounds.width / 2);
y = pane.getHeight() - contentInsets[index].top - contentInsets[index].bottom - 1;
} else if (direction == Direction.DOWN) {
x = tabBounds.x + (tabBounds.width / 2);
y = contentInsets[index].top + contentInsets[index].bottom;
} else if (direction == Direction.LEFT) {
x = pane.getWidth() - contentInsets[index].left - contentInsets[index].right - 1;
y = tabBounds.y + (tabBounds.height / 2);
} else {
x += contentInsets[index].left + contentInsets[index].right;
y = tabBounds.y + (tabBounds.height / 2);
}
final int px = x;
final int py = y;
RGBImageFilter colorFilter =
new RGBImageFilter() {
@Override
public int filterRGB(int x, int y, int rgb) {
if (px == x && py == y) {
int r = (rgb >> 16) & 0xff;
int g = (rgb >> 8) & 0xff;
int b = (rgb) & 0xff;
int a = (rgb >> 24) & 0xff;
contentTabAreaBorderColors[getDirectionIndex(direction.getOpposite())] =
new Color(r, g, b, a);
}
return rgb;
}
};
FilteredImageSource source = new FilteredImageSource(img.getSource(), colorFilter);
pane.paint(img.getGraphics());
BufferedImage img2 =
new BufferedImage(pane.getWidth(), pane.getHeight(), BufferedImage.TYPE_INT_ARGB);
img2.getGraphics().drawImage(Toolkit.getDefaultToolkit().createImage(source), 0, 0, null);
pane.setSize(preSize);
pane.doValidation();
}
public void process(String srcImageFile) {
try {
Image img;
ImageFilter cropFilter;
// 读取源图像
BufferedImage bi = ImageIO.read(new File(srcImageFile));
int srcWidth = bi.getWidth(); // 源图宽度
int srcHeight = bi.getHeight(); // 源图高度
int destLength = srcWidth > srcHeight ? srcHeight : srcWidth;
int x = (srcWidth - destLength) / 2;
int y = (srcHeight - destLength) / 2;
logger.debug(
String.format(
"ImgUtil -----> picUrl: %s,srcWidth %d,srcHeight:%d",
srcImageFile, srcWidth, srcHeight));
cropFilter = new CropImageFilter(x, y, destLength, destLength);
img =
Toolkit.getDefaultToolkit()
.createImage(new FilteredImageSource(bi.getSource(), cropFilter));
BufferedImage tag = new BufferedImage(destLength, destLength, BufferedImage.TYPE_INT_RGB);
Graphics g = tag.getGraphics();
g.drawImage(img, 0, 0, null); // 绘制截取后的图
g.dispose();
logger.debug("ImgUtil -----> Cut finished");
// 压缩
for (String s : compressSizeList.keySet()) {
int length = compressSizeList.get(s);
// To Test
Image tmpResult = tag.getScaledInstance(length, length, Image.SCALE_DEFAULT);
BufferedImage mBufferedImage =
new BufferedImage(length, length, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = mBufferedImage.createGraphics();
g2.drawImage(tmpResult, 0, 0, length, length, Color.white, null);
g2.dispose();
float[] kernelData2 = {
-0.125f, -0.125f, -0.125f, -0.125f, 2, -0.125f, -0.125f, -0.125f, -0.125f
};
Kernel kernel = new Kernel(3, 3, kernelData2);
ConvolveOp cOp = new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
mBufferedImage = cOp.filter(mBufferedImage, null);
String targetImageFile = getPictureSmallURL(srcImageFile, s);
File target = new File(targetImageFile);
File targetDir = target.getParentFile();
if (!targetDir.exists()) targetDir.mkdirs();
// 输出为文件
FileOutputStream out = new FileOutputStream(targetImageFile);
JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
encoder.encode(mBufferedImage);
out.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}