// Extract the objects in an SPK kernel
std::vector<int> spkobjects(std::string kernel) {
SPICEINT_CELL(ids,100);
scard_c(0,&ids);
std::vector<int> ret;
spkobj_c(kernel.c_str(),&ids);
for(int i=0;i<card_c(&ids);i++)
ret.push_back(SPICE_CELL_ELEM_I(&ids,i));
return ret;
}
void SpicePosition::getbodies(const std::string &kernel) {
SPICEINT_CELL (ids, 1000);
spkobj_c(kernel.c_str(), &ids);
for (SpiceInt i = 0; i < card_c(&ids); i++) {
SpiceInt obj = SPICE_CELL_ELEM_I(&ids, i);
int key = obj;
if (m_bodies[key] == 0) {
double values[3], radius, gm;
char name[200];
SpiceInt dim;
SpiceBoolean found;
bodc2n_c(obj, sizeof(name), name, &found);
if (found) {
for (int i = 1; name[i] != 0; i++) {
name[i] = tolower(name[i]);
}
radius = gm = 0;
bodvcd_c(obj, "RADII", 3, &dim, values);
if (dim == 3) {
radius = (values[0] + values[1] + values[2]) / 3.;
bodvcd_c(obj, "GM", 1, &dim, values);
if (dim > 0) {
gm = values[0];
BodyConstants bc(obj, name, radius, gm, 40);
m_bodies.addBody(new BodyConstants(obj, name, radius, gm, 40));
}
}
}
}
}
}
//------------------------------------------------------------------------------
void SpiceOrbitKernelReader::GetCoverageStartAndEnd(StringArray &kernels,
Integer forNaifId,
Real &start,
Real &end)
{
// first check to see if a kernel specified is not loaded; if not,
// try to load it
for (unsigned int ii = 0; ii < kernels.size(); ii++)
if (!IsLoaded(kernels.at(ii))) LoadKernel(kernels.at(ii));
SpiceInt idSpice = forNaifId;
SpiceInt arclen = 4;
SpiceInt typlen = 5;
bool firstInt = true;
bool idOnKernel = false;
ConstSpiceChar *kernelName = NULL;
SpiceInt objId = 0;
SpiceInt numInt = 0;
SpiceChar *kernelType;
SpiceChar *arch;
SpiceDouble b;
SpiceDouble e;
Real bA1;
Real eA1;
SPICEINT_CELL(ids, 200);
SPICEDOUBLE_CELL(cover, 200000);
char kStr[5] = " ";
char aStr[4] = " ";
// look through each kernel
for (unsigned int ii = 0; ii < kernels.size(); ii++)
{
#ifdef DEBUG_SPK_COVERAGE
MessageInterface::ShowMessage(wxT("Checking coverage for ID %d on kernel %s\n"),
forNaifId, (kernels.at(ii)).c_str());
#endif
kernelName = kernels[ii].char_str();
// check the type of kernel
arch = aStr;
kernelType = kStr;
getfat_c(kernelName, arclen, typlen, arch, kernelType);
if (failed_c())
{
ConstSpiceChar option[] = "LONG";
SpiceInt numChar = MAX_LONG_MESSAGE_VALUE;
//SpiceChar err[MAX_LONG_MESSAGE_VALUE];
SpiceChar *err = new SpiceChar[MAX_LONG_MESSAGE_VALUE];
getmsg_c(option, numChar, err);
wxString errStr(wxString::FromAscii(err));
wxString errmsg = wxT("Error determining type of kernel \"");
errmsg += kernels.at(ii) + wxT("\". Message received from CSPICE is: ");
errmsg += errStr + wxT("\n");
reset_c();
delete [] err;
throw UtilityException(errmsg);
}
#ifdef DEBUG_SPK_COVERAGE
MessageInterface::ShowMessage(wxT("Kernel is of type %s\n"),
kernelType);
#endif
// only deal with SPK kernels
if (eqstr_c( kernelType, "spk" ))
{
spkobj_c(kernelName, &ids);
// get the list of objects (IDs) for which data exists in the SPK kernel
for (SpiceInt jj = 0; jj < card_c(&ids); jj++)
{
objId = SPICE_CELL_ELEM_I(&ids,jj);
#ifdef DEBUG_SPK_COVERAGE
MessageInterface::ShowMessage(wxT("Kernel contains data for object %d\n"),
(Integer) objId);
#endif
// look to see if this kernel contains data for the object we're interested in
if (objId == idSpice)
{
idOnKernel = true;
break;
}
}
// only deal with kernels containing data for the object we're interested in
if (idOnKernel)
{
#ifdef DEBUG_SPK_COVERAGE
MessageInterface::ShowMessage(wxT("Checking kernel %s for data for object %d\n"),
(kernels.at(ii)).c_str(), (Integer) objId);
#endif
scard_c(0, &cover); // reset the coverage cell
spkcov_c (kernelName, idSpice, &cover);
if (failed_c())
{
ConstSpiceChar option[] = "LONG";
SpiceInt numChar = MAX_LONG_MESSAGE_VALUE;
//SpiceChar err[MAX_LONG_MESSAGE_VALUE];
SpiceChar *err = new SpiceChar[MAX_LONG_MESSAGE_VALUE];
getmsg_c(option, numChar, err);
wxString errStr(wxString::FromAscii(err));
wxString errmsg = wxT("Error determining coverage for SPK kernel \"");
errmsg += kernels.at(ii) + wxT("\". Message received from CSPICE is: ");
errmsg += errStr + wxT("\n");
reset_c();
delete [] err;
throw UtilityException(errmsg);
}
numInt = wncard_c(&cover);
#ifdef DEBUG_SPK_COVERAGE
MessageInterface::ShowMessage(wxT("Number of intervals found = %d\n"),
(Integer) numInt);
#endif
if ((firstInt) && (numInt > 0))
{
wnfetd_c(&cover, 0, &b, &e);
if (failed_c())
{
ConstSpiceChar option[] = "LONG";
SpiceInt numChar = MAX_LONG_MESSAGE_VALUE;
//SpiceChar err[MAX_LONG_MESSAGE_VALUE];
SpiceChar *err = new SpiceChar[MAX_LONG_MESSAGE_VALUE];
getmsg_c(option, numChar, err);
wxString errStr(wxString::FromAscii(err));
wxString errmsg = wxT("Error getting interval times for SPK kernel \"");
errmsg += kernels.at(ii) + wxT("\". Message received from CSPICE is: ");
errmsg += errStr + wxT("\n");
reset_c();
delete [] err;
throw UtilityException(errmsg);
}
start = SpiceTimeToA1(b);
end = SpiceTimeToA1(e);
firstInt = false;
}
for (SpiceInt jj = 0; jj < numInt; jj++)
{
wnfetd_c(&cover, jj, &b, &e);
bA1 = SpiceTimeToA1(b);
eA1 = SpiceTimeToA1(e);
if (bA1 < start) start = bA1;
if (eA1 > end) end = eA1;
}
}
}
}
if (firstInt)
{
wxString errmsg(wxT(""));
errmsg << wxT("Error - no data available for body with NAIF ID ") << forNaifId << wxT(" on specified SPK kernels\n");
throw UtilityException(errmsg);
}
}
