Миф о бесконечном масштабировании или когда ИИшка упрется в потолок

import matplotlib.pyplot as plt

# Screen resolution (width x height)
screen_width = 640
screen_height = 480

# List of circles, each represented by [x_center, y_center, diameter]
circles_data = [
    [100, 100, 50],   # Circle at position (100, 100), diameter=50
    [200, 200, 70],   # Circle at position (200, 200), diameter=70
    [300, 300, 30],   # Circle at position (300, 300), diameter=30
    [400, 400, 60],   # Circle at position (400, 400), diameter=60
    [500, 50, 40],    # Circle at position (500, 50), diameter=40
]

fig, ax = plt.subplots(figsize=(screen_width/100, screen_height/100))  # Convert pixel units to inches for figure size

for data in circles_data:
    x, y, d = data
    radius = d / 2  # Diameter divided by 2 gives radius
    
    # Create a circle patch object centered at (x, y) with given radius
    circle = plt.Circle((x, y), radius, edgecolor='black', facecolor='none')
    ax.add_patch(circle)

ax.set_xlim([0, screen_width])
ax.set_ylim([0, screen_height])
plt.axis('equal')  # Ensure equal scaling between X and Y axes
plt.title("Circles Visualization")
plt.show()

import matplotlib.pyplot as plt

class Circle:
    def __init__(self, x0, y0, diameter):
        self.x0 = x0      # Center coordinate along x-axis
        self.y0 = y0      # Center coordinate along y-axis
        self.diameter = diameter  # Diameter of the circle
        
    @property
    def radius(self):
        return self.diameter / 2  # Radius calculation (diameter / 2)
    
    def draw(self, ax):
        """
        Draws the circle on provided Axes object 'ax'.
        """
        circle_patch = plt.Circle(
            (self.x0, self.y0),
            self.radius,
            color="blue",
            fill=False,
            linewidth=2
        )
        ax.add_patch(circle_patch)

# Set up the display window dimensions
screen_width = 640
screen_height = 480

# Define some circles with various positions and sizes
circle1 = Circle(x0=100, y0=100, diameter=50)
circle2 = Circle(x0=200, y0=200, diameter=70)
circle3 = Circle(x0=300, y0=300, diameter=30)
circle4 = Circle(x0=400, y0=400, diameter=60)
circle5 = Circle(x0=500, y0=50, diameter=40)

# Prepare the plot
fig, ax = plt.subplots(figsize=(screen_width/100, screen_height/100))

# Add each circle to the plot
for c in [circle1, circle2, circle3, circle4, circle5]:
    c.draw(ax)

# Adjust axis limits and aspect ratio
ax.set_xlim(0, screen_width)
ax.set_ylim(0, screen_height)
ax.set_aspect('equal')  # Equal scaling ensures circles appear circular not oval

# Show the final visualization
plt.title("Collection of Circles")
plt.show()

import matplotlib.pyplot as plt
import numpy as np

# Base class representing non-colored circles
class BaseCircle:
    def __init__(self, x0, y0, diameter):
        self.x0 = x0              # x-coordinate of center
        self.y0 = y0              # y-coordinate of center
        self.diameter = diameter  # Diameter of the circle
    
    @property
    def radius(self):
        return self.diameter / 2  # Compute radius from diameter
    
    def draw(self, ax):
        """Draws the outline of the circle."""
        circle_outline = plt.Circle(
            (self.x0, self.y0),
            self.radius,
            color="black",
            fill=False,
            linewidth=2
        )
        ax.add_patch(circle_outline)

# Subclass extending BaseCircle with color capability
class ColoredCircle(BaseCircle):
    def __init__(self, x0, y0, diameter, color):
        super().__init__(x0, y0, diameter)  # Initialize parent class attributes
        self.color = color                 # Additional color attribute
    
    def draw(self, ax):
        """Draws the filled circle with chosen color."""
        circle_filled = plt.Circle(
            (self.x0, self.y0),
            self.radius,
            color=self.color,
            fill=True,
            alpha=0.7,                    # Translucent appearance
            linewidth=2
        )
        ax.add_patch(circle_filled)

# Screen settings
screen_width = 640
screen_height = 480

# Colors for ColoredCircle instances
colors = ['red', 'green', 'blue', 'cyan']

# Generate random circles dynamically
base_circles = []       # Collection of BaseCircle instances
colored_circles = []    # Collection of ColoredCircle instances

