Question

enter image description here

我的最终目标是有一个方法，让我们说：

Rectangle snapRects(Rectangle rec1, Rectangle rec2);

想象一下Rectangle有position，size和angle的信息。

将ABDE矩形拖放到BCGF矩形附近会调用方法，ABDE作为第一个参数，BCGF作为第二个参数，生成的矩形是一个与BCGF边缘对齐的矩形。

顶点不必匹配（并且最好不要匹配，因此捕捉不是那么严格）。

我只能轻易理解如何给出相同的角度，但位置变化对我来说非常困惑。此外，我相信即使我达成了一个解决方案，它也会得到很好的优化（资源成本过高），所以我很感激这方面的指导。

（已经有人问过，但没有给出满意的答案而忘记了这个问题。）

------------------------------------------------------------------

编辑：我的解释似乎不够，所以我会尽力澄清我的意愿：

下图显示了该方法的目标：

enter image description here

忘掉“最近的矩形”，想象一下只有两个矩形。矩形内的线条代表它们所面对的方向（角度的视觉辅助）。

有一个静态矩形，它不会被移动并且有一个角度（0-> 360），还有一个矩形（也有一个角度）我想要捕捉到最近边缘的静态矩形。通过这个，我的意思是，我希望最少的转换可能用于“捕捉到边缘”。

这会带来许多可能的情况，具体取决于矩形的旋转及其相对位置。

下一张图片显示静态矩形以及“To Snap”矩形的位置如何更改捕捉结果：

enter image description here

最后的旋转可能并不完美，因为它是由眼睛完成的，但是你得到了重点，重要的是相对位置以及两个角度。

现在，在我看来，这可能是完全天真的，我看到在转换“To Snap”矩形的两个重要且不同的步骤上解决了这个问题：定位和旋转

位置：新位置的目标是粘贴到最近的边缘，但由于我们希望它将并行方式固定到静态矩形，因此静态矩形的角度很重要。下图显示了定位的例子：

enter image description here

在这种情况下，静态矩形没有角度，因此很容易确定上，下，左和右。但是角度来看，还有更多的可能性：

enter image description here

对于旋转，目标是“捕捉”矩形旋转与静态矩形成为并列所需的最小：

enter image description here

作为最后一点，关于实现输入，目标是实际将“to snap”矩形拖动到我希望围绕静态矩形的任何位置，然后通过按键盘键，快照发生。

另外，当我要求优化时，我似乎已经夸大了一点，说实话我不需要或需要优化，我更喜欢一个易于阅读，一步一步的明确代码（如果是这样），而是比任何优化都要好。

我希望这次我很清楚，对不起第一名的不清楚，如果你有任何疑问，请问。

Answer 1

问题显然不明确：边缘的“排队”是什么意思？一个共同的起点（但不一定是一个共同的终点）？两个边缘的共同中心点？（这就是我现在的假设）。所有边缘应该匹配吗？决定第一个矩形的边缘应该与第二个矩形的边缘“匹配”的标准是什么？也就是说，想象一个正方形恰好包含另一个正方形边缘的中心点 - 那么它应该如何对齐呢？

（次要问题：优化（或“低资源成本”）到底有多远？）

然而，我写了几个第一行，也许这可以用来更清楚地指出预期的行为应该是什么 - 即通过说出预期的行为与实际行为有多远：

编辑：省略旧代码，根据澄清更新：

“攫取”的条件仍然不明确。例如，不清楚位置的变化或角度的变化是否应该是优选的。但诚然，我没有详细说明可能出现这个问题的所有可能情况。在任何情况下，根据更新的问题，这可能更接近您所寻找的。

注意：此代码既不“干净”也不特别优雅或高效。到目前为止的目标是找到一种能够提供“令人满意”结果的方法。优化和美化是可能的。

基本理念：

给定的是静态矩形r1，以及要捕捉的矩形，r0
计算应该拼接在一起的边缘。这分为两个步骤：
- 方法computeCandidateEdgeIndices1计算可以捕捉移动矩形的静态矩形的“候选边”（分别是它们的索引）。这基于以下标准：它检查移动矩形的多少个顶点（角）是特定边的右。例如，如果移动矩形的所有4个顶点都是边缘2的 right ，则边缘2将成为捕捉矩形的候选者。
- 由于可能存在相同数量的顶点可能为“右”的多个边，因此方法computeBestEdgeIndices计算其中心距移动矩形的任何边的中心的距离最小的候选边。返回相应边的索引
给定要捕捉的边的索引，计算这些边之间的角度。生成的矩形将是原始矩形，按此角度旋转。
将移动旋转的矩形，使捕捉的边缘的中心位于同一点

我用几种配置对此进行了测试，结果对我来说至少看起来“可行”。当然，这并不意味着它在所有情况下都能令人满意，但也许它可以作为一个起点。

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.awt.geom.AffineTransform;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;


public class RectangleSnap
{
    public static void main(String[] args)
    {
        SwingUtilities.invokeLater(new Runnable()
        {
            @Override
            public void run()
            {
                createAndShowGUI();
            }
        });
    }

