soiltextureplot 0.1.0__py3-none-any.whl

soiltextureplot/__init__.py

@@ -0,0 +1,32 @@
+"""
+Soil Texture Plotting Package
+=============================
+
+A Python package for soil texture classification and plotting on ternary diagrams.
+
+Modules
+-------
+classifier
+    Logic for classifying soil samples into texture classes.
+datasets
+    Loading sample datasets.
+plotting
+    Functions for creating ternary plots.
+systems
+    Definitions of standard soil texture classification systems (USDA, HYPRES, etc.).
+triangle
+    Core triangle geometry utilities.
+utils
+    General utility functions.
+"""
+
+from .classifier import PolygonClassifier
+from .systems import TextureSystem, get_texture_system
+from .plotting import plot_triangle_with_points
+
+__all__ = [
+    "PolygonClassifier",
+    "TextureSystem",
+    "get_texture_system",
+    "plot_triangle_with_points",
+]

soiltextureplot/classifier.py

@@ -0,0 +1,95 @@
+from dataclasses import dataclass
+from typing import Dict, List
+
+import numpy as np
+from matplotlib.path import Path
+
+from .systems import TextureSystem
+from .utils import ternary_to_cartesian
+
+
+@dataclass
+class PolygonClassifier:
+    """
+    Classifies points into soil texture classes using polygon inclusion.
+
+    Parameters
+    ----------
+    system : TextureSystem
+        The texture system definition containing polygon vertices.
+    _paths : Dict[str, Path]
+        Precomputed matplotlib Paths for point testing.
+    _class_order : List[str]
+        Ordered list of class names for consistency.
+    """
+    system: TextureSystem
+    _paths: Dict[str, Path]
+    _class_order: List[str]
+
+    @classmethod
+    def from_system(cls, system: TextureSystem) -> "PolygonClassifier":
+        """
+        Create a classifier from a TextureSystem.
+
+        Parameters
+        ----------
+        system : TextureSystem
+            The texture classification system to use.
+
+        Returns
+        -------
+        PolygonClassifier
+            Initialized classifier instance.
+        """
+        paths: Dict[str, Path] = {}
+
+        for name, vertices in system.polygons.items():
+            verts = np.array(vertices, dtype=float)  # shape (N, 3) (clay, sand, silt)
+            clay, sand, silt = verts.T
+            xy = ternary_to_cartesian(clay, sand, silt)
+            # Ensure polygon is closed
+            if not np.allclose(xy[0], xy[-1]):
+                xy = np.vstack([xy, xy[0]])
+
+            paths[name] = Path(xy)
+
+        class_order = list(system.polygons.keys())
+        return cls(system=system, _paths=paths, _class_order=class_order)
+
+    def classify_points(
+        self,
+        clay: np.ndarray,
+        sand: np.ndarray,
+        silt: np.ndarray
+    ) -> np.ndarray:
+        """
+        Classify many points at once.
+
+        Parameters
+        ----------
+        clay : np.ndarray
+            Array of clay percentages.
+        sand : np.ndarray
+            Array of sand percentages.
+        silt : np.ndarray
+            Array of silt percentages.
+
+        Returns
+        -------
+        np.ndarray
+            Array of class names (dtype=object). Returns 'Unknown' if no
+            polygon contains the point.
+        """
+        xy = ternary_to_cartesian(clay, sand, silt)
+        n = xy.shape[0]
+        result = np.full(n, "Unknown", dtype=object)
+
+        # Vectorized point-in-polygon: test all points against each Path
+        for class_name in self._class_order:
+            path = self._paths[class_name]
+            inside = path.contains_points(xy)
+            # Only overwrite where still Unknown
+            mask = inside & (result == "Unknown")
+            result[mask] = class_name
+
+        return result

soiltextureplot/datasets.py

