code: def iloc(cls, dataset, index):
      from geopandas import GeoSeries
      from shapely.geometry import MultiPoint
  
      rows, cols = index
      geom_dims = cls.geom_dims(dataset)
      geom_col = cls.geo_column(dataset.data)
      scalar = False
      columns = list(dataset.data.columns)
      if isinstance(cols, slice):
          cols = [d.name for d in dataset.dimensions()][cols]
      elif np.isscalar(cols):
          scalar = np.isscalar(rows)
          cols = [dataset.get_dimension(cols).name]
      else:
          cols = [dataset.get_dimension(d).name for d in index[1]]
      if not all(d in cols for d in geom_dims):
          raise DataError(
              "Cannot index a dimension which is part of the "
              "geometry column of a spatialpandas DataFrame.",
              cls,
          )
      cols = list(
          unique_iterator(
              [
                  columns.index(geom_col)
                  if c in geom_dims
                  else columns.index(c)
                  for c in cols
              ]
          )
      )
  
      geom_type = dataset.data[geom_col].geom_type.iloc[0]
      if geom_type != "MultiPoint":
          if scalar:
              return dataset.data.iloc[rows[0], cols[0]]
          elif isscalar(rows):
              rows = [rows]
          return dataset.data.iloc[rows, cols]
  
      geoms = dataset.data[geom_col]
      count = 0
      new_geoms, indexes = [], []
      for i, geom in enumerate(geoms):
          length = len(geom.geoms)
          if np.isscalar(rows):
              if count <= rows < (count + length):
                  new_geoms.append(geom.geoms[rows - count])
                  indexes.append(i)
                  break
          elif isinstance(rows, slice):
              if rows.start is not None and rows.start > (
                  count + length
              ):
                  continue
              elif rows.stop is not None and rows.stop < count:
                  break
              start = (
                  None
                  if rows.start is None
                  else max(rows.start - count, 0)
              )
              stop = (
                  None
                  if rows.stop is None
                  else min(rows.stop - count, length)
              )
              if rows.step is not None:
                  dataset.param.warning(
                      ".iloc step slicing currently not supported for"
                      "the multi-tabular data format."
                  )
              indexes.append(i)
              new_geoms.append(geom.geoms[start:stop])
          elif isinstance(rows, (list, set)):
              sub_rows = [
                  (r - count)
                  for r in rows
                  if count <= r < (count + length)
              ]
              if not sub_rows:
                  continue
              indexes.append(i)
              new_geoms.append(
                  MultiPoint([geom.geoms[r] for r in sub_rows])
              )
          count += length
  
      new = dataset.data.iloc[indexes].copy()
      new[geom_col] = GeoSeries(new_geoms)
      return new
  
imports: import sys
  import warnings
  from collections import defaultdict
  import numpy
  import pandas
  from holoviews.core.util import isscalar, unique_iterator, unique_array
  from holoviews.core.data import Dataset, Interface, MultiInterface, PandasAPI
  from holoviews.core.data.interface import DataError
  from holoviews.core.data import PandasInterface
  from holoviews.core.data.spatialpandas import get_value_array
  from holoviews.core.dimension import dimension_name
  from holoviews.element import Path
  from ..util import asarray, geom_to_array, geom_types, geom_length
  from .geom_dict import geom_from_dict
label_desc: Use image node_id 27 for calling the GeoPandasInterface obj's underlying member method code with example usage: obj.iloc(cls, dataset, index) and returns: new, dataset, dataset