Upload 2 files

page_files/categorized/Backend/plot_mapping_ui.py

@@ -0,0 +1,397 @@
+"""
+plot_mapping_ui.py
+------------------
+Drop-in replacement for the "Extracted Plots" tab (tab2) in Upload_Data.py.
+
+HOW TO INTEGRATE
+────────────────
+1. Copy plot_property_mapper.py next to upload_backend.py.
+2. In Upload_Data.py, add at the top:
+
+       from plot_mapping_ui import render_plot_mapping_tab
+
+3. Replace the entire `with tab2:` block with:
+
+       with tab2:
+           render_plot_mapping_tab(pdf_path, paper_id)
+
+That's it.  The function reads everything it needs from st.session_state
+(which your existing tab1 code already populates).
+"""
+
+import json
+import os
+
+import cv2
+import numpy as np
+import streamlit as st
+
+from plot_property_mapper import (
+    batch_map_plots,
+    fetch_properties_for_material,
+    save_plot_image_mapping,
+)
+
+# ── tiny helper ───────────────────────────────────────────────────────────────
+
+def _confidence_badge(conf: str) -> str:
+    colors = {"high": "#16a34a", "medium": "#d97706", "low": "#dc2626"}
+    c = colors.get(conf.lower(), "#6b7280")
+    return (
+        f"<span style='background:{c};color:#fff;padding:2px 10px;"
+        f"border-radius:99px;font-size:0.78rem;font-weight:700'>{conf.upper()}</span>"
+    )
+
+
+# ── main render function ───────────────────────────────────────────────────────
+
+def render_plot_mapping_tab(pdf_path: str, paper_id: str):
+    """Render the full Extracted Plots + Property Mapping tab."""
+
+    st.subheader("Extracted Plot Images & Property Mapping")
+
+    # ── session-state keys ────────────────────────────────────────────────────
+    for key, default in [
+        ("pdf_processed",       False),
+        ("image_results",       []),
+        ("mapped_results",      []),
+        ("mapping_done",        False),
+        ("saved_image_mapping", {}),
+        ("pdf_extracted_df",    __import__("pandas").DataFrame()),
+        ("pdf_extracted_meta",  {}),
+    ]:
+        if key not in st.session_state:
+            st.session_state[key] = default
+
+    # ── 1. Extract plots if not done yet ─────────────────────────────────────
+    if not st.session_state.pdf_processed:
+        with st.spinner("Extracting plots from PDF…"):
+            import fitz
+            from upload_backend import extract_images
+
+            doc = fitz.open(pdf_path)
+            st.session_state.image_results = extract_images(doc)
+            doc.close()
+            st.session_state.pdf_processed  = True
+            st.session_state.mapping_done   = False   # reset mapping on new PDF
+
+    image_results = st.session_state.image_results
+
+    if not image_results:
+        st.warning("No plots found in this PDF.")
+        return
+
+    # ── 2. Info bar ───────────────────────────────────────────────────────────
+    has_data = not st.session_state.pdf_extracted_df.empty
+    material_class = st.session_state.get("selected_material_class")   # set below
+
+    if has_data:
+        df = st.session_state.pdf_extracted_df
+        mat_abbr = df.iloc[0]["material_abbreviation"]
+        st.info(
+            f"**{len(image_results)} plots** extracted  |  "
+            f"Material: **{mat_abbr}**  |  "
+            f"{len(df['property_name'].unique())} DB properties available"
+        )
+    else:
+        st.warning(
+            "Extract material data in the **Material Data** tab first "
+            "to enable AI property mapping."
+        )
+
+    st.divider()
+
+    # ── 3. Download buttons (always visible) ──────────────────────────────────
+    from upload_backend import create_zip
+
+    col_img, col_json, col_all = st.columns(3)
+    with col_img:
+        img_zip = create_zip(image_results, include_json=False)
+        st.download_button(
+            "⬇ Download Images",
+            data=img_zip,
+            file_name=f"{paper_id}_images.zip",
+            mime="application/zip",
+            use_container_width=True,
+            key="dl_images",
+        )
+    with col_json:
+        json_data = [
+            {"caption": r["caption"], "page": r["page"],
+             "image_count": len(r["image_data"])}
+            for r in image_results
+        ]
+        st.download_button(
+            "⬇ Download JSON",
+            data=json.dumps(json_data, indent=4),
+            file_name=f"{paper_id}_metadata.json",
+            mime="application/json",
+            use_container_width=True,
+            key="dl_json",
+        )
+    with col_all:
+        full_zip = create_zip(image_results, include_json=True)
+        st.download_button(
+            "⬇ Download All",
+            data=full_zip,
+            file_name=f"{paper_id}_complete.zip",
+            mime="application/zip",
+            use_container_width=True,
+            key="dl_all",
+        )
+
+    st.divider()
+
+    # ── 4. AI mapping panel (only when data is extracted) ────────────────────
+    if has_data:
+        from db import fetch_all  # your existing db module
+
+        df          = st.session_state.pdf_extracted_df
+        mat_abbr    = df.iloc[0]["material_abbreviation"]
+        extracted_json = st.session_state.get("pdf_extracted_meta", {})
+
+        # Material class selector (needed to route to the right table)
+        material_class = st.selectbox(
+            "Material class (for DB lookup)",
+            ["Polymer", "Fiber", "Composite"],
+            index=0,
+            key="selected_material_class",
+            help="Determines which PostgreSQL table to fetch properties from.",
+        )
+
+        run_mapping = st.button(
+            "🤖  Run AI Property Mapping",
+            type="primary",
+            disabled=st.session_state.mapping_done,
+            help="Sends each plot + caption + extracted JSON to Gemini for matching.",
+        )
+
+        if run_mapping:
+            # Fetch DB properties
+            with st.spinner("Fetching properties from PostgreSQL…"):
+                try:
+                    db_properties = fetch_properties_for_material(
+                        mat_abbr, material_class, fetch_all
+                    )
+                except Exception as exc:
+                    st.error(f"DB error: {exc}")
+                    db_properties = []
+
+            if not db_properties:
+                st.warning(
+                    f"No properties found for **{mat_abbr}** in the "
+                    f"**{material_class}** table.  Mapping will use all properties."
+                )
+
+            # Run batch mapping with progress bar
+            progress_bar = st.progress(0, text="Mapping plots…")
+
+            def _update(i, total, caption):
+                pct = int((i / max(total, 1)) * 100)
+                progress_bar.progress(
+                    pct,
+                    text=f"Mapping {i+1}/{total}: {caption[:60]}…",
+                )
+
+            with st.spinner("AI is analysing plots…"):
+                mapped = batch_map_plots(
+                    image_results=image_results,
+                    extracted_json=extracted_json,
+                    db_properties=db_properties,
+                    progress_callback=_update,
+                )
+
+            progress_bar.progress(100, text="Done!")
+            st.session_state.mapped_results = mapped
+            st.session_state.mapping_done   = True
+            st.success(f"✅  Mapped {len(mapped)} plots")
+            st.rerun()
+
+        if st.session_state.mapping_done and st.session_state.mapped_results:
+            st.caption("Mapping complete. Review & confirm each match below.")
+
+    st.divider()
+
+    # ── 5. Plot cards ─────────────────────────────────────────────────────────
+    use_mapped = (
+        has_data
+        and st.session_state.mapping_done
+        and bool(st.session_state.mapped_results)
+    )
+
+    display_list = (
+        st.session_state.mapped_results if use_mapped else image_results
+    )
+
+    for idx, item in enumerate(display_list):
+        caption     = item.get("caption", f"Figure {idx+1}")
+        page        = item.get("page", "?")
+        img_list    = item.get("image_data", [])
+        mapping     = item.get("mapping_result") if use_mapped else None
+
+        with st.container(border=True):
+
+            # — header row —
+            col_cap, col_del = st.columns([0.88, 0.12])
+            col_cap.markdown(f"**Page {page}** — {caption}")
+            if col_del.button("🗑 Delete", key=f"del_group_{idx}"):
+                if use_mapped:
+                    st.session_state.mapped_results.pop(idx)
+                else:
+                    st.session_state.image_results.pop(idx)
+                st.rerun()
+
+            # — AI mapping result banner —
+            if mapping:
+                prop_name  = mapping.get("property_name", "")
+                section    = mapping.get("section", "")
+                confidence = mapping.get("confidence", "low")
+                reasoning  = mapping.get("reasoning", "")
+                db_row     = mapping.get("db_row")
+                candidates = mapping.get("all_candidates", [])
+
+                badge = _confidence_badge(confidence)
+                if prop_name:
+                    st.markdown(
+                        f"🔗 **AI Match:** `{section}` › **{prop_name}** &nbsp; {badge}",
+                        unsafe_allow_html=True,
+                    )
+                    if reasoning:
+                        st.caption(f"💬 {reasoning}")
+
+                    # DB row details
+                    if db_row:
+                        with st.expander("📋 Matched DB row", expanded=False):
+                            col_v, col_u, col_c = st.columns(3)
+                            col_v.metric("Value",    db_row.get("value",        "—"))
+                            col_u.metric("Unit",     db_row.get("unit",         "—"))
+                            col_c.metric("Condition", db_row.get("test_condition", "—"))
+                            if db_row.get("comments"):
+                                st.caption(f"Comments: {db_row['comments']}")
+                            if db_row.get("english"):
+                                st.caption(f"English units: {db_row['english']}")
+
+                    # Alternative candidates
+                    if candidates:
+                        with st.expander("🔄 All candidates", expanded=False):
+                            for c in candidates:
+                                rank = c.get("rank", "?")
+                                cn   = c.get("confidence", "low")
+                                st.markdown(
+                                    f"{rank}. `{c.get('section','?')}` › "
+                                    f"**{c.get('property_name','?')}** "
+                                    f"&nbsp; {_confidence_badge(cn)}",
+                                    unsafe_allow_html=True,
+                                )
+                else:
+                    st.warning("⚠️ AI could not match this plot to any DB property.")
+
+            # — sub-images —
+            for p_idx, img_data in enumerate(img_list):
+                bgr = img_data.get("array")
+                if bgr is None:
+                    continue
+
+                img_key = f"{idx}_{p_idx}_{page}"
+
+                # Show the plot
+                st.image(bgr, channels="BGR", width=420)
+
+                # — mapping controls —
+                if has_data:
+                    df          = st.session_state.pdf_extracted_df
+                    mat_abbr    = df.iloc[0]["material_abbreviation"]
+                    property_list = df["property_name"].unique().tolist()
+
+                    # Pre-select the AI suggestion if available
+                    ai_suggestion = mapping.get("property_name", "") if mapping else ""
+                    default_idx   = 0
+                    options       = ["— Select property —"] + property_list
+                    if ai_suggestion in property_list:
+                        default_idx = property_list.index(ai_suggestion) + 1
+
+                    col_sel, col_sec, col_save, col_rem = st.columns(
+                        [0.42, 0.18, 0.20, 0.20]
+                    )
+
+                    with col_sel:
+                        selected = st.selectbox(
+                            "Property",
+                            options=options,
+                            index=default_idx,
+                            key=f"prop_sel_{img_key}",
+                            label_visibility="collapsed",
+                        )
+
+                    with col_sec:
+                        section_override = st.text_input(
+                            "Section",
+                            value=mapping.get("section", "") if mapping else "",
+                            key=f"sec_{img_key}",
+                            label_visibility="collapsed",
+                            placeholder="Section",
+                        )
+
+                    with col_save:
+                        if st.button("💾 Save", key=f"save_{img_key}"):
+                            if selected and selected != "— Select property —":
+                                filepath = save_plot_image_mapping(
+                                    mat_abbr,
+                                    selected,
+                                    section_override,
+                                    bgr,
+                                    save_dir="images",
+                                )
+                                st.session_state.saved_image_mapping[img_key] = {
+                                    "property":  selected,
+                                    "section":   section_override,
+                                    "caption":   caption,
+                                    "filename":  os.path.basename(filepath),
+                                    "path":      filepath,
+                                }
+                                st.success(f"Saved → `{os.path.basename(filepath)}`")
+                                st.rerun()
+                            else:
+                                st.warning("Select a property first.")
+
+                    with col_rem:
+                        if st.button("✕ Remove", key=f"rem_{img_key}"):
+                            img_list.pop(p_idx)
+                            if not img_list:
+                                if use_mapped:
+                                    st.session_state.mapped_results.pop(idx)
+                                else:
+                                    st.session_state.image_results.pop(idx)
+                            st.rerun()
+
+                    # Saved badge
+                    if img_key in st.session_state.saved_image_mapping:
+                        m = st.session_state.saved_image_mapping[img_key]
+                        st.info(f"✅ Saved as **{m['property']}** → `{m['filename']}`")
+
+                else:
+                    # No data extracted yet — just allow removal
+                    col_msg, col_rem = st.columns([0.80, 0.20])
+                    col_msg.caption(
+                        "Extract material data in the **Material Data** tab to enable mapping."
+                    )
+                    if col_rem.button("✕ Remove", key=f"rem_nodata_{img_key}"):
+                        img_list.pop(p_idx)
+                        if not img_list:
+                            st.session_state.image_results.pop(idx)
+                        st.rerun()
+
+                st.divider()
+
+    # ── 6. Saved-mappings summary ─────────────────────────────────────────────
+    if st.session_state.saved_image_mapping:
+        with st.expander(
+            f"📁 Saved mappings ({len(st.session_state.saved_image_mapping)})",
+            expanded=False,
+        ):
+            for key, info in st.session_state.saved_image_mapping.items():
+                st.markdown(
+                    f"**{info['property']}** &nbsp;›&nbsp; `{info['filename']}`  \n"
+                    f"<small>Caption: {info['caption']}</small>",
+                    unsafe_allow_html=True,
+                )

page_files/categorized/Backend/plot_property_mapper.py

@@ -0,0 +1,385 @@
+"""
+plot_property_mapper.py
+-----------------------
+Maps extracted plot images to material properties stored in PostgreSQL.
+
+Strategy:
+  1. Fetch all properties for the material from the DB (Polymers / Fibers / Composites_materials)
+  2. For each plot: send image + caption + extracted JSON data to Gemini
+  3. Gemini returns the best-matching property_name + confidence reasoning
+  4. Caller can confirm/override and persist the match
+
+DB schema (per table: Polymers, Fibers, Composites_materials):
+    material_name, material_abbreviation, section,
+    property_name, value, unit, english, test_condition, comments
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import re
+from io import BytesIO
+from typing import Any
+
+import cv2
+import numpy as np
+import requests
+from PIL import Image
+
+# ---------------------------------------------------------------------------
+# Gemini config  (re-uses the same key / model you already use)
+# ---------------------------------------------------------------------------
+_GEMINI_KEY = os.getenv(
+    "GEMINI_API_KEY",
+    "AIzaSyAuI-qwSCRpdAcGTvNNaS70NkxlLMSrWF0",   # fallback – prefer env var
+)
+_GEMINI_MODEL = "gemini-2.5-flash-preview-09-2025"
+_GEMINI_URL = (
+    f"https://generativelanguage.googleapis.com/v1beta/"
+    f"models/{_GEMINI_MODEL}:generateContent?key={_GEMINI_KEY}"
+)
+
+# ---------------------------------------------------------------------------
+# Table routing  (mirrors data_loader.py)
+# ---------------------------------------------------------------------------
+TABLE_MAP = {
+    "Polymer":   "Polymers",
+    "Fiber":     "Fibers",
+    "Composite": "Composites_materials",
+}
+
+# ---------------------------------------------------------------------------
+# DB helpers  (thin wrappers – import your existing fetch_all from db.py)
+# ---------------------------------------------------------------------------
+
+def fetch_properties_for_material(
+    material_abbr: str,
+    material_class: str,
+    fetch_all_fn,               # pass db.fetch_all so we don't re-import
+) -> list[dict]:
+    """
+    Return all property rows for a given material abbreviation.
+    Falls back to all rows in the table if nothing matches the abbreviation.
+    """
+    table = TABLE_MAP.get(material_class)
+    if not table:
+        raise ValueError(f"Unknown material_class: {material_class!r}")
+
+    query = f"""
+        SELECT
+            material_name,
+            material_abbreviation,
+            section,
+            property_name,
+            value,
+            unit,
+            english,
+            test_condition,
+            comments
+        FROM "{table}"
+        WHERE LOWER(material_abbreviation) = LOWER(:abbr)
+        ORDER BY section, property_name
+    """
+    rows = fetch_all_fn(query, {"abbr": material_abbr})
+
+    # fallback: try by name fragment
+    if not rows:
+        query2 = f"""
+            SELECT
+                material_name, material_abbreviation, section,
+                property_name, value, unit, english, test_condition, comments
+            FROM "{table}"
+            ORDER BY section, property_name
+        """
+        rows = fetch_all_fn(query2)
+
+    return rows
+
+
+def save_plot_image_mapping(
+    material_abbr: str,
+    property_name: str,
+    section: str,
+    image_array: np.ndarray,    # BGR numpy array from cv2
+    save_dir: str = "images",
+) -> str:
+    """
+    Save the plot image to disk as  <save_dir>/<abbr>_<safe_property>.png
+    Returns the file path.
+    """
+    os.makedirs(save_dir, exist_ok=True)
+    safe_prop = re.sub(r"[^\w\s-]", "", property_name).strip().replace(" ", "_")
+    filename = f"{material_abbr}_{safe_prop}.png"
+    filepath = os.path.join(save_dir, filename)
+    cv2.imwrite(filepath, image_array)
+    return filepath
+
+
+# ---------------------------------------------------------------------------
+# Core: Gemini image + data → property match
+# ---------------------------------------------------------------------------
+
+def _encode_image_bgr(bgr: np.ndarray) -> tuple[str, str]:
+    """Convert BGR numpy array → base64 PNG string."""
+    rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+    pil = Image.fromarray(rgb)
+    buf = BytesIO()
+    pil.save(buf, format="PNG")
+    b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
+    return b64, "image/png"
+
+
+def map_plot_to_property(
+    image_bgr: np.ndarray,
+    caption: str,
+    extracted_json: dict[str, Any],   # full Gemini data-extraction output
+    db_properties: list[dict],        # rows from fetch_properties_for_material
+    gemini_api_key: str | None = None,
+) -> dict:
+    """
+    Ask Gemini which DB property best matches this plot.
+
+    Returns
+    -------
+    {
+        "property_name": str,          # best match from DB
+        "section":       str,
+        "confidence":    "high"|"medium"|"low",
+        "reasoning":     str,
+        "db_row":        dict | None,  # full matching DB row
+        "all_candidates": list[dict],  # top-3 ranked by Gemini
+    }
+    """
+    key = gemini_api_key or _GEMINI_KEY
+    url = (
+        f"https://generativelanguage.googleapis.com/v1beta/"
+        f"models/{_GEMINI_MODEL}:generateContent?key={key}"
+    )
+
+    # Build a compact list of DB properties for the prompt
+    prop_list_text = "\n".join(
+        f"  - [{row['section']}] {row['property_name']}  "
+        f"(value={row['value']}, unit={row['unit']})"
+        for row in db_properties[:80]   # cap at 80 to stay within context
+    )
+
+    # Compact extracted JSON (just material + property names + values)
+    extracted_summary = {
+        "material_name": extracted_json.get("material_name", ""),
+        "material_abbreviation": extracted_json.get("material_abbreviation", ""),
+        "properties": [
+            {
+                "section": p.get("section"),
+                "property_name": p.get("property_name"),
+                "value": p.get("value"),
+                "unit": p.get("unit"),
+            }
+            for p in extracted_json.get("mechanical_properties", [])[:40]
+        ],
+    }
+
+    prompt = f"""You are an expert materials scientist.
+
+TASK: Identify which property from the DATABASE LIST best matches the provided plot image.
+
+PLOT CAPTION:
+"{caption}"
+
+EXTRACTED TEXT DATA FROM THE SAME PDF (JSON summary):
+{json.dumps(extracted_summary, indent=2)}
+
+DATABASE PROPERTIES FOR THIS MATERIAL:
+{prop_list_text}
+
+INSTRUCTIONS:
+1. Examine the plot image carefully (axes labels, units, curve shapes, legend text).
+2. Use the caption AND the extracted JSON data as additional context.
+3. Select the TOP 3 best-matching property names from the DATABASE PROPERTIES list above.
+4. For each candidate give a confidence: high / medium / low.
+5. Return ONLY valid JSON — no markdown, no explanation outside the JSON.
+
+REQUIRED JSON FORMAT:
+{{
+  "best_match": {{
+    "property_name": "<exact name from DB list>",
+    "section": "<section from DB list>",
+    "confidence": "high|medium|low",
+    "reasoning": "<1-2 sentence explanation>"
+  }},
+  "candidates": [
+    {{"rank": 1, "property_name": "...", "section": "...", "confidence": "..."}},
+    {{"rank": 2, "property_name": "...", "section": "...", "confidence": "..."}},
+    {{"rank": 3, "property_name": "...", "section": "...", "confidence": "..."}}
+  ]
+}}
+"""
+
+    img_b64, img_mime = _encode_image_bgr(image_bgr)
+
+    payload = {
+        "contents": [
+            {
+                "parts": [
+                    {"text": prompt},
+                    {"inlineData": {"mimeType": img_mime, "data": img_b64}},
+                ]
+            }
+        ],
+        "generationConfig": {
+            "temperature": 0.0,
+            "responseMimeType": "application/json",
+        },
+    }
+
+    try:
+        resp = requests.post(url, json=payload, timeout=120)
+        resp.raise_for_status()
+        raw = resp.json()
+
+        parts = raw.get("candidates", [{}])[0].get("content", {}).get("parts", [])
+        json_text = ""
+        for p in parts:
+            t = p.get("text", "")
+            if t.strip().startswith("{"):
+                json_text = t
+                break
+
+        if not json_text:
+            return _empty_result("Gemini returned no JSON")
+
+        result = json.loads(json_text)
+
+    except Exception as exc:
+        return _empty_result(str(exc))
+
+    # Attach full DB row to best_match
+    best = result.get("best_match", {})
+    matched_prop = best.get("property_name", "")
+    db_row = next(
+        (r for r in db_properties if r["property_name"] == matched_prop),
+        None,
+    )
+    best["db_row"] = db_row
+
+    return {
+        "property_name": matched_prop,
+        "section":       best.get("section", ""),
+        "confidence":    best.get("confidence", "low"),
+        "reasoning":     best.get("reasoning", ""),
+        "db_row":        db_row,
+        "all_candidates": result.get("candidates", []),
+    }
+
+
+def _empty_result(error: str) -> dict:
+    return {
+        "property_name": "",
+        "section":       "",
+        "confidence":    "low",
+        "reasoning":     f"Error: {error}",
+        "db_row":        None,
+        "all_candidates": [],
+    }
+
+
+# ---------------------------------------------------------------------------
+# Batch mapper  (call once per PDF after extraction)
+# ---------------------------------------------------------------------------
+
+def batch_map_plots(
+    image_results: list[dict],      # from extract_images() in upload_backend.py
+    extracted_json: dict,           # from call_gemini_from_bytes()
+    db_properties: list[dict],      # from fetch_properties_for_material()
+    gemini_api_key: str | None = None,
+    progress_callback=None,         # optional fn(current, total, caption)
+) -> list[dict]:
+    """
+    Map every extracted plot to a DB property.
+
+    Returns a list parallel to image_results:
+    [
+      {
+        "caption":        str,
+        "page":           int,
+        "image_data":     [...],    # original image_data list
+        "mapping_result": { ...map_plot_to_property output... }
+      },
+      ...
+    ]
+    """
+    total = len(image_results)
+    out = []
+
+    for i, item in enumerate(image_results):
+        caption = item.get("caption", "")
+        page    = item.get("page", 0)
+
+        if progress_callback:
+            progress_callback(i, total, caption)
+
+        # Use first sub-image for mapping (usually there's only one per caption)
+        img_list = item.get("image_data", [])
+        if not img_list:
+            out.append({**item, "mapping_result": _empty_result("No image data")})
+            continue
+
+        bgr = img_list[0].get("array")
+        if bgr is None:
+            out.append({**item, "mapping_result": _empty_result("Missing array")})
+            continue
+
+        result = map_plot_to_property(
+            image_bgr=bgr,
+            caption=caption,
+            extracted_json=extracted_json,
+            db_properties=db_properties,
+            gemini_api_key=gemini_api_key,
+        )
+
+        out.append({
+            "caption":        caption,
+            "page":           page,
+            "image_data":     img_list,
+            "mapping_result": result,
+        })
+
+    return out
+
+def save_plot_image_to_db(
+    material_abbr: str,
+    property_name: str,
+    image_bgr,
+    material_class: str,
+    execute_query_fn,
+) -> bool:
+    """Save plot image as BYTEA into the matching property row in PostgreSQL."""
+
+    table_map = {
+        "Polymer":   "Polymers",
+        "Fiber":     "Fibers",
+        "Composite": "Composites_materials",
+    }
+    table = table_map.get(material_class)
+    if not table:
+        return False
+
+    _, buffer = cv2.imencode(".png", image_bgr)
+    image_bytes = buffer.tobytes()
+
+    query = f"""
+        UPDATE "{table}"
+        SET image = :image
+        WHERE LOWER(material_abbreviation) = LOWER(:abbr)
+        AND LOWER(property_name) = LOWER(:prop)
+    """
+    rows_updated = execute_query_fn(
+        query,
+        {
+            "image": image_bytes,
+            "abbr":  material_abbr,
+            "prop":  property_name,
+        }
+    )
+    return rows_updated > 0