Berechnen der Bounding-box-Koordinaten aus einem gedrehten Rechteck

• Transformieren die Koordinaten aller vier Ecken
• Finden Sie die kleinste von allen vier x als min_x
• Finden Sie die größte aller vier x und nennen es max_x
• Dito mit der y
• Ihre bounding box ist (min_x,min_y), (min_x,max_y), (max_x,max_y), (max_x,min_y)

AFAIK, es gibt keine königliche Straße ist, das Sie es viel schneller.

Wenn Sie sich Fragen, wie eine Transformation der Koordinaten, versuchen Sie:

x2 = x0+(x-x0)*cos(theta)+(y-y0)*sin(theta)
y2 = y0-(x-x0)*sin(theta)+(y-y0)*cos(theta)

wo (x0,y0) ist das Zentrum, um das Sie rotieren. Sie müssen möglicherweise basteln mit diesem je nach trigonometrischen Funktionen (erwarten Sie Grad oder Radiant) der Sinn /Zeichen Ihrer Koordinatensystem gegenüber, wie Sie angeben, Winkel, etc.

InformationsquelleAutor MarkusQ

Die beschriebene Methode von MarkusQ perfekt funktioniert, aber Bedenken Sie, dass Sie nicht brauchen, um zu transformieren, werden die anderen drei Ecken, wenn Sie Punkt A bereits.

Eine alternative Methode, die effizienter ist, ist zu prüfen, welche Quadranten Sie Ihre Rotationswinkel und dann einfach berechnen Sie die Antwort direkt. Dies ist effizienter, da Sie nur eine worst-case von zwei if-Anweisungen (überprüfung der Winkel), während in dem anderen Ansatz hat ein schlimmsten Fall der zwölf (6) für jede Komponente bei der Kontrolle der anderen drei Ecken zu sehen, wenn Sie größer als der aktuelle max oder kleiner als der aktuelle min), denke ich.

Den grundlegenden Algorithmus, der verwendet nichts anderes als eine Reihe von Anwendungen des Satz des Pythagoras, wird unten angezeigt. Ich habe bezeichnet den Rotationswinkel von theta und äußerte die Prüfung in Grad, wie es pseudo-code.

ct = cos( theta );
st = sin( theta );

hct = h * ct;
wct = w * ct;
hst = h * st;
wst = w * st;

if ( theta > 0 )
{
    if ( theta < 90 )
    {
        //0 < theta < 90
        y_min = A_y;
        y_max = A_y + hct + wst;
        x_min = A_x - hst;
        x_max = A_x + wct;
    }
    else
    {
        //90 <= theta <= 180
        y_min = A_y + hct;
        y_max = A_y + wst;
        x_min = A_x - hst + wct;
        x_max = A_x;
    }
}
else
{
    if ( theta > -90 )
    {
        //-90 < theta <= 0
        y_min = A_y + wst;
        y_max = A_y + hct;
        x_min = A_x;
        x_max = A_x + wct - hst;
    }
    else
    {
        //-180 <= theta <= -90
        y_min = A_y + wst + hct;
        y_max = A_y;
        x_min = A_x + wct;
        x_max = A_x - hst;
    }
}

Diesem Ansatz wird davon ausgegangen, dass Sie haben, was Sie sagen, Sie haben also den Punkt A, und einen Wert für theta, der sich in den Bereich [-180, 180]. Ich habe auch angenommen, dass die theta-Zunahmen im Uhrzeigersinn, wie das ist, was Sie das Rechteck, das gedreht ist, um 30 Grad in dein Diagramm scheint zu zeigen, die Sie verwenden, ich war nicht sicher, was das Teil auf der rechten Seite wurde versucht, zu bezeichnen. Wenn dies der falsche Weg, um dann nur die swap-symmetrischen Klauseln und auch das Schild von den st-Bedingungen.

InformationsquelleAutor Troubadour

wenn Sie mithilfe von GDI+ , die Sie erstellen können eine neue GrpaphicsPath -> Fügen Sie keine Punkte oder Formen -> Anwenden drehen transformation -> verwenden GraphicsPath.GetBounds() und wird es wieder ein Rechteck, die Grenzen Ihrer gedrehten Form.

(Bearbeiten) VB.Net Beispiel