@@ -0,0 +1,106 @@
+from typing import Dict, List, Annotated
+
+# Type alias for texture definitions: Name -> List of Polygon Vertices (Clay, Sand, Silt)
+TextureClasses = Dict[str, List[List[float]]]
+
+USDA_TEXTURE_CLASSES: TextureClasses = {
+    "sand": [[10.0, 90.0, 0.0], [0.0, 100.0, 0.0], [0.0, 85.0, 15.0]],
+    "loamy sand": [
+        [15.0, 85.0, 0.0],
+        [10.0, 90.0, 0.0],
+        [0.0, 85.0, 15.0],
+        [0.0, 70.0, 30.0],
+    ],
+    "sandy loam": [
+        [20.0, 52.0, 28.0],
+        [20.0, 80.0, 0.0],
+        [15.0, 85.0, 0.0],
+        [0.0, 70.0, 30.0],
+        [0.0, 50.0, 50.0],
+        [7.0, 43.0, 50.0],
+        [7.0, 52.0, 41.0],
+    ],
+    "loam": [
+        [27.0, 23.0, 50.0],
+        [27.0, 45.0, 28.0],
+        [20.0, 52.0, 28.0],
+        [7.0, 52.0, 41.0],
+        [7.0, 43.0, 50.0],
+    ],
+    "silt loam": [
+        [27.0, 0.0, 73.0],
+        [27.0, 23.0, 50.0],
+        [0.0, 50.0, 50.0],
+        [0.0, 20.0, 80.0],
+        [12.0, 8.0, 80.0],
+        [12.0, 0.0, 88.0],
+    ],
+    "silt": [
+        [12.0, 0.0, 88.0],
+        [12.0, 8.0, 80.0],
+        [0.0, 20.0, 80.0],
+        [0.0, 0.0, 100.0],
+    ],
+    "sandy clay loam": [
+        [35.0, 45.0, 20.0],
+        [35.0, 65.0, 0.0],
+        [20.0, 80.0, 0.0],
+        [20.0, 52.0, 28.0],
+        [27.0, 45.0, 28.0],
+    ],
+    "clay loam": [
+        [40.0, 20.0, 40.0],
+        [40.0, 45.0, 15.0],
+        [27.0, 45.0, 28.0],
+        [27.0, 20.0, 53.0],
+    ],
+    "silty clay loam": [
+        [40.0, 0.0, 60.0],
+        [40.0, 20.0, 40.0],
+        [27.0, 20.0, 53.0],
+        [27.0, 0.0, 73.0],
+    ],
+    "sandy clay": [[55.0, 45.0, 0.0], [35.0, 65.0, 0.0], [35.0, 45.0, 20.0]],
+    "silty clay": [[60.0, 0.0, 40.0], [40.0, 20.0, 40.0], [40.0, 0.0, 60.0]],
+    "clay": [
+        [100.0, 0.0, 0.0],
+        [55.0, 45.0, 0.0],
+        [40.0, 45.0, 15.0],
+        [40.0, 20.0, 40.0],
+        [60.0, 0.0, 40.0],
+    ],
+}
+
+HYPRES_TEXTURE_CLASSES: TextureClasses = {
+    "coarse": [  # Coarse: 0 ≤ clay < 18, sand ≥ 65
+        [18.0, 82.0, 0.0],
+        [0.0, 100.0, 0.0],
+        [0.0, 65.0, 35.0],
+        [18.0, 65.0, 17.0],
+    ],
+    "medium": [  # Medium: (0–18 clay & 15–65 sand) OR (18–35 clay & sand ≥15)
+        [35.0, 65.0, 0.0],
+        [18.0, 82.0, 0.0],
+        [18.0, 65.0, 17.0],
+        [0.0, 65.0, 35.0],
+        [0.0, 15.0, 85.0],
+        [35.0, 15.0, 50.0],
+    ],
+    "medium fine": [  # Medium fine: (clay<35) and (sand<15)
+        [35.0, 15.0, 50.0],
+        [0.0, 15.0, 85.0],
+        [0.0, 0.0, 100.0],
+        [35.0, 0.0, 65.0],
+    ],
+    "fine": [  # Fine: 35 ≤ clay < 60
+        [60.0, 40.0, 0.0],
+        [35.0, 65.0, 0.0],
+        [35.0, 0.0, 65.0],
+        [60.0, 0.0, 40.0],
+    ],
+    "very fine": [  # Very fine: clay ≥ 60
+        [100.0, 0.0, 0.0],
+        [60.0, 40.0, 0.0],
+        [60.0, 0.0, 40.0],
+    ],
+}

soiltextureplot/plotting.py

@@ -0,0 +1,247 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+
+from typing import Optional, Union, List, Tuple
+from matplotlib.figure import Figure
+from matplotlib.axes import Axes
+from matplotlib.colors import Colormap
+from matplotlib.ticker import AutoMinorLocator, MultipleLocator
+from matplotlib import colormaps
+
+from .systems import TextureSystem
+from .utils import calculate_centroid
+
+
+def plot_triangle_with_points(
+    df: pd.DataFrame,
+    system: TextureSystem,
+    size_by: Optional[str] = None,
+    size_min: Optional[float] = None,
+    size_max: Optional[float] = None,
+    show_labels: Optional[bool] = None,
+    cmap: Optional[Union[str, List[str], Colormap]] = None,
+    color_points: Optional[Union[str, List[str]]] = None,
+) -> Tuple[Figure, Axes]:
+    """
+    Plot soil texture data on a ternary diagram.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame with 'clay', 'sand', 'silt' columns.
+    system : TextureSystem
+        The soil texture classification system to use.
+    size_by : str, optional
+        Column name to use for sizing points.
+    size_min : float, optional
+        Minimum point size.
+    size_max : float, optional
+        Maximum point size.
+    show_labels : bool, optional
+        If True, show sample labels on points.
+    cmap : str, list, or Colormap, optional
+        Colormap for filling texture classes. Can be a matplotlib colormap name
+        or a list of colors. Defaults to 'Set3_r'.
+    color_points : str or list, optional
+        Color for the scattered points.
+
+    Returns
+    -------
+    fig : Figure
+        The matplotlib Figure object.
+    ax : Axes
+        The matplotlib Axes object (ternary projection).
+    """
+    import mpltern  # imported here so core doesn’t hard‑depend for non‑plot use
+
+    fig = plt.figure(figsize=(7, 6))
+    ax = fig.add_subplot(projection="ternary", ternary_sum=100.0)
+
+    _plot_background_classes(ax, system, cmap=cmap)
+
+    # coordinates in ternary order (clay, sand, silt)
+    t = df["clay"].to_numpy()
+    l = df["sand"].to_numpy()
+    r = df["silt"].to_numpy()
+
+    sizes = _compute_sizes(df, size_by, size_min, size_max)
+
+    ax.scatter(
+        t,
+        l,
+        r,
+        c=color_points,
+        alpha=0.7,
+        edgecolors="none",
+        s=sizes,
+    )
+
+    if show_labels and "sample_id" in df.columns:
+        for (_, row), tt, ll, rr in zip(df.iterrows(), t, l, r):
+            ax.text(
+                tt,
+                ll,
+                rr,
+                row["sample_id"],
+                fontsize=7,
+                ha="center",
+                va="center",
+                color="white",
+            )
+
+    ax.set_title(f"{system.name} Soil Texture Triangle", weight="bold", pad=20)
+    fig.tight_layout()
+    return fig, ax
+
+
+def _plot_background_classes(
+    ax: Axes,
+    system: TextureSystem,
+    cmap: Optional[Union[str, List[str], Colormap]] = None
+) -> None:
+    """
+    Plots the texture class polygons in the background.
+
+    Parameters
+    ----------
+    ax : Axes
+        The ternary axes to plot on.
+    system : TextureSystem
+        The system containing polygons to plot.
+    cmap : str, list, or Colormap, optional
+        Colormap to use for filling polygons.
+    """
+    from itertools import cycle
+
+    num_polygons = len(system.polygons)
+
+    colors = None
+    if isinstance(cmap, list):
+        colors = cmap
+    else:
+        if cmap is None:
+            cmap = "Set3_r"  # default
+        try:
+            colormap = colormaps.get_cmap(cmap)
+            # Resample the colormap to have exactly the number of colors we need.
+            # Then, get the list of colors by calling the resampled map.
+            # This is a robust way that works for both continuous and discrete colormaps.
+            resampled_cmap = colormap.resampled(num_polygons)
+            colors = [resampled_cmap(i) for i in range(resampled_cmap.N)]
+        except (ValueError, KeyError):
+            print(
+                f"Warning: Colormap '{cmap}' not found. Falling back to default 'Set3_r'."
+            )
+            colormap = colormaps.get_cmap("Set3_r")
+            resampled_cmap = colormap.resampled(num_polygons)
+            colors = [resampled_cmap(i) for i in range(resampled_cmap.N)]
+
+    # Cycle through colors if not enough are provided for the polygons.
+    # This is a safeguard, though resampled() should give the correct number.
+    if len(colors) < num_polygons:
+        color_cycle = cycle(colors)
+    else:
+        color_cycle = colors  # type: ignore
+
+    for (name, vertices), color in zip(system.polygons.items(), color_cycle):
+        tn0, tn1, tn2 = np.array(vertices).T  # clay, sand, silt
+        patch = ax.fill(
+            tn0,
+            tn1,
+            tn2,
+            ec="k",
+            fc=color,
+            alpha=0.5,
+        )
+        centroid = calculate_centroid(patch[0].get_xy())
+
+        label = name.capitalize()
+
+        ax.text(
+            centroid[0],
+            centroid[1],
+            label,
+            ha="center",
+            va="center",
+            transform=ax.transData,
+        )
+
+    # ticks, grid, etc. (same as you already have)
+    ax.taxis.set_major_locator(MultipleLocator(10.0))
+    ax.laxis.set_major_locator(MultipleLocator(10.0))
+    ax.raxis.set_major_locator(MultipleLocator(10.0))
+    ax.taxis.set_minor_locator(AutoMinorLocator(2))
+    ax.laxis.set_minor_locator(AutoMinorLocator(2))
+    ax.raxis.set_minor_locator(AutoMinorLocator(2))
+    ax.grid(which="both", linewidth=0.4, color="gray", alpha=0.6)
+
+    # Add custom axis labels along edges
+
+    # Sand (%) – bottom edge, centered, below triangle
+    ax.text(
+        -5,
+        33,
+        33,  # roughly mid bottom edge in (t,l,r) = (clay,sand,silt)
+        "Sand [%]",
+        ha="center",
+        va="top",
+        fontsize=12,
+        rotation=0,
+        transform=ax.transTernaryAxes,  # use ternary coordinate classification_system
+    )
+
+    # Clay (%) – left edge, centered, rotated up
+    ax.text(
+        40,
+        40,
+        -8,  # somewhere along left edge
+        "Clay [%]",
+        ha="center",
+        va="center",
+        fontsize=12,
+        rotation=60,  # rotate along left edge
+        transform=ax.transTernaryAxes,
+    )
+
+    # Silt (%) – right edge, centered, rotated down
+    ax.text(
+        40,
+        -8,
+        40,  # somewhere along right edge
+        "Silt [%]",
+        ha="center",
+        va="center",
+        fontsize=12,
+        rotation=-60,  # rotate along right edge
+        transform=ax.transTernaryAxes,
+    )
+    ax.taxis.set_ticks_position("tick2")
+    ax.laxis.set_ticks_position("tick2")
+    ax.raxis.set_ticks_position("tick2")
+
+
+def _compute_sizes(
+    df: pd.DataFrame,
+    size_by: Optional[str],
+    size_min: Optional[float],
+    size_max: Optional[float]
+) -> Union[float, np.ndarray]:
+    """Helper to compute point sizes based on a column."""
+    if size_min is None:
+        size_min = 20.0  # default fallback
+    if size_by is None or size_by not in df.columns:
+        return size_min
+
+    if size_max is None:
+        size_max = 100.0  # default fallback
+
+    vals = df[size_by].to_numpy().astype(float)
+    valid = np.isfinite(vals)
+    if not valid.any() or np.allclose(vals[valid], vals[valid][0]):
+        return np.full_like(vals, (size_min + size_max) / 2.0)
+
+    vmin = vals[valid].min()
+    vmax = vals[valid].max()
+    norm = (vals - vmin) / (vmax - vmin)
+    return size_min + norm * (size_max - size_min)

