libossim-dev 1.7.21-3ubuntu2 / usr / include / ossim / imaging / ossimHsiRemapper.h

This file is indexed.

/usr/include/ossim/imaging/ossimHsiRemapper.h is in libossim-dev 1.7.21-3ubuntu2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
//*******************************************************************
// Copyright (C) 2002 ImageLinks Inc. 
//
// License:  LGPL
// 
// See LICENSE.txt file in the top level directory for more details.
//
// Author:  David Burken
//
// Description:
//
// Remapper to adjust hue, saturation and intensity.
//
//*************************************************************************
// $Id: ossimHsiRemapper.h 9094 2006-06-13 19:12:40Z dburken $

#ifndef ossimHsiRemapper_HEADER
#define ossimHsiRemapper_HEADER

#include <ossim/imaging/ossimImageSourceFilter.h>

class OSSIMDLLEXPORT ossimHsiRemapper : public ossimImageSourceFilter
{
public:
   enum
   {
      RED      = 0,
      YELLOW   = 1,
      GREEN    = 2,
      CYAN     = 3,      
      BLUE     = 4,
      MAGENTA  = 5,
      ALL      = 6
   };
   
   ossimHsiRemapper();

   virtual ~ossimHsiRemapper();

   virtual ossimString getLongName()  const;
   virtual ossimString getShortName() const;

   virtual void initialize();

   virtual ossimRefPtr<ossimImageData> getTile(const ossimIrect& tile_rect,
                                   ossim_uint32 resLevel=0);

   virtual bool saveState(ossimKeywordlist& kwl,
                          const char* prefix=0)const;
   
   /*!
    * Method to the load (recreate) the state of an object from a keyword
    * list.  Return true if ok or false on error.
    */
   virtual bool loadState(const ossimKeywordlist& kwl,
                          const char* prefix=0);
   
   
   ossim_uint32 getNumberOfOutputBands() const;

   virtual ostream& print(ostream& os) const;

   friend ostream& operator << (ostream& os,  const ossimHsiRemapper& hr);
   
   void setHueOffset               (int color_group, double offset);
   void setHueLowRange             (int color_group, double range);
   void setHueHighRange            (int color_group, double range);
   void setHueBlendRange           (int color_group, double range);
   void setSaturationOffset        (int color_group, double offset);
   void setIntensityOffset         (int color_group, double offset);
   
   void setMasterHueOffset         (double offset);
   void setMasterSaturationOffset  (double offset);
   void setMasterIntensityOffset   (double offset);
   void setMasterIntensityLowClip  (double clip);
   void setMasterIntensityHighClip (double clip);

   void setRedHueOffset            (double offset);
   void setRedHueLowRange          (double range);
   void setRedHueHighRange         (double range);
   void setRedHueBlendRange        (double range);
   void setRedSaturationOffset     (double offset);
   void setRedIntensityOffset      (double offset);

   void setYellowHueOffset         (double offset);
   void setYellowHueLowRange       (double range);
   void setYellowHueHighRange      (double range);
   void setYellowHueBlendRange     (double range);
   void setYellowSaturationOffset  (double offset);
   void setYellowIntensityOffset   (double offset);

   void setGreenHueOffset          (double offset);
   void setGreenHueLowRange        (double range);
   void setGreenHueHighRange       (double range);
   void setGreenHueBlendRange      (double range);
   void setGreenSaturationOffset   (double offset);
   void setGreenIntensityOffset    (double offset);

   void setCyanHueOffset           (double offset);
   void setCyanHueLowRange         (double range);
   void setCyanHueHighRange        (double range);
   void setCyanHueBlendRange       (double range);
   void setCyanSaturationOffset    (double offset);
   void setCyanIntensityOffset     (double offset);

   void setBlueHueOffset           (double offset);
   void setBlueHueLowRange         (double range);
   void setBlueHueHighRange        (double range);
   void setBlueHueBlendRange       (double range);
   void setBlueSaturationOffset    (double offset);
   void setBlueIntensityOffset     (double offset);

   void setMagentaHueOffset        (double offset);
   void setMagentaHueLowRange      (double range);
   void setMagentaHueHighRange     (double range);
   void setMagentaHueBlendRange    (double range);
   void setMagentaSaturationOffset (double offset);
   void setMagentaIntensityOffset  (double offset);

