ENH: Adding SelectAreaHandler

Code/Visualization/otbImageLayerRenderingModel.h

@@ -64,6 +64,7 @@ public:
   typedef typename Superclass::LayerType       LayerType;
   typedef typename LayerType::RegionType       RegionType;
   typedef typename RegionType::IndexType       IndexType;
+  typedef typename RegionType::SizeType        SizeType;
   
   /** Layer list typedef */
   typedef typename Superclass::LayerListType    LayerListType;
@@ -116,6 +117,10 @@ public:
    * region */
   void SetExtractRegionCenter(const IndexType & index);
   
+  /** Change the extract region by giving the 2 points of the
+   * region */
+  void SetExtractRegionByIndex(const IndexType & startIndex, const IndexType & stopIndex );
+
   /** Get the sumbsampling rate */
   unsigned int GetSubsamplingRate();
 
@@ -161,6 +166,7 @@ private:
   bool                   m_HasScaledExtract;
   RegionType             m_ScaledExtractRegion;
 
+
   /** Wether the model is currently updating or not */
   bool                   m_Updating;
 

Code/Visualization/otbImageLayerRenderingModel.txx

@@ -264,6 +264,35 @@ ImageLayerRenderingModel<TOutputImage>
   m_ExtractRegion.SetIndex(newIndex);
 }
 
+
+template <class TOutputImage>
+void
+ImageLayerRenderingModel<TOutputImage>
+::SetExtractRegionByIndex( const IndexType & startIndex, const IndexType & stopIndex )
+{
+ RegionType lImageRegion;
+        lImageRegion = this->GetLayer(0)->GetExtent();
+
+        SizeType lSize;
+        lSize[0] = vcl_abs(stopIndex[0]-startIndex[0]);
+        lSize[1] = vcl_abs(stopIndex[1]-startIndex[1]);
+
+        IndexType lIndex;
+        lIndex[0] = std::min(startIndex[0],stopIndex[0]);
+        lIndex[1] = std::min(startIndex[1],stopIndex[1]);
+
+        RegionType lRegion;
+        lRegion.SetIndex(lIndex);
+        lRegion.SetSize(lSize);
+
+std::cout<<"OH OUIIIIIIIIi"<<std::endl;
+
+  if(lRegion.Crop(lImageRegion))
+{
+  m_ExtractRegion = lRegion;
+}
+}
+
 template <class TOutputImage>
 unsigned int
 ImageLayerRenderingModel<TOutputImage>

Code/Visualization/otbImageView.h

@@ -93,6 +93,8 @@ public:
   itkGetObjectMacro(FullWidget,ImageWidgetType);
   itkGetObjectMacro(ZoomWidget,ImageWidgetType);
 
+  itkGetObjectMacro(Model,ModelType);
+
   /** Clear the widgets buffers  */
   void ClearBuffer();
 

Code/Visualization/otbImageView.txx

@@ -22,8 +22,8 @@ PURPOSE.  See the above copyright notices for more information.
 
 namespace otb
 {
-template < class TInputImage >
-ImageView<TInputImage>
+template < class TViewerModel >
+ImageView<TViewerModel>
 ::ImageView() : m_ScrollWidget(), m_FullWidget(), m_ZoomWidget(),
                 m_Model(), m_Controller(), m_ExtractRegionGlComponent(), m_ScaledExtractRegionGlComponent()
 {
@@ -46,16 +46,16 @@ ImageView<TInputImage>
   m_ZoomWidget->SetIdentifier("Zoom");
 }
 
-template < class TInputImage >
-ImageView<TInputImage>
+template < class TViewerModel >
+ImageView<TViewerModel>
 ::~ImageView()
 {
   
 }
 
-template < class TInputImage >
+template < class TViewerModel >
 void
-ImageView<TInputImage>
+ImageView<TViewerModel>
 ::SetModel(ModelType * model)
 {
   // Unregister from previous model if nay
@@ -69,9 +69,9 @@ ImageView<TInputImage>
   m_Model->RegisterListener(this);
 }
 
-template < class TInputImage >
+template < class TViewerModel >
 void
-ImageView<TInputImage>
+ImageView<TViewerModel>
 ::SetController(ControllerType * controller)
 {
   m_Controller = controller;
@@ -80,9 +80,9 @@ ImageView<TInputImage>
   m_ZoomWidget->SetController(m_Controller);
 }
 
-template < class TInputImage>
+template < class TViewerModel>
 void
-ImageView<TInputImage>
+ImageView<TViewerModel>
 ::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   // Call the superclass implementation
@@ -90,17 +90,17 @@ ImageView<TInputImage>
 }
 
 
