Elysia Tools

Explora herramientas, ejemplos, explicaciones visuales y guías temáticas en un solo espacio claro.

Categorías populares

Temas

Idioma
ZHDERUPTENFRES

Elysia Tools

Navegación

Visualización de datos

Ejemplos Plotly Interactive Charts

Ejemplos completos de Plotly.js incluyendo gráficos 3D, visualizaciones estadísticas y visualizaciones interactivas web

Ejemplos

Entradas de esta colección

CódigojavascriptSimple

Gráficos Básicos Plotly

Gráficos esenciales Plotly.js incluyendo dispersión, líneas, circular y superficies 3D con características interactivas

Dificultad

4/10

Tiempo estimado

25 min

Etiquetas

plotly, charts, interactive

Requisitos previos

JavaScript, Plotly.js library, HTML basics

javascript
// Plotly.js Basic Charts Examples

// 1. Scatter Plot
function createScatterPlot() {
    const trace1 = {
        x: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
        y: [2.1, 3.4, 1.2, 4.5, 3.8, 6.2, 2.8, 5.1, 4.3, 3.9],
        mode: 'markers',
        type: 'scatter',
        name: 'Dataset 1',
        marker: {
            size: 8,
            color: 'rgba(78, 121, 167, 0.8)',
            line: {
                color: 'rgba(78, 121, 167, 1)',
                width: 2
            }
        }
    };

    const trace2 = {
        x: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
        y: [1.8, 2.9, 2.5, 4.2, 5.1, 5.8, 3.2, 4.9, 3.5, 4.1],
        mode: 'markers+lines',
        type: 'scatter',
        name: 'Dataset 2',
        marker: {
            size: 10,
            color: 'rgba(242, 142, 44, 0.8)',
            line: {
                color: 'rgba(242, 142, 44, 1)',
                width: 3,
                dash: 'dot'
            }
        }
    };

    const layout = {
        title: 'Interactive Scatter Plot',
        xaxis: {
            title: 'X Variable',
            gridcolor: 'rgba(0,0,0,0.1)',
            zerolinecolor: 'rgba(0,0,0,0.2)'
        },
        yaxis: {
            title: 'Y Variable',
            gridcolor: 'rgba(0,0,0,0.1)',
            zerolinecolor: 'rgba(0,0,0,0.2)'
        },
        plot_bgcolor: 'rgba(240, 240, 240, 0.8)',
        paper_bgcolor: 'rgba(255, 255, 255, 1)',
        hovermode: 'closest',
        showlegend: true,
        legend: {
            x: 1,
            y: 1,
            bgcolor: 'rgba(255, 255, 255, 0.8)',
            bordercolor: 'rgba(0,0,0,0.2)',
            borderwidth: 1
        },
        margin: {
            l: 50,
            r: 50,
            t: 50,
            b: 50
        }
    };

    const config = {
        responsive: true,
        displayModeBar: false
    };

    return Plotly.newPlot('scatter-plot', [trace1, trace2], layout, config);
}

// 2. 3D Surface Plot
function createSurface3D() {
    const size = 50;
    const x = [];
    const y = [];
    const z = [];

    // Generate meshgrid
    for (let i = 0; i < size; i++) {
        x[i] = [];
        y[i] = [];
        z[i] = [];
        for (let j = 0; j < size; j++) {
            const x_val = (i - size / 2) / (size / 10);
            const y_val = (j - size / 2) / (size / 10);
            x[i][j] = x_val;
            y[i][j] = y_val;
            z[i][j] = Math.sin(Math.sqrt(x_val * x_val + y_val * y_val));
        }
    }

    const data = [{
        x: x,
        y: y,
        z: z,
        type: 'surface',
        colorscale: 'Viridis',
        showscale: true,
        colorbar: {
            title: 'Z Value',
            titleside: false,
            tickmode: 'linear',
            tick0: 0,
            dtick: 0.5
        }
    }];

    const layout = {
        title: '3D Surface Plot',
        autosize: false,
        width: 600,
        height: 500,
        scene: {
            xaxis: {
                title: 'X Axis',
                gridcolor: 'rgb(200,200,200)',
                showbackground: true,
                backgroundcolor: 'rgba(200,200,200,0.2)'
            },
            yaxis: {
                title: 'Y Axis',
                gridcolor: 'rgb(200,200,200)',
                showbackground: true,
                backgroundcolor: 'rgba(200,200,200,0.2)'
            },
            zaxis: {
                title: 'Z Axis',
                gridcolor: 'rgb(200,200,200)',
                showbackground: true,
                backgroundcolor: 'rgba(200,200,200,0.2)'
            }
        },
        margin: {
            l: 0,
            r: 0,
            b: 0,
            t: 0
        }
    };

    const config = {
        responsive: true,
        displayModeBar: false
    };

    return Plotly.newPlot('surface-3d', data, layout, config);
}

