adding final draft for convolution chapter

Author: leios

SUMMARY.md

@@ -17,9 +17,6 @@
         * [Convolutions in 1D](contents/convolutions/1d/1d.md)
         * [Convolutions of images (2D)](contents/convolutions/2d/2d.md)
         * [Convolutional Theorem](contents/convolutions/convolutional_theorem/convolutional_theorem.md)
-* [Sorting and Searching](contents/sorting_and_searching/sorting_and_searching.md)
-    * [Bubble Sort](contents/bubble_sort/bubble_sort.md)
-    * [Bogo Sort](contents/bogo_sort/bogo_sort.md)
 * [Tree Traversal](contents/tree_traversal/tree_traversal.md)
 * [Euclidean Algorithm](contents/euclidean_algorithm/euclidean_algorithm.md)
 * [Monte Carlo](contents/monte_carlo_integration/monte_carlo_integration.md)

contents/convolutions/1d/1d.md

@@ -55,6 +55,10 @@ With this in mind, we can almost directly transcribe the discrete equation into
 [import:29-48, lang:"julia"](../code/julia/1d_convolution.jl)
 {% endmethod %}
 
+The easiest way to think about this is to read it as you might read a textbook.
+For each element in the output domain, we are summing a certain subsets of elements from `i-length(filter)` to `i` after multiplying it by the reversed filter (filter[i-j]`).
+In this way, it is precisely the same as the mathematical notation mentioned before.
+
 In contrast to the animation, where the filter continuously reappears on the left edge of the screen, the code we have written for this part of the chapter requires the user to specify what they expect the output array length to be.
 Determining what should happen at the edges of the convolution is a somewhat hotly debated topic and differs depending on what the user actually wants, so we will be discussing this in greater detail later in this chapter.
 
@@ -166,11 +170,13 @@ Your browser does not support the video tag.
 </div>
 
 Similar to the case without boundary conditions, this convolution needs to "ramp up," but not "ramp down."
-This is because the convolution output no longer extends past the bounds of the original signal.
+This is because the convolution output no longer extends past the bounds of the original signal so the bounded convolution is a subset of the full convolution.
 More than that, the convolution does not go all the way to 0 on the right side.
 This means that we are actually ignoring a rather important part of the convolution!
 
 This is 100% true; however, if the signal is large and the filter is small (as is the case with most of image processing), we do not really care that much about the bits of the convolution we missed.
+In addition, there is a way to center the convolution by modifying the location where the filter starts.
+For example, we could have half of the filter already existing and overlapping with the signal for the very first computed point of the convolution.
 For this reason, simple bounds are used frequently when performing convolutions on an image.
 
 In the previous code snippet, we were able to perform both a bounded and unbounded convolution.
@@ -196,7 +202,16 @@ On the other hand, the bounded call would set the output array size to simply be
 [import:65-66, lang:"julia"](../code/julia/1d_convolution.jl)
 {% endmethod %}
 
-As another note, the point we are computing for the convolution in the previous animation seems to be at the very front of the Gaussian to match the code; however, it is possible to compute the convolution at the center of the filter by giving the iterations through `j` an offset.
+Finally, as we mentioned before, it is possible to center bounded convolutions by changing the location where we calculate the each point along the filter.
+This can be done by modifying the following line:
+
+{% method %}
+{% sample lang="jl" %}
+[import:37-37, lang:"julia"](../code/julia/1d_convolution.jl)
+{% endmethod %}
+
+Here, `j` counts from `i-length(filter)` to `i`.
+To center the convolution, it would need to count from `i-(length(filter)/2)` to `i+(length(filter)/2)` instead.
 
 I think this is a good place to stop discussions on the simple boundary conditions.
 Now let us talk a bit more in detail about the case where we want to filter to continuously reappear every loop.
@@ -329,13 +344,23 @@ This will be discussed in further detail when we talk about the Schonhage-Strass
 ## Example Code
 
 For the full code, we have used the convolution to generate a few files for the full convolution, along with the periodic and simple boundary conditions discussed in this chapter.
-At a test case, we have chosen to use a random distribution for the input signal and a Gaussian filter.
 
 {% method %}
 {% sample lang="jl" %}
 [import, lang:"julia"](../code/julia/1d_convolution.jl)
 {% endmethod %}
 
+At a test case, we have chosen to use two sawtooth functions, which should produce the following images:
+
+| Description | Image |
+| ----------- | ----- |
+| Simple Boundaries | <img  class="center" src="../res/simple_linear.png" style="width:100%" /> |
+| Full | <img  class="center" src="../res/full_linear.png" style="width:100%" /> |
+| Cyclic | <img  class="center" src="../res/cyclic.png" style="width:100%" /> |
+
+As a sanity check, make sure that the bounded convolution is a subset of the full convolution.
+In this example, the bounded convolution is the start of the full convolution, but it is entirely possible it could be the middle or somewhere else entirely depending on how you counted within the inner, summation loop for the convolution.
+
 <script>
 MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
 </script>
@@ -357,6 +382,9 @@ The code examples are licensed under the MIT license (found in [LICENSE.md](http
 - The video "[Sawtooth Square Convolution](../res/1d_sawtooth.mp4)" was created by [James Schloss](https://github.com/leios) and is licensed under the [Creative Commons Attribution-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-sa/4.0/legalcode).
 - The video "[Full Random Convolution](../res/1d_rand_gaussian_full.mp4)" was created by [James Schloss](https://github.com/leios) and is licensed under the [Creative Commons Attribution-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-sa/4.0/legalcode).
 - The video "[Simple Random Convolution](../res/1d_rand_gaussian_simple.mp4)" was created by [James Schloss](https://github.com/leios) and is licensed under the [Creative Commons Attribution-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-sa/4.0/legalcode).
+- The image "[Simple Linear](../res/simple_linear.png)" was created by [James Schloss](https://github.com/leios) and is licensed under the [Creative Commons Attribution-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-sa/4.0/legalcode).
+- The image "[Full Linear](../res/full_linear.png)" was created by [James Schloss](https://github.com/leios) and is licensed under the [Creative Commons Attribution-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-sa/4.0/legalcode).
+- The image "[Cyclic](../res/cyclic.png)" was created by [James Schloss](https://github.com/leios) and is licensed under the [Creative Commons Attribution-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-sa/4.0/legalcode).
 
 
 ##### Text

contents/convolutions/2d/2d.md

@@ -144,8 +144,8 @@ We will definitely return to this topic in the future as new algorithms require
 
 ## Example Code
 
-For the full code in this section, we have modified the code from the [one-dimensional convolution chapter](../1d/1d.md) to add a two-dimensional variant for an image of random white noise.
-We have also added code to create the Gaussian kernel and Sobel operator.
+For the full code in this section, we have modified the visualizations from the [one-dimensional convolution chapter](../1d/1d.md) to add a two-dimensional variant for an image of random white noise.
+We have also added code to create the Gaussian kernel and Sobel operator and apply it to the circle, as shown in the text.
 
 {% method %}
 {% sample lang="jl" %}

contents/convolutions/code/julia/1d_convolution.jl

@@ -49,11 +49,9 @@ end
 
 function main()
 
-    # Random distribution in x
-    x = rand(100)
-
-    # Gaussian signals
-    y = [exp(-((i-50)/100)^2/.01) for i = 1:100]
+    # sawtooth functions for x and y
+    x = [float(i)/200 for i = 1:200]
+    y = [float(i)/200 for i = 1:200]
 
     # Normalization is not strictly necessary, but good practice
     normalize!(x)