MedicalHelper.h

// Open Inventor Medical Helper functions
 
//
// This class is part of the Open Inventor Medical utility library.
//
// The medical utility classes are provided as a prebuilt library named
// "fei_inventor_medical", that can be used directly in an Open Inventor
// application. The classes in the prebuilt library are documented and
// supported by Thermo Fisher Scientific. These classes are also provided as source code.
//
// Please see $OIVHOME/include/Medical/InventorMedical.h for the full text.
//
 
#ifndef _INVENTOR_MEDICAL_HELPER_H_
#define _INVENTOR_MEDICAL_HELPER_H_
 
#include <Medical/InventorMedical.h>
#include <Inventor/nodes/SoNode.h>
#include <Inventor/actions/SoSearchPathAction.h>
 
// SoDialogViz.h must be included before this file in order for
// DialogViz-related functions to be available.
// This is to avoid linking DialogViz with the Medical library
// so that the user code can decide which DialogViz library to use
// with their application.
#if defined(__DIALOGVIZLIB)
#include <DialogViz/dialog/SoTopLevelDialog.h>
#include <DialogViz/dialog/SoDialogCustom.h>
#endif
 
#include <Inventor/Axis.h>
 
#include <Inventor/STL/vector>
 
class SoCamera;
class SoDataRange;
class SoImageBackground;
class SoImageDataAdapter;
class SoMemoryDataAdapter;
class SoOrthoSlice;
class SoTransferFunction;
class SoVolumeData;
class SoVRDicomFileReader;
class SoMatrixTransform;
 
class INVENTORMEDICAL_API MedicalHelper {
public:
 
  enum Axis {
    AXIAL      = 2,
    TRANSVERSE = 2,
    CORONAL    = 1,
    SAGITTAL   = 0
  };
 
  static SbBool orientView( MedicalHelper::Axis axis, SoCamera* camera,
                            const SoVolumeData* volume = NULL, float slack = 1.01 );
 
  static SbBool dicomAdjustVolume( SoVolumeData* volume, SbBool useImagePosition = TRUE );
 
  static SbBool dicomAdjustVolume( SoVolumeData* volume, SoMatrixTransform* imgToPatient );
 
  static SbBool dicomAdjustDataRange( SoDataRange* rangeNode, const SoVolumeData* volume );
 
  static SbBool dicomCheckMonochrome1( SoTransferFunction* cmapNode, const SoVolumeData* volume,
                                       SbBool forceReverse = FALSE );
 
  static SbBool dicomGetImagePosition( const SoVolumeData* volume, SbVec3f& imagePos );
 
  static SbBool dicomGetWindowCenterWidth( const SoVolumeData* volume, SbVec2f& winCW );
 
  static SbVec2f dicomGetWindowCenterWidth( const SoDataRange* dataRange );
 
  static SbBool dicomSetWindowCenterWidth( SoDataRange* dataRange, const SbVec2f& winCW );
 
  static int dicomFindFilesbySeries( const SbString& firstFile, std::vector<SbString>& files );
 
  static int dicomFindFilesbySeries( const SbString& firstFile, SbStringList& files );
 
  static void dollyZoom( float value, SoCamera* camera );
 
  static SbBool setFilenameList( SoVRDicomFileReader& reader, const std::vector<SbString>& list );
 
  SbVec3f getVoxelSize( const SoVolumeData* volume ) const;
 
  SbVec3f getPhysicalSize( const SoVolumeData* volume ) const;
 
  SbVec3f getDicomOrigin( const SoVolumeData* volume ) const;
  
  static SoMemoryDataAdapter* getImageDataAdapter( const SoVolumeData* volume );
 
  static SoVolumeData* getVolumeData( const SoImageDataAdapter* adapter );
 
  static SoSeparator* buildSliceOrientationMarkers( const SoOrthoSlice* orthoSlice );
 
  static SoSeparator* buildSliceScaleBars( const SoCamera* camera );
 
  static SoSeparator* buildSliceAnnotation( const SoCamera* camera, 
                                            const SoOrthoSlice* sliceNode,
                                            const SbString* dicomFilename );
 
  static const SbVec2s& exampleWindowSize();
 
  static SoNode* exampleLogoNode();
 
  static SoNode* exampleDicomAnnotation( const SbString& filename );
 
  static Axis MedicalAxisFromViewAxis(openinventor::inventor::Axis::Type viewAxis, const SoVolumeData* volData);
 
  static Axis MedicalAxisFromViewAxis(openinventor::inventor::Axis::Type viewAxis, const SbMatrix& orientationMatrix);
 
  static openinventor::inventor::Axis::Type ViewAxisFromMedicalAxis(Axis medicalAxis, const SoVolumeData* volData);
 
  static openinventor::inventor::Axis::Type ViewAxisFromMedicalAxis(Axis medicalAxis, const SbMatrix& orientationMatrix);
 
