Анализ роста грибов с помощью Python

import plantcv as pcv

# Загрузка изображения
image, path, filename = pcv.readimage("mushroom.jpg")

# Сегментация грибов
mask = pcv.threshold.difference(image, (50, 50, 50), (255, 255, 255))

# Анализ параметров грибов
analysis = pcv.analyze.size(mask, image)

# Визуализация результатов
pcv.plot_image(analysis["image"])

import cv2
import numpy as np

# Загрузка изображения
image = cv2.imread('mushroom.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Бинаризация
_, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# Поиск контуров
contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# Анализ размеров грибов
for contour in contours:
 area = cv2.contourArea(contour)
 if area > 100: # Фильтрация маленьких объектов
 x, y, w, h = cv2.boundingRect(contour)
 cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2)

# Отображение результатов
cv2.imshow('Mushroom Analysis', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

from skimage import io, filters, measure, morphology
import matplotlib.pyplot as plt

# Загрузка изображения
image = io.imread('mushroom.jpg')
gray = image[:, :, 0] # Используем один канал для упрощения

# Предварительная обработка
filtered = filters.gaussian(gray, sigma=1)
thresh = filters.threshold_otsu(filtered)
binary = filtered > thresh

# Морфологические операции
cleaned = morphology.remove_small_objects(binary, min_size=50)
cleaned = morphology.remove_small_holes(cleaned, area_threshold=50)

# Метка регионов и анализ
label_image = measure.label(cleaned)
regions = measure.regionprops(label_image)

# Визуализация
fig, ax = plt.subplots()
ax.imshow(image)
ax.axis('off')

for region in regions:
 if region.area > 100:
 minr, minc, maxr, maxc = region.bbox
 rect = plt.Rectangle((minc, minr), maxc-minc, maxr-minr,
 fill=False, edgecolor='red', linewidth=2)
 ax.add_patch(rect)

plt.tight_layout()
plt.show()

import os
import pandas as pd
from skimage import io, measure

# Папка с изображениями по дням
image_folder = 'mushroom_growth/'

# Сбор данных о росте
growth_data = []

for day_folder in sorted(os.listdir(image_folder)):
 day_path = os.path.join(image_folder, day_folder)
 if os.path.isdir(day_path):
 for image_file in os.listdir(day_path):
 image_path = os.path.join(day_path, image_file)
 image = io.imread(image_path)
 gray = image[:, :, 0]
 
 # Анализ размеров
 label_image = measure.label(gray > 100)
 regions = measure.regionprops(label_image)
 
 for region in regions:
 if region.area > 50:
 growth_data.append({
 'day': int(day_folder),
 'area': region.area,
 'perimeter': region.perimeter,
 'eccentricity': region.eccentricity,
 'filename': image_file
 })

# Создание DataFrame для анализа
df = pd.DataFrame(growth_data)

# Анализ динамики роста
print(df.groupby('day')['area'].mean())

import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats

# Визуализация динамики роста
plt.figure(figsize=(12, 6))

# График среднего размера по дням
sns.lineplot(data=df, x='day', y='area', marker='o')

# Добавление тренда
x = df['day']
y = df['area']
slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)
plt.plot(x, slope * x + intercept, 'r-', label=f'Trend (R²={r_value**2:.2f})')

plt.xlabel('День наблюдения')
plt.ylabel('Средняя площадь (пиксели)')
plt.title('Динамика роста грибов')
plt.legend()
plt.grid(True)
plt.show()

# Корреляционный анализ
correlation_matrix = df[['area', 'perimeter', 'eccentricity']].corr()
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm')
plt.title('Корреляция параметров роста грибов')
plt.show()

import matplotlib.pyplot as plt
import numpy as np

# Данные о температуре и скорости роста
temperatures = np.array([10, 15, 20, 25, 30, 35])
growth_rates = np.array([0.5, 1.2, 2.5, 3.8, 2.1, 0.8])

# Визуализация зависимости скорости роста от температуры
plt.figure(figsize=(10, 6))
plt.plot(temperatures, growth_rates, 'o-', linewidth=2, markersize=8)
plt.xlabel('Температура (°C)')
plt.ylabel('Скорость роста (мм/день)')
plt.title('Влияние температуры на рост грибов')
plt.grid(True, alpha=0.3)

# Оптимальная температура
optimal_temp = temperatures[np.argmax(growth_rates)]
plt.axvline(x=optimal_temp, color='r', linestyle='--', label=f'Оптимальная температура: {optimal_temp}°C')
plt.legend()
plt.show()

