scifir-units 2.0.0
scifir-units is a library of units of measurement, angles, coordinates, fields, and related data, all lightweight, that help in the development of scientific software and scientific machines
Loading...
Searching...
No Matches
Public Member Functions | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
scifir::coordinates_ndr< float > Class Reference

#include <coordinates_ndr.hpp>

Public Member Functions

 coordinates_ndr ()
 
 coordinates_ndr (const coordinates_ndr< float > &x)
 
 coordinates_ndr (coordinates_ndr< float > &&x)
 
 coordinates_ndr (const vector< float > &new_values, const vector< float > &new_angles)
 
 coordinates_ndr (const vector< float > &new_values, const vector< angle > &new_angles)
 
 coordinates_ndr (float new_x)
 
 coordinates_ndr (float new_x, float new_y, const angle &new_theta)
 
 coordinates_ndr (float new_p, const angle &new_polar_theta, const angle &new_theta)
 
 coordinates_ndr (float new_x, float new_y, float new_z, const angle &new_theta, const angle &new_phi)
 
 coordinates_ndr (float new_p, const angle &new_cylindrical_theta, float new_z, const angle &new_theta, const angle &new_phi)
 
 coordinates_ndr (float new_r, const angle &new_spherical_theta, const angle &new_spherical_phi, const angle &new_theta, const angle &new_phi)
 
 coordinates_ndr (const angle &new_latitude, const angle &new_longitude, float new_altitude, const angle &new_theta, const angle &new_phi)
 
 coordinates_ndr (const coordinates_nd< float > &new_coordinates, const vector< float > &new_angles)
 
 coordinates_ndr (coordinates_nd< float > &&new_coordinates, const vector< float > &new_angles)
 
 coordinates_ndr (const coordinates_nd< float > &new_coordinates, const vector< angle > &new_angles)
 
 coordinates_ndr (coordinates_nd< float > &&new_coordinates, const vector< angle > &new_angles)
 
 coordinates_ndr (const string &init_coordinates_ndr)
 
coordinates_ndr< float > & operator= (const coordinates_ndr< float > &x_coordinates)
 
coordinates_ndr< float > & operator= (coordinates_ndr< float > &&x_coordinates)
 
coordinates_ndr< float > & operator= (const coordinates_nd< float > &x_coordinates)
 
coordinates_ndr< float > & operator= (coordinates_nd< float > &&x_coordinates)
 
coordinates_ndr< float > & operator= (const string &init_coordinates_ndr)
 
bool is_nd (unsigned int i) const
 
int get_nd () const
 
void change_nd (const vector< float > &new_values, const vector< float > &new_angles)
 
void change_nd (const vector< float > &new_values, const vector< angle > &new_angles)
 
const vector< float > & get_values () const
 
void set_values (const vector< float > &new_values)
 
const float & get_value (unsigned int i) const
 
float & get_value (unsigned int i)
 
const vector< angle > & get_angles () const
 
void set_angles (const vector< float > &new_angles)
 
void set_angles (const vector< angle > &new_angles)
 
const angle & get_angle (unsigned int i) const
 
angle & get_angle (unsigned int i)
 
float get_p () const
 
angle get_spherical_theta () const
 
float get_r () const
 
angle get_spherical_phi () const
 
latitude get_latitude () const
 
longitude get_longitude () const
 
float get_altitude () const
 
void point_to (direction::name x)
 
void set_position (float new_x)
 
void set_position (float new_x, float new_y)
 
void set_position (float new_p, const angle &new_theta)
 
void set_position (float new_x, float new_y, float new_z)
 
void set_position (float new_p, const angle &new_theta, float new_z)
 
void set_position (float new_r, const angle &new_theta, const angle &new_phi)
 
void set_position (const angle &new_latitude, const angle &new_longitude, float new_altitude)
 
void set_position (const vector< float > &new_values)
 
void rotate_in_2d (const angle &new_theta)
 
void rotate_in_3d (int axis, const angle &new_theta)
 
void move (float new_x)
 
void move (const displacement_2d &x_displacement)
 
void move (float new_x, float new_y)
 
void move (float new_p, const angle &new_theta)
 
void move (const displacement_3d &x_displacement)
 
void move (float new_x, float new_y, float new_z)
 
void move (float new_p, const angle &new_theta, float new_z)
 
void move (float new_r, const angle &new_theta, const angle &new_phi)
 
void move (const displacement_nd &x_displacement)
 
void move (float new_r, const vector< angle > &new_angles)
 
float distance_to_origin () const
 
string display_cartesian_2d () const
 
string display_polar () const
 
string display_cartesian_3d () const
 
string display_cylindrical () const
 
string display_spherical () const
 
string display_geographical () const
 

Private Member Functions

void initialize_from_string (string init_coordinates_ndr)
 

Private Attributes

vector< float > values
 
vector< angle > angles
 

Static Private Attributes

static float no_value = 0
 

Detailed Description

Definition at line 1117 of file coordinates_ndr.hpp.

Constructor & Destructor Documentation

