Android OpenCV Найти самый большой квадрат или прямоугольник

На это можно было ответить, но я отчаянно нуждаюсь в ответе за это. Я хочу найти самый большой квадрат или прямоугольник в изображении с помощью OpenCV в Android. Все решения, которые я нашел, это С++, и я попытался преобразовать его, но он не работает, и я не знаю, где я ошибаюсь.

private Mat findLargestRectangle(Mat original_image) {
    Mat imgSource = original_image;

    Imgproc.cvtColor(imgSource, imgSource, Imgproc.COLOR_BGR2GRAY);
    Imgproc.Canny(imgSource, imgSource, 100, 100);

    //I don't know what to do in here

    return imgSource;
}

То, что я пытаюсь сделать здесь, - создать новое изображение, основанное на самом большом квадрате, найденном в исходном изображении (возвращаемое значение Mat image).

Это то, что я хочу:

1 http://img14.imageshack.us/img14/7855/s7zr.jpg

Также хорошо, что я просто получаю четыре точки самого большого квадрата, и я думаю, что могу взять его оттуда. Но было бы лучше, если бы я мог просто вернуть обрезанное изображение.

ОТВЕТЫ

Ответ 1

После canny

1- вам нужно уменьшить шум с помощью гауссовского размытия и найти все контуры

2- найдите и перечислите все области контуров.

3 - самый большой контур будет только картиной.

4- теперь используйте преобразование перспективы, чтобы преобразовать фигуру в прямоугольник.

проверьте примеры решения sudoku, чтобы увидеть аналогичную проблему обработки. (наибольший контур + перспектива)

Ответ 2

Мне понадобилось некоторое время, чтобы преобразовать код С++ в Java, но вот он: -)

Внимание! Исходный код, полностью не оптимизированный и все.

Я отказываюсь от какой-либо ответственности в случае травмы или смертельной аварии

    List<MatOfPoint> squares = new ArrayList<MatOfPoint>();

    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {

        if (Math.random()>0.80) {

            findSquares(inputFrame.rgba().clone(),squares);

        }

        Mat image = inputFrame.rgba();

        Imgproc.drawContours(image, squares, -1, new Scalar(0,0,255));

        return image;
    }

    int thresh = 50, N = 11;

 // helper function:
 // finds a cosine of angle between vectors
 // from pt0->pt1 and from pt0->pt2
    double angle( Point pt1, Point pt2, Point pt0 ) {
            double dx1 = pt1.x - pt0.x;
            double dy1 = pt1.y - pt0.y;
            double dx2 = pt2.x - pt0.x;
            double dy2 = pt2.y - pt0.y;
            return (dx1*dx2 + dy1*dy2)/Math.sqrt((dx1*dx1 + dy1*dy1)*(dx2*dx2 + dy2*dy2) + 1e-10);
    }

 // returns sequence of squares detected on the image.
 // the sequence is stored in the specified memory storage
 void findSquares( Mat image, List<MatOfPoint> squares )
 {

     squares.clear();

     Mat smallerImg=new Mat(new Size(image.width()/2, image.height()/2),image.type());

     Mat gray=new Mat(image.size(),image.type());

     Mat gray0=new Mat(image.size(),CvType.CV_8U);

     // down-scale and upscale the image to filter out the noise
     Imgproc.pyrDown(image, smallerImg, smallerImg.size());
     Imgproc.pyrUp(smallerImg, image, image.size());

     // find squares in every color plane of the image
     for( int c = 0; c < 3; c++ )
     {

         extractChannel(image, gray, c);

         // try several threshold levels
         for( int l = 1; l < N; l++ )
         {
             //Cany removed... Didn't work so well


             Imgproc.threshold(gray, gray0, (l+1)*255/N, 255, Imgproc.THRESH_BINARY);


             List<MatOfPoint> contours=new ArrayList<MatOfPoint>();

             // find contours and store them all as a list
             Imgproc.findContours(gray0, contours, new Mat(), Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_SIMPLE);

             MatOfPoint approx=new MatOfPoint();

             // test each contour
             for( int i = 0; i < contours.size(); i++ )
             {

                 // approximate contour with accuracy proportional
                 // to the contour perimeter
                 approx = approxPolyDP(contours.get(i),  Imgproc.arcLength(new MatOfPoint2f(contours.get(i).toArray()), true)*0.02, true);


                 // square contours should have 4 vertices after approximation
                 // relatively large area (to filter out noisy contours)
                 // and be convex.
                 // Note: absolute value of an area is used because
                 // area may be positive or negative - in accordance with the
                 // contour orientation

                 if( approx.toArray().length == 4 &&
                     Math.abs(Imgproc.contourArea(approx)) > 1000 &&
                     Imgproc.isContourConvex(approx) )
                 {
                     double maxCosine = 0;

                     for( int j = 2; j < 5; j++ )
                     {
                         // find the maximum cosine of the angle between joint edges
                         double cosine = Math.abs(angle(approx.toArray()[j%4], approx.toArray()[j-2], approx.toArray()[j-1]));
                         maxCosine = Math.max(maxCosine, cosine);
                     }

                     // if cosines of all angles are small
                     // (all angles are ~90 degree) then write quandrange
                     // vertices to resultant sequence
                     if( maxCosine < 0.3 )
                         squares.add(approx);
                 }
             }
         }
     }
 }

 void extractChannel(Mat source, Mat out, int channelNum) {
     List<Mat> sourceChannels=new ArrayList<Mat>();
     List<Mat> outChannel=new ArrayList<Mat>();

     Core.split(source, sourceChannels);

     outChannel.add(new Mat(sourceChannels.get(0).size(),sourceChannels.get(0).type()));

     Core.mixChannels(sourceChannels, outChannel, new MatOfInt(channelNum,0));

     Core.merge(outChannel, out);
 }

 MatOfPoint approxPolyDP(MatOfPoint curve, double epsilon, boolean closed) {
     MatOfPoint2f tempMat=new MatOfPoint2f();

     Imgproc.approxPolyDP(new MatOfPoint2f(curve.toArray()), tempMat, epsilon, closed);

     return new MatOfPoint(tempMat.toArray());
 }

Ответ 3

В SO есть некоторые связанные вопросы. Проверьте их:

Также есть пример, поставляемый с OpenCV:

Как только у вас есть прямоугольник, вы можете выровнять изображение, вычислив гомографию с углами прямоугольника и применив перспективное преобразование.