# Данные о влажности и параметрах роста
humidity_levels = np.array([40, 50, 60, 70, 80, 90])
biomass = np.array([0.3, 0.8, 1.5, 2.2, 1.9, 1.1])
spore_count = np.array([100, 500, 1200, 2000, 1800, 900])

# Визуализация
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))

# Биомасса
ax1.plot(humidity_levels, biomass, 'o-', color='blue', linewidth=2, markersize=8)
ax1.set_xlabel('Влажность (%)')
ax1.set_ylabel('Биомасса (г)')
ax1.set_title('Влияние влажности на биомассу')
ax1.grid(True, alpha=0.3)

# Количество спор
ax2.plot(humidity_levels, spore_count, 'o-', color='green', linewidth=2, markersize=8)
ax2.set_xlabel('Влажность (%)')
ax2.set_ylabel('Количество спор')
ax2.set_title('Влияние влажности на спороношение')
ax2.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans

# Синтетические данные о факторах и росте
np.random.seed(42)
n_samples = 100

# Факторы
temperature = np.random.normal(25, 5, n_samples)
humidity = np.random.normal(70, 15, n_samples)
nutrient_level = np.random.normal(0.5, 0.2, n_samples)
light_intensity = np.random.normal(500, 150, n_samples)

# Скорость роста (зависит от факторов с некоторым шумом)
growth_rate = (0.1 * temperature + 
 0.05 * humidity + 
 0.2 * nutrient_level + 
 0.01 * light_intensity + 
 np.random.normal(0, 0.5, n_samples))

# Создание DataFrame
import pandas as pd
data = pd.DataFrame({
 'Temperature': temperature,
 'Humidity': humidity,
 'Nutrient_Level': nutrient_level,
 'Light_Intensity': light_intensity,
 'Growth_Rate': growth_rate
})

# Стандартизация данных
scaler = StandardScaler()
scaled_data = scaler.fit_transform(data.drop('Growth_Rate', axis=1))

# PCA для снижения размерности
pca = PCA(n_components=2)
principal_components = pca.fit_transform(scaled_data)

# Кластеризация
kmeans = KMeans(n_clusters=3, random_state=42)
clusters = kmeans.fit_predict(scaled_data)

# Визуализация
plt.figure(figsize=(12, 8))

# График PCA
plt.subplot(2, 2, 1)
scatter = plt.scatter(principal_components[:, 0], principal_components[:, 1], 
 c=clusters, cmap='viridis', alpha=0.6)
plt.xlabel('PC1')
plt.ylabel('PC2')
plt.title('PCA кластеризация факторов роста')
plt.colorbar(scatter, label='Кластер')

# График зависимости роста от температуры
plt.subplot(2, 2, 2)
plt.scatter(data['Temperature'], data['Growth_Rate'], alpha=0.6)
plt.xlabel('Температура (°C)')
plt.ylabel('Скорость роста')
plt.title('Зависимость роста от температуры')

plt.tight_layout()
plt.show()

import tensorflow as tf
from tensorflow.keras import layers, models
import numpy as np
import matplotlib.pyplot as plt

