> ...

janhardo — Tue, 18 Aug 2026 15:50:53 Z

restart;

UHG := module()
    option package;

    export BilinearForm,
           Quadrance,
           GramMatrixUHG,
           NormalizePoints,
           ClassifyPoints,
           FindOddPoint,
           ScalePoints,
           PreparePoints,
           NormalizePrepared,
           DetectGeometry,
           ShowGeometry,
           Distance,
           ProjectiveQuadrance,
           PointLocation,

           LineFromPoints,
           PointFromLines,
           DualPoint,
           DualLine,
           Spread,

           Midpoints,
           Midlines,
           Syndpoints,
           Sydlines,
           SidePoints,
           Sideliness,
           OppositePoints,
           Oppositelines,

           Circumlines,
           Circumcenters,
           Medians,
           Centroids,
           DoubleTriangle,
           CircumDualPoints,
           TangentLines,
           SoundPoints,
           JayLines,
           WrenLines,
           CircumJayPoints,
           CircumWrenPoints,
           JayWrenPoints,
           T_Axis,
           U_Axis,
           V_Axis,
           Circumcircles,
           TwinCircumcircles,
           SoundConics,

           PlotAll2D,
           PlotAll3D,
           PlotCircumlinear,
           IntersectionPlot,
           PlotUnitTriangle,
           PlotConicOnUnitTriangle,
           BuildConicFromCanonical,
           PlotUnitTriangleWithConic3D,
           PlotStepsArray,
           PlotSteps,
           PlotHierarchy,

           GetInverseTransform,
           TransformConic,
           PlotConic,

           ClassifyTriangle,
           Info;

    local Jdefault;

    Jdefault := Matrix([[1,0,0],[0,1,0],[0,0,-1]]);

    # ------------------------------------------------------------
    # 1. Basisalgebra (volledig)
    # ------------------------------------------------------------
    DetectGeometry := proc(J::Matrix := Jdefault)
        local i, j, isDiag, diag, eigvals, pos, neg;
        isDiag := true;
        for i from 1 to 3 do
            for j from 1 to 3 do
                if i <> j and J[i,j] <> 0 then
                    isDiag := false;
                    break;
                end if;
            end do;
            if not isDiag then break; end if;
        end do;

        if isDiag then
            diag := [seq(J[i,i], i=1..3)];
            pos := nops(select(x -> x > 0, diag));
            neg := nops(select(x -> x < 0, diag));
        else
            eigvals := LinearAlgebra:-Eigenvalues(J);
            eigvals := map(simplify, eigvals);
            pos := nops(select(x -> x > 0, eigvals));
            neg := nops(select(x -> x < 0, eigvals));
        end if;

        if pos = 3 then
            return "Euclidean";
        elif pos = 2 and neg = 1 then
            return "Hyperbolic";
        elif pos = 1 and neg = 2 then
            return "Elliptic";
        else
            return "Unknown";
        end if;
    end proc;

    ShowGeometry := proc(J::Matrix := Jdefault)
        local geom;
        geom := DetectGeometry(J);
        printf("Detected geometry: %s\n", geom);
        printf("Metric matrix J:\n");
        print(J);
        return geom;
    end proc;

    BilinearForm := proc(u, v, J::Matrix := Jdefault)
        local U, V;
        U := Vector[row](u);
        V := Vector[row](v);
        return simplify((U . J) . (V^%T));
    end proc;

    Quadrance := proc(v, J::Matrix := Jdefault)
        return BilinearForm(v, v, J);
    end proc;

    GramMatrixUHG := proc(A::Matrix, J::Matrix := Jdefault)
        return simplify(A . J . LinearAlgebra:-Transpose(A));
    end proc;

    ClassifyPoints := proc(A::Matrix, J::Matrix := Jdefault)
        local i, Q, expr;
        Q := [seq(Quadrance(A[i], J), i=1..LinearAlgebra:-RowDimension(A))];
        return map(proc(expr)
            local val;
            if simplify(expr) = 0 then
                return 0;
            end if;
            val := evalf(expr);
            if abs(val) < 1e-10 then
                return 0;
            else
                return sign(val);
            end if;
        end proc, Q);
    end proc;

    ScalePoints := proc(A::Matrix, J::Matrix := Jdefault, oddIndex::integer := 0)
        local Q, lambdas, i, N;
        Q := [seq(Quadrance(A[i], J), i=1..3)];
        if member(0, Q) then
            return Matrix(A);
        end if;
        if oddIndex = 0 then
            lambdas := [1, sqrt(Q[1]/Q[2]), sqrt(Q[1]/Q[3])];
        else
            lambdas := [1,1,1];
            for i from 1 to 3 do
                if i <> oddIndex then
                    lambdas[i] := sqrt(-Q[oddIndex]/Q[i]);
                end if;
            end do;
        end if;
        N := Matrix(3,3);
        for i from 1 to 3 do
            N[i] := lambdas[i] * A[i];
        end do;
        return N;
    end proc;

    FindOddPoint := proc(A::Matrix, J::Matrix := Jdefault)
        local signs, i, oddIdx;
        signs := ClassifyPoints(A, J);
        if nops({signs[]}) = 1 then
            return 0;
        end if;
        for i from 1 to 3 do
            if signs[i] <> signs[(i mod 3)+1] and signs[i] <> signs[((i+1) mod 3)+1] then
                oddIdx := i;
                break;
            end if;
        end do;
        return oddIdx;
    end proc;

    PreparePoints := proc(A::Matrix, J::Matrix := Jdefault)
        local oddIdx, N, orderedN;
        oddIdx := FindOddPoint(A, J);
        N := ScalePoints(A, J, oddIdx);
        if oddIdx = 0 then
            orderedN := N;
        elif oddIdx = 1 then
            orderedN := < N[2], N[3], N[1] >;
        elif oddIdx = 2 then
            orderedN := < N[1], N[3], N[2] >;
        else
            orderedN := N;
        end if;
        return orderedN;
    end proc;

    NormalizePoints := proc(A::Matrix, J::Matrix := Jdefault)
        local G, Q, D, C, eps, a, b, c, i, hasIdeal, triType;
        G := GramMatrixUHG(A, J);
        Q := [seq(G[i,i], i=1..LinearAlgebra:-RowDimension(G))];
        hasIdeal := false;
        D := Matrix(LinearAlgebra:-RowDimension(G), LinearAlgebra:-RowDimension(G));
        for i from 1 to LinearAlgebra:-RowDimension(G) do
            if Q[i] = 0 then
                D[i,i] := 1;
                hasIdeal := true;
            else
                D[i,i] := 1/sqrt(abs(Q[i]));
            end if;
        end do;
        C := simplify(D . G . D);
        if C[3,3] <> 0 then
            eps := sign(evalf(C[3,3]));
            if eps = -1 then
                C := -C;
                eps := 1;
            end if;
        else
            eps := 0;
        end if;
        a := C[1,2];
        b := C[1,3];
        c := C[2,3];
        triType := ClassifyTriangle(A, J);
        return table([
            "MetricMatrix"    = J,
            "GramMatrix"      = G,
            "Quadrances"      = Q,
            "Normalizer"      = D,
            "CanonicalMatrix" = C,
            "a"               = a,
            "b"               = b,
            "c"               = c,
            "epsilon"         = eps,
            "Geometry"        = DetectGeometry(J),
            "has_ideal"       = hasIdeal,
            "TriangleType"    = triType
        ]);
    end proc;

    NormalizePrepared := proc(A::Matrix, J::Matrix := Jdefault)
        local N, res;
        N := PreparePoints(A, J);
        res := NormalizePoints(N, J);
        if res["has_ideal"] then
            printf("Warning: this triangle contains ideal points; NormalizePrepared may be inappropriate.\n");
        end if;
        printf("Geometry: %s\n", res["Geometry"]);
        printf("Triangle location: %s\n", res["TriangleType"]);
        return res;
    end proc;

    Distance := proc(C::Matrix, i::integer, j::integer, J::Matrix := Jdefault)
        local di, dj, val, geom;
        di := C[i,i];
        dj := C[j,j];
        val := C[i,j];
        geom := DetectGeometry(J);

        if geom = "Hyperbolic" then
            if di = 0 or dj = 0 then
                return infinity;
            elif di = 1 and dj = 1 then
                return arccosh(abs(val));
            elif di = -1 and dj = -1 then
                return arccosh(abs(val));
            else
                return arcsinh(abs(val));
            end if;
        elif geom = "Euclidean" then
            if di = 0 or dj = 0 then
                return infinity;
            else
                return arccos(val);
            end if;
        elif geom = "Elliptic" then
            if di = 0 or dj = 0 then
                return infinity;
            else
                return arccos(val);
            end if;
        else
            error "Unknown geometry for distance calculation";
        end if;
    end proc;

    GetInverseTransform := proc(A::Matrix, J::Matrix := Jdefault)
        local N, invN;
        N := PreparePoints(A, J);
        invN := LinearAlgebra:-MatrixInverse(N);
        return invN;
    end proc;

    TransformConic := proc(conicMatrix::Matrix, invN::Matrix)
        local M;
        M := simplify(invN^%T . conicMatrix . invN);
        return M;
    end proc;

    PlotConic := proc(conicMatrix::Matrix, A::Matrix, J::Matrix := Jdefault,
                      kleur::string := "red", dikte::integer := 1,
                      bereik::numeric := 2.0)
        local invN, M, expr, p, cirkel;
        invN := GetInverseTransform(A, J);
        M := TransformConic(conicMatrix, invN);
        expr := simplify(<x,y,1> . M . <x,y,1>);
        p := plots:-implicitplot(expr, x=-bereik..bereik, y=-bereik..bereik,
                                 color=kleur, thickness=dikte, grid=[50,50],
                                 legend="Transformed conic");
        cirkel := plots:-implicitplot(x^2+y^2=1, x=-bereik..bereik, y=-bereik..bereik,
                                      color=black, scaling=constrained, grid=[50,50],
                                      legend="Null circle");
        return plots:-display(cirkel, p, title="Conic in Klein model");
    end proc;

    # ------------------------------------------------------------
    # 3. Meetkundige functies
    # ------------------------------------------------------------
    ProjectiveQuadrance := proc(u, v, J::Matrix := Jdefault)
        local Qu, Qv, B;
        Qu := Quadrance(u, J);
        Qv := Quadrance(v, J);
        if Qu = 0 or Qv = 0 then
            error "One of the points is ideal (Q=0)";
        end if;
        B := BilinearForm(u, v, J);
        return simplify(B^2 / (Qu * Qv));
    end proc;

    PointLocation := proc(v, J::Matrix := Jdefault)
        local Q := Quadrance(v, J);
        if Q < 0 then return "inside the null circle";
        elif Q = 0 then return "on the null circle";
        else return "outside the null circle"; end if;
    end proc;

    LineFromPoints := proc(p::Vector, q::Vector)
        return LinearAlgebra:-CrossProduct(p, q);
    end proc;

    PointFromLines := proc(L::Vector, M::Vector)
        return LinearAlgebra:-CrossProduct(L, M);
    end proc;

    DualPoint := proc(p::Vector, C::Matrix)
        return simplify(C . p);
    end proc;

    DualLine := proc(L::Vector, C::Matrix)
        local Jinv;
        Jinv := LinearAlgebra:-Adjoint(C);
        return simplify(Jinv . L);
    end proc;

    Spread := proc(u, v, J::Matrix := Jdefault)
        local Qu, Qv, B;
        Qu := Quadrance(u, J);
        Qv := Quadrance(v, J);
        if Qu = 0 or Qv = 0 then
            error "One of the vectors is null";
        end if;
        B := BilinearForm(u, v, J);
        return simplify(1 - B^2/(Qu*Qv));
    end proc;

    Midpoints := proc(A::Matrix, i::integer, j::integer, J::Matrix := Jdefault)
        local nA, pi, pj, m1, m2, Q1, Q2;
        nA := NormalizePoints(A, J)["Normalizer"] . A;
        pi := nA[i];
        pj := nA[j];
        m1 := pi + pj;
        Q1 := Quadrance(m1, J);
        if Q1 = 0 then return []; end if;
        m1 := m1 / sqrt(abs(Q1));
        m2 := pi - pj;
        Q2 := Quadrance(m2, J);
        if Q2 = 0 then return []; end if;
        m2 := m2 / sqrt(abs(Q2));
        return [m1, m2];
    end proc;

    Midlines := proc(A::Matrix, i::integer, j::integer, J::Matrix := Jdefault)
        local m, C;
        C := NormalizePoints(A, J)["CanonicalMatrix"];
        m := Midpoints(A, i, j, J);
        if m = [] then return []; end if;
        return [DualPoint(m[1], C), DualPoint(m[2], C)];
    end proc;

    Syndpoints := proc(A::Matrix, i::integer, j::integer, J::Matrix := Jdefault)
        local nA, pi, pj, s1, s2, Q1, Q2;
        nA := NormalizePoints(A, J)["Normalizer"] . A;
        pi := nA[i];
        pj := nA[j];
        s1 := pi + pj;
        Q1 := Quadrance(s1, J);
        if Q1 = 0 then return []; end if;
        s1 := s1 / sqrt(abs(Q1));
        s2 := pi - pj;
        Q2 := Quadrance(s2, J);
        if Q2 = 0 then return []; end if;
        s2 := s2 / sqrt(abs(Q2));
        return [s1, s2];
    end proc;

    Sydlines := proc(A::Matrix, i::integer, j::integer, J::Matrix := Jdefault)
        local s, C;
        C := NormalizePoints(A, J)["CanonicalMatrix"];
        s := Syndpoints(A, i, j, J);
        if s = [] then return []; end if;
        return [DualPoint(s[1], C), DualPoint(s[2], C)];
    end proc;

    SidePoints := proc(A::Matrix, i::integer, J::Matrix := Jdefault)
        local j, k;
        if i = 1 then j:=2; k:=3;
        elif i = 2 then j:=1; k:=3;
        else j:=1; k:=2; end if;
        return Midpoints(A, j, k, J);
    end proc;

    Sideliness := proc(A::Matrix, i::integer, J::Matrix := Jdefault)
        local pts;
        pts := SidePoints(A, i, J);
        if pts = [] then return []; end if;
        return [DualLine(pts[1], NormalizePoints(A, J)["CanonicalMatrix"]),
                DualLine(pts[2], NormalizePoints(A, J)["CanonicalMatrix"])];
    end proc;

    OppositePoints := proc(A::Matrix, i::integer, J::Matrix := Jdefault)
        local j, k;
        if i = 1 then j:=2; k:=3;
        elif i = 2 then j:=1; k:=3;
        else j:=1; k:=2; end if;
        return [A[j], A[k]];
    end proc;

    Oppositelines := proc(A::Matrix, i::integer, J::Matrix := Jdefault)
        local pts;
        pts := OppositePoints(A, i, J);
        return [DualPoint(pts[1], NormalizePoints(A, J)["CanonicalMatrix"]),
                DualPoint(pts[2], NormalizePoints(A, J)["CanonicalMatrix"])];
    end proc;

    Circumlines := proc(C::Matrix)
        return [
            <1, 1, 1>,
            <-1, 1, 1>,
            <1, -1, 1>,
            <1, 1, -1>
        ];
    end proc;

    Circumcenters := proc(C::Matrix)
        local lines, centers, i, Cadj;
        Cadj := LinearAlgebra:-Adjoint(C);
        lines := Circumlines(C);
        centers := [];
        for i from 1 to 4 do
            centers := [op(centers), simplify(Cadj . lines[i])];
        end do;
        return centers;
    end proc;

    Medians := proc(C::Matrix)
        return [
            <0, 1, -1>,
            <-1, 0, 1>,
            <1, -1, 0>
        ];
    end proc;

    Centroids := proc(C::Matrix)
        return [
            <1, 1, 1>,
            <1, -1, -1>,
            <-1, 1, -1>,
            <-1, -1, 1>
        ];
    end proc;

    DoubleTriangle := proc(C::Matrix)
        return [<0,1,1>, <1,0,1>, <1,1,0>];
    end proc;

    CircumDualPoints := proc(C::Matrix)
        local a, b, c, eps, A1, A2, A3, C0, C1, C2, C3, p, i, j;
        a := C[1,2]; b := C[1,3]; c := C[2,3]; eps := C[3,3];
        A1 := <1, a, b>;
        A2 := <a, 1, c>;
        A3 := <b, c, eps>;
        C0 := <1, 1, 1>; C1 := <-1, 1, 1>; C2 := <1, -1, 1>; C3 := <1, 1, -1>;
        local meet := (L,M) -> LinearAlgebra:-CrossProduct(L,M);
        p := Matrix(3,4);
        p[1,1] := meet(A1,C0); p[1,2] := meet(A1,C1); p[1,3] := meet(A1,C2); p[1,4] := meet(A1,C3);
        p[2,1] := meet(A2,C0); p[2,2] := meet(A2,C1); p[2,3] := meet(A2,C2); p[2,4] := meet(A2,C3);
        p[3,1] := meet(A3,C0); p[3,2] := meet(A3,C1); p[3,3] := meet(A3,C2); p[3,4] := meet(A3,C3);
        return p;
    end proc;

    TangentLines := proc(C::Matrix)
        local a, b, c, eps, p, T, i, j;
        a := C[1,2]; b := C[1,3]; c := C[2,3]; eps := C[3,3];
        p := CircumDualPoints(C);
        T := Matrix(3,4);
        for i from 1 to 3 do
            for j from 1 to 4 do
                if i = 1 then T[i,j] := LinearAlgebra:-CrossProduct(<1,0,0>, p[i,j]);
                elif i = 2 then T[i,j] := LinearAlgebra:-CrossProduct(<0,1,0>, p[i,j]);
                else T[i,j] := LinearAlgebra:-CrossProduct(<0,0,1>, p[i,j]); end if;
            end do;
        end do;
        return T;
    end proc;

    SoundPoints := proc(C::Matrix)
        local a, b, c, eps, T, L1, L2, L3, s, i, j;
        a := C[1,2]; b := C[1,3]; c := C[2,3]; eps := C[3,3];
        T := TangentLines(C);
        L1 := <1,0,0>; L2 := <0,1,0>; L3 := <0,0,1>;
        s := Matrix(3,4);
        for i from 1 to 3 do
            for j from 1 to 4 do
                if i = 1 then s[i,j] := LinearAlgebra:-CrossProduct(T[i,j], L1);
                elif i = 2 then s[i,j] := LinearAlgebra:-CrossProduct(T[i,j], L2);
                else s[i,j] := LinearAlgebra:-CrossProduct(T[i,j], L3); end if;
            end do;
        end do;
        return s;
    end proc;

    JayLines := proc(C::Matrix)
        local a, b, c, eps;
        a := C[1,2]; b := C[1,3]; c := C[2,3]; eps := C[3,3];
        return [
            < (a-1)*(b-1), (a-1)*(c-1), (c-1)*(b-1) >,
            < (a+1)*(b+1), (a+1)*(c-1), (c-1)*(b+1) >,
            < (a+1)*(b-1), (a+1)*(c+1), (c+1)*(b-1) >,
            < (a-1)*(b+1), (a-1)*(c+1), (c+1)*(b+1) >
        ];
    end proc;

    WrenLines := proc(C::Matrix)
        local a, b, c, eps;
        a := C[1,2]; b := C[1,3]; c := C[2,3]; eps := C[3,3];
        return [
            < (a+1)*(b+1), (a+1)*(c+1), (b+1)*(c+1) >,
            < (a-1)*(b-1), (c+1)*(a-1), (c+1)*(b-1) >,
            < (b+1)*(a-1), (a-1)*(c-1), (b+1)*(c-1) >,
            < (a+1)*(b-1), (a+1)*(c-1), (b-1)*(c-1) >
        ];
    end proc;

    CircumJayPoints := proc(C::Matrix)
        local J, Cline, t, i;
        J := JayLines(C);
        Cline := Circumlines(C);
        t := [];
        for i from 1 to 4 do
            t := [op(t), LinearAlgebra:-CrossProduct(Cline[i], J[i])];
        end do;
        return t;
    end proc;

    CircumWrenPoints := proc(C::Matrix)
        local W, Cline, u, i;
        W := WrenLines(C);
        Cline := Circumlines(C);
        u := [];
        for i from 1 to 4 do
            u := [op(u), LinearAlgebra:-CrossProduct(Cline[i], W[i])];
        end do;
        return u;
    end proc;

    JayWrenPoints := proc(C::Matrix)
        local J, W, v, i;
        J := JayLines(C);
        W := WrenLines(C);
        v := [];
        for i from 1 to 4 do
            v := [op(v), LinearAlgebra:-CrossProduct(J[i], W[i])];
        end do;
        return v;
    end proc;

    T_Axis := proc(C::Matrix)
        local a, b, c, eps;
        a := C[1,2]; b := C[1,3]; c := C[2,3]; eps := C[3,3];
        return < c + a*b, b + a*c, a + b*c >;
    end proc;

    U_Axis := proc(C::Matrix)
        local a, b, c, eps;
        a := C[1,2]; b := C[1,3]; c := C[2,3]; eps := C[3,3];
        return < a*b - c, a*c - b, b*c - a >;
    end proc;

    V_Axis := proc(C::Matrix)
        local a, b, c, eps;
        a := C[1,2]; b := C[1,3]; c := C[2,3]; eps := C[3,3];
        return < c*(b^2-1)*(a^2-1), b*(c^2-1)*(a^2-1), a*(c^2-1)*(b^2-1) >;
    end proc;

    Circumcircles := proc(C::Matrix)
        local a, b, c, eps;
        a := C[1,2]; b := C[1,3]; c := C[2,3]; eps := C[3,3];
        return [
            (1-eps)*(x^2+y^2) + 2*(a-eps)*x*y + 2*(b-eps)*x*z + 2*(c-eps)*y*z,
            (1-eps)*(x^2+y^2) + 2*(a+eps)*x*y + 2*(b+eps)*x*z + 2*(c-eps)*y*z,
            (1-eps)*(x^2+y^2) + 2*(a+eps)*x*y + 2*(b-eps)*x*z + 2*(c+eps)*y*z,
            (1-eps)*(x^2+y^2) + 2*(a-eps)*x*y + 2*(b+eps)*x*z + 2*(c+eps)*y*z
        ];
    end proc;

    TwinCircumcircles := proc(C::Matrix)
        local a, b, c, eps;
        a := C[1,2]; b := C[1,3]; c := C[2,3]; eps := C[3,3];
        return [
            (1+eps)*(x^2+y^2) + 2*eps*z^2 + 2*(a+eps)*x*y + 2*(b+eps)*x*z + 2*(c+eps)*y*z,
            (1+eps)*(x^2+y^2) + 2*eps*z^2 + 2*(a-eps)*x*y + 2*(b-eps)*x*z + 2*(c+eps)*y*z,
            (1+eps)*(x^2+y^2) + 2*eps*z^2 + 2*(a-eps)*x*y + 2*(b+eps)*x*z + 2*(c-eps)*y*z,
            (1+eps)*(x^2+y^2) + 2*eps*z^2 + 2*(a+eps)*x*y + 2*(b-eps)*x*z + 2*(c-eps)*y*z
        ];
    end proc;

    SoundConics := proc(C::Matrix)
        local a, b, c, eps, K;
        a := C[1,2]; b := C[1,3]; c := C[2,3]; eps := C[3,3];
        K := [];
        K[1] := [
            (c+eps)*(b-eps)*(b^2-1)*(a^2-1),
            (c+eps)*(b-eps)*(c^2-1)*(a^2-1),
            (c+eps)*(b-eps)*(c^2-1)*(b^2-1),
            2*(a^2-1)*(b*c+1)*(b*eps - c*eps + b*c - 1),
            2*(c+eps)*(b-eps)*(b^2-1)*(a*c+1),
            2*(c+eps)*(b-eps)*(a*b+1)*(c^2-1)
        ];
        K[2] := [
            (b+eps)*(c+eps)*(b^2-1)*(a^2-1),
            (b+eps)*(c+eps)*(c^2-1)*(a^2-1),
            (b+eps)*(c+eps)*(c^2-1)*(b^2-1),
            2*(b*c-1)*(a^2-1)*(b*eps + c*eps + b*c + 1),
            2*(b+eps)*(c+eps)*(a*c-1)*(b^2-1),
            2*(b+eps)*(c+eps)*(a*b+1)*(c^2-1)
        ];
        K[3] := [
            (c+eps)*(b+eps)*(b^2-1)*(a^2-1),
            (c+eps)*(b+eps)*(c^2-1)*(a^2-1),
            (c+eps)*(b+eps)*(c^2-1)*(b^2-1),
            2*(b*c-1)*(b*eps + c*eps + b*c + 1)*(a^2-1),
            2*(c+eps)*(b+eps)*(a*c+1)*(b^2-1),
            2*(c+eps)*(b+eps)*(a*b-1)*(c^2-1)
        ];
        K[4] := [
            (c+eps)*(b-eps)*(b^2-1)*(a^2-1),
            (c+eps)*(b-eps)*(c^2-1)*(a^2-1),
            (c+eps)*(b-eps)*(c^2-1)*(b^2-1),
            2*(b*c+1)*(b*eps - c*eps + b*c - 1)*(a^2-1),
            2*(c+eps)*(b-eps)*(a*c-1)*(b^2-1),
            2*(c+eps)*(b-eps)*(a*b-1)*(c^2-1)
        ];
        return K;
    end proc;

    ClassifyTriangle := proc(A::Matrix, J::Matrix := Jdefault)
        local signs, neg, pos, zero;
        signs := ClassifyPoints(A, J);
        neg := nops(select(x -> x = -1, signs));
        pos := nops(select(x -> x = 1, signs));
        zero := nops(select(x -> x = 0, signs));
        if neg = 3 then
            return "All vertices inside the null circle";
        elif pos = 3 then
            return "All vertices outside the null circle";
        elif zero = 3 then
            return "All vertices on the null circle (ideal triangle)";
        else
            return sprintf("Mixed: %d inside, %d on circle, %d outside", neg, zero, pos);
        end if;
    end proc;

    # ------------------------------------------------------------
    # 4. Visualisatiefuncties
    # ------------------------------------------------------------

    # 4.1 PlotAll2D – met elements-parameter (Optie 2)
    PlotAll2D := proc(A::Matrix, J::Matrix, titel::string,
                  color_null::string := "black",
                  color_triangle::string := "green",
                  color_vertices::string := "red",
                  color_midpoints::string := "blue",
                  color_circumcenters::string := "magenta",
                  color_circumlines::string := "gray",
                  color_circumcircles::string := "red",
                  color_twin::string := "blue",
                  color_jay::string := "orange",
                  color_wren::string := "purple",
                  color_circumjay::string := "cyan",
                  color_circumwren::string := "gold",
                  color_jaywren::string := "yellow",
                  thickness_triangle::integer := 2,
                  size_vertices::integer := 20,
                  size_midpoints::integer := 15,
                  size_centers::integer := 20,
                  size_jaywren::integer := 15,
                  elements::list := ["all"])
    local res, C, m12, m23, m31, all_points, point_proj,
          CC, center_proj, CL, line_plots, circs, twins,
          circle_plots, J_lines, W_lines, t_pts, u_pts, v_pts,
          bereik, i, eq, eq_twin, cirkel, driehoek, hoekpunten,
          mid_plot, center_plot, j_plots, w_plots, t_proj, u_proj, v_proj,
          t_plot, u_plot, v_plot, xmin, xmax, ymin, ymax, margin,
          alle_xy, x_vals, y_vals, valid_proj, safe_project,
          p, c, mid_valid, first, tri_pts,
          plot_list;

    safe_project := proc(pt)
        if evalf(abs(pt[3])) < 1e-12 then
            return [undefined, undefined];
        else
            return [pt[1]/pt[3], pt[2]/pt[3]];
        end if;
    end proc;

    res := NormalizePoints(A, J);
    C := res["CanonicalMatrix"];

    m12 := Midpoints(A, 1, 2, J);
    m23 := Midpoints(A, 2, 3, J);
    m31 := Midpoints(A, 3, 1, J);
    all_points := [A[1], A[2], A[3]];
    if m12 <> [] then all_points := [op(all_points), m12[1], m12[2]]; end if;
    if m23 <> [] then all_points := [op(all_points), m23[1], m23[2]]; end if;
    if m31 <> [] then all_points := [op(all_points), m31[1], m31[2]]; end if;

    point_proj := [seq(safe_project(p), p in all_points)];

    CC := Circumcenters(C);
    center_proj := [seq(safe_project(c), c in CC)];

    valid_proj := [];
    for p in [op(point_proj), op(center_proj)] do
        if p[1] <> undefined then
            valid_proj := [op(valid_proj), p];
        end if;
    end do;
    if valid_proj = [] then
        xmin := -1.5; xmax := 1.5; ymin := -1.5; ymax := 1.5;
    else
        x_vals := [seq(valid_proj[i][1], i=1..nops(valid_proj))];
        y_vals := [seq(valid_proj[i][2], i=1..nops(valid_proj))];
        xmin := min(x_vals); xmax := max(x_vals);
        ymin := min(y_vals); ymax := max(y_vals);
    end if;
    margin := max(0.5, (max(xmax-xmin, ymax-ymin))*0.2);
    bereik := max(abs(xmin), abs(xmax), abs(ymin), abs(ymax)) + margin;
    bereik := max(bereik, 1.5);

    plot_list := [];

    # Debug: print elements ###################################################################JD
    printf("elements = %a\n", elements);

    # Nulcirkel
    if member("all", elements) or member("null", elements) then
        cirkel := plots:-implicitplot(x^2 + y^2 = 1, x=-bereik..bereik, y=-bereik..bereik,
                               color=color_null, scaling=constrained, grid=[50,50],
                               legend="Null circle");
        plot_list := [op(plot_list), cirkel];
    end if;

    # Driehoek
    if member("all", elements) or member("triangle", elements) then
        tri_pts := [point_proj[1], point_proj[2], point_proj[3], point_proj[1]];
        driehoek := plot(tri_pts, style=line, color=color_triangle, thickness=thickness_triangle,
                         legend="Triangle sides");
        plot_list := [op(plot_list), driehoek];
    end if;

    # Hoekpunten
    if member("all", elements) or member("vertices", elements) then
        hoekpunten := plots:-pointplot(point_proj[1..3], symbol=solidcircle, symbolsize=size_vertices, color=color_vertices,
                                       legend="Vertices");
        plot_list := [op(plot_list), hoekpunten];
    end if;

    # Midpoints
    if member("all", elements) or member("midpoints", elements) then
        mid_valid := [];
        for i from 4 to nops(point_proj) do
            if point_proj[i][1] <> undefined then
                mid_valid := [op(mid_valid), point_proj[i]];
            end if;
        end do;
        mid_plot := plots:-pointplot(mid_valid, symbol=solidcircle, symbolsize=size_midpoints, color=color_midpoints,
                                     legend="Midpoints");
        plot_list := [op(plot_list), mid_plot];
    end if;

    # Circumcenters
    if member("all", elements) or member("circumcenters", elements) then
        center_plot := plots:-pointplot(center_proj, symbol=solidcircle, symbolsize=size_centers, color=color_circumcenters,
                                        legend="Circumcenters");
        plot_list := [op(plot_list), center_plot];
    end if;

    # Circumlines
    if member("all", elements) or member("circumlines", elements) then
        CL := Circumlines(C);
        line_plots := [];
        first := true;
        for i from 1 to 4 do
            line_plots := [op(line_plots),
                plots:-implicitplot(CL[i][1]*x + CL[i][2]*y + CL[i][3] = 0,
                             x=-bereik..bereik, y=-bereik..bereik,
                             color=color_circumlines, linestyle=dash,
                             legend=piecewise(first, "Circumlines", ""))];
            first := false;
        end do;
        plot_list := [op(plot_list), op(line_plots)];
    end if;

    # Circumcircles & Twin circles
    if member("all", elements) or member("circumcircles", elements) or member("twin", elements) then
        circs := Circumcircles(C);
        twins := TwinCircumcircles(C);
        circle_plots := [];
        first := true;
        if member("all", elements) or member("circumcircles", elements) then
            for i from 1 to 4 do
                eq := eval(circs[i], {z=1});
                circle_plots := [op(circle_plots),
                    plots:-implicitplot(eq, x=-bereik..bereik, y=-bereik..bereik,
                                 color=color_circumcircles, grid=[50,50],
                                 legend=piecewise(first, "Circumcircles", ""))];
                first := false;
            end do;
        end if;
        first := true;
        if member("all", elements) or member("twin", elements) then
            for i from 1 to 4 do
                eq_twin := eval(twins[i], {z=1});
                circle_plots := [op(circle_plots),
                    plots:-implicitplot(eq_twin, x=-bereik..bereik, y=-bereik..bereik,
                                 color=color_twin, grid=[50,50],
                                 legend=piecewise(first, "Twin circles", ""))];
                first := false;
            end do;
        end if;
        plot_list := [op(plot_list), op(circle_plots)];
    end if;

    # Jay lines
    if member("all", elements) or member("jay", elements) then
        J_lines := JayLines(C);
        j_plots := [];
        first := true;
        for i from 1 to 4 do
            j_plots := [op(j_plots),
                plots:-implicitplot(J_lines[i][1]*x + J_lines[i][2]*y + J_lines[i][3] = 0,
                             x=-bereik..bereik, y=-bereik..bereik,
                             color=color_jay, linestyle=solid,
                             legend=piecewise(first, "Jay lines", ""))];
            first := false;
        end do;
        plot_list := [op(plot_list), op(j_plots)];
    end if;

    # Wren lines
    if member("all", elements) or member("wren", elements) then
        W_lines := WrenLines(C);
        w_plots := [];
        first := true;
        for i from 1 to 4 do
            w_plots := [op(w_plots),
                plots:-implicitplot(W_lines[i][1]*x + W_lines[i][2]*y + W_lines[i][3] = 0,
                             x=-bereik..bereik, y=-bereik..bereik,
                             color=color_wren, linestyle=solid,
                             legend=piecewise(first, "Wren lines", ""))];
            first := false;
        end do;
        plot_list := [op(plot_list), op(w_plots)];
    end if;

    # CircumJay points
    if member("all", elements) or member("circumjay", elements) then
        t_pts := CircumJayPoints(C);
        t_proj := [seq(safe_project(t_pts[i]), i=1..4)];
        t_plot := plots:-pointplot(t_proj, symbol=solidcircle, symbolsize=size_jaywren, color=color_circumjay,
                                   legend="CircumJay points");
        plot_list := [op(plot_list), t_plot];
    end if;

    # CircumWren points
    if member("all", elements) or member("circumwren", elements) then
        u_pts := CircumWrenPoints(C);
        u_proj := [seq(safe_project(u_pts[i]), i=1..4)];
        u_plot := plots:-pointplot(u_proj, symbol=solidcircle, symbolsize=size_jaywren, color=color_circumwren,
                                   legend="CircumWren points");
        plot_list := [op(plot_list), u_plot];
    end if;

    # JayWren points
    if member("all", elements) or member("jaywren", elements) then
        v_pts := JayWrenPoints(C);
        v_proj := [seq(safe_project(v_pts[i]), i=1..4)];
        v_plot := plots:-pointplot(v_proj, symbol=solidcircle, symbolsize=size_jaywren, color=color_jaywren,
                                   legend="JayWren points");
        plot_list := [op(plot_list), v_plot];
    end if;

    return plots:-display(plot_list,
                          title=sprintf("UHG Triangle Analysis (2D) – %s", titel),
                          view=[-bereik..bereik, -bereik..bereik],
                          legendstyle=[font=["Times",10]]);
