Advertisement
Guest User

Untitled

a guest
Jun 25th, 2017
56
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 6.48 KB | None | 0 0
  1. import javax.swing.*;
  2. import javax.swing.Timer;
  3.  
  4. import java.awt.*;
  5. import java.util.*;
  6. import java.util.List;
  7. import java.awt.event.ActionEvent;
  8. import java.awt.event.ActionListener;
  9. import java.awt.event.KeyEvent;
  10. import java.awt.event.KeyListener;
  11. import static java.lang.Math.*;
  12.  
  13. public class Geom extends JFrame {
  14. private class PaintPanel extends JPanel {
  15. double maxX = 1000 / 10;
  16. double maxY = 1000 / 10;
  17. double minX = -maxX;
  18. double minY = -maxY;
  19.  
  20. int state = 0;
  21. double[][] cord = new double[3][3];
  22. double[][] center;
  23.  
  24. public PaintPanel() {
  25. addKeyListener(new KeyListener() {
  26. public void keyPressed(KeyEvent arg0) {
  27. }
  28.  
  29. public void keyReleased(KeyEvent arg0) {
  30. }
  31.  
  32. public void keyTyped(KeyEvent key) {
  33. if (key.getKeyChar() == ' ') {
  34. state = (state + 1) % MOD;
  35. repaint();
  36. }
  37. System.err.println(state);
  38. }
  39. });
  40. new Timer(100, new ActionListener() {
  41. public void actionPerformed(ActionEvent arg0) {
  42. repaint();
  43. }
  44. }).start();
  45. setFocusable(true);
  46. }
  47.  
  48. public void paintComponent(Graphics g) {
  49. super.paintComponents(g);
  50. Graphics2D g2 = (Graphics2D) g;
  51. g2.setColor(Color.black);
  52. g2.fill(new Rectangle(getSize()));
  53. paintAxis(g2);
  54. g2.setColor(Color.yellow);
  55. if (false) {
  56. if (state == 0) {
  57. cord = createNewTriangle();
  58. } else if (state == 1) {
  59. double dx = cord[0][0];
  60. double dy = cord[0][1];
  61. for (int i = 0; i < cord.length; ++i) {
  62. cord[i] = move(cord[i], -dx, -dy);
  63. }
  64. } else if (state == 2) {
  65. double angle = Math.PI - Math.atan2(cord[1][1], cord[1][0]);
  66. for (int i = 0; i < cord.length; ++i) {
  67. cord[i] = rotate(cord[i], angle);
  68. }
  69. } else if (state == 3) {
  70. for (int i = 0; i < cord.length; ++i) {
  71. cord[i] = scale(cord[i], -1, -1);
  72. }
  73. } else if (state == 4) {
  74. double[][] ncord = new double[4][];
  75. ncord[0] = cord[1];
  76. ncord[1] = cord[2];
  77. ncord[2] = new double[] {-cord[1][0], -cord[1][1], 1};
  78. ncord[3] = new double[] {-cord[2][0], -cord[2][1], 1};
  79. cord = ncord;
  80. } else if (state == 5) {
  81. double kx = 1;
  82. double ky = Math.abs((cord[1][0] + cord[2][0]) / (cord[1][1] + cord[2][1]));
  83. for (int i = 0; i < cord.length; ++i) {
  84. cord[i] = scale(cord[i], kx, ky);
  85. }
  86. } else if (state == 6) {
  87. double dx = 0;
  88. for (int i = 0; i < cord.length; ++i) {
  89. dx = Math.max(dx, Math.abs(cord[i][0]));
  90. }
  91. for (int i = 0; i < cord.length; ++i) {
  92. if (Math.abs(cord[i][0]) < 1e-9) {
  93. if (cord[i][1] > 0) {
  94. cord[i] = move(cord[i], dx, 0);
  95. } else if (cord[i][1] < 0){
  96. cord[i] = move(cord[i], -dx, 0);
  97. }
  98. }
  99. }
  100. }
  101. } else {
  102. if (state == 0) {
  103. cord = createNewFigure();
  104. center = createNewCenter();
  105. } else {
  106. for (int i = 0; i < cord.length; ++i) {
  107. double dx = center[0][0];
  108. double dy = center[0][1];
  109. cord[i] = move(cord[i], -dx, -dy);
  110. cord[i] = rotate(cord[i], Math.PI / 150);
  111. cord[i] = move(cord[i], dx, dy);
  112. }
  113. }
  114. drawPolygon(cord, g2);
  115. drawPolygon(center, g2);
  116. }
  117. }
  118. int MOD = Integer.MAX_VALUE / 2;
  119.  
  120. private double[][] createNewCenter() {
  121. double[][] res = new double[][] {{maxX / 5, maxY / 5, 1},
  122. {maxX / 5, maxY / 5, 1}};
  123. return res;
  124. }
  125.  
  126. private double[][] createNewFigure() {
  127. double x = maxX / 10;
  128. double y = maxY / 8;
  129. double dx = maxX / 10;
  130. double dy = maxY / 3;
  131. double[][] res = new double[][] { {-x, -y, 1},
  132. {-x - dx / 2, -y, 1},
  133. {-x - dx, -y - dy, 1},
  134. {-x, -y -dy, 1}};
  135. return res;
  136. }
  137.  
  138. private double[] scale(double[] a, double kx, double ky) {
  139. double[][] m = new double[][] { {kx, 0, 0},
  140. {0, ky, 0},
  141. {0, 0, 1} };
  142. return multiply(a, m)[0];
  143. }
  144.  
  145. private void drawPolygon(double[][] cord, Graphics2D g2) {
  146. for (int i = 0; i < cord.length; ++i) {
  147. drawLine(cord[i][0], cord[i][1], cord[(i + 1) % cord.length][0], cord[(i + 1) % cord.length][1], g2);
  148. }
  149. }
  150.  
  151. private double[][] createNewTriangle() {
  152. double[][] cord = new double[3][];
  153. Random rm = new Random();
  154. double x = (rm.nextDouble() + 0.5) * maxX / 3;
  155. double y = (rm.nextDouble() + 0.5) * maxY / 3;
  156. cord[0] = new double[] {0, 0, 1};
  157. cord[1] = new double[] {0, y, 1};
  158. cord[2] = new double[] {x, 0, 1};
  159. double dx = (rm.nextDouble() + 0.0) * maxX / 3 + maxX / 5;
  160. double dy = (rm.nextDouble() + 0.0) * maxY / 3 + maxY / 5;
  161. for (int i = 0; i < 3; ++i) {
  162. cord[i] = move(cord[i], dx, dy);
  163. }
  164. double angle = Math.PI * rm.nextDouble();
  165. for (int i = 0; i < 3; ++i) {
  166. cord[i] = rotate(cord[i], angle);
  167. }
  168. return cord;
  169. }
  170.  
  171. private double[] rotate(double[] a, double angle) {
  172. double[][] m = new double[][] { {cos(angle), sin(angle), 0},
  173. {-sin(angle), cos(angle), 0},
  174. {0, 0, 1}};
  175. return multiply(a, m)[0];
  176. }
  177.  
  178. private double[] move(double[] a, double dx, double dy) {
  179. double[][] m = new double[][] { {1, 0, 0},
  180. {0, 1, 0},
  181. {dx, dy, 1}};
  182. return multiply(a, m)[0];
  183. }
  184.  
  185. private double[][] multiply(double[] cord, double[][] b) {
  186. double[][] a = new double[][] {cord};
  187. double[][] res = new double[a.length][b[0].length];
  188. for (int i = 0; i < res.length; ++i) {
  189. for (int j = 0; j < res[i].length; ++j) {
  190. for (int k = 0; k < a[i].length; ++k) {
  191. res[i][j] += a[i][k] * b[k][j];
  192. }
  193. }
  194. }
  195. return res;
  196. }
  197.  
  198. private void paintAxis(Graphics2D g2) {
  199. g2.setColor(Color.green);
  200. drawLine(minX, 0, maxX, 0, g2);
  201. drawLine(0, minY, 0, maxY, g2);
  202. }
  203.  
  204. private void drawLine(double x, double y, double x2, double y2, Graphics2D g2) {
  205. int ix = screenX(x);
  206. int iy = screenY(y);
  207. int ix2 = screenX(x2);
  208. int iy2 = screenY(y2);
  209. g2.drawLine(ix, iy, ix2, iy2);
  210. }
  211.  
  212. private int screenY(double y) {
  213. Dimension dim = getSize();
  214. return (int) (dim.height * (1 - (y - minX) / (maxX - minX)));
  215. }
  216.  
  217. private int screenX(double x) {
  218. Dimension dim = getSize();
  219. return (int) (dim.width * (x - minX) / (maxX - minX));
  220. }
  221. }
  222.  
  223. public Geom() {
  224. Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
  225. setBounds(10, 10, 1000, 1000);
  226. add(new PaintPanel());
  227. setDefaultCloseOperation(EXIT_ON_CLOSE);
  228. setVisible(true);
  229. }
  230.  
  231. public static void main(String[] args) {
  232. new Geom();
  233. }
  234.  
  235. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement