Applied Computer Vision

From David Vernon's Wiki
Revision as of 07:37, 19 April 2017 by Dvernon (Talk | contribs)

Jump to: navigation, search

|CARNEGIE MELLON UNIVERSITY AFRICA|

04-800
Applied Computer Vision

Elective

Units: 12

Lecture/Lab/Rep hours/week: 4 hours lectures/week

Semester: Spring

Pre-requisites: programming skills

Students are expected to be familiar with programming in at least one programming language, ideally C/C++.

Course description

This course provides students with a solid foundation in the key elements of computer vision, emphasizing the practical application of the underlying theory. It focusses mainly on the techniques required to build robot vision applications but the algorithms can also be applied in other domains such as industrial inspection and video surveillance. A key focus of the course is on effective implementation of solutions to practical computer vision problems in a variety of environments using both bespoke software authored by the students and standard computer vision libraries.

Learning objectives

The course covers optics, sensors, image formation, image acquisition & image representation before proceeding to the essentials of image processing and image filtering. This provides the basis for a treatment of image segmentation, including edge detection, region growing, and boundary detection, the Hough transform, and colour-based segmentation.

Building on this, the course then proceeds to deal with object detection and recognition in 2D, addressing template matching, interest point operators, gradient orientation histograms, the SIFT descriptor, and colour histogram intersection and back-projection.

The problem of recovery of 3D information is then addressed, introducing homogeneous coordinates and transformations, the perspective transformation, camera model, inverse perspective transformation, stereo vision, and epipolar geometry.

The interpretation of visual information in unstructured environments poses many problems. To deal with these, the course then addresses visual attention, clustering, grouping, and segmentation, building on Gestalt principles, before proceeding to deal with object detection, object recognition, and object categorization in both 2D and 3D.

Outcomes

After completing this course, students should be able to:

  • Apply their knowledge of image acquisition, image processing, and image analysis to extract the required information from visual images.
  • Design, implement, and document appropriate, effective, and efficient software solutions for a variety of real-world computer vision problems.
  • Exploit standard computer vision software libraries in the development of these solutions.

Content details

Refer to the Lecture Schedule for information on course delivery, including lectures, labs, assignments, and exercises.

The course will cover the following topics:

  • Introduction: The Software Development Life Cycle
  • Formalisms for Representing Algorithms
  • Analysis of Complexity
  • Searching and Sorting Algorithms
  • Abstract Data Types (ADT)
  • Containers, Dictionaries, and Lists
  • Stacks
  • Queues
  • Trees
  • Heaps
  • Graphs
  • Complex Networks
  • Hashing
  • Algorithmic Strategies
  • Analysis of Correctness
  • Automata Theory
  • Computability Theory

The detailed content for each of these topics follows.


Introduction: The Software Development Life Cycle

  • Motivation
  • Goals of the course
  • Syllabus and lecture schedule
  • Course operation
  • Software development tools for assignments
  • Preview of course material
  • Levels of abstraction in information processing systems
  • The software development life cycle: Yourdon Structured Analysis - functional, data, and behavioural models (hierarchical decomposition trees, architecture diagrams, data flow diagrams DFD, data dictionaries, entity relationship ER diagrams, state transition diagrams)
  • Software process models: waterfall, evolutionary, formal transformation, re-use, hybrid, spiral

Formalisms for Representing Algorithms

  • Definition of an algorithm
  • Modelling software
  • Relational modelling
  • State modelling
  • Practical representations
  • Pseudo code
  • Flow charts
  • Finite state machines
  • UML
  • Predicate logic
  • Analysis

Analysis of Complexity

  • Performance of algorithms, time and space tradeoff, worst case and average case performance
  • Big O notation
  • Recurrence relationships
  • Analysis of complexity of iterative and recursive algorithms
  • Recursive vs. iterative algorithms: runtime memory implications
  • Complexity theory: tractable vs intractable algorithmic complexity
  • Example intractable problems: travelling salesman problem, Hamiltonian circuit, 3-colour problem, SAT, cliques
  • Determinism and non-determinism
  • P, NP, and NP-Complete classes of algorithm

Searching and Sorting Algorithms

  • Linear and binary search (iterative and recursive)
  • In-place sorts: bubblesort (efficient and inefficient), selection sort, insertion sort.
  • Not-in-place sorts: Quicksort, merge sort.
  • Complexity analysis
  • Characteristics of a good sort
  • Speed, consistency, keys, memory usage, length & code complexity, stability
  • Other sorts ordered by complexity

Abstract Data Types (ADT)

  • Vector example exercise
  • History of abstraction
  • Abstract Data Types (ADT)
  • Information hiding
  • Types and typing
  • Encapsulation
  • Efficiency
  • Design practices

Containers, Dictionaries, and Lists

  • Basic operations
  • Implementation with arrays and linked lists
  • Singly linked lists
  • Doubly linked lists
  • Performance considerations

Stacks

  • Stack (LIFO): push, pop, peek, size, numItems operations
  • Array implementation (directly and array of pointers to data)
  • Stack applications, including evaluation of infix, prefix, and postfix expressions

Queues

  • Queue (FIFO): enqueue, dequeue, peek, size, numItems operations
  • Array implementation (directly and array of pointers to data)
  • Linked list implementation
  • Circular queues
  • Performance considerations

Trees

  • Concepts and terminology: level, height, external and internal nodes, skinny, fat, complete, left-complete, perfect, multi-way, d-ary
  • Types of tree: binary, binary search, B-tree, 2-3 tree, AVL, Red-Black
  • Binary trees and binary search trees
  • Tree traversals: inorder, preorder, postorder
  • Fixed-length codes, variable length codes, optimal code trees, Huffman's algorithm and implementation
  • Height-balanced trees: AVL Trees, RR, RL, LR, LL rotations
  • Height-balanced trees: Red-Black Trees, single promotion, zig-zag promotion, recolouring and restructuring

Heaps

  • Heap basics
  • Types of heap: min heaps and max heap
  • Heap characteristics
  • Heap operations: delete max/min, down heap, up heap, merge, construct, heapify; complexity of operations
  • Priority queues
  • Operating systems heaps
  • Implementation of heap
  • Heap sort

Graphs

  • Types of graphs: directed, undirected, weighted, unweighted, cyclic, acyclic, directed acyclic, simple, non-simple, implicit, explicit, embedded, topological
  • Adjacency matrix representation,
  • Adjacency list representation
  • Topological sort
  • Euler's theorem
  • Graph traversal: breadth-first and depth-first, uses of
  • Depth-first search and maze traversal
  • Spanning trees and minimum spanning trees, Kruskal's algorithm, Prim's algorithm
  • Dijkstra's shortest path algorithm
  • Floyd-Warshall's all-pairs algorithm

Complex Networks

  • The importance of complex networks and network science
  • Euler's theorem: the Bridges of Königsberg
  • Networks vs. graphs
  • Degree, average degree, and degree distribution
  • Bipartite networks
  • Path length, BFS, Connectivity, Components
  • Clustering coefficient
  • Random graph model
  • Small world phenomena
  • Scale free networks
  • Communities
  • Fundamental Hypothesis
  • Connectedness and Density Hypothesis
  • Strong and weak communities
  • Graph partitioning
  • Community detection
  • Hierarchical clustering
  • Girvan-Newman Algorithm
  • Modularity
  • Random Hypothesis
  • Maximum Modularity Hypothesis
  • Greedy algorithm for community detection by maximizing modularity
  • Overlapping communities
  • Clique percolation algorithm and CFinder

Hashing

  • Using keys to address data
  • Mappings: injection, surjection, bijection
  • Map ADT
  • Hash functions
  • Hash tables: current value tables, direct access tables
  • Managing collisions: chaining, overflow areas, re-hashing, linear probing, quadratic probing
  • Example application: dictionaries

Algorithmic Strategies

  • Classes of algorithms
  • Brute force
  • Divide and conquer
  • Greedy algorithms
  • Dynamic programming
  • Combinatorial search and backtracking
  • Branch and bound

Analysis of Correctness

  • Types of software defects
  • Code module design
  • Syntactic, semantic, logical defects
  • (Semi-)formal verification: partial vs. total correctness
  • Invariant assertion method
  • Simple proof strategies: by contradiction, counterexample, induction
  • Dynamic testing: unit tests, test harness, stubs, drivers, integration testing, regression testing.
  • Static tests: reviews, walkthroughs, inspections, reviewing algorithms and software
  • Pair programming
  • Verification and validation strategies

Automata Theory

  • Regular Languages
  • Finite Automata
  • Nondeterminism
  • Regular Expressions
  • Nonregular Languages
  • Context-free Languages
  • Context-free Grammars
  • Pushdown Automata
  • Deterministic Context-Free Languages

Computability Theory

  • The Church-Turing Thesis
  • Turing Machines
  • Variants of Turing Machines
  • The Definition of Algorithm
  • Decidability
  • Decidable Languages
  • Undecidability
  • Reducibility

Lecture Schedule

Refer to the Lecture Schedule for information on course delivery, including lectures, labs, assignments, and exercises.

Faculty

David Vernon

Delivery

Face-to-face.

Student assessment

This course includes several hands-on programming and analysis assignments. Students will program mainly in C/C++. The programming assignments include individual assignments and a team capstone project in teams of 2-3 people. In addition to programming assignments, students will be assigned readings to support the lecture material.

Marks will be awarded as follows.

Seven individual assignments 70%. Final examination 30%.

Software tools

We will use Microsoft Visual C++ Express compiler, version 10.0 (also known as Visual C++ 2010) and CMake running on Windows 7 (64 bit).

Please follow the instructions provided in the Software Development Environment installation guide.

Course texts

David Harel and Yishai Feldman, Algorithmics: The Spirit of Computing, Third Edition.

Alfred V. Aho, Jeffrey D. Ullman, and John E. Hopcroft, Data Structures and Algorithms.

A selection of examples will be taken from Steven Skiena, "The Algorithm Design Manual", Second Edition.

A selection of papers and readings will be provided to complement these required textbooks.

Acknowledgments

This syllabus is based mainly on Course 04-630 Computer Science Principles for Practicing Engineers given by Mel Rosso-Llopart and Anthony J. Lattanze at Carnegie Mellon University, USA, Course CS-CO-412 Algorithms and Data Structures given by David Vernon at Innopolis University, Russia, and Course IT706A Scientific Theory in Informatics given by David Vernon and others at the University of Skövde, Sweden.