COMP6771 - Advanced C++ Programming

Weekly Exercise - Week 2

**With my own solution (might be incorrect)**



## Q2.1. Definitive Declarations

Answer the following questions

1. Is the line marked (*) a declaration or a definition?
```cpp
int get_age(); // (*)

int main() {

}
```
- **a) Declaration**
- b) Definition
- c) Neither
- d) Both

2. Is the line marked (*) a declaration or a definiton?
```cpp
int get_age();

int age = get_age(); // (*)
```
- a) Declaration
- **b) Definition**
- c) Neither
- d) Both

3. Is the line marked (*) a declaration or a definition?
```cpp
int main() {
  auto age = 20; // (*)
}
```
- a) Declaration
- b) Definition
- c) Neither
- **d) Both**

4. Is the line marked (*) a declaration or a definition?
```cpp
int main() {
  auto age = 20;
  std::cout << age << std::endl; // (*)
}

```
- a) Declaration
- b) Definition
- **c) Neither**
- d) Both

5. Is the line marked (*) a declaration or a definition?
```cpp
int get_age();

int get_age() { // (*)
  return 6771;
}
```
- a) Declaration
- b) Definition
- c) Neither
- **d) Both**

## Q2.2. Resolution Overload

Answer the following questions

1. Consider the code below:
```cpp
/* 1 */ auto put(char) -> void;
/* 2 */ auto put(int) -> void;
/* 3 */ auto put(const char) -> void;
/* 4 */ auto put(char &) -> void;

put('a');
```
Which overload of `put` would be selected and why?
- **a) Overload 1: `put` was called with a `char` and overload 3 is just a redeclaration of overload 1.**
- b) Overload 2: `char` is implicitly promotable to `int` and so overload 2 is the best match.
- c) Overload 3: `put` was called with a temporary `const char`.
- d) Overload 4: `put` was called with a temporary `char` and temporaries preferentially bind to references.


2. Consider the code below:
```cpp
/* 1 */ auto put(char) -> void;
/* 2 */ auto put(char &) -> void;
/* 3 */ auto put(const char &) -> void;
char c = 'a';
put(c);
```
Which overload of `put` would be selected and why?
- a) Overload 1: `put` was called with a `char`.
- **b) Overload 2: `put` was called with a mutable `char` and and references have higher priority.**
- c) Overload 3: `put` was called with a const `char` and const references have higher priority.
- d) No overload: this call is ambiguous.


3. Consider the code below:
```cpp
/* 1 */ auto memcpy(char *dst, const char *src, int n = 0) -> void *;
/* 2 */ auto memcpy(const char *dst, char * const src) -> char *;

char *dst = /* appropriate initialisation... */;
const char *src = /* appropriate initialisation... */;

void *ptr = memcpy(dst, src);
```
Which overload of `memcpy` would be selected and why?
- a) Overload 1: both overloads are equally viable but the return type of overload 1 matches `ptr`'s type better
- b) Overload 2: has exactly two arguments and a non-bottom-level const pointer is always convertible to a bottom-level const pointer.
- **c) Overload 1: the first two arguments match perfectly and the default argument is used for the third.**
- d) Overload 2: the top-level const `src` argument has higher priority than the corresponding bottom-level const `src` in overload 1.


4. Consider the code below
```cpp
/* 1 */ auto min(int(&arr)[2]) -> int;
/* 2 */ auto min(int *arr) -> int;
/* 3 */ auto min(int(&arr)[]) -> int;

auto fn(int buf[3]) -> void {
    min(buf);
}
```
Which overload of `min` would be selected and why?
- a) Overload 1: though `min` was called with an array of length 3, 3 is close to 2, so this is the best match.
- **b) Overload 2: the `buf` argument decays to `int *` and so overload 2 is the best match.**
- c) Overload 3: neither `int(&)[2]` nor `int *` match `int(&)[3]` perfectly but a reference to an array of unknown length does, so this is the best match.
- d) No Overload: this call is ambigous.