end proc:

    # 4.2 PlotAll3D – met legenda
    PlotAll3D := proc(
        A::Matrix,
        J::Matrix,
        titel::string,
        model::string := "projective",
        color_null::string := "gray",
        color_triangle::string := "green",
        color_vertices::string := "red",
        color_midpoints::string := "blue",
        color_circumcenters::string := "magenta",
        color_circumlines::string := "gray",
        color_circumcircles::string := "red",
        color_twin::string := "blue",
        color_jay::string := "orange",
        color_wren::string := "purple",
        color_circumjay::string := "cyan",
        color_circumwren::string := "gold",
        color_jaywren::string := "yellow",
        thickness_triangle::integer := 2,
        thickness_lines::integer := 1,
        size_points::integer := 20,
        bereik::numeric := 2.0,
        show_legend::boolean := false,
        plot_width::integer := 1400,
        plot_height::integer := 700,
        legend_width::integer := 300,
        legend_height::integer := 350
    )
        local res, C, m12, m23, m31, all_points, CC, center_punten,
              punten, mid_punten, i, p, q, zijden,
              puntplot, midplot, centerplot, zijdeplots, absoluut,
              hyper_scale, toList, scale_to_model, get_line_points,
              CL, J_lines, W_lines, t_pts, u_pts, v_pts,
              circs, twins, line_plots,
              t_plot, u_plot, v_plot,
              first, j, line_pts, p3d, legend, items,
              sym_plots, txt_plots, y, step, tx, sym_plot, txt_plot;

        toList := proc(v)
            if type(v, list) and nops(v) >= 3 then
                return [v[1], v[2], v[3]];
            elif type(v, Vector) then
                return [v[1], v[2], v[3]];
            else
                return [0,0,0];
            end if;
        end proc;

        hyper_scale := proc(v)
            local Q;
            Q := Quadrance(v, J);
            if Q >= 0 then return v; end if;
            return v / sqrt(-Q);
        end proc;

        scale_to_model := proc(pts)
            if model = "hyperboloid" then
                return map(hyper_scale, pts);
            else
                return pts;
            end if;
        end proc;

        get_line_points := proc(line_vec)
            local p1, p2, n, v1, v2, pts;
            n := line_vec;
            if evalf(abs(n[1])) > evalf(abs(n[2])) then
                v1 := < -n[2], n[1], 0 >;
            else
                v1 := < 0, -n[3], n[2] >;
            end if;
            v2 := LinearAlgebra:-CrossProduct(n, v1);
            if evalf(abs(n[2])) > 1e-12 then
                p1 := [0, -n[3]/n[2], 1];
            elif evalf(abs(n[1])) > 1e-12 then
                p1 := [-n[3]/n[1], 0, 1];
            else
                p1 := [1, 0, 0];
            end if;
            if evalf(abs(n[2])) > 1e-12 then
                p2 := [0, n[3]/n[2], -1];
            elif evalf(abs(n[1])) > 1e-12 then
                p2 := [n[3]/n[1], 0, -1];
            else
                p2 := [-1, 0, 0];
            end if;
            pts := [p1, p2];
            pts := scale_to_model(pts);
            return map(toList, pts);
        end proc;

        res := NormalizePoints(A, J);
        C := res["CanonicalMatrix"];

        m12 := Midpoints(A, 1, 2, J);
        m23 := Midpoints(A, 2, 3, J);
        m31 := Midpoints(A, 3, 1, J);
        all_points := [A[1], A[2], A[3]];
        if m12 <> [] then all_points := [op(all_points), m12[1], m12[2]]; end if;
        if m23 <> [] then all_points := [op(all_points), m23[1], m23[2]]; end if;
        if m31 <> [] then all_points := [op(all_points), m31[1], m31[2]]; end if;

        CC := Circumcenters(C);
        center_punten := [op(CC)];

        CL := Circumlines(C);
        J_lines := JayLines(C);
        W_lines := WrenLines(C);
        circs := Circumcircles(C);
        twins := TwinCircumcircles(C);
        t_pts := CircumJayPoints(C);
        u_pts := CircumWrenPoints(C);
        v_pts := JayWrenPoints(C);

        all_points := scale_to_model(all_points);
        center_punten := scale_to_model(center_punten);
        t_pts := scale_to_model(t_pts);
        u_pts := scale_to_model(u_pts);
        v_pts := scale_to_model(v_pts);

        all_points := map(toList, all_points);
        center_punten := map(toList, center_punten);
        t_pts := map(toList, t_pts);
        u_pts := map(toList, u_pts);
        v_pts := map(toList, v_pts);

        punten := all_points[1..3];
        mid_punten := all_points[4..-1];

        puntplot := plots:-pointplot3d(punten, symbol=solidsphere, color=color_vertices, symbolsize=size_points);
        midplot := plots:-pointplot3d(mid_punten, symbol=solidsphere, color=color_midpoints, symbolsize=size_points-5);
        centerplot := plots:-pointplot3d(center_punten, symbol=solidsphere, color=color_circumcenters, symbolsize=size_points);
        t_plot := plots:-pointplot3d(t_pts, symbol=solidsphere, color=color_circumjay, symbolsize=size_points-5);
        u_plot := plots:-pointplot3d(u_pts, symbol=solidsphere, color=color_circumwren, symbolsize=size_points-5);
        v_plot := plots:-pointplot3d(v_pts, symbol=solidsphere, color=color_jaywren, symbolsize=size_points-5);

        zijdeplots := [];
        for i from 1 to 3 do
            q := i mod 3 + 1;
            zijdeplots := [op(zijdeplots),
                plots:-spacecurve([punten[i], punten[q]], color=color_triangle, thickness=thickness_triangle)];
        end do;

        line_plots := [];
        for i from 1 to 4 do
            line_pts := get_line_points(CL[i]);
            if nops(line_pts) >= 2 then
                line_plots := [op(line_plots),
                    plots:-spacecurve(line_pts, color=color_circumlines, thickness=thickness_lines, linestyle=dash)];
            end if;
        end do;
        for i from 1 to 4 do
            line_pts := get_line_points(J_lines[i]);
            if nops(line_pts) >= 2 then
                line_plots := [op(line_plots),
                    plots:-spacecurve(line_pts, color=color_jay, thickness=thickness_lines)];
            end if;
        end do;
        for i from 1 to 4 do
            line_pts := get_line_points(W_lines[i]);
            if nops(line_pts) >= 2 then
                line_plots := [op(line_plots),
                    plots:-spacecurve(line_pts, color=color_wren, thickness=thickness_lines)];
            end if;
        end do;

        if model = "hyperboloid" then
            absoluut := plots:-implicitplot3d(x^2 + y^2 - z^2 = -1,
                                x=-bereik..bereik, y=-bereik..bereik, z=-bereik..bereik,
                                color=color_null, style=wireframe, grid=[30,30,30]);
        else
            absoluut := plots:-implicitplot3d(x^2 + y^2 - z^2 = 0,
                                x=-bereik..bereik, y=-bereik..bereik, z=-bereik..bereik,
                                color=color_null, style=wireframe, grid=[30,30,30]);
        end if;

        p3d := plots:-display(puntplot, midplot, centerplot, t_plot, u_plot, v_plot,
                              op(zijdeplots), op(line_plots), absoluut,
                              title=sprintf("UHG Triangle Analysis (3D) – %s", titel),
                              axes=normal, scaling=constrained, view=[-bereik..bereik, -bereik..bereik, -bereik..bereik]);

        if show_legend then
            items := [
                ["Vertices", color_vertices, "point"],
                ["Midpoints", color_midpoints, "point"],
                ["Circumcenters", color_circumcenters, "point"],
                ["CircumJay points", color_circumjay, "point"],
                ["CircumWren points", color_circumwren, "point"],
                ["JayWren points", color_jaywren, "point"],
                ["Triangle sides", color_triangle, "line"],
                ["Circumlines", color_circumlines, "line"],
                ["Jay lines", color_jay, "line"],
                ["Wren lines", color_wren, "line"],
                ["Null cone", color_null, "line"]
            ];
            sym_plots := [];
            txt_plots := [];
            y := 0.9;
            step := 0.055;
            for item in items do
                if item[3] = "line" then
                    p := plots:-plot([[0.15, y], [0.30, y]], color=item[2], thickness=2);
                elif item[3] = "polygon" then
                    p := plots:-polygonplot([[0.15, y-0.015], [0.30, y-0.015], [0.30, y+0.015], [0.15, y+0.015]],
                                            color=item[2], style=polygon);
                else
                    p := plots:-pointplot([[0.225, y]], symbol=solidcircle, symbolsize=12, color=item[2]);
                end if;
                sym_plots := [op(sym_plots), p];
                tx := plots:-textplot([0.35, y, item[1]], align=left, font=[Times, 7], color="black");
                txt_plots := [op(txt_plots), tx];
                y := y - step;
            end do;
            sym_plot := plots:-display(sym_plots, axes=none, scaling=constrained, view=[0..0.5, 0..1]);
            txt_plot := plots:-display(txt_plots, axes=none, scaling=constrained, view=[0..0.5, 0..1]);
            legend := plots:-display(Array([[sym_plot, txt_plot]]), size=[legend_width, legend_height]);
            return plots:-display(Array([[p3d, legend]]), size=[plot_width, plot_height]);
        else
            return p3d;
        end if;
    end proc;

    # 4.3 PlotCircumlinear – volledig (hersteld)
    PlotCircumlinear := proc(A::Matrix, J::Matrix, titel::string,
                             show_unit_triangle::boolean := true,
                             color_null::string := "black",
                             color_triangle::string := "green",
                             color_vertices::string := "red",
                             color_midpoints::string := "blue",
                             color_circumcenters::string := "magenta",
                             color_circumlines::string := "gray",
                             color_circumcircles::string := "red",
                             color_twin::string := "blue",
                             color_jay::string := "orange",
                             color_wren::string := "purple",
                             color_circumjay::string := "cyan",
                             color_circumwren::string := "gold",
                             color_jaywren::string := "yellow",
                             thickness_triangle::integer := 2,
                             size_vertices::integer := 20,
                             size_midpoints::integer := 15,
                             size_centers::integer := 20,
                             size_jaywren::integer := 15,
                             bereik::numeric := 2.0)
        local res, C, m12, m23, m31, all_points, CC, CL,
              circs, twins, J_lines, W_lines, t_pts, u_pts, v_pts,
              i, j, eq, eq_twin, unit_triangle, null_conic,
              point_proj, center_proj, t_proj, u_proj, v_proj,
              punktplot, midplot, centerplot, t_plot, u_plot, v_plot,
              zijde_plots, line_plots, circle_plots,
              xmin, xmax, ymin, ymax, margin,
              alle_xy, x_vals, y_vals,
              first, safe_project_circum, tri_pts,
              line_eq, center_punten, punten, mid_punten,
              null_plot;

        safe_project_circum := proc(pt)
            local s;
            s := pt[1] + pt[2] + pt[3];
            if abs(evalf(s)) < 1e-12 then
                return [undefined, undefined];
            else
                return [pt[1]/s, pt[2]/s];
            end if;
        end proc;

        res := NormalizePoints(A, J);
        C := res["CanonicalMatrix"];

        m12 := Midpoints(A, 1, 2, J);
        m23 := Midpoints(A, 2, 3, J);
        m31 := Midpoints(A, 3, 1, J);
        all_points := [A[1], A[2], A[3]];
        if m12 <> [] then all_points := [op(all_points), m12[1], m12[2]]; end if;
        if m23 <> [] then all_points := [op(all_points), m23[1], m23[2]]; end if;
        if m31 <> [] then all_points := [op(all_points), m31[1], m31[2]]; end if;

        CC := Circumcenters(C);
        center_punten := [op(CC)];

        CL := Circumlines(C);
        J_lines := JayLines(C);
        W_lines := WrenLines(C);
        circs := Circumcircles(C);
        twins := TwinCircumcircles(C);
        t_pts := CircumJayPoints(C);
        u_pts := CircumWrenPoints(C);
        v_pts := JayWrenPoints(C);

        point_proj := map(safe_project_circum, all_points);
        center_proj := map(safe_project_circum, center_punten);
        t_proj := map(safe_project_circum, t_pts);
        u_proj := map(safe_project_circum, u_pts);
        v_proj := map(safe_project_circum, v_pts);

        alle_xy := [op(point_proj), op(center_proj), op(t_proj), op(u_proj), op(v_proj)];
        alle_xy := select(p -> p[1] <> undefined, alle_xy);
        if alle_xy = [] then
            xmin := -bereik; xmax := bereik; ymin := -bereik; ymax := bereik;
        else
            x_vals := [seq(alle_xy[i][1], i=1..nops(alle_xy))];
            y_vals := [seq(alle_xy[i][2], i=1..nops(alle_xy))];
            xmin := min(x_vals); xmax := max(x_vals);
            ymin := min(y_vals); ymax := max(y_vals);
        end if;
        margin := max(0.5, (max(xmax-xmin, ymax-ymin))*0.2);
        xmin := xmin - margin; xmax := xmax + margin;
        ymin := ymin - margin; ymax := ymax + margin;
        if show_unit_triangle then
            xmin := min(xmin, -0.5); xmax := max(xmax, 1.5);
            ymin := min(ymin, -0.5); ymax := max(ymax, 1.5);
        end if;

        if show_unit_triangle then
            unit_triangle := plots:-polygonplot([[0,0],[1,0],[0,1]], color=yellow, transparency=0.7,
                                                legend="Unit triangle");
        else
            unit_triangle := NULL;
        end if;

        null_conic := simplify(eval(x^2 + y^2 - z^2, z=1-x-y));
        null_plot := plots:-implicitplot(null_conic, x=xmin..xmax, y=ymin..ymax,
                                         color=color_null, grid=[50,50],
                                         legend="Null conic");

        punten := point_proj[1..3];
        mid_punten := point_proj[4..-1];

        punktplot := plots:-pointplot(select(p -> p[1]<>undefined, punten), symbol=solidcircle,
                                      symbolsize=size_vertices, color=color_vertices,
                                      legend="Vertices");
        midplot := plots:-pointplot(select(p -> p[1]<>undefined, mid_punten), symbol=solidcircle,
                                    symbolsize=size_midpoints, color=color_midpoints,
                                    legend="Midpoints");
        centerplot := plots:-pointplot(select(p -> p[1]<>undefined, center_proj), symbol=solidcircle,
                                       symbolsize=size_centers, color=color_circumcenters,
                                       legend="Circumcenters");
        t_plot := plots:-pointplot(select(p -> p[1]<>undefined, t_proj), symbol=solidcircle,
                                   symbolsize=size_jaywren, color=color_circumjay,
                                   legend="CircumJay points");
        u_plot := plots:-pointplot(select(p -> p[1]<>undefined, u_proj), symbol=solidcircle,
                                   symbolsize=size_jaywren, color=color_circumwren,
                                   legend="CircumWren points");
        v_plot := plots:-pointplot(select(p -> p[1]<>undefined, v_proj), symbol=solidcircle,
                                   symbolsize=size_jaywren, color=color_jaywren,
                                   legend="JayWren points");

        tri_pts := [punten[1], punten[2], punten[3], punten[1]];
        tri_pts := select(p -> p[1]<>undefined, tri_pts);
        if nops(tri_pts) >= 4 then
            zijde_plots := plot(tri_pts, style=line, color=color_triangle, thickness=thickness_triangle,
                                legend="Triangle sides");
        else
            zijde_plots := NULL;
        end if;

        line_plots := [];
        first := true;
        for i from 1 to 4 do
            line_eq := simplify(CL[i][1]*x + CL[i][2]*y + CL[i][3]*(1-x-y));
            line_plots := [op(line_plots),
                plots:-implicitplot(line_eq, x=xmin..xmax, y=ymin..ymax,
                                    color=color_circumlines, linestyle=dash,
                                    legend=piecewise(first, "Circumlines", ""))];
            first := false;
        end do;
        first := true;
        for i from 1 to 4 do
            line_eq := simplify(J_lines[i][1]*x + J_lines[i][2]*y + J_lines[i][3]*(1-x-y));
            line_plots := [op(line_plots),
                plots:-implicitplot(line_eq, x=xmin..xmax, y=ymin..ymax,
                                    color=color_jay, linestyle=solid,
                                    legend=piecewise(first, "Jay lines", ""))];
            first := false;
        end do;
        first := true;
        for i from 1 to 4 do
            line_eq := simplify(W_lines[i][1]*x + W_lines[i][2]*y + W_lines[i][3]*(1-x-y));
            line_plots := [op(line_plots),
                plots:-implicitplot(line_eq, x=xmin..xmax, y=ymin..ymax,
                                    color=color_wren, linestyle=solid,
                                    legend=piecewise(first, "Wren lines", ""))];
            first := false;
        end do;

        circle_plots := [];
        first := true;
        for i from 1 to 4 do
            eq := eval(circs[i], {z=1-x-y});
            circle_plots := [op(circle_plots),
                plots:-implicitplot(eq, x=xmin..xmax, y=ymin..ymax,
                                    color=color_circumcircles, grid=[50,50],
                                    legend=piecewise(first, "Circumcircles", ""))];
            first := false;
        end do;
        first := true;
        for i from 1 to 4 do
            eq := eval(twins[i], {z=1-x-y});
            circle_plots := [op(circle_plots),
                plots:-implicitplot(eq, x=xmin..xmax, y=ymin..ymax,
                                    color=color_twin, grid=[50,50],
                                    legend=piecewise(first, "Twin circles", ""))];
            first := false;
        end do;

        return plots:-display(unit_triangle, null_plot,
                              punktplot, midplot, centerplot, t_plot, u_plot, v_plot,
                              zijde_plots, op(line_plots), op(circle_plots),
                              title=sprintf("UHG Triangle Analysis (Circumlinear) – %s", titel),
                              view=[xmin..xmax, ymin..ymax],
                              scaling=constrained,
                              legendstyle=[font=["Times",10]]);
    end proc;

    # 4.4 IntersectionPlot
    IntersectionPlot := proc(
        F,
        P,
        curveColor::string := "cyan",
        intersectionOnly::boolean := true,
        curveThickness::posint := 2,
        plotSize::list := [850,850],
        xr::range := -3..3,
        yr::range := -3..3,
        zr::range := -3..3
    )
        local Feq, Peq, zsol, G, surf, plane, C2d, C3d, sz;
        Feq := `if`(type(F, equation), F, F = 0);
        Peq := `if`(type(P, equation), P, P = 0);
        if type(xr, equation) then xr := rhs(xr); end if;
        if type(yr, equation) then yr := rhs(yr); end if;
        if type(zr, equation) then zr := rhs(zr); end if;
        sz := convert(plotSize, list);
        if nops(sz) <> 2 then
            error "plotSize must be a 2-element list or Vector, e.g. [850,850]";
        end if;
        zsol := solve(Peq, z);
        if zsol = NULL then
            error "could not solve the plane equation for z; rewrite the plane so z can be isolated";
        end if;
        G := expand(subs(z = zsol, lhs(Feq) - rhs(Feq)));
        C2d := plots:-implicitplot(G = 0, x = xr, y = yr, color = curveColor, thickness = curveThickness);
        C3d := plottools:-transform(unapply([x, y, zsol], x, y))(C2d);
        if intersectionOnly then
            return plots:-display([C3d], axes = normal, size = sz);
        else
            surf := plots:-implicitplot3d(Feq, x = xr, y = yr, z = zr,
                                          grid = [40,40,40], style = patchnogrid,
                                          color = "blue", transparency = 0.6);
            plane := plots:-implicitplot3d(Peq, x = xr, y = yr, z = zr,
                                           grid = [2,2,2], style = patchnogrid,
                                           color = "gold", transparency = 0.5);
            return plots:-display([surf, plane, C3d], axes = normal, size = sz);
        end if;
    end proc:

    # 4.5 PlotUnitTriangle
    PlotUnitTriangle := proc(
        kleur::string := "yellow",
        transparantie::numeric := 0.75,
        grootte_punten::integer := 12,
        bereik::numeric := 2.0
    )
        local driehoek, punten;
        driehoek := plots:-polygonplot3d([[1,0,0],[0,1,0],[0,0,1]],
                                         color=kleur, transparency=transparantie);
        punten := plots:-pointplot3d([[1,0,0],[0,1,0],[0,0,1]],
                                     symbol=solidsphere, symbolsize=grootte_punten, color=black);
        return plots:-display(driehoek, punten,
                              title="Unit triangle in 3D",
                              axes=normal, scaling=constrained, view=[-bereik..bereik, -bereik..bereik, -bereik..bereik]);
    end proc:

    # 4.6 PlotConicOnUnitTriangle
    PlotConicOnUnitTriangle := proc(
        conicExpr,
        curveColor::string := "cyan",
        curveThickness::integer := 2,
        showSurface::boolean := false,
        bereik::numeric := 2.0
    )
        local P, F, result;
        P := x + y + z - 1;
        F := conicExpr;
        result := IntersectionPlot(F, P, curveColor, not showSurface, curveThickness, [850,850],
                                   -bereik..bereik, -bereik..bereik, -bereik..bereik);
        return plots:-display(result, title="Conic intersection with unit triangle");
    end proc:

    # 4.7 BuildConicFromCanonical
    BuildConicFromCanonical := proc(C::Matrix)
        return expand(<x,y,z>^%T . C . <x,y,z>);
    end proc:

    # 4.8 PlotUnitTriangleWithConic3D
    PlotUnitTriangleWithConic3D := proc(
        conicExpr,
        planeExpr := x+y+z-1,
        triangleColor::string := "yellow",
        triangleTransparency::numeric := 0.75,
        pointSize::integer := 12,
        curveColor::string := "cyan",
        curveThickness::integer := 2,
        showSurface::boolean := false,
        xrange := -3..3,
        yrange := -3..3,
        zrange := -3..3,
        show_legend::boolean := false,
        plot_width::integer := 1400,
        plot_height::integer := 700,
        legend_width::integer := 300,
        legend_height::integer := 350
    )
        local tri, pts, inter, p3d, legend, items,
              sym_plots, txt_plots, i, y, step, p, tx,
              sym_plot, txt_plot;

        tri := plots:-polygonplot3d([[1,0,0],[0,1,0],[0,0,1]],
                                    color=triangleColor, transparency=triangleTransparency);
        pts := plots:-pointplot3d([[1,0,0],[0,1,0],[0,0,1]],
                                  symbol=solidsphere, symbolsize=pointSize, color="black");
        inter := IntersectionPlot(conicExpr, planeExpr, curveColor,
                                  not showSurface, curveThickness, [850,850],
                                  xrange, yrange, zrange);
        p3d := plots:-display(tri, pts, inter, scaling=constrained,
                              title="Unit triangle with conic intersection");

        if show_legend then
            items := [
                ["Null conic", curveColor, "line"],
                ["Unit triangle", triangleColor, "polygon"],
                ["Vertices", "black", "point"]
            ];
            sym_plots := [];
            txt_plots := [];
            y := 0.9;
            step := 0.065;
            for item in items do
                if item[3] = "line" then
                    p := plots:-plot([[0.15, y], [0.30, y]], color=item[2], thickness=2);
                elif item[3] = "polygon" then
                    p := plots:-polygonplot([[0.15, y-0.015], [0.30, y-0.015], [0.30, y+0.015], [0.15, y+0.015]],
                                            color=item[2], style=polygon);
                else
                    p := plots:-pointplot([[0.225, y]], symbol=solidcircle, symbolsize=12, color=item[2]);
                end if;
                sym_plots := [op(sym_plots), p];
                tx := plots:-textplot([0.35, y, item[1]], align=left, font=[Times, 8], color="black");
                txt_plots := [op(txt_plots), tx];
                y := y - step;
            end do;
            sym_plot := plots:-display(sym_plots, axes=none, scaling=constrained, view=[0..0.5, 0..1]);
            txt_plot := plots:-display(txt_plots, axes=none, scaling=constrained, view=[0..0.5, 0..1]);
            legend := plots:-display(Array([[sym_plot, txt_plot]]), size=[legend_width, legend_height]);
            return plots:-display(Array([[p3d, legend]]), size=[plot_width, plot_height]);
        else
            return p3d;
        end if;
    end proc:

    # ------------------------------------------------------------
    # 4.9 PlotStepsArray (volledig)
    # ------------------------------------------------------------
    PlotStepsArray := proc(A::Matrix, J::Matrix := Jdefault)
        local res, C, m12, m23, m31, all_points, point_proj,
              CC, center_proj, CL, line_plots, circs, twins,
              circle_plots, J_lines, W_lines, t_pts, u_pts, v_pts,
              bereik, i, eq, eq_twin, cirkel, dreihoek, hoekpunten,
              mid_plot, center_plot, step1, step2, step3, step4, step5,
              xmin, xmax, ymin, ymax, margin, alle_xy, x_vals, y_vals,
              j_plots, w_plots, t_proj, u_proj, v_proj, t_plot, u_plot, v_plot,
              triType, p, valid_proj, safe_project, mid_valid;

        safe_project := proc(pt)
            if evalf(abs(pt[3])) < 1e-12 then
                return [undefined, undefined];
            else
                return [pt[1]/pt[3], pt[2]/pt[3]];
            end if;
        end proc;

        res := NormalizePoints(A, J);
        C := res["CanonicalMatrix"];
        triType := res["TriangleType"];

        m12 := Midpoints(A, 1, 2, J);
        m23 := Midpoints(A, 2, 3, J);
        m31 := Midpoints(A, 3, 1, J);
        all_points := [A[1], A[2], A[3]];
        if m12 <> [] then all_points := [op(all_points), m12[1], m12[2]]; end if;
        if m23 <> [] then all_points := [op(all_points), m23[1], m23[2]]; end if;
        if m31 <> [] then all_points := [op(all_points), m31[1], m31[2]]; end if;

        point_proj := [seq(safe_project(p), p in all_points)];

        CC := Circumcenters(C);
        center_proj := [seq(safe_project(c), c in CC)];

        valid_proj := [];
        for p in [op(point_proj), op(center_proj)] do
            if p[1] <> undefined then
                valid_proj := [op(valid_proj), p];
            end if;
        end do;

        if valid_proj = [] then
            xmin := -1.5; xmax := 1.5; ymin := -1.5; ymax := 1.5;
        else
            x_vals := [seq(valid_proj[i][1], i=1..nops(valid_proj))];
            y_vals := [seq(valid_proj[i][2], i=1..nops(valid_proj))];
            xmin := min(x_vals); xmax := max(x_vals);
            ymin := min(y_vals); ymax := max(y_vals);
        end if;
        margin := max(0.5, (max(xmax-xmin, ymax-ymin))*0.2);
        bereik := max(abs(xmin), abs(xmax), abs(ymin), abs(ymax)) + margin;
        bereik := max(bereik, 1.5);

        cirkel := plots:-implicitplot(x^2 + y^2 = 1, x=-bereik..bereik, y=-bereik..bereik,
                               color=black, scaling=constrained, grid=[50,50]);
        dreihoek := plots:-pointplot([point_proj[1], point_proj[2], point_proj[3], point_proj[1]],
                              style=line, color=green, thickness=2);
        hoekpunten := plots:-pointplot(point_proj[1..3], symbol=solidcircle, symbolsize=20, color=red);
        mid_valid := [];
        for i from 4 to nops(point_proj) do
            if point_proj[i][1] <> undefined then
                mid_valid := [op(mid_valid), point_proj[i]];
            end if;
        end do;
        mid_plot := plots:-pointplot(mid_valid, symbol=solidcircle, symbolsize=15, color=blue);

        step1 := plots:-display(cirkel, dreihoek, hoekpunten,
                      title=sprintf("Step 1: Triangle (%s)", triType),
                      view=[-bereik..bereik, -bereik..bereik]);

        center_plot := plots:-pointplot(center_proj, symbol=solidcircle, symbolsize=20, color=magenta);
        step2 := plots:-display(cirkel, dreihoek, hoekpunten, center_plot,
                      title=sprintf("Step 2: Circumcenters (%s)", triType),
                      view=[-bereik..bereik, -bereik..bereik]);

        CL := Circumlines(C);
        line_plots := [];
        for i from 1 to 4 do
            line_plots := [op(line_plots),
                plots:-implicitplot(CL[i][1]*x + CL[i][2]*y + CL[i][3] = 0,
                             x=-bereik..bereik, y=-bereik..bereik,
                             color=gray, linestyle=dash)];
        end do;
        step3 := plots:-display(cirkel, dreihoek, hoekpunten, center_plot, op(line_plots),
                      title=sprintf("Step 3: Circumlines (%s)", triType),
                      view=[-bereik..bereik, -bereik..bereik]);

        circs := Circumcircles(C);
        twins := TwinCircumcircles(C);
        circle_plots := [];
        for i from 1 to 4 do
            eq := eval(circs[i], {z=1});
            circle_plots := [op(circle_plots),
                plots:-implicitplot(eq, x=-bereik..bereik, y=-bereik..bereik,
                             color=red, grid=[50,50])];
            eq_twin := eval(twins[i], {z=1});
            circle_plots := [op(circle_plots),
                plots:-implicitplot(eq_twin, x=-bereik..bereik, y=-bereik..bereik,
                             color=blue, grid=[50,50])];
        end do;
        step4 := plots:-display(cirkel, dreihoek, hoekpunten, center_plot, op(line_plots), op(circle_plots),
                      title=sprintf("Step 4: Circumcircles & Twin circles (%s)", triType),
                      view=[-bereik..bereik, -bereik..bereik]);

        J_lines := JayLines(C);
        W_lines := WrenLines(C);
        t_pts := CircumJayPoints(C);
        u_pts := CircumWrenPoints(C);
        v_pts := JayWrenPoints(C);

        j_plots := [];
        for i from 1 to 4 do
            j_plots := [op(j_plots),
                plots:-implicitplot(J_lines[i][1]*x + J_lines[i][2]*y + J_lines[i][3] = 0,
                             x=-bereik..bereik, y=-bereik..bereik, color=orange, linestyle=solid)];
        end do;
        w_plots := [];
        for i from 1 to 4 do
            w_plots := [op(w_plots),
                plots:-implicitplot(W_lines[i][1]*x + W_lines[i][2]*y + W_lines[i][3] = 0,
                             x=-bereik..bereik, y=-bereik..bereik, color=purple, linestyle=solid)];
        end do;

        t_proj := [seq(safe_project(t_pts[i]), i=1..4)];
        u_proj := [seq(safe_project(u_pts[i]), i=1..4)];
        v_proj := [seq(safe_project(v_pts[i]), i=1..4)];

        t_plot := plots:-pointplot(t_proj, symbol=solidcircle, symbolsize=15, color=cyan);
        u_plot := plots:-pointplot(u_proj, symbol=solidcircle, symbolsize=15, color=gold);
        v_plot := plots:-pointplot(v_proj, symbol=solidcircle, symbolsize=15, color=yellow);

        step5 := plots:-display(cirkel, dreihoek, hoekpunten, center_plot, op(line_plots), op(circle_plots),
                      op(j_plots), op(w_plots), t_plot, u_plot, v_plot,
                      title=sprintf("Step 5: Jay & Wren lines, points (%s)", triType),
                      view=[-bereik..bereik, -bereik..bereik]);

        return plots:-display(Array([step1, step2, step3, step4, step5]));
    end proc;

    # ------------------------------------------------------------
    # 5. Overige functies
    # ------------------------------------------------------------
    PlotSteps := proc(C::Matrix)
        printf("\n============================================================\n");
        printf("HOW TO BUILD A PLOT OF THE TRIANGLE IN CIRCUMLINEAR COORDINATES?\n");
        printf("============================================================\n\n");
        printf("The triangle is in circumlinear coordinates: a1=[1,0,0], a2=[0,1,0], a3=[0,0,1]\n");
        printf("The canonical matrix C has parameters a,b,c,epsilon:\n");
        print(C);
        printf("\nFollow these steps to create a plot in Maple:\n\n");
        printf("STEP 1: Show the triangle in the Klein model\n");
        printf(" A := Matrix([[1,0,0],[0,1,0],[0,0,1]]);\n");
        printf(" triangle := pointplot([[1,0],[0,1],[0,0],[1,0]], style=line, color=green, thickness=2);\n\n");
        printf("STEP 2: Draw the circumcenters\n");
        printf(" centers := Circumcenters(C);\n");
        printf(" center_proj := [seq([c[1]/c[3], c[2]/c[3]], c in centers)];\n");
        printf(" center_plot := pointplot(center_proj, symbol=solidcircle, symbolsize=20, color=magenta);\n\n");
        printf("STEP 3: Draw the circumlines\n");
        printf(" lines := Circumlines(C);\n");
        printf(" line_plots := [seq(implicitplot(lines[i][1]*x + lines[i][2]*y + lines[i][3] = 0, x=-2..2, y=-2..2, color=gray), i=1..4)];\n\n");
        printf("STEP 4: Draw the circumcircles and twin circles\n");
        printf(" circles := Circumcircles(C); twin_circles := TwinCircumcircles(C);\n");
        printf(" circle_plots := [seq(implicitplot(eval(circles[i], z=1), x=-2..2, y=-2..2), i=1..4)];\n\n");
        printf("STEP 5: Draw Jay and Wren lines and points\n");
        printf(" J := JayLines(C); W := WrenLines(C);\n");
        printf(" t := CircumJayPoints(C); u := CircumWrenPoints(C); v := JayWrenPoints(C);\n");
        printf(" # Project and plot.\n\n");
        printf("STEP 6: Combine everything with display()\n");
        printf(" display(triangle, center_plot, op(line_plots), op(circle_plots), ...);\n\n");
        printf("============================================================\n");
        return NULL;
    end proc;

    PlotHierarchy := proc(C::Matrix, depth::integer := 1)
        printf("PlotHierarchy: shows the Circumcenter hierarchy up to depth %d.\n", depth);
        printf("This function is still under development.\n");
        printf("Use PlotSteps(C) to visualize the first layer.\n");
        return NULL;
    end proc;

    # ------------------------------------------------------------
    # 6. Info – bijgewerkt
    # ------------------------------------------------------------
    Info := proc(cmd::string := "")
        local help, cmds, c;
        help := table([
            "PlotAll2D" =
                "PlotAll2D(A, J, titel, ... , elements := [\"all\"])\n"#
                " Comprehensive 2D plot with optional elements selection.\n"#
                " Possible element names: \"null\", \"triangle\", \"vertices\",\n"#
                " \"midpoints\", \"circumcenters\", \"circumlines\",\n"#
                " \"circumcircles\", \"twin\", \"jay\", \"wren\",\n"#
                " \"circumjay\", \"circumwren\", \"jaywren\".\n"#
                " Example: PlotAll2D(A, J, 'Step 1', elements=[\"null\",\"triangle\"]);",

            "PlotStepsArray" =
                "PlotStepsArray(A, J)\n"#
                " Displays five construction steps (triangle, circumcenters,\n"#
                " circumlines, circles, Jay/Wren) in a column of plots.\n"#
                " Example: PlotStepsArray(A, J);",

            "PlotCircumlinear" =
                "PlotCircumlinear(A, J, titel, ...)\n"#
                " Projects all triangle objects onto the unit triangle plane x+y+z=1.\n"#
                " Use show_unit_triangle to toggle the yellow triangle.\n"#
                " Example: PlotCircumlinear(A, J, 'Circumlinear view');",

            # ... andere entries zijn beknopt maar aanwezig
            "Info" =
                "Info(cmd)\n"#
                " Display this help message.\n"#
                " With no argument, list all available commands.\n"#
                " Example: Info('NormalizePoints');"
        ]);

        if cmd = "" then
            printf("Universal Hyperbolic Geometry (UHG) module\n");
            printf("==========================================\n");
            printf("Available commands:\n");
            cmds := sort([indices(help, nolist)]);
            for c in cmds do
                printf(" %s\n", c);
            end do;
            printf("\nUse Info(\"command\") for detailed help on a specific command.\n");
            printf("Example: Info(\"NormalizePoints\");\n");
        else
            if assigned(help[cmd]) then
                printf("%s\n\n", help[cmd]);
            else
                printf("Unknown command: %s\n", cmd);
                printf("Use Info() to list all available commands.\n");
            end if;
        end if;
    end proc;

