OpenCV Operations

import cv2, numpy as np

image = cv2.imread('TT.jpeg')

#cv2.imshow('Image', image)

cv2.waitKey(0)  # Wait indefinitely (0) for key press

cv2.destroyAllWindows()

resized = cv2.resize(image, (400, 400))  # Resize to 400x400 pixels

#cv2.imshow('Resized', resized)

cv2.waitKey(0)

cv2.destroyAllWindows()

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

#cv2.imshow('Gray Image', gray)

cv2.waitKey(0)

cv2.destroyAllWindows()

edges = cv2.Canny(gray, threshold1=50, threshold2=150)

#cv2.imshow('Edges', edges)

cv2.waitKey(0)

cv2.destroyAllWindows()

kernel = np.ones((5, 5), np.uint8)

eroded = cv2.erode(image, kernel, iterations=1)

dilated = cv2.dilate(image, kernel, iterations=1)

#cv2.imshow('Eroded', eroded);  cv2.moveWindow("Eroded", 0, 0)

#cv2.imshow('Dilated', dilated);  cv2.moveWindow("Dilated", 950, 0)

#cv2.waitKey(0)

#cv2.destroyAllWindows()

opened = cv2.dilate(eroded, kernel, iterations=1)

closed = cv2.erode(dilated, kernel, iterations=1)

#cv2.imshow('Opened', opened);  cv2.moveWindow("Opened", 0, 500)

#cv2.imshow('Closed', closed);  cv2.moveWindow("Closed", 950, 500)

cv2.waitKey(0)

cv2.destroyAllWindows()

equalized = cv2.equalizeHist(gray) # Increases contrast

#cv2.imshow('Equalized', equalized)

cv2.waitKey(0)

cv2.destroyAllWindows()

hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

#cv2.imshow('HSV', hsv)

cv2.waitKey(0)

cv2.destroyAllWindows()

image1 = cv2.imread('View1.png') # Uploaded to drive

image2 = cv2.imread('View2.png') # Uploaded to drive

#cv2.imshow('Image1', image1)

#cv2.imshow('Image2', image2)

stitcher = cv2.Stitcher.create()

(status, stitched_image) = stitcher.stitch([image1, image2])

if status == cv2.STITCHER_OK:

  #cv2.imshow('Stitched Image', stitched_image)

  cv2.waitKey(0)

  cv2.destroyAllWindows()

else:

  print("Image stitching failed. Status:", status)

    

face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

image = cv2.imread('Crowd.jpg') # Uploaded to drive

gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

faces = face_cascade.detectMultiScale(gray_image, scaleFactor=1.1, minNeighbors=5)

for (x, y, w, h) in faces:

  cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)

#cv2.imshow('Face Detection', image)

cv2.waitKey(0)

cv2.destroyAllWindows()

image = cv2.imread('Traffic signal.jpg')

image = cv2.imread('Traffic.png')

gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

edges = cv2.Canny(gray_image, threshold1=50, threshold2=150)

kernel = np.ones((5, 5), np.uint8)

dilated = cv2.dilate(edges, kernel, iterations=1)

contours, _ = cv2.findContours(dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

for contour in contours:

  if cv2.contourArea(contour) > 100:

    x, y, w, h = cv2.boundingRect(contour)

    cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)

cv2.imshow('Traffic Sign Detection', image)

cv2.waitKey(0)

cv2.destroyAllWindows()

from ultralytics import YOLO

model = YOLO("yolo11n.pt")

image = cv2.imread("Traffic.png") # Uploaded to drive

results = model(image)

for result in results:

  for box in result.boxes:

    class_id = int(box.cls[0])

    class_name = model.names[class_id]

    x1, y1, x2, y2 = map(int, box.xyxy[0])

    cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)

    cv2.putText(image, class_name, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)

cv2.imshow("Vehicle Detection", image)

cv2.waitKey(0)

cv2.destroyAllWindows()

Turning GitHub pages as live websites

• Create the repository on GitHub.

a) Click → New repository
b) Give it a name, e.g. reinforcement-learning-game
c) Choose Public if you're using GitHub Free.
d) Click Create repository.

• Upload your files in the repository's main folder.

• Turn on GitHub Pages.

a) In the repository: Settings → Pages

b) Under Build and deployment:

•    Source: Deploy from a branch
•    Select Branch: main Folder: / (root)
•    Click Save.

• Get your webpage URL.