5. Consider the code below:
```cpp
/* 1 */ auto sink(int i, ...);
/* 2 */ auto sink(int i, short s);
/* 3 */ auto sink(...);

auto L = std::numeric_limits<long>::max();
sink(1, L);
```
Which overload of `sink` would be selected and why?
- a) Overload 1: correct number of parameters and a variadic function is preferred over a narrowing conversion from `long` to `short`
- **b) Overload 2: correct number of parameters and variadic functions have the lowest priority in overload resolution, so this is the only viable candidate.**
- c) Overload 3: by definition, a single-parameter variadic function can be called with any number and type of arguments, so it is always the best match.
- d) No Overload: this call is ambigous.

## Q2.3. Programmable Errors

Answer the following questions

1. What kind of error is first displayed in the below code?
```cpp
// api.h
int rand();

// me.cpp
#include "api.h"
int rand() {
    return 42;
}

// you.cpp
int rand() {
    return 6771;
}

// client.cpp
#include "api.h"
int i = rand();
```
- a) Compile-time error: `you.cpp` did not include `api.h`
- b) Compile-time error: multiple definitions of `rand()`.
- **c) Link-time error: multiple definitions of `rand()`.**
- d) Logic Error: 6771 is not a random number!

2. What kind of error is first displayed in the below code?
```cpp
namespace constants {
  #define N 6771  
}

int N = constants::N;

int main() {
    int ints[N] = {1, 2, 3};
}
```
- a) Logic error: `constants` is a bad name for a namespace
- **b) Compile-time error: macros do not obey namespace rules and so `int N` is changed to `int 6771`.**
- c) run-time error: main does not return a value.
- d) Compile-time error: `N` is not const and so cannot be used in `ints[N]`.

3. What kind of error is displayed in the below code?
```cpp
#include <vector>

int main() {
    std::vector<int> v;
    unsigned i;
    while (i-- > 0) {
        v.push_back(i);
    }
}
```
- a) Link-time error: `i` is just a variable declaration and the real `i` hasn't been defined yet.
- **b) Logic error: `i` is uninitialised and so its use is illegal.**
- c) Logic error: `v` is not used after the for-loop.
- d) Run-time error: pushing back continuously to a vector can result in an "out of memory" error

4. What kind of error is displayed in the below code?
```cpp
int main() {
    int *ptr = new int{42};

    *ptr = 6771;

    return *ptr;
}
```
- a) Logic-error: you are only allowed to return numbers in the range [-128, 128] from `main()`.
- b) Runtime-error: `new` can fail allocation and throws an exception if that happens
- c) Compile-time error: `int{42}` is invalid syntax.
- **d) Logic-error: programmer did not check if `ptr` was `nullptr` or not before dereferencing.**

## 2.4. Type-Safe Scaling

C++ has a poignant emphasis on strong type-safety. To that end it offers a type-safe version of the C-style cast called `static_cast` which only allows conversion between compatible types e.g. `int` to `float`, `void *` to `int *` etc., and will not allow unrelated casts e.g. `void *` to `int`.

In this exercise we will use `static_cast` to safely scale a vector of integers by a `double` value and return a new vector of doubles.

In `src/2.4/scale.h` there is documentation for `scale()` which does this conversion.
Implement this function in `src/2.4/scale.cpp`.
You will also need to write at least **two** tests for it in `src/2.4/scale.test.cpp`.

To improve ease of use, also add a _default value_ of 0.5 for the scaling factor.
This will allow users to not have to pass a scale factor when commonly scaling a vector in half.

### Answer

```C++
// scale.h

auto scale(std::vector<int>& ivec, double factor=0.5) -> std::vector<double>;

// scale.cpp

auto scale(std::vector<int>& ivec, double factor) -> std::vector<double> {
	std::vector<double> dvec(ivec.size());
	for (size_t i = 0; i < ivec.size(); i++) {
		dvec[i] = ivec[i] * factor;
	}
	return dvec;
}
```