end module;

printf("\n============================================================\n");
printf("UHG module loaded successfully.\n");
printf("Use Info() to list all available commands.\n");
printf("Info(\"command\") for details on a specific command.\n");
printf("\nAll functions are fully implemented:\n");
printf(" - PlotStepsArray (restored)\n");
printf(" - PlotCircumlinear (restored)\n");
printf(" - PlotAll2D with 'elements' parameter\n");
printf(" - PlotAll3D and PlotUnitTriangleWithConic3D with legend\n");
printf("============================================================\n");

Warning, (in UHG:-PlotAll3D) `item` is implicitly declared local

Warning, (in UHG:-PlotUnitTriangleWithConic3D) `item` is implicitly declared local

Warning, (in UHG:-PlotStepsArray) `c` is implicitly declared local

============================================================
UHG module loaded successfully.
Use Info() to list all available commands.
Info("command") for details on a specific command.

All functions are fully implemented:
- PlotStepsArray (restored)
- PlotCircumlinear (restored)
- PlotAll2D with 'elements' parameter
- PlotAll3D and PlotUnitTriangleWithConic3D with legend
============================================================

>	with(UHG):

Info();

Universal Hyperbolic Geometry (UHG) module
==========================================
Available commands:
  Info
  PlotAll2D
  PlotCircumlinear
  PlotStepsArray

