#include "igs_os_type.h"

#include <stdio.h></stdio.h>

#include <math.h></math.h>

#include <stdint.h></stdint.h>

#include <string.h></string.h>

#include <stdarg.h></stdarg.h>

#include <time.h></time.h>

#include <assert.h></assert.h>

#include <stdlib.h></stdlib.h>

#include <iostream></iostream>

#include <stdexcept></stdexcept>

namespace {

#ifndef _pri_h_

#define _pri_h_

/* Windowsではstdint.hが見付からない */

#if defined _MSC_VER

typedef int int32_t;

#else

#include <stdint.h> /* for int32_t */</stdint.h>

#endif

#ifdef __cplusplus

extern "C" {

#endif

extern void pri_funct_cv_start(int32_t i32_ys);

extern void pri_funct_cv_run(int32_t i32_y);

extern void pri_funct_cv_end(void);

extern void pri_funct_set_cp_title(const char *cp_title);

extern void pri_funct_msg_ttvr(const char *fmt, ...);

extern void pri_funct_msg_vr(const char *fmt, ...);

extern void pri_funct_err_bttvr(const char *fmt, ...);

#ifdef __cplusplus

}

#endif

#endif /* !_pri_h_ */

#include <stdio.h></stdio.h>

#include "igs_line_blur.h"  // "pri.h"

static int32_t pri_param_i32_ysize, pri_param_i32_pos_before;

/* カウントダウン開始 */

void pri_funct_cv_start(int32_t i32_ys) {

  /* 目盛表示 */

  (void)fprintf(stdout,

                "0%%  10   20   30   40   50   60   70   80   90   100%%\n");

  (void)fprintf(stdout, "....v....v....v....v....v....v....v....v....v....v\n");

  /* パラメータ初期設定 */

  pri_param_i32_ysize      = i32_ys;

  pri_param_i32_pos_before = 0;

}

/* カウントダウン実行中 */

void pri_funct_cv_run(int32_t i32_y) {

  int32_t i32_pos_current, ii;

  /* 目盛上の現在位置(1...50) */

  i32_pos_current = 50 * (i32_y + 1) / pri_param_i32_ysize;

  /* 一回で45度くるくるカウンター */

  /******switch (i32_y%4) {

  case 0: (void)fprintf(stdout, "-\b"  ); break;

  case 1: (void)fprintf(stdout, "\\\b" ); break;

  case 2: (void)fprintf(stdout, "|\b"  ); break;

  case 3: (void)fprintf(stdout, "/\b"  ); break;

  }

  (void)fflush(stdout);******/

  /* 一回前の目盛位置と同じなら抜ける */

  if (i32_pos_current == pri_param_i32_pos_before) return;

  /* 目盛が進んだとき */

  for (ii = pri_param_i32_pos_before; ii < i32_pos_current; ++ii) {

    /* 一目盛以上進んだときのすき間 */

    if ((ii + 1) < i32_pos_current) {

      (void)fprintf(stdout, ".");

    }

    /* 一目盛分 */

    else {

      (void)fprintf(stdout, "^");

    }

  }

  (void)fflush(stdout);

  /* 現在位置を記憶する */

  pri_param_i32_pos_before = i32_pos_current;

}

/* カウントダウン終了 */

void pri_funct_cv_end(void) {

  /* 改行 */

  (void)fprintf(stdout, "\n");

}

#include <stdio.h></stdio.h>

#include <string.h></string.h>

#include <stdarg.h></stdarg.h>

#include <time.h></time.h>

#include "igs_line_blur.h"  // "pri.h"

/* Windowsではvsnprintf()の頭にアンダーバーが付く!!! */

#if defined _WIN32

#define vsnprintf(buf, len, fmt, ap) _vsnprintf(buf, len, fmt, ap)

#endif

static const char *pri_param_cp_com_name = "#";

void pri_funct_set_cp_title(const char *cp_title) {

  pri_param_cp_com_name = cp_title;

}

/* print  Valiable_argument, Return_code */

void pri_funct_msg_vr(const char *fmt, ...) {

  int i_ret;

  va_list ap;

  char buf[FILENAME_MAX]; /* redhat9 : stdio.h --> bits/stdio_lim.h */

  va_start(ap, fmt);

  i_ret = vsnprintf(buf, FILENAME_MAX, fmt, ap);

  va_end(ap);

  if (i_ret < 0) {

    (void)strcpy(buf, "bad argument for fprintf stdout");

  }

  /* 可変引数,改行 */

  (void)fprintf(stdout, "%s\n", buf);

  (void)fflush(stdout);

}

/* print  Title, Time_stamp, Valiable_argument, Return_code */

void pri_funct_msg_ttvr(const char *fmt, ...) {

  time_t tt;

  char *cc;

  int i_ret;

  va_list ap;

  char buf[FILENAME_MAX]; /* redhat9 : stdio.h --> bits/stdio_lim.h */

  tt     = time(NULL);

  cc     = asctime(localtime(&tt)); /* 注意：ccはstatic変数 */

  cc[24] = '\0'; /* 26-character Example : "Fri Sep 13 00:00:00 1986\n\0" */

  va_start(ap, fmt);

  i_ret = vsnprintf(buf, FILENAME_MAX, fmt, ap);

  va_end(ap);

  if (i_ret < 0) {

    (void)strcpy(buf, "bad argument for fprintf stdout");

  }

  /* ベル,タイトル,日時,可変引数,改行 */

  (void)fprintf(stdout, "%s  %s  %s\n", pri_param_cp_com_name, cc, buf);

  (void)fflush(stdout);

}

/* print  Bell, Title, Time_stamp, Valiable_argument, Return_code */

void pri_funct_err_bttvr(const char *fmt, ...) {

  time_t tt;

  char *cc;

  int i_ret;

  va_list ap;

  char buf[FILENAME_MAX];

  tt     = time(NULL);

  cc     = asctime(localtime(&tt)); /* 注意：ccはstatic変数 */

  cc[24] = '\0'; /* 26-character Example : "Fri Sep 13 00:00:00 1986\n\0" */

  va_start(ap, fmt);

  i_ret = vsnprintf(buf, FILENAME_MAX, fmt, ap);

  va_end(ap);

  if (i_ret < 0) {

    (void)strcpy(buf, "bad argument for fprintf stderr");

  }

  /* ベル,タイトル,日時,可変引数,改行 */

  (void)fprintf(stderr, "\007%s  %s  %s\n", pri_param_cp_com_name, cc, buf);

  (void)fflush(stderr);

}

#ifndef _list_node_h_

#define _list_node_h_

#include <stdio.h></stdio.h>

class list_node {

public:

  list_node() {

    this->_clp_previous = NULL;

    this->_clp_next     = NULL;

  }

  list_node *get_clp_next(void) { return this->_clp_next; }

  list_node *get_clp_previous(void) { return this->_clp_previous; }

  void set_clp_next(list_node *clp) { this->_clp_next = clp; }

  void set_clp_previous(list_node *clp) { this->_clp_previous = clp; }

private:

  list_node *_clp_previous, *_clp_next;

};

#endif /* !_list_node_h_ */

#ifndef _list_root_h_

#define _list_root_h_

#include <stdio.h></stdio.h>

/* Windowsではstdint.hが見つからない */

#if defined _MSC_VER

typedef int int32_t;

typedef unsigned short uint16_t;

#else

#include <stdint.h> /* for int32_t, uint16_t */</stdint.h>

#endif

#include "igs_line_blur.h"  // "list_node.h"

class list_root {

public:

  list_root() {

    this->_clp_first = NULL;

    this->_clp_last  = NULL;

    this->_i32_count = 0;

  }

  list_node *push(list_node *clp_previous, list_node *clp_new);

  list_node *pop(list_node *clp_old);

  list_node *get_clp_first(void) { return this->_clp_first; }

  list_node *get_clp_last(void) { return this->_clp_last; }

  int32_t get_i32_count(void) { return this->_i32_count; }

private:

  list_node *_clp_first, *_clp_last;

  int32_t _i32_count;

  void _set_clp_first(list_node *clp_) { this->_clp_first = clp_; }

  void _set_clp_last(list_node *clp_) { this->_clp_last = clp_; }

