🔬 Setting Up Scientific Visualization Tools on Alpine Linux: Research Computing

Let’s transform Alpine Linux into a powerful scientific visualization workstation! 🚀 This comprehensive tutorial shows you how to install and configure cutting-edge visualization software for data analysis, 3D rendering, and computational research. Perfect for researchers, scientists, and engineers who need high-performance visualization on a lightweight system! 😊

🤔 What is Scientific Visualization?

Scientific visualization is the practice of creating graphical representations of scientific data and phenomena to enable researchers to understand, analyze, and communicate complex information through interactive 2D/3D graphics, animations, and immersive visual experiences!

Scientific visualization is like:

• 🎨 Digital art studio where data transforms into meaningful visual stories
• 🔭 Powerful telescope that reveals hidden patterns in complex datasets
• 🧬 Microscope that makes invisible scientific phenomena visible and comprehensible

🎯 What You Need

Before we start, you need:

• ✅ Alpine Linux system with adequate GPU and memory resources
• ✅ Understanding of scientific computing and data analysis concepts
• ✅ Knowledge of programming languages like Python, R, or MATLAB
• ✅ Root access for system package installation and GPU driver configuration

📋 Step 1: Install Graphics and Computing Foundation

Install Graphics Drivers and OpenGL Support

Let’s set up the graphics foundation! 😊

What we’re doing: Installing graphics drivers, OpenGL libraries, and GPU acceleration components for high-performance 3D rendering and visualization.

# Update package list
apk update

# Install X11 and graphics libraries
apk add xorg-server xorg-server-xvfb
apk add mesa mesa-dev mesa-gl mesa-gles

# Install GPU drivers (choose based on your hardware)
apk add mesa-dri-gallium        # Open source drivers
apk add xf86-video-nouveau      # NVIDIA open source
apk add xf86-video-amdgpu       # AMD graphics
apk add xf86-video-intel        # Intel graphics

# Install OpenGL and graphics development libraries
apk add libgl1-mesa-dev libglu1-mesa-dev
apk add freeglut3-dev libglew-dev
apk add libglfw3-dev

# Install image and video processing libraries
apk add opencv opencv-dev
apk add imagemagick imagemagick-dev
apk add ffmpeg ffmpeg-dev

# Install mathematical libraries
apk add blas lapack
apk add gsl gsl-dev
apk add fftw fftw-dev

# Install compression and I/O libraries
apk add hdf5 hdf5-dev
apk add netcdf netcdf-dev
apk add zlib-dev libpng-dev libjpeg-turbo-dev

# Install font rendering
apk add fontconfig freetype freetype-dev
apk add font-noto font-dejavu

# Test OpenGL support
apk add mesa-demos
glxinfo | grep "OpenGL version"
glxgears

echo "Graphics foundation installed! 🎨"

What this does: 📖 Installs complete graphics and computational libraries for scientific visualization.

Example output:

OpenGL version string: 4.6 Mesa 23.1.9
1047 frames in 5.0 seconds = 209.374 FPS
Graphics foundation installed! 🎨

What this means: Graphics acceleration is ready for visualization software! ✅

Install Python Scientific Computing Stack

Let’s set up Python for scientific computing! 🎯

What we’re doing: Installing Python with NumPy, SciPy, matplotlib, and other essential scientific computing libraries for data analysis and visualization.

# Install Python and development tools
apk add python3 python3-dev py3-pip
apk add python3-tkinter  # For matplotlib GUI backend

# Install compilation tools for Python packages
apk add gcc g++ gfortran
apk add musl-dev linux-headers

# Install Python scientific computing stack
pip3 install --upgrade pip setuptools wheel

# Core scientific computing libraries
pip3 install numpy scipy matplotlib
pip3 install pandas scikit-learn
pip3 install sympy statsmodels

# Visualization libraries
pip3 install plotly bokeh altair
pip3 install seaborn plotnine
pip3 install mayavi vtk

# Jupyter ecosystem for interactive computing
pip3 install jupyter jupyterlab
pip3 install ipywidgets ipyvolume

# 3D visualization and rendering
pip3 install pyvista meshio
pip3 install trimesh pyglet
pip3 install open3d

# Image and signal processing
pip3 install pillow scikit-image
pip3 install opencv-python

# Parallel computing
pip3 install dask distributed
pip3 install joblib multiprocessing-logging

# Create scientific computing environment
cat > ~/.bashrc << 'EOF'

# Scientific Computing Environment
export PYTHONPATH="/usr/local/lib/python3.11/site-packages:$PYTHONPATH"
export JUPYTER_CONFIG_DIR="$HOME/.jupyter"
export MPLBACKEND="TkAgg"

# Aliases for scientific tools
alias jupyter-lab='jupyter-lab --ip=0.0.0.0 --port=8888 --allow-root'
alias python-sci='python3 -c "import numpy as np; import matplotlib.pyplot as plt; import pandas as pd; print(\"Scientific computing environment ready!\")"'

echo "Python scientific computing environment loaded! 🐍"
EOF

source ~/.bashrc

# Verify installation
python3 -c "
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import vtk
print('✅ NumPy version:', np.__version__)
print('✅ Matplotlib version:', plt.matplotlib.__version__)
print('✅ Pandas version:', pd.__version__)
print('✅ VTK version:', vtk.vtkVersion().GetVTKVersion())
"

echo "Python scientific stack installed! 🐍"

What this does: 📖 Sets up comprehensive Python environment for scientific computing and visualization.

Example output:

✅ NumPy version: 1.24.3
✅ Matplotlib version: 3.7.1
✅ Pandas version: 2.0.3
✅ VTK version: 9.2.6
Python scientific stack installed! 🐍

What this means: Python scientific computing environment is fully operational! ✅

📋 Step 2: Install Specialized Visualization Software

Install ParaView for 3D Visualization

Let’s set up ParaView for advanced 3D visualization! 😊

What we’re doing: Installing and configuring ParaView, a powerful open-source application for large-scale data analysis and visualization.

# Create ParaView installation directory
mkdir -p /opt/paraview
cd /tmp

# Download ParaView (adjust version as needed)
PARAVIEW_VERSION="5.12.0"
PARAVIEW_URL="https://www.paraview.org/paraview-downloads/download.php?submit=Download&version=v5.12&type=binary&os=Linux&downloadFile=ParaView-5.12.0-MPI-Linux-Python3.10-x86_64.tar.gz"

# Download and extract ParaView
wget -O paraview.tar.gz "$PARAVIEW_URL"
tar -xzf paraview.tar.gz -C /opt/paraview --strip-components=1

# Create ParaView wrapper script
cat > /usr/local/bin/paraview << 'EOF'
#!/bin/bash

# ParaView Launcher Script
export PARAVIEW_HOME="/opt/paraview"
export PATH="$PARAVIEW_HOME/bin:$PATH"
export LD_LIBRARY_PATH="$PARAVIEW_HOME/lib:$LD_LIBRARY_PATH"

# Set display environment
export DISPLAY=${DISPLAY:-:0}

# Launch ParaView with optimizations
exec "$PARAVIEW_HOME/bin/paraview" \
    --force-offscreen-rendering \
    --mesa-gpu-override \
    "$@"
EOF

chmod +x /usr/local/bin/paraview

# Create ParaView server script for remote visualization
cat > /usr/local/bin/paraview-server << 'EOF'
#!/bin/bash

# ParaView Server Script
PARAVIEW_HOME="/opt/paraview"
PORT=${1:-11111}
DATA_DIR=${2:-/data}

