# python3 hello.py 
def main():
  print("Hello World!")
main()

# python3 sys_test.py
import sys
print(f"sys.argv is a list, length: {len(sys.argv)}")
print("The first argument of sys.argv is you filename: ")
print(sys.argv[0])
print("The second argument of sys.argv: ")
print(sys.argv[1])
print("The third argument of sys.argv: ")
print(sys.argv[2])
print("The last argument of sys.argv: ")
print(sys.argv[3])

# python3 argarse_positional_args.py
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("arg1",
                    nargs=3, # 限定引數數量為3
                    type=int, # 限定資料型態
                    help="This is the first argument,\
                    please input three intergers.")
parser.add_argument("arg2",
                    nargs='?', # 限定引數數量為0或1
                    default="NO_VALUE", # 無輸入時的預設值
                    help="This is the second argument,\
                    you can input an argument or not.")
parser.add_argument("arg3",
                    nargs='+', # 引數數量至少為1（1或任意多個）
                    help="This is the third argument,\
                    you can input one or more arguments.")
args = parser.parse_args()
print(args)

# python3 argparse_optional_args.py
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("first_position_arg",
                    nargs=2,
                    help="This is the first positional argument,\
                    please input two intergers.")
parser.add_argument("-a",
                    "--arg1",
                    type=str,
                    help="This is the first optional argument,\
                    please input a string.")
parser.add_argument("--arg2",
                    nargs=1,
                    type=int,
                    default=0,
                    help="This is the second positional argument\
                    please input an interger, or the default would be 0.")
args = parser.parse_args()
print(args)

# 節省時間，部分程式碼在此
zero_2_nine = {0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four',
               5: 'five', 6: 'six', 7: 'seven', 8: 'eight', 9: 'nine'}
ten_2_nineteen = {10: 'ten', 11: 'eleven', 12: 'twelve', 13: 'thirteen',
                  14: 'forteen', 15: 'fifteen', 16: 'sixteen', 17: 'seventeen',
                  18: 'eighteen', 19: 'nineteen'}
twenty_2_ninety = {20: 'twenty', 30: 'thirty', 40: 'forty', 50: 'fifty',
                   60: 'sixty', 70: 'seventy', 80: 'eighty', 90: 'ninety'}

# python3 num_en_convertion.py
from argparse import ArgumentParser

parser = ArgumentParser()
parser.add_argument("-n", help = "Enter a number from 0 to 99.")
args = vars(parser.parse_args())

digits = int(args['n']) % 10
tens = int(args['n']) - digits

zero_2_nine = {0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four',
               5: 'five', 6: 'six', 7: 'seven', 8: 'eight', 9: 'nine'}
ten_2_nineteen = {10: 'ten', 11: 'eleven', 12: 'twelve', 13: 'thirteen',
                  14: 'forteen', 15: 'fifteen', 16: 'sixteen', 
                  17: 'seventeen', 18: 'eighteen', 19: 'nineteen'}
twenty_2_ninety = {20: 'twenty', 30: 'thirty', 40: 'forty', 50: 'fifty',
                   60: 'sixty', 70: 'seventy', 80: 'eighty', 90: 'ninety'}

def number_2_words(num):
    if int(num) >= 100:
        print('input error')

    else:
        if int(num) < 10:
            print(zero_2_nine[digits])
        elif int(num) < 20:
            print(ten_2_nineteen[int(num)])
        elif int(num) % 10 == 0:
            print(twenty_2_ninety[tens])
        else:
            print(twenty_2_ninety[tens], zero_2_nine[digits])
            
def main():
    number_2_words(args['n'])
    
main()

pip install opencv-python

python3 -m venv tutorial-env

# Windows:
tutorial-env\Scripts\activate

# Unix or MacOS:
source tutorial-env/bin/activate

pip install argparse

pip install opencv-python

# python3 opencv_get_started.py

# import the necessary packages
import argparse
import cv2

# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--image", type=str, default="adrian.png",
	help="path to the input image")
args = vars(ap.parse_args())

# load the image, grab its spatial dimensions (width and height),
# and then display the original image to our screen
image = cv2.imread(args["image"]) #read file
(h, w) = image.shape[:2] #抓取長寬
cv2.imshow("Original", image) #前者字串是圖片標題，後者是要顯示的圖片
cv2.waitKey(0) #按下任意鍵繼續

