Marcus Sanatan

Phaser 3 and Tiled: Building a Platformer

Dhananjay Singh

Spring Cloud Stream with RabbitMQ: Message-Driven Microservices

<h2 id="introduction">Introduction</h2>
Machine Learning is gaining popularity and usage over the globe. It has already drastically changed the way certain applications are built and will likely continue to be a huge (and increasing) part of our daily lives.
There's no sugarcoating it, Machine Learning isn't simple. It's pretty daunting and can seem very complex to many.
Companies such as Google took it upon themselves to bring Machine Learning concepts closer to developers and allow them to gradually, with major help, make their first steps.
Thus, frameworks such as <a rel="nofollow" target="_blank" href="https://www.tensorflow.org/">TensorFlow</a> were born.
<h2 id="whatistensorflow">What is TensorFlow?</h2>
TensorFlow is an open-source Machine Learning framework developed by Google in Python and C++.
It helps developers easily acquire data, prepare and train models, predict future states, and perform large-scale machine learning.
With it, we can train and run deep neural networks which are most often used for <a target="_blank" href="/pytesseract-simple-python-optical-character-recognition/">Optical Character Recognition</a>, <a target="_blank" href="/image-recognition-in-python-with-tensorflow-and-keras/">Image Recognition/Classification, <a target="_blank" href="/what-is-natural-language-processing/">Natural Language Processing</a>, etc.
<h2 id="tensorsandoperations">Tensors and Operations</h2>
TensorFlow is based on computational graphs, which you can imagine as a classic graph with nodes and edges.
Each node is referred to as an operation, and they take zero or more tensors in and produce zero or more tensors out. An operation can be very simple, such as basic addition, but they can also be very complex.
Tensors are depicted as edges of the graph, and are the core data unit. We perform different functions on these tensors as we feed them to operations. They can have a single or multiple dimensions, which are sometimes referred to as their <a rel="nofollow" target="_blank" href="http://mathworld.wolfram.com/TensorRank.html">ranks</a> - (Scalar: rank 0, Vector: rank 1, Matrix: rank 2)
This data flows through the computational graph through tensors, impacted by operations - hence the name TensorFlow.
Tensors can store data in any number of dimensions, and there are three main types of tensors: placeholders, variables, and constants.
<h2 id="installingtensorflow">Installing TensorFlow</h2>
Using <a target="_blank" href="/what-is-maven/">Maven</a>, installing TensorFlow is as easy as including the dependency:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.tensorflow&lt;/groupId&gt;
 &lt;artifactId&gt;tensorflow&lt;/artifactId&gt;
 &lt;version&gt;1.13.1&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
If your device supports <a rel="nofollow" target="_blank" href="https://www.tensorflow.org/install/gpu">GPU support</a>, then use these dependencies:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.tensorflow&lt;/groupId&gt;
 &lt;artifactId&gt;libtensorflow&lt;/artifactId&gt;
 &lt;version&gt;1.13.1&lt;/version&gt;
&lt;/dependency&gt;

&lt;dependency&gt;
 &lt;groupId&gt;org.tensorflow&lt;/groupId&gt;
 &lt;artifactId&gt;libtensorflow_jni_gpu&lt;/artifactId&gt;
 &lt;version&gt;1.13.1&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
You can check the version of TensorFlow currently installed by using the <code>TensorFlow</code> object:
<pre><code class="hljs">System.out.println(TensorFlow.version());
</code></pre>
<h2 id="tensorflowjavaapi">TensorFlow Java API</h2>
The Java API TensorFlow offers is contained within the <code>org.tensorflow</code> package. It's currently experimental so it's not guaranteed to be stable.
Please note that the only fully supported language for TensorFlow is Python and that the Java API isn't nearly as functional.
It introduces us to new classes, an interface, enum, and exception.
<h3 id="classes">Classes</h3>
The new classes introduced through the API are:
<ul>
<li><code>Graph</code>: A data flow graph representing a TensorFlow computation</li>
<li><code>Operation</code>: A Graph node that performs computation on Tensors</li>
<li><code>OperationBuilder</code>: A builder class for Operations</li>
<li><code>Output&lt;T&gt;</code>: A symbolic handle to a tensor produced by an Operation</li>
<li><code>SavedModelBundle</code>: Represents a model loaded from storage.</li>
<li><code>SavedModelBundle.Loader</code>: Provides options for loading a SavedModel</li>
<li><code>Server</code>: An in-process TensorFlow server, for use in distributed training</li>
<li><code>Session</code>: Driver for Graph execution</li>
<li><code>Session.Run</code>: Output tensors and metadata obtained when executing a session</li>
<li><code>Session.Runner</code>: Run Operations and evaluate Tensors</li>
<li><code>Shape</code>: The possibly partially known shape of a tensor produced by an operation</li>
<li><code>Tensor&lt;T&gt;</code>: A statically typed multi-dimensional array whose elements are of a type described by T</li>
<li><code>TensorFlow</code>: Static utility methods describing the TensorFlow runtime</li>
<li><code>Tensors</code>: Type-safe factory methods for creating Tensor objects</li>
</ul>
<h3 id="enum">Enum</h3>
<ul>
<li><code>DataType</code>: Represents the type of elements in a Tensor as an enum</li>
</ul>
<h3 id="interface">Interface</h3>
<ul>
<li><code>Operand&lt;T&gt;</code>: Interface implemented by operands of a TensorFlow operation</li>
</ul>
<h3 id="exception">Exception</h3>
<ul>
<li><code>TensorFlowException</code>: Unchecked exception thrown when executing TensorFlow Graphs</li>
</ul>
If we compare all of this to the <a rel="nofollow" target="_blank" href="https://www.tensorflow.org/api_docs/python/tf">tf module in Python</a>, there's an obvious difference. The Java API doesn't have nearly the same amount of functionality, at least for now.
<h2 id="graphs">Graphs</h2>
As mentioned before, TensorFlow is based on computational graphs - where <code>org.tensorflow.Graph</code> is Java's implementation.
Note: Its instances are thread-safe, though we need to explicitly release resources used by the Graph after we're finished with it.
Let's start off with an empty graph:
<pre><code class="hljs">Graph graph = new Graph();
</code></pre>
This graph doesn't mean much, it's empty. To do anything with it, we first need to load it up with <code>Operation</code>s.
To load it up with operations, we use the <code>opBuilder()</code> method, which returns an <code>OperationBuilder</code> object that'll add the operations to our graph once we call the <code>.build()</code> method.
<h3 id="constants">Constants</h3>
Let's add a constant to our graph:
<pre><code class="hljs">Operation x = graph.opBuilder(&quot;Const&quot;, &quot;x&quot;)
 .setAttr(&quot;dtype&quot;, DataType.FLOAT)
 .setAttr(&quot;value&quot;, Tensor.create(3.0f))
 .build(); 