echo "Starting ParaView server on port $PORT"
echo "Data directory: $DATA_DIR"

export LD_LIBRARY_PATH="$PARAVIEW_HOME/lib:$LD_LIBRARY_PATH"

exec "$PARAVIEW_HOME/bin/pvserver" \
    --server-port=$PORT \
    --force-offscreen-rendering \
    --data-directory="$DATA_DIR"
EOF

chmod +x /usr/local/bin/paraview-server

# Install ParaView Python bindings
PYTHONPATH="/opt/paraview/lib/python3.10/site-packages:$PYTHONPATH"
export PYTHONPATH

# Create ParaView configuration
mkdir -p ~/.config/ParaView

cat > ~/.config/ParaView/ParaView-5.12.ini << 'EOF'
[General]
RecentFiles=
ShowWelcomeDialog=false
AutoApplySettings=true

[RenderView]
UseOffscreenRendering=true
EnableAntiAliasing=true
StereoType=Crystal Eyes

[Settings]
ColorPalette=Default
BackgroundColor=0.32,0.34,0.43
EOF

# Test ParaView installation
/opt/paraview/bin/paraview --version

echo "ParaView installed and configured! 🔬"

What this does: 📖 Installs ParaView with server capabilities and optimized configuration for scientific visualization.

Example output:

paraview version 5.12.0
ParaView installed and configured! 🔬

What this means: ParaView is ready for large-scale data visualization! ✅

Install VisIt for Advanced Visualization

Let’s add VisIt for specialized scientific visualization! 🎯

What we’re doing: Installing VisIt, a distributed, parallel visualization tool for analyzing extremely large datasets.

# Create VisIt installation directory
mkdir -p /opt/visit
cd /tmp

# Download VisIt (adjust version as needed)
VISIT_VERSION="3.3.3"
VISIT_URL="https://github.com/visit-dav/visit/releases/download/v3.3.3/visit3_3_3.linux-x86_64-ubuntu18.tar.gz"

# Download and extract VisIt
wget -O visit.tar.gz "$VISIT_URL"
tar -xzf visit.tar.gz -C /opt/visit --strip-components=1

# Create VisIt wrapper script
cat > /usr/local/bin/visit << 'EOF'
#!/bin/bash

# VisIt Launcher Script
export VISIT_HOME="/opt/visit"
export PATH="$VISIT_HOME/bin:$PATH"
export LD_LIBRARY_PATH="$VISIT_HOME/lib:$LD_LIBRARY_PATH"

# Set environment for VisIt
export VISITPLUGINDIR="$VISIT_HOME/plugins"
export VISITHOME="$VISIT_HOME"

# Configure for headless operation if no display
if [ -z "$DISPLAY" ]; then
    VISIT_ARGS="-nowin -cli"
else
    VISIT_ARGS=""
fi

# Launch VisIt
exec "$VISIT_HOME/bin/visit" $VISIT_ARGS "$@"
EOF

chmod +x /usr/local/bin/visit

# Install VisIt Python module
VISIT_PYTHON_PATH="/opt/visit/lib/site-packages"
if [ -d "$VISIT_PYTHON_PATH" ]; then
    echo "export PYTHONPATH=\"$VISIT_PYTHON_PATH:\$PYTHONPATH\"" >> ~/.bashrc
fi

# Create VisIt configuration directory
mkdir -p ~/.visit

# Configure VisIt for scientific computing
cat > ~/.visit/config << 'EOF'
# VisIt Configuration for Scientific Computing

# Default rendering settings
VISIT_RENDERING_ENGINE="mesa"
VISIT_PRECISION="double"

# Memory and performance settings
VISIT_MEMORY_LIMIT="8GB"
VISIT_PARALLEL_COMPUTE="true"

# File format support
VISIT_FILE_FORMATS="all"

# Visualization settings
VISIT_DEFAULT_COLORMAP="viridis"
VISIT_ANTIALIASING="true"
EOF

# Test VisIt installation
/opt/visit/bin/visit -version

echo "VisIt installed and configured! 📊"

What this does: 📖 Installs VisIt with parallel visualization capabilities for large-scale scientific data.

Example output:

VisIt version 3.3.3
VisIt installed and configured! 📊

What this means: VisIt is ready for distributed data visualization! ✅

📋 Step 3: Configure Jupyter Environment for Interactive Visualization

Set Up JupyterLab with Extensions

Let’s create a powerful interactive visualization environment! 😊

What we’re doing: Configuring JupyterLab with visualization extensions, GPU acceleration, and scientific computing widgets.

# Install JupyterLab extensions
pip3 install jupyterlab-widgets
pip3 install jupyterlab-matplotlib
pip3 install jupyter-bokeh
pip3 install ipyvolume
pip3 install pythreejs

# Install additional visualization tools
pip3 install plotly-dash
pip3 install streamlit
pip3 install panel holoviews

# Install computational notebooks extensions
pip3 install nb_conda_kernels
pip3 install jupyter-lsp
pip3 install jupyterlab-git

# Configure JupyterLab
jupyter lab --generate-config

# Create JupyterLab configuration
cat > ~/.jupyter/jupyter_lab_config.py << 'EOF'
# JupyterLab Configuration for Scientific Visualization

# Server settings
c.ServerApp.ip = '0.0.0.0'
c.ServerApp.port = 8888
c.ServerApp.open_browser = False
c.ServerApp.allow_remote_access = True
c.ServerApp.token = ''  # Disable token for local development
c.ServerApp.password = ''

# Resource settings
c.ResourceUseDisplay.mem_limit = 8 * 1024**3  # 8GB
c.ResourceUseDisplay.track_cpu_percent = True

# Kernel settings
c.MultiKernelManager.default_kernel_name = 'python3'

# File browser settings
c.ContentsManager.allow_hidden = True

# WebGL and graphics settings
c.NotebookApp.allow_origin = '*'
c.NotebookApp.disable_check_xsrf = True
EOF

# Create custom kernel for scientific computing
python3 -m ipykernel install --user --name=scientific-viz --display-name="Scientific Visualization"

# Create kernel configuration
mkdir -p ~/.local/share/jupyter/kernels/scientific-viz
cat > ~/.local/share/jupyter/kernels/scientific-viz/kernel.json << 'EOF'
{
 "argv": [
  "/usr/bin/python3",
  "-m",
  "ipykernel_launcher",
  "-f",
  "{connection_file}"
 ],
 "display_name": "Scientific Visualization",
 "language": "python",
 "env": {
   "MPLBACKEND": "module://matplotlib_inline.backend_inline",
   "PYTHONPATH": "/opt/paraview/lib/python3.10/site-packages:/opt/visit/lib/site-packages"
 }
}
EOF

