bbtk_creaVtk_PKG/src/bbcreaVtkScalarsToColors.cxx

   1 //=====
   2 // Before editing this file, make sure it's a file of your own (i.e.: it wasn't generated from xml description; if so : your modifications will be lost)
   3 //=====
   4 #include "bbcreaVtkScalarsToColors.h"
   5 #include "bbcreaVtkPackage.h"
   6
   7 #include "vtkLookupTable.h"
   8 #include "vtkObjectFactory.h"
   9
  10 namespace bbcreaVtk
  11 {
  12
  13 class /*VTK_COMMON_EXPORT*/ vtkLookupTableDirectionVector2 : public vtkScalarsToColors
  14 {
  15 public:
  16         // Description:
  17         // Construct with range=[0,1]; and hsv ranges set up for rainbow color table
  18         // (from red to blue).
  19         static vtkLookupTableDirectionVector2 *New();
  20         vtkTypeMacro(vtkLookupTableDirectionVector2,vtkScalarsToColors);
  21         void PrintSelf(ostream& os, vtkIndent indent);
  22         double *GetRange() { return this->GetTableRange(); };
  23         void SetRange(double min, double max) { this->SetTableRange(min, max); };
  24         void SetRange(double rng[2]) { this->SetRange(rng[0], rng[1]); };
  25         void SetTableRange(double r[2]);
  26         virtual void SetTableRange(double min, double max);
  27         vtkGetVectorMacro(TableRange,double,2);
  28         unsigned char *MapValue(double v);
  29         void GetColor(double x, double rgb[3]);
  30         void MapScalarsThroughTable2(void *input, unsigned char *output,
  31                                                                  int inputDataType, int numberOfValues,
  32                                                                  int inputIncrement, int outputIncrement);
  33         void SetTypeTable( int typetable );
  34 protected:
  35         double TableRange[2];
  36         vtkLookupTableDirectionVector2(int sze=256, int ext=256);
  37         ~vtkLookupTableDirectionVector2();
  38 private:
  39         int TypeTable;                                                                                                                  //EED
  40         vtkLookupTableDirectionVector2(const vtkLookupTableDirectionVector2&);  // Not implemented.
  41         void operator=(const vtkLookupTableDirectionVector2&);                                  // Not implemented.
  42 };
  43
  44
  45
  46
  47 vtkStandardNewMacro(vtkLookupTableDirectionVector2);
  48
  49 // Construct with range=(0,1); and hsv ranges set up for rainbow color table
  50 // (from red to blue).
  51 vtkLookupTableDirectionVector2::vtkLookupTableDirectionVector2(int sze, int ext)
  52 {
  53         this->TableRange[0] = 0.0;
  54         this->TableRange[1] = 1.0;
  55         TypeTable=0;
  56 }
  57
  58 //----------------------------------------------------------------------------
  59 vtkLookupTableDirectionVector2::~vtkLookupTableDirectionVector2()
  60 {
  61 }
  62
  63 unsigned char *vtkLookupTableDirectionVector2::MapValue(double v)
  64 {
  65
  66         //int idx = this->GetIndex(v);
  67         //return (this->Table->GetPointer(0) + 4*idx);
  68         return 0;
  69 }
  70
  71 void vtkLookupTableDirectionVector2::GetColor(double v, double rgb[3])
  72 {
  73 //      unsigned char *rgb8 = this->MapValue(v);
  74 //      rgb[0] = rgb8[0]/255.0;
  75 //      rgb[1] = rgb8[1]/255.0;
  76 //      rgb[2] = rgb8[2]/255.0;
  77
  78         rgb[0] = 1;
  79         rgb[1] = 1;
  80         rgb[2] = 0;
  81 }
  82
  83
  84 void vtkLookupTableDirectionVector2::SetTableRange(double r[2])
  85 {
  86         this->SetTableRange(r[0],r[1]);
  87 }
  88
  89 void vtkLookupTableDirectionVector2::SetTypeTable( int typetable )
  90 {
  91         TypeTable=typetable;
  92 }
  93
  94 //----------------------------------------------------------------------------
  95 // Set the minimum/maximum scalar values for scalar mapping. Scalar values
  96 // less than minimum range value are clamped to minimum range value.
  97 // Scalar values greater than maximum range value are clamped to maximum
  98 // range value.
  99 void vtkLookupTableDirectionVector2::SetTableRange(double rmin, double rmax)
 100 {
 101         if (rmax < rmin)
 102     {
 103                 vtkErrorMacro("Bad table range: ["<<rmin<<", "<<rmax<<"]");
 104                 return;
 105     }
 106
 107         if (this->TableRange[0] == rmin && this->TableRange[1] == rmax)
 108     {
 109                 return;
 110     }
 111
 112         this->TableRange[0] = rmin;
 113         this->TableRange[1] = rmax;
 114
 115         this->Modified();
 116 }
 117
 118
 119
 120 //----------------------------------------------------------------------------
 121 // Although this is a relatively expensive calculation,
 122 // it is only done on the first render. Colors are cached
 123 // for subsequent renders.
 124 template<class T>
 125 void vtkLookupTableMapDirVectorEED2(vtkLookupTableDirectionVector2 *self, T *input,
 126                           unsigned char *output, int length,
 127                           int inIncr, int outFormat,int TypeTable)
 128 {
 129
 130         if (TypeTable==0)
 131         {
 132                 double sum;
 133                 int i;
 134                 double dirx,diry,dirz;
 135                 for (i = 0; i < length; ++i)
 136                 {
 137                                 dirx    = static_cast<T>(input[0]);
 138                                 diry    = static_cast<T>(input[1]);
 139                                 dirz    = static_cast<T>(input[2]);
 140                                 input   = input+inIncr;
 141                                 sum             = sqrt( dirx*dirx + diry*diry + dirz*dirz );
 142                                 *output++ = (unsigned char) abs( (255*dirx/sum) );
 143                                 *output++ = (unsigned char) abs( (255*diry/sum) );
 144                                 *output++ = (unsigned char) abs( (255*dirz/sum) );
 145                                 *output++ = 255;
 146                 //              printf("%d %d %d   ",(int)(255*dirx/sum),(int)(255*diry/sum),(int)(255*dirz/sum));
 147                 //              printf(" C     %d        %f %f %f   \n",inIncr,dirx,diry,dirz);
 148
 149                 } // for
 150         } // typeTable == 0
 151
 152         if (TypeTable==1)
 153         {
 154                 int i;
 155                 for (i = 0; i < length; ++i)
 156                 {
 157                                 *output++ = static_cast<T>(input[0]);  // red
 158                                 *output++ = static_cast<T>(input[1]);  // green
 159                                 *output++ = static_cast<T>(input[2]);  // blue
 160 //                              *output++ = 255;
 161                                 input   = input+inIncr;
 162                 } // for
 163         } // typeTable == 1
 164
 165
 166 }
 167
 168
 169 //----------------------------------------------------------------------------
 170 void vtkLookupTableDirectionVector2::MapScalarsThroughTable2(void *input,
 171                                              unsigned char *output,
 172                                              int inputDataType,
 173                                              int numberOfValues,
 174                                              int inputIncrement,
 175                                              int outputFormat)
 176 {
 177 // if (this->UseMagnitude && inputIncrement > 1)
 178 // {
 179      switch (inputDataType)
 180      {
 181        vtkTemplateMacro( vtkLookupTableMapDirVectorEED2(this,static_cast<VTK_TT*>(input),output,
 182                          numberOfValues,inputIncrement,outputFormat,TypeTable);
 183                          return
 184                         );
 185         case VTK_BIT:
 186             vtkErrorMacro("Cannot comput magnitude of bit array.");
 187             break;
 188         default:
 189             vtkErrorMacro(<< "MapImageThroughTable: Unknown input ScalarType");
 190      } /// switch
 191 // } //if
 192 }
 193
 194
 195 //----------------------------------------------------------------------------
 196 void vtkLookupTableDirectionVector2::PrintSelf(ostream& os, vtkIndent indent)
 197 {
 198         this->Superclass::PrintSelf(os,indent);
 199 }
 200
 201
 202
 203
 204
 205
 206 BBTK_ADD_BLACK_BOX_TO_PACKAGE(creaVtk,ScalarsToColors)
 207 BBTK_BLACK_BOX_IMPLEMENTATION(ScalarsToColors,bbtk::AtomicBlackBox);
 208 //=====
 209 // Before editing this file, make sure it's a file of your own (i.e.: it wasn't generated from xml description; if so : your modifications will be lost)
 210 //=====
 211 void ScalarsToColors::Process()
 212 {
 213
 214 // THE MAIN PROCESSING METHOD BODY
 215 //   Here we simply set the input 'In' value to the output 'Out'
 216 //   And print out the output value
 217 // INPUT/OUTPUT ACCESSORS ARE OF THE FORM :
 218 //    void bbSet{Input|Output}NAME(const TYPE&)
 219 //    const TYPE& bbGet{Input|Output}NAME() const
 220 //    Where :
 221 //    * NAME is the name of the input/output
 222 //      (the one provided in the attribute 'name' of the tag 'input')
 223 //    * TYPE is the C++ type of the input/output
 224 //      (the one provided in the attribute 'type' of the tag 'input')
 225
 226 //    bbSetOutputOut( bbGetInputIn() );
 227 //    std::cout << "Output value = " <<bbGetOutputOut() << std::endl;
 228
 229
 230         if (firsttime==true)
 231         {
 232                 firsttime=false;
 233                 // Create the color map
 234                 if ((bbGetInputType()==0) || (bbGetInputType()==100) )
 235                 {
 236                         vtkLookupTable *colorLookupTable = vtkLookupTable::New();
 237                         if (bbGetInputRange().size()==2)
 238                         {
 239                                 colorLookupTable->SetRange( bbGetInputRange()[0],bbGetInputRange()[1]);
 240 //                              colorLookupTable->SetTableRange( bbGetInputRange()[0],bbGetInputRange()[1]);
 241                         } else {
 242                                 colorLookupTable->SetRange(0,255);
 243                         }
 244                         int NumberOfColors=1000;
 245                         int NumberOfColorsHalf=NumberOfColors/2;
 246                         colorLookupTable->SetNumberOfTableValues( NumberOfColors );
 247                         colorLookupTable->Build();
 248                         double rgba1[4];
 249                         double rgba2[4];
 250                         int iLookTable;
 251                         for (iLookTable = 0; iLookTable<NumberOfColorsHalf; iLookTable++)
 252                         {
 253                                 colorLookupTable->GetTableValue(      iLookTable, rgba1);
 254                                 colorLookupTable->GetTableValue(NumberOfColors-1-iLookTable, rgba2);
 255                                 colorLookupTable->SetTableValue(NumberOfColors-1-iLookTable , rgba1[0],rgba1[1],rgba1[2],rgba1[3]);
 256                                 colorLookupTable->SetTableValue(      iLookTable , rgba2[0],rgba2[1],rgba2[2],rgba2[3]);
 257                         } // for iLookTable
 258                         double rgba[4];
 259                         colorLookupTable->GetTableValue(0,rgba);
 260                         rgba[3]=0;
 261                         colorLookupTable->SetTableValue(0,rgba);
 262
 263                         // Transparency
 264                         if (bbGetInputType()==0)
 265                         {
 266                                 int i,iMax=(NumberOfColors/16)*4;
 267                                 for (i=0;i<iMax;i++)
 268                                 {
 269                                         colorLookupTable->GetTableValue(NumberOfColorsHalf+i, rgba);
 270                                         rgba[3]=(double)i/(double)iMax;
 271                                         colorLookupTable->SetTableValue(NumberOfColorsHalf+i,rgba);
 272                                         colorLookupTable->GetTableValue(NumberOfColorsHalf-i, rgba);
 273                                         rgba[3]=(double)i/(double)iMax;
 274                                         colorLookupTable->SetTableValue(NumberOfColorsHalf-i,rgba);
 275                                 } // for
 276                         } //if Type 0
 277
 278                         colorLookupTable->Modified();
 279                         _scalarstocolors = colorLookupTable;
 280                 } // if Type 0 || 100
 281
 282 //EED 2018-06-8 ***********************ARDS Projet***********************************************
 283                 if ((bbGetInputType()==1) || (bbGetInputType()==101) )
 284                 {
 285                         vtkLookupTable *colorLookupTable = vtkLookupTable::New();
 286                         if (bbGetInputRange().size()==2)
 287                         {
 288                                 colorLookupTable->SetRange( bbGetInputRange()[0],bbGetInputRange()[1]);
 289 //                              colorLookupTable->SetTableRange( bbGetInputRange()[0],bbGetInputRange()[1]);
 290                         } else {
 291                                 colorLookupTable->SetRange(0,255);
 292                         }
 293                         colorLookupTable->SetValueRange(0.0, 1.0); // from black to white
 294                         colorLookupTable->SetSaturationRange(0.0, 0.0); // no color saturation
 295                         colorLookupTable->SetRampToLinear();
 296                         colorLookupTable->Build();
 297                         // Transparency
 298                         if (bbGetInputType()==1)
 299                         {
 300                                 double rgba[4];
 301                                 colorLookupTable->GetTableValue(0,rgba);
 302                                 rgba[3]=0;
 303                                 colorLookupTable->SetTableValue(0,rgba);
 304                         } // if Type 1
 305                         _scalarstocolors = colorLookupTable;
 306                 } // If Type 1 || 101
 307
 308
 309                 if (bbGetInputType()==2)  // Direction Color Vector
 310                 {
 311                         vtkLookupTableDirectionVector2 *_LutEED = vtkLookupTableDirectionVector2::New();
 312                         _LutEED->SetVectorModeToRGBColors();
 313                         _LutEED->SetTypeTable(0);
 314                         _scalarstocolors = _LutEED;
 315                 } // If Type 2
 316
 317                 if (bbGetInputType()==3)  // Componets image rgb [0 255]
 318                 {
 319                         vtkLookupTableDirectionVector2 *_LutEED = vtkLookupTableDirectionVector2::New();
 320                         _LutEED->SetVectorModeToRGBColors();
 321                         _LutEED->SetTypeTable(1);                                // for components image
 322                         _scalarstocolors = _LutEED;
 323                 } // If Type 3
 324
 325
 326         } // firsttime
 327         double rgb[3];
 328         std::vector<double>colorRGB;
 329         _scalarstocolors->GetColor( bbGetInputScalarValue() , rgb );
 330         colorRGB.push_back( rgb[0] );
 331         colorRGB.push_back( rgb[1] );
 332         colorRGB.push_back( rgb[2] );
 333         bbSetOutputColor( colorRGB );
 334         bbSetOutputLookupTable( _scalarstocolors );
 335
 336
 337 }
 338 //=====
 339 // Before editing this file, make sure it's a file of your own (i.e.: it wasn't generated from xml description; if so : your modifications will be lost)
 340 //=====
 341 void ScalarsToColors::bbUserSetDefaultValues()
 342 {
 343
 344 //  SET HERE THE DEFAULT INPUT/OUTPUT VALUES OF YOUR BOX
 345 //    Here we initialize the input 'In' to 0
 346    bbSetInputType(0);
 347    std::vector<double>range;
 348    range.push_back( 0 );
 349    range.push_back( 1 );
 350         bbSetInputRange(range);
 351    bbSetInputScalarValue(0);
 352    firsttime            = true;
 353    _scalarstocolors     = NULL;
 354 }
 355 //=====
 356 // Before editing this file, make sure it's a file of your own (i.e.: it wasn't generated from xml description; if so : your modifications will be lost)
 357 //=====
 358 void ScalarsToColors::bbUserInitializeProcessing()
 359 {
 360
 361 //  THE INITIALIZATION METHOD BODY :
 362 //    Here does nothing
 363 //    but this is where you should allocate the internal/output pointers
 364 //    if any
 365
 366
 367 }
 368 //=====
 369 // Before editing this file, make sure it's a file of your own (i.e.: it wasn't generated from xml description; if so : your modifications will be lost)
 370 //=====
 371 void ScalarsToColors::bbUserFinalizeProcessing()
 372 {
 373
 374 //  THE FINALIZATION METHOD BODY :
 375 //    Here does nothing
 376 //    but this is where you should desallocate the internal/output pointers
 377 //    if any
 378
 379 }
 380 }
 381 // EO namespace bbcreaVtk
 382
 383