[Git][debian-gis-team/ossim][master] 2 commits: Add upstream patch to fix FTBFS with GCC 8. (closes: #897829)
Bas Couwenberg
gitlab at salsa.debian.org
Tue May 29 15:20:34 BST 2018
Bas Couwenberg pushed to branch master at Debian GIS Project / ossim
Commits:
970d5acb by Bas Couwenberg at 2018-05-29T15:21:03+02:00
Add upstream patch to fix FTBFS with GCC 8. (closes: #897829)
- - - - -
2f8f43a0 by Bas Couwenberg at 2018-05-29T15:51:45+02:00
Set distribution to unstable.
- - - - -
3 changed files:
- debian/changelog
- + debian/patches/0001-The-bitmask-was-calling-pixel-flipper-directly.-I-th.patch
- debian/patches/series
Changes:
=====================================
debian/changelog
=====================================
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,8 +1,11 @@
-ossim (2.3.2-2) UNRELEASED; urgency=medium
+ossim (2.3.2-2) unstable; urgency=medium
+ * Team upload.
* Strip trailing whitespace from rules file.
+ * Add upstream patch to fix FTBFS with GCC 8.
+ (closes: #897829)
- -- Bas Couwenberg <sebastic at debian.org> Mon, 07 May 2018 21:34:38 +0200
+ -- Bas Couwenberg <sebastic at debian.org> Tue, 29 May 2018 15:50:41 +0200
ossim (2.3.2-1) unstable; urgency=medium
=====================================
debian/patches/0001-The-bitmask-was-calling-pixel-flipper-directly.-I-th.patch
=====================================
--- /dev/null
+++ b/debian/patches/0001-The-bitmask-was-calling-pixel-flipper-directly.-I-th.patch
@@ -0,0 +1,1781 @@
+Description: The bitmask was calling pixel flipper directly.
+ I think this is having problems with template methods.
+ Instead use the memory source and connect flipper to it
+Author: Garrett Potts <gpotts at radiantblue.com>
+Origin: https://github.com/ossimlabs/ossim/commit/545b65169484ad0d5237bf5c6d0279558538b62b
+Bug: https://github.com/ossimlabs/ossim/issues/200
+Bug-Debian: https://bugs.debian.org/897829
+
+--- a/include/ossim/imaging/ossimBitMaskWriter.h
++++ b/include/ossim/imaging/ossimBitMaskWriter.h
+@@ -16,6 +16,7 @@
+ #include <ossim/base/ossimIpt.h>
+ #include <ossim/base/ossimOutputSource.h>
+ #include <ossim/imaging/ossimPixelFlipper.h>
++#include <ossim/imaging/ossimMemoryImageSource.h>
+ #include <vector>
+
+ class ossimFilename;
+@@ -123,7 +124,8 @@ protected:
+ ossimIpt computeImageSize(ossim_uint32 rlevel, ossimImageData* tile) const;
+
+ ossimRefPtr<ossimPixelFlipper> m_flipper;
+- vector<ossim_uint8*> m_buffers;
++ ossimRefPtr<ossimMemoryImageSource> m_memoryImage;
++ vector<ossim_uint8 *> m_buffers;
+ vector<ossimIpt> m_bufferSizes;
+ ossim_uint32 m_startingResLevel;
+ ossimIpt m_imageSize; //!< Size of full res source image
+--- a/include/ossim/imaging/ossimPixelFlipper.h
++++ b/include/ossim/imaging/ossimPixelFlipper.h
+@@ -206,15 +206,18 @@ public:
+ virtual void setProperty(ossimRefPtr<ossimProperty> property);
+ virtual void getPropertyNames(std::vector<ossimString>& propertyNames)const;
+
+- //! This object can be used outside of an image chain for offline processing of existing tile.
+- template <class T> void flipPixels(T dummy, ossimImageData* inpuTile, ossim_uint32 resLevel);
+
+ protected:
+ /** destructor */
+ virtual ~ossimPixelFlipper();
+- template <class T> void clipTile(T dummy,
+- ossimImageData* inpuTile,
+- ossim_uint32 resLevel);
++ //! This object can be used outside of an image chain for offline processing of existing tile.
++ template <class T>
++ void flipPixels(T dummy, ossimImageData *inpuTile, ossim_uint32 resLevel);
++
++ template <class T>
++ void clipTile(T dummy,
++ ossimImageData *inpuTile,
++ ossim_uint32 resLevel);
+
+ /**
+ * Verifies pixel is in range.
+--- a/src/imaging/ossimBitMaskWriter.cpp
++++ b/src/imaging/ossimBitMaskWriter.cpp
+@@ -8,7 +8,7 @@
+ //
+ // Description: Contains implementation of class for computing a mask from an input image.
+ // The mask is stored in a compressed format where one byte represents 8 bit-masks for masking
+-// 8 image pixels.
++// 8 image pixels.
+ //*************************************************************************************************
+ // $Id: ossimBitMaskWriter.cpp 3081 2011-12-22 16:34:12Z oscar.kramer $
+
+@@ -20,16 +20,16 @@
+ #include <ossim/imaging/ossimImageData.h>
+ #include <ossim/imaging/ossimImageHandler.h>
+
+-const char* ossimBitMaskWriter::MASK_FILE_MAGIC_NUMBER = "OSSIM_BIT_MASK";
+-const char* ossimBitMaskWriter::BM_STARTING_RLEVEL_KW = "starting_rlevel";
++const char *ossimBitMaskWriter::MASK_FILE_MAGIC_NUMBER = "OSSIM_BIT_MASK";
++const char *ossimBitMaskWriter::BM_STARTING_RLEVEL_KW = "starting_rlevel";
+
+ //*************************************************************************************************
+ // Constructor accepts handler to the source imagery being used to compute the mask.
+ //*************************************************************************************************
+ ossimBitMaskWriter::ossimBitMaskWriter()
+- :
+- m_flipper(0),
+- m_startingResLevel(0)
++ : m_flipper(0),
++ m_memoryImage(0),
++ m_startingResLevel(0)
+ {
+ }
+
+@@ -58,7 +58,7 @@ bool ossimBitMaskWriter::open()
+ {
+ // Nothing to do yet. Eventually want to open the output stream here and write the buffer after
+ // each R-level is completed, so we don't need to keep vector of buffers in memory.
+- return true;
++ return true;
+ }
+
+ //*************************************************************************************************
+@@ -67,10 +67,10 @@ bool ossimBitMaskWriter::open()
+ void ossimBitMaskWriter::reset()
+ {
+ // Wipe the mask buffers:
+- vector<ossim_uint8*>::iterator iter = m_buffers.begin();
++ vector<ossim_uint8 *>::iterator iter = m_buffers.begin();
+ while (iter != m_buffers.end())
+ {
+- delete [] (*iter);
++ delete[](*iter);
+ iter++;
+ }
+ m_buffers.clear();
+@@ -116,49 +116,14 @@ void ossimBitMaskWriter::generateMask(os
+ if (!m_flipper.valid())
+ initializeFlipper();
+
+- // The flipper is used to identify null pixels since it has more sophisticated filtering
+- // than available from the tile object:
+- switch (tile->getScalarType())
+- {
+- case OSSIM_UCHAR:
+- m_flipper->flipPixels(ossim_uint8(0), tile.get(), rLevel);
+- break;
+- case OSSIM_UINT16:
+- case OSSIM_USHORT11:
+- case OSSIM_USHORT12:
+- case OSSIM_USHORT13:
+- case OSSIM_USHORT14:
+- case OSSIM_USHORT15:
+- m_flipper->flipPixels(ossim_uint16(0), tile.get(), rLevel);
+- break;
+- case OSSIM_SSHORT16:
+- m_flipper->flipPixels(ossim_sint16(0), tile.get(), rLevel);
+- break;
+- case OSSIM_UINT32:
+- m_flipper->flipPixels(ossim_uint32(0), tile.get(), rLevel);
+- break;
+- case OSSIM_SINT32:
+- m_flipper->flipPixels(ossim_sint32(0), tile.get(), rLevel);
+- break;
+- case OSSIM_FLOAT32:
+- case OSSIM_NORMALIZED_FLOAT:
+- m_flipper->flipPixels(float(0), tile.get(), rLevel);
+- break;
+- case OSSIM_NORMALIZED_DOUBLE:
+- case OSSIM_FLOAT64:
+- m_flipper->flipPixels(ossim_float64(0), tile.get(), rLevel);
+- break;
+- case OSSIM_SCALAR_UNKNOWN:
+- default:
+- ossimNotify(ossimNotifyLevel_WARN) << "ossimBitMaskWriter::generateMask()-- "
+- "Unsupported scalar type!" << endl;
+- break;
+- }
+-
+- ossimIpt image_size = computeImageSize(rLevel, tile.get());
+- ossim_uint32 num_mask_cols = (image_size.x+7)/8; // size of mask buffer after compression
++ ossimRefPtr<ossimImageData> flipTile;
++ m_memoryImage->setImage(tile);
++ m_flipper->initialize();
++ flipTile = m_flipper->getTile(tile->getImageRectangle());
++ ossimIpt image_size = computeImageSize(rLevel, flipTile.get());
++ ossim_uint32 num_mask_cols = (image_size.x + 7) / 8; // size of mask buffer after compression
+ ossim_uint32 num_mask_rows = image_size.y;
+- ossim_uint8* maskbuf = 0;
++ ossim_uint8 *maskbuf = 0;
+
+ // Check if mask buffer for this R-level has already been allocated:
+ if (m_buffers.size() <= mask_rlevel)
+@@ -172,32 +137,31 @@ void ossimBitMaskWriter::generateMask(os
+ else
+ maskbuf = m_buffers[mask_rlevel];
+
+- ossim_uint32 mask_index=0, tile_index=0, start_bit=0;
+- ossimIrect tile_rect (tile->getImageRectangle());
+- ossimIpt ul (tile_rect.ul());
+- ossimIpt lr (tile_rect.lr());
++ ossim_uint32 mask_index = 0, tile_index = 0, start_bit = 0;
++ ossimIrect tile_rect(flipTile->getImageRectangle());
++ ossimIpt ul(tile_rect.ul());
++ ossimIpt lr(tile_rect.lr());
+
+ // Scan each pixel in the source tile and decide on mask value:
+- for (int y=ul.y; (y<=lr.y)&&(y<image_size.y); y++)
++ for (int y = ul.y; (y <= lr.y) && (y < image_size.y); y++)
+ {
+- mask_index = y*num_mask_cols + ul.x/8;
++ mask_index = y * num_mask_cols + ul.x / 8;
+ start_bit = ul.x % 8; // may not start on even mask byte boundary
+
+- for (int x=ul.x; (x<=lr.x); /* incremented in bit loop below */ )
++ for (int x = ul.x; (x <= lr.x); /* incremented in bit loop below */)
+ {
+- if ( x < image_size.x )
++ if (x < image_size.x)
+ {
+ // Process 8 samples and pack resultant mask into one byte:
+ maskbuf[mask_index] = 0;
+- for (ossim_uint32 mask_bit=start_bit; mask_bit<8; ++mask_bit)
++ for (ossim_uint32 mask_bit = start_bit; mask_bit < 8; ++mask_bit)
+ {
+- // Decide whether to mask depending on pixel flipper outputting a NULL pixel.
+- // if (tile->isNull(tile_index++))
+- if (tile->isNull(tile_index++))
+- maskbuf[mask_index] &= MASK_BITS_0[mask_bit];
++ // Decide whether to mask depending on pixel flipper outputting a NULL pixel.
++ if (flipTile->isNull(tile_index++))
++ maskbuf[mask_index] &= MASK_BITS_0[mask_bit];
+ else
+ maskbuf[mask_index] |= MASK_BITS_1[mask_bit];
+-
++
+ // Advance the pixel column and check for end of image rect:
+ ++x;
+ if ((x >= image_size.x) || (x > lr.x))
+@@ -209,7 +173,7 @@ void ossimBitMaskWriter::generateMask(os
+ else
+ {
+ ++x;
+-
++
+ ++tile_index;
+ }
+ }
+@@ -223,37 +187,38 @@ void ossimBitMaskWriter::generateMask(os
+ //*************************************************************************************************
+ void ossimBitMaskWriter::close()
+ {
+- static const char* MODULE = "ossimBitMaskWriter::writeMask()";
+- static const ossimString MASK_EXTENSION ("mask");
++ static const char *MODULE = "ossimBitMaskWriter::writeMask()";
++ static const ossimString MASK_EXTENSION("mask");
+
+ // Open the output file. Use default name if none provided.
+ if (theOutputName.empty()) // Couldn't figure out the name
+ {
+- ossimNotify(ossimNotifyLevel_WARN)<<MODULE<<" -- Error encountered trying to create mask file"
+- " for writing because output file name was never initialized.";
++ ossimNotify(ossimNotifyLevel_WARN) << MODULE << " -- Error encountered trying to create mask file"
++ " for writing because output file name was never initialized.";
+ return;
+ }
+
+- ofstream maskFileStream (theOutputName.chars(), ios::out|ios::binary);
++ ofstream maskFileStream(theOutputName.chars(), ios::out | ios::binary);
+ if (!maskFileStream.is_open())
+ {
+- ossimNotify(ossimNotifyLevel_WARN)<<MODULE<<" -- Error encountered trying to create mask file"
+- "<"<<theOutputName<<"> for writing. Cannot write mask.";
++ ossimNotify(ossimNotifyLevel_WARN) << MODULE << " -- Error encountered trying to create mask file"
++ "<"
++ << theOutputName << "> for writing. Cannot write mask.";
+ return;
+ }
+
+ // Write the header info:
+- ossim_uint32 num_rlevels = (ossim_uint32) m_buffers.size();
+- maskFileStream << MASK_FILE_MAGIC_NUMBER <<" "<< m_startingResLevel <<" "<< num_rlevels<<" ";
+- for (ossim_uint32 r=0; r<num_rlevels; r++)
+- maskFileStream << m_bufferSizes[r].x <<" "<< m_bufferSizes[r].y <<" ";
++ ossim_uint32 num_rlevels = (ossim_uint32)m_buffers.size();
++ maskFileStream << MASK_FILE_MAGIC_NUMBER << " " << m_startingResLevel << " " << num_rlevels << " ";
++ for (ossim_uint32 r = 0; r < num_rlevels; r++)
++ maskFileStream << m_bufferSizes[r].x << " " << m_bufferSizes[r].y << " ";
+ maskFileStream << ends;
+
+ // Loop over each res level and write buffers to disk:
+- for (ossim_uint32 rlevel = 0; rlevel<num_rlevels; ++rlevel)
++ for (ossim_uint32 rlevel = 0; rlevel < num_rlevels; ++rlevel)
+ {
+ ossim_uint32 bufsize = m_bufferSizes[rlevel].x * m_bufferSizes[rlevel].y;
+- maskFileStream.write((char*)(m_buffers[rlevel]), bufsize);
++ maskFileStream.write((char *)(m_buffers[rlevel]), bufsize);
+ }
+
+ maskFileStream.close();
+@@ -266,7 +231,7 @@ void ossimBitMaskWriter::close()
+ //! Constructor accepts keywordlist with all info necessary to compute a mask. The caller will
+ //! still need to call writeMask().
+ //*************************************************************************************************
+-bool ossimBitMaskWriter::loadState(const ossimKeywordlist& kwl, const char* prefix)
++bool ossimBitMaskWriter::loadState(const ossimKeywordlist &kwl, const char *prefix)
+ {
+ // static const char* MODULE = "ossimBitMaskWriter::writeMask(kwl)";
+
+@@ -289,7 +254,7 @@ bool ossimBitMaskWriter::loadState(const
+ }
+
+ //*************************************************************************************************
+-//
++//
+ //*************************************************************************************************
+ void ossimBitMaskWriter::initializeFlipper()
+ {
+@@ -300,6 +265,11 @@ void ossimBitMaskWriter::initializeFlipp
+ m_flipper->setTargetValue(0);
+ m_flipper->setReplacementValue(0);
+ }
++ if (!m_memoryImage)
++ {
++ m_memoryImage = new ossimMemoryImageSource();
++ m_flipper->connectMyInputTo(m_memoryImage.get());
++ }
+
+ // This method gets called when an input connection is made as well as other times, so keep an
+ // eye out for valid input connection:
+@@ -310,23 +280,23 @@ void ossimBitMaskWriter::initializeFlipp
+ }
+
+ //*************************************************************************************************
+-//
++//
+ //*************************************************************************************************
+-bool ossimBitMaskWriter::canConnectMyInputTo(ossim_int32 /*myInputIndex*/,
+- const ossimConnectableObject* object) const
++bool ossimBitMaskWriter::canConnectMyInputTo(ossim_int32 /*myInputIndex*/,
++ const ossimConnectableObject *object) const
+ {
+- const ossimImageSource* ois = dynamic_cast<const ossimImageSource*>(object);
++ const ossimImageSource *ois = dynamic_cast<const ossimImageSource *>(object);
+ return (ois != NULL);
+ }
+
+ //*************************************************************************************************
+-//
++//
+ //*************************************************************************************************
+-ossim_int32 ossimBitMaskWriter::connectMyInputTo (ossimConnectableObject *inputObject,
+- bool makeOutputConnection,
+- bool createEventFlag)
++ossim_int32 ossimBitMaskWriter::connectMyInputTo(ossimConnectableObject *inputObject,
++ bool makeOutputConnection,
++ bool createEventFlag)
+ {
+- ossimImageSource* input_source = dynamic_cast<ossimImageSource*>(inputObject);
++ ossimImageSource *input_source = dynamic_cast<ossimImageSource *>(inputObject);
+ if (input_source == NULL)
+ return -1;
+
+@@ -335,42 +305,42 @@ ossim_int32 ossimBitMaskWriter::connectM
+
+ // This input should be an image handler, but may need to search the objects inputs in case
+ // it is chained:
+- ossimImageHandler* handler = dynamic_cast<ossimImageHandler*>(input_source);
++ ossimImageHandler *handler = dynamic_cast<ossimImageHandler *>(input_source);
+ if (handler == NULL)
+ {
+ // Need to search:
+ ossimTypeNameVisitor visitor(ossimString("ossimImageHandler"),
+ true,
+- ossimVisitor::VISIT_CHILDREN|ossimVisitor::VISIT_INPUTS);
+-
++ ossimVisitor::VISIT_CHILDREN | ossimVisitor::VISIT_INPUTS);
++
+ input_source->accept(visitor);
+ ossimRefPtr<ossimObject> obj = visitor.getObject();
+- if ( obj.valid() )
++ if (obj.valid())
+ {
+- handler = dynamic_cast<ossimImageHandler*>( obj.get() );
++ handler = dynamic_cast<ossimImageHandler *>(obj.get());
+ }
+ }
+
+ // Should have a handler:
+ if (!handler)
+- {
++ {
+ disconnectAllInputs();
+ return -1;
+ }
+
+ // A handler has been identified. Need the filename:
+- ossimFilename imageFile = handler->getFilename();
++ ossimFilename imageFile = handler->getFilename();
+ if (imageFile.contains("ovr.tmp"))
+ {
+ // The handler is actually an overview, need some massaging to work since the overview may
+ // not have an R0 entry and R1 rect must be requested instead:
+- m_imageSize = handler->getBoundingRect(1).size() * 2;
++ m_imageSize = handler->getBoundingRect(1).size() * 2;
+ imageFile = imageFile.noExtension();
+ }
+ else
+ {
+ // This is normal image handler so it is OK to request R0 rect:
+- m_imageSize = handler->getBoundingRect(0).size();
++ m_imageSize = handler->getBoundingRect(0).size();
+ }
+ if (theOutputName.empty())
+ theOutputName = imageFile.setExtension("mask");
+@@ -388,21 +358,21 @@ ossim_int32 ossimBitMaskWriter::connectM
+ //! Since overviews may not yet exist when the mask is being written, we must compute the
+ //! size of the mask buffer based on the original R0 image size.
+ //*************************************************************************************************
+-ossimIpt ossimBitMaskWriter::computeImageSize(ossim_uint32 rlevel, ossimImageData* tile) const
++ossimIpt ossimBitMaskWriter::computeImageSize(ossim_uint32 rlevel, ossimImageData *tile) const
+ {
+ if (rlevel == 0)
+ return m_imageSize;
+
+- ossimIpt isize (m_imageSize);
+- for (ossim_uint32 r=1; r<=rlevel; r++)
++ ossimIpt isize(m_imageSize);
++ for (ossim_uint32 r = 1; r <= rlevel; r++)
+ {
+ isize.x = (isize.x + 1) / 2;
+ isize.y = (isize.y + 1) / 2;
+ }
+
+ // Adjust size n X direction to even mask boundary:
+- ossimIpt tile_size (tile->getWidth(), tile->getHeight());
+- isize.x = ((int)(isize.x+7)/8) * 8;
++ ossimIpt tile_size(tile->getWidth(), tile->getHeight());
++ isize.x = ((int)(isize.x + 7) / 8) * 8;
+
+ return isize;
+ }
+@@ -422,11 +392,11 @@ bool ossimBitMaskWriter::buildOverviews(
+ return false;
+ if (m_buffers.size() == total_num_rlevels)
+ return true; // nothing to do
+- ossim_uint32 ref_rlevel = m_startingResLevel + (ossim_uint32) m_buffers.size() - 1;
++ ossim_uint32 ref_rlevel = m_startingResLevel + (ossim_uint32)m_buffers.size() - 1;
+ ossim_uint32 ovr_rlevel = ref_rlevel + 1;
+
+- ossimIpt ref_size (m_bufferSizes[ref_rlevel-m_startingResLevel]);
+- ossim_uint8 *ref_buf = m_buffers[ref_rlevel-m_startingResLevel];
++ ossimIpt ref_size(m_bufferSizes[ref_rlevel - m_startingResLevel]);
++ ossim_uint8 *ref_buf = m_buffers[ref_rlevel - m_startingResLevel];
+ ossim_uint32 ref_index = 0, ovr_index = 0;
+ ossim_uint8 *ovr_buf = 0;
+ ossim_uint32 size_of_refbuf = ref_size.x * ref_size.y;
+@@ -435,7 +405,7 @@ bool ossimBitMaskWriter::buildOverviews(
+ while (ovr_rlevel != total_num_rlevels)
+ {
+ // Allocate the buffer at this R-level:
+- ossimIpt ovr_size ((ref_size.x+1)/2, (ref_size.y+1)/2);
++ ossimIpt ovr_size((ref_size.x + 1) / 2, (ref_size.y + 1) / 2);
+ ossim_uint32 size_of_ovrbuf = ovr_size.x * ovr_size.y;
+ if (size_of_ovrbuf == 0)
+ return false;
+@@ -446,22 +416,22 @@ bool ossimBitMaskWriter::buildOverviews(
+
+ // Loop over each output overview pixel, considering the underlying rlevel (equivalent to
+ // nearest-neighbor resampling for overview at 2X decimation):
+- for (int y=0; y<ovr_size.y; y++)
++ for (int y = 0; y < ovr_size.y; y++)
+ {
+- ref_index = 2*y*ref_size.x;
+- ovr_index = y*ovr_size.x;
++ ref_index = 2 * y * ref_size.x;
++ ovr_index = y * ovr_size.x;
+
+- for (int x=0; x<ovr_size.x; x++)
++ for (int x = 0; x < ovr_size.x; x++)
+ {
+ ossim_uint8 a = 0;
+ ossim_uint8 b = 0;
+ if (ref_index < size_of_refbuf)
+ {
+ a = ref_buf[ref_index++];
+- if ((x < (ovr_size.x-1)) || !(ref_size.x & 1))
++ if ((x < (ovr_size.x - 1)) || !(ref_size.x & 1))
+ b = ref_buf[ref_index++];
+ }
+- ovr_buf[ovr_index++] = ( (a & 0x80) |
++ ovr_buf[ovr_index++] = ((a & 0x80) |
+ ((a & 0x20) << 1) |
+ ((a & 0x08) << 2) |
+ ((a & 0x02) << 3) |
+@@ -469,7 +439,6 @@ bool ossimBitMaskWriter::buildOverviews(
+ ((b & 0x20) >> 3) |
+ ((b & 0x08) >> 2) |
+ ((b & 0x02) >> 1));
+-
+ }
+ }
+
+@@ -482,4 +451,3 @@ bool ossimBitMaskWriter::buildOverviews(
+
+ return true;
+ }
+-
+--- a/src/imaging/ossimPixelFlipper.cpp
++++ b/src/imaging/ossimPixelFlipper.cpp
+@@ -11,7 +11,6 @@
+ //*************************************************************************
+ // $Id: ossimPixelFlipper.cpp 21631 2012-09-06 18:10:55Z dburken $
+
+-
+ #include <ossim/imaging/ossimPixelFlipper.h>
+ #include <ossim/base/ossimTrace.h>
+ #include <ossim/base/ossimNotifyContext.h>
+@@ -25,14 +24,14 @@ RTTI_DEF1(ossimPixelFlipper, "ossimPixel
+
+ static ossimTrace traceDebug("ossimPixelFlipper:debug");
+
+-const char ossimPixelFlipper::PF_TARGET_VALUE_KW[] = "target_value";
+-const char ossimPixelFlipper::PF_TARGET_RANGE_KW[] = "target_range";
++const char ossimPixelFlipper::PF_TARGET_VALUE_KW[] = "target_value";
++const char ossimPixelFlipper::PF_TARGET_RANGE_KW[] = "target_range";
+ const char ossimPixelFlipper::PF_REPLACEMENT_VALUE_KW[] = "replacement_value";
+-const char ossimPixelFlipper::PF_REPLACEMENT_MODE_KW[] = "replacement_mode";
+-const char ossimPixelFlipper::PF_CLAMP_VALUE_KW[] = "clamp_value"; // deprecated by clamp_value_hi
+-const char ossimPixelFlipper::PF_CLAMP_VALUE_LO_KW[] = "clamp_value_lo";
+-const char ossimPixelFlipper::PF_CLAMP_VALUE_HI_KW[] = "clamp_value_hi";
+-const char ossimPixelFlipper::PF_CLIP_MODE_KW[] = "border_clip_mode";
++const char ossimPixelFlipper::PF_REPLACEMENT_MODE_KW[] = "replacement_mode";
++const char ossimPixelFlipper::PF_CLAMP_VALUE_KW[] = "clamp_value"; // deprecated by clamp_value_hi
++const char ossimPixelFlipper::PF_CLAMP_VALUE_LO_KW[] = "clamp_value_lo";
++const char ossimPixelFlipper::PF_CLAMP_VALUE_HI_KW[] = "clamp_value_hi";
++const char ossimPixelFlipper::PF_CLIP_MODE_KW[] = "border_clip_mode";
+
+ static const char TARGET_LOWER_LIMIT_PROP_NAME[] = "target_range_lower_limit";
+ static const char TARGET_UPPER_LIMIT_PROP_NAME[] = "target_range_upper_limit";
+@@ -41,9 +40,8 @@ static const char TARGET_UPPER_LIMIT_PRO
+ static const char OSSIM_ID[] = "$Id: ossimPixelFlipper.cpp 21631 2012-09-06 18:10:55Z dburken $";
+ #endif
+
+-ossimPixelFlipper::ossimPixelFlipper(ossimObject* owner)
+- :
+- ossimImageSourceFilter(owner),
++ossimPixelFlipper::ossimPixelFlipper(ossimObject *owner)
++ : ossimImageSourceFilter(owner),
+ theTargetValueLo(0.0),
+ theTargetValueHi(0.0),
+ theReplacementValue(1.0),
+@@ -56,122 +54,126 @@ ossimPixelFlipper::ossimPixelFlipper(oss
+ if (traceDebug())
+ {
+ ossimNotify(ossimNotifyLevel_DEBUG)
+- << "ossimPixelFlipper::ossimPixelFlipper entered...\n";
++ << "ossimPixelFlipper::ossimPixelFlipper entered...\n";
+ #ifdef OSSIM_ID_ENABLED
+ ossimNotify(ossimNotifyLevel_DEBUG)
+- << "OSSIM_ID: " << OSSIM_ID << "\n";
+-#endif
++ << "OSSIM_ID: " << OSSIM_ID << "\n";
++#endif
+ }
+-
++
+ setDescription(ossimString("Pixel Flipper"));
+ enableSource();
+ }
+
+ ossimPixelFlipper::~ossimPixelFlipper()
+-{}
++{
++}
+
+ ossimRefPtr<ossimImageData> ossimPixelFlipper::getTile(
+- const ossimIrect& tile_rect, ossim_uint32 resLevel)
++ const ossimIrect &tile_rect, ossim_uint32 resLevel)
+ {
+
+- if(!theInputConnection)
++ if (!theInputConnection)
+ {
+ return 0;
+ }
+
+ // Fetch tile from pointer from the input source.
+ ossimRefPtr<ossimImageData> inputTile =
+- theInputConnection->getTile(tile_rect, resLevel);
+-
+- if (!inputTile.valid() || !isSourceEnabled()) return inputTile;
+-
+- if (!inputTile->getBuf()) return inputTile;
+-
++ theInputConnection->getTile(tile_rect, resLevel);
++
++ if (!inputTile.valid() || !isSourceEnabled())
++ return inputTile;
++
++ if (!inputTile->getBuf())
++ return inputTile;
++
+ // Lock for the length of this method.
+- std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
+-
++ std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
++
+ // Call the appropriate load method.
+ switch (inputTile->getScalarType())
+ {
+-
+- case OSSIM_UCHAR:
+- {
+- flipPixels(ossim_uint8(0), inputTile.get(), resLevel);
+- break;
+- }
+-
+- case OSSIM_UINT16:
+- case OSSIM_USHORT11:
+- case OSSIM_USHORT12:
+- case OSSIM_USHORT13:
+- case OSSIM_USHORT14:
+- case OSSIM_USHORT15:
+- {
+- flipPixels(ossim_uint16(0), inputTile.get(), resLevel);
+- break;
+- }
+-
+- case OSSIM_SSHORT16:
+- {
+- flipPixels(ossim_sint16(0), inputTile.get(), resLevel);
+- break;
+- }
+- case OSSIM_UINT32:
+- {
+- flipPixels(ossim_uint32(0), inputTile.get(), resLevel);
+- break;
+- }
+- case OSSIM_SINT32:
+- {
+- flipPixels(ossim_sint32(0), inputTile.get(), resLevel);
+- break;
+- }
+- case OSSIM_FLOAT32:
+- case OSSIM_NORMALIZED_FLOAT:
+- {
+- flipPixels(float(0), inputTile.get(), resLevel);
+- break;
+- }
+-
+- case OSSIM_NORMALIZED_DOUBLE:
+- case OSSIM_FLOAT64:
+- {
+- flipPixels(ossim_float64(0), inputTile.get(), resLevel);
+- break;
+- }
+-
+- case OSSIM_SCALAR_UNKNOWN:
+- default:
+- {
+- ossimNotify(ossimNotifyLevel_WARN)
+- << "ossimPixelFlipper::getTile Unsupported scalar type!" << endl;
+- break;
+- }
++
++ case OSSIM_UCHAR:
++ {
++ flipPixels(ossim_uint8(0), inputTile.get(), resLevel);
++ break;
++ }
++
++ case OSSIM_UINT16:
++ case OSSIM_USHORT11:
++ case OSSIM_USHORT12:
++ case OSSIM_USHORT13:
++ case OSSIM_USHORT14:
++ case OSSIM_USHORT15:
++ {
++ flipPixels(ossim_uint16(0), inputTile.get(), resLevel);
++ break;
+ }
+-
++
++ case OSSIM_SSHORT16:
++ {
++ flipPixels(ossim_sint16(0), inputTile.get(), resLevel);
++ break;
++ }
++ case OSSIM_UINT32:
++ {
++ flipPixels(ossim_uint32(0), inputTile.get(), resLevel);
++ break;
++ }
++ case OSSIM_SINT32:
++ {
++ flipPixels(ossim_sint32(0), inputTile.get(), resLevel);
++ break;
++ }
++ case OSSIM_FLOAT32:
++ case OSSIM_NORMALIZED_FLOAT:
++ {
++ flipPixels(ossim_float32(0), inputTile.get(), resLevel);
++ break;
++ }
++
++ case OSSIM_NORMALIZED_DOUBLE:
++ case OSSIM_FLOAT64:
++ {
++ flipPixels(ossim_float64(0), inputTile.get(), resLevel);
++ break;
++ }
++
++ case OSSIM_SCALAR_UNKNOWN:
++ default:
++ {
++ ossimNotify(ossimNotifyLevel_WARN)
++ << "ossimPixelFlipper::getTile Unsupported scalar type!" << endl;
++ break;
++ }
++ }
++
+ inputTile->validate();
+ return inputTile;
+ }
+
+ template <class T>
+ void ossimPixelFlipper::flipPixels(T /* dummy */,
+- ossimImageData* inputTile,
++ ossimImageData *inputTile,
+ ossim_uint32 resLevel)
+ {
+- if (!inputTile) return;
++ if (!inputTile)
++ return;
+
+- T targetLo = static_cast<T>(theTargetValueLo);
+- T targetHi = static_cast<T>(theTargetValueHi);
++ T targetLo = static_cast<T>(theTargetValueLo);
++ T targetHi = static_cast<T>(theTargetValueHi);
+ T replacement = static_cast<T>(theReplacementValue);
+- T clampLo = static_cast<T>(theClampValueLo);
+- T clampHi = static_cast<T>(theClampValueHi);
++ T clampLo = static_cast<T>(theClampValueLo);
++ T clampHi = static_cast<T>(theClampValueHi);
+
+ // Get pointers to data for each band.
+ ossim_uint32 bands = inputTile->getNumberOfBands();
+ ossim_uint32 band;
+- T** buf = new T*[bands];
+- for(band=0; band<bands; ++band)
+- buf[band] = static_cast<T*>(inputTile->getBuf(band));
++ T **buf = new T *[bands];
++ for (band = 0; band < bands; ++band)
++ buf[band] = static_cast<T *>(inputTile->getBuf(band));
+
+ ossimIrect rect = inputTile->getImageRectangle();
+ ossimIpt ul = rect.ul();
+@@ -184,7 +186,7 @@ void ossimPixelFlipper::flipPixels(T /*
+ bool needsTesting = false;
+ if ((theClipMode == BOUNDING_RECT) && (resLevel < theBoundingRects.size()))
+ {
+- if(!rect.intersects(theBoundingRects[resLevel]))
++ if (!rect.intersects(theBoundingRects[resLevel]))
+ is_outside_aoi = true;
+ else
+ needsTesting = !rect.completely_within(theBoundingRects[resLevel]);
+@@ -195,7 +197,7 @@ void ossimPixelFlipper::flipPixels(T /*
+ bool urFlag = theValidVertices[resLevel].isPointWithin(rect.ur());
+ bool lrFlag = theValidVertices[resLevel].isPointWithin(rect.lr());
+ bool llFlag = theValidVertices[resLevel].isPointWithin(rect.ll());
+- if((!ulFlag) && (!urFlag) && (!lrFlag) && (!llFlag))
++ if ((!ulFlag) && (!urFlag) && (!lrFlag) && (!llFlag))
+ is_outside_aoi = true;
+ else
+ needsTesting = !(ulFlag && urFlag && lrFlag && llFlag);
+@@ -203,18 +205,18 @@ void ossimPixelFlipper::flipPixels(T /*
+ if (is_outside_aoi)
+ {
+ // none of the tile is inside so just return with empty tile:
+- delete [] buf;
+- return;
++ delete[] buf;
++ return;
+ }
+
+- ossim_uint32 i = 0; // index into band buffers;
+- ossimIpt pixel_loc;
++ ossim_uint32 i = 0; // index into band buffers;
++ ossimIpt pixel_loc;
+ bool can_replace, found_candidate;
+
+ // Begin loop over each pixel in the tile. The individual bands are handled inside this loop:
+- for(pixel_loc.y = ul.y; pixel_loc.y <= lr.y; ++pixel_loc.y)
++ for (pixel_loc.y = ul.y; pixel_loc.y <= lr.y; ++pixel_loc.y)
+ {
+- for(pixel_loc.x = ul.x; pixel_loc.x <= lr.x; ++pixel_loc.x)
++ for (pixel_loc.x = ul.x; pixel_loc.x <= lr.x; ++pixel_loc.x)
+ {
+ // First consider if we need to test the pixel for border clipping:
+ if (needsTesting)
+@@ -228,12 +230,12 @@ void ossimPixelFlipper::flipPixels(T /*
+ if (!is_inside)
+ {
+ // Remap this pixel to the replacement value (all bands)
+- for (band=0; band<bands; ++band)
++ for (band = 0; band < bands; ++band)
+ buf[band][i] = replacement;
+
+ // Proceed to next pixel location:
+ ++i;
+- continue;
++ continue;
+ }
+ }
+
+@@ -244,7 +246,7 @@ void ossimPixelFlipper::flipPixels(T /*
+ {
+ case REPLACE_BAND_IF_TARGET:
+ case REPLACE_ALL_BANDS_IF_ANY_TARGET:
+- for (band=0; band<bands; ++band)
++ for (band = 0; band < bands; ++band)
+ {
+ if (!ossim::isnan(theClampValueLo) && (buf[band][i] < clampLo))
+ buf[band][i] = clampLo;
+@@ -253,16 +255,16 @@ void ossimPixelFlipper::flipPixels(T /*
+ }
+ break;
+
+- case REPLACE_BAND_IF_PARTIAL_TARGET:
++ case REPLACE_BAND_IF_PARTIAL_TARGET:
+ case REPLACE_ALL_BANDS_IF_PARTIAL_TARGET:
+- // First band loop to establish if pixel qualifies for replacement (at least one
++ // First band loop to establish if pixel qualifies for replacement (at least one
+ // band must be valid):
+ can_replace = false;
+ found_candidate = false;
+- for (band=0; (band < bands) && !(can_replace && found_candidate); ++band)
++ for (band = 0; (band < bands) && !(can_replace && found_candidate); ++band)
+ {
+ if ((!ossim::isnan(theClampValueLo) && (buf[band][i] < clampLo)) ||
+- (!ossim::isnan(theClampValueHi) && (buf[band][i] > clampHi)))
++ (!ossim::isnan(theClampValueHi) && (buf[band][i] > clampHi)))
+ found_candidate = true;
+ else
+ can_replace = true;
+@@ -271,7 +273,7 @@ void ossimPixelFlipper::flipPixels(T /*
+ {
+ // This pixel has at least one band with normal value, so need to rescan bands
+ // to find pixels that need replacing (are within the target range):
+- for (band=0; band<bands; ++band)
++ for (band = 0; band < bands; ++band)
+ {
+ if (!ossim::isnan(theClampValueLo) && (buf[band][i] < clampLo))
+ buf[band][i] = clampLo;
+@@ -282,10 +284,10 @@ void ossimPixelFlipper::flipPixels(T /*
+ break;
+
+ case REPLACE_ONLY_FULL_TARGETS:
+- // First band loop to establish if pixel qualifies for replacement (all
++ // First band loop to establish if pixel qualifies for replacement (all
+ // bands must be in target range):
+ can_replace = true;
+- for (band=0; (band < bands) && can_replace; ++band)
++ for (band = 0; (band < bands) && can_replace; ++band)
+ {
+ if ((ossim::isnan(theClampValueLo) || (buf[band][i] >= clampLo)) &&
+ (ossim::isnan(theClampValueHi) || (buf[band][i] <= clampHi)))
+@@ -293,8 +295,8 @@ void ossimPixelFlipper::flipPixels(T /*
+ }
+ if (can_replace)
+ {
+- // Map all pixels to replacement value:
+- for (band=0; band<bands; ++band)
++ // Map all pixels to replacement value:
++ for (band = 0; band < bands; ++band)
+ {
+ if (!ossim::isnan(theClampValueLo) && (buf[band][i] < clampLo))
+ buf[band][i] = clampLo;
+@@ -307,7 +309,7 @@ void ossimPixelFlipper::flipPixels(T /*
+
+ // Proceed to next pixel location:
+ ++i;
+- continue;
++ continue;
+ }
+
+ // If we got here (the continue statement was not reached) then
+@@ -315,20 +317,20 @@ void ossimPixelFlipper::flipPixels(T /*
+ switch (theReplacementMode)
+ {
+ case REPLACE_BAND_IF_TARGET:
+- for (band=0; band<bands; ++band)
++ for (band = 0; band < bands; ++band)
+ {
+- if ((buf[band][i] >= targetLo) && (buf[band][i] <=targetHi))
++ if ((buf[band][i] >= targetLo) && (buf[band][i] <= targetHi))
+ buf[band][i] = theReplacementValue;
+ }
+ break;
+
+- case REPLACE_BAND_IF_PARTIAL_TARGET:
++ case REPLACE_BAND_IF_PARTIAL_TARGET:
+
+- // First band loop to establish if pixel qualifies for replacement (at least one
++ // First band loop to establish if pixel qualifies for replacement (at least one
+ // band must be valid):
+ can_replace = false;
+ found_candidate = false;
+- for (band=0; (band < bands) && !(can_replace && found_candidate); ++band)
++ for (band = 0; (band < bands) && !(can_replace && found_candidate); ++band)
+ {
+ // check for target range replacement qualification:
+ if ((buf[band][i] < targetLo) || (buf[band][i] > targetHi))
+@@ -340,9 +342,9 @@ void ossimPixelFlipper::flipPixels(T /*
+ {
+ // This pixel has at least one band with normal value, so need to rescan bands
+ // to find pixels that need replacing (are within the target range):
+- for (band=0; band<bands; ++band)
++ for (band = 0; band < bands; ++band)
+ {
+- if ((buf[band][i] >= targetLo) && (buf[band][i] <= targetHi))
++ if ((buf[band][i] >= targetLo) && (buf[band][i] <= targetHi))
+ buf[band][i] = theReplacementValue;
+ }
+ }
+@@ -350,11 +352,11 @@ void ossimPixelFlipper::flipPixels(T /*
+
+ case REPLACE_ALL_BANDS_IF_PARTIAL_TARGET:
+
+- // First band loop to establish if pixel qualifies for replacement (at least one
++ // First band loop to establish if pixel qualifies for replacement (at least one
+ // band must be valid):
+ can_replace = false;
+ found_candidate = false;
+- for (band=0; (band < bands) && !(can_replace && found_candidate); ++band)
++ for (band = 0; (band < bands) && !(can_replace && found_candidate); ++band)
+ {
+ // check for target range replacement qualification:
+ if ((buf[band][i] < targetLo) || (buf[band][i] > targetHi))
+@@ -364,19 +366,19 @@ void ossimPixelFlipper::flipPixels(T /*
+ }
+ if (can_replace && found_candidate)
+ {
+- // This pixel has at least one band with normal value and one with target, so
++ // This pixel has at least one band with normal value and one with target, so
+ // map all bands to target:
+- for (band=0; band<bands; ++band)
++ for (band = 0; band < bands; ++band)
+ buf[band][i] = theReplacementValue;
+ }
+ break;
+
+ case REPLACE_ONLY_FULL_TARGETS:
+
+- // First band loop to establish if pixel qualifies for replacement (all
++ // First band loop to establish if pixel qualifies for replacement (all
+ // bands must be in target range):
+ can_replace = true;
+- for (band=0; (band < bands) && can_replace; ++band)
++ for (band = 0; (band < bands) && can_replace; ++band)
+ {
+ // check for target range replacement qualification:
+ if ((buf[band][i] < targetLo) || (buf[band][i] > targetHi))
+@@ -384,18 +386,18 @@ void ossimPixelFlipper::flipPixels(T /*
+ }
+ if (can_replace)
+ {
+- // Map all pixels to replacement value:
+- for (band=0; band<bands; ++band)
++ // Map all pixels to replacement value:
++ for (band = 0; band < bands; ++band)
+ buf[band][i] = theReplacementValue;
+ }
+ break;
+
+ case REPLACE_ALL_BANDS_IF_ANY_TARGET:
+
+- // First band loop to establish if pixel qualifies for replacement (all
++ // First band loop to establish if pixel qualifies for replacement (all
+ // bands must be in target range):
+ can_replace = false;
+- for (band=0; (band < bands) && !can_replace; ++band)
++ for (band = 0; (band < bands) && !can_replace; ++band)
+ {
+ // check for target range replacement qualification:
+ if ((buf[band][i] >= targetLo) && (buf[band][i] <= targetHi))
+@@ -403,8 +405,8 @@ void ossimPixelFlipper::flipPixels(T /*
+ }
+ if (can_replace)
+ {
+- // Map all pixels to replacement value:
+- for (band=0; band<bands; ++band)
++ // Map all pixels to replacement value:
++ for (band = 0; band < bands; ++band)
+ buf[band][i] = theReplacementValue;
+ }
+ break;
+@@ -413,140 +415,140 @@ void ossimPixelFlipper::flipPixels(T /*
+ // Reached end of processing for one pixel location. Increment the band buffers index:
+ ++i;
+ } // end of loop over pixel_loc.x
+- } // end of loop over pixel_loc.y
+-
+- delete [] buf;
++ } // end of loop over pixel_loc.y
++
++ delete[] buf;
+ inputTile->validate();
+ }
+
+-template <class T> void ossimPixelFlipper::clipTile(T /* dummy */,
+- ossimImageData* inputTile,
+- ossim_uint32 resLevel)
++template <class T>
++void ossimPixelFlipper::clipTile(T /* dummy */,
++ ossimImageData *inputTile,
++ ossim_uint32 resLevel)
+ {
+- if(theClipMode == NONE)
++ if (theClipMode == NONE)
+ {
+ theClipTileBuffer = 0;
+ return;
+ }
+- if(!inputTile) return;
+- if(!inputTile->getBuf()||
+- (inputTile->getDataObjectStatus() == OSSIM_EMPTY))
++ if (!inputTile)
++ return;
++ if (!inputTile->getBuf() ||
++ (inputTile->getDataObjectStatus() == OSSIM_EMPTY))
+ {
+ return;
+ }
+ allocateClipTileBuffer(inputTile);
+
+-
+- if(theClipTileBuffer.valid())
++ if (theClipTileBuffer.valid())
+ {
+ ossimIrect tileRect = inputTile->getImageRectangle();
+ // force to all nulls
+ theClipTileBuffer->setDataObjectStatus(OSSIM_FULL);
+ theClipTileBuffer->makeBlank();
+-
+- switch(theClipMode)
++
++ switch (theClipMode)
+ {
+- case NONE:
+- {
+- break;
+- }
+- case BOUNDING_RECT:
++ case NONE:
++ {
++ break;
++ }
++ case BOUNDING_RECT:
++ {
++ if (resLevel < theBoundingRects.size())
+ {
+- if(resLevel < theBoundingRects.size())
++ if (tileRect.completely_within(theBoundingRects[resLevel]) ||
++ theBoundingRects[resLevel].hasNans())
++ {
++ return;
++ }
++ else
+ {
+- if(tileRect.completely_within(theBoundingRects[resLevel])||
+- theBoundingRects[resLevel].hasNans())
++ if (tileRect.intersects(theBoundingRects[resLevel]))
+ {
+- return;
++ ossimIrect clipRect = tileRect.clipToRect(theBoundingRects[resLevel]);
++
++ theClipTileBuffer->setImageRectangle(clipRect);
++
++ theClipTileBuffer->loadTile(inputTile);
++ inputTile->makeBlank();
++ inputTile->loadTile(theClipTileBuffer.get());
++ inputTile->validate();
+ }
+ else
+ {
+- if(tileRect.intersects(theBoundingRects[resLevel]))
+- {
+- ossimIrect clipRect = tileRect.clipToRect(theBoundingRects[resLevel]);
+-
+- theClipTileBuffer->setImageRectangle(clipRect);
+-
+- theClipTileBuffer->loadTile(inputTile);
+- inputTile->makeBlank();
+- inputTile->loadTile(theClipTileBuffer.get());
+- inputTile->validate();
+- }
+- else
+- {
+- inputTile->makeBlank();
+- }
++ inputTile->makeBlank();
+ }
+ }
+- break;
+ }
+- case VALID_VERTICES:
++ break;
++ }
++ case VALID_VERTICES:
++ {
++ if (resLevel < theValidVertices.size())
+ {
+- if(resLevel < theValidVertices.size())
++ const ossimPolygon &p = theValidVertices[resLevel];
++ bool ulWithin = p.isPointWithin(tileRect.ul());
++ bool urWithin = p.isPointWithin(tileRect.ur());
++ bool lrWithin = p.isPointWithin(tileRect.lr());
++ bool llWithin = p.isPointWithin(tileRect.ll());
++
++ if (ulWithin &&
++ urWithin &&
++ lrWithin &&
++ llWithin)
+ {
+- const ossimPolygon& p = theValidVertices[resLevel];
+- bool ulWithin = p.isPointWithin(tileRect.ul());
+- bool urWithin = p.isPointWithin(tileRect.ur());
+- bool lrWithin = p.isPointWithin(tileRect.lr());
+- bool llWithin = p.isPointWithin(tileRect.ll());
+-
+- if(ulWithin&&
+- urWithin&&
+- lrWithin&&
+- llWithin)
+- {
+- return;
+- }
+- else if(!(ulWithin|| // if none are in
+- urWithin||
+- lrWithin||
+- llWithin))
+- {
+- inputTile->makeBlank();
+- return;
+- }
+- else
++ return;
++ }
++ else if (!(ulWithin || // if none are in
++ urWithin ||
++ lrWithin ||
++ llWithin))
++ {
++ inputTile->makeBlank();
++ return;
++ }
++ else
++ {
++ ossimIpt ul = tileRect.ul();
++ ossimIpt origin;
++ ossim_uint32 x = 0;
++ ossim_uint32 y = 0;
++ ossim_uint32 w = inputTile->getWidth();
++ ossim_uint32 h = inputTile->getHeight();
++ ossim_uint32 offset = 0;
++ origin.y = ul.y;
++ for (y = 0; y < h; ++y)
+ {
+- ossimIpt ul = tileRect.ul();
+- ossimIpt origin;
+- ossim_uint32 x = 0;
+- ossim_uint32 y = 0;
+- ossim_uint32 w = inputTile->getWidth();
+- ossim_uint32 h = inputTile->getHeight();
+- ossim_uint32 offset = 0;
+- origin.y = ul.y;
+- for(y = 0; y < h; ++y)
++ origin.x = ul.x;
++ for (x = 0; x < w; ++x)
+ {
+- origin.x = ul.x;
+- for(x = 0; x < w; ++x)
++ if (!p.isPointWithin(origin))
+ {
+- if(!p.isPointWithin(origin))
+- {
+- inputTile->setNull(offset);
+- }
+- ++offset;
+- ++origin.x;
++ inputTile->setNull(offset);
+ }
+- ++origin.y;
++ ++offset;
++ ++origin.x;
+ }
++ ++origin.y;
+ }
+ }
+- break;
+ }
++ break;
++ }
+ }
+ }
+ }
+
+-
+ void ossimPixelFlipper::allocateClipTileBuffer(ossimRefPtr<ossimImageData> inputImage)
+ {
+- if(inputImage.valid())
++ if (inputImage.valid())
+ {
+ bool needDupFlag = false;
+- if(theClipTileBuffer.valid())
++ if (theClipTileBuffer.valid())
+ {
+- if((theClipTileBuffer->getScalarType() != inputImage->getScalarType())||
+- theClipTileBuffer->getNumberOfBands() != theClipTileBuffer->getNumberOfBands())
++ if ((theClipTileBuffer->getScalarType() != inputImage->getScalarType()) ||
++ theClipTileBuffer->getNumberOfBands() != theClipTileBuffer->getNumberOfBands())
+ {
+ needDupFlag = true;
+ }
+@@ -559,16 +561,16 @@ void ossimPixelFlipper::allocateClipTile
+ {
+ needDupFlag = true;
+ }
+- if(needDupFlag)
++ if (needDupFlag)
+ {
+- theClipTileBuffer = (ossimImageData*)inputImage->dup();
++ theClipTileBuffer = (ossimImageData *)inputImage->dup();
+ }
+ }
+ }
+
+ void ossimPixelFlipper::initialize()
+ {
+- std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
++ std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
+ ossimImageSourceFilter::initialize();
+ theValidVertices.clear();
+ theBoundingRects.clear();
+@@ -576,17 +578,17 @@ void ossimPixelFlipper::initialize()
+ ossim_uint32 rlevels = getNumberOfDecimationLevels();
+ ossim_uint32 idx = 0;
+
+- if(rlevels)
++ if (rlevels)
+ {
+- if(theValidVertices.size() != rlevels)
++ if (theValidVertices.size() != rlevels)
+ {
+ theValidVertices.resize(rlevels);
+ }
+- if(theBoundingRects.size() != rlevels)
++ if (theBoundingRects.size() != rlevels)
+ {
+ theBoundingRects.resize(rlevels);
+ }
+- for(idx = 0; idx < rlevels; ++idx)
++ for (idx = 0; idx < rlevels; ++idx)
+ {
+ std::vector<ossimIpt> validVertices;
+ getValidImageVertices(validVertices,
+@@ -600,7 +602,7 @@ void ossimPixelFlipper::initialize()
+
+ ossimScalarType ossimPixelFlipper::getOutputScalarType() const
+ {
+- if(theInputConnection)
++ if (theInputConnection)
+ {
+ ossimScalarType scalar = theInputConnection->getOutputScalarType();
+ {
+@@ -655,7 +657,7 @@ ossimScalarType ossimPixelFlipper::getOu
+ return OSSIM_SCALAR_UNKNOWN;
+ }
+
+-ossim_float64 ossimPixelFlipper::getMaxPixelValue (ossim_uint32 band) const
++ossim_float64 ossimPixelFlipper::getMaxPixelValue(ossim_uint32 band) const
+ {
+ const ossim_float64 MIN = ossimImageSourceFilter::getMinPixelValue(band);
+ const ossim_float64 MAX = ossimImageSourceFilter::getMaxPixelValue(band);
+@@ -666,7 +668,7 @@ ossim_float64 ossimPixelFlipper::getMaxP
+ return MAX;
+ }
+
+-ossim_float64 ossimPixelFlipper::getMinPixelValue (ossim_uint32 band) const
++ossim_float64 ossimPixelFlipper::getMinPixelValue(ossim_uint32 band) const
+ {
+ const ossim_float64 MIN = ossimImageSourceFilter::getMinPixelValue(band);
+ const ossim_float64 MAX = ossimImageSourceFilter::getMaxPixelValue(band);
+@@ -677,60 +679,60 @@ ossim_float64 ossimPixelFlipper::getMinP
+ return MIN;
+ }
+
+-bool ossimPixelFlipper::loadState(const ossimKeywordlist& kwl,
+- const char* prefix)
++bool ossimPixelFlipper::loadState(const ossimKeywordlist &kwl,
++ const char *prefix)
+ {
+- const char* lookupReturn;
+-
++ const char *lookupReturn;
++
+ lookupReturn = kwl.find(prefix, PF_TARGET_VALUE_KW);
+- if(lookupReturn)
++ if (lookupReturn)
+ {
+ setTargetValue(atof(lookupReturn));
+ }
+
+ lookupReturn = kwl.find(prefix, PF_TARGET_RANGE_KW);
+- if(lookupReturn)
++ if (lookupReturn)
+ {
+- ossimString min_max_string (lookupReturn);
+- ossimString separator (" ");
++ ossimString min_max_string(lookupReturn);
++ ossimString separator(" ");
+ ossim_float64 min_target = min_max_string.before(separator).toFloat64();
+ ossim_float64 max_target = min_max_string.after(separator).toFloat64();
+ setTargetRange(min_target, max_target);
+ }
+
+ lookupReturn = kwl.find(prefix, PF_REPLACEMENT_VALUE_KW);
+- if(lookupReturn)
++ if (lookupReturn)
+ {
+ setReplacementValue(atof(lookupReturn));
+ }
+
+ lookupReturn = kwl.find(prefix, PF_REPLACEMENT_MODE_KW);
+- if(lookupReturn)
++ if (lookupReturn)
+ {
+ ossimString modeString = lookupReturn;
+ setReplacementMode(modeString);
+ }
+
+ lookupReturn = kwl.find(prefix, PF_CLAMP_VALUE_KW);
+- if(lookupReturn)
++ if (lookupReturn)
+ {
+ setClampValue(atof(lookupReturn), true);
+ }
+
+ lookupReturn = kwl.find(prefix, PF_CLAMP_VALUE_LO_KW);
+- if(lookupReturn)
++ if (lookupReturn)
+ {
+ setClampValue(atof(lookupReturn), false);
+ }
+
+ lookupReturn = kwl.find(prefix, PF_CLAMP_VALUE_HI_KW);
+- if(lookupReturn)
++ if (lookupReturn)
+ {
+ setClampValue(atof(lookupReturn), true);
+ }
+
+ lookupReturn = kwl.find(prefix, PF_CLIP_MODE_KW);
+- if(lookupReturn)
++ if (lookupReturn)
+ {
+ ossimString modeString = lookupReturn;
+ setClipMode(modeString);
+@@ -746,16 +748,16 @@ bool ossimPixelFlipper::loadState(const
+ return status;
+ }
+
+-bool ossimPixelFlipper::saveState(ossimKeywordlist& kwl,
+- const char* prefix) const
++bool ossimPixelFlipper::saveState(ossimKeywordlist &kwl,
++ const char *prefix) const
+ {
+ // Call the base class saveState.
+ ossimImageSourceFilter::saveState(kwl, prefix);
+
+ if (theTargetValueHi != theTargetValueLo)
+ {
+- ossimString s (ossimString::toString(theTargetValueLo) + " " +
+- ossimString::toString(theTargetValueHi));
++ ossimString s(ossimString::toString(theTargetValueLo) + " " +
++ ossimString::toString(theTargetValueHi));
+ kwl.add(prefix, PF_TARGET_RANGE_KW, s);
+ }
+ else
+@@ -763,14 +765,14 @@ bool ossimPixelFlipper::saveState(ossimK
+ kwl.add(prefix, PF_TARGET_VALUE_KW, theTargetValueLo);
+ }
+ kwl.add(prefix, PF_REPLACEMENT_VALUE_KW, theReplacementValue);
+- kwl.add(prefix, PF_REPLACEMENT_MODE_KW, getReplacementModeString().c_str());
++ kwl.add(prefix, PF_REPLACEMENT_MODE_KW, getReplacementModeString().c_str());
+
+ if (theClampingMode)
+ {
+- kwl.add(prefix, PF_CLAMP_VALUE_LO_KW, theClampValueLo);
+- kwl.add(prefix, PF_CLAMP_VALUE_HI_KW, theClampValueHi);
++ kwl.add(prefix, PF_CLAMP_VALUE_LO_KW, theClampValueLo);
++ kwl.add(prefix, PF_CLAMP_VALUE_HI_KW, theClampValueHi);
+ }
+- kwl.add(prefix, PF_CLIP_MODE_KW, getClipModeString().c_str());
++ kwl.add(prefix, PF_CLIP_MODE_KW, getClipModeString().c_str());
+
+ return true;
+ }
+@@ -785,7 +787,7 @@ void ossimPixelFlipper::setTargetValue(o
+ std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
+
+ theTargetValueLo = target_value;
+- theTargetValueHi = target_value;
++ theTargetValueHi = target_value;
+ }
+
+ void ossimPixelFlipper::setTargetRange(ossim_float64 target_min, ossim_float64 target_max)
+@@ -798,12 +800,12 @@ void ossimPixelFlipper::setTargetRange(o
+ std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
+
+ theTargetValueLo = target_min;
+- theTargetValueHi = target_max;
++ theTargetValueHi = target_max;
+ }
+
+ void ossimPixelFlipper::setReplacementValue(ossim_float64 replacement_value)
+ {
+- std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
++ std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
+
+ // Range check to ensure within null, min and max of output radiometry.
+ if (inRange(replacement_value))
+@@ -819,18 +821,18 @@ void ossimPixelFlipper::setClampValue(os
+ if (inRange(clamp_value))
+ {
+ // Stupid MS compiler complains if we do an |= on enum type. (OLK 1/11)
+- int temp_int = (int) theClampingMode;
++ int temp_int = (int)theClampingMode;
+ if (clamp_max_value)
+ {
+ theClampValueHi = clamp_value;
+- temp_int |= (int) CLAMPING_HI;
++ temp_int |= (int)CLAMPING_HI;
+ }
+ else
+ {
+ theClampValueLo = clamp_value;
+- temp_int |= (int) CLAMPING_LO;
++ temp_int |= (int)CLAMPING_LO;
+ }
+- theClampingMode = (ClampingMode) temp_int;
++ theClampingMode = (ClampingMode)temp_int;
+ }
+ }
+
+@@ -843,13 +845,13 @@ void ossimPixelFlipper::setClampValues(o
+
+ void ossimPixelFlipper::setReplacementMode(ossimPixelFlipper::ReplacementMode mode)
+ {
+- std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
++ std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
+ theReplacementMode = mode;
+ }
+
+-bool ossimPixelFlipper::setReplacementMode(const ossimString& modeString)
++bool ossimPixelFlipper::setReplacementMode(const ossimString &modeString)
+ {
+- std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
++ std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
+
+ ossimString mode = modeString;
+ mode.upcase();
+@@ -876,9 +878,9 @@ bool ossimPixelFlipper::setReplacementMo
+ else
+ {
+ ossimNotify(ossimNotifyLevel_WARN)
+- << "ossimPixelFlipper::setReplacementMode warning:\n"
+- << "Invalid mode: " << modeString
+- << endl;
++ << "ossimPixelFlipper::setReplacementMode warning:\n"
++ << "Invalid mode: " << modeString
++ << endl;
+ return false;
+ }
+ return true;
+@@ -886,11 +888,11 @@ bool ossimPixelFlipper::setReplacementMo
+
+ void ossimPixelFlipper::setClipMode(ossimPixelFlipper::ClipMode mode)
+ {
+- std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
++ std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
+ theClipMode = mode;
+ }
+
+-void ossimPixelFlipper::setClipMode(const ossimString& modeString)
++void ossimPixelFlipper::setClipMode(const ossimString &modeString)
+ {
+ ossimString mode = modeString;
+ mode.downcase();
+@@ -909,9 +911,9 @@ void ossimPixelFlipper::setClipMode(cons
+ else
+ {
+ ossimNotify(ossimNotifyLevel_WARN)
+- << "ossimPixelFlipper::setClipMode warning:\n"
+- << "Invalid mode: " << modeString
+- << endl;
++ << "ossimPixelFlipper::setClipMode warning:\n"
++ << "Invalid mode: " << modeString
++ << endl;
+ }
+ }
+
+@@ -925,33 +927,33 @@ ossim_float64 ossimPixelFlipper::getRepl
+ return theReplacementValue;
+ }
+
+-ossimPixelFlipper::ReplacementMode ossimPixelFlipper::getReplacementMode() const
++ossimPixelFlipper::ReplacementMode ossimPixelFlipper::getReplacementMode() const
+ {
+ return theReplacementMode;
+ }
+-
+-ossimString ossimPixelFlipper::getReplacementModeString() const
++
++ossimString ossimPixelFlipper::getReplacementModeString() const
+ {
+- switch(theReplacementMode)
++ switch (theReplacementMode)
+ {
+- case REPLACE_BAND_IF_TARGET:
+- return ossimString("REPLACE_BAND_IF_TARGET");
+- case REPLACE_BAND_IF_PARTIAL_TARGET:
+- return ossimString("REPLACE_BAND_IF_PARTIAL_TARGET");
+- case REPLACE_ALL_BANDS_IF_PARTIAL_TARGET:
+- return ossimString("REPLACE_ALL_BANDS_IF_PARTIAL_TARGET");
+- case REPLACE_ONLY_FULL_TARGETS:
+- return ossimString("REPLACE_ONLY_FULL_TARGETS");
+- case REPLACE_ALL_BANDS_IF_ANY_TARGET:
+- return ossimString("REPLACE_ALL_BANDS_IF_ANY_TARGET");
+- default:
+- break;
++ case REPLACE_BAND_IF_TARGET:
++ return ossimString("REPLACE_BAND_IF_TARGET");
++ case REPLACE_BAND_IF_PARTIAL_TARGET:
++ return ossimString("REPLACE_BAND_IF_PARTIAL_TARGET");
++ case REPLACE_ALL_BANDS_IF_PARTIAL_TARGET:
++ return ossimString("REPLACE_ALL_BANDS_IF_PARTIAL_TARGET");
++ case REPLACE_ONLY_FULL_TARGETS:
++ return ossimString("REPLACE_ONLY_FULL_TARGETS");
++ case REPLACE_ALL_BANDS_IF_ANY_TARGET:
++ return ossimString("REPLACE_ALL_BANDS_IF_ANY_TARGET");
++ default:
++ break;
+ }
+
+ return ossimString("UNKNOWN_MODE");
+ }
+
+-ossimString ossimPixelFlipper::getClipModeString() const
++ossimString ossimPixelFlipper::getClipModeString() const
+ {
+ if (theClipMode == BOUNDING_RECT)
+ return ossimString("bounding_rect");
+@@ -967,7 +969,7 @@ ossimPixelFlipper::ClipMode ossimPixelFl
+ return theClipMode;
+ }
+
+-std::ostream& ossimPixelFlipper::print(std::ostream& out) const
++std::ostream &ossimPixelFlipper::print(std::ostream &out) const
+ {
+ out << "ossimPixelFlipper::print:"
+ << "\ntarget value Lo: " << theTargetValueLo
+@@ -977,59 +979,59 @@ std::ostream& ossimPixelFlipper::print(s
+ << "\nclamp value Hi: " << theClampValueHi
+ << "\nreplacement mode: " << getReplacementModeString().c_str()
+ << "\nclip_mode: " << getClipModeString().c_str()
+- << endl;
++ << endl;
+ return out;
+ }
+
+ ossimRefPtr<ossimProperty> ossimPixelFlipper::getProperty(
+- const ossimString& name)const
++ const ossimString &name) const
+ {
+ // Lock for the length of this method.
+- std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
++ std::lock_guard<std::recursive_mutex> scopeLock(theMutex);
+
+ if (name == PF_TARGET_VALUE_KW)
+ {
+- ossimProperty* p =
+- new ossimNumericProperty(name,
+- ossimString::toString(theTargetValueLo));
++ ossimProperty *p =
++ new ossimNumericProperty(name,
++ ossimString::toString(theTargetValueLo));
+ p->setCacheRefreshBit();
+ return ossimRefPtr<ossimProperty>(p);
+ }
+ if (name == PF_TARGET_RANGE_KW)
+ {
+- ossimProperty* p =
+- new ossimNumericProperty(name,
+- ossimString::toString(theTargetValueLo));
++ ossimProperty *p =
++ new ossimNumericProperty(name,
++ ossimString::toString(theTargetValueLo));
+ p->setCacheRefreshBit();
+ return ossimRefPtr<ossimProperty>(p);
+ }
+ if (name == TARGET_UPPER_LIMIT_PROP_NAME)
+ {
+- ossimProperty* p =
+- new ossimNumericProperty(name,
+- ossimString::toString(theTargetValueHi));
++ ossimProperty *p =
++ new ossimNumericProperty(name,
++ ossimString::toString(theTargetValueHi));
+ p->setCacheRefreshBit();
+ return ossimRefPtr<ossimProperty>(p);
+ }
+ else if (name == PF_REPLACEMENT_VALUE_KW)
+ {
+- ossimProperty* p =
+- new ossimNumericProperty(name,
+- ossimString::toString(theReplacementValue));
+- p->setCacheRefreshBit();
++ ossimProperty *p =
++ new ossimNumericProperty(name,
++ ossimString::toString(theReplacementValue));
++ p->setCacheRefreshBit();
+ return ossimRefPtr<ossimProperty>(p);
+ }
+ else if (name == PF_CLAMP_VALUE_LO_KW)
+ {
+- ossimProperty* p =
+- new ossimNumericProperty(name, ossimString::toString(theClampValueLo));
++ ossimProperty *p =
++ new ossimNumericProperty(name, ossimString::toString(theClampValueLo));
+ p->setCacheRefreshBit();
+ return ossimRefPtr<ossimProperty>(p);
+ }
+ else if (name == PF_CLAMP_VALUE_HI_KW)
+ {
+- ossimProperty* p =
+- new ossimNumericProperty(name, ossimString::toString(theClampValueHi));
++ ossimProperty *p =
++ new ossimNumericProperty(name, ossimString::toString(theClampValueHi));
+ p->setCacheRefreshBit();
+ return ossimRefPtr<ossimProperty>(p);
+ }
+@@ -1041,12 +1043,12 @@ ossimRefPtr<ossimProperty> ossimPixelFli
+ constraintList[2] = "REPLACE_ALL_BANDS_IF_PARTIAL_TARGET";
+ constraintList[3] = "REPLACE_ONLY_FULL_TARGETS";
+ constraintList[4] = "REPLACE_ALL_BANDS_IF_ANY_TARGET";
+-
+- ossimStringProperty* p =
+- new ossimStringProperty(name,
+- getReplacementModeString(),
+- false,
+- constraintList);
++
++ ossimStringProperty *p =
++ new ossimStringProperty(name,
++ getReplacementModeString(),
++ false,
++ constraintList);
+ p->setCacheRefreshBit();
+ return ossimRefPtr<ossimProperty>(p);
+ }
+@@ -1056,23 +1058,23 @@ ossimRefPtr<ossimProperty> ossimPixelFli
+ constraintList[0] = "none";
+ constraintList[1] = "bounding_rect";
+ constraintList[2] = "valid_vertices";
+-
+- ossimStringProperty* p =
+- new ossimStringProperty(name,
+- getClipModeString(),
+- false,
+- constraintList);
++
++ ossimStringProperty *p =
++ new ossimStringProperty(name,
++ getClipModeString(),
++ false,
++ constraintList);
+ p->setCacheRefreshBit();
+ return ossimRefPtr<ossimProperty>(p);
+ }
+ ossimRefPtr<ossimProperty> result = ossimSource::getProperty(name);
+
+- if(result.valid())
++ if (result.valid())
+ {
+- if(result->getName() == ossimKeywordNames::ENABLED_KW)
++ if (result->getName() == ossimKeywordNames::ENABLED_KW)
+ {
+ result->clearChangeType();
+-
++
+ // we will at least say its a radiometric change
+ //
+ result->setCacheRefreshBit();
+@@ -1084,10 +1086,11 @@ ossimRefPtr<ossimProperty> ossimPixelFli
+
+ void ossimPixelFlipper::setProperty(ossimRefPtr<ossimProperty> property)
+ {
+- if (!property) return;
++ if (!property)
++ return;
+
+ ossimString os = property->valueToString();
+-
++
+ ossimString name = property->getName();
+ if (name == PF_TARGET_VALUE_KW)
+ {
+@@ -1101,23 +1104,23 @@ void ossimPixelFlipper::setProperty(ossi
+ {
+ setTargetRange(theTargetValueLo, os.toDouble());
+ }
+- else if (name == PF_REPLACEMENT_VALUE_KW)
++ else if (name == PF_REPLACEMENT_VALUE_KW)
+ {
+ setReplacementValue(os.toDouble());
+ }
+- else if (name == PF_REPLACEMENT_MODE_KW)
++ else if (name == PF_REPLACEMENT_MODE_KW)
+ {
+ setReplacementMode(os);
+ }
+- else if (name == PF_CLAMP_VALUE_LO_KW)
++ else if (name == PF_CLAMP_VALUE_LO_KW)
+ {
+ setClampValue(os.toDouble(), false);
+ }
+- else if (name == PF_CLAMP_VALUE_HI_KW)
++ else if (name == PF_CLAMP_VALUE_HI_KW)
+ {
+ setClampValue(os.toDouble(), true);
+ }
+- else if (name == PF_CLIP_MODE_KW)
++ else if (name == PF_CLIP_MODE_KW)
+ {
+ setClipMode(os);
+ }
+@@ -1128,7 +1131,7 @@ void ossimPixelFlipper::setProperty(ossi
+ }
+
+ void ossimPixelFlipper::getPropertyNames(
+- std::vector<ossimString>& propertyNames)const
++ std::vector<ossimString> &propertyNames) const
+ {
+ propertyNames.push_back(PF_TARGET_VALUE_KW);
+ propertyNames.push_back(TARGET_LOWER_LIMIT_PROP_NAME);
+@@ -1138,11 +1141,11 @@ void ossimPixelFlipper::getPropertyNames
+ propertyNames.push_back(PF_CLAMP_VALUE_LO_KW);
+ propertyNames.push_back(PF_CLAMP_VALUE_HI_KW);
+ propertyNames.push_back(PF_CLIP_MODE_KW);
+-
++
+ ossimImageSourceFilter::getPropertyNames(propertyNames);
+ }
+
+-ossimString ossimPixelFlipper::getShortName()const
++ossimString ossimPixelFlipper::getShortName() const
+ {
+ return ossimString("Pixel flipper");
+ }
+@@ -1159,24 +1162,24 @@ bool ossimPixelFlipper::inRange(ossim_fl
+ //---
+ return true;
+ }
+-
++
+ const ossim_float64 NULL_PIX = ossimImageSourceFilter::getNullPixelValue();
+- const ossim_float64 MIN_PIX = ossimImageSourceFilter::getMinPixelValue();
+- const ossim_float64 MAX_PIX = ossimImageSourceFilter::getMaxPixelValue();
++ const ossim_float64 MIN_PIX = ossimImageSourceFilter::getMinPixelValue();
++ const ossim_float64 MAX_PIX = ossimImageSourceFilter::getMaxPixelValue();
+
+- if ( (value == NULL_PIX) || ((value >= MIN_PIX) && (value <= MAX_PIX)) )
++ if ((value == NULL_PIX) || ((value >= MIN_PIX) && (value <= MAX_PIX)))
+ {
+ return true;
+ }
+
+ ossimNotify(ossimNotifyLevel_WARN)
+- << "\nossimPixelFlipper::inRange WARNING:"
+- << "\nvalue \"" << value
+- << "\" is out of range!"
+- << "\nInput source null = " << NULL_PIX
+- << "\nInput source min = " << MIN_PIX
+- << "\nInput source max = " << MAX_PIX
+- << endl;
++ << "\nossimPixelFlipper::inRange WARNING:"
++ << "\nvalue \"" << value
++ << "\" is out of range!"
++ << "\nInput source null = " << NULL_PIX
++ << "\nInput source min = " << MIN_PIX
++ << "\nInput source max = " << MAX_PIX
++ << endl;
+
+ return false;
+ }
=====================================
debian/patches/series
=====================================
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1 +1,2 @@
spelling-errors.patch
+0001-The-bitmask-was-calling-pixel-flipper-directly.-I-th.patch
View it on GitLab: https://salsa.debian.org/debian-gis-team/ossim/compare/c9e7f3033bbaef4241dc5bc0e971488a9f09c402...2f8f43a09267b7947256899d135742fd9b528132
--
View it on GitLab: https://salsa.debian.org/debian-gis-team/ossim/compare/c9e7f3033bbaef4241dc5bc0e971488a9f09c402...2f8f43a09267b7947256899d135742fd9b528132
You're receiving this email because of your account on salsa.debian.org.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://alioth-lists.debian.net/pipermail/pkg-grass-devel/attachments/20180529/65e5b4ba/attachment-0001.html>
More information about the Pkg-grass-devel
mailing list