// 3. Statistical Box Plot
function createBoxPlot() {
    const y0 = [
        [0.75, 5.25, 5.5, 6, 6.25, 6.5, 6.75, 7.0, 7.25, 7.5, 7.75, 8.0, 8.25, 8.5, 8.75, 9.0, 9.25, 9.5, 9.75, 10.0, 10.25, 10.5, 10.75, 11.0, 11.25, 11.5, 11.75, 12.0, 12.25, 12.5, 12.75, 13.0, 13.25, 13.5, 13.75, 14.5],
        [2.0, 6.0, 6.25, 6.5, 6.75, 7.0, 7.25, 7.5, 7.75, 8.0, 8.25, 8.5, 8.75, 9.0, 9.25, 9.5, 9.75, 10.0, 10.25, 10.5, 10.75, 11.0, 11.25, 11.5, 11.75, 12.0, 12.25, 12.5, 12.75, 13.0, 13.25, 13.5, 13.75, 14.5]
    ];

    const y1 = [
        [1.0, 4.0, 4.25, 4.5, 4.75, 5.0, 5.25, 5.5, 5.75, 6.0, 6.25, 6.5, 6.75, 7.0, 7.25, 7.5, 7.75, 8.0, 8.25, 8.5, 8.75, 9.0, 9.25, 9.5, 9.75, 10.0, 10.25, 10.5, 10.75, 11.0, 11.25, 11.5, 11.75, 12.0, 12.25, 12.5, 12.75, 13.0, 13.25, 13.5, 13.75, 14.5],
        [2.0, 4.5, 4.75, 5.0, 5.25, 5.5, 5.75, 6.0, 6.25, 6.5, 6.75, 7.0, 7.25, 7.5, 7.75, 8.0, 8.25, 8.5, 8.75, 9.0, 9.25, 9.5, 9.75, 10.0, 10.25, 10.5, 10.75, 11.0, 11.25, 11.5, 11.75, 12.0, 12.25, 12.5, 12.75, 13.0, 13.25, 13.5, 13.75, 14.5]
    ];

    const trace1 = {
        y: y0,
        type: 'box',
        name: 'Group A',
        marker: {
            color: 'rgb(78, 121, 167)'
        },
        boxpoints: 'all',
        jitter: 0.3,
        whiskerwidth: 0.2,
        fillcolor: 'rgba(78, 121, 167, 0.5)',
        line: {
            color: 'rgb(78, 121, 167)'
        }
    };

    const trace2 = {
        y: y1,
        type: 'box',
        name: 'Group B',
        marker: {
            color: 'rgb(242, 142, 44)'
        },
        boxpoints: 'all',
        jitter: 0.3,
        whiskerwidth: 0.2,
        fillcolor: 'rgba(242, 142, 44, 0.5)',
        line: {
            color: 'rgb(242, 142, 44)'
        }
    };

    const layout = {
        title: 'Statistical Box Plot',
        yaxis: {
            title: 'Values',
            gridcolor: 'rgba(0,0,0,0.1)',
            zerolinecolor: 'rgba(0,0,0,0.2)'
        },
        xaxis: {
            title: 'Groups',
            gridcolor: 'rgba(0,0,0,0.1)',
            zerolinecolor: 'rgba(0,0,0,0.2)'
        },
        plot_bgcolor: 'rgba(240, 240, 240, 0.8)',
        paper_bgcolor: 'rgba(255, 255, 255, 1)',
        showlegend: true,
        margin: {
            l: 50,
            r: 50,
            t: 50,
            b: 50
        }
    };

    const config = {
        responsive: true,
        displayModeBar: false
    };

    return Plotly.newPlot('box-plot', [trace1, trace2], layout, config);
}

