From bdcbd52c6236cd0156293b72dc0d8a5b064f4a14 Mon Sep 17 00:00:00 2001 From: Kevin Schneider Date: Fri, 17 Sep 2021 15:41:52 +0200 Subject: [PATCH 1/7] Add Image trace style --- .../CommonAbstractions/StyleParams.fs | 38 ++++++++++ src/Plotly.NET/Traces/Trace2D.fs | 71 +++++++++++++++++++ 2 files changed, 109 insertions(+) diff --git a/src/Plotly.NET/CommonAbstractions/StyleParams.fs b/src/Plotly.NET/CommonAbstractions/StyleParams.fs index f0e5dc362..85ff7f72c 100644 --- a/src/Plotly.NET/CommonAbstractions/StyleParams.fs +++ b/src/Plotly.NET/CommonAbstractions/StyleParams.fs @@ -314,6 +314,44 @@ module StyleParam = // #C# //-------------------------- + + [] + type ColorModel = + | RGB + | RGBA + | RGBA256 + | HSL + | HSLA + + static member toString = function + | RGB -> "rgb" + | RGBA -> "rgba" + | RGBA256 -> "rgba256" + | HSL -> "hsl" + | HSLA -> "hsla" + + static member convert = ColorModel.toString >> box + override this.ToString() = this |> ColorModel.toString + member this.Convert() = this |> ColorModel.convert + + [] + type ColorComponentBound = + | RGB of R:int * G:int * B:int + | RGBA of R:int * G:int * B:int * A:int + | RGBA256 of int*int*int*int + | HSL of H:int * S:int * L:int + | HSLA of H:int * S:int * L:int * A:int + + static member convert = function + | RGB (r,g,b) -> [r;g;b] |> box + | RGBA (r,g,b,a) -> [r;g;b;a] |> box + | RGBA256 (i,d,k,m) -> [i;d;k;m] |> box + | HSL (h,s,l) -> [h;s;l] |> box + | HSLA (h,s,l,a) -> [h;s;l;a] |> box + + member this.Convert() = this |> ColorComponentBound.convert + + [] type ClickToShow = | False | OnOff | OnOut diff --git a/src/Plotly.NET/Traces/Trace2D.fs b/src/Plotly.NET/Traces/Trace2D.fs index eeb4bffaf..760c8d276 100644 --- a/src/Plotly.NET/Traces/Trace2D.fs +++ b/src/Plotly.NET/Traces/Trace2D.fs @@ -946,6 +946,77 @@ type Trace2DStyle() = // out -> heatmap ) + + // Applies the styles of heatmap to TraceObjects + static member Image + ( + [] ?Name : string, + [] ?Visible : StyleParam.Visible, + [] ?ShowLegend : bool, + [] ?LegendRank : int, + [] ?LegendGroup : string, + [] ?LegendGroupTitle : Title, + [] ?Opacity : float, + [] ?Ids : seq<#IConvertible>, + [] ?X : seq<#IConvertible>, + [] ?X0 : #IConvertible, + [] ?DX : #IConvertible, + [] ?Y : seq<#IConvertible>, + [] ?Y0 : #IConvertible, + [] ?DY : #IConvertible, + [] ?Z : seq<#seq<#IConvertible>>, + [] ?Source : string, + [] ?Text : seq<#IConvertible>, + [] ?HoverText : string, + [] ?HoverInfo : StyleParam.HoverInfo, + [] ?HoverTemplate : string, + [] ?Meta : string, + [] ?CustomData : seq<#IConvertible>, + [] ?XAxis : StyleParam.LinearAxisId, + [] ?YAxis : StyleParam.LinearAxisId, + [] ?ColorModel : StyleParam.ColorModel, + [] ?ZMax : StyleParam.ColorComponentBound, + [] ?ZMin : StyleParam.ColorComponentBound, + [] ?ZSmooth : StyleParam.SmoothAlg, + [] ?HoverLabel : Hoverlabel, + [] ?UIRevision : string + ) = + (fun (image: ('T :> Trace)) -> + + Name |> DynObj.setValueOpt image "name" + Visible |> DynObj.setValueOptBy image "visible" StyleParam.Visible.convert + ShowLegend |> DynObj.setValueOpt image "showlegend" + LegendRank |> DynObj.setValueOpt image "legendrank" + LegendGroup |> DynObj.setValueOpt image "legendgroup" + LegendGroupTitle |> DynObj.setValueOpt image "legendgrouptitle" + Opacity |> DynObj.setValueOpt image "opacity" + Ids |> DynObj.setValueOpt image "ids" + X |> DynObj.setValueOpt image "x" + X0 |> DynObj.setValueOpt image "x0" + DX |> DynObj.setValueOpt image "dx" + Y |> DynObj.setValueOpt image "y" + Y0 |> DynObj.setValueOpt image "y0" + DY |> DynObj.setValueOpt image "dy" + Z |> DynObj.setValueOpt image "z" + Source |> DynObj.setValueOpt image "source" + Text |> DynObj.setValueOpt image "text" + HoverText |> DynObj.setValueOpt image "hovertext" + HoverInfo |> DynObj.setValueOptBy image "hoverinfo" StyleParam.HoverInfo.convert + HoverTemplate |> DynObj.setValueOpt image "hovertemplate" + Meta |> DynObj.setValueOpt image "meta" + CustomData |> DynObj.setValueOpt image "customdata" + XAxis |> DynObj.setValueOptBy image "xaxis" StyleParam.LinearAxisId.convert + YAxis |> DynObj.setValueOptBy image "yaxis" StyleParam.LinearAxisId.convert + ColorModel |> DynObj.setValueOptBy image "colormodel" StyleParam.ColorModel.convert + ZMax |> DynObj.setValueOptBy image "zmax" StyleParam.ColorComponentBound.convert + ZMin |> DynObj.setValueOptBy image "zmin" StyleParam.ColorComponentBound.convert + ZSmooth |> DynObj.setValueOptBy image "zsmooth" StyleParam.SmoothAlg.convert + HoverLabel |> DynObj.setValueOpt image "hoverlabel" + UIRevision |> DynObj.setValueOpt image "uirevision" + + // out -> + image + ) static member Contour From 1a35c0264a1c22a9b010ae7baa9c649b35fae6f3 Mon Sep 17 00:00:00 2001 From: Kevin Schneider Date: Sun, 19 Sep 2021 09:15:40 +0200 Subject: [PATCH 2/7] Add Chart.Image --- src/Plotly.NET/ChartAPI/Chart2D.fs | 72 ++++++++++++++++++++++++++++++ src/Plotly.NET/Playground.fsx | 32 ++++++++++++- src/Plotly.NET/Traces/Trace2D.fs | 2 +- 3 files changed, 104 insertions(+), 2 deletions(-) diff --git a/src/Plotly.NET/ChartAPI/Chart2D.fs b/src/Plotly.NET/ChartAPI/Chart2D.fs index 09b8382ec..48d9a5dce 100644 --- a/src/Plotly.NET/ChartAPI/Chart2D.fs +++ b/src/Plotly.NET/ChartAPI/Chart2D.fs @@ -1436,6 +1436,78 @@ module Chart2D = Chart.renderHeatmapTrace useWebGL style + [] + static member Image + ( + [] ?Z : seq<#seq<#seq>>, + [] ?Source : string, + [] ?Name : string, + [] ?ShowLegend : bool, + [] ?Opacity : float, + [] ?Ids : seq<#IConvertible>, + [] ?X : seq<#IConvertible>, + [] ?Y : seq<#IConvertible>, + [] ?ColorModel : StyleParam.ColorModel, + [] ?ZMax : StyleParam.ColorComponentBound, + [] ?ZMin : StyleParam.ColorComponentBound, + [] ?ZSmooth : StyleParam.SmoothAlg + ) = + + Trace2D.initImage ( + Trace2DStyle.Image ( + ?Z = Z , + ?Source = Source , + ?Name = Name , + ?ShowLegend = ShowLegend, + ?Opacity = Opacity , + ?Ids = Ids , + ?X = X , + ?Y = Y , + ?ColorModel = ColorModel, + ?ZMax = ZMax , + ?ZMin = ZMin , + ?ZSmooth = ZSmooth + ) + ) + |> GenericChart.ofTraceObject + + [] + static member Image + ( + z : seq<#seq>, + [] ?Name : string, + [] ?ShowLegend : bool, + [] ?Opacity : float, + [] ?Ids : seq<#IConvertible>, + [] ?X : seq<#IConvertible>, + [] ?Y : seq<#IConvertible>, + [] ?ZMax : StyleParam.ColorComponentBound, + [] ?ZMin : StyleParam.ColorComponentBound, + [] ?ZSmooth : StyleParam.SmoothAlg + ) = + + let z' = + z + |> Seq.map (Seq.map (fun argb -> seq{int argb.R; int argb.G; int argb.B; int argb.A;})) + + + Trace2D.initImage ( + Trace2DStyle.Image ( + Z = z' , + ?Name = Name , + ?ShowLegend = ShowLegend, + ?Opacity = Opacity , + ?Ids = Ids , + ?X = X , + ?Y = Y , + ColorModel = StyleParam.ColorModel.RGBA, + ?ZMax = ZMax , + ?ZMin = ZMin , + ?ZSmooth = ZSmooth + ) + ) + |> GenericChart.ofTraceObject + /// Shows a graphical representation of data where the individual values contained in a matrix are represented as colors. [] static member Contour(data:seq<#seq<#IConvertible>>, diff --git a/src/Plotly.NET/Playground.fsx b/src/Plotly.NET/Playground.fsx index 6f6148345..3f18ed085 100644 --- a/src/Plotly.NET/Playground.fsx +++ b/src/Plotly.NET/Playground.fsx @@ -27,10 +27,10 @@ #load "Margin.fs" #load "Domain.fs" #load "Shape.fs" +#load "Hoverlabel.fs" #load "Annotation.fs" #load "LayoutGrid.fs" #load "Legend.fs" -#load "Hoverlabel.fs" #load "TickFormatStop.fs" #load "ColorBar.fs" #load "Rangebreak.fs" @@ -153,6 +153,36 @@ open FSharpAux open System open System.IO +let imagebase64 = + System.Convert.ToBase64String(File.ReadAllBytes(@"C:\Users\schne\Pictures\Untitled.jpg")) + +Chart.Image( + Source=($"data:image/jpg;base64,{imagebase64}") +) +|> Chart.show + +let colors = [ + [[0 ;0 ;255]; [255;255;0 ]; [0 ;0 ;255]] + [[255;0 ;0 ]; [255;0 ;255]; [255;0 ;255]] + [[0 ;255;0 ]; [0 ;255;255]; [255;0 ;0 ]] +] + +Chart.Image( + Z=colors +) +|> Chart.show + +let argbs = [ + [(0 ,0 ,255); (0 ,255,255); (0 ,0 ,255)] |> List.map (fun (r,g,b) -> ARGB.fromRGB r g b ) + [(255,0 ,0 ); (255,0 ,255); (0 ,0 ,0 )] |> List.map (fun (r,g,b) -> ARGB.fromRGB r g b ) + [(0 ,255,0 ); (255,255,0 ); (0 ,0 ,255)] |> List.map (fun (r,g,b) -> ARGB.fromRGB r g b ) +] + +Chart.Image( + argbs +) +|> Chart.show + Chart.ScatterTernary( A = [1; 2; 3], B = [3; 2; 1], diff --git a/src/Plotly.NET/Traces/Trace2D.fs b/src/Plotly.NET/Traces/Trace2D.fs index 760c8d276..cc2fba620 100644 --- a/src/Plotly.NET/Traces/Trace2D.fs +++ b/src/Plotly.NET/Traces/Trace2D.fs @@ -964,7 +964,7 @@ type Trace2DStyle() = [] ?Y : seq<#IConvertible>, [] ?Y0 : #IConvertible, [] ?DY : #IConvertible, - [] ?Z : seq<#seq<#IConvertible>>, + [] ?Z : #seq<#seq<#seq>>, [] ?Source : string, [] ?Text : seq<#IConvertible>, [] ?HoverText : string, From c85460040e09df053bc5d697d35282453a6a4782 Mon Sep 17 00:00:00 2001 From: Kevin Schneider Date: Sun, 19 Sep 2021 09:53:56 +0200 Subject: [PATCH 3/7] Add LayoutImage object --- .../CommonAbstractions/StyleParams.fs | 16 ++++ src/Plotly.NET/Layout/Layout.fs | 10 ++- .../ObjectAbstractions/Common/LayoutImage.fs | 87 +++++++++++++++++++ src/Plotly.NET/Plotly.NET.fsproj | 1 + 4 files changed, 111 insertions(+), 3 deletions(-) create mode 100644 src/Plotly.NET/Layout/ObjectAbstractions/Common/LayoutImage.fs diff --git a/src/Plotly.NET/CommonAbstractions/StyleParams.fs b/src/Plotly.NET/CommonAbstractions/StyleParams.fs index 85ff7f72c..6fe57ac23 100644 --- a/src/Plotly.NET/CommonAbstractions/StyleParams.fs +++ b/src/Plotly.NET/CommonAbstractions/StyleParams.fs @@ -1119,7 +1119,23 @@ module StyleParam = // #L# //-------------------------- + + /// Specifies whether shapes are drawn below or above traces. Default is Above + [] + type LayoutImageSizing = + | Fill + | Contain + | Stretch + static member toString = function + | Fill -> "fill" + | Contain -> "contain" + | Stretch -> "stretch" + + static member convert = LayoutImageSizing.toString >> box + override this.ToString() = this |> LayoutImageSizing.toString + member this.Convert() = this |> LayoutImageSizing.convert + /// Specifies whether shapes are drawn below or above traces. Default is Above [] type Layer = diff --git a/src/Plotly.NET/Layout/Layout.fs b/src/Plotly.NET/Layout/Layout.fs index 1f93891b7..050d940ae 100644 --- a/src/Plotly.NET/Layout/Layout.fs +++ b/src/Plotly.NET/Layout/Layout.fs @@ -76,7 +76,8 @@ type Layout() = [] ?ExtendIcicleColors : bool, [] ?IcicleColorWay : Color, [] ?Annotations : seq, - [] ?Shapes : seq + [] ?Shapes : seq, + [] ?Images : seq ) = Layout() |> Layout.style @@ -145,7 +146,8 @@ type Layout() = ?ExtendIcicleColors = ExtendIcicleColors , ?IcicleColorWay = IcicleColorWay , ?Annotations = Annotations , - ?Shapes = Shapes + ?Shapes = Shapes , + ?Images = Images ) // Applies the styles to Layout() @@ -215,7 +217,8 @@ type Layout() = [] ?ExtendIcicleColors : bool, [] ?IcicleColorWay : Color, [] ?Annotations : seq, - [] ?Shapes : seq + [] ?Shapes : seq, + [] ?Images : seq ) = (fun (layout:Layout) -> @@ -284,6 +287,7 @@ type Layout() = IcicleColorWay |> DynObj.setValueOpt layout "iciclecolorway" Annotations |> DynObj.setValueOpt layout "annotations" Shapes |> DynObj.setValueOpt layout "shapes" + Images |> DynObj.setValueOpt layout "images" layout ) diff --git a/src/Plotly.NET/Layout/ObjectAbstractions/Common/LayoutImage.fs b/src/Plotly.NET/Layout/ObjectAbstractions/Common/LayoutImage.fs new file mode 100644 index 000000000..e14ac7740 --- /dev/null +++ b/src/Plotly.NET/Layout/ObjectAbstractions/Common/LayoutImage.fs @@ -0,0 +1,87 @@ +namespace Plotly.NET.LayoutObjects + +open Plotly.NET +open DynamicObj +open System +open System.Runtime.InteropServices + +/// Dimensions type inherits from dynamic object +type LayoutImage () = + inherit DynamicObj () + + static member init + ( + ?Layer : StyleParam.Layer, + ?Name : string, + ?Opacity : float, + ?SizeX : int, + ?SizeY : int, + ?Sizing : StyleParam.LayoutImageSizing, + ?Source : string, + ?TemplateItemname : string, + ?Visible : bool, + ?X : #IConvertible, + ?XAnchor : StyleParam.XAnchorPosition, + ?XRef : string, + ?Y : #IConvertible, + ?YAnchor : StyleParam.YAnchorPosition, + ?YRef : string + ) = + LayoutImage () + |> LayoutImage.style + ( + ?Layer = Layer , + ?Name = Name , + ?Opacity = Opacity , + ?SizeX = SizeX , + ?SizeY = SizeY , + ?Sizing = Sizing , + ?Source = Source , + ?TemplateItemname = TemplateItemname, + ?Visible = Visible , + ?X = X , + ?XAnchor = XAnchor , + ?XRef = XRef , + ?Y = Y , + ?YAnchor = YAnchor , + ?YRef = YRef + ) + + static member style + ( + ?Layer : StyleParam.Layer, + ?Name : string, + ?Opacity : float, + ?SizeX : int, + ?SizeY : int, + ?Sizing : StyleParam.LayoutImageSizing, + ?Source : string, + ?TemplateItemname : string, + ?Visible : bool, + ?X : #IConvertible, + ?XAnchor : StyleParam.XAnchorPosition, + ?XRef : string, + ?Y : #IConvertible, + ?YAnchor : StyleParam.YAnchorPosition, + ?YRef : string + ) = + (fun (layoutImage:LayoutImage) -> + + Layer |> DynObj.setValueOptBy layoutImage "layer" StyleParam.Layer.convert + Name |> DynObj.setValueOpt layoutImage "name" + Opacity |> DynObj.setValueOpt layoutImage "opacity" + SizeX |> DynObj.setValueOpt layoutImage "sizex" + SizeY |> DynObj.setValueOpt layoutImage "sizey" + Sizing |> DynObj.setValueOptBy layoutImage "sizing" StyleParam.LayoutImageSizing.convert + Source |> DynObj.setValueOpt layoutImage "source" + TemplateItemname |> DynObj.setValueOpt layoutImage "templateitemname" + Visible |> DynObj.setValueOpt layoutImage "visible" + X |> DynObj.setValueOpt layoutImage "x" + XAnchor |> DynObj.setValueOptBy layoutImage "xanchor" StyleParam.XAnchorPosition.convert + XRef |> DynObj.setValueOpt layoutImage "xref" + Y |> DynObj.setValueOpt layoutImage "y" + YAnchor |> DynObj.setValueOptBy layoutImage "yanchor" StyleParam.YAnchorPosition.convert + YRef |> DynObj.setValueOpt layoutImage "yref" + + layoutImage + ) \ No newline at end of file diff --git a/src/Plotly.NET/Plotly.NET.fsproj b/src/Plotly.NET/Plotly.NET.fsproj index 55b0fe870..5ca1a0253 100644 --- a/src/Plotly.NET/Plotly.NET.fsproj +++ b/src/Plotly.NET/Plotly.NET.fsproj @@ -41,6 +41,7 @@ + From acb3b9c9bde707d75119c44650876884467262eb Mon Sep 17 00:00:00 2001 From: Kevin Schneider Date: Sun, 19 Sep 2021 09:54:22 +0200 Subject: [PATCH 4/7] Add Chart.withLayoutImage(s), adapt Chart.withShape(s) --- .../CSharpLayer/GenericChartExtensions.fs | 35 ++++--- src/Plotly.NET/ChartAPI/Chart.fs | 98 ++++++++++++++++--- src/Plotly.NET/Playground.fsx | 18 ++++ 3 files changed, 123 insertions(+), 28 deletions(-) diff --git a/src/Plotly.NET/CSharpLayer/GenericChartExtensions.fs b/src/Plotly.NET/CSharpLayer/GenericChartExtensions.fs index ea2cf11c0..bae45b65c 100644 --- a/src/Plotly.NET/CSharpLayer/GenericChartExtensions.fs +++ b/src/Plotly.NET/CSharpLayer/GenericChartExtensions.fs @@ -493,12 +493,15 @@ module GenericChartExtensions = member this.WithConfig (config:Config) = GenericChart.setConfig config this + [] + [] + member this.WithAnnotation(annotation:Annotation, []?Append:bool) = + this |> Chart.withAnnotation(annotation, ?Append = Append) + [] [] - member this.WithAnnotations(annotations:seq) = - this - |> GenericChart.mapLayout - (Layout.style (Annotations = annotations)) + member this.WithAnnotations(annotations:Annotation seq, []?Append:bool) = + this |> Chart.withAnnotations(annotations, ?Append = Append) // Set the title of a Chart [] @@ -574,19 +577,13 @@ module GenericChartExtensions = //(`x0`,`y0`), (`x1`,`y0`), (`x1`,`y1`), (`x0`,`y1`), (`x0`,`y0`) [] [] - member this.WithShape(shape:Shape) = - let layout = - GenericChart.getLayout this - |> Layout.style (Shapes=[shape]) - GenericChart.setLayout layout this + member this.WithShape(shape:Shape, []?Append:bool) = + this |> Chart.withShape(shape, ?Append = Append) [] [] - member this.WithShapes(shapes:Shape seq) = - let layout = - GenericChart.getLayout this - |> Layout.style (Shapes=shapes) - GenericChart.setLayout layout this + member this.WithShapes(shapes:Shape seq, []?Append:bool) = + this |> Chart.withShapes(shapes, ?Append = Append) // ############################################################ // ####################### Apply to DisplayOptions @@ -664,3 +661,13 @@ module GenericChartExtensions = member this.WithTernary(ternary:Ternary, [] ?Id) = this |> Chart.withTernary(ternary,?Id=Id) + + [] + [] + member this.WithLayoutImage(image:LayoutImage, []?Append:bool) = + this |> Chart.withLayoutImage(image, ?Append = Append) + + [] + [] + member this.WithLayoutImages(images:seq, []?Append:bool) = + this |> Chart.withLayoutImages(images, ?Append = Append) \ No newline at end of file diff --git a/src/Plotly.NET/ChartAPI/Chart.fs b/src/Plotly.NET/ChartAPI/Chart.fs index d9c82bc3b..adef70048 100644 --- a/src/Plotly.NET/ChartAPI/Chart.fs +++ b/src/Plotly.NET/ChartAPI/Chart.fs @@ -823,6 +823,14 @@ type Chart = |> GenericChart.mapLayout (Layout.style (Annotations = annotations')) + [] + static member withAnnotation + ( + annotation: Annotation, + [] ?Append: bool + ) = + Chart.withAnnotations([annotation], ?Append = Append) + // Set the title of a Chart [] static member withTitle(title,[] ?TitleFont) = @@ -911,23 +919,45 @@ type Chart = //Specifies the shape type to be drawn. If "line", a line is drawn from (`x0`,`y0`) to (`x1`,`y1`) If "circle", a circle is drawn from //((`x0`+`x1`)/2, (`y0`+`y1`)/2)) with radius (|(`x0`+`x1`)/2 - `x0`|, |(`y0`+`y1`)/2 -`y0`)|) If "rect", a rectangle is drawn linking //(`x0`,`y0`), (`x1`,`y0`), (`x1`,`y1`), (`x0`,`y1`), (`x0`,`y0`) - [] - static member withShape(shape:Shape) = - (fun (ch:GenericChart) -> - let layout = - GenericChart.getLayout ch - |> Layout.style (Shapes=[shape]) - GenericChart.setLayout layout ch) + + /// + /// + /// + /// The shapes to add to the input charts layout + /// If true, the input annotations will be appended to existing annotations, otherwise existing annotations will be removed (default: true) + [] + static member withShapes + ( + shapes:seq, + [] ?Append: bool + ) = + let append = defaultArg Append true + fun (ch:GenericChart) -> + + let shapes' = - [] - static member withShapes(shapes:Shape seq) = - (fun (ch:GenericChart) -> - let layout = - GenericChart.getLayout ch - |> Layout.style (Shapes=shapes) - GenericChart.setLayout layout ch) + if append then + + let layout = GenericChart.getLayout ch + + layout.TryGetTypedValue>("shapes") + |> Option.defaultValue Seq.empty + |> Seq.append shapes + + else shapes + + ch + |> GenericChart.mapLayout + (Layout.style (Shapes = shapes')) + [] + static member withShape + ( + shape: Shape, + [] ?Append: bool + ) = + Chart.withShapes([shape], ?Append = Append) // ####################### /// Create a combined chart with the given charts merged @@ -1491,3 +1521,43 @@ type Chart = GenericChart.setLayout updatedLayout ch ) + + /// + /// + /// + /// The images to add to the input charts layout + /// If true, the input images will be appended to existing annotations, otherwise existing annotations will be removed (default: true) + [] + static member withLayoutImages + ( + images:seq, + [] ?Append: bool + ) = + let append = defaultArg Append true + + fun (ch:GenericChart) -> + + let images' = + + if append then + + let layout = GenericChart.getLayout ch + + layout.TryGetTypedValue>("images") + |> Option.defaultValue Seq.empty + |> Seq.append images + + else images + + ch + |> GenericChart.mapLayout + (Layout.style (Images = images')) + + [] + static member withLayoutImage + ( + image: LayoutImage, + [] ?Append: bool + ) = + + Chart.withLayoutImages([image], ?Append = Append) \ No newline at end of file diff --git a/src/Plotly.NET/Playground.fsx b/src/Plotly.NET/Playground.fsx index 3f18ed085..b579e132a 100644 --- a/src/Plotly.NET/Playground.fsx +++ b/src/Plotly.NET/Playground.fsx @@ -16,6 +16,7 @@ #I "Layout/ObjectAbstractions/Common" +#load "LayoutImage.fs" #load "Button.fs" #load "RangeSelector.fs" #load "RangeSlider.fs" @@ -153,6 +154,23 @@ open FSharpAux open System open System.IO +Chart.Line([0.; 0.5; 1.; 2.; 2.2], y=[1.23; 2.5; 0.42; 3.; 1.]) +|> Chart.withLayoutImage( + LayoutImage.init( + Source="https://fsharp.org/img/logo/fsharp.svg", + XRef="x", + YRef="y", + X=0, + Y=3, + SizeX=2, + SizeY=2, + Sizing=StyleParam.LayoutImageSizing.Stretch, + Opacity=0.5, + Layer=StyleParam.Layer.Below + ) +) +|> Chart.show + let imagebase64 = System.Convert.ToBase64String(File.ReadAllBytes(@"C:\Users\schne\Pictures\Untitled.jpg")) From b29a51bcfd89470e0b7a14b7335b00ca51778225 Mon Sep 17 00:00:00 2001 From: Kevin Schneider Date: Sun, 19 Sep 2021 10:08:43 +0200 Subject: [PATCH 5/7] Add layoutimage docs --- Plotly.NET.sln | 1 + docs/01_5_layout_images.fsx | 76 ++++++++++++++++++++++++ docs/10_0_ternary_line_scatter_plots.fsx | 2 +- docs/10_1_styling_ternary_layouts.fsx | 4 +- 4 files changed, 80 insertions(+), 3 deletions(-) create mode 100644 docs/01_5_layout_images.fsx diff --git a/Plotly.NET.sln b/Plotly.NET.sln index ba7fa9ca6..d68e54db6 100644 --- a/Plotly.NET.sln +++ b/Plotly.NET.sln @@ -49,6 +49,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "docs", "docs", "{7B09CC0A-F docs\01_2_multiple-charts.fsx = docs\01_2_multiple-charts.fsx docs\01_3_shapes.fsx = docs\01_3_shapes.fsx docs\01_4_annotations.fsx = docs\01_4_annotations.fsx + docs\01_5_layout_images.fsx = docs\01_5_layout_images.fsx docs\02_0_line-scatter-plots.fsx = docs\02_0_line-scatter-plots.fsx docs\02_1_bar-and-column-charts.fsx = docs\02_1_bar-and-column-charts.fsx docs\02_2_area-plots.fsx = docs\02_2_area-plots.fsx diff --git a/docs/01_5_layout_images.fsx b/docs/01_5_layout_images.fsx new file mode 100644 index 000000000..72b680721 --- /dev/null +++ b/docs/01_5_layout_images.fsx @@ -0,0 +1,76 @@ +(** +--- +title: Layout images +category: Chart Layout +categoryindex: 2 +index: 6 +--- +*) + +(*** hide ***) + +(*** condition: prepare ***) +#r "nuget: Newtonsoft.JSON, 12.0.3" +#r "nuget: DynamicObj" +#r "../bin/Plotly.NET/netstandard2.0/Plotly.NET.dll" + +(*** condition: ipynb ***) +#if IPYNB +#r "nuget: Plotly.NET, {{fsdocs-package-version}}" +#r "nuget: Plotly.NET.Interactive, {{fsdocs-package-version}}" +#endif // IPYNB + +(** +# Annotations + +[![Binder]({{root}}img/badge-binder.svg)](https://mybinder.org/v2/gh/plotly/Plotly.NET/gh-pages?filepath={{fsdocs-source-basename}}.ipynb)  +[![Script]({{root}}img/badge-script.svg)]({{root}}{{fsdocs-source-basename}}.fsx)  +[![Notebook]({{root}}img/badge-notebook.svg)]({{root}}{{fsdocs-source-basename}}.ipynb) + + +*Summary:* This example shows how to create Images and add them to the Charts in F#. + +let's first create some data for the purpose of creating example charts: + +*) + +open Plotly.NET + +let x = [1.; 2.; 3.; 4.; 5.; 6.; 7.; 8.; 9.; 10.; ] +let y' = [2.; 1.5; 5.; 1.5; 3.; 2.5; 2.5; 1.5; 3.5; 1.] + +(** +use the `LayoutImage.init` function to generate an image, and either the `Chart.withLayoutImage` or the `Chart.withLayoutImages` function to add +multiple annotations at once. + +*) + +open Plotly.NET.LayoutObjects + +let image = + LayoutImage.init( + Source="https://fsharp.org/img/logo/fsharp.svg", + XRef="x", + YRef="y", + X=0, + Y=3, + SizeX=2, + SizeY=2, + Sizing=StyleParam.LayoutImageSizing.Stretch, + Opacity=0.5, + Layer=StyleParam.Layer.Below + ) + +let imageChart = + Chart.Line(x,y',Name="line") + |> Chart.withLayoutImage(image) + +(*** condition: ipynb ***) +#if IPYNB +imageChart +#endif // IPYNB + +(***hide***) +imageChart |> GenericChart.toChartHTML +(***include-it-raw***) + diff --git a/docs/10_0_ternary_line_scatter_plots.fsx b/docs/10_0_ternary_line_scatter_plots.fsx index 3f9af2161..668ca0c73 100644 --- a/docs/10_0_ternary_line_scatter_plots.fsx +++ b/docs/10_0_ternary_line_scatter_plots.fsx @@ -2,7 +2,7 @@ --- title: Ternary line and scatter plots category: Ternary Plots -categoryindex: 10 +categoryindex: 11 index: 1 --- *) diff --git a/docs/10_1_styling_ternary_layouts.fsx b/docs/10_1_styling_ternary_layouts.fsx index 2e4cfca38..3d55169aa 100644 --- a/docs/10_1_styling_ternary_layouts.fsx +++ b/docs/10_1_styling_ternary_layouts.fsx @@ -2,8 +2,8 @@ --- title: Styling ternary layouts category: Ternary Plots -categoryindex: 9 -index: 3 +categoryindex: 11 +index: 2 --- *) From e69aaa5f00e13c5e9d3468b0a6646210fae8b913 Mon Sep 17 00:00:00 2001 From: Kevin Schneider Date: Mon, 20 Sep 2021 10:45:26 +0200 Subject: [PATCH 6/7] Add Image docs --- Plotly.NET.sln | 1 + docs/02_8_Images.fsx | 130 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 131 insertions(+) create mode 100644 docs/02_8_Images.fsx diff --git a/Plotly.NET.sln b/Plotly.NET.sln index d68e54db6..da836e59c 100644 --- a/Plotly.NET.sln +++ b/Plotly.NET.sln @@ -58,6 +58,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "docs", "docs", "{7B09CC0A-F docs\02_5_pie-doughnut-charts.fsx = docs\02_5_pie-doughnut-charts.fsx docs\02_6_table.fsx = docs\02_6_table.fsx docs\02_7_heatmaps.fsx = docs\02_7_heatmaps.fsx + docs\02_8_Images.fsx = docs\02_8_Images.fsx docs\03_0_3d-scatter-plots.fsx = docs\03_0_3d-scatter-plots.fsx docs\03_1_3d-surface-plots.fsx = docs\03_1_3d-surface-plots.fsx docs\03_2_3d-mesh-plots.fsx = docs\03_2_3d-mesh-plots.fsx diff --git a/docs/02_8_Images.fsx b/docs/02_8_Images.fsx new file mode 100644 index 000000000..e00f11128 --- /dev/null +++ b/docs/02_8_Images.fsx @@ -0,0 +1,130 @@ +(** +--- +title: Images +category: Simple Charts +categoryindex: 3 +index: 9 +--- +*) + +(*** hide ***) + +(*** condition: prepare ***) +#r "nuget: Newtonsoft.JSON, 12.0.3" +#r "nuget: DynamicObj" +#r "../bin/Plotly.NET/netstandard2.0/Plotly.NET.dll" + +(*** condition: ipynb ***) +#if IPYNB +#r "nuget: Plotly.NET, {{fsdocs-package-version}}" +#r "nuget: Plotly.NET.Interactive, {{fsdocs-package-version}}" +#endif // IPYNB + +(** +# Images + +[![Binder]({{root}}img/badge-binder.svg)](https://mybinder.org/v2/gh/plotly/Plotly.NET/gh-pages?filepath={{fsdocs-source-basename}}.ipynb)  +[![Script]({{root}}img/badge-script.svg)]({{root}}{{fsdocs-source-basename}}.fsx)  +[![Notebook]({{root}}img/badge-notebook.svg)]({{root}}{{fsdocs-source-basename}}.ipynb) + +*Summary:* This example shows how to create image charts in F#. + +There are multiple ways of generating image charts: + - From 3 Dimensional color collections, where the inner arrays contain 3 (color dimensions without alpha channel) or 4 (color dimensions and alpha channel) values. The color model can be set separately as shown below. + - From a 2 dimensional collection Plotly.NETs `ARGB` type that represents rgba values + - From a base64 encoded image data source + +## Creating Image charts from raw color arrays +*) + +// 3d collection containing color values +open Plotly.NET + +let colors = [ + [[0 ;0 ;255]; [255;255;0 ]; [0 ;0 ;255]] + [[255;0 ;0 ]; [255;0 ;255]; [255;0 ;255]] + [[0 ;255;0 ]; [0 ;255;255]; [255;0 ;0 ]] +] + +let imageRaw = + Chart.Image(Z=colors) + |> Chart.withTitle "Image chart from raw color component arrays" + +(*** condition: ipynb ***) +#if IPYNB +imageRaw +#endif // IPYNB + +(***hide***) +imageRaw |> GenericChart.toChartHTML +(***include-it-raw***) + +(** +To change the color model to HSL for example, add the `ColorModel` argument: +*) + +let imageRawHSL = + Chart.Image(Z=colors, ColorModel=StyleParam.ColorModel.HSL) + |> Chart.withTitle "HSL color model" + +(*** condition: ipynb ***) +#if IPYNB +imageRawHSL +#endif // IPYNB + +(***hide***) +imageRawHSL |> GenericChart.toChartHTML +(***include-it-raw***) + +(** +## Creating Image charts from ARGB arrays + +Note that this way of creating image charts uses the RGBA color model. +*) + +let argbs = [ + [ColorKeyword.AliceBlue ; ColorKeyword.CornSilk ; ColorKeyword.LavenderBlush ] |> List.map ARGB.fromKeyword + [ColorKeyword.DarkGray ; ColorKeyword.Snow ; ColorKeyword.MidnightBlue ] |> List.map ARGB.fromKeyword + [ColorKeyword.LightSteelBlue; ColorKeyword.DarkKhaki; ColorKeyword.LightAkyBlue ] |> List.map ARGB.fromKeyword +] + +let imageARGB = + Chart.Image(argbs) + |> Chart.withTitle "ARGB image chart" + +(*** condition: ipynb ***) +#if IPYNB +imageARGB +#endif // IPYNB + +(***hide***) +imageARGB |> GenericChart.toChartHTML +(***include-it-raw***) + +(** +## Creating Image charts from base64 encoded images +*) +open System +open System.IO + +let imageSource = $@"{__SOURCE_DIRECTORY__}/img/logo.png" + +let base64String = + imageSource + |> File.ReadAllBytes + |> System.Convert.ToBase64String + +let logoImage = + Chart.Image( + Source=($"data:image/jpg;base64,{base64String}") + ) + |> Chart.withTitle "This is Plotly.NET:" + +(*** condition: ipynb ***) +#if IPYNB +logoImage +#endif // IPYNB + +(***hide***) +logoImage |> GenericChart.toChartHTML +(***include-it-raw***) From e17e533e7c4abf75da6c901502e838e30ea777f6 Mon Sep 17 00:00:00 2001 From: Kevin Schneider Date: Mon, 20 Sep 2021 11:27:32 +0200 Subject: [PATCH 7/7] Add image chart tests --- .../HtmlCodegen/SimpleCharts.fs | 87 +++++++++++++++++++ 1 file changed, 87 insertions(+) diff --git a/tests/Plotly.NET.Tests/HtmlCodegen/SimpleCharts.fs b/tests/Plotly.NET.Tests/HtmlCodegen/SimpleCharts.fs index cce9b92e8..5ea7634dd 100644 --- a/tests/Plotly.NET.Tests/HtmlCodegen/SimpleCharts.fs +++ b/tests/Plotly.NET.Tests/HtmlCodegen/SimpleCharts.fs @@ -514,4 +514,91 @@ let ``Heatmap charts`` = "var layout = {\"width\":700,\"height\":500,\"margin\":{\"l\":200.0}};" |> chartGeneratedContains heatmapStyledChart ); + ] + + +let colors = [ + [[0 ;0 ;255]; [255;255;0 ]; [0 ;0 ;255]] + [[255;0 ;0 ]; [255;0 ;255]; [255;0 ;255]] + [[0 ;255;0 ]; [0 ;255;255]; [255;0 ;0 ]] +] + +let imageRawChart = + Chart.Image(Z=colors) + |> Chart.withTitle "Image chart from raw color component arrays" + +let imageRawHSLChart = + Chart.Image(Z=colors, ColorModel=StyleParam.ColorModel.HSL) + |> Chart.withTitle "HSL color model" + +let argbs = [ + [ColorKeyword.AliceBlue ; ColorKeyword.CornSilk ; ColorKeyword.LavenderBlush ] |> List.map ARGB.fromKeyword + [ColorKeyword.DarkGray ; ColorKeyword.Snow ; ColorKeyword.MidnightBlue ] |> List.map ARGB.fromKeyword + [ColorKeyword.LightSteelBlue; ColorKeyword.DarkKhaki; ColorKeyword.LightAkyBlue ] |> List.map ARGB.fromKeyword +] + +let imageARGBChart = + Chart.Image(argbs) + |> Chart.withTitle "ARGB image chart" + +open System.IO + +let imageSource = $@"{__SOURCE_DIRECTORY__}../../../../docs/img/logo.png" + +let base64String = + imageSource + |> File.ReadAllBytes + |> System.Convert.ToBase64String + +let logoImageChart = + Chart.Image( + Source=($"data:image/jpg;base64,{base64String}") + ) + |> Chart.withTitle "This is Plotly.NET:" + +imageRawChart |> Chart.show +imageRawHSLChart |> Chart.show +imageARGBChart |> Chart.show +logoImageChart |> Chart.show + +[] +let ``Image charts`` = + testList "SimpleCharts.Image charts" [ + testCase "Image raw data" ( fun () -> + """var data = [{"type":"image","z":[[[0,0,255],[255,255,0],[0,0,255]],[[255,0,0],[255,0,255],[255,0,255]],[[0,255,0],[0,255,255],[255,0,0]]]}];""" + |> chartGeneratedContains imageRawChart + ); + testCase "Image raw layout" ( fun () -> + """var layout = {"title":{"text":"Image chart from raw color component arrays"}};""" + |> chartGeneratedContains imageRawChart + ); + + testCase "Image raw hsl data" ( fun () -> + """var data = [{"type":"image","z":[[[0,0,255],[255,255,0],[0,0,255]],[[255,0,0],[255,0,255],[255,0,255]],[[0,255,0],[0,255,255],[255,0,0]]],"colormodel":"hsl"}];""" + |> chartGeneratedContains imageRawHSLChart + ); + testCase "Image raw hsl layout" ( fun () -> + """var layout = {"title":{"text":"HSL color model"}};""" + |> chartGeneratedContains imageRawHSLChart + ); + + testCase "Image ARGB data" ( fun () -> + """var data = [{"type":"image","z":[[[240,248,255,255],[255,248,220,255],[255,240,245,255]],[[169,169,169,255],[255,250,250,255],[25,25,112,255]],[[176,196,222,255],[189,183,107,255],[135,206,250,255]]],"colormodel":"rgba"}];""" + |> chartGeneratedContains imageARGBChart + ); + testCase "Image ARGB layout" ( fun () -> + """var layout = {"title":{"text":"ARGB image chart"}};""" + |> chartGeneratedContains imageARGBChart + ); + + testCase "Image base64 data" ( fun () -> + """var data = [{"type":"image","source":"data:image/jpg;base64,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"}];""" + |> chartGeneratedContains logoImageChart + ); + testCase "Image base64 layout" ( fun () -> + """var layout = {"title":{"text":"This is Plotly.NET:"}};""" + |> chartGeneratedContains logoImageChart + ); + + ] \ No newline at end of file