Application: gvSIG desktop » gvSIG 3D

#  $Id: gcps2wld.py 18953 2010-02-28 12:00:54Z rouault $

    print('Unable to open %s' % filename)

# $Id: gdal_merge.py 18953 2010-02-28 12:00:54Z rouault $

                print('Unknown GDAL data type: %s' % argv[i])

            print('Unrecognised command option: %s' % arg)

#  $Id: gdal_polygonize.py 18953 2010-02-28 12:00:54Z rouault $

    print('Unable to open %s' % src_filename)

else:

    if dst_fieldname is not None:

        dst_field = dst_layer.GetLayerDefn().GetFieldIndex(dst_fieldname)

        if dst_field < 0:

            print("Warning: cannot find field '%s' in layer '%s'" % (dst_fieldname, dst_layername))

#  $Id: epsg_tr.py 18953 2010-02-28 12:00:54Z rouault $

        print('Unable to lookup %d, either not a valid EPSG' % code)

                print('EPSG:%d' % code)

                print('EPSG:%d' % code)

#  $Id: esri2wkt.py 18953 2010-02-28 12:00:54Z rouault $

    print('Error = %d' % err)

#  $Id: gdalchksum.py 18953 2010-02-28 12:00:54Z rouault $

    print('Unable to open %s' % filename)

CONFIG_VERSION="1.7.2"

#!/usr/bin/env python2.6

# See http://cens.ioc.ee/projects/f2py2e/

import os, sys

for mode in ["g3-numpy", "2e-numeric", "2e-numarray", "2e-numpy"]:

    try:

        i=sys.argv.index("--"+mode)

        del sys.argv[i]

        break

    except ValueError: pass

os.environ["NO_SCIPY_IMPORT"]="f2py"

if mode=="g3-numpy":

    print >> sys.stderr, "G3 f2py support is not implemented, yet."

    sys.exit(1)

elif mode=="2e-numeric":

    from f2py2e import main

elif mode=="2e-numarray":

    sys.argv.append("-DNUMARRAY")

    from f2py2e import main

elif mode=="2e-numpy":

    from numpy.f2py import main

else:

    print >> sys.stderr, "Unknown mode:",`mode`

    sys.exit(1)

main()

#  $Id: gdal_proximity.py 18953 2010-02-28 12:00:54Z rouault $

quiet_flag = 0

    print('Unable to open %s' % src_filename)

#  $Id: gdalimport.py 18953 2010-02-28 12:00:54Z rouault $

    print('%s %d' % (cb_data, complete))

    print('Unable to open %s' % filename)

print('Importing to Tiled GeoTIFF file: %s' % newfile)

#  $Id: gdal_sieve.py 18953 2010-02-28 12:00:54Z rouault $

    print('Unable to open %s ' % src_filename)

#  $Id: rgb2pct.py 18953 2010-02-28 12:00:54Z rouault $

    print('Unable to open %s' % src_filename)

#  $Id: pct2rgb.py 18953 2010-02-28 12:00:54Z rouault $

    print('Unable to open %s ' % src_filename)

    print('Unable to open %s' % src_filename)

#  $Id: gdal_retile.py 18955 2010-02-28 12:13:25Z rouault $

            print("Error openenig:%s" % NameError)

        self.countTilesX= int(xsize / tileWidth)

        self.countTilesY= int(ysize / tileHeight)

        self.lastTileWidth = int(xsize - self.countTilesX *  tileWidth)

        self.lastTileHeight = int(ysize - self.countTilesY *  tileHeight)

        from sys import version_info

        if version_info >= (3,0,0):

            exec('print("Building internal Index for %d tile(s) ..." % len(inputTiles), end=" ")')

        else:

            exec('print "Building internal Index for %d tile(s) ..." % len(inputTiles), ')

                print('Unknown GDAL data type: %s' % argv[i])

                print("Unknown resampling method: %s" % ResamplingMethodString)

                print("Invalid number of levels : %d" % Levels)

            print('Unrecognised command option: %s' % arg)

                print("Cannot create level dir: %s" % leveldir)

                print("Created level dir: %s" % leveldir)

