Forem: Diksha Rai

Getting Started with OpenCV - Reversing a Video

Diksha Rai — Sat, 07 Jan 2023 08:50:21 +0000

OpenCV's documentation is the best place to learn OpenCV, check it out.

Learn the basics of Image and Video Handling and then try reversing a video by yourself. If you are stuck here is the code for your reference.

Make sure you are comfortable with Numpy before jumping on it OpenCV.


# Import the library 
import cv2 as cv

#Video Capture Instance
cap = cv.VideoCapture('videopath.mp4')

#Total number of frames in video
frames = cap.get(cv.CAP_PROP_FRAME_COUNT)

#Frames per second 
fps = cap.get(cv.CAP_PROP_FPS)

#height and width of video
height = cap.get(cv.CAP_PROP_FRAME_HEIGHT)
width = cap.get(cv.CAP_PROP_FRAME_WIDTH)

fourcc = cv.VideoWriter_fourcc(*'MJPG')
out = cv.VideoWriter('reversed_vid_name.avi', fourcc,fps ,(int(width*0.5), int(height*0.5)))

#We can print the progress of the video as it will take some time depending on video quality and length.
# print("No. of frames are : {}".format(frames))
# print("Frames per second is :{}".format(fps))

# We get the index of the last frame of the video file
frame_index = frames-1

if(cap.isOpened()):
    while(frame_index!=0):
        cap.set(cv.CAP_PROP_POS_FRAMES, frame_index)
        ret, frame = cap.read()
        frame = cv.resize(frame,(int(width*0.5), int(height*0.5)))

        #OPTIONAL : To show the reversing video
        #cv2.imshow('winname', frame)

        #Writing the reversed video 
        out.write(frame)
        #Decrementing Frame index at each step
        frame_index = frame_index-1

        #Printing the progress
        if(frame_index%100==0):
            print(frame_index)
        # if(cv2.waitKey(2)==ord('q')):
        #   break
out.release()
cap.release()

Singly Linked Lists

Diksha Rai — Sat, 12 Mar 2022 15:08:53 +0000

As I have already discussed in the previous blog that a node in a linked list contains the data element and the address of the next node. When the node of the linked list contains only the data element and the address to the next node these kinds of linked lists are known as singly-linked lists.
Here is a representation of the singly linked list

The last node of the linked list points to null, which means it contains no address.
So one node of the linked list contains:- a data element and address of the next node. So let's try to code this:

A linked list contains several nodes.

So we will create a linked list class, which will have a subclass for nodes.
Suppose we created two nodes of the linked list where the first node contains the data element and the address to the second node and the second node contains the data element and it points to null because there is no node after that.

We can access the second node using the first node, but wait how will we access the first node?
We need a pointer that will point to the first node of the linked list.
So we will create a node which we will call 'head' to point to the first node of the linked list.

Now we can easily access each node of the linked list, we can access first node using head, and second node using the first node.
The above things can be coded like this:

public class LinkedList {

    private Node head;

    private class Node {
        private int value;
        private Node next;

    }
}

I assume that you have some familiarity with object-oriented programming beforehand.
Now when we create a node of the linked list, we want to pass a value that will be the data element contained by the node. So will create a constructor of the node class for this purpose.

public Node(int value) {
            this.value = value;
            this.next= null;
        }

Now the whole code is given below:

public class LinkedList {

    private Node head;

    private class Node {
        private int value;
        private Node next;

        public Node(int value) {
            this.value = value;
            this.next= null;
        }

    }
}

Now let us look what are the operations we can perform on the linked list. There are 6 basic operations that can be performed on these linked lists, and these operations will make things crystal clear.

Traversal
Insertion
Deletion
Searching
Sorting
Reversal

Traversing the linked list

The most important point to consider in a linked list is:

If the head node is lost the whole list is lost.

In order to traverse the linked list, we will create a node and set it equal to the head node, which means it will also point to the first node of the list.

When

temp == null

means we have reached the end of the linked list.
Here is the code to traverse the linked list:

public void traverse() {
        Node temp = head;
        while (temp != null) {
            temp = temp.next;
        }
    }

We will continue the remaining operations in the next blog. Stay tuned :)

Linked Lists

Diksha Rai — Sat, 12 Mar 2022 06:46:14 +0000

You may have worked with arrays before jumping on linked lists. Arrays are one of the most popular and simplest data structures. Both arrays and linked lists are linear data structures. But they have certain advantages and disadvantages over one another, that's the reason why they exist.

This is how we represent an array, they store elements in a contagious fashion. If you haven't heard of arrays then check out the following link. It covers everything you need to know about arrays.