   double getHueOffset             (int color_group) const;
   double getHueLowRange           (int color_group) const;
   double getHueHighRange          (int color_group) const;
   double getHueBlendRange         (int color_group) const;
   double getSaturationOffset      (int color_group) const;
   double getIntensityOffset       (int color_group) const;
   
   double getMasterHueOffset          () const;
   double getMasterSaturationOffset   () const;
   double getMasterIntensityOffset    () const;
   double getMasterIntensityLowClip   () const;
   double getMasterIntensityHighClip  () const;
   
   double getRedHueOffset             () const;
   double getRedHueLowRange           () const;
   double getRedHueHighRange          () const;
   double getRedHueBlendRange         () const;
   double getRedSaturationOffset      () const;
   double getRedIntensityOffset       () const;

   double getYellowHueOffset          () const;
   double getYellowHueLowRange        () const;
   double getYellowHueHighRange       () const;
   double getYellowHueBlendRange      () const;
   double getYellowSaturationOffset   () const;
   double getYellowIntensityOffset    () const;

   double getGreenHueOffset           () const;
   double getGreenHueLowRange         () const;
   double getGreenHueHighRange        () const;
   double getGreenHueBlendRange       () const;
   double getGreenSaturationOffset    () const;
   double getGreenIntensityOffset     () const;

   double getCyanHueOffset            () const;
   double getCyanHueLowRange          () const;
   double getCyanHueHighRange         () const;
   double getCyanHueBlendRange        () const;
   double getCyanSaturationOffset     () const;
   double getCyanIntensityOffset      () const;

   double getBlueHueOffset            () const;
   double getBlueHueLowRange          () const;
   double getBlueHueHighRange         () const;
   double getBlueHueBlendRange        () const;
   double getBlueSaturationOffset     () const;
   double getBlueIntensityOffset      () const;

   double getMagentaHueOffset         () const;
   double getMagentaHueLowRange       () const;
   double getMagentaHueHighRange      () const;
   double getMagentaHueBlendRange     () const;
   double getMagentaSaturationOffset  () const;
   double getMagentaIntensityOffset   () const;

   void   setWhiteObjectClip          (double clip);
   double getWhiteObjectClip          () const;
   void   resetWhiteObjectClip        ();

   void resetGroup(int color_group);
   void resetAll();
   void resetMaster();
   void resetRed();
   void resetYellow();
   void resetGreen();
   void resetCyan();
   void resetBlue();
   void resetMagenta();
   
protected:
   void   allocate(const ossimIrect& rect);
   void   verifyEnabled();
   double calculateMinNormValue();

   ossimRefPtr<ossimImageData> theTile;
   double*                     theBuffer;
   double                      theNormalizedMinPix;

   double theMasterHueOffset;
   double theMasterSaturationOffset;
   double theMasterIntensityOffset;
   double theMasterIntensityLowClip;
   double theMasterIntensityHighClip;

   double theRedHueOffset;
   double theRedHueLowRange;
   double theRedHueHighRange;
   double theRedHueBlendRange;
   double theRedSaturationOffset;
   double theRedIntensityOffset;

   double theYellowHueOffset;
   double theYellowHueLowRange;
   double theYellowHueHighRange;
   double theYellowHueBlendRange;
   double theYellowSaturationOffset;
   double theYellowIntensityOffset;

   double theGreenHueOffset;
   double theGreenHueLowRange;
   double theGreenHueHighRange;
   double theGreenHueBlendRange;
   double theGreenSaturationOffset;
   double theGreenIntensityOffset;

   double theCyanHueOffset;
   double theCyanHueLowRange;
   double theCyanHueHighRange;
   double theCyanHueBlendRange;
   double theCyanSaturationOffset;
   double theCyanIntensityOffset;

   double theBlueHueOffset;
   double theBlueHueLowRange;
   double theBlueHueHighRange;
   double theBlueHueBlendRange;
   double theBlueSaturationOffset;
   double theBlueIntensityOffset;

   double theMagentaHueOffset;
   double theMagentaHueLowRange;
   double theMagentaHueHighRange;
   double theMagentaHueBlendRange;
   double theMagentaSaturationOffset;
   double theMagentaIntensityOffset;

   double theWhiteObjectClip;

   TYPE_DATA
};

#endif

APT Browse - Built by Thomas Orozco.