Medical/helpers/MedicalHelper.h

Go to the documentation of this file.

// 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 FEI. 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>
#if !defined(OIV_HEADLESS)
#include <DialogViz/dialog/SoTopLevelDialog.h>
#include <DialogViz/dialog/SoDialogCustom.h>
#else
#include <Inventor/nodes/SoMatrixTransform.h>
#include <Inventor/actions/SoGetBoundingBoxAction.h>
#endif
#include <Inventor/actions/SoSearchPathAction.h>

#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 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(OIV_HEADLESS)
  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

  //------------------------------------------------------------------------------
  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(OIV_HEADLESS)
  // Set as template to avoid linking DialogViz with the Medical library
  // so that the user code can decide which DialogViz library to use
  // with their application.
  template<typename TopLevelDialog>
  static Widget
  buildInterface( Widget window, const char* filename, const char* viewerName, TopLevelDialog** topLevelDialog)
  {
    SoInput myInput;
    if (!myInput.openFile(filename))
      return NULL;

    SoGroup *myGroup = SoDB::readAll(&myInput);
    myInput.closeFile();
    if (!myGroup)
      return NULL;

    *topLevelDialog = (TopLevelDialog *)myGroup->getChild(0);

    SoDialogCustom *customNode = (SoDialogCustom *)(*topLevelDialog)->searchForAuditorId(SbString(viewerName));

    (*topLevelDialog)->buildDialog(window, customNode != NULL);
    (*topLevelDialog)->show();

    return customNode ? customNode->getWidget() : window;
  }
#endif
};

#endif

---

Open Inventor Toolkit reference manual, generated on 15 Mar 2023
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/