soiltextureplot/systems.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass
+from typing import List, Dict, Mapping, Any, Optional
+from . import datasets
+
+
+@dataclass(frozen=True)
+class TextureSystem:
+    """
+    Represents a soil texture classification system.
+
+    Parameters
+    ----------
+    name : str
+        The unique name of the system (e.g., 'USDA').
+    polygons : Mapping[str, Any]
+        A mapping of class names to polygon vertices.
+    meta : Mapping[str, Any]
+        Metadata about the system (description, citation, etc.).
+    """
+    name: str
+    polygons: Mapping[str, Any]
+    meta: Mapping[str, Any]
+
+
+_SYSTEMS: Dict[str, TextureSystem] = {
+    "USDA": TextureSystem(
+        name="USDA",
+        polygons=datasets.USDA_TEXTURE_CLASSES,
+        meta={
+            "description": "United States Department of Agriculture (USDA) Soil Texture Classification"
+        },
+    ),
+    "HYPRES": TextureSystem(
+        name="HYPRES",
+        polygons=datasets.HYPRES_TEXTURE_CLASSES,
+        meta={
+            "description": "The HYdraulic PRoperties of European Soils (HYPRES) is a European framework for classifying soils based on their hydrologic properties"
+        },
+    ),
+    # additional systems can be added here
+}
+
+
+def get_texture_system(system_name: str) -> TextureSystem:
+    """
+    Retrieve a TextureSystem by name.
+
+    Parameters
+    ----------
+    system_name : str
+        The name of the system to retrieve.
+
+    Returns
+    -------
+    TextureSystem
+        The requested texture system.
+
+    Raises
+    ------
+    ValueError
+        If the system name is not found.
+    """
+    try:
+        return _SYSTEMS[system_name]
+    except KeyError:
+        raise ValueError(
+            f"Unknown texture system {system_name!r}. Available: {list(_SYSTEMS)}"
+        )
+
+
+def list_texture_systems() -> Dict[str, str]:
+    """
+    List all available texture systems.
+
+    Returns
+    -------
+    Dict[str, str]
+        A dictionary mapping system names to their descriptions.
+    """
+    return {k: v.meta.get("description", "") for k, v in _SYSTEMS.items()}