// 4. Heatmap
function createHeatmap() {
    const data = [
        {
            z: [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20], [21, 22, 23, 24, 25]],
            x: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'],
            y: ['Morning', 'Afternoon', 'Evening', 'Night'],
            type: 'heatmap',
            hovertemplate: '<b>%{x}</b><br>%{y}<br>%{z:.1f}',
            colorscale: 'Reds',
            showscale: true
        }
    ];

    const layout = {
        title: 'Activity Heatmap',
        xaxis: {
            title: 'Day of Week'
        },
        yaxis: {
            title: 'Time of Day'
        },
        margin: {
            l: 50,
            r: 50,
            t: 50,
            b: 50
        }
    };

    const config = {
        responsive: true,
        displayModeBar: false
    };

    return Plotly.newPlot('heatmap', data, layout, config);
}

// 5. Pie Chart with Customization
function createPieChart() {
    const data = [{
        values: [30, 25, 15, 12, 18],
        labels: ['Electronics', 'Clothing', 'Food', 'Books', 'Other'],
        type: 'pie',
        name: 'Sales Distribution',
        marker: {
            colors: ['#4e79a7', '#f28e2c', '#e15759', '#76b7b2', '#59a14f'],
            line: {
                color: '#fff'
            }
        },
        textinfo: 'label+percent',
        textposition: 'inside',
        automargin: true
    }];

    const layout = {
        title: 'Sales Distribution',
        font: {
            size: 16
        },
        showlegend: true,
        legend: {
            orientation: 'h',
            x: 0.5,
            xanchor: 'center',
            y: -0.1,
            yanchor: 'top'
        },
        margin: {
            l: 50,
            r: 50,
            t: 50,
            b: 50
        }
    };

    const config = {
        responsive: true,
        displayModeBar: false
    };

    return Plotly.newPlot('pie-chart', [data], layout, config);
}

// Initialize all charts when page loads
document.addEventListener('DOMContentLoaded', function() {
    const scatterPlot = createScatterPlot();
    const surface3D = createSurface3D();
    const boxPlot = createBoxPlot();
    const heatmap = createHeatmap();
    const pieChart = createPieChart();

    // Store chart references for later manipulation
    window.plotlyCharts = {
        scatter: scatterPlot,
        surface3D: surface3D,
        box: boxPlot,
        heatmap: heatmap,
        pie: pieChart
    };
});

// Update function for real-time data updates
function updateChartData(chartId, newData) {
    const chart = window.plotlyCharts[chartId];
    if (chart) {
        Plotly.update(chart, {
            data: newData
        });
    }
}
CódigojavascriptIntermedio

Gráficos 3D Avanzados Plotly

Visualizaciones 3D avanzadas incluyendo malla, contornos, renderizado volumétrico y animaciones

Dificultad

7/10

Tiempo estimado

40 min

Etiquetas

plotly, 3d, advanced

Requisitos previos

JavaScript, Plotly.js, 3D visualization concepts, Math

javascript
// Plotly 3D Advanced Examples

// 1. 3D Mesh Plot with Custom Data
function create3DMeshPlot() {
    // Generate complex 3D data
    const createMeshData = () => {
        const size = 30;
        const x = [];
        const y = [];
        const z = [];

        for (let i = 0; i < size; i++) {
            x[i] = [];
            y[i] = [];
            z[i] = [];
            for (let j = 0; j < size; j++) {
                const x_val = (i - size / 2) / 5;
                const y_val = (j - size / 2) / 5;
                x[i][j] = x_val;
                y[i][j] = y_val;

                // Create more complex surface
                const r = Math.sqrt(x_val * x_val + y_val * y_val);
                const theta = Math.atan2(y_val, x_val);
                z[i][j] = r * Math.sin(theta * 3) * Math.cos(r * 2) * 0.5;
            }
        }
        return { x, y, z };
    };

    const { x, y, z } = createMeshData();

    const data = [{
        type: 'mesh3d',
        x: x,
        y: y,
        z: z,
        opacity: 0.8,
        color: 'rgba(78, 121, 167, 1)',
        flatshading: false,
        lighting: {
            ambient: 0.4,
            diffuse: 0.6,
            specular: 0.8,
            roughness: 0.2,
            fresnel: 1
        },
        lightposition: {x: 100, y: 200, z: 0},
        lightcolor: 'white'
    }];

    const layout = {
        title: 'Complex 3D Mesh Surface',
        scene: {
            camera: {
                eye: {x: 1.5, y: 1.5, z: 1.5},
                center: {x: 0, y: 0, z: 0}
            },
            xaxis: {
                title: 'X',
                gridcolor: 'rgb(200,200,200)',
                showbackground: true,
                backgroundcolor: 'rgba(230,230,230,0.2)'
            },
            yaxis: {
                title: 'Y',
                gridcolor: 'rgb(200,200,200)',
                showbackground: true,
                backgroundcolor: 'rgba(230,230,230,0.2)'
            },
            zaxis: {
                title: 'Z',
                gridcolor: 'rgb(200,200,200)',
                showbackground: true,
                backgroundcolor: 'rgba(230,230,230,0.2)'
            }
        },
        margin: { l: 0, r: 0, t: 0, b: 0 }
    };

    return Plotly.newPlot('mesh-3d', [data], layout);
}

