wellioviz

https://justingosses.github.io/wellioviz
Admin
wellioviz is a JavaScript library for visualizing well logs, particularly those converted to JSON,...
Tokens:6,102
Snippets:50
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Deploy Holoviews Panel/Bokeh Application

Source: https://justingosses.github.io/wellioviz/index

Instructions to set up and run an example Holoviews Panel/Bokeh application, including installing necessary Python dependencies and serving the application via the command line.

```shell
pip install panel
```

```shell
panel serve example_panel_app --show
```

--------------------------------

### Serve Documentation Locally using Node.js http-server

Source: https://justingosses.github.io/wellioviz/index

As an alternative to the Python server, this command starts an HTTP server using the 'http-server' Node.js module. It provides a convenient way to serve the documentation or any static files locally, typically used when Node.js is preferred or already installed.

```bash
http-server
```

--------------------------------

### Install Wellioviz in Observable Notebook

Source: https://justingosses.github.io/wellioviz/index

Instructions for importing the Wellioviz module into an ObservableHQ.com JavaScript notebook. It shows how to use `require` with a CDN URL and how to specify a particular version. Also includes an example of calling a Wellioviz function.

```JavaScript
wellioviz = require('https://bundle.run/wellioviz')
```

```JavaScript
wellioviz = require('https://bundle.run/wellioviz@0.0.25')
```

```JavaScript
example_template = wellioviz.curveBoxTemplateExamples("example")
```

--------------------------------

### Wellioviz Helper Functions

Source: https://justingosses.github.io/wellioviz/index

Miscellaneous utility functions, primarily for retrieving templates and examples within the Wellioviz library.

```APIDOC
define_wellioviz()
getexampletemplate()
getfakeincomingsparsedataexample()
```

--------------------------------

### Retrieve Wellioviz CurveBox Template Examples and Definitions

Source: https://justingosses.github.io/wellioviz/index

Demonstrates how to use `wellioviz.curveBoxTemplateExamples()` to inspect the expected JSON format for `curveBox()` data and its key definitions. This helps users understand the required structure for plotting configurations and data input.

```JavaScript
wellioviz.curveBoxTemplateExamples("example")
```

```JavaScript
wellioviz.curveBoxTemplateExamples("definitions")
```

--------------------------------

### Serve Demo HTML Locally using Python's HTTP Server

Source: https://justingosses.github.io/wellioviz/index

This command starts a simple HTTP server using Python 3, specifically for serving the 'demo.html' page and its associated assets. It allows developers to test the demo functionality locally in a web browser, ensuring that the bundled JavaScript and other resources load correctly.

```bash
python3 -m http.server
```

--------------------------------

### Wellioviz Template Functions Overview

Source: https://justingosses.github.io/wellioviz/index

Describes functions that provide JSON templates for Wellioviz, either as examples with sensible defaults or with definitions of valid values for keys.

```APIDOC
curveBoxTemplateExamples(type: "example" | "definitions")
  type: A string indicating whether to return an example template or definitions.
  Returns: JSON template for curveBox() function, either filled with defaults or with definitions.
```

--------------------------------

### curveBoxTemplateExamples() function

Source: https://justingosses.github.io/wellioviz/index

This function provides examples of the JSON template used by plotting functions and definitions of its fields. It accepts a string ('help', 'example', or 'definitions') and returns either a string or an object, aiding in the construction of JSON objects for the curveBox plotting function.

```APIDOC
curveBoxTemplateExamples(string_of_either__help_example_definitions_mandatories: string)
  Parameters:
    string_of_either__help_example_definitions_mandatories: string
      A string of either "help" "example" or "definitions"
  Returns:
    string | object: Returns a string or Object depending on the input parameter.
```

--------------------------------

### Local Installation and Node.js Backend Usage

Source: https://justingosses.github.io/wellioviz/index

Instructions for installing Wellioviz locally and using it within a Node.js backend environment, particularly useful for tasks like generating static SVGs. It covers npm installation and interactive usage within the Node.js console.

```Shell
npm install wellioviz
```

```Shell
node --require wellioviz
```

```JavaScript
var wellio = require('wellioviz')
```