</code></pre>
<h3 id="placeholders">Placeholders</h3>
Placeholders are a &quot;type&quot; of variable that don't have a value at declaration. Their values will be assigned at a later date. This allows us to build graphs with operations without any actual data:
<pre><code class="hljs">Operation y = graph.opBuilder(&quot;Placeholder&quot;, &quot;y&quot;)
 .setAttr(&quot;dtype&quot;, DataType.FLOAT)
 .build();
</code></pre>
<h3 id="functions">Functions</h3>
And now finally, to round this up, we need to add certain functions. These could be as simple as multiplication, division, or addition, or as complex as matrix multiplications. The same as before, we define functions using the <code>.opBuilder()</code> method:
<pre><code class="hljs">Operation xy = graph.opBuilder(&quot;Mul&quot;, &quot;xy&quot;)
 .addInput(x.output(0))
 .addInput(y.output(0))
 .build(); 
</code></pre>
Note: We're using <code>output(0)</code> as a tensor can have more than one output.
<h3 id="graphvisualisation">Graph Visualisation</h3>
Sadly, the Java API doesn't yet include any tools that allow you to visualize graphs as you would in Python. When the Java API gets updated, so will this article.
<h2 id="sessions">Sessions</h2>
As mentioned before, a <code>Session</code> is the driver for a <code>Graph</code>'s execution. It encapsulates the environment in which <code>Operation</code>s and <code>Graph</code>s are executed to compute <code>Tensor</code>s.
What this means is that the tensors in our graph that we constructed don't actually hold any value, as we didn't run the graph within a session.
Let's first add the graph to a session:
<pre><code class="hljs">Session session = new Session(graph);
</code></pre>
Our computation simply multiples the <code>x</code> and <code>y</code> value. In order to run our graph and compute it, we <code>fetch()</code> the <code>xy</code> operation and feed it the <code>x</code> and <code>y</code> values:
<pre><code class="hljs">Tensor tensor = session.runner().fetch(&quot;xy&quot;).feed(&quot;x&quot;, Tensor.create(5.0f)).feed(&quot;y&quot;, Tensor.create(2.0f)).run().get(0);
System.out.println(tensor.floatValue());
</code></pre>
Running this piece of code will yield:
<pre><code class="hljs">10.0f
</code></pre>
<h2 id="savingmodelsinpythonandloadinginjava">Saving Models in Python and Loading in Java</h2>
This may sound a bit odd, but since Python is the only well-supported language, the Java API still doesn't have the functionality to save models.
This means that the Java API is meant only for the serving use-case, at least until it's fully supported by TensorFlow. At least, we can train and save models in Python and then load them in Java to serve them, using the <code>SavedModelBundle</code> class:
<pre><code class="hljs">SavedModelBundle model = SavedModelBundle.load(&quot;./model&quot;, &quot;serve&quot;); 
Tensor tensor = model.session().runner().fetch(&quot;xy&quot;).feed(&quot;x&quot;, Tensor.create(5.0f)).feed(&quot;y&quot;, Tensor.create(2.0f)).run().get(0); 

System.out.println(tensor.floatValue());
</code></pre>

<h2 id="conclusion">Conclusion</h2>
TensorFlow is a powerful, robust and widely-used framework. It's constantly being improved and lately introduced to new languages - including Java and JavaScript.
Although the Java API doesn't yet have nearly as much functionality as TensorFlow for Python, it can still serve as a good intro to TensorFlow for Java developers.

David Landup

How to Use TensorFlow with Java

