Differences

This shows you the differences between two versions of the page.

--- camera_design [2020/08/29 17:20]
paul [Camera Design]
+++ camera_design [2020/08/31 03:24] (current)
paul [Observer Pattern]
@@ Line 1: / Line 1: @@
 ====== Camera Design ======
+===== Android Binder =====
+Android uses an IPC framework called Binder that allows for inter process communication. Everyone in Android is connected together in Binder.
+===== Intents =====
+Android allows for processes to communicate with each other using Intents. You can send intents to other processes and then handle their callbacks.
+{{:pasted:20200830-211833.png?500}}
+==== Binder Structure ====
+{{:pasted:20200830-213136.png?500}}
+Binder allows us to communicate to other process through a managed way. It's pretty much roscore in ROS.
+Theres a bunch of different stuff that will happen to get messages from senders to receivers. No need to worry about it but here is how it looks.
+{{:pasted:20200830-224627.png?500}}
+Here is an interesting example of how this plays out when an app requests a location service.
+{{:pasted:20200830-224905.png?500}}
+===== OOP =====
+Compositions: models s relationship. Owner is responsible for the creation and destruction of this data.
+Aggregation: models "has a" relationship. This data can be a member elsewhere. The class including this data is not responsible for its creation/deletion.
+Association: models a bi-directional association relationship. For example a patient has a doctor, and a doctor has a patient. They both know about each other.
+Reflexive association: models relationship of objects of the same type. For instance, a course may have prerequisites, which are themselves courses.
+<code>
+| Property                                 | Composition    | Aggregation    | Association                     |
+|------------------------------------------+----------------+----------------+---------------------------------|
+| Relationship type                        | Whole/part     | Whole/part     | Otherwise unrelated             |
+| Members can belong to multiple classes   | No             | Yes            | Yes                             |
+| Members existence managed by class       | Yes            | No             | No                              |
+| Directionality                           | Unidirectional | Unidirectional | Unidirectional or bidirectional |
+| Relationship verb                        | Part-of        | Has-a          | Uses-a                          |
+</code>
+Abstract Class: Abstract classes contain pure virtual functions are cannot be
+instantiated. They can however contain constructors, and other code that gets
+inherited by derived classes.
+Virtual Functions: in C++ a function marked virtual derives to the lowest
+derived function of that class. If you have a pointer of base class type, but it
+is a pointer to a derived class, the function will resolve to derived class.
+Pure Virtual Function: A function marked with ''= 0'' that has to be
+implemented by a derived class. Having a pure virtual function in a class makes
+the class abstract.
+<code cpp>
+class A{
+private:
+  int m_id;
+public:
+  A(int id) : m_id{id}
+  {
+  }
+  virtual void printId() = 0; // this make the function pure virtual, and the
+};
+</code>
+Interfaces are pure virtual functions that have no member variables and contain
+all pure virtual functions.
+<code cpp>
+class ICameraDriver {
+public:
+  virtual capture() = 0;
+  virtual stream() = 0;
+  virtual ~ICameraDriver() {}
+};
+</code>
+===== OOP Patterns =====
+The following are different design patterns that can be implemented.
+==== Strategy Pattern ====
+I've used this pattern a lot. It's when you define a set of functionality and encapsulate them and then make it interchangeable.
+{{:pasted:20200830-201230.png?500}}
+Here is some implemented C++ code. To see some code, check out ex4 of oop1 in
+learn. Use the strategy pattern when you need to use one of several behaviors
+dynamically.
+==== Observer Pattern ====
+This very similar to the publisher subscriber model. An Observer
+{{:pasted:20200830-233332.png?500}}
 ===== Video Compression ====
  A 1920 x 1080 video at 30 fps with RGB8 (24 bits total) comes out to 1.5Gbits/s.
-{{:pasted:20200829-172051.png}}
+{{:pasted:20200829-172051.png?500}}
+Encoding and decoding.
+{{:pasted:20200829-172157.png?500}}
 ===== Camera Pipeline =====
 ==== White Balance ====
@@ Line 42: / Line 145: @@
 {{:pasted:20200829-170417.png?500}}
+Back Side Illumination
+{{:pasted:20200829-174125.png?500}}
 Final Pipeline example.