```JavaScript
wellioviz.help
```

```JavaScript
wellioviz.functionName(arguments)
```

--------------------------------

### Install Node.js Project Dependencies

Source: https://justingosses.github.io/wellioviz/index

This command installs all required production and development dependencies for the wellioviz project, as specified in the 'package.json' file. Key libraries like Browserify, wellio.js, and d3.js are installed into the 'node_modules' folder, preparing the environment for development and building.

```bash
npm install
```

--------------------------------

### Clone wellioviz Git Repository

Source: https://justingosses.github.io/wellioviz/index

This command clones the wellioviz GitHub repository to the local machine. It creates a complete local copy of the project, including all branches and commit history, essential for starting development or contributing.

```bash
git clone https://github.com/JustinGOSSES/wellioviz.git
```

--------------------------------

### Set Up Wellioviz for Development Contribution

Source: https://justingosses.github.io/wellioviz/index

Steps for developers to fork, clone, and navigate into their local Wellioviz repository for contributing changes. This includes standard Git commands for repository management.

```shell
git clone https://github.com/+yourUserName+/wellioviz.git
```

```shell
cd wellioviz
```

--------------------------------

### help() function

Source: https://justingosses.github.io/wellioviz/index

A function that directs users to the documentation if they need help. It provides links to the main wellioviz documentation and suggests other utility functions for further exploration.

```APIDOC
help(): string
  Returns:
    string: It says = I'm really no help. Please check out the docs at https://justingosses.github.io/wellioviz/ or the main README.md at https://github.com/JustinGOSSES/wellioviz. If you would like to know what wellioviz does, try wellioviz.define(). If you would like to see an example template, try wellioviz.curveBoxTemplateExamples('example') If you would like to see an example template defintions, try wellioviz.curveBoxTemplateExamples('definitions') Best of luck.
```

--------------------------------

### minimumDataIntoTemplateFunc Function API

Source: https://justingosses.github.io/wellioviz/index

minimumDataIntoTemplateFunc

```APIDOC
minimumDataIntoTemplateFunc(example_template: any, data: any, well_names: any, curve_names: any, curve_colors: any, curve_units: any, fill: any, div_id: any, width: any, height: any, depth_curve_name: any)
  example_template: any
  data: any
  well_names: any
  curve_names: any
  curve_colors: any
  curve_units: any
  fill: any
  div_id: any
  width: any
  height: any
  depth_curve_name: any
```

--------------------------------

### Front-end Website Integration: npm and Direct Script Tag

Source: https://justingosses.github.io/wellioviz/index

A method for integrating Wellioviz into a front-end web project. It involves creating a `package.json` file, running `npm install`, and then including the module's main script directly in an HTML file using a `<script>` tag.

```JSON
{ "dependencies": { "wellioviz": "0.0.25" } }
```

```Shell
npm install
```

```HTML
<script src="node_modules/wellioviz/dist/index.js"></script>
```

--------------------------------

### Front-end Website Integration: npm and Browserify Bundling

Source: https://justingosses.github.io/wellioviz/index

An alternative, cleaner approach for front-end integration. This method uses npm to install Wellioviz and Browserify to bundle the module with other project JavaScript files into a single `bundle.js` file, which is then included in the HTML.

```Shell
npm install wellioviz
```

```JavaScript
wellio = require('wellioviz');
```

```Shell
browserify main.js other.js more.js -o bundle.js
```

```HTML
<script src="JS/bundle.js"></script>
```

--------------------------------

### Get Wellioviz Plotting Template

Source: https://justingosses.github.io/wellioviz/index

Retrieves a blank template from Wellioviz that defines both the data structure and styling options for visualizing well log curves. This template serves as a foundation that will be populated with specific well log data and custom styling.

```Python
example_template = wellioviz.curveBoxTemplateExamples("example")
```

--------------------------------

### getFakeIncomingSparseDataExample() function

Source: https://justingosses.github.io/wellioviz/index

A function that generates and returns a JSON object containing fake sparse incoming data. This serves as an example of an alternative data input format, distinct from wellio.js style JSON, and is optimized for reduced data transmission and front-end calculation.

