Пример #1
0
  public static boolean checkAngleL(Mat binary) {
    int leftPointX = -1;

    double pixel[];

    for (int i = 0; i < binary.cols(); i++) {
      pixel = binary.get(0, i);
      if (pixel[0] != 0.0) {
        leftPointX = i;
      }
    }

    int rightPointY = -1;
    for (int i = 0; i < binary.rows(); i++) {
      pixel = binary.get(i, binary.cols() - 1);
      if (pixel[0] != 0.0) {
        rightPointY = i;
        break;
      }
    }

    double opposite = rightPointY;
    double adjacent = binary.cols() - 1 - leftPointX;

    double angle = Math.atan2(opposite, adjacent) * (180 / Math.PI);

    if (angle >= 50.0 & angle < 70.0) {
      return true; // angle indicates L
    } else {
      return false; // angle indicates not L
    }
  }
Пример #2
0
  private static double perceptualHash(String sourceImagePath, String targetImagePath) {

    System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

    Mat matSrc = Imgcodecs.imread(sourceImagePath, Imgcodecs.CV_LOAD_IMAGE_COLOR);
    Mat matTrgt = Imgcodecs.imread(targetImagePath, Imgcodecs.CV_LOAD_IMAGE_COLOR);
    Mat matSrcResize = new Mat();
    Mat matTrgtResize = new Mat();
    Imgproc.resize(
        matSrc,
        matSrcResize,
        new Size(matSrc.width(), matSrc.height()),
        0,
        0,
        Imgproc.INTER_NEAREST);
    Imgproc.resize(
        matTrgt,
        matTrgtResize,
        new Size(matTrgt.width(), matTrgt.height()),
        0,
        0,
        Imgproc.INTER_LANCZOS4);
    Mat matSrcDst = new Mat();
    Mat matTrgtDst = new Mat();
    Imgproc.resize(matSrcResize, matSrcDst, new Size(8, 8), 0, 0, Imgproc.INTER_CUBIC);
    Imgproc.resize(matTrgtResize, matTrgtDst, new Size(8, 8), 0, 0, Imgproc.INTER_CUBIC);
    Imgproc.cvtColor(matSrcDst, matSrcDst, Imgproc.COLOR_BGR2GRAY);
    Imgproc.cvtColor(matTrgtDst, matTrgtDst, Imgproc.COLOR_BGR2GRAY);

    int iAvgSrc = 0, iAvgTrgt = 0;
    int[] arrSrc = new int[64];
    int[] arrTrgt = new int[64];
    for (int i = 0; i < 8; i++) {
      byte[] dataSrc = new byte[8];
      matSrcDst.get(i, 0, dataSrc);
      byte[] dataTrgt = new byte[8];
      matTrgtDst.get(i, 0, dataTrgt);

      int tmp = i * 8;
      for (int j = 0; j < 8; j++) {
        int tmpSrc = tmp + j;
        arrSrc[tmpSrc] = dataSrc[j] / 4 * 4;
        arrTrgt[tmpSrc] = dataTrgt[j] / 4 * 4;
        iAvgSrc += arrSrc[tmpSrc];
        iAvgTrgt += arrTrgt[tmpSrc];
      }
    }

    iAvgSrc /= 64;
    iAvgTrgt /= 64;
    for (int i = 0; i < 64; i++) {
      arrSrc[i] = (arrSrc[i] >= iAvgSrc) ? 1 : 0;
      arrTrgt[i] = (arrTrgt[i] >= iAvgTrgt) ? 1 : 0;
    }
    int iDiffNum = 0;
    for (int i = 0; i < 64; i++) if (arrSrc[i] != arrTrgt[i]) ++iDiffNum;

    return 1.0 - (double) iDiffNum / 64;
  }
Пример #3
0
 Mat setupMatrix(double hSmallToGlass[], double hGlassToSmall[]) {
   Mat hSmallToGlassMat = HMatFromArray(hSmallToGlass);
   Mat hGlassToSmallMat = hSmallToGlassMat.inv();
   double denominator = hGlassToSmallMat.get(2, 2)[0];
   for (int i = 0; i < 3; i++)
     for (int j = 0; j < 3; j++)
       hGlassToSmall[i * 3 + j] = hGlassToSmallMat.get(i, j)[0] / denominator;
   return hSmallToGlassMat;
 }
Пример #4
0
 public SaliencyResult saliencyalgorithmInterface(ImageObj imgobj, String method) {
   // TODO Auto-generated method stub
   float min = Float.MAX_VALUE;
   float max = Float.MIN_VALUE;
   String imgpath = imgobj.getSourcePath();
   int k_num = imgobj.getK_num();
   SaliencyResult result = new SaliencyResult();
   Mat img = Highgui.imread(imgpath, Highgui.CV_LOAD_IMAGE_GRAYSCALE);
   Mat saliencyMap = new Mat();
   saliencyMap.create(img.rows(), img.cols(), CvType.CV_16U);
   int HistGram[] = new int[256];
   int Gray[] = new int[img.cols() * img.rows()];
   int Dist[] = new int[256];
   float DistMap[] = new float[img.rows() * img.cols()];
   for (int row = 0; row < img.rows(); row++) {
     int CurIndex = row * img.cols();
     for (int col = 0; col < img.cols(); col++) {
       HistGram[(int) (img.get(row, col)[0])]++;
       Gray[CurIndex] = (int) (img.get(row, col)[0]);
       CurIndex++;
     }
   }
   for (int Y = 0; Y < 256; Y++) {
     int Value = 0;
     for (int X = 0; X < 256; X++) Value += Math.abs(Y - X) * HistGram[X];
     Dist[Y] = Value;
   }
   for (int row = 0; row < img.rows(); row++) {
     int CurIndex = row * img.cols();
     for (int col = 0; col < img.cols(); col++) {
       DistMap[CurIndex] = Dist[Gray[CurIndex]];
       if (DistMap[CurIndex] < min) min = DistMap[CurIndex];
       if (DistMap[CurIndex] > max) max = DistMap[CurIndex];
       CurIndex++;
     }
   }
   for (int row = 0; row < img.rows(); row++) {
     int CurIndex = row * img.cols();
     for (int col = 0; col < img.cols(); col++) {
       saliencyMap.put(row, col, partTwo((DistMap[CurIndex] - min) / (max - min) * 255));
       CurIndex++;
     }
   }
   new findMarkUtil();
   int nums[] = null;
   if (method == "kmeans") {
     nums = findMarkUtil.findMarkUtil_kmeans(saliencyMap, k_num, 255, 0, 5);
   } else if (method == "random") {
     nums = findMarkUtil.findMarkUtil_random(saliencyMap, k_num, 255);
   }
   result.setK_num(k_num);
   result.setSource(imgpath);
   result.setResult(nums);
   result.setSaliency(saliencyMap);
   return result;
 }
Пример #5
0
  private float derivImodelAlpha(int i, int idx) {
    float Gx, Gy;
    float res;

    int x = model.get(idx).getX();
    int y = model.get(idx).getY();

    Gx = (float) dxModel.get(x, y)[0];
    Gy = (float) dyModel.get(x, y)[0];

    res = Gx * s[idx * 3][i] + Gy * s[idx * 3 + 2][i];

    return res;
  }
