470 lines
11 KiB
Java
470 lines
11 KiB
Java
|
|
//TODO sterne wegmachen
|
|
import javax.swing.*;
|
|
import java.awt.*;
|
|
import java.util.*;
|
|
|
|
import java.util.Random;
|
|
import java.util.ArrayList;
|
|
|
|
//keys
|
|
import java.awt.event.KeyEvent;
|
|
import java.awt.event.KeyListener;
|
|
//files
|
|
import java.io.FileReader;
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.IOException;
|
|
import java.io.BufferedReader;
|
|
//mouse
|
|
import java.awt.event.MouseAdapter;
|
|
import java.awt.event.MouseEvent;
|
|
//refresh
|
|
import java.awt.event.ActionEvent;
|
|
import javax.swing.Timer;
|
|
import java.awt.event.ActionListener;
|
|
|
|
public class sichtlinien extends JFrame implements KeyListener {
|
|
|
|
public static String filename;
|
|
Scanner scan;
|
|
Polygon p;
|
|
Shape[] shapes = makeArr();
|
|
int amount, startX, startY, HEIGHT = 1100, WIDTH = 1100;
|
|
|
|
Timer looper = new Timer(1000 / 60, new ActionListener() {
|
|
|
|
@Override
|
|
public void actionPerformed(ActionEvent e) {
|
|
// repaint();
|
|
}
|
|
|
|
});
|
|
|
|
boolean first = false, showLines = false;
|
|
|
|
Segment[] segments = makeSegments();
|
|
Segment[] rays = createRays();
|
|
|
|
public static void main(String[] args) {
|
|
// DONE for-loop fur mehrere inputs
|
|
if (args.length != 0) {
|
|
for (String arg : args) {
|
|
filename = arg;
|
|
new sichtlinien(arg);
|
|
}
|
|
|
|
} else {
|
|
filename = "file1.txt";
|
|
new sichtlinien("file1.txt");
|
|
}
|
|
|
|
}
|
|
|
|
public sichtlinien(String input) {
|
|
filename = input;
|
|
System.out.println("Before");
|
|
setSize(WIDTH, HEIGHT);
|
|
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
setLocationRelativeTo(null);
|
|
setVisible(true);
|
|
setBackground(new Color(0, 0, 0));
|
|
addKeyListener(this);
|
|
JPanel panel = new JPanel();
|
|
add(panel);
|
|
panel.addMouseListener(new MouseAdapter() {
|
|
@Override
|
|
public void mousePressed(MouseEvent e) {
|
|
System.out.println(e.getX() + "," + e.getY());
|
|
startX = e.getX();
|
|
startY = e.getY() - 75;
|
|
repaint();
|
|
}
|
|
});
|
|
// looper.start();
|
|
repaint();
|
|
|
|
}
|
|
|
|
@Override
|
|
public void keyTyped(KeyEvent e) {
|
|
|
|
}
|
|
|
|
@Override
|
|
public void keyPressed(KeyEvent e) {
|
|
System.out.println("Key: " + e.getKeyChar());
|
|
if (e.getKeyChar() == 'a') {
|
|
|
|
}
|
|
if (e.getKeyChar() == 'd') {
|
|
showLines = false;
|
|
repaint();
|
|
}
|
|
if (e.getKeyChar() == 's') {
|
|
showLines = true;
|
|
repaint();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void keyReleased(KeyEvent e) {
|
|
|
|
}
|
|
|
|
public void readFile(String filename) {
|
|
try {
|
|
scan = new Scanner(new File(filename));
|
|
} catch (FileNotFoundException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public Shape[] makeArr() {
|
|
readFile(filename);
|
|
amount = scan.nextInt();
|
|
System.out.println(amount);
|
|
Shape shapes[] = new Shape[amount];
|
|
|
|
for (int i = 0; i < amount; i++) {
|
|
shapes[i] = new Shape();
|
|
System.out.println("added");
|
|
int aPoints = scan.nextInt();
|
|
for (int j = 0; j < aPoints; j++) {
|
|
shapes[i].addPoint(scan.nextInt(), scan.nextInt());
|
|
System.out.println("added2");
|
|
System.out.println(shapes[i].getLength());
|
|
}
|
|
}
|
|
startX = scan.nextInt();
|
|
startY = scan.nextInt();
|
|
return shapes;
|
|
}
|
|
|
|
public int numberLines() {
|
|
int out = 0;
|
|
|
|
for (Shape shape : shapes) {
|
|
out = out + shape.getLength();
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
public Segment[] makeSegments() {
|
|
Segment[] segments = new Segment[numberLines() + 4];
|
|
int tmpCounter = 0;
|
|
|
|
for (Shape shape : shapes) {
|
|
for (int i = 0; i < shape.getLength(); i++) {
|
|
if (i < shape.getLength() - 1) {
|
|
segments[tmpCounter] = new Segment(new Vector(shape.getX(i), shape.getY(i)),
|
|
new Vector(shape.getX(i + 1), shape.getY(i + 1)));
|
|
} else {
|
|
segments[tmpCounter] = new Segment(new Vector(shape.getX(i), shape.getY(i)),
|
|
new Vector(shape.getX(0), shape.getY(0)));
|
|
}
|
|
tmpCounter++;
|
|
}
|
|
}
|
|
|
|
segments[tmpCounter] = new Segment(new Vector(0, 0), new Vector(WIDTH, 0));
|
|
tmpCounter++;
|
|
segments[tmpCounter] = new Segment(new Vector(WIDTH, 0), new Vector(WIDTH, HEIGHT));
|
|
tmpCounter++;
|
|
segments[tmpCounter] = new Segment(new Vector(WIDTH, HEIGHT), new Vector(0, HEIGHT));
|
|
tmpCounter++;
|
|
segments[tmpCounter] = new Segment(new Vector(0, HEIGHT), new Vector(0, 0));
|
|
|
|
return segments;
|
|
|
|
}
|
|
|
|
Segment[] createRays() {
|
|
|
|
rays = new Segment[segments.length * 3];
|
|
|
|
int counter = 0;
|
|
|
|
for (int s = 0; s < segments.length; s++) {
|
|
|
|
Vector a = new Vector(startX, startY);
|
|
Vector b = segments[s].b;
|
|
Vector c = b.subtract(a).normalize();
|
|
|
|
Segment s1 = new Segment(
|
|
a,
|
|
b);
|
|
Segment s2 = new Segment(
|
|
a,
|
|
a.add(c.setDir(c.getAngle() + 0.00001f).normalize().scale(WIDTH)));
|
|
Segment s3 = new Segment(
|
|
a,
|
|
a.add(c.setDir(c.getAngle() - 0.00001f).normalize().scale(WIDTH)));
|
|
|
|
rays[counter] = s1;
|
|
rays[counter + 1] = s2;
|
|
rays[counter + 2] = s3;
|
|
|
|
counter += 3;
|
|
|
|
}
|
|
return (sortRays());
|
|
}
|
|
|
|
Segment[] sortRays() {
|
|
|
|
ArrayList<Segment> list = new ArrayList<Segment>();
|
|
|
|
for (int r = 0; r < rays.length; r++) {
|
|
list.add(rays[r]);
|
|
}
|
|
|
|
list.sort(new Comparator<Segment>() {
|
|
|
|
@Override
|
|
public int compare(Segment e1, Segment e2) {
|
|
|
|
Vector v1 = e1.b.subtract(e1.a);
|
|
Vector v2 = e2.b.subtract(e2.a);
|
|
|
|
if (v1.getAngle() < v2.getAngle())
|
|
return -1;
|
|
if (v1.getAngle() > v2.getAngle())
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
});
|
|
|
|
for (int i = 0; i < list.size(); i++) {
|
|
|
|
rays[i] = list.get(i);
|
|
|
|
}
|
|
return rays;
|
|
}
|
|
|
|
public void paint(Graphics g) {
|
|
|
|
createRays();
|
|
sortRays();
|
|
|
|
// TODO farbpalette und farben speichern
|
|
|
|
// reset field
|
|
g.clearRect(0, 0, WIDTH, HEIGHT);
|
|
|
|
// shapes
|
|
g.setColor(new Color(100, 255, 100));
|
|
drawShapes(g);
|
|
|
|
// borders
|
|
g.setColor(new Color(255, 255, 255));
|
|
drawBorders(g);
|
|
|
|
// TODO fix polygons
|
|
// make polygons
|
|
// g.setColor(new Color(100, 100, 200));
|
|
// drawPolygons(g);
|
|
|
|
// make lines
|
|
g.setColor(new Color(0, 0, 255));
|
|
drawRays(g);
|
|
|
|
// point
|
|
g.setColor(new Color(255, 100, 100));
|
|
g.fillOval(startX - 10, startY - 10 + 100, 20, 20);
|
|
|
|
}
|
|
|
|
void drawBorders(Graphics g) {
|
|
for (Shape shape : shapes) {
|
|
p = new Polygon();
|
|
for (int j = 0; j < shape.getLength(); j++) {
|
|
p.addPoint(shape.getX(j), shape.getY(j) + 100);
|
|
}
|
|
g.drawPolygon(p);
|
|
}
|
|
}
|
|
|
|
void drawShapes(Graphics g) {
|
|
for (Shape shape : shapes) {
|
|
p = new Polygon();
|
|
for (int j = 0; j < shape.getLength(); j++) {
|
|
p.addPoint(shape.getX(j), shape.getY(j) + 100);
|
|
}
|
|
g.fillPolygon(p);
|
|
}
|
|
}
|
|
|
|
void drawRays(Graphics g) {
|
|
for (int r = 0; r < rays.length; r++) {
|
|
Segment ray = rays[r];
|
|
|
|
Vector closestIntersect = ray.b;
|
|
float distToIntersect = WIDTH;
|
|
|
|
for (int i = 0; i < segments.length; i++) {
|
|
|
|
Intersect inter = getIntersection(ray, segments[i]);
|
|
|
|
if (inter != null) {
|
|
|
|
float d = inter.distance;
|
|
|
|
if (distToIntersect > d) {
|
|
distToIntersect = d;
|
|
closestIntersect = inter.intersect;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
ray.b = closestIntersect;
|
|
}
|
|
|
|
for (int r = 0; r < rays.length; r++) {
|
|
|
|
Segment ray = rays[r];
|
|
|
|
g.drawLine((int) ray.a.x, (int) ray.a.y + 100, (int) ray.b.x, (int) ray.b.y + 100);
|
|
|
|
}
|
|
}
|
|
|
|
void drawPolygons(Graphics g) {
|
|
|
|
for (int r = 0; r < rays.length; r++) {
|
|
|
|
Segment ray1 = rays[r];
|
|
Segment ray2;
|
|
|
|
if (r == rays.length - 1) {
|
|
ray2 = rays[0];
|
|
} else {
|
|
ray2 = rays[r + 1];
|
|
}
|
|
|
|
Polygon p;
|
|
int[] x_points = { (int) ray1.a.x, (int) ray1.b.x, (int) ray2.b.x };
|
|
int[] y_points = { (int) ray1.a.y + 100, (int) ray1.b.y + 100, (int) ray2.b.y + 100 };
|
|
|
|
p = new Polygon(x_points, y_points, 3);
|
|
|
|
g.fillPolygon(p);
|
|
|
|
// g.setClip(p);
|
|
|
|
}
|
|
}
|
|
|
|
public void neuzeichnen() {
|
|
repaint();
|
|
}
|
|
|
|
public void anzeigenTxt() {
|
|
|
|
}
|
|
|
|
public void wait(int milliseconds) {
|
|
try {
|
|
Thread.sleep(milliseconds);
|
|
} catch (Exception e) {
|
|
|
|
}
|
|
}
|
|
|
|
Intersect getIntersection(Segment s1, Segment s2) {
|
|
|
|
Vector p = s1.a;
|
|
Vector q = s2.a;
|
|
Vector r = s1.b.subtract(s1.a);
|
|
Vector s = s2.b.subtract(s2.a);
|
|
|
|
float t = (crossProduct(q, s) - crossProduct(p, s)) / crossProduct(r, s);
|
|
float u = (crossProduct(p, r) - crossProduct(q, r)) / crossProduct(s, r);
|
|
|
|
if (t >= 0 && t <= 1 && u >= 0 && u <= 1) {
|
|
return new Intersect(new Vector(p.x + t * r.x, p.y + t * r.y), t);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
float crossProduct(Vector a, Vector b) {
|
|
return a.x * b.y - a.y * b.x;
|
|
}
|
|
|
|
class Intersect {
|
|
Vector intersect;
|
|
float distance;
|
|
|
|
Intersect(Vector i, float d) {
|
|
this.intersect = i;
|
|
this.distance = d;
|
|
}
|
|
|
|
}
|
|
|
|
class Segment {
|
|
|
|
Vector a;
|
|
Vector b;
|
|
|
|
Segment(Vector a, Vector b) {
|
|
this.a = a;
|
|
this.b = b;
|
|
}
|
|
|
|
}
|
|
|
|
class Vector {
|
|
float x;
|
|
float y;
|
|
|
|
Vector(float x, float y) {
|
|
this.x = x;
|
|
this.y = y;
|
|
}
|
|
|
|
Vector add(Vector v) {
|
|
return new Vector(x + v.x, y + v.y);
|
|
}
|
|
|
|
Vector subtract(Vector v) {
|
|
return new Vector(x - v.x, y - v.y);
|
|
}
|
|
|
|
float getM() {
|
|
return (float) (Math.sqrt(x * x + y * y));
|
|
}
|
|
|
|
Vector normalize() {
|
|
float m = getM();
|
|
x = x / m;
|
|
y = y / m;
|
|
return this;
|
|
}
|
|
|
|
Vector scale(float t) {
|
|
x *= t;
|
|
y *= t;
|
|
return this;
|
|
}
|
|
|
|
Vector setDir(float angle) {
|
|
|
|
float m = getM();
|
|
return new Vector((float) (m * Math.cos(angle)), (float) (m * Math.sin(angle)));
|
|
|
|
}
|
|
|
|
float getAngle() {
|
|
return (float) Math.atan2(y, x);
|
|
}
|
|
|
|
}
|
|
|
|
}
|