-template < class TInputImage >
+template < class TViewerModel >
 void
-ImageView<TInputImage>
+ImageView<TViewerModel>
 ::ImageLayerRenderingModelNotify()
 {
   this->Update();
 }
 
-template < class TInputImage >
+template < class TViewerModel >
 void
-ImageView<TInputImage>
+ImageView<TViewerModel>
 ::Update()
 {
   this->UpdateScrollWidget();
@@ -108,15 +108,15 @@ ImageView<TInputImage>
   this->UpdateZoomWidget();
 }
 
-template < class TInputImage >
+template < class TViewerModel >
 void
-ImageView<TInputImage>
+ImageView<TViewerModel>
 ::UpdateScrollWidget()
 {
   // If the model has a quicklook
   if(m_Model->GetHasQuicklook())
     {
-    otbMsgDevMacro(<<"ImageView::UpdateScrollWidget(): redrawing scroll widget");
+      otbMsgDevMacro(<<"ImageView::UpdateScrollWidget(): redrawing scroll widget");
 
     // Read the buffer
     const RegionType qlRegion =  m_Model->GetRasterizedQuicklook()
@@ -153,9 +153,9 @@ ImageView<TInputImage>
 }
 
 
-template < class TInputImage >
+template < class TViewerModel >
 void
-ImageView<TInputImage>
+ImageView<TViewerModel>
 ::UpdateFullWidget()
 {
   if(m_Model->GetHasExtract())
@@ -185,9 +185,9 @@ ImageView<TInputImage>
     }
  }
 
-template < class TInputImage >
+template < class TViewerModel >
 void
