Restituisce CATransform3D per mappare quadrilatero a quadrilatero

Question

Sto provando a derivare un CATransform3D che mapperà un quad con 4 punti d'angolo su un altro quad con 4 nuovi punti d'angolo. Ho passato un po 'di tempo a cercare questo e sembra che i passaggi implichino la conversione del Quad originale in un quadrato, e quindi la conversione di quel Quadrato nel nuovo Quad. I miei metodi simile a questa (codice preso in prestito da here):

- (CATransform3D)quadFromSquare_x0:(float)x0 y0:(float)y0 x1:(float)x1 y1:(float)y1 x2:(float)x2 y2:(float)y2 x3:(float)x3 y3:(float)y3 { 

    float dx1 = x1 - x2, dy1 = y1 - y2; 
    float dx2 = x3 - x2, dy2 = y3 - y2; 
    float sx = x0 - x1 + x2 - x3; 
    float sy = y0 - y1 + y2 - y3; 
    float g = (sx * dy2 - dx2 * sy)/(dx1 * dy2 - dx2 * dy1); 
    float h = (dx1 * sy - sx * dy1)/(dx1 * dy2 - dx2 * dy1); 
    float a = x1 - x0 + g * x1; 
    float b = x3 - x0 + h * x3; 
    float c = x0; 
    float d = y1 - y0 + g * y1; 
    float e = y3 - y0 + h * y3; 
    float f = y0; 

    CATransform3D mat; 

    mat.m11 = a; 
    mat.m12 = b; 
    mat.m13 = 0; 
    mat.m14 = c; 

    mat.m21 = d; 
    mat.m22 = e; 
    mat.m23 = 0; 
    mat.m24 = f; 

    mat.m31 = 0; 
    mat.m32 = 0; 
    mat.m33 = 1; 
    mat.m34 = 0; 

    mat.m41 = g; 
    mat.m42 = h; 
    mat.m43 = 0; 
    mat.m44 = 1; 

    return mat; 

} 

- (CATransform3D)squareFromQuad_x0:(float)x0 y0:(float)y0 x1:(float)x1 y1:(float)y1 x2:(float)x2 y2:(float)y2 x3:(float)x3 y3:(float)y3 { 

    CATransform3D mat = [self quadFromSquare_x0:x0 y0:y0 x1:x1 y1:y1 x2:x2 y2:y2 x3:x3 y3:y3]; 

    // invert through adjoint 

    float a = mat.m11,  d = mat.m21, /* ignore */   g = mat.m41; 
    float b = mat.m12,  e = mat.m22, /* 3rd col*/   h = mat.m42; 
    /* ignore 3rd row */ 
    float c = mat.m14,  f = mat.m24; 

    float A =  e - f * h; 
    float B = c * h - b; 
    float C = b * f - c * e; 
    float D = f * g - d; 
    float E =  a - c * g; 
    float F = c * d - a * f; 
    float G = d * h - e * g; 
    float H = b * g - a * h; 
    float I = a * e - b * d; 

    // Probably unnecessary since 'I' is also scaled by the determinant, 
    // and 'I' scales the homogeneous coordinate, which, in turn, 
    // scales the X,Y coordinates. 
    // Determinant = a * (e - f * h) + b * (f * g - d) + c * (d * h - e * g); 
    float idet = 1.0f/(a * A   + b * D   + c * G); 

    mat.m11 = A * idet;  mat.m21 = D * idet;  mat.m31 = 0; mat.m41 = G * idet; 
    mat.m12 = B * idet;  mat.m22 = E * idet;  mat.m32 = 0; mat.m42 = H * idet; 
    mat.m13 = 0  ;  mat.m23 = 0  ;  mat.m33 = 1; mat.m43 = 0  ; 
    mat.m14 = C * idet;  mat.m24 = F * idet;  mat.m34 = 0; mat.m44 = I * idet; 

    return mat; 

} 

Dopo aver calcolato entrambe le matrici, moltiplicandoli insieme, e assegnando alla vista in questione, io alla fine con una vista trasformata, ma è selvaggiamente errato. In effetti, sembra essere tosato come un parallelogramma, qualunque cosa io faccia. Cosa mi manca?

UPDATE 2/1/12

Sembra che la ragione per cui sto correndo in problemi può essere che ho bisogno di ospitare per il FOV e la lunghezza focale nella matrice vista del modello (che è l'unica matrice I può cambiare direttamente in Quarzo.) Non ho alcuna fortuna a trovare documentazione online su come calcolare la matrice corretta, però.

Answer 1

sono stato in grado di raggiungere questo obiettivo porting e combinando l'orditura quad e il codice omografia da questi due URL:

• http://forum.openframeworks.cc/index.php/topic,509.30.html
• http://forum.openframeworks.cc/index.php?topic=3121.15

UPDATE: Ho un open source piccola classe che esegue questa operazione: https://github.com/dominikhofmann/DHWarpView