a) Repository URL: Shows your source files and GitHub repository.

      https://github.com/BinoyThomas1108/ReInforcement-Learning-1

b) Live webpage URL: Runs your index.html as a webpage.

      https://binoythomas1108.github.io/ReInforcement-Learning-1/

Python GUI to delete (extract) pages from PDF

from tkinter import *

from tkinter import filedialog, messagebox

from PIL import Image, ImageTk

import fitz

root = Tk()

root.title("PDF Page Viewer")

root.geometry("900x700")

pdf_doc = None

pdf_path = ""

current_page = 0

deleted_pages = set()

frame = Frame(root)

frame.pack(fill=BOTH, expand=True)

canvas = Canvas(frame, bg="gray")

canvas.pack(fill=BOTH, expand=True)

button_frame = Frame(root)

button_frame.pack(fill=X)

img_tk = None

def open_pdf():

  global pdf_doc, pdf_path, current_page, deleted_pages

  path = filedialog.askopenfilename(filetypes=[("PDF Files", "*.pdf")])

  if not path:

    return

  pdf_path = path

  pdf_doc = fitz.open(path)

  current_page = 0

  deleted_pages = set()

  show_page()

def valid_pages():

  return [i for i in range(len(pdf_doc)) if i not in deleted_pages]

def show_page():

  global img_tk

  if pdf_doc is None:

    return

  pages = valid_pages()

  if not pages:

    canvas.delete("all")

    messagebox.showinfo("Info", "No pages remaining")

    return

  page_number = pages[current_page]

  page = pdf_doc.load_page(page_number)

  pix = page.get_pixmap(matrix=fitz.Matrix(2, 2))

  img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)

  canvas_width = canvas.winfo_width()

  canvas_height = canvas.winfo_height()

  if canvas_width > 1 and canvas_height > 1:

    img.thumbnail((canvas_width, canvas_height))

  img_tk = ImageTk.PhotoImage(img)

  canvas.delete("all")

  canvas.create_image(

    canvas.winfo_width() // 2,

    canvas.winfo_height() // 2,

    image=img_tk,

    anchor=CENTER

  )

  root.title(f"PDF Viewer - Page {current_page + 1} of {len(pages)}")

def next_page():

  global current_page

  if pdf_doc is None:

    return

  pages = valid_pages()

  if current_page < len(pages) - 1:

    current_page += 1

    show_page()

def delete_page():

  global current_page

  if pdf_doc is None:

    return

  pages = valid_pages()

  if not pages:

    return

  page_to_delete = pages[current_page]

  deleted_pages.add(page_to_delete)

  remaining = valid_pages()

  if current_page >= len(remaining) and current_page > 0:

    current_page -= 1

  show_page()

def save_pdf():

  if pdf_doc is None:

    return

  pages = valid_pages()

  if not pages:

    messagebox.showerror("Error", "No pages to save")

    return

  save_path = filedialog.asksaveasfilename(

    defaultextension=".pdf",

    filetypes=[("PDF Files", "*.pdf")]

  )

  if not save_path:

    return

  new_pdf = fitz.open()

  for p in pages:

    new_pdf.insert_pdf(pdf_doc, from_page=p, to_page=p)

  new_pdf.save(save_path)

  new_pdf.close()

  messagebox.showinfo("Saved", "PDF saved successfully")

Button(button_frame, text="OPEN PDF", command=open_pdf).pack(side=LEFT, padx=10, pady=10)

Button(button_frame, text="NEXT", command=next_page).pack(side=LEFT, padx=10, pady=10)

Button(button_frame, text="DELETE", command=delete_page).pack(side=LEFT, padx=10, pady=10)

Button(button_frame, text="SAVE", command=save_pdf).pack(side=LEFT, padx=10, pady=10)

canvas.bind("<Configure>", lambda e: show_page())

root.mainloop()

Download YouTube video using yt-dlp

# pip install yt-dlp

import yt_dlp

def download_youtube_video(url, save_path='.'):

  ydl_opts = {'outtmpl': f'{save_path}/%(title)s.%(ext)s', 'format': 'best'

  }

  try:

    with yt_dlp.YoutubeDL(ydl_opts) as ydl:

      ydl.download([url])

    print("Download completed!")

  except Exception as e:

    print(f"An error occurred: {e}")

video_url = "https://www.youtube.com/watch?v=tAEek8nO11c"

download_youtube_video(video_url)

