HEAVY.AI Docs
v9.0.0 (Latest)
v9.0.0 (Latest)
  • Welcome to HEAVY.AI Documentation
  • Overview
    • Overview
    • Release Notes
  • Installation and Configuration
    • System Requirements
      • Hardware Reference
      • Software Requirements
      • Licensing
    • Installation
      • Free Version
      • Installing on Docker
        • HEAVY.AI Installation using Docker on Ubuntu
      • Installing on Ubuntu
        • HEAVY.AI Installation on Ubuntu
        • Install NVIDIA Drivers and Vulkan on Ubuntu
      • Installing on Rocky Linux / RHEL
        • HEAVY.AI Installation on RHEL
        • Install NVIDIA Drivers and Vulkan on Rocky Linux and RHEL
      • Getting Started on AWS
      • Getting Started on GCP
      • Getting Started on Azure
      • Getting Started on Kubernetes (BETA)
      • Upgrading
        • Upgrading HEAVY.AI
        • Upgrading from Omnisci to HEAVY.AI 6.0
        • CUDA Compatibility Drivers
      • Uninstalling
      • Ports
    • Services and Utilities
      • Using Services
      • Using Utilities
    • Executor Resource Manager
    • Configuration Parameters
      • Overview
      • Configuration Parameters for HeavyDB
      • Configuration Parameters for HEAVY.AI Web Server
      • Configuration Parameters for HeavyIQ
    • Security
      • Roles and Privileges
        • Column-Level Security
      • Connecting Using SAML
      • Implementing a Secure Binary Interface
      • Encrypted Credentials in Custom Applications
      • LDAP Integration
    • Distributed Configuration
  • Loading and Exporting Data
    • Supported Data Sources
      • Kafka
      • Using HeavyImmerse Data Manager
      • Importing Geospatial Data
    • Command Line
      • Loading Data with SQL
      • Exporting Data
  • SQL
    • Data Definition (DDL)
      • Datatypes
      • Users and Databases
      • Tables
      • System Tables
      • Views
      • Policies
      • Comment
    • Data Manipulation (DML)
      • SQL Capabilities
        • ALTER SESSION SET
        • ALTER SYSTEM CLEAR
        • DELETE
        • EXPLAIN
        • INSERT
        • KILL QUERY
        • LIKELY/UNLIKELY
        • SELECT
        • SHOW
        • UPDATE
        • Arrays
        • Logical Operators and Conditional and Subquery Expressions
        • Table Expression and Join Support
        • Type Casts
      • Geospatial Capabilities
        • Uber H3 Hexagonal Modeling
      • Functions and Operators
      • System Table Functions
        • generate_random_strings
        • generate_series
        • tf_compute_dwell_times
        • tf_feature_self_similarity
        • tf_feature_similarity
        • tf_geo_rasterize
        • tf_geo_rasterize_slope
        • tf_graph_shortest_path
        • tf_graph_shortest_paths_distances
        • tf_load_point_cloud
        • tf_mandelbrot*
        • tf_point_cloud_metadata
        • tf_raster_contour_lines; tf_raster_contour_polygons
        • tf_raster_graph_shortest_slope_weighted_path
        • tf_rf_prop_max_signal (Directional Antennas)
        • ts_rf_prop_max_signal (Isotropic Antennas)
        • tf_rf_prop
      • Window Functions
      • Reserved Words
      • SQL Extensions
      • HeavyIQ LLM_TRANSFORM
  • HeavyImmerse
    • Introduction to HeavyImmerse
    • Admin Portal
    • Control Panel
    • Working with Dashboards
      • Dashboard List
      • Creating a Dashboard
      • Configuring a Dashboard
      • Duplicating and Sharing Dashboards
    • Measures and Dimensions
    • Using Parameters
    • Using Filters
    • Using Cross-link
    • Color Consistency
    • Chart Animation
    • Multilayer Charts
    • SQL Editor
    • Customization
    • Joins (Beta)
    • Chart Types
      • Overview
      • Box/Whisker and Violin Plots
      • Bubble
      • Choropleth
      • Combo
      • Contour
      • Cross-Section
      • Gauge
      • Geo Heatmap
      • Heatmap
      • Linemap
      • Number
      • Pie
      • Pointmap
      • Scatter Plot
      • Skew-T
      • Table
      • Text Widget
      • Wind Barb
    • Deprecated Charts
      • Bar
      • Combo - Original
      • Histogram
      • Line
      • Stacked Bar
    • HeavyIQ SQL Notebook
  • HEAVYIQ Conversational Analytics
    • HeavyIQ Overview
      • HeavyIQ Guidance
    • HeavyIQ Model Overview (HeavyLM)
  • HeavyRF
    • Introduction to HeavyRF
    • Getting Started
    • HeavyRF Table Functions
  • HeavyConnect
    • HeavyConnect Release Overview
    • Getting Started
    • Best Practices
    • Examples
    • Command Reference
    • Parquet Data Wrapper Reference
    • ODBC Data Wrapper Reference
    • Raster Data Wrapper Reference
  • HeavyML (BETA)
    • HeavyML Overview
    • Clustering Algorithms
    • Regression Algorithms
      • Linear Regression
      • Random Forest Regression
      • Decision Tree Regression
      • Gradient Boosting Tree Regression
    • Principal Components Analysis
  • Python / Data Science
    • Data Science Foundation
    • JupyterLab Installation and Configuration
    • Using HEAVY.AI with JupyterLab
    • Python User-Defined Functions (UDFs) with the Remote Backend Compiler (RBC)
      • Installation
      • Registering and Using a Function
      • User-Defined Table Functions
      • RBC UDF/UDTF Example Notebooks
      • General UDF/UDTF Tutorial Notebooks
      • RBC API Reference
    • Ibis
    • Interactive Data Exploration with Altair
    • Additional Examples
      • Forecasting with HEAVY.AI and Prophet
  • APIs and Interfaces
    • Overview
    • heavysql
    • Thrift
    • JDBC
    • ODBC
    • Vega
      • Vega Tutorials
        • Vega at a Glance
        • Getting Started with Vega
        • Getting More from Your Data
        • Creating More Advanced Charts
        • Using Polys Marks Type
        • Vega Accumulator
        • Using Transform Aggregation
        • Improving Rendering with SQL Extensions
      • Vega Reference Overview
        • data Property
        • projections Property
        • scales Property
        • marks Property
      • Migration
        • Migrating Vega Code to Dynamic Poly Rendering
      • Try Vega
    • RJDBC
    • SQuirreL SQL
    • heavyai-connector
  • Tutorials and Demos
    • Loading Data
    • Using Heavy Immerse
    • Hello World
    • Creating a Kafka Streaming Application
    • Getting Started with Open Source
    • Try Vega
  • Troubleshooting and Special Topics
    • FAQs
    • Troubleshooting
    • Vulkan Renderer
    • Optimizing
    • Known Issues and Limitations
    • Logs and Monitoring
    • Archived Release Notes
      • Release 7.x
      • Release 6.x
      • Release 5.x
      • Release 4.x
      • Release 3.x
Powered by GitBook
On this page
  • Supported Charts
  • Automatic Categorical Color Consistency
  • Customized Color Consistency - Introduction to Color Mappings
  • Managing Color Mappings
  • Importing Color Mappings
Export as PDF
  1. HeavyImmerse

Color Consistency

PreviousUsing Cross-linkNextChart Animation

Last updated 4 days ago

As of version 8.5.3, Immerse has taken large steps to address previous issues with color consistency across different charts. Let's explore these changes and see how they can benefit your workflows and data analysis.

Supported Charts

Here are the charts that received the new Color Consistency updates as of 8.5.3:

  • Combo

  • Pie

  • Bubble

  • Box Plot

  • Pointmap

  • Linemap

  • Choropleth

Automatic Categorical Color Consistency

First, supported charts now offer out-of-the-box color consistency for categorically-colored columns. Immerse uses a hash function to drive the coloring, ensuring that identical values across different data sources and columns will receive the same colors. Let's look at the following two charts as an example:

It's important to note that these charts use two completely different data sources. The Combo chart uses a flights dataset, colored by destination state abbreviation, while the Choropleth uses a dataset on US counties, colored by state abbreviation. Despite the different data sources, the coloring remains consistent across both charts. In the screenshot above, we highlighted three states on the Combo chart: Washington (in blue), Nevada (in dark purple), and Arizona (in pink). You'll see these states have matching colors on the Choropleth.

This demonstrates the power of hash coloring: the same values, when processed by the hash function, will always produce the same colors. This eliminates the need for manual work to ensure color consistency.

While hash coloring brings significant benefits, it does introduce one minor side effect: hash collisions. You might notice this, for example, on the Combo chart where two green bars appear next to each other. In previous versions, Immerse prevented such adjacent duplicates by simply assigning colors sequentially from the palette. However, this method meant there was no guarantee of color consistency across different charts. Our new hash-based approach prioritizes consistency, offering immediate benefits for data analysis, even with the rare occurrence of a collision. Fortunately, reassigning colors is straightforward, as we will cover in the next section.

Customized Color Consistency - Introduction to Color Mappings

To streamline your workflow and enhance color consistency, we've implemented a new tool called Color Mappings. This allows you to easily carry over your customized color schemes from one chart to another, eliminating the need for repetitive adjustments and saving you valuable time.

First let's look at new ways to assign colors in the chart editor. As before, to re-assign a color, you click on a swatch in the values list on the right side of the chart editor. While previously you could only choose between colors in the selected palette, we have now added a free color picker - you can choose whatever color you would like, or select from the existing palette. The current color will automatically be selected in the color picker, as well as in the current palette list, to show the value is currently assigned to a color in the selected palette:

If you decide to pick a color from the color picker that is not in the current palette, this will be registered as an "Additional Color", and will be saved so that you can pick the same color for other values, if you so choose. Let's choose a dark blue color for the current value, then click on a different swatch:

As you can see, the first swatch in the list, which we were previously editing, has changed to the dark blue color we selected from the color picker. We can now see a new section has appeared below our palette selection, called "Additional Colors" - this shows all custom (as-in, non-palette colors) currently in use in the chart. If we click on the swatch for the second item in our list, we now see another section displayed below "Palette Colors", which allows you to select additional colors used previously in this chart.

Now let's explore how we can carry over custom color modifications between charts. To illustrate this, in the example below we have re-assigned the colors for numerous values to different shades of blue. To save these customizations, we need to create a new Color Mapping. To do this, click the plus button, as shown below:

Once you click this button to create a color mapping, a modal will open asking you to provide a name for the current mapping. This will help you to distinguish between different Color Mappings you create. Once you input a name and click save, you will see a new section appear above the palette selector:

This shows that a Color Mapping is currently assigned to this chart; you can see the custom name given to the mapping, as well as a preview of what the assigned colors currently look like. We will revisit this section later, but for now, let's go to our Choropleth chart and see how we can apply this mapping created in our Combo chart.

In the chart editor for our Choropleth chart, click on the "Manage" button in the Color Mapping section - this will bring up the menu below:

This is the Color Mapping Manager, which allows us to select which Color Mapping we want to assign to our current chart. Notice that at the top, we get a message saying we don't have any mappings that match our current data source and column - remember, we used two different sources for the Combo and Choropleth. When assigning mappings created from different data sources and columns, there is no guarantee that the values the colors are assigned to will match up with the values in your current column; for all the values that do not match, the colors will simply be auto-hashed based on your current palette. However, since we know these two columns contain state abbreviations and will in fact match, we are safe to use our "Kind of Blue" mapping created previously. Simply click on that mapping to assign it to the current chart.

Have a look at the result below - all those blue colors, that we assigned and customized in our Combo chart, are now assigned to the same values in our Choropleth:

This eliminates painstakingly having to customize each chart individually, and allows us to ensure color consistency between charts while being able to make modifications to the auto-generated colors.

Managing Color Mappings

Now we will take a look at what options we have when working with existing Color Mappings. To make modifications to a Color Mapping, it must be assigned to your current chart in the chart editor. Let's see what happens when we modify a color after having assigned a mapping:

Here we have re-assigned the color for the first item in our list, "VI", to red. Notice how a warning icon has appeared above the Color Mapping - this indicates that an unsaved change has been made to the mapping. If we want to save this modification, click the disk icon to the right of the mapping. This will automatically apply the change to all charts that are currently using this mapping (even across different dashboard tabs). Please Note: if you click "Apply" to leave the chart editor, all unsaved Color Mapping changes will be auto-saved, updating the mapping for all charts which have it applied.

Next to the warning icon, we see a "Reset" button - clicking that will eliminate any unsaved changes, reverting the mapping to its previously saved state.

The trash can icon will delete the current mapping - once clicked, this cannot be reversed. Any charts that had the mapping applied will keep the colors from the mapping. To reset back to the original auto-hashed colors, simply remove and re-add the categorical field driving the coloring (whether it's assigned via a dimension, color measure, etc.).

Below the Color Mapping, there is a "Remove Mapping" button. This will remove the current mapping assigned to the chart; however, all colors will remain as they were when the mapping is applied. This is useful for one-off changes that you do not want saved in your mapping - say, for example, on this chart you do want "VI" to be red, but you don't want that to be carried over to other charts using your mapping. Simply click "Remove Mapping", and you will keep all the colors from the mapping as well as your changes, and you can save the chart without affecting other charts.

Importing Color Mappings

Color Mappings can also be imported from other dashboards, saving you from having to re-create mappings on each dashboard. To import a Color Mapping, click the "Manage" button, and click on the "Import" button in the Color Mapping Manager:

Here you will find a list of all the dashboards available on your current instance. You can use the search bar at the top to search for specific dashboards. Once you have found the dashboard you wish to import a mapping from, click on it.

Here we have found another dashboard with a saved Color Mapping for state abbreviations. As you can see, this was created from a different data source than the one applied to our current chart, so we get the same message we saw earlier. However, because we know they are both based on state abbreviations, we are fine to proceed. Click on the "Import" button to bring that mapping into your current dashboard.

One note - mappings imported across dashboards do not retain links to their original source. This means, if we import the "Multi-Colored State Abbreviations" mapping into our own dashboard and make changes, saved changes will not affect the original mapping. Each mapping is local to its dashboard, so you are free to import mappings and make changes without worrying about effecting other dashboards.