summaryrefslogtreecommitdiff
path: root/qadevOOo/runner/convwatch/BorderRemover.java
diff options
context:
space:
mode:
Diffstat (limited to 'qadevOOo/runner/convwatch/BorderRemover.java')
-rw-r--r--qadevOOo/runner/convwatch/BorderRemover.java319
1 files changed, 319 insertions, 0 deletions
diff --git a/qadevOOo/runner/convwatch/BorderRemover.java b/qadevOOo/runner/convwatch/BorderRemover.java
new file mode 100644
index 000000000000..986f6ff6582b
--- /dev/null
+++ b/qadevOOo/runner/convwatch/BorderRemover.java
@@ -0,0 +1,319 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 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;
+ }
+
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-04 08:45:48 +0000