import random
import matplotlib.pyplot as plt

def estimate_pi(n):
    num_points_circle = 0
    num_points_total = 0
    circle_x, circle_y = [], []
    square_x, square_y = [], []

    # Loop for generating random points and estimating π
    for _ in range(n):
        x = random.uniform(-1, 1)
        y = random.uniform(-1, 1)
        distance = x**2 + y**2
        if distance <= 1:
            num_points_circle += 1
            circle_x.append(x)
            circle_y.append(y)
        else:
            square_x.append(x)
            square_y.append(y)
        num_points_total += 1

    # Plotting the points on a graph
    plt.figure(figsize=(5, 5))
    plt.scatter(circle_x, circle_y, color='blue', s=0.1)
    plt.scatter(square_x, square_y, color='red', s=0.1)
    plt.xlim(-1.1, 1.1)
    plt.ylim(-1.1, 1.1)
    plt.title("Estimation of π using the Monte Carlo method\nN = {}".format(n))
    plt.show()

    # Calculating and returning the estimated value of π
    return 4 * num_points_circle / num_points_total

print(estimate_pi(10000))

import cv2
import numpy as np
import random

# Load the image and convert it to grayscale
img = cv2.imread("/Users/.../falcon2.png", cv2.IMREAD_GRAYSCALE)

# Apply thresholding to get a binary image
ret, thresh = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)

# Invert the colors so that black becomes white and vice versa
thresh = cv2.bitwise_not(thresh)

# Find contours in the image
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# Create a black image to draw the contours
contour_img = np.zeros((img.shape[0], img.shape[1], 3), np.uint8)

# Draw the contours in white on the black image
cv2.drawContours(contour_img, contours, -1, (255, 255, 255), 2)

# Get the size of the image in pixels
height, width = img.shape[:2]

# Retrieve the size of the image in pixels
size = img.shape[:2]

# Define the real dimensions of the Millennium Falcon
real_length = 35  # in meters
real_width = 25   # in meters

# Define the resolution of the image in pixels/meter
resolution = 144

# Calculate the total number of pixels of the ship's surface
total_surface_pixels = int(real_length * real_width * resolution**2)

# Number of random points to generate for the estimation
n = 1000000

# Number of points inside the black figure
num_points_inside = 0

# Generate random points in the image and count the number of points inside the black figure
for i in range(n):
    # Generate a random point in the image
    x = random.randint(0, width-1)
    y = random.randint(0, height-1)

    # Check if the point is inside the black figure
    if cv2.pointPolygonTest(contours[0], (x, y), False) == 1:
        num_points_inside += 1
        # Draw the point in blue
        cv2.circle(contour_img, (x, y), 1, (255, 0, 0), -1)
    else:
        # Draw the point in red
        cv2.circle(contour_img, (x, y), 1, (0, 0, 255), -1)

# Estimation of the area of the black figure using the Monte Carlo method
estimated_area = (num_points_inside / n) * (width * height)

# Display the image with points in blue and red
cv2.imshow('Image with points', contour_img)

# Wait for the user to press a key to close the window
cv2.waitKey(0)
cv2.destroyAllWindows()

# Display the estimated area of the black figure
print("Estimated area of the black figure:", estimated_area)

import random
import math
import matplotlib.pyplot as plt

num_shots = 1000000
circle_hits = 0
square_hits = 0
circle_x = []
circle_y = []
square_x = []
square_y = []

for i in range(num_shots):
    x = random.gauss(0, 0.05) # shots centered at the circle's center
    y = random.gauss(0, 0.05)
    distance = math.sqrt(x**2 + y**2)
    if distance <= 1:
        circle_hits += 1
        circle_x.append(x)
        circle_y.append(y)
    else:
        square_x.append(x)
        square_y.append(y)
    square_hits += 1
    if random.random() < 0.1: # 10% chance of shooting in the circle
        if distance <= 1:
            circle_hits -= 1
            circle_x.pop()
            circle_y.pop()
        else:
            circle_hits += 1
            circle_x.append(x)
            circle_y.append(y)
        square_hits -= 1

pi_estimation = 4 * circle_hits / square_hits
print("Estimation of pi:", pi_estimation)

fig, ax = plt.subplots(figsize=(6, 6))
ax.set_xlim([-1.2, 1.2])
ax.set_ylim([-1.2, 1.2])
ax.set_aspect('equal')
ax.scatter(square_x, square_y, color='red', s=1, label='Outside the circle')
ax.scatter(circle_x, circle_y, color='blue', s=1, label='Inside the circle')
circle = plt.Circle((0, 0), 1, color='black', fill=False)
ax.add_artist(circle)
ax.legend()
plt.show()