#include "igs_os_type.h"

#include <stdio.h>

#include <math.h>

#include <stdint.h>

#include <string.h>

#include <stdarg.h>

#include <time.h>

#include <assert.h>

#include <stdlib.h>

#include <iostream>

#include <stdexcept>

namespace

{

#ifndef _pri_h_

#define _pri_h_

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

#if defined _WIN32

typedef int int32_t;

#else

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

#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(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>

#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>

#include <string.h>

#include <stdarg.h>

#include <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 char *pri_param_cp_com_name = "#";

void pri_funct_set_cp_title(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>

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>

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

#if defined _WIN32

typedef int int32_t;

typedef unsigned short uint16_t;

#else

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

#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() */

#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>

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

#if defined _WIN32

typedef int int32_t;

#else

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

#endif

#ifndef ON

#define ON (1)

#endif

#ifndef OFF

#define OFF (0)

#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 = OFF;

		this->_i_pv_sw = OFF;

		this->_i_cv_sw = OFF;

		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(int ii) { this->_i_mv_sw = ii; }

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

	void set_i_cv_sw(int 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, char *cp_fname);

	void debug_print(void);

private:

	int _i_mv_sw, /* Method    Verbose */

		_i_pv_sw, /* Parameter Verbose */

		_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() */

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

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

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

/* メモリ開放 */

void brush_curve_blur::mem_free(void)

{

	if (NULL != this->_dp_ratio) {

		if (ON == 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 (ON == this->_i_mv_sw) {

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

	}

	if (ON == 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() */

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

int brush_curve_blur::save(double d_xp, double d_yp, 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>

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

#if defined _WIN32

typedef int int32_t;

typedef unsigned short uint16_t;

#else

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

#endif

#ifndef ON

#define ON (1)

#endif

#ifndef OFF

#define OFF (0)

#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 = OFF;

		this->_i_pv_sw = OFF;

		this->_i_cv_sw = OFF;

		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(int ii) { this->_i_mv_sw = ii; }

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

	void set_i_cv_sw(int 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:

	int _i_mv_sw, /* Method    Verbose */

		_i_pv_sw, /* Parameter Verbose */

		_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() */

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

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

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

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

/* メモリ開放 */

void brush_smudge_circle::mem_free(void)

{

	if (NULL != this->_dp_brush) {

		if (ON == 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;

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

	if (ON == this->_i_mv_sw) {

		pri_funct_msg_ttvr("brush_smudge_circle::mem_alloc()");

	}

	if (ON == this->_i_pv_sw) {

		pri_funct_msg_ttvr(

			"calloc((%d x %d + %d x %d + %d x %d) x (%d x %d))",

			i32_sz, i32_sz,

			i32_sz, i32_sz,

			(this->_i32_size_by_pixel + 1), (this->_i32_size_by_pixel + 1),

			sizeof(double), 5);

	}

	this->_dp_brush = (double *)calloc(

		i32_sz * i32_sz +

			i32_sz * i32_sz +

			(this->_i32_size_by_pixel + 1) * (this->_i32_size_by_pixel + 1),

		sizeof(double) * 5);

	if (NULL == this->_dp_brush) {

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

		return NG;

	}

	this->_dp_subpixel_image = this->_dp_brush +

							   i32_sz * i32_sz * 5;

	this->_dp_pixel_image = this->_dp_subpixel_image +

							i32_sz * i32_sz * 5;

	return OK;

}

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

/* 画像上に置いたブラシの範囲

	+-------+-------+ --> *dp_y2

	|       |       |

	|   +   |   +   |

	|       |       |

	+-------+-------+ <-- d_yp

	|       |       |

	|   +   |   +   |

	|       |       |

	+-------+-------+ --> *dp_y2

	|       ^       |