Méthode Java pour trouver le rectangle qui est l'intersection de deux rectangles en utilisant seulement le point inférieur gauche, la largeur et la hauteur?

J'ai trouvé la solution, mais voulait s'assurer que ma logique est la plus efficace. Je sens qu'il ya une meilleure façon. J'ai l' (x,y) les coordonnées du coin inférieur gauche, la hauteur et la largeur de 2 rectangles, et j'ai besoin de revenir un troisième rectangle qui est leur point d'intersection. Je ne veux pas poster le code que je ressens c'est de la triche.

- Je savoir qui est le plus à gauche et plus haut sur le graphique.
- Je vérifier si l'on recouvre complètement l'autre, et l'inverse pour voir si l'autre recouvre complètement la première sur l'axe des X.
- Je vérifier pour une partie d'intersection sur l'axe des X.
En gros, j'ai répétez les étapes 2 et 3 pour l'axe des Y.
Je fais un peu de maths et obtenir les points du rectangle en fonction de ces conditions.

J'ai peut-être plus de cette pensée et de l'écriture inefficace code. J'ai déjà tourné dans un programme de travail, mais aimerait trouver la meilleure façon pour mes propres connaissances. Si quelqu'un pouvait soit d'accord ou me diriger dans la bonne direction, ce serait génial!

source d'informationauteur Doug B

16

Pourquoi ne pas utiliser le JDK API pour le faire pour vous?
```
Rectangle rect1 = new Rectangle(100, 100, 200, 240);
Rectangle rect2 = new Rectangle(120, 80, 80, 120);
Rectangle intersection = rect1.intersection(rect2);
```
À utiliser java.awt.Rectangle classe, les paramètres du constructeur sont les suivantes: x, y, largeur, hauteur, dans laquelle x, y du coin supérieur gauche du rectangle. Vous pouvez facilement convertir les bas-point à gauche à en haut à gauche.

Je recommande ci-dessus, mais si vous voulez vraiment le faire vous-même, vous pouvez suivre les étapes ci-dessous:

dire (x1, y1), (x2, y2) sont en bas à gauche et en bas à droite de Rect1 respectivement,
(x3, y3), (x4, y4) sont ceux de Rect2.
- trouver le plus grand de x1x3 et la plus petite de x2x4dire xL
  xR respectivement
  - si xL >= xRpuis retour pas d'intersection d'autre
- trouver le plus grand de y1y3 et la plus petite de y2y4dire yT
  yB respectivement
  - si yT >= yBpuis retour pas d'intersection d'autre
  - retour (xL, yB, xR-xL, yB-yT).
Plus Java-comme le pseudo-code:
```
//Two rectangles, assume the class name is `Rect`
Rect r1 = new Rect(x1, y2, w1, h1);
Rect r2 = new Rect(x3, y4, w2, h2);

//get the coordinates of other points needed later:
int x2 = x1 + w1;
int x4 = x3 + w2;
int y1 = y2 - h1;
int y3 = y4 - h2;

//find intersection:
int xL = Math.max(x1, x3);
int xR = Math.min(x2, x4);
if (xR <= xL)
    return null;
else {
    int yT = Math.max(y1, y3);
    int yB = Math.min(y2, y4);
    if (yB <= yT)
        return null;
    else
        return new Rect(xL, yB, xR-xL, yB-yT);
}
```
Comme vous le voyez, si votre rectangle a été défini à l'origine par deux diagonales coins, il sera plus facile, il vous suffit de faire la //find intersection partie.

Accepté la réponse est incorrecte. Voici ma version, ce qui est correct.

N'utilisez pas la accepté de répondre.

//returns true when intersection is found, false otherwise.
//when returning true, rectangle 'out' holds the intersection of r1 and r2.
private static boolean intersection2(Rectangle r1, Rectangle r2,
        Rectangle out) {
    float xmin = Math.max(r1.x, r2.x);
    float xmax1 = r1.x + r1.width;
    float xmax2 = r2.x + r2.width;
    float xmax = Math.min(xmax1, xmax2);
    if (xmax > xmin) {
        float ymin = Math.max(r1.y, r2.y);
        float ymax1 = r1.y + r1.height;
        float ymax2 = r2.y + r2.height;
        float ymax = Math.min(ymax1, ymax2);
        if (ymax > ymin) {
            out.x = xmin;
            out.y = ymin;
            out.width = xmax - xmin;
            out.height = ymax - ymin;
            return true;
        }
    }
    return false;
}

Vous pouvez également utiliser le Rectangle de code source pour comparer avec votre propre algorithme:

/**
 * Computes the intersection of this <code>Rectangle</code> with the
 * specified <code>Rectangle</code>. Returns a new <code>Rectangle</code>
 * that represents the intersection of the two rectangles.
 * If the two rectangles do not intersect, the result will be
 * an empty rectangle.
 *
 * @param     r   the specified <code>Rectangle</code>
 * @return    the largest <code>Rectangle</code> contained in both the
 *            specified <code>Rectangle</code> and in
 *            this <code>Rectangle</code>; or if the rectangles
 *            do not intersect, an empty rectangle.
 */
public Rectangle intersection(Rectangle r) {
    int tx1 = this.x;
    int ty1 = this.y;
    int rx1 = r.x;
    int ry1 = r.y;
    long tx2 = tx1; tx2 += this.width;
    long ty2 = ty1; ty2 += this.height;
    long rx2 = rx1; rx2 += r.width;
    long ry2 = ry1; ry2 += r.height;
    if (tx1 < rx1) tx1 = rx1;
    if (ty1 < ry1) ty1 = ry1;
    if (tx2 > rx2) tx2 = rx2;
    if (ty2 > ry2) ty2 = ry2;
    tx2 -= tx1;
    ty2 -= ty1;
    //tx2,ty2 will never overflow (they will never be
    //larger than the smallest of the two source w,h)
    //they might underflow, though...
    if (tx2 < Integer.MIN_VALUE) tx2 = Integer.MIN_VALUE;
    if (ty2 < Integer.MIN_VALUE) ty2 = Integer.MIN_VALUE;
    return new Rectangle(tx1, ty1, (int) tx2, (int) ty2);
}

Vous devez vous connecter pour publier un commentaire.