// 2. 3D Contour Plot
function create3DContourPlot() {
    // Generate contour data
    const generateContourData = () => {
        const x = [];
        const y = [];
        const z = [];

        for (let i = 0; i < 50; i++) {
            x[i] = [];
            y[i] = [];
            z[i] = [];
            for (let j = 0; j < 50; j++) {
                const x_val = (i - 25) / 10;
                const y_val = (j - 25) / 10;
                x[i][j] = x_val;
                y[i][j] = y_val;

                // Create interesting contour pattern
                z[i][j] = Math.sin(x_val * 3) * Math.cos(y_val * 2) +
                             Math.sin(x_val * y_val) * 0.5 +
                             Math.cos(x_val - y_val) * 0.3;
            }
        }
        return { x, y, z };
    };

    const { x, y, z } = generateContourData();

    const data = [{
        type: 'surface',
        x: x,
        y: y,
        z: z,
        contours: {
            z: {
                show: true,
                usecolormap: true,
                project: { z: true },
                start: -2,
                end: 2,
                size: 0.1,
                color: 'black'
            }
        },
        colorscale: 'Jet',
        showscale: false
    }];

    const layout = {
        title: '3D Contour Plot',
        scene: {
            camera: {
                eye: {x: 1.5, y: 1.5, z: 1.5},
                center: {x: 0, y: 0, z: 0}
            }
        }
    };

    return Plotly.newPlot('contour-3d', [data], layout);
}

// 3. 3D Scatter Plot with Animation
function create3DScatterPlot() {
    const frames = [];
    const nFrames = 100;

    for (let frame = 0; frame < nFrames; frame++) {
        const t = frame / (nFrames - 1);
        const angle = t * 2 * Math.PI;

        // Create spiral data
        const spiralData = [];
        const nPoints = 50;

        for (let i = 0; i < nPoints; i++) {
            const r = i / nPoints * 5;
            const theta = i / nPoints * 4 * Math.PI + angle;
            const x = r * Math.cos(theta);
            const y = r * Math.sin(theta);
            const z = Math.sin(r * 3) * t * 2;

            spiralData.push([x, y, z, Math.random() * 10 + 5]);
        }

        frames.push({
            data: [{
                type: 'scatter3d',
                mode: 'markers',
                x: spiralData.map(d => d[0]),
                y: spiralData.map(d => d[1]),
                z: spiralData.map(d => d[2]),
                marker: {
                    size: spiralData.map(d => d[3]),
                    color: spiralData.map(d => `hsl(${(d[2] * 60)}, 70%, 50%)`)
                }
            }],
            name: frame.toString()
        });
    }

    const layout = {
        title: 'Animated 3D Spiral',
        scene: {
            camera: {
                eye: {x: 2, y: 2, z: 2},
                center: {x: 0, y: 0, z: 0}
            },
            aspectmode: 'cube'
        },
        margin: { l: 0, r: 0, t: 0, b: 0 }
    };

    const config = {
        frame: frames,
        transition: {
            duration: 50
        }
    };

    return Plotly.newPlot('scatter-3d', frames[0].data, layout, config);
}