  void _connect(list_node *clp_previous, list_node *clp_next);

};

#endif              /* !_list_root_h_ */

#include <assert.h> /* assert() */</assert.h>

#include "igs_line_blur.h"  // "list_root.h"

/* ピクセルリストを前後でつなげるメソッド */

void list_root::_connect(list_node *clp_previous, list_node *clp_next) {

  /* リスト初期化 */

  if ((NULL == clp_previous) && (NULL == clp_next)) {

    this->_clp_first = NULL;

    this->_clp_last  = NULL;

  }

  /* (clp_previous)をリストの最後部に追加 */

  else if ((NULL != clp_previous) && (NULL == clp_next)) {

    this->_clp_last = clp_previous;

    clp_previous->set_clp_next(NULL);

  }

  /* (clp_next)をリストの最前部に挿入 */

  else if ((NULL == clp_previous) && (NULL != clp_next)) {

    this->_clp_first = clp_next;

    clp_next->set_clp_previous(NULL);

  }

  /* (clp_previous)と、(clp_next)をつなげる */

  else if ((NULL != clp_previous) && (NULL != clp_next)) {

    clp_next->set_clp_previous(clp_previous);

    clp_previous->set_clp_next(clp_next);

  }

}

list_node *list_root::push(list_node *clp_previous, list_node *clp_new) {

  /* あってはならないプログラムバグのチェック */

  assert(NULL != clp_new);

  /* リスト上で、clp_newの後ろを接続 */

  if (NULL != clp_previous) { /* clp_previousの後ろに接続 */

    this->_connect(clp_new, clp_previous->get_clp_next());

  } else { /* clp_previousがNULLなら、リストの頭に挿入 */

    this->_connect(clp_new, this->get_clp_first());

  }

  /* リスト上で、clp_newの前を接続 */

  this->_connect(clp_previous, clp_new);

  /* 子リストの数のカウント */

  ++(this->_i32_count);

  return clp_new;

}

list_node *list_root::pop(list_node *clp_old) {

  /* あってはならないプログラムバグのチェック */

  assert(NULL != clp_old);

  /* はずすノードの前後をつなげる */

  this->_connect(clp_old->get_clp_previous(), clp_old->get_clp_next());

  /* 子リストの数のカウント */

  --(this->_i32_count);

  /* あってはならないプログラムバグのチェック */

  assert(0 <= (this->_i32_count));

  return clp_old;

}

#ifndef _brush_curve_blur_h_

#define _brush_curve_blur_h_

#include <stdio.h></stdio.h>

/* Windowsではstdint.hが見つからない */

#if defined _MSC_VER

typedef int int32_t;

#else

#include <stdint.h> /* for int32_t */</stdint.h>

#endif

#ifndef OK

#define OK (0)

#endif

#ifndef NG

#define NG (-1)

#endif

#ifndef CHANNEL_COUNT

#define CHANNEL_COUNT (4)

#endif

class brush_curve_blur {

public:

  /* constructer */

  brush_curve_blur(void) {

    int32_t ii;

    this->_i_mv_sw = false;

    this->_i_pv_sw = false;

    this->_i_cv_sw = false;

    this->_i32_count            = 51;

    this->_i32_subpixel_divide  = 2;

    this->_d_effect_area_radius = 25.0;

    this->_d_power              = 1.0;

    this->_dp_ratio      = NULL;

    this->_dp_linepixels = NULL;

    this->_dp_xp         = NULL;

    this->_dp_yp         = NULL;

    this->_dp_subpixel   = NULL;

    for (ii = 0; ii < CHANNEL_COUNT; ++ii) {

      this->_da_pixel[ii] = 0.0;

    }

  }

  /* constructer */

  ~brush_curve_blur(void) { this->mem_free(); }

  /* パラメータ設定 */

  void set_i_mv_sw(bool ii) { this->_i_mv_sw = ii; }

  void set_i_pv_sw(bool ii) { this->_i_pv_sw = ii; }

  void set_i_cv_sw(bool ii) { this->_i_cv_sw = ii; }

  /* ぼかし線のポイント数 */

  void set_i32_count(int32_t ii) { this->_i32_count = ii; }

  int32_t get_i32_count(void) { return this->_i32_count; }

  void set_i32_subpixel_divide(int32_t ii) { this->_i32_subpixel_divide = ii; }

  int32_t get_i32_subpixel_divide(void) { return this->_i32_subpixel_divide; }

  void set_d_effect_area_radius(double dd) { this->_d_effect_area_radius = dd; }

  double get_d_effect_area_radius(void) { return this->_d_effect_area_radius; }

  void set_d_power(double dd) { this->_d_power = dd; }

  double get_d_power(void) { return this->_d_power; }

  /* get for using */

  double *get_dp_linepixels(void) { return this->_dp_linepixels; }

  double *get_dp_xp(void) { return this->_dp_xp; }

