n角形の図形を三角形の集合にわける方法

[MoNoQLoREATOR]

私は現在、点と面の当たり判定について考えています。
三角形の中に点が含まれているか否かの判定方法は思いつきました。
だから、n角形の図形の中に点が含まれているか否かを判定するには、それを三角形の集合に分けることができれば可能だろうと考えました。
しかし、その方法が考えつきません。

具体的な状況を説明します。
ここに頂点情報(x,y)がn個格納されたvector配列があります。(ベクターでなくても構わないのですが)
格納されている順番に点を繋げて出来上がった図形について考えます。
ただし最後の要素が示す頂点は最初の要素が示す頂点につながります。
また、その図形の各線分同士は交差していないものとします。
このとき、ある点(x,y)がその図形の内部に存在しているかどうかを判定したいのです。

判定することさえできれば、三角形に分ける必要はもちろんございません。

ご教授よろしくお願い致します。

[たいちう]

効率良いプログラムが作れる方法かどうか判りませんが、、、

判定対象となる点から無限遠に半直線を引きます。
この半直線が多角形の辺と何回交差するかで判定できます。
奇数なら多角形の中、偶数なら多角形の外です。

[たいちう]

追記
セジウィック先生の『アルゴリズムC++』にもこの方法で書いてあったので、
この方法で問題ないでしょう。本にはサンプルプログラムが載っています。
キーワードは「多角形による包含」

[MoNoQLoREATOR]

なるほど。確かにその方法ならうまく判定できそうですね。
というわけでさっそく書いてみたのですが、ごく稀にしか内部判定が出ませんでした。
原因は今のところ不明です。
ソースコードはこちらです。

コード:

#include "DxLib.h"
#include <vector>

struct coor{
	int x;
	int y;

	coor(){}
	coor(int x, int y){
		this->x = x;
		this->y = y;
	}
};

struct line{
	double a;
	double b;
	bool useful;

	line(){ useful = false; }
	line & set(const coor & beg, const coor & end){
		if(beg.x == end.x){
			useful = false;
			a = beg.x;
		}
		else{
			useful = true;
			a = (beg.y+end.y) / (beg.x-end.x);
			b = beg.y - a*beg.x;
		}
		return *this;
	}
	line(const coor & beg, const coor & end){ set(beg, end); }
	line & operator() (const coor & beg, const coor & end){ return set(beg, end); }
};

struct cross{
	double x;
	double y;
	bool useful;

	cross(){ useful = false; }
	bool compute(const line & one,const line & another){
		if(one.a == another.a){ return useful = false; }
		x = (another.b-one.b) / (one.a-another.a);
		y = one.a*x + one.b;
		return useful = true;
	}
	cross(const line & one,const line & another){ compute(one, another); }
	bool operator() (const line & one,const line & another){ return compute(one, another); }
};

typedef unsigned int uint;

std::vector<coor> v;
coor dot;

void refresh(){
	uint num = GetRand(10)+5;
	v.resize(0);
	v.reserve(num);
	for(uint i=0;i<num;++i){
		int x = GetRand(640);
		int y = GetRand(480);
		coor c(x, y);
		v.push_back(c);
	}

	dot.x = GetRand(640);
	dot.y = GetRand(480);
}

bool crossing(const line & segment, const coor & beg,const coor & end){
	coor zero(0,0);
	line ray(zero, dot);

	cross c(segment, ray);

	if(c.x > dot.x) return false;
	//対象の点から(0,0)方向への半直線上に交点が無い場合は
	//交点(x,y)のどちらも対象の点のそれよりも大きいから(x,y)のどちらかを比較するだけで良い。
	//今回は、たまたまxを使用した。

	if(c.useful==false) return false;	//usefulがfalseの場合は交点を持たないから。

	int x1 = beg.x;
	int x2 = end.x;
	if(x1 > x2){
		x1 = end.x;
		x2 = beg.x;
	}
	bool flag = c.x>=x1 && c.x<=x2;
	if(flag==false) return false;

	int y1 = beg.y;
	int y2 = end.y;
	if(y1 > y2){
		y1 = end.y;
		y2 = beg.y;
	}
	flag = c.y>=y1 && c.y<=y2;
	if(flag==false) return false;

	return true;
}

bool inside(){
	uint num = 0;

	for(uint i=0;i<v.size();++i){
		uint next = (i+1)%v.size();
		line segment(v[i], v[next]);

		if(crossing(segment, v[i],v[next]) ) ++num;
	}

	return num%2 == 1;
}

char key[256];

int WINAPI WinMain(HINSTANCE hI, HINSTANCE hP, LPSTR lpC, int nC){
	ChangeWindowMode(true);
	SetOutApplicationLogValidFlag(false);
	SetWindowText("InsideTest");
	SetMultiThreadFlag(false);
	if(DxLib_Init() == -1) return(-1);
	SetAlwaysRunFlag(false);
	SetDrawScreen(DX_SCREEN_BACK);
	SetDragFileValidFlag(false);

	refresh();

	while(ProcessMessage() == 0 && CheckHitKey(KEY_INPUT_ESCAPE) == 0){
        ClsDrawScreen();

		GetHitKeyStateAll(key);

		if(key[KEY_INPUT_SPACE] != 0) refresh();
		if(key[KEY_INPUT_UP] != 0) dot.y -= 5;
		if(key[KEY_INPUT_DOWN] != 0) dot.y += 5;
		if(key[KEY_INPUT_LEFT]) dot.x -=5;
		if(key[KEY_INPUT_RIGHT]) dot.x += 5;

		for(uint i=0;i<v.size();++i){
			uint next = (i+1)%v.size();
			DrawLine(v[i].x,v[i].y, v[next].x,v[next].y, 0xffffff, 2);
		}
		DrawCircle(dot.x,dot.y, 3, GetColor(255,0,0), true);

		if(inside() ) DrawString(0,0, "inside!", GetColor(0,0,255) );
		else DrawString(0,0, "outside", GetColor(0,0,255) );

		ScreenFlip();
	}

	DxLib_End();
	return(0);
}

線分同士が交わらないようにランダムに多角形を生成する方法が思いつかなかったのでむちゃくちゃな図形が出現しますが、ちゃんとした結果が出る場所はあると思います。
矢印キーで点を動かすことができます。
スペースキーを押すと再度ランダム生成を行います。

