Add grey color/spacing functionality to scalar bar control

diff --git a/src/PIPELINE/VISU_ScalarBarCtrl.cxx b/src/PIPELINE/VISU_ScalarBarCtrl.cxx
index 2132b6776b93f4a868d3dfbc876a16282f5828ea..cbd61e7b3cdfd9c75a3caac58faf34d6d81b1192 100644 (file)
--- a/src/PIPELINE/VISU_ScalarBarCtrl.cxx
+++ b/src/PIPELINE/VISU_ScalarBarCtrl.cxx
@@ -36,9 +36,14 @@
 #include <vtkIdType.h>
 #include <string.h>
 //
+static 
+  void MarkValueByColor(vtkLookupTable* theTable,
+                       float theValue,
+                       unsigned char* theColor);
+//
 vtkStandardNewMacro(VISU_ScalarBarCtrl);
 //==================================================================
-// function : Constructor
+// function : Ctor
 // purpose  :
 //==================================================================
 VISU_ScalarBarCtrl::VISU_ScalarBarCtrl()
@@ -47,9 +52,12 @@ VISU_ScalarBarCtrl::VISU_ScalarBarCtrl()
   myDistance=0.02;
   myL=0.8;
   myB=0.15;
-  myPosition[0]=0.05;
-  myPosition[1]=0.1;
+  myPosition[0]=0.15;
+  myPosition[1]=0.01;
   myBicolor=false;
+  myMaximumNumberOfColors=256;
+  myMarked=false;
+  myMarkedValue=99.;
   //
   int i;
   //
@@ -68,10 +76,18 @@ VISU_ScalarBarCtrl::VISU_ScalarBarCtrl()
   for (i=0; i<myScalarBarNumberMax; ++i){
     myXLT[i]=vtkLookupTable::New();
     myXLT[i]->SetHueRange(0.667,0.0);
+    myXLT[i]->SetNumberOfColors((vtkIdType)myMaximumNumberOfColors);
+    //
     mySBA[i]=vtkScalarBarActor::New();
+    mySBA[i]->SetMaximumNumberOfColors(myMaximumNumberOfColors);       
   } 
   //
   SetOrientation(1);//VERTICAL
+  //
+  for (i=0; i<4; ++i){
+    myBlack[i]=0;
+    myGrey[i]=192;
+  }
 }
 //==================================================================
 // function : ~
@@ -129,7 +145,7 @@ void VISU_ScalarBarCtrl::SetRangeLocal(const float *theX)
 // purpose  :
 //==================================================================
 void VISU_ScalarBarCtrl::SetRangeLocal(const float theX1,
-                                           const float theX2)
+                                      const float theX2)
 {
   myRangeLocal[0]=theX1;
   myRangeLocal[1]=theX2;
@@ -155,7 +171,7 @@ void VISU_ScalarBarCtrl::SetRangeGlobal(const float *theX)
 // purpose  :
 //==================================================================
 void VISU_ScalarBarCtrl::SetRangeGlobal(const float theX1,
-                                           const float theX2)
+                                       const float theX2)
 {
   myRangeGlobal[0]=theX1;
   myRangeGlobal[1]=theX2;
@@ -282,6 +298,22 @@ const float* VISU_ScalarBarCtrl::GetPosition()const
   return myPosition;
 }
 //==================================================================
+// function : SetSpacing
+// purpose  :
+//==================================================================
+void VISU_ScalarBarCtrl::SetSpacing(const float theSpacing)
+{
+  myDistance=theSpacing;
+}
+//==================================================================
+// function : GetSpacing
+// purpose  :
+//==================================================================
+float VISU_ScalarBarCtrl::GetSpacing()const
+{
+  return myDistance;
+}
+//==================================================================
 // function : SetBicolor
 // purpose  :
 //==================================================================
@@ -298,16 +330,49 @@ bool VISU_ScalarBarCtrl::GetBicolor()const
   return myBicolor;
 }
 //==================================================================
+// function : SetMaximumNumberOfColors
+// purpose  :
+//==================================================================
+void VISU_ScalarBarCtrl::SetMaximumNumberOfColors(const int theNumber)
+{
+  myMaximumNumberOfColors=theNumber;
+}
+//==================================================================
+// function : GetMaximumNumberOfColors
+// purpose  :
+//==================================================================
+int VISU_ScalarBarCtrl::GetMaximumNumberOfColors()const
+{
+  return myMaximumNumberOfColors;
+}
+//==================================================================
+// function : MarkValue
+// purpose  :
+//==================================================================
+void VISU_ScalarBarCtrl::MarkValue(const float theValue) 
+{
+  myMarked=true;
+  myMarkedValue=theValue;
+}
+//==================================================================
+// function : UnmarkValue
+// purpose  :
+//==================================================================
+void VISU_ScalarBarCtrl::UnmarkValue()
+{
+  myMarked=false;
+}
+//==================================================================
 // function : Update
 // purpose  :
 //==================================================================