Public Shared Sub RotateImage(ByRef img As Bitmap, degrees As Integer)
' http://stackoverflow.com/questions/622140/calculate-bounding-box-coordinates-from-a-rotated-rectangle-picture-inside#680877
'
Using gp As New GraphicsPath
  gp.AddRectangle(New Rectangle(0, 0, img.Width, img.Height))

  Dim translateMatrix As New Matrix
  translateMatrix.RotateAt(degrees, New PointF(img.Width \ 2, img.Height \ 2))
  gp.Transform(translateMatrix)

  Dim gpb = gp.GetBounds

  Dim newwidth = CInt(gpb.Width)
  Dim newheight = CInt(gpb.Height)

  ' http://www.codeproject.com/Articles/58815/C-Image-PictureBox-Rotations
  '
  Dim rotatedBmp As New Bitmap(newwidth, newheight)

  rotatedBmp.SetResolution(img.HorizontalResolution, img.VerticalResolution)

  Using g As Graphics = Graphics.FromImage(rotatedBmp)
    g.Clear(Color.White)
    translateMatrix = New Matrix
    translateMatrix.Translate(newwidth \ 2, newheight \ 2)
    translateMatrix.Rotate(degrees)
    translateMatrix.Translate(-img.Width \ 2, -img.Height \ 2)
    g.Transform = translateMatrix
    g.DrawImage(img, New PointF(0, 0))
  End Using
  img.Dispose()
  img = rotatedBmp
End Using

End Sub

InformationsquelleAutor Bishoy

/**
     * Applies the given transformation matrix to the rectangle and returns
     * a new bounding box to the transformed rectangle.
     */
    public static function getBoundsAfterTransformation(bounds:Rectangle, m:Matrix):Rectangle {
        if (m == null) return bounds;

        var topLeft:Point = m.transformPoint(bounds.topLeft);
        var topRight:Point = m.transformPoint(new Point(bounds.right, bounds.top));
        var bottomRight:Point = m.transformPoint(bounds.bottomRight);
        var bottomLeft:Point = m.transformPoint(new Point(bounds.left, bounds.bottom));

        var left:Number = Math.min(topLeft.x, topRight.x, bottomRight.x, bottomLeft.x);
        var top:Number = Math.min(topLeft.y, topRight.y, bottomRight.y, bottomLeft.y);
        var right:Number = Math.max(topLeft.x, topRight.x, bottomRight.x, bottomLeft.x);
        var bottom:Number = Math.max(topLeft.y, topRight.y, bottomRight.y, bottomLeft.y);
        return new Rectangle(left, top, right - left, bottom - top);
    }

InformationsquelleAutor Nick Bilyk

Hier sind drei Funktionen von meinem open-source-Bibliotheken. Die Funktionen sind vollständig getestet in Java, aber die Formeln können leicht übersetzt werden zu jeder Sprache.

Die Signaturen sind:

public static float getAngleFromPoint(letzten Punkt, dem Mittelpunkt, Endpunkt touchPoint)

public static float getTwoFingerDistance(float firstTouchX, float firstTouchY, float secondTouchX, float secondTouchY)

Punkt getPointFromAngle(final double angle, final double radius)

Dieser Lösung wird davon ausgegangen, dass die pixel-Dichte ist gleichmäßig verteilt.
Vor dem drehen des Objekts führen Sie die folgenden:

1. Verwenden getAngleFromPoint zur Berechnung der Winkel von der Mitte der oberen rechten Ecke (können sagen, dieser liefert 20 Grad), was bedeutet, dass die upp linken Ecke ist -20 Grad und 340 Grad.

2. Verwenden Sie die getTwoFingerDistance die Rückkehr der Diagonale Abstand zwischen dem Mittelpunkt und der rechten oberen Ecke (sollte dieser Abstand obvoiusly werden die gleichen für alle Ecken Dieser Abstand wird bei der nächsten Berechnung).

3. Können nun sagen, wir drehen das Objekt im Uhrzeigersinn um 30 Grad. Wir wissen jetzt, dass die oberen rechten Ecke werden müssen, bei 50 Grad, und die Obere linken Ecke ist mit 10 Grad.

4. Sollten Sie nun in der Lage sein zu verwenden, die getPointFromAngle Funktion auf der oberen linken und oberen rechten Ecke. mit dem radius zurück aus Schritt 2.
   Die X-position, multipliziert mit 2 aus der oberen rechten Ecke sollten Sie die neue Breite und die Y-position mal 2 von der oberen linken Ecke geben sollte, der die neue Höhe.

Diese oben genannten 4 Schritte sollten gesetzt werden zu Bedingungen, basierend auf, wie weit Sie sich gedreht haben Ihr Objekt andere weisen, die Sie zurückgeben kann die Höhe als die Breite und die Breite als die Höhe.

