dronelytics 1.0.1__py3-none-any.whl

dronelytics/__init__.py

@@ -0,0 +1,45 @@
+"""
+Dronelytics: Comprehensive package for end-to-end drone orthomosaic analysis
+and agricultural field phenotyping.
+
+Features:
+- Load and process multispectral orthomosaics (4-band and 5-band)
+- Calculate 10 vegetation indices with custom formula support
+- Automated plot boundary detection
+- Pixel-level data extraction
+- 3D canopy modeling from point clouds (DTM, DSM, CHM)
+- 3D visualization of point clouds, elevation models, and mesh surfaces
+- CSV/Excel data export
+"""
+
+__version__ = "1.0.0"
+__author__ = "Research Development"
+__license__ = "MIT"
+
+from .core.orthomosaic import Orthomosaic
+from .core.indices import VegetationIndices
+from .core.vegetation_indices_extended import VegetationIndicesExtended
+from .core.segmentation import PlotSegmentation
+from .core.extraction import PixelExtraction
+from .core.pointcloud import PointCloudProcessor
+from .processing.pipeline import AnalysisPipeline
+from .export.csv_export import CSVExporter
+from .export.excel_export import ExcelExporter
+from .utils.logger import setup_logger
+from . import visualization
+
+logger = setup_logger(__name__)
+
+__all__ = [
+    'Orthomosaic',
+    'VegetationIndices',
+    'VegetationIndicesExtended',
+    'PlotSegmentation',
+    'PixelExtraction',
+    'PointCloudProcessor',
+    'AnalysisPipeline',
+    'CSVExporter',
+    'ExcelExporter',
+    'setup_logger',
+    'visualization',
+]

dronelytics/core/__init__.py

@@ -0,0 +1,17 @@
+"""Core modules for dronelytics package."""
+
+from .orthomosaic import Orthomosaic
+from .indices import VegetationIndices
+from .vegetation_indices_extended import VegetationIndicesExtended
+from .segmentation import PlotSegmentation
+from .extraction import PixelExtraction
+from .pointcloud import PointCloudProcessor
+
+__all__ = [
+    'Orthomosaic',
+    'VegetationIndices',
+    'VegetationIndicesExtended',
+    'PlotSegmentation',
+    'PixelExtraction',
+    'PointCloudProcessor',
+]

dronelytics/core/extraction.py

@@ -0,0 +1,234 @@
+"""Pixel-level data extraction from orthomosaic."""
+
+import logging
+import numpy as np
+import pandas as pd
+from ..data.structures import ExtractionResult
+
+logger = logging.getLogger(__name__)
+
+
+class PixelExtraction:
+    """Extract pixel-level spectral and derived data."""
+
+    def __init__(self, orthomosaic):
+        """Initialize with orthomosaic."""
+        self.ortho = orthomosaic
+        self.extracted_data = None
+
+    def extract_spectra(self, mask=None):
+        """Extract spectral values for all bands."""
+        try:
+            logger.info("Extracting spectral data")
+
+            if mask is None:
+                mask = np.ones(self.ortho.get_shape(), dtype=bool)
+
+            extracted = {}
+            for band_name in self.ortho.band_config.keys():
+                band_data = self.ortho.get_band(band_name)
+                extracted[band_name] = band_data[mask]
+
+            logger.info(f"Extracted {mask.sum()} pixels")
+            self.extracted_data = extracted
+
+            return ExtractionResult(extracted, mask, {'method': 'spectra'})
+
+        except Exception as e:
+            logger.error(f"Extraction failed: {e}")
+            raise
+
+    def extract_by_coordinates(self, x_coords, y_coords):
+        """Extract values at specific pixel coordinates."""
+        try:
+            logger.info(f"Extracting {len(x_coords)} pixel locations")
+
+            extracted = {}
+            for band_name in self.ortho.band_config.keys():
+                band_data = self.ortho.get_band(band_name)
+                extracted[band_name] = band_data[y_coords, x_coords]
+
+            return ExtractionResult(extracted, None, {'method': 'coordinates', 'count': len(x_coords)})
+
+        except Exception as e:
+            logger.error(f"Coordinate extraction failed: {e}")
+            raise
+
+    def to_dataframe(self):
+        """Convert extracted data to pandas DataFrame."""
+        if self.extracted_data is None:
+            raise ValueError("No data extracted yet")
+
+        df = pd.DataFrame(self.extracted_data)
+        logger.info(f"Created DataFrame with shape {df.shape}")
+        return df
+
+    def get_statistics(self):
+        """Get statistics of extracted data."""
+        if self.extracted_data is None:
+            raise ValueError("No data extracted yet")
+
+        stats = {}
+        for band_name, values in self.extracted_data.items():
+            stats[band_name] = {
+                'mean': float(np.mean(values)),
+                'std': float(np.std(values)),
+                'min': float(np.min(values)),
+                'max': float(np.max(values)),
+                'count': int(len(values))
+            }
+
+        return stats
+
+    def extract_from_segmentation(self, segmentation, segments_array):
+        """Extract pixel data from segmented regions.
+
+        Parameters
+        ----------
+        segmentation : PlotSegmentation
+            PlotSegmentation instance with performed segmentation
+        segments_array : np.ndarray
+            Labeled segments array
+
+        Returns
+        -------
+        ExtractionResult
+            Extracted data from segments
+        """
+        try:
+            logger.info("Extracting data from segmented regions")
+
+            # Extract all spectral data
+            extracted = {}
+            for band_name in self.ortho.band_config.keys():
+                band_data = self.ortho.get_band(band_name)
+                extracted[band_name] = band_data.flatten()
+
+            mask = segments_array.flatten() > 0
+            self.extracted_data = extracted
+
+            return ExtractionResult(
+                np.column_stack([extracted[b] for b in extracted.keys()]),
+                mask,
+                {'method': 'segmentation', 'num_segments': len(np.unique(segments_array)) - 1}
+            )
+
+        except Exception as e:
+            logger.error(f"Segmentation extraction failed: {e}")
+            raise
+
+    def summarize_by_plot(self, segmentation, segments_array, vegetation_index=None):
+        """Create summary statistics by plot (segment).
+
+        Parameters
+        ----------
+        segmentation : PlotSegmentation
+            PlotSegmentation instance
+        segments_array : np.ndarray
+            Labeled segments array
+        vegetation_index : np.ndarray, optional
+            Vegetation index values for statistics
+
+        Returns
+        -------
+        pd.DataFrame
+            Summary statistics by plot
+        """
+        try:
+            logger.info("Summarizing data by plot")
+
+            summaries = []
+            unique_segments = np.unique(segments_array)
+            unique_segments = unique_segments[unique_segments > 0]  # Remove background
+
+            for seg_id in unique_segments:
+                mask = segments_array == seg_id
+                stats = self._calculate_plot_stats(mask, seg_id, vegetation_index)
+                summaries.append(stats)
+
+            df = pd.DataFrame(summaries)
+            logger.info(f"Created summary for {len(summaries)} plots")
+            return df
+
+        except Exception as e:
+            logger.error(f"Plot summarization failed: {e}")
+            raise
+
+    def _calculate_plot_stats(self, mask, plot_id, vegetation_index=None):
+        """Calculate statistics for a single plot.
+
+        Parameters
+        ----------
+        mask : np.ndarray
+            Boolean mask for plot pixels
+        plot_id : int
+            Plot identifier
+        vegetation_index : np.ndarray, optional
+            Vegetation index array
+
+        Returns
+        -------
+        dict
+            Statistics dictionary
+        """
+        stats = {
+            'plot_id': int(plot_id),
+            'pixel_count': int(mask.sum()),
+        }
+
+        # Band statistics
+        for band_name in self.ortho.band_config.keys():
+            band_data = self.ortho.get_band(band_name)
+            pixels = band_data[mask]
+            if len(pixels) > 0:
+                stats[f'{band_name}_mean'] = float(np.mean(pixels))
+                stats[f'{band_name}_std'] = float(np.std(pixels))
+                stats[f'{band_name}_min'] = float(np.min(pixels))
+                stats[f'{band_name}_max'] = float(np.max(pixels))
+
+        # Vegetation index statistics if provided
+        if vegetation_index is not None:
+            vi_pixels = vegetation_index[mask]
+            if len(vi_pixels) > 0:
+                stats['vi_mean'] = float(np.mean(vi_pixels))
+                stats['vi_std'] = float(np.std(vi_pixels))
+                stats['vi_min'] = float(np.min(vi_pixels))
+                stats['vi_max'] = float(np.max(vi_pixels))
+
+        return stats
+
+    def get_plot_statistics(self, plot_id, segmentation, segments_array):
+        """Get statistics for a specific plot.
+
+        Parameters
+        ----------
+        plot_id : int
+            Plot identifier
+        segmentation : PlotSegmentation
+            PlotSegmentation instance
+        segments_array : np.ndarray
+            Labeled segments array
+
+        Returns
+        -------
+        dict
+            Statistics for the plot
+        """
+        mask = segments_array == plot_id
+        return self._calculate_plot_stats(mask, plot_id)
+
+    def to_csv(self, filepath):
+        """Export extracted data to CSV file.
+
+        Parameters
+        ----------
+        filepath : str
+            Output CSV file path
+        """
+        try:
+            df = self.to_dataframe()
+            df.to_csv(filepath, index=False)
+            logger.info(f"Data exported to {filepath}")
+        except Exception as e:
+            logger.error(f"CSV export failed: {e}")
+            raise

dronelytics/core/indices.py

