org.swtchart/src/org/swtchart/internal/compress/Compress.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.compress;

import java.util.ArrayList;

public abstract class Compress implements ICompress {

    protected int previousXGridIndex;

    protected int previousYGridIndex;

    protected CompressConfig config;

    protected CompressConfig prevConfig;

    protected boolean compressed;

    protected double[] xSeries = null;

    protected double[] ySeries = null;

    protected transient double[] compressedXSeries = null;

    protected transient double[] compressedYSeries = null;

    protected transient int[] compressedIndexes = null;

    protected double xLower;

    protected double xUpper;

    protected double yLower;

    protected double yUpper;

    private boolean isXLogScale;

    private boolean isYLogScale;

    private long widthInPixel;

    private long heightInPixel;

    /*
     * @see ICompress#setXSeries(double[])
     */
    public void setXSeries(double[] xSeries) {
        if (xSeries == null) {
            return;
        }

        double[] copiedSeries = new double[xSeries.length];
        System.arraycopy(xSeries, 0, copiedSeries, 0, xSeries.length);

        this.xSeries = copiedSeries;
        compressedXSeries = copiedSeries;
        compressedIndexes = new int[xSeries.length];
        for (int i = 0; i < xSeries.length; i++) {
            compressedIndexes[i] = i;
        }

        compressed = false;
    }

    /*
     * @see ICompress#setYSeries(double[])
     */
    public void setYSeries(double[] ySeries) {
        if (ySeries == null) {
            return;
        }

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

        this.ySeries = copiedSeries;
        compressedYSeries = copiedSeries;

        compressed = false;
    }

    /*
     * @see ICompress#getCompressedXSeries()
     */
    public double[] getCompressedXSeries() {
        double[] copiedSeries = new double[compressedXSeries.length];
        System.arraycopy(compressedXSeries, 0, copiedSeries, 0,
                compressedXSeries.length);

        return copiedSeries;
    }

    /*
     * @see ICompress#getCompressedYSeries()
     */
    public double[] getCompressedYSeries() {
        double[] copiedSeries = new double[compressedYSeries.length];
        System.arraycopy(compressedYSeries, 0, copiedSeries, 0,
                compressedYSeries.length);

        return copiedSeries;
    }

    /*
     * @see ICompress#getCompressedIndexes()
     */
    public int[] getCompressedIndexes() {
        int[] copiedSeries = new int[compressedIndexes.length];
        System.arraycopy(compressedIndexes, 0, copiedSeries, 0,
                compressedIndexes.length);

        return copiedSeries;
    }

    /*
     * @see ICompress#compress(CompressConfig)
     */
    final public boolean compress(CompressConfig compressConfig) {

        if ((compressConfig.equals(prevConfig) && compressed)
                || xSeries == null || ySeries == null) {
            return false;
        }

        // store the previous configuration
        prevConfig = new CompressConfig(compressConfig);

        this.config = compressConfig;

        // store into fields to improve performance
        xLower = config.getXLowerValue();
        xUpper = config.getXUpperValue();
        yLower = config.getYLowerValue();
        yUpper = config.getYUpperValue();
        isXLogScale = config.isXLogScale();
        isYLogScale = config.isYLogScale();
        widthInPixel = config.getWidthInPixel();
        heightInPixel = config.getHeightInPixel();

        previousXGridIndex = -1;
        previousYGridIndex = -1;

        ArrayList<Double> xList = new ArrayList<Double>();
        ArrayList<Double> yList = new ArrayList<Double>();
        ArrayList<Integer> indexList = new ArrayList<Integer>();

        // add necessary plots to the array
        addNecessaryPlots(xList, yList, indexList);

        compressedXSeries = new double[xList.size()];
        compressedYSeries = new double[yList.size()];
        compressedIndexes = new int[indexList.size()];
        for (int i = 0; i < xList.size(); i++) {
            compressedXSeries[i] = xList.get(i);
            compressedYSeries[i] = yList.get(i);
            compressedIndexes[i] = indexList.get(i);
        }

        compressed = true;

        return true;
    }

    abstract protected void addNecessaryPlots(ArrayList<Double> xList,
            ArrayList<Double> yList, ArrayList<Integer> indexList);

    protected void addToList(ArrayList<Double> xList, ArrayList<Double> yList,
            ArrayList<Integer> indexList, double x, double y, int index) {
        xList.add(x);
        yList.add(y);
        indexList.add(index);
    }

    protected boolean isInSameGridAsPrevious(double x, double y) {
        int xGridIndex;
        int yGridIndex;

        // calculate the X grid index
        if (isXLogScale) {
            double lower = Math.log10(xLower);
            double upper = Math.log10(xUpper);
            xGridIndex = (int) ((Math.log10(x) - lower) / (upper - lower) * widthInPixel);
        } else {
            xGridIndex = (int) ((x - xLower) / (xUpper - xLower) * widthInPixel);
        }

        // calculate the Y grid index
        if (isYLogScale) {
            double lower = Math.log10(yLower);
            double upper = Math.log10(yUpper);
            yGridIndex = (int) ((Math.log10(y) - lower) / (upper - lower) * heightInPixel);
        } else {
            yGridIndex = (int) ((y - yLower) / (yUpper - yLower) * heightInPixel);
        }

        // check if the grid index is the same as previous
        boolean isInSameGridAsPrevious = (xGridIndex == previousXGridIndex && yGridIndex == previousYGridIndex);

        // store the previous grid index
        previousXGridIndex = xGridIndex;
        previousYGridIndex = yGridIndex;

        return isInSameGridAsPrevious;
    }
}

---