## 2.5. Finding a Mismatch

The **S**tandard **T**emplate **L**ibrary (aka the STL, now part of the C++ standard proper) has three fundamental concepts: containers, iterators, and algorithms. Iterators are the glue that sits between containers of data and the algorithms that operate on them. By using these three concepts together, code reuse is maximised and composition of existing code becomes very easy.

In this exercise you will be using `std::vector<int>::iterator` to implement a less general version of [std::mismatch](https://en.cppreference.com/w/cpp/algorithm/mismatch), one of the many algorithms provided by the standard library.

There is documentation for our version of `mismatch()` in `src/2.5/mismatch.cpp`. Complete this function and write at least **three** more tests to verify your code is correct. Two have already been provided for you.


### Answer

```C++
auto mismatch(std::vector<int>& v1, std::vector<int>& v2) -> std::pair<iter, iter> {
	auto v1_iter = v1.begin();
	auto v2_iter = v2.begin();
	while(v1_iter != v1.end() and v2_iter != v2.end()) {
		if (*v1_iter != *v2_iter) {
			return std::make_pair(v1_iter, v2_iter);
		}
		++v1_iter;
		++v2_iter;
	}
	return std::make_pair(v1_iter, v2_iter);
}
```

## 2.6. Is It a Perumutation?

The purpose of this exercise is to get experience using different parts of the C++ Standard Library's helpful types and data structures.
In src/permutation.h, there is documentation for a function that, given two strings, determines if one string is a permutation of the other. In this instance, a string s1 is a permuation of another string s2 if:
 * s1 and s2 contain the same number of letters
 * s2 contains all of the letters of s1, but not necessarily in the same order.
The empty string is a permutation of itself.

You need to implement this function in `src/2.6/permutation.cpp` and write at least two tests in `src/2.6/permutation.test.cpp`.

### Answer

```C++
auto is_permutation(const std::string& x, const std::string& y) -> bool
{
    if (x.empty() and y.empty()) {
	    return true;
    }
	if (x.size() != y.size()) {
		return false;
	}
	std::map<char, int> letter_map_x;
	std::map<char, int> letter_map_y;
	for (const auto& c : x) {
		++letter_map_x[c];
	}
	for (const auto& c : y) {
		++letter_map_y[c];
	}
	for (const auto& el : letter_map_x) {
		if (el.second != letter_map_y[el.first]) {
			return false;
		}
	}
	return true;
}
```

## 2.7. Sorting Sequences

The C++ Standard Library provides many [algorithms](https://en.cppreference.com/w/cpp/header/algorithm), one very widely-used one being [std::sort](https://en.cppreference.com/w/cpp/algorithm/sort). `std::sort` accepts two iterators denoting a range and performs an optimised sort on that range.

In this exercise, we shall explore what requirements `std::sort` expects this pair of iterators to satisfy and how the [sequence containers](https://en.cppreference.com/w/cpp/container) `std::vector`, `std::list`, and `std::array` satisfy these requirements.

In `src/2.7/assortment.cpp` there are 3 overloads for a function `sort()` which accepts a vector, array, and list of integers. There are also three test cases in `src/2.7/assortment.test.cpp` for sanity checking.
Try implementing each `sort()` function using `std::sort`.

You may notice that the program will not compile.

Consider these questions:
- Where in the code is the compilation error happening?
- **Why** is this compilation error happening? (hint: the compiler error may only be a symptom, not the cause!)
- How might one resolve this error? (Hint: `std::vector` is always handy...)

Modify your implementation such that now the tests pass.

### Answer

```C++
#include "assortment.h"
#include <algorithm>

auto sort(std::vector<int>& ivec) -> void
{
    std::sort(ivec.begin(), ivec.end());
}

auto sort(std::array<int, 4>& iarr) -> void
{
    std::sort(iarr.begin(), iarr.end());
}

auto sort(std::list<int>& ilist) -> void
{
    ilist.sort();
}
```

## 2.8. Mixing Paint

C++ builds upon many constructs found in C. For example:
- `std::function` (and more) over raw function pointers
- `enum class` over `enum`
- `std::optional` over "magic" invalid values such as `nullptr` for an absent `T*`

In this exercise we shall implement a paint-mixing algorithm to gain familiarity with these new constructs. Namely:
- Paints will be represented by an `enum class` called `paint`.
- `sizeof(<any paint>) == 1`.
- The paint colours should be:
    - red
    - green
    - blue
    - yellow
    - cyan
    - magenta
    - brown
- Instead of baking-in which mixing strategy to use, we shall encapsulate it with a `std::function`.
- If a combination of colours doesn't exist, we will denote its absence by a `std::optional`.

In `src/2.8/mixing_paint.h`, there is documentation for a function `mix` that accepts a mixing strategy and vector of paints and mixes them according to the given strategy.
Mixing follows the left-fold algorithm, for example, if we were summing integers...:
```cpp
auto add(int x, int y) -> int { return x + y; }

auto sum(const std::vector<int> nums, int init) -> int {
    for (auto i : nums) {
        init = add(init, i);
    }

    return init;
}
```
Here, the accumulator is on the left of the `add()` function and the next element in the list is on the right.

There is also documentation for a default mixing strategy `wacky_colour` which you will also need to implement.

Complete these functions in `src/2.8/mixer.cpp` and write at least **two tests** for `mixer` and **two tests** for `wacky_colour` in `src/2.8/mixer.test.cpp`.

### Answer

```C++
auto wacky_colour(paint p1, paint p2) -> std::optional<paint>
{
    if (p1 == red and p2 == green) {
	    return yellow;
    }
	if (p1 == red and p2 == blue) {
		return magenta;
	}
	if (p1 == green and p2 == blue) {
		return cyan;
	}
	if (p1 == yellow and p2 == magenta) {
		return brown;
	}
	if (p1 == cyan and p2 == magenta) {
		return brown;
	}
	if (p1 == brown and p2 == brown) {
		return brown;
	}
	return std::nullopt;
}

auto mix(const std::vector<paint>& paints, std::function<std::optional<paint>(paint, paint)> fn) -> std::optional<paint>
{
	std::optional<paint> result = paints[0];
	for (size_t i = 1; i < paints.size(); i++) {
		result = fn(result.value(), paints[i]);
		if (not result) {
			return std::nullopt;
		}
	}
	return result;
}
```

COMP6771 Exercise W2

COMP6771 - Advanced C++ Programming

Weekly Exercise - Week 1

**With my own solution (might be incorrect)**



## Q1.1. Introduction using a set diff

In `src/1.1/setdiff.h` there is a documentation for a function that removes elements in one vector from another. In the provided test stub in `src/1.1/setdiff.test.cpp`, write **three** or more _unit tests_ for this function. Considerations include:
- a test for invalid input
- a test for an _edge_ case
- a test for the average use case

When you are happy with the tests, implement the function in `src/setdiff.cpp` so that your tests pass.

### Answer

```C++
// src/setdiff.cpp

auto set_difference(std::vector<char>& vec_set, const std::vector<char>& blacklist) -> void
{
	auto is_blacklist = [&blacklist](const char& element) -> bool {
		return std::find(blacklist.begin(), blacklist.end(), element) != blacklist.end();
	};
	auto new_end = std::remove_if(vec_set.begin(), vec_set.end(), is_blacklist);
	vec_set.erase(new_end, vec_set.end());
}
```

## Q1.2. Using and Testing `std::vector`

One of the most widely used containers from the C++ Standard Library is `std::vector`. A vector is a dynamic array that looks after its own memory and allows elements to be inserted, retrieved, compared for equality, etc.

Alot can be done with a vector and the purpose of this exercise is to gain familiarity with its various operations (called _member functions_ or _methods_).

In `src/1.2/fib_vector.cpp`, there is an incomplete implementation of a function that calculates all of the [Fibonacci numbers](https://en.wikipedia.org/wiki/Fibonacci_number) and returns them in a `std::vector<int>` as well as a few failing tests. Write a proper implementation of `fibonacci()` and more tests so that you more become familiar and confident with using a vector (and also with testing!).

Hint: some of the most widely used methods on vectors are:
- `push_back(elem)`: adds an elements to the vector at the end
- `size()`: returns how many elements are currently in the vector
- `empty()`: returns true if and only if `size() == 0` (**N.B.** this does not `clear()` the vector!)
- `at(n)`: get the nth element from the vector. Can also use `[]`.

A full description of these methods can be found [here](https://en.cppreference.com/w/cpp/container/vector).

### Answer

```C++
auto fibonacci(int n) -> std::vector<int>
{
	if (n == 0) {
		return {};
	}
	std::vector<int> nums(static_cast<size_t>(n), 1);
	if (n == 1) {
		return nums;
	}
	for (size_t i = 2; i < nums.size(); i++) {
		nums[i] = nums[i - 1] + nums[i - 2];
	}
	return nums;
}
```






## Q1.3. Evolution: C to C++

Write a C++ program in `src/1.3/cat.cpp` that mimics the C program written below.
The program is intended to mimic the behaviour of the UNIX command `cat`.
For each C++ change, think about what advantages C++ provides.

Make sure you check with your tutor that your C++ code is styled according to modern guidelines.

```c
#include <stdio.h>

int main() {
  char buffer[100];
  fgets(buffer, 100, stdin);
  printf("%s", buffer);
  return 0;
}
```

### Answer

```C++
#include <iostream>
#include <string>

int main() {
	std::string buffer;
	std::getline(std::cin, buffer);
	std::cout << buffer << std::endl;
	return 0;
}
```

## Q1.4. Gotta Sort It Out

Write a function, called `sort3` in `src/1.4/sort3.cpp`, which takes three `int` references and sorts them in ascending order.

Then, write **two** test cases in `src/1.4/sort3.test.cpp` to confirm that `sort3` is correct.

You should then write an overload for `sort3` so that it also sorts three `std::string` references. Don't forget to write at least **two** more test cases!

### Answer

```C++
#include <vector>
#include <algorithm>

auto sort3(int& a, int& b, int& c) -> void
{
    std::vector<int> nums = {a, b, c};
	std::sort(nums.begin(), nums.end());
	a = nums[0];
	b = nums[1];
	c = nums[2];
}

auto sort3(std::string& a, std::string& b, std::string& c) -> void
{
	std::vector<std::string> nums = {a, b, c};
	std::sort(nums.begin(), nums.end());
	a = nums[0];
	b = nums[1];
	c = nums[2];
}
```

## Q1.5. Catch2 Syntax

Answer the following questions:

1. What is a `TEST_CASE`?
- a) A `TEST_CASE` is a uniquely-named testing scope that must contain every test we write about our program.
- b) A `TEST_CASE` is a fancy macro that has no effect in "real" code.
- **c) A `TEST_CASE` is a uniquely-named testing scope that will keep track of all the `CHECK`s and `REQUIRE`s that pass or fail.**
- d) A `TEST_CASE` is a macro where only compile-time evaluable assertions about our code can be written.


2. What is a `CHECK`? In what way, if any, is it different to `assert()`?
- a) `CHECK` and `assert` are both macros and do the exact same thing.
- b) **`CHECK` and `assert` are both macros, but a `CHECK` will evaluate an expression and report it if it's false whereas `assert` will crash the program.**
- c) `CHECK` is a function that suggests a fact about our code should be true, but `assert` enforces it.
- d) `CHECK` records the failure of an assertion but does nothing about it and is entirely unrelated to `assert`.