# Create sample scientific visualization notebook
mkdir -p ~/notebooks
cat > ~/notebooks/scientific-visualization-demo.ipynb << 'EOF'
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scientific Visualization Demo on Alpine Linux\n",
    "\n",
    "This notebook demonstrates various scientific visualization techniques available on Alpine Linux."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import scientific computing libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import plotly.graph_objects as go\n",
    "import plotly.express as px\n",
    "from scipy import stats\n",
    "import seaborn as sns\n",
    "\n",
    "# Configure matplotlib for high-quality output\n",
    "plt.style.use('seaborn-v0_8')\n",
    "plt.rcParams['figure.dpi'] = 150\n",
    "plt.rcParams['savefig.dpi'] = 300\n",
    "\n",
    "print(\"✅ Scientific visualization environment loaded!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate sample scientific data\n",
    "np.random.seed(42)\n",
    "\n",
    "# 3D surface data\n",
    "x = np.linspace(-5, 5, 100)\n",
    "y = np.linspace(-5, 5, 100)\n",
    "X, Y = np.meshgrid(x, y)\n",
    "Z = np.sin(np.sqrt(X**2 + Y**2)) * np.exp(-0.1 * (X**2 + Y**2))\n",
    "\n",
    "# Time series data\n",
    "time = np.linspace(0, 4*np.pi, 1000)\n",
    "signal1 = np.sin(time) + 0.1 * np.random.randn(1000)\n",
    "signal2 = np.cos(time * 1.5) + 0.1 * np.random.randn(1000)\n",
    "\n",
    "# Statistical data\n",
    "data = pd.DataFrame({\n",
    "    'x': np.random.normal(0, 1, 1000),\n",
    "    'y': np.random.normal(0, 1, 1000),\n",
    "    'category': np.random.choice(['A', 'B', 'C'], 1000)\n",
    "})\n",
    "\n",
    "print(\"📊 Sample data generated!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3D Surface Visualization\n",
    "fig = go.Figure(data=[go.Surface(x=X, y=Y, z=Z, colorscale='viridis')])\n",
    "fig.update_layout(\n",
    "    title='3D Scientific Surface Plot',\n",
    "    scene=dict(\n",
    "        xaxis_title='X Coordinate',\n",
    "        yaxis_title='Y Coordinate',\n",
    "        zaxis_title='Field Intensity'\n",
    "    ),\n",
    "    width=800,\n",
    "    height=600\n",
    ")\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Statistical Analysis Visualization\n",
    "fig, axes = plt.subplots(2, 2, figsize=(12, 10))\n",
    "\n",
    "# Scatter plot with regression\n",
    "sns.scatterplot(data=data, x='x', y='y', hue='category', ax=axes[0,0])\n",
    "axes[0,0].set_title('Scatter Plot with Categories')\n",
    "\n",
    "# Distribution plots\n",
    "sns.histplot(data=data, x='x', hue='category', ax=axes[0,1])\n",
    "axes[0,1].set_title('Distribution Analysis')\n",
    "\n",
    "# Box plots\n",
    "sns.boxplot(data=data, x='category', y='y', ax=axes[1,0])\n",
    "axes[1,0].set_title('Box Plot Comparison')\n",
    "\n",
    "# Correlation heatmap\n",
    "corr_matrix = data[['x', 'y']].corr()\n",
    "sns.heatmap(corr_matrix, annot=True, ax=axes[1,1])\n",
    "axes[1,1].set_title('Correlation Matrix')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Time Series Analysis\n",
    "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))\n",
    "\n",
    "# Signal plots\n",
    "ax1.plot(time, signal1, label='Signal 1', alpha=0.7)\n",
    "ax1.plot(time, signal2, label='Signal 2', alpha=0.7)\n",
    "ax1.set_title('Time Series Signals')\n",
    "ax1.set_xlabel('Time')\n",
    "ax1.set_ylabel('Amplitude')\n",
    "ax1.legend()\n",
    "ax1.grid(True, alpha=0.3)\n",
    "\n",
    "# Frequency domain analysis\n",
    "freqs1 = np.fft.fftfreq(len(signal1), time[1] - time[0])\n",
    "fft1 = np.fft.fft(signal1)\n",
    "freqs2 = np.fft.fftfreq(len(signal2), time[1] - time[0])\n",
    "fft2 = np.fft.fft(signal2)\n",
    "\n",
    "ax2.semilogy(freqs1[:len(freqs1)//2], np.abs(fft1)[:len(fft1)//2], label='Signal 1 FFT')\n",
    "ax2.semilogy(freqs2[:len(freqs2)//2], np.abs(fft2)[:len(fft2)//2], label='Signal 2 FFT')\n",
    "ax2.set_title('Frequency Domain Analysis')\n",
    "ax2.set_xlabel('Frequency')\n",
    "ax2.set_ylabel('Magnitude')\n",
    "ax2.legend()\n",
    "ax2.grid(True, alpha=0.3)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Scientific Visualization",
   "language": "python",
   "name": "scientific-viz"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
EOF

echo "JupyterLab scientific environment configured! 📓"

What this does: 📖 Sets up comprehensive JupyterLab environment with scientific visualization extensions and sample notebooks.

Example output:

JupyterLab scientific environment configured! 📓

What this means: Interactive scientific computing environment is ready! ✅

Install R and RStudio for Statistical Computing

Let’s add R for statistical visualization! 🎯

What we’re doing: Installing R programming language with statistical packages and visualization libraries for advanced data analysis.

# Install R and development packages
apk add R R-dev
apk add R-doc

# Install system dependencies for R packages
apk add curl-dev libxml2-dev
apk add cairo-dev pango-dev
apk add harfbuzz-dev fribidi-dev

# Start R and install essential packages
R --slave --no-restore --no-save << 'EOF'
# Install package management
if (!require(pak)) install.packages("pak", repos="https://cloud.r-project.org")

# Core data manipulation and visualization
pak::pkg_install(c(
  "tidyverse",
  "ggplot2", 
  "plotly",
  "shiny",
  "DT"
))

# Statistical analysis packages
pak::pkg_install(c(
  "stats",
  "MASS",
  "car",
  "lme4",
  "survival"
))

# Advanced visualization
pak::pkg_install(c(
  "ggvis",
  "lattice", 
  "gridExtra",
  "cowplot",
  "patchwork"
))

# 3D visualization and graphics
pak::pkg_install(c(
  "rgl",
  "plot3D",
  "plotrix",
  "RColorBrewer"
))

# Interactive and web-based visualization
pak::pkg_install(c(
  "leaflet",
  "networkD3",
  "visNetwork",
  "DiagrammeR"
))

# Time series and forecasting
pak::pkg_install(c(
  "forecast",
  "xts",
  "zoo",
  "lubridate"
))

# Bioinformatics and scientific computing
pak::pkg_install(c(
  "Biobase",
  "limma",
  "edgeR"
), repos=c("https://bioconductor.org/packages/3.18/bioc", "https://cloud.r-project.org"))

cat("R packages installed successfully!\n")
EOF

# Create R configuration for scientific computing
mkdir -p ~/.R
cat > ~/.R/Makevars << 'EOF'
# R Configuration for Scientific Computing
CXX11FLAGS = -O3 -march=native
CXXFLAGS = -O3 -march=native
CFLAGS = -O3 -march=native
FFLAGS = -O3 -march=native
EOF

# Create sample R visualization script
cat > ~/scientific-r-demo.R << 'EOF'
# Scientific Visualization with R on Alpine Linux
library(tidyverse)
library(plotly)
library(rgl)
library(plot3D)

# Generate scientific data
set.seed(42)
n <- 1000

# Experimental data simulation
experiment_data <- data.frame(
  time = seq(0, 10, length.out = n),
  treatment = rep(c("A", "B", "C"), length.out = n),
  response = rnorm(n, mean = rep(c(5, 7, 6), length.out = n), sd = 1),
  measurement_error = rnorm(n, 0, 0.1)
)

experiment_data$corrected_response <- experiment_data$response + experiment_data$measurement_error

