Haskell Study Note
Posted Updated Notea few seconds read (About 0 words)

Haskell Study Note

CADC Ground Investigation Visual Solution
Posted Updated Note5 minutes read (About 679 words)

CADC Ground Investigation Visual Solution

Catalog

Introduce

Motivation

We want to apply computer vision to the plane to fullfill ground investigation task automatically.

Objective

The input image looks like this:
InputImg

And we hope the output prediction to be 56.

Implementation

Environment Preparation

  • python3
  • numpy
  • torch
  • torchvision
  • opencv-python
  • other basic or dependency package

(requirment.txt will be added afterwards)

Foundation

Basic OpenCV methods is required.

Recommended learning site:

Code Review

Source code
in detect.py, there are two large function

1
2
3
4
def detect_target(image):
    ...
def get_numberShot(img, rect_list, ROI):
    ...

Function detect_target

Overview

detect_target receive image data(three channels, BGR), detect the colored targets and returns the index of them.

index:

  • rect_list
    • the list whose elements are Box2D type rect, indicating the information of the minimum bounding rectangle
  • ROI
    • the list whose elements are index([x,y,w,h]) of orthogonal bounding rectangle
      MinRect and BoundingBox
      In this picture, the blue frames are the minimum bounding Rectangle and the green ones are ordinary bounding box.

Note: What is Box2D type rect?

index description
rect[0] the location of the box’s center (x,y)
rect[1][0] width of the box(the length of the side which will be first reached by the horizontal line when rotating counter-clockwise)
rect[1][1] height
rect[2] rotation angle

Get the estimated area of the target by color filtering

First we need to convert the color layout from BGR to HSV, which is easier to judge color.

1
image_hsv=cv2.cvtColor(image_cut,cv2.COLOR_BGR2HSV)

Then define a mask that filter the color(hue) range from 160-179 or 0-10 (red),
HSV

1
2
3
4
5
6
7
red1=np.array([0,100,100])
red2=np.array([10,255,255])
red3=np.array([160,100,100])
red4=np.array([179,255,255])
mask1=cv2.inRange(image_hsv,red1,red2)
mask2=cv2.inRange(image_hsv,red3,red4)
mask=cv2.bitwise_or(mask1,mask2)

And apply the mask to the picture

1
after_mask=cv2.add(image_cut, np.zeros(np.shape(image_cut), dtype=np.uint8), mask=mask)

after_mask

Turn the after mask image into binary image and adapt close and open processing to fill holes and cancel noise.

1
2
3
kernel=np.ones([3,3],np.uint8)
close=cv2.morphologyEx(binary,cv2.MORPH_CLOSE,kernel,iterations=3)
Open=cv2.morphologyEx(close,cv2.MORPH_OPEN,kernel,iterations=1)

close and open

Then, find the contours of the processed image.

For each contour, adapt filters such as area, the ratio of the height and width of bounding rectangle.

If these restrictions are fullfilled, append the index of bounding rectangle and min area rectangle to two lists respectively, and return the lists.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
contours, hier=cv2.findContours(Open,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)
res_img=image.copy()
ROI=[]
rect_list=[]
for i in range(len(contours)):
    if cv2.contourArea(contours[i])<100:
        continue
    epsl=0.01*cv2.arcLength(contours[i],True)
    approx=cv2.approxPolyDP(contours[i],epsl,True)
    x,y,w,h=cv2.boundingRect(approx)
    if (float(w/h)<2) and (float(w/h)>0.5):
        res_img=cv2.rectangle(res_img,(x,y),(x+w,y+h),(0,255,0),1)
        ROI.append([x,y,w,h])
        rect = cv2.minAreaRect(approx)
        box = cv2.boxPoints(rect)
        box = np.int0(box)
        rect_list.append(rect)
        res_img=cv2.drawContours(res_img, [box], 0, (255, 0, 0), 2)
cv2.imshow('res_img',res_img)
return rect_list,ROI
ROS-Subscriber
Posted Updated Note2 minutes read (About 239 words)

ROS-Subscriber

Study note for ROS subscriber.