◆ coordinates_ndr() [1/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( )
inline

Definition at line 1120 of file coordinates_ndr.hpp.

1120 : values(),angles()
1121 {}
scifir::coordinates_ndr< float >::angles
vector< angle > angles
Definition coordinates_ndr.hpp:2035
scifir::coordinates_ndr< float >::values
vector< float > values
Definition coordinates_ndr.hpp:2034

◆ coordinates_ndr() [2/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( const coordinates_ndr< float > &  x)
inline

Definition at line 1123 of file coordinates_ndr.hpp.

1123 : values(),angles()
1124 {
1125 if (x.values.size() == (x.angles.size() + 1))
1126 {
1127 values = x.values;
1128 angles = x.angles;
1129 }
1130 }

◆ coordinates_ndr() [3/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( coordinates_ndr< float > &&  x)
inline

Definition at line 1132 of file coordinates_ndr.hpp.

1132 : values(),angles()
1133 {
1134 if (x.values.size() == (x.angles.size() + 1))
1135 {
1136 values = std::move(x.values);
1137 angles = std::move(x.angles);
1138 }
1139 }

◆ coordinates_ndr() [4/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( const vector< float > &  new_values,
const vector< float > &  new_angles 
)
inlineexplicit

Definition at line 1141 of file coordinates_ndr.hpp.

1141 : values(),angles()
1142 {
1143 if (new_values.size() == (new_angles.size() + 1))
1144 {
1145 values = new_values;
1146 for(const float& x_angle : new_angles)
1147 {
1148 angles.push_back(angle(x_angle));
1149 }
1150 }
1151 }

◆ coordinates_ndr() [5/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( const vector< float > &  new_values,
const vector< angle > &  new_angles 
)
inlineexplicit

Definition at line 1153 of file coordinates_ndr.hpp.

1153 : values(),angles()
1154 {
1155 if (new_values.size() == (new_angles.size() + 1))
1156 {
1157 values = new_values;
1158 angles = new_angles;
1159 }
1160 }

◆ coordinates_ndr() [6/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( float  new_x)
inlineexplicit

Definition at line 1162 of file coordinates_ndr.hpp.

1162 : values(),angles()
1163 {
1164 values.push_back(new_x);
1165 }

◆ coordinates_ndr() [7/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( float  new_x,
float  new_y,
const angle &  new_theta 
)
inlineexplicit

Definition at line 1167 of file coordinates_ndr.hpp.

1167 : values(),angles()
1168 {
1169 values.push_back(new_x);
1170 values.push_back(new_y);
1171 angles.push_back(new_theta);
1172 }

◆ coordinates_ndr() [8/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( float  new_p,
const angle &  new_polar_theta,
const angle &  new_theta 
)
inlineexplicit

Definition at line 1174 of file coordinates_ndr.hpp.

1174 : values(),angles()
1175 {
1176 values.push_back(new_p * scifir::cos(new_polar_theta));
1177 values.push_back(new_p * scifir::sin(new_polar_theta));
1178 angles.push_back(new_theta);
1179 }
scifir::cos
float cos(const angle &x)
Calculates the cos of angle x. It uses the cos() function of the standard library of C++,...
Definition angle.cpp:431
scifir::sin
float sin(const angle &x)
Calculates the sin of angle x. It uses the sin() function of the standard library of C++,...
Definition angle.cpp:426

◆ coordinates_ndr() [9/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( float  new_x,
float  new_y,
float  new_z,
const angle &  new_theta,
const angle &  new_phi 
)
inlineexplicit

Definition at line 1181 of file coordinates_ndr.hpp.

1181 : values(),angles()
1182 {
1183 values.push_back(new_x);
1184 values.push_back(new_y);
1185 values.push_back(new_z);
1186 angles.push_back(new_theta);
1187 angles.push_back(new_phi);
1188 }

◆ coordinates_ndr() [10/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( float  new_p,
const angle &  new_cylindrical_theta,
float  new_z,
const angle &  new_theta,
const angle &  new_phi 
)
inlineexplicit

Definition at line 1190 of file coordinates_ndr.hpp.

1190 : values(),angles()
1191 {
1192 values.push_back(new_p * scifir::cos(new_cylindrical_theta));
1193 values.push_back(new_p * scifir::sin(new_cylindrical_theta));
1194 values.push_back(new_z);
1195 angles.push_back(new_theta);
1196 angles.push_back(new_phi);
1197 }

◆ coordinates_ndr() [11/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( float  new_r,
const angle &  new_spherical_theta,
const angle &  new_spherical_phi,
const angle &  new_theta,
const angle &  new_phi 
)
inlineexplicit

Definition at line 1199 of file coordinates_ndr.hpp.

1199 : values(),angles()
1200 {
1201 values.push_back(new_r * scifir::cos(new_spherical_theta) * scifir::sin(new_spherical_phi));
1202 values.push_back(new_r * scifir::sin(new_spherical_theta) * scifir::sin(new_spherical_phi));
1203 values.push_back(new_r * scifir::cos(new_spherical_phi));
1204 angles.push_back(new_theta);
1205 angles.push_back(new_phi);
1206 }

◆ coordinates_ndr() [12/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( const angle &  new_latitude,
const angle &  new_longitude,
float  new_altitude,
const angle &  new_theta,
const angle &  new_phi 
)
inlineexplicit

Definition at line 1208 of file coordinates_ndr.hpp.

1208 : values(),angles()
1209 {
1210 values.push_back(new_altitude * scifir::cos(new_latitude) * scifir::cos(new_longitude));
1211 values.push_back(new_altitude * scifir::cos(new_latitude) * scifir::sin(new_longitude));
1212 values.push_back(new_altitude * scifir::sin(new_latitude));
1213 angles.push_back(new_theta);
1214 angles.push_back(new_phi);
1215 }

◆ coordinates_ndr() [13/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( const coordinates_nd< float > &  new_coordinates,
const vector< float > &  new_angles 
)
inlineexplicit

Definition at line 1217 of file coordinates_ndr.hpp.

1217 : values(),angles()
1218 {
1219 if (new_coordinates.values.size() == (new_angles.size() + 1))
1220 {
1221 values = new_coordinates.values;
1222 for(const float& x_angle : new_angles)
1223 {
1224 angles.push_back(angle(x_angle));
1225 }
1226 }
1227 }

◆ coordinates_ndr() [14/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( coordinates_nd< float > &&  new_coordinates,
const vector< float > &  new_angles 
)
inlineexplicit

Definition at line 1229 of file coordinates_ndr.hpp.

1229 : values(),angles()
1230 {
1231 if (new_coordinates.values.size() == (new_angles.size() + 1))
1232 {
1233 values = std::move(new_coordinates.values);
1234 for(const float& x_angle : new_angles)
1235 {
1236 angles.push_back(angle(x_angle));
1237 }
1238 }
1239 }

◆ coordinates_ndr() [15/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( const coordinates_nd< float > &  new_coordinates,
const vector< angle > &  new_angles 
)
inlineexplicit

Definition at line 1241 of file coordinates_ndr.hpp.

1241 : values(),angles()
1242 {
1243 if (new_coordinates.values.size() == (new_angles.size() + 1))
1244 {
1245 values = new_coordinates.values;
1246 angles = new_angles;
1247 }
1248 }

◆ coordinates_ndr() [16/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( coordinates_nd< float > &&  new_coordinates,
const vector< angle > &  new_angles 
)
inlineexplicit

Definition at line 1250 of file coordinates_ndr.hpp.

1250 : values(),angles()
1251 {
1252 if (new_coordinates.values.size() == (new_angles.size() + 1))
1253 {
1254 values = std::move(new_coordinates.values);
1255 angles = new_angles;
1256 }
1257 }

◆ coordinates_ndr() [17/17]

scifir::coordinates_ndr< float >::coordinates_ndr ( const string &  init_coordinates_ndr)
inlineexplicit

Definition at line 1259 of file coordinates_ndr.hpp.

1259 : values(),angles()
1260 {
1261 initialize_from_string(init_coordinates_ndr);
1262 }
scifir::coordinates_ndr< float >::initialize_from_string
void initialize_from_string(string init_coordinates_ndr)
Definition coordinates_ndr.hpp:2038

Member Function Documentation

◆ change_nd() [1/2]

void scifir::coordinates_ndr< float >::change_nd ( const vector< float > &  new_values,
const vector< angle > &  new_angles 
)
inline

Definition at line 1331 of file coordinates_ndr.hpp.

1332 {
1333 if (new_values.size() == (new_angles.size() + 1))
1334 {
1335 values = new_values;
1336 angles = new_angles;
1337 }
1338 }

◆ change_nd() [2/2]

void scifir::coordinates_ndr< float >::change_nd ( const vector< float > &  new_values,
const vector< float > &  new_angles 
)
inline

Definition at line 1318 of file coordinates_ndr.hpp.

1319 {
1320 if (new_values.size() == (new_angles.size() + 1))
1321 {
1322 values = new_values;
1323 angles.clear();
1324 for(const float& x_angle : new_angles)
1325 {
1326 angles.push_back(angle(x_angle));
1327 }
1328 }
1329 }

◆ display_cartesian_2d()

string scifir::coordinates_ndr< float >::display_cartesian_2d ( ) const
inline

Definition at line 1919 of file coordinates_ndr.hpp.

1920 {
1921 if (values.size() == 2 and angles.size() == 1)
1922 {
1923 ostringstream out;
1924 out << "(";
1925 if (get_nd() == 2)
1926 {
1927 out << display_float(values[0]) << "," << display_float(values[1]) << ";" << angles[0];
1928 }
1929 out << ")";
1930 return out.str();
1931 }
1932 else
1933 {
1934 return "[no-2d]";
1935 }
1936 }
scifir::coordinates_ndr< float >::get_nd
int get_nd() const
Definition coordinates_ndr.hpp:1313
scifir::display_float
string display_float(const float &value, int number_of_decimals)
Definition types.cpp:36

◆ display_cartesian_3d()

string scifir::coordinates_ndr< float >::display_cartesian_3d ( ) const
inline

Definition at line 1957 of file coordinates_ndr.hpp.

1958 {
1959 if (values.size() == 3 and angles.size() == 2)
1960 {
1961 ostringstream out;
1962 out << "(";
1963 if (get_nd() == 3)
1964 {
1965 out << display_float(values[0]) << "," << display_float(values[1]) << "," << display_float(values[2]) << ";" << angles[0] << "," << angles[1];
1966 }
1967 out << ")";
1968 return out.str();
1969 }
1970 else
1971 {
1972 return "[no-3d]";
1973 }
1974 }

◆ display_cylindrical()

string scifir::coordinates_ndr< float >::display_cylindrical ( ) const
inline

Definition at line 1976 of file coordinates_ndr.hpp.

1977 {
1978 if (values.size() == 3 and angles.size() == 2)
1979 {
1980 ostringstream out;
1981 out << "(";
1982 if (get_nd() == 3)
1983 {
1984 out << display_float(get_p()) << "," << get_spherical_theta() << "," << display_float(values[2]) << ";" << angles[0] << "," << angles[1];
1985 }
1986 out << ")";
1987 return out.str();
1988 }
1989 else
1990 {
1991 return "[no-3d]";
1992 }
1993 }
scifir::coordinates_ndr< float >::get_spherical_theta
angle get_spherical_theta() const
Definition coordinates_ndr.hpp:1438
scifir::coordinates_ndr< float >::get_p
float get_p() const
Definition coordinates_ndr.hpp:1426

◆ display_geographical()

string scifir::coordinates_ndr< float >::display_geographical ( ) const
inline

Definition at line 2014 of file coordinates_ndr.hpp.

2015 {
2016 if (values.size() == 3 and angles.size() == 2)
2017 {
2018 ostringstream out;
2019 out << "(";
2020 if (get_nd() == 3)
2021 {
2022 out << get_latitude() << "," << get_longitude() << "," << display_float(get_altitude()) << ";" << angles[0] << "," << angles[1];
2023 }
2024 out << ")";
2025 return out.str();
2026 }
2027 else
2028 {
2029 return "[no-3d]";
2030 }
2031 }
scifir::coordinates_ndr< float >::get_longitude
longitude get_longitude() const
Definition coordinates_ndr.hpp:1486
scifir::coordinates_ndr< float >::get_latitude
latitude get_latitude() const
Definition coordinates_ndr.hpp:1474
scifir::coordinates_ndr< float >::get_altitude
float get_altitude() const
Definition coordinates_ndr.hpp:1498

◆ display_polar()

string scifir::coordinates_ndr< float >::display_polar ( ) const
inline

Definition at line 1938 of file coordinates_ndr.hpp.

1939 {
1940 if (values.size() == 2 and angles.size() == 1)
1941 {
1942 ostringstream out;
1943 out << "(";
1944 if (get_nd() == 2)
1945 {
1946 out << display_float(get_p()) << "," << get_spherical_theta() << ";" << angles[0];
1947 }
1948 out << ")";
1949 return out.str();
1950 }
1951 else
1952 {
1953 return "[no-2d]";
1954 }
1955 }

◆ display_spherical()

string scifir::coordinates_ndr< float >::display_spherical ( ) const
inline

Definition at line 1995 of file coordinates_ndr.hpp.

1996 {
1997 if (values.size() == 3 and angles.size() == 2)
1998 {
1999 ostringstream out;
2000 out << "(";
2001 if (get_nd() == 3)
2002 {
2003 out << display_float(get_r()) << "," << get_spherical_theta() << "," << get_spherical_phi() << ";" << angles[0] << "," << angles[1];
2004 }
2005 out << ")";
2006 return out.str();
2007 }
2008 else
2009 {
2010 return "[no-3d]";
2011 }
2012 }
scifir::coordinates_ndr< float >::get_spherical_phi
angle get_spherical_phi() const
Definition coordinates_ndr.hpp:1462
scifir::coordinates_ndr< float >::get_r
float get_r() const
Definition coordinates_ndr.hpp:1450

◆ distance_to_origin()

float scifir::coordinates_ndr< float >::distance_to_origin ( ) const
inline

Definition at line 1909 of file coordinates_ndr.hpp.

1910 {
1911 float x_T = 0;
1912 for (unsigned int i = 0; i < values.size(); i++)
1913 {
1914 x_T += float(std::pow(values[i],2));
1915 }
1916 return std::sqrt(x_T);
1917 }

◆ get_altitude()

float scifir::coordinates_ndr< float >::get_altitude ( ) const
inline

Definition at line 1498 of file coordinates_ndr.hpp.

1499 {
1500 if (get_nd() == 3)
1501 {
1502 return ECEF_to_LLA_altitude(values[0],values[1],values[2]);
1503 }
1504 else
1505 {
1506 return 0.0f;
1507 }
1508 }
scifir::ECEF_to_LLA_altitude
scalar_unit ECEF_to_LLA_altitude(const scalar_unit &x, scalar_unit y, const scalar_unit &z)
Definition coordinates_3d.hpp:45

◆ get_angle() [1/2]

angle & scifir::coordinates_ndr< float >::get_angle ( unsigned int  i)
inline

Definition at line 1414 of file coordinates_ndr.hpp.

1415 {
1416 if (i < (values.size() - 1))
1417 {
1418 return angles[i];
1419 }
1420 else
1421 {
1422 return coordinates_ndr_no_angle;
1423 }
1424 }
scifir::coordinates_ndr_no_angle
angle coordinates_ndr_no_angle
Definition coordinates_ndr.cpp:7

◆ get_angle() [2/2]

const angle & scifir::coordinates_ndr< float >::get_angle ( unsigned int  i) const
inline

Definition at line 1402 of file coordinates_ndr.hpp.

1403 {
1404 if (i < (values.size() - 1))
1405 {
1406 return angles[i];
1407 }
1408 else
1409 {
1410 return coordinates_ndr_no_angle;
1411 }
1412 }

◆ get_angles()

const vector< angle > & scifir::coordinates_ndr< float >::get_angles ( ) const
inline

Definition at line 1377 of file coordinates_ndr.hpp.

1378 {
1379 return angles;
1380 }

◆ get_latitude()

latitude scifir::coordinates_ndr< float >::get_latitude ( ) const
inline

Definition at line 1474 of file coordinates_ndr.hpp.

1475 {
1476 if (get_nd() == 3)
1477 {
1478 return ECEF_to_LLA_latitude(values[0],values[1],values[2]);
1479 }
1480 else
1481 {
1482 return latitude();
1483 }
1484 }
scifir::ECEF_to_LLA_latitude
latitude ECEF_to_LLA_latitude(const scalar_unit &x, scalar_unit y, const scalar_unit &z)
Definition coordinates_3d.hpp:22

◆ get_longitude()

longitude scifir::coordinates_ndr< float >::get_longitude ( ) const
inline

Definition at line 1486 of file coordinates_ndr.hpp.

1487 {
1488 if (get_nd() == 3)
1489 {
1490 return ECEF_to_LLA_longitude(values[0],values[1],values[2]);
1491 }
1492 else
1493 {
1494 return longitude();
1495 }
1496 }
scifir::ECEF_to_LLA_longitude
longitude ECEF_to_LLA_longitude(const scalar_unit &x, scalar_unit y, const scalar_unit &z)
Definition coordinates_3d.hpp:40

◆ get_nd()

int scifir::coordinates_ndr< float >::get_nd ( ) const
inline

Definition at line 1313 of file coordinates_ndr.hpp.

1314 {
1315 return values.size();
1316 }

◆ get_p()

float scifir::coordinates_ndr< float >::get_p ( ) const
inline

Definition at line 1426 of file coordinates_ndr.hpp.

1427 {
1428 if (get_nd() == 2 or get_nd() == 3)
1429 {
1430 return float(std::sqrt(std::pow(values[0],2) + std::pow(values[1],2)));
1431 }
1432 else
1433 {
1434 return float();
1435 }
1436 }

◆ get_r()

float scifir::coordinates_ndr< float >::get_r ( ) const
inline

Definition at line 1450 of file coordinates_ndr.hpp.

1451 {
1452 if (get_nd() == 2 or get_nd() == 3)
1453 {
1454 return float(std::sqrt(std::pow(values[0],2) + std::pow(values[1],2) + std::pow(values[2],2)));
1455 }
1456 else
1457 {
1458 return float();
1459 }
1460 }

◆ get_spherical_phi()

angle scifir::coordinates_ndr< float >::get_spherical_phi ( ) const
inline

Definition at line 1462 of file coordinates_ndr.hpp.

1463 {
1464 if (get_nd() == 3)
1465 {
1466 return angle(scifir::acos_degree(float(values[2]/std::sqrt(std::pow(values[0],2) + std::pow(values[1],2) + std::pow(values[2],2)))));
1467 }
1468 else
1469 {
1470 return angle();
1471 }
1472 }
scifir::acos_degree
float acos_degree(float x)
Calculates the acos receiving x in degrees. It uses the acos() function of the standard library of C+...
Definition angle.hpp:247

◆ get_spherical_theta()

angle scifir::coordinates_ndr< float >::get_spherical_theta ( ) const
inline

Definition at line 1438 of file coordinates_ndr.hpp.

1439 {
1440 if (get_nd() == 2 or get_nd() == 3)
1441 {
1442 return angle(scifir::atan_degree(float(values[1]/values[0])));
1443 }
1444 else
1445 {
1446 return angle();
1447 }
1448 }
scifir::atan_degree
float atan_degree(float x)
Calculates the atan receiving x in degrees. It uses the atan() function of the standard library of C+...
Definition angle.hpp:252

◆ get_value() [1/2]

float & scifir::coordinates_ndr< float >::get_value ( unsigned int  i)
inline

Definition at line 1365 of file coordinates_ndr.hpp.

1366 {
1367 if (i < (values.size()))
1368 {
1369 return values[i];
1370 }
1371 else
1372 {
1373 return no_value;
1374 }
1375 }
scifir::coordinates_ndr< float >::no_value
static float no_value
Definition coordinates_ndr.hpp:2036

◆ get_value() [2/2]

const float & scifir::coordinates_ndr< float >::get_value ( unsigned int  i) const
inline

Definition at line 1353 of file coordinates_ndr.hpp.

1354 {
1355 if (i < (values.size()))
1356 {
1357 return values[i];
1358 }
1359 else
1360 {
1361 return no_value;
1362 }
1363 }

◆ get_values()

const vector< float > & scifir::coordinates_ndr< float >::get_values ( ) const
inline

Definition at line 1340 of file coordinates_ndr.hpp.

1341 {
1342 return values;
1343 }

◆ initialize_from_string()

void scifir::coordinates_ndr< float >::initialize_from_string ( string  init_coordinates_ndr)
inlineprivate

Definition at line 2038 of file coordinates_ndr.hpp.

2039 {
2040 vector<string> init_coordinates;
2041 vector<string> init_values;
2042 vector<string> init_angles;
2043 if (init_coordinates_ndr.front() == '(')
2044 {
2045 init_coordinates_ndr.erase(0,1);
2046 }
2047 if (init_coordinates_ndr.back() == ')')
2048 {
2049 init_coordinates_ndr.erase(init_coordinates_ndr.size()-1,1);
2050 }
2051 boost::split(init_coordinates,init_coordinates_ndr,boost::is_any_of(";"));
2052 if (init_coordinates.size() > 0)
2053 {
2054 boost::split(init_values,init_coordinates[0],boost::is_any_of(","));
2055 }
2056 if (init_coordinates.size() > 1)
2057 {
2058 boost::split(init_angles,init_coordinates[1],boost::is_any_of(","));
2059 }
2060 for (const string& x_value : init_values)
2061 {
2062 if (x_value == "")
2063 {
2064 return;
2065 }
2066 }
2067 for (const string& x_value : init_angles)
2068 {
2069 if (x_value == "")
2070 {
2071 return;
2072 }
2073 }
2074 if (init_values.size() == 2 and init_angles.size() == 1)
2075 {
2076 if (is_angle(init_values[1]))
2077 {
2078 values.push_back(stof(init_values[0]) * scifir::cos(angle(init_values[1])));
2079 values.push_back(stof(init_values[0]) * scifir::sin(angle(init_values[1])));
2080 }
2081 else
2082 {
2083 values.push_back(stof(init_values[0]));
2084 values.push_back(stof(init_values[1]));
2085 }
2086 angles.push_back(angle(init_angles[0]));
2087 }
2088 else if (init_values.size() == 3 and init_angles.size() == 2)
2089 {
2090 if (is_latitude(init_values[0]))
2091 {
2092 if (is_longitude(init_values[1]))
2093 {
2094 if (!is_angle(init_values[2]))
2095 {
2096 values.push_back(stof(init_values[2]) * scifir::cos(angle(init_values[0])) * scifir::cos(angle(init_values[1])));
2097 values.push_back(stof(init_values[2]) * scifir::cos(angle(init_values[0])) * scifir::sin(angle(init_values[1])));
2098 values.push_back(stof(init_values[2]) * scifir::sin(angle(init_values[0])));
2099 }
2100 }
2101 }
2102 else
2103 {
2104 if (is_angle(init_values[1]))
2105 {
2106 if (is_angle(init_values[2]))
2107 {
2108 values.push_back(stof(init_values[0]) * scifir::cos(angle(init_values[1])) * scifir::sin(angle(init_values[2])));
2109 values.push_back(stof(init_values[0]) * scifir::sin(angle(init_values[1])) * scifir::sin(angle(init_values[2])));
2110 values.push_back(stof(init_values[0]) * scifir::cos(angle(init_values[2])));
2111 }
2112 else
2113 {
2114 values.push_back(stof(init_values[0]) * scifir::cos(angle(init_values[1])));
2115 values.push_back(stof(init_values[0]) * scifir::sin(angle(init_values[1])));
2116 values.push_back(stof(init_values[2]));
2117 }
2118 }
2119 else
2120 {
2121 if (!is_angle(init_values[2]))
2122 {
2123 values.push_back(stof(init_values[0]));
2124 values.push_back(stof(init_values[1]));
2125 values.push_back(stof(init_values[2]));
2126 }
2127 }
2128 }
2129 angles.push_back(angle(init_angles[0]));
2130 angles.push_back(angle(init_angles[1]));
2131 }
2132 else
2133 {
2134 if (init_values.size() == (init_angles.size() + 1))
2135 {
2136 for (int i = 0; i < init_values.size(); i++)
2137 {
2138 values.push_back(stof(init_values[i]));
2139 }
2140 for (int i = 0; i < init_angles.size(); i++)
2141 {
2142 angles.push_back(angle(init_angles[i]));
2143 }
2144 }
2145 }
2146 }
scifir::is_latitude
bool is_latitude(const string &init_latitude)
Definition latitude.cpp:199
scifir::is_longitude
bool is_longitude(const string &init_longitude)
Definition longitude.cpp:195
scifir::is_angle
bool is_angle(const string &init_angle)
Checks if some string is an initialization string of an angle.
Definition angle.cpp:336

◆ is_nd()

bool scifir::coordinates_ndr< float >::is_nd ( unsigned int  i) const
inline

Definition at line 1308 of file coordinates_ndr.hpp.

1309 {
1310 return values.size() == i;
1311 }

◆ move() [1/10]

void scifir::coordinates_ndr< float >::move ( const displacement_2d &  x_displacement)
inline

Definition at line 1825 of file coordinates_ndr.hpp.

1826 {
1827 if (values.size() == 2 and angles.size() == 1)
1828 {
1829 values[0] += float(x_displacement.x_projection());
1830 values[1] += float(x_displacement.y_projection());
1831 }
1832 }

◆ move() [2/10]

void scifir::coordinates_ndr< float >::move ( const displacement_3d &  x_displacement)
inline

Definition at line 1852 of file coordinates_ndr.hpp.

1853 {
1854 if (values.size() == 3 and angles.size() == 2)
1855 {
1856 values[0] += float(x_displacement.x_projection());
1857 values[1] += float(x_displacement.y_projection());
1858 values[2] += float(x_displacement.z_projection());
1859 }
1860 }

◆ move() [3/10]

void scifir::coordinates_ndr< float >::move ( const displacement_nd &  x_displacement)
inline

Definition at line 1892 of file coordinates_ndr.hpp.

1893 {
1894 if (x_displacement.get_nd() == get_nd())
1895 {
1896 for (int i = 0; i < x_displacement.get_nd(); i++)
1897 {
1898 values[i] += float(x_displacement.n_projection(i));
1899 }
1900 }
1901 }

◆ move() [4/10]

void scifir::coordinates_ndr< float >::move ( float  new_p,
const angle &  new_theta 
)
inline

Definition at line 1843 of file coordinates_ndr.hpp.

1844 {
1845 if (values.size() == 2 and angles.size() == 1)
1846 {
1847 values[0] += new_p * scifir::cos(new_theta);
1848 values[1] += new_p * scifir::sin(new_theta);
1849 }
1850 }

◆ move() [5/10]

void scifir::coordinates_ndr< float >::move ( float  new_p,
const angle &  new_theta,
float  new_z 
)
inline

Definition at line 1872 of file coordinates_ndr.hpp.

1873 {
1874 if (values.size() == 3 and angles.size() == 2)
1875 {
1876 values[0] += new_p * scifir::cos(new_theta);
1877 values[1] += new_p * scifir::sin(new_theta);
1878 values[2] += new_z;
1879 }
1880 }

◆ move() [6/10]

void scifir::coordinates_ndr< float >::move ( float  new_r,
const angle &  new_theta,
const angle &  new_phi 
)
inline

Definition at line 1882 of file coordinates_ndr.hpp.

1883 {
1884 if (values.size() == 3 and angles.size() == 2)
1885 {
1886 values[0] += new_r * scifir::cos(new_theta) * scifir::sin(new_phi);
1887 values[1] += new_r * scifir::sin(new_theta) * scifir::sin(new_phi);
1888 values[2] += new_r * scifir::cos(new_phi);
1889 }
1890 }

◆ move() [7/10]

void scifir::coordinates_ndr< float >::move ( float  new_r,
const vector< angle > &  new_angles 
)
inline

Definition at line 1903 of file coordinates_ndr.hpp.

1904 {
1905 displacement_nd x_displacement = displacement_nd(new_r,"m",new_angles);
1906 move(x_displacement);
1907 }
scifir::coordinates_ndr< float >::move
void move(float new_x)
Definition coordinates_ndr.hpp:1817

◆ move() [8/10]

void scifir::coordinates_ndr< float >::move ( float  new_x)
inline

Definition at line 1817 of file coordinates_ndr.hpp.

1818 {
1819 if (values.size() == 1 and angles.size() == 0)
1820 {
1821 values[0] += new_x;
1822 }
1823 }

◆ move() [9/10]

void scifir::coordinates_ndr< float >::move ( float  new_x,
float  new_y 
)
inline

Definition at line 1834 of file coordinates_ndr.hpp.

1835 {
1836 if (values.size() == 2 and angles.size() == 1)
1837 {
1838 values[0] += new_x;
1839 values[1] += new_y;
1840 }
1841 }

◆ move() [10/10]

void scifir::coordinates_ndr< float >::move ( float  new_x,
float  new_y,
float  new_z 
)
inline

Definition at line 1862 of file coordinates_ndr.hpp.

1863 {
1864 if (values.size() == 3 and angles.size() == 2)
1865 {
1866 values[0] += new_x;
1867 values[1] += new_y;
1868 values[2] += new_z;
1869 }
1870 }

◆ operator=() [1/5]

coordinates_ndr< float > & scifir::coordinates_ndr< float >::operator= ( const coordinates_nd< float > &  x_coordinates)
inline

Definition at line 1284 of file coordinates_ndr.hpp.

1285 {
1286 if (x_coordinates.values.size() == (angles.size() + 1))
1287 {
1288 values = x_coordinates.values;
1289 }
1290 return *this;
1291 }

◆ operator=() [2/5]

coordinates_ndr< float > & scifir::coordinates_ndr< float >::operator= ( const coordinates_ndr< float > &  x_coordinates)
inline

Definition at line 1264 of file coordinates_ndr.hpp.

1265 {
1266 if (x_coordinates.values.size() == (x_coordinates.angles.size() + 1))
1267 {
1268 values = x_coordinates.values;
1269 angles = x_coordinates.angles;
1270 }
1271 return *this;
1272 }

◆ operator=() [3/5]

coordinates_ndr< float > & scifir::coordinates_ndr< float >::operator= ( const string &  init_coordinates_ndr)
inline

Definition at line 1302 of file coordinates_ndr.hpp.

1303 {
1304 initialize_from_string(init_coordinates_ndr);
1305 return *this;
1306 }

◆ operator=() [4/5]

coordinates_ndr< float > & scifir::coordinates_ndr< float >::operator= ( coordinates_nd< float > &&  x_coordinates)
inline

Definition at line 1293 of file coordinates_ndr.hpp.

1294 {
1295 if (x_coordinates.values.size() == (angles.size() + 1))
1296 {
1297 values = std::move(x_coordinates.values);
1298 }
1299 return *this;
1300 }

◆ operator=() [5/5]

coordinates_ndr< float > & scifir::coordinates_ndr< float >::operator= ( coordinates_ndr< float > &&  x_coordinates)
inline

Definition at line 1274 of file coordinates_ndr.hpp.

1275 {
1276 if (x_coordinates.values.size() == (x_coordinates.angles.size() + 1))
1277 {
1278 values = std::move(x_coordinates.values);
1279 angles = std::move(x_coordinates.angles);
1280 }
1281 return *this;
1282 }

◆ point_to()

void scifir::coordinates_ndr< float >::point_to ( direction::name  x)
inline

Definition at line 1510 of file coordinates_ndr.hpp.

1511 {
1512 if (is_nd(1))
1513 {
1514 if (x == direction::LEFT)
1515 {
1516 if (values[0] > 0)
1517 {
1518 values[0] *= -1;
1519 }
1520 }
1521 else if(x == direction::RIGHT)
1522 {
1523 if (values[0] < 0)
1524 {
1525 values[0] *= -1;
1526 }
1527 }
1528 }
1529 else if (is_nd(2))
1530 {
1531 if (x == direction::LEFT)
1532 {
1533 angles[0] = 180.0f;
1534 }
1535 else if(x == direction::RIGHT)
1536 {
1537 angles[0] = 0.0f;
1538 }
1539 else if(x == direction::TOP)
1540 {
1541 angles[0] = 90.0f;
1542 }
1543 else if(x == direction::BOTTOM)
1544 {
1545 angles[0] = 270.0f;
1546 }
1547 else if(x == direction::LEFT_TOP)
1548 {
1549 angles[0] = 135.0f;
1550 }
1551 else if(x == direction::RIGHT_TOP)
1552 {
1553 angles[0] = 45.0f;
1554 }
1555 else if(x == direction::RIGHT_BOTTOM)
1556 {
1557 angles[0] = 315.0f;
1558 }
1559 else if(x == direction::LEFT_BOTTOM)
1560 {
1561 angles[0] = 225.0f;
1562 }
1563 }
1564 else if (is_nd(3))
1565 {
1566 if (x == direction::LEFT)
1567 {
1568 angles[0] = 270.0f;
1569 angles[1] = 90.0f;
1570 }
1571 else if(x == direction::RIGHT)
1572 {
1573 angles[0] = 90.0f;
1574 angles[1] = 90.0f;
1575 }
1576 else if(x == direction::TOP)
1577 {
1578 angles[0] = 0.0f;
1579 angles[1] = 0.0f;
1580 }
1581 else if(x == direction::BOTTOM)
1582 {
1583 angles[0] = 0.0f;
1584 angles[1] = 180.0f;
1585 }
1586 else if(x == direction::LEFT_TOP)
1587 {
1588 angles[0] = 270.0f;
1589 angles[1] = 45.0f;
1590 }
1591 else if(x == direction::RIGHT_TOP)
1592 {
1593 angles[0] = 90.0f;
1594 angles[1] = 45.0f;
1595 }
1596 else if(x == direction::RIGHT_BOTTOM)
1597 {
1598 angles[0] = 90.0f;
1599 angles[1] = 135.0f;
1600 }
1601 else if(x == direction::LEFT_BOTTOM)
1602 {
1603 angles[0] = 270.0f;
1604 angles[1] = 135.0f;
1605 }
1606 else if(x == direction::FRONT)
1607 {
1608 angles[0] = 0.0f;
1609 angles[1] = 90.0f;
1610 }
1611 else if(x == direction::BACK)
1612 {
1613 angles[0] = 180.0f;
1614 angles[1] = 90.0f;
1615 }
1616 else if(x == direction::LEFT_FRONT)
1617 {
1618 angles[0] = 315.0f;
1619 angles[1] = 90.0f;
1620 }
1621 else if(x == direction::RIGHT_FRONT)
1622 {
1623 angles[0] = 45.0f;
1624 angles[1] = 90.0f;
1625 }
1626 else if(x == direction::TOP_FRONT)
1627 {
1628 angles[0] = 0.0f;
1629 angles[1] = 45.0f;
1630 }
1631 else if(x == direction::BOTTOM_FRONT)
1632 {
1633 angles[0] = 0.0f;
1634 angles[1] = 135.0f;
1635 }
1636 else if(x == direction::LEFT_BACK)
1637 {
1638 angles[0] = 225.0f;
1639 angles[1] = 90.0f;
1640 }
1641 else if(x == direction::RIGHT_BACK)
1642 {
1643 angles[0] = 135.0f;
1644 angles[1] = 90.0f;
1645 }
1646 else if(x == direction::TOP_BACK)
1647 {
1648 angles[0] = 180.0f;
1649 angles[1] = 45.0f;
1650 }
1651 else if(x == direction::BOTTOM_BACK)
1652 {
1653 angles[0] = 180.0f;
1654 angles[1] = 135.0f;
1655 }
1656 else if(x == direction::LEFT_TOP_FRONT)
1657 {
1658 angles[0] = 315.0f;
1659 angles[1] = 45.0f;
1660 }
1661 else if(x == direction::RIGHT_TOP_FRONT)
1662 {
1663 angles[0] = 45.0f;
1664 angles[1] = 45.0f;
1665 }
1666 else if(x == direction::LEFT_BOTTOM_FRONT)
1667 {
1668 angles[0] = 315.0f;
1669 angles[1] = 135.0f;
1670 }
1671 else if(x == direction::RIGHT_BOTTOM_FRONT)
1672 {
1673 angles[0] = 45.0f;
1674 angles[1] = 135.0f;
1675 }
1676 else if(x == direction::LEFT_TOP_BACK)
1677 {
1678 angles[0] = 225.0f;
1679 angles[1] = 45.0f;
1680 }
1681 else if(x == direction::RIGHT_TOP_BACK)
1682 {
1683 angles[0] = 135.0f;
1684 angles[1] = 45.0f;
1685 }
1686 else if(x == direction::LEFT_BOTTOM_BACK)
1687 {
1688 angles[0] = 225.0f;
1689 angles[1] = 135.0f;
1690 }
1691 else if(x == direction::RIGHT_BOTTOM_BACK)
1692 {
1693 angles[0] = 135.0f;
1694 angles[1] = 135.0f;
1695 }
1696 }
1697 }
scifir::coordinates_ndr< float >::is_nd
bool is_nd(unsigned int i) const
Definition coordinates_ndr.hpp:1308

◆ rotate_in_2d()

void scifir::coordinates_ndr< float >::rotate_in_2d ( const angle &  new_theta)
inline

Definition at line 1778 of file coordinates_ndr.hpp.

1779 {
1780 if (get_nd() == 2)
1781 {
1782 float x_coord = values[0];
1783 float y_coord = values[1];
1784 values[0] = x_coord * scifir::cos(new_theta) - y_coord * scifir::sin(new_theta);
1785 values[1] = x_coord * scifir::sin(new_theta) + y_coord * scifir::cos(new_theta);
1786 }
1787 }

◆ rotate_in_3d()

void scifir::coordinates_ndr< float >::rotate_in_3d ( int  axis,
const angle &  new_theta 
)
inline

Definition at line 1789 of file coordinates_ndr.hpp.

1790 {
1791 if (get_nd() == 3)
1792 {
1793 if (axis == 1)
1794 {
1795 float y_coord = values[1];
1796 float z_coord = values[2];
1797 values[1] = y_coord * scifir::cos(new_theta) - z_coord * scifir::sin(new_theta);
1798 values[2] = y_coord * scifir::sin(new_theta) + z_coord * scifir::cos(new_theta);
1799 }
1800 else if (axis == 2)
1801 {
1802 float x_coord = values[0];
1803 float z_coord = values[2];
1804 values[0] = x_coord * scifir::cos(new_theta) - z_coord * scifir::sin(new_theta);
1805 values[2] = x_coord * scifir::sin(new_theta) + z_coord * scifir::cos(new_theta);
1806 }
1807 else if (axis == 3)
1808 {
1809 float x_coord = values[0];
1810 float y_coord = values[1];
1811 values[0] = x_coord * scifir::cos(new_theta) - y_coord * scifir::sin(new_theta);
1812 values[1] = x_coord * scifir::sin(new_theta) + y_coord * scifir::cos(new_theta);
1813 }
1814 }
1815 }

◆ set_angles() [1/2]

void scifir::coordinates_ndr< float >::set_angles ( const vector< angle > &  new_angles)
inline

Definition at line 1394 of file coordinates_ndr.hpp.

1395 {
1396 if (values.size() == (new_angles.size() + 1))
1397 {
1398 angles = new_angles;
1399 }
1400 }

◆ set_angles() [2/2]

void scifir::coordinates_ndr< float >::set_angles ( const vector< float > &  new_angles)
inline

Definition at line 1382 of file coordinates_ndr.hpp.

1383 {
1384 if (values.size() == (new_angles.size() + 1))
1385 {
1386 angles.clear();
1387 for(const float& x_angle : new_angles)
1388 {
1389 angles.push_back(angle(x_angle));
1390 }
1391 }
1392 }

◆ set_position() [1/8]

void scifir::coordinates_ndr< float >::set_position ( const angle &  new_latitude,
const angle &  new_longitude,
float  new_altitude 
)
inline

Definition at line 1761 of file coordinates_ndr.hpp.

1762 {
1763 if (values.size() == 3 and angles.size() == 2)
1764 {
1765 values.clear();
1766 values.push_back(new_altitude * scifir::cos(new_latitude) * scifir::cos(new_longitude));
1767 values.push_back(new_altitude * scifir::cos(new_latitude) * scifir::sin(new_longitude));
1768 values.push_back(new_altitude * scifir::sin(new_latitude));
1769 }
1770 }

◆ set_position() [2/8]

void scifir::coordinates_ndr< float >::set_position ( const vector< float > &  new_values)
inline

Definition at line 1772 of file coordinates_ndr.hpp.

1773 {
1774 values.clear();
1775 values = new_values;
1776 }

◆ set_position() [3/8]

void scifir::coordinates_ndr< float >::set_position ( float  new_p,
const angle &  new_theta 
)
inline

Definition at line 1718 of file coordinates_ndr.hpp.

1719 {
1720 if (values.size() == 2 and angles.size() == 1)
1721 {
1722 values.clear();
1723 values.push_back(new_p * scifir::cos(new_theta));
1724 values.push_back(new_p * scifir::sin(new_theta));
1725 }
1726 }

◆ set_position() [4/8]

void scifir::coordinates_ndr< float >::set_position ( float  new_p,
const angle &  new_theta,
float  new_z 
)
inline

Definition at line 1739 of file coordinates_ndr.hpp.

1740 {
1741 if (values.size() == 3 and angles.size() == 2)
1742 {
1743 values.clear();
1744 values.push_back(new_p * scifir::cos(new_theta));
1745 values.push_back(new_p * scifir::sin(new_theta));
1746 values.push_back(new_z);
1747 }
1748 }

◆ set_position() [5/8]

void scifir::coordinates_ndr< float >::set_position ( float  new_r,
const angle &  new_theta,
const angle &  new_phi 
)
inline

Definition at line 1750 of file coordinates_ndr.hpp.

1751 {
1752 if (values.size() == 3 and angles.size() == 2)
1753 {
1754 values.clear();
1755 values.push_back(new_r * scifir::cos(new_theta) * scifir::sin(new_phi));
1756 values.push_back(new_r * scifir::sin(new_theta) * scifir::sin(new_phi));
1757 values.push_back(new_r * scifir::cos(new_phi));
1758 }
1759 }

◆ set_position() [6/8]

void scifir::coordinates_ndr< float >::set_position ( float  new_x)
inline

Definition at line 1699 of file coordinates_ndr.hpp.

1700 {
1701 if (values.size() == 1 and angles.size() == 0)
1702 {
1703 values.clear();
1704 values.push_back(new_x);
1705 }
1706 }

◆ set_position() [7/8]

void scifir::coordinates_ndr< float >::set_position ( float  new_x,
float  new_y 
)
inline

Definition at line 1708 of file coordinates_ndr.hpp.

1709 {
1710 if (values.size() == 2 and angles.size() == 1)
1711 {
1712 values.clear();
1713 values.push_back(new_x);
1714 values.push_back(new_y);
1715 }
1716 }

◆ set_position() [8/8]

void scifir::coordinates_ndr< float >::set_position ( float  new_x,
float  new_y,
float  new_z 
)
inline

Definition at line 1728 of file coordinates_ndr.hpp.

1729 {
1730 if (values.size() == 3 and angles.size() == 2)
1731 {
1732 values.clear();
1733 values.push_back(new_x);
1734 values.push_back(new_y);
1735 values.push_back(new_z);
1736 }
1737 }

◆ set_values()

void scifir::coordinates_ndr< float >::set_values ( const vector< float > &  new_values)
inline

Definition at line 1345 of file coordinates_ndr.hpp.

1346 {
1347 if (values.size() == new_values.size())
1348 {
1349 values = new_values;
1350 }
1351 }

Member Data Documentation

◆ angles

vector<angle> scifir::coordinates_ndr< float >::angles
private

Definition at line 2035 of file coordinates_ndr.hpp.

◆ no_value

float scifir::coordinates_ndr< float >::no_value = 0
staticprivate

Definition at line 2036 of file coordinates_ndr.hpp.

◆ values

vector<float> scifir::coordinates_ndr< float >::values
private

Definition at line 2034 of file coordinates_ndr.hpp.

The documentation for this class was generated from the following files:
Generated by doxygen 1.9.8