# Statistical visualization
p1 <- ggplot(experiment_data, aes(x = time, y = corrected_response, color = treatment)) +
  geom_point(alpha = 0.6) +
  geom_smooth(method = "loess") +
  labs(
    title = "Scientific Experiment Results",
    x = "Time (hours)",
    y = "Response Variable",
    color = "Treatment"
  ) +
  theme_minimal() +
  theme(
    plot.title = element_text(size = 14, face = "bold"),
    axis.title = element_text(size = 12),
    legend.position = "bottom"
  )

# Create interactive plot
interactive_plot <- ggplotly(p1, tooltip = c("x", "y", "colour"))

# 3D surface visualization
x <- seq(-2, 2, length.out = 50)
y <- seq(-2, 2, length.out = 50)
z <- outer(x, y, function(x, y) sin(sqrt(x^2 + y^2)) * exp(-0.1 * (x^2 + y^2)))

# Statistical summary
cat("=== Scientific Data Analysis Summary ===\n")
cat("Sample size:", nrow(experiment_data), "\n")
cat("Treatments:", unique(experiment_data$treatment), "\n")

# ANOVA analysis
model <- aov(corrected_response ~ treatment, data = experiment_data)
cat("ANOVA Results:\n")
print(summary(model))

# Create visualization report
png("scientific_analysis.png", width = 800, height = 600, res = 150)
print(p1)
dev.off()

cat("✅ R scientific visualization demo completed!\n")
cat("📊 Interactive plot and analysis files generated.\n")
EOF

# Test R installation
R --version

echo "R statistical computing environment installed! 📈"

What this does: 📖 Installs R with comprehensive statistical and visualization packages for scientific research.

Example output:

R version 4.3.2 (2023-10-31) -- "Eye Holes"
R statistical computing environment installed! 📈

What this means: R environment is ready for advanced statistical visualization! ✅

📋 Step 4: Configure GPU Acceleration and Remote Visualization

Set Up GPU Acceleration for Visualization

Let’s enable GPU acceleration for high-performance rendering! 😊

What we’re doing: Configuring GPU acceleration, CUDA support, and optimized rendering for computationally intensive visualizations.

# Install GPU acceleration libraries
apk add opencl-headers opencl-icd-loader
apk add vulkan-headers vulkan-loader vulkan-tools

# Install NVIDIA drivers and CUDA (if NVIDIA GPU present)
if lspci | grep -i nvidia; then
    echo "NVIDIA GPU detected, installing CUDA support..."
    
    # Add NVIDIA repository (community packages)
    echo "https://dl-cdn.alpinelinux.org/alpine/edge/community" >> /etc/apk/repositories
    apk update
    
    # Install NVIDIA drivers
    apk add nvidia-driver nvidia-uvm
    
    # Load NVIDIA modules
    modprobe nvidia
    modprobe nvidia-uvm
    
    # Add to startup
    echo "nvidia" >> /etc/modules
    echo "nvidia-uvm" >> /etc/modules
fi

# Configure Mesa for GPU acceleration
cat > /etc/environment << 'EOF'
# GPU Acceleration Configuration
MESA_GL_VERSION_OVERRIDE=4.5
MESA_GLSL_VERSION_OVERRIDE=450
LIBGL_ALWAYS_INDIRECT=0
GALLIUM_DRIVER=auto

# OpenCL configuration
OPENCL_VENDOR_PATH=/usr/lib/OpenCL/vendors

# Vulkan configuration
VK_ICD_FILENAMES=/usr/share/vulkan/icd.d/intel_icd.x86_64.json:/usr/share/vulkan/icd.d/radeon_icd.x86_64.json
EOF

# Create GPU benchmark script
cat > ~/gpu-benchmark.py << 'EOF'
#!/usr/bin/env python3

# GPU Acceleration Benchmark for Scientific Visualization
import numpy as np
import matplotlib.pyplot as plt
import time
try:
    import cupy as cp
    CUPY_AVAILABLE = True
except ImportError:
    CUPY_AVAILABLE = False
    print("CuPy not available, using CPU-only benchmarks")

def benchmark_computation(size=1000):
    """Benchmark computational performance"""
    print(f"Benchmarking computation with array size {size}x{size}")
    
    # CPU benchmark
    start_time = time.time()
    a_cpu = np.random.random((size, size))
    b_cpu = np.random.random((size, size))
    c_cpu = np.dot(a_cpu, b_cpu)
    cpu_time = time.time() - start_time
    
    print(f"CPU computation time: {cpu_time:.3f} seconds")
    
    # GPU benchmark (if available)
    if CUPY_AVAILABLE:
        start_time = time.time()
        a_gpu = cp.random.random((size, size))
        b_gpu = cp.random.random((size, size))
        c_gpu = cp.dot(a_gpu, b_gpu)
        cp.cuda.Stream.null.synchronize()
        gpu_time = time.time() - start_time
        
        print(f"GPU computation time: {gpu_time:.3f} seconds")
        print(f"GPU speedup: {cpu_time/gpu_time:.2f}x")
        
        return cpu_time, gpu_time
    
    return cpu_time, None

def benchmark_visualization(size=1000):
    """Benchmark visualization rendering"""
    print(f"Benchmarking visualization with {size}x{size} data points")
    
    # Generate test data
    x = np.linspace(-5, 5, size)
    y = np.linspace(-5, 5, size)
    X, Y = np.meshgrid(x, y)
    Z = np.sin(np.sqrt(X**2 + Y**2)) * np.exp(-0.1 * (X**2 + Y**2))
    
    # Benchmark matplotlib rendering
    start_time = time.time()
    fig, ax = plt.subplots(figsize=(10, 8))
    contour = ax.contourf(X, Y, Z, levels=50, cmap='viridis')
    plt.colorbar(contour)
    plt.title('GPU Accelerated Scientific Visualization')
    plt.savefig('/tmp/gpu_benchmark.png', dpi=300, bbox_inches='tight')
    plt.close()
    render_time = time.time() - start_time
    
    print(f"Visualization render time: {render_time:.3f} seconds")
    return render_time

def check_gpu_capabilities():
    """Check GPU capabilities"""
    print("=== GPU Capabilities Check ===")
    
    # Check OpenGL
    try:
        import OpenGL.GL as gl
        from OpenGL import GLUT
        print("✅ OpenGL support available")
        print(f"OpenGL Version: {gl.glGetString(gl.GL_VERSION).decode()}")
        print(f"OpenGL Renderer: {gl.glGetString(gl.GL_RENDERER).decode()}")
    except ImportError:
        print("❌ OpenGL not available")
    
    # Check CUDA
    if CUPY_AVAILABLE:
        try:
            print(f"✅ CUDA support available")
            print(f"CUDA Version: {cp.cuda.runtime.runtimeGetVersion()}")
            print(f"GPU Device: {cp.cuda.Device().name}")
            print(f"GPU Memory: {cp.cuda.Device().mem_info[1] / 1024**3:.1f} GB")
        except:
            print("❌ CUDA not properly configured")
    
    # Check Vulkan
    try:
        import subprocess
        result = subprocess.run(['vulkaninfo'], capture_output=True, text=True)
        if result.returncode == 0:
            print("✅ Vulkan support available")
        else:
            print("❌ Vulkan not available")
    except:
        print("❌ Vulkan not available")

def main():
    print("🚀 GPU Acceleration Benchmark for Scientific Visualization")
    print("=" * 60)
    
    check_gpu_capabilities()
    print()
    
    # Run benchmarks
    cpu_time, gpu_time = benchmark_computation(1000)
    render_time = benchmark_visualization(500)
    
    print("\n=== Benchmark Summary ===")
    print(f"CPU computation: {cpu_time:.3f}s")
    if gpu_time:
        print(f"GPU computation: {gpu_time:.3f}s (speedup: {cpu_time/gpu_time:.2f}x)")
    print(f"Visualization rendering: {render_time:.3f}s")
    
    print("\n✅ GPU benchmark completed!")

