/*
 * GRAL: GRAphing Library for Java(R)
 *
 * (C) Copyright 2009-2016 Erich Seifert ,
 * Michael Seifert 
 *
 * This file is part of GRAL.
 *
 * GRAL is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GRAL 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with GRAL.  If not, see .
 */
package de.erichseifert.gral.data.filters;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;

import de.erichseifert.gral.data.AbstractDataSource;
import de.erichseifert.gral.data.DataChangeEvent;
import de.erichseifert.gral.data.DataListener;
import de.erichseifert.gral.data.DataSource;
import de.erichseifert.gral.util.MathUtils;


/**
 * 

Abstract class that provides basic functions for filtering arbitrary * columns of a DataSource, in other words a set of one-dimensional data.

* *

Functionality includes:

*
    *
  • Different modes for filtering (see {@link Mode})
  • *
  • Support for listening for changes of the original data
  • *
  • Filtering of multiple columns
  • *
* *

Values of filtered columns are buffered. Access to unfiltered columns is * delegated to the original data source. Derived classes must make sure the * caches are updated when deserialization is done. This can be done by calling * {@code dataUpdated(this)} in a custom deserialization method.

*/ public abstract class Filter2D extends AbstractDataSource implements DataListener { /** Version id for serialization. */ private static final long serialVersionUID = -5004453681128601437L; /** Type to define the behavior when engaging the borders of a column, i.e. the filter would need more data values than available. */ public static enum Mode { /** Ignore missing values. */ OMIT, /** Treat missing values as zero. */ ZERO, /** Repeat the last value. */ REPEAT, /** Mirror values at the last value. */ MIRROR, /** Repeat the data. */ CIRCULAR } /** Original data source. */ private final DataSource original; /** Columns that should be filtered. */ private final int[] cols; /** Data that was produced by the filter. */ private transient ArrayList rows; /** Mode for handling. */ private Mode mode; /** * Initializes a new instance with the specified data source, border * handling and columns to be filtered. The columns must be numeric, * otherwise an {@code IllegalArgumentException} is thrown. * @param original Data source to be filtered. * @param mode Border handling mode to be used. * @param cols Indexes of numeric columns to be filtered. */ @SuppressWarnings("unchecked") public Filter2D(DataSource original, Mode mode, int... cols) { this.rows = new ArrayList(original.getRowCount()); this.original = original; this.mode = mode; this.cols = Arrays.copyOf(cols, cols.length); // A sorted array is necessary for binary search Arrays.sort(this.cols); // Check if columns are numeric Class>[] originalColumnTypes = original.getColumnTypes(); for (int colIndex : this.cols) { if (!original.isColumnNumeric(colIndex)) { throw new IllegalArgumentException(MessageFormat.format( "Column {0,number,integer} isn't numeric and cannot be filtered.", //$NON-NLS-1$ colIndex)); } } Class>[] types = originalColumnTypes; for (int colIndex : this.cols) { types[colIndex] = Double.class; } setColumnTypes(types); this.original.addDataListener(this); dataUpdated(this.original); } /** * Returns the original data source that is filtered. * @return Original data source. */ protected DataSource getOriginal() { return original; } /** * Returns the value of the original data source at the specified column * and row. * @param col Column index. * @param row Row index. * @return Original value. */ protected Comparable getOriginal(int col, int row) { int rowLast = original.getRowCount() - 1; if (row < 0 || row > rowLast) { if (getMode() == Mode.OMIT) { return Double.NaN; } else if (getMode() == Mode.ZERO) { return 0.0; } else if (getMode() == Mode.REPEAT) { row = MathUtils.limit(row, 0, rowLast); } else if (getMode() == Mode.MIRROR) { int rem = Math.abs(row) / rowLast; int mod = Math.abs(row) % rowLast; if ((rem & 1) == 0) { row = mod; } else { row = rowLast - mod; } } else if (getMode() == Mode.CIRCULAR) { if (row >= 0) { row = row % (rowLast + 1); } else { row = (row + 1) % (rowLast + 1) + rowLast; } } } return original.get(col, row); } /** * Clears this Filter2D. */ protected void clear() { rows.clear(); } /** * Adds the specified row data to this Filter2D. * @param rowData Row data to be added. */ protected void add(Double[] rowData) { rows.add(rowData); } /** * Adds the specified row data to this Filter2D. * @param rowData Row to be added. */ protected void add(Number[] rowData) { Double[] doubleData = new Double[rowData.length]; int i = 0; for (Number value : rowData) { doubleData[i++] = value.doubleValue(); } rows.add(doubleData); } /** * Returns the row with the specified index. * @param col index of the column to return * @param row index of the row to return * @return the specified value of the data cell */ public Comparable get(int col, int row) { int colPos = getIndex(col); if (colPos < 0) { return original.get(col, row); } return rows.get(row)[colPos]; } /** * Sets a new value for a specified cell. * @param col Column of the cell. * @param row Row of the cell. * @param value New cell value. * @return The previous value before it has been changed. */ protected Number set(int col, int row, Double value) { int colPos = getIndex(col); if (colPos < 0) { throw new IllegalArgumentException( "Can't set value in unfiltered column."); //$NON-NLS-1$ } Double old = rows.get(row)[colPos]; rows.get(row)[colPos] = value; notifyDataUpdated(new DataChangeEvent(this, col, row, old, value)); return old; } @Override public int getColumnCount() { return original.getColumnCount(); } /** * Returns the number of filtered columns. * @return Number of filtered columns. */ protected int getColumnCountFiltered() { if (cols.length == 0) { return original.getColumnCount(); } return cols.length; } /** * Returns the number of rows of the data source. * @return number of rows in the data source. */ public int getRowCount() { return original.getRowCount(); } /** * Returns the number of filtered rows. * @return Number of filtered rows. */ protected int getRowCountFiltered() { return original.getRowCount(); } /** * Method that is invoked when data has been added. * This method is invoked by objects that provide support for * {@code DataListener}s and should not be called manually. * @param source Data source that has been changed. * @param events Optional event object describing the data values that * have been added. */ public void dataAdded(DataSource source, DataChangeEvent... events) { dataChanged(source, events); notifyDataAdded(events); } /** * Method that is invoked when data has been updated. * This method is invoked by objects that provide support for * {@code DataListener}s and should not be called manually. * @param source Data source that has been changed * @param events Optional event object describing the data values that * have been updated. */ public void dataUpdated(DataSource source, DataChangeEvent... events) { dataChanged(source, events); notifyDataUpdated(events); } /** * Method that is invoked when data has been removed. * This method is invoked by objects that provide support for * {@code DataListener}s and should not be called manually. * @param source Data source that has been changed * @param events Optional event object describing the data values that * have been removed. */ public void dataRemoved(DataSource source, DataChangeEvent... events) { dataChanged(source, events); notifyDataRemoved(events); } /** * Method that is invoked when data has been added, updated, or removed. * This method is invoked by objects that provide support for * {@code DataListener}s and should not be called manually. * @param source Data source that has been changed * @param events Optional event object describing the data values that * have been removed. */ private void dataChanged(DataSource source, DataChangeEvent... events) { filter(); } /** * Returns the index of the original column using the index of the * filtered column. * @param col Index of the filtered column * @return Index of the original column */ protected int getIndexOriginal(int col) { if (cols.length == 0) { return col; } return cols[col]; } /** * Returns the index of the filtered column using the index of the * original column. * @param col Index of the original column * @return Index of the filtered column */ protected int getIndex(int col) { if (cols.length == 0) { return col; } return Arrays.binarySearch(cols, col); } /** * Returns whether the specified column is filtered. * @param col Column index. * @return True, if the column is filtered. */ protected boolean isFiltered(int col) { return getIndex(col) >= 0; } /** * Invokes the filtering routine. */ protected abstract void filter(); /** * Returns the Mode of this Filter2D. * @return Mode of filtering. */ public Mode getMode() { return mode; } /** * Sets the Mode the specified value. * @param mode Mode of filtering. */ public void setMode(Mode mode) { this.mode = mode; dataUpdated(this); } /** * Custom deserialization method. * @param in Input stream. * @throws ClassNotFoundException if a serialized class doesn't exist anymore. * @throws IOException if there is an error while reading data from the * input stream. */ private void readObject(ObjectInputStream in) throws ClassNotFoundException, IOException { // Normal deserialization in.defaultReadObject(); // Handle transient fields rows = new ArrayList(); // Update caches original.addDataListener(this); } }

Ads help maintain this website.