Added main functions

.gitignore

+### IntelliJ IDEA ###
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store
\ No newline at end of file

.idea/.gitignore

+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/misc.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_19" default="true" project-jdk-name="19" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>
\ No newline at end of file

.idea/modules.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/horizon2.iml" filepath="$PROJECT_DIR$/horizon2.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file

.idea/vcs.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file

horizon2.iml

+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file

src/GraphDrawer.java

+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyEvent;
+import java.awt.image.BufferedImage;
+import java.util.Arrays;
+import java.util.Vector;
+
+public class GraphDrawer extends JPanel {
+
+
+    private static final int MATRIX_SIZE = 4;
+    private static final int WINDOW_SIZE_X = 1800;
+    private static final int WINDOW_SIZE_Y = 1200;
+    private static final int STEPS = 50;
+
+    private float[][] transformMatrix = {
+            {1.f / 3, 0, 0, 0},
+            {0, 1.f / 3, 0, 0},
+            {0, 0, 1.f / 3, 0},
+            {0, 0, 0, 1}
+    };
+
+    private float[][] projectionMatrix = {
+            {1, 0, 0, 0},
+            {0, 1, 0, 0},
+            {0, 0, 1, 0},
+            {0, 0, 0, 1}
+    };
+
+    private BufferedImage pixbuf = new BufferedImage(WINDOW_SIZE_X, WINDOW_SIZE_Y, BufferedImage.TYPE_INT_ARGB);
+
+    public JTextField x0Field, y0Field, x1Field, y1Field, stepsField;
+
+    public float x0,x1,y0,y1;
+    private JButton drawButton;
+    public int steps;
+
+    public GraphDrawer() {
+        // Инициализация текстовых полей и кнопки
+        x0Field = new JTextField("-5.0");
+        y0Field = new JTextField("-5.0");
+        x1Field = new JTextField("5.0");
+        y1Field = new JTextField("5.0");
+        stepsField = new JTextField("100");
+        drawButton = new JButton("Draw Graph");
+
+        // Установка макета
+        //JFrame frame = new JFrame("Graph Drawer");
+        setLayout(new BorderLayout());
+
+
+        // Создание панели для текстовых полей и кнопки
+        JPanel inputPanel = new JPanel();
+        inputPanel.setLayout(new GridLayout(6, 2));
+        inputPanel.add(new JLabel("x0:"));
+        inputPanel.add(x0Field);
+        inputPanel.add(new JLabel("y0:"));
+        inputPanel.add(y0Field);
+        inputPanel.add(new JLabel("x1:"));
+        inputPanel.add(x1Field);
+        inputPanel.add(new JLabel("y1:"));
+        inputPanel.add(y1Field);
+        inputPanel.add(new JLabel("Steps:"));
+        inputPanel.add(stepsField);
+        inputPanel.add(new JLabel(""));
+        inputPanel.add(drawButton);
+
+        // Добавление слушателя на кнопку
+        drawButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                drawGraph();
+                repaint();  // Перерисовываем содержимое панели
+            }
+        });
+
+// Additional ActionListener for keyboard events
+        KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(new KeyEventDispatcher() {
+            @Override
+            public boolean dispatchKeyEvent(KeyEvent e) {
+                int keyCode = e.getKeyCode();
+                switch (e.getID()) {
+                    case KeyEvent.KEY_PRESSED: {
+                        switch (keyCode) {
+                            case KeyEvent.VK_A: {
+                                transformMatrix[3][0] += -0.1f;
+                                transformMatrix[3][1] += 0;
+                                transformMatrix[3][2] += 0;
+
+                                repaint();
+                                break;
+                            }
+                            case KeyEvent.VK_D: {
+                                transformMatrix[3][0] += 0.1f;
+                                transformMatrix[3][1] += 0;
+                                transformMatrix[3][2] += 0;
+                                break;
+                            }
+                            case KeyEvent.VK_W: {
+                                transformMatrix[3][0] += 0;
+                                transformMatrix[3][1] += -0.1f;
+                                transformMatrix[3][2] += 0;
+                                break;
+                            }
+                            case KeyEvent.VK_S: {
+                                transformMatrix[3][0] += 0;
+                                transformMatrix[3][1] += 0.1f;
+                                transformMatrix[3][2] += 0;
+                                break;
+                            }
+                            case KeyEvent.VK_Q: {
+                                transformMatrix[3][0] += 0;
+                                transformMatrix[3][1] += 0;
+                                transformMatrix[3][2] += -1;
+                                break;
+                            }
+                            case KeyEvent.VK_E: {
+                                transformMatrix[3][0] += 0;
+                                transformMatrix[3][1] += 0;
+                                transformMatrix[3][2] += 1;
+                                break;
+                            }
+                            case KeyEvent.VK_F: {
+                                float sina = (float) Math.sin(-1 * Math.PI / 180);
+                                float cosa = (float) Math.cos(-1 * Math.PI / 180);
+
+                                float[][] m = {
+                                        {cosa, 0, sina, 0},
+                                        {0, 1, 0, 0},
+                                        {-sina, 0, cosa, 0},
+                                        {0, 0, 0, 1}
+                                };
+
+                                transformMatrix = multiplyMatrices(transformMatrix, m);
+                                break;
+                            }
+                            case KeyEvent.VK_H: {
+                                float sina = (float) Math.sin(1 * Math.PI / 180);
+                                float cosa = (float) Math.cos(1 * Math.PI / 180);
+
+                                float[][] m = {
+                                        {cosa, 0, sina, 0},
+                                        {0, 1, 0, 0},
+                                        {-sina, 0, cosa, 0},
+                                        {0, 0, 0, 1}
+                                };
+
+                                transformMatrix = multiplyMatrices(transformMatrix, m);
+                                break;
+                            }
+                            case KeyEvent.VK_T: {
+                                float sina = (float) Math.sin(-1 * Math.PI / 180);
+                                float cosa = (float) Math.cos(-1 * Math.PI / 180);
+
+                                float[][] m = {
+                                        {1, 0, 0, 0},
+                                        {0, cosa, sina, 0},
+                                        {0, -sina, cosa, 0},
+                                        {0, 0, 0, 1}
+                                };
+
+                                transformMatrix = multiplyMatrices(transformMatrix, m);
+                                break;
+                            }
+                            case KeyEvent.VK_G: {
+                                float sina = (float) Math.sin(1 * Math.PI / 180);
+                                float cosa = (float) Math.cos(1 * Math.PI / 180);
+
+                                float[][] m = {
+                                        {1, 0, 0, 0},
+                                        {0, cosa, sina, 0},
+                                        {0, -sina, cosa, 0},
+                                        {0, 0, 0, 1}
+                                };
+
+                                transformMatrix = multiplyMatrices(transformMatrix, m);
+                                break;
+
+                            }
+                        }
+
+                        break;
+
+                    }
+                }
+                return false;  // Allow further processing of the event
+            }
+        });
+
+
+
+
+
+        // Добавление панели с компонентами в верхнюю часть окна
+        add(inputPanel, BorderLayout.NORTH);
+
+        // Установка параметров окна и отображение
+        //frame.setSize(800, 600);
+        //frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        //frame.setVisible(true);
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        g.drawImage(pixbuf, 0, 0, getWidth(), getHeight(), this);
+    }
+
+    public void drawGraph() {
+        x0 = Float.parseFloat(x0Field.getText());
+        y0 = Float.parseFloat(y0Field.getText());
+        x1 = Float.parseFloat(x1Field.getText());
+        y1 = Float.parseFloat(y1Field.getText());
+        steps = Integer.parseInt(stepsField.getText());
+
+        Graphics2D graphics = pixbuf.createGraphics();
+        graphics.setColor(Color.WHITE);
+        graphics.fillRect(0, 0, WINDOW_SIZE_X, WINDOW_SIZE_Y);
+
+
+        float ystep = (y1 - y0) / STEPS;
+        float xstep = (x1 - x0) / steps;
+
+        Vector<int[]> points = new Vector<>();
+        float[] maxValues = new float[WINDOW_SIZE_X];
+        Arrays.fill(maxValues, -Float.POSITIVE_INFINITY);
+        float[] minValues = new float[WINDOW_SIZE_X];
+        Arrays.fill(minValues, Float.POSITIVE_INFINITY);
+
+        float[][] matrix = multiplyMatrices(transformMatrix, projectionMatrix);
+
+        for (int i = 0; i < STEPS; ++i) {
+            float y = y0 + ystep * i;
+            System.out.println();
+            points.clear();
+            for (int j = 0; j < steps; ++j) {
+                float x = x0 + xstep * j;
+                float r = x * x + y * y;
+                float val =  (float) Math.cos(r) /(r+1);
+                float[] point = {x, val, y};
+                float[] transformedPoint = multiplyVector(point, matrix);
+                int[] mapped = mapToScreen(transformedPoint, WINDOW_SIZE_X, WINDOW_SIZE_Y);
+                points.add(mapped);
+                System.out.print(mapped[0] + " " + mapped[1]+";");
+
+                if (mapped[1] < maxValues[mapped[0]] && mapped[1] > minValues[mapped[0]]) {
+                    continue;
+                }
+
+                if (mapped[1] > maxValues[mapped[0]]) {
+                    maxValues[mapped[0]] = mapped[1];
+                    graphics.setColor(Color.GREEN);
+                }
+
+                if (mapped[1] < minValues[mapped[0]]) {
+                    minValues[mapped[0]] = mapped[1];
+                    graphics.setColor(Color.RED);
+                }
+
+                if (j > 0) {
+                    drawLine(graphics, mapped, points.get(j - 1));
+                    //drawLine(graphics, mapped, points.get(j - 1));
+                }
+            }
+        }
+        repaint();
+
+//        JFrame resultFrame = new JFrame("Graph Result");
+//        resultFrame.setSize(800, 600);
+//        resultFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+//        resultFrame.add(new JPanel() {
+//            @Override
+//            protected void paintComponent(Graphics g) {
+//                super.paintComponent(g);
+//                g.drawImage(pixbuf, 0, 0, getWidth(), getHeight(), this);
+//            }
+//        });
+//        resultFrame.setVisible(true);
+    }
+    private void drawLine(Graphics graphics, int[] p1, int[] p2) {
+        graphics.drawLine(p1[0], p1[1], p2[0], p2[1]);
+    }
+
+    private float[] multiplyVector(float[] vector, float[][] matrix) {
+        float[] tmp = new float[]{vector[0],vector[1],vector[2],1};
+        float[] result = new float[MATRIX_SIZE];
+        for (int i = 0; i < MATRIX_SIZE; ++i) {
+            for (int j = 0; j < MATRIX_SIZE; ++j) {
+                result[i] += matrix[i][j] * tmp[j];
+            }
+        }
+        return result;
+    }
+
+    private float[][] multiplyMatrices(float[][] matrix1, float[][] matrix2) {
+        float[][] result = new float[MATRIX_SIZE][MATRIX_SIZE];
+        for (int i = 0; i < MATRIX_SIZE; ++i) {
+            for (int j = 0; j < MATRIX_SIZE; ++j) {
+                for (int k = 0; k < MATRIX_SIZE; ++k) {
+                    result[i][j] += matrix1[i][k] * matrix2[k][j];
+                }
+            }
+        }
+        return result;
+    }
+
+    private int[] mapToScreen(float[] point, int screenWidth, int screenHeight) {
+        float kx = screenWidth / 4.0f;
+        float ky = screenHeight / 4.0f;
+        int x = (int) ((point[0]) * kx + screenWidth / 2);
+        int y = (int) ((point[1]) * ky + screenHeight / 2);
+        return new int[]{x, y};
+    }
+}
\ No newline at end of file

src/Main.java

+import javax.swing.*;
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.util.Arrays;
+import java.util.Vector;
+
+
+
+public class Main {
+
+    public static void main(String[] args) {
+        SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                JFrame frame = new JFrame("Graph Drawer");
+                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+                frame.setSize(800, 600);
+                frame.add(new GraphDrawer(), BorderLayout.CENTER);
+                frame.setVisible(true);
+            }
+        });
+
+    }
+}