Sometimes you have made some changes into your local copy and you don’t want to make a commit because your code doesn’t compile, but something came up and you should change your branch for instance and you will lose your local changes. In this situation, you can stash your changes and save your changes and […]
Mastering git, Part 6, git stash Read More »
Git cherry-picking is a feature in Git that allows you to select and apply specific commits from one branch to another, rather than merging the entire branch. This can be useful when you want to apply a specific change or fix to a different branch, without merging the entire branch. Imagine the following situation, you
Mastering git, Part 5, git cherry-pick Read More »
Diff Before following this post, make sure you have already set up everything from my other post regarding the configuration of the git environment. Diff command will allow you to compare two different commits, let’s set up a repository:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
mkdir repos1 mkdir repos2 mkdir remote_repose cd repos1 git init git init --bare ../remote_repose/ git remote add origin ../remote_repose/ touch A.txt git add -A git commit -a -m 'A Added' git push --set-upstream origin master |
Now in the second repository, we make some changes:
|
1 2 3 4 5 6 7 |
cd ../repos2/ git clone ../remote_repose/ . touch B.txt date > A.txt git add -A git commit -m 'some changes' git push |
now let’s back to the first repository and see
1. Checkout The git checkout moves the HEAD ref pointer to a specified commit. To demonstrate this, consider the following example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
mkdir remote_repose mkdir repos && cd repos git init git init --bare ../remote_repose/ git remote add origin ../remote_repose/ touch A.txt git add -A git commit -a -m 'A Added' git push --set-upstream origin master touch B.txt git add -A git commit -a -m 'B Added' git push touch C.txt git add -A git commit -a -m 'C Added' git push touch D.txt git add -A git commit -a -m 'D Added' git push |
Now you can change the HEAD with:
|
1 |
git checkout <commit-id> |
or
|
1 |
git checkout HEAD~<number> |
you can find all commits again by:
|
1 |
git log --all |
For instance:
|
1 |
git checkout HEAD~2 |
|
1 |
gitk --all |
1.2 Detached HEAD Any checkout of a commit that is not
Creating a bare repository
|
1 2 3 4 5 |
mkdir remote_repose1 remote_repose2 cd remote_repose1 git init --bare cd ../remote_repose2 git init --bare |
Creating a repositiy
|
1 2 3 |
mkdir repos1 repos2 cd repos1/ git init . |
Managing remotes You need to know how to handle your remote repositories in order to be able to work on any Git project. Remote repositories are copies of your project which are hosted elsewhere on the Internet or the network. You can have several of them,
Mastering git, Part 2, Creating and managing repositories Read More »
Installing prerequisite
|
1 |
sudo apt-get install git-gui gitk meld kdiff3 |
Configuring Git Environment First config your environment and set a proper merge/ diff tool. The settings in Linux are under/home/<username>/.gitconfig. If you don’t know where this file is located in your OS You can easily edit this file by:
|
1 |
git config --global -e |
All Git settings can be set or viewed via terminal, i.e:
|
1 |
git config --list --show-origin |
Mastering git, Part 1, setting up git environment, GUI, mergetool, difftool Read More »
Pose estimation and tracking human is one the key step in sports analysis. Here is in this work I used openpose for analysis of player in a Bundesliga game HSV Hamburg vs Bayer München. Warning: the video might be disturbing for HSV fans 🙂 Original Video Analyzed Video Original Video Analyzed Video Original Video Analyzed Video Original Video
Human detection and Pose Estimation with Deep Learning for Sport Analysis Read More »
Python Implementation BFS traverse:
|
1 2 3 4 5 |
Root='a' g.nodes[Root]['visited']=True print Root Q=[Root] BFS_travrse(Q,g) |
DFS traverse:
|
1 2 3 4 5 |
Root='a' print Root g.nodes[Root]['visited']=True coloring_tree(g) DFS_travrse(Root,g) |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 |
import networkx as nx import matplotlib.pyplot as plt from networkx.drawing.nx_agraph import write_dot, graphviz_layout def coloring_tree(G): visited_list=[] for i in G.nodes(): visited_list.append( g.nodes[i]['visited'] ) graph_color_map=[] for i in visited_list: if i: color='blue' else: color='red' graph_color_map.append(color) pos =graphviz_layout(G, prog='dot') nx.draw(G, pos, with_labels=True, arrows=True,node_color = graph_color_map) #plt.savefig('nx_test.png') plt.show() return def DFS_travrse(N,G): neighbors =G.neighbors(N) size=len( list(neighbors)) if size==0: return neighbors =G.neighbors(N) for neighbor in neighbors: G.nodes[neighbor]['visited']=True coloring_tree(G) DFS_travrse(neighbor,G) return def BFS_travrse(Q,G): if len(Q)==0: return Root=Q[0] Q=Q[1:len(Q)] neighbors =G.neighbors(Root) for neighbor in neighbors: print neighbor coloring_tree(G) G.nodes[neighbor]['visited']=True Q.append(neighbor) BFS_travrse(Q,G) return g=nx.DiGraph() g.add_node('a',visited=False) g.add_node('b',visited=False) g.add_node('c',visited=False) g.add_node('d',visited=False) g.add_node('e',visited=False) g.add_node('f',visited=False) g.add_node('g',visited=False) g.add_node('h',visited=False) g.add_edge('a','b') g.add_edge('a','c') g.add_edge('b','e') g.add_edge('b','d') g.add_edge('e','h') g.add_edge('c','f') g.add_edge('c','g') |
C++ Implementation
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 |
#include <algorithm> #include <iostream> #include <memory> class node { public: std::vector<std::shared_ptr<node> > leaves; double data; }; void populateTree(std::shared_ptr<node> rootNodePtr) { /* -1 / \ 3 7 / \ / 4 1 5 */ rootNodePtr->data=-1; std::shared_ptr<node> leftNodePtr,rightNodePtr; std::shared_ptr<node> leftNode1stKidPtr,leftNode2ndtKidPtr, rightNode1stKidPtr; leftNodePtr.reset(new node) ; rightNodePtr.reset(new node); rootNodePtr->leaves.push_back(leftNodePtr); rootNodePtr->leaves.push_back(rightNodePtr); leftNodePtr->data=3; rightNodePtr->data=7; leftNode1stKidPtr.reset(new node); leftNode2ndtKidPtr.reset(new node); rightNode1stKidPtr.reset(new node); leftNode1stKidPtr->data=4; leftNode2ndtKidPtr->data=1; rightNode1stKidPtr->data=5; leftNodePtr->leaves.push_back(leftNode1stKidPtr); leftNodePtr->leaves.push_back(leftNode2ndtKidPtr); rightNodePtr->leaves.push_back(rightNode1stKidPtr); } void DFS(std::shared_ptr<node> rootNode) { std::cout<<rootNode->data <<std::endl; for(auto n:rootNode->leaves) DFS(n); } void BFS(std::shared_ptr<node> rootNode) { for(auto n:rootNode->leaves) std::cout<<n->data <<std::endl; for(auto n:rootNode->leaves) BFS(n); } int main() { std::shared_ptr<node> tree(new node); populateTree(tree); DFS(tree); BFS(tree); } |
Breadth-first search (BFS) and Depth-first search (DSF) Algorithm with Python and C++ Read More »
