@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/analysis/dataviz/chart-image-generator/SKILL.md

@@ -0,0 +1,229 @@
+---
+name: chart-image-generator
+description: "Generate publication-quality chart images from research data"
+metadata:
+  openclaw:
+    emoji: "📉"
+    category: "analysis"
+    subcategory: "dataviz"
+    keywords: ["chart generation", "data visualization", "matplotlib", "publication figures", "scientific plots", "graph export"]
+    source: "https://github.com/AcademicSkills/chart-image-generator"
+---
+
+# Chart Image Generator
+
+A skill for generating publication-quality chart images from research data using Python visualization libraries. Covers chart type selection, styling for academic journals, multi-panel layouts, color accessibility, and export at the correct resolution and format for submission.
+
+## Overview
+
+Creating figures for academic publications requires more than just plotting data. Journals have specific requirements for resolution (typically 300-600 DPI), file format (TIFF, EPS, PDF, or high-resolution PNG), font sizes (often 8-12pt in the final printed figure), line weights, and color accessibility. This skill automates the production of figures that meet these standards, reducing the time researchers spend on manual formatting and ensuring consistency across all figures in a manuscript.
+
+The skill supports common chart types used in academic research: scatter plots, bar charts, line plots, box plots, violin plots, heatmaps, forest plots, Kaplan-Meier curves, and multi-panel composite figures. All examples use matplotlib and seaborn with a custom academic styling configuration.
+
+## Academic Figure Styling
+
+### Journal-Ready Style Configuration
+
+```python
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+
+def set_academic_style():
+    """
+    Configure matplotlib for publication-quality figures.
+    Matches common requirements for Nature, Science, PLOS, IEEE journals.
+    """
+    plt.rcParams.update({
+        # Font settings
+        'font.family': 'sans-serif',
+        'font.sans-serif': ['Arial', 'Helvetica', 'DejaVu Sans'],
+        'font.size': 8,
+        'axes.titlesize': 9,
+        'axes.labelsize': 8,
+        'xtick.labelsize': 7,
+        'ytick.labelsize': 7,
+        'legend.fontsize': 7,
+
+        # Line and marker settings
+        'lines.linewidth': 1.0,
+        'lines.markersize': 4,
+        'axes.linewidth': 0.5,
+        'xtick.major.width': 0.5,
+        'ytick.major.width': 0.5,
+
+        # Grid and background
+        'axes.grid': False,
+        'axes.facecolor': 'white',
+        'figure.facecolor': 'white',
+
+        # Legend
+        'legend.frameon': False,
+        'legend.borderpad': 0.3,
+
+        # Save settings
+        'savefig.dpi': 300,
+        'savefig.bbox': 'tight',
+        'savefig.pad_inches': 0.05,
+
+        # Use Type 1 fonts for EPS/PDF (required by many journals)
+        'pdf.fonttype': 42,
+        'ps.fonttype': 42,
+    })
+
+# Common journal figure widths (in inches):
+SINGLE_COLUMN = 3.5   # ~89mm (Nature, Science, PLOS)
+DOUBLE_COLUMN = 7.0   # ~178mm
+ONE_AND_HALF = 5.5    # ~140mm
+```
+
+### Accessible Color Palettes
+
+```python
+# Colorblind-safe palettes for academic figures
+PALETTES = {
+    'categorical_8': [
+        '#332288', '#88CCEE', '#44AA99', '#117733',
+        '#999933', '#DDCC77', '#CC6677', '#882255'
+    ],  # Tol's qualitative palette
+
+    'sequential': 'viridis',  # Perceptually uniform
+
+    'diverging': 'RdBu_r',   # Red-Blue diverging
+
+    'binary': ['#0072B2', '#D55E00'],  # Blue and vermilion
+}
+```
+
+## Chart Type Selection Guide
+
+| Data Pattern | Recommended Chart | When to Use |
+|-------------|------------------|-------------|
+| Distribution of one variable | Histogram, KDE, violin | Showing data spread |
+| Comparing groups | Box plot, violin, bar + error bars | Group differences |
+| Two continuous variables | Scatter plot | Correlation, regression |
+| Trends over time | Line plot | Time series, longitudinal |
+| Proportions | Stacked bar, pie (sparingly) | Composition |
+| Correlation matrix | Heatmap | Many variable pairs |
+| Effect sizes + CIs | Forest plot | Meta-analysis, multi-model |
+| Survival data | Kaplan-Meier curve | Time-to-event |
+
+## Generating Common Academic Charts
+
+### Scatter Plot with Regression Line
+
+```python
+import numpy as np
+import seaborn as sns
+
+def scatter_with_regression(x, y, xlabel, ylabel, title, output_path,
+                            groups=None, group_label=None):
+    """
+    Create a scatter plot with regression line and confidence interval.
+    """
+    set_academic_style()
+    fig, ax = plt.subplots(figsize=(SINGLE_COLUMN, SINGLE_COLUMN * 0.8))
+
+    if groups is not None:
+        for group_val in sorted(set(groups)):
+            mask = groups == group_val
+            ax.scatter(x[mask], y[mask], s=15, alpha=0.7, label=group_val)
+        ax.legend(title=group_label)
+    else:
+        ax.scatter(x, y, s=15, alpha=0.7, color=PALETTES['binary'][0])
+
+    # Add regression line
+    from scipy import stats
+    slope, intercept, r, p, se = stats.linregress(x, y)
+    x_line = np.linspace(x.min(), x.max(), 100)
+    ax.plot(x_line, slope * x_line + intercept, color='#CC6677',
+            linewidth=1.0, linestyle='--')
+
+    # Annotate with statistics
+    ax.text(0.05, 0.95, f'r = {r:.3f}\np = {p:.3f}',
+            transform=ax.transAxes, verticalalignment='top', fontsize=7)
+
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(ylabel)
+    ax.set_title(title)
+
+    fig.savefig(output_path, dpi=300, bbox_inches='tight')
+    plt.close(fig)
+    return output_path
+```
+
+### Multi-Panel Composite Figure
+
+```python
+def create_multipanel_figure(panels: list, ncols: int = 2,
+                              output_path: str = 'figure.pdf'):
+    """
+    Create a multi-panel figure with automatic panel labels (A, B, C, ...).
+
+    Args:
+        panels: List of dicts with 'plot_func', 'args', 'title'
+        ncols: Number of columns
+        output_path: Output file path
+    """
+    set_academic_style()
+    nrows = int(np.ceil(len(panels) / ncols))
+    fig, axes = plt.subplots(nrows, ncols,
+                              figsize=(DOUBLE_COLUMN, 3.0 * nrows))
+    axes = axes.flatten() if hasattr(axes, 'flatten') else [axes]
+
+    for i, (ax, panel) in enumerate(zip(axes, panels)):
+        panel['plot_func'](ax, **panel.get('args', {}))
+        # Add panel label (A, B, C, ...)
+        ax.text(-0.15, 1.08, chr(65 + i), transform=ax.transAxes,
+                fontsize=11, fontweight='bold', va='top')
+        if 'title' in panel:
+            ax.set_title(panel['title'])
+
+    # Hide unused panels
+    for ax in axes[len(panels):]:
+        ax.set_visible(False)
+
+    fig.tight_layout()
+    fig.savefig(output_path, dpi=300, bbox_inches='tight')
+    plt.close(fig)
+    return output_path
+```
+
+## Export Specifications by Journal
+
+| Journal / Publisher | Format | DPI | Max Width | Color Mode |
+|--------------------|--------|-----|-----------|------------|
+| Nature | TIFF, EPS, PDF | 300 | 180mm | RGB |
+| Science | EPS, PDF | 300 | 174mm | RGB |
+| PLOS | TIFF, EPS | 300 | 174mm | RGB |
+| IEEE | EPS, PDF, PNG | 300 | 3.5in (1-col) | RGB or CMYK |
+| Elsevier | TIFF, EPS, PDF | 300-600 | 190mm | RGB or CMYK |
+| Springer | TIFF, EPS, PDF | 300 | 174mm | RGB or CMYK |
+
+### Export Function
+
+```python
+def export_figure(fig, basename: str, formats=('pdf', 'png', 'tiff'), dpi=300):
+    """Export a figure in multiple formats for journal submission."""
+    paths = []
+    for fmt in formats:
+        path = f"{basename}.{fmt}"
+        fig.savefig(path, format=fmt, dpi=dpi, bbox_inches='tight',
+                    facecolor='white', edgecolor='none')
+        paths.append(path)
+    return paths
+```
+
+## Best Practices
+
+- Always use vector formats (PDF, EPS) for line art and plots; raster (TIFF, PNG) only when required.
+- Set figure dimensions to the exact column width of your target journal.
+- Use the same font and size across all figures in a manuscript for consistency.
+- Test figures in grayscale to ensure they remain readable without color.
+- Include all figure generation code in your supplementary materials for reproducibility.
+- Label axes with units (e.g., "Temperature (K)") and avoid abbreviations unless defined.
+
+## References
+
+- Rougier, N. P., Droettboom, M., & Borne, P. E. (2014). Ten Simple Rules for Better Figures. *PLoS Computational Biology*, 10(9).
+- Tufte, E. R. (2001). *The Visual Display of Quantitative Information* (2nd ed.). Graphics Press.
+- Wong, B. (2011). Color Blindness. *Nature Methods*, 8(6), 441.

package/skills/analysis/dataviz/citation-map-guide/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: citation-map-guide
+description: "Generate citation world maps from Google Scholar profiles"
+metadata:
+  openclaw:
+    emoji: "🗺️"
+    category: "analysis"
+    subcategory: "dataviz"
+    keywords: ["citation map", "Google Scholar", "geospatial", "academic impact", "visualization", "world map"]
+    source: "https://github.com/ChenLiu-1996/CitationMap"
+---
+
+# Citation Map Guide
+
+## Overview
+
+CitationMap generates geographical world maps showing where your citations come from, based on Google Scholar data. It geocodes citing authors' affiliations and plots them on an interactive map, revealing the global reach and geographical distribution of your research impact. Useful for CV enhancement, grant applications, and understanding your research's international footprint.
+
+## Installation
+
+```bash
+pip install citationmap
+
+# Or from source
+git clone https://github.com/ChenLiu-1996/CitationMap.git
+cd CitationMap
+pip install -e .
+```
+
+## Usage
+
+```python
+from citationmap import CitationMap
+
+# Generate map from Google Scholar ID
+cmap = CitationMap(scholar_id="YOUR_SCHOLAR_ID")
+
+# Fetch citation data
+cmap.fetch_citations()
+
+print(f"Total citations: {cmap.total_citations}")
+print(f"Unique citing authors: {cmap.unique_authors}")
+print(f"Countries represented: {cmap.unique_countries}")
+
+# Generate interactive map
+cmap.plot_map(
+    output="citation_map.html",
+    style="heatmap",       # heatmap, markers, clusters
+    color_by="count",      # count, year, paper
+)
+```
+
+## Map Styles
+
+```python
+# Marker map — individual pins per institution
+cmap.plot_map(
+    output="markers.html",
+    style="markers",
+    show_labels=True,
+    popup_info=["author", "paper", "year"],
+)
+
+# Heatmap — density visualization
+cmap.plot_map(
+    output="heatmap.html",
+    style="heatmap",
+    radius=30,
+    blur=20,
+)
+
+# Cluster map — grouped by proximity
+cmap.plot_map(
+    output="clusters.html",
+    style="clusters",
+    max_cluster_radius=50,
+)
+
+# Static image (for publications/CVs)
+cmap.plot_static(
+    output="citation_map.png",
+    dpi=300,
+    projection="robinson",
+    figsize=(14, 8),
+)
+```
+
+## Analysis Features
+
+```python
+# Geographic distribution stats
+stats = cmap.get_stats()
+
+print("\nTop countries:")
+for country, count in stats.top_countries[:10]:
+    print(f"  {country}: {count} citations")
+
+print("\nTop institutions:")
+for inst, count in stats.top_institutions[:10]:
+    print(f"  {inst}: {count} citations")
+
+print("\nContinental distribution:")
+for continent, pct in stats.continental_distribution.items():
+    print(f"  {continent}: {pct:.1f}%")
+```
+
+## Time Evolution
+
+```python
+# Animate citation spread over time
+cmap.plot_animated(
+    output="citation_evolution.html",
+    time_field="year",
+    interval=1000,  # ms per year
+    cumulative=True,
+)
+
+# Year-by-year breakdown
+for year in range(2020, 2026):
+    year_stats = cmap.filter_by_year(year)
+    print(f"{year}: {year_stats.count} citations, "
+          f"{year_stats.countries} countries")
+```
+
+## Paper-Specific Maps
+
+```python
+# Map for a specific paper
+cmap.plot_map(
+    paper_title="Your Specific Paper Title",
+    output="paper_citations.html",
+    style="markers",
+)
+
+# Compare papers
+papers = cmap.get_papers()
+for paper in papers[:5]:
+    print(f"\n{paper.title} ({paper.year})")
+    print(f"  Citations: {paper.citation_count}")
+    print(f"  Countries: {paper.country_count}")
+```
+
+## Export
+
+```python
+# Export citation data
+cmap.export_csv("citations.csv")
+# Columns: citing_author, affiliation, country, lat, lon,
+#           citing_paper, cited_paper, year
+
+# Export for GIS software
+cmap.export_geojson("citations.geojson")
+
+# Export summary statistics
+cmap.export_report("citation_report.md")
+```
+
+## Configuration
+
+```python
+cmap = CitationMap(
+    scholar_id="YOUR_ID",
+    config={
+        "geocoding_service": "nominatim",  # or "google"
+        "cache_dir": ".citationmap_cache",
+        "rate_limit": 1.0,  # seconds between API calls
+        "affiliation_parsing": "heuristic",  # or "llm"
+    },
+)
+```
+
+## Use Cases
+
+1. **CV enhancement**: Show global research impact visually
+2. **Grant applications**: Demonstrate international reach
+3. **Department reports**: Aggregate maps for research groups
+4. **Collaboration discovery**: Find active citing institutions
+5. **Impact assessment**: Geographic diversity of citations
+
+## References
+
+- [CitationMap GitHub](https://github.com/ChenLiu-1996/CitationMap)
+- [Google Scholar](https://scholar.google.com/)
+- [Folium](https://python-visualization.github.io/folium/) — Map rendering

package/skills/analysis/dataviz/d3-visualization-guide/SKILL.md

@@ -0,0 +1,281 @@
+---
+name: d3-visualization-guide
+description: "Guide to D3.js for building custom interactive data visualizations"
+metadata:
+  openclaw:
+    emoji: "📊"
+    category: "analysis"
+    subcategory: "dataviz"
+    keywords: ["data visualization", "D3.js", "interactive charts", "SVG", "web visualization", "scientific plots"]
+    source: "https://github.com/d3/d3"
+---
+
+# D3.js Visualization Guide
+
+## Overview
+
+D3.js (Data-Driven Documents) is the most powerful and flexible JavaScript library for producing dynamic, interactive data visualizations in web browsers. With over 112K stars on GitHub, D3 has become the de facto standard for custom data visualization on the web. It uses HTML, SVG, and CSS to bring data to life, giving researchers full control over the final visual output.
+
+Unlike higher-level charting libraries, D3 operates at the level of individual SVG elements and data bindings, which means researchers can create entirely bespoke visualizations tailored to their specific datasets and publication requirements. This makes it particularly valuable for academic work where standard chart types may not adequately represent complex research findings.
+
+D3 provides a comprehensive ecosystem of modules covering everything from scales and axes to geographic projections, force-directed layouts, and hierarchical data structures. The library follows a functional, composable design that allows researchers to combine modules as needed for their specific visualization tasks.
+
+## Core Concepts for Research Visualizations
+
+D3 revolves around the concept of binding data to DOM elements and applying data-driven transformations. The key patterns every researcher should understand are selections, data joins, scales, and axes.
+
+### Data Binding and Selections
+
+```javascript
+// Load research data from CSV
+const data = await d3.csv("experiment_results.csv", d => ({
+  condition: d.condition,
+  measurement: +d.measurement,
+  error: +d.standard_error
+}));
+
+// Create an SVG container
+const svg = d3.select("#chart")
+  .append("svg")
+  .attr("width", 800)
+  .attr("height", 500);
+
+// Binddata to elements using the enter-update-exit pattern
+svg.selectAll("circle")
+  .data(data)
+  .join("circle")
+  .attr("cx", d => xScale(d.condition))
+  .attr("cy", d => yScale(d.measurement))
+  .attr("r", 5)
+  .attr("fill", "#3B82F6");
+```
+
+### Scales and Axes
+
+```javascript
+// Linear scale for continuous measurements
+const yScale = d3.scaleLinear()
+  .domain([0, d3.max(data, d => d.measurement)])
+  .range([height - margin.bottom, margin.top]);
+
+// Band scale for categorical conditions
+const xScale = d3.scaleBand()
+  .domain(data.map(d => d.condition))
+  .range([margin.left, width - margin.right])
+  .padding(0.3);
+
+// Add axes with proper formatting
+svg.append("g")
+  .attr("transform", `translate(0,${height - margin.bottom})`)
+  .call(d3.axisBottom(xScale));
+
+svg.append("g")
+  .attr("transform", `translate(${margin.left},0)`)
+  .call(d3.axisLeft(yScale).tickFormat(d3.format(".2f")));
+```
+
+## Publication-Quality Scientific Charts
+
+### Error Bar Plot for Experimental Results
+
+```javascript
+function createErrorBarPlot(data, container) {
+  const margin = { top: 40, right: 30, bottom: 60, left: 70 };
+  const width = 700 - margin.left - margin.right;
+  const height = 450 - margin.top - margin.bottom;
+
+  const svg = d3.select(container)
+    .append("svg")
+    .attr("width", width + margin.left + margin.right)
+    .attr("height", height + margin.top + margin.bottom)
+    .append("g")
+    .attr("transform", `translate(${margin.left},${margin.top})`);
+
+  const x = d3.scaleBand()
+    .domain(data.map(d => d.group))
+    .range([0, width])
+    .padding(0.4);
+
+  const y = d3.scaleLinear()
+    .domain([0, d3.max(data, d => d.mean + d.sem) * 1.15])
+    .range([height, 0]);
+
+  // Draw bars
+  svg.selectAll(".bar")
+    .data(data)
+    .join("rect")
+    .attr("class", "bar")
+    .attr("x", d => x(d.group))
+    .attr("y", d => y(d.mean))
+    .attr("width", x.bandwidth())
+    .attr("height", d => height - y(d.mean))
+    .attr("fill", (d, i) => d3.schemeTableau10[i]);
+
+  // Draw error bars
+  svg.selectAll(".error-line")
+    .data(data)
+    .join("line")
+    .attr("x1", d => x(d.group) + x.bandwidth() / 2)
+    .attr("x2", d => x(d.group) + x.bandwidth() / 2)
+    .attr("y1", d => y(d.mean - d.sem))
+    .attr("y2", d => y(d.mean + d.sem))
+    .attr("stroke", "#333")
+    .attr("stroke-width", 1.5);
+
+  // Error bar caps
+  const capWidth = 10;
+  ["top", "bottom"].forEach(pos => {
+    svg.selectAll(`.cap-${pos}`)
+      .data(data)
+      .join("line")
+      .attr("x1", d => x(d.group) + x.bandwidth() / 2 - capWidth)
+      .attr("x2", d => x(d.group) + x.bandwidth() / 2 + capWidth)
+      .attr("y1", d => y(d.mean + (pos === "top" ? d.sem : -d.sem)))
+      .attr("y2", d => y(d.mean + (pos === "top" ? d.sem : -d.sem)))
+      .attr("stroke", "#333")
+      .attr("stroke-width", 1.5);
+  });
+
+  // Axes
+  svg.append("g")
+    .attr("transform", `translate(0,${height})`)
+    .call(d3.axisBottom(x))
+    .selectAll("text")
+    .style("font-size", "12px");
+
+  svg.append("g")
+    .call(d3.axisLeft(y))
+    .selectAll("text")
+    .style("font-size", "12px");
+}
+```
+
+### Heatmap for Correlation Matrices
+
+```javascript
+function createCorrelationHeatmap(matrix, labels, container) {
+  const size = 500;
+  const cellSize = size / labels.length;
+
+  const colorScale = d3.scaleSequential(d3.interpolateRdBu)
+    .domain([1, -1]);
+
+  const svg = d3.select(container)
+    .append("svg")
+    .attr("width", size + 120)
+    .attr("height", size + 120);
+
+  const g = svg.append("g")
+    .attr("transform", "translate(100, 20)");
+
+  // Draw cells
+  labels.forEach((rowLabel, i) => {
+    labels.forEach((colLabel, j) => {
+      g.append("rect")
+        .attr("x", j * cellSize)
+        .attr("y", i * cellSize)
+        .attr("width", cellSize - 1)
+        .attr("height", cellSize - 1)
+        .attr("fill", colorScale(matrix[i][j]))
+        .append("title")
+        .text(`${rowLabel} vs ${colLabel}: ${matrix[i][j].toFixed(3)}`);
+
+      g.append("text")
+        .attr("x", j * cellSize + cellSize / 2)
+        .attr("y", i * cellSize + cellSize / 2)
+        .attr("text-anchor", "middle")
+        .attr("dominant-baseline", "central")
+        .style("font-size", "10px")
+        .text(matrix[i][j].toFixed(2));
+    });
+  });
+
+  // Row and column labels
+  g.selectAll(".row-label")
+    .data(labels)
+    .join("text")
+    .attr("x", -8)
+    .attr("y", (d, i) => i * cellSize + cellSize / 2)
+    .attr("text-anchor", "end")
+    .attr("dominant-baseline", "central")
+    .style("font-size", "11px")
+    .text(d => d);
+}
+```
+
+## Interactive Techniques for Research Presentations
+
+D3 excels at adding interactivity to visualizations, which is valuable for research presentations, supplementary materials, and data exploration during analysis.
+
+### Tooltips and Hover Effects
+
+```javascript
+// Create a tooltip div
+const tooltip = d3.select("body").append("div")
+  .attr("class", "tooltip")
+  .style("position", "absolute")
+  .style("background", "rgba(0,0,0,0.8)")
+  .style("color", "#fff")
+  .style("padding", "8px 12px")
+  .style("border-radius", "4px")
+  .style("font-size", "12px")
+  .style("pointer-events", "none")
+  .style("opacity", 0);
+
+// Attach to data points
+svg.selectAll("circle")
+  .on("mouseover", (event, d) => {
+    tooltip.transition().duration(200).style("opacity", 1);
+    tooltip.html(
+      `<strong>${d.sample_id}</strong><br/>` +
+      `Value: ${d.measurement.toFixed(3)}<br/>` +
+      `p-value: ${d.pvalue.toExponential(2)}`
+    )
+    .style("left", (event.pageX + 12) + "px")
+    .style("top", (event.pageY - 28) + "px");
+  })
+  .on("mouseout", () => {
+    tooltip.transition().duration(300).style("opacity", 0);
+  });
+```
+
+### Zoom and Pan for Large Datasets
+
+```javascript
+const zoom = d3.zoom()
+  .scaleExtent([1, 20])
+  .on("zoom", (event) => {
+    chartGroup.attr("transform", event.transform);
+  });
+
+svg.call(zoom);
+```
+
+## Exporting for Publications
+
+When preparing figures for journal submissions, D3 SVG output can be exported directly to vector formats.
+
+```javascript
+// Extract SVG markup for saving
+function exportSVG(svgElement) {
+  const serializer = new XMLSerializer();
+  const svgString = serializer.serializeToString(svgElement);
+  const blob = new Blob([svgString], { type: "image/svg+xml" });
+  const url = URL.createObjectURL(blob);
+
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = "figure.svg";
+  link.click();
+  URL.revokeObjectURL(url);
+}
+```
+
+Researchers can then convert SVG to PDF or EPS using tools like Inkscape or cairosvg for submission to journals that require specific formats.
+
+## References
+
+- D3.js official documentation: https://d3js.org
+- D3 GitHub repository: https://github.com/d3/d3
+- Observable D3 tutorials: https://observablehq.com/@d3
+- D3 Graph Gallery (examples): https://d3-graph-gallery.com