#ifndef _vtk_LandmarkManager_h_
#define _vtk_LandmarkManager_h_

#include <vtkCommand.h>
#include <vtkPoints.h>
#include <vtkPolyData.h>
#include <vtkProperty.h>
#include <vtkCellArray.h>
#include <string>
#include <vector>

class vtkViewImage;
class vtkPolyData;


class VTK_EXPORT vtkLandmark : public vtkObject
{
 public:

  static vtkLandmark* New()
  { return new vtkLandmark; };
  
  vtkGetMacro (Scale, double);
  vtkSetMacro (Scale, double);
  
  void SetName (const char* name)
  { this->Name = name; }
  const char* GetName (void)
  { return this->Name.c_str(); }

  int* GetVoxelCoord()
  { return this->VoxelCoord; }
  void SetVoxelCoord (const int val[3])
  {
    this->VoxelCoord[0] = val[0];
    this->VoxelCoord[1] = val[1];
    this->VoxelCoord[2] = val[2];
  }
  
  double* GetRealCoord()
  { return this->RealCoord; } 
  void SetRealCoord (const double val[3]);
  
  vtkGetObjectMacro(PolyData, vtkPolyData);
  vtkGetObjectMacro(Property, vtkProperty);
  
 protected:

  void PositionHasChanged();
  
  vtkLandmark();
  ~vtkLandmark();
  
 private:

  vtkPolyData* PolyData;
  vtkProperty* Property;
  //BTX
  std::string Name;
  //ETX
  double Scale;

  int VoxelCoord[3];
  double       RealCoord[3];
  
};




class VTK_EXPORT vtkLandmarkCallback : public vtkCommand
{    
 public:
  
  static  vtkLandmarkCallback* New() 
    { return new vtkLandmarkCallback; }

  void SetLandmark (vtkLandmark* mark)
  { this->Landmark = mark; }
  vtkLandmark* GetLandmark (void) const
  { return this->Landmark; }
  
  void Execute(vtkObject *   caller, 
               unsigned long event, 
               void *        callData);

  void AddViewImage (vtkViewImage* view);
  bool HasViewImage(vtkViewImage* view);

 protected:
  vtkLandmarkCallback()
  {
    this->Landmark = NULL;
  };
  ~vtkLandmarkCallback(){};
  
 private:

  vtkLandmark* Landmark;
  std::vector<vtkViewImage*> ViewList;
  
  
};


class VTK_EXPORT vtkLandmarkManager : public vtkObject
{
 public:

  static vtkLandmarkManager* New();
  vtkTypeRevisionMacro(vtkLandmarkManager, vtkObject);

  /** Reset the fiber manager to its first input. */
  void Reset (void);
  
  /** Set the render window interactor */
  void AddViewImage (vtkViewImage* view);
  unsigned int AddLandmark(void);
  void RemoveLandmark (const char* name);
  void RemoveAllLandmarks(void);
  void SelectLandmark (const char* name);
  void SelectLandmark (vtkLandmark* landmark);

  void ShowAll(void);
  void HideAll(void);
  void InteractionOn(void);
  void InteractionOff(void);
  bool HasViewImage(vtkViewImage* view);

  vtkGetObjectMacro (CurrentLandmark, vtkLandmark);

  vtkLandmark* GetLandmark (unsigned int id) const
  {
    if (id >= this->LandmarkList.size())
      return NULL;
    return this->LandmarkList[id];
  }
  vtkLandmark* GetLandmark (const char* name) const
  { return this->FindLandmark (name); }
  unsigned int GetNumberOfLandmarks (void) const
  { return this->LandmarkList.size(); }
  
  

  
  
  
 protected:
  vtkLandmarkManager();
  ~vtkLandmarkManager();

  vtkLandmark* FindLandmark(const char* name) const;
  void RemoveLandmark(vtkLandmark* landmark);
  
 private:

  //BTX
  std::vector<vtkViewImage*> ViewList;
  std::vector<vtkLandmark*> LandmarkList;
  //ETX

  vtkLandmark* CurrentLandmark;
  vtkLandmarkCallback* Callback;
  vtkProperty* Property;
  vtkProperty* SelectedProperty;
  
  
  
};



#endif