Remove pages from PDF

from PyPDF2 import PdfReader, PdfWriter

input_file = "00 CTAI Curriculum 3 to 8.pdf"

output_file = "00 CTAI Curriculum 3 to 8 Abridged.pdf"

pages_to_remove = [1, 3, 5, 7, 31]

reader = PdfReader(input_file)

writer = PdfWriter()

for i in range(len(reader.pages)):

  if i not in pages_to_remove:

    writer.add_page(reader.pages[i])

with open(output_file, "wb") as f:

  writer.write(f)

Create YouTube link to start at a particular time

Original link: https://www.youtube.com/live/TPDzPcU8Esk?feature=shared

Timed link:    https://youtu.be/TPDzPcU8Esk?t=38m8s

Soccer ball Football in Python Turtle

import turtle, math

screen = turtle.Screen()

screen.bgcolor("#1a1a2e")

screen.title("Soccer Ball")

screen.setup(700, 700)

screen.tracer(0)

t = turtle.Turtle()

t.hideturtle(); t.speed(0)

CX, CY, R = 0, 0, 220   # ball centre & radius in pixels

# ── Build 60 correct vertices of a truncated icosahedron ──────────

phi = (1 + math.sqrt(5)) / 2

def norm3(v):

  x, y, z = v

  d = math.sqrt(x*x+y*y+z*z)

  return (x/d,y/d,z/d)

def dot3(a,b):

  return a[0]*b[0]+a[1]*b[1]+a[2]*b[2]

def cross3(a,b):

  return(a[1]*b[2]-a[2]*b[1],a[2]*b[0]-a[0]*b[2],a[0]*b[1]-a[1]*b[0])

def sub3(a,b):

  return(a[0]-b[0],a[1]-b[1],a[2]-b[2])

raw = set()

for s1 in (-1,1):

  for s2 in (-1,1):

    raw.add((0,   s1,      s2*3*phi))

    raw.add((s2*3*phi, 0,    s1))

    raw.add((s1,  s2*3*phi,  0))

    for s3 in (-1,1):

      raw.add((s1,    s2*(2+phi),   s3*2*phi))

      raw.add((s3*2*phi,  s1,       s2*(2+phi)))

      raw.add((s2*(2+phi),s3*2*phi,   s1))

      raw.add((s1*2,    s2*(1+2*phi), s3*phi))

      raw.add((s3*phi,  s1*2,     s2*(1+2*phi)))

      raw.add((s2*(1+2*phi), s3*phi,  s1*2))

verts = [norm3(v) for v in raw]   # 60 unit-sphere vertices

N = len(verts)

# ── Adjacency (shortest edge) 

def d3(a,b): return math.sqrt(sum((a[k]-b[k])**2 for k in range(3)))

min_d = min(d3(verts[i],verts[j]) for i in range(N) for j in range(i+1,N))

ETOL  = 0.02

adj   = [[] for _ in range(N)]

for i in range(N):

  for j in range(i+1,N):

    if abs(d3(verts[i],verts[j])-min_d) < ETOL:

      adj[i].append(j); adj[j].append(i)

# ── Face enumeration via half-edge walk 

def next_vert(i, j):

  """Return k: the next vertex CCW around the face containing directed edge i→j."""

  others = [k for k in adj[j] if k != i]

  if len(others) == 1:

    return others[0]

  nj = verts[j]

  raw_in  = sub3(verts[i], nj)

  proj_in = dot3(raw_in, nj)

  tang_in = (raw_in[0]-proj_in*nj[0], raw_in[1]-proj_in*nj[1], raw_in[2]-proj_in*nj[2])

  mag = math.sqrt(dot3(tang_in,tang_in))

  if mag > 1e-10: tang_in = tuple(c/mag for c in tang_in)

  best, best_k = None, None

  for k in others:

    raw_out  = sub3(verts[k], nj)

    proj_out = dot3(raw_out, nj)

    tang_out = (raw_out[0]-proj_out*nj[0], raw_out[1]-proj_out*nj[1], raw_out[2]-proj_out*nj[2])

    cr   = cross3(tang_in, tang_out)

    sine = dot3(cr, nj)

    cosine = dot3(tang_in, tang_out)

    angle = math.atan2(sine, cosine)

    if best is None or angle < best:

      best, best_k = angle, k

  return best_k

face_set, face_list = set(), []