soiltextureplot/triangle.py

@@ -0,0 +1,178 @@
+import numpy as np
+import pandas as pd
+
+from dataclasses import dataclass, field
+from pathlib import Path as PathLibPath
+from typing import Optional, Union, TYPE_CHECKING
+from matplotlib.figure import Figure
+from matplotlib.axes import Axes
+
+from .systems import get_texture_system, TextureSystem
+from .classifier import PolygonClassifier
+from . import plotting
+
+if TYPE_CHECKING:
+    # Avoid circular import at runtime by only importing for type checking if needed
+    pass
+
+
+@dataclass
+class SoilTextureTriangle:
+    """
+    Main interface for loading soil data, classifying it, and plotting it.
+
+    Parameters
+    ----------
+    system_name : str, optional
+        Name of the texture classification system. Defaults to 'USDA'.
+    df : pd.DataFrame, optional
+        Initial DataFrame. Can be set later via load functions.
+    """
+    system_name: str = "USDA"
+    df: Optional[pd.DataFrame] = field(default=None, repr=False)
+
+    def __post_init__(self):
+        self.system: TextureSystem = get_texture_system(self.system_name)
+        self._classifier = PolygonClassifier.from_system(self.system)
+
+    # data loading
+    def load_csv(
+        self,
+        path: Union[str, PathLibPath],
+        sand_col: str = "sand",
+        silt_col: str = "silt",
+        clay_col: str = "clay",
+    ) -> "SoilTextureTriangle":
+        """
+        Load data from a CSV file.
+
+        Parameters
+        ----------
+        path : str or Path
+            Path to the CSV file.
+        sand_col : str
+            Name of the column containing sand percentages.
+        silt_col : str
+            Name of the column containing silt percentages.
+        clay_col : str
+            Name of the column containing clay percentages.
+
+        Returns
+        -------
+        SoilTextureTriangle
+            Self for chaining.
+        """
+        df = pd.read_csv(path)
+        return self.load_dataframe(df, sand_col, silt_col, clay_col)
+
+    def load_dataframe(
+        self,
+        df: pd.DataFrame,
+        sand_col: str = "sand",
+        silt_col: str = "silt",
+        clay_col: str = "clay",
+    ) -> "SoilTextureTriangle":
+        """
+        Load data from an existing DataFrame.
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            The DataFrame containing soil data.
+        sand_col : str
+            Name of the column containing sand percentages.
+        silt_col : str
+            Name of the column containing silt percentages.
+        clay_col : str
+            Name of the column containing clay percentages.
+
+        Returns
+        -------
+        SoilTextureTriangle
+            Self for chaining.
+        """
+        # normalize column names internally
+        self.df = df.rename(
+            columns={sand_col: "sand", silt_col: "silt", clay_col: "clay"}
+        )
+        return self
+
+    # classification
+    def classify(self) -> pd.DataFrame:
+        """
+        Classify loaded data into texture classes.
+
+        Adds a 'texture_class' column to the internal DataFrame.
+
+        Returns
+        -------
+        pd.DataFrame
+            The DataFrame with the added 'texture_class' column.
+
+        Raises
+        ------
+        ValueError
+            If no data has been loaded.
+        """
+        if self.df is None:
+            raise ValueError("No data loaded. Call load_csv or load_dataframe first.")
+
+        clay = self.df["clay"].to_numpy()
+        sand = self.df["sand"].to_numpy()
+        silt = self.df["silt"].to_numpy()
+
+        classes = self._classifier.classify_points(clay, sand, silt)
+        self.df["texture_class"] = classes
+        return self.df
+
+    # plotting
+    def plot(
+        self,
+        size_by: Optional[str] = None,
+        size_min: float = 40,
+        size_max: float = 160,
+        show_labels: bool = True,
+        cmap: Optional[str] = None,
+        color_points: Optional[str] = "black",
+    ) -> tuple[Figure, Axes]:
+        """
+        Plot current data on the soil texture triangle using mpltern.
+
+        Parameters
+        ----------
+        size_by : str, optional
+            Column name for sizing points.
+        size_min : float, optional
+            Min point size.
+        size_max : float, optional
+            Max point size.
+        show_labels : bool, optional
+            Show labels on points.
+        cmap : str, optional
+            Colormap name for background polygons.
+        color_points : str, optional
+            Color for sample points.
+
+        Returns
+        -------
+        fig, ax
+            Matplotlib Figure and Axes.
+
+        Raises
+        ------
+        ValueError
+            If no data is loaded.
+        """
+        if self.df is None:
+            raise ValueError("No data loaded. Call load_csv or load_dataframe first.")
+
+        return plotting.plot_triangle_with_points(
+            df=self.df,
+            system=self.system,
+            size_by=size_by,
+            size_min=size_min,
+            size_max=size_max,
+            show_labels=show_labels,
+            cmap=cmap,
+            color_points=color_points,
+        )

