OSSIM - Open Source Software Image Map: ossim Namespace Reference

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519

#define DEG_PER_RAD

Definition: ossimConstants.h:452

◆ almostEqual()

template<class T >

bool ossim::almostEqual	(	T	x,
		T	y,
		T	tolerance = `FLT_EPSILON`
	)

inline

Definition at line 53 of file ossimCommon.h.

References x, and y.

55 { return std::fabs(x - y) <= tolerance; }

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519

y

ossim_uint32 y

Definition: ossimPdfWriter.cpp:520

◆ asind()

double ossim::asind ( double x )

inline

Definition at line 265 of file ossimCommon.h.

References DEG_PER_RAD, and x.

Referenced by matrixToHpr().

265 { return DEG_PER_RAD*std::asin(x); }

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519

#define DEG_PER_RAD

Definition: ossimConstants.h:452

◆ atan2d()

double ossim::atan2d	(	double	y,
		double	x
	)

inline

Definition at line 267 of file ossimCommon.h.

References DEG_PER_RAD, x, and y.

Referenced by ossimGpt::azimuthTo(), ossimRangeDomeTileSource::getTile(), matrixToHpr(), and ossimImageGeometry::upIsUpAngle().

267 { return DEG_PER_RAD*std::atan2(y,x); }

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519

#define DEG_PER_RAD

Definition: ossimConstants.h:452

y

ossim_uint32 y

Definition: ossimPdfWriter.cpp:520

◆ atand()

double ossim::atand ( double x )

inline

Definition at line 266 of file ossimCommon.h.

References DEG_PER_RAD, and x.

Referenced by ossimViewshedTool::writeHorizonProfile().

266 { return DEG_PER_RAD*std::atan(x); }

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519

Referenced by ossimGpt::azimuthTo(), ossimGdalOgrVectorAnnotation::computeDefaultView(), ossimKmlSuperOverlayReader::createDefaultProj(), ossimOgrVectorTileSource::createDefaultProj(), ossimTopographicCorrectionFilter::executeTopographicCorrectionTemplate(), ossimEllipsoid::geodeticRadii(), ossimEllipsoid::geodeticRadius(), ATP::AtpTileSource::initializeStaticMembers(), ossimEllipsoid::latLonHeightToXYZ(), matrixToHpr(), ossimGpt::metersPerDegree(), ossimLsrSpace::ossimLsrSpace(), ossimIpodSensor::updateModel(), ossimSkyBoxLearSensor::updateModel(), ossimAdjMapModel::updateModel(), ossimLandSatModel::updateModel(), and ossimRpcModel::updateModel().

#define DEG_PER_RAD

Definition: ossimConstants.h:452

◆ byteOrder()

ossimByteOrder ossim::byteOrder ( )

Definition at line 54 of file ossimCommon.cpp.

References OSSIM_BIG_ENDIAN, and OSSIM_LITTLE_ENDIAN.

 {
    union
    {
       short s;
       char  c[sizeof(short)];
    } un;
 
    un.s = 0x0102;
    if (un.c[0] ==  2 && un.c[1] == 1)
    {
       return OSSIM_LITTLE_ENDIAN;
    }
    else
    {
       return OSSIM_BIG_ENDIAN;
    }
 }

◆ clamp()

template<class T >

T ossim::clamp	(	T	x,
		T	a,
		T	b
	)

inline

Definition at line 168 of file ossimCommon.h.

References isnan(), ossimREQUIRE, and x.

Referenced by matrixToHpr(), ossimNormRgbVector::operator*(), ossimRgbVector::operator*(), ossimRgbVector::operator+(), ossimNormRgbVector::operator-(), and ossimRgbVector::operator-().

     {
         ossimREQUIRE(a <= b);  // input must make sense, disallow nans 
         
             if (ossim::isnan(x)) return x;
             if (x < a) return a;
             if (b < x) return b;
             return x;
     }

◆ clipRegionToImage()

bool ossim::clipRegionToImage	(	kdu_core::kdu_codestream &	codestream,
		kdu_core::kdu_dims &	region,
		int	discard_levels,
		kdu_core::kdu_dims &	clipRegion
	)

Sets clipRegion from region, and image dimensions for level.

This will clip region to the image dimensions for the given discard_levels. Returns false if no intersection.

Parameters

codestream	Stream to pull from.
region	The region wanted from codestream.
discard_levels	The resolution level, 0 being full res.
clipRegion	The region to initialize.

Returns: true on success, false if no intersection or there were codestream or pointer issues.

Definition at line 49 of file ossimKakaduCommon.cpp.

Referenced by copyRegionToTile(), and ossimKakaduJpipHandler::getTileAtRes().

 {
    // Clip the region to the image dimensions.
 
    bool result = false;
 
    if ( codestream.exists() )
    {
       codestream.apply_input_restrictions(
          0, 0, discard_levels, 0, NULL, kdu_core::KDU_WANT_OUTPUT_COMPONENTS);
       
       kdu_core::kdu_dims dims;
       codestream.get_dims(0, dims);
       if ( region.intersects(dims) )
       {
          clipRegion = region.intersection(dims);
          result = true;
       }
    }
 
    return result;
 }

◆ color_apply_icc_profile()

void ossim::color_apply_icc_profile ( opj_image * image )

◆ color_sycc_to_rgb()

void ossim::color_sycc_to_rgb ( opj_image * img )

Definition at line 241 of file ossimOpjColor.cpp.

 {
    if(img->numcomps < 3) 
    {
       img->color_space = OPJ_CLRSPC_GRAY;
       return;
    }
 
    if((img->comps[0].dx == 1)
       && (img->comps[1].dx == 2)
       && (img->comps[2].dx == 2)
       && (img->comps[0].dy == 1)
       && (img->comps[1].dy == 2)
       && (img->comps[2].dy == 2))/* horizontal and vertical sub-sample */
    {
       sycc420_to_rgb(img);
    }
    else
       if((img->comps[0].dx == 1)
          && (img->comps[1].dx == 2)
          && (img->comps[2].dx == 2)
          && (img->comps[0].dy == 1)
          && (img->comps[1].dy == 1)
          && (img->comps[2].dy == 1))/* horizontal sub-sample only */
       {
          sycc422_to_rgb(img);
       }
       else
          if((img->comps[0].dx == 1)
             && (img->comps[1].dx == 1)
             && (img->comps[2].dx == 1)
             && (img->comps[0].dy == 1)
             && (img->comps[1].dy == 1)
             && (img->comps[2].dy == 1))/* no sub-sample */
          {
             sycc444_to_rgb(img);
          }
          else
          {
             fprintf(stderr,"%s:%d:color_sycc_to_rgb\n\tCAN NOT CONVERT\n",
                     __FILE__,__LINE__);
             return;
          }
    img->color_space = OPJ_CLRSPC_SRGB;
 
 }/* color_sycc_to_rgb() */

◆ computeLevels()

ossim_uint32 ossim::computeLevels ( const ossimIrect & rect )

Computes the number of decimation levels to get to the overview stop dimension.

This uses ossim preferences "overview_stop_dimension" value if set else it uses the default tile size to compute the number of levels.

Parameters

rect	The rectangle of the first level.

Returns: The number of decimation levels needed.

Definition at line 1253 of file ossimCommon.cpp.

References defaultTileSize(), ossimIrect::height(), ossimPreferences::instance(), ossimKeywordNames::OVERVIEW_STOP_DIMENSION_KW, ossimString::toUInt32(), ossimIrect::width(), ossimIpt::x, and ossimIpt::y.

Referenced by ossimOpjCompressor::initLevels(), and ossimKakaduCompressor::setLevels().

 {
    ossim_uint32 result = 0;
    ossim_uint32 stopDimension = 0;
       
    // Get the stop dimension from ossim preferences.
    const char* lookup = ossimPreferences::instance()->
       findPreference(ossimKeywordNames::OVERVIEW_STOP_DIMENSION_KW);
    if (lookup)
    {
       stopDimension = ossimString(lookup).toUInt32();
    }
    
    if (stopDimension == 0)
    {
       // Use the smallest default tile size.
       ossimIpt tileSize;
       ossim::defaultTileSize(tileSize);
       stopDimension = tileSize.x < tileSize.y ? tileSize.x : tileSize.y;
    }
       
    ossim_uint32 largestImageDimension =
       rect.width() > rect.height() ? rect.width() : rect.height();
    
    while(largestImageDimension > stopDimension)
    {
       largestImageDimension /= 2;
       ++result;
    }
    
    return result;
 }

◆ convertHtmlSpecialCharactersToNormalCharacter()

std::string ossim::convertHtmlSpecialCharactersToNormalCharacter ( const std::string & src )

Definition at line 574 of file ossimCommon.cpp.

References ossimString::find(), min(), ossimString::size(), size, and ossimString::substitute().

Referenced by ossimWmsGetMap::read().

 {
    ossimString result = src;
    std::string::size_type pos = 0;
    pos = result.find("&");
    
    while(pos != std::string::npos)
    {
       std::string::size_type size = result.size();
       std::string test1(&result[pos], ossim::min(6, (int)(size-pos)));
       std::string test2(&result[pos], ossim::min(5, (int)(size-pos)));
       std::string test3(&result[pos], ossim::min(4, (int)(size-pos)));
       
       if(test1 == "&apos;")
       {
          result = result.substitute(test1, "'");
       }
       else if(test1 == "&quot;")
       {
          result = result.substitute(test1, "\"");
       }
       else if(test2 == "&amp;")
       {
          result = result.substitute(test2, "&");
       }
       else if(test3 == "&gt;")
       {
          result = result.substitute(test3, ">");
       }
       else if(test3 == "&lt;")
       {
          result = result.substitute(test3, "<");
       }
       pos = result.find("&", pos+1);
    }
    
    return result;
 }

◆ copyOpjImage()

bool ossim::copyOpjImage	(	opj_image *	image,
		ossimImageData *	tile
	)

Definition at line 389 of file ossimOpjCommon.cpp.

References copyOpjSrgbImage(), ossimRectilinearDataObject::getScalarType(), OSSIM_UINT8, ossimNotify(), ossimNotifyLevel_WARN, and status.

 {
    bool status = false;
    
    if ( image && tile )
    {
       if ( image->color_space == OPJ_CLRSPC_SRGB )
       {
          const ossimScalarType SCALAR = tile->getScalarType();
          if ( SCALAR == OSSIM_UINT8 )
          {
             status = ossim::copyOpjSrgbImage( ossim_uint8(0), image, tile );
          }
          else
          {
             ossimNotify(ossimNotifyLevel_WARN)
                << "ossim::copyOpjImage WARNING!\nUnhandle scalar: "
                << SCALAR << "\n";
          }
       }
       else
       {
          ossimNotify(ossimNotifyLevel_WARN)
             << "ossim::copyOpjImage WARNING!\nUnhandle color space: "
             << image->color_space << "\n";
       }
    }
 
    return status;
 }

◆ copyOpjSrgbImage()

template<class T >

bool ossim::copyOpjSrgbImage	(	T	dummy,
		opj_image *	image,
		ossimImageData *	tile
	)

Definition at line 420 of file ossimOpjCommon.cpp.

References ossimImageData::getBuf(), ossimImageData::getHeight(), ossimImageData::getNumberOfBands(), ossimImageData::getWidth(), ossimNotify(), ossimNotifyLevel_WARN, and status.

Referenced by copyOpjImage().

 {
    bool status = false;
    
    const ossim_uint32 BANDS = tile->getNumberOfBands();
 
    if ( image->numcomps == BANDS )
    {
       for ( ossim_uint32 band = 0; band < BANDS; ++band )
       {
          T* buf = (T*)tile->getBuf(band);
          const ossim_uint32 LINES = tile->getHeight();
          
          if ( image->comps[band].h == LINES )
          {
             ossim_uint32 offset = 0;
             for ( ossim_uint32 line = 0; line < LINES; ++line )
             {
                const ossim_uint32 SAMPS = tile->getWidth();
                if ( image->comps[band].w == SAMPS )
                {
                   for ( ossim_uint32 samp = 0; samp < SAMPS; ++samp )
                   {
                      buf[offset] = (T)(image->comps[band].data[offset]);
                      ++offset;
                   }
 
                   //---
                   // If we get here all the dimensions match and things sould
                   // be good.
                   //---
                   status = true;
                }
                else
                {
                   ossimNotify(ossimNotifyLevel_WARN)
                      << "ossim::copyOpjSrgbImage WARNING: sample mismatch!\n";
                }
             }
          }
          else
          {
             ossimNotify(ossimNotifyLevel_WARN)
                << "ossim::copyOpjSrgbImage WARNING: line mismatch!\n";
          } 
       }
    }
    else
    {
       ossimNotify(ossimNotifyLevel_WARN)
                << "ossim::copyOpjSrgbImage WARNING: band mismatch!\n";
    }
 
    return status;
    
 } // End: ossim::copyOpjSrgbImage( ... )

◆ copyRegionToTile() [1/2]

bool ossim::copyRegionToTile	(	kdu_supp::kdu_channel_mapping *	channelMapping,
		kdu_core::kdu_codestream &	codestream,
		int	discard_levels,
		kdu_core::kdu_thread_env *	threadEnv,
		kdu_core::kdu_thread_queue *	threadQueue,
		ossimImageData *	destTile
	)

Copies region from codestream to tile at a given rlevel.

This method takes a channelMapping and decompresses all bands at once. Specifically needed to convert YCC color space to RGB.

Parameters

Kakadu	channel mapping object.
codestream	Stream to pull from.
region	The region wanted from codestream.
discard_levels	The resolution level, 0 being full res.
threadEnv	Pointer to kdu_thread_env.
threadQueue	Pointer to kdu_thread_queue.
destTile	The ossimImageData object to copy to.

Returns: true on success, false on error.

Definition at line 164 of file ossimKakaduCommon.cpp.

Referenced by ossimKakaduNitfReader::getOverviewTile(), ossimKakaduJ2kReader::getOverviewTile(), ossimKakaduJp2Reader::getOverviewTile(), and ossimKakaduJpipHandler::getTileAtRes().

 {
    bool result = true;
 
    if ( channelMapping && destTile && codestream.exists())// && threadEnv && threadQueue )
    {
       try // Kakadu throws exceptions...
       {
          kdu_core::kdu_dims region;
          getDims(destTile->getImageRectangle(), region);
       
          kdu_core::kdu_dims clipRegion;
          if ( clipRegionToImage(codestream,
                                 region,
                                 discard_levels,
                                 clipRegion) )
          {
             if (region != clipRegion)
             {
                // Not filling whole tile.
                destTile->makeBlank();
             }
          
             const ossim_uint32 BANDS = destTile->getNumberOfBands();
             const ossimScalarType SCALAR = destTile->getScalarType();
          
             int max_layers = INT_MAX;
             kdu_core::kdu_coords expand_numerator(1,1);
             kdu_core::kdu_coords expand_denominator(1,1);
             bool precise = true;
             kdu_core::kdu_component_access_mode access_mode =
                kdu_core::KDU_WANT_OUTPUT_COMPONENTS;
             bool fastest = false;
 
             // Start the kdu_region_decompressor.
             kdu_supp::kdu_region_decompressor krd;
             if ( krd.start( codestream,
                             channelMapping,
                             -1,
                             discard_levels,
                             max_layers,
                             clipRegion,
                             expand_numerator,
                             expand_denominator,
                             precise,
                             access_mode,
                             fastest,
                             threadEnv,
                             threadQueue )
                  == false)
             {
                std::string e = "kdu_region_decompressor::start error!";
                throw(ossimException(e));
             }
 
             bool expand_monochrome = false;
             int pixel_gap = 1;
             kdu_core::kdu_coords buffer_origin;
             buffer_origin.x = destTile->getImageRectangle().ul().x;
             buffer_origin.y = destTile->getImageRectangle().ul().y;
             int row_gap = region.size.x;
             int suggested_increment = static_cast<int>(destTile->getSize());
             int max_region_pixels = suggested_increment;
             kdu_core::kdu_dims incomplete_region = clipRegion;
             kdu_core::kdu_dims new_region;
             bool measure_row_gap_in_pixels = true;
          
             // For signed int set precision bit to 0 for kakadu.
             int precision_bits = (SCALAR != OSSIM_SINT16) ? codestream.get_bit_depth(0, true) : 0;
 
             switch (SCALAR)
             {
                case OSSIM_UINT8:
                {
                   // Get pointers to the tile buffers.
                   std::vector<kdu_core::kdu_byte*> channel_bufs(BANDS);
                   for ( ossim_uint32 band = 0; band < BANDS; ++band )
                   {
                      channel_bufs[band] = destTile->getUcharBuf(band);
                   }
 
                   while ( !incomplete_region.is_empty() )
                   {
                      if ( krd.process( &channel_bufs.front(),
                                        expand_monochrome,
                                        pixel_gap,
                                        buffer_origin,
                                        row_gap, 
                                        suggested_increment,
                                        max_region_pixels,
                                        incomplete_region,
                                        new_region,
                                        precision_bits,
                                        measure_row_gap_in_pixels ) == false )
                      {
                         break;
                      }
                   }
 
                   // Wait for things to finish.
                   if( threadEnv && threadQueue )
                   {
                      //---
                      // Wait for all queues descended from `root_queue' to identify themselves
                      // as "finished" via the `kdu_thread_queue::all_done' function.
                      //---
                      threadEnv->join(threadQueue, true);
                   }
                   
                   // Validate the tile.
                   destTile->validate();
 
                   break;
                }
                case OSSIM_UINT11:
                case OSSIM_UINT12:
                case OSSIM_UINT13:
                case OSSIM_UINT14:                  
                case OSSIM_UINT15:                  
                case OSSIM_UINT16:
                case OSSIM_SINT16:
                {
                   // Get pointers to the tile buffers.
                   std::vector<kdu_core::kdu_uint16*> channel_bufs(BANDS);
                   for ( ossim_uint32 band = 0; band < BANDS; ++band )
                   {
                      channel_bufs[band] = static_cast<kdu_core::kdu_uint16*>(
                         destTile->getBuf(band));
                   }
 
                   while ( !incomplete_region.is_empty() )
                   {
                      //---
                      // Note: precision_bits set to 0 to indicate "signed" data
                      // for the region decompressor.
                      //---
                      if ( krd.process( &channel_bufs.front(),
                                        expand_monochrome,
                                        pixel_gap,
                                        buffer_origin,
                                        row_gap, 
                                        suggested_increment,
                                        max_region_pixels,
                                        incomplete_region,
                                        new_region,
                                        precision_bits,
                                        measure_row_gap_in_pixels ) == false )
                      {
                         break;
                      }
                   }
 
                   // Wait for things to finish.
                   if( threadEnv && threadQueue )
                   {
                      //---
                      // Wait for all queues descended from `root_queue' to identify themselves
                      // as "finished" via the `kdu_thread_queue::all_done' function.
                      //---
                      threadEnv->join(threadQueue, true);
                   }
                   
                   // Validate the tile.
                   destTile->validate();
 
                   break;
                }
                case OSSIM_SINT32:
                case OSSIM_FLOAT32:
                {
                   //---
                   // NOTES:
                   // 1) Signed 32 bit integer data gets normalized when compressed
                   //    so use the same code path as float data.
                   // 2) Cannot call "ossimImageData::getFloatBuf" as it will return a
                   //    null pointer if the destination tile is OSSIM_SINT32 scalar type.
                   //---
 
                   // Get pointers to the tile buffers.
                   std::vector<ossim_float32*> channel_bufs(BANDS);
                   for ( ossim_uint32 band = 0; band < BANDS; ++band )
                   {
                      channel_bufs[band] = static_cast<ossim_float32*>(destTile->getBuf(band));
                   }
 
                   while ( !incomplete_region.is_empty() )
                   {
                      //---
                      // Note: precision_bits set to 0 to indicate "signed" data
                      // for the region decompressor.
                      //---
                      if ( krd.process( &channel_bufs.front(),
                                        expand_monochrome,
                                        pixel_gap,
                                        buffer_origin,
                                        row_gap,
                                        suggested_increment,
                                        max_region_pixels,
                                        incomplete_region,
                                        new_region,
                                        true, // normalize
                                        measure_row_gap_in_pixels ) )
                      {
                         break;
                      }
                   }
                   
                   if( threadEnv && threadQueue )
                   {
                      //---
                      // Wait for all queues descended from `root_queue' to identify themselves
                      // as "finished" via the `kdu_thread_queue::all_done' function.
                      //---
                      threadEnv->join(threadQueue, true);
                   }
                   
                   // Un-normalize.
                   ossim::unNormalizeTile(destTile);
                   
                   // Validate the tile.
                   destTile->validate();
 
                   break;
                }
                default:
                {
                   ossimNotify(ossimNotifyLevel_WARN)
                      << __FILE__ << " " << __LINE__ << " Unhandle scalar: "
                      << destTile->getScalarType() << "\n";
                   result = false;
                   break;
                }
                
             } // End of:  switch (theScalarType)
             
             // Every call to kdu_region_decompressor::start has a finish.
             if ( krd.finish() == false )
             {
                ossimNotify(ossimNotifyLevel_WARN)
                   << __FILE__ << " " << __LINE__
                   << "kdu_region_decompressor::proces error!\n";
             }
          }
          else // No region intersect with image.
          {
             destTile->makeBlank();
          }
          
       } // Matches: try{ ...
       
       // Catch and rethrow exceptions.
       catch( const ossimException& /* e */ )
       {
          throw;
       }
       catch ( kdu_core::kdu_exception exc )
       {
          // kdu_exception is an int typedef.
          if ( threadEnv != 0 )
          {
             threadEnv->handle_exception(exc);
          }
          ostringstream e;
          e << "Caught exception from kdu_region_decompressor: " << exc << "\n";
          throw ossimException( e.str() );
       }
       catch ( std::bad_alloc& )
       {
          if ( threadEnv != 0 )
          {
             threadEnv->handle_exception(KDU_MEMORY_EXCEPTION);
          }
          std::string e =
             "Caught exception from kdu_region_decompressor: std::bad_alloc";
          throw ossimException( e );
       }
       catch( ... )
       {
          std::string e =
             "Caught unhandled exception from kdu_region_decompressor";
          throw ossimException( e );
       }
    }
    else  // no codestream
    {
       result = false;
    }
 
 #if 0  /* Please leave for serious debug. (drb) */
    if (destTile)
    {
       static int tileNumber = 0;
       if (destTile)
       {
          ossimFilename f = "tile-dump";
          f += ossimString::toString(tileNumber);
          f += ".ras";
          if (destTile->write(f))
          {
             ossimNotify(ossimNotifyLevel_DEBUG)
                << "wrote: " << f << std::endl;
             ++tileNumber;
          }
       }
    }
 #endif
    
    return result;
 
 } // End: ossim::copyRegionToTile

◆ copyRegionToTile() [2/2]

bool ossim::copyRegionToTile	(	kdu_core::kdu_codestream &	codestream,
		int	discard_levels,
		kdu_core::kdu_thread_env *	threadEnv,
		kdu_core::kdu_thread_queue *	threadQueue,
		ossimImageData *	destTile
	)

Copies region from codestream to tile at a given rlevel.

This method takes a codestream and decompresses each band separately. Specifically needed for n-band data where the kdu_channel_mapping will not work.

Parameters

codestream	Stream to pull from.
region	The region wanted from codestream.
discard_levels	The resolution level, 0 being full res.
threadEnv	Pointer to kdu_thread_env.
threadQueue	Pointer to kdu_thread_queue.
destTile	The ossimImageData object to copy to.

Returns: true on success, false on error.

Definition at line 481 of file ossimKakaduCommon.cpp.

 {
    bool result = true;
 
    if ( destTile && codestream.exists())// && threadEnv && threadQueue )
    {
       try // Kakadu throws exceptions...
       {
          kdu_core::kdu_dims region;
          getDims(destTile->getImageRectangle(), region);
 
          kdu_core::kdu_dims clipRegion;
          if ( clipRegionToImage(codestream,
                                 region,
                                 discard_levels,
                                 clipRegion) )
          {
             if (region != clipRegion)
             {
                // Not filling whole tile.
                destTile->makeBlank();
             }
             
             const ossimScalarType SCALAR = destTile->getScalarType();
             const ossim_uint32 BANDS = destTile->getNumberOfBands();
             
             kdu_supp::kdu_channel_mapping* mapping = 0;
             int max_layers = INT_MAX;
             kdu_core::kdu_coords expand_numerator(1,1);
             kdu_core::kdu_coords expand_denominator(1,1);
             bool precise = true;
             kdu_core::kdu_component_access_mode access_mode =
                kdu_core::KDU_WANT_OUTPUT_COMPONENTS;
             bool fastest = false;
             
             //---
             // band loop:
             // Note: At some point we may want to be a band selector;
             // in which case, we would loop through the band list.
             // For now just go through all bands and let the ossimBandSelector
             // weed them out.
             //---
             for (ossim_uint32 band = 0; band < BANDS; ++band)
             {
                int single_component = band;
             
                // Start the kdu_region_decompressor.
                kdu_supp::kdu_region_decompressor krd;
                
                if ( krd.start( codestream,
                                mapping,
                                single_component,
                                discard_levels,
                                max_layers,
                                clipRegion,
                                expand_numerator,
                                expand_denominator,
                                precise,
                                access_mode,
                                fastest,
                                threadEnv,
                                threadQueue )
                     == false)
                {
                   std::string e = "kdu_region_decompressor::start error!";
                   throw(ossimException(e));
                }
                
                vector<int> channel_offsets(1);
                channel_offsets[0] = 0;
                int pixel_gap = 1;
                kdu_core::kdu_coords buffer_origin;
                buffer_origin.x = destTile->getImageRectangle().ul().x;
                buffer_origin.y = destTile->getImageRectangle().ul().y;
                int row_gap = region.size.x;
                int suggested_increment = static_cast<int>(destTile->getSize());
                int max_region_pixels = suggested_increment;
                kdu_core::kdu_dims incomplete_region = clipRegion;
                kdu_core::kdu_dims new_region;
                bool measure_row_gap_in_pixels = true;
                
                // For signed int set precision bit to 0 for kakadu.
                int precision_bits = (SCALAR != OSSIM_SINT16) ? codestream.get_bit_depth(0, true) : 0;
                
                switch (SCALAR)
                {
                   case OSSIM_UINT8:
                   {
                      // Get pointer to the tile buffer.
                      kdu_core::kdu_byte* buffer = destTile->getUcharBuf(band);
                      
                      while ( !incomplete_region.is_empty() )
                      {
                         if ( krd.process( buffer,
                                           &channel_offsets.front(),
                                           pixel_gap,
                                           buffer_origin,
                                           row_gap,
                                           suggested_increment,
                                           max_region_pixels,
                                           incomplete_region,
                                           new_region,
                                           precision_bits,
                                           measure_row_gap_in_pixels ) )
                         {
                            break;
                         }
                      }
 
                      if( threadEnv && threadQueue)
                      {
                         //---
                         // Wait for all queues descended from `root_queue' to identify themselves
                         // as "finished" via the `kdu_thread_queue::all_done' function.
                         //---
                         threadEnv->join(threadQueue, true);
                      }
                      
                      // Validate the tile.
                      destTile->validate();
 
                      break;
                   }
                   case OSSIM_UINT11:
                   case OSSIM_UINT12:
                   case OSSIM_UINT13:
                   case OSSIM_UINT14:                  
                   case OSSIM_UINT15:                  
                   case OSSIM_UINT16:
                   case OSSIM_SINT16:   
                   {
                      // Get pointer to the tile buffer.
                      kdu_core::kdu_uint16* buffer =
                         static_cast<kdu_core::kdu_uint16*>(destTile->getBuf(band));
                      
                      while ( !incomplete_region.is_empty() )
                      {
                         //---
                         // Note: precision_bits set to 0 to indicate "signed" data
                         // for the region decompressor.
                         //---
                         if ( krd.process( buffer,
                                           &channel_offsets.front(),
                                           pixel_gap,
                                           buffer_origin,
                                           row_gap,
                                           suggested_increment,
                                           max_region_pixels,
                                           incomplete_region,
                                           new_region,
                                           precision_bits,
                                           measure_row_gap_in_pixels ) == false )
                         {
                            break;
                         }
                      }
                      
                      //---
                      // Wait for all queues descended from `root_queue' to identify themselves
                      // as "finished" via the `kdu_thread_queue::all_done' function.
                      //---
                      if( threadEnv && threadQueue)
                      {
                         threadEnv->join(threadQueue, true);
                      }
                      
                      // Validate the tile.
                      destTile->validate();
                   
                      break;
                   }
                   case OSSIM_SINT32:
                   case OSSIM_FLOAT32:
                   {
                      //---
                      // NOTES:
                      // 1) Signed 32 bit integer data gets normalized when compressed
                      //    so use the same code path as float data.
                      // 2) Cannot call "ossimImageData::getFloatBuf" as it will return a
                      //    null pointer if the destination tile is OSSIM_SINT32 scalar type.
                      //---
                      
                      // Get pointer to the tile buffer.
                      ossim_float32* buffer = static_cast<ossim_float32*>(destTile->getBuf(band));
                      
                      while ( !incomplete_region.is_empty() )
                      {
                         //---
                         // Note: precision_bits set to 0 to indicate "signed" data
                         // for the region decompressor.
                         //---
                         if ( krd.process( buffer,
                                           &channel_offsets.front(),
                                           pixel_gap,
                                           buffer_origin,
                                           row_gap,
                                           suggested_increment,
                                           max_region_pixels,
                                           incomplete_region,
                                           new_region,
                                           true, // normalize
                                           measure_row_gap_in_pixels ) == false )
                         {
                            break;
                         }
                      }
                
                      if( threadEnv && threadQueue)
                      {
                         //---
                         // Wait for all queues descended from `root_queue' to identify themselves
                         // as "finished" via the `kdu_thread_queue::all_done' function.
                         //---
                         threadEnv->join(threadQueue, true);
                      }
                
                      // Un-normalize.
                      ossim::unNormalizeTile(destTile);
                      
                      // Validate the tile.
                      destTile->validate();
                      
                      break;
                   }
                   
                   default:
                   {
                      ossimNotify(ossimNotifyLevel_WARN)
                         << __FILE__ << " " << __LINE__ << " Unhandle scalar: "
                         << destTile->getScalarType() << "\n";
                      result = false;
                      break;
                   }
          
                } // End of:  switch (theScalarType)
             
                // Every call to kdu_region_decompressor::start has a finish.
                if ( krd.finish() == false )
                {
                   result = false;
                   ossimNotify(ossimNotifyLevel_WARN)
                      << __FILE__ << " " << __LINE__
                      << " kdu_region_decompressor::proces error!" << std::endl;
                }
                
          
             } // End of band loop.
          }
          else // No region intersect with image.
          {
             destTile->makeBlank();
          }
          
       } // Matches: try{ ...
 
       // Catch and rethrow exceptions.
       catch( const ossimException& /* e */ )
       {
          throw;
       }
       catch ( kdu_core::kdu_exception exc )
       {
          // kdu_exception is an int typedef.
          if ( threadEnv != 0 )
          {
             threadEnv->handle_exception(exc);
          }
          ostringstream e;
          e << "Caught exception from kdu_region_decompressor: " << exc << "\n";
          throw ossimException( e.str() );
          
       }
       catch ( std::bad_alloc& )
       {
          if ( threadEnv != 0 )
          {
             threadEnv->handle_exception(KDU_MEMORY_EXCEPTION);
          }
          std::string e =
             "Caught exception from kdu_region_decompressor: std::bad_alloc";
          throw ossimException( e );
       }
       catch( ... )
       {
          std::string e =
             "Caught unhandled exception from kdu_region_decompressor";
          throw ossimException(e);
       }
    }
    else  // no codestream
    {
       result = false;
    }
 
 #if 0  /* Please leave for serious debug. (drb) */
    if (destTile)
    {
       static int tileNumber = 0;
       if (destTile)
       {
          ossimFilename f = "tile-dump";
          f += ossimString::toString(tileNumber);
          f += ".ras";
          if (destTile->write(f))
          {
             ossimNotify(ossimNotifyLevel_DEBUG)
                << "wrote: " << f << std::endl;
             ++tileNumber;
          }
       }
    }
 #endif
    
    return result;
 
 } // End: ossim::copyRegionToTile

◆ cosd()

double ossim::cosd ( double x )

inline

Definition at line 259 of file ossimCommon.h.

References RAD_PER_DEG, and x.

259 { return std::cos(x*RAD_PER_DEG); }

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519

Referenced by ossimGdalTileSource::computeMinMax(), ossim3x3ConvolutionFilter::computeNullMinMax(), ossimConvolutionFilter1D::computeNullMinMax(), ossimConvolutionSource::convolve(), ossimImageMetaData::getMaxPix(), ossimImageData::getMaxPix(), ossimCastTileSourceFilter::getMaxPixelValue(), ossimHdf5ImageDataset::getMaxPixelValue(), ossimImageSource::getMaxPixelValue(), ossimImageChain::getMaxPixelValue(), ossimEquationCombiner::getMaxPixelValue(), ossimGdalTileSource::getMaxPixelValue(), ossimImageHandler::getMaxPixelValue(), ossimCastTileSourceFilter::getMinPixelValue(), ossimBandAverageFilter::getMinPixelValue(), ossimHistogramRemapper::initializeClips(), ossimImageData::initializeMaxDefault(), ossimHistogramRemapper::initializeMinMaxOutput(), ossimImageMetaData::setDefaultsForArrays(), ossimHistogramRemapper::setupTable(), ossimImageData::stretchMinMax(), and ossimTiffTileSource::validateMinMaxNull().

#define RAD_PER_DEG

Definition: ossimConstants.h:458

◆ defaultMax()

double ossim::defaultMax ( ossimScalarType scalarType )

Definition at line 152 of file ossimCommon.cpp.

 {
    switch(scalarType)
    {
       case OSSIM_UINT8:
       {
          return OSSIM_DEFAULT_MAX_PIX_UINT8;
       }
       case OSSIM_SINT8:
       {
          return OSSIM_DEFAULT_MAX_PIX_SINT8;
       }
       case OSSIM_UINT16:
       {
     return OSSIM_DEFAULT_MAX_PIX_UINT16;
       }
       case OSSIM_SINT16:
       {
          return OSSIM_DEFAULT_MAX_PIX_SINT16;
       }
       case OSSIM_UINT11:
       {
          return OSSIM_DEFAULT_MAX_PIX_UINT11;
       }
       case OSSIM_UINT12:
       {
          return OSSIM_DEFAULT_MAX_PIX_UINT12;
       }
       case OSSIM_UINT13:
       {
          return OSSIM_DEFAULT_MAX_PIX_UINT13;
       }
       case OSSIM_UINT14:
       {
          return OSSIM_DEFAULT_MAX_PIX_UINT14;
       }
       case OSSIM_UINT15:
       {
          return OSSIM_DEFAULT_MAX_PIX_UINT15;
       }
       case OSSIM_UINT32:
       {
     return OSSIM_DEFAULT_MAX_PIX_UINT32;
       }
       case OSSIM_SINT32:
       {
          return OSSIM_DEFAULT_MAX_PIX_SINT32;
       }
       case OSSIM_FLOAT32:
       {
          return OSSIM_DEFAULT_MAX_PIX_FLOAT;
       }
       case OSSIM_NORMALIZED_FLOAT:
       {
          return OSSIM_DEFAULT_MAX_PIX_NORM_FLOAT;
       }
       case OSSIM_FLOAT64:
       {
          return OSSIM_DEFAULT_MAX_PIX_DOUBLE;
       }
       case OSSIM_NORMALIZED_DOUBLE:
       {
          return OSSIM_DEFAULT_MAX_PIX_NORM_DOUBLE;
       }
       case OSSIM_SCALAR_UNKNOWN:
       default:
       {
          if(traceDebug())
          {
             ossimNotify(ossimNotifyLevel_WARN)
                << __FILE__ << ":" << __LINE__
                << "\nUnhandled scalar type:  " << scalarType << std::endl;
          }
          break;
       }
    }
    return 0.0; // Should never happen...
 }

◆ defaultMin()

double ossim::defaultMin ( ossimScalarType scalarType )

Definition at line 73 of file ossimCommon.cpp.

Referenced by ossimGdalTileSource::computeMinMax(), ossim3x3ConvolutionFilter::computeNullMinMax(), ossimConvolutionFilter1D::computeNullMinMax(), ossimConvolutionSource::convolve(), ossimCastTileSourceFilter::getMaxPixelValue(), ossimBandAverageFilter::getMaxPixelValue(), ossimImageMetaData::getMinPix(), ossimImageData::getMinPix(), ossimCastTileSourceFilter::getMinPixelValue(), ossimHdf5ImageDataset::getMinPixelValue(), ossimImageSource::getMinPixelValue(), ossimImageChain::getMinPixelValue(), ossimEquationCombiner::getMinPixelValue(), ossimGdalTileSource::getMinPixelValue(), ossimImageHandler::getMinPixelValue(), ossimHistogramRemapper::initializeClips(), ossimImageData::initializeMinDefault(), ossimHistogramRemapper::initializeMinMaxOutput(), ossimPiecewiseRemapper::initMinMax(), ossimImageMetaData::setDefaultsForArrays(), ossimHistogramRemapper::setupTable(), ossimImageData::stretchMinMax(), and ossimTiffTileSource::validateMinMaxNull().

 {
    switch(scalarType)
    {
       case OSSIM_UINT8:
       {
     return OSSIM_DEFAULT_MIN_PIX_UINT8;
       }
       case OSSIM_SINT8:
       {
     return OSSIM_DEFAULT_MIN_PIX_SINT8;
       }
       case OSSIM_UINT16:
       {
          return OSSIM_DEFAULT_MIN_PIX_UINT16;
       }
       case OSSIM_SINT16:
       {
          return OSSIM_DEFAULT_MIN_PIX_SINT16;
       }
       case OSSIM_USHORT11:
       {
          return OSSIM_DEFAULT_MIN_PIX_UINT11;
       }
       case OSSIM_USHORT12:
       {
          return OSSIM_DEFAULT_MIN_PIX_UINT12;
       }
       case OSSIM_USHORT13:
       {
          return OSSIM_DEFAULT_MIN_PIX_UINT13;
       }
       case OSSIM_USHORT14:
       {
          return OSSIM_DEFAULT_MIN_PIX_UINT14;
       }
       case OSSIM_USHORT15:
       {
          return OSSIM_DEFAULT_MIN_PIX_UINT15;
       }
       case OSSIM_UINT32:
       {
          return OSSIM_DEFAULT_MIN_PIX_UINT32;
       }
       case OSSIM_SINT32:
       {
          return OSSIM_DEFAULT_MIN_PIX_SINT32;
       }
       case OSSIM_FLOAT32:
       {
          return OSSIM_DEFAULT_MIN_PIX_FLOAT;
       }
       case OSSIM_NORMALIZED_FLOAT:
       {
          return OSSIM_DEFAULT_MIN_PIX_NORM_FLOAT;
       }
       case OSSIM_FLOAT64:
       {
          return OSSIM_DEFAULT_MIN_PIX_DOUBLE;
       }
       case OSSIM_NORMALIZED_DOUBLE:
       {
          return OSSIM_DEFAULT_MIN_PIX_NORM_DOUBLE;
       }
       case OSSIM_SCALAR_UNKNOWN:
       default:
       {
          if(traceDebug())
          {
             ossimNotify(ossimNotifyLevel_DEBUG)
                << __FILE__ << ":" << __LINE__
                << "\nUnhandled scalar type:  " << scalarType << std::endl;
          }
          break;
       }
    }
    return 0.0; // Should never happen...
 }

◆ defaultNull()

double ossim::defaultNull ( ossimScalarType scalarType )

Definition at line 231 of file ossimCommon.cpp.

 {
    switch(scalarType)
    {
       case OSSIM_UINT8:
       {
          return OSSIM_DEFAULT_NULL_PIX_UINT8;
       }
       case OSSIM_SINT8:
       {
          return OSSIM_DEFAULT_NULL_PIX_SINT8;
       }
       case OSSIM_UINT16:
       {
          return OSSIM_DEFAULT_NULL_PIX_UINT16;
       }
       case OSSIM_SINT16:
       {
          return OSSIM_DEFAULT_NULL_PIX_SINT16;
       }
       case OSSIM_UINT11:
       {
          return OSSIM_DEFAULT_NULL_PIX_UINT11;
       }
       case OSSIM_UINT12:
       {
          return OSSIM_DEFAULT_NULL_PIX_UINT12;
       }
       case OSSIM_UINT13:
       {
          return OSSIM_DEFAULT_NULL_PIX_UINT13;
       }
       case OSSIM_UINT14:
       {
          return OSSIM_DEFAULT_NULL_PIX_UINT14;
       }
       case OSSIM_UINT15:
       {
          return OSSIM_DEFAULT_NULL_PIX_UINT15;
       }
       case OSSIM_UINT32:
       {
          return OSSIM_DEFAULT_NULL_PIX_UINT32;
       }
       case OSSIM_SINT32:
       {
          return OSSIM_DEFAULT_NULL_PIX_SINT32;
       }
       case OSSIM_FLOAT32:
       {
          return OSSIM_DEFAULT_NULL_PIX_FLOAT;
       }
       case OSSIM_NORMALIZED_FLOAT:
       {
          return OSSIM_DEFAULT_NULL_PIX_NORM_FLOAT;
       }
       case OSSIM_FLOAT64:
       {
          return OSSIM_DEFAULT_NULL_PIX_DOUBLE;
       }
       case OSSIM_NORMALIZED_DOUBLE:
       {
          return OSSIM_DEFAULT_NULL_PIX_NORM_DOUBLE;
       }
       case OSSIM_SCALAR_UNKNOWN:
       default:
       {
          if(traceDebug())
          {
             ossimNotify(ossimNotifyLevel_DEBUG)
                << __FILE__ << ":" << __LINE__
                << "\nUnhandled scalar type:  " << scalarType << std::endl;
          }
          break;
       }
     }
 
    return 0.0; // Should never happen...
 }

◆ defaultTileSize()

void ossim::defaultTileSize ( ossimIpt & tileSize )

Definition at line 525 of file ossimCommon.cpp.

References ossimPreferences::instance(), OSSIM_DEFAULT_TILE_HEIGHT, OSSIM_DEFAULT_TILE_WIDTH, ossimString::split(), ossimIpt::x, and ossimIpt::y.

Referenced by ossimJpegTileSource::allocate(), ossimPngReader::allocate(), computeLevels(), ossimImageDataFactory::create(), ossimImageSource::getTileHeight(), ossimPointCloudImageHandler::getTileHeight(), ossimGpkgReader::getTileHeight(), ossimNitfTileSource::getTileHeight(), ossimLasReader::getTileHeight(), ossimTiffTileSource::getTileHeight(), ossimPdfWriter::getTileSize(), ossimImageSource::getTileWidth(), ossimPointCloudImageHandler::getTileWidth(), ossimGpkgReader::getTileWidth(), ossimNitfTileSource::getTileWidth(), ossimLasReader::getTileWidth(), ossimTiffTileSource::getTileWidth(), ossimOverviewBuilderBase::initializePreferenceSettings(), ossimKakaduJ2kReader::initializeTile(), ossimKakaduJp2Reader::initializeTile(), ossimTiffWriter::loadState(), ossimCacheTileSource::ossimCacheTileSource(), ossimDtedTileSource::ossimDtedTileSource(), ossimFixedTileCache::ossimFixedTileCache(), ossimImageData::ossimImageData(), ossimImageElevationHandler::ossimImageElevationHandler(), ossimImageSourceSequencer::ossimImageSourceSequencer(), ossimNitfWriter::ossimNitfWriter(), ossimWriter::ossimWriter(), and ossimFixedTileCache::setRect().

 {
    const char* tileSizeKw = ossimPreferences::instance()->
       findPreference("tile_size");
 
    if(tileSizeKw)
    {
       std::vector<ossimString> splitArray;
       ossimString tempString(tileSizeKw);
       tempString.split(splitArray, " ");
       bool hasX = true;
     if(splitArray.size() == 2)
       {
          tileSize.x = splitArray[0].toInt32();
          tileSize.y = splitArray[1].toInt32();
       }
       else if(splitArray.size() == 1)
       {
          tileSize.x = splitArray[0].toInt32();
          tileSize.y = splitArray[0].toInt32();
       }
       else
       {
          tileSize = ossimIpt(0,0);
       }
       if(tileSize.x < 1)
       {
          tileSize.x = OSSIM_DEFAULT_TILE_WIDTH;
          hasX = false;
       }
       if(tileSize.y < 1)
       {
          if(!hasX)
          {
             tileSize.y = OSSIM_DEFAULT_TILE_HEIGHT;
          }
          else
          {
             tileSize.y = tileSize.x;
          }
       }
    }
    else
    {
       tileSize.x = OSSIM_DEFAULT_TILE_WIDTH;
       tileSize.y = OSSIM_DEFAULT_TILE_HEIGHT;
    }
 }

◆ degreesToRadians()

double ossim::degreesToRadians ( double x )

inline

Definition at line 258 of file ossimCommon.h.

References RAD_PER_DEG, and x.

Referenced by ossim::Quaternion::makeRotate(), ossimIpodSensor::updateModel(), ossimSkyBoxLearSensor::updateModel(), ossimSonomaSensor::updateModel(), and ossimRsmModel::worldToLineSample().

258 { return x*RAD_PER_DEG;}

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519

#define RAD_PER_DEG

Definition: ossimConstants.h:458

◆ extractSimpleValues()

bool ossim::extractSimpleValues	(	std::vector< ossimString > &	values,
		const ossimString &	stringOfPoints
	)

Generic function to extract a list of values into a vector of string where the string of points is of the form:

(value1,value2, ... , )

Parenthesis are required

Definition at line 948 of file ossimCommon.cpp.

References ossimString::empty(), and skipws().

Referenced by toSimpleVector().

 {
    std::istringstream in(stringOfPoints);
    ossim::skipws(in);
    bool result = true;
    if(stringOfPoints.empty()) return result;
    char c = in.get();
    ossimString value = "";
    if(c == '(')
    {
       c = (char)in.get();
       while((c!=')')&&
             (in.good()))
       {
          if(c!= ',')
          {
             value += ossimString(c);
          }
          else
          {
             values.push_back(value);
             value = "";
          }
          ossim::skipws(in);
          c = in.get();
       }
    }
    if(c!= ')')
    {
       result = false;
    }
    else
    {
       if(!value.empty())
       {
          values.push_back(value);
       }
    }
    
    return result;
 }

◆ ft2mtrs()

double ossim::ft2mtrs ( double feet )

inline

Definition at line 372 of file ossimCommon.h.

References MTRS_PER_FT.

Referenced by ossimGeoTiff::convert2meters().

372 { return (feet * MTRS_PER_FT); }

MTRS_PER_FT

#define MTRS_PER_FT

Definition: ossimConstants.h:461

◆ gcd()

template<class IntType >

IntType ossim::gcd	(	IntType	n,
		IntType	m
	)

Definition at line 271 of file ossimCommon.h.

References n.

Referenced by gcd< int >(), lcm(), ossimRationalNumber::normalize(), ossimRationalNumber::operator*(), ossimRationalNumber::operator*=(), ossimRationalNumber::operator+(), ossimRationalNumber::operator+=(), ossimRationalNumber::operator-(), and ossimRationalNumber::operator-=().

         {
             IntType zero(0);    // Avoid repeated construction
             
             // This is abs() - given the existence of broken compilers with Koenig
             // lookup issues and other problems, I code this explicitly. (Remember,
             // IntType may be a user-defined type).
             if (n < zero)
                 n = -n;
             if (m < zero)
                 m = -m;
             
             // As n and m are now positive, we can be sure that %= returns a
             // positive value (the standard guarantees this for built-in types,
             // and we require it of user-defined types).
             for (;;) {
                 if (m == zero)
                     return n;
                 n %= m;
                 if (n == zero)
                     return m;
                 m %= n;
             }
         }

◆ gcd< int >()

template<>

int ossim::gcd< int >	(	int	n,
		int	m
	)

inline

Definition at line 300 of file ossimCommon.h.

References gcd(), and n.

         { 
             if (m == 0)
                 return n;
             else
                 return gcd(m, n % m);  // gcc can optimize tail calls right?
         }

◆ getActualBitsPerPixel()

ossim_uint32 ossim::getActualBitsPerPixel ( ossimScalarType scalarType )

Get actual bits per pixel for a given scalar type.

This is bits used. (OSSIM_USHORT11 = 11)

Returns: The actual bits per pixel. This will return 0 if the input connection is not hooked up or there is an unhandled scalar type.

Definition at line 392 of file ossimCommon.cpp.

References OSSIM_CFLOAT32, OSSIM_CFLOAT64, OSSIM_CINT16, OSSIM_CINT32, OSSIM_FLOAT32, OSSIM_FLOAT64, OSSIM_NORMALIZED_DOUBLE, OSSIM_NORMALIZED_FLOAT, OSSIM_SINT16, OSSIM_SINT32, OSSIM_SINT8, OSSIM_UINT16, OSSIM_UINT32, OSSIM_UINT8, OSSIM_USHORT11, OSSIM_USHORT12, OSSIM_USHORT13, OSSIM_USHORT14, and OSSIM_USHORT15.

Referenced by ossimOpjCompressor::createOpjImage(), ossimNitf20Writer::writeBlockBandSeparate(), ossimNitfWriter::writeBlockBandSeparate(), ossimNitf20Writer::writeBlockBandSequential(), ossimNitfWriter::writeBlockBandSequential(), and ossimKakaduCompressor::writeTile().

 {
    ossim_uint32 actualBitsPerPixel = 0;
    switch(scalarType)
    {
       case OSSIM_UINT8:
       case OSSIM_SINT8:
       {
          actualBitsPerPixel = 8;
          break;
       }
       case OSSIM_USHORT11:
       {
          actualBitsPerPixel = 11;
          break;
       }
       case OSSIM_USHORT12:
       {
          actualBitsPerPixel = 12;
          break;
       }
       case OSSIM_USHORT13:
       {
          actualBitsPerPixel = 13;
          break;
       }
       case OSSIM_USHORT14:
       {
          actualBitsPerPixel = 14;
          break;
       }
       case OSSIM_USHORT15:
       {
          actualBitsPerPixel = 15;
          break;
       }
       case OSSIM_UINT16:
       case OSSIM_SINT16:
       {
          actualBitsPerPixel = 16;
          break;
       }
       case OSSIM_UINT32:
       case OSSIM_SINT32:
       case OSSIM_FLOAT32:
       case OSSIM_CINT16:
       case OSSIM_NORMALIZED_FLOAT:
       {
          actualBitsPerPixel = 32;
          break;
       }
       case OSSIM_FLOAT64:
       case OSSIM_CFLOAT32:
       case OSSIM_CINT32:
       case OSSIM_NORMALIZED_DOUBLE:
       {
          actualBitsPerPixel = 64;
          break;
       }
       case OSSIM_CFLOAT64:
       {
          actualBitsPerPixel = 128;
          
          break;
       }
       default:
       {
          if (traceDebug())
          {
             ossimNotify(ossimNotifyLevel_DEBUG)
                << __FILE__ << ":" << __LINE__
                << "\nUnhandled scalar type:  " << scalarType << std::endl;
          }
          break;
       }
    }
    return actualBitsPerPixel;
 }

◆ getBitsPerPixel()

ossim_uint32 ossim::getBitsPerPixel ( ossimScalarType scalarType )

Get bits per pixel for a given scalar type.

This the total bits per pixel. (OSSIM_USHORT11 = 16)

Returns: The bits per pixel. This will return 0 if the input connection is not hooked up or there is an unhandled scalar type.

Definition at line 471 of file ossimCommon.cpp.

References OSSIM_FLOAT32, OSSIM_FLOAT64, OSSIM_NORMALIZED_DOUBLE, OSSIM_NORMALIZED_FLOAT, OSSIM_SINT16, OSSIM_SINT32, OSSIM_SINT8, OSSIM_UINT16, OSSIM_UINT32, OSSIM_UINT8, OSSIM_USHORT11, OSSIM_USHORT12, OSSIM_USHORT13, OSSIM_USHORT14, and OSSIM_USHORT15.

Referenced by ossimOpjCompressor::createOpjImage(), ossimNitfCommon::getCompressionRate(), ossimNitf20Writer::writeBlockBandSeparate(), ossimNitfWriter::writeBlockBandSeparate(), ossimNitf20Writer::writeBlockBandSequential(), ossimNitfWriter::writeBlockBandSequential(), and ossimWriter::writeTiffTags().

 {
    ossim_uint32 bitsPerPixel = 0;
    switch(scalarType)
    {
       case OSSIM_UINT8:
       case OSSIM_SINT8:
       {
          bitsPerPixel = 8;
          break;
       }
       case OSSIM_USHORT11:
       case OSSIM_USHORT12:
       case OSSIM_USHORT13:
       case OSSIM_USHORT14:
       case OSSIM_USHORT15:
       {
          bitsPerPixel = 16;
          break;
       }
       case OSSIM_UINT16:
       case OSSIM_SINT16:
       {
          bitsPerPixel = 16;
          break;
       }
       case OSSIM_UINT32:
       case OSSIM_SINT32:
       case OSSIM_FLOAT32:
       case OSSIM_NORMALIZED_FLOAT:
       {
          bitsPerPixel = 32;
          break;
       }
       case OSSIM_FLOAT64:
       case OSSIM_NORMALIZED_DOUBLE:
       {
          bitsPerPixel = 64;
          break;
       }
       default:
       {
          if (traceDebug())
          {
             ossimNotify(ossimNotifyLevel_DEBUG)
                << __FILE__ << ":" << __LINE__
                << "\nUnhandled scalar type:  " << scalarType << std::endl;
          }
          break;
       }
    }
    return bitsPerPixel;
 }

◆ getCodecFormat()

ossim_int32 ossim::getCodecFormat ( std::istream * str )

Gets codec format from magic number.

Returns: OPJ_CODEC_J2K = 0, OPJ_CODEC_JP2 = 2, OPJ_CODEC_UNKNOWN = -1

Definition at line 479 of file ossimOpjCommon.cpp.

 {
    ossim_int32 result = OPJ_CODEC_UNKNOWN; // -1
 
    if ( str )
    {
       if ( str->good() )
       {
          const ossim_uint8 JP2_RFC3745_MAGIC[12] = 
             { 0x00,0x00,0x00,0x0c,0x6a,0x50,0x20,0x20,0x0d,0x0a,0x87,0x0a };
          const ossim_uint8 JP2_MAGIC[4] = { 0x0d,0x0a,0x87,0x0a };
          const ossim_uint8 J2K_CODESTREAM_MAGIC[4] = { 0xff,0x4f,0xff,0x51 };
          
          ossim_uint8 buf[12];
          
          // Read in the box.
          str->read((char*)buf, 12);
          
          if ( ( std::memcmp(buf, JP2_RFC3745_MAGIC, 12) == 0 ) ||
               ( std::memcmp(buf, JP2_MAGIC, 4) == 0 ) )
          {
             result = OPJ_CODEC_JP2;
          }
          else if ( std::memcmp(buf, J2K_CODESTREAM_MAGIC, 4) == 0 )
          {
             result = OPJ_CODEC_J2K;
          }
       }
    }
    
    return result;
 }

◆ getCodestreamDimensions()

bool ossim::getCodestreamDimensions	(	kdu_core::kdu_codestream &	codestream,
		std::vector< ossimIrect > &	imageDims,
		std::vector< ossimIrect > &	tileDims
	)

Gets image and tile dimensions from codestream for each resolution level (rlevel).

Note that on entry the arrays are cleared so they will be empty on failure.

Parameters

codestream	The codestream to read from.
imageDims	Array to initialize with image size of each rlevel. This will have any sub image offset applied to it.
tileDims	Array to initialize with tile size of each rlevel. This is zero base tile size. No sub image offset if there is one.

Returns: true on success, false on error.

Note: On entry the arrays are cleared so they will can be empty on failure.

Definition at line 75 of file ossimKakaduCommon.cpp.

References getRect().

 {
    bool result = true;
    
    imageDims.clear();
    tileDims.clear();
 
    if ( codestream.exists() )
    {
       kdu_core::kdu_coords tileIdx(0, 0);
       
       ossim_uint32 levels = codestream.get_min_dwt_levels();
 
       for (ossim_uint32 level=0; level <= levels; ++level)
       {
          // Get the image dimensions.
 
          codestream.apply_input_restrictions(
             0,     // first_component
             0,     // max_components (0 = all remaining will appear)
             level, // highest resolution level
             0,     // max_layers (0 = all layers retained)
             NULL,  // expanded out to block boundary.
             kdu_core::KDU_WANT_OUTPUT_COMPONENTS);
          
          kdu_core::kdu_dims dims;
          codestream.get_dims(0, dims);
          
          // Make the imageRect upper left relative to any sub image offset.
          ossimIrect imageRect;
          getRect(dims, imageRect);
          
          imageDims.push_back(imageRect);
 
          // Get the tile dimensions.
          
          kdu_core::kdu_dims mappedRegion;
          codestream.map_region(0, dims, mappedRegion, true);
          
          kdu_core::kdu_tile tile = codestream.open_tile(tileIdx);
          if ( tile.exists() )
          {
             codestream.get_tile_dims( tile.get_tile_idx(), 0, dims );
             
             // Make the tile rect zero based.
             ossimIrect tileRect(0,
                                 0,
                                 dims.size.x-1,
                                 dims.size.y-1);
             
             tileDims.push_back(tileRect);
 
             // Every open has a close.
             tile.close();
          }
          else
          {
             result = false;
          }
          
       } // matches: for (ossim_uint32 level=0; level <= levels; ++level)
 
       // Set things back to level 0.
       codestream.apply_input_restrictions(
          0,     // first_component
          0,     // max_components (0 = all remaining will appear)
          0, // highest resolution level
          0,     // max_layers (0 = all layers retained)
          NULL,  // expanded out to block boundary.
          kdu_core::KDU_WANT_OUTPUT_COMPONENTS);
 
       // Should be the same sizes as levels.
       if ( (imageDims.size() != tileDims.size()) ||
            (tileDims.size() != levels+1) )
       {
          result = false;
       }
    } 
    else // codestream.exists() == false
    {
       result = false;
    }
 
    return result;
 }

◆ getDims()

void ossim::getDims	(	const ossimIrect &	rect,
		kdu_core::kdu_dims &	dims
	)

Convenience method to convert ossimIrect to kdu_dims.

Parameters

rect	The ossimIrect to convert.
dims	This kdu_dim to initialize.

Definition at line 33 of file ossimKakaduCommon.cpp.

References ossimIrect::height(), ossimIrect::ul(), ossimIrect::width(), ossimIpt::x, and ossimIpt::y.

Referenced by copyRegionToTile().

 {
    dims.pos.x = rect.ul().x;
    dims.pos.y = rect.ul().y;
    dims.size.x = static_cast<int>(rect.width());
    dims.size.y = static_cast<int>(rect.height());
 }

◆ getFormattedTime()

void ossim::getFormattedTime	(	const std::string &	format,
		bool	gmtFlag,
		std::string &	result
	)

Gets the current time.

Example formats and output: format = "%Y-%m-%dT%H:%M:%SZ" output = "2014-03-06T13:55:10Z"

Parameters

format	E.g. "%Y-%m-%dT%H:%M:%SZ"
gmtFlag	If true get the zulu time; else, gets the local time.
result	Initialized by this with result.

E.g. "2014-03-06T13:55:10Z"

Note: If an error occurs result will be empty.

Definition at line 1204 of file ossimCommon.cpp.

Referenced by ossimFilename::appendTimestamp(), ossimImageUtil::gsubDate(), ossimAutRegUtil::saveAdjustment(), ossimTieMeasurementGenerator::summarizeRun(), and ossimAdjustmentExecutive::summarizeSolution().

 {
    std::lock_guard<std::mutex>   lock(timeMutex);
    time_t rawTime;
    time(&rawTime);
    
    struct tm* timeInfo;
    if ( gmtFlag )
    {
       timeInfo = gmtime(&rawTime);
    }
    else
    {
       timeInfo = localtime(&rawTime);
    }
    
    size_t size = 0;
    if ( timeInfo )
    {
       const size_t STRING_SIZE = 196; // This is a big time string size.
       char outStr[STRING_SIZE];
 
       size = strftime(outStr, STRING_SIZE, format.c_str(), timeInfo );
 
       if ( size )
       {
          // Per strftime spec not needed but null terminating anyway.
          outStr[STRING_SIZE-1] = '\0';
          result = outStr;
       }
    }
    if ( !size )
    {
       result.clear();
    }
 
 }

◆ getNumberOfThreads()

ossim_uint32 ossim::getNumberOfThreads ( )

Get the number threads to use from ossimPreferences or ossim::Thread.

Keyword searched for is: "ossim_threads"

If keyword is not found ossim::Thread::getNumberOfProcessors() is used.

Returns: Number of threads. Default=1

Definition at line 1185 of file ossimCommon.cpp.

References ossimPreferences::findPreference(), ossim::Thread::getNumberOfProcessors(), ossimPreferences::instance(), and ossimString::toUInt32().

Referenced by ossimHlzTool::computeHLZ(), ossimViewshedTool::computeViewshed(), and ossimMultiThreadSequencer::setToStartOfSequence().

 {
    ossim_uint32 result;
    const char* str = ossimPreferences::instance()->findPreference("ossim_threads");
    if ( str )
    {
       result = ossimString(str).toUInt32();
    }
    else
    {
       result = static_cast<ossim_uint32>( ossim::Thread::getNumberOfProcessors() );
    }
    if ( !result )
    {
       result = 1;
    }
    return result;
 }

◆ getProgressionOrderString()

std::string ossim::getProgressionOrderString ( ossim_int32 prog_order )

Definition at line 886 of file ossimOpjCommon.cpp.

Referenced by print().

 {
    std::string result = "";
    switch (prog_order)
    {
       case OPJ_LRCP:
       {
          result = "LRCP";
          break;
       }
       case OPJ_RLCP:
       {
          result = "RLCP";
          break;
       }
       case OPJ_RPCL:
       {
          result = "RPCL";
          break;
       }
       case OPJ_PCRL:
       {
          result = "PCRL";
          break;
       }
       case OPJ_CPRL:
       {
          result = "CPRL";
          break;
       }
       default:
       {
          result = "UNKOWN";
          break;
       }
    }
    
    return result;
 }

◆ getRect()

void ossim::getRect	(	const kdu_core::kdu_dims &	dims,
		ossimIrect &	rect
	)

Convenience method to convert kdu_core::kdu_dims to ossimIrect.

Parameters

dims	This kdu_dim to convert.
rect	The ossimIrect to initialize.

Definition at line 41 of file ossimKakaduCommon.cpp.

Referenced by getCodestreamDimensions().

 {
    rect = ossimIrect(dims.pos.x,
                      dims.pos.y,
                      dims.pos.x + dims.size.x - 1,
                      dims.pos.y + dims.size.y - 1);
 }

◆ getTime()

ossim_int64 ossim::getTime ( )

Gets the current time.

Wrapper around time.h time_t time(time_t *t) with a mutex lock.

Note that time_t is a long int. Returning ossim_int64 to avoid include of time.h.

Returns: The time as the number of seconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).

Definition at line 1243 of file ossimCommon.cpp.

Referenced by ossimFilename::lastAccessed(), and ossimImageHandlerMtAdaptor::writeTime().

 {
    std::lock_guard<std::mutex>   lock(timeMutex);
    time_t rawTime;
    
    time(&rawTime);
    
    return (ossim_int64)rawTime;
 }

◆ inInterval()

template<class T >

bool ossim::inInterval	(	T	x,
		T	a,
		T	b
	)

inline

Definition at line 58 of file ossimCommon.h.

References x.

60 { return x >= a && x <= b; }

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519

◆ inOpenInterval()

template<class T >

bool ossim::inOpenInterval	(	T	x,
		T	a,
		T	b
	)

inline

Definition at line 63 of file ossimCommon.h.

References x.

65 { return x > a && x < b; }

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519

◆ inverseLerp()

template<class T >

T ossim::inverseLerp	(	T	x,
		T	begin,
		T	end
	)

inline

Definition at line 152 of file ossimCommon.h.

References isnan(), and x.

155 { return begin == end ? (ossim::isnan(x) ? x : T(0)) : (x - begin)/(end - begin); }

Referenced by ossimKakaduNitfReader::allocateBuffers(), ossimGpt::changeDatum(), clamp(), ossimPositionQualityEvaluator::computeElevAzim(), ossimImageGeometry::computeGroundToImagePartials(), ATP::AtpGenerator::constructChain(), RadialProcessor::doRadial(), ossimGeoidNgs::ellipsoidToGeoidHeight(), ossimGeoidEgm96::ellipsoidToGeoidHeight(), ossimNitfTileSource::establishDecimationFactors(), ossimPositionQualityEvaluator::extractErrorEllipse(), ossimQuadProjection::extrapolate(), ossimPixelFlipper::flipPixels(), ossimGeoidNgs::geoidToEllipsoidHeight(), ossimGeoidEgm96::geoidToEllipsoidHeight(), ossimRpcModel::getForwardDeriv(), ossimTieGptSet::getGroundBoundaries(), ossimElevManager::getHeightAboveEllipsoid(), ossimImageElevationDatabase::getHeightAboveEllipsoid(), ossimElevManager::getHeightAboveMSL(), ossimPdfWriter::getLgiDictCtm(), ossimShiftFilter::getMaxPixelValue(), ossimImageCacheTileSource::getMaxPixelValue(), ossimKakaduNitfReader::getMaxPixelValue(), ossimNitfUse00aTag::getMeanGsdInMeters(), ossimNitfPiaimcTag::getMeanGsdInMeters(), ossimElevManager::getMeanSpacingMeters(), ossimShiftFilter::getMinPixelValue(), ossimImageCacheTileSource::getMinPixelValue(), ossimKakaduNitfReader::getMinPixelValue(), ossimGpkgTileEntry::getNewMapProjection(), ossimShiftFilter::getNullPixelValue(), ossimImageCacheTileSource::getNullPixelValue(), ossimKakaduNitfReader::getNullPixelValue(), ossimElevationDatabase::getOffsetFromEllipsoid(), ossimIntensityAdjustmentFilter::getTile(), ossimBrightnessMatch::getTile(), ossimShiftFilter::getTile(), ossimH5GridModel::getWktFootprint(), ossimTDpt::hasNans(), ossimFpt::hasNans(), ossimDpt3d::hasNans(), ossimDpt::hasNans(), ossimEcefPoint::hasNans(), ossimTieGpt::hasNans(), ossimEcefVector::hasNans(), ossimLsrPoint::hasNans(), ossimLsrVector::hasNans(), ossimPointObservation::hasNans(), ossimGpt::hasNans(), ossimElevationAccuracyInfo::hasValidAbsoluteError(), ossimElevationAccuracyInfo::hasValidRelativeError(), ossimHistogramEqualization::initializeLuts(), ATP::AtpTileSource::initializeStaticMembers(), ossimSonomaSensor::intersectRay(), inverseLerp(), ossimGpt::isEqualTo(), ossimGpt::isHgtNan(), ossimGpt::isLatLonNan(), ossimGpt::isLatNan(), ossimGrect::isLonLatNan(), ossimGpt::isLonLatNan(), ossimGpt::isLonNan(), ossimTDpt::isNan(), ossimDpt::isNan(), ossimEcefPoint::isNan(), ossimTieGpt::isNan(), ossimEcefVector::isNan(), ossimPointObservation::isNan(), ossimGpt::isNan(), ossimHlzTool::LsFitPatchProcessorJob::level1Test(), ossimHlzTool::NormPatchProcessorJob::level1Test(), ossimPpjFrameSensor::lineSampleHeightToWorld(), ossimPolynomProjection::lineSampleHeightToWorld(), ossimRsmModel::lineSampleHeightToWorld(), ossimBilinearProjection::lineSampleHeightToWorld(), ossimSonomaSensor::lineSampleHeightToWorld(), ossimSarModel::lineSampleHeightToWorld(), ossimRpcModel::lineSampleHeightToWorld(), ossimSrtmFilename::ll(), ossimIpodSensor::loadState(), ossimSkyBoxLearSensor::loadState(), ossimSonomaSensor::loadState(), ossimSrtmFilename::lr(), max< ossim_float32 >(), max< ossim_float64 >(), min< ossim_float32 >(), min< ossim_float64 >(), ossimDatum::molodenskyShift(), ossimGeoidManager::offsetFromEllipsoid(), ossimPolynomProjection::optimizeFit(), ossimInfo::outputHeight(), ossimNitfFile::print(), ossimTDpt::print(), ossimObservationSet::print(), ossimTieGpt::print(), ossimDpt::print(), ossimPointObservation::print(), ossimMapProjection::print(), ossimResampler::resamplePartialTile(), round(), ossimPointCloudImageHandler::setGSD(), ossimHistogramRemapper::setHighClipPoint(), ossimHistogramRemapper::setLowClipPoint(), ossimRangeDomeTileSource::setProperty(), ossimPointCloudImageHandler::setProperty(), ossimHistogramRemapper::setupTable(), sgn(), sgn< ossim_float32 >(), ossimNadconNarDatum::shift(), ossimRpcSolver::solveCoefficients(), ossimDpt::toString(), ossimDpt3d::toString(), ossimColumnVector3d::toString(), ossimString::toString(), ossimSrtmFilename::ul(), ossimImageGeometry::upIsUpAngle(), ossimSrtmFilename::ur(), ossimTiffTileSource::validateMinMaxNull(), ossimRsmModel::worldToLineSample(), ossimPolynomProjection::worldToLineSample(), ossimH5GridModel::worldToLineSample(), ossimSensorModel::worldToLineSample(), and wrap().

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519

ossim::isnan

bool isnan(const float &v)

isnan Test for floating point Not A Number (NAN) value.

Definition: ossimCommon.h:91

◆ isnan() [1/2]

bool ossim::isnan ( const float & v )

inline

isnan Test for floating point Not A Number (NAN) value.

This should be used test for nan. DO NOT USE operator==. Like "if (height == ossim::nan())"

Returns: true if nan, false if not.

See also: nan()

Definition at line 91 of file ossimCommon.h.

References isnan().

91 { return ( std::isnan(v) ); }

ossim::isnan

bool isnan(const double &v)

Definition: ossimCommon.h:92

◆ isnan() [2/2]

bool ossim::isnan ( const double & v )

inline

Definition at line 92 of file ossimCommon.h.

Referenced by isnan().

92 { return ( std::isnan(v) ); }

ossim::isnan

bool isnan(const double &v)

Definition: ossimCommon.h:92

◆ isSigned()

bool ossim::isSigned ( ossimScalarType scalarType )

Returns: true if scalar type is signed, false if not.

Definition at line 370 of file ossimCommon.cpp.

References OSSIM_FLOAT32, OSSIM_FLOAT64, OSSIM_SINT16, OSSIM_SINT32, and OSSIM_SINT8.

Referenced by ossimOpjCompressor::createOpjImage(), ossimJ2kSizRecord::getScalarType(), ossimHdf5::getScalarType(), ossim_hdf5::getScalarType(), ossim_hdf5::printAttribute(), ossim_hdf5::printIntType(), ossim_hdf5::printObject(), and ossimKakaduCompressor::writeTile().

 {
    bool result = false;
    switch(scalarType)
    {
       case OSSIM_SINT8:
       case OSSIM_SINT16:
       case OSSIM_SINT32:
       case OSSIM_FLOAT32:
       case OSSIM_FLOAT64:
       {
          result = true;
          break;
       }
       default:
       {
          break;
       }
   }
   return result;
 }

◆ isWhiteSpace()

bool ossim::isWhiteSpace ( int c )

Definition at line 49 of file ossimCommon.cpp.

Referenced by skipws().

 {
    return ( (c == ' ') || (c == '\t') || (c == '\n')|| (c == '\r') ) ;
 }

◆ lcm()

template<class IntType >

IntType ossim::lcm	(	IntType	n,
		IntType	m
	)

Definition at line 315 of file ossimCommon.h.

References gcd(), and n.

         {
             IntType zero(0);    // Avoid repeated construction
             
             if (n == zero || m == zero) {
                 return zero;
             } else {
                 n /= gcd(n, m);
                 n *= m;
                 if (n < zero)
                     n = -n;
                 return n;
             }
         }

◆ lerp()

template<class S , class T >

T ossim::lerp	(	S	x,
		T	begin,
		T	end
	)

inline

Definition at line 147 of file ossimCommon.h.

References x.

149 { return x*(end - begin) + begin; }

Referenced by ossimMeanMedianFilter::applyMean(), ossimMeanMedianFilter::applyMeanNullCenterOnly(), ossimMeanMedianFilter::applyMedian(), ossimMeanMedianFilter::applyMedianNullCenterOnly(), ossimGdalWriter::buildGdalOverviews(), ossimDrect::clipToRect(), ossimImageHistogramSource::computeFastModeHistogram(), ossimImageHistogramSource::computeNormalModeHistogram(), convertHtmlSpecialCharactersToNormalCharacter(), ossimNBandToIndexFilter::convertInputTileToOutputTemplate(), ossimDilationFilter::doDilation(), ossimErosionFilter::doErosion(), ossimTopographicCorrectionFilter::executeTopographicCorrectionMinnaertTemplate(), ossimCacheTileSource::getCacheId(), ossimApplicationUsage::getFormatedString(), ossimChipperUtil::getIrect(), ossimImageMetaData::getMaxPix(), ossimImageMetaData::getMinPix(), ossimImageMetaData::getNullPix(), ossimClosestToCenterCombiner::getTile(), ossimImageRenderer::initializeBoundingRects(), ossimGrect::intersects(), ossimIrect::intersects(), ossimDrect::intersects(), ossimVpfExtent::operator+(), ossimIrect::ossimIrect(), ossimMatrixProperty::resize(), ossimTopographicCorrectionFilter::resizeArrays(), ossimScaleFilter::runHorizontalFilterTemplate(), ossimScaleFilter::runVerticalFilterTemplate(), ossimImageData::setNumberOfBands(), ossimThinPlateSpline::solve(), and ossimKakaduCompressor::writeTile().

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519

◆ lexQuotedTokens()

void ossim::lexQuotedTokens	(	const std::string &	str,
		ossim_uint32	start,
		const char *	whitespace,
		const char *	quotes,
		std::vector< std::string > &	tokens,
		bool &	unbalancedQuotes
	)

Definition at line 708 of file ossimCommon.cpp.

References ossimREQUIRE.

 {
    ossimREQUIRE(whitespace != NULL);
    ossimREQUIRE(quotes != NULL);
    ossimREQUIRE(tokens != NULL);
    
    const char openQuote(quotes[0]), closeQuote(quotes[1]);
    
    tokens.clear();
    unbalancedQuotes = false;
    
    int end=0;
    while (start < str.length())
    {
       if (str[start] == openQuote)
       {
          int openBraceCount = 1;
          
          if (start+1 < str.length())
          {
             start++;
             if (str[start] != closeQuote)
             {
                //               end = start+1;
                end = start;
                while (static_cast<ossim_uint32>(end) < str.length() &&
                       openBraceCount > 0)
                {
                   if (str[end] == openQuote)
                      openBraceCount++;
                   else if (str[end] == closeQuote)
                      openBraceCount--;
                   end++;
                }
             }
             else
             {
                openBraceCount = 0;
                start++;
                end = start+1;
             }
          }
          if (openBraceCount == 0)
          {
             tokens.push_back(str.substr(start, end-1-start));
          }
          else
          {
             unbalancedQuotes = true;
             end = (int)str.length();
          }
       }
       else if (str[start] == closeQuote)
       {
          unbalancedQuotes = true;
          end = (int)str.length();
      
       }
       else
       {
          end = (int)str.find_first_of(whitespace, start);
          tokens.push_back(str.substr(start, end-start));
       }
       
       start = (ossim_uint32)str.find_first_not_of(whitespace, end);
    }
 }

◆ matrixToHpr() [1/2]

bool ossim::matrixToHpr	(	ossim_float64	hpr[3],
		const NEWMAT::Matrix &	rotation
	)

Heading pitch roll extraction from a matrix.

Definition at line 613 of file ossimCommon.cpp.

References asind(), atan2d(), clamp(), cosd(), and ossimDpt3d::length().

Referenced by matrixToHpr().

 {
     //implementation converted from plib's sg.cxx
     //PLIB - A Suite of Portable Game Libraries
     //Copyright (C) 1998,2002  Steve Baker
     //For further information visit http://plib.sourceforge.net
     
    NEWMAT::Matrix mat(rotation);
     
    ossimDpt3d col1(rotation[0][0], rotation[1][0], rotation[2][0]);
    double s = col1.length();
    
    hpr[0] = 0.0;
    hpr[1] = 0.0;
    hpr[2] = 0.0;
 
    if ( s <= 0.00001 )
    {
       return true;
    }
    
    
    double oneOverS = 1.0f / s;
    for( int i = 0; i < 3; i++ )
       for( int j = 0; j < 3; j++ )
          mat[i][j] = rotation[j][i] * oneOverS;
    
    
    hpr[1] = ossim::asind(ossim::clamp(mat[1][2], -1.0, 1.0));
    
    double cp = ossim::cosd(hpr[1]);
    
    if ( cp > -0.00001 && cp < 0.00001 )
    {
       double cr = ossim::clamp(mat[0][1], -1.0, 1.0);
       double sr = ossim::clamp(-mat[2][1], -1.0, 1.0);
       
       hpr[0] = 0.0f;
       hpr[2] = ossim::atan2d(sr,cr);
    }
    else
    {
       cp = 1.0 / cp;
       double sr = ossim::clamp((-mat[0][2] * cp), -1.0,1.0);
       double cr = ossim::clamp((mat[2][2] * cp), -1.0, 1.0);
       double sh = ossim::clamp((-mat[1][0] * cp), -1.0, 1.0);
       double ch = ossim::clamp((mat[1][1] * cp), -1.0, 1.0);
       
       if ( (sh == 0.0f && ch == 0.0f) || (sr == 0.0f && cr == 0.0f) )
       {
          cr = ossim::clamp(mat[0][1], -1.0, 1.0);
          sr = ossim::clamp(-mat[2][1], -1.0, 1.0);
          
          hpr[0] = 0.0f;
       }
       else
       {
          hpr[0] = ossim::atan2d(sh, ch);
       }
       
       hpr[2] = ossim::atan2d(sr, cr);
    }
    
    hpr[0] *= -1.0;
    return true;
 }

◆ matrixToHpr() [2/2]

bool ossim::matrixToHpr	(	ossim_float64	hpr[3],
		const NEWMAT::Matrix &	lsrMatrix,
		const NEWMAT::Matrix &	rotationalMatrix
	)

Heading pitch roll extraction from a matrix.

Definition at line 680 of file ossimCommon.cpp.

References abs, FLT_EPSILON, and matrixToHpr().

 {
     bool result = false;
     NEWMAT::Matrix invertLsr(lsrMatrix.i());
    
     hpr[0] = 0.0;
     hpr[1] = 0.0;
     hpr[2] = 0.0;
     result = matrixToHpr(hpr, invertLsr*rotationalMatrix);
     if(std::abs(hpr[0]) < FLT_EPSILON)
     {
        hpr[0] = 0.0;
     }
     if(std::abs(hpr[1]) < FLT_EPSILON)
     {
        hpr[1] = 0.0;
     }
     if(std::abs(hpr[2]) < FLT_EPSILON)
     {
        hpr[2] = 0.0;
     }
     
     return result;
 }

◆ max()

template<class T >

T ossim::max	(	T	a,
		T	b
	)

inline

◆ max< ossim_float32 >()

template<>

ossim_float32 ossim::max< ossim_float32 >	(	ossim_float32	a,
		ossim_float32	b
	)

inline

Definition at line 242 of file ossimCommon.h.

References isnan().

     {
        if (ossim::isnan(b))
           return b;
        else
           return (a < b) ? b : a;       
     }

◆ max< ossim_float64 >()

template<>

ossim_float64 ossim::max< ossim_float64 >	(	ossim_float64	a,
		ossim_float64	b
	)

inline

Definition at line 250 of file ossimCommon.h.

References isnan().

Referenced by ossimGrect::clipToRect(), and ossimGpkgWriter::initializeRect().

     {
        if (ossim::isnan(b))
           return b;
        else
           return (a < b) ? b : a;       
     }

◆ memClear() [1/2]

template<class T >

void ossim::memClear	(	T &	var,
		int	z = `0`
	)

inline

Definition at line 390 of file ossimCommon.h.

392 { memset(&var, z, sizeof(T)); }

◆ memClear() [2/2]

template<class T >

void ossim::memClear ( T * var )

inline

Definition at line 395 of file ossimCommon.h.

References ossimSTATIC_CHECK.

397 { ossimSTATIC_CHECK(false, YOU_PROBABLY_WANT_TO_MEMCLEAR_WHAT_THE_POINTER_POINTS_TO_NOT_THE_POINTER_ITSELF); }

ossimSTATIC_CHECK

#define ossimSTATIC_CHECK(expr, msg)

Definition: ossimCommon.h:22

◆ min()

template<class T >

T ossim::min	(	T	a,
		T	b
	)

inline

Definition at line 203 of file ossimCommon.h.

     {
        return (a < b) ? a : b;
     }

◆ min< ossim_float32 >()

template<>

ossim_float32 ossim::min< ossim_float32 >	(	ossim_float32	a,
		ossim_float32	b
	)

inline

Definition at line 210 of file ossimCommon.h.

References isnan(), and nan().

     {
        if (ossim::isnan(a)||ossim::isnan(b))
        {
           return ossim::nan();
        }
        else
        {
           return (a < b) ? a : b;
        }
     }

◆ min< ossim_float64 >()

template<>

ossim_float64 ossim::min< ossim_float64 >	(	ossim_float64	a,
		ossim_float64	b
	)

inline

Definition at line 223 of file ossimCommon.h.

References isnan(), and nan().

Referenced by ossimGrect::clipToRect(), ossimElevationCellDatabase::getCellsForBounds(), and ossimGpkgWriter::initializeRect().

     {
        if (ossim::isnan(a)||ossim::isnan(b))
        {
           return ossim::nan();
        }
        else
        {
           return (a < b) ? a : b;
        }
     }

◆ mtrs2ft()

double ossim::mtrs2ft ( double meters )

inline

Definition at line 374 of file ossimCommon.h.

References MTRS_PER_FT.

374 { return (meters / MTRS_PER_FT); }

MTRS_PER_FT

#define MTRS_PER_FT

Definition: ossimConstants.h:461

◆ mtrs2usft()

double ossim::mtrs2usft ( double meters )

inline

Definition at line 375 of file ossimCommon.h.

References US_METERS_PER_FT.

Referenced by ossimMapProjectionInfo::getUsSurveyFeetPerPixel(), ossimMapProjectionInfo::llEastingNorthingPtInFt(), ossimMapProjectionInfo::lrEastingNorthingPtInFt(), ossimMapProjectionInfo::ulEastingNorthingPtInFt(), and ossimMapProjectionInfo::urEastingNorthingPtInFt().

375 { return (meters / US_METERS_PER_FT); }

US_METERS_PER_FT

#define US_METERS_PER_FT

Definition: ossimConstants.h:486

◆ nan()

double ossim::nan ( )

inline

Method to return ieee floating point double precision NAN.

Returns: ieee floating point double precision NAN.

See also: isnan()

Note: casts seamlessly to float and long double.; Use ossim::isnan(v) to test for nan. Like "if (isnan(myDoubleValue)) { doSomething; }" DO NOT USE operator==. Like "if (myDoubleValue == ossim::nan())"

Definition at line 135 of file ossimCommon.h.

135 { return nanValue.bits.floatname; }

◆ operator<<() [1/2]

ostream& ossim::operator<<	(	std::ostream &	out,
		const JsonParam &	obj
	)

Definition at line 299 of file JsonConfig.cpp.

References ossim::JsonParam::saveJSON().

 {
    Json::Value jsonNode;
    obj.saveJSON(jsonNode);
    out << jsonNode << endl;
    return out;
 }

◆ operator<<() [2/2]

std::ostream& ossim::operator<<	(	std::ostream &	out,
		const JsonConfig &	obj
	)

Definition at line 472 of file JsonConfig.cpp.

References ossim::JsonConfig::saveJSON().

 {
    Json::Value configJsonNode;
    obj.saveJSON(configJsonNode);
    out<<configJsonNode<<endl;
    return out;
 }

◆ opj_decode()

bool ossim::opj_decode	(	std::ifstream *	in,
		const ossimIrect &	rect,
		ossim_uint32	resLevel,
		ossim_int32	format,
		std::streamoff	fileOffset,
		ossimImageData *	tile
	)

you may here add custom decoding parameters

Definition at line 143 of file ossimOpjCommon.cpp.

References status.

 {
    static const char MODULE[] = "ossimOpjDecoder::decode";
 
    bool status = false;
 
    if ( traceDebug() )
    {
       ossimNotify(ossimNotifyLevel_DEBUG)
          << MODULE << "entered...\nrect: " << rect
          << "\nresLevel: " << resLevel << std::endl;
    }
    
    // Need to check for NAN in rect
    if ( in && tile && !rect.hasNans())
    {
       in->seekg( fileOffset, std::ios_base::beg );
 
       opj_dparameters_t param;
       opj_codec_t*      codec = 0;
       opj_image_t*      image = 0;;
       opj_stream_t*     stream = 0;
 
       opj_user_istream* userStream = new opj_user_istream();
       userStream->m_str = in;
       userStream->m_offset = fileOffset;
 
       /* Set the length to avoid an assert */
       in->seekg(0, std::ios_base::end);
 
       // Fix: length must be passed in for nift blocks.
       userStream->m_length = in->tellg();
 
       // Set back to front:
       in->clear();
       in->seekg(fileOffset, std::ios_base::beg);
       
       stream = opj_stream_default_create(OPJ_TRUE);
       if (!stream)
       {
          opj_stream_destroy(stream);
          std::string errMsg = MODULE;
          errMsg += " ERROR: opj_setup_decoder failed!";
          throw ossimException(errMsg);
       }
       
       opj_stream_set_read_function(stream, ossim_opj_istream_read);
       opj_stream_set_skip_function(stream, ossim_opj_istream_skip);
       opj_stream_set_seek_function(stream, ossim_opj_istream_seek);
 
       // Fix: length must be passed in for nift blocks.
       opj_stream_set_user_data_length(stream, userStream->m_length);
       
       opj_stream_set_user_data(stream, userStream,
                                ossim_opj_free_user_istream_data);
 
       opj_stream_set_user_data_length(stream, userStream->m_length);
 
       
       /* Set the default decoding parameters */
       opj_set_default_decoder_parameters(&param);
 
       param.decod_format = format;
 
       /* do not use layer decoding limitations */
       param.cp_layer = 0;
 
       /* do not use resolutions reductions */
       param.cp_reduce = resLevel;
 
       codec = opj_create_decompress( (CODEC_FORMAT)format );
 
       // catch events using our callbacks and give a local context
       //opj_set_info_handler   (codec, ossim::opj_info_callback,   00);
       opj_set_info_handler   (codec, NULL,   00);
       opj_set_warning_handler(codec, ossim::opj_warning_callback,00);
       opj_set_error_handler  (codec, ossim::opj_error_callback,  00);
 
       // Setup the decoder decoding parameters using user parameters
       if ( opj_setup_decoder(codec, &param) == false )
       {
          opj_stream_destroy(stream);
          opj_destroy_codec(codec);
          std::string errMsg = MODULE;
          errMsg += " ERROR: opj_setup_decoder failed!";
          throw ossimException(errMsg);
       }
 
       // Read the main header of the codestream and if necessary the JP2 boxes.
       if ( opj_read_header(stream, codec, &image) == false )
       {
          opj_stream_destroy(stream);
          opj_destroy_codec(codec);
          opj_image_destroy(image);         
          std::string errMsg = MODULE;
          errMsg += " ERROR: opj_read_header failed!";
          throw ossimException(errMsg);
       }
 
       // tmp drb:
       // opj_stream_destroy(stream);
       // return;
       
       if ( opj_set_decoded_resolution_factor(codec, resLevel) == false)
       {
          opj_stream_destroy(stream);
          opj_destroy_codec(codec);
          opj_image_destroy(image);
          std::string errMsg = MODULE;
          errMsg += " ERROR:  opj_set_decoded_resolution_factor failed!";
          throw ossimException(errMsg);
       }
 
       //ossim_float32 res = resLevel;
       ossimIrect resRect = rect * (1 << resLevel);
 
       //std::cout << "resRect.ul(): " << resRect.ul()
       //          << "\nresRect.lr(): " << resRect.lr()
       //          << std::endl;
 
 //      if ( opj_set_decode_area(codec, image, rect.ul().x, rect.ul().y,
 //                               rect.lr().x+1, rect.lr().y+1) == false )
       if ( opj_set_decode_area(codec, image, resRect.ul().x, resRect.ul().y,
                                resRect.lr().x+1, resRect.lr().y+1) == false )
       {
          opj_stream_destroy(stream);
          opj_destroy_codec(codec);
          opj_image_destroy(image);
          std::string errMsg = MODULE;
          errMsg += " ERROR: opj_set_decode_area failed!";
          throw ossimException(errMsg);
       }
 
       // Get the decoded image:
       if ( opj_decode(codec, stream, image) == false )
       {
          opj_stream_destroy(stream);
          opj_destroy_codec(codec);
          opj_image_destroy(image);
          std::string errMsg = MODULE;
          errMsg += " ERROR: opj_decode failed!";
          throw ossimException(errMsg);
       }
       
       // ossim::print(std::cout, *image);
       if(image->icc_profile_buf) {
 #if defined(OPJ_HAVE_LIBLCMS1) || defined(OPJ_HAVE_LIBLCMS2)
           color_apply_icc_profile(image); /* FIXME */
 #endif
           free(image->icc_profile_buf);
           image->icc_profile_buf = NULL; image->icc_profile_len = 0;
       }
 
       status = ossim::copyOpjImage(image, tile);
       
 #if 0
       ossim_uint32 tile_index      = 0;
       ossim_uint32 data_size       = 0;
       ossim_int32  current_tile_x0 = 0;
       ossim_int32  current_tile_y0 = 0;
       ossim_int32  current_tile_x1 = 0;
       ossim_int32  current_tile_y1 = 0;
       ossim_uint32 nb_comps        = 0;
       OPJ_BOOL go_on = 1;
 
       if ( opj_read_tile_header( codec,
                                  stream,
                                  &tile_index,
                                  &data_size,
                                  &current_tile_x0,
                                  &current_tile_y0,
                                  &current_tile_x1,
                                  &current_tile_y1,
                                  &nb_comps,
                                  &go_on) == false )
       {
          opj_stream_destroy(stream);
          opj_destroy_codec(codec);
          opj_image_destroy(image);
          std::string errMsg = MODULE;
          errMsg += " ERROR: opj_read_tile_header failed!";
          throw ossimException(errMsg);
       }
 #endif
 
 #if 0
       std::cout << "tile_index:      " << tile_index
                 << "\ndata_size:       " << data_size
                 << "\ncurrent_tile_x0: " << current_tile_x0
                 << "\ncurrent_tile_y0: " << current_tile_y0
                 << "\ncurrent_tile_x1: " << current_tile_x1
                 << "\ncurrent_tile_y1: " << current_tile_y1
                 << "\nnb_comps:        " << nb_comps
                 << std::endl;
 #endif
 
 #if 0
       if ( opj_decode_tile_data(codec, tile_index,l_data,l_data_size,l_stream) == false)
       {
          opj_stream_destroy(l_stream);
          opj_destroy_codec(l_codec);
          opj_image_destroy(l_image);
          std::string errMsg = MODULE;
          errMsg += " ERROR: opj_read_tile_header failed!";
          throw ossimException(errMsg);
       }
 #endif
 
 #if 0
       
       if (opj_end_decompress(codec,stream) == false )
       {
          opj_stream_destroy(stream);
          opj_destroy_codec(codec);
          opj_image_destroy(image);
          std::string errMsg = MODULE;
          errMsg += " ERROR: opj_end_decompress failed!";
          throw ossimException(errMsg);
       } 
 
 #endif
       
       /* Free memory */
       opj_stream_destroy(stream);
       opj_destroy_codec(codec);
       opj_image_destroy(image);
 
       // Tmp drb:
       if ( in->eof() )
       {
          in->clear();
       }
       in->seekg(fileOffset, std::ios_base::beg );
       
    } // Matches: if ( in && tile )
 
    return status;
    
 } // End: ossim::opj_decode( ... )

◆ opj_error_callback()

void ossim::opj_error_callback	(	const char *	msg,
		void *
	)

Callback method for errors.

Definition at line 46 of file ossimOpjCommon.cpp.

References ossimNotify(), and ossimNotifyLevel_WARN.

Referenced by ossimOpjCompressor::createOpjCodec().

 {
    ossimNotify(ossimNotifyLevel_WARN) << msg << std::endl;
 }

◆ opj_info_callback()

void ossim::opj_info_callback	(	const char *	msg,
		void *
	)

Callback method for info.

Definition at line 58 of file ossimOpjCommon.cpp.

Referenced by ossimOpjCompressor::createOpjCodec().

 {
     //ossimNotify(ossimNotifyLevel_NOTICE) << msg << std::endl;
 }

◆ opj_warning_callback()

void ossim::opj_warning_callback	(	const char *	msg,
		void *
	)

Callback method for warnings.

Definition at line 52 of file ossimOpjCommon.cpp.

References ossimNotify(), and ossimNotifyLevel_WARN.

Referenced by ossimOpjCompressor::createOpjCodec().

 {
    ossimNotify(ossimNotifyLevel_WARN) << msg << std::endl;
 }

◆ OSSIM_DLL_DATA()

ossim::OSSIM_DLL_DATA ( const IntFloatBitCoercion )

Declaration of nan part of nan() declared here for inline ossim::nan().

◆ print() [1/8]

std::ostream & ossim::print	(	std::ostream &	out,
		const opj_codestream_info &	info
	)

Prints codestream info from openjpeg struct opj_codestream_info.

Returns: std::ostream&

Definition at line 512 of file ossimOpjCommon.cpp.

References ossimString::string(), and ossimString::toString().

 {
    // Capture stream flags since we are going to mess with them.
    std::ios_base::fmtflags f = out.flags();
    
    const int W = 20;
    
    out << std::setiosflags(std::ios_base::right) << std::setfill(' ')
        << "opj_codestream_info:\n\n"
        << std::setw(W) << "D_max: "
        << info.D_max << "\n"
        << std::setw(W) << "packno: "
        << info.packno << "\n"
        << std::setw(W) << "index_write: "
        <<info.index_write << "\n"
        << std::setw(W) << "image_w: "
        << info.image_w << "\n"
        << std::setw(W) << "image_h: "
        << info.image_h << "\n"
        << std::setw(W) << "proj: "
        << info.prog << "\n"
        << std::setw(W) << "tile_x: "
        << info.tile_x << "\n"
        << std::setw(W) << "tile_y: "
        << info.tile_y << "\n"
        << std::setw(W) << "tile_Ox: "
        << info.tile_Ox << "\n"
        << std::setw(W) << "tile_Oy: "
        << info.tile_Oy << "\n"
        << std::setw(W) << "tw: "
        << info.tw << "\n"
        << std::setw(W) << "th: "
        << info.th << "\n"
        << std::setw(W) << "numcomps: "
        << info.numcomps << "\n"
        << std::setw(W) << "numlayers: "
        << info.numlayers << "\n";
 
    for (int i = 0; i < info.numcomps; ++i)
    {
       std::string s = "numdecompos[";
       s += ossimString::toString(i).string();
       s += "]: ";
       out << std::setw(W) << s << info.numdecompos[i] << "\n";
    }
 
    out << std::setw(W) << "marknum: "
        << info.marknum << "\n"
       // << std::setw(W) << "marker: " << info.marker << "\n"
        << std::setw(W) << "maxmarknum: "
        << info.maxmarknum << "\n"
        << std::setw(W) << "main_head_start: "
        << info.main_head_start << "\n"
        << std::setw(W) << "main_head_end: "
        << info.main_head_end << "\n"
        << std::setw(W) << "codestream_size: "
        << info.codestream_size << "\n"
       // << "tile: " << info.tile
        << std::endl;
 
    // Set the flags back.
    out.flags(f);
 
    return out;
 }

◆ print() [2/8]

std::ostream & ossim::print	(	std::ostream &	out,
		const opj_cparameters &	param
	)

Prints compression parameters from openjpeg struct opj_cparameters.

Returns: std::ostream&

Definition at line 578 of file ossimOpjCommon.cpp.

References getProgressionOrderString().

 {
    // Capture stream flags since we are going to mess with them.
    std::ios_base::fmtflags f = out.flags();
 
    const int W = 24;
    int i;
 
    out << std::setiosflags(std::ios_base::left) << std::setfill(' ')
        << "opj_cparameters:\n\n"
       
        << std::setw(W) << "tile_size_on:"
        << param.tile_size_on << "\n"
 
        << std::setw(W) << "cp_tx0: "
        << param.cp_tx0 << "\n"
 
        << std::setw(W) << "cp_ty0: "
        << param.cp_ty0 << "\n"
 
        << std::setw(W) << "cp_tdx: "
        << param.cp_tdx << "\n"
 
        << std::setw(W) << "cp_tdy: "
        << param.cp_tdy << "\n"
 
        << std::setw(W) << "cp_disto_alloc: "
        << param.cp_disto_alloc << "\n"
 
        << std::setw(W) << "cp_fixed_alloc: "
        << param.cp_fixed_alloc << "\n"
 
        << std::setw(W) << "cp_fixed_quality: "
        << param.cp_fixed_quality << "\n"
 
        << "cp_matrice:\n"
 
        << "cp_comment:\n"
 
        << std::setw(W) << "csty:"
        << param.csty << "\n"
       
        << std::setw(W) << "prog_order: "
        << getProgressionOrderString( (ossim_int32)param.prog_order ) << "\n"
 
        << "POC:\n"
       
        << std::setw(W) << "numpocs:"
        << param.numpocs << "\n"
       
        << std::setw(W) << "tcp_numlayers:"
        << param.tcp_numlayers << "\n";
 
    for ( i = 0; i < param.tcp_numlayers; ++i )
    {
       out << "tcp_rate[" << i << std::setw(14)<< "]: "<< std::setw(4) << param.tcp_rates[i] << "\n"
           << "tcp_distoratio[" << i << std::setw(8) << "]: " << std::setw(4) << param.tcp_distoratio[i] << "\n";
    }
 
    out << std::setw(W) << "numresolution:"
        << param.numresolution << "\n"
 
        << std::setw(W) << "cblockw_init:"
        << param.cblockw_init << "\n"
       
        << std::setw(W) << "cblockh_init:"
        << param.cblockh_init << "\n"
       
        << std::setw(W) << "mode:"
        << param.mode << "\n"
       
        << std::setw(W) << "irreversible:"
        << param.irreversible << "\n"
       
        << std::setw(W) << "roi_compn:"
        << param.roi_compno << "\n"
       
        << std::setw(W) << "roi_shift:"
        << param.roi_shift << "\n"
       
        << std::setw(W) << "res_spec:"
        << param.res_spec << "\n"
       
        << "prcw_init:\n"
       // << param.prcw_init << "\n"
       
        << "prch_init:\n"
       // << param.prcw_init << "\n"
 
       // << std::setw(W) << "infile:"
       //  << param.infile << "\n"
 
        << std::setw(W) << "outfile:"
        << param.outfile << "\n"
 
       // << std::setw(W) << "index_on:"
       //  << param.index_on << "\n"
 
       // << std::setw(W) << "index:"
       //  << param.index << "\n"
 
        << std::setw(W) << "image_offset_x0:"
        << param.image_offset_x0 << "\n"
 
        << std::setw(W) << "image_offset_y0:"
        << param.image_offset_y0 << "\n"
       
        << std::setw(W) << "subsampling_dx:"
        << param.subsampling_dx << "\n"
 
        << std::setw(W) << "image_offset_dy:"
        << param.subsampling_dy << "\n"
       
        << std::setw(W) << "decod_format:"
        << param.decod_format << "\n"
       
        << std::setw(W) << "cod_format:"
        << param.cod_format << "\n"
       
        << std::setw(W) << "jpwl_epc_on:"
        << param.jpwl_epc_on << "\n"
       
        << std::setw(W) << "jpwl_hprot_MH:"
        << param.jpwl_hprot_MH << "\n"
       
        << "jpwl_hprot_TPH_tileno:\n"
 
        << "jpwl_pprot_TPH:\n"
 
        << "jpwl_pprot_tileno:\n"
       
        << "jpwl_pprot_packno:\n"
 
        << "jpwl_pprot:\n"
       
        << std::setw(W) << "jpwl_sens_size:"
        << param.jpwl_sens_size << "\n"
 
        << std::setw(W) << "jpwl_sens_addr:"
        << param.jpwl_sens_addr << "\n"
      
        << std::setw(W) << "jpwl_sens_range:"
        << param.jpwl_sens_range << "\n"
      
        << std::setw(W) << "jpwl_sens_MH:"
        << param.jpwl_sens_MH << "\n"
      
        << "jpwl_sens_TPH_tileno:\n"
 
        << "jpwl_sens_TPH:\n"
 
        << "cp_cinema:\n"
 
        << std::setw(W) << "max_comp_size:"
        << param.max_comp_size << "\n"
 
        << std::setw(W) << "cp_rsiz:"
        << param.cp_rsiz << "\n"
 
        << std::setw(W) << "tp_on:"
        << param.tp_on << "\n"
 
        << std::setw(W) << "tp_flag:"
        << param.tp_flag << "\n"
 
        << std::setw(W) << "tcp_mct:"
        << int(param.tcp_mct) << "\n"
 
        << std::setw(W) << "jpip_on:"
        << param.jpip_on << "\n"
 
        << "mct_data:\n"
 
        << std::setw(W) << "max_cs_size:"
        << param.max_cs_size << "\n"
 
        << std::setw(W) << "rsiz:"
        << param.rsiz << "\n"
 
        << std::endl;
 
    // Set the flags back.
    out.flags(f);
 
    return out;
 }

◆ print() [3/8]

std::ostream & ossim::print	(	std::ostream &	out,
		const opj_dparameters &	param
	)

Prints decode parameters from openjpeg struct opj_dparameters.

Returns: std::ostream&

Definition at line 765 of file ossimOpjCommon.cpp.

 {
    // Capture stream flags since we are going to mess with them.
    std::ios_base::fmtflags f = out.flags();
 
    const int W = 20;
 
    out << std::setiosflags(std::ios_base::right) << std::setfill(' ')
        << "opj_dparameters:\n\n"
        << std::setw(W) << "cp_reduce: "
        << param.cp_reduce << "\n"
        << std::setw(W) << "cp_layer: "
        << param.cp_layer << "\n"
        << std::setw(W) << "infile: "
        << param.infile << "\n"
        << std::setw(W) << "outfile: "
        << param.outfile << "\n"
        << std::setw(W) << "decod_format: "
        << param.decod_format << "\n"
        << std::setw(W) << "cod_format: "
        << param.cod_format << "\n"
        << std::setw(W) << "jpwl_correct: "
        << param.jpwl_correct << "\n"
        << std::setw(W) << "jpwl_exp_comps: "
        << param.jpwl_exp_comps << "\n"
        << std::setw(W) << "jpwl_max_tiles: "
        << param.jpwl_max_tiles << "\n"
        << std::setw(W) << "cp_limit_decoding: "
       // << param.cp_limit_decoding fix (drb)
        << std::endl;
    // Set the flags back.
    out.flags(f);
 
    return out;
 }

◆ print() [4/8]

std::ostream & ossim::print	(	std::ostream &	out,
		const opj_image &	image
	)

Prints opj_image structure.

Returns: std::ostream&

Definition at line 801 of file ossimOpjCommon.cpp.

References ossim_hdf5::print(), ossimString::string(), and ossimString::toString().

 {
    // Capture stream flags since we are going to mess with them.
    std::ios_base::fmtflags f = out.flags();
 
    const int W = 20;
 
    out << std::setiosflags(std::ios_base::right) << std::setfill(' ')
        << "opj_image:\n\n"
        << std::setw(W) << "x0: "
        << image.x0 << "\n"
        << std::setw(W) << "y0: "
        << image.y0 << "\n"
        << std::setw(W) << "x1: "
        << image.x1 << "\n"
        << std::setw(W) << "y1: "
        << image.y1 << "\n"
        << std::setw(W) << "numcomps: "
        << image.numcomps << "\n"
        << std::setw(W) << "color_space: ";
    if ( image.color_space == OPJ_CLRSPC_UNKNOWN ) out << "UNKNOWN\n";
    else if (  image.color_space == OPJ_CLRSPC_UNSPECIFIED) out << "UNSPECIFIED\n";
    else if (  image.color_space == OPJ_CLRSPC_SRGB) out << "SRGB\n";
    else if (  image.color_space == OPJ_CLRSPC_GRAY) out << "GRAY\n";
    else if (  image.color_space == OPJ_CLRSPC_SYCC) out << "SYCC\n";
    else if (  image.color_space == OPJ_CLRSPC_EYCC) out << "EYCC\n";
    else if (  image.color_space == OPJ_CLRSPC_CMYK) out << "CMYK\n";
 
    for (ossim_uint32 i = 0; i < image.numcomps; ++i)
    {
       std::string s = "comps[";
       s += ossimString::toString(i).string();
       s += "]: ";
       out << s << std::endl;
          
       print(out, (image.comps[i]));
    }
 
    out << std::endl;
       
    // Set the flags back.
    out.flags(f);
 
    return out;
 }

◆ print() [5/8]

std::ostream & ossim::print	(	std::ostream &	out,
		const opj_image_comp &	comp
	)

Prints opj_image_comp structure.

Returns: std::ostream&

Definition at line 847 of file ossimOpjCommon.cpp.

 {
    // Capture stream flags since we are going to mess with them.
    std::ios_base::fmtflags f = out.flags();
 
    const int W = 20;
 
    out << std::setiosflags(std::ios_base::right) << std::setfill(' ')
        << "opj_image_comp:\n\n"
        << std::setw(W) << "dx: "
        << comp.dx << "\n"
        << std::setw(W) << "dy: "
        << comp.dy << "\n"
        << std::setw(W) << "w: "
        << comp.w << "\n"
        << std::setw(W) << "h: "
        << comp.h << "\n"
        << std::setw(W) << "x0: "
        << comp.x0 << "\n"
        << std::setw(W) << "y0: "
        << comp.y0 << "\n"
        << std::setw(W) << "prec: "
        << comp.prec << "\n"
        << std::setw(W) << "bpp: "
        << comp.bpp << "\n" 
        << std::setw(W) << "sgnd: "
        << comp.sgnd << "\n"
        << std::setw(W) << "resno_decoded: "
        << comp.resno_decoded << "\n"
        << std::setw(W) << "factor: "
        << comp.factor
        << std::endl;
       
    // Set the flags back.
    out.flags(f);
 
    return out;
 }

◆ print() [6/8]

std::ostream & ossim::print	(	std::ostream &	out,
		kdu_core::kdu_codestream &	cs
	)

Convenience print method for kdu_codestream.

Definition at line 860 of file ossimKakaduCommon.cpp.

 {
    out << "codestream debug:"
        << "exists: " << (cs.exists()?"true":"false");
    if (cs.exists())
    {
       const int BANDS = cs.get_num_components(true);
       out << "\ncomponents: " << BANDS;
       for (int i = 0; i < BANDS; ++i)
       {
          kdu_core::kdu_dims dims;
          cs.get_dims(i, dims, true);
          out << "\nbit_depth[" << i << "]: " << cs.get_bit_depth(i, true)
              << "\nsigned[" << i << "]: " << cs.get_signed(i, true)
              << "\ndims[" << i << "]: ";
          ossim::print(out, dims);
       }
       out << "\nlevels: " << cs.get_min_dwt_levels();
    }
    return out;
 }

◆ print() [7/8]

std::ostream & ossim::print	(	std::ostream &	out,
		const kdu_core::kdu_dims &	dims
	)

Convenience print method for kdu_dims.

Definition at line 882 of file ossimKakaduCommon.cpp.

References ossim_hdf5::print().

 {
    out << "pos: ";
    print(out, dims.pos);
    out << ", size: ";
    print(out, dims.size);
    out << "\n";
    return out;
 }

◆ print() [8/8]

std::ostream & ossim::print	(	std::ostream &	out,
		const kdu_core::kdu_coords &	coords
	)

Convenience print method for kdu_coords.

Definition at line 892 of file ossimKakaduCommon.cpp.

 {
    out << "(" << coords.x << ", " << coords.y << ")";
    return out;
 }

◆ quaderp()

template<class S , class T >

T ossim::quaderp	(	S	x,
		T	begin,
		T	middle,
		T	end
	)

Definition at line 158 of file ossimCommon.h.

References x.

     {
         // newton interpolation
         const T a1 = S(2)*(middle - begin);
         const T a2 = S(2)*(end - middle) - a1;
         return x*((x - S(0.5))*a2 + a1) + begin;
     }

◆ quadraticRoots()

template<class T >

std::pair<T, T> ossim::quadraticRoots	(	T	a,
		T	b,
		T	c
	)

Definition at line 379 of file ossimCommon.h.

     {
             // XXX could suffer from catastrophic cancellation, 
             // see David Goldberg's "What Every Computer Scientist Should Know About Floating-Point Arithmetic"
         T s = std::sqrt(b*b - T(4)*a*c);
         T twoA = T(2)*a;
             return std::pair<T, T>((-b + s)/twoA, (-b - s)/twoA); 
     }

◆ radiansToDegrees()

double ossim::radiansToDegrees ( double x )

inline

Definition at line 257 of file ossimCommon.h.

References DEG_PER_RAD, and x.

Referenced by ossim::Quaternion::getRotate(), ossimMercatorProjection::inverse(), and ossimRsmModel::lineSampleHeightToWorld().

257 { return x*DEG_PER_RAD;}

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519

Referenced by ossimNitfCommon::getCompressionRate(), ossimRectilinearDataObject::getScalarSizeInBytes(), ossimGdalTileSource::getTile(), ossimHdf5ImageHandler::getTile(), ossimH5ImageHandler::getTile(), ossimImageCombiner::initialize(), ossimH5ImageDataset::initialize(), ossimSrtmHandler::open(), ossimTiffWriter::openTiff(), ossimImageMetaData::ossimImageMetaData(), ossim_hdf5::printObject(), ossimHdf5ImageDataset::scanForMinMax(), ossimImageMetaData::setScalarType(), ossimImageMetaData::updateMetaData(), ossimNitf20Writer::writeBlockBandSeparate(), ossimNitfWriter::writeBlockBandSeparate(), ossimNitf20Writer::writeBlockBandSequential(), and ossimNitfWriter::writeBlockBandSequential().

#define DEG_PER_RAD

Definition: ossimConstants.h:452

◆ round()

template<class R , class F >

R ossim::round ( F x )

inline

Definition at line 361 of file ossimCommon.h.

References isnan(), ossimENSURE, and x.

         {
             R result = static_cast<R>((x < F(0)) ? std::ceil(x - F(0.5)) : std::floor(x + F(0.5)));
             
             ossimENSURE(ossim::isnan(x) == ossim::isnan(result));   // if x is nan, R must be a float type
             return result;
             
             // XXX is this better than use of ceil/floor?:    return static_cast<long long>((x < T(0)) ? x - T(0.5) : x + T(0.5));
         }

◆ scalarSizeInBytes()

ossim_uint32 ossim::scalarSizeInBytes ( ossimScalarType scalarType )

Definition at line 311 of file ossimCommon.cpp.

References OSSIM_FLOAT32, OSSIM_FLOAT64, OSSIM_NORMALIZED_DOUBLE, OSSIM_NORMALIZED_FLOAT, OSSIM_SCALAR_UNKNOWN, OSSIM_SINT16, OSSIM_SINT32, OSSIM_SINT8, OSSIM_UINT16, OSSIM_UINT32, OSSIM_UINT8, OSSIM_USHORT11, OSSIM_USHORT12, OSSIM_USHORT13, OSSIM_USHORT14, and OSSIM_USHORT15.

 {
    switch(scalarType)
    {
       case OSSIM_UINT8:
       {
          return sizeof(ossim_uint8);
       }
       case OSSIM_SINT8:
       {
          return sizeof(ossim_sint8);
       }
       case OSSIM_UINT16:
       case OSSIM_USHORT11:
       case OSSIM_USHORT12:
       case OSSIM_USHORT13:
       case OSSIM_USHORT14:
       case OSSIM_USHORT15:
       {
          return sizeof(ossim_uint16);
       }
       case OSSIM_SINT16:
       {
          return sizeof(ossim_sint16);
       }
       case OSSIM_UINT32:
       {
          return sizeof(ossim_uint32);
       }
       case OSSIM_SINT32:
       {
          return sizeof(ossim_sint32);
       }
       case OSSIM_FLOAT32:
       case OSSIM_NORMALIZED_FLOAT:
       {
          return sizeof(ossim_float32);
       }
       case OSSIM_FLOAT64:
       case OSSIM_NORMALIZED_DOUBLE:
       {
          return sizeof(ossim_float64);
       }
       case OSSIM_SCALAR_UNKNOWN:
       default:
       {
          if (traceDebug())
          {
             ossimNotify(ossimNotifyLevel_DEBUG)
                << __FILE__ << ":" << __LINE__
                << "\nUnhandled scalar type:  " << scalarType << std::endl;
          }
          break;
       }
   }
   
   return 1;
 }

◆ sgn() [1/2]

template<class T >

T ossim::sgn ( T x )

inline

Definition at line 339 of file ossimCommon.h.

Referenced by ossimPositionQualityEvaluator::atan3(), ossimImageGeometry::calculatePolyBounds(), ossimImageViewProjectionTransform::getViewSegments(), and ossimImageViewProjectionTransform::initializeViewSize().

         {
             const T table[] = {T(0), T(1), T(-1)};
             return table[((x < T(0)) << 1) | (x > T(0))];
         }

◆ sgn() [2/2]

template<>

ossim_float64 ossim::sgn ( ossim_float64 x )

inline

Definition at line 353 of file ossimCommon.h.

References isnan(), and x.

         {
             const ossim_float64 table[] = {ossim_float64(0), ossim_float64(1), ossim_float64(-1)};
             return ossim::isnan(x) ? x : table[((x < ossim_float64(0)) << 1) | (x > ossim_float64(0))];
         }

◆ sgn< ossim_float32 >()

template<>

ossim_float32 ossim::sgn< ossim_float32 > ( ossim_float32 x )

inline

Definition at line 346 of file ossimCommon.h.

References isnan(), and x.

         {
             const ossim_float32 table[] = {ossim_float32(0), ossim_float32(1), ossim_float32(-1)};
             return ossim::isnan(x) ? x : table[((x < ossim_float32(0)) << 1) | (x > ossim_float32(0))];
         }

◆ sind()

double ossim::sind ( double x )

inline

Definition at line 260 of file ossimCommon.h.

References RAD_PER_DEG, and x.

Referenced by ossimEllipsoid::geodeticRadii(), ossimEllipsoid::geodeticRadius(), ossimEllipsoid::latLonHeightToXYZ(), ossimLsrSpace::ossimLsrSpace(), ossimIpodSensor::updateModel(), ossimSkyBoxLearSensor::updateModel(), ossimAdjMapModel::updateModel(), ossimLandSatModel::updateModel(), and ossimRpcModel::updateModel().

260 { return std::sin(x*RAD_PER_DEG); }

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519

#define RAD_PER_DEG

Definition: ossimConstants.h:458

◆ skipws()

std::istream & ossim::skipws ( std::istream & in )

Definition at line 38 of file ossimCommon.cpp.

References isWhiteSpace().

Referenced by extractSimpleValues(), ossimEnviHeader::isEnviHeader(), ossimNmeaMessage::parseMessage(), ossimEnviHeader::readStream(), ossimIrect::toRect(), ossimDrect::toRect(), toSimpleVector(), and toVector().

 {
    int c = in.peek();
    while( !in.bad() && ossim::isWhiteSpace(c))
    {
       in.ignore();
       c = in.peek();
    }
    
    return in;
 }

◆ square()

template<class T >

T ossim::square ( T x )

inline

Definition at line 334 of file ossimCommon.h.

References x.

Referenced by Cholesky(), ossimMagicFilter::filter(), ossimRadialDecentLensDistortion::forward(), and SVD().

335 { return x*x; }

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519

◆ tand()

double ossim::tand ( double x )

inline

Definition at line 261 of file ossimCommon.h.

References RAD_PER_DEG, and x.

261 { return std::tan(x*RAD_PER_DEG); }

ossim_uint32 x

Definition: ossimPdfWriter.cpp:519