#  $Id: gcps2vec.py 18953 2010-02-28 12:00:54Z rouault $

    print('Unable to open %s' % filename)

	<string>GDAL/OGR 1.7.2-2</string>

	<string>1.7.2</string>

	<string>GDAL/OGR 1.7.2-2</string>

 <img src="gdalicon.png" alt="GDAL">  is a translator library for raster geospatial data formats that is released under an <a href="http://trac.osgeo.org/gdal/wiki/FAQGeneral#WhatlicensedoesGDALOGRuse">X/MIT</a> style <a href="http://www.opensource.org/">Open Source</a> license by the <a href="http://www.osgeo.org/">Open Source Geospatial Foundation</a>. As a library, it presents a <a class="el" href="gdal_datamodel.html">single abstract data model</a> to the calling application for all supported formats. It also comes with a variety of useful <a class="el" href="gdal_utilities.html">commandline utilities</a> for data translation and processing. The <a href="http://trac.osgeo.org/gdal/wiki/Release/1.7.2-News">NEWS</a> page describes the April 2010 GDAL/OGR 1.7.2 release.<p>

1600,KENTUCKY,SINGLE ZONE,2,NAD83,1600,3088 

10407,CALIFORNIA,VII,2,NAD27,407,26799

 * $Id: cpl_atomic_ops.h 19357 2010-04-10 09:27:35Z rouault $

#ifdef CPL_INLINE

#else

int CPL_DLL CPLAtomicInc(volatile int* ptr);

#endif

#ifdef CPL_INLINE

#else

int CPL_DLL CPLAtomicDec(volatile int* ptr);

#endif

#  define GDAL_VERSION_REV      2

#  define GDAL_RELEASE_DATE     20100423

#  define GDAL_RELEASE_NAME     "1.7.2"

Conveniently, one can access any field of the array by indexing using the

string that names that field. In this case the fields have received the

default names 'f0', 'f1' and 'f2'.

in the record. But, rather than being a copy of the data in the structured

array, it is a view, i.e., it shares exactly the same memory locations.

Thus, when we updated this array by doubling its values, the structured

array shows the corresponding values as doubled as well. Likewise, if one

changes the record, the field view also changes: ::

One defines a structured array through the dtype object.  There are

**several** alternative ways to define the fields of a record.  Some of

these variants provide backward compatibility with Numeric, numarray, or

another module, and should not be used except for such purposes. These

will be so noted. One specifies record structure in

one of four alternative ways, using an argument (as supplied to a dtype

function keyword or a dtype object constructor itself).  This

argument must be one of the following: 1) string, 2) tuple, 3) list, or

4) dictionary.  Each of these is briefly described below.

In this case, the constructor expects a comma-separated list of type

specifiers, optionally with extra shape information.

>>> help(np.doc.TOPIC)

NumPy operations are usually done on pairs of arrays on an

element-by-element basis.  In the simplest case, the two arrays must

have exactly the same shape, as in the following example:

The code in the second example is more efficient than that in the first

because broadcasting moves less memory around during the multiplication

(``b`` is a scalar rather than an array).

  B      (3d array):  8 x 4 x 3 # second from last dimensions mismatched

An example illustrates much better than a verbal description: ::