Use Info("command") for detailed help on a specific command.
Example: Info("NormalizePoints");

>	Example: Info("NormalizePoints");

Unknown command: NormalizePoints
Use Info() to list all available commands.

>	Example: Info("PlotUnitTriangleWithConic3D");

Unknown command: PlotUnitTriangleWithConic3D
Use Info() to list all available commands.

>	Example: Info("PlotAll2D");

PlotAll2D(A, J, titel, ... , elements := ["all"])
  Comprehensive 2D plot with optional elements selection.
  Possible element names: "null", "triangle", "vertices",
  "midpoints", "circumcenters", "circumlines",
  "circumcircles", "twin", "jay", "wren",
  "circumjay", "circumwren", "jaywren".
  Example: PlotAll2D(A, J, 'Step 1', elements=["null","triangle"]);

with(UHG):
J := Matrix([[1,0,0],[0,1,0],[0,0,-1]]);
a1 := [1,0,1];
a2 := [-1/2, sqrt(3)/2, 1];
a3 := [-1/2, -sqrt(3)/2, 1];
A := Matrix([a1,a2,a3]);

# 2D Klein-model
PlotAll2D(A, J, "Ideale driehoek");

# 3D projectief
PlotAll3D(A, J, "Projectieve ruimte");

# 3D hyperboloïde
PlotAll3D(A, J, "Hyperboloïde", model="hyperboloid");