    private static void createAndShowGUI()
    {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        RectangleSnapPanel panel = new RectangleSnapPanel();
        f.getContentPane().add(panel);

        f.setSize(1000,1000);
        f.setLocationRelativeTo(null);
        f.setVisible(true);
    }
}

class SnapRectangle
{
    private Point2D position;
    private double sizeX;
    private double sizeY;
    private double angleRad;

    private AffineTransform at;


    SnapRectangle(
        double x, double y, 
        double sizeX, double sizeY, double angleRad)
    {
        this.position = new Point2D.Double(x,y);
        this.sizeX = sizeX;
        this.sizeY = sizeY;
        this.angleRad = angleRad;

        at = AffineTransform.getRotateInstance(
            angleRad, position.getX(), position.getY());
    }

    double getAngleRad()
    {
        return angleRad;
    }

    double getSizeX()
    {
        return sizeX;
    }

    double getSizeY()
    {
        return sizeY;
    }

    Point2D getPosition()
    {
        return position;
    }

    void draw(Graphics2D g)
    {
        Color oldColor = g.getColor();

        Rectangle2D r = new Rectangle2D.Double(
            position.getX(),  position.getY(), sizeX,  sizeY);
        AffineTransform at = AffineTransform.getRotateInstance(
            angleRad, position.getX(), position.getY());
        g.draw(at.createTransformedShape(r));

        g.setColor(Color.RED);
        for (int i=0; i<4; i++)
        {
            Point2D c = getCorner(i);
            Ellipse2D e = new Ellipse2D.Double(c.getX()-3, c.getY()-3, 6, 6);
            g.fill(e);
            g.drawString(""+i, (int)c.getX(), (int)c.getY()+15);
        }

        g.setColor(Color.GREEN);
        for (int i=0; i<4; i++)
        {
            Point2D c = getEdgeCenter(i);
            Ellipse2D e = new Ellipse2D.Double(c.getX()-3, c.getY()-3, 6, 6);
            g.fill(e);
            g.drawString(""+i, (int)c.getX(), (int)c.getY()+15);
        }

        g.setColor(oldColor);
    }

    Point2D getCorner(int i)
    {
        switch (i)
        {
            case 0:
                return new Point2D.Double(position.getX(), position.getY());
            case 1:
            {
                Point2D.Double result = new Point2D.Double(
                    position.getX(), position.getY()+sizeY);
                return at.transform(result, null);
            }
            case 2:
            {
                Point2D.Double result = new Point2D.Double
                    (position.getX()+sizeX, position.getY()+sizeY);
                return at.transform(result, null);
            }
            case 3:
            {
                Point2D.Double result = new Point2D.Double(
                    position.getX()+sizeX, position.getY());
                return at.transform(result, null);
            }
        }
        return null;
    }

    Line2D getEdge(int i)
    {
        Point2D p0 = getCorner(i); 
        Point2D p1 = getCorner((i+1)%4);
        return new Line2D.Double(p0, p1);
    }

    Point2D getEdgeCenter(int i)
    {
        Point2D p0 = getCorner(i); 
        Point2D p1 = getCorner((i+1)%4);
        Point2D c = new Point2D.Double(
            p0.getX() + 0.5 * (p1.getX() - p0.getX()),
            p0.getY() + 0.5 * (p1.getY() - p0.getY()));
        return c;
    }

    void setPosition(double x, double y)
    {
        this.position.setLocation(x, y);
        at = AffineTransform.getRotateInstance(
            angleRad, position.getX(), position.getY());
    }
}


class RectangleSnapPanel extends JPanel implements MouseMotionListener
{
    private final SnapRectangle rectangle0;
    private final SnapRectangle rectangle1;
    private SnapRectangle snappedRectangle0;

    RectangleSnapPanel()
    {
        this.rectangle0 = new SnapRectangle(
            200, 300, 250, 200, Math.toRadians(-21));
        this.rectangle1 = new SnapRectangle(
            500, 300, 200, 150, Math.toRadians(36));
        addMouseMotionListener(this);
    }

    @Override
    protected void paintComponent(Graphics gr)
    {
        super.paintComponent(gr);
        Graphics2D g = (Graphics2D)gr;

        g.setColor(Color.BLACK);
        rectangle0.draw(g);
        rectangle1.draw(g);
        if (snappedRectangle0 != null)
        {
            g.setColor(Color.BLUE);
            snappedRectangle0.draw(g);
        }
    }

    @Override
    public void mouseDragged(MouseEvent e)
    {
        rectangle0.setPosition(e.getX(), e.getY());

        snappedRectangle0 = snapRects(rectangle0, rectangle1);

        repaint();
    }

    @Override
    public void mouseMoved(MouseEvent e)
    {
    }


