Changeset 1025 for GTP/trunk/Lib/Geom


Ignore:
Timestamp:
06/20/06 13:28:51 (19 years ago)
Author:
gumbau
Message:

namespace simplif

Location:
GTP/trunk/Lib/Geom/shared
Files:
1 added
1 deleted
39 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoLodStripsConstructor.cpp

    r1018 r1025  
    418418         
    419419        //      2 min. 
    420         //      Calcular los siguiente teniendo en cuenta el QSLIM. 
     420        //      Calcular los siguiente teniendo en cuenta el simplif. 
    421421        for (i = 0; i < Ordenacion.size(); i++) 
    422422        { 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjModel.cxx

    r774 r1025  
    77     mlab: (Id: polymodel.cc,v 1.21 1997/02/06 16:34:14 garland Exp) 
    88  via 
    9      QSlim: (Id: polymodel.cc,v 1.5 1997/02/25 20:36:36 garland Exp) 
     9     simplif: (Id: polymodel.cc,v 1.5 1997/02/25 20:36:36 garland Exp) 
    1010 
    1111 ************************************************************************/ 
    … …  
    1313#include "AdjModel.h" 
    1414 
    15 using namespace qslim; 
     15using namespace simplif; 
    1616 
    1717int Model::in_Vertex(const Vec3& p) 
    … …  
    329329/*              // SUS: recalcular la normal en los triangulos cambiados no degenerados 
    330330 
    331                 qslim::Vertex * auxv0 = F->vertex(0); 
    332                 qslim::Vertex * auxv1 = F->vertex(1); 
    333                 qslim::Vertex * auxv2 = F->vertex(2); 
    334                 qslim::Vec3 vd1(auxv1->operator[](qslim::X) - auxv0->operator[](qslim::X),  
    335                                                 auxv1->operator[](qslim::Y) - auxv0->operator[](qslim::Y), 
    336                                                 auxv1->operator[](qslim::Z) - auxv0->operator[](qslim::Z)); 
    337                 qslim::Vec3 vd2(auxv2->operator[](qslim::X) - auxv0->operator[](qslim::X),  
    338                                                 auxv2->operator[](qslim::Y) - auxv0->operator[](qslim::Y), 
    339                                                 auxv2->operator[](qslim::Z) - auxv0->operator[](qslim::Z)); 
    340  
    341                 qslim::unitize(vd1); 
    342                 qslim::unitize(vd2); 
    343  
    344                 qslim::Vec3 vn = vd1 ^ vd2; 
    345                 qslim::unitize(vn); 
     331                simplif::Vertex * auxv0 = F->vertex(0); 
     332                simplif::Vertex * auxv1 = F->vertex(1); 
     333                simplif::Vertex * auxv2 = F->vertex(2); 
     334                simplif::Vec3 vd1(auxv1->operator[](simplif::X) - auxv0->operator[](simplif::X),  
     335                                                auxv1->operator[](simplif::Y) - auxv0->operator[](simplif::Y), 
     336                                                auxv1->operator[](simplif::Z) - auxv0->operator[](simplif::Z)); 
     337                simplif::Vec3 vd2(auxv2->operator[](simplif::X) - auxv0->operator[](simplif::X),  
     338                                                auxv2->operator[](simplif::Y) - auxv0->operator[](simplif::Y), 
     339                                                auxv2->operator[](simplif::Z) - auxv0->operator[](simplif::Z)); 
     340 
     341                simplif::unitize(vd1); 
     342                simplif::unitize(vd2); 
     343 
     344                simplif::Vec3 vn = vd1 ^ vd2; 
     345                simplif::unitize(vn); 
    346346                 
    347347                //auxf->vertex_normals[0] = vn; 
    348348                //auxf->vertex_normals[1] = vn; 
    349349                //auxf->vertex_normals[2] = vn; 
    350                 F->vertex_normals[0][qslim::X] = vn[qslim::X]; 
    351                 F->vertex_normals[0][qslim::Y] = vn[qslim::Y]; 
    352                 F->vertex_normals[0][qslim::Z] = vn[qslim::Z]; 
    353                 F->vertex_normals[1][qslim::X] = vn[qslim::X]; 
    354                 F->vertex_normals[1][qslim::Y] = vn[qslim::Y]; 
    355                 F->vertex_normals[1][qslim::Z] = vn[qslim::Z]; 
    356                 F->vertex_normals[2][qslim::X] = vn[qslim::X]; 
    357                 F->vertex_normals[2][qslim::Y] = vn[qslim::Y]; 
    358                 F->vertex_normals[2][qslim::Z] = vn[qslim::Z];*/ 
     350                F->vertex_normals[0][simplif::X] = vn[simplif::X]; 
     351                F->vertex_normals[0][simplif::Y] = vn[simplif::Y]; 
     352                F->vertex_normals[0][simplif::Z] = vn[simplif::Z]; 
     353                F->vertex_normals[1][simplif::X] = vn[simplif::X]; 
     354                F->vertex_normals[1][simplif::Y] = vn[simplif::Y]; 
     355                F->vertex_normals[1][simplif::Z] = vn[simplif::Z]; 
     356                F->vertex_normals[2][simplif::X] = vn[simplif::X]; 
     357                F->vertex_normals[2][simplif::Y] = vn[simplif::Y]; 
     358                F->vertex_normals[2][simplif::Z] = vn[simplif::Z];*/ 
    359359 
    360360    } 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjModel.h

    r774 r1025  
    1010     mlab: (Id: polymodel.h,v 1.13 1997/02/06 16:30:11 garland Exp) 
    1111  via 
    12      QSlim: (Id: polymodel.h,v 1.1 1997/02/11 15:21:29 garland Exp) 
     12     simplif: (Id: polymodel.h,v 1.1 1997/02/11 15:21:29 garland Exp) 
    1313 
    1414 ************************************************************************/ 
    … …  
    1818#include <vector> 
    1919 
    20 namespace qslim 
     20namespace simplif 
    2121{ 
    2222        class Model : public SMF_Model 
    … …  
    5858                // Basic model accessor functions 
    5959                // 
    60                 qslim::Vertex *vertex(int i) { return vertices(i); } 
    61                 qslim::Vec3 & normal(int i){ return normals(i); } 
    62                 qslim::Vec2 & texcoord(int i){ return texcoords(i); } 
    63                 qslim::Edge *edge(int i) { return edges(i); } 
    64                 qslim::Face *face(int i) { return faces(i); } 
     60                simplif::Vertex *vertex(int i) { return vertices(i); } 
     61                simplif::Vec3 & normal(int i){ return normals(i); } 
     62                simplif::Vec2 & texcoord(int i){ return texcoords(i); } 
     63                simplif::Edge *edge(int i) { return edges(i); } 
     64                simplif::Face *face(int i) { return faces(i); } 
    6565 
    6666                int vertCount() { return vertices.length(); } 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjPrims.cxx

    r774 r1025  
    77     mlab: (Id: primitives.cc,v 1.7 1997/02/06 16:32:45 garland Exp) 
    88  via 
    9      QSlim: (Id: primitives.cc,v 1.2 1997/02/18 21:11:27 garland Exp) 
     9     simplif: (Id: primitives.cc,v 1.2 1997/02/18 21:11:27 garland Exp) 
    1010 
    1111 ************************************************************************/ 
    … …  
    1313#include "AdjPrims.h" 
    1414 
    15 using namespace qslim; 
     15using namespace simplif; 
    1616 
    1717void Vertex::kill() 
    … …  
    215215 
    216216 
    217 void qslim::untagFaceLoop(Vertex *v) 
     217void simplif::untagFaceLoop(Vertex *v) 
    218218{ 
    219219    edge_buffer& edges = v->edgeUses(); 
    … …  
    227227} 
    228228 
    229 void qslim::collectFaceLoop(Vertex *v, face_buffer& loop) 
     229void simplif::collectFaceLoop(Vertex *v, face_buffer& loop) 
    230230{ 
    231231    edge_buffer& edges = v->edgeUses(); 
    … …  
    243243} 
    244244 
    245 int qslim::classifyEdge(Edge *e) 
     245int simplif::classifyEdge(Edge *e) 
    246246{ 
    247247    int cls = e->faceUses().length(); 
    … …  
    252252} 
    253253 
    254 int qslim::classifyVertex(Vertex *v) 
     254int simplif::classifyVertex(Vertex *v) 
    255255{ 
    256256    int border_count = 0; 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjPrims.h

    r774 r1025  
    1010     mlab: (Id: primitives.h,v 1.7 1997/02/06 16:30:14 garland Exp) 
    1111  via 
    12      QSlim: (Id: primitives.h,v 1.3 1997/02/18 21:11:29 garland Exp) 
     12     simplif: (Id: primitives.h,v 1.3 1997/02/18 21:11:29 garland Exp) 
    1313 
    1414 ************************************************************************/ 
    … …  
    2121#include <gfx/geom/3D.h> 
    2222 
    23 namespace qslim 
     23namespace simplif 
    2424{ 
    2525        class Vertex; 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/SimplificationMethod.cpp

    r1007 r1025  
    3333//      Recalculate the cost of the vertices of an edge 
    3434//--------------------------------------------------------------------------- 
    35 void SimplificationMethod::compute_pair_info(qslim::pair_info *auxpair) 
    36 { 
    37         qslim::Vertex *v0 = auxpair->v0; 
    38         qslim::Vertex *v1 = auxpair->v1; 
    39  
    40         qslim::vert_info& v0_info = vertex_info(v0); 
    41         qslim::vert_info& v1_info = vertex_info(v1); 
    42  
    43         qslim::Mat4 Q = v0_info.Q + v1_info.Q; 
    44         qslim::real norm = v0_info.norm + v1_info.norm; 
    45  
    46         auxpair->cost = qslim::quadrix_pair_target(Q, v0, v1, auxpair->candidate); 
    47  
    48         if( qslim::will_weight_by_area ) 
     35void SimplificationMethod::compute_pair_info(simplif::pair_info *auxpair) 
     36{ 
     37        simplif::Vertex *v0 = auxpair->v0; 
     38        simplif::Vertex *v1 = auxpair->v1; 
     39 
     40        simplif::vert_info& v0_info = vertex_info(v0); 
     41        simplif::vert_info& v1_info = vertex_info(v1); 
     42 
     43        simplif::Mat4 Q = v0_info.Q + v1_info.Q; 
     44        simplif::real norm = v0_info.norm + v1_info.norm; 
     45 
     46        auxpair->cost = simplif::quadrix_pair_target(Q, v0, v1, auxpair->candidate); 
     47 
     48        if( simplif::will_weight_by_area ) 
    4949                auxpair->cost /= norm; 
    5050 
    51         if( qslim::will_preserve_mesh_quality ) 
     51        if( simplif::will_preserve_mesh_quality ) 
    5252                auxpair->cost += pair_mesh_penalty(M0, v0, v1, auxpair->candidate); 
    5353 
    … …  
    7070//      Reasign the new vertex to the adequate face 
    7171//--------------------------------------------------------------------------- 
    72 int SimplificationMethod::predict_face(qslim::Face& F, qslim::Vertex *v1, qslim::Vertex *v2, qslim::Vec3& vnew, qslim::Vec3& f1, qslim::Vec3& f2, qslim::Vec3& f3) 
     72int SimplificationMethod::predict_face(simplif::Face& F, simplif::Vertex *v1, simplif::Vertex *v2, simplif::Vec3& vnew, simplif::Vec3& f1, simplif::Vec3& f2, simplif::Vec3& f3) 
    7373{ 
    7474        int nmapped = 0; 
    … …  
    9393//--------------------------------------------------------------------------- 
    9494//--------------------------------------------------------------------------- 
    95 qslim::real SimplificationMethod::pair_mesh_penalty(qslim::Model& M, qslim::Vertex *v1, qslim::Vertex *v2, qslim::Vec3& vnew) 
    96 { 
    97         static qslim::face_buffer changed; 
     95simplif::real SimplificationMethod::pair_mesh_penalty(simplif::Model& M, simplif::Vertex *v1, simplif::Vertex *v2, simplif::Vec3& vnew) 
     96{ 
     97        static simplif::face_buffer changed; 
    9898        changed.reset(); 
    9999 
    … …  
    101101 
    102102        // real Nsum = 0; 
    103         qslim::real Nmin = 0; 
     103        simplif::real Nmin = 0; 
    104104 
    105105        for(int i=0; i<changed.length(); i++) 
    106106        { 
    107                 qslim::Face& F = *changed(i); 
    108                 qslim::Vec3 f1, f2, f3; 
     107                simplif::Face& F = *changed(i); 
     108                simplif::Vec3 f1, f2, f3; 
    109109 
    110110                int nmapped = predict_face(F, v1, v2, vnew, f1, f2, f3); 
    … …  
    113113                if( nmapped < 2 ) 
    114114                { 
    115                         qslim::Plane Pnew(f1, f2, f3); 
    116                         qslim::real delta =  Pnew.normal() * F.plane().normal(); 
     115                        simplif::Plane Pnew(f1, f2, f3); 
     116                        simplif::real delta =  Pnew.normal() * F.plane().normal(); 
    117117 
    118118                        if( Nmin > delta ) Nmin = delta; 
    … …  
    130130//      Returns true if the givens vertices are a valid pair 
    131131//--------------------------------------------------------------------------- 
    132 bool SimplificationMethod::check_for_pair(qslim::Vertex *v0, qslim::Vertex *v1) 
    133 { 
    134         const qslim::pair_buffer& pairs = vertex_info(v0).pairs; 
     132bool SimplificationMethod::check_for_pair(simplif::Vertex *v0, simplif::Vertex *v1) 
     133{ 
     134        const simplif::pair_buffer& pairs = vertex_info(v0).pairs; 
    135135 
    136136        for(int i=0; i<pairs.length(); i++) 
    … …  
    146146//      Create a new pair with two given vertices 
    147147//--------------------------------------------------------------------------- 
    148 qslim::pair_info *SimplificationMethod::new_pair(qslim::Vertex *v0, qslim::Vertex *v1) 
    149 { 
    150         qslim::vert_info& v0_info = vertex_info(v0); 
    151         qslim::vert_info& v1_info = vertex_info(v1); 
    152  
    153         qslim::pair_info *pair = new qslim::pair_info(v0,v1); 
     148simplif::pair_info *SimplificationMethod::new_pair(simplif::Vertex *v0, simplif::Vertex *v1) 
     149{ 
     150        simplif::vert_info& v0_info = vertex_info(v0); 
     151        simplif::vert_info& v1_info = vertex_info(v1); 
     152 
     153        simplif::pair_info *pair = new simplif::pair_info(v0,v1); 
    154154        v0_info.pairs.add(pair); 
    155155        v1_info.pairs.add(pair); 
    … …  
    161161//      Remove a given pair 
    162162//--------------------------------------------------------------------------- 
    163 void SimplificationMethod::delete_pair(qslim::pair_info *auxpair) 
    164 { 
    165         qslim::vert_info& v0_info = vertex_info(auxpair->v0); 
    166         qslim::vert_info& v1_info = vertex_info(auxpair->v1); 
     163void SimplificationMethod::delete_pair(simplif::pair_info *auxpair) 
     164{ 
     165        simplif::vert_info& v0_info = vertex_info(auxpair->v0); 
     166        simplif::vert_info& v1_info = vertex_info(auxpair->v1); 
    167167 
    168168        v0_info.pairs.remove(v0_info.pairs.find(auxpair)); 
    … …  
    178178//      Contract a given pair 
    179179//--------------------------------------------------------------------------- 
    180 void SimplificationMethod::do_contract(qslim::Model& m, qslim::pair_info *auxpair) 
    181 { 
    182         qslim::Vertex *v0 = auxpair->v0;  qslim::Vertex *v1 = auxpair->v1; 
    183         qslim::vert_info& v0_info = vertex_info(v0); 
    184         qslim::vert_info& v1_info = vertex_info(v1); 
    185         qslim::Vec3 vnew = auxpair->candidate; 
     180void SimplificationMethod::do_contract(simplif::Model& m, simplif::pair_info *auxpair) 
     181{ 
     182        simplif::Vertex *v0 = auxpair->v0;  simplif::Vertex *v1 = auxpair->v1; 
     183        simplif::vert_info& v0_info = vertex_info(v0); 
     184        simplif::vert_info& v1_info = vertex_info(v1); 
     185        simplif::Vec3 vnew = auxpair->candidate; 
    186186        int i; 
    187187 
    … …  
    190190        v0_info.norm += v1_info.norm; 
    191191 
    192         qslim::Vec3 p(vnew); 
    193         qslim::Vec3 v0antes(v0->operator[](qslim::X),v0->operator[](qslim::Y),v0->operator[](qslim::Z)); 
     192        simplif::Vec3 p(vnew); 
     193        simplif::Vec3 v0antes(v0->operator[](simplif::X),v0->operator[](simplif::Y),v0->operator[](simplif::Z)); 
    194194 
    195195        // Find the edge to remove (before remove it (contract())) 
    196         qslim::Edge *econ=NULL; 
     196        simplif::Edge *econ=NULL; 
    197197        bool finded = false; 
    198198        for (i=0; i<v0->edgeUses().length(); i++) 
    … …  
    210210 
    211211        // Perform the actual contraction 
    212         static qslim::face_buffer changed; 
     212        static simplif::face_buffer changed; 
    213213        changed.reset(); 
    214214        m.contract(v0, v1, vnew, changed); 
    … …  
    216216        // Stores the simplification step 
    217217        MeshSimplificationSequence::Step simplifstep; 
    218         qslim::Vec3 vdesp = p - v0antes; 
     218        simplif::Vec3 vdesp = p - v0antes; 
    219219 
    220220        // Stores the displacement in the simplification step 
    221         simplifstep.x=(float)vdesp[qslim::X]; 
    222         simplifstep.y = (float)vdesp[qslim::Y]; 
    223         simplifstep.z = (float)vdesp[qslim::Z]; 
     221        simplifstep.x=(float)vdesp[simplif::X]; 
     222        simplifstep.y = (float)vdesp[simplif::Y]; 
     223        simplifstep.z = (float)vdesp[simplif::Z]; 
    224224         
    225225        //      Submeshes which pertains each vertex 
    … …  
    245245        for (i=0; i<changed.length(); i++) 
    246246        { 
    247                 qslim::Face *auxface = changed(i); 
     247                simplif::Face *auxface = changed(i); 
    248248 
    249249                if (auxface->isValid()) 
    … …  
    291291        for(i=0; i<v0_info.pairs.length(); i++) 
    292292        { 
    293                 qslim::pair_info *p = v0_info.pairs(i); 
     293                simplif::pair_info *p = v0_info.pairs(i); 
    294294                compute_pair_info(p); 
    295295        } 
    296296 
    297297        // Process pairs associated with now dead vertex 
    298         static qslim::pair_buffer condemned(6); // collect condemned pairs for execution 
     298        static simplif::pair_buffer condemned(6); // collect condemned pairs for execution 
    299299        condemned.reset(); 
    300300 
    301301        for(i=0; i<v1_info.pairs.length(); i++) 
    302302        { 
    303                 qslim::pair_info *p = v1_info.pairs(i); 
    304  
    305                 qslim::Vertex *u; 
     303                simplif::pair_info *p = v1_info.pairs(i); 
     304 
     305                simplif::Vertex *u; 
    306306                if( p->v0 == v1 )       
    307307                        u = p->v1; 
    … …  
    332332//--------------------------------------------------------------------------- 
    333333//--------------------------------------------------------------------------- 
    334 bool SimplificationMethod::decimate_quadric(qslim::Vertex *v, qslim::Mat4& Q) 
     334bool SimplificationMethod::decimate_quadric(simplif::Vertex *v, simplif::Mat4& Q) 
    335335{ 
    336336        if( vinfo.length() > 0 ) 
    … …  
    346346//      Extract a pair from the heap, concract it and remove it form the heap 
    347347//--------------------------------------------------------------------------- 
    348 void SimplificationMethod::decimate_contract(qslim::Model& m) 
    349 { 
    350         qslim::heap_node *top; 
    351         qslim::pair_info *pair; 
     348void SimplificationMethod::decimate_contract(simplif::Model& m) 
     349{ 
     350        simplif::heap_node *top; 
     351        simplif::pair_info *pair; 
    352352 
    353353        for(;;) 
    … …  
    355355                top = heap->extract(); 
    356356                if( !top ) return; 
    357                 pair = (qslim::pair_info *)top->obj; 
     357                pair = (simplif::pair_info *)top->obj; 
    358358 
    359359                //Remove all the vertices of the removed edges 
    … …  
    361361                for (int i=0; i<pair->v0->edgeUses().length(); i++) 
    362362                {                
    363                         qslim::Edge *econ = pair->v0->edgeUses()(i); 
     363                        simplif::Edge *econ = pair->v0->edgeUses()(i); 
    364364                        if (pair->v1->vID == econ->org()->vID || pair->v1->vID == econ->dest()->vID) 
    365365                        { 
    … …  
    383383//--------------------------------------------------------------------------- 
    384384//--------------------------------------------------------------------------- 
    385 qslim::real SimplificationMethod::decimate_error(qslim::Vertex *v) 
    386 { 
    387         qslim::vert_info& info = vertex_info(v); 
    388  
    389         qslim::real err = qslim::quadrix_evaluate_vertex(*v, info.Q); 
    390  
    391     if( qslim::will_weight_by_area ) 
     385simplif::real SimplificationMethod::decimate_error(simplif::Vertex *v) 
     386{ 
     387        simplif::vert_info& info = vertex_info(v); 
     388 
     389        simplif::real err = simplif::quadrix_evaluate_vertex(*v, info.Q); 
     390 
     391    if( simplif::will_weight_by_area ) 
    392392                err /= info.norm; 
    393393 
    … …  
    398398//      Extract the minimum cost of the the valid nodes (not simplified) 
    399399//--------------------------------------------------------------------------- 
    400 qslim::real SimplificationMethod::decimate_min_error() 
    401 { 
    402         qslim::heap_node *top; 
    403         qslim::pair_info *pair; 
     400simplif::real SimplificationMethod::decimate_min_error() 
     401{ 
     402        simplif::heap_node *top; 
     403        simplif::pair_info *pair; 
    404404 
    405405        for(;;) 
    … …  
    407407                top = heap->top(); 
    408408                if( !top ) return -1.0; 
    409                 pair = (qslim::pair_info *)top->obj; 
     409                pair = (simplif::pair_info *)top->obj; 
    410410 
    411411                if( pair->isValid() ) 
    … …  
    422422//      Returns the maximum error by vertex 
    423423//--------------------------------------------------------------------------- 
    424 qslim::real SimplificationMethod::decimate_max_error(qslim::Model& m) 
    425 { 
    426         qslim::real max_err = 0; 
     424simplif::real SimplificationMethod::decimate_max_error(simplif::Model& m) 
     425{ 
     426        simplif::real max_err = 0; 
    427427 
    428428        for(int i=0; i<m.vertCount(); i++) 
    … …  
    438438//      Initializations 
    439439//--------------------------------------------------------------------------- 
    440 void SimplificationMethod::decimate_init(qslim::Model& m, qslim::real limit) 
     440void SimplificationMethod::decimate_init(simplif::Model& m, simplif::real limit) 
    441441{ 
    442442        int i,j; 
    … …  
    444444        vinfo.init(m.vertCount()); 
    445445 
    446         if( qslim::will_use_vertex_constraint ) 
     446        if( simplif::will_use_vertex_constraint ) 
    447447                for(i=0; i<m.vertCount(); i++) 
    448448                { 
    449                         qslim::Vertex *v = m.vertex(i); 
     449                        simplif::Vertex *v = m.vertex(i); 
    450450                        if( v->isValid() ) 
    451                                 vertex_info(v).Q = qslim::quadrix_vertex_constraint(*v); 
     451                                vertex_info(v).Q = simplif::quadrix_vertex_constraint(*v); 
    452452                } 
    453453 
    … …  
    455455                if( m.face(i)->isValid() ) 
    456456                { 
    457                         if( qslim::will_use_plane_constraint ) 
    458                         { 
    459                                 qslim::Mat4 Q = qslim::quadrix_plane_constraint(*m.face(i)); 
    460                                 qslim::real norm = 0.0; 
    461  
    462                                 if( qslim::will_weight_by_area ) 
     457                        if( simplif::will_use_plane_constraint ) 
     458                        { 
     459                                simplif::Mat4 Q = simplif::quadrix_plane_constraint(*m.face(i)); 
     460                                simplif::real norm = 0.0; 
     461 
     462                                if( simplif::will_weight_by_area ) 
    463463                                { 
    464464                                        norm = m.face(i)->area(); 
    … …  
    475475                } 
    476476 
    477         if( qslim::will_constrain_boundaries ) 
     477        if( simplif::will_constrain_boundaries ) 
    478478        { 
    479479                for(i=0; i<m.edgeCount(); i++) 
    480                         if( m.edge(i)->isValid() && qslim::check_for_discontinuity(m.edge(i)) ) 
    481                         { 
    482                                 qslim::Mat4 B = qslim::quadrix_discontinuity_constraint(m.edge(i)); 
    483                                 qslim::real norm = 0.0; 
    484  
    485                                 if( qslim::will_weight_by_area ) 
    486                                 { 
    487                                         norm = qslim::norm2(*m.edge(i)->org() - *m.edge(i)->dest()); 
     480                        if( m.edge(i)->isValid() && simplif::check_for_discontinuity(m.edge(i)) ) 
     481                        { 
     482                                simplif::Mat4 B = simplif::quadrix_discontinuity_constraint(m.edge(i)); 
     483                                simplif::real norm = 0.0; 
     484 
     485                                if( simplif::will_weight_by_area ) 
     486                                { 
     487                                        norm = simplif::norm2(*m.edge(i)->org() - *m.edge(i)->dest()); 
    488488                                        B *= norm; 
    489489                                } 
    490490 
    491                                 B *= qslim::boundary_constraint_weight; 
     491                                B *= simplif::boundary_constraint_weight; 
    492492                                vertex_info(m.edge(i)->org()).Q += B; 
    493493                                vertex_info(m.edge(i)->org()).norm += norm; 
    … …  
    497497        } 
    498498 
    499         heap = new qslim::Heap(m.validEdgeCount); 
     499        heap = new simplif::Heap(m.validEdgeCount); 
    500500 
    501501        int pair_count = 0; 
    … …  
    504504                if( m.edge(i)->isValid() ) 
    505505                { 
    506                         qslim::pair_info *pair = new_pair(m.edge(i)->org(), m.edge(i)->dest()); 
     506                        simplif::pair_info *pair = new_pair(m.edge(i)->org(), m.edge(i)->dest()); 
    507507                        //pointers_to_remove.push_back(pair); 
    508508                        compute_pair_info(pair); 
    … …  
    517517        if( proximity_limit > 0 ) 
    518518        { 
    519                 qslim::ProxGrid grid(m.bounds.min, m.bounds.max, limit); 
     519                simplif::ProxGrid grid(m.bounds.min, m.bounds.max, limit); 
    520520                for(i=0; i<m.vertCount(); i++) 
    521521                        grid.addPoint(m.vertex(i)); 
    522522 
    523                 qslim::buffer<qslim::Vec3 *> nearby(32); 
     523                simplif::buffer<simplif::Vec3 *> nearby(32); 
    524524                for(i=0; i<m.vertCount(); i++) 
    525525                { 
    … …  
    529529                        for(j=0; j<nearby.length(); j++) 
    530530                        { 
    531                                 qslim::Vertex *v1 = m.vertex(i); 
    532                                 qslim::Vertex *v2 = (qslim::Vertex *)nearby(j); 
     531                                simplif::Vertex *v1 = m.vertex(i); 
     532                                simplif::Vertex *v2 = (simplif::Vertex *)nearby(j); 
    533533 
    534534                                if( v1->isValid() && v2->isValid() ) 
    … …  
    539539                                        if( !check_for_pair(v1,v2) ) 
    540540                                        { 
    541                                                 qslim::pair_info *pair = new_pair(v1,v2); 
     541                                                simplif::pair_info *pair = new_pair(v1,v2); 
    542542                                                compute_pair_info(pair); 
    543543                                                pair_count++; 
    … …  
    586586void SimplificationMethod::simplifmethod_run(int finalfaces,TIPOFUNC upb) 
    587587{ 
    588         decimate_init(M0, qslim::pair_selection_tolerance); 
     588        decimate_init(M0, simplif::pair_selection_tolerance); 
    589589        unsigned        int     contador        =       0; 
    590590        float                                   percent; // simplification percentage. 
    … …  
    604604        decim_data.clear(); 
    605605 
    606         while( M0.validFaceCount > finalfaces/*qslim::face_target*/ 
     606        while( M0.validFaceCount > finalfaces/*simplif::face_target*/ 
    607607                        && M0.validFaceCount > 1 
    608                         && decimate_min_error() < qslim::error_tolerance )  
     608                        && decimate_min_error() < simplif::error_tolerance )  
    609609        { 
    610610                decimate_contract(M0); 
    … …  
    629629void SimplificationMethod::simplifmethod_runv(int numvertices,TIPOFUNC upb) 
    630630{ 
    631         decimate_init(M0, qslim::pair_selection_tolerance); 
     631        decimate_init(M0, simplif::pair_selection_tolerance); 
    632632        unsigned        int     contador        =       0; 
    633633        int                                             previousValidVertCount; 
    … …  
    650650        decim_data.clear(); 
    651651 
    652         while(  M0.validVertCount > numvertices /*qslim::face_target*/ 
     652        while(  M0.validVertCount > numvertices /*simplif::face_target*/ 
    653653                        && 
    654                         decimate_min_error() < qslim::error_tolerance 
     654                        decimate_min_error() < simplif::error_tolerance 
    655655                        && 
    656656                        previousValidVertCount  !=      M0.validVertCount) 
    … …  
    730730                                        { 
    731731                                                //If the vertex is not in vertices_map, then is added 
    732                                                 simplifindex=M0.in_Vertex(qslim::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].x,  
     732                                                simplifindex=M0.in_Vertex(simplif::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].x,  
    733733                                                                        objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].y, 
    734734                                                                        objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].z)); 
    735                                                 M0.in_Normal(qslim::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].x,  
     735                                                M0.in_Normal(simplif::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].x,  
    736736                                                                        objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].y, 
    737737                                                                        objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].z)); 
    738738 
    739                                                 M0.in_TexCoord(qslim::Vec2(objmesh->mSubMesh[i].mVertexBuffer->mTexCoords[j].x,  
     739                                                M0.in_TexCoord(simplif::Vec2(objmesh->mSubMesh[i].mVertexBuffer->mTexCoords[j].x,  
    740740                                                                        objmesh->mSubMesh[i].mVertexBuffer->mTexCoords[j].y)); 
    741741                                                vertices_map[auxvert] = num_final_verts; 
    … …  
    777777                                        { 
    778778                                                //If the vertex is not in vertices_map, then is added 
    779                                                 simplifindex=M0.in_Vertex(qslim::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].x,  
     779                                                simplifindex=M0.in_Vertex(simplif::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].x,  
    780780                                                                        objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].y, 
    781781                                                                        objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].z)); 
    782                                                 M0.in_Normal(qslim::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].x,  
     782                                                M0.in_Normal(simplif::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].x,  
    783783                                                                        objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].y, 
    784784                                                                        objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].z)); 
    785                                                 M0.in_TexCoord(qslim::Vec2(0.0,0.0)); 
     785                                                M0.in_TexCoord(simplif::Vec2(0.0,0.0)); 
    786786                                                vertices_map[auxvert] = num_final_verts; 
    787787                                                num_final_verts ++; 
    … …  
    970970                if (M0.face(i)->isValid()) 
    971971                { 
    972                         qslim::Face *auxface    =       M0.face(i); 
     972                        simplif::Face *auxface  =       M0.face(i); 
    973973 
    974974                        //      Determine to which submesh pertains the triangle. 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/SimplificationMethod.h

    r1007 r1025  
    66#include <list> 
    77#include <iostream> 
    8 #include <qslim.h> 
     8#include <simplif.h> 
    99#include <GeoMeshSimplifier.h> 
    1010 
    … …  
    1313private: 
    1414        Geometry::Mesh  *mGeoMesh; 
    15         void compute_pair_info(qslim::pair_info*); 
    16         qslim::Model M0; 
    17         qslim::array<qslim::vert_info> vinfo; 
    18         qslim::Heap *heap; 
    19         qslim::real proximity_limit;    // distance threshold squared 
     15        void compute_pair_info(simplif::pair_info*); 
     16        simplif::Model M0; 
     17        simplif::array<simplif::vert_info> vinfo; 
     18        simplif::Heap *heap; 
     19        simplif::real proximity_limit;    // distance threshold squared 
    2020        int initialVertCount; 
    2121        int initialEdgeCount; 
    2222        int initialFaceCount; 
    2323 
    24         inline qslim::vert_info& vertex_info(qslim::Vertex *v) 
     24        inline simplif::vert_info& vertex_info(simplif::Vertex *v) 
    2525        { 
    2626                return vinfo(v->validID()); 
    2727        } 
    2828         
    29         qslim::real pair_mesh_penalty(qslim::Model& M, 
    30                                                                                                                                 qslim::Vertex *v1, 
    31                                                                                                                                 qslim::Vertex *v2, 
    32                                                                                                                                 qslim::Vec3& vnew); 
     29        simplif::real pair_mesh_penalty(simplif::Model& M, 
     30                                                                                                                                simplif::Vertex *v1, 
     31                                                                                                                                simplif::Vertex *v2, 
     32                                                                                                                                simplif::Vec3& vnew); 
    3333         
    34         int predict_face(qslim::Face& F, 
    35                                                                         qslim::Vertex *v1, 
    36                                                                         qslim::Vertex *v2, 
    37                                                                         qslim::Vec3& vnew, 
    38                                                                         qslim::Vec3& f1, 
    39                                                                         qslim::Vec3& f2, 
    40                                                                         qslim::Vec3& f3); 
     34        int predict_face(simplif::Face& F, 
     35                                                                        simplif::Vertex *v1, 
     36                                                                        simplif::Vertex *v2, 
     37                                                                        simplif::Vec3& vnew, 
     38                                                                        simplif::Vec3& f1, 
     39                                                                        simplif::Vec3& f2, 
     40                                                                        simplif::Vec3& f3); 
    4141         
    42         bool check_for_pair(qslim::Vertex *v0, qslim::Vertex *v1); 
     42        bool check_for_pair(simplif::Vertex *v0, simplif::Vertex *v1); 
    4343         
    44         qslim::pair_info *new_pair(qslim::Vertex *v0, qslim::Vertex *v1); 
     44        simplif::pair_info *new_pair(simplif::Vertex *v0, simplif::Vertex *v1); 
    4545         
    46         void delete_pair(qslim::pair_info *pair); 
     46        void delete_pair(simplif::pair_info *pair); 
    4747         
    48         void do_contract(qslim::Model& m, qslim::pair_info *pair); 
     48        void do_contract(simplif::Model& m, simplif::pair_info *pair); 
    4949         
    50         bool decimate_quadric(qslim::Vertex *v, qslim::Mat4& Q); 
     50        bool decimate_quadric(simplif::Vertex *v, simplif::Mat4& Q); 
    5151         
    52         void decimate_contract(qslim::Model& m); 
     52        void decimate_contract(simplif::Model& m); 
    5353         
    54         qslim::real decimate_error(qslim::Vertex *v); 
     54        simplif::real decimate_error(simplif::Vertex *v); 
    5555         
    56         qslim::real decimate_min_error(); 
     56        simplif::real decimate_min_error(); 
    5757         
    58         qslim::real decimate_max_error(qslim::Model& m); 
     58        simplif::real decimate_max_error(simplif::Model& m); 
    5959         
    60         void decimate_init(qslim::Model& m, qslim::real limit); 
     60        void decimate_init(simplif::Model& m, simplif::real limit); 
    6161         
    62         bool pair_is_valid(qslim::Vertex *u, qslim::Vertex *v); 
     62        bool pair_is_valid(simplif::Vertex *u, simplif::Vertex *v); 
    6363         
    6464        void simplifmethod_run(int,     Geometry::TIPOFUNC      upb=0); 
    … …  
    8585        unsigned int *first_index_submesh; 
    8686         
    87         //std::vector<qslim::pair_info *> pointers_to_remove; 
     87        //std::vector<simplif::pair_info *> pointers_to_remove; 
    8888 
    8989        int indexMeshLeaves; 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/avars.cxx

    r981 r1025  
    99// GLOBAL SIMPLIFICATION OPTIONS 
    1010 
    11 int qslim::face_target = 0; 
    12 qslim::real qslim::error_tolerance = HUGE; 
     11int simplif::face_target = 0; 
     12simplif::real simplif::error_tolerance = HUGE; 
    1313 
    1414 
    15 bool qslim::will_use_plane_constraint = true; 
    16 bool qslim::will_use_vertex_constraint = true; 
     15bool simplif::will_use_plane_constraint = true; 
     16bool simplif::will_use_vertex_constraint = true; 
    1717 
    18 bool qslim::will_preserve_boundaries = true; 
    19 bool qslim::will_preserve_mesh_quality = true; 
    20 bool qslim::will_constrain_boundaries = true; 
    21 qslim::real qslim::boundary_constraint_weight = 1.0; 
     18bool simplif::will_preserve_boundaries = true; 
     19bool simplif::will_preserve_mesh_quality = true; 
     20bool simplif::will_constrain_boundaries = true; 
     21simplif::real simplif::boundary_constraint_weight = 1.0; 
    2222 
    23 bool qslim::will_weight_by_area = false; 
     23bool simplif::will_weight_by_area = false; 
    2424 
    25 int qslim::placement_policy = PLACE_ENDPOINTS; 
     25int simplif::placement_policy = PLACE_ENDPOINTS; 
    2626 
    27 qslim::real qslim::pair_selection_tolerance = 0.0; 
     27simplif::real simplif::pair_selection_tolerance = 0.0; 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/avars.h

    r774 r1025  
    22#include <gfx/SMF/smf.h> 
    33 
    4 namespace qslim 
     4namespace simplif 
    55{ 
    66//      extern ostream *outfile; 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smf.cxx

    r774 r1025  
    99#include <gfx/SMF/smfstate.h> 
    1010 
    11 using namespace qslim; 
     11using namespace simplif; 
    1212 
    1313inline int streq(const char *a,const char *b) { return strcmp(a,b)==0; } 
    1414 
    15 float qslim::SMF_version = 1.0; 
    16 char *qslim::SMF_version_string = "1.0"; 
     15float simplif::SMF_version = 1.0; 
     16char *simplif::SMF_version_string = "1.0"; 
    1717char *SMF_source_revision = "$Id: smf.cxx,v 1.1 1997/06/16 22:11:40 garland Exp $"; 
    1818 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smf.h

    r774 r1025  
    1717 
    1818 
    19 namespace qslim 
     19namespace simplif 
    2020{ 
    2121        #define SMF_MAXLINE 4096 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smfstate.cxx

    r774 r1025  
    88inline int streq(const char *a,const char *b) { return strcmp(a,b)==0; } 
    99 
    10 using namespace qslim; 
     10using namespace simplif; 
    1111 
    1212SMF_State::SMF_State(const SMF_ivars& ivar, SMF_State *link) 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smfstate.h

    r774 r1025  
    22#define GFXSMF_STATE_INCLUDED 
    33 
    4 namespace qslim 
     4namespace simplif 
    55{ 
    66        class SMF_State 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/3D.cxx

    r774 r1025  
    33#include <gfx/geom/3D.h> 
    44 
    5 using namespace qslim; 
     5using namespace simplif; 
    66 
    77Vec3 randomPoint(const Vec3& v1, const Vec3& v2) 
    … …  
    2121} 
    2222 
    23 real qslim::triangleArea(const Vec3& v1, const Vec3& v2, const Vec3& v3) 
     23real simplif::triangleArea(const Vec3& v1, const Vec3& v2, const Vec3& v3) 
    2424{ 
    2525    Vec3 a = v2 - v1; 
    … …  
    3838    real L3 = norm2(v1-v3); 
    3939 
    40     return FOUR_ROOT3 * qslim::triangleArea(v1,v2,v3) / (L1+L2+L3); 
     40    return FOUR_ROOT3 * simplif::triangleArea(v1,v2,v3) / (L1+L2+L3); 
    4141} 
    4242 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/3D.h

    r774 r1025  
    1010// 
    1111 
    12 namespace qslim 
     12namespace simplif 
    1313{ 
    1414        extern Vec3 randomPoint(const Vec3&, const Vec3&);  // on segment 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/ProjectH.cxx

    r774 r1025  
    2727#define DOTP(a, b) (a[0] * b[0] + a[1] * b[1] + a[2] * b[2]) 
    2828 
    29 using namespace qslim; 
     29using namespace simplif; 
    3030 
    3131static real Distance2(real x[3], real *y) 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/ProxGrid.cxx

    r774 r1025  
    66#include <gfx/geom/ProxGrid.h> 
    77 
    8 using namespace qslim; 
     8using namespace simplif; 
    99 
    1010ProxGrid::ProxGrid(const Vec3& lo, const Vec3& hi, real dist) 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/ProxGrid.h

    r774 r1025  
    77 
    88 
    9 namespace qslim 
     9namespace simplif 
    1010{ 
    1111        class ProxGrid_Cell : public buffer<Vec3 *> 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat2.cxx

    r774 r1025  
    22#include <gfx/math/Mat2.h> 
    33 
    4 using namespace qslim; 
     4using namespace simplif; 
    55 
    66Mat2 Mat2::identity(Vec2(1,0), Vec2(0,1)); 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat2.h

    r774 r1025  
    44#include <gfx/math/Vec2.h> 
    55 
    6 namespace qslim 
     6namespace simplif 
    77{ 
    88        class Mat2 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat3.cxx

    r774 r1025  
    22#include <gfx/math/Mat3.h> 
    33 
    4 using namespace qslim; 
     4using namespace simplif; 
    55 
    66Mat3 Mat3::identity(Vec3(1,0,0), Vec3(0,1,0), Vec3(0,0,1)); 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat3.h

    r774 r1025  
    55#include <ostream> 
    66 
    7 namespace qslim 
     7namespace simplif 
    88{ 
    99        class Mat3 
    … …  
    6464 
    6565//              // Input/Output methods 
    66 //              friend std::ostream& operator<<(std::ostream&, const qslim::Mat3&); 
    67 //              friend std::istream& operator>>(std::istream&, qslim::Mat3&); 
     66//              friend std::ostream& operator<<(std::ostream&, const simplif::Mat3&); 
     67//              friend std::istream& operator>>(std::istream&, simplif::Mat3&); 
    6868        }; 
    6969 
    … …  
    134134 
    135135/* 
    136 inline std::ostream& operator<<(std::ostream& out, const qslim::Mat3& M) 
     136inline std::ostream& operator<<(std::ostream& out, const simplif::Mat3& M) 
    137137{ 
    138138    return out << M.row[0] << endl << M.row[1] << endl << M.row[2]; 
    … …  
    144144} 
    145145*/ 
    146 extern bool jacobi(const qslim::Mat3& m, qslim::Vec3& vals, qslim::Vec3 vecs[3]); 
     146extern bool jacobi(const simplif::Mat3& m, simplif::Vec3& vals, simplif::Vec3 vecs[3]); 
    147147 
    148148 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat4.cxx

    r774 r1025  
    22#include <gfx/math/Mat4.h> 
    33 
    4 using namespace qslim; 
     4using namespace simplif; 
    55 
    66Mat4 Mat4::identity(Vec4(1,0,0,0),Vec4(0,1,0,0),Vec4(0,0,1,0),Vec4(0,0,0,1)); 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat4.h

    r774 r1025  
    1313#include <gfx/math/Vec4.h> 
    1414 
    15 namespace qslim 
     15namespace simplif 
    1616{ 
    1717        class Mat4 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Vec2.h

    r774 r1025  
    1010 ************************************************************************/ 
    1111 
    12 namespace qslim 
     12namespace simplif 
    1313{ 
    1414        class Vec2 { 
    … …  
    7878        // 
    7979 
    80         inline void qslim::Vec2::copy(const qslim::Vec2& v) 
     80        inline void simplif::Vec2::copy(const simplif::Vec2& v) 
    8181        { 
    8282                elt[0]=v.elt[0]; elt[1]=v.elt[1]; 
    8383        } 
    8484 
    85         inline bool qslim::Vec2::operator==(const qslim::Vec2& v) const 
     85        inline bool simplif::Vec2::operator==(const simplif::Vec2& v) const 
    8686        { 
    8787                real dx=elt[X]-v[X],  dy=elt[Y]-v[Y]; 
    … …  
    8989        } 
    9090 
    91         inline bool qslim::Vec2::operator!=(const qslim::Vec2& v) const 
     91        inline bool simplif::Vec2::operator!=(const simplif::Vec2& v) const 
    9292        { 
    9393                real dx=elt[X]-v[X],  dy=elt[Y]-v[Y]; 
    … …  
    9595        } 
    9696 
    97         inline qslim::Vec2& qslim::Vec2::operator=(const qslim::Vec2& v) 
     97        inline simplif::Vec2& simplif::Vec2::operator=(const simplif::Vec2& v) 
    9898        { 
    9999                copy(v); 
    … …  
    101101        } 
    102102 
    103         inline qslim::Vec2& qslim::Vec2::operator+=(const qslim::Vec2& v) 
     103        inline simplif::Vec2& simplif::Vec2::operator+=(const simplif::Vec2& v) 
    104104        { 
    105105                elt[0] += v[0];   elt[1] += v[1]; 
    … …  
    107107        } 
    108108 
    109         inline qslim::Vec2& qslim::Vec2::operator-=(const qslim::Vec2& v) 
     109        inline simplif::Vec2& simplif::Vec2::operator-=(const simplif::Vec2& v) 
    110110        { 
    111111                elt[0] -= v[0];   elt[1] -= v[1]; 
    … …  
    113113        } 
    114114 
    115         inline qslim::Vec2& qslim::Vec2::operator*=(qslim::real s) 
     115        inline simplif::Vec2& simplif::Vec2::operator*=(simplif::real s) 
    116116        { 
    117117                elt[0] *= s;   elt[1] *= s; 
    … …  
    119119        } 
    120120 
    121         inline qslim::Vec2& qslim::Vec2::operator/=(qslim::real s) 
     121        inline simplif::Vec2& simplif::Vec2::operator/=(simplif::real s) 
    122122        { 
    123123                elt[0] /= s;   elt[1] /= s; 
    … …  
    125125        } 
    126126 
    127         inline qslim::Vec2 qslim::Vec2::operator+(const qslim::Vec2& v) const 
     127        inline simplif::Vec2 simplif::Vec2::operator+(const simplif::Vec2& v) const 
    128128        { 
    129129                return Vec2(elt[0]+v[0], elt[1]+v[1]); 
    130130        } 
    131131 
    132         inline qslim::Vec2 qslim::Vec2::operator-(const qslim::Vec2& v) const 
     132        inline simplif::Vec2 simplif::Vec2::operator-(const simplif::Vec2& v) const 
    133133        { 
    134134                return Vec2(elt[0]-v[0], elt[1]-v[1]); 
    135135        } 
    136136 
    137         inline qslim::Vec2 qslim::Vec2::operator-() const 
    138         { 
    139                 return qslim::Vec2(-elt[0], -elt[1]); 
    140         } 
    141  
    142         inline qslim::Vec2 qslim::Vec2::operator*(qslim::real s) const 
     137        inline simplif::Vec2 simplif::Vec2::operator-() const 
     138        { 
     139                return simplif::Vec2(-elt[0], -elt[1]); 
     140        } 
     141 
     142        inline simplif::Vec2 simplif::Vec2::operator*(simplif::real s) const 
    143143        { 
    144144                return Vec2(elt[0]*s, elt[1]*s); 
    145145        } 
    146146 
    147         inline qslim::Vec2 qslim::Vec2::operator/(qslim::real s) const 
     147        inline simplif::Vec2 simplif::Vec2::operator/(simplif::real s) const 
    148148        { 
    149149                return Vec2(elt[0]/s, elt[1]/s); 
    150150        } 
    151151 
    152         inline qslim::real qslim::Vec2::operator*(const qslim::Vec2& v) const 
     152        inline simplif::real simplif::Vec2::operator*(const simplif::Vec2& v) const 
    153153        { 
    154154                return elt[0]*v[0] + elt[1]*v[1]; 
    … …  
    156156 
    157157        // Make scalar multiplication commutative 
    158         inline qslim::Vec2 operator*(qslim::real s, const qslim::Vec2& v) { return v*s; } 
     158        inline simplif::Vec2 operator*(simplif::real s, const simplif::Vec2& v) { return v*s; } 
    159159 
    160160 
    … …  
    164164        // 
    165165 
    166 namespace qslim 
     166namespace simplif 
    167167{ 
    168         inline real norm(const qslim::Vec2& v) { return sqrt(v[0]*v[0] + v[1]*v[1]); } 
    169         inline real norm2(const qslim::Vec2& v) { return v[0]*v[0] + v[1]*v[1]; } 
    170         inline real length(const qslim::Vec2& v) { return norm(v); } 
    171  
    172         inline real unitize(qslim::Vec2& v) 
    173         { 
    174                 qslim::real l=norm2(v); 
     168        inline real norm(const simplif::Vec2& v) { return sqrt(v[0]*v[0] + v[1]*v[1]); } 
     169        inline real norm2(const simplif::Vec2& v) { return v[0]*v[0] + v[1]*v[1]; } 
     170        inline real length(const simplif::Vec2& v) { return norm(v); } 
     171 
     172        inline real unitize(simplif::Vec2& v) 
     173        { 
     174                simplif::real l=norm2(v); 
    175175                if( l!=1.0 && l!=0.0 ) 
    176176                { 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Vec3.h

    r774 r1025  
    1212#include "../std.h" 
    1313 
    14 namespace qslim 
     14namespace simplif 
    1515{ 
    1616        class Vec3 { 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Vec4.h

    r774 r1025  
    1010 ************************************************************************/ 
    1111 
    12 namespace qslim 
     12namespace simplif 
    1313{ 
    1414        class Vec4 { 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/cholesky.cxx

    r774 r1025  
    1212// 
    1313 
    14 using namespace qslim; 
     14using namespace simplif; 
    1515 
    1616bool cholesky(Mat4& a, Vec4& p) 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/jacobi.cxx

    r774 r1025  
    2020// 
    2121 
    22 using namespace qslim; 
     22using namespace simplif; 
    2323 
    2424static 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/random.h

    r774 r1025  
    55#include <limits.h> 
    66 
    7 namespace qslim 
     7namespace simplif 
    88{ 
    99        // 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/std.h

    r774 r1025  
    1818 
    1919 
    20 namespace qslim 
     20namespace simplif 
    2121{ 
    2222        // 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Array.h

    r774 r1025  
    55#include "../std.h" 
    66 
    7 namespace qslim 
     7namespace simplif 
    88{ 
    99        template<class T> 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Buffer.h

    r774 r1025  
    44#include <gfx/tools/Array.h> 
    55 
    6 namespace qslim 
     6namespace simplif 
    77{ 
    88        template<class T> 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Heap.h

    r774 r1025  
    1212// 
    1313 
    14 namespace qslim 
     14namespace simplif 
    1515{ 
    1616        class Heapable 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/heap.cxx

    r774 r1025  
    33#include <gfx/tools/Heap.h> 
    44 
    5 using namespace qslim; 
     5using namespace simplif; 
    66 
    77void Heap::swap(int i,int j) 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/quadrics.cxx

    r774 r1025  
    11// $Id: quadrics.cxx,v 1.5 1997/10/01 14:07:28 garland Exp $ 
    22 
    3 #include "qslim.h" 
     3#include "simplif.h" 
    44#include "quadrics.h" 
    55 
    … …  
    1616// 
    1717 
    18 using namespace qslim; 
    19  
    20 Mat4 qslim::quadrix_vertex_constraint(const Vec3& v) 
     18using namespace simplif; 
     19 
     20Mat4 simplif::quadrix_vertex_constraint(const Vec3& v) 
    2121{ 
    2222    Mat4 L(Mat4::identity); 
    … …  
    3939// quadric" discussed in the paper. 
    4040// 
    41 Mat4 qslim::quadrix_plane_constraint(real a, real b, real c, real d) 
     41Mat4 simplif::quadrix_plane_constraint(real a, real b, real c, real d) 
    4242{ 
    4343    Mat4 K(Mat4::zero); 
    … …  
    5454// Define some other convenient ways for constructing these plane quadrics. 
    5555// 
    56 Mat4 qslim::quadrix_plane_constraint(const Vec3& n, real d) 
    57 { 
    58     return qslim::quadrix_plane_constraint(n[X], n[Y], n[Z], d); 
    59 } 
    60  
    61 Mat4 qslim::quadrix_plane_constraint(Face& T) 
     56Mat4 simplif::quadrix_plane_constraint(const Vec3& n, real d) 
     57{ 
     58    return simplif::quadrix_plane_constraint(n[X], n[Y], n[Z], d); 
     59} 
     60 
     61Mat4 simplif::quadrix_plane_constraint(Face& T) 
    6262{ 
    6363    const Plane& p = T.plane(); 
    … …  
    6565    p.coeffs(&a, &b, &c, &d); 
    6666 
    67     return qslim::quadrix_plane_constraint(a, b, c, d); 
    68 } 
    69  
    70 qslim::Mat4 qslim::quadrix_plane_constraint(const qslim::Vec3& v1, const qslim::Vec3& v2, const qslim::Vec3& v3) 
     67    return simplif::quadrix_plane_constraint(a, b, c, d); 
     68} 
     69 
     70simplif::Mat4 simplif::quadrix_plane_constraint(const simplif::Vec3& v1, const simplif::Vec3& v2, const simplif::Vec3& v3) 
    7171{ 
    7272    Plane P(v1,v2,v3); 
    … …  
    7474    P.coeffs(&a, &b, &c, &d); 
    7575 
    76     return qslim::quadrix_plane_constraint(a, b, c, d); 
    77 } 
    78  
    79 real qslim::quadrix_evaluate_vertex(const Vec3& v, const Mat4& K) 
     76    return simplif::quadrix_plane_constraint(a, b, c, d); 
     77} 
     78 
     79real simplif::quadrix_evaluate_vertex(const Vec3& v, const Mat4& K) 
    8080{ 
    8181    real x=v[X], y=v[Y], z=v[Z]; 
    … …  
    113113} 
    114114 
    115 bool qslim::check_for_discontinuity(Edge *e) 
     115bool simplif::check_for_discontinuity(Edge *e) 
    116116{ 
    117117    return is_border(e); 
    118118} 
    119119 
    120 Mat4 qslim::quadrix_discontinuity_constraint(Edge *edge, const Vec3& n) 
     120Mat4 simplif::quadrix_discontinuity_constraint(Edge *edge, const Vec3& n) 
    121121{ 
    122122    Vec3& org = *edge->org(); 
    … …  
    128128 
    129129    real d = -n2 * org; 
    130     return qslim::quadrix_plane_constraint(n2, d); 
    131 } 
    132  
    133  
    134 Mat4 qslim::quadrix_discontinuity_constraint(Edge *edge) 
     130    return simplif::quadrix_plane_constraint(n2, d); 
     131} 
     132 
     133 
     134Mat4 simplif::quadrix_discontinuity_constraint(Edge *edge) 
    135135{ 
    136136    Mat4 D(Mat4::zero); 
    … …  
    139139 
    140140    for(int i=0; i<faces.length(); i++) 
    141                 D += qslim::quadrix_discontinuity_constraint(edge,faces(i)->plane().normal()); 
     141                D += simplif::quadrix_discontinuity_constraint(edge,faces(i)->plane().normal()); 
    142142 
    143143    return D; 
    … …  
    150150// 
    151151 
    152 bool qslim::quadrix_find_local_fit(const Mat4& K, 
     152bool simplif::quadrix_find_local_fit(const Mat4& K, 
    153153                            const Vec3& v1, const Vec3& v2, 
    154154                            Vec3& candidate) 
    … …  
    159159    bool try_midpoint = placement_policy > PLACE_ENDPOINTS; 
    160160 
    161     real c1 = qslim::quadrix_evaluate_vertex(v1, K); 
    162     real c2 = qslim::quadrix_evaluate_vertex(v2, K); 
     161    real c1 = simplif::quadrix_evaluate_vertex(v1, K); 
     162    real c2 = simplif::quadrix_evaluate_vertex(v2, K); 
    163163    real c3; 
    164     if( try_midpoint ) c3 = qslim::quadrix_evaluate_vertex(v3, K); 
     164    if( try_midpoint ) c3 = simplif::quadrix_evaluate_vertex(v3, K); 
    165165 
    166166    if( c1<c2 ) 
    … …  
    182182} 
    183183 
    184 bool qslim::quadrix_find_line_fit(const Mat4& Q, 
     184bool simplif::quadrix_find_line_fit(const Mat4& Q, 
    185185                           const Vec3& v1, const Vec3& v2, 
    186186                           Vec3& candidate) 
    … …  
    206206} 
    207207 
    208 bool qslim::quadrix_find_best_fit(const Mat4& Q, Vec3& candidate) 
     208bool simplif::quadrix_find_best_fit(const Mat4& Q, Vec3& candidate) 
    209209{ 
    210210    Mat4 K = Q; 
    … …  
    237237#include <assert.h> 
    238238 
    239 real qslim::quadrix_pair_target(const Mat4& Q, 
     239real simplif::quadrix_pair_target(const Mat4& Q, 
    240240                         Vertex *v1, 
    241241                         Vertex *v2, 
    … …  
    257257        { 
    258258            candidate = *v1; 
    259             return qslim::quadrix_evaluate_vertex(candidate, Q); 
     259            return simplif::quadrix_evaluate_vertex(candidate, Q); 
    260260        } 
    261261        else if( c2 > c1 ) 
    262262        { 
    263263            candidate = *v2; 
    264             return qslim::quadrix_evaluate_vertex(candidate, Q); 
     264            return simplif::quadrix_evaluate_vertex(candidate, Q); 
    265265        } 
    266266        else if( c1>0 && policy>PLACE_LINE ) 
    … …  
    273273    { 
    274274    case PLACE_OPTIMAL: 
    275         if( qslim::quadrix_find_best_fit(Q, candidate) ) 
     275        if( simplif::quadrix_find_best_fit(Q, candidate) ) 
    276276            break; 
    277277 
    278278    case PLACE_LINE: 
    279         if( qslim::quadrix_find_line_fit(Q, *v1, *v2, candidate) ) 
     279        if( simplif::quadrix_find_line_fit(Q, *v1, *v2, candidate) ) 
    280280            break; 
    281281 
    282282    default: 
    283                 qslim::quadrix_find_local_fit(Q, *v1, *v2, candidate); 
     283                simplif::quadrix_find_local_fit(Q, *v1, *v2, candidate); 
    284284                break; 
    285285    } 
    286286 
    287     return qslim::quadrix_evaluate_vertex(candidate, Q); 
    288 } 
     287    return simplif::quadrix_evaluate_vertex(candidate, Q); 
     288} 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/quadrics.h

    r774 r1025  
    55#include <gfx/math/Mat4.h> 
    66 
    7 namespace qslim 
     7namespace simplif 
    88{ 
    99        extern Mat4 quadrix_vertex_constraint(const Vec3&); 
Note: See TracChangeset for help on using the changeset viewer.