All about Arrays

As you know, elements in an array are stored in contiguous memory locations. Here is a representation:

If we want to store say 5 elements in an array then we can do that

But what if we want to continuously update the number of elements in the array and the chunk of contiguous space available is less. Or even if the space is available we will have to copy elements from one location to another. That will cost us a lot of memory, So linked lists come to the rescue.

This doesn't mean that arrays are of no use, there are certain advantages of arrays. Let's look at the first then we will discuss linked lists and the disadvantages of arrays.
Arrays are stored contiguously that's why each element are easily accessed. So if you have a case where you set the data once and you don't have to update it. You just need to access it, then there is no better solution than storing them in an array.

But if you want to add some data to the existing one or delete some, then arrays are not efficient in this case. This is one of the major disadvantages of arrays.
For this reason, linked lists come into the picture.

One node of the linked list contains a data element and the address of the next node. Both data part and address part combined are known as a 'node'.

Nodes can be at any place in the memory, the previous node will contain the address to the next node. Hence the insertion and deletion are easily done because we just need to update the address.

Based on the address of the nodes they contain there are 3 types of linked lists.

Singly Linked Lists
Doubly Linked Lists
Circular Linked Lists

First Class Functions

Diksha Rai — Thu, 03 Mar 2022 14:44:54 +0000

A programming language is said to have First-class functions when functions in that language are treated like any other variable.

Functions are also called first-class objects, this means that functions should have all the properties which object haves.

The properties a first-class function have are:

A function can be assigned to a variable. Following is the code explaining that.

#Defining a function square
def square(num):
    return num*num
#assinging function to a variable
x=square #now x is same as square and we can treat x as a function
print (square)
print(x)
#both print statements will have same results
#calling the functions
print(square(2)) # output-4
print(f(2))#output-4

A function can be passed as an argument to other functions.

#defining a function
def multiple_of_two(num):
    return 2*num


#defining another function
def my_func(func, a_list_of_integers):

    result=[ ] #creating an empty list which will be used later in function
    for i in a_list_of_integers:

        result.append(func(i))
    return result # each element of list is passed as an argument to "func" function
#and the output of that function is then added to "result"


multiplication = my_func(multiple_of_two, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

print(multiplication) #output-[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

A function can be returned from other functions.

def greetings(name):
    def greet():
        print("Hi "+msg)
        return
    return greet #returning greet function from greetings function


my_func = greetings("xyz")
my_func() #calling the function

What is VCS ?

Diksha Rai — Wed, 11 Aug 2021 07:25:31 +0000

In simple terms, version control is nothing but a system that keeps track of the changes made to source code or files. With a version control system, you can look back at the changes made to a particular file, either by you or another person, by accessing the version control database. This system gives you the ability to compare different versions of a file, thus allowing you to stay informed about the changes that have happened over a period of time.

The version control system can be referred to as a database that stores snapshots of different files in a project. These snapshots are taken every time a file is modified. It maintains all the records of the different versions of a file. In addition to comparing different versions of a file, VCSs also allows you to switch between them. VCSs can either be distributed or centralized. Let us see how these two types differ.

Centralized version control systems use a single, centralized server to store all the different versions of a file. Users can access these files by gaining access to this centralized server. Now, there is a disadvantage associated with this type of VCS. If the central server fails to function due to any reason, the entire history stored on its will be gone and no one will be able to recover any version/versions of the lost files.

Git is one of the most popular VCS, and I will discuss about Git in the next post.
Till then keep learning and keep sharing.

DSA and Languages

Diksha Rai — Tue, 10 Aug 2021 17:34:20 +0000

As a beginner we generally get confused about which language we should choose in order to have a safer career, I was also confused about the same in my freshman year. My journey as a programmer started in my first-year of college, many people learn programming since their school days and this confusion is quite lesser in them. But for people like me it is very much seen among us, and then students waste a lot of time switching over languages and not learning the core concepts of it. They just want to learn as many languages they can, and end up learning none completely.

In my first-year I also did the same the I tried to learn all the languages and stuffs as much as I can in shorter span of time, however I was having a good grip in one language so learning the other language was quite easier for me.
But we need to understand the fact that language doesn't actually matter in each and every language you will almost use the same approach to solve a problem, they are just syntactically different. Our main focus should be that are we able to solve problems in any programming language be it C C++ Java Python anything. When you know one language completely learning other becomes easier for you, try solving problems as much as you can in any language of your choice.

And avoid wasting time on switching over languages, use the platforms like Leetcode Hackkerrank CodeChef to practice your skills, and don't try to cheat in that because that's not going to help you.