Пример #6
0
  /**
   * Helper function to convert a Mat into a BufferedImage. Taken from
   * http://answers.opencv.org/question/10344/opencv-java-load-image-to-gui Author: 'Lucky Luke'
   *
   * @param matrix Mat of type CV_8UC3 or CV_8UC1
   * @return BufferedImage of type TYPE_3BYTE_BGR or TYPE_BYTE_GRAY
   */
  private static BufferedImage matToBufferedImage(Mat matrix) {
    int cols = matrix.cols();
    int rows = matrix.rows();
    int elemSize = (int) matrix.elemSize();
    byte[] data = new byte[cols * rows * elemSize];
    int type;

    matrix.get(0, 0, data);

    switch (matrix.channels()) {
      case 1:
        type = BufferedImage.TYPE_BYTE_GRAY;
        break;

      case 3:
        type = BufferedImage.TYPE_3BYTE_BGR;

        // bgr to rgb
        byte b;
        for (int i = 0; i < data.length; i = i + 3) {
          b = data[i];
          data[i] = data[i + 2];
          data[i + 2] = b;
        }
        break;

      default:
        return null;
    }

    BufferedImage image = new BufferedImage(cols, rows, type);
    image.getRaster().setDataElements(0, 0, cols, rows, data);

    return image;
  }
Пример #7
0
  private Mat rotateImage(Mat src, double angle) {
    Point center = new Point(src.cols() / 2, src.rows() / 2);
    double scale = 1.0;

    Mat rotateMat = Imgproc.getRotationMatrix2D(center, angle, scale);
    Mat dst = new Mat();
    Size frameSize = new Size(src.rows(), src.cols());

    // adjust dst center point
    double m[] = new double[6];
    rotateMat.get(0, 0, m);
    m[2] += (frameSize.width - src.cols()) / 2;
    m[5] += (frameSize.height - src.rows()) / 2;
    rotateMat.put(0, 0, m);

    Imgproc.warpAffine(
        src,
        dst,
        rotateMat,
        frameSize,
        Imgproc.INTER_LINEAR,
        Imgproc.BORDER_CONSTANT,
        Scalar.all(0));

    return dst;
  }
  private Scalar converScalarHsv2Rgba(Scalar hsvColor) {
    Mat pointMatRgba = new Mat();
    Mat pointMatHsv = new Mat(1, 1, CvType.CV_8UC3, hsvColor);
    Imgproc.cvtColor(pointMatHsv, pointMatRgba, Imgproc.COLOR_HSV2RGB_FULL, 4);

    return new Scalar(pointMatRgba.get(0, 0));
  }
Пример #9
0
  protected static void rotateXAxis(Mat rotation) {
    // get the matrix corresponding to the rotation vector
    Mat R = new Mat(3, 3, CvType.CV_64FC1);
    Calib3d.Rodrigues(rotation, R);

    // create the matrix to rotate 90º around the X axis
    // 1, 0, 0
    // 0 cos -sin
    // 0 sin cos
    double[] rot = {
      1, 0, 0,
      0, 0, -1,
      0, 1, 0
    };
    // multiply both matrix
    Mat res = new Mat(3, 3, CvType.CV_64FC1);
    double[] prod = new double[9];
    double[] a = new double[9];
    R.get(0, 0, a);
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++) {
        prod[3 * i + j] = 0;
        for (int k = 0; k < 3; k++) {
          prod[3 * i + j] += a[3 * i + k] * rot[3 * k + j];
        }
      }
    // convert the matrix to a vector with rodrigues back
    res.put(0, 0, prod);
    Calib3d.Rodrigues(res, rotation);
  }
Пример #10
0
  public static void main(String[] args) {
    try {
      System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

      File input = new File("traffic_signal.jpg");
      BufferedImage image = ImageIO.read(input);

      byte[] data = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
      Mat mat = new Mat(image.getHeight(), image.getWidth(), CvType.CV_8UC3);
      mat.put(0, 0, data);

      Mat mat1 = new Mat(image.getHeight(), image.getWidth(), CvType.CV_8UC1);
      Imgproc.cvtColor(mat, mat1, Imgproc.COLOR_RGB2GRAY);

      byte[] data1 = new byte[mat1.rows() * mat1.cols() * (int) (mat1.elemSize())];
      mat1.get(0, 0, data1);
      BufferedImage image1 =
          new BufferedImage(mat1.cols(), mat1.rows(), BufferedImage.TYPE_BYTE_GRAY);
      image1.getRaster().setDataElements(0, 0, mat1.cols(), mat1.rows(), data1);

      File ouptut = new File("output\\grayscale_" + new Date().getTime() + ".jpg");
      ImageIO.write(image1, "jpg", ouptut);
    } catch (Exception e) {
      System.out.println("Error: " + e.getMessage());
    }
  }
Пример #11
0
 private static void printMatI(Mat mat) {
   int[] data = new int[mat.channels()];
   for (int r = 0; r < mat.rows(); r++) {
     for (int c = 0; c < mat.cols(); c++) {
       mat.get(r, c, data);
       log(lvl, "(%d, %d) %s", r, c, Arrays.toString(data));
     }
   }
 }
Пример #12
0
 public static BufferedImage bufferedImage(Mat m) {
   int type = BufferedImage.TYPE_BYTE_GRAY;
   if (m.channels() > 1) {
     type = BufferedImage.TYPE_3BYTE_BGR;
   }
   BufferedImage image = new BufferedImage(m.cols(), m.rows(), type);
   m.get(
       0, 0, ((DataBufferByte) image.getRaster().getDataBuffer()).getData()); // get all the pixels
   return image;
 }
Пример #13
0
  public void predictOutput() {
    network.load(Settings.networkFile);

    for (int ntestSample = 0; ntestSample < networkInput.rows(); ntestSample++) {
      Mat testSample = networkInput.row(ntestSample);
      Mat classificationResult = new Mat(1, Settings.CLASSES, CvType.CV_32F);

      // System.out.println(testSample.dump());

      network.predict(testSample, classificationResult);

      // System.out.println(classificationResult.dump());

      int maxIndex = 0;
      double value = 0;
      double maxValue = classificationResult.get(0, 0)[0];

      for (int index = 1; index < Settings.CLASSES; index++) {
        value = classificationResult.get(0, index)[0];

        if (value > maxValue) {
          maxValue = value;
          maxIndex = index;
        }
      }

      if (networkOutput.get(ntestSample, maxIndex)[0] != 1) {

        for (int classIndex = 0; classIndex < Settings.CLASSES; classIndex++) {
          if (networkOutput.get(ntestSample, classIndex)[0] == 1) {
            results[classIndex][1]++;
          }
        }
      } else {
        results[maxIndex][0]++;
        results[maxIndex][1]++;
      }
    }
  }
 public static Image convertMatToImage(Mat m) {
   int type = BufferedImage.TYPE_BYTE_GRAY;
   if (m.channels() > 1) {
     type = BufferedImage.TYPE_3BYTE_BGR;
   }
   int bufferSize = m.channels() * m.cols() * m.rows();
   byte[] b = new byte[bufferSize];
   m.get(0, 0, b);
   BufferedImage image = new BufferedImage(m.cols(), m.rows(), type);
   final byte[] targetPixels = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
   System.arraycopy(b, 0, targetPixels, 0, b.length);
   return image;
 }
Пример #15
0
  /** Capture images and run color processing through here */
  public void capture() {
    VideoCapture camera = new VideoCapture();

    camera.set(12, -20); // change contrast, might not be necessary

    // CaptureImage image = new CaptureImage();

    camera.open(0); // Useless
    if (!camera.isOpened()) {
      System.out.println("Camera Error");

      // Determine whether to use System.exit(0) or return

    } else {
      System.out.println("Camera OK");
    }

    boolean success = camera.read(capturedFrame);
    if (success) {
      try {
        processWithContours(capturedFrame, processedFrame);
      } catch (Exception e) {
        System.out.println(e);
      }
      // image.processFrame(capturedFrame, processedFrame);
      // processedFrame should be CV_8UC3

      // image.findCaptured(processedFrame);

      // image.determineKings(capturedFrame);

      int bufferSize = processedFrame.channels() * processedFrame.cols() * processedFrame.rows();
      byte[] b = new byte[bufferSize];

      processedFrame.get(0, 0, b); // get all the pixels
      // This might need to be BufferedImage.TYPE_INT_ARGB
      img =
          new BufferedImage(
              processedFrame.cols(), processedFrame.rows(), BufferedImage.TYPE_INT_RGB);
      int width = (int) camera.get(Highgui.CV_CAP_PROP_FRAME_WIDTH);
      int height = (int) camera.get(Highgui.CV_CAP_PROP_FRAME_HEIGHT);
      // img.getRaster().setDataElements(0, 0, width, height, b);
      byte[] a = new byte[bufferSize];
      System.arraycopy(b, 0, a, 0, bufferSize);

      Highgui.imwrite("camera.jpg", processedFrame);
      System.out.println("Success");
    } else System.out.println("Unable to capture image");

    camera.release();
  }