  double *get_dp_yp(void) { return this->_dp_yp; }

  double *get_dp_pixel(void) { return this->_da_pixel; }

  void mem_free(void);

  int mem_alloc(void);

  void init_ratio_array(void);

  void set_subpixel_value(int32_t i32_x_sub, int32_t i32_y_sub);

  void set_pixel_value(void);

  int save(double d_xp, double d_yp, const char *cp_fname);

  void debug_print(void);

private:

  bool _i_mv_sw; /* Method    Verbose */

  bool _i_pv_sw; /* Parameter Verbose */

  bool _i_cv_sw; /* Counter   Verbose */

  int32_t _i32_count;

  int32_t _i32_subpixel_divide;

  double _d_effect_area_radius;

  double _d_power;

  double *_dp_ratio, *_dp_linepixels, *_dp_xp, *_dp_yp, *_dp_subpixel,

      _da_pixel[CHANNEL_COUNT];

};

#endif              /* !_brush_curve_blur_h_ */

#include <math.h>   /* pow() */</math.h>

#include <stdlib.h> /* free(), calloc() */</stdlib.h>

#include <assert.h> /* assert() */</assert.h>

#include "igs_line_blur.h"  // "pri.h" "brush_curve_blur.h"

/* メモリ開放 */

void brush_curve_blur::mem_free(void) {

  if (NULL != this->_dp_ratio) {

    if (this->_i_mv_sw) {

      pri_funct_msg_ttvr("brush_curve_blur::mem_free()");

    }

    free(this->_dp_ratio);

    this->_dp_ratio      = NULL;

    this->_dp_linepixels = NULL;

    this->_dp_xp         = NULL;

    this->_dp_yp         = NULL;

    this->_dp_subpixel   = NULL;

  }

}

/* メモリ確保 */

int brush_curve_blur::mem_alloc(void) {

  /* 以前のメモリが残っていたら開放する */

  this->mem_free();

  /* ユーザー指定がゼロなら動作キャンセル */

  if (this->_i32_count <= 0) {

    return OK;

  }

  /* 処理ごとのメッセージ */

  if (this->_i_mv_sw) {

    pri_funct_msg_ttvr("brush_curve_blur::mem_alloc()");

  }

  if (this->_i_pv_sw) {

    pri_funct_msg_ttvr(

        "alloc brush_curve_blur memory ((%d * %d) + %d) x %d bytes",

        this->_i32_count, (1 + CHANNEL_COUNT + 2), /* ratio,accum,xp,yp */

        this->_i32_subpixel_divide * this->_i32_subpixel_divide *

            CHANNEL_COUNT, /* pixel(rgba) */

        sizeof(double));

  }

  this->_dp_ratio = (double *)calloc(

      /* ratio,linepixels,xp,yp */

      this->_i32_count * (1 + CHANNEL_COUNT + 2) +

          this->_i32_subpixel_divide * this->_i32_subpixel_divide *

              CHANNEL_COUNT, /* pixel(rgba) */

      sizeof(double));

  if (NULL == this->_dp_ratio) {

    pri_funct_err_bttvr("Error : calloc(-) returns NULL.");

    return NG;

  }

  this->_dp_linepixels = this->_dp_ratio + this->_i32_count;

  this->_dp_xp       = this->_dp_linepixels + this->_i32_count * CHANNEL_COUNT;

  this->_dp_yp       = this->_dp_xp + this->_i32_count;

  this->_dp_subpixel = this->_dp_yp + this->_i32_count;

  return OK;

}

/********************************************************************/

void brush_curve_blur::init_ratio_array(void) {

  int32_t ii;

  double d_total;

  /* ユーザー指定がゼロなら動作キャンセル */

  if (this->_i32_count <= 0) {

    return;

  }

  /* 前半の変化、ゼロからリニア増 */

  for (ii = 1; ii < this->_i32_count / 2; ++ii) {

    this->_dp_ratio[ii] = ii;

  }

  /* 後半の変化、ゼロへリニア減 */

  for (ii = this->_i32_count / 2; ii < this->_i32_count; ++ii) {

    this->_dp_ratio[ii] = this->_i32_count - ii;

  }

  /* 正規化(0...1)する */

  /****for (ii = 0; ii < this->_i32_count; ++ii) {

          this->_dp_ratio[ii] /=

                  (double)(this->_i32_count - this->_i32_count/2);

  }****/

  /* 影響の強さの設定 */

  for (ii = 0; ii < this->_i32_count; ++ii) {

    this->_dp_ratio[ii] = pow(this->_dp_ratio[ii], 1.0 / this->_d_power);

  }

  /* 総計 */

  d_total = 0.0;

  for (ii = 0; ii < this->_i32_count; ++ii) {

    d_total += this->_dp_ratio[ii];

  }

  /* 総計で割って、総計を1にする */

  for (ii = 0; ii < this->_i32_count; ++ii) {

    this->_dp_ratio[ii] /= d_total;

  }

}

/********************************************************************/

/* 線分から取り込んだピクセル値をサブピクセル値として合成 */

void brush_curve_blur::set_subpixel_value(int32_t i32_x_sub,

                                          int32_t i32_y_sub) {

  int32_t ii, zz;

  double d_accum;

  /* ユーザー指定がゼロなら動作キャンセル */

  if (this->_i32_count <= 0) {

    return;

  }

  /* チャネルごと */

  for (zz = 0; zz < CHANNEL_COUNT; ++zz) {

    /* 加算の前にゼロ初期化 */

    this->_dp_subpixel[(this->_i32_subpixel_divide * i32_y_sub + i32_x_sub) *

                           CHANNEL_COUNT +

                       zz] = 0.0;

    /* ピクセル値を加算 */

    d_accum = 0.0;

    for (ii = 0; ii < this->_i32_count; ++ii) {

      /* 画像の範囲外 */

      if (this->_dp_linepixels[ii * CHANNEL_COUNT + zz] < 0.0) {

        continue;

      }

      /* ピクセル値に比を掛けて加算 */

      this->_dp_subpixel[(this->_i32_subpixel_divide * i32_y_sub + i32_x_sub) *

                             CHANNEL_COUNT +

                         zz] +=

          this->_dp_linepixels[ii * CHANNEL_COUNT + zz] * this->_dp_ratio[ii];

      d_accum += this->_dp_ratio[ii];

    }

    /* 画像をスキャンしているのだから、

    画像の範囲となる値はかならず一つ以上ある */

    assert(0.0 < d_accum);

    /* 値の計算 */

    this->_dp_subpixel[(this->_i32_subpixel_divide * i32_y_sub + i32_x_sub) *

                           CHANNEL_COUNT +

                       zz] /= d_accum;

  }

}

/* サブピクセル値を平均してピクセル値を得る */

void brush_curve_blur::set_pixel_value(void) {

  int32_t xx, yy, zz;

  /* ユーザー指定がゼロなら動作キャンセル */

  if (this->_i32_count <= 0) {

    return;

  }

  for (zz = 0; zz < CHANNEL_COUNT; ++zz) {

    this->_da_pixel[zz] = 0.0;

    for (yy = 0; yy < this->_i32_subpixel_divide; ++yy) {

      for (xx = 0; xx < this->_i32_subpixel_divide; ++xx) {

        this->_da_pixel[zz] +=

            this->_dp_subpixel[(this->_i32_subpixel_divide * yy + xx) *

                                   CHANNEL_COUNT +

                               zz];

      }

    }

    this->_da_pixel[zz] /=

        this->_i32_subpixel_divide * this->_i32_subpixel_divide;

  }

}

#include <assert.h> /* assert() */</assert.h>

#include "igs_line_blur.h"  // "pri.h" "brush_curve_blur.h"

int brush_curve_blur::save(double d_xp, double d_yp, const char *cp_fname) {

  FILE *fp;

  int32_t ii;

  /* ファイル開く */

  fp = fopen(cp_fname, "w");

  if (NULL == fp) {

    pri_funct_err_bttvr("Error : fopen(%s,w) returns NULL", cp_fname);

    return NG;

  }

  /* 選択数保存 */

  if (fprintf(fp, "# curve blur count %d\n", this->get_i32_count()) < 0) {

    pri_funct_err_bttvr("Error : fprintf(# curve blur count) returns minus");

    fclose(fp);

    return NG;

  }

  for (ii = 0; ii < this->get_i32_count(); ++ii) {

    /* ピクセル位置から近点位置保存 */

    if (fprintf(fp, "%g %g\n", d_xp + this->_dp_xp[ii],

                d_yp + this->_dp_yp[ii]) < 0) {

      pri_funct_err_bttvr("Error : fprintf(avarage x y) returns minus");

      fclose(fp);

      return NG;

    }

  }

  /* ファイル閉じる */

  fclose(fp);

  return OK;

}

#ifndef __brush_smudge_circle_h__

#define __brush_smudge_circle_h__

#include <stdio.h></stdio.h>

/* Windowsではstdint.hが見つからない */

#if defined _MSC_VER

typedef int int32_t;

typedef unsigned short uint16_t;

#else

#include <stdint.h> /* for int32_t, uint16_t */</stdint.h>

#endif

#ifndef OK

#define OK (0)

#endif

#ifndef NG

#define NG (-1)

#endif

class brush_smudge_circle {

public:

