; 画像番号は (gimp-image-list) で取得できる数字。今回は「1」
(gimp-xcf-save 
  0                                        ; ダミーパラメータ
  1                                        ; 画像番号
  (car (gimp-image-get-active-drawable 1)) ; 有効にしたいレイヤー（現在選択中のレイヤー）
  "c:/data/test.xcf"                       ; 保存ファイル名 URI形式
  "test.xcf"                               ; 保存ファイルのベース名
)

;; 画素番号と画像幅からx座標を計算
(define (getx pos width)
  (remainder pos width)
)

;; x座標と画素番号と画像幅からy座標を計算し、x,yで返す
(define (getxy x pos width)
  (list
    x
    (/ (- pos x) width)
  )
)

;; 画素番号と画像幅からx,y座標を計算する
(define (2dcoord pos width)
    (getxy (getx pos width) pos width)
)

// x,yから画素番号を算出
inline int calcpos(int x, int y,int width) {
  return
    y * width + x;
}

// 画素番号と画像幅からx座標を計算
int getx(int pos, int width) {
  return pos % width;
}

// 画素番号とx座標と画像幅からy座標を計算
int gety(int x, int pos, int width) {
  return (pos - x) / width;
}


int main()
{
  int width = 50;
  int height = 25;

  int x = 12;
  int y = 23;

  int pos = calcpos(x, y, width); //1162

  printf("pos %d\n", pos);

  int xx = getx(pos, width);
  int yy = gety(xx, pos, width);

  printf("xx %d\n", xx);
  printf("yy %d\n", yy);

}

; レイヤー一覧
(define (get-layer-list image)
  (vector->list 
    (car 
      (cdr 
        (gimp-image-get-layers image)
      )
    )
  )
)

; imagelistの中からテキストレイヤーだけを抽出する
(define (get-text-layers imagelist)
  (if ( null? imagelist )
    '()
     (if (= 1 (car (gimp-drawable-is-text-layer (car imagelist) ) ) )
       (cons
         (car imagelist)
         (get-text-layers (cdr imagelist) )
       )
       (get-text-layers (cdr imagelist) )
     )
  )
)

;; 画像一覧
(define Images (vector->list (car (cdr (gimp-image-list)))))
(define ImageIndex (car Images) )

;; ImageIndex内のレイヤー一覧
(define Layers (vector->list (car (cdr (gimp-image-get-layers ImageIndex)))))
(define LayerIndex (car Layers) )

;; 編集対象は以後Drawable
(define Drawable LayerIndex)

;; 画像サイズ確認
(gimp-drawable-width Drawable)
(gimp-drawable-height Drawable)

;; 座標
(define x 10)
(define y 10)