soiltextureplot/utils.py

@@ -0,0 +1,85 @@
+import numpy as np
+
+
+def calculate_centroid(vertices: np.ndarray) -> np.ndarray:
+    """
+    Compute centroid of a 2D polygon given an (N, 2) array of vertices.
+    Uses the standard shoelace formula (no np.cross).
+
+    Parameters
+    ----------
+    vertices : np.ndarray
+        Array of shape (N, 2) containing polygon vertices.
+
+    Returns
+    -------
+    np.ndarray
+        Array of shape (2,) containing the (x, y) centroid coordinates.
+    """
+    x = vertices[:, 0]
+    y = vertices[:, 1]
+
+    # Close the polygon
+    x_next = np.roll(x, -1)
+    y_next = np.roll(y, -1)
+
+    cross = x * y_next - x_next * y
+    area = cross.sum() / 2.0
+
+    if np.isclose(area, 0.0):
+        # Fallback: simple mean if area is ~0 (degenerate polygon)
+        return np.array([x.mean(), y.mean()])
+
+    cx = ((x + x_next) * cross).sum() / (6.0 * area)
+    cy = ((y + y_next) * cross).sum() / (6.0 * area)
+
+    return np.array([cx, cy])
+
+
+def ternary_to_cartesian(
+    clay: np.ndarray,
+    sand: np.ndarray,
+    silt: np.ndarray,
+    ternary_sum: float = 100.0
+) -> np.ndarray:
+    """
+    Convert ternary coordinates (clay, sand, silt) to 2D Cartesian (x, y).
+
+    Uses an equilateral triangle with side length = ternary_sum.
+
+    Parameters
+    ----------
+    clay : np.ndarray
+        Clay percentages.
+    sand : np.ndarray
+        Sand percentages.
+    silt : np.ndarray
+        Silt percentages.
+    ternary_sum : float, optional
+        The sum of the ternary components (default 100.0).
+
+    Returns
+    -------
+    np.ndarray
+        Array of shape (N, 2) containing Cartesian (x, y) coordinates.
+    """
+    clay = np.asarray(clay, dtype=float)
+    sand = np.asarray(sand, dtype=float)
+    silt = np.asarray(silt, dtype=float)
+
+    # Normalize to sum to ternary_sum to be safe
+    total = clay + sand + silt
+    total[total == 0] = ternary_sum
+    clay = clay * ternary_sum / total
+    sand = sand * ternary_sum / total
+    silt = silt * ternary_sum / total
+
+    # Place triangle with one vertex at (0, 0), base horizontal
+    # Many ternary implementations use:
+    # x = 0.5 * (2*sand + silt) / ternary_sum
+    # y = (np.sqrt(3)/2) * silt / ternary_sum
+    # but we’ll keep units ~percent and let plotting handle scaling.
+    x = sand + 0.5 * silt
+    y = (np.sqrt(3) / 2.0) * silt
+
+    return np.stack([x, y], axis=-1)