3. What is a `REQUIRE`? In what way, if any, is it different to `assert()`?
- a) `REQUIRE` evaluates an expression and crashes the program if it is false but `assert` will report it to the user.
- b) `REQUIRE` and `assert` both evaluate expressions and terminate the currently executing test if false.
- c) `assert` and `REQUIRE` both evaluate expressions, but only `assert` has an effect if the expression is false.
- d) **`REQUIRE` evalutes an expression and if false will terminate the currently executing test and move onto the next one. It is entirely unrelated to `assert`.**

4. What are `SECTION` blocks in Catch2?
- **a) `SECTION` blocks are ways to divide testing logic in `TEST_CASE`s. Any state changes in a `SECTION` are not reflected in `SECTION`s at the same level.**
- b) `SECTION` blocks are a way to break up long tests and have little use other than that.
- c) `SECTION`s are unique testing scopes that can only contain `TEST_CASE`s.
- d) `SECTION`s are part of Behaviour Driven Development and group together `SCENARIO`s.

5. What goes between the parentheses in `TEST_CASE`s and `SECTION`s?
- a) The function or class name that is currently being tested.
- **b) A succinct and insightful description in plain language of the code under test.**
- c) A description that matches a similarly-worded comment directly above the `TEST_CASE`/`SECTION`.
- d) A note for future readers of your code about what you were thinking at the time of writing this test.

