app/src/main/java/com/ea/groupbuilder/classSpaceN.java - master - nea/androidGroupBuilder

app/src/main/java/com/ea/groupbuilder/classSpaceN.java
371 строка14 KB
Группа Автоморфизмов отлажено 23_04_2026
23 апр 2026, 17:08
23 апр 2026, 17:084513276
package com.ea.groupbuilder;

import static com.ea.groupbuilder.SurfaceHolderActivity.setkaOs;
import static java.lang.Math.PI;
import static java.lang.Math.acos;
import static java.lang.Math.cos;
import static java.lang.Math.sin;
import static java.lang.Math.sqrt;

import android.graphics.Canvas;
import android.graphics.Paint;
import android.opengl.Matrix;
import android.util.Log;

public class classSpaceN extends classImages {
    // RnActivity использует
    final static private String TAG = "GRUGRA_SPACE";
    final static private boolean DISPLAYLOG = false;
    private final float beginArc = 40f;
    private final float beginVuctor[] = {0f, 1f / (float) sqrt(2f), 1f / (float) sqrt(2f)};


    final private int dimn;   // размерность


    private final float[] work2Matrix = new float[16]; // рабочие матрицы
    private final float[] workMatrix = new float[16];   // раб матрица
    public float[] modelRotate = new float[16]; // добавленное вращение через Touch

    private int movO1 = 0, movO2 = 1;    // индексы осей движения
    private double axisSt[][];    // начальная матрица проектирования на D2;
    public double movZnak = 1.;     // как перебирать оси вращения

    classSpaceN(int dimension) {
        dimn = dimension;
        Matrix.setIdentityM(modelRotate, 0);
        axisX = new double[2][dimn];    // матрица проектирования на D2
        axisSt = new double[2][dimn];   // начальная построенная матрица

        movO1 = dimn / 2;   // выбираю оси вращения
        if (movO1 < dimn - 2) {
            movO2 = dimn - 1;
        } else {
            movO1 = dimn - 2;
            movO2 = dimn - 1;
        }

        if (DISPLAYLOG)
            Log.d(TAG, "classSpaceN dimension = " + dimension + " movO1 = " + movO1 + " mov02 = " + movO2 );

    }


    public void f_TouchMove(double xs, double ys, double xt, double yt, float xdpi, float ydpi) {
        // устанавливает modelRotate
        // 		(OldX, OldY, NowX, NowY) - поворот вокруг оси перпендикулярной движению пальца
        final float h2 = 25.f / (xdpi + ydpi);
        final double dl = Math.sqrt((xt - xs) * (xt - xs) + (yt - ys) * (yt - ys));
        if (dl == 0.d) return;
        final double ox = (ys - yt) / dl, oz = 0d, oy = (xs - xt) / dl; // перпендикуляр к плоскости, в которой идет вращение
        final double ug = 5. * Math.atan(dl * h2) / dimn; //  (renderer.near)); // / Math.PI;
//        if (DISPLAYLOG)
//            Log.d(TAG, "f_TouchMove ug= " + ug + " xt,yt= "+ xt+ " "+ yt + " xs="+xs+" " + ys+" x1="+x1 + " "+ y1 + " "+ z1 + " ug="+ ug+ " xdpi="+xdpi+ " h2="+h2 + " dl="+dl);

//        f_printMatr("A");

        Matrix.setIdentityM(work2Matrix, 0);
        Matrix.rotateM(work2Matrix, 0, (float) ug, (float) ox, (float) oy, (float) oz);
        System.arraycopy(modelRotate, 0, workMatrix, 0, 16);
        Matrix.multiplyMM(modelRotate, 0, work2Matrix, 0, workMatrix, 0);

//        if (DISPLAYLOG)
//                f_printMatr("B");
    }