soiltextureplot-0.1.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: soiltextureplot
+Version: 0.1.0
+Summary: Soil texture triangle plotting and classification
+Author-email: Amninder Singh <amnindersingh13@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Amninder Singh
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE OR ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/singhamninder/soiltextureplot
+Project-URL: Bug Tracker, https://github.com/singhamninder/soiltextureplot/issues
+Keywords: soil,texture,triangle,plot,classification,ternary
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.5.0
+Requires-Dist: numpy>=1.23.0
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: mpltern>=1.0.0
+Dynamic: license-file
+
+# Soil Texture Plot
+
+[![Streamlit App](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](https://soiltextureplot.streamlit.app/)
+
+This repository contains codebase for soil texture classification and visualization using ternary diagrams. It provides tools to plot soil texture data on texture triangles and classify soil samples according to different classification systems.
+
+## Features
+
+- **Ternary Plotting**: Visualize soil texture data on interactive ternary diagrams
+- **Multiple Classification Systems**: Support for USDA and HYPRES soil texture classification systems
+- **Interactive Web App**: Streamlit-based application for easy data upload and visualization
+- **Flexible Data Input**: Support for CSV files with customizable column mapping
+- **Point Classification**: Automatic classification of soil samples into texture classes
+- **Customizable Visualization**: Control point sizes, colors, and labels
+
+## Dependencies
+
+- streamlit
+- pandas
+- numpy
+- matplotlib
+- mpltern
+
+
+## Web Application
+
+The web app allows you to:
+- Upload CSV files with soil texture data
+- Map columns to sand, silt, and clay percentages
+- Visualize data on interactive texture triangles
+- Customize plot appearance
+
+## Supported Classification Systems
+
+### USDA (United States Department of Agriculture)
+The standard USDA soil texture classification system with 12 texture classes.
+
+### HYPRES (HYdraulic PRoperties of European Soils)
+A European framework for classifying soils based on their hydrologic properties.
+
+## Data Format
+
+Your CSV file should contain soil texture data with percentages of sand, silt, and clay. The percentages should sum to 100% for each sample.
+
+Example data format:
+
+```csv
+sample_id,sand,silt,clay
+S1,65,20,15
+S2,70,24,6
+S3,75,21,4
+```
+
+## Acknowledgments
+
+- Built using [mpltern](https://github.com/yuzie007/mpltern) for ternary plotting
+- Inspired by soil science classification standards
+- Streamlit for the web interface

soiltextureplot-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+soiltextureplot/__init__.py,sha256=PXZ9KDE8bVO0seCW21ds3psztkh_Ab2mQdAyGf_YrbQ,774
+soiltextureplot/classifier.py,sha256=sPf33xI5gJHKACTIWaqW9r1MPpX9R8VMRgsXJgzDt8M,2748
+soiltextureplot/datasets.py,sha256=k42L-eMIlG_ehWwxW7Is_JUIWOAEgOgyIzYXRayp3RY,2827
+soiltextureplot/plotting.py,sha256=sH9_2YKz9O0XVkJOhb5izf47yRk7_epaIioF9fOEsXU,7485
+soiltextureplot/systems.py,sha256=sk4YFLjLlRbyAAPsitmBI3hG5mJq3bOhAIcOgUJm9K8,2046
+soiltextureplot/triangle.py,sha256=lAySOgGZFipaTeqedoG4H2NU3d-x6C2VKkWdFeZYFQ8,5056
+soiltextureplot/utils.py,sha256=Yhq3PXPUQt17xkaH1HEO9fvZHeR7E5UzH4VIcNUtaDc,2324
+soiltextureplot-0.1.0.dist-info/licenses/LICENSE,sha256=heva5rpPPnoz6pdO3QinIy2P0LfIHXOoi_CALnus4f8,1073
+soiltextureplot-0.1.0.dist-info/METADATA,sha256=OH2tw4o0u0hWAqI-1tBZIKK9ew6ea10ZnpDSxHKHU2A,4274
+soiltextureplot-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+soiltextureplot-0.1.0.dist-info/top_level.txt,sha256=MyfpMMvqcQcnj28Ns9jfqGvl6zqo4vaycuPFu8oDXv0,16
+soiltextureplot-0.1.0.dist-info/RECORD,,

soiltextureplot-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

soiltextureplot-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Amninder Singh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE OR ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

soiltextureplot-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+soiltextureplot