Пример #16
0
  private void seamlessEdges(Mat image) {
    int imageHeight = image.height();
    int imageWidth = image.width();
    double smoothRange = smoothValue * (imageWidth / 2000f);
    double smoothRangeHalf = smoothRange / 2;
    double pixel1[];
    double pixel2[];
    double tempPixel[] = new double[4];
    tempPixel[3] = 255;

    int i, j;
    for (i = 0; i < smoothRangeHalf; i++) {
      for (j = 0; j < imageHeight; j++) {
        pixel1 = image.get(j, i);
        pixel2 = image.get(j, imageWidth - i - 1);
        tempPixel[0] =
            pixel1[0] * ((smoothRangeHalf + i) / smoothRange)
                + pixel2[0] * ((smoothRangeHalf - i) / smoothRange);
        tempPixel[1] =
            pixel1[1] * ((smoothRangeHalf + i) / smoothRange)
                + pixel2[1] * ((smoothRangeHalf - i) / smoothRange);
        tempPixel[2] =
            pixel1[2] * ((smoothRangeHalf + i) / smoothRange)
                + pixel2[2] * ((smoothRangeHalf - i) / smoothRange);
        pixel2[0] =
            pixel2[0] * ((smoothRangeHalf + i) / smoothRange)
                + pixel1[0] * ((smoothRangeHalf - i) / smoothRange);
        pixel2[1] =
            pixel2[1] * ((smoothRangeHalf + i) / smoothRange)
                + pixel1[1] * ((smoothRangeHalf - i) / smoothRange);
        pixel2[2] =
            pixel2[2] * ((smoothRangeHalf + i) / smoothRange)
                + pixel1[2] * ((smoothRangeHalf - i) / smoothRange);
        image.put(j, i, tempPixel);
        image.put(j, imageWidth - i - 1, pixel2);
      }
    }
  }
Пример #17
0
  private static Mat quat2rpy(Mat quat) {
    double[] q = new double[4];
    quat.get(0, 0, q);

    double[] rpy = {
      Math.atan2(2 * (q[0] * q[1] + q[2] * q[3]), 1 - 2 * (q[1] * q[1] + q[2] * q[2])),
      Math.asin(2 * (q[0] * q[2] - q[3] * q[1])),
      Math.atan2(2 * (q[0] * q[3] + q[1] * q[2]), 1 - 2 * (q[2] * q[2] + q[3] * q[3]))
    };

    Mat rpym = new Mat(3, 1, CvType.CV_64F);
    rpym.put(0, 0, rpy);
    return rpym;
  }
  public void copyMat(Mat src, Mat dest) {
    int srcRows = src.rows();
    int srcCols = src.cols();
    int destRows = dest.rows();
    int destCols = dest.cols();

    for (int i = 0; i < srcRows; i++) {
      for (int j = 0; j < srcCols; j++) {
        double bit = src.get(i, j)[0];
        dest.put(i, j, bit);
        System.out.println(bit);
      }
    }
  }
Пример #19
0
  private static Mat rodr2quat(Mat rodr) {
    double t = Core.norm(rodr);
    double[] r = new double[3];
    rodr.get(0, 0, r);

    double[] quat = {
      Math.cos(t / 2),
      Math.sin(t / 2) * r[0] / t,
      Math.sin(t / 2) * r[1] / t,
      Math.sin(t / 2) * r[2] / t
    };
    Mat quatm = new Mat(4, 1, CvType.CV_64F);
    quatm.put(0, 0, quat);
    return quatm;
  }
  public static Mat getCCH(Mat image) {
    ArrayList<MatOfPoint> contours = new ArrayList<MatOfPoint>();
    Mat hierarchy = new Mat();
    Imgproc.findContours(
        image, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_NONE);

    Mat chainHistogram = Mat.zeros(1, 8, CvType.CV_32F);
    int n = 0;
    MatOfPoint2f approxCurve = new MatOfPoint2f();
    for (MatOfPoint contour : contours) {

      // get the freeman chain code from the contours
      int rows = contour.rows();
      // System.out.println("\nrows"+rows+"\n"+contour.dump());
      int direction = 7;
      Mat prevPoint = contours.get(0).row(0);
      n += rows - 1;
      for (int i = 1; i < rows; i++) {
        // get the current point
        double x1 = contour.get(i - 1, 0)[1];
        double y1 = contour.get(i - 1, 0)[0];

        // get the second point
        double x2 = contour.get(i, 0)[1];
        double y2 = contour.get(i, 0)[0];

        if (x2 == x1 && y2 == y1 + 1) direction = 0;
        else if (x2 == x1 - 1 && y2 == y1 + 1) direction = 1;
        else if (x2 == x1 - 1 && y2 == y1) direction = 2;
        else if (x2 == x1 - 1 && y2 == y1 - 1) direction = 3;
        else if (x2 == x1 && y2 == y1 - 1) direction = 4;
        else if (x2 == x1 + 1 && y2 == y1 - 1) direction = 5;
        else if (x2 == x1 + 1 && y2 == y1) direction = 6;
        else if (x2 == x1 + 1 && y2 == y1 + 1) direction = 7;
        else System.out.print("err");
        double counter = chainHistogram.get(0, direction)[0];
        chainHistogram.put(0, direction, ++counter);
        System.out.print(direction);
      }
    }
    System.out.println("\n" + chainHistogram.dump());
    Scalar alpha = new Scalar(n); // the factor
    Core.divide(chainHistogram, alpha, chainHistogram);
    System.out.println("\nrows=" + n + " " + chainHistogram.dump());
    return chainHistogram;
  }
  /**
   * fills 'cTable' with the values in confMatrix
   *
   * @param confMatrix Mat - a result from TestingResult 'res'
   */
  public void fillConfTable(Mat confMatrix) {
    // initialize table header
    JTableHeader header = cTable.getTableHeader();
    for (int i = 0; i < cTable.getColumnCount() - 1; i++) {
      TableColumn column1 = cTable.getTableHeader().getColumnModel().getColumn(i + 1);
      column1.setHeaderValue(wordClasses[i]);
    }
    System.out.println(cTable.getColumnCount());
    // fill the first column with classes

    for (int i = 0; i < wordClasses.length; i++) {
      for (int j = 0; j < wordClasses.length; j++) {
        cTable.setValueAt(wordClasses[i], i, 0);
        cTable.setValueAt(confMatrix.get(i, j)[0], i, j + 1);
      }
    }
  }
Пример #22
0
 private boolean setCircleParameters(Mat circles) {
   /** Determine which circle in on the left and right */
   if (circles.get(0, 0)[0] < circles.get(0, 1)[0]) {
     circle1 = circles.get(0, 0)[0];
     circle2 = circles.get(0, 1)[0];
   } else {
     circle1 = circles.get(0, 1)[0];
     circle2 = circles.get(0, 0)[0];
   }
   minRadius = (int) ((circles.get(0, 1)[2] + circles.get(0, 0)[2]) / 2) - 10;
   if (minRadius < 5) minRadius = 5;
   maxRadius = minRadius + 20;
   minDistance = (int) (circle2 - circle1 - 10);
   return true;
 }
