Example usage for org.jfree.data Range Range

List of usage examples for org.jfree.data Range Range

  1. HOME
  2. Java
  3. org.jfree
  4. org.jfree.data.*
  5. Range
  6. Range

Introduction

In this page you can find the example usage for org.jfree.data Range Range.

Prototype

public Range(double lower, double upper)

Source Link

Document

Creates a new range.

Usage

From source file:de.bund.bfr.knime.nls.chart.ChartCreator.java

public JFreeChart createChart() throws ParseException {
    if (varX == null || varY == null) {
        return new JFreeChart(null, JFreeChart.DEFAULT_TITLE_FONT, new XYPlot(), showLegend);
    }/*  ww w. j a v  a2  s.  c  o  m*/

    List<String> idsToPaint;

    if (selectAll) {
        idsToPaint = new ArrayList<>(plotables.keySet());
    } else {
        idsToPaint = selectedIds;
    }

    NumberAxis xAxis = new NumberAxis(transformX.getName(varX));
    NumberAxis yAxis = new NumberAxis(transformY.getName(varY));
    XYPlot plot = new XYPlot(null, xAxis, yAxis, null);
    double usedMinX = Double.POSITIVE_INFINITY;
    double usedMaxX = Double.NEGATIVE_INFINITY;
    int index = 0;
    List<Color> defaultColors = ChartUtils.createColorList(idsToPaint.size());
    List<NamedShape> defaultShapes = ChartUtils.createShapeList(idsToPaint.size());

    for (String id : idsToPaint) {
        Plotable plotable = plotables.get(id);

        if (plotable == null) {
            continue;
        }

        if (plotable.isDataType()) {
            double[][] points = plotable.getDataPoints(varX, varY, transformX, transformY);

            if (points != null) {
                for (int i = 0; i < points[0].length; i++) {
                    usedMinX = Math.min(usedMinX, points[0][i]);
                    usedMaxX = Math.max(usedMaxX, points[0][i]);
                }
            }
        }

        if (plotable.isParamType()) {
            double minArg = transformX.to(MathUtils.nullToNan(plotable.getMinValues().get(varX)));
            double maxArg = transformX.to(MathUtils.nullToNan(plotable.getMaxValues().get(varX)));

            if (Double.isFinite(minArg)) {
                usedMinX = Math.min(usedMinX, minArg);
            }

            if (Double.isFinite(maxArg)) {
                usedMaxX = Math.max(usedMaxX, maxArg);
            }
        }
    }

    if (!Double.isFinite(usedMinX)) {
        usedMinX = 0.0;
    }

    if (!Double.isFinite(usedMaxX)) {
        usedMaxX = 100.0;
    }

    xAxis.setAutoRangeIncludesZero(false);
    yAxis.setAutoRangeIncludesZero(false);

    if (usedMinX == usedMaxX) {
        usedMinX -= 1.0;
        usedMaxX += 1.0;
    }

    if (useManualRange && minX < maxX && minY < maxY) {
        usedMinX = minX;
        usedMaxX = maxX;
        xAxis.setRange(new Range(minX, maxX));
        yAxis.setRange(new Range(minY, maxY));
    }

    for (String id : idsToPaint) {
        Plotable plotable = plotables.get(id);

        if (plotable == null) {
            continue;
        }

        plotable.setFunctionSteps(resolution);
        plotable.setInterpolator(interpolator);

        switch (plotable.getType()) {
        case DATA:
            plotData(plot, plotable, id, defaultColors.get(index), defaultShapes.get(index));
            break;
        case FUNCTION:
            plotFunction(plot, plotable, id, defaultColors.get(index), defaultShapes.get(index), usedMinX,
                    usedMaxX);
            break;
        case DATA_FUNCTION:
            plotDataFunction(plot, plotable, id, defaultColors.get(index), defaultShapes.get(index), usedMinX,
                    usedMaxX);
            break;
        case DIFF:
            plotDiff(plot, plotable, id, defaultColors.get(index), defaultShapes.get(index), usedMinX,
                    usedMaxX);
            break;
        case DATA_DIFF:
            plotDataDiff(plot, plotable, id, defaultColors.get(index), defaultShapes.get(index), usedMinX,
                    usedMaxX);
            break;
        default:
            throw new RuntimeException("Unknown type of plotable: " + plotable.getType());
        }

        index++;
    }

    if (minToZero && !useManualRange) {
        Range xRange = xAxis.getRange();
        Range yRange = yAxis.getRange();

        if (xRange.getUpperBound() <= 0.0 || yRange.getUpperBound() <= 0.0) {
            return null;
        }

        xAxis.setRange(new Range(0.0, xRange.getUpperBound()));
        yAxis.setRange(new Range(0.0, yRange.getUpperBound()));
    }

    return new JFreeChart(null, JFreeChart.DEFAULT_TITLE_FONT, plot, showLegend);
}

