| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| package convwatch; |
| |
| import convwatch.ImageHelper; |
| import java.io.File; |
| import java.awt.image.RenderedImage; |
| import java.awt.image.BufferedImage; |
| import java.lang.reflect.Method; |
| |
| // ----------------------------------------------------------------------------- |
| class Rect |
| { |
| int x; |
| int y; |
| int w; |
| int h; |
| |
| public Rect(int _x, int _y, int _w, int _h) |
| { |
| x = _x; |
| y = _y; |
| w = _w; |
| h = _h; |
| } |
| public int getX() {return x;} |
| public int getY() {return y;} |
| public int getWidth() {return w;} |
| public int getHeight() {return h;} |
| } |
| |
| class BorderRemover |
| { |
| ImageHelper m_aImage; |
| |
| // Helper values, filled after find Border |
| |
| // --------------------------------- test mode --------------------------------- |
| |
| // void pixelValue(int pixel) |
| // { |
| // int alpha = (pixel >> 24) & 0xff; |
| // int red = (pixel >> 16) & 0xff; |
| // int green = (pixel >> 8) & 0xff; |
| // int blue = (pixel ) & 0xff; |
| // int dummy = 0; |
| // } |
| |
| /* |
| * compares 2 colors with a given tolerance. So it's possible to check differences approximate. |
| * @param _nColor1 |
| * @param _nColor2 |
| * @param _nTolerance is a percentage value how strong the colors could be differ |
| |
| */ |
| boolean compareColorWithTolerance(int _nColor1, int _nColor2, int _nTolerance) |
| { |
| // int alpha1 = (_nColor1 >> 24) & 0xff; |
| int red1 = (_nColor1 >> 16) & 0xff; |
| int green1 = (_nColor1 >> 8) & 0xff; |
| int blue1 = (_nColor1 ) & 0xff; |
| |
| // int alpha2 = (_nColor2 >> 24) & 0xff; |
| int red2 = (_nColor2 >> 16) & 0xff; |
| int green2 = (_nColor2 >> 8) & 0xff; |
| int blue2 = (_nColor2 ) & 0xff; |
| |
| if (_nTolerance > 100) |
| { |
| _nTolerance = 100; |
| } |
| |
| // calculate tolerance halve |
| double nTolerable = (_nTolerance * 256 / 100); |
| if (nTolerable < 0) |
| { |
| nTolerable = 0; |
| } |
| |
| // X - th < Y < X + th |
| // if ((red1 - nTolerable) < red2 && red2 < (red1 + nTolerable)) |
| // is the same |
| // abs (X - Y) < th |
| if (Math.abs(red1 - red2) < nTolerable) |
| { |
| if (Math.abs(green1 - green2) < nTolerable) |
| { |
| if (Math.abs(blue1 - blue2) < nTolerable) |
| { |
| return true; |
| } |
| else |
| { |
| // blue differ |
| } |
| } |
| else |
| { |
| // green differ |
| } |
| } |
| else |
| { |
| // red differ |
| } |
| |
| return false; |
| } |
| |
| /** |
| * create a new image from an exist one without it's borders |
| * open the file (_sFilenameFrom) as an image, check if it contains any borders and remove |
| * the borders. |
| */ |
| public boolean createNewImageWithoutBorder(String _sFilenameFrom, String _sFilenameTo) |
| throws java.io.IOException |
| { |
| // System.out.println("load image: " + fileName); |
| m_aImage = ImageHelper.createImageHelper(_sFilenameFrom); |
| |
| // System.out.println("image width:" + String.valueOf(m_aImage.getWidth())); |
| // System.out.println("image height:" + String.valueOf(m_aImage.getHeight())); |
| |
| // int nw = graphics_stuff.countNotWhitePixel(m_aImage); |
| // System.out.println("not white pixels:" + String.valueOf(nw)); |
| |
| // int nb = graphics_stuff.countNotBlackPixel(m_aImage); |
| // System.out.println("not black pixels:" + String.valueOf(nb)); |
| |
| int nBorderColor = m_aImage.getPixel(0,0); |
| Rect aInnerRect = findBorder(m_aImage, nBorderColor); |
| |
| RenderedImage aImage = createImage(m_aImage, aInnerRect); |
| |
| File aWriteFile = new File(_sFilenameTo); |
| // GlobalLogWriter.get().println("Hello World: File to: " + _sFilenameTo); |
| |
| Exception ex = null; |
| try |
| { |
| Class imageIOClass = Class.forName("javax.imageio.ImageIO"); |
| // GlobalLogWriter.get().println("Hello World: get Class"); |
| |
| Method getWriterMIMETypesMethod = imageIOClass.getDeclaredMethod("getWriterMIMETypes", new Class[]{ }); |
| // GlobalLogWriter.get().println("Hello World: get Methode"); |
| |
| Object aObj = getWriterMIMETypesMethod.invoke(imageIOClass, new Object[]{ }); |
| String[] types = (String[])aObj; |
| // GlobalLogWriter.get().println("Hello World: types: " + Arrays.asList(types) ); |
| |
| Method writeMethod = imageIOClass.getDeclaredMethod("write", new Class[]{ java.awt.image.RenderedImage.class, |
| java.lang.String.class, |
| java.io.File.class}); |
| // GlobalLogWriter.get().println("Hello World: get Methode"); |
| writeMethod.invoke(imageIOClass, new Object[]{aImage, "image/jpeg", aWriteFile}); |
| } |
| catch(java.lang.ClassNotFoundException e) { |
| e.printStackTrace(); |
| ex = e; |
| } |
| catch(java.lang.NoSuchMethodException e) { |
| e.printStackTrace(); |
| ex = e; |
| } |
| catch(java.lang.IllegalAccessException e) { |
| e.printStackTrace(); |
| ex = e; |
| } |
| catch(java.lang.reflect.InvocationTargetException e) { |
| e.printStackTrace(); |
| ex = e; |
| } |
| |
| if (ex != null) { |
| // get Java version: |
| String javaVersion = System.getProperty("java.version"); |
| throw new java.io.IOException( |
| "Cannot construct object with current Java version " + |
| javaVersion + ": " + ex.getMessage()); |
| } |
| // ImageIO.write(aImage, "jpg", aWriteFile); |
| |
| return true; |
| } |
| |
| |
| /** |
| * runs through the image, pixel by pixel |
| * as long as found pixels like the color at (0,0) this is interpreted as border. |
| * as result it fills the m_nXMin, m_nXMax, m_nYMin, m_nYMax values. |
| */ |
| |
| Rect findBorder(ImageHelper _aImage, int _nBorderColor) |
| { |
| int h = _aImage.getHeight(); |
| int w = _aImage.getWidth(); |
| int nXMin = w; |
| int nXMax = 0; |
| int nYMin = h; |
| int nYMax = 0; |
| |
| for (int y = 0; y < h; y++) |
| { |
| for (int x = 0; x < nXMin; x++) |
| { |
| // handlesinglepixel(x+i, y+j, pixels[j * w + i]); |
| int nCurrentColor = _aImage.getPixel(x, y); |
| if (! compareColorWithTolerance(nCurrentColor, _nBorderColor, 10)) |
| { |
| // pixelValue(nCurrentColor); |
| // System.out.print("*"); |
| nXMin = java.lang.Math.min(nXMin, x); |
| nYMin = java.lang.Math.min(nYMin, y); |
| } |
| // else |
| // { |
| // System.out.print(" "); |
| // } |
| } |
| } |
| for (int y = 0; y < h; y++) |
| { |
| for (int nx = w - 1; nx >= nXMax; --nx) |
| { |
| int ny = h - y - 1; |
| int nCurrentColor = _aImage.getPixel(nx, ny); |
| if (! compareColorWithTolerance(nCurrentColor, _nBorderColor, 10)) |
| { |
| nXMax = java.lang.Math.max(nXMax, nx); |
| nYMax = java.lang.Math.max(nYMax, ny); |
| } |
| } |
| // System.out.println(); |
| } |
| // System.out.println("xmin: " + String.valueOf(nXMin)); |
| // System.out.println("xmax: " + String.valueOf(nXMax)); |
| // System.out.println("ymin: " + String.valueOf(nYMin)); |
| // System.out.println("ymax: " + String.valueOf(nYMax)); |
| |
| Rect aRect; |
| if (nXMin < nXMax && nYMin < nYMax) |
| { |
| int nw = nXMax - nXMin + 1; |
| int nh = nYMax - nYMin + 1; |
| |
| // this is the rectangle around the image content. |
| aRect = new Rect(nXMin, nYMin, nw, nh ); |
| } |
| else |
| { |
| // create the smalles possible image |
| aRect = new Rect(0,0,1,1); |
| } |
| |
| |
| // m_nXMin = nXMin; |
| // m_nXMax = nXMax; |
| // m_nYMin = nYMin; |
| // m_nYMax = nYMax; |
| return aRect; |
| } |
| |
| RenderedImage createImage(ImageHelper _aImage, Rect _aRect) throws IllegalArgumentException |
| { |
| // TODO: throw if w or h < 0 |
| int w = _aRect.getWidth(); |
| int h = _aRect.getHeight(); |
| |
| if (w <= 0 || h <= 0) |
| { |
| throw new IllegalArgumentException("width or height are too small or negative."); |
| } |
| |
| BufferedImage aBI = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); |
| |
| int nXOffset = _aRect.getX(); |
| int nYOffset = _aRect.getY(); |
| |
| // Memory Block move |
| for (int y = 0; y < h; y++) |
| { |
| for (int x = 0; x < w; x++) |
| { |
| // aPixels[y * w + x] = m_aImage.getPixel(m_nXMin + x, m_nYMin + y); |
| aBI.setRGB(x, y, _aImage.getPixel(x + nXOffset, y + nYOffset)); |
| } |
| } |
| // java.awt.image.MemoryImageSource aSource = new java.awt.image.MemoryImageSource(w, h, aPixels, 0, w); |
| // return java.awt.Component.createImage(aSource); |
| // return java.awt.Toolkit.getDefaultToolkit().createImage(aSource); |
| return aBI; |
| } |
| |
| } |