'''

=============================

 Byteswapping and byte order

=============================

Introduction to byte ordering and ndarrays

==========================================

The ``ndarray`` is an object that provide a python array interface to data

in memory.

It often happens that the memory that you want to view with an array is

not of the same byte ordering as the computer on which you are running

Python.

For example, I might be working on a computer with a little-endian CPU -

such as an Intel Pentium, but I have loaded some data from a file

written by a computer that is big-endian.  Let's say I have loaded 4

bytes from a file written by a Sun (big-endian) computer.  I know that

these 4 bytes represent two 16-bit integers.  On a big-endian machine, a

two-byte integer is stored with the Most Significant Byte (MSB) first,

and then the Least Significant Byte (LSB). Thus the bytes are, in memory order:

#. MSB integer 1

#. LSB integer 1

#. MSB integer 2

#. LSB integer 2

Let's say the two integers were in fact 1 and 770.  Because 770 = 256 *

3 + 2, the 4 bytes in memory would contain respectively: 0, 1, 3, 2.

The bytes I have loaded from the file would have these contents:

>>> big_end_str = chr(0) + chr(1) + chr(3) + chr(2)

>>> big_end_str

'\\x00\\x01\\x03\\x02'

We might want to use an ``ndarray`` to access these integers.  In that

case, we can create an array around this memory, and tell numpy that

there are two integers, and that they are 16 bit and big-endian:

>>> import numpy as np

>>> big_end_arr = np.ndarray(shape=(2,),dtype='>i2', buffer=big_end_str)

>>> big_end_arr[0]

1

>>> big_end_arr[1]

770

Note the array ``dtype`` above of ``>i2``.  The ``>`` means 'big-endian'

(``<`` is little-endian) and ``i2`` means 'signed 2-byte integer'.  For

example, if our data represented a single unsigned 4-byte little-endian

integer, the dtype string would be ``<u4``.

In fact, why don't we try that?

>>> little_end_u4 = np.ndarray(shape=(1,),dtype='<u4', buffer=big_end_str)

>>> little_end_u4[0] == 1 * 256**1 + 3 * 256**2 + 2 * 256**3

True

Returning to our ``big_end_arr`` - in this case our underlying data is

big-endian (data endianness) and we've set the dtype to match (the dtype

is also big-endian).  However, sometimes you need to flip these around.

Changing byte ordering

======================

As you can imagine from the introduction, there are two ways you can

affect the relationship between the byte ordering of the array and the

underlying memory it is looking at:

* Change the byte-ordering information in the array dtype so that it

  interprets the undelying data as being in a different byte order.

  This is the role of ``arr.newbyteorder()``

* Change the byte-ordering of the underlying data, leaving the dtype

  interpretation as it was.  This is what ``arr.byteswap()`` does.

The common situations in which you need to change byte ordering are:

#. Your data and dtype endianess don't match, and you want to change

   the dtype so that it matches the data.

#. Your data and dtype endianess don't match, and you want to swap the

   data so that they match the dtype

#. Your data and dtype endianess match, but you want the data swapped

   and the dtype to reflect this

Data and dtype endianness don't match, change dtype to match data

-----------------------------------------------------------------

We make something where they don't match:

>>> wrong_end_dtype_arr = np.ndarray(shape=(2,),dtype='<i2', buffer=big_end_str)

>>> wrong_end_dtype_arr[0]

256

The obvious fix for this situation is to change the dtype so it gives

the correct endianness:

>>> fixed_end_dtype_arr = wrong_end_dtype_arr.newbyteorder()

>>> fixed_end_dtype_arr[0]

1

Note the the array has not changed in memory:

>>> fixed_end_dtype_arr.tostring() == big_end_str

True

Data and type endianness don't match, change data to match dtype

----------------------------------------------------------------

You might want to do this if you need the data in memory to be a certain

ordering.  For example you might be writing the memory out to a file

that needs a certain byte ordering.

>>> fixed_end_mem_arr = wrong_end_dtype_arr.byteswap()

>>> fixed_end_mem_arr[0]

1

Now the array *has* changed in memory:

>>> fixed_end_mem_arr.tostring() == big_end_str

False

Data and dtype endianness match, swap data and dtype

----------------------------------------------------

You may have a correctly specified array dtype, but you need the array

to have the opposite byte order in memory, and you want the dtype to

match so the array values make sense.  In this case you just do both of

the previous operations:

>>> swapped_end_arr = big_end_arr.byteswap().newbyteorder()

>>> swapped_end_arr[0]

1

>>> swapped_end_arr.tostring() == big_end_str

False

'''

#

# Note: the docstring is autogenerated.

#

import textwrap, re

    Use `inf` because `Inf`, `Infinity`, `PINF` and `infty` are aliases for

    `inf`. For more details, see `inf`.

    See Also

    --------

    inf

    Use `inf` because `Inf`, `Infinity`, `PINF` and `infty` are aliases for

    `inf`. For more details, see `inf`.

    See Also

    --------

    inf

    `NaN` and `NAN` are equivalent definitions of `nan`. Please use

    `nan` instead of `NAN`.

    y : float

        A floating point representation of negative infinity.

    y : float

        A floating point representation of negative zero.

    `NaN` and `NAN` are equivalent definitions of `nan`. Please use

    `nan` instead of `NaN`.

    Use `inf` because `Inf`, `Infinity`, `PINF` and `infty` are aliases for

    `inf`. For more details, see `inf`.

    See Also

    --------

    inf

    y : float

        A floating point representation of positive zero.

    (IEEE 754). Positive zero is considered to be a finite number.

    y : float

        A floating point representation of positive infinity.

    `Inf`, `Infinity`, `PINF` and `infty` are aliases for `inf`.

    >>> np.array([1]) / 0.

    Use `inf` because `Inf`, `Infinity`, `PINF` and `infty` are aliases for

    `inf`. For more details, see `inf`.

    See Also

    --------

    inf

    `NaN` and `NAN` are aliases of `nan`.

    A convenient alias for None, useful for indexing arrays.

    >>> x[:, newaxis]

    >>> x[:, newaxis, newaxis]

    >>> x[:, newaxis] * x

    Outer product, same as ``outer(x, y)``:

    >>> y = np.arange(3, 6)

    >>> x[:, newaxis] * y

    ``x[newaxis, :]`` is equivalent to ``x[newaxis]`` and ``x[None]``:

    >>> x[newaxis, :].shape

    >>> x[:, newaxis].shape

        s = textwrap.dedent(doc).replace("\n", "\n    ")

        # Replace sections by rubrics

        lines = s.split("\n")

        new_lines = []

        for line in lines:

            m = re.match(r'^(\s+)[-=]+\s*$', line)

            if m and new_lines:

                prev = textwrap.dedent(new_lines.pop())

                new_lines.append('%s.. rubric:: %s' % (m.group(1), prev))

                new_lines.append('')

            else:

                new_lines.append(line)

        s = "\n".join(new_lines)

        # Done.

        constants_str.append(""".. const:: %s\n    %s""" % (name, s))

    del line, lines, new_lines, m, s, prev

Subclassing ndarray is relatively simple, but it has some complications

compared to other Python objects.  On this page we explain the machinery

that allows you to subclass ndarray, and the implications for

implementing a subclass.

Subclassing ndarray is complicated by the fact that new instances of

ndarray classes can come about in three different ways.  These are:

#. Explicit constructor call - as in ``MySubClass(params)``.  This is

   the usual route to Python instance creation.

#. View casting - casting an existing ndarray as a given subclass

#. New from template - creating a new instance from a template

   instance. Examples include returning slices from a subclassed array,

   creating return types from ufuncs, and copying arrays.  See

   :ref:`new-from-template` for more details

The last two are characteristics of ndarrays - in order to support

things like array slicing.  The complications of subclassing ndarray are

due to the mechanisms numpy has to support these latter two routes of

instance creation.

.. _view-casting:

View casting

------------

*View casting* is the standard ndarray mechanism by which you take an

ndarray of any subclass, and return a view of the array as another

(specified) subclass:

>>> # create a completely useless ndarray subclass

>>> class C(np.ndarray): pass

>>> # create a standard ndarray

>>> # take a view of it, as our useless subclass

>>> c_arr = arr.view(C)

>>> type(c_arr)

<class 'C'>

.. _new-from-template:

Creating new from template

--------------------------

New instances of an ndarray subclass can also come about by a very

similar mechanism to :ref:`view-casting`, when numpy finds it needs to

create a new instance from a template instance.  The most obvious place

this has to happen is when you are taking slices of subclassed arrays.

For example:

>>> v = c_arr[1:]

>>> type(v) # the view is of type 'C'

<class 'C'>

>>> v is c_arr # but it's a new instance

The slice is a *view* onto the original ``c_arr`` data.  So, when we

take a view from the ndarray, we return a new ndarray, of the same

class, that points to the data in the original.

There are other points in the use of ndarrays where we need such views,

such as copying arrays (``c_arr.copy()``), creating ufunc output arrays

(see also :ref:`array-wrap`), and reducing methods (like

``c_arr.mean()``.

Relationship of view casting and new-from-template

--------------------------------------------------

These paths both use the same machinery.  We make the distinction here,

because they result in different input to your methods.  Specifically,

:ref:`view-casting` means you have created a new instance of your array

type from any potential subclass of ndarray.  :ref:`new-from-template`

means you have created a new instance of your class from a pre-existing

instance, allowing you - for example - to copy across attributes that

are particular to your subclass.

Implications for subclassing

----------------------------

If we subclass ndarray, we need to deal not only with explicit

construction of our array type, but also :ref:`view-casting` or

:ref:`new-from-template`.  Numpy has the machinery to do this, and this

machinery that makes subclassing slightly non-standard.

There are two aspects to the machinery that ndarray uses to support

views and new-from-template in subclasses.

The first is the use of the ``ndarray.__new__`` method for the main work

of object initialization, rather then the more usual ``__init__``

method.  The second is the use of the ``__array_finalize__`` method to

allow subclasses to clean up after the creation of views and new

instances from templates.

A brief Python primer on ``__new__`` and ``__init__``

=====================================================

``__new__`` is a standard Python method, and, if present, is called

before ``__init__`` when we create a class instance. See the `python

__new__ documentation

<http://docs.python.org/reference/datamodel.html#object.__new__>`_ for more detail.

For example, consider the following Python code:

.. testcode::

          print 'Cls in __new__:', cls

          print 'type(self) in __init__:', type(self)

meaning that we get:

>>> c = C('hello')

Cls in __new__: <class 'C'>

Args in __new__: ('hello',)

type(self) in __init__: <class 'C'>

Args in __init__: ('hello',)