Software for Satellite Image processing and analysis

Programming languages

Ideal programming language for satellite image processing and analysis

Ideal programming language for satellite image processing and analysis?

Visual environments

Examples

Programming versus visual environments

Scripting verus Traditional Programming

Why Python?

Scalability

Scientific Python Environment

Getting started with IPython

Invoking the IPython shell 

ipython
ipython -pylab

loads pylab module and enables interactive plotting

Quit with CTRL-D

Getting help 

help()
help modules

list available modules

Features of IPython:

Importing modules

There are many ways to import modules. The resulting namespaces are different

Import module SciPy: import scipy

List SciPy subpackages help(scipy) or scipy.info(scipy)

Import SciPy subpackage n-dimensional image package import scipy.ndimage

List ndimage functions help(scipy.ndimage) \item \textbf{help(scipy.ndimage.laplace)}\\ Help on ndimage function laplace \item \textbf{from scipy import *}\\ Import SciPy module into local namespace \item \textbf{import scipy.ndimage as ndi}\\ Import SciPy subpackage ndimage in namespace ndi \item \textbf{scipy.source(ndi.laplace)}\\ Write source for this object to output \end{itemize} \vfill}

\begin{frame}[fragile]\frametitle{Getting started: defining functions and visualization} \vfill\small \begin{lstlisting} def tv(a):

a=rand(10,10) tv(a) savefig('figure1.png',dpi=100) \end{lstlisting} \vfill \includegraphics[height=0.4\textheight]{images/figure1.png} \end{frame}

\begin{frame}[fragile]\frametitle{Getting started: basic plotting} \vfill\small \begin{lstlisting} x=linspace(0,2*pi,100) plot(x,sin(x),x,cos(x)) grid() axis('tight') legend(('sin(x)','cos(x)'),'upper right') xlabel('x') ylabel('f(x)') \end{lstlisting} \vfill \includegraphics[height=0.6\textheight]{images/sinx.png} \end{frame}

\section{Basic Python} \begin{frame}[fragile]\frametitle{Basic Python} \vfill \begin{itemize} \item Keywords \item Built-in types \item Operators \item Conditions \item Variables \item Functions \end{itemize} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{Basic Python} \vfill Python built-in keywords \small \begin{verbatim} help> keywords

and else import raise assert except in return break exec is try class finally lambda while continue for not yield def from or del global pass elif if print \end{verbatim} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{Built-in types} \vfill \textbf{Python built-in numeric types}\vfill There are four distinct numeric types: \begin{itemize} \item plain integers \textbf{int} \item long integers \textbf{long} \item floating point numbers \textbf{float} \item complex numbers \textbf{complex} \end{itemize} In addition, Booleans are a subtype of plain integers \vfill \end{frame}

\begin{frame}[fragile]\frametitle{Operations} \small \begin{verbatim} x + y sum of x and y x - y difference of x and y x * y product of x and y x / y quotient of x and y x // y (floored) quotient of x and y x % y remainder of x / y -x x negated +x x unchanged abs(x) absolute value or magnitude of x int(x) x converted to integer long(x) x converted to long integer float(x) x converted to floating point complex(re,im) a complex number with real part re,

c.conjugate() conjugate of the complex number c x ** y x to the power y \end{verbatim} \end{frame}

\begin{frame}[fragile]\frametitle{Comparisons} \small \begin{verbatim} < strictly less than <= less than or equal > strictly greater than >= greater than or equal == equal != not equal

is object identity \end{verbatim} \end{frame}

\begin{frame}[fragile]\frametitle{Boolean} Boolean (logical) types \begin{itemize} \item \textbf{True} \item \textbf{False} \end{itemize} \vfill Boolean Operations: \textbf{and}, \textbf{or}, \textbf{not} \small \begin{verbatim} x or y if x is false, then y, else x x and y if x is false, then x, else y not x if x is false, then True, else False \end{verbatim} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{Sequence types} Sequence types \begin{itemize} \item \textbf{str} \item \textbf{list} \item \textbf{tuple} \end{itemize} Operations \small \begin{verbatim} x in s True if an item of s is equal to x, else False x not in s False if an item of s is equal to x,

s + t the concatenation of s and t s[i] i'th item of s s[i:j] slice of s from i to j s[i:j:k] slice of s from i to j with step k len(s) length of s min(s) smallest item of s max(s) largest item of s \end{verbatim} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{Variables, assignment} The \textbf{assignment statement =} creates new variables and gives them values \begin{verbatim} a=2 l=9**1000L S='Hello' f=1e5 \end{verbatim} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{Lists and tuples} \begin{itemize} \item Lists \textbf{[]} are mutable sequences of values \item Tuples \textbf{()} can not be changed (immutable) \end{itemize} \tiny \begin{verbatim} In [5]: a=[1,2,3] In [6]: b=(1,2,3)

