mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-05-02 08:49:20 -05:00
Code Issues Packages Projects Releases Wiki Activity

RenderableFov class.

Browse Source 
Intersections with planet and instrument FOV boundary vectors / boresight seem to be correct with a margin of error. This could be either due to
precision issues experienced at greater distances, light-time or stellar aberration correction methods, planetary radius etc etc.
This commit is contained in:
michal
2014-10-27 21:35:59 -04:00
parent 51c8034fe9
commit e31a0b70ab
12 changed files with 184 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/openspace/rendering/renderablefov.h
-4
View File
@@ -66,8 +66,6 @@ public:
double _ratio;
double _day;
// need to write robust method for vbo id selection
// (right now galactic grid has to be present) (why though?) solve later...
GLuint _vaoID ;
GLuint _vBufferID ;
GLuint _iBufferID;
@@ -83,8 +81,6 @@ public:
unsigned int _vtotal;
unsigned int _stride;
double _startTrail;
//Vertex* _varray;
std::vector<float> _varray;
int* _iarray;
include/openspace/util/spicemanager.h
+33 -29
View File
@@ -250,6 +250,8 @@ public:
bool getDateFromET(double ephemerisTime, std::string& date,
const std::string& format = "YYYY MON DDTHR:MN:SC.### ::RND");
void frameConversion(glm::dvec3& v, const std::string from, const std::string to, double ephemerisTime) const;
/**
* Returns the <code>position</code> of a <code>target</code> body relative to an
* <code>observer</code> in a specific <code>referenceFrame</code>, optionally
@@ -290,7 +292,37 @@ public:
psc& position,
double& lightTime) const;
void getPointingAttitude();
/**
* Given an observer and a direction vector defining a ray, compute
* the surface intercept of the ray on a target body at a specified
* epoch, optionally corrected for light time and stellar
* aberration.
* \param method Computation method.
* \param target Name of target body.
* \param et Epoch in ephemeris seconds past J2000 TDB.
* \param fixref Body-fixed, body-centered target body frame.
* \param abcorr Aberration correction.
* \param obsrvr Name of observing body.
* \param dref Reference frame of ray's direction vector.
* \param dvec Ray's direction vector.
* \param spoint Surface intercept point on the target body.
* \param trgepc Intercept epoch.
* \param srfvec Vector from observer to intercept point.
* \param found Flag indicating whether intercept was found.
* For further details, refer to
* http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/sincpt_c.html
*/
bool getSurfaceIntercept(const std::string& target,
const std::string& observer,
const std::string& fovFrame,
const std::string& bodyFixedFrame,
const std::string& method,
const std::string& aberrationCorrection,
double ephemerisTime,
double& targetEpoch,
psc& directionVector,
psc& surfaceIntercept,
psc& surfaceVector) const;
/**
* Returns the state vector (<code>position</code> and <code>velocity</code>) of a
@@ -524,34 +556,6 @@ public:
double& targetEphemerisTime,
glm::dvec3& vectorToSurfacePoint) const;
/**
* Computes the rectangular coordinates of the sub-solar point on
* a target body at a specified epoch, optionally corrected for
* light time and stellar aberration.
* For further details, please refer to 'subslr_c ' in SPICE Docummentation
*
* \param computationMethod Computation method.
* \param target Name of target body.
* \param ephemeris Epoch in ephemeris seconds past J2000 TDB.
* \param bodyFixedFrame Body-fixed, body-centered target body frame.
* \param aberrationCorrection Aberration correction.
* \param observer Name of observing body.
* \param subObserverPoint Sub-observer point on the target body.
* \param targetEpoch Sub-observer point epoch.
* \param observerToSubObserverVec Vector from observer to sub-observer point.
* \return Whether the function succeeded or not
*/
//bool getSubSolarPoint(std::string target,
// std::string computationMethod,
//
// double ephemeris,
// std::string bodyFixedFrame,
// std::string aberrationCorrection,
//
// glm::dvec3& subSolarPoint,
// double& targetEpoch,
// glm::dvec3& vectorToSurfacePoint) const;
/**
* This method checks if one of the previous SPICE methods has failed. If it has, the
* <code>errorMessage</code> is used to log an error along with the original SPICE
openspace-data
+1 -1
Submodule openspace-data updated: b8179a6d15...79b6eaed96
scripts/default_startup.lua
+3 -3
View File
@@ -1,10 +1,10 @@
--openspace.setPropertyValue('Earth.renderable.colorTexture', '${OPENSPACE_DATA}/modules/mars/textures/mars.png')
openspace.time.setTime("2007-02-26T17:30:00")
openspace.time.setTime("2007-02-26T17:57:54")
--openspace.time.setTime("2006-08-22T20:00:00")
--openspace.time.setDeltaTime(200000.0)
--openspace.time.setDeltaTime(5000.00)
--openspace.time.setDeltaTime(864000)
openspace.time.setDeltaTime(100.0)
openspace.time.setDeltaTime(3600)
--openspace.time.setDeltaTime(100.0)
-- print(openspace.time.currentTimeUTC())
shaders/pscstandard_fs.glsl
+1
View File
@@ -71,6 +71,7 @@ void main()
}
*/
diffuse = max(intensity * diffuse, ambient);
diffuse[3] = 0.8f;
//diffuse = vec4(1);
ABufferStruct_t frag = createGeometryFragment(diffuse, position, depth);
src/rendering/model/renderablemodel.cpp
+2 -1
View File
@@ -125,6 +125,8 @@ void RenderableModel::render(const RenderData& data)
// scale the planet to appropriate size since the planet is a unit sphere
glm::mat4 transform = glm::mat4(1);
glm::mat4 roty = glm::rotate(transform, 90.f, glm::vec3(0, 1, 0));
glm::mat4 scale = glm::scale(transform, glm::vec3(1, -1, 1));
glm::mat4 tmp = glm::mat4(1);
for (int i = 0; i < 3; i++){
@@ -132,7 +134,6 @@ void RenderableModel::render(const RenderData& data)
tmp[i][j] = _stateMatrix[i][j];
}
}
transform *= tmp;
glm::mat4 modelview = data.camera.viewMatrix()*data.camera.modelMatrix();
src/rendering/renderablefov.cpp
+63 -55
View File
@@ -52,19 +52,11 @@ namespace openspace{
, _vaoID(0)
, _vBufferID(0)
, _iBufferID(0)
, _mode(GL_LINE_STRIP){
, _mode(GL_LINES){
assert(dictionary.getValue(keyBody , _target));
assert(dictionary.getValue(keyObserver , _observer));
assert(dictionary.getValue(keyFrame , _frame));
if (!dictionary.getValue(keyColor, _c)){
_c = glm::vec3(0.0);
}else{
_r = 1 / _c[0];
_g = 1 / _c[1];
_b = 1 / _c[2];
}
}
void RenderableFov::fullYearSweep(){
@@ -122,9 +114,6 @@ bool RenderableFov::initialize(){
if (_programObject == nullptr)
completeSuccess &= OsEng.ref().configurationManager().getValue("EphemerisProgram", _programObject);
_startTrail;
SpiceManager::ref().getETfromDate("2007 feb 26 20:00:00", _startTrail);
fullYearSweep();
sendToGPU();
@@ -147,74 +136,93 @@ void RenderableFov::render(const RenderData& data){
_programObject->activate();
// fetch data
glm::mat4 tmat = glm::mat4(1);
glm::mat4 transform(1);
glm::mat4 tmp = glm::mat4(1);
glm::mat4 rot = glm::rotate(transform, 90.f, glm::vec3(0, 1, 0));
glm::mat4 roty = glm::rotate(transform, 90.f, glm::vec3(0, 1, 0));
glm::mat4 rotx = glm::rotate(transform, -90.f, glm::vec3(1, 0, 0));
glm::mat4 scale = glm::scale(transform, glm::vec3(1, -1, 1));
for (int i = 0; i < 3; i++){
for (int j = 0; j < 3; j++){
tmp[i][j] = _stateMatrix[i][j];
}
}
transform = tmp*rot;
// setup the data to the shader
_programObject->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
_programObject->setUniform("ModelTransform", transform);
setPscUniforms(_programObject, &data.camera, data.position);
if (_oldTime != _time){
//boresight vector
std::string shape, instrument;
std::vector<glm::dvec3> bounds;
glm::dvec3 boresight;
//boresight vector
std::string shape, name;
shape.resize(32);
name.resize(32);
std::vector<glm::dvec3> bounds;
glm::dvec3 boresight;
bool found = openspace::SpiceManager::ref().getFieldOfView("NH_LORRI", shape, instrument, boresight, bounds);
if (!found) LERROR("Could not locate instrument"); // fixlater
bool found = openspace::SpiceManager::ref().getFieldOfView("NH_LORRI", shape, name, boresight, bounds);
float size = 4 * sizeof(float);
float *begin = &_varray[0];
float size = 4 * sizeof(float);
float *begin = &_varray[0];
glm::vec4 origin(0);
glm::vec4 col_gray(0.3, 0.3, 0.3, 1);
glm::vec4 col_start(1.00, 0.89, 0.00, 1);
glm::vec4 col_end(1.00, 0.29, 0.00, 1);
// glm::vec4 bsight_t(boresight[0], boresight[1], boresight[2], data.position[3] - 3);
glm::vec4 origin(0);
glm::vec4 col_start(1.00, 0.89, 0.00, 1);
glm::vec4 col_end(1.00, 0.29, 0.00, 1);
glm::vec4 bsight_t(boresight[0], boresight[1], boresight[2], data.position[3]-3);
float sc = 2.4;
int indx = 0;
for (int i = 0; i < 4; i++){
// might as well take glm. Would be nice if we had just one type to deal with here...
psc dir = PowerScaledCoordinate::PowerScaledCoordinate(bounds[i][0], bounds[i][1], bounds[i][2], 1);
psc intercept, interceptVector;
double targetEpoch;
found = openspace::SpiceManager::ref().getSurfaceIntercept("JUPITER", _target, instrument,
_frame, "ELLIPSOID", "XCN+S",
_time, targetEpoch, dir, intercept, interceptVector);
interceptVector[3] += 3;
glm::vec4 corner(bounds[i][0], bounds[i][1], bounds[i][2], data.position[3]);
float sc = 2.2;
glm::vec4 corner1(bounds[0][0], bounds[0][1], bounds[0][2], data.position[3]-sc);
memcpy(begin, glm::value_ptr(origin), size);
memcpy(begin + 4, glm::value_ptr(col_start), size);
memcpy(begin + 8, glm::value_ptr(corner1), size);
memcpy(begin + 12, glm::value_ptr(col_end), size);
corner = tmp*corner;
glm::vec4 corner2(bounds[1][0], bounds[1][1], bounds[1][2], data.position[3]-sc);
memcpy(begin + 16, glm::value_ptr(origin), size);
memcpy(begin + 20, glm::value_ptr(col_start), size);
memcpy(begin + 24, glm::value_ptr(corner2), size);
memcpy(begin + 28, glm::value_ptr(col_end), size);
glm::vec4 corner3(bounds[2][0], bounds[2][1], bounds[2][2], data.position[3]-sc);
memcpy(begin + 32, glm::value_ptr(origin), size);
memcpy(begin + 36, glm::value_ptr(col_start), size);
memcpy(begin + 40, glm::value_ptr(corner3), size);
memcpy(begin + 44, glm::value_ptr(col_end), size);
glm::vec4 corner4(bounds[3][0], bounds[3][1], bounds[3][2], data.position[3]-sc);
memcpy(begin + 48, glm::value_ptr(origin), size);
memcpy(begin + 52, glm::value_ptr(col_start), size);
memcpy(begin + 56, glm::value_ptr(corner4), size);
memcpy(begin + 60, glm::value_ptr(col_end), size);
updateData();
//cleanup later.
if (found){
memcpy(&_varray[indx], glm::value_ptr(origin), size);
indx += 4;
memcpy(&_varray[indx], glm::value_ptr(col_start), size);
indx += 4;
memcpy(&_varray[indx], glm::value_ptr(interceptVector.vec4()), size);
indx += 4;
memcpy(&_varray[indx], glm::value_ptr(col_end), size);
indx += 4;
}else{
memcpy(&_varray[indx], glm::value_ptr(origin), size);
indx += 4;
memcpy(&_varray[indx], glm::value_ptr(col_gray), size);
indx += 4;
memcpy(&_varray[indx], glm::value_ptr(corner), size);
indx += 4;
memcpy(&_varray[indx], glm::value_ptr(glm::vec4(0)), size);
indx += 4;
}
}
updateData();
}
_oldTime = _time;
glBindVertexArray(_vaoID);
glDrawArrays(_mode, 0, _vtotal);
glBindVertexArray(0);
glPointSize(3.f);
glBindVertexArray(_vaoID);
glDrawArrays(GL_POINTS, 0, _vtotal);
glBindVertexArray(0);
_programObject->deactivate();
}
@@ -223,7 +231,7 @@ void RenderableFov::update(const UpdateData& data){
_time = data.time;
_delta = data.delta;
openspace::SpiceManager::ref().getPositionTransformMatrix("NH_SPACECRAFT", "GALACTIC", data.time, _stateMatrix);
openspace::SpiceManager::ref().getPositionTransformMatrix("NH_LORRI", "GALACTIC", data.time, _stateMatrix);
}
void RenderableFov::loadTexture()
src/rendering/renderablepath.cpp
+2 -2
View File
@@ -94,7 +94,7 @@ void RenderablePath::fullYearSweep(){
int indx = 0;
for (int i = 0; i < segments + 1; i++){
SpiceManager::ref().getTargetState(_target, _observer, _frame, "LT+S", et, _pscpos, _pscvel, lightTime);
SpiceManager::ref().getTargetState(_target, _observer, _frame, "CN+S", et, _pscpos, _pscvel, lightTime);
if (_pscpos[0] != 0 && _pscpos[1] != 0 && _pscpos[2] != 0 && _pscpos[3] != 1){
_pscpos[3] += 3;
_varray.push_back(_pscpos[0]);
@@ -214,7 +214,7 @@ void RenderablePath::fullYearSweep(){
_delta = data.delta;
int newhorizons = 0;
SpiceManager::ref().getTargetState(_target, _observer, _frame, "LT+S", data.time, _pscpos, _pscvel, lightTime);
SpiceManager::ref().getTargetState(_target, _observer, _frame, "CN+S", data.time, _pscpos, _pscvel, lightTime);
}
void RenderablePath::loadTexture()
src/rendering/renderabletrail.cpp
+4 -4
View File
@@ -104,7 +104,7 @@ void RenderableTrail::fullYearSweep(){
_iarray = new int[_isize];
for (int i = 0; i < segments+2; i++){
SpiceManager::ref().getTargetState(_target, _observer, _frame, "LT+S", et, _pscpos, _pscvel, lightTime);
SpiceManager::ref().getTargetState(_target, _observer, _frame, "CN+S", et, _pscpos, _pscvel, lightTime);
_pscpos[3] += 3;
for (int k = 0; k < 4; k++)
@@ -172,7 +172,7 @@ bool RenderableTrail::initialize(){
_startTrail;
// SpiceManager::ref().getETfromDate("2006 Aug 22 17:00:00", _startTrail);
SpiceManager::ref().getETfromDate("2007 feb 26 17:30:00", _startTrail);
SpiceManager::ref().getETfromDate("2007 feb 26 17:57:54", _startTrail);
_dtEt = _startTrail;
fullYearSweep();
@@ -215,7 +215,7 @@ void RenderableTrail::updateTrail(){
while (_dtEt < _time){
// get intermediary points
psc dtPoint;
SpiceManager::ref().getTargetState(_target, _observer, _frame, "NONE", _dtEt, dtPoint, _pscvel, lightTime);
SpiceManager::ref().getTargetState(_target, _observer, _frame, "CN+S", _dtEt, dtPoint, _pscvel, lightTime);
dtPoint[3] += 3;
// overwrite the old position
@@ -281,7 +281,7 @@ void RenderableTrail::update(const UpdateData& data){
_time = data.time;
_delta = data.delta;
SpiceManager::ref().getTargetState(_target, _observer, _frame, "NONE", data.time, _pscpos, _pscvel, lightTime);
SpiceManager::ref().getTargetState(_target, _observer, _frame, "CN+S", data.time, _pscpos, _pscvel, lightTime);
_pscpos[3] += 3; // KM to M
}
src/scenegraph/spiceephemeris.cpp
+9 -1
View File
@@ -75,7 +75,15 @@ void SpiceEphemeris::update(const UpdateData& data) {
glm::dvec3 position(0,0,0);
double lightTime = 0.0;
SpiceManager::ref().getTargetPosition(_targetName, _originName, "GALACTIC", "CN+S", data.time, position, lightTime);
SpiceManager::ref().getTargetPosition(_targetName, _originName,
"GALACTIC", "NONE", data.time, position, lightTime);
if (_targetName == "NEW HORIZONS"){
// In order to properly draw the viewfrustrum, the craft might have to be
// positioned using the X-variations of aberration methods (ongoing investigation).
SpiceManager::ref().getTargetPosition(_targetName, _originName,
"GALACTIC", "NONE", data.time, position, lightTime);
}
_position = psc::CreatePowerScaledCoordinate(position.x, position.y, position.z);
_position[3] += 3;
src/util/factorymanager.cpp
-3
View File
@@ -29,7 +29,6 @@
// renderables
#include <openspace/rendering/model/renderablemodel.h>
#include <openspace/rendering/stars/renderablestars.h>
#include <openspace/rendering/renderableephemeris.h>
#include <openspace/rendering/renderabletrail.h>
#include <openspace/rendering/renderablepath.h>
@@ -68,8 +67,6 @@ void FactoryManager::initialize()
"RenderablePlanet");
_manager->factory<Renderable>()->registerClass<RenderableStars>(
"RenderableStars");
_manager->factory<Renderable>()->registerClass<RenderableEphemeris>(
"RenderableEphemeris");
//will replace ephemeris class soon...
_manager->factory<Renderable>()->registerClass<RenderablePath>(
"RenderablePath");
src/util/spicemanager.cpp
+66
View File
@@ -310,6 +310,72 @@ bool SpiceManager::getTargetPosition(const std::string& target,
return true;
}
void SpiceManager::frameConversion(glm::dvec3& v, const std::string from, const std::string to, double ephemerisTime) const{
glm::dmat3 transform;
pxform_c(from.c_str(), to.c_str(), ephemerisTime, (double(*)[3])glm::value_ptr(transform));
transform = glm::transpose(transform);
v = transform*v;
}
bool SpiceManager::getSurfaceIntercept(const std::string& target,
const std::string& observer,
const std::string& fovInstrument,
const std::string& referenceFrame,
const std::string& method,
const std::string& aberrationCorrection,
double ephemerisTime,
double& targetEpoch,
psc& directionVector,
psc& surfaceIntercept,
psc& surfaceVector) const{
// make pretty latr
double dvec[3], spoint[3], et;
glm::dvec3 srfvec;
int found;
bool convert;
dvec[0] = directionVector[0];
dvec[1] = directionVector[1];
dvec[2] = directionVector[2];
// allow client specify non-inertial frame.
std::string bodyfixed = "IAU_";
convert = (referenceFrame.find(bodyfixed) == std::string::npos);
if (convert){
bodyfixed += target;
}else{
bodyfixed = referenceFrame;
}
sincpt_c(method.c_str(),
target.c_str(),
ephemerisTime,
bodyfixed.c_str(),
aberrationCorrection.c_str(),
observer.c_str(),
fovInstrument.c_str(),
dvec,
spoint,
&et,
glm::value_ptr(srfvec),
&found);
bool hasError = checkForError("Error retrieving surface intercept on target '" + target + "'" +
"viewed from observer '" + observer + "' in " +
"reference frame '" + bodyfixed + "' at time '" +
std::to_string(ephemerisTime) + "'");
if (convert) frameConversion(srfvec, bodyfixed, referenceFrame, ephemerisTime);
if (!hasError && found){
directionVector = PowerScaledCoordinate::CreatePowerScaledCoordinate(dvec[0] , dvec[1] , dvec[2] );
surfaceIntercept = PowerScaledCoordinate::CreatePowerScaledCoordinate(spoint[0], spoint[1], spoint[2]);
surfaceVector = PowerScaledCoordinate::CreatePowerScaledCoordinate(srfvec[0], srfvec[1], srfvec[2]);
}
return found;
}
bool SpiceManager::getTargetState(const std::string& target,
const std::string& observer,
const std::string& referenceFrame,