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

package View;

import Model.Arrangement;
import Model.Line;
import Model.Point;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.util.LinkedList;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.SwingConstants;
import javax.swing.event.MouseInputAdapter;
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.ui.RectangleEdge;
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 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, 10000, 5000);
    this.hslider = new JSlider(SwingConstants.HORIZONTAL, 1, 10000, 5000);
  }

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

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

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

    XYSeries intersections = new XYSeries("intersections");
    for (Point p : points) {
      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();

    System.out.println(domainMin+" -- "+domainMax+" -- "+rangeMin+" -- "+rangeMax);
    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();
    addZooming(panel);

    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() - 5000) * 0.1;
      if (slider.getValue() < 5000) {
        domain.setRange(domain.getLowerBound() - delta, domain.getUpperBound() - delta);
      } else {
        domain.setRange(domain.getLowerBound() + delta, domain.getUpperBound() + delta);
      }
    });

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

      if (slider.getValue() < 5000) {
        range.setRange(range.getLowerBound() - delta, range.getUpperBound() - delta);
      } else {
        range.setRange(range.getLowerBound() + delta, range.getUpperBound() + delta);
      }
    });
  }

  protected void  addZooming(ChartPanel chartPanel) {

    chartPanel.addMouseWheelListener(new MouseWheelListener() {

      public void mouseWheelMoved(MouseWheelEvent e) {
        Double x = Double.valueOf(e.getY());
        Double y = Double.valueOf(e.getY());
        if (e.getScrollType() != MouseWheelEvent.WHEEL_UNIT_SCROLL)
          return;
        if (e.getWheelRotation() < 0)
          increaseZoom((ChartPanel) e.getComponent(), true, x, y);
        else
          decreaseZoom((ChartPanel) e.getComponent(), true, x, y);
      }

      public synchronized void increaseZoom(JComponent chart, boolean saveAction, Double x, Double y) {
        ChartPanel ch = (ChartPanel) chart;
        zoomChartAxis(ch, true, x, y);
      }

      public synchronized void decreaseZoom(JComponent chart, boolean saveAction, Double x, Double y) {
        ChartPanel ch = (ChartPanel) chart;
        zoomChartAxis(ch, false, x, y);
      }

      private void zoomChartAxis(ChartPanel chartP, boolean increase, Double x, Double y) {
        int width = chartP.getMaximumDrawWidth() - chartP.getMinimumDrawWidth();
        int height = chartP.getMaximumDrawHeight() - chartP.getMinimumDrawWidth();
        if (increase) {
          chartP.zoomInBoth(width / 2, height / 2);
        } else {
          chartP.zoomOutBoth(width / 2, height / 2);
        }

      }
    });
  }

  }