Devuelve CATransform3D para mapear cuadrilátero a cuadrilátero

Question

Estoy tratando de derivar un CATransform3D que mapeará un quad con 4 puntos de esquina a otro quad con 4 nuevos puntos de esquina. He dedicado un poco de tiempo a investigar esto y parece que los pasos implican convertir el Quad original en un Square, y luego convertir ese Square en el nuevo Quad. Mis métodos de este aspecto (código tomado de 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; 

} 

Después de calcular ambas matrices, multiplicar juntos, y asignar a la vista de que se trate, termino con miras transformado, pero es tremendamente incorrecto. De hecho, parece esquilarse como un paralelogramo sin importar lo que haga. ¿Qué me estoy perdiendo?

ACTUALIZACIÓN 2/1/12

Parece que la razón por la que estoy corriendo en problemas puede ser que necesito para dar cabida a FOV y la distancia focal en la matriz de vista del modelo (que es la única matriz I puede alterar directamente en Quartz.) Sin embargo, no estoy teniendo suerte para encontrar documentación en línea sobre cómo calcular la matriz adecuada.

Answer 1

que fue capaz de lograr esto portando y la combinación de la deformación quad y código homografía a partir de estas dos direcciones URL:

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

Actualización: He código abierto una clase pequeña que hace esto: https://github.com/dominikhofmann/DHWarpView