    private void f_printMatr(String txt) {
// печать modelRotate
        for (int j = 0; j < 4; j++) {
/*            Log.e(TAG, "f_TouchMove modelRotate[j] " + txt + " j= " + j + " " + modelRotate[j]
                    + " " + modelRotate[j + 4]
                    + " " + modelRotate[j + 8]
                    + " " + modelRotate[j + 12]);

 */
        }
    }
    volatile public double movAngle = 0.00;  // угол

    public void f_move() {
        // движение по осям movO1, movO2
        // оси меняю после круга
        final double PRIR_UGLA = 0.3 * PI / 200. + 0.8 * Math.abs(Math.sin(movAngle) * PI / 200.);

        double x1[] = new double[dimn], y1[]  = new double[dimn];

        movAngle += PRIR_UGLA;

        double cs = cos(movAngle), sn = sin(movAngle);
        int ff = 0, j;

        if ( (1. - cs) < sin(0.2 * PRIR_UGLA) && movAngle > 4. ) {  // // смена осей movO1, movO2 - круг сделан
/*            Log.e(TAG, " f_move ff = " + ff );
            for (j = 0; j < dimn; j++) {
                x1[j] = axisX[0][j];
                y1[j] = axisX[1][j];
                Log.e(TAG, " f_move 0 j = " + j + " x1 = " + x1[j] + " y1 = " + y1[j] + " movO1 = " + movO1 + " movO2 = " + movO2 + " movAngle = " + movAngle + " cs = " + cs + " sn = " + sn );
            }
*/
            do {
                if ((movO1 == dimn - 1 && movO2 == dimn - 1) || (movO1 == 0 && movO2 == 0))
                    movZnak *= -1.;

                movO2 += movZnak;
                if (movO2 > dimn - 1 || movO2 < 0) {
                    movO1 += movZnak;
                    movO2 = 0;
                }
                if (movO1 > dimn - 1 || movO1 < 0) {
                    movO1 = 0;
                }
            } while (movO1 == movO2);


            movAngle = 0.;
            ff = 1;
        }

        cs = cos(movAngle);
        sn = sin(movAngle);

/*
        if (ff > 0) {
            Log.e(TAG, " f_move movO1= " + movO1 + " movO2 = " + movO2 + " movZnak = " + movZnak + " movAng = " + movAngle + " 2PI = " + (2. * PI));
            for (j = 0; j < dimn; j++) {
                x1[j] = axisX[0][j];
                y1[j] = axisX[1][j];
                Log.e(TAG, " f_move A j = " + j + " x1 = " + x1[j] + " y1 = " + y1[j] + " cs = " + cs + " sn = " + sn );
            }
        }
*/

        axisX[0][movO1] = cs * axisSt[0][movO1] - sn * axisSt[0][movO2];
        axisX[1][movO1] = cs * axisSt[1][movO1] - sn * axisSt[1][movO2];
        axisX[0][movO2] = -sn * axisSt[0][movO1] + cs * axisSt[0][movO2];
        axisX[1][movO2] = -sn * axisSt[1][movO1] + cs * axisSt[1][movO2];

/*
        if (ff > 0) {
            for (j = 0; j < dimn; j++) {
                Log.e(TAG, " f_move D j = " + j + " x1 = "+ x1[j] + " =? " + axisX[0][j] + " y1 = " + y1[j] + " =? " + axisX[1][j] + " movAngle = " + movAngle);
                Log.e(TAG, " f_move D = " + (x1[j] - axisX[0][j]) + " " + (y1[j] - axisX[1][j])  + " PRIR_UGLA = " + PRIR_UGLA);
            }
        }
*/
        ff = 0;

    }

