Wie zeichnet man eine, die die Perspektive Korrigieren-Gitter in 2D

Ich habe eine Anwendung, die definiert, eine Reale Welt Rechteck auf einem Bild/Foto, natürlich in 2D kann es nicht sein, ein Rechteck, denn Sie betrachten es aus einem Winkel.

Das problem ist, sagen, dass das Rechteck muss Gitterlinien gezeichnet ist, zum Beispiel, wenn es 3x5, also muss ich zeichnen 2 Linien von Seite 1 zu Seite 3, und 4 Zeilen von Seite 2 auf Seite 4.

Ab jetzt bin ich brechen jede Zeile in äquidistante Teile, um die start-und end-Punkt aller Linien des Rasters. Doch je mehr von einem Winkel, das Rechteck ist, desto mehr "falsche" diese Zeilen, werden als horizontale Linien weiter aus, Sie sollten näher zusammen.

Kennt jemand den Namen des Algorithmus, den ich suchen sollte?

Ja, ich weiß, Sie können dies tun, in 3D, allerdings bin ich beschränkt auf 2D für diese spezielle Anwendung.

So ein Beispiel könnte sein, zu versuchen, ziehen Sie ein Rechteck auf ein Fenster in ein Bild?
ja, das wäre ein Beispiel
hatten Sie kein Glück mit diesem Projekt? Ich brauche etwas, das sehr ähnlich! danke

InformationsquelleAutor Neil N | 2009-02-09

15

Hier ist die Lösung:
http://freespace.virgin.net/hugo.elias/graphics/x_persp.htm

Die Grundidee ist, finden Sie die richtige Perspektive "Zentrum" des Rechtecks durch das verbinden der Ecken Diagonal. Der Schnittpunkt der beiden resultierenden Linien ist Ihre Perspektive korrigieren Zentrum. Von dort werden Sie unterteilen das Rechteck in vier kleinere Rechtecke, und wiederholen Sie den Vorgang. Die Anzahl der Zeiten hängt davon ab, wie genau Sie es wollen. Sie können unterteilen, um nur unterhalb der Größe eines pixels, um effektiv perfekte Perspektive.

Dann in Ihre subrectangles Sie nur Ihre standard-unkorrigiert "strukturierte" Dreiecke, oder Rechtecke oder was auch immer.

Können Sie führen Sie diesen Algorithmus, ohne auf die komplexen Probleme des Aufbaus einer 'echten' 3d-Welt. es ist auch gut, denn wenn Sie tun haben eine echte 3d-Welt modelliert, sondern Ihre textriangles nicht die Perspektive korrigiert werden, die in hardware oder benötigen Sie einen leistungsfähigen Weg, um perspektivisch korrekte Flugzeuge ohne pro-pixel-rendering-Tricks.

Würde diese Lösung funktionieren nur für Netze, die eine Potenz von 2?
Ich nehme an, so, aber, wenn Sie ein anständig genug, Mathematiker, wahrscheinlich könnte man ableiten, eine nicht-lineare transformation die matrix spiegelt die gleiche Beziehung zwischen Quell-und Ziel-Pixel. Ich bin nicht so der Mathematiker, aber ich zumindest wissen, die magischen Worte zu untersuchen, und nun, so tun Sie.
Hier ein aktualisierter link, der funktioniert: web.archive.org/web/20160413080849/http://freespace.virgin.net/...

InformationsquelleAutor Breton

Wie zeichnet man eine, die die Perspektive Korrigieren-Gitter in 2D
Bild: Beispiel für eine Bilineare & Sicht-Transformation (Hinweis: Die Höhe der oberen & unteren horizontalen grid-Linien tatsächlich die Hälfte der übrigen Linien Höhe, auf beide Zeichnungen)

========================================

Ich weiß, das ist eine alte Frage, aber ich habe eine generische Lösung, so dass ich beschloss, es zu veröffentlichen-hopping, es wird nützlich sein, um den zukünftigen Lesern.
Der code Balg ziehen können eine beliebige Perspektive Netz ohne die Notwendigkeit von sich wiederholenden Berechnungen.