-ImageView<TInputImage>
+ImageView<TViewerModel>
 ::UpdateZoomWidget()
 {
   if(m_Model->GetHasScaledExtract())

Code/Visualization/otbSelectAreaActionHandler.h

+/*=========================================================================
+
+  Program:   ORFEO Toolbox
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+
+  Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
+  See OTBCopyright.txt for details.
+
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+#ifndef __otbSelectAreaActionHandler_h
+#define __otbSelectAreaActionHandler_h
+
+#include "otbImageWidgetActionHandler.h"
+
+
+namespace otb
+{
+/** \class SelectAreaActionHandler
+*   \brief Implements basic Scroll, Full and Zoom  widgets resizing.
+* 
+*   \sa ImageWidgetController
+*   \sa ImageWidgetActionHandler
+*/
+
+template <class TModel, class TView> 
+class SelectAreaActionHandler
+  : public ImageWidgetActionHandler
+{
+public:
+  /** Standard class typedefs */
+  typedef SelectAreaActionHandler Self;
+  typedef ImageWidgetActionHandler               Superclass;
+  typedef itk::SmartPointer<Self>                Pointer;
+  typedef itk::SmartPointer<const Self>          ConstPointer;
+  
+  /** Method for creation through the object factory */
+  itkNewMacro(Self);
+  
+  /** Runtime information */
+  itkTypeMacro(SelectAreaActionHandler,ImageWidgetActionHandler);
+
+  /** Model typedefs */
+  typedef TModel                         ModelType;
+  typedef typename ModelType::Pointer    ModelPointerType;
+  typedef typename ModelType::RegionType RegionType;
+
+  /** View typedefs */
+  typedef TView                          ViewType;
+  typedef typename ViewType::Pointer     ViewPointerType;
+  typedef typename ViewType::IndexType   IndexType;
+
+
+
+  /** Handle widget event
+   * \param widgetId The id of the moved widget
+   * \param event The event
+   * \return The handling return code
+   */
+  virtual bool HandleWidgetEvent(std::string widgetId, int event)
+  {
+    if( m_View.IsNotNull() && m_Model.IsNotNull() )
+      {
+    if(widgetId == m_View->GetScrollWidget()->GetIdentifier() )
+      {
+        //otbMsgDevMacro(<<"SelectArea PixelClickedActionHandler::HandleWidgetEvent(): handling ("<<widgetId<<", "<<event<<")");
+        
+        // Get the clicked index
+        //typename ImageViewType::ImageWidgetType::PointType screenPoint, imagePoint;
+        typename ViewType::ImageWidgetType::PointType screenPoint, imagePoint;/*, lScreenSizePoint, lImageSizePoint;*/
+        screenPoint = m_View->GetScrollWidget()->GetMousePosition();
+        
+        // Transform to image point
+        imagePoint = m_View->GetScrollWidget()->GetScreenToImageTransform()->TransformPoint(screenPoint);
+
+        // Transform to index
+        IndexType lIndex;
+        lIndex[0]=static_cast<long int>(imagePoint[0]);
+        lIndex[1]=static_cast<long int>(imagePoint[1]);
+
+       
+        switch (event)
+        {
+          case FL_PUSH:
+          {
+              m_FirstPush = false;
+              m_StartIndex = lIndex;
+            
+            break;
+          }
+          case FL_RELEASE:
+          {
+            m_FirstPush = true;
+            m_StopIndex = lIndex;
+            m_Model->SetExtractRegionByIndex(m_StartIndex,m_StopIndex);
+           m_Model->Update();
+            //m_Model->UpdateSecondScroll();
+            break;
+          }
+          case FL_DRAG:
+          {
+            m_StopIndex = lIndex;
+            m_Model->SetExtractRegionByIndex(m_StartIndex,m_StopIndex);
+            m_Model->Update();
+            break;
+          }
+          default:
+          {
+          }
+        }
+        return true;
+      }
+      }
+    return false;
+ 
+}
+  
+  /** Set/Get the pointer to the view */
+  itkSetObjectMacro(View,ViewType);
+  itkGetObjectMacro(View,ViewType);
+
+  /** Set/Get the pointer to the model */
+  itkSetObjectMacro(Model,ModelType);
+  itkGetObjectMacro(Model,ModelType);
+
+
+protected:
+  /** Constructor */
+  SelectAreaActionHandler() : m_View(), m_Model()
+  {
+    m_FirstPush = true;
+    m_StartIndex.Fill(0);
+    m_StopIndex.Fill(0);
+  }
+
+  /** Destructor */
+  virtual ~SelectAreaActionHandler(){}
+  /** Printself method */
+  void PrintSelf(std::ostream& os, itk::Indent indent) const
+  {
+    Superclass::PrintSelf(os,indent);
+  }
+ 
+private:
+  SelectAreaActionHandler(const Self&);    // purposely not implemented
+  void operator=(const Self&); // purposely not implemented
+
+  // Pointer to the view
+  ViewPointerType m_View;
+
+  // Pointer to the model
+  ModelPointerType m_Model;
+
+  bool m_FirstPush;
+
+  // Area selection indexes
+  IndexType m_StartIndex;
+  IndexType m_StopIndex;
+
+}; // end class 
+} // end namespace otb
+#endif
+
+

Testing/Code/Visualization/CMakeLists.txt

@@ -214,6 +214,11 @@ otbImageViewerEndToEndSingleLayer
 ${INPUTDATA}/couleurs.tif
 200 500 200 0
 )