  brush_smudge_circle() {

    this->_i_mv_sw = false;

    this->_i_pv_sw = false;

    this->_i_cv_sw = false;

    this->_i32_size_by_pixel   = 7; /* 画像上の線の最大幅 */

    this->_i32_subpixel_divide = 4;

    this->_d_ratio             = 0.85;

    this->_dp_brush          = NULL;

    this->_dp_subpixel_image = NULL;

    this->_dp_pixel_image    = NULL;

  }

  ~brush_smudge_circle() { this->mem_free(); }

  /* パラメータ設定 */

  void set_i_mv_sw(bool ii) { this->_i_mv_sw = ii; }

  void set_i_pv_sw(bool ii) { this->_i_pv_sw = ii; }

  void set_i_cv_sw(bool ii) { this->_i_cv_sw = ii; }

  void set_i32_size_by_pixel(int32_t ii) { this->_i32_size_by_pixel = ii; }

  void set_i32_subpixel_divide(int32_t ii) { this->_i32_subpixel_divide = ii; }

  void set_d_ratio(double dd) { this->_d_ratio = dd; }

  /* パラメータを得る */

  int32_t get_i32_size_by_pixel(void) { return this->_i32_size_by_pixel; }

  int32_t get_i32_subpixel_divide(void) { return this->_i32_subpixel_divide; }