```APIDOC
getFakeIncomingSparseDataExample(): array
  Returns:
    array: returns an array that contains an object. probably just a single object? Many of the things like max and min depth that are auto-calculated when the input is a wellio JSON and instead explicitly defined here. This saves data transmission from a backend as well as front-end calculation time.
```

--------------------------------

### Navigate to wellioviz Project Directory

Source: https://justingosses.github.io/wellioviz/index

This command changes the current working directory to the root folder of the wellioviz repository. This step is crucial before running any project-specific commands like installing dependencies or building assets.

```bash
cd wellioviz
```

--------------------------------

### Build wellioviz Documentation with documentation.js

Source: https://justingosses.github.io/wellioviz/index

This command utilizes the documentation.js tool to generate HTML documentation from the project's JavaScript source files and a specified configuration file. The output HTML files are placed into the 'docs' directory, making them ready for local serving or deployment.

```bash
documentation build ./dist/index.js --config docs/doc_setup.yml -f html -o docs
```

--------------------------------

### Wellioviz Packaging and Plotting Functions

Source: https://justingosses.github.io/wellioviz/index

Functions that combine reformatted data with pre-packaged templates and generate SVG visualizations.

```APIDOC
// Packaging:
multiplelogplot()

// Plotting:
curvebox()
savesvg()
```

--------------------------------

### Publish wellioviz Package to npm

Source: https://justingosses.github.io/wellioviz/index

This command publishes the current version of the wellioviz package to the npm registry. Before running, ensure the version number in 'package.json' has been incremented. Successful execution makes the package available for public consumption via 'npm install'.

```bash
npm publish
```

--------------------------------

### putArrayOfLogsIntoSection Function API

Source: https://justingosses.github.io/wellioviz/index

THE FUNCTION putArrayOfLogsIntoSection NEEDS DOCUMENTATION!

```APIDOC
putArrayOfLogsIntoSection(logs_in_json: any, div_id: any, example_template: any, curve_name: any, curve_color: any, curve_unit: any, fill: any, depth_name: any, width: any, height: any)
  logs_in_json: any
  div_id: any
  example_template: any
  curve_name: any
  curve_color: any
  curve_unit: any
  fill: any
  depth_name: any
  width: any
  height: any
```

--------------------------------

### Serve Documentation Locally using Python's HTTP Server

Source: https://justingosses.github.io/wellioviz/index

This command initiates a simple HTTP server using Python 3's built-in module. It's intended to serve the generated documentation locally, allowing developers to preview changes in a web browser. For correct image links, this command should be executed from within the 'docs' directory.

```bash
python3 -m http.server
```

--------------------------------

### Generate Depth Array from Min, Max, and Step

Source: https://justingosses.github.io/wellioviz/index

This function creates a numerical array of depth values, starting from a minimum float, incrementing by a step float, and ending at a maximum float. It is particularly useful for generating depth axes for plotting when explicit depth curve data is not provided, reducing data transfer from the backend.

```APIDOC
createDepthArray(min: float, max: float, step: float): array
  min: a float or integer that represents the top depth of an eventual array of depth values that this function creates.
  max: a float or integer that represents the bottom depth of an array of depth values this function creates.
  step: a float or integer that represents the interval the depth curve increases as you go from the top to the bottom of the depth curve this function creates.
Returns: array
  returns an array of depth values from the min to the max by the step. AN EXAMPLE = [10,10.5,11,11.5,12]
```

--------------------------------

### Wellioviz Dependency: wellio.js Module

Source: https://justingosses.github.io/wellioviz/index

Provides access to the wellio.js library functions as a module within Wellioviz, primarily for loading LAS 2.0 files and converting them to JSON.

```APIDOC
wellio()
  Returns: obj - The wellio.js object containing all its functions.
```

--------------------------------

### define_wellioviz() function

Source: https://justingosses.github.io/wellioviz/index

A function that returns a short description of what the wellioviz library is all about. It provides a concise definition of the library's purpose.

```APIDOC
define_wellioviz(): string
  Returns:
    string: Returns a string that defines wellioviz.
```

--------------------------------

### Wellioviz Dependency: d3.js Module

Source: https://justingosses.github.io/wellioviz/index