if __name__ == '__main__':
    main()
EOF

chmod +x ~/gpu-benchmark.py

# Install GPU acceleration for Python
pip3 install pyopengl pyopengl-accelerate

# Test GPU capabilities
python3 ~/gpu-benchmark.py

echo "GPU acceleration configured! 🚀"

What this does: 📖 Sets up GPU acceleration with comprehensive benchmarking and optimization for scientific visualization.

Example output:

🚀 GPU Acceleration Benchmark for Scientific Visualization
============================================================
✅ OpenGL support available
OpenGL Version: 4.6 Mesa 23.1.9
GPU acceleration configured! 🚀

What this means: GPU acceleration is enabled for high-performance visualization! ✅

Configure Remote Visualization Server

Let’s set up remote visualization capabilities! 🎯

What we’re doing: Configuring VNC, X11 forwarding, and web-based visualization servers for remote scientific computing access.

# Install VNC server for remote desktop
apk add x11vnc xvfb

# Install web-based visualization tools
pip3 install tornado websockets
pip3 install bokeh-server panel-serve

# Create VNC server configuration
mkdir -p ~/.vnc

# Set VNC password
echo "Creating VNC server configuration..."
x11vnc -storepasswd

# Create VNC startup script
cat > ~/.vnc/xstartup << 'EOF'
#!/bin/bash

# VNC Startup Script for Scientific Visualization
xrdb $HOME/.Xresources
xsetroot -solid grey

# Start window manager
if command -v fluxbox &> /dev/null; then
    exec fluxbox &
elif command -v fvwm &> /dev/null; then
    exec fvwm &
else
    exec twm &
fi

# Start scientific applications
if [ -f "$HOME/.vnc/scientific-apps" ]; then
    source "$HOME/.vnc/scientific-apps"
fi
EOF

chmod +x ~/.vnc/xstartup

# Create scientific applications startup
cat > ~/.vnc/scientific-apps << 'EOF'
# Scientific Applications Auto-start
export DISPLAY=:1

# Start JupyterLab
nohup jupyter-lab --ip=0.0.0.0 --port=8888 --allow-root &

# Start ParaView server
nohup paraview-server 11111 /data &

# Set up X11 forwarding optimizations
export XAUTHORITY=$HOME/.Xauthority
export SSH_ASKPASS=""
EOF

# Create VNC server management script
cat > /usr/local/bin/vnc-server << 'EOF'
#!/bin/bash

# VNC Server Management Script
VNC_DISPLAY=":1"
VNC_GEOMETRY="1920x1080"
VNC_DEPTH="24"

case "$1" in
    start)
        echo "Starting VNC server for scientific visualization..."
        
        # Start virtual display
        Xvfb $VNC_DISPLAY -screen 0 ${VNC_GEOMETRY}x${VNC_DEPTH} &
        XVFB_PID=$!
        
        # Wait for X server
        sleep 2
        
        # Start VNC server
        x11vnc -display $VNC_DISPLAY -forever -usepw -create &
        VNC_PID=$!
        
        # Save PIDs
        echo $XVFB_PID > /var/run/xvfb.pid
        echo $VNC_PID > /var/run/vnc.pid
        
        echo "VNC server started on display $VNC_DISPLAY"
        echo "Connect using VNC client to localhost:5901"
        ;;
        
    stop)
        echo "Stopping VNC server..."
        
        if [ -f /var/run/vnc.pid ]; then
            kill $(cat /var/run/vnc.pid) 2>/dev/null
            rm /var/run/vnc.pid
        fi
        
        if [ -f /var/run/xvfb.pid ]; then
            kill $(cat /var/run/xvfb.pid) 2>/dev/null
            rm /var/run/xvfb.pid
        fi
        
        echo "VNC server stopped"
        ;;
        
    status)
        if [ -f /var/run/vnc.pid ] && kill -0 $(cat /var/run/vnc.pid) 2>/dev/null; then
            echo "VNC server is running (PID: $(cat /var/run/vnc.pid))"
        else
            echo "VNC server is not running"
        fi
        ;;
        
    *)
        echo "Usage: $0 {start|stop|status}"
        exit 1
        ;;
esac
EOF

chmod +x /usr/local/bin/vnc-server

# Create web-based visualization server
cat > ~/web-viz-server.py << 'EOF'
#!/usr/bin/env python3

# Web-based Scientific Visualization Server
import tornado.web
import tornado.ioloop
import tornado.websocket
import json
import numpy as np
import matplotlib.pyplot as plt
import io
import base64
from threading import Thread
import time

class VisualizationHandler(tornado.web.RequestHandler):
    def get(self):
        self.render("visualization.html")

class PlotWebSocket(tornado.websocket.WebSocketHandler):
    def open(self):
        print("WebSocket connection opened")
        
    def on_message(self, message):
        try:
            data = json.loads(message)
            plot_type = data.get('type', 'line')
            
            # Generate visualization based on request
            if plot_type == 'surface':
                self.generate_surface_plot()
            elif plot_type == 'scatter':
                self.generate_scatter_plot()
            else:
                self.generate_line_plot()
                
        except Exception as e:
            self.write_message({'error': str(e)})
    
    def generate_line_plot(self):
        # Generate sample data
        x = np.linspace(0, 10, 100)
        y = np.sin(x) + 0.1 * np.random.randn(100)
        
        # Create plot
        plt.figure(figsize=(10, 6))
        plt.plot(x, y, 'b-', alpha=0.7, linewidth=2)
        plt.title('Scientific Line Plot')
        plt.xlabel('X Coordinate')
        plt.ylabel('Signal Amplitude')
        plt.grid(True, alpha=0.3)
        
        # Convert to base64
        img_buffer = io.BytesIO()
        plt.savefig(img_buffer, format='png', dpi=150, bbox_inches='tight')
        img_buffer.seek(0)
        img_str = base64.b64encode(img_buffer.read()).decode()
        plt.close()
        
        self.write_message({'type': 'plot', 'data': img_str})
    
    def generate_scatter_plot(self):
        # Generate sample data
        n = 200
        x = np.random.randn(n)
        y = 2 * x + np.random.randn(n)
        colors = np.random.rand(n)
        
        # Create plot
        plt.figure(figsize=(10, 6))
        scatter = plt.scatter(x, y, c=colors, alpha=0.7, s=50, cmap='viridis')
        plt.colorbar(scatter)
        plt.title('Scientific Scatter Plot')
        plt.xlabel('Variable X')
        plt.ylabel('Variable Y')
        plt.grid(True, alpha=0.3)
        
        # Convert to base64
        img_buffer = io.BytesIO()
        plt.savefig(img_buffer, format='png', dpi=150, bbox_inches='tight')
        img_buffer.seek(0)
        img_str = base64.b64encode(img_buffer.read()).decode()
        plt.close()
        
        self.write_message({'type': 'plot', 'data': img_str})
    
    def generate_surface_plot(self):
        # Generate 3D surface data
        x = np.linspace(-3, 3, 50)
        y = np.linspace(-3, 3, 50)
        X, Y = np.meshgrid(x, y)
        Z = np.sin(np.sqrt(X**2 + Y**2)) * np.exp(-0.1 * (X**2 + Y**2))
        
        # Create contour plot (2D representation of 3D surface)
        plt.figure(figsize=(10, 8))
        contour = plt.contourf(X, Y, Z, levels=20, cmap='viridis')
        plt.colorbar(contour)
        plt.title('Scientific Surface Plot')
        plt.xlabel('X Coordinate')
        plt.ylabel('Y Coordinate')
        
        # Convert to base64
        img_buffer = io.BytesIO()
        plt.savefig(img_buffer, format='png', dpi=150, bbox_inches='tight')
        img_buffer.seek(0)
        img_str = base64.b64encode(img_buffer.read()).decode()
        plt.close()
        
        self.write_message({'type': 'plot', 'data': img_str})
    
    def on_close(self):
        print("WebSocket connection closed")

