algorithms-for-computing-line-estimators/src/main/java/View/ArrangementDialog.java

package View;

import Model.Line;
import Model.Point;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.util.LinkedList;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.SwingConstants;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.ValueAxis;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.jfree.util.ShapeUtilities;

/**
 * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
 *
 * @Author: Armin Wolf
 * @Email: a_wolf28@uni-muenster.de
 * @Date: 28.05.2017.
 */
public class ArrangementDialog extends JPanel {

  private LinkedList<Line> lines;
  private LinkedList<Point> points;
  private double max;
  private double min;
  private JFreeChart chart;
  private ChartPanel panel;
  private JSlider hslider;
  private JSlider vslider;
  private double domainMin, domainMax;
  private double rangeMin, rangeMax;
  private ValueAxis domain;
  private ValueAxis range;

  public ArrangementDialog() {
    super();
    this.setPreferredSize(new Dimension(800, 800));
    this.setMinimumSize(new Dimension(800, 800));
    this.setLayout(new BorderLayout());
    this.vslider = new JSlider(SwingConstants.VERTICAL, 1, 100, 50);
    this.hslider = new JSlider(SwingConstants.HORIZONTAL, 10, 1000, 500);
  }

  public void setPrameters(LinkedList<Line> lines, LinkedList<Point> points) {
    this.lines = lines;
    this.points = points;
    this.domainMin = Double.MAX_VALUE;
    this.domainMax = Double.MIN_VALUE;
    this.rangeMin = Double.MAX_VALUE;
    this.rangeMax = Double.MIN_VALUE;
  }

  public void createArrangement() {
    XYSeriesCollection dataset = new XYSeriesCollection();

    for (Line p : lines) {
      XYSeries series = new XYSeries(p.getId());
      series.add(p.getX1(), p.getY1());
      series.add(p.getX2(), p.getY2());
      dataset.addSeries(series);
    }

    XYSeries intersections = new XYSeries("intersections");
    for (Point p : points) {
      domainMax = domainMax < p.getX() ? p.getX() : domainMax;
      domainMin = domainMin > p.getX() ? p.getX() : domainMin;
      rangeMax = rangeMax < p.getY() ? p.getY() : rangeMax;
      rangeMin = rangeMin > p.getY() ? p.getY() : rangeMin;
      intersections.add(p.getX(), p.getY());
    }
    dataset.addSeries(intersections);

    chart = ChartFactory.createXYLineChart(
        null, null, null, dataset,
        PlotOrientation.HORIZONTAL, false, false, false);
    chart.setRenderingHints(
        new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON));
    chart.setAntiAlias(true);

    final XYPlot plot = chart.getXYPlot();

    domain = plot.getDomainAxis();
    range = plot.getRangeAxis();

    domain.setRange(domainMin - 1, domainMax + 1);
    range.setRange(rangeMin - 1, rangeMax + 1);
    plot.setBackgroundPaint(Color.WHITE);
    plot.setDomainGridlinePaint(Color.white);
    plot.setRangeGridlinePaint(Color.white);

    final XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
    renderer.setSeriesLinesVisible(dataset.indexOf(intersections), false);
    plot.setRenderer(renderer);

    for (int i = 0; i < lines.size(); i++) {
      // Setze die Shapes für die Schnittpunkte
      renderer.setSeriesPaint(i, Color.BLUE);
      renderer.setBaseSeriesVisible(true);
    }

    Shape shape = ShapeUtilities.createDiagonalCross(4, 1);
    renderer.setSeriesPaint(lines.size(), Color.BLACK);
    renderer.setSeriesShape(lines.size(), shape);

    panel = new ChartPanel(chart);
    panel.setPreferredSize(new Dimension(800, 800));

    addListener();

    this.add(panel, BorderLayout.CENTER);
    this.add(hslider, BorderLayout.SOUTH);
    this.add(vslider, BorderLayout.EAST);
  }

  private void addListener() {
    this.vslider.addChangeListener(e -> {
      JSlider slider = (JSlider) e.getSource();
      double delta = Math.abs(slider.getValue() - 50) * 0.1;
      if (slider.getValue() < 50) {
        domain.setRange(domainMin - delta, domainMax - delta);
      } else {
        domain.setRange(domainMin + delta, domainMax + delta);
      }
    });

    this.hslider.addChangeListener(e -> {
      JSlider slider = (JSlider) e.getSource();
      double delta = Math.abs(slider.getValue() - 500);

      if (slider.getValue() < 500) {
        range.setRange(rangeMin - delta, rangeMax - delta);
      } else {
        range.setRange(rangeMin + delta, rangeMax + delta);
      }
    });

  }


}