for _ in range(10):    # Total 10 random circles
    x0 = np.random.randint(screen_width//10, screen_width-screen_width//10)
    y0 = np.random.randint(screen_height//10, screen_height-screen_height//10)
    diameter = np.random.uniform(20, 100)
    
    # Decide whether it's a base circle or colored circle
    if np.random.rand() > 0.5:  # Probability-based decision
        # Colored circle
        selected_color = np.random.choice(colors)
        col_circle = ColoredCircle(x0, y0, diameter, selected_color)
        colored_circles.append(col_circle)
    else:
        # Regular circle
        base_circle = BaseCircle(x0, y0, diameter)
        base_circles.append(base_circle)

# Drawing procedure
fig, ax = plt.subplots(figsize=(screen_width/100, screen_height/100))

# Render all base circles first
for bc in base_circles:
    bc.draw(ax)

# Then render all colored circles
for cc in colored_circles:
    cc.draw(ax)

# Configure plot layout
ax.set_xlim(0, screen_width)
ax.set_ylim(0, screen_height)
ax.set_aspect('equal')  # Ensures proper scaling

plt.title("Dynamically Generated Base vs Colored Circles")
plt.show()

import matplotlib.pyplot as plt
import numpy as np

# Base class representing non-colored circles
class BaseCircle:
    def __init__(self, x0, y0, diameter):
        self.x0 = x0              # x-coordinate of center
        self.y0 = y0              # y-coordinate of center
        self.diameter = diameter  # Diameter of the circle
    
    @property
    def radius(self):
        return self.diameter / 2  # Compute radius from diameter
    
    def draw(self, ax):
        """Draws the outline of the circle."""
        circle_outline = plt.Circle(
            (self.x0, self.y0),
            self.radius,
            color="black",
            fill=False,
            linewidth=2
        )
        ax.add_patch(circle_outline)

# Subclass extending BaseCircle with color capability
class ColoredCircle(BaseCircle):
    def __init__(self, x0, y0, diameter, color):
        super().__init__(x0, y0, diameter)  # Initialize parent class attributes
        self.color = color                 # Additional color attribute
    
    def draw(self, ax):
        """Draws the filled circle with chosen color."""
        circle_filled = plt.Circle(
            (self.x0, self.y0),
            self.radius,
            color=self.color,
            fill=True,
            alpha=0.7,                    # Translucent appearance
            linewidth=2
        )
        ax.add_patch(circle_filled)

# Screen settings
screen_width = 640
screen_height = 480

# Available colors for ColoredCircle instances
colors = ['red', 'green', 'blue', 'cyan']

# Single list holding all circle objects (both BaseCircle and ColoredCircle)
all_circles = []

# Dynamic generation of random circles
for _ in range(15):  # Total 15 random circles
    x0 = np.random.randint(screen_width//10, screen_width-screen_width//10)
    y0 = np.random.randint(screen_height//10, screen_height-screen_height//10)
    diameter = np.random.uniform(20, 100)
    
    # Decide probabilistically whether it's a base circle or colored circle
    if np.random.rand() > 0.5:  # Probability-based choice
        # Create a ColoredCircle instance
        selected_color = np.random.choice(colors)
        col_circle = ColoredCircle(x0, y0, diameter, selected_color)
        all_circles.append(col_circle)
    else:
        # Create a BaseCircle instance
        base_circle = BaseCircle(x0, y0, diameter)
        all_circles.append(base_circle)

# Drawing routine
fig, ax = plt.subplots(figsize=(screen_width/100, screen_height/100))

# Unify iteration over both types of circles
for circle in all_circles:
    circle.draw(ax)  # Polymorphic call to draw(), handled appropriately per type

# Configuring plot aesthetics
ax.set_xlim(0, screen_width)
ax.set_ylim(0, screen_height)
ax.set_aspect('equal')  # Equivalent scaling for perfect circles

plt.title("Mixed Display of Base and Colored Circles")
plt.show()

import matplotlib.pyplot as plt
import numpy as np

# Simple circle class with coordinate clamping
class BaseCircle:
    def __init__(self, x0, y0, diameter):
        # Validate and clamp coordinates
        self.x0 = np.clip(x0, 0, 320)    # Saturation enforced
        self.y0 = np.clip(y0, 0, 200)    # Saturation enforced
        self.diameter = diameter          # Assume valid diameter input
    
    @property
    def radius(self):
        return self.diameter / 2          # Derived radius computation
    
    def draw(self, ax):
        """Draws the outline of the circle."""
        circle_outline = plt.Circle(
            (self.x0, self.y0),
            self.radius,
            color="black",
            fill=False,
            linewidth=2
        )
        ax.add_patch(circle_outline)

# Extended class supporting color-filling
class ColoredCircle(BaseCircle):
    def __init__(self, x0, y0, diameter, color):
        super().__init__(x0, y0, diameter)  # Parent initialization handles validation
        self.color = color                   # Additional color attribute
    
    def draw(self, ax):
        """Draws the filled circle with chosen color."""
        circle_filled = plt.Circle(
            (self.x0, self.y0),
            self.radius,
            color=self.color,
            fill=True,
            alpha=0.7,                      # Translucent shading
            linewidth=2
        )
        ax.add_patch(circle_filled)

# Screen specifications
screen_width = 640
screen_height = 480

# Valid diameter range derived from screen size
min_diameter = screen_width / 10
max_diameter = screen_height / 3

# Palette of possible colors
colors = ['red', 'green', 'blue', 'cyan']

# Container for storing circle objects
all_circles = []

# Dynamically generate 15 circles with constrained parameters
for _ in range(15):
    # Randomly choose coordinates within saturation limits
    x0 = np.random.randint(0, screen_width)         # 0 <= x0 <= screen_width
    y0 = np.random.randint(0, screen_height)        # 0 <= y0 <= screen_height
    
    # Random diameter selection within permissible range
    diameter = np.random.uniform(min_diameter, max_diameter)
    
    # Choose between BaseCircle and ColoredCircle probabilistically
    if np.random.rand() > 0.5:
        # Create a ColoredCircle instance
        sel_color = np.random.choice(colors)
        col_circle = ColoredCircle(x0, y0, diameter, sel_color)
        all_circles.append(col_circle)
    else:
        # Create a BaseCircle instance
        base_circle = BaseCircle(x0, y0, diameter)
        all_circles.append(base_circle)

# Setup for drawing
fig, ax = plt.subplots(figsize=(screen_width/100, screen_height/100))

# Draw all circles
for circle in all_circles:
    circle.draw(ax)  # Invokes respective draw method

# Fine-tune plot settings
ax.set_xlim(0, screen_width)
ax.set_ylim(0, screen_height)
ax.set_aspect('equal')  # Equivalent scaling prevents distortion

plt.title("Circling Within Constraints: Mixed Types")
plt.show()