This guide is for the wslg feature of windows 11.
Check for display:

1
2

$ echo $DISPLAY
:0

if not, change it with:

1

$ export DISPLAY=:0

check for X11 display socket

1
2

$ ls -la /tmp/.X11-unix
lrwxrwxrwx 1 spronovo spronovo 19 Apr 21 15:28 /tmp/.X11-unix -> /mnt/wslg/.X11-unix

This is setup during WSL’s INIT.
If doesn’t exist, re-create it to try things out:

1
2

$ sudo rm -r /tmp/.X11-unix
$ ln -s /mnt/wslg/.X11-unix /tmp/.X11-unix

Check whether X11 server is running:

1
2

$ ls /tmp/.X11-unix
X0

Catalog

• Course Introduction
  * Common Tenses and Voices
• Writing Email
• Resume
• CV
• Peer-reviewed Article Publishing
• Citation
• Technical Project Deliverables

Course Introduction

What is TC?
Communication that presents specific information to a specific audience for a specific purpose

• who is audience?
• what information are we commmunicating?
• why are we communicating

Criteria of TC:

• Accuracy
• Brevity
• • no need for complex sentense, idea itself is complicated enough
• Clarify

Topics:

• Workplace-related communications
• Technical project design through a problem-need-solution framework
• Diagrams and data visualization, reporting results
• Paraphrasing, direct quotation, citation(AIAA)
• presentation skills

Requirements

• No late homework submission
• Attendance and active participation
• HC & plagiarism

Common Tenses and Voices

Tenses

• Use present tense a lot.
• If action happens in the past and is done, use past tense (if is true till now, use present tense(project, theorms))

Voices

• Use active voice, engaged and easier to read
• Use passive voice to put emphasis on action or the subject is unknow
• Do not use we, be objective

Writing Email

Components:

• address lines
• subject line
• salutation
• introduction, body and conclusion
• closing
• signiture
• signiture section

Notes:

• no conversation
• don’t send confidential information
• one single page is enough
• forward to others only when is authorized
• pause before sending
• clean out mailboxes

Three different levels of formality:

1. Personal, brief notes
2. Memo style
3. Letter style: formal business emails

Be careful when using !, it is super strong tone, meaning frustrated, very very angry.

Resume

Common traits

How to state your impact?

• What was differnent or better when you finish?
• What were obstacles and how did you get around them?
• What did you learn in that experience?

Name & Time:

• Yulin Chen
• Chen, Yulin
• May 2022

#CV
Sections:

• Contact info
• Education
• Experience
• Teaching

Peer-reviewed Article Publishing

Process

• Manuscript prepared by authors
• Submission(System)
• • may reject by AI if format is wrong
• Initial Eval.(Managing editor)
• • may reject if logic wrong
• Editor’s Eval.(Chief editors)
• • if not good enough, may reject
• Reviewing(Reviewers)
• read review advice(Editor)
• • if need author’s Rev. give back to author, then submit again
• • no thing required, publish
• • or reject if still not good enough

Citation

• name [index]
• endOfSentense [index1-index2].
• • the sentense is a summary of works cited ad index1-index2(multiple references)
• endOfSentense. [index]
• • cover several sentenses ahead

General Rule : if not cited, you are claiming that it is your own work.
Five-consecutive-word Rule
So we need paraphrasing

• Use different vacabulary
• Change order of words
• Different grammar/sentense structure

Style:

• MLA
• • Modern Language Association
• APA
• CMS
• AAAS
• AIAA
• ACS
• IEEE has many different styles

Technical Project Deliverables

Deliverables:

• Project
• Solution
• Finding
• Publication
• Patent
  all end up with a report

TC element

• Audience
• • Potential/existing customers, fellow engineers, colleagues from other departments
• • Professors, classmates, staffs
• • General readers interested
• Information
• • Project’s ‘result’ (not everything of the project)
• Purpose
• • Promote new product, share experience, establish status within, provide solution…

General Design Logic

• Describe problem at hand
• • General/broad topic
• • Narrow down gradually
• Analyze need

Catalog

• Introduce
  • Motivation
  • Objective
• Implementation
  • Environment Preparation
  • Foundation
  • Code Review
    • Function detect_target
      • Overview
      • Get the estimated area of the target by color filtering

Introduce

Motivation

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

Objective

The input image looks like this:

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:

• For OpenCV
• • Bilibili video tutorial (Only 1-27 is required for this project)
• • Offical document
• For CNN(implemented by pytorch)
• • What is CNN
• • Official tutorial
• • Hand -written number recognition

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
    
    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?

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),

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)

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)

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

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,
...

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
...

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

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);

Search

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;
}