def make_app():
    return tornado.web.Application([
        (r"/", VisualizationHandler),
        (r"/websocket", PlotWebSocket),
    ], template_path="templates", static_path="static")

def main():
    # Create templates directory
    import os
    os.makedirs("templates", exist_ok=True)
    os.makedirs("static", exist_ok=True)
    
    # Create HTML template
    html_template = '''
    <!DOCTYPE html>
    <html>
    <head>
        <title>Scientific Visualization Server</title>
        <style>
            body { font-family: Arial, sans-serif; margin: 20px; }
            .controls { margin: 20px 0; }
            button { margin: 5px; padding: 10px 20px; background: #007cba; color: white; border: none; border-radius: 5px; cursor: pointer; }
            button:hover { background: #005a87; }
            #plot-container { text-align: center; margin: 20px 0; }
            #plot-image { max-width: 100%; height: auto; border: 1px solid #ddd; }
        </style>
    </head>
    <body>
        <h1>🔬 Scientific Visualization Server</h1>
        <p>Real-time scientific visualization on Alpine Linux</p>
        
        <div class="controls">
            <button onclick="requestPlot('line')">Line Plot</button>
            <button onclick="requestPlot('scatter')">Scatter Plot</button>
            <button onclick="requestPlot('surface')">Surface Plot</button>
        </div>
        
        <div id="plot-container">
            <img id="plot-image" alt="Visualization will appear here" />
        </div>
        
        <script>
            const ws = new WebSocket("ws://localhost:8080/websocket");
            
            ws.onmessage = function(event) {
                const data = JSON.parse(event.data);
                if (data.type === 'plot') {
                    document.getElementById('plot-image').src = 'data:image/png;base64,' + data.data;
                }
            };
            
            function requestPlot(type) {
                ws.send(JSON.stringify({type: type}));
            }
            
            // Generate initial plot
            ws.onopen = function() {
                requestPlot('line');
            };
        </script>
    </body>
    </html>
    '''
    
    with open("templates/visualization.html", "w") as f:
        f.write(html_template)
    
    app = make_app()
    app.listen(8080)
    print("🌐 Web visualization server started at http://localhost:8080")
    tornado.ioloop.IOLoop.current().start()

if __name__ == "__main__":
    main()
EOF

chmod +x ~/web-viz-server.py

echo "Remote visualization server configured! 🌐"

What this does: 📖 Sets up comprehensive remote visualization with VNC and web-based access for scientific computing.

Example output:

Remote visualization server configured! 🌐

What this means: Remote scientific visualization is ready for distributed research! ✅

📋 Step 5: Performance Optimization and Benchmarking

Create Visualization Performance Optimizer

Let’s optimize visualization performance! 😊

What we’re doing: Implementing performance monitoring, optimization recommendations, and automated tuning for scientific visualization workloads.

# Create performance optimization toolkit
mkdir -p /opt/viz-optimizer
cd /opt/viz-optimizer

# Create visualization performance monitor
cat > viz-performance-monitor.py << 'EOF'
#!/usr/bin/env python3

# Scientific Visualization Performance Monitor
import psutil
import time
import json
import subprocess
import threading
from datetime import datetime
import numpy as np

class VizPerformanceMonitor:
    def __init__(self):
        self.metrics_history = []
        self.alerts = []
        
    def collect_system_metrics(self):
        """Collect system performance metrics"""
        metrics = {
            'timestamp': datetime.now().isoformat(),
            'cpu': {
                'percent': psutil.cpu_percent(interval=1),
                'count': psutil.cpu_count(),
                'freq': psutil.cpu_freq()._asdict() if psutil.cpu_freq() else None
            },
            'memory': {
                'total': psutil.virtual_memory().total,
                'available': psutil.virtual_memory().available,
                'percent': psutil.virtual_memory().percent,
                'used': psutil.virtual_memory().used
            },
            'disk': {
                'total': psutil.disk_usage('/').total,
                'used': psutil.disk_usage('/').used,
                'free': psutil.disk_usage('/').free,
                'percent': psutil.disk_usage('/').percent
            },
            'network': {}
        }
        
        # Network statistics
        net_io = psutil.net_io_counters()
        if net_io:
            metrics['network'] = {
                'bytes_sent': net_io.bytes_sent,
                'bytes_recv': net_io.bytes_recv,
                'packets_sent': net_io.packets_sent,
                'packets_recv': net_io.packets_recv
            }
        
        return metrics
    
    def collect_gpu_metrics(self):
        """Collect GPU performance metrics"""
        gpu_metrics = {}
        
        try:
            # Try to get NVIDIA GPU stats
            result = subprocess.run([
                'nvidia-smi', '--query-gpu=name,memory.total,memory.used,utilization.gpu',
                '--format=csv,noheader,nounits'
            ], capture_output=True, text=True)
            
            if result.returncode == 0:
                for i, line in enumerate(result.stdout.strip().split('\n')):
                    if line:
                        name, mem_total, mem_used, gpu_util = line.split(', ')
                        gpu_metrics[f'gpu_{i}'] = {
                            'name': name,
                            'memory_total_mb': int(mem_total),
                            'memory_used_mb': int(mem_used),
                            'utilization_percent': int(gpu_util)
                        }
        except FileNotFoundError:
            # nvidia-smi not available
            pass
        
        return gpu_metrics
    
    def collect_visualization_metrics(self):
        """Collect visualization-specific metrics"""
        viz_metrics = {
            'active_processes': [],
            'jupyter_notebooks': 0,
            'paraview_instances': 0,
            'r_processes': 0
        }
        
        # Check for visualization processes
        for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent']):
            try:
                pinfo = proc.info
                name = pinfo['name'].lower()
                
                if 'jupyter' in name:
                    viz_metrics['jupyter_notebooks'] += 1
                elif 'paraview' in name:
                    viz_metrics['paraview_instances'] += 1
                elif 'r' == name or 'rstudio' in name:
                    viz_metrics['r_processes'] += 1
                
                # Track high-resource visualization processes
                if pinfo['cpu_percent'] > 10 or pinfo['memory_percent'] > 5:
                    viz_metrics['active_processes'].append({
                        'pid': pinfo['pid'],
                        'name': pinfo['name'],
                        'cpu_percent': pinfo['cpu_percent'],
                        'memory_percent': pinfo['memory_percent']
                    })
            except (psutil.NoSuchProcess, psutil.AccessDenied):
                continue
        
        return viz_metrics
    
    def analyze_performance(self, metrics):
        """Analyze performance and generate recommendations"""
        recommendations = []
        
        # CPU analysis
        if metrics['cpu']['percent'] > 90:
            recommendations.append({
                'type': 'cpu_high',
                'severity': 'critical',
                'message': f"High CPU usage: {metrics['cpu']['percent']:.1f}%",
                'action': 'Consider reducing visualization complexity or using GPU acceleration'
            })
        
        # Memory analysis
        if metrics['memory']['percent'] > 85:
            recommendations.append({
                'type': 'memory_high',
                'severity': 'warning',
                'message': f"High memory usage: {metrics['memory']['percent']:.1f}%",
                'action': 'Close unused applications or increase system memory'
            })
        
        # Disk space analysis
        if metrics['disk']['percent'] > 90:
            recommendations.append({
                'type': 'disk_full',
                'severity': 'critical',
                'message': f"Low disk space: {metrics['disk']['percent']:.1f}% used",
                'action': 'Clean up temporary files and old visualization outputs'
            })
        
        return recommendations
    
    def optimize_system(self):
        """Apply system optimizations for visualization"""
        optimizations = []
        
        # Set CPU governor to performance
        try:
            subprocess.run(['cpupower', 'frequency-set', '-g', 'performance'], 
                          capture_output=True)
            optimizations.append("Set CPU governor to performance mode")
        except FileNotFoundError:
            pass
        
        # Increase shared memory for large datasets
        try:
            with open('/proc/sys/kernel/shmmax', 'w') as f:
                f.write(str(1024 * 1024 * 1024))  # 1GB
            optimizations.append("Increased shared memory limit")
        except PermissionError:
            pass
        
        # Optimize swap usage
        try:
            with open('/proc/sys/vm/swappiness', 'w') as f:
                f.write('10')  # Reduce swap usage
            optimizations.append("Reduced swap usage for better performance")
        except PermissionError:
            pass
        
        return optimizations
    
    def generate_report(self):
        """Generate comprehensive performance report"""
        system_metrics = self.collect_system_metrics()
        gpu_metrics = self.collect_gpu_metrics()
        viz_metrics = self.collect_visualization_metrics()
        recommendations = self.analyze_performance(system_metrics)
        
        report = {
            'timestamp': system_metrics['timestamp'],
            'system': system_metrics,
            'gpu': gpu_metrics,
            'visualization': viz_metrics,
            'recommendations': recommendations,
            'summary': {
                'cpu_usage': system_metrics['cpu']['percent'],
                'memory_usage': system_metrics['memory']['percent'],
                'active_viz_processes': len(viz_metrics['active_processes']),
                'total_recommendations': len(recommendations)
            }
        }
        
        # Store metrics history
        self.metrics_history.append(report)
        
        # Keep only last 100 reports
        if len(self.metrics_history) > 100:
            self.metrics_history = self.metrics_history[-100:]
        
        return report
    
    def save_report(self, report, filename=None):
        """Save performance report to file"""
        if not filename:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = f"/var/log/viz_performance_{timestamp}.json"
        
        with open(filename, 'w') as f:
            json.dump(report, f, indent=2)
        
        return filename