@@ -0,0 +1,75 @@
+"""Standard vegetation indices (legacy, use vegetation_indices_extended instead)."""
+
+import logging
+import numpy as np
+from ..data.structures import VegetationIndexData
+
+logger = logging.getLogger(__name__)
+
+
+class VegetationIndices:
+    """Calculate standard vegetation indices (4-band support)."""
+
+    def __init__(self, orthomosaic):
+        """Initialize with orthomosaic."""
+        self.ortho = orthomosaic
+        self.results = {}
+
+    def _safe_divide(self, numerator, denominator):
+        """Safely divide avoiding division by zero."""
+        epsilon = 1e-10 + np.abs(denominator).max() * 1e-12
+        return np.divide(numerator, denominator + epsilon, where=denominator != 0)
+
+    def _check_bands(self, required_bands):
+        """Check if required bands exist."""
+        missing = [b for b in required_bands if b not in self.ortho.band_config]
+        if missing:
+            raise ValueError(f"Missing bands: {missing}")
+
+    def ndvi(self):
+        """Normalized Difference Vegetation Index."""
+        self._check_bands(['red', 'nir'])
+        nir = self.ortho.get_band('nir')
+        red = self.ortho.get_band('red')
+        ndvi = self._safe_divide(nir - red, nir + red)
+        self.results['ndvi'] = VegetationIndexData('NDVI', ndvi, ndvi.mean(), ndvi.std(), ndvi.min(), ndvi.max(), ndvi.size)
+        return self.results['ndvi']
+
+    def ndre(self):
+        """Normalized Difference Red Edge Index."""
+        self._check_bands(['nir', 'red_edge'])
+        nir = self.ortho.get_band('nir')
+        red_edge = self.ortho.get_band('red_edge')
+        ndre = self._safe_divide(nir - red_edge, nir + red_edge)
+        self.results['ndre'] = VegetationIndexData('NDRE', ndre, ndre.mean(), ndre.std(), ndre.min(), ndre.max(), ndre.size)
+        return self.results['ndre']
+
+    def gndvi(self):
+        """Green Normalized Difference Vegetation Index."""
+        self._check_bands(['nir', 'green'])
+        nir = self.ortho.get_band('nir')
+        green = self.ortho.get_band('green')
+        gndvi = self._safe_divide(nir - green, nir + green)
+        self.results['gndvi'] = VegetationIndexData('GNDVI', gndvi, gndvi.mean(), gndvi.std(), gndvi.min(), gndvi.max(), gndvi.size)
+        return self.results['gndvi']
+
+    # Alias methods for consistency with documentation
+    def calculate_ndvi(self):
+        """Alias for ndvi()."""
+        return self.ndvi()
+
+    def calculate_ndre(self):
+        """Alias for ndre()."""
+        return self.ndre()
+
+    def calculate_gndvi(self):
+        """Alias for gndvi()."""
+        return self.gndvi()
+
+    def get(self, name):
+        """Get calculated index by name."""
+        return self.results.get(name.lower())
+
+    def get_all(self):
+        """Get all calculated indices."""
+        return self.results

dronelytics/core/orthomosaic.py

@@ -0,0 +1,77 @@
+"""Orthomosaic loading and management."""
+
+import logging
+import numpy as np
+import rasterio
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class Orthomosaic:
+    """Load and manage multispectral orthomosaic data."""
+
+    def __init__(self, filepath, band_config=None):
+        """
+        Initialize orthomosaic.
+
+        Parameters
+        ----------
+        filepath : str
+            Path to GeoTIFF file
+        band_config : dict
+            Band configuration mapping (e.g., {'red': 1, 'nir': 4})
+        """
+        self.filepath = Path(filepath)
+        if not self.filepath.exists():
+            raise FileNotFoundError(f"File not found: {filepath}")
+
+        self.band_config = band_config or {}
+        self.data = None
+        self.metadata = {}
+        self._load()
+
+    def _load(self):
+        """Load GeoTIFF file."""
+        try:
+            with rasterio.open(self.filepath) as src:
+                self.data = src.read()
+                self.metadata = src.meta
+                self.transform = src.transform
+                self.crs = src.crs
+                logger.info(f"Loaded {self.filepath}: shape {self.data.shape}")
+        except Exception as e:
+            logger.error(f"Failed to load {self.filepath}: {e}")
+            raise
+
+    def get_band(self, band_name):
+        """Get band data by name."""
+        if band_name not in self.band_config:
+            raise ValueError(f"Band '{band_name}' not in config")
+
+        band_idx = self.band_config[band_name]
+        return self.data[band_idx - 1].astype(np.float32)
+
+    def get_shape(self):
+        """Get data shape."""
+        return self.data.shape[1:]
+
+    def get_transform(self):
+        """Get geospatial transform."""
+        return self.transform
+
+    def get_crs(self):
+        """Get coordinate reference system."""
+        return self.crs
+
+    def close(self):
+        """Close and cleanup."""
+        self.data = None
+        logger.info("Orthomosaic closed")
+
+    def clear_cache(self):
+        """Clear cache."""
+        self.data = None
+
+    def __repr__(self):
+        return f"Orthomosaic({self.filepath.name}, shape={self.data.shape})"