Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,12 @@
+.git
+.gitignore
+.gitattributes
+.env
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.venv/
+.hf_vendor/
+outputs/
+Showcase.gif

.gitattributes

@@ -1,35 +1,19 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Auto detect text files and perform LF normalization
+* text=auto
+images/AISI[[:space:]]1045[[:space:]]and[[:space:]]AA5052_Ram[[:space:]]Speed.png filter=lfs diff=lfs merge=lfs -text
+images/ASAAAA_Coefficient[[:space:]]'a'[[:space:]]for[[:space:]]average[[:space:]]equivalent[[:space:]]strain[[:space:]](ε̄_ave).png filter=lfs diff=lfs merge=lfs -text
+images/ASAAAA_Flow[[:space:]]Stress[[:space:]]Equation[[:space:]](Lubricated).png filter=lfs diff=lfs merge=lfs -text
+images/ASAAAA_Flow[[:space:]]Stress[[:space:]]Equation[[:space:]](Power's[[:space:]]Law).png filter=lfs diff=lfs merge=lfs -text
+images/Epoxy[[:space:]]+[[:space:]]44%[[:space:]]Carbon[[:space:]]fiber_Tensile[[:space:]]Strength.png filter=lfs diff=lfs merge=lfs -text
+images/Home.png filter=lfs diff=lfs merge=lfs -text
+images/iPP_Curve[[:space:]]Error[[:space:]](Maximum).png filter=lfs diff=lfs merge=lfs -text
+images/iPP_Injection[[:space:]]Pressure[[:space:]](Pinject)[[:space:]]Range.png filter=lfs diff=lfs merge=lfs -text
+images/iPP_Injection[[:space:]]Rate[[:space:]](Rinject)[[:space:]]Range.png filter=lfs diff=lfs merge=lfs -text
+images/iPP_Melting[[:space:]]temperature.png filter=lfs diff=lfs merge=lfs -text
+images/iPP_Normalized[[:space:]]Root[[:space:]]Mean[[:space:]]Square[[:space:]]Error[[:space:]](NRMSE)[[:space:]]Distribution[[:space:]]Center.png filter=lfs diff=lfs merge=lfs -text
+images/logo.png filter=lfs diff=lfs merge=lfs -text
+images/Materials_bg_InDeS.png filter=lfs diff=lfs merge=lfs -text
+images/us_deptenergy.jpg filter=lfs diff=lfs merge=lfs -text
+logo.png filter=lfs diff=lfs merge=lfs -text
+page_files/categorized/ESS-min.jpg filter=lfs diff=lfs merge=lfs -text
+Showcase.gif filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,152 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintainted in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

.streamlit/config.toml

@@ -0,0 +1,14 @@
+[theme]
+base = "light"
+primaryColor = "#1d4ed8"
+backgroundColor = "#ffffff"
+secondaryBackgroundColor = "#ffffff"
+textColor = "#111827"
+font = "sans serif"
+borderColor = "rgba(0, 0, 0, 0)"
+showWidgetBorder = false
+
+[theme.sidebar]
+backgroundColor = "#ffffff"
+secondaryBackgroundColor = "#ffffff"
+textColor = "#111827"

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    STREAMLIT_BROWSER_GATHER_USAGE_STATS=false
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libglib2.0-0 \
+    libgl1 \
+    libsm6 \
+    libxext6 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt /app/requirements.txt
+RUN pip install --upgrade pip && pip install -r /app/requirements.txt
+
+COPY . /app
+
+EXPOSE 7860
+
+CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0", "--server.port=7860"]

README.md

@@ -1,10 +1,29 @@
 ---
 title: Mat Database
-emoji: 📚
-colorFrom: purple
-colorTo: yellow
+emoji: "🧪"
+colorFrom: blue
+colorTo: indigo
 sdk: docker
+app_port: 7860
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Mat Database
+
+Streamlit application for browsing and uploading material properties data.
+
+## Local Run
+
+```bash
+pip install -r requirements.txt
+streamlit run app.py
+```
+
+## Environment Variables
+
+- `GEMINI_API_KEY` (optional but required for PDF extraction with Gemini)
+- `DB_HOST` (optional, required for database-backed browsing/upload)
+- `DB_PORT` (optional, defaults to `5432`)
+- `DB_NAME` (optional, required for database-backed browsing/upload)
+- `DB_USER` (optional, required for database-backed browsing/upload)
+- `DB_PASSWORD` (optional, required for database-backed browsing/upload)

app.py

@@ -0,0 +1,15 @@
+import streamlit as st
+
+st.set_page_config(layout="wide", initial_sidebar_state="collapsed")
+
+pages = {
+    "": [
+        st.Page("page_files/Home.py", title="Home"),
+        st.Page("page_files/Categorized_Search.py", title="Categorized Search"),
+        st.Page("page_files/Upload_Data.py", title="Upload Data"),
+        st.Page("page_files/Contact_Team.py", title="Contact Team"),
+    ]
+}
+
+pg = st.navigation(pages, position="top")
+pg.run()

data_loader.py

@@ -0,0 +1,116 @@
+from db import execute_query, fetch_all
+import pandas as pd
+
+EMPTY_MATERIAL_COLUMNS = [
+    "material_name",
+    "material_abbreviation",
+    "section",
+    "property_name",
+    "value",
+    "unit",
+    "english",
+    "test_condition",
+    "comments",
+]
+
+def load_material_data(material_type: str) -> pd.DataFrame:
+    table_map = {
+        "Polymers": "Polymers",
+        "Fibers": "Fibers",
+        "Composites": "Composites_materials",  
+    }
+
+    table = table_map.get(material_type)
+    if not table:
+        return pd.DataFrame(columns=EMPTY_MATERIAL_COLUMNS)
+
+    query = f"""
+        SELECT
+            material_name,
+            material_abbreviation,
+            section,
+            property_name,
+            value,
+            unit,
+            english,
+            test_condition,
+            comments
+        FROM "{table}"
+    """
+
+    try:
+        rows = fetch_all(query)
+    except Exception:
+        return pd.DataFrame(columns=EMPTY_MATERIAL_COLUMNS)
+    return pd.DataFrame(rows, columns=EMPTY_MATERIAL_COLUMNS)
+
+def get_all_sections():
+    all_data = pd.concat([
+        load_material_data("Polymers"),
+        load_material_data("Fibers"),
+        load_material_data("Composites"),
+    ], ignore_index=True)
+
+    if all_data.empty or "section" not in all_data.columns:
+        return []
+    return sorted(all_data["section"].dropna().unique().tolist())
+
+
+def insert_material_rows(df: pd.DataFrame) -> int:
+    if df is None or df.empty:
+        return 0
+
+    table_map = {
+        "Polymer": "Polymers",
+        "Fiber": "Fibers",
+        "Composite": "Composites_materials",
+    }
+
+    insert_template = """
+        INSERT INTO "{table}" (
+            material_name,
+            material_abbreviation,
+            section,
+            property_name,
+            value,
+            unit,
+            english,
+            test_condition,
+            comments
+        ) VALUES (
+            :material_name,
+            :material_abbreviation,
+            :section,
+            :property_name,
+            :value,
+            :unit,
+            :english,
+            :test_condition,
+            :comments
+        )
+    """
+
+    inserted = 0
+    for _, row in df.iterrows():
+        table = table_map.get(row.get("material_class"))
+        if not table:
+            continue
+
+        params = {
+            "material_name": row.get("material_name", ""),
+            "material_abbreviation": row.get("material_abbreviation", ""),
+            "section": row.get("section", ""),
+            "property_name": row.get("property_name", ""),
+            "value": row.get("value", ""),
+            "unit": row.get("unit", ""),
+            "english": row.get("english", ""),
+            "test_condition": row.get("test_condition", ""),
+            "comments": row.get("comments", ""),
+        }
+
+        try:
+            inserted += execute_query(insert_template.format(table=table), params)
+        except Exception:
+            return inserted
+
+    return inserted

db.py

@@ -0,0 +1,48 @@
+# db.py
+import os
+from sqlalchemy import create_engine, text
+from sqlalchemy.orm import sessionmaker
+from dotenv import load_dotenv
+
+load_dotenv()
+
+DB_HOST = os.getenv("DB_HOST")
+DB_PORT = os.getenv("DB_PORT", "5432")
+DB_NAME = os.getenv("DB_NAME")
+DB_USER = os.getenv("DB_USER")
+DB_PASSWORD = os.getenv("DB_PASSWORD")
+
+DATABASE_URL = None
+engine = None
+SessionLocal = None
+
+if all([DB_HOST, DB_NAME, DB_USER, DB_PASSWORD]):
+    DATABASE_URL = f"postgresql+psycopg://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
+    engine = create_engine(DATABASE_URL, pool_pre_ping=True)
+    SessionLocal = sessionmaker(bind=engine, autoflush=False, autocommit=False)
+
+
+def _require_engine():
+    if engine is None:
+        raise RuntimeError(
+            "Database is not configured. Set DB_HOST, DB_PORT, DB_NAME, DB_USER, and DB_PASSWORD."
+        )
+
+def fetch_all(query, params=None):
+    _require_engine()
+    with engine.connect() as conn:
+        result = conn.execute(text(query), params or {})
+        return [dict(row._mapping) for row in result]
+
+def fetch_one(query, params=None):
+    _require_engine()
+    with engine.connect() as conn:
+        result = conn.execute(text(query), params or {})
+        row = result.fetchone()
+        return dict(row._mapping) if row else None
+
+def execute_query(query, params=None):
+    _require_engine()
+    with engine.begin() as conn:
+        result = conn.execute(text(query), params or {})
+        return result.rowcount

images/desktop.ini

@@ -0,0 +1,3 @@
+[LocalizedFileNames]
+Screenshot 2026-01-20 001556.png=@Screenshot 2026-01-20 001556,0
+Screenshot 2026-01-20 001941.png=@Screenshot 2026-01-20 001941,0

page_files/Categorized_Search.py

@@ -0,0 +1,900 @@
+import base64
+import re
+from pathlib import Path
+
+import pandas as pd
+import streamlit as st
+from PIL import Image
+
+from data_loader import get_all_sections, load_material_data
+
+st.markdown(
+    """
+    <style>
+    [data-testid="stToolbar"],
+    [data-testid="stDecoration"],
+    [data-testid="stHeader"],
+    [data-testid="stSidebar"] {
+        display: none !important;
+    } 
+
+    [data-testid="stAppViewContainer"] {
+        background: #eef2f7 !important;
+    }
+
+    .st-emotion-cache-6c7yup [data-testid="stLayoutWrapper"] {
+        background: #fff !important;
+    
+    
+    }
+
+    .st-emotion-cache-18kf3ut [data-testid="stLayoutWrapper"] {
+        background: #fff !important;
+    
+    
+    }
+
+    .block-container {
+        max-width: 100% !important;
+        padding: 0.6rem 0.75rem 0.8rem 0.75rem !important;
+    }
+    
+    div[data-testid="stVerticalBlockBorderWrapper"] {
+        border-color: #e1e7ef !important;
+        border-radius: 10px !important;
+        background: #ffffff !important;
+    }
+
+    .aim-top-strip {
+        height: 54px;
+        border: 1px solid #e1e7ef;
+        border-radius: 10px;
+        background: #ffffff;
+        margin-bottom: 12px;
+    }
+
+    .st-key-top_search_row [data-testid="stHorizontalBlock"] {
+        gap: 0 !important;
+        align-items: stretch !important;
+    }
+
+    .st-key-top_search_input [data-baseweb="input"] {
+        height: 46px !important;
+        min-height: 46px !important;
+        border-radius: 50px 0 0 50px !important;
+        border-right: none !important;
+        border-color: #d0d8d4 !important;
+        background: #ffffff !important;
+    }
+
+    .st-key-top_search_input input {
+        height: 46px !important;
+        color: #0f1f1a !important;
+        font-family: 'DM Sans', sans-serif !important;
+        font-size: 0.92rem !important;
+        padding-left: 18px !important;
+    }
+
+    .st-key-top_search_input input::placeholder {
+        color: #0f1f1a !important;
+        opacity: 0.4 !important;
+    }
+
+    .st-key-top_search_btn button {
+        background: #8ACAFF !important;
+        border: 1.5px solid #8ACAFF !important;
+        border-left: none !important;
+        border-radius: 0 50px 50px 0 !important;
+        color: #0f1f1a !important;
+        font-family: 'DM Sans', sans-serif !important;
+        font-size: 0.88rem !important;
+        font-weight: 600 !important;
+        height: 46px !important;
+        padding: 0 28px !important;
+        box-shadow: none !important;
+    }
+
+    .st-key-top_search_input {
+        margin-right: 0 !important;
+        padding-right: 0 !important;
+    }
+
+    .st-key-top_search_btn {
+        margin-left: 0 !important;
+        padding-left: 0 !important;
+    }
+
+    .aim-logo {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        padding: 14px 14px 12px;
+        margin: -0.2rem -0.2rem 10px -0.2rem;
+        border-bottom: 1px solid #edf2f7;
+        border-top-left-radius: 10px;
+        border-top-right-radius: 10px;
+        background: #bae1fc;
+        color: #111827;
+        font-size: 0.92rem;
+        font-weight: 700;
+    }
+
+    .aim-sec {
+        color: #94a3b8;
+        font-size: 0.64rem;
+        font-weight: 700;
+        letter-spacing: 1.5px;
+        text-transform: uppercase;
+        margin: 8px 0 6px;
+    }
+
+    .aim-lbl {
+        color: #94a3b8;
+        font-size: 0.62rem;
+        font-weight: 700;
+        letter-spacing: 0.9px;
+        text-transform: uppercase;
+        margin: 3px 0;
+    }
+
+    .aim-breadcrumb {
+        color: #94a3b8;
+        font-size: 0.7rem;
+        letter-spacing: 0.3px;
+        margin-top: 4px;
+    }
+
+    .aim-breadcrumb span {
+        color: #3155d4;
+        font-weight: 600;
+    }
+
+    .aim-title {
+        color: #111827;
+        font-size: 2.95rem;
+        line-height: 1.03;
+        font-weight: 800;
+        margin: 4px 0 6px;
+    }
+
+    .aim-sub {
+        color: #64748b;
+        font-size: 0.82rem;
+    }
+
+    .aim-sub strong {
+        color: #111827;
+    }
+
+    .aim-selected {
+        color: #64748b;
+        font-size: 0.74rem;
+        margin-top: 10px;
+        line-height: 1.35;
+    }
+
+    .aim-selected b {
+        color: #111827;
+    }
+
+    .stButton > button {
+        min-height: 30px;
+        border-radius: 999px !important;
+        border: 1.35px solid #d8e1eb !important;
+        font-size: 0.78rem !important;
+        font-weight: 600 !important;
+        padding: 0.18rem 0.6rem !important;
+        white-space: nowrap !important;
+    }
+
+    .stButton > button[kind="secondary"] {
+        background: #ffffff !important;
+        color: #334155 !important;
+    }
+
+    .stButton > button[kind="primary"] {
+        background: #111827 !important;
+        border-color: #111827 !important;
+        color: #ffffff !important;
+    }
+
+    div[data-baseweb="select"] > div {
+        min-height: 34px;
+        border: 1.35px solid #dce4ee !important;
+        border-radius: 8px !important;
+        background: #ffffff !important;
+    }
+
+    div[data-baseweb="select"] * {
+        font-size: 0.8rem !important;
+        color: #334155 !important;
+    }
+
+    [data-testid="stCheckbox"] label p {
+        color: #374151 !important;
+        font-size: 0.78rem !important;
+    }
+
+    [data-testid="stTabs"] [data-baseweb="tab-list"] {
+        justify-content: flex-end;
+        gap: 10px;
+        border-bottom: 1px solid #edf2f7;
+    }
+
+    [data-testid="stTabs"] button[data-baseweb="tab"] {
+        color: #94a3b8;
+        font-size: 0.84rem;
+        font-weight: 600;
+        padding: 12px 8px 11px;
+    }
+
+    [data-testid="stTabs"] button[aria-selected="true"] {
+        color: #111827 !important;
+        border-bottom: 2.5px solid #111827 !important;
+    }
+
+    div[data-testid="stDataEditor"] {
+        border: none !important;
+        border-radius: 0 !important;
+        overflow: visible !important;
+        background: transparent !important;
+        box-shadow: none !important;
+    }
+
+    div[data-testid="stDataEditor"] [role="columnheader"] {
+        background: #f8fafc !important;
+        color: #94a3b8 !important;
+        text-transform: uppercase;
+        letter-spacing: 1px;
+        font-size: 0.64rem !important;
+        font-weight: 700 !important;
+        border-bottom: 1px solid #edf2f7 !important;
+    }
+
+    div[data-testid="stDataEditor"] [role="gridcell"] {
+        font-size: 0.82rem;
+        color: #111827 !important;
+        background: #ffffff !important;
+        border-bottom: 1px solid #f8fafc !important;
+    }
+
+    div[data-testid="stDataEditor"] [role="grid"] {
+        background: #ffffff !important;
+        border: none !important;
+        border-radius: 0 !important;
+        box-shadow: none !important;
+    }
+
+    /* Materials grid must blend with the parent card (no inner boxed layer) */
+    div.stElementContainer[class*="st-key-materials_editor_"] div[data-testid="stFullScreenFrame"],
+    div.stElementContainer[class*="st-key-materials_editor_"] div[data-testid="stDataFrame"],
+    div.stElementContainer[class*="st-key-materials_editor_"] div[data-testid="stDataFrameResizable"],
+    div.stElementContainer[class*="st-key-materials_editor_"] div[data-testid="stDataFrameResizable"][style] {
+        border: 0 !important;
+        border-radius: 0 !important;
+        background: transparent !important;
+        box-shadow: none !important;
+        outline: none !important;
+    }
+
+    div.stElementContainer[class*="st-key-materials_editor_"] div.stDataFrameGlideDataEditor,
+    div.stElementContainer[class*="st-key-materials_editor_"] div.stDataFrameGlideDataEditor[style] {
+        --gdg-bg-cell: #ffffff !important;
+        --gdg-bg-cell-medium: #ffffff !important;
+        --gdg-bg-header: #f8fafc !important;
+        --gdg-border-color: transparent !important;
+        --gdg-horizontal-border-color: transparent !important;
+        --gdg-drilldown-border: transparent !important;
+        --gdg-text-dark: #111827 !important;
+        --gdg-text-medium: rgba(17, 24, 39, 0.82) !important;
+        --gdg-text-header: rgba(148, 163, 184, 1) !important;
+        --gdg-cell-vertical-padding: 8px !important;
+        --gdg-bg-bubble: #dbeafe !important;
+        --gdg-text-bubble: #1d4ed8 !important;
+        --gdg-bubble-height: 22px !important;
+        --gdg-bubble-padding: 10px !important;
+    }
+
+    .aim-pg-info {
+        color: #94a3b8;
+        font-size: 0.8rem;
+        margin-top: 6px;
+    }
+
+    .aim-pg-info strong {
+        color: #111827;
+    }
+
+    .aim-ellipsis {
+        color: #94a3b8;
+        font-size: 0.85rem;
+        text-align: center;
+        margin-top: 4px;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+
+@st.cache_data
+def load_data(material_type: str) -> pd.DataFrame:
+    return load_material_data(material_type)
+
+
+@st.cache_data
+def load_all_data() -> pd.DataFrame:
+    frames = []
+    for material_type in ["Composites", "Polymers", "Fibers"]:
+        frame = load_data(material_type)
+        frame["_class"] = material_type
+        frames.append(frame)
+    return pd.concat(frames, ignore_index=True)
+
+
+def extract_matrix_fiber(abbr: str):
+    if not isinstance(abbr, str):
+        return None, None
+
+    text = abbr.lower()
+
+    matrix_map = {
+        "epoxy": "Epoxy",
+        "cyanate ester": "Cyanate Ester",
+        "cynate ester": "Cyanate Ester",
+        "polypropylene": "Polypropylene",
+        "pp": "Polypropylene",
+        "peek": "PEEK",
+        "pei": "PEI",
+        "nylon": "Nylon",
+        "pa6": "PA6",
+        "polyester": "Polyester",
+        "vinyl ester": "Vinyl Ester",
+        "phenolic": "Phenolic",
+    }
+
+    fiber_map = {
+        "carbon": "Carbon Fiber",
+        "glass": "Glass Fiber",
+        "e-glass": "E-Glass Fiber",
+        "s-glass": "S-Glass Fiber",
+        "aramid": "Aramid Fiber",
+        "kevlar": "Kevlar Fiber",
+        "basalt": "Basalt Fiber",
+        "natural": "Natural Fiber",
+    }
+
+    matrix = next((value for key, value in matrix_map.items() if key in text), None)
+    fiber = next((value for key, value in fiber_map.items() if key in text), None)
+    return matrix, fiber
+
+
+def toggle_class(material_class: str):
+    active = list(st.session_state.active_classes)
+    if material_class in active:
+        active.remove(material_class)
+    else:
+        active.append(material_class)
+
+    order = ["Composites", "Polymers", "Fibers"]
+    st.session_state.active_classes = [item for item in order if item in active]
+    st.session_state.current_page = 0
+
+
+def visible_page_numbers(current_page: int, total_pages: int):
+    if total_pages <= 6:
+        return list(range(total_pages))
+
+    pages = {0, 1, 2, current_page, total_pages - 1}
+    if current_page - 1 > 2:
+        pages.add(current_page - 1)
+    if current_page + 1 < total_pages - 1:
+        pages.add(current_page + 1)
+    return sorted(pages)
+
+
+defaults = {
+    "active_classes": [],
+    "selected_props": [],
+    "selected_matrix": "All",
+    "selected_fiber": "All",
+    "selected_row": None,
+    "current_page": 0,
+    "_search_term": None,
+    "top_search_input": "",
+    "inspect_section": None,
+    "inspect_property": None,
+    "_reset_prop_checks": False,
+}
+
+for key, value in defaults.items():
+    if key not in st.session_state:
+        st.session_state[key] = value
+
+if "material_type" in st.session_state:
+    incoming_type = st.session_state.pop("material_type")
+    if incoming_type in ["Composites", "Polymers", "Fibers"]:
+        st.session_state.active_classes = [incoming_type]
+
+if "selected_section" in st.session_state:
+    st.session_state.selected_props = [st.session_state.pop("selected_section")]
+    st.session_state._reset_prop_checks = True
+
+if "search_term" in st.session_state:
+    st.session_state._search_term = st.session_state.pop("search_term")
+
+if st.session_state._search_term and not st.session_state.top_search_input:
+    st.session_state.top_search_input = st.session_state._search_term
+
+all_data = load_all_data()
+if "user_uploaded_data" in st.session_state:
+    uploaded = st.session_state["user_uploaded_data"].copy()
+    uploaded["_class"] = uploaded["material_class"].map(
+        {"Polymer": "Polymers", "Fiber": "Fibers", "Composite": "Composites"}
+    )
+    all_data = pd.concat([all_data, uploaded], ignore_index=True)
+
+st.session_state["base_data"] = all_data
+
+meta = (
+    all_data[["material_abbreviation", "material_name", "_class"]]
+    .fillna("")
+    .drop_duplicates(subset=["material_abbreviation"])
+    .reset_index(drop=True)
+)
+meta[["Matrix", "Fiber"]] = meta["material_abbreviation"].apply(
+    lambda value: pd.Series(extract_matrix_fiber(value))
+)
+
+all_sections = get_all_sections()
+
+if st.session_state._reset_prop_checks:
+    selected = set(st.session_state.selected_props)
+    for index, section in enumerate(all_sections):
+        st.session_state[f"prop_check_{index}"] = section in selected
+    st.session_state._reset_prop_checks = False
+
+filtered_meta = meta.copy()
+if st.session_state.active_classes:
+    filtered_meta = filtered_meta[filtered_meta["_class"].isin(st.session_state.active_classes)]
+if st.session_state.selected_matrix != "All":
+    filtered_meta = filtered_meta[filtered_meta["Matrix"] == st.session_state.selected_matrix]
+if st.session_state.selected_fiber != "All":
+    filtered_meta = filtered_meta[filtered_meta["Fiber"] == st.session_state.selected_fiber]
+
+if st.session_state._search_term:
+    term = st.session_state._search_term
+    try:
+        pattern = re.compile(term, re.IGNORECASE)
+    except re.error:
+        pattern = re.compile(re.escape(term), re.IGNORECASE)
+
+    filtered_meta = filtered_meta[
+        filtered_meta["material_abbreviation"].astype(str).str.contains(pattern)
+        | filtered_meta["material_name"].astype(str).str.contains(pattern)
+    ]
+
+if st.session_state.selected_props:
+    valid_abbr = all_data[
+        all_data["section"].isin(st.session_state.selected_props) & all_data["value"].notna()
+    ]["material_abbreviation"].unique()
+    filtered_meta = filtered_meta[filtered_meta["material_abbreviation"].isin(valid_abbr)]
+
+filtered_meta = filtered_meta.reset_index(drop=True)
+
+PAGE_SIZE = 5
+total = len(filtered_meta)
+total_pages = max(1, (total + PAGE_SIZE - 1) // PAGE_SIZE)
+st.session_state.current_page = min(st.session_state.current_page, total_pages - 1)
+
+start = st.session_state.current_page * PAGE_SIZE
+end = start + PAGE_SIZE
+page_meta = filtered_meta.iloc[start:end].reset_index(drop=True)
+
+left_col, right_col = st.columns([1.03, 3.07], gap="small")
+
+with left_col:
+    with st.container(border=True):
+        logo_html = ""
+        logo_path = Path("logo.png")
+        if logo_path.exists():
+            with logo_path.open("rb") as file_handle:
+                logo_b64 = base64.b64encode(file_handle.read()).decode()
+            logo_html = (
+                f"<img src='data:image/png;base64,{logo_b64}' "
+                "style='height:20px;width:20px;object-fit:contain;border-radius:4px;'/>"
+            )
+
+        st.markdown(
+            f"<div class='aim-logo'>{logo_html} AIM Composites</div>",
+            unsafe_allow_html=True,
+        )
+
+        st.markdown("<div class='aim-sec'>🧩 Material Class</div>", unsafe_allow_html=True)
+
+        cls_a, cls_b = st.columns(2)
+        with cls_a:
+            if st.button(
+                "Composites",
+                key="class_comp",
+                use_container_width=True,
+                type="primary" if "Composites" in st.session_state.active_classes else "secondary",
+            ):
+                toggle_class("Composites")
+                st.rerun()
+
+        with cls_b:
+            if st.button(
+                "Polymers",
+                key="class_poly",
+                use_container_width=True,
+                type="primary" if "Polymers" in st.session_state.active_classes else "secondary",
+            ):
+                toggle_class("Polymers")
+                st.rerun()
+
+        if st.button(
+            "Fibers",
+            key="class_fib",
+            use_container_width=True,
+            type="primary" if "Fibers" in st.session_state.active_classes else "secondary",
+        ):
+            toggle_class("Fibers")
+            st.rerun()
+
+        st.markdown("<div class='aim-sec'>🧪 Composition</div>", unsafe_allow_html=True)
+        composite_meta = meta[meta["_class"] == "Composites"]
+        matrix_options = ["All"] + sorted([item for item in composite_meta["Matrix"].dropna().unique() if item])
+        fiber_options = ["All"] + sorted([item for item in composite_meta["Fiber"].dropna().unique() if item])
+
+        st.markdown("<div class='aim-lbl'>🧱 Matrix</div>", unsafe_allow_html=True)
+        matrix_value = st.selectbox(
+            "Matrix",
+            matrix_options,
+            index=matrix_options.index(st.session_state.selected_matrix)
+            if st.session_state.selected_matrix in matrix_options
+            else 0,
+            key="matrix_select",
+            label_visibility="collapsed",
+        )
+
+        st.markdown("<div class='aim-lbl'>🧵 Fiber</div>", unsafe_allow_html=True)
+        fiber_value = st.selectbox(
+            "Fiber",
+            fiber_options,
+            index=fiber_options.index(st.session_state.selected_fiber)
+            if st.session_state.selected_fiber in fiber_options
+            else 0,
+            key="fiber_select",
+            label_visibility="collapsed",
+        )
+
+        if matrix_value != st.session_state.selected_matrix:
+            st.session_state.selected_matrix = matrix_value
+            st.session_state.current_page = 0
+            st.rerun()
+
+        if fiber_value != st.session_state.selected_fiber:
+            st.session_state.selected_fiber = fiber_value
+            st.session_state.current_page = 0
+            st.rerun()
+
+        st.markdown("<div class='aim-sec'>📋 Property Types</div>", unsafe_allow_html=True)
+        selected_props = []
+        with st.container(height=480):
+            for index, section in enumerate(all_sections):
+                key = f"prop_check_{index}"
+                if key not in st.session_state:
+                    st.session_state[key] = section in st.session_state.selected_props
+
+                if st.checkbox(section, key=key):
+                    selected_props.append(section)
+
+        if selected_props != st.session_state.selected_props:
+            st.session_state.selected_props = selected_props
+            st.session_state.current_page = 0
+            st.rerun()
+
+        if st.button(
+            "🔎 Inspect",
+            key="inspect_btn",
+            use_container_width=True,
+            type="primary",
+            disabled=st.session_state.selected_row is None,
+        ):
+            st.info("Open the Inspect tab on the right panel.")
+
+        if st.session_state.selected_row:
+            selected_abbr, selected_name = st.session_state.selected_row
+            st.markdown(
+                f"<div class='aim-selected'><b>Selected</b><br>{selected_name}<br><span style='font-family:monospace'>{selected_abbr}</span></div>",
+                unsafe_allow_html=True,
+            )
+
+with right_col:
+    with st.container(border=True):
+        with st.container(key="top_search_row"):
+            input_col, btn_col = st.columns([0.82, 0.18], gap="small")
+            with input_col:
+                search_query = st.text_input(
+                    label="Search",
+                    placeholder="Search by material name, property, or abbreviation...",
+                    label_visibility="collapsed",
+                    key="top_search_input",
+                )
+            with btn_col:
+                search_clicked = st.button("Search", key="top_search_btn", use_container_width=True)
+
+    if search_clicked:
+        query = (search_query or "").strip()
+        st.session_state._search_term = query if query else None
+        st.session_state.current_page = 0
+        st.rerun()
+
+    with st.container(border=True):
+        st.markdown(
+            """
+            <div style='padding:14px 18px 0;'>
+                <div class='aim-breadcrumb'>INVENTORY / <span>MATERIALS DATABASE</span></div>
+                <div class='aim-title'>Materials Database</div>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+
+        tab_materials, tab_dashboard, tab_inspect = st.tabs(
+            ["All Materials", "Dashboard", "Inspect"]
+        )
+
+        with tab_materials:
+            filter_label = (
+                ", ".join(st.session_state.active_classes)
+                if st.session_state.active_classes
+                else "All Materials"
+            )
+            shown_start = start + 1 if total > 0 else 0
+            shown_end = min(end, total)
+
+            row_left, row_right = st.columns([2.2, 1.2])
+            with row_left:
+                st.markdown(f"<div class='aim-sub'>{filter_label}</div>", unsafe_allow_html=True)
+            with row_right:
+                st.markdown(
+                    f"<div class='aim-sub' style='text-align:right'>Showing <strong>{shown_start}-{shown_end}</strong> of <strong>{total}</strong> materials</div>",
+                    unsafe_allow_html=True,
+                )
+
+            selected_abbr = st.session_state.selected_row[0] if st.session_state.selected_row else None
+
+            class_map = {
+                "Composites": "🔵 COMPOSITE",
+                "Polymers": "🟢 POLYMER",
+                "Fibers": "🟠 FIBER",
+            }
+
+            if not page_meta.empty:
+                table_df = page_meta.copy()
+                table_df["Select"] = table_df["material_abbreviation"].eq(selected_abbr)
+                table_df["Class"] = table_df["_class"].map(class_map)
+                table_df["Actions"] = ""
+                table_df = table_df[
+                    ["Select", "material_name", "material_abbreviation", "Class", "Actions"]
+                ].rename(
+                    columns={
+                        "material_name": "Material Name",
+                        "material_abbreviation": "Abbreviation",
+                    }
+                )
+            else:
+                table_df = pd.DataFrame(
+                    columns=["Select", "Material Name", "Abbreviation", "Class", "Actions"]
+                )
+
+            for _ in range(2):
+                table_df.loc[len(table_df)] = [False, "", "", "", ""]
+
+            editor_df = st.data_editor(
+                table_df,
+                key=f"materials_editor_{st.session_state.current_page}",
+                use_container_width=True,
+                hide_index=True,
+                height=372,
+                row_height=46,
+                column_order=["Select", "Material Name", "Abbreviation", "Class", "Actions"],
+                column_config={
+                    "Select": st.column_config.CheckboxColumn("", width="small"),
+                    "Material Name": st.column_config.TextColumn("MATERIAL NAME", width="large"),
+                    "Abbreviation": st.column_config.TextColumn("ABBREVIATION", width="medium"),
+                    "Class": st.column_config.TextColumn("CLASS", width="small"),
+                    "Actions": st.column_config.TextColumn("ACTIONS", width="small"),
+                },
+                disabled=["Material Name", "Abbreviation", "Class", "Actions"],
+            )
+
+            checked_rows = editor_df[
+                editor_df["Select"]
+                & editor_df["Abbreviation"].astype(str).str.strip().ne("")
+            ]
+            if not checked_rows.empty:
+                chosen = checked_rows.iloc[0]
+                abbr = chosen["Abbreviation"]
+                name = chosen["Material Name"]
+                if (
+                    st.session_state.selected_row is None
+                    or st.session_state.selected_row[0] != abbr
+                ):
+                    st.session_state.selected_row = (abbr, name)
+                    st.rerun()
+            info_col, nav_col = st.columns([2.4, 2.0])
+            with info_col:
+                st.markdown(
+                    f"<div class='aim-pg-info'>Showing <strong>{shown_start}-{shown_end}</strong> of <strong>{total}</strong> materials | Items per page: <strong>{PAGE_SIZE}</strong></div>",
+                    unsafe_allow_html=True,
+                )
+
+            with nav_col:
+                nav_items = []
+                nav_items.append(("<<", 0, st.session_state.current_page == 0, False))
+                nav_items.append(("<", max(0, st.session_state.current_page - 1), st.session_state.current_page == 0, False))
+
+                visible_pages = visible_page_numbers(st.session_state.current_page, total_pages)
+                previous = -1
+                for number in visible_pages:
+                    if previous >= 0 and number - previous > 1:
+                        nav_items.append(("...", None, True, False))
+                    nav_items.append(
+                        (
+                            str(number + 1),
+                            number,
+                            False,
+                            number == st.session_state.current_page,
+                        )
+                    )
+                    previous = number
+
+                nav_items.append(
+                    (
+                        ">",
+                        min(total_pages - 1, st.session_state.current_page + 1),
+                        st.session_state.current_page >= total_pages - 1,
+                        False,
+                    )
+                )
+                nav_items.append(
+                    (
+                        ">>",
+                        total_pages - 1,
+                        st.session_state.current_page >= total_pages - 1,
+                        False,
+                    )
+                )
+
+                nav_columns = st.columns(len(nav_items))
+                for idx, (column, item) in enumerate(zip(nav_columns, nav_items)):
+                    label, target_page, disabled, active = item
+                    with column:
+                        if label == "...":
+                            st.markdown("<div class='aim-ellipsis'>...</div>", unsafe_allow_html=True)
+                        else:
+                            if st.button(
+                                label,
+                                key=f"page_btn_{idx}_{label}_{target_page}",
+                                use_container_width=True,
+                                disabled=disabled,
+                                type="primary" if active else "secondary",
+                            ):
+                                st.session_state.current_page = target_page
+                                st.rerun()
+
+        with tab_dashboard:
+            st.markdown(
+                "<div style='padding:40px 8px;color:#64748b;font-size:0.85rem'>Dashboard coming soon. Analytics and visualizations will appear here.</div>",
+                unsafe_allow_html=True,
+            )
+
+        with tab_inspect:
+            if not st.session_state.selected_row:
+                st.warning("Select a material in All Materials first.")
+            else:
+                selected_abbr, selected_name = st.session_state.selected_row
+                st.markdown(f"**Material:** {selected_name}")
+                st.caption(selected_abbr)
+
+                material_df = all_data[
+                    (all_data["material_abbreviation"] == selected_abbr)
+                    & (all_data["value"].notna())
+                    & (all_data["property_name"].notna())
+                ]
+
+                section_options = sorted(material_df["section"].dropna().unique().tolist())
+                if not section_options:
+                    st.warning("No property data found for this material.")
+                else:
+                    if st.session_state.inspect_section not in section_options:
+                        st.session_state.inspect_section = section_options[0]
+
+                    section_choice = st.selectbox(
+                        "Type of Property",
+                        section_options,
+                        index=section_options.index(st.session_state.inspect_section),
+                        key="inspect_section_select",
+                    )
+                    st.session_state.inspect_section = section_choice
+
+                    properties_df = (
+                        material_df[material_df["section"] == section_choice][
+                            ["property_name", "section"]
+                        ]
+                        .drop_duplicates()
+                        .reset_index(drop=True)
+                    )
+                    st.dataframe(properties_df, use_container_width=True, hide_index=True, height=240)
+
+                    property_options = properties_df["property_name"].dropna().tolist()
+                    if property_options:
+                        if st.session_state.inspect_property not in property_options:
+                            st.session_state.inspect_property = property_options[0]
+
+                        property_choice = st.selectbox(
+                            "Property",
+                            property_options,
+                            index=property_options.index(st.session_state.inspect_property),
+                            key="inspect_property_select",
+                        )
+                        st.session_state.inspect_property = property_choice
+
+                        if st.button("Search", key="inspect_search", type="primary"):
+                            result = all_data[
+                                (all_data["material_abbreviation"] == selected_abbr)
+                                & (all_data["property_name"] == property_choice)
+                                & (all_data["value"].notna())
+                            ]
+
+                            if result.empty:
+                                st.warning("No data found for this material-property combination")
+                            else:
+                                st.subheader("Property Data")
+                                st.dataframe(result.T, use_container_width=True)
+
+                                st.subheader("Property Graph")
+                                image_path = Path("images") / f"{selected_abbr}_{property_choice}.png"
+                                if image_path.exists():
+                                    image = Image.open(image_path)
+                                    st.image(image, use_container_width=True, caption="Stress strain curve")
+                                else:
+                                    st.caption("No plot image available for this material-property pair.")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

page_files/Contact_Team.py

@@ -0,0 +1,40 @@
+import streamlit as st
+from pathlib import Path
+from PIL import Image, ImageOps
+
+IMG_DIR = Path("images")
+TARGET_SIZE = (213, 310)
+
+def fixed_image(name):
+    img = Image.open(IMG_DIR / name).convert("RGB")
+    return ImageOps.fit(img, TARGET_SIZE, Image.LANCZOS, centering=(0.5, 0.5))
+
+c1, c2, c3 = st.columns([1, 2, 1])
+with c2:
+    st.subheader("Team Members")
+
+col1, col2, col3 = st.columns(3)
+with col1:
+    st.image(fixed_image("GangLi.jpg"))
+    st.markdown("**Gang Li**  \nProfessor of Mechanical Engineering, Clemson University  \ngli@clemson.edu")
+
+with col2:
+    st.image(fixed_image("Mathias.jpg"))
+    st.markdown("**Heider, Mathias**  \nResearch Assistant - CSE PhD Student  \nUniversity of Delaware  \nmheider@udel.edu")
+
+with col3:
+    st.image(fixed_image("Abhijit.jpg"))
+    st.markdown("**Abhijit Varanasi**  \nLab Specialist - Clemson University  \nMFA Graduate, Clemson University  \nBE - CSE  \navarana@clemson.edu")
+
+st.write("")
+
+sp1, col4, sp2, col5, sp3 = st.columns([1, 3, 1, 3, 1])
+with col4:
+    st.image(fixed_image("Tejaswi.jpg"))
+    st.markdown("**Tejaswi Gudimetla**  \nLab Aide - Clemson University  \nvgudime@clemson.edu")
+
+with col5:
+    st.image(fixed_image("Pradeep.jpg"))
+    st.markdown("**Sai Aditya Pradeep**  \nResearch and Development Engineer, University of Delaware  \nspradeep@udel.edu")
+
+st.sidebar.image("logo.png", caption=" ", width=150)

page_files/Home.py

@@ -0,0 +1,722 @@
+import streamlit as st
+import streamlit.components.v1 as components
+from pathlib import Path
+import base64
+from streamlit_card import card
+from data_loader import get_all_sections
+import random
+from data_loader import get_all_sections
+import re
+
+
+ALL_CARDS = [
+    ("Composites",  "Material class",  "material", "Composites"),
+    ("Polymers",    "Material class",  "material", "Polymers"),
+    ("Fibers",      "Material class",  "material", "Fibers"),
+]
+
+sections = get_all_sections()
+for section in sections:
+    ALL_CARDS.append((section, "Property type", "section", section))
+
+if "visible_cards" not in st.session_state:
+    random.shuffle(ALL_CARDS)
+    st.session_state.visible_cards = ALL_CARDS[:4]  
+
+VISIBLE_CARDS = st.session_state.visible_cards 
+prop_count = len([c for c in ALL_CARDS if c[2] == "section"])
+
+def get_card_icon(title: str, card_type: str) -> str:
+    if card_type == "material":
+        icons = {"composites": "🧱", "polymers": "🔬", "fibers": "🧵"}
+        return icons.get(title.lower(), "🧱")
+    t = title.lower()
+    if "mechanical" in t: return "⚙️"
+    if "thermal" in t: return "🔥"
+    if "electrical" in t: return "⚡"
+    if "physical" in t: return "⚖️"
+    if "processing" in t: return "🔧"
+    if "optical" in t: return "🔭"
+    if "chemical" in t: return "🧪"
+    if "flammab" in t: return "🔴"
+    if "component" in t: return "🧩"
+    if "descriptive" in t: return "📋"
+    return "📋"
+
+def img_to_b64(path):
+    try:
+        ext = Path(path).suffix.lower().replace(".", "")
+        mime = "png" if ext == "png" else "jpeg"
+        with open(path, "rb") as f:
+            data = base64.b64encode(f.read()).decode()
+        return f"data:image/{mime};base64,{data}"
+    except Exception:
+        return ""
+
+
+home_img = img_to_b64("images/Home.png")
+logo_img = img_to_b64("logo.png")
+
+st.markdown("""
+  <style>
+  section[data-testid="stMain"] {
+      background: #fff !important;
+  }
+  .stApp {
+      background: #fff !important;
+  }
+  </style>
+  """, 
+  unsafe_allow_html=True
+  )
+
+#  Global style overrides 
+st.markdown("""
+<style>
+@import url('https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700;800&display=swap');
+
+/* Hide default Streamlit chrome */
+.block-container { padding: 0 !important; max-width: 100% !important; background: #fff !important;}
+[data-testid="stToolbar"],
+[data-testid="stDecoration"],
+[data-testid="stHeader"] { display: none !important; }
+
+
+
+
+
+/* ── Search row ── */
+/* Only target the search bar's horizontal block, not all columns */
+.st-emotion-cache-y1l7l5 .st-emotion-cache-1permvm {
+    gap: 0 !important;
+    align-items: stretch !important;
+}
+
+.st-emotion-cache-16s2yzk button {
+    background: #f2f6f4 !important;
+    border: 1.5px solid #d0d8d4 !important;
+    border-right: none !important;
+    border-radius: 50px 0 0 50px !important;
+    color: #3a5248 !important;
+    font-family: 'DM Sans', sans-serif !important;
+    font-size: 0.8rem !important;
+    font-weight: 600 !important;
+    height: 46px !important;
+    padding: 0 16px !important;
+    white-space: nowrap !important;
+    box-shadow: none !important;
+}
+
+.st-emotion-cache-4dubyl [data-baseweb="input"] {
+    background: #000 !important;
+    height: 46px !important;
+    min-height: 46px !important;
+    border-radius: 0 !important;
+    border-color: #d0d8d4 !important;
+    border-left: none !important;
+    border-right: none !important;
+}
+            
+.st-emotion-cache-4dubyl input {
+    background: #fff !important;
+    height: 46px !important;
+    padding-top: 0 !important;
+    padding-bottom: 0 !important;
+    font-family: 'DM Sans', sans-serif !important;
+    font-size: 0.92rem !important;
+    color: #000 !important;
+    box-shadow: none !important;
+    padding-left: 18px !important;
+}
+
+.st-emotion-cache-4dubyl > div {
+
+    height: 46px !important;
+}
+.st-emotion-cache-4dubyl input::placeholder {
+    color: #0f1f1a !important;
+    opacity: 0.4 !important;
+}
+.st-emotion-cache-mpgwbc button {
+    background: #8ACAFF !important;
+    border: 1.5px solid #8ACAFF !important;
+    border-left: none !important;
+    border-radius: 0 50px 50px 0 !important;
+    color: #0f1f1a !important;
+    font-family: 'DM Sans', sans-serif !important;
+    font-size: 0.88rem !important;
+    font-weight: 600 !important;
+    height: 46px !important;
+    padding: 0 28px !important;
+    box-shadow: none !important;
+}
+
+.st-key-view_all_btn button {
+    background: transparent !important;
+    border: none !important;
+    color: #8ACAFF !important;
+    font-family: 'DM Sans', sans-serif !important;
+    font-size: 0.85rem !important;
+    font-weight: 600 !important;
+    padding: 0 !important;
+    height: auto !important;
+    box-shadow: none !important;
+    cursor: pointer !important;
+}
+.st-key-view_all_btn button:hover {
+    color: #8ACAFF !important;
+    text-decoration: underline !important;
+    background: transparent !important;
+}
+.footer-nav-head {
+    font-size: 0.68rem;
+    font-weight: 700;
+    letter-spacing: 1.4px;
+    text-transform: uppercase;
+    color: #0f1f1a;
+    margin-bottom: 14px;
+    font-family: 'DM Sans', sans-serif;
+}
+
+</style>
+""", unsafe_allow_html=True)
+
+
+#  Helper 
+def go_categorized(material=None, search=None):
+    if material:
+        st.session_state.material_type = material
+    if search:
+        st.session_state.search_term = search
+    st.switch_page("page_files/Categorized_Search.py")
+
+
+def go_upload():
+    st.switch_page("page_files/Upload_Data.py")
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 1.  ANIMATION SECTION  (pure HTML, no clickables needed)
+# ══════════════════════════════════════════════════════════════════════════════
+about_img_html = (
+    f"<div class='aim-about-img'><img src='{home_img}' alt='AIM platform diagram'/></div>"
+    if home_img else
+    "<div class='aim-about-img-placeholder'>[ Platform diagram ]</div>"
+)
+
+logo_html = (
+    f"<img src='{logo_img}' alt='AIM Logo' style='height:52px;width:52px;object-fit:contain;border-radius:14px;'/>"
+    if logo_img else ""
+)
+
+components.html(f"""
+<!DOCTYPE html><html lang="en"><head>
+<meta charset="UTF-8"/>
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link href="https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700;800&display=swap" rel="stylesheet">
+<style>
+*, *::before, *::after {{ box-sizing: border-box; margin: 0; padding: 0; }}
+body {{ font-family: 'DM Sans', sans-serif; background: #f7f7f5; color: #1a2e26; overflow-x: hidden; }}
+
+/*  ANIMATION SECTION  */
+.anim-section {{
+    background: #000;
+    padding: 80px 40px 60px;
+    display: flex; flex-direction: column; align-items: center;
+}}
+.anim-title {{
+    font-size: clamp(1.6rem, 3vw, 2.4rem); font-weight: 800;
+    color: #fff; text-align: center; letter-spacing: -1px; margin-bottom: 60px;
+}}
+.anim-stage {{
+    position: relative; width: 560px; height: 320px;
+    display: flex; align-items: center;
+    justify-content: space-between; padding: 0 40px;
+}}
+
+/* MAG GLASS */
+.mag-wrap {{ position: relative; width: 100px; display: flex; flex-direction: column; align-items: center; }}
+.mag-label {{ font-size: 0.65rem; font-weight: 600; letter-spacing: 1.5px; text-transform: uppercase; color: #4a7a6a; margin-bottom: 10px; }}
+.mag-svg {{ width: 90px; height: 160px; overflow: visible; }}
+.mag-lens-flash {{ opacity: 0; transition: opacity 0.6s ease 0.5s; }}
+.mag-wrap.active .mag-lens-flash {{ opacity: 1; animation: lensFlash 1.8s ease-in-out infinite 0.5s; }}
+@keyframes lensFlash {{ 0%,100% {{ opacity:.2; r:26; }} 50% {{ opacity:.7; r:28; }} }}
+.mag-scan {{ opacity: 0; transition: opacity 0.3s ease 0.8s; }}
+.mag-wrap.active .mag-scan {{ opacity: 1; animation: scanMove 1.2s ease-in-out infinite 0.8s; }}
+@keyframes scanMove {{ 0% {{ transform:translateY(-14px);opacity:.8; }} 50% {{ transform:translateY(0);opacity:1; }} 100% {{ transform:translateY(14px);opacity:.8; }} }}
+
+/* BUBBLES */
+.bubble {{ position:absolute; border-radius:50%; background:radial-gradient(circle at 35% 35%,rgba(255,255,255,.6),rgba(80,160,255,.25)); border:1px solid rgba(100,180,255,.4); opacity:0; pointer-events:none; backdrop-filter:blur(2px); }}
+.b1 {{ width:18px;height:18px;left:108px;bottom:155px; }}
+.b2 {{ width:13px;height:13px;left:120px;bottom:175px; }}
+.b3 {{ width:22px;height:22px;left:96px; bottom:140px; }}
+.b4 {{ width:10px;height:10px;left:128px;bottom:185px; }}
+.b5 {{ width:16px;height:16px;left:112px;bottom:165px; }}
+.b6 {{ width:8px; height:8px; left:124px;bottom:195px; }}
+.anim-stage.active .b1 {{ animation:floatBubble1 2.6s cubic-bezier(.25,.46,.45,.94) 1.2s forwards; }}
+.anim-stage.active .b2 {{ animation:floatBubble2 2.2s cubic-bezier(.25,.46,.45,.94) 1.5s forwards; }}
+.anim-stage.active .b3 {{ animation:floatBubble3 3.0s cubic-bezier(.25,.46,.45,.94) 1.0s forwards; }}
+.anim-stage.active .b4 {{ animation:floatBubble4 2.0s cubic-bezier(.25,.46,.45,.94) 1.8s forwards; }}
+.anim-stage.active .b5 {{ animation:floatBubble5 2.8s cubic-bezier(.25,.46,.45,.94) 1.3s forwards; }}
+.anim-stage.active .b6 {{ animation:floatBubble6 1.8s cubic-bezier(.25,.46,.45,.94) 2.0s forwards; }}
+@keyframes floatBubble1 {{ 0% {{ opacity:0;transform:translate(0,0) scale(.4); }} 15% {{ opacity:1;transform:translate(4px,-20px) scale(1); }} 60% {{ opacity:.9;transform:translate(120px,-55px) scale(.9); }} 85% {{ opacity:.5;transform:translate(280px,-30px) scale(.6); }} 100% {{ opacity:0;transform:translate(340px,-10px) scale(.2); }} }}
+@keyframes floatBubble2 {{ 0% {{ opacity:0;transform:translate(0,0) scale(.3); }} 15% {{ opacity:1;transform:translate(-5px,-28px) scale(1); }} 60% {{ opacity:.9;transform:translate(110px,-70px) scale(.85); }} 85% {{ opacity:.4;transform:translate(265px,-40px) scale(.5); }} 100% {{ opacity:0;transform:translate(330px,-15px) scale(.15); }} }}
+@keyframes floatBubble3 {{ 0% {{ opacity:0;transform:translate(0,0) scale(.5); }} 15% {{ opacity:1;transform:translate(6px,-15px) scale(1); }} 55% {{ opacity:.9;transform:translate(130px,-45px) scale(.95); }} 80% {{ opacity:.4;transform:translate(278px,-20px) scale(.55); }} 100% {{ opacity:0;transform:translate(345px,-5px) scale(.2); }} }}
+@keyframes floatBubble4 {{ 0% {{ opacity:0;transform:translate(0,0) scale(.3); }} 20% {{ opacity:1;transform:translate(-8px,-35px) scale(1); }} 65% {{ opacity:.8;transform:translate(105px,-80px) scale(.8); }} 88% {{ opacity:.3;transform:translate(255px,-50px) scale(.4); }} 100% {{ opacity:0;transform:translate(320px,-20px) scale(.1); }} }}
+@keyframes floatBubble5 {{ 0% {{ opacity:0;transform:translate(0,0) scale(.4); }} 15% {{ opacity:1;transform:translate(3px,-22px) scale(1); }} 58% {{ opacity:.9;transform:translate(115px,-60px) scale(.88); }} 83% {{ opacity:.45;transform:translate(270px,-35px) scale(.55); }} 100% {{ opacity:0;transform:translate(335px,-12px) scale(.2); }} }}
+@keyframes floatBubble6 {{ 0% {{ opacity:0;transform:translate(0,0) scale(.25); }} 20% {{ opacity:1;transform:translate(-3px,-40px) scale(1); }} 62% {{ opacity:.7;transform:translate(100px,-85px) scale(.75); }} 85% {{ opacity:.25;transform:translate(250px,-55px) scale(.35); }} 100% {{ opacity:0;transform:translate(318px,-22px) scale(.1); }} }}
+
+/* DATABASE */
+.db-wrap {{ position:relative;width:130px;display:flex;flex-direction:column;align-items:center; }}
+.db-label {{ font-size:.65rem;font-weight:600;letter-spacing:1.5px;text-transform:uppercase;color:#4a7a6a;margin-bottom:10px; }}
+.cyl {{ opacity:.15;transition:opacity .5s ease; }}
+.anim-stage.active .cyl-left  {{ opacity:1;transition-delay:2.0s; }}
+.anim-stage.active .cyl-right {{ opacity:1;transition-delay:2.2s; }}
+.anim-stage.active .cyl-front {{ opacity:1;transition-delay:2.4s;animation:frontPulse 2.4s ease-in-out infinite 2.8s; }}
+@keyframes frontPulse {{ 0%,100% {{ filter:brightness(1); }} 50% {{ filter:brightness(1.2); }} }}
+
+/* CAPTION */
+.anim-caption {{ margin-top:48px;display:flex;gap:40px;align-items:center; }}
+.anim-step {{ display:flex;align-items:center;gap:10px;opacity:0;transform:translateY(10px);transition:opacity .5s ease,transform .5s ease; }}
+.anim-stage.active ~ .anim-caption .anim-step:nth-child(1) {{ opacity:1;transform:none;transition-delay:.5s; }}
+.anim-stage.active ~ .anim-caption .anim-step:nth-child(2) {{ opacity:1;transform:none;transition-delay:1s; }}
+.anim-stage.active ~ .anim-caption .anim-step:nth-child(3) {{ opacity:1;transform:none;transition-delay:1.5s; }}
+.step-text {{ font-size:.78rem;color:#5a8a7a;font-weight:500; }}
+</style>
+</head><body>
+
+<section class="anim-section">
+    <h2 class="anim-title">From Experiment to Database</h2>
+    <div class="anim-stage" id="animStage">
+        <!-- MAG GLASS -->
+        <div class="mag-wrap" id="magWrap">
+            <div class="mag-label">Research</div>
+            <svg class="mag-svg" viewBox="0 0 90 160" fill="none" xmlns="http://www.w3.org/2000/svg">
+                <defs>
+                    <radialGradient id="lensGrad" cx="40%" cy="38%" r="55%">
+                        <stop offset="0%" stop-color="#4da6ff" stop-opacity="0.25"/>
+                        <stop offset="100%" stop-color="#1a4a8a" stop-opacity="0.7"/>
+                    </radialGradient>
+                    <radialGradient id="flashGrad" cx="50%" cy="50%" r="50%">
+                        <stop offset="0%" stop-color="#8ACAFF" stop-opacity="0.9"/>
+                        <stop offset="100%" stop-color="#8ACAFF" stop-opacity="0"/>
+                    </radialGradient>
+                </defs>
+                <circle cx="38" cy="38" r="32" fill="none" stroke="#2a5a8a" stroke-width="3"/>
+                <circle cx="38" cy="38" r="29" fill="url(#lensGrad)"/>
+                <line class="mag-scan" x1="16" y1="38" x2="60" y2="38" stroke="#8ACAFF" stroke-width="1.5" stroke-linecap="round" opacity="0.8"/>
+                <circle class="mag-lens-flash" cx="38" cy="38" r="26" fill="url(#flashGrad)"/>
+                <circle cx="24" cy="24" r="5" fill="white" opacity="0.15"/>
+                <circle cx="30" cy="34" r="2" fill="#8ACAFF" opacity="0.7"/>
+                <circle cx="42" cy="30" r="2" fill="#8ACAFF" opacity="0.5"/>
+                <circle cx="38" cy="44" r="2" fill="#8ACAFF" opacity="0.6"/>
+                <circle cx="48" cy="38" r="1.5" fill="#8ACAFF" opacity="0.4"/>
+            </svg>
+        </div>
+        <!-- BUBBLES -->
+        <div class="bubble b1"></div><div class="bubble b2"></div>
+        <div class="bubble b3"></div><div class="bubble b4"></div>
+        <div class="bubble b5"></div><div class="bubble b6"></div>
+        <!-- DATABASE -->
+        <div class="db-wrap">
+            <div class="db-label">Database</div>
+            <svg width="220" height="200" viewBox="0 0 220 200" fill="none" xmlns="http://www.w3.org/2000/svg">
+                <defs>
+                    <linearGradient id="sideBlue" x1="0" y1="0" x2="1" y2="0">
+                        <stop offset="0%" stop-color="#2a55b0"/><stop offset="50%" stop-color="#4a7fd8"/><stop offset="100%" stop-color="#2a55b0"/>
+                    </linearGradient>
+                    <linearGradient id="sideDark" x1="0" y1="0" x2="1" y2="0">
+                        <stop offset="0%" stop-color="#0d1f5c"/><stop offset="50%" stop-color="#1a3a8a"/><stop offset="100%" stop-color="#0d1f5c"/>
+                    </linearGradient>
+                    <linearGradient id="topBlue" x1="0" y1="0" x2="0" y2="1">
+                        <stop offset="0%" stop-color="#6a9fe0"/><stop offset="100%" stop-color="#3a6abf"/>
+                    </linearGradient>
+                    <linearGradient id="topDark" x1="0" y1="0" x2="0" y2="1">
+                        <stop offset="0%" stop-color="#2a4a9a"/><stop offset="100%" stop-color="#0d1f5c"/>
+                    </linearGradient>
+                </defs>
+                <!-- back left -->
+                <g class="cyl cyl-left">
+                    <rect x="10" y="88" width="66" height="20" rx="1" fill="url(#sideBlue)"/>
+                    <ellipse cx="43" cy="88" rx="33" ry="10" fill="url(#topBlue)"/>
+                    <rect x="10" y="66" width="66" height="24" rx="1" fill="url(#sideBlue)"/>
+                    <ellipse cx="43" cy="66" rx="33" ry="10" fill="url(#topBlue)"/>
+                    <rect x="10" y="46" width="66" height="22" rx="1" fill="url(#sideBlue)"/>
+                    <ellipse cx="43" cy="46" rx="33" ry="10" fill="url(#topBlue)"/>
+                    <ellipse cx="43" cy="108" rx="33" ry="10" fill="#1e3a80"/>
+                </g>
+                <!-- back right -->
+                <g class="cyl cyl-right">
+                    <rect x="144" y="88" width="66" height="20" rx="1" fill="url(#sideBlue)"/>
+                    <ellipse cx="177" cy="88" rx="33" ry="10" fill="url(#topBlue)"/>
+                    <rect x="144" y="66" width="66" height="24" rx="1" fill="url(#sideBlue)"/>
+                    <ellipse cx="177" cy="66" rx="33" ry="10" fill="url(#topBlue)"/>
+                    <rect x="144" y="46" width="66" height="22" rx="1" fill="url(#sideBlue)"/>
+                    <ellipse cx="177" cy="46" rx="33" ry="10" fill="url(#topBlue)"/>
+                    <ellipse cx="177" cy="108" rx="33" ry="10" fill="#1e3a80"/>
+                </g>
+                <!-- front center -->
+                <g class="cyl cyl-front">
+                    <rect x="70" y="128" width="80" height="24" rx="1" fill="url(#sideDark)"/>
+                    <ellipse cx="110" cy="128" rx="40" ry="13" fill="url(#topDark)"/>
+                    <rect x="70" y="102" width="80" height="28" rx="1" fill="url(#sideDark)"/>
+                    <ellipse cx="110" cy="102" rx="40" ry="13" fill="url(#topDark)"/>
+                    <rect x="70" y="76" width="80" height="28" rx="1" fill="url(#sideDark)"/>
+                    <ellipse cx="110" cy="76" rx="40" ry="13" fill="url(#topDark)"/>
+                    <rect x="70" y="54" width="80" height="24" rx="1" fill="url(#sideDark)"/>
+                    <ellipse cx="110" cy="54" rx="40" ry="13" fill="url(#topDark)"/>
+                    <ellipse cx="110" cy="152" rx="40" ry="13" fill="#080f2a"/>
+                </g>
+            </svg>
+        </div>
+    </div>
+    <div class="anim-caption">
+        <div class="anim-step"><span class="step-text">Collect measurements</span></div>
+        <div class="anim-step"><span class="step-text">Process &amp; validate</span></div>
+        <div class="anim-step"><span class="step-text">Stored in AIM</span></div>
+    </div>
+</section>
+
+<script>
+const stage = document.getElementById('animStage');
+const magWrap = document.getElementById('magWrap');
+const observer = new IntersectionObserver(entries => {{
+    entries.forEach(e => {{
+        if (e.isIntersecting) {{
+            setTimeout(() => {{ magWrap.classList.add('active'); stage.classList.add('active'); }}, 300);
+        }} else {{
+            magWrap.classList.remove('active'); stage.classList.remove('active');
+        }}
+    }});
+}}, {{ threshold: 0.4 }});
+observer.observe(document.querySelector('.anim-section'));
+</script>
+</body></html>
+""", height=700, scrolling=False)
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 2.  HERO , heading + description (static HTML)
+# ══════════════════════════════════════════════════════════════════════════════
+st.markdown("""
+<style>
+.aim-hero-text {
+    background: #fff;
+    text-align: center;
+    padding: 64px 40px 24px;
+    border-bottom: none;
+}
+.aim-hero-text h1 {
+    font-family: 'DM Sans', sans-serif;
+    font-size: clamp(2rem, 4.5vw, 3.2rem);
+    font-weight: 800; color: #0f1f1a;
+    line-height: 1.1; letter-spacing: -1.5px;
+    margin-bottom: 18px;
+}
+.aim-hero-text p {
+    color: #5a6b65; font-size: 1rem; line-height: 1.65;
+    max-width: 500px; margin: 0 auto 28px;
+}
+</style>
+<div class="aim-hero-text">
+    <h1>Accelerate Your Composites Research</h1>
+    <p>Access a centralized, open-source database for experimental composite material properties.
+       Polymer, fiber, and composite datasets , all in one place.</p>
+</div>
+""", unsafe_allow_html=True)
+
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 4.  STATS (static HTML)
+# ══════════════════════════════════════════════════════════════════════════════
+st.markdown(f"""
+<style>
+.aim-stats {{
+    background: #f7f7f5; border-bottom: 1px solid #e4e8e5;
+    display: flex; justify-content: center;
+}} 
+.aim-stat {{
+    text-align: center; padding: 34px 56px;
+    border-right: 1px solid #e4e8e5;
+}}
+.aim-stat:last-child {{ border-right: none; }}
+.aim-stat-num {{
+    font-family: 'DM Sans', sans-serif;
+    font-size: 2.1rem; font-weight: 800;
+    color: #8ACAFF; line-height: 1; margin-bottom: 6px;
+}}
+.aim-stat-label {{
+    font-size: 0.68rem; font-weight: 600;
+    letter-spacing: 1.4px; color: #7a8e87; text-transform: uppercase;
+}}
+</style>
+<div class="aim-stats">
+    <div class="aim-stat"><div class="aim-stat-num">3</div><div class="aim-stat-label">Material Classes</div></div>
+    <div class="aim-stat"><div class="aim-stat-num">{prop_count}</div><div class="aim-stat-label">Properties Tracked</div></div>
+    <div class="aim-stat"><div class="aim-stat-num">8</div><div class="aim-stat-label">Research Teams</div></div>
+    <div class="aim-stat"><div class="aim-stat-num">2</div><div class="aim-stat-label">Universities</div></div>
+</div>
+""", unsafe_allow_html=True)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 5.  MAJOR CATEGORIES , Streamlit columns + containers + buttons
+# ══════════════════════════════════════════════════════════════════════════════
+st.markdown("""
+<style>
+/* Card buttons - scoped to cards horizontal block only */
+.st-emotion-cache-r3ry0f button {
+    background: #fff !important;
+    border: 1.5px solid #e4e8e5 !important;
+    border-radius: 12px !important;
+    padding: 24px 20px !important;
+    height: 160px !important;
+    width: 100% !important;
+    text-align: left !important;
+    white-space: pre-wrap !important;
+    line-height: 1.5 !important;
+    box-shadow: none !important;
+    transition: box-shadow 0.2s, border-color 0.2s !important;
+}
+            
+.st-emotion-cache-r3ry0f button:hover {
+    border-color: #BAE1FC !important;
+    box-shadow: 0 0 0 3px rgba(186,225,252,0.25), 0 6px 22px rgba(0,0,0,0.07) !important;
+    background: #fff !important;
+}
+.st-emotion-cache-r3ry0f button p:first-child {
+    font-size: 1.1rem !important;
+    background: #f2f4f3 !important;
+    border-radius: 8px !important;
+    padding: 6px 8px !important;
+    display: inline-block !important;
+    margin-bottom: 12px !important;
+    line-height: 1 !important;
+}
+.st-emotion-cache-r3ry0f button p:nth-child(2) {
+    font-family: 'DM Sans', sans-serif !important;
+    font-size: 0.97rem !important;
+    font-weight: 700 !important;
+    color: #0f1f1a !important;
+    margin-bottom: 6px !important;
+}
+.st-emotion-cache-r3ry0f button p:last-child {
+    font-family: 'DM Sans', sans-serif !important;
+    font-size: 0.7rem !important;
+    font-weight: 700 !important;
+    letter-spacing: 1.2px !important;
+    color: #8ACAFF !important;
+    text-transform: uppercase !important;
+}
+.cards-section-wrap h2 {
+    font-family: 'DM Sans', sans-serif !important;
+    font-size: 1.4rem !important;
+    font-weight: 700 !important;
+    color: #0f1f1a !important;
+    margin-bottom: 6px !important;
+}
+.cards-section-wrap p {
+    color: #5a6b65 !important;
+    font-size: 0.9rem !important;
+    line-height: 1.6 !important;
+    margin-bottom: 16px !important;
+}
+</style>
+""", unsafe_allow_html=True)
+
+
+
+st.markdown("<div style='padding: 64px 0 0 0;'></div>", unsafe_allow_html=True)
+
+st.markdown("""
+    <div class="cards-section-wrap">
+        <h2>Quick Links</h2>
+        <p>Open the pages you need most.</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+quick_cards = [
+    ("Extract Data", "Platform", "page_files/Upload_Data.py", "about", "📋"),
+    ("Contact Team", "Support", "page_files/Contact_Team.py", "contact", " 🛡️"),
+    ("Search", "Data Page", "page_files/Categorized_Search.py", "search", "🔎"),
+]
+
+cols = st.columns(3, gap="large")
+for col, (title, tag, target_page, key_suffix, badge) in zip(cols, quick_cards):
+    with col:
+        if st.button(
+            f"{badge}\n\n{title}\n\n{tag}",
+            key=f"quick_{key_suffix}_page",
+            use_container_width=True,
+        ):
+            st.switch_page(target_page)
+
+st.markdown("<div style='background:#fff; padding: 24px 0; border-bottom: 1px solid #e8e8e4;'></div>", unsafe_allow_html=True)
+
+        
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 6.  ABOUT + FOOTER (static HTML)
+# ══════════════════════════════════════════════════════════════════════════════
+components.html(f"""
+<!DOCTYPE html><html lang="en"><head>
+<meta charset="UTF-8"/>
+<link href="https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700;800&display=swap" rel="stylesheet">
+<style>
+*, *::before, *::after {{ box-sizing: border-box; margin: 0; padding: 0; }}
+body {{ font-family: 'DM Sans', sans-serif; color: #1a2e26; }}
+
+.aim-about {{ background: #fff; padding: 60px; border-bottom: 1px solid #e8e8e4; }}
+.aim-about h2 {{ font-size: 1.65rem; font-weight: 700; color: #0f1f1a; letter-spacing: -0.5px; margin-bottom: 8px; }}
+.aim-about-sub {{ color: #6a7e77; font-size: 0.9rem; margin-bottom: 30px; }}
+.aim-about-grid {{ display: grid; grid-template-columns: 1fr 1fr; gap: 48px; align-items: start; }}
+.aim-about-text p {{ color: #3a4e47; font-size: 0.91rem; line-height: 1.75; margin-bottom: 14px; }}
+.aim-about-img {{ border-radius: 10px; overflow: hidden; border: 1px solid #e4e8e5; }}
+.aim-about-img img {{ width: 100%; display: block; }}
+.aim-about-img-placeholder {{
+    background: #f0f5f3; border-radius: 10px; height: 280px;
+    display: flex; align-items: center; justify-content: center;
+    color: #7a9e8f; font-size: 0.85rem; border: 1.5px dashed #c8d6d0;
+}}
+
+.aim-footer {{ background: #fff; border-top: 1px solid #e8e8e4; padding: 50px 60px 28px; }}
+.aim-footer-brand {{ display: flex; align-items: center; gap: 8px; font-weight: 700; color: #0f1f1a; font-size: 0.95rem; margin-bottom: 10px; }}
+.aim-footer-desc {{ font-size: 0.82rem; color: #7a8e87; line-height: 1.6; }}
+</style>
+</head><body>
+
+<section class="aim-about">
+    <h2>About the Platform</h2>
+    <p class="aim-about-sub">Artificially Intelligent Manufacturing Paradigm (AIM) for Composites</p>
+    <div class="aim-about-grid">
+        <div class="aim-about-text">
+            <p>The AIM Database tool serves as a powerful, centralized hub designed to streamline
+            collaboration and information exchange within the composite materials research community.
+            The platform enables researchers to contribute to a shared knowledge base by uploading
+            experimental datasets through secure terminals.</p>
+            <p>Users can submit specific measurements regarding mechanical properties, thermal behavior,
+            and rheology, alongside their published journal papers , ensuring that both raw data and
+            peer-reviewed findings are integrated into one cohesive system.</p>
+            <p>All contributed information is securely aggregated within a central cloud architecture,
+            allowing for efficient storage, organization, and retrieval across polymer, fiber, and
+            composite categories.</p>
+        </div>
+        <div>{about_img_html}</div>
+    </div>
+</section>
+
+
+
+</body></html>
+""", height=550, scrolling=False)
+
+st.markdown("""
+<style>
+            
+/* Footer nav wrapper */
+div[data-testid="stHorizontalBlock"]:has(.footer-nav-head) {
+    background: #fff !important;
+    border-bottom: 1px solid #e8e8e4 !important;
+    padding: 0 60px 28px !important;
+    margin-top: -16px !important;
+    
+}
+.aim-footer-brand {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-weight: 700;
+    color: #0f1f1a;
+    font-size: 0.95rem;
+    margin-bottom: 10px;
+    font-family: 'DM Sans', sans-serif;
+}
+.aim-footer-desc {
+    font-size: 0.82rem;
+    color: #7a8e87;
+    line-height: 1.6;
+    font-family: 'DM Sans', sans-serif;
+}
+.footer-nav-head {
+    font-size: 0.68rem;
+    font-weight: 700;
+    letter-spacing: 1.4px;
+    text-transform: uppercase;
+    color: #0f1f1a;
+    margin-bottom: 14px;
+    font-family: 'DM Sans', sans-serif;
+}
+.st-emotion-cache-1ofqig9 {
+    background: transparent !important;
+    border: none !important;
+    padding: 0 !important;
+}
+.st-emotion-cache-1qeq59m {
+    background: transparent !important;
+    border: none !important;
+    text-decoration: none !important;
+    padding: 0 0 9px 0 !important;
+    display: block !important;
+}
+.st-emotion-cache-1qeq59m:hover {
+    background: transparent !important;
+    border: none !important;
+}
+.st-emotion-cache-1qeq59m p {
+    color: #6a7e77 !important;
+    font-family: 'DM Sans', sans-serif !important;
+    font-size: 0.83rem !important;
+    font-weight: 400 !important;
+    margin: 0 !important;
+}
+.st-emotion-cache-1qeq59m:hover p {
+    color: #8ACAFF !important;
+}
+
+/* copyright bar */
+.aim-footer-bottom {
+    background: #fff;
+    border-top: 1px solid #e8e8e4;
+    padding: 22px 60px;
+    font-size: 0.76rem;
+    color: #a0b0aa;
+    font-family: 'DM Sans', sans-serif;
+}
+
+</style>
+""", unsafe_allow_html=True)
+
+brand_col, db_col, sup_col, _ = st.columns([4, 2, 2, 2], vertical_alignment="top", width="stretch")
+
+with brand_col:
+    st.markdown(f"""
+    <div class="aim-footer-brand">{logo_html} AIM Composites</div>
+    <p class="aim-footer-desc">Advancing composites research through open data and collaborative tools.
+    A joint initiative of Clemson University and University of Delaware.</p>
+    """, unsafe_allow_html=True)
+
+with sup_col:
+    st.markdown('<p class="footer-nav-head">DATABASE</p>', unsafe_allow_html=True)
+    st.page_link(
+        "page_files/Categorized_Search.py",
+        label="Browse Materials",
+    )
+    st.page_link(
+        "page_files/Categorized_Search.py",
+        label="Categorized Search",
+    )
+    st.page_link(
+        "page_files/Upload_Data.py",
+        label="Upload Data",
+    )
+
+with _:
+    st.markdown('<p class="footer-nav-head">SUPPORT</p>', unsafe_allow_html=True)
+    st.page_link(
+        "page_files/Contact_Team.py",
+        label="Contact Team",
+    )
+
+
+

page_files/Upload_Data.py

@@ -0,0 +1,887 @@
+import os
+import json
+import tempfile
+import base64
+
+import fitz  # PyMuPDF
+import pandas as pd
+import streamlit as st
+
+from data_loader import insert_material_rows
+from page_files.categorized.Backend.upload_backend import (
+    call_gemini_from_bytes,
+    convert_to_dataframe,
+    create_zip,
+    extract_images,
+    save_matched_images,
+    save_single_image_with_property,
+)
+def inject_upload_page_styles():
+    st.markdown(
+        """
+        <style>
+            @import url("https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700;800&display=swap");
+                
+            [data-testid="stHeader"] {
+                    display: none !important;
+            } 
+
+            .stApp {
+                background: #f3f6fb !important;
+            }
+
+            html, body, [class*="css"] {
+                font-family: "DM Sans", sans-serif !important;
+            }
+
+            .block-container {
+                max-width: 980px !important;
+                padding-top: 1rem !important;
+                padding-bottom: 2rem !important;
+            }
+            .st-emotion-cache-tn0cau {
+                background: #ffffff !important;
+
+            
+            
+            }
+            div[class*="st-key-ud_main_card"] > div[data-testid="stVerticalBlockBorderWrapper"] > div {
+                background: #ffffff !important;
+                border: 1px solid #dbe3ee !important;
+                border-radius: 16px !important;
+                padding: 28px 32px 32px 32px !important;
+                box-shadow: 0 4px 24px rgba(15, 23, 42, 0.08) !important;
+            }
+        
+
+            /* Card wrapper like cardref */
+            .upload-card {
+                max-width: 960px;
+                margin: 2.5rem auto;
+                padding: 2.25rem 2.5rem;
+                border-radius: 18px;
+                background: #ffffff;
+                box-shadow: 0 18px 45px rgba(15, 23, 42, 0.09);
+                border: 1px solid #e4e7f0;
+            }
+
+            /* Upload section layout */
+            .upload-section {
+                display: flex;
+                align-items: center;     /* vertical alignment */
+                justify-content: space-between;
+                gap: 1.5rem;
+                margin-top: 1.25rem;
+            }
+
+            .upload-dropzone {
+                flex: 1;
+            }
+
+            .upload-button-wrap {
+                display: flex;
+                align-items: center;
+                justify-content: center;
+            }
+
+            .upload-button-wrap button {
+                min-width: 160px;
+            }
+            
+            div[class*="st-key-ud_main_card"] [data-testid="stVerticalBlockBorderWrapper"] {
+                background: #ffffff !important;
+                border: 1px solid #dbe3ee !important;
+                border-radius: 16px !important;
+                box-shadow: 0 4px 24px rgba(15, 23, 42, 0.08) !important;
+            }
+            span.st-emotion-cache-epvm6 {
+                display: flex !important;
+                justify-content: center !important;
+                width: 100% !important;
+            }
+            .ud-page-title {
+                color: #111827;
+                font-size: 2.2rem;
+                line-height: 1.08;
+                font-weight: 800;
+                margin: 0 0 8px 0;
+            }
+
+            .ud-page-desc {
+                color: #64748b;
+                font-size: 1rem;
+                margin: 0 0 16px 0;
+            }
+
+            .ud-topbar {
+                display: flex;
+                align-items: center;
+                gap: 10px;
+                background: #bae1fc;
+                border: 4px solid #d7e4f2;
+                border-radius: 20px;
+                color: #111827;
+                font-size: 1.05rem;
+                font-weight: 700;
+                padding: 12px 14px;
+                margin-bottom: 7px;
+            }
+
+            .ud-topbar img {
+                width: 20px;
+                height: 20px;
+                object-fit: contain;
+                border-radius: 4px;
+            }
+
+
+
+            div[class*="st-key-material_ident_card"] [data-testid="stVerticalBlockBorderWrapper"] {
+                background: transparent !important;
+                border: 0 !important;
+                border-radius: 0 !important;
+                padding: 0 !important;
+                box-shadow: none !important;
+            }
+
+            div[class*="st-key-material_form_card"] [data-testid="stVerticalBlockBorderWrapper"] {
+                background: transparent !important;
+                border: 0 !important;
+                border-radius: 0 !important;
+                padding: 0 !important;
+                box-shadow: none !important;
+            }
+
+            .ud-ident-title {
+                color: #111827;
+                font-size: 2rem;
+                font-weight: 800;
+                margin: 4px 0 8px 2px;
+                display: flex;
+                align-items: center;
+                gap: 8px;
+            }
+
+            .ud-sec-icon {
+                width: 18px;
+                height: 18px;
+                border-radius: 999px;
+                background: #2563eb;
+                color: #ffffff;
+                display: inline-flex;
+                align-items: center;
+                justify-content: center;
+                font-size: 0.72rem;
+                font-weight: 700;
+                line-height: 1;
+            }
+
+            .ud-upload-title {
+                color: #111827;
+                font-size: 1.9rem;
+                font-weight: 800;
+                margin: 12px 0 8px 0;
+                display: flex;
+                align-items: center;
+                gap: 8px;
+            }
+
+            div[class*="st-key-material_ident_card"] label p {
+                color: #1f2937 !important;
+                font-size: 0.95rem !important;
+                font-weight: 600 !important;
+            }
+
+            div[class*="st-key-material_ident_card"] div[data-baseweb="select"] > div,
+            div[class*="st-key-material_ident_card"] div[data-baseweb="input"] > div {
+                min-height: 46px !important;
+                border-radius: 10px !important;
+                border: 1px solid #d6dee8 !important;
+                background: #f8fafc !important;
+            }
+
+            [data-testid="stFileUploaderDropzone"] {
+                background: #f8fbff !important;
+                border: 2px dashed #d4deea !important;
+                border-radius: 14px !important;
+                min-height: 230px !important;
+                padding: 1.4rem !important;
+                position: relative !important;
+                display: flex !important;
+                flex-direction: column !important;
+                align-items: center !important;
+                justify-content: center !important;
+            }
+
+            /* The inner flex column — center everything */
+            [data-testid="stFileUploaderDropzone"] > div {
+                display: flex !important;
+                flex-direction: column !important;
+                align-items: center !important;
+                justify-content: center !important;
+                text-align: center !important;
+                gap: 10px !important;
+                width: 100% !important;
+            }
+
+            /* Browse files button itself */
+            [data-testid="stFileUploaderDropzone"] button,
+            [data-testid="stFileUploaderDropzone"] > div button {
+                background: #2f6fe4 !important;
+                color: #ffffff !important;
+                border: 0 !important;
+                border-radius: 9px !important;
+                font-weight: 700 !important;
+                padding: 0.45rem 1.25rem !important;
+                display: block !important;
+                margin: 0 auto !important;
+            }
+
+            /* Streamlit wraps button in a top-level span; center that wrapper */
+            [data-testid="stFileUploaderDropzone"] > span {
+                display: flex !important;
+                justify-content: center !important;
+                width: 100% !important;
+                margin-top: 0.5rem !important;
+            }
+
+            [data-testid="stFileUploaderDropzone"] [data-testid="stFileUploaderDropzoneInstructions"] {
+                width: 100% !important;
+                display: flex !important;
+                flex-direction: column !important;
+                align-items: center !important;
+                justify-content: center !important;
+                text-align: center !important;
+            }
+
+            /* The "Limit 200MB" small text */
+            [data-testid="stFileUploaderDropzone"] small {
+                font-size: 0.96rem !important;
+                text-align: center !important;
+                display: block !important;
+            }
+
+            /* Cloud icon / drag text paragraph */
+            [data-testid="stFileUploaderDropzone"] p,
+            [data-testid="stFileUploaderDropzone"] div > p {
+                text-align: center !important;
+                width: 100% !important;
+            }
+        </style>
+        """,
+        unsafe_allow_html=True,
+    )
+   
+
+def render_top_bar():
+    logo_html = ""
+    try:
+        with open("logo.png", "rb") as fh:
+            logo_b64 = base64.b64encode(fh.read()).decode()
+        logo_html = f"<img src='data:image/png;base64,{logo_b64}' alt='AIM'/>"
+    except Exception:
+        logo_html = ""
+
+    st.markdown(
+        f"<div class='ud-topbar'>{logo_html}<span>AIM Composites</span></div>",
+        unsafe_allow_html=True,
+    )
+
+
+def input_form():
+    property_categories = {
+        "Polymer": [
+            "Thermal",
+            "Mechanical",
+            "Processing",
+            "Physical",
+            "Descriptive",
+        ],
+        "Fiber": [
+            "Mechanical",
+            "Physical",
+            "Thermal",
+            "Descriptive",
+        ],
+        "Composite": [
+            "Mechanical",
+            "Thermal",
+            "Processing",
+            "Physical",
+            "Descriptive",
+            "Composition / Reinforcement",
+            "Architecture / Structure",
+        ],
+    }
+
+    property_names = {
+        "Polymer": {
+            "Thermal": [
+                "Glass transition temperature (Tg)",
+                "Melting temperature (Tm)",
+                "Crystallization temperature (Tc)",
+                "Degree of crystallinity",
+                "Decomposition temperature",
+            ],
+            "Mechanical": [
+                "Tensile modulus",
+                "Tensile strength",
+                "Elongation at break",
+                "Flexural modulus",
+                "Impact strength",
+            ],
+            "Processing": [
+                "Melt flow index (MFI)",
+                "Processing temperature",
+                "Cooling rate",
+                "Mold shrinkage",
+            ],
+            "Physical": [
+                "Density",
+                "Specific gravity",
+            ],
+            "Descriptive": [
+                "Material grade",
+                "Manufacturer",
+            ],
+        },
+        "Fiber": {
+            "Mechanical": [
+                "Tensile modulus",
+                "Tensile strength",
+                "Strain to failure",
+            ],
+            "Physical": [
+                "Density",
+                "Fiber diameter",
+            ],
+            "Thermal": [
+                "Decomposition temperature",
+            ],
+            "Descriptive": [
+                "Fiber type",
+                "Surface treatment",
+            ],
+        },
+        "Composite": {
+            "Mechanical": [
+                "Longitudinal modulus (E1)",
+                "Transverse modulus (E2)",
+                "Shear modulus (G12)",
+                "Poissons ratio (V12)",
+                "Tensile strength (fiber direction)",
+                "Interlaminar shear strength",
+            ],
+            "Thermal": [
+                "Glass transition temperature (matrix)",
+                "Coefficient of thermal expansion (CTE)",
+            ],
+            "Processing": [
+                "Curing temperature",
+                "Curing pressure",
+            ],
+            "Physical": [
+                "Density",
+            ],
+            "Descriptive": [
+                "Laminate type",
+            ],
+            "Composition / Reinforcement": [
+                "Fiber volume fraction",
+                "Fiber weight fraction",
+                "Fiber type",
+                "Matrix type",
+            ],
+            "Architecture / Structure": [
+                "Weave type",
+                "Ply orientation",
+                "Number of plies",
+                "Stacking sequence",
+            ],
+        },
+    }
+
+    with st.container(border=False, key="material_ident_card"):
+        st.markdown("<div class='ud-ident-title'><span class='ud-sec-icon'>i</span>Material Identification</div>", unsafe_allow_html=True)
+
+        col_a, col_b = st.columns(2)
+        with col_a:
+            material_class = st.selectbox(
+                "Material Class",
+                ("Polymer", "Fiber", "Composite"),
+                index=None,
+                placeholder="Choose material class",
+                key="manual_material_class",
+            )
+        with col_b:
+            if material_class:
+                property_category = st.selectbox(
+                    "Property Type",
+                    property_categories[material_class],
+                    index=None,
+                    placeholder="Choose property type",
+                    key="manual_property_category",
+                )
+            else:
+                property_category = None
+                st.selectbox(
+                    "Property Type",
+                    ["Choose material class first"],
+                    index=0,
+                    disabled=True,
+                    key="manual_property_category_disabled",
+                )
+
+        if material_class and property_category:
+            property_options = property_names[material_class][property_category] + ["Something else"]
+            property_name = st.selectbox(
+                "Property Name",
+                property_options,
+                index=None,
+                placeholder="Choose property",
+                key="manual_property_name",
+            )
+        else:
+            property_name = None
+
+        custom_property_name = ""
+        if property_name == "Something else":
+            custom_property_name = st.text_input(
+                "Custom Property Name",
+                placeholder="Type property name",
+                key="manual_custom_property_name",
+            ).strip()
+
+        selected_property_name = (
+            custom_property_name if property_name == "Something else" else property_name
+        )
+
+    if material_class and property_category and selected_property_name:
+        with st.container(border=False, key="material_form_card"):
+            with st.form("user_input"):
+                st.subheader("Enter Data")
+
+                material_name = st.text_input("Material Name")
+                material_abbr = st.text_input("Material Abbreviation")
+
+                value = st.text_input("Value")
+                unit = st.text_input("Unit (SI)")
+                english = st.text_input("English Units")
+                test_condition = st.text_input("Test Condition")
+                comments = st.text_area("Comments")
+
+                submitted = st.form_submit_button("Submit")
+
+                if submitted:
+                    if not (material_name and value):
+                        st.error("Material name and value are required.")
+                        return False
+                    else:
+                        input_db = pd.DataFrame(
+                            [
+                                {
+                                    "material_class": material_class,
+                                    "material_name": material_name,
+                                    "material_abbreviation": material_abbr,
+                                    "section": property_category,
+                                    "property_name": selected_property_name,
+                                    "value": value,
+                                    "unit": unit,
+                                    "english": english,
+                                    "test_condition": test_condition,
+                                    "comments": comments,
+                                }
+                            ]
+                        )
+
+                        try:
+                            inserted = insert_material_rows(input_db)
+                        except Exception as exc:
+                            st.error(f"Failed to save to PostgreSQL: {exc}")
+                            return False
+
+                        if inserted <= 0:
+                            st.error("No rows were inserted into PostgreSQL.")
+                            return False
+
+                        st.cache_data.clear()
+                        st.success("Property added successfully to PostgreSQL.")
+                        st.dataframe(input_db)
+                        return True
+
+                return False
+
+    return False
+
+
+def main():
+    inject_upload_page_styles()
+    render_top_bar()
+
+
+    st.subheader("Submit Scientific Material")
+    st.caption("Provide technical data and research documentation for the central repository.")
+
+
+    if "image_results" not in st.session_state:
+        st.session_state.image_results = []
+    if "pdf_processed" not in st.session_state:
+        st.session_state.pdf_processed = False
+    if "current_pdf_name" not in st.session_state:
+        st.session_state.current_pdf_name = None
+    if "form_submitted" not in st.session_state:
+        st.session_state.form_submitted = False
+    if "pdf_data_extracted" not in st.session_state:
+        st.session_state.pdf_data_extracted = False
+    if "pdf_extracted_df" not in st.session_state:
+        st.session_state.pdf_extracted_df = pd.DataFrame()
+    if "saved_image_mapping" not in st.session_state:
+        st.session_state.saved_image_mapping = {}
+
+
+    with st.container(border=True, key="ud_main_card"):
+        if input_form():
+            st.session_state.form_submitted = True
+
+
+        st.markdown("<div class='ud-upload-title'><span class='ud-sec-icon'>i</span>Research Documentation</div>", unsafe_allow_html=True)
+
+        uploaded_file = st.file_uploader(
+            "Upload PDF (Material Datasheet or Research Paper)", type=["pdf"]
+        )
+
+
+        if not uploaded_file:
+            st.info("Upload a PDF to extract material data and plots")
+
+    if not uploaded_file:
+        st.session_state.pdf_processed = False
+        st.session_state.current_pdf_name = None
+        st.session_state.image_results = []
+        st.session_state.form_submitted = False
+        st.session_state.pdf_data_extracted = False
+        st.session_state.pdf_extracted_df = pd.DataFrame()
+        st.session_state.saved_image_mapping = {}
+        return
+
+    paper_id = os.path.splitext(uploaded_file.name)[0].replace(" ", "_")
+
+    if st.session_state.current_pdf_name != uploaded_file.name:
+        st.session_state.pdf_processed = False
+        st.session_state.current_pdf_name = uploaded_file.name
+        st.session_state.image_results = []
+        st.session_state.form_submitted = False
+        st.session_state.saved_image_mapping = {}
+
+    if st.session_state.form_submitted:
+        st.session_state.form_submitted = False
+        st.info(
+            "A Form was submitted. But your previous extracted data has been added already. "
+            "If you want to extract more data/plots upload again"
+        )
+        tab1, tab2 = st.tabs(["Material Data", "Extracted Plots"])
+        with tab1:
+            st.info("Material data from form has been added to database.")
+        with tab2:
+            st.info("Plots already extracted")
+        return
+
+    tab1, tab2 = st.tabs([" Material Data", " Extracted Plots"])
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        pdf_path = os.path.join(tmpdir, uploaded_file.name)
+        with open(pdf_path, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+
+        with tab1:
+            st.subheader("Material Properties Data")
+
+            if not st.session_state.pdf_data_extracted:
+                with st.spinner(" Extracting material data..."):
+                    with open(pdf_path, "rb") as f:
+                        pdf_bytes = f.read()
+
+                    data = call_gemini_from_bytes(pdf_bytes, uploaded_file.name)
+
+                    if data:
+                        df = convert_to_dataframe(data)
+                        if not df.empty:
+                            st.session_state.pdf_extracted_df = df
+                            st.session_state.pdf_data_extracted = True
+                            st.session_state.pdf_extracted_meta = data
+                        else:
+                            st.warning("No data extracted")
+                    else:
+                        st.error("Failed to extract data from PDF")
+
+            df = st.session_state.pdf_extracted_df
+
+            if not df.empty:
+                data = st.session_state.get("pdf_extracted_meta", {})
+                st.success(f"Extracted {len(df)} properties")
+
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.metric("Material", data.get("material_name", "N/A"))
+                with col2:
+                    st.metric("Abbreviation", data.get("material_abbreviation", "N/A"))
+
+                st.dataframe(df, use_container_width=True, height=400)
+                st.subheader("Assign Material Category")
+
+                extracted_material_class = st.selectbox(
+                    "Select category for this material",
+                    ["Polymer", "Fiber", "Composite"],
+                    index=None,
+                    placeholder="Required before adding to database",
+                )
+
+                if st.button("+Add to Database"):
+                    if not extracted_material_class:
+                        st.error("Please select a material category before adding.")
+                    else:
+                        df["material_class"] = extracted_material_class
+                        df["material_type"] = extracted_material_class
+
+                        if st.session_state.image_results:
+                            with st.spinner("Saving matched plot images..."):
+                                saved_images = save_matched_images(
+                                    df,
+                                    st.session_state.image_results,
+                                    save_dir="images",
+                                )
+
+                                if saved_images:
+                                    st.success(f" Saved {len(saved_images)} plot image(s)")
+                                    with st.expander("View saved images"):
+                                        for img_info in saved_images:
+                                            st.write(
+                                                f"? **{img_info['property']}** ? {img_info['caption']}"
+                                            )
+                                            st.write(f"  Saved to: `{img_info['path']}`")
+                                else:
+                                    st.info("? No plots matched the extracted properties")
+
+                        if "user_uploaded_data" not in st.session_state:
+                            st.session_state["user_uploaded_data"] = df
+                        else:
+                            st.session_state["user_uploaded_data"] = pd.concat(
+                                [st.session_state["user_uploaded_data"], df],
+                                ignore_index=True,
+                            )
+
+                        st.success(f"Added to {extracted_material_class} database!")
+
+        with tab2:
+            st.subheader("Extracted Plot Images")
+
+            if not st.session_state.pdf_processed:
+                with st.spinner(" Extracting plots from PDF..."):
+                    doc = fitz.open(pdf_path)
+                    st.session_state.image_results = extract_images(doc)
+                    doc.close()
+                    st.session_state.pdf_processed = True
+
+            if st.session_state.image_results:
+                has_extracted_data = not st.session_state.pdf_extracted_df.empty
+
+                if has_extracted_data:
+                    mat_abbr = st.session_state.pdf_extracted_df.iloc[0][
+                        "material_abbreviation"
+                    ]
+                    property_list = (
+                        st.session_state.pdf_extracted_df["property_name"].unique().tolist()
+                    )
+
+                    st.info(
+                        f" Material: **{mat_abbr}** | {len(property_list)} properties available for mapping"
+                    )
+                else:
+                    st.warning(
+                        " No extracted material data found. Please extract material data first (Tab 1) to enable property mapping."
+                    )
+
+                subtab1, subtab2 = st.tabs([" Images", "JSON Preview"])
+
+                with subtab1:
+                    st.success(
+                        f"Extracted {len(st.session_state.image_results)} plots"
+                    )
+
+                    col_img, col_json, col_all = st.columns(3)
+
+                    with col_img:
+                        img_zip = create_zip(st.session_state.image_results, include_json=False)
+                        st.download_button(
+                            " Download Images Only",
+                            data=img_zip,
+                            file_name=f"{paper_id}_images.zip",
+                            mime="application/zip",
+                            use_container_width=True,
+                            key="download_images",
+                        )
+
+                    with col_json:
+                        json_data = [
+                            {
+                                "caption": r["caption"],
+                                "page": r["page"],
+                                "image_count": len(r["image_data"]),
+                            }
+                            for r in st.session_state.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="download_json_top",
+                        )
+
+                    with col_all:
+                        full_zip = create_zip(st.session_state.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="download_all",
+                        )
+
+                    st.divider()
+
+                    if st.session_state.saved_image_mapping:
+                        with st.expander(" Saved Image Mappings", expanded=False):
+                            for img_key, mapping_info in st.session_state.saved_image_mapping.items():
+                                st.write(
+                                    f" **{mapping_info['caption']}** ? `{mapping_info['property']}`"
+                                )
+                                st.write(
+                                    f"    Saved as: `{mapping_info['filename']}`"
+                                )
+                        st.divider()
+
+                    results_copy = st.session_state.image_results.copy()
+
+                    for idx in range(len(results_copy)):
+                        if idx >= len(st.session_state.image_results):
+                            break
+
+                        result = st.session_state.image_results[idx]
+
+                        with st.container(border=True):
+                            col_cap, col_btn = st.columns([0.85, 0.15])
+                            col_cap.markdown(
+                                f"**Page {result['page']}** - {result['caption']}"
+                            )
+
+                            if col_btn.button("Delete", key=f"del_g_{idx}_{result['page']}"):
+                                del st.session_state.image_results[idx]
+                                st.rerun()
+
+                            image_data_list = result["image_data"]
+                            if image_data_list and len(image_data_list) > 0:
+                                for p_idx in range(len(image_data_list)):
+                                    if p_idx >= len(st.session_state.image_results[idx]["image_data"]):
+                                        break
+
+                                    img_data = st.session_state.image_results[idx]["image_data"][p_idx]
+                                    img_unique_key = f"{idx}_{p_idx}_{result['page']}"
+
+                                    st.image(img_data["array"], width=300, channels="BGR")
+
+                                    if has_extracted_data:
+                                        col_dropdown, col_add_btn, col_remove = st.columns(
+                                            [0.6, 0.2, 0.2]
+                                        )
+
+                                        with col_dropdown:
+                                            selected_property = st.selectbox(
+                                                "Select Property",
+                                                options=["-- Select --"] + property_list,
+                                                key=f"prop_select_{img_unique_key}",
+                                                label_visibility="collapsed",
+                                            )
+
+                                        with col_add_btn:
+                                            if st.button(" Add", key=f"add_btn_{img_unique_key}"):
+                                                if selected_property and selected_property != "-- Select --":
+                                                    filepath = save_single_image_with_property(
+                                                        img_data["array"],
+                                                        mat_abbr,
+                                                        selected_property,
+                                                        save_dir="images",
+                                                    )
+
+                                                    st.session_state.saved_image_mapping[
+                                                        img_unique_key
+                                                    ] = {
+                                                        "property": selected_property,
+                                                        "caption": result["caption"],
+                                                        "filename": os.path.basename(filepath),
+                                                        "path": filepath,
+                                                    }
+
+                                                    st.success(
+                                                        f" Saved as `{mat_abbr}_{selected_property}.png`"
+                                                    )
+                                                    st.rerun()
+                                                else:
+                                                    st.warning("Please select a property first")
+
+                                        with col_remove:
+                                            if st.button("Remove", key=f"del_s_{img_unique_key}"):
+                                                if img_unique_key in st.session_state.saved_image_mapping:
+                                                    del st.session_state.saved_image_mapping[img_unique_key]
+
+                                                del st.session_state.image_results[idx]["image_data"][p_idx]
+                                                if len(st.session_state.image_results[idx]["image_data"]) == 0:
+                                                    del st.session_state.image_results[idx]
+                                                st.rerun()
+
+                                        if img_unique_key in st.session_state.saved_image_mapping:
+                                            mapping = st.session_state.saved_image_mapping[img_unique_key]
+                                            st.info(f"Mapped to: **{mapping['property']}**")
+                                    else:
+                                        col_info, col_remove = st.columns([0.8, 0.2])
+                                        with col_info:
+                                            st.caption(
+                                                "Extract material data first to enable property mapping"
+                                            )
+                                        with col_remove:
+                                            if st.button("Remove", key=f"del_s_{img_unique_key}"):
+                                                del st.session_state.image_results[idx]["image_data"][p_idx]
+                                                if len(st.session_state.image_results[idx]["image_data"]) == 0:
+                                                    del st.session_state.image_results[idx]
+                                                st.rerun()
+
+                                    st.divider()
+
+                with subtab2:
+                    st.subheader("Metadata Preview")
+                    json_data = [
+                        {
+                            "caption": r["caption"],
+                            "page": r["page"],
+                            "image_count": len(r["image_data"]),
+                            "images": [img["filename"] for img in r["image_data"]],
+                        }
+                        for r in st.session_state.image_results
+                    ]
+
+                    st.download_button(
+                        " Download JSON",
+                        data=json.dumps(json_data, indent=4),
+                        file_name=f"{paper_id}_metadata.json",
+                        mime="application/json",
+                        key="download_json_bottom",
+                    )
+
+                    st.json(json_data)
+            else:
+                st.warning("No plots found in PDF")
+
+
+main()

page_files/categorized/Backend/Pdf_DataExtraction.py

@@ -0,0 +1,295 @@
+import streamlit as st
+import pandas as pd
+from PIL import Image
+import requests
+import base64
+import json
+import os
+from typing import Dict, Any, Optional
+
+
+
+
+# Backend PDF extraction Logic
+API_KEY = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+API_URL = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-09-2025:generateContent?key={API_KEY}"
+
+SCHEMA = {
+    "type": "OBJECT",
+    "properties": {
+        "material_name": {"type": "STRING"},
+        "material_abbreviation": {"type": "STRING"},
+        "mechanical_properties": {
+            "type": "ARRAY",
+            "items": {
+                "type": "OBJECT",
+                "properties": {
+                    "section": {"type": "STRING"},
+                    "property_name": {"type": "STRING"},
+                    "value": {"type": "STRING"},
+                    "unit": {"type": "STRING"},
+                    "english": {"type": "STRING"},
+                    "test_condition": {"type": "STRING"},
+                    "comments": {"type": "STRING"}
+                },
+                "required": ["section", "property_name", "value", "english", "comments"]
+            }
+        }
+    }
+}
+
+# === GEMINI CALL FUNCTION ===
+def call_gemini_from_bytes(pdf_bytes: bytes, filename: str) -> Optional[Dict[str, Any]]:
+    """Calls Gemini API with PDF bytes"""
+    try:
+        encoded_file = base64.b64encode(pdf_bytes).decode("utf-8")
+        mime_type = "application/pdf"
+    except Exception as e:
+        st.error(f"Error encoding PDF: {e}")
+        return None
+
+    prompt = (
+         "Extract all experimental data from this research paper. "
+         "For each measurement, extract: "
+         "- experiment_name, measured_value, unit, uncertainty, method, conditions. "
+         "Return as JSON."
+        # "You are an expert materials scientist. From the attached PDF, extract the material name, "
+        # "abbreviation, and ALL properties across categories (Mechanical, Thermal, Electrical, Physical, "
+        # "Optical, Rheological, etc.). Return them as 'mechanical_properties' (a single list). "
+        # "For each property, you MUST extract:\n"
+        # "- property_name\n- value (or range)\n- unit\n"
+        # "- english (converted or alternate units, e.g., psi, °F, inches; write '' if not provided)\n"
+        # "- test_condition\n- comments (include any notes, footnotes, standards, remarks; write '' if none)\n"
+        # "All fields including english and comments are REQUIRED. Respond ONLY with valid JSON following the schema."
+    )
+
+    payload = {
+        "contents": [
+            {
+                "parts": [
+                    {"text": prompt},
+                    {"inlineData": {"mimeType": mime_type, "data": encoded_file}}
+                ]
+            }
+        ],
+        "generationConfig": {
+            "temperature": 0,
+            "responseMimeType": "application/json",
+            "responseSchema": SCHEMA
+        }
+    }
+
+    try:
+        r = requests.post(API_URL, json=payload, timeout=300)
+        r.raise_for_status()
+        data = r.json()
+        
+        candidates = data.get("candidates", [])
+        if not candidates:
+            return None
+
+        parts = candidates[0].get("content", {}).get("parts", [])
+        json_text = None
+        for p in parts:
+            t = p.get("text", "")
+            if t.strip().startswith("{"):
+                json_text = t
+                break
+
+        return json.loads(json_text) if json_text else None
+    except Exception as e:
+        st.error(f"Gemini API Error: {e}")
+        return None
+
+
+def convert_to_dataframe(data: Dict[str, Any]) -> pd.DataFrame:
+    """Convert extracted JSON to DataFrame"""
+    rows = []
+    for item in data.get("mechanical_properties", []):
+        rows.append({
+            "material_name": data.get("material_name", ""),
+            "material_abbreviation": data.get("material_abbreviation", ""),
+            "section": item.get("section", ""),
+            "property_name": item.get("property_name", ""),
+            "value": item.get("value", ""),
+            "unit": item.get("unit", ""),
+            "english": item.get("english", ""),
+            "test_condition": item.get("test_condition", ""),
+            "comments": item.get("comments", "")
+        })
+    return pd.DataFrame(rows)
+
+
+
+#using sentence transformers and semantic search techniques
+import sqlite3
+import pandas as pd
+import os
+import requests
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# ==========================
+# CONFIGURATION
+# ==========================
+DB_PATH = "output_materials.db"
+EXCEL_PATH = "5.1__actual.xlsx"
+OUTPUT_EXCEL = "5.1__filled.xlsx"
+GEMINI_KEY = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+
+GEMINI_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent"
+
+
+# ==========================
+# GEMINI YES/NO MATCH CHECK
+# ==========================
+def gemini_same_property(excel_prop, db_prop):
+    prompt = f"""
+You are an expert materials scientist. Determine if BOTH property names refer
+to the SAME mechanical property.
+
+Excel property: "{excel_prop}"
+Database property: "{db_prop}"
+
+Rules:
+- Compare meaning, not formatting.
+- Ignore units, values, and numbers.
+- If either refers to conditions, test setup, or non-property info, return NO.
+- Return ONLY YES or NO.
+"""
+
+    payload = {
+        "contents": [{"parts": [{"text": prompt}]}]
+    }
+
+    response = requests.post(
+        GEMINI_URL,
+        params={"key": GEMINI_KEY},
+        json=payload,
+        timeout=60
+    ).json()
+
+    try:
+        ans = response["candidates"][0]["content"]["parts"][0]["text"].strip().upper()
+    except:
+        return False
+
+    return ans == "YES"
+
+
+# ==========================
+# SEMANTIC MATCHER (fallback)
+# ==========================
+embed_model = SentenceTransformer("all-MiniLM-L6-v2")
+
+def semantic_match(excel_prop, df_section):
+    if df_section.empty:
+        return None
+
+    # compute embeddings
+    db_props = df_section["property_name"].tolist()
+    db_vecs = embed_model.encode(db_props, convert_to_numpy=True)
+    q_vec = embed_model.encode([excel_prop], convert_to_numpy=True)
+
+    sims = cosine_similarity(q_vec, db_vecs)[0]
+
+    df_section = df_section.copy()
+    df_section["sim"] = sims
+    df_section = df_section.sort_values("sim", ascending=False)
+
+    # Take top-5 candidates for Gemini check
+    top5 = df_section.head(5)
+
+    for _, row in top5.iterrows():
+        cand = row["property_name"]
+        if gemini_same_property(excel_prop, cand):
+            return row
+
+    return None
+
+
+# ==========================
+# MAIN PIPELINE
+# ==========================
+conn = sqlite3.connect(DB_PATH)
+
+# Get material tables
+tables = pd.read_sql_query(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';",
+    conn
+)["name"].tolist()
+
+print(f"Detected tables: {tables}")
+
+# Load Excel template once
+df_excel_template = pd.read_excel(EXCEL_PATH)
+cols = df_excel_template.columns.tolist()
+
+section_col = next((c for c in cols if "section" in c.lower()), None)
+prop_col = next((c for c in cols if "property" in c.lower()), cols[0])
+
+print(f"Detected section column: {section_col}")
+print(f"Detected property column: {prop_col}")
+
+with pd.ExcelWriter(OUTPUT_EXCEL, engine="openpyxl") as writer:
+
+    for table in tables:
+        print(f"\nProcessing table: {table}")
+
+        # Load DB table
+        df_db = pd.read_sql_query(f"""
+            SELECT section, property_name, value, unit, english, comments
+            FROM '{table}'
+        """, conn)
+
+        df_excel = df_excel_template.copy()
+        df_excel["Matched Property"] = ""
+        df_excel["Value"] = ""
+        df_excel["Unit"] = ""
+        df_excel["English"] = ""
+        df_excel["Comments"] = ""
+
+        # Process each Excel property
+        for i, row in df_excel.iterrows():
+            excel_prop = str(row[prop_col]).strip()
+            excel_section = str(row.get(section_col, "")).strip().lower()
+
+
+            if section_col:
+                df_sec = df_db[df_db["section"].str.lower() == excel_section]
+            else:
+                df_sec = df_db
+
+            # ==========================
+            # 1️ EXACT MATCH
+            # ==========================
+            exact = df_sec[df_sec["property_name"].str.lower() == excel_prop.lower()]
+
+            if not exact.empty:
+                r = exact.iloc[0]
+                df_excel.at[i, "Matched Property"] = r["property_name"]
+                df_excel.at[i, "Value"] = r["value"]
+                df_excel.at[i, "Unit"] = r["unit"]
+                df_excel.at[i, "English"] = r["english"]
+                df_excel.at[i, "Comments"] = r["comments"]
+                continue  # done
+
+            # ==========================
+            # 2️ SEMANTIC + GEMINI MATCH
+            # ==========================
+            best = semantic_match(excel_prop, df_sec)
+
+            if best is not None:
+                df_excel.at[i, "Matched Property"] = best["property_name"]
+                df_excel.at[i, "Value"] = best["value"]
+                df_excel.at[i, "Unit"] = best["unit"]
+                df_excel.at[i, "English"] = best["english"]
+                df_excel.at[i, "Comments"] = best["comments"]
+            else:
+                df_excel.at[i, "Matched Property"] = ""
+
+        # Write one sheet per material
+        df_excel.to_excel(writer, sheet_name=table[:31], index=False)
+
+print(f"\nDONE → Final filled Excel: {OUTPUT_EXCEL}")
+conn.close()

page_files/categorized/Backend/Pdf_ImageExtraction.py

@@ -0,0 +1,390 @@
+import os
+import re
+import json
+import math
+import tempfile
+import fitz  # PyMuPDF
+import cv2
+import numpy as np
+from PIL import Image
+import streamlit as st
+
+# -------------------
+# Config
+# -------------------
+DPI = 300
+OUT_DIR = "outputs"
+
+KEEP_ONLY_STRESS_STRAIN = False
+
+CAP_RE = re.compile(r"^(Fig\.?\s*\d+|Figure\s*\d+)\b", re.IGNORECASE)
+SS_KW  = re.compile(
+    r"(stress\s*[-–]?\s*strain|stress|strain|tensile|MPa|GPa|kN|yield|elongation)",
+    re.IGNORECASE
+)
+
+# -------------------
+# Render helpers
+# -------------------
+def render_page(page, dpi=DPI):
+    mat = fitz.Matrix(dpi/72, dpi/72)
+    pix = page.get_pixmap(matrix=mat, alpha=False)
+    img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+    return img, mat
+
+def pdf_to_px_bbox(bbox_pdf, mat):
+    x0, y0, x1, y1 = bbox_pdf
+    sx, sy = mat.a, mat.d
+    return (int(float(x0) * sx), int(float(y0) * sy), int(float(x1) * sx), int(float(y1) * sy))
+
+def safe_crop_px(pil_img, box):
+    if not isinstance(box, (tuple, list)):
+        return None
+    if len(box) == 1 and isinstance(box[0], (tuple, list)) and len(box[0]) == 4:
+        box = box[0]
+    if len(box) != 4:
+        return None
+
+    x0, y0, x1, y1 = box
+    if any(isinstance(v, (tuple, list)) for v in (x0, y0, x1, y1)):
+        return None
+
+    try:
+        x0 = int(x0)
+        y0 = int(y0)
+        x1 = int(x1)
+        y1 = int(y1)
+    except (TypeError, ValueError):
+        return None
+
+    if x1 < x0: 
+        x0, x1 = x1, x0
+    if y1 < y0: 
+        y0, y1 = y1, y0
+
+    W, H = pil_img.size
+    x0 = max(0, min(W, x0))
+    x1 = max(0, min(W, x1))
+    y0 = max(0, min(H, y0))
+    y1 = max(0, min(H, y1))
+    if x1 <= x0 or y1 <= y0:
+        return None
+    return pil_img.crop((x0, y0, x1, y1))
+
+# -------------------
+# Captions
+# -------------------
+def find_caption_blocks(page):
+    caps = []
+    blocks = page.get_text("blocks")
+    for b in blocks:
+        x0, y0, x1, y1, text = b[0], b[1], b[2], b[3], b[4]
+        t = " ".join(str(text).strip().split())
+        if CAP_RE.match(t):
+            caps.append({"bbox": (x0, y0, x1, y1), "text": t})
+    return caps
+
+# -------------------
+# Dedupe: dHash
+# -------------------
+def dhash64(pil_img):
+    gray = pil_img.convert("L").resize((9, 8), Image.LANCZOS)
+    pixels = list(gray.getdata())
+    bits = 0
+    for r in range(8):
+        for c in range(8):
+            left = pixels[r * 9 + c]
+            right = pixels[r * 9 + c + 1]
+            bits = (bits << 1) | (1 if left > right else 0)
+    return bits
+
+# -------------------
+# Rejectors
+# -------------------
+def has_colorbar_like_strip(pil_img):
+    img = np.array(pil_img)
+    if img.ndim != 3:
+        return False
+    H, W, _ = img.shape
+    if W < 250 or H < 150:
+        return False
+    strip_w = max(18, int(0.07 * W))
+    strip = img[:, W-strip_w:W, :]
+    q = (strip // 24).reshape(-1, 3)
+    uniq = np.unique(q, axis=0)
+    return len(uniq) > 70
+
+def texture_score(pil_img):
+    gray = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2GRAY)
+    lap = cv2.Laplacian(gray, cv2.CV_64F)
+    return float(lap.var())
+
+def is_mostly_legend(pil_img):
+    gray = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2GRAY)
+    bw = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]
+    bw = cv2.medianBlur(bw, 3)
+    H, W = bw.shape
+    fill = float(np.count_nonzero(bw)) / float(H * W)
+    return (0.03 < fill < 0.18) and (min(H, W) < 260)
+
+# -------------------
+# Plot detection
+# -------------------
+def detect_axes_lines(pil_img):
+    gray = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2GRAY)
+    edges = cv2.Canny(gray, 50, 150)
+    H, W = gray.shape
+    min_len = int(0.28 * min(H, W))
+
+    lines = cv2.HoughLinesP(
+        edges, 1, np.pi/180,
+        threshold=90,
+        minLineLength=min_len,
+        maxLineGap=14
+    )
+    if lines is None:
+        return None, None
+
+    horizontals, verticals = [], []
+    for x1, y1, x2, y2 in lines[:, 0]:
+        dx, dy = abs(x2-x1), abs(y2-y1)
+        length = math.hypot(dx, dy)
+        if dy < 18 and dx > 0.35 * W:
+            horizontals.append((length, (x1, y1, x2, y2)))
+        if dx < 18 and dy > 0.35 * H:
+            verticals.append((length, (x1, y1, x2, y2)))
+
+    if not horizontals or not verticals:
+        return None, None
+
+    horizontals.sort(key=lambda t: t[0], reverse=True)
+    verticals.sort(key=lambda t: t[0], reverse=True)
+    return horizontals[0][1], verticals[0][1]
+
+def axis_intersection_ok(x_axis, y_axis, W, H):
+    xa_y = int(round((x_axis[1] + x_axis[3]) / 2))
+    ya_x = int(round((y_axis[0] + y_axis[2]) / 2))
+    if not (0 <= xa_y < H and 0 <= ya_x < W):
+        return False
+    if ya_x > int(0.95 * W) or xa_y < int(0.05 * H):
+        return False
+    return True
+
+def tick_text_presence_score(pil_img, x_axis, y_axis):
+    img = np.array(pil_img)
+    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+    bw = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]
+    bw = cv2.medianBlur(bw, 3)
+
+    H, W = gray.shape
+    xa_y = int(round((x_axis[1] + x_axis[3]) / 2))
+    ya_x = int(round((y_axis[0] + y_axis[2]) / 2))
+
+    y0a = max(0, xa_y - 40)
+    y1a = min(H, xa_y + 110)
+    x_roi = bw[y0a:y1a, 0:W]
+
+    x0b = max(0, ya_x - 180)
+    x1b = min(W, ya_x + 50)
+    y_roi = bw[0:H, x0b:x1b]
+
+    def count_small_components(mask):
+        num, _, stats, _ = cv2.connectedComponentsWithStats(mask, connectivity=8)
+        cnt = 0
+        for i in range(1, num):
+            x, y, w, h, area = stats[i]
+            if 4 <= w <= 150 and 4 <= h <= 150 and 20 <= area <= 5000:
+                cnt += 1
+        return cnt
+
+    return count_small_components(x_roi) + count_small_components(y_roi)
+
+def is_real_plot(pil_img):
+    if has_colorbar_like_strip(pil_img):
+        return False
+    if is_mostly_legend(pil_img):
+        return False
+
+    x_axis, y_axis = detect_axes_lines(pil_img)
+    if x_axis is None or y_axis is None:
+        return False
+
+    arr = np.array(pil_img)
+    H, W = arr.shape[0], arr.shape[1]
+    if not axis_intersection_ok(x_axis, y_axis, W, H):
+        return False
+
+    if texture_score(pil_img) > 2200:
+        return False
+
+    score = tick_text_presence_score(pil_img, x_axis, y_axis)
+    return score >= 18
+
+# -------------------
+# Candidate boxes in a region
+# -------------------
+def connected_components_boxes(pil_img):
+    img_bgr = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
+    gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
+    mask = (gray < 245).astype(np.uint8) * 255
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8), iterations=2)
+    num, _, stats, _ = cv2.connectedComponentsWithStats(mask, connectivity=8)
+
+    boxes = []
+    for i in range(1, num):
+        x, y, w, h, area = stats[i]
+        boxes.append((int(area), (int(x), int(y), int(x + w), int(y + h))))
+    boxes.sort(key=lambda t: t[0], reverse=True)
+    return boxes
+
+def expand_box(box, W, H, left=0.10, right=0.06, top=0.06, bottom=0.18):
+    x0, y0, x1, y1 = box
+    bw = x1 - x0
+    bh = y1 - y0
+    ex0 = max(0, int(x0 - left * bw))
+    ex1 = min(W, int(x1 + right * bw))
+    ey0 = max(0, int(y0 - top * bh))
+    ey1 = min(H, int(y1 + bottom * bh))
+    return (ex0, ey0, ex1, ey1)
+
+# -------------------
+# Crop plot from caption
+# -------------------
+def crop_plot_from_caption(page_img, cap_bbox_pdf, mat):
+    cap_px = pdf_to_px_bbox(cap_bbox_pdf, mat)
+    cap_y0 = cap_px[1]
+    cap_y1 = cap_px[3]
+
+    W, H = page_img.size
+    search_top = max(0, cap_y0 - int(0.95 * H))
+    search_bot = min(H, cap_y1 + int(0.20 * H))
+    region = safe_crop_px(page_img, (0, search_top, W, search_bot))
+    if region is None:
+        return None
+
+    comps = connected_components_boxes(region)
+    best = None
+    best_area = -1
+
+    for area, box in comps[:35]:
+        x0, y0, x1, y1 = box
+        bw = x1 - x0
+        bh = y1 - y0
+        if bw < 220 or bh < 180:
+            continue
+
+        exp = expand_box(box, region.size[0], region.size[1])
+        cand = safe_crop_px(region, exp)
+        if cand is None:
+            continue
+
+        if not is_real_plot(cand):
+            continue
+
+        if area > best_area:
+            best_area = area
+            best = cand
+
+    return best
+
+# -------------------
+# Streamlit UI
+# -------------------
+def run_extraction(pdf_path, paper_id="uploaded_paper"):
+    out_paper = os.path.join(OUT_DIR, paper_id)
+    out_imgs = os.path.join(out_paper, "plots_with_axes")
+    os.makedirs(out_imgs, exist_ok=True)
+
+    doc = fitz.open(pdf_path)
+    results = []
+    seen = set()
+    saved = 0
+
+    for p in range(len(doc)):
+        page = doc[p]
+        caps = find_caption_blocks(page)
+        if not caps:
+            continue
+
+        page_img, mat = render_page(page, dpi=DPI)
+
+        for cap in caps:
+            cap_text = cap["text"]
+
+            if KEEP_ONLY_STRESS_STRAIN and not SS_KW.search(cap_text):
+                continue
+
+            fig = crop_plot_from_caption(page_img, cap["bbox"], mat)
+            if fig is None:
+                continue
+
+            if fig.size[0] > 8 and fig.size[1] > 8:
+                fig = fig.crop((2, 2, fig.size[0]-2, fig.size[1]-2))
+
+            try:
+                h = dhash64(fig)
+            except Exception:
+                continue
+
+            if h in seen:
+                continue
+            seen.add(h)
+
+            img_name = f"p{p+1:02d}_{saved:04d}.png"
+            img_path = os.path.join(out_imgs, img_name)
+            fig.save(img_path)
+
+            results.append({
+                "page": p + 1,
+                "caption": cap_text,
+                "image": img_path
+            })
+            saved += 1
+
+    out_json = os.path.join(out_paper, "plots_with_axes.json")
+    with open(out_json, "w", encoding="utf-8") as f:
+        json.dump(results, f, indent=2, ensure_ascii=False)
+
+    return results, out_json
+
+def main():
+    st.set_page_config(page_title="Research Paper Plot Extractor", layout="wide")
+    st.title(" Plot Extractor (Upload PDF)")
+
+    uploaded = st.file_uploader("Upload a research paper PDF", type=["pdf"])
+    if not uploaded:
+        st.info("Upload a PDF to extract plots.")
+        return
+
+    paper_id = os.path.splitext(uploaded.name)[0].replace(" ", "_")
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        pdf_path = os.path.join(tmpdir, uploaded.name)
+        with open(pdf_path, "wb") as f:
+            f.write(uploaded.read())
+
+        with st.spinner("Extracting plots..."):
+            results, out_json = run_extraction(pdf_path, paper_id=paper_id)
+
+        st.success(f"Extracted {len(results)} plots.")
+
+        # Show images + captions
+        for r in results:
+            st.markdown(f"**Page {r['page']}** — {r['caption']}")
+            st.image(r["image"], use_container_width=True)
+            st.divider()
+
+        # JSON viewer + download
+        st.subheader("JSON Output")
+        st.json(results)
+
+        with open(out_json, "rb") as f:
+            st.download_button(
+                "Download JSON",
+                data=f,
+                file_name=os.path.basename(out_json),
+                mime="application/json"
+            )
+
+if __name__ == "__main__":
+    main()

page_files/categorized/Backend/upload_backend.py

@@ -0,0 +1,356 @@
+import os
+import re
+import json
+import zipfile
+from io import BytesIO
+from typing import Dict, Any, Optional
+from collections import defaultdict
+
+import cv2
+import fitz  # PyMuPDF
+import numpy as np
+import pandas as pd
+import requests
+import streamlit as st
+import base64
+
+API_KEY = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+API_URL = (
+    "https://generativelanguage.googleapis.com/v1beta/"
+    "models/gemini-2.5-flash-preview-09-2025:generateContent?key="
+    f"{API_KEY}"
+    if API_KEY
+    else None
+)
+
+SCHEMA = {
+    "type": "OBJECT",
+    "properties": {
+        "material_name": {"type": "STRING"},
+        "material_abbreviation": {"type": "STRING"},
+        "trade_grade": {
+            "type": "STRING",
+            "description": "Commercial or trade grade name of the material; '' if not provided",
+        },
+        "manufacturer": {
+            "type": "STRING",
+            "description": "Company or organization producing the material; '' if not provided",
+        },
+        "mechanical_properties": {
+            "type": "ARRAY",
+            "items": {
+                "type": "OBJECT",
+                "properties": {
+                    "section": {"type": "STRING"},
+                    "property_name": {"type": "STRING"},
+                    "value": {"type": "STRING"},
+                    "unit": {"type": "STRING"},
+                    "english": {"type": "STRING"},
+                    "test_condition": {"type": "STRING"},
+                    "comments": {"type": "STRING"},
+                },
+                "required": [
+                    "section",
+                    "property_name",
+                    "value",
+                    "english",
+                    "comments",
+                ],
+            },
+        },
+    },
+}
+
+DPI = 300
+CAP_RE = re.compile(r"^(Fig\.?\s*\d+|Figure\s*\d+)\b", re.IGNORECASE)
+
+
+def make_abbreviation(name: str) -> str:
+    if not name:
+        return "UNKNOWN"
+    words = name.split()
+    abbr = "".join(w[0] for w in words if w and w[0].isalpha()).upper()
+    return abbr or name[:6].upper()
+
+
+def call_gemini_from_bytes(pdf_bytes: bytes, filename: str) -> Optional[Dict[str, Any]]:
+    if not API_KEY or not API_URL:
+        st.error("Missing Gemini API key. Set GEMINI_API_KEY in environment variables.")
+        return None
+
+    try:
+        encoded_file = base64.b64encode(pdf_bytes).decode("utf-8")
+        mime_type = "application/pdf"
+    except Exception as exc:
+        st.error(f"Error encoding PDF: {exc}")
+        return None
+
+    prompt = (
+        "You are an expert materials scientist. From the attached PDF, extract:\n"
+        "- material_name (generic material, e.g., isotactic polypropylene)\n"
+        "- material_abbreviation\n"
+        "- trade_grade (commercial or trade name; write '' if not provided)\n"
+        "- manufacturer (company or organization producing the material; write '' if not provided)\n\n"
+        "Extract ALL properties across categories (Mechanical, Thermal, Electrical, Physical, "
+        "Optical, Rheological, etc.) and return them as 'mechanical_properties' (a single list).\n\n"
+        "For each property, you MUST extract:\n"
+        "- property_name\n"
+        "- value (or range)\n"
+        "- unit\n"
+        "- english (converted or alternate units, e.g., psi, °F, inches; write '' if not provided)\n"
+        "- test_condition\n"
+        "- comments (include any notes, footnotes, standards, remarks; write '' if none)\n\n"
+        "All fields including english and comments are REQUIRED.\n"
+        "Respond ONLY with valid JSON following the schema."
+    )
+
+    payload = {
+        "contents": [
+            {
+                "parts": [
+                    {"text": prompt},
+                    {"inlineData": {"mimeType": mime_type, "data": encoded_file}},
+                ]
+            }
+        ],
+        "generationConfig": {
+            "temperature": 0,
+            "responseMimeType": "application/json",
+            "responseSchema": SCHEMA,
+        },
+    }
+
+    try:
+        response = requests.post(API_URL, json=payload, timeout=300)
+        response.raise_for_status()
+        data = response.json()
+
+        candidates = data.get("candidates", [])
+        if not candidates:
+            return None
+
+        parts = candidates[0].get("content", {}).get("parts", [])
+        json_text = None
+        for part in parts:
+            text = part.get("text", "")
+            if text.strip().startswith("{"):
+                json_text = text
+                break
+
+        return json.loads(json_text) if json_text else None
+    except Exception as exc:
+        st.error(f"Gemini API Error: {exc}")
+        return None
+
+
+def convert_to_dataframe(data: Dict[str, Any]) -> pd.DataFrame:
+    mat_name = data.get("material_name", "") or ""
+    mat_abbr = data.get("material_abbreviation", "") or ""
+    trade_grade = data.get("trade_grade", "") or ""
+    manufacturer = data.get("manufacturer", "") or ""
+
+    if not mat_abbr:
+        mat_abbr = make_abbreviation(mat_name)
+
+    rows = []
+    for item in data.get("mechanical_properties", []):
+        rows.append(
+            {
+                "material_name": mat_name,
+                "material_abbreviation": mat_abbr,
+                "trade_grade": trade_grade,
+                "manufacturer": manufacturer,
+                "section": item.get("section", "") or "Mechanical",
+                "property_name": item.get("property_name", "") or "Unknown property",
+                "value": item.get("value", "") or "N/A",
+                "unit": item.get("unit", "") or "",
+                "english": item.get("english", "") or "",
+                "test_condition": item.get("test_condition", "") or "",
+                "comments": item.get("comments", "") or "",
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+def get_page_image(page):
+    pix = page.get_pixmap(matrix=fitz.Matrix(DPI / 72, DPI / 72))
+    img = np.frombuffer(pix.samples, dtype=np.uint8).reshape(pix.h, pix.w, 3)
+    return cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+
+
+def is_valid_plot_geometry(binary_crop):
+    height, width = binary_crop.shape
+    if height < 100 or width < 100:
+        return False
+    ink_density = cv2.countNonZero(binary_crop) / (width * height)
+    if ink_density > 0.35:
+        return False
+    h_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (width // 4, 1))
+    v_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, height // 4))
+    has_h = cv2.countNonZero(cv2.erode(binary_crop, h_kernel, iterations=1)) > 0
+    has_v = cv2.countNonZero(cv2.erode(binary_crop, v_kernel, iterations=1)) > 0
+    return has_h or has_v
+
+
+def merge_boxes(rects):
+    if not rects:
+        return []
+    rects = sorted(rects, key=lambda r: r[2] * r[3], reverse=True)
+    merged = []
+    for rect in rects:
+        rx, ry, rw, rh = rect
+        if not any(
+            rx >= m[0] - 15
+            and ry >= m[1] - 15
+            and rx + rw <= m[0] + m[2] + 15
+            and ry + rh <= m[1] + m[3] + 15
+            for m in merged
+        ):
+            merged.append(rect)
+    return merged
+
+
+def extract_images(pdf_doc):
+    grouped_data = defaultdict(lambda: {"page": 0, "image_data": []})
+    padding = 30
+
+    for page_num, page in enumerate(pdf_doc, start=1):
+        img_bgr = get_page_image(page)
+        gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
+        _, binary = cv2.threshold(gray, 225, 255, cv2.THRESH_BINARY_INV)
+        kernel = np.ones((10, 10), np.uint8)
+        dilated = cv2.dilate(binary, kernel, iterations=1)
+        contours, _ = cv2.findContours(dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+        candidates = []
+        page_h, page_w = gray.shape
+        for cnt in contours:
+            x, y, w, h = cv2.boundingRect(cnt)
+            if 0.03 < (w * h) / (page_w * page_h) < 0.8:
+                if is_valid_plot_geometry(binary[y : y + h, x : x + w]):
+                    candidates.append((x, y, w, h))
+
+        final_rects = merge_boxes(candidates)
+        blocks = page.get_text("blocks")
+
+        for (cx, cy, cw, ch) in final_rects:
+            best_caption = f"Figure on Page {page_num} (Unlabeled)"
+            min_dist = float("inf")
+            for block in blocks:
+                text = block[4].strip()
+                if CAP_RE.match(text):
+                    cap_y = block[1] * (DPI / 72)
+                    dist = cap_y - (cy + ch)
+                    if 0 < dist < (page_h * 0.3) and dist < min_dist:
+                        best_caption = text.replace("\n", " ")
+                        min_dist = dist
+
+            x1, y1 = max(0, cx - padding), max(0, cy - padding)
+            x2, y2 = min(page_w, cx + cw + padding), min(page_h, cy + ch + padding)
+            crop = img_bgr[int(y1) : int(y2), int(x1) : int(x2)]
+
+            _, buffer = cv2.imencode(".png", crop)
+            img_bytes = buffer.tobytes()
+            fname = f"pg{page_num}_{cx}_{cy}.png"
+
+            grouped_data[best_caption]["page"] = page_num
+            grouped_data[best_caption]["image_data"].append(
+                {"filename": fname, "bytes": img_bytes, "array": crop}
+            )
+
+    return [
+        {"caption": key, "page": value["page"], "image_data": value["image_data"]}
+        for key, value in grouped_data.items()
+    ]
+
+
+def create_zip(results, include_json=True):
+    buf = BytesIO()
+    with zipfile.ZipFile(buf, "w") as zf:
+        if include_json:
+            json_data = [
+                {"caption": item["caption"], "page": item["page"], "image_count": len(item["image_data"])}
+                for item in results
+            ]
+            zf.writestr("plot_data.json", json.dumps(json_data, indent=4))
+
+        for item in results:
+            for img_data in item["image_data"]:
+                zf.writestr(img_data["filename"], img_data["bytes"])
+
+    buf.seek(0)
+    return buf.getvalue()
+
+
+def match_caption_to_property(caption: str, property_name: str) -> bool:
+    caption_lower = caption.lower()
+    prop_lower = property_name.lower()
+
+    if prop_lower in caption_lower:
+        return True
+
+    keyword_map = {
+        "tensile modulus": ["tensile", "modulus", "young", "elastic"],
+        "tensile strength": ["tensile", "strength", "ultimate"],
+        "elongation at break": ["elongation", "strain", "break"],
+        "glass transition temperature": ["glass transition", "tg", "transition"],
+        "melting temperature": ["melting", "tm", "melt"],
+        "density": ["density", "specific gravity"],
+        "impact strength": ["impact", "izod", "charpy"],
+        "flexural modulus": ["flexural", "bending", "flex"],
+        "stress": ["stress", "strain"],
+        "thermal": ["thermal", "temperature", "heat"],
+        "crystallinity": ["crystallinity", "crystalline", "xrd"],
+    }
+
+    for prop_key, keywords in keyword_map.items():
+        if prop_key in prop_lower and any(kw in caption_lower for kw in keywords):
+            return True
+
+    prop_words = set(prop_lower.replace("(", "").replace(")", "").split())
+    caption_words = set(caption_lower.replace("(", "").replace(")", "").split())
+
+    common_words = prop_words & caption_words
+    significant_words = common_words - {"the", "of", "at", "in", "a", "an"}
+
+    return len(significant_words) >= 2
+
+
+def save_matched_images(df: pd.DataFrame, image_results: list, save_dir: str = "images"):
+    os.makedirs(save_dir, exist_ok=True)
+    saved_images = []
+
+    if df.empty:
+        return saved_images
+
+    mat_abbr = df.iloc[0]["material_abbreviation"]
+    properties = df["property_name"].unique()
+    matched_properties = set()
+
+    for img_result in image_results:
+        caption = img_result["caption"]
+
+        for prop in properties:
+            if prop in matched_properties:
+                continue
+            if match_caption_to_property(caption, prop):
+                if img_result["image_data"]:
+                    first_img = img_result["image_data"][0]
+                    filename = f"{mat_abbr}_{prop}.png"
+                    filepath = os.path.join(save_dir, filename)
+                    cv2.imwrite(filepath, first_img["array"])
+                    saved_images.append({"property": prop, "caption": caption, "path": filepath})
+                    matched_properties.add(prop)
+                    break
+
+    return saved_images
+
+
+def save_single_image_with_property(
+    img_array, mat_abbr: str, property_name: str, save_dir: str = "images"
+) -> str:
+    os.makedirs(save_dir, exist_ok=True)
+    filename = f"{mat_abbr}_{property_name}.png"
+    filepath = os.path.join(save_dir, filename)
+    cv2.imwrite(filepath, img_array)
+    return filepath