for i in range(N):

  for j in adj[i]:

    face = [i, j]

    ci, cj = i, j

    for _ in range(7):

      k = next_vert(ci, cj)

      if k == i: break

      face.append(k); ci, cj = cj, k

    key = frozenset(face)

    if key not in face_set and len(face) in (5, 6):

      face_set.add(key); face_list.append(face)

# ── Rotation & projection 

AY, AX = 0.52, -0.28

def rotate(v, ay, ax):

  x,y,z = v

  x2 =  x*math.cos(ay)+z*math.sin(ay); z2 = -x*math.sin(ay)+z*math.cos(ay); y2=y

  y3 =  y2*math.cos(ax)-z2*math.sin(ax); z3 = y2*math.sin(ax)+z2*math.cos(ax)

  return (x2, y3, z3)

def project(v):

  x,y,z = rotate(v, AY, AX)

  fov   = 3.8

  s   = R * fov / (fov + z + 1)

  return (CX + x*s, CY + y*s, z)

# ── Lighting / shading 

LIGHT = norm3((0.5, 0.7, 1.0))

def shade(face_idxs, is_pent):

  fv  = [verts[i] for i in face_idxs]

  cn  = norm3(tuple(sum(v[k] for v in fv)/len(fv) for k in range(3)))

  rcn = rotate(cn, AY, AX)

  diff = max(0.0, dot3(rcn, LIGHT))

  spec = max(0.0, diff)**12 * 0.5

  if is_pent:

    bright = 0.15 + 0.65*diff + spec

    base   = (18, 18, 18)

  else:

    bright = 0.38 + 0.55*diff + spec

    base   = (248, 248, 248)

  r = int(min(255, base[0]*bright + 255*spec))

  g = int(min(255, base[1]*bright + 255*spec))

  b = int(min(255, base[2]*bright + 255*spec))

  return f"#{r:02x}{g:02x}{b:02x}"

# ── Drawing helpers 

def draw_disk(x, y, r, fill, pen, lw=2):

  t.penup()

  t.goto(x, y-r)

  t.pendown()

  t.pencolor(pen)

  t.pensize(lw)

  t.fillcolor(fill)

  t.begin_fill()

  t.end_fill()

def draw_poly(pts, fill, pen, lw):

  t.penup(); t.goto(pts[0]); t.pendown()

  t.pencolor(pen); t.pensize(lw); t.fillcolor(fill)

  t.begin_fill()

  for p in pts[1:]: t.goto(p)

  t.goto(pts[0]); t.end_fill()

def in_ball(px, py):

  return (px-CX)**2+(py-CY)**2 <= R**2

# ── RENDER 

# Ground shadow

t.penup(); t.pencolor("#0c0c1a"); t.fillcolor("#0c0c1a")

sw, sh = 170, 22

t.goto(CX-sw, CY-R-14); t.pendown(); t.begin_fill()

for s in range(61):

  a = math.pi + s*math.pi/60

  t.goto(CX+sw*math.cos(a), CY-R-14+sh*math.sin(a))

t.end_fill()

# White ball base

draw_disk(CX, CY, R, "white", "#1a1a1a", lw=3)

# Sort faces back→front and draw

sorted_faces = sorted(face_list, key=lambda f: sum(project(verts[i])[2] for i in f)/len(f))

for face in sorted_faces:

  projs  = [project(verts[i]) for i in face]

  avg_z  = sum(p[2] for p in projs)/len(projs)

  if avg_z < -0.10:

    continue              # back-face cull

  pts2d  = [(p[0],p[1]) for p in projs]

  if not any(in_ball(px,py) for px,py in pts2d):

    continue

  is_pent = len(face) == 5

  col   = shade(face, is_pent)

  pen   = "#000000" if is_pent else "#555555"

  lw    = 2.5 if is_pent else 1.2

  draw_poly(pts2d, col, pen, lw)

# Clean ball outline

t.penup(); t.goto(CX, CY-R); t.pendown()

t.pencolor("#111111"); t.pensize(4); t.fillcolor("")

# Specular highlights

for hx,hy,hr,col in [(CX-65,CY+80,40,"#ffffff"),(CX-55,CY+68,20,"#ffffff")]:

  t.penup(); t.goto(hx,hy-hr); t.pendown()

  t.pencolor(col); t.pensize(1); t.fillcolor(col)

  t.begin_fill()

  t.end_fill()

screen.update()

turtle.done()