Provides access to the d3.js library functions as a module within Wellioviz, used for data-driven document manipulation and visualizations.

```APIDOC
d3()
  Returns: obj - The d3.js object containing all its functions.
```

--------------------------------

### Navigate to Docs JavaScript Directory

Source: https://justingosses.github.io/wellioviz/index

This command changes the current directory to the 'docs/js' subfolder within the wellioviz project. This directory typically contains JavaScript files specifically used for the project's demo or documentation pages.

```bash
cd docs/js
```

--------------------------------

### Build Demo JavaScript Bundle with Browserify

Source: https://justingosses.github.io/wellioviz/index

This command uses Browserify to concatenate and bundle several JavaScript files (call_plots.js, main.js, get_wellio.js, vkbeautify.js) into a single output file named 'bundle.js'. This 'bundle.js' is then utilized by the 'demo.html' page to provide all necessary client-side functionality.

```bash
browserify call_plots.js main.js get_wellio.js vkbeautify.js -o bundle.js
```

--------------------------------

### putIncomingSparseJsonIntoPlottingTemplate Function API

Source: https://justingosses.github.io/wellioviz/index

This function is used to put the incoming sparse style JSON information into the plotting tempalte JSON that is given to curveBox which then handles the plotting.

```APIDOC
putIncomingSparseJsonIntoPlottingTemplate(incoming_sparse: Object, template: Object)
  incoming_sparse: This is a JSON object of incoming sparse style data & plotting instructions.
  template: This is a JSON example template of the type typically given to the curveBox function. The user will use if for defaults and replace the data and formatting options they want to change.
```

--------------------------------

### Wellioviz Data Transformation Functions

Source: https://justingosses.github.io/wellioviz/index

Functions responsible for reformatting data into a structure usable by Wellioviz, supporting both Wellio.js style JSON and sparse style JSON inputs.

```APIDOC
// For Wellio.js style JSON:
convertwelljsontoobj()
fromjsonofwellgetthingsforplotting()
takeinarraysandgetobjectofcurvedataforplotting()

// For sparse style JSON:
createdeptharray()
```

--------------------------------

### Plot Multiple Curves with Minimum Data (forMultipleCurvesMinimumDataIntoTemplateFunc)

Source: https://justingosses.github.io/wellioviz/index

This function is used to quickly plot multiple curves as separate curveboxes, taking into consideration a list of curves to skip and some basic pre-built styles, both given as arguments.

```APIDOC
forMultipleCurvesMinimumDataIntoTemplateFunc(well_log_curves_reformatted_for_d3_2: array, curves_to_skip: array, prebuilt_minimal_styles_by_curvename: object, uwi2: any, depth_curve_name: any): array
  Parameters:
    well_log_curves_reformatted_for_d3_2 (array): An array of objects. Each object is a depth point with key:value pairs of curve name and value. This was likely created by the three_things_2 function and returned like so: well_log_curves_reformatted_for_d3_2 = three_things_2["well_log_curves_reformatted_for_d3"]
    curves_to_skip (array): An array of strings for curve names to skip plotting.
    prebuilt_minimal_styles_by_curvename (object): An object that maps curve names to style and styles to basic style config like fill color
    uwi2 (any):
    depth_curve_name (any):
  Returns:
    array: array_of_jsons_for_what_to_plot - An array of objects for each curve to be plotted in its curvebox via the curveBox() function or another function that funnels into curvebox.
```

--------------------------------

### curveBox Function API

Source: https://justingosses.github.io/wellioviz/index

CurveBox is the central function to wellioviz in a lot of ways, not least as it holds the d3.js code. It takes a JSOn template, appends the resulting SVG to a defined DIV.

```APIDOC
curveBox(template_for_plotting: any, well_curve_config_template: Object): any
  template_for_plotting: any
  well_curve_config_template: Object
  Returns: SVG.node() But its main function is to append this SVG to a DIV given in the template that is the single parameter.
```

--------------------------------

### Wellioviz Core API: curveBox Function and Plotting JSON Template

Source: https://justingosses.github.io/wellioviz/index

Documentation for the fundamental components of the Wellioviz API: the mandatory `curveBox()` function and the associated JSON template. These elements are central to defining and rendering well log visualizations, with Wellioviz handling visualization exclusively, not data loading or user interfaces.

```APIDOC
Wellioviz Core API:
  curveBox(plotting_json_template: object) -> visualization_output
    description: The primary function in Wellioviz responsible for generating well log visualizations. It takes a JSON template as input to define plotting instructions.
    parameters:
      plotting_json_template: object - A JSON object that specifies what and how to plot. This template includes sensible defaults, allowing users to customize visualizations without direct D3.js interaction.
    returns: A D3.js-based visualization output.
    notes: This function is mandatory for Wellioviz usage. Wellioviz focuses solely on visualization and does not handle well log data loading or provide a graphical user interface.

  Plotting JSON Template:
    description: A configuration object central to Wellioviz, defining all parameters for well log visualization. It encapsulates sensible defaults, simplifying the customization process for end-users.
    structure: (Conceptual - specific keys are not detailed in the source text, but it's implied to contain instructions for curves, scales, etc.)
    usage: Must be provided as an argument to the `curveBox()` function.
```

--------------------------------

### Wellioviz Curvebox Plotting JSON Structure

Source: https://justingosses.github.io/wellioviz/index

Describes the hierarchical structure of the JSON object expected by the `curveBox()` function for configuring visualizations. It includes top-level configuration, and arrays for curves, lines, and rectangles, each containing their own configuration and data.

```APIDOC
curve_box: object
  description: Key-value pairs of configuration options that apply to the entire curve box.
components: array
  description: An array containing a single object with three keys: curves, lines, and rectangles.
  items: object
    curves: array
      description: An array of curve objects.
      items: object
        description: Each curve object has key-value pairs for configuration and data to build a single curve.
    lines: array
      description: An array of line objects.
      items: object
        description: Each line object has key-value pairs for configuration and data to build a single line.
    rectangles: array
      description: An array of rectangle objects.
      items: object
        description: Each rectangle object has key-value pairs for configuration and data to build a single rectangle.
```

--------------------------------

### Plot Multiple Curveboxes in a Row (multipleLogPlot)

Source: https://justingosses.github.io/wellioviz/index

This function is used to plot multiple curveboxes in a row, effectively creating a cross-section. It internally calls the curveBox function multiple times.

```APIDOC
multipleLogPlot(div_id: string, templates: object, show_all: boolean, remove_preexisting: any)
  Parameters:
    div_id (string): A string that represents the div ID that the multiple curveboxes will be appended to.
    templates (object): An array of CurveBox input templates.
    show_all (boolean = true): A boolean value that decides whether or not multiple plots are shown in a multiple log plot div. If show_all is false, the developer must switch their CSS to be "inline-block" one at a time via some other means, otherwise none will appear!
    remove_preexisting (any = true):
```

--------------------------------

### Convert LAS 2.0 String to Wellio JSON

Source: https://justingosses.github.io/wellioviz/index

Converts a LAS 2.0 well log file, loaded as a string, into a wellio-style JSON object. This is the initial step to transform raw LAS data into a structured format suitable for Wellioviz processing.

```Python
well_json_01_01_095_19W4 = wellio.las2json(well_as_string)
```

--------------------------------

### findDepthName() function

Source: https://justingosses.github.io/wellioviz/index

This function takes a wellio-style JSON representation of a well log, analyzes its curve names, and identifies the most probable depth curve. It returns the name of this curve, which is useful for excluding it from plotting operations.

```APIDOC
findDepthName(well_log_in_json: object): string
  Parameters:
    well_log_in_json: object
      a full wellio style JSON
  Returns:
    string: returns a string representation of the curve name that is likely the depth curve. It assumes there is only one!
```

--------------------------------

### Populate Plotting Template with Well Log Data and Styling

Source: https://justingosses.github.io/wellioviz/index

Fills a Wellioviz template with specific well log data, UWI, curve names, colors, and styling options. This function allows for fine-grained control over how individual curves are visualized, including fill directions, cutoff values, and multiple curve definitions within a single plot.