## Q1.6. Constant Referencing

Answer the following questions:

1. Are there any errors in this code and if so what are they?
```cpp
auto i = 3;
i = 4;
```
- a) Yes: `auto` is a reserved keyword
- b) Yes: it is illegal to initialise a variable after it is defined.
- c) Maybe: it depends on what CPU this code is run on.
- d) **No: assignment after initialisation is legal, even in C.**

2. Are there any errors in this code and if so what are they?
```cpp
const auto j = 5;
--j;
```
- **a) Yes: `j` is a constant integer which cannot be modified.**
- b) Maybe: it depends if the programmer prefers east or west const.
- c) No: decrementing a constant integer creates a new one.
- d) Yes: `auto` and `const` should not be mixed.

3. Are there any errors in this code and if so what are they?
```cpp
auto age = 18;
auto& my_age = age;
++my_age;
```
- a) Maybe: it depends if the code is compiled as C++98 or C++11 or higher.
- **b) No: my_age is a reference to age, so preincrement is perfectly legal.**
- c) Yes: references are inherently const and so modifying `age` through `my_age` is illegal.
- d) No: `my_age` is a copy of `age` and modifying `my_age` has no impact on `age` whatsoever.

4. Are there any errors in this code and if so what are they?
```cpp
auto age = 21;
const auto &my_age = age;
--my_age;
```
- a) Yes: `auto` references can only be used with explicit type annotations.
- b) Maybe: if this code is compiled with the "-pedantic" flag in GCC, it would be perfectly legal.
- c) No: my_age is a const reference, but `age` is not constant, so this is fine.
- **d) Yes: `my_age` is a reference to a constant integer, which cannot be modified.**

