HeteQuadrature/gjj/primitiveDebug.hpp

#include <array>
#include <bitset>
#include <iostream>
#include <booluarray.hpp>


#include <cstddef>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include "bernstein.hpp"
#include "multiloop.hpp"
#include "quadrature_multipoly.hpp"
#include "binomial.hpp"

#include "real.hpp"
#include "uvector.hpp"
#include "vector"
#include "xarray.hpp"
#include <chrono>
#include <memory>

#include "organizer/primitive.hpp"
#include "organizer/organizer.hpp"

#include "organizer/blobtree.hpp"


using namespace algoim::Organizer;
using namespace algoim;

void casePolyhedron1()
{
    // std::vector<std::shared_ptr<PrimitiveDesc>> ps;

    // mesh
    std::vector<uvector3> vertices = {uvector3(-0.8, -0.8, -0.8), uvector3(-0.8, -0.8, 0.8), uvector3(-0.8, 0.8, -0.8),
                                      uvector3(-0.8, 0.8, 0.8),   uvector3(0.8, -0.8, -0.8), uvector3(0.8, -0.8, 0.8),
                                      uvector3(0.8, 0.8, -0.8),   uvector3(0.8, 0.8, 0.8)};
    std::vector<int>      indices  = {3, 2, 0, 1,  // left
                                      4, 6, 7, 5,  // right
                                      6, 2, 3, 7,  // top
                                      1, 0, 4, 5,  // bottom
                                      7, 3, 1, 5,  // front
                                      2, 6, 4, 0}; // back
    std::vector<int>      scan     = {4, 8, 12, 16, 20, 24};

    // ps.emplace_back(std::make_shared<MeshDesc>(vertices, indices, scan));
    // ps.emplace_back(std::make_shared<SphereDesc>(0.8, 0., 1.));
    // ps.emplace_back(std::make_shared<PowerTensor>(makeSphere(0.2)));
    // ps.emplace_back(std::make_shared<MeshDesc>(MeshDesc(vertices, indices, scan)));
    basicTask(std::make_shared<MeshDesc>(MeshDesc(vertices, indices, scan)));
}

void casePolyhedron2()
{
    // std::vector<std::shared_ptr<PrimitiveDesc>> ps;

    // mesh
    std::vector<uvector3> vertices = {uvector3(-0.8, -0.8, -0.8), uvector3(-0.8, -0.8, 0.8), uvector3(-0.8, 0.8, -0.8),
                                      uvector3(-0.8, 0.8, 0.8),   uvector3(0.8, -0.8, -0.8), uvector3(0.8, -0.8, 0.8),
                                      uvector3(0.8, 0.8, -0.8),   uvector3(0.8, 0.8, 0.8)};
    std::vector<int>      indices  = {
        3, 2, 0,
        1, // left
        6, 2, 3,
        7  // top
    };
    std::vector<int> scan = {4, 8};

    // ps.emplace_back(std::make_shared<MeshDesc>(vertices, indices, scan));
    // ps.emplace_back(std::make_shared<SphereDesc>(0.8, 0., 1.));
    // ps.emplace_back(std::make_shared<PowerTensor>(makeSphere(0.2)));
    // ps.emplace_back(std::make_shared<MeshDesc>(MeshDesc(vertices, indices, scan)));
    basicTask(std::make_shared<MeshDesc>(MeshDesc(vertices, indices, scan)));
}

void casePolyhedron3()
{
    std::vector<std::shared_ptr<PrimitiveDesc>> primitiveDescriptions;
    // std::vector<uvector3>                       vertices = {uvector3(-1.6, 0, 0),
    //                                                         uvector3(-1.6, 0, 1.6),
    //                                                         uvector3(-1.6, 1.6, 0),
    //                                                         uvector3(-1.6, 1.6, 1.6),
    //                                                         uvector3(1.6, 0, 0),
    //                                                         uvector3(1.6, 0, 1.6),
    //                                                         uvector3(1.6, 1.6, 0),
    //                                                         uvector3(1.6, 1.6, 1.6)};
    std::vector<uvector3> vertices = {uvector3(-0.8, -0.8, -0.8), uvector3(-0.8, -0.8, 0.8), uvector3(-0.8, 0.8, -0.8),
                                      uvector3(-0.8, 0.8, 0.8),   uvector3(0.8, -0.8, -0.8), uvector3(0.8, -0.8, 0.8),
                                      uvector3(0.8, 0.8, -0.8),   uvector3(0.8, 0.8, 0.8)};
    std::vector<int>      indices  = {3, 2, 0,
                                      1, // left
                                      6, 2, 3,
                                      7, // top
                                      // 7,
                                      // 3,
                                      // 1,
                                      // 5, // front
                                      2, 6, 4, 0}; // back
    std::vector<int>      scan     = {4, 8, 12};
    basicTask(std::make_shared<MeshDesc>(MeshDesc(vertices, indices, scan)));
}