Beginne ich eigentlich mit einem ähnlichen problem: zeichnen Sie eine 2D-Perspektive, Netz-und dann verwandeln Sie das unterstreichen-image zum wiederherstellen der Perspektive.

Ich begann zu Lesen, hier:
http://www.imagemagick.org/Usage/distorts/#bilinear_forward

und dann hier (die Bibliothek Leptonica):
http://www.leptonica.com/affine.html

waren, fand ich dies:

Aussehen, wenn Sie auf ein Objekt in einer Ebene, aus einer willkürlichen Richtung auf
eine endliche Entfernung, bekommen Sie einen zusätzlichen "keystone" Verzerrung in der
Bild. Dies ist eine projektive Transformation, die dafür sorgt, gerade Linien
gerade, aber nicht die Erhaltung der Winkel zwischen den Linien. Dieses verziehen
kann nicht beschrieben werden, durch eine lineare affine transformation, und in der Tat
unterscheidet sich von x - und y-abhängigen terms im Nenner.

Ist die transformation nicht linear, wie viele Menschen bereits darauf hingewiesen, in diesem thread. Es beinhaltet die Lösung eines linearen system von 8 Gleichungen (einmalig) berechnen Sie die 8 benötigten Koeffizienten und dann können Sie Sie zu verwandeln, so viele Punkte wie Sie wollen.

Zu vermeiden, einschließlich aller Leptonica Bibliothek in mein Projekt, ich nahm ein paar Stücke von code, das ich entfernt alle speziellen Leptonica Datentypen & Makros, ich reparierte einige Speicherlecks und ich baute es zu einer C++ - Klasse (meist aus Gründen der Kapselung), die nicht nur eine einzige Sache:
Es ordnet ein (Qt) QPointF float - (x,y) - Koordinate in der entsprechenden Perspektive zu Koordinieren.

Wenn Sie anpassen möchten, den code zu einem anderen C++ - Bibliothek, das einzige, was neu zu definieren/ersetzen ist die QPointF koordinieren Klasse.

Ich hoffe, dass auch zukünftige Leser würden es nützlich finden.
Der code unten wird in 3 Teile unterteilt:

A. Ein Beispiel dafür, wie die genImageProjective C++ - Klasse zum zeichnen eines 2D-Perspektive Grid

B. genImageProjective.h-Datei

C. genImageProjective.cpp Datei

//============================================================
//C++ Code Example on how to use the 
//    genImageProjective class to draw a perspective 2D Grid
//============================================================

#include "genImageProjective.h"

//Input: 4 Perspective-Tranformed points:
//       perspPoints[0] = top-left
//       perspPoints[1] = top-right
//       perspPoints[2] = bottom-right
//       perspPoints[3] = bottom-left
void drawGrid(QPointF *perspPoints)
{
(...)
        //Setup a non-transformed area rectangle
        //I use a simple square rectangle here because in this case we are not interested in the source-rectangle,
        // (we want to just draw a grid on the perspPoints[] area)
        //  but you can use any arbitrary rectangle to perform a real mapping to the perspPoints[] area
        QPointF topLeft = QPointF(0,0);
        QPointF topRight = QPointF(1000,0);
        QPointF bottomRight = QPointF(1000,1000);
        QPointF bottomLeft = QPointF(0,1000);
        float width = topRight.x() - topLeft.x();
        float height = bottomLeft.y() - topLeft.y();

        //Setup Projective trasform object
        genImageProjective imageProjective;
        imageProjective.sourceArea[0] = topLeft;
        imageProjective.sourceArea[1] = topRight;
        imageProjective.sourceArea[2] = bottomRight;
        imageProjective.sourceArea[3] = bottomLeft;
        imageProjective.destArea[0] = perspPoints[0];
        imageProjective.destArea[1] = perspPoints[1];
        imageProjective.destArea[2] = perspPoints[2];
        imageProjective.destArea[3] = perspPoints[3];
        //Compute projective transform coefficients
        if (imageProjective.computeCoeefficients() != 0)
            return; //This can actually fail if any 3 points of Source or Dest are colinear

        //Initialize Grid parameters (without transform)
        float gridFirstLine = 0.1f; //The normalized position of first Grid Line (0.0 to 1.0)
        float gridStep = 0.1f;      //The normalized Grd size (=distance between grid lines: 0.0 to 1.0)

        //Draw Horizonal Grid lines
        QPointF lineStart, lineEnd, tempPnt;
        for (float pos = gridFirstLine; pos <= 1.0f; pos += gridStep)
        {
            //Compute Grid Line Start
            tempPnt = QPointF(topLeft.x(), topLeft.y() + pos*width);
            imageProjective.mapSourceToDestPoint(tempPnt, lineStart);
            //Compute Grid Line End
            tempPnt = QPointF(topRight.x(), topLeft.y() + pos*width);
            imageProjective.mapSourceToDestPoint(tempPnt, lineEnd);

            //Draw Horizontal Line (use your prefered method to draw the line)
            (...)
        }
        //Draw Vertical Grid lines
        for (float pos = gridFirstLine; pos <= 1.0f; pos += gridStep)
        {
            //Compute Grid Line Start
            tempPnt = QPointF(topLeft.x() + pos*height, topLeft.y());
            imageProjective.mapSourceToDestPoint(tempPnt, lineStart);
            //Compute Grid Line End
            tempPnt = QPointF(topLeft.x() + pos*height, bottomLeft.y());
            imageProjective.mapSourceToDestPoint(tempPnt, lineEnd);

            //Draw Vertical Line (use your prefered method to draw the line)
            (...)
        }
(...)
}