+ADD_TEST(vrTvImageViewerEndToEndSingleLayerWithSelectAreaHandler ${VISUREFAC_TESTS1}
+otbImageViewerEndToEndSingleLayerWithSelectAreaHandler
+${INPUTDATA}/couleurs.tif
+200 500 200 0
+)
 
 ADD_TEST(vrTvImageViewerEndToEndTwoLayers ${VISUREFAC_TESTS1}
 otbImageViewerEndToEndTwoLayers
@@ -323,6 +328,7 @@ otbMultiplyBlendingFunctionNew.cxx
 otbRenderingImageFilterVectorWithExpNegativeTransfer.cxx
 otbImageViewNew.cxx
 otbImageViewerEndToEndSingleLayer.cxx
+otbImageViewerEndToEndSingleLayerWithSelectAreaHandler.cxx
 otbImageViewerEndToEndTwoLayers.cxx
 otbPixelDescriptionModelNew.cxx
 otbPixelDescriptionModelSingleLayer.cxx

Testing/Code/Visualization/otbImageViewerEndToEndSingleLayerWithSelectAreaHandler.cxx

+/*=========================================================================
+
+Program:   ORFEO Toolbox
+Language:  C++
+Date:      $Date$
+Version:   $Revision$
+
+
+Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
+See OTBCopyright.txt for details.
+
+
+This software is distributed WITHOUT ANY WARRANTY; without even
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+#include "otbImageLayerRenderingModel.h"
+#include "otbVectorImage.h"
+#include "itkRGBPixel.h"
+#include "otbImageFileReader.h"
+#include "otbImageFileWriter.h"
+#include "otbImageLayerGenerator.h"
+#include "otbImageLayer.h"
+#include "otbImageView.h"
+#include <FL/Fl.H>
+#include "otbImageWidgetController.h"
+#include "otbWidgetResizingActionHandler.h"
+#include "otbChangeScaledExtractRegionActionHandler.h"
+#include "otbSelectAreaActionHandler.h"
+//#include "otbChangeExtractRegionActionHandler.h"
+#include "otbChangeScaleActionHandler.h"
+#include "otbPixelDescriptionModel.h"
+#include "otbPixelDescriptionActionHandler.h"
+#include "otbPixelDescriptionView.h"
+
+int otbImageViewerEndToEndSingleLayerWithSelectAreaHandler( int argc, char * argv[] )
+{
+  // params
+  const char * infname = argv[1];
+  const unsigned int scrollSize = atoi(argv[2]);
+  const unsigned int fullSize = atoi(argv[3]);
+  const unsigned int zoomSize = atoi(argv[4]);
+  const double       run      = atoi(argv[5]);
+
+  // typedefs 
+  typedef double                                     PixelType;
+  typedef itk::RGBPixel<unsigned char>               RGBPixelType;
+  typedef otb::Image<RGBPixelType,2>                 OutputImageType;
+  typedef otb::VectorImage<PixelType,2>              ImageType;
+  typedef otb::ImageLayer<ImageType>                 LayerType;
+  typedef otb::ImageFileReader<ImageType>            ReaderType;
+  typedef otb::ImageLayerGenerator<LayerType>        LayerGeneratorType;
+  typedef otb::ImageLayerRenderingModel<OutputImageType>     ModelType;
+  typedef otb::ImageView<ModelType>                  ViewType;
+  typedef otb::ImageWidgetController                 ControllerType;
+  typedef otb::WidgetResizingActionHandler
+    <ModelType,ViewType>                             ResizingHandlerType;
+  typedef otb::ChangeScaledExtractRegionActionHandler
+    <ModelType,ViewType>                             ChangeScaledRegionHandlerType;
+//   typedef otb::ChangeExtractRegionActionHandler
+//     <ModelType,ViewType>                             ChangeRegionHandlerType;
+  typedef otb::ChangeScaleActionHandler
+    <ModelType,ViewType>                             ChangeScaleHandlerType;
+  typedef otb::PixelDescriptionModel<OutputImageType> PixelDescriptionModelType;
+  typedef otb::PixelDescriptionActionHandler
+    < PixelDescriptionModelType, ViewType>            PixelDescriptionActionHandlerType;
+  typedef otb::PixelDescriptionView
+    < PixelDescriptionModelType >                     PixelDescriptionViewType;
+  typedef otb::SelectAreaActionHandler
+    <ModelType,ViewType>                             ChangeRegionHandlerType;
+ 
+  // Instantiation
+  ModelType::Pointer model = ModelType::New();
+  PixelDescriptionModelType::Pointer pixelModel = PixelDescriptionModelType::New();
+  pixelModel->SetLayers(model->GetLayers());
+
+  // Reading input image
+  ReaderType::Pointer reader = ReaderType::New();
+  reader->SetFileName(infname);
+  
+  // Generate the layer
+  LayerGeneratorType::Pointer generator = LayerGeneratorType::New();
+  generator->SetImage(reader->GetOutput());
+  generator->GenerateLayer();
+  
+   // Add the layer to the model
+  model->AddLayer(generator->GetLayer());
+  
+
+  // Build a view
+  ViewType::Pointer view = ViewType::New();
+  view->SetModel(model);
+
+  // Build a controller
+  ControllerType::Pointer controller = ControllerType::New();
+  view->SetController(controller);
+
+  // Add the resizing handler
+  ResizingHandlerType::Pointer resizingHandler = ResizingHandlerType::New();
+  resizingHandler->SetModel(model);
+  resizingHandler->SetView(view);
+  controller->AddActionHandler(resizingHandler);
+
+  // Add the change scaled region handler
+  ChangeScaledRegionHandlerType::Pointer changeScaledHandler =ChangeScaledRegionHandlerType::New();
+  changeScaledHandler->SetModel(model);
+  changeScaledHandler->SetView(view);
+  controller->AddActionHandler(changeScaledHandler);
+
+  // Add the pixel description action handler
+  PixelDescriptionActionHandlerType::Pointer pixelActionHandler = PixelDescriptionActionHandlerType::New();
+  pixelActionHandler->SetView(view);
+  pixelActionHandler->SetModel(pixelModel);
+  controller->AddActionHandler(pixelActionHandler);
+
+  // Add the change scaled handler
+  ChangeScaleHandlerType::Pointer changeScaleHandler =ChangeScaleHandlerType::New();
+  changeScaleHandler->SetModel(model);
+  changeScaleHandler->SetView(view);
+  controller->AddActionHandler(changeScaleHandler);
+
+
+   // Add the change extract region handler
+  ChangeRegionHandlerType::Pointer changeHandler =ChangeRegionHandlerType::New();
+  changeHandler->SetModel(model);
+  changeHandler->SetView(view);
+  controller->AddActionHandler(changeHandler);
+
+ 
+
+  // Build a pixel description view
+  PixelDescriptionViewType::Pointer pixelView = PixelDescriptionViewType::New();
+  pixelView->SetModel(pixelModel);
+
+ Fl_Window pixelWindow(fullSize,50);
+  if(fullSize > 0)
+    {
+    pixelWindow.add(pixelView->GetPixelDescriptionWidget());
+    pixelWindow.resizable(pixelView->GetPixelDescriptionWidget());
+    pixelWindow.show();
+    pixelView->GetPixelDescriptionWidget()->show();
+    pixelView->GetPixelDescriptionWidget()->resize(0,0,fullSize,50);
+    }
+
+   Fl_Window scrollWindow(scrollSize,scrollSize);
+  if(scrollSize > 0)
+    {
+     scrollWindow.add(view->GetScrollWidget());
+     scrollWindow.resizable(view->GetScrollWidget());
+     scrollWindow.show();
+    view->GetScrollWidget()->show();
+    view->GetScrollWidget()->resize(0,0,scrollSize,scrollSize);
+    }
+
+  Fl_Window fullWindow(fullSize,fullSize);
+  if(fullSize > 0)
+    {
+    fullWindow.add(view->GetFullWidget());
+    fullWindow.resizable(view->GetFullWidget());
+    fullWindow.show(); 
+    view->GetFullWidget()->show();
+    view->GetFullWidget()->resize(0,0,fullSize,fullSize);
+    }
+
+  Fl_Window zoomWindow(zoomSize,zoomSize);
+  if(zoomSize > 0)
+    {
+    zoomWindow.add(view->GetZoomWidget());
+    zoomWindow.resizable(view->GetZoomWidget());
+    zoomWindow.show();
+    view->GetZoomWidget()->show();
+    view->GetZoomWidget()->resize(0,0,zoomSize,zoomSize);
+    }
+
+  if(run)
+    {
+    Fl::run();
+    }
+  else
+    {
+    Fl::check();
+    }
+
+  zoomWindow.remove(view->GetZoomWidget());
+  scrollWindow.remove(view->GetScrollWidget());
+  fullWindow.remove(view->GetFullWidget());
+  pixelWindow.remove(pixelView->GetPixelDescriptionWidget());
+
+  return EXIT_SUCCESS;
+}

Testing/Code/Visualization/otbVisualizationTests1.cxx

@@ -51,6 +51,7 @@ void RegisterTests()
   REGISTER_TEST(otbMultiplyBlendingFunctionNew);
   REGISTER_TEST(otbImageViewNew);
   REGISTER_TEST(otbImageViewerEndToEndSingleLayer);
+  REGISTER_TEST(otbImageViewerEndToEndSingleLayerWithSelectAreaHandler);
   REGISTER_TEST(otbImageViewerEndToEndTwoLayers);
   REGISTER_TEST(otbPixelDescriptionModelNew);
   REGISTER_TEST(otbPixelDescriptionModelSingleLayer);