Пример #23
0
  protected static void glGetModelViewMatrix(double[] modelview_matrix, Mat Rvec, Mat Tvec)
      throws ExtParamException {
    // check if parameters are valid
    boolean invalid = false;
    double[] tvec = new double[3];
    double[] rvec = new double[3];

    Rvec.get(0, 0, rvec);
    Tvec.get(0, 0, tvec);

    for (int i = 0; i < 3 && !invalid; i++) {
      if (tvec[i] != -999999) invalid |= false;
      if (rvec[i] != -999999) invalid |= false;
    }

    if (invalid)
      throw new ExtParamException("extrinsic parameters are not set Marker.getModelViewMatrix");
    Mat Rot = new Mat(3, 3, CvType.CV_32FC1);
    Mat Jacob = new Mat();
    Calib3d.Rodrigues(Rvec, Rot, Jacob); // TODO jacob no se vuelve a usar

    double[][] para = new double[3][4];
    double[] rotvec = new double[9];
    Rot.get(0, 0, rotvec);
    for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) para[i][j] = rotvec[3 * i + j];
    // now, add the translation
    para[0][3] = tvec[0];
    para[1][3] = tvec[1];
    para[2][3] = tvec[2];
    double scale = 1;

    // R1C2
    modelview_matrix[0 + 0 * 4] = para[0][0];
    modelview_matrix[0 + 1 * 4] = para[0][1];
    modelview_matrix[0 + 2 * 4] = para[0][2];
    modelview_matrix[0 + 3 * 4] = para[0][3];
    // R2
    modelview_matrix[1 + 0 * 4] = para[1][0];
    modelview_matrix[1 + 1 * 4] = para[1][1];
    modelview_matrix[1 + 2 * 4] = para[1][2];
    modelview_matrix[1 + 3 * 4] = para[1][3];
    // R3
    modelview_matrix[2 + 0 * 4] = -para[2][0];
    modelview_matrix[2 + 1 * 4] = -para[2][1];
    modelview_matrix[2 + 2 * 4] = -para[2][2];
    modelview_matrix[2 + 3 * 4] = -para[2][3];

    modelview_matrix[3 + 0 * 4] = 0.0f;
    modelview_matrix[3 + 1 * 4] = 0.0f;
    modelview_matrix[3 + 2 * 4] = 0.0f;
    modelview_matrix[3 + 3 * 4] = 1.0f;
    if (scale != 0.0) {
      modelview_matrix[12] *= scale;
      modelview_matrix[13] *= scale;
      modelview_matrix[14] *= scale;
    }

    // rotate 90º around the x axis
    // rotating around x axis in OpenGL is equivalent to
    // multiply the model matrix by the matrix:
    // 1, 0, 0, 0, 0, cos(a), sin(a), 0, 0, -sin(a), cos(a), 0, 0, 0, 0, 1
    //	    double[] auxRotMat = new double[]{
    //	    	1, 0,  0, 0,
    //	    	0, 0, 1, 0,
    //	    	0, -1,  0, 0,
    //	    	0, 0,  0, 1
    //	    };
    //	    Utils.matrixProduct(modelview_matrix1, auxRotMat, modelview_matrix);
  }
  public Mat onCameraFrame(Mat inputFrame) {
    inputFrame.copyTo(mRgba);

    switch (ImageManipulationsActivity.viewMode) {
      case ImageManipulationsActivity.VIEW_MODE_RGBA:
        break;

      case ImageManipulationsActivity.VIEW_MODE_HIST:
        if ((mSizeRgba == null)
            || (mRgba.cols() != mSizeRgba.width)
            || (mRgba.height() != mSizeRgba.height)) CreateAuxiliaryMats();
        int thikness = (int) (mSizeRgba.width / (mHistSizeNum + 10) / 5);
        if (thikness > 5) thikness = 5;
        int offset = (int) ((mSizeRgba.width - (5 * mHistSizeNum + 4 * 10) * thikness) / 2);
        // RGB
        for (int c = 0; c < 3; c++) {
          Imgproc.calcHist(Arrays.asList(mRgba), mChannels[c], mMat0, mHist, mHistSize, mRanges);
          Core.normalize(mHist, mHist, mSizeRgba.height / 2, 0, Core.NORM_INF);
          mHist.get(0, 0, mBuff);
          for (int h = 0; h < mHistSizeNum; h++) {
            mP1.x = mP2.x = offset + (c * (mHistSizeNum + 10) + h) * thikness;
            mP1.y = mSizeRgba.height - 1;
            mP2.y = mP1.y - 2 - (int) mBuff[h];
            Core.line(mRgba, mP1, mP2, mColorsRGB[c], thikness);
          }
        }
        // Value and Hue
        Imgproc.cvtColor(mRgba, mIntermediateMat, Imgproc.COLOR_RGB2HSV_FULL);
        // Value
        Imgproc.calcHist(
            Arrays.asList(mIntermediateMat), mChannels[2], mMat0, mHist, mHistSize, mRanges);
        Core.normalize(mHist, mHist, mSizeRgba.height / 2, 0, Core.NORM_INF);
        mHist.get(0, 0, mBuff);
        for (int h = 0; h < mHistSizeNum; h++) {
          mP1.x = mP2.x = offset + (3 * (mHistSizeNum + 10) + h) * thikness;
          mP1.y = mSizeRgba.height - 1;
          mP2.y = mP1.y - 2 - (int) mBuff[h];
          Core.line(mRgba, mP1, mP2, mWhilte, thikness);
        }
        // Hue
        Imgproc.calcHist(
            Arrays.asList(mIntermediateMat), mChannels[0], mMat0, mHist, mHistSize, mRanges);
        Core.normalize(mHist, mHist, mSizeRgba.height / 2, 0, Core.NORM_INF);
        mHist.get(0, 0, mBuff);
        for (int h = 0; h < mHistSizeNum; h++) {
          mP1.x = mP2.x = offset + (4 * (mHistSizeNum + 10) + h) * thikness;
          mP1.y = mSizeRgba.height - 1;
          mP2.y = mP1.y - 2 - (int) mBuff[h];
          Core.line(mRgba, mP1, mP2, mColorsHue[h], thikness);
        }
        break;

      case ImageManipulationsActivity.VIEW_MODE_CANNY:
        if ((mRgbaInnerWindow == null)
            || (mGrayInnerWindow == null)
            || (mRgba.cols() != mSizeRgba.width)
            || (mRgba.height() != mSizeRgba.height)) CreateAuxiliaryMats();
        Imgproc.Canny(mRgbaInnerWindow, mIntermediateMat, 80, 90);
        Imgproc.cvtColor(mIntermediateMat, mRgbaInnerWindow, Imgproc.COLOR_GRAY2BGRA, 4);
        break;

      case ImageManipulationsActivity.VIEW_MODE_SOBEL:
        Imgproc.cvtColor(mRgba, mGray, Imgproc.COLOR_RGBA2GRAY);

        if ((mRgbaInnerWindow == null)
            || (mGrayInnerWindow == null)
            || (mRgba.cols() != mSizeRgba.width)
            || (mRgba.height() != mSizeRgba.height)) CreateAuxiliaryMats();

        Imgproc.Sobel(mGrayInnerWindow, mIntermediateMat, CvType.CV_8U, 1, 1);
        Core.convertScaleAbs(mIntermediateMat, mIntermediateMat, 10, 0);
        Imgproc.cvtColor(mIntermediateMat, mRgbaInnerWindow, Imgproc.COLOR_GRAY2BGRA, 4);
        break;

      case ImageManipulationsActivity.VIEW_MODE_SEPIA:
        Core.transform(mRgba, mRgba, mSepiaKernel);
        break;

      case ImageManipulationsActivity.VIEW_MODE_ZOOM:
        if ((mZoomCorner == null)
            || (mZoomWindow == null)
            || (mRgba.cols() != mSizeRgba.width)
            || (mRgba.height() != mSizeRgba.height)) CreateAuxiliaryMats();
        Imgproc.resize(mZoomWindow, mZoomCorner, mZoomCorner.size());

        Size wsize = mZoomWindow.size();
        Core.rectangle(
            mZoomWindow,
            new Point(1, 1),
            new Point(wsize.width - 2, wsize.height - 2),
            new Scalar(255, 0, 0, 255),
            2);
        break;

      case ImageManipulationsActivity.VIEW_MODE_PIXELIZE:
        if ((mRgbaInnerWindow == null)
            || (mRgba.cols() != mSizeRgba.width)
            || (mRgba.height() != mSizeRgba.height)) CreateAuxiliaryMats();
        Imgproc.resize(mRgbaInnerWindow, mIntermediateMat, mSize0, 0.1, 0.1, Imgproc.INTER_NEAREST);
        Imgproc.resize(
            mIntermediateMat, mRgbaInnerWindow, mSizeRgbaInner, 0., 0., Imgproc.INTER_NEAREST);
        break;

      case ImageManipulationsActivity.VIEW_MODE_POSTERIZE:
        if ((mRgbaInnerWindow == null)
            || (mRgba.cols() != mSizeRgba.width)
            || (mRgba.height() != mSizeRgba.height)) CreateAuxiliaryMats();
        /*
        Imgproc.cvtColor(mRgbaInnerWindow, mIntermediateMat, Imgproc.COLOR_RGBA2RGB);
        Imgproc.pyrMeanShiftFiltering(mIntermediateMat, mIntermediateMat, 5, 50);
        Imgproc.cvtColor(mIntermediateMat, mRgbaInnerWindow, Imgproc.COLOR_RGB2RGBA);
        */

        Imgproc.Canny(mRgbaInnerWindow, mIntermediateMat, 80, 90);
        mRgbaInnerWindow.setTo(new Scalar(0, 0, 0, 255), mIntermediateMat);
        Core.convertScaleAbs(mRgbaInnerWindow, mIntermediateMat, 1. / 16, 0);
        Core.convertScaleAbs(mIntermediateMat, mRgbaInnerWindow, 16, 0);
        break;
    }

    return mRgba;
  }
  boolean decodeJPEGAndAnalyze(Context context, CalibrationEntries calibrationEntries) {
    boolean result = false;
    BitmapFactory.Options opt = new BitmapFactory.Options();
    opt.inPreferQualityOverSpeed = true;
    BitmapRegionDecoder brd;
    byte[] data = mData;
    try {
      brd = BitmapRegionDecoder.newInstance(data, 0, data.length, false);
      Rect rect;
      rect = new Rect(0, 0, brd.getWidth(), brd.getHeight());
      Bitmap bitmap = brd.decodeRegion(rect, opt);
      MatBitmapHolder mRgbaMatHolder = new MatBitmapHolder(bitmap);
      Mat rgbaMat = mRgbaMatHolder.pin();
      Mat grayData = new Mat();
      Imgproc.cvtColor(rgbaMat, grayData, Imgproc.COLOR_RGB2GRAY, 1);
      Mat centersCalibCircles = new Mat();

      Size patternSize = CalibrationEntries.Pattern_ASYMMETRIC_CIRCLES_GRID_SIZE;
      Size imageSize = new Size(grayData.cols(), grayData.rows());
      boolean patternWasFound =
          Calib3d.findCirclesGridDefault(
              grayData, patternSize, centersCalibCircles, Calib3d.CALIB_CB_ASYMMETRIC_GRID);

      if (patternWasFound && this.orientation != null) {
        int addedIdx = calibrationEntries.addEntry(this.orientation, centersCalibCircles);
        if (addedIdx >= 0) {
          Log.d(
              "CALIB",
              String.format(
                  "PictureCapture: Added calibration entry at %d tot: %d",
                  addedIdx, calibrationEntries.getNumEntries()));
          if (calibrationEntries.getNewlyAdded() > 5) {
            List<Mat> imagePoints = calibrationEntries.getPoints();
            List<Mat> objectPoints =
                calibrationEntries.getObjectPointsAsymmentricList(imagePoints.size());
            if (CalibrationEntries.isEnoughCalibrationPoints(imagePoints.size())) {
              calibrationEntries.resetNewlyAdded();
              CameraCalibrationData cameraCalibrationData = new CameraCalibrationData();
              List<Mat> rvecs = new Vector<Mat>(imagePoints.size());
              List<Mat> tvecs = new Vector<Mat>(imagePoints.size());
              int flags = 0;
              flags |= Calib3d.CALIB_FIX_K4 | Calib3d.CALIB_FIX_K5;
              Log.d("CALIB", String.format("PictureCapture: Calling Calib3d.calibrateCamera"));
              Mat K = new Mat();
              Mat kdist = new Mat();
              double rms =
                  Calib3d.calibrateCamera(
                      objectPoints, imagePoints, imageSize, K, kdist, rvecs, tvecs, flags);
              double[] Karray = new double[9];
              double[] distcoeffs_array = new double[5];
              K.get(0, 0, Karray);
              kdist.get(0, 0, distcoeffs_array);
              cameraCalibrationData.setData(
                  grayData.cols(), grayData.rows(), Karray, distcoeffs_array, rms);
              Log.d(
                  "CALIB",
                  String.format(
                      "PictureCapture: Calibration data: %s",
                      cameraCalibrationData.formatCalibrationDataString()));
              calibrationEntries.setCalibrationData(cameraCalibrationData);
              result = true;
            }
          }
        }
      }

      // mRightBitmap = brd.decodeRegion(rect, opt);
      rect = new Rect(brd.getWidth() - brd.getWidth() / 3, 0, brd.getWidth(), brd.getHeight());
      // mLeftBitmap = brd.decodeRegion(rect, opt);

      mRgbaMatHolder.unpin(rgbaMat);

    } catch (IOException e) {
      XLog.e("Region decoder doesn't want to cooperate", e);
    }

    return result;
  }