void casePolyhedronSphere()
{
    // PI * r^3 / 6
    auto                  phi0     = std::make_shared<SphereDesc>(SphereDesc(0.8, uvector3(-0.8, 0.8, -0.8), 1.));
    std::vector<uvector3> vertices = {uvector3(-0.8, -0.8, -0.8), uvector3(-0.8, -0.8, 0.8), uvector3(-0.8, 0.8, -0.8),
                                      uvector3(-0.8, 0.8, 0.8),   uvector3(0.8, -0.8, -0.8), uvector3(0.8, -0.8, 0.8),
                                      uvector3(0.8, 0.8, -0.8),   uvector3(0.8, 0.8, 0.8)};
    std::vector<int>      indices  = {3, 2, 0,
                                      1,           // left
                                      6, 2, 3,
                                      7,           // top
                                      2, 6, 4, 0}; // back
    std::vector<int>      scan     = {4, 8, 12};
    std::vector<std::shared_ptr<PrimitiveDesc>> primitiveDescriptions(2);
    primitiveDescriptions[0] = phi0;
    primitiveDescriptions[1] = std::make_shared<MeshDesc>(MeshDesc(vertices, indices, scan));
    basicTask(primitiveDescriptions);
}

void caseScene()
{
    const int                                   PRIMITIVE_CNT = 6;
    std::vector<std::shared_ptr<PrimitiveDesc>> primitiveDescriptions(PRIMITIVE_CNT);
    primitiveDescriptions[2]                    = std::make_shared<CuboidDesc>(CuboidDesc(0., 1.6));
    primitiveDescriptions[1]                    = std::make_shared<CuboidDesc>(CuboidDesc(uvector3(0.6, 0.6, -0.6), 2.));
    primitiveDescriptions[0]                    = std::make_shared<SphereDesc>(SphereDesc(0.7, uvector3(0.8, 0.8, 0.8), 1.));
    primitiveDescriptions[3]                    = std::make_shared<SphereDesc>(SphereDesc(0.5, uvector3(-0.3, -0.8, 0.8), 1.));
    std::vector<uvector3> pyramidBottomVertices = {
        uvector3{-1, -1, 0},
        uvector3{1,  -1, 0},
        uvector3{1,  1,  0},
        uvector3{-1, 1,  0}
    };
    primitiveDescriptions[4] = std::make_shared<PyramidDesc>(pyramidBottomVertices, uvector3{0, 0, 1});
    primitiveDescriptions[5] = std::make_shared<ConeDesc>(ConeDesc(uvector3(0., -0.2, 0.), -0.7, 0.4, 1));
    // primitiveDescriptions[6] = std::make_shared<CylinderDesc>(CylinderDesc(uvector3(-0.3, 0.3, 2.3), 0.4, 3.6, 1));
    organizer::BlobTree blobTree;
    blobTree.structure.resize(PRIMITIVE_CNT * 2 - 1);
    blobTree.primitiveNodeIdx.resize(PRIMITIVE_CNT);
    blobTree.structure[0]     = {1, 0, 0, 0, 1, 2};  // cube1
    blobTree.structure[1]     = {1, 0, 0, 0, 0, 0};  // cube2
    blobTree.structure[2]     = {0, 0, 0, 0, 1, 6};  // Union of cubes = opNode1
    blobTree.structure[3]     = {1, 0, 0, 0, 1, 5};  // sphere1
    blobTree.structure[4]     = {1, 0, 0, 0, 0, 0};  // sphere2
    blobTree.structure[5]     = {0, 0, 0, 0, 0, 0};  // Union of spheres = opNode2
    blobTree.structure[6]     = {0, 2, 0, 0, 1, 10}; // Difference of opNode1 and sphere2 = opNode3
    blobTree.structure[7]     = {1, 0, 0, 0, 1, 9};  // Pyramid
    blobTree.structure[8]     = {1, 0, 0, 0, 0, 0};  // Cone
    blobTree.structure[9]     = {0, 1, 0, 0, 0, 0};  // Intersection of Pyramid and Cone = opNode4
    blobTree.structure[10]    = {0, 0, 0, 0, 1, 12}; // Union of opNode3 and opNode4 = opNode5
                                                     // blobTree.structure[11]    = {1, 0, 0, 0, 0, 0};  // Cylinder
    // blobTree.structure[12]    = {0, 2, 0, 0, 1, 0};  // Difference of opNode5 and Cylinder
    // blobTree.primitiveNodeIdx = {0, 1, 3, 4, 7, 8, 11};
    // quadratureScene(primitiveDescriptions, uvector3(-1., -1.3, -1.6), uvector3(1.6, 1.6, 2.3), blobTree);
    blobTree.primitiveNodeIdx = {0, 1, 3, 4, 7, 8};
    quadratureScene(primitiveDescriptions, uvector3(-1., -1.3, -1.6), uvector3(1.6, 1.6, 1.5), blobTree);
}