;; ピクセルの更新
(gimp-drawable-set-pixel Drawable x x 3 #(255 0 0) )
(gimp-displays-flush)
(gimp-drawable-update Drawable x y 1 1)

#include <cstdio>
#include <string>
#include <variant>

enum VARIANT_TYPES {
  V_INT = 0,
  V_STR = 1,
  V_DBL = 2
};

int main()
{

  std::variant<int, std::string, double> val;

  val = 2;
  //val = 5.5;
  //val = "abc";

  if (val.index() == V_INT) {
    int& x = std::get<V_INT>(val);
    printf("--- %d\n", x);
  }

  else if(val.index()==V_STR){
    std::string& s = std::get<V_STR>(val);
    printf("--- %s\n", s.c_str());
  }

  else if (val.index() == V_DBL) {
    double& d = std::get<V_DBL>(val);
    printf("--- %lf\n", d);
  }

  int k = getchar();

}

#include <cstdio>
#include <string>

#include <variant>

struct Print {

  // int が代入されたときに呼び出される
  void operator()(const int& data) {
    printf("--- %d\n", data);
  }

  // std::string が代入されたときに呼び出される
  void operator()(const std::string& data) {
    printf("--- %s\n", data.c_str());
  }

  // double が代入されたときに呼び出される
  void operator()(const double& data) {
    printf("--- %lf\n", data);
  }

};

int main()
{

  std::variant<int, std::string, double> val;

  val = 2;
  std::visit(Print(), val);

  val = 5.5;
  std::visit(Print(), val);

  val = "abc";
  std::visit(Print(), val);

  int k = getchar();
}

#include <cstdio>
#include <string>

#include <variant>


struct Print {

  // int が代入されたときに呼び出される
  void operator()(const int& data) {
    printf("--- %d\n", data);
  }

  // std::string が代入されたときに呼び出される
  void operator()(const std::string& data) {
    printf("--- %s\n", data.c_str());
  }

  // double が代入されたときに呼び出される
  void operator()(const double& data) {
    printf("--- %lf\n", data);
  }

};

struct Add {

  // int が代入されたときに呼び出される
  void operator()(int& data, const int val) {
    data += val;
  }

  // std::string が代入されたときに呼び出される
  void operator()(std::string& data, const int val) {
    data += std::to_string(val);
  }

  // double が代入されたときに呼び出される
  void operator()(double& data, const int val) {
    data += val;
  }

};

int main()
{

  std::variant<int, std::string, double> val;


  val = 2;
  std::visit( Add(), val,std::variant<int>(4) );
  std::visit(Print(),val);

  val = 5.5;
  std::visit( Add(), val, std::variant<int>(4));
  std::visit(Print(), val);

  val = "abc";
  std::visit( Add(), val, std::variant<int>(4));
  std::visit(Print(), val);

  int k = getchar();
}

#include <cstdio>
#include <string>

#include <variant>

struct Print {

  std::string _sign;
public:
  Print(const std::string& sign):_sign(sign) {}

  // int が代入されたときに呼び出される
  void operator()(const int& data) {
    printf("%s %d\n",_sign.c_str(), data);
  }

  // std::string が代入されたときに呼び出される
  void operator()(const std::string& data) {
    printf("%s %s\n", _sign.c_str(), data.c_str());
  }

  // double が代入されたときに呼び出される
  void operator()(const double& data) {
    printf("%s %lf\n", _sign.c_str(), data);
  }

};

int main()
{

  std::variant<int, std::string, double> val;


  val = 2;
  std::visit(Print(">>"),val);

  val = 5.5;
  std::visit(Print(">>"), val);

  val = "abc";
  std::visit(Print(">>"), val);

  int k = getchar();
}

#include <cstdio>
#include <vector>
#include <cassert>
#include "NByteData.hpp"

#include "ppmP3_read.hpp"

namespace szl{

  inline int calc_position2d(const int x, const int y, const int width) {
    return x + y * width;
  }

  //canvasの一部に矩形でアクセスできるためのクラス
  class D2CanvasWindow {
  public:

    //! @brief start ～ end の範囲の画素番号一覧
    std::vector<size_t> m_imgp;
    int startx,starty;
    int endx,endy;
    int canvaswidth; //!< 元画像の範囲
    int canvasheight;//!< 元画像の範囲
    inline int width() {return endx - startx + 1;}
    inline int height() {return endy - starty + 1;}

    //! @brief 元画像サイズとクリップサイズの設定
    //! @param [in] canvaswidth  元画像のサイズ
    //! @param [in] canvasheight 元画像のサイズ
    //! @param [in] sx 始点
    //! @param [in] sy 始点
    //! @param [in] ex 終点
    //! @param [in] ey 終点
    //! @return なし
    void set_size(const int canvaswidth, const int canvasheight, const int sx, const int sy, const int ex, const int ey) {

      startx = sx;
      starty = sy;
      endx = ex;
      endy = ey;

      const int Width = width();
      const int Height = height();

      m_imgp.resize(Width * Height);

      int wx, wy;// クリップする範囲の画素indexの一覧を作成
      for (int cx = sx; cx <= ex; cx++) {
        for (int cy = sy; cy <= ey; cy++) {
          wx = cx - sx;
          wy = cy - sy;

          int ci = calc_position2d(cx, cy, canvaswidth);
          int wi = calc_position2d(wx, wy, Width);

          m_imgp[wi] = ci;
        }

      }
    }

    //! @brief 画像を切り出す
    //! @param [in] dst 結果画像
    //! @param [in] src 元画像
    //! @return なし
    template<typename Canvas>
    void Clip(Canvas* dst, const Canvas& src) {
      
      assert(iwidth(*dst) == width());
      assert(iheight(*dst) == height());

      for(size_t i =0;i<m_imgp.size();i++){
        (*dst)[i] = src[m_imgp[i]];
      }
    }

  };

}

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

using PixelT = NByteData<3>;

//画像データ
struct Img2d {
  std::vector<PixelT> m_img;
  int width;
  int height;
  Img2d(int w, int h) {
    m_img.resize(w*h);
    width = w;
    height = h;
  }
  PixelT& operator[](const size_t index) {return m_img[index];}
  const PixelT& operator[](const size_t index)const {return m_img[index];}
};

//! @brief 画像の幅の取得関数
//! @param [in] i 画像
//! @return 画像の幅
int iwidth(const Img2d& i) { return i.width; }

//! @brief 画像の高さ取得関数
//! @param [in] i 画像
//! @return 画像の幅
int iheight(const Img2d& i) { return i.height; }

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

//! @brief 画像の書き込み
void ppmP3_write(
  const char* const fname,
  const int width,
  const int height,
  const unsigned char* const p,
  const int vmax
);

int main()
{
  // 画像読み込み
  PixelT* pimg;
  int width;
  int height;
  int vmax;

  ppmP3_read(
    "C:\\test\\p.ppm",
    &width,
    &height,
    &vmax,
    (unsigned char**)&pimg
  );

  Img2d img(width, height);

  for (size_t i = 0; i < width*height; i++) {
    img.m_img[i] = pimg[i];
  }
  delete[]pimg;

  /////////////////////////////////
  /////////////////////////////////
  // 画像のクリップ

  szl::D2CanvasWindow win;

  win.set_size(img.width,img.height, 2, 3, 8, 10);
  
  Img2d clip(win.width(), win.height());
  win.Clip(&clip, img);

  /////////////////////////////////
  /////////////////////////////////
  ppmP3_write(
    "C:\\test\\q.ppm",
    clip.width,
    clip.height,
    (unsigned char*)clip.m_img.data(), 255);

}