Пример #1
0
/*
 * Constructor
 *
 * (u0,v0) = image centre
 * alfaU = f*ku = pixels per unit of measurement in Y e.g. 1 pixel/microm
 * alfaV
 */
MultipleViewGeomOld::MultipleViewGeomOld(int u0, int v0, float alfaU, float alfaV) :
    myLogger(log4cplus::Logger::getInstance("multipleViewGeom")) {

    // Ortographic projection
    float pContents[] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1 };
    pMat = cvCreateMat(3, 4, CV_32F);
    cvInitMatHeader(pMat, 3, 4, CV_32F, pContents);
    pMat = cvCloneMat(pMat);

    calculateCameraMatrix(u0, v0, alfaU, alfaV);

}
Пример #2
0
bspNode* createBSPTree(scene* scene) {
    
    // Funktio luo tilasta BSP-puun, jonka juureksi valitaan
    // ensimmäisen mallin ensimmäinen polygoni. Samalla
    // lasketaan polygonien ikkunakoordinaatit. Funktio
    // tarkistaa, että tilan osoitin ei ole tyhjä.
    
    assert(scene != NULL);
    
    // Lasketaan kameramatriisi
    
    matrix* camMatrix = calculateCameraMatrix(scene);
    
    matrix* world;
    matrix* fullTransform;
    
    // Käydään läpi tilan kaikki objektit ja laitetaan kaikki polygonit
    // aluksi yhteen listaan.
    
    object* obj = scene->objects;
    mesh* M;
    polygon* P;
    
    bspNode* root = NULL;
    bspNode* node;
    bspNode* prevNode = NULL;
    
    while(obj != NULL) {
        M = obj->mesh;
        
        if(M != NULL) {
            
            // Lasketaan objektikohtainen muunnosmatriisi
            
            world = matrixMultiply(obj->worldTransform, obj->scaleTransform);
            fullTransform = matrixMultiply(camMatrix, world);
            
            P = M->polygons;
            while(P != NULL) {
                
                calculateWorldCoordinates(P, world);
                
                // Luodaan alkio BSP-puuhun, jos polygoni osoittaa
                // kameraan päin.

                node = createBSPNode(P, fullTransform);

                if(root == NULL) {
                    root = node;
                }

                if(prevNode != NULL) {
                    prevNode->front = node;
                }
                prevNode = node;
                
                P = P->next;
            }
        }
        obj = obj->next;
    }
    
    // Asetetaan alkiot oikeaan järjestykseen rekursiivisella
    // kutsulla
    
    resolveBSPTree(root);
    return root;
}