  double get_d_ratio(void) { return this->_d_ratio; }

  void get_dp_area(double d_xp, double d_yp, double *dp_x1, double *dp_y1,

                   double *dp_x2, double *dp_y2);

  /* メモリ確保 */

  int mem_alloc(void);

  /* メモリへのポインターを得る */

  double *get_dp_brush(void) { return this->_dp_brush; }

  double *get_dp_subpixel_image(void) { return this->_dp_subpixel_image; }

  double *get_dp_pixel_image(void) { return this->_dp_pixel_image; }

  /* 実行 */

  void set_brush_circle(void);

  void copy_to_brush_from_image(void);

  void exec(void);

  void to_subpixel_from_pixel(double d_x1, double d_y1, double d_x2,

                              double d_y2);

  void to_pixel_from_subpixel(double d_x1, double d_y1, double d_x2,

                              double d_y2);

  /* メモリ開放 */

  void mem_free(void);

private:

  bool _i_mv_sw; /* Method    Verbose */

  bool _i_pv_sw; /* Parameter Verbose */

  bool _i_cv_sw; /* Counter   Verbose */

  int32_t _i32_size_by_pixel, _i32_subpixel_divide;

  double _d_ratio;

  double *_dp_brush, *_dp_subpixel_image, *_dp_pixel_image;

};

#endif              /* !__brush_smudge_circle_h__ */

#include <stdlib.h> /* free(), calloc() */</stdlib.h>

#include <math.h>   /* sqrt() */</math.h>

#include <string.h> /* memset() */</string.h>

#include <assert.h> /* assert() */</assert.h>

#include "igs_line_blur.h"  // "pri.h" "brush_smudge_circle.h"

/* メモリ開放 */

void brush_smudge_circle::mem_free(void) {

  if (NULL != this->_dp_brush) {

    if (this->_i_mv_sw) {

      pri_funct_msg_ttvr("brush_smudge_circle::mem_free()");

    }

    free(this->_dp_brush);

    this->_dp_brush          = NULL;

    this->_dp_pixel_image    = NULL;

    this->_dp_subpixel_image = NULL;

  }

}

/* データ設定とメモリ確保 */

int brush_smudge_circle::mem_alloc(void) {

  int32_t i32_sz;

  /* もし以前のメモリがあるなら開放する */

  this->mem_free();

  /* メモリ確保のためのサイズの1単位 */

  i32_sz = this->_i32_size_by_pixel * this->_i32_subpixel_divide;