とりあえず途中報告ということで。
何か進展があればまた書き込みます。

[たいちう]

> というわけでさっそく書いてみたのですが、ごく稀にしか内部判定が出ませんでした。
> 原因は今のところ不明です。

ソースはちゃんと読んでいませんが、ランダムだとデバッグしにくくないですか？
まずは単純な図形で判定ができることを確認した方が良いと思いますが。


> //対象の点から(0,0)方向への半直線上に交点が無い場合は

半直線の向きは自由なので、xの無限大の方向（傾き0）とかの方が楽ではないかと。

[MoNoQLoREATOR]

仰る通りです。
というわけでその方針でソースコードを修正しました。
ちゃんと判定されているようです。
今回のプログラムでは三角形のみで判定を行っていますが、おそらくどんな図形でも正確な判定結果が出ると思います。
ソースコードと実行ファイルを載せておきますので、ご自由にお使いください。

コード:

#include "DxLib.h"
#include <vector>

struct coor{
	int x;
	int y;

	coor(){}
	coor(int x, int y){
		this->x = x;
		this->y = y;
	}
};

struct line{
	double a;
	double b;
	bool useful;

	line(){ useful = false; }
	line & set(const coor & beg, const coor & end){
		if(beg.x == end.x){
			useful = false;
			a = 0.0;
			b = beg.x;
		}
		else{
			useful = true;
			a = (double)(beg.y-end.y) / (double)(beg.x-end.x);
			b = beg.y - a*beg.x;
		}
		return *this;
	}
	line(const coor & beg, const coor & end){ set(beg, end); }
	line & operator() (const coor & beg, const coor & end){ return set(beg, end); }
};


typedef unsigned int uint;

std::vector<coor> v;

void refresh(){
	for(uint i=0;i<v.size();++i){
		int x = GetRand(640);
		int y = GetRand(480);
		coor c(x, y);
		v[i]=c;
	}
}

char key[256];

bool crossing(const coor & dot, const line & segment, const coor & beg,const coor & end){
	int y1 = beg.y;
	int y2 = end.y;
	if(y1 > y2){
		y1 = end.y;
		y2 = beg.y;
	}
	bool flag = dot.y>=y1 && dot.y<=y2;
	if(flag==false) return false;

	if(segment.a==0){
		if(beg.x>dot.x && end.x>dot.x) return false;	//この場合2直線は並行。ある点よりもx座標が大きければ交点をもたない。
		else return true;
	}

	double x = (double)(dot.y-segment.b) / (double)segment.a;
	if(x >= dot.x) return true;
	return false;
}

bool inside(const coor & dot){
	uint num = 0;

	for(uint i=0;i<v.size();++i){
		uint next = (i+1)%v.size();
		line segment(v[i], v[next]);

		if(crossing(dot, segment, v[i],v[next]) ) ++num;
	}

	return num%2 == 1;
}

int WINAPI WinMain(HINSTANCE hI, HINSTANCE hP, LPSTR lpC, int nC){
	ChangeWindowMode(true);
	SetOutApplicationLogValidFlag(false);
	SetWindowText("InsideTest");
	SetMultiThreadFlag(false);
	if(DxLib_Init() == -1) return(-1);
	SetAlwaysRunFlag(false);
	SetDrawScreen(DX_SCREEN_BACK);
	SetDragFileValidFlag(false);

	v.resize(3);
	refresh();

	while(ProcessMessage() == 0 && CheckHitKey(KEY_INPUT_ESCAPE) == 0){
        ClsDrawScreen();

		GetHitKeyStateAll(key);

		coor dot;
		GetMousePoint(&dot.x, &dot.y);

		if(key[KEY_INPUT_SPACE] != 0) refresh();
		if(key[KEY_INPUT_UP] != 0) dot.y -= 5;
		if(key[KEY_INPUT_DOWN] != 0) dot.y += 5;
		if(key[KEY_INPUT_LEFT]) dot.x -=5;
		if(key[KEY_INPUT_RIGHT]) dot.x += 5;

		for(uint i=0;i<v.size();++i){
			uint next = (i+1)%v.size();
			DrawLine(v[i].x,v[i].y, v[next].x,v[next].y, 0xffffff, 2);
		}
		DrawCircle(dot.x,dot.y, 3, GetColor(255,0,0), true);

		if(inside(dot) ) DrawString(0,0, "inside!", GetColor(0,0,255) );
		else DrawString(0,0, "outside", GetColor(0,0,255) );

		ScreenFlip();
	}

	DxLib_End();
	return(0);
}

点はマウスポインタの位置になります。
スペースキーを押すと三角形がランダムに再生成されます。
実行ファイルは下記よりダウンロードしてください。


無事解決しました。本当にありがとうございました。

[nullptr]

ミスありです。

ss_035.png (30.93 KiB) 閲覧数: 5636 回

ss_036.png (26.77 KiB) 閲覧数: 5636 回

この２つの画像見ればあらかた検討付きますが一応ご報告まで。

[たいちう]

ランダムでデバッグしにくいことの１つですね。
3角形((1, 0), (-1, 1), (-1, -1))と原点を判定するテストを用意しましょう。
このような一連のテストを作ることができると、この手のバグは激減しますよ。

一朝一夕にはできるようにならないので、
長期間取り組むテーマの1つとして考えて下さい。

[GRAM]

まぁ横槍なんですけれど、次のような凸多角形を使うアルゴリズムもあるにはあります。
（凸多角形とは内角がすべて180°未満で構成された多角形）

①与えられた図形が凸多角形の時
高速で判定できます。
与えられた座標が各辺のどちら側にいるかを判定します。つまり、右回りに辺を巡っていって、すべて右手に与えられた座標があれば多角形の中にいます。
ベクトルの外積を使えば簡単に求まります。

②与えられた図形が凸多角形でない場合。

まず与えられたすべての頂点を含むような凸多角形を求めます。これを図形Aとします。
これは凸包のアルゴリズムを調べればいくらでも出てくると思います。
凸多角形に含まれていない頂点は、図形のへこんでいる部分に相当します。
そこで求めた凸多角形から図形のへこんでいる部分だけを抽出します。これを図形Bとします。


