This file is indexed.

/usr/lib/python3/dist-packages/affine-1.2.0.egg-info/PKG-INFO is in python3-affine 1.2.0-1.

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
Metadata-Version: 1.0
Name: affine
Version: 1.2.0
Summary: Matrices describing affine transformation of the plane
Home-page: https://github.com/sgillies/affine
Author: Sean Gillies
Author-email: sean@mapbox.com
License: BSD
Description: Affine
        ======
        
        Matrices describing affine transformation of the plane.
        
        .. image:: https://travis-ci.org/sgillies/affine.svg?branch=master
            :target: https://travis-ci.org/sgillies/affine
        
        .. image:: https://coveralls.io/repos/sgillies/affine/badge.svg
            :target: https://coveralls.io/r/sgillies/affine
        
        The Affine package is derived from Casey Duncan's Planar package. Please see
        the copyright statement in `affine/__init__.py <affine/__init__.py>`__.
        
        Usage
        -----
        
        The 3x3 augmented affine transformation matrix for transformations in two
        dimensions is illustrated below.
        
        .. ::
        
          | x' |   | a  b  c | | x |
          | y' | = | d  e  f | | y |
          | 1  |   | 0  0  1 | | 1 |
        
        Matrices can be created by passing the values ``a, b, c, d, e, f`` to the
        ``affine.Affine`` constructor or by using its ``identity()``,
        ``translation()``, ``scale()``, ``shear()``, and ``rotation()`` class methods.
        
        .. code-block:: pycon
        
          >>> from affine import Affine
          >>> Affine.identity()
          Affine(1.0, 0.0, 0.0,
                 0.0, 1.0, 0.0)
          >>> Affine.translation(1.0, 5.0)
          Affine(1.0, 0.0, 1.0,
                 0.0, 1.0, 5.0)
          >>> Affine.scale(2.0)
          Affine(2.0, 0.0, 0.0,
                 0.0, 2.0, 0.0)
          >>> Affine.shear(45.0, 45.0)  # decimal degrees
          Affine(1.0, 0.9999999999999999, 0.0,
                 0.9999999999999999, 1.0, 0.0)
          >>> Affine.rotation(45.0)     # decimal degrees
          Affine(0.7071067811865476, 0.7071067811865475, 0.0,
                 -0.7071067811865475, 0.7071067811865476, 0.0)
        
        These matrices can be applied to ``(x, y)`` tuples to obtain transformed
        coordinates ``(x', y')``.
        
        .. code-block:: pycon
        
          >>> Affine.translation(1.0, 5.0) * (1.0, 1.0)
          (2.0, 6.0)
          >>> Affine.rotation(45.0) * (1.0, 1.0)
          (1.1102230246251565e-16, 1.414213562373095)
        
        They may also be multiplied together to combine transformations.
        
        .. code-block:: pycon
        
          >>> Affine.translation(1.0, 5.0) * Affine.rotation(45.0)
          Affine(0.7071067811865476, 0.7071067811865475, 1.0,
                 -0.7071067811865475, 0.7071067811865476, 5.0)
        
        Usage with GIS data packages
        ----------------------------
        
        Georeferenced raster datasets use affine transformations to map from image
        coordinates to world coordinates. The ``affine.Affine.from_gdal()`` class
        method helps convert `GDAL GeoTransform
        <http://www.gdal.org/classGDALDataset.html#af9593cc241e7d140f5f3c4798a43a668>`__,
        sequences of 6 numbers in which the first and fourth are the x and y offsets
        and the second and sixth are the x and y pixel sizes.
        
        Using a GDAL dataset transformation matrix, the world coordinates ``(x, y)``
        corresponding to the top left corner of the pixel 100 rows down from the
        origin can be easily computed.
        
        .. code-block:: pycon
        
          >>> geotransform = (-237481.5, 425.0, 0.0, 237536.4, 0.0, -425.0)
          >>> fwd = Affine.from_gdal(*geotransform)
          >>> col, row = 0, 100
          >>> fwd * (col, row)
          (-237481.5, 195036.4)
        
        The reverse transformation is obtained using the ``~`` operator.
        
        .. code-block:: pycon
        
          >>> rev = ~fwd
          >>> rev * fwd * (col, row)
          (0.0, 99.99999999999999)
        
        
Keywords: affine transformation matrix
Platform: UNKNOWN