GeoTessCPP: rstt/GeoTessCPP/include/GeoTessPosition.h Source File

GeoTessCPP 2.2.3 Software to facilitate storage and retrieval of 3D information about the Earth.

GeoTessPosition.h
Go to the documentation of this file.
1 //- ****************************************************************************
2 //-
3 //- Copyright 2009 National Technology & Engineering Solutions of Sandia, LLC
4 //- (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
5 //- Government retains certain rights in this software.
6 //-
7 //- BSD Open Source License
8 //- All rights reserved.
9 //-
10 //- Redistribution and use in source and binary forms, with or without
11 //- modification, are permitted provided that the following conditions are met:
12 //-
13 //- 1. Redistributions of source code must retain the above copyright notice,
14 //- this list of conditions and the following disclaimer.
15 //-
16 //- 2. Redistributions in binary form must reproduce the above copyright
17 //- notice, this list of conditions and the following disclaimer in the
18 //- documentation and/or other materials provided with the distribution.
19 //-
20 //- 3. Neither the name of the copyright holder nor the names of its
21 //- contributors may be used to endorse or promote products derived from
22 //- this software without specific prior written permission.
23 //-
24 //- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 //- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 //- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 //- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
28 //- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 //- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 //- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 //- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 //- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 //- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 //- POSSIBILITY OF SUCH DAMAGE.
35 //-
36 //- ****************************************************************************
37
38 #ifndef GEOTESSPOSITION_OBJECT_H
39 #define GEOTESSPOSITION_OBJECT_H
40
41 // **** _SYSTEM INCLUDES_ ******************************************************
42
43 #include <iostream>
44 #include <string>
45 #include <fstream>
46 #include <vector>
47 #include <sstream>
48
49 // use standard library objects
50 using namespace std;
51
52 // **** _LOCAL INCLUDES_ *******************************************************
53
54 #include "CPPUtils.h"
55 #include "GeoTessUtils.h"
56 #include "GeoTessModel.h"
57 #include "GeoTessGrid.h"
58 #include "GeoTessMetaData.h"
59 #include "CpuTimer.h"
60 #include "GeoTessProfile.h"
61 #include "GeoTessData.h"
62
63 // **** _BEGIN GEOTESS NAMESPACE_ **********************************************
64
65 namespace geotess {
66
67 // **** _FORWARD REFERENCES_ ***************************************************
68
69 class GeoTessInterpolatorType;
70 class GeoTessProfile;
71
72 // **** _CLASS DEFINITION_ *****************************************************
73
103 class GEOTESS_EXP_IMP GeoTessPosition
104 {
105 private:
106
110 int refCount;
111
117 int* maxTessLevel;
118
124 int* tessLevels;
125
134 int* triangle;
135
141 double errorValue;
142
153 void updatePosition2D(int layerid, const double* const uVector);
154
172 void checkTessellation(const int& tid)
173 {
174 if (triangle[tid] < 0)
175 {
176 tessLevels[tid] = 0;
177 triangle[tid] = grid.getTriangle(tid, 0, 0);
178 getContainingTriangle(tid);
179 update2D(tid);
180 }
181 }
182
190 void updateRadius(int lid, double rad)
191 {
192 if ((radius < 0.) || (rad != radius) || (lid != layerId))
193 {
194 radius = rad;
195 layerId = lid;
196 tessid = layerTessIds[lid];
197 checkTessellation(tessid);
198 clearRadialCoefficients();
199 }
200 }
201
202 void clearRadialCoefficients()
203 {
204 for (int i=0; i<(int)radialIndexes.size(); ++i)
205 {
206 radialIndexes[i].clear();
207 radialCoefficients[i].clear();
208 }
209 }
210
217 void updateRadialCoefficients()
218 {
219 // make sure dimensions of radialIndexes and radialCoefficients
220 // are at least as big as the number of vertices involved in interpolation.
221 if (radialIndexes.size() < vertices[tessid].size())
222 {
223 radialIndexes.resize(vertices[tessid].size());
224 radialCoefficients.resize(vertices[tessid].size());
225 }
226
227 // if radial interpolation coefficients have already been computed
228 // do nothing.
229 if (radialIndexes[0].size() == 0)
230 {
231 vector<int>& v = vertices[tessid];
232 for (int i = 0; i < (int)v.size(); ++i)
233 modlProfiles[v[i]][layerId]->setInterpolationCoefficients(radialInterpolatorType,
234 radialIndexes[i], radialCoefficients[i], radius, radiusOutOfRangeAllowed);
235 }
236 }
237
242 static const double TWALK_TOLERANCE;
243
254 void getContainingTriangle(int tid);
255
264 int biggerTriangle(int t1, int t2)
265 {
266 const int* tv = grid.getTriangleVertexIndexes(t1);
267 double dot1 = GeoTessUtils::dot(grid.getVertex(tv[0]), grid.getVertex(tv[1]))
268 + GeoTessUtils::dot(grid.getVertex(tv[1]), grid.getVertex(tv[2]))
269 + GeoTessUtils::dot(grid.getVertex(tv[2]), grid.getVertex(tv[0]));
270
271 tv = grid.getTriangleVertexIndexes(t2);
272 double dot2 = GeoTessUtils::dot(grid.getVertex(tv[0]), grid.getVertex(tv[1]))
273 + GeoTessUtils::dot(grid.getVertex(tv[1]), grid.getVertex(tv[2]))
274 + GeoTessUtils::dot(grid.getVertex(tv[2]), grid.getVertex(tv[0]));
275
276 return dot2 > dot1 ? t1 : t2;
277
278 }
279
280 protected:
281
283
287 double radius;
288
292 double earthRadius;
293
301 vector<double> layerRadii;
302
306 int layerId;
307
311 int tessid;
312
320 vector< vector< int> > vertices;
321
327 vector< vector< double> > linearCoefficients;
328
335 //vector< vector< double> > nnCoefficients;
336
340 vector< vector< double> > hCoefficients;
341
356 vector<vector<int> > radialIndexes;
357
375 vector<vector<double> > radialCoefficients;
376
377
382 const GeoTessInterpolatorType& radialInterpolatorType;
383
388 GeoTessModel* model;
389
393 GeoTessGrid& grid;
394
398 GeoTessProfile *** modlProfiles;
399 double const* const* gridVertices;
400 int const* const* gridTriangles;
401 int const* gridDescendants;
402 const vector<vector<Edge*> >& gridEdges;
403 const int* layerTessIds;
404 int nLayers;
405
420 bool radiusOutOfRangeAllowed;
421
425 double unitVector[3];
426
430 int getTriangle(int tid)
431 { checkTessellation(tid); return triangle[tid]; };
432
437 virtual void update2D(int tid) = ABSTRACT;
438
442 GeoTessPosition(GeoTessModel* model, const GeoTessInterpolatorType& radialType);
443
447 long memory()
448 {
449 long m = 0;
450
451 // memory for int* triangle, tessLevels and maxTessLevel.
452 m += (long)(grid.getNTessellations() * 3 * sizeof(int));
453
454 // vector<double> layerRadii;
455 m += (long)(layerRadii.capacity() * sizeof(double));
456
457 // vector< vector< int> > vertices;
458 m += (long)(vertices.capacity()*sizeof(vector<int>));
459 for (int i=0; i<(int)vertices.size(); ++i)
460 m += (long)(vertices[i].capacity()*sizeof(int));
461
462 // vector< vector< double> > linearCoefficients;
463 m += (long)(linearCoefficients.capacity()*sizeof(vector<double>));
464 for (int i=0; i<(int)linearCoefficients.size(); ++i)
465 m += (long)(linearCoefficients[i].capacity()*sizeof(double));
466
467 // vector< vector< double> > hCoefficients;
468 m += (long)(hCoefficients.capacity()*sizeof(vector<double>));
469 for (int i=0; i<(int)hCoefficients.size(); ++i)
470 m += (long)(hCoefficients[i].capacity()*sizeof(double));
471
472 // vector<vector<int> > radialIndexes;
473 m += (long)(radialIndexes.capacity()*sizeof(vector<int>));
474 for (int i=0; i<(int)radialIndexes.size(); ++i)
475 m += (long)(radialIndexes[i].capacity()*sizeof(int));
476
477 // vector<vector<double> > radialCoefficients;
478 m += (long)(radialCoefficients.capacity()*sizeof(vector<double>));
479 for (int i=0; i<(int)radialCoefficients.size(); ++i)
480 m += (long)(radialCoefficients[i].capacity()*sizeof(double));
481
482 return m;
483 }
484
486
487 public:
488
498 static GeoTessPosition* getGeoTessPosition(GeoTessModel* model);
499
514 static GeoTessPosition* getGeoTessPosition(GeoTessModel* model,
515 const GeoTessInterpolatorType& horizontalType);
516
530 static GeoTessPosition* getGeoTessPosition(GeoTessModel* model,
531 const GeoTessInterpolatorType& horizontalType, const GeoTessInterpolatorType& radialType);
532
536 virtual ~GeoTessPosition();
537
544 virtual const GeoTessInterpolatorType& getInterpolatorType() const = ABSTRACT;
545
550 virtual long getMemory() = ABSTRACT;
551
558 virtual double getValue(int attribute);
559
580 void setModel(GeoTessModel* newModel);
581
586 bool noEmptyProfiles();
587
608 void set(double lat, double lon, double depth)
609 {
610 double uVector[3] = {0.0, 0.0, 0.0};
611 GeoTessUtils::getVectorDegrees(lat, lon, uVector);
612 double newRadius = GeoTessUtils::getEarthRadius(uVector) - depth;
613 set(uVector, newRadius);
614 }
615
628 void set(const double* const uVector, const double& newRadius)
629 {
630 updatePosition2D(nLayers - 1, uVector);
631
632 int lid = getLayerId(newRadius);
633
634 updatePosition2D(lid, uVector);
635 updateRadius(lid, newRadius);
636 }
637
655 void set(int layid, double lat, double lon, double depth)
656 {
657 if (layid < 0)
658 set(lat, lon, depth);
659 else
660 {
661 double uVector[3];
662 GeoTessUtils::getVectorDegrees(lat, lon, uVector);
663 updatePosition2D(layid, uVector);
664 updateRadius(layid, GeoTessUtils::getEarthRadius(uVector) - depth);
665 }
666 }
667
678 void set(int layid, const double* const uVector, double rad)
679 {
680 if (layid < 0)
681 set(uVector, rad);
682 else
683 {
684 updatePosition2D(layid, uVector);
685 if (rad >= 0.0) updateRadius(layid, rad);
686 }
687 }
688
696 void setTop(int layid, const double* const uVector)
697 {
698 updatePosition2D(layid, uVector);
699 updateRadius(layid, getRadiusTop(layid));
700 }
701
710 void setBottom(int layid, const double* const uVector)
711 {
712 updatePosition2D(layid, uVector);
713 updateRadius(layid, getRadiusBottom(layid));
714 }
715
723 void setRadius(int layid, double rad)
724 {
725 if (tessid < 0)
726 {
727 ostringstream os;
728 os << endl << "ERROR in GeoTessPosition::setRadius" << endl
729 << "Geographic position has not been specified." << endl;
730 throw GeoTessException(os, __FILE__, __LINE__, 3001);
731 }
732 updateRadius(layid, rad);
733 }
734
741 void setRadius(double rad)
742 {
743 if (tessid < 0)
744 if (tessid < 0)
745 {
746 ostringstream os;
747 os << endl << "ERROR in GeoTessPosition::setRadius" << endl
748 << "Geographic position has not been specified." << endl;
749 throw GeoTessException(os, __FILE__, __LINE__, 3002);
750 }
751 updateRadius(getLayerId(rad), rad);
752 }
753
765 void setDepth(int layer, double depth)
766 {
767 setRadius(layer, getEarthRadius()-depth);
768 }
769
776 void setDepth(double depth)
777 {
778 setRadius(getEarthRadius()-depth);
779 }
780
786 void setTop(int layid)
787 {
788 if (tessid < 0)
789 {
790 ostringstream os;
791 os << endl << "ERROR in GeoTessPosition::setRadius" << endl
792 << "Geographic position has not been specified." << endl;
793 throw GeoTessException(os, __FILE__, __LINE__, 3003);
794 }
795 tessid = layerTessIds[layid];
796 checkTessellation(tessid);
797 updateRadius(layid, getRadiusTop(layid));
798 }
799
806 void setBottom(int layid)
807 {
808 if (tessid < 0)
809 {
810 ostringstream os;
811 os << endl << "ERROR in GeoTessPosition::setRadius" << endl
812 << "Geographic position has not been specified." << endl;
813 throw GeoTessException(os, __FILE__, __LINE__, 3004);
814 }
815 tessid = layerTessIds[layid];
816 checkTessellation(tessid);
817 updateRadius(layid, getRadiusBottom(layid));
818 }
819
827 double getRadiusTop(int layid);
828
835 double getRadiusBottom(int layid);
836
842 double getEarthRadius()
843 {
844 if (earthRadius < 0.)
845 earthRadius = GeoTessUtils::getEarthRadius(unitVector);
846 return earthRadius;
847 }
848
855 double* getVector() { return unitVector; };
856
863 void copyVector(double* u)
864 { u[0] = unitVector[0]; u[1] = unitVector[1]; u[2] = unitVector[2]; };
865
871 int getTriangle() { return triangle[tessid]; };
872
877 int getNVertices() { return vertices[tessid].size(); };
878
886 const vector<int>& getVertices() const { return vertices[tessid]; };
887
893 int getIndexOfClosestVertex() const;
894
901 const double* getClosestVertex() const
902 {
903 return grid.getVertex(getIndexOfClosestVertex());
904 }
905
912 int getVertex(int index)
913 { return vertices[tessid][index]; }
914
920 void getCoefficients(map<int, double>& coefficients)
921 {
922 coefficients.clear();
923 vector<int>& vtx = vertices[tessid];
924 vector<double>& hc = hCoefficients[tessid];
925 for (int i = 0; i < (int) vtx.size(); ++i)
926 modlProfiles[vtx[i]][layerId]->getCoefficients(coefficients, radius, hc[i]);
927 }
928
938 void setMaxTessLevel(int layid, int maxTess)
939 {
940 maxTessLevel[layerTessIds[layid]] = maxTess;
941 triangle[layerTessIds[layid]] = -1;
942 checkTessellation(tessid);
943 }
944
954 int getMaxTessLevel(int layid)
955 { return maxTessLevel[layerTessIds[layid]]; }
956
963 int getTessLevel() const { return tessLevels[tessid]; };
964
973 int getTessLevel(const int& tId) { checkTessellation(tId); return tessLevels[tId]; }
974
980 double getRadiusTop()
981 { return getRadiusTop(layerId); };
982
988 double getRadiusBottom()
989 { return getRadiusBottom(layerId); };
990
996 double getDepthTop()
997 {
998 return getEarthRadius() - getRadiusTop(layerId);
999 }
1000
1006 double getDepthBottom()
1007 {
1008 return getEarthRadius() - getRadiusBottom(layerId);
1009 }
1010
1017 double getDepthTop(int layid)
1018 {
1019 return getEarthRadius() - getRadiusTop(layid);
1020 }
1021
1028 double getDepthBottom(int layid)
1029 {
1030 return getEarthRadius() - getRadiusBottom(layid);
1031 }
1032
1039 double getLayerThickness(int layid)
1040 {
1041 return getRadiusTop(layid) - getRadiusBottom(layid);
1042 }
1043
1049 double getLayerThickness()
1050 {
1051 return getRadiusTop() - getRadiusBottom();
1052 }
1053
1059 double getRadius() { return radius; };
1060
1066 double getDepth()
1067 { return getEarthRadius() - radius; };
1068
1072 GeoTessModel* getModel() { return model; }
1073
1077 int getTessID() { return tessid; };
1078
1089 int getLayerId(double rad)
1090 {
1091 for (int i=0; i<nLayers; ++i)
1092 if (rad <= getRadiusTop(i))
1093 return i;
1094
1095 for (int i=nLayers-1; i>=0; --i)
1096 if (getLayerThickness(i) > 0)
1097 return i;
1098
1099 return nLayers-1;
1100 };
1101
1105 int getLayerId() { return layerId; };
1106
1111 string toString();
1112
1119 double getErrorValue()
1120 {
1121 return errorValue;
1122 }
1123
1130 void setErrorValue(double errVal)
1131 {
1132 errorValue = errVal;
1133 }
1134
1142 int getVertexIndex()
1143 {
1144 vector<int>& vtid = vertices[tessid];
1145 vector<double>& htid = hCoefficients[tessid];
1146 for (int v = 0; v < (int) vtid.size(); ++v)
1147 if (htid[v] > 0.999999999)
1148 return vtid[v];
1149 return -1;
1150 }
1151
1176 void getWeights(map<int, double>& weights, double dkm)
1177 {
1178 vector<int>& vtx = vertices[tessid];
1179 vector<double>& htid = hCoefficients[tessid];
1180 model->getPointMap();
1181 for (int i = 0; i < (int) vtx.size(); ++i)
1182 modlProfiles[vtx[i]][layerId]->getWeights(weights, dkm, radius, htid[i]);
1183 }
1184
1192 const vector<double>& getHorizontalCoefficients() const
1193 {
1194 return hCoefficients[tessid];
1195 }
1196
1205 double getHorizontalCoefficient(int index) const
1206 {
1207 return hCoefficients[tessid][index];
1208 }
1209
1225 bool isRadiusOutOfRangeAllowed()
1226 {
1227 return radiusOutOfRangeAllowed;
1228 }
1229
1245 void setRadiusOutOfRangeAllowed(bool allowed)
1246 {
1247 if (allowed != radiusOutOfRangeAllowed)
1248 clearRadialCoefficients();
1249
1250 radiusOutOfRangeAllowed = allowed;
1251 }
1252
1256 void addReference() { ++refCount; }
1257
1261 void removeReference()
1262 {
1263 if (isNotReferenced())
1264 {
1265 ostringstream os;
1266 os << endl << "ERROR in Polygon::removeReference" << endl
1267 << "Reference count (" << refCount << ") is already zero." << endl;
1268 throw GeoTessException(os, __FILE__, __LINE__, 3005);
1269 }
1270
1271 --refCount;
1272 }
1273
1279 int getReferenceCount()
1280 {
1281 return refCount;
1282 }
1283
1288 bool isNotReferenced() { return refCount == 0; }
1289
1290 }; // end class GeoTessModel
1291
1292 } // end namespace geotess
1293
1294 #endif // GEOTESSPOSITION_OBJECT_H
geotess::GeoTessPosition::getDepthTop
double getDepthTop()
Definition: GeoTessPosition.h:996
geotess::GeoTessPosition::copyVector
void copyVector(double *u)
Definition: GeoTessPosition.h:863
geotess
Definition: ArrayReuse.h:57
geotess::GeoTessProfile
Abstract class that manages the radii and data values that span a single layer associated with a sing...
Definition: GeoTessProfile.h:99
GeoTessData.h
geotess::GeoTessPosition::setDepth
void setDepth(double depth)
Definition: GeoTessPosition.h:776
geotess::GeoTessPosition::getEarthRadius
double getEarthRadius()
Definition: GeoTessPosition.h:842
geotess::GeoTessPosition::isRadiusOutOfRangeAllowed
bool isRadiusOutOfRangeAllowed()
Definition: GeoTessPosition.h:1225
geotess::GeoTessPosition::setBottom
void setBottom(int layid, const double *const uVector)
Definition: GeoTessPosition.h:710
geotess::GeoTessPosition::getLayerThickness
double getLayerThickness()
Definition: GeoTessPosition.h:1049
geotess::GeoTessPosition::getDepthTop
double getDepthTop(int layid)
Definition: GeoTessPosition.h:1017
geotess::GeoTessPosition::getGeoTessPosition
static GeoTessPosition * getGeoTessPosition(GeoTessModel *model, const GeoTessInterpolatorType &horizontalType)
geotess::GeoTessPosition::setTop
void setTop(int layid, const double *const uVector)
Definition: GeoTessPosition.h:696
geotess::GeoTessPosition::getHorizontalCoefficient
double getHorizontalCoefficient(int index) const
Definition: GeoTessPosition.h:1205
GeoTessProfile.h
geotess::GeoTessPosition::getGeoTessPosition
static GeoTessPosition * getGeoTessPosition(GeoTessModel *model)
geotess::GeoTessGrid::getNTessellations
int getNTessellations() const
Definition: GeoTessGrid.h:828
geotess::GeoTessPosition::getGeoTessPosition
static GeoTessPosition * getGeoTessPosition(GeoTessModel *model, const GeoTessInterpolatorType &horizontalType, const GeoTessInterpolatorType &radialType)
geotess::GeoTessPosition::setBottom
void setBottom(int layid)
Definition: GeoTessPosition.h:806
geotess::GeoTessPosition::setTop
void setTop(int layid)
Definition: GeoTessPosition.h:786
geotess::GeoTessPosition::noEmptyProfiles
bool noEmptyProfiles()
geotess::GeoTessPosition::set
void set(int layid, double lat, double lon, double depth)
Definition: GeoTessPosition.h:655
geotess::GeoTessPosition::getVertexIndex
int getVertexIndex()
Definition: GeoTessPosition.h:1142
geotess::GeoTessPosition::setErrorValue
void setErrorValue(double errVal)
Definition: GeoTessPosition.h:1130
geotess::GeoTessPosition::getLayerId
int getLayerId(double rad)
Definition: GeoTessPosition.h:1089
geotess::GeoTessModel::getPointMap
GeoTessPointMap * getPointMap()
Definition: GeoTessModel.h:1088
geotess::GeoTessPosition::getMemory
virtual long getMemory()
GeoTessUtils.h
geotess::GeoTessPosition::getInterpolatorType
virtual const GeoTessInterpolatorType & getInterpolatorType() const
geotess::GeoTessPosition::getErrorValue
double getErrorValue()
Definition: GeoTessPosition.h:1119
geotess::GeoTessPosition::setDepth
void setDepth(int layer, double depth)
Definition: GeoTessPosition.h:765
geotess::GeoTessPosition::getReferenceCount
int getReferenceCount()
Definition: GeoTessPosition.h:1279
geotess::GeoTessPosition::getVertex
int getVertex(int index)
Definition: GeoTessPosition.h:912
geotess::GeoTessPosition::getTessLevel
int getTessLevel(const int &tId)
Definition: GeoTessPosition.h:973
geotess::GeoTessPosition::getIndexOfClosestVertex
int getIndexOfClosestVertex() const
geotess::GeoTessPosition::removeReference
void removeReference()
Definition: GeoTessPosition.h:1261
geotess::GeoTessGrid
Manages the geometry and topology of one or more multi-level triangular tessellations of a unit spher...
Definition: GeoTessGrid.h:169
geotess::GeoTessPosition::setRadius
void setRadius(int layid, double rad)
Definition: GeoTessPosition.h:723
geotess::GeoTessPosition::addReference
void addReference()
Definition: GeoTessPosition.h:1256
geotess::GeoTessPosition::getNVertices
int getNVertices()
Definition: GeoTessPosition.h:877
geotess::GeoTessPosition::getRadius
double getRadius()
Definition: GeoTessPosition.h:1059
CpuTimer.h
geotess::GeoTessGrid::getVertex
const double * getVertex(int vertex) const
Definition: GeoTessGrid.h:632
geotess::GeoTessPosition::set
void set(int layid, const double *const uVector, double rad)
Definition: GeoTessPosition.h:678
geotess::GeoTessPosition::getClosestVertex
const double * getClosestVertex() const
Definition: GeoTessPosition.h:901
geotess::GeoTessPosition::getModel
GeoTessModel * getModel()
Definition: GeoTessPosition.h:1072
geotess::GeoTessPosition::getDepth
double getDepth()
Definition: GeoTessPosition.h:1066
geotess::GeoTessPosition::getValue
virtual double getValue(int attribute)
GeoTessGrid.h
GEOTESS_EXP_IMP
#define GEOTESS_EXP_IMP
Definition: CPPGlobals.h:73
geotess::GeoTessPosition::getVertices
const vector< int > & getVertices() const
Definition: GeoTessPosition.h:886
geotess::GeoTessPosition::getTessID
int getTessID()
Definition: GeoTessPosition.h:1077
GeoTessModel.h
geotess::GeoTessPosition::getTriangle
int getTriangle()
Definition: GeoTessPosition.h:871
geotess::GeoTessPosition::setRadiusOutOfRangeAllowed
void setRadiusOutOfRangeAllowed(bool allowed)
Definition: GeoTessPosition.h:1245
geotess::GeoTessPosition::getDepthBottom
double getDepthBottom()
Definition: GeoTessPosition.h:1006
geotess::GeoTessModel
Top level class that manages the GeoTessMetaData, GeoTessGrid and GeoTessData that comprise a 3D Eart...
Definition: GeoTessModel.h:123
ABSTRACT
#define ABSTRACT
Global constant used to make pure virtual functions readable.
Definition: CPPGlobals.h:80
geotess::GeoTessPosition::isNotReferenced
bool isNotReferenced()
Definition: GeoTessPosition.h:1288
geotess::GeoTessPosition::toString
string toString()
geotess::GeoTessPosition::~GeoTessPosition
virtual ~GeoTessPosition()
geotess::GeoTessPosition
Information about an interpolated point at an arbitrary position in a model.
Definition: GeoTessPosition.h:104
GeoTessMetaData.h
geotess::GeoTessPosition::getRadiusBottom
double getRadiusBottom()
Definition: GeoTessPosition.h:988
geotess::GeoTessPosition::getLayerThickness
double getLayerThickness(int layid)
Definition: GeoTessPosition.h:1039
geotess::GeoTessPosition::getWeights
void getWeights(map< int, double > &weights, double dkm)
Definition: GeoTessPosition.h:1176
geotess::GeoTessPosition::set
void set(double lat, double lon, double depth)
Definition: GeoTessPosition.h:608
geotess::GeoTessPosition::setRadius
void setRadius(double rad)
Definition: GeoTessPosition.h:741
geotess::GeoTessException
An exception class for all GeoTess objects.
Definition: GeoTessException.h:68
geotess::GeoTessPosition::getLayerId
int getLayerId()
Definition: GeoTessPosition.h:1105
geotess::GeoTessPosition::getRadiusTop
double getRadiusTop(int layid)
geotess::GeoTessPosition::getMaxTessLevel
int getMaxTessLevel(int layid)
Definition: GeoTessPosition.h:954
geotess::GeoTessPosition::getRadiusBottom
double getRadiusBottom(int layid)
CPPUtils.h
geotess::GeoTessPosition::getHorizontalCoefficients
const vector< double > & getHorizontalCoefficients() const
Definition: GeoTessPosition.h:1192
geotess::GeoTessPosition::getTessLevel
int getTessLevel() const
Definition: GeoTessPosition.h:963
geotess::GeoTessPosition::getDepthBottom
double getDepthBottom(int layid)
Definition: GeoTessPosition.h:1028
geotess::GeoTessPosition::setModel
void setModel(GeoTessModel *newModel)
geotess::GeoTessPosition::set
void set(const double *const uVector, const double &newRadius)
Definition: GeoTessPosition.h:628
geotess::GeoTessPosition::getCoefficients
void getCoefficients(map< int, double > &coefficients)
Definition: GeoTessPosition.h:920
geotess::GeoTessPosition::getRadiusTop
double getRadiusTop()
Definition: GeoTessPosition.h:980
geotess::GeoTessPosition::getVector
double * getVector()
Definition: GeoTessPosition.h:855
geotess::GeoTessInterpolatorType
Enumeration of the interpolation algorithms supported by GeoTess including LINEAR,...
Definition: GeoTessInterpolatorType.h:74
geotess::GeoTessPosition::setMaxTessLevel
void setMaxTessLevel(int layid, int maxTess)
Definition: GeoTessPosition.h:938