Пример #26
0
  public static void Circle(List<MatOfPoint> contours, int index) {
    int i = index;
    Mat mRGBA = new Mat();
    Utils.bitmapToMat(image, mRGBA);
    // cyklus s podmienkou na konci
    do {
      int buff[] = new int[4];
      hierarchy.get(0, i, buff);

      // Get contour form list
      Mat contour = contours.get(i);

      // id kont�ry
      int id = i;

      // dostaneme �a��ie id kont�ry
      i = buff[0];

      // zis�ujeme �i m�me dostato�ne ve�k� kont�ru aby sme sa �ou v�bec zaoberali
      if (Imgproc.contourArea(contour) > 500) {

        List<Point> points = new ArrayList<Point>();

        // dostaneme celkov� po�et kont�r
        int num = (int) contour.total();

        // vytvor�me si pole o dvojn�sobnej ve�kosti samotnej kontury
        int temp[] = new int[num * 2];

        // na��tame si kont�ru do do�asnej premennej
        contour.get(0, 0, temp);

        // konvertujeme  List<Point> do MatOfPoint2f pre pou�itie fitEllipse
        for (int j = 0; j < num * 2; j = j + 2) {
          points.add(new Point(temp[j], temp[j + 1]));
        }
        MatOfPoint2f specialPointMtx = new MatOfPoint2f(points.toArray(new Point[0]));

        // do premennej bound uklad�me dokonal� elipsu
        RotatedRect bound = Imgproc.fitEllipse(specialPointMtx);

        // Vypo��ta sa hodnota pi
        double pi =
            Imgproc.contourArea(contour) / ((bound.size.height / 2) * (bound.size.width / 2));

        // zis�ujeme toleranciu pi - zaoplenie
        if (Math.abs(pi - 3.14) > 0.03) {
          int k = buff[2];
          // zis�ujeme �i existuje nejak� rodi� kont�ry
          if (k != -1) {
            Circle(contours, k);
          }
          continue;
        }

        // konvertujeme MatOfPoint2f do MatOfPoint  pre funckiu fitEllipse - rozdie� je len v 32-bit
        // float a 32-bit int
        MatOfPoint NewMtx = new MatOfPoint(specialPointMtx.toArray());
        // dostaneme s�radnice najmen�ieho mo�n�ho �tvorca
        Rect box = Imgproc.boundingRect(NewMtx);
        // nacita obrazok znova
        Mat mat_for_count = new Mat();
        Utils.bitmapToMat(image, mat_for_count);
        // vytvori sa klon stvorca - dobry kandidat pre vyhladanie
        Mat candidate = ((mat_for_count).submat(box)).clone();
        // napln maticu binarnou ciernou
        Mat mask = new Mat(box.size(), candidate.type(), new Scalar(0, 0, 0));
        // naplni ciernu plochu bielimi konturami
        Imgproc.drawContours(
            mask,
            contours,
            id,
            new Scalar(255, 255, 255),
            -1,
            8,
            hierarchy,
            0,
            new Point(-box.x, -box.y));
        // ulozi sa kandidat
        Mat roi = new Mat(candidate.size(), candidate.type(), new Scalar(255, 255, 255));
        // ulozia sa len informacie o kandidatovi
        candidate.copyTo(roi, mask);

        double longAxis;
        double shortAxis;
        // ziska dve osy elipsy
        if (bound.size.height < bound.size.width) {
          shortAxis = bound.size.height / 2;
          longAxis = bound.size.width / 2;
        } else {
          shortAxis = bound.size.width / 2;
          longAxis = bound.size.height / 2;
        }

        // zastavi sa vyhladavanie pokial je elipsa prilis ovalna
        if ((longAxis / shortAxis) < 2.0) {
          signList.add(roi);
          boxList.add(box);
        }
      }
      // zis�uje sa �i je tam e�te �al�� kandid�t
    } while (i != -1);
  }
