将矩形的四个点重新排序为正确的顺序

Question

纵横比=高度/宽度始终> 1(大多数情况下甚至> 2),因此我应该清楚/精确地如何旋转.

---

我RotatedRect在OpenCV/Java中有一个对象.
我可以得到一个数组,其中包含4个Point of Point和Point对象定义x/y值.

现在我想对这4个点进行排序,使得左上角是数组的第一个元素,然后是顺时针,所以上下点是第四个元素.

我假设矩形没有旋转太多(只是一些小角度),例如

我在示例中指出了哪个点我称为左上角(TL).

怎么做？

你不需要专门告诉我OpenCV等,只是假设你有两个数组

int[] x = new int[4];
int[] y = new int[4];

而n-th Point有坐标(x[n-1], y[n-1]).然后我可以自己为OpenCV做这件事.

Answer 1

回答

如果您知道，有一个非常简单的解决方案：

1. -45 < roundedRect.angle < 45
2. roundedRect.size.height > roundedRect.size.width

如果这是真的，那么按顺时针顺序排列的点将始终按以下顺序排列：

pts[0], pts[3], pts[2], pts[1]

顺便说一句，如果它不会对您的程序造成太大伤害，那么点将按逆时针顺序传递，从左上角开始……那么您就不必进行任何重新排序/排序。

其他情况：

• height > width && 135 < roundedRect.angle < 225
  
  • 从左上角开始的顺时针顺序是 2,3,0,1
  • 从左上角逆时针顺序是2,1,0,3。
• width > height && -135 < roundedRect.angle < -45
  • 从左上角开始的顺时针顺序是 3,2,1,0
  • 从左上角逆时针顺序是 3,0,1,2
• width > height && 45 < roundedRect.angle < 135
  • 从左上角开始的顺时针顺序是 1,0,3,2
  • 从左上角逆时针顺序是 1,2,3,0

其余情况都意味着矩形从左到右大于从上到下，这在您的场景中不会发生。此外，如果角度在这些范围之外，您可以连续添加或减去 360 度以获得这些范围之一中的角度。

解释

(tl;博士)

我们从 OpenCV 如何计算这些点的值中知道这一点。你可以通过一些实验来解决这个问题。这是我编写的一个小程序来演示它：

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;

import org.opencv.core.Point;
import org.opencv.core.RotatedRect;
import org.opencv.core.Size;

public class TestFrame extends JFrame {
    public static void main(String... args) {
        final TestFrame frame = new TestFrame();
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                frame.setVisible(true);
            }
        });
    }

    private RectComponent rect;

    public TestFrame() {
        JPanel containerPane = new JPanel(new BorderLayout());
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        rect = new RectComponent();
        containerPane.add(rect);
        setContentPane(containerPane);
        setSize(400,400);
        new Timer(100, rect).start();
    }

    public class RectComponent extends JComponent implements ActionListener {
        private RotatedRect rect = new RotatedRect(new Point(0,0), new Size(1, 3), 0);

        private final Point[] pts = new Point[4];

        @Override
        protected void paintComponent(Graphics g) {
            rect.points(pts);
            printPoints();
            Dimension size = getSize();
            drawRectLine(g, pts[0], pts[1], size);
            drawRectLine(g, pts[1], pts[2], size);
            drawRectLine(g, pts[2], pts[3], size);
            drawRectLine(g, pts[0], pts[3], size);
        }

        private void printPoints() {
            System.out.format("A: %d, TL: %s, TR: %s, BR: %s, BL%s%n",
                    (int) (rect.angle + (rect.angle < 0 ? -1e-6 : 1e-6)), // Stupid doubles, stupid rounding error
                    pointToString(pts[0]),
                    pointToString(pts[3]),
                    pointToString(pts[2]),
                    pointToString(pts[1]));
        }

        private String pointToString(Point p) {
            return String.format("{%.2f,%.2f}",p.x, p.y);
        }

        private void drawRectLine(Graphics g, Point left, Point right, Dimension size) {
            g.drawLine(scale(left.x, size.width), scale(left.y, size.height),
                    scale(right.x, size.width), scale(right.y, size.height));
        }


        private int scale(double value, int coord) {
            return (int) (value * coord) / 4 + coord / 2;
        }


        @Override
        public void actionPerformed(ActionEvent e) {
            rect.angle += 1;
            if(rect.angle > 44) rect.angle = -44;
            repaint();
        }
    }
}