==========================================



//========================================
//C++ Header File: genImageProjective.h
//========================================

#ifndef GENIMAGE_H
#define GENIMAGE_H

#include <QPointF>

//Class to transform an Image Point using Perspective transformation
class genImageProjective
{
public:
    genImageProjective();

    int computeCoeefficients(void);
    int mapSourceToDestPoint(QPointF& sourcePoint, QPointF& destPoint);

public:
    QPointF sourceArea[4]; //Source Image area limits (Rectangular)
    QPointF destArea[4];   //Destination Image area limits (Perspectivelly Transformed)

private:
    static int gaussjordan(float  **a, float  *b, int n);

    bool coefficientsComputed;
    float vc[8];           //Vector of Transform Coefficients
};

#endif //GENIMAGE_H
//========================================


//========================================
//C++ CPP File: genImageProjective.cpp
//========================================

#include <math.h>
#include "genImageProjective.h"

//----------------------------------------------------
//class genImageProjective
//----------------------------------------------------
genImageProjective::genImageProjective()
{
    sourceArea[0] = sourceArea[1] = sourceArea[2] = sourceArea[3] = QPointF(0,0);
    destArea[0] = destArea[1] = destArea[2] = destArea[3] = QPointF(0,0);
    coefficientsComputed = false;
}


//--------------------------------------------------------------
//Compute projective transform coeeeficients
//RetValue: 0: Success, !=0: Error
/*-------------------------------------------------------------*
 *                Projective coordinate transformation         *
 *-------------------------------------------------------------*/