# images are simply NumPy arrays -- with the origin (0, 0) located at
# the top-left of the image
(b, g, r) = image[0, 0]
print("Pixel at (0, 0) - Red: {}, Green: {}, Blue: {}".format(r, g, b))

# access the pixel located at x=50, y=20
(b, g, r) = image[20, 50]
print("Pixel at (50, 20) - Red: {}, Green: {}, Blue: {}".format(r, g, b))

# update the pixel at (50, 20) and set it to red
image[20, 50] = (0, 0, 255)
(b, g, r) = image[20, 50]
print("Pixel at (50, 20) - Red: {}, Green: {}, Blue: {}".format(r, g, b))

# compute the center of the image, which is simply the width and height
# divided by two
(cX, cY) = (w // 2, h // 2) #取中心點

# since we are using NumPy arrays, we can apply array slicing to grab
# large chunks/regions of interest from the image -- here we grab the
# top-left corner of the image
tl = image[0:cY, 0:cX] #裁切圖片
cv2.imshow("Top-Left Corner", tl)
cv2.waitKey(0)

# in a similar fashion, we can crop the top-right, bottom-right, and
# bottom-left corners of the image and then display them to our
# screen
tr = image[0:cY, cX:w]
br = image[cY:h, cX:w]
bl = image[cY:h, 0:cX]
cv2.imshow("Top-Right Corner", tr)
cv2.waitKey(0)

cv2.imshow("Bottom-Right Corner", br)
cv2.waitKey(0)

cv2.imshow("Bottom-Left Corner", bl)
cv2.waitKey(0)

# set the top-left corner of the original image to be green
image[0:cY, 0:cX] = (0, 255, 0) #更改顏色呈綠色

# Show our updated image
cv2.imshow("Updated", image)
cv2.waitKey(0)

# Shut down
cv2.destroyAllWindows() #關閉所有視窗

# python3 opencv_get_started.py
import argparse
import cv2
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--image", type=str, default="adrian.png", help="path to the input image")
args = vars(ap.parse_args())
image = cv2.imread(args["image"])
(h, w) = image.shape[:2]
cv2.imshow("Original", image)
cv2.waitKey(0)
(b, g, r) = image[0, 0]
print("Pixel at (0, 0) - Red: {}, Green: {}, Blue: {}".format(r, g, b))
(b, g, r) = image[20, 50]
print("Pixel at (50, 20) - Red: {}, Green: {}, Blue: {}".format(r, g, b))
image[20, 50] = (0, 0, 255)
(b, g, r) = image[20, 50]
print("Pixel at (50, 20) - Red: {}, Green: {}, Blue: {}".format(r, g, b))
(cX, cY) = (w // 2, h // 2)
tl = image[0:cY, 0:cX]
cv2.imshow("Top-Left Corner", tl)
cv2.waitKey(0)
tr = image[0:cY, cX:w]
br = image[cY:h, cX:w]
bl = image[cY:h, 0:cX]
cv2.imshow("Top-Right Corner", tr)
cv2.waitKey(0)
cv2.imshow("Bottom-Right Corner", br)
cv2.waitKey(0)
cv2.imshow("Bottom-Left Corner", bl)
cv2.waitKey(0)
image[0:cY, 0:cX] = (0, 255, 0)
cv2.imshow("Updated", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

# python3 practice_1.py
import argparse
import cv2

ap = argparse.ArgumentParser()
ap.add_argument("-i", "--image", type=str, default="adrian.png",
	help="path to the input image")
args = vars(ap.parse_args())

image = cv2.imread(args["image"])
(h, w) = image.shape[:2]
cv2.imshow("Original", image)
cv2.waitKey(0)

(cX, cY) = (w // 2, h // 2)

tl = image[0:h, 0:cX]
cv2.imshow("Half-Left of the image", tl)
cv2.waitKey(0)

br = image[cY:h, cX:w]
cv2.imshow("Bottom-Right Corner", br)
cv2.waitKey(0)

image[0:cY, cX:w] = (255, 0, 0)
cv2.imshow("Updated", image)
cv2.waitKey(0)

cv2.destroyAllWindows()

# python3 opencv_basic_drawing.py

# import the necessary packages
import numpy as np
import cv2

# initialize our canvas as a 300x300 pixel image with 3 channels
# (Red, Green, and Blue) with a black background
canvas = np.zeros((300, 300, 3), dtype="uint8")

# draw a green line from the top-left corner of our canvas to the
# bottom-right
green = (0, 255, 0) #設定顏色
# cv2.line(畫布, 座標起始點, 座標終點, 顏色, 線寬)
# cv2.line(canvas, (x1, y1), (x2, y2), color)
cv2.line(canvas, (0, 0), (300, 300), green)
cv2.imshow("Canvas", canvas)
cv2.waitKey(0)

# draw a 3 pixel thick red line from the top-right corner to the
# bottom-left
red = (0, 0, 255) #(b, g, r)
cv2.line(canvas, (300, 0), (0, 300), red, 3)
cv2.imshow("Canvas", canvas)
cv2.waitKey(0)

# draw a green 50x50 pixel square, starting at 10x10 and ending at 60x60
cv2.rectangle(canvas, (10, 10), (60, 60), green)
cv2.imshow("Canvas", canvas)
cv2.waitKey(0)

# draw another rectangle, this one red with 5 pixel thickness
cv2.rectangle(canvas, (50, 200), (200, 225), red, 5)
cv2.imshow("Canvas", canvas)
cv2.waitKey(0)

# draw a final rectangle (blue and filled in )
blue = (255, 0, 0)
cv2.rectangle(canvas, (200, 50), (225, 125), blue, -1)
cv2.imshow("Canvas", canvas)
cv2.waitKey(0)

# re-initialize our canvas as an empty array, then compute the
# center (x, y)-coordinates of the canvas
canvas = np.zeros((300, 300, 3), dtype="uint8")
(centerX, centerY) = (canvas.shape[1] // 2, canvas.shape[0] // 2) #找圓心
white = (255, 255, 255)

# loop over increasing radii, from 25 pixels to 150 pixels in 25
# pixel increments
for r in range(0, 175, 25):
	# draw a white circle with the current radius size
	cv2.circle(canvas, (centerX, centerY), r, white)

# show our work of art
cv2.imshow("Canvas", canvas)
cv2.waitKey(0)

# re-initialize our canvas once again
canvas = np.zeros((300, 300, 3), dtype="uint8")

# let's draw 5 random circles
for i in range(0, 5):
	# randomly generate a radius size between 5 and 200, generate a
	# random color, and then pick a random point on our canvas where
	# the circle will be drawn
	radius = np.random.randint(5, high=200)
	color = np.random.randint(0, high=256, size=(3,)).tolist()
	# print(type(color))
	pt = np.random.randint(0, high=300, size=(2,))

	# draw our random circle on the canvas
	# we use a thickness of -1, so our circles are drawn as a solid color 
	# and not just an outline.
	# cv2.circle(canvas, center, radius, color, thickness)
	cv2.circle(canvas, tuple(pt), radius, color, 5)
	cv2.imshow("Canvas", canvas)
	cv2.waitKey(0)

# display our masterpiece to our screen
cv2.imshow("Canvas", canvas)
cv2.waitKey(0)

# python3 practice_2.py
import numpy as np
import cv2
import argparse
canvas = np.zeros((300, 300, 3), dtype="uint8")
parser = argparse.ArgumentParser()
parser.add_argument("-l", "--line", type=int, help="How many lines do you want to draw.")
parser.add_argument("-s", "--square", type=int, help="How many squares do you want to draw.")
parser.add_argument("-c", "--circle", type=int, help="How many circles do you want to draw.")
args = vars(parser.parse_args())
# random lines
for i in range(args["line"]):
    color = np.random.randint(0, high=256, size=(3,)).tolist()
    pt_s = np.random.randint(0, high=300, size=(2,))
    pt_e = np.random.randint(0, high=300, size=(2,))
    cv2.line(canvas, tuple(pt_s), tuple(pt_e), color, 5)
    cv2.imshow("Canvas", canvas)
    cv2.waitKey(0)
# random squares
for i in range(args["square"]):
    color = np.random.randint(0, high=256, size=(3,)).tolist()
    pt_s = np.random.randint(0, high=300, size=(2,))
    pt_e = np.random.randint(0, high=300, size=(2,))
    cv2.rectangle(canvas, tuple(pt_s), tuple(pt_e), color, 5)
    cv2.imshow("Canvas", canvas)
    cv2.waitKey(0)  
# random circles
for i in range(args["circle"]):
    radius = np.random.randint(5, high=200)
    color = np.random.randint(0, high=256, size=(3,)).tolist()
    pt = np.random.randint(0, high=300, size=(2,))
    cv2.circle(canvas, tuple(pt), radius, color, 5)
    cv2.imshow("Canvas", canvas)
    cv2.waitKey(0) 
cv2.destroyAllWindows()