I have two proxy models that filter columns of my main model. This one also filter rows

LayersProxyModel::LayersProxyModel(QObject* parent) : QSortFilterProxyModel(parent)
{
       
}


bool LayersProxyModel::filterAcceptsColumn(int source_column, 
                                           const QModelIndex &source_parent) const
{
    switch (static_cast<DataBaseModel::Columns>(source_column))
    {
        case DataBaseModel::Columns::LayerName:
            return true;
        default:
            return false;
    }
    return false;
}

bool LayersProxyModel::lessThan(const QModelIndex &left, 
                                const QModelIndex &right) const
{
    int filterColumn = static_cast<int>(DataBaseModel::Columns::LayerName);

    QVariant leftData = sourceModel()->data(left, filterColumn);
    QVariant rightData = sourceModel()->data(right, filterColumn);
    
    // QVariant < QVariant Q_DEPRECATED
    return leftData.toString() < rightData.toString();
}

bool LayersProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
{
    int filterColumn = static_cast<int>(DataBaseModel::Columns::LayerName);
    
    QModelIndex index = sourceModel()->index(source_row, filterColumn, source_parent);
    QVariant data = sourceModel()->data(index);
    for (int row = 0; row < source_row; ++row)
    {
        QModelIndex previousIndex = sourceModel()->index(row, filterColumn, source_parent);
        if (sourceModel()->data(previousIndex) == data)
        {
            return false;
        }
    }

    return true;
}

This one filter only columns

PacketLayerPurposeProxyModel::PacketLayerPurposeProxyModel(QObject* parent) : 
QSortFilterProxyModel(parent)
{
       
}

bool PacketLayerPurposeProxyModel::filterAcceptsColumn(int source_column, 
                                                       const QModelIndex &source_parent) const
{
  
    switch (static_cast<DataBaseModel::Columns>(source_column))
    {
        case DataBaseModel::Columns::PacketName:
        case DataBaseModel::Columns::LayerName:
        case DataBaseModel::Columns::PurposeName:
        case DataBaseModel::Columns::Manipulators:
            return true;

        default:
            return false;
    }
    return false;
}

What I would like to do:

auto p_l_p_dbmodel = new PacketLayerPurposeProxyModel(p_l_p_tableView);
p_l_p_tableView->setSourceModel(main_model);

LayersProxyModel *layers_proxy_model = new LayersProxyModel(this);
layers_proxy_model->setSourceModel(p_l_p_tableView);

The problem is that when the sourceModel is a proxy model, the index of the column by which I filter is in a different position and I don’t understand how I can translate the index of the source model into the index of the proxy model

bool LayersProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
{
    int filterColumn = static_cast<int>(DataBaseModel::Columns::LayerName);

***PROBLEM IS HERE
    filterСolumn == 6 but in the proxy model the index of this column is 2 and calling 
    this function returns invalid indexes and the data is not displayed when sourceModel() 
    is a proxy model***

    QModelIndex index = sourceModel()->index(source_row, filterColumn, source_parent);
    QVariant data = sourceModel()->data(index);
    for (int row = 0; row < source_row; ++row)
    {
        QModelIndex previousIndex = sourceModel()->index(row, filterColumn, source_parent);
        if (sourceModel()->data(previousIndex) == data)
        {
            return false;
        }
    }

    return true;
}

Just I have several views and I need to adapt this function to work with both, when source model is a proxy model and when source model is actual model