#include <iostream>

//VTK_MODULE_INITに必要
#include <vtkAutoInit.h>


#include <vtkSmartPointer.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>

#include <vtkDoubleArray.h>
#include <vtkPointData.h>
#include <vtkActor.h>

#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>


#pragma comment(lib,"opengl32.lib")
#pragma comment(lib,"psapi.lib")
#pragma comment(lib,"dbghelp.lib")
#pragma comment(lib,"ws2_32.lib")


//必須
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);

void create(
    
    vtkSmartPointer<vtkPoints> points, 
    vtkSmartPointer<vtkDoubleArray> colors, 
    vtkSmartPointer<vtkCellArray> cells

) {

    for (size_t i = 0; i < 100000; i++) {

        double x = (double)rand() / (double)RAND_MAX;
        double y = (double)rand() / (double)RAND_MAX;
        double z = (double)rand() / (double)RAND_MAX;

        points->InsertNextPoint(x, y, z);  // 座標追加
        colors->InsertNextTuple3(x, y, z); // 色情報追加

        cells->InsertNextCell(1);  // 要素数
        cells->InsertCellPoint(i); // 頂点インデックスを追加

    }
}

vtkSmartPointer<vtkActor> createActor() {

    // 頂点配列
    vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();

    // 色情報の配列
    vtkSmartPointer<vtkDoubleArray> colors = vtkSmartPointer<vtkDoubleArray>::New();
    colors->SetNumberOfComponents(3);
    colors->SetName("Colors");

    // 頂点インデクスの配列
    vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();

    create(points, colors, cells);

    ///////////////////////////////////////////////////

    // --- vtkPolyData作成 ---
    auto polydata = vtkSmartPointer<vtkPolyData>::New();
    polydata->SetPoints(points);
    polydata->SetVerts(cells);
    polydata->GetPointData()->SetScalars(colors);

    // --- actor作成 ---
    auto mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
    mapper->SetInputData(polydata);

    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
    actor->SetMapper(mapper);

    return actor;

}

int main(int /*argc*/, char** /*argv*/)
{
    auto actor = createActor();

    auto renderer = vtkSmartPointer<vtkRenderer>::New();
    renderer->AddActor(actor);
    renderer->ResetCamera();

    //////////////////////////////////////
    auto interactor = vtkSmartPointer<vtkRenderWindowInteractor>::New();

    //////////////////////////////////////
    auto renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
    renderWindow->AddRenderer(renderer);
    renderWindow->SetInteractor(interactor);
    renderWindow->Render();

    interactor->Start(); //イベントループへ入る

    return 0;
}

#include <Windows.h>
#include <open3d/Open3D.h>
#include <GL/GL.h>

#pragma comment(lib, "opengl32.lib")


std::shared_ptr<open3d::geometry::LineSet> obb_to_lineset(const open3d::geometry::OrientedBoundingBox& obb) {

    // BoundingVolume.h 参照
    ///      0 ------------------- 1
    ///       /|                /|
    ///      / |               / |
    ///     /  |              /  |
    ///    /   |             /   |
    /// 2 ------------------- 7  |
    ///   |    |____________|____| 6
    ///   |   /3            |   /
    ///   |  /              |  /
    ///   | /               | /
    ///   |/                |/
    /// 5 ------------------- 4
    std::vector<Eigen::Vector3d> points = obb.GetBoxPoints();

    std::vector<Eigen::Vector2i> linesegments;
    // 0-2-7-1
    linesegments.push_back(Eigen::Vector2i(0,2));
    linesegments.push_back(Eigen::Vector2i(2,7));
    linesegments.push_back(Eigen::Vector2i(7,1));
    linesegments.push_back(Eigen::Vector2i(1,0));
    // 4-5-3-6
    linesegments.push_back(Eigen::Vector2i(4,5));
    linesegments.push_back(Eigen::Vector2i(5,3));
    linesegments.push_back(Eigen::Vector2i(3,6));
    linesegments.push_back(Eigen::Vector2i(6,4));
    // 0-3-5-2
    linesegments.push_back(Eigen::Vector2i(0,3));
    linesegments.push_back(Eigen::Vector2i(3,5));
    linesegments.push_back(Eigen::Vector2i(5,2));
    linesegments.push_back(Eigen::Vector2i(2,0));
    // 4-6-1-7
    linesegments.push_back(Eigen::Vector2i(4,6));
    linesegments.push_back(Eigen::Vector2i(6,1));
    linesegments.push_back(Eigen::Vector2i(1,7));
    linesegments.push_back(Eigen::Vector2i(7,4));

    // 色を設定
    std::vector<Eigen::Vector3d> colors;
    for (size_t i = 0; i < linesegments.size(); ++i) {
		colors.push_back(Eigen::Vector3d(0.0, 0.0, 0.0));
	}

    auto line_set = std::make_shared<open3d::geometry::LineSet>();
    line_set->points_ = points;
    line_set->lines_ = linesegments;
    line_set->colors_ = colors;

    return line_set;

}