/*!
 *  computeCoeefficients()
 *
 *      Input:  this->sourceArea[4]: (source 4 points; unprimed)
 *              this->destArea[4]:   (transformed 4 points; primed)
 *              this->vc  (computed vector of transform coefficients)
 *      Return: 0 if OK; <0 on error
 *
 *  We have a set of 8 equations, describing the projective
 *  transformation that takes 4 points (sourceArea) into 4 other
 *  points (destArea).  These equations are:
 *
 *          x1' = (c[0]*x1 + c[1]*y1 + c[2]) /(c[6]*x1 + c[7]*y1 + 1)
 *          y1' = (c[3]*x1 + c[4]*y1 + c[5]) /(c[6]*x1 + c[7]*y1 + 1)
 *          x2' = (c[0]*x2 + c[1]*y2 + c[2]) /(c[6]*x2 + c[7]*y2 + 1)
 *          y2' = (c[3]*x2 + c[4]*y2 + c[5]) /(c[6]*x2 + c[7]*y2 + 1)
 *          x3' = (c[0]*x3 + c[1]*y3 + c[2]) /(c[6]*x3 + c[7]*y3 + 1)
 *          y3' = (c[3]*x3 + c[4]*y3 + c[5]) /(c[6]*x3 + c[7]*y3 + 1)
 *          x4' = (c[0]*x4 + c[1]*y4 + c[2]) /(c[6]*x4 + c[7]*y4 + 1)
 *          y4' = (c[3]*x4 + c[4]*y4 + c[5]) /(c[6]*x4 + c[7]*y4 + 1)
 *
 *  Multiplying both sides of each eqn by the denominator, we get
 *
 *           AC = B
 *
 *  where B and C are column vectors
 *
 *         B = [ x1' y1' x2' y2' x3' y3' x4' y4' ]
 *         C = [ c[0] c[1] c[2] c[3] c[4] c[5] c[6] c[7] ]
 *
 *  and A is the 8x8 matrix
 *
 *             x1   y1     1     0   0    0   -x1*x1'  -y1*x1'
 *              0    0     0    x1   y1   1   -x1*y1'  -y1*y1'
 *             x2   y2     1     0   0    0   -x2*x2'  -y2*x2'
 *              0    0     0    x2   y2   1   -x2*y2'  -y2*y2'
 *             x3   y3     1     0   0    0   -x3*x3'  -y3*x3'
 *              0    0     0    x3   y3   1   -x3*y3'  -y3*y3'
 *             x4   y4     1     0   0    0   -x4*x4'  -y4*x4'
 *              0    0     0    x4   y4   1   -x4*y4'  -y4*y4'
 *
 *  These eight equations are solved here for the coefficients C.
 *
 *  These eight coefficients can then be used to find the mapping
 *  (x,y) --> (x',y'):
 *
 *           x' = (c[0]x + c[1]y + c[2]) /(c[6]x + c[7]y + 1)
 *           y' = (c[3]x + c[4]y + c[5]) /(c[6]x + c[7]y + 1)
 *
 */
int genImageProjective::computeCoeefficients(void)
{
    int retValue = 0;
    int     i;
    float  *a[8];  /* 8x8 matrix A  */
    float  *b = this->vc; /* rhs vector of primed coords X'; coeffs returned in vc[] */

    b[0] = destArea[0].x();
    b[1] = destArea[0].y();
    b[2] = destArea[1].x();
    b[3] = destArea[1].y();
    b[4] = destArea[2].x();
    b[5] = destArea[2].y();
    b[6] = destArea[3].x();
    b[7] = destArea[3].y();

    for (i = 0; i < 8; i++)
        a[i] = NULL;
    for (i = 0; i < 8; i++)
    {
        if ((a[i] = (float *)calloc(8, sizeof(float))) == NULL)
        {
            retValue = -100; //ERROR_INT("a[i] not made", procName, 1);
            goto Terminate;
        }
    }

    a[0][0] = sourceArea[0].x();
    a[0][1] = sourceArea[0].y();
    a[0][2] = 1.;
    a[0][6] = -sourceArea[0].x() * b[0];
    a[0][7] = -sourceArea[0].y() * b[0];
    a[1][3] = sourceArea[0].x();
    a[1][4] = sourceArea[0].y();
    a[1][5] = 1;
    a[1][6] = -sourceArea[0].x() * b[1];
    a[1][7] = -sourceArea[0].y() * b[1];
    a[2][0] = sourceArea[1].x();
    a[2][1] = sourceArea[1].y();
    a[2][2] = 1.;
    a[2][6] = -sourceArea[1].x() * b[2];
    a[2][7] = -sourceArea[1].y() * b[2];
    a[3][3] = sourceArea[1].x();
    a[3][4] = sourceArea[1].y();
    a[3][5] = 1;
    a[3][6] = -sourceArea[1].x() * b[3];
    a[3][7] = -sourceArea[1].y() * b[3];
    a[4][0] = sourceArea[2].x();
    a[4][1] = sourceArea[2].y();
    a[4][2] = 1.;
    a[4][6] = -sourceArea[2].x() * b[4];
    a[4][7] = -sourceArea[2].y() * b[4];
    a[5][3] = sourceArea[2].x();
    a[5][4] = sourceArea[2].y();
    a[5][5] = 1;
    a[5][6] = -sourceArea[2].x() * b[5];
    a[5][7] = -sourceArea[2].y() * b[5];
    a[6][0] = sourceArea[3].x();
    a[6][1] = sourceArea[3].y();
    a[6][2] = 1.;
    a[6][6] = -sourceArea[3].x() * b[6];
    a[6][7] = -sourceArea[3].y() * b[6];
    a[7][3] = sourceArea[3].x();
    a[7][4] = sourceArea[3].y();
    a[7][5] = 1;
    a[7][6] = -sourceArea[3].x() * b[7];
    a[7][7] = -sourceArea[3].y() * b[7];

    retValue = gaussjordan(a, b, 8);

Terminate:
    //Clean up
    for (i = 0; i < 8; i++)
    {
        if (a[i])
            free(a[i]);
    }

    this->coefficientsComputed = (retValue == 0);
    return retValue;
}


