Exemple #1
0
void vtkPolyDataSingleSourceShortestPath::init()
{
	BuildAdjacency(this->GetInput());
	
	IdList->Reset();
	
	this->n = this->GetInput()->GetNumberOfPoints();
	
	this->d->SetNumberOfComponents(1);
	this->d->SetNumberOfTuples(this->n);
	this->pre->SetNumberOfComponents(1);
	this->pre->SetNumberOfTuples(this->n);
	this->f->SetNumberOfComponents(1);
	this->f->SetNumberOfTuples(this->n);
	this->s->SetNumberOfComponents(1);
	this->s->SetNumberOfTuples(this->n);
	this->p->SetNumberOfComponents(1);
	this->p->SetNumberOfTuples(this->n);
	
	// The heap has elements from 1 to n
	this->H->SetNumberOfComponents(1);
	this->H->SetNumberOfTuples(this->n+1);
	
	Hsize = 0;
}
// -------------------------------------------------------------------------- //
void Class_VolTri::ExtractBoundaries(
    Class_SurfTri    &Bounds,
    int               BC_flag
) {

// ========================================================================== //
// void Class_VolTri::ExtractBoundaries(                                      //
//     Class_SurfTri    &Bounds,                                              //
//     int               BC_flag)                                             //
//                                                                            //
// Extract boundaries of volume mesh.                                         //
// ========================================================================== //
// INPUT                                                                      //
// ========================================================================== //
// - Bounds     : Class_SurfTri, surface mesh                                 //
// - BC_flag    : int, boundary condition flag                                //
// ========================================================================== //
// OUTPUT                                                                     //
// ========================================================================== //
// - none                                                                     //
// ========================================================================== //

// ========================================================================== //
// VARIABLES DECLARATION                                                      //
// ========================================================================== //

// Local variables
ivector1D                simplex;

// Counters
int                      nS;
int                      i, j;
int                      n, m;
int                      T;

// ========================================================================== //
// BUILD ADJACENCY IF NOT ALREADY BUILT                                       //
// ========================================================================== //
if ((Adjacency.size() == 0) || (Adjacency.size() < nSimplex)) {
    BuildAdjacency();
}

// ========================================================================== //
// RESIZE DATA STRUCTURES                                                     //
// ========================================================================== //
Bounds.AddVertices(Vertex);
nS = Bounds.nSimplex;
Bounds.nSimplex += CountFreeFaces();
Bounds.ResizeSimplex();
Bounds.nSimplex = nS;

// ========================================================================== //
// LOOP OVER SIMPLICIES                                                       //
// ========================================================================== //
for (T = 0; T < nSimplex; ++T) {
    n = infos[e_type[T]].n_faces;
    for (i = 0; i < n; ++i) {
        if (Adjacency[T][i] == BC_flag) {
            m = infos[e_type[T]].faces[i].size();
            simplex.resize(m, -1);
            for (j = 0; j < m; ++j) {
                simplex[j] = Simplex[T][infos[e_type[T]].faces[i][j]];
            } //next j
            Bounds.AddSimplex(simplex);
        }
    } //next i
} //next T

// ========================================================================== //
// CLEAN SURFACE TASSELATION                                                  //
// ========================================================================== //
Bounds.RemoveIsolatedVertex();
Bounds.ResizeVertex();

return; };
// -------------------------------------------------------------------------- //
int Class_VolTri::ReturnSimplexID(
    a3vector1D  &P,
    int          S0
) {

// ========================================================================== //
// int Class_VolTri::ReturnSimplexID(                                         //
//     a3vector1D  &P,                                                        //
//     int          S0)                                                       //
//                                                                            //
// Return the ID of the simplex enclosing point P.                            //
// ========================================================================== //
// INPUT                                                                      //
// ========================================================================== //
// - P     : a3vector1D, point coordinates                                    //
// - S0    : int, seed for search procedure                                   //
// ========================================================================== //
// OUTPUT                                                                     //
// ========================================================================== //
// - S     : int, ID of simplex enclosing point P                             //
// ========================================================================== //

// ========================================================================== //
// VARIABLES DECLARATION                                                      //
// ========================================================================== //

// Local variables
bool                        check = false;
int                         n, m, p;
double                      max_dp, dp;
bvector1D                   visited(nSimplex, false);
ivector2D                   face_vlist;
a3vector1D                  x, y, xF, xS, dir;
a3vector2D                  face_normals;
LIFOstack<int>              stack;

// Counters
int                         i, j, k, l, S, A;
/*debug*/int                         n_visited = 0;

// /*debug*/ofstream       log_file;
// /*debug*/log_file.open("SEARCH.log", ifstream::app);

// ========================================================================== //
// INITIALIZE PARAMETERS                                                      //
// ========================================================================== //
// x.fill(0.0);
// y.fill(0.0);

// /*debug*/log_file << "point coordinates: " << P << endl;

// ========================================================================== //
// BUILD ADJACENCY IF NOT ALREADY BUILT                                       //
// ========================================================================== //
if ((Adjacency.size() == 0) || (Adjacency.size() < nSimplex)) {
    BuildAdjacency();
}

// ========================================================================== //
// LOOP UNTIL SIMPLEX IS FOUND                                                //
// ========================================================================== //
stack.push(S0);
while ((stack.TOPSTK > 0) && (!check)) {

// /*debug*/n_visited++;

    // Pop item from stack -------------------------------------------------- //
    S = stack.pop();
    visited[S] = true;

// /*debug*/log_file << "  traversing simplex: " << S << endl;
// /*debug*/log_file << "  (visited: " << n_visited << " of " << nSimplex << endl;

    // Simplex infos -------------------------------------------------------- //
    n = infos[e_type[S]].n_vert;
    m = infos[e_type[S]].n_faces;

    // Get face vertices ---------------------------------------------------- //
    {
        face_vlist.resize(m);
        for (j = 0; j < m; ++j) {
            face_vlist[j] = FaceVertices(S, j);
        } //next j
    }

    // Simplex baricenter --------------------------------------------------- //
    {
        xS.fill(0.0);
        for (j = 0; j < n; ++j) {
            for (l = 0; l < 3; ++l) {
                xS[l] += Vertex[Simplex[S][j]][l];
            } //next l
        } //next j
        xS = xS/((double) n);
    }

    // Compute face normals ------------------------------------------------- //
    {
        face_normals.resize(m);
        for (j = 0; j < m; ++j) {
            if (face_vlist[j].size() == 2) {
                x = Vertex[face_vlist[j][1]] - Vertex[face_vlist[j][0]];
                x[2] = 0.0;
                y[0] = 0.0;
                y[1] = 0.0;
                y[2] = 1.0;
                face_normals[j] = Cross_Product(x, y);
            }
            else {
                x = Vertex[face_vlist[j][2]] - Vertex[face_vlist[j][1]];
                y = Vertex[face_vlist[j][1]] - Vertex[face_vlist[j][0]];
                face_normals[j] = Cross_Product(x, y);
            }
            face_normals[j] = face_normals[j]/max(norm_2(face_normals[j]), 2.0e-16);
        } //next j
    }
    
    // Check if Simplex S encloses point P ---------------------------------- //
    {
        check = true;
        for (j = 0; j < m; ++j) {
            n = face_vlist[j].size();
    
            // Compute face center
            xF.fill(0.0);
            for (k = 0; k < n; ++k) {
                for (l = 0; l < 3; l++) {
                    xF[l] += Vertex[face_vlist[j][k]][l];
                } //next l
            } //next k
            xF = xF/((double) n);
    
            // Check if simplex encloses point
            dir = P - xF;
            dir = dir/max(norm_2(dir), 2.0e-16);
            check = (check && (Dot_Product(dir, face_normals[j]) <= 0.0));
        } //next j
    }

// /*debug*/log_file << "    encloses point: " << check << endl;

    // Look for best direction (Euristic search of best path) --------------- //
    // NOTES:                                                                 //
    // - modificare il criterio euristico per la scelta del path migliore     //
    //   * congiungente P-xS attraversa una faccia.                           //
    //   * distanza minima dalle facce.                                       //
    // ---------------------------------------------------------------------- //
    if (!check) {

        // local direction of searching path
        dir = P - xS;
        dir = dir/max(norm_2(dir), 2.0e-16);
    
        // Loop over simplex faces
        max_dp = -2.0;
        i = 0;
        j = -1;
        while (i < m) {
            dp = Dot_Product(face_normals[i], dir);
            if (dp > max_dp) {
                j = i;
                max_dp = dp;
            }
            i++;
        } //next i
    
        // Alternative directions
        for (i = 0; i < m; ++i) {
            A = Adjacency[S][i];
            if ((i != j) && (A >= 0) && (!visited[A])) {
                stack.push(A);
            }
        } //next i
        A = Adjacency[S][j];
        if ((A >= 0) && (!visited[A])) {
            stack.push(A);
        }
    }

} //next simplex

// /*debug*/log_file << "  (visited: " << n_visited << " of " << nSimplex << ")" << endl;

// Old algorithm ============================================================ //
{
    // while ((n_visited <= nSimplex) && (!check) && (S0 >= 0)) {
    
        // // Update simplex ID ---------------------------------------------------- //
        // // cout << "    on simplex " << S0;
        // S = S0;
        // n_visited++;
        // visited[S] = true;
        // /*debug*/log_file << "  traversing simplex: " << S << endl;
        // /*debug*/log_file << "  (visited: " << n_visited << " of " << nSimplex << endl;
    
        // // Simplex infos -------------------------------------------------------- //
        // m = infos[e_type[S]].n_faces;
        // p = infos[e_type[S]].n_vert;
    
        // // Compute simplex baricenter ------------------------------------------- //
        // {
            // xS.fill(0.0);
            // for (j = 0; j < p; ++j) {
                // for (l = 0; l < dim; ++l) {
                    // xS[l] += Vertex[Simplex[S][j]][l];
                // } //next l
            // } //next j
            // xS = xS/((double) p);
        // }
    
        // // Get face vertices ---------------------------------------------------- //
        // {
            // face_vlist.resize(m);
            // for (j = 0; j < m; ++j) {
                // face_vlist[j] = FaceVertices(S, j);
            // } //next j
        // }
    
        // // Compute face normals ------------------------------------------------- //
        // {
            // face_normals.resize(m);
            // for (j = 0; j < m; ++j) {
                // if (face_vlist[j].size() == 2) {
                    // x[0] = Vertex[face_vlist[j][1]][0] - Vertex[face_vlist[j][0]][0];
                    // x[1] = Vertex[face_vlist[j][1]][1] - Vertex[face_vlist[j][0]][1];
                    // x[2] = 0.0;
                    // y[0] = 0.0;
                    // y[1] = 0.0;
                    // y[2] = 1.0;
                    // face_normals[j] = Cross_Product(x, y);
                // }
                // else {
                    // x[0] = Vertex[face_vlist[j][2]][0] - Vertex[face_vlist[j][1]][0];
                    // x[1] = Vertex[face_vlist[j][2]][1] - Vertex[face_vlist[j][1]][1];
                    // x[2] = Vertex[face_vlist[j][2]][2] - Vertex[face_vlist[j][1]][2];
                    // y[0] = Vertex[face_vlist[j][1]][0] - Vertex[face_vlist[j][0]][0];
                    // y[1] = Vertex[face_vlist[j][1]][1] - Vertex[face_vlist[j][0]][1];
                    // y[2] = Vertex[face_vlist[j][1]][2] - Vertex[face_vlist[j][0]][2];
                    // face_normals[j] = Cross_Product(x, y);
                // }
                // face_normals[j] = face_normals[j]/max(norm_2(face_normals[j]), 2.0e-16);
            // } //next j
        // }
    
        // // Check if P is enclosed in simplex S0 --------------------------------- //
        // {
            // check = true;
            // for (j = 0; j < m; ++j) {
                // n = face_vlist[j].size();
        
                // // Compute face center
                // xF.fill(0.0);
                // for (k = 0; k < n; ++k) {
                    // for (l = 0; l < dim; l++) {
                        // xF[l] += Vertex[face_vlist[j][k]][l];
                    // } //next l
                // } //next k
                // xF = xF/((double) n);
        
                // // Check if simplex encloses point
                // for (l = 0; l < dim; l++) {
                    // dir[l] = P[l] - xF[l];
                // } //next l
                // dir = dir/max(norm_2(dir), 2.0e-16);
                // check = (check && (Dot_Product(dir, face_normals[j]) <= 0.0));
                // // cout << " f " << j << ", c: " << check;
            // } //next j
        // }
        // // cout << ", check: " << check << endl;
        // /*debug*/log_file << "    encloses point: " << check << endl;
    
        // // Look for best direction (Euristic search) ---------------------------- //
        // if (!check) {
        
            // // Find face to be crossed (Euristic search of best path)
            // {
        
                // // path local direction
                // for (l = 0; l < dim; ++l) {
                    // dir[l] = P[l] - xS[l];
                // } //next l
                // dir = dir/max(norm_2(dir), 2.0e-16);
        
                // // Loop over simplex faces
                // // WARNING: infinite loop at corner simplicies!!
                // max_dp = -2.0;
                // i = -1;
                // j = 0;
                // while (j < m) {
                    // dp = Dot_Product(face_normals[j], dir);
                    // A = Adjacency[S][j];
                    // if ((dp > max_dp) && (A >= 0)) {//&& (!visited[A])) {
                        // i = j;
                        // max_dp = dp;
                    // }
                    // j++;
                // } //next j
            // }
    
            // // Move to adjacent simplex
            // if (i >= 0) { S0 = Adjacency[S][i]; }
            // else        { S0 = -1;}
        // }
    
        // /*debug*/log_file << "    next simplex: " << S0 << endl;
    // } //next simplex
}
// /*debug*/log_file.close();

return(S); };
// -------------------------------------------------------------------------- //
ivector1D Class_VolTri::VertNeigh(
    int          T,
    int          i
) {

// ========================================================================== //
// ivector1D Class_VolTri::VertNeigh(                                         //
//     int          T,                                                        //
//     int          i)                                                        //
//                                                                            //
// Returns the indices of neighbors at the i-th vertex of simplex T.          //
// ========================================================================== //
// INPUT                                                                      //
// ========================================================================== //
// - T      : int, simplex global index                                       //
// - i      : int, vertex local index                                         //
// ========================================================================== //
// OUTPUT                                                                     //
// ========================================================================== //
// - neigh  : ivector1D, vertex neighbors                                     //
// ========================================================================== //

// ========================================================================== //
// INPUT                                                                      //
// ========================================================================== //

// Local variables
int                             n_faces = infos[e_type[T]].n_faces;
LIFOstack<int>                  stack(4*n_faces), visited(4*n_faces);
ivector1D                       e;
ivector1D                       neigh;
ivector1D                       e_neigh;
ivector1D::iterator             it_, end_;

// Counters
int                             n, m;
int                             j, k;
int                             S, A, V;

// ========================================================================== //
// BUILD ADJACENCIES IF NOT ALREADY BUILT                                     //
// ========================================================================== //
if ((Adjacency.size() == 0) || (Adjacency.size() < nSimplex)) {
    BuildAdjacency();
}

// ========================================================================== //
// ITERATIVELY ADD SIMPLICIES TO STACK                                        //
// ========================================================================== //

// Initialize stack --------------------------------------------------------- //
stack.push(T);
visited.push(T);
V = Simplex[T][i];

// Iterate until stack is empty --------------------------------------------- //
while (stack.TOPSTK > 0) {

    // Pop item from stack
    S = stack.pop();

    // Loop over S-neighbors
    n = infos[e_type[S]].n_faces;
    for (j = 0; j < n; ++j) {
        A = Adjacency[S][j];
        if (A >= 0) {
            end_ = visited.STACK.begin() + visited.TOPSTK;
            if (find(visited.STACK.begin(), end_, A) == end_) {
                if (vertex(A, V) >= 0) {
                    stack.push(A);
                    visited.push(A);
                    neigh.push_back(A);
                }
            }
        }
    } //next j
} //next item

// Remove face adjacent simplicies ------------------------------------------ //
for (j = 0; j < n_faces; ++j) {
    A = Adjacency[T][j];
    if (A >= 0) {
        it_ = find(neigh.begin(), neigh.end(), A);
        if (it_ != neigh.end()) {
            neigh.erase(it_);
        }
    }
} //next j

// Remove edge-adjacent simplicies ------------------------------------------ //

// find edges incident to vertex (T, i)
m = infos[e_type[T]].n_edges;
for (k = 0; k < m; k++) {
    if (find(infos[e_type[T]].edges[k].begin(),
             infos[e_type[T]].edges[k].end(),
             i) != infos[e_type[T]].edges[k].end()) {
        e.push_back(k);
    }
} //next k

// Remove edge-adjacent simplicies from neigh
m = e.size();
for (k = 0; k < m; ++k) {
    e_neigh = EdgeNeigh(T, e[k]);
    n = e_neigh.size();
    for (j = 0; j < n; ++j) {
        it_ = find(neigh.begin(), neigh.end(), e_neigh[j]);
        if (it_ != neigh.end()) {
            neigh.erase(it_);
        }
    } //next j
} //next k

return(neigh); };
// -------------------------------------------------------------------------- //
ivector1D Class_VolTri::EdgeNeigh(
    int          T, 
    int          i
) {

// ========================================================================== //
// ivector1D Class_VolTri::EdgeNeigh(                                         //
//     int          T,                                                        //
//     int          i)                                                        //
//                                                                            //
// Find neighboring simplicies of simplex T along the i-th edge.              //
// ========================================================================== //
// INPUT                                                                      //
// ========================================================================== //
// - T      : int, simplex global index                                       //
// - i      : int, edge local index                                           //
// ========================================================================== //
// OUTPUT                                                                     //
// ========================================================================== //
// - list   : ivector1D, list of edge neighbors                               //
// ========================================================================== //

// ========================================================================== //
// INPUT                                                                      //
// ========================================================================== //

// Local variables
int                             n_faces = infos[e_type[T]].n_faces;
LIFOstack<int>                  stack(4*n_faces), visited(4*n_faces);
ivector1D                       e;
ivector1D                       neigh;
ivector1D::iterator             it_, end_;

// Counters
int                             n;
int                             j;
int                             S, A;

// ========================================================================== //
// BUILD ADJACENCIES IF NOT ALREADY BUILT                                     //
// ========================================================================== //
if ((Adjacency.size() == 0) || (Adjacency.size() < nSimplex)) {
    BuildAdjacency();
}

// ========================================================================== //
// ITERATIVELY ADD SIMPLICIES TO STACK                                        //
// ========================================================================== //

// Initialize stack --------------------------------------------------------- //
stack.push(T);
n = infos[e_type[T]].edges[i].size();
e.resize(n, -1);
for (j = 0; j < n; ++j) {
    e[j] = Simplex[T][infos[e_type[T]].edges[i][j]];
} //next i

// Iterate until stack is empty --------------------------------------------- //

// Initialize visited list
for (i = 0; i < visited.STACK.size(); ++i) {
    visited.STACK[i] = -1;
} //next i
visited.push(T);

// Loop over items in stack
while (stack.TOPSTK > 0) {

    // Pop item from stack
    S = stack.pop();

    // Loop over S-neighbors
    n = infos[e_type[S]].n_faces;
    for (j = 0; j < n; ++j) {
        A = Adjacency[S][j];
        if (A >= 0) {
            end_ = visited.STACK.begin() + visited.TOPSTK;
            if (find(visited.STACK.begin(), end_, A) == end_) {
                if (edge(A, e) >= 0) {
                    stack.push(A);
                    visited.push(A);
                    neigh.push_back(A);
                }
            }
        }
    } //next j
} //next item

// Remove face adjacent simplicies ------------------------------------------ //
for (j = 0; j < n_faces; ++j) {
    A = Adjacency[T][j];
    if (A >= 0) {
        it_ = find(neigh.begin(), neigh.end(), A);
        if (it_ != neigh.end()) {
            neigh.erase(it_);
        }
    }
} //next j

return(neigh); };