NaifDskPlateModel.cpp

Go to the documentation of this file.

// Uncomment this definition and you get thread-safe methods.  Note this is not
// done in the header as it would change the header footprint and require a
// complete system recompile.  Done here only invokes locking with defined mutex
// classes in the header.  To make this happen on demand, uncomment the define,
// recompile, reinsert in libisisx.y.z.a and recreate the shared library.
// 
// #define MAKE_THREAD_SAFE 1

#include "NaifDskPlateModel.h"

#include <iostream>
#include <iomanip>
#include <numeric>
#include <sstream>

#if defined(MAKE_THREAD_SAFE)
#include <QMutexLocker>
#endif
#include <QScopedPointer>

#include <dsk_proto.h>
#include <SpiceDLA.h>
#include <SpiceDSK.h>
#include <SpiceUsr.h>
#include <SpiceZfc.h>
#include <SpiceZim.h>

#include "FileName.h"
#include "IException.h"
#include "Intercept.h"
#include "IString.h"
#include "Latitude.h"
#include "Longitude.h"
#include "NaifDskApi.h"
#include "NaifStatus.h"
#include "SurfacePoint.h"
#include "TriangularPlate.h"

using namespace std;

namespace Isis {

  NaifDskPlateModel::NaifDskPlateModel() : m_dsk(0) { }
  


  NaifDskPlateModel::NaifDskPlateModel(const QString &dskfile) : m_dsk(0) {
    m_dsk = SharedNaifDskDescriptor(openDSK(dskfile));
    if ( !isValid() ) {
      QString mess = "Could not open DSK file " + dskfile;
      throw IException(IException::User, mess, _FILEINFO_);
    }
  }
  


  NaifDskPlateModel::~NaifDskPlateModel() { }



  bool NaifDskPlateModel::isValid() const {
    return ( !m_dsk.isNull() );
  }
  


  QString NaifDskPlateModel::filename() const {
    if ( isValid() ) { return (m_dsk->m_dskfile); }
    return ( QString() );
  }
  


  int NaifDskPlateModel::size() const {
    return ( numberPlates() );
  }
  


  int NaifDskPlateModel::numberPlates() const {
    if ( !isValid() )  return (0);
    return ( m_dsk->m_plates );
  }
  


  int NaifDskPlateModel::numberVertices() const {
    if ( !isValid() )  return (0);
    return ( m_dsk->m_vertices );
  }
  


  SurfacePoint *NaifDskPlateModel::point(const Latitude &lat, 
                                         const Longitude &lon) const {
  
    // Sanity check on input point
    verify ( lat.isValid(), "Latitude parameter invalid in NaifDskPlateMode::point()" );
    verify ( lon.isValid(), "Longitude parameter invalid in NaifDskPlateMode::point()" );
  
    // Ensure a DSK file is opened or exception is thrown
    verify( isValid(), "NAIF DSK file not opened/valid!");
  
    // Get the lon/lat point in radians
    SpiceDouble lonlat[2];
    lonlat[0] = lon.positiveEast(Angle::Radians);
    lonlat[1] = lat.planetocentric(Angle::Radians);
    SpiceInt npoints(1);
    NaifVertex spoint(3, 0.0);
    SpiceInt plateId(-1);
  
  #if defined(MAKE_THREAD_SAFE)
    QMutexLocker lock(&m_dsk->m_mutex);  // Thread locking for NAIF I/O
  #endif
  
    llgrid_pl02( m_dsk->m_handle, &m_dsk->m_dladsc, npoints, 
                 (ConstSpiceDouble (*)[2]) lonlat, 
                 (SpiceDouble (*)[3]) &spoint[0], &plateId);
    NaifStatus::CheckErrors();
  
  #if 0
    if ( !isPlateIdValid(plateId) ) {
      QString mess = "Plateid = " + QString::number(plateId) + " is invalid";
      throw IException(IException::Programmer, mess, _FILEINFO_);
    }
  #endif
  
    // Other error checks???
    return  ( makePoint(spoint) );
  }
  


  Intercept *NaifDskPlateModel::intercept(const NaifVertex &vertex,
                                          const NaifVector &raydir) const {
    // Get the plate
    NaifVertex xpoint;
    SpiceInt plateid = plateIdOfIntercept(vertex, raydir, xpoint);
    if ( !isPlateIdValid(plateid) ) return (0);
  
    NaifTriangle triangle = plate(plateid); 
  
    // Return the intercept
    return (new Intercept(vertex, raydir, makePoint(xpoint), 
                          new TriangularPlate(triangle, plateid)));
  }
  


  bool NaifDskPlateModel::isPlateIdValid(const SpiceInt plateid) const {
    if ( !isValid() ) return (false);
    return ( (plateid >= 1) && (plateid <= m_dsk->m_plates) );
  }
  


