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 printf("EED ScalarsToColors::Process  Start\n");
 231
 232         if (firsttime==true)
 233         {
 234                 firsttime=false;
 235                 // Create the color map
 236                 if (bbGetInputType()==0)
 237                 {
 238                         vtkLookupTable *colorLookupTable = vtkLookupTable::New();
 239                         if (bbGetInputRange().size()==2)
 240                         {
 241                                 colorLookupTable->SetRange( bbGetInputRange()[0],bbGetInputRange()[1]);
 242 //                              colorLookupTable->SetTableRange( bbGetInputRange()[0],bbGetInputRange()[1]);
 243                         } else {
 244                                 colorLookupTable->SetRange(0,255);
 245                         }
 246                         colorLookupTable->SetNumberOfTableValues(1000);
 247                         colorLookupTable->Build();
 248                         double rgba1[4];
 249                         double rgba2[4];
 250                         int iLookTable;
 251                         for (iLookTable = 0; iLookTable<500; iLookTable++)
 252                         {
 253                                 colorLookupTable->GetTableValue(      iLookTable, rgba1);
 254                                 colorLookupTable->GetTableValue(1000-1-iLookTable, rgba2);
 255                                 colorLookupTable->SetTableValue(1000-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                         int i,iMax;
 263                         iMax=(1000/16)*4;
 264                         for (i=0;i<iMax;i++)
 265                         {
 266                                 colorLookupTable->GetTableValue(500+i, rgba);
 267                                 rgba[3]=(double)i/(double)iMax;
 268                                 colorLookupTable->SetTableValue(500+i,rgba);
 269                                 colorLookupTable->GetTableValue(500-i, rgba);
 270                                 rgba[3]=(double)i/(double)iMax;
 271                                 colorLookupTable->SetTableValue(500-i,rgba);
 272                         } // for
 273 /*
 274                         iMax=100;
 275                         for (i=0;i<iMax;i++)
 276                         {
 277
 278                                 _colorLookupTable->GetTableValue(500+100+i, rgba);
 279                                 rgba[3]=(double)i/(double)iMax;
 280                                 _colorLookupTable->SetTableValue(500+100+i,rgba);
 281                                 _colorLookupTable->GetTableValue(500-100-i, rgba);
 282                                 rgba[3]=(double)i/(double)iMax;
 283                                 _colorLookupTable->SetTableValue(500-100-i,rgba);
 284
 285                         } // for
 286
 287                         iMax=200;
 288                         for (i=0;i<iMax;i++)
 289                         {
 290                                 _colorLookupTable->GetTableValue(500+i, rgba);
 291                                 rgba[3]=0;
 292                                 _colorLookupTable->SetTableValue(500+i,rgba);
 293                                 _colorLookupTable->GetTableValue(500-i, rgba);
 294                                 rgba[3]=0;
 295                                 _colorLookupTable->SetTableValue(500-i,rgba);
 296                         } // for
 297 */
 298                         _scalarstocolors = colorLookupTable;
 299                 } // if Type 0
 300
 301 //EED 2018-06-8 ***********************ARDS Projet***********************************************
 302                 if (bbGetInputType()==1)
 303                 {
 304                         vtkLookupTable *colorLookupTable = vtkLookupTable::New();
 305                         if (bbGetInputRange().size()==2)
 306                         {
 307                                 colorLookupTable->SetRange( bbGetInputRange()[0],bbGetInputRange()[1]);
 308 //                              colorLookupTable->SetTableRange( bbGetInputRange()[0],bbGetInputRange()[1]);
 309                         } else {
 310                                 colorLookupTable->SetRange(0,255);
 311                         }
 312                         colorLookupTable->SetValueRange(0.0, 1.0); // from black to white
 313                         colorLookupTable->SetSaturationRange(0.0, 0.0); // no color saturation
 314                         colorLookupTable->SetRampToLinear();
 315                         colorLookupTable->Build();
 316                         double rgba[4];
 317                         colorLookupTable->GetTableValue(0,rgba);
 318                         rgba[3]=0;
 319                         colorLookupTable->SetTableValue(0,rgba);
 320                         _scalarstocolors = colorLookupTable;
 321                 } // If Type 1
 322
 323
 324                 if (bbGetInputType()==2)  // Direction Color Vector
 325                 {
 326                         vtkLookupTableDirectionVector2 *_LutEED = vtkLookupTableDirectionVector2::New();
 327                         _LutEED->SetVectorModeToRGBColors();
 328                         _LutEED->SetTypeTable(0);
 329                         _scalarstocolors = _LutEED;
 330                 } // If Type 2
 331
 332                 if (bbGetInputType()==3)  // Componets image rgb [0 255]
 333                 {
 334                         vtkLookupTableDirectionVector2 *_LutEED = vtkLookupTableDirectionVector2::New();
 335                         _LutEED->SetVectorModeToRGBColors();
 336                         _LutEED->SetTypeTable(1);                                // for components image
 337                         _scalarstocolors = _LutEED;
 338                 } // If Type 3
 339
 340
 341         } // firsttime
 342         double rgb[3];
 343         std::vector<double>colorRGB;
 344         _scalarstocolors->GetColor( bbGetInputScalarValue() , rgb );
 345         colorRGB.push_back( rgb[0] );
 346         colorRGB.push_back( rgb[1] );
 347         colorRGB.push_back( rgb[2] );
 348         bbSetOutputColor( colorRGB );
 349         bbSetOutputLookupTable( _scalarstocolors );
 350
 351 printf("EED ScalarsToColors::Process  End\n");
 352
 353
 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::bbUserSetDefaultValues()
 359 {
 360
 361 //  SET HERE THE DEFAULT INPUT/OUTPUT VALUES OF YOUR BOX
 362 //    Here we initialize the input 'In' to 0
 363    bbSetInputType(0);
 364    std::vector<double>range;
 365    range.push_back( 0 );
 366    range.push_back( 1 );
 367         bbSetInputRange(range);
 368    bbSetInputScalarValue(0);
 369    firsttime            = true;
 370    _scalarstocolors     = NULL;
 371 }
 372 //=====
 373 // 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)
 374 //=====
 375 void ScalarsToColors::bbUserInitializeProcessing()
 376 {
 377
 378 //  THE INITIALIZATION METHOD BODY :
 379 //    Here does nothing
 380 //    but this is where you should allocate the internal/output pointers
 381 //    if any
 382
 383
 384 }
 385 //=====
 386 // 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)
 387 //=====
 388 void ScalarsToColors::bbUserFinalizeProcessing()
 389 {
 390
 391 //  THE FINALIZATION METHOD BODY :
 392 //    Here does nothing
 393 //    but this is where you should desallocate the internal/output pointers
 394 //    if any
 395
 396 }
 397 }
 398 // EO namespace bbcreaVtk
 399
 400