// 4. Multiple 3D Subplots
function createMultiple3DPlots() {
    const trace1 = {
        x: [1, 2, 3, 4, 5],
        y: [5, 4, 3, 2, 1],
        z: [2, 3, 4, 5, 1],
        mode: 'markers',
        marker: { size: 8, color: 'red' },
        type: 'scatter3d'
    };

    const trace2 = {
        x: [1, 2, 3, 4, 5],
        y: [2, 3, 4, 5, 6],
        z: [5, 4, 3, 2, 1],
        mode: 'markers',
        marker: { size: 8, color: 'blue' },
        type: 'scatter3d'
    };

    const trace3 = {
        x: [1, 2, 3, 4, 5],
        y: [3, 2, 1, 5, 4],
        z: [4, 5, 1, 2, 3],
        mode: 'markers',
        marker: { size: 8, color: 'green' },
        type: 'scatter3d'
    };

    const layout = {
        title: 'Multiple 3D Subplots',
        scene: {
            domain: {
                x: [0, 0.33],
                y: [0.33, 0.66]
            },
            camera: {
                eye: {x: 1.5, y: 1.5, z: 1.5},
                center: {x: 0, y: 0, z: 0}
            }
        }
    };

    const layout2 = {
        scene: {
            domain: {
                x: [0.33, 0.66],
                y: [0.33, 0.66]
            },
            camera: {
                eye: {x: 1.5, y: 1.5, z: 1.5},
                center: {x: 0.5, y: 0.5, z: 0}
            }
        }
    };

    const layout3 = {
        scene: {
            domain: {
                x: [0.66, 1],
                y: [0.33, 0.66]
            },
            camera: {
                eye: {x: 1.5, y: 1.5, z: 1.5},
                center: {x: 1, y: 0.5, z: 0}
            }
        }
    };

    const layoutArray = [layout, layout2, layout3];

    const config = {
        responsive: true
    };

    return Plotly.newPlot('multiple-3d', [trace1, trace2, trace3], layoutArray, config);
}

// 5. 3D Bar Chart
function create3DBarChart() {
    const trace = {
        x: ['Product A', 'Product B', 'Product C', 'Product D', 'Product E'],
        y: ['Q1', 'Q2', 'Q3', 'Q4'],
        z: [[10, 20, 15, 25, 30], [12, 18, 22, 28, 35], [8, 14, 18, 22, 28], [15, 25, 20, 30, 32], [20, 15, 25, 35, 40]],
        type: 'bar',
        marker: {
            color: 'rgba(78, 121, 167, 0.8)'
        },
        showscale: true,
        colorscale: 'Blues'
    };

    const layout = {
        title: '3D Bar Chart',
        scene: {
            camera: {
                eye: {x: 1.5, y: 1.5, z: 1.5},
                center: {x: 0, y: 0, z: 0}
            },
            xaxis: {
                title: 'Products'
            },
            yaxis: {
                title: 'Quarters'
            },
            zaxis: {
                title: 'Sales'
            }
        },
        margin: { l: 0, r: 0, t: 0, b: 0 }
    };

    const config = {
        responsive: true,
        displayModeBar: false
    };

    return Plotly.newPlot('bar-3d', [trace], layout, config);
}

// Initialize all 3D charts
document.addEventListener('DOMContentLoaded', function() {
    const meshPlot = create3DMeshPlot();
    const contourPlot = create3DContourPlot();
    const scatterPlot = create3DScatterPlot();
    const multiPlot = createMultiple3DPlots();
    const barPlot = create3DBarChart();

    // Store chart references
    window.plotly3DCharts = {
        mesh: meshPlot,
        contour: contourPlot,
        scatter: scatterPlot,
        multi: multiPlot,
        bar: barPlot
    };
});
CódigojavascriptIntermedio

Gráficos Estadísticos Plotly

Visualizaciones estadísticas incluyendo histogramas, gráficos de violín, gráficos de caja y análisis de regresión

Dificultad

6/10

Tiempo estimado

35 min

Etiquetas

plotly, statistics, analysis

Requisitos previos

JavaScript, Plotly.js, Statistics, Data analysis

javascript
// Plotly Statistical Charts Examples

// 1. Histogram with Normal Distribution Fit
function createHistogram() {
    // Generate sample data
    const sampleData = [];
    for (let i = 0; i < 1000; i++) {
        // Create normal distribution data
        let sum = 0;
        for (let j = 0; j < 12; j++) {
            sum += Math.random();
        }
        sampleData.push(sum / 12);
    }

    const data = [{
        x: sampleData,
        type: 'histogram',
        name: 'Sample Distribution',
        opacity: 0.75,
        marker: {
            color: 'rgba(78, 121, 167, 0.8)'
        },
        nbinsx: 30,
        autobinx: true,
        histnorm: 'probability density'
    }];

    // Calculate mean and standard deviation
    const mean = sampleData.reduce((a, b) => a + b) / sampleData.length;
    const stdDev = Math.sqrt(sampleData.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / sampleData.length);

    // Add normal distribution curve
    const xValues = [];
    const yValues = [];
    for (let i = 0; i < 100; i++) {
        const x = Math.min(...sampleData) + (Math.max(...sampleData) - Math.min(...sampleData)) * (i / 99);
        const y = (1 / (stdDev * Math.sqrt(2 * Math.PI))) *
                   Math.exp(-0.5 * Math.pow((x - mean) / stdDev, 2));
        xValues.push(x);
        yValues.push(y);
    }

    const normalCurve = {
        x: xValues,
        y: yValues,
        type: 'scatter',
        mode: 'lines',
        name: 'Normal Distribution',
        line: {
            color: 'rgba(242, 142, 44, 1)',
            width: 3
        }
    };

    const layout = {
        title: 'Histogram with Normal Distribution Fit',
        xaxis: {
            title: 'Value',
            titlefont: {
                size: 14
            }
        },
        yaxis: {
            title: 'Probability Density',
            titlefont: {
                size: 14
            }
        },
        barmode: 'group',
        bargap: 0.2,
        bargroupgap: 0.2,
        plot_bgcolor: 'rgba(240, 240, 240, 0.8)',
        paper_bgcolor: 'rgba(255, 255, 255, 1)',
        margin: { l: 50, r: 50, t: 50, b: 50 },
        showlegend: true
    };

    const config = {
        responsive: true,
        displayModeBar: false
    };

    return Plotly.newPlot('histogram', [data, normalCurve], layout, config);
}

// 2. Violin Plot
function createViolinPlot() {
    const data = [
        {
            type: 'violin',
            x: ['Group A', 'Group B', 'Group C', 'Group D', 'Group E'],
            y: [
                [1, 2, 3, 4, 5],
                [2, 3, 4, 5, 6],
                [3, 4, 5, 6, 7],
                [4, 5, 6, 7, 8],
                [5, 6, 7, 8, 9]
            ],
            name: 'Dataset 1',
            box: {
                visible: true,
                width: 0.1,
                color: 'rgba(78, 121, 167, 0.8)'
            },
            meanline: {
                visible: true,
                color: 'rgba(242, 142, 44, 1)'
            }
        },
        {
            type: 'violin',
            x: ['Group A', 'Group B', 'Group C', 'Group D', 'Group E'],
            y: [
                [2, 3, 4, 5, 6],
                [3, 4, 5, 6, 7],
                [4, 5, 6, 7, 8],
                [5, 6, 7, 8, 9],
                [6, 7, 8, 9, 10]
            ],
            name: 'Dataset 2',
            box: {
                visible: true,
                width: 0.1,
                color: 'rgba(225, 87, 89, 0.8)'
            },
            meanline: {
                visible: true,
                color: 'rgba(59, 161, 79, 1)'
            }
        }
    ];

    const layout = {
        title: 'Violin Plot Comparison',
        yaxis: {
            title: 'Values',
            zeroline: false
        },
        xaxis: {
            title: 'Groups'
        },
        violinmode: 'group',
        violinggap: 0,
        violinmode: 'group',
        plot_bgcolor: 'rgba(240, 240, 240, 0.8)',
        paper_bgcolor: 'rgba(255, 255, 255, 1)',
        margin: { l: 50, r: 50, t: 50, b: 50 },
        showlegend: true
    };

    const config = {
        responsive: true,
        displayModeBar: false
    };

    return Plotly.newPlot('violin-plot', data, layout, config);
}

// 3. Error Bars Chart
function createErrorBarsChart() {
    const trace1 = {
        x: ['January', 'February', 'March', 'April', 'May', 'June'],
        y: [20, 14, 25, 22, 18, 30],
        error_y: {
            type: 'data',
            array: [2, 3, 1.5, 2.5, 1.8, 4],
            visible: true
        },
        type: 'scatter',
        name: 'Series 1',
        marker: {
            color: 'rgba(78, 121, 167, 0.8)',
            size: 8
        }
    };

    const trace2 = {
        x: ['January', 'February', 'March', 'April', 'May', 'June'],
        y: [18, 16, 22, 20, 16, 25],
        error_y: {
            type: 'percent',
            value: 10,
            visible: true
        },
        type: 'scatter',
        name: 'Series 2',
        marker: {
            color: 'rgba(242, 142, 44, 0.8)',
            size: 8
        }
    };

    const layout = {
        title: 'Error Bars Comparison',
        xaxis: {
            title: 'Month'
        },
        yaxis: {
            title: 'Value'
        },
        plot_bgcolor: 'rgba(240, 240, 240, 0.8)',
        paper_bgcolor: 'rgba(255, 255, 255, 1)',
        margin: { l: 50, r: 50, t: 50, b: 50 },
        showlegend: true,
        error_y: {
            type: 'data'
        }
    };

    const config = {
        responsive: true,
        displayModeBar: false
    };

    return Plotly.newPlot('error-bars', [trace1, trace2], layout, config);
}

// 4. Parallel Coordinates Plot
function createParallelCoordinates() {
    const dimensions = ['Dimension 1', 'Dimension 2', 'Dimension 3', 'Dimension 4', 'Dimension 5'];
    const categories = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'];

    const data = [
        {
            type: 'parcoords',
            dimensions: [
                {
                    label: 'Dimension 1',
                    values: [1, 2, 3, 4, 5]
                },
                {
                    label: 'Dimension 2',
                    values: [2, 3, 1, 5, 4]
                },
                {
                    label: 'Dimension 3',
                    values: [3, 1, 4, 2, 5]
                },
                {
                    label: 'Dimension 4',
                    values: [4, 5, 2, 1, 3]
                },
                {
                    label: 'Dimension 5',
                    values: [5, 4, 5, 3, 1]
                }
            ],
            line: {
                color: 'blue'
            },
            marker: {
                size: 8,
                color: 'red'
            }
        },
        {
            type: 'parcoords',
            dimensions: [
                {
                    label: 'Dimension 1',
                    values: [3, 4, 5, 2, 1]
                },
                {
                    label: 'Dimension 2',
                    values: [4, 3, 2, 5, 6]
                },
                {
                    label: 'Dimension 3',
                    values: [2, 5, 4, 3, 7]
                },
                {
                    label: 'Dimension 4',
                    values: [5, 2, 3, 1, 4]
                },
                {
                    label: 'Dimension 5',
                    values: [1, 3, 6, 4, 2]
                }
            ],
            line: {
                color: 'green'
            },
            marker: {
                size: 8,
                color: 'orange'
            }
        }
    ];

    const layout = {
        title: 'Parallel Coordinates Plot',
        paper_bgcolor: 'rgba(255, 255, 255, 1)',
        plot_bgcolor: 'rgba(240, 240, 240, 0.8)',
        margin: { l: 50, r: 50, t: 50, b: 50 },
        margin: {
            l: 100,
            r: 50,
            t: 50,
            b: 50
        },
        padding: {
            l: 80,
            r: 10,
            t: 60,
            b: 80
        },
        autosize: true
    };

    const config = {
        responsive: true,
        displayModeBar: false
    };

    return Plotly.newPlot('parallel-coordinates', data, layout, config);
}

// 5. Distribution Comparison
function createDistributionComparison() {
    const data = [
        {
            x: [
                0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0
            ],
            type: 'histogram',
            opacity: 0.7,
            name: 'Dataset A',
            marker: {
                color: 'rgba(78, 121, 167, 0.8)'
            }
        },
        {
            x: [
                0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0
            ],
            type: 'histogram',
            opacity: 0.7,
            name: 'Dataset B',
            marker: {
                color: 'rgba(242, 142, 44, 0.8)'
            }
        },
        {
            x: [
                0.1, 0.25, 0.35, 0.45, 0.55, 0.65, 0.75, 0.85, 0.95, 1.0
            ],
            type: 'histogram',
            opacity: 0.7,
            name: 'Dataset C',
            marker: {
                color: 'rgba(225, 87, 89, 0.8)'
            }
        }
    ];

    const layout = {
        title: 'Distribution Comparison',
        barmode: 'overlay',
        barnorm: 'fraction',
        xaxis: {
            title: 'Value',
            titlefont: {
                size: 14
            }
        },
        yaxis: {
            title: 'Count',
            titlefont: {
                size: 14
            }
        },
        plot_bgcolor: 'rgba(240, 240, 240, 0.8)',
        paper_bgcolor: 'rgba(255, 255, 255, 1)',
        margin: { l: 50, r: 50, t: 50, b: 50 },
        showlegend: true
    };

    const config = {
        responsive: true,
        displayModeBar: false
    };

    return Plotly.newPlot('distribution-comparison', data, layout, config);
}

// Initialize all statistical charts
document.addEventListener('DOMContentLoaded', function() {
    const histogram = createHistogram();
    const violinPlot = createViolinPlot();
    const errorBars = createErrorBarsChart();
    const parallelPlot = createParallelCoordinates();
    const distribution = createDistributionComparison();

    // Store chart references
    window.plotlyStatistical = {
        histogram: histogram,
        violin: violinPlot,
        errorBars: errorBars,
        parallel: parallelPlot,
        distribution: distribution
    };
});

Herramientas

Herramientas que suelen usarse con este ejemplo

Relacionado

Colecciones de ejemplos relacionadas

Relacionado

Temas relacionados

Tema

Generadores de gráficos y diagramas

Elige una visualización para comparar, distribuir, ordenar, relacionar y planificar datos.

Tema

Medición e inspección de audio

Mide sonoridad, picos, dinámica, descriptores musicales, espectro y metadatos antes de masterizar, publicar o archivar audio.

Tema

Revisión e integración de un componente de sorteos autoalojado

Revisa la configuración, las respuestas de ejemplo, la legibilidad y el diseño adaptable antes de entregar los archivos y las pruebas de integración del sorteo.

Tema

Adapte un currículum a una sola oferta de empleo

Compare su currículum contra la oferta real para exponer los huecos de cobertura, puntúe cada viñeta por verbos fuertes y resultados cuantificados, y reescriba las débiles como logros STAR con evidencia de antes y después.

Inicio
Herramientas3212
Ejemplos593
Visualizaciones471
Visores de archivos103
Temas239
Etiquetas333
Imágenes, audio y video657

Herramientas de procesamiento, conversión y optimización de imágenes, audio y video

Matemáticas, fechas y finanzas647

Calculadoras, herramientas numéricas, lógica de fechas, estadística y finanzas

Diseño y color298

Herramientas de color, maquetación, gráficos, estilo visual y apoyo al diseño

Texto y redacción209

Herramientas de redacción, limpieza, formato, extracción y análisis de texto

Desarrollo y Web193

Utilidades para desarrolladores, red, depuración web y automatización

Conversión y codificación175

Herramientas de conversión de formatos, archivos, unidades, archivos comprimidos y codificación

Lanzamiento de un cuestionario de captación y entrega de contactos
Textos conmemorativos: revisión familiar y entrega para impresión
Hábitos privados: copia, restauración y revisión antes de compartir
De artículo a borradores de X y LinkedIn: revisión factual y entrega
Revisión de una lección Markdown interactiva y entrega sin conexión

© 2026 Elysia Tools. Todos los derechos reservados.

DocumentaciónPreciosAcerca deTérminos de servicioPolítica de privacidadCookiesContacto

Data Visualization

Generador de Gráficos de Área

Generar gráficos de área personalizables desde datos con áreas rellenas bajo líneas, perfecto para mostrar tendencias y datos acumulativos

Data Visualization

Bar Chart Generator

Generate customizable bar charts from data with various styling options

Data Visualization

Generador de Gráfico de Burbujas

Generar gráficos de burbujas personalizables desde datos con tres dimensiones (x, y, tamaño)

Data Visualization

Line Chart Generator

Generate customizable multi-line charts from data with various styling options

Data Visualization

Pie Chart Generator

Generate customizable pie charts from data with various styling options

Data Visualization

Scatter Plot Generator

Generate customizable scatter plots with regression lines and multiple data series

Data Visualization

Generador de Gráficos de Área Apilada

Generar gráficos de área apilada mostrando tendencias acumulativas de múltiples series de datos, perfecto para visualizar tendencias totales y contribuciones de componentes

Data Visualization

Generador de Gráfico de Dona

Generar gráficos de dona personalizables desde datos con varias opciones de estilo, perfecto para mostrar proporciones con espacio central

Visualización de datos

Ejemplos Chart.js Library

Ejemplos completos de Chart.js incluyendo tipos de gráficos, opciones de personalización, animaciones y diseños responsivos

Visualización de datos

Ejemplos D3.js Data Visualization

Ejemplos completos de visualización de datos D3.js incluyendo gráficos, mapas, animaciones y visualizaciones interactivas

Visualización de datos

Ejemplos Apache ECharts

Ejemplos completos de Apache ECharts incluyendo varios tipos de gráficos, visualizaciones avanzadas y dashboards interactivos

Visualización de datos

Ejemplos Observable Notebooks

Ejemplos completos de Observable Notebooks incluyendo análisis de datos, flujos de trabajo de visualización y técnicas interactivas avanzadas

Medios

Ejemplos SVG

Ejemplos de Gráficos Vectoriales Escalables (SVG) que demuestran varias características y técnicas SVG