    private static SnapRectangle snapRects(
        SnapRectangle r0, SnapRectangle r1)
    {
        List<Integer> candidateEdgeIndices1 = 
            computeCandidateEdgeIndices1(r0, r1);

        int bestEdgeIndices[] = computeBestEdgeIndices(
            r0, r1, candidateEdgeIndices1);

        int bestEdgeIndex0 = bestEdgeIndices[0];
        int bestEdgeIndex1 = bestEdgeIndices[1];

        System.out.println("Best to snap "+bestEdgeIndex0+" to "+bestEdgeIndex1);

        Line2D bestEdge0 = r0.getEdge(bestEdgeIndex0);
        Line2D bestEdge1 = r1.getEdge(bestEdgeIndex1);
        double edgeAngle = angleRad(bestEdge0, bestEdge1);
        double rotationAngle = edgeAngle;

        if (rotationAngle <= Math.PI)
        {
            rotationAngle = Math.PI + rotationAngle;
        }
        else if (rotationAngle <= -Math.PI / 2)
        {
            rotationAngle = Math.PI + rotationAngle;
        }
        else if (rotationAngle >= Math.PI)
        {
            rotationAngle = -Math.PI + rotationAngle;
        }

        SnapRectangle result = new SnapRectangle(
            r0.getPosition().getX(), r0.getPosition().getY(), 
            r0.getSizeX(), r0.getSizeY(), r0.getAngleRad()-rotationAngle);

        Point2D edgeCenter0 = result.getEdgeCenter(bestEdgeIndex0);
        Point2D edgeCenter1 = r1.getEdgeCenter(bestEdgeIndex1);
        double dx = edgeCenter1.getX() - edgeCenter0.getX();
        double dy = edgeCenter1.getY() - edgeCenter0.getY();
        result.setPosition(
            r0.getPosition().getX()+dx,
            r0.getPosition().getY()+dy);

        return result;
    }

    // Compute for the edge indices for r1 in the given list
    // the one that has the smallest distance to any edge
    // of r0, and return this pair of indices
    private static int[] computeBestEdgeIndices(
        SnapRectangle r0, SnapRectangle r1,
        List<Integer> candidateEdgeIndices1)
    {
        int bestEdgeIndex0 = -1;
        int bestEdgeIndex1 = -1;
        double minCenterDistance = Double.MAX_VALUE;
        for (int i=0; i<candidateEdgeIndices1.size(); i++)
        {
            int edgeIndex1 = candidateEdgeIndices1.get(i);
            for (int edgeIndex0=0; edgeIndex0<4; edgeIndex0++)
            {
                Point2D p0 = r0.getEdgeCenter(edgeIndex0);
                Point2D p1 = r1.getEdgeCenter(edgeIndex1);
                double distance = p0.distance(p1);
                if (distance < minCenterDistance)
                {
                    minCenterDistance = distance;
                    bestEdgeIndex0 = edgeIndex0;
                    bestEdgeIndex1 = edgeIndex1;
                }
            }
        }
        return new int[]{ bestEdgeIndex0, bestEdgeIndex1 };
    }

    // Compute the angle, in radians, between the given lines,
    // in the range (-2*PI, 2*PI)
    private static double angleRad(Line2D line0, Line2D line1)
    {
        double dx0 = line0.getX2() - line0.getX1();
        double dy0 = line0.getY2() - line0.getY1();
        double dx1 = line1.getX2() - line1.getX1();
        double dy1 = line1.getY2() - line1.getY1();
        double a0 = Math.atan2(dy0, dx0);
        double a1 = Math.atan2(dy1, dx1);
        return (a0 - a1) % (2 * Math.PI);
    }

    // In these methods, "right" refers to screen coordinates, which 
    // unfortunately are upside down in Swing. Mathematically, 
    // these relation is "left"

    // Compute the "candidate" edges of r1 to which r0 may
    // be snapped. These are the edges to which the maximum
    // number of corners of r0 are right of 
    private static List<Integer> computeCandidateEdgeIndices1(
        SnapRectangle r0, SnapRectangle r1)
    {
        List<Integer> bestEdgeIndices = new ArrayList<Integer>();
        int maxRight = 0;
        for (int i=0; i<4; i++)
        {
            Line2D e1 = r1.getEdge(i);
            int right = countRightOf(e1, r0);
            if (right > maxRight)
            {
                maxRight = right;
                bestEdgeIndices.clear();
                bestEdgeIndices.add(i);
            }
            else if (right == maxRight)
            {
                bestEdgeIndices.add(i);
            }
        }
        //System.out.println("Candidate edges "+bestEdgeIndices);
        return bestEdgeIndices;
    }

    // Count the number of corners of the given rectangle
    // that are right of the given line
    private static int countRightOf(Line2D line, SnapRectangle r)
    {
        int count = 0;
        for (int i=0; i<4; i++)
        {
            if (isRightOf(line, r.getCorner(i)))
            {
                count++;
            }
        }
        return count;
    }

    // Returns whether the given point is right of the given line
    // (referring to the actual line *direction* - not in terms 
    // of coordinates in 2D!)
    private static boolean isRightOf(Line2D line, Point2D point)
    {
        double d00 = line.getX1() - point.getX();
        double d01 = line.getY1() - point.getY();
        double d10 = line.getX2() - point.getX();
        double d11 = line.getY2() - point.getY();
        return d00 * d11 - d10 * d01 > 0;
    }

}

捕捉边缘效应

1 个答案: