libossim-dev 1.8.16-3+b1 / usr / include / ossim / imaging / ossimTilePatch.h

This file is indexed.

/usr/include/ossim/imaging/ossimTilePatch.h is in libossim-dev 1.8.16-3+b1.

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

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
//*******************************************************************
// Copyright (C) 2000 ImageLinks Inc.
//
// License:  LGPL
// 
// See LICENSE.txt file in the top level directory for more details.
//
// Author:  Garrett Potts
//
//*******************************************************************
//  $Id: ossimTilePatch.h 15766 2009-10-20 12:37:09Z gpotts $

#ifndef ossimTilePatch_HEADER
#define ossimTilePatch_HEADER
#include <ossim/base/ossimObject.h>
#include <ossim/base/ossimRefPtr.h>
#include <ossim/base/ossimIrect.h>
#include <ossim/base/ossimDrect.h>
#include <ossim/imaging/ossimDiscreteNearestNeighbor.h>
#include <ossim/imaging/ossimImageData.h>

class ossimImageSource;

class ossimTilePatch : public ossimObject
{
public:
   ossimTilePatch(ossimImageSource* input);
   /*!
    * The rect is assumed up right and all we need
    * to do is compute the even tile boundary rect
    */
   ossimTilePatch(ossimScalarType scalarType = OSSIM_UCHAR,
                  long numberOfComponents = 1,
                  long width=128,
                  long height=128);
   
   /*!
    * return the tile boundary aligned rectangle for this
    * patch.
    */
   virtual ossimIrect getRect()const;

   /*!
    * The padding is for any convolution that must take
    * place.  
    */
   virtual void setRect(const ossimDpt &p1,
                        const ossimDpt &p2,
                        const ossimDpt &p3,
                        const ossimDpt &p4,
                        const ossimDpt &tile_size,
                        const ossimDpt &padding=ossimDpt(0,0));

   virtual void setRect(const ossimDrect &aRect,
                        const ossimDpt &tile_size,
                        const ossimDpt &padding=ossimDpt(0,0));

   virtual void setRect(const ossimDpt &center_of_rect,
                        const ossimDpt &rect_size,
                        const ossimDpt &tile_size,
                        const ossimDpt &padding=ossimDpt(0,0));

   /*!
    * This will fill the tile from the tile patch.
    */
   virtual void fillTile(ossimRefPtr<ossimImageData>& aTile)const;

   /*!
    * This will fill the tile from the tile patch and apply the convolution
    * kernel.  This is optimized for upright rectangles.  Use the bilinear
    * fill tile bellow for arbitrary 4-sided polygons.
    */
   virtual void fillTile(ossimRefPtr<ossimImageData>& result,
                         ossimDiscreteConvolutionKernel* kernel)const;

   /*!
    * We will assume that the patch is already
    * big enough to satisfy the kernel size.
    */
   virtual void fillTile(ossimRefPtr<ossimImageData>& result,
                         const ossimDpt   &ul,
                         const ossimDpt   &ur,
                         const ossimDpt   &deltaUl,
                         const ossimDpt   &deltaUr,
                         const ossimDpt   &length)const;


   virtual void fillPatch(ossimImageSource *imageSource,
                          long resLevel = 0);
   
   
   
//    static ossimIrect alignRectToBoundary(const ossimDrect &aRect,
//                                          const ossimDpt &tile_size);
   static ossimDrect findBoundingRect(const ossimDpt &p1,
                                      const ossimDpt &p2,
                                      const ossimDpt &p3,
                                      const ossimDpt &p4);
   /*!
    * Do not delete this data.  We give raw access to the buffer
    * if there are special things you wish to have done.
    */
   ossimRefPtr<ossimImageData> getData(){return thePatchData;}

   void setData(ossimRefPtr<ossimImageData>& patchData);
   /*!
    *  This will implement an in place convolution.  It will
    *  allocate a buffer pass it to the convolution algorithm
    * and then replace the internal buffer.
    */
   void convolve(ossimDiscreteConvolutionKernel* kernel);
   
protected:
   virtual ~ossimTilePatch();
   
   ossimRefPtr<ossimImageData>         thePatchData;
   static ossimDiscreteNearestNeighbor nearestNeighborKernel;
   


   template<class T>
   void fillTileTemplate(T dummyVariable,
                         ossimRefPtr<ossimImageData>& result,
                         const ossimDpt   &ul,
                         const ossimDpt   &ur,
                         const ossimDpt   &deltaUl,
                         const ossimDpt   &deltaUr,
                         const ossimDpt   &length)const;
   
   template<class T>
   void fillTileTemplate(T dummyVariable,
                         ossimRefPtr<ossimImageData>& result,
                         ossimDiscreteConvolutionKernel* kernel)const;
};

#endif

APT Browse - Built by Thomas Orozco.