  SpiceInt NaifDskPlateModel::plateIdOfIntercept(const NaifVertex &vertex, 
                                                    const NaifVector &raydir,
                                                    NaifVertex &xpoint) const {
  
    // Sanity check on input parameters
    try {
      verify( validate(vertex), "Invalid/bad dimensions on intercept source point");
      verify( validate(raydir), "Invalid/bad dimensions on ray direction vector");
    }
    catch ( IException &ie ) {
      throw IException(ie, IException::Programmer, 
                       "Invalid point source data to determine intercept", 
                       _FILEINFO_);
    }
  
    // Ensure a DSK file is opened or exception is thrown
    verify( isValid(), "NAIF DSK file not opened/valid!");
  
    // Get the lon/lat point in radians
    SpiceInt plateid;
    NaifVertex xpt(3, 0.0);
    SpiceBoolean found;
  
  #if defined(MAKE_THREAD_SAFE)
    QMutexLocker lock(&m_dsk->m_mutex);  // Thread locking for NAIF I/O
  #endif
    // Find the plate of intersection and intercept point
    NaifStatus::CheckErrors();
    dskx02_c( m_dsk->m_handle, &m_dsk->m_dladsc, &vertex[0], &raydir[0],
              &plateid, &xpt[0], &found);
    // Check status
    NaifStatus::CheckErrors();
    if ( !found ) return (0);
  
    // Return succesful results
    xpoint = xpt;
    return ( plateid );
  }
  

  
  NaifTriangle NaifDskPlateModel::plate(SpiceInt plateid) const {
  
    // Ensure a DSK file is opened or exception is thrown
    verify( isValid(), "NAIF DSK file not opened/valid!");
  
    // Sanity check on plateid
    if ( !isPlateIdValid(plateid) ) {
      QString mess = "Plateid = " + QString::number(plateid) + " is invalid";
      throw IException(IException::Programmer, mess, _FILEINFO_);
    }
  
   // Get the plate
    SpiceInt nplates;
    SpiceInt iplate[3];
  
  #if defined(MAKE_THREAD_SAFE)
    QMutexLocker lock(&m_dsk->m_mutex);  // Thread locking for NAIF I/O
  #endif
  
    NaifStatus::CheckErrors();
    dskp02_c(m_dsk->m_handle, &m_dsk->m_dladsc, plateid, 1, &nplates, 
             ( SpiceInt(*)[3] )(iplate));
    NaifStatus::CheckErrors();
  
    // Get the verticies of the plates
    NaifTriangle plate(3, 3);
    SpiceInt n;
    for (int i = 0 ; i < 3 ; i++) {
    dskv02_c(m_dsk->m_handle, &m_dsk->m_dladsc, iplate[i], 1, &n, 
             ( SpiceDouble(*)[3] )(plate[i]));
    }
    NaifStatus::CheckErrors();
  
    return (plate);
  }
  


  NaifDskPlateModel::NaifDskDescriptor *NaifDskPlateModel::openDSK(const QString &dskfile) {
  
    // Sanity check
    FileName dskFile(dskfile);
    if ( !dskFile.fileExists() ) {
      QString mess = "NAIF DSK file [" + dskfile + "] does not exist.";
      throw IException(IException::User, mess, _FILEINFO_);
    }
  
    // Open the NAIF Digital Shape Kernel (DSK)
    QScopedPointer<NaifDskDescriptor> dsk(new NaifDskDescriptor());
    dsk->m_dskfile = dskfile;
    NaifStatus::CheckErrors();
    dasopr_c( dskFile.expanded().toAscii().data(), &dsk->m_handle );
    NaifStatus::CheckErrors();
  
    // Search to the first DLA segment
    SpiceBoolean found;
    dlabfs_c( dsk->m_handle, &dsk->m_dladsc, &found );
    NaifStatus::CheckErrors();
    if ( !found ) {
      QString mess = "No segments found in DSK file " + dskfile ; 
      throw IException(IException::User, mess, _FILEINFO_);
    }

    NaifStatus::CheckErrors();
    dskgd_c( dsk->m_handle, &dsk->m_dladsc, &dsk->m_dskdsc );
  
    // Get size/counts
    dskz02_c( dsk->m_handle, &dsk->m_dladsc, &dsk->m_vertices, 
                     &dsk->m_plates );
    NaifStatus::CheckErrors();
  
    // return pointer
    return ( dsk.take() );
  }
  


  bool NaifDskPlateModel::verify(const bool &test, const QString &errmsg,
                                 const NaifDskPlateModel::ErrAction &action) 
                                 const {
    if ( ( Throw == action ) && ( !test ) ) {
      throw IException(IException::Programmer, errmsg, _FILEINFO_);
    }
  
    // Looks good
    return ( test );
  }
  


  SurfacePoint *NaifDskPlateModel::makePoint(const NaifVertex &v) const {
    verify( validate(v), "Vertex/point invalid - not a 3 vector" );
    return (new SurfacePoint(Displacement(v[0], Displacement::Kilometers),
                             Displacement(v[1], Displacement::Kilometers),
                             Displacement(v[2], Displacement::Kilometers)));
  
  }


  NaifDskPlateModel::NaifDskDescriptor::NaifDskDescriptor() : m_dskfile(), m_handle(-1), 
                                                              m_dladsc(), m_dskdsc(), m_plates(0), 
                                                              m_vertices(0), m_mutex() { 
  }


  NaifDskPlateModel::NaifDskDescriptor::~NaifDskDescriptor() {
    if ( -1 != m_handle ) { 
      NaifStatus::CheckErrors();
      dascls_c ( m_handle ); 
      NaifStatus::CheckErrors();
    }
  }
  

}  // namespace Isis