refactor(android): remove dead code

Author: jorgemasta

android/src/main/java/com/documentscanner/DocumentScannerPackage.java

@@ -1,15 +1,11 @@
 package com.documentscanner;
 
-import android.app.Activity;
-
-import com.facebook.react.ReactPackage;
 import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.JavaScriptModule;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;

android/src/main/java/com/documentscanner/DocumentScannerViewManager.java

@@ -19,7 +19,7 @@
 
 public class DocumentScannerViewManager extends ViewGroupManager<MainView> {
 
-    public static final String REACT_CLASS = "RNPdfScanner";
+    private static final String REACT_CLASS = "RNPdfScanner";
     private MainView view = null;
 
     @Override
@@ -95,9 +95,4 @@ public void setContrast(MainView view, double contrast) {
         view.setContrast(contrast);
     }
 
-    @ReactProp(name = "noGrayScale", defaultBoolean = false)
-    public void setRemoveGrayScale(MainView view, boolean bw) {
-        view.setRemoveGrayScale(bw);
-    }
-
 }

android/src/main/java/com/documentscanner/ImageProcessor.java

@@ -1,10 +1,8 @@
 package com.documentscanner;
 
-import android.app.Activity;
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.graphics.Bitmap;
-import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Path;
 import android.graphics.drawable.shapes.PathShape;
@@ -16,8 +14,6 @@
 
 import com.documentscanner.views.OpenNoteCameraView;
 import com.google.zxing.BinaryBitmap;
-import com.google.zxing.ChecksumException;
-import com.google.zxing.FormatException;
 import com.google.zxing.LuminanceSource;
 import com.google.zxing.NotFoundException;
 import com.google.zxing.RGBLuminanceSource;
@@ -35,49 +31,34 @@
 import org.opencv.core.Core;
 import org.opencv.core.CvType;
 import org.opencv.core.Mat;
-import org.opencv.core.MatOfInt;
 import org.opencv.core.MatOfPoint;
 import org.opencv.core.MatOfPoint2f;
 import org.opencv.core.Point;
-import org.opencv.core.Rect;
-import org.opencv.core.Scalar;
 import org.opencv.core.Size;
 import org.opencv.imgcodecs.Imgcodecs;
 import org.opencv.imgproc.Imgproc;
 
-import org.opencv.calib3d.Calib3d;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.Date;
 import java.util.HashMap;
-import java.util.List;
 