In [7]: a[0] Out[7]: 1

In [8]: b[0] Out[8]: 1

In [9]: a[0]=4

In [10]: a Out[10]: [4, 2, 3]

In [11]: b[0]=4

exceptions.TypeError \end{verbatim} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{Indexing and slicing} \begin{itemize} \item Indices \textbf{[]} select elements of variables \item Indices start from zero \item \textbf{[a:b]} selects a slice of elements \end{itemize} \tiny \begin{verbatim} In [1]: a=range(10)

In [2]: a Out[2]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [3]: a[0:4] Out[3]: [0, 1, 2, 3]

In [4]: a[4:] Out[4]: [4, 5, 6, 7, 8, 9]

In [5]: a[:4] Out[5]: [0, 1, 2, 3]

In [6]: a[:-1] Out[6]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

In [7]: s='Hello world' In [8]: s[:5] Out[8]: 'Hello'

In [9]: a=tuple(range(10)) In [10]: a[0:4] Out[10]: (0, 1, 2, 3) \end{verbatim} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{List built-in functions (methods)} \begin{itemize} \item \textbf{L.append(object)} -- append object to end \item \textbf{L.count(value)} -> integer -- return number of occurrences of value \item \textbf{L.extend(iterable)} -- extend list by appending elements from the iterable \item \textbf{L.index(value, [start, [stop]])} -> integer -- return first index of value \item \textbf{L.insert(index, object)} -- insert object before index \item \textbf{L.pop([index])} -> item -- remove and return item at index (default last) \item \textbf{L.reverse()} -- reverse *IN PLACE* \item \textbf{L.sort()} -- stable sort *IN PLACE* \end{itemize} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{List built-in functions (methods)} \scriptsize \begin{verbatim} In [72]: L=['C','A','B'] In [73]: L.sort()

In [74]: L Out[74]: ['A', 'B', 'C']

In [75]: L.pop() Out[75]: 'C'

In [76]: L Out[76]: ['A', 'B']

In [77]: L.insert(1,'C')

In [78]: L Out[78]: ['A', 'C', 'B'] \end{verbatim} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{Nested data structures} \scriptsize \begin{verbatim} In [84]: a=range(10) In [85]: b=range(0,10,2) In [86]: b Out[86]: [0, 2, 4, 6, 8]

In [87]: c=[a,b]

In [88]: c Out[88]: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 2, 4, 6, 8

In [91]: c[0] Out[91]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [92]: c[1] Out[92]: [0, 2, 4, 6, 8]

In [93]: c[0][0:4] Out[93]: [0, 1, 2, 3]

In [94]: c[1][0:4] Out[94]: [0, 2, 4, 6] \end{verbatim} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{Dictionary}

\begin{itemize} \item A dictionary is like a list, but more general. \item In a list, the indices have to be integers; in a dictionary they can be (almost) any type. \item \textbf{d=\{\}} creates empty dictionary \item \textbf{d[key]=value} add a key, value pair to dictionary \item \textbf{d.keys()} returns list of keys \end{itemize} \scriptsize \begin{verbatim} In [95]: D={} In [96]: D['a']=range(10) In [97]: D['b']=range(0,10,2)

In [98]: D Out[98]: {'a': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 'b': [0, 2, 4, 6, 8]}

In [99]: D['a'] Out[99]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [100]: D.keys() Out[100]: ['a', 'b'] \end{verbatim} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{Loops} \begin{itemize} \item Looping over a list is done for the \textbf{for} statement \item \textbf{enumerate()} returns an enumerated object \end{itemize} \scriptsize \begin{verbatim} In [106]: a=['Hund','Katze','Maus'] In [108]: for i in a:

Hund Katze Maus

In [111]: for i,j in enumerate(a):

0 Hund 1 Katze 2 Maus

\end{verbatim} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{Control statements} \begin{itemize} \item Conditions can be checked with \textbf{if-else} statement \item \textbf{if} condition: indented block \item \textbf{else:} \item condition \end{itemize} \scriptsize \begin{verbatim} In [116]: if a==1:

a=1 \end{verbatim} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{Functions} Function with one argument \begin{verbatim} In [124]: def quadrat(x):

In [125]: quadrat(2) Out[125]: 4 \end{verbatim} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{Functions} Function with variable number of arguments \begin{verbatim} In [126]: def printargs(*args):

In [127]: printargs(a) [1, 2, 3]

In [128]: printargs(a,range(4)) [1, 2, 3] [0, 1, 2, 3] \end{verbatim} \vfill \end{frame}

\begin{frame}[fragile]\frametitle{Functions} Function with variable number of keywords \begin{verbatim} In [131]: def printkeys(**kw):

In [132]: printkeys(key1=10,key2='Hallo') key2 Hallo key1 10 \end{verbatim} \vfill \end{frame}

\end{document}