Šiuolaikinėje duomenų valdomame pasaulyje, sudėtingos informacijos vizualizavimas per grafikus ir grafikus tapo būtina. Nors „Excel“ suteikia galingas grafikos galimybes, yra daugybė scenarijų, kuriuose turite išgauti šiuos vizualinius elementus kaip atskirus vaizdus:

  • Įtraukti grafikus į ataskaitas ir pristatymus
  • Įterpiamos vizualizacijos žiniatinklio programose
  • Dalijimasis įžvalgomis, neplatindamas visą skirtuką
  • Dokumentų kūrimas su grafikos iliustracijomis
  • Dinaminio vaizdo turinio generavimas verslo intelekto dashboards

Aspose.Cells for .NET siūlo tvirtą sprendimą programai konvertuoti „Excel“ grafikus į aukštos kokybės vaizdus, nereikalaujant „Microsoft Excel“ įrengimo.

Kodėl pasirinkti Aspose.Cells žemėlapio konvertavimo?

Tradiciniai „Excel“ automatizavimo metodai gali būti problematiški gamybos aplinkoje dėl:

  • Saugumo pažeidimai
  • Įdiegimo sudėtingumas
  • Licencijos iššūkiai
  • Veiklos buteliukai
  • Stabilumo klausimai

Aspose.Cells siūlo specialų API, specialiai sukurtą „Excel“ failų serverio pusės apdorojimui, užtikrinant aukštesnį našumą ir patikimumą.

pradėti

Prieš nusileidžiant į pavyzdžius, įsitikinkite, kad turite:

  • Atsisiųsti ir įdiegti Aspose.Cells už .NET
  • Pridėta nuoroda į Aspose.Cells.dll Jūsų projekte
  • Importuoti reikalingi pavadinimų erdvės:
using Aspose.Cells;
using Aspose.Cells.Charts;
using Aspose.Cells.Rendering;

Pagrindinis grafikas į vaizdo konvertavimą

Pradėkime nuo paprasto pavyzdžio, kaip konvertuoti visus grafikus darbo lentelėje į vaizdus naudojant C# Excel Chart to Image :

// Load the Excel file containing charts
Workbook workbook = new Workbook("SalesReport.xlsx");

// Access the worksheet containing charts
Worksheet sheet = workbook.Worksheets[0];

// Initialize counter for unique filenames
int chartIndex = 1;

// Process each chart in the worksheet
foreach (Chart chart in sheet.Charts)
{
    // Define the output path for the image
    string outputPath = $"Chart_{chartIndex}.png";
    
    // Convert the chart to an image
    chart.ToImage(outputPath, ImageFormat.Png);
    
    Console.WriteLine($"Successfully converted chart {chartIndex} to {outputPath}");
    chartIndex++;
}

Pagerintas vaizdo kokybė su pritaikytomis parinktimis

Profesionalioms programoms dažnai reikės kontroliuoti eksportuotų vaizdų kokybę ir išvaizdą.Tai galima pasiekti naudojant Java Excel Chart to Image metodus:

// Load the workbook containing charts
Workbook workbook = new Workbook("FinancialDashboard.xlsx");
Worksheet sheet = workbook.Worksheets["Performance Metrics"];

// Create image options with high resolution
ImageOrPrintOptions imageOptions = new ImageOrPrintOptions
{
    HorizontalResolution = 300,
    VerticalResolution = 300,
    ImageFormat = ImageFormat.Jpeg,
    Quality = 95 // Higher quality JPEG compression
};

// Access a specific chart (e.g., the first chart)
Chart revenueChart = sheet.Charts[0];

// Convert with custom options
revenueChart.ToImage("Revenue_Trends_HQ.jpg", imageOptions);

Konvertuoti kelias diagramas į skirtingus formatus

Skirtingi naudojimo atvejai gali reikalauti skirtingų vaizdo formatų. štai kaip eksportuoti grafikus į skirtingus formatus:

// Load the Excel workbook
Workbook workbook = new Workbook("QuarterlyReport.xlsx");
Worksheet sheet = workbook.Worksheets["Sales Analysis"];

// Initialize counter for unique filenames
int idx = 0;

// Process each chart with custom options for different formats
foreach (Chart chart in sheet.Charts)
{
    // Create image options
    ImageOrPrintOptions imgOpts = new ImageOrPrintOptions();
    
    // Configure different settings based on chart index
    switch (idx % 3)
    {
        case 0: // PNG format with transparency
            imgOpts.ImageFormat = ImageFormat.Png;
            chart.ToImage($"Chart_{idx}_transparent.png", imgOpts);
            break;
            
        case 1: // JPEG format with high quality
            imgOpts.ImageFormat = ImageFormat.Jpeg;
            imgOpts.Quality = 100;
            chart.ToImage($"Chart_{idx}_high_quality.jpg", imgOpts);
            break;
            
        case 2: // SVG format for vector graphics
            imgOpts.ImageFormat = ImageFormat.Svg;
            chart.ToImage($"Chart_{idx}_vector.svg", imgOpts);
            break;
    }
    
    ++idx;
}

Išplėstinė grafika Rendering Options

Kai jums reikia tikslios perdavimo proceso kontrolės, Aspose.Cells suteikia platų pritaikymo galimybių:

// Load the source workbook
Workbook workbook = new Workbook("MarketingAnalytics.xlsx");
Worksheet sheet = workbook.Worksheets["Campaign Performance"];

// Get reference to a specific chart
Chart campaignChart = sheet.Charts[0];

// Create advanced rendering options
ImageOrPrintOptions renderOptions = new ImageOrPrintOptions
{
    // Set high resolution for print-quality output
    HorizontalResolution = 600,
    VerticalResolution = 600,
    
    // Control image appearance
    ImageFormat = ImageFormat.Png,
    OnlyArea = false, // Include the entire chart area
    
    // Set custom dimensions (if needed)
    CustomPrintPageWidth = 800,
    CustomPrintPageHeight = 600,
    
    // Enable text rendering hints for smoother text
    TextRenderingHint = TextRenderingHint.AntiAlias,
    
    // Apply print settings from the workbook
    PrintingPage = PrintingPageType.Default
};

// Convert chart with advanced options
campaignChart.ToImage("Campaign_Performance_Print_Quality.png", renderOptions);

Batch apdorojimo grafikai iš kelių darbo lapų

Verslo programose jums gali prireikti apdoroti grafikus per keletą darbdavių:

// Load the source Excel file
Workbook workbook = new Workbook("AnnualReport.xlsx");

// Create a directory for output images
string outputDir = "ChartImages";
Directory.CreateDirectory(outputDir);

// Process charts from all worksheets in the workbook
foreach (Worksheet sheet in workbook.Worksheets)
{
    // Skip worksheets without charts
    if (sheet.Charts.Count == 0)
        continue;
        
    Console.WriteLine($"Processing {sheet.Charts.Count} charts from worksheet '{sheet.Name}'");
    
    // Process each chart in the current worksheet
    for (int i = 0; i < sheet.Charts.Count; i++)
    {
        // Get the chart
        Chart chart = sheet.Charts[i];
        
        // Create a descriptive filename
        string sanitizedSheetName = string.Join("_", sheet.Name.Split(Path.GetInvalidFileNameChars()));
        string outputPath = Path.Combine(outputDir, $"{sanitizedSheetName}_Chart_{i+1}.png");
        
        // Define image options
        ImageOrPrintOptions imgOptions = new ImageOrPrintOptions
        {
            HorizontalResolution = 300,
            VerticalResolution = 300
        };
        
        // Convert and save the chart
        chart.ToImage(outputPath, imgOptions);
        
        Console.WriteLine($"  - Saved chart {i+1} to {outputPath}");
    }
}

Konvertuoti grafikus į SVG žiniatinklio programoms

SVG (Scalable Vector Graphics) yra puikus formatas žiniatinklio programoms, užtikrinant, kad jūsų grafikai atrodytų gražiai bet kokioje rezoliucijoje:

// Load the workbook
Workbook workbook = new Workbook("WebDashboard.xlsx");
Worksheet sheet = workbook.Worksheets["Performance Metrics"];

// Configure SVG export options
ImageOrPrintOptions svgOptions = new ImageOrPrintOptions
{
    ImageFormat = ImageFormat.Svg,
    SaveFormat = SaveFormat.Svg
};

// Export all charts to SVG with viewBox attribute for responsive display
for (int i = 0; i < sheet.Charts.Count; i++)
{
    Chart chart = sheet.Charts[i];
    
    // Export with viewBox attribute
    chart.ToImage($"WebChart_{i+1}.svg", svgOptions);
}

Konversijos pažangos stebėjimas didelėms darbo knygoms

Kalbant apie darbo knygas, kuriose yra daug grafikų, naudinga sekti konvertavimo pažangą:

// Load a large workbook with many charts
Workbook workbook = new Workbook("EnterpriseReports.xlsx");

// Create a custom stream provider to monitor progress
class ChartConversionStreamProvider : IStreamProvider
{
    private int _totalCharts;
    private int _processedCharts = 0;
    
    public ChartConversionStreamProvider(int totalCharts)
    {
        _totalCharts = totalCharts;
    }
    
    public Stream GetStream(string chartName, StreamType streamType)
    {
        // Create output stream
        string outputPath = $"Chart_{chartName}.png";
        Stream stream = new FileStream(outputPath, FileMode.Create);
        
        // Update and report progress
        _processedCharts++;
        double progressPercentage = (_processedCharts / (double)_totalCharts) * 100;
        Console.WriteLine($"Converting chart {_processedCharts} of {_totalCharts}: {progressPercentage:F1}% complete");
        
        return stream;
    }
    
    public void CloseStream(Stream stream)
    {
        if (stream != null)
        {
            stream.Close();
        }
    }
}

// Count total charts across all worksheets
int totalCharts = 0;
foreach (Worksheet sheet in workbook.Worksheets)
{
    totalCharts += sheet.Charts.Count;
}

// Create stream provider and options
ChartConversionStreamProvider streamProvider = new ChartConversionStreamProvider(totalCharts);
ImageOrPrintOptions options = new ImageOrPrintOptions
{
    HorizontalResolution = 300,
    VerticalResolution = 300
};

// Process each chart with progress tracking
int chartIndex = 0;
foreach (Worksheet sheet in workbook.Worksheets)
{
    foreach (Chart chart in sheet.Charts)
    {
        // Generate unique chart name
        string chartName = $"{sheet.Name}_Chart_{chartIndex++}";
        
        // Convert using stream provider
        chart.ToImage(streamProvider.GetStream(chartName, StreamType.Output), options);
    }
}

Geriausios grafikos į vaizdo konvertavimo praktikos

Norėdami pasiekti optimalius rezultatus konvertuojant „Excel“ grafikus į vaizdus, apsvarstykite šias rekomendacijas:

  • Nustatykite rezoliuciją pagal paskirtį : Naudokite aukštesnius (300+ DPI) leidinius spausdinimo medžiagoms ir mažesnes leidimus žiniatinklio ekranui.
  • ** Pasirinkite teisingą formatą** : Naudokite PNG skaidrumo grafikai, JPEG nuotraukoms ir SVG žiniatinklio programoms.
  • Išbandykite skirtingus kokybės nustatymus : subalansuoti failų dydį ir vaizdo kokybę, ypač JPEG suspaudimui.
  • Sanitize Filenames : Generuojant filenamas iš darbalaukio pavadinimų, pašalinkite neįgalius simbolius.
  • Implement Progress Tracking : Darbo knygoms su daugybe grafikų pateikti naudotojams pažangos atsiliepimus.
  • Tinkamai tvarkykite išteklius : Artimieji srautai ir objektų išdėstymas, kad būtų užkirstas kelias atminties plyšimui.

Conclusion

Aspose.Cells for .NET suteikia galingą, lanksčią sprendimą konvertuoti „Excel“ grafikus į įvairius vaizdo formatus programiniu būdu. Nesvarbu, ar jums reikia aukštos raiškos vaizdų spausdinimo medžiagoms, optimizuotos grafikos žiniatinklio programoms ar vektorinių SVGs reaguojantiems dizainams, „Aspose.“ Cells teikia nuoseklų, kokybiškų rezultatų nereikalauja „Microsoft Excel“ įrengimo.

Sekdami šiame straipsnyje išdėstytus pavyzdžius ir geriausią praktiką, galite integruoti grafikos į vaizdą konvertavimo galimybes į savo .NET programas, pagerinti jūsų duomenų vizualizavimo darbo srautus ir leisti nesąžiningai dalytis „Excel“ pagrindu pagrįstais vaizdais įvairiose platformose ir žiniasklaidos priemonėse.

More in this category