-/**
- * Created by allgood on 05/03/16.
- */
 public class ImageProcessor extends Handler {
 
     private static final String TAG = "ImageProcessor";
-    private final Handler mUiHandler;
     private final OpenNoteCameraView mMainActivity;
     private boolean mBugRotate;
-    private boolean colorMode = false;
-    private boolean filterMode = true;
     private double colorGain = 1; // contrast
     private double colorBias = 10; // bright
-    private int colorThresh = 115; // threshold
     private Size mPreviewSize;
     private Point[] mPreviewPoints;
-    private ResultPoint[] qrResultPoints;
     private int numOfSquares = 0;
     private int numOfRectangles = 10;
-    private boolean noGrayscale = false;
 
-    public ImageProcessor(Looper looper, Handler uiHandler, OpenNoteCameraView mainActivity, Context context) {
+    public ImageProcessor(Looper looper, OpenNoteCameraView mainActivity, Context context) {
         super(looper);
-        mUiHandler = uiHandler;
         this.mMainActivity = mainActivity;
         SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(context);
         mBugRotate = sharedPref.getBoolean("bug_rotate", false);
@@ -95,10 +76,6 @@ public void setContrast(double contrast) {
         this.colorGain = contrast;
     }
 
-    public void setRemoveGrayScale(boolean grayscale) {
-        this.noGrayscale = grayscale;
-    }
-
     public void handleMessage(Message msg) {
 
         if (msg.obj.getClass() == OpenNoteMessage.class) {
@@ -108,50 +85,33 @@ public void handleMessage(Message msg) {
             String command = obj.getCommand();
 
             Log.d(TAG, "Message Received: " + command + " - " + obj.getObj().toString());
+            // TODO: Manage command.equals("colorMode" || "filterMode"), return boolean
 
             if (command.equals("previewFrame")) {
                 processPreviewFrame((PreviewFrame) obj.getObj());
             } else if (command.equals("pictureTaken")) {
                 processPicture((Mat) obj.getObj());
-            } else if (command.equals("colorMode")) {
-                colorMode = (Boolean) obj.getObj();
-            } else if (command.equals("filterMode")) {
-                filterMode = (Boolean) obj.getObj();
             }
         }
     }
 
     private void processPreviewFrame(PreviewFrame previewFrame) {
 
-        Result[] results = {};
-
         Mat frame = previewFrame.getFrame();
 
-        try {
-            results = zxing(frame);
-        } catch (ChecksumException | FormatException e) {
-            // TODO Auto-generated catch block
-            e.printStackTrace();
-        }
-
-        boolean qrOk = false;
-        String currentQR = null;
+        Result[] results = zxing(frame);
 
         for (Result result : results) {
             String qrText = result.getText();
             if (Utils.isMatch(qrText, "^P.. V.. S[0-9]+") && checkQR(qrText)) {
                 Log.d(TAG, "QR Code valid: " + result.getText());
-                qrOk = true;
-                currentQR = qrText;
-                qrResultPoints = result.getResultPoints();
+                ResultPoint[] qrResultPoints = result.getResultPoints();
                 break;
             } else {
                 Log.d(TAG, "QR Code ignored: " + result.getText());
             }
         }
 
-        boolean autoMode = previewFrame.isAutoMode();
-        boolean previewOnly = previewFrame.isPreviewOnly();
         boolean focused = mMainActivity.isFocused();
 
         if (detectPreviewDocument(frame) && focused) {
@@ -170,7 +130,7 @@ private void processPreviewFrame(PreviewFrame previewFrame) {
 
     }
 
-    public void processPicture(Mat picture) {
+    private void processPicture(Mat picture) {
 
         Mat img = Imgcodecs.imdecode(picture, Imgcodecs.CV_LOAD_IMAGE_UNCHANGED);
         picture.release();
@@ -212,15 +172,11 @@ private ScannedDocument detectDocument(Mat inputRgba) {
 
             sd.originalPoints = new Point[4];
 
-            sd.originalPoints[0] = new Point(sd.widthWithRatio - quad.points[3].y, quad.points[3].x); // Topleft
+            sd.originalPoints[0] = new Point(sd.widthWithRatio - quad.points[3].y, quad.points[3].x); // TopLeft
             sd.originalPoints[1] = new Point(sd.widthWithRatio - quad.points[0].y, quad.points[0].x); // TopRight
             sd.originalPoints[2] = new Point(sd.widthWithRatio - quad.points[1].y, quad.points[1].x); // BottomRight
             sd.originalPoints[3] = new Point(sd.widthWithRatio - quad.points[2].y, quad.points[2].x); // BottomLeft
 
-            sd.previewPoints = mPreviewPoints;
-
-            MatOfPoint c = quad.contour;
-
             sd.quadrilateral = quad;
             sd.previewPoints = mPreviewPoints;
             sd.previewSize = mPreviewSize;
@@ -234,7 +190,7 @@ private ScannedDocument detectDocument(Mat inputRgba) {
         return sd.setProcessed(doc);
     }
 
-    private HashMap<String, Long> pageHistory = new HashMap<>();
+    private final HashMap<String, Long> pageHistory = new HashMap<>();
 
     private boolean checkQR(String qrCode) {
 
@@ -356,15 +312,15 @@ private Point[] sortPoints(Point[] src) {
         Comparator<Point> sumComparator = new Comparator<Point>() {
             @Override
             public int compare(Point lhs, Point rhs) {
-                return Double.valueOf(lhs.y + lhs.x).compareTo(rhs.y + rhs.x);
+                return Double.compare(lhs.y + lhs.x, rhs.y + rhs.x);
             }
         };
 
         Comparator<Point> diffComparator = new Comparator<Point>() {
 
             @Override
             public int compare(Point lhs, Point rhs) {
-                return Double.valueOf(lhs.y - lhs.x).compareTo(rhs.y - rhs.x);
+                return Double.compare(lhs.y - lhs.x, rhs.y - rhs.x);
             }
         };
 
@@ -374,10 +330,10 @@ public int compare(Point lhs, Point rhs) {
         // bottom-right corner = maximal sum
         result[2] = Collections.max(srcPoints, sumComparator);
 
-        // top-right corner = minimal diference
+        // top-right corner = minimal difference
         result[1] = Collections.min(srcPoints, diffComparator);
 
-        // bottom-left corner = maximal diference
+        // bottom-left corner = maximal difference
         result[3] = Collections.max(srcPoints, diffComparator);
 
         return result;
@@ -412,52 +368,9 @@ private void enhanceDocument(Mat src) {
         src.convertTo(src, CvType.CV_8UC1, colorGain, colorBias);
     }
 
-    /**
-     * When a pixel have any of its three elements above the threshold value and the
-     * average of the three values are less than 80% of the higher one, brings all
-     * three values to the max possible keeping the relation between them, any
-     * absolute white keeps the value, all others go to absolute black.
-     *
-     * src must be a 3 channel image with 8 bits per channel
-     *
-     * @param src
-     * @param threshold
-     */
-    private void colorThresh(Mat src, int threshold) {
-        Size srcSize = src.size();
-        int size = (int) (srcSize.height * srcSize.width) * 3;
-        byte[] d = new byte[size];
-        src.get(0, 0, d);
-
-        for (int i = 0; i < size; i += 3) {
-
-            // the "& 0xff" operations are needed to convert the signed byte to double
-
-            // avoid unneeded work
-            if ((double) (d[i] & 0xff) == 255) {
-                continue;
-            }
-
-            double max = Math.max(Math.max((double) (d[i] & 0xff), (double) (d[i + 1] & 0xff)),
-                    (double) (d[i + 2] & 0xff));
-            double mean = ((double) (d[i] & 0xff) + (double) (d[i + 1] & 0xff) + (double) (d[i + 2] & 0xff)) / 3;
-
-            if (max > threshold && mean < max * 0.8) {
-                d[i] = (byte) ((double) (d[i] & 0xff) * 255 / max);
-                d[i + 1] = (byte) ((double) (d[i + 1] & 0xff) * 255 / max);
-                d[i + 2] = (byte) ((double) (d[i + 2] & 0xff) * 255 / max);
-            } else {
-                d[i] = d[i + 1] = d[i + 2] = 0;
-            }
-        }
-        src.put(0, 0, d);
-    }
-
     private Mat fourPointTransform(Mat src, Point[] pts) {
 
         double ratio = src.size().height / 500;
-        int height = Double.valueOf(src.size().height / ratio).intValue();
-        int width = Double.valueOf(src.size().width / ratio).intValue();
 
         Point tl = pts[0];
         Point tr = pts[1];
@@ -494,9 +407,9 @@ private Mat fourPointTransform(Mat src, Point[] pts) {
 
     private ArrayList<MatOfPoint> findContours(Mat src) {
 
-        Mat grayImage = null;
-        Mat cannedImage = null;
-        Mat resizedImage = null;
+        Mat grayImage;
+        Mat cannedImage;
+        Mat resizedImage;
 
         double ratio = src.size().height / 500;
         int height = Double.valueOf(src.size().height / ratio).intValue();
@@ -512,7 +425,7 @@ private ArrayList<MatOfPoint> findContours(Mat src) {
         Imgproc.GaussianBlur(grayImage, grayImage, new Size(5, 5), 0);
         Imgproc.Canny(grayImage, cannedImage, 80, 100, 3, false);
 
-        ArrayList<MatOfPoint> contours = new ArrayList<MatOfPoint>();
+        ArrayList<MatOfPoint> contours = new ArrayList<>();
         Mat hierarchy = new Mat();
 
         Imgproc.findContours(cannedImage, contours, hierarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE);
@@ -523,7 +436,7 @@ private ArrayList<MatOfPoint> findContours(Mat src) {
 
             @Override
             public int compare(MatOfPoint lhs, MatOfPoint rhs) {
-                return Double.valueOf(Imgproc.contourArea(rhs)).compareTo(Imgproc.contourArea(lhs));
+                return Double.compare(Imgproc.contourArea(rhs), Imgproc.contourArea(lhs));
             }
         });
 
@@ -534,9 +447,9 @@ public int compare(MatOfPoint lhs, MatOfPoint rhs) {
         return contours;
     }
 
-    private QRCodeMultiReader qrCodeMultiReader = new QRCodeMultiReader();
+    private final QRCodeMultiReader qrCodeMultiReader = new QRCodeMultiReader();
 
-    public Result[] zxing(Mat inputImage) throws ChecksumException, FormatException {
+    private Result[] zxing(Mat inputImage) {
 
         int w = inputImage.width();
         int h = inputImage.height();
@@ -563,7 +476,7 @@ public Result[] zxing(Mat inputImage) throws ChecksumException, FormatException
         Result[] results = {};
         try {
             results = qrCodeMultiReader.decodeMultiple(bitmap);
-        } catch (NotFoundException e) {
+        } catch (NotFoundException ignored) {
         }
 
         return results;