{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b046916b",
   "metadata": {},
   "source": [
    "# Working with marks in `pointpats`\n",
    "\n",
    "In addition to the *locations* of events, a point pattern can have extra attributes\n",
    "attached to each point: these are called **marks**.\n",
    "\n",
    "Examples of marks:\n",
    "\n",
    "- species of a tree (categorical)\n",
    "- crime type (categorical)\n",
    "- tree diameter (continuous)\n",
    "- number of injuries at an accident (count)\n",
    "\n",
    "In `pointpats`, a **marked point pattern** is represented by a\n",
    "`PointPattern` whose underlying data frame (`pp.df`) has extra columns\n",
    "beyond the coordinates, or by adding marks using the `add_marks` method.\n",
    "You can also split a marked pattern into separate unmarked patterns using\n",
    "`explode`. \n",
    "\n",
    "In this notebook we will:\n",
    "\n",
    "1. Create an unmarked point pattern.\n",
    "2. Attach categorical and numeric marks with `add_marks`.\n",
    "3. Explore marks in the underlying pandas DataFrame.\n",
    "4. Visualize the pattern by mark category.\n",
    "5. Use `explode` to split the pattern into one pattern per mark level.\n",
    "6. Compute a **weighted mean center** using a numeric mark as weights. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f133c33f",
   "metadata": {},
   "source": [
    "## Setup and imports\n",
    "\n",
    "We will simulate points in the unit square `[0, 1] × [0, 1]` using the\n",
    "random distributions in `pointpats.random` and then work with their marks.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4dcf9af3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 1., 1.])"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "from pointpats import PointPattern\n",
    "from pointpats import random as ppr\n",
    "from pointpats import weighted_mean_center, mean_center  # centrography functions\n",
    "\n",
    "# Make results reproducible\n",
    "np.random.seed(42)\n",
    "\n",
    "# Define a simple square hull as a bounding box: [xmin, ymin, xmax, ymax]\n",
    "hull = np.array([0.0, 0.0, 1.0, 1.0])\n",
    "hull"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67e5f4cb",
   "metadata": {},
   "source": [
    "## 1. Create an unmarked point pattern\n",
    "\n",
    "First, we simulate 200 locations from a homogeneous Poisson point process\n",
    "in the unit square and construct a `PointPattern` from the coordinates. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ee524a72",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(200, 2)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Simulate 200 points in the unit square (unmarked pattern)\n",
    "coords = ppr.poisson(hull, size=200)\n",
    "coords.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ab0d2505",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point Pattern\n",
      "200 points\n",
      "Bounding rectangle [(0.005061583846218687,0.009197051616629648), (0.9905051420006733,0.9900538501042633)]\n",
      "Area of window: 0.9665790135416406\n",
      "Intensity estimate for window: 206.91531390401323\n",
      "          x         y\n",
      "0  0.374540  0.950714\n",
      "1  0.731994  0.598658\n",
      "2  0.156019  0.155995\n",
      "3  0.058084  0.866176\n",
      "4  0.601115  0.708073\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.374540</td>\n",
       "      <td>0.950714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.731994</td>\n",
       "      <td>0.598658</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.156019</td>\n",
       "      <td>0.155995</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.058084</td>\n",
       "      <td>0.866176</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.601115</td>\n",
       "      <td>0.708073</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          x         y\n",
       "0  0.374540  0.950714\n",
       "1  0.731994  0.598658\n",
       "2  0.156019  0.155995\n",
       "3  0.058084  0.866176\n",
       "4  0.601115  0.708073"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Build an unmarked PointPattern\n",
    "pp = PointPattern(coords)\n",
    "\n",
    "pp.summary()  # quick textual summary\n",
    "pp.df.head()  # underlying DataFrame with coordinates only (x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "688e56e9",
   "metadata": {},
   "source": [
    "At this stage, `pp` has only coordinates (`x`, `y`) and **no marks**.\n",
    "\n",
    "Internally, `PointPattern` stores the data in a pandas DataFrame (`pp.df`).\n",
    "Any extra columns we add will be treated as marks (attributes) of the\n",
    "points. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11f0062c",
   "metadata": {},
   "source": [
    "## 2. Add categorical and numeric marks with `add_marks`\n",
    "\n",
    "We will assign two marks to each point:\n",
    "\n",
    "- `type`: a **categorical** mark taking values `'A'` or `'B'`.\n",
    "- `value`: a **continuous** mark drawn from a normal distribution.\n",
    "\n",
    "We use the `add_marks(marks, mark_names=None)` method of `PointPattern`\n",
    "to attach these attributes. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "58797dbf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>type</th>\n",
       "      <th>value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.374540</td>\n",
       "      <td>0.950714</td>\n",
       "      <td>A</td>\n",
       "      <td>1.071554</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.731994</td>\n",
       "      <td>0.598658</td>\n",
       "      <td>B</td>\n",
       "      <td>0.838322</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.156019</td>\n",
       "      <td>0.155995</td>\n",
       "      <td>A</td>\n",
       "      <td>1.532274</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.058084</td>\n",
       "      <td>0.866176</td>\n",
       "      <td>B</td>\n",
       "      <td>0.655587</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.601115</td>\n",
       "      <td>0.708073</td>\n",
       "      <td>A</td>\n",
       "      <td>5.707410</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          x         y type     value\n",
       "0  0.374540  0.950714    A  1.071554\n",
       "1  0.731994  0.598658    B  0.838322\n",
       "2  0.156019  0.155995    A  1.532274\n",
       "3  0.058084  0.866176    B  0.655587\n",
       "4  0.601115  0.708073    A  5.707410"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = pp.n\n",
    "\n",
    "# Categorical mark: two types, A and B\n",
    "types = np.random.choice([\"A\", \"B\"], size=n, p=[0.6, 0.4])\n",
    "\n",
    "# Numeric mark: e.g. \"intensity\" or \"size\" for each event\n",
    "values = np.random.gamma(shape=2.0, scale=1.0, size=n)\n",
    "\n",
    "# Attach both marks to the point pattern\n",
    "pp.add_marks([types, values], mark_names=[\"type\", \"value\"])\n",
    "\n",
    "pp.df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72f763b1",
   "metadata": {},
   "source": [
    "Now `pp` is a **marked point pattern**. The DataFrame has four columns:\n",
    "`x`, `y` (coordinates) and `type`, `value` (marks).\n",
    "\n",
    "We can work with marks using standard pandas tools, for example to\n",
    "compute simple summaries by type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1b8e99e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type\n",
       "A    114\n",
       "B     86\n",
       "Name: count, dtype: int64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Counts by categorical mark\n",
    "pp.df[\"type\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4a80a2a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type\n",
       "A    2.000269\n",
       "B    1.736881\n",
       "Name: value, dtype: float64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Mean of the numeric mark by type\n",
    "pp.df.groupby(\"type\")[\"value\"].mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51984ed0",
   "metadata": {},
   "source": [
    "## 3. Visualizing a marked point pattern\n",
    "\n",
    "Let’s write a helper to plot points colored by a categorical mark, here\n",
    "`type`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "24547460",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_marked_pattern(pp, mark_column=\"type\", ax=None, title=None):\n",
    "    \"\"\"Plot a marked point pattern, coloring by a categorical mark.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    pp : pointpats.PointPattern\n",
    "        Marked point pattern.\n",
    "    mark_column : str\n",
    "        Column in `pp.df` containing categorical marks.\n",
    "    ax : matplotlib.axes.Axes, optional\n",
    "        Axis to plot on.\n",
    "    title : str, optional\n",
    "        Plot title.\n",
    "    \"\"\"\n",
    "    if ax is None:\n",
    "        fig, ax = plt.subplots(figsize=(5, 5))\n",
    "\n",
    "    df = pp.df\n",
    "    categories = df[mark_column].astype(\"category\")\n",
    "    cats = categories.cat.categories\n",
    "\n",
    "    # Basic color cycle\n",
    "    colors = plt.rcParams[\"axes.prop_cycle\"].by_key()[\"color\"]\n",
    "\n",
    "    for i, cat in enumerate(cats):\n",
    "        sub = df[categories == cat]\n",
    "        ax.scatter(sub[pp.coord_names[0]], sub[pp.coord_names[1]],\n",
    "                   s=15, label=f\"{mark_column} = {cat}\",\n",
    "                   color=colors[i % len(colors)], alpha=0.8)\n",
    "\n",
    "    # Use the window of the pattern to set plot limits\n",
    "    xmin, ymin, xmax, ymax = pp.window.bbox\n",
    "    ax.set_xlim(xmin, xmax)\n",
    "    ax.set_ylim(ymin, ymax)\n",
    "    ax.set_aspect(\"equal\", adjustable=\"box\")\n",
    "    ax.set_xlabel(pp.coord_names[0])\n",
    "    ax.set_ylabel(pp.coord_names[1])\n",
    "    if title:\n",
    "        ax.set_title(title)\n",
    "    ax.legend(loc=\"best\")\n",
    "\n",
    "    return ax\n",
    "\n",
    "\n",
    "plot_marked_pattern(pp, mark_column=\"type\",\n",
    "                    title=\"Marked point pattern colored by type\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efef5a3e",
   "metadata": {},
   "source": [
    "The colors distinguish the mark categories (`type = 'A'` vs `type = 'B'`).\n",
    "You can adapt the plotting function to map numeric marks to size or\n",
    "color gradients if desired."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae87e7b0",
   "metadata": {},
   "source": [
    "## 4. Splitting a marked pattern with `explode`\n",
    "\n",
    "To analyze each mark category as its own point pattern, we can use the\n",
    "`explode(mark)` method of `PointPattern`. It returns a list of\n",
    "`PointPattern` objects, one per unique value of the mark. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b6421f39",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['A', 'B'], dtype='object')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Unique categories in the \"type\" mark\n",
    "categories = pp.df[\"type\"].astype(\"category\").cat.categories\n",
    "categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b367b558",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Explode into a list of unmarked patterns, one per category\n",
    "pps_by_type = pp.explode(\"type\")\n",
    "\n",
    "len(pps_by_type)  # should match the number of unique categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e7870bdb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Category 'A' -> 114 points\n",
      "Category 'B' -> 86 points\n"
     ]
    }
   ],
   "source": [
    "for cat, sub_pp in zip(categories, pps_by_type):\n",
    "    print(f\"Category {cat!r} -> {sub_pp.n} points\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4d3b414",
   "metadata": {},
   "source": [
    "We can visualize each category in its own panel to compare their\n",
    "spatial distributions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e2a5098e-f418-41b6-8857-7313589a58e1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, len(pps_by_type), figsize=(5 * len(pps_by_type), 4))\n",
    "if len(pps_by_type) == 1:\n",
    "    axes = [axes]\n",
    "\n",
    "for ax, cat, sub_pp in zip(axes, categories, pps_by_type):\n",
    "    df = sub_pp.df\n",
    "    xname, yname = sub_pp.coord_names\n",
    "\n",
    "    ax.scatter(df[xname], df[yname], s=15, alpha=0.8)\n",
    "    xmin, ymin, xmax, ymax = sub_pp.window.bbox\n",
    "    ax.set_xlim(xmin, xmax)\n",
    "    ax.set_ylim(ymin, ymax)\n",
    "    ax.set_aspect(\"equal\", adjustable=\"box\")\n",
    "    ax.set_title(f\"type = {cat}\")\n",
    "    ax.set_xlabel(xname)\n",
    "    ax.set_ylabel(yname)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5711efc6",
   "metadata": {},
   "source": [
    "Each panel now shows the points belonging to a single mark category.\n",
    "\n",
    "This is useful when you want to treat each type as its **own** point\n",
    "pattern (e.g., trees of different species, crimes of different types)\n",
    "and compare their intensities, clustering, or nearest-neighbor behavior."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80cda364",
   "metadata": {},
   "source": [
    "## 5. Using numeric marks as weights: weighted mean center\n",
    "\n",
    "Numeric marks are often used as **weights** when summarizing the pattern.\n",
    "For example, you might weight accidents by the number of injuries or\n",
    "trees by their biomass.\n",
    "\n",
    "The function `weighted_mean_center(points, weights)` computes a\n",
    "weighted mean center, where each point contributes proportionally to its\n",
    "weight. \n",
    "\n",
    "Here we compare the (unweighted) mean center of the pattern to the\n",
    "weighted mean center using the `value` mark as weights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b11cb2d4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.49831839, 0.49006298]), array([0.50793006, 0.47675179]))"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Unweighted mean center\n",
    "mc = mean_center(pp.points)\n",
    "\n",
    "# Weighted mean center using the numeric mark \"value\" as weights\n",
    "wmc = weighted_mean_center(pp.points, pp.df[\"value\"].values)\n",
    "\n",
    "mc, wmc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e09e6e5c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(5, 5))\n",
    "\n",
    "# Plot marked pattern with small gray points\n",
    "ax.scatter(pp.df[pp.coord_names[0]], pp.df[pp.coord_names[1]],\n",
    "           s=10, alpha=0.5, label=\"events\")\n",
    "\n",
    "xmin, ymin, xmax, ymax = pp.window.bbox\n",
    "ax.set_xlim(xmin, xmax)\n",
    "ax.set_ylim(ymin, ymax)\n",
    "ax.set_aspect(\"equal\", adjustable=\"box\")\n",
    "\n",
    "# Add unweighted and weighted mean centers\n",
    "ax.plot(mc[0], mc[1], \"b^\", markersize=10, label=\"mean center\")\n",
    "ax.plot(wmc[0], wmc[1], \"ro\", markersize=10, label=\"weighted mean center\")\n",
    "\n",
    "ax.set_xlabel(pp.coord_names[0])\n",
    "ax.set_ylabel(pp.coord_names[1])\n",
    "ax.set_title(\"Unweighted vs weighted mean center\")\n",
    "ax.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a67d5d9",
   "metadata": {},
   "source": [
    "The weighted mean center is pulled toward points with larger `value`.\n",
    "This is a simple example of how numeric marks can affect spatial\n",
    "summaries.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff56dbf8",
   "metadata": {},
   "source": [
    "## 6. Creating a marked pattern directly from an array\n",
    "\n",
    "Instead of starting with an unmarked pattern and calling `add_marks`,\n",
    "you can also pass a full `(n, p)` array (coordinates + attributes) into\n",
    "`PointPattern` and specify `names` for the columns. \n",
    "\n",
    "In this example we build a second point pattern whose coordinates and\n",
    "marks are all stored in a single NumPy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "16c80159",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>type_code</th>\n",
       "      <th>value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.374540</td>\n",
       "      <td>0.950714</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.071554</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.731994</td>\n",
       "      <td>0.598658</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.838322</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.156019</td>\n",
       "      <td>0.155995</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.532274</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.058084</td>\n",
       "      <td>0.866176</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.655587</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.601115</td>\n",
       "      <td>0.708073</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.707410</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          x         y  type_code     value\n",
       "0  0.374540  0.950714        0.0  1.071554\n",
       "1  0.731994  0.598658        1.0  0.838322\n",
       "2  0.156019  0.155995        0.0  1.532274\n",
       "3  0.058084  0.866176        1.0  0.655587\n",
       "4  0.601115  0.708073        0.0  5.707410"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Build a new (n, 4) array: x, y, type_code, value\n",
    "type_code = (types == \"B\").astype(float)  # 0 for A, 1 for B\n",
    "points_with_marks = np.column_stack([pp.points, type_code, values])\n",
    "\n",
    "names = [\"x\", \"y\", \"type_code\", \"value\"]\n",
    "pp2 = PointPattern(points_with_marks, names=names)\n",
    "\n",
    "pp2.df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5d08eb8",
   "metadata": {},
   "source": [
    "Here, `pp2` is also a marked point pattern: `x`, `y` are coordinates,\n",
    "and `type_code`, `value` are marks.\n",
    "\n",
    "This pattern (constructing a full `(n, p)` table and passing it to\n",
    "`PointPattern`) is convenient when your data already live in a\n",
    "DataFrame or when loading from a CSV or GIS table."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09d0bb9f",
   "metadata": {},
   "source": [
    "## Recap\n",
    "\n",
    "In this notebook, we have:\n",
    "\n",
    "- Built an **unmarked** `PointPattern` from simulated coordinates.\n",
    "- Attached **categorical** and **numeric** marks with `add_marks`.\n",
    "- Used `pp.df` (a pandas DataFrame) to summarize marks by category.\n",
    "- Visualized a marked point pattern with color by categorical mark.\n",
    "- Applied `explode` to split a marked pattern into separate patterns,\n",
    "  one per mark category.\n",
    "- Computed a **weighted mean center** using a numeric mark as weights.\n",
    "- Created a marked pattern directly from a full `(n, p)` array with\n",
    "  coordinate and mark columns.\n",
    "\n",
    "These tools form the core of working with **marked point patterns** in\n",
    "`pointpats`. You can combine them with quadrat statistics, distance-based\n",
    "functions, and space–time tests for more advanced analyses.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}