# Circumlineair (eenheidsdriehoek)
PlotCircumlinear(A, J, "Circumlineaire coördinaten");

PlotAll2D(
    A,
    J,
    "Stap 1",
    elements=["null","triangle","vertices"]
);

elements = ["all"]

#restart;
with(UHG):
with(plots): # voor extra plotopties (niet verplicht)

# 1. Definieer de metriek (hyperbolisch Klein-model)
J := Matrix([[1,0,0],[0,1,0],[0,0,-1]]);

# 2. Definieer een ideale gelijkzijdige driehoek (punten op de eenheidscirkel)
a1 := [1, 0, 1];
a2 := [-1/2, sqrt(3)/2, 1];
a3 := [-1/2, -sqrt(3)/2, 1];

A := Matrix([a1, a2, a3]);

# 3. Normaliseer de driehoek en verkrijg de canonieke matrix
res := NormalizePoints(A, J);
C := res["CanonicalMatrix"];
printf("Canonieke matrix C:\n");
print(C);

# 4. Classificeer de driehoek
triType := res["TriangleType"];
printf("Type driehoek: %s\n", triType);

# 5. Bereken de kwadraten van de punten (moeten 0 zijn voor ideale punten)
Q := res["Quadrances"];
printf("Kwadraten: %a\n", Q);

# 6. Bepaal de parameters a,b,c,epsilon
a := C[1,2]; b := C[1,3]; c := C[2,3]; eps := C[3,3];
printf("a = %a, b = %a, c = %a, epsilon = %a\n", a, b, c, eps);

# 7. Visualisaties
# 7a. 2D Klein-model (eenheidscirkel)
PlotAll2D(A, J, "Ideale gelijkzijdige driehoek");

# 7b. 3D projectief model
PlotAll3D(A, J, "Projectief model", show_legend=true);

# 7c. Circumlineaire coördinaten (eenheidsdriehoek)
PlotCircumlinear(A, J, "Circumlineair model");

# 8. Extra: bereken de circumcenters en toon ze
centers := Circumcenters(C);
printf("Circumcenters (homogeen):\n");
for i from 1 to 4 do
printf(" C%a = %a\n", i-1, centers[i]);
end do;

Canonieke matrix C:

Type driehoek: All vertices on the null circle (ideal triangle)

Kwadraten: [0, 0, 0]

a = -3/2, b = -3/2, c = -3/2, epsilon = 0
elements = ["all"]

Circumcenters (homogeen):
  C0 = Vector(3, [9/4,9/4,9/4])
  C1 = Vector(3, [27/4,-9/4,-9/4])
  C2 = Vector(3, [-9/4,27/4,-9/4])
  C3 = Vector(3, [-9/4,-9/4,27/4])

