/** * @brief Determines type of NAIF/ISIS kernel we're dealing with * * This method will open the file and look at the first 8 characters. Valid * NAIF binary and text kernels typically have its type defined in the first 8 * characters. The expected format of these characters is "DAF/CK". This * method retrieves this string, trims off formatting characters and spaces * and returns the string after the "/" character. This value is returned as * the kernel type. * * It also checks for ISIS DEMs and a special case of ISIS IAKs, which does * not follow the NAIF convention. ISIS IAKs don't typically contain the NAIF * format identifier but do contain the ".ti" file extention. * * UNKNOWN and DAF types are further checked by the filename. This is a last * resort to properly tag kernel types that are ambiguous. DAFs are common * for some SPKs. UNKNOWNs are common for many kernels that do not follow the * NAIF standard first 8 character identifier model. * * @param kfile Name of potential NAIF kernel to determine type for * * @return QString Value of the identifier found. If undetermined, * "UNKNOWN" is returned. */ QString Kernels::resolveType(const QString &kfile) const { FileName kernFile(kfile); QString kpath = kernFile.expanded(); ifstream ifile(kpath.toAscii().data(), ios::in | ios::binary); QString ktype("UNKNOWN"); if (ifile) { char ibuf[10]; ifile.read(ibuf, 8); ibuf[8] = '\0'; for (int i = 0 ; i < 8 ; i++) if (ibuf[i] == '\n') ibuf[i] = '\0'; // See if the file is a known NAIF type. Assume it has been // extracted from a NAIF compliant kernel QString istr = IString(ibuf).Trim(" \n\r\f\t\v\b").ToQt(); if (istr.contains("/")) { ktype = istr.split("/").last(); } // If type is not resolved, check file extensions and special ISIS types if ((ktype == "UNKNOWN") || (ktype == "DAF")) { ktype = resolveTypeByExt(kfile, ktype); } } return (ktype); }
virtual void dataEvent(const itype &data) final override { auto curKey = meta::slctTupleRef(data, Kslct{}); auto curVal = meta::slctTupleRef(data, Vslct{}); auto it = _index.find(curKey, _hash, _eq); if(TypeInfo::isRefRes) { if (it != std::end(_index)) { decltype(auto) x = meta::invokeReduce(_func, curKey, curVal, it->second); if (&x != &it->second) { it->second = x; } } else { it = _index.emplace_hint(it, ktype(curKey), _initVal); decltype(auto) x = meta::invokeReduce(_func, curKey, curVal, it->second); if (&x != &it->second) { it->second = x; } } } else { if (it != std::end(_index)) { it->second = meta::invokeReduce(_func, curKey, curVal, it->second); } else { it = _index.emplace_hint( it, ktype(curKey), meta::invokeReduce(_func, curKey, curVal, (_initVal) )); } } if (_ordered) { if (_first) { _first = false; _preIt = it; } else if (_preIt->first != curKey) { callKey<FO>(); _index.erase(_preIt); _preIt = it; } } }
/** * @brief Check kernel type by file extension and special ISIS kernels * * This method is a fallback attempt to determine the type of an expected NAIF * kernel. This method assumes the proper way (inspecting first 8 characters * of the kernel file) did not succeed in making this determination. * * There are some times that are expected to fail this test. ISIS DEMs are * cube files and will not be determined using the NAIF 8 character approach. * As such, all files that end in .cub are assumed to be DEMs and are tagged * as such. * * There are also some special ISIS IK addendum files that exist in the ISIS * system. These files are used to augment an instruments' IK kernel and * potentially override some of the original IK contents. This file type is * determined by checking for a ".ti" extension and then further checking the * base filename for the substring "Addendum". This is the only way to ensure * it is an ISIS IAK file. It must pass both tests or it is simply tagged as * an IK (due to the .ti extension). * * The remainder of the tests are strictly testing the file extension. Here is * how the associations are made to the files based upon their file * extensions: * * .cub = DEM - ISIS cubes are DEMs * .ti = IK - unless "Addendum" is in basename, then it is an IAK * .tf = FK - frames kernel * .tsc = SCLK - spacecraft clock kernel * .tsl = LSK - leap seconds kernel * .tpc = PCK - planetary ephemeris kernel * .bc = CK - C-kernel * .bsp = SPK - spacecraft position kernel * .bes = EK - event kernels * * If none of these file extensions or condition are found, then the value of * the parameter iktype is returned as the default type. * * @param kfile File to determine type for * @param iktype Default type to be used in none are determined from this * methiod * * @return QString Type of kernel found from file extensions */ QString Kernels::resolveTypeByExt(const QString &kfile, const QString &iktype) const { QString ktype(iktype); // Set default condition // Deciminate file parts FileName kf(kfile); string ext = IString(kf.extension()).DownCase(); // Check extensions for types if (ext == "cub") { ktype = "DEM"; } else if (ext == "ti") { // Assume its an instrument kernel but check for ISIS IAK file ktype = "IK"; string base = IString(kf.baseName()).DownCase(); string::size_type idx = base.find("addendum"); if (idx != string::npos) { // This is an ISIS IK addendum (IAK) ktype = "IAK"; } } else if (ext == "tsc") { ktype = "SCLK"; } else if (ext == "tf") { ktype = "FK"; } else if (ext == "tls") { ktype = "LSK"; } else if (ext == "tpc") { ktype = "PCK"; } else if (ext == "bc") { ktype = "CK"; } else if (ext == "bsp") { ktype = "SPK"; } else if (ext == "bes") { ktype = "EK"; } return (ktype); }
static PyObject* _arraytok(PyObject* self, PyObject* a) { K kobj = 0; if (!PyArray_Check(a)) { return PyErr_Format(PyExc_TypeError, "argument is not a numeric array"); } PyArrayObject* arr = (PyArrayObject*)a; if (!PyArray_ISCONTIGUOUS(arr)) { return PyErr_Format(PyExc_TypeError, "cannot handle non-contiguous arrays"); } int n = PyArray_SIZE(arr); int t = ktype(arr->descr->type_num); if (t > 0) { kobj = gtn(-t,n); memcpy(kobj->k, arr->data, PyArray_NBYTES(arr)); } else if (arr->descr->type_num == PyArray_OBJECT) { /* special handling for arrays of strings */ char** strings = malloc(n*sizeof(char*)); PyObject** objects = (PyObject**)arr->data; int i; for (i = 0; i < n; ++i) { char* str = PyString_AsString(objects[i]); if (str) { strings[i] = str; } else { free(strings); /* XXX should we raise our own exception here * * XXX or keep the one which came from "AsString"? */ return NULL; } } kobj = gtn(-4, n); for (i = 0; i < n; ++i) { KS(kobj)[i] = sp(strings[i]); } } return PyK_mk_K(kobj); }