Пример #27
0
  /**
   * Extracts and classifies colour bands for each Resistor. Each ColourBand object is instantiated
   * and linked to their parent Resistor object.
   *
   * @param resistorList A list of Resistor objects from which to extract the colour bands
   * @param paintDebugInfo If ture, the extracted colour band ROIs are displayed on the GUI
   */
  private void extractColourBandsAndClassify(List<Resistor> resistorList, boolean paintDebugInfo) {
    if (resistorList.size() > 0) {
      for (int r = 0; r < resistorList.size(); r++) {
        Mat resImg = resistorList.get(r).resistorMat;

        Mat imgHSV = new Mat();
        Mat satImg = new Mat();
        Mat hueImg = new Mat();

        // convert to HSV
        Imgproc.cvtColor(resImg, imgHSV, Imgproc.COLOR_BGR2HSV);
        ArrayList<Mat> channels = new ArrayList<Mat>();
        Core.split(imgHSV, channels);
        // extract channels
        satImg = channels.get(1); // saturation
        hueImg = channels.get(0); // hue

        // threshold saturation channel
        Mat threshedROISatBands = new Mat(); // ~130 sat thresh val
        Imgproc.threshold(satImg, threshedROISatBands, SAT_BAND_THRESH, 255, Imgproc.THRESH_BINARY);

        // threshold hue channel
        Mat threshedROIHueBands = new Mat(); // ~50 hue thresh val
        Imgproc.threshold(hueImg, threshedROIHueBands, HUE_BAND_THRESH, 255, Imgproc.THRESH_BINARY);

        // combine the thresholded binary images
        Mat bandROI = new Mat();
        Core.bitwise_or(threshedROIHueBands, threshedROISatBands, bandROI);

        // find contours in binary ROI image
        ArrayList<MatOfPoint> contours = new ArrayList<MatOfPoint>();
        Mat hierarchy = new Mat();
        Imgproc.findContours(
            bandROI,
            contours,
            hierarchy,
            Imgproc.RETR_EXTERNAL,
            Imgproc.CHAIN_APPROX_SIMPLE,
            new Point(0, 0));

        // remove any remaining noise by only keeping contours which area > threshold
        for (int i = 0; i < contours.size(); i++) {
          double area = Imgproc.contourArea(contours.get(i));
          if (area < MIN_BAND_AREA) {
            contours.remove(i);
            i--;
          }
        }

        // create a ColourBand object for each detected band
        // storing its center, the contour and the bandROI
        for (int i = 0; i < contours.size(); i++) {
          MatOfPoint contour = contours.get(i);

          // extract this colour band and store in a Mat
          Rect boundingRect = Imgproc.boundingRect(contour);
          Mat mask = Mat.zeros(bandROI.size(), CvType.CV_8U);
          Imgproc.drawContours(mask, contours, i, new Scalar(255), Core.FILLED);
          Mat imageROI = new Mat();
          resImg.copyTo(imageROI, mask);
          Mat colourBandROI = new Mat(imageROI, boundingRect);

          // instantiate new ColourBand object
          ColourBand cb = new ColourBand(findCenter(contour), contour, colourBandROI);

          // cluster the band colour
          cb.clusterBandColour(BAND_COLOUR_K_MEANS);

          // classify using the Lab colourspace as feature vector
          Mat sampleMat =
              new Mat(1, 3, CvType.CV_32FC1); // create a Mat contacting the clustered band colour
          sampleMat.put(0, 0, cb.clusteredColourLAB[0]);
          sampleMat.put(0, 1, cb.clusteredColourLAB[1]);
          sampleMat.put(0, 2, cb.clusteredColourLAB[2]);
          Mat classifiedValue = new Mat(1, 1, CvType.CV_32FC1);
          Mat neighborResponses = new Mat(); // dont actually use this
          Mat dists = new Mat(); // dont actually use this
          // classify
          knn.find_nearest(sampleMat, 3, classifiedValue, neighborResponses, dists);

          // cast classified value into Colour enum and store
          cb.classifiedColour = ColourEnumVals[(int) classifiedValue.get(0, 0)[0]];
          // add the band to the parent resistor
          resistorList.get(r).bands.add(cb);
        }

        // paint the extracted band ROIs
        if (paintDebugInfo) {
          Mat finalBandROIMask = Mat.zeros(bandROI.size(), CvType.CV_8U);
          for (int i = 0; i < contours.size(); i++) {
            Scalar color = new Scalar(255, 255, 255);
            Imgproc.drawContours(
                finalBandROIMask, contours, i, color, -1, 4, hierarchy, 0, new Point());
          }
          Mat colourROI = new Mat();
          resImg.copyTo(colourROI, finalBandROIMask);
          paintResistorSubRegion(colourROI, r);
        }
      }
    }
  }
