#include <iostream>

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

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

// コールバック関数を使用するのに必要
#include <vtkCallbackCommand.h>


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

// コールバック関数に渡すデータ
struct MyData
{
  std::string text;
  int counter;
};

// タイマーのコールバック関数
void MyTimerCallbackFunction(vtkObject* caller, long unsigned int eventId, void* clientData, void* callData)
{
  MyData* data = static_cast<MyData*>(clientData);

  // タイマーイベントが発生したことを確認する
  std::cout << data->text << " " << data->counter << std::endl;
  data->counter++;

  // 画面更新
  auto interactor = static_cast<vtkRenderWindowInteractor*>(caller);
  interactor->Render();
}

int main(int /*argc*/, char** /*argv*/)
{

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

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

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

  // タイマーに渡す構造体の作成
  MyData callbackData{ "Counter:",0 };

  // タイマー作成
  auto timerCallback = vtkSmartPointer<vtkCallbackCommand>::New();
  timerCallback->SetCallback(MyTimerCallbackFunction); // コールバック関数を設定
  timerCallback->SetClientData(&callbackData); // コールバック関数に渡すデータを設定

  interactor->AddObserver(vtkCommand::TimerEvent, timerCallback); // タイマーイベントにコールバック関数を設定

  interactor->Initialize();
  interactor->CreateRepeatingTimer(100); // 100msごとにタイマーイベントを発生させる

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


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

  return 0;
}

#include <iostream>
#include <unicode/ubrk.h>
#include <unicode/ustring.h>

#include <vector>
#include <fstream>

// 要リンク
#pragma comment(lib, "icuuc.lib")


struct Grapheme {
    int32_t start;
    int32_t end;
};

std::vector<Grapheme> createGraphemeList(const char16_t* text,const size_t length) {

    UErrorCode status = U_ZERO_ERROR;
    std::vector<Grapheme> graphemes;

    // イテレータ作成
    UBreakIterator* bi = ubrk_open(UBRK_CHARACTER, "ja_JP", nullptr, 0, &status);

    if (U_FAILURE(status)) {
        return std::vector<Grapheme>();  // エラーが発生
    }

    // テキストを設定
    ubrk_setText(bi, (const UChar*)text, length, &status);
    // ubrk_setText(bi, (const UChar*)text, -1, &status);// null終端の場合は -1 を指定できる
    
    if (U_FAILURE(status)) {
        ubrk_close(bi);
        return std::vector<Grapheme>();  // エラーが発生
    }

    // 最初の書記素の位置を取得
    int32_t start = ubrk_first(bi);
    int32_t end;

    // 書記素リストを作成
    while ((end = ubrk_next(bi)) != UBRK_DONE) {

        graphemes.push_back(Grapheme{ start, end });
        start = end;

    }

    // 終了処理
    ubrk_close(bi);

    return graphemes;
}

int main()
{
    // 日本語ロケール
    setlocale(LC_ALL, "japanese");

    std::u16string u16str = u"あいうえお";


    std::vector<Grapheme> glist =  createGraphemeList(u16str.data(),u16str.length());

    for(size_t i = 0; i < glist.size(); i++) {
        size_t length = glist[i].end - glist[i].start;

        std::wstring u16w( (wchar_t*)u16str.data()+ glist[i].start, length);
        std::wcout << u16w;// 一文字ずつ表示
        std::wcout << "( " << glist[i].start << L" " << glist[i].end << " )" << std::endl;
    }

}

int main()
{
    // 日本語ロケール
    setlocale(LC_ALL, "japanese");

    std::u16string u16str = u"あい👨‍👩‍👧‍👦うえお";

    // 👨‍👩‍👧‍👦　絵文字（結合文字）

    std::vector<Grapheme> glist = createGraphemeList(u16str.data(), u16str.length());

    // バイナリ出力
    std::ofstream out("grapheme.txt", std::ios_base::binary);

    for (size_t i = 0; i < glist.size(); i++) {

        size_t length = glist[i].end - glist[i].start;
        out.write((const char*)(u16str.data() + glist[i].start), length * 2);// 一文字出力
        out.write("\n", 2);

    }

}

#pragma warning(disable:4996)

#if defined(_DEBUG)
#pragma comment(lib,"C:\\libraries\\Open3D-0.18.0\\debug\\lib\\Open3D.lib")
#else
#pragma comment(lib,"C:\\libraries\\Open3D-0.18.0\\release\\lib\\Open3D.lib")
#endif

#include <Open3D/Open3D.h>

#include <iostream>

int main()
{
  std::string filename = "bunny.ply";
  auto mesh = open3d::io::CreateMeshFromFile(filename);
  auto pcd = open3d::io::CreatePointCloudFromFile(filename);
}

#include <pcl/io/pcd_io.h>
#include <pcl/point_types.h>
#include <pcl/features/normal_3d.h>
#include <pcl/filters/statistical_outlier_removal.h>

pcl::PointCloud<pcl::PointXYZ>::Ptr create_cloud() {

    // 点群データの生成
    pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>());

    cloud->width = 1000;
    cloud->height = 1;
    cloud->is_dense = false;
    cloud->points.resize(cloud->width * cloud->height);

    for (size_t i = 0; i < cloud->points.size(); ++i)
    {
        cloud->points[i].x = 1024 * rand() / (RAND_MAX + 1.0f);
        cloud->points[i].y = 1024 * rand() / (RAND_MAX + 1.0f);
        cloud->points[i].z = 1024 * rand() / (RAND_MAX + 1.0f);
    }

    return cloud;
}

