pikl 0.2.7-x86-mswin32 → 0.2.8-x86-mswin32

data/ext/pikl/pikl_pattern.h

@@ -0,0 +1,12 @@
+#ifndef _LIB_PIKL_PATTERN_
+#define _LIB_PIKL_PATTERN_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "pikl.h"
+#include "pikl_private.h"
+
+#endif

data/ext/pikl/pikl_scrap.c

@@ -0,0 +1,731 @@
+#include "pikl_scrap.h"
+
+static void pkl_circle(PKLImage pkl, int x, int y, int radius, unsigned char *color);
+
+//=============================================================================
+//	�A���`�G�C���A�X�����������~��`��
+//	x,y: �~�̒��S���W
+//	radius: ���a
+//	color: �h��F(unsigned char x[pkl->channel]�̗̈�����ƒ|�C���^)
+//=============================================================================
+static void pkl_circle(PKLImage pkl, int x, int y, int radius, unsigned char *color)
+{
+	unsigned char *p;
+	int sx, sy, ex, ey, tx, ty;
+	int i, j, k, t, s;
+	int outside;
+	int stock[PKL_CHANNEL];
+	
+	if(radius <= 0) return;
+	if(x<0 || x>=pkl->width || y<0 || y>=pkl->height) return;
+	
+	//��`���W���Z�o
+	sx = x-radius;
+	sy = y-radius;
+	ex = x+radius;
+	ey = y+radius;
+	
+	//tx,ty:���S����̋���
+	for(i=sy; i<=ey; i++){
+		ty = i-y;
+		for(j=sx; j<=ex; j++){
+			tx = j-x;
+			outside=0;
+			memset(stock, 0, sizeof(stock));
+			
+			//�J�����g�s�N�Z���Ǝ��͂R�����~�̓������O���ɂ��邩�����āA�F��I������
+			for(t=0; t<=1; t++){
+				for(s=0; s<=1; s++){
+					if((tx+s)*(tx+s)+(ty+t)*(ty+t) > radius*radius){
+						if(j<0 || j>=pkl->width || i<0 || i>=pkl->height) continue;
+						p = &pkl->image[(i*pkl->width+j)*pkl->channel];
+						for(k=0; k<pkl->channel; k++)
+							stock[k] += *p++;
+						outside++;
+					}
+				}
+			}
+			
+			if(j<0 || j>=pkl->width || i<0 || i>=pkl->height) continue;
+			
+			p = &pkl->image[(i*pkl->width+j)*pkl->channel];
+			if(outside==0){
+				//�S�ĉ~�̓����ɂ���
+				for(k=0; k<pkl->channel; k++)
+					*p++ = color[k];
+			}else{
+				//�ꕔ�͉~�̊O���ɂ���
+				for(k=0; k<pkl->channel; k++)
+					*p++ = PKL_COLOR_CLIP((stock[k] + color[k]*(4-outside))/4);
+			}
+		}
+	}
+	
+	return;
+}
+
+//=============================================================================
+// pkl_dots
+//=============================================================================
+PKLExport int pkl_dots(PKLImage pkl, int zone, int color)
+{
+	unsigned char *wrk, *bp, *p, dc[PKL_CHANNEL];
+	int i, j, k, t, s, gray, count, stock;
+	double propc;
+	
+	if(zone<3 || zone>10) return(1);
+	
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0xff, pkl->width*pkl->height*pkl->channel);
+	
+	for(i=0; i<pkl->channel; i++)
+		dc[i] = (color>>((pkl->channel-i)*8) & 0xFF);
+	
+	propc = zone/32.0;
+	
+	bp = pkl->image;
+	pkl->image = wrk;
+	
+	for(i=0; i<pkl->height; i+=zone){
+		for(j=0; j<pkl->width; j+=zone){
+			count=0;
+			stock=0;
+			for(t=i; t<i+zone; t++){
+				for(s=j; s<j+zone; s++){
+					if(t>=pkl->height || s>=pkl->width) continue;
+					p = &bp[(t*pkl->width+s)*pkl->channel];
+					for(k=0,gray=0; k<pkl->channel; k++)
+						gray += *p++;
+					stock += (255-gray/pkl->channel);
+					count++;
+				}
+			}
+			if(count)
+				pkl_circle(pkl, j+zone/2, i+zone/2, sqrt(stock/count)*propc, dc);
+		}
+	}
+
+	free(bp);
+	return(0);
+}
+
+//=============================================================================
+// pkl_swirl
+//=============================================================================
+PKLExport int pkl_swirl(PKLImage pkl, double factor, int x, int y, int backcolor)
+{
+	unsigned char *wrk, color[PKL_CHANNEL], *p, *q;
+	int i, j, k, tx, ty, sx, sy;
+	double range, rad;
+	
+	if(fabs(factor) > 1) return(1);
+	
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
+	
+	for(i=0; i<pkl->channel; i++)
+		color[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+		
+	for(i=0; i<pkl->width*pkl->height; i++)
+		memcpy(&wrk[i*pkl->channel], color, pkl->channel);
+	
+	//���S���W
+	tx = (x<0 || x>=pkl->width) ? pkl->width/2 : x;
+	ty = (y<0 || y>=pkl->height) ? pkl->height/2 : y;
+	
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			range = sqrt((j-tx)*(j-tx) + (i-ty)*(i-ty));
+			rad = atan2(i-ty, j-tx) + (factor * range);
+			
+			sx = range * cos(rad) + tx;
+			sy = range * sin(rad) + ty;
+			if(sx<0 || sx>=pkl->width || sy<0 || sy>=pkl->height) continue;
+			
+			p = &pkl->image[(sy*pkl->width+sx)*pkl->channel];
+			q = &wrk[(i*pkl->width+j)*pkl->channel];
+			for(k=0; k<pkl->channel; k++)
+				*q++ = *p++;
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+
+//=============================================================================
+// pkl_wave
+//=============================================================================
+PKLExport int pkl_wave(PKLImage pkl, PKL_WAVE mode, double factor, double frequency)
+{
+	unsigned char *wrk, *p, *q;
+	int i, j, k, tx, ty;
+	
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height*pkl->channel);
+	
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			tx=j;
+			ty=i;
+			switch(mode){
+				case PKL_WAVE_HORZ:
+					ty += factor * sin(frequency * M_PI/180.0 * j);
+					break;
+				case PKL_WAVE_VERT:
+					tx += factor * sin(frequency * M_PI/180.0 * i);
+					break;
+				case PKL_WAVE_BOTH:
+				default:
+					tx += factor * sin(frequency * M_PI/180.0 * i);
+					ty += factor * sin(frequency * M_PI/180.0 * j);
+			}
+			
+			tx = tx<0 ? 0 : tx>=pkl->width ? pkl->width-1 : tx;
+			ty = ty<0 ? 0 : ty>=pkl->height ? pkl->height-1 : ty;
+			
+			p = &pkl->image[(ty*pkl->width+tx)*pkl->channel];
+			q = &wrk[(i*pkl->width+j)*pkl->channel];
+			for(k=0; k<pkl->channel; k++)
+				*q++ = *p++;
+		}
+	}
+
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+
+//=============================================================================
+// pkl_splitframe
+//=============================================================================
+PKLExport int pkl_splitframe(PKLImage pkl, int backcolor, int wbs, int hbs, int margin, int frame)
+{
+	unsigned char *wrk, color[PKL_CHANNEL];
+	int i, j, k, s, t, u, tx, ty;
+	int offsetx, offsety, width, height, fw, fh;
+	int warea, harea;
+	int shift=5;
+
+	if(wbs<=0 || hbs<=0) return(1);
+	if(margin<0) return(1);
+	if(frame<1) return(1);
+
+	//1�‚̕����G���A�̃C���[�W�T�C�Y
+	warea = pkl->width / wbs;
+	harea = pkl->height / hbs;
+	//1�‚̃G���A�̃T�C�Y(�t���[���T�C�Y���܂�)
+	fw = warea + frame*2;
+	fh = harea + frame*2;
+	//�ŏI�I�ȃL�����o�X�̑傫��
+	width = fw * wbs + margin*2;
+	height = fh * hbs + margin*2;
+
+	wrk = malloc(width*height*pkl->channel);
+	if(!wrk) return(1);
+	
+	//�w�i�F�̐ݒ�
+	for(i=0; i<pkl->channel; i++)
+		color[i] = (backcolor>>((pkl->channel-i)*8) & 0xFF);
+	for(i=0; i<width*height; i++)
+		memcpy(&wrk[i*pkl->channel], color, pkl->channel);
+	
+	srand48(1);
+	for(i=margin,s=0; i<height-margin; i+=fh,s+=harea){
+		for(j=margin,t=0; j<width-margin; j+=fw,t+=warea){
+			offsetx = mrand48()%shift;
+			offsety = mrand48()%shift;
+			
+			//�t�H�g�t���[��
+			k = i+offsety<0 ? 0 : i+offsety+fh>=height ? height-fh : i+offsety;
+			for(ty=k; ty<k+fh; ty++){
+				tx = j+offsetx<0 ? 0 : j+offsetx+fw>=width ? width-fw : j+offsetx;
+				//�w�i�F(��)
+				memset(&wrk[(ty*width+tx)*pkl->channel], 0xFF, fw*pkl->channel);
+				//�V�n�̃t���[��
+				if(ty==k || ty==k+fh-1)
+					memset(&wrk[(ty*width+tx)*pkl->channel], 0x00, fw*pkl->channel);
+				//���E�̃t���[��
+				memset(&wrk[(ty*width+tx)*pkl->channel], 0x00, pkl->channel);
+				memset(&wrk[(ty*width+tx+fw-1)*pkl->channel], 0x00, pkl->channel);
+			}
+			//�C���[�W
+			k = i+offsety<0 ? frame : i+offsety+fh>=height ? height-fh+frame : i+offsety+frame;
+			for(ty=k,u=s; ty<k+harea; ty++,u++){
+				tx = j+offsetx<0 ? frame : j+offsetx+fw>=width ? width-fw+frame : j+offsetx+frame;
+				memcpy(&wrk[(ty*width+tx)*pkl->channel], &pkl->image[(u*pkl->width+t)*pkl->channel], warea*pkl->channel);
+			}
+		}
+	}
+	
+	free(pkl->image);
+	pkl->image = wrk;
+	pkl->width = width;
+	pkl->height = height;
+	return(0);
+}
+
+//=============================================================================
+// pkl_colordither
+//=============================================================================
+PKLExport int pkl_colordither(PKLImage pkl, int weight)
+{
+	double FloydSteinberg[2][3] = {
+		{       -1,       -1, 7.0/16.0},
+		{ 3.0/16.0, 5.0/16.0, 1.0/16.0} };
+	unsigned char *wrk, pix, *graypic;
+	double *pt, err;
+	int i, j, k, gray, s, t, tx, ty, row, col, xrange;
+	
+	row = 3;
+	col = 2;
+	pt = &(FloydSteinberg[0][0]);
+	
+	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0xff, pkl->width*pkl->height*pkl->channel);
+
+	graypic = malloc(pkl->width*pkl->height);
+	if(!wrk) return(1);
+
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			gray=0;
+			for(k=0; k<pkl->channel; k++)
+				gray += pkl->image[(i*pkl->width+j)*pkl->channel+k];
+			graypic[i*pkl->width+j] = PKL_COLOR_CLIP(gray/pkl->channel);
+		}
+	}
+	xrange = (row-1)/2;
+
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			pix = graypic[i*pkl->width+j];
+			if(pix<127){
+				memcpy(&wrk[(i*pkl->width+j)*pkl->channel], &pkl->image[(i*pkl->width+j)*pkl->channel], pkl->channel);
+			}else{
+				for(k=0; k<pkl->channel; k++)
+					wrk[(i*pkl->width+j)*pkl->channel+k] = PKL_COLOR_CLIP(pkl->image[(i*pkl->width+j)*pkl->channel+k]+weight);
+			}
+			err = pix>127 ? pix-255 : pix;
+
+			for(s=0; s<col; s++){
+				for(t=-xrange; t<=xrange; t++){
+					tx = j+t;
+					ty = i+s;
+					if(tx<0 || tx>=pkl->width || ty>=pkl->height) continue;
+					if (pt[s*row+t+xrange] < 0) continue;
+					graypic[ty*pkl->width+tx] = PKL_COLOR_CLIP(graypic[ty*pkl->width+tx] + err * pt[s*row+t+xrange]);
+				}
+			}
+		}
+	}
+	free(graypic);
+	free(pkl->image);
+	pkl->image = wrk;
+	return(0);
+}
+
+
+//=============================================================================
+// pkl_ttt
+//=============================================================================
+PKLExport int pkl_ttt(PKLImage pkl)
+{
+	unsigned char *wrk;
+	int i, j, s, t, k, clipx, clipy;
+	int color[PKL_CHANNEL];
+
+	int matrix[9] = { 0,  0, -1,
+                      0,  0,  0,
+                      1,  0,  0 };
+
+//	{ PKL_EMBOSS_EMBOSS,    { 0,  0, -1,
+//							  0,  0,  0,
+//							  1,  0,  0 }},
+//	
+//	{ PKL_EMBOSS_LAPLACIAN, {-1, -1, -1,
+//							 -1,  8, -1,
+//							 -1, -1, -1 }},
+//
+//	{ PKL_EMBOSS_HEAVY,     { 2,  0,  0,
+//							  0, -1,  0,
+//							  0,  0, -1 }},
+//	
+//	{ PKL_EMBOSS_LIGHT,     { 0,  0,  0,
+//							  0,  1,  0,
+//							  0,  0, -1 }},
+
+
+	
+	wrk = malloc(pkl->width*pkl->height);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->width*pkl->height);
+
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			memset(color, 0, sizeof(color));
+			for(s=0; s<3; s++){
+				for(t=0; t<3; t++){
+					clipx = (j+t)>=pkl->width  ? pkl->width-1  : j+t;
+					clipy = (i+s)>=pkl->height ? pkl->height-1 : i+s;
+					//for(k=0; k<pkl->channel; k++)
+					color[0] += pkl->image[(clipy*pkl->width+clipx) * pkl->channel + 0] * matrix[t+s*3];
+				}
+			}
+			
+			//for(k=0; k<pkl->channel; k++)
+			wrk[i*pkl->width+j] = PKL_COLOR_CLIP(color[0]-127);
+		}
+	}
+
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			for(k=0; k<pkl->channel; k++)
+				pkl->image[(i*pkl->width+j)*pkl->channel+k] =
+					PKL_COLOR_CLIP((pkl->image[(i*pkl->width+j)*pkl->channel+k] - wrk[i*pkl->width+j]));
+		}
+	}
+
+	
+	free(wrk);
+	return(0);
+}
+
+
+
+////=============================================================================
+//// pkl_sketch
+////=============================================================================
+//PKLExport int pkl_sketch(PKLImage pkl)
+//{
+//	unsigned char *wrk, ave[PKL_CHANNEL];
+//	int color[PKL_CHANNEL];
+//	int i, j, k, s;
+//	int weight=10;
+//	int sx, sy, dx, dy, x1, x2, y1, y2, xadder;
+//	double t, adder;
+//	
+//	wrk = malloc(pkl->width*pkl->height*pkl->channel);
+//	if(!wrk) return(1);
+//	memset(wrk, 0xff, pkl->width*pkl->height*pkl->channel);
+//	
+//	srand48(1);
+//	for(i=0; i<pkl->height; i+=weight){
+//		for(j=0; j<pkl->width; j+=weight){
+//			
+//			for(k=0; k<weight*2; k++){
+//				//�����_���ȂQ�_�𐶐�
+//				x1 = j + mrand48()%weight;
+//				y1 = i + mrand48()%weight;
+//				x2 = j + mrand48()%weight;
+//				y2 = i + mrand48()%weight;
+//				
+//				sx = x1;
+//				dx = x2;
+//				sy = y1<y2 ? y1 : y2;
+//				dy = y1<y2 ? y2 : y1;
+//				
+//				sx = sx<0 ? 0 : sx>=pkl->width ? pkl->width-1 : sx;
+//				dx = dx<0 ? 0 : dx>=pkl->width ? pkl->width-1 : dx;
+//				sy = sy<0 ? 0 : sy>=pkl->height ? pkl->height-1 : sy;
+//				dy = dy<0 ? 0 : dy>=pkl->height ? pkl->height-1 : dy;
+//				
+//				if(dx-sx != 0)
+//					adder = (double)(dy-sy)/(double)(dx-sx);
+//				else
+//					adder=1.0;
+//				
+//				if(sx<dx){
+//					for(s=sx,t=sy; s<dx; s++,t+=adder){
+//						if(t<pkl->height)
+//							memcpy(&wrk[((int)t*pkl->width+s)*pkl->channel], &pkl->image[((int)t*pkl->width+s)*pkl->channel], pkl->channel);
+//					}
+//				}else{
+//					for(s=sx,t=sy; s>=dx; s--,t-=adder){
+//						if(t>0.0)
+//							memcpy(&wrk[((int)t*pkl->width+s)*pkl->channel], &pkl->image[((int)t*pkl->width+s)*pkl->channel], pkl->channel);
+//					}
+//				}
+//			}
+//		}
+//	}
+//	
+//	free(pkl->image);
+//	pkl->image = wrk;
+//	return(0);
+//}
+
+
+
+
+
+
+
+//    /** �X�g���[�N�̒��� */
+//    int LENGTH = 10; //1..50
+//    /** �u���V�̑傫�� */
+//    int BRUSHSIZE = 8;	//1..50
+//    /** �Z�W����**/
+//    int Gray = 124;	//50..200
+//    /** ���l */
+//    float ALPHA = .8f;	//0.01 .. 1.0
+//
+//    /** �C���[�W�̃\�[�X */
+//    protected AnimatedImage AI;
+//    protected int width;
+//    protected int height;
+//
+//	/** (r, g, b)����P�x���Z�o���� */
+//	public int getLuminance(int r, int g, int b){
+//		return (int)(0.3f*r + 0.59f*g + 0.11f*b);
+//	}
+//
+//    /** �摜�̃t�B���^�����O���s�� */
+//    public void filter(AnimatedImage AI){
+//		this.AI = AI;
+//		width = AI.getWidth();
+//		height = AI.getHeight();
+//
+//		Random rand = new Random(System.currentTimeMillis());
+//
+//		//�o�b�t�@�̏�����
+//		setUpBuffer();
+//
+//		//�z���C�g�m�C�Y
+//		for (int y=0; y<height; y++) {
+//			for (int x=0; x<width; x++) {
+//				int r = AI.getR(x, y);
+//				int g = AI.getG(x, y);
+//				int b = AI.getB(x, y);
+//				int G=getLuminance(r,g,b);
+//				double T = 0.2*(1-G/40);
+//				double P = rand.nextInt()%1.0;
+//				if(P>=T)AI.setRGB(x, y, 255, 255, 255);
+//				else AI.setRGB(x, y, 0, 0, 0);
+//			}
+//		}
+//
+//		//�����_���ɃX�g���[�N��z�u
+//		for (int i = 0; i < height; i++) {
+//		    for(int j = 0; j < width/5; j++){
+//				int x = Math.abs(rand.nextInt()) % width;
+//				int y = i + Math.abs(rand.nextInt()) %  (LENGTH+BRUSHSIZE);
+//				if ( y<0 || y>=height ) continue;
+//			
+//				int r = AI.getR(x, y);
+//				int g = AI.getG(x, y);
+//				int b = AI.getB(x, y);
+//		 
+//				//�u���V�X�g���[�N��`��
+//				drawPenStroke(x, y, r, g, b);
+//		    }
+//		}
+//		return;
+//    }
+//
+//	//* �y���X�g���[�N���P�•`�悷��
+//	protected void drawPenStroke(int x, int y, int r, int g, int b){
+//		// �摜�̋P�x�̌��z�������擾
+//		Point dir = getDirection(x, y);
+//		float vx, vy, l;
+//		vx = -dir.y/255.0f;
+//		vy = dir.x/255.0f;
+//		l = (float)Math.sqrt(vx*vx+vy*vy);
+//		vx /= l;
+//		vy /= l;
+//
+//		//�`��̈���w�肷��
+//		int vxl = (int)(vx * LENGTH);
+//		int vyl = (int)(vy * LENGTH);
+//		int vxb = (int)(vx * BRUSHSIZE / 2);
+//		int vyb = (int)(vy * BRUSHSIZE / 2);
+//		int sx = x - vxl, sy = y - vyl ; //�n�_
+//		int ex = x + vxl, ey = y + vyl; //�I�_
+//
+//		writeLine(sx - vyb, sy + vxb, ex - vyb, ey + vxb);
+//		//�`��̈���w��F�œh��‚Ԃ��B
+//		paintBuffer(r, g, b, ALPHA);
+//	}
+//
+//    //* �P�x�̌��z�������擾����
+//	protected Point getDirection(int x, int y){
+//		int vx, vy;
+//		int[][] pixel = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+//
+//		for(int i = 0; i < pixel.length; i++){
+//		    int yy = y + i - 1;
+//
+//		    if(yy < 0) continue;
+//		    else if(yy >= height) break;
+//
+//		    for(int j = 0; j < pixel[i].length; j++){
+//				int xx = x + j - 1;
+//
+//				if(xx < 0) continue;
+//				else if(xx >= width) break;
+//
+//				int r = AI.getR(xx, yy);
+//				int g = AI.getG(xx, yy);
+//				int b = AI.getB(xx, yy);
+//
+//				pixel[i][j] = getLuminance(r, g, b);
+//		    }
+//		}
+//
+//		vx = - pixel[0][0] + pixel[0][2] - 2 * pixel[1][0] + 2 * pixel[1][2] - pixel[2][0] + pixel[2][2];
+//		vy = - pixel[0][0] + pixel[2][0] - 2 * pixel[0][1] + 2 * pixel[2][1] - pixel[0][2] + pixel[2][2];
+//
+//		return new Point(vx, vy);
+//	}
+//
+//    //**************************************************************************
+//    //               �ȍ~�A�O���t�B�b�N�X�֘A�̃����o���L�q����
+//    //**************************************************************************
+//
+//    /* �`��̈�𒲂ׂ邽�߂̃o�b�t�@�B
+//     * �`��̈�͓ʂł���Ɖ��肵�Ă���B
+//     * ��{(x, y) | y �� {0, ... height - 1}, buf[y][0] <= x <= buf[y][1]}
+//     * �ŕ\�����̈悪�`��̈�ƂȂ�B
+//     */
+//	protected int[][] buf;
+//
+//    /** �`��̈��y���W�̍ŏ��l */
+//    protected int yMin;
+//
+//    /** �`��̈��y���W�̍ő�l */
+//    protected int yMax;
+//
+//
+//    /**
+//     * buf�̏��������s���B
+//     * �n�߂ɂP�x�����Ăяo�����ƁB
+//     */
+//    protected void setUpBuffer(){
+//		buf = new int[height][2];
+//		yMin = 0;
+//		yMax = height - 1;
+//		clearBuffer();
+//    }
+//
+//	//* buf�̓��e���N���A����B
+//    protected void clearBuffer(){
+//		if(yMin < 0) yMin = 0;
+//		if(yMax >= height) yMax = height - 1;
+//
+//		for(int i = yMin; i <= yMax; i++){
+//		    buf[i][0] = width - 1; //�ŏ��l�̏����l�͍ő�l
+//		    buf[i][1] = 0;         //�ő�l�̏����l�͍ŏ��l
+//		}
+//		yMin = height - 1; //�ŏ��l�̏����l�͍ő�l
+//		yMax = 0;          //�ő�l�̏����l�͍ŏ��l
+//    }
+//
+//    // * buf�ŕ\�����`��̈��F(r, g, b, a)�œh��‚Ԃ��B
+//    protected void paintBuffer(int r, int g, int b, float a){
+//		if(yMin < 0) yMin = 0;
+//		if(yMax >= height) yMax = height - 1;
+//
+//		for(int y = yMin; y <= yMax; y++){
+//		    if(buf[y][0] < 0) buf[y][0] = 0;
+//		    if(buf[y][1] >= width) buf[y][1] = width - 1;
+//
+//		    for(int x = buf[y][0]; x <= buf[y][1]; x++){
+//	              	int G=(int)(0.299*r+0.587*g+0.114*b);    
+//	                if(G>=3*Gray/2)
+//			    		AI.setRGBA(x, y,255, 255, 255, a);
+//	                else if(G>=Gray&&G<3*Gray/2)
+//			    		AI.setRGBA(x, y,170, 170, 170, a);
+//	                else if(G<Gray&&G>Gray/2)
+//						AI.setRGBA(x, y,80, 80, 80, a);
+//	                else
+//						AI.setRGBA(x, y,0, 0, 0, a);
+//		    }
+//		}
+//		clearBuffer();
+//    }
+//
+////     * �_�f�[�^��buf�ɏ������ށB
+////     * yMin, yMax�͍X�V����Ȃ����Ƃɒ��ӁB
+//    protected void writePoint(int x, int y){
+//		if(y < 0 || y >= height) return;
+//		if(x < buf[y][0]) buf[y][0] = x;
+//		if(x > buf[y][1]) buf[y][1] = x;
+//    }
+//
+//
+//    /**
+//     * �����f�[�^��buf�ɏ������ށB
+//     * �u���[���n���̃A���S���Y����p���Ă���B
+//     */
+//    protected void writeLine(int x1, int y1, int x2, int y2){
+//		//yMin, yMax�̍X�V
+//		if(y1 < yMin) yMin = y1;
+//		if(y1 > yMax) yMax = y1;
+//		if(y2 < yMin) yMin = y2;
+//		if(y2 > yMax) yMax = y2;
+//
+//		//dx, dy: X, Y�������̋���
+//		int dx = x2 - x1, dy = y2 - y1;
+//		int sx, sy; //dx, dy�̕�������
+//
+//		if(dx >= 0)
+//		    sx = 1;
+//		else{
+//		    sx = -1; dx = -dx;
+//		}
+//		if(dy >= 0)
+//		    sy = 1;
+//		else{
+//		    sy = -1; dy = -dy;
+//		}
+//
+//		int x = x1, y = y1;
+//		int d, tmp;
+//
+//		if(dx >= dy){
+//		    dy += dy; //dy *= 2
+//		    d = dy - dx;
+//		    tmp = dy - 2 * dx;
+//
+//		    //(x, y)��check
+//		    writePoint(x, y);
+//
+//		    for(int i = 0; i < dx; i++){
+//			if(d > 0){
+//			    y += sy; d += tmp;
+//			}else
+//			    d += dy;
+//
+//			x += sx;
+//
+//					//(x, y)��check
+//			writePoint(x, y);
+//		    }
+//		}else{
+//		    dx += dx; //dx *= 2
+//		    d = dx - dy;
+//		    tmp = dx - 2 * dy;
+//
+//		    //(x, y)��check
+//		    writePoint(x, y);
+//
+//		    for(int i = 0; i < dy; i++){
+//			if(d > 0){
+//			    x += sx; d += tmp;
+//			}else
+//			    d += dx;
+//
+//			y += sy;
+//
+//					//(x, y)��check
+//			writePoint(x, y);
+//		    }
+//		}
+//    }
+//
+//}