Model of Topic

  • Publisher(turtlesim)
    • –[Message(geometry_msgs::Twist)]–>
  • Topic (/turtle1/pose)
    • –[Message(geometry_msgs::Twist)]–>
  • Subscriber(Pose Listener)

Programming realization

How to realize a subscriber

  • initialize ROS node
  • subscribe required topic
  • loop wait the msgs from topic, after receiving msgs, enter callback function
  • implement msgs processing in the callback function

Code

Also we put this node into function package learning_topic
Create velocity_publisher.cpp file in learning_topic/src:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <ros/ros.h>
#include <turtlesim/Pose.h>

void poseCallback(const turtlesim::Pose::ConstPtr& msg)
{
    ROS_INFO("Turtle pose: x:%0.6f, y:%0.6f, ",msg->x,msg->y);
}

int main(int argc, char *argv[])
{
    ros::init(argc, argv, "pose_subscriber");
    ros::NodeHandle n;
    ros::Subscriber pose_sub = n.subscribe("/turtle1/pose",10,poseCallback）
    //queue also first in first thrown
    //loop waiting for callback function, keep the endless loop
    ros::spin();
    return 0;
}

Note

  • Callback function must be sufficient, or newer data will be blocked

Configure the compile run of subscriber

Steps same as publisher
Add two lines to learning\_topic/CMakeLists.txt (in build part):

1
2
add_executable(velocity_publisher src/pose_subscriber.cpp)
target_link_libraries(pose_subsriber ${catkin_LIBRARIES})

Compile

1
2
3
4
5
6
7
$ cd ~/ROS_study/catkin_ws
$ catkin_make
$ source ./devel/setup.zsh
$ roscore
$ rosrun turtlesim turtlesim_node
$ rosrun learning_topic velocity_publisher
$ rosrun learning_topic pose_subscriber

The output of pose_subscriber:

1
2
3
4
5
...
[ INFO] [1650184199.757606156]: Turtle pose: x:3.100077, y:7.501662,
[ INFO] [1650184199.773327854]: Turtle pose: x:3.101826, y:7.493855,
[ INFO] [1650184199.790252785]: Turtle pose: x:3.103601, y:7.486054,
...
ROS-Publisher
Posted Updated Note3 minutes read (About 378 words)

ROS-Publisher

Study note for ROS publisher.

Model of Topic

  • Publisher(turtle Velocity)
    • –[Message(geometry_msgs::Twist)]–>
  • Topic (/turtle1/cmd_vel)
    • –[Message(geometry_msgs::Twist)]–>
  • Subscriber(turtlesim)

Programming realization

Take turtlesim as the example.
We write a program acting like a publisher and sending controlling messages.

Create package

1
2
$ cd catkin_ws/src
$ catkin_create_pkg learning_topic roscpp rospy std_msgs geometry_msgs turtlesim

can see:

1
2
$ ls
CMakeLists.txt  include  package.xml  src

How to realize a publisher?

  • Initialize ROS node
  • register node info from ROS Master, including name of the topic and msg type
  • create message data
  • publish message at a specific frequency

Code

create velocity_publisher.cpp file in learning_topic/src

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
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>

int main(int argc, char *argv[])
{
    //init the node
    ros::init(argc,argv,"velocitypublisher");

    //create node handle
    ros::NodeHandle n;

    //create a publisher, who publish topic names '/turtle1/cmd_vel', message type 'geometry_msgs:Twist', queue length 10
    ros::Publisher turtle_vel_pub = n.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel",10);

    //set loop rate
    ros::Rate loop_rate(10);
    while (ros::ok()) {
        //initialize geometry_msgs:Twist msg
        geometry_msgs::Twist vel_msg;
        vel_msg.linear.x = 0.5;
        vel_msg.angular.z = 0.2;

        //publish msgs
        turtle_vel_pub.publish(vel_msg);
        ROS_INFO("Publish turtle velocity command at %0.2f m/s, %0.2f rad/s",
                vel_msg.linear.x,vel_msg.angular.z);

        //delay
        loop_rate.sleep();
    }
    return 0;
}

What is queue length?

  • msgs can be published very fast while the data transmission rate is limited, so the queue act as a buffer
  • first in, first thrown, keeping the remained msgs in the queue relatively new

Configure the compile rule of publisher

Steps:

  • set the code need to be complied and the generated excutable file
  • set the link library

Add two lines to learning\_topic/CMakeLists.txt (in build part):

1
2
add_executable(velocity_publisher src/velocity_publisher.cpp)
target_link_libraries(velocity_publisher ${catkin_LIBRARIES})

Compile

1
2
3
4
5
6
$ cd ~/ROS_study/catkin_ws
$ catkin_make
$ source ./devel/setup.zsh
$ roscore
$ rosrun turtlesim turtlesim_node
$ rosrun learning_topic velocity_publisher

Then, you can see turtle:

And outputs:

1
2
3
4
5
...
[ INFO] [1650088100.376299177]: Publish turtle velocity command at 0.50 m/s, 0.20 rad/s
[ INFO] [1650088100.476312726]: Publish turtle velocity command at 0.50 m/s, 0.20 rad/s
[ INFO] [1650088100.576304995]: Publish turtle velocity command at 0.50 m/s, 0.20 rad/s
...
Regular-Expression
Posted Updated Note2 minutes read (About 347 words)

Regular-Expression

Studying note for regular expression

Definition

Regular expression describes a pattern of matching string
Can be used to detect/replace/take out specific substring

Syntax

symbol description example
^ match the beginning of he line
[ABC] match all char in […] [aeiou]: google runoob taobao
[^ABC] match all except those in […]
[A-Z] describe an interval [a-z] matchs all lower case char
(…) set groups
\1…\n match the same elements as nth group
{n} the front element repeats n times
{n,} the front element repeats at least n times
{n,m} the front element repeats at least n and at most m times
. match any char except (\n,\r), same with [^\n\r]
\s\S match all, \s:match all space char, \S:match all non space char, ‘return’ not included
\w match letter,number,underline, equal to [A-Za-z0-9 ]
\cx match the control char indicated by x(A-Z/a-z) \cM: Control-M or return char
\f match a page change char
\n\r match a return symbol
\t match a tab
\v match a vertical tab
$ match the end of the string, to match $ itself, use $
* match the front subexpression multiple or zero times, use \* to match *
+ match the front subexpression multiple or one times, use \+
. match any single char except \n
[ mark the beginning of a []expression
? match the front subexpression one or zero times, or indicate a non-greedy qualifier
| logic or

Application in Cpp

In cpp, we use std::regex to express regular expression, supporting ECMAScripts as default.

Match

Use regex_match() to match xml (or html) format:

1
2
3
4
5
6
7
8
9
10
11
std::regex reg("<.*>.*</.*>");

bool ret = std::regex_match("<xml>value</xml>",reg);
assert(ret);


bool ret = std::regex_match("<html>value</html>",reg);
assert(ret);

bool ret = std::regex_match("<xml>value<xml>",reg);
assert(ret);

Use std::regex_search.
As long as there exists targets in the string, it will return.

1
2
3
4
5
6
7
8
std::regex reg("<(.*)>(.*)</(\\1)>");
std::cmatch m;
auto ret = std::regex_search("123<xml>value</xml>456", m, reg);
if (ret){
    for (auto& elem : m)
        std::cout<<elem<<std::endl;
}

VIM Snippets Customization
Posted Updated Notea few seconds read (About 106 words)

VIM Snippets Customization

Studying note for customizing vim-snippets.

Install vim-snippets

See Github

Syntax

Module:

1
2
3
snippet [trigger] ["Description"] [index]
[content]
endsnippet

Index:

Index Description
b trigger should be in the front of the line
i trigger can be inside a word
w trigger should be in the edge of two words
r trigger can be a regular expression
A auto trigger

Example

Generate a two column table:

1
2
3
4
5
6
7
8
9
10
snippet tb2 "Create table of two columns" b
| $1 | $2 |
|----|----|
| $3 | $4 |
| $5 | $6 |
endsnippet

snippet tbex2 "Create table of two columns" b
| $1 | $2 |
endsnippet

Or generate a code block for bash

1
2
3
4
5
6
snippet bbl "Bashblock" b
\`\`\`bash
\$ ${2:${VISUAL}}
\`\`\`
$0
endsnippet
ROS Orgmode Note
Posted Updated Note3 minutes read (About 505 words)

ROS Orgmode Note

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
Study note for ROS
* Core Concept
** Node and ROS Master
*** Node
implement functions for purposes
support various language
can have thousands of nodes
*** ROS Master
mange the registion and name of various nodes
support(trace and record) communication between different nodes
for nodes to find each other
provide parameter server(store global variables...)[[about parameter]]
** Communication between nodes
|                    | Topic               | Service        |
|--------------------+---------------------+----------------|
| sync               | n                   | y              |
| model              | publish/subscribe   | service/client |
| protocol           | ROSTCP/ROSUDP       | ROSTCP/ROSUDP  |
| response           | n                   | y              |
| buffer             | y                   | n              |
| real-time          | weak                | strong         |
| nodes relationship | multi/one to multi  | one to multi   |
| scene              | data transformation | logic process  |
*** Topic
Node(publisher)->Topic(/example)&Message_Tyoe(std_msgs/String)->other ROS nodes(subscriber)
Message: define the data type and struct of data, defined by .msg file
async
*** Service
C/S model(Client/Server)
client send requests, server return response data
defined by .srv file, defines the structure of the requests and response
    ROS node(Service Server)
    ^  |response
request|  v
    ROS node(Service Client)
sync
** Parameter
<<about parameter>>
talker -> ROS master : setParam("foo",1)
listener -> ROS master: getParam("foo")
ROS master ->listener: {"foo",1}

multiple variable dictionary
for storing static nonbinary configuration, not suitable for dynamic
** File system
*** package
Basic unit in ROS, include the src of nodes, cfg, data def
*** package manifest
record the basic information of packages
*** Meta packages
orgnize multi packages for one common purpose
* Commond Line Tools
** rqt_graph
visualize tool
display the calculate process graph
** rosnode
display node information
*** rosnode list
list all node
default node /rosout
*** rosnode info /turtle_sim
show info of a node
** rostopic
usage like rosnode(list,info)
*** rostopic pub /../.. data_structure data 
publish message as a topic
add -r num to repeat sending at rate num/s
** rosmsg
*** rosmsg show data_structure
show the data structure
** rosservice 
| commond addition       |                                   |
|------------------------+-----------------------------------|
| list                   | list all service the node provide |
| call service_name data |                                   |
** rosbag
| command addition        |                                               |        |                 |
|-------------------------+-----------------------------------------------+--------+-----------------|
| record -a -O cmd_record | record the topic data in the system           | -a:all | -O as a package |
| play cmd_record.bag     | play the recorded data of previous simulation |        |                 |
|                         |                                               |        |                 |
* setup workspace and function package
** workspace
*** overview
| src     | source space  |                         |
| build   | build space   | no need to touch        |
| devel   | develop space | script, executable file |
| install | install sapce |                         |

work space folder/
  src/
    CmakeLists.txt
    package_1/
      CmakeList.txt
      package.xml
      ...
    package_n/
      CmakeList.txt
      package.xml
      ...
  build/
    CATKIN_IGNORE
  devel/
    bin/
    etc/
    include/
    lib/
    share/
    .catkin
    env.bash
    setup.bash
    setup.sh
    ...
  install/
    bin/
    etc/
    include/
    lib/
    share/
    .catkin
    env.bash
    setup.bash
    setup.sh
    ...
*** setup
**** establish ws
mkdir -p ./catkin_ws/src
cd ./catkin_ws/src
catkin_init_workspace
**** compile ws
cd ./catkin_ws/
catkin_make -DPYTHON_EXECUTABLE=/usr/bin/python3
catkin_make install
**** set env variables
source devel/setup.bash
**** check env variables
echo $ROS_PACKAGE_PATHH
** fucntion package
*** setup
| establish package | cd ./src                                                                   |                                       |
|                   | catkin_create_pkg <pkg_name> [depend1] [depend2].. (rospy,roscpp,std_msgs) |                                       |
| source env path   | source devel/setup.bash                                                    | make sure that ros can detect the pkg |

*** package.xml
| label                        | description                                         |
|------------------------------+-----------------------------------------------------|
| <name>                       |                                                     |
| <version>                    |                                                     |
| <description>                |                                                     |
| <maintainer email="">        | maintainer's name and email                         |
| <license>                    |                                                     |
| <buildtool depend>           | usually catkin                                      |
| <build_depend>/<exec_depend> | package dependencies ,usually roscpp rospy std_msgs |
*** CmakeList.txt
TODO


How I set up my blog site
Posted Updated Notea minute read (About 211 words)

How I set up my blog site

This post record the steps I set up this blog site.

Catalog

Env preparation

Installation

Use following command to confirm:

1
2
3
$ node -v
$ npm -v
$ git --version

Github

Connection

Create and copy SSH key:

1
2
3
$ ssh-keygen -t rsa -C "GitHub email"
$ cd ~/.ssh
$ vim id_rsa.pub

Copy the contents

Go to Github -> Settings and Add SSH key

Confirm the connection:

1
$ ssh -T git@github.com

Setup Github Pages repository

Create Username.github.io(your URL)

Install Hexo

1
$ npm install -g hexo-cli

Setup a local workspace:

1
2
3
$ git init
$ hexo init
$ npm install

launch local server:

1
2
3
$ hexo cl
$ hexo g
$ hexo s

or use following command to specify port:

1
$ hexo server -p 5000

visit http://localhost:4000

Deploy to Github server

Install hexo-developer-git:

1
$ npm install hexo-deployer-git --save

edit _config file’s Deployment part:

1
2
3
4
deploy:
  type: git
  repository: git@github.com:Chen-Yulin/Chen-Yulin.github.io.git
  branch: master

then run in bash:

1
$ hexo d
Hexo Start
Posted Updated Notea minute read (About 123 words)

Hexo Start

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1
$ hexo new "My New Post"

More info: Writing

Run server

1
$ hexo server

More info: Server

Generate static files

1
$ hexo generate

More info: Generating

Deploy to remote sites

1
$ hexo deploy

More info: Deployment

Follow

Archives

Recents

Tags

6-D2
AI7
AIGC1
AR1
Behaviorism1
CADC1
CD1
CNN1
CSharp1
CV3
Capstone10
Control1
Discrete-Mathematics1
ESP322
Embeded-System9
Foundation1
Functional programming1
GPT3
Game4
Github1
HTML1
Haskell1
Hexo2
Humanism1
IK1
Information1
Javascript1
LSP2
Latex1
LinearAlgebra1
ML1
Method1
Mod3
Music3
NLP3
Network2
OpenCV1
PHD1
PSY4
Planning1
Plugin1
Postgraduate1
Prefab1
Probability1
Python1
Pytorch1
Quantum1
RNN3
ROS3
Reading13
Robot2
SJTU-Lecture1
SQL2
Script1
Shader2
Signals and Systems1
Snippets1
Star-rail1
TOEFL1
Tech Communication1
Transoformer1
Unity19
VideoEditing1
Vim1
WSL1
Web1
academic-ability1
app3
autonomousDriving2
beautify1
bs41
c1
comment&doc1
course1
csharp7
css1
dataframe1
debate5
docs1
dynamic-programmming1
emoation1
emotion6
ethic1
family1
git5
health1
hexo5
html3
idea1
javascript2
json1
linux9
live2d1
mason1
math1
meeting1
meme1
motivation1
movie1
music2
nodejs1
numpy1
nvim3
operational-ability1
oral1
pandas2
path1
philosophy1
pio2
plugin2
python13
recursive1
reference1
regex2
reinforcement-learning1
repository2
scrap1
shell3
sklearn1
society1
ssh1
start-business1
submodule1
supervised-learning2
thought1
travel2
unsupervised-learning1
version-management1
website1
well-being1
window-manager2
ykll2
zen1
🐱1
×