int main(int argc, char** argv)
{
    auto cloud = create_cloud();

    pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filtered(new pcl::PointCloud<pcl::PointXYZ>);

    pcl::StatisticalOutlierRemoval<pcl::PointXYZ> sor;
    sor.setInputCloud(cloud);
    sor.setMeanK(50);
    sor.setStddevMulThresh(1.0);
    sor.filter(*cloud_filtered);

    return 0;
}

/** \internal Frees memory allocated with aligned_malloc. */
EIGEN_DEVICE_FUNC inline void aligned_free(void *ptr)
{
  #if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED

    EIGEN_USING_STD(free)
    free(ptr);

  #else
    handmade_aligned_free(ptr);
  #endif
}

  vtkSmartPointer<vtkActor> actor1 = vtkSmartPointer<vtkActor>::New();
  std::cout << "actor1 reference count: " << actor1->GetReferenceCount() << std::endl;

  vtkSmartPointer<vtkActor> actor2 = actor1;
  std::cout << "actor2 reference count: " << actor2->GetReferenceCount() << std::endl;

  actor1 = nullptr;// actor1を無効化
  std::cout << "Delete" << std::endl;

  // ここは通らない
  if(actor1)
    std::cout << "actor1 reference count: " << actor1->GetReferenceCount() << std::endl;

  if(actor2)
    std::cout << "actor2 reference count: " << actor2->GetReferenceCount() << std::endl;

  vtkWeakPointer<vtkActor> weak_actor; // WeakPointerを定義

  {

    vtkSmartPointer<vtkActor> actor1 = vtkSmartPointer<vtkActor>::New();
    std::cout << "actor1 reference count: " << actor1->GetReferenceCount() << std::endl;

    weak_actor = actor1;// actor1 を弱参照　参照カウンタは増えない
    std::cout << "weak_actor reference count: " << weak_actor->GetReferenceCount() << std::endl;


    vtkSmartPointer<vtkActor> actor2 = actor1;
    std::cout << "actor2 reference count: " << actor2->GetReferenceCount() << std::endl;


    actor1 = nullptr;
    std::cout << "Delete" << std::endl;

    // ここは通らない
    if (actor1)
      std::cout << "actor1 reference count: " << actor1->GetReferenceCount() << std::endl;

    if (actor2)
      std::cout << "actor2 reference count: " << actor2->GetReferenceCount() << std::endl;

  }

  if (weak_actor) {
    // ここは通らない
    std::cout << "actor1 reference count: " << weak_actor->GetReferenceCount() << std::endl;
  }
  else {
    // こちらを通る
    std::cout << "actor is deleted" << std::endl;
  }

#include <iostream>
#include <fstream>
#include <sstream>

#include <regex>

#include <gumbo.h>
 

std::string getTagName(std::string str) {
    // HTMLのタグ名を取得する関数
    // タグは< > で囲まれているが、attribute等があるかもしれないので
    // < スペース 文字列 という構造になっている部分の文字列部分だけを取り出す
    std::regex tagPattern("<\\s*([^ >]+)\\s*");
    std::smatch matches;
    std::regex_search(str, matches, tagPattern);
    return matches[1].str();
}

void myTraceCore(const GumboNode* node, const char* src) {


    switch (node->type) {
    case GUMBO_NODE_ELEMENT:
    {

        // 要素開始位置
        const char* tag_start = node->v.element.original_tag.data;

        // 要素終了位置
        const char* tag_end = node->v.element.original_end_tag.data;

        std::string tagname;
        // タグ名を抽出
        tagname = getTagName(tag_start);
        std::cout << "tag: '" << tagname << "'" << std::endl;


        // 子要素一覧へアクセス
        const GumboVector* children = &node->v.element.children;

        // 子要素がある場合
        if (children->length > 0) {

            for (unsigned int i = 0; i < children->length; ++i) {
 
                const GumboNode* node = static_cast<GumboNode*>(children->data[i]);

                myTraceCore(node, src);

            }

        }

        // タグ名を抽出
        tagname = getTagName(tag_end);
        std::cout << "tag: '" << tagname << "'" << std::endl;


        break;
    }
    case GUMBO_NODE_TEXT:
        // テキストノードの場合	
        std::cout << "text: '" << node->v.text.text << "'" << std::endl;
        break;
    case GUMBO_NODE_WHITESPACE:
        // 空白ノードの場合
        std::cout << "whitespace: '" << node->v.text.text << "'" << std::endl;
        break;
    default:
        std::cout << "others: '" << node->v.text.text << "'" << std::endl;
        break;
    }
}

void myTrace(std::string html) {

    // Gumboでパース
    GumboOutput* output = gumbo_parse(html.c_str());

    // 自作関数の本体呼び出し
    myTraceCore(output->root,html.c_str());

    // GumboOutputの解放
    gumbo_destroy_output(&kGumboDefaultOptions, output);

}



int main()
{
    std::string html = R"(
<!DOCTYPE html>
<html>
  <head>
    <title>The Title</title>
  </head>
  <body>
    <h1>Test</h1>
  </body>
</html>
)";

    myTrace(html);

}

#include <iostream>
#include <fstream>
#include <sstream>

#include <regex>

#include <gumbo.h>
 

// 要素の属性を取得する関数
void myAttributes(const GumboNode* node) {

  if (node->type != GUMBO_NODE_ELEMENT) {
    return;
  }

  // 要素の属性を取得
  const GumboVector* attributes = &node->v.element.attributes;

  // 属性リストへアクセス
  for (unsigned int i = 0; i < attributes->length; ++i) {
    GumboAttribute* attr = (GumboAttribute*)attributes->data[i];
    std::cout << "    ";
    std::cout << "    " << attr->name << " : " << attr->value << std::endl;
  }

}