>	PlotAll2D(A, J, "My triangle", color_triangle="red", thickness_triangle=3);

elements = ["all"]

>	PlotStepsArray(A, J) ;

with(UHG):
with(plots): # voor extra plotopties (niet verplicht)

# 1. Definieer de metriek (hyperbolisch Klein-model)
J := Matrix([[1,0,0],[0,1,0],[0,0,-1]]);

# 2. Definieer een ideale gelijkzijdige driehoek (punten op de eenheidscirkel)
a1 := [1, 0, 1];
a2 := [-1/2, sqrt(3)/2, 1];
a3 := [-1/2, -sqrt(3)/2, 1];

A := Matrix([a1, a2, a3]);

(3.1)

# Stap 1: Nulcirkel, driehoek en hoekpunten
(*PlotAll2D(A, J, "Stap 1: Nulcirkel, driehoek en hoekpunten",
          elements=["null", "triangle", "vertices"]);*)

(*PlotAll2D(
    A,
    J,
    "test",
    ["null","triangle","vertices"]
);*)
(*PlotAll2D(A, J, "Stap 1", elements=["null","triangle","vertices"]);*)# FOUT met elements=
# Stap 1: Nulcirkel, driehoek en hoekpunten
PlotAll2D(A, J, "Stap 1", ["null","triangle","vertices"]);