与えられた座標が、多角形内にいるかどうかは次のように判定できます。
１、図形Aの外側にいる→与えられた点は多角形の内側にいない
２、図形Aの内側にいる
→図形Bの外側にいれば、多角形の内側にいる
→図形Bの内側にいれば、多角形の外側にいる

図形Aとの判定は①を使えます。
また図形Bは多角形の集合です。
図形Bの内側に与えられた点がいるかどうかは、②の方法を再帰的に繰り返せば判定できます。

図形の内角の大きさが180°の境界を超えない限り、図形が変形、回転しても凸包の判定をして、
図形の階層構造をつくる工程は1度で済みます。
外積をとる回数自体は、凸多角形でもそうでなくても一定のはずなので、
一旦図形を凸包の形に分解してしまえばもしかしたらそこそこスピードが出るかもしれません。
出ないかもしれません。

3次元の場合はこちらの方が考えるのが楽かも。
（線分と半直線は判定しやすいが、自由な多角形で区切られた平面と半直線の判定はそこまで高速とは言えないから）

[MoNoQLoREATOR]

>>獅子さん
ご報告ありがとうございます。
私も、この判定方法の抜け穴には気づいていました。
半直線が図形の頂点を通るときは正確な判定をすることができないのですよね。
このとき、1回交差したことにすべきか2回、3回、あるいはそれ以上交差(平行に交わった場合に有りうる)したことにすべきかは、状況によって判断する必要があり、それをプログラム上で判断する方法は今のところ思いつきません。
だから、GRAMさんに教えて頂いた方法で正確性を追求しようと思います。


>>GRAMさん
返信ありがとうございます。
凸多角形の内部に点が存在するかどうかを判定する方法については理解しました。
凸包のアルゴリズムについてはこれから調べます。
何か進展があればまた返信いたします。

[GRAM]

このとき、1回交差したことにすべきか2回、3回、あるいはそれ以上交差(平行に交わった場合に有りうる)したことにすべきかは、状況によって判断する必要があり、それをプログラム上で判断する方法は今のところ思いつきません。

そうでしょうか？
n角形に対し、
1定点からn+1本の異なる半直線を引けば必ず妥当な半直線が1本あるはずですが。
（頂点はn個しかないから）

追記：
１８０°境界を超えない限りのくだりは僕の勘違いですね。
よく考えたら、図形が変形したら、もう一度凸包を考える必要がありそうです。
回転に関しては問題ないですね。

[MoNoQLoREATOR]

なるほど。
頂点と交わってしまったときのことを考えるのではなくて、頂点と交わらないような半直線を引くことを考えればよいのですね。
それが最も簡単そうです。
さっそく組んでみることにします。

[MoNoQLoREATOR]

とりあえずソースコードはできました。
しかし、外部判定しか出ません。
原因は今のところ不明です。
進展があればまた返信いたします。

コード:

#define _CRT_SECURE_NO_DEPRECATE
#include "DxLib.h"
#define FW_WIN_MAIN_
#define FW_ALL_POP_UP_
#define FW_TYPEDEF_
#include "../fireworks/fireworks.h"

void refresh(fw::figure & f){
	f.init();
	for(uint i=0;i<3;++i){
		int x = fw::random(640);
		int y = fw::random(480);
		f << fw::coor(x,y);
	}
}

int WINAPI WinMain(HINSTANCE hI, HINSTANCE hP, LPSTR lpC, int nC){
	ChangeWindowMode(true);
	SetOutApplicationLogValidFlag(false);
	SetWindowText("InsideTest");
	SetMultiThreadFlag(false);
	if(DxLib_Init() == -1) return(-1);
	SetAlwaysRunFlag(false);
	SetDrawScreen(DX_SCREEN_BACK);
	SetDragFileValidFlag(false);

	static fw::figure f;
	refresh(f);

	static fw::Mouse dot;

	while(ProcessMessage() == 0 && CheckHitKey(KEY_INPUT_ESCAPE) == 0){
        ClsDrawScreen();

		dot.refresh();

		char key[256];
		GetHitKeyStateAll(key);
		if(key[KEY_INPUT_SPACE] != 0) refresh(f);

		for(uint i=0;i<f.size();++i){
			uint next = (i+1)%f.size();
			DrawLine(f[i].x,f[i].y, f[next].x,f[next].y, 0xffffff, 2);
		}
		DrawCircle(dot.x(),dot.y(), 3, GetColor(255,0,0), true);

		if(dot.in(fw::coor(0,0),f) ) DrawString(0,0, "inside!", GetColor(0,0,255) );
		else DrawString(0,0, "outside", GetColor(0,0,255) );

		ScreenFlip();
	}

	DxLib_End();
	return(0);
}

fw::Mouse.h

コード:

#pragma once

namespace fw{

class Mouse{
	int bx, by;
	int myx, myy;
	bool bleft;
	bool left;
	bool bright;
	bool right;
	int wheel;

	uint crossing(const fw::coor dist, const line & segment, const coor & beg,const coor & end) const {
		fw::line ray(fw::coor(myx,myy), dist);
		fw::cross c(ray, segment);

		if(c.parallel) return 2;	//半直線と図形の一辺（線分）が平行なら問答無用で半直線を変更する
		if(c.intersect==false) return 0;	//交点がなければ0を返す

		fw::real basevecx(dist.x-myx);
		fw::real vecx(c.x-myx);
		if(basevecx*vecx < 0) return 0;	//交点が無限遠の方向になければ交点なし

		fw::real most = fw::distance(beg, end);
		fw::real sub1 = fw::distance(beg, c);
		fw::real sub2 = fw::distance(end, c);
		if(sub1>most || sub2>most) return 0;	//直線として考えたときの交点が線分上になければ交点なし

		if(c==beg || c==end) return 2;	//半直線が頂点を通るようなら半直線を変更する

		return 1;

		/*
		int y1 = beg.y;
		int y2 = end.y;
		if(y1 > y2){
			y1 = end.y;
			y2 = beg.y;
		}
		bool flag = myy>=y1 && myy<=y2;
		if(flag==false) return false;

		if(segment.a==0){
			if(beg.x>myx && end.x>myx) return false;	//この場合2直線は並行。ある点よりもx座標が大きければ交点をもたない。
			else return true;
		}

		double x = (double)(myy-segment.b.num() ) / (double)segment.a;
		if(x >= myx) return true;
		return false;
		//*/
	}
	fw::coor Get2DJoypadAngle(int joygle) const {
		int jg = joygle % 8000;
		if(jg < 0) jg = 8000 - abs(jg);
		if(jg <= 1000) return fw::coor(jg, 1000);
		if(jg <= 3000) return fw::coor(1000, 1000 - (jg-1000) );
		if(jg <= 5000) return fw::coor(1000 - (jg-3000), -1000);
		if(jg <= 7000) return fw::coor(-1000, -1000 + (jg-5000) );
		return fw::coor(-1000 + (jg-7000), 1000);
	}
	bool inside(const fw::vector<coor> & v) const {
		fw::coor dist(0+myx,1000+myy);
		int joygle = 8000 / (v.size()+1);
		fw::coor gap = Get2DJoypadAngle(joygle);
		uint num = 0;

		uint i = 0;
		while(i < v.size() ){
			uint next = (i+1)%v.size();
			line segment(v[i], v[next]);

			uint result = crossing(dist, segment, v[i],v[next]);
			if(result == 2){
				dist += gap;
				i = 0;
				num = 0;
				continue;
			}
			if(result == 1) ++num;

			++i;
		}

		return num%2 == 1;
	}

	bool insidec(const coor & base, int r) const {
		fw::real length = fw::distance(base, coor(myx,myy) );
		return length <= r;
	} 

public:

	Mouse(){
		GetMousePoint(&myx, &myy);
		left = (GetMouseInput() & MOUSE_INPUT_LEFT)!=0;
		right = (GetMouseInput() & MOUSE_INPUT_RIGHT)!=0;
		wheel = 0;
	}

	void refresh(){
		bx = myx;
		by = myy;
		GetMousePoint(&myx, &myy);

		bleft = left;
		left = (GetMouseInput() & MOUSE_INPUT_LEFT)!=0;

		bright = right;
		right = (GetMouseInput() & MOUSE_INPUT_RIGHT)!=0;

		wheel = GetMouseWheelRotVol();
	}

	bool in(const coor & base, const fw::figure & f) const {
		if(f.cflagdata() ) return insidec(base, f.rdata() );

		fw::vector<coor> v;
		v.requre(f.size() );
		for(uint i=0;i<f.size();++i){
			coor c;
			c.x = base.x + f[i].x;
			c.y = base.y + f[i].y;
			v += c;
		}
		return inside(v);
	}

	bool lclick() const { return left==false && bleft; }
	bool lpush() const { return left && bleft==false; }
	bool ldown() const { return left; }
	bool lfree() const { return !left; }

	bool rclick() const { return right==false && bright; }
	bool rpush() const { return right && bright==false; }
	bool rdown() const { return right; }
	bool rfree() const { return !right; }

	bool free() const { return !(left || right); }

	int vx() const { return myx-bx; }
	int vy() const { return myy-by; }

	int x() const { return myx; }
	int y() const { return myy; }

	int step() const { return wheel; }

	void set(int x, int y) const { SetMousePoint(x, y); }

	void show() const {
		int num = ShowCursor(true);
		while(num != 0){
			if(num > 0) num = ShowCursor(false);
			if(num < 0) num = ShowCursor(true);
		}
	}
	void hidden() const {
		int num = ShowCursor(false);
		while(num != -1){
			if(num > -1) num = ShowCursor(false);
			if(num < -1) num = ShowCursor(true);
		}
	}

	void normal() const { SetClassLongPtr(GetMainWindowHandle(), GCL_HCURSOR, (LONG_PTR)(HCURSOR)LoadImage(NULL, MAKEINTRESOURCE(32512), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED) ); }
	void plus() const { SetClassLongPtr(GetMainWindowHandle(), GCL_HCURSOR, (LONG_PTR)(HCURSOR)LoadImage(NULL, MAKEINTRESOURCE(32515), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED) ); }
	void timer() const { SetClassLongPtr(GetMainWindowHandle(), GCL_HCURSOR, (LONG_PTR)(HCURSOR)LoadImage(NULL, MAKEINTRESOURCE(32514), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED) ); }
	void minitimer() const { SetClassLongPtr(GetMainWindowHandle(), GCL_HCURSOR, (LONG_PTR)(HCURSOR)LoadImage(NULL, MAKEINTRESOURCE(32650), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED) ); }
	void help() const { SetClassLongPtr(GetMainWindowHandle(), GCL_HCURSOR, (LONG_PTR)(HCURSOR)LoadImage(NULL, MAKEINTRESOURCE(32651), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED) ); }
	void text() const { SetClassLongPtr(GetMainWindowHandle(), GCL_HCURSOR, (LONG_PTR)(HCURSOR)LoadImage(NULL, MAKEINTRESOURCE(32513), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED) ); }
	void ban() const { SetClassLongPtr(GetMainWindowHandle(), GCL_HCURSOR, (LONG_PTR)(HCURSOR)LoadImage(NULL, MAKEINTRESOURCE(32648), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED) ); }
	void hand() const { SetClassLongPtr(GetMainWindowHandle(), GCL_HCURSOR, (LONG_PTR)(HCURSOR)LoadImage(NULL, MAKEINTRESOURCE(32649), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED) ); }

	~Mouse(){
		normal();
		show();
	}
};

}

ご覧の通り、自作【クラス・構造体・関数】を多用しています。
そうです。めんどくさかったんです。いちいちコピペするのが。
要望があればアップします。
あと解決したら解決コードを載せるルールがあるようですので、そのときは・・・どうしましょう。多分コピペすると思います。

[MoNoQLoREATOR]

今度こそ解決しました。
無事正確な判定結果を得ることができるようになりました。
三角形、四角形、五角形でのみテストを行いましたが、おそらくn角形の図形でも正確な判定結果を得ることができると思います。

解決したソースコードを載せることがここのルールだそうですので、一応載せておきますが、非常に長いコードとなっております。
なぜこれほどまでにも長いコードなのかと申しますと、自作の【クラス・構造体・関数】を多用しているからです。
いつもはインクルード文一行で済むのですがね・・・。
今回最も注目すべきコードは、fwネームスペースの一番下の方で定義されているMouseクラスのin関数です。
もともとマウスと図形の当たり判定を行いたかったのですよ。
ちなみにMouseクラスの定義で、in関数に関係しないメンバは削除しました。Mouseクラスは見やすくなっていると思います。
ですから、in関数を解析して、詳細が知りたい【クラス・構造体・関数】があったら右クリック→「定義へ」をクリック(VisualStudioをお使いの場合の話ですが)するという作業を行えば、判定方法がわかるのではないかと思います。
fw::vectorについてはこのページ(少し情報が古いですが)を、fw::cnctについてはこのページを参照してくださればよくわかると思います。
私に直接質問してくださっても構いませんが、おそらく新しくトピックを立てて、自分なりに考えたコードを載せ、たいちうさんやGRAMさんから個別指導をしていただく方がよくわかるし何より自分の力になると思います＾＾；
ちなみに、ここに載せてあるソースコードのご使用は完全に自由です。
使ってみようという猛者の方はお好きにどうぞ（笑）

長くなりましたが、これがソースコードです↓

► スポイラーを表示

コード:

#include "DxLib.h"
#include <math.h>
#include <vector>




namespace fw{

	typedef unsigned int uint;


	template<typename X>
	class vector;

	template<typename X>
	class vecmemdata{
		const fw::vector<X> & wvec;
		fw::vector<X> & rvec;
		bool rflag;
		uint mybeg;
		uint mynum;

	public:

		vecmemdata(const fw::vector<X> & target, uint num) :wvec(target) {
			mybeg = 0;
			mynum = num;
			rflag = false;
		}
		vecmemdata(const fw::vector<X> & target, uint beg, uint num) :wvec(target) {
			mybeg = beg;
			mynum = num;
			rflag = false;
		}
		vecmemdata(fw::vector<X> & target, uint num) :rvec(target) :rvec(target) {
			mybeg = 0;
			mynum = num;
			rflag = true;
		}
		vecmemdata(fw::vector<X> & target, uint beg, uint num) :rvec(target) {
			mybeg = beg;
			mynum = num;
			rflag = true;
		}

		const fw::vector<X> & cvec() const {
			if(rflag) return rvec;
			return wvec;
		}
		fw::vector<X> & vec() const { return rvec; }

		uint beg() const { return mybeg; }
		uint num() const { return mynum; }

		const void * cbegress() const {
			if(rflag) return &(rvec[beg]);
			return &(wvec[beg]);
		}
		void * begress() const { return &(rvec[beg]); }
	};


	template<typename X>
	class vector{
		X * cont[2];
		bool use;
		uint Size;
		uint sized;
		uint space;
		int Perm;
		std::vector<X> myvec;

		void mysecure(uint size){
				cont[!use] = (X*)malloc(sizeof(X)*size);
				for(uint i=0;i<Size;i++) new(&cont[!use][i]) X(cont[use][i]);
				for(uint i=0;i<sized;i++) cont[use][i].~X();
				free(cont[use]);
				use = !use;

				space = size;
		}

		void myset(){
			myvec.resize(Size);
			for(uint i=0;i<Size;i++) myvec[i] = show(i);
		}

		void myinit(uint size){
			Size = size;
			sized = Size;
			Perm = 0;
			space = size+256;
			use = (bool)0;
			cont[use] = (X*)malloc(sizeof(X)*space);
		}

		X & aconss(uint index) const {
			uint needSize = index+1;

			if(needSize<1 || Size<needSize){
						#ifdef FW_VECTOR_POP_UP_
						MessageBox(NULL, "範囲外アクセスが発生しました", "エラー", MB_OK);
						#endif
						throw std::out_of_range("範囲外アクセスエラー");
			}

			return cont[use][index];
		}

	public:

		void init(uint size=0){
			myinit(size);
			for(uint i=0;i<size;i++) new(&cont[use][i]) X();
		}
		void init(const X* arr, uint size){
			myinit(size);
			for(uint i=0;i<size;i++) new(&cont[use][i]) X(arr[i]);
		}
		void init(const fw::vector<X> & input){
			uint size = input.size();
			myinit(size);
			for(uint i=0;i<size;i++) new(&cont[use][i]) X(input[i]);
		}
		vector(){ init(); }
		vector(uint size){ init(size); }
		vector(const X* arr, uint size){ init(arr, size); }
		vector(const fw::vector<X> & input){ init(input); }

		fw::vector<X> & operator= (const std::vector<X> & sv){
			setsize(sv.size() );
			for(uint i=0;i<sv.size();i++) cont[use][i] = sv[i];
			return *this;
		}
		fw::vector<X> & operator= (const fw::vector<X> & fv){
			setsize(fv.size() );
			for(uint i=0;i<fv.size();i++) cont[use][i] = fv[i];
			return *this;
		}
		fw::vector<X> & operator= (const X & input){
			setsize(1);
			last() = input;
			return *this;
		}

		operator std::vector<X> (){
			myset();
			return myvec;
		}
		operator std::vector<X> & (){
			myset();
			return myvec;
		}
		fw::vector<X> & reflect(){
			this=myvec;
		}

		fw::vector<X> & perm(){
			Perm = -1;
			return *this;
		}
		fw::vector<X> & perm(uint limit){
			Perm = limit;
			return *this;
		}
		fw::vector<X> & lim(){
			Perm = 0;
			return *this;
		}

		fw::vector<X> & secure(uint size){
			if(Size > size) Size = size;
			mysecure(size);
			sized = Size;

			return *this;
		}
		fw::vector<X> & requre(uint size){
			if(size > space) secure(size);
			return *this;
		}
		fw::vector<X> & addcure(uint size){
			requre(Size+size);
			return *this;
		}
		fw::vector<X> & setsize(uint size){
			uint reqsize = size;
			uint needsize = size;
			if(needsize > space){
				needsize = reqsize*2;
				mysecure(needsize);
			}
			if(needsize > Size){
				for(uint i=Size;i<sized;i++) cont[use][i] = X();
				for(uint i=sized;i<reqsize;i++) new(&cont[use][i]) X();
			}
			Size = reqsize;
			if(sized < Size) sized = Size;

			return *this;
		}
		fw::vector<X> & reqsize(uint size){
			if(Size < size) setsize(size);
			return *this;
		}
		fw::vector<X> & addsize(uint size=1){
			setsize(size+Size);
			return *this;
		}
		fw::vector<X> & popsize(uint size=1){
			int ressize = Size - size;
			if(ressize < 0) ressize = 0;
			setsize(ressize);
			return *this;
		}

		fw::vector<X> & pop(uint size=1){
			Size -= size;
			return *this;
		}
		fw::vector<X> & operator-- (){
			Size--;
			return *this;
		}
		fw::vector<X> operator-- (int){
			fw::vector<X> send = *this;
			Size--;
			return send;
		}
		fw::vector<X> & add(){
			addsize();
			return *this;
		}
		fw::vector<X> & add(const X & input){
			next() = input;
			return *this;
		}
		fw::vector<X> & add(const X * arr, uint size){
			requre(Size+size);
			for(uint i=0;i<size;i++) next() = arr[i];
			return *this;
		}
		fw::vector<X> & add(const fw::vector<X> & input){
			requre(input.size()+Size);
			for(uint i=0;i<input.size();i++) next() = input[i];
			return *this;
		}
		fw::vector<X> & operator++ (){
			add();
			return *this;
		}
		fw::vector<X> operator++ (int){
			fw::vector<X> send = *this;
			add();
			return send;
		}
		fw::vector<X> & operator+= (const X & input){
			add(input);
			return *this;
		}
		fw::vector<X> & operator+= (const fw::vector<X> & input){
			add(input);
			return *this;
		}
		fw::vector<X> & operator<< (const X & input){
			add(input);
			return *this;
		}
		fw::vector<X> & operator<< (const fw::vector<X> & input){
			add(input);
			return *this;
		}

		const X & access(uint index) const { return aconss(index); }
		X & access(uint index){
			uint needSize = index+1;

			if(needSize >= 1){
				if( (int)needSize<=Perm || Perm==-1) reqsize(needSize);
			}

			return aconss(index);
		}
		const X & operator[] (uint index) const { return access(index); }
		X & operator[] (uint index){ return access(index); }
		const X & last() const { return access(Size-1); }
		X & last(){ return access(Size-1); }
		X & next(){
			addsize();
			return last();
		}
		X & next(const X & input){
			add(input);
			return last();
		}
		const X * address(uint index) const { return &access(index); }
		X * address(uint index){ return &access(index); }
		fw::vector<X> member(uint index, uint size) const {
			fw::vector<X> r(&access(index), size);
			return r;
		}
		fw::vecmemdata<X> vecmem(uint beg, uint num) const {
			fw::vecmemdata<X> v(*this, beg, num);
			return v;
		}
		fw::vecmemdata<X> vecmem(uint num) const {
			fw::vecmemdata<X> v(*this, num);
			return v;
		}

		uint size() const { return Size; }

		const X * head() const { return address(0); }
		X * head(){ return address(0); }

		fw::vector<X> operator+ (const X & target){
			fw::vector<X> send = *this;
			send.add(target);
			return send;
		}
		fw::vector<X> operator+ (const fw::vector<X> & target){
			fw::vector<X> send = *this;
			send.add(target);
			return send;
		}

		~vector(){
			for(uint i=0;i<sized;i++) cont[use][i].~X();
			free(cont[use]);
		}
	};





	double inline decimal(double num){ return modf(num, (double *)NULL); }

	int inline floor(double num){ return (int)::floor(num); }

	int inline integer(double num){
		double i;
		modf(num, &i);
		return fw::floor(i);
	}

	struct intdec{
		int integer;
		double decimal;

		intdec(){
			integer = int();
			decimal = double();
		}
		intdec & set(double num){
			double i;
			decimal = modf(num, &i);
			integer = fw::floor(i);

			return *this;
		}
		intdec & operator= (double num){ return set(num); }
		intdec & operator() (double num){ return set(num); }
		intdec(double num){ set(num); }
	};

	class real{
		double mydouble;

	public:

		real(){ mydouble = double(); }
		template<typename X>
		real & subs(X num){
			mydouble = (double)num;
			return *this;
		}
		template<typename X>
		real & operator= (X num){ return subs(num); }
		template<typename X>
		real(X num){ subs(num); }

		double num() const { return mydouble; }
		template<typename X>
		operator X () const { return (X)mydouble; }

		bool equal(real num) const {
			fw::intdec my(mydouble);
			fw::intdec req(num.num() );

			if(my.integer != req.integer) return false;
			if(my.decimal != req.decimal) return false;

			return true;
		}
		bool operator== (real num) const { return equal(num); }
		bool inequal(real num) const { return !equal(num); }
		bool operator!= (real num) const { return inequal(num); }

		bool big(real num) const {
			fw::intdec my(mydouble);
			fw::intdec req(num.num() );

			if(my.integer > req.integer) return true;
			if(my.integer == req.integer) if(my.decimal > req.decimal) return true;

			return false;
		}
		bool operator> (real num) const { return big(num); }
		bool smalequal(real num) const { return !big(num); }
		bool operator<= (real num) const { return smalequal(num); }

		bool smal(real num) const {
			fw::intdec my(mydouble);
			fw::intdec req(num.num() );

			if(my.integer < req.integer) return true;
			if(my.integer == req.integer) if(my.decimal < req.decimal) return true;

			return false;
		}
		bool operator< (real num) const { return smal(num); }
		bool bigequal(real num) const { return !smal(num); }
		bool operator>= (real num) const { return bigequal(num); }

		real & operator+= (real num){
			mydouble += num.num();
			return *this;
		}
		real & operator-= (real num){
			mydouble -= num.num();
			return *this;
		}
		real & operator*= (real num){
			mydouble *= num.num();
			return *this;
		}
		real & operator/= (real num){
			mydouble /= num.num();
			return *this;
		}

		real operator+ (real num) const {
			real r = mydouble + num.num();
			return r;
		}
		real operator- (real num) const {
			real r = mydouble - num.num();
			return r;
		}
		real operator* (real num) const {
			real r = mydouble * num.num();
			return r;
		}
		real operator/ (real num) const {
			real r = mydouble / num.num();
			return r;
		}
	};

	fw::real inline pow(fw::real target, int exponent){ return ::pow(target.num(), exponent); }
	int inline pow(int target, int exponent){ return (int)::pow( (double)target, exponent); }