    public void f_setAxes(int beginFlag) {
        // устанавливает матрицу поворота axisSt по modelRotate
        // beginFlag = 0 - нач устновка на , -1 - сброс на центр,  = 1 - поворот
        int j, k;
        double  w3 = 0.,  // длина
                w4 = 0., wk = 0.;

        if (beginFlag <= 0) {

            for (j = 0; j < dimn; j++) {
                axisX[0][j] = cos(2. * PI * j / (double) dimn);  // x оси j
                axisX[1][j] = sin(2. * PI * j / (double) dimn);  // Y оси j
//                Log.e(TAG, " axisST[0][j] j= " + j + " x= " + axisX[0][j] + " y= " + axisX[1][j] + " arg= " + (2. * PI * j / (double) dimn) );
            }

            // нормировка

            for (k = 0; k < 2; k++) {
                w3 = 0.;
                for (j = 0; j < dimn; j++)
                    w3 += (axisX[k][j] * axisX[k][j]);

                wk = sqrt(w3);
//
//                Log.e(TAG, " k= " + k + " sqrt(w3)= " + sqrt(w3) + " wl = " + wl );
//                Log.e(TAG, " k= " + k +  " 1/wl =  " + (1. / wl));

                for (j = 0; j < dimn; j++) {
                    axisX[k][j] /= wk;
                }
            }

            Matrix.setIdentityM(work2Matrix, 0);
            for (k = 0; k < 2; k++) // первые 3 оси - инициализация modelRotate
                for (j = 0; j < 3; j++)
                    modelRotate[4 * k + j] = (float) axisX[k][j];  // 3D
//            f_printMatr("f_setAxes beginFlag=" + beginFlag);

            if (beginFlag == 0) {   //  нач усстановка
// повернуть немного
                Matrix.setIdentityM(work2Matrix, 0);
                Matrix.rotateM(work2Matrix, 0, beginArc, beginVuctor[0], beginVuctor[1], beginVuctor[2]);  // вектор вокруг которого делается поворот
                System.arraycopy(modelRotate, 0, workMatrix, 0, 16);
                Matrix.multiplyMM(modelRotate, 0, work2Matrix, 0, workMatrix, 0);
            }
        }

        // чистый поворот, modelRotate установлена в f_TouchMove
        for (k = 0; k < 2; k++) // первые 3 оси
            for (j = 0; j < 3; j++) {
                axisX[k][j] = modelRotate[4 * k + j];  // 3D
            }


//        f_printMatr("f_setAxes end =" + beginFlag);

           for (j = 0; j < dimn; j++) {
               axisSt[0][j] = axisX[0][j];
               axisSt[1][j] = axisX[1][j];
//               Log.e(TAG, "f_setAxes j= " + j + " axisST = " + axisSt[0][j] + " " + axisSt[1][j]);
           }


        if (DISPLAYLOG) {
           w3 = w4 = 0;
           double w = 0.;
           for (j = 0; j < dimn; j++) {
               w3 += axisX[0][j] * axisX[0][j];
               w4 += axisX[1][j] * axisX[1][j];
               w += axisX[0][j] * axisX[1][j];
           }

//           Log.e(TAG, "f_setAxes " + " w = " + w + " " + w3 + " " + w4);

       }

    }

    //     private int nnn = 0;
    public float[] f_setVector(int[] sub, int kak) {
        // по подстановке sub выводит координаты точки на канвасе
        // kak = 0 - вывод точек как есть: (1, 2, 3) -> x=1, y=2, z=3
        // kak = 1 - вывод точек -1: (1, 2, 3) -> x=0, y=1, z=2

        int j, k;
        float vec0[] = {0f, 0f};

        for (k = 0; k < 2; k++) {
            for (j = 0; j < dimn; j++) {
                vec0[k] += (sub[j] - (kak == 0 ? 0. : 1.)) * axisX[k][j];
            }
        }

        for (k = 0; k < 2; k++) {
            vec0[k] *= koeffX[k];
            vec0[k] += dx[k];
        }
//        if (nnn < 20)
//            Log.e(TAG, "f_setVector sub = " + sub[0] + " "  + sub[1] + " "  + sub[2] // + " "  + sub[3] //  + " "  + sub[4]
//                    + " vec0 = " + vec0[0] + " " + vec0[1] + "  kak = " + kak);

//        nnn += 1;

        return vec0;
    }

    public void f_putAxes(Canvas canvas, Paint paint, float startX, float startY) {
        // вывод осей на canvas

        int os0[] = new int[dimn],
                os1[] = new int[dimn],
                subs0[] = new int[dimn];
        int k, kk, j;

        for (k = 0; k < dimn; k++)
            os0[k] = os1[k] = 0;

        float v0[] = f_setVector(os0, 0);


        for (k = 0; k < dimn; k++) {    // выводит базисные векторы
            os1[k] = 1;
            float v1[] = f_setVector(os1, 0);
            paint.setStrokeWidth(1);
            canvas.drawLine(v0[0] + startX, v0[1] + startY, v1[0] + startX, v1[1] + startY, paint);
            canvas.drawText(" " + (k + 1), v1[0] + startX, v1[1] + startY, paint);
/*            if (DISPLAYLOG)
                Log.e(TAG, "f_putAxes k = " + k +
                        " os1 = " + os1[0] + " " + os1[1] + " " + os1[2] +
                        " v0 = " + v0[0] + " " + v0[1] + " " + " v1 = " + v1[0] + " " + v1[1]);

 */
            os1[k] = 0;

// вывод точек на осях
            for (j = 0; j < dimn; j++) {
                for (kk = 0; kk < dimn; kk++)
                    subs0[kk] = 0;
            }
            paint.setStrokeWidth(2);
            for (j = 2; j <= dimn; j++) {
                subs0[k] = j;
                v1 = f_setVector(subs0, 0);
                canvas.drawPoint(v1[0] + startX, v1[1] + startY, paint);
            }
        }

    }

    int kkk = 0;

    public void f_putSetka(Canvas canvas, Paint paint, float startX, float startY) {
        // Вывод сетки на canvas = все целочисленные точки Rn
        int subs0[] = new int[dimn];
        int k, j;

/*        if (kkk > 7)
            return;
        kkk++;
*/

        for (j = 0; j < dimn; j++) {
            for (k = 0; k < dimn; k++)
                subs0[k] = 0;

            subs0[0] = setkaOs.contains(0) ? j : 0;
            f_putSetkaRec(subs0, 1, canvas, paint, startX, startY);
        }

    }

    private void f_putSetkaRec(int subs0[], int numpos, Canvas canvas, Paint paint, float startX, float startY) {
// рекурсия для получения сетки
        if (setkaOs.size() < 1)
            return;
        int j;

        if (setkaOs.contains(numpos)) {

            for (j = 0; j < dimn; j++) {
//                for (k = numpos; k < dimn; k++)
//                    subs0[k] = 0;

                subs0[numpos] = setkaOs.contains(numpos) ? j : 0;

                if (numpos == dimn - 1) {
                    float v1[] = f_setVector(subs0, 0);
                    canvas.drawPoint(v1[0] + startX, v1[1] + startY, paint);
/*                    if (DISPLAYLOG)
                        Log.e(TAG, "f_putSetkaRec  numpos = " + numpos + " j= " + j +
                                " subs0 = " + subs0[0] + " " + subs0[1] + " " + subs0[2] +
                                " v1 = " + v1[0] + " " + v1[1]);
*/
                } else {
                    f_putSetkaRec(subs0, numpos + 1, canvas, paint, startX, startY);
                }
            }
        } else {
            if (numpos == dimn - 1) {
                float v1[] = f_setVector(subs0, 0);
                canvas.drawPoint(v1[0] + startX, v1[1] + startY, paint);

            } else {
//                for (k = numpos; k < dimn; k++)
//                    subs0[k] = 0;
                f_putSetkaRec(subs0, numpos + 1, canvas, paint, startX, startY);
            }
        }
    }


}
//=======================