| TerraLib 4.1

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files
- Examples

- File List
- File Members

E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeTin.h
Go to the documentation of this file.

    00001 /************************************************************************************
    00002 TerraLib - a library for developing GIS applications.
    00003 Copyright © 2001-2007 INPE and Tecgraf/PUC-Rio.
    00004
    00005 This code is part of the TerraLib library.
    00006 This library is free software; you can redistribute it and/or
    00007 modify it under the terms of the GNU Lesser General Public
    00008 License as published by the Free Software Foundation; either
    00009 version 2.1 of the License, or (at your option) any later version.
    00010
    00011 You should have received a copy of the GNU Lesser General Public
    00012 License along with this library.
    00013
    00014 The authors reassure the license terms regarding the warranties.
    00015 They specifically disclaim any warranties, including, but not limited to,
    00016 the implied warranties of merchantability and fitness for a particular purpose.
    00017 The library provided hereunder is on an "as is" basis, and the authors have no
    00018 obligation to provide maintenance, support, updates, enhancements, or modifications.
    00019 In no event shall INPE and Tecgraf / PUC-Rio be held liable to any party for direct,
    00020 indirect, special, incidental, or consequential damages arising out of the use
    00021 of this library and its documentation.
    00022 *************************************************************************************/
    00026 #ifndef  __TERRALIB_INTERNAL_TIN_H
    00027 #define  __TERRALIB_INTERNAL_TIN_H
    00028
    00029 #include "TeGeometry.h"
    00030 #include "TeLayer.h"
    00031 #include "TeQuerier.h"
    00032 #include "TeDatabase.h"
    00033 #include "TeKdTree.h"
    00034 #include "TeRTree.h"
    00035
    00036 #include <list>
    00037 #include <set>
    00038
    00039 typedef TeSAM::TeKdTreeNode<TeCoord2D, unsigned int, unsigned int> TimKdTreeNode;
    00040
    00046 const double          TeTinBIGFLOAT = TeMAXFLOAT / 10.;
    00047
    00049 //enum TeTinVertexType
    00050 //{ DELETEDVERTEX = -1, NORMALVERTEX = 0, ONCONTOURVERTEX = 1, ONBREAKLINEVERTEX = 0x10 };
    00051
    00052 enum TeTinVertexType
    00053 { DELETEDVERTEX = -1, NORMALVERTEX = 0, ONCONTOURVERTEX = 1, ONBOXVERTEX = 2, ONBREAKLINEVERTEX = 3,
    00054   CONTOURFIRSTVERTEX = 4, CONTOURLASTVERTEX = 5, BREAKLINEFIRSTVERTEX = 6, BREAKLINELASTVERTEX = 7};
    00055 //{ DELETEDVERTEX = -1, NORMALVERTEX = 0, ONCONTOURVERTEX = 1, ONBOXVERTEX = 2, ONBREAKLINEVERTEX = 0x10 };
    00056
    00058
    00061 class TL_DLL TeTinVertex : public TeGeomSingle<TeCoord2D>, public TeMeasure
    00062 {
    00063 public:
    00064
    00066            TeTinVertex() : TeMeasure ( TeMAXFLOAT ), oneEdge_ (-1) {}
    00067
    00069            TeTinVertex( TeCoord2D xy, double value, TeTinVertexType type,
    00070                       long edge ) :
    00071                       TeGeomSingle<TeCoord2D> (xy), TeMeasure ( value ),
    00072                        type_ (type), oneEdge_ ( edge )
    00073                       { if ( ! xy.tooBig() ) TeGeometry::setBox(TeBox(xy,xy)); }
    00074
    00075 // -- Methods
    00076 //
    00078            bool operator== (const TeTinVertex& other) const
    00079            {
    00080                       if((value_ == other.value_) && (type_ == other.type_) )
    00081                       {
    00082                                  TeCoord2D p1 = location();
    00083                                  TeCoord2D p2 = other.location();
    00084                                  return p1==p2;
    00085                       }
    00086                       return false;
    00087            }
    00088
    00089            long oneEdge ()
    00090            { return oneEdge_; }
    00091
    00092            void setOneEdge (long oneEdge)
    00093            { oneEdge_ = oneEdge; }
    00094
    00095            TeTinVertexType type ()
    00096            { return type_; }
    00097
    00098            void setType (TeTinVertexType type)
    00099            { type_ = type; }
    00100
    00101            void value (double value)
    00102            { value_ = value; }
    00103
    00104
    00105
    00106            double value ()
    00107            { return value_; }
    00108
    00109
    00110            TeGeomRep elemType() { return TeSAMPLES; }
    00111
    00112 private:
    00113
    00114            TeTinVertexType type_;
    00115            long         oneEdge_;
    00116
    00117 };
    00118
    00120 class TL_DLL TeTinVertexSet : public TeGeomComposite <TeTinVertex>
    00121 {
    00122 public:
    00123
    00124 // -- Constructors
    00125
    00126            TeTinVertexSet() {}
    00127
    00128 // -- Methods
    00129
    00130            bool loadFromFile (std::string &fileName);
    00131
    00132            TeGeomRep elemType() { return TeSAMPLES; }
    00133 };
    00134
    00136 enum TeTinEdgeType
    00137 { DELETEDEDGE = -1, NORMALEDGE = 0, ONCONTOUREDGE = 1, ONBREAKLINEEDGE = 2 };
    00138
    00140
    00143 class TL_DLL TeTinEdge : public TeGeometry
    00144 {
    00145 public:
    00146
    00147 // -- Constructors
    00148
    00149            TeTinEdge() {}
    00150            TeTinEdge(long from, long to, long left, long right,
    00151                       TeTinEdgeType type) :
    00152            from_ (from), to_ (to), left_ (left), right_ (right), type_ (type)
    00153            {}
    00154
    00155 // -- Methods
    00156
    00158            bool operator== (const TeTinEdge& other) const
    00159            {
    00160                       if( (to_ == other.to_) && (from_ == other.from_) &&
    00161                                  (left_ == other.left_) && (right_ == other.right_) &&
    00162                                  (type_ == other.type_) )
    00163                                  return true;
    00164
    00165                       return false;
    00166            }
    00167
    00168            long from ()
    00169            { return from_; }
    00170
    00171            long to ()
    00172            { return to_; }
    00173
    00174            void setVertices (long from, long to)
    00175            {
    00176                       from_ = from;
    00177                       to_ = to;
    00178            }
    00179
    00180            void swapVertices ()
    00181            {
    00182                       long aux = from_;
    00183                       from_ = to_;
    00184                       to_ = aux;
    00185            }
    00186
    00187            long left ()
    00188            { return left_; }
    00189
    00190            long right ()
    00191            { return right_; }
    00192
    00193            void setTriangles (long left, long right)
    00194            {
    00195                       left_ = left;
    00196                       right_ = right;
    00197            }
    00198
    00199            void swapTriangles ()
    00200            {
    00201                       long aux = left_;
    00202                       left_ = right_;
    00203                       right_ = aux;
    00204            }
    00205
    00206            void exchangeTriangle ( long t1, long t2 )
    00207            {
    00208                       if (left_ == t1 )
    00209                                  left_ = t2;
    00210                       else
    00211                                  right_ = t2;
    00212            }
    00213
    00214            void exchangeVertex ( long v1, long v2 )
    00215            {
    00216                       if (from_ == v1 )
    00217                                  from_ = v2;
    00218                       else
    00219                                  to_ = v2;
    00220            }
    00221
    00222            TeTinEdgeType type ()
    00223            { return type_; }
    00224
    00225            void setType (TeTinEdgeType type)
    00226            { type_ = type; }
    00227
    00228            TeGeomRep elemType() { return TeSAMPLES; }
    00229
    00230 private:
    00231
    00232            long       from_, to_;
    00233            long       left_, right_;
    00234            TeTinEdgeType type_;
    00235 };
    00236
    00238 class TL_DLL TeTinEdgeSet : public TeGeomComposite<TeTinEdge>
    00239 {
    00240 public:
    00241
    00242 // -- Constructors
    00243
    00244            TeTinEdgeSet()        {}
    00245
    00246 // -- Methods
    00247
    00248            bool loadFromFile (std::string &fileName);
    00249
    00250            TeGeomRep elemType() { return TeSAMPLES; }
    00251 };
    00252
    00254 class TL_DLL TeTinTriangle : public TeGeometry
    00255 {
    00256 public:
    00257
    00258 // -- Constructors
    00259
    00260            TeTinTriangle()
    00261            {
    00262                       triEdges_[0] = -1;
    00263                       triEdges_[1] = -1;
    00264                       triEdges_[2] = -1;
    00265            }
    00266
    00267            TeTinTriangle(long first, long second, long third)
    00268            {
    00269                       triEdges_[0] = first;
    00270                       triEdges_[1] = second;
    00271                       triEdges_[2] = third;
    00272            }
    00273
    00274 // -- Methods
    00275
    00277            bool operator== (const TeTinTriangle& other) const
    00278            {
    00279                       if( (triEdges_[0] == other.triEdges_[0]) &&
    00280                                  (triEdges_[1] == other.triEdges_[1]) &&
    00281                                  (triEdges_[2] == other.triEdges_[2]) )
    00282                                  return true;
    00283
    00284                       return false;
    00285            }
    00286
    00287            void setEdges (long first, long second, long third)
    00288            {
    00289                       triEdges_[0] = first;
    00290                       triEdges_[1] = second;
    00291                       triEdges_[2] = third;
    00292            }
    00293
    00295
    00300            void edges (long& first, long& second, long& third)
    00301            {
    00302                       first  = triEdges_[0];
    00303                       second = triEdges_[1];
    00304                       third  = triEdges_[2];
    00305            }
    00306
    00307            long edgeAt (short num)
    00308            {
    00309                       if ((num > -1) && (num < 3))
    00310                                  return triEdges_[num];
    00311                       else
    00312                                  return -1;
    00313            }
    00314
    00315            TeGeomRep elemType() { return TeSAMPLES; }
    00316
    00317 private:
    00318
    00319            long       triEdges_[3];
    00320 };
    00321
    00323 class TL_DLL TeTinTriangleSet : public TeGeomComposite<TeTinTriangle>
    00324 {
    00325 public:
    00326
    00327 // -- Constructors
    00328
    00329            TeTinTriangleSet()    {}
    00330
    00331 // -- Methods
    00332
    00333            bool loadFromFile (std::string &fileName);
    00334
    00335            TeGeomRep elemType() { return TeSAMPLES; }
    00336 };
    00337
    00339 class TL_DLL TeTin
    00340 {
    00341 public:
    00342
    00343 // -- Constructors
    00344
    00345            TeTin()
    00346            {
    00347                       minedgesize_ = 0;
    00348                       fbvertex_ = 0;
    00349                       breakline_ = false;
    00350                       indexTriang_ = new TeSAM::TeRTree<long>(TeBox());
    00351            }
    00352            TeTin(TeBox & /* box */)
    00353            {
    00354                       minedgesize_ = 0;
    00355                       fbvertex_ = 0;
    00356                       breakline_ = false;
    00357                       indexTriang_ = new TeSAM::TeRTree<long>(TeBox());
    00358            }
    00359
    00360 // -- Methods
    00361
    00362            void clear()
    00363            { vertexSet_.clear(); triangleSet_.clear(); edgeSet_.clear();}
    00364
    00365            TeBox box()
    00366            { return vertexSet_.box(); }
    00367
    00368            bool createInitialTriangles(TeBox &box);
    00369            bool insertLineSamples ( TeContourLine& line );
    00370            bool loadFromFile(std::string &fileName);
    00371            bool getLines(TeLineSet &lineSet);
    00372            bool isEmpty ()
    00373            { return ( vertexSet_.empty() && triangleSet_.empty() &&
    00374                       edgeSet_.empty() ); }
    00375
    00376            TeTinEdge& edge (long i)
    00377            { return edgeSet_[i]; }
    00378
    00379            TeTinVertex& vertex (long i)
    00380            { return vertexSet_[i];          }
    00381
    00382            TeTinTriangle& triangle (long i)
    00383            { return triangleSet_[i];        }
    00384
    00385            typedef TeTinVertexSet::iterator TeTinVertexIterator;
    00386
    00387            TeTinVertexIterator vertexBegin()
    00388            { return vertexSet_.begin(); }
    00389
    00390            TeTinVertexIterator vertexEnd()
    00391            { return vertexSet_.end(); }
    00392
    00393            typedef  TeTinEdgeSet::iterator TeTinEdgeIterator;
    00394
    00395            TeTinEdgeIterator edgeBegin()
    00396            { return edgeSet_.begin(); }
    00397
    00398            TeTinEdgeIterator edgeEnd()
    00399            { return edgeSet_.end(); }
    00400
    00401            typedef  TeTinTriangleSet::iterator TeTinTriangleIterator;
    00402
    00403            TeTinTriangleIterator triangleBegin()
    00404            { return triangleSet_.begin(); }
    00405
    00406            TeTinTriangleIterator triangleEnd()
    00407            { return triangleSet_.end(); }
    00408
    00409            bool triangleContainsPoint(TeTinTriangle& t, TeCoord2D& pt);
    00410            bool triangleContainsPoint(long t, TeCoord2D& pt)
    00411            { return triangleContainsPoint(triangleSet_[t], pt); }
    00412
    00413            long edgeWithVertexDiffFromEdge(long t, long v, long e);
    00414            long oneTriangleWithVertex(long vertex);
    00415            long oneEdgeWithVertex(long vertex);
    00416
    00417            long edgeOppVertex(TeTinTriangle& triangle, long vertex);
    00418            long edgeOppVertex(long triangle, long vertex)
    00419            { return edgeOppVertex(triangleSet_[triangle], vertex); }
    00420
    00421            long vertexOppEdge(long triangle, long edge);
    00422            bool vertexEdges(long vertex, std::list<long> &edges);
    00423            bool vertexOppEdges(long vertex, std::list<long> &edges);
    00424            bool vertexOppEdges(long v, std::list<long> &triset, std::list<long> &edges);
    00425
    00426            bool vertexOppVertices(long vertex, std::list<long> &vertices);
    00427            bool vertexSecondNeighVertices(long v, list<long> &vertices);
    00428            bool vertexTriangles(long vertex, std::list<long> &triangles);
    00429            bool triangle3Neighbors(long t, long& neighbor0, long& neighbor1, long& neighbor2);
    00430            long triangleAt (TeCoord2D& pt);
    00431            long triangleAt (TeBox boxPt);
    00432
    00433            bool triangleVertices(TeTinTriangle& t, long& vertex0, long& vertex1, long& vertex2);
    00434            bool triangleVertices(long t, long& vertex0, long& vertex1, long& vertex2)
    00435            { return this->triangleVertices(triangleSet_[t], vertex0, vertex1, vertex2); }
    00436
    00437            long triangleVertexAt(long t, long vertex);
    00438
    00439            bool triangle3DPoints(TeTinTriangle& t, TeCoord2D& pt0, TeCoord2D& pt1,
    00440                       TeCoord2D& pt2, double& val0, double& val1, double& val2);
    00441            bool triangle3DPoints(long t, TeCoord2D& pt0, TeCoord2D& pt1, TeCoord2D& pt2,
    00442                       double& val0, double& val1, double& val2)
    00443            { return triangle3DPoints( triangleSet_[t], pt0, pt1, pt2, val0, val1, val2); }
    00444
    00445
    00446            bool trianglePoints(TeTinTriangle& t, TeCoord2D& pt0, TeCoord2D& pt1, TeCoord2D& pt2);
    00447            bool trianglePoints(long t, TeCoord2D& pt0, TeCoord2D& pt1, TeCoord2D& pt2)
    00448            { return trianglePoints( triangleSet_[t], pt0, pt1, pt2); }
    00449
    00450            bool twoNewTriangles(long t, long v, std::set<long>& triangles);
    00451            long duplicateTriangle(long t, long n, long v, std::set<long>& triangles);
    00452            bool dupNeighTriangle (long t, long e, long v, std::set<long>& triangles);
    00453
    00454            void testDelaunayForVertex(long v, std::set<long>& triangles);
    00455            bool testDelaunayAt(long t, long v, std::set<long>& triangles);
    00456
    00457            bool testDelaunay(long e);
    00458            bool testDelaunay(long t, long v);
    00459            bool testDelaunay(long t1, long t2, long t3);
    00460            bool testDelaunay(long t1, long t2, long t3, long t4);
    00461
    00462            bool createDelaunay();
    00463            bool generateDelaunay(long nt, long ntbase, long& contr);
    00464
    00465            void vertexExchange(long oldVertex, long newVertex);
    00467            long oppositeVertex(long t, long e);
    00468
    00470            bool createSmallerAngleTriangulation();
    00472
    00476            bool testSmallerAngleAt(long t, long v);
    00477
    00479            bool createIsolinesTriangulation();
    00480
    00481            bool swapEdges( long t, long tv, long ai );
    00482
    00483            bool insertPoint(TeSample& xyz)
    00484            { return insertPoint ( xyz.location().x(),xyz.location().y(),xyz.value() ); }
    00485
    00486            bool insertPoint(double x, double y, double value);
    00487
    00488            bool edgesInterBySegment( TeCoord2D& pf, TeCoord2D& pn, std::list<long> &aiset, std::list<long> &viset );
    00489            bool insertSegment( TeCoord2D& pf, TeCoord2D& pn );
    00490
    00491
    00492            void convexize ();
    00493            bool isEdgeTriangle (long t);
    00494
    00495            int sizeTriangles()
    00496            {return triangleSet_.size();}
    00497
    00498            int sizeVertex()
    00499            {return vertexSet_.size();}
    00500
    00501            TeGeomRep elemType() { return TeSAMPLES; }
    00502
    00504
    00508            bool createTIN(TeSampleSet& sampleSet, TeContourLineSet& contourSet);
    00509
    00511
    00515            bool createTIN(TeLayer* inputLayer_ptr, TePolygonSet& ps);
    00516
    00518
    00521            bool createTIN(TeLayer* inputLayer_ptr);
    00522
    00524
    00529     bool createAttrTable(TeTable& attTable, TeDatabase* db, TeLayer* layer);
    00530
    00532
    00543     bool createPolygon(TePolygonSet ps, TeTable& attTable, int t, TeCoord2D& pt0,
    00544                                      TeCoord2D& pt1, TeCoord2D& pt2, double& val0, double& val1,
    00545                                                           double& val2);
    00546
    00548
    00560     bool createPolygon(TePolygonSet ps, TeTable& attTable, int t, TeCoord2D& pt0,
    00561                                      TeCoord2D& pt1, TeCoord2D& pt2, double& val0, double& val1,
    00562                                                           double& val2, double& slope, double& aspect);
    00563
    00564            bool createPolygon(TePolygonSet ps, TeTable& attTable, int t, TeTinVertex vert0,
    00565                                      TeTinVertex vert1, TeTinVertex vert2, double& slope, double& aspect);
    00566
    00568
    00574     bool saveTIN(TeDatabase* db, TeLayer* layer, TePolygonSet& ps,
    00575                                TeTable& attTable);
    00576
    00578
    00584            bool saveVertexTIN(TeDatabase* db, TeLayer* layer, TePointSet& ps,
    00585                                     TeTable& attTable);
    00586
    00588
    00593            bool saveTINdb(TeDatabase* db, string& outLayerName, string& tablename);
    00594
    00596
    00601            TeLayer* saveTINdb(TeDatabase* db, TeProjection* proj, string& outLayerName, string& tablename);
    00602
    00604
    00609            bool saveVertexTINdb(TeDatabase* db, string& outLayerName, string& tablename);
    00610
    00612            bool borderUp();
    00613
    00615
    00618            void writeTriangleEdgesSPRFile (std::string& name, TeRaster* raster);
    00619
    00621
    00625            void areaTriangle (TeTinTriangle& t, float& area); //necessita testar o metodo de calculo de area do TeGeometryAlgorithms
    00626
    00628
    00633            void slopeTriangle (TeTinTriangle& t, double& slope, char slopetype);
    00634
    00636
    00640            void aspectTriangle (TeTinTriangle& t, double& aspect);
    00641
    00643
    00648            bool calculateGradient(TeRaster*& grid, char gradtype, char slopetype);
    00649
    00651
    00657            bool createPointSet(TePointSet& ps, TeTable& atttable, TeLayer* layer, TeDatabase* db);
    00658
    00660
    00663            bool createSampleSet(TeSampleSet& sample);
    00664
    00666
    00671            double triangleGradient(TeTinTriangle& t, char gradtype, char slopetype);
    00672
    00674
    00678            bool normalTriangle(TeTinTriangle& t, std::vector<double>& nvector); // calculo da normal (adaptado do SPRING)
    00679            bool normalTriangle(std::vector<TeTinVertex> vert, double* nvector);
    00680
    00682
    00685            void normalizeVector(std::vector<double>& nvector);
    00686            void normalizeVector(double* nvector);
    00687
    00689
    00697            bool defineInterLinesColumns(TeRaster* raster, TeTinTriangle t, int& fline, int& lline, int& fcol, int& lcol);
    00698
    00700
    00709            void linearInterpolation(TeRaster* raster, int band, TeTinTriangle t, int fline, int lline, int fcol, int lcol);
    00710
    00712
    00715            bool linearInterpolation(TeRaster*& grid);
    00716
    00721            //Testado apenas para grade.
    00722            bool quinticInterpolation(TeRaster*& grid, int interpolator);
    00723
    00725
    00729            bool interpolationPoint(TeCoord2D& pt, double& z);
    00730
    00732
    00737            bool slopeaspectPoint(TeCoord2D& pt,double& s,double& a);
    00738
    00739            bool vertexOncontour(long& v);
    00740
    00742
    00748            void setTolerances(double minedgesize = 0, double isoTol = -1, double ptsdist = -1, double breaklineTol = -1);
    00749
    00751
    00758            double pointToSegmentDistance(TeCoord2D fseg, TeCoord2D lseg, TeCoord2D pt, TeCoord2D& pti);
    00759
    00761
    00764            bool insertBreaklines(TeLineSet& breaklineSet, double scale);
    00765
    00767
    00770            void copyBreaklines(TeLineSet& breaklines);
    00771
    00773
    00776            bool insertBreaklinesPoints(TeLineSet breaklines, double scale);
    00777
    00779
    00783            bool vertexClosestPoints(long v, std::vector<long>& clstVert);
    00784
    00786
    00791            bool breakVertexClosestPoints(long v, std::vector<long>& rclstVert, std::vector<long>& lclstVert);
    00792
    00794            void vertexDerivatives();
    00795
    00797            void triangleFirstDeriv();
    00798
    00800            void vertexFirstDeriv();
    00801
    00803            void triangleSecondDeriv();
    00804
    00806            void vertexSecondDeriv();
    00807
    00809            void breakVertexFirstDeriv();
    00810
    00812            void breakTriangleSecondDeriv();
    00813
    00815            void breakVertexSecondDeriv();
    00816
    00818
    00823            void calcVertexFirstDeriv(long v, std::vector<long> clstVertex, TeTinVertex& deriv);
    00824
    00826
    00831            void calcVertexSecondDeriv(long v, std::vector<long> clstVertex, TeTinVertex& deriv);
    00832
    00834
    00839            void calcTriangleSecondDeriv(long v, std::list<long> triangles, TeTinVertexSet& fderiv);
    00840
    00842
    00847            bool findInterPoints(TeCoord2D& pf, TeCoord2D& pn, TeTinVertexSet& pts);
    00848
    00850
    00855            void vertexTriangles(long v, std::list<long>& rtri, std::list<long>& ltri);
    00856
    00858
    00863            void calcZvalueAkima(long t, TeTinVertex& v1, TeTinVertex& v2);
    00864
    00865            void defineAkimaCoeficients(long t, double* coef);
    00866
    00868
    00872            void defineAkimaCoeficients(long t, TeTinVertexSet vertSet, double* coef);
    00873
    00875            bool checkTopology();
    00876
    00878
    00881            void checkEdges(long t);
    00882
    00884            void orderEdges();
    00885
    00887
    00891            long findEdge(long v1, long v2);
    00892
    00894            bool onIsolineSegment(long e, TeTinVertex& vert);
    00895
    00897            bool onSegment(TeCoord2D pt, TeCoord2D fseg, TeCoord2D lseg, double tol);
    00898
    00900            bool isIsolineSegment(long e);
    00901
    00903            bool isBreaklineSegment(long e);
    00904
    00905            void writeTriangleSPRFile(std::string nameVert, std::string nameEdge, std::string nameTriang);
    00906
    00908
    00912            bool loadTIN(TeLayer* layer, TeDatabase* db);
    00913
    00916            void point3dListFilter(TeTinVertexSet vertSet, double tol);
    00917
    00919
    00926            bool leastSquareFitting(double* vectx, double* vecty, int np, int degree, double* coef);
    00927
    00929
    00934            bool gaussElimination(int nvars, int neqs, double** matrix);
    00935
    00937            bool isNeighborOnIsoOrBreakline(long t, long nviz);
    00938
    00940            void generateContour(double contour, TeContourLine*& ptline);
    00941
    00943            bool defineInterTriangle(TeContourLine*& ptline, TeTinVertex* vert);
    00944
    00946
    00951            bool defineInterEdge(TeContourLine*& ptline, TeTinVertex fpt, TeTinVertex spt);
    00952
    00953            long onSameSide(TeCoord2D pt1, TeCoord2D pt2, TeCoord2D fseg, TeCoord2D lseg);
    00954
    00956            string errorMessage ()
    00957            { return errorMessage_; }
    00958
    00959 private:
    00960
    00961            TeTinVertexSet                   vertexSet_;
    00962            TeTinTriangleSet      triangleSet_;
    00963            TeTinEdgeSet                     edgeSet_;
    00964
    00965            TeTinVertexSet                   vfderivSet_;
    00966            TeTinVertexSet                   vsderivSet_;
    00967            TeTinVertexSet                   tfderivSet_;
    00968            TeTinVertexSet                   tsderivSet_;
    00969            TeTinVertexSet                   vbrfderivSet_;
    00970            TeTinVertexSet                   vblfderivSet_;
    00971            TeTinVertexSet                   vbrsderivSet_;
    00972            TeTinVertexSet                   vblsderivSet_;
    00973
    00974            TeTinVertexType                  verttype_;
    00975
    00976            long                                        fbvertex_;
    00977            bool                                        breakline_;
    00978
    00979            double                                      isoTol_;
    00980            double                                      ptsdist_;
    00981            double                                      breaklineTol_;
    00982            double                                      minedgesize_;
    00983
    00984            TeSAM::TeRTree<long>* indexTriang_;
    00985
    00986            std::string                                 errorMessage_;
    00987 };
    00988
    00989 #endif
    00990
    00991

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines