org.swtchart/src/org/swtchart/internal/series/Series.java

Go to the documentation of this file.

/*******************************************************************************
 * Copyright (c) 2008-2014 SWTChart project. All rights reserved.
 *
 * This code is distributed under the terms of the Eclipse Public License v1.0
 * which is available at http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.swtchart.internal.series;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Event;
import org.swtchart.Chart;
import org.swtchart.IAxis;
import org.swtchart.IDisposeListener;
import org.swtchart.IErrorBar;
import org.swtchart.ISeries;
import org.swtchart.ISeriesLabel;
import org.swtchart.Range;
import org.swtchart.IAxis.Direction;
import org.swtchart.internal.axis.Axis;
import org.swtchart.internal.compress.ICompress;

abstract public class Series implements ISeries {

    protected static final SeriesType DEFAULT_SERIES_TYPE = SeriesType.LINE;

    protected double[] xSeries;

    protected double[] ySeries;

    protected double minX;

    protected double maxX;

    protected double minY;

    protected double maxY;

    protected String id;

    protected ICompress compressor;

    protected int xAxisId;

    protected int yAxisId;

    protected boolean visible;

    protected boolean isXMonotoneIncreasing;

    protected SeriesType type;

    protected SeriesLabel seriesLabel;

    protected ErrorBar xErrorBar;

    protected ErrorBar yErrorBar;

    protected Chart chart;

    protected boolean stackEnabled;

    protected double[] stackSeries;

    private boolean isDateSeries;

    private boolean visibleInLegend;

    private String description;

    private List<IDisposeListener> listeners;

    protected Series(Chart chart, String id) {
        super();

        this.chart = chart;
        this.id = id;
        xAxisId = 0;
        yAxisId = 0;
        visible = true;
        type = DEFAULT_SERIES_TYPE;
        stackEnabled = false;
        isXMonotoneIncreasing = true;
        seriesLabel = new SeriesLabel();
        xErrorBar = new ErrorBar();
        yErrorBar = new ErrorBar();
        visibleInLegend = true;
        listeners = new ArrayList<IDisposeListener>();
        xSeries = new double[0];
        ySeries = new double[0];
    }

    /*
     * @see ISeries#getId()
     */
    public String getId() {
        return id;
    }

    /*
     * @see ISeries#setVisible(boolean)
     */
    public void setVisible(boolean visible) {
        if (this.visible == visible) {
            return;
        }

        this.visible = visible;

        ((SeriesSet) chart.getSeriesSet()).updateStackAndRiserData();
    }

    /*
     * @see ISeries#isVisible()
     */
    public boolean isVisible() {
        return visible;
    }

    /*
     * @see ISeries#getType()
     */
    public SeriesType getType() {
        return type;
    }

    /*
     * @see ISeries#isStackEnabled()
     */
    public boolean isStackEnabled() {
        return stackEnabled;
    }

    /*
     * @see ISeries#enableStack(boolean)
     */
    public void enableStack(boolean enabled) {
        if (enabled && minY < 0) {
            throw new IllegalStateException(
                    "Stacked series cannot contain minus values.");
        }

        if (stackEnabled == enabled) {
            return;
        }

        stackEnabled = enabled;

        ((SeriesSet) chart.getSeriesSet()).updateStackAndRiserData();
    }

    /*
     * @see ISeries#setXSeries(double[])
     */
    public void setXSeries(double[] series) {

        if (series == null) {
            SWT.error(SWT.ERROR_NULL_ARGUMENT);
            return; // to suppress warning...
        }

        xSeries = new double[series.length];
        System.arraycopy(series, 0, xSeries, 0, series.length);
        isDateSeries = false;

        if (xSeries.length == 0) {
            return;
        }

        // find the min and max value of x series
        minX = xSeries[0];
        maxX = xSeries[0];
        for (int i = 1; i < xSeries.length; i++) {
            if (minX > xSeries[i]) {
                minX = xSeries[i];
            }
            if (maxX < xSeries[i]) {
                maxX = xSeries[i];
            }

            if (xSeries[i - 1] > xSeries[i]) {
                isXMonotoneIncreasing = false;
            }
        }

        setCompressor();

        compressor.setXSeries(xSeries);
        compressor.setYSeries(ySeries);

        if (minX <= 0) {
            IAxis axis = chart.getAxisSet().getXAxis(xAxisId);
            if (axis != null) {
                axis.enableLogScale(false);
            }
        }
    }

    /*
     * @see ISeries#getXSeries()
     */
    public double[] getXSeries() {
        double[] copiedSeries = new double[xSeries.length];
        System.arraycopy(xSeries, 0, copiedSeries, 0, xSeries.length);

        return copiedSeries;
    }

    /*
     * @see ISeries#setYSeries(double[])
     */
    public void setYSeries(double[] series) {

        if (series == null) {
            SWT.error(SWT.ERROR_NULL_ARGUMENT);
            return; // to suppress warning...
        }

        ySeries = new double[series.length];
        System.arraycopy(series, 0, ySeries, 0, series.length);

        if (ySeries.length == 0) {
            return;
        }

        // find the min and max value of y series
        minY = Double.MAX_VALUE;
        maxY = Double.MIN_VALUE;
        for (int i = 0; i < ySeries.length; i++) {
            if (isInvalidSeries(ySeries[i]))
                continue;
            if (minY > ySeries[i]) {
                minY = ySeries[i];
            }
            if (maxY < ySeries[i]) {
                maxY = ySeries[i];
            }
        }

        if (xSeries.length != series.length) {
            xSeries = new double[series.length];
            for (int i = 0; i < series.length; i++) {
                xSeries[i] = i;
            }
            minX = xSeries[0];
            maxX = xSeries[xSeries.length - 1];
            isXMonotoneIncreasing = true;
        }

        setCompressor();

        compressor.setXSeries(xSeries);
        compressor.setYSeries(ySeries);

        if (minX <= 0) {
            IAxis axis = chart.getAxisSet().getXAxis(xAxisId);
            if (axis != null) {
                axis.enableLogScale(false);
            }
        }
        if (minY <= 0) {
            IAxis axis = chart.getAxisSet().getYAxis(yAxisId);
            if (axis != null) {
                axis.enableLogScale(false);
            }
            stackEnabled = false;
        }
    }

    /*
     * @see ISeries#getYSeries()
     */
    public double[] getYSeries() {
        double[] copiedSeries = new double[ySeries.length];
        System.arraycopy(ySeries, 0, copiedSeries, 0, ySeries.length);

        return copiedSeries;
    }

    /*
     * @see ISeries#setXDateSeries(Date[])
     */
    public void setXDateSeries(Date[] series) {
        if (series == null) {
            SWT.error(SWT.ERROR_NULL_ARGUMENT);
            return; // to suppress warning...
        }

        double[] xDateSeries = new double[series.length];
        for (int i = 0; i < series.length; i++) {
            xDateSeries[i] = series[i].getTime();
        }
        setXSeries(xDateSeries);
        isDateSeries = true;
    }

    /*
     * @see ISeries#getXDateSeries()
     */
    public Date[] getXDateSeries() {
        if (!isDateSeries) {
            return new Date[0];
        }

        Date[] series = new Date[xSeries.length];
        for (int i = 0; i < series.length; i++) {
            series[i] = new Date((long) xSeries[i]);
        }
        return series;
    }

    public boolean isDateSeries() {
        return isDateSeries;
    }

    public boolean isValidStackSeries() {
        return stackEnabled
                && stackSeries != null
                && stackSeries.length > 0
                && !chart.getAxisSet().getYAxis(yAxisId).isLogScaleEnabled()
                && ((Axis) chart.getAxisSet().getXAxis(xAxisId))
                        .isValidCategoryAxis();
    }

    public Range getXRange() {
        return new Range(minX, maxX);
    }

    abstract public Range getAdjustedRange(Axis axis, int length);

    public Range getYRange() {
        double min = minY;
        double max = maxY;
        Axis xAxis = (Axis) chart.getAxisSet().getXAxis(xAxisId);
        if (isValidStackSeries() && xAxis.isValidCategoryAxis()) {
            for (int i = 0; i < stackSeries.length; i++) {
                if (max < stackSeries[i]) {
                    max = stackSeries[i];
                }
            }
        }
        return new Range(min, max);
    }

    protected ICompress getCompressor() {
        return compressor;
    }

    abstract protected void setCompressor();

    /*
     * @see ISeries#getXAxisId()
     */
    public int getXAxisId() {
        return xAxisId;
    }

    /*
     * @see ISeries#setXAxisId(int)
     */
    public void setXAxisId(int id) {
        if (xAxisId == id) {
            return;
        }

        IAxis axis = chart.getAxisSet().getXAxis(xAxisId);

        if (minX <= 0 && axis != null && axis.isLogScaleEnabled()) {
            chart.getAxisSet().getXAxis(xAxisId).enableLogScale(false);
        }

        xAxisId = id;

        ((SeriesSet) chart.getSeriesSet()).updateStackAndRiserData();
    }

    /*
     * @see ISeries#getYAxisId()
     */
    public int getYAxisId() {
        return yAxisId;
    }

    /*
     * @see ISeries#setYAxisId(int)
     */
    public void setYAxisId(int id) {
        yAxisId = id;
    }

    /*
     * @see ISeries#getLabel()
     */
    public ISeriesLabel getLabel() {
        return seriesLabel;
    }

    /*
     * @see ISeries#getXErrorBar()
     */
    public IErrorBar getXErrorBar() {
        return xErrorBar;
    }

    /*
     * @see ISeries#getYErrorBar()
     */
    public IErrorBar getYErrorBar() {
        return yErrorBar;
    }

    protected void setStackSeries(double[] stackSeries) {
        this.stackSeries = stackSeries;
    }

    /*
     * @see ISeries#getPixelCoordinates(int)
     */
    public Point getPixelCoordinates(int index) {

        // get the horizontal and vertical axes
        IAxis hAxis;
        IAxis vAxis;
        if (chart.getOrientation() == SWT.HORIZONTAL) {
            hAxis = chart.getAxisSet().getXAxis(xAxisId);
            vAxis = chart.getAxisSet().getYAxis(yAxisId);
        } else if (chart.getOrientation() == SWT.VERTICAL) {
            hAxis = chart.getAxisSet().getYAxis(yAxisId);
            vAxis = chart.getAxisSet().getXAxis(xAxisId);
        } else {
            throw new IllegalStateException("unknown chart orientation"); //$NON-NLS-1$
        }

        // get the pixel coordinates
        return new Point(getPixelCoordinate(hAxis, index), getPixelCoordinate(
                vAxis, index));
    }

    private int getPixelCoordinate(IAxis axis, int index) {

        // get the data coordinate
        double dataCoordinate;
        if (axis.getDirection() == Direction.X) {
            if (axis.isCategoryEnabled()) {
                dataCoordinate = index;
            } else {
                if (index < 0 || xSeries.length <= index) {
                    throw new IllegalArgumentException(
                            "Series index is out of range."); //$NON-NLS-1$
                }
                dataCoordinate = xSeries[index];
            }
        } else if (axis.getDirection() == Direction.Y) {
            if (isValidStackSeries()) {
                if (index < 0 || stackSeries.length <= index) {
                    throw new IllegalArgumentException(
                            "Series index is out of range."); //$NON-NLS-1$
                }
                dataCoordinate = stackSeries[index];
            } else {
                if (index < 0 || ySeries.length <= index) {
                    throw new IllegalArgumentException(
                            "Series index is out of range."); //$NON-NLS-1$
                }
                dataCoordinate = ySeries[index];
            }
        } else {
            throw new IllegalStateException("unknown axis direction"); //$NON-NLS-1$
        }

        // get the pixel coordinate
        return axis.getPixelCoordinate(dataCoordinate);
    }

    protected Range getRangeWithMargin(int lowerPlotMargin,
            int upperPlotMargin, int length, Axis axis, Range range) {
        if (length == 0) {
            return range;
        }

        int lowerPixelCoordinate = axis.getPixelCoordinate(range.lower,
                range.lower, range.upper)
                + lowerPlotMargin
                * (axis.isHorizontalAxis() ? -1 : 1);
        int upperPixelCoordinate = axis.getPixelCoordinate(range.upper,
                range.lower, range.upper)
                + upperPlotMargin
                * (axis.isHorizontalAxis() ? 1 : -1);

        double lower = axis.getDataCoordinate(lowerPixelCoordinate,
                range.lower, range.upper);
        double upper = axis.getDataCoordinate(upperPixelCoordinate,
                range.lower, range.upper);

        return new Range(lower, upper);
    }

    /*
     * @see ISeries#setVisibleInLegend(boolean)
     */
    public void setVisibleInLegend(boolean visible) {
        visibleInLegend = visible;
    }

    /*
     * @see ISeries#isVisibleInLegend()
     */
    public boolean isVisibleInLegend() {
        return visibleInLegend;
    }

    /*
     * @see ISeries#setDescription(String)
     */
    public void setDescription(String description) {
        this.description = description;
    }

    /*
     * @see ISeries#getDescription()
     */
    public String getDescription() {
        return description;
    }

    protected void dispose() {
        for (IDisposeListener listener : listeners) {
            listener.disposed(new Event());
        }
    }

    /*
     * @see IAxis#addDisposeListener(IDisposeListener)
     */
    public void addDisposeListener(IDisposeListener listener) {
        listeners.add(listener);
    }

    public void draw(GC gc, int width, int height) {

        if (!visible || width < 0 || height < 0 || xSeries.length == 0
                || ySeries.length == 0) {
            return;
        }

        Axis xAxis = (Axis) chart.getAxisSet().getXAxis(getXAxisId());
        Axis yAxis = (Axis) chart.getAxisSet().getYAxis(getYAxisId());
        if (xAxis == null || yAxis == null) {
            return;
        }

        draw(gc, width, height, xAxis, yAxis);
    }
    
    static protected boolean isInvalidSeries(double value) {
        return Double.isNaN(value);
    }

    abstract protected void draw(GC gc, int width, int height, Axis xAxis,
            Axis yAxis);
}

---