def performance_monitoring_loop():
    """Main performance monitoring loop"""
    monitor = VizPerformanceMonitor()
    
    print("🔍 Starting visualization performance monitoring...")
    
    while True:
        try:
            # Generate performance report
            report = monitor.generate_report()
            
            # Print summary
            summary = report['summary']
            print(f"[{datetime.now().strftime('%H:%M:%S')}] "
                  f"CPU: {summary['cpu_usage']:.1f}% | "
                  f"Memory: {summary['memory_usage']:.1f}% | "
                  f"Viz Processes: {summary['active_viz_processes']} | "
                  f"Alerts: {summary['total_recommendations']}")
            
            # Print recommendations
            for rec in report['recommendations']:
                print(f"  ⚠️  {rec['severity'].upper()}: {rec['message']}")
            
            # Save detailed report every 10 minutes
            if int(time.time()) % 600 == 0:
                filename = monitor.save_report(report)
                print(f"📊 Detailed report saved: {filename}")
            
            time.sleep(30)  # Monitor every 30 seconds
            
        except Exception as e:
            print(f"Error in monitoring loop: {e}")
            time.sleep(60)

def main():
    print("🚀 Scientific Visualization Performance Monitor")
    print("=" * 50)
    
    monitor = VizPerformanceMonitor()
    
    # Apply initial optimizations
    optimizations = monitor.optimize_system()
    if optimizations:
        print("Applied optimizations:")
        for opt in optimizations:
            print(f"  ✅ {opt}")
    
    # Start monitoring
    performance_monitoring_loop()

if __name__ == '__main__':
    main()
EOF

# Create visualization benchmark suite
cat > viz-benchmark-suite.py << 'EOF'
#!/usr/bin/env python3

# Scientific Visualization Benchmark Suite
import time
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import json
from datetime import datetime

class VizBenchmarkSuite:
    def __init__(self):
        self.results = {}
        
    def benchmark_matplotlib_rendering(self):
        """Benchmark matplotlib rendering performance"""
        print("Benchmarking matplotlib rendering...")
        
        results = {}
        
        # Test different plot complexities
        sizes = [100, 500, 1000, 5000]
        
        for size in sizes:
            # Generate test data
            x = np.random.randn(size)
            y = np.random.randn(size)
            
            # Benchmark scatter plot
            start_time = time.time()
            plt.figure(figsize=(10, 6))
            plt.scatter(x, y, alpha=0.6)
            plt.title(f'Scatter Plot ({size} points)')
            plt.savefig(f'/tmp/scatter_{size}.png', dpi=150)
            plt.close()
            scatter_time = time.time() - start_time
            
            # Benchmark line plot
            start_time = time.time()
            plt.figure(figsize=(10, 6))
            plt.plot(x, alpha=0.7)
            plt.title(f'Line Plot ({size} points)')
            plt.savefig(f'/tmp/line_{size}.png', dpi=150)
            plt.close()
            line_time = time.time() - start_time
            
            results[f'size_{size}'] = {
                'scatter_time': scatter_time,
                'line_time': line_time,
                'points': size
            }
            
            print(f"  Size {size}: Scatter {scatter_time:.3f}s, Line {line_time:.3f}s")
        
        return results
    
    def benchmark_data_processing(self):
        """Benchmark data processing performance"""
        print("Benchmarking data processing...")
        
        results = {}
        
        # Test different data sizes
        sizes = [1000, 10000, 100000, 1000000]
        
        for size in sizes:
            # Generate test dataset
            data = pd.DataFrame({
                'x': np.random.randn(size),
                'y': np.random.randn(size),
                'category': np.random.choice(['A', 'B', 'C'], size)
            })
            
            # Benchmark operations
            start_time = time.time()
            grouped = data.groupby('category').agg({
                'x': ['mean', 'std'],
                'y': ['mean', 'std']
            })
            groupby_time = time.time() - start_time
            
            start_time = time.time()
            correlation = data[['x', 'y']].corr()
            corr_time = time.time() - start_time
            
            start_time = time.time()
            sorted_data = data.sort_values('x')
            sort_time = time.time() - start_time
            
            results[f'size_{size}'] = {
                'groupby_time': groupby_time,
                'correlation_time': corr_time,
                'sort_time': sort_time,
                'rows': size
            }
            
            print(f"  Size {size}: Group {groupby_time:.3f}s, Corr {corr_time:.3f}s, Sort {sort_time:.3f}s")
        
        return results
    
    def benchmark_3d_visualization(self):
        """Benchmark 3D visualization performance"""
        print("Benchmarking 3D visualization...")
        
        results = {}
        
        # Test different surface resolutions
        resolutions = [25, 50, 100, 200]
        
        for res in resolutions:
            # Generate 3D surface data
            x = np.linspace(-3, 3, res)
            y = np.linspace(-3, 3, res)
            X, Y = np.meshgrid(x, y)
            Z = np.sin(np.sqrt(X**2 + Y**2)) * np.exp(-0.1 * (X**2 + Y**2))
            
            # Benchmark contour plot
            start_time = time.time()
            plt.figure(figsize=(10, 8))
            contour = plt.contourf(X, Y, Z, levels=20, cmap='viridis')
            plt.colorbar(contour)
            plt.savefig(f'/tmp/contour_{res}.png', dpi=150)
            plt.close()
            contour_time = time.time() - start_time
            
            # Benchmark surface plot (using contour as approximation)
            start_time = time.time()
            plt.figure(figsize=(10, 8))
            surface = plt.imshow(Z, extent=[-3, 3, -3, 3], cmap='viridis')
            plt.colorbar(surface)
            plt.savefig(f'/tmp/surface_{res}.png', dpi=150)
            plt.close()
            surface_time = time.time() - start_time
            
            results[f'resolution_{res}'] = {
                'contour_time': contour_time,
                'surface_time': surface_time,
                'points': res * res
            }
            
            print(f"  Resolution {res}x{res}: Contour {contour_time:.3f}s, Surface {surface_time:.3f}s")
        
        return results
    
    def run_full_benchmark(self):
        """Run complete benchmark suite"""
        print("🏁 Running Scientific Visualization Benchmark Suite")
        print("=" * 60)
        
        start_time = time.time()
        
        # Run benchmarks
        self.results['matplotlib'] = self.benchmark_matplotlib_rendering()
        self.results['data_processing'] = self.benchmark_data_processing()
        self.results['3d_visualization'] = self.benchmark_3d_visualization()
        
        total_time = time.time() - start_time
        
        # Generate summary
        summary = {
            'timestamp': datetime.now().isoformat(),
            'total_time': total_time,
            'benchmarks_completed': len(self.results),
            'system_info': {
                'cpu_count': __import__('psutil').cpu_count(),
                'memory_gb': __import__('psutil').virtual_memory().total / (1024**3)
            }
        }
        
        # Save results
        benchmark_data = {
            'summary': summary,
            'results': self.results
        }
        
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"/var/log/viz_benchmark_{timestamp}.json"
        
        with open(filename, 'w') as f:
            json.dump(benchmark_data, f, indent=2)
        
        print(f"\n📊 Benchmark completed in {total_time:.1f} seconds")
        print(f"📁 Results saved to: {filename}")
        
        return benchmark_data

def main():
    benchmark_suite = VizBenchmarkSuite()
    results = benchmark_suite.run_full_benchmark()
    
    # Print performance recommendations
    print("\n🎯 Performance Recommendations:")
    
    matplotlib_results = results['results']['matplotlib']
    largest_size = max([int(k.split('_')[1]) for k in matplotlib_results.keys()])
    largest_result = matplotlib_results[f'size_{largest_size}']
    
    if largest_result['scatter_time'] > 5.0:
        print("  ⚠️  Consider using GPU acceleration for large scatter plots")
    
    if largest_result['line_time'] > 2.0:
        print("  ⚠️  Consider data decimation for large line plots")
    
    data_results = results['results']['data_processing']
    largest_data = max([int(k.split('_')[1]) for k in data_results.keys()])
    largest_data_result = data_results[f'size_{largest_data}']
    
    if largest_data_result['groupby_time'] > 1.0:
        print("  ⚠️  Consider using Dask for large dataset operations")
    
    print("\n✅ Benchmark suite completed successfully!")

if __name__ == '__main__':
    main()
EOF

chmod +x *.py

# Create startup script for monitoring services
cat > start-viz-monitoring.sh << 'EOF'
#!/bin/bash

# Start Scientific Visualization Monitoring Services
echo "🚀 Starting visualization monitoring services..."

# Create log directory
mkdir -p /var/log

# Start performance monitor
nohup python3 /opt/viz-optimizer/viz-performance-monitor.py > /var/log/viz-monitor.log 2>&1 &
MONITOR_PID=$!

# Start web visualization server
nohup python3 ~/web-viz-server.py > /var/log/web-viz.log 2>&1 &
WEB_PID=$!

# Save PIDs
echo $MONITOR_PID > /var/run/viz-monitor.pid
echo $WEB_PID > /var/run/web-viz.pid

echo "✅ Monitoring services started:"
echo "  Performance Monitor (PID: $MONITOR_PID)"
echo "  Web Visualization Server (PID: $WEB_PID)"
echo "  Log files in /var/log/"
EOF

chmod +x start-viz-monitoring.sh

echo "Visualization performance optimization configured! ⚡"

What this does: 📖 Creates comprehensive performance monitoring and optimization tools for scientific visualization workloads.

Example output:

Visualization performance optimization configured! ⚡

What this means: Complete performance optimization suite is ready for scientific computing! ✅

🎉 You’re All Set!

Congratulations! You’ve successfully set up a comprehensive scientific visualization environment on Alpine Linux! 🚀

What You’ve Accomplished:

✅ Graphics Foundation - OpenGL acceleration and GPU drivers
✅ Python Scientific Stack - NumPy, SciPy, matplotlib, VTK, and ParaView
✅ Specialized Software - ParaView and VisIt for large-scale visualization
✅ Interactive Environment - JupyterLab with scientific extensions
✅ Statistical Computing - R with comprehensive visualization packages
✅ Remote Access - VNC and web-based visualization servers
✅ Performance Optimization - Monitoring and automated tuning

Software Stack Overview:

┌─────────────────────────────────────────────────────────┐
│            Scientific Applications Layer               │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │
│  │  ParaView   │  │   VisIt     │  │ JupyterLab  │     │
│  │     +       │  │     +       │  │     +       │     │
│  │    VTK      │  │  Parallel   │  │  Widgets    │     │
│  └─────────────┘  └─────────────┘  └─────────────┘     │
└─────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────┐
│          Scientific Computing Libraries                │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │
│  │   Python    │  │      R      │  │   OpenGL    │     │
│  │ NumPy+SciPy │  │  ggplot2+   │  │    Mesa     │     │
│  │ matplotlib  │  │  Plotly     │  │   Vulkan    │     │
│  └─────────────┘  └─────────────┘  └─────────────┘     │
└─────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────┐
│              Alpine Linux Foundation                   │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │
│  │   Kernel    │  │   Graphics  │  │Performance  │     │
│  │  Modules    │  │   Drivers   │  │ Monitoring  │     │
│  └─────────────┘  └─────────────┘  └─────────────┘     │
└─────────────────────────────────────────────────────────┘

Quick Reference Commands:

# Start JupyterLab
jupyter-lab --ip=0.0.0.0 --port=8888 --allow-root

# Launch ParaView
paraview

# Start VNC server
vnc-server start

# Run benchmarks
cd /opt/viz-optimizer && python3 viz-benchmark-suite.py

# Monitor performance
cd /opt/viz-optimizer && python3 viz-performance-monitor.py

# Start web visualization
python3 ~/web-viz-server.py

Next Steps:

• 🔬 Domain-Specific Tools - Install specialized software for your research field
• 📊 Custom Visualizations - Develop application-specific visualization workflows
• 🌐 Cluster Integration - Connect to HPC clusters and distributed computing
• 🔧 Automation - Create automated analysis and visualization pipelines
• 📚 Documentation - Document your workflows and share with research community

Your Alpine Linux system is now a powerful scientific visualization workstation ready for cutting-edge research! 😊🔬