  //------------------------------------------------------------------------------
  template <typename NodeType>
  static NodeType*
    find(SoNode* root, const SbString& nodeName = SbString(), const bool okIfNotFound = false)
  {
    if (root == NULL)
      return NULL;
 
    SoSearchAction* spa = NULL;
    if (!nodeName.isEmpty())
    {
      spa = new SoSearchPathAction;
      ((SoSearchPathAction*)spa)->setSearchString(nodeName.getString());
    }
    else
    {
      spa = new SoSearchAction;
    }
    spa->setSearchingAll(TRUE);
    spa->setType(NodeType::getClassTypeId());
 
    // Make sure the action doesn't destroy this node...
    // Do not unref until _after_ the action is destroyed!
    // Apply() will ref and unref, but root will also be ref'd by the resulting SoPath.
    root->ref();
    spa->apply(root);
 
    if (spa->getPath() == NULL)
    {
      delete spa;
      if (!okIfNotFound)
        std::cerr << "Cannot find \"" << nodeName << "\" of type \"" << NodeType::getClassTypeId().getName() << "\" in scene graph." << std::endl;
      return NULL;
    }
 
    NodeType* node = dynamic_cast<NodeType*>(spa->getPath()->getTail());
    if (node == NULL)
    {
      delete spa;
      if (!okIfNotFound)
        std::cerr << "Cannot find \"" << nodeName << "\" of type \"" << NodeType::getClassTypeId().getName() << "\" in scene graph." << std::endl;
      return NULL;
    }
 
    delete spa;             // This will also destroy the SoPath, which will unref 'root'.
    root->unrefNoDelete();  // Finally, remove our safety ref from 'root'
    return node;
  }
 
  //------------------------------------------------------------------------------
  template <typename NodeType>
  static std::vector<NodeType*>findNodes(SoNode* scene)
  {
    SoSearchAction* sa = new SoSearchAction;
    sa->setType(NodeType::getClassTypeId());
    sa->setInterest(SoSearchAction::ALL);
 
    scene->ref(); // Make sure action does not destroy this node...
    sa->apply(scene);
    scene->unrefNoDelete();
 
    std::vector<NodeType*> ret;
 
    const SoPathList& path = sa->getPaths();
    if (path.getLength() == 0)
    {
      std::cerr << NodeType::getClassTypeId().getName().getString() << " not found" << std::endl;
      return ret;
    }
 
    for (int i = 0; i < path.getLength(); i++)
      ret.push_back(dynamic_cast<NodeType*>(path[i]->getTail()));
 
    delete sa;
 
    return ret;
  }
 
#if defined(__DIALOGVIZLIB)
  //------------------------------------------------------------------------------
  template <typename NodeType>
  static NodeType*
    find(SoTopLevelDialog* root, const SbString& auditorId = SbString(), bool exitIfNotFound = true)
  {
    if (root == NULL)
      return NULL;
 
    NodeType* node = dynamic_cast<NodeType*>(root->searchForAuditorId(auditorId));
    if (node == NULL)
    {
      std::cerr << "Cannot find " << auditorId << " of type " << NodeType::getClassTypeId().getName() << " in interface." << std::endl;
      if (exitIfNotFound)
        exit(1);
    }
 
    return node;
  }
#endif /* __DIALOGVIZLIB */
 
  //------------------------------------------------------------------------------
  static SbBox3f getBoundingBox(SoNode* node);
 
  //------------------------------------------------------------------------------
  static SoSeparator* createCube(const SbBox3f& bbox);
 
  //------------------------------------------------------------------------------
  static SoSeparator* createBoundingBox(const SbBox3f& bbox, SbColor* color = NULL);
 
  //------------------------------------------------------------------------------
  static SoSeparator* readFile(const char *filename);
 
#if defined(__DIALOGVIZLIB)
  //------------------------------------------------------------------------------
  template<typename WidgetType>
  static WidgetType
  buildInterface(WidgetType window, const char* filename, const char* viewerName, SoTopLevelDialog** topLevelDialog)
  {
    SoInput myInput;
    if (!myInput.openFile(filename))
      return NULL;
 
    SoGroup *myGroup = SoDB::readAll(&myInput);
    myInput.closeFile();
    if (!myGroup)
      return NULL;
 
    *topLevelDialog = (SoTopLevelDialog *)myGroup->getChild(0);
 
    SoDialogCustom *customNode = (SoDialogCustom *)(*topLevelDialog)->searchForAuditorId(SbString(viewerName));
 
    (*topLevelDialog)->buildDialog(window, customNode != NULL);
    (*topLevelDialog)->show();
 
    return customNode ? customNode->getWidget() : window;
  }
#endif /* __DIALOGVIZLIB */
};
 
#endif