/**
* Copyright (C) 2001-2017 by RapidMiner and the contributors
*
* Complete list of developers available at our web site:
*
* http://rapidminer.com
*
* This program is free software: you can redistribute it and/or modify it under the terms of the
* GNU Affero General Public License as published by the Free Software Foundation, either version 3
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
* even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License along with this program.
* If not, see http://www.gnu.org/licenses/.
*/
package com.rapidminer.datatable;
import com.rapidminer.gui.new_plotter.utility.DataStructureUtils;
import com.rapidminer.tools.container.Pair;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
/**
* A view on a dataTable which changes the mapping of nominal values such that nominal values or
* ordered lexically ascending or descending with increasing index values.
*
* Uses lazy initialization, i.e. the mapping is only created on first access.
*
* @author Marius Helf
*
*/
public class NominalSortingDataTableMapping implements BidirectionalMappingProvider, DataTableListener {
/**
* Maps values from the parent table to the new values.
*/
Map<Double, Double> parentToChildMapping = null;
Map<Double, Double> childToParentMapping = null;
private boolean ascending;
private int columnIdx;
private final DataTable originalDataTable;
public NominalSortingDataTableMapping(ValueMappingDataTableView dataTable, int columnIdx, boolean ascending) {
if (!dataTable.isNominal(columnIdx)) {
throw new IllegalArgumentException("NominalSortingDataTableMapping can only work on nominal columns.");
}
this.ascending = ascending;
this.columnIdx = columnIdx;
this.originalDataTable = dataTable.getParent();
originalDataTable.addDataTableListener(this, true);
}
private void updateMapping(DataTable dataTable, int columnIdx, boolean ascending) {
List<Double> distinctValues = DataStructureUtils.getDistinctDataTableValues(dataTable, columnIdx);
List<Pair<Double, String>> valueStrings = new LinkedList<Pair<Double, String>>();
for (double value : distinctValues) {
valueStrings.add(new Pair<Double, String>(value, dataTable.mapIndex(columnIdx, (int) value)));
}
Collections.sort(valueStrings, new DataStructureUtils.PairComparator<Double, String>(ascending));
parentToChildMapping = new HashMap<Double, Double>();
childToParentMapping = new HashMap<Double, Double>();
double idx = 0.0;
for (Pair<Double, String> entry : valueStrings) {
parentToChildMapping.put(entry.getFirst(), idx);
childToParentMapping.put(idx, entry.getFirst());
idx += 1;
}
}
@Override
public double mapFromParentValue(double originalValue) {
if (parentToChildMapping == null) {
updateMapping(originalDataTable, columnIdx, ascending);
}
return parentToChildMapping.get(originalValue);
}
@Override
public void dataTableUpdated(DataTable source) {
// invalidate mapping (will be recalculated on next access)
parentToChildMapping = null;
childToParentMapping = null;
}
@Override
public double mapToParentValue(double value) {
if (childToParentMapping == null) {
updateMapping(originalDataTable, columnIdx, ascending);
}
return childToParentMapping.get(value);
}
}