3D Mesh plots

BinderScriptNotebook

Summary: This example shows how to create 3D-Mesh charts in F#.

let's first create some data for the purpose of creating example charts:

open System
open Plotly.NET 


//---------------------- Generate linearly spaced vector ----------------------
let linspace (min,max,n) = 
    if n <= 2 then failwithf "n needs to be larger then 2"
    let bw = float (max - min) / (float n - 1.)
    Array.init n (fun i -> min + (bw * float i))
    //[|min ..bw ..max|]

//---------------------- Create example data ----------------------
let size = 100
let x = linspace(-2. * Math.PI, 2. * Math.PI, size)
let y = linspace(-2. * Math.PI, 2. * Math.PI, size)

let f x y = - (5. * x / (x**2. + y**2. + 1.) )

let z = 
    Array.init size (fun i -> 
        Array.init size (fun j -> 
            f x.[j] y.[i] 
        )
    )

let rnd = System.Random()
let a = Array.init 50 (fun _ -> rnd.NextDouble())
let b = Array.init 50 (fun _ -> rnd.NextDouble())
let c = Array.init 50 (fun _ -> rnd.NextDouble())

open Plotly.NET.TraceObjects

let mesh3d =
    Trace3D.initMesh3d 
        (fun mesh3d ->
            mesh3d?x <- a
            mesh3d?y <- b
            mesh3d?z <- c
            mesh3d?flatshading <- true
            mesh3d?contour <- Contours.initXyz(Show=true)
            mesh3d
            )
    |> GenericChart.ofTraceObject 
    
namespace System
namespace Plotly
namespace Plotly.NET
val linspace : min:float * max:float * n:int -> float []
val min : float
val max : float
val n : int
val failwithf : format:Printf.StringFormat<'T,'Result> -> 'T
<summary>Print to a string buffer and raise an exception with the given result. Helper printers must return strings.</summary>
<param name="format">The formatter.</param>
<returns>The formatted result.</returns>
val bw : float
Multiple items
val float : value:'T -> float (requires member op_Explicit)
<summary>Converts the argument to 64-bit float. This is a direct conversion for all primitive numeric types. For strings, the input is converted using <c>Double.Parse()</c> with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type.</summary>
<param name="value">The input value.</param>
<returns>The converted float</returns>


--------------------
[<Struct>] type float = Double
<summary>An abbreviation for the CLI type <see cref="T:System.Double" />.</summary>
<category>Basic Types</category>


--------------------
type float<'Measure> = float
<summary>The type of double-precision floating point numbers, annotated with a unit of measure. The unit of measure is erased in compiled code and when values of this type are analyzed using reflection. The type is representationally equivalent to <see cref="T:System.Double" />.</summary>
<category index="6">Basic Types with Units of Measure</category>
type Array = interface ICollection interface IEnumerable interface IList interface IStructuralComparable interface IStructuralEquatable interface ICloneable new : unit -> unit member Clone : unit -> obj member CopyTo : array: Array * index: int -> unit + 1 overload member GetEnumerator : unit -> IEnumerator ...
<summary>Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the base class for all arrays in the common language runtime.</summary>
val init : count:int -> initializer:(int -> 'T) -> 'T []
<summary>Creates an array given the dimension and a generator function to compute the elements.</summary>
<param name="count">The number of elements to initialize.</param>
<param name="initializer">The function to generate the initial values for each index.</param>
<returns>The created array.</returns>
<exception cref="T:System.ArgumentException">Thrown when count is negative.</exception>
val i : int
val size : int
val x : float []
type Math = static member Abs : value: decimal -> decimal + 6 overloads static member Acos : d: float -> float static member Acosh : d: float -> float static member Asin : d: float -> float static member Asinh : d: float -> float static member Atan : d: float -> float static member Atan2 : y: float * x: float -> float static member Atanh : d: float -> float static member BigMul : a: int * b: int -> int64 + 2 overloads static member BitDecrement : x: float -> float ...
<summary>Provides constants and static methods for trigonometric, logarithmic, and other common mathematical functions.</summary>
field Math.PI: float = 3.14159265359
<summary>Represents the ratio of the circumference of a circle to its diameter, specified by the constant, π.</summary>
val y : float []
val f : x:float -> y:float -> float
val x : float
val y : float
val z : float [] []
val j : int
val rnd : Random
Multiple items
type Random = new : unit -> unit + 1 overload member Next : unit -> int + 2 overloads member NextBytes : buffer: byte [] -> unit + 1 overload member NextDouble : unit -> float member Sample : unit -> float
<summary>Represents a pseudo-random number generator, which is an algorithm that produces a sequence of numbers that meet certain statistical requirements for randomness.</summary>

--------------------
Random() : Random
Random(Seed: int) : Random
val a : float []
Random.NextDouble() : float
val b : float []
val c : float []
namespace Plotly.NET.TraceObjects
val mesh3d : GenericChart.GenericChart
Multiple items
type Trace3D = inherit Trace new : traceTypeName:string -> Trace3D static member initCone : applyStyle:(Trace3D -> Trace3D) -> Trace3D static member initIsoSurface : applyStyle:(Trace3D -> Trace3D) -> Trace3D static member initMesh3d : applyStyle:(Trace3D -> Trace3D) -> Trace3D static member initScatter3d : applyStyle:(Trace3D -> Trace3D) -> Trace3D static member initStreamTube : applyStyle:(Trace3D -> Trace3D) -> Trace3D static member initSurface : applyStyle:(Trace3D -> Trace3D) -> Trace3D static member initVolume : applyStyle:(Trace3D -> Trace3D) -> Trace3D
<summary> Traces for 3D subplots, using layout.scene as anchors. These trace types are compatible with 3D subplots via the scene attribute, which contains special camera controls: - scatter3d, which can be used to draw individual markers, 3d bubble charts and lines and curves - surface and mesh: 3d surface trace types - cone and streamtube: 3d vector field trace types - volume and isosurface: 3d volume trace types </summary>

--------------------
new : traceTypeName:string -> Trace3D
static member Trace3D.initMesh3d : applyStyle:(Trace3D -> Trace3D) -> Trace3D
val mesh3d : Trace3D
Multiple items
type Contours = inherit DynamicObj new : unit -> Contours static member init : ?X:Contour * ?Y:Contour * ?Z:Contour -> Contours static member initXyz : ?Color:Color * ?End:float * ?Highlight:bool * ?HighlightColor:Color * ?HighlightWidth:float * ?Project:ContourProject * ?Show:bool * ?Size:float * ?Start:float * ?UseColorMap:bool * ?Width:float -> Contours static member style : ?X:Contour * ?Y:Contour * ?Z:Contour -> (Contours -> Contours) static member styleXyz : ?Color:Color * ?End:float * ?Highlight:bool * ?HighlightColor:Color * ?HighlightWidth:float * ?Project:ContourProject * ?Show:bool * ?Size:float * ?Start:float * ?UseColorMap:bool * ?Width:float -> (Contours -> Contours)
<summary> Contours type inherits from dynamic object </summary>

--------------------
new : unit -> Contours
static member Contours.initXyz : ?Color:Color * ?End:float * ?Highlight:bool * ?HighlightColor:Color * ?HighlightWidth:float * ?Project:ContourProject * ?Show:bool * ?Size:float * ?Start:float * ?UseColorMap:bool * ?Width:float -> Contours
module GenericChart from Plotly.NET
<summary> Module to represent a GenericChart </summary>
val ofTraceObject : trace:Trace -> GenericChart.GenericChart
<summary> Converts from a trace object and a layout object into GenericChart </summary>
val toChartHTML : gChart:GenericChart.GenericChart -> string
<summary> Converts a GenericChart to it HTML representation. The div layer has a default size of 600 if not specified otherwise. </summary>