COMP6771 Exercise W1

对PPT的简单总结省流版本，不代表全部内容。



# 运动估计

**Change Detection**:
- **方法**：使用图像减法（image subtraction）来检测场景中的变化。
- **应用**：广泛用于监控系统、交通监控等领域，通过比较时间序列图像来发现新的或消失的物体。

**Sparse Motion Estimation**:
- **方法**：使用模板匹配（template matching）来估计局部位移。
- **应用**：用于跟踪特定点或特征的运动，例如光流的计算、物体的跟踪等。模板匹配通过比较图像中的局部区域来找到最佳匹配位置。

**Dense Motion Estimation**:
- **方法**：使用光流（optical flow）来计算密集的运动向量场。
- **应用**：广泛用于视频压缩、运动分析、3D重建等领域。光流算法能够在整个图像范围内计算每个像素的运动，从而提供详细的运动信息。

## Change Detection

**检测移动物体**:
- **场景**: 在一个恒定背景中检测移动物体。
- **边缘移动**: 物体的前后边缘每帧仅移动几个像素。
  
**方法**:
- **图像减法**: 通过将当前帧 与上一帧相减，检测边缘变化。
- **结果**: 减法后的图像中，显著不同于零的像素就是物体的边缘。

这种方法在监控系统和交通监控中应用广泛，可以有效检测场景中出现的新物体或消失的物体。