Bare daran, die Winkel-Funktionen ausgedrückt werden, in der Faktoren von 0-1, anstatt 0-360 (einfach multiplizieren oder dividieren von 360 gegebenenfalls):

//Wird ein Winkel von zwei Punkten ausgedrückt als ein Faktor 0 -1 (0 0/360, 0.25 als 90 Grad etc)

public float getAngleFromPoint(final Point centerPoint, final Point touchPoint) {

    float returnVal = 0;

    //+0 - 0.5
    if(touchPoint.x > centerPoint.x) {

        returnVal = (float) (Math.atan2((touchPoint.x - centerPoint.x), (centerPoint.y - touchPoint.y)) * 0.5 / Math.PI);

    }
    //+0.5
    else if(touchPoint.x < centerPoint.x) {

        returnVal = (float) (1 - (Math.atan2((centerPoint.x - touchPoint.x), (centerPoint.y - touchPoint.y)) * 0.5 / Math.PI));

    }//End if(touchPoint.x > centerPoint.x)

    return returnVal;

}

//Misst die Diagonale Entfernung zwischen zwei Punkten

public float getTwoFingerDistance(final float firstTouchX, final float firstTouchY, final float secondTouchX, final float secondTouchY) {

    float pinchDistanceX = 0;
    float pinchDistanceY = 0;

    if(firstTouchX > secondTouchX) {

        pinchDistanceX = Math.abs(secondTouchX - firstTouchX);

    }
    else if(firstTouchX < secondTouchX) {

        pinchDistanceX = Math.abs(firstTouchX - secondTouchX);

    }//End if(firstTouchX > secondTouchX)

    if(firstTouchY > secondTouchY) {

        pinchDistanceY = Math.abs(secondTouchY - firstTouchY);

    }
    else if(firstTouchY < secondTouchY) {

        pinchDistanceY = Math.abs(firstTouchY - secondTouchY);

    }//End if(firstTouchY > secondTouchY)

    if(pinchDistanceX == 0 && pinchDistanceY == 0) {

        return 0;

    }
    else {

        pinchDistanceX = (pinchDistanceX * pinchDistanceX);
        pinchDistanceY = (pinchDistanceY * pinchDistanceY);
        return (float) Math.abs(Math.sqrt(pinchDistanceX + pinchDistanceY));

    }//End if(pinchDistanceX == 0 && pinchDistanceY == 0)

}

//XY-Koordinaten aus einem Winkel in einem gegebenen radius (Der Winkel, ausgedrückt in einem Faktor 0-1 0 0/360 Grad und 0,75 als 270 etc)

public Point getPointFromAngle(final double angle, final double radius) {

    final Point coords = new Point();
    coords.x = (int) (radius * Math.sin((angle) * 2 * Math.PI));
    coords.y = (int) -(radius * Math.cos((angle) * 2 * Math.PI));

    return coords;

}

Diese code-Schnipsel sind aus meiner open-source-Bibliotheken: https://bitbucket.org/warwick/hgdialrepo und https://bitbucket.org/warwick/hacergestov2.
Die eine ist eine Geste-Bibliothek für Android-und der andere ist ein dial-Steuerung für Android. Es ist auch ein OpenGLES 2.0-Implementierung von der regler: https://bitbucket.org/warwick/hggldial

InformationsquelleAutor user2288580

Ich verwendet-Region für das Erste drehen des Rechtecks, und verwenden Sie dann gedreht region zu erkennen, Rechteck

        r = new Rectangle(new Point(100, 200), new Size(200, 200));         
        Color BorderColor = Color.WhiteSmoke;
        Color FillColor = Color.FromArgb(66, 85, 67);
        int angle = 13;
        Point pt = new Point(r.X, r.Y);
        PointF rectPt = new PointF(r.Left + (r.Width / 2),
                               r.Top + (r.Height / 2));
       //declare myRegion globally 
        myRegion = new Region(r);

        //Create a transform matrix and set it to have a 13 degree

        //rotation.
        Matrix transformMatrix = new Matrix();
        transformMatrix.RotateAt(angle, pt);

        //Apply the transform to the region.
        myRegion.Transform(transformMatrix);
        g.FillRegion(Brushes.Green, myRegion);
        g.ResetTransform();

nun zu erkennen, dass Rechteck

        private void panel_MouseMove(object sender, MouseEventArgs e)
    {


        Point point = e.Location;
        if (myRegion.IsVisible(point, _graphics))
        {
            //The point is in the region. Use an opaque brush.
            this.Cursor = Cursors.Hand;
        }
        else {
            this.Cursor = Cursors.Cross;
        }

    }

InformationsquelleAutor Abdulrehman