albaGizmoScale.h

Go to the documentation of this file.

/*=========================================================================
 
 Program: ALBA (Agile Library for Biomedical Applications)
 Module: albaGizmoScale
 Authors: Stefano Perticoni
 
 Copyright (c) BIC
 All rights reserved. See Copyright.txt or
 
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
 
#ifndef __albaGizmoScale_H__
#define __albaGizmoScale_H__
 
//----------------------------------------------------------------------------
// Include:
//----------------------------------------------------------------------------
#include "albaEvent.h"
#include "albaObserver.h"
#include "albaGizmoInterface.h"
#include "albaGUIGizmoScale.h"
 
//----------------------------------------------------------------------------
// forward references :
//----------------------------------------------------------------------------
class albaGizmoScaleAxis;
class albaGizmoScaleIsotropic;
class albaMatrix;
class albaVME;
class albaGUI;
 
class ALBA_EXPORT albaGizmoScale: public albaGizmoInterface 
{
public:
  albaGizmoScale(albaVME *input, albaObserver* listener = NULL , bool buildGUI = true);
  virtual ~albaGizmoScale(); 
 
  void SetInput(albaVME *vme); 
 
  void SetRenderWindowHeightPercentage(double percentage);
 
  void SetAutoscale(bool autoscale);
 
  void SetAlwaysVisible(bool alwaysVisible);
 
  //----------------------------------------------------------------------------
  // events handling 
  //----------------------------------------------------------------------------
 
  void OnEvent(albaEventBase *alba_event);
 
  //----------------------------------------------------------------------------
  // show 
  //----------------------------------------------------------------------------
  
  void Show(bool show);  
   void Show(bool showX, bool showY, bool showZ, bool showIso);
 
  void SetAbsPose(albaMatrix *absPose, albaTimeStamp ts = -1);
 
  albaMatrix *GetAbsPose();
  
  //----------------------------------------------------------------------------
  // RefSys
  //----------------------------------------------------------------------------
 
  void SetRefSys(albaVME *refSys);
  albaVME* GetRefSys();
 
  //----------------------------------------------------------------------------
  // Gizmo Gui
  //----------------------------------------------------------------------------
  albaGUI *GetGui() {return (m_GuiGizmoScale->GetGui());};
 
   bool GetApplyScaleToVME() const { return m_ApplyScaleToVME; }
   void SetApplyScaleToVME(bool val) { m_ApplyScaleToVME = val; }
 
protected:
 
  albaGUIGizmoScale *m_GuiGizmoScale;
 
  void OnEventGizmoGui(albaEventBase *alba_event);
 
  void OnEventGizmoComponents(albaEventBase *alba_event);
 
  enum AXIS {X = 0, Y, Z};
  enum ACTIVE_COMPONENT {NONE = -1, X_AXIS = 0, Y_AXIS, Z_AXIS, ISOTROPIC};
 
  void Highlight(int component); 
  
  albaGizmoScaleAxis *m_GSAxis[3];
 
  albaGizmoScaleIsotropic *m_GSIsotropic;
 
  int m_ActiveGizmoComponent;
 
  void SendTransformMatrixFromGui(albaEventBase *alba_event);
 
private:
  
  bool m_BuildGUI;
 
   bool m_ApplyScaleToVME;
 
   double m_CurrentDist;
   double m_ScaleDiff;
 
  albaMatrix *m_InitialGizmoPose;
  
  albaMatrix *m_VmeMatrixRelativeToRefSysVME;
 
  albaMatrix *m_RefSysVMEAbsMatrixAtMouseDown;
 
  double GetScalingValue();
 
  
  void BuildVector(double *p1, double *p2, double *vec) const
  {
    if (vec)
    {
        vec[0] = p2[0] - p1[0];
        vec[1] = p2[1] - p1[1];
        vec[2] = p2[2] - p1[2];
    }
  }
 
  friend class albaGizmoScaleTest;
};
#endif
 
/*
  //----------------------------------------------------------------------------
  // Build the scale matrix from gizmo translation during mouse_move
  //----------------------------------------------------------------------------
 
  
  ^           ________          
  |          |        |
  |----------|        |
  |          |        |------>X
  |----------|        |
  |          |________|
  O          
  
  |-------------------|
        gl0
 
  
  ^                      ________          
  |                     |        |
  |           ----------|        |
  |                     |        |------>X
  |           ----------|        |
  |                     |________|
  O          
  
  |------------------------------|
        gl1
 
 
  S = gl1 / gl0
 
  S: scale to be postmultiplyed at mouse up
  
 
  //----------------------------------------------------------------------------
  // Build matrix to be sent to listener operation given the scale matrix S
  // to be applied relative to RS refsys to the vme
  //----------------------------------------------------------------------------
 
 
                      ^   
               ^      |
               |      |
               |       --->
  ^             --->  VME 
  |            RS
  |
   --->
  W
 
  1) Express VME matrix in RS refsys via albaTransform
      mflTr->SetInput(VME->GetAbsMatrix)
      mflTr->SetSourceRefSys(W)
      mflTr->SetTargetRefSys(RS)
 
      VME_RS = mflTr->GetTransform();
 
  2) Postmultiply scale matrix to VME_RS matrix
      transform->PostMultiply()
      transform->SetMatrix(VME_RS)
      transform->Concatenate(S)
        
  3) Express S * VME_RS in W refsys: this is new vme abs pose
      
      mflTr->SetInput(S_x_VME_RS)
      mflTr->SetSourceRefSys(RS)
      mflTr->SetTargetRS(W)
 
      NEW_VME_ABS_pose = mflTr->GetTransform();
  
  - At this point i could set the abs pose to the vme 
  
  4) Build matrix to be sent to listening op if a matrix to be postmultiplied to the vme abs pose has to be created
 
 
*/