When you want Git to track a file in a repository, you must explicitly add it to the repo, which can become a bit cumbersome if you have many files. Another option would be to add/stage all files to the repo, which is much quicker. In general it is best to manually add each to avoid staging files that you don't want, but if you know what you're doing this can save some time.
Like everything in Git, there are a few ways to do this. The behavior and options available also changes depending on the version of Git you're using, so for this article we'll be focusing on Git 2.x, which should be installed on most machines.
<h2 id="stageallfiles">Stage all Files</h2>
Using this command will stage all files in your repository, which includes all new, modified, and deleted files. The command is as follows:
<pre><code class="hljs">$ git add -A
</code></pre>
The <code>-A</code> option is shorthand for <code>--all</code>.
Another way to do this would be to omit the <code>-A</code> option and just specify a period to indicate all files in the current working directory:
<pre><code class="hljs">$ git add .
</code></pre>
Note: The command <code>git add .</code> only stages files in the current directory and not any subdirectories, whereas <code>git add -A</code> will stage files in subdirectories as well.
<h2 id="stageallnewandmodifiedfiles">Stage all New and Modified Files</h2>
The previous commands will also remove a file from your repository if it no longer exists in the project. If that is an undesired behavior in your case then you should use the <code>--ignore-removal</code> option, which will only stage new and modified files:
<pre><code class="hljs">$ git add --ignore-removal .
</code></pre>
<h2 id="stageallmodifiedanddeletedfiles">Stage all Modified and Deleted Files</h2>
Another variation of this command would be to only stage modified and deleted files, but not any new files. For many existing projects this is actually a safer command than the others since it only affects files already tracked by the repo, and it won't add any others unless you specifically tell it to.
This behavior is achieved via the <code>-u</code> flag, which is shorthand for the <code>--update</code> option:
<pre><code class="hljs">$ git add -u
</code></pre>
<h2 id="addingfilesbywildcard">Adding Files by Wildcard</h2>
Although this technically isn't adding all files, it's another way to add a batch of files. Git allows you to add multiple files at once by using wildcard patterns.
So, for example, if you wanted to add all Python files in your current directory to your repo you'd want to use a command like this:
<pre><code class="hljs">$ git add *.py
</code></pre>
Although, most projects have subdirectories, in which case you'd have to run this command on each one to add all of your Python files. But there is a faster way. Instead you could use the <code>**</code> syntax, which matches all subdirectories.
So, for another example, this command would add all JavaScript files, including those in subdirectories:
<pre><code class="hljs">$ git add **/*.js
</code></pre>

Scott Robinson

Git: Add All Files to a Repo

<h2 id="introduction">Introduction</h2>
This is the second article in the series of articles on Concurrency in Java. In the <a target="_blank" href="/concurrency-in-java-the-executor-framework/">previous article</a>, we learnt about the <code>Executor</code> pool and various categories of <code>Executors</code> in Java.
In this article, we will learn what the <code>synchronized</code> keyword is and how we can use that in a multi-threading environment.
<h2 id="whatissynchronization">What is Synchronization?</h2>
In a multi-threaded environment, it is possible that more than one thread may try to access the same resource. For example, two threads trying to write in to the same text file. In the absence of any synchronization between them, it is possible that the data written to the file will be corrupt when two or more threads have write access to the same file.
Also, in the JVM, each thread stores a local copy of variables on its stack. The actual value of these variables may be changed by some other thread. But that value may not be refreshed in another thread's local copy. This may cause incorrect execution of programs and non-deterministic behavior.
To avoid such issues, Java provides us with the <code>synchronized</code> keyword, which acts like a lock to a particular resource. This helps achieve communication between threads such that only one thread accesses the synchronized resource and other threads wait for the resource to become free.
The <code>synchronized</code> keyword can be used in a few different ways, like a synchronized block:
<pre><code class="hljs">synchronized (someObject) {
 // Thread-safe code here
}
</code></pre>
It can also be used with a method like this:
<pre><code class="hljs">public synchronized void somemMethod() {
 // Thread-safe code here
}
</code></pre>
<h2 id="howsynchronizationworksinthejvm">How Synchronization Works in the JVM</h2>
When a thread tries to enter the synchronized block or method, it has to acquire a <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Lock_(computer_science)">lock</a> on the object being synchronized. One and only one thread can acquire that lock at a time and execute code in that block.
If another thread tries to access a synchronized block before the current thread completes its execution of the block, it has to wait. When the current thread exits the block, the lock is automatically released and any waiting thread can acquire that lock and enter the synchronized block:
<ul>
<li>For a <code>synchronized</code> block, the lock is acquired on the object specified in the parentheses after the <code>synchronized</code> keyword</li>
<li>For a <code>synchronized static</code> method, the lock is acquired on the <code>.class</code> object</li>
<li>For a <code>synchronized</code> instance method, the lock is acquired on the current instance of that class i.e. <code>this</code> instance</li>
</ul>
<h2 id="synchronizedmethods">Synchronized Methods</h2>
Defining <code>synchronized</code> methods is as easy as simply including the keyword before the return type. Let's define a method that prints out the numbers between 1 and 5 in a sequential manner.
Two threads will try to access this method, so let's first see how this'll end up without synchronizing them, and then we'll lock the shared object and see what happens:
<pre><code class="hljs">public class NonSynchronizedMethod {

 public void printNumbers() {
 System.out.println(&quot;Starting to print Numbers for &quot; + Thread.currentThread().getName());

 for (int i = 0; i &lt; 5; i++) {
 System.out.println(Thread.currentThread().getName() + &quot; &quot; + i);
 }

 System.out.println(&quot;Completed printing Numbers for &quot; + Thread.currentThread().getName());
 }
}
</code></pre>
Now, let's implement two custom threads that access this object and wish to run the <code>printNumbers()</code> method:
<pre><code class="hljs">class ThreadOne extends Thread {

 NonSynchronizedMethod nonSynchronizedMethod;

 public ThreadOne(NonSynchronizedMethod nonSynchronizedMethod) {
 this.nonSynchronizedMethod = nonSynchronizedMethod;
 }

 @Override
 public void run() {
 nonSynchronizedMethod.printNumbers();
 }
}

class ThreadTwo extends Thread {

 NonSynchronizedMethod nonSynchronizedMethod;

 public ThreadTwo(NonSynchronizedMethod nonSynchronizedMethod) {
 this.nonSynchronizedMethod = nonSynchronizedMethod;
 }

 @Override
 public void run() {
 nonSynchronizedMethod.printNumbers();
 }
}
</code></pre>
These threads share a common object <code>NonSynchronizedMethod</code> and they will simultaneously try to call the non-synchronized method <code>printNumbers()</code> on this object.
To test this behavior, let's write a main class:
<pre><code class="hljs">public class TestSynchronization {
 public static void main(String[] args) {

 NonSynchronizedMethod nonSynchronizedMethod = new NonSynchronizedMethod();

 ThreadOne threadOne = new ThreadOne(nonSynchronizedMethod);
 threadOne.setName(&quot;ThreadOne&quot;);

 ThreadTwo threadTwo = new ThreadTwo(nonSynchronizedMethod);
 threadTwo.setName(&quot;ThreadTwo&quot;);

 threadOne.start();
 threadTwo.start();

 }
}
</code></pre>
Running the code will give us something along the lines of:
<pre><code class="hljs">Starting to print Numbers for ThreadOne
Starting to print Numbers for ThreadTwo
ThreadTwo 0
ThreadTwo 1
ThreadTwo 2
ThreadTwo 3
ThreadTwo 4
Completed printing Numbers for ThreadTwo
ThreadOne 0
ThreadOne 1
ThreadOne 2
ThreadOne 3
ThreadOne 4
Completed printing Numbers for ThreadOne
</code></pre>
<code>ThreadOne</code> started first, though <code>ThreadTwo</code> completed first.
And running it again greets us with another undesired output:
<pre><code class="hljs">Starting to print Numbers for ThreadOne
Starting to print Numbers for ThreadTwo
ThreadOne 0
ThreadTwo 0
ThreadOne 1
ThreadTwo 1
ThreadOne 2
ThreadTwo 2
ThreadOne 3
ThreadOne 4
ThreadTwo 3
Completed printing Numbers for ThreadOne
ThreadTwo 4
Completed printing Numbers for ThreadTwo
</code></pre>
These outputs are given completely to chance, and are completely unpredictable. Each run will give us a different output. Factor this in with the fact that there can be many more threads, and we could have a problem. In real-world scenarios this is especially important to consider when accessing some type of shared resource, like a file or other type of IO, as opposed to just printing to the console.
Now, let's adequately <code>synchronize</code> our method:
<pre><code class="hljs">public synchronized void printNumbers() {
 System.out.println(&quot;Starting to print Numbers for &quot; + Thread.currentThread().getName());

 for (int i = 0; i &lt; 5; i++) {
 System.out.println(Thread.currentThread().getName() + &quot; &quot; + i);
 }

 System.out.println(&quot;Completed printing Numbers for &quot; + Thread.currentThread().getName());
}
</code></pre>
Absolutely nothing has changed, besides including the <code>synchronized</code> keyword. Now, when we run the code:
<pre><code class="hljs">Starting to print Numbers for ThreadOne
ThreadOne 0
ThreadOne 1
ThreadOne 2
ThreadOne 3
ThreadOne 4
Completed printing Numbers for ThreadOne
Starting to print Numbers for ThreadTwo
ThreadTwo 0
ThreadTwo 1
ThreadTwo 2
ThreadTwo 3
ThreadTwo 4
Completed printing Numbers for ThreadTwo
</code></pre>
This looks about right.
Here, we see that even though the two threads run simultaneously, only one of the threads enters the synchronized method at a time which in this case is <code>ThreadOne</code>.
Once it completes execution, <code>ThreadTwo</code> can starts with the execution of the <code>printNumbers()</code> method.
<h2 id="synchronizedblocks">Synchronized Blocks</h2>
The main aim of multi-threading is to execute as many tasks in parallel as is possible. However, synchronization throttles the parallelism for threads which have to execute synchronized method or block.
This reduces the throughput and parallel execution capacity of the application. This downside cannot be entirely avoided due to shared resources.
However, we can try to reduc the amount of code to be executed in a synchronized fashion by keeping the least amount of code as possible in the scope of <code>synchronized</code>. There could be many scenarios where instead of synchronizing on the whole method, it is okay to just synchronize a few lines of code in the method instead.
We can use the <code>synchronized</code> block to enclose only that portion of code instead of the whole method.
Since there is less amount of code to be executed inside the synchronized block, the lock is released by each of the threads more quickly. As a result, the other threads spend less time waiting for the lock and code throughput increases greatly.
Let's modify the earlier example to synchronize only the <code>for</code> loop printing the sequence of numbers, as realistically, it's the only portion of code that should be synchronized in our example:
<pre><code class="hljs">public class SynchronizedBlockExample {

 public void printNumbers() {

 System.out.println(&quot;Starting to print Numbers for &quot; + Thread.currentThread().getName());

 synchronized (this) {
 for (int i = 0; i &lt; 5; i++) {
 System.out.println(Thread.currentThread().getName() + &quot; &quot; + i);
 }
 }

 System.out.println(&quot;Completed printing Numbers for &quot; + Thread.currentThread().getName());
 }
}
</code></pre>
Let's check out the output now:
<pre><code class="hljs">Starting to print Numbers for ThreadOne
Starting to print Numbers for ThreadTwo
ThreadOne 0
ThreadOne 1
ThreadOne 2
ThreadOne 3
ThreadOne 4
Completed printing Numbers for ThreadOne
ThreadTwo 0
ThreadTwo 1
ThreadTwo 2
ThreadTwo 3
ThreadTwo 4
Completed printing Numbers for ThreadTwo
</code></pre>
Although it may seem alarming that <code>ThreadTwo</code> has &quot;started&quot; printing numbers before <code>ThreadOne</code> completed its task, this is only because we allowed the thread to reach past the <code>System.out.println(Starting to print Numbers for ThreadTwo)</code> statement before stopping <code>ThreadTwo</code> with the lock.
That's fine because we just wanted to synchronize the sequence of the numbers in each thread. We can clearly see that the two threads are printing numbers in the correct sequence by just synchronizing the <code>for</code> loop.
<h2 id="conclusion">Conclusion</h2>
In this example we saw how we can use synchronized keyword in Java to achieve synchronization between multiple threads. We also learnt when we can use synchronized method and blocks with examples.
As always, you can find the code used in this example <a rel="nofollow" target="_blank" href="https://github.com/chand31290/codingExamples/tree/master/SynchronizedExample">here</a>.

Chandan Singh

Concurrency in Java: The synchronized Keyword

In the Git version control system you're able to push and pull code from any number of remote repositories. This is beneficial for when you want to pull in updates from someone else's fork of a project, for example. Or you may just want to have a way to link your local Git repo with the remote one on GitHub. Either way, it's beneficial to associate a remote repository to your local one. In this short article I'll explain exactly how to do that.
The command you'll want to use is <code>git remote add</code>, and is generally used in the following way:
<pre><code class="hljs">$ git remote add &lt;remote-name&gt; &lt;remote-location&gt;
</code></pre>
The remote name is helpful for being able to reference this repository without having to type out the entire location. You can also set these remotes as your default <code>push</code> or <code>pull</code> locations, shortening your Git commands even more.
For example, to add a remote origin to your repository, you would use the command like this:
<pre><code class="hljs">$ git remote add origin git@github.com:scottwrobinson/camo.git
</code></pre>
Once you've added a remote to your repo you can then verify it with the <code>-v</code> flag:
<pre><code class="hljs">$ git remote -v
origin git@github.com:scottwrobinson/camo.git (fetch)
origin git@github.com:scottwrobinson/camo.git (push)
</code></pre>
<h2 id="addingremotesforfetchandpull">Adding Remotes for Fetch and Pull</h2>
In the output of the last command you may have noticed that there are actually two lines listed for the &quot;origin&quot; remote repository. This means you can actually set two different remote repositories for &quot;origin&quot;, one for the push operation and one for fetch. This can be done with the following commands:
<pre><code class="hljs">$ git remote set-url &lt;remote-name&gt; &lt;repo-url-for-fetching&gt;
$ git remote set-url --push &lt;remote-name&gt; &lt;repo-url-for-pushing&gt;
</code></pre>
This kind of setup can be helpful if you're pulling in changes from the main branch of a project and then pushing any changes you make to a separate branch of your own, for example.

Git: Add New Remote to a Repo

Shadab Ansari

Web Browser Automation with Selenium and Java

<h2 id="introduction">Introduction</h2>
In this tutorial, we are going to learn how to use <a rel="nofollow" target="_blank" href="https://opencv.org">OpenCV</a> library in Python. OpenCV is an open source library which is supported by multiple platforms including Windows, Linux, and MacOS, and is available for use in multiple other languages as well; however, it is most commonly used in Python for Machine Learning applications, specifically in the Computer Vision domain.
Apart from its cross-platform support and availability in multiple other computer languages, which allows applications developed in it to be used on different systems, OpenCV is also, in comparison to other such libraries, fairly efficient in terms of computations, as it uses vector operations for most of its functions.
In this tutorial, we'll cover OpenCV installation on Mac, Windows, and Linux, image operations, image arithmetics, image smoothing, and geometric transformations using OpenCV. So without further ado, let's start.
<h2 id="installation">Installation</h2>
Note: Since we are going to use OpenCV in the Python language, it is an implicit requirement that you already have Python (version 3) installed on your workstation. Depending upon your OS, execute one of the following commands to install OpenCV library on your system:
Windows
<pre><code class="hljs">$ pip install opencv-python
</code></pre>
MacOS
<pre><code class="hljs">$ brew install opencv3 --with-contrib --with-python3
</code></pre>
Linux
<pre><code class="hljs">$ sudo apt-get install libopencv-dev python-opencv
</code></pre>
To check if your installation was successful or not, run the following command in either a Python shell, or your command prompt/ terminal:
<pre><code class="hljs">import cv2
</code></pre>
If you do not get an error on importing <code>cv2</code> then it was installed correctly.
<h2 id="basicimageoperations">Basic Image Operations</h2>
Now that we have installed OpenCV on our workstations, let's get our hands dirty with some of the functionalities that OpenCV offers.
<h3 id="displayanimage">Display an Image</h3>
Displaying an image using OpenCV is a two-step process; first, we have to load it, and then we can display it. Both operations are done in sequence using different functions.
To display an image, we need to know two things:
<ol>
<li>Image Path (both absolute and relative paths work)</li>
<li>Read Mode (read, write, etc.)</li>
</ol>
The function we'll use for reading/loading an image is <code>cv2.imread()</code>, which has two variations. First one is <code>IMREAD_GRAYSCALE</code>, which as the name suggests, converts the image to grayscale before reading it. The second one is <code>IMREAD_UNCHANGED</code>, which loads the image without cutting out the alpha channel. The default is <code>IMREAD_COLOR</code>, which simply reads the colored image using the RGB channels only.
Let's code an example:
<pre><code class="hljs">import cv2

my_bike = cv2.imread(&#x27;bike.png&#x27;)
</code></pre>
This will load the image of a bike from the file system and store it in the <code>my_bike</code> variable for further operations
Note: If you get an error from the above code, there are only three possible reasons for it. The first one is that the path you specified is incorrect, second is that the image file you specified doesn't exist, and the last one is that the image type (jpg/jpeg/png) in the image path is incorrect.
Let's now display the image we just read. It can be done by the <code>cv2.imshow()</code> function. If you have used Matlab, you may be familiar with these image operations.
<pre><code class="hljs">cv2.imshow(&#x27;my_bike&#x27;, my_bike)
</code></pre>
The first parameter to the <code>imshow()</code> function is the string name that you want to display on the image window. The second parameter is the image handler we created using the <code>cv2.imread()</code> function.
<h3 id="savinganimage">Saving an Image</h3>
Saving an image is a very commonly used feature, as we may need to update our image and save the changes to the file system for later use. OpenCV has an <code>cv2.imwrite()</code> function to save images.
Here is an example:
<pre><code class="hljs">cv2.imwrite(&#x27;bike.png&#x27;, my_bike)
</code></pre>
Here we specify the name and current location of the image. The resulting image is automatically saved in the current working directory.
<h2 id="arithmeticoperationsonimages">Arithmetic Operations on Images</h2>
Arithmetic operations on images refer to adding, subtracting, multiplying, or dividing multiple images to generate a new image which is an arithmetic combination of the input images. Image arithmetics has a lot of applications, like adding a watermark to an image, creating a blended combination of two images, applying different types of image filters, etc.
While there are many operations you can perform, we will only be showing two examples here, as this will then allow you to apply the concept to other arithmetic operations available in OpenCV. The first example will be the addition of two images, and the second example will be blending two images.
Let's code these two examples:
<h3 id="addingimages">Adding Images</h3>
<pre><code class="hljs">import cv2

# Read in the two images
image_1 = cv2.imread(&#x27;bike.jpg&#x27;)
image_2 = cv2.imread(&#x27;car.jpg&#x27;)

# Sum the two image arrays for all channels
result = cv2.add(image_1, image_2)

cv2.imshow(&#x27;result&#x27;, result)
cv2.waitKey(0)
cv2.destroyAllWindows()
</code></pre>
The <code>waitKey</code> command will wait for you to press a key before it moves on to the next command. This is useful so that the program will continue to display your image until a key is pressed, otherwise it will be displayed for a split second and then quickly disappear once the program has stopped executing.
<h3 id="blendingimages">Blending Images</h3>
Blending images is similar to image addition, except each image's contribution to the new resulting image can be controlled. Basically, if we want one image to be more focused, and the other one to be more faint when they get merged, we will go with blending, instead of simple addition.
Lets code it to clarify further:
<pre><code class="hljs">import cv2

# Read in the two images
image_1 = cv2.imread(&#x27;bike.jpg&#x27;)
image_2 = cv2.imread(&#x27;car.jpg&#x27;)

result = cv2.addWeighted(image_1, 0.9, image_2, 0.1)

cv2.imshow(&#x27;result&#x27;, result)
cv2.waitKey(0) # Wait for the user to press a key before continuing
cv2.destroyAllWindows()
</code></pre>
The sum of the weights given to the <code>addWeighted</code> function should be equal to 1.0. You can also give a scalar value at the end, which would be added to all the pixel values of the resultant image.
Note: The images can be of any type; however, the type should be the same for all images. For instance, if you are using PNG format, all images being used for computation should be in PNG format as well.
<h2 id="imagesmoothing">Image Smoothing</h2>
Image smoothing is a very helpful feature, which is mostly performed before the images are passed on to a machine learning model. It is mostly done to remove noise/high-frequency elements from images by passing the image through a low-pass filter. There are many filters, including box filter (averaging filter), median filter, mode filter, Gaussian filter, and many more; however, to understand image smoothing and how to do it using OpenCV, we will only cover the box filter.
Let's say you have an image of 10x10, and you want to pass it through a 3x3 box/averaging filter, how would you do it?
You'll start with the top left of the image, place your 3x3 filter there, and replace the central element with the average of all 9 elements. This was the first step, now you will move your filter one step to the right, and repeat the same process until you have covered the whole image. An example of 10x10 image, and 3x3 averaging filter are shown below for your reference:
Filter/Mask:
<img class="img-responsive" src="https://stackabuse.s3.amazonaws.com/media/introduction-opencv-python-1.png">
Filter being applied on 10x10 Image:
<img class="img-responsive" src="https://stackabuse.s3.amazonaws.com/media/introduction-opencv-python-2.png">
Now that we have discussed how it works, lets try and see how we can apply different filters on our image using OpenCV; please read the comments thoroughly to know which line of code is used for which filter:
<pre><code class="hljs">import cv2

# Load the original image
original_image = cv2.imread(&#x27;my_bike.png&#x27;)

# Filter by passing image through 3x3 averaging filter
average_image = cv2.blur(original_image,(3,3))

# Apply 3x3 gaussian filter on the original image
gaussian_image = cv2.GaussianBlur((original_image,(3,3),0))

# Apply 3x3 median filter on the original image
median_image = cv2.medianBlur(original_image,3)
</code></pre>
Note: You can view the resulting images by using the following additional code:
<pre><code class="hljs">import matplotlib.pyplot as plt

plt.imshow(average_image)
plt.show()
</code></pre>
<h2 id="imagetransformations">Image Transformations</h2>
Image transformation is the last, but one of the most important topics that we are going to cover with OpenCV. It has a lot of applications, but one of the most common ones nowadays is in Machine Learning for Data Augmentation, i.e. when you have a shortage of dataset, you augment/transform the currently available images to make them different from your existing dataset. This effectively increases your dataset size and might help in improving your model accuracy.
The list of possible transformations is a long one, including scaling, <a target="_blank" href="/affine-image-transformations-in-python-with-numpy-pillow-and-opencv/">affine</a>, rotation, translation, etc. We will only cover two of them using OpenCV to get a general idea; however, OpenCV provides supporting functions for a wide range of them. Let's start with scaling.
<h3 id="scaling">Scaling</h3>
To put it in simple words, scaling is basically just resizing your image, i.e. either making it bigger or smaller. <code>resize</code> is the function used for scaling the images in OpenCV. Resizing has three types: <code>INTER_CUBIC</code>, <code>INTER_LINEAR</code>, and <code>INTER_AREA</code>. Let's code an example using these functions for scaling; please read through the code, comments, and descriptions carefully as they will explain what exactly is going on in the code:
<pre><code class="hljs">import cv2
import numpy as np
import matplotlib.pyplot as plt

image = cv2.imread(&#x27;my_bike.jpg&#x27;)

# Scale up/expand both width and height by factor of 2
result_1 = cv2.resize(image, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)

# Scale down/shrink both width and height by factor of 2
result_2 = cv2.resize(image, None, fx=2, fy=2, interpolation=cv2.INTER_AREA)

# Display the resulting images
plt.imshow(result_1)
plt.imshow(result_2)
plt.show()
</code></pre>
Here in the <code>resize</code> function, the <code>fx</code> parameter in represents the scale factor for width, <code>fy</code> represents the scale factor height, and <code>interpolation</code> specifies the function to be used for scaling (shrinking or expansion).
<h3 id="rotation">Rotation</h3>
Rotation allows us to move an image about the axis for a certain specified angle.
Before we learn how to rotate our images using code, we should know that there is a <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Rotation_matrix">rotation matrix</a> that is used for performing this transformation; we will not go in details of that, as OpenCV makes it very simple for us to calculate that matrix using a single function call. You will see that in the code below:
<pre><code class="hljs">import cv2
import matplotlib.pyplot as plt

# Load the image of a bike
image = cv2.imread(&#x27;my_bike.jpg&#x27;,0)

# Rows and columns
r, c = image.shape

matrix = cv2.getRotationMatrix2D((cols/2,rows/2), 180, 1)
result = cv2.warpAffine(image,matrix,(c,r))

# Display resulting rotation
plt.imshow(result)
plt.show()
</code></pre>
In the <code>getRotationMatrix2D</code> function, 180 specifies the degree by which the image should be rotated, 1 is the scaling factor, the function call would return the rotation matrix in the <code>matrix</code> variable.
The <code>warpAffine</code> function call uses the matrix we calculated from the previous method to rotate the image according to our specifications.
<h2 id="conclusion">Conclusion</h2>
To conclude it all, let's reiterate over some important points that we discussed in this article. OpenCV is a library available in multiple languages and is mostly used in conjunction with <a target="_blank" href="/numpy-tutorial-a-simple-example-based-guide/">NumPy</a>, SciPy and <a target="_blank" href="/python-data-visualization-with-matplotlib/">Matplotlib</a>, as we saw in some of the examples above, as well. Some of its functions are the same as in Matlab, and it also supports vectorized operations, hence increasing computational efficiency.
Furthermore, OpenCV is one of the best libraries out there for the Computer Vision domain, and after reading this article, you should be able to go ahead and search up some computer vision / machine learning applications that have been developed using OpenCV.
Let it be known that this article was just the tip of the iceberg, and OpenCV has a lot more to offer. Reading this should enable you to dive deeper and learn about other advanced features that OpenCV has to offer.

Muhammad Junaid Khalid

Introduction to OpenCV with Python

In this article we'll go over how the run-length encoding algorithm works, what it's used for, and how to implement its encode and decode functions in Python.
Run-length encoding (RLE) is a very simple form of data compression in which a stream of data is given as the input (i.e. &quot;AAABBCCCC&quot;) and the output is a sequence of counts of consecutive data values in a row (i.e. &quot;3A2B4C&quot;). This type of data compression is lossless, meaning that when decompressed, all of the original data will be recovered when decoded. Its simplicity in both the encoding (compression) and decoding (decompression) is one of the most attractive features of the algorithm.
Here you can see a simple example of a stream (&quot;run&quot;) of data in its original form and encoded form:
Input data:
<pre><code class="hljs">AAAAAAFDDCCCCCCCAEEEEEEEEEEEEEEEEE
</code></pre>
Output data:
<pre><code class="hljs">6A1F2D7C1A17E
</code></pre>
In this example we were able to compress the data from 34 characters down to 13.
As you may have noticed, the more consecutive values in a row, the more space we save in the resulting compression. On the other hand, if you have a sequence of data that frequently changes between values (i.e. &quot;BEFEFADED&quot;) then we won't save much space at all. In fact, we could even increase the size of our data since a single instance of a character results in 2 characters (i.e. &quot;A&quot; becomes &quot;1A&quot;) in the output of the encoding.
Because of this, RLE is only good for certain types of data and applications. For example, the <a rel="nofollow" target="_blank" href="https://pixycam.com/pixy-cmucam5/">Pixy camera</a>, which is a robotics camera that helps you easily track objects, uses RLE to compress labeled video data before transferring it from the embedded camera device to an external application. Each pixel is given a label of &quot;no object&quot;, &quot;object 1&quot;, &quot;object 2&quot;, etc. This is the perfect encoding for this application because of its simplicity, speed, and ability to compress the low-entropy label data.
<h2 id="encoding">Encoding</h2>
In order to encode a string of data, your code will need to loop through each character of the data and count the occurrences. Once you see a character that is different from the previous character, you will append the number of occurrences and the character to your encoding.
Below you'll find a simple implementation in Python:
<pre><code class="hljs"># rle-encode.py

def rle_encode(data):
 encoding = &#x27;&#x27;
 prev_char = &#x27;&#x27;
 count = 1

 if not data: return &#x27;&#x27;

 for char in data:
 # If the prev and current characters
 # don&#x27;t match...
 if char != prev_char:
 # ...then add the count and character
 # to our encoding
 if prev_char:
 encoding += str(count) + prev_char
 count = 1
 prev_char = char
 else:
 # Or increment our counter
 # if the characters do match
 count += 1
 else:
 # Finish off the encoding
 encoding += str(count) + prev_char
 return encoding
</code></pre>
From the comments you should be able to tell what is going on throughout the code. If not, it would be a good exercise to run through the code with a debugger and see it in action.
Continuing with the same file as above, here is an example of the code being executed:
<pre><code class="hljs">encoded_val = rle_encode(&#x27;AAAAAAFDDCCCCCCCAEEEEEEEEEEEEEEEEE&#x27;)
print(encoded_val)
</code></pre>
And the output:
<pre><code class="hljs">$ python rle-encode.py
6A1F2D7C1A17E
</code></pre>
<h2 id="decoding">Decoding</h2>
Decoding an RLE-encoded stream of data is actually even easier than encoding it. Like before, you iterate through the data stream one character at a time. If you see a numeric character then you add it to your <code>count</code>, and if you see a non-numeric character then you add <code>count</code> of those characters to your decoding, which is returned to the caller once you iterate through all of the input<code>data</code>.
Here is the algorithm implemented in Python:
<pre><code class="hljs"># rle-decode.py

def rle_decode(data):
 decode = &#x27;&#x27;
 count = &#x27;&#x27;
 for char in data:
 # If the character is numerical...
 if char.isdigit():
 # ...append it to our count
 count += char
 else:
 # Otherwise we&#x27;ve seen a non-numerical
 # character and need to expand it for
 # the decoding
 decode += char * int(count)
 count = &#x27;&#x27;
 return decode
</code></pre>
We can run this code on the same output that we got from our encoding:
<pre><code class="hljs">decoded_val = rle_decode(&#x27;6A1F2D7C1A17E&#x27;)
print(decoded_val)
</code></pre>
And the output is the same as our original input to the encoding function:
<pre><code class="hljs">$ python rle-decode.py
AAAAAAFDDCCCCCCCAEEEEEEEEEEEEEEEEE
</code></pre>
Note that this implementation doesn't do any error checking to ensure that we have a valid RLE data stream. If any of the input data isn't formatted properly then you'll likely encounter an error.