CHKIMGチェックイメージ関数

本ページには広告が含まれています。

指定画像が画面上にあるかチェックし、あればその情報を返します。

CHKIMG関数は色幅は64/256までは許容範囲ですが、形は完全に一致する画像しか検索しかできません。曖昧あいまい検索をする場合は、ChkImgX関数を使います。

構文
  1. Boolean = CHKIMG( 画像名, 透過色/色無視, x1, y1, x2, y2, 番号, 色幅 )
引数
画像名 (String = Empty)省略可
画像ファイル名(BMP形式のみ) (画像名を省略した場合はクリップボードから)
透過色/色無視 (Integer = 0)省略可
0
指定なし(デフォルト)
1,2,3,4
左上(1),右上(2),左下(3),右下(4)の1ピクセルの色を透過色として処理
-1
色を無視して形でチェックする
x1, y1, x2, y2 (Integer)省略可
サーチ範囲
番号 (Integer = 0)省略可
複数ある場合に順番を指定 (左上から)
-1
-1が指定された場合はヒットした数を戻値として返し、座標情報は ALL_IMG_X[], ALL_IMG_Y[]に格納
G_IMG_XG_IMG_Yには最後にヒットした位置が入る)
色幅 (#chkimg = 0)省略可
チェックに色幅を持たせる (色無視指定時もしくは 16bitカラー以下の場合は無効)
IMG_MSK_BGR1
各色(BGR)に対し 2/256の色幅を許す
IMG_MSK_BGR2
各色(BGR)に対し 4/256の色幅を許す
IMG_MSK_BGR3
各色(BGR)に対し 8/256の色幅を許す
IMG_MSK_BGR4
各色(BGR)に対し 16/256の色幅を許す
IMG_MSK_B1, 2, 3, 4
青に対し 2/256, 4/256, 8/256, 16/256の色幅を許す
IMG_MSK_G1, 2, 3, 4
緑に対し 2/256, 4/256, 8/256, 16/256の色幅を許す
IMG_MSK_R1, 2, 3, 4
赤に対し 2/256, 4/256, 8/256, 16/256の色幅を許す
演算可
例:IMG_MSK_B1 or IMG_MSK_R3(青に対し 2/256の色幅を許す + 赤に対し 8/256の色幅を許す)
戻り値

有ればTRUE、無ければFALSE

TRUEの場合は見つかった座標を特殊変数G_IMG_XG_IMG_Yに格納

番号にて -1指定時はヒットした数を返し、座標情報は配列変数 ALL_IMG_X[], ALL_IMG_Y[] に格納(配列はゼロから)

画像名

画像名は現在実行しているUWSファイルがあるフォルダにある画像となります。現在のフォルダはGET_CUR_DIRで確認することができ、他のフォルダの画像を指定する場合は絶対パスで指定します。

サーチ範囲の座標について

左上が基準(x = 0,y = 0)です。x2,y2x1,y1より大きい値(x1 < x2かつy1 < y2が成り立つ範囲)を指定してください。

アクティブウィンドウの範囲

UWSC
DIM ID = GETID(GET_ACTIVE_WIN)
DIM x = STATUS(ID, ST_X)
DIM y = STATUS(ID, ST_Y)
DIM width = STATUS(ID, ST_WIDTH)
DIM height = STATUS(ID, ST_HEIGHT)

CHKIMG("image.bmp",, x, y, x + width, y + height)

色幅

色幅は24bit以上でないと無視されてしまいます。

ビットの深さは、[ファイル]を右クリック-[プロパティ]-[詳細]で確認、もしくはgetBitmap関数 (自作関数)で取得できます。

UWSC
DIM array = getBitmap(path)
PRINT array[3]

以下は左上から(B, G, R) = (180, 174, 255)~(219, 174, 255)の画像を並べています。

BGR=180-219,174,255.bmp

以下は上記画像のB成分をまとめた表です。画像の位置と対応しています。

B成分の値
180 181 182 183 184 185 186 187 188 189
190 191 192 193 194 195 196 197 198 199
200 201 202 203 204 205 206 207 208 209
210 211 212 213 214 215 216 217 218 219

以下は(B, G, R) = (200, 174, 255)の画像で、色幅を指定することで上に示したハートを並べた画像にどれだけの誤差までマッチするのかを調べるプログラム。

BGR=200,174,255.bmp
UWSC
DIM path = "D:\Desktop\CHKIMG\BGR=200,174,255.bmp"
DIM array[] = "IMG_MSK_BGR", "IMG_MSK_B", "IMG_MSK_G", "IMG_MSK_R"

PRINT "元画像:BGR=200,174,255.bmp"
PRINT 

FOR item IN array
	FOR i = 1 TO 4
		a = item + i
//		PRINT a + "<#TAB>" + CHKIMG(path,,,,,, -1, EVAL(a))
		DIM num = CHKIMG(path,,,,,, -1, EVAL(a))
		PRINT "■" + a
		PRINT "マッチ数:" + num
		FOR n = 0 TO num - 1
			DIM c = PEEKCOLOR(ALL_IMG_X[n] + 25, ALL_IMG_Y[n] + 25)
			DIM r = c AND $FF
			DIM g = (c AND $FF00) / $100
			DIM b = (c AND $FF0000) / $10000
			PRINT r + ", " + g + ", " + b
		NEXT
		PRINT
	NEXT
NEXT
結果
プレーンテキスト
元画像:BGR=200,174,255.bmp

■IMG_MSK_BGR1
マッチ数:3
255, 174, 199
255, 174, 200
255, 174, 201

■IMG_MSK_BGR2
マッチ数:7
255, 174, 197
255, 174, 198
255, 174, 199
255, 174, 200
255, 174, 201
255, 174, 202
255, 174, 203

■IMG_MSK_BGR3
マッチ数:15
255, 174, 193
255, 174, 194
255, 174, 195
255, 174, 196
255, 174, 197
255, 174, 198
255, 174, 199
255, 174, 200
255, 174, 201
255, 174, 202
255, 174, 203
255, 174, 204
255, 174, 205
255, 174, 206
255, 174, 207

■IMG_MSK_BGR4
マッチ数:31
255, 174, 185
255, 174, 186
255, 174, 187
255, 174, 188
255, 174, 189
255, 174, 190
255, 174, 191
255, 174, 192
255, 174, 193
255, 174, 194
255, 174, 195
255, 174, 196
255, 174, 197
255, 174, 198
255, 174, 199
255, 174, 200
255, 174, 201
255, 174, 202
255, 174, 203
255, 174, 204
255, 174, 205
255, 174, 206
255, 174, 207
255, 174, 208
255, 174, 209
255, 174, 210
255, 174, 211
255, 174, 212
255, 174, 213
255, 174, 214
255, 174, 215

■IMG_MSK_B1
マッチ数:3
255, 174, 199
255, 174, 200
255, 174, 201

■IMG_MSK_B2
マッチ数:7
255, 174, 197
255, 174, 198
255, 174, 199
255, 174, 200
255, 174, 201
255, 174, 202
255, 174, 203

■IMG_MSK_B3
マッチ数:15
255, 174, 193
255, 174, 194
255, 174, 195
255, 174, 196
255, 174, 197
255, 174, 198
255, 174, 199
255, 174, 200
255, 174, 201
255, 174, 202
255, 174, 203
255, 174, 204
255, 174, 205
255, 174, 206
255, 174, 207

■IMG_MSK_B4
マッチ数:31
255, 174, 185
255, 174, 186
255, 174, 187
255, 174, 188
255, 174, 189
255, 174, 190
255, 174, 191
255, 174, 192
255, 174, 193
255, 174, 194
255, 174, 195
255, 174, 196
255, 174, 197
255, 174, 198
255, 174, 199
255, 174, 200
255, 174, 201
255, 174, 202
255, 174, 203
255, 174, 204
255, 174, 205
255, 174, 206
255, 174, 207
255, 174, 208
255, 174, 209
255, 174, 210
255, 174, 211
255, 174, 212
255, 174, 213
255, 174, 214
255, 174, 215

■IMG_MSK_G1
マッチ数:1
255, 174, 200

■IMG_MSK_G2
マッチ数:1
255, 174, 200

■IMG_MSK_G3
マッチ数:1
255, 174, 200

■IMG_MSK_G4
マッチ数:1
255, 174, 200

■IMG_MSK_R1
マッチ数:1
255, 174, 200

■IMG_MSK_R2
マッチ数:1
255, 174, 200

■IMG_MSK_R3
マッチ数:1
255, 174, 200

■IMG_MSK_R4
マッチ数:1
255, 174, 200

以上の結果から、マッチする色幅は以下のようになることがわかります。

定数名 マッチするBGRの範囲
IMG_MSK_BGR1 (-1, -1, -1)〜(+1, +1, +1)
IMG_MSK_BGR2 (-3, -3, -3)〜(+3, +3, +3)
IMG_MSK_BGR3 (-7, -7, -7)〜(+7, +7, +7)
IMG_MSK_BGR4 (-15, -15, -15)〜(+15, +15, +15)
IMG_MSK_B1 (-1, ±0, ±0)〜(+1, ±0, ±0)
IMG_MSK_B2 (-3, ±0, ±0)〜(+3, ±0, ±0)
IMG_MSK_B3 (-7, ±0, ±0)〜(+7, ±0, ±0)
IMG_MSK_B4 (-15, ±0, ±0)〜(+15, ±0, ±0)
IMG_MSK_G1 (±0, -1, ±0)〜(±0, +1, ±0)
IMG_MSK_G2 (±0, -3, ±0)〜(±0, +3, ±0)
IMG_MSK_G3 (±0, -7, ±0)〜(±0, +7, ±0)
IMG_MSK_G4 (±0, -15, ±0)〜(±0, +15, ±0)
IMG_MSK_R1 (±0, ±0, -1)〜(±0, ±0, +1)
IMG_MSK_R2 (±0, ±0, -3)〜(±0, ±0, +3)
IMG_MSK_R3 (±0, ±0, -7)〜(±0, ±0, +7)
IMG_MSK_R4 (±0, ±0, -15)〜(±0, ±0, +15)

IMG_MSK_RGB(数値) の数値を\(n\)とすると、以下が成り立ちます。

色幅:\((2^{n}-1) \times 2 + 1\)
範囲:\(-(2^{n}-1)〜+(2^{n}+1)\)

エラー

CHKIMGでのヒット数が4096を超えるとエラーになるので、マッチさせる画像を大きくするか、調べる範囲を狭くするなどの対策が必要です。

CHKIMG HIT数が最大値(4096)を超えました.png

使い方

指定した画像があるか

指定した画像が画面上にある場合True、なければFalseを返します。

UWSC
PRINT CHKIMG("image.bmp")

最初に見つかった画像をクリック

最初に見つかったビットマップ画像をクリックします。

UWSC
IF CHKIMG("image.bmp") THEN BTN(LEFT, CLICK, G_IMG_X, G_IMG_Y)

最後に見つかった画像をクリック

最後に見つかったビットマップ画像をクリックします。

UWSC
DIM n = CHKIMG("image.bmp", -1,,,,, -1)

BTN(LEFT, CLICK, ALL_IMG_X[n-1], ALL_IMG_Y[n-1])

指定画像を色を無視してチェック

指定画像を色を無視して形のみでチェックします。画像が見つかればTrue、見つからなければFalseを返します。

UWSC
PRINT CHKIMG("image.bmp", -1)

指定した画像のヒット数を取得

指定したビットマップ画像のヒット数を取得します。

UWSC
PRINT CHKIMG("image.bmp",,,,,, -1)
結果
プレーンテキスト
4

指定した画像が見つかった座標を取得

指定したビットマップ画像が最初に見つかった座標をx,yの形式で出力します。

UWSC
IF CHKIMG("image.bmp") THEN PRINT G_IMG_X + "," + G_IMG_Y
結果
プレーンテキスト
67,377

指定した画像が見つかったすべての座標を取得

指定したビットマップ画像が見つかったすべての座標を出力します。インデックス番号は0から始まることに注意してください。

UWSC
FOR i = 0 TO CHKIMG("image.bmp", -1,,,,, -1) - 1
	PRINT i + "<#TAB>" + ALL_IMG_X[i] + "," + ALL_IMG_Y[i]
NEXT
結果
プレーンテキスト
0	67,277
1	117,277
2	167,277
3	217,277
4	267,277

見つかったすべての画像をクリック

画面上で見つかったすべてビットマップ画像をクリックします。ESCで処理を終了します。

UWSC
SETHOTKEY(VK_ESC, EMPTYPARAM, "forceQuit")

FOR i = 0 TO CHKIMG("image.bmp", -1,,,,, -1) - 1
	BTN(LEFT, CLICK, ALL_IMG_X[i], ALL_IMG_Y[i])
	SLEEP(0.500)
NEXT

//////////////////////////////////////////////////
// 【引数】
//   
// 【戻り値】
//   
//////////////////////////////////////////////////
PROCEDURE forceQuit()
	EXITEXIT
FEND

ALL_IMG_X,ALL_IMG_Yは指定した画像の左上の座標なので、位置をずらしたい場合はその値を加算します。以下は見つかった画像の左上の座標から右に5px、下に10pxだけずらした位置をクリックします。

UWSC
SETHOTKEY(VK_ESC, EMPTYPARAM, "forceQuit")

FOR i = 0 TO CHKIMG("image.bmp", -1,,,,, -1) - 1
	BTN(LEFT, CLICK, ALL_IMG_X[i] + 5, ALL_IMG_Y[i] + 10)
	SLEEP(0.500)
NEXT

//////////////////////////////////////////////////
// 【引数】
//   
// 【戻り値】
//   
//////////////////////////////////////////////////
PROCEDURE forceQuit()
	EXITEXIT
FEND

指定した画像が表示されるまで待機

指定した画像が画面上に表示されるまで処理を待機します。CHKIMG関数は画像が見つからなければFalse、見つかったときはTrueを返すので、REPEAT文Trueになるまでループし待機します。

UWSC
SETHOTKEY(VK_ESC, EMPTYPARAM, "forceQuit")

REPEAT
	SLEEP(0.001)
UNTIL CHKIMG("image.bmp", -1)

FUKIDASI("画像が見つかりました")
SLEEP(1.000)

//////////////////////////////////////////////////
// 【引数】
//   
// 【戻り値】
//   
//////////////////////////////////////////////////
PROCEDURE forceQuit()
	EXITEXIT
FEND

プログラム実行例

指定した範囲に画像があるかチェック

指定画像が左上の範囲にあればTrue、なければFalseを返します。

UWSC
PRINT CHKIMG("image.bmp", , 0, 0, G_SCREEN_W / 2, G_SCREEN_H / 2)
使用関数

指定した画像の中央を左クリック

UWSC
DIM path = "image.bmp"
DIM arr = getBitmap(path)
CHKIMG(path)

BTN(LEFT, CLICK, G_IMG_X + arr[1] / 2, G_IMG_Y + arr[2] / 2)

//////////////////////////////////////////////////
// 【引数】
//   bin : 2進数 
//   signFlg : 符号付きならばTrue 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION binToDec(bin, signFlg = TRUE)
	DIM dec = 0
	DIM decimalFlg = IIF(POS(".", bin), TRUE, FALSE)
	IFB COPY(bin, 1, 1) = "1" AND signFlg THEN
		// 負数
		// ビット反転用の値
		// 最上位ビット
		DIM msb = IIF(decimalFlg, POS(".", bin) - 1, LENGTH(bin))
		// 最下位ビット
		DIM lsb = IIF(decimalFlg, POS(".", bin) - LENGTH(bin), 0)
		// 整数部
		DIM dec2 = POWER(2, msb) - 1
		// 小数部
		FOR i = -1 TO lsb STEP -1
			dec2 = dec2 + POWER(2, i)
		NEXT
		DIM a = binToDec(bin, FALSE)
		DIM b = dec2
		dec = -1 * (bitXor(a, b) + POWER(2, lsb))
	ELSE
		// 正数(先頭ビットが0、もしくは、signFlgがFalse)
		IFB decimalFlg THEN
			// 小数部分
			DIM integer = COPY(bin, 1, POS(".", bin) - 1)
			DIM decimal = COPY(bin, POS(".", bin) + 1)
			FOR i = 1 TO LENGTH(decimal)
				dec = dec + COPY(decimal, i, 1) * POWER(2, -1 * i)
			NEXT
		ELSE
			integer = bin
		ENDIF
		// 整数部分
		FOR i = 1 TO LENGTH(integer)
			dec = dec + COPY(integer, i, 1) * POWER(2, LENGTH(integer) - i)
		NEXT
	ENDIF
	RESULT = dec
FEND

//////////////////////////////////////////////////
// 【引数】
//   arg1 : 数値1(10進数) 
//   arg2 : 数値2(10進数) 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION bitXor(arg1, arg2)
	DIM args[1] = arg1, arg2
	DIM bins[1]
	DIM decimals[1]
	DIM integers[1]
	DIM keta[1]
	IFB ABS(arg1) <> arg1 OR ABS(arg2) <> arg2 THEN
		RESULT = ERR_VALUE
		EXIT
	ENDIF
	FOR i = 0 TO 1
		bins[i] = decToBin(args[i])
		decimals[i] = 0
		IFB POS(".", bins[i]) <> 0 THEN
			integers[i] = COPY(bins[i], 1, POS(".", bins[i]) - 1)
			decimals[i] = COPY(bins[i], POS(".", bins[i]) + 1)
		ELSE
			integers[i] = bins[i]
		ENDIF
	NEXT
	keta[0] = IIF(LENGTH(integers[0]) > LENGTH(integers[1]), LENGTH(integers[0]), LENGTH(integers[1]))
	integers[0] = strPad(integers[0], keta[0], "0", LEFT)
	integers[1] = strPad(integers[1], keta[0], "0", LEFT)
	keta[1] = IIF(LENGTH(decimals[0]) > LENGTH(decimals[1]), LENGTH(decimals[0]), LENGTH(decimals[1]))
	decimals[0] = strPad(decimals[0], keta[1], "0", RIGHT)
	decimals[1] = strPad(decimals[1], keta[1], "0", RIGHT)
	DIM bin = ""
	FOR i = 1 TO keta[0]
		bin = bin + (VAL(COPY(integers[0], i, 1)) XOR VAL(COPY(integers[1], i, 1)))
	NEXT
	bin = bin + "."
	FOR i = 1 TO keta[1]
		bin = bin + (VAL(COPY(decimals[0], i, 1)) XOR VAL(COPY(decimals[1], i, 1)))
	NEXT
	RESULT = binToDec(bin)
FEND

//////////////////////////////////////////////////
// 【引数】
//   dec : 10進数 
//   signFlg : 符号付きならばTrue 
//   digits : 桁数 
//   recursive : 再帰処理の深さ。処理する際に必要なだけで指定する必要はありません。 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION decToBin(dec, signFlg = FALSE, digits = FALSE, recursive = 1)
	DIM bin = ""
	DIM decimalFlg = IIF(POS(".", dec) <> 0, TRUE, FALSE)
	DIM negativeFlg = IIF(dec < 0, TRUE, FALSE)
	dec = ABS(dec)
	DIM integer = IIF(decimalFlg, COPY(dec, 1, POS(".", dec) - 1), dec)
	DIM offset = POWER(10, LENGTH(dec) - POS(".", dec))
	DIM decimal = IIF(decimalFlg, COPY(dec, POS(".", dec) + 1) / offset, 0)
	REPEAT
		bin = (integer MOD 2) + bin
		integer = INT(integer / 2)
	UNTIL integer = 0
	IFB decimalFlg THEN
		bin = bin + "."
		DIM loop = 0
		REPEAT
			loop = loop + 1
			decimal = decimal * 2
			bin = bin + IIF(decimal >= 1, "1", "0")
			IF decimal > 1 THEN decimal = decimal - 1
		UNTIL decimal = 1 OR loop >= 16
		WHILE loop MOD 4 <> 0
			loop = loop + 1
			bin = bin + "0"
		WEND
	ENDIF
	WHILE LENGTH(REPLACE(bin, ".", "")) MOD 8 <> 0
		bin = "0" + bin
	WEND
	IFB negativeFlg THEN
		DIM msb = IIF(decimalFlg, POS(".", bin) - 1, LENGTH(bin))
		DIM lsb = IIF(decimalFlg , POS(".", bin) - LENGTH(bin), 0)
		DIM a = binToDec(bin)
		DIM b = POWER(2, msb) - 1
		FOR i = -1 TO lsb STEP -1
			b = b + POWER(2, i)
		NEXT
  		dec = bitXor(a, b) + POWER(2, lsb)
 		bin = decToBin(dec, signFlg, digits, recursive + 1)
	ENDIF
	IFB recursive = 1 THEN
		DIM bit = COPY(bin, 1, 1)
 		DIM len = LENGTH(REPLACE(bin, ".", ""))
		IF negativeFlg AND (bit = "0" OR len MOD 2 <> 0) THEN bin = strRepeat("1", IIF(len MOD 2 <> 0, 4, 8)) + bin
		IF !negativeFlg AND (bit = "1" OR len MOD 2 <> 0) THEN bin = strRepeat("0", IIF(len MOD 2 <> 0, 4, 8)) + bin
	ENDIF
	RESULT = bin
FEND

//////////////////////////////////////////////////
// 【引数】
//   dec : 10進数 
//   signFlg : 符号付きならばTrue 
//   recursive : 再帰処理の深さ 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION decToHex(dec, signFlg = FALSE, recursive = 1)
	DIM hex = ""
	DIM array[] = "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"
	DIM decimalFlg = IIF(POS(".", dec) <> 0, TRUE, FALSE)
	DIM negativeFlg = IIF(dec < 0, TRUE, FALSE)
	dec = ABS(dec)
	DIM integer = IIF(decimalFlg, COPY(dec, 1, POS(".", dec) - 1), dec)
	DIM offset = POWER(10, LENGTH(dec) - POS(".", dec))
	DIM decimal = IIF(decimalFlg, COPY(dec, POS(".", dec) + 1) / offset, 0)
	REPEAT
		hex = array[integer MOD 16] + hex
		integer = INT(integer / 16)
	UNTIL integer = 0
	IFB decimalFlg THEN
		hex = hex + "."
		DIM loop = 0
		REPEAT
			loop = loop + 1
			decimal = decimal * 16
			hex = hex + array[decimal]
			offset = POWER(10, LENGTH(decimal) - POS(".", decimal))
			decimal = (decimal * offset - INT(decimal) * offset) / offset
		UNTIL decimal = 0 OR loop >= 4
	ENDIF
	IFB negativeFlg THEN
		DIM bin = hexToBin(hex)
		DIM msb = IIF(decimalFlg, POS(".", bin) - 1, LENGTH(bin))
		DIM lsb = IIF(decimalFlg, POS(".", bin) - LENGTH(bin), 0)
		DIM a = hexToDec(hex)
		DIM b = POWER(2, msb) - 1
		FOR i = -1 TO lsb STEP -1
			b = b + POWER(2, i)
		NEXT
		dec = bitXor(a, b) + POWER(2, lsb)
		hex = decToHex(dec, signFlg, recursive + 1)
	ENDIF
	IFB recursive = 1 THEN
		DIM bit = COPY(hexToBin(COPY(hex, 1, 1)), 1, 1)
		DIM len = LENGTH(REPLACE(hex, ".", ""))
		IF negativeFlg AND (bit = "0" OR len MOD 2 <> 0) THEN hex = strRepeat("F", IIF(len MOD 2 <> 0, 1, 2)) + hex
		IF !negativeFlg AND (bit = "1" OR len MOD 2 <> 0) THEN hex = strRepeat("0", IIF(len MOD 2 <> 0, 1, 2)) + hex
	ENDIF
	RESULT = hex
FEND

//////////////////////////////////////////////////
// 【引数】
//   str : 相互変換させるバイナリデータ 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION Endian(str)
	DIM len = LENGTH(str)
	
	IFB !isEven(len) THEN
		str = "0" + str
		len = len + 1
	ENDIF
	
	DIM res = ""
	FOR n = 1 TO len STEP 2
		res = COPY(str, n, 2)  + res
	NEXT
	
	RESULT = res
FEND

//////////////////////////////////////////////////
// 【引数】
//   path : ビットマップ画像のパス 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION getBitmap(path)
	DIM arr[3]		// 戻り値
	
	DIM Stream = CREATEOLEOBJ("ADODB.Stream")
	Stream.Open()
	Stream.Type = 1		// adTypeBinary
	Stream.LoadFromFile(path)
	DIM tmp = Stream.Read(30)
	Stream.Close()

	// BM(0~1)
	DIM fmt = ""
	FOR n = 0 TO 1
		fmt = fmt + decToHex(tmp[n])
	NEXT

	IFB fmt <> "424D" THEN
		RESULT = ERR_VALUE
		EXIT
	ENDIF
	
	// サイズ(2~5)
	DIM size = ""
	FOR n = 2 TO 5
		hex = decToHex(tmp[n])
		size = size + IIF(LENGTH(hex) = 1, "0", "") + hex
	NEXT
	arr[0] = hexToDec(Endian(size))
	
	// 幅(18~21)
	DIM width = ""
	FOR n = 18 TO 21
		hex = decToHex(tmp[n])
		width = width +IIF(LENGTH(hex) = 1, "0", "") + hex
	NEXT
	arr[1] = hexToDec(Endian(width))
	
	// 高さ(22~25)
	DIM height = ""
	FOR n = 22 TO 25
		hex = decToHex(tmp[n])
		height = height + IIF(LENGTH(hex) = 1, "0", "") + hex
	NEXT
	arr[2] = hexToDec(Endian(height))
	
	// ビットの深さ(28~29)
	DIM bit = ""
	FOR n = 28 TO 29
		hex = decToHex(tmp[n])
		bit = bit + IIF(LENGTH(hex) = 1, "0", "") + hex
	NEXT
	arr[3] = hexToDec(Endian(bit))

	RESULT = SLICE(arr)
FEND

//////////////////////////////////////////////////
// 【引数】
//   hex : 16進数 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION hexToBin(hex)
	HASHTBL hb
	hb["0"] = "0000";	hb["1"] = "0001";	hb["2"] = "0010";	hb["3"] = "0011";
	hb["4"] = "0100";	hb["5"] = "0101";	hb["6"] = "0110";	hb["7"] = "0111";
	hb["8"] = "1000";	hb["9"] = "1001";	hb["A"] = "1010";	hb["B"] = "1011";
	hb["C"] = "1100";	hb["D"] = "1101";	hb["E"] = "1110";	hb["F"] = "1111";
	DIM bin = ""
	IFB POS(".", hex) <> 0 THEN
		FOR i = 1 TO LENGTH(hex)
			DIM str = COPY(hex, i, 1)
			IF str = "." THEN bin = bin + "."
			bin = bin + hb[str]
		NEXT
	ELSE
		FOR i = 1 TO LENGTH(hex)
			bin = bin + hb[COPY(hex, i, 1)]
		NEXT
	ENDIF
	RESULT = bin
FEND

//////////////////////////////////////////////////
// 【引数】
//   hex : 16進数 
//   signFlg : 符号付きならばTrue 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION hexToDec(hex, signFlg = TRUE)
	hex = STRCONV(hex, SC_UPPERCASE)
	DIM dec = 0
	DIM decimalFlg = IIF(POS(".", hex) <> 0, TRUE, FALSE)
	hex = IIF(LENGTH(REPLACE(hex,".", "" )) MOD 2 <> 0, "0", "") + hex
	DIM negativeFlg = IIF(COPY(hexToBin(hex), 1, 1) = "1", TRUE, FALSE)
	DIM sign = 1
	IF negativeFlg AND signFlg THEN sign = -1
	IFB negativeFlg AND signFlg THEN
		DIM bin = hexToBin(hex)
		DIM msb = IIF(decimalFlg, POS(".", bin) - 1, LENGTH(bin))
		DIM lsb = IIF(decimalFlg, POS(".", bin) - LENGTH(bin), 0)
		DIM a = hexToDec(hex, FALSE)
		DIM b = POWER(2, msb) - 1
		FOR i = -1 TO lsb STEP -1
			b = b + POWER(2, i)
		NEXT
		DIM dec2 = bitXor(a, b) + POWER(2, lsb)
		hex = decToHex(dec2)
	ENDIF
	integer = IIF(decimalFlg, COPY(hex, 1, POS(".", hex) - 1), hex)
	decimal = IIF(decimalFlg, COPY(hex, POS(".", hex) + 1), "0")
	FOR i = 1 TO LENGTH(integer)
		s = COPY(hex, i, 1)
		num = IIF(CHKNUM(s), s, ASC(s) - (ASC("A") - 10))
		dec = dec + num * POWER(16, LENGTH(integer) - i)
	NEXT
	FOR i = 1 TO LENGTH(decimal)
		s = COPY(decimal, i, 1)
		num = IIF(CHKNUM(s), s, ASC(s) - (ASC("A") - 10))
		dec = dec + num * POWER(16, -1 * i)
	NEXT
	RESULT = sign * dec
FEND

//////////////////////////////////////////////////
// 【引数】
//   expr : 評価する式 
//   truepart : 評価した式がTrueのときに返す値 
//   falsepart : 評価した式がFalseのときに返す値 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION IIF(expr, truepart, falsepart)
	IFB EVAL(expr) THEN
		RESULT = truepart
	ELSE
		RESULT = falsepart
	ENDIF
FEND

//////////////////////////////////////////////////
// 【引数】
//   数値 : 整数 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION isEven(n)
	IFB VAL(n) = n THEN
		RESULT = IIF(INT(n) MOD 2 = 0, TRUE, FALSE)
	ELSE
		RESULT = ERR_VALUE
	ENDIF
FEND

//////////////////////////////////////////////////
// 【引数】
//   num : 符号を求める数値 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION sign(num)
	SELECT TRUE
		CASE !CHKNUM(num)
			RESULT = ERR_VALUE
		CASE num > 0
			RESULT = 1
		CASE num = 0
			RESULT = 0
		CASE num < 0
			RESULT = -1
	SELEND
FEND

//////////////////////////////////////////////////
// 【引数】
//   input : 入力文字列 
//   length : 埋めたあとの長さ 
//   str : 埋める文字 
//   type : 埋める方向 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION strPad(input, length, str = " ", type = RIGHT)
	DIM s = ""
	SELECT type
		CASE LEFT
			FOR i = 1 TO CEIL((length - LENGTH(input)) / LENGTH(str))
				s = s + str
			NEXT
			input = COPY(s, 1, length - LENGTH(input)) + input
		CASE RIGHT
			FOR i = 1 TO CEIL((length - LENGTH(input)) / LENGTH(str))
				s = s + str
			NEXT
			input = input + COPY(s, 1, length - LENGTH(input))
	SELEND
	RESULT = input
FEND

//////////////////////////////////////////////////
// 【引数】
//   inputs : 繰り返す文字列 
//   multiplier : inputsを繰り返す回数 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION strRepeat(inputs, multiplier)
	DIM res = ""
	FOR n = 1 TO multiplier
		res = res + inputs
	NEXT
	RESULT = res
FEND
使用関数
解説

バックグラウンドでマッチした画像クリックする

UWSC
MOUSEORG(ID, MORG_DIRECT, MORG_BACK)
CHKIMG("image.bmp", -1)
BTN(LEFT, CLICK, G_IMG_X, G_IMG_Y)
解説

関連記事

PEEKCOLOR関数 (スクリプト関数)
PEEKCOLOR関数は、指定座標の色を取得する関数です。
BGRToColor関数 (自作関数)
引数に指定された青成分、緑成分、赤成分、もしくは#BBGGRR形式の文字列からColor値を求めます。
invertedColor関数 (自作関数)
RGBの各成分、Color値、もしくは#RRGGBB形式の文字列から反転色を返します。返り値は引数と同じ形式で返します。
colorToBGR関数 (自作関数)
Color値を青成分、緑成分、赤成分に分解し格納した配列で返します。各成分は10進数の値で表されます。flgTrueを指定した場合、#BBGGRRの形式で返します。
SAVEIMG関数 (スクリプト関数)
SAVEIMGは、第一引数に指定した絶対パス・相対パスに画像を保存する関数です。第一引数を省略した場合クリップボードに、第二引数に0を指定でスクリーン全体をコピーします。
altClick関数 (自作関数)
Web上(IE)の指定したalt属性を含む画像をクリックします。
getBitmap関数 (自作関数)
引数に指定したビットマップ画像のサイズ・幅・高さ・ビットの深さを配列で返します。
ACW関数 (スクリプト関数)
指定したIDのウィンドウの位置・サイズを変更します。IDのみを指定した場合、そのウィンドウをアクティブにします。
MOUSEORG関数 (スクリプト関数)
マウス座標を相対座標にする、 またはマウスとキー情報を直接ウィンドウへ送ります。
IE.Left プロパティ
オブジェクトの左端の座標を取得または設定します。