From source file:it.eng.spagobi.engines.chart.bo.charttypes.targetcharts.WinLose.java

@Override
public JFreeChart createChart(DatasetMap datasets) {
    logger.debug("IN");
    DefaultCategoryDataset dataset = (DefaultCategoryDataset) datasets.getDatasets().get("1");

    JFreeChart chart = ChartFactory.createBarChart(name, null, null, dataset, PlotOrientation.VERTICAL, legend,
            false, false);/*from w w w. ja  va 2 s  .  co  m*/
    chart.setBorderVisible(false);
    chart.setBackgroundPaint(color);

    TextTitle title = setStyleTitle(name, styleTitle);
    chart.setTitle(title);
    if (subName != null && !subName.equals("")) {
        TextTitle subTitle = setStyleTitle(subName, styleSubTitle);
        chart.addSubtitle(subTitle);
    }

    CategoryPlot plot = chart.getCategoryPlot();
    plot.setOutlineVisible(false);
    plot.setInsets(new RectangleInsets(0.0, 0.0, 0.0, 0.0));
    plot.setBackgroundPaint(color);
    plot.setDomainGridlinesVisible(false);
    plot.setRangeGridlinesVisible(false);
    plot.setRangeCrosshairVisible(true);
    plot.setRangeCrosshairStroke(new BasicStroke(1f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
    plot.setRangeCrosshairPaint(color.BLACK);

    // customize axes 
    CategoryAxis domainAxis = plot.getDomainAxis();
    domainAxis.setVisible(false);
    domainAxis.setCategoryMargin(0.2);

    NumberAxis rangeAxis = (NumberAxis) plot.getRangeAxis();
    rangeAxis.setVisible(false);
    rangeAxis.setRange(new Range(-(barHeight + 0.2), (barHeight + 0.2)));

    // customize renderer 
    MyBarRendererThresholdPaint renderer = new MyBarRendererThresholdPaint(useTargets, thresholds, dataset,
            timeSeries, nullValues, bottomThreshold, color);

    if (wlt_mode.doubleValue() == 0) {
        renderer.setBaseItemLabelsVisible(Boolean.FALSE, true);
    } else {
        renderer.setBaseItemLabelsVisible(Boolean.TRUE, true);
        renderer.setBaseItemLabelFont(
                new Font(styleValueLabels.getFontName(), Font.PLAIN, styleValueLabels.getSize()));
        renderer.setBaseItemLabelPaint(styleValueLabels.getColor());
        renderer.setBaseItemLabelGenerator(
                new StandardCategoryItemLabelGenerator("{2}", new DecimalFormat("0.#")) {
                    public String generateLabel(CategoryDataset dataset, int row, int column) {
                        if (dataset.getValue(row, column) == null
                                || dataset.getValue(row, column).doubleValue() == 0)
                            return "";
                        String columnKey = (String) dataset.getColumnKey(column);
                        int separator = columnKey.indexOf('-');
                        String month = columnKey.substring(0, separator);
                        String year = columnKey.substring(separator + 1);
                        int monthNum = Integer.parseInt(month);
                        if (wlt_mode.doubleValue() >= 1 && wlt_mode.doubleValue() <= 4) {
                            if (wlt_mode.doubleValue() == 2 && column % 2 == 0)
                                return "";

                            Calendar calendar = Calendar.getInstance();
                            calendar.set(Calendar.MONTH, monthNum - 1);
                            SimpleDateFormat dataFormat = new SimpleDateFormat("MMM");
                            return dataFormat.format(calendar.getTime());
                        } else
                            return "" + monthNum;
                    }
                });
    }

    if (wlt_mode.doubleValue() == 3) {
        renderer.setBasePositiveItemLabelPosition(new ItemLabelPosition(ItemLabelAnchor.OUTSIDE12,
                org.jfree.ui.TextAnchor.BOTTOM_CENTER, org.jfree.ui.TextAnchor.BOTTOM_RIGHT, Math.PI / 2));
        renderer.setBaseNegativeItemLabelPosition(new ItemLabelPosition(ItemLabelAnchor.OUTSIDE6,
                org.jfree.ui.TextAnchor.TOP_CENTER, org.jfree.ui.TextAnchor.HALF_ASCENT_LEFT, Math.PI / 2));

    } else if (wlt_mode.doubleValue() == 4 || wlt_mode.doubleValue() == 5) {
        renderer.setBasePositiveItemLabelPosition(new ItemLabelPosition(ItemLabelAnchor.OUTSIDE12,
                org.jfree.ui.TextAnchor.BOTTOM_CENTER, org.jfree.ui.TextAnchor.BOTTOM_RIGHT, Math.PI / 4));
        renderer.setBaseNegativeItemLabelPosition(new ItemLabelPosition(ItemLabelAnchor.OUTSIDE6,
                org.jfree.ui.TextAnchor.TOP_CENTER, org.jfree.ui.TextAnchor.HALF_ASCENT_LEFT, Math.PI / 4));
    }

    if (legend == true) {
        LegendItemCollection collection = createThresholdLegend(plot);
        plot.setFixedLegendItems(collection);
    }

    if (maxBarWidth != null) {
        renderer.setMaximumBarWidth(maxBarWidth);
    }
    //renderer.setSeriesPaint(0, Color.BLUE); 
    plot.setRenderer(renderer);

    logger.debug("OUT");
    if (mainThreshold == null)
        return null;
    return chart;

}

From source file:org.jfree.data.statistics.DefaultStatisticalCategoryDatasetTest.java

/**
 * Some checks for the getRangeBounds() method.
 *//*from  w w  w.j  a v a  2s . c  o  m*/
@Test
public void testGetRangeBounds2() {
    DefaultStatisticalCategoryDataset d1 = new DefaultStatisticalCategoryDataset();
    d1.add(1.0, 2.0, "R1", "C1");
    assertEquals(new Range(1.0, 1.0), d1.getRangeBounds(false));
    assertEquals(new Range(-1.0, 3.0), d1.getRangeBounds(true));

    d1.add(10.0, 20.0, "R1", "C1");
    assertEquals(new Range(10.0, 10.0), d1.getRangeBounds(false));
    assertEquals(new Range(-10.0, 30.0), d1.getRangeBounds(true));
}

From source file:ec.ui.view.res.ResidualsView.java

private Range calcRange(double[] values) {
    double min = Double.NEGATIVE_INFINITY, max = -Double.POSITIVE_INFINITY;

    DescriptiveStatistics stats = new DescriptiveStatistics(new DataBlock(values));
    double smin = stats.getMin(), smax = stats.getMax();
    if (Double.isInfinite(min) || smin < min) {
        min = smin;//from w  w  w .  jav a  2 s .c  o m
    }
    if (Double.isInfinite(max) || smax > max) {
        max = smax;
    }

    if (Double.isInfinite(max) || Double.isInfinite(min)) {
        return new Range(0, 1);
    }
    double length = max - min;
    if (length == 0) {
        return new Range(0, 1);
    } else {
        //double eps = length * .05;
        //return new Range(min - eps, max + eps);
        return new Range(min, max);
    }
}

From source file:de.uniol.ui.tsv.ui.LineChartDialog.java

/**
 * @return the resulting chart object//from ww  w.ja  va2s  .c  o  m
 */
protected JFreeChart createChart() {
    JFreeChart chart = ChartFactory.createTimeSeriesChartFast(title, xTitle, yTitle, xy, true, false, false);

    chart.setBackgroundPaint(Color.white);
    chart.getLegend().setBackgroundPaint(new Color(224, 224, 224));

    FastXYPlot plot = (FastXYPlot) chart.getPlot();
    //      plot.setBackgroundPaint(new Color(224, 224, 224));
    plot.setBackgroundPaint(new Color(77, 77, 77));
    plot.setDomainGridlinePaint(Color.lightGray);
    plot.setRangeGridlinePaint(Color.lightGray);
    plot.setAxisOffset(new RectangleInsets(5.0, 5.0, 5.0, 5.0));
    StandardXYItemRendererFast r = new StandardXYItemRendererFast(StandardXYItemRendererFast.LINES, null, null);
    plot.setRenderer(r);

    for (int i : seriesStrokes.keySet()) {
        r.setSeriesStroke(i, seriesStrokes.get(i));
    }
    for (int i : seriesColors.keySet()) {
        r.setSeriesPaint(i, seriesColors.get(i));
    }

    DateAxis da = new DateAxis(xTitle);
    if (useRelativeHourFormat) {
        da.setDateFormatOverride(new RelativeHourFormat());
    }
    da.setLowerMargin(0.03);
    plot.setDomainAxis(da);

    if (minRange != 0.0 && maxRange != 0.0) {
        ValueAxis yaxis = plot.getRangeAxis();
        yaxis.setRange(new Range(minRange, maxRange));
    }

    return chart;
}

From source file:br.ufrgs.enq.jcosmo.test.VLEdiagramsGAMESS.java

public JPanel calcAcAcidOctanol() throws Exception {
    double T = 293.15;
    setLayout(new BorderLayout());

    COSMOSACDataBase db = COSMOSACDataBase.getInstance();
    COSMOSACCompound c1 = db.getComp("acetic-acid");
    COSMOSACCompound c2 = db.getComp("1-octanol");

    double[] cavityVolume = new double[2];
    cavityVolume[0] = c1.Vcosmo;/*from   www.  ja  v a 2  s  .  com*/
    cavityVolume[1] = c2.Vcosmo;

    double[][] sigma = new double[2][];

    sigma[0] = c1.sigma;
    sigma[1] = c2.sigma;

    SigmaProfileGenerator c1Sigma = new SigmaProfileGenerator(SigmaProfileGenerator.FileType.GAMESS,
            c1.name.toLowerCase() + ".log");
    SigmaProfileGenerator c2Sigma = new SigmaProfileGenerator(SigmaProfileGenerator.FileType.GAMESS,
            c2.name.toLowerCase() + ".log");
    sigma[0] = c1Sigma.getSigmaProfile();
    sigma[1] = c2Sigma.getSigmaProfile();

    COSMOSAC cosmosac = new COSMOSAC();
    cosmosac.setParameters(cavityVolume, c1.charge, sigma);
    cosmosac.setIgnoreSG(true);
    cosmosac.setSigmaHB(COSMOSAC.SIGMAHB * 1.2);

    cosmosac.setTemperature(T);

    double[] x1 = new double[n];
    double[] x2 = new double[n];
    double[] gamma1 = new double[n];
    double[] gamma2 = new double[n];
    double[] z = new double[2];
    double[] lnGamma = new double[2];
    z[0] = 0.00;
    int j = 0;
    while (z[0] < 1.0001) {
        z[1] = 1 - z[0];
        x1[j] = z[0];
        x2[j] = z[1];
        cosmosac.setComposition(z);
        cosmosac.activityCoefficient(lnGamma);
        gamma1[j] = Math.exp(lnGamma[0]);
        gamma2[j] = Math.exp(lnGamma[1]);
        z[0] += 0.05;
        j++;
    }

    double[] Psat = new double[2];
    Psat[0] = 1600;
    Psat[1] = 10;
    double[] P = calcPx(x1, x2, gamma1, gamma2, Psat);
    double[] y1 = calcY(x1, gamma1, Psat, P);

    XYPlot plot1;
    XYSeriesCollection dataset = new XYSeriesCollection();
    XYSeries liq = new XYSeries("liquid");
    XYSeries vap = new XYSeries("vapor");
    XYSeries raoult = new XYSeries("Raoult's Law");
    for (int i = 0; i < n; i++) {
        liq.add(x1[i], P[i]);
        vap.add(y1[i], P[i]);
    }
    raoult.add(0, Psat[1]);
    raoult.add(1, Psat[0]);
    dataset.addSeries(liq);
    dataset.addSeries(vap);
    dataset.addSeries(raoult);

    JFreeChart chart = ChartFactory.createXYLineChart(null, "Mole Fraction: x1, y1", "P/KPa", null,
            PlotOrientation.VERTICAL, true, true, false);
    plot1 = (XYPlot) chart.getPlot();
    plot1.getDomainAxis().setRange(new Range(0.0, 1.0));

    plot1.setDataset(dataset);

    ChartPanel chartPanel = new ChartPanel(chart);
    JPanel jp1 = new JPanel(new BorderLayout());
    jp1.add(chartPanel);

    add(jp1, BorderLayout.CENTER);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setSize(400, 500);

    return jp1;
}

From source file:it.eng.spagobi.engines.chart.bo.charttypes.targetcharts.SparkLine.java

@Override
public JFreeChart createChart(DatasetMap datasets) {
    logger.debug("IN");
    XYDataset dataset = (XYDataset) datasets.getDatasets().get("1");

    final JFreeChart sparkLineGraph = ChartFactory.createTimeSeriesChart(null, null, null, dataset, legend,
            false, false);/*from  ww w . j a  v a 2 s  .c  o m*/
    sparkLineGraph.setBackgroundPaint(color);

    TextTitle title = setStyleTitle(name, styleTitle);
    sparkLineGraph.setTitle(title);
    if (subName != null && !subName.equals("")) {
        TextTitle subTitle = setStyleTitle(subName, styleSubTitle);
        sparkLineGraph.addSubtitle(subTitle);
    }

    sparkLineGraph.setBorderVisible(false);
    sparkLineGraph.setBorderPaint(Color.BLACK);
    XYPlot plot = sparkLineGraph.getXYPlot();
    plot.setOutlineVisible(false);
    plot.setInsets(new RectangleInsets(0.0, 0.0, 0.0, 0.0));
    plot.setBackgroundPaint(null);
    plot.setDomainGridlinesVisible(false);
    plot.setDomainCrosshairVisible(false);
    plot.setRangeGridlinesVisible(false);
    plot.setRangeCrosshairVisible(false);
    plot.setBackgroundPaint(color);

    // calculate the last marker color
    Paint colorLast = getLastPointColor();

    // Calculate average, minimum and maximum to draw plot borders.
    boolean isFirst = true;
    double avg = 0, min = Double.POSITIVE_INFINITY, max = Double.NEGATIVE_INFINITY;
    int count = 0;
    for (int i = 0; i < timeSeries.getItemCount(); i++) {
        if (timeSeries.getValue(i) != null) {
            count++;
            if (isFirst) {
                min = timeSeries.getValue(i).doubleValue();
                max = timeSeries.getValue(i).doubleValue();
                isFirst = false;
            }
            double n = timeSeries.getValue(i).doubleValue();
            //calculate avg, min, max
            avg += n;
            if (n < min)
                min = n;
            if (n > max)
                max = n;
        }
    }
    // average
    avg = avg / (double) count;

    // calculate min and max between thresholds!
    boolean isFirst2 = true;
    double lb = 0, ub = 0;
    for (Iterator iterator = thresholds.keySet().iterator(); iterator.hasNext();) {
        Double thres = (Double) iterator.next();
        if (isFirst2 == true) {
            ub = thres.doubleValue();
            lb = thres.doubleValue();
            isFirst2 = false;
        }
        if (thres.doubleValue() > ub)
            ub = thres.doubleValue();
        if (thres.doubleValue() < lb)
            lb = thres.doubleValue();
    }

    plot.getRangeAxis().setRange(new Range(Math.min(lb, min - 2), Math.max(ub, max + 2) + 2));

    addMarker(1, avg, Color.GRAY, 0.8f, plot);
    //addAvaregeSeries(series, plot);
    addPointSeries(timeSeries, plot);

    int num = 3;
    for (Iterator iterator = thresholds.keySet().iterator(); iterator.hasNext();) {
        Double thres = (Double) iterator.next();
        TargetThreshold targThres = thresholds.get(thres);
        Color color = Color.WHITE;
        if (targThres != null && targThres.getColor() != null) {
            color = targThres.getColor();
        }
        if (targThres.isVisible()) {
            addMarker(num++, thres.doubleValue(), color, 0.5f, plot);
        }
    }

    ValueAxis domainAxis = plot.getDomainAxis();
    domainAxis.setVisible(false);
    domainAxis.setUpperMargin(0.2);
    NumberAxis rangeAxis = (NumberAxis) plot.getRangeAxis();
    rangeAxis.setVisible(false);

    plot.getRenderer().setSeriesPaint(0, Color.BLACK);
    XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(true, false) {
        public boolean getItemShapeVisible(int _series, int item) {
            TimeSeriesDataItem tsdi = timeSeries.getDataItem(item);
            if (tsdi == null)
                return false;
            Month period = (Month) tsdi.getPeriod();
            int currMonth = period.getMonth();
            int currYear = period.getYearValue();
            int lastMonthFilled = lastMonth.getMonth();
            int lastYearFilled = lastMonth.getYearValue();
            boolean isLast = false;
            if (currYear == lastYearFilled && currMonth == lastMonthFilled) {
                isLast = true;
            }
            return isLast;
        }
    };
    renderer.setSeriesPaint(0, Color.decode("0x000000"));

    renderer.setBaseShapesVisible(true);
    renderer.setBaseShapesFilled(true);
    renderer.setDrawOutlines(true);
    renderer.setUseFillPaint(true);
    renderer.setBaseFillPaint(colorLast);
    renderer.setBaseOutlinePaint(Color.BLACK);
    renderer.setUseOutlinePaint(true);
    renderer.setSeriesShape(0, new Ellipse2D.Double(-4.0, -4.0, 8.0, 8.0));

    if (wlt_mode.doubleValue() == 0) {
        renderer.setBaseItemLabelsVisible(Boolean.FALSE, true);
    } else {
        renderer.setBaseItemLabelsVisible(Boolean.TRUE, true);
        renderer.setBaseItemLabelFont(
                new Font(styleValueLabels.getFontName(), Font.PLAIN, styleValueLabels.getSize()));
        renderer.setBaseItemLabelPaint(styleValueLabels.getColor());
        renderer.setBaseItemLabelGenerator(new StandardXYItemLabelGenerator("{2}", new DecimalFormat("0.###"),
                new DecimalFormat("0.###")) {
            public String generateLabel(CategoryDataset dataset, int row, int column) {
                if (dataset.getValue(row, column) == null || dataset.getValue(row, column).doubleValue() == 0)
                    return "";
                String columnKey = (String) dataset.getColumnKey(column);
                int separator = columnKey.indexOf('-');
                String month = columnKey.substring(0, separator);
                String year = columnKey.substring(separator + 1);
                int monthNum = Integer.parseInt(month);
                if (wlt_mode.doubleValue() >= 1 && wlt_mode.doubleValue() <= 4) {
                    if (wlt_mode.doubleValue() == 2 && column % 2 == 0)
                        return "";

                    Calendar calendar = Calendar.getInstance();
                    calendar.set(Calendar.MONTH, monthNum - 1);
                    SimpleDateFormat dataFormat = new SimpleDateFormat("MMM");
                    return dataFormat.format(calendar.getTime());
                } else
                    return "" + monthNum;
            }
        });
    }

    if (wlt_mode.doubleValue() == 3) {
        renderer.setBasePositiveItemLabelPosition(new ItemLabelPosition(ItemLabelAnchor.OUTSIDE12,
                org.jfree.ui.TextAnchor.BOTTOM_CENTER, org.jfree.ui.TextAnchor.BOTTOM_RIGHT, Math.PI / 2));
        renderer.setBaseNegativeItemLabelPosition(new ItemLabelPosition(ItemLabelAnchor.OUTSIDE6,
                org.jfree.ui.TextAnchor.TOP_CENTER, org.jfree.ui.TextAnchor.HALF_ASCENT_LEFT, Math.PI / 2));

    } else if (wlt_mode.doubleValue() == 4) {
        renderer.setBasePositiveItemLabelPosition(new ItemLabelPosition(ItemLabelAnchor.OUTSIDE12,
                org.jfree.ui.TextAnchor.BOTTOM_CENTER, org.jfree.ui.TextAnchor.BOTTOM_RIGHT, Math.PI / 4));
        renderer.setBaseNegativeItemLabelPosition(new ItemLabelPosition(ItemLabelAnchor.OUTSIDE6,
                org.jfree.ui.TextAnchor.TOP_CENTER, org.jfree.ui.TextAnchor.HALF_ASCENT_LEFT, Math.PI / 4));
    }

    if (legend == true) {
        LegendItemCollection collection = createThresholdLegend(plot);
        LegendItem item = new LegendItem("Avg", "Avg", "Avg", "Avg", new Rectangle(10, 10), colorAverage);
        collection.add(item);
        plot.setFixedLegendItems(collection);

    }

    plot.setRenderer(0, renderer);
    logger.debug("OUT");
    return sparkLineGraph;
}

From source file:org.tsho.dmc2.core.chart.TrajectoryMultiRenderer.java

private void computeRanges() {

    Stepper.Point2D point;/*from w w w. j a  va2  s. c  o  m*/
    double xLower, xUpper;
    double yLower, yUpper;

    for (int i = 0; i < stepperList.length; i++) {
        stepperList[i].initialize();
    }

    point = stepperList[0].getCurrentPoint2D();
    xLower = point.getX();
    xUpper = point.getX();
    yLower = point.getY();
    yUpper = point.getY();

    for (index = 0; index < rangeIterations; index++) {

        for (int i = 0; i < stepperList.length; i++) {

            point = stepperList[i].getCurrentPoint2D();

            if (xLower > point.getX()) {
                xLower = point.getX();
            } else if (xUpper < point.getX()) {
                xUpper = point.getX();
            }

            if (yLower > point.getY()) {
                yLower = point.getY();
            } else if (yUpper < point.getY()) {
                yUpper = point.getY();
            }

            stepperList[i].step();

            if (stopped) {
                break;
            }
        }
    }

    if (Double.isInfinite(xLower) || Double.isInfinite(xUpper) || Double.isInfinite(yLower)
            || Double.isInfinite(yUpper) || Double.isNaN(xLower) || Double.isNaN(xUpper) || Double.isNaN(yLower)
            || Double.isNaN(yUpper)) {

        throw new ModelException("Exception during range calculations: (infinite or not-a-number value found)");
    }

    if (!timePlot) {
        plot.setDataRanges(new Range(xLower, xUpper), new Range(yLower, yUpper));
    } else {
        plot.setDataRanges(new Range(transients, transients + iterations), new Range(yLower, yUpper));
    }

    computeRanges = false;
}

From source file:org.tsho.dmc2.core.chart.TrajectoryRenderer.java

private void computeRanges() {
    Stepper.Point2D point;/* w ww  .  j ava2 s .c o m*/
    double xLower, xUpper;
    double yLower, yUpper;

    stepper.initialize();

    point = stepper.getCurrentPoint2D();
    xLower = xUpper = point.getX();
    yLower = yUpper = point.getY();

    for (index = 0; index < rangeIterations; index++) {
        if (stopped) {
            state = STATE_STOPPED;
            break;
        }

        stepper.step();
        point = stepper.getCurrentPoint2D();

        if (xLower > point.getX()) {
            xLower = point.getX();
        } else if (xUpper < point.getX()) {
            xUpper = point.getX();
        }

        if (yLower > point.getY()) {
            yLower = point.getY();
        } else if (yUpper < point.getY()) {
            yUpper = point.getY();
        }
    }

    if (Double.isInfinite(xLower) || Double.isInfinite(xUpper) || Double.isInfinite(yLower)
            || Double.isInfinite(yUpper) || Double.isNaN(xLower) || Double.isNaN(xUpper) || Double.isNaN(yLower)
            || Double.isNaN(yUpper)) {
        throw new ModelException("Exception during range calculations: (infinite or not-a-number value found)");
    }

    if (!timePlot) {
        plot.setDataRanges(new Range(xLower, xUpper), new Range(yLower, yUpper));
    } else {
        plot.setDataRanges(new Range(transients, transients + iterations), new Range(yLower, yUpper));
    }

    computeRanges = false;
}

From source file:org.tsho.dmc2.managers.TrajectoryManager.java

public final boolean doRendering(final boolean redraw) {

    TrajectoryRenderer renderer = null;/* ww  w.  j  a v  a 2s .  c o m*/

    VariableDoubles initialVal;
    VariableDoubles parameters;
    VariableDoubles deltaVar = null;
    VariableDoubles deltaPar = null;
    int variationCount = 0;
    double stepSize = 0;
    int transients;
    int iterations;
    int rangeIterations = 0;
    Range xRange = null, yRange = null;
    String xLabel;
    String yLabel;

    // collect user values

    try {
        parameters = form.getParameterValues();
        initialVal = form.getInitialValues();

        if (form.isVariation()) {
            deltaVar = form.getDeltaVarValues();
            deltaPar = form.getDeltaParameters();
            variationCount = form.getVariationCount();
        }

        if (model instanceof ODE) {
            stepSize = form.getStepSize();
        }

        transients = form.getTransients();
        iterations = form.getIterations();

        if (form.isAutoRanges()) {
            rangeIterations = form.getRangeIterations();
        } else {
            if (!form.isTime()) {
                xRange = form.getXRange();
            }
            yRange = form.getYRange();
        }

        xLabel = form.getLabelOnX();
        yLabel = form.getLabelOnY();
    } catch (InvalidData e) {
        errorMessage = e.getMessage();
        // frame.errorNotify(e.getMessage()); // this causes the sm to re-enter!
        return false;
    }

    // create renderer

    if (!form.isVariation()) {
        Stepper stepper = null;
        if (model instanceof SimpleMap) {
            stepper = Lua.newIterator(model, VariableDoubles.toArray(parameters),
                    VariableDoubles.toArray(initialVal));
        } else if (model instanceof ODE) {
            stepper = Lua.newODEStepper(model, VariableDoubles.toArray(parameters),
                    VariableDoubles.toArray(initialVal), stepSize, odeStepFunction);
        }

        renderer = new TrajectoryRenderer(plot, stepper, component);
        plot.setPlotRenderer(renderer);

        stepper.setAxes(VariableDoubles.indexOf(initialVal, xLabel),
                VariableDoubles.indexOf(initialVal, yLabel));
    } else {
        Stepper[] steppersList;
        steppersList = createStepperList(model, variationCount, initialVal, parameters, deltaVar, deltaPar,
                xLabel, yLabel);

        renderer = new TrajectoryMultiRenderer(plot, steppersList, component);
        plot.setPlotRenderer(renderer);
    }

    // set type-depending stuff
    if (!form.isTime()) {
        renderer.setTimePlot(false);
        xAxis.setLabel(xLabel);
        yAxis.setLabel(yLabel);
    } else {
        renderer.setTimePlot(true);
        xAxis.setLabel("time");
        yAxis.setLabel(yLabel);
        xLabel = yLabel;
    }

    // set ranges if not redrawing only

    if (!redraw) {
        if (form.isAutoRanges()) {
            renderer.setRangeIterations(rangeIterations);
            xAxis.setLowerMargin(0.05);
            xAxis.setUpperMargin(0.05);
            yAxis.setLowerMargin(0.05);
            yAxis.setUpperMargin(0.05);
            renderer.setComputeRanges(true);
        } else {
            xAxis.setLowerMargin(0);
            xAxis.setUpperMargin(0);
            yAxis.setLowerMargin(0);
            yAxis.setUpperMargin(0);
            if (form.isTime()) {
                Range timeRange = new Range(transients, transients + iterations);
                plot.setDataRanges(timeRange, yRange);
            } else {
                plot.setDataRanges(xRange, yRange);
            }
            renderer.setComputeRanges(false);
        }
        plot.zoom(0.0); // reset zoom
    } else {
        renderer.setComputeRanges(false);
    }

    renderer.setTransients(transients);
    renderer.setIterations(iterations);
    renderer.setDelay(getFrame().getDelayValue());
    renderer.setBigDots(bigDots);
    renderer.setConnectWithLines(connectDots);
    renderer.setContinua(false);

    plot.setDrawGridLines(gridlines);
    plot.setNoData(false);

    launchThread(false);

    return true;
}