/*-------------------------------------------------------------*
 *               Gauss-jordan linear equation solver           *
 *-------------------------------------------------------------*/
/*
 *  gaussjordan()
 *
 *      Input:   a  (n x n matrix)
 *               b  (rhs column vector)
 *               n  (dimension)
 *      Return:  0 if ok, 1 on error
 *
 *      Note side effects:
 *            (1) the matrix a is transformed to its inverse
 *            (2) the vector b is transformed to the solution X to the
 *                linear equation AX = B
 *
 *      Adapted from "Numerical Recipes in C, Second Edition", 1992
 *      pp. 36-41 (gauss-jordan elimination)
 */
#define  SWAP(a,b)   {temp = (a); (a) = (b); (b) = temp;}
int genImageProjective::gaussjordan(float  **a, float  *b, int n)
{
    int retValue = 0;
    int i, icol=0, irow=0, j, k, l, ll;
    int *indexc = NULL, *indexr = NULL, *ipiv = NULL;
    float  big, dum, pivinv, temp;

    if (!a)
    {
        retValue = -1; //ERROR_INT("a not defined", procName, 1);
        goto Terminate;
    }
    if (!b)
    {
        retValue = -2; //ERROR_INT("b not defined", procName, 1);
        goto Terminate;
    }

    if ((indexc = (int *)calloc(n, sizeof(int))) == NULL)
    {
        retValue = -3; //ERROR_INT("indexc not made", procName, 1);
        goto Terminate;
    }
    if ((indexr = (int *)calloc(n, sizeof(int))) == NULL)
    {
        retValue = -4; //ERROR_INT("indexr not made", procName, 1);
        goto Terminate;
    }
    if ((ipiv = (int *)calloc(n, sizeof(int))) == NULL)
    {
        retValue = -5; //ERROR_INT("ipiv not made", procName, 1);
        goto Terminate;
    }

    for (i = 0; i < n; i++)
    {
        big = 0.0;
        for (j = 0; j < n; j++)
        {
            if (ipiv[j] != 1)
            {
                for (k = 0; k < n; k++)
                {
                    if (ipiv[k] == 0)
                    {
                        if (fabs(a[j][k]) >= big)
                        {
                            big = fabs(a[j][k]);
                            irow = j;
                            icol = k;
                        }
                    }
                    else if (ipiv[k] > 1)
                    {
                        retValue = -6; //ERROR_INT("singular matrix", procName, 1);
                        goto Terminate;
                    }
                }
            }
        }
        ++(ipiv[icol]);

        if (irow != icol)
        {
            for (l = 0; l < n; l++)
                SWAP(a[irow][l], a[icol][l]);
            SWAP(b[irow], b[icol]);
        }

        indexr[i] = irow;
        indexc[i] = icol;
        if (a[icol][icol] == 0.0)
        {
            retValue = -7; //ERROR_INT("singular matrix", procName, 1);
            goto Terminate;
        }
        pivinv = 1.0 /a[icol][icol];
        a[icol][icol] = 1.0;
        for (l = 0; l < n; l++)
            a[icol][l] *= pivinv;
        b[icol] *= pivinv;

        for (ll = 0; ll < n; ll++)
        {
            if (ll != icol)
            {
                dum = a[ll][icol];
                a[ll][icol] = 0.0;
                for (l = 0; l < n; l++)
                    a[ll][l] -= a[icol][l] * dum;
                b[ll] -= b[icol] * dum;
            }
        }
    }

    for (l = n - 1; l >= 0; l--)
    {
        if (indexr[l] != indexc[l])
        {
            for (k = 0; k < n; k++)
                SWAP(a[k][indexr[l]], a[k][indexc[l]]);
        }
    }

Terminate:
    if (indexr)
        free(indexr);
    if (indexc)
        free(indexc);
    if (ipiv)
        free(ipiv);
    return retValue;
}


//--------------------------------------------------------------
//Map a source point to destination using projective transform
//--------------------------------------------------------------
//Params:
// sourcePoint: initial point
// destPoint:   transformed point
//RetValue: 0: Success, !=0: Error
//--------------------------------------------------------------
// Notes:
//  1. You must call once computeCoeefficients() to compute
//     the this->vc[] vector of 8 coefficients, before you call
//     mapSourceToDestPoint().
//  2. If there was an error or the 8 coefficients were not computed,
//     a -1 is returned and destPoint is just set to sourcePoint value.
//--------------------------------------------------------------
int genImageProjective::mapSourceToDestPoint(QPointF& sourcePoint, QPointF& destPoint)
{
    if (coefficientsComputed)
    {
        float factor = 1.0f /(vc[6] * sourcePoint.x() + vc[7] * sourcePoint.y() + 1.);
        destPoint.setX( factor * (vc[0] * sourcePoint.x() + vc[1] * sourcePoint.y() + vc[2]) );
        destPoint.setY( factor * (vc[3] * sourcePoint.x() + vc[4] * sourcePoint.y() + vc[5]) );
        return 0;
    }
    else //There was an error while computing coefficients
    {
        destPoint = sourcePoint; //just copy the source to destination...
        return -1;               //...and return an error
    }
}
//========================================

Sie scheinen zu beschreiben, projektive Transformationen, oder homographies. OpenCV-Bibliothek (C++, Java, Python), zum Beispiel, hat Funktionen zu schätzen verwandelt, und Sie zu verwenden.
Danke für die info. Ich war eigentlich denken, & Experimentieren mit OpenCV irgendwann in der Zukunft, so dass dies eine zusätzliche Motivation, es zu tun.
Also, wenn keine zwei Kanten kollinear, diese Lösung funktioniert. Wenn jede Kante ist kollinear mit dem gegenüber, finde ich eine affine transformation. Aber was ist, wenn ein paar von Kanten kollinear, und ein paar nicht? Wie soll ich es machen?
die Lösung, die ich oben dargestellt, funktioniert im Fall, den Sie beschreiben. Es funktioniert auch, wenn die beiden Rand-Paare sind colinear (d.h. in einem normalen Rechteck Fall) aber in diesem letzteren Fall wird eine lineare ransformation 😉 (PS: ich gehe davon aus, dass durch die 'kollinearer' du meinst parallel. Wenn Sie eigentlich kollinear, liefern Sie bitte eine Zeichnung, denn das ist jenseits meiner Vorstellungskraft)
Ich bin sehr Leid, ich hatte einen Fehler in meiner eigenen Implementierung gaussjordan(), die fehlgeschlagen, wenn zwei Kanten parallel ... ich habe es behoben und es funktioniert jetzt 🙂 BTW. Ich benutze es zum transformieren eines Fotos, Benutzer können ziehen Sie jede Ecke des Bildes einzeln 🙂 i.imgur.com/tCDfhZx.png

InformationsquelleAutor Fivos Vilanakis

4

Während mein google-fu hat, konnte nicht produzieren jede solide mathematische Lösung, vielleicht ist diese Zeichnung, die ich fand konnte dir ein wenig helfen.

http://studiochalkboard.evansville.edu/lp-diminish.html