Пример #28
0
  public static void main(String[] args) {

    System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

    /** *** Configuration Variables **** */
    int imgWidth = 200;
    int imgHeight = 200;
    int numPatch = 2000;
    int patchWidth = 40;
    int patchHeight = 40;
    int k = 200; // kmeans number of center
    int numBins = 8;

    String filePathRed = "base/Red/";
    String filePathBlack = "base/Black";
    String procPathRed = "base/ProcRed";
    String procPathBlack = "base/ProcBlack";
    /** ******************************** */
    ArrayList<String> fileNames = new ArrayList<String>();

    sources = new ArrayList<Mat>();

    /* Image IO */
    try {

      /* Read Red Staplers */
      File folder = new File(filePathRed);
      BufferedImage currentImage;
      for (final File fileEntry : folder.listFiles()) {
        if (!fileEntry.isDirectory()) {

          // Resize Image
          currentImage = ImageProc.resize(ImageIO.read(fileEntry), imgWidth, imgHeight);

          File outFile = new File(procPathRed + "/" + fileEntry.getName());
          ImageIO.write(currentImage, "JPG", outFile);
          sources.add(Highgui.imread(outFile.getPath()));
          fileNames.add(outFile.getName());
        }
      }

      /* Read Black Staplers */
      folder = new File(filePathBlack);
      for (final File fileEntry : folder.listFiles()) {
        if (!fileEntry.isDirectory()) {

          // Resize Image
          currentImage = ImageProc.resize(ImageIO.read(fileEntry), imgWidth, imgHeight);

          File outFile = new File(procPathBlack + "/" + fileEntry.getName());
          ImageIO.write(currentImage, "JPG", outFile);
          sources.add(Highgui.imread(outFile.getPath()));
          fileNames.add(outFile.getName());
        }
      }

    } catch (IOException e) {
      e.printStackTrace();
    }

    /** ************************************* */
    float[] p1 = new float[30];
    float[] p2 = new float[30];

    /* Create Image Patches and calculate color feature vector for each patch */
    Iterator<Mat> imgIter = sources.iterator();
    Mat thisImage;
    Mat featureMat = new Mat();
    List<Mat> imagePatches = null;
    Iterator<Mat> patchIter = null;

    while (imgIter.hasNext()) {

      thisImage = imgIter.next();

      // Randomly Sample Patches
      imagePatches = ImageProc.sampleImage(thisImage, patchWidth, patchHeight, numPatch);
      patchIter = imagePatches.iterator();

      // Create color feature vector for each patch
      while (patchIter.hasNext()) {
        featureMat.push_back(ImageProc.calBGRFeature(patchIter.next(), numBins));
      }
    }

    Mat centers = new Mat();
    Mat bestLabels = new Mat();
    Core.kmeans(
        featureMat,
        k,
        bestLabels,
        new TermCriteria(TermCriteria.EPS, 0, Math.pow(10, -5)),
        0,
        Core.KMEANS_RANDOM_CENTERS,
        centers);

    MatOfFloat bestLabelRange = new MatOfFloat(0, k);

    ArrayList<Mat> centerHist = new ArrayList<Mat>();
    Mat centerHistMat = new Mat(0, k, CvType.CV_32FC1);

    imgIter = sources.listIterator();
    Iterator<String> nameIter = fileNames.iterator();

    int ptr = 0;
    int cnt = 0;

    // Output CSV

    try {
      File outCSV = new File("output/res.csv");
      FileWriter fstream = new FileWriter(outCSV);
      BufferedWriter out = new BufferedWriter(fstream);
      StringBuilder sb;
      out.write("@relation staplers\n");
      for (int n = 0; n < 200; n++) {
        out.write("@attribute " + "a" + n + " real\n");
      }

      out.write("@attribute class {RedStapler, BlackStapler}\n\n");
      out.write("@data\n\n");

      while (imgIter.hasNext()) {

        Mat thisMat = new Mat(bestLabels, new Range(ptr, ptr + numPatch), new Range(0, 1));
        Mat mat = new Mat();
        thisMat.convertTo(mat, CvType.CV_32F);

        ArrayList<Mat> bestLabelList = new ArrayList<Mat>();
        bestLabelList.add(mat);

        Mat thisHist = new Mat();
        Imgproc.calcHist(
            bestLabelList, new MatOfInt(0), new Mat(), thisHist, new MatOfInt(k), bestLabelRange);

        centerHist.add(thisHist);

        // Create file
        sb = new StringBuilder();

        float[] histArr = new float[(int) thisHist.total()];
        thisHist.get(0, 0, histArr);

        for (int m = 0; m < histArr.length; m++) {
          sb.append(histArr[m] + ",");
        }

        if (cnt++ < 10) sb.append("RedStapler");
        else sb.append("BlackStapler");

        sb.append("\n");
        out.write(sb.toString());
        // Close the output stream

        centerHistMat.push_back(thisHist.t());
        ptr += numPatch;
        imgIter.next();
      }

      out.close();
    } catch (IOException e) { // Catch exception if any
      System.err.println("Error: " + e.getMessage());
      System.exit(-1);
    }

    /* Support Vector Machine Validation */
    Mat labelMat = new Mat(sources.size(), 1, CvType.CV_32FC1);

    double[] labels = new double[20];
    for (int i = 0; i < 10; i++) {
      labels[i] = 1;
      labels[i + 10] = -1;
    }
    labelMat.put(0, 0, labels);

    CvSVMParams params = new CvSVMParams();
    params.set_kernel_type(CvSVM.LINEAR);

    CvSVM svm = new CvSVM();
    svm.train(centerHistMat, labelMat, new Mat(), new Mat(), params);
    svm.save("base/haha.txt");
    String basePath = "base/predict/";

    try {
      File testCSV = new File("output/test.arff");
      FileWriter testStream = new FileWriter(testCSV);
      BufferedWriter testOut = new BufferedWriter(testStream);

      testOut.write("@relation staplers\n");
      for (int n = 0; n < 200; n++) {
        testOut.write("@attribute " + "a" + n + " real\n");
      }

      testOut.write("@attribute class {RedStapler, BlackStapler}\n\n");
      testOut.write("@data\n\n");

      for (int m = 0; m < 21; m++) {

        // System.out.println(basePath + m + ".jpg");
        Mat testImg = Highgui.imread(basePath + m + ".jpg");

        List<Mat> patches = ImageProc.sampleImage(testImg, patchWidth, patchHeight, numPatch);
        List<Mat> features = new ArrayList<Mat>();

        for (int i = 0; i < patches.size(); i++) {

          Mat testVector = ImageProc.calBGRFeature(patches.get(i), numBins);
          features.add(testVector);
        }

        Mat testData = ImageProc.calFeatureVector(features, centers);

        StringBuilder testsb = new StringBuilder();
        // String name = nameIter.next();
        // sb.append(name + ",");

        float[] data = new float[testData.cols()];
        testData.get(0, 0, data);

        for (int o = 0; o < data.length; o++) {
          testsb.append(data[o] + ",");
        }
        if (m < 6) testsb.append("RedStapler");
        else testsb.append("BlackStapler");

        testsb.append("\n");
        testOut.write(testsb.toString());

        System.out.println("Img" + m + " " + svm.predict(testData));
      }
    } catch (IOException e) {
      e.printStackTrace();
      System.exit(-1);
    }
  }