int main() {
    // 点群データの作成
    auto cloud = std::make_shared<open3d::geometry::PointCloud>();

    // ランダムな点を生成
    for (int i = 0; i < 50000; ++i) {
        double x = (static_cast<double>(rand()) / RAND_MAX) * 80.0;
        double y = (static_cast<double>(rand()) / RAND_MAX) * 30.0;
        double z = (static_cast<double>(rand()) / RAND_MAX) * 10.0;
        cloud->points_.push_back(Eigen::Vector3d(x, y, z));
    }

    auto lineset = obb_to_lineset(cloud->GetOrientedBoundingBox());

    // 表示用のウィンドウを作成
    open3d::visualization::Visualizer visualizer;
    visualizer.CreateVisualizerWindow("Open3D Visualization", 800, 600);

    visualizer.AddGeometry(cloud);
    visualizer.AddGeometry(lineset);
    visualizer.UpdateGeometry();
    visualizer.PollEvents();
    visualizer.UpdateRender();

    // ウィンドウを閉じるまでループ
    while (visualizer.PollEvents()) {
        visualizer.UpdateRender();
    }

    visualizer.DestroyVisualizerWindow();
    return 0;
}

#pragma once

#include <Eigen/Dense>

#include <filesystem>
#include <vector>
#include <string>

#include "pugixml.hpp"

struct Data3D {
    std::vector< Eigen::Vector3d > points;
    std::vector< Eigen::Vector3i > triangles; // 頂点ID三つで構成される三角形
    std::vector< int > polyline;// N個の頂点を格納した頂点リストで表現される折れ線
};

void save_vtp_vtkfree(const std::string& filename, const Data3D& data) {
    pugi::xml_document doc;
    auto vtkFile = doc.append_child("VTKFile");
    vtkFile.append_attribute("type") = "PolyData";
    vtkFile.append_attribute("version") = "1.0";
    vtkFile.append_attribute("byte_order") = "LittleEndian";

    auto polyData = vtkFile.append_child("PolyData");
    polyData.append_attribute("WholeExtent") = "0 0 0 0 0 0";
    auto piece = polyData.append_child("Piece");
    piece.append_attribute("NumberOfPoints") = data.points.size();
    piece.append_attribute("NumberOfLines") = data.polyline.empty() ? 0 : 1;
    piece.append_attribute("NumberOfPolys") = data.triangles.size();

    //////////////////////////////////////////////////////////////////
    // Points
    auto pointsNode = piece.append_child("Points");
    auto pointsArray = pointsNode.append_child("DataArray");
    pointsArray.append_attribute("type") = "Float64";
    pointsArray.append_attribute("NumberOfComponents") = 3;
    pointsArray.append_attribute("format") = "ascii";
    std::ostringstream pointsStream;
    for (const auto& p : data.points) {
        pointsStream << p.x() << " " << p.y() << " " << p.z() << " ";
    }
    pointsArray.text().set(pointsStream.str().c_str());

    //////////////////////////////////////////////////////////////////
    // PolyLine
    if (!data.polyline.empty()) {
        auto linesNode = piece.append_child("Lines");
        auto connArray = linesNode.append_child("DataArray");
        connArray.append_attribute("type") = "Int32";
        connArray.append_attribute("Name") = "connectivity";
        connArray.append_attribute("format") = "ascii";
        std::ostringstream connStream;
        for (const auto& pointIndex : data.polyline) {
            connStream << pointIndex << " ";
        }
        connArray.text().set(connStream.str().c_str());

        auto offsetArray = linesNode.append_child("DataArray");
        offsetArray.append_attribute("type") = "Int32";
        offsetArray.append_attribute("Name") = "offsets";
        offsetArray.append_attribute("format") = "ascii";
        std::ostringstream offsetStream;
        offsetStream << data.polyline.size();
        offsetArray.text().set(offsetStream.str().c_str());
    }

    //////////////////////////////////////////////////////////////////
    // Triangles
    if (!data.triangles.empty()) {
        auto polysNode = piece.append_child("Polys");
        auto polyConnArray = polysNode.append_child("DataArray");
        polyConnArray.append_attribute("type") = "Int32";
        polyConnArray.append_attribute("Name") = "connectivity";
        polyConnArray.append_attribute("format") = "ascii";
        std::ostringstream polyConnStream;
        for (const auto& tri : data.triangles) {
            polyConnStream << tri[0] << " " << tri[1] << " " << tri[2] << " ";
        }
        polyConnArray.text().set(polyConnStream.str().c_str());

        auto polyOffsetArray = polysNode.append_child("DataArray");
        polyOffsetArray.append_attribute("type") = "Int32";
        polyOffsetArray.append_attribute("Name") = "offsets";
        polyOffsetArray.append_attribute("format") = "ascii";
        std::ostringstream polyOffsetStream;
        for (size_t i = 0; i < data.triangles.size(); ++i) {
            polyOffsetStream << (i + 1) * 3 << " ";
        }
        polyOffsetArray.text().set(polyOffsetStream.str().c_str());
    }
    //////////////////////////////////////////////////////////////////

    doc.save_file(filename.c_str());
}