Ich denke, es könnte tatsächlich ziemlich schwierig zu kommen mit der richtigen Mathematik auf Ihre eigene, es ist wahrscheinlich eine Art von logarithmischer oder Summierung Ausdruck. Hoffentlich ist die Zeichnung und der Bezug zu diesem link, könnte etwas ein wenig mehr durchsuchbar für Sie.

Danke, dass ist wirklich sehr wertvoll. Ihre Google-Fähigkeiten sind definitiv vor mir.

InformationsquelleAutor Cheese Daneish
3

Mit Breton 's subdivision-Methode (die mit Mongo' s extension-Methode), erhalten Sie präzise beliebige Kraft-der-zwei Divisionen. Aufgeteilt in non-power-of-zwei Divisionen mit diesen Methoden haben Sie zu unterteilen, um sub-pixel-Abstand, das kann sehr teuer werden.

Allerdings glaube ich, dass Sie anwenden können eine variation der Haga ' s Theorem (welches in origami-teilen Sie eine Seite in Nths gegeben, eine Seite unterteilt sich in (N-1)ths) an der Perspektive-Quadrat Unterabteilungen zu produzieren willkürlichen Trennungen von der nächsten Potenz von 2 ist die zimmerreserviereung, ohne das weiter zu unterteilen.

Haga ist theorum war eine sehr interessante Lektüre, aber es kann nur für Quadrate. Mit variablem h/w Verhältnis zu meinem Rechtecke, die ich kann nicht scheinen zu finden ein Weg, um zu gelten, dass theorum.
Anstatt das sub-pixel-acuracy, ich denke, ich werde tun, eine "binäre Suche" für jede Unterteilung. Also wenn ich spaltete meine rect in Drittel, würde ich im Grunde tun eine binäre Suche innerhalb einer gewissen Genauigkeit von 33.33% und 66.66%, dann eine gewichtete bisection mit jedem "Teil" (und durch das Teil-ich meine, wenn ich die halbierten 4 mal, es ergäben sich eine perspektivisch korrekte 16)

InformationsquelleAutor Sparr
1

Die eleganteste und Schnellste Lösung wäre, dass Sie die homography matrix, welche Karten Rechteck-Koordinaten, Foto Koordinaten.

Mit einer anständigen matrix-Bibliothek-es sollte nicht eine schwierige Aufgabe, solange Sie wissen, Ihre math.

Keywords: Collineation, Homography, Direkte Lineare Transformation

Jedoch der rekursive Algorithmus oben sollte funktionieren, aber wahrscheinlich nur, wenn die Ressourcen begrenzt sind, projektive geometrie ist der einzige Weg zu gehen.

InformationsquelleAutor Ugauga
0

In dem speziellen Fall, wenn man sich senkrecht zu den Seiten 1 und 3, teilen Sie jene Seiten zu gleichen teilen. Zeichnen Sie dann eine Diagonale, parallelen zu ziehen zu Seite 1 durch jeden Schnittpunkt der diagonalen und die Trennlinien gezogen früher.

InformationsquelleAutor stevenvh
0

Diese eine geometrische Lösung, die ich dachte. Ich weiß nicht, ob der 'Algorithmus' hat einen Namen.

Sagen, dass Sie möchten, starten Sie durch Division der 'Rechteck' in n Stücke mit vertikalen Linien zuerst.

Das Ziel ist, platzieren Sie die Punkte P1..Pn-1 auf der oberen Linie, die wir verwenden können, zum zeichnen von Linien durch Sie die Punkte, wo die linke und Rechte Linie treffen oder parallel zu Ihnen, wenn dieser Punkt nicht vorhanden.

Wenn die Obere und untere Zeile sind parallel zueinander legen Sie einfach thoose Punkte aufgeteilt die Obere Linie zwischen den Ecken zentriert ist.

Sonst Platz n Punkte Q1..Qn auf der linken Linie, so dass diese und der oberen linken Ecke sind gleich weit und ich < j => Qi ist näher an der oberen linken cornern als Qj.
Um einen überblick über die Q-Punkte der oberen Zeile finden Sie den Schnittpunkt S der Linie von Qn durch den oberen-rechten Ecke und die parallel zu der Linie durch den Schnittpunkt von oben und unten line. Verbinden Sie nun S mit Q1..Qn-1. Der Schnittpunkt der neuen Linien mit der obersten Zeile sind die wollten, P-Punkte.