void testDeCasteljau()
{
    auto    phiDesc = std::make_shared<SphereDesc>(SphereDesc(0.8, uvector3(0), 1.));
    tensor3 tensor(nullptr, 3), tensor01(nullptr, 3), tensorBernstein(nullptr, 3), transformedTensorBernstein(nullptr, 3);
    algoim_spark_alloc(real, tensor, tensor01, tensorBernstein, transformedTensorBernstein);
    makeSphere(*phiDesc, tensor);
    uvector3 xmax = 1, xmin = -1, range = xmax - xmin;
    Organizer::detail::powerTransformation(range, xmin, tensor, tensor01);
    Organizer::detail::power2BernsteinTensor(tensor01, tensorBernstein);

    // bernstein::deCasteljau(tensorBernstein, uvector3(0), uvector3(0.2690598923241497 + 0.0000001),
    // transformedTensorBernstein);
    bernstein::deCasteljau(tensorBernstein, uvector3(0.2690598923241497 + 0.0000001),
                           uvector3(1 - 0.2690598923241497 - 0.0000001), transformedTensorBernstein);
    uvector3 testX = uvector3(0.5);

    int  sign  = bernstein::uniformSign(transformedTensorBernstein);
    real evalX = evalPower(tensor, testX);

    std::cout << "evalX original rep = " << evalX << std::endl;
    evalX = bernstein::evalBernsteinPoly(tensorBernstein, testX);
    std::cout << "evalX bernstein within 0-1 = " << evalX << std::endl;
    evalX = bernstein::evalBernsteinPoly(transformedTensorBernstein, testX);
    std::cout << "evalX bernstein after Decasteljau = " << evalX << std::endl;
    std::cout << "sign = " << sign << std::endl;
}

void testSubDivideWithDeCasteljau()
{
    auto    phiDesc = std::make_shared<SphereDesc>(SphereDesc(0.7, uvector3(0.8), 1.));
    tensor3 tensor(nullptr, 3), tensor01(nullptr, 3), tensorBernstein(nullptr, 3), transformedTensorBernstein(nullptr, 3);
    algoim_spark_alloc(real, tensor, tensor01, tensorBernstein, transformedTensorBernstein);
    makeSphere(*phiDesc, tensor);
    uvector3 xmin = uvector3(-1., -1.3, -1.6), xmax = uvector3(1.6, 1.6, 2.3), range = xmax - xmin;
    Organizer::detail::powerTransformation(range, xmin, tensor, tensor01);
    Organizer::detail::power2BernsteinTensor(tensor01, tensorBernstein);
    xmin = 0, xmax = 1;

    // bernstein::deCasteljau(tensorBernstein, uvector3(0), uvector3(0.2690598923241497 + 0.0000001),
    // transformedTensorBernstein);
    for (MultiLoop<3> j(0, 2); ~j; ++j) {
        if (all(j() == uvector3i(1, 0, 0))) {
            int aaa = 1;
            int bbb = 1;
        }
        auto aabb = Organizer::detail::getOneEightCellAABB(xmin, xmax, j(), 0);
        bernstein::deCasteljau(tensorBernstein, aabb.first, aabb.second, transformedTensorBernstein);
        int sign = bernstein::uniformSign(transformedTensorBernstein);
        std::cout << "j(): (" << j(0) << ", " << j(1) << ", " << j(2) << "), sign: " << sign << std::endl;
    }
    uvector3 testX = uvector3(0.5);

    bernstein::deCasteljau(tensorBernstein, uvector3(-1., -1.3, 0.35), uvector3(0.3, 0.15, 2.3), transformedTensorBernstein);
    int  sign  = bernstein::uniformSign(transformedTensorBernstein);
    real evalX = evalPower(tensor, testX);

    std::cout << "evalX original rep = " << evalX << std::endl;
    evalX = bernstein::evalBernsteinPoly(tensorBernstein, testX);
    std::cout << "evalX bernstein within 0-1 = " << evalX << std::endl;
    evalX = bernstein::evalBernsteinPoly(transformedTensorBernstein, testX);
    std::cout << "evalX bernstein after Decasteljau = " << evalX << std::endl;
    std::cout << "sign = " << sign << std::endl;
}

void testBlob()
{
    organizer::Blob blob = {5, 3, 4, 5, 6};

    // std::cout << blob.isPrimitive << std::endl;
    // std::cout << blob.nodeOp << std::endl;
    // std::cout << blob.ignoreMod << std::endl;
    // std::cout << blob.isLeft << std::endl;
    // std::cout << blob.ancestor << std::endl;
    std::cout << sizeof(blob) << std::endl;
    std::cout << sizeof(int) << std::endl;
}

void vectorDebug()
{
    struct A {
        std::vector<real> data;
        A() = default;
    };

    A   a;
    int s = a.data.size();
    std::cout << "size: " << s << std::endl;
}

void testPrimitive()
{
    // casePolyhedron1();
    // casePolyhedronSphere();
    // testSubDivideWithDeCasteljau();
    // testBlob();
    caseScene();
    // vectorDebug();
}