Add Carpet C# bindings

Author: kMutagene

src/Plotly.NET.CSharp/ChartAPI/ChartCarpet.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Plotly.NET.LayoutObjects;
+using Plotly.NET.TraceObjects;
+
+namespace Plotly.NET.CSharp
+{
+    public static partial class Chart
+    {
+        /// <summary>
+        /// Creates a carpet in a 2D coordinate system to be used as additional coordinate system in a carpet plot.
+        ///
+        /// A  carpet plot illustrates the interaction between two or more independent variables and one or more dependent variables in a two-dimensional plot.
+        /// Besides the ability to incorporate more variables, another feature that distinguishes a carpet plot from an equivalent contour plot or 3D surface plot is that a carpet plot can be used to more accurately interpolate data points.
+        /// A conventional carpet plot can capture the interaction of up to three independent variables and three dependent variables and still be easily read and interpolated.
+        ///
+        /// Three-variable carpet plot (cheater plot):
+        ///
+        /// A carpet plot with two independent variables and one dependent variable is often called a cheater plot for the use of a phantom "cheater" axis instead of the horizontal axis. As a result of this missing axis, the values can be shifted horizontally such that the intersections line up vertically. This allows easy interpolation by having fixed horizontal intervals correspond to fixed intervals in both independent variables.
+        ///
+        /// Four-variable carpet plot (true carpet plot)
+        ///
+        /// Instead of using the horizontal axis to adjust the plot perspective and align carpet intersections vertically, the horizontal axis can be used to show the effects on an additional dependent variable.[5] In this case the perspective is fixed, and any overlapping cannot be adjusted. Because a true carpet plot represents two independent variables and two dependent variables simultaneously, there is no corresponding way to show the information on a conventional contour plot or 3D surface plot.
+        ///
+        /// (from https://en.wikipedia.org/wiki/Carpet_plot @ 1/11/2021)
+        /// </summary>
+        /// <param name="carpetId">An identifier for this carpet, so that `scattercarpet` and `contourcarpet` traces can specify a carpet plot on which they lie.</param>
+        /// <param name="Name">Sets the trace name. The trace name appear as the legend item and on hover</param>
+        /// <param name="ShowLegend">Determines whether or not an item corresponding to this trace is shown in the legend.</param>
+        /// <param name="Opacity">Sets the opactity of the trace</param>
+        /// <param name="X">A one dimensional array of x coordinates matching the dimensions of `a` and `b`.</param>
+        /// <param name="MultiX">A two dimensional array of x coordinates at each carpet point. If omitted, the plot is a cheater plot and the xaxis is hidden by default.</param>
+        /// <param name="Y">A one dimensional array of y coordinates matching the dimensions of `a` and `b`.</param>
+        /// <param name="MultiY">A two dimensional array of y coordinates at each carpet point.</param>
+        /// <param name="A">An array containing values of the first parameter value</param>
+        /// <param name="B">An array containing values of the second parameter value</param>
+        /// <param name="AAxis">Sets this carpet's a axis.</param>
+        /// <param name="BAxis">Sets this carpet's b axis.</param>
+        /// <param name="XAxis">Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If "x" (the default value), the x coordinates refer to `layout.xaxis`. If "x2", the x coordinates refer to `layout.xaxis2`, and so on.</param>
+        /// <param name="YAxis">Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If "y" (the default value), the y coordinates refer to `layout.yaxis`. If "y2", the y coordinates refer to `layout.yaxis2`, and so on.</param>
+        /// <param name="Color">Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this.</param>
+        /// <param name="CheaterSlope">The shift applied to each successive row of data in creating a cheater plot. Only used if `x` is been omitted.</param>
+        /// <param name="UseDefaults">If set to false, ignore the global default settings set in `Defaults`</param>
+        public static GenericChart.GenericChart Carpet<XType, MultiXType, YType, MultiYType, AType, BType>(
+            string carpetId,
+            string? Name = null,
+            bool? ShowLegend = null,
+            double? Opacity = null,
+            IEnumerable<XType>? X = null,
+            IEnumerable<IEnumerable<MultiXType>>? MultiX = null,
+            IEnumerable<YType>? Y = null,
+            IEnumerable<IEnumerable<MultiYType>>? MultiY = null,
+            IEnumerable<AType>? A = null,
+            IEnumerable<BType>? B = null,
+            LinearAxis? AAxis = null,
+            LinearAxis? BAxis = null,
+            StyleParam.LinearAxisId? XAxis = null,
+            StyleParam.LinearAxisId? YAxis = null,
+            Color? Color = null,
+            double? CheaterSlope = null,
+            bool? UseDefaults = true
+        )
+            where XType : IConvertible 
+            where MultiXType : IConvertible 
+            where YType : IConvertible 
+            where MultiYType : IConvertible 
+            where AType : IConvertible 
+            where BType : IConvertible
+            =>
+                Plotly.NET.ChartCarpet.Chart.Carpet<XType, IEnumerable<MultiXType>, MultiXType, YType, IEnumerable<MultiYType>, MultiYType, AType, BType>(
+                    carpetId: carpetId,
+                    Name: Name.ToOption(),
+                    ShowLegend: ShowLegend.ToOptionV(),
+                    Opacity: Opacity.ToOptionV(),
+                    X: X.ToOption(),
+                    MultiX: MultiX.ToOption(), 
+                    Y: Y.ToOption(),
+                    MultiY: MultiY.ToOption(),
+                    A: A.ToOption(),
+                    B: B.ToOption(),
+                    AAxis: AAxis.ToOption(),
+                    BAxis: BAxis.ToOption(),
+                    XAxis: XAxis.ToOption(),
+                    YAxis: YAxis.ToOption(),
+                    Color: Color.ToOption(),
+                    CheaterSlope: CheaterSlope.ToOptionV(),
+                    UseDefaults: UseDefaults.ToOptionV()
+                );
+    }
+}

src/Plotly.NET.CSharp/ChartAPI/ChartTernary.cs

@@ -10,6 +10,38 @@ namespace Plotly.NET.CSharp
 {
     public static partial class Chart
     {
+        /// <summary>
+        /// Creates a Scatter plot on a ternary coordinate system
+        ///
+        /// In general, ScatterTernary creates a barycentric plot on three variables which sum to a constant, graphically depicting the ratios of the three variables as positions in an equilateral triangle.
+        ///
+        /// ScatterTernary charts are the basis of PointTernary, LineTernary, and BubbleTernary Charts, and can be customized as such. We also provide abstractions for those: Chart.LineTernary, Chart.PointTernary, Chart.BubbleTernary
+        /// </summary>
+        /// <param name="A">Sets the quantity of component `a` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary&lt;i&gt;.sum`.</param>
+        /// <param name="B">Sets the quantity of component `b` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary&lt;i&gt;.sum`.</param>
+        /// <param name="C">Sets the quantity of component `c` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary&lt;i&gt;.sum`.</param>
+        /// <param name="Sum">The number each triplet should sum to, if only two of `a`, `b`, and `c` are provided. This overrides `ternary&lt;i&gt;.sum` to normalize this specific trace, but does not affect the values displayed on the axes. 0 (or missing) means to use `ternary&lt;i&gt;.sum`</param>
+        /// <param name="Mode">Determines the drawing mode for this scatter trace.</param>
+        /// <param name="Name">Sets the trace name. The trace name appear as the legend item and on hover</param>
+        /// <param name="ShowLegend">Determines whether or not an item corresponding to this trace is shown in the legend.</param>
+        /// <param name="Opacity">Sets the opactity of the trace</param>
+        /// <param name="MultiOpacity">Sets the opactity of individual datum markers</param>
+        /// <param name="Text">Sets a text associated with each datum</param>
+        /// <param name="MultiText">Sets individual text for each datum</param>
+        /// <param name="TextPosition">Sets the position of text associated with each datum</param>
+        /// <param name="MultiTextPosition">Sets the position of text associated with individual datum</param>
+        /// <param name="MarkerColor">Sets the color of the marker</param>
+        /// <param name="MarkerColorScale">Sets the colorscale of the marker</param>
+        /// <param name="MarkerOutline">Sets the outline of the marker</param>
+        /// <param name="MarkerSymbol">Sets the marker symbol for each datum</param>
+        /// <param name="MultiMarkerSymbol">Sets the marker symbol for each individual datum</param>
+        /// <param name="Marker">Sets the marker (use this for more finegrained control than the other marker-associated arguments)</param>
+        /// <param name="LineColor">Sets the color of the line</param>
+        /// <param name="LineColorScale">Sets the colorscale of the line</param>
+        /// <param name="LineWidth">Sets the width of the line</param>
+        /// <param name="LineDash">sets the drawing style of the line</param>
+        /// <param name="Line">Sets the line (use this for more finegrained control than the other line-associated arguments)</param>
+        /// <param name="UseDefaults">If set to false, ignore the global default settings set in `Defaults`</param>
         public static GenericChart.GenericChart Scatterternary<AType, BType, CType, SumType, TextType>(
             IEnumerable<AType>? A = null,
             IEnumerable<BType>? B = null,

src/Plotly.NET.CSharp/GenericChartExtensions.cs

@@ -17,7 +17,7 @@ public static class GenericChartExtensions
         public static void SaveHtml(
             this GenericChart.GenericChart gChart,
             string path,
-            bool? OpenInBrowser
+            bool? OpenInBrowser = null
         ) =>
             Plotly.NET.Chart.SaveHtml(
                 path: path,
@@ -41,12 +41,12 @@ public static void SaveHtml(
         /// <param name="LegendGroupTitle">Sets the title for the chart's trace legend group </param>
         public static GenericChart.GenericChart WithTraceInfo(
             this GenericChart.GenericChart gChart,
-            string? Name,
-            StyleParam.Visible? Visible,
-            bool? ShowLegend,
-            int? LegendRank,
-            string? LegendGroup,
-            Title? LegendGroupTitle
+            string? Name = null,
+            StyleParam.Visible? Visible = null,
+            bool? ShowLegend = null,
+            int? LegendRank = null,
+            string? LegendGroup = null,
+            Title? LegendGroupTitle = null
         ) =>
             Plotly.NET.Chart.WithTraceInfo(
                 Name: Name,
@@ -56,6 +56,14 @@ public static GenericChart.GenericChart WithTraceInfo(
                 LegendGroup: LegendGroup,
                 LegendGroupTitle: LegendGroupTitle
             ).Invoke(gChart);
+
+        /// Sets the size of a Chart (in pixels)
+        public static GenericChart.GenericChart WithSize(
+            this GenericChart.GenericChart gChart,
+            int? Width = null,
+            int? Height = null
+        ) =>
+            Plotly.NET.Chart.WithSize(Width: Width, Height: Height).Invoke(gChart);
     }
 
 

src/Plotly.NET/ChartAPI/Chart.fs

@@ -2638,7 +2638,7 @@ type Chart =
             GenericChart.addLayout layout ch)
 
 
-    // Set the size of a Chart
+    /// Sets the size of a Chart (in pixels)
     [<CompiledName("WithSize")>]
     static member withSize
         (

tests/Plotly.NET.Tests.CSharpConsole/Program.cs

@@ -10,7 +10,7 @@ class Program
         static void Main(string[] args)
         {
             Chart.Grid(
-                nRows: 5,
+                nRows: 6,
                 nCols: 3,
                 gCharts:
                     new GenericChart []
@@ -57,8 +57,18 @@ static void Main(string[] args)
                         ),
                         Chart.Invisible(),
                         Chart.Invisible(),
+                        Chart.Carpet<double,double,double,double,double,double>(
+                            carpetId: "testCarpet",
+                            A: new double [] {4.0, 4.0, 4.0, 4.5, 4.5, 4.5, 5.0, 5.0, 5.0, 6.0, 6.0, 6.0},
+                            B: new double [] {1.0, 2.0, 3.0, 1.0, 2.0, 3.0, 1.0, 2.0, 3.0, 1.0, 2.0, 3.0},
+                            Y: new double [] {2.0, 3.5, 4.0, 3.0, 4.5, 5.0, 5.5, 6.5, 7.5, 8.0, 8.5, 10.0}
+                        ),
+                        Chart.Invisible(),
+                        Chart.Invisible(),
                     }
-            ).Show();
+            )
+                .WithSize(750,2000)
+                .Show();
         }
     }
 }