	fw::real inline sqrt(fw::real num){ return ::sqrt(num.num() ); }






	struct coor{
		fw::real x;
		fw::real y;

		coor(){}
		coor & set(fw::real x, fw::real y){
			this->x = x;
			this->y = y;
			return *this;
		}
		coor(fw::real x, fw::real y){ set(x,y); }
		coor & operator() (fw::real x, fw::real y){ return set(x,y); }

		coor & operator+= (const coor & another){
			x += another.x;
			y += another.y;
			return *this;
		}

		bool operator== (const coor & another){
			if(x != another.x) return false;
			if(y != another.y) return false;
			return true;
		}
	};

	struct line{
		fw::real a;
		fw::real b;
		bool useful;

		line(){ useful = false; }
		line & set(const coor & beg, const coor & end){
			if(beg.x == end.x){
				useful = false;
				a = 0.0;
				b = beg.x;
			}
			else{
				useful = true;
				a = (beg.y-end.y) / (beg.x-end.x);
				b = beg.y - a*beg.x;
			}
			return *this;
		}
		line(const coor & beg, const coor & end){ set(beg, end); }
		line & operator() (const coor & beg, const coor & end){ return set(beg, end); }
	};

	struct housen{
		fw::line myline;

		housen(){}
		housen & set(const fw::line & l, const fw::coor & dot){
			myline.useful = true;
			if(l.useful){
				if(l.a==0){
					myline.useful = false;
					myline.a = 0;
					myline.b = dot.x;
				}
				else{
					myline.a = -1.0/(double)l.a;
					myline.b = dot.y - myline.a*dot.x;
				}
			}
			else{
				myline.a = 0;
				myline.b = dot.y;
			}
			return *this;
		}
		housen(const fw::line & l, const fw::coor & dot){ set(l, dot); }
		housen & operator() (const fw::line & l, const fw::coor & dot){ set(l, dot); }

		operator fw::line () const { return myline; }
	};

	struct cross : public coor{
		bool useful;
		bool intersect;
		bool parallel;

		cross(){ useful = false; }
		bool compute(const fw::line & one,const fw::line & another){
			if(one.a==another.a && one.useful==another.useful){
				useful = false;
				intersect = one.b==another.b;
				return parallel = intersect;
			}

			useful = true;
			intersect = true;
			parallel = false;

			if(one.useful==false){
				x = one.b;
				y = another.a*x + another.b;
				return true;
			}
			if(another.useful==false){
				x = another.b;
				y = one.a*x + one.b;
				return true;
			}
			if(one.a == 0){
				y = one.b;
				x = (y-another.b) / another.a;
				return true;
			}
			if(another.a == 0){
				y = another.b;
				x = (y-one.b) / one.a;
				return true;
			}

			x = (another.b-one.b) / (one.a-another.a);
			y = one.a*x + one.b;
			return true;
		}
		cross(const fw::line & one,const fw::line & another){ compute(one, another); }
		bool operator() (const fw::line & one,const fw::line & another){ return compute(one, another); }
	};

	fw::real inline distance(const fw::coor & one, const fw::coor & another){
		fw::real width = one.x-another.x;
		fw::real height = one.y-another.y;
		return sqrt(pow(width,2)+pow(height,2) );
	}





	struct quad{
		fw::coor tops[4];

		quad(){}
		quad & set(coor a, coor b, coor c, coor d){
			tops[0] = a;
			tops[1] = b;
			tops[2] = c;
			tops[3] = d;
			return *this;
		}
		quad(coor a, coor b, coor c, coor d){ set(a,b,c,d); }
		quad & set(const coor & lt, const coor & rb){
			tops[0] = lt;
			tops[1] = coor(lt.x,rb.y);
			tops[2] = rb;
			tops[3] = coor(rb.x,lt.y);
			return *this;
		}
		quad(const coor & lt, const coor & rb){ set(lt, rb); }
	};
	struct triangle{
		coor tops[3];

		triangle(){}
		triangle & set(const coor & f, const coor & s, const coor & t){
			tops[0] = f;
			tops[1] = s;
			tops[2] = t;
			return *this;
		}
		triangle(const coor & f, const coor & s, const coor & t){ set(f,s,t); }
	};
	struct circle{
		coor o;
		int r;

		circle(){}

		circle & set(coor o, int r){
			this->o = o;
			this->r = r;
			return *this;
		}
		circle(coor o, int r){ set(o,r); }

		circle & set(int x,int y, int r){
			this->o = coor(x,y);
			this->r = r;
			return *this;
		}
		circle(int x,int y, int r){ set(x,y, r); }
	};

	class figure{
		fw::vector<coor> tops;
		int r;
		bool cflag;
		int myx1, myy1;
		int myx2, myy2;

		void myset(const fw::vector<coor> & tops){
			this->tops = tops;

			myx1 = (int)tops[0].x;
			myy1 = (int)tops[0].y;
			myx2 = myx1;
			myy2 = myy1;
			for(fw::uint i=1;i<tops.size();i++){
				int x = (int)tops[i].x;
				if(x < myx1) myx1 = x;
				if(x > myx2) myx2 = x;

				int y = (int)tops[i].y;
				if(y < myy1) myy1 = y;
				if(y > myy2) myy2 = y;
			}
		}
		void mysetc(const circle & c){
			cflag = true;
			tops.setsize(1);
			tops.last() = c.o;
			r = c.r;

			myx1 = c.o.x - c.r;
			myy1 = c.o.y - c.r;
			myx2 = c.o.x + c.r;
			myy2 = c.o.y + c.r;
		}

	public:

		figure & init(){
			tops.setsize(0);
			r = 0;
			cflag = false;

			myx1 = 0;
			myy1 = 0;
			myx2 = 0;
			myy2 = 0;

			return *this;
		}

		const fw::vector<coor> & topsdata() const { return tops; }
		int rdata() const { return r; }
		bool cflagdata() const { return cflag; }