-int VISU_ScalarBarCtrl::Update()
+void VISU_ScalarBarCtrl::Update()
 {
   if (!myBarVisibility) {
     for (int i=0; i<myScalarBarNumberMax; ++i){
       mySBA[i]->SetVisibility(myBarVisibility);
     }
-    return 0;
+    return;
   }
   //
   PrepareTables();
@@ -318,7 +383,23 @@ int VISU_ScalarBarCtrl::Update()
   else {
     UpdateForColor();
   }
-  return 0;
+  //
+  UpdateMarkValue();
+}
+//==================================================================
+// function : UpdateMarkValue
+// purpose  :
+//==================================================================
+void VISU_ScalarBarCtrl::UpdateMarkValue()
+{
+  if (myMarked){
+    if (myMode==0 || myMode==1) {
+      MarkValueByColor(myXLT[0], myMarkedValue, myBlack);
+    }
+    else {
+      MarkValueByColor(myXLT[1], myMarkedValue, myBlack);
+    }
+  }
 }
 //==================================================================
 // function : PrepareTables
@@ -336,23 +417,25 @@ void VISU_ScalarBarCtrl::PrepareTables()
     pCoordinate->SetCoordinateSystemToNormalizedViewport();
     //
     if (aOrientation) {// VERTICAL
-      pCoordinate->SetValue(myPosition[0]+i*0.5*(myL+myDistance), myPosition[1]);
-      mySBA[i]->SetWidth(0.5*(myL-myDistance));
+      pCoordinate->SetValue(myPosition[0]+i*(myL+myDistance), myPosition[1]);
+      mySBA[i]->SetWidth(myL);
       mySBA[i]->SetHeight(myB);
     }
     else { 
-      pCoordinate->SetValue(myPosition[0], myPosition[1]+i*0.5*(myB+myDistance));
+      pCoordinate->SetValue(myPosition[0], myPosition[1]+i*(myB+myDistance));
       mySBA[i]->SetWidth(myL);
-      mySBA[i]->SetHeight(0.5*(myB-myDistance));
+      mySBA[i]->SetHeight(myB);
     }
   }
   //
   // Initialize Lookup Tables and Scalar Bars 
   for (i=0; i<myScalarBarNumberMax; ++i){
+    myXLT[i]->SetNumberOfColors((vtkIdType)myMaximumNumberOfColors);
     myXLT[i]->SetRange(myRangeGlobal[0], myRangeGlobal[1]);
     myXLT[i]->Modified();
     myXLT[i]->Build();
     //
+    mySBA[i]->SetMaximumNumberOfColors(myMaximumNumberOfColors); 
     mySBA[i]->SetLookupTable(myXLT[i]);
     mySBA[i]->SetVisibility(myBarVisibility);
     mySBA[i]->Modified();
@@ -364,56 +447,37 @@ void VISU_ScalarBarCtrl::PrepareTables()
 //==================================================================
 void VISU_ScalarBarCtrl::UpdateForColor()
 {
-  int i;
-  //
-  if (!myMode){
+  if (myMode==0){ 
+    myXLT[0]->SetRange(myRangeLocal[0], myRangeLocal[1]);
+    myXLT[0]->Modified();
+    myXLT[0]->Build();
+    //
     mySBA[1]->VisibilityOff();
     return ; 
   }
   //
-  // Fill Lookup Tables
   size_t aN4=4*sizeof(unsigned char);
   unsigned char *pTL, *pTG;
-  vtkIdType j, aNbColors, aG[2], dG;
+  vtkIdType j, aNbColors;
   //
-  for (j=0; j<2; ++j) {
-    aG[j]=myXLT[0]->GetIndex(myRangeLocal[j]);
-  }
-  dG=aG[1]-aG[0];
   aNbColors=myXLT[0]->GetNumberOfColors();
   //
   if (myMode==1){ 
-    vtkIdType aGj;
-    //
     for (j=0; j<aNbColors; ++j){
       pTL=myXLT[1]->GetPointer(j);
-      
-      aGj=aG[0]+j*dG/aNbColors; 
-      pTG=myXLT[0]->GetPointer(aGj);
-      memcpy(pTL, pTG, aN4); 
+      myGrey[3]=pTL[3];
+      memcpy(pTL, myGrey, aN4);
     }
   }
-  else {
-    unsigned char *pTL0, *pTL1;
-    vtkIdType aLj;
-    //
-    pTL0=myXLT[1]->GetPointer(0);
-    pTL1=myXLT[1]->GetPointer(aNbColors-1);
+  else if (myMode==2){
     for (j=0; j<aNbColors; ++j){
       pTG=myXLT[0]->GetPointer(j);
-    
-      if (j<aG[0]) {
-       pTL=pTL0;
-      }
-      else if (j>aG[1]) {
-       pTL=pTL1; 
-      }
-      else {
-       aLj=(j-aG[0])*aNbColors/dG;
-       pTL=myXLT[1]->GetPointer(aLj);
-      }
-      memcpy(pTG, pTL, aN4); 
+      myGrey[3]=pTG[3];
+      memcpy(pTG, myGrey, aN4);
     }
+    //
+    MarkValueByColor(myXLT[0], myRangeLocal[0], myBlack);
+    MarkValueByColor(myXLT[0], myRangeLocal[1], myBlack);
   }
   myXLT[1]->SetRange(myRangeLocal[0], myRangeLocal[1]);
 }
@@ -425,38 +489,57 @@ void VISU_ScalarBarCtrl::UpdateForColor()
 void VISU_ScalarBarCtrl::UpdateForBicolor()
 {
   size_t aN4=4*sizeof(unsigned char);
-  unsigned char *pTi, *pTRed, *pTBlue;
-  int i, j, aNb;
-  float aXi, aX0, dX;
+  unsigned char *pTi, *pTRed, *pTBlue, *pTL, *pTG; 
+  int i;
+  float aXi, aX0, dX, *pRange;
   vtkIdType aIndex, aNbColors;
   //
   aNbColors=myXLT[0]->GetNumberOfColors();
-  //
   pTBlue=myXLT[0]->GetPointer(0);
-  pTRed=myXLT[0]->GetPointer(aNbColors-1);
+  pTRed =myXLT[0]->GetPointer(aNbColors-1);
   //
-  if (myMode){
-    aNb=2;
-    myXLT[1]->SetRange(myRangeLocal[0], myRangeLocal[1]);
-    myXLT[1]->Modified();
-    myXLT[1]->Build();
+  if (myMode==0) {
+    myXLT[0]->SetRange(myRangeLocal[0], myRangeLocal[1]);
+    myXLT[0]->Modified();
+    myXLT[0]->Build();
     //
-    mySBA[1]->SetLookupTable(myXLT[1]);
-    mySBA[1]->Modified();
-  }
-  else {
-    aNb=1;
+    mySBA[0]->SetLookupTable(myXLT[0]);
+    mySBA[0]->Modified();
+    //
+    pRange=myRangeLocal;
+    dX=(pRange[1]-pRange[0])/aNbColors;
+    aX0=pRange[0]+0.5*dX;
+    for (i=0; i<aNbColors; ++i){
+      aXi=aX0+i*dX;
+      aIndex=myXLT[0]->GetIndex(aXi);
+      pTi=myXLT[0]->GetPointer(aIndex);
+      if (aXi > 0.) {
+       memcpy(pTi, pTRed, aN4); 
+      }
+      else {
+       memcpy(pTi, pTBlue, aN4); 
+      }
+    }
     mySBA[1]->VisibilityOff();
+    return;
   }
   //
-  for (j=0; j<aNb; ++j){
-    float *pRange=(!j) ? myRangeGlobal : myRangeLocal;
+  // mode: 1,2 
+  myXLT[1]->SetRange(myRangeLocal[0], myRangeLocal[1]);
+  myXLT[1]->Modified();
+  myXLT[1]->Build();
+  //
+  mySBA[1]->SetLookupTable(myXLT[1]);
+  mySBA[1]->Modified();
+  //
+  if (myMode==1){
+    pRange=myRangeGlobal;
     dX=(pRange[1]-pRange[0])/aNbColors;
     aX0=pRange[0]+0.5*dX;
     for (i=0; i<aNbColors; ++i){
       aXi=aX0+i*dX;
-      aIndex=myXLT[j]->GetIndex(aXi);
-      pTi=myXLT[j]->GetPointer(aIndex);
+      aIndex=myXLT[0]->GetIndex(aXi);
+      pTi=myXLT[0]->GetPointer(aIndex);
       if (aXi > 0.) {
        memcpy(pTi, pTRed, aN4); 
       }
@@ -464,5 +547,56 @@ void VISU_ScalarBarCtrl::UpdateForBicolor()
        memcpy(pTi, pTBlue, aN4); 
       }
     }
+    //
+    for (i=0; i<aNbColors; ++i){
+      pTL=myXLT[1]->GetPointer(i);
+      myGrey[3]=pTL[3];
+      memcpy(pTL, myGrey, aN4);
+    }
   }
+  //
+  else if (myMode==2){
+    pRange=myRangeLocal;
+    dX=(pRange[1]-pRange[0])/aNbColors;
+    aX0=pRange[0]+0.5*dX;
+    for (i=0; i<aNbColors; ++i){
+      aXi=aX0+i*dX;
+      aIndex=myXLT[1]->GetIndex(aXi);
+      pTi=myXLT[1]->GetPointer(aIndex);
+      if (aXi > 0.) {
+       memcpy(pTi, pTRed, aN4); 
+      }
+      else {
+       memcpy(pTi, pTBlue, aN4); 
+      }
+    }
+    //
+    for (i=0; i<aNbColors; ++i){ 
+      pTG=myXLT[0]->GetPointer(i);
+      myGrey[3]=pTG[3];
+      memcpy(pTG, myGrey, aN4);
+    }
+    //
+    MarkValueByColor(myXLT[0], myRangeLocal[0], myBlack);
+    MarkValueByColor(myXLT[0], myRangeLocal[1], myBlack);
+  }
+}
+//==================================================================
+// function : MarkValueByColor
+// purpose  :
+//==================================================================
+void MarkValueByColor(vtkLookupTable* theTable,
+                     float theValue,
+                     unsigned char* theColor)
+{ 
+  size_t aN4=4*sizeof(unsigned char);
+  unsigned char *pT, aC3;
+  vtkIdType aIndex;
+  //
+  aC3=theColor[3];
+  aIndex=theTable->GetIndex(theValue);
+  pT=theTable->GetPointer(aIndex);
+  theColor[3]=pT[3];
+  memcpy(pT, theColor, aN4); 
+  theColor[3]=aC3;
 }

diff --git a/src/PIPELINE/VISU_ScalarBarCtrl.hxx b/src/PIPELINE/VISU_ScalarBarCtrl.hxx
index 711be719d5507b60ae7b13c6aaa306742d2a9ea4..7436b22f1236408abc68ab59e4f1b6cba8facff1 100644 (file)
--- a/src/PIPELINE/VISU_ScalarBarCtrl.hxx
+++ b/src/PIPELINE/VISU_ScalarBarCtrl.hxx
@@ -56,18 +56,7 @@ public:
   
   const float* GetRangeLocal()const;
   //
-  //Orientation
-  void SetOrientationToHorizontal() {
-    SetOrientation(0);
-  }
-  void SetOrientationToVertical() {
-     SetOrientation(1);
-  }
-  
-  void SetOrientation(const int theOrientation);
-  
-  int GetOrientation()const;
-  //
+  // Selectors
   vtkScalarBarActor* GetScalarBarActor(const int theIndex);
   vtkLookupTable* GetLookupTable(const int theIndex);
   //
@@ -79,26 +68,53 @@ public:
   void SetBarVisibility(const bool theFlag);
   bool GetBarVisibility()const;
   //
-  int Update();
+  // Build
+  void Update();
   //
+  // Position
   void  SetWidth(const float theWidth);
   float GetWidth()const;
   void  SetHeight(const float theHeight);
   float GetHeight()const;
   void  SetPosition(const float* thePosition);
   const float* GetPosition()const;
-  
+  //
+  // Spacing
+  void  SetSpacing(const float theSpacing);
+  float GetSpacing()const;
+  //
+  // Rainbow/bicolor
   bool  GetBicolor() const;
   void  SetBicolor(const bool theBicolor);
-
+  //
+  //Orientation
+  void SetOrientationToHorizontal() {
+    SetOrientation(0);
+  }
+  void SetOrientationToVertical() {
+     SetOrientation(1);
+  }
+  void SetOrientation(const int theOrientation);
+  int GetOrientation()const;
+  //
+  // Maximum Number Of Colors
+  void SetMaximumNumberOfColors(const int theNumber);
+  int GetMaximumNumberOfColors ()const;
+  //
+  // Misc
+  void MarkValue  (const float theValue);
+  void UnmarkValue();
+  //
 protected:
   VISU_ScalarBarCtrl();
   virtual ~VISU_ScalarBarCtrl();
   
   void UpdateForBicolor();
   void UpdateForColor();
+  void UpdateMarkValue();
   void PrepareTables();
-
+  
+  
 protected:
   int   myMode;
   int   myScalarBarNumber;
@@ -108,6 +124,12 @@ protected:
   float myRangeGlobal[2];
   bool  myBicolor;
   bool  myBarVisibility;
+  int   myMaximumNumberOfColors;
+  unsigned char myBlack[4];
+  unsigned char myGrey[4];
+  //
+  bool  myMarked;
+  float myMarkedValue;
   //
   vtkScalarBarActor *mySBA[2];
   vtkLookupTable *myXLT[2];