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 
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 
499 
515  const GeoTessInterpolatorType& horizontalType);
516 
531  const GeoTessInterpolatorType& horizontalType, const GeoTessInterpolatorType& radialType);
532 
536  virtual ~GeoTessPosition();
537 
545 
550  virtual long getMemory() = ABSTRACT;
551 
558  virtual double getValue(int attribute);
559 
580  void setModel(GeoTessModel* newModel);
581 
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 
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 
989  { return getRadiusBottom(layerId); };
990 
996  double getDepthTop()
997  {
998  return getEarthRadius() - getRadiusTop(layerId);
999  }
1000 
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 
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 
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 
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 
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 
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