@aguacerowx/react-native 0.0.31 → 0.0.32

package/src/WeatherLayerManager.js

@@ -1,7 +1,7 @@
 // packages/react-native/src/WeatherLayerManager.js
 
 import React, { useState, useRef, useContext, useEffect, forwardRef, useImperativeHandle, useMemo } from 'react';
-import { AguaceroCore, getUnitConversionFunction } from '@aguacerowx/javascript-sdk';
+import { AguaceroCore, getUnitConversionFunction, DICTIONARIES } from '@aguacerowx/javascript-sdk';
 import { AguaceroContext } from './AguaceroContext';
 import { GridRenderLayer } from './GridRenderLayer';
 import { fromByteArray } from 'base64-js';
@@ -282,13 +282,38 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 }
                 
                 const { baseUnit } = core._getColormapForVariable(variable);
-                const toUnit = core._getTargetUnit(baseUnit, units);
                 
+                const toUnit = core._getTargetUnit(baseUnit, units);
+
+                const fieldInfo = DICTIONARIES?.fld?.[variable] || {};
+                const serverDataUnit = fieldInfo.defaultUnit || baseUnit;
+
                 let dataScale = result.scale;
                 let dataOffset = result.offset;
-                
+
                 let convertedScale = dataScale;
                 let convertedOffset = dataOffset;
+
+                if (serverDataUnit !== baseUnit) {
+                    const conversionFunc = getUnitConversionFunction(serverDataUnit, baseUnit);
+                    if (conversionFunc) {
+                        if (result.scaleType === 'sqrt') {
+                            const physicalAtOffset = dataOffset * dataOffset;
+                            const physicalAtOffsetPlusScale = (dataOffset + dataScale) * (dataOffset + dataScale);
+                            const convertedPhysicalAtOffset = conversionFunc(physicalAtOffset);
+                            const convertedPhysicalAtOffsetPlusScale = conversionFunc(physicalAtOffsetPlusScale);
+                            convertedOffset = Math.sqrt(Math.abs(convertedPhysicalAtOffset)) * Math.sign(convertedPhysicalAtOffset);
+                            const newOffsetPlusScale = Math.sqrt(Math.abs(convertedPhysicalAtOffsetPlusScale)) * Math.sign(convertedPhysicalAtOffsetPlusScale);
+                            convertedScale = newOffsetPlusScale - convertedOffset;
+                        } else {
+                            convertedOffset = conversionFunc(dataOffset);
+                            const convertedOffsetPlusScale = conversionFunc(dataOffset + dataScale);
+                            convertedScale = convertedOffsetPlusScale - convertedOffset;
+                        }
+                        dataScale = convertedScale;
+                        dataOffset = convertedOffset;
+                    }
+                }
                 
                 if (baseUnit !== toUnit) {
                     const conversionFunc = getUnitConversionFunction(baseUnit, toUnit);
@@ -307,7 +332,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                             convertedScale = convertedOffsetPlusScale - convertedOffset;
                         }
                     }
-                }
+                } 
                 
                 const frameData = {
                     filePath: result.filePath,
@@ -378,8 +403,11 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                         return;
                     }
                     
+                    // ADD: Same two-step conversion as the current frame
                     const { baseUnit } = core._getColormapForVariable(variable);
                     const toUnit = core._getTargetUnit(baseUnit, units);
+                    const fieldInfo = DICTIONARIES?.fld?.[variable] || {};
+                    const serverDataUnit = fieldInfo.defaultUnit || baseUnit;
                     
                     let dataScale = result.scale;
                     let dataOffset = result.offset;
@@ -387,6 +415,29 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                     let convertedScale = dataScale;
                     let convertedOffset = dataOffset;
                     
+                    // Step 1: Convert from server unit to colormap base unit
+                    if (serverDataUnit !== baseUnit) {
+                        const conversionFunc = getUnitConversionFunction(serverDataUnit, baseUnit);
+                        if (conversionFunc) {
+                            if (result.scaleType === 'sqrt') {
+                                const physicalAtOffset = dataOffset * dataOffset;
+                                const physicalAtOffsetPlusScale = (dataOffset + dataScale) * (dataOffset + dataScale);
+                                const convertedPhysicalAtOffset = conversionFunc(physicalAtOffset);
+                                const convertedPhysicalAtOffsetPlusScale = conversionFunc(physicalAtOffsetPlusScale);
+                                convertedOffset = Math.sqrt(Math.abs(convertedPhysicalAtOffset)) * Math.sign(convertedPhysicalAtOffset);
+                                const newOffsetPlusScale = Math.sqrt(Math.abs(convertedPhysicalAtOffsetPlusScale)) * Math.sign(convertedPhysicalAtOffsetPlusScale);
+                                convertedScale = newOffsetPlusScale - convertedOffset;
+                            } else {
+                                convertedOffset = conversionFunc(dataOffset);
+                                const convertedOffsetPlusScale = conversionFunc(dataOffset + dataScale);
+                                convertedScale = convertedOffsetPlusScale - convertedOffset;
+                            }
+                            dataScale = convertedScale;
+                            dataOffset = convertedOffset;
+                        }
+                    }
+                    
+                    // Step 2: Convert from colormap base unit to target display unit
                     if (baseUnit !== toUnit) {
                         const conversionFunc = getUnitConversionFunction(baseUnit, toUnit);
                         if (conversionFunc) {
@@ -815,9 +866,33 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 if (cachedData && cachedData.originalScale !== undefined && cachedData.originalOffset !== undefined) {
                     const { baseUnit } = core._getColormapForVariable(variable);
                     const toUnit = core._getTargetUnit(baseUnit, units);
+                    const fieldInfo = DICTIONARIES?.fld?.[variable] || {};
+                    const serverDataUnit = fieldInfo.defaultUnit || baseUnit;
+                    
                     let dataScale = cachedData.originalScale;
                     let dataOffset = cachedData.originalOffset;
                     
+                    if (serverDataUnit !== baseUnit) {
+                        const conversionFunc = getUnitConversionFunction(serverDataUnit, baseUnit);
+                        if (conversionFunc) {
+                            if (cachedData.scaleType === 'sqrt') {
+                                const physicalAtOffset = dataOffset * dataOffset;
+                                const physicalAtOffsetPlusScale = (dataOffset + dataScale) * (dataOffset + dataScale);
+                                const convertedPhysicalAtOffset = conversionFunc(physicalAtOffset);
+                                const convertedPhysicalAtOffsetPlusScale = conversionFunc(physicalAtOffsetPlusScale);
+                                const newOffset = Math.sqrt(Math.abs(convertedPhysicalAtOffset)) * Math.sign(convertedPhysicalAtOffset);
+                                const newOffsetPlusScale = Math.sqrt(Math.abs(convertedPhysicalAtOffsetPlusScale)) * Math.sign(convertedPhysicalAtOffsetPlusScale);
+                                dataScale = newOffsetPlusScale - newOffset;
+                                dataOffset = newOffset;
+                            } else {
+                                const convertedOffset = conversionFunc(dataOffset);
+                                const convertedOffsetPlusScale = conversionFunc(dataOffset + dataScale);
+                                dataScale = convertedOffsetPlusScale - convertedOffset;
+                                dataOffset = convertedOffset;
+                            }
+                        }
+                    }
+                    
                     if (baseUnit !== toUnit) {
                         const conversionFunc = getUnitConversionFunction(baseUnit, toUnit);
                         if (conversionFunc) {