```Python
gr_plot_template_noFill = wellioviz.minimumDataIntoTemplateFunc(
example_template,well_log_curves_reformatted_for_d3_2,[uwi2],["CALI"],["black"],[""],[
{"curve_name":"GR",
"fill":"no",
"fill_direction":"left",
"cutoffs":[0,ShaleSiltCutOff,SiltSandCutOff],
"fill_colors":["gray","orange","yellow"],
"curve2":""
}
],
"well_holder_1A",200,400,"DEPT")
```

```Python
resd_plot_template_1 = wellioviz.minimumDataIntoTemplateFunc(example_template,well_log_curves_reformatted_for_d3_2,[uwi2],['ILD'],["RED"],[""],[
{"curve_name":"ILD","fill":"yes","fill_direction":"left","cutoffs":[5,10,25],"fill_colors":["#ffe6e6","#ffb3b3","red"],"curve2":"ILD"}],"well_holder_1B",200,400,"DEPT")
```

```Python
poro_plot_template_1 = wellioviz.minimumDataIntoTemplateFunc(example_template,well_log_curves_reformatted_for_d3_2,[uwi2],["NPHI","DPHI"],["purple","pink"],[""],[{
"curve_name":"NPHI",
"fill":"yes",
"fill_direction":"between",
"cutoffs":[0],
"fill_colors":["lightblue"],
"curve2":"DPHI"
},
{
"curve_name":"DPHI",
"fill":"no",
"fill_direction":"left",
"cutoffs":[],
"fill_colors":[],
"curve2":""
}
],"well_holder_1C",200,400,"DEPT")
```

--------------------------------

### Save SVG Element to File (saveSvg)

Source: https://justingosses.github.io/wellioviz/index

This function is used to save a given SVG element with a specified name. It creates a download link div which is then used to initiate the download of the SVG file. Note that in certain environments, this functionality may not work due to security reasons.

```APIDOC
saveSvg(svgEl: string, name: string)
  Parameters:
    svgEl (string): An SVG element returned from the curveBox function.
    name (string): The name of the file to be downloaded.
```

--------------------------------

### Plot Single Curvebox (makeThisCurveBox)

Source: https://justingosses.github.io/wellioviz/index

This function is used to plot a single curvebox in the div specified by the plotting templates div_id key. When called, it removes any existing children from the target div before appending the new curveBox.

```APIDOC
makeThisCurveBox(template_for_plotting: string): string
  Parameters:
    template_for_plotting (string): A JSON of all the information needed to be plotted using the exact format of wellioviz.
  Returns:
    string: curve_box_return - A string representation of the SVG variable called SVG. This can be given to the saveSvg function to save the SVG as a file with a .svg ending.
```

--------------------------------

### Extract Plotting Data from Wellio JSON

Source: https://justingosses.github.io/wellioviz/index

Processes the wellio-style JSON object and a specified depth curve name to extract necessary data for plotting. The output is an object (or dictionary) containing 'curve_names', 'uwi', and 'well_log_curves_reformatted_for_d3', which are essential for subsequent visualization steps.

```Python
three_things_2 = wellioviz.fromJSONofWEllGetThingsForPlotting(well_json_01_01_095_19W4,"DEPTH")
```

--------------------------------

### convertWellJSONToObjV2 Function API

Source: https://justingosses.github.io/wellioviz/index

convertWellJSONToObjV2 is a function that takes in sparse style JSON and other information and returns an array of that information properly packaged, array of curves names, and a string for UWI and returns the data array of objects that D3.js likes for data used in plotting.

```APIDOC
convertWellJSONToObjV2(depth: Array, curve_data: Array, UWI: String, CurveNames: Array): Array
  depth: An array of strings that can be parsed into floats that represents the depth along the well log curves in a curvebox.
  curve_data: An array of arrays of strings that can be parsed into floats that represents each of the well log curves in a curvebox.
  UWI: A string for the well log UWI ID
  CurveNames: An array of strings that represent curvenames, one for each well log curve in curve_data
  Returns: An array of objects properly formatted for next step ___.
```

--------------------------------

### Convert Wellio JSON to D3.js Plotting Object

Source: https://justingosses.github.io/wellioviz/index