Пример #29
0
  /** new algo */
  public static String findTips(Mat image) {
    Mat binary = new Mat();

    // Convert to B&W image
    Imgproc.threshold(image, binary, 0, 255, Imgproc.THRESH_BINARY);

    // Convert to binary image, 1 channel
    Imgproc.cvtColor(binary, binary, Imgproc.COLOR_RGB2GRAY);

    boolean flag_bg = false;
    boolean handInQuarterOfImg = false;
    int count_finger = 0;

    int start = -1;
    int end = -1;

    int tester = 0; // test variable CAN BE REMOVED

    double startPercent = 0, endPercent = 0;

    int leftHeight = -1;

    int firstHandPixel = -1;
    int lastHandPixel = -1;

    int KV_midFinger = -1;
    int KV_indxFinger = -1;

    double pixel[];
    for (int i = 0; i < binary.cols(); i++) {
      pixel = binary.get((int) (binary.rows() * 0.23), i);
      if (pixel[0] != 0.0) {
        if (firstHandPixel == -1) firstHandPixel = i;
        if (i < image.cols() / 4) handInQuarterOfImg = true;
        lastHandPixel = i;
        leftHeight = i;
      }

      if (pixel[0] != 0.0) {
        if (flag_bg == false) { // flag_bg is false
          count_finger++;
          flag_bg = true;

          start = i;
        }
        end = i;
      } else {
        if (count_finger == 1) KV_midFinger = end;
        else if (count_finger == 2) KV_indxFinger = start;
        flag_bg = false;
        if (tester != count_finger) { // remove this line -- just for
          // testing
          startPercent = ((double) start / (double) binary.cols()) * 100;
          endPercent = ((double) end / (double) binary.cols()) * 100;
        }
        tester = count_finger; // remove this line -- just for testing
      }
    }

    if (count_finger == 3) {
      if (endPercent > 80.0) {
        return "W";
      } else {
        return "F";
      }
    } else if (count_finger == 4) {
      return "B";
    } else if (count_finger == 1) {
      if (endPercent > 70.0)
        if (handInQuarterOfImg) return "B";
        else {
          int result = identify_R_U(binary);
          switch (result) {
            case 1:
              return "R";
            case 2:
              return "U";
            default:
              return " ";
              // return "RU";
          }
        }
      else {
        if ((float) (lastHandPixel - firstHandPixel) / image.cols() > 0.35) return "F";
        else {
          image = Filter.furtherClean(image);
          Mat binary2 = new Mat();
          // Convert to B&W image
          Imgproc.threshold(image, binary2, 0, 255, Imgproc.THRESH_BINARY);

          // Convert to binary image, 1 channel
          Imgproc.cvtColor(binary2, binary2, Imgproc.COLOR_RGB2GRAY);

          flag_bg = false;
          int countHandArea = 0;
          for (int i = 0; i < binary2.rows(); i++) {

            pixel = binary2.get(i, (int) (binary2.cols() * 0.70));

            if (pixel[0] != 0.0) {
              if (!flag_bg) {
                flag_bg = true;
                countHandArea++;
              }
            } else flag_bg = false;
          }
          if (countHandArea == 1) {
            if (checkAngleL(binary)) return "L";
            else {
              int result = identify_R_U(binary);
              switch (result) {
                case 1:
                  return "R";
                case 2:
                  return "U";
                default:
                  return " ";
              }
            }
          } else if (countHandArea == 2) return "D";
          else return " ";
        }
      }
    } else if (count_finger == 2) {
      // int result = identify_K_V(rgb, binary, new Point(KV_midFinger,
      // (int) (binary.rows() * 0.23)), new Point(KV_indxFinger,
      // (int) (binary.rows() * 0.23)));
      int startX = (int) KV_midFinger;
      int startY = (int) (binary.rows() * 0.23);
      int lastDir = 1; // 0 up; 1 down
      int currDir = 1;
      int ctr = 1;
      Point KV_PtsArray[] = new Point[3];
      KV_PtsArray[0] = new Point(startX, startY);
      // Core.circle(rgb,
      // new Point(UL.x + startX, UL.y + startY), 5,
      // new Scalar(0, 0, 255));
      // double pixel[];
      Log.i("START", "" + startX);
      Log.i("END", "" + startY);

      for (int i = startX; i < KV_indxFinger; i++) {

        for (int k = (int) (binary.rows() * 0.23); k < binary.rows(); k++) {

          pixel = binary.get(k, i + 1);
          Log.i("CHECK1", "" + binary.rows());
          Log.i("CHECK2", "" + binary.rows() * 0.23);
          Log.i("CHECK3", "" + (int) (binary.rows() * 0.23));
          Log.i("CHECK4", "" + pixel[0]);

          if (pixel[0] != 0.0) {
            // Plots the edges from hullPoint[0] to hullPoint[1]
            // Core.circle(rgb, new Point(UL.x + startX + 1,
            // UL.y
            // + k), 5, new Scalar(0, 255, 0));
            if (k > startY) currDir = 1;
            else if (k < startY) currDir = 0;
            if (currDir != lastDir && ctr < 3) {
              // Plots 3 significant pts in K and V
              // Core.circle(rgb,
              // new Point(UL.x + i + 1, UL.y + k), 5,
              // new Scalar(0, 0, 255));
              KV_PtsArray[ctr] = new Point(i + 1, k);
              ctr++;
            }
            lastDir = currDir;
            // startX = startX + 1;
            startY = k;
            break;
          }
        }

        if (ctr < 3 && i + 1 == (int) KV_indxFinger) {
          // Core.circle(rgb, new Point(UL.x + startX, UL.y + startY),
          // 5,
          // new Scalar(0, 0, 255));
          KV_PtsArray[ctr] = new Point(i, startY);
          ctr++;
        }

        if (ctr == 3) break;
      }

      if (ctr == 3) {
        if (KV_PtsArray[0].y == KV_PtsArray[2].y) return "V"; // V
        else return "K"; // K
      } else return " ";
    }
    return Integer.toString(count_finger);
  }
Пример #30
0
  // Bhattacharyya coefficient for two distributions
  // a, b are original data samples
  // better if a, b are dimension-reduced Principal Components
  public static double Bhattacharyya(Mat a, Mat b) {

    // if not dimension-reduced
    //		int k = a.cols()/2;
    //		Mat temp1 = new Mat();
    //		Mat temp2 = new Mat();
    //		Mat pa = new Mat();
    //		Mat pb = new Mat();
    //		Core.PCACompute(a, temp1, temp2, k);
    //		Core.PCAProject(a, temp1, temp2, pa);
    //		Core.PCACompute(b, temp1, temp2, k);
    //		Core.PCAProject(b, temp1, temp2, pb);
    //

    Mat cova = new Mat();
    Mat covb = new Mat();
    Mat meana = new Mat();
    Mat meanb = new Mat();
    Core.calcCovarMatrix(a, cova, meana, Core.COVAR_NORMAL | Core.COVAR_ROWS);
    Core.calcCovarMatrix(b, covb, meanb, Core.COVAR_NORMAL | Core.COVAR_ROWS);

    // if not dimension-reduced
    //		Core.calcCovarMatrix(pa, cova, meana, Core.COVAR_NORMAL|Core.COVAR_ROWS);
    //		Core.calcCovarMatrix(pb, covb, meanb, Core.COVAR_NORMAL|Core.COVAR_ROWS);

    //		System.out.println("cov");
    //		System.out.println(cova.dump());
    //		System.out.println(covb.dump());

    double detcova = Core.determinant(cova);
    double detcovb = Core.determinant(covb);
    Mat cov = new Mat();
    Core.add(cova, covb, cov);
    //		cov = cov.mul(cov, 0.5);

    //		Core.scaleAdd(cov, 0.5, new Mat(), cov);
    for (int i = 0; i < cov.rows(); i++)
      for (int j = 0; j < cov.cols(); j++) {
        cov.put(i, j, 0.5 * cov.get(i, j)[0]);
      }

    double detcov = Core.determinant(cov);

    Mat inv = new Mat(); // inverse of cov
    Core.invert(cov, inv);

    Mat mabsub = new Mat();
    Core.subtract(meana, meanb, mabsub);

    Mat mabsub_tp = new Mat();
    Core.transpose(mabsub, mabsub_tp);

    Mat temp = new Mat();
    Core.gemm(mabsub, inv, 1, new Mat(), 0, temp);
    //		System.out.println(temp.dump());
    //		System.out.println(mabsub_tp.dump());

    Mat res = new Mat();
    Core.gemm(temp, mabsub_tp, 1, new Mat(), 0, res);
    //		System.out.println(res.dump());

    //		Mat temp = mabsub_tp.mul(inv);
    //		System.out.println(temp.dump());
    //
    //		Mat res = temp.mul(mabsub);
    //		System.out.println(res.dump());

    double s2 = Math.sqrt(detcov / (Math.sqrt(detcova * detcovb)));
    // s1 = 0.125 * (mabsub_tp*inv*mabsub)
    double s1 = 0.125 * res.get(0, 0)[0];

    double bdis = 1 / (Math.exp(s1) * s2);
    return bdis;
  }