elements = ["null", "triangle", "vertices"]

>	# Stap 2: + circumcenters PlotAll2D(A, J, "Stap 2", ["null","triangle","vertices","circumcenters"]);

elements = ["null", "triangle", "vertices", "circumcenters"]

>	# Stap 3: + circumlines PlotAll2D(A, J, "Stap 3", ["null","triangle","vertices","circumcenters","circumlines"]);

elements = ["null", "triangle", "vertices", "circumcenters", "circumlines"]

>	# Stap 4: + circumcircles en twin circles PlotAll2D(A, J, "Stap 4", ["null","triangle","vertices","circumcenters","circumlines","circumcircles","twin"]);

elements = ["null", "triangle", "vertices", "circumcenters", "circumlines", "circumcircles", "twin"]

>	# Stap 5: + Jay-, Wren-lijnen en bijbehorende punten PlotAll2D(A, J, "Stap 5", ["null","triangle","vertices","circumcenters","circumlines","circumcircles","twin","jay"]);

elements = ["null", "triangle", "vertices", "circumcenters", "circumlines", "circumcircles", "twin", "jay"]

>	# Stap 6: + Jay-, Wren-lijnen en bijbehorende punten PlotAll2D(A, J, "Stap 6", ["null","triangle","vertices","circumcenters","circumlines","circumcircles","twin","jay","wren"]);

elements = ["null", "triangle", "vertices", "circumcenters", "circumlines", "circumcircles", "twin", "jay", "wren"]

>	# Stap 7: + Jay-, Wren-lijnen en bijbehorende punten PlotAll2D(A, J, "Stap 7", ["null","triangle","vertices","circumcenters","circumlines","circumcircles","twin","jay","wren","circumjay"]);

elements = ["null", "triangle", "vertices", "circumcenters", "circumlines", "circumcircles", "twin", "jay", "wren", "circumjay"]

>	# Stap 8: + Jay-, Wren-lijnen en bijbehorende punten PlotAll2D(A, J, "Stap 8", ["null","triangle","vertices","circumcenters","circumlines","circumcircles","twin","jay","wren","circumjay","circumwren"]);

elements = ["null", "triangle", "vertices", "circumcenters", "circumlines", "circumcircles", "twin", "jay", "wren", "circumjay", "circumwren"]

>	# Stap 9: + Jay-, Wren-lijnen en bijbehorende punten PlotAll2D(A, J, "Stap 9", ["null","triangle",("vertices","circumcenters","circumlines","circumcircles","twin","jay","wren","circumjay",)"circumwren","jaywren"]);

elements = ["null", "triangle", "vertices", "circumcenters", "circumlines", "circumcircles", "twin", "jay", "wren", "circumjay", "circumwren", "jaywren"]

>	# Stap 10: + Jay-, Wren-lijnen en bijbehorende punten PlotAll2D(A, J, "Stap 10", ["null","triangle",("vertices","circumcenters","circumlines","circumcircles","twin","jay","wren","circumjay",)"circumwren","jaywren"]);

elements = ["null", "triangle", "circumwren", "jaywren"]

Download UHG_module_versieA_18-8-2026.mw

MaplePrimes - Newest Comments

@Ronan That's not a very smart t...

As far as I can make out.

Now in 3D with the unit triangle

> ...

UHG_module_18-8-2026.mw

@Ronan You're showing a lot of e...