		figure & operator= (const figure & f){
			tops = f.topsdata();
			r = f.rdata();
			cflag = f.cflagdata();
			myx1 = f.x1();
			myy1 = f.y1();
			myx2 = f.x2();
			myy2 = f.y2();
			return *this;
		}
		figure & operator= (const quad & q){
			myset(fw::vector<coor>(&(q.tops[0]), 4) );
			return *this;
		}
		figure & operator= (const triangle & t){
			myset(fw::vector<coor>(&(t.tops[0]), 3) );
			return *this;
		}
		figure & operator= (const circle & c){
			mysetc(c);
			return *this;
		}

		figure(){ init(); }
		figure(const figure & f){ *this = f; }
		figure(const quad & q){ *this = q; }
		figure(const triangle & t){ *this = t; }
		figure(const circle & c){ *this = c; }

		figure & operator+= (const coor & top){
			tops += top;
			int x = (int)top.x;
			if(x < myx1) myx1 = x;
			if(x > myx2) myx2 = x;

			int y = (int)top.y;
			if(y < myy1) myy1 = y;
			if(y > myy2) myy2 = y;

			return *this;
		}
		figure & operator<< (const coor & top){ return *this += top; }

		int x1() const { return myx1; }
		int y1() const { return myy1; }
		int x2() const { return myx2; }
		int y2() const { return myy2; }

		const coor & operator[] (fw::uint index) const {
			return tops[index];
		}

		fw::uint size() const { return tops.size(); }

		void draw(const coor & base, int color, int thick = 1) const {
			for(uint i=0;i<size();++i){
				uint next = (i+1) % size();
				DrawLine(base.x+tops[i].x,base.y+tops[i].y, base.x+tops[next].x,base.y+tops[next].y, color, thick);
			}
		}
	};






	class Mouse{
		int myx, myy;

		uint crossing(const fw::coor dist, const line & segment, const coor & beg,const coor & end) const {
			fw::line ray(fw::coor(myx,myy), dist);

			fw::cross c(ray, segment);

			if(c.intersect==false) return 0;	//交点がなければ0を返す

			if(c.parallel){
				//半直線と図形の一辺（線分）が平行のとき。それが半直線上にあるなら問答無用で半直線を変更する。そうでなければ交点なし

				fw::real basevecx = dist.x-myx;
				fw::real vecx1 = beg.x-myx;
				fw::real vecx2 = end.x-myx;
				if(basevecx*vecx1 < 0 && basevecx*vecx2 < 0) return 2;

				fw::real basevecy = dist.y-myy;
				fw::real vecy1 = beg.y-myy;
				fw::real vecy2 = end.y-myy;
				if(basevecy*vecy1 < 0 && basevecy*vecy2 < 0) return 2;

				return 0;
			}

			fw::real basevecx(dist.x-myx);
			fw::real vecx(c.x-myx);
			if(basevecx*vecx < 0) return 0;	//交点のx成分が無限遠の方向になければ交点なし
			fw::real basevecy(dist.y-myy);
			fw::real vecy(c.y-myy);
			if(basevecy*vecy < 0) return 0;	//交点のy成分が無限遠の方向になければ交点なし

			fw::real most = fw::distance(beg, end);
			fw::real sub1 = fw::distance(beg, c);
			fw::real sub2 = fw::distance(end, c);
			if(sub1>most || sub2>most) return 0;	//直線として考えたときの交点が線分上になければ交点なし

			if(c==beg || c==end) return 2;	//半直線が頂点を通るようなら半直線を変更する

			return 1;
		}
		fw::coor Get2DJoypadAngle(int joygle) const {
			int jg = joygle % 8000;
			if(jg < 0) jg = 8000 - abs(jg);
			if(jg <= 1000) return fw::coor(jg, 1000);
			if(jg <= 3000) return fw::coor(1000, 1000 - (jg-1000) );
			if(jg <= 5000) return fw::coor(1000 - (jg-3000), -1000);
			if(jg <= 7000) return fw::coor(-1000, -1000 + (jg-5000) );
			return fw::coor(-1000 + (jg-7000), 1000);
		}
		bool inside(const fw::vector<coor> & v) const {
			fw::coor dist(0+myx,1000+myy);
			int joygle = 8000 / (v.size()+1);
			int gap = 0;
			uint num = 0;

			for(uint i = 0;i < v.size();){
				uint next = (i+1)%v.size();
				line segment(v[i], v[next]);

				uint result = crossing(dist, segment, v[i],v[next]);
				if(result == 2){
					gap += joygle;
					dist = Get2DJoypadAngle(gap);
					dist.x += myx;
					dist.y += myy;
					i = 0;
					num = 0;
					continue;
				}
				if(result == 1) ++num;

				++i;
			}

			return num%2 == 1;
		}

		bool insidec(const coor & base, int r) const {
			fw::real length = fw::distance(base, coor(myx,myy) );
			return length <= r;
		} 

	public:

		Mouse(){
			GetMousePoint(&myx, &myy);
		}

		void refresh(){
			GetMousePoint(&myx, &myy);
		}

		bool in(const coor & base, const fw::figure & f) const {
			if(f.cflagdata() ) return insidec(base, f.rdata() );

			fw::vector<coor> v;
			v.requre(f.size() );
			for(uint i=0;i<f.size();++i){
				coor c;
				c.x = base.x + f[i].x;
				c.y = base.y + f[i].y;
				v += c;
			}
			return inside(v);
		}


		int x() const { return myx; }
		int y() const { return myy; }
	};

}




int WINAPI WinMain(HINSTANCE hI, HINSTANCE hP, LPSTR lpC, int nC){
	ChangeWindowMode(true);
	SetOutApplicationLogValidFlag(false);
	SetWindowText("InsideProject");
	SetMultiThreadFlag(false);
	if(DxLib_Init() == -1) return(-1);
	SetAlwaysRunFlag(false);
	SetDrawScreen(DX_SCREEN_BACK);
	SetDragFileValidFlag(false);


	while(ProcessMessage() == 0 && CheckHitKey(KEY_INPUT_ESCAPE) == 0){
        ClsDrawScreen();


		ScreenFlip();
	}

	DxLib_End();
	return(0);
}

ついでに、テストに使用した実行ファイルを下の方にアップしておきました。
マウスの座標が判定すべき点(赤色で表示される)になります。
最初は五角形が表示されていますが、スペースキーを押すと三角形がランダムに生成されます。


最後に、
たいちうさん、GRAMさん、獅子さん
本当にありがとうございました。