You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@superset.apache.org by di...@apache.org on 2025/07/08 15:37:54 UTC

(superset) branch master updated: feat(deck-gl): Enable individual deck.gl layer selection in FilterScope tree (#33769)

This is an automated email from the ASF dual-hosted git repository.

diegopucci pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/superset.git


The following commit(s) were added to refs/heads/master by this push:
     new 85034b9748 feat(deck-gl): Enable individual deck.gl layer selection in FilterScope tree (#33769)
85034b9748 is described below

commit 85034b9748c50a08b8d9b710db8408b68f49a95c
Author: Richard Fogaca Nienkotter <63...@users.noreply.github.com>
AuthorDate: Tue Jul 8 12:37:47 2025 -0300

    feat(deck-gl): Enable individual deck.gl layer selection in FilterScope tree (#33769)
    
    Co-authored-by: richardfn <ri...@appsilon.com>
    Co-authored-by: amaannawab923 <am...@gmail.com>
---
 CONTRIBUTING.md                                    |   2 +-
 .../legacy-preset-chart-deckgl/src/Multi/Multi.tsx | 223 ++++++--
 .../components/SyncDashboardState/index.tsx        |  12 +-
 .../components/nativeFilters/FilterBar/index.tsx   |   8 +-
 .../FiltersConfigForm/FilterScope/ScopingTree.tsx  | 118 +++-
 .../FiltersConfigForm/FilterScope/state.ts         |  21 +-
 .../FiltersConfigForm/FilterScope/types.ts         |   4 +
 .../FiltersConfigForm/FilterScope/utils.ts         | 179 +++++-
 .../dashboard/components/nativeFilters/utils.ts    | 163 ++++++
 superset-frontend/src/dashboard/types.ts           |   7 +
 .../dashboard/util/activeAllDashboardFilters.ts    | 122 +++-
 .../util/charts/getFormDataWithExtraFilters.ts     |  97 +++-
 .../src/dashboard/util/getChartIdsInFilterScope.ts |  55 +-
 .../components/ExploreViewContainer/index.jsx      |  24 +-
 .../controls/FilterControl/AdhocFilter/index.js    |   2 +
 .../FilterControl/AdhocFilterEditPopover/index.jsx | 160 +++++-
 .../getFormDataWithDashboardContext.ts             |  95 +++-
 superset-frontend/src/pages/Chart/index.tsx        |  19 +-
 .../src/types/DashboardContextForExplore.ts        |   3 +-
 superset-frontend/src/utils/simpleFilterToAdhoc.ts |  43 +-
 superset/viz.py                                    | 162 +++++-
 tests/integration_tests/viz_tests.py               | 614 +++++++++++++++++++++
 22 files changed, 1959 insertions(+), 174 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5dbf90157f..06ed3b146c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -5,7 +5,7 @@
  regarding copyright ownership.  The ASF licenses this file
  to you under the Apache License, Version 2.0 (the
  "License"); you may not use this file except in compliance
- with the License.  You may obtain a copy of the License at
+ with the License. You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
diff --git a/superset-frontend/plugins/legacy-preset-chart-deckgl/src/Multi/Multi.tsx b/superset-frontend/plugins/legacy-preset-chart-deckgl/src/Multi/Multi.tsx
index 153a3e7917..d11d5ae21f 100644
--- a/superset-frontend/plugins/legacy-preset-chart-deckgl/src/Multi/Multi.tsx
+++ b/superset-frontend/plugins/legacy-preset-chart-deckgl/src/Multi/Multi.tsx
@@ -22,11 +22,15 @@
 import { memo, useCallback, useEffect, useRef, useState } from 'react';
 import { isEqual } from 'lodash';
 import {
+  AdhocFilter,
   Datasource,
+  ensureIsArray,
   HandlerFunction,
+  isDefined,
   JsonObject,
   JsonValue,
   QueryFormData,
+  QueryObjectFilterClause,
   SupersetClient,
   usePrevious,
 } from '@superset-ui/core';
@@ -107,70 +111,175 @@ const DeckMulti = (props: DeckMultiProps) => {
     }
   }, []);
 
+  const getLayerIndex = useCallback(
+    (sliceId: number, payloadIndex: number, deckSlices?: number[]): number =>
+      deckSlices ? deckSlices.indexOf(sliceId) : payloadIndex,
+    [],
+  );
+
+  const processLayerFilters = useCallback(
+    (
+      subslice: JsonObject,
+      formData: QueryFormData,
+      layerIndex: number,
+    ): {
+      extraFilters: (AdhocFilter | QueryObjectFilterClause)[];
+      adhocFilters: AdhocFilter[];
+    } => {
+      const layerFilterScope = formData.layer_filter_scope;
+
+      const extraFilters: (AdhocFilter | QueryObjectFilterClause)[] = [
+        ...(subslice.form_data.extra_filters || []),
+        ...(formData.extra_filters || []),
+      ];
+
+      const adhocFilters: AdhocFilter[] = [
+        ...(subslice.form_data?.adhoc_filters || []),
+      ];
+
+      if (layerFilterScope) {
+        const filterDataMapping = formData.filter_data_mapping || {};
+        let shouldAddDashboardAdhocFilters = false;
+
+        Object.entries(layerFilterScope).forEach(
+          ([filterId, filterScope]: [string, number[]]) => {
+            const shouldApplyFilter =
+              ensureIsArray(filterScope).includes(layerIndex);
+
+            if (shouldApplyFilter) {
+              shouldAddDashboardAdhocFilters = true;
+              const filtersFromThisFilter = filterDataMapping[filterId] || [];
+              extraFilters.push(...filtersFromThisFilter);
+            }
+          },
+        );
+
+        if (shouldAddDashboardAdhocFilters) {
+          const dashboardAdhocFilters = formData.adhoc_filters || [];
+          adhocFilters.push(...dashboardAdhocFilters);
+        }
+      } else {
+        const originalExtraFormDataFilters =
+          formData.extra_form_data?.filters || [];
+        extraFilters.push(...originalExtraFormDataFilters);
+
+        const dashboardAdhocFilters = formData.adhoc_filters || [];
+        adhocFilters.push(...dashboardAdhocFilters);
+      }
+
+      return { extraFilters, adhocFilters };
+    },
+    [],
+  );
+
+  const createLayerFromData = useCallback(
+    (subslice: JsonObject, json: JsonObject): Layer =>
+      // @ts-ignore TODO(hainenber): define proper type for `form_data.viz_type` and call signature for functions in layerGenerators.
+      layerGenerators[subslice.form_data.viz_type](
+        subslice.form_data,
+        json,
+        props.onAddFilter,
+        setTooltip,
+        props.datasource,
+        [],
+        props.onSelect,
+      ),
+    [props.onAddFilter, props.onSelect, props.datasource, setTooltip],
+  );
+
+  const loadSingleLayer = useCallback(
+    (
+      subslice: JsonObject,
+      formData: QueryFormData,
+      payloadIndex: number,
+    ): void => {
+      const layerIndex = getLayerIndex(
+        subslice.slice_id,
+        payloadIndex,
+        formData.deck_slices,
+      );
+      let extraFilters: (AdhocFilter | QueryObjectFilterClause)[] = [];
+      let adhocFilters: AdhocFilter[] = [];
+      const isExplore = (window.location.href || '').includes('explore');
+      if (isExplore) {
+        // in explore all the filters are in the adhoc_filters
+        const adhocFiltersFromFormData = formData.adhoc_filters || [];
+        const finalAdhocFilters = adhocFiltersFromFormData
+          .map((filter: AdhocFilter & { layerFilterScope?: number[] }) => {
+            if (!isDefined(filter?.layerFilterScope)) {
+              return filter;
+            }
+            if (
+              Array.isArray(filter.layerFilterScope) &&
+              filter.layerFilterScope.length > 0
+            ) {
+              if (filter.layerFilterScope.includes(-1)) {
+                return filter;
+              }
+              if (filter.layerFilterScope.includes(layerIndex)) {
+                return filter;
+              }
+            }
+            return undefined;
+          })
+          .filter(filter => isDefined(filter));
+        adhocFilters = finalAdhocFilters as AdhocFilter[];
+      } else {
+        const {
+          extraFilters: processLayerFiltersResultExtraFilters,
+          adhocFilters: processLayerFiltersResultAdhocFilters,
+        } = processLayerFilters(subslice, formData, layerIndex);
+        extraFilters = processLayerFiltersResultExtraFilters;
+        adhocFilters = processLayerFiltersResultAdhocFilters;
+      }
+
+      const subsliceCopy = {
+        ...subslice,
+        form_data: {
+          ...subslice.form_data,
+          extra_filters: extraFilters,
+          adhoc_filters: adhocFilters,
+        },
+      } as any as JsonObject & { slice_id: number };
+
+      const url = getExploreLongUrl(subsliceCopy.form_data, 'json');
+
+      if (url) {
+        SupersetClient.get({ endpoint: url })
+          .then(({ json }) => {
+            const layer = createLayerFromData(subsliceCopy, json);
+            setSubSlicesLayers(subSlicesLayers => ({
+              ...subSlicesLayers,
+              [subsliceCopy.slice_id]: layer,
+            }));
+          })
+          .catch(error => {
+            console.error(
+              `Error loading layer for slice ${subsliceCopy.slice_id}:`,
+              error,
+            );
+          });
+      }
+    },
+    [getLayerIndex, processLayerFilters, createLayerFromData],
+  );
+
   const loadLayers = useCallback(
-    (formData: QueryFormData, payload: JsonObject, viewport?: Viewport) => {
+    (
+      formData: QueryFormData,
+      payload: JsonObject,
+      viewport?: Viewport,
+    ): void => {
       setViewport(getAdjustedViewport());
       setSubSlicesLayers({});
+
       payload.data.slices.forEach(
-        (subslice: { slice_id: number } & JsonObject) => {
-          // Filters applied to multi_deck are passed down to underlying charts
-          // note that dashboard contextual information (filter_immune_slices and such) aren't
-          // taken into consideration here
-          const extra_filters = [
-            ...(subslice.form_data.extra_filters || []),
-            ...(formData.extra_filters || []),
-            ...(formData.extra_form_data?.filters || []),
-          ];
-
-          const adhoc_filters = [
-            ...(formData.adhoc_filters || []),
-            ...(subslice.formData?.adhoc_filters || []),
-            ...(formData.extra_form_data?.adhoc_filters || []),
-          ];
-
-          const subsliceCopy = {
-            ...subslice,
-            form_data: {
-              ...subslice.form_data,
-              extra_filters,
-              adhoc_filters,
-            },
-          };
-
-          const url = getExploreLongUrl(subsliceCopy.form_data, 'json');
-
-          if (url) {
-            SupersetClient.get({
-              endpoint: url,
-            })
-              .then(({ json }) => {
-                // @ts-ignore TODO(hainenber): define proper type for `form_data.viz_type` and call signature for functions in layerGenerators.
-                const layer = layerGenerators[subsliceCopy.form_data.viz_type](
-                  subsliceCopy.form_data,
-                  json,
-                  props.onAddFilter,
-                  setTooltip,
-                  props.datasource,
-                  [],
-                  props.onSelect,
-                );
-                setSubSlicesLayers(subSlicesLayers => ({
-                  ...subSlicesLayers,
-                  [subsliceCopy.slice_id]: layer,
-                }));
-              })
-              .catch(() => {});
-          }
+        (subslice: { slice_id: number } & JsonObject, payloadIndex: number) => {
+          loadSingleLayer(subslice, formData, payloadIndex);
         },
       );
     },
-    [
-      props.datasource,
-      props.onAddFilter,
-      props.onSelect,
-      setTooltip,
-      getAdjustedViewport,
-    ],
+    [getAdjustedViewport, loadSingleLayer],
   );
 
   const prevDeckSlices = usePrevious(props.formData.deck_slices);
diff --git a/superset-frontend/src/dashboard/components/SyncDashboardState/index.tsx b/superset-frontend/src/dashboard/components/SyncDashboardState/index.tsx
index 27f649fb1f..51655e057c 100644
--- a/superset-frontend/src/dashboard/components/SyncDashboardState/index.tsx
+++ b/superset-frontend/src/dashboard/components/SyncDashboardState/index.tsx
@@ -29,6 +29,7 @@ import {
 } from 'src/utils/localStorageHelpers';
 import { RootState } from 'src/dashboard/types';
 import { getActiveFilters } from 'src/dashboard/util/activeDashboardFilters';
+import { getAllActiveFilters } from 'src/dashboard/util/activeAllDashboardFilters';
 import { enforceSharedLabelsColorsArray } from 'src/utils/colorScheme';
 import { Divider, Filter } from '@superset-ui/core';
 
@@ -65,8 +66,9 @@ const selectDashboardContextForExplore = createSelector(
     (state: RootState) => state.dashboardState?.colorScheme,
     (state: RootState) => state.nativeFilters?.filters,
     (state: RootState) => state.dataMask,
+    (state: RootState) => state.dashboardState?.sliceIds || [],
   ],
-  (metadata, dashboardId, colorScheme, filters, dataMask) => {
+  (metadata, dashboardId, colorScheme, filters, dataMask, sliceIds) => {
     const nativeFilters = Object.keys(filters).reduce<
       Record<string, Pick<Filter | Divider, 'chartsInScope'>>
     >((acc, key) => {
@@ -74,6 +76,13 @@ const selectDashboardContextForExplore = createSelector(
       return acc;
     }, {});
 
+    const activeFilters = getAllActiveFilters({
+      chartConfiguration: metadata?.chart_configuration || EMPTY_OBJECT,
+      nativeFilters: filters,
+      dataMask,
+      allSliceIds: sliceIds,
+    });
+
     return {
       labelsColor: metadata?.label_colors || EMPTY_OBJECT,
       labelsColorMap: metadata?.map_label_colors || EMPTY_OBJECT,
@@ -86,6 +95,7 @@ const selectDashboardContextForExplore = createSelector(
       dataMask,
       dashboardId,
       filterBoxFilters: getActiveFilters(),
+      activeFilters,
     };
   },
 );
diff --git a/superset-frontend/src/dashboard/components/nativeFilters/FilterBar/index.tsx b/superset-frontend/src/dashboard/components/nativeFilters/FilterBar/index.tsx
index f69ff6fcef..391a481f20 100644
--- a/superset-frontend/src/dashboard/components/nativeFilters/FilterBar/index.tsx
+++ b/superset-frontend/src/dashboard/components/nativeFilters/FilterBar/index.tsx
@@ -278,11 +278,11 @@ const FilterBar: FC<FiltersBarProps> = ({
 
   const handleApply = useCallback(() => {
     dispatch(logEvent(LOG_ACTIONS_CHANGE_DASHBOARD_FILTER, {}));
-    const filterIds = Object.keys(dataMaskSelected);
     setUpdateKey(1);
-    filterIds.forEach(filterId => {
-      if (dataMaskSelected[filterId]) {
-        dispatch(updateDataMask(filterId, dataMaskSelected[filterId]));
+
+    Object.entries(dataMaskSelected).forEach(([filterId, dataMask]) => {
+      if (dataMask) {
+        dispatch(updateDataMask(filterId, dataMask));
       }
     });
   }, [dataMaskSelected, dispatch]);
diff --git a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/ScopingTree.tsx b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/ScopingTree.tsx
index 96a31d8170..72aa515e09 100644
--- a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/ScopingTree.tsx
+++ b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/ScopingTree.tsx
@@ -18,14 +18,22 @@
  */
 
 import { FC, useMemo, useState, memo } from 'react';
-import { NativeFilterScope } from '@superset-ui/core';
+import { NativeFilterScope, styled, css } from '@superset-ui/core';
 import Tree from '@superset-ui/core/components/Tree';
 import { DASHBOARD_ROOT_ID } from 'src/dashboard/util/constants';
 import { Tooltip } from '@superset-ui/core/components';
 import { Icons } from '@superset-ui/core/components/Icons';
+import { Layout } from 'src/dashboard/types';
 import { useFilterScopeTree } from './state';
 import { findFilterScope, getTreeCheckedItems } from './utils';
 
+const StyledTree = styled(Tree)`
+  .ant-tree-title {
+    display: flex;
+    align-items: center;
+  }
+`;
+
 type ScopingTreeProps = {
   forceUpdate: Function;
   updateFormValues: (values: any) => void;
@@ -40,8 +48,29 @@ const buildTreeLeafTitle = (
   label: string,
   hasTooltip: boolean,
   tooltipTitle?: string,
+  isDeckMultiChart?: boolean,
 ) => {
   let title = <span>{label}</span>;
+
+  if (isDeckMultiChart) {
+    title = (
+      <span
+        css={css`
+          display: inline-flex;
+          align-items: center;
+        `}
+      >
+        <Icons.CheckSquareOutlined
+          iconSize="l"
+          css={css`
+            margin-right: 4px;
+          `}
+        />
+        {label}
+      </span>
+    );
+  }
+
   if (hasTooltip) {
     title = (
       <>
@@ -55,6 +84,68 @@ const buildTreeLeafTitle = (
   return title;
 };
 
+const separateKeys = (
+  checkedKeys: string[],
+): { layerKeys: string[]; nonLayerKeys: string[] } => {
+  const layerKeys = checkedKeys.filter(key => key.includes('-layer-'));
+  const nonLayerKeys = checkedKeys.filter(key => !key.includes('-layer-'));
+  return { layerKeys, nonLayerKeys };
+};
+
+const extractParentChartIds = (layerKeys: string[]): Set<number> => {
+  const LAYER_KEY_REGEX = /^chart-(\d+)-layer-\d+$/;
+  const parentChartIds = new Set<number>();
+
+  layerKeys.forEach(layerKey => {
+    const match = layerKey.match(LAYER_KEY_REGEX);
+    if (match) {
+      const chartId = parseInt(match[1], 10);
+      parentChartIds.add(chartId);
+    }
+  });
+  return parentChartIds;
+};
+
+const updateScopeWithParentCharts = (
+  scope: NativeFilterScope,
+  parentChartIds: Set<number>,
+  nonLayerKeys: string[],
+  layout: Layout,
+): NativeFilterScope => {
+  const updatedScope = { ...scope };
+  parentChartIds.forEach(chartId => {
+    const chartLayoutKey = Object.keys(layout).find(
+      key => layout[key]?.meta?.chartId === chartId,
+    );
+    if (chartLayoutKey && layout[chartLayoutKey]) {
+      const tempScope = findFilterScope(
+        [...nonLayerKeys, chartLayoutKey],
+        layout,
+      );
+      updatedScope.rootPath = tempScope.rootPath;
+      updatedScope.excluded = tempScope.excluded;
+    }
+  });
+  return updatedScope;
+};
+
+const createFormValues = (
+  scope: NativeFilterScope,
+  layerKeys: string[],
+  chartId?: number,
+): { scope: NativeFilterScope & { selectedLayers?: string[] } } => {
+  const finalScope = { ...scope };
+  if (chartId !== undefined) {
+    finalScope.excluded = [...new Set([...finalScope.excluded, chartId])];
+  }
+  return {
+    scope:
+      layerKeys.length > 0
+        ? { ...finalScope, selectedLayers: layerKeys }
+        : finalScope,
+  };
+};
+
 const ScopingTree: FC<ScopingTreeProps> = ({
   formScope,
   initialScope,
@@ -74,6 +165,7 @@ const ScopingTree: FC<ScopingTreeProps> = ({
     buildTreeLeafTitle,
     title,
   );
+
   const [autoExpandParent, setAutoExpandParent] = useState<boolean>(true);
 
   const handleExpand = (expandedKeys: string[]) => {
@@ -83,22 +175,30 @@ const ScopingTree: FC<ScopingTreeProps> = ({
 
   const handleCheck = (checkedKeys: string[]) => {
     forceUpdate();
-    const scope = findFilterScope(checkedKeys, layout);
-    if (chartId !== undefined) {
-      scope.excluded = [...new Set([...scope.excluded, chartId])];
-    }
-    updateFormValues({
+    const { layerKeys, nonLayerKeys } = separateKeys(checkedKeys);
+    const scope = findFilterScope(nonLayerKeys, layout);
+    const parentChartIds = extractParentChartIds(layerKeys);
+    const updatedScope = updateScopeWithParentCharts(
       scope,
-    });
+      parentChartIds,
+      nonLayerKeys,
+      layout,
+    );
+    updateFormValues(createFormValues(updatedScope, layerKeys, chartId));
   };
 
   const checkedKeys = useMemo(
-    () => getTreeCheckedItems({ ...(formScope || initialScope) }, layout),
+    () =>
+      getTreeCheckedItems(
+        { ...(formScope || initialScope) },
+        layout,
+        ((formScope || initialScope) as any)?.selectedLayers,
+      ),
     [formScope, initialScope, layout],
   );
 
   return (
-    <Tree
+    <StyledTree
       checkable
       selectable={false}
       onExpand={handleExpand}
diff --git a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/state.ts b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/state.ts
index 42320f7d0a..f89cd6e918 100644
--- a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/state.ts
+++ b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/state.ts
@@ -19,7 +19,7 @@
 import { useMemo } from 'react';
 import { useSelector } from 'react-redux';
 import { t } from '@superset-ui/core';
-import { Charts, Layout, RootState } from 'src/dashboard/types';
+import { Charts, Layout, RootState, Slice } from 'src/dashboard/types';
 import { DASHBOARD_ROOT_ID } from 'src/dashboard/util/constants';
 import {
   CHART_TYPE,
@@ -43,6 +43,15 @@ export function useFilterScopeTree(
   );
 
   const charts = useSelector<RootState, Charts>(({ charts }) => charts);
+
+  const sliceEntities = useSelector<RootState, Slice>(state => {
+    if (!state.sliceEntities) {
+      console.warn('sliceEntities not found in state');
+      return {};
+    }
+    return state.sliceEntities.slices || {};
+  });
+
   const tree = {
     children: [],
     key: DASHBOARD_ROOT_ID,
@@ -72,8 +81,16 @@ export function useFilterScopeTree(
       validNodes,
       initiallyExcludedCharts,
       buildTreeLeafTitle,
+      sliceEntities,
     );
-  }, [layout, tree, charts, initiallyExcludedCharts, buildTreeLeafTitle]);
+  }, [
+    layout,
+    tree,
+    charts,
+    initiallyExcludedCharts,
+    buildTreeLeafTitle,
+    sliceEntities,
+  ]);
 
   return { treeData: [tree], layout };
 }
diff --git a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/types.ts b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/types.ts
index c99c1d65e8..fcb6e1d126 100644
--- a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/types.ts
+++ b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/types.ts
@@ -24,10 +24,14 @@ export type TreeItem = {
   children: TreeItem[];
   key: string;
   title: ReactNode;
+  nodeType?: 'CHART' | 'TAB' | 'ROOT' | 'DECKGL_LAYER';
+  chartId?: number;
+  layerType?: string;
 };
 
 export type BuildTreeLeafTitle = (
   label: string,
   hasTooltip: boolean,
   tooltipTitle?: string,
+  isDeckMultiChart?: boolean,
 ) => ReactNode;
diff --git a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/utils.ts b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/utils.ts
index 5e3079d3ae..0594e0fcc7 100644
--- a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/utils.ts
+++ b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/utils.ts
@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { Charts, Layout, LayoutItem } from 'src/dashboard/types';
+import { Charts, Layout, LayoutItem, Slice } from 'src/dashboard/types';
 import {
   CHART_TYPE,
   DASHBOARD_ROOT_TYPE,
@@ -37,6 +37,58 @@ export const getNodeTitle = (node: LayoutItem) =>
   node?.id?.toString?.() ??
   '';
 
+export const generateChartSubNodes = (
+  chartId: number,
+  chart: {
+    form_data?: {
+      viz_type?: string;
+      deck_slices?: number[];
+    };
+  } & Partial<Pick<Charts[keyof Charts], 'queriesResponse'>>,
+  buildTreeLeafTitle: BuildTreeLeafTitle,
+  sliceEntities?: Record<number, Slice>,
+): TreeItem[] => {
+  const subNodes: TreeItem[] = [];
+
+  if (chart?.form_data?.viz_type === 'deck_multi') {
+    const deckSliceIds = chart?.form_data?.deck_slices || [];
+
+    deckSliceIds.forEach((sliceId: number, index: number) => {
+      let sliceName = `Slice ${sliceId}`;
+
+      if (chart.queriesResponse?.[0]?.data?.slices) {
+        const slice = chart.queriesResponse[0].data.slices.find(
+          (s: { slice_id: number; slice_name?: string }) =>
+            s.slice_id === sliceId,
+        );
+        if (slice?.slice_name) {
+          sliceName = slice.slice_name;
+        }
+      }
+
+      const sliceInfo = sliceEntities?.[sliceId];
+      if (sliceInfo?.slice_name) {
+        sliceName = sliceInfo.slice_name;
+      }
+
+      subNodes.push({
+        key: `chart-${chartId}-layer-${index}`,
+        title: buildTreeLeafTitle(
+          sliceName,
+          false,
+          `Deck.gl layer: ${sliceName}`,
+        ),
+        children: [],
+        nodeType: 'DECKGL_LAYER',
+        chartId,
+        layerType: sliceInfo?.viz_type || 'deck_layer',
+      });
+    });
+  }
+
+  return subNodes;
+};
+
 export const buildTree = (
   node: LayoutItem,
   treeItem: TreeItem,
@@ -45,7 +97,12 @@ export const buildTree = (
   validNodes: string[],
   initiallyExcludedCharts: number[],
   buildTreeLeafTitle: BuildTreeLeafTitle,
+  sliceEntities?: Record<number, Slice>,
 ) => {
+  if (!node) {
+    return;
+  }
+
   let itemToPass: TreeItem = treeItem;
   if (
     node &&
@@ -60,34 +117,60 @@ export const buildTree = (
       t(
         "This chart might be incompatible with the filter (datasets don't match)",
       ),
+      !!(
+        node.type === CHART_TYPE &&
+        node.meta?.chartId &&
+        charts &&
+        charts[node.meta.chartId]?.form_data?.viz_type === 'deck_multi'
+      ),
     );
 
-    const currentTreeItem = {
+    const currentTreeItem: TreeItem = {
       key: node.id,
       title,
       children: [],
+      nodeType: node.type === CHART_TYPE ? 'CHART' : 'TAB',
+      chartId: node.meta?.chartId,
     };
+
+    if (node.type === CHART_TYPE && node.meta?.chartId) {
+      const chart = charts?.[node.meta.chartId];
+      if (chart) {
+        const subNodes = generateChartSubNodes(
+          node.meta.chartId,
+          chart,
+          buildTreeLeafTitle,
+          sliceEntities,
+        );
+        currentTreeItem.children = subNodes;
+      }
+    }
+
     treeItem.children.push(currentTreeItem);
     itemToPass = currentTreeItem;
   }
-  node?.children?.forEach?.(child => {
-    const node = layout?.[child];
-    if (node) {
-      buildTree(
-        node,
-        itemToPass,
-        layout,
-        charts,
-        validNodes,
-        initiallyExcludedCharts,
-        buildTreeLeafTitle,
-      );
-    } else {
-      logging.warn(
-        `Unable to find item with id: ${child} in the dashboard layout. This may indicate you have invalid references in your dashboard and the references to id: ${child} should be removed.`,
-      );
-    }
-  });
+
+  if (node.type !== CHART_TYPE) {
+    node?.children?.forEach?.(child => {
+      const childNode = layout?.[child];
+      if (childNode) {
+        buildTree(
+          childNode,
+          itemToPass,
+          layout,
+          charts,
+          validNodes,
+          initiallyExcludedCharts,
+          buildTreeLeafTitle,
+          sliceEntities,
+        );
+      } else {
+        logging.warn(
+          `Unable to find item with id: ${child} in the dashboard layout. This may indicate you have invalid references in your dashboard and the references to id: ${child} should be removed.`,
+        );
+      }
+    });
+  }
 };
 
 const addInvisibleParents = (layout: Layout, item: string) => [
@@ -102,7 +185,6 @@ const addInvisibleParents = (layout: Layout, item: string) => [
     .map(({ id }) => id),
 ];
 
-// Generate checked options for Ant tree from redux scope
 const checkTreeItem = (
   checkedItems: string[],
   layout: Layout,
@@ -125,12 +207,39 @@ const checkTreeItem = (
   });
 };
 
+const LAYER_KEY_REGEX = /^chart-(\d+)-layer-\d+$/;
+
 export const getTreeCheckedItems = (
   scope: NativeFilterScope,
   layout: Layout,
+  selectedLayers?: string[],
 ) => {
   const checkedItems: string[] = [];
   checkTreeItem(checkedItems, layout, [...scope.rootPath], [...scope.excluded]);
+
+  // If we have individual layer selections, exclude their parent charts from checkedItems
+  // to prevent Tree component from auto-checking all children
+  if (selectedLayers && selectedLayers.length > 0) {
+    const parentChartIds = new Set<number>();
+    selectedLayers.forEach(layerKey => {
+      const match = layerKey.match(LAYER_KEY_REGEX);
+      if (match) {
+        const chartId = parseInt(match[1], 10);
+        parentChartIds.add(chartId);
+      }
+    });
+
+    const filteredItems = checkedItems.filter(item => {
+      if (layout[item]?.type === CHART_TYPE) {
+        const chartId = layout[item]?.meta?.chartId;
+        return chartId ? !parentChartIds.has(chartId) : true;
+      }
+      return true;
+    });
+
+    return [...new Set([...filteredItems, ...selectedLayers])];
+  }
+
   return [...new Set(checkedItems)];
 };
 
@@ -146,8 +255,32 @@ export const findFilterScope = (
     };
   }
 
+  const layerKeys = checkedKeys.filter(key => key.includes('-layer-'));
+  const chartKeys = checkedKeys.filter(key => {
+    if (layout[key]?.type === CHART_TYPE) {
+      return true;
+    }
+    if (key.includes('-layer-')) {
+      return false;
+    }
+    return true;
+  });
+
+  layerKeys.forEach(layerKey => {
+    const match = layerKey.match(LAYER_KEY_REGEX);
+    if (match) {
+      const chartId = parseInt(match[1], 10);
+      const chartLayoutKey = Object.keys(layout).find(
+        key => layout[key]?.meta?.chartId === chartId,
+      );
+      if (chartLayoutKey && !chartKeys.includes(chartLayoutKey)) {
+        chartKeys.push(chartLayoutKey);
+      }
+    }
+  });
+
   // Get arrays of parents for selected charts
-  const checkedItemParents = checkedKeys
+  const checkedItemParents = chartKeys
     .filter(item => layout[item]?.type === CHART_TYPE)
     .map(key => {
       const parents = [DASHBOARD_ROOT_ID, ...(layout[key]?.parents || [])];
@@ -162,7 +295,7 @@ export const findFilterScope = (
 
   const excluded: number[] = [];
   const isExcluded = (parent: string, item: string) =>
-    rootPath.includes(parent) && !checkedKeys.includes(item);
+    rootPath.includes(parent) && !chartKeys.includes(item);
   // looking for charts to be excluded: iterate over all charts
   // and looking for charts that have one of their parents in `rootPath` and not in selected items
   Object.entries(layout).forEach(([key, value]) => {
diff --git a/superset-frontend/src/dashboard/components/nativeFilters/utils.ts b/superset-frontend/src/dashboard/components/nativeFilters/utils.ts
index c883ed0403..45bbe5b826 100644
--- a/superset-frontend/src/dashboard/components/nativeFilters/utils.ts
+++ b/superset-frontend/src/dashboard/components/nativeFilters/utils.ts
@@ -192,3 +192,166 @@ export const getFilterValueForDisplay = (
   }
   return t('Unknown value');
 };
+
+export interface FilterTarget {
+  type: 'CHART' | 'LAYER';
+  chartId: string;
+  layerId?: string;
+}
+
+export interface FilterScope {
+  filterId: string;
+  targets: FilterTarget[];
+}
+
+// Matches layer keys in format: 'chart-123-layer-456' where 123 is chartId and 456 is layerId
+const LAYER_KEY_REGEX = /^chart-(\d+)-layer-(\d+)$/;
+// Matches chart keys in format: 'chart-123' where 123 is chartId
+const CHART_KEY_REGEX = /^chart-(\d+)$/;
+
+export function parseFilterTarget(scopeKey: string): FilterTarget | null {
+  const layerMatch = scopeKey.match(LAYER_KEY_REGEX);
+  if (layerMatch) {
+    return {
+      type: 'LAYER',
+      chartId: layerMatch[1],
+      layerId: layerMatch[2],
+    };
+  }
+
+  const chartMatch = scopeKey.match(CHART_KEY_REGEX);
+  if (chartMatch) {
+    return {
+      type: 'CHART',
+      chartId: chartMatch[1],
+    };
+  }
+
+  return null;
+}
+
+export function getFilterScope(
+  filterId: string,
+  filterScopes: Record<string, string[]>,
+): FilterScope {
+  const scopeKeys = filterScopes[filterId] || [];
+  const targets: FilterTarget[] = [];
+
+  scopeKeys.forEach(scopeKey => {
+    const target = parseFilterTarget(scopeKey);
+    if (target) {
+      targets.push(target);
+    } else {
+      console.warn(`Invalid filter scope key format: ${scopeKey}`);
+    }
+  });
+
+  return {
+    filterId,
+    targets,
+  };
+}
+
+export function aggregateFiltersForTarget(
+  dataMask: DataMaskStateWithId,
+  filterIds: string[],
+): ExtraFormData {
+  let aggregatedFormData: ExtraFormData = {};
+
+  filterIds.forEach(filterId => {
+    const filterData = dataMask[filterId];
+    if (filterData?.extraFormData) {
+      aggregatedFormData = mergeExtraFormData(
+        aggregatedFormData,
+        filterData.extraFormData,
+      );
+    }
+  });
+
+  return aggregatedFormData;
+}
+
+function createTargetKey(target: FilterTarget): string {
+  if (target.type === 'LAYER') {
+    return `${target.chartId}-${target.layerId}`;
+  }
+  return target.chartId;
+}
+
+export function groupFiltersByTarget(
+  dataMask: DataMaskStateWithId,
+  filterScopes: Record<string, string[]>,
+): {
+  chartFilters: Map<string, ExtraFormData>;
+  layerFilters: Map<string, ExtraFormData>;
+} {
+  const chartFilters = new Map<string, ExtraFormData>();
+  const layerFilters = new Map<string, ExtraFormData>();
+
+  Object.keys(dataMask).forEach(filterId => {
+    const scope = getFilterScope(filterId, filterScopes);
+
+    scope.targets.forEach(target => {
+      const filterData = dataMask[filterId]?.extraFormData || {};
+      const targetKey = createTargetKey(target);
+
+      if (target.type === 'CHART') {
+        const existing = chartFilters.get(targetKey) || {};
+        chartFilters.set(targetKey, mergeExtraFormData(existing, filterData));
+      } else if (target.type === 'LAYER') {
+        const existing = layerFilters.get(targetKey) || {};
+        layerFilters.set(targetKey, mergeExtraFormData(existing, filterData));
+      }
+    });
+  });
+
+  return { chartFilters, layerFilters };
+}
+
+export function buildFilterScopesFromFilters(
+  filters: any,
+): Record<string, string[]> {
+  const filterScopes: Record<string, string[]> = {};
+
+  Object.values(filters).forEach((filter: Filter) => {
+    if (filter.chartsInScope) {
+      filterScopes[filter.id] = filter.chartsInScope.map(
+        (chartId: number) => `chart-${chartId}`,
+      );
+    }
+  });
+
+  return filterScopes;
+}
+
+export function getLayerSpecificExtraFormData(
+  dataMask: DataMaskStateWithId,
+  filterIds: string[],
+  chartId: number,
+  layerId?: string,
+): ExtraFormData {
+  let extraFormData: ExtraFormData = {};
+
+  filterIds.forEach(filterId => {
+    const filterData = dataMask[filterId];
+    if (filterData?.extraFormData) {
+      extraFormData = mergeExtraFormData(
+        extraFormData,
+        filterData.extraFormData,
+      );
+    }
+  });
+
+  if (layerId) {
+    const layerKey = `${chartId}-${layerId}`;
+    const layerFilterData = dataMask[layerKey];
+    if (layerFilterData?.extraFormData) {
+      extraFormData = mergeExtraFormData(
+        extraFormData,
+        layerFilterData.extraFormData,
+      );
+    }
+  }
+
+  return extraFormData;
+}
diff --git a/superset-frontend/src/dashboard/types.ts b/superset-frontend/src/dashboard/types.ts
index 66fcf6418f..43d67bd351 100644
--- a/superset-frontend/src/dashboard/types.ts
+++ b/superset-frontend/src/dashboard/types.ts
@@ -39,6 +39,10 @@ import { ChartState } from '../explore/types';
 
 export type { Dashboard } from 'src/types/Dashboard';
 
+export interface ExtendedNativeFilterScope extends NativeFilterScope {
+  selectedLayers?: string[];
+}
+
 export type ChartReducerInitialState = typeof chart;
 
 // chart query built from initialState
@@ -210,6 +214,9 @@ type ActiveFilter = {
   targets: number[] | [Partial<NativeFilterTarget>];
   scope: number[];
   values: ExtraFormData;
+  layerScope?: {
+    [chartId: number]: number[];
+  };
 };
 
 export type ActiveFilters = {
diff --git a/superset-frontend/src/dashboard/util/activeAllDashboardFilters.ts b/superset-frontend/src/dashboard/util/activeAllDashboardFilters.ts
index 0d3ae30eb4..bcc533780e 100644
--- a/superset-frontend/src/dashboard/util/activeAllDashboardFilters.ts
+++ b/superset-frontend/src/dashboard/util/activeAllDashboardFilters.ts
@@ -16,27 +16,39 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import {
-  DataMaskStateWithId,
-  PartialFilters,
-  JsonObject,
-  DataMaskWithId,
-} from '@superset-ui/core';
+import { DataMaskStateWithId, PartialFilters } from '@superset-ui/core';
 import { ActiveFilters, ChartConfiguration } from '../types';
 
 export const getRelevantDataMask = (
   dataMask: DataMaskStateWithId,
-  prop: string,
-): JsonObject | DataMaskStateWithId =>
-  Object.values(dataMask)
-    .filter(item => item[prop as keyof DataMaskWithId])
-    .reduce(
-      (prev, next) => ({
-        ...prev,
-        [next.id]: prop ? next[prop as keyof DataMaskWithId] : next,
-      }),
-      {},
-    );
+  filterId: string,
+): DataMaskStateWithId =>
+  dataMask[filterId] ? { [filterId]: dataMask[filterId] } : {};
+
+interface LayerInfo {
+  layerMap: { [chartId: number]: number[] };
+  chartIds: Set<number>;
+}
+
+const extractLayerIndicesFromKeys = (selectedLayers: string[]): LayerInfo => {
+  const layerMap: { [chartId: number]: number[] } = {};
+  const chartIds = new Set<number>();
+  selectedLayers.forEach(layerKey => {
+    const match = layerKey.match(/^chart-(\d+)-layer-(\d+)$/);
+    if (match) {
+      const chartId = parseInt(match[1], 10);
+      const layerIndex = parseInt(match[2], 10);
+      if (!Number.isNaN(chartId)) {
+        if (!layerMap[chartId]) {
+          layerMap[chartId] = [];
+        }
+        layerMap[chartId].push(layerIndex);
+        chartIds.add(chartId);
+      }
+    }
+  });
+  return { layerMap, chartIds };
+};
 
 export const getAllActiveFilters = ({
   chartConfiguration,
@@ -51,23 +63,87 @@ export const getAllActiveFilters = ({
 }): ActiveFilters => {
   const activeFilters: ActiveFilters = {};
 
-  // Combine native filters with cross filters, because they have similar logic
+  const hasLayerSelectionsInAnyFilter = Object.values(dataMask).some(
+    ({ id: filterId }) => {
+      const selectedLayers = (nativeFilters?.[filterId]?.scope as any)
+        ?.selectedLayers;
+      return selectedLayers && selectedLayers.length > 0;
+    },
+  );
+
+  let masterSelectedLayers: string[] = [];
+  let masterExcluded: number[] = [];
+  if (hasLayerSelectionsInAnyFilter) {
+    Object.values(dataMask).forEach(({ id: filterId }) => {
+      const selectedLayers = (nativeFilters?.[filterId]?.scope as any)
+        ?.selectedLayers;
+      const excluded =
+        (nativeFilters?.[filterId]?.scope as any)?.excluded || [];
+      if (selectedLayers && selectedLayers.length > 0) {
+        masterSelectedLayers = selectedLayers;
+        masterExcluded = excluded;
+      }
+    });
+  }
+
   Object.values(dataMask).forEach(({ id: filterId, extraFormData = {} }) => {
-    const scope =
+    let scope =
       nativeFilters?.[filterId]?.chartsInScope ??
       chartConfiguration?.[parseInt(filterId, 10)]?.crossFilters
         ?.chartsInScope ??
       allSliceIds ??
       [];
     const filterType = nativeFilters?.[filterId]?.filterType;
-    const targets = nativeFilters?.[filterId]?.targets ?? scope;
-    // Iterate over all roots to find all affected charts
+    const targets = nativeFilters?.[filterId]?.targets;
+
+    let selectedLayers = (nativeFilters?.[filterId]?.scope as any)
+      ?.selectedLayers;
+    let excludedCharts =
+      (nativeFilters?.[filterId]?.scope as any)?.excluded || [];
+
+    if (
+      hasLayerSelectionsInAnyFilter &&
+      (!selectedLayers || selectedLayers.length === 0)
+    ) {
+      selectedLayers = masterSelectedLayers;
+      excludedCharts = masterExcluded;
+    }
+
+    let layerScope;
+    if (selectedLayers && selectedLayers.length > 0) {
+      const layerInfo = extractLayerIndicesFromKeys(selectedLayers);
+      layerScope = layerInfo.layerMap;
+
+      const explicitlyTargetedCharts = new Set<number>(layerInfo.chartIds);
+
+      const originalScope = scope;
+      originalScope.forEach((chartId: number) => {
+        if (!excludedCharts.includes(chartId)) {
+          const hasLayerSelections = selectedLayers.some((key: string) =>
+            key.startsWith(`chart-${chartId}-layer-`),
+          );
+
+          if (!hasLayerSelections) {
+            explicitlyTargetedCharts.add(chartId);
+          }
+        }
+      });
+
+      scope = Array.from(explicitlyTargetedCharts);
+    } else {
+      scope = scope.filter(
+        (chartId: number) => !excludedCharts.includes(chartId),
+      );
+    }
+
     activeFilters[filterId] = {
       scope,
-      filterType,
-      targets,
+      targets: targets || [],
       values: extraFormData,
+      filterType,
+      ...(layerScope && { layerScope }),
     };
   });
+
   return activeFilters;
 };
diff --git a/superset-frontend/src/dashboard/util/charts/getFormDataWithExtraFilters.ts b/superset-frontend/src/dashboard/util/charts/getFormDataWithExtraFilters.ts
index 56cc787b1d..629bb74b95 100644
--- a/superset-frontend/src/dashboard/util/charts/getFormDataWithExtraFilters.ts
+++ b/superset-frontend/src/dashboard/util/charts/getFormDataWithExtraFilters.ts
@@ -24,7 +24,11 @@ import {
   JsonObject,
   PartialFilters,
 } from '@superset-ui/core';
-import { ChartConfiguration, ChartQueryPayload } from 'src/dashboard/types';
+import {
+  ChartConfiguration,
+  ChartQueryPayload,
+  ActiveFilters,
+} from 'src/dashboard/types';
 import { getExtraFormData } from 'src/dashboard/components/nativeFilters/utils';
 import { areObjectsEqual } from 'src/reduxUtils';
 import { isEqual } from 'lodash';
@@ -45,14 +49,18 @@ interface CachedFormData {
   label_colors?: Record<string, string>;
   shared_label_colors?: string[];
   map_label_colors?: Record<string, string>;
+  layer_filter_scope?: {
+    [filterId: string]: number[];
+  };
+  filter_data_mapping?: {
+    [filterId: string]: any[];
+  };
 }
 
 export type CachedFormDataWithExtraControls = CachedFormData & {
   [key: string]: any;
 };
 
-// We cache formData objects so that our connected container components don't always trigger
-// render cascades. we cannot leverage the reselect library because our cache size is >1
 const cachedFiltersByChart: Record<number, DataRecordFilters> = {};
 const cachedFormdataByChart: Record<
   number,
@@ -77,11 +85,25 @@ export interface GetFormDataWithExtraFiltersArguments {
   labelsColorMap?: Record<string, string>;
   sharedLabelsColors?: string[];
   allSliceIds: number[];
+  activeFilters?: ActiveFilters;
 }
 
-// this function merge chart's formData with dashboard filters value,
-// and generate a new formData which will be used in the new query.
-// filters param only contains those applicable to this chart.
+const createFilterDataMapping = (
+  dataMask: DataMaskStateWithId,
+  filterIdsAppliedOnChart: string[],
+): { [filterId: string]: any[] } => {
+  const filterDataMapping: { [filterId: string]: any[] } = {};
+
+  filterIdsAppliedOnChart.forEach(filterId => {
+    const filterFormData = getExtraFormData(dataMask, [filterId]);
+    if (filterFormData.filters && filterFormData.filters.length > 0) {
+      filterDataMapping[filterId] = filterFormData.filters;
+    }
+  });
+
+  return filterDataMapping;
+};
+
 export default function getFormDataWithExtraFilters({
   chart,
   filters,
@@ -97,8 +119,8 @@ export default function getFormDataWithExtraFilters({
   labelsColorMap,
   sharedLabelsColors,
   allSliceIds,
+  activeFilters: passedActiveFilters,
 }: GetFormDataWithExtraFiltersArguments) {
-  // if dashboard metadata + filters have not changed, use cache if possible
   const cachedFormData = cachedFormdataByChart[sliceId];
   if (
     cachedFiltersByChart[sliceId] === filters &&
@@ -125,20 +147,62 @@ export default function getFormDataWithExtraFilters({
     return cachedFormData;
   }
 
-  let extraData: { extra_form_data?: JsonObject } = {};
-  const activeFilters = getAllActiveFilters({
-    chartConfiguration,
-    dataMask,
-    nativeFilters,
-    allSliceIds,
-  });
+  const activeFilters: ActiveFilters =
+    passedActiveFilters ||
+    getAllActiveFilters({
+      chartConfiguration,
+      nativeFilters,
+      dataMask,
+      allSliceIds,
+    });
+
+  let extraData: JsonObject = {};
   const filterIdsAppliedOnChart = Object.entries(activeFilters)
-    .filter(([, { scope }]) => scope.includes(chart.id))
+    .filter(([, activeFilter]) => activeFilter.scope.includes(chart.id))
     .map(([filterId]) => filterId);
+
   if (filterIdsAppliedOnChart.length) {
+    const aggregatedFormData = getExtraFormData(
+      dataMask,
+      filterIdsAppliedOnChart,
+    );
     extraData = {
-      extra_form_data: getExtraFormData(dataMask, filterIdsAppliedOnChart),
+      extra_form_data: aggregatedFormData,
     };
+
+    const isDeckMultiChart = chart.form_data?.viz_type === 'deck_multi';
+    const hasLayerScopeInActiveFilters =
+      passedActiveFilters &&
+      Object.values(passedActiveFilters).some(filter => filter.layerScope);
+
+    if (isDeckMultiChart || hasLayerScopeInActiveFilters) {
+      const filterDataMapping = createFilterDataMapping(
+        dataMask,
+        filterIdsAppliedOnChart,
+      );
+      extraData.filter_data_mapping = filterDataMapping;
+    }
+  }
+
+  let layerFilterScope: { [filterId: string]: number[] } | undefined;
+
+  const isDeckMultiChart = chart.form_data?.viz_type === 'deck_multi';
+  const hasLayerScopeInActiveFilters =
+    passedActiveFilters &&
+    Object.values(passedActiveFilters).some(filter => filter.layerScope);
+
+  if (isDeckMultiChart || hasLayerScopeInActiveFilters) {
+    layerFilterScope = {};
+
+    Object.entries(activeFilters).forEach(([filterId, activeFilter]) => {
+      if (activeFilter.layerScope?.[chart.id]) {
+        layerFilterScope![filterId] = activeFilter.layerScope[chart.id];
+      }
+    });
+
+    if (Object.keys(layerFilterScope).length === 0) {
+      layerFilterScope = undefined;
+    }
   }
 
   const formData: CachedFormDataWithExtraControls = {
@@ -154,6 +218,7 @@ export default function getFormDataWithExtraFilters({
     extra_filters: getEffectiveExtraFilters(filters),
     ...extraData,
     ...extraControls,
+    ...(layerFilterScope && { layer_filter_scope: layerFilterScope }),
   };
 
   cachedFiltersByChart[sliceId] = filters;
diff --git a/superset-frontend/src/dashboard/util/getChartIdsInFilterScope.ts b/superset-frontend/src/dashboard/util/getChartIdsInFilterScope.ts
index 5bd37f26bc..f6b3c91ae4 100644
--- a/superset-frontend/src/dashboard/util/getChartIdsInFilterScope.ts
+++ b/superset-frontend/src/dashboard/util/getChartIdsInFilterScope.ts
@@ -20,12 +20,59 @@ import { NativeFilterScope } from '@superset-ui/core';
 import { CHART_TYPE } from './componentTypes';
 import { LayoutItem } from '../types';
 
+interface ExtendedNativeFilterScope extends NativeFilterScope {
+  selectedLayers?: string[];
+}
+
 export function getChartIdsInFilterScope(
-  filterScope: NativeFilterScope,
+  filterScope: ExtendedNativeFilterScope,
   chartIds: number[],
   layoutItems: LayoutItem[],
-) {
-  return chartIds.filter(
+): number[] {
+  if (filterScope.selectedLayers && filterScope.selectedLayers.length > 0) {
+    const targetChartIds: number[] = [];
+
+    filterScope.selectedLayers.forEach(selectionKey => {
+      const layerMatch = selectionKey.match(/^chart-(\d+)-layer-(\d+)$/);
+      if (layerMatch) {
+        const chartId = parseInt(layerMatch[1], 10);
+        if (chartIds.includes(chartId) && !targetChartIds.includes(chartId)) {
+          targetChartIds.push(chartId);
+        }
+      }
+    });
+    const chartsWithLayerSelections = new Set<number>();
+    filterScope.selectedLayers.forEach(selectionKey => {
+      const layerMatch = selectionKey.match(/^chart-(\d+)-layer-(\d+)$/);
+      if (layerMatch) {
+        chartsWithLayerSelections.add(parseInt(layerMatch[1], 10));
+      }
+    });
+
+    const regularChartIds = chartIds.filter(
+      chartId =>
+        !filterScope.excluded.includes(chartId) &&
+        !chartsWithLayerSelections.has(chartId) &&
+        layoutItems
+          .find(
+            layoutItem =>
+              layoutItem?.type === CHART_TYPE &&
+              layoutItem.meta?.chartId === chartId,
+          )
+          ?.parents?.some(elementId =>
+            filterScope.rootPath.includes(elementId),
+          ),
+    );
+
+    regularChartIds.forEach(chartId => {
+      if (!targetChartIds.includes(chartId)) {
+        targetChartIds.push(chartId);
+      }
+    });
+    return targetChartIds;
+  }
+
+  const traditionalResult = chartIds.filter(
     chartId =>
       !filterScope.excluded.includes(chartId) &&
       layoutItems
@@ -36,4 +83,6 @@ export function getChartIdsInFilterScope(
         )
         ?.parents?.some(elementId => filterScope.rootPath.includes(elementId)),
   );
+
+  return traditionalResult;
 }
diff --git a/superset-frontend/src/explore/components/ExploreViewContainer/index.jsx b/superset-frontend/src/explore/components/ExploreViewContainer/index.jsx
index 6f6df842b4..13b67c5b99 100644
--- a/superset-frontend/src/explore/components/ExploreViewContainer/index.jsx
+++ b/superset-frontend/src/explore/components/ExploreViewContainer/index.jsx
@@ -769,7 +769,29 @@ function mapStateToProps(state) {
   const fieldsToOmit = hasQueryMode
     ? retainQueryModeRequirements(hiddenFormData)
     : Object.keys(hiddenFormData ?? {});
-  const form_data = omit(getFormDataFromControls(controls), fieldsToOmit);
+
+  const controlsBasedFormData = omit(
+    getFormDataFromControls(controls),
+    fieldsToOmit,
+  );
+  const isDeckGLChart = explore.form_data?.viz_type === 'deck_multi';
+
+  const getDeckGLFormData = () => {
+    const formData = { ...controlsBasedFormData };
+
+    if (explore.form_data?.layer_filter_scope) {
+      formData.layer_filter_scope = explore.form_data.layer_filter_scope;
+    }
+
+    if (explore.form_data?.filter_data_mapping) {
+      formData.filter_data_mapping = explore.form_data.filter_data_mapping;
+    }
+
+    return formData;
+  };
+
+  const form_data = isDeckGLChart ? getDeckGLFormData() : controlsBasedFormData;
+
   const slice_id = form_data.slice_id ?? slice?.slice_id ?? 0; // 0 - unsaved chart
   form_data.extra_form_data = mergeExtraFormData(
     { ...form_data.extra_form_data },
diff --git a/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilter/index.js b/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilter/index.js
index 7c13236573..eeea251a39 100644
--- a/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilter/index.js
+++ b/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilter/index.js
@@ -63,6 +63,8 @@ export default class AdhocFilter {
     this.isExtra = !!adhocFilter.isExtra;
     this.isNew = !!adhocFilter.isNew;
     this.datasourceWarning = !!adhocFilter.datasourceWarning;
+    this.deck_slices = adhocFilter?.deck_slices;
+    this.layerFilterScope = adhocFilter?.layerFilterScope;
 
     this.filterOptionName =
       adhocFilter.filterOptionName ||
diff --git a/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilterEditPopover/index.jsx b/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilterEditPopover/index.jsx
index 55a0515dd8..112580bfbc 100644
--- a/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilterEditPopover/index.jsx
+++ b/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilterEditPopover/index.jsx
@@ -18,9 +18,9 @@
  */
 import { createRef, Component } from 'react';
 import PropTypes from 'prop-types';
-import { Button, Icons } from '@superset-ui/core/components';
+import { Button, Icons, Select } from '@superset-ui/core/components';
 import { ErrorBoundary } from 'src/components';
-import { styled, t } from '@superset-ui/core';
+import { styled, t, SupersetClient } from '@superset-ui/core';
 
 import Tabs from '@superset-ui/core/components/Tabs';
 import adhocMetricType from 'src/explore/components/controls/MetricControl/adhocMetricType';
@@ -32,6 +32,8 @@ import {
   POPOVER_INITIAL_HEIGHT,
   POPOVER_INITIAL_WIDTH,
 } from 'src/explore/constants';
+import rison from 'rison';
+import { isObject } from 'lodash';
 import { ExpressionTypes } from '../types';
 
 const propTypes = {
@@ -86,6 +88,11 @@ const FilterActionsContainer = styled.div`
   margin-top: ${({ theme }) => theme.sizeUnit * 2}px;
 `;
 
+const LayerSelectContainer = styled.div`
+  margin-top: ${({ theme }) => theme.sizeUnit * 2}px;
+  margin-bottom: ${({ theme }) => theme.sizeUnit * 12}px;
+`;
+
 export default class AdhocFilterEditPopover extends Component {
   constructor(props) {
     super(props);
@@ -97,6 +104,8 @@ export default class AdhocFilterEditPopover extends Component {
     this.setSimpleTabIsValid = this.setSimpleTabIsValid.bind(this);
     this.adjustHeight = this.adjustHeight.bind(this);
     this.onTabChange = this.onTabChange.bind(this);
+    this.loadLayerOptions = this.loadLayerOptions.bind(this);
+    this.onLayerChange = this.onLayerChange.bind(this);
 
     this.state = {
       adhocFilter: this.props.adhocFilter,
@@ -104,6 +113,9 @@ export default class AdhocFilterEditPopover extends Component {
       height: POPOVER_INITIAL_HEIGHT,
       activeKey: this.props?.adhocFilter?.expressionType || 'SIMPLE',
       isSimpleTabValid: true,
+      selectedLayers: [{ id: null, value: -1, label: 'All' }],
+      layerOptions: [],
+      hasLayerFilterScopeChanged: false,
     };
 
     this.popoverContentRef = createRef();
@@ -111,6 +123,26 @@ export default class AdhocFilterEditPopover extends Component {
 
   componentDidMount() {
     document.addEventListener('mouseup', this.onMouseUp);
+
+    // Load layer options if deck_slices exist
+    if (
+      this.props.adhocFilter?.deck_slices &&
+      this.props.adhocFilter.deck_slices.length > 0
+    ) {
+      this.loadLayerOptions(0, 100).then(result => {
+        this.setState({ layerOptions: result.data });
+        const layerFilterScope = this.props.adhocFilter?.layerFilterScope;
+        if (layerFilterScope) {
+          const selectedLayers = layerFilterScope.map(item => {
+            const layerOption = result.data.find(
+              option => option.value === item,
+            );
+            return layerOption;
+          });
+          this.setState({ selectedLayers });
+        }
+      });
+    }
   }
 
   componentWillUnmount() {
@@ -127,7 +159,28 @@ export default class AdhocFilterEditPopover extends Component {
   }
 
   onSave() {
-    this.props.onChange(this.state.adhocFilter);
+    const hasDeckSlices =
+      this.state.adhocFilter.deck_slices &&
+      this.state.adhocFilter.deck_slices.length > 0;
+
+    if (!hasDeckSlices) {
+      this.props.onChange(this.state.adhocFilter);
+      this.props.onClose();
+      return;
+    }
+    // Update layer filter scope for deck multi
+    const selectedLayers = this.state.selectedLayers.map(item => {
+      if (isObject(item)) {
+        return item.value;
+      }
+      return item;
+    });
+    const correctedAdhocFilter = {
+      ...this.state.adhocFilter,
+      layerFilterScope: selectedLayers,
+    };
+    this.setState({ hasLayerFilterScopeChanged: false });
+    this.props.onChange(correctedAdhocFilter);
     this.props.onClose();
   }
 
@@ -167,6 +220,86 @@ export default class AdhocFilterEditPopover extends Component {
     this.setState(state => ({ height: state.height + heightDifference }));
   }
 
+  loadLayerOptions(page, pageSize) {
+    const query = rison.encode({
+      columns: ['id', 'slice_name', 'viz_type'],
+      filters: [{ col: 'viz_type', opr: 'sw', value: 'deck' }],
+      page,
+      page_size: pageSize,
+      order_column: 'slice_name',
+      order_direction: 'asc',
+    });
+
+    return SupersetClient.get({
+      endpoint: `/api/v1/chart/?q=${query}`,
+    }).then(response => {
+      if (!response?.json?.result) {
+        return {
+          data: [
+            {
+              id: null,
+              value: -1,
+              label: 'All',
+            },
+          ],
+          totalCount: 1,
+        };
+      }
+
+      const deckSlices = this.props.adhocFilter?.deck_slices || [];
+
+      const list = [
+        {
+          id: null,
+          value: -1,
+          label: 'All',
+        },
+        ...response.json.result
+          .map(item => {
+            const sliceIndex = deckSlices.indexOf(item.id);
+            return {
+              id: item.id,
+              value: sliceIndex >= 0 ? sliceIndex : item.id,
+              label: item.slice_name,
+              sliceIndex,
+            };
+          })
+          .filter(item => item.sliceIndex !== -1)
+          .map(({ sliceIndex, ...item }) => item),
+      ];
+
+      return {
+        data: list,
+        totalCount: list.length,
+      };
+    });
+  }
+
+  onLayerChange(selectedValue) {
+    let updatedSelectedLayers = selectedValue;
+
+    if (!selectedValue || selectedValue.length === 0) {
+      updatedSelectedLayers = [{ id: null, value: -1, label: 'All' }];
+    } else if (
+      selectedValue.length > 1 &&
+      selectedValue.some(item => item.value === -1 || item === -1)
+    ) {
+      if (
+        selectedValue[selectedValue.length - 1].value === -1 ||
+        selectedValue[selectedValue.length - 1] === -1
+      ) {
+        updatedSelectedLayers = [{ id: null, value: -1, label: 'All' }];
+      } else {
+        updatedSelectedLayers = selectedValue
+          .filter(item => item.value !== -1)
+          .filter(item => item !== -1);
+      }
+    }
+
+    this.setState({ selectedLayers: updatedSelectedLayers });
+    this.setState({ hasLayerFilterScopeChanged: true });
+  }
+
   render() {
     const {
       adhocFilter: propsAdhocFilter,
@@ -182,10 +315,16 @@ export default class AdhocFilterEditPopover extends Component {
       ...popoverProps
     } = this.props;
 
-    const { adhocFilter } = this.state;
+    const { adhocFilter, selectedLayers, hasLayerFilterScopeChanged } =
+      this.state;
     const stateIsValid = adhocFilter.isValid();
     const hasUnsavedChanges =
-      requireSave || !adhocFilter.equals(propsAdhocFilter);
+      requireSave ||
+      !adhocFilter.equals(propsAdhocFilter) ||
+      hasLayerFilterScopeChanged;
+
+    const hasDeckSlices =
+      adhocFilter.deck_slices && adhocFilter.deck_slices.length > 0;
 
     return (
       <FilterPopoverContentContainer
@@ -239,6 +378,17 @@ export default class AdhocFilterEditPopover extends Component {
             },
           ]}
         />
+        {hasDeckSlices && (
+          <LayerSelectContainer>
+            <Select
+              options={this.state.layerOptions}
+              onChange={this.onLayerChange}
+              value={selectedLayers}
+              mode="multiple"
+            />
+          </LayerSelectContainer>
+        )}
+
         <FilterActionsContainer>
           <Button
             buttonStyle="secondary"
diff --git a/superset-frontend/src/explore/controlUtils/getFormDataWithDashboardContext.ts b/superset-frontend/src/explore/controlUtils/getFormDataWithDashboardContext.ts
index 4017883ab1..127df12155 100644
--- a/superset-frontend/src/explore/controlUtils/getFormDataWithDashboardContext.ts
+++ b/superset-frontend/src/explore/controlUtils/getFormDataWithDashboardContext.ts
@@ -115,6 +115,8 @@ const mergeNativeFiltersToFormData = (
 ) => {
   const nativeFiltersData: JsonObject = {};
   const extraFormData = dashboardFormData.extra_form_data || {};
+  const layerFilterScope = dashboardFormData?.layer_filter_scope;
+  const filterDataMapping = dashboardFormData?.filter_data_mapping;
   Object.entries(EXTRA_FORM_DATA_OVERRIDE_REGULAR_MAPPINGS).forEach(
     ([srcKey, targetKey]) => {
       const val = extraFormData[srcKey];
@@ -150,7 +152,12 @@ const mergeNativeFiltersToFormData = (
   }));
 
   const appendFilters = ensureIsArray(extraFormData.filters).map(extraFilter =>
-    simpleFilterToAdhoc({ ...extraFilter, isExtra: true }),
+    simpleFilterToAdhoc({
+      ...extraFilter,
+      isExtra: true,
+      filterDataMapping,
+      layerFilterScope,
+    }),
   );
   Object.keys(exploreFormData).forEach(key => {
     if (key.match(/adhoc_filter.*/)) {
@@ -160,6 +167,7 @@ const mergeNativeFiltersToFormData = (
       ];
     }
   });
+
   return nativeFiltersData;
 };
 
@@ -186,15 +194,23 @@ const applyTimeRangeFilters = (
 export const getFormDataWithDashboardContext = (
   exploreFormData: QueryFormData,
   dashboardContextFormData: JsonObject,
+  saveAction?: string | null,
 ) => {
   const filterBoxData = mergeFilterBoxToFormData(
     exploreFormData,
     dashboardContextFormData,
   );
+
   const nativeFiltersData = mergeNativeFiltersToFormData(
     exploreFormData,
     dashboardContextFormData,
   );
+  const isDeckGLChart =
+    exploreFormData.viz_type === 'deck_multi' ||
+    dashboardContextFormData.viz_type === 'deck_multi';
+
+  const deckSlices = exploreFormData?.deck_slices;
+
   const adhocFilters = [
     ...Object.keys(exploreFormData),
     ...Object.keys(filterBoxData),
@@ -204,25 +220,77 @@ export const getFormDataWithDashboardContext = (
     .reduce(
       (acc, key) => ({
         ...acc,
-        [key]: removeExtraFieldForNewCharts(
-          applyTimeRangeFilters(
-            dashboardContextFormData,
-            removeAdhocFilterDuplicates([
-              ...ensureIsArray(exploreFormData[key]),
-              ...ensureIsArray(filterBoxData[key]),
-              ...ensureIsArray(nativeFiltersData[key]),
-            ]),
-          ),
-          exploreFormData.slice_id === 0,
-        ),
+        [key]: (() => {
+          const beforeDuplicates = [
+            ...ensureIsArray(exploreFormData[key]),
+            ...ensureIsArray(filterBoxData[key]),
+            ...ensureIsArray(nativeFiltersData[key]),
+          ];
+
+          const afterDuplicates = removeAdhocFilterDuplicates(beforeDuplicates);
+
+          const final = removeExtraFieldForNewCharts(
+            applyTimeRangeFilters(dashboardContextFormData, afterDuplicates),
+            exploreFormData.slice_id === 0,
+          );
+
+          return final;
+        })(),
       }),
       {},
     );
-
   const ownColorScheme = exploreFormData.color_scheme;
   const dashboardColorScheme = dashboardContextFormData.color_scheme;
   const appliedColorScheme = dashboardColorScheme || ownColorScheme;
 
+  const deckGLProperties: JsonObject = {};
+
+  if (
+    isDeckGLChart &&
+    isDefined(deckSlices) &&
+    'adhoc_filters' in adhocFilters &&
+    Array.isArray(adhocFilters?.adhoc_filters)
+  ) {
+    const adhocFiltersWithDeckSlices =
+      adhocFilters?.adhoc_filters?.map((filter: AdhocFilter) => ({
+        ...filter,
+        ...(Array.isArray(deckSlices) &&
+          deckSlices?.length > 0 &&
+          filter?.isExtra && {
+            deck_slices: deckSlices,
+          }),
+      })) || [];
+
+    adhocFilters.adhoc_filters = adhocFiltersWithDeckSlices;
+  }
+
+  if (isDeckGLChart) {
+    if (dashboardContextFormData.layer_filter_scope) {
+      deckGLProperties.layer_filter_scope =
+        dashboardContextFormData.layer_filter_scope;
+    }
+    if (dashboardContextFormData.filter_data_mapping) {
+      deckGLProperties.filter_data_mapping =
+        dashboardContextFormData.filter_data_mapping;
+    }
+  }
+
+  if (saveAction === 'overwrite') {
+    return {
+      ...dashboardContextFormData,
+      ...filterBoxData,
+      ...nativeFiltersData,
+      ...adhocFilters,
+      ...exploreFormData, // Explore form data comes last to override
+      own_color_scheme: ownColorScheme,
+      color_scheme: appliedColorScheme,
+      dashboard_color_scheme: dashboardColorScheme,
+      ...deckGLProperties,
+    };
+  }
+
+  // Default behavior: Dashboard context overrides explore data, but adhoc filters, color schemes
+  // and specific properties from filterBox and native filters take final precedence
   return {
     ...exploreFormData,
     ...dashboardContextFormData,
@@ -232,5 +300,6 @@ export const getFormDataWithDashboardContext = (
     own_color_scheme: ownColorScheme,
     color_scheme: appliedColorScheme,
     dashboard_color_scheme: dashboardColorScheme,
+    ...deckGLProperties,
   };
 };
diff --git a/superset-frontend/src/pages/Chart/index.tsx b/superset-frontend/src/pages/Chart/index.tsx
index cc2b431ffb..61edb9bfe5 100644
--- a/superset-frontend/src/pages/Chart/index.tsx
+++ b/superset-frontend/src/pages/Chart/index.tsx
@@ -108,7 +108,9 @@ const getDashboardContextFormData = () => {
       filterBoxFilters,
       dataMask,
       dashboardId,
+      activeFilters,
     } = dashboardContext;
+
     const dashboardContextWithFilters = getFormDataWithExtraFilters({
       chart: { id: sliceId },
       filters: getAppliedFilterValues(sliceId, filterBoxFilters),
@@ -122,6 +124,7 @@ const getDashboardContextFormData = () => {
       sliceId,
       allSliceIds: [sliceId],
       extraControls: {},
+      ...(activeFilters && { activeFilters }),
     });
     Object.assign(dashboardContextWithFilters, {
       dashboardId,
@@ -143,16 +146,18 @@ export default function ExplorePage() {
       URL_PARAMS.saveAction,
     ) as SaveActionType | null;
     const dashboardContextFormData = getDashboardContextFormData();
+
     if (!isExploreInitialized.current || !!saveAction) {
       fetchExploreData(exploreUrlParams)
         .then(({ result }) => {
-          const formData =
-            !isExploreInitialized.current && dashboardContextFormData
-              ? getFormDataWithDashboardContext(
-                  result.form_data,
-                  dashboardContextFormData,
-                )
-              : result.form_data;
+          const formData = dashboardContextFormData
+            ? getFormDataWithDashboardContext(
+                result.form_data,
+                dashboardContextFormData,
+                saveAction,
+              )
+            : result.form_data;
+
           dispatch(
             hydrateExplore({
               ...result,
diff --git a/superset-frontend/src/types/DashboardContextForExplore.ts b/superset-frontend/src/types/DashboardContextForExplore.ts
index e9e964a1a3..b9d0c3bd4a 100644
--- a/superset-frontend/src/types/DashboardContextForExplore.ts
+++ b/superset-frontend/src/types/DashboardContextForExplore.ts
@@ -21,7 +21,7 @@ import {
   DataRecordValue,
   PartialFilters,
 } from '@superset-ui/core';
-import { ChartConfiguration } from 'src/dashboard/types';
+import { ChartConfiguration, ActiveFilters } from 'src/dashboard/types';
 
 export interface DashboardContextForExplore {
   labelsColor: Record<string, string>;
@@ -40,6 +40,7 @@ export interface DashboardContextForExplore {
         };
       }
     | {};
+  activeFilters?: ActiveFilters;
   isRedundant?: boolean;
   dashboardPageId?: string;
 }
diff --git a/superset-frontend/src/utils/simpleFilterToAdhoc.ts b/superset-frontend/src/utils/simpleFilterToAdhoc.ts
index a3db14c074..4bff03eace 100644
--- a/superset-frontend/src/utils/simpleFilterToAdhoc.ts
+++ b/superset-frontend/src/utils/simpleFilterToAdhoc.ts
@@ -29,10 +29,50 @@ import {
 import { OPERATOR_ENUM_TO_OPERATOR_TYPE } from '../explore/constants';
 import { translateToSql } from '../explore/components/controls/FilterControl/utils/translateToSQL';
 
+const findMatchingFilterKey = (
+  filterClause: QueryObjectFilterClause & {
+    filterDataMapping?: Record<string, any[]>;
+    layerFilterScope?: Record<string, any>;
+  },
+): string | null => {
+  if (!filterClause.filterDataMapping) {
+    return null;
+  }
+
+  const { col, op } = filterClause;
+  const val = 'val' in filterClause ? filterClause.val : undefined;
+
+  for (const [key, filters] of Object.entries(filterClause.filterDataMapping)) {
+    if (Array.isArray(filters)) {
+      const matchingFilter = filters.find(
+        filter =>
+          filter.col === col &&
+          filter.op === op &&
+          JSON.stringify(filter.val) === JSON.stringify(val),
+      );
+
+      if (matchingFilter) {
+        return key;
+      }
+    }
+  }
+
+  return null;
+};
+
 export const simpleFilterToAdhoc = (
-  filterClause: QueryObjectFilterClause,
+  filterClause: QueryObjectFilterClause & {
+    filterDataMapping?: Record<string, any[]>;
+    layerFilterScope?: Record<string, any>;
+  },
   clause: Clauses = Clauses.Where,
 ) => {
+  // Find matching filter key
+  const matchingFilterKey = findMatchingFilterKey(filterClause);
+  const filterScope = matchingFilterKey
+    ? filterClause.layerFilterScope?.[matchingFilterKey]
+    : undefined;
+
   let result: AdhocFilter;
   if (isAdhocColumn(filterClause.col)) {
     result = {
@@ -60,6 +100,7 @@ export const simpleFilterToAdhoc = (
   if (filterClause.isExtra) {
     Object.assign(result, {
       isExtra: true,
+      layerFilterScope: filterScope,
       filterOptionName: `filter_${Math.random()
         .toString(36)
         .substring(2, 15)}_${Math.random().toString(36).substring(2, 15)}`,
diff --git a/superset/viz.py b/superset/viz.py
index 22e9e506f3..a180183d3a 100644
--- a/superset/viz.py
+++ b/superset/viz.py
@@ -1525,6 +1525,81 @@ class DeckGLMultiLayer(BaseViz):
     def query_obj(self) -> QueryObjectDict:
         return {}
 
+    def _filter_items_by_scope(
+        self,
+        items: list[Any],
+        layer_index: int,
+        layer_filter_scope: dict[str, list[int]],
+    ) -> list[Any]:
+        """Filter items based on layer filter scope."""
+        filtered_items = []
+        for filter_item in items:
+            filter_id = getattr(filter_item, "filterId", None)
+            if filter_id:
+                filter_scope = layer_filter_scope.get(filter_id, [])
+                if filter_scope is None:
+                    filter_scope = []
+                if not filter_scope or layer_index in filter_scope:
+                    filtered_items.append(filter_item)
+            else:
+                filtered_items.append(filter_item)
+        return filtered_items
+
+    def _process_extra_form_data_filters(
+        self,
+        layer_index: int,
+        layer_filter_scope: dict[str, list[int]],
+        filter_data_mapping: dict[str, list[Any]],
+        extra_form_data: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Process extra_form_data filters with layer-specific filtering."""
+        if not extra_form_data or not filter_data_mapping:
+            return extra_form_data
+
+        filtered_extra_form_data_filters = []
+        for filter_id, filter_scope in layer_filter_scope.items():
+            if filter_scope is None:
+                filter_scope = []
+
+            if not filter_scope or layer_index in filter_scope:
+                filters_from_this_filter = filter_data_mapping.get(filter_id, [])
+                filtered_extra_form_data_filters.extend(filters_from_this_filter)
+
+        return {
+            **extra_form_data,
+            "filters": filtered_extra_form_data_filters,
+        }
+
+    def _apply_layer_filtering(
+        self, form_data: dict[str, Any], layer_index: int
+    ) -> dict[str, Any]:
+        """Apply layer-specific filtering to form data."""
+        layer_filter_scope = self.form_data.get("layer_filter_scope", {})
+        filter_data_mapping = self.form_data.get("filter_data_mapping", {})
+
+        if not layer_filter_scope:
+            form_data["extra_filters"] = self.form_data.get("extra_filters", [])
+            form_data["adhoc_filters"] = self.form_data.get("adhoc_filters")
+            form_data["extra_form_data"] = self.form_data.get("extra_form_data")
+            return form_data
+
+        filtered_extra_filters = self._filter_items_by_scope(
+            self.form_data.get("extra_filters", []), layer_index, layer_filter_scope
+        )
+        filtered_adhoc_filters = self._filter_items_by_scope(
+            self.form_data.get("adhoc_filters", []), layer_index, layer_filter_scope
+        )
+
+        extra_form_data = self.form_data.get("extra_form_data", {})
+        filtered_extra_form_data = self._process_extra_form_data_filters(
+            layer_index, layer_filter_scope, filter_data_mapping, extra_form_data
+        )
+
+        form_data["extra_filters"] = filtered_extra_filters
+        form_data["adhoc_filters"] = filtered_adhoc_filters
+        form_data["extra_form_data"] = filtered_extra_form_data
+        return form_data
+
     @deprecated(deprecated_in="3.0")
     def get_data(self, df: pd.DataFrame) -> VizData:
         # Late imports to avoid circular import issues
@@ -1537,12 +1612,9 @@ class DeckGLMultiLayer(BaseViz):
 
         features: dict[str, list[Any]] = {}
 
-        for slc in slices:
+        for layer_index, slc in enumerate(slices):
             form_data = slc.form_data
-
-            form_data["extra_filters"] = self.form_data.get("extra_filters", [])
-            form_data["extra_form_data"] = self.form_data.get("extra_form_data", {})
-            form_data["adhoc_filters"] = self.form_data.get("adhoc_filters")
+            form_data = self._apply_layer_filtering(form_data, layer_index)
 
             viz_type_name = form_data.get("viz_type")
             viz_class = viz_types.get(viz_type_name)
@@ -1552,7 +1624,12 @@ class DeckGLMultiLayer(BaseViz):
             viz_instance = viz_class(datasource=slc.datasource, form_data=form_data)
             payload = viz_instance.get_payload()
 
-            if payload and "data" in payload and "features" in payload["data"]:
+            if (
+                payload
+                and "data" in payload
+                and payload["data"] is not None
+                and "features" in payload["data"]
+            ):
                 if viz_type_name not in features:
                     features[viz_type_name] = []
                 features[viz_type_name].extend(payload["data"]["features"])
@@ -1560,7 +1637,7 @@ class DeckGLMultiLayer(BaseViz):
         return {
             "features": features,
             "mapboxApiKey": config["MAPBOX_API_KEY"],
-            "slices": [slc.data for slc in slices],
+            "slices": [slc.data for slc in slices if slc.data is not None],
         }
 
 
@@ -1571,6 +1648,77 @@ class BaseDeckGLViz(BaseViz):
     credits = '<a href="https://uber.github.io/deck.gl/">deck.gl</a>'
     spatial_control_keys: list[str] = []
 
+    def __init__(
+        self, datasource: BaseDatasource, form_data: dict[str, Any], **kwargs: Any
+    ) -> None:
+        # Apply layer-specific filtering for deck multi layer charts in edit mode
+        if self._should_apply_layer_filtering(form_data):
+            form_data = self._apply_multilayer_filtering(form_data)
+        super().__init__(datasource, form_data, **kwargs)
+
+    def _should_apply_layer_filtering(self, form_data: dict[str, Any]) -> bool:
+        """Check if this is a deck layer that's part of a multilayer setup."""
+        return (
+            "slice_id" in form_data
+            and "adhoc_filters" in form_data
+            and self._has_layer_scoped_filters(form_data)
+        )
+
+    def _has_layer_scoped_filters(self, form_data: dict[str, Any]) -> bool:
+        """Check if any filter has layerFilterScope (indicates multilayer context)."""
+        for filter_item in form_data.get("adhoc_filters", []):
+            if (
+                isinstance(filter_item, dict)
+                and filter_item.get("layerFilterScope") is not None
+            ):
+                return True
+        return False
+
+    def _apply_multilayer_filtering(self, form_data: dict[str, Any]) -> dict[str, Any]:
+        """
+        Filter adhoc_filters based on layer scope for this specific layer.
+
+        In deck multi-layer charts, each individual layer should only receive:
+        1. Global filters (filters without layerFilterScope)
+        2. Filters specifically scoped to this layer
+
+        This prevents over-filtering when multiple layer-scoped filters are present.
+        """
+        slice_id = form_data.get("slice_id")
+        deck_slices = self._get_deck_slices_from_filters(form_data)
+
+        if not deck_slices or slice_id not in deck_slices:
+            return form_data
+
+        layer_index = deck_slices.index(slice_id)
+        filtered_adhoc_filters = []
+
+        for filter_item in form_data.get("adhoc_filters", []):
+            layer_scope = self._get_filter_layer_scope(filter_item)
+
+            # Include global filters (no layer scope) or filters scoped to this layer
+            if layer_scope is None or layer_index in layer_scope:
+                filtered_adhoc_filters.append(filter_item)
+
+        modified_form_data = form_data.copy()
+        modified_form_data["adhoc_filters"] = filtered_adhoc_filters
+        return modified_form_data
+
+    def _get_deck_slices_from_filters(
+        self, form_data: dict[str, Any]
+    ) -> list[int] | None:
+        """Extract deck_slices from any filter that contains it."""
+        for filter_item in form_data.get("adhoc_filters", []):
+            if isinstance(filter_item, dict) and "deck_slices" in filter_item:
+                return filter_item["deck_slices"]
+        return None
+
+    def _get_filter_layer_scope(self, filter_item: Any) -> list[int] | None:
+        """Extract layerFilterScope from a filter item."""
+        if isinstance(filter_item, dict):
+            return filter_item.get("layerFilterScope")
+        return getattr(filter_item, "layerFilterScope", None)
+
     @deprecated(deprecated_in="3.0")
     def get_metrics(self) -> list[str]:
         # pylint: disable=attribute-defined-outside-init
diff --git a/tests/integration_tests/viz_tests.py b/tests/integration_tests/viz_tests.py
index 1631f8d7e0..b3f4a65da1 100644
--- a/tests/integration_tests/viz_tests.py
+++ b/tests/integration_tests/viz_tests.py
@@ -812,6 +812,620 @@ class TestBaseDeckGLViz(SupersetTestCase):
             adhoc_filters = test_viz_deckgl.form_data["adhoc_filters"]
             assert expected_results.get(mock_key) == adhoc_filters
 
+    def test_init_with_layer_filtering_applied(self):
+        """Test BaseDeckGLViz.__init__ applies layer filtering when conditions are
+        met."""
+        datasource = self.get_datasource_mock()
+        form_data = {
+            "slice_id": 123,
+            "adhoc_filters": [
+                {
+                    "clause": "WHERE",
+                    "subject": "col1",
+                    "operator": "==",
+                    "comparator": "value1",
+                    "layerFilterScope": [0, 1],
+                    "deck_slices": [123, 456],
+                },
+                {
+                    "clause": "WHERE",
+                    "subject": "col2",
+                    "operator": "!=",
+                    "comparator": "value2",
+                    "layerFilterScope": [1],
+                    "deck_slices": [123, 456],
+                },
+            ],
+        }
+
+        test_viz = viz.BaseDeckGLViz(datasource, form_data)
+
+        # Should only have the first filter (scoped to layer 0)
+        assert len(test_viz.form_data["adhoc_filters"]) == 1
+        assert test_viz.form_data["adhoc_filters"][0]["subject"] == "col1"
+
+    def test_init_without_layer_filtering(self):
+        """Test BaseDeckGLViz.__init__ doesn't apply filtering when conditions
+        aren't met."""
+        datasource = self.get_datasource_mock()
+        form_data = {
+            "adhoc_filters": [
+                {
+                    "clause": "WHERE",
+                    "subject": "col1",
+                    "operator": "==",
+                    "comparator": "value1",
+                }
+            ]
+        }
+        original_filters = form_data["adhoc_filters"].copy()
+
+        test_viz = viz.BaseDeckGLViz(datasource, form_data)
+
+        # Filters should remain unchanged
+        assert test_viz.form_data["adhoc_filters"] == original_filters
+
+    def test_should_apply_layer_filtering_true(self):
+        """Test _should_apply_layer_filtering returns True when all conditions are
+        met."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {"slice_id": 123, "adhoc_filters": [{"layerFilterScope": [0, 1]}]}
+
+        result = test_viz._should_apply_layer_filtering(form_data)
+        assert result is True
+
+    def test_should_apply_layer_filtering_false_missing_slice_id(self):
+        """Test _should_apply_layer_filtering returns False when slice_id is missing."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {"adhoc_filters": [{"layerFilterScope": [0, 1]}]}
+
+        result = test_viz._should_apply_layer_filtering(form_data)
+        assert result is False
+
+    def test_should_apply_layer_filtering_false_missing_adhoc_filters(self):
+        """Test _should_apply_layer_filtering returns False when adhoc_filters is
+        missing."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {"slice_id": 123}
+
+        result = test_viz._should_apply_layer_filtering(form_data)
+        assert result is False
+
+    def test_should_apply_layer_filtering_false_no_layer_scoped_filters(self):
+        """Test _should_apply_layer_filtering returns False when no layer scoped
+        filters exist."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {
+            "slice_id": 123,
+            "adhoc_filters": [{"clause": "WHERE", "subject": "col1"}],
+        }
+
+        result = test_viz._should_apply_layer_filtering(form_data)
+        assert result is False
+
+    def test_has_layer_scoped_filters_true_with_dict(self):
+        """Test _has_layer_scoped_filters returns True when filter dict has
+        layerFilterScope."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {
+            "adhoc_filters": [{"layerFilterScope": [0, 1]}, {"clause": "WHERE"}]
+        }
+
+        result = test_viz._has_layer_scoped_filters(form_data)
+        assert result is True
+
+    def test_has_layer_scoped_filters_true_with_non_none_value(self):
+        """Test _has_layer_scoped_filters returns True when layerFilterScope is not
+        None."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {
+            "adhoc_filters": [
+                {"layerFilterScope": []},  # Empty list is not None
+                {"clause": "WHERE"},
+            ]
+        }
+
+        result = test_viz._has_layer_scoped_filters(form_data)
+        assert result is True
+
+    def test_has_layer_scoped_filters_false_none_value(self):
+        """Test _has_layer_scoped_filters returns False when layerFilterScope is
+        None."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {"adhoc_filters": [{"layerFilterScope": None}, {"clause": "WHERE"}]}
+
+        result = test_viz._has_layer_scoped_filters(form_data)
+        assert result is False
+
+    def test_has_layer_scoped_filters_false_no_scoped_filters(self):
+        """Test _has_layer_scoped_filters returns False when no filters have
+        layerFilterScope."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {
+            "adhoc_filters": [
+                {"clause": "WHERE", "subject": "col1"},
+                {"clause": "WHERE", "subject": "col2"},
+            ]
+        }
+
+        result = test_viz._has_layer_scoped_filters(form_data)
+        assert result is False
+
+    def test_has_layer_scoped_filters_empty_filters(self):
+        """Test _has_layer_scoped_filters returns False when adhoc_filters is empty."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {"adhoc_filters": []}
+
+        result = test_viz._has_layer_scoped_filters(form_data)
+        assert result is False
+
+    def test_apply_multilayer_filtering_filters_by_layer_scope(self):
+        """Test _apply_multilayer_filtering correctly filters by layer scope."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {
+            "slice_id": 456,  # This is layer index 1
+            "adhoc_filters": [
+                {
+                    "subject": "global_filter",
+                    "deck_slices": [123, 456],
+                    # No layerFilterScope = global filter
+                },
+                {
+                    "subject": "layer_0_filter",
+                    "layerFilterScope": [0],
+                    "deck_slices": [123, 456],
+                },
+                {
+                    "subject": "layer_1_filter",
+                    "layerFilterScope": [1],
+                    "deck_slices": [123, 456],
+                },
+                {
+                    "subject": "layer_0_1_filter",
+                    "layerFilterScope": [0, 1],
+                    "deck_slices": [123, 456],
+                },
+            ],
+        }
+
+        result = test_viz._apply_multilayer_filtering(form_data)
+
+        # Should include: global_filter, layer_1_filter, layer_0_1_filter
+        assert len(result["adhoc_filters"]) == 3
+        subjects = [f["subject"] for f in result["adhoc_filters"]]
+        assert "global_filter" in subjects
+        assert "layer_1_filter" in subjects
+        assert "layer_0_1_filter" in subjects
+        assert "layer_0_filter" not in subjects
+
+    def test_apply_multilayer_filtering_no_deck_slices(self):
+        """Test _apply_multilayer_filtering returns original form_data when no
+        deck_slices."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {"slice_id": 123, "adhoc_filters": [{"subject": "filter1"}]}
+
+        result = test_viz._apply_multilayer_filtering(form_data)
+
+        # Should return original form_data unchanged
+        assert result == form_data
+
+    def test_apply_multilayer_filtering_slice_not_in_deck_slices(self):
+        """Test _apply_multilayer_filtering returns original when slice_id not in
+        deck_slices."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {
+            "slice_id": 999,  # Not in deck_slices
+            "adhoc_filters": [{"subject": "filter1", "deck_slices": [123, 456]}],
+        }
+
+        result = test_viz._apply_multilayer_filtering(form_data)
+
+        # Should return original form_data unchanged
+        assert result == form_data
+
+    def test_get_deck_slices_from_filters_found(self):
+        """Test _get_deck_slices_from_filters returns deck_slices when found."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {
+            "adhoc_filters": [
+                {"subject": "filter1"},
+                {"subject": "filter2", "deck_slices": [123, 456, 789]},
+                {"subject": "filter3"},
+            ]
+        }
+
+        result = test_viz._get_deck_slices_from_filters(form_data)
+
+        assert result == [123, 456, 789]
+
+    def test_get_deck_slices_from_filters_not_found(self):
+        """Test _get_deck_slices_from_filters returns None when not found."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {"adhoc_filters": [{"subject": "filter1"}, {"subject": "filter2"}]}
+
+        result = test_viz._get_deck_slices_from_filters(form_data)
+
+        assert result is None
+
+    def test_get_deck_slices_from_filters_empty_filters(self):
+        """Test _get_deck_slices_from_filters returns None when adhoc_filters is
+        empty."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        form_data = {"adhoc_filters": []}
+
+        result = test_viz._get_deck_slices_from_filters(form_data)
+
+        assert result is None
+
+    def test_get_filter_layer_scope_dict(self):
+        """Test _get_filter_layer_scope with dict filter item."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        filter_item = {"layerFilterScope": [0, 1, 2]}
+        result = test_viz._get_filter_layer_scope(filter_item)
+
+        assert result == [0, 1, 2]
+
+    def test_get_filter_layer_scope_dict_none(self):
+        """Test _get_filter_layer_scope with dict that has None layerFilterScope."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        filter_item = {"layerFilterScope": None}
+        result = test_viz._get_filter_layer_scope(filter_item)
+
+        assert result is None
+
+    def test_get_filter_layer_scope_dict_missing_key(self):
+        """Test _get_filter_layer_scope with dict missing layerFilterScope."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        filter_item = {"subject": "col1"}
+        result = test_viz._get_filter_layer_scope(filter_item)
+
+        assert result is None
+
+    def test_get_filter_layer_scope_object_with_attribute(self):
+        """Test _get_filter_layer_scope with object having layerFilterScope
+        attribute."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        from unittest.mock import Mock
+
+        filter_item = Mock()
+        filter_item.layerFilterScope = [1, 2]
+
+        result = test_viz._get_filter_layer_scope(filter_item)
+
+        assert result == [1, 2]
+
+    def test_get_filter_layer_scope_object_without_attribute(self):
+        """Test _get_filter_layer_scope with object missing layerFilterScope
+        attribute."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        from unittest.mock import Mock
+
+        filter_item = Mock()
+        del filter_item.layerFilterScope  # Remove the attribute
+
+        result = test_viz._get_filter_layer_scope(filter_item)
+
+        assert result is None
+
+    def test_get_filter_layer_scope_non_dict_non_object(self):
+        """Test _get_filter_layer_scope with non-dict, non-object types."""
+        datasource = self.get_datasource_mock()
+        test_viz = viz.BaseDeckGLViz(datasource, {})
+
+        # Test with string
+        result = test_viz._get_filter_layer_scope("string_filter")
+        assert result is None
+
+        # Test with number
+        result = test_viz._get_filter_layer_scope(123)
+        assert result is None
+
+        # Test with None
+        result = test_viz._get_filter_layer_scope(None)
+        assert result is None
+
+
+class TestDeckGLMultiLayer(SupersetTestCase):
+    def test_filter_items_by_scope_with_filter_id(self):
+        """Test _filter_items_by_scope method with items having filterId."""
+        datasource = self.get_datasource_mock()
+        form_data = {}
+        test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+
+        filter_item_1 = Mock()
+        filter_item_1.filterId = "filter_1"
+        filter_item_2 = Mock()
+        filter_item_2.filterId = "filter_2"
+        filter_item_3 = Mock()
+        filter_item_3.filterId = "filter_3"
+
+        items = [filter_item_1, filter_item_2, filter_item_3]
+        layer_index = 0
+        layer_filter_scope = {"filter_1": [0, 1], "filter_2": [1], "filter_3": []}
+
+        result = test_viz._filter_items_by_scope(items, layer_index, layer_filter_scope)
+
+        assert len(result) == 2
+        assert filter_item_1 in result
+        assert filter_item_3 in result
+        assert filter_item_2 not in result
+
+    def test_filter_items_by_scope_without_filter_id(self):
+        """Test _filter_items_by_scope method with items without filterId."""
+        datasource = self.get_datasource_mock()
+        form_data = {}
+        test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+
+        filter_item_1 = Mock()
+        del filter_item_1.filterId
+        filter_item_2 = Mock()
+        filter_item_2.filterId = None
+
+        items = [filter_item_1, filter_item_2]
+        layer_index = 0
+        layer_filter_scope = {"filter_1": [1]}
+
+        result = test_viz._filter_items_by_scope(items, layer_index, layer_filter_scope)
+
+        assert len(result) == 2
+        assert filter_item_1 in result
+        assert filter_item_2 in result
+
+    def test_process_extra_form_data_filters(self):
+        """Test _process_extra_form_data_filters method."""
+        datasource = self.get_datasource_mock()
+        form_data = {}
+        test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+
+        layer_index = 0
+        layer_filter_scope = {"filter_1": [0, 1], "filter_2": [1], "filter_3": []}
+        filter_data_mapping = {
+            "filter_1": [{"column": "col1", "op": "==", "val": "value1"}],
+            "filter_2": [{"column": "col2", "op": "!=", "val": "value2"}],
+            "filter_3": [{"column": "col3", "op": ">", "val": 100}],
+        }
+        extra_form_data = {"existing_key": "existing_value"}
+
+        result = test_viz._process_extra_form_data_filters(
+            layer_index, layer_filter_scope, filter_data_mapping, extra_form_data
+        )
+
+        expected_filters = [
+            {"column": "col1", "op": "==", "val": "value1"},
+            {"column": "col3", "op": ">", "val": 100},
+        ]
+        assert result["filters"] == expected_filters
+        assert result["existing_key"] == "existing_value"
+
+    def test_process_extra_form_data_filters_empty_inputs(self):
+        """Test _process_extra_form_data_filters with empty inputs."""
+        datasource = self.get_datasource_mock()
+        form_data = {}
+        test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+
+        result = test_viz._process_extra_form_data_filters(0, {}, {}, {})
+        assert result == {}
+
+        extra_form_data = {"key": "value"}
+        result = test_viz._process_extra_form_data_filters(0, {}, {}, extra_form_data)
+        assert result == extra_form_data
+
+    def test_apply_layer_filtering_without_layer_filter_scope(self):
+        """Test _apply_layer_filtering when layer_filter_scope is empty."""
+        datasource = self.get_datasource_mock()
+        form_data = {
+            "extra_filters": [Mock(), Mock()],
+            "adhoc_filters": [Mock()],
+            "extra_form_data": {"key": "value"},
+        }
+        test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+
+        layer_form_data = {"viz_type": "deck_scatter"}
+        layer_index = 0
+
+        result = test_viz._apply_layer_filtering(layer_form_data, layer_index)
+
+        assert result["extra_filters"] == form_data["extra_filters"]
+        assert result["adhoc_filters"] == form_data["adhoc_filters"]
+        assert result["extra_form_data"] == form_data["extra_form_data"]
+
+    def test_apply_layer_filtering_with_layer_filter_scope(self):
+        """Test _apply_layer_filtering with layer_filter_scope."""
+        datasource = self.get_datasource_mock()
+
+        extra_filter_1 = Mock()
+        extra_filter_1.filterId = "filter_1"
+        extra_filter_2 = Mock()
+        extra_filter_2.filterId = "filter_2"
+
+        adhoc_filter_1 = Mock()
+        adhoc_filter_1.filterId = "filter_1"
+
+        form_data = {
+            "layer_filter_scope": {"filter_1": [0], "filter_2": [1]},
+            "filter_data_mapping": {
+                "filter_1": [{"column": "col1", "op": "==", "val": "value1"}]
+            },
+            "extra_filters": [extra_filter_1, extra_filter_2],
+            "adhoc_filters": [adhoc_filter_1],
+            "extra_form_data": {"existing": "data"},
+        }
+        test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+
+        layer_form_data = {"viz_type": "deck_scatter"}
+        layer_index = 0
+
+        result = test_viz._apply_layer_filtering(layer_form_data, layer_index)
+
+        assert len(result["extra_filters"]) == 1
+        assert result["extra_filters"][0].filterId == "filter_1"
+        assert len(result["adhoc_filters"]) == 1
+        assert result["adhoc_filters"][0].filterId == "filter_1"
+        assert result["extra_form_data"]["filters"] == [
+            {"column": "col1", "op": "==", "val": "value1"}
+        ]
+
+    @patch("superset.viz.viz_types")
+    @patch("superset.db.session")
+    def test_get_data_with_layer_filtering(self, mock_db_session, mock_viz_types):
+        """Test get_data method with layer filtering enabled."""
+        datasource = self.get_datasource_mock()
+
+        slice_1 = Mock()
+        slice_1.form_data = {"viz_type": "deck_scatter", "layer_name": "Layer 1"}
+        slice_1.data = {"features": [{"type": "Feature"}]}
+        slice_1.datasource = datasource
+
+        slice_2 = Mock()
+        slice_2.form_data = {"viz_type": "deck_path", "layer_name": "Layer 2"}
+        slice_2.data = {"features": [{"type": "Feature"}]}
+        slice_2.datasource = datasource
+
+        # Mock the database query to return our slice objects
+        mock_db_session.query.return_value.filter.return_value.all.return_value = [
+            slice_1,
+            slice_2,
+        ]
+
+        mock_scatter_viz_class = Mock()
+        mock_scatter_viz_instance = Mock()
+        mock_scatter_viz_instance.get_payload.return_value = {
+            "data": {"features": [{"id": 1}]}
+        }
+        mock_scatter_viz_class.return_value = mock_scatter_viz_instance
+
+        mock_path_viz_class = Mock()
+        mock_path_viz_instance = Mock()
+        mock_path_viz_instance.get_payload.return_value = {
+            "data": {"features": [{"id": 2}]}
+        }
+        mock_path_viz_class.return_value = mock_path_viz_instance
+
+        mock_viz_types.get.side_effect = lambda viz_type: {
+            "deck_scatter": mock_scatter_viz_class,
+            "deck_path": mock_path_viz_class,
+        }.get(viz_type)
+
+        form_data = {
+            "layer_filter_scope": {"filter_1": [0], "filter_2": [1]},
+            "filter_data_mapping": {
+                "filter_1": [{"column": "col1", "op": "==", "val": "value1"}],
+                "filter_2": [{"column": "col2", "op": "!=", "val": "value2"}],
+            },
+            "deck_slices": [1, 2],  # Use integer IDs instead of Mock objects
+        }
+
+        with patch("superset.viz.config", {"MAPBOX_API_KEY": "test_key"}):
+            test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+
+            test_viz._apply_layer_filtering = Mock(
+                side_effect=lambda form_data, idx: form_data
+            )
+
+            result = test_viz.get_data(pd.DataFrame())
+
+            assert test_viz._apply_layer_filtering.call_count == 2
+            test_viz._apply_layer_filtering.assert_any_call(slice_1.form_data, 0)
+            test_viz._apply_layer_filtering.assert_any_call(slice_2.form_data, 1)
+
+            assert isinstance(result, dict)
+            assert "features" in result
+            assert "mapboxApiKey" in result
+            assert "slices" in result
+            assert result["mapboxApiKey"] == "test_key"
+
+    @patch("superset.viz.viz_types")
+    @patch("superset.db.session")
+    def test_get_data_filters_none_data_slices(self, mock_db_session, mock_viz_types):
+        """Test get_data method filters out slices with None data."""
+        datasource = self.get_datasource_mock()
+
+        slice_1 = Mock()
+        slice_1.form_data = {"viz_type": "deck_scatter"}
+        slice_1.data = {"features": [{"type": "Feature"}]}
+        slice_1.datasource = datasource
+
+        slice_2 = Mock()
+        slice_2.form_data = {"viz_type": "deck_path"}
+        slice_2.data = None
+        slice_2.datasource = datasource
+
+        # Mock the database query to return our slice objects
+        mock_db_session.query.return_value.filter.return_value.all.return_value = [
+            slice_1,
+            slice_2,
+        ]
+
+        mock_viz_class = Mock()
+        mock_viz_instance = Mock()
+        mock_viz_instance.get_payload.return_value = {"data": {"features": []}}
+        mock_viz_class.return_value = mock_viz_instance
+        mock_viz_types.get.return_value = mock_viz_class
+
+        form_data = {"deck_slices": [1, 2]}  # Use integer IDs instead of Mock objects
+
+        with patch("superset.viz.config", {"MAPBOX_API_KEY": "test_key"}):
+            test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+            result = test_viz.get_data(pd.DataFrame())
+
+            assert isinstance(result, dict)
+            assert len(result["slices"]) == 1
+            assert result["slices"][0] == slice_1.data
+
+    def test_get_data_empty_deck_slices(self):
+        """Test get_data method with empty deck_slices."""
+        datasource = self.get_datasource_mock()
+        form_data = {"deck_slices": []}
+
+        with patch("superset.viz.config", {"MAPBOX_API_KEY": "test_key"}):
+            test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+            result = test_viz.get_data(pd.DataFrame())
+
+            assert isinstance(result, dict)
+            assert result["features"] == {}
+            assert result["slices"] == []
+            assert result["mapboxApiKey"] == "test_key"
+
 
 class TestTimeSeriesViz(SupersetTestCase):
     def test_timeseries_unicode_data(self):