This function transforms wellio-style JSON data, an array of curve names, and a UWI string into an array of objects. The output format is specifically designed for consumption by D3.js for data visualization and plotting.

```APIDOC
convertWellJSONToObj(well_log_json: object, CurveNames: array, UWI: string, depth_curve_name: any): array
  well_log_json: a full wellio style JSON
  CurveNames: array of curve names as strings
  UWI: a string the represents the well name
  depth_curve_name: any
Returns: array
  returns array of objects that contain key:value pairs of curve name and value at each depth. Depth is also a key:value pair.
```

--------------------------------

### Reformat Curve Arrays for D3.js Plotting

Source: https://justingosses.github.io/wellioviz/index

This function is designed to reformat raw arrays of curve values into an array of objects, a structure that is more compatible with D3.js for plotting. The source documentation indicates that this function is currently too explicit and requires refactoring.

```APIDOC
takeInArraysAndGetObjectOfCurveDataForPlotting(arraysOfCurvesAndNames: any, CurveName: any, DepthName: any)
  arraysOfCurvesAndNames: any
  CurveName: any
  DepthName: any
```

--------------------------------

### Combine Multiple Log Plots into a Single Container

Source: https://justingosses.github.io/wellioviz/index

Takes a list of individual well log plot templates (each representing a curve or set of curves) and combines them into a single HTML div. This function facilitates displaying multiple curves for a single well in a unified view, creating sub-divs with SVGs for each curve.

```Python
result_1 = wellioviz.multipleLogPlot("well_holder",[gr_plot_template_noFill,resd_plot_template_1,poro_plot_template_1])
```

--------------------------------

### format_log Function API Reference

Source: https://justingosses.github.io/wellioviz/index

Documents the `format_log` function, which takes a dictionary of wellio-style curves and a specific curve name, returning an array of objects formatted for D3.js plotting. This function is crucial for preparing well log data for visualization by structuring depth and curve value pairs.

```APIDOC
format_log(curve_dict: object, curve_name: string): array
  Parameters:
    curve_dict (object): wellio style curves
    curve_name (string): the name of the curve to format
  Returns:
    array: returns array of objects that contain key:value pairs of curve name and value at each depth. Depth is also a key:value pair.
```

--------------------------------

### Extract Plotting Data from Wellio JSON

Source: https://justingosses.github.io/wellioviz/index

This function takes wellio-style JSON and a depth curve name, returning an object containing three key elements: reformatted D3.js data, curve names, and the UWI. This aggregated object is intended for subsequent use in plotting functions.

```APIDOC
fromJSONofWEllGetThingsForPlotting(jsonWell: object, depth_curve_name: string): array
  jsonWell: a full wellio style JSON
  depth_curve_name: String for the depth curve name
Returns: array
  returns an object of 3 things that will eventually be used in plotting. {"well_log_curves_reformatted_for_d3":well_log_curves_reformatted_for_d3,"curve_names":curve_names,"uwi":uwi}
```

--------------------------------

### Wellioviz curveBox() Function API Reference

Source: https://justingosses.github.io/wellioviz/index

Documents the `curveBox()` function, the primary plotting function in wellioviz. It accepts well log data and configuration in a standard format to render curves. The function's default behavior of clearing existing content in a target div can be modified, allowing for multiple curves within the same container.

```APIDOC
wellioviz.curveBox(data: object, config: object, targetDiv: HTMLElement)
  data: Object - Contains well log data in a standard format. Example structure can be seen via `wellioviz.curveBoxTemplateExamples("example")`.
  config: Object - Contains configuration options for plotting, such as colors, line thickness, fill colors, cutoffs, width, height, and percentage of well visible via scrolling. Definitions for keys can be found via `wellioviz.curveBoxTemplateExamples("definitions")`.
  targetDiv: HTMLElement - The HTML element (div) where the curveBox should be rendered.

Behavior:
  - Renders well log curves based on the provided data and configuration.
  - By default, clears any existing curveBox content within the `targetDiv` before rendering new content.
  - Future functionality aims to allow developers to disable this default clearing behavior, enabling the addition of multiple curves to the same div without requiring manual handling of div creation.
```
Tokens:
Raw