## Sparse Motion Estimation

**稀疏运动估计**:

- **定义**: 通过识别在时间 $ t $ 和 $ t+\Delta t $ 拍摄的两幅图像中相对应的点对，计算稀疏运动场。
- **假设**: 兴趣点及其邻域的强度在时间上保持几乎不变。

**步骤**:
1. **检测兴趣点**: 在时间 $ t $ 检测图像中的兴趣点。
2. **搜索对应点**: 在时间 $ t+\Delta t $ 搜索这些兴趣点的对应点。

### 运动向量 Motion Vector

- **运动场**: 是二维数组的二维向量，表示3D场景点的运动。
- **图像中的运动向量**: 代表移动的3D点的图像位移。
  - **尾部**: 在时间 $ t $。
  - **头部**: 在时间 $ t+\Delta t $。
  - **瞬时速度估计**: 在时间 $ t $。

### 检测兴趣点 Detect Interesting Points

- **图像滤波器**:
  - Canny边缘检测器
  - Hessian脊检测器
  - Harris角点检测器
  - 尺度不变特征变换（SIFT）
  - 全卷积神经网络（FCN）

- **兴趣算子**:
  - 计算垂直、水平和对角方向的强度方差
  - 如果这些四个方差中的最小值超过阈值，则为兴趣点

## Dense Motion Estimation

**密集运动估计**:

- **假设**:
  - 在考虑的时间间隔内，物体的反射率和照明不变
  - 物体到相机和光源的距离在此时间间隔内没有显著变化
  - 时间 $t$ 时的小邻域 $ N_t(x,y) $ 在时间 $ t+\Delta t $ 时观测到的为某个偏移位置 $ N_{t+\Delta t}(x+\Delta x, y+\Delta y) $

- 这些假设在现实中可能并不完全成立，但提供了有用的计算和近似

密集运动估计主要用于计算整个图像的运动场，是光流计算的基础。尽管假设条件可能不完全准确，但它们仍然是估计运动的实用近似。

### Optical Flow Computation

**光流计算**:

- **光流方程**提供了一个可以应用于每个像素位置的约束
- 然而，这个方程没有唯一解，因此需要进一步的约束

例如，通过对一组相邻像素使用光流方程，并假设它们都有相同的速度，光流计算任务相当于使用最小二乘法解决一个线性方程组。

# 运动追踪 Motion Tracking

**跟踪方法**:

- **贝叶斯推理 Bayesian inference**:
  - 使用**概率模型**进行跟踪
- **卡尔曼滤波 Kalman filtering**:
  - 使用**线性模型假设**进行跟踪
- **粒子滤波 Particle filtering**:
  - 使用**非线性模型**进行跟踪


**主要步骤**:

- **预测** (Prediction):
   - 使用从时间 $i-1$ 之前的测量值 $(y_0, y_1, ..., y_{i-1})$来预测时间 $i$ 的状态。
   - 公式表示：$P(X_i | Y_0 = y_0, Y_1 = y_1, ..., Y_{i-1} = y_{i-1}) $

-  **关联** (Association):
   - 在时间 $i$ 选择与目标状态相关的测量值。

- **校正** (Correction):
   - 使用新的测量值 $y_i$ 来更新状态预测。
   - 公式表示：$ P(X_i | Y_0 = y_0, Y_1 = y_1, ..., Y_{i-1} = y_{i-1}, Y_i = y_i) $

## 贝叶斯推理 Bayesian inference