Tun dies analog für die horizontalen Linien.

InformationsquelleAutor a427
0

Gegeben ist eine rotation um die y-Achse, vor allem, wenn die rotation Flächen sind planar, der Perspektive generiert wird, die durch vertikale Gradienten. Diese bekommen zunehmend näher in Sicht. Anstelle der Verwendung von diagonalen zu definieren, die vier Rechtecke, die Befugnisse von zwei... definieren Sie zwei Rechtecke, Links und rechts. Werden Sie höher als breit sind, schließlich, wenn man weiterhin unterteilen Sie die Fläche in schmaler vertikaler Segmente. Dieser bietet Platz für Oberflächen, die nicht rechteckig sind. Wenn eine rotation um die x-Achse, dann die horizontalen Gradienten benötigt werden.

InformationsquelleAutor Brian Coyle

Ich denke, dass die ausgewählte Antwort ist nicht die beste Lösung. Eine bessere Lösung ist die Anwendung der Perspektive der (projektiven) transformation eines Rechtecks auf einfache raster folgende Matlab-Skript und Bild zeigen. Implementieren Sie diesen Algorithmus mit C++ und OpenCV als gut.

function drawpersgrid
sz      = [ 24, 16 ]; % [x y]
srcpt   = [ 0 0; sz(1) 0; 0 sz(2); sz(1) sz(2)];
destpt  = [ 20 50; 100 60; 0 150; 200 200;];

% make rectangular grid
[X,Y]   = meshgrid(0:sz(1),0:sz(2));

% find projective transform matching corner points
tform   = maketform('projective',srcpt,destpt);

% apply the projective transform to the grid
[X1,Y1] = tformfwd(tform,X,Y);

hold on;

%% find grid

for i=1:sz(2)
    for j=1:sz(1)
        x = [ X1(i,j);X1(i,j+1);X1(i+1,j+1);X1(i+1,j);X1(i,j)];
        y = [ Y1(i,j);Y1(i,j+1);Y1(i+1,j+1);Y1(i+1,j);Y1(i,j)];
        plot(x,y,'b');
    end
end
hold off;

Wie zeichnet man eine, die die Perspektive Korrigieren-Gitter in 2D

InformationsquelleAutor Tae-Sung Shin

-1

Das problem ist, dass es die transformation von 3D nach 2D, die immer Sie.

Hier's eine Anleitung, wie es gemacht wird.

Dies ist striclty 2D, es gibt keine 3D-Daten zum Projekt aus.

InformationsquelleAutor Charlie Martin
-1

Was Sie tun müssen, ist, stellen es in 3D (Welt) und projizieren es auf 2D (Bild).

Dies erfordert die Verwendung eines 4D-transformation matrix, die die Projektion auf eine 4D homogene unten, um eine homogene 3D-Vektor, die Sie dann konvertieren nach unten auf einem 2D screen space vector.

Ich konnte ihn nicht finden in Google, aber ein guter computer graphics Bücher haben die details.

Keywords Projektions-matrix, Projektion, transformation, affine transformation, homogene Vektor, Welt, Raum, Platz auf dem Bildschirm, eine perspektivische transformation, 3D-transformation

Und durch die Art und Weise, dies dauert in der Regel ein paar vorlesungen zu erklären. Also auf gut Glück.

Mit 3D-Mathematik, um dies zu erreichen, ist Massiv übertrieben, extrem mehr Komplexität als erforderlich.
Es ist nur ein Haufen von Mathematik, die nicht benötigt keine IO. Es wäre also super schnell.
"super schnell" ist relativ. Nicht mit 3D-Mathematik wäre "super schnell"ER. Werfen Millionen von Prozessor-Zyklen auf ein problem, das sollte Tausende ist nur ärger bringen. Was passiert, wenn er beschließt, zu einem 1024x1024 Gitter anstelle von 5x5?

InformationsquelleAutor Pyrolistical

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.