# Создание синтетического набора данных
def generate_mushroom_data(num_samples=1000, image_size=(64, 64)):
 # Данные для съедобных грибов
 edible_data = np.random.normal(0.3, 0.1, (num_samples//2, *image_size, 3))
 edible_data = np.clip(edible_data, 0, 1)
 
 # Данные для ядовитых грибов (более темные)
 poisonous_data = np.random.normal(0.2, 0.15, (num_samples//2, *image_size, 3))
 poisonous_data = np.clip(poisonous_data, 0, 1)
 
 # Метки: 0 - съедобные, 1 - ядовитые
 labels = np.array([0] * (num_samples//2) + [1] * (num_samples//2))
 
 # Случайное перемешивание
 indices = np.random.permutation(num_samples)
 images = np.concatenate([edible_data, poisonous_data])[indices]
 labels = labels[indices]
 
 return images, labels

# Генерация данных
images, labels = generate_mushroom_data()

# Разделение на обучающую и тестовую выборки
split = int(0.8 * len(images))
train_images, test_images = images[:split], images[split:]
train_labels, test_labels = labels[:split], labels[split:]

# Создание модели CNN
model = models.Sequential([
 layers.Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 3)),
 layers.MaxPooling2D((2, 2)),
 layers.Conv2D(64, (3, 3), activation='relu'),
 layers.MaxPooling2D((2, 2)),
 layers.Conv2D(64, (3, 3), activation='relu'),
 layers.Flatten(),
 layers.Dense(64, activation='relu'),
 layers.Dense(1, activation='sigmoid')
])

# Компиляция модели
model.compile(optimizer='adam',
 loss='binary_crossentropy',
 metrics=['accuracy'])

# Обучение модели
history = model.fit(train_images, train_labels, epochs=10, 
 validation_data=(test_images, test_labels))

# Оценка модели
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print(f'\nТочность на тестовых данных: {test_acc:.4f}')

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader, TensorDataset
import numpy as np

# Определение архитектуры нейронной сети
class MushroomClassifier(nn.Module):
 def __init__(self):
 super(MushroomClassifier, self).__init__()
 self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
 self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
 self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
 self.pool = nn.MaxPool2d(2, 2)
 self.fc1 = nn.Linear(128 * 8 * 8, 512)
 self.fc2 = nn.Linear(512, 2) # 2 класса: съедобные и ядовитые
 self.dropout = nn.Dropout(0.5)
 
 def forward(self, x):
 x = self.pool(torch.relu(self.conv1(x)))
 x = self.pool(torch.relu(self.conv2(x)))
 x = self.pool(torch.relu(self.conv3(x)))
 x = x.view(-1, 128 * 8 * 8)
 x = torch.relu(self.fc1(x))
 x = self.dropout(x)
 x = self.fc2(x)
 return x

# Генерация синтетических данных
def generate_pytorch_data(num_samples=1000, image_size=(32, 32)):
 # Данные для съедобных грибов
 edible_data = torch.randn(num_samples//2, 3, *image_size) * 0.1 + 0.3
 edible_data = torch.clamp(edible_data, 0, 1)
 
 # Данные для ядовитых грибов
 poisonous_data = torch.randn(num_samples//2, 3, *image_size) * 0.15 + 0.2
 poisonous_data = torch.clamp(poisonous_data, 0, 1)
 
 # Метки
 labels = torch.tensor([0] * (num_samples//2) + [1] * (num_samples//2))
 
 # Соединение и перемешивание
 all_data = torch.cat([edible_data, poisonous_data])
 all_labels = labels
 
 return TensorDataset(all_data, all_labels)

# Создание набора данных
dataset = generate_pytorch_data()
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# Инициализация модели
model = MushroomClassifier()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Обучение модели
num_epochs = 10
for epoch in range(num_epochs):
 running_loss = 0.0
 for i, (images, labels) in enumerate(dataloader):
 # Обнуление градиентов
 optimizer.zero_grad()
 
 # Прямой проход
 outputs = model(images)
 loss = criterion(outputs, labels)
 
 # Обратное распространение и оптимизация
 loss.backward()
 optimizer.step()
 
 running_loss += loss.item()
 
 print(f'Эпоха [{epoch+1}/{num_epochs}], Потери: {running_loss/len(dataloader):.4f}')

# Установка основных библиотек
pip install opencv-python numpy matplotlib scikit-image plantcv tensorflow torch torchvision pandas

# Дополнительные библиотеки для машинного обучения
pip install scikit-learn seaborn

import os
import cv2
import numpy as np
from skimage import io, transform

# Создание структуры папок для хранения данных
data_dir = 'mushroom_dataset'
train_dir = os.path.join(data_dir, 'train')
test_dir = os.path.join(data_dir, 'test')

# Создание папок для классов
classes = ['edible', 'poisonous']
for class_name in classes:
 os.makedirs(os.path.join(train_dir, class_name), exist_ok=True)
 os.makedirs(os.path.join(test_dir, class_name), exist_ok=True)

# Функция для предварительной обработки изображений
def preprocess_image(image_path, target_size=(256, 256)):
 # Загрузка изображения
 image = io.imread(image_path)
 
 # Изменение размера
 image = transform.resize(image, target_size)
 
 # Нормализация
 image = (image * 255).astype(np.uint8)
 
 return image

import matplotlib.pyplot as plt
import pandas as pd
from skimage import measure, io
import numpy as np
from datetime import datetime, timedelta

# Класс для отслеживания роста грибов
class MushroomGrowthTracker:
 def __init__(self):
 self.growth_data = []
 self.measurements = []
 
 def process_image(self, image_path, timestamp=None):
 # Загрузка изображения
 image = io.imread(image_path)
 gray = image[:, :, 0] # Используем один канал для упрощения
 
 # Бинаризация
 threshold = np.mean(gray) + np.std(gray)
 binary = gray > threshold
 
 # Метка регионов
 labeled = measure.label(binary)
 regions = measure.regionprops(labeled)
 
 # Извлечение данных о грибах
 mushrooms = []
 for region in regions:
 if region.area > 100: # Фильтрация маленьких объектов
 mushroom_data = {
 'timestamp': timestamp or datetime.now(),
 'area': region.area,
 'perimeter': region.perimeter,
 'eccentricity': region.eccentricity,
 'major_axis': region.major_axis_length,
 'minor_axis': region.minor_axis_length,
 'solidity': region.solidity,
 'image_path': image_path
 }
 mushrooms.append(mushroom_data)
 
 self.measurements.extend(mushrooms)
 return mushrooms
 
 def analyze_growth(self, time_window_hours=24):
 # Преобразование данных в DataFrame
 df = pd.DataFrame(self.measurements)
 
 if df.empty:
 return None
 
 # Расчет времени в часах от начала наблюдений
 start_time = df['timestamp'].min()
 df['hours'] = (df['timestamp'] - start_time).dt.total_seconds() / 3600
 
 # Агрегация данных по времени
 growth_summary = df.groupby('hours').agg({
 'area': ['mean', 'std'],
 'perimeter': ['mean', 'std'],
 'major_axis': ['mean', 'std']
 }).reset_index()
 
 # Расчет скорости роста
 growth_summary['growth_rate'] = growth_summary['area']['mean'].diff() / growth_summary['hours'].diff()
 growth_summary['growth_rate'] = growth_summary['growth_rate'].fillna(0)
 
 return growth_summary
 
 def visualize_growth(self, growth_summary):
 if growth_summary is None or growth_summary.empty:
 print("Нет данных для визуализации")
 return
 
 fig, axes = plt.subplots(2, 2, figsize=(14, 10))
 
 # График площади
 axes[0, 0].plot(growth_summary['hours'], growth_summary['area']['mean'], 'o-', label='Средняя площадь')
 axes[0, 0].fill_between(growth_summary['hours'], 
 growth_summary['area']['mean'] - growth_summary['area']['std'],
 growth_summary['area']['mean'] + growth_summary['area']['std'],
 alpha=0.2)
 axes[0, 0].set_xlabel('Время (часы)')
 axes[0, 0].set_ylabel('Площадь (пиксели)')
 axes[0, 0].set_title('Динамика площади грибов')
 axes[0, 0].grid(True)
 
 # График периметра
 axes[0, 1].plot(growth_summary['hours'], growth_summary['perimeter']['mean'], 'o-', color='green', label='Средний периметр')
 axes[0, 1].fill_between(growth_summary['hours'], 
 growth_summary['perimeter']['mean'] - growth_summary['perimeter']['std'],
 growth_summary['perimeter']['mean'] + growth_summary['perimeter']['std'],
 alpha=0.2, color='green')
 axes[0, 1].set_xlabel('Время (часы)')
 axes[0, 1].set_ylabel('Периметр (пиксели)')
 axes[0, 1].set_title('Динамика периметра грибов')
 axes[0, 1].grid(True)
 
 plt.tight_layout()
 plt.show()

# Использование класса для отслеживания роста
tracker = MushroomGrowthTracker()

# Симуляция сбора данных за несколько дней
base_time = datetime.now() - timedelta(days=5)

for day in range(5):
 timestamp = base_time + timedelta(days=day)
 
 # Симуляция роста грибов (в реальном проекте здесь будет загрузка реальных изображений)
 for hour in range(0, 24, 6): # Каждые 6 часов
 synthetic_image = np.random.normal(0.3 + day*0.05, 0.1, (256, 256, 3))
 synthetic_image = np.clip(synthetic_image, 0, 1)
 
 # Сохранение временной метки
 timestamp_with_hour = timestamp + timedelta(hours=hour)
 
 # Обработка изображения
 mushrooms = tracker.process_image(None, timestamp_with_hour)
 print(f"День {day+1}, час {hour}: обнаружено {len(mushrooms)} грибов")

# Анализ и визуализация данных о росте
growth_summary = tracker.analyze_growth()
tracker.visualize_growth(growth_summary)