def my_vtk_grid_props(vtk_reader):
    """
    Get grid properties from vtk_reader instance.

    Parameters
    ----------
    vtk_reader: vtk Reader instance
        vtk Reader containing information about a vtk-file.

    Returns
    ----------
    step_x : float
        For regular grid, stepsize in x-direction.

    step_y : float
        For regular grid, stepsize in y-direction.

    npts_x : float
        Number of cells in x-direction.

    npts_y : float
        Number of cells in y-direction.

    low_m_x : float
        Middle of first x cell

    high_m_x : float
        Middle of last x cell

    low_m_y : float
        Middle of first y cell

    high_m_y : float
        Middle of last y cell

    low_x : float
        Edge of first x cell

    high_x : float
        Edge of last x cell

    low_y : float
        Edge of first y cell

    high_y : float
        Edge of last y cell

    Notes
    ----------
    0: step_x
    1: step_y
    2: npts_x
    3: npts_y
    4: low_m_x - Middle of cells: first x cell
    5: high_m_x - Middle of cells: last x cell
    6: low_m_y - Middle of cells: first y cell
    7: high_m_y - Middle of cells: last y cell
    8: low_x - Edge of cells: first x cell
    9: high_x - Edge of cells: last x cell
    10: low_y - Edge of cells: first y cell
    11: high_y - Edge of cells: last y cell
    """

    vtk_output = vtk_reader.GetOutput()

    # Read attributes of the vtk-Array
    # num_cells = vtk_output.GetNumberOfCells()
    # num_points = vtk_output.GetNumberOfPoints()
    # whole_extent = vtk_output.GetExtent()
    grid_bounds = vtk_output.GetBounds()
    grid_dims = vtk_output.GetDimensions()

    # Grid information
    step_x = (grid_bounds[1] - grid_bounds[0]) / (grid_dims[0] - 1)
    step_y = (grid_bounds[3] - grid_bounds[2]) / (grid_dims[1] - 1)
    if grid_bounds[0] == 0.0:  # CELLS
        npts_x = grid_dims[0] - 1
        npts_y = grid_dims[1] - 1
        low_m_x = grid_bounds[0] + 0.5 * step_x
        high_m_x = grid_bounds[1] - 0.5 * step_x
        low_m_y = grid_bounds[2] + 0.5 * step_y
        high_m_y = grid_bounds[3] - 0.5 * step_y
        low_x = grid_bounds[0]
        high_x = grid_bounds[1]
        low_y = grid_bounds[2]
        high_y = grid_bounds[3]
    else:  # POINTS
        npts_x = grid_dims[0]
        npts_y = grid_dims[1]
        low_m_x = grid_bounds[0]
        high_m_x = grid_bounds[1]
        low_m_y = grid_bounds[2]
        high_m_y = grid_bounds[3]
        low_x = grid_bounds[0] - 0.5 * step_x
        high_x = grid_bounds[1] + 0.5 * step_x
        low_y = grid_bounds[2] - 0.5 * step_y
        high_y = grid_bounds[3] + 0.5 * step_y

    return step_x, step_y, \
        npts_x, npts_y, \
        low_m_x, high_m_x, low_m_y, high_m_y, \
        low_x, high_x, low_y, high_y