F # charting example

Question

Me gustaría hacer algunos gráficos básicos en F # usando funciones de compilación o una biblioteca gratuita. Y estaría muy contento con un ejemplo muy básico de ello, un gráfico circular si es posible.

Ejemplo datos:

[("John",34);("Sara",30);("Will",20);("Maria",16)] 

Cuando los enteros son porcentajes para ser representados en el pastel.

recientemente he instalado VSLab y aunque encuentro un montón de ejemplos en 3D, sólo estoy buscando un gráfico circular simple ...

También es muy bien utilizar las características de Excel, por cierto, no es libre, pero instalado sin embargo ..

Answer 1

Aquí es algo que rompieron junto con la API de Google Chart, espero que el código es lo suficientemente claro, sin más explicaciones:

//Built with F# 1.9.7.8 
open System.IO 
open System.Net 
open Microsoft.FSharp.Control.WebExtensions 
//Add references for the namespaces below if you're not running this code in F# interactive 
open System.Drawing 
open System.Windows.Forms 

let buildGoogleChartUri input = 
    let chartWidth, chartHeight = 250,100 

    let labels,data = List.unzip input 
    let dataString = 
     data 
     |> List.map (box>>string) //in this way, data can be anything for which ToString() turns it into a number 
     |> List.toArray |> String.concat "," 

    let labelString = labels |> List.toArray |> String.concat "|" 

    sprintf "http://chart.apis.google.com/chart?chs=%dx%d&chd=t:%s&cht=p3&chl=%s" 
      chartWidth chartHeight dataString labelString 

//Bake a bitmap from the google chart URI 
let buildGoogleChart myData = 
    async { 
     let req = HttpWebRequest.Create(buildGoogleChartUri myData) 
     let! response = req.AsyncGetResponse() 
     return new Bitmap(response.GetResponseStream()) 
    } |> Async.RunSynchronously 

//invokes the google chart api to build a chart from the data, and presents the image in a form 
//Excuse the sloppy winforms code 
let test() = 
    let myData = [("John",34);("Sara",30);("Will",20);("Maria",16)] 

    let image = buildGoogleChart myData 
    let frm = new Form() 
    frm.BackgroundImage <- image 
    frm.BackgroundImageLayout <- ImageLayout.Center 
    frm.ClientSize <- image.Size 
    frm.Show() 

Answer 2

es fácil de hacer "hecho en casa" gráfico de sectores : System.Drawing abierta

let red = new SolidBrush(Color.Red) in 
let green = new SolidBrush(Color.Green) in 
let blue = new SolidBrush(Color.Blue) in 
let rec colors = 
    seq { 
    yield red 
    yield green 
    yield blue 
    yield! colors 
    } 


let pie data (g: Graphics) (r: Rectangle) = 
    let vals = 0.0 :: List.map snd data 
    let total = List.sum vals 
    let angles = List.map (fun v -> v/total*360.0) vals 
    let p = new Pen(Color.Black,1) 
    Seq.pairwise vals |> Seq.zip colors |> Seq.iter (fun (c,(a1,a2)) -> g.DrawPie(p,r,a1,a2); g.FillPie(c,r,a1,a2)) 

Answer 3

Originalmente sólo se trató de complementar ejemplo de ssp aquí con una muy simples ventanas de diálogo que muestra formar un pastel. Pero al intentar esto encontré un error en el código de ssp: por un lado Seq.pairwise opera en vals en lugar de angles y por otro lado, obviamente no considera que los sectores de tarta se dibujarán comenzando desde el ángulo de inicio a lo largo del ángulo de barrido.

he corregido el error, comentó, reorganizado, reordenada y renombrado algunas cosas - y lo hizo tanto #load -able en fsi.exe y compilables con fsc.exe:

#light 
module YourNamespace.PieExample 

open System 
open System.Drawing 
open System.ComponentModel 
open System.Windows.Forms 

(* (circular) sequence of three colors *) 
#nowarn "40" 
let red = new SolidBrush(Color.Red) 
let green = new SolidBrush(Color.Green) 
let blue = new SolidBrush(Color.Blue) 
let rec colors = 
    seq { yield red 
      yield green 
      yield blue 
      yield! colors } 

(* core function to build up and show a pie diagram *) 
let pie data (g: Graphics) (r: Rectangle) = 
    // a pen for borders of pie slices 
    let p = new Pen(Color.Black, 1.0f) 
    // retrieve pie shares from data and sum 'em up 
    let vals = List.map snd data 
    let total = List.sum vals 
    // baking a pie starts here with ... 
    vals 
    // scaling vals in total to a full circle 
    |> List.map (fun v -> v * 360.0/total) 
    // transform list of angles to list of pie slice delimiting angles 
    |> List.scan (+) 0.0 
    // turn them into a list of tuples consisting of start and end angles 
    |> Seq.pairwise 
    // intermix the colors successively 
    |> Seq.zip colors 
    // and at last do FillPies and DrawPies with these ingredients 
    |> Seq.iter (fun (c,(starta,enda)) 
        -> g.FillPie(c,r,(float32 starta) 
            ,(float32 (enda - starta))) 
         g.DrawPie(p,r,(float32 starta) 
            ,(float32 (enda - starta)))) 

(* demo data *) 
let demolist = [ ("a", 1.); ("b", 2.); ("c", 3.); 
       ("d", 2.); ("e", 2.); ("f", 2.) ] 

(* finally a simple resizable form showing demo data as pie with 6 slices *) 
let mainform = new Form(MinimumSize = Size(200,200)) 
// add two event handlers 
mainform.Paint.Add (fun e -> pie demolist e.Graphics mainform.ClientRectangle) 
mainform.Resize.Add (fun _ -> mainform.Invalidate()) 
#if COMPILED 
Application.Run(mainform) 
#else 
mainform.ShowDialog() |> ignore 
#endif 

Por último, pero no por eso menos importante, quiero mencionar dos consejos útiles que encontré útil

• in a stackoverflow.com answer by ildjarn donde muestra atontamiento (a t menos para mí) el uso de List.scan
• at a c-sharpcorner.com blog by Shalini Juneja donde se muestra cómo crear y dibujar un simple ventanas de tamaño variable forma de diálogo con F # (de hecho, ella también muestra cómo mostrar un pastel)

Answer 4

vieja pregunta, pero tecnología cambiante

en vs 2013, F # 3, y la instalación de la Nuget paquete

Install-Package FSharp.Charting 

Añadir referencia a:

System.Windows.Forms 
    System.Windows.Forms.DataVisualization 

y con una línea de código:

 Application.Run ((Chart.Pie data).ShowChart()) 

La siguiente El código F # genera la tabla bie:

open System 
open System.Windows.Forms 
open FSharp.Charting 

[<EntryPoint>] 
let main argv = 
    Application.EnableVisualStyles() 
    Application.SetCompatibleTextRenderingDefault false 
    let data =[("John",34);("Sara",30);("Will",20);("Maria",16)